lutaml-model 0.5.4 → 0.6.0

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/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/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["elements"]["street"].text
-      model.child_mapper.city = value["elements"]["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

data/spec/lutaml/model/collection_spec.rb

@@ -47,7 +47,7 @@ module CollectionTests
     end
 
     def city_from_xml(model, node)
-      model.city = node
+      model.city = node.text
     end
 
     def city_to_xml(model, parent, doc)

data/spec/lutaml/model/custom_model_spec.rb

@@ -55,9 +55,8 @@ class CustomModelParentMapper < Lutaml::Model::Serializable
 
   def child_from_xml(model, value)
     model.child_mapper ||= CustomModelChild.new
-
-    model.child_mapper.street = value["elements"]["street"].text
-    model.child_mapper.city = value["elements"]["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
 
@@ -126,10 +125,10 @@ module CustomModelSpecs
 
     def bibdata_from_xml(model, value)
       model.bibdata = BibliographicItem.new(
-        "type" => value["attributes"]["type"],
-        "title" => value["elements"]["title"],
-        "language" => value["elements"]["title"]["attributes"]["language"],
-        "schema_version" => value["attributes"]["schema-version"],
+        "type" => value.find_attribute_value("type"),
+        "title" => value.find_child_by_name("title"),
+        "language" => value.find_child_by_name("title").find_attribute_value("language"),
+        "schema_version" => value.find_attribute_value("schema-version"),
       )
     end
 

data/spec/lutaml/model/custom_serialization_spec.rb

@@ -68,7 +68,7 @@ class CustomSerialization < Lutaml::Model::Serializable
   end
 
   def name_from_xml(model, value)
-    model.full_name = value.sub(/^XML Masterpiece: /, "")
+    model.full_name = value.text.sub(/^XML Masterpiece: /, "")
   end
 
   def size_to_xml(model, parent, doc)
@@ -86,7 +86,7 @@ class CustomSerialization < Lutaml::Model::Serializable
   end
 
   def color_from_xml(model, value)
-    model.color = value.downcase
+    model.color = value.text.downcase
   end
 
   def description_to_xml(model, parent, doc)
@@ -98,6 +98,37 @@ class CustomSerialization < Lutaml::Model::Serializable
   end
 end
 
+class GrammarInfo < Lutaml::Model::Serializable
+  attribute :part_of_speech, :string, values: %w[user admin super_admin]
+
+  key_value do
+    map :part_of_speech, with: { to: :part_of_speech_to_key_value, from: :part_of_speech_from_key_value }
+  end
+
+  xml do
+    root "GrammarInfo"
+    map_element :part_of_speech, with: { to: :part_of_speech_to_xml, from: :part_of_speech_from_xml }
+  end
+
+  def part_of_speech_from_key_value(model, value)
+    model.part_of_speech = value
+  end
+
+  def part_of_speech_to_key_value(model, doc)
+    doc["part_of_speech"] = model.part_of_speech
+  end
+
+  def part_of_speech_from_xml(model, node)
+    model.part_of_speech = node.text
+  end
+
+  def part_of_speech_to_xml(model, parent, doc)
+    el = doc.create_element("part_of_speech")
+    doc.add_text(el, model.part_of_speech)
+    doc.add_element(parent, el)
+  end
+end
+
 RSpec.describe CustomSerialization do
   let(:attributes) do
     {
@@ -183,4 +214,45 @@ RSpec.describe CustomSerialization do
       expect(ceramic.description).to eq(model.description)
     end
   end
+
+  context "when enum used with custom methods" do
+    let(:hash) do
+      {
+        "part_of_speech" => "user",
+      }
+    end
+
+    it "correctly persist value for yaml" do
+      instance = GrammarInfo.from_yaml(hash.to_yaml)
+      serialized = instance.to_yaml
+
+      expect(instance.part_of_speech).to eq("user")
+      expect(serialized).to eq(hash.to_yaml)
+    end
+
+    it "correctly persist value for json" do
+      instance = GrammarInfo.from_json(hash.to_json)
+      serialized = instance.to_json
+
+      expect(instance.part_of_speech).to eq("user")
+      expect(serialized).to eq(hash.to_json)
+    end
+
+    it "correctly handles value for xml" do
+      xml_input = <<~XML
+        <GrammarInfo>
+          <part_of_speech>user</part_of_speech>
+        </GrammarInfo>
+      XML
+
+      instance = GrammarInfo.from_xml(xml_input)
+      expect(instance.part_of_speech).to eq("user")
+      expect(instance.user?).to be true
+      expect(instance.admin?).to be false
+      expect(instance.super_admin?).to be false
+
+      serialized = instance.to_xml
+      expect(serialized).to be_equivalent_to(xml_input)
+    end
+  end
 end

data/spec/lutaml/model/defaults_spec.rb

@@ -115,7 +115,9 @@ module DefaultsSpec
     model Lang
 
     attribute :lang, :string, default: -> { "en" }
-    attribute :content, :string, default: -> { "default value not render when render_default is false" }
+    attribute :content, :string, default: -> {
+      "default value not render when render_default is false"
+    }
 
     xml do
       root "CustomModelWithDefaultValue"

data/spec/lutaml/model/delegation_spec.rb

@@ -99,14 +99,16 @@ RSpec.describe Delegation do
   end
 
   it "serializes to JSON with pretty formatting" do
-    expected_pretty_json = {
-      type: "Vase",
-      color: "Blue",
-    }.to_json
+    expected_pretty_json = <<~JSON.chomp
+      {
+        "type": "Vase",
+        "color": "Blue"
+      }
+    JSON
 
     generated_json = delegation.to_json(only: %i[type color], pretty: true)
 
-    expect(generated_json.strip).to eq(expected_pretty_json.strip)
+    expect(generated_json).to eq(expected_pretty_json)
   end
 
   it "serializes to XML with pretty formatting" do

data/spec/lutaml/model/enum_spec.rb

@@ -43,6 +43,21 @@ RSpec.describe "Enum" do
             .from(nil)
             .to("user")
         end
+
+        it "sets and unsets all enum values correctly" do
+          object.user = true
+          object.admin = false
+          object.super_admin = false
+
+          expect(object.user?).to be true
+          expect(object.admin?).to be false
+          expect(object.super_admin?).to be false
+
+          expect { object.user = false }
+            .to change(object, :user?)
+            .from(true)
+            .to(false)
+        end
       end
 
       describe "#multi_value" do
@@ -59,6 +74,26 @@ RSpec.describe "Enum" do
             .from([])
             .to(%w[dual plural])
         end
+
+        it "sets and unsets all enum values correctly" do
+          object.singular = false
+          object.dual = true
+          object.plural = true
+
+          expect(object.singular?).to be false
+          expect(object.dual?).to be true
+          expect(object.plural?).to be true
+
+          expect { object.plural = false }
+            .to change(object, :plural?)
+            .from(true)
+            .to(false)
+
+          expect { object.dual = false }
+            .to change(object, :dual?)
+            .from(true)
+            .to(false)
+        end
       end
 
       EnumSpec::WithEnum.enums.each_value do |enum_attr|