lutaml-model 0.7.1 → 0.7.3

data/spec/lutaml/model/group_spec.rb

@@ -228,13 +228,24 @@ RSpec.describe "Group" do
       )
     end
 
-    it "raises error if root_less class used for deserializing" do
-      ceramic = GroupSpec::Ceramic.new(type: "Data", name: "Starc")
+    context "deserializing XML" do
+      let(:ceramic) { GroupSpec::Ceramic.new(type: "Data", name: "Starc") }
+
+      it "raises error for root_less class" do
+        expect { ceramic.to_xml }.to raise_error(
+          Lutaml::Model::NoRootMappingError,
+          "GroupSpec::Ceramic has `no_root`, it allowed only for reusable models",
+        )
+      end
+    end
 
-      expect { ceramic.to_xml }.to raise_error(
-        Lutaml::Model::NoRootMappingError,
-        "GroupSpec::Ceramic has `no_root`, it allowed only for reusable models",
-      )
+    context "deserializing key-value formats" do
+      let(:ceramic) { GroupSpec::Ceramic.new(type: "Data", name: "Starc") }
+
+      it "does not raises error for root_less class" do
+        expect { ceramic.to_yaml }
+          .not_to raise_error(Lutaml::Model::NoRootMappingError)
+      end
     end
 
     it "correctly get the element of root-less class" do
@@ -412,7 +423,7 @@ RSpec.describe "Group" do
       context "with sequence elements" do
         it "updates sequence elements only in `Mrow`" do
           sequence = GroupSpec::Mrow.mappings_for(:xml).element_sequence.first
-          sequence.attributes << Lutaml::Model::XmlMappingRule.new(
+          sequence.attributes << Lutaml::Model::Xml::MappingRule.new(
             "new_element",
             to: :new_element,
             namespace: "http://example.com",

data/spec/lutaml/model/hash/adapter_spec.rb

@@ -0,0 +1,255 @@
+require "spec_helper"
+
+RSpec.describe "HashAdapter" do
+  before do
+    stub_const("HashMappingSpec", Module.new)
+
+    simple_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :age, :integer
+      attribute :active, :boolean
+
+      hsh do
+        map "name", to: :name
+        map "age", to: :age
+        map "is_active", to: :active
+      end
+    end
+
+    stub_const("HashMappingSpec::SimpleClass", simple_class)
+
+    nested_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :title, :string
+      attribute :simple, HashMappingSpec::SimpleClass
+      attribute :items, :string, collection: true
+
+      hsh do
+        map "title", to: :title
+        map "simple", to: :simple
+        map "items", to: :items
+      end
+    end
+
+    stub_const("HashMappingSpec::NestedClass", nested_class)
+
+    collection_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :simples, HashMappingSpec::SimpleClass, collection: true
+
+      hsh do
+        map "name", to: :name
+        map "simples", to: :simples
+      end
+    end
+
+    stub_const("HashMappingSpec::CollectionClass", collection_class)
+  end
+
+  describe "from_hash" do
+    context "with simple attributes" do
+      let(:parsed) do
+        HashMappingSpec::SimpleClass.from_hash(hash_data)
+      end
+
+      let(:hash_data) do
+        {
+          "name" => "John Doe",
+          "age" => 30,
+          "is_active" => true,
+        }
+      end
+
+      let(:expected) do
+        HashMappingSpec::SimpleClass.new(
+          name: "John Doe",
+          age: 30,
+          active: true,
+        )
+      end
+
+      it "deserializes hash to object" do
+        expect(parsed).to eq(expected)
+      end
+    end
+
+    context "with nested objects" do
+      let(:parsed) do
+        HashMappingSpec::NestedClass.from_hash(hash_data)
+      end
+
+      let(:hash_data) do
+        {
+          "title" => "Test Title",
+          "simple" => {
+            "name" => "Jane Doe",
+            "age" => 25,
+            "is_active" => false,
+          },
+          "items" => ["item1", "item2", "item3"],
+        }
+      end
+
+      let(:expected) do
+        HashMappingSpec::NestedClass.new(
+          title: "Test Title",
+          simple: HashMappingSpec::SimpleClass.new(
+            name: "Jane Doe",
+            age: 25,
+            active: false,
+          ),
+          items: ["item1", "item2", "item3"],
+        )
+      end
+
+      it "deserializes nested objects" do
+        expect(parsed).to eq(expected)
+      end
+    end
+
+    context "with collections of objects" do
+      let(:parsed) do
+        HashMappingSpec::CollectionClass.from_hash(hash_data)
+      end
+
+      let(:hash_data) do
+        {
+          "name" => "Collection",
+          "simples" => [
+            { "name" => "First", "age" => 10, "is_active" => true },
+            { "name" => "Second", "age" => 20, "is_active" => false },
+          ],
+        }
+      end
+
+      let(:expected) do
+        HashMappingSpec::CollectionClass.new(
+          name: "Collection",
+          simples: [
+            HashMappingSpec::SimpleClass.new(
+              name: "First",
+              age: 10,
+              active: true,
+            ),
+            HashMappingSpec::SimpleClass.new(
+              name: "Second",
+              age: 20,
+              active: false,
+            ),
+          ],
+        )
+      end
+
+      it "deserializes collections of objects" do
+        expect(parsed).to eq(expected)
+      end
+    end
+  end
+
+  describe "to_hash" do
+    context "with simple attributes" do
+      let(:instance) do
+        HashMappingSpec::SimpleClass.new(
+          name: "John Doe",
+          age: 30,
+          active: true,
+        )
+      end
+
+      let(:expected_hash) do
+        {
+          "name" => "John Doe",
+          "age" => 30,
+          "is_active" => true,
+        }
+      end
+
+      it "serializes object to hash" do
+        expect(instance.to_hash).to eq(expected_hash)
+      end
+    end
+
+    context "with nested objects" do
+      let(:simple) do
+        HashMappingSpec::SimpleClass.new(
+          name: "Jane Doe",
+          age: 25,
+          active: false,
+        )
+      end
+
+      let(:instance) do
+        HashMappingSpec::NestedClass.new(
+          title: "Test Title",
+          simple: simple,
+          items: ["item1", "item2", "item3"],
+        )
+      end
+
+      let(:expected_hash) do
+        {
+          "title" => "Test Title",
+          "simple" => {
+            "name" => "Jane Doe",
+            "age" => 25,
+            "is_active" => false,
+          },
+          "items" => ["item1", "item2", "item3"],
+        }
+      end
+
+      it "serializes nested objects to hash" do
+        expect(instance.to_hash).to eq(expected_hash)
+      end
+    end
+
+    context "with collections of objects" do
+      let(:simples) do
+        [
+          HashMappingSpec::SimpleClass.new(name: "First", age: 10, active: true),
+          HashMappingSpec::SimpleClass.new(name: "Second", age: 20, active: false),
+        ]
+      end
+
+      let(:instance) do
+        HashMappingSpec::CollectionClass.new(
+          name: "Collection",
+          simples: simples,
+        )
+      end
+
+      let(:expected_hash) do
+        {
+          "name" => "Collection",
+          "simples" => [
+            { "name" => "First", "age" => 10, "is_active" => true },
+            { "name" => "Second", "age" => 20, "is_active" => false },
+          ],
+        }
+      end
+
+      it "serializes collections of objects to hash" do
+        expect(instance.to_hash).to eq(expected_hash)
+      end
+    end
+  end
+
+  describe "round-trip serialization" do
+    let(:original_hash) do
+      {
+        "name" => "Collection",
+        "simples" => [
+          { "name" => "First", "age" => 10, "is_active" => true },
+          { "name" => "Second", "age" => 20, "is_active" => false },
+        ],
+      }
+    end
+
+    let(:parsed) do
+      HashMappingSpec::CollectionClass.from_hash(original_hash)
+    end
+
+    it "maintains data integrity through serialization and deserialization" do
+      expect(parsed.to_hash).to eq(original_hash)
+    end
+  end
+end

data/spec/lutaml/model/json_adapter_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
-require "lutaml/model/json_adapter/standard_json_adapter"
-require "lutaml/model/json_adapter/multi_json_adapter"
+require "lutaml/model/json/standard_adapter"
+require "lutaml/model/json/multi_json_adapter"
 require_relative "../../fixtures/sample_model"
 
 RSpec.describe "JsonAdapter" do
@@ -9,9 +9,9 @@ RSpec.describe "JsonAdapter" do
     let(:model) { SampleModel.new(attributes) }
 
     let(:expected_json) do
-      if adapter_class == Lutaml::Model::JsonAdapter::StandardJsonAdapter
+      if adapter_class == Lutaml::Model::Json::StandardAdapter
         JSON.generate(attributes)
-      elsif adapter_class == Lutaml::Model::JsonAdapter::MultiJsonAdapter
+      elsif adapter_class == Lutaml::Model::Json::MultiJsonAdapter
         MultiJson.dump(attributes)
       end
     end
@@ -29,11 +29,11 @@ RSpec.describe "JsonAdapter" do
     end
   end
 
-  describe Lutaml::Model::JsonAdapter::StandardJsonAdapter do
+  describe Lutaml::Model::Json::StandardAdapter do
     it_behaves_like "a JSON adapter", described_class
   end
 
-  describe Lutaml::Model::JsonAdapter::MultiJsonAdapter do
+  describe Lutaml::Model::Json::MultiJsonAdapter do
     it_behaves_like "a JSON adapter", described_class
   end
 end

data/spec/lutaml/model/key_value_mapping_spec.rb

@@ -3,6 +3,30 @@ require "spec_helper"
 RSpec.describe Lutaml::Model::KeyValueMapping do
   let(:mapping) { described_class.new(:json) }
 
+  it "raises error when :to is nil and :with single mapping" do
+    expect do
+      mapping.map("test", with: { from: :from_method })
+    end.to raise_error(
+      Lutaml::Model::IncorrectMappingArgumentsError,
+      ":with argument for mapping 'test' requires :to and :from keys",
+    )
+  end
+
+  it "raises error when :to is nil and :with arguments have nil values" do
+    expect do
+      mapping.map("test", with: { from: nil, to: nil })
+    end.to raise_error(
+      Lutaml::Model::IncorrectMappingArgumentsError,
+      ":with argument for mapping 'test' requires :to and :from keys",
+    )
+  end
+
+  it "does not raise error when using :to, and :with has single mapping" do
+    expect do
+      mapping.map("test", to: :field, with: { to: :to_method })
+    end.not_to raise_error
+  end
+
   context "with delegate option" do
     before do
       mapping.map("type", to: :type, delegate: :some_delegate)
@@ -115,7 +139,7 @@ RSpec.describe Lutaml::Model::KeyValueMapping do
     end
 
     context "with TOML format" do
-      let(:mapping) { Lutaml::Model::TomlMapping.new }
+      let(:mapping) { Lutaml::Model::Toml::Mapping.new }
 
       it "raises error when render_nil is :as_nil" do
         expect do

data/spec/lutaml/model/mixed_content_spec.rb

@@ -2,9 +2,9 @@
 
 require "spec_helper"
 require "lutaml/model"
-require "lutaml/model/xml_adapter/nokogiri_adapter"
-require "lutaml/model/xml_adapter/ox_adapter"
-require "lutaml/model/xml_adapter/oga_adapter"
+require "lutaml/model/xml/nokogiri_adapter"
+require "lutaml/model/xml/ox_adapter"
+require "lutaml/model/xml/oga_adapter"
 require_relative "../../fixtures/sample_model"
 
 module MixedContentSpec
@@ -246,7 +246,7 @@ RSpec.describe "MixedContent" do
 
           # due to the difference in capturing
           # newlines in ox and nokogiri adapters
-          if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+          if adapter_class == Lutaml::Model::Xml::OxAdapter
             expected_output = expected_output.gsub(/\n\s*/, " ")
           end
 
@@ -297,7 +297,7 @@ RSpec.describe "MixedContent" do
 
           # due to the difference in capturing
           # newlines in ox and nokogiri adapters
-          if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+          if adapter_class == Lutaml::Model::Xml::OxAdapter
             expected_output = expected_output.gsub(/\n\s*/, " ")
           end
 
@@ -353,7 +353,7 @@ RSpec.describe "MixedContent" do
 
           # due to the difference in capturing
           # newlines in ox and nokogiri adapters
-          if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+          if adapter_class == Lutaml::Model::Xml::OxAdapter
             expected_output = expected_output.gsub(/\n\s*/, " ")
           end
 
@@ -412,7 +412,7 @@ RSpec.describe "MixedContent" do
 
           # due to the difference in capturing
           # newlines in ox and nokogiri adapters
-          if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+          if adapter_class == Lutaml::Model::Xml::OxAdapter
             expected_output = expected_output.gsub(/\n\s*/, " ")
           end
 
@@ -539,7 +539,7 @@ RSpec.describe "MixedContent" do
         it "deserializes special char mixed content correctly" do
           parsed = MixedContentSpec::SpecialCharContentWithRawAndMixedOption.from_xml(xml)
           expected_content = public_send(:"expected_#{adapter_class.type}_content")
-          parsed.special.force_encoding("UTF-8") unless adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
+          parsed.special.force_encoding("UTF-8") unless adapter_class == Lutaml::Model::Xml::NokogiriAdapter
 
           expect(parsed.special.strip).to eq(expected_content)
         end
@@ -608,7 +608,7 @@ RSpec.describe "MixedContent" do
         it "deserializes special char mixed content correctly" do
           parsed = MixedContentSpec::SpecialCharContentWithRawAndMixedOption.from_xml(xml)
 
-          expected_output = adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter ? expected_nokogiri_content : expected_ox_content
+          expected_output = adapter_class == Lutaml::Model::Xml::NokogiriAdapter ? expected_nokogiri_content : expected_ox_content
           expect(parsed.special.strip).to eq(expected_output)
         end
       end
@@ -715,9 +715,9 @@ RSpec.describe "MixedContent" do
             parsed = MixedContentSpec::HexCode.from_xml(xml, encoding: nil)
             serialized = parsed.to_xml(encoding: nil)
 
-            expected_output = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
+            expected_output = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
                                 expected_encoding_nil_nokogiri_xml
-                              elsif adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+                              elsif adapter_class == Lutaml::Model::Xml::OxAdapter
                                 expected_encoding_nil_ox_xml
                               else
                                 expected_encoding_nil_oga_xml
@@ -726,7 +726,7 @@ RSpec.describe "MixedContent" do
             expect(parsed.encoding).to be_nil
             expect(serialized.strip).to include(expected_output.strip)
 
-            if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+            if adapter_class == Lutaml::Model::Xml::OxAdapter
               expect(serialized.encoding.to_s).to eq("ASCII-8BIT")
             else
               expect(serialized.encoding.to_s).to eq("UTF-8")
@@ -750,7 +750,7 @@ 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::NokogiriAdapter
+            expected_content = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
                                  "手書き英字１"
                                else
                                  "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
@@ -762,7 +762,7 @@ RSpec.describe "MixedContent" do
           it "deserializes SHIFT encoded content incorrectly without explicit encoding option" do
             parsed = MixedContentSpec::Shift.from_xml(fixture)
 
-            expected_content = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
+            expected_content = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
                                  "手書き英字１"
                                else
                                  "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
@@ -785,7 +785,7 @@ RSpec.describe "MixedContent" do
             parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
             serialized = parsed.to_xml(encoding: "UTF-8")
 
-            parsed_xml = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
+            parsed_xml = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
                            "手書き英字１"
                          else
                            "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
@@ -802,7 +802,7 @@ 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::NokogiriAdapter
+            expected_xml = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
                              "手書き英字１"
                            else
                              "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
@@ -829,9 +829,9 @@ RSpec.describe "MixedContent" do
             parsed = MixedContentSpec::Shift.from_xml(fixture)
             serialized = parsed.to_xml(encoding: "Shift_JIS")
 
-            expected_content = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
+            expected_content = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
                                  "<root>\n  <FieldName>手書き英字１</FieldName>\n  <FieldName>123456</FieldName>\n</root>".encode("Shift_JIS")
-                               elsif adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+                               elsif adapter_class == Lutaml::Model::Xml::OxAdapter
                                  "<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")
@@ -868,7 +868,7 @@ 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::NokogiriAdapter
+            expected_content = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
                                  ["Müller", "José"]
                                else
                                  ["M\xFCller".force_encoding("ISO-8859-1"), "Jos\xE9".force_encoding("ISO-8859-1")]
@@ -882,7 +882,7 @@ RSpec.describe "MixedContent" 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
+            expected_content = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
                                  ["Müller", "José"]
                                else
                                  ["M\xFCller".force_encoding("ISO-8859-1"), "Jos\xE9".force_encoding("ISO-8859-1")]
@@ -898,7 +898,7 @@ RSpec.describe "MixedContent" do
           it "serializes latin encoded content correctly" do
             parsed = MixedContentSpec::Latin.from_xml(fixture, encoding: "ISO-8859-1")
             serialized = parsed.to_xml
-            expected_xml = if adapter_class == Lutaml::Model::XmlAdapter::OgaAdapter
+            expected_xml = if adapter_class == Lutaml::Model::Xml::OgaAdapter
                              "<note><to>Jos\xE9</to><from>M\xFCller</from><heading>Reminder</heading></note>"
                            else
                              "<note>\n  <to>Jos\xE9</to>\n  <from>M\xFCller</from>\n  <heading>Reminder</heading>\n</note>"
@@ -910,7 +910,7 @@ RSpec.describe "MixedContent" do
     end
   end
 
-  describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+  describe Lutaml::Model::Xml::NokogiriAdapter do
     it_behaves_like "mixed content behavior", described_class
 
     it "raises error when serializes special char content with false encoding: 'ABC'" do
@@ -920,11 +920,11 @@ RSpec.describe "MixedContent" do
     end
   end
 
-  describe Lutaml::Model::XmlAdapter::OxAdapter do
+  describe Lutaml::Model::Xml::OxAdapter do
     it_behaves_like "mixed content behavior", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OgaAdapter do
+  describe Lutaml::Model::Xml::OgaAdapter do
     it_behaves_like "mixed content behavior", described_class
   end
 end

data/spec/lutaml/model/multiple_mapping_spec.rb

@@ -252,11 +252,11 @@ RSpec.describe MultipleMapping do
     end
 
     context "with Nokogiri adapter" do
-      it_behaves_like "xml adapter with multiple mappings", Lutaml::Model::XmlAdapter::NokogiriAdapter
+      it_behaves_like "xml adapter with multiple mappings", Lutaml::Model::Xml::NokogiriAdapter
     end
 
     context "with Ox adapter" do
-      it_behaves_like "xml adapter with multiple mappings", Lutaml::Model::XmlAdapter::OxAdapter
+      it_behaves_like "xml adapter with multiple mappings", Lutaml::Model::Xml::OxAdapter
     end
   end
 
@@ -285,7 +285,7 @@ RSpec.describe MultipleMapping do
     context "with XML format" do
       shared_examples "xml adapter with custom methods" do |_adapter_class|
         before do
-          Lutaml::Model::Config.xml_adapter = Lutaml::Model::XmlAdapter::NokogiriAdapter
+          Lutaml::Model::Config.xml_adapter = Lutaml::Model::Xml::NokogiriAdapter
         end
 
         let(:xml_with_alternate) do
@@ -330,11 +330,11 @@ RSpec.describe MultipleMapping do
       end
 
       context "with Nokogiri adapter" do
-        it_behaves_like "xml adapter with custom methods", Lutaml::Model::XmlAdapter::NokogiriAdapter
+        it_behaves_like "xml adapter with custom methods", Lutaml::Model::Xml::NokogiriAdapter
       end
 
       context "with Ox adapter" do
-        it_behaves_like "xml adapter with custom methods", Lutaml::Model::XmlAdapter::OxAdapter
+        it_behaves_like "xml adapter with custom methods", Lutaml::Model::Xml::OxAdapter
       end
     end
   end

data/spec/lutaml/model/ordered_content_spec.rb

@@ -2,9 +2,9 @@
 
 require "spec_helper"
 require "lutaml/model"
-require "lutaml/model/xml_adapter/nokogiri_adapter"
-require "lutaml/model/xml_adapter/ox_adapter"
-require "lutaml/model/xml_adapter/oga_adapter"
+require "lutaml/model/xml/nokogiri_adapter"
+require "lutaml/model/xml/ox_adapter"
+require "lutaml/model/xml/oga_adapter"
 require_relative "../../fixtures/sample_model"
 
 module OrderedContentSpec
@@ -69,15 +69,15 @@ RSpec.describe "OrderedContent" do
     end
   end
 
-  describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+  describe Lutaml::Model::Xml::NokogiriAdapter do
     it_behaves_like "ordered content behavior", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OxAdapter do
+  describe Lutaml::Model::Xml::OxAdapter do
     it_behaves_like "ordered content behavior", described_class
   end
 
-  describe Lutaml::Model::XmlAdapter::OgaAdapter do
+  describe Lutaml::Model::Xml::OgaAdapter do
     it_behaves_like "ordered content behavior", described_class
   end
 end