undertow 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b2c91ae2e1c3eafff3e52438ca4a8c2e2856fd83c2c1097708d3e7f2ed457be
-  data.tar.gz: 385394ce28a3034f17d4e89d3d00528931f38c44a180b338c5bfb43c83b4877b
+  metadata.gz: bf230477188804dcf6c63e0c97c615defb3577c78f85e930449d7dba6d9d965e
+  data.tar.gz: 6653637c116fff79ba2a2806326882f7e7e939acdf1ca0f01a653e22530dd3c7
 SHA512:
-  metadata.gz: 57614c035d133873d7f3c9b881bc6c59de51c0f2add8bc860eb059f955bdd4cc7a57576e99df1085576db5b64fbdfd7c6b4376136093b46ed259e2e70dc3f87b
-  data.tar.gz: 20cca40fdfe6459d18b264050ce5db678d6d94e537d3bd19a7fbe3a61fb5b7e32bb13bd859a88d263f20d8df4473cc178d6796470d609add092d66ca60229da9
+  metadata.gz: 74aca2058a93a4474bd275de1ab3d077b7e83e5a6449cb0921938585821c29f39ab531240eabbfb89d28ba7ac4a73cd4f3c58183e001992847d1a3ebae6e89b2
+  data.tar.gz: 6c18ad42284eb95008c44bfd6240e79ae14c7d99aa50befa8c1ccb417d07286a55049c1467f6e4f66a66d8f93df8e7c1b613cc045217df6ba81c9334af3cf368

data/lib/undertow/dsl.rb

@@ -21,19 +21,27 @@ module Undertow
       _undertow_ensure_trackable!
     end
 
+    # Suppress self-tracking when these root-model columns are the only changes.
+    # Accepts strings or symbols; blanks are ignored.
     def undertow_skip(columns)
-      _undertow_config.skip_columns = columns
+      _undertow_config.skip_columns = Array(columns).map(&:to_s).reject(&:blank?).uniq
       _undertow_ensure_trackable!
     end
 
+    # Track invalidations from an upstream association.
+    # `watched_columns` accepts strings or symbols; blanks are ignored.
+    # Empty/nil means no watched-column filter.
     def undertow_depends_on(association, foreign_key: nil, resolver: nil, watched_columns: nil)
       raise ArgumentError, 'provide exactly one of foreign_key: or resolver:' unless foreign_key.nil? ^ resolver.nil?
 
+      normalized_watched = Array(watched_columns).map(&:to_s).
+        reject(&:blank?).uniq.presence
+
       _undertow_config.dependencies << {
          association: association,
          foreign_key: foreign_key,
          resolver: resolver,
-         watched_columns: watched_columns
+         watched_columns: normalized_watched
       }.freeze
       _undertow_ensure_trackable!
     end

data/lib/undertow/trackable.rb

@@ -4,8 +4,9 @@ module Undertow
   # ActiveRecord concern mixed in automatically when a model uses the Undertow DSL
   # (undertow_on_drain, undertow_skip, undertow_depends_on). Never included manually.
   #
-  # Provides class-level callback registration and the skip_columns guard.
-  # Callbacks are wired at boot by the Railtie after all models are loaded.
+  # Provides class-level callback registration and dependency push handlers, plus
+  # instance-level self-tracking handlers. Callbacks are wired at boot by the Railtie
+  # after all models are loaded.
   module Trackable
     extend ActiveSupport::Concern
 
@@ -30,86 +31,100 @@ module Undertow
         (config.dependencies || []).each { |dep| _register_dep_callbacks!(dep) }
       end
 
+      def _push_undertow_pending(ids)
+        Buffer.push_pending(name, ids)
+      end
+
+      def _push_undertow_deleted(ids)
+        Buffer.push_deleted(name, ids)
+      end
+
+      def _push_dep_pending(record, dep)
+        ids = _dep_ids_for(record, dep)
+        _push_undertow_pending(ids) if ids.any?
+      end
+
+      def _push_dep_updated(record, dep)
+        watched = dep[:watched_columns]
+        # Two non-obvious cases where after_commit on :update fires:
+        #   - no-op save: saved_changes is {}, suppressed when watched_columns is configured
+        #   - touch (e.g. belongs_to touch: true): saved_changes contains only updated_at,
+        #     suppressed only when watched_columns is configured and updated_at is not in it
+        return if watched && (record.saved_changes.keys & watched).none?
+
+        _push_dep_pending(record, dep)
+      end
+
       private
 
       def _register_self_callbacks!
-        after_commit  :_push_self_pending, on: %i[create update]
+        after_commit  :_push_self_created, on: :create
+        after_commit  :_push_self_updated, on: :update
         after_destroy :_push_self_deleted
-        after_restore :_push_self_pending if respond_to?(:after_restore)
+        after_restore :_push_self_restored if respond_to?(:after_restore)
       end
 
       def _register_dep_callbacks!(dep)
         dep_class = _resolve_dep_class(dep)
-        return unless dep_class
-
         root_class = self
-        watched    = dep[:watched_columns].presence # [] treated same as nil, watch all
-
-        resolver = dep[:resolver] || begin
-          fk = dep[:foreign_key]
-          ->(record) { root_class.where(fk => record.id) }
-        end
-
-        push_pending = ->(record) {
-          ids = resolver.call(record).pluck(:id)
-          next unless ids.any?
 
-          root_class._push_undertow_pending(ids)
-        }
+        dep_class.after_commit(on: :create) { root_class._push_dep_pending(self, dep) }
+        dep_class.after_commit(on: :update) { root_class._push_dep_updated(self, dep) }
 
-        # Skip create/update callback when watched_columns is set and none changed.
-        # Note: saved_changes is empty when touched via belongs_to touch: true (bypasses
-        # dirty tracking), that correctly falls through to skip here.
-        dep_class.after_commit on: %i[create update] do
-          next if watched && (saved_changes.keys & watched).none?
+        # Soft-delete gems fire run_callbacks(:destroy), triggering after_destroy, but
+        # mark the record deleted via update_columns (bypassing after_commit),
+        # so the create/update callbacks above never double-fire on a soft delete.
+        dep_class.after_destroy { root_class._push_dep_pending(self, dep) }
 
-          push_pending.call(self)
-        end
-
-        # Dep destroyed, reindex surviving root records. SoftDeletable calls
-        # run_callbacks(:destroy), which fires after_destroy, but update_columns does NOT
-        # trigger after_commit, so scoping after_commit to [:create, :update] above
-        # ensures destroy commits don't double-fire.
-        dep_class.after_destroy { push_pending.call(self) }
-
-        # Dep restored, after_restore is the only hook that fires because restore!
-        # uses update_columns, bypassing after_commit.
-        if dep_class.respond_to?(:after_restore)
-          dep_class.after_restore { push_pending.call(self) }
-        end
+        # Soft-delete restores use update_columns to unmark the record, bypassing
+        # after_commit. after_restore is the only hook that fires for restores.
+        dep_class.after_restore { root_class._push_dep_pending(self, dep) } if dep_class.respond_to?(:after_restore)
       end
 
       def _resolve_dep_class(dep)
-        if dep[:resolver]
+        reflect_on_association(dep[:association])&.klass ||
           dep[:association].to_s.classify.constantize
+      end
+
+      def _dep_ids_for(record, dep)
+        if dep[:resolver]
+          dep[:resolver].call(record).pluck(:id)
         else
-          reflect_on_association(dep[:association])&.klass ||
-            dep[:association].to_s.classify.constantize
+          where(dep[:foreign_key] => record.id).pluck(:id)
         end
       end
+    end
 
-      public
-
-      def _push_undertow_pending(ids)
-        Buffer.push_pending(name, ids)
-      end
+    private
 
-      def _push_undertow_deleted(ids)
-        Buffer.push_deleted(name, ids)
-      end
+    def _push_self_created
+      _enqueue_self_pending
     end
 
-    private
+    def _push_self_updated
+      return unless _self_update_requires_invalidation?
 
-    def _push_self_pending
-      ignored = self.class._undertow_ignored_columns
-      return if ignored.any? && saved_changes.any? && (saved_changes.keys - ignored).empty?
+      _enqueue_self_pending
+    end
 
-      self.class._push_undertow_pending([id])
+    def _push_self_restored
+      _enqueue_self_pending
     end
 
     def _push_self_deleted
       self.class._push_undertow_deleted([id])
     end
+
+    def _enqueue_self_pending
+      self.class._push_undertow_pending([id])
+    end
+
+    def _self_update_requires_invalidation?
+      changed = saved_changes.keys
+      return false if changed.empty?
+
+      ignored = self.class._undertow_ignored_columns
+      (changed - ignored).any?
+    end
   end
 end

data/lib/undertow/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Undertow
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: undertow
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Nathan Allen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-06 00:00:00.000000000 Z
+date: 2026-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord