undertow 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53f9ee409c2585ff551f21884f10e8eec276ee750e6f3c12109280cc79fdd934
-  data.tar.gz: e343c5be340f08b271e5851a91c0a3c5f363ce28357b5deb83657ae5c242f494
+  metadata.gz: 0b2c91ae2e1c3eafff3e52438ca4a8c2e2856fd83c2c1097708d3e7f2ed457be
+  data.tar.gz: 385394ce28a3034f17d4e89d3d00528931f38c44a180b338c5bfb43c83b4877b
 SHA512:
-  metadata.gz: 28d46d6ddfb4e02ef12dcc001295e9f39034708af79ba12761553d61c32fe96d6d64769cdf45c9df8d3276ff19c9de0080b843ff54cc575e94f7a947db545c99
-  data.tar.gz: 49c01b579d3797b755d52c077890753abba9defe3b49ca7e7871564c4ee31627328933a00e0fa0f3e031af16f5e2cb54354516dc277bc87dfc18e68cd464379c
+  metadata.gz: 57614c035d133873d7f3c9b881bc6c59de51c0f2add8bc860eb059f955bdd4cc7a57576e99df1085576db5b64fbdfd7c6b4376136093b46ed259e2e70dc3f87b
+  data.tar.gz: 20cca40fdfe6459d18b264050ce5db678d6d94e537d3bd19a7fbe3a61fb5b7e32bb13bd859a88d263f20d8df4473cc178d6796470d609add092d66ca60229da9

data/lib/undertow/buffer.rb

@@ -1,98 +1,80 @@
 # frozen_string_literal: true
 
 module Undertow
-  # Low-level Redis SET operations used by Trackable callbacks and DrainJob.
-  # All methods are no-ops when tracking is disabled or Redis is unavailable.
+  # Low-level set operations used by Trackable callbacks and DrainJob.
+  # Delegates to the configured store adapter. All methods are no-ops when
+  # tracking is disabled.
   module Buffer
     class << self
       def push_pending(model_name, ids)
         return if Undertow.tracking_disabled?
 
-        with_redis do |r|
-          r.sadd(Registry.pending_key(model_name), ids)
-          r.sadd(Registry::MODELS_KEY, model_name)
-        end
+        store.add_members(Registry.pending_key(model_name), ids)
+        store.add_members(Registry::MODELS_KEY, model_name)
       end
 
       def push_deleted(model_name, ids)
         return if Undertow.tracking_disabled?
 
-        with_redis do |r|
-          r.sadd(Registry.deleted_key(model_name), ids)
-          r.sadd(Registry::MODELS_KEY, model_name)
-        end
+        store.add_members(Registry.deleted_key(model_name), ids)
+        store.add_members(Registry::MODELS_KEY, model_name)
       end
 
       def pop_pending(model_name, count)
-        with_redis { |r| r.spop(Registry.pending_key(model_name), count) } || []
+        store.pop_members(Registry.pending_key(model_name), count)
       end
 
       def pop_deleted(model_name, count)
-        with_redis { |r| r.spop(Registry.deleted_key(model_name), count) } || []
+        store.pop_members(Registry.deleted_key(model_name), count)
       end
 
       def pending_model_names
-        with_redis { |r| r.smembers(Registry::MODELS_KEY) } || []
+        store.members(Registry::MODELS_KEY)
       end
 
       def deregister_model(model_name)
-        with_redis { |r| r.srem(Registry::MODELS_KEY, model_name) }
+        store.remove_member(Registry::MODELS_KEY, model_name)
       end
 
       def reregister_model(model_name)
-        with_redis { |r| r.sadd(Registry::MODELS_KEY, model_name) }
+        store.add_members(Registry::MODELS_KEY, model_name)
       end
 
       def remaining(model_name)
-        with_redis do |r|
-          r.scard(Registry.pending_key(model_name)) +
-          r.scard(Registry.deleted_key(model_name))
-        end || 0
+        store.member_count(Registry.pending_key(model_name)) +
+          store.member_count(Registry.deleted_key(model_name))
       end
 
       def restore_pending(model_name, ids)
-        with_redis { |r| r.sadd(Registry.pending_key(model_name), ids) } if ids.any?
+        store.add_members(Registry.pending_key(model_name), ids) if ids.any?
       end
 
       def restore_deleted(model_name, ids)
-        with_redis { |r| r.sadd(Registry.deleted_key(model_name), ids) } if ids.any?
+        store.add_members(Registry.deleted_key(model_name), ids) if ids.any?
       end
 
       def pending?
-        with_redis { |r| r.scard(Registry::MODELS_KEY) > 0 } || false
+        store.member_count(Registry::MODELS_KEY).positive?
       end
 
-      # Acquire the distributed drain lock using SET NX. Returns true if the lock
-      # was acquired, false if it was already held. TTL is a safety valve in case
-      # the job process dies before releasing it.
       def acquire_drain_lock(ttl: 30)
         lock_key = Undertow.configuration.drain_lock_key
         return true unless lock_key
 
-        with_redis { |r| r.set(lock_key, '1', nx: true, ex: ttl) } || false
+        store.lock_acquire(lock_key, ttl: ttl)
       end
 
-      # Release the drain lock. Called at the start of DrainJob#perform so the
-      # scheduler can enqueue another job for IDs that arrive while this one runs.
       def release_drain_lock
         lock_key = Undertow.configuration.drain_lock_key
         return unless lock_key
 
-        with_redis { |r| r.del(lock_key) }
+        store.lock_release(lock_key)
       end
 
       private
 
-      def with_redis
-        client = Undertow.configuration.redis!
-        if client.respond_to?(:with)
-          client.with { |conn| yield conn }
-        else
-          yield client
-        end
-      rescue Redis::BaseConnectionError, Redis::CommandError => e
-        Rails.logger.error("Undertow: Redis error: #{e.message}") if defined?(Rails)
-        nil
+      def store
+        Undertow.configuration.store!
       end
     end
   end

data/lib/undertow/configuration.rb

@@ -2,12 +2,21 @@
 
 module Undertow
   class Configuration
-    # A Redis client or connection pool. Must respond to :sadd, :srem, :smembers,
-    # :spop, :scard, :del. Injected by the host application:
+    # A store adapter (an instance of Undertow::Store::Base). Injected by the
+    # host application:
     #
-    #   Undertow.configure { |c| c.redis = Redis.new(url: ENV['REDIS_URL']) }
+    #   # Redis
+    #   Undertow.configure do |c|
+    #     c.store = Undertow::Store::RedisStore.new(Redis.new(url: ENV['REDIS_URL']))
+    #   end
     #
-    attr_accessor :redis
+
+    #   # In-memory (test / single-process dev)
+    #   Undertow.configure do |c|
+    #     c.store = Undertow::Store::MemoryStore.new
+    #   end
+    #
+    attr_accessor :store
 
     # Maximum number of IDs to pop from the buffer per drain per model.
     attr_accessor :max_batch
@@ -15,20 +24,21 @@ module Undertow
     # ActiveJob queue to use for DrainJob.
     attr_accessor :queue_name
 
-    # Redis key used for the distributed drain lock. The scheduler acquires this
-    # lock (SET NX) before enqueueing DrainJob; the job releases it immediately
-    # on start so new work arriving mid-drain gets its own job on the next tick.
+    # Key used for the distributed drain lock. The scheduler acquires this lock
+    # before enqueueing DrainJob; the job releases it immediately on start so
+    # new work arriving mid-drain gets its own job on the next tick.
     # Set to nil to disable lock management entirely.
     attr_accessor :drain_lock_key
 
     def initialize
+      @store          = Undertow::Store::MemoryStore.new
       @max_batch      = 1_000
       @queue_name     = :undertow
       @drain_lock_key = 'undertow:drain:lock'
     end
 
-    def redis!
-      redis or raise 'Undertow.configuration.redis is not set'
+    def store!
+      store or raise 'Undertow.configuration.store is not set'
     end
   end
 end

data/lib/undertow/drain_job.rb

@@ -5,8 +5,8 @@ module Undertow
   # each model's configured on_drain handler.
   #
   # Publishes two ActiveSupport::Notifications events:
-  #   drain.undertow  — after a successful on_drain call ({ model:, ids:, deleted_ids: })
-  #   error.undertow  — when on_drain raises ({ model:, exception: })
+  #   drain.undertow , after a successful on_drain call ({ model:, ids:, deleted_ids: })
+  #   error.undertow , when on_drain raises ({ model:, exception: })
   class DrainJob < ActiveJob::Base
     queue_as { Undertow.configuration.queue_name }
 
@@ -26,7 +26,7 @@ module Undertow
     def drain_model(model_name)
       max = Undertow.configuration.max_batch
 
-      # Deregister before popping — any concurrent push will re-add the model,
+      # Deregister before popping, any concurrent push will re-add the model,
       # preventing the race where srem fires after a concurrent sadd.
       Buffer.deregister_model(model_name)
 
@@ -44,8 +44,8 @@ module Undertow
       config.on_drain.call(model_name, ids, deleted_ids)
 
       ActiveSupport::Notifications.instrument('drain.undertow', {
-        model:       model_name,
-        ids:         ids,
+        model: model_name,
+        ids: ids,
         deleted_ids: deleted_ids
       })
     rescue StandardError => e

data/lib/undertow/dsl.rb

@@ -3,7 +3,7 @@
 module Undertow
   # Class-level DSL extended onto ActiveRecord::Base by the Railtie. Any model
   # that calls these methods automatically registers itself with Undertow and
-  # gets Trackable behavior wired in at boot — no include needed.
+  # gets Trackable behavior wired in at boot, no include needed.
   #
   #   class Activity < ApplicationRecord
   #     undertow_on_drain ->(model_name, ids, deleted_ids) { ActivityReindexJob.perform_later(ids, deleted_ids) }
@@ -30,10 +30,10 @@ module Undertow
       raise ArgumentError, 'provide exactly one of foreign_key: or resolver:' unless foreign_key.nil? ^ resolver.nil?
 
       _undertow_config.dependencies << {
-        association:     association,
-        foreign_key:     foreign_key,
-        resolver:        resolver,
-        watched_columns: watched_columns
+         association: association,
+         foreign_key: foreign_key,
+         resolver: resolver,
+         watched_columns: watched_columns
       }.freeze
       _undertow_ensure_trackable!
     end

data/lib/undertow/store/base.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Undertow
+  module Store
+    # Abstract base class for Undertow store adapters.
+    #
+    # Concrete adapters must implement all methods defined here.
+    # Buffer delegates all operations to the configured store, so adapters
+    # are the only place that knows about the underlying backend.
+    class Base
+      # Add members to the set at key.
+      def add_members(key, members)
+        raise NotImplementedError, "#{self.class}#add_members is not implemented"
+      end
+
+      # Remove a single member from the set at key.
+      def remove_member(key, member)
+        raise NotImplementedError, "#{self.class}#remove_member is not implemented"
+      end
+
+      # Return all members of the set at key.
+      def members(key)
+        raise NotImplementedError, "#{self.class}#members is not implemented"
+      end
+
+      # Atomically remove and return up to count members from the set at key.
+      def pop_members(key, count)
+        raise NotImplementedError, "#{self.class}#pop_members is not implemented"
+      end
+
+      # Return the number of members in the set at key.
+      def member_count(key)
+        raise NotImplementedError, "#{self.class}#member_count is not implemented"
+      end
+
+      # Attempt to acquire a lock at key with the given TTL in seconds.
+      # Returns true if the lock was acquired, false if already held.
+      def lock_acquire(key, ttl:)
+        raise NotImplementedError, "#{self.class}#lock_acquire is not implemented"
+      end
+
+      # Release the lock at key.
+      def lock_release(key)
+        raise NotImplementedError, "#{self.class}#lock_release is not implemented"
+      end
+    end
+  end
+end

data/lib/undertow/store/memory_store.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Undertow
+  module Store
+    # Store adapter backed by in-process memory.
+    #
+    # Uses Mutex-protected Ruby Sets for thread safety. Intended for use in
+    # test environments and single-process development setups.
+    #
+    # Lock operations are no-ops, there is no scheduler race in a single process.
+    #
+    #   Undertow.configure do |c|
+    #     c.store = Undertow::Store::MemoryStore.new
+    #   end
+    #
+    # WARNING: State is not shared across processes. Do not use in multi-process
+    # or multi-dyno deployments.
+    class MemoryStore < Base
+      def initialize
+        super
+        @sets  = Hash.new { |h, k| h[k] = Set.new }
+        @mutex = Mutex.new
+      end
+
+      def add_members(key, members)
+        @mutex.synchronize { @sets[key].merge(Array(members)) }
+      end
+
+      def remove_member(key, member)
+        @mutex.synchronize { @sets[key].delete(member) }
+      end
+
+      def members(key)
+        @mutex.synchronize { @sets[key].to_a }
+      end
+
+      def pop_members(key, count)
+        @mutex.synchronize do
+          members = @sets[key].first(count)
+          members.each { |m| @sets[key].delete(m) }
+          members
+        end
+      end
+
+      def member_count(key)
+        @mutex.synchronize { @sets[key].size }
+      end
+
+      # No-op, single process, no scheduler race possible.
+      def lock_acquire(*)
+        true
+      end
+
+      # No-op.
+      def lock_release(key)
+        # nothing to do
+      end
+    end
+  end
+end

data/lib/undertow/store/redis_store.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Undertow
+  module Store
+    # Store adapter backed by Redis.
+    #
+    # Accepts a Redis client or a connection pool (any object responding to #with).
+    #
+    #   Undertow.configure do |c|
+    #     c.store = Undertow::Store::RedisStore.new(Redis.new(url: ENV['REDIS_URL']))
+    #   end
+    #
+    class RedisStore < Base
+      def initialize(client)
+        super()
+        @client = client
+      end
+
+      def add_members(key, members)
+        with_redis { |r| r.sadd(key, members) }
+      end
+
+      def remove_member(key, member)
+        with_redis { |r| r.srem(key, member) }
+      end
+
+      def members(key)
+        with_redis { |r| r.smembers(key) } || []
+      end
+
+      def pop_members(key, count)
+        with_redis { |r| r.spop(key, count) } || []
+      end
+
+      def member_count(key)
+        with_redis { |r| r.scard(key) } || 0
+      end
+
+      def lock_acquire(key, ttl:)
+        with_redis { |r| r.set(key, '1', nx: true, ex: ttl) } || false
+      end
+
+      def lock_release(key)
+        with_redis { |r| r.del(key) }
+      end
+
+      private
+
+      def with_redis
+        if @client.respond_to?(:with)
+          @client.with { |conn| yield conn }
+        else
+          yield @client
+        end
+      rescue Redis::BaseConnectionError, Redis::CommandError => e
+        Rails.logger.error("Undertow: Redis error: #{e.message}") if defined?(Rails)
+        nil
+      end
+    end
+  end
+end

data/lib/undertow/trackable.rb

@@ -11,14 +11,14 @@ module Undertow
 
     included do
       # Columns listed here suppress self-tracking when they are the *only*
-      # things that changed — prevents feedback loops from columns updated by
+      # things that changed, prevents feedback loops from columns updated by
       # the drain handler itself.
       class_attribute :_undertow_ignored_columns, default: [], instance_writer: false
     end
 
     class_methods do
       # Called by the Railtie after all models/associations are loaded.
-      # Idempotent — safe to call multiple times (e.g. in reloading environments).
+      # Idempotent, safe to call multiple times (e.g. in reloading environments).
       def register_undertow_callbacks!(config)
         return if @_undertow_callbacks_registered
 
@@ -43,7 +43,7 @@ module Undertow
         return unless dep_class
 
         root_class = self
-        watched    = dep[:watched_columns].presence # [] treated same as nil — watch all
+        watched    = dep[:watched_columns].presence # [] treated same as nil, watch all
 
         resolver = dep[:resolver] || begin
           fk = dep[:foreign_key]
@@ -59,20 +59,20 @@ module Undertow
 
         # 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.
+        # 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?
 
           push_pending.call(self)
         end
 
-        # Dep destroyed — reindex surviving root records. SoftDeletable calls
+        # 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!
+        # 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) }

data/lib/undertow/version.rb

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

data/lib/undertow.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
-require 'active_support'
 require 'active_record'
+require 'active_support'
 
 require_relative 'undertow/version'
 require_relative 'undertow/configuration'
+require_relative 'undertow/store/base'
+require_relative 'undertow/store/redis_store'
+require_relative 'undertow/store/memory_store'
 require_relative 'undertow/registry'
 require_relative 'undertow/buffer'
 require_relative 'undertow/dsl'
@@ -37,7 +40,7 @@ module Undertow
     end
 
     # Called from the host application's scheduler on each tick. Checks for
-    # pending work, acquires the drain lock, and enqueues DrainJob — no other
+    # pending work, acquires the drain lock, and enqueues DrainJob, no other
     # wiring required:
     #
     #   every(1.second, 'undertow') { Undertow.tick }

data/undertow.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata = {
     'source_code_uri' => 'https://github.com/nallenscott/undertow',
-    'changelog_uri'   => 'https://github.com/nallenscott/undertow/blob/main/CHANGELOG.md',
+    'changelog_uri' => 'https://github.com/nallenscott/undertow/blob/main/CHANGELOG.md',
     'bug_tracker_uri' => 'https://github.com/nallenscott/undertow/issues'
   }
 
@@ -24,5 +24,4 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activerecord',  '~> 7.0'
   spec.add_dependency 'activesupport', '~> 7.0'
   spec.add_dependency 'activejob',     '~> 7.0'
-  spec.add_dependency 'redis',         '~> 5.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: undertow
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Nathan Allen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-25 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -52,20 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '7.0'
-- !ruby/object:Gem::Dependency
-  name: redis
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
 description:
 email:
 - hello@nallenscott.com
@@ -80,6 +66,9 @@ files:
 - lib/undertow/dsl.rb
 - lib/undertow/railtie.rb
 - lib/undertow/registry.rb
+- lib/undertow/store/base.rb
+- lib/undertow/store/memory_store.rb
+- lib/undertow/store/redis_store.rb
 - lib/undertow/trackable.rb
 - lib/undertow/version.rb
 - undertow.gemspec