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

data/lib/active_interactor/organizer/interactor_interface.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+
+module ActiveInteractor
+  class Organizer < ActiveInteractor::Base
+    # @api private
+    # An interface for an interactor's to allow conditional invokation of an
+    #  interactor's {Interactor#perform #perform} method.
+    # @author Aaron Allen <hello@aaronmallen.me>
+    # @since 1.0.0
+    # @!attribute [r] filters
+    #  @return [Hash{Symbol=>*}] conditional filters for an interactor's
+    #    {Interactor#perform #perform} invocation.
+    # @!attribute [r] interactor_class
+    #  @return [Class] an interactor class
+    # @!attribute [r] perform_options
+    #  @return [Hash{Symbol=>*}] perform options to use for an interactor's
+    #    {Interactor#perform #perform} invocation.
+    class InteractorInterface
+      attr_reader :filters, :interactor_class, :perform_options
+
+      # @return [Array<Symbol>] keywords that indicate an option is a
+      #  conditional.
+      CONDITIONAL_FILTERS = %i[if unless].freeze
+
+      # @param interactor_class [Class|Symbol|String] the {.interactor_class}
+      # @param options [Hash{Symbol=>*}] the {.filters} and {.perform_options}
+      # @return [InteractorInterface|nil] a new instance of {InteractorInterface} if
+      #  the {#interactor_class} exists
+      def initialize(interactor_class, options = {})
+        @interactor_class = interactor_class.to_s.classify.safe_constantize
+        @filters = options.select { |key, _value| CONDITIONAL_FILTERS.include?(key) }
+        @perform_options = options.reject { |key, _value| CONDITIONAL_FILTERS.include?(key) }
+      end
+
+      # Check conditional filters on an interactor and invoke it's {Interactor#perform #perform}
+      #  method if conditions are met.
+      # @param target [Class] an instance of {Organizer}
+      # @param context [Context::Base] the organizer's {Context::Base context} instance
+      # @param fail_on_error [Boolean] if `true` {Interactor::ClassMethods#perform! .perform!}
+      #  will be invoked on the interactor. If `false` {Interactor::ClassMethods#perform .perform}
+      #  will be invokded on the interactor.
+      # @param perform_options [Hash{Symbol=>*}] options for perform
+      # @return [Context::Base|nil] an instance of {Context::Base} if an interactor's
+      #   {Interactor#perform #perform} is invoked
+      def perform(target, context, fail_on_error = false, perform_options = {})
+        return if check_conditionals(target, filters[:if]) == false
+        return if check_conditionals(target, filters[:unless]) == true
+
+        method = fail_on_error ? :perform! : :perform
+        options = self.perform_options.merge(perform_options)
+        interactor_class.send(method, context, options)
+      end
+
+      private
+
+      def check_conditionals(target, filter)
+        return unless filter
+
+        return target.send(filter) if filter.is_a?(Symbol)
+        return target.instance_exec(&filter) if filter.is_a?(Proc)
+      end
+    end
+  end
+end

data/lib/active_interactor/organizer/interactor_interface_collection.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'active_interactor/organizer/interactor_interface'
+
+module ActiveInteractor
+  class Organizer < ActiveInteractor::Base
+    # @api private
+    # A collection of ordered interactors for an {Organizer}
+    # @author Aaron Allen <hello@aaronmallen.me>
+    # @since 1.0.0
+    # @!attribute [r] collection
+    #  @return [Array<Hash{Symbol=>*}] the organized interactors and filters
+    class InteractorInterfaceCollection
+      attr_reader :collection
+
+      # @!method each(&block)
+      # Calls the given block once for each element of {#collection}, passing that
+      #  element as a parameter
+      # @yield [.collection] the {#collection}
+      # @return [Array<InteractorInterface>] the {#collection}
+
+      # @!method map(&block)
+      # Invokes the given block once fore each element of {#collection}.
+      # @yield [.collection] the {#collection}
+      # @return [Array] a new array containing the values returned by the block.
+      delegate :each, :map, to: :collection
+
+      # @return [InteractorInterfaceCollection] a new instance of {InteractorInterfaceCollection}
+      def initialize
+        @collection = []
+      end
+
+      # Add an {InteractorInterface} to the {#collection}
+      # @param interactor [Class|Symbol|String] an interactor class name
+      # @param filters [Hash{Symbol=>*}] conditions and {Interactor::PerformOptions} for the interactor
+      # @option filters [Symbol|Proc] :if only invoke the interactor's perform method
+      #   if method or block returns `true`
+      # @option filters [Symbol|Proc] :unless only invoke the interactor's perform method
+      #   if method or block returns `false`
+      # @see Interactor::PerformOptions
+      # @return [InteractorInterface] the {InteractorInterface} instance
+      def add(interactor, filters = {})
+        interface = InteractorInterface.new(interactor, filters)
+        collection << interface if interface.interactor_class
+        self
+      end
+
+      # Concat multiple {InteractorInterface} to the {#collection}
+      # @param interactors [Array<Class>] the interactor classes to add
+      #  to the collection
+      # @return [InteractorInterface] the {InteractorInterface} instance
+      def concat(interactors)
+        interactors.flatten.each { |interactor| add(interactor) }
+        self
+      end
+    end
+  end
+end

data/lib/active_interactor/version.rb

@@ -2,5 +2,5 @@
 
 module ActiveInteractor
   # @return [String] the ActiveInteractor version
-  VERSION = '1.0.0.beta.3'
+  VERSION = '1.0.0.beta.4'
 end

data/spec/active_interactor/interactor/perform_options_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ActiveInteractor::Interactor::PerformOptions do
+  subject { described_class.new }
+
+  it { is_expected.to respond_to :skip_each_perform_callbacks }
+  it { is_expected.to respond_to :skip_perform_callbacks }
+  it { is_expected.to respond_to :skip_rollback }
+  it { is_expected.to respond_to :skip_rollback_callbacks }
+  it { is_expected.to respond_to :validate }
+  it { is_expected.to respond_to :validate_on_calling }
+  it { is_expected.to respond_to :validate_on_called }
+
+  describe 'defaults' do
+    it { is_expected.to have_attributes(skip_each_perform_callbacks: false) }
+    it { is_expected.to have_attributes(skip_perform_callbacks: false) }
+    it { is_expected.to have_attributes(skip_rollback: false) }
+    it { is_expected.to have_attributes(skip_rollback_callbacks: false) }
+    it { is_expected.to have_attributes(validate: true) }
+    it { is_expected.to have_attributes(validate_on_calling: true) }
+    it { is_expected.to have_attributes(validate_on_called: true) }
+  end
+end

data/spec/active_interactor/interactor/worker_spec.rb

@@ -8,6 +8,72 @@ RSpec.describe ActiveInteractor::Interactor::Worker do
     before { build_interactor }
     let(:interactor) { TestInteractor.new }
 
+    RSpec.shared_examples 'an interactor with options' do
+      context 'when interactor has options :skip_perform_callbacks eq to true' do
+        let(:interactor) { TestInteractor.new.with_options(skip_perform_callbacks: true) }
+
+        it 'is expected not to invoke #run_callbacks with :perform' do
+          allow_any_instance_of(TestInteractor).to receive(:run_callbacks)
+            .with(:validation).and_call_original
+          expect_any_instance_of(TestInteractor).not_to receive(:run_callbacks)
+            .with(:perform)
+          subject
+        end
+      end
+
+      context 'when interactor has options :validate eq to false' do
+        let(:interactor) { TestInteractor.new.with_options(validate: false) }
+
+        it 'is expected not to invoke #run_callbacks with :validation' do
+          expect_any_instance_of(TestInteractor).not_to receive(:run_callbacks)
+            .with(:validation)
+          subject
+        end
+      end
+
+      context 'when interactor has options :validate_on_calling eq to false' do
+        let(:interactor) { TestInteractor.new.with_options(validate_on_calling: false) }
+
+        before do
+          allow_any_instance_of(TestInteractor).to receive(:context_valid?)
+            .with(:called).and_return(true)
+        end
+
+        it 'is expected not to invoke #context_valid? with :calling' do
+          expect_any_instance_of(TestInteractor).not_to receive(:context_valid?)
+            .with(:calling)
+          subject
+        end
+
+        it 'is expected to invoke #context_valid? with :called' do
+          expect_any_instance_of(TestInteractor).to receive(:context_valid?)
+            .with(:called)
+          subject
+        end
+      end
+
+      context 'when interactor has options :validate_on_called eq to false' do
+        let(:interactor) { TestInteractor.new.with_options(validate_on_called: false) }
+
+        before do
+          allow_any_instance_of(TestInteractor).to receive(:context_valid?)
+            .with(:calling).and_return(true)
+        end
+
+        it 'is expected to invoke #context_valid? with :calling' do
+          expect_any_instance_of(TestInteractor).to receive(:context_valid?)
+            .with(:calling)
+          subject
+        end
+
+        it 'is expected not to invoke #context_valid? with :called' do
+          expect_any_instance_of(TestInteractor).not_to receive(:context_valid?)
+            .with(:called)
+          subject
+        end
+      end
+    end
+
     describe '#execute_perform' do
       subject { described_class.new(interactor).execute_perform }
 
@@ -22,6 +88,8 @@ RSpec.describe ActiveInteractor::Interactor::Worker do
         it { expect { subject }.not_to raise_error }
         it { is_expected.to be_an TestInteractor.context_class }
       end
+
+      include_examples 'an interactor with options'
     end
 
     describe '#execute_perform!' do
@@ -40,23 +108,6 @@ RSpec.describe ActiveInteractor::Interactor::Worker do
         subject
       end
 
-      context 'with options :skip_perform_callbacks eq to true' do
-        subject { described_class.new(interactor).execute_perform!(skip_perform_callbacks: true) }
-
-        it 'is expected not to run perform callbacks on interactor' do
-          allow_any_instance_of(TestInteractor).to receive(:run_callbacks)
-            .with(:validation).and_call_original
-          expect_any_instance_of(TestInteractor).not_to receive(:run_callbacks)
-            .with(:perform)
-          subject
-        end
-
-        it 'calls #perform on interactor instance' do
-          expect_any_instance_of(TestInteractor).to receive(:perform)
-          subject
-        end
-      end
-
       context 'when interactor context is invalid on :calling' do
         before do
           allow_any_instance_of(TestInteractor.context_class).to receive(:valid?)
@@ -72,33 +123,6 @@ RSpec.describe ActiveInteractor::Interactor::Worker do
           expect_any_instance_of(TestInteractor).to receive(:context_rollback!)
           expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure)
         end
-
-        context 'with options :validate eq to false' do
-          subject { described_class.new(interactor).execute_perform!(validate: false) }
-
-          it { expect { subject }.not_to raise_error }
-          it 'is expected not to run validation callbacks on interactor' do
-            expect_any_instance_of(TestInteractor).not_to receive(:run_callbacks)
-              .with(:validation)
-            subject
-          end
-        end
-
-        context 'with options :validate_on_calling eq to false' do
-          subject { described_class.new(interactor).execute_perform!(validate_on_calling: false) }
-
-          it { expect { subject }.not_to raise_error }
-          it 'is expected not to call valid? with :calling' do
-            expect_any_instance_of(TestInteractor.context_class).not_to receive(:valid?)
-              .with(:calling)
-            subject
-          end
-          it 'is expected to call valid? with :called' do
-            expect_any_instance_of(TestInteractor.context_class).to receive(:valid?)
-              .with(:called)
-            subject
-          end
-        end
       end
 
       context 'when interactor context is invalid on :called' do
@@ -116,34 +140,9 @@ RSpec.describe ActiveInteractor::Interactor::Worker do
           expect_any_instance_of(TestInteractor).to receive(:context_rollback!)
           expect { subject }.to raise_error(ActiveInteractor::Error::ContextFailure)
         end
-
-        context 'with options :validate eq to false' do
-          subject { described_class.new(interactor).execute_perform!(validate: false) }
-
-          it { expect { subject }.not_to raise_error }
-          it 'is expected not to run validation callbacks on interactor' do
-            expect_any_instance_of(TestInteractor).not_to receive(:run_callbacks)
-              .with(:validation)
-            subject
-          end
-        end
-
-        context 'with options :validate_on_called eq to false' do
-          subject { described_class.new(interactor).execute_perform!(validate_on_called: false) }
-
-          it { expect { subject }.not_to raise_error }
-          it 'is expected to call valid? with :calling' do
-            expect_any_instance_of(TestInteractor.context_class).to receive(:valid?)
-              .with(:calling)
-            subject
-          end
-          it 'is expected not to call valid? with :called' do
-            expect_any_instance_of(TestInteractor.context_class).not_to receive(:valid?)
-              .with(:called)
-            subject
-          end
-        end
       end
+
+      include_examples 'an interactor with options'
     end
 
     describe '#execute_rollback' do
@@ -155,31 +154,31 @@ RSpec.describe ActiveInteractor::Interactor::Worker do
         subject
       end
 
-      it 'calls #context_rollback on interactor instance' do
+      it 'is expected to invoke #context_rollback on interactor instance' do
         expect_any_instance_of(TestInteractor).to receive(:context_rollback!)
         subject
       end
 
-      context 'with options :skip_rollback eq to true' do
-        subject { described_class.new(interactor).execute_rollback(skip_rollback: true) }
+      context 'when interactor has options :skip_rollback eq to true' do
+        let(:interactor) { TestInteractor.new.with_options(skip_rollback: true) }
 
-        it 'is expected not to call #context_rollback on interactor instance' do
+        it 'is expected not to invoke #context_rollback on interactor instance' do
           expect_any_instance_of(TestInteractor).not_to receive(:context_rollback!)
           subject
         end
       end
 
-      context 'with options :skip_rollback_callbacks eq to true' do
-        subject { described_class.new(interactor).execute_rollback(skip_rollback_callbacks: true) }
+      context 'when interactor has options :skip_rollback_callbacks eq to true' do
+        let(:interactor) { TestInteractor.new.with_options(skip_rollback_callbacks: true) }
 
-        it 'is expected not to run rollback callbacks on interactor' do
-          expect_any_instance_of(TestInteractor).not_to receive(:run_callbacks)
-            .with(:rollback)
+        it 'is expected to invoke #context_rollback on interactor instance' do
+          expect_any_instance_of(TestInteractor).to receive(:context_rollback!)
           subject
         end
 
-        it 'calls #context_rollback on interactor instance' do
-          expect_any_instance_of(TestInteractor).to receive(:context_rollback!)
+        it 'is expected not to run rollback callbacks on interactor' do
+          expect_any_instance_of(TestInteractor).not_to receive(:run_callbacks)
+            .with(:rollback)
           subject
         end
       end

data/spec/active_interactor/organizer/interactor_interface_collection_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ActiveInteractor::Organizer::InteractorInterfaceCollection do
+  describe '#add' do
+    subject { instance.add(interactor) }
+    let(:instance) { described_class.new }
+
+    context 'with an interactor that does not exist' do
+      let(:interactor) { :an_interactor_that_does_not_exist }
+
+      it { expect { subject }.not_to(change { instance.collection.count }) }
+      it { is_expected.to be_a described_class }
+    end
+
+    context 'with an existing interactor' do
+      before { build_interactor }
+
+      context 'when interactors are passed as contants' do
+        let(:interactor) { TestInteractor }
+
+        it { expect { subject }.to change { instance.collection.count }.by(1) }
+        it { is_expected.to be_a described_class }
+
+        it 'is expected to add the appropriate interactor' do
+          subject
+          expect(instance.collection.first.interactor_class).to eq TestInteractor
+        end
+      end
+
+      context 'when interactors are passed as symbols' do
+        let(:interactor) { :test_interactor }
+
+        it { expect { subject }.to change { instance.collection.count }.by(1) }
+        it { is_expected.to be_a described_class }
+
+        it 'is expected to add the appropriate interactor' do
+          subject
+          expect(instance.collection.first.interactor_class).to eq TestInteractor
+        end
+      end
+
+      context 'when interactors are passed as strings' do
+        let(:interactor) { 'TestInteractor' }
+
+        it { expect { subject }.to change { instance.collection.count }.by(1) }
+        it { is_expected.to be_a described_class }
+
+        it 'is expected to add the appropriate interactor' do
+          subject
+          expect(instance.collection.first.interactor_class).to eq TestInteractor
+        end
+      end
+    end
+  end
+
+  describe '#concat' do
+    subject { instance.concat(interactors) }
+    let(:instance) { described_class.new }
+
+    context 'with two existing interactors' do
+      let!(:interactor1) { build_interactor('TestInteractor1') }
+      let!(:interactor2) { build_interactor('TestInteractor2') }
+      let(:interactors) { %i[test_interactor_1 test_interactor_2] }
+
+      it { expect { subject }.to change { instance.collection.count }.by(2) }
+
+      it 'is expected to add the appropriate interactors' do
+        subject
+        expect(instance.collection.first.interactor_class).to eq TestInteractor1
+        expect(instance.collection.last.interactor_class).to eq TestInteractor2
+      end
+    end
+  end
+end