lutaml-model 0.5.3 → 0.6.0

data/spec/lutaml/model/map_all_spec.rb

@@ -0,0 +1,188 @@
+require "spec_helper"
+
+module MapAllSpec
+  class Document < Lutaml::Model::Serializable
+    attribute :content, :string
+
+    xml do
+      root "document"
+      map_all to: :content
+    end
+
+    json do
+      map_all to: :content
+    end
+
+    yaml do
+      map_all to: :content
+    end
+
+    toml do
+      map_all to: :content
+    end
+  end
+
+  class InvalidDocument < Lutaml::Model::Serializable
+    attribute :content, :string
+    attribute :title, :string
+
+    json do
+      map_all to: :content
+    end
+
+    yaml do
+      map_element "title", to: :title
+    end
+  end
+
+  RSpec.describe "MapAll" do
+    describe "XML serialization" do
+      let(:xml_content) do
+        <<~XML
+          <document>
+            Content with <b>tags</b> and <i>formatting</i>.
+            <metadata>
+              <author>John Doe</author>
+              <date>2024-01-15</date>
+            </metadata>
+          </document>
+        XML
+      end
+
+      let(:sub_xml_content) do
+        <<~XML
+          Content with <b>tags</b> and <i>formatting</i>.
+          <metadata>
+            <author>John Doe</author>
+            <date>2024-01-15</date>
+          </metadata>
+        XML
+      end
+
+      it "captures all XML content" do
+        doc = Document.from_xml(xml_content)
+        expect(doc.content).to be_equivalent_to(sub_xml_content)
+      end
+
+      it "preserves XML content through round trip" do
+        doc = Document.from_xml(xml_content)
+        regenerated = doc.to_xml
+        expect(regenerated).to be_equivalent_to(xml_content)
+      end
+    end
+
+    describe "JSON serialization" do
+      let(:json_content) do
+        {
+          "sections" => [
+            { "title" => "Introduction", "text" => "Chapter 1" },
+            { "title" => "Conclusion", "text" => "Final chapter" },
+          ],
+          "metadata" => {
+            "author" => "John Doe",
+            "date" => "2024-01-15",
+          },
+        }.to_json
+      end
+
+      it "captures all JSON content" do
+        doc = Document.from_json(json_content)
+        parsed = JSON.parse(doc.content)
+        expect(parsed["sections"].first["title"]).to eq("Introduction")
+        expect(parsed["metadata"]["author"]).to eq("John Doe")
+      end
+
+      it "preserves JSON content through round trip" do
+        doc = Document.from_json(json_content)
+        regenerated = doc.to_json
+        expect(JSON.parse(regenerated)).to eq(JSON.parse(json_content))
+      end
+    end
+
+    describe "YAML serialization" do
+      let(:yaml_content) do
+        <<~YAML
+          sections:
+            - title: Introduction
+              text: Chapter 1
+            - title: Conclusion
+              text: Final chapter
+          metadata:
+            author: John Doe
+            date: 2024-01-15
+        YAML
+      end
+
+      it "captures all YAML content" do
+        doc = Document.from_yaml(yaml_content)
+        parsed = YAML.safe_load(doc.content, permitted_classes: [Date])
+        expect(parsed["sections"].first["title"]).to eq("Introduction")
+        expect(parsed["metadata"]["author"]).to eq("John Doe")
+      end
+
+      it "preserves YAML content through round trip" do
+        doc = Document.from_yaml(yaml_content)
+        regenerated = doc.to_yaml
+        expect(YAML.safe_load(regenerated, permitted_classes: [Date])).to eq(YAML.safe_load(yaml_content, permitted_classes: [Date]))
+      end
+    end
+
+    describe "TOML serialization" do
+      let(:toml_content) do
+        <<~TOML
+          title = "Document Title"
+
+          [metadata]
+          author = "John Doe"
+          date = "2024-01-15"
+
+          [[sections]]
+          title = "Introduction"
+          text = "Chapter 1"
+
+          [[sections]]
+          title = "Conclusion"
+          text = "Final chapter"
+        TOML
+      end
+
+      it "captures all TOML content" do
+        doc = Document.from_toml(toml_content)
+        parsed = TomlRB.parse(doc.content)
+        expect(parsed["sections"].first["title"]).to eq("Introduction")
+        expect(parsed["metadata"]["author"]).to eq("John Doe")
+      end
+
+      it "preserves TOML content through round trip" do
+        doc = Document.from_toml(toml_content)
+        regenerated = doc.to_toml
+        expect(TomlRB.parse(regenerated)).to eq(TomlRB.parse(toml_content))
+      end
+    end
+
+    describe "invalid mapping combinations" do
+      it "raises error when combining map_all with other mappings" do
+        expect do
+          InvalidDocument.json do
+            map_element "title", to: :title
+          end
+        end.to raise_error(
+          StandardError,
+          "map_all is not allowed with other mappings",
+        )
+      end
+
+      it "raises error when combining other mappings are used with map_all" do
+        expect do
+          InvalidDocument.yaml do
+            map_element "title", to: :title
+            map_all to: :content
+          end
+        end.to raise_error(
+          StandardError,
+          "map_all is not allowed with other mappings",
+        )
+      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)
@@ -539,10 +549,10 @@ RSpec.describe "MixedContent" do
         let(:expected_nokogiri_xml) do
           <<~XML
             <SpecialCharContentWithRawOptionAndMixedOption><special>
-                B &lt;p&gt;R&amp;amp;C&lt;/p&gt;
-                C &lt;p&gt;J&amp;#x2014;C&lt;/p&gt;
-                O &lt;p&gt;A &amp;amp; B &lt;/p&gt;
-                F &lt;p&gt;Z &amp;#xA9;S&lt;/p&gt;
+                B <p>R&amp;C</p>
+                C <p>J—C</p>
+                O <p>A &amp; B </p>
+                F <p>Z ©S</p>
               </special></SpecialCharContentWithRawOptionAndMixedOption>
           XML
         end
@@ -550,10 +560,10 @@ RSpec.describe "MixedContent" do
         let(:expected_ox_xml) do
           <<~XML
             <SpecialCharContentWithRawOptionAndMixedOption>
-              <special> B &lt;p&gt;R&amp;amp;C&lt;/p&gt;
-                C &lt;p&gt;J—C&lt;/p&gt;
-                O &lt;p&gt;A &amp;amp; B &lt;/p&gt;
-                F &lt;p&gt;Z ©S&lt;/p&gt;
+              <special> B <p>R&amp;C</p>
+                C <p>J—C</p>
+                O <p>A &amp; B </p>
+                F <p>Z ©S</p>
               </special>
               </SpecialCharContentWithRawOptionAndMixedOption>
           XML
@@ -562,10 +572,10 @@ RSpec.describe "MixedContent" do
         let(:expected_oga_xml) do
           <<~XML
             <SpecialCharContentWithRawOptionAndMixedOption>
-              <special> B &lt;p&gt;R&amp;C&lt;/p&gt;
-                C &lt;p&gt;J—C&lt;/p&gt;
-                O &lt;p&gt;A &amp; B &lt;/p&gt;
-                F &lt;p&gt;Z ©S&lt;/p&gt;
+              <special> B <p>R&amp;C</p>
+                C <p>J—C</p>
+                O <p>A &amp; B </p>
+                F <p>Z ©S</p>
               </special>
             </SpecialCharContentWithRawOptionAndMixedOption>
           XML
@@ -604,9 +614,9 @@ RSpec.describe "MixedContent" do
       end
 
       describe ".to_xml" do
-        let(:expected_nokogiri_xml) { "B &lt;p&gt;R&lt;/p&gt;" }
-        let(:expected_oga_xml) { "B &lt;p&gt;R&amp;C&lt;/p&gt;" }
-        let(:expected_ox_xml) { "B &lt;p&gt;R&amp;amp;C&lt;/p&gt;" }
+        let(:expected_nokogiri_xml) { "B <p>R</p>" }
+        let(:expected_oga_xml) { "B <p>R&amp;C</p>" }
+        let(:expected_ox_xml) { "B <p>R&amp;C</p>" }
 
         it "serializes 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)