lutaml-model 0.3.24 → 0.3.25

data/spec/lutaml/model/toml_adapter_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+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)
+    end
+  end
+
+  it "serializes to TOML" do
+    toml = adapter_class.new(attributes).to_toml
+
+    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)
+
+    expect(new_model.name).to eq("John Doe")
+    expect(new_model.age).to eq(30)
+  end
+end
+
+RSpec.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
+end

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

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Type::Boolean do
+  describe ".cast" do
+    let(:truthy_values) { [true, "true", "t", "yes", "y", "1"] }
+    let(:falsey_values) { [false, "false", "f", "no", "n", "0"] }
+
+    it "returns nil for nil input" do
+      expect(described_class.cast(nil)).to be_nil
+    end
+
+    context "with truthy values" do
+      it "casts to true" do
+        truthy_values.each do |value|
+          expect(described_class.cast(value)).to be true
+        end
+      end
+    end
+
+    context "with falsey values" do
+      it "casts to false" do
+        falsey_values.each do |value|
+          expect(described_class.cast(value)).to be false
+        end
+      end
+    end
+
+    context "with other values" do
+      it "returns the original value" do
+        value = "other"
+        expect(described_class.cast(value)).to eq value
+      end
+    end
+  end
+
+  describe ".serialize" do
+    it "returns nil for nil input" do
+      expect(described_class.serialize(nil)).to be_nil
+    end
+
+    it "returns true for truthy input" do
+      expect(described_class.serialize(true)).to be true
+    end
+
+    it "returns false for falsey input" do
+      expect(described_class.serialize(false)).to be false
+    end
+
+    it "preserves input boolean values" do
+      expect(described_class.serialize(false)).to be false
+      expect(described_class.serialize(true)).to be true
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Type::Date do
+  describe ".cast" do
+    subject(:cast) { described_class.cast(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with valid Date string" do
+      let(:value) { "2024-01-01" }
+
+      it { is_expected.to eq(Date.new(2024, 1, 1)) }
+    end
+
+    context "with Date object" do
+      let(:value) { Date.new(2024, 1, 1) }
+
+      it { is_expected.to eq(value) }
+    end
+
+    context "with DateTime object" do
+      let(:value) { DateTime.new(2024, 1, 1, 12, 0, 0) }
+
+      it { is_expected.to eq(Date.new(2024, 1, 1)) }
+    end
+
+    context "with Time object" do
+      let(:value) { Time.new(2024, 1, 1, 12, 0, 0) }
+
+      it { is_expected.to eq(Date.new(2024, 1, 1)) }
+    end
+
+    context "with invalid date string" do
+      let(:value) { "not a date" }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with invalid month" do
+      let(:value) { "2024-13-01" }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with invalid day" do
+      let(:value) { "2024-04-31" }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with different date formats" do
+      it "parses ISO 8601" do
+        expect(described_class.cast("2024-01-01")).to eq(Date.new(2024, 1, 1))
+      end
+
+      it "parses RFC 3339" do
+        expect(described_class.cast("2024-01-01T12:00:00Z")).to eq(Date.new(
+                                                                     2024, 1, 1
+                                                                   ))
+      end
+
+      it "parses common formats" do
+        expect(described_class.cast("01/01/2024")).to eq(Date.new(2024, 1, 1))
+        expect(described_class.cast("Jan 1, 2024")).to eq(Date.new(2024, 1, 1))
+      end
+    end
+
+    context "with leap year dates" do
+      it "handles February 29 in leap years" do
+        expect(described_class.cast("2024-02-29")).to eq(Date.new(2024, 2, 29))
+      end
+
+      it "rejects February 29 in non-leap years" do
+        expect(described_class.cast("2023-02-29")).to be_nil
+      end
+    end
+  end
+
+  describe ".serialize" do
+    subject(:serialize) { described_class.serialize(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with Date object" do
+      let(:value) { Date.new(2024, 1, 1) }
+
+      it { is_expected.to eq("2024-01-01") }
+    end
+
+    context "with single-digit month and day" do
+      let(:value) { Date.new(2024, 1, 1) }
+
+      it "zero-pads month and day" do
+        expect(serialize).to eq("2024-01-01")
+      end
+    end
+
+    context "with double-digit month and day" do
+      let(:value) { Date.new(2024, 12, 31) }
+
+      it { is_expected.to eq("2024-12-31") }
+    end
+
+    context "with leap year date" do
+      let(:value) { Date.new(2024, 2, 29) }
+
+      it { is_expected.to eq("2024-02-29") }
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Type::DateTime do
+  describe ".cast" do
+    subject(:cast) { described_class.cast(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with valid DateTime string" do
+      let(:value) { "2024-01-01T12:00:00Z" }
+
+      it "parses with UTC offset" do
+        expect(cast.offset).to eq(0)
+        expect(cast.zone).to eq("+00:00")
+      end
+    end
+
+    context "with positive timezone offset" do
+      let(:value) { "2024-01-01T12:00:00+08:00" }
+
+      it "retains the positive offset" do
+        expect(cast.offset).to eq(Rational(8, 24))
+        expect(cast.zone).to eq("+08:00")
+      end
+    end
+
+    context "with negative timezone offset" do
+      let(:value) { "2024-01-01T12:00:00-05:00" }
+
+      it "retains the negative offset" do
+        expect(cast.offset).to eq(Rational(-5, 24))
+        expect(cast.zone).to eq("-05:00")
+      end
+    end
+
+    context "with fractional offset" do
+      let(:value) { "2024-01-01T12:00:00+05:30" }
+
+      it "retains the fractional offset" do
+        expect(cast.offset).to eq(Rational(5.5, 24))
+        expect(cast.zone).to eq("+05:30")
+      end
+    end
+
+    context "with Time object with offset" do
+      let(:value) { Time.new(2024, 1, 1, 12, 0, 0, "+08:00") }
+
+      it "preserves the offset from Time object" do
+        expect(cast.offset).to eq(Rational(8, 24))
+        expect(cast.zone).to eq("+08:00")
+      end
+    end
+
+    context "with DateTime object with offset" do
+      let(:value) { DateTime.new(2024, 1, 1, 12, 0, 0, "+08:00") }
+
+      it "preserves the offset from DateTime object" do
+        expect(cast.offset).to eq(Rational(8, 24))
+        expect(cast.zone).to eq("+08:00")
+      end
+    end
+  end
+
+  describe ".serialize" do
+    subject(:serialize) { described_class.serialize(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with UTC DateTime" do
+      let(:value) { DateTime.new(2024, 1, 1, 12, 0, 0) }
+
+      it "serializes with +00:00 offset" do
+        expect(serialize).to eq("2024-01-01T12:00:00+00:00")
+      end
+    end
+
+    context "with positive offset" do
+      let(:value) { DateTime.new(2024, 1, 1, 12, 0, 0, "+08:00") }
+
+      it "retains positive offset in serialized form" do
+        expect(serialize).to eq("2024-01-01T12:00:00+08:00")
+      end
+    end
+
+    context "with negative offset" do
+      let(:value) { DateTime.new(2024, 1, 1, 12, 0, 0, "-05:00") }
+
+      it "retains negative offset in serialized form" do
+        expect(serialize).to eq("2024-01-01T12:00:00-05:00")
+      end
+    end
+
+    context "with fractional offset" do
+      let(:value) { DateTime.new(2024, 1, 1, 12, 0, 0, "+05:30") }
+
+      it "retains fractional offset in serialized form" do
+        expect(serialize).to eq("2024-01-01T12:00:00+05:30")
+      end
+    end
+
+    context "with fractional seconds" do
+      let(:value) { DateTime.new(2024, 1, 1, 12, 0, 0.5, "+08:00") }
+
+      xit "retains both fractional seconds and offset" do
+        expect(serialize).to eq("2024-01-01T12:00:00.500+08:00")
+      end
+    end
+
+    context "with microsecond precision" do
+      let(:value) do
+        DateTime.new(2024, 1, 1, 12, 0, Rational(123456, 1000000), "+08:00")
+      end
+
+      xit "retains microsecond precision and offset" do
+        expect(serialize).to eq("2024-01-01T12:00:00.123456+08:00")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+require "spec_helper"
+require "bigdecimal"
+
+RSpec.describe Lutaml::Model::Type do
+  describe "Decimal type" do
+    let(:decimal_class) { Lutaml::Model::Type::Decimal }
+
+    context "when bigdecimal is loaded" do
+      before do
+        # Ensure BigDecimal is loaded
+        require "bigdecimal"
+      end
+
+      it "serializes into Lutaml::Model::Type::Decimal" do
+        value = BigDecimal("123.45")
+        serialized = decimal_class.serialize(value)
+        expect(serialized).to eq("123.45")
+      end
+
+      it "deserializes into Ruby BigDecimal" do
+        value = "123.45"
+        deserialized = decimal_class.cast(value)
+        expect(deserialized).to be_a(BigDecimal)
+        expect(deserialized).to eq(BigDecimal("123.45"))
+      end
+    end
+
+    context "when bigdecimal is not loaded" do
+      before do
+        hide_const("BigDecimal")
+      end
+
+      it "raises TypeNotEnabledError when serializing" do
+        expect do
+          decimal_class.serialize(123.45)
+        end.to raise_error(Lutaml::Model::TypeNotEnabledError, /Decimal/)
+      end
+
+      it "raises TypeNotEnabledError when deserializing" do
+        expect do
+          decimal_class.cast("123.45")
+        end.to raise_error(Lutaml::Model::TypeNotEnabledError, /Decimal/)
+      end
+    end
+  end
+
+  describe ".cast" do
+    context "with BigDecimal available" do
+      before do
+        # Ensure BigDecimal is loaded
+        require "bigdecimal"
+      end
+
+      let(:decimal_class) { Lutaml::Model::Type::Decimal }
+
+      it "returns nil for nil input" do
+        expect(decimal_class.cast(nil)).to be_nil
+      end
+
+      it "casts numeric string to BigDecimal" do
+        expect(decimal_class.cast("123.45")).to eq BigDecimal("123.45")
+      end
+
+      it "casts integer to BigDecimal" do
+        expect(decimal_class.cast(123)).to eq BigDecimal("123")
+      end
+
+      it "casts float to BigDecimal" do
+        expect(decimal_class.cast(123.45)).to eq BigDecimal("123.45")
+      end
+
+      it "casts BigDecimal to BigDecimal" do
+        value = BigDecimal("123.45")
+        expect(decimal_class.cast(value)).to eq value
+      end
+    end
+
+    context "with BigDecimal not available", :skip_before do
+      before do
+        hide_const("BigDecimal")
+      end
+
+      it "raises TypeNotEnabledError" do
+        expect { Lutaml::Model::Type::Decimal.cast("123.45") }.to raise_error(
+          Lutaml::Model::TypeNotEnabledError,
+          /Decimal/,
+        )
+      end
+    end
+  end
+
+  describe ".serialize" do
+    context "with BigDecimal available" do
+      let(:decimal_class) { Lutaml::Model::Type::Decimal }
+
+      before do
+        # Ensure BigDecimal is loaded
+        require "bigdecimal"
+      end
+
+      it "returns nil for nil input" do
+        expect(decimal_class.serialize(nil)).to be_nil
+      end
+
+      it "serializes BigDecimal to string" do
+        expect(decimal_class.serialize(BigDecimal("123.45"))).to eq "123.45"
+      end
+    end
+
+    context "with BigDecimal not available", :skip_before do
+      before do
+        hide_const("BigDecimal")
+      end
+
+      it "raises TypeNotEnabledError" do
+        expect do
+          Lutaml::Model::Type::Decimal.serialize("123.45")
+        end.to raise_error(
+          Lutaml::Model::TypeNotEnabledError,
+          /Decimal/,
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Type::Float do
+  describe ".cast" do
+    subject(:cast) { described_class.cast(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with float" do
+      let(:value) { 123.45 }
+
+      it { is_expected.to eq(123.45) }
+    end
+
+    context "with integer" do
+      let(:value) { 123 }
+
+      it { is_expected.to eq(123.0) }
+    end
+
+    context "with float string" do
+      let(:value) { "123.45" }
+
+      it { is_expected.to eq(123.45) }
+    end
+
+    context "with integer string" do
+      let(:value) { "123" }
+
+      it { is_expected.to eq(123.0) }
+    end
+
+    context "with negative float" do
+      let(:value) { -123.45 }
+
+      it { is_expected.to eq(-123.45) }
+    end
+
+    context "with negative float string" do
+      let(:value) { "-123.45" }
+
+      it { is_expected.to eq(-123.45) }
+    end
+
+    context "with exponential notation" do
+      let(:value) { "1.2345e2" }
+
+      it { is_expected.to eq(123.45) }
+    end
+
+    context "with negative exponential notation" do
+      let(:value) { "-1.2345e2" }
+
+      it { is_expected.to eq(-123.45) }
+    end
+
+    context "with very small exponential notation" do
+      let(:value) { "1.2345e-2" }
+
+      it { is_expected.to eq(0.012345) }
+    end
+
+    context "with string containing leading zeros" do
+      let(:value) { "000123.45" }
+
+      it { is_expected.to eq(123.45) }
+    end
+
+    context "with trailing zeros" do
+      let(:value) { "123.4500" }
+
+      it { is_expected.to eq(123.45) }
+    end
+
+    context "with plus sign" do
+      let(:value) { "+123.45" }
+
+      it { is_expected.to eq(123.45) }
+    end
+
+    context "with whitespace" do
+      let(:value) { " 123.45 " }
+
+      it { is_expected.to eq(123.45) }
+    end
+
+    context "with invalid string" do
+      let(:value) { "not a float" }
+
+      it { is_expected.to eq(0.0) }
+    end
+
+    context "with special float values" do
+      it "handles infinity" do
+        expect(described_class.cast(Float::INFINITY)).to eq(Float::INFINITY)
+        expect(described_class.cast(-Float::INFINITY)).to eq(-Float::INFINITY)
+      end
+
+      it "handles NaN" do
+        expect(described_class.cast(Float::NAN)).to be_nan
+      end
+    end
+
+    context "with very large numbers" do
+      let(:value) { "1.23456789e100" }
+
+      it { is_expected.to eq(1.23456789e100) }
+    end
+
+    context "with very small numbers" do
+      let(:value) { "1.23456789e-100" }
+
+      it { is_expected.to eq(1.23456789e-100) }
+    end
+
+    context "with precision edge cases" do
+      it "handles floating point precision" do
+        expect(described_class.cast(0.1 + 0.2)).to be_within(0.0000001).of(0.3)
+      end
+    end
+  end
+
+  describe ".serialize" do
+    subject(:serialize) { described_class.serialize(value) }
+
+    context "with nil value" do
+      let(:value) { nil }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "with positive float" do
+      let(:value) { 123.45 }
+
+      it { is_expected.to eq(123.45) }
+    end
+
+    context "with negative float" do
+      let(:value) { -123.45 }
+
+      it { is_expected.to eq(-123.45) }
+    end
+
+    context "with zero" do
+      let(:value) { 0.0 }
+
+      it { is_expected.to eq(0.0) }
+    end
+
+    context "with integer-like float" do
+      let(:value) { 123.0 }
+
+      it { is_expected.to eq(123.0) }
+    end
+
+    context "with very small number" do
+      let(:value) { 0.000000123 }
+
+      it { is_expected.to eq(0.000000123) }
+    end
+
+    context "with very large number" do
+      let(:value) { 1.23e100 }
+
+      it { is_expected.to eq(1.23e100) }
+    end
+
+    context "with special float values" do
+      it "serializes infinity" do
+        expect(described_class.serialize(Float::INFINITY)).to eq(Float::INFINITY)
+        expect(described_class.serialize(-Float::INFINITY)).to eq(-Float::INFINITY)
+      end
+
+      it "serializes NaN" do
+        expect(described_class.serialize(Float::NAN)).to be_nan
+      end
+    end
+
+    context "with maximum precision" do
+      let(:value) { 123.456789123456789 }
+
+      it "maintains precision" do
+        expect(serialize).to eq(123.456789123456789)
+      end
+    end
+  end
+end