lutaml-model 0.7.1 → 0.7.7

data/lib/lutaml/model/mapping/mapping.rb

@@ -0,0 +1,13 @@
+module Lutaml
+  module Model
+    class Mapping
+      def initialize
+        @mappings = []
+      end
+
+      def mappings
+        raise NotImplementedError, "#{self.class.name} must implement `mappings`."
+      end
+    end
+  end
+end

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -3,6 +3,8 @@ module Lutaml
     class MappingRule
       attr_reader :name,
                   :to,
+                  :to_instance,
+                  :as_attribute,
                   :render_nil,
                   :render_default,
                   :render_empty,
@@ -44,6 +46,8 @@ module Lutaml
       def initialize(
         name,
         to:,
+        to_instance: nil,
+        as_attribute: nil,
         render_nil: false,
         render_default: false,
         render_empty: false,
@@ -61,6 +65,8 @@ module Lutaml
       )
         @name = name
         @to = to
+        @to_instance = to_instance
+        @as_attribute = as_attribute
         @render_nil = render_nil
         @render_default = render_default
         @render_empty = render_empty
@@ -212,12 +218,15 @@ module Lutaml
       def deserialize(model, value, attributes, mapper_class = nil)
         handle_custom_method(model, value, mapper_class) ||
           handle_delegate(model, value, attributes) ||
-          handle_transform_method(model, value, attributes) ||
-          assign_value(model, value)
+          handle_transform_method(model, value, attributes)
       end
 
-      def using_custom_methods?
-        !custom_methods.empty?
+      def has_custom_method_for_serialization?
+        !custom_methods.empty? && custom_methods[:to]
+      end
+
+      def has_custom_method_for_deserialization?
+        !custom_methods.empty? && custom_methods[:from]
       end
 
       def multiple_mappings?
@@ -280,14 +289,11 @@ module Lutaml
         delegate_value = model.public_send(delegate)
         return if Utils.initialized?(delegate_value) && !delegate_value.nil?
 
-        model.public_send(:"#{delegate}=", attributes[delegate].type.new)
+        model.public_send(:"#{delegate}=", attributes[delegate].type(model.__register).new)
       end
 
       def handle_transform_method(model, value, attributes)
-        transform_method = transform[:import] || attributes[to].transform_import_method
-        return unless transform_method
-
-        assign_value(model, transform_method.call(value))
+        assign_value(model, ImportTransformer.call(value, self, attributes[to]))
         true
       end
 

data/lib/lutaml/model/register.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class Register
+      attr_reader :id, :models
+
+      def initialize(id)
+        @id = id
+        @models = {}
+        @global_substitutions = {}
+        @type_class_cache = {}
+      end
+
+      def register_model(klass, id: nil)
+        id ||= Utils.base_class_snake_case(klass).to_sym
+        return Lutaml::Model::Type.register(id, klass) if klass <= Lutaml::Model::Type::Value
+        raise NotRegistrableClassError.new(klass) unless klass.include?(Lutaml::Model::Registrable)
+
+        @models[id.to_sym] = klass
+        @models[klass.to_s] = klass
+      end
+
+      def resolve(klass_str)
+        @models[klass_str.to_s]
+      end
+
+      def get_class(klass_name)
+        expected_class = get_class_without_register(klass_name)
+        if !(expected_class < Lutaml::Model::Type::Value)
+          expected_class.class_variable_set(:@@__register, id)
+        end
+        expected_class
+      end
+
+      def register_model_tree(klass)
+        register_model(klass)
+        if klass.include?(Lutaml::Model::Serialize)
+          register_attributes(klass.attributes)
+        end
+      end
+
+      def register_global_type_substitution(from_type:, to_type:)
+        @global_substitutions[from_type] = to_type
+      end
+
+      def register_attributes(attributes)
+        attributes.each_value do |attribute|
+          next unless attribute.unresolved_type.is_a?(Class)
+          next if built_in_type?(attribute.unresolved_type) || attribute.unresolved_type.nil?
+
+          register_model_tree(attribute.unresolved_type)
+        end
+      end
+
+      def substitutable?(klass)
+        @global_substitutions.key?(klass)
+      end
+
+      def substitute(klass)
+        @global_substitutions[klass]
+      end
+
+      def get_class_without_register(klass_name)
+        klass = extract_class_from(klass_name)
+        raise Lutaml::Model::UnknownTypeError.new(klass_name) unless klass
+
+        substitute(klass) || substitute(klass_name) || klass
+      end
+
+      private
+
+      def get_type_class(klass_name)
+        if klass_name.is_a?(String)
+          Lutaml::Model::Type.const_get(klass_name)
+        elsif klass_name.is_a?(Symbol)
+          Lutaml::Model::Type.lookup(klass_name)
+        end
+      end
+
+      def built_in_type?(type)
+        Lutaml::Model::Type::TYPE_CODES.value?(type.inspect) ||
+          Lutaml::Model::Type::TYPE_CODES.key?(type.to_s.to_sym)
+      end
+
+      def extract_class_from(klass)
+        return klass if klass.is_a?(Class)
+        return @models[klass] if @models.key?(klass)
+
+        # Check cache first
+        return @type_class_cache[klass] if @type_class_cache.key?(klass)
+
+        # If not in cache, try to get type class and cache it
+        if type_klass = get_type_class(klass)
+          @type_class_cache[klass] = type_klass
+          type_klass
+        end
+      end
+
+      def clear_type_class_cache
+        @type_class_cache.clear
+      end
+    end
+  end
+end

data/lib/lutaml/model/{toml_adapter.rb → registrable.rb}

@@ -1,6 +1,6 @@
 module Lutaml
   module Model
-    module TomlAdapter
+    module Registrable
     end
   end
 end

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

@@ -0,0 +1,64 @@
+require_relative "generator/definitions_collection"
+# require_relative "generator/collection"
+require_relative "generator/ref"
+
+module Lutaml
+  module Model
+    module Schema
+      class BaseSchema
+        class << self
+          def generate(klass, options = {})
+            schema = new(
+              klass,
+              schema: options[:schema],
+              id: options[:id],
+              title: options[:title],
+              description: options[:description],
+            ).generate_schema_hash
+
+            format_schema(schema, options)
+          end
+        end
+
+        attr_reader :schema, :klass
+        attr_accessor :id, :title, :description
+
+        def initialize(klass, schema:, id: nil, title: nil, description: nil)
+          @schema = schema
+          @klass = klass
+          @id = id
+          @title = title
+          @description = description
+        end
+
+        def generate_schema_hash
+          {
+            "$schema" => schema,
+            "$id" => id,
+            "description" => description,
+            "$ref" => "#/$defs/#{klass.name.gsub('::', '_')}",
+            "$defs" => generate_definitions(klass),
+          }.compact
+        end
+
+        private
+
+        def polymorphic?(attr)
+          Utils.present?(attr.options[:polymorphic])
+        end
+
+        def generate_definitions(klass)
+          Generator::DefinitionsCollection.from_class(klass).to_schema
+        end
+
+        def generate_polymorphic_definitions(attr)
+          return {} unless polymorphic?(attr)
+
+          attr.options[:polymorphic].each_with_object({}) do |child, result|
+            result.merge!(generate_definitions(child))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Decorators
+        class Attribute
+          ATTRIBUTE_TYPES = {
+            "string" => ":string",
+            "integer" => ":integer",
+            "boolean" => ":boolean",
+            "number" => ":float",
+            "object" => ":hash",
+          }.freeze
+
+          attr_reader :name, :options, :polymorphic
+          attr_accessor :type, :base_class
+
+          # @param attribute [Hash] The JSON schema attribute to be decorated.
+          def initialize(name, options)
+            @name = name
+            @options = options
+            @type = extract_type(options)
+            @polymorphic = options["oneOf"]&.map { |choice| choice["$ref"].split("/").last }
+          end
+
+          def default
+            @options["default"]
+          end
+
+          def polymorphic?
+            !!@polymorphic
+          end
+
+          def polymorphic_classes
+            return [] unless polymorphic?
+
+            @base_class.sub_classes.map do |klass|
+              klass.namespaced_name.gsub("_", "::")
+            end
+          end
+
+          def collection?
+            @options["type"] == "array"
+          end
+
+          def collection
+            return unless collection?
+
+            if @options["minItems"] && @options["maxItems"]
+              @options["minItems"]..@options["maxItems"]
+            elsif @options["minItems"]
+              @options["minItems"]..Float::INFINITY
+            elsif @options["maxItems"]
+              0..@options["maxItems"]
+            else
+              true
+            end
+          end
+
+          def choice?
+            false
+          end
+
+          private
+
+          def lutaml_type_symbol(type)
+            return ":string" if type.nil?
+
+            type = type.first if type.is_a?(Array)
+
+            return array_type(options) if type == "array"
+            return object_type(options) if type == "object"
+
+            ATTRIBUTE_TYPES[type] || ":string"
+          end
+
+          def array_type(options)
+            lutaml_type_symbol(options["items"]["type"])
+          end
+
+          def extract_type(options)
+            return extract_type(options["items"]) if options["type"] == "array"
+
+            if options["type"]
+              lutaml_type_symbol(options["type"])
+            elsif options["$ref"]
+              options["$ref"].split("/").last.gsub("_", "::")
+            else
+              ":string" # Default to string if type is not recognized
+            end
+          end
+
+          def object_type(options)
+            if options["oneOf"]
+              {
+                "polymorphic" => options["oneOf"].map do |choice|
+                  choice["$ref"].split("/").last.gsub("_", "::")
+                end,
+              }
+
+            elsif options["properties"]
+              options["properties"].map do |name, attr|
+                Attribute.new(name, attr)
+              end
+            else
+              ":hash" # Default to hash if no specific type is defined
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "attribute"
+
+module Lutaml
+  module Model
+    module Schema
+      module Decorators
+        class Choices
+          attr_reader :attributes
+
+          # Decorates a collection of choice attributes.
+          # This class is used to handle attributes that are part of a choice
+          # constraint in a JSON schema. It provides a way to access the choice
+          # attributes in a structured manner.
+          def initialize(attributes)
+            @attributes = attributes.values
+          end
+
+          def choice?
+            true
+          end
+
+          def polymorphic?
+            false
+          end
+        end
+      end
+    end
+  end
+end

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