acidic_job 1.0.0.pre20 → 1.0.0.pre21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e608eefef4baffbfb2c95dcbef942a53c9ca242c4c593ddbbe0d677ef7d318da
-  data.tar.gz: 65bed32739c1a1a860102e59dac69598c4357512034d8d3e87ed772469b9bac0
+  metadata.gz: f47391c0a8bdb8c62c967d716d0190eeddc5ebdd28af81309ffea17ae58f52b2
+  data.tar.gz: 575abae7eb9f70a81537b3260fa8a5ac76d64c231936f0f8e4d96b9e4be116d7
 SHA512:
-  metadata.gz: 5a5f6155e20f929c631392f00480f57928455778e13117609457be9b8624e7f16c41661df96ae34a4045582f957b044cbdf811bfa7e187dd627b8b72b80edb90
-  data.tar.gz: 6a663d288bd1ef3ba5cfac8e137fd496ebbca76e08573e50d706ed2570c98b6fe3148b8c9335b55313a091ccd0cc226e3b9023878dd418d400af33fd0280c1b4
+  metadata.gz: 6d325fad1fb3240a6cf56d5b8d683b4bf4a0ab8b44c68173141d96fc7ca23a4c8d9f9fcf36d3410ed74f6dec9c16ef4739a642bb09e106050f1a21bc473e3a82
+  data.tar.gz: 355057c6f50d2b37a1b5837247d0d54b9e40e9fedc5793115a607bf9c03353e9ae5f847624608778ee54bdc1bfb950888c33b5ff6db96cb42f83001582571377

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    acidic_job (1.0.0.pre20)
+    acidic_job (1.0.0.pre21)
       activerecord
       activesupport
       database_cleaner

data/README.md

@@ -269,6 +269,25 @@ class RideCreateJob < ActiveJob::Base
 end
 ```
 
+If you need to await a job that takes arguments, you can prepare that job along with its arguments using the `with` class method that `acidic_job` will add to your jobs:
+
+```ruby
+class RideCreateJob < ActiveJob::Base
+  include AcidicJob
+
+  def perform(user_id, ride_params)
+    @user = User.find(user_id)
+    @params = ride_params
+
+    with_acidity providing: { ride: nil } do
+      step :create_ride_and_audit_record, awaits: [SomeJob]
+      step :create_stripe_charge, args: [1, 2, 3], kwargs: { some: 'thing' }
+      step :send_receipt
+    end
+  end
+end
+```
+
 ### Run Finished Callbacks
 
 When working with workflow jobs that make use of the `awaits` feature for a step, it is important to remember that the `after_perform` callback will be called _as soon as the first `awaits` step has enqueued job_, and **not** when the entire job run has finished. `acidic_job` allows the `perform` method to finish so that the queue for the workflow job is cleared to pick up new work while the `awaits` jobs are running. `acidic_job` will automatically re-enqueue the workflow job and progress to the next step when all of the `awaits` jobs have successfully finished. However, this means that `after_perform` **is not necessarily** the same as `after_finish`. In order to provide the opportunity for you to execute callback logic _if and only if_ a job run has finished, we provide callback hooks for the `finish` event.
@@ -285,7 +304,7 @@ class RideCreateJob < ActiveJob::Base
     @params = ride_params
 
     with_acidity providing: { ride: nil } do
-      step :create_ride_and_audit_record, awaits: [SomeJob]
+      step :create_ride_and_audit_record, awaits: [SomeJob.with('argument_1', keyword: 'value')]
       step :create_stripe_charge, args: [1, 2, 3], kwargs: { some: 'thing' }
       step :send_receipt
     end
@@ -299,6 +318,8 @@ class RideCreateJob < ActiveJob::Base
 end
 ```
 
+You can also await a batch of jobs by simply passing multiple jobs to the `awaits` array (e.g. `awaits: [SomeJob, AnotherJob.with('argument_1', keyword: 'value')]`). Your top level workflow job will only continue to the next step once all of the jobs in your `awaits` array have successfully finished.
+
 ## Testing
 
 When testing acidic jobs, you are likely to run into `ActiveRecord::TransactionIsolationError`s:

data/lib/acidic_job/awaiting.rb

@@ -6,6 +6,8 @@ module AcidicJob
   module Awaiting
     extend ActiveSupport::Concern
 
+    private
+
     def enqueue_step_parallel_jobs(jobs, run, step_result)
       # `batch` is available from Sidekiq::Pro
       raise SidekiqBatchRequired unless defined?(Sidekiq::Batch)
@@ -16,27 +18,22 @@ module AcidicJob
         :success,
         "#{self.class.name}#step_done",
         # NOTE: options are marshalled through JSON so use only basic types.
-        { "run_id" => run.id,
+        {
+          "run_id" => run.id,
           "step_result_yaml" => step_result.to_yaml.strip,
           "parent_worker" => self.class.name,
-          "job_names" => jobs.map(&:to_s) }
+          "job_names" => jobs.map { |job| job_name(job) }
+        }
       )
 
       # NOTE: The jobs method is atomic.
       # All jobs created in the block are actually pushed atomically at the end of the block.
       # If an error is raised, none of the jobs will go to Redis.
       step_batch.jobs do
-        jobs.each do |worker_name|
-          # TODO: handle Symbols as well
-          worker = worker_name.is_a?(String) ? worker_name.constantize : worker_name
-
-          if worker.instance_method(:perform).arity.presence_in [0, -1]
-            worker.perform_async
-          elsif worker.instance_method(:perform).arity == 1
-            worker.perform_async(run.id)
-          else
-            raise TooManyParametersForParallelJob
-          end
+        jobs.each do |job|
+          worker, args, kwargs = job_args_and_kwargs(job)
+
+          worker.perform_async(*args, **kwargs)
         end
       end
     end
@@ -53,5 +50,33 @@ module AcidicJob
       # when a batch of jobs for a step succeeds, we begin processing the `AcidicJob::Run` record again
       process_run(run)
     end
+
+    def job_name(job)
+      case job
+      when Class, Symbol
+        job.to_s
+      when String
+        job
+      else
+        job.class.name
+      end
+    end
+
+    def job_args_and_kwargs(job)
+      case job
+      when Class
+        [job, [], {}]
+      when String
+        [job.constantize, [], {}]
+      when Symbol
+        [job.to_s.constantize, [], {}]
+      else
+        [
+          job.class,
+          job.instance_variable_get(:@__acidic_job_args),
+          job.instance_variable_get(:@__acidic_job_kwargs)
+        ]
+      end
+    end
   end
 end

data/lib/acidic_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AcidicJob
-  VERSION = "1.0.0.pre20"
+  VERSION = "1.0.0.pre21"
 end

data/lib/acidic_job.rb

@@ -68,6 +68,10 @@ module AcidicJob
       super
     end
 
+    def with(*args, **kwargs)
+      new(*args, **kwargs)
+    end
+
     def acidic_identifier
       @acidic_identifier
     end
@@ -79,11 +83,11 @@ module AcidicJob
     @__acidic_job_args = args
     @__acidic_job_kwargs = kwargs
 
-    if method(__method__).super_method.arity.zero?
-      super()
-    else
-      super(*args, **kwargs)
-    end
+    super(*args, **kwargs)
+  rescue ArgumentError => e
+    raise e unless e.message.include?("wrong number of arguments")
+
+    super()
   end
 
   def with_acidity(providing: {})

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acidic_job
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre20
+  version: 1.0.0.pre21
 platform: ruby
 authors:
 - fractaledmind
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-16 00:00:00.000000000 Z
+date: 2022-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord