flow 0.9.3 → 0.10.0

data/lib/flow/operation/callbacks.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
 # Callbacks provide an extensible mechanism for hooking into a Operation.
-module Operation
-  module Callbacks
-    extend ActiveSupport::Concern
+module Flow
+  module Operation
+    module Callbacks
+      extend ActiveSupport::Concern
 
-    included do
-      include ActiveSupport::Callbacks
-      define_callbacks :failure, :execute, :behavior, :rewind, :undo
-    end
+      included do
+        include ActiveSupport::Callbacks
+        define_callbacks :failure, :execute, :behavior
+      end
 
-    class_methods do
-      def on_failure(*filters, &block)
-        set_callback(:failure, :before, *filters, &block)
+      class_methods do
+        def on_failure(*filters, &block)
+          set_callback(:failure, :before, *filters, &block)
+        end
       end
     end
   end

data/lib/flow/operation/core.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 # Operations take a state as input.
-module Operation
-  module Core
-    extend ActiveSupport::Concern
+module Flow
+  module Operation
+    module Core
+      extend ActiveSupport::Concern
 
-    included do
-      attr_reader :state
-    end
+      included do
+        attr_reader :state
+      end
 
-    def initialize(state)
-      @state = state
+      def initialize(state)
+        @state = state
+      end
     end
   end
 end

data/lib/flow/operation/error_handler.rb

@@ -1,22 +1,28 @@
 # frozen_string_literal: true
 
 # When an exception is raised during during execution, but a handler can rescue, it causes a failure instead.
-module Operation
-  module ErrorHandler
-    extend ActiveSupport::Concern
+module Flow
+  module Operation
+    module ErrorHandler
+      extend ActiveSupport::Concern
 
-    class_methods do
-      private
+      class_methods do
+        private
 
-      def handle_error(error_class, problem: error_class.name.demodulize.underscore, with: nil, &block)
-        failure problem
+        def handle_error(error_class, problem: error_class.name.demodulize.underscore, with: nil, &block)
+          failure problem
 
-        rescue_from(error_class) { |exception| fail!(problem.to_sym, exception: exception) }
+          rescue_from(error_class) { |exception| fail!(problem.to_sym, exception: exception) }
 
-        if with.present?
-          rescue_from(error_class, with: with)
-        elsif block_given?
-          rescue_from(error_class, &block)
+          if with.present?
+            rescue_from(error_class, with: with)
+          elsif block_given?
+            rescue_from(error_class, &block)
+          end
+        end
+
+        def handle_errors(*errors)
+          errors.flatten.each(&method(:handle_error))
         end
       end
     end

data/lib/flow/operation/errors/already_executed.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-module Operation
-  module Errors
-    class AlreadyExecuted < StandardError; end
+module Flow
+  module Operation
+    module Errors
+      class AlreadyExecuted < StandardError; end
+    end
   end
 end

data/lib/flow/operation/errors/already_rewound.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-module Operation
-  module Errors
-    class AlreadyRewound < StandardError; end
+module Flow
+  module Operation
+    module Errors
+      class AlreadyRewound < StandardError; end
+    end
   end
 end

data/lib/flow/operation/execute.rb

@@ -1,41 +1,43 @@
 # frozen_string_literal: true
 
 # Operations define a `#behavior` that occurs when `#execute` is called.
-module Operation
-  module Execute
-    extend ActiveSupport::Concern
+module Flow
+  module Operation
+    module Execute
+      extend ActiveSupport::Concern
 
-    included do
-      include ActiveSupport::Rescuable
+      included do
+        include ActiveSupport::Rescuable
 
-      attr_reader :operation_failure
+        attr_reader :operation_failure
 
-      set_callback :execute, :around, ->(_, block) { surveil(:execute) { block.call } }
-      set_callback :execute, :before, -> { raise Operation::Errors::AlreadyExecuted }, if: :executed?
-    end
-
-    def execute!
-      run_callbacks(:execute) do
-        run_callbacks(:behavior) { behavior }
+        set_callback :execute, :around, ->(_, block) { surveil(:execute) { block.call } }
+        set_callback :execute, :before, -> { raise Operation::Errors::AlreadyExecuted }, if: :executed?
       end
 
-      self
-    rescue StandardError => exception
-      rescue_with_handler(exception) || raise
+      def execute!
+        run_callbacks(:execute) do
+          run_callbacks(:behavior) { behavior }
+        end
 
-      self
-    end
+        self
+      rescue StandardError => exception
+        rescue_with_handler(exception) || raise
+
+        self
+      end
 
-    def execute
-      execute!
-    rescue Operation::Failures::OperationFailure => exception
-      @operation_failure = exception
+      def execute
+        execute!
+      rescue Operation::Failures::OperationFailure => exception
+        @operation_failure = exception
 
-      self
-    end
+        self
+      end
 
-    def behavior
-      # abstract method which should be defined by descendants with the functionality of the given operation
+      def behavior
+        # abstract method which should be defined by descendants with the functionality of the given operation
+      end
     end
   end
 end

data/lib/flow/operation/failures.rb

@@ -1,64 +1,70 @@
 # frozen_string_literal: true
 
 # When `#execute` is unsuccessful, expected problems are **failures** and unexpected problems are **Exceptions**.
-module Operation
-  module Failures
-    extend ActiveSupport::Concern
+module Flow
+  module Operation
+    module Failures
+      extend ActiveSupport::Concern
 
-    included do
-      class_attribute :_failures, instance_writer: false, default: []
+      included do
+        class_attribute :_failures, instance_writer: false, default: []
 
-      delegate :_failures, to: :class
-    end
-
-    class_methods do
-      def inherited(base)
-        base._failures = _failures.dup
-        super
+        delegate :_failures, to: :class
       end
 
-      private
+      class_methods do
+        def inherited(base)
+          base._failures = _failures.dup
+          super
+        end
 
-      def failure(problem)
-        problem = problem.to_s.to_sym
-        warn(:problem_already_defined) if _failures.include? problem
+        private
 
-        _failures << problem
-        define_callbacks problem
-        define_on_failure_for_problem(problem)
-        define_fail_method_for_problem(problem)
-      end
+        def failure(problem, **options)
+          problem = problem.to_s.to_sym
+          _failures << problem
+          define_callbacks problem
+          define_on_failure_for_problem(problem)
+          define_fail_method_for_problem(problem)
+          define_proactive_failure_for_problem(problem, **options)
+        end
 
-      def define_on_failure_for_problem(problem)
-        on_failure_name = "on_#{problem}_failure".to_sym
-        return if respond_to?(on_failure_name)
+        def define_on_failure_for_problem(problem)
+          on_failure_name = "on_#{problem}_failure".to_sym
+          return if respond_to?(on_failure_name)
 
-        define_singleton_method(on_failure_name) { |*filters, &block| set_callback(problem, :before, *filters, &block) }
-      end
+          define_singleton_method(on_failure_name) { |*filters, &block| set_callback(problem, :before, *filters, &block) }
+        end
 
-      def define_fail_method_for_problem(problem)
-        problem_failure_name = "#{problem}_failure!".to_sym
-        return if method_defined?(problem_failure_name)
+        def define_fail_method_for_problem(problem)
+          problem_failure_name = "#{problem}_failure!".to_sym
+          return if method_defined?(problem_failure_name)
 
-        define_method(problem_failure_name) { |**details| fail!(problem, **details) }
+          define_method(problem_failure_name) { |**details| fail!(problem, **details) }
+        end
+
+        def define_proactive_failure_for_problem(problem, **options)
+          conditional_options = options.slice(:if, :unless)
+          set_callback(:execute, :before, -> { fail!(problem) }, **conditional_options) if conditional_options.present?
+        end
       end
-    end
 
-    def fail!(problem, **details)
-      run_callbacks(problem) do
-        run_callbacks(:failure) do
-          error! OperationFailure.new(problem, **details), **details
+      def fail!(problem, **details)
+        run_callbacks(problem) do
+          run_callbacks(:failure) do
+            error! OperationFailure.new(problem, **details), **details
+          end
         end
       end
-    end
 
-    class OperationFailure < StandardError
-      attr_reader :problem, :details
+      class OperationFailure < StandardError
+        attr_reader :problem, :details
 
-      def initialize(problem = nil, **details)
-        super(problem)
-        @problem = problem
-        @details = OpenStruct.new(details)
+        def initialize(problem = nil, **details)
+          super(problem)
+          @problem = problem
+          @details = OpenStruct.new(details)
+        end
       end
     end
   end

data/lib/flow/operation/status.rb

@@ -1,33 +1,30 @@
 # frozen_string_literal: true
 
 # The Operation status is used by the Flow calling it to determine what to do next; continue on or stop and rollback.
-module Operation
-  module Status
-    extend ActiveSupport::Concern
+module Flow
+  module Operation
+    module Status
+      extend ActiveSupport::Concern
 
-    included do
-      set_callback(:execute, :before) { self.was_executed = true }
-      set_callback(:rewind, :before) { self.was_rewound = true }
+      included do
+        set_callback(:execute, :before) { self.was_executed = true }
 
-      private
+        private
 
-      attr_accessor :was_executed, :was_rewound
-    end
+        attr_accessor :was_executed
+      end
 
-    def executed?
-      was_executed.present?
-    end
+      def executed?
+        was_executed.present?
+      end
 
-    def rewound?
-      was_rewound.present?
-    end
-
-    def failed?
-      operation_failure.present?
-    end
+      def failed?
+        operation_failure.present?
+      end
 
-    def success?
-      executed? && !failed?
+      def success?
+        executed? && !failed?
+      end
     end
   end
 end

data/lib/flow/operation/transactions.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 # Operations which modify several persisted objects together should use a transaction.
-module Operation
-  module Transactions
-    extend ActiveSupport::Concern
+module Flow
+  module Operation
+    module Transactions
+      extend ActiveSupport::Concern
 
-    class_methods do
-      def callbacks_for_transaction
-        %i[behavior undo].freeze
+      class_methods do
+        def callback_name
+          :behavior
+        end
       end
     end
   end

data/lib/flow/operation_base.rb

@@ -3,26 +3,28 @@
 require_relative "operation/errors/already_executed"
 require_relative "operation/errors/already_rewound"
 
+require_relative "operation/accessors"
 require_relative "operation/callbacks"
 require_relative "operation/core"
 require_relative "operation/error_handler"
 require_relative "operation/execute"
 require_relative "operation/failures"
-require_relative "operation/rewind"
 require_relative "operation/status"
 require_relative "operation/transactions"
 
 # An **Operation** is a service object which is executed with a **State**.
-class OperationBase
-  include ShortCircuIt
-  include Technologic
-  include TransactionWrapper
-  include Operation::Callbacks
-  include Operation::Core
-  include Operation::ErrorHandler
-  include Operation::Execute
-  include Operation::Failures
-  include Operation::Rewind
-  include Operation::Status
-  include Operation::Transactions
+module Flow
+  class OperationBase
+    include ShortCircuIt
+    include Technologic
+    include Flow::TransactionWrapper
+    include Flow::Operation::Accessors
+    include Flow::Operation::Callbacks
+    include Flow::Operation::Core
+    include Flow::Operation::ErrorHandler
+    include Flow::Operation::Execute
+    include Flow::Operation::Failures
+    include Flow::Operation::Status
+    include Flow::Operation::Transactions
+  end
 end

data/lib/flow/rspec_configuration.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.include CustomMatchers
+end

data/lib/flow/spec_helper.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
 
+require "instructor/spec_helper"
+
 require_relative "custom_matchers"
 require_relative "shoulda_matcher_helper"
+require_relative "rspec_configuration"

data/lib/flow/state/errors/not_validated.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Flow
+  module State
+    module Errors
+      class NotValidated < StandardError; end
+    end
+  end
+end