lutaml-model 0.3.10 → 0.3.14

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

@@ -55,6 +55,7 @@ module Lutaml
             end
 
             index_hash = {}
+            content = []
 
             element.element_order.each do |name|
               index_hash[name] ||= -1
@@ -68,15 +69,20 @@ module Lutaml
               value = attribute_value_for(element, element_rule)
 
               if element_rule == xml_mapping.content_mapping
-                text = element.send(xml_mapping.content_mapping.to)
+                text = xml_mapping.content_mapping.serialize(element)
                 text = text[curr_index] if text.is_a?(Array)
 
-                prefixed_xml.text text
+                if element.mixed?
+                  prefixed_xml.text text
+                else
+                  content << text
+                end
               elsif !value.nil? || element_rule.render_nil?
                 value = value[curr_index] if attribute_def.collection?
 
                 add_to_xml(
                   xml,
+                  element,
                   element_rule.prefix,
                   value,
                   options.merge(
@@ -86,12 +92,14 @@ module Lutaml
                 )
               end
             end
+
+            prefixed_xml.text content.join
           end
         end
       end
 
       class NokogiriElement < XmlElement
-        def initialize(node, root_node: nil)
+        def initialize(node, root_node: nil, default_namespace: nil)
           if root_node
             node.namespaces.each do |prefix, name|
               namespace = XmlNamespace.new(name, prefix)
@@ -115,14 +123,15 @@ module Lutaml
               namespace_prefix: attr.namespace&.prefix,
             )
           end
-
+          default_namespace = node.namespace&.href if root_node.nil?
           super(
             node.name,
             attributes,
-            parse_all_children(node, root_node: root_node || self),
+            parse_all_children(node, root_node: root_node || self, default_namespace: default_namespace),
             node.text,
             parent_document: root_node,
             namespace_prefix: node.namespace&.prefix,
+            default_namespace: default_namespace
           )
         end
 
@@ -137,8 +146,10 @@ module Lutaml
           if name == "text"
             builder.text(text)
           else
-            builder.send(name, build_attributes(self)) do |xml|
-              children.each { |child| child.to_xml(xml) }
+            builder.public_send(name, build_attributes(self)) do |xml|
+              children.each do |child|
+                child.to_xml(xml)
+              end
             end
           end
 
@@ -153,9 +164,9 @@ module Lutaml
           end
         end
 
-        def parse_all_children(node, root_node: nil)
+        def parse_all_children(node, root_node: nil, default_namespace: nil)
           node.children.map do |child|
-            NokogiriElement.new(child, root_node: root_node)
+            NokogiriElement.new(child, root_node: root_node, default_namespace: default_namespace)
           end
         end
 

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

@@ -42,6 +42,7 @@ module Lutaml
           builder.create_and_add_element(tag_name,
                                          attributes: attributes) do |el|
             index_hash = {}
+            content = []
 
             element.element_order.each do |name|
               index_hash[name] ||= -1
@@ -58,12 +59,17 @@ module Lutaml
                 text = element.send(xml_mapping.content_mapping.to)
                 text = text[curr_index] if text.is_a?(Array)
 
-                el.add_text(el, text)
+                if element.mixed?
+                  el.add_text(el, text)
+                else
+                  content << text
+                end
               elsif !value.nil? || element_rule.render_nil?
                 value = value[curr_index] if attribute_def.collection?
 
                 add_to_xml(
                   el,
+                  element,
                   nil,
                   value,
                   options.merge(
@@ -73,6 +79,8 @@ module Lutaml
                 )
               end
             end
+
+            el.add_text(el, content.join)
           end
         end
       end

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

@@ -21,6 +21,16 @@ module Lutaml
             name
           end
         end
+
+        def namespaced_name
+          if unprefixed_name == "lang"
+            name
+          elsif namespace
+            "#{namespace}:#{unprefixed_name}"
+          else
+            unprefixed_name
+          end
+        end
       end
     end
   end

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

@@ -66,24 +66,43 @@ module Lutaml
           options[:tag_name] = rule.name
 
           options[:mapper_class] = attribute&.type if attribute
+          options[:namespace_set] = set_namespace?(rule)
 
           options
         end
 
-        def parse_element(element)
+        def parse_element(element, klass = nil, format = nil)
           result = Lutaml::Model::MappingHash.new
           result.item_order = element.order
 
           element.children.each_with_object(result) do |child, hash|
-            value = child.text? ? child.text : parse_element(child)
+            attr = klass.attribute_for_child(child.name, format) if klass&.<= Serialize
+
+            value = if child.text?
+                      child.text
+                    elsif attr&.raw?
+                      child.children.map do |c|
+                        next c.text if c.text?
+
+                        c.to_xml.doc.root.to_xml({})
+                      end.join
+                    else
+                      parse_element(child, attr&.type || klass, format)
+                    end
 
-            hash[child.unprefixed_name] = if hash[child.unprefixed_name]
-                                            [hash[child.unprefixed_name], value].flatten
+            hash[child.namespaced_name] = if hash[child.namespaced_name]
+                                            [hash[child.namespaced_name], value].flatten
                                           else
                                             value
                                           end
           end
 
+          result.merge(attributes_hash(element))
+        end
+
+        def attributes_hash(element)
+          result = Lutaml::Model::MappingHash.new
+
           element.attributes.each_value do |attr|
             if attr.unprefixed_name == "schemaLocation"
               result["__schema_location"] = {
@@ -92,7 +111,7 @@ module Lutaml
                 schema_location: attr.value,
               }
             else
-              result[attr.unprefixed_name] = attr.value
+              result[attr.namespaced_name] = attr.value
             end
           end
 
@@ -107,10 +126,10 @@ module Lutaml
           end
         end
 
-        def add_to_xml(xml, prefix, value, options = {})
+        def add_to_xml(xml, element, prefix, value, options = {})
           if value.is_a?(Array)
             value.each do |item|
-              add_to_xml(xml, prefix, item, options)
+              add_to_xml(xml, element, prefix, item, options)
             end
 
             return
@@ -120,7 +139,7 @@ module Lutaml
           rule = options[:rule]
 
           if rule.custom_methods[:to]
-            @root.send(rule.custom_methods[:to], @root, xml.parent, xml)
+            options[:mapper_class].new.send(rule.custom_methods[:to], element, xml.parent, xml)
             return
           end
 
@@ -130,21 +149,29 @@ module Lutaml
               value,
               options.merge({ rule: rule, attribute: attribute }),
             )
-          else
+          elsif rule.prefix_set?
             xml.create_and_add_element(rule.name, prefix: prefix) do
-              if !value.nil?
-                serialized_value = attribute.type.serialize(value)
+              add_value(xml, value, attribute)
+            end
+          else
+            xml.create_and_add_element(rule.name) do
+              add_value(xml, value, attribute)
+            end
+          end
+        end
 
-                if attribute.type == Lutaml::Model::Type::Hash
-                  serialized_value.each do |key, val|
-                    xml.create_and_add_element(key) do |element|
-                      element.text(val)
-                    end
-                  end
-                else
-                  xml.add_text(xml, serialized_value)
+        def add_value(xml, value, attribute)
+          if !value.nil?
+            serialized_value = attribute.type.serialize(value)
+
+            if attribute.type == Lutaml::Model::Type::Hash
+              serialized_value.each do |key, val|
+                xml.create_and_add_element(key) do |element|
+                  element.text(val)
                 end
               end
+            else
+              xml.add_text(xml, serialized_value)
             end
           end
         end
@@ -176,21 +203,28 @@ module Lutaml
               prefixed_xml.add_namespace_prefix(nil)
             end
 
+            xml_mapping.attributes.each do |attribute_rule|
+              attribute_rule.serialize_attribute(element, prefixed_xml.parent, xml)
+            end
+
             xml_mapping.elements.each do |element_rule|
               attribute_def = attribute_definition_for(element, element_rule,
                                                        mapper_class: mapper_class)
 
-              value = attribute_value_for(element, element_rule)
+              if attribute_def
+                value = attribute_value_for(element, element_rule)
 
-              next if value.nil? && !element_rule.render_nil?
+                next if value.nil? && !element_rule.render_nil?
 
-              value = [value] if attribute_def.collection? && !value.is_a?(Array)
+                value = [value] if attribute_def.collection? && !value.is_a?(Array)
+              end
 
               add_to_xml(
                 prefixed_xml,
+                element,
                 element_rule.prefix,
                 value,
-                options.merge({ attribute: attribute_def, rule: element_rule }),
+                options.merge({ attribute: attribute_def, rule: element_rule, mapper_class: mapper_class }),
               )
             end
 
@@ -199,7 +233,7 @@ module Lutaml
                 @root.send(content_rule.custom_methods[:to], element,
                            prefixed_xml.parent, prefixed_xml)
               else
-                text = element.send(content_rule.to)
+                text = content_rule.serialize(element)
                 text = text.join if text.is_a?(Array)
                 prefixed_xml.add_text(xml, text)
               end
@@ -216,15 +250,21 @@ module Lutaml
           mapper_class ? mapper_class.mappings_for(:xml).mixed_content? : false
         end
 
-        def build_namespace_attributes(klass, processed = {})
+        def set_namespace?(rule)
+          rule.nil? || !rule.namespace_set? || !rule.namespace.nil?
+        end
+
+        def build_namespace_attributes(klass, processed = {}, options = {})
           xml_mappings = klass.mappings_for(:xml)
           attributes = klass.attributes
 
           attrs = {}
 
-          if xml_mappings.namespace_uri
-            prefixed_name = ["xmlns",
-                             xml_mappings.namespace_prefix].compact.join(":")
+          if xml_mappings.namespace_uri && set_namespace?(options[:caller_rule])
+            prefixed_name = [
+              "xmlns",
+              xml_mappings.namespace_prefix,
+            ].compact.join(":")
 
             attrs[prefixed_name] = xml_mappings.namespace_uri
           end
@@ -239,14 +279,16 @@ module Lutaml
             type = if mapping_rule.delegate
                      attributes[mapping_rule.delegate].type.attributes[mapping_rule.to].type
                    else
-                     attributes[mapping_rule.to].type
+                     attributes[mapping_rule.to]&.type
                    end
 
+            next unless type
+
             if type <= Lutaml::Model::Serialize
-              attrs = attrs.merge(build_namespace_attributes(type, processed))
+              attrs = attrs.merge(build_namespace_attributes(type, processed, { caller_rule: mapping_rule }))
             end
 
-            if mapping_rule.namespace
+            if mapping_rule.namespace && mapping_rule.prefix && mapping_rule.name != "lang"
               attrs["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
             end
           end
@@ -255,22 +297,31 @@ module Lutaml
         end
 
         def build_attributes(element, xml_mapping, options = {})
-          attrs = namespace_attributes(xml_mapping)
+          attrs = if options.fetch(:namespace_set, true)
+                    namespace_attributes(xml_mapping)
+                  else
+                    {}
+                  end
+
+          if element.respond_to?(:schema_location) && element.schema_location
+            attrs.merge!(element.schema_location.to_xml_attributes)
+          end
 
           xml_mapping.attributes.each_with_object(attrs) do |mapping_rule, hash|
             next if options[:except]&.include?(mapping_rule.to)
+            next if mapping_rule.custom_methods[:to]
 
-            if mapping_rule.namespace
+            if mapping_rule.namespace && mapping_rule.prefix && mapping_rule.name != "lang"
               hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
             end
 
-            hash[mapping_rule.prefixed_name] = element.send(mapping_rule.to)
+            hash[mapping_rule.prefixed_name] = mapping_rule.to_value_for(element)
           end
 
           xml_mapping.elements.each_with_object(attrs) do |mapping_rule, hash|
             next if options[:except]&.include?(mapping_rule.to)
 
-            if mapping_rule.namespace
+            if mapping_rule.namespace && mapping_rule.prefix
               hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
             end
           end

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

@@ -16,7 +16,8 @@ module Lutaml
           children = [],
           text = nil,
           parent_document: nil,
-          namespace_prefix: nil
+          namespace_prefix: nil,
+          default_namespace: nil
         )
           @name = extract_name(name)
           @namespace_prefix = namespace_prefix || extract_namespace_prefix(name)
@@ -24,11 +25,20 @@ module Lutaml
           @children = children
           @text = text
           @parent_document = parent_document
+          @default_namespace = default_namespace
         end
 
         def name
-          if namespace_prefix
-            "#{namespace_prefix}:#{@name}"
+          return @name unless namespace_prefix
+
+          "#{namespace_prefix}:#{@name}"
+        end
+
+        def namespaced_name
+          if namespaces[namespace_prefix] && !text?
+            "#{namespaces[namespace_prefix].uri}:#{@name}"
+          elsif @default_namespace && !text?
+            "#{@default_namespace}:#{name}"
           else
             @name
           end

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

@@ -37,7 +37,7 @@ module Lutaml
         end
 
         def attr_name
-          if prefix && !prefix.empty?
+          if Utils.present?(prefix)
             "xmlns:#{prefix}"
           else
             "xmlns"

data/lib/lutaml/model/xml_mapping.rb

@@ -6,7 +6,8 @@ module Lutaml
       attr_reader :root_element,
                   :namespace_uri,
                   :namespace_prefix,
-                  :mixed_content
+                  :mixed_content,
+                  :ordered
 
       def initialize
         @elements = {}
@@ -16,10 +17,12 @@ module Lutaml
       end
 
       alias mixed_content? mixed_content
+      alias ordered? ordered
 
-      def root(name, mixed: false)
+      def root(name, mixed: false, ordered: false)
         @root_element = name
         @mixed_content = mixed
+        @ordered = ordered || mixed # mixed contenet will always be ordered
       end
 
       def prefixed_root
@@ -38,37 +41,46 @@ module Lutaml
       # rubocop:disable Metrics/ParameterLists
       def map_element(
         name,
-        to:,
+        to: nil,
         render_nil: false,
         with: {},
         delegate: nil,
         namespace: (namespace_set = false
                     nil),
-        prefix: nil
+        prefix: (prefix_set = false
+                 nil)
       )
-        @elements[name] = XmlMappingRule.new(
+        validate!(name, to, with)
+
+        rule = XmlMappingRule.new(
           name,
           to: to,
           render_nil: render_nil,
           with: with,
           delegate: delegate,
           namespace: namespace,
+          default_namespace: namespace_uri,
           prefix: prefix,
           namespace_set: namespace_set != false,
+          prefix_set: prefix_set != false,
         )
+        @elements[rule.namespaced_name] = rule
       end
 
       def map_attribute(
         name,
-        to:,
+        to: nil,
         render_nil: false,
         with: {},
         delegate: nil,
         namespace: (namespace_set = false
                     nil),
-        prefix: nil
+        prefix: (prefix_set = false
+                 nil)
       )
-        @attributes[name] = XmlMappingRule.new(
+        validate!(name, to, with)
+
+        rule = XmlMappingRule.new(
           name,
           to: to,
           render_nil: render_nil,
@@ -76,19 +88,25 @@ module Lutaml
           delegate: delegate,
           namespace: namespace,
           prefix: prefix,
+          attribute: true,
+          default_namespace: namespace_uri,
           namespace_set: namespace_set != false,
+          prefix_set: prefix_set != false,
         )
+        @attributes[rule.namespaced_name] = rule
       end
 
       # rubocop:enable Metrics/ParameterLists
 
       def map_content(
-        to:,
+        to: nil,
         render_nil: false,
         with: {},
         delegate: nil,
         mixed: false
       )
+        validate!("content", to, with)
+
         @content_mapping = XmlMappingRule.new(
           nil,
           to: to,
@@ -99,6 +117,18 @@ module Lutaml
         )
       end
 
+      def validate!(key, to, with)
+        if to.nil? && with.empty?
+          msg = ":to or :with argument is required for mapping '#{key}'"
+          raise IncorrectMappingArgumentsError.new(msg)
+        end
+
+        if !with.empty? && (with[:from].nil? || with[:to].nil?)
+          msg = ":with argument for mapping '#{key}' requires :to and :from keys"
+          raise IncorrectMappingArgumentsError.new(msg)
+        end
+      end
+
       def elements
         @elements.values
       end
@@ -136,6 +166,27 @@ module Lutaml
           end
         end
       end
+
+      def deep_dup
+        self.class.new.tap do |xml_mapping|
+          xml_mapping.root(@root_element.dup, mixed: @mixed_content, ordered: @ordered)
+          xml_mapping.namespace(@namespace_uri.dup, @namespace_prefix.dup)
+
+          xml_mapping.instance_variable_set(:@attributes, dup_mappings(@attributes))
+          xml_mapping.instance_variable_set(:@elements, dup_mappings(@elements))
+          xml_mapping.instance_variable_set(:@content_mapping, @content_mapping&.deep_dup)
+        end
+      end
+
+      def dup_mappings(mappings)
+        new_mappings = {}
+
+        mappings.each do |key, mapping_rule|
+          new_mappings[key] = mapping_rule.deep_dup
+        end
+
+        new_mappings
+      end
     end
   end
 end

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -3,7 +3,7 @@ require_relative "mapping_rule"
 module Lutaml
   module Model
     class XmlMappingRule < MappingRule
-      attr_reader :namespace, :prefix
+      attr_reader :namespace, :prefix, :mixed_content, :default_namespace
 
       def initialize(
         name,
@@ -14,7 +14,10 @@ module Lutaml
         namespace: nil,
         prefix: nil,
         mixed_content: false,
-        namespace_set: false
+        namespace_set: false,
+        prefix_set: false,
+        attribute: false,
+        default_namespace: nil
       )
         super(
           name,
@@ -22,8 +25,7 @@ module Lutaml
           render_nil: render_nil,
           with: with,
           delegate: delegate,
-          mixed_content: mixed_content,
-          namespace_set: namespace_set,
+          attribute: attribute,
         )
 
         @namespace = if namespace.to_s == "inherit"
@@ -33,6 +35,64 @@ module Lutaml
                        namespace
                      end
         @prefix = prefix
+        @mixed_content = mixed_content
+
+        @default_namespace = default_namespace
+
+        @namespace_set = namespace_set
+        @prefix_set = prefix_set
+      end
+
+      def namespace_set?
+        !!@namespace_set
+      end
+
+      def prefix_set?
+        !!@prefix_set
+      end
+
+      def content_mapping?
+        name.nil?
+      end
+
+      def mixed_content?
+        !!@mixed_content
+      end
+
+      def prefixed_name
+        if prefix
+          "#{prefix}:#{name}"
+        else
+          name
+        end
+      end
+
+      def namespaced_name
+        if name == "lang"
+          "#{prefix}:#{name}"
+        elsif namespace_set? || @attribute
+          [namespace, name].compact.join(":")
+        elsif default_namespace
+          "#{default_namespace}:#{name}"
+        else
+          name
+        end
+      end
+
+      def deep_dup
+        self.class.new(
+          name.dup,
+          to: to,
+          render_nil: render_nil,
+          with: Utils.deep_dup(custom_methods),
+          delegate: delegate,
+          namespace: namespace.dup,
+          prefix: prefix.dup,
+          mixed_content: mixed_content,
+          namespace_set: namespace_set?,
+          prefix_set: prefix_set?,
+          default_namespace: default_namespace.dup,
+        )
       end
     end
   end

data/lib/lutaml/model/yaml_adapter/standard_yaml_adapter.rb

@@ -5,12 +5,17 @@ module Lutaml
   module Model
     module YamlAdapter
       class StandardYamlAdapter < YamlDocument
+        PERMITTED_CLASSES_BASE = [Date, Time, DateTime, Symbol, Hash,
+                                  Array].freeze
+
+        PERMITTED_CLASSES = if defined?(BigDecimal)
+                              PERMITTED_CLASSES_BASE + [BigDecimal]
+                            else
+                              PERMITTED_CLASSES_BASE
+                            end.freeze
+
         def self.parse(yaml)
-          YAML.safe_load(
-            yaml,
-            permitted_classes: [Date, Time, DateTime, Symbol,
-                                BigDecimal, Hash, Array],
-          )
+          YAML.safe_load(yaml, permitted_classes: PERMITTED_CLASSES)
         end
 
         def to_yaml(options = {})