lutaml-model 0.7.1 → 0.7.7

data/lib/lutaml/model/schema/generator/definitions_collection.rb

@@ -0,0 +1,81 @@
+require_relative "definition"
+require_relative "../shared_methods"
+
+module Lutaml
+  module Model
+    module Schema
+      module Generator
+        class DefinitionsCollection
+          class << self
+            include SharedMethods
+
+            def from_class(klass)
+              new.tap do |collection|
+                collection << Definition.new(klass)
+
+                process_attributes(collection, klass)
+              end
+            end
+
+            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
+
+            def process_attribute(collection, attribute, register)
+              attr_type = Lutaml::Model::GlobalRegister.lookup(register).get_class(attribute.type)
+              collection.merge(DefinitionsCollection.from_class(attr_type))
+
+              process_polymorphic_types(collection, attribute)
+            end
+
+            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
+          end
+
+          attr_reader :definitions
+
+          def initialize(definitions = [])
+            @definitions = definitions.map do |definition|
+              next definition if definition.is_a?(Definition)
+
+              Definition.new(definition)
+            end
+          end
+
+          def to_schema
+            definitions.each_with_object({}) do |definition, schema|
+              schema.merge!(definition.to_schema)
+            end
+          end
+
+          def add_definition(definition)
+            @definitions ||= []
+            @definitions << definition
+          end
+          alias << add_definition
+          alias push add_definition
+
+          def merge(collection)
+            @definitions ||= []
+
+            if collection.is_a?(Array)
+              @definitions.concat(collection)
+            else
+              @definitions.concat(collection.definitions)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/generator/properties_collection.rb

@@ -0,0 +1,63 @@
+require_relative "property"
+require_relative "../shared_methods"
+
+module Lutaml
+  module Model
+    module Schema
+      module Generator
+        class PropertiesCollection
+          class << self
+            include SharedMethods
+
+            def from_class(klass)
+              from_attributes(klass.attributes.values, extract_register_from(klass))
+            end
+
+            def from_attributes(attributes, register)
+              new(register: register).tap do |collection|
+                attributes.each do |attribute|
+                  name = attribute.name
+                  collection << Property.new(name, attribute, register: register)
+                end
+              end
+            end
+          end
+
+          attr_reader :properties, :register
+
+          def initialize(properties = [], register:)
+            self.properties = properties
+            @register = register
+          end
+
+          def to_schema
+            properties.each_with_object({}) do |property, schema|
+              schema.merge!(property.to_schema)
+            end
+          end
+
+          def add_property(property)
+            @properties << if property.is_a?(Property)
+                             property
+                           else
+                             Property.new(property.name, property, register: register)
+                           end
+          end
+          alias << add_property
+          alias push add_property
+
+          def properties=(properties)
+            @properties ||= []
+            @properties.clear
+
+            @properties = properties.map do |property|
+              next property if property.is_a?(Property)
+
+              Property.new(property.name, property, register)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/generator/property.rb

@@ -0,0 +1,110 @@
+module Lutaml
+  module Model
+    module Schema
+      module Generator
+        # This class is used to generate a property schema definition.
+        # It is used in the context of generating JSON schemas.
+        class Property
+          attr_reader :name, :attribute, :register
+
+          def initialize(name, attribute, register:)
+            @name = name.to_s.gsub("::", "_")
+            @attribute = attribute
+            @register = register
+          end
+
+          def to_schema
+            { name => generate_attribute_schema(attribute) }
+          end
+
+          private
+
+          def generate_attribute_schema(attr, options = {})
+            include_null = options.fetch(:include_null, true)
+            inside_collection = options.fetch(:inside_collection, false)
+            if attr.collection? && !inside_collection
+              collection_schema(attr)
+            elsif attr.serializable?(register) && polymorphic?(attr)
+              polymorphic_schema(attr)
+            elsif attr.serializable?(register)
+              Generator::Ref.new(attr.type(register)).to_schema
+            else
+              primitive_schema(attr, include_null: include_null)
+            end
+          end
+
+          def collection_schema(attr)
+            schema = {
+              "type" => "array",
+              "items" => generate_attribute_schema(
+                attr,
+                include_null: false,
+                inside_collection: true,
+              ),
+            }
+
+            if attr.options[:collection].is_a?(Range)
+              add_collection_constraints!(schema, attr.options[:collection])
+            end
+
+            schema
+          end
+
+          def add_collection_constraints!(schema, range)
+            schema["minItems"] = range.begin
+            schema["maxItems"] = range.end if range.end
+          end
+
+          def polymorphic_schema(attr)
+            ref_schemas = attr.options[:polymorphic].map do |type|
+              Ref.new(type).to_schema
+            end
+
+            ref_schemas << Ref.new(attr.type).to_schema if attr.type
+
+            {
+              "type" => ["object", "null"],
+              "oneOf" => ref_schemas,
+            }
+          end
+
+          def primitive_schema(attr, include_null: true)
+            type = get_type(attr.type(register))
+            type = [type, "null"] if include_null
+
+            { "type" => type }.merge(get_constraints(attr))
+          end
+
+          def get_constraints(attr)
+            constraints = {}
+
+            # Add pattern validation
+            constraints["pattern"] = attr.pattern.source if attr.pattern
+
+            # Add default value
+            constraints["default"] = attr.default(register) if attr.default_set?(register)
+
+            # Add enumeration values
+            constraints["enum"] = attr.enum_values if attr.enum?
+
+            constraints
+          end
+
+          def polymorphic?(attr)
+            Utils.present?(attr.options[:polymorphic])
+          end
+
+          def get_type(type)
+            {
+              Lutaml::Model::Type::String => "string",
+              Lutaml::Model::Type::Integer => "integer",
+              Lutaml::Model::Type::Boolean => "boolean",
+              Lutaml::Model::Type::Float => "number",
+              Lutaml::Model::Type::Hash => "object",
+            }[type] || "string" # Default to string for unknown types
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/generator/ref.rb

@@ -0,0 +1,24 @@
+module Lutaml
+  module Model
+    module Schema
+      module Generator
+        # This class is used to generate a reference to a schema definition.
+        # It is used in the context of generating JSON schemas.
+        class Ref
+          attr_reader :name
+
+          def initialize(type)
+            @type = type
+            @name = @type.name.gsub("::", "_")
+          end
+
+          def to_schema
+            {
+              "$ref" => "#/$defs/#{name}",
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/helpers/template_helper.rb

@@ -0,0 +1,49 @@
+module Lutaml
+  module Model
+    module Schema
+      module Helpers
+        module TemplateHelper
+          def open_namespaces(namespaces)
+            namespaces.map { |ns| "module #{ns}" }.join("\n")
+          end
+
+          def close_namespaces(namespaces)
+            namespaces.reverse.map { "end" }.join("\n")
+          end
+
+          def indent(level)
+            "  " * level
+          end
+
+          def attribute_line(attribute, level)
+            if attribute.choice?
+              <<~RUBY.chomp
+
+                #{indent(level)}choice do
+                #{attribute.attributes.map { |attr| attribute_line(attr, level + 1) }.join("\n")}
+                #{indent(level)}end
+              RUBY
+            else
+              "#{indent(level)}attribute #{attribute_properties(attribute)}"
+            end
+          end
+
+          def attribute_properties(attribute)
+            # properties = {}
+            # properties[:default] = attribute.default if attribute.default
+            # properties[:collection] = true if attribute.collection?
+
+            required_properties = ":#{attribute.name}, #{attribute.type}"
+            required_properties += ", default: #{attribute.default.inspect}" if attribute.default
+            required_properties += ", collection: #{attribute.collection}" if attribute.collection?
+            required_properties += ", values: #{attribute.options['enum']}" if attribute.options["enum"]
+            required_properties += ", pattern: /#{attribute.options['pattern']}/" if attribute.options["pattern"]
+            required_properties += ", polymorphic: [#{attribute.polymorphic_classes.join(', ')}]" if attribute.polymorphic?
+
+            required_properties
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/json_schema.rb

@@ -1,66 +1,59 @@
+require_relative "shared_methods"
+require_relative "base_schema"
+require_relative "renderer"
+require_relative "decorators/class_definition"
+require_relative "decorators/definition_collection"
+
 require "json"
 
 module Lutaml
   module Model
     module Schema
-      class JsonSchema
-        def self.generate(klass, options = {})
-          schema = {
-            "$schema" => "https://json-schema.org/draft/2020-12/schema",
-            "$id" => options[:id],
-            "description" => options[:description],
-            "$ref" => "#/$defs/#{klass.name}",
-            "$defs" => generate_definitions(klass),
-          }.compact
+      class JsonSchema < BaseSchema
+        class << self
+          include Lutaml::Model::Schema::SharedMethods
 
-          options[:pretty] ? JSON.pretty_generate(schema) : schema.to_json
-        end
+          def generate(
+            klass,
+            id: nil,
+            title: nil,
+            description: nil,
+            pretty: false
+          )
+            options = {
+              schema: "https://json-schema.org/draft/2020-12/schema",
+              id: id,
+              title: title,
+              description: description,
+              pretty: pretty,
+            }
 
-        def self.generate_definitions(klass)
-          defs = { klass.name => generate_class_schema(klass) }
-          klass.attributes.each_value do |attr|
-            if attr.type <= Lutaml::Model::Serialize
-              defs.merge!(generate_definitions(attr.type))
-            end
+            super(klass, options)
           end
-          defs
-        end
 
-        def self.generate_class_schema(klass)
-          {
-            "type" => "object",
-            "properties" => generate_properties(klass),
-            "required" => klass.attributes.keys,
-          }
-        end
+          def format_schema(schema, options)
+            options[:pretty] ? JSON.pretty_generate(schema) : schema.to_json
+          end
+
+          def generate_model_classes(schema)
+            definitions = definition_collection_class.new(schema["$defs"])
 
-        def self.generate_properties(klass)
-          klass.attributes.transform_values do |attr|
-            generate_property_schema(attr)
+            definitions.transform_values do |definition|
+              generate_model_class(definition)
+            end
           end
-        end
 
-        def self.generate_property_schema(attr)
-          if attr.type <= Lutaml::Model::Serialize
-            { "$ref" => "#/$defs/#{attr.type.name}" }
-          elsif attr.collection?
-            {
-              "type" => "array",
-              "items" => { "type" => get_json_type(attr.type) },
-            }
-          else
-            { "type" => get_json_type(attr.type) }
+          private
+
+          def generate_model_class(schema)
+            template = File.join(__dir__, "templates", "model.erb")
+
+            Lutaml::Model::Schema::Renderer.render(template, schema: schema)
           end
-        end
 
-        def self.get_json_type(type)
-          {
-            Lutaml::Model::Type::String => "string",
-            Lutaml::Model::Type::Integer => "integer",
-            Lutaml::Model::Type::Boolean => "boolean",
-            Lutaml::Model::Type::Float => "number",
-            Lutaml::Model::Type::Hash => "object",
-          }[type] || "string" # Default to string for unknown types
+          def definition_collection_class
+            Lutaml::Model::Schema::Decorators::DefinitionCollection
+          end
         end
       end
     end

data/lib/lutaml/model/schema/relaxng_schema.rb

@@ -4,11 +4,14 @@ module Lutaml
   module Model
     module Schema
       class RelaxngSchema
+        extend SharedMethods
+
         def self.generate(klass, options = {})
+          register = extract_register_from(klass)
           builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
             xml.grammar(xmlns: "http://relaxng.org/ns/structure/1.0") do
               generate_start(xml, klass)
-              generate_define(xml, klass)
+              generate_define(xml, klass, register)
             end
           end
 
@@ -21,34 +24,35 @@ module Lutaml
           end
         end
 
-        def self.generate_attributes(xml, klass)
+        def self.generate_attributes(xml, klass, register)
           klass.attributes.each do |name, attr|
-            if attr.type <= Lutaml::Model::Serialize
-              xml.ref(name: attr.type.name)
+            attr_type = attr.type(register)
+            if attr_type <= Lutaml::Model::Serialize
+              xml.ref(name: attr_type.name)
             elsif attr.collection?
               xml.zeroOrMore do
                 xml.element(name: name) do
-                  xml.data(type: get_relaxng_type(attr.type))
+                  xml.data(type: get_relaxng_type(attr_type))
                 end
               end
             else
               xml.element(name: name) do
-                xml.data(type: get_relaxng_type(attr.type))
+                xml.data(type: get_relaxng_type(attr_type))
               end
             end
           end
         end
 
-        def self.generate_define(xml, klass)
+        def self.generate_define(xml, klass, register)
           xml.define(name: klass.name) do
             xml.element(name: klass.name) do
-              generate_attributes(xml, klass)
+              generate_attributes(xml, klass, register)
             end
           end
 
           klass.attributes.each_value do |attr|
-            if attr.type <= Lutaml::Model::Serialize
-              generate_define(xml, attr.type)
+            if attr.type(register) <= Lutaml::Model::Serialize
+              generate_define(xml, attr.type(register), register)
             end
           end
         end

data/lib/lutaml/model/schema/renderer.rb

@@ -0,0 +1,36 @@
+require "erb"
+require "ostruct"
+
+require_relative "helpers/template_helper"
+
+module Lutaml
+  module Model
+    module Schema
+      class Context
+        include Lutaml::Model::Schema::Helpers::TemplateHelper
+
+        attr_reader :schema
+
+        def initialize(schema)
+          @schema = schema
+        end
+      end
+
+      class Renderer
+        def self.render(template_path, context = {})
+          new(template_path).render(context)
+        end
+
+        def initialize(template_path)
+          @template = File.read(template_path)
+        end
+
+        def render(context = {})
+          context = Context.new(context[:schema])
+
+          ERB.new(@template, trim_mode: "-").result(context.instance_eval { binding })
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/shared_methods.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module SharedMethods
+        def extract_register_from(klass)
+          register = if klass.class_variable_defined?(:@@__register)
+                       klass.class_variable_get(:@@__register)
+                     end
+
+          case register
+          when Lutaml::Model::Register
+            register.id
+          when String, Symbol
+            register.to_sym
+          else
+            Lutaml::Model::Config.default_register
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/templates/model.erb

@@ -0,0 +1,9 @@
+require "lutaml/model"
+
+<%= open_namespaces(schema.namespaces) %>
+<%= indent(schema.namespaces.size) %>class <%= schema.name %> < <%= schema.parent_class %>
+<% schema.attributes.each do |attribute| -%>
+<%= attribute_line(attribute, schema.namespaces.size + 1) %>
+<% end -%>
+<%= indent(schema.namespaces.size) %>end
+<%= close_namespaces(schema.namespaces) %>

data/lib/lutaml/model/schema/xml_compiler/attribute.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class Attribute
+          attr_accessor :id,
+                        :ref,
+                        :name,
+                        :type,
+                        :default
+
+          TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
+            <%= indent %>attribute :<%= resolved_name %>, :<%= resolved_type %>
+          TEMPLATE
+
+          XML_MAPPING_TEMPLATE = ERB.new(<<~XML_MAPPING_TEMPLATE, trim_mode: "-")
+            <%= indent %>map_attribute :<%= resolved_name(change_case: false) %>, to: :<%= resolved_name %><%= namespace_prefix_option %>
+          XML_MAPPING_TEMPLATE
+
+          def initialize(name: nil, ref: nil)
+            @name = name
+            @ref = ref
+          end
+
+          def to_attributes(indent)
+            return if skippable?
+
+            TEMPLATE.result(binding)
+          end
+
+          def to_xml_mapping(indent)
+            return if skippable?
+
+            XML_MAPPING_TEMPLATE.result(binding)
+          end
+
+          def required_files
+            return if skippable?
+
+            raw_type = resolved_type(change_case: false)
+            if raw_type == "decimal"
+              "require \"bigdecimal\""
+            elsif !SimpleType.skippable?(raw_type)
+              "require_relative \"#{Utils.snake_case(raw_type)}\""
+            end
+          end
+
+          private
+
+          def resolved_name(change_case: true)
+            @current_name ||= name || referenced_instance&.name
+            change_case ? Utils.snake_case(@current_name) : @current_name
+          end
+
+          def resolved_type(change_case: true)
+            @current_type ||= type || referenced_instance&.type
+            klass_name = last_of_split(@current_type)
+            change_case ? Utils.snake_case(klass_name) : klass_name
+          end
+
+          def referenced_instance
+            @referenced_instance ||= XmlCompiler.attributes[last_of_split]
+          end
+
+          def last_of_split(field = ref)
+            field&.split(":")&.last
+          end
+
+          def skippable?
+            resolved_name == "schema_location"
+          end
+
+          def namespace_prefix_option
+            return "" unless Utils.present?(ref)
+            return "" unless ref.start_with?("xml:")
+
+            ", namespace: \"http://www.w3.org/XML/1998/namespace\", prefix: \"xml\""
+          end
+        end
+      end
+    end
+  end
+end