lutaml-model 0.6.7 → 0.7.1

data/lib/lutaml/model/attribute.rb

@@ -14,6 +14,9 @@ module Lutaml
         choice
         sequence
         method_name
+        polymorphic
+        polymorphic_class
+        initialize_empty
       ].freeze
 
       def initialize(name, type, options = {})
@@ -25,6 +28,10 @@ module Lutaml
         process_options!
       end
 
+      def polymorphic?
+        @options[:polymorphic_class]
+      end
+
       def derived?
         type.nil?
       end
@@ -41,6 +48,10 @@ module Lutaml
         @options[:method_name]
       end
 
+      def initialize_empty?
+        @options[:initialize_empty]
+      end
+
       def cast_type!(type)
         case type
         when Symbol
@@ -97,11 +108,17 @@ module Lutaml
           type.attributes[to].default
         elsif options[:default].is_a?(Proc)
           options[:default].call
-        else
+        elsif options.key?(:default)
           options[:default]
+        else
+          Lutaml::Model::UninitializedClass.instance
         end
       end
 
+      def default_set?
+        !Utils.uninitialized?(default_value)
+      end
+
       def pattern
         options[:pattern]
       end
@@ -121,6 +138,7 @@ module Lutaml
       def valid_value!(value)
         return true if value.nil? && singular?
         return true unless enum?
+        return true if Utils.uninitialized?(value)
 
         unless valid_value?(value)
           raise Lutaml::Model::InvalidValueError.new(name, value, enum_values)
@@ -162,7 +180,21 @@ module Lutaml
 
         valid_value!(value) &&
           valid_collection!(value, self) &&
-          valid_pattern!(value)
+          valid_pattern!(value) &&
+          validate_polymorphic!(value)
+      end
+
+      def validate_polymorphic(value)
+        return value.all? { |v| validate_polymorphic!(v) } if value.is_a?(Array)
+        return true unless polymorphic_enabled?
+
+        valid_polymorphic_type?(value)
+      end
+
+      def validate_polymorphic!(value)
+        return true if validate_polymorphic(value)
+
+        raise Lutaml::Model::PolymorphicError.new(value, options)
       end
 
       def validate_collection_range
@@ -200,9 +232,6 @@ module Lutaml
 
         return true unless collection?
 
-        # Allow nil values for collections during initialization
-        return true if value.nil?
-
         # Allow any value for unbounded collections
         return true if options[:collection] == true
 
@@ -235,7 +264,8 @@ module Lutaml
       end
 
       def serialize(value, format, options = {})
-        return if value.nil?
+        value ||= [] if collection? && initialize_empty?
+        return value if value.nil? || Utils.uninitialized?(value)
         return value if derived?
         return serialize_array(value, format, options) if value.is_a?(Array)
         return serialize_model(value, format, options) if type <= Serialize
@@ -244,27 +274,64 @@ module Lutaml
       end
 
       def cast(value, format, options = {})
-        return value if type <= Serialize && value.is_a?(type.model)
-
-        value ||= [] if collection?
+        value ||= [] if collection? && !value.nil?
         return value.map { |v| cast(v, format, options) } if value.is_a?(Array)
 
-        if type <= Serialize && castable?(value, format)
-          type.apply_mappings(value, format, options)
-        elsif !value.nil? && !value.is_a?(type)
-          type.send(:"from_#{format}", value)
+        return value if already_serialized?(type, value)
+
+        klass = resolve_polymorphic_class(type, value, options)
+
+        if can_serialize?(klass, value, format)
+          klass.apply_mappings(value, format, options)
+        elsif needs_conversion?(klass, value)
+          klass.send(:"from_#{format}", value)
         else
-          type.cast(value)
+          klass.cast(value)
         end
       end
 
+      def deep_dup
+        self.class.new(name, type, Utils.deep_dup(options))
+      end
+
       private
 
+      def resolve_polymorphic_class(type, value, options)
+        return type unless polymorphic_map_defined?(options, value)
+
+        val = value[options[:polymorphic][:attribute]]
+        klass_name = options[:polymorphic][:class_map][val]
+        Object.const_get(klass_name)
+      end
+
+      def polymorphic_map_defined?(options, value)
+        !value.nil? &&
+          options[:polymorphic] &&
+          !options[:polymorphic].empty? &&
+          value[options[:polymorphic][:attribute]]
+      end
+
       def castable?(value, format)
         value.is_a?(Hash) ||
           (format == :xml && value.is_a?(Lutaml::Model::XmlAdapter::XmlElement))
       end
 
+      def castable_serialized_type?(value)
+        type <= Serialize && value.is_a?(type.model)
+      end
+
+      def can_serialize?(klass, value, format)
+        klass <= Serialize && castable?(value, format)
+      end
+
+      def needs_conversion?(klass, value)
+        !value.nil? && !value.is_a?(klass)
+      end
+
+      def already_serialized?(klass, value)
+        klass <= Serialize && value.is_a?(klass.model)
+      end
+
       def serialize_array(value, format, options)
         value.map { |v| serialize(v, format, options) }
       end
@@ -300,7 +367,7 @@ module Lutaml
 
       def set_default_for_collection
         validate_collection_range
-        @options[:default] ||= -> { [] }
+        @options[:default] ||= -> { [] } if initialize_empty?
       end
 
       def validate_options!(options)
@@ -315,6 +382,10 @@ module Lutaml
                 "`pattern` is only allowed for :string type"
         end
 
+        if initialize_empty? && !collection?
+          raise StandardError,
+                "Invalid option `initialize_empty` given without `collection: true` option"
+        end
         true
       end
 
@@ -325,6 +396,14 @@ module Lutaml
         raise ArgumentError,
               "Invalid type: #{type}, must be a Symbol, String or a Class"
       end
+
+      def polymorphic_enabled?
+        options[:polymorphic]&.any?
+      end
+
+      def valid_polymorphic_type?(value)
+        value.is_a?(type) && options[:polymorphic].include?(value.class)
+      end
     end
   end
 end

data/lib/lutaml/model/choice.rb

@@ -15,6 +15,13 @@ module Lutaml
         raise Lutaml::Model::InvalidChoiceRangeError.new(@min, @max) if @min.negative? || @max.negative?
       end
 
+      def ==(other)
+        @attributes == other.attributes &&
+          @min == other.min &&
+          @max == other.max &&
+          @model == other.model
+      end
+
       def attribute(name, type, options = {})
         options[:choice] = self
         @attributes << @model.attribute(name, type, options)

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/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,9 @@
+module Lutaml
+  module Model
+    class PolymorphicError < Error
+      def initialize(value, options)
+        super("#{value.class} not in #{options[:polymorphic]}")
+      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/mapping/json_mapping.rb

@@ -0,0 +1,17 @@
+require_relative "key_value_mapping"
+
+module Lutaml
+  module Model
+    class JsonMapping < 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

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

@@ -3,10 +3,11 @@ require_relative "key_value_mapping_rule"
 module Lutaml
   module Model
     class KeyValueMapping
-      attr_reader :mappings
+      attr_reader :mappings, :format
 
-      def initialize
+      def initialize(format = nil)
         @mappings = []
+        @format = format
       end
 
       def map(
@@ -14,25 +15,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 +61,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 +80,47 @@ 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!(key, with)
+      end
+
+      def validate_with_options!(key, with)
         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 +128,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 +140,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

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

@@ -11,20 +11,34 @@ module Lutaml
         to:,
         render_nil: false,
         render_default: false,
+        render_empty: false,
+        treat_nil: :nil,
+        treat_empty: :empty,
+        treat_omitted: :nil,
         with: {},
         delegate: nil,
         child_mappings: nil,
         root_mappings: nil,
-        transform: {}
+        polymorphic: {},
+        polymorphic_map: {},
+        transform: {},
+        value_map: {}
       )
         super(
           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,
-          transform: transform
+          polymorphic: polymorphic,
+          polymorphic_map: polymorphic_map,
+          transform: transform,
+          value_map: value_map,
         )
 
         @child_mappings = child_mappings
@@ -42,9 +56,11 @@ module Lutaml
           name.dup,
           to: to.dup,
           render_nil: render_nil.dup,
+          render_empty: render_empty.dup,
           with: Utils.deep_dup(custom_methods),
           delegate: delegate,
           child_mappings: Utils.deep_dup(child_mappings),
+          value_map: Utils.deep_dup(@value_map),
         )
       end