hibiki_rails 0.17.1 → 0.17.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4919aaf1d8c96e1436138dfc5c0050602e0590447ccf9daebb5598072bf01e2d
-  data.tar.gz: 214048d87eec87fa482744750f736eb3d3004381864e69c12b1664a10ffaf9a5
+  metadata.gz: 83e9656d09f3910405a4db7167b526c173158eb1035d5cb5129e4f916c88c278
+  data.tar.gz: e22b25605c6522e98cfdc86dcd685e62b3c60ed31ca865eb2daa53f74aaaf946
 SHA512:
-  metadata.gz: f1da64047eb007f11f45f55007519808ad717f9b53968273455586c3977486f1e03e2478f9041c05a7f9d889191d6591a7e116e21d918dfb7719b337e0eeed3b
-  data.tar.gz: 1ed922620989a1997ef4231a7c2e737cbca070ff3c3917966c74b1ed48c28e087e08fd7763152eeb96b713e8675b5126d831b07e5e4dc10e22c31d20cb908fdb
+  metadata.gz: 8c459eb9453de6af88c6e7859849a41dcbf7c0daa5d2e79da12e5ac8f729f4b85093e9d10c176d97cb8cd5141ef47ffeb0bcb2482aa03b223e42b2af4b13d9a6
+  data.tar.gz: 7ccd090ef5fdd72735d7bb45d356a1f7085fb6c323d42692c91b7226a5fd6ac058f0ea477efaa6d7693dfbfe66254d85c358e8ea5ca7d3fcd49f6fde56366040

data/CHANGELOG.md

@@ -4,6 +4,44 @@ The gem and the npm package are released in lockstep and share these version
 numbers — `app/assets/javascripts/hibiki.js` is a single copy served both ways,
 so importmap and bundler apps always resolve identical client code.
 
+## 0.17.2 — 2026-10-11
+
+### Fixed
+
+**A save the model refused could leave a `reactive_association` form unable
+to save.** The form keeps one record between attempts. When a `commit` was
+refused, the join rows were rolled back, but the record still remembered the
+selection that attempt had written, and the next `commit` was compared with
+that memory instead of the table. If the refused attempt had removed an id
+that the next one still held, the retry inserted a join row that was already
+there. With a unique index on the pair, which the `multiselect` generator
+writes, that raised `ActiveRecord::RecordNotUnique` and the visitor saw a
+Save that did nothing, every time, until the form was opened again. Without
+the index it wrote a duplicate row.
+
+- Any refused save could set it up, not only one about the association: a
+  blank name saved together with a removed tag was enough.
+- A refused `commit` or `commit!` now unloads the associations named in
+  `reactive_association`, and the join association behind a
+  `has_many :through` or a `has_and_belongs_to_many`. The form keeps the
+  visitor's selection; nothing changes in the channel or the view.
+- An app that calls `record.reload` before `commit` to get round this can
+  remove the call.
+- `hibiki_associations` on a form class lists the names it declared.
+
+**A form that had saved once could save its `reactive_association` wrongly
+after another session changed the same record.** The cause is the same
+memory. If the other session had added an id this form then added too, the
+commit raised `ActiveRecord::RecordNotUnique`. If it had removed an id this
+form still showed, the commit returned `true` and did not write it.
+
+- `commit` now reads the association from the table each time, at the cost
+  of one query per association when it was already loaded.
+- The later save still wins: the form's selection replaces the other
+  session's, as its other fields already did.
+- Nested forms (`reactive_nested`) are not changed.
+- The npm package is unchanged apart from its version.
+
 ## 0.17.1 — 2026-10-09
 
 ### Fixed

data/lib/hibiki/rails/reactive_form.rb

@@ -77,6 +77,7 @@ module Hibiki
         def reactive_association(*names)
           raise "#{self}: declare reactive_attributes before reactive_association" unless __hibiki_model_declared?
 
+          @hibiki_associations = [*hibiki_associations, *names.map(&:to_sym)]
           names.each { |name| __hibiki_ids_signal(name) }
         end
 
@@ -108,6 +109,10 @@ module Hibiki
           @hibiki_nested || __hibiki_inherited(:hibiki_nested) || {}
         end
 
+        def hibiki_associations
+          @hibiki_associations || __hibiki_inherited(:hibiki_associations) || []
+        end
+
         # The child form class, resolved on every use like hibiki_model so
         # a String declaration never pins a constant across a reload.
         def hibiki_nested_form(name)
@@ -259,7 +264,7 @@ module Hibiki
       # have moved values, and #persisted? flips after an INSERT.
       # rubocop:disable-next Naming/PredicateMethod -- boolean without a ?, exactly like AR's #save
       def commit
-        record = __hibiki_record!
+        record = __hibiki_unloaded_record
         if record.update(**to_h)
           # Unload before re-hydrating, so the reload honors the
           # association's own scope and drops destroyed rows.
@@ -272,13 +277,13 @@ module Hibiki
           # update APPENDS its built new children to the in-memory
           # association — a later success would insert them all again.
           # Unloading makes the next attempt start clean.
-          __hibiki_reset_nested(record)
+          __hibiki_unload(record)
           false
         end
       end
 
       # The raising half. Re-assigns and raises ActiveRecord::RecordInvalid
-      # (no rescue, and no AR constant named here); the nested associations
+      # (no rescue, and no AR constant named here); the record's associations
       # are unloaded even on the raise, so a rescued retry starts clean.
       def commit!
         return true if commit
@@ -287,7 +292,7 @@ module Hibiki
         begin
           record.update!(**to_h)
         ensure
-          __hibiki_reset_nested(record)
+          __hibiki_unload(record)
         end
       end
 
@@ -359,6 +364,34 @@ module Hibiki
         self.class.hibiki_nested.each_key { |name| record.public_send(name).reset }
       end
 
+      # What a refused attempt leaves behind on the record.
+      def __hibiki_unload(record)
+        __hibiki_reset_nested(record)
+        __hibiki_reset_associations(record)
+      end
+
+      # A refused update rolls the join rows back, but the ids writer has
+      # already left the association holding the refused set, and the join
+      # association behind a :through (or a has_and_belongs_to_many) holding
+      # the join records it built. The next ids write would be diffed
+      # against that memory instead of the table, so both are unloaded.
+      def __hibiki_reset_associations(record)
+        self.class.hibiki_associations.each do |name|
+          association = record.association(name)
+          association.reset
+          reflection = association.reflection
+          record.association(reflection.through_reflection.name).reset if reflection.through_reflection?
+        end
+      end
+
+      # The record to write to. Its ids associations are unloaded first, so
+      # the ids writer reads the table and not what this record remembers
+      # from an earlier commit or a preload: rows another session wrote
+      # since would otherwise be inserted twice, or silently left out.
+      def __hibiki_unloaded_record
+        __hibiki_record!.tap { __hibiki_reset_associations(it) }
+      end
+
       def __hibiki_record!
         record || raise("#{self.class} has no record — build it with .from(record)")
       end

data/lib/hibiki/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Hibiki
   module Rails
-    VERSION = "0.17.1"
+    VERSION = "0.17.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hibiki_rails
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 0.17.2
 platform: ruby
 authors:
 - planetaska
@@ -216,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: 'Rails glue for hibiki: connection-scoped signal graphs over ActionCable
   + Turbo Streams.'