acidic_job 0.8.2 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a84bc161e4771a11415d7b9bcc9be10cd703242f43ee69bcc1f139e05e93367c
-  data.tar.gz: 353e0abc18c50d946817e0263517d8efebd6d842a5186f362355da9d2382ac7a
+  metadata.gz: 54586a38aa48a14ef168657659a81b0db14446d011bd76085641dd4fb21f7838
+  data.tar.gz: 849af5f8e34684cd22d454f85ac816e749c3a4dd91ba58dba34ce67931916d3c
 SHA512:
-  metadata.gz: 6009e9a0b132da090454d1ea6c70f852c53169f5a5842f5cd982cc7b167df0a20f2a3dd534879c058b6ffbf2a305ba88f39020b1c92c099ae0d4e76f48b905ff
-  data.tar.gz: abee47aaa85eed503f0af7e3c3c27b2f6a3c3ed04fd4456d3a9ff743e097db1215409039cbc4c86dccb07cffb073f2e06dcefbf043cf56dc4ad2a83fc64ff624
+  metadata.gz: fe54d708708a8316020979400dda7afd73480d34597f9416b30218b7307d8e4ce3cfbf65e14e05681810de88e21d131f06f4a3f72549a7dedef62be209b3137d
+  data.tar.gz: 58ba97af8e30c9bff0df8cf4015a3920ce722a5242048469b2224a4d9ca32c67971f03792862c2548515adc33b8407309c386ab1ff1dd509735f420029c11085

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    acidic_job (0.8.2)
+    acidic_job (0.8.5)
       activejob
       activerecord
       activesupport

data/README.md

@@ -1,7 +1,10 @@
 # AcidicJob
 
-[![Gem Version](https://badge.fury.io/rb/acidic_job.svg)](https://badge.fury.io/rb/acidic_job)
-![main workflow](https://github.com/fractaledmind/acidic_job/actions/workflows/main.yml/badge.svg)
+[![Gem Version](https://badge.fury.io/rb/acidic_job.svg)](https://rubygems.org/gems/acidic_job)
+[![Gem Downloads](https://img.shields.io/gem/dt/acidic_job)](https://rubygems.org/gems/acidic_job)
+![Tests](https://github.com/fractaledmind/acidic_job/actions/workflows/main.yml/badge.svg)
+![Coverage](https://img.shields.io/badge/code%20coverage-98%25-success)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/e0df63f7a6f141d4aecc3c477314fdb2)](https://www.codacy.com/gh/fractaledmind/acidic_job/dashboard?utm_source=github.com&utm_medium=referral&utm_content=fractaledmind/acidic_job&utm_campaign=Badge_Grade)
 
 ## Idempotent operations for Rails apps (for ActiveJob or Sidekiq)
 
@@ -306,24 +309,22 @@ class ExampleJob < AcidicJob::Base
 end
 ```
 
-These options cover the two common situations, but sometimes our systems need finer-grained control. For example, our job might take some record as the job argument, but we need to use a combination of the record identifier and record status as the foundation for the idempotency key. In these cases you can pass a `Proc` to an `acidic_by` class method:
+These options cover the two common situations, but sometimes our systems need finer-grained control. For example, our job might take some record as the job argument, but we need to use a combination of the record identifier and record status as the foundation for the idempotency key. In these cases you can pass a `Proc` or a `Block` to an `acidic_by` class method. This code will be executed in the context of the newly initialized job instance, so you will have access to whatever data the job is initialized with (like the `arguments`, for example):
 
 ```ruby
 class ExampleJob < AcidicJob::Base
-  acidic_by -> { [@record.id, @record.status] }
+  acidic_by do
+    record = arguments.first[:record]
+    [record.id, record.status]
+  end
 
   def perform(record:)
-    @record = record
-
-    # the idempotency key will be based on whatever the values of `@record.id` and `@record.status` are
-    with_acidic_workflow do |workflow|
-      workflow.step :do_something
-    end
+    # ...
   end
 end
 ```
 
-> **Note:** The `acidic_by` proc _will be executed in the context of the job instance_ at the moment the `with_acidic_workflow` method is called. This means it will have access to any instance variables defined in your `perform` method up to that point.
+> **Note:** The `acidic_by` proc/block _will be executed in the context of the job instance_ at the moment the job is initialized. This means it will **not** have access to any instance variables defined in your `perform` method.
 
 
 ### Sidekiq Callbacks

data/lib/acidic_job/active_kiq.rb

@@ -13,11 +13,29 @@ module AcidicJob
     define_callbacks :perform
     include Mixin
 
+    concerning :Configuring do
+      # Configures the job with the given options.
+      def set(options = {}) # :nodoc:
+        self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait]
+        self.scheduled_at = options[:wait_until].to_f if options[:wait_until]
+        self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
+
+        self
+      end
+    end
+
     concerning :Initializing do
+      class_methods do
+        def job_or_instantiate(*args)
+          args.first.is_a?(self) ? args.first : new(*args)
+        end
+      end
+
       included do
         attr_accessor :arguments
         attr_accessor :job_id
         attr_accessor :queue_name
+        attr_accessor :scheduled_at
         attr_accessor :sidekiq_options
       end
       ##
@@ -25,8 +43,8 @@ module AcidicJob
       # +args+ are the arguments, if any, that will be passed to the perform method
       # +opts+ are any options to configure the job
       def initialize(*arguments)
-        @arguments  = arguments
-        @job_id     = ::SecureRandom.uuid
+        @arguments = arguments
+        @job_id = ::SecureRandom.uuid
         @sidekiq_options = sidekiq_options_hash || ::Sidekiq.default_job_options
         @queue_name = @sidekiq_options["queue"]
       end
@@ -43,22 +61,33 @@ module AcidicJob
 
     concerning :Performing do
       class_methods do
-        def perform_now(*args, **kwargs)
-          new.perform(*args, **kwargs)
+        def perform_later(*args)
+          perform_async(*args)
+        end
+
+        def perform_now(*args)
+          perform_inline(*args)
         end
       end
 
-      def perform_now(*args, **kwargs)
-        perform(*args, **kwargs)
+      def perform_later(*args)
+        Setter.new(self.class, {}).perform_async(*args)
+      end
+
+      def perform_now(*args)
+        Setter.new(self.class, {}).perform_inline(*args)
       end
 
       def enqueue
-        ::Sidekiq::Client.push(
+        item = {
           "class" => self.class,
           "args" => @arguments,
           "jid" => @job_id,
           "queue" => @queue_name
-        )
+        }
+        item["at"] = @scheduled_at if @scheduled_at
+
+        ::Sidekiq::Client.push(item)
       end
     end
 

data/lib/acidic_job/configured_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "active_job/configured_job"
+
+module AcidicJob
+  class ConfiguredJob < ::ActiveJob::ConfiguredJob
+    def perform_acidicly(...)
+      @job_class.new(...).set(@options).perform_acidicly
+    end
+  end
+end

data/lib/acidic_job/mixin.rb

@@ -10,6 +10,8 @@ module AcidicJob
       # Ensure our `perform` method always runs first to gather parameters
       # and run perform callbacks for Sidekiq workers
       other.prepend PerformWrapper
+      # Ensure both configured and base jobs can be performed acidicly
+      other.include PerformAcidicly
 
       # By default, we unique job runs by the `job_id`
       other.instance_variable_set(:@acidic_identifier, :job_id)
@@ -18,7 +20,7 @@ module AcidicJob
       # You could unique job runs by the arguments passed to the job (e.g. memoization)
       other.define_singleton_method(:acidic_by_job_arguments) { @acidic_identifier = :job_arguments }
       # Or, you could unique jobs run by any logic you'd like using a block
-      other.define_singleton_method(:acidic_by) { |&block| @acidic_identifier = block }
+      other.define_singleton_method(:acidic_by) { |proc = nil, &block| @acidic_identifier = proc || block }
 
       # We add a callback to ensure that staged, non-workflow jobs are "finished" after they are "performed".
       # This allows us to ensure that we can always inspect whether a run is finished and get correct data
@@ -40,19 +42,6 @@ module AcidicJob
         super
       end
 
-      # `perform_now` runs a job synchronously and immediately
-      # `perform_later` runs a job asynchronously and queues it immediately
-      # `perform_acidicly` run a job asynchronously and queues it after a successful database commit
-      def perform_acidicly(*args, **kwargs)
-        job = if kwargs.empty?
-                new(*args)
-              else
-                new(*args, **kwargs)
-              end
-
-        Run.stage!(job)
-      end
-
       # Instantiate an instance of a job ready for serialization
       def with(...)
         # New delegation syntax (...) was introduced in Ruby 2.7.
@@ -62,12 +51,26 @@ module AcidicJob
         job.queue_name
         job
       end
+
+      def set(options = {})
+        ::AcidicJob::ConfiguredJob.new(self, options)
+      end
     end
 
     def idempotency_key
       IdempotencyKey.new(self).value(acidic_by: acidic_identifier)
     end
 
+    # Configures the job with the given options.
+    def set(options = {}) # :nodoc:
+      self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait]
+      self.scheduled_at = options[:wait_until].to_f if options[:wait_until]
+      self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
+      self.priority     = options[:priority].to_i if options[:priority]
+
+      self
+    end
+
     protected
 
     # Short circuits execution by sending execution right to 'finished'.

data/lib/acidic_job/perform_acidicly.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module AcidicJob
+  module PerformAcidicly
+    extend ActiveSupport::Concern
+
+    # `perform_now` runs a job synchronously and immediately
+    # `perform_later` runs a job asynchronously and queues it immediately
+    # `perform_acidicly` run a job asynchronously and queues it after a successful database commit
+
+    class_methods do
+      def perform_acidicly(...)
+        job_or_instantiate(...).perform_acidicly
+      end
+    end
+
+    def perform_acidicly
+      Run.stage!(self)
+    end
+  end
+end

data/lib/acidic_job/rails.rb

@@ -20,14 +20,17 @@ module AcidicJob
           Serializers::JobSerializer,
           Serializers::RangeSerializer,
           Serializers::RecoveryPointSerializer,
-          Serializers::WorkerSerializer
+          Serializers::WorkerSerializer,
+          Serializers::ActiveKiqSerializer
         )
       end
     end
 
+    # :nocov:
     generators do
       require "generators/acidic_job/install_generator"
     end
+    # :nocov:
 
     # This hook happens after all initializers are run, just before returning
     config.after_initialize do

data/lib/acidic_job/serializers/active_kiq_serializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_job/serializers/object_serializer"
+
+module AcidicJob
+  module Serializers
+    class ActiveKiqSerializer < ::ActiveJob::Serializers::ObjectSerializer
+      def serialize(worker)
+        super(
+          "job_class" => worker.class.name,
+          "arguments" => Arguments.serialize(worker.arguments),
+        )
+      end
+
+      def deserialize(hash)
+        worker_class = hash["job_class"].constantize
+        worker_class.new(*hash["arguments"])
+      end
+
+      def serialize?(argument)
+        defined?(::AcidicJob::ActiveKiq) && argument.class < ::AcidicJob::ActiveKiq
+      end
+    end
+  end
+end

data/lib/acidic_job/serializers/exception_serializer.rb

@@ -13,7 +13,7 @@ module AcidicJob
           "backtrace" => {}
         }
 
-        exception.backtrace.map do |trace|
+        exception&.backtrace&.map do |trace|
           path, _, location = trace.rpartition("/")
 
           next if hash["backtrace"].key?(path)

data/lib/acidic_job/serializers/job_serializer.rb

@@ -10,7 +10,7 @@ module AcidicJob
         # by comparing the deserialized database value with a temporary in-memory generated value.
         # That temporary in-memory generated value can sometimes have an `enqueued_at` value that is 1 second off
         # from the original. In this case, ActiveRecord will think the record has unsaved changes and block the lock.
-        super(job.as_json.merge("job_class" => job.class.name))
+        super(job.serialize.except("enqueued_at"))
       end
 
       def deserialize(hash)

data/lib/acidic_job/serializers/worker_serializer.rb

@@ -2,26 +2,24 @@
 
 require "active_job/serializers/object_serializer"
 
-# :nocov:
 module AcidicJob
   module Serializers
     class WorkerSerializer < ::ActiveJob::Serializers::ObjectSerializer
       def serialize(worker)
         super(
-          "job_class" => worker.class.name,
-          "arguments" => worker.arguments,
+          "job_class" => worker.class.name
         )
       end
 
       def deserialize(hash)
         worker_class = hash["job_class"].constantize
-        worker_class.new(*hash["arguments"])
+        worker_class.new
       end
 
       def serialize?(argument)
-        defined?(::Sidekiq) && argument.class.include?(::Sidekiq::Worker)
+        defined?(::Sidekiq) && argument.class.include?(::Sidekiq::Worker) &&
+          !(defined?(::AcidicJob::ActiveKiq) && argument.class < ::AcidicJob::ActiveKiq)
       end
     end
   end
 end
-# :nocov:

data/lib/acidic_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AcidicJob
-  VERSION = "0.8.2"
+  VERSION = "0.8.5"
 end

data/lib/acidic_job.rb

@@ -5,6 +5,7 @@ require_relative "acidic_job/errors"
 require_relative "acidic_job/logger"
 require_relative "acidic_job/arguments"
 require_relative "acidic_job/serializer"
+require_relative "acidic_job/configured_job"
 require_relative "acidic_job/workflow_builder"
 require_relative "acidic_job/idempotency_key"
 require_relative "acidic_job/recovery_point"
@@ -14,6 +15,7 @@ require_relative "acidic_job/workflow_step"
 require_relative "acidic_job/workflow"
 require_relative "acidic_job/processor"
 require_relative "acidic_job/perform_wrapper"
+require_relative "acidic_job/perform_acidicly"
 require_relative "acidic_job/extensions/action_mailer"
 require_relative "acidic_job/extensions/noticed"
 require_relative "acidic_job/mixin"
@@ -27,6 +29,7 @@ require_relative "acidic_job/serializers/job_serializer"
 require_relative "acidic_job/serializers/range_serializer"
 require_relative "acidic_job/serializers/recovery_point_serializer"
 require_relative "acidic_job/serializers/worker_serializer"
+require_relative "acidic_job/serializers/active_kiq_serializer"
 
 require_relative "acidic_job/rails"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acidic_job
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.8.5
 platform: ruby
 authors:
 - fractaledmind
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-17 00:00:00.000000000 Z
+date: 2022-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -253,6 +253,7 @@ files:
 - lib/acidic_job/active_kiq.rb
 - lib/acidic_job/arguments.rb
 - lib/acidic_job/base.rb
+- lib/acidic_job/configured_job.rb
 - lib/acidic_job/errors.rb
 - lib/acidic_job/extensions/action_mailer.rb
 - lib/acidic_job/extensions/noticed.rb
@@ -260,12 +261,14 @@ files:
 - lib/acidic_job/idempotency_key.rb
 - lib/acidic_job/logger.rb
 - lib/acidic_job/mixin.rb
+- lib/acidic_job/perform_acidicly.rb
 - lib/acidic_job/perform_wrapper.rb
 - lib/acidic_job/processor.rb
 - lib/acidic_job/rails.rb
 - lib/acidic_job/recovery_point.rb
 - lib/acidic_job/run.rb
 - lib/acidic_job/serializer.rb
+- lib/acidic_job/serializers/active_kiq_serializer.rb
 - lib/acidic_job/serializers/exception_serializer.rb
 - lib/acidic_job/serializers/finished_point_serializer.rb
 - lib/acidic_job/serializers/job_serializer.rb