lutaml-model 0.8.74 → 0.8.76

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45577608605b19115a3826164cf851363218b65e71efa0b48a0d25e3a0df913f
-  data.tar.gz: '0181c1f69c5d731ad13dd65fa31a37c929714f3a0a7fd12d9dd59f7e0d093b1a'
+  metadata.gz: ad2065e687ebed599cff0524f7b165d48d7af977d4329650bcc4e4a5a0fd2acb
+  data.tar.gz: 829f9d6e8eb74705aa3e3ee522f4132805667091b155d1305e9ecde8e2eec817
 SHA512:
-  metadata.gz: ea5765db2e067d6d9b5670eaaa3c4f1269bdea9486ed07179ffa048e4435c0a504542dbf9dbdc0f270f776d084511d7d91998425b024fd8516f3599b7d238616
-  data.tar.gz: 88db0489938297bd0d74e24d169fbf6aecc0245998401159e0795122e24580e050e9dff58672c481f8b7fa14c64314305b23c3d7780962023282fa66a1d549c3
+  metadata.gz: d87aa437e5db934316d42673eda31910bde0145da7a60019c08f60629575063176b3fc5bacb444e1a90a65e36735d5791e3230caed5449b4c76eb146ee4972e0
+  data.tar.gz: d77a73477b74c34626c6951e2de41b1eb8450872ab5164bec957b56407634a799ecce669050d531b1e54963c617a68000812ce6accb27cbb62bca8466c30169f

data/.github/workflows/js-pr-check.yml

@@ -31,6 +31,10 @@ permissions:
   contents: read
   pull-requests: write
 
+concurrency:
+  group: js-pr-check-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   trigger:
     runs-on: ubuntu-latest

data/.github/workflows/js-sync.yml

@@ -20,6 +20,10 @@ on:
 permissions:
   contents: read
 
+concurrency:
+  group: js-sync-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   trigger:
     runs-on: ubuntu-latest

data/.github/workflows/opal.yml

@@ -9,6 +9,10 @@ on:
 permissions:
   contents: read
 
+concurrency:
+  group: opal-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   test:
     runs-on: ubuntu-latest

data/.github/workflows/release.yml

@@ -20,6 +20,12 @@ permissions:
   contents: write
   id-token: write
 
+# One release at a time: concurrent bumps race the version commit
+# and half-published gems are worse than a queued release.
+concurrency:
+  group: release
+  cancel-in-progress: false
+
 jobs:
   release:
     uses: metanorma/ci/.github/workflows/rubygems-release.yml@main

data/lib/lutaml/key_value/transformation.rb

@@ -329,6 +329,11 @@ register = self.register)
           # (public contract, TODO.perf 19 keeps it): a scratch element
           # is merged into the output hash afterwards.
           doc = Lutaml::KeyValue::DataModel::Element.new("__custom__")
+          # Custom methods may write children, or doc.value[key]=, or
+          # nothing at all (pubid 2.0 regression: an empty scratch
+          # flattened to {key => nil} and crashed the merge). Seed the
+          # value hash and merge only hash-shaped results.
+          doc.value = {}
           # lutaml-model#550: custom methods may declare a third context
           # parameter to receive the options passed to `to_*`.
           if model_instance.method(to_method).parameters.size >= 3
@@ -337,7 +342,15 @@ register = self.register)
           else
             model_instance.public_send(to_method, model_instance, doc)
           end
-          parent.update(doc.to_hash.fetch("__custom__", {}))
+          # The 0.8.68 contract: only the method's doc mutations count —
+          # its return value is ignored. (A mutation-style handler whose
+          # last statement is an assignment returns the assigned inner
+          # value; honoring it merged child content at the wrong level —
+          # lutaml-model#892.) Empty docs serialize as nothing, matching
+          # the pre-0.8.74 behavior.
+          merged = doc.to_hash
+          parent.update(merged["__custom__"]) if merged.is_a?(::Hash) &&
+            merged["__custom__"].is_a?(::Hash)
           return
         end
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.74"
+    VERSION = "0.8.76"
   end
 end

data/spec/lutaml/key_value/transformation_spec.rb

@@ -290,4 +290,72 @@ RSpec.describe Lutaml::KeyValue::Transformation do
       end.not_to raise_error
     end
   end
+
+  describe "custom to: methods under hash-direct emission (pubid regression)" do
+    before do
+      stub_const("PubidRegress", Module.new)
+      stub_const("PubidRegress::EmptyCustom", empty_custom_class)
+      stub_const("PubidRegress::ValueWriter", value_writer_class)
+      stub_const("PubidRegress::ReturnOnly", return_only_class)
+    end
+
+    let(:empty_custom_class) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :code, :string
+        key_value do
+          map "code", to: :code, with: { to: :to_code }
+        end
+
+        # pubid 2.0's shape: inspects the doc and may return without
+        # writing anything — must not crash the emission.
+        def to_code(_model, doc); end
+      end
+    end
+
+    let(:value_writer_class) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :code, :string
+        key_value do
+          map "code", to: :code, with: { to: :to_code }
+        end
+
+        def to_code(model, doc)
+          doc.value["code"] = model.code
+        end
+      end
+    end
+
+    let(:return_only_class) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :code, :string
+        key_value do
+          map "code", to: :code, with: { to: :to_code }
+        end
+
+        # Returns its value without touching the doc — a shape the
+        # mutation-only contract must serialize as nothing (#892).
+        def to_code(_model, _doc)
+          { "code" => "RETURNED" }
+        end
+      end
+    end
+
+    it "tolerates a custom method that writes nothing to the doc" do
+      model = PubidRegress::EmptyCustom.new(code: "X")
+      expect(model.to_hash).to eq({})
+    end
+
+    it "merges a custom method writing through doc.value" do
+      model = PubidRegress::ValueWriter.new(code: "X")
+      expect(model.to_hash).to eq("code" => "X")
+    end
+
+    it "ignores a custom method's return value (mutation-only contract)" do
+      # A method returning a hash without touching the doc serializes
+      # as nothing — honoring returns merged child content at the
+      # wrong level (lutaml-model#892).
+      model = PubidRegress::ReturnOnly.new(code: "X")
+      expect(model.to_hash).to eq({})
+    end
+  end
 end

data/spec/lutaml/model/collection_validation_spec.rb

@@ -732,5 +732,270 @@ RSpec.describe Lutaml::Model::Collection do
         end
       end
     end
+
+    describe "Conditional validation chaining with context" do
+      context "with context sharing between validations" do
+        it "allows validations to read results from previous validations" do
+          chain_executed = []
+
+          chained_collection = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validates_uniqueness_of :id
+
+            validate_collection do |_collection, _errors, ctx|
+              chain_executed << :first
+              ctx[:duplicates_found] = !ctx[:duplicates_of_id].nil? && ctx[:duplicates_of_id].any?
+            end
+
+            validate_collection do |_collection, errors, ctx|
+              chain_executed << :second
+              if ctx[:duplicates_found]
+                errors.add(:collection, "Cannot proceed with duplicates")
+              end
+            end
+          end
+
+          # Test with duplicates
+          collection = chained_collection.new([science_publication, duplicate_id_publication])
+          expect { collection.validate! }.to raise_error(Lutaml::Model::ValidationError) do |error|
+            expect(error.message).to include("Cannot proceed with duplicates")
+          end
+          expect(chain_executed).to eq(%i[first second])
+
+          # Test without duplicates
+          chain_executed.clear
+          collection = chained_collection.new([science_publication, fiction_publication])
+          expect { collection.validate! }.not_to raise_error
+          expect(chain_executed).to eq(%i[first second])
+        end
+
+        it "stores duplicate values in context for downstream validations" do
+          chained_collection = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validates_uniqueness_of :id
+
+            validate_collection do |_collection, errors, ctx|
+              if ctx[:duplicates_of_id]&.include?("1")
+                errors.add(:collection, "Found duplicate ID: 1")
+              end
+            end
+          end
+
+          collection = chained_collection.new([science_publication, duplicate_id_publication])
+          expect { collection.validate! }.to raise_error(Lutaml::Model::ValidationError) do |error|
+            expect(error.message).to include("Found duplicate ID: 1")
+          end
+        end
+
+        it "stores missing count in context for validates_all_present" do
+          chained_collection = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validates_all_present :author
+
+            validate_collection do |_collection, errors, ctx|
+              if ctx[:missing_author_count].to_i > 0
+                errors.add(:collection, "#{ctx[:missing_author_count]} items missing author")
+              end
+            end
+          end
+
+          collection = chained_collection.new([science_publication, publication_without_author])
+          expect { collection.validate! }.to raise_error(Lutaml::Model::ValidationError) do |error|
+            expect(error.message).to include("1 items missing author")
+          end
+        end
+      end
+
+      context "with conditional validation using :if_cond option" do
+        it "only runs validation when condition is met" do
+          chained_collection = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validates_uniqueness_of :id
+
+            validate_collection(if_cond: ->(ctx) { ctx[:duplicates_of_id]&.any? }) do |_collection, errors, _ctx|
+              errors.add(:collection, "Validation ran because duplicates exist")
+            end
+          end
+
+          # With duplicates - conditional validation should run
+          collection = chained_collection.new([science_publication, duplicate_id_publication])
+          expect { collection.validate! }.to raise_error(Lutaml::Model::ValidationError) do |error|
+            expect(error.message).to include("Validation ran because duplicates exist")
+          end
+
+          # Without duplicates - conditional validation should not run
+          collection = chained_collection.new([science_publication, fiction_publication])
+          expect { collection.validate! }.not_to raise_error
+        end
+
+        it "can skip validation based on context state" do
+          expensive_validation_ran = false
+
+          chained_collection = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validates_uniqueness_of :id
+
+            validate_collection(if_cond: ->(ctx) { !ctx[:duplicates_of_id]&.any? }) do |_collection, _errors, _ctx|
+              expensive_validation_ran = true
+            end
+          end
+
+          # With duplicates - the uniqueness error raises (landed
+          # semantics) AND the expensive validation still skipped
+          collection = chained_collection.new([science_publication, duplicate_id_publication])
+          expect { collection.validate! }.to raise_error(Lutaml::Model::ValidationError,
+                                                         /unique across collection/)
+          expect(expensive_validation_ran).to be false
+
+          # Without duplicates - expensive validation should run
+          expensive_validation_ran = false
+          collection = chained_collection.new([science_publication, fiction_publication])
+          collection.validate!
+          expect(expensive_validation_ran).to be true
+        end
+      end
+
+      context "with conditional validation using :unless_cond option" do
+        it "skips validation when condition is met" do
+          ran_count = 0
+
+          chained_collection = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validates_uniqueness_of :id
+
+            validate_collection(unless_cond: ->(ctx) { ctx[:duplicates_of_id]&.any? }) do |_collection, _errors, _ctx|
+              ran_count += 1
+            end
+          end
+
+          # With duplicates - the uniqueness error raises (landed
+          # semantics) AND the conditional validation still skipped
+          collection = chained_collection.new([science_publication, duplicate_id_publication])
+          expect { collection.validate! }.to raise_error(Lutaml::Model::ValidationError,
+                                                         /unique across collection/)
+          expect(ran_count).to be 0
+
+          # Without duplicates - should run
+          collection = chained_collection.new([science_publication, fiction_publication])
+          collection.validate!
+          expect(ran_count).to be 1
+        end
+      end
+
+      context "with ctx.stop!" do
+        it "stops validation chain when ctx.stop! is called" do
+          chain_order = []
+
+          chained_collection = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validate_collection do |_collection, _errors, ctx|
+              chain_order << :first
+              ctx.stop!
+            end
+
+            validate_collection do |_collection, _errors, ctx|
+              chain_order << :second
+              ctx.stop!
+            end
+
+            validate_collection do |_collection, _errors, _ctx|
+              chain_order << :third
+            end
+          end
+
+          collection = chained_collection.new([science_publication])
+          collection.validate!
+          expect(chain_order).to eq([:first])
+        end
+      end
+
+      context "with backwards compatible block signatures" do
+        it "works with 1-argument blocks" do
+          ran = false
+
+          collection_class = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validate_collection do |collection|
+              ran = true if !collection.empty?
+            end
+          end
+
+          collection = collection_class.new([science_publication])
+          collection.validate!
+          expect(ran).to be true
+        end
+
+        it "works with 2-argument blocks (original signature)" do
+          ran_args = []
+
+          collection_class = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validate_collection do |collection, errors|
+              ran_args << [collection.size, errors.class.name]
+              errors.add(:collection, "Test error") if !collection.empty?
+            end
+          end
+
+          collection = collection_class.new([science_publication])
+          errors = collection.validate
+          expect(ran_args.first.first).to eq 1
+          expect(ran_args.first.last).to include("Errors")
+          expect(errors.map(&:message).first).to include("Test error")
+        end
+
+        it "works with 3-argument blocks (new signature with context)" do
+          received_context = nil
+
+          collection_class = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validate_collection do |_collection, _errors, ctx|
+              received_context = ctx
+              ctx[:test_value] = "from_validation"
+            end
+          end
+
+          collection = collection_class.new([science_publication])
+          collection.validate
+          expect(received_context).to be_a(Lutaml::Model::ValidationContext)
+          expect(received_context[:test_value]).to eq("from_validation")
+        end
+      end
+
+      context "with ctx.failed? helper" do
+        it "returns true when errors have been added" do
+          result = nil
+
+          chained_collection = Class.new(Lutaml::Model::Collection) do
+            instances :publications, CollectionValidationTests::Publication
+
+            validates_uniqueness_of :id
+
+            validate_collection do |_collection, _errors, ctx|
+              result = ctx.failed?
+            end
+          end
+
+          # Without errors
+          collection = chained_collection.new([science_publication, fiction_publication])
+          collection.validate
+          expect(result).to be false
+
+          # With errors
+          collection = chained_collection.new([science_publication, duplicate_id_publication])
+          collection.validate
+          expect(result).to be true
+        end
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.74
+  version: 0.8.76
 platform: ruby
 authors:
 - Ribose Inc.