lutaml-model 0.6.1 → 0.6.2

data/spec/lutaml/model/schema/xsd_schema_spec.rb

@@ -1,21 +1,21 @@
 require "spec_helper"
 require "lutaml/model/schema"
 
-RSpec.describe Lutaml::Model::Schema::XsdSchema do
-  module SchemaGeneration
-    class Glaze < Lutaml::Model::Serializable
-      attribute :color, Lutaml::Model::Type::String
-      attribute :finish, Lutaml::Model::Type::String
-    end
+module SchemaGeneration
+  class Glaze < Lutaml::Model::Serializable
+    attribute :color, Lutaml::Model::Type::String
+    attribute :finish, Lutaml::Model::Type::String
+  end
 
-    class Vase < Lutaml::Model::Serializable
-      attribute :height, Lutaml::Model::Type::Float
-      attribute :diameter, Lutaml::Model::Type::Float
-      attribute :glaze, Glaze
-      attribute :materials, Lutaml::Model::Type::String, collection: true
-    end
+  class Vase < Lutaml::Model::Serializable
+    attribute :height, Lutaml::Model::Type::Float
+    attribute :diameter, Lutaml::Model::Type::Float
+    attribute :glaze, Glaze
+    attribute :materials, Lutaml::Model::Type::String, collection: true
   end
+end
 
+RSpec.describe Lutaml::Model::Schema::XsdSchema do
   describe ".generate" do
     it "generates an XSD schema for nested Serialize objects" do
       schema = described_class.generate(SchemaGeneration::Vase, pretty: true)

data/spec/lutaml/model/schema/yaml_schema_spec.rb

@@ -1,21 +1,21 @@
 require "spec_helper"
 require "lutaml/model/schema"
 
-RSpec.describe Lutaml::Model::Schema::YamlSchema do
-  module SchemaGeneration
-    class Glaze < Lutaml::Model::Serializable
-      attribute :color, Lutaml::Model::Type::String
-      attribute :finish, Lutaml::Model::Type::String
-    end
+module SchemaGeneration
+  class Glaze < Lutaml::Model::Serializable
+    attribute :color, Lutaml::Model::Type::String
+    attribute :finish, Lutaml::Model::Type::String
+  end
 
-    class Vase < Lutaml::Model::Serializable
-      attribute :height, Lutaml::Model::Type::Float
-      attribute :diameter, Lutaml::Model::Type::Float
-      attribute :glaze, Glaze
-      attribute :materials, Lutaml::Model::Type::String, collection: true
-    end
+  class Vase < Lutaml::Model::Serializable
+    attribute :height, Lutaml::Model::Type::Float
+    attribute :diameter, Lutaml::Model::Type::Float
+    attribute :glaze, Glaze
+    attribute :materials, Lutaml::Model::Type::String, collection: true
   end
+end
 
+RSpec.describe Lutaml::Model::Schema::YamlSchema do
   describe ".generate" do
     it "generates a YAML schema for nested Serialize objects" do
       schema = described_class.generate(SchemaGeneration::Vase)

data/spec/lutaml/model/sequence_spec.rb

@@ -56,45 +56,10 @@ RSpec.describe "Sequence" do
   context "with nesting sequence" do
     let(:mapper) { SequenceSpec::Ceramic }
 
-    it "don't raise error for a valid instance, if given attribute for sequence has correct order" do
-      xml = <<~XML
-        <Ceramic>
-          <tag>Nik</tag>
-          <id>1</id>
-          <name>Vase</name>
-          <type>Decorative</type>
-          <color>Blue</color>
-          <bold>Heading</bold>
-          <text>Header</text>
-          <usage>Indoor</usage>
-          <size>Medium</size>
-          <first_name>Dale</first_name>
-          <last_name>Steyn</last_name>
-          <temperature>Normal</temperature>
-        </Ceramic>
-      XML
-
-      expect { mapper.from_xml(xml) }.not_to raise_error
-    end
-
-    it "don't raise error for a valid instance with sequence range, if given attribute for sequence has correct order" do
-      xml = <<~XML
-        <collection>
-          <ceramic>
-            <tag>Nik</tag>
-            <id>1</id>
-            <name>Vase</name>
-            <type>Decorative</type>
-            <color>Blue</color>
-            <bold>Heading</bold>
-            <text>Header</text>
-            <usage>Indoor</usage>
-            <size>Medium</size>
-            <first_name>Dale</first_name>
-            <last_name>Steyn</last_name>
-            <temperature>Normal</temperature>
-          </ceramic>
-          <ceramic>
+    context "when given attribute for sequence has correct order" do
+      let(:xml) do
+        <<~XML
+          <Ceramic>
             <tag>Nik</tag>
             <id>1</id>
             <name>Vase</name>
@@ -107,95 +72,146 @@ RSpec.describe "Sequence" do
             <first_name>Dale</first_name>
             <last_name>Steyn</last_name>
             <temperature>Normal</temperature>
-          </ceramic>
-        </collection>
-      XML
+          </Ceramic>
+        XML
+      end
 
-      expect do
-        SequenceSpec::CeramicCollection.from_xml(xml)
-      end.not_to raise_error
+      it "does not raise error" do
+        expect { mapper.from_xml(xml) }.not_to raise_error
+      end
     end
 
-    it "raises error, if given attributes order is incorrect in sequence" do
-      xml = <<~XML
-        <Ceramic>
-          <tag>Nik</tag>
-          <temperature>High</temperature>
-          <first_name>Micheal</first_name>
-          <id>1</id>
-          <name>Vase</name>
-          <type>Decorative</type>
-          <color>Blue</color>
-          <bold>Heading</bold>
-          <usage>Indoor</usage>
-          <size>Medium</size>
-          <last_name>Johnson</last_name>
-          <text>Header</text>
-        </Ceramic>
-      XML
+    context "when given attribute for sequence collection has correct order" do
+      let(:xml) do
+        <<~XML
+          <collection>
+            <ceramic>
+              <tag>Nik</tag>
+              <id>1</id>
+              <name>Vase</name>
+              <type>Decorative</type>
+              <color>Blue</color>
+              <bold>Heading</bold>
+              <text>Header</text>
+              <usage>Indoor</usage>
+              <size>Medium</size>
+              <first_name>Dale</first_name>
+              <last_name>Steyn</last_name>
+              <temperature>Normal</temperature>
+            </ceramic>
+            <ceramic>
+              <tag>Nik</tag>
+              <id>1</id>
+              <name>Vase</name>
+              <type>Decorative</type>
+              <color>Blue</color>
+              <bold>Heading</bold>
+              <text>Header</text>
+              <usage>Indoor</usage>
+              <size>Medium</size>
+              <first_name>Dale</first_name>
+              <last_name>Steyn</last_name>
+              <temperature>Normal</temperature>
+            </ceramic>
+          </collection>
+        XML
+      end
 
-      expect do
-        mapper.from_xml(xml)
-      end.to raise_error(Lutaml::Model::IncorrectSequenceError) do |error|
-        expect(error.message).to eq("Element `usage` does not match the expected sequence order element `text`")
+      it "does not raise error" do
+        expect do
+          SequenceSpec::CeramicCollection.from_xml(xml)
+        end.not_to raise_error
       end
     end
 
-    it "raises error with sequence range, if given attributes order is incorrect in sequence" do
-      invalid_xml = <<~XML
-        <collection>
-          <ceramic>
+    context "when given attributes order is incorrect in sequence" do
+      let(:xml) do
+        <<~XML
+          <Ceramic>
+            <tag>Nik</tag>
+            <temperature>High</temperature>
+            <first_name>Micheal</first_name>
             <id>1</id>
             <name>Vase</name>
             <type>Decorative</type>
             <color>Blue</color>
             <bold>Heading</bold>
-            <text>Header</text>
             <usage>Indoor</usage>
             <size>Medium</size>
-            <first_name>Dale</first_name>
-            <last_name>Steyn</last_name>
-            <temperature>Normal</temperature>
-            <tag>Nik</tag>
-          </ceramic>
-
-          <ceramic>
-            <id>2</id>
-            <name>Nick</name>
-            <type>Unique</type>
-            <color>Red</color>
-            <bold>Name</bold>
-            <text>Body</text>
-            <usage>Outdoor</usage>
-            <size>Small</size>
-            <first_name>Smith</first_name>
-            <last_name>Ash</last_name>
-            <temperature>High</temperature>
-            <tag>Adid</tag>
-          </ceramic>
-
-          <ceramic>
-            <id>3</id>
-            <name>Starc</name>
-            <type>Int</type>
-            <color>White</color>
-            <bold>Act</bold>
-            <text>Footer</text>
-            <usage>Nothing</usage>
-            <size>Large</size>
-            <first_name>Dale</first_name>
-            <last_name>Steyn</last_name>
-            <temperature>Normal</temperature>
-            <tag>Bet</tag>
-          </ceramic>
-        </collection>
-      XML
+            <last_name>Johnson</last_name>
+            <text>Header</text>
+          </Ceramic>
+        XML
+      end
 
-      expect do
-        SequenceSpec::CeramicCollection.from_xml(invalid_xml).validate!
-      end.to raise_error(Lutaml::Model::ValidationError) do |error|
-        expect(error).to include(Lutaml::Model::CollectionCountOutOfRangeError)
-        expect(error.error_messages).to eq(["ceramic count is 3, must be between 1 and 2"])
+      it "raises IncorrectSequenceError error" do
+        expect do
+          mapper.from_xml(xml)
+        end.to raise_error(Lutaml::Model::IncorrectSequenceError) do |error|
+          expect(error.message).to eq("Element `usage` does not match the expected sequence order element `text`")
+        end
+      end
+    end
+
+    context "when given attributes order is incorrect in sequence collection" do
+      let(:xml) do
+        <<~XML
+          <collection>
+            <ceramic>
+              <id>1</id>
+              <name>Vase</name>
+              <type>Decorative</type>
+              <color>Blue</color>
+              <bold>Heading</bold>
+              <text>Header</text>
+              <usage>Indoor</usage>
+              <size>Medium</size>
+              <first_name>Dale</first_name>
+              <last_name>Steyn</last_name>
+              <temperature>Normal</temperature>
+              <tag>Nik</tag>
+            </ceramic>
+
+            <ceramic>
+              <id>2</id>
+              <name>Nick</name>
+              <type>Unique</type>
+              <color>Red</color>
+              <bold>Name</bold>
+              <text>Body</text>
+              <usage>Outdoor</usage>
+              <size>Small</size>
+              <first_name>Smith</first_name>
+              <last_name>Ash</last_name>
+              <temperature>High</temperature>
+              <tag>Adid</tag>
+            </ceramic>
+
+            <ceramic>
+              <id>3</id>
+              <name>Starc</name>
+              <type>Int</type>
+              <color>White</color>
+              <bold>Act</bold>
+              <text>Footer</text>
+              <usage>Nothing</usage>
+              <size>Large</size>
+              <first_name>Dale</first_name>
+              <last_name>Steyn</last_name>
+              <temperature>Normal</temperature>
+              <tag>Bet</tag>
+            </ceramic>
+          </collection>
+        XML
+      end
+
+      it "raises CollectionCountOutOfRangeError error" do
+        expect do
+          SequenceSpec::CeramicCollection.from_xml(xml).validate!
+        end.to raise_error(Lutaml::Model::ValidationError) do |error|
+          expect(error).to include(Lutaml::Model::CollectionCountOutOfRangeError)
+          expect(error.error_messages).to eq(["ceramic count is 3, must be between 1 and 2"])
+        end
       end
     end
 

data/spec/lutaml/model/toml_adapter_spec.rb

@@ -3,37 +3,39 @@ require "lutaml/model/toml_adapter/toml_rb_adapter"
 require "lutaml/model/toml_adapter/tomlib_adapter"
 require_relative "../../fixtures/sample_model"
 
-RSpec.shared_examples "a TOML adapter" do |adapter_class|
-  let(:attributes) { { name: "John Doe", age: 30 } }
-  let(:model) { SampleModel.new(attributes) }
-
-  let(:expected_toml) do
-    if adapter_class == Lutaml::Model::TomlAdapter::TomlRbAdapter
-      TomlRB.dump(attributes)
-    elsif adapter_class == Lutaml::Model::TomlAdapter::TomlibAdapter
-      Tomlib.dump(attributes)
+RSpec.describe "TomlAdapter" do
+  shared_examples "a TOML adapter" do |adapter_class|
+    let(:attributes) { { name: "John Doe", age: 30 } }
+    let(:model) { SampleModel.new(attributes) }
+
+    let(:expected_toml) do
+      if adapter_class == Lutaml::Model::TomlAdapter::TomlRbAdapter
+        TomlRB.dump(attributes)
+      elsif adapter_class == Lutaml::Model::TomlAdapter::TomlibAdapter
+        Tomlib.dump(attributes)
+      end
     end
-  end
 
-  it "serializes to TOML" do
-    toml = adapter_class.new(attributes).to_toml
+    it "serializes to TOML" do
+      toml = adapter_class.new(attributes).to_toml
 
-    expect(toml).to eq(expected_toml)
-  end
+      expect(toml).to eq(expected_toml)
+    end
 
-  it "deserializes from TOML" do
-    doc = adapter_class.parse(expected_toml)
-    new_model = SampleModel.new(doc.to_h)
+    it "deserializes from TOML" do
+      doc = adapter_class.parse(expected_toml)
+      new_model = SampleModel.new(doc.to_h)
 
-    expect(new_model.name).to eq("John Doe")
-    expect(new_model.age).to eq(30)
+      expect(new_model.name).to eq("John Doe")
+      expect(new_model.age).to eq(30)
+    end
   end
-end
 
-RSpec.describe Lutaml::Model::TomlAdapter::TomlRbAdapter do
-  it_behaves_like "a TOML adapter", described_class
-end
+  describe Lutaml::Model::TomlAdapter::TomlRbAdapter do
+    it_behaves_like "a TOML adapter", described_class
+  end
 
-RSpec.describe Lutaml::Model::TomlAdapter::TomlibAdapter do
-  it_behaves_like "a TOML adapter", described_class
+  describe Lutaml::Model::TomlAdapter::TomlibAdapter do
+    it_behaves_like "a TOML adapter", described_class
+  end
 end

data/spec/lutaml/model/transformation_spec.rb

@@ -1,97 +1,97 @@
 require "spec_helper"
 
-RSpec.describe "Value Transformations" do
-  module TransformationSpec
-    # Class with only attribute-level transformations
-    class AttributeTransformPerson < Lutaml::Model::Serializable
-      attribute :name, :string, transform: {
-        export: ->(value) { value.to_s.upcase },
+module TransformationSpec
+  # Class with only attribute-level transformations
+  class AttributeTransformPerson < Lutaml::Model::Serializable
+    attribute :name, :string, transform: {
+      export: ->(value) { value.to_s.upcase },
+    }
+    attribute :email, :string, transform: {
+      import: ->(value) { "#{value}@example.com" },
+    }
+    attribute :tags, :string, collection: true, transform: {
+      export: ->(value) { value.map(&:upcase) },
+      import: ->(value) { value.map { |v| "#{v}-1" } },
+    }
+  end
+
+  # Class with only mapping-level transformations
+  class MappingTransformPerson < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :email, :string
+    attribute :tags, :string, collection: true
+
+    json do
+      map "fullName", to: :name, transform: {
+        export: ->(value) { "Dr. #{value}" },
       }
-      attribute :email, :string, transform: {
-        import: ->(value) { "#{value}@example.com" },
+      map "emailAddress", to: :email, transform: {
+        import: ->(value) { value.gsub("at", "@") },
       }
-      attribute :tags, :string, collection: true, transform: {
-        export: ->(value) { value.map(&:upcase) },
-        import: ->(value) { value.map { |v| "#{v}-1" } },
+      map "labels", to: :tags, transform: {
+        export: ->(value) { value.join("-|-") },
+        import: ->(value) { value.split("|") },
       }
     end
 
-    # Class with only mapping-level transformations
-    class MappingTransformPerson < Lutaml::Model::Serializable
-      attribute :name, :string
-      attribute :email, :string
-      attribute :tags, :string, collection: true
-
-      json do
-        map "fullName", to: :name, transform: {
-          export: ->(value) { "Dr. #{value}" },
-        }
-        map "emailAddress", to: :email, transform: {
-          import: ->(value) { value.gsub("at", "@") },
-        }
-        map "labels", to: :tags, transform: {
-          export: ->(value) { value.join("-|-") },
-          import: ->(value) { value.split("|") },
-        }
-      end
-
-      xml do
-        root "person"
-        map_element "full-name", to: :name, transform: {
-          export: ->(value) { "Dr. #{value}" },
-        }
-        map_element "email-address", to: :email, transform: {
-          import: ->(value) { value.gsub("at", "@") },
-        }
-        map_element "labels", to: :tags, transform: {
-          export: ->(value) { value.join("-|-") },
-          import: ->(value) { value.split("|") },
-        }
-      end
-    end
-
-    # Class with both attribute and mapping transformations
-    class CombinedTransformPerson < Lutaml::Model::Serializable
-      attribute :name, :string, transform: {
-        export: ->(value) { value.to_s.capitalize },
-        import: ->(value) { value.to_s.downcase },
+    xml do
+      root "person"
+      map_element "full-name", to: :name, transform: {
+        export: ->(value) { "Dr. #{value}" },
       }
-      attribute :email, :string, transform: {
-        export: lambda(&:downcase),
-        import: lambda(&:downcase),
+      map_element "email-address", to: :email, transform: {
+        import: ->(value) { value.gsub("at", "@") },
+      }
+      map_element "labels", to: :tags, transform: {
+        export: ->(value) { value.join("-|-") },
+        import: ->(value) { value.split("|") },
+      }
+    end
+  end
+
+  # Class with both attribute and mapping transformations
+  class CombinedTransformPerson < Lutaml::Model::Serializable
+    attribute :name, :string, transform: {
+      export: ->(value) { value.to_s.capitalize },
+      import: ->(value) { value.to_s.downcase },
+    }
+    attribute :email, :string, transform: {
+      export: lambda(&:downcase),
+      import: lambda(&:downcase),
+    }
+    attribute :tags, :string, collection: true, transform: {
+      export: ->(value) { value.map(&:upcase) },
+      import: ->(value) { value.map { |v| "#{v}-1" } },
+    }
+
+    json do
+      map "fullName", to: :name, transform: {
+        export: ->(value) { "Prof. #{value}" },
+        import: ->(value) { value.gsub("Prof. ", "") },
       }
-      attribute :tags, :string, collection: true, transform: {
-        export: ->(value) { value.map(&:upcase) },
-        import: ->(value) { value.map { |v| "#{v}-1" } },
+      map "contactEmail", to: :email, transform: {
+        export: ->(value) { "contact+#{value}" },
+        import: ->(value) { value.gsub("contact+", "") },
       }
+      map "skills", to: :tags
+    end
 
-      json do
-        map "fullName", to: :name, transform: {
-          export: ->(value) { "Prof. #{value}" },
-          import: ->(value) { value.gsub("Prof. ", "") },
-        }
-        map "contactEmail", to: :email, transform: {
-          export: ->(value) { "contact+#{value}" },
-          import: ->(value) { value.gsub("contact+", "") },
-        }
-        map "skills", to: :tags
-      end
-
-      xml do
-        root "person"
-        map_element "full-name", to: :name, transform: {
-          export: ->(value) { "Prof. #{value}" },
-          import: ->(value) { value.gsub("Prof. ", "") },
-        }
-        map_element "contact-email", to: :email, transform: {
-          export: ->(value) { "contact+#{value}" },
-          import: ->(value) { value.gsub("contact+", "") },
-        }
-        map_element "skills", to: :tags
-      end
+    xml do
+      root "person"
+      map_element "full-name", to: :name, transform: {
+        export: ->(value) { "Prof. #{value}" },
+        import: ->(value) { value.gsub("Prof. ", "") },
+      }
+      map_element "contact-email", to: :email, transform: {
+        export: ->(value) { "contact+#{value}" },
+        import: ->(value) { value.gsub("contact+", "") },
+      }
+      map_element "skills", to: :tags
     end
   end
+end
 
+RSpec.describe "Value Transformations" do
   describe "Attribute-only transformations" do
     let(:attribute_person) do
       TransformationSpec::AttributeTransformPerson.new(

data/spec/lutaml/model/type/boolean_spec.rb

@@ -71,14 +71,14 @@ RSpec.describe Lutaml::Model::Type::Boolean do
   end
 
   context "with key-value serialization" do
-    let(:yaml) do
+    let(:attrs) do
       {
         "name" => "John Smith",
         "full_time" => true,
         "on_leave" => false,
         "remote" => nil,
         "active" => nil,
-      }.to_yaml
+      }
     end
 
     let(:expected_yaml) do
@@ -91,7 +91,7 @@ RSpec.describe Lutaml::Model::Type::Boolean do
     end
 
     it "deserializes boolean values correctly" do
-      employee = BooleanSpec::Employee.from_yaml(yaml)
+      employee = BooleanSpec::Employee.from_yaml(attrs.to_yaml)
 
       expect(employee.name).to eq("John Smith")
       expect(employee.full_time).to be true
@@ -101,13 +101,7 @@ RSpec.describe Lutaml::Model::Type::Boolean do
     end
 
     it "serializes boolean values correctly" do
-      employee = BooleanSpec::Employee.new(
-        name: "John Smith",
-        full_time: true,
-        on_leave: false,
-        remote: nil,
-        active: nil,
-      )
+      employee = BooleanSpec::Employee.new(attrs)
 
       yaml_output = employee.to_yaml
       expect(yaml_output).to eq(expected_yaml)

data/spec/lutaml/model/type/decimal_spec.rb

@@ -112,10 +112,10 @@ RSpec.describe Lutaml::Model::Type do
         hide_const("BigDecimal")
       end
 
+      let(:serialized) { Lutaml::Model::Type::Decimal.serialize("123.45") }
+
       it "raises TypeNotEnabledError" do
-        expect do
-          Lutaml::Model::Type::Decimal.serialize("123.45")
-        end.to raise_error(
+        expect { serialized }.to raise_error(
           Lutaml::Model::TypeNotEnabledError,
           /Decimal/,
         )