batch_processor 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f2c6357a153ebd1b3559ffca1eb4a039b0fc326180292ea1b0e182eede3b69e
-  data.tar.gz: 7ebf000d79144b788b76867c242558424ba97e2c7bdb762d9edc7b88ff335e40
+  metadata.gz: 92f896e89a4f7222fb235fc9db1db9631792ff72508b2af911807db824bc9c57
+  data.tar.gz: ca8818ccccf18d57cfbc5a2c9628f3a4d349417789a90e1d2ca2fd2e77ac0c67
 SHA512:
-  metadata.gz: bf7dea4b7afd8e690eb24c09b867b568562bcfe66695ce542b390a107f2f0c8b8772132473c492aa518de1fb324b145c26ed7f4946003fb4ce5c8d1204048d9a
-  data.tar.gz: f245ab4a0848d1032180b20e3a240d4716ad93e3fe6a379e51e1a7148f2755bcaddb5439856812acd8a4530e6ca627c34bc1743d13386fc16cfbb4d5ba61eab5
+  metadata.gz: 88f75329cbdada1be5be38abd8edd8da5e31509a745917e56dc0d317ce9420f1a6cb7622968a40ec4342237d244c92bbaba4a3b9a8cb9b5b4b739baee69ebae7
+  data.tar.gz: b6ca0129ffeef8ef479bcee475420d891972d1ef307daa50140bcd63b150d2869909e8dcbfec0157e4a386e4b03baa6dcc6f98a54395eb3af5cbfd94ed57094c

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Eric Garside
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+# BatchProcessor
+
+Define your collection, job, and callbacks all in one clear and concise object
+
+[![Gem Version](https://badge.fury.io/rb/batch_processor.svg)](https://badge.fury.io/rb/batch_processor)
+[![Build Status](https://semaphoreci.com/api/v1/freshly/batch_processor/branches/master/badge.svg)](https://semaphoreci.com/freshly/batch_processor)
+[![Maintainability](https://api.codeclimate.com/v1/badges/fbdaeaf118a16a55ab7d/maintainability)](https://codeclimate.com/github/Freshly/batch_processor/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/fbdaeaf118a16a55ab7d/test_coverage)](https://codeclimate.com/github/Freshly/batch_processor/test_coverage)
+
+* [BatchProcessor](#batchprocessor)
+   * [Installation](#installation)
+   * [Usage](#usage)
+   * [Development](#development)
+   * [Contributing](#contributing)
+   * [License](#license)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'batch_processor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install batch_processor
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Freshly/batch_processor.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/batch_processor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_job"
+
+require "spicerack"
+
+require "batch_processor/version"
+require "batch_processor/batch_job"
+require "batch_processor/batch_details"
+require "batch_processor/processor_base"
+require "batch_processor/processors/parallel"
+require "batch_processor/processors/sequential"
+require "batch_processor/collection"
+require "batch_processor/batch_base"
+
+module BatchProcessor
+  class Error < StandardError; end
+
+  class NotFoundError < Error; end
+  class ClassMissingError < Error; end
+  class CollectionEmptyError < Error; end
+  class CollectionInvalidError < Error; end
+  class AlreadyExistsError < Error; end
+  class AlreadyStartedError < Error; end
+  class AlreadyEnqueuedError < Error; end
+  class AlreadyFinishedError < Error; end
+  class AlreadyAbortedError < Error; end
+  class AlreadyClearedError < Error; end
+  class StillProcessingError < Error; end
+  class NotProcessingError < Error; end
+  class NotAbortedError < Error; end
+  class NotStartedError < Error; end
+end

data/lib/batch_processor/batch/controller.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# The controller performs updates on and tracks details of a batch.
+module BatchProcessor
+  module Batch
+    module Controller
+      extend ActiveSupport::Concern
+
+      included do
+        batch_callbacks :started, :enqueued, :aborted, :cleared, :finished
+
+        delegate :allow_empty?, to: :class
+        delegate :name, to: :class, prefix: true
+        delegate :pipelined, to: :details
+      end
+
+      class_methods do
+        def allow_empty
+          @allow_empty = true
+        end
+
+        def allow_empty?
+          @allow_empty.present?
+        end
+
+        private
+
+        def batch_callbacks(*events)
+          batch_events = events.map { |event| "batch_#{event}".to_sym }
+
+          define_callbacks_with_handler(*batch_events)
+
+          batch_events.each do |batch_event|
+            set_callback batch_event, :around, ->(_, block) { surveil(batch_event) { block.call } }
+          end
+        end
+      end
+
+      def start
+        raise BatchProcessor::CollectionInvalidError unless collection.valid?
+        raise BatchProcessor::AlreadyStartedError if started?
+        raise BatchProcessor::CollectionEmptyError if collection_items.empty? && !allow_empty?
+
+        run_callbacks(:batch_started) do
+          collection_size = collection_items.count
+
+          pipelined do
+            details.class_name = class_name
+            details.started_at = Time.current
+            details.size = collection_size
+            details.pending_jobs_count = collection_size
+          end
+        end
+
+        started?
+      end
+
+      def enqueued
+        raise BatchProcessor::AlreadyEnqueuedError if enqueued?
+        raise BatchProcessor::NotStartedError unless started?
+
+        run_callbacks(:batch_enqueued) { details.enqueued_at = Time.current }
+
+        enqueued?
+      end
+
+      def abort!
+        raise BatchProcessor::NotStartedError unless started?
+        raise BatchProcessor::AlreadyFinishedError if finished?
+        raise BatchProcessor::AlreadyAbortedError if aborted?
+
+        run_callbacks(:batch_aborted) { details.aborted_at = Time.current }
+
+        aborted?
+      end
+
+      def clear!
+        raise BatchProcessor::NotAbortedError unless aborted?
+        raise BatchProcessor::AlreadyFinishedError if finished?
+        raise BatchProcessor::AlreadyClearedError if cleared?
+
+        run_callbacks(:batch_cleared) do
+          pending_jobs_count = details.pending_jobs_count
+          running_jobs_count = details.running_jobs_count
+
+          pipelined do
+            details.cleared_at = Time.current
+            details.finished_at = Time.current
+            details.decrement(:pending_jobs_count, by: pending_jobs_count)
+            details.decrement(:running_jobs_count, by: running_jobs_count)
+            details.increment(:cleared_jobs_count, by: pending_jobs_count + running_jobs_count)
+          end
+        end
+
+        run_callbacks(:batch_finished)
+
+        cleared?
+      end
+
+      def finish
+        raise BatchProcessor::AlreadyFinishedError if finished?
+        raise BatchProcessor::StillProcessingError if unfinished_jobs?
+
+        run_callbacks(:batch_finished) { details.finished_at = Time.current }
+
+        finished?
+      end
+    end
+  end
+end

data/lib/batch_processor/batch/core.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# A batch has an ID, details, and is recoverable as an STI.
+module BatchProcessor
+  module Batch
+    module Core
+      extend ActiveSupport::Concern
+
+      included do
+        option(:batch_id) { SecureRandom.urlsafe_base64(10) }
+
+        delegate :items, :item_to_job_params, to: :collection, prefix: true
+
+        private
+
+        attr_reader :collection_input
+        memoize :collection
+        memoize :collection_items
+        memoize :details
+      end
+
+      def initialize(**input)
+        super(input.slice(*_attributes))
+        @collection_input = input.except(*_attributes)
+      end
+
+      def collection
+        self.class::Collection.new(**collection_input)
+      end
+
+      def details
+        BatchProcessor::BatchDetails.new(batch_id)
+      end
+
+      class_methods do
+        def find(batch_id)
+          class_name = BatchProcessor::BatchDetails.class_name_for_batch_id(batch_id)
+          raise BatchProcessor::NotFoundError, "A Batch with id #{batch_id} was not found." if class_name.nil?
+
+          batch_class = class_name.safe_constantize
+          raise BatchProcessor::ClassMissingError, "#{class_name} is not a class" if batch_class.nil?
+
+          batch_class.new(batch_id: batch_id)
+        end
+      end
+    end
+  end
+end

data/lib/batch_processor/batch/job.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# A batch job is what process each item in the collection.
+module BatchProcessor
+  module Batch
+    module Job
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :job_class, to: :class
+      end
+
+      class_methods do
+        def job_class
+          return @job_class if defined?(@job_class)
+
+          "#{name.chomp("Batch")}Job".constantize
+        end
+
+        private
+
+        def process_with_job(job_class)
+          raise ArgumentError, "Unbatchable job" unless job_class.ancestors.include? BatchProcessor::BatchJob
+
+          @job_class = job_class
+        end
+      end
+    end
+  end
+end

data/lib/batch_processor/batch/job_controller.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# The job controller performs updates on and tracks details related to the jobs in a batch.
+module BatchProcessor
+  module Batch
+    module JobController
+      extend ActiveSupport::Concern
+
+      class_methods do
+        private
+
+        def job_callbacks(*events)
+          job_events = events.map { |event| "job_#{event}".to_sym }
+
+          define_callbacks_with_handler(*job_events)
+
+          job_events.each do |job_event|
+            set_callback job_event, :around, ->(_, block) { surveil(job_event) { block.call } }
+          end
+        end
+      end
+
+      included do
+        job_callbacks :enqueued, :running, :retried, :canceled, :success, :failure
+
+        on_job_success :finish, unless: :unfinished_jobs?
+        on_job_failure :finish, unless: :unfinished_jobs?
+        on_job_canceled :finish, unless: :unfinished_jobs?
+      end
+
+      def job_enqueued
+        raise BatchProcessor::AlreadyEnqueuedError if enqueued?
+        raise BatchProcessor::NotProcessingError unless processing?
+
+        run_callbacks(__method__) { details.increment(:enqueued_jobs_count) }
+      end
+
+      def job_running
+        raise BatchProcessor::NotProcessingError unless processing?
+
+        run_callbacks(__method__) do
+          details.pipelined do
+            details.increment(:running_jobs_count)
+            details.decrement(:pending_jobs_count)
+          end
+        end
+      end
+
+      def job_retried
+        raise BatchProcessor::NotProcessingError unless processing?
+
+        run_callbacks(__method__) do
+          details.pipelined do
+            details.increment(:total_retries_count)
+            details.increment(:pending_jobs_count)
+            details.decrement(:failed_jobs_count)
+          end
+        end
+      end
+
+      def job_success
+        raise BatchProcessor::NotStartedError unless started?
+        raise BatchProcessor::AlreadyFinishedError if finished?
+
+        run_callbacks(__method__) do
+          details.pipelined do
+            details.increment(:successful_jobs_count)
+            details.decrement(:running_jobs_count)
+          end
+        end
+      end
+
+      def job_failure
+        raise BatchProcessor::NotStartedError unless started?
+        raise BatchProcessor::AlreadyFinishedError if finished?
+
+        run_callbacks(__method__) do
+          details.pipelined do
+            details.increment(:failed_jobs_count)
+            details.decrement(:running_jobs_count)
+          end
+        end
+      end
+
+      def job_canceled
+        raise BatchProcessor::NotAbortedError unless aborted?
+
+        run_callbacks(__method__) do
+          details.pipelined do
+            details.increment(:canceled_jobs_count)
+            details.decrement(:pending_jobs_count)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/batch_processor/batch/predicates.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Predicates allow inspection of the status of a batch.
+module BatchProcessor
+  module Batch
+    module Predicates
+      extend ActiveSupport::Concern
+
+      included do
+        date_predicate :started, :enqueued, :aborted, :cleared, :finished
+
+        job_count_predicate :enqueued, :pending, :running, :failed, :canceled, :unfinished, :finished
+      end
+
+      def processing?
+        started? && !aborted? && !finished?
+      end
+
+      class_methods do
+        private
+
+        def date_predicate(*methods)
+          methods.each do |method|
+            define_method("#{method}?".to_sym) { details.public_send("#{method}_at?".to_sym) }
+          end
+        end
+
+        def job_count_predicate(*methods)
+          methods.each do |method|
+            define_method("#{method}_jobs?".to_sym) { details.public_send("#{method}_jobs_count".to_sym) > 0 }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/batch_processor/batch/processor.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# When processed, the batch performs a job for each item in its collection.
+module BatchProcessor
+  module Batch
+    module Processor
+      extend ActiveSupport::Concern
+
+      # This is left mutable for extension and customization
+      # rubocop:disable Style/MutableConstant
+      PROCESSOR_CLASS_BY_STRATEGY = {
+        default: BatchProcessor::Processors::Parallel,
+        parallel: BatchProcessor::Processors::Parallel,
+        sequential: BatchProcessor::Processors::Sequential,
+      }
+      # rubocop:enable Style/MutableConstant
+
+      included do
+        class_attribute :_processor_options, instance_writer: false, default: {}
+        delegate :processor_class, :processor_options, to: :class
+      end
+
+      class_methods do
+        PROCESSOR_CLASS_BY_STRATEGY.except(:default).each do |strategy, processor_class|
+          strategy_method = "with_#{strategy}_processor".to_sym
+          define_method(strategy_method) { @processor_class = processor_class }
+          private strategy_method
+        end
+
+        def process(*arguments)
+          new(*arguments).process
+        end
+
+        def processor_class
+          return @processor_class if defined?(@processor_class)
+
+          PROCESSOR_CLASS_BY_STRATEGY[:default]
+        end
+
+        def inherited(base)
+          dup = _processor_options.dup
+          base._processor_options = dup.each { |k, v| dup[k] = v.dup }
+          super
+        end
+
+        private
+
+        def processor_option(option, value = nil)
+          _processor_options[option.to_sym] = value
+        end
+      end
+
+      def process
+        processor_class.execute(batch: self, **_processor_options)
+      end
+    end
+  end
+end

data/lib/batch_processor/batch_base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "batch/core"
+require_relative "batch/job"
+require_relative "batch/processor"
+require_relative "batch/predicates"
+require_relative "batch/controller"
+require_relative "batch/job_controller"
+
+module BatchProcessor
+  class BatchBase < Spicerack::InputObject
+    class BatchCollection < BatchProcessor::Collection; end
+    class Collection < BatchCollection; end
+
+    include BatchProcessor::Batch::Core
+    include BatchProcessor::Batch::Job
+    include BatchProcessor::Batch::Processor
+    include BatchProcessor::Batch::Predicates
+    include BatchProcessor::Batch::Controller
+    include BatchProcessor::Batch::JobController
+  end
+end

data/lib/batch_processor/batch_details.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# The details of a batch represent the state of the work to process.
+module BatchProcessor
+  class BatchDetails < Spicerack::RedisModel
+    attr_reader :batch_id
+
+    field :class_name, :string
+
+    field :started_at, :datetime
+    field :enqueued_at, :datetime
+    field :aborted_at, :datetime
+    field :cleared_at, :datetime
+    field :finished_at, :datetime
+
+    field :size, :integer, default: 0
+
+    field :enqueued_jobs_count, :integer, default: 0
+
+    field :pending_jobs_count, :integer, default: 0
+    field :running_jobs_count, :integer, default: 0
+
+    field :successful_jobs_count, :integer, default: 0
+    field :failed_jobs_count, :integer, default: 0
+
+    field :canceled_jobs_count, :integer, default: 0
+    field :cleared_jobs_count, :integer, default: 0
+
+    field :total_retries_count, :integer, default: 0
+
+    class << self
+      def redis_key_for_batch_id(batch_id)
+        "#{name}::#{batch_id}"
+      end
+
+      def class_name_for_batch_id(batch_id)
+        default_redis.hget(redis_key_for_batch_id(batch_id), "class_name")
+      end
+    end
+
+    def initialize(batch_id)
+      @batch_id = batch_id
+      super redis_key: self.class.redis_key_for_batch_id(batch_id)
+    end
+
+    def unfinished_jobs_count
+      sum_up(:pending_jobs_count, :running_jobs_count)
+    end
+
+    def finished_jobs_count
+      sum_up(:successful_jobs_count, :failed_jobs_count, :canceled_jobs_count)
+    end
+
+    def total_jobs_count
+      sum_up(
+        :pending_jobs_count,
+        :running_jobs_count,
+        :successful_jobs_count,
+        :failed_jobs_count,
+        :canceled_jobs_count,
+        :cleared_jobs_count,
+      )
+    end
+
+    private
+
+    def sum_up(*fields)
+      values_at(*fields).map(&:to_i).sum
+    end
+  end
+end

data/lib/batch_processor/batch_job.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# A batch can only be processed by a batchable job.
+module BatchProcessor
+  class BatchJob < ActiveJob::Base
+    attr_accessor :batch_id
+
+    class BatchAbortedError < StandardError; end
+
+    after_enqueue(if: :batch_job?) do |job|
+      if job.executions == 0
+        batch.job_enqueued
+      else
+        batch.job_retried
+      end
+    end
+
+    before_perform(if: :batch_job?) do
+      raise BatchAbortedError if batch.aborted?
+
+      batch.job_running
+    end
+
+    after_perform(if: :batch_job?) { batch.job_success }
+
+    def rescue_with_handler(exception)
+      batch.job_canceled and return exception if exception.is_a?(BatchAbortedError)
+
+      batch.job_failure if batch_job?
+
+      super
+    end
+
+    def retry_job(*)
+      return if batch_job? && batch.processor_class.disable_retries?
+
+      super
+    end
+
+    def serialize
+      super.merge("batch_id" => batch_id) # rubocop:disable Style/StringHashKeys
+    end
+
+    def deserialize(job_data)
+      super(job_data)
+      self.batch_id = job_data["batch_id"]
+    end
+
+    def batch
+      return unless batch_job?
+
+      @batch ||= BatchProcessor::BatchBase.find(batch_id)
+    end
+
+    def batch_job?
+      batch_id.present?
+    end
+  end
+end

data/lib/batch_processor/collection.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module BatchProcessor
+  class Collection < Spicerack::InputModel
+    def items
+      []
+    end
+
+    def item_to_job_params(item)
+      item
+    end
+  end
+end

data/lib/batch_processor/processor/execute.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# When executed, the processor performs a job for each item in the batch collection.
+module BatchProcessor
+  module Processor
+    module Execute
+      extend ActiveSupport::Concern
+
+      included do
+        define_callbacks :execute
+        set_callback :execute, :around, ->(_, block) { surveil(:execute) { block.call } }
+      end
+
+      class_methods do
+        def execute(*arguments)
+          new(*arguments).execute
+        end
+      end
+
+      def execute
+        run_callbacks(:execute) { process }
+      end
+    end
+  end
+end

data/lib/batch_processor/processor/process.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Processing a batch performs a job for each item in the batch collection.
+module BatchProcessor
+  module Processor
+    module Process
+      extend ActiveSupport::Concern
+
+      included do
+        define_callbacks :collection_processed, :item_processed
+        set_callback :collection_processed, :around, ->(_, block) { surveil(:collection_processed) { block.call } }
+        set_callback :item_processed, :around, ->(_, block) { surveil(:item_processed) { block.call } }
+      end
+
+      def process
+        batch.start
+
+        run_callbacks(:collection_processed) { process_collection }
+
+        batch.finish unless batch.finished? || batch.unfinished_jobs?
+
+        self
+      end
+
+      def process_collection_item(_item)
+        # Abstract
+      end
+
+      private
+
+      def iterator_method
+        batch.collection_items.respond_to?(:find_each) ? :find_each : :each
+      end
+
+      def process_collection
+        batch.collection_items.public_send(iterator_method) do |item|
+          run_callbacks(:item_processed) { process_collection_item(batch.collection_item_to_job_params(item)) }
+        end
+      end
+    end
+  end
+end

data/lib/batch_processor/processor_base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "processor/process"
+require_relative "processor/execute"
+
+module BatchProcessor
+  class ProcessorBase < Spicerack::InputObject
+    argument :batch, allow_nil: false
+
+    class << self
+      def disable_retries?
+        false
+      end
+    end
+
+    include BatchProcessor::Processor::Process
+    include BatchProcessor::Processor::Execute
+  end
+end

data/lib/batch_processor/processors/parallel.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BatchProcessor
+  module Processors
+    class Parallel < BatchProcessor::ProcessorBase
+      set_callback(:collection_processed, :after) { batch.enqueued }
+
+      def process_collection_item(item)
+        job = batch.job_class.new(item)
+        job.batch_id = batch.batch_id
+        job.enqueue
+      end
+    end
+  end
+end

data/lib/batch_processor/processors/sequential.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module BatchProcessor
+  module Processors
+    class Sequential < BatchProcessor::ProcessorBase
+      option :continue_after_exception, default: false
+      option :sorted, default: false
+
+      class << self
+        def disable_retries?
+          true
+        end
+      end
+
+      def process_collection_item(item)
+        job = batch.job_class.new(item)
+        job.batch_id = batch.batch_id
+        job.perform_now
+      rescue StandardError => exception
+        raise exception unless continue_after_exception
+      end
+
+      private
+
+      def iterator_method
+        sorted ? :each : super
+      end
+    end
+  end
+end

data/lib/batch_processor/rspec/active_job_test_adapter_monkeypatch.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module QueueAdapters
+    class TestAdapter
+      # BatchProcessor relies on serialized arguments being passed to ActiveJob, as the batch_id is put into the
+      # serialized hash to keep it out of the arguments and prevent needing a deeper override of ActiveJob's API.
+      # This works totally fine and perfect when you are using the test adapter and processing the jobs, as the
+      # internal implementation is to just call ActiveJob::Base.execute on the serialized hash. Weirdly, instead of...
+      # just putting the serialized hash into an array and using that, the implementation literally reinvents a simpler
+      # wheel WHILE USING THE ACTUAL SERIALIZED HASH ITSELF TO EXTRACT ARGUMENTS. So like... I changed that.
+      #
+      # There didn't seem to be a value to me to put this implementation in a way which keeps the original API because
+      # the actual serialized API itself is so similar, refactoring any test implementation to work with the change
+      # should be trivial.
+      def job_to_hash(job, extras = {})
+        job.serialize.merge!(extras)
+      end
+    end
+  end
+end

data/lib/batch_processor/rspec/custom_matchers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "custom_matchers/set_processor_option"
+require_relative "custom_matchers/use_batch_processor_strategy"
+require_relative "custom_matchers/use_default_job_class"
+require_relative "custom_matchers/use_default_processor"
+require_relative "custom_matchers/use_job_class"
+require_relative "custom_matchers/use_parallel_processor"
+require_relative "custom_matchers/use_sequential_processor"

data/lib/batch_processor/rspec/custom_matchers/set_processor_option.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests usages of batches which do not specify a processor
+#
+#     class ExampleBatch < ApplicationBatch
+#       processor_option :sorted, true
+#     end
+#
+#     RSpec.describe ExampleBatch do
+#       it { is_expected.to set_processor_option :sorted, true }
+#     end
+
+RSpec::Matchers.define :set_processor_option do |key, value|
+  match { expect(test_subject._processor_options[key]).to eq value }
+  description { "set processor option #{key}" }
+  failure_message { "expected #{test_subject} to set processor option #{key} to #{value}" }
+  failure_message_when_negated { "expected #{test_subject} not to set processor option #{key} to #{value}" }
+
+  def test_subject
+    subject.is_a?(Class) ? subject : subject.class
+  end
+end

data/lib/batch_processor/rspec/custom_matchers/use_batch_processor_strategy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# RSpec matcher to DRY out the similarities between the other batch processor matchers.
+#
+#     class ExampleBatch < ApplicationBatch
+#     end
+#
+#     RSpec.describe ExampleBatch do
+#       it { is_expected.to use_batch_processor_strategy :default }
+#     end
+
+RSpec::Matchers.define :use_batch_processor_strategy do |strategy|
+  match { test_subject.processor_class == BatchProcessor::Batch::Processor::PROCESSOR_CLASS_BY_STRATEGY[strategy] }
+  description { "use #{strategy} processor" }
+  failure_message { "expected #{test_subject} to use #{strategy} processor" }
+  failure_message_when_negated { "expected #{test_subject} not to use #{strategy} processor" }
+
+  def test_subject
+    subject.is_a?(Class) ? subject : subject.class
+  end
+end

data/lib/batch_processor/rspec/custom_matchers/use_default_job_class.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# RSpec matcher to DRY out the similarities between the other batch processor matchers.
+#
+#     class ExampleBatch < ApplicationBatch
+#     end
+#
+#     RSpec.describe ExampleBatch do
+#       it { is_expected.to use_default_job_class }
+#     end
+
+RSpec::Matchers.define :use_default_job_class do
+  match { is_expected.to use_job_class "#{test_subject.name.chomp("Batch")}Job".constantize }
+
+  def test_subject
+    subject.is_a?(Class) ? subject : subject.class
+  end
+end

data/lib/batch_processor/rspec/custom_matchers/use_default_processor.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests usages of batches which do not specify a processor
+#
+#     class ExampleBatch < ApplicationBatch
+#     end
+#
+#     RSpec.describe ExampleBatch do
+#       it { is_expected.to use_default_processor }
+#     end
+
+RSpec::Matchers.define :use_default_processor do
+  match { is_expected.to use_batch_processor_strategy :default }
+end

data/lib/batch_processor/rspec/custom_matchers/use_job_class.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# RSpec matcher to DRY out the similarities between the other batch processor matchers.
+#
+#     class ExampleBatch < ApplicationBatch
+#       def self.job_class
+#         SpecialJobClass
+#       end
+#     end
+#
+#     RSpec.describe ExampleBatch do
+#       it { is_expected.to use_job_class SpecialJobClass }
+#     end
+
+RSpec::Matchers.define :use_job_class do |job_class|
+  match { test_subject.job_class == job_class }
+  description { "use #{job_class} job" }
+  failure_message { "expected #{test_subject} to use #{job_class} job" }
+  failure_message_when_negated { "expected #{test_subject} not to use #{job_class} job" }
+
+  def test_subject
+    subject.is_a?(Class) ? subject : subject.class
+  end
+end

data/lib/batch_processor/rspec/custom_matchers/use_parallel_processor.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests usages of `.with_parallel_processor`
+#
+#     class ExampleBatch < ApplicationBatch
+#       with_parallel_processor
+#     end
+#
+#     RSpec.describe ExampleBatch do
+#       it { is_expected.to use_parallel_processor }
+#     end
+
+RSpec::Matchers.define :use_parallel_processor do
+  match { is_expected.to use_batch_processor_strategy :parallel }
+end

data/lib/batch_processor/rspec/custom_matchers/use_sequential_processor.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests usages of `.with_parallel_processor`
+#
+#     class ExampleBatch < ApplicationBatch
+#       with_sequential_processor
+#     end
+#
+#     RSpec.describe ExampleBatch do
+#       it { is_expected.to use_sequential_processor }
+#     end
+
+RSpec::Matchers.define :use_sequential_processor do
+  match { is_expected.to use_batch_processor_strategy :sequential }
+end

data/lib/batch_processor/rspec/shoulda_matcher_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if defined?(Shoulda::Matchers::ActiveModel)
+  RSpec.configure do |config|
+    config.include(Shoulda::Matchers::ActiveModel, type: :batch_collection)
+  end
+end

data/lib/batch_processor/spec_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "rspec/custom_matchers"
+require_relative "rspec/shoulda_matcher_helper"

data/lib/batch_processor/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BatchProcessor
+  VERSION = "0.2.2"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: batch_processor
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Eric Garside
@@ -231,7 +231,37 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/batch_processor.rb
+- lib/batch_processor/batch/controller.rb
+- lib/batch_processor/batch/core.rb
+- lib/batch_processor/batch/job.rb
+- lib/batch_processor/batch/job_controller.rb
+- lib/batch_processor/batch/predicates.rb
+- lib/batch_processor/batch/processor.rb
+- lib/batch_processor/batch_base.rb
+- lib/batch_processor/batch_details.rb
+- lib/batch_processor/batch_job.rb
+- lib/batch_processor/collection.rb
+- lib/batch_processor/processor/execute.rb
+- lib/batch_processor/processor/process.rb
+- lib/batch_processor/processor_base.rb
+- lib/batch_processor/processors/parallel.rb
+- lib/batch_processor/processors/sequential.rb
+- lib/batch_processor/rspec/active_job_test_adapter_monkeypatch.rb
+- lib/batch_processor/rspec/custom_matchers.rb
+- lib/batch_processor/rspec/custom_matchers/set_processor_option.rb
+- lib/batch_processor/rspec/custom_matchers/use_batch_processor_strategy.rb
+- lib/batch_processor/rspec/custom_matchers/use_default_job_class.rb
+- lib/batch_processor/rspec/custom_matchers/use_default_processor.rb
+- lib/batch_processor/rspec/custom_matchers/use_job_class.rb
+- lib/batch_processor/rspec/custom_matchers/use_parallel_processor.rb
+- lib/batch_processor/rspec/custom_matchers/use_sequential_processor.rb
+- lib/batch_processor/rspec/shoulda_matcher_helper.rb
+- lib/batch_processor/spec_helper.rb
+- lib/batch_processor/version.rb
 homepage: https://github.com/Freshly/batch_processor
 licenses:
 - MIT