lutaml-model 0.3.10 → 0.3.14

data/lib/lutaml/model/key_value_mapping_rule.rb

@@ -3,7 +3,37 @@ require_relative "mapping_rule"
 module Lutaml
   module Model
     class KeyValueMappingRule < MappingRule
-      # No additional attributes or methods required for now
+      attr_reader :child_mappings
+
+      def initialize(
+        name,
+        to:,
+        render_nil: false,
+        with: {},
+        delegate: nil,
+        child_mappings: nil
+      )
+        super(
+          name,
+          to: to,
+          render_nil: render_nil,
+          with: with,
+          delegate: delegate,
+        )
+
+        @child_mappings = child_mappings
+      end
+
+      def deep_dup
+        self.class.new(
+          name.dup,
+          to: to.dup,
+          render_nil: render_nil.dup,
+          with: Utils.deep_dup(custom_methods),
+          delegate: delegate,
+          child_mappings: Utils.deep_dup(child_mappings),
+        )
+      end
     end
   end
 end

data/lib/lutaml/model/mapping_hash.rb

@@ -14,6 +14,14 @@ module Lutaml
         @item_order&.map { |key| normalize(key) } || keys
       end
 
+      def fetch(key)
+        self[key.to_s] || self[key.to_sym]
+      end
+
+      def key_exist?(key)
+        key?(key.to_s) || key?(key.to_sym)
+      end
+
       def item_order=(order)
         raise "`item order` must be an array" unless order.is_a?(Array)
 
@@ -24,6 +32,20 @@ module Lutaml
         @ordered
       end
 
+      def method_missing(method_name, *args)
+        value = self[method_name] || self[method_name.to_s]
+        return value if value
+
+        super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        key_present = key?(method_name) || key?(method_name.to_s)
+        return true if key_present
+
+        super
+      end
+
       private
 
       def normalize(key)

data/lib/lutaml/model/mapping_rule.rb

@@ -5,59 +5,65 @@ module Lutaml
                   :to,
                   :render_nil,
                   :custom_methods,
-                  :delegate,
-                  :mixed_content,
-                  :child_mappings
+                  :delegate
 
       def initialize(
         name,
         to:,
         render_nil: false,
         with: {},
-        delegate: nil,
-        mixed_content: false,
-        namespace_set: false,
-        child_mappings: nil
+        attribute: false,
+        delegate: nil
       )
         @name = name
         @to = to
         @render_nil = render_nil
         @custom_methods = with
+        @attribute = attribute
         @delegate = delegate
-        @mixed_content = mixed_content
-        @namespace_set = namespace_set
-        @child_mappings = child_mappings
       end
 
       alias from name
       alias render_nil? render_nil
 
-      def prefixed_name
-        if prefix
-          "#{prefix}:#{name}"
+      def serialize_attribute(model, element, doc)
+        if custom_methods[:to]
+          model.send(custom_methods[:to], model, element, doc)
+        end
+      end
+
+      def to_value_for(model)
+        if delegate
+          model.public_send(delegate).public_send(to)
         else
-          name
+          model.public_send(to)
         end
       end
 
-      def serialize(model, value)
+      def serialize(model, parent = nil, doc = nil)
         if custom_methods[:to]
-          model.send(custom_methods[:to], model, value)
+          model.send(custom_methods[:to], model, parent, doc)
         else
-          value
+          to_value_for(model)
         end
       end
 
-      def deserialize(model, doc)
+      def deserialize(model, value, attributes, mapper_class = nil)
         if custom_methods[:from]
-          model.send(custom_methods[:from], model, doc)
+          mapper_class.new.send(custom_methods[:from], model, value)
+        elsif delegate
+          if model.public_send(delegate).nil?
+            model.public_send(:"#{delegate}=", attributes[delegate].type.new)
+          end
+
+          model.public_send(delegate).public_send(:"#{to}=", value)
         else
-          doc[name.to_s]
+          model.public_send(:"#{to}=", value)
         end
       end
 
-      def namespace_set?
-        @namespace_set
+      def deep_dup
+        raise NotImplementedError, "Subclasses must implement `deep_dup`."
       end
     end
   end

data/lib/lutaml/model/serialize.rb

@@ -11,6 +11,7 @@ require_relative "json_adapter"
 require_relative "comparable_model"
 require_relative "schema_location"
 require_relative "validation"
+require_relative "error"
 
 module Lutaml
   module Model
@@ -31,19 +32,50 @@ module Lutaml
           @mappings ||= {}
           @attributes ||= {}
 
-          subclass.instance_variable_set(:@attributes, @attributes.dup)
-          subclass.instance_variable_set(:@mappings, @mappings.dup)
+          subclass.instance_variable_set(:@attributes, Utils.deep_dup(@attributes))
+          subclass.instance_variable_set(:@mappings, Utils.deep_dup(@mappings))
           subclass.instance_variable_set(:@model, subclass)
         end
 
         def model(klass = nil)
           if klass
             @model = klass
+            add_order_handling_methods_to_model(klass)
           else
             @model
           end
         end
 
+        def add_order_handling_methods_to_model(klass)
+          Utils.add_method_if_not_defined(klass, :ordered=) do |ordered|
+            @ordered = ordered
+          end
+
+          Utils.add_method_if_not_defined(klass, :ordered?) do
+            !!@ordered
+          end
+
+          Utils.add_method_if_not_defined(klass, :mixed=) do |mixed|
+            @mixed = mixed
+          end
+
+          Utils.add_method_if_not_defined(klass, :mixed?) do
+            !!@mixed
+          end
+
+          Utils.add_method_if_not_defined(klass, :element_order=) do |order|
+            @element_order = order
+          end
+
+          Utils.add_method_if_not_defined(klass, :element_order) do
+            @element_order
+          end
+        end
+
+        def cast(value)
+          value
+        end
+
         # Define an attribute for the model
         def attribute(name, type, options = {})
           attr = Attribute.new(name, type, options)
@@ -54,15 +86,14 @@ module Lutaml
           end
 
           define_method(:"#{name}=") do |value|
-            instance_variable_set(:"@#{name}", value)
-            # validate!(name)
+            instance_variable_set(:"@#{name}", attr.cast_value(value))
           end
         end
 
         Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
           define_method(format) do |&block|
             klass = format == :xml ? XmlMapping : KeyValueMapping
-            mappings[format] = klass.new
+            mappings[format] ||= klass.new
             mappings[format].instance_eval(&block)
 
             if format == :xml && !mappings[format].root_element
@@ -74,17 +105,22 @@ module Lutaml
             adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
 
             doc = adapter.parse(data)
-            public_send(:"of_#{format}", doc.to_h)
+            public_send(:"of_#{format}", doc)
           end
 
-          define_method(:"of_#{format}") do |hash|
-            if hash.is_a?(Array)
-              return hash.map do |item|
-                       apply_mappings(item, format)
+          define_method(:"of_#{format}") do |doc|
+            if doc.is_a?(Array)
+              return doc.map do |item|
+                       send(:"of_#{format}", item)
                      end
             end
 
-            apply_mappings(hash, format)
+            if format == :xml
+              doc_hash = doc.parse_element(doc.root, self, :xml)
+              apply_mappings(doc_hash, format)
+            else
+              apply_mappings(doc.to_h, format)
+            end
           end
 
           define_method(:"to_#{format}") do |instance|
@@ -185,6 +221,7 @@ module Lutaml
 
         def default_mappings(format)
           klass = format == :xml ? XmlMapping : KeyValueMapping
+
           klass.new.tap do |mapping|
             attributes&.each do |name, attr|
               mapping.map_element(
@@ -193,6 +230,8 @@ module Lutaml
                 render_nil: attr.render_nil?,
               )
             end
+
+            mapping.root(to_s.split("::").last) if format == :xml
           end
         end
 
@@ -242,20 +281,34 @@ module Lutaml
           hash
         end
 
+        def valid_rule?(rule)
+          attribute = attribute_for_rule(rule)
+
+          !!attribute || rule.custom_methods[:from]
+        end
+
+        def attribute_for_rule(rule)
+          return attributes[rule.to] unless rule.delegate
+
+          attributes[rule.delegate].type.attributes[rule.to]
+        end
+
+        def attribute_for_child(child_name, format)
+          mapping_rule = mappings_for(format).find_by_name(child_name)
+
+          attribute_for_rule(mapping_rule) if mapping_rule
+        end
+
         def apply_mappings(doc, format, options = {})
           instance = options[:instance] || model.new
-          return instance if !doc || doc.empty?
+          return instance if Utils.blank?(doc)
           return apply_xml_mapping(doc, instance, options) if format == :xml
 
           mappings = mappings_for(format).mappings
           mappings.each do |rule|
-            attr = if rule.delegate
-                     attributes[rule.delegate].type.attributes[rule.to]
-                   else
-                     attributes[rule.to]
-                   end
+            raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
 
-            raise "Attribute '#{rule.to}' not found in #{self}" unless attr
+            attr = attribute_for_rule(rule)
 
             value = if doc.key?(rule.name) || doc.key?(rule.name.to_sym)
                       doc[rule.name] || doc[rule.name.to_sym]
@@ -264,26 +317,17 @@ module Lutaml
                     end
 
             if rule.custom_methods[:from]
-              if value && !value.empty?
-                value = new.send(rule.custom_methods[:from], instance,
-                                 value)
+              if Utils.present?(value)
+                value = new.send(rule.custom_methods[:from], instance, value)
               end
+
               next
             end
 
             value = apply_child_mappings(value, rule.child_mappings)
             value = attr.cast(value, format)
 
-            if rule.delegate
-              if instance.public_send(rule.delegate).nil?
-                instance.public_send(:"#{rule.delegate}=",
-                                     attributes[rule.delegate].type.new)
-              end
-              instance.public_send(rule.delegate).public_send(:"#{rule.to}=",
-                                                              value)
-            else
-              instance.public_send(:"#{rule.to}=", value)
-            end
+            rule.deserialize(instance, value, attributes, self)
           end
 
           instance
@@ -301,7 +345,8 @@ module Lutaml
 
           if instance.respond_to?(:ordered=) && doc.is_a?(Lutaml::Model::MappingHash)
             instance.element_order = doc.item_order
-            instance.ordered = mappings_for(:xml).mixed_content? || options[:mixed_content]
+            instance.ordered = mappings_for(:xml).ordered? || options[:ordered]
+            instance.mixed = mappings_for(:xml).mixed_content? || options[:mixed_content]
           end
 
           if doc["__schema_location"]
@@ -313,44 +358,55 @@ module Lutaml
           end
 
           mappings.each do |rule|
-            attr = attributes[rule.to]
-            raise "Attribute '#{rule.to}' not found in #{self}" unless attr
-
-            is_content_mapping = rule.name.nil?
+            raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
 
-            value = if is_content_mapping
+            value = if rule.content_mapping?
                       doc["text"]
+                    elsif doc.key_exist?(rule.namespaced_name)
+                      doc.fetch(rule.namespaced_name)
                     else
-                      doc[rule.name.to_s] || doc[rule.name.to_sym]
+                      rule.to_value_for(instance)
                     end
 
-            value = [value].compact if attr.collection? && !value.is_a?(Array)
+            value = normalize_xml_value(value, rule)
+            rule.deserialize(instance, value, attributes, self)
+          end
 
-            if value.is_a?(Array)
-              value = value.map do |v|
-                v.is_a?(Hash) && !(attr.type <= Serialize) ? v["text"] : v
-              end
-            elsif !(attr.type <= Serialize) && value.is_a?(Hash) && attr.type != Lutaml::Model::Type::Hash
-              value = value["text"]
-            end
+          instance
+        end
 
-            unless is_content_mapping
-              value = attr.cast(
-                value,
-                :xml,
-                caller_class: self,
-                mixed_content: rule.mixed_content,
-              )
-            end
+        def normalize_xml_value(value, rule)
+          attr = attribute_for_rule(rule)
 
-            if rule.custom_methods[:from]
-              new.send(rule.custom_methods[:from], instance, value)
-            else
-              instance.public_send(:"#{rule.to}=", value)
-            end
+          value = [value].compact if attr&.collection? && !value.is_a?(Array)
+
+          value = if value.is_a?(Array)
+                    value.map do |v|
+                      text_hash?(attr, v) ? v["text"] : v
+                    end
+                  elsif text_hash?(attr, value)
+                    value["text"]
+                  else
+                    value
+                  end
+
+          if attr && !rule.content_mapping?
+            value = attr.cast(
+              value,
+              :xml,
+              caller_class: self,
+              mixed_content: rule.mixed_content,
+            )
           end
 
-          instance
+          value
+        end
+
+        def text_hash?(attr, value)
+          return false unless value.is_a?(Hash)
+          return value.keys == ["text"] unless attr
+
+          !(attr.type <= Serialize) && attr.type != Lutaml::Model::Type::Hash
         end
 
         def ensure_utf8(value)
@@ -373,6 +429,7 @@ module Lutaml
       end
 
       attr_accessor :element_order, :schema_location
+      attr_writer :ordered, :mixed
 
       def initialize(attrs = {})
         @validate_on_set = attrs.delete(:validate_on_set) || false
@@ -422,11 +479,11 @@ module Lutaml
       end
 
       def ordered?
-        @ordered
+        !!@ordered
       end
 
-      def ordered=(ordered)
-        @ordered = ordered
+      def mixed?
+        !!@mixed
       end
 
       def key_exist?(hash, key)
@@ -439,7 +496,6 @@ module Lutaml
 
       Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
         define_method(:"to_#{format}") do |options = {}|
-          validate!
           adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
           representation = if format == :xml
                              self

data/lib/lutaml/model/type.rb

@@ -62,6 +62,10 @@ module Lutaml
         when "Boolean"
           to_boolean(value)
         when "Decimal"
+          unless defined?(BigDecimal)
+            raise Lutaml::Model::TypeNotEnabledError.new("Decimal", value)
+          end
+
           BigDecimal(value.to_s)
         when "Hash"
           normalize_hash(Hash(value))
@@ -85,6 +89,10 @@ module Lutaml
         when "Boolean"
           to_boolean(value)
         when "Decimal"
+          unless defined?(BigDecimal)
+            raise Lutaml::Model::TypeNotEnabledError.new("Decimal", value)
+          end
+
           value.to_s("F")
         when "Hash"
           Hash(value)
@@ -108,6 +116,8 @@ module Lutaml
       def self.normalize_hash(hash)
         return hash["text"] if hash.keys == ["text"]
 
+        hash = hash.to_h if hash.is_a?(Lutaml::Model::MappingHash)
+
         hash.filter_map do |key, value|
           next if key == "text"
 

data/lib/lutaml/model/utils.rb

@@ -34,6 +34,40 @@ module Lutaml
             .downcase
         end
 
+        def present?(value)
+          !blank?(value)
+        end
+
+        def blank?(value)
+          value.respond_to?(:empty?) ? value.empty? : !value
+        end
+
+        def add_method_if_not_defined(klass, method_name, &block)
+          unless klass.method_defined?(method_name)
+            klass.class_eval do
+              define_method(method_name, &block)
+            end
+          end
+        end
+
+        def deep_dup(hash)
+          return hash if hash.nil?
+
+          new_hash = {}
+
+          hash.each do |key, value|
+            new_hash[key] = if value.is_a?(Hash)
+                              deep_dup(value)
+                            elsif value.respond_to?(:deep_dup)
+                              value.deep_dup
+                            else
+                              value.dup
+                            end
+          end
+
+          new_hash
+        end
+
         private
 
         def camelize_part(part)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.10"
+    VERSION = "0.3.14"
   end
 end

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

@@ -27,11 +27,21 @@ module Lutaml
             element.add_child(child)
           end
 
-          def create_and_add_element(element_name, prefix: nil, attributes: {})
-            add_namespace_prefix(prefix) if prefix
+          def add_attribute(element, name, value)
+            element[name] = value
+          end
+
+          def create_and_add_element(
+            element_name,
+            prefix: (prefix_unset = true
+                     nil),
+            attributes: {}
+          )
+            add_namespace_prefix(prefix)
 
             if block_given?
               public_send(element_name, attributes) do
+                xml.parent.namespace = nil if prefix.nil? && !prefix_unset
                 yield(self)
               end
             else
@@ -53,11 +63,9 @@ module Lutaml
             self
           end
 
-          def method_missing(method_name, *args)
+          def method_missing(method_name, *args, &block)
             if block_given?
-              xml.public_send(method_name, *args) do
-                yield(xml)
-              end
+              xml.public_send(method_name, *args, &block)
             else
               xml.public_send(method_name, *args)
             end

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

@@ -38,6 +38,10 @@ module Lutaml
             element << child
           end
 
+          def add_attribute(element, name, value)
+            element[name] = value
+          end
+
           def create_and_add_element(element_name, prefix: nil, attributes: {})
             prefixed_name = if prefix
                               "#{prefix}:#{element_name}"