lutaml-model 0.3.11 → 0.3.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91ff48fd66cf1435e5e18508b24cc24f7cc92dc8b5d1619c7796932eb21dcea2
-  data.tar.gz: 51eabdb2aede716ce86cea46325cad0b7b9f0da98df3235fc3b8596fe9f96bd9
+  metadata.gz: 59ac2ffbc292a5e34dbbbf79441a8220a48954ba5acd21d2780235281bfbbee2
+  data.tar.gz: 253892694acb1359120e6401d83e05bc2daa2f371b69f667210c048c08f2336c
 SHA512:
-  metadata.gz: 3ce25727c43d1c25f97e49c529c9ded5f51d8f2c13ae2766dba8c94d2c1d9a7c646bad564bfb9cd4c5555ee71395f6ff39023268e9e92044f10985c20dd826ca
-  data.tar.gz: edf1d699e944a2427b947e1a262258e93623c44bc765a5f5497c13bd4d806984722ececd6318254c15196d435b2b809f44389a1be1d9cd5f33e005169b232eaf
+  metadata.gz: 920de33ce2cc20336fa2ed87c3a2d5743f4016c8a400a881c91e4eafee0452e3fdc110429f3e71b7216f84694e546b26848c50323bc25397d32c8a1aa2e6901e
+  data.tar.gz: 3685a35624c0c355ee457241a308bf9e46c37c9a7b14994948a897c9210a13229c2a2832d8f595b2d83a4bf96660f1ea2b9843c83ea8ba9a73978ef67e864818

data/.rubocop_todo.yml

@@ -1,12 +1,12 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2024-09-23 15:00:23 UTC using RuboCop version 1.65.1.
+# on 2024-10-23 12:15:48 UTC using RuboCop version 1.66.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 100
+# Offense count: 139
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, AllowedPatterns.
 # URISchemes: http, https
@@ -30,7 +30,7 @@ Lint/DuplicateMethods:
   Exclude:
     - 'lib/lutaml/model/attribute.rb'
 
-# Offense count: 34
+# Offense count: 37
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Exclude:
@@ -44,14 +44,15 @@ Metrics/AbcSize:
     - 'lib/lutaml/model/xml_adapter/nokogiri_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
+    - 'lib/lutaml/model/xml_mapping_rule.rb'
 
-# Offense count: 4
+# Offense count: 6
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns, inherit_mode.
 # AllowedMethods: refine
 Metrics/BlockLength:
-  Max: 42
+  Max: 47
 
-# Offense count: 26
+# Offense count: 27
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Exclude:
@@ -63,7 +64,7 @@ Metrics/CyclomaticComplexity:
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
 
-# Offense count: 45
+# Offense count: 50
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 51
@@ -71,7 +72,7 @@ Metrics/MethodLength:
 # Offense count: 4
 # Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
 Metrics/ParameterLists:
-  Max: 10
+  Max: 13
 
 # Offense count: 22
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
@@ -84,7 +85,7 @@ Metrics/PerceivedComplexity:
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
 
-# Offense count: 7
+# Offense count: 8
 # Configuration parameters: Prefixes, AllowedPatterns.
 # Prefixes: when, with, without
 RSpec/ContextWording:
@@ -93,8 +94,9 @@ RSpec/ContextWording:
     - 'spec/lutaml/model/xml_adapter/oga_adapter_spec.rb'
     - 'spec/lutaml/model/xml_adapter/ox_adapter_spec.rb'
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
+    - 'spec/lutaml/model/xml_mapping_spec.rb'
 
-# Offense count: 105
+# Offense count: 109
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 54
@@ -123,7 +125,7 @@ RSpec/MultipleDescribes:
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
     - 'spec/lutaml/model/xml_adapter_spec.rb'
 
-# Offense count: 98
+# Offense count: 119
 RSpec/MultipleExpectations:
   Max: 14
 

data/README.adoc

@@ -423,6 +423,51 @@ end
 ----
 ====
 
+=== Attribute as raw string
+
+An attribute can be set to read the value as raw string for XML, by using the `raw: true` option.
+
+Syntax:
+
+[source,ruby]
+----
+attribute :name_of_attribute, :string, raw: true
+----
+
+.Using the `raw` option to read raw value for an XML attribute
+[example]
+====
+[source,ruby]
+----
+class Person < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :description, :string, raw: true
+end
+----
+
+For the following xml
+[source,xml]
+----
+<Person>
+  <name>John Doe</name>
+  <description>
+    A <b>fictional person</b> commonly used as a <i>placeholder name</i>.
+  </description>
+</Person>
+----
+
+[source,ruby]
+----
+> Person.from_xml(xml)
+> # <Person:0x0000000107a3ca70
+    @description="\n    A <b>fictional person</b> commonly used as a <i>placeholder name</i>.\n  ",
+    @element_order=["text", "name", "text", "description", "text"],
+    @name="John Doe",
+    @ordered=nil,
+    @validate_on_set=false>
+----
+====
+
 == Serialization model mappings
 
 === General
@@ -612,7 +657,7 @@ end
 
 [source,xml]
 ----
-<example value=12><name>John Doe</name></example>
+<example value="12"><name>John Doe</name></example>
 ----
 
 [source,ruby]
@@ -622,6 +667,37 @@ end
 > Example.new(value: 12).to_xml
 > #<example value="12"></example>
 ----
+
+The map_attribute method does not inherit the root element's namespace. If you need to specify a namespace for an attribute,
+you must explicitly declare the namespace and prefix in the map_attribute method.
+[example]
+====
+The following class will parse the XML snippet below:
+
+[source,ruby]
+----
+class Attribute < Lutaml::Model::Serializable
+  attribute :value, :integer
+
+  xml do
+    root 'example'
+    map_attribute 'value', to: :value, namespace: "http://www.tech.co/XMI", prefix: "xl"
+  end
+end
+----
+
+[source,xml]
+----
+<example xl:value="20" xmlns:xl="http://www.tech.co/XMI"></example>
+----
+
+[source,ruby]
+----
+> Attribute.from_xml(xml)
+> #<Attribute:0x0000000109436db8 @value=20>
+> Attribute.new(value: 20).to_xml
+> #<example xmlns:xl=\"http://www.tech.co/XMI\" xl:value=\"20\"/>
+----
 ====
 
 
@@ -698,7 +774,7 @@ end
 
 [source,xml]
 ----
-<example value=12><name>John Doe</name> is my moniker.</example>
+<example value="12"><name>John Doe</name> is my moniker.</example>
 ----
 
 [source,ruby]

data/lib/lutaml/model/attribute.rb

@@ -7,6 +7,7 @@ module Lutaml
         @name = name
         @type = cast_type(type)
         @options = options
+        @raw = !!options[:raw]
 
         if collection?
           validate_collection_range
@@ -14,6 +15,10 @@ module Lutaml
         end
       end
 
+      def delegate
+        @options[:delegate]
+      end
+
       def cast_type(type)
         case type
         when Class
@@ -45,8 +50,18 @@ module Lutaml
         !collection?
       end
 
+      def raw?
+        @raw
+      end
+
+      def render_default?
+        !!@options[:render_default]
+      end
+
       def default
-        value = if options[:default].is_a?(Proc)
+        value = if delegate
+                  type.attributes[to].default
+                elsif options[:default].is_a?(Proc)
                   options[:default].call
                 else
                   options[:default]

data/lib/lutaml/model/key_value_mapping.rb

@@ -42,6 +42,16 @@ module Lutaml
           raise IncorrectMappingArgumentsError.new(msg)
         end
       end
+
+      def deep_dup
+        self.class.new.tap do |new_mapping|
+          new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+        end
+      end
+
+      def duplicate_mappings
+        @mappings.map(&:deep_dup)
+      end
     end
   end
 end

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)
 

data/lib/lutaml/model/mapping_rule.rb

@@ -4,43 +4,33 @@ module Lutaml
       attr_reader :name,
                   :to,
                   :render_nil,
+                  :render_default,
+                  :attribute,
                   :custom_methods,
-                  :delegate,
-                  :mixed_content,
-                  :child_mappings
+                  :delegate
 
       def initialize(
         name,
         to:,
         render_nil: false,
+        render_default: false,
         with: {},
-        delegate: nil,
-        mixed_content: false,
-        namespace_set: false,
-        prefix_set: false,
-        child_mappings: nil
+        attribute: false,
+        delegate: nil
       )
         @name = name
         @to = to
         @render_nil = render_nil
+        @render_default = render_default
         @custom_methods = with
+        @attribute = attribute
         @delegate = delegate
-        @mixed_content = mixed_content
-        @namespace_set = namespace_set
-        @prefix_set = prefix_set
-        @child_mappings = child_mappings
       end
 
       alias from name
       alias render_nil? render_nil
-
-      def prefixed_name
-        if prefix
-          "#{prefix}:#{name}"
-        else
-          name
-        end
-      end
+      alias render_default? render_default
+      alias attribute? attribute
 
       def serialize_attribute(model, element, doc)
         if custom_methods[:to]
@@ -48,13 +38,19 @@ module Lutaml
         end
       end
 
+      def to_value_for(model)
+        if delegate
+          model.public_send(delegate).public_send(to)
+        else
+          model.public_send(to)
+        end
+      end
+
       def serialize(model, parent = nil, doc = nil)
         if custom_methods[:to]
           model.send(custom_methods[:to], model, parent, doc)
-        elsif delegate
-          model.public_send(delegate).public_send(to)
         else
-          model.public_send(to)
+          to_value_for(model)
         end
       end
 
@@ -72,16 +68,8 @@ module Lutaml
         end
       end
 
-      def namespace_set?
-        @namespace_set
-      end
-
-      def prefix_set?
-        @prefix_set
-      end
-
-      def content_mapping?
-        name.nil?
+      def deep_dup
+        raise NotImplementedError, "Subclasses must implement `deep_dup`."
       end
     end
   end

data/lib/lutaml/model/serialize.rb

@@ -32,8 +32,8 @@ 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
 
@@ -55,6 +55,14 @@ module Lutaml
             !!@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
@@ -78,6 +86,7 @@ module Lutaml
           end
 
           define_method(:"#{name}=") do |value|
+            value_set_for(name)
             instance_variable_set(:"@#{name}", attr.cast_value(value))
           end
         end
@@ -85,7 +94,7 @@ module Lutaml
         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
@@ -107,7 +116,12 @@ module Lutaml
                      end
             end
 
-            apply_mappings(doc.to_h, 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|
@@ -280,38 +294,18 @@ module Lutaml
           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 Utils.blank?(doc)
           return apply_xml_mapping(doc, instance, options) if format == :xml
 
-          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) || doc.key?(rule.name.to_sym)
-                      doc[rule.name] || doc[rule.name.to_sym]
-                    else
-                      attr.default
-                    end
-
-            if rule.custom_methods[:from]
-              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)
-
-            rule.deserialize(instance, value, attributes, self)
-          end
-
-          instance
+          apply_hash_mapping(doc, instance, format, options)
         end
 
         def apply_xml_mapping(doc, instance, options = {})
@@ -326,7 +320,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"]
@@ -337,19 +332,58 @@ module Lutaml
             )
           end
 
+          defaults_used = []
+
           mappings.each do |rule|
             raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
 
             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]
+                      defaults_used << rule.to
+                      rule.to_value_for(instance)
                     end
 
             value = normalize_xml_value(value, rule)
             rule.deserialize(instance, value, attributes, self)
           end
 
+          defaults_used.each do |attribute_name|
+            instance.using_default_for(attribute_name) if instance.respond_to?(:using_default_for)
+          end
+
+          instance
+        end
+
+        def apply_hash_mapping(doc, instance, format, _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) || doc.key?(rule.name.to_sym)
+                      doc[rule.name] || doc[rule.name.to_sym]
+                    else
+                      attr.default
+                    end
+
+            if rule.custom_methods[:from]
+              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)
+
+            rule.deserialize(instance, value, attributes, self)
+          end
+
           instance
         end
 
@@ -407,9 +441,11 @@ 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
+        @using_default ||= {}
 
         return unless self.class.attributes
 
@@ -426,6 +462,7 @@ module Lutaml
           value = if attrs.key?(name) || attrs.key?(name.to_s)
                     self.class.attr_value(attrs, name, attr)
                   else
+                    using_default_for(name)
                     attr.default
                   end
 
@@ -438,6 +475,18 @@ module Lutaml
         end
       end
 
+      def using_default_for(attribute_name)
+        @using_default[attribute_name] = true
+      end
+
+      def value_set_for(attribute_name)
+        @using_default[attribute_name] = false
+      end
+
+      def using_default?(attribute_name)
+        @using_default[attribute_name]
+      end
+
       def method_missing(method_name, *args)
         if method_name.to_s.end_with?("=") && self.class.attributes.key?(method_name.to_s.chomp("=").to_sym)
           define_singleton_method(method_name) do |value|
@@ -456,11 +505,11 @@ module Lutaml
       end
 
       def ordered?
-        @ordered
+        !!@ordered
       end
 
-      def ordered=(ordered)
-        @ordered = ordered
+      def mixed?
+        !!@mixed
       end
 
       def key_exist?(hash, key)

data/lib/lutaml/model/type.rb

@@ -116,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

@@ -50,6 +50,24 @@ module Lutaml
           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.11"
+    VERSION = "0.3.15"
   end
 end

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

@@ -63,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/nokogiri_adapter.rb

@@ -55,6 +55,7 @@ module Lutaml
             end
 
             index_hash = {}
+            content = []
 
             element.element_order.each do |name|
               index_hash[name] ||= -1
@@ -71,7 +72,11 @@ module Lutaml
                 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?
 
@@ -87,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)
@@ -116,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
 
@@ -138,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
 
@@ -154,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,7 +59,11 @@ 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?
 
@@ -74,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)
-
-            hash[child.unprefixed_name] = if hash[child.unprefixed_name]
-                                            [hash[child.unprefixed_name], value].flatten
+            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.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
 
@@ -124,6 +143,8 @@ module Lutaml
             return
           end
 
+          return if !render_element?(rule, element, value)
+
           if value && (attribute&.type&.<= Lutaml::Model::Serialize)
             handle_nested_elements(
               xml,
@@ -231,13 +252,31 @@ 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 render_element?(rule, element, value)
+          render_default?(rule, element) && render_value?(rule, value)
+        end
+
+        def render_value?(rule, value)
+          rule.attribute? || rule.render_nil? || !value.nil?
+        end
+
+        def render_default?(rule, element)
+          !element.respond_to?(:using_default?) ||
+            rule.render_default? ||
+            !element.using_default?(rule.to)
+        end
+
+        def build_namespace_attributes(klass, processed = {}, options = {})
           xml_mappings = klass.mappings_for(:xml)
           attributes = klass.attributes
 
           attrs = {}
 
-          if xml_mappings.namespace_uri
+          if xml_mappings.namespace_uri && set_namespace?(options[:caller_rule])
             prefixed_name = [
               "xmlns",
               xml_mappings.namespace_prefix,
@@ -262,10 +301,10 @@ module Lutaml
             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
@@ -274,23 +313,33 @@ 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)
+            if render_element?(mapping_rule, element, mapping_rule.to_value_for(element))
+              hash[mapping_rule.prefixed_name] = mapping_rule.to_value_for(element)
+            end
           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_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
@@ -40,6 +43,7 @@ module Lutaml
         name,
         to: nil,
         render_nil: false,
+        render_default: false,
         with: {},
         delegate: nil,
         namespace: (namespace_set = false
@@ -49,23 +53,27 @@ module Lutaml
       )
         validate!(name, to, with)
 
-        @elements[name] = XmlMappingRule.new(
+        rule = XmlMappingRule.new(
           name,
           to: to,
           render_nil: render_nil,
+          render_default: render_default,
           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: nil,
         render_nil: false,
+        render_default: false,
         with: {},
         delegate: nil,
         namespace: (namespace_set = false
@@ -75,17 +83,21 @@ module Lutaml
       )
         validate!(name, to, with)
 
-        @attributes[name] = XmlMappingRule.new(
+        rule = XmlMappingRule.new(
           name,
           to: to,
           render_nil: render_nil,
+          render_default: render_default,
           with: with,
           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
@@ -93,6 +105,7 @@ module Lutaml
       def map_content(
         to: nil,
         render_nil: false,
+        render_default: false,
         with: {},
         delegate: nil,
         mixed: false
@@ -103,6 +116,7 @@ module Lutaml
           nil,
           to: to,
           render_nil: render_nil,
+          render_default: render_default,
           with: with,
           delegate: delegate,
           mixed_content: mixed,
@@ -158,6 +172,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,29 +3,31 @@ 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,
         to:,
         render_nil: false,
+        render_default: false,
         with: {},
         delegate: nil,
         namespace: nil,
         prefix: nil,
         mixed_content: false,
         namespace_set: false,
-        prefix_set: false
+        prefix_set: false,
+        attribute: false,
+        default_namespace: nil
       )
         super(
           name,
           to: to,
           render_nil: render_nil,
+          render_default: render_default,
           with: with,
           delegate: delegate,
-          mixed_content: mixed_content,
-          namespace_set: namespace_set,
-          prefix_set: prefix_set,
+          attribute: attribute,
         )
 
         @namespace = if namespace.to_s == "inherit"
@@ -35,6 +37,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.3.11
+  version: 0.3.15
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-10-04 00:00:00.000000000 Z
+date: 2024-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor