acidic_job 1.0.0.rc3 → 1.0.0.rc4

data/lib/acidic_job/plugin_context.rb

@@ -4,13 +4,22 @@ module AcidicJob
   class PluginContext
     PLUGIN_INACTIVE = :__ACIDIC_JOB_PLUGIN_INACTIVE__
 
-    def initialize(plugin, job, execution, step_definition)
+    def initialize(plugin, job, execution, context, step_definition)
       @plugin = plugin
       @job = job
       @execution = execution
+      @context = context
       @step_definition = step_definition
     end
 
+    def set(hash)
+      @context.set(hash)
+    end
+
+    def get(*keys)
+      @context.get(*keys)
+    end
+
     def definition
       @step_definition.fetch(@plugin.keyword.to_s, PLUGIN_INACTIVE)
     end
@@ -40,8 +49,22 @@ module AcidicJob
       @job.enqueue(...)
     end
 
-    def halt_step!
-      @job.halt_step!
+    def halt_workflow!
+      @job.halt_workflow!
+    end
+
+    def repeat_step!
+      @job.repeat_step!
+    end
+
+    def resolve_method(method_name)
+      begin
+        method_obj = @job.method(method_name)
+      rescue NameError
+        raise UndefinedMethodError.new(method_name)
+      end
+
+      method_obj
     end
 
     def plugin_action(action)

data/lib/acidic_job/plugins/transactional_step.rb

@@ -26,10 +26,10 @@ module AcidicJob
         return yield if context.definition == false
 
         model = if context.definition == true
-                  AcidicJob::Execution
-                else
-                  context.definition["on"].constantize
-                end
+          AcidicJob::Execution
+        else
+          context.definition["on"].constantize
+        end
 
         model.transaction(&block)
       end

data/lib/acidic_job/serializer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "arguments"
+
+module AcidicJob
+  # Used for `serialize` method in ActiveRecord
+  module Serializer
+    extend self
+
+    def load(json)
+      return if json.nil? || json.empty?
+
+      data = JSON.parse json
+
+      Arguments.__send__ :deserialize_argument, data
+    end
+
+    def dump(obj)
+      data = Arguments.__send__ :serialize_argument, obj
+
+      JSON.generate data, strict: true
+    rescue ActiveJob::SerializationError => e
+      e.message << " (`#{obj.inspect}`)"
+      raise e
+    end
+  end
+end

data/lib/acidic_job/serializers/job_serializer.rb

@@ -15,7 +15,7 @@ module AcidicJob
 
       def deserialize(hash)
         job = ::ActiveJob::Base.deserialize(hash)
-        job.send(:deserialize_arguments_if_needed)
+        job.__send__(:deserialize_arguments_if_needed)
         job
       end
 

data/lib/acidic_job/serializers/range_serializer.rb

@@ -17,9 +17,7 @@ module AcidicJob
         klass.new(*Arguments.deserialize(hash.values_at(*KEYS)))
       end
 
-      private
-
-      def klass
+      private def klass
         ::Range
       end
     end

data/lib/acidic_job/testing.rb

@@ -22,25 +22,23 @@ module AcidicJob
       ::DatabaseCleaner.cleaners = @original_cleaners
     end
 
-    private
-
     # Ensure that the system's original DatabaseCleaner configuration is maintained, options included,
     # except that any `transaction` strategies for any ORMs are replaced with a `deletion` strategy.
-    def transaction_free_cleaners_for(original_cleaners)
+    private def transaction_free_cleaners_for(original_cleaners)
       non_transaction_cleaners = original_cleaners.dup.to_h do |(orm, opts), cleaner|
         [[orm, opts], ensure_no_transaction_strategies_for(cleaner)]
       end
       ::DatabaseCleaner::Cleaners.new(non_transaction_cleaners)
     end
 
-    def ensure_no_transaction_strategies_for(cleaner)
+    private def ensure_no_transaction_strategies_for(cleaner)
       return cleaner unless strategy_name_for(cleaner) == "transaction"
 
       cleaner.strategy = deletion_strategy_for(cleaner)
       cleaner
     end
 
-    def strategy_name_for(cleaner)
+    private def strategy_name_for(cleaner)
       cleaner               # <DatabaseCleaner::Cleaner>
         .strategy           # <DatabaseCleaner::ActiveRecord::Truncation>
         .class              # DatabaseCleaner::ActiveRecord::Truncation
@@ -50,19 +48,19 @@ module AcidicJob
         .downcase           # "truncation"
     end
 
-    def deletion_strategy_for(cleaner)
+    private def deletion_strategy_for(cleaner)
       strategy = cleaner.strategy
-      strategy_namespace = strategy                    # <DatabaseCleaner::ActiveRecord::Truncation>
-                           .class                      # DatabaseCleaner::ActiveRecord::Truncation
-                           .name                       # "DatabaseCleaner::ActiveRecord::Truncation"
-                           .rpartition("::")           # ["DatabaseCleaner::ActiveRecord", "::", "Truncation"]
-                           .first                      # "DatabaseCleaner::ActiveRecord"
+      strategy_namespace = strategy # <DatabaseCleaner::ActiveRecord::Truncation>
+        .class                      # DatabaseCleaner::ActiveRecord::Truncation
+        .name                       # "DatabaseCleaner::ActiveRecord::Truncation"
+        .rpartition("::")           # ["DatabaseCleaner::ActiveRecord", "::", "Truncation"]
+        .first                      # "DatabaseCleaner::ActiveRecord"
       deletion_strategy_class_name = [strategy_namespace, "::", "Deletion"].join
       deletion_strategy_class = deletion_strategy_class_name.constantize
       instance_variable_hash = strategy.instance_variables.to_h do |var|
         [
           var.to_s.remove("@"),
-          strategy.instance_variable_get(var)
+          strategy.instance_variable_get(var),
         ]
       end
       options = instance_variable_hash.except("db", "connection_class")

data/lib/acidic_job/version.rb

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

data/lib/acidic_job/workflow.rb

@@ -8,7 +8,7 @@ module AcidicJob
     HALT_STEP = :__ACIDIC_JOB_HALT_STEP_SIGNAL__
     private_constant :REPEAT_STEP, :HALT_STEP
 
-    def execute_workflow(unique_by:, with: [Plugins::TransactionalStep], &block)
+    def execute_workflow(unique_by:, with: AcidicJob.plugins, &block)
       @__acidic_job_plugins__ = with
       serialized_job = serialize
 
@@ -30,13 +30,13 @@ module AcidicJob
 
       AcidicJob.instrument(:initialize_workflow, definition: workflow_definition) do
         transaction_args = case ::ActiveRecord::Base.connection.adapter_name.downcase.to_sym
-                           # SQLite doesn't support `serializable` transactions
-                           when :sqlite
-                             {}
-                           else
-                             { isolation: :serializable }
-                           end
-        idempotency_key = Digest::SHA256.hexdigest(JSON.fast_generate([self.class.name, unique_by], strict: true))
+          # SQLite doesn't support `serializable` transactions
+          when :sqlite
+            {}
+          else
+            { isolation: :serializable }
+        end
+        idempotency_key = Digest::SHA256.hexdigest(JSON.generate([self.class.name, unique_by], strict: true))
 
         @__acidic_job_execution__ = ::ActiveRecord::Base.transaction(**transaction_args) do
           record = Execution.find_by(idempotency_key: idempotency_key)
@@ -61,11 +61,11 @@ module AcidicJob
             )
           else
             starting_point = if workflow_definition.key?("steps")
-                               workflow_definition["steps"].keys.first
-                             else
-                               # TODO: add deprecation warning
-                               workflow_definition.keys.first
-                             end
+              workflow_definition["steps"].keys.first
+            else
+              # TODO: add deprecation warning
+              workflow_definition.keys.first
+            end
 
             record = Execution.create!(
               idempotency_key: idempotency_key,
@@ -89,7 +89,7 @@ module AcidicJob
 
           current_step = @__acidic_job_execution__.recover_to
 
-          if not @__acidic_job_execution__.defined?(current_step) # rubocop:disable Style/Not
+          if not @__acidic_job_execution__.defined?(current_step)
             raise UndefinedStepError.new(current_step)
           end
 
@@ -101,11 +101,10 @@ module AcidicJob
               @__acidic_job_execution__.record!(
                 step: step_definition.fetch("does"),
                 action: :halted,
-                timestamp: Time.now
               )
               return true
             else
-              @__acidic_job_execution__.update!(recover_to: recover_to)
+              @__acidic_job_execution__.update_column(:recover_to, recover_to)
             end
           end
         end
@@ -116,14 +115,19 @@ module AcidicJob
       throw :repeat, REPEAT_STEP
     end
 
-    def halt_step!
+    def halt_workflow!
       throw :halt, HALT_STEP
     end
 
+    def halt_step!
+      # TODO add deprecation warning
+      halt_workflow!
+    end
+
     def step_retrying?
       step_name = caller_locations.first.label
 
-      if not @__acidic_job_execution__.defined?(step_name) # rubocop:disable Style/IfUnlessModifier, Style/Not
+      if not @__acidic_job_execution__.defined?(step_name)
         raise UndefinedStepError.new(step_name)
       end
 
@@ -138,9 +142,7 @@ module AcidicJob
       @__acidic_job_context__
     end
 
-    private
-
-    def take_step(step_definition)
+    private def take_step(step_definition)
       curr_step = step_definition.fetch("does")
       next_step = step_definition.fetch("then")
 
@@ -148,7 +150,7 @@ module AcidicJob
 
       rescued_error = nil
       begin
-        @__acidic_job_execution__.record!(step: curr_step, action: :started, timestamp: Time.now)
+        @__acidic_job_execution__.record!(step: curr_step, action: :started)
         result = AcidicJob.instrument(:perform_step, **step_definition) do
           perform_step_for(step_definition)
         end
@@ -156,10 +158,16 @@ module AcidicJob
         when REPEAT_STEP
           curr_step
         else
-          @__acidic_job_execution__.record!(step: curr_step, action: :succeeded, timestamp: Time.now, result: result)
+          @__acidic_job_execution__.record!(
+            step: curr_step,
+            action: :succeeded,
+            ignored: {
+              result: result,
+            }
+          )
           next_step
         end
-      rescue StandardError => e
+      rescue => e
         rescued_error = e
         raise e
       ensure
@@ -168,11 +176,10 @@ module AcidicJob
             @__acidic_job_execution__.record!(
               step: curr_step,
               action: :errored,
-              timestamp: Time.now,
               exception_class: rescued_error.class.name,
               message: rescued_error.message
             )
-          rescue StandardError => e
+          rescue => e
             # We're already inside an error condition, so swallow any additional
             # errors from here and just send them to logs.
             logger.error(
@@ -183,7 +190,7 @@ module AcidicJob
       end
     end
 
-    def perform_step_for(step_definition)
+    private def perform_step_for(step_definition)
       step_name = step_definition.fetch("does")
       begin
         step_method = method(step_name)
@@ -191,10 +198,10 @@ module AcidicJob
         raise UndefinedMethodError.new(step_name)
       end
 
-      raise InvalidMethodError.new(step_name) unless step_method.arity.zero?
+      # raise InvalidMethodError.new(step_name) unless step_method.arity.zero?
 
       plugin_pipeline_callable = @__acidic_job_plugins__.reverse.reduce(step_method) do |callable, plugin|
-        context = PluginContext.new(plugin, self, @__acidic_job_execution__, step_definition)
+        context = PluginContext.new(plugin, self, @__acidic_job_execution__, @__acidic_job_context__, step_definition)
 
         if context.inactive?
           callable
@@ -202,14 +209,19 @@ module AcidicJob
           proc do
             called = false
 
-            result = plugin.around_step(context) do
+            result = plugin.around_step(context) do |*args, **kwargs|
               raise DoublePluginCallError.new(plugin, step_name) if called
 
               called = true
-              callable.call
+
+              if callable.arity.zero?
+                callable.call
+              else
+                callable.call(*args, **kwargs)
+              end
             end
 
-            raise MissingPluginCallError.new(plugin, step_name) unless called
+            # raise MissingPluginCallError.new(plugin, step_name) unless called
 
             result
           end

data/lib/acidic_job.rb

@@ -9,6 +9,7 @@ require_relative "acidic_job/arguments"
 require_relative "acidic_job/plugin_context"
 require_relative "acidic_job/plugins/transactional_step"
 require_relative "acidic_job/log_subscriber"
+require_relative "acidic_job/serializer"
 require_relative "acidic_job/workflow"
 
 require "active_support"
@@ -21,6 +22,8 @@ module AcidicJob
 
   mattr_accessor :logger, default: DEFAULT_LOGGER
   mattr_accessor :connects_to
+  mattr_accessor :plugins, default: [Plugins::TransactionalStep]
+  mattr_accessor :clear_finished_executions_after, default: 1.week
 
   def instrument(channel, **options, &block)
     ActiveSupport::Notifications.instrument("#{channel}.acidic_job", **options.deep_symbolize_keys, &block)

data/lib/generators/acidic_job/install_generator.rb

@@ -12,13 +12,13 @@ module AcidicJob
 
       # Copies the migration template to db/migrate.
       def copy_acidic_job_runs_migration_files
-        migration_template "create_acidic_job_tables_migration.rb.erb",
-                           "db/migrate/create_acidic_job_tables.rb",
-                           migration_version: migration_version
+        migration_template(
+          "create_acidic_job_tables_migration.rb.erb",
+          "db/migrate/create_acidic_job_tables.rb",
+          migration_version: migration_version
+        )
       end
 
-      protected
-
       def migration_version
         "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
       end

data/lib/generators/acidic_job/templates/create_acidic_job_tables_migration.rb.erb

@@ -2,30 +2,30 @@ class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version
   def change
     create_table :acidic_job_executions, force: true do |t|
       t.string      :idempotency_key, null: false,  index: { unique: true }
-      t.json        :serialized_job, 	null: false,  default: "{}"
+      t.json        :serialized_job, 	null: false
       t.datetime    :last_run_at, 		null: true
       t.datetime    :locked_at, 			null: true
       t.string      :recover_to, 	    null: true
-      t.json        :definition, 			null: true,   default: "{}"
+      t.text        :definition, 			null: true
 
       t.timestamps
     end
 
     create_table :acidic_job_entries do |t|
-      t.references :execution, null: false, foreign_key: { to_table: :acidic_job_executions }
+      t.references :execution, null: false, foreign_key: { to_table: :acidic_job_executions, on_delete: :cascade }
       t.string     :step,      null: false
       t.string     :action,    null: false
       t.datetime   :timestamp, null: false
-      t.json       :data,      null: true,  default: "{}"
+      t.text       :data,      null: true
 
       t.timestamps
     end
     add_index :acidic_job_entries, [:execution_id, :step, :action]
 
     create_table :acidic_job_values do |t|
-      t.references :execution, null: false, foreign_key: { to_table: :acidic_job_executions }
+      t.references :execution, null: false, foreign_key: { to_table: :acidic_job_executions, on_delete: :cascade }
       t.string     :key,       null: false
-      t.json       :value,     null: false, default: "{}"
+      t.text       :value,     null: false
 
       t.timestamps
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: acidic_job
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc3
+  version: 1.0.0.rc4
 platform: ruby
 authors:
 - fractaledmind
 bindir: exe
 cert_chain: []
-date: 2025-05-16 00:00:00.000000000 Z
+date: 2025-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -163,34 +163,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -230,6 +202,7 @@ files:
 - ".github/FUNDING.yml"
 - ".github/workflows/main.yml"
 - ".gitignore"
+- ".rubocop-https---www-goodcop-style-base-yml"
 - ".rubocop.yml"
 - ".ruby-version"
 - Gemfile
@@ -262,6 +235,7 @@ files:
 - lib/acidic_job/log_subscriber.rb
 - lib/acidic_job/plugin_context.rb
 - lib/acidic_job/plugins/transactional_step.rb
+- lib/acidic_job/serializer.rb
 - lib/acidic_job/serializers/exception_serializer.rb
 - lib/acidic_job/serializers/job_serializer.rb
 - lib/acidic_job/serializers/new_record_serializer.rb