lutaml-model 0.4.0 → 0.5.0

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      module Builder
+        class Oga
+          def self.build(options = {}, &block)
+            if block_given?
+              XmlAdapter::Builder::Oga.new(options, &block)
+            else
+              XmlAdapter::Builder::Oga.new(options)
+            end
+          end
+
+          attr_reader :document, :current_node, :options
+
+          def initialize(options = {})
+            @document = XmlAdapter::Oga::Document.new
+            @current_node = @document
+            @options = options
+            yield(self) if block_given?
+          end
+
+          def create_element(name, attributes = {}, &block)
+            if @current_namespace && !name.start_with?("#{@current_namespace}:")
+              name = "#{@current_namespace}:#{name}"
+            end
+
+            if block_given?
+              element(name, attributes, &block)
+            else
+              element(name, attributes)
+            end
+          end
+
+          def element(name, attributes = {})
+            oga_element = ::Oga::XML::Element.new(name: name)
+            if block_given?
+              element_attributes(oga_element, attributes)
+              @current_node.children << oga_element
+              # Save previous node to reset the pointer for the rest of the iteration
+              previous_node = @current_node
+              # Set current node to new element as pointer for the block
+              @current_node = oga_element
+              yield(self)
+              # Reset the pointer for the rest of the iterations
+              @current_node = previous_node
+            end
+            oga_element
+          end
+
+          def add_element(oga_element, child)
+            if child.is_a?(String)
+              current_element = oga_element.is_a?(XmlAdapter::Oga::Document) ? current_node : oga_element
+              add_xml_fragment(current_element, child)
+            elsif oga_element.is_a?(XmlAdapter::Oga::Document)
+              oga_element.children.last.children << child
+            else
+              oga_element.children << child
+            end
+          end
+
+          def add_attribute(element, name, value)
+            attribute = ::Oga::XML::Attribute.new(
+              name: name,
+              value: value.to_s,
+            )
+            if element.is_a?(XmlAdapter::Oga::Document)
+              element.children.last.attributes << attribute
+            else
+              element.attributes << attribute
+            end
+          end
+
+          def create_and_add_element(
+            element_name,
+            prefix: (prefix_unset = true
+                     nil),
+            attributes: {},
+            &block
+          )
+            @current_namespace = nil if prefix.nil? && !prefix_unset
+            prefixed_name = if prefix
+                              "#{prefix}:#{element_name}"
+                            elsif @current_namespace && !element_name.start_with?("#{@current_namespace}:")
+                              "#{@current_namespace}:#{element_name}"
+                            else
+                              element_name
+                            end
+
+            if block_given?
+              element(prefixed_name, attributes, &block)
+            else
+              element(prefixed_name, attributes)
+            end
+          end
+
+          def <<(text)
+            @current_node.text(text)
+          end
+
+          def add_xml_fragment(element, content)
+            fragment = "<fragment>#{content}</fragment>"
+            parsed_fragment = ::Oga.parse_xml(fragment)
+            parsed_children = parsed_fragment.children.first.children
+            if element.is_a?(XmlAdapter::Oga::Document)
+              element.children.last.children += parsed_children
+            else
+              element.children += parsed_children
+            end
+          end
+
+          def add_text(element, text, cdata: false)
+            return add_cdata(element, text) if cdata
+
+            oga_text = ::Oga::XML::Text.new(text: text.to_s)
+            if element.is_a?(XmlAdapter::Oga::Document)
+              children = element.children
+              children.empty? ? children << oga_text : children.last.children << oga_text
+            else
+              element.children << oga_text
+            end
+          end
+
+          def add_cdata(element, value)
+            oga_cdata = ::Oga::XML::CData.new(text: value.to_s)
+            if element.is_a?(XmlAdapter::Oga::Document)
+              element.children.last.children << oga_cdata
+            else
+              element.children << oga_cdata
+            end
+          end
+
+          def add_namespace_prefix(prefix)
+            @current_namespace = prefix
+            self
+          end
+
+          def parent
+            @document
+          end
+
+          def text(value = nil)
+            return @current_node.inner_text if value.nil?
+
+            str = value.is_a?(Array) ? value.join : value
+            @current_node.children << ::Oga::XML::Text.new(text: str)
+          end
+
+          def method_missing(method_name, *args)
+            if block_given?
+              @current_node.public_send(method_name, *args) do
+                yield(self)
+              end
+            else
+              @current_node.public_send(method_name, *args)
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            @current_node.respond_to?(method_name) || super
+          end
+
+          private
+
+          def element_attributes(oga_element, attributes)
+            oga_element.attributes = attributes.map do |name, value|
+              ::Oga::XML::Attribute.new(
+                name: name,
+                value: value,
+                element: oga_element,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -43,6 +43,7 @@ module Lutaml
           end
 
           def create_and_add_element(element_name, prefix: nil, attributes: {})
+            element_name = element_name.first if element_name.is_a?(Array)
             prefixed_name = if prefix
                               "#{prefix}:#{element_name}"
                             elsif @current_namespace && !element_name.start_with?("#{@current_namespace}:")

data/lib/lutaml/model/xml_adapter/oga/document.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      module Oga
+        class Document < ::Oga::XML::Document
+          def initialize(options = {})
+            super
+          end
+
+          def text(value = nil)
+            children << ::Oga::XML::Text.new(text: value)
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/xml_adapter/oga/element.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module XmlAdapter
+      module Oga
+        class Element < XmlElement
+          def initialize(node, parent: nil)
+            name = case node
+                   when ::Oga::XML::Element
+                     namespace_name = node.namespace_name
+                     add_namespaces(node)
+                     children = parse_children(node)
+                     attributes = node_attributes(node)
+                     node.name
+                   when ::Oga::XML::Text
+                     "text"
+                   end
+            super(
+              name,
+              Hash(attributes),
+              Array(children),
+              node.text,
+              parent_document: parent,
+              namespace_prefix: namespace_name,
+            )
+          end
+
+          def text?
+            children.empty? && text&.length&.positive?
+          end
+
+          def text
+            @text
+          end
+
+          def to_xml(builder = Builder::Oga.build)
+            build_xml(builder).to_xml
+          end
+
+          def build_xml(builder = Builder::Oga.build)
+            if name == "text"
+              builder.add_text(builder.current_node, @text)
+            else
+              builder.create_element(name, build_attributes(self)) do |xml|
+                children.each { |child| child.build_xml(xml) }
+              end
+            end
+
+            builder
+          end
+
+          def inner_xml
+            children.map(&:to_xml).join
+          end
+
+          private
+
+          def node_attributes(node)
+            node.attributes.each_with_object({}) do |attr, hash|
+              next if attr_is_namespace?(attr)
+
+              name = if attr.namespace
+                       "#{attr.namespace.name}:#{attr.name}"
+                     else
+                       attr.name
+                     end
+              hash[name] = XmlAttribute.new(
+                name,
+                attr.value,
+                namespace: attr.namespace&.uri,
+                namespace_prefix: attr.namespace&.name,
+              )
+            end
+          end
+
+          def parse_children(node)
+            node.children.map { |child| self.class.new(child, parent: self) }
+          end
+
+          def add_namespaces(node)
+            node.namespaces.each_value do |namespace|
+              add_namespace(XmlNamespace.new(namespace.uri, namespace.name))
+            end
+          end
+
+          def attr_is_namespace?(attr)
+            attribute_is_namespace?(attr.name) ||
+              namespaces[attr.name]&.uri == attr.value
+          end
+
+          def build_attributes(node, _options = {})
+            attrs = node.attributes.transform_values(&:value)
+
+            attrs.merge(build_namespace_attributes(node))
+          end
+
+          def build_namespace_attributes(node)
+            namespace_attrs = {}
+
+            node.own_namespaces.each_value do |namespace|
+              namespace_attrs[namespace.attr_name] = namespace.uri
+            end
+
+            node.children.each do |child|
+              namespace_attrs = namespace_attrs.merge(
+                build_namespace_attributes(child),
+              )
+            end
+
+            namespace_attrs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,69 +1,102 @@
 require "oga"
 require_relative "xml_document"
+require_relative "oga/document"
+require_relative "oga/element"
+require_relative "builder/oga"
 
 module Lutaml
   module Model
     module XmlAdapter
       class OgaAdapter < XmlDocument
-        def self.parse(xml, _options = {})
-          parsed = Oga.parse_xml(xml)
-          root = OgaElement.new(parsed)
-          new(root)
-        end
-
-        def to_h
-          { @root.name => parse_element(@root) }
+        def self.parse(xml, options = {})
+          encoding = options[:encoding] || xml.encoding.to_s
+          xml = xml.encode("UTF-16").encode("UTF-8") if encoding && encoding != "UTF-8"
+          parsed = ::Oga.parse_xml(xml)
+          @root = Oga::Element.new(parsed.children.first)
+          new(@root, encoding)
         end
 
         def to_xml(options = {})
-          builder = Oga::XML::Builder.new
-          build_element(builder, @root, options)
-          xml_data = builder.to_xml
+          builder_options = {}
+
+          builder_options[:encoding] = if options.key?(:encoding)
+                                         options[:encoding] || "UTF-8"
+                                       elsif options.key?(:parse_encoding)
+                                         options[:parse_encoding]
+                                       else
+                                         "UTF-8"
+                                       end
+          builder = Builder::Oga.build(options) do |xml|
+            if @root.is_a?(Oga::Element)
+              @root.build_xml(xml)
+            else
+              build_element(xml, @root, options)
+            end
+          end
+          xml_data = builder.to_xml.encode!(builder_options[:encoding])
           options[:declaration] ? declaration(options) + xml_data : xml_data
+        rescue Encoding::ConverterNotFoundError
+          invalid_encoding!(builder_options[:encoding])
         end
 
         private
 
-        def build_element(builder, element, options = {})
-          attributes = build_attributes(element.attributes)
-          builder.element(element.name, attributes) do
-            element.children.each do |child|
-              build_element(builder, child, options)
-            end
-            builder.text(element.text) if element.text
-          end
-        end
+        def build_ordered_element(builder, element, options = {})
+          mapper_class = options[:mapper_class] || element.class
+          xml_mapping = mapper_class.mappings_for(:xml)
+          return xml unless xml_mapping
 
-        def build_attributes(attributes)
-          attributes.transform_values(&:value)
-        end
+          attributes = build_attributes(element, xml_mapping).compact
 
-        def parse_element(element)
-          result = { "_text" => element.text }
-          element.children.each do |child|
-            next if child.is_a?(Oga::XML::Text)
+          tag_name = options[:tag_name] || xml_mapping.root_element
+          builder.create_and_add_element(tag_name,
+                                         attributes: attributes) do |el|
+            index_hash = {}
+            content = []
 
-            result[child.name] ||= []
-            result[child.name] << parse_element(child)
-          end
-          result
-        end
-      end
+            element.element_order.each do |name|
+              index_hash[name] ||= -1
+              curr_index = index_hash[name] += 1
+
+              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)
+              value = attribute_value_for(element, element_rule)
+
+              next if element_rule == xml_mapping.content_mapping && element_rule.cdata && name == "text"
+
+              if element_rule == xml_mapping.content_mapping
+                text = xml_mapping.content_mapping.serialize(element)
+                text = text[curr_index] if text.is_a?(Array)
+
+                next el.add_text(el, text, cdata: element_rule.cdata) if element.mixed?
 
-      class OgaElement < XmlElement
-        def initialize(node)
-          attributes = node.attributes.each_with_object({}) do |attr, hash|
-            hash[attr.name] = XmlAttribute.new(attr.name, attr.value)
+                content << text
+              elsif !value.nil? || element_rule.render_nil?
+                value = value[curr_index] if attribute_def.collection?
+
+                add_to_xml(
+                  el,
+                  element,
+                  nil,
+                  value,
+                  options.merge(
+                    attribute: attribute_def,
+                    rule: element_rule,
+                    mapper_class: mapper_class,
+                  ),
+                )
+              end
+            end
+
+            el.add_text(el, content.join)
           end
-          super(node.name, attributes, parse_children(node), node.text)
         end
 
-        private
-
-        def parse_children(node)
-          node.children.select do |child|
-            child.is_a?(Oga::XML::Element)
-          end.map { |child| OgaElement.new(child) }
+        def invalid_encoding!(encoding)
+          raise Error, "unknown encoding name - #{encoding}"
         end
       end
     end

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

@@ -233,20 +233,16 @@ module Lutaml
             end
 
             process_content_mapping(element, xml_mapping.content_mapping,
-                                    prefixed_xml)
+                                    prefixed_xml, mapper_class)
           end
         end
 
-        def process_content_mapping(element, content_rule, xml)
+        def process_content_mapping(element, content_rule, xml, mapper_class)
           return unless content_rule
 
           if content_rule.custom_methods[:to]
-            @root.send(
-              content_rule.custom_methods[:to],
-              element,
-              xml.parent,
-              xml,
-            )
+            mapper_class.new.send(content_rule.custom_methods[:to], element,
+                                  xml.parent, xml)
           else
             text = content_rule.serialize(element)
             text = text.join if text.is_a?(Array)
@@ -340,7 +336,9 @@ module Lutaml
             next if options[:except]&.include?(mapping_rule.to)
             next if mapping_rule.custom_methods[:to]
 
-            if mapping_rule.namespace && mapping_rule.prefix && mapping_rule.name != "lang"
+            mapping_rule_name = mapping_rule.multiple_mappings? ? mapping_rule.name.first : mapping_rule.name
+
+            if mapping_rule.namespace && mapping_rule.prefix && mapping_rule_name != "lang"
               hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
             end
 
@@ -378,6 +376,10 @@ module Lutaml
           key = ["xmlns", xml_mapping.namespace_prefix].compact.join(":")
           { key => xml_mapping.namespace_uri }
         end
+
+        def self.type
+          Utils.snake_case(self).split("/").last.split("_").first
+        end
       end
     end
   end

data/lib/lutaml/model/xml_mapping.rb

@@ -92,7 +92,6 @@ module Lutaml
                  nil)
       )
         validate!(name, to, with, type: TYPES[:attribute])
-
         rule = XmlMappingRule.new(
           name,
           to: to,

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -19,7 +19,8 @@ module Lutaml
         namespace_set: false,
         prefix_set: false,
         attribute: false,
-        default_namespace: nil
+        default_namespace: nil,
+        id: nil
       )
         super(
           name,
@@ -29,6 +30,7 @@ module Lutaml
           with: with,
           delegate: delegate,
           attribute: attribute,
+          id: id
         )
 
         @namespace = if namespace.to_s == "inherit"
@@ -45,6 +47,7 @@ module Lutaml
 
         @namespace_set = namespace_set
         @prefix_set = prefix_set
+        @id = id
       end
 
       def namespace_set?
@@ -72,14 +75,23 @@ module Lutaml
       end
 
       def prefixed_name
+        rule_name = multiple_mappings? ? name.first : name
         if prefix
-          "#{prefix}:#{name}"
+          "#{prefix}:#{rule_name}"
+        else
+          rule_name
+        end
+      end
+
+      def namespaced_names(parent_namespace = nil)
+        if multiple_mappings?
+          name.map { |rule_name| namespaced_name(parent_namespace, rule_name) }
         else
-          name
+          [namespaced_name(parent_namespace)]
         end
       end
 
-      def namespaced_name(parent_namespace = nil)
+      def namespaced_name(parent_namespace = nil, name = self.name)
         if name == "lang"
           "#{prefix}:#{name}"
         elsif namespace_set? || @attribute

data/spec/address_spec.rb

@@ -100,6 +100,7 @@ RSpec.describe Address do
     expect(address_from_json.post_code).to eq("01001")
     expect(address_from_json.person.first.first_name).to eq("Tom")
     expect(address_from_json.person.last.first_name).to eq("Jack")
+    expect(address_from_json.person.last.active).to be(false)
   end
 
   it "serializes to XML with a collection of persons" do

data/spec/fixtures/sample_model.rb

@@ -36,5 +36,12 @@ class SampleModel < Lutaml::Model::Serializable
   yaml do
     map "name", to: :name
     map "age", to: :age
+    map "balance", to: :balance
+    map "tags", to: :tags
+    map "preferences", to: :preferences
+    map "status", to: :status
+    map "large_number", to: :large_number
+    map "email", to: :email
+    map "role", to: :role
   end
 end

data/spec/lutaml/model/custom_model_spec.rb

@@ -78,7 +78,7 @@ module CustomModelSpecs
   end
 
   class Id
-    attr_accessor :id
+    attr_accessor :id, :prefix
   end
 
   class Docid < Lutaml::Model::Serializable
@@ -147,6 +147,28 @@ module CustomModelSpecs
       end
     end
   end
+
+  class CustomId < Lutaml::Model::Serializable
+    model Id
+    attribute :id, :string
+    attribute :prefix, :string
+
+    xml do
+      root "custom-id"
+      map_attribute "prefix", to: :prefix
+      map_content with: { to: :id_to_xml, from: :id_from_xml }
+    end
+
+    def id_to_xml(model, _parent, doc)
+      content = "ABC-#{model.id}"
+      doc.add_text(doc, content)
+    end
+
+    def id_from_xml(model, value)
+      id = value.split("-").last
+      model.id = id.to_i
+    end
+  end
 end
 
 RSpec.describe "CustomModel" do
@@ -407,4 +429,28 @@ RSpec.describe "CustomModel" do
       end
     end
   end
+
+  context "with custom methods" do
+    describe ".xml serialization" do
+      it "handles custom content mapping methods" do
+        xml = '<custom-id prefix="ABC">ABC-123</custom-id>'
+
+        instance = CustomModelSpecs::Id.new
+        instance.id = 123
+        instance.prefix = "ABC"
+        result_xml = CustomModelSpecs::CustomId.to_xml(instance)
+        expect(result_xml).to eq(xml)
+      end
+    end
+
+    describe ".xml deserialization" do
+      it "handles custom content mapping methods" do
+        xml = '<custom-id prefix="ABC">ABC-123</custom-id>'
+        instance = CustomModelSpecs::CustomId.from_xml(xml)
+
+        expect(instance.id).to eq(123)
+        expect(instance.prefix).to eq("ABC")
+      end
+    end
+  end
 end