lutaml-model 0.5.3 → 0.6.0

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["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
 
@@ -126,10 +125,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.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
 
@@ -410,22 +409,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/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|

data/spec/lutaml/model/group_spec.rb

@@ -0,0 +1,160 @@
+require "spec_helper"
+require "lutaml/model"
+
+module GroupSpec
+  class Ceramic < Lutaml::Model::Serializable
+    attribute :type, :string
+    attribute :name, :string
+
+    xml do
+      no_root
+      map_element :type, to: :type
+      map_element :name, to: :name
+    end
+  end
+
+  class CeramicCollection < Lutaml::Model::Serializable
+    attribute :ceramic, Ceramic, collection: 1..2
+
+    xml do
+      root "collection"
+      map_element "ceramic", to: :ceramic
+    end
+  end
+
+  class AttributeValueType < Lutaml::Model::Type::Decimal
+  end
+
+  class GroupOfItems < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :type, :string
+    attribute :description, :string
+    attribute :code, :string
+
+    xml do
+      no_root
+      sequence do
+        map_element "name", to: :name
+        map_element "type", to: :type
+        map_element "description", to: :description,
+                                   namespace: "http://www.sparxsystems.com/profiles/GML/1.0",
+                                   prefix: "GML"
+      end
+      map_attribute "code", to: :code, namespace: "http://www.example.com", prefix: "ex1"
+    end
+  end
+
+  class ComplexType < Lutaml::Model::Serializable
+    attribute :tag, AttributeValueType
+    attribute :content, :string
+    attribute :group, :string
+    import_model_attributes GroupOfItems
+
+    xml do
+      root "GroupOfItems"
+      map_attribute "tag", to: :tag
+      map_content to: :content
+      map_element :group, to: :group
+      import_model_mappings GroupOfItems
+    end
+  end
+
+  class SimpleType < Lutaml::Model::Serializable
+    import_model GroupOfItems
+  end
+
+  class GenericType < Lutaml::Model::Serializable
+    import_model_mappings GroupOfItems
+  end
+
+  class GroupWithRoot < Lutaml::Model::Serializable
+    attribute :name, :string
+
+    xml do
+      root "group"
+      map_element :name, to: :name
+    end
+  end
+end
+
+RSpec.describe "Group" do
+  context "with no_root" do
+    let(:mapper) { GroupSpec::CeramicCollection }
+
+    it "raises error if root-less class used directly for parsing" do
+      xml = <<~XML
+        <type>Data</type>
+        <name>Smith</name>
+      XML
+
+      expect { GroupSpec::Ceramic.from_xml(xml) }.to raise_error(
+        Lutaml::Model::NoRootMappingError,
+        "GroupSpec::Ceramic has `no_root`, it allowed only for reusable models",
+      )
+    end
+
+    it "raises error if root_less class used for deserializing" do
+      ceramic = GroupSpec::Ceramic.new(type: "Data", name: "Starc")
+
+      expect { ceramic.to_xml }.to raise_error(
+        Lutaml::Model::NoRootMappingError,
+        "GroupSpec::Ceramic has `no_root`, it allowed only for reusable models",
+      )
+    end
+
+    it "correctly get the element of root-less class" do
+      xml = <<~XML
+        <collection>
+          <ceramic>
+            <type>Data</type>
+          </ceramic>
+        </collection>
+      XML
+
+      expect { mapper.from_xml(xml) }.not_to raise_error
+    end
+  end
+
+  context "with model" do
+    it "import attributes" do
+      expect(GroupSpec::ComplexType.attributes).to include(GroupSpec::GroupOfItems.attributes)
+    end
+
+    it "import mappings in xml block" do
+      expect(GroupSpec::ComplexType.mappings_for(:xml).elements).to include(*GroupSpec::GroupOfItems.mappings_for(:xml).elements)
+    end
+
+    it "import mappings outside xml block" do
+      expect(GroupSpec::GenericType.mappings_for(:xml).elements).to include(*GroupSpec::GroupOfItems.mappings_for(:xml).elements)
+    end
+
+    it "import attributes and mappings in xml block" do
+      expect(GroupSpec::ComplexType.attributes).to include(GroupSpec::GroupOfItems.attributes)
+      expect(GroupSpec::ComplexType.mappings_for(:xml).elements).to include(*GroupSpec::GroupOfItems.mappings_for(:xml).elements)
+    end
+
+    it "import attributes and mappings outside the xml block" do
+      expect(GroupSpec::SimpleType.attributes).to include(GroupSpec::GroupOfItems.attributes)
+      expect(GroupSpec::SimpleType.mappings_for(:xml).elements).to include(*GroupSpec::GroupOfItems.mappings_for(:xml).elements)
+    end
+
+    it "raises error if root is defined on imported class" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          import_model GroupSpec::GroupWithRoot
+        end
+      end.to raise_error(Lutaml::Model::ImportModelWithRootError, "Cannot import a model `GroupSpec::GroupWithRoot` with a root element")
+    end
+
+    it "raises error if namespace is defined with no_root" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          xml do
+            no_root
+            namespace "http://www.omg.org/spec/XMI/20131001", "xmi"
+          end
+        end
+      end.to raise_error(Lutaml::Model::NoRootNamespaceError, "Cannot assign namespace to `no_root`")
+    end
+  end
+end

data/spec/lutaml/model/inheritance_spec.rb

@@ -34,6 +34,22 @@ module InheritanceSpec
       map_element "gender", to: :age
     end
   end
+
+  class ParentWithMapAll < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :description, :string
+
+    xml do
+      map_attribute "id", to: :id
+      map_all_content to: :description
+    end
+  end
+
+  class Child < ParentWithMapAll
+    xml do
+      root "child"
+    end
+  end
 end
 
 RSpec.describe "Inheritance" do
@@ -89,4 +105,13 @@ RSpec.describe "Inheritance" do
       end
     end
   end
+
+  context "with map_all in parent" do
+    let(:xml) { "<child id=\"en\">Some <b>bold</b> Content</child>" }
+
+    it "round trip correctly" do
+      parsed = InheritanceSpec::Child.from_xml(xml)
+      expect(parsed.to_xml).to eq(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/liquefiable_spec.rb

@@ -0,0 +1,121 @@
+require "spec_helper"
+require_relative "../../fixtures/address"
+
+class LiquefiableClass
+  include Lutaml::Model::Liquefiable
+
+  attr_accessor :name, :value
+
+  def initialize(name, value)
+    @name = name
+    @value = value
+  end
+
+  def display_name
+    "#{name} (#{value})"
+  end
+end
+
+RSpec.describe Lutaml::Model::Liquefiable do
+  before do
+    stub_const("DummyModel", Class.new(LiquefiableClass))
+  end
+
+  let(:dummy) { DummyModel.new("TestName", 42) }
+
+  describe ".register_liquid_drop_class" do
+    context "when drop class does not exist" do
+      it "creates a new drop class" do
+        expect { dummy.class.register_liquid_drop_class }.to change {
+          dummy.class.const_defined?(:DummyModelDrop)
+        }
+          .from(false)
+          .to(true)
+      end
+    end
+
+    context "when drop class already exists" do
+      it "raises an error" do
+        dummy.class.register_liquid_drop_class
+        expect { dummy.class.register_liquid_drop_class }.to raise_error(RuntimeError, "DummyModelDrop Already exists!")
+      end
+    end
+  end
+
+  describe ".drop_class_name" do
+    it "returns the correct drop class name" do
+      expect(dummy.class.drop_class_name).to eq("DummyModelDrop")
+    end
+  end
+
+  describe ".drop_class" do
+    context "when drop class exists" do
+      it "returns the drop class" do
+        dummy.class.register_liquid_drop_class
+        expect(dummy.class.drop_class).to eq(DummyModel::DummyModelDrop)
+      end
+    end
+
+    context "when drop class does not exist" do
+      it "returns nil" do
+        expect(dummy.class.drop_class).to be_nil
+      end
+    end
+  end
+
+  describe ".register_drop_method" do
+    before do
+      dummy.class.register_liquid_drop_class
+    end
+
+    it "defines a method on the drop class" do
+      expect { dummy.class.register_drop_method(:display_name) }.to change {
+        dummy.to_liquid.respond_to?(:display_name)
+      }
+        .from(false)
+        .to(true)
+    end
+  end
+
+  describe ".to_liquid" do
+    before do
+      dummy.class.register_liquid_drop_class
+      dummy.class.register_drop_method(:display_name)
+    end
+
+    it "returns an instance of the drop class" do
+      expect(dummy.to_liquid).to be_a(dummy.class.drop_class)
+    end
+
+    it "allows access to registered methods via the drop class" do
+      expect(dummy.to_liquid.display_name).to eq("TestName (42)")
+    end
+  end
+
+  context "with serializeable classes" do
+    let(:address) do
+      Address.new(
+        {
+          country: "US",
+          post_code: "12345",
+          person: [Person.new, Person.new],
+        },
+      )
+    end
+
+    describe ".to_liquid" do
+      it "returns correct drop object" do
+        expect(address.to_liquid).to be_a(Address::AddressDrop)
+      end
+
+      it "returns array of drops for collection objects" do
+        person_classes = address.to_liquid.person.map(&:class)
+        expect(person_classes).to eq([Person::PersonDrop, Person::PersonDrop])
+      end
+
+      it "returns `US` for country" do
+        expect(address.to_liquid.country).to eq("US")
+      end
+    end
+  end
+end