lutaml-model 0.6.7 → 0.7.2

data/lib/lutaml/model/comparable_model.rb

@@ -12,21 +12,61 @@ module Lutaml
       # Checks if two objects are equal based on their attributes
       # @param other [Object] The object to compare with
       # @return [Boolean] True if objects are equal, false otherwise
-      def eql?(other)
-        other.class == self.class &&
-          self.class.attributes.all? do |attr, _|
-            send(attr) == other.send(attr)
+      def eql?(other, compared_objects = {})
+        return true if equal?(other)
+        return false unless same_class?(other)
+        return true if already_compared?(other, compared_objects)
+
+        compared_objects[comparison_key(other)] = true
+        self.class.attributes.all? do |attr, _|
+          attr_value = send(attr)
+          other_value = other.send(attr)
+
+          if attr_value.respond_to?(:eql?) && same_class?(attr_value)
+            attr_value.eql?(other_value, compared_objects)
+          else
+            attr_value == other_value
           end
+        end
       end
 
       alias == eql?
 
+      def same_class?(other)
+        other.instance_of?(self.class)
+      end
+
+      def comparison_key(other)
+        "#{object_id}:#{other.object_id}"
+      end
+
+      def already_compared?(other, compared_objects)
+        compared_objects[comparison_key(other)]
+      end
+
       # Generates a hash value for the object
       # @return [Integer] The hash value
       def hash
-        ([self.class] + self.class.attributes.map do |attr, _|
-                          send(attr).hash
-                        end).hash
+        calculate_hash
+      end
+
+      def calculate_hash(processed_objects = {}.compare_by_identity)
+        return if processed_objects.key?(self)
+
+        processed_objects[self] = true
+        ([self.class] + attributes_hash(processed_objects)).hash
+      end
+
+      def attributes_hash(processed_objects)
+        self.class.attributes.map do |attr, _|
+          attr_value = send(attr)
+
+          if attr_value.respond_to?(:calculate_hash)
+            attr_value.calculate_hash(processed_objects)
+          else
+            attr_value.hash
+          end
+        end
       end
 
       # Class methods added to the class that includes ComparableModel
@@ -419,8 +459,7 @@ module Lutaml
         # @param label [String] The label for the value
         # @param type_info [String, nil] Additional type information
         # @return [String] Formatted value tree
-        def format_value_tree(value1, value2, parent_node, label,
-type_info = nil)
+        def format_value_tree(value1, value2, parent_node, label, type_info = nil)
           return if value1 == value2 && !@show_unchanged
 
           if value1 == value2

data/lib/lutaml/model/config.rb

@@ -3,12 +3,7 @@ module Lutaml
     module Config
       extend self
 
-      # Default values are set for these so the readers are defined below
-      attr_writer :json_adapter, :yaml_adapter
-
-      attr_accessor :xml_adapter, :toml_adapter
-
-      AVAILABLE_FORMATS = %i[xml json yaml toml].freeze
+      AVAILABLE_FORMATS = %i[xml json yaml toml hash].freeze
       KEY_VALUE_FORMATS = AVAILABLE_FORMATS - %i[xml]
 
       def configure
@@ -42,55 +37,66 @@ module Lutaml
       #     one of [:tomlib, :toml_rb]
       #   @example
       #     Lutaml::Model::Config.toml_adapter = :tomlib
+      #
+      # AVAILABLE_FORMATS.each do |adapter_name|
+      #   define_method(:"#{adapter_name}_adapter_type=") do |type_name|
+      #     Lutaml::Model::FormatRegistry.send(:"#{adapter_name}_adapter_type=", type_name)
+      #   end
+      # end
+
       AVAILABLE_FORMATS.each do |adapter_name|
         define_method(:"#{adapter_name}_adapter_type=") do |type_name|
-          adapter = "#{adapter_name}_adapter"
-          type = "#{type_name}_adapter"
+          adapter = adapter_name.to_s
+          type = normalize_type_name(type_name, adapter_name)
+          load_adapter_file(adapter, type)
+          load_moxml_adapter(type_name, adapter_name)
+          set_adapter_for(adapter_name, class_for(adapter, type))
+        end
+      end
 
-          begin
-            adapter_file = File.join(adapter, type)
-            require_relative adapter_file
-          rescue LoadError
-            raise(
-              Lutaml::Model::UnknownAdapterTypeError.new(
-                adapter_name,
-                type_name,
-              ),
-              cause: nil,
-            )
-          end
-          Moxml::Adapter.load(type_name) unless KEY_VALUE_FORMATS.include?(adapter_name)
+      def adapter_for(format)
+        public_send(:"#{format}_adapter")
+      end
 
-          instance_variable_set(
-            :"@#{adapter}",
-            Lutaml::Model.const_get(to_class_name(adapter))
-                         .const_get(to_class_name(type)),
-          )
-        end
+      def set_adapter_for(format, adapter)
+        public_send(:"#{format}_adapter=", adapter)
       end
 
-      # Return JSON adapter. By default StandardJsonAdapter is used
-      #
-      # @example
-      #   Lutaml::Model::Config.json_adapter
-      #   # => Lutaml::Model::YamlAdapter::StandardJsonAdapter
-      def json_adapter
-        @json_adapter || Lutaml::Model::JsonAdapter::StandardJsonAdapter
+      def mappings_class_for(format)
+        Lutaml::Model::FormatRegistry.mappings_class_for(format)
       end
 
-      # Return YAML adapter. By default StandardYamlAdapter is used
-      #
-      # @example
-      #   Lutaml::Model::Config.yaml_adapter
-      #   # => Lutaml::Model::YamlAdapter::StandardYamlAdapter
-      def yaml_adapter
-        @yaml_adapter || Lutaml::Model::YamlAdapter::StandardYamlAdapter
+      def transformer_for(format)
+        Lutaml::Model::FormatRegistry.transformer_for(format)
+      end
+
+      def class_for(adapter, type)
+        Lutaml::Model.const_get(to_class_name(adapter))
+          .const_get(to_class_name(type))
       end
 
-      # @api private
       def to_class_name(str)
         str.to_s.split("_").map(&:capitalize).join
       end
+
+      private
+
+      def normalize_type_name(type_name, adapter_name)
+        "#{type_name.to_s.gsub("_#{adapter_name}", '')}_adapter"
+      end
+
+      def load_adapter_file(adapter, type)
+        adapter_file = File.join(adapter, type)
+        require_relative adapter_file
+      rescue LoadError
+        raise UnknownAdapterTypeError.new(adapter, type), cause: nil
+      end
+
+      def load_moxml_adapter(type_name, adapter_name)
+        return if KEY_VALUE_FORMATS.include?(adapter_name)
+
+        Moxml::Adapter.load(type_name)
+      end
     end
   end
 end

data/lib/lutaml/model/error/collection_count_out_of_range_error.rb

@@ -10,7 +10,7 @@ module Lutaml
       end
 
       def to_s
-        "#{@attr_name} count is #{@value.size}, must be #{range_to_string}"
+        "#{@attr_name} count is #{@value&.size || 0}, must be #{range_to_string}"
       end
 
       private

data/lib/lutaml/model/error/polymorphic_error.rb

@@ -0,0 +1,14 @@
+module Lutaml
+  module Model
+    class PolymorphicError < Error
+      def initialize(value, options, type)
+        error = if options[:polymorphic].is_a?(Array)
+                  "#{value.class} not in #{options[:polymorphic]}"
+                else
+                  "#{value.class} is not valid sub class of #{type}"
+                end
+        super(error)
+      end
+    end
+  end
+end

data/lib/lutaml/model/error.rb

@@ -26,3 +26,4 @@ require_relative "error/invalid_choice_range_error"
 require_relative "error/unknown_sequence_mapping_error"
 require_relative "error/choice_lower_bound_error"
 require_relative "error/no_root_namespace_error"
+require_relative "error/polymorphic_error"

data/lib/lutaml/model/format_registry.rb

@@ -0,0 +1,41 @@
+module Lutaml
+  module Model
+    class FormatRegistry
+      class << self
+        attr_reader :format, :mapping_class, :adapter_class
+
+        def register(format, mapping_class:, adapter_class:, transformer:)
+          registered_formats[format] = {
+            mapping_class: mapping_class,
+            transformer: transformer,
+          }
+
+          ::Lutaml::Model::Type::Value.register_format_to_from_methods(format)
+          ::Lutaml::Model::Serialize.register_format_mapping_method(format)
+          ::Lutaml::Model::Serialize.register_from_format_method(format)
+          ::Lutaml::Model::Serialize.register_to_format_method(format)
+
+          Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter") do
+            instance_variable_get(:"@#{format}_adapter") || adapter_class
+          end
+
+          Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter=") do |adapter_klass|
+            instance_variable_set(:"@#{format}_adapter", adapter_klass)
+          end
+        end
+
+        def mappings_class_for(format)
+          registered_formats.dig(format, :mapping_class)
+        end
+
+        def transformer_for(format)
+          registered_formats.dig(format, :transformer)
+        end
+
+        def registered_formats
+          @registered_formats ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/hash/document.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module HashAdapter
+      # Base class for Hash documents
+      class Document < KeyValueDocument
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require_relative "../mapping/key_value_mapping"
+
+module Lutaml
+  module Model
+    module HashAdapter
+      class Mapping < Lutaml::Model::KeyValueMapping
+        def initialize
+          super(:hash)
+        end
+
+        def deep_dup
+          self.class.new.tap do |new_mapping|
+            new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require_relative "../mapping/key_value_mapping_rule"
+
+module Lutaml
+  module Model
+    module HashAdapter
+      class MappingRule < Lutaml::Model::KeyValueMappingRule; end
+    end
+  end
+end

data/lib/lutaml/model/hash/standard_adapter.rb

@@ -0,0 +1,17 @@
+require_relative "document"
+
+module Lutaml
+  module Model
+    module HashAdapter
+      class StandardAdapter < Document
+        def self.parse(hsh, _options = {})
+          hsh
+        end
+
+        def to_hash(_options = {})
+          @attributes
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/hash/transform.rb

@@ -0,0 +1,8 @@
+module Lutaml
+  module Model
+    module HashAdapter
+      class Transform < Lutaml::Model::KeyValueTransform
+      end
+    end
+  end
+end

data/lib/lutaml/model/hash.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module HashAdapter
+    end
+  end
+end
+
+require_relative "hash/standard_adapter"
+require_relative "hash/document"
+require_relative "hash/mapping"
+require_relative "hash/mapping_rule"
+require_relative "hash/transform"
+
+Lutaml::Model::FormatRegistry.register(
+  :hash,
+  mapping_class: Lutaml::Model::HashAdapter::Mapping,
+  adapter_class: Lutaml::Model::HashAdapter::StandardAdapter,
+  transformer: Lutaml::Model::HashAdapter::Transform,
+)

data/lib/lutaml/model/json/document.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Json
+      # Base class for JSON documents
+      class Document < Lutaml::Model::KeyValueDocument
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require_relative "../mapping/key_value_mapping"
+
+module Lutaml
+  module Model
+    module Json
+      class Mapping < Lutaml::Model::KeyValueMapping
+        def initialize
+          super(:json)
+        end
+
+        def deep_dup
+          self.class.new.tap do |new_mapping|
+            new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require_relative "../mapping/key_value_mapping_rule"
+
+module Lutaml
+  module Model
+    module Json
+      class MappingRule < Lutaml::Model::KeyValueMappingRule; end
+    end
+  end
+end

data/lib/lutaml/model/{json_adapter → json}/multi_json_adapter.rb

@@ -1,13 +1,12 @@
 require "multi_json"
-require_relative "json_document"
+require_relative "document"
 
 module Lutaml
   module Model
-    module JsonAdapter
-      class MultiJsonAdapter < JsonDocument
+    module Json
+      class MultiJsonAdapter < Document
         def self.parse(json, _options = {})
-          data = MultiJson.load(json)
-          new(data)
+          MultiJson.load(json)
         end
 
         def to_json(*args)

data/lib/lutaml/model/{json_adapter/standard_json_adapter.rb → json/standard_adapter.rb}

@@ -1,10 +1,12 @@
 require "json"
-require_relative "json_document"
+require_relative "document"
 
 module Lutaml
   module Model
-    module JsonAdapter
-      class StandardJsonAdapter < JsonDocument
+    module Json
+      class StandardAdapter < Document
+        FORMAT_SYMBOL = :json
+
         def self.parse(json, _options = {})
           JSON.parse(json, create_additions: false)
         end

data/lib/lutaml/model/json/transform.rb

@@ -0,0 +1,8 @@
+module Lutaml
+  module Model
+    module Json
+      class Transform < Lutaml::Model::KeyValueTransform
+      end
+    end
+  end
+end

data/lib/lutaml/model/json.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Json
+    end
+  end
+end
+
+require_relative "json/standard_adapter"
+require_relative "json/document"
+require_relative "json/mapping"
+require_relative "json/mapping_rule"
+require_relative "json/transform"
+
+Lutaml::Model::FormatRegistry.register(
+  :json,
+  mapping_class: Lutaml::Model::Json::Mapping,
+  adapter_class: Lutaml::Model::Json::StandardAdapter,
+  transformer: Lutaml::Model::Json::Transform,
+)

data/lib/lutaml/model/key_value_document.rb

@@ -0,0 +1,27 @@
+module Lutaml
+  module Model
+    class KeyValueDocument
+      attr_reader :attributes
+
+      def initialize(attributes = {})
+        @attributes = attributes
+      end
+
+      def [](key)
+        @attributes[key]
+      end
+
+      def []=(key, value)
+        @attributes[key] = value
+      end
+
+      def key?(key)
+        @attributes.key?(key)
+      end
+
+      def to_h
+        @attributes
+      end
+    end
+  end
+end

data/lib/lutaml/model/{key_value_mapping.rb → mapping/key_value_mapping.rb}

@@ -1,12 +1,15 @@
+require_relative "mapping"
 require_relative "key_value_mapping_rule"
 
 module Lutaml
   module Model
-    class KeyValueMapping
-      attr_reader :mappings
+    class KeyValueMapping < Mapping
+      attr_reader :mappings, :format
 
-      def initialize
-        @mappings = []
+      def initialize(format = nil)
+        super()
+
+        @format = format
       end
 
       def map(
@@ -14,25 +17,39 @@ module Lutaml
         to: nil,
         render_nil: false,
         render_default: false,
+        render_empty: false,
+        treat_nil: nil,
+        treat_empty: nil,
+        treat_omitted: nil,
         with: {},
         delegate: nil,
         child_mappings: nil,
         root_mappings: nil,
-        transform: {}
+        polymorphic: {},
+        polymorphic_map: {},
+        transform: {},
+        value_map: {}
       )
         mapping_name = name_for_mapping(root_mappings, name)
-        validate!(mapping_name, to, with)
+        validate!(mapping_name, to, with, render_nil, render_empty)
 
         @mappings << KeyValueMappingRule.new(
           mapping_name,
           to: to,
           render_nil: render_nil,
           render_default: render_default,
+          render_empty: render_empty,
+          treat_nil: treat_nil,
+          treat_empty: treat_empty,
+          treat_omitted: treat_omitted,
           with: with,
           delegate: delegate,
           child_mappings: child_mappings,
           root_mappings: root_mappings,
+          polymorphic: polymorphic,
+          polymorphic_map: polymorphic_map,
           transform: transform,
+          value_map: value_map,
         )
       end
 
@@ -46,7 +63,7 @@ module Lutaml
         delegate: nil
       )
         @raw_mapping = true
-        validate!(Constants::RAW_MAPPING_KEY, to, with)
+        validate!(Constants::RAW_MAPPING_KEY, to, with, render_nil, nil)
         @mappings << KeyValueMappingRule.new(
           Constants::RAW_MAPPING_KEY,
           to: to,
@@ -65,28 +82,49 @@ module Lutaml
         name
       end
 
-      def validate!(key, to, with)
+      def validate!(key, to, with, render_nil, render_empty)
         validate_mappings!(key)
+        validate_to_and_with_arguments!(key, to, with)
+
+        # Validate `render_nil` for unsupported value
+        validate_blank_mappings!(render_nil, render_empty)
+        validate_root_mappings!(key)
+      end
 
+      def validate_to_and_with_arguments!(key, to, with)
         if to.nil? && with.empty? && !@raw_mapping
-          msg = ":to or :with argument is required for mapping '#{key}'"
-          raise IncorrectMappingArgumentsError.new(msg)
+          raise IncorrectMappingArgumentsError.new(
+            ":to or :with argument is required for mapping '#{key}'",
+          )
         end
 
+        validate_with_options!(to, key, with)
+      end
+
+      def validate_with_options!(to, key, with)
+        return true if to
+
         if !with.empty? && (with[:from].nil? || with[:to].nil?) && !@raw_mapping
-          msg = ":with argument for mapping '#{key}' requires :to and :from keys"
-          raise IncorrectMappingArgumentsError.new(msg)
+          raise IncorrectMappingArgumentsError.new(
+            ":with argument for mapping '#{key}' requires :to and :from keys",
+          )
         end
-
-        validate_mappings(key)
       end
 
-      def validate_mappings(name)
+      def validate_root_mappings!(name)
         if @mappings.any?(&:root_mapping?) || (name == "root_mapping" && @mappings.any?)
           raise MultipleMappingsError.new("root_mappings cannot be used with other mappings")
         end
       end
 
+      def validate_blank_mappings!(render_nil, render_empty)
+        if render_nil == :as_blank || render_empty == :as_blank
+          raise IncorrectMappingArgumentsError.new(
+            ":as_blank is not supported for key-value mappings",
+          )
+        end
+      end
+
       def validate_mappings!(_type)
         if (@raw_mapping && Utils.present?(@mappings)) || (!@raw_mapping && @mappings.any?(&:raw_mapping?))
           raise StandardError, "map_all is not allowed with other mappings"
@@ -94,7 +132,7 @@ module Lutaml
       end
 
       def deep_dup
-        self.class.new.tap do |new_mapping|
+        self.class.new(@format).tap do |new_mapping|
           new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
         end
       end
@@ -106,6 +144,16 @@ module Lutaml
       def find_by_to(to)
         @mappings.find { |m| m.to.to_s == to.to_s }
       end
+
+      def polymorphic_mapping
+        @mappings.find(&:polymorphic_mapping?)
+      end
+
+      Lutaml::Model::Config::KEY_VALUE_FORMATS.each do |format|
+        define_method(:"format_#{format}?") do
+          @format == format
+        end
+      end
     end
   end
 end