Class: Lutaml::Model::Schema::Generator::DefinitionsCollection

Inherits:
Object
  • Object
show all
Extended by:
SharedMethods
Defined in:
lib/lutaml/model/schema/generator/definitions_collection.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from SharedMethods

extract_register_from

Constructor Details

#initialize(definitions = []) ⇒ DefinitionsCollection

Returns a new instance of DefinitionsCollection.



73
74
75
76
77
78
79
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 73

def initialize(definitions = [])
  @definitions = definitions.map do |definition|
    next definition if definition.is_a?(Definition)

    Definition.new(definition)
  end
end

Instance Attribute Details

#definitions ⇒ Object (readonly)

Returns the value of attribute definitions.



71
72
73
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 71

def definitions
  @definitions
end

Class Method Details

.from_class(klass) ⇒ Object 



11
12
13
14
15
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 11

def from_class(klass)
  collection = new
  register_definition(collection, klass)
  collection
end

.process_attribute(collection, attribute, register, seen = {}) ⇒ Object 



40
41
42
43
44
45
46
47
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 40

def process_attribute(collection, attribute, register, seen = {})
  attr_type = Lutaml::Model::GlobalContext.resolve_type(
    attribute.type, register
  )
  register_definition(collection, attr_type, seen)

  process_polymorphic_types(collection, attribute, seen)
end

.process_attributes(collection, klass, seen = {}) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 17

def process_attributes(collection, klass, seen = {})
  register = extract_register_from(klass)
  klass.attributes.each_value do |attribute|
    if attribute.union?
      process_union_members(collection, attribute, seen)
    elsif attribute.serializable?(register)
      process_attribute(collection, attribute, register, seen)
    end
  end
end

.process_polymorphic_types(collection, attribute, seen = {}) ⇒ Object 



49
50
51
52
53
54
55
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 49

def process_polymorphic_types(collection, attribute, seen = {})
  return unless attribute.options&.[](:polymorphic)

  attribute.options[:polymorphic].each do |child|
    register_definition(collection, child, seen)
  end
end

.process_union_members(collection, attribute, seen = {}) ⇒ Object

A union attribute's type is Type::Union, not a model, so collect definitions for each of its Serializable members directly (a union schema emits a $ref per model member).



31
32
33
34
35
36
37
38
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 31

def process_union_members(collection, attribute, seen = {})
  attribute.union_member_types.each do |member|
    next unless member.is_a?(::Class) &&
      member.include?(Lutaml::Model::Serialize)

    register_definition(collection, member, seen)
  end
end

.register_definition(collection, klass, seen = {}) ⇒ Object

Recursive models (Node#child → Node, or longer include cycles) are valid; the seen-set registers each class once and lets property references point at the shared $defs entry instead of recursing (#863).



61
62
63
64
65
66
67
68
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 61

def register_definition(collection, klass, seen = {})
  return collection if seen[klass]

  seen[klass] = true
  collection << Definition.new(klass)
  process_attributes(collection, klass, seen)
  collection
end

Instance Method Details

#add_definition(definition) ⇒ Object Also known as: <<, push 



87
88
89
90
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 87

def add_definition(definition)
  @definitions ||= []
  @definitions << definition
end

#merge(collection) ⇒ Object 



94
95
96
97
98
99
100
101
102
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 94

def merge(collection)
  @definitions ||= []

  if collection.is_a?(Array)
    @definitions.concat(collection)
  else
    @definitions.concat(collection.definitions)
  end
end

#to_schema ⇒ Object 



81
82
83
84
85
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 81

def to_schema
  definitions.each_with_object({}) do |definition, schema|
    schema.merge!(definition.to_schema)
  end
end