lutaml-model 0.3.29 → 0.4.0

data/lib/lutaml/model/xml_adapter/ox_adapter.rb

@@ -6,23 +6,28 @@ module Lutaml
   module Model
     module XmlAdapter
       class OxAdapter < XmlDocument
-        def self.parse(xml)
+        def self.parse(xml, options = {})
+          Ox.default_options = Ox.default_options.merge(encoding: options[:encoding] || "UTF-8")
+
           parsed = Ox.parse(xml)
           root = OxElement.new(parsed)
-          new(root)
+          new(root, Ox.default_options[:encoding])
         end
 
         def to_xml(options = {})
-          builder = Builder::Ox.build
           builder_options = { version: options[:version] }
 
-          if options.key?(:encoding)
-            builder_options[:encoding] = options[:encoding] unless options[:encoding].nil?
-          else
-            builder_options[:encoding] = "UTF-8"
-          end
+          builder_options[:encoding] = if options.key?(:encoding)
+                                         options[:encoding]
+                                       elsif options.key?(:parse_encoding)
+                                         options[:parse_encoding]
+                                       else
+                                         "UTF-8"
+                                       end
+
+          builder = Builder::Ox.build
+          builder.xml.instruct(:xml, encoding: options[:parse_encoding])
 
-          builder.xml.instruct(:xml, builder_options)
           if @root.is_a?(Lutaml::Model::XmlAdapter::OxElement)
             @root.build_xml(builder)
           elsif ordered?(@root, options)
@@ -34,7 +39,12 @@ module Lutaml
           end
 
           xml_data = builder.xml.to_s
-          options[:declaration] ? xml_data : xml_data.sub(/\A<\?xml[^>]*\?>\n?/, "")
+          if builder_options[:encoding] && xml_data.valid_encoding?
+            xml_data = xml_data.encode(builder_options[:encoding])
+          end
+
+          stripped_data = xml_data.lines.drop(1).join
+          options[:declaration] ? declaration(options) + stripped_data : stripped_data
         end
 
         private
@@ -145,6 +155,11 @@ module Lutaml
           build_xml.xml.to_s
         end
 
+        def inner_xml
+          # Ox builder by default, adds a newline at the end, so `chomp` is used
+          children.map { |child| child.to_xml.chomp }.join
+        end
+
         def build_xml(builder = nil)
           builder ||= Builder::Ox.build
           attrs = build_attributes(self)

data/lib/lutaml/model/xml_adapter/xml_document.rb

@@ -7,13 +7,14 @@ module Lutaml
   module Model
     module XmlAdapter
       class XmlDocument
-        attr_reader :root
+        attr_reader :root, :encoding
 
-        def initialize(root)
+        def initialize(root, encoding = nil)
           @root = root
+          @encoding = encoding
         end
 
-        def self.parse(xml)
+        def self.parse(xml, _options = {})
           raise NotImplementedError, "Subclasses must implement `parse`."
         end
 
@@ -150,6 +151,8 @@ module Lutaml
               value,
               options.merge({ rule: rule, attribute: attribute }),
             )
+          elsif rule.raw_mapping?
+            xml.add_xml_fragment(xml, value)
           elsif rule.prefix_set?
             xml.create_and_add_element(rule.name, prefix: prefix) do
               add_value(xml, value, attribute, cdata: rule.cdata)
@@ -186,10 +189,6 @@ module Lutaml
           attributes = build_attributes(element,
                                         xml_mapping, options).merge(attributes)&.compact
 
-          if element.respond_to?(:schema_location) && element.schema_location
-            attributes.merge!(element.schema_location.to_xml_attributes)
-          end
-
           prefix = if options.key?(:namespace_prefix)
                      options[:namespace_prefix]
                    elsif xml_mapping.namespace_prefix
@@ -210,7 +209,8 @@ module Lutaml
                                                  xml)
             end
 
-            xml_mapping.elements.each do |element_rule|
+            mappings = xml_mapping.elements + [xml_mapping.raw_mapping].compact
+            mappings.each do |element_rule|
               attribute_def = attribute_definition_for(element, element_rule,
                                                        mapper_class: mapper_class)
 
@@ -234,20 +234,9 @@ module Lutaml
 
             process_content_mapping(element, xml_mapping.content_mapping,
                                     prefixed_xml)
-
-            process_raw_mapping(element, xml_mapping.raw_mapping, prefixed_xml)
           end
         end
 
-        def process_raw_mapping(element, rule, xml)
-          return unless rule
-
-          value = attribute_value_for(element, rule)
-          return unless render_element?(rule, element, value)
-
-          xml.add_text(xml, value, cdata: rule.cdata)
-        end
-
         def process_content_mapping(element, content_rule, xml)
           return unless content_rule
 
@@ -343,7 +332,7 @@ module Lutaml
                     {}
                   end
 
-          if element.respond_to?(:schema_location) && element.schema_location
+          if element.respond_to?(:schema_location) && element.schema_location && !options[:except]&.include?(:schema_location)
             attrs.merge!(element.schema_location.to_xml_attributes)
           end
 
@@ -355,10 +344,9 @@ module Lutaml
               hash["xmlns:#{mapping_rule.prefix}"] = mapping_rule.namespace
             end
 
-            if render_element?(mapping_rule, element,
-                               mapping_rule.to_value_for(element))
-              hash[mapping_rule.prefixed_name] =
-                mapping_rule.to_value_for(element)
+            value = mapping_rule.to_value_for(element)
+            if render_element?(mapping_rule, element, value)
+              hash[mapping_rule.prefixed_name] = value ? value.to_s : value
             end
           end
 

data/lib/lutaml/model/yaml_adapter/standard_yaml_adapter.rb

@@ -14,7 +14,7 @@ module Lutaml
                               PERMITTED_CLASSES_BASE
                             end.freeze
 
-        def self.parse(yaml)
+        def self.parse(yaml, _options = {})
           YAML.safe_load(yaml, permitted_classes: PERMITTED_CLASSES)
         end
 

data/lib/lutaml/model/yaml_adapter/yaml_document.rb

@@ -7,7 +7,7 @@ module Lutaml
     module YamlAdapter
       # Base class for YAML documents
       class YamlDocument < YamlObject
-        def self.parse(yaml)
+        def self.parse(yaml, _options = {})
           raise NotImplementedError, "Subclasses must implement `parse`."
         end
 

data/spec/fixtures/xml/latin_encoding.xml

@@ -0,0 +1,5 @@
+<note>
+    <to>Jos�</to>
+    <from>M�ller</from>
+    <heading>Reminder</heading>
+</note>

data/spec/fixtures/xml/shift_jis.xml

@@ -0,0 +1,4 @@
+<root>
+  <FieldName>�菑���p���P</FieldName>
+  <FieldName>123456</FieldName>
+</root>

data/spec/lutaml/model/custom_serialization_spec.rb

@@ -138,6 +138,22 @@ RSpec.describe CustomSerialization do
     end
   end
 
+  context "with partial JSON input" do
+    it "deserializes from JSON with missing attributes" do
+      json = {
+        name: "JSON Masterpiece: Vase",
+        color: "BLUE",
+      }.to_json
+
+      ceramic = described_class.from_json(json)
+
+      expect(ceramic.full_name).to eq("Vase")
+      expect(ceramic.color).to eq("blue")
+      expect(ceramic.size).to be_nil
+      expect(ceramic.description).to be_nil
+    end
+  end
+
   context "with XML serialization" do
     it "serializes to XML with custom methods" do
       expected_xml = <<~XML

data/spec/lutaml/model/defaults_spec.rb

@@ -105,6 +105,29 @@ module DefaultsSpec
       map "opacity", to: :opacity, render_default: false
     end
   end
+
+  # Class for testing render_default: true with custom model
+  class Lang
+    attr_accessor :lang, :content
+  end
+
+  class CustomModelWithDefaultValue < Lutaml::Model::Serializable
+    model Lang
+
+    attribute :lang, :string, default: -> { "en" }
+    attribute :content, :string, default: -> { "default value not render when render_default is false" }
+
+    xml do
+      root "CustomModelWithDefaultValue"
+      map_attribute "lang", to: :lang, render_default: true
+      map_content to: :content, render_default: false
+    end
+
+    key_value do
+      map "lang", to: :lang, render_default: true
+      map "content", to: :content, render_default: false
+    end
+  end
 end
 
 RSpec.describe DefaultsSpec::Glaze do
@@ -125,6 +148,13 @@ RSpec.describe DefaultsSpec::Glaze do
       expect(default_model.manufacturer).to eq("example@glazes.com")
       expect(default_model.type).to eq("stoneware")
     end
+
+    it "contains the default value in instance" do
+      instance = DefaultsSpec::CustomModelWithDefaultValue.new
+
+      expect(instance.content).to eq("default value not render when render_default is false")
+      expect(instance.lang).to eq("en")
+    end
   end
 
   describe "Default value rendering behavior" do
@@ -155,6 +185,15 @@ RSpec.describe DefaultsSpec::Glaze do
           expect(xml).to include("<Opacity>Opaque</Opacity>")
           expect(xml).to include("<FiringTime>60</FiringTime>")
         end
+
+        it "serializes when render_default is true with custom model" do
+          parsed = DefaultsSpec::CustomModelWithDefaultValue.from_xml "<CustomModelWithDefaultValue>English</CustomModelWithDefaultValue>"
+          expect(parsed.lang).to eq("en")
+          expect(parsed.content).to eq("English")
+
+          serialized = DefaultsSpec::CustomModelWithDefaultValue.to_xml(parsed)
+          expect(serialized).to eq("<CustomModelWithDefaultValue lang=\"en\">English</CustomModelWithDefaultValue>")
+        end
       end
 
       context "when value is not default" do
@@ -200,6 +239,15 @@ RSpec.describe DefaultsSpec::Glaze do
           expect(json["opacity"]).to eq("Opaque")
           expect(json["firingTime"]).to eq(60)
         end
+
+        it "serializes when render_default is true with custom model" do
+          parsed = DefaultsSpec::CustomModelWithDefaultValue.from_json('{"content": "content"}')
+          expect(parsed.lang).to eq("en")
+          expect(parsed.content).to eq("content")
+
+          serialized = DefaultsSpec::CustomModelWithDefaultValue.to_json(parsed)
+          expect(serialized).to eq('{"lang":"en","content":"content"}')
+        end
       end
 
       context "when value is not default" do
@@ -217,5 +265,31 @@ RSpec.describe DefaultsSpec::Glaze do
         end
       end
     end
+
+    context "with YAML serialization" do
+      context "when value is default" do
+        it "serializes when render_default is true with custom model" do
+          parsed = DefaultsSpec::CustomModelWithDefaultValue.from_yaml("---\ncontent: content")
+          expect(parsed.lang).to eq("en")
+          expect(parsed.content).to eq("content")
+
+          serialized = DefaultsSpec::CustomModelWithDefaultValue.to_yaml(parsed)
+          expect(serialized).to eq("---\nlang: en\ncontent: content\n")
+        end
+      end
+    end
+
+    context "with TOML serialization" do
+      context "when value is default" do
+        it "serializes when render_default is true with custom model" do
+          parsed = DefaultsSpec::CustomModelWithDefaultValue.from_toml("content = 'content'")
+          expect(parsed.lang).to eq("en")
+          expect(parsed.content).to eq("content")
+
+          serialized = DefaultsSpec::CustomModelWithDefaultValue.to_toml(parsed)
+          expect(serialized).to eq("content = \"content\"\nlang = \"en\"\n")
+        end
+      end
+    end
   end
 end

data/spec/lutaml/model/enum_spec.rb

@@ -0,0 +1,131 @@
+require "spec_helper"
+require "lutaml/model"
+
+module EnumSpec
+  class WithEnum < Lutaml::Model::Serializable
+    attribute :without_enum, :string
+    attribute :single_value, :string, values: %w[user admin super_admin]
+    attribute :multi_value, :string, values: %w[singular dual plural], collection: true
+  end
+end
+
+RSpec.describe "Enum" do
+  let(:single_value_attr) do
+    EnumSpec::WithEnum.attributes[:single_value]
+  end
+
+  let(:multi_value_attr) do
+    EnumSpec::WithEnum.attributes[:multi_value]
+  end
+
+  let(:without_enum_attr) do
+    EnumSpec::WithEnum.attributes[:without_enum]
+  end
+
+  let(:object) do
+    EnumSpec::WithEnum.new
+  end
+
+  context "when values are provided for an attribute" do
+    it "is marked as enum for single_value" do
+      expect(single_value_attr.enum?).to be(true)
+    end
+
+    it "is marked as enum for multi_value" do
+      expect(multi_value_attr.enum?).to be(true)
+    end
+
+    context "with enum convinience methods" do
+      describe "#single_value" do
+        it "returns single value" do
+          expect { object.single_value = "user" }
+            .to change(object, :single_value)
+            .from(nil)
+            .to("user")
+        end
+      end
+
+      describe "#multi_value" do
+        it "returns single value in array" do
+          expect { object.multi_value = "dual" }
+            .to change(object, :multi_value)
+            .from([])
+            .to(["dual"])
+        end
+
+        it "returns multiple value in array" do
+          expect { object.multi_value = %w[dual plural] }
+            .to change(object, :multi_value)
+            .from([])
+            .to(%w[dual plural])
+        end
+      end
+
+      EnumSpec::WithEnum.enums.each_value do |enum_attr|
+        enum_attr.enum_values.each do |value|
+          describe "##{value}=" do
+            it "sets the #{value} if true" do
+              expect { object.public_send(:"#{value}=", true) }
+                .to change { object.public_send(:"#{value}?") }
+                .from(false)
+                .to(true)
+            end
+
+            it "unsets the #{value} if false" do
+              object.public_send(:"#{value}=", true)
+
+              expect { object.public_send(:"#{value}=", false) }
+                .to change(object, "#{value}?")
+                .from(true)
+                .to(false)
+            end
+          end
+
+          describe "##{value}!" do
+            it "method #{value}? should be present" do
+              expect(object.respond_to?(:"#{value}!")).to be(true)
+            end
+
+            it "sets #{value} to true for enum" do
+              expect { object.public_send(:"#{value}!") }
+                .to change(object, "#{value}?")
+                .from(false)
+                .to(true)
+            end
+          end
+
+          describe "##{value}?" do
+            it "method #{value}? should be present" do
+              expect(object.respond_to?(:"#{value}?")).to be(true)
+            end
+
+            it "is false if role is not #{value}" do
+              expect(object.public_send(:"#{value}?")).to be(false)
+            end
+
+            it "is true if role is set to #{value}" do
+              expect { object.public_send(:"#{value}=", value) }
+                .to change(object, "#{value}?")
+                .from(false)
+                .to(true)
+            end
+          end
+
+          it "adds a method named #{value}=" do
+            expect(object.respond_to?(:"#{value}?")).to be(true)
+          end
+
+          it "adds a method named #{value}!" do
+            expect(object.respond_to?(:"#{value}!")).to be(true)
+          end
+        end
+      end
+    end
+  end
+
+  context "when values are not provided for an attribute" do
+    it "is not marked as enum" do
+      expect(without_enum_attr.enum?).to be(false)
+    end
+  end
+end

data/spec/lutaml/model/mixed_content_spec.rb

@@ -72,6 +72,28 @@ module MixedContentSpec
     end
   end
 
+  class Latin < Lutaml::Model::Serializable
+    attribute :the, :string
+    attribute :from, :string
+    attribute :heading, :string
+
+    xml do
+      root "note"
+      map_element "to", to: :the
+      map_element "from", to: :from
+      map_element "heading", to: :heading
+    end
+  end
+
+  class Shift < Lutaml::Model::Serializable
+    attribute :field, :string, collection: true
+
+    xml do
+      root "root"
+      map_element "FieldName", to: :field
+    end
+  end
+
   class SpecialCharContentWithMixedTrue < Lutaml::Model::Serializable
     attribute :content, :string
 
@@ -651,24 +673,185 @@ RSpec.describe "MixedContent" do
 
         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) { "\xE2\x88\x91computer security\xE2\x88\x8F type of \xE2\x80\x8B operation specified \xC2\xB5 by an access right" }
+          let(:expected_encoding_nil_ox_xml) { "∑computer security∏ type of ​ operation specified µ by an access right" }
 
           it "serializes special char mixed content correctly with encoding: nil to get hexcode" do
             parsed = MixedContentSpec::HexCode.from_xml(xml)
             serialized = parsed.to_xml(encoding: nil)
 
-            if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
-              expected_output = expected_encoding_nil_ox_xml
-              expected_output.force_encoding("ASCII-8BIT")
-            else
-              expected_output = expected_encoding_nil_nokogiri_xml
-            end
+            expected_output = if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+                                expected_encoding_nil_ox_xml
+                              else
+                                expected_encoding_nil_nokogiri_xml
+                              end
 
             expect(serialized.strip).to include(expected_output)
           end
         end
       end
     end
+
+    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") }
+
+        describe ".from_xml" do
+          it "verifies the encoding of file read" do
+            expect(fixture.encoding.to_s).to eq("Shift_JIS")
+          end
+
+          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
+                                 "手書き英字１"
+                               end
+
+            expect(parsed.field).to include(expected_content)
+          end
+
+          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::OxAdapter
+                                 "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("UTF-8")
+                               else
+                                 "�菑���p���P"
+                               end
+
+            expect(parsed.field).to include(expected_content)
+          end
+        end
+
+        describe ".to_xml" do
+          it "serializes SHIFT-JIS encoding content correctly reading from file" do
+            parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
+            serialized = parsed.to_xml
+
+            expect(serialized.strip).to eq(fixture.strip)
+          end
+
+          it "serializes SHIFT encoded content correctly with explicit encoding option both in parsing and deserializing" 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
+
+            expect(parsed.field).to include(expected_xml)
+            expect(parsed.encoding).to eq("Shift_JIS")
+
+            expect(serialized).to include("手書き英字１")
+            expect(serialized.encoding.to_s).to eq("UTF-8")
+          end
+
+          it "serializes SHIFT encoded content correctly with explicit encoding option" 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
+                             "手書き英字１"
+                           end
+
+            expect(parsed.field).to include(expected_xml)
+            expect(parsed.encoding).to eq("Shift_JIS")
+
+            expect(serialized).to include("\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS"))
+            expect(serialized.encoding.to_s).to eq("Shift_JIS")
+          end
+
+          it "serializes SHIFT encoded content correctly with declaration: true" do
+            parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
+            serialized = parsed.to_xml(declaration: true, encoding: "Shift_JIS")
+
+            expected_xml = "<?xml version=\"1.0\" encoding=\"Shift_JIS\"?>\n<root>\n  <FieldName>\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P</FieldName>\n  <FieldName>123456</FieldName>\n</root>"
+
+            expect(serialized).to be_equivalent_to(expected_xml)
+            expect(serialized.encoding.to_s).to eq("Shift_JIS")
+          end
+
+          it "serializes SHIFT-JIS content incorrectly bcz no encoding provided during parsing" do
+            parsed = MixedContentSpec::Shift.from_xml(fixture)
+            serialized = parsed.to_xml(encoding: "Shift_JIS")
+
+            expected_content = if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+                                 "<root>\n  <FieldName>\x8E菑\x82\xAB\x89p\x8E\x9A\x82P</FieldName>\n  <FieldName>123456</FieldName>\n</root>\n"
+                               else
+                                 "<root>\n  <FieldName>&#65533;&#33745;&#65533;&#65533;&#65533;p&#65533;&#65533;&#65533;P</FieldName>\n  <FieldName>123456</FieldName>\n</root>"
+                               end
+
+            expect(serialized).to eq(expected_content)
+          end
+
+          it "serializes SHIFT-JIS encoding content correctly reading from string" do
+            xml = "<root><FieldName>手書き英字１</FieldName><FieldName>123456</FieldName></root>".encode("Shift_JIS")
+            parsed = MixedContentSpec::Shift.from_xml(xml, encoding: "Shift_JIS")
+            serialized = parsed.to_xml(encoding: "Shift_JIS")
+
+            expect(serialized).to be_equivalent_to(xml)
+          end
+
+          it "serializes SHIFT-JIS encoding content correctly" do
+            parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
+            serialized = parsed.to_xml(encoding: "Shift_JIS")
+
+            expect(serialized).to be_equivalent_to(fixture)
+          end
+        end
+      end
+
+      context "when use LATIN (ISO-8859-1) encoding" do
+        let(:fixture) { File.read(fixture_path("xml/latin_encoding.xml"), encoding: "ISO-8859-1") }
+
+        describe ".from_xml" do
+          it "verifies the encoding of file read" do
+            expect(fixture.encoding.to_s).to eq("ISO-8859-1")
+          end
+
+          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
+                                 ["Müller", "José"]
+                               end
+
+            expect(parsed.from).to eq(expected_content[0])
+            expect(parsed.the).to eq(expected_content[1])
+          end
+
+          it "deserializes latin encoded content incorrectly" do
+            parsed = MixedContentSpec::Latin.from_xml(fixture)
+
+            expected_content = if adapter_class == Lutaml::Model::XmlAdapter::OxAdapter
+                                 ["M\xFCller", "Jos\xE9"]
+                               else
+                                 ["M�ller", "Jos�"]
+                               end
+
+            expect(parsed.from).to eq(expected_content[0])
+            expect(parsed.the).to eq(expected_content[1])
+          end
+        end
+
+        describe ".to_xml" do
+          it "serializes latin encoded content correctly" do
+            parsed = MixedContentSpec::Latin.from_xml(fixture, encoding: "ISO-8859-1")
+            serialized = parsed.to_xml
+
+            expect(serialized.strip).to eq("<note>\n  <to>Jos\xE9</to>\n  <from>M\xFCller</from>\n  <heading>Reminder</heading>\n</note>".force_encoding("ISO-8859-1"))
+          end
+        end
+      end
+    end
   end
 
   describe Lutaml::Model::XmlAdapter::NokogiriAdapter do

data/spec/lutaml/model/render_nil_spec.rb

@@ -68,7 +68,6 @@ RSpec.describe RenderNil do
       name: nil,
       clay_type: nil,
       glaze: nil,
-      dimensions: [],
     }.to_json
 
     expect(model.to_json).to eq(expected_json)
@@ -113,7 +112,6 @@ RSpec.describe RenderNil do
       ---
       name:
       glaze:
-      dimensions: []
     YAML
 
     generated_yaml = model.to_yaml.strip