lutaml-model 0.5.3 → 0.6.0

data/lib/lutaml/model/xml_mapping.rb

@@ -16,11 +16,13 @@ module Lutaml
                   :namespace_uri,
                   :namespace_prefix,
                   :mixed_content,
-                  :ordered
+                  :ordered,
+                  :element_sequence
 
       def initialize
         @elements = {}
         @attributes = {}
+        @element_sequence = []
         @content_mapping = nil
         @raw_mapping = nil
         @mixed_content = false
@@ -35,6 +37,18 @@ module Lutaml
         @ordered = ordered || mixed # mixed contenet will always be ordered
       end
 
+      def root?
+        !!root_element
+      end
+
+      def no_root
+        @no_root = true
+      end
+
+      def no_root?
+        !!@no_root
+      end
+
       def prefixed_root
         if namespace_uri && namespace_prefix
           "#{namespace_prefix}:#{root_element}"
@@ -44,6 +58,8 @@ module Lutaml
       end
 
       def namespace(uri, prefix = nil)
+        raise Lutaml::Model::NoRootNamespaceError if no_root?
+
         @namespace_uri = uri
         @namespace_prefix = prefix
       end
@@ -60,7 +76,8 @@ module Lutaml
         namespace: (namespace_set = false
                     nil),
         prefix: (prefix_set = false
-                 nil)
+                 nil),
+        transform: {}
       )
         validate!(name, to, with, type: TYPES[:element])
 
@@ -77,6 +94,7 @@ module Lutaml
           prefix: prefix,
           namespace_set: namespace_set != false,
           prefix_set: prefix_set != false,
+          transform: transform,
         )
         @elements[rule.namespaced_name] = rule
       end
@@ -149,10 +167,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 +186,23 @@ module Lutaml
         @raw_mapping = rule
       end
 
+      alias map_all_content map_all
+
+      def sequence(&block)
+        @element_sequence << Sequence.new(self).tap do |s|
+          s.instance_eval(&block)
+        end
+      end
+
+      def import_model_mappings(model)
+        raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+
+        mappings = model.mappings_for(:xml)
+        @elements.merge!(mappings.instance_variable_get(:@elements))
+        @attributes.merge!(mappings.instance_variable_get(:@attributes))
+        (@element_sequence << mappings.element_sequence).flatten!
+      end
+
       def validate!(key, to, with, type: nil)
         validate_mappings!(type)
 
@@ -241,14 +276,23 @@ module Lutaml
                                               ordered: @ordered)
           xml_mapping.namespace(@namespace_uri.dup, @namespace_prefix.dup)
 
-          xml_mapping.instance_variable_set(:@attributes,
-                                            dup_mappings(@attributes))
-          xml_mapping.instance_variable_set(:@elements, dup_mappings(@elements))
-          xml_mapping.instance_variable_set(:@content_mapping,
-                                            @content_mapping&.deep_dup)
+          attributes_to_dup.each do |var_name|
+            value = instance_variable_get(var_name)
+            xml_mapping.instance_variable_set(var_name, Utils.deep_dup(value))
+          end
         end
       end
 
+      def attributes_to_dup
+        @attributes_to_dup ||= %i[
+          @content_mapping
+          @raw_mapping
+          @element_sequence
+          @attributes
+          @elements
+        ]
+      end
+
       def dup_mappings(mappings)
         new_mappings = {}
 

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,
+        transform: {}
       )
         super(
           name,
@@ -28,7 +29,8 @@ module Lutaml
           render_default: render_default,
           with: with,
           delegate: delegate,
-          attribute: attribute
+          attribute: attribute,
+          transform: transform
         )
 
         @namespace = if namespace.to_s == "inherit"
@@ -59,10 +61,6 @@ module Lutaml
         name.nil?
       end
 
-      def raw_mapping?
-        name == "__raw_mapping"
-      end
-
       def content_key
         cdata ? "#cdata-section" : "text"
       end
@@ -105,14 +103,18 @@ module Lutaml
           name.dup,
           to: to,
           render_nil: render_nil,
+          render_default: render_default,
           with: Utils.deep_dup(custom_methods),
           delegate: delegate,
           namespace: namespace.dup,
           prefix: prefix.dup,
           mixed_content: mixed_content,
+          cdata: cdata,
           namespace_set: namespace_set?,
           prefix_set: prefix_set?,
+          attribute: attribute,
           default_namespace: default_namespace.dup,
+          transform: transform.dup,
         )
       end
     end

data/lib/lutaml/model.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "moxml"
 require_relative "model/version"
 require_relative "model/loggable"
 require_relative "model/type"
@@ -10,6 +11,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/lutaml-model.gemspec

@@ -30,6 +30,11 @@ Gem::Specification.new do |spec|
   end
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
 
+  # TODO: remove once https://github.com/Shopify/liquid/issues/1772 is fixed
+  # needed for liquid with ruby 3.4
+  spec.add_dependency "base64"
+  spec.add_dependency "liquid", "~> 5"
+  spec.add_dependency "moxml", ">= 0.1.2"
   spec.add_dependency "thor"
   spec.metadata["rubygems_mfa_required"] = "true"
 end

data/spec/benchmarks/xml_parsing_benchmark_spec.rb

@@ -0,0 +1,75 @@
+require "benchmark"
+require "benchmark/ips"
+require "lutaml/model"
+require "lutaml/model/xml_adapter/oga_adapter"
+
+RSpec.describe "LutaML Model Performance" do
+  after do
+    Lutaml::Model::Config.xml_adapter = Lutaml::Model::XmlAdapter::NokogiriAdapter
+  end
+
+  let(:large_xml) do
+    xml = "<root>\n"
+    1000.times do |i|
+      xml += "<item id='#{i}'><name>Test #{i}</name><value>#{i}</value></item>\n"
+    end
+    xml += "</root>"
+    xml
+  end
+
+  class DeserializerItem < Lutaml::Model::Serializable
+    attribute :id, :integer
+    attribute :name, :string
+    attribute :value, :integer
+
+    xml do
+      map_attribute "id", to: :id
+      map_element "value", to: :value
+      map_element "name", to: :name
+      map_element "value", to: :value
+    end
+  end
+
+  class Deserializer < Lutaml::Model::Serializable
+    attribute :item, DeserializerItem, collection: true
+
+    xml do
+      root "root"
+      map_element "item", to: :item
+    end
+  end
+
+  it "measures parsing performance across adapters" do
+    report = Benchmark.ips do |x|
+      x.config(time: 5, warmup: 2)
+
+      x.report("Nokogiri Adapter") do
+        Deserializer.from_xml(large_xml)
+      end
+
+      x.report("Ox Adapter") do
+        Lutaml::Model::Config.xml_adapter = Lutaml::Model::XmlAdapter::OxAdapter
+        Deserializer.from_xml(large_xml)
+      end
+
+      x.report("Oga Adapter") do
+        Lutaml::Model::Config.xml_adapter = Lutaml::Model::XmlAdapter::OgaAdapter
+        Deserializer.from_xml(large_xml)
+      end
+
+      x.compare!
+    end
+
+    thresholds = {
+      "Nokogiri Adapter" => 5,
+      "Ox Adapter" => 15,
+      "Oga Adapter" => 5,
+    }
+
+    report.entries.each do |entry|
+      puts "#{entry.label} performance: #{entry.ips.round(2)} ips"
+      expect(entry.ips).to be >= thresholds[entry.label],
+                           "#{entry.label} performance below threshold: got #{entry.ips.round(2)} ips, expected >= #{thresholds[entry.label]} ips"
+    end
+  end
+end

data/spec/ceramic_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+require_relative "fixtures/ceramic"
+
+RSpec.describe Ceramic do
+  xml = <<~XML
+    <ceramic kilnFiringTimeAttribute="2012-04-07T01:51:37.112+02:00">
+      <kilnFiringTime>2012-04-07T01:51:37.112+02:00</kilnFiringTime>
+    </ceramic>
+  XML
+
+  it "deserializes from XML with high-precision date-time" do
+    ceramic = described_class.from_xml(xml)
+    expect(ceramic.kiln_firing_time.strftime("%Y-%m-%dT%H:%M:%S.%L%:z")).to eq("2012-04-07T01:51:37.112+02:00")
+  end
+
+  it "serializes to XML with high-precision date-time" do
+    ceramic = described_class.from_xml(xml)
+    expect(ceramic.to_xml).to be_equivalent_to(xml)
+  end
+
+  it "deserializes from JSON with high-precision date-time" do
+    json = {
+      kilnFiringTime: "2012-04-07T01:51:37+02:00",
+    }.to_json
+
+    ceramic_from_json = described_class.from_json(json)
+    expect(ceramic_from_json.kiln_firing_time).to eq(DateTime.new(2012, 4, 7, 1, 51, 37, "+02:00"))
+  end
+
+  it "serializes to JSON with high-precision date-time" do
+    ceramic = described_class.from_xml(xml)
+    expected_json = {
+      kilnFiringTime: "2012-04-07T01:51:37+02:00",
+      kilnFiringTimeAttribute: "2012-04-07T01:51:37+02:00",
+    }.to_json
+
+    expect(ceramic.to_json).to eq(expected_json)
+  end
+end

data/spec/fixtures/ceramic.rb

@@ -0,0 +1,23 @@
+require "lutaml/model"
+
+class HighPrecisionDateTime < Lutaml::Model::Type::DateTime
+  def to_xml
+    value.strftime("%Y-%m-%dT%H:%M:%S.%L%:z")
+  end
+end
+
+class Ceramic < Lutaml::Model::Serializable
+  attribute :kiln_firing_time, HighPrecisionDateTime
+  attribute :kiln_firing_time_attribute, HighPrecisionDateTime
+
+  xml do
+    root "ceramic"
+    map_element "kilnFiringTime", to: :kiln_firing_time
+    map_attribute "kilnFiringTimeAttribute", to: :kiln_firing_time_attribute
+  end
+
+  json do
+    map "kilnFiringTime", to: :kiln_firing_time
+    map "kilnFiringTimeAttribute", to: :kiln_firing_time_attribute
+  end
+end

data/spec/fixtures/xml/address_example_260.xsd

@@ -0,0 +1,9 @@
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="qualified">
+  <xs:element name="Address" type="Address"/>
+  <xs:complexType name="Address" mixed="true">
+    <xs:sequence>
+      <xs:element name="City" type="xs:string" minOccurs="0"/>
+      <xs:element name="ZIP" type="xs:string" minOccurs="0"/>
+    </xs:sequence>
+  </xs:complexType>
+</xs:schema>

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/user.xsd

@@ -0,0 +1,10 @@
+<schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.openxmlformats.org/officeDocument/2006/math">
+  <xsd:complexType name="User">
+    <xsd:sequence>
+      <xsd:element name="id" type="xsd:nonNegativeInteger" minOccurs="1" />
+      <xsd:element name="age" type="xsd:unsignedLong" minOccurs="0" />
+      <xsd:element name="token" type="xsd:token" minOccurs="0" />
+    </xsd:sequence>
+  </xsd:complexType>
+  <xsd:element name="User" type="User"/>
+</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

@@ -44,7 +44,7 @@ module CDATA
     end
 
     def house_from_xml(model, node)
-      model.house = node
+      model.house = node.children.first.text
     end
 
     def house_to_xml(model, _parent, doc)
@@ -54,7 +54,7 @@ module CDATA
     end
 
     def city_from_xml(model, node)
-      model.city = node
+      model.city = node.children.first.text
     end
 
     def city_to_xml(model, _parent, doc)
@@ -117,9 +117,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.find_child_by_name("street").text
+      model.child_mapper.city = value.find_child_by_name("city").text
     end
   end
 

data/spec/lutaml/model/choice_spec.rb

@@ -0,0 +1,168 @@
+require "spec_helper"
+require "lutaml/model"
+
+module ChoiceSpec
+  class CandidateType < Lutaml::Model::Serializable
+    attribute :id, :integer
+    attribute :name, :string
+
+    xml do
+      map_attribute "id", to: :id
+      map_attribute "name", to: :name
+    end
+  end
+
+  class DocumentState < Lutaml::Model::Serializable
+    choice(min: 1, max: 3) do
+      attribute :signed, :boolean
+      attribute :unsigned, :boolean
+      attribute :watermarked, :boolean
+      attribute :encrypted, :boolean
+    end
+
+    attribute :candidate, CandidateType
+
+    xml do
+      map_element "signed", to: :signed
+      map_element "unsigned", to: :unsigned
+      map_element "watermarked", to: :watermarked
+      map_element "encrypted", to: :encrypted
+      map_attribute "candidate", to: :candidate
+    end
+  end
+
+  class PersonDetails < Lutaml::Model::Serializable
+    choice(min: 1, max: 3) do
+      attribute :first_name, :string
+      attribute :middle_name, :string
+      choice(min: 2, max: 2) do
+        attribute :email, :string
+        attribute :phone, :string
+        attribute :check, :string
+      end
+    end
+
+    choice(min: 1, max: 2) do
+      attribute :fb, :string
+      choice(min: 1, max: 1) do
+        attribute :insta, :string
+        attribute :last_name, :string
+      end
+    end
+
+    key_value do
+      map :first_name, to: :first_name
+      map :email, to: :email
+      map :phone, to: :phone
+      map :fb, to: :fb
+      map :insta, to: :insta
+      map :last_name, to: :last_name
+    end
+  end
+end
+
+RSpec.describe "Choice" do
+  context "with choice option" do
+    let(:mapper) { ChoiceSpec::DocumentState }
+
+    it "returns an empty array for a valid choice instance" do
+      valid_instance = mapper.new(
+        signed: true,
+        unsigned: true,
+        watermarked: false,
+        candidate: ChoiceSpec::CandidateType.new(id: 1, name: "Smith"),
+      )
+
+      expect(valid_instance.validate).to be_empty
+    end
+
+    it "returns nil for a valid instance, if given attributes for choice are within defined range" do
+      valid_instance = mapper.new(
+        watermarked: false,
+        encrypted: true,
+      )
+
+      expect(valid_instance.validate!).to be_nil
+    end
+
+    it "raises error, if attributes given for choice are out of upper bound" do
+      valid_instance = mapper.new(
+        signed: true,
+        unsigned: false,
+        watermarked: false,
+        encrypted: true,
+      )
+
+      expect do
+        valid_instance.validate!
+      end.to raise_error(Lutaml::Model::ValidationError) do |error|
+        expect(error.error_messages.join("\n")).to include("Attributes `[:signed, :unsigned, :watermarked, :encrypted]` count exceeds the upper bound `3`")
+      end
+    end
+  end
+
+  context "with nested choice option" do
+    let(:mapper) { ChoiceSpec::PersonDetails }
+
+    it "returns an empty array for a valid instance" do
+      valid_instance = mapper.new(
+        first_name: "John",
+        middle_name: "S",
+        fb: "fb",
+      )
+
+      expect(valid_instance.validate).to be_empty
+    end
+
+    it "returns nil for a valid instance" do
+      valid_instance = mapper.new(
+        email: "email",
+        phone: "02344",
+        last_name: "last_name",
+      )
+
+      expect(valid_instance.validate!).to be_nil
+    end
+
+    it "raises error, if given attribute for choice are not within upper bound" do
+      valid_instance = mapper.new(
+        first_name: "Nick",
+        email: "email",
+        phone: "phone",
+        check: "check",
+        fb: "fb",
+        insta: "insta",
+      )
+
+      expect do
+        valid_instance.validate!
+      end.to raise_error(Lutaml::Model::ValidationError) do |error|
+        expect(error.error_messages.join("\n")).to eq("Attributes `[:email, :phone, :check]` count exceeds the upper bound `2`")
+      end
+    end
+
+    it "raises error, if given attribute for choice are not within lower bound" do
+      valid_instance = mapper.new(
+        fb: "fb",
+        insta: "insta",
+      )
+
+      expect do
+        valid_instance.validate!
+      end.to raise_error(Lutaml::Model::ValidationError) do |error|
+        expect(error.error_messages.join("\n")).to eq("Attributes `[]` count is less than the lower bound `1`")
+      end
+    end
+
+    it "raises error, if min, max is not positive" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          choice(min: -1, max: -2) do
+            attribute :id, :integer
+            attribute :name, :string
+          end
+        end
+      end.to raise_error(Lutaml::Model::InvalidChoiceRangeError, "Choice lower bound `-1` must be positive")
+    end
+  end
+end