lutaml-model 0.5.2 → 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,17 +269,22 @@ 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(value, format, rule.root_mappings)) if rule.root_mapping?
+            next hash.merge!(generate_hash_from_child_mappings(attribute, value, format, rule.root_mappings)) if rule.root_mapping?
 
             value = if rule.child_mappings
-                      generate_hash_from_child_mappings(value, format, rule.child_mappings)
+                      generate_hash_from_child_mappings(attribute, value, format, rule.child_mappings)
                     else
                       attribute.serialize(value, format, options)
                     end
 
-            next if Utils.blank?(value) && !rule.render_nil
+            next unless rule.render?(value)
 
             rule_from_name = rule.multiple_mappings? ? rule.from.first.to_s : rule.from.to_s
             hash[rule_from_name] = value
@@ -346,7 +351,7 @@ module Lutaml
           end
         end
 
-        def generate_hash_from_child_mappings(value, format, child_mappings)
+        def generate_hash_from_child_mappings(attr, value, format, child_mappings)
           return value unless child_mappings
 
           hash = {}
@@ -365,7 +370,11 @@ module Lutaml
           value.each do |child_obj|
             map_key = nil
             map_value = {}
+            mapping_rules = attr.type.mappings_for(format)
+
             child_mappings.each do |attr_name, path|
+              mapping_rule = mapping_rules.find_by_to(attr_name)
+
               attr_value = child_obj.send(attr_name)
 
               attr_value = if attr_value.is_a?(Lutaml::Model::Serialize)
@@ -376,7 +385,7 @@ module Lutaml
                              attr_value
                            end
 
-              next if Utils.blank?(attr_value)
+              next unless mapping_rule&.render?(attr_value)
 
               if path == :key
                 map_key = attr_value
@@ -446,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
 
@@ -461,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
@@ -484,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|
@@ -496,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/utils.rb

@@ -42,6 +42,13 @@ module Lutaml
           value.respond_to?(:empty?) ? value.empty? : value.nil?
         end
 
+        def empty_collection?(collection)
+          return false if collection.nil?
+          return false unless [Array, Hash].include?(collection.class)
+
+          collection.empty?
+        end
+
         def add_method_if_not_defined(klass, method_name, &block)
           unless klass.method_defined?(method_name)
             klass.class_eval do

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.5.2"
+    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