delayable 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c17ddd3e91c54be2b587b653633a034aec19f240a0a15439b80aa5ed88a9c11f
-  data.tar.gz: e589da2392206c0f1574199fd1bc3b3c2c59161886a2f11effeb32b79fb5ecfd
+  metadata.gz: fbc0e3130501e50157a5dd2807576126022d145f89a3a005eb596b41c3456ecf
+  data.tar.gz: 729e2cf6548e11b220d7f8f19da46e55c1e520de3046ced844c5b858e4b1b2e5
 SHA512:
-  metadata.gz: 9c22ae61f2b817ac71bd85f96bb9d65f3d0d985a58b5fdf9dd67e10ec7654afc71943c09aa5710ac367a2a1bc9d5579b45eccdf365b486168f9df01ca0af5cbb
-  data.tar.gz: 6c73c6c141da927a236674c774ec8ad3124128b3f0017e6d05ac40ae4a72a04eaf2fb9ac4d22076cd5f241b68b9c9b19cac42e5ab2cbe9bc35c6093b18b333e1
+  metadata.gz: 3bd0b541a0d948c9c320a0ed7caf4e8f5585a147ed551c7e1b1c397c119cf4a23969ac510888c0f985e1d7c00997fac896fbdc3aa850d9ba0dc0865670336bf2
+  data.tar.gz: c81b5c272398ea577e9030852410a7813a8abcad24d7ec3ea3843e36b1529a0dfd79647d80cfe12edc093dc298ea2963c45680894376405ee15d4c8a94e58fa0

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## Unreleased
+
+## 0.5.0 - 2026-08-03
+
+### Added
+
+- Added class-level `_all_later` helpers for delayed instance methods.
+- Added bulk enqueue support through `ActiveJob.perform_all_later`, with individual enqueue fallback for Rails 7.0 and adapters without bulk support.

data/README.md

@@ -9,6 +9,7 @@ A Ruby gem that makes it easy to convert any method call into a background job u
 - **Flexible Configuration**: Configure queue names, delays, and concurrency limits per method
 - **Method Parameter Support**: Full support for regular arguments, keyword arguments, and blocks
 - **Bang Method Handling**: Automatic support for methods ending with `!`
+- **Bulk Enqueuing**: Enqueue the same instance method for many receivers at once
 - **ActiveJob Integration**: Seamlessly integrates with your existing ActiveJob setup
 
 ## Installation
@@ -80,6 +81,46 @@ processor.process_csv_import_later("/tmp/users.csv", 123)
 processor.sync_external_data_later("https://api.example.com/data", 1.hour.ago)
 ```
 
+### Bulk Instance Methods
+
+Every delayed instance method also gets a class-level `_all_later` helper. It creates one job per receiver and passes the same positional and keyword arguments to each:
+
+```ruby
+class Unit
+  include Delayable
+
+  def sync_channex_availability(date_from, date_to, channel:)
+    # Sync availability for this unit
+  end
+  delay :sync_channex_availability, queue: :integrations
+end
+
+Unit.sync_channex_availability_all_later(
+  units,
+  Date.current,
+  1.year.from_now.to_date,
+  channel: :channex
+)
+```
+
+The helper preserves `Current.attributes` and all generated job configuration. A configured wait applies to every job and can be overridden per bulk call:
+
+```ruby
+Unit.sync_channex_availability_all_later(
+  units,
+  date_from,
+  date_to,
+  channel: :channex,
+  wait: 30.seconds
+)
+```
+
+Bang methods use `_all_later!`, such as `Unit.refresh_all_later!(units)`. Delayable does not remove duplicate receivers; use `units.uniq` when needed. An empty collection returns without enqueuing anything.
+
+Bulk helpers are only generated for instance methods. Delayed class methods still use their regular `_later` helper.
+
+Delayable uses `ActiveJob.perform_all_later` when available (Rails 7.1+). A true bulk queue operation requires an ActiveJob adapter that implements `enqueue_all`; otherwise ActiveJob enqueues each job individually. On Rails 7.0, Delayable also falls back to individual enqueues.
+
 ### Class Methods
 
 You can also delay class methods by setting the `class_method: true` option:
@@ -429,6 +470,7 @@ DataProcessor::ProcessCsvImportJob.queue_name
 - Ruby >= 3.4.0
 - Rails >= 7.0.4.3
 - ActiveJob configured with a backend (Sidekiq, Resque, etc.)
+- An ActiveJob adapter with `enqueue_all` support for a true bulk queue operation (optional)
 - **SolidQueue** (optional) - Required only if using `limits_concurrency` feature
 
 ## Contributing

data/lib/delayable/version.rb

@@ -1,3 +1,3 @@
 module Delayable
-  VERSION = '0.4.2'.freeze
+  VERSION = '0.5.0'.freeze
 end

data/lib/delayable.rb

@@ -25,10 +25,23 @@ module Delayable
       )
 
       defined_wait = wait
+      build_job = method(:delayable_build_job)
+      extract_wait = method(:delayable_extract_wait)
+      enqueue_jobs = method(:delayable_enqueue_jobs)
       delayable_define_method(class_method:, method_name:) do |*arguments, **kwargs|
-        wait = kwargs.key?(:wait) ? kwargs.delete(:wait) : defined_wait
-        run_data = { current_attributes: Current.attributes, record: self }
-        job.set(wait:).perform_later(run_data, *arguments, **kwargs)
+        job_wait = extract_wait.call(kwargs, defined_wait)
+        build_job.call(job, self, job_wait, arguments, kwargs, enqueue: true)
+      end
+
+      return if class_method
+
+      delayable_define_bulk_method(method_name) do |receivers, *arguments, **kwargs|
+        receivers = receivers.to_a
+        next if receivers.empty?
+
+        job_wait = extract_wait.call(kwargs, defined_wait)
+        jobs = receivers.map { |receiver| build_job.call(job, receiver, job_wait, arguments, kwargs) }
+        enqueue_jobs.call(jobs)
       end
     end
 
@@ -56,6 +69,24 @@ module Delayable
       end
     end
 
+    def delayable_build_job(job, receiver, wait, arguments, kwargs, enqueue: false)
+      run_data = { current_attributes: Current.attributes, record: receiver }
+      return job.set(wait:).perform_later(run_data, *arguments, **kwargs) if enqueue
+
+      job.new(run_data, *arguments, **kwargs).set(wait:)
+    end
+
+    def delayable_extract_wait(kwargs, defined_wait)
+      kwargs.key?(:wait) ? kwargs.delete(:wait) : defined_wait
+    end
+
+    def delayable_enqueue_jobs(jobs)
+      return ActiveJob.perform_all_later(*jobs) if ActiveJob.respond_to?(:perform_all_later)
+
+      jobs.each(&:enqueue)
+      nil
+    end
+
     def delayable_job_name(method_name, class_method: false)
       class_name = bang_method?(method_name) ? "#{method_name.to_s.chomp('!').camelize}Bang" : method_name.to_s.camelize
       :"#{'Class' if class_method}#{class_name}Job"
@@ -63,8 +94,16 @@ module Delayable
 
     def delayable_define_method(class_method:, method_name:, &)
       define_method_type = class_method ? :define_singleton_method : :define_method
-      method_name = bang_method?(method_name) ? "#{method_name.to_s.chomp('!')}_later!" : "#{method_name}_later"
-      public_send(define_method_type, method_name, &)
+      public_send(define_method_type, delayable_method_name(method_name), &)
+    end
+
+    def delayable_define_bulk_method(method_name, &)
+      define_singleton_method(delayable_method_name(method_name, bulk: true), &)
+    end
+
+    def delayable_method_name(method_name, bulk: false)
+      suffix = bulk ? '_all_later' : '_later'
+      bang_method?(method_name) ? "#{method_name.to_s.chomp('!')}#{suffix}!" : "#{method_name}#{suffix}"
     end
 
     def bang_method?(method_name)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: delayable
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Trae Robrock
 bindir: exe
 cert_chain: []
-date: 2026-07-08 00:00:00.000000000 Z
+date: 2026-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -33,6 +33,7 @@ extra_rdoc_files: []
 files:
 - ".rubocop.yml"
 - ".ruby-version"
+- CHANGELOG.md
 - MIT-LICENSE
 - README.md
 - Rakefile