lutaml-model 0.8.18 → 0.9.1

data/spec/lutaml/model/attribute_apply_value_map_spec.rb

@@ -18,7 +18,8 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
     it "maps nil through value_map[:nil] => :empty to [] (collection)" do
       expect(
-        attribute(:string, collection: true).apply_value_map(nil, { nil: :empty }),
+        attribute(:string, collection: true).apply_value_map(nil,
+                                                             { nil: :empty }),
       ).to eq([])
     end
 
@@ -34,13 +35,15 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
       custom_collection_class = Class.new(Lutaml::Model::Collection) do
         instances :items, member_class
       end
-      attr = described_class.new("items", member_class, collection: custom_collection_class)
+      attr = described_class.new("items", member_class,
+                                 collection: custom_collection_class)
       result = attr.apply_value_map(nil, { nil: :empty })
       expect(result).to be_a(custom_collection_class)
     end
 
     it "maps nil through value_map[:nil] => :omitted to UninitializedClass" do
-      expect(attribute(:string).apply_value_map(nil, { nil: :omitted })).to eq(uninit)
+      expect(attribute(:string).apply_value_map(nil,
+                                                { nil: :omitted })).to eq(uninit)
     end
   end
 
@@ -50,12 +53,14 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
     end
 
     it "maps '' through value_map[:empty] => :empty preserving '' for scalar" do
-      expect(attribute(:string).apply_value_map("", { empty: :empty })).to eq("")
+      expect(attribute(:string).apply_value_map("",
+                                                { empty: :empty })).to eq("")
     end
 
     it "maps [] through value_map[:empty] => :empty preserving [] for collection" do
       expect(
-        attribute(:string, collection: true).apply_value_map([], { empty: :empty }),
+        attribute(:string, collection: true).apply_value_map([],
+                                                             { empty: :empty }),
       ).to eq([])
     end
 
@@ -69,11 +74,13 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
   describe "omitted handling" do
     it "maps UninitializedClass through value_map[:omitted] => :nil" do
-      expect(attribute(:string).apply_value_map(uninit, { omitted: :nil })).to be_nil
+      expect(attribute(:string).apply_value_map(uninit,
+                                                { omitted: :nil })).to be_nil
     end
 
     it "maps UninitializedClass through value_map[:omitted] => :empty" do
-      expect(attribute(:string).apply_value_map(uninit, { omitted: :empty })).to eq("")
+      expect(attribute(:string).apply_value_map(uninit,
+                                                { omitted: :empty })).to eq("")
     end
 
     it "does NOT route UninitializedClass through the :empty branch" do
@@ -81,18 +88,21 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
       # utils.rb:132-137. Ensure dispatch order matches the originals: uninit
       # values go to :omitted, not :empty.
       expect(
-        attribute(:string).apply_value_map(uninit, { empty: :nil, omitted: :empty }),
+        attribute(:string).apply_value_map(uninit,
+                                           { empty: :nil, omitted: :empty }),
       ).to eq("")
     end
   end
 
   describe "Boolean bare-form (Boolean attribute type required)" do
     it "returns false directly for Boolean attribute, value_map[:empty] = false" do
-      expect(attribute(:boolean).apply_value_map("", { empty: false })).to be(false)
+      expect(attribute(:boolean).apply_value_map("",
+                                                 { empty: false })).to be(false)
     end
 
     it "returns true directly for Boolean attribute, value_map[:omitted] = true" do
-      expect(attribute(:boolean).apply_value_map(uninit, { omitted: true })).to be(true)
+      expect(attribute(:boolean).apply_value_map(uninit,
+                                                 { omitted: true })).to be(true)
     end
 
     it "does NOT apply bare-boolean form to a non-Boolean attribute (documented tightening)" do
@@ -106,15 +116,18 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
   describe "Boolean nested-form (value_map[:from][:empty] / [:omitted])" do
     it "returns false from value_map[:from][:empty] unconditionally for Boolean attribute" do
-      expect(attribute(:boolean).apply_value_map("", { from: { empty: false } })).to be(false)
+      expect(attribute(:boolean).apply_value_map("",
+                                                 { from: { empty: false } })).to be(false)
     end
 
     it "returns true from value_map[:from][:omitted] unconditionally for Boolean attribute" do
-      expect(attribute(:boolean).apply_value_map(uninit, { from: { omitted: true } })).to be(true)
+      expect(attribute(:boolean).apply_value_map(uninit,
+                                                 { from: { omitted: true } })).to be(true)
     end
 
     it "returns false from nested form even for non-Boolean attribute (no type gate)" do
-      expect(attribute(:string).apply_value_map("", { from: { empty: false } })).to be(false)
+      expect(attribute(:string).apply_value_map("",
+                                                { from: { empty: false } })).to be(false)
     end
   end
 

data/spec/lutaml/model/attribute_spec.rb

@@ -358,7 +358,8 @@ RSpec.describe Lutaml::Model::Attribute do
       it "executes the proc in the instance context (reads instance attribute)" do
         instance = model_class.new(name: "Alice")
         attribute = model_class.attributes[:greeting]
-        expect(attribute.default_value(register, instance)).to eq("Hello, Alice")
+        expect(attribute.default_value(register,
+                                       instance)).to eq("Hello, Alice")
       end
     end
   end
@@ -413,7 +414,9 @@ RSpec.describe Lutaml::Model::Attribute do
         end
         instance = model_class.new(prefix: "Dr")
         attr = model_class.attributes[:name]
-        expect { attr.validate_value!(nil, register, instance_object: instance) }
+        expect do
+          attr.validate_value!(nil, register, instance_object: instance)
+        end
           .to raise_error(Lutaml::Model::InvalidValueError) do |error|
             # The error carries the value that was used for validation.
             # If instance_exec ran, value is "Dr_default"; if not, error
@@ -427,7 +430,9 @@ RSpec.describe Lutaml::Model::Attribute do
       it "short-circuits without raising" do
         uninit = Lutaml::Model::UninitializedClass.instance
         attr = described_class.new("name", :string)
-        expect { attr.validate_value!(uninit, register, instance_object: model) }
+        expect do
+          attr.validate_value!(uninit, register, instance_object: model)
+        end
           .not_to raise_error
       end
     end

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/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