lutaml-model 0.6.7 → 0.7.1

data/lib/lutaml/model/serialize.rb

@@ -3,10 +3,8 @@ require_relative "xml_adapter"
 require_relative "config"
 require_relative "type"
 require_relative "attribute"
-require_relative "mapping_rule"
 require_relative "mapping_hash"
-require_relative "xml_mapping"
-require_relative "key_value_mapping"
+require_relative "mapping"
 require_relative "json_adapter"
 require_relative "comparable_model"
 require_relative "schema_location"
@@ -94,22 +92,15 @@ module Lutaml
           end
         end
 
-        # Define an attribute for the model
-        def attribute(name, type, options = {})
-          if type.is_a?(Hash)
-            options[:method_name] = type[:method]
-            type = nil
-          end
-
-          attr = Attribute.new(name, type, options)
-          attributes[name] = attr
+        def define_attribute_methods(attr)
+          name = attr.name
 
           if attr.enum?
             add_enum_methods_to_model(
               model,
               name,
-              options[:values],
-              collection: options[:collection],
+              attr.options[:values],
+              collection: attr.options[:collection],
             )
           elsif attr.derived? && name != attr.method_name
             define_method(name) do
@@ -119,35 +110,74 @@ module Lutaml
             define_method(name) do
               instance_variable_get(:"@#{name}")
             end
-
             define_method(:"#{name}=") do |value|
               value_set_for(name)
               instance_variable_set(:"@#{name}", attr.cast_value(value))
             end
           end
+        end
+
+        # Define an attribute for the model
+        def attribute(name, type, options = {})
+          if type.is_a?(Hash)
+            options[:method_name] = type[:method]
+            type = nil
+          end
+
+          attr = Attribute.new(name, type, options)
+          attributes[name] = attr
+          define_attribute_methods(attr)
 
           attr
         end
 
         def root?
-          mappings_for(:xml).root?
+          mappings_for(:xml)&.root?
+        end
+
+        def import_model_with_root_error(model)
+          return unless model.mappings.key?(:xml) && model.root?
+
+          raise Lutaml::Model::ImportModelWithRootError.new(model)
         end
 
         def import_model_attributes(model)
-          raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+          model.attributes.each_value do |attr|
+            define_attribute_methods(attr)
+          end
 
-          @attributes.merge!(model.attributes)
+          @choice_attributes.concat(Utils.deep_dup(model.choice_attributes))
+          @attributes.merge!(Utils.deep_dup(model.attributes))
         end
 
         def import_model_mappings(model)
-          raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+          import_model_with_root_error(model)
+
+          Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
+            next unless model.mappings.key?(format)
+
+            mapping = model.mappings_for(format)
+            mapping = Utils.deep_dup(mapping)
+
+            @mappings[format] ||= format == :xml ? XmlMapping.new : KeyValueMapping.new
+
+            if format == :xml
+              @mappings[format].merge_mapping_attributes(mapping)
+              @mappings[format].merge_mapping_elements(mapping)
+              @mappings[format].merge_elements_sequence(mapping)
+            else
+              @mappings[format].mappings.concat(mapping.mappings)
+            end
+          end
+        end
 
-          @mappings.merge!(model.mappings)
+        def handle_key_value_mappings(mapping, format)
+          @mappings[format] ||= KeyValueMapping.new
+          @mappings[format].mappings.concat(mapping.mappings)
         end
 
         def import_model(model)
-          raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
-
+          import_model_with_root_error(model)
           import_model_attributes(model)
           import_model_mappings(model)
         end
@@ -213,7 +243,8 @@ module Lutaml
 
         def add_enum_setter_if_not_defined(klass, enum_name, _values, collection)
           Utils.add_method_if_not_defined(klass, "#{enum_name}=") do |value|
-            value = [value] unless value.is_a?(Array)
+            value = [] if value.nil?
+            value = [value] if !value.is_a?(Array)
 
             value_set_for(enum_name)
 
@@ -233,8 +264,8 @@ module Lutaml
 
         Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
           define_method(format) do |&block|
-            klass = format == :xml ? XmlMapping : KeyValueMapping
-            mappings[format] ||= klass.new
+            mapping_class = const_get("Lutaml::Model::#{format.to_s.capitalize}Mapping")
+            mappings[format] ||= mapping_class.new
             mappings[format].instance_eval(&block)
 
             if format == :xml && !mappings[format].root_element && !mappings[format].no_root?
@@ -243,6 +274,8 @@ module Lutaml
           end
 
           define_method(:"from_#{format}") do |data, options = {}|
+            return data if Utils.uninitialized?(data)
+
             adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
 
             doc = adapter.parse(data, options)
@@ -260,7 +293,7 @@ module Lutaml
               options[:encoding] = doc.encoding
               apply_mappings(doc, format, options)
             else
-              apply_mappings(doc.to_h, format)
+              apply_mappings(doc.to_h, format, options)
             end
           end
 
@@ -298,7 +331,7 @@ module Lutaml
 
         def key_value(&block)
           Lutaml::Model::Config::KEY_VALUE_FORMATS.each do |format|
-            mappings[format] ||= KeyValueMapping.new
+            mappings[format] ||= KeyValueMapping.new(format)
             mappings[format].instance_eval(&block)
           end
         end
@@ -310,43 +343,68 @@ module Lutaml
 
           mappings.each_with_object({}) do |rule, hash|
             name = rule.to
-            next if except&.include?(name) || (only && !only.include?(name))
-            next if !rule.custom_methods[:to] && (!rule.render_default? && instance.using_default?(rule.to))
+            attr = attributes[name]
 
+            next if except&.include?(name) || (only && !only.include?(name))
             next handle_delegate(instance, rule, hash, format) if rule.delegate
 
             if rule.custom_methods[:to]
               next instance.send(rule.custom_methods[:to], instance, hash)
             end
 
-            value = instance.send(name)
+            value = rule.serialize(instance)
 
             if rule.raw_mapping?
               adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
               return adapter.parse(value, options)
             end
 
-            attribute = attributes[name]
-
-            if export_method = rule.transform[:export] || attribute.transform_export_method
+            if export_method = rule.transform[:export] || attr.transform_export_method
               value = export_method.call(value)
             end
 
-            next hash.merge!(generate_hash_from_child_mappings(attribute, value, format, rule.root_mappings)) if rule.root_mapping?
+            next hash.merge!(generate_hash_from_child_mappings(attr, value, format, rule.root_mappings)) if rule.root_mapping?
 
             value = if rule.child_mappings
-                      generate_hash_from_child_mappings(attribute, value, format, rule.child_mappings)
+                      generate_hash_from_child_mappings(attr, value, format, rule.child_mappings)
                     else
-                      attribute.serialize(value, format, options)
+                      attr.serialize(value, format, options)
                     end
 
-            next unless rule.render?(value)
+            next if !rule.render?(value, instance, options)
+
+            value = apply_value_map(value, rule.value_map(:to, options), attr)
 
             rule_from_name = rule.multiple_mappings? ? rule.from.first.to_s : rule.from.to_s
             hash[rule_from_name] = value
           end
         end
 
+        def apply_value_map(value, value_map, attr)
+          if value.nil?
+            value_for_option(value_map[:nil], attr)
+          elsif Utils.empty?(value)
+            value_for_option(value_map[:empty], attr, value)
+          elsif Utils.uninitialized?(value)
+            value_for_option(value_map[:omitted], attr)
+          else
+            value
+          end
+        end
+
+        def value_for_option(option, attr, empty_value = nil)
+          return nil if option == :nil
+          return empty_value || empty_object(attr) if option == :empty
+
+          Lutaml::Model::UninitializedClass.instance
+        end
+
+        def empty_object(attr)
+          return [] if attr.collection?
+
+          ""
+        end
+
         def handle_delegate(instance, rule, hash, format)
           name = rule.to
           value = instance.send(rule.delegate).send(name)
@@ -362,9 +420,9 @@ module Lutaml
         end
 
         def default_mappings(format)
-          klass = format == :xml ? XmlMapping : KeyValueMapping
+          _mappings = format == :xml ? XmlMapping.new : KeyValueMapping.new(format)
 
-          klass.new.tap do |mapping|
+          _mappings.tap do |mapping|
             attributes&.each_key do |name|
               mapping.map_element(
                 name.to_s,
@@ -441,7 +499,7 @@ module Lutaml
                              attr_value
                            end
 
-              next unless mapping_rule&.render?(attr_value)
+              next unless mapping_rule&.render?(attr_value, nil)
 
               if path == :key
                 map_key = attr_value
@@ -484,46 +542,43 @@ module Lutaml
           instance = options[:instance] || model.new
           return instance if Utils.blank?(doc)
 
-          options[:mappings] = mappings_for(format).mappings
+          mappings = mappings_for(format)
 
+          if mappings.polymorphic_mapping
+            return resolve_polymorphic(doc, format, mappings, instance, options)
+          end
+
+          options[:mappings] = mappings.mappings
           return apply_xml_mapping(doc, instance, options) if format == :xml
 
           apply_hash_mapping(doc, instance, format, options)
         end
 
+        def resolve_polymorphic(doc, format, mappings, instance, options = {})
+          polymorphic_mapping = mappings.polymorphic_mapping
+          return instance if polymorphic_mapping.polymorphic_map.empty?
+
+          klass_key = doc[polymorphic_mapping.name]
+          klass_name = polymorphic_mapping.polymorphic_map[klass_key]
+          klass = Object.const_get(klass_name)
+
+          klass.apply_mappings(doc, format, options)
+        end
+
         def apply_xml_mapping(doc, instance, options = {})
-          options = Utils.deep_dup(options)
+          options = prepare_options(options)
           instance.encoding = options[:encoding]
           return instance unless doc
 
-          if options[:default_namespace].nil?
-            options[:default_namespace] = mappings_for(:xml)&.namespace_uri
-          end
           mappings = options[:mappings] || mappings_for(:xml).mappings
 
-          raise Lutaml::Model::CollectionTrueMissingError(self, option[:caller_class]) if doc.is_a?(Array)
+          validate_document!(doc, options)
 
-          doc_order = doc.root.order
-          if instance.respond_to?(:ordered=)
-            instance.element_order = doc_order
-            instance.ordered = mappings_for(:xml).ordered? || options[:ordered]
-            instance.mixed = mappings_for(:xml).mixed_content? || options[:mixed_content]
-          end
-
-          schema_location = doc.attributes.values.find do |a|
-            a.unprefixed_name == "schemaLocation"
-          end
-
-          if !schema_location.nil?
-            instance.schema_location = Lutaml::Model::SchemaLocation.new(
-              schema_location: schema_location.value,
-              prefix: schema_location.namespace_prefix,
-              namespace: schema_location.namespace,
-            )
-          end
+          set_instance_ordering(instance, doc, options)
+          set_schema_location(instance, doc)
 
           defaults_used = []
-          validate_sequence!(doc_order)
+          validate_sequence!(doc.root.order)
 
           mappings.each do |rule|
             raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
@@ -531,26 +586,76 @@ module Lutaml
             attr = attribute_for_rule(rule)
             next if attr&.derived?
 
+            new_opts = options.dup
+            if rule.namespace_set?
+              new_opts[:default_namespace] = rule.namespace
+            end
+
             value = if rule.raw_mapping?
                       doc.root.inner_xml
                     elsif rule.content_mapping?
                       rule.cdata ? doc.cdata : doc.text
-                    elsif val = value_for_rule(doc, rule, options, instance)
-                      val
-                    elsif instance.using_default?(rule.to) || rule.render_default
-                      defaults_used << rule.to
-                      attr&.default || rule.to_value_for(instance)
+                    else
+                      val = value_for_rule(doc, rule, new_opts, instance)
+
+                      if (Utils.uninitialized?(val) || val.nil?) && (instance.using_default?(rule.to) || rule.render_default)
+                        defaults_used << rule.to
+                        attr&.default || rule.to_value_for(instance)
+                      else
+                        val
+                      end
                     end
 
-            value = normalize_xml_value(value, rule, attr, options)
+            value = apply_value_map(value, rule.value_map(:from, new_opts), attr)
+            value = normalize_xml_value(value, rule, attr, new_opts)
             rule.deserialize(instance, value, attributes, self)
           end
 
-          defaults_used.each { |attr_name| instance.using_default_for(attr_name) }
+          defaults_used.each do |attr_name|
+            instance.using_default_for(attr_name)
+          end
 
           instance
         end
 
+        def prepare_options(options)
+          opts = Utils.deep_dup(options)
+          opts[:default_namespace] ||= mappings_for(:xml)&.namespace_uri
+
+          opts
+        end
+
+        def validate_document!(doc, options)
+          return unless doc.is_a?(Array)
+
+          raise Lutaml::Model::CollectionTrueMissingError(
+            self,
+            options[:caller_class],
+          )
+        end
+
+        def set_instance_ordering(instance, doc, options)
+          return unless instance.respond_to?(:ordered=)
+
+          instance.element_order = doc.root.order
+          instance.ordered = mappings_for(:xml).ordered? || options[:ordered]
+          instance.mixed = mappings_for(:xml).mixed_content? || options[:mixed_content]
+        end
+
+        def set_schema_location(instance, doc)
+          schema_location = doc.attributes.values.find do |a|
+            a.unprefixed_name == "schemaLocation"
+          end
+
+          return if schema_location.nil?
+
+          instance.schema_location = Lutaml::Model::SchemaLocation.new(
+            schema_location: schema_location.value,
+            prefix: schema_location.namespace_prefix,
+            namespace: schema_location.namespace,
+          )
+        end
+
         def value_for_rule(doc, rule, options, instance)
           rule_names = rule.namespaced_names(options[:default_namespace])
 
@@ -567,40 +672,69 @@ module Lutaml
               return return_child ? children.first : children
             end
 
+            return handle_cdata(children) if rule.cdata
+
+            values = []
+
             if Utils.present?(children)
               instance.value_set_for(attr.name)
+            else
+              children = nil
+              values = Lutaml::Model::UninitializedClass.instance
             end
 
-            if rule.cdata
-              values = children.map do |child|
-                child.cdata_children&.map(&:text)
-              end.flatten
-              return children.count > 1 ? values : values.first
-            end
-
-            values = children.map do |child|
+            children&.each do |child|
               if !rule.using_custom_methods? && attr.type <= Serialize
-                attr.cast(child, :xml, options.except(:mappings))
+                cast_options = options.except(:mappings)
+                cast_options[:polymorphic] = rule.polymorphic if rule.polymorphic
+
+                values << attr.cast(child, :xml, cast_options)
               elsif attr.raw?
-                inner_xml_of(child)
+                values << inner_xml_of(child)
               else
-                child&.children&.first&.text
+                return nil if rule.render_nil_as_nil? && child.nil_element?
+
+                text = child.nil_element? ? nil : (child&.text&.+ child&.cdata)
+                values << text
               end
             end
-            attr&.collection? ? values : values.first
+
+            normalized_value_for_attr(values, attr)
           end
         end
 
+        def handle_cdata(children)
+          values = children.map do |child|
+            child.cdata_children&.map(&:text)
+          end.flatten
+
+          children.count > 1 ? values : values.first
+        end
+
+        def normalized_value_for_attr(values, attr)
+          # for xml collection true cases like
+          #   <store><items /></store>
+          #   <store><items xsi:nil="true"/></store>
+          #   <store><items></items></store>
+          #
+          # these are considered empty collection
+          return [] if attr&.collection? && [[nil], [""]].include?(values)
+          return values if attr&.collection?
+
+          values.is_a?(Array) ? values.first : values
+        end
+
         def apply_hash_mapping(doc, instance, format, options = {})
           mappings = options[:mappings] || mappings_for(format).mappings
           mappings.each do |rule|
             raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
 
             attr = attribute_for_rule(rule)
+            next if attr&.derived?
 
             names = rule.multiple_mappings? ? rule.name : [rule.name]
 
-            value = names.collect do |rule_name|
+            values = names.collect do |rule_name|
               if rule.root_mapping?
                 doc
               elsif rule.raw_mapping?
@@ -610,10 +744,16 @@ module Lutaml
                 doc[rule_name.to_s]
               elsif doc.key?(rule_name.to_sym)
                 doc[rule_name.to_sym]
-              else
+              elsif attr&.default_set?
                 attr&.default
+              else
+                Lutaml::Model::UninitializedClass.instance
               end
-            end.compact.first
+            end.compact
+
+            value = values.find { |v| Utils.initialized?(v) } || values.first
+
+            value = apply_value_map(value, rule.value_map(:from, options), attr)
 
             if rule.using_custom_methods?
               if Utils.present?(value)
@@ -624,7 +764,11 @@ module Lutaml
             end
 
             value = translate_mappings(value, rule.hash_mappings, attr, format)
-            value = attr.cast(value, format) unless rule.hash_mappings
+
+            cast_options = {}
+            cast_options[:polymorphic] = rule.polymorphic if rule.polymorphic
+
+            value = attr.cast(value, format, cast_options) unless rule.hash_mappings
             attr.valid_collection!(value, self)
 
             rule.deserialize(instance, value, attributes, self)
@@ -634,7 +778,7 @@ module Lutaml
         end
 
         def normalize_xml_value(value, rule, attr, options = {})
-          value = [value].compact if attr&.collection? && !value.is_a?(Array)
+          value = [value].compact if attr&.collection? && !value.is_a?(Array) && !value.nil?
 
           return value unless cast_value?(attr, rule)
 
@@ -702,7 +846,7 @@ module Lutaml
       attr_accessor :element_order, :schema_location, :encoding
       attr_writer :ordered, :mixed
 
-      def initialize(attrs = {})
+      def initialize(attrs = {}, options = {})
         @using_default = {}
 
         return unless self.class.attributes
@@ -721,22 +865,28 @@ module Lutaml
 
           value = if attrs.key?(name) || attrs.key?(name.to_s)
                     attr_value(attrs, name, attr)
-                  else
+                  elsif attr.default_set?
                     using_default_for(name)
                     attr.default
+                  else
+                    Lutaml::Model::UninitializedClass.instance
                   end
 
-          # Initialize collections with an empty array if no value is provided
-          if attr.collection? && value.nil?
-            value = []
-          end
-
           default = using_default?(name)
+          value = self.class.apply_value_map(value, value_map(options), attr)
           public_send(:"#{name}=", self.class.ensure_utf8(value))
           using_default_for(name) if default
         end
       end
 
+      def value_map(options)
+        {
+          omitted: options[:omitted] || :nil,
+          nil: options[:nil] || :nil,
+          empty: options[:empty] || :empty,
+        }
+      end
+
       def attr_value(attrs, name, attr_rule)
         value = if attrs.key?(name.to_sym)
                   attrs[name.to_sym]
@@ -747,7 +897,7 @@ module Lutaml
                 end
 
         if attr_rule.collection? || value.is_a?(Array)
-          (value || []).map do |v|
+          value&.map do |v|
             if v.is_a?(Hash)
               attr_rule.type.new(v)
             else

data/lib/lutaml/model/type/date.rb

@@ -3,7 +3,7 @@ module Lutaml
     module Type
       class Date < Value
         def self.cast(value)
-          return nil if value.nil?
+          return value if value.nil? || Utils.uninitialized?(value)
 
           case value
           when ::DateTime, ::Time

data/lib/lutaml/model/type/date_time.rb

@@ -6,7 +6,7 @@ module Lutaml
       # Date and time representation
       class DateTime < Value
         def self.cast(value)
-          return nil if value.nil?
+          return value if value.nil? || Utils.uninitialized?(value)
 
           case value
           when ::DateTime then value
@@ -18,7 +18,7 @@ module Lutaml
         end
 
         def self.serialize(value)
-          return nil if value.nil?
+          return value if value.nil? || Utils.uninitialized?(value)
 
           cast(value)&.iso8601
         end

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

@@ -3,7 +3,7 @@ module Lutaml
     module Type
       class Hash < Value
         def self.cast(value)
-          return nil if value.nil?
+          return value if value.nil? || Utils.uninitialized?(value)
 
           hash = if value.respond_to?(:to_h)
                    value.to_h

data/lib/lutaml/model/type/time.rb

@@ -5,7 +5,7 @@ module Lutaml
     module Type
       class Time < Value
         def self.cast(value)
-          return nil if value.nil?
+          return value if value.nil? || Utils.uninitialized?(value)
 
           case value
           when ::Time then value
@@ -17,7 +17,7 @@ module Lutaml
         end
 
         def self.serialize(value)
-          return nil if value.nil?
+          return value if value.nil? || Utils.uninitialized?(value)
 
           value = cast(value)
           # value&.strftime("%Y-%m-%dT%H:%M:%S%:z")

data/lib/lutaml/model/type/time_without_date.rb

@@ -11,7 +11,7 @@ module Lutaml
         # ::Time.new(1, 1, 1, time.hour, time.min, time.sec)
 
         def self.cast(value)
-          return nil if value.nil?
+          return value if value.nil? || Utils.uninitialized?(value)
 
           case value
           when ::Time then value
@@ -22,7 +22,7 @@ module Lutaml
         end
 
         def self.serialize(value)
-          return nil if value.nil?
+          return value if value.nil? || Utils.uninitialized?(value)
 
           value = cast(value)
           value.strftime("%H:%M:%S") # Format as HH:MM:SS