lutaml-model 0.5.3 → 0.6.0

data/spec/lutaml/model/sequence_spec.rb

@@ -0,0 +1,216 @@
+require "spec_helper"
+require "lutaml/model"
+
+module SequenceSpec
+  class Ceramic < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :name, :string
+    attribute :type, :string
+    attribute :color, :string
+    attribute :bold, :string
+    attribute :text, :string
+    attribute :usage, :string
+    attribute :size, :string
+    attribute :first_name, :string
+    attribute :last_name, :string
+    attribute :tag, :string
+    attribute :temperature, :string
+
+    xml do
+      root "Ceramic"
+      map_element :tag, to: :tag
+
+      sequence do
+        map_element :id, to: :id
+        map_element :name, to: :name
+        map_element :type, to: :type
+        map_element :color, to: :color
+        map_element :bold, to: :bold
+        map_element :text, to: :text
+        sequence do
+          map_element :usage, to: :usage
+          map_element :size, to: :size
+        end
+      end
+
+      sequence do
+        map_element :first_name, to: :first_name
+        map_element :last_name, to: :last_name
+      end
+
+      map_element :temperature, to: :temperature
+    end
+  end
+
+  class CeramicCollection < Lutaml::Model::Serializable
+    attribute :ceramic, Ceramic, collection: 1..2
+
+    xml do
+      root "collection"
+      map_element "ceramic", to: :ceramic
+    end
+  end
+end
+
+RSpec.describe "Sequence" do
+  context "with nesting sequence" do
+    let(:mapper) { SequenceSpec::Ceramic }
+
+    it "don't raise error for a valid instance, if given attribute for sequence has correct order" do
+      xml = <<~XML
+        <Ceramic>
+          <tag>Nik</tag>
+          <id>1</id>
+          <name>Vase</name>
+          <type>Decorative</type>
+          <color>Blue</color>
+          <bold>Heading</bold>
+          <text>Header</text>
+          <usage>Indoor</usage>
+          <size>Medium</size>
+          <first_name>Dale</first_name>
+          <last_name>Steyn</last_name>
+          <temperature>Normal</temperature>
+        </Ceramic>
+      XML
+
+      expect { mapper.from_xml(xml) }.not_to raise_error
+    end
+
+    it "don't raise error for a valid instance with sequence range, if given attribute for sequence has correct order" do
+      xml = <<~XML
+        <collection>
+          <ceramic>
+            <tag>Nik</tag>
+            <id>1</id>
+            <name>Vase</name>
+            <type>Decorative</type>
+            <color>Blue</color>
+            <bold>Heading</bold>
+            <text>Header</text>
+            <usage>Indoor</usage>
+            <size>Medium</size>
+            <first_name>Dale</first_name>
+            <last_name>Steyn</last_name>
+            <temperature>Normal</temperature>
+          </ceramic>
+          <ceramic>
+            <tag>Nik</tag>
+            <id>1</id>
+            <name>Vase</name>
+            <type>Decorative</type>
+            <color>Blue</color>
+            <bold>Heading</bold>
+            <text>Header</text>
+            <usage>Indoor</usage>
+            <size>Medium</size>
+            <first_name>Dale</first_name>
+            <last_name>Steyn</last_name>
+            <temperature>Normal</temperature>
+          </ceramic>
+        </collection>
+      XML
+
+      expect do
+        SequenceSpec::CeramicCollection.from_xml(xml)
+      end.not_to raise_error
+    end
+
+    it "raises error, if given attributes order is incorrect in sequence" do
+      xml = <<~XML
+        <Ceramic>
+          <tag>Nik</tag>
+          <temperature>High</temperature>
+          <first_name>Micheal</first_name>
+          <id>1</id>
+          <name>Vase</name>
+          <type>Decorative</type>
+          <color>Blue</color>
+          <bold>Heading</bold>
+          <usage>Indoor</usage>
+          <size>Medium</size>
+          <last_name>Johnson</last_name>
+          <text>Header</text>
+        </Ceramic>
+      XML
+
+      expect do
+        mapper.from_xml(xml)
+      end.to raise_error(Lutaml::Model::IncorrectSequenceError) do |error|
+        expect(error.message).to eq("Element `usage` does not match the expected sequence order element `text`")
+      end
+    end
+
+    it "raises error with sequence range, if given attributes order is incorrect in sequence" do
+      invalid_xml = <<~XML
+        <collection>
+          <ceramic>
+            <id>1</id>
+            <name>Vase</name>
+            <type>Decorative</type>
+            <color>Blue</color>
+            <bold>Heading</bold>
+            <text>Header</text>
+            <usage>Indoor</usage>
+            <size>Medium</size>
+            <first_name>Dale</first_name>
+            <last_name>Steyn</last_name>
+            <temperature>Normal</temperature>
+            <tag>Nik</tag>
+          </ceramic>
+
+          <ceramic>
+            <id>2</id>
+            <name>Nick</name>
+            <type>Unique</type>
+            <color>Red</color>
+            <bold>Name</bold>
+            <text>Body</text>
+            <usage>Outdoor</usage>
+            <size>Small</size>
+            <first_name>Smith</first_name>
+            <last_name>Ash</last_name>
+            <temperature>High</temperature>
+            <tag>Adid</tag>
+          </ceramic>
+
+          <ceramic>
+            <id>3</id>
+            <name>Starc</name>
+            <type>Int</type>
+            <color>White</color>
+            <bold>Act</bold>
+            <text>Footer</text>
+            <usage>Nothing</usage>
+            <size>Large</size>
+            <first_name>Dale</first_name>
+            <last_name>Steyn</last_name>
+            <temperature>Normal</temperature>
+            <tag>Bet</tag>
+          </ceramic>
+        </collection>
+      XML
+
+      expect do
+        SequenceSpec::CeramicCollection.from_xml(invalid_xml).validate!
+      end.to raise_error(Lutaml::Model::ValidationError) do |error|
+        expect(error).to include(Lutaml::Model::CollectionCountOutOfRangeError)
+        expect(error.error_messages).to eq(["ceramic count is 3, must be between 1 and 2"])
+      end
+    end
+
+    it "raises error, if mapping other map_element are defined in sequence" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :type, :string
+
+          xml do
+            sequence do
+              map_attribute :type, to: :type
+            end
+          end
+        end
+      end.to raise_error(Lutaml::Model::UnknownSequenceMappingError, "map_attribute is not allowed in sequence")
+    end
+  end
+end

data/spec/lutaml/model/transformation_spec.rb

@@ -0,0 +1,230 @@
+require "spec_helper"
+
+RSpec.describe "Value Transformations" do
+  module TransformationSpec
+    # Class with only attribute-level transformations
+    class AttributeTransformPerson < Lutaml::Model::Serializable
+      attribute :name, :string, transform: {
+        export: ->(value) { value.to_s.upcase },
+      }
+      attribute :email, :string, transform: {
+        import: ->(value) { "#{value}@example.com" },
+      }
+      attribute :tags, :string, collection: true, transform: {
+        export: ->(value) { value.map(&:upcase) },
+        import: ->(value) { value.map { |v| "#{v}-1" } },
+      }
+    end
+
+    # Class with only mapping-level transformations
+    class MappingTransformPerson < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :email, :string
+      attribute :tags, :string, collection: true
+
+      json do
+        map "fullName", to: :name, transform: {
+          export: ->(value) { "Dr. #{value}" },
+        }
+        map "emailAddress", to: :email, transform: {
+          import: ->(value) { value.gsub("at", "@") },
+        }
+        map "labels", to: :tags, transform: {
+          export: ->(value) { value.join("-|-") },
+          import: ->(value) { value.split("|") },
+        }
+      end
+
+      xml do
+        root "person"
+        map_element "full-name", to: :name, transform: {
+          export: ->(value) { "Dr. #{value}" },
+        }
+        map_element "email-address", to: :email, transform: {
+          import: ->(value) { value.gsub("at", "@") },
+        }
+        map_element "labels", to: :tags, transform: {
+          export: ->(value) { value.join("-|-") },
+          import: ->(value) { value.split("|") },
+        }
+      end
+    end
+
+    # Class with both attribute and mapping transformations
+    class CombinedTransformPerson < Lutaml::Model::Serializable
+      attribute :name, :string, transform: {
+        export: ->(value) { value.to_s.capitalize },
+        import: ->(value) { value.to_s.downcase },
+      }
+      attribute :email, :string, transform: {
+        export: lambda(&:downcase),
+        import: lambda(&:downcase),
+      }
+      attribute :tags, :string, collection: true, transform: {
+        export: ->(value) { value.map(&:upcase) },
+        import: ->(value) { value.map { |v| "#{v}-1" } },
+      }
+
+      json do
+        map "fullName", to: :name, transform: {
+          export: ->(value) { "Prof. #{value}" },
+          import: ->(value) { value.gsub("Prof. ", "") },
+        }
+        map "contactEmail", to: :email, transform: {
+          export: ->(value) { "contact+#{value}" },
+          import: ->(value) { value.gsub("contact+", "") },
+        }
+        map "skills", to: :tags
+      end
+
+      xml do
+        root "person"
+        map_element "full-name", to: :name, transform: {
+          export: ->(value) { "Prof. #{value}" },
+          import: ->(value) { value.gsub("Prof. ", "") },
+        }
+        map_element "contact-email", to: :email, transform: {
+          export: ->(value) { "contact+#{value}" },
+          import: ->(value) { value.gsub("contact+", "") },
+        }
+        map_element "skills", to: :tags
+      end
+    end
+  end
+
+  describe "Attribute-only transformations" do
+    let(:attribute_person) do
+      TransformationSpec::AttributeTransformPerson.new(
+        name: "john",
+        email: "smith",
+        tags: ["ruby", "rails"],
+      )
+    end
+
+    let(:expected_xml) do
+      <<~XML
+        <AttributeTransformPerson>
+          <name>JOHN</name>
+          <email>smith</email>
+          <tags>RUBY</tags>
+          <tags>RAILS</tags>
+        </AttributeTransformPerson>
+      XML
+    end
+
+    it "applies attribute transformations during serialization" do
+      parsed_json = JSON.parse(attribute_person.to_json)
+      expect(parsed_json["name"]).to eq("JOHN")
+      expect(parsed_json["email"]).to eq("smith")
+      expect(parsed_json["tags"]).to eq(["RUBY", "RAILS"])
+    end
+
+    it "applies attribute transformations during deserialization" do
+      json = {
+        "name" => "jane",
+        "email" => "doe",
+        "tags" => ["python", "django"],
+      }.to_json
+
+      parsed = TransformationSpec::AttributeTransformPerson.from_json(json)
+      expect(parsed.name).to eq("jane")
+      expect(parsed.email).to eq("doe@example.com")
+      expect(parsed.tags).to eq(["python-1", "django-1"])
+    end
+
+    it "applies attribute transformations during XML serialization" do
+      xml = attribute_person.to_xml
+      expect(xml).to be_equivalent_to(expected_xml)
+    end
+  end
+
+  describe "Mapping-only transformations" do
+    let(:mapping_person) do
+      TransformationSpec::MappingTransformPerson.new(
+        name: "alice",
+        email: "aliceattest.com",
+        tags: ["developer", "architect"],
+      )
+    end
+
+    let(:expected_xml) do
+      <<~XML
+        <person>
+          <full-name>Dr. alice</full-name>
+          <email-address>aliceattest.com</email-address>
+          <labels>developer-|-architect</labels>
+        </person>
+      XML
+    end
+
+    it "applies mapping transformations during JSON serialization" do
+      json = mapping_person.to_json
+      parsed = JSON.parse(json)
+      expect(parsed["fullName"]).to eq("Dr. alice")
+      expect(parsed["emailAddress"]).to eq("aliceattest.com")
+      expect(parsed["labels"]).to eq("developer-|-architect")
+    end
+
+    it "applies mapping transformations during JSON deserialization" do
+      json = {
+        "fullName" => "Dr. bob",
+        "emailAddress" => "bobattest.com",
+        "labels" => "senior|lead",
+      }.to_json
+
+      parsed = TransformationSpec::MappingTransformPerson.from_json(json)
+      expect(parsed.name).to eq("Dr. bob")
+      expect(parsed.email).to eq("bob@test.com")
+      expect(parsed.tags).to eq(["senior", "lead"])
+    end
+
+    it "applies mapping transformations during XML serialization" do
+      xml = mapping_person.to_xml
+      expect(xml).to be_equivalent_to(expected_xml)
+    end
+  end
+
+  describe "Combined transformations" do
+    let(:combined_person) do
+      TransformationSpec::CombinedTransformPerson.new(
+        name: "carol",
+        email: "CAROL@TEST.COM",
+        tags: ["manager", "agile"],
+      )
+    end
+
+    let(:expected_xml) do
+      <<~XML
+        <person>
+          <full-name>Prof. carol</full-name>
+          <contact-email>contact+CAROL@TEST.COM</contact-email>
+          <skills>MANAGER-1</skills>
+          <skills>AGILE-1</skills>
+        </person>
+      XML
+    end
+
+    it "applies both transformations with correct precedence in JSON" do
+      json = combined_person.to_json
+      parsed = JSON.parse(json)
+
+      expect(parsed["fullName"]).to eq("Prof. carol")
+      expect(parsed["contactEmail"]).to eq("contact+CAROL@TEST.COM")
+    end
+
+    it "handles round-trip transformations across formats" do
+      # JSON -> Key-Value -> JSON cycle
+      json = combined_person.to_json
+      parsed_json = TransformationSpec::CombinedTransformPerson.from_json(json)
+      expect(parsed_json.name).to eq("carol")
+      expect(parsed_json.email).to eq("CAROL@TEST.COM")
+      expect(parsed_json.tags).to eq(["MANAGER-1", "AGILE-1"])
+    end
+
+    it "applies both transformations with correct precedence in XML" do
+      xml = combined_person.to_xml
+      parsed_xml = TransformationSpec::CombinedTransformPerson.from_xml(xml)
+      expect(parsed_xml.to_xml).to be_equivalent_to(expected_xml)
+    end
+  end
+end

data/spec/lutaml/model/type_spec.rb

@@ -2,16 +2,47 @@
 require "spec_helper"
 require "bigdecimal"
 
-# Test classes for type registration scenarios
-class CustomType < Lutaml::Model::Type::Value
-  def self.cast(value)
-    value.to_s.upcase
+class CustomSerializationType < Lutaml::Model::Type::Value
+  def self.from_xml(_xml_string)
+    "from_xml_overrided"
+  end
+
+  def self.from_json(_value)
+    "from_json_overrided"
+  end
+
+  def self.serialize(_value)
+    "serialize_overrided"
+  end
+
+  def to_xml
+    "to_xml_overrided"
+  end
+
+  def to_json(*_args)
+    "to_json_overrided"
   end
 end
 
-class InvalidType
-  def self.cast(value)
-    value
+class SampleModel < Lutaml::Model::Serializable
+  attribute :custom_type, CustomSerializationType
+  xml do
+    root "sample"
+    map_element "custom_type", to: :custom_type
+  end
+  json do
+    map_element "custom_type", to: :custom_type
+  end
+end
+
+class SampleModelAttribute < Lutaml::Model::Serializable
+  attribute :custom_type, CustomSerializationType
+  xml do
+    root "sample"
+    map_attribute "custom_type", to: :custom_type
+  end
+  json do
+    map_element "custom_type", to: :custom_type
   end
 end
 
@@ -19,6 +50,17 @@ RSpec.describe Lutaml::Model::Type do
   describe "Type System" do
     describe ".register and .lookup" do
       context "with valid types" do
+        before do
+          # Test class for type registration scenarios
+          custom_type = Class.new(Lutaml::Model::Type::Value) do
+            def self.cast(value)
+              value.to_s.upcase
+            end
+          end
+
+          stub_const("CustomType", custom_type)
+        end
+
         it "registers and looks up a custom type" do
           described_class.register(:custom, CustomType)
           expect(described_class.lookup(:custom)).to eq(CustomType)
@@ -33,6 +75,16 @@ RSpec.describe Lutaml::Model::Type do
       end
 
       context "with invalid types" do
+        before do
+          invalid_type = Class.new do
+            def self.cast(value)
+              value
+            end
+          end
+
+          stub_const("InvalidType", invalid_type)
+        end
+
         it "raises TypeError when registering non-Type::Value class" do
           expect do
             described_class.register(:invalid,
@@ -159,31 +211,35 @@ RSpec.describe Lutaml::Model::Type do
   end
 
   describe "Type Usage in Models" do
-    class TypeTestModel < Lutaml::Model::Serializable
-      attribute :string_symbol, :string
-      attribute :string_class, Lutaml::Model::Type::String
-      attribute :integer_value, :integer
-      attribute :float_value, :float
-      attribute :date_value, :date
-      attribute :time_value, :time
-      attribute :time_without_date_value, :time_without_date
-      attribute :date_time_value, :date_time
-      attribute :boolean_value, :boolean
-      attribute :hash_value, :hash
-
-      xml do
-        root "test"
-        map_element "string_symbol", to: :string_symbol
-        map_element "string_class", to: :string_class
-        map_element "integer", to: :integer_value
-        map_element "float", to: :float_value
-        map_element "date", to: :date_value
-        map_element "time", to: :time_value
-        map_element "time_without_date", to: :time_without_date_value
-        map_element "date_time", to: :date_time_value
-        map_element "boolean", to: :boolean_value
-        map_element "hash", to: :hash_value
+    before do
+      type_test_model = Class.new(Lutaml::Model::Serializable) do
+        attribute :string_symbol, :string
+        attribute :string_class, Lutaml::Model::Type::String
+        attribute :integer_value, :integer
+        attribute :float_value, :float
+        attribute :date_value, :date
+        attribute :time_value, :time
+        attribute :time_without_date_value, :time_without_date
+        attribute :date_time_value, :date_time
+        attribute :boolean_value, :boolean
+        attribute :hash_value, :hash
+
+        xml do
+          root "test"
+          map_element "string_symbol", to: :string_symbol
+          map_element "string_class", to: :string_class
+          map_element "integer", to: :integer_value
+          map_element "float", to: :float_value
+          map_element "date", to: :date_value
+          map_element "time", to: :time_value
+          map_element "time_without_date", to: :time_without_date_value
+          map_element "date_time", to: :date_time_value
+          map_element "boolean", to: :boolean_value
+          map_element "hash", to: :hash_value
+        end
       end
+
+      stub_const("TypeTestModel", type_test_model)
     end
 
     let(:test_instance) do
@@ -272,5 +328,56 @@ RSpec.describe Lutaml::Model::Type do
         expect(deserialized.hash_value).to eq({ "key" => "value" })
       end
     end
+
+    describe "Serialization Of Custom Type" do
+      let(:xml) do
+        <<~XML
+          <sample>
+            <custom_type>test_string</custom_type>
+          </sample>
+        XML
+      end
+
+      let(:xml_attribute) do
+        <<~XML
+          <sample custom_type="test_string"/>
+        XML
+      end
+
+      let(:sample_instance) { SampleModel.from_xml(xml) }
+      let(:sample_instance_attribute) do
+        SampleModelAttribute.from_xml(xml_attribute)
+      end
+
+      it "correctly serializes to XML" do
+        expected_xml = <<~XML
+          <sample>
+            <custom_type>to_xml_overrided</custom_type>
+          </sample>
+        XML
+        expect(sample_instance.to_xml).to be_equivalent_to(expected_xml)
+      end
+
+      it "correctly serializes to XML attribute" do
+        expected_xml = <<~XML
+          <sample custom_type="to_xml_overrided"/>
+        XML
+        expect(sample_instance_attribute.to_xml).to be_equivalent_to(expected_xml)
+      end
+
+      it "correctly serializes to JSON" do
+        expect(sample_instance.to_json).to eq('{"custom_type":"to_json_overrided"}')
+      end
+
+      it "correctly deserializes from XML" do
+        expect(sample_instance.custom_type).to eq("from_xml_overrided")
+      end
+
+      it "correctly deserializes from JSON" do
+        json_sample_instance = SampleModel.from_json('{"custom_type":"test_string"}')
+        json_sample_instance.to_json
+        expect(json_sample_instance.custom_type).to eq("from_json_overrided")
+      end
+    end
   end
 end

data/spec/lutaml/model/utils_spec.rb

@@ -54,7 +54,19 @@ RSpec.describe Lutaml::Model::Utils do
       }
     end
 
+    let(:original_array) do
+      [
+        "one", [
+          "one_one", [
+            "one_one1", "one_one2"
+          ],
+          "one_two"
+        ]
+      ]
+    end
+
     let(:duplicate_hash) { utils.deep_dup(original_hash) }
+    let(:duplicate_array) { utils.deep_dup(original_array) }
 
     it "creates deep duplicate of hash" do
       expect(original_hash).to eq(duplicate_hash)
@@ -75,5 +87,25 @@ RSpec.describe Lutaml::Model::Utils do
       expect(original_hash[:one][:one_two]).to eq(duplicate_hash[:one][:one_two])
       expect(original_hash[:one][:one_two].object_id).not_to eq(duplicate_hash[:one][:one_two].object_id)
     end
+
+    it "creates deep duplicate of array" do
+      expect(original_array).to eq(duplicate_array)
+      expect(original_array.object_id).not_to eq(duplicate_array.object_id)
+
+      expect(original_array[0]).to eq(duplicate_array[0])
+      expect(original_array[0].object_id).not_to eq(duplicate_array[0].object_id)
+
+      expect(original_array[1][0]).to eq(duplicate_array[1][0])
+      expect(original_array[1][0].object_id).not_to eq(duplicate_array[1][0].object_id)
+
+      expect(original_array[1][1][0]).to eq(duplicate_array[1][1][0])
+      expect(original_array[1][1][0].object_id).not_to eq(duplicate_array[1][1][0].object_id)
+
+      expect(original_array[1][1][1]).to eq(duplicate_array[1][1][1])
+      expect(original_array[1][1][1].object_id).not_to eq(duplicate_array[1][1][1].object_id)
+
+      expect(original_array[1][2]).to eq(duplicate_array[1][2])
+      expect(original_array[1][2].object_id).not_to eq(duplicate_array[1][2].object_id)
+    end
   end
 end