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.



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

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.



46
47
48
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 46

def definitions
  @definitions
end

Class Method Details

.from_class(klass) ⇒ Object 



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

def from_class(klass)
  new.tap do |collection|
    collection << Definition.new(klass)

    process_attributes(collection, klass)
  end
end

.process_attribute(collection, attribute, register) ⇒ Object 



28
29
30
31
32
33
34
35
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 28

def process_attribute(collection, attribute, register)
  attr_type = Lutaml::Model::GlobalContext.resolve_type(
    attribute.type, register
  )
  collection.merge(DefinitionsCollection.from_class(attr_type))

  process_polymorphic_types(collection, attribute)
end

.process_attributes(collection, klass) ⇒ Object 



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

def process_attributes(collection, klass)
  register = extract_register_from(klass)
  klass.attributes.each_value do |attribute|
    next unless attribute.serializable?(register)

    process_attribute(collection, attribute, register)
  end
end

.process_polymorphic_types(collection, attribute) ⇒ Object 



37
38
39
40
41
42
43
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 37

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

  attribute.options[:polymorphic].each do |child|
    collection.merge(DefinitionsCollection.from_class(child))
  end
end

Instance Method Details

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



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

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

#merge(collection) ⇒ Object 



69
70
71
72
73
74
75
76
77
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 69

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

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

#to_schema ⇒ Object 



56
57
58
59
60
 
# File 'lib/lutaml/model/schema/generator/definitions_collection.rb', line 56

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