activeinteractor 1.0.0.beta.3 → 1.0.0.beta.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec758d003a313ede93fb1abbabc42cae23e071b9c675a9515006a5fb0e3a02a4
-  data.tar.gz: 6e1c83a0e0f7a37f63a9d9523cfbad34ccd8fb1996c5329e91294c772f4898bc
+  metadata.gz: b887e29c2334d776e28d0df4e79ba53b42123d47e4e6f4da6c94a2fa5b38ea78
+  data.tar.gz: e6ca29f29e435b5b73e405c41eccfa6dea8837a7316c3d3143abd97cda241347
 SHA512:
-  metadata.gz: 91ccd10ef1bd421dcf3275a980fe279de279c60a52b4815c0f4ae8b44c6d4721ed135f2e3978dd1c6cca4bc1acc3fd064013023ac89e48a1fd4fb53ba4c32f7d
-  data.tar.gz: fec0e7ab4a5976efae4b0c64cc4593789b914d8c6208966575af9f79b6ebbd495d30c2c9e5ef942a060334620b6dfca946c67c27a694a36295bf194d41cd4887
+  metadata.gz: 8f766aa0e2c50d7cec5c74def38f7e2ea9d3918354f511d2ec127cf4054c9484638f1cd6f984686e1b12ca09116f53708fd4e5f714620178c4dd73ab745d6ee3
+  data.tar.gz: 2ece11503295a16bfba3860cb8d4ad3653eca4a1399c5b8928b2780884ca81b48b3a6128c9fce11b464cd0bf2928d4f22924a7d2d6a4c4a00e71d9c7603375a2

data/CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [v1.0.0-beta.4] - 2020-01-14
+
+### Added
+
+- [#114] `ActiveInteractor::Organizer::InteractorInterface`
+- [#114] `ActiveInteractor::Organizer::InteractorInterfaceCollection`
+- [#115] `ActiveInteractor::Interactor#options`
+- [#115] `ActiveInteractor::Interactor#with_options`
+- [#115] `ActiveInteractor::Interactor::PerformOptions#skip_each_perform_callbacks`
+
+### Changed
+
+- [#115] `ActiveInteractor::Interactor::Worker#execute_perform` and `#execute_perform!` no longer accept arguments,
+   use `ActiveInteractor::Interactor#with_options` instead.
+- [#115] `ActiveInteractor::Organizer` can now skip `each_perform` callbacks with
+  the option `skip_each_perform_callbacks`
+
+### Removed
+
+- [#115] `ActiveInteractor::Interactor#execute_rollback`
+- [#115] `ActiveInteractor::Interactor::Worker#run_callbacks`
+
 ## [v1.0.0-beta.3] - 2020-01-12
 
 ### Added
@@ -147,7 +169,8 @@ and this project adheres to [Semantic Versioning].
 
 <!-- versions -->
 
-[Unreleased]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.3...HEAD
+[Unreleased]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.4...HEAD
+[v1.0.0-beta.4]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.3...v1.0.0-beta.4
 [v1.0.0-beta.3]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.2...v1.0.0-beta.3
 [v1.0.0-beta.2]: https://github.com/aaronmallen/activeinteractor/compare/v1.0.0-beta.1...v1.0.0-beta.2
 [v1.0.0-beta.1]: https://github.com/aaronmallen/activeinteractor/compare/v0.1.7...v1.0.0-beta.1
@@ -181,3 +204,5 @@ and this project adheres to [Semantic Versioning].
 [#105]: https://github.com/aaronmallen/activeinteractor/pull/105
 [#109]: https://github.com/aaronmallen/activeinteractor/pull/109
 [#110]: https://github.com/aaronmallen/activeinteractor/pull/110
+[#114]:https://github.com/aaronmallen/activeinteractor/pull/114
+[#115]: https://github.com/aaronmallen/activeinteractor/pull/115

data/README.md

@@ -11,6 +11,9 @@
 
 Ruby interactors with [ActiveModel::Validations] based on the [interactor][collective_idea_interactors] gem.
 
+**ActiveInteractor v1.0.0 is currently in beta.  For documentation on the current stable version please
+see [v0.1.7](https://github.com/aaronmallen/activeinteractor/tree/0-1-stable)**
+
 <!-- TOC -->
 
 * [Getting Started](#getting-started)
@@ -26,7 +29,8 @@ Ruby interactors with [ActiveModel::Validations] based on the [interactor][colle
     * [Kinds of Interactors](#kinds-of-interactors)
       * [Interactors](#interactors)
       * [Organizers](#organizers)
-      * [Parallel Organizers](#parallel-organizers)
+        * [Organizing Interactors Conditionally](#organizing-interactors-conditionally)
+        * [Running Interactors In Parallel](#running-interactors-in-parallel)
     * [Rollback](#rollback)
     * [Callbacks](#callbacks)
       * [Validation Callbacks](#validation-callbacks)
@@ -46,7 +50,7 @@ Ruby interactors with [ActiveModel::Validations] based on the [interactor][colle
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'activeinteractor'
+gem 'activeinteractor', '~> 1.0.0.beta.3'
 ```
 
 And then execute:
@@ -58,7 +62,7 @@ bundle
 Or install it yourself as:
 
 ```bash
-gem install activeinteractor
+gem install activeinteractor --pre
 ```
 
 ## What is an Interactor
@@ -422,7 +426,27 @@ end
 The organizer passes its context to the interactors that it organizes, one at a time and in order. Each interactor may
 change that context before it's passed along to the next interactor.
 
-##### Parallel Organizers
+###### Organizing Interactors Conditionally
+
+We can also add conditional statements to our organizer by passing a block to the `#organize` method:
+
+```ruby
+class PlaceOrder < ActiveInteractor::Organizer
+  organize do
+    add :create_order, if :user_registered?
+    add :charge_card, if: -> { context.order_number }
+    add :send_thank_you, if: -> { context.order_number }
+  end
+
+  private
+
+  def user_registered?
+    context.user&.registered?
+  end
+end
+```
+
+###### Running Interactors In Parallel
 
 Organizers can be told to run their interactors in parallel with the `#perform_in_parallel` class method.  This
 will run each interactor in parallel with one and other only passing the original context to each organizer.

data/lib/active_interactor/interactor.rb

@@ -11,7 +11,7 @@ module ActiveInteractor
         extend ClassMethods
         include Callbacks
         include Context
-        delegate :execute_perform, :execute_perform!, :execute_rollback, to: :worker
+        delegate :execute_perform, :execute_perform!, to: :worker
       end
     end
 
@@ -23,10 +23,11 @@ module ActiveInteractor
       #  MyInteractor.perform(name: 'Aaron')
       #  #=> <#MyInteractor::Context name='Aaron'>
       # @param context [Hash|Context::Base] attributes to assign to the interactor context
-      # @param options [PerformOptions|Hash] execution options for the interactor perform step
+      # @param options [Hash] execution options for the interactor perform step
+      #   see {PerformOptions}
       # @return [Context::Base] an instance of context.
-      def perform(context = {}, options = PerformOptions.new)
-        new(context).execute_perform(options)
+      def perform(context = {}, options = {})
+        new(context).with_options(options).execute_perform
       end
 
       # Run an interactor context. The {.perform!} method behaves identically to
@@ -37,14 +38,22 @@ module ActiveInteractor
       #  MyInteractor.perform!(name: 'Aaron')
       #  #=> <#MyInteractor::Context name='Aaron'>
       # @param context [Hash|Context::Base] attributes to assign to the interactor context
-      # @param options [PerformOptions|Hash] execution options for the interactor perform step
+      # @param options [Hash] execution options for the interactor perform step
+      #   see {PerformOptions}
       # @raise [Error::ContextFailure] if the context fails.
       # @return [Context::Base] an instance of context.
-      def perform!(context = {}, options = PerformOptions.new)
-        new(context).execute_perform!(options)
+      def perform!(context = {}, options = {})
+        new(context).with_options(options).execute_perform!
       end
     end
 
+    # Options for invokation of {#perform}
+    # @since 1.0.0
+    # @return [PerformOptions] the options
+    def options
+      @options ||= PerformOptions.new
+    end
+
     # Invoke an Interactor instance without any hooks, tracking, or rollback
     # @abstract It is expected that the {#perform} method is overwritten
     #  for each interactor class.
@@ -55,6 +64,15 @@ module ActiveInteractor
     #  failure is expected to overwrite the {#rollback} method.
     def rollback; end
 
+    # Set options for invokation of {#perform}
+    # @since 1.0.0
+    # @param options [PerformOptions|Hash] the perform options
+    # @return [Base] the instance of {Base}
+    def with_options(options)
+      @options = options.is_a?(PerformOptions) ? options : PerformOptions.new(options)
+      self
+    end
+
     private
 
     def worker

data/lib/active_interactor/interactor/perform_options.rb

@@ -5,6 +5,8 @@ module ActiveInteractor
     # Options object for interactor perform
     # @author Aaron Allen <hello@aaronmallen.me>
     # @since 1.0.0
+    # @!attribute [rw] skip_each_perform_callbacks
+    #   @return [Boolean] whether or not to skip :each_perform callbacks for an {Organizer}
     # @!attribute [rw] skip_perform_callbacks
     #  @return [Boolean] whether or not to skip :perform callbacks
     # @!attribute [rw] skip_rollback
@@ -19,27 +21,9 @@ module ActiveInteractor
     # @!attribute [rw] validate_on_called
     #  @return [Boolean] whether or not to run validation on :called
     class PerformOptions
-      # Default options for interactor perform
-      # @return [Hash{Symbol=>*}] the default options
-      DEFAULTS = {
-        skip_perform_callbacks: false,
-        skip_rollback: false,
-        skip_rollback_callbacks: false,
-        validate: true,
-        validate_on_calling: true,
-        validate_on_called: true
-      }.freeze
-
-      attr_accessor :skip_perform_callbacks, :skip_rollback, :skip_rollback_callbacks,
-                    :validate, :validate_on_calling, :validate_on_called
-
-      # @param options [Hash] the attributes for the {PerformOptions}
-      # @return [PerformOptions] a new instance of {PerformOptions}
-      def initialize(options = {})
-        DEFAULTS.dup.merge(options).each do |key, value|
-          instance_variable_set("@#{key}", value)
-        end
-      end
+      include ActiveInteractor::Configurable
+      defaults skip_each_perform_callbacks: false, skip_perform_callbacks: false, skip_rollback: false,
+               skip_rollback_callbacks: false, validate: true, validate_on_calling: true, validate_on_called: true
     end
   end
 end

data/lib/active_interactor/interactor/worker.rb

@@ -8,108 +8,99 @@ module ActiveInteractor
     # @author Aaron Allen <hello@aaronmallen.me>
     # @since 0.0.2
     class Worker
-      delegate :run_callbacks, to: :interactor
-
       # @param interactor [Base] an instance of interactor
       # @return [Worker] a new instance of {Worker}
       def initialize(interactor)
-        @interactor = interactor.dup
+        options = interactor.options.dup
+        @interactor = interactor.dup.with_options(options)
       end
 
       # Calls {#execute_perform!} and rescues {Error::ContextFailure}
-      # @param options [PerformOptions|Hash] execution options for the interactor perform step
       # @return [Context::Base] an instance of {Context::Base}
-      def execute_perform(options = PerformOptions.new)
-        execute_perform!(options)
+      def execute_perform
+        execute_perform!
       rescue Error::ContextFailure => e
         ActiveInteractor.logger.error("ActiveInteractor: #{e}")
         context
       end
 
       # Calls {Interactor#perform} with callbacks and context validation
-      # @param options [PerformOptions|Hash] execution options for the interactor perform step
       # @raise [Error::ContextFailure] if the context fails
       # @return [Context::Base] an instance of {Context::Base}
-      def execute_perform!(options = PerformOptions.new)
-        options = parse_options(options)
-        execute_context!(options)
+      def execute_perform!
+        execute_context!
       rescue StandardError => e
-        handle_error(e, options)
+        handle_error(e)
       end
 
       # Calls {Interactor#rollback} with callbacks
       # @return [Boolean] `true` if rolled back successfully or `false` if already
       #  rolled back
-      def execute_rollback(options = PerformOptions.new)
-        options = parse_options(options)
-        return if options.skip_rollback
+      def execute_rollback
+        return if interactor.options.skip_rollback
 
-        execute_interactor_rollback!(options)
+        execute_interactor_rollback!
       end
 
       private
 
       attr_reader :context, :interactor
 
-      def execute_context!(options)
-        if options.skip_perform_callbacks
-          execute_context_with_validation_check!(options)
+      def execute_context!
+        if interactor.options.skip_perform_callbacks
+          execute_context_with_validation_check!
         else
-          execute_context_with_callbacks!(options)
+          execute_context_with_callbacks!
         end
       end
 
-      def execute_context_with_callbacks!(options)
-        run_callbacks :perform do
-          execute_context_with_validation_check!(options)
+      def execute_context_with_callbacks!
+        interactor.run_callbacks :perform do
+          execute_context_with_validation_check!
           @context = interactor.finalize_context!
         end
       end
 
-      def execute_context_with_validation!(options)
-        validate_on_calling(options)
+      def execute_context_with_validation!
+        validate_on_calling
         interactor.perform
-        validate_on_called(options)
+        validate_on_called
       end
 
-      def execute_context_with_validation_check!(options)
-        return interactor.perform unless options.validate
+      def execute_context_with_validation_check!
+        return interactor.perform unless interactor.options.validate
 
-        execute_context_with_validation!(options)
+        execute_context_with_validation!
       end
 
-      def execute_interactor_rollback!(options)
-        return interactor.context_rollback! if options.skip_rollback_callbacks
+      def execute_interactor_rollback!
+        return interactor.context_rollback! if interactor.options.skip_rollback_callbacks
 
-        run_callbacks :rollback do
+        interactor.run_callbacks :rollback do
           interactor.context_rollback!
         end
       end
 
-      def handle_error(exception, options)
+      def handle_error(exception)
         @context = interactor.finalize_context!
-        execute_rollback(options)
+        execute_rollback
         raise exception
       end
 
-      def parse_options(options)
-        @options = options.is_a?(PerformOptions) ? options : PerformOptions.new(options)
-      end
-
       def validate_context(validation_context = nil)
-        run_callbacks :validation do
+        interactor.run_callbacks :validation do
           interactor.context_valid?(validation_context)
         end
       end
 
-      def validate_on_calling(options)
-        return unless options.validate_on_calling
+      def validate_on_calling
+        return unless interactor.options.validate_on_calling
 
         interactor.context_fail! unless validate_context(:calling)
       end
 
-      def validate_on_called(options)
-        return unless options.validate_on_called
+      def validate_on_called
+        return unless interactor.options.validate_on_called
 
         interactor.context_fail! unless validate_context(:called)
       end

data/lib/active_interactor/organizer.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
 require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/string/inflections'
+
+require 'active_interactor/organizer/interactor_interface_collection'
 
 module ActiveInteractor
   # A base Organizer class.  All organizers should inherit from
   #  {Organizer}.
   # @author Aaron Allen <hello@aaronmallen.me>
   # @since 0.0.1
-  # @!attribute [r] organized
-  #  @!scope class
-  #  @return [Array<Base>] the organized interactors
   # @!attribute [r] parallel
   #  @since 1.0.0
   #  @!scope class
@@ -36,7 +34,6 @@ module ActiveInteractor
   #  MyOrganizer.perform
   #  #=> <MyOrganizer::Context interactor1=true interactor2=true>
   class Organizer < Base
-    class_attribute :organized, instance_writer: false, default: []
     class_attribute :parallel, instance_writer: false, default: false
     define_callbacks :each_perform
 
@@ -83,7 +80,6 @@ module ActiveInteractor
 
     # Define a callback to call around each organized interactor's
     #  {Base.perform} has been invokation
-    #
     # @example
     #  class MyInteractor1 < ActiveInteractor::Base
     #    before_perform :print_name
@@ -129,7 +125,6 @@ module ActiveInteractor
 
     # Define a callback to call before each organized interactor's
     #  {Base.perform} has been invoked
-    #
     # @example
     #  class MyInteractor1 < ActiveInteractor::Base
     #    before_perform :print_name
@@ -172,21 +167,50 @@ module ActiveInteractor
     # 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
+    # @example Basic interactor organization
+    #   class MyOrganizer < ActiveInteractor::Organizer
+    #     organize :interactor_one, :interactor_two
     #   end
-    #
-    #   class MySecondOrganizer < ActiveInteractor::Organizer
-    #     organize [InteractorThree, InteractorFour]
+    # @example Conditional interactor organization with block
+    #   class MyOrganizer < ActiveInteractor::Organizer
+    #     organize do
+    #       add :interactor_one
+    #       add :interactor_two, if: -> { context.valid? }
+    #     end
     #   end
+    # @example Conditional interactor organization with method
+    #   class MyOrganizer < ActiveInteractor::Organizer
+    #     organize do
+    #       add :interactor_one
+    #       add :interactor_two, unless: :invalid_context?
+    #     end
+    #
+    #     private
     #
-    # @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
+    #     def invalid_context?
+    #       !context.valid?
+    #     end
+    #   end
+    # @example Interactor organization with perform options
+    #   class MyOrganizer < ActiveInteractor::Organizer
+    #     organize do
+    #       add :interactor_one, validate: false
+    #       add :interactor_two, skip_perform_callbacks: true
+    #     end
+    #   end
+    # @param interactors [Array<Base|Symbol|String>] the interactors to call
+    # @yield [.organized] if block given
+    # @return [InteractorInterfaceCollection] an instance of {InteractorInterfaceCollection}
+    def self.organize(*interactors, &block)
+      organized.concat(interactors) if interactors
+      organized.instance_eval(&block) if block
+      organized
+    end
+
+    # Organized interactors
+    # @return [InteractorInterfaceCollection] an instance of {InteractorInterfaceCollection}
+    def self.organized
+      @organized ||= InteractorInterfaceCollection.new
     end
 
     # Run organized interactors in parallel
@@ -196,7 +220,7 @@ module ActiveInteractor
     end
 
     # Invoke the organized interactors. An organizer is
-    #  expected not to define its own {Base#perform} method
+    #  expected not to define its own {Interactor#perform #perform} method
     #  in favor of this default implementation.
     def perform
       if self.class.parallel
@@ -208,11 +232,16 @@ module ActiveInteractor
 
     private
 
-    def execute_interactor_with_callbacks(interactor, fail_on_error = false, execute_options = {})
+    def execute_interactor(interface, fail_on_error = false, perform_options = {})
+      interface.perform(self, context, fail_on_error, perform_options)
+    end
+
+    def execute_interactor_with_callbacks(interface, fail_on_error = false, perform_options = {})
+      args = [interface, fail_on_error, perform_options]
+      return execute_interactor(*args) if options.skip_each_perform_callbacks
+
       run_callbacks :each_perform do
-        instance = interactor.new(context)
-        method = fail_on_error ? :execute_perform! : :execute_perform
-        instance.send(method, execute_options)
+        execute_interactor(*args)
       end
     end
 
@@ -222,16 +251,17 @@ module ActiveInteractor
     end
 
     def perform_in_order
-      self.class.organized.each do |interactor|
-        context.merge!(execute_interactor_with_callbacks(interactor, true))
+      self.class.organized.each do |interface|
+        result = execute_interactor_with_callbacks(interface, true)
+        context.merge!(result) if result
       end
     rescue Error::ContextFailure => e
       context.merge!(e.context)
     end
 
     def perform_in_parallel
-      results = self.class.organized.map do |interactor|
-        Thread.new { execute_interactor_with_callbacks(interactor, false, skip_rollback: true) }
+      results = self.class.organized.map do |interface|
+        Thread.new { execute_interactor_with_callbacks(interface, false, skip_rollback: true) }
       end
       merge_contexts(results.map(&:value))
     end