Explore module based refactor

app/jobs/maintenance_tasks/task_job.rb

@@ -26,20 +26,9 @@ def retry_on(*, **)
     private
 
     def build_enumerator(_run, cursor:)
-      cursor ||= @run.cursor
-      collection = @task.collection
-
-      case collection
-      when ActiveRecord::Relation
-        enumerator_builder.active_record_on_records(collection, cursor: cursor)
-      when Array
-        enumerator_builder.build_array_enumerator(collection, cursor: cursor)
-      when CSV
-        JobIteration::CsvEnumerator.new(collection).rows(cursor: cursor)
-      else
-        raise ArgumentError, "#{@task.class.name}#collection must be either "\
-          'an Active Record Relation, Array, or CSV.'
-      end
+      context = Task::EnumerationContext.new(cursor: cursor || @run.cursor)
+
+      @task.enumerator_builder.enumerator(context: context)
     end
 
     # Performs task iteration logic for the current input returned by the

app/tasks/maintenance_tasks/active_record_task.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module MaintenanceTasks
+  class ActiveRecordTask < Task
+    # TODO: define replacement for Task.collection, delegating to instance
+    # Probably simplest to make this an ActiveSupport::Concern
+
+    # TODO: specify abstract_class
+
+    EnumeratorBuilder = Struct.new(:collection) do
+      def enumerator(context:)
+        enumerator_builder.active_record_on_records(collection, cursor: context.cursor)
+      end
+    end
+
+    def enumerator(context:)
+      collection = self.collection
+      assert_relation!(collection)
+
+      EnumeratorBuilder.new(collection)
+    end
+
+    def collection
+      raise NotImplementedError, 'consumers implement this'
+    end
+
+    def count
+      collection.count
+    end
+
+    # Easily lends itself to adding batching
+    # def batch_size
+    #   1
+    # end
+
+    private
+
+    def assert_relation!(collection)
+      return if collection.is_a?(ActiveRecord::Relation)
+
+      raise(
+        ArgumentError,
+        "#{self.class.name}#collection must be an ActiveRecord::Relation",
+      )
+    end
+
+    # Convenience method to allow tasks define enumerators with cursors for
+    # compatibility with Job Iteration.
+    #
+    # @return [JobIteration::EnumeratorBuilder] instance of an enumerator
+    #   builder available to tasks.
+    def enumerator_builder
+      JobIteration.enumerator_builder.new(nil)
+    end
+  end
+end

app/tasks/maintenance_tasks/array_task.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module MaintenanceTasks
+  class ActiveRecordTask < Task
+    # TODO: define replacement for Task.collection, delegating to instance
+    # Probably simplest to make this an ActiveSupport::Concern
+
+    # TODO: Specify abstract_class
+
+    EnumeratorBuilder = Struct.new(:collection) do
+      def enumerator(context:)
+        enumerator_builder.array(collection, cursor: context.cursor)
+      end
+    end
+
+    def enumerator(context:)
+      collection = self.collection
+      assert_array!(collection)
+
+      EnumeratorBuilder.new(collection)
+    end
+
+    def collection
+      raise NotImplementedError, 'consumers implement this'
+    end
+
+    def count
+      collection.length
+    end
+
+    private
+
+    def assert_array!(collection)
+      return if collection.is_a?(Array)
+
+      raise(
+        ArgumentError,
+        "#{self.class.name}#collection must be an Array",
+      )
+    end
+
+    # Convenience method to allow tasks define enumerators with cursors for
+    # compatibility with Job Iteration.
+    #
+    # @return [JobIteration::EnumeratorBuilder] instance of an enumerator
+    #   builder available to tasks.
+    def enumerator_builder
+      JobIteration.enumerator_builder.new(nil)
+    end
+  end
+end

app/tasks/maintenance_tasks/csv_task.rb

@@ -6,17 +6,21 @@ module MaintenanceTasks
   # Base class that is inherited by the host application's Task classes for
   # processing CSV files.
   class CsvTask < Task
+    # TODO: specify abstract_class
+
+    EnumeratorBuilder = Struct.new(:collection) do
+      def enumerator(context:)
+        JobIteration::CsvEnumerator.new(collection).rows(cursor: context.cursor)
+      end
+    end
+
     # The contents of a CSV file to be processed by a Task.
     #
     # @return [String] the content of the CSV file to process.
     attr_accessor :csv_content
 
-    # Defines the collection to be iterated over, based on the provided CSV.
-    #
-    # @return [CSV] the CSV object constructed from the specified CSV content,
-    #   with headers.
-    def collection
-      CSV.new(csv_content, headers: true)
+    def enumerator_builder(context:)
+      EnumeratorBuilder.new(collection)
     end
 
     # The number of rows to be processed. Excludes the header row from the count
@@ -27,5 +31,15 @@ def collection
     def count
       csv_content.count("\n") - 1
     end
+
+    private
+
+    # Defines the collection to be iterated over, based on the provided CSV.
+    #
+    # @return [CSV] the CSV object constructed from the specified CSV content,
+    #   with headers.
+    def collection
+      CSV.new(csv_content, headers: true)
+    end
   end
 end

app/tasks/maintenance_tasks/task.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require 'maintenance_tasks/active_record_task'
+require 'maintenance_tasks/array_task'
+require 'maintenance_tasks/csv_task'
+# TODO: require other adapters, or make this dynamic somehow
+
 module MaintenanceTasks
   # Base class that is inherited by the host application's task classes.
   class Task
     extend ActiveSupport::DescendantsTracker
 
+    # TODO: Might need to be abstract_class, even if just for consistency
+
     class NotFoundError < NameError; end
+    EnumerationContext = Struct.new(:cursor, keyword_init: true)
 
     class << self
       # Finds a Task with the given name.
@@ -27,7 +35,7 @@ def named(name)
       # @return [Array<Class>] the list of classes.
       def available_tasks
         load_constants
-        descendants.without(CsvTask)
+        descendants.without(CsvTask) # TODO: Would need abstract_class check
       end
 
       # Processes one item.
@@ -39,13 +47,13 @@ def process(item)
         new.process(item)
       end
 
-      # Returns the collection for this Task.
+      # Returns the enumerator for this Task.
       #
       # Especially useful for tests.
       #
-      # @return the collection.
-      def collection
-        new.collection
+      # @return the enumerator.
+      def enumerator(cursor:)
+        new.enumerator(cursor: cursor)
       end
 
       # Returns the count of items for this Task.
@@ -71,9 +79,10 @@ def load_constants
     #
     # @raise [NotImplementedError] with a message advising subclasses to
     #   implement an override for this method.
-    def collection
+    def enumerator_builder(context:)
       raise NotImplementedError,
-        "#{self.class.name} must implement `collection`."
+        "#{self.class.name} must implement `#{__method__}` or inherit from a class which does"
+      # TODO: Could make error string list available adapters
     end
 
     # Placeholder method to raise in case a subclass fails to implement the

example.rb

@@ -0,0 +1,54 @@
+class ProductTask < MaintenanceTasks::ActiveRecordTask
+  # Consumers implement these method
+  def collection() Product.all end
+  def process(product) product.discontinue! end
+
+  # .count implementation provided, but could be overriden if consumer has some
+  # optimization or if the relation is too expensive to count
+
+  # Could easily add
+  #   run_in_batches_of 50
+  # or
+  #   def batch_size() 50 end
+end
+
+class SeedTask < MaintenanceTasks::ArrayTask
+  # Similar API to ActiveRecordTask
+  def collection() %w[Alice Bob Chantalle] end
+  def process(name) Person.create!(name: name) end
+  # Again, .count provided
+end
+
+class BetaFlagTask < MaintenanceTasks::CsvTask
+  # CSV infra handles everything except .process
+  def process(row) BetaFlag[:whatever].enable(row.shop_id) end
+end
+
+class PaymentTask < MaintenanceTasks::Task
+  # Consumers implement .build_enumerator instead of .collection, without
+  # having to know that other tasks actually also use it internally
+  class EnumeratorBuilder
+    def enumerator(context:)
+      Enumerator.new do |yielder|
+        cursor = context.cursor
+        loop do
+          page = cursor ? InvoiceAPI.fetch(after: cursor) : InvoiceAPI.fetch_all
+          break if page.empty?
+          page.each do |invoice|
+            cursor = invoice.id
+            yielder.yield(invoice, cursor)
+          end
+        end
+      end
+    end
+  end
+
+  def build_enumerator
+    Enumerator.new
+  end
+
+  # Again, can be implemented if appropriate
+  def count() InvoiceAPI.unpaid_count end
+
+  def process(invoice) invoice.pay! if invoice.unpaid? end
+end