lutaml-model 0.5.4 → 0.6.0

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

data/spec/lutaml/model/xml_adapter/oga_adapter_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
   let(:document) { described_class.parse(xml_string) }
 
   context "parsing XML with namespaces" do
-    let(:child) { document.root.children[1] }
+    let(:child) { document.root.children.first }
 
     it "parses the root element with default namespace" do
       expect(document.root.name).to eq("root")
@@ -39,18 +39,22 @@ RSpec.describe Lutaml::Model::XmlAdapter::OgaAdapter do
 
   context "generating XML with namespaces" do
     it "generates XML with namespaces correctly" do
-      xml_output = document.to_xml
-      parsed_output = Oga.parse_xml(xml_output)
+      xml_output = document.root.to_xml
+      parsed_output = Moxml::Adapter::Oga.parse(xml_output)
 
       root = parsed_output.children.first
       expect(root.name).to eq("root")
       expect(root.namespace.uri).to eq("http://example.com/default")
 
-      child = root.children[1]
-      expect(child.expanded_name).to eq("prefix:child")
+      child = root.children.first
+      expect(described_class.prefixed_name_of(child)).to eq("prefix:child")
       expect(child.namespace.uri).to eq("http://example.com/prefixed")
-      expect(child.get("attr")).to eq("value")
-      expect(child.get("prefix:attr")).to eq("prefixed_value")
+      unprefixed_attr = child.attributes.find { |attr| attr.name == "attr" }
+      expect(unprefixed_attr.value).to eq("value")
+      prefixed_attr = child.attributes.find do |attr|
+        described_class.prefixed_name_of(attr) == "prefix:attr"
+      end
+      expect(prefixed_attr.value).to eq("prefixed_value")
     end
   end
 end

data/spec/lutaml/model/xml_mapping_rule_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+require "lutaml/model/xml_adapter/ox_adapter"
+require "lutaml/model/xml_adapter/oga_adapter"
+
+require_relative "../../../lib/lutaml/model/xml_mapping_rule"
+
+def content_to_xml(model, parent, doc)
+  content = model.all_content.sub(/^<div>/, "").sub(/<\/div>$/, "")
+  doc.add_xml_fragment(parent, content)
+end
+
+def content_from_xml(model, value)
+  model.all_content = "<div>#{value}</div>"
+end
+
+RSpec.describe Lutaml::Model::XmlMappingRule do
+  context "with Xml Mapping Rule" do
+    let(:orig_mapping_rule) do
+      described_class.new(
+        "name",
+        to: :name,
+        render_nil: true,
+        render_default: true,
+        with: { to: :content_to_xml, from: :content_from_xml },
+        delegate: true,
+        namespace: "http://child-namespace",
+        prefix: "cn",
+        mixed_content: true,
+        cdata: true,
+        namespace_set: true,
+        prefix_set: true,
+        attribute: true,
+        default_namespace: "http://parent-namespace",
+      )
+    end
+
+    let(:dup_mapping_rule) do
+      orig_mapping_rule.deep_dup
+    end
+
+    it "duplicates all instance variables" do
+      orig_mapping_rule.instance_variables.each do |variable|
+        orig_var = orig_mapping_rule.instance_variable_get(variable)
+        dup_var = dup_mapping_rule.instance_variable_get(variable)
+
+        expect(orig_var).to eq(dup_var)
+      end
+    end
+  end
+end