acidic_job 1.0.0.beta.10 → 1.0.0.pre1

data/lib/acidic_job/workflow.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module AcidicJob
-  class Workflow
-    # { "step 1": { does: "step 1", awaits: [], then: "step 2" }, ...  }
-    def initialize(run, job, step_result = nil)
-      @run = run
-      @job = job
-      @step_result = step_result
-    end
-
-    def execute_current_step
-      rescued_error = false
-
-      begin
-        run_current_step
-      rescue StandardError => e
-        rescued_error = e
-        raise e
-      ensure
-        if rescued_error
-          begin
-            @run.store_error!(rescued_error)
-          rescue StandardError => e
-            # We're already inside an error condition, so swallow any additional
-            # errors from here and just send them to logs.
-            AcidicJob.logger.error("Failed to unlock AcidicJob::Run #{@run.id} because of #{e}.")
-          end
-        end
-      end
-
-      # be sure to return the `step_result`
-      # which is set by `run_current_step`
-      # which runs the (wrapped) current step method
-      @step_result
-    end
-
-    def progress_to_next_step
-      return if @run.current_step_finished?
-      return run_step_result unless @run.next_step_finishes?
-
-      @job.run_callbacks :finish do
-        run_step_result
-      end
-    end
-
-    private
-
-    def run_current_step
-      wrapped_method = WorkflowStep.new(run: @run, job: @job).wrapped
-      current_step = @run.current_step_name
-
-      AcidicJob.logger.log_run_event("Executing #{current_step}...", @job, @run)
-      @run.with_lock do
-        @step_result = wrapped_method.call(@run)
-      end
-      AcidicJob.logger.log_run_event("Executed #{current_step}.", @job, @run)
-    end
-
-    def run_step_result
-      next_step = @run.next_step_name
-
-      AcidicJob.logger.log_run_event("Progressing to #{next_step}...", @job, @run)
-      @run.with_lock do
-        @step_result.call(run: @run)
-      end
-      AcidicJob.logger.log_run_event("Progressed to #{next_step}.", @job, @run)
-    end
-  end
-end

data/lib/acidic_job/workflow_builder.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module AcidicJob
-  class WorkflowBuilder
-    attr_reader :steps
-
-    def initialize
-      @steps = []
-    end
-
-    def step(method_name, awaits: [], for_each: nil)
-      @steps << {
-        "does" => method_name.to_s,
-        "awaits" => awaits,
-        "for_each" => for_each
-      }
-
-      @steps
-    end
-    alias_method "✅", :step
-
-    def define_workflow
-      # [ { does: "step 1", awaits: [] }, { does: "step 2", awaits: [] }, ... ]
-      @steps << { "does" => Run::FINISHED_RECOVERY_POINT.to_s }
-
-      {}.tap do |workflow|
-        @steps.each_cons(2).map do |enter_step, exit_step|
-          enter_name = enter_step["does"]
-          workflow[enter_name] = enter_step.merge("then" => exit_step["does"])
-        end
-      end
-      # { "step 1": { does: "step 1", awaits: [], then: "step 2" }, ...  }
-    end
-  end
-end

data/lib/acidic_job/workflow_step.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module AcidicJob
-  class WorkflowStep
-    def initialize(run:, job:)
-      @run = run
-      @job = job
-    end
-
-    def wrapped
-      # return a callable Proc with a consistent interface for the execution phase
-      proc do |_run|
-        current_step_result = process_current_step
-
-        if current_step_result.is_a?(FinishedPoint)
-          current_step_result
-        elsif next_item.present?
-          @run.attr_accessors[iterated_key] = prev_iterateds + [next_item]
-          @run.save!(validate: false)
-          RecoveryPoint.new(current_step_name)
-        elsif @run.next_step_finishes?
-          FinishedPoint.new
-        else
-          RecoveryPoint.new(@run.next_step_name)
-        end
-      end
-    end
-
-    private
-
-    def process_current_step
-      result = nil
-
-      if iterable_key.present? && next_item.present? # have an item to iterate over, so pass it to the step method
-        result = current_callable.call(next_item)
-      elsif iterable_key.present? && next_item.nil? # have iterated over all items
-        result = true
-      elsif current_callable.arity.zero?
-        result = current_callable.call
-      else
-        raise TooManyParametersForStepMethod
-      end
-
-      result
-    end
-
-    def current_callable
-      return @job.method(current_step_name) if @job.respond_to?(current_step_name, _include_private = true)
-      # jobs can have no-op steps, especially so that they can use only the async/await mechanism for that step
-      return proc {} if @run.current_step_hash["awaits"].present?
-
-      raise UndefinedStepMethod
-    end
-
-    def iterable_key
-      # the `iterable_key` represents the name of the collection accessor
-      # that must be present in `@run.attr_accessors`; that is,
-      # it must have been passed to `persisting` when calling `with_acidic_workflow`
-      for_each = @run.current_step_hash["for_each"]
-
-      return unless for_each.present?
-
-      return for_each if @run.attr_accessors.key?(for_each)
-
-      raise UnknownForEachCollection
-    end
-
-    def iterated_key
-      # in order to ensure we don't iterate over successfully iterated values in previous runs,
-      # we need to store the collection of already processed values.
-      # we store this collection under a key bound to the current step to ensure multiple steps
-      # can iterate over the same collection.
-      "processed_#{current_step_name}_#{iterable_key}"
-    end
-
-    def prev_iterables
-      # The collection of values to iterate over
-      iterables = @run.attr_accessors.fetch(iterable_key, [])
-
-      return Array(iterables) if iterables.is_a?(Enumerable)
-
-      raise UniterableForEachCollection
-    end
-
-    def prev_iterateds
-      # The collection of values already iterated over
-      iterateds = @run.attr_accessors.fetch(iterated_key, [])
-
-      Array(iterateds)
-    end
-
-    def next_item
-      # The collection of values to iterate over now
-      curr_iterables = prev_iterables - prev_iterateds
-
-      curr_iterables.first
-    end
-
-    def current_step_name
-      @run.current_step_name
-    end
-  end
-end

data/lib/generators/acidic_job/drop_tables_generator.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators/active_record"
-
-module AcidicJob
-  module Generators
-    class DropTablesGenerator < ::Rails::Generators::Base
-      include ActiveRecord::Generators::Migration
-      source_root File.expand_path("templates", __dir__)
-
-      desc "Drops the pre-1.0 tables for the AcidicJob::Key and AcidicJob::Staged models."
-
-      def copy_migration
-        migration_template "drop_acidic_job_keys_migration.rb.erb",
-                           "db/migrate/drop_old_acidic_job_tables.rb",
-                           migration_version: migration_version
-      end
-
-      protected
-
-      def migration_version
-        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
-      end
-    end
-  end
-end

data/lib/generators/acidic_job/install_generator.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators/active_record"
-
-module AcidicJob
-  module Generators
-    class InstallGenerator < ::Rails::Generators::Base
-      include ActiveRecord::Generators::Migration
-      source_root File.expand_path("templates", __dir__)
-
-      desc "Generates a migration for the AcidicJob::Run table."
-
-      # Copies the migration template to db/migrate.
-      def copy_acidic_job_runs_migration_files
-        migration_template "create_acidic_job_runs_migration.rb.erb",
-                           "db/migrate/create_acidic_job_runs.rb",
-                           migration_version: migration_version
-      end
-
-      protected
-
-      def migration_version
-        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
-  def change
-    create_table :acidic_job_runs do |t|
-      t.boolean     :staged, 					null: false,  default: -> { false }
-      t.string      :idempotency_key, null: false,  index: { unique: true }
-      t.text        :serialized_job, 	null: false
-      t.string      :job_class, 			null: false
-      t.datetime    :last_run_at, 		null: true,   default: -> { "CURRENT_TIMESTAMP" }
-      t.datetime    :locked_at, 			null: true
-      t.string      :recovery_point, 	null: true
-      t.text        :error_object, 		null: true
-      t.text        :attr_accessors, 	null: true
-      t.text        :workflow, 				null: true
-      t.references  :awaited_by,      null: true,   index: true
-      t.text        :returning_to,    null: true
-      t.timestamps
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
-  def change
-    drop_table :acidic_job_keys do |t|
-      t.string :idempotency_key, null: false
-      t.string :job_name, null: false
-      t.text :job_args, null: true
-      t.datetime :last_run_at, null: false, default: -> { "CURRENT_TIMESTAMP" }
-      t.datetime :locked_at, null: true
-      t.string :recovery_point, null: false
-      t.text :error_object
-      t.text :attr_accessors
-      t.text :workflow
-      t.timestamps
-    
-      t.index %i[idempotency_key job_name job_args],
-        unique: true,
-        name: "idx_acidic_job_keys_on_idempotency_key_n_job_name_n_job_args"
-    end
-    
-    drop_table :staged_acidic_jobs do |t|
-      t.string :adapter, null: false
-      t.string :job_name, null: false
-      t.text :job_args, null: true
-      t.timestamps
-    end
-  end
-end