activeinteractor 0.1.7 → 1.0.0.beta.1

data/lib/active_interactor/interactor/context.rb

@@ -1,96 +1,130 @@
 # frozen_string_literal: true
 
+require 'active_model'
+require 'active_support/core_ext/string/inflections'
+
 module ActiveInteractor
   module Interactor
-    # Provides ActiveInteractor::Interactor::Context methods to included classes
-    #
-    # @api private
+    # Interactor context methods included by all {Base}
     # @author Aaron Allen <hello@aaronmallen.me>
     # @since 0.0.1
-    # @version 0.2
+    # @!attribute [rw] context
+    #  @api private
+    #  @return [Context::Base] an instance of the interactor's context class
     module Context
-      extend ActiveSupport::Concern
+      # @!method context_fail!(errors = nil)
+      # Fail the interactor's context
+      # @since 1.0.0
+      # @see ActiveInteractor::Context::Base#fail!
+
+      # @!method context_rollback!
+      # Rollback the interactor's context
+      # @since 1.0.0
+      # @see ActiveInteractor::Context::Base#rollback!
+
+      # @!method context_valid?(context = nil)
+      # Whether or not the interactor's context is valid
+      # @since 1.0.0
+      # @see ActiveInteractor::Context::Base#valid?
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+          delegate :fail!, :rollback!, to: :context, prefix: true
+          delegate(*ActiveModel::Validations.instance_methods, to: :context, prefix: true)
+          delegate(*ActiveModel::Validations::HelperMethods.instance_methods, to: :context, prefix: true)
 
-      included do
-        extend ClassMethods
-        include Callbacks
+          private
 
-        delegate(*ActiveModel::Validations.instance_methods, to: :context, prefix: true)
-        delegate(*ActiveModel::Validations::HelperMethods.instance_methods, to: :context, prefix: true)
+          attr_accessor :context
+        end
       end
 
+      # Interactor context class methods extended by all {Base}
       module ClassMethods
         delegate(*ActiveModel::Validations::ClassMethods.instance_methods, to: :context_class, prefix: :context)
         delegate(*ActiveModel::Validations::HelperMethods.instance_methods, to: :context_class, prefix: :context)
+        # @!method context_attributes(*attributes)
+        # Set or get attributes defined on the interactor's context class
+        # @since 0.0.1
+        # @see ActiveInteractor::Context::Attributes#attributes
+        delegate :attributes, 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
+        # The context class of the interactor
+        # @note If a context class is not defined on the interactor
+        #  with {#contextualize_with} ActiveInteractor will attempt
+        #  to find a class with the naming conventions:
+        #    `MyInteractor::Context` or `MyInteractorContext`
+        #  if no matching context class is found a context class
+        #  will be created with the naming convention: `MyInteractor::Context`.
+        # @example With an existing class named `MyInteractor::Context`
+        #  class MyInteractor::Context < ActiveInteractor::Context::Base
         #  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
-
-        # Assign attribute aliases to the context class of the interactor
-        #  any aliases passed to the context will be assigned to the
-        #  key of the aliases hash
-        #
-        # @example Assign attribute aliases to the context class
-        #  class MyInteractor > ActiveInteractor::Base
-        #   context_attributes :first_name, :last_name
-        #   context_attribute_aliases last_name: :sir_name
+        #  class MyInteractor < ActiveInteractor::Base
         #  end
         #
-        #  MyInteractor::Context.attribute_aliases
-        #  #=> { last_name: [:sir_name] }
-        #
-        #  class MyInteractor > ActiveInteractor::Base
-        #   context_attributes :first_name, :last_name
-        #   context_attribute_aliases last_name: %i[sir_name, sirname]
+        #  MyInteractor.context_class
+        #  #=> MyInteractor::Context
+        # @example With an existing class named `MyInteractorContext`
+        #  class MyInteractorContext < ActiveInteractor::Context::Base
         #  end
         #
-        #  MyInteractor::Context.attribute_aliases
-        #  #=> { last_name: [:sir_name, :sirname] }
-        #
-        #  context = MyInteractor.perform(first_name: 'Aaron', sir_name: 'Allen')
-        #  #=> <#MyInteractor::Context first_name='Aaron', last_name='Allen')
-        #
-        #  context.sir_name
-        #  #=> nil
-        #
-        #  context.last_name
-        #  #=> 'Allen'
-        #
-        # @param aliases [Hash{Symbol => Symbol, Array<Symbol>}] the attribute aliases
-        #
-        # @return [Hash{Symbol => Array<Symbol>}] the attribute aliases
-        def context_attribute_aliases(aliases = {})
-          context_class.alias_attributes(aliases)
-        end
-
-        # The context class of the interactor
+        #  class MyInteractor < ActiveInteractor::Base
+        #  end
         #
-        # @example
+        #  MyInteractor.context_class
+        #  #=> MyInteractorContext
+        # @example With no existing context class
         #  class MyInteractor < ActiveInteractor::Base
         #  end
         #
         #  MyInteractor.context_class
         #  #=> MyInteractor::Context
+        # @return [Class] the interactor's context class
         def context_class
-          const_get 'Context'
+          @context_class ||= ActiveInteractor::Context::Loader.find_or_create(self)
+        end
+
+        # Manual define an interactor's context class
+        # @since 1.0.0
+        # @example
+        #   class AGenericContext < ActiveInteractor::Context::Base
+        #   end
+        #
+        #   class MyInteractor < ActiveInteractor::Base
+        #     contextualize_with :a_generic_context
+        #   end
+        #
+        #   MyInteractor.context_class
+        #   #=> AGenericContext
+        # @param klass [String|Symbol|Class] the context class
+        # @raise [Error::InvalidContextClass] if no matching class can be found
+        # @return [Class] the context class
+        def contextualize_with(klass)
+          @context_class = begin
+            context_class = klass.to_s.classify.safe_constantize
+            raise(Error::InvalidContextClass, klass) unless context_class
+
+            context_class
+          end
         end
       end
+
+      # @api private
+      # @param context [Context::Base|Hash] attributes to assign to the context
+      # @return [Base] a new instane of {Base}
+      def initialize(context = {})
+        @context = self.class.context_class.new(context)
+      end
+
+      # @api private
+      # Mark the interactor's context as called and return the context
+      # @since 1.0.0
+      # @return [Context::Base] an instance of the interactor's context class
+      def finalize_context!
+        context.called!(self)
+        context
+      end
     end
   end
 end

data/lib/active_interactor/interactor/worker.rb

@@ -2,39 +2,40 @@
 
 module ActiveInteractor
   module Interactor
-    # A worker class responsible for thread safe execution
-    #  of interactor {.perform} methods.
-    #
+    # @api private
+    # Thread safe execution of interactor {Interactor#perform #perform} and
+    #  {Interactor#rollback #rollback} methods.
     # @author Aaron Allen <hello@aaronmallen.me>
     # @since 0.0.2
-    # @version 0.1
     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}
+      # @param interactor [Base] an instance of interactor
+      # @return [Worker] a new instance of {Worker}
       def initialize(interactor)
-        @interactor = clone_interactor(interactor)
+        @interactor = interactor.dup
       end
 
-      # Calls {#execute_perform!} and rescues {ActiveInteractor::Error::ContextFailure}
-      # @return [ActiveInteractor::Context::Base] an instance of {ActiveInteractor::Context::Base}
+      # Calls {#execute_perform!} and rescues {Error::ContextFailure}
+      # @return [Context::Base] an instance of {Context::Base}
       def execute_perform
         execute_perform!
-      rescue ActiveInteractor::Error::ContextFailure => e
-        log_context_failure(e)
+      rescue Error::ContextFailure => e
+        ActiveInteractor.logger.error("ActiveInteractor: #{e}")
         context
       end
 
       # Calls {Interactor#perform} with callbacks and context validation
-      # @raise [ActiveInteractor::Error::ContextFailure] if the context fails
-      # @return [ActiveInteractor::Context::Base] an instance of {ActiveInteractor::Context::Base}
+      # @raise [Error::ContextFailure] if the context fails
+      # @return [Context::Base] an instance of {Context::Base}
       def execute_perform!
         run_callbacks :perform do
           execute_context!
-        rescue => e # rubocop:disable Style/RescueStandardError
-          rollback_context_and_raise!(e)
+          @context = interactor.finalize_context!
+        rescue StandardError
+          @context = interactor.finalize_context!
+          execute_rollback
+          raise
         end
       end
 
@@ -43,67 +44,23 @@ module ActiveInteractor
       #  rolled back
       def execute_rollback
         run_callbacks :rollback do
-          interactor.rollback
+          interactor.context_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
+      attr_reader :context, :interactor
 
       def execute_context!
-        perform!
-        context
-      ensure
-        finalize_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 log_context_failure(exception)
-        ActiveInteractor.logger.error("ActiveInteractor: #{exception}")
-      end
-
-      def perform!
-        fail_on_invalid_context!(:calling)
+        interactor.context_fail! unless validate_context(:calling)
         interactor.perform
-        fail_on_invalid_context!(:called)
-      end
-
-      def rollback_context_and_raise!(exception)
-        context.rollback!
-        context.send(:mark_failed!)
-        raise exception
-      end
-
-      def should_fail_on_invalid_context?(validation_context)
-        !validate_context(validation_context) && interactor.fail_on_invalid_context?
+        interactor.context_fail! unless validate_context(:called)
       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
+          interactor.context_valid?(validation_context)
         end
       end
     end

data/lib/active_interactor/organizer.rb

@@ -1,190 +1,206 @@
 # frozen_string_literal: true
 
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/string/inflections'
+
 module ActiveInteractor
-  # The Base Interactor class inherited by all Interactor::Organizers
-  #
+  # A base Organizer class.  All organizers should inherit from
+  #  {Organizer}.
   # @author Aaron Allen <hello@aaronmallen.me>
   # @since 0.0.1
-  # @version 0.3
-  class Organizer < ActiveInteractor::Base
+  # @!attribute [r] organized
+  #  @!scope class
+  #  @return [Array<Base>] the organized interactors
+  # @example a basic organizer
+  #  class MyInteractor1 < ActiveInteractor::Base
+  #    def perform
+  #      context.interactor1 = true
+  #    end
+  #  end
+  #
+  #  class MyInteractor2 < ActiveInteractor::Base
+  #    def perform
+  #      context.interactor2 = true
+  #    end
+  #  end
+  #
+  #  class MyOrganizer < ActiveInteractor::Organizer
+  #    organize MyInteractor1, MyInteractor2
+  #  end
+  #
+  #  MyOrganizer.perform
+  #  #=> <MyOrganizer::Context interactor1=true interactor2=true>
+  class Organizer < Base
+    class_attribute :organized, instance_writer: false, default: []
     define_callbacks :each_perform
 
-    class << self
-      # Define a callback to call after each organized interactor's
-      #  {ActiveInteractor::Base.perform} has been invoked
-      #
-      # @example
-      #  class MyInteractor1 < ActiveInteractor::Base
-      #    before_perform :print_name
-      #
-      #    def perform
-      #      puts 'MyInteractor1'
-      #    end
-      #  end
-      #
-      #  class MyInteractor2 < ActiveInteractor::Base
-      #    before_perform :print_name
-      #
-      #    def perform
-      #      puts 'MyInteractor2'
-      #    end
-      #  end
-      #
-      #  class MyOrganizer < ActiveInteractor::Organizer
-      #    after_each_perform :print_done
-      #
-      #    organized MyInteractor1, MyInteractor2
-      #
-      #    private
-      #
-      #    def print_done
-      #      puts "done"
-      #    end
-      #  end
-      #
-      #  MyOrganizer.perform(name: 'Aaron')
-      #  "MyInteractor1"
-      #  "Done"
-      #  "MyInteractor2"
-      #  "Done"
-      #  #=> <MyOrganizer::Context name='Aaron'>
-      def after_each_perform(*filters, &block)
-        set_callback(:each_perform, :after, *filters, &block)
-      end
-
-      # Define a callback to call around each organized interactor's
-      #  {ActiveInteractor::Base.perform} has been invokation
-      #
-      # @example
-      #  class MyInteractor1 < ActiveInteractor::Base
-      #    before_perform :print_name
-      #
-      #    def perform
-      #      puts 'MyInteractor1'
-      #    end
-      #  end
-      #
-      #  class MyInteractor2 < ActiveInteractor::Base
-      #    before_perform :print_name
-      #
-      #    def perform
-      #      puts 'MyInteractor2'
-      #    end
-      #  end
-      #
-      #  class MyOrganizer < ActiveInteractor::Organizer
-      #    around_each_perform :print_time
-      #
-      #    organized MyInteractor1, MyInteractor2
-      #
-      #    private
-      #
-      #    def print_time
-      #      puts Time.now.utc
-      #      yield
-      #      puts Time.now.utc
-      #    end
-      #  end
-      #
-      #  MyOrganizer.perform(name: 'Aaron')
-      #  "2019-04-01 00:00:00 UTC"
-      #  "MyInteractor1"
-      #  "2019-04-01 00:00:01 UTC"
-      #  "2019-04-01 00:00:02 UTC"
-      #  "MyInteractor2"
-      #  "2019-04-01 00:00:03 UTC"
-      #  #=> <MyOrganizer::Context name='Aaron'>
-      def around_each_perform(*filters, &block)
-        set_callback(:each_perform, :around, *filters, &block)
-      end
+    # Define a callback to call after each organized interactor's
+    #  {Base.perform} has been invoked
+    # @example
+    #  class MyInteractor1 < ActiveInteractor::Base
+    #    before_perform :print_name
+    #
+    #    def perform
+    #      puts 'MyInteractor1'
+    #    end
+    #  end
+    #
+    #  class MyInteractor2 < ActiveInteractor::Base
+    #    before_perform :print_name
+    #
+    #    def perform
+    #      puts 'MyInteractor2'
+    #    end
+    #  end
+    #
+    #  class MyOrganizer < ActiveInteractor::Organizer
+    #    after_each_perform :print_done
+    #
+    #    organized MyInteractor1, MyInteractor2
+    #
+    #    private
+    #
+    #    def print_done
+    #      puts "done"
+    #    end
+    #  end
+    #
+    #  MyOrganizer.perform(name: 'Aaron')
+    #  "MyInteractor1"
+    #  "Done"
+    #  "MyInteractor2"
+    #  "Done"
+    #  #=> <MyOrganizer::Context name='Aaron'>
+    def self.after_each_perform(*filters, &block)
+      set_callback(:each_perform, :after, *filters, &block)
+    end
 
-      # Define a callback to call before each organized interactor's
-      #  {ActiveInteractor::Base.perform} has been invoked
-      #
-      # @example
-      #  class MyInteractor1 < ActiveInteractor::Base
-      #    before_perform :print_name
-      #
-      #    def perform
-      #      puts 'MyInteractor1'
-      #    end
-      #  end
-      #
-      #  class MyInteractor2 < ActiveInteractor::Base
-      #    before_perform :print_name
-      #
-      #    def perform
-      #      puts 'MyInteractor2'
-      #    end
-      #  end
-      #
-      #  class MyOrganizer < ActiveInteractor::Organizer
-      #    before_each_perform :print_start
-      #
-      #    organized MyInteractor1, MyInteractor2
-      #
-      #    private
-      #
-      #    def print_start
-      #      puts "Start"
-      #    end
-      #  end
-      #
-      #  MyOrganizer.perform(name: 'Aaron')
-      #  "Start"
-      #  "MyInteractor1"
-      #  "Start"
-      #  "MyInteractor2"
-      #  #=> <MyOrganizer::Context name='Aaron'>
-      def before_each_perform(*filters, &block)
-        set_callback(:each_perform, :before, *filters, &block)
-      end
+    # Define a callback to call around each organized interactor's
+    #  {Base.perform} has been invokation
+    #
+    # @example
+    #  class MyInteractor1 < ActiveInteractor::Base
+    #    before_perform :print_name
+    #
+    #    def perform
+    #      puts 'MyInteractor1'
+    #    end
+    #  end
+    #
+    #  class MyInteractor2 < ActiveInteractor::Base
+    #    before_perform :print_name
+    #
+    #    def perform
+    #      puts 'MyInteractor2'
+    #    end
+    #  end
+    #
+    #  class MyOrganizer < ActiveInteractor::Organizer
+    #    around_each_perform :print_time
+    #
+    #    organized MyInteractor1, MyInteractor2
+    #
+    #    private
+    #
+    #    def print_time
+    #      puts Time.now.utc
+    #      yield
+    #      puts Time.now.utc
+    #    end
+    #  end
+    #
+    #  MyOrganizer.perform(name: 'Aaron')
+    #  "2019-04-01 00:00:00 UTC"
+    #  "MyInteractor1"
+    #  "2019-04-01 00:00:01 UTC"
+    #  "2019-04-01 00:00:02 UTC"
+    #  "MyInteractor2"
+    #  "2019-04-01 00:00:03 UTC"
+    #  #=> <MyOrganizer::Context name='Aaron'>
+    def self.around_each_perform(*filters, &block)
+      set_callback(:each_perform, :around, *filters, &block)
+    end
 
-      # Declare Interactors to be invoked as part of the
-      #  organizer's invocation. These interactors are invoked in
-      #  the order in which they are declared
-      #
-      # @example
-      #   class MyFirstOrganizer < ActiveInteractor::Organizer
-      #     organize InteractorOne, InteractorTwo
-      #   end
-      #
-      #   class MySecondOrganizer < ActiveInteractor::Organizer
-      #     organize [InteractorThree, InteractorFour]
-      #   end
-      #
-      # @param interactors [Array<ActiveInteractor::Base>] the interactors to call
-      def organize(*interactors)
-        @organized = interactors.flatten
-      end
+    # Define a callback to call before each organized interactor's
+    #  {Base.perform} has been invoked
+    #
+    # @example
+    #  class MyInteractor1 < ActiveInteractor::Base
+    #    before_perform :print_name
+    #
+    #    def perform
+    #      puts 'MyInteractor1'
+    #    end
+    #  end
+    #
+    #  class MyInteractor2 < ActiveInteractor::Base
+    #    before_perform :print_name
+    #
+    #    def perform
+    #      puts 'MyInteractor2'
+    #    end
+    #  end
+    #
+    #  class MyOrganizer < ActiveInteractor::Organizer
+    #    before_each_perform :print_start
+    #
+    #    organized MyInteractor1, MyInteractor2
+    #
+    #    private
+    #
+    #    def print_start
+    #      puts "Start"
+    #    end
+    #  end
+    #
+    #  MyOrganizer.perform(name: 'Aaron')
+    #  "Start"
+    #  "MyInteractor1"
+    #  "Start"
+    #  "MyInteractor2"
+    #  #=> <MyOrganizer::Context name='Aaron'>
+    def self.before_each_perform(*filters, &block)
+      set_callback(:each_perform, :before, *filters, &block)
+    end
 
-      # An Array of declared Interactors to be invoked
-      # @return [Array<ActiveInteractor::Base] the organized interactors
-      def organized
-        @organized ||= []
-      end
+    # Declare Interactors to be invoked as part of the
+    #  organizer's invocation. These interactors are invoked in
+    #  the order in which they are declared
+    #
+    # @example
+    #   class MyFirstOrganizer < ActiveInteractor::Organizer
+    #     organize InteractorOne, InteractorTwo
+    #   end
+    #
+    #   class MySecondOrganizer < ActiveInteractor::Organizer
+    #     organize [InteractorThree, InteractorFour]
+    #   end
+    #
+    # @param interactors [Array<Base>] the interactors to call
+    def self.organize(*interactors)
+      self.organized = interactors.flatten.map do |interactor|
+        interactor.to_s.classify.safe_constantize
+      end.compact
     end
 
     # Invoke the organized interactors. An organizer is
-    #  expected not to define its own {ActiveInteractor::Interactor#perform #perform} method
+    #  expected not to define its own {Base#perform} method
     #  in favor of this default implementation.
     def perform
       self.class.organized.each do |interactor|
-        execute_interactor_perform_with_callbacks!(interactor)
+        self.context = execute_interactor_perform_with_callbacks!(interactor)
       end
+    rescue Error::ContextFailure => e
+      self.context = e.context
+    ensure
+      self.context = self.class.context_class.new(context)
     end
 
     private
 
-    def execute_interactor_perform!(interactor)
-      self.context = interactor.new(context)
-                               .tap(&:skip_clean_context!)
-                               .execute_perform!
-    end
-
     def execute_interactor_perform_with_callbacks!(interactor)
       run_callbacks :each_perform do
-        execute_interactor_perform!(interactor)
+        interactor.new(context).execute_perform!
       end
     end
   end