Class: Jsapi::Meta::Schema::Object

Inherits:
Base show all
Defined in:
lib/jsapi/meta/schema/object.rb

Constant Summary

Constants included from Model::Attributes

Model::Attributes::DEFAULT_ARRAY, Model::Attributes::DEFAULT_HASH

Instance Attribute Summary

Attributes inherited from Base

#validations

Instance Method Summary collapse

Methods inherited from Base

#default, #default_value, #deprecated, #description, #enum, #enum=, #examples, #existence, #external_docs, #initialize, #nullable?, #omittable?, #title, #type

Methods included from OpenAPI::Extensions

included

Methods inherited from Model::Base

#initialize, #inspect, #merge!, #reference?, #resolve

Methods included from Model::Attributes

#attribute, #attribute_names

Constructor Details

This class inherits a constructor from Jsapi::Meta::Schema::Base

Instance Method Details

#add_property(name, keywords = {}) ⇒ Object

:nodoc:



35
36
37
 
# File 'lib/jsapi/meta/schema/object.rb', line 35

def add_property(name, keywords = {}) # :nodoc:
  (@properties ||= {})[name.to_s] = Property.new(name, **keywords)
end

#additional_properties ⇒ Object

:attr: additional_properties The AdditionalProperties.



10
 
# File 'lib/jsapi/meta/schema/object.rb', line 10

attribute :additional_properties, AdditionalProperties

#all_of_references ⇒ Object

:attr: all_of_references



14
 
# File 'lib/jsapi/meta/schema/object.rb', line 14

attribute :all_of_references, [Reference]

#discriminator ⇒ Object

:attr: discriminator The Discriminator.



22
 
# File 'lib/jsapi/meta/schema/object.rb', line 22

attribute :discriminator, Discriminator

#model ⇒ Object

:attr: model The model class to access nested object parameters by. The default model class is Jsapi::Model::Base.



28
 
# File 'lib/jsapi/meta/schema/object.rb', line 28

attribute :model, Class, default: Jsapi::Model::Base

#properties ⇒ Object

:attr: properties The properties.



33
 
# File 'lib/jsapi/meta/schema/object.rb', line 33

attribute :properties, { String => Property }, accessors: i[reader writer]

#resolve_properties(definitions, context: nil) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/jsapi/meta/schema/object.rb', line 39

def resolve_properties(definitions, context: nil)
  properties = merge_properties(definitions, [])

  case context
  when :response
    properties.reject { |_k, v| v.write_only? }
  when :request
    properties.reject { |_k, v| v.read_only? }
  else
    properties
  end
end

#resolve_schema(object, definitions, context: nil) ⇒ Object

Resolves the schema within context.

Raises a RuntimeError when the schema couldn’t be resolved.



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/jsapi/meta/schema/object.rb', line 55

def resolve_schema(object, definitions, context: nil)
  return self if discriminator.nil?

  properties = resolve_properties(definitions, context: context)

  discriminating_property = properties[discriminator.property_name]
  if discriminating_property.nil?
    raise InvalidValueError.new('discriminator property',
                                discriminator.property_name,
                                valid_values: properties.keys)
  end

  discriminating_value = discriminating_property.reader.call(object)
  if discriminating_value.nil?
    discriminating_value = discriminating_property.default_value(
      definitions,
      context: context
    )
    if discriminating_value.nil? && discriminator.default_mapping.nil?
      raise "discriminating value can't be nil"
    end
  end

  schema_name = discriminator.mapping(discriminating_value) || discriminating_value

  schema = definitions.find_schema(schema_name)
  if schema.nil?
    default_mapping = discriminator.default_mapping
    schema = definitions.find_schema(default_mapping) unless default_mapping.nil?

    if schema.nil?
      raise "inheriting schema couldn't be found: " \
            "#{[schema_name, default_mapping].compact.map(&:inspect).join(' or ')}"
    end
  end

  schema.resolve(definitions).resolve_schema(object, definitions, context: context)
end

#to_json_schema ⇒ Object

:nodoc:



94
95
96
97
98
99
100
101
 
# File 'lib/jsapi/meta/schema/object.rb', line 94

def to_json_schema # :nodoc:
  super.merge(
    allOf: all_of_references.map(&:to_json_schema).presence,
    properties: properties.transform_values(&:to_json_schema),
    additionalProperties: additional_properties&.to_json_schema,
    required: properties.values.select(&:required?).map(&:name)
  ).compact
end

#to_openapi(version) ⇒ Object

:nodoc:



103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/jsapi/meta/schema/object.rb', line 103

def to_openapi(version, *) # :nodoc:
  super.merge(
    allOf: all_of_references.map do |schema|
      schema.to_openapi(version)
    end.presence,
    discriminator: discriminator&.to_openapi(version),
    properties: properties.transform_values do |property|
      property.to_openapi(version)
    end,
    additionalProperties: additional_properties&.to_openapi(version),
    required: properties.values.select(&:required?).map(&:name)
  ).compact
end