activeinteractor 0.1.0

data/lib/active_interactor/interactor/callbacks.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveInteractor
+  module Interactor
+    # Provides context attribute assignment methods to included classes
+    #
+    # @author Aaron Allen <hello@aaronmallen.me>
+    # @since 0.0.1
+    # @version 0.1
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+        extend ClassMethods
+        include ActiveSupport::Callbacks
+
+        class_attribute :__clean_after_perform, instance_writer: false, default: false
+        class_attribute :__fail_on_invalid_context, instance_writer: false, default: true
+        define_callbacks :validation,
+                         skip_after_callbacks_if_terminated: true,
+                         scope: %i[kind name]
+        define_callbacks :perform, :rollback
+      end
+
+      module ClassMethods
+        # Define a callback to call after `#valid?` has been invoked on an
+        #  interactor's context
+        #
+        # @example Implement an after_context_validation callback
+        #  class MyInteractor < ActiveInteractor::Base
+        #    after_context_validation :ensure_name_is_aaron
+        #    context_validates :name, inclusion: { in: %w[Aaron] }
+        #
+        #    def ensure_name_is_aaron
+        #      context.name = 'Aaron'
+        #    end
+        #  end
+        #
+        #  context = MyInteractor.new(name: 'Bob').context
+        #  #=> <MyInteractor::Context name='Bob'>
+        #
+        #  context.valid?
+        #  #=> false
+        #
+        #  context.name
+        #  #=> 'Aaron'
+        #
+        #  context.valid?
+        #  #=> true
+        def after_context_validation(*args, &block)
+          options = normalize_options(args.extract_options!.dup.merge(prepend: true))
+          set_callback(:validation, :after, *args, options, &block)
+        end
+
+        # Define a callback to call after {ActiveInteractor::Base.perform} has been invoked
+        #
+        # @example
+        #  class MyInteractor < ActiveInteractor::Base
+        #    after_perform :print_done
+        #
+        #    def perform
+        #      puts 'Performing'
+        #    end
+        #
+        #    def print_done
+        #      puts 'Done'
+        #    end
+        #  end
+        #
+        #  MyInteractor.perform(name: 'Aaron')
+        #  "Performing"
+        #  "Done"
+        #  #=> <MyInteractor::Context name='Aaron'>
+        def after_perform(*filters, &block)
+          set_callback(:perform, :after, *filters, &block)
+        end
+
+        # Define a callback to call after {ActiveInteractor::Base#rollback} has been invoked
+        #
+        # @example
+        #  class MyInteractor < ActiveInteractor::Base
+        #    after_rollback :print_done
+        #
+        #    def rollback
+        #      puts 'Rolling back'
+        #    end
+        #
+        #    def print_done
+        #      puts 'Done'
+        #    end
+        #  end
+        #
+        #  context = MyInteractor.perform(name: 'Aaron')
+        #  #=> <MyInteractor::Context name='Aaron'>
+        #
+        #  context.rollback!
+        #  "Rolling back"
+        #  "Done"
+        def after_rollback(*filters, &block)
+          set_callback(:rollback, :after, *filters, &block)
+        end
+
+        # By default an interactor context will fail if it is deemed
+        #  invalid before or after the {ActiveInteractor::Base.perform} method
+        #  is invoked.  Calling this method on an interactor class
+        #  will not invoke {ActiveInteractor::Context::Base#fail!} if the
+        #  context is invalid.
+        def allow_context_to_be_invalid
+          self.__fail_on_invalid_context = false
+        end
+
+        # Define a callback to call around {ActiveInteractor::Base.perform} invokation
+        #
+        # @example
+        #  class MyInteractor < ActiveInteractor::Base
+        #    around_perform :track_time
+        #
+        #    def perform
+        #      sleep(1)
+        #    end
+        #
+        #    def track_time
+        #      context.start_time = Time.now.utc
+        #      yield
+        #      context.end_time = Time.now.utc
+        #    end
+        #  end
+        #
+        #  context = MyInteractor.perform(name: 'Aaron')
+        #  #=> <MyInteractor::Context name='Aaron'>
+        #
+        #  context.start_time
+        #  #=> 2019-01-01 00:00:00 UTC
+        #
+        #  context.end_time
+        #  #=> 2019-01-01 00:00:01 UTC
+        def around_perform(*filters, &block)
+          set_callback(:perform, :around, *filters, &block)
+        end
+
+        # Define a callback to call around {ActiveInteractor::Base#rollback} invokation
+        #
+        # @example
+        #  class MyInteractor < ActiveInteractor::Base
+        #    around_rollback :track_time
+        #
+        #    def rollback
+        #      sleep(1)
+        #    end
+        #
+        #    def track_time
+        #      context.start_time = Time.now.utc
+        #      yield
+        #      context.end_time = Time.now.utc
+        #    end
+        #  end
+        #
+        #  context = MyInteractor.perform(name: 'Aaron')
+        #  #=> <MyInteractor::Context name='Aaron'>
+        #
+        #  context.rollback!
+        #  #=> true
+        #
+        #  context.start_time
+        #  #=> 2019-01-01 00:00:00 UTC
+        #
+        #  context.end_time
+        #  #=> 2019-01-01 00:00:01 UTC
+        def around_rollback(*filters, &block)
+          set_callback(:rollback, :around, *filters, &block)
+        end
+
+        # Define a callback to call before `#valid?` has been invoked on an
+        #  interactor's context
+        #
+        # @example Implement an after_context_validation callback
+        #  class MyInteractor < ActiveInteractor::Base
+        #    before_context_validation :set_name_aaron
+        #    context_validates :name, inclusion: { in: %w[Aaron] }
+        #
+        #    def set_name_aaron
+        #      context.name = 'Aaron'
+        #    end
+        #  end
+        #
+        #  context = MyInteractor.new(name: 'Bob').context
+        #  #=> <MyInteractor::Context name='Bob'>
+        #
+        #  context.valid?
+        #  #=> true
+        #
+        #  context.name
+        #  #=> 'Aaron'
+        def before_context_validation(*args, &block)
+          options = normalize_options(args.extract_options!.dup)
+          set_callback(:validation, :before, *args, options, &block)
+        end
+
+        # Define a callback to call before {ActiveInteractor::Base.perform} has been invoked
+        #
+        # @example
+        #  class MyInteractor < ActiveInteractor::Base
+        #    before_perform :print_start
+        #
+        #    def perform
+        #      puts 'Performing'
+        #    end
+        #
+        #    def print_start
+        #      puts 'Start'
+        #    end
+        #  end
+        #
+        #  MyInteractor.perform(name: 'Aaron')
+        #  "Start"
+        #  "Performing"
+        #  #=> <MyInteractor::Context name='Aaron'>
+        def before_perform(*filters, &block)
+          set_callback(:perform, :before, *filters, &block)
+        end
+
+        # Define a callback to call before {ActiveInteractor::Base#rollback} has been invoked
+        #
+        # @example
+        #  class MyInteractor < ActiveInteractor::Base
+        #    before_rollback :print_start
+        #
+        #    def rollback
+        #      puts 'Rolling Back'
+        #    end
+        #
+        #    def print_start
+        #      puts 'Start'
+        #    end
+        #  end
+        #
+        #  context = MyInteractor.perform(name: 'Aaron')
+        #  #=> <MyInteractor::Context name='Aaron'>
+        #
+        #  context.rollback!
+        #  "Start"
+        #  "Rolling Back"
+        #  #=> true
+        def before_rollback(*filters, &block)
+          set_callback(:rollback, :before, *filters, &block)
+        end
+
+        # Calling this method on an interactor class will invoke
+        #  {ActiveInteractor::Context::Base#clean!} on the interactor's
+        #  context instance after {ActiveInteractor::Base.perform}
+        #  is invoked.
+        def clean_context_on_completion
+          self.__clean_after_perform = true
+        end
+
+        private
+
+        def normalize_options(options)
+          if options.key?(:on)
+            options[:on] = Array(options[:on])
+            options[:if] = Array(options[:if])
+            options[:if].unshift { |o| !(options[:on] & Array(o.validation_context)).empty? }
+          end
+
+          options
+        end
+      end
+    end
+  end
+end

data/lib/active_interactor/interactor/context.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Interactor
+    # Provides ActiveInteractor::Interactor::Context methods to included classes
+    #
+    # @api private
+    # @author Aaron Allen <hello@aaronmallen.me>
+    # @since 0.0.1
+    # @version 0.1
+    module Context
+      extend ActiveSupport::Concern
+
+      included do
+        extend ClassMethods
+        include Callbacks
+
+        delegate(*ActiveModel::Validations.instance_methods, to: :context, prefix: true)
+        delegate(*ActiveModel::Validations::HelperMethods.instance_methods, to: :context, prefix: true)
+      end
+
+      module ClassMethods
+        delegate(*ActiveModel::Validations::ClassMethods.instance_methods, to: :context_class, prefix: :context)
+        delegate(*ActiveModel::Validations::HelperMethods.instance_methods, to: :context_class, prefix: :context)
+
+        # Create the context class for inherited classes.
+        def inherited(base)
+          base.const_set 'Context', Class.new(ActiveInteractor::Context::Base)
+        end
+
+        # Assign attributes to the context class of the interactor
+        #
+        # @example Assign attributes to the context class
+        #  class MyInteractor > ActiveInteractor::Base
+        #    context_attributes :first_name, :last_name
+        #  end
+        #
+        #  MyInteractor::Context.attributes
+        #  #=> [:first_name, :last_name]
+        # @param attributes [Array] the attributes to assign to the context
+        def context_attributes(*attributes)
+          context_class.attributes = attributes
+        end
+
+        # The context class of the interactor
+        #
+        # @example
+        #  class MyInteractor < ActiveInteractor::Base
+        #  end
+        #
+        #  MyInteractor.context_class
+        #  #=> MyInteractor::Context
+        def context_class
+          const_get 'Context'
+        end
+      end
+    end
+  end
+end

data/lib/active_interactor/interactor/execution.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Interactor
+    module Execution
+      extend ActiveSupport::Concern
+
+      DELEGATED_WORKER_METHODS = %i[
+        execute_perform
+        execute_perform!
+        execute_rollback
+      ].freeze
+
+      included do
+        delegate(*DELEGATED_WORKER_METHODS, to: :worker)
+      end
+
+      private
+
+      def worker
+        Worker.new(self)
+      end
+    end
+  end
+end

data/lib/active_interactor/interactor/worker.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Interactor
+    class Worker
+      delegate :run_callbacks, to: :interactor
+
+      # A new instance of {Worker}
+      # @param interactor [ActiveInteractor::Base] an interactor instance
+      # @return [ActiveInteractor::Interactor::Worker] a new instance of {Worker}
+      def initialize(interactor)
+        @interactor = clone_interactor(interactor)
+      end
+
+      # Calls {#execute_perform!} and rescues {ActiveInteractor::Context::Failure}
+      # @return [ActiveInteractor::Context::Base] an instance of {ActiveInteractor::Context::Base}
+      def execute_perform
+        execute_perform!
+      rescue ActiveInteractor::Context::Failure => exception
+        ActiveInteractor.logger.error("ActiveInteractor: #{exception}")
+        context
+      end
+
+      # Calls {Interactor#perform} with callbacks and context validation
+      # @raise [ActiveInteractor::Context::Failure] if the context fails
+      # @return [ActiveInteractor::Context::Base] an instance of {ActiveInteractor::Context::Base}
+      def execute_perform!
+        run_callbacks :perform do
+          perform!
+          finalize_context!
+          context
+        rescue # rubocop:disable Style/RescueStandardError
+          context.rollback!
+          raise
+        end
+      end
+
+      # Calls {Interactor#rollback} with callbacks
+      def execute_rollback
+        run_callbacks :rollback do
+          interactor.rollback
+        end
+      end
+
+      private
+
+      attr_reader :interactor
+
+      def clone_interactor(interactor)
+        cloned = interactor.clone
+        cloned.send(:context=, cloned.send(:context).clone)
+        cloned
+      end
+
+      def context
+        interactor.send(:context)
+      end
+
+      def fail_on_invalid_context!(validation_context = nil)
+        context.fail! if should_fail_on_invalid_context?(validation_context)
+      end
+
+      def finalize_context!
+        context.clean! if interactor.should_clean_context?
+        context.called!
+      end
+
+      def perform!
+        fail_on_invalid_context!(:calling)
+        interactor.perform
+        fail_on_invalid_context!(:called)
+      end
+
+      def should_fail_on_invalid_context?(validation_context)
+        !validate_context(validation_context) && interactor.fail_on_invalid_context?
+      end
+
+      def validate_context(validation_context = nil)
+        run_callbacks :validation do
+          init_validation_context = context.validation_context
+          context.validation_context = validation_context || init_validation_context
+          context.valid?
+        ensure
+          context.validation_context = init_validation_context
+        end
+      end
+    end
+  end
+end