lutaml-model 0.5.3 → 0.5.4

data/lib/lutaml/model/schema.rb

@@ -2,6 +2,7 @@ require_relative "schema/json_schema"
 require_relative "schema/xsd_schema"
 require_relative "schema/relaxng_schema"
 require_relative "schema/yaml_schema"
+require_relative "schema/xml_compiler"
 
 module Lutaml
   module Model
@@ -21,6 +22,10 @@ module Lutaml
       def self.to_yaml(klass, options = {})
         YamlSchema.generate(klass, options)
       end
+
+      def self.from_xml(xml, options = {})
+        XmlCompiler.to_models(xml, options)
+      end
     end
   end
 end

data/lib/lutaml/model/serialize.rb

@@ -269,6 +269,11 @@ module Lutaml
 
             value = instance.send(name)
 
+            if rule.raw_mapping?
+              adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
+              return adapter.parse(value, options)
+            end
+
             attribute = attributes[name]
 
             next hash.merge!(generate_hash_from_child_mappings(attribute, value, format, rule.root_mappings)) if rule.root_mapping?
@@ -450,11 +455,11 @@ module Lutaml
             instance.mixed = mappings_for(:xml).mixed_content? || options[:mixed_content]
           end
 
-          if doc["__schema_location"]
+          if doc["attributes"]&.key?("__schema_location")
             instance.schema_location = Lutaml::Model::SchemaLocation.new(
-              schema_location: doc["__schema_location"][:schema_location],
-              prefix: doc["__schema_location"][:prefix],
-              namespace: doc["__schema_location"][:namespace],
+              schema_location: doc["attributes"]["__schema_location"][:schema_location],
+              prefix: doc["attributes"]["__schema_location"][:prefix],
+              namespace: doc["attributes"]["__schema_location"][:namespace],
             )
           end
 
@@ -465,18 +470,17 @@ module Lutaml
 
             attr = attribute_for_rule(rule)
 
-            namespaced_names = rule.namespaced_names(options[:default_namespace])
-
             value = if rule.raw_mapping?
                       doc.node.inner_xml
                     elsif rule.content_mapping?
                       doc[rule.content_key]
-                    elsif key = (namespaced_names & doc.keys).first
-                      doc[key]
+                    elsif val = value_for_rule(doc, rule, options)
+                      val
                     else
                       defaults_used << rule.to
                       attr&.default || rule.to_value_for(instance)
                     end
+
             value = normalize_xml_value(value, rule, attr, options)
             rule.deserialize(instance, value, attributes, self)
           end
@@ -488,6 +492,15 @@ module Lutaml
           instance
         end
 
+        def value_for_rule(doc, rule, options)
+          rule_names = rule.namespaced_names(options[:default_namespace])
+          hash = rule.attribute? ? doc["attributes"] : doc["elements"]
+          return unless hash
+
+          value_key = rule_names.find { |name| hash.key_exist?(name) }
+          hash.fetch(value_key) if value_key
+        end
+
         def apply_hash_mapping(doc, instance, format, options = {})
           mappings = options[:mappings] || mappings_for(format).mappings
           mappings.each do |rule|
@@ -500,6 +513,9 @@ module Lutaml
             value = names.collect do |rule_name|
               if rule.root_mapping?
                 doc
+              elsif rule.raw_mapping?
+                adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
+                adapter.new(doc).public_send(:"to_#{format}")
               elsif doc.key?(rule_name.to_s)
                 doc[rule_name.to_s]
               elsif doc.key?(rule_name.to_sym)

data/lib/lutaml/model/toml_adapter/toml_rb_adapter.rb

@@ -6,8 +6,7 @@ module Lutaml
     module TomlAdapter
       class TomlRbAdapter < TomlDocument
         def self.parse(toml, _options = {})
-          data = TomlRB.parse(toml)
-          new(data)
+          TomlRB.parse(toml)
         end
 
         def to_toml(*)

data/lib/lutaml/model/type/hash.rb

@@ -19,18 +19,18 @@ module Lutaml
 
           hash = hash.to_h if hash.is_a?(Lutaml::Model::MappingHash)
 
-          hash = hash.except("text")
-
-          hash.transform_values do |value|
-            if value.is_a?(::Hash)
-              # Only process if value is a Hash
-              nested = normalize_hash(value)
-              # Only include non-text nodes in nested hashes if it's a hash
-              nested.is_a?(::Hash) ? nested.except("text") : nested
-            else
-              value
-            end
+          normalized_hash = hash.transform_values do |value|
+            normalize_value(value)
           end
+
+          normalized_hash["elements"] || normalized_hash
+        end
+
+        def self.normalize_value(value)
+          return value unless value.is_a?(::Hash)
+
+          nested = normalize_hash(value)
+          nested.is_a?(::Hash) ? nested.except("text") : nested
         end
 
         def self.serialize(value)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.5.3"
+    VERSION = "0.5.4"
   end
 end

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

@@ -124,7 +124,11 @@ module Lutaml
           end
 
           attributes = {}
-          node.attributes.transform_values do |attr|
+
+          # Using `attribute_nodes` instead of `attributes` because
+          # `attribute_nodes` handles name collisions as well
+          # More info: https://devdocs.io/nokogiri/nokogiri/xml/node#method-i-attributes
+          node.attribute_nodes.each do |attr|
             name = if attr.namespace
                      "#{attr.namespace.prefix}:#{attr.name}"
                    else

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

@@ -77,26 +77,21 @@ module Lutaml
           result.node = element
           result.item_order = element.order
 
-          element.children.each_with_object(result) do |child, hash|
+          element.children.each do |child|
             if klass&.<= Serialize
               attr = klass.attribute_for_child(child.name,
                                                format)
             end
 
-            value = if child.text?
-                      child.text
-                    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
+            next result.assign_or_append_value(child.name, child.text) if child.text?
+
+            result["elements"] ||= Lutaml::Model::MappingHash.new
+            result["elements"].assign_or_append_value(child.namespaced_name, parse_element(child, attr&.type || klass, format))
           end
 
-          result.merge(attributes_hash(element))
+          result["attributes"] = attributes_hash(element) if element.attributes&.any?
+
+          result
         end
 
         def attributes_hash(element)
@@ -167,8 +162,9 @@ module Lutaml
         def add_value(xml, value, attribute, cdata: false)
           if !value.nil?
             serialized_value = attribute.type.serialize(value)
-
-            if attribute.type == Lutaml::Model::Type::Hash
+            if attribute.raw?
+              xml.add_xml_fragment(xml, value)
+            elsif attribute.type == Lutaml::Model::Type::Hash
               serialized_value.each do |key, val|
                 xml.create_and_add_element(key) do |element|
                   element.text(val)

data/lib/lutaml/model/xml_mapping.rb

@@ -149,10 +149,10 @@ module Lutaml
         prefix: (prefix_set = false
                  nil)
       )
-        validate!("__raw_mapping", to, with, type: TYPES[:all_content])
+        validate!(Constants::RAW_MAPPING_KEY, to, with, type: TYPES[:all_content])
 
         rule = XmlMappingRule.new(
-          "__raw_mapping",
+          Constants::RAW_MAPPING_KEY,
           to: to,
           render_nil: render_nil,
           render_default: render_default,
@@ -168,6 +168,8 @@ module Lutaml
         @raw_mapping = rule
       end
 
+      alias map_all_content map_all
+
       def validate!(key, to, with, type: nil)
         validate_mappings!(type)
 

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -59,10 +59,6 @@ module Lutaml
         name.nil?
       end
 
-      def raw_mapping?
-        name == "__raw_mapping"
-      end
-
       def content_key
         cdata ? "#cdata-section" : "text"
       end
@@ -111,6 +107,7 @@ module Lutaml
           prefix: prefix.dup,
           mixed_content: mixed_content,
           namespace_set: namespace_set?,
+          attribute: attribute,
           prefix_set: prefix_set?,
           default_namespace: default_namespace.dup,
         )

data/lib/lutaml/model.rb

@@ -10,6 +10,7 @@ require_relative "model/yaml_adapter/standard_yaml_adapter"
 require_relative "model/xml_adapter"
 require_relative "model/toml_adapter"
 require_relative "model/error"
+require_relative "model/constants"
 
 module Lutaml
   module Model

data/spec/fixtures/xml/invalid_math_document.xml

@@ -0,0 +1,4 @@
+<MathDocument>
+  <Title>Example Title</Title>
+  <IPV4Address>Example Address</IPV4Address>
+</MathDocument>

data/spec/fixtures/xml/math_document_schema.xsd

@@ -0,0 +1,56 @@
+<schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.openxmlformats.org/officeDocument/2006/math">
+  <xs:simpleType name="StringDatatype">
+    <xs:annotation>
+      <xs:documentation>
+        A string data type to be used for the example. 
+      </xs:documentation>
+    </xs:annotation>
+    <xs:restriction base="xs:string"></xs:restriction>
+  </xs:simpleType>
+
+  <xs:simpleType name="IPV4AddressDatatype">
+    <xs:annotation>
+      <xs:documentation>
+        An Internet Protocol version 4 address represented using dotted-quad syntax as defined in section 3.2 of RFC2673.
+      </xs:documentation>
+    </xs:annotation>
+    <xs:restriction base="StringDatatype">
+      <xs:pattern value="((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9]).){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])" />
+    </xs:restriction>
+  </xs:simpleType>
+
+  <xs:simpleType name="whiteSpaces">
+    <xs:annotation>
+      <xs:documentation>
+        A non-empty string of Unicode characters with leading and trailing whitespace
+          disallowed. Whitespace is: U+9, U+10, U+32 or [ \n\t]+
+      </xs:documentation>
+    </xs:annotation>
+    <xs:restriction base="xs:string">
+      <xs:annotation>
+        <xs:documentation>
+          The 'string' datatype restricts the XSD type by prohibiting leading 
+          and trailing whitespace, and something (not only whitespace) is required.
+        </xs:documentation>
+      </xs:annotation>
+      <xs:pattern value="\S(.*\S)?">
+        <xs:annotation>
+          <xs:documentation>
+            This pattern ensures that leading and trailing whitespace is
+            disallowed. This helps to even the user experience between implementations
+            related to whitespace.
+          </xs:documentation>
+        </xs:annotation>
+      </xs:pattern>
+    </xs:restriction>
+  </xs:simpleType>
+
+  <xs:complexType name="MathDocument">
+    <xs:choice>
+      <xs:element name="Title" type="whiteSpaces"/>
+      <xs:element name="IPV4Address" type="IPV4AddressDatatype"/>
+    </xs:choice>
+  </xs:complexType>
+
+  <xs:element name="MathDocument" type="MathDocument"/>
+</schema>

data/spec/fixtures/xml/test_schema.xsd

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="qualified" blockDefault="#all" targetNamespace="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <xsd:simpleType name="ST_Integer255">
+    <xsd:annotation>
+      <xsd:documentation>Integer value (1 to 255)</xsd:documentation>
+    </xsd:annotation>
+    <xsd:restriction base="xsd:integer">
+      <xsd:minInclusive value="1" />
+      <xsd:maxInclusive value="255" />
+    </xsd:restriction>
+  </xsd:simpleType>
+  <xsd:complexType name="CT_Integer255">
+    <xsd:attribute name="val" type="ST_Integer255" use="required">
+      <xsd:annotation>
+        <xsd:documentation>Value</xsd:documentation>
+      </xsd:annotation>
+    </xsd:attribute>
+  </xsd:complexType>
+  <xsd:simpleType name="ST_Integer2">
+    <xsd:annotation>
+      <xsd:documentation>Integer value (-2 to 2)</xsd:documentation>
+    </xsd:annotation>
+    <xsd:restriction base="xsd:integer">
+      <xsd:minInclusive value="-2" />
+      <xsd:maxInclusive value="2" />
+    </xsd:restriction>
+  </xsd:simpleType>
+  <xsd:complexType name="CT_Integer2">
+    <xsd:attribute name="val" type="ST_Integer2" use="required">
+      <xsd:annotation>
+        <xsd:documentation>Value</xsd:documentation>
+      </xsd:annotation>
+    </xsd:attribute>
+  </xsd:complexType>
+  <xsd:element name="MathTest" type="CT_Integer255">
+    <xsd:annotation>
+      <xsd:documentation>Main Test class</xsd:documentation>
+    </xsd:annotation>
+  </xsd:element>
+  <xsd:element name="MathTest1" type="CT_Integer2">
+    <xsd:annotation>
+      <xsd:documentation>Main Test class</xsd:documentation>
+    </xsd:annotation>
+  </xsd:element>
+  <xsd:complexType name="CT_MathTest">
+    <xsd:group>
+      <xsd:sequence>
+        <xsd:element ref="MathTest" />
+        <xsd:element ref="MathTest1" />
+      </xsd:sequence>
+    </xsd:group>
+  </xsd:complexType>
+</xsd:schema>

data/spec/fixtures/xml/valid_math_document.xml

@@ -0,0 +1,4 @@
+<MathDocument>
+  <Title>Example Title</Title>
+  <IPV4Address>192.168.1.1</IPV4Address>
+</MathDocument>

data/spec/lutaml/model/cdata_spec.rb

@@ -118,8 +118,8 @@ module CDATA
     def child_from_xml(model, value)
       model.child_mapper ||= CustomModelChild.new
 
-      model.child_mapper.street = value["street"].text
-      model.child_mapper.city = value["city"].text
+      model.child_mapper.street = value["elements"]["street"].text
+      model.child_mapper.city = value["elements"]["city"].text
     end
   end
 

data/spec/lutaml/model/custom_model_spec.rb

@@ -56,8 +56,8 @@ class CustomModelParentMapper < Lutaml::Model::Serializable
   def child_from_xml(model, value)
     model.child_mapper ||= CustomModelChild.new
 
-    model.child_mapper.street = value["street"].text
-    model.child_mapper.city = value["city"].text
+    model.child_mapper.street = value["elements"]["street"].text
+    model.child_mapper.city = value["elements"]["city"].text
   end
 end
 
@@ -126,10 +126,10 @@ module CustomModelSpecs
 
     def bibdata_from_xml(model, value)
       model.bibdata = BibliographicItem.new(
-        "type" => value["type"],
-        "title" => value["title"],
-        "language" => value["title"]["language"],
-        "schema_version" => value["schema-version"],
+        "type" => value["attributes"]["type"],
+        "title" => value["elements"]["title"],
+        "language" => value["elements"]["title"]["attributes"]["language"],
+        "schema_version" => value["attributes"]["schema-version"],
       )
     end
 
@@ -410,22 +410,9 @@ RSpec.describe "CustomModel" do
           </MixedWithNestedContent>
         XML
 
-        expected_xml = <<~XML
-          <MixedWithNestedContent>
-            <street>
-              A &lt;p&gt;b&lt;/p&gt; B &lt;p&gt;c&lt;/p&gt; C
-            </street>
-            <bibdata type="collection" schema-version="v1.2.8">
-              <title language="en">
-                JCGM Collection 1
-              </title>
-            </bibdata>
-          </MixedWithNestedContent>
-        XML
-
         bibdata = CustomModelSpecs::MixedWithNestedContent.from_xml(xml)
 
-        expect(bibdata.to_xml).to be_equivalent_to(expected_xml)
+        expect(bibdata.to_xml).to be_equivalent_to(xml)
       end
     end
   end

data/spec/lutaml/model/key_value_mapping_spec.rb

@@ -83,4 +83,31 @@ RSpec.describe Lutaml::Model::KeyValueMapping do
       expect(m.custom_methods.object_id).not_to eq(dup_m.custom_methods.object_id)
     end
   end
+
+  context "with map_all option" do
+    before do
+      mapping.map_all(
+        render_nil: true,
+        delegate: :container,
+      )
+    end
+
+    it "handles JSON mapping" do
+      expect(mapping.mappings[0].render_nil).to be true
+      expect(mapping.mappings[0].delegate).to eq(:container)
+      expect(mapping.mappings[0].raw_mapping?).to be true
+    end
+
+    it "handles YAML mapping" do
+      expect(mapping.mappings[0].render_nil).to be true
+      expect(mapping.mappings[0].delegate).to eq(:container)
+      expect(mapping.mappings[0].raw_mapping?).to be true
+    end
+
+    it "handles TOML mapping" do
+      expect(mapping.mappings[0].render_nil).to be true
+      expect(mapping.mappings[0].delegate).to eq(:container)
+      expect(mapping.mappings[0].raw_mapping?).to be true
+    end
+  end
 end

data/spec/lutaml/model/map_all_spec.rb

@@ -0,0 +1,188 @@
+require "spec_helper"
+
+module MapAllSpec
+  class Document < Lutaml::Model::Serializable
+    attribute :content, :string
+
+    xml do
+      root "document"
+      map_all to: :content
+    end
+
+    json do
+      map_all to: :content
+    end
+
+    yaml do
+      map_all to: :content
+    end
+
+    toml do
+      map_all to: :content
+    end
+  end
+
+  class InvalidDocument < Lutaml::Model::Serializable
+    attribute :content, :string
+    attribute :title, :string
+
+    json do
+      map_all to: :content
+    end
+
+    yaml do
+      map_element "title", to: :title
+    end
+  end
+
+  RSpec.describe "MapAll" do
+    describe "XML serialization" do
+      let(:xml_content) do
+        <<~XML
+          <document>
+            Content with <b>tags</b> and <i>formatting</i>.
+            <metadata>
+              <author>John Doe</author>
+              <date>2024-01-15</date>
+            </metadata>
+          </document>
+        XML
+      end
+
+      let(:sub_xml_content) do
+        <<~XML
+          Content with <b>tags</b> and <i>formatting</i>.
+          <metadata>
+            <author>John Doe</author>
+            <date>2024-01-15</date>
+          </metadata>
+        XML
+      end
+
+      it "captures all XML content" do
+        doc = Document.from_xml(xml_content)
+        expect(doc.content).to be_equivalent_to(sub_xml_content)
+      end
+
+      it "preserves XML content through round trip" do
+        doc = Document.from_xml(xml_content)
+        regenerated = doc.to_xml
+        expect(regenerated).to be_equivalent_to(xml_content)
+      end
+    end
+
+    describe "JSON serialization" do
+      let(:json_content) do
+        {
+          "sections" => [
+            { "title" => "Introduction", "text" => "Chapter 1" },
+            { "title" => "Conclusion", "text" => "Final chapter" },
+          ],
+          "metadata" => {
+            "author" => "John Doe",
+            "date" => "2024-01-15",
+          },
+        }.to_json
+      end
+
+      it "captures all JSON content" do
+        doc = Document.from_json(json_content)
+        parsed = JSON.parse(doc.content)
+        expect(parsed["sections"].first["title"]).to eq("Introduction")
+        expect(parsed["metadata"]["author"]).to eq("John Doe")
+      end
+
+      it "preserves JSON content through round trip" do
+        doc = Document.from_json(json_content)
+        regenerated = doc.to_json
+        expect(JSON.parse(regenerated)).to eq(JSON.parse(json_content))
+      end
+    end
+
+    describe "YAML serialization" do
+      let(:yaml_content) do
+        <<~YAML
+          sections:
+            - title: Introduction
+              text: Chapter 1
+            - title: Conclusion
+              text: Final chapter
+          metadata:
+            author: John Doe
+            date: 2024-01-15
+        YAML
+      end
+
+      it "captures all YAML content" do
+        doc = Document.from_yaml(yaml_content)
+        parsed = YAML.safe_load(doc.content, permitted_classes: [Date])
+        expect(parsed["sections"].first["title"]).to eq("Introduction")
+        expect(parsed["metadata"]["author"]).to eq("John Doe")
+      end
+
+      it "preserves YAML content through round trip" do
+        doc = Document.from_yaml(yaml_content)
+        regenerated = doc.to_yaml
+        expect(YAML.safe_load(regenerated, permitted_classes: [Date])).to eq(YAML.safe_load(yaml_content, permitted_classes: [Date]))
+      end
+    end
+
+    describe "TOML serialization" do
+      let(:toml_content) do
+        <<~TOML
+          title = "Document Title"
+
+          [metadata]
+          author = "John Doe"
+          date = "2024-01-15"
+
+          [[sections]]
+          title = "Introduction"
+          text = "Chapter 1"
+
+          [[sections]]
+          title = "Conclusion"
+          text = "Final chapter"
+        TOML
+      end
+
+      it "captures all TOML content" do
+        doc = Document.from_toml(toml_content)
+        parsed = TomlRB.parse(doc.content)
+        expect(parsed["sections"].first["title"]).to eq("Introduction")
+        expect(parsed["metadata"]["author"]).to eq("John Doe")
+      end
+
+      it "preserves TOML content through round trip" do
+        doc = Document.from_toml(toml_content)
+        regenerated = doc.to_toml
+        expect(TomlRB.parse(regenerated)).to eq(TomlRB.parse(toml_content))
+      end
+    end
+
+    describe "invalid mapping combinations" do
+      it "raises error when combining map_all with other mappings" do
+        expect do
+          InvalidDocument.json do
+            map_element "title", to: :title
+          end
+        end.to raise_error(
+          StandardError,
+          "map_all is not allowed with other mappings",
+        )
+      end
+
+      it "raises error when combining other mappings are used with map_all" do
+        expect do
+          InvalidDocument.yaml do
+            map_element "title", to: :title
+            map_all to: :content
+          end
+        end.to raise_error(
+          StandardError,
+          "map_all is not allowed with other mappings",
+        )
+      end
+    end
+  end
+end