activeinteractor 1.2.2 → 2.0.0.alpha.1.0.0

data/lib/active_interactor/interactor/worker.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  module Interactor
-    # A worker class to call {Base interactor} {Interactor::Perform#perform #perform} and
-    # {Interactor::Perform#rollback #rollback} methods in a thread safe manner.
-    #
-    # @api private
-    # @author Aaron Allen <hello@aaronmallen.me>
-    # @since 0.1.0
-    class Worker
-      # Initialize a new instance of {Worker}
-      #
-      # @param interactor [Base] an {Base interactor} instance
-      # @return [Worker] a new instance of {Worker}
-      def initialize(interactor)
-        @interactor = interactor.deep_dup
-      end
-
-      # Run the {Base interactor} instance's {Interactor::Perform#perform #perform} with callbacks and validation.
-      #
-      # @return [Class] a {ActiveInteractor::Context::Base context} instance
-      def execute_perform
-        execute_perform!
-      rescue Error::ContextFailure => e
-        ActiveInteractor.logger.error("ActiveInteractor: #{e}")
-        context
-      end
-
-      # Run the {Base interactor} instance's {Interactor::Perform#perform #perform} with callbacks and validation
-      # without rescuing {Error::ContextFailure}.
-      #
-      # @raise [Error::ContextFailure] if the {Base interactor} fails it's {ActiveInteractor::Context::Base context}
-      # @return [Class] a {ActiveInteractor::Context::Base context} instance
-      def execute_perform!
-        execute_context!
-      rescue StandardError => e
-        handle_error(e)
-      end
-
-      # Run the {Base interactor} instance's {Interactor::Perform#rollback #rollback} with callbacks
-      #
-      # @return [Boolean] `true` if context was successfully rolled back
-      def execute_rollback
-        return if interactor.options.skip_rollback
-
-        execute_interactor_rollback!
-      end
-
-      private
-
-      attr_reader :context, :interactor
-
-      def execute_context!
-        if interactor.options.skip_perform_callbacks
-          execute_context_with_validation_check!
-        else
-          execute_context_with_callbacks!
-        end
-      end
-
-      def execute_context_with_callbacks!
-        result = interactor.run_callbacks :perform do
-          execute_context_with_validation_check!
-          @context = interactor.finalize_context!
-        end
-
-        if context&.success? && interactor.respond_to?(:run_deferred_after_perform_callbacks_on_children)
-          interactor.run_deferred_after_perform_callbacks_on_children
-        end
-
-        result
-      end
-
-      def execute_context_with_validation!
-        validate_on_calling
-        interactor.perform
-        validate_on_called
-      end
-
-      def execute_context_with_validation_check!
-        return interactor.perform unless interactor.options.validate
-
-        execute_context_with_validation!
-      end
-
-      def execute_interactor_rollback!
-        return interactor.context_rollback! if interactor.options.skip_rollback_callbacks
-
-        interactor.run_callbacks :rollback do
-          interactor.context_rollback!
-        end
-      end
-
-      def handle_error(exception)
-        @context = interactor.finalize_context!
-        execute_rollback
-        raise exception
-      end
-
-      def validate_context(validation_context = nil)
-        interactor.run_callbacks :validation do
-          interactor.context_valid?(validation_context)
-        end
-      end
-
-      def validate_on_calling
-        return unless interactor.options.validate_on_calling
-
-        interactor.context_fail! unless validate_context(:calling)
-      end
-
-      def validate_on_called
-        return unless interactor.options.validate_on_called
-
-        interactor.context_fail! unless validate_context(:called)
-      end
-    end
-  end
-end

data/lib/active_interactor/models.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  # Helper methods for using classes that do not inherit from {Context::Base} as {Context::Base context} objects
-  # for {Base interactors}.  Classes should extend {Models}.
-  #
-  # @author Aaron Allen <hello@aaronmallen.me>
-  # @since 1.0.0
-  module Models
-    # Instance methods needed for a {Context::Base context} class to function properly.
-    #
-    # @private
-    # @author Aaron Allen <hello@aaronmallen.me>
-    # @since 1.0.0
-    module InstanceMethods
-      def initialize(*)
-        @attributes = self.class._default_attributes&.deep_dup
-        super
-      end
-    end
-
-    # Include methods needed for a {Context::Base context} class to function properly.
-    #
-    # @note You must include ActiveModel::Model and ActiveModel::Attributes or a similar implementation for
-    #  the object to function properly.
-    #
-    # @example
-    #   class User
-    #     include ActiveModel::Model
-    #     include ActiveModel::Attributes
-    #     extend ActiveInteractor::Models
-    #     acts_as_context
-    #   end
-    #
-    #   class MyInteractor < ActiveInteractor::Base
-    #     contextualize_with :user
-    #   end
-    def acts_as_context
-      class_eval do
-        extend ActiveInteractor::Context::Attributes::ClassMethods
-
-        include ActiveInteractor::Context::Attributes
-        include ActiveInteractor::Context::Errors
-        include ActiveInteractor::Context::Status
-        include ActiveInteractor::Models::InstanceMethods
-        delegate :each_pair, to: :attributes
-      end
-    end
-  end
-end

data/lib/active_interactor/organizer/base.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  module Organizer
-    # The base {Base organizer} class all {Base organizers} should inherit from.
-    #
-    # @author Aaron Allen <hello@aaronmallen.me>
-    # @since 1.0.0
-    class Base < ActiveInteractor::Base
-      extend ActiveInteractor::Organizer::Callbacks::ClassMethods
-      extend ActiveInteractor::Organizer::Organize::ClassMethods
-      extend ActiveInteractor::Organizer::Perform::ClassMethods
-
-      include ActiveInteractor::Organizer::Callbacks
-      include ActiveInteractor::Organizer::Perform
-    end
-  end
-end

data/lib/active_interactor/organizer/callbacks.rb

@@ -1,275 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  module Organizer
-    # Organizer callback methods. Because {Callbacks} is a module classes should include {Callbacks} rather than
-    # inherit from it.
-    #
-    # @author Aaron Allen <hello@aaronmallen.me>
-    # @since 1.0.0
-    # @see https://github.com/aaronmallen/activeinteractor/wiki/Callbacks Callbacks
-    # @see https://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html ActiveSupport::Callbacks
-    module Callbacks
-      # Organizer callback class methods. Because {ClassMethods} is a module classes should extend {ClassMethods}
-      # rather than inherit from it.
-      #
-      # @author Aaron Allen
-      # @since 1.0.0
-      module ClassMethods
-        # Define a callback to call after each {Organizer::Organize::ClassMethods#organized organized}
-        # {ActiveInteractor::Base interactor's} {Interactor::Perform#perform #perform} method has been called.
-        #
-        # @since 0.1.3
-        #
-        # @example
-        #  class MyInteractor1 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor1'
-        #    end
-        #  end
-        #
-        #  class MyInteractor2 < ActiveInteractor::Base
-        #    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
-        #  "MyInteractor1"
-        #  "Done"
-        #  "MyInteractor2"
-        #  "Done"
-        #  #=> <MyOrganizer::Context>
-        def after_each_perform(*filters, &block)
-          set_callback(:each_perform, :after, *filters, &block)
-        end
-
-        # Define a callback to call around each {Organizer::Organize::ClassMethods#organized organized}
-        # {ActiveInteractor::Base interactor's} {Interactor::Perform#perform #perform} method call.
-        #
-        # @since 0.1.3
-        #
-        # @example
-        #  class MyInteractor1 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor1'
-        #      sleep(1)
-        #    end
-        #  end
-        #
-        #  class MyInteractor2 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor2'
-        #      sleep(1)
-        #    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
-        #  "2019-04-01 00:00:00 UTC"
-        #  "MyInteractor1"
-        #  "2019-04-01 00:00:01 UTC"
-        #  "2019-04-01 00:00:01 UTC"
-        #  "MyInteractor2"
-        #  "2019-04-01 00:00:02 UTC"
-        #  #=> <MyOrganizer::Context>
-        def around_each_perform(*filters, &block)
-          set_callback(:each_perform, :around, *filters, &block)
-        end
-
-        # Define a callback to call before each {Organizer::Organize::ClassMethods#organized organized}
-        # {ActiveInteractor::Base interactor's} {Interactor::Perform#perform #perform} method has been called.
-        #
-        # @since 0.1.3
-        #
-        # @example
-        #  class MyInteractor1 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor1'
-        #    end
-        #  end
-        #
-        #  class MyInteractor2 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor2'
-        #    end
-        #  end
-        #
-        #  class MyOrganizer < ActiveInteractor::Organizer
-        #    before_each_perform :print_starting
-        #
-        #    organized MyInteractor1, MyInteractor2
-        #
-        #    private
-        #
-        #    def print_starting
-        #      puts 'Starting'
-        #    end
-        #  end
-        #
-        #  MyOrganizer.perform
-        #  "Starting"
-        #  "MyInteractor1"
-        #  "Starting"
-        #  "MyInteractor2"
-        #  #=> <MyOrganizer::Context>
-        def before_each_perform(*filters, &block)
-          set_callback(:each_perform, :before, *filters, &block)
-        end
-
-        # Define a callback to call after all {Organizer::Organize::ClassMethods#organized organized}
-        # {ActiveInteractor::Base interactors'} {Interactor::Perform#perform #perform} methods have been called.
-        #
-        # @since v1.2.0
-        #
-        # @example
-        #  class MyInteractor1 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor1'
-        #    end
-        #  end
-        #
-        #  class MyInteractor2 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor2'
-        #    end
-        #  end
-        #
-        #  class MyOrganizer < ActiveInteractor::Organizer
-        #    after_all_perform :print_done
-        #
-        #    organized MyInteractor1, MyInteractor2
-        #
-        #    private
-        #
-        #    def print_done
-        #      puts 'Done'
-        #    end
-        #  end
-        #
-        #  MyOrganizer.perform
-        #  "MyInteractor1"
-        #  "MyInteractor2"
-        #  "Done"
-        #  #=> <MyOrganizer::Context>
-        def after_all_perform(*filters, &block)
-          set_callback(:all_perform, :after, *filters, &block)
-        end
-
-        # Define a callback to call around all {Organizer::Organize::ClassMethods#organized organized}
-        # {ActiveInteractor::Base interactors'} {Interactor::Perform#perform #perform} method calls.
-        #
-        # @since v1.2.0
-        #
-        # @example
-        #  class MyInteractor1 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor1'
-        #      sleep(1)
-        #    end
-        #  end
-        #
-        #  class MyInteractor2 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor2'
-        #      sleep(1)
-        #    end
-        #  end
-        #
-        #  class MyOrganizer < ActiveInteractor::Organizer
-        #    around_all_perform :print_time
-        #
-        #    organized MyInteractor1, MyInteractor2
-        #
-        #    private
-        #
-        #    def print_time
-        #      puts Time.now.utc
-        #      yield
-        #      puts Time.now.utc
-        #    end
-        #  end
-        #
-        #  MyOrganizer.perform
-        #  "2019-04-01 00:00:00 UTC"
-        #  "MyInteractor1"
-        #  "MyInteractor2"
-        #  "2019-04-01 00:00:02 UTC"
-        #  #=> <MyOrganizer::Context>
-        def around_all_perform(*filters, &block)
-          set_callback(:all_perform, :around, *filters, &block)
-        end
-
-        # Define a callback to call before all {Organizer::Organize::ClassMethods#organized organized}
-        # {ActiveInteractor::Base interactors'} {Interactor::Perform#perform #perform} methods have been called.
-        #
-        # @since v1.2.0
-        #
-        # @example
-        #  class MyInteractor1 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor1'
-        #    end
-        #  end
-        #
-        #  class MyInteractor2 < ActiveInteractor::Base
-        #    def perform
-        #      puts 'MyInteractor2'
-        #    end
-        #  end
-        #
-        #  class MyOrganizer < ActiveInteractor::Organizer
-        #    before_all_perform :print_starting
-        #
-        #    organized MyInteractor1, MyInteractor2
-        #
-        #    private
-        #
-        #    def print_starting
-        #      puts 'Starting'
-        #    end
-        #  end
-        #
-        #  MyOrganizer.perform
-        #  "Starting"
-        #  "MyInteractor1"
-        #  "MyInteractor2"
-        #  #=> <MyOrganizer::Context>
-        def before_all_perform(*filters, &block)
-          set_callback(:all_perform, :before, *filters, &block)
-        end
-      end
-
-      def self.included(base)
-        base.class_eval do
-          define_callbacks :each_perform, :all_perform
-        end
-      end
-    end
-  end
-end

data/lib/active_interactor/organizer/interactor_interface.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  module Organizer
-    # An interface object to facilitate conditionally calling {Interactor::Perform::ClassMethods#perform .perform} on
-    # an {ActiveInteractor::Base interactor}
-    #
-    # @api private
-    # @author Aaron Allen <hello@aaronmallen.me>
-    # @since 1.0.0
-    #
-    # @!attribute [r] filters
-    #  Conditional options for the {ActiveInteractor::Base interactor} class
-    #
-    #  @return [Hash{Symbol=>Proc, Symbol}] conditional options for the {ActiveInteractor::Base interactor} class
-    #
-    # @!attribute [r] callbacks
-    #   Callbacks for the interactor_class
-    #
-    #   @since 1.1.0
-    #
-    #   @return [Hash{Symbol=>*}] the interactor callbacks
-    #
-    # @!attribute [r] interactor_class
-    #  An {ActiveInteractor::Base interactor} class
-    #
-    #  @return [Const] an {ActiveInteractor::Base interactor} class
-    #
-    # @!attribute [r] perform_options
-    #  {Interactor::Perform::Options} for the {ActiveInteractor::Base interactor} {Interactor::Perform#perform #perform}
-    #
-    #  @see Interactor::Perform::Options
-    #
-    #  @return [Hash{Symbol=>*}] {Interactor::Perform::Options} for the {ActiveInteractor::Base interactor}
-    #   {Interactor::Perform#perform #perform}
-    #
-    # @!attribute [r] deferred_after_perform_callbacks
-    #   Deffered callbacks for the interactor_class
-    #   @since 1.2.0
-    #
-    #   @return [Hash{Symbol=>*}] the interactor callbacks
-    class InteractorInterface
-      attr_reader :filters, :callbacks, :interactor_class, :perform_options, :deferred_after_perform_callbacks
-
-      # Keywords for conditional filters
-      # @return [Array<Symbol>]
-      CONDITIONAL_FILTERS = %i[if unless].freeze
-      CALLBACKS = %i[before after].freeze
-
-      # Initialize a new instance of {InteractorInterface}
-      #
-      # @param interactor_class [Const] an {ActiveInteractor::Base interactor} class
-      # @param options [Hash] options to use for the {ActiveInteractor::Base interactor's}
-      #  {Interactor::Perform::ClassMethods#perform .perform}. See {Interactor::Perform::Options}.
-      # @return [InteractorInterface] a new instance of {InteractorInterface}
-      def initialize(interactor_class, options = {})
-        @interactor_class = interactor_class.to_s.camelize.safe_constantize
-        @filters = options.select { |key, _value| CONDITIONAL_FILTERS.include?(key) }
-        @callbacks = options.select { |key, _value| CALLBACKS.include?(key) }
-        @perform_options = options.reject { |key, _value| CONDITIONAL_FILTERS.include?(key) || CALLBACKS.include?(key) }
-        init_deferred_after_perform_callbacks
-      end
-
-      # Call the {#interactor_class} {Interactor::Perform::ClassMethods#perform .perform} or
-      # {Interactor::Perform::ClassMethods#perform! .perform!} method if all conditions in {#filters} are properly met.
-      #
-      # @param target [Class] the calling {Base organizer} instance
-      # @param context [Class] an instance of {Context::Base context}
-      # @param fail_on_error [Boolean] if `true` {Interactor::Perform::ClassMethods#perform! .perform!} will be called
-      #  on the {#interactor_class} other wise {Interactor::Perform::ClassMethods#perform .perform} will be called.
-      # @param perform_options [Hash] additional {Interactor::Perform::Options} to merge with {#perform_options}
-      # @raise [Error::ContextFailure] if `fail_on_error` is `true` and the {#interactor_class}
-      #  {Context::Status#fail! fails} its {Context::Base context}.
-      # @return [Class] an instance of {Context::Base context}
-      def perform(target, context, fail_on_error = false, perform_options = {})
-        return if check_conditionals(target, :if) == false
-        return if check_conditionals(target, :unless) == true
-
-        skip_deferred_after_perform_callbacks
-
-        method = fail_on_error ? :perform! : :perform
-        options = self.perform_options.merge(perform_options)
-        interactor_class.send(method, context, options)
-      end
-
-      def execute_inplace_callback(target, callback)
-        resolve_option(target, callbacks[callback])
-      end
-
-      def execute_deferred_after_perform_callbacks(context)
-        return unless deferred_after_perform_callbacks.present?
-
-        interactor = interactor_class.new(context)
-        env = ActiveSupport::Callbacks::Filters::Environment.new(interactor, false, nil)
-        deferred_after_perform_callbacks.compile.invoke_after(env)
-        interactor.send(:context)
-      end
-
-      private
-
-      def init_deferred_after_perform_callbacks
-        after_callbacks_deferred = interactor_class.present? &&
-                                   interactor_class.after_callbacks_deferred_when_organized
-        @deferred_after_perform_callbacks = after_callbacks_deferred ? interactor_class._perform_callbacks : nil
-      end
-
-      def skip_deferred_after_perform_callbacks
-        return unless deferred_after_perform_callbacks.present?
-
-        deferred_after_perform_callbacks.each do |callback|
-          interactor_class.skip_callback(:perform, :after, callback.filter, raise: false)
-        end
-      end
-
-      def check_conditionals(target, filter)
-        resolve_option(target, filters[filter])
-      end
-
-      def resolve_option(target, opt)
-        return unless opt
-
-        return target.send(opt) if opt.is_a?(Symbol)
-        return target.instance_exec(&opt) if opt.is_a?(Proc)
-      end
-    end
-  end
-end

data/lib/active_interactor/organizer/interactor_interface_collection.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  module Organizer
-    # A collection of {InteractorInterface}
-    #
-    # @api private
-    # @author Aaron Allen <hello@aaronmallen.me>
-    # @since 1.0.0
-    #
-    # @!attribute [r] collection
-    #  An array of {InteractorInterface}
-    #
-    #  @return [Array<InteractorInterface>] the {InteractorInterface} collection
-    class InteractorInterfaceCollection
-      attr_reader :collection
-
-      # @!method map(&block)
-      #  Invokes the given block once for each element of {#collection}.
-      #  @return [Array] a new array containing the values returned by the block.
-      delegate :map, to: :collection
-
-      # Initialize a new instance of {InteractorInterfaceCollection}
-      # @return [InteractorInterfaceCollection] a new instance of {InteractorInterfaceCollection}
-      def initialize
-        @collection = []
-      end
-
-      # Add an {InteractorInterface} to the {#collection}
-      #
-      # @param interactor_class [Const, Symbol, String] an {ActiveInteractor::Base interactor} class
-      # @param filters [Hash{Symbol=> Proc, Symbol}] conditional options for the {ActiveInteractor::Base interactor}
-      #  class
-      # @option filters [Proc, Symbol] :if only call the {ActiveInteractor::Base interactor}
-      #  {Interactor::Perform::ClassMethods#perform .perform} if `Proc` or `method` returns `true`
-      # @option filters [Proc, Symbol] :unless only call the {ActiveInteractor::Base interactor}
-      #  {Interactor::Perform::ClassMethods#perform .perform} if `Proc` or `method` returns `false` or `nil`
-      # @return [self] the {InteractorInterfaceCollection} instance
-      def add(interactor_class, filters = {})
-        interface = ActiveInteractor::Organizer::InteractorInterface.new(interactor_class, filters)
-        collection << interface if interface.interactor_class
-        self
-      end
-
-      # Add multiple {InteractorInterface} to the {#collection}
-      #
-      # @param interactor_classes [Array<Const, Symbol, String>] the {ActiveInteractor::Base interactor} classes
-      # @return [self] the {InteractorInterfaceCollection} instance
-      def concat(interactor_classes)
-        interactor_classes.flatten.each { |interactor_class| add(interactor_class) }
-        self
-      end
-
-      # Calls the given block once for each element in {#collection}, passing that element as a parameter.
-      # @return [self] the {InteractorInterfaceCollection} instance
-      def each(&block)
-        collection.each(&block) if block
-        self
-      end
-    end
-  end
-end