lutaml-model 0.3.30 → 0.5.0

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

data/spec/lutaml/model/custom_serialization_spec.rb

@@ -138,6 +138,22 @@ RSpec.describe CustomSerialization do
     end
   end
 
+  context "with partial JSON input" do
+    it "deserializes from JSON with missing attributes" do
+      json = {
+        name: "JSON Masterpiece: Vase",
+        color: "BLUE",
+      }.to_json
+
+      ceramic = described_class.from_json(json)
+
+      expect(ceramic.full_name).to eq("Vase")
+      expect(ceramic.color).to eq("blue")
+      expect(ceramic.size).to be_nil
+      expect(ceramic.description).to be_nil
+    end
+  end
+
   context "with XML serialization" do
     it "serializes to XML with custom methods" do
       expected_xml = <<~XML

data/spec/lutaml/model/enum_spec.rb

@@ -0,0 +1,131 @@
+require "spec_helper"
+require "lutaml/model"
+
+module EnumSpec
+  class WithEnum < Lutaml::Model::Serializable
+    attribute :without_enum, :string
+    attribute :single_value, :string, values: %w[user admin super_admin]
+    attribute :multi_value, :string, values: %w[singular dual plural], collection: true
+  end
+end
+
+RSpec.describe "Enum" do
+  let(:single_value_attr) do
+    EnumSpec::WithEnum.attributes[:single_value]
+  end
+
+  let(:multi_value_attr) do
+    EnumSpec::WithEnum.attributes[:multi_value]
+  end
+
+  let(:without_enum_attr) do
+    EnumSpec::WithEnum.attributes[:without_enum]
+  end
+
+  let(:object) do
+    EnumSpec::WithEnum.new
+  end
+
+  context "when values are provided for an attribute" do
+    it "is marked as enum for single_value" do
+      expect(single_value_attr.enum?).to be(true)
+    end
+
+    it "is marked as enum for multi_value" do
+      expect(multi_value_attr.enum?).to be(true)
+    end
+
+    context "with enum convinience methods" do
+      describe "#single_value" do
+        it "returns single value" do
+          expect { object.single_value = "user" }
+            .to change(object, :single_value)
+            .from(nil)
+            .to("user")
+        end
+      end
+
+      describe "#multi_value" do
+        it "returns single value in array" do
+          expect { object.multi_value = "dual" }
+            .to change(object, :multi_value)
+            .from([])
+            .to(["dual"])
+        end
+
+        it "returns multiple value in array" do
+          expect { object.multi_value = %w[dual plural] }
+            .to change(object, :multi_value)
+            .from([])
+            .to(%w[dual plural])
+        end
+      end
+
+      EnumSpec::WithEnum.enums.each_value do |enum_attr|
+        enum_attr.enum_values.each do |value|
+          describe "##{value}=" do
+            it "sets the #{value} if true" do
+              expect { object.public_send(:"#{value}=", true) }
+                .to change { object.public_send(:"#{value}?") }
+                .from(false)
+                .to(true)
+            end
+
+            it "unsets the #{value} if false" do
+              object.public_send(:"#{value}=", true)
+
+              expect { object.public_send(:"#{value}=", false) }
+                .to change(object, "#{value}?")
+                .from(true)
+                .to(false)
+            end
+          end
+
+          describe "##{value}!" do
+            it "method #{value}? should be present" do
+              expect(object.respond_to?(:"#{value}!")).to be(true)
+            end
+
+            it "sets #{value} to true for enum" do
+              expect { object.public_send(:"#{value}!") }
+                .to change(object, "#{value}?")
+                .from(false)
+                .to(true)
+            end
+          end
+
+          describe "##{value}?" do
+            it "method #{value}? should be present" do
+              expect(object.respond_to?(:"#{value}?")).to be(true)
+            end
+
+            it "is false if role is not #{value}" do
+              expect(object.public_send(:"#{value}?")).to be(false)
+            end
+
+            it "is true if role is set to #{value}" do
+              expect { object.public_send(:"#{value}=", value) }
+                .to change(object, "#{value}?")
+                .from(false)
+                .to(true)
+            end
+          end
+
+          it "adds a method named #{value}=" do
+            expect(object.respond_to?(:"#{value}?")).to be(true)
+          end
+
+          it "adds a method named #{value}!" do
+            expect(object.respond_to?(:"#{value}!")).to be(true)
+          end
+        end
+      end
+    end
+  end
+
+  context "when values are not provided for an attribute" do
+    it "is not marked as enum" do
+      expect(without_enum_attr.enum?).to be(false)
+    end
+  end
+end