lutaml-model 0.5.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,28 +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}'"
@@ -42,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
@@ -53,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,
@@ -13,7 +14,7 @@ module Lutaml
         with: {},
         delegate: nil,
         child_mappings: nil,
-        id: nil
+        root_mappings: nil
       )
         super(
           name,
@@ -21,11 +22,17 @@ module Lutaml
           render_nil: render_nil,
           render_default: render_default,
           with: with,
-          delegate: delegate,
-          id: id
+          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
@@ -38,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

@@ -17,7 +17,7 @@ module Lutaml
         with: {},
         attribute: false,
         delegate: nil,
-        id: nil
+        root_mappings: nil
       )
         @name = name
         @to = to
@@ -26,7 +26,7 @@ module Lutaml
         @custom_methods = with
         @attribute = attribute
         @delegate = delegate
-        @id = id
+        @root_mappings = root_mappings
       end
 
       alias from name

data/lib/lutaml/model/serialize.rb

@@ -271,8 +271,10 @@ module Lutaml
 
             attribute = attributes[name]
 
+            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, rule.child_mappings)
+                      generate_hash_from_child_mappings(value, format, rule.child_mappings)
                     else
                       attribute.serialize(value, format, options)
                     end
@@ -313,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
@@ -327,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
 
@@ -380,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
 
@@ -393,10 +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)
@@ -443,8 +475,8 @@ 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)
 
@@ -453,7 +485,9 @@ module Lutaml
             names = rule.multiple_mappings? ? rule.name : [rule.name]
 
             value = names.collect do |rule_name|
-              if doc.key?(rule_name.to_s)
+              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]
@@ -470,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

data/lib/lutaml/model/version.rb

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

data/lib/lutaml/model/xml_adapter/xml_document.rb

@@ -109,9 +109,9 @@ module Lutaml
                 prefix: attr.namespace_prefix,
                 schema_location: attr.value,
               }
-            else
-              result[attr.namespaced_name] = attr.value
             end
+
+            result[attr.namespaced_name] = attr.value
           end
 
           result
@@ -328,7 +328,7 @@ module Lutaml
                     {}
                   end
 
-          if element.respond_to?(:schema_location) && element.schema_location && !options[:except]&.include?(:schema_location)
+          if element.respond_to?(:schema_location) && element.schema_location.is_a?(Lutaml::Model::SchemaLocation) && !options[:except]&.include?(:schema_location)
             attrs.merge!(element.schema_location.to_xml_attributes)
           end
 

data/lib/lutaml/model/xml_mapping.rb

@@ -3,6 +3,8 @@ require_relative "xml_mapping_rule"
 module Lutaml
   module Model
     class XmlMapping
+      include Lutaml::Model::Loggable
+
       TYPES = {
         attribute: :map_attribute,
         element: :map_element,
@@ -92,6 +94,8 @@ module Lutaml
                  nil)
       )
         validate!(name, to, with, type: TYPES[:attribute])
+        warn_auto_handling(name) if name == "schemaLocation"
+
         rule = XmlMappingRule.new(
           name,
           to: to,

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -19,8 +19,7 @@ module Lutaml
         namespace_set: false,
         prefix_set: false,
         attribute: false,
-        default_namespace: nil,
-        id: nil
+        default_namespace: nil
       )
         super(
           name,
@@ -29,8 +28,7 @@ module Lutaml
           render_default: render_default,
           with: with,
           delegate: delegate,
-          attribute: attribute,
-          id: id
+          attribute: attribute
         )
 
         @namespace = if namespace.to_s == "inherit"
@@ -47,7 +45,6 @@ module Lutaml
 
         @namespace_set = namespace_set
         @prefix_set = prefix_set
-        @id = id
       end
 
       def namespace_set?

data/lib/lutaml/model.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "model/version"
+require_relative "model/loggable"
 require_relative "model/type"
 require_relative "model/utils"
 require_relative "model/serializable"