Class: Lutaml::Model::Schema::JsonSchemaParser

Inherits:
Object
  • Object
show all
Defined in:
lib/lutaml/model/schema/json_schema_parser.rb

Class Method Summary collapse

Class Method Details

.generate(schema_json) ⇒ Object 



83
84
85
86
87
 
# File 'lib/lutaml/model/schema/json_schema_parser.rb', line 83

def self.generate(schema_json)
  @nested_classes = []
  main_classes = parse(schema_json)
  (nested_classes + [main_classes]).join("\n")
end

.generate_attributes(attributes, required_attributes) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/lutaml/model/schema/json_schema_parser.rb', line 30

def self.generate_attributes(attributes, required_attributes)
  attributes.map do |name, schema|
    type = schema["type"]
    ruby_type = get_ruby_type(type, schema)
    attributes = [
      "attribute :#{name}",
      "Lutaml::Model::Type::#{ruby_type}",
      "required: #{required_attributes.include?(name).inspect}",
    ]

    attributes.join(", ")
  end.join("\n  ")
end

.generate_class_definition(class_name, class_schema) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/lutaml/model/schema/json_schema_parser.rb', line 15

def self.generate_class_definition(class_name, class_schema)
  attributes = class_schema["properties"] || {}
  required_attributes = class_schema["required"] || []

  <<~RUBY
    class #{class_name} < Lutaml::Model::Serializable
      #{generate_attributes(attributes, required_attributes)}

      json do
        #{generate_json_mappings(attributes)}
      end
    end
  RUBY
end

.generate_json_mappings(attributes) ⇒ Object 



44
45
46
47
48
 
# File 'lib/lutaml/model/schema/json_schema_parser.rb', line 44

def self.generate_json_mappings(attributes)
  attributes.keys.map do |name|
    "map '#{name}', to: :#{name}"
  end.join("\n    ")
end

.get_ruby_type(type, schema) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/lutaml/model/schema/json_schema_parser.rb', line 50

def self.get_ruby_type(type, schema)
  case type
  when "integer"
    "Integer"
  when "boolean"
    "Boolean"
  when "number"
    "Float"
  when "array"
    item_schema = schema["items"]
    item_type = get_ruby_type(item_schema["type"], item_schema)
    "Array.of(#{item_type})"
  when "object"
    object_class_name(schema)
  else
    "String" # Default to string for unknown types
  end
end

.nested_classes ⇒ Object 



79
80
81
 
# File 'lib/lutaml/model/schema/json_schema_parser.rb', line 79

def self.nested_classes
  @nested_classes ||= []
end

.object_class_name(schema) ⇒ Object 



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

def self.object_class_name(schema)
  nested_class_name = schema["title"] || "NestedObject"
  nested_class_definition = generate_class_definition(
    nested_class_name, schema
  )
  @nested_classes ||= []
  @nested_classes << nested_class_definition
  nested_class_name
end

.parse(schema_json) ⇒ Object 



7
8
9
10
11
12
13
 
# File 'lib/lutaml/model/schema/json_schema_parser.rb', line 7

def self.parse(schema_json)
  schema = JSON::Schema.parse(schema_json)
  definitions = schema.schema.fetch("$defs", {})
  definitions.map do |class_name, class_schema|
    generate_class_definition(class_name, class_schema)
  end.join("\n")
end