lutaml-model 0.5.4 → 0.6.0

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/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

data/spec/lutaml/model/mixed_content_spec.rb

@@ -467,7 +467,9 @@ RSpec.describe "MixedContent" do
       end
 
       describe ".from_xml" do
-        let(:expected_content) { "Moon&Mars Distanced©its — surface covered & processed" }
+        let(:expected_content) do
+          "Moon&Mars Distanced©its — surface covered & processed"
+        end
 
         it "deserializes special char mixed content correctly" do
           parsed = MixedContentSpec::SpecialCharContentWithMixedTrue.from_xml(xml)
@@ -476,7 +478,9 @@ RSpec.describe "MixedContent" do
       end
 
       describe ".to_xml" do
-        let(:expected_xml) { "Moon&Mars Distanced©its — surface covered & processed" }
+        let(:expected_xml) do
+          "Moon&Mars Distanced©its — surface covered & processed"
+        end
 
         it "serializes special char mixed content correctly" do
           parsed = MixedContentSpec::SpecialCharContentWithMixedTrue.from_xml(xml)
@@ -522,9 +526,15 @@ RSpec.describe "MixedContent" do
       end
 
       describe ".from_xml" do
-        let(:expected_nokogiri_content) { "B <p>R&amp;C</p>\n    C <p>J&#x2014;C</p>\n    O <p>A &amp; B </p>\n    F <p>Z &#xA9;S</p>" }
-        let(:expected_ox_content) { "B <p>R&amp;C</p>\n C <p>J—C</p>\n O <p>A &amp; B </p>\n F <p>Z ©S</p>" }
-        let(:expected_oga_content) { "B <p>R&amp;C</p>\n    C <p>J—C</p>\n    O <p>A &amp; B </p>\n    F <p>Z ©S</p>" }
+        let(:expected_nokogiri_content) do
+          "B <p>R&amp;C</p>\n    C <p>J&#x2014;C</p>\n    O <p>A &amp; B </p>\n    F <p>Z &#xA9;S</p>"
+        end
+        let(:expected_ox_content) do
+          "B <p>R&amp;C</p> C <p>J—C</p> O <p>A &amp; B </p> F <p>Z ©S</p>"
+        end
+        let(:expected_oga_content) do
+          "B <p>R&amp;C</p>\n    C <p>J—C</p>\n    O <p>A &amp; B </p>\n    F <p>Z ©S</p>"
+        end
 
         it "deserializes special char mixed content correctly" do
           parsed = MixedContentSpec::SpecialCharContentWithRawAndMixedOption.from_xml(xml)
@@ -627,7 +637,9 @@ RSpec.describe "MixedContent" do
       end
 
       describe ".from_xml" do
-        let(:expected_content) { "<computer security> type of operation specified by an access right" }
+        let(:expected_content) do
+          "<computer security> type of operation specified by an access right"
+        end
 
         it "deserializes special char mixed content correctly" do
           parsed = MixedContentSpec::TextualSupport.from_xml(xml)
@@ -637,8 +649,12 @@ RSpec.describe "MixedContent" do
       end
 
       describe ".to_xml" do
-        let(:expected_xml) { "<TextualSupport>\n  <value>&lt;computer security&gt; type of operation specified by an access right</value>\n</TextualSupport>" }
-        let(:expected_oga_xml) { "<TextualSupport><value>&lt;computer security&gt; type of operation specified by an access right</value></TextualSupport>" }
+        let(:expected_xml) do
+          "<TextualSupport>\n  <value>&lt;computer security&gt; type of operation specified by an access right</value>\n</TextualSupport>"
+        end
+        let(:expected_oga_xml) do
+          "<TextualSupport><value>&lt;computer security&gt; type of operation specified by an access right</value></TextualSupport>"
+        end
 
         it "serializes special char mixed content correctly" do
           parsed = MixedContentSpec::TextualSupport.from_xml(xml)
@@ -659,7 +675,9 @@ RSpec.describe "MixedContent" do
       end
 
       describe ".from_xml" do
-        let(:expected_content) { "∑computer security∏ type of ​ operation specified µ by an access right" }
+        let(:expected_content) do
+          "∑computer security∏ type of ​ operation specified µ by an access right"
+        end
 
         it "deserializes special char mixed content correctly" do
           parsed = MixedContentSpec::HexCode.from_xml(xml)
@@ -670,7 +688,9 @@ RSpec.describe "MixedContent" do
 
       describe ".to_xml" do
         context "when default encoding xml" do
-          let(:expected_default_encoding_xml) { "∑computer security∏ type of ​ operation specified µ by an access right" }
+          let(:expected_default_encoding_xml) do
+            "∑computer security∏ type of ​ operation specified µ by an access right"
+          end
 
           it "serializes special char mixed content correctly with default encoding: UTF-8" do
             parsed = MixedContentSpec::HexCode.from_xml(xml)
@@ -681,20 +701,36 @@ RSpec.describe "MixedContent" do
         end
 
         context "when encoding: nil xml" do
-          let(:expected_encoding_nil_nokogiri_xml) { "&#x2211;computer security&#x220F; type of &#x200B; operation specified &#xB5; by an access right" }
-          let(:expected_encoding_nil_ox_xml) { "∑computer security∏ type of ​ operation specified µ by an access right" }
+          let(:expected_encoding_nil_nokogiri_xml) do
+            "&#x2211;computer security&#x220F; type of &#x200B; operation specified &#xB5; by an access right"
+          end
+          let(:expected_encoding_nil_ox_xml) do
+            "<HexCode> \xE2\x88\x91computer security\xE2\x88\x8F type of \xE2\x80\x8B operation specified \xC2\xB5 by an access right </HexCode>\n".force_encoding("ASCII-8BIT")
+          end
+          let(:expected_encoding_nil_oga_xml) do
+            "<HexCode>\n  ∑computer security∏ type of ​ operation specified µ by an access right\n</HexCode>"
+          end
 
           it "serializes special char mixed content correctly with encoding: nil to get hexcode" do
-            parsed = MixedContentSpec::HexCode.from_xml(xml)
+            parsed = MixedContentSpec::HexCode.from_xml(xml, encoding: nil)
             serialized = parsed.to_xml(encoding: nil)
 
             expected_output = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
                                 expected_encoding_nil_nokogiri_xml
-                              else
+                              elsif adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
                                 expected_encoding_nil_ox_xml
+                              else
+                                expected_encoding_nil_oga_xml
                               end
 
-            expect(serialized.strip).to include(expected_output)
+            expect(parsed.encoding).to be_nil
+            expect(serialized.strip).to include(expected_output.strip)
+
+            if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+              expect(serialized.encoding.to_s).to eq("ASCII-8BIT")
+            else
+              expect(serialized.encoding.to_s).to eq("UTF-8")
+            end
           end
         end
       end
@@ -702,7 +738,9 @@ RSpec.describe "MixedContent" do
 
     context "when use encoding in parsing" do
       context "when use SHIFT-JIS encoding" do
-        let(:fixture) { File.read(fixture_path("xml/shift_jis.xml"), encoding: "Shift_JIS") }
+        let(:fixture) do
+          File.read(fixture_path("xml/shift_jis.xml"), encoding: "Shift_JIS")
+        end
 
         describe ".from_xml" do
           it "verifies the encoding of file read" do
@@ -712,10 +750,10 @@ RSpec.describe "MixedContent" do
           it "deserializes SHIFT encoded content correctly with explicit encoding option" do
             parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
 
-            expected_content = if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
-                                 "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
-                               else
+            expected_content = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
                                  "手書き英字１"
+                               else
+                                 "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
                                end
 
             expect(parsed.field).to include(expected_content)
@@ -725,13 +763,12 @@ RSpec.describe "MixedContent" do
             parsed = MixedContentSpec::Shift.from_xml(fixture)
 
             expected_content = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
-                                 "�菑���p���P"
-                               elsif adapter_class == Lutaml::Model::XmlAdapter::OgaAdapter
                                  "手書き英字１"
                                else
-                                 "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("UTF-8")
+                                 "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
                                end
 
+            expect(parsed.encoding).to eq("Shift_JIS")
             expect(parsed.field).to include(expected_content)
           end
         end
@@ -748,13 +785,13 @@ RSpec.describe "MixedContent" do
             parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
             serialized = parsed.to_xml(encoding: "UTF-8")
 
-            expected_xml = if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
-                             "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
-                           else
-                             "手書き英字１"
-                           end
+            parsed_xml = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
+                           "手書き英字１"
+                         else
+                           "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
+                         end
 
-            expect(parsed.field).to include(expected_xml)
+            expect(parsed.field).to include(parsed_xml)
             expect(parsed.encoding).to eq("Shift_JIS")
 
             expect(serialized).to include("手書き英字１")
@@ -765,10 +802,10 @@ RSpec.describe "MixedContent" do
             parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
             serialized = parsed.to_xml(encoding: "Shift_JIS")
 
-            expected_xml = if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
-                             "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
-                           else
+            expected_xml = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
                              "手書き英字１"
+                           else
+                             "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
                            end
 
             expect(parsed.field).to include(expected_xml)
@@ -788,16 +825,18 @@ RSpec.describe "MixedContent" do
             expect(serialized.encoding.to_s).to eq("Shift_JIS")
           end
 
-          it "serializes SHIFT-JIS content incorrectly bcz no encoding provided during parsing" do
+          it "serializes SHIFT-JIS content correctly bcz xml.encoding used during parsing" do
             parsed = MixedContentSpec::Shift.from_xml(fixture)
             serialized = parsed.to_xml(encoding: "Shift_JIS")
+
             expected_content = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
-                                 "<root>\n  <FieldName>&#65533;&#33745;&#65533;&#65533;&#65533;p&#65533;&#65533;&#65533;P</FieldName>\n  <FieldName>123456</FieldName>\n</root>"
+                                 "<root>\n  <FieldName>手書き英字１</FieldName>\n  <FieldName>123456</FieldName>\n</root>".encode("Shift_JIS")
                                elsif adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
-                                 "<root>\n  <FieldName>\x8E菑\x82\xAB\x89p\x8E\x9A\x82P</FieldName>\n  <FieldName>123456</FieldName>\n</root>\n"
+                                 "<root>\n  <FieldName>手書き英字１</FieldName>\n  <FieldName>123456</FieldName>\n</root>\n".encode("Shift_JIS")
                                else
                                  "<root><FieldName>手書き英字１</FieldName><FieldName>123456</FieldName></root>".encode("Shift_JIS")
                                end
+
             expect(serialized).to eq(expected_content)
           end
 
@@ -829,27 +868,27 @@ RSpec.describe "MixedContent" do
           it "deserializes latin encoded content correctly" do
             parsed = MixedContentSpec::Latin.from_xml(fixture, encoding: "ISO-8859-1")
 
-            expected_content = if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
-                                 ["M\xFCller".force_encoding("ISO-8859-1"), "Jos\xE9".force_encoding("ISO-8859-1")]
-                               else
+            expected_content = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
                                  ["Müller", "José"]
+                               else
+                                 ["M\xFCller".force_encoding("ISO-8859-1"), "Jos\xE9".force_encoding("ISO-8859-1")]
                                end
 
+            expect(parsed.encoding).to eq("ISO-8859-1")
             expect(parsed.from).to eq(expected_content[0])
             expect(parsed.the).to eq(expected_content[1])
           end
 
-          it "deserializes latin encoded content incorrectly" do
+          it "deserializes latin encoded content correctly, bcz xml.encoding used for parsing" do
             parsed = MixedContentSpec::Latin.from_xml(fixture)
 
             expected_content = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
-                                 ["M�ller", "Jos�"]
-                               elsif adapter_class == Lutaml::Model::XmlAdapter::OgaAdapter
                                  ["Müller", "José"]
                                else
-                                 ["M\xFCller", "Jos\xE9"]
+                                 ["M\xFCller".force_encoding("ISO-8859-1"), "Jos\xE9".force_encoding("ISO-8859-1")]
                                end
 
+            expect(parsed.encoding).to eq("ISO-8859-1")
             expect(parsed.from).to eq(expected_content[0])
             expect(parsed.the).to eq(expected_content[1])
           end

data/spec/lutaml/model/multiple_mapping_spec.rb

@@ -106,7 +106,7 @@ module MultipleMapping
     end
 
     def name_from_xml(model, value)
-      model.full_name = value.sub(/^XML Model: /, "")
+      model.full_name = value.text.sub(/^XML Model: /, "")
     end
 
     def color_to_xml(model, parent, doc)
@@ -116,7 +116,7 @@ module MultipleMapping
     end
 
     def color_from_xml(model, value)
-      model.color = value.downcase
+      model.color = value.text.downcase
     end
 
     def size_to_xml(model, parent, doc)
@@ -126,7 +126,7 @@ module MultipleMapping
     end
 
     def size_from_xml(model, value)
-      model.size = (value.to_i || 0) - 10
+      model.size = (value.text.to_i || 0) - 10
     end
 
     def desc_to_xml(model, parent, doc)
@@ -136,7 +136,7 @@ module MultipleMapping
     end
 
     def desc_from_xml(model, value)
-      model.description = value.sub(/^XML Description: /, "")
+      model.description = value.text.sub(/^XML Description: /, "")
     end
   end
 end
@@ -144,8 +144,12 @@ end
 RSpec.describe MultipleMapping do
   context "with key-value formats" do
     context "with YAML format" do
-      let(:yaml_with_name) { "product_name: Coffee Maker\ndescription: Premium coffee maker" }
-      let(:yaml_with_desc) { "---\nname: Coffee Maker\ndesc: Premium coffee maker\n" }
+      let(:yaml_with_name) do
+        "product_name: Coffee Maker\ndescription: Premium coffee maker"
+      end
+      let(:yaml_with_desc) do
+        "---\nname: Coffee Maker\ndesc: Premium coffee maker\n"
+      end
 
       it "handles bidirectional conversion" do
         product1 = MultipleMapping::Product.from_yaml(yaml_with_name)
@@ -161,8 +165,12 @@ RSpec.describe MultipleMapping do
     end
 
     context "with JSON format" do
-      let(:json_with_name) { '{"product_name":"Coffee Maker","description":"Premium coffee maker"}' }
-      let(:json_with_desc) { '{"name":"Coffee Maker","desc":"Premium coffee maker"}' }
+      let(:json_with_name) do
+        '{"product_name":"Coffee Maker","description":"Premium coffee maker"}'
+      end
+      let(:json_with_desc) do
+        '{"name":"Coffee Maker","desc":"Premium coffee maker"}'
+      end
 
       it "handles bidirectional conversion" do
         product1 = MultipleMapping::Product.from_json(json_with_name)
@@ -254,8 +262,12 @@ RSpec.describe MultipleMapping do
 
   context "with CustomModel" do
     context "with JSON format" do
-      let(:json_with_alternate) { '{"custom_name":"JSON Model: Vase","shade":"BLUE","dimension":22,"description":"JSON Description: A beautiful ceramic vase"}' }
-      let(:json_with_standard) { '{"name":"JSON Model: Vase","color":"BLUE","size":22,"desc":"JSON Description: A beautiful ceramic vase"}' }
+      let(:json_with_alternate) do
+        '{"custom_name":"JSON Model: Vase","shade":"BLUE","dimension":22,"description":"JSON Description: A beautiful ceramic vase"}'
+      end
+      let(:json_with_standard) do
+        '{"name":"JSON Model: Vase","color":"BLUE","size":22,"desc":"JSON Description: A beautiful ceramic vase"}'
+      end
 
       it "handles bidirectional conversion with custom methods" do
         model1 = MultipleMapping::CustomModel.from_json(json_with_alternate)