lutaml-model 0.8.18 → 0.8.22

data/spec/lutaml/model/custom_from_empty_values_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string: true
+
+require "spec_helper"
+
+# lutaml-model#746: an empty value ("", [], {}) is a PRESENT value per
+# docs/_guides/missing-values-handling.adoc and must reach custom `from`
+# methods. Only nil (non-existent) and an omitted key (undefined) skip them.
+module CustomFromEmptyValuesSpec
+  class Tagged < Lutaml::Model::Serializable
+    attribute :received, :string
+
+    key_value do
+      map "tags", to: :received, with: { to: :tags_to, from: :tags_from }
+    end
+
+    def tags_to(model, doc)
+      doc["tags"] = model.received
+    end
+
+    def tags_from(model, value)
+      model.received = value.inspect
+    end
+  end
+
+  class Mapped < Lutaml::Model::Serializable
+    attribute :received, :string
+
+    key_value do
+      map "fields", to: :received, with: { to: :fields_to, from: :fields_from }
+    end
+
+    def fields_to(model, doc)
+      doc["fields"] = model.received
+    end
+
+    def fields_from(model, value)
+      model.received = value.inspect
+    end
+  end
+end
+
+RSpec.describe "custom from methods and empty values" do
+  it "receives an empty collection" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("tags: []").received)
+      .to eq("[]")
+  end
+
+  it "receives an empty string" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml('tags: ""').received)
+      .to eq("\"\"")
+  end
+
+  it "receives an empty mapping" do
+    expect(CustomFromEmptyValuesSpec::Mapped.from_yaml("fields: {}").received)
+      .to eq("{}")
+  end
+
+  it "receives empty values from JSON too" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_json(%({"tags": []})).received)
+      .to eq("[]")
+    expect(CustomFromEmptyValuesSpec::Tagged.from_json(%({"tags": ""})).received)
+      .to eq("\"\"")
+  end
+
+  it "still skips the method for a nil value" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("tags:").received)
+      .to be_nil
+  end
+
+  it "still skips the method for an omitted key" do
+    expect(CustomFromEmptyValuesSpec::Tagged.from_yaml("{}").received)
+      .to be_nil
+  end
+end

data/spec/lutaml/model/custom_vobject_adapter_spec.rb

@@ -201,8 +201,8 @@ module CustomVobjectAdapterSpec
       @objects
     end
 
-    def map(&)
-      @objects.map(&)
+    def map(&block)
+      @objects.map(&block)
     end
 
     private
@@ -260,16 +260,16 @@ module CustomVobjectAdapterSpec
       @element_type = element_type
     end
 
-    def map_value(to:, **)
-      add_mapping(:value, to, type: :simple, **)
+    def map_value(to:, **options)
+      add_mapping(:value, to, type: :simple, **options)
     end
 
-    def map_property(name, to:, type: :simple, **)
-      add_mapping(name.downcase, to, type: type, **)
+    def map_property(name, to:, type: :simple, **options)
+      add_mapping(name.downcase, to, type: type, **options)
     end
 
-    def map_component(name, to:, **)
-      add_mapping(name.downcase, to, type: :component, **)
+    def map_component(name, to:, **options)
+      add_mapping(name.downcase, to, type: :component, **options)
     end
 
     def map_field_set(count:, item_type:, item_options: {})

data/spec/lutaml/model/defaults_spec.rb

@@ -146,6 +146,33 @@ module DefaultsSpec
 
   class InstanceAwareGrandChild < InstanceAwareChild
   end
+
+  # Class-method defaults must keep resolving as they did before 0.8.0
+  # (lutaml-model#745): default lambdas are evaluated against the instance,
+  # with the model class as fallback for methods the instance does not have.
+  class ClassMethodDefault < Lutaml::Model::Serializable
+    attribute :os, :string, default: -> { detect_os }
+
+    def self.detect_os
+      "from-class-method"
+    end
+  end
+
+  class ClassMethodDefaultWithArgs < Lutaml::Model::Serializable
+    attribute :label, :string, default: -> { build_label("x") }
+
+    def self.build_label(prefix)
+      "#{prefix}-label"
+    end
+  end
+
+  class InstanceMethodDefault < Lutaml::Model::Serializable
+    attribute :value, :string, default: -> { instance_helper }
+
+    def instance_helper
+      "from-instance-method"
+    end
+  end
 end
 
 RSpec.describe DefaultsSpec::Glaze do
@@ -346,3 +373,21 @@ RSpec.describe DefaultsSpec::Glaze do
     end
   end
 end
+
+RSpec.describe DefaultsSpec::ClassMethodDefault do
+  it "resolves class methods from default lambdas" do
+    expect(described_class.new.os).to eq("from-class-method")
+  end
+end
+
+RSpec.describe DefaultsSpec::ClassMethodDefaultWithArgs do
+  it "passes arguments through to class methods" do
+    expect(described_class.new.label).to eq("x-label")
+  end
+end
+
+RSpec.describe DefaultsSpec::InstanceMethodDefault do
+  it "still resolves instance methods in default lambdas" do
+    expect(described_class.new.value).to eq("from-instance-method")
+  end
+end

data/spec/lutaml/model/json_spec.rb

@@ -8,9 +8,8 @@ RSpec.describe Lutaml::Model::Json do
     let(:lib_path) { File.expand_path("../../../lib", __dir__) }
 
     it "loads require 'lutaml/json' without preloading lutaml/model" do
-      # rubocop:disable Style/CommandLiteral
+      # rubocop:disable-next Style/CommandLiteral
       result = `#{RbConfig.ruby} -I#{lib_path} -e 'require "lutaml/json"; puts :ok' 2>&1`
-      # rubocop:enable Style/CommandLiteral
 
       expect($?.success?).to be(true), result
       expect(result).to include("ok")

data/spec/lutaml/model/ordered_content_spec.rb

@@ -148,7 +148,9 @@ RSpec.describe "OrderedContent" do
 
     # Regression for issue #735: `ordered` builder must honour setter
     # call order, not declaration order. The @__order_tracking__ flag
-    # was gated on mixed_content? instead of ordered?.
+    # was gated on mixed_content? instead of ordered?. Comprehensive
+    # coverage of the setter/appender equivalence lives in
+    # spec/lutaml/model/serialize/builder_spec.rb.
     context "ordered builder honours setter call order" do
       it "emits elements in builder-call order, not declaration order" do
         klass = Class.new(Lutaml::Model::Serializable) do
@@ -163,16 +165,25 @@ RSpec.describe "OrderedContent" do
           end
         end
 
-        item = klass.new do |i|
+        # Both the appender syntax and the direct setter syntax MUST
+        # honour call order and MUST NOT silently drop the other.
+        item_appender = klass.new do |i|
           i.b "first"
           i.a "second"
         end
 
-        xml = item.to_xml
-        b_pos = xml.index("<b>first</b>")
-        a_pos = xml.index("<a>second</a>")
-        expect(b_pos).to be < a_pos
-        expect(item.element_order.map(&:name)).to eq(%w[b a])
+        item_setter = klass.new do |i|
+          i.b = "first"
+          i.a = "second"
+        end
+
+        [item_appender, item_setter].each do |item|
+          xml = item.to_xml
+          b_pos = xml.index("<b>first</b>")
+          a_pos = xml.index("<a>second</a>")
+          expect(b_pos).to be < a_pos
+          expect(item.element_order.map(&:name)).to eq(%w[b a])
+        end
       end
     end
   end

data/spec/lutaml/model/serialize/builder_spec.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "../../../../lib/lutaml/model"
+require "lutaml/xml/adapter/nokogiri_adapter"
+
+# Specs for Lutaml::Model::Serialize::Builder — the module that gives
+# Serializable the `Klass.new do |x| ... end` block syntax.
+#
+# These specs exist because of a regression where direct setters
+# (`x.attr = v`) inside the builder block silently dropped attributes
+# from serialized output while appender calls (`x.attr(v)`) worked.
+# The root cause was that only getter-with-arg paths called track_order;
+# generated setters did not. The fix centralises mutation recording via
+# Builder#record_mutation / record_mutation_collection, and the
+# serializer's apply_remaining_rules acts as a safety net so element
+# values are never silently dropped.
+#
+# These specs cover the invariant ("no silent data loss"), call-order
+# preservation, round-trip parity, equivalence between .tap and block,
+# the no-op guarantee for non-ordered models, and the wholesale
+# collection assignment case.
+RSpec.describe "Lutaml::Model::Serialize::Builder" do
+  let(:ordered_klass) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :singular, :string
+      attribute :items, :string, collection: true
+
+      xml do
+        element "container"
+        ordered
+        map_element "singular", to: :singular
+        map_element "items", to: :items
+      end
+    end
+  end
+
+  let(:mixed_klass) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :singular, :string
+      attribute :items, :string, collection: true
+
+      xml do
+        element "container"
+        mixed_content
+        map_element "singular", to: :singular
+        map_element "items", to: :items
+      end
+    end
+  end
+
+  let(:plain_klass) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :singular, :string
+      attribute :items, :string, collection: true
+
+      xml do
+        element "container"
+        map_element "singular", to: :singular
+        map_element "items", to: :items
+      end
+    end
+  end
+
+  shared_examples "no silent data loss across mutation styles" do
+    it "appender-only: emits every call in order" do
+      obj = ordered_klass.new do |x|
+        x.singular "first"
+        x.items "a"
+        x.items "b"
+      end
+
+      xml = obj.to_xml
+      expect(xml).to be_xml_equivalent_to(<<~XML)
+        <container>
+          <singular>first</singular>
+          <items>a</items>
+          <items>b</items>
+        </container>
+      XML
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items items])
+    end
+
+    it "direct setter for singular: still emits the element" do
+      obj = ordered_klass.new do |x|
+        x.singular = "first"
+        x.items "a"
+      end
+
+      xml = obj.to_xml
+      expect(xml).to be_xml_equivalent_to(<<~XML)
+        <container>
+          <singular>first</singular>
+          <items>a</items>
+        </container>
+      XML
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items])
+    end
+
+    it "wholesale collection assignment: emits one element per item" do
+      obj = ordered_klass.new do |x|
+        x.singular "first"
+        x.items = %w[a b c]
+      end
+
+      xml = obj.to_xml
+      expect(xml).to be_xml_equivalent_to(<<~XML)
+        <container>
+          <singular>first</singular>
+          <items>a</items>
+          <items>b</items>
+          <items>c</items>
+        </container>
+      XML
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items items
+                                                     items])
+    end
+
+    it "all direct setters: emits in call order" do
+      obj = ordered_klass.new do |x|
+        x.singular = "first"
+        x.items = %w[a b]
+      end
+
+      xml = obj.to_xml
+      expect(xml).to be_xml_equivalent_to(<<~XML)
+        <container>
+          <singular>first</singular>
+          <items>a</items>
+          <items>b</items>
+        </container>
+      XML
+    end
+
+    it "mixed style preserves call order across setters and appenders" do
+      obj = ordered_klass.new do |x|
+        x.items "a"
+        x.singular = "middle"
+        x.items "b"
+      end
+
+      xml = obj.to_xml
+      expect(xml).to be_xml_equivalent_to(<<~XML)
+        <container>
+          <items>a</items>
+          <singular>middle</singular>
+          <items>b</items>
+        </container>
+      XML
+    end
+  end
+
+  describe "no silent data loss" do
+    it_behaves_like "no silent data loss across mutation styles"
+
+    it "mixed_content model emits setter-only attributes too" do
+      obj = mixed_klass.new do |x|
+        x.singular = "first"
+        x.items "a"
+      end
+
+      xml = obj.to_xml
+      expect(xml).to include("<singular>first</singular>")
+      expect(xml).to include("<items>a</items>")
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items])
+    end
+  end
+
+  describe "call order preservation" do
+    it "reverse declaration order is honoured via direct setters" do
+      obj = ordered_klass.new do |x|
+        x.items = %w[a b]
+        x.singular = "last"
+      end
+
+      xml = obj.to_xml
+      items_pos = xml.index("<items>")
+      singular_pos = xml.index("<singular>")
+      expect(items_pos).to be < singular_pos
+      expect(obj.element_order.map(&:name)).to eq(%w[items items singular])
+    end
+
+    it "reverse declaration order is honoured via appenders" do
+      obj = ordered_klass.new do |x|
+        x.items "a"
+        x.singular "last"
+      end
+
+      xml = obj.to_xml
+      items_pos = xml.index("<items>")
+      singular_pos = xml.index("<singular>")
+      expect(items_pos).to be < singular_pos
+      expect(obj.element_order.map(&:name)).to eq(%w[items singular])
+    end
+  end
+
+  describe "round-trip parity" do
+    it "ordered: parses and re-emits equivalent XML" do
+      original = <<~XML
+        <container>
+          <items>a</items>
+          <singular>middle</singular>
+          <items>b</items>
+        </container>
+      XML
+
+      parsed = ordered_klass.from_xml(original)
+      expect(parsed.to_xml).to be_xml_equivalent_to(original)
+    end
+
+    it "mixed_content: parses and re-emits equivalent XML" do
+      original = <<~XML
+        <container>before <items>a</items> mid <singular>x</singular> end</container>
+      XML
+
+      parsed = mixed_klass.from_xml(original)
+      roundtrip = parsed.to_xml
+      expect(roundtrip).to include("<items>a</items>")
+      expect(roundtrip).to include("<singular>x</singular>")
+    end
+  end
+
+  describe ".tap vs builder block equivalence" do
+    it "produces identical element_order presence and XML shape" do
+      via_tap = ordered_klass.new.tap do |x|
+        x.singular = "first"
+        x.items = %w[a b]
+      end
+
+      via_block = ordered_klass.new do |x|
+        x.singular = "first"
+        x.items = %w[a b]
+      end
+
+      # .tap path does not enable tracking; both must still emit the same XML.
+      expect(via_tap.element_order).to be_nil
+      expect(via_block.element_order).not_to be_nil
+      expect(via_tap.to_xml).to be_xml_equivalent_to(via_block.to_xml)
+    end
+  end
+
+  describe "setter return value contract" do
+    # Ruby's setter contract: `obj.foo = v` evaluates to `v`. Callers
+    # like `obj.foo || (obj.foo = [])` depend on this. Generated
+    # setters must continue to honour this contract regardless of
+    # whether order tracking is enabled.
+    it "singular setter returns the assigned value" do
+      obj = plain_klass.new
+      expect((obj.singular = "v")).to eq("v")
+    end
+
+    it "collection setter returns the assigned value" do
+      obj = plain_klass.new
+      expect((obj.items = %w[a b])).to eq(%w[a b])
+    end
+
+    it "supports the `obj.foo || (obj.foo = [])` pattern from downstream consumers" do
+      obj = plain_klass.new
+      # Mirror Docbook::Elements::Para#try_add_inline, which relies on
+      # the setter returning the array (not nil) when the getter is nil.
+      # The bug: when the setter returned nil (because record_mutation
+      # returned nil with tracking disabled), `collection` was nil and
+      # `collection << element` failed with NoMethodError.
+      collection = obj.items || (obj.items = [])
+      expect(collection).to eq([])
+      expect { collection << "x" }.not_to raise_error
+    end
+  end
+
+  describe "no-op guarantee when not tracking" do
+    it "plain (non-ordered) models do not allocate element_order entries" do
+      obj = plain_klass.new do |x|
+        x.singular = "first"
+        x.items "a"
+      end
+
+      expect(obj.element_order).to be_nil
+      expect { obj.to_xml }.not_to raise_error
+    end
+
+    it "ordered models constructed without a block do not track" do
+      obj = ordered_klass.new
+      obj.singular = "first"
+      obj.items = %w[a b]
+
+      expect(obj.element_order).to be_nil
+      expect(obj.to_xml).to include("<singular>first</singular>")
+    end
+  end
+
+  describe "wholesale collection reassignment" do
+    it "tracks one entry per item across multiple assignments" do
+      obj = ordered_klass.new do |x|
+        x.items = %w[a b]
+        x.items = %w[c d e]
+      end
+
+      # element_order is a log of mutations, not a reflection of final state,
+      # so both assignments are recorded. The serializer emits the current
+      # value of the attribute via element_order in recorded order; the
+      # safety net guarantees no data loss.
+      expect(obj.element_order.map(&:name)).to eq(%w[items items items items
+                                                     items])
+      xml = obj.to_xml
+      # The serialized output must contain all current items
+      expect(xml).to include("<items>c</items>")
+      expect(xml).to include("<items>d</items>")
+      expect(xml).to include("<items>e</items>")
+    end
+  end
+
+  describe "no-silent-drop invariant (cross-cutting)" do
+    # The bug class: any attribute with a non-default value MUST appear in
+    # the serialized output, regardless of how it was set. This spec is the
+    # regression guard for the whole class of bug, not just one instance.
+    shared_examples "no silent drop" do |description, mutation_block|
+      it "does not silently drop any attribute set via: #{description}" do
+        obj = ordered_klass.new(&mutation_block)
+        xml = obj.to_xml
+
+        if !obj.singular.nil? && !obj.singular.to_s.empty?
+          expect(xml).to include("<singular>"),
+                         "singular was dropped from output"
+        end
+        return if obj.items.nil? || obj.items.empty?
+
+        obj.items.each do |item|
+          expect(xml).to include("<items>#{item}</items>"),
+                         "items element for #{item.inspect} was dropped from output"
+        end
+      end
+    end
+
+    it_behaves_like "no silent drop",
+                    "singular setter + wholesale items setter",
+                    lambda { |x|
+                      x.singular = "v"
+                      x.items = %w[a b]
+                    }
+    it_behaves_like "no silent drop",
+                    "all appenders",
+                    lambda { |x|
+                      x.singular "v"
+                      x.items "a"
+                      x.items "b"
+                    }
+    it_behaves_like "no silent drop",
+                    "singular setter + items appender (the original bug)",
+                    lambda { |x|
+                      x.singular = "v"
+                      x.items "a"
+                      x.items "b"
+                    }
+    it_behaves_like "no silent drop",
+                    "singular appender + wholesale items setter",
+                    lambda { |x|
+                      x.singular "v"
+                      x.items = %w[a b]
+                    }
+  end
+end

data/spec/lutaml/model/store_spec.rb

@@ -43,7 +43,9 @@ RSpec.describe Lutaml::Model::Store do
 
   describe "indexed lookup" do
     it "builds index lazily on first resolve" do
-      5.times { |i| model_class.new(id: "obj-#{i}") }
+      # Hold strong references: Store keeps WeakRefs, so unreferenced
+      # objects can be collected before resolve runs.
+      _objects = Array.new(5) { |i| model_class.new(id: "obj-#{i}") }
 
       result = described_class.resolve(model_class, :id, "obj-3")
       expect(result.id).to eq("obj-3")

data/spec/lutaml/model/transform_apply_value_map_spec.rb

@@ -33,7 +33,8 @@ RSpec.describe Lutaml::Model::Transform, "#apply_value_map (nil attr)" do
     end
 
     it "passes initialized values through unchanged" do
-      expect(transform.apply_value_map("hello", default_vmap, nil)).to eq("hello")
+      expect(transform.apply_value_map("hello", default_vmap,
+                                       nil)).to eq("hello")
     end
   end
 
@@ -50,11 +51,13 @@ RSpec.describe Lutaml::Model::Transform, "#apply_value_map (nil attr)" do
   # custom method runs), and resolved :nil/:empty consistently for empty inputs.
   describe "non-:nil options with nil attr" do
     it "maps a nil value to uninitialized via nil: :omitted" do
-      expect(transform.apply_value_map(nil, { nil: :omitted }, nil)).to eq(uninit)
+      expect(transform.apply_value_map(nil, { nil: :omitted },
+                                       nil)).to eq(uninit)
     end
 
     it "maps an empty value to uninitialized via empty: :omitted" do
-      expect(transform.apply_value_map("", { empty: :omitted }, nil)).to eq(uninit)
+      expect(transform.apply_value_map("", { empty: :omitted },
+                                       nil)).to eq(uninit)
     end
 
     it "maps an empty value to nil via empty: :nil" do

data/spec/lutaml/model/union_attribute_spec.rb

@@ -311,7 +311,8 @@ RSpec.describe "Union-typed attributes (issue #190)" do
     it "serializes a model member built in plain Ruby identically to a deserialized one" do
       built = UnionAttributeSpec::Ceramic.new(
         firing_temperature:
-          UnionAttributeSpec::TemperatureWithUnit.new(number: 1300.0, unit: "C"),
+          UnionAttributeSpec::TemperatureWithUnit.new(number: 1300.0,
+                                                      unit: "C"),
       )
       round = UnionAttributeSpec::Ceramic.from_yaml(built.to_yaml)
       expect(round.firing_temperature)
@@ -424,7 +425,8 @@ RSpec.describe "Union-typed attributes (issue #190)" do
     end
 
     it "rejects unsupported scalar member types at definition time" do
-      %i[hash symbol time time_without_date date date_time].each do |unsupported|
+      %i[hash symbol time time_without_date date
+         date_time].each do |unsupported|
         expect do
           Class.new(Lutaml::Model::Serializable) do
             attribute :bad, [unsupported, :string]