lutaml-model 0.7.3 → 0.7.5

data/lib/lutaml/model/schema/decorators/class_definition.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "attribute"
+require_relative "choices"
+
+module Lutaml
+  module Model
+    module Schema
+      module Decorators
+        class ClassDefinition
+          attr_accessor :base_class, :sub_classes
+          attr_reader :additional_properties, :properties, :namespaced_name
+
+          # Decorates a JSON schema information to be used in class definitions.
+          # This class is used to provide a structured way to handle schema
+          # information for class definitions, including attributes,
+          # required fields, and JSON mappings.
+          #
+          # @param schema [Hash] The JSON schema to be decorated.
+          # @param options [Hash] Additional options for the decorator.
+          def initialize(namespaced_name, schema)
+            @namespaced_name = namespaced_name
+            @choices = schema["oneOf"] || []
+            @additional_properties = schema["additionalProperties"] || false
+            @polymorphic_attributes = []
+
+            @properties = (schema["properties"] || {}).to_h do |name, attr|
+              attribute = Decorators::Attribute.new(name, attr)
+              polymorphic_attributes << attribute if attribute.polymorphic?
+
+              [name, attribute]
+            end
+
+            @base_class = nil
+            @sub_classes = []
+          end
+
+          def name
+            @name ||= @namespaced_name.split("_").last
+          end
+
+          def namespaces
+            @namespaces ||= @namespaced_name.split("_")[0..-2]
+          end
+
+          def parent_class
+            @parent_class ||= @base_class&.namespaced_name&.gsub("_", "::") || "Lutaml::Model::Serializable"
+          end
+
+          def choice?
+            @choices&.any?
+          end
+
+          def attributes
+            return @properties.values if !choice?
+
+            choice_attributes = {}
+            @choices.each do |choice|
+              choice["properties"].each do |name, attr|
+                choice_attributes[name] = properties[name] || Decorators::Attribute.new(name, attr)
+                properties[name] = nil if properties[name]
+              end
+            end
+
+            @properties.values.compact + [Choices.new(choice_attributes)]
+          end
+
+          def polymorphic?
+            polymorphic_attributes.any?
+          end
+
+          def polymorphic_attributes
+            return @polymorphic_attributes if !@polymorphic_attributes.nil?
+
+            attributes.each do |attr|
+              @polymorphic_attributes << attr if attr.polymorphic?
+            end
+
+            @polymorphic_attributes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/decorators/definition_collection.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "class_definition"
+
+module Lutaml
+  module Model
+    module Schema
+      module Decorators
+        class DefinitionCollection
+          include Enumerable
+
+          def initialize(definitions_hash)
+            @definition_hash = definitions_hash
+            @polymorphic_classes = []
+
+            @definitions = definitions_hash.to_h do |name, schema|
+              definition = definition_class.new(name, schema)
+              @polymorphic_classes << definition if definition.polymorphic?
+
+              [name, definition]
+            end
+
+            resolve_polymorphic_base_types!
+          end
+
+          def each(&block)
+            @definitions.each(&block)
+          end
+
+          def transform_values(&block)
+            @definitions.transform_values(&block)
+          end
+
+          def [](name)
+            @definitions[name] || raise("Definition not found: #{name}")
+          end
+
+          private
+
+          def definition_class
+            Lutaml::Model::Schema::Decorators::ClassDefinition
+          end
+
+          def resolve_polymorphic_base_types!
+            @polymorphic_classes.each do |poly_class|
+              poly_class.polymorphic_attributes.each do |attr|
+                resolve_polymorphic_attribute(attr)
+              end
+            end
+          end
+
+          def resolve_polymorphic_attribute(attr)
+            child_classes = resolve_child_classes(attr.polymorphic)
+            return if child_classes.size < 2
+
+            base_class = find_common_base_class(child_classes)
+            return unless base_class
+
+            update_polymorphic_attribute(attr, base_class)
+            refactor_subclasses(child_classes, base_class)
+          end
+
+          def resolve_child_classes(class_names)
+            class_names.filter_map { |name| @definitions[name] }
+          end
+
+          def update_polymorphic_attribute(attr, base_class)
+            attr.base_class = base_class
+            attr.type = base_class.namespaced_name.gsub("_", "::")
+          end
+
+          def refactor_subclasses(child_classes, base_class)
+            common_keys = base_class.properties.keys.to_set
+            (child_classes - [base_class]).each do |child|
+              child.base_class = base_class
+              child.properties.reject! { |key, _| common_keys.include?(key) }
+              base_class.sub_classes << child unless base_class.sub_classes.include?(child)
+            end
+          end
+
+          def find_common_base_class(class_defs)
+            return nil if class_defs.size < 2
+
+            # Get intersection of all property names
+            common_props = class_defs.map { |klass| klass.properties.keys }.reduce(:&)
+            return nil if common_props.empty?
+
+            # Look for a class that exactly matches the common properties — assume it's the base
+            class_defs.find do |klass|
+              klass.properties.keys.to_set == common_props.to_set
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require_relative "properties_collection"
+require_relative "../shared_methods"
+
+module Lutaml
+  module Model
+    module Schema
+      module Generator
+        class Definition
+          include SharedMethods
+
+          attr_reader :type, :name
+
+          def initialize(type)
+            @type = type
+            @name = type.name.gsub("::", "_")
+          end
+
+          def to_schema
+            @schema = {
+              name => {
+                "type" => "object",
+                "additionalProperties" => false,
+                "properties" => properties_to_schema(type),
+              },
+            }
+
+            # Add choice validation if present
+            if type.choice_attributes.any?
+              @schema[name]["oneOf"] = generate_choice_attributes(type)
+            end
+
+            @schema
+          end
+
+          private
+
+          def generate_choice_attributes(type)
+            type.choice_attributes.map do |choice|
+              {
+                "type" => "object",
+                "properties" => PropertiesCollection.from_attributes(choice.attributes, extract_register_from(type)).to_schema,
+              }
+            end
+          end
+
+          def properties_to_schema(type)
+            PropertiesCollection.from_class(type).to_schema
+          end
+        end
+      end
+    end
+  end
+end

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