lutaml-model 0.4.0 → 0.5.1

data/lib/lutaml/model/attribute.rb

@@ -142,7 +142,7 @@ module Lutaml
         # Use the default value if the value is nil
         value = default if value.nil?
 
-        valid_value!(value) && valid_collection!(value) && valid_pattern!(value)
+        valid_value!(value) && valid_collection!(value, self) && valid_pattern!(value)
       end
 
       def validate_collection_range
@@ -169,7 +169,9 @@ module Lutaml
         end
       end
 
-      def valid_collection!(value)
+      def valid_collection!(value, caller)
+        raise Lutaml::Model::CollectionTrueMissingError.new(name, caller) if value.is_a?(Array) && !collection?
+
         return true unless collection?
 
         # Allow nil values for collections during initialization
@@ -207,6 +209,8 @@ module Lutaml
       end
 
       def serialize(value, format, options = {})
+        return if value.nil?
+
         if value.is_a?(Array)
           value.map do |v|
             serialize(v, format, options)

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

@@ -0,0 +1,16 @@
+module Lutaml
+  module Model
+    class CollectionTrueMissingError < Error
+      def initialize(attr_name, caller_class)
+        @attr_name = attr_name
+        @caller = caller_class
+
+        super()
+      end
+
+      def to_s
+        "May be `collection: true` is missing for `#{@attr_name}` in #{@caller}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Lutaml
+  module Model
+    class MultipleMappingsError < Error
+    end
+  end
+end

data/lib/lutaml/model/error.rb

@@ -14,3 +14,5 @@ require_relative "error/validation_error"
 require_relative "error/type_not_enabled_error"
 require_relative "error/type_error"
 require_relative "error/unknown_type_error"
+require_relative "error/multiple_mappings_error"
+require_relative "error/collection_true_missing_error"

data/lib/lutaml/model/key_value_mapping.rb

@@ -10,29 +10,38 @@ module Lutaml
       end
 
       def map(
-        name,
+        name = nil,
         to: nil,
         render_nil: false,
         render_default: false,
         with: {},
         delegate: nil,
-        child_mappings: nil
+        child_mappings: nil,
+        root_mappings: nil
       )
-        validate!(name, to, with)
+        mapping_name = name_for_mapping(root_mappings, name)
+        validate!(mapping_name, to, with)
 
         @mappings << KeyValueMappingRule.new(
-          name,
+          mapping_name,
           to: to,
           render_nil: render_nil,
           render_default: render_default,
           with: with,
           delegate: delegate,
           child_mappings: child_mappings,
+          root_mappings: root_mappings,
         )
       end
 
       alias map_element map
 
+      def name_for_mapping(root_mappings, name)
+        return "root_mapping" if root_mappings
+
+        name
+      end
+
       def validate!(key, to, with)
         if to.nil? && with.empty?
           msg = ":to or :with argument is required for mapping '#{key}'"
@@ -43,6 +52,14 @@ module Lutaml
           msg = ":with argument for mapping '#{key}' requires :to and :from keys"
           raise IncorrectMappingArgumentsError.new(msg)
         end
+
+        validate_mappings(key)
+      end
+
+      def validate_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 deep_dup
@@ -54,6 +71,10 @@ module Lutaml
       def duplicate_mappings
         @mappings.map(&:deep_dup)
       end
+
+      def find_by_to(to)
+        @mappings.find { |m| m.to.to_s == to.to_s }
+      end
     end
   end
 end

data/lib/lutaml/model/key_value_mapping_rule.rb

@@ -3,7 +3,8 @@ require_relative "mapping_rule"
 module Lutaml
   module Model
     class KeyValueMappingRule < MappingRule
-      attr_reader :child_mappings
+      attr_reader :child_mappings,
+                  :root_mappings
 
       def initialize(
         name,
@@ -12,7 +13,8 @@ module Lutaml
         render_default: false,
         with: {},
         delegate: nil,
-        child_mappings: nil
+        child_mappings: nil,
+        root_mappings: nil
       )
         super(
           name,
@@ -20,10 +22,17 @@ module Lutaml
           render_nil: render_nil,
           render_default: render_default,
           with: with,
-          delegate: delegate,
+          delegate: delegate
         )
 
         @child_mappings = child_mappings
+        @root_mappings = root_mappings
+      end
+
+      def hash_mappings
+        return @root_mappings if @root_mappings
+
+        @child_mappings
       end
 
       def deep_dup
@@ -36,6 +45,10 @@ module Lutaml
           child_mappings: Utils.deep_dup(child_mappings),
         )
       end
+
+      def root_mapping?
+        name == "root_mapping"
+      end
     end
   end
 end

data/lib/lutaml/model/loggable.rb

@@ -0,0 +1,15 @@
+module Lutaml
+  module Model
+    module Loggable
+      def self.included(base)
+        base.define_method :warn_auto_handling do |name|
+          caller_file = File.basename(caller_locations(2, 1)[0].path)
+          caller_line = caller_locations(2, 1)[0].lineno
+
+          str = "[Lutaml::Model] WARN: `#{name}` is handled by default. No need to explecitly define at `#{caller_file}:#{caller_line}`"
+          warn(str)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/mapping_rule.rb

@@ -16,7 +16,8 @@ module Lutaml
         render_default: false,
         with: {},
         attribute: false,
-        delegate: nil
+        delegate: nil,
+        root_mappings: nil
       )
         @name = name
         @to = to
@@ -25,6 +26,7 @@ module Lutaml
         @custom_methods = with
         @attribute = attribute
         @delegate = delegate
+        @root_mappings = root_mappings
       end
 
       alias from name
@@ -42,6 +44,8 @@ module Lutaml
         if delegate
           model.public_send(delegate).public_send(to)
         else
+          return if to.nil?
+
           model.public_send(to)
         end
       end
@@ -56,7 +60,7 @@ module Lutaml
 
       def deserialize(model, value, attributes, mapper_class = nil)
         if custom_methods[:from]
-          mapper_class.new.send(custom_methods[:from], model, value)
+          mapper_class.new.send(custom_methods[:from], model, value) unless value.nil?
         elsif delegate
           if model.public_send(delegate).nil?
             model.public_send(:"#{delegate}=", attributes[delegate].type.new)
@@ -68,6 +72,14 @@ module Lutaml
         end
       end
 
+      def using_custom_methods?
+        !custom_methods.empty?
+      end
+
+      def multiple_mappings?
+        name.is_a?(Array)
+      end
+
       def deep_dup
         raise NotImplementedError, "Subclasses must implement `deep_dup`."
       end

data/lib/lutaml/model/serialize.rb

@@ -21,6 +21,7 @@ module Lutaml
 
       def self.included(base)
         base.extend(ClassMethods)
+        base.initialize_attrs(base)
       end
 
       module ClassMethods
@@ -28,14 +29,18 @@ module Lutaml
 
         def inherited(subclass)
           super
+          subclass.initialize_attrs(self)
+        end
 
-          @mappings ||= {}
-          @attributes ||= {}
+        def included(base)
+          base.extend(ClassMethods)
+          base.initialize_attrs(self)
+        end
 
-          subclass.instance_variable_set(:@attributes,
-                                         Utils.deep_dup(@attributes))
-          subclass.instance_variable_set(:@mappings, Utils.deep_dup(@mappings))
-          subclass.instance_variable_set(:@model, subclass)
+        def initialize_attrs(source_class)
+          @mappings = Utils.deep_dup(source_class.instance_variable_get(:@mappings)) || {}
+          @attributes = Utils.deep_dup(source_class.instance_variable_get(:@attributes)) || {}
+          instance_variable_set(:@model, self)
         end
 
         def model(klass = nil)
@@ -264,15 +269,20 @@ module Lutaml
 
             value = instance.send(name)
 
-            next if Utils.blank?(value) && !rule.render_nil
-
             attribute = attributes[name]
 
-            hash[rule.from.to_s] = if rule.child_mappings
-                                     generate_hash_from_child_mappings(value, rule.child_mappings)
-                                   else
-                                     attribute.serialize(value, format, options)
-                                   end
+            next hash.merge!(generate_hash_from_child_mappings(value, format, rule.root_mappings)) if rule.root_mapping?
+
+            value = if rule.child_mappings
+                      generate_hash_from_child_mappings(value, format, rule.child_mappings)
+                    else
+                      attribute.serialize(value, format, options)
+                    end
+
+            next if Utils.blank?(value) && !rule.render_nil
+
+            rule_from_name = rule.multiple_mappings? ? rule.from.first.to_s : rule.from.to_s
+            hash[rule_from_name] = value
           end
         end
 
@@ -282,39 +292,14 @@ module Lutaml
           return if value.nil? && !rule.render_nil
 
           attribute = instance.send(rule.delegate).class.attributes[name]
-          hash[rule.from.to_s] = attribute.serialize(value, format)
+          rule_from_name = rule.multiple_mappings? ? rule.from.first.to_s : rule.from.to_s
+          hash[rule_from_name] = attribute.serialize(value, format)
         end
 
         def mappings_for(format)
           mappings[format] || default_mappings(format)
         end
 
-        def attr_value(attrs, name, attr_rule)
-          value = if attrs.key?(name.to_sym)
-                    attrs[name.to_sym]
-                  elsif attrs.key?(name.to_s)
-                    attrs[name.to_s]
-                  else
-                    attr_rule.default
-                  end
-
-          if attr_rule.collection? || value.is_a?(Array)
-            (value || []).map do |v|
-              if v.is_a?(Hash)
-                attr_rule.type.new(v)
-              else
-                # TODO: This code is problematic because Type.cast does not know
-                # about all the types.
-                Lutaml::Model::Type.cast(v, attr_rule.type)
-              end
-            end
-          else
-            # TODO: This code is problematic because Type.cast does not know
-            # about all the types.
-            Lutaml::Model::Type.cast(value, attr_rule.type)
-          end
-        end
-
         def default_mappings(format)
           klass = format == :xml ? XmlMapping : KeyValueMapping
 
@@ -330,11 +315,11 @@ module Lutaml
           end
         end
 
-        def apply_child_mappings(hash, child_mappings)
+        def translate_mappings(hash, child_mappings, attr, format)
           return hash unless child_mappings
 
           hash.map do |key, value|
-            child_mappings.to_h do |attr_name, path|
+            child_hash = child_mappings.to_h do |attr_name, path|
               attr_value = if path == :key
                              key
                            elsif path == :value
@@ -344,32 +329,59 @@ module Lutaml
                              value.dig(*path.map(&:to_s))
                            end
 
-              [attr_name, attr_value]
+              attr_rule = attr.type.mappings_for(format).find_by_to(attr_name)
+              [attr_rule.from.to_s, attr_value]
             end
+
+            if child_mappings.values == [:key] && hash.values.all?(Hash)
+              child_hash.merge!(value)
+            end
+
+            attr.type.apply_hash_mapping(
+              child_hash,
+              attr.type.model.new,
+              format,
+              { mappings: attr.type.mappings_for(format).mappings },
+            )
           end
         end
 
-        def generate_hash_from_child_mappings(value, child_mappings)
+        def generate_hash_from_child_mappings(value, format, child_mappings)
           return value unless child_mappings
 
           hash = {}
 
+          if child_mappings.values == [:key]
+            klass = value.first.class
+            mappings = klass.mappings_for(format)
+
+            klass.attributes.each_key do |name|
+              next if child_mappings.key?(name.to_sym) || child_mappings.key?(name.to_s)
+
+              child_mappings[name.to_sym] = mappings.find_by_to(name)&.name.to_s || name.to_s
+            end
+          end
+
           value.each do |child_obj|
             map_key = nil
             map_value = {}
             child_mappings.each do |attr_name, path|
+              attr_value = child_obj.send(attr_name)
+              attr_value = attr_value.to_yaml_hash if attr_value.is_a?(Lutaml::Model::Serialize)
+
               if path == :key
-                map_key = child_obj.send(attr_name)
+                map_key = attr_value
               elsif path == :value
-                map_value = child_obj.send(attr_name)
+                map_value = attr_value
               else
                 path = [path] unless path.is_a?(Array)
                 path[0...-1].inject(map_value) do |acc, k|
                   acc[k.to_s] ||= {}
-                end.public_send(:[]=, path.last.to_s, child_obj.send(attr_name))
+                end.public_send(:[]=, path.last.to_s, attr_value)
               end
             end
 
+            map_value = nil if map_value.empty?
             hash[map_key] = map_value
           end
 
@@ -397,12 +409,15 @@ module Lutaml
         def apply_mappings(doc, format, options = {})
           instance = options[:instance] || model.new
           return instance if Utils.blank?(doc)
+
+          options[:mappings] = mappings_for(format).mappings
           return apply_xml_mapping(doc, instance, options) if format == :xml
 
           apply_hash_mapping(doc, instance, format, options)
         end
 
         def apply_xml_mapping(doc, instance, options = {})
+          options = Utils.deep_dup(options)
           instance.encoding = options[:encoding]
           return instance unless doc
 
@@ -410,11 +425,10 @@ module Lutaml
             options[:default_namespace] =
               mappings_for(:xml)&.namespace_uri
           end
-          mappings = mappings_for(:xml).mappings
+          mappings = options[:mappings] || mappings_for(:xml).mappings
 
           if doc.is_a?(Array)
-            raise "May be `collection: true` is" \
-                  "missing for #{self} in #{options[:caller_class]}"
+            raise Lutaml::Model::CollectionTrueMissingError(self, option[:caller_class])
           end
 
           if instance.respond_to?(:ordered=) && doc.is_a?(Lutaml::Model::MappingHash)
@@ -438,17 +452,18 @@ module Lutaml
 
             attr = attribute_for_rule(rule)
 
+            namespaced_names = rule.namespaced_names(options[:default_namespace])
+
             value = if rule.raw_mapping?
                       doc.node.inner_xml
                     elsif rule.content_mapping?
                       doc[rule.content_key]
-                    elsif doc.key_exist?(rule.namespaced_name(options[:default_namespace]))
-                      doc.fetch(rule.namespaced_name(options[:default_namespace]))
+                    elsif key = (namespaced_names & doc.keys).first
+                      doc[key]
                     else
                       defaults_used << rule.to
                       attr&.default || rule.to_value_for(instance)
                     end
-
             value = normalize_xml_value(value, rule, attr, options)
             rule.deserialize(instance, value, attributes, self)
           end
@@ -460,20 +475,28 @@ module Lutaml
           instance
         end
 
-        def apply_hash_mapping(doc, instance, format, _options = {})
-          mappings = mappings_for(format).mappings
+        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)
 
-            value = if doc.key?(rule.name.to_s) || doc.key?(rule.name.to_sym)
-                      doc[rule.name.to_s] || doc[rule.name.to_sym]
-                    else
-                      attr&.default
-                    end
+            names = rule.multiple_mappings? ? rule.name : [rule.name]
+
+            value = names.collect do |rule_name|
+              if rule.root_mapping?
+                doc
+              elsif doc.key?(rule_name.to_s)
+                doc[rule_name.to_s]
+              elsif doc.key?(rule_name.to_sym)
+                doc[rule_name.to_sym]
+              else
+                attr&.default
+              end
+            end.compact.first
 
-            if rule.custom_methods[:from]
+            if rule.using_custom_methods?
               if Utils.present?(value)
                 value = new.send(rule.custom_methods[:from], instance, value)
               end
@@ -481,8 +504,9 @@ module Lutaml
               next
             end
 
-            value = apply_child_mappings(value, rule.child_mappings)
-            value = attr.cast(value, format)
+            value = translate_mappings(value, rule.hash_mappings, attr, format)
+            value = attr.cast(value, format) unless rule.hash_mappings
+            attr.valid_collection!(value, self)
 
             rule.deserialize(instance, value, attributes, self)
           end
@@ -567,7 +591,7 @@ module Lutaml
 
         self.class.attributes.each do |name, attr|
           value = if attrs.key?(name) || attrs.key?(name.to_s)
-                    self.class.attr_value(attrs, name, attr)
+                    attr_value(attrs, name, attr)
                   else
                     using_default_for(name)
                     attr.default
@@ -584,6 +608,32 @@ module Lutaml
         end
       end
 
+      def attr_value(attrs, name, attr_rule)
+        value = if attrs.key?(name.to_sym)
+                  attrs[name.to_sym]
+                elsif attrs.key?(name.to_s)
+                  attrs[name.to_s]
+                else
+                  attr_rule.default
+                end
+
+        if attr_rule.collection? || value.is_a?(Array)
+          (value || []).map do |v|
+            if v.is_a?(Hash)
+              attr_rule.type.new(v)
+            else
+              # TODO: This code is problematic because Type.cast does not know
+              # about all the types.
+              Lutaml::Model::Type.cast(v, attr_rule.type)
+            end
+          end
+        else
+          # TODO: This code is problematic because Type.cast does not know
+          # about all the types.
+          Lutaml::Model::Type.cast(value, attr_rule.type)
+        end
+      end
+
       def using_default_for(attribute_name)
         @using_default[attribute_name] = true
       end

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

@@ -36,6 +36,11 @@ module Lutaml
             raise TypeNotEnabledError.new("Decimal", value)
           end
         end
+
+        # Override to avoid serializing ruby object in YAML
+        def to_yaml
+          value&.to_s("F")
+        end
       end
     end
   end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.4.0"
+    VERSION = "0.5.1"
   end
 end

data/lib/lutaml/model/xml_adapter/builder/nokogiri.rb

@@ -39,6 +39,7 @@ module Lutaml
           )
             add_namespace_prefix(prefix)
 
+            element_name = element_name.first if element_name.is_a?(Array)
             element_name = "#{element_name}_" if respond_to?(element_name)
 
             if block_given?