lutaml-model 0.3.6 → 0.3.8

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.3.6"
+    VERSION = "0.3.8"
   end
 end

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

@@ -0,0 +1,73 @@
+module Lutaml
+  module Model
+    module XmlAdapter
+      module Builder
+        class Nokogiri
+          def self.build(options = {})
+            if block_given?
+              ::Nokogiri::XML::Builder.new(options) do |xml|
+                yield(new(xml))
+              end
+            else
+              new(::Nokogiri::XML::Builder.new(options))
+            end
+          end
+
+          attr_reader :xml
+
+          def initialize(xml)
+            @xml = xml
+          end
+
+          def create_element(name, attributes = {})
+            xml.doc.create_element(name, attributes)
+          end
+
+          def add_element(element, child)
+            element.add_child(child)
+          end
+
+          def create_and_add_element(element_name, prefix: nil, attributes: {})
+            add_namespace_prefix(prefix) if prefix
+
+            if block_given?
+              public_send(element_name, attributes) do
+                yield(self)
+              end
+            else
+              public_send(element_name, attributes)
+            end
+          end
+
+          def add_text(element, text)
+            if element.is_a?(self.class)
+              element = element.xml.parent
+            end
+
+            add_element(element, ::Nokogiri::XML::Text.new(text.to_s, xml.doc))
+          end
+
+          def add_namespace_prefix(prefix)
+            xml[prefix] if prefix
+
+            self
+          end
+
+          def method_missing(method_name, *args)
+            if block_given?
+              xml.public_send(method_name, *args) do
+                yield(xml)
+              end
+            else
+              xml.public_send(method_name, *args)
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            xml.respond_to?(method_name) || super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Lutaml
+  module Model
+    module XmlAdapter
+      module Builder
+        class Ox
+          def self.build(options = {})
+            if block_given?
+              ::Ox::Builder.new(options) do |xml|
+                yield(new(xml))
+              end
+            else
+              new(::Ox::Builder.new(options))
+            end
+          end
+
+          attr_reader :xml
+
+          def initialize(xml)
+            @xml = xml
+          end
+
+          def create_element(name, attributes = {})
+            if block_given?
+              xml.element(name, attributes) do |element|
+                yield(self.class.new(element))
+              end
+            else
+              xml.element(name, attributes)
+            end
+          end
+
+          def add_element(element, child)
+            element << child
+          end
+
+          def create_and_add_element(element_name, prefix: nil, attributes: {})
+            prefixed_name = if prefix
+                              "#{prefix}:#{element_name}"
+                            else
+                              element_name
+                            end
+
+            if block_given?
+              xml.element(prefixed_name, attributes) do |element|
+                yield(self.class.new(element))
+              end
+            else
+              xml.element(prefixed_name, attributes)
+            end
+          end
+
+          def <<(text)
+            xml.text(text)
+          end
+
+          def add_text(element, text)
+            element << text
+          end
+
+          # Add XML namespace to document
+          #
+          # Ox doesn't support XML namespaces so this method does nothing.
+          def add_namespace_prefix(_prefix)
+            # :noop:
+            self
+          end
+
+          def parent
+            xml
+          end
+
+          def method_missing(method_name, *args)
+            if block_given?
+              xml.public_send(method_name, *args) do
+                yield(xml)
+              end
+            else
+              xml.public_send(method_name, *args)
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            xml.respond_to?(method_name) || super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 require "nokogiri"
 require_relative "xml_document"
+require_relative "builder/nokogiri"
 
 module Lutaml
   module Model
@@ -12,12 +13,13 @@ module Lutaml
         end
 
         def to_xml(options = {})
-          builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+          builder = Builder::Nokogiri.build(encoding: "UTF-8") do |xml|
             if root.is_a?(Lutaml::Model::XmlAdapter::NokogiriElement)
               root.to_xml(xml)
             else
               mapper_class = options[:mapper_class] || @root.class
-              options[:xml_attributes] = build_namespace_attributes(mapper_class)
+              options[:xml_attributes] =
+                build_namespace_attributes(mapper_class)
               build_element(xml, @root, options)
             end
           end
@@ -31,59 +33,6 @@ module Lutaml
 
         private
 
-        def build_unordered_element(xml, element, options = {})
-          mapper_class = options[:mapper_class] || element.class
-          xml_mapping = mapper_class.mappings_for(:xml)
-          return xml unless xml_mapping
-
-          attributes = options[:xml_attributes] ||= {}
-          attributes = build_attributes(element,
-                                        xml_mapping).merge(attributes)&.compact
-
-          prefixed_xml = if options.key?(:namespace_prefix)
-                           options[:namespace_prefix] ? xml[options[:namespace_prefix]] : xml
-                         elsif xml_mapping.namespace_prefix
-                           xml[xml_mapping.namespace_prefix]
-                         else
-                           xml
-                         end
-
-          tag_name = options[:tag_name] || xml_mapping.root_element
-          prefixed_xml.public_send(tag_name, attributes) do
-            if options.key?(:namespace_prefix) && !options[:namespace_prefix]
-              xml.parent.namespace = nil
-            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)
-
-              next if value.nil? && !element_rule.render_nil?
-
-              nsp_xml = element_rule.prefix ? xml[element_rule.prefix] : xml
-
-              if attribute_def.collection?
-                value.each do |v|
-                  add_to_xml(nsp_xml, v, attribute_def, element_rule)
-                end
-              elsif !value.nil? || element_rule.render_nil?
-                add_to_xml(nsp_xml, value, attribute_def, element_rule)
-              end
-            end
-
-            if (content_rule = xml_mapping.content_mapping)
-              text = element.send(content_rule.to)
-              text = text.join if text.is_a?(Array)
-
-              if content_rule.custom_methods[:to]
-                text = @root.send(content_rule.custom_methods[:to], @root, text)
-              end
-
-              prefixed_xml.text text
-            end
-          end
-        end
-
         def build_ordered_element(xml, element, options = {})
           mapper_class = options[:mapper_class] || element.class
           xml_mapping = mapper_class.mappings_for(:xml)
@@ -114,49 +63,27 @@ module Lutaml
               element_rule = xml_mapping.find_by_name(name)
               next if element_rule.nil?
 
-              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
+              attribute_def = attribute_definition_for(element, element_rule,
+                                                       mapper_class: mapper_class)
               value = attribute_value_for(element, element_rule)
-              nsp_xml = element_rule.prefix ? xml[element_rule.prefix] : xml
 
               if element_rule == xml_mapping.content_mapping
                 text = element.send(xml_mapping.content_mapping.to)
                 text = text[curr_index] if text.is_a?(Array)
 
                 prefixed_xml.text text
-              elsif attribute_def.collection?
-                add_to_xml(nsp_xml, value[curr_index], attribute_def,
-                           element_rule)
               elsif !value.nil? || element_rule.render_nil?
-                add_to_xml(nsp_xml, value, attribute_def, element_rule)
-              end
-            end
-          end
-        end
-
-        def add_to_xml(xml, value, attribute, rule)
-          if rule.custom_methods[:to]
-            value = @root.send(rule.custom_methods[:to], @root, value)
-          end
-
-          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
-            handle_nested_elements(
-              xml,
-              value,
-              rule: rule,
-              attribute: attribute,
-            )
-          else
-            xml.public_send(rule.name) do
-              if !value.nil?
-                serialized_value = attribute.type.serialize(value)
-
-                if attribute.type == Lutaml::Model::Type::Hash
-                  serialized_value.each do |key, val|
-                    xml.public_send(key) { xml.text val }
-                  end
-                else
-                  xml.text(serialized_value)
-                end
+                value = value[curr_index] if attribute_def.collection?
+
+                add_to_xml(
+                  xml,
+                  element_rule.prefix,
+                  value,
+                  options.merge(
+                    attribute: attribute_def,
+                    rule: element_rule,
+                  ),
+                )
               end
             end
           end
@@ -205,7 +132,7 @@ module Lutaml
         end
 
         def to_xml(builder = nil)
-          builder ||= Nokogiri::XML::Builder.new
+          builder ||= Builder::Nokogiri.build
 
           if name == "text"
             builder.text(text)
@@ -232,7 +159,7 @@ module Lutaml
           end
         end
 
-        def build_attributes(node)
+        def build_attributes(node, _options = {})
           attrs = node.attributes.transform_values(&:value)
 
           attrs.merge(build_namespace_attributes(node))

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

@@ -1,5 +1,6 @@
 require "ox"
 require_relative "xml_document"
+require_relative "builder/ox"
 
 module Lutaml
   module Model
@@ -12,7 +13,7 @@ module Lutaml
         end
 
         def to_xml(options = {})
-          builder = Ox::Builder.new
+          builder = Builder::Ox.build
 
           if @root.is_a?(Lutaml::Model::XmlAdapter::OxElement)
             @root.to_xml(builder)
@@ -22,66 +23,12 @@ module Lutaml
             build_element(builder, @root, options)
           end
 
-          # xml_data = Ox.dump(builder)
-          xml_data = builder.to_s
+          xml_data = builder.xml.to_s
           options[:declaration] ? declaration(options) + xml_data : xml_data
         end
 
         private
 
-        def build_unordered_element(builder, element, options = {})
-          mapper_class = options[:mapper_class] || element.class
-          xml_mapping = mapper_class.mappings_for(:xml)
-          return xml unless xml_mapping
-
-          attributes = build_attributes(element, xml_mapping).compact
-
-          tag_name = options[:tag_name] || xml_mapping.root_element
-          prefixed_name = if options.key?(:namespace_prefix)
-                            [options[:namespace_prefix], tag_name].compact.join(":")
-                          elsif xml_mapping.namespace_prefix
-                            "#{xml_mapping.namespace_prefix}:#{tag_name}"
-                          else
-                            tag_name
-                          end
-
-          builder.element(prefixed_name, attributes) do |el|
-            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)
-
-              val = if attribute_def.collection?
-                      value
-                    elsif value || element_rule.render_nil?
-                      [value]
-                    else
-                      []
-                    end
-
-              val.each do |v|
-                if attribute_def&.type&.<= Lutaml::Model::Serialize
-                  handle_nested_elements(el, v, rule: element_rule, attribute: attribute_def)
-                else
-                  builder.element(element_rule.prefixed_name) do |el|
-                    el.text(attribute_def.type.serialize(v)) if v
-                  end
-                end
-              end
-            end
-
-            if (content_rule = xml_mapping.content_mapping)
-              text = element.send(xml_mapping.content_mapping.to)
-              text = text.join if text.is_a?(Array)
-
-              if content_rule.custom_methods[:to]
-                text = @root.send(content_rule.custom_methods[:to], @root, text)
-              end
-
-              el.text text
-            end
-          end
-        end
-
         def build_ordered_element(builder, element, options = {})
           mapper_class = options[:mapper_class] || element.class
           xml_mapping = mapper_class.mappings_for(:xml)
@@ -90,7 +37,8 @@ module Lutaml
           attributes = build_attributes(element, xml_mapping).compact
 
           tag_name = options[:tag_name] || xml_mapping.root_element
-          builder.element(tag_name, attributes) do |el|
+          builder.create_and_add_element(tag_name,
+                                         attributes: attributes) do |el|
             index_hash = {}
 
             element.element_order.each do |name|
@@ -99,47 +47,27 @@ module Lutaml
 
               element_rule = xml_mapping.find_by_name(name)
 
-              attribute_def = attribute_definition_for(element, element_rule, mapper_class: mapper_class)
+              attribute_def = attribute_definition_for(element, element_rule,
+                                                       mapper_class: mapper_class)
               value = attribute_value_for(element, element_rule)
 
               if element_rule == xml_mapping.content_mapping
                 text = element.send(xml_mapping.content_mapping.to)
                 text = text[curr_index] if text.is_a?(Array)
 
-                el.text text
-              elsif attribute_def.collection?
-                add_to_xml(el, value[curr_index], attribute_def, element_rule)
+                el.add_text(el, text)
               elsif !value.nil? || element_rule.render_nil?
-                add_to_xml(el, value, attribute_def, element_rule)
-              end
-            end
-          end
-        end
-
-        def add_to_xml(xml, value, attribute, rule)
-          if rule.custom_methods[:to]
-            value = @root.send(rule.custom_methods[:to], @root, value)
-          end
-
-          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
-            handle_nested_elements(
-              xml,
-              value,
-              rule: rule,
-              attribute: attribute,
-            )
-          else
-            xml.element(rule.name) do |el|
-              if !value.nil?
-                serialized_value = attribute.type.serialize(value)
-
-                if attribute.type == Lutaml::Model::Type::Hash
-                  serialized_value.each do |key, val|
-                    el.element(key) { |child_el| child_el.text val }
-                  end
-                else
-                  el.text(serialized_value)
-                end
+                value = value[curr_index] if attribute_def.collection?
+
+                add_to_xml(
+                  el,
+                  nil,
+                  value,
+                  options.merge(
+                    attribute: attribute_def,
+                    rule: element_rule,
+                  ),
+                )
               end
             end
           end
@@ -188,13 +116,13 @@ module Lutaml
         end
 
         def to_xml(builder = nil)
-          builder ||= Ox::Builder.new
+          builder ||= Builder::Ox.build
           attrs = build_attributes(self)
 
           if text?
-            builder.text(text)
+            builder.add_text(builder, text)
           else
-            builder.element(name, attrs) do |el|
+            builder.create_and_add_element(name, attributes: attrs) do |el|
               children.each { |child| child.to_xml(el) }
             end
           end

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

@@ -42,21 +42,24 @@ module Lutaml
           @root.order
         end
 
-        def handle_nested_elements(builder, value, rule: nil, attribute: nil)
-          options = build_options_for_nested_elements(attribute, rule)
+        def handle_nested_elements(builder, value, options = {})
+          element_options = build_options_for_nested_elements(options)
 
           case value
           when Array
-            value.each { |val| build_element(builder, val, options) }
+            value.each { |val| build_element(builder, val, element_options) }
           else
-            build_element(builder, value, options)
+            build_element(builder, value, element_options)
           end
         end
 
-        def build_options_for_nested_elements(attribute, rule)
+        def build_options_for_nested_elements(options = {})
+          attribute = options.delete(:attribute)
+          rule = options.delete(:rule)
+
           return {} unless rule
 
-          options = {}
+          # options = {}
 
           options[:namespace_prefix] = rule.prefix if rule&.namespace_set?
           options[:mixed_content] = rule.mixed_content
@@ -97,6 +100,103 @@ module Lutaml
           end
         end
 
+        def add_to_xml(xml, prefix, value, options = {})
+          if value.is_a?(Array)
+            value.each do |item|
+              add_to_xml(xml, prefix, item, options)
+            end
+
+            return
+          end
+
+          attribute = options[:attribute]
+          rule = options[:rule]
+
+          if rule.custom_methods[:to]
+            @root.send(rule.custom_methods[:to], @root, xml.parent, xml)
+            return
+          end
+
+          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
+            handle_nested_elements(
+              xml,
+              value,
+              options.merge({ rule: rule, attribute: attribute }),
+            )
+          else
+            xml.create_and_add_element(rule.name, prefix: prefix) do
+              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
+          end
+        end
+
+        def build_unordered_element(xml, element, options = {})
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
+          return xml unless xml_mapping
+
+          attributes = options[:xml_attributes] ||= {}
+          attributes = build_attributes(element,
+                                        xml_mapping, options).merge(attributes)&.compact
+
+          prefix = if options.key?(:namespace_prefix)
+                     options[:namespace_prefix]
+                   elsif xml_mapping.namespace_prefix
+                     xml_mapping.namespace_prefix
+                   end
+
+          prefixed_xml = xml.add_namespace_prefix(prefix)
+          tag_name = options[:tag_name] || xml_mapping.root_element
+
+          xml.create_and_add_element(tag_name, prefix: prefix,
+                                               attributes: attributes) do
+            if options.key?(:namespace_prefix) && !options[:namespace_prefix]
+              xml.add_namespace_prefix(nil)
+            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)
+
+              next if value.nil? && !element_rule.render_nil?
+
+              value = [value] if attribute_def.collection? && !value.is_a?(Array)
+
+              add_to_xml(
+                xml,
+                element_rule.prefix,
+                value,
+                options.merge({ attribute: attribute_def, rule: element_rule }),
+              )
+            end
+
+            if (content_rule = xml_mapping.content_mapping)
+              if content_rule.custom_methods[:to]
+                @root.send(content_rule.custom_methods[:to], element,
+                           prefixed_xml.parent, prefixed_xml)
+              else
+                text = element.send(content_rule.to)
+                text = text.join if text.is_a?(Array)
+                prefixed_xml.add_text(xml, text)
+              end
+            end
+          end
+        end
+
         def ordered?(element, options = {})
           return false unless element.respond_to?(:element_order)
           return element.ordered? if element.respond_to?(:ordered?)
@@ -142,10 +242,12 @@ module Lutaml
           attrs
         end
 
-        def build_attributes(element, xml_mapping)
+        def build_attributes(element, xml_mapping, options = {})
           attrs = namespace_attributes(xml_mapping)
 
           xml_mapping.attributes.each_with_object(attrs) do |mapping_rule, hash|
+            next if options[:except]&.include?(mapping_rule.to)
+
             if mapping_rule.namespace
               hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
             end
@@ -154,6 +256,8 @@ module Lutaml
           end
 
           xml_mapping.elements.each_with_object(attrs) do |mapping_rule, hash|
+            next if options[:except]&.include?(mapping_rule.to)
+
             if mapping_rule.namespace
               hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
             end

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

@@ -16,18 +16,6 @@ module Lutaml
         def to_yaml(options = {})
           YAML.dump(@attributes, options)
         end
-
-        # TODO: Is this really needed?
-        def self.to_yaml(attributes, *args)
-          new(attributes).to_yaml(*args)
-        end
-
-        # TODO: Is this really needed?
-        def self.from_yaml(yaml, klass)
-          data = parse(yaml)
-          mapped_attrs = klass.send(:apply_mappings, data, :yaml)
-          klass.new(mapped_attrs)
-        end
       end
     end
   end

data/lib/lutaml/model.rb

@@ -2,6 +2,7 @@
 
 require_relative "model/version"
 require_relative "model/type"
+require_relative "model/utils"
 require_relative "model/serializable"
 require_relative "model/json_adapter/standard_json_adapter"
 require_relative "model/yaml_adapter/standard_yaml_adapter"