flow 0.10.2 → 0.10.7.1.pre1

data/lib/flow.rb

@@ -4,14 +4,29 @@ require "active_model"
 require "active_record"
 require "active_support"
 
-require "spicerack"
+require "spicery"
+require "malfunction"
 
 require "flow/version"
 
 require "flow/concerns/transaction_wrapper"
 
+require "flow/malfunction/base"
+
 require "flow/flow_base"
 require "flow/operation_base"
 require "flow/state_base"
+require "flow/state_proxy"
+
+module Flow
+  class Error < StandardError; end
+
+  class FlowError < Error; end
+  class StateInvalidError < FlowError; end
+
+  class OperationError < Error; end
+  class AlreadyExecutedError < OperationError; end
 
-module Flow; end
+  class StateError < Error; end
+  class NotValidatedError < StateError; end
+end

data/lib/flow/flow/callbacks.rb

@@ -2,12 +2,14 @@
 
 # Callbacks provide an extensible mechanism for hooking into a Flow.
 module Flow
-  module Callbacks
-    extend ActiveSupport::Concern
+  module Flow
+    module Callbacks
+      extend ActiveSupport::Concern
 
-    included do
-      include ActiveSupport::Callbacks
-      define_callbacks :initialize, :trigger, :flux
+      included do
+        include ActiveSupport::Callbacks
+        define_callbacks :initialize, :trigger, :flux
+      end
     end
   end
 end

data/lib/flow/flow/core.rb

@@ -2,25 +2,27 @@
 
 # Accepts input representing the arguments and options which define the initial state.
 module Flow
-  module Core
-    extend ActiveSupport::Concern
+  module Flow
+    module Core
+      extend ActiveSupport::Concern
 
-    class_methods do
-      def state_class
-        "#{name.chomp("Flow")}State".constantize
+      class_methods do
+        def state_class
+          conjugate(StateBase)
+        end
       end
-    end
 
-    included do
-      delegate :state_class, to: :class
-      delegate :outputs, to: :state
+      included do
+        delegate :state_class, to: :class
+        delegate :outputs, to: :state
 
-      attr_reader :state
-    end
+        attr_reader :state
+      end
 
-    def initialize(state_instance = nil, **options)
-      run_callbacks(:initialize) do
-        @state = state_instance || state_class.new(**options)
+      def initialize(state_instance = nil, **options)
+        run_callbacks(:initialize) do
+          @state = state_instance || state_class.new(**options)
+        end
       end
     end
   end

data/lib/flow/flow/flux.rb

@@ -2,52 +2,56 @@
 
 # When `#trigger` is called on a Flow, `#execute` is called on Operations sequentially in their given order.
 module Flow
-  module Flux
-    extend ActiveSupport::Concern
+  module Flow
+    module Flux
+      extend ActiveSupport::Concern
 
-    included do
-      set_callback(:initialize, :after) { @executed_operations = [] }
+      included do
+        set_callback(:initialize, :after) { @executed_operations = [] }
 
-      attr_reader :failed_operation
+        attr_reader :failed_operation
 
-      private
+        delegate :operation_failure, to: :failed_operation, allow_nil: true
 
-      attr_reader :executed_operations
+        private
 
-      def _flux
-        executable_operations.each do |operation|
-          operation.execute
-          (@failed_operation = operation) and raise Flow::Flux::Failure if operation.failed?
-          executed_operations << operation
+        attr_reader :executed_operations
+
+        def _flux
+          executable_operations.each do |operation|
+            operation.execute
+            (@failed_operation = operation) and raise Flow::Flux::Failure if operation.failed?
+            executed_operations << operation
+          end
+        end
+
+        def executable_operations
+          operation_instances - executed_operations
         end
-      end
 
-      def executable_operations
-        operation_instances - executed_operations
+        def operation_instances
+          _operations.map { |operation_class| operation_class.new(state) }
+        end
+        memoize :operation_instances
       end
 
-      def operation_instances
-        _operations.map { |operation_class| operation_class.new(state) }
+      def failed_operation?
+        failed_operation.present?
       end
-      memoize :operation_instances
-    end
 
-    def failed_operation?
-      failed_operation.present?
-    end
+      def flux
+        flux!
+      rescue StandardError => exception
+        info :error_executing_operation, state: state, exception: exception
 
-    def flux
-      flux!
-    rescue StandardError => exception
-      error :error_executing_operation, state: state, exception: exception
+        raise exception unless exception.is_a? Flow::Flux::Failure
+      end
 
-      raise exception unless exception.is_a? Flow::Flux::Failure
-    end
+      def flux!
+        run_callbacks(:flux) { _flux }
+      end
 
-    def flux!
-      run_callbacks(:flux) { _flux }
+      class Failure < StandardError; end
     end
-
-    class Failure < StandardError; end
   end
 end

data/lib/flow/flow/operations.rb

@@ -2,25 +2,27 @@
 
 # Operations are an ordered list of the behaviors which are executed with (and possibly change) the Flow's state.
 module Flow
-  module Operations
-    extend ActiveSupport::Concern
+  module Flow
+    module Operations
+      extend ActiveSupport::Concern
 
-    included do
-      class_attribute :_operations, instance_writer: false, default: []
+      included do
+        class_attribute :_operations, instance_writer: false, default: []
 
-      delegate :_operations, to: :class
-    end
-
-    class_methods do
-      def inherited(base)
-        base._operations = _operations.dup
-        super
+        delegate :_operations, to: :class
       end
 
-      private
+      class_methods do
+        def inherited(base)
+          base._operations = _operations.dup
+          super
+        end
+
+        private
 
-      def operations(*operations)
-        _operations.concat(operations.flatten)
+        def operations(*operations)
+          _operations.concat(operations.flatten)
+        end
       end
     end
   end

data/lib/flow/flow/status.rb

@@ -2,23 +2,25 @@
 
 # The Flow status is a summary of what has occurred during the runtime, used mainly for analysis and program flow.
 module Flow
-  module Status
-    extend ActiveSupport::Concern
+  module Flow
+    module Status
+      extend ActiveSupport::Concern
 
-    def pending?
-      executed_operations.none?
-    end
+      def pending?
+        executed_operations.none?
+      end
 
-    def triggered?
-      executed_operations.any? || failed_operation?
-    end
+      def triggered?
+        executed_operations.any? || failed_operation?
+      end
 
-    def success?
-      triggered? && (operation_instances - executed_operations).none?
-    end
+      def success?
+        triggered? && (operation_instances - executed_operations).none?
+      end
 
-    def failed?
-      triggered? && !success?
+      def failed?
+        triggered? && !success?
+      end
     end
   end
 end

data/lib/flow/flow/transactions.rb

@@ -2,12 +2,14 @@
 
 # Flows where no operation should be persisted unless all are successful should use a transaction.
 module Flow
-  module Transactions
-    extend ActiveSupport::Concern
+  module Flow
+    module Transactions
+      extend ActiveSupport::Concern
 
-    class_methods do
-      def callback_name
-        :flux
+      class_methods do
+        def callback_name
+          :flux
+        end
       end
     end
   end

data/lib/flow/flow/trigger.rb

@@ -2,37 +2,39 @@
 
 # Triggering a Flow executes all its operations in sequential order (see `Flow::Flux`) *iff* it has a valid state.
 module Flow
-  module Trigger
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def trigger!(*arguments)
-        new(*arguments).trigger!
+  module Flow
+    module Trigger
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def trigger!(*arguments, **options)
+          new(*arguments, **options).trigger!
+        end
+
+        def trigger(*arguments, **options)
+          new(*arguments, **options).trigger
+        end
       end
 
-      def trigger(*arguments)
-        new(*arguments).trigger
-      end
-    end
+      included do
+        delegate :valid?, :validated?, to: :state, prefix: true
 
-    included do
-      delegate :valid?, :validated?, to: :state, prefix: true
-
-      set_callback :trigger, :around, ->(_, block) { surveil(:trigger) { block.call } }
-    end
+        set_callback :trigger, :around, ->(_, block) { surveil(:trigger) { block.call } }
+      end
 
-    def trigger!
-      raise Flow::Errors::StateInvalid unless state_valid?
+      def trigger!
+        raise StateInvalidError unless state_valid?
 
-      run_callbacks(:trigger) { flux }
+        run_callbacks(:trigger) { flux }
 
-      self
-    end
+        self
+      end
 
-    def trigger
-      trigger!
-    rescue Flow::Errors::StateInvalid
-      self
+      def trigger
+        trigger!
+      rescue StateInvalidError
+        self
+      end
     end
   end
 end

data/lib/flow/flow_base.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "flow/errors/state_invalid"
-
 require_relative "flow/callbacks"
 require_relative "flow/core"
 require_relative "flow/flux"
@@ -12,10 +10,11 @@ require_relative "flow/trigger"
 
 # A **Flow** is a collection of procedurally executed **Operations** sharing a common **State**.
 module Flow
-  class FlowBase
-    include ShortCircuIt
-    include Technologic
-    include Flow::TransactionWrapper
+  class FlowBase < Spicerack::RootObject
+    include Conjunction::Junction
+    suffixed_with "Flow"
+
+    include TransactionWrapper
     include Flow::Callbacks
     include Flow::Core
     include Flow::Flux

data/lib/flow/malfunction/base.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Flow
+  module Malfunction
+    class Base < ::Malfunction::MalfunctionBase
+      prefixed_with "Flow::Malfunction::"
+      suffixed_with nil
+    end
+  end
+end

data/lib/flow/operation/core.rb

@@ -8,10 +8,21 @@ module Flow
 
       included do
         attr_reader :state
+
+        delegate :state_proxy_class, to: :class
+      end
+
+      class_methods do
+        def state_proxy_class
+          @state_proxy_class ||= Class.new(StateProxy).tap do |proxy_class|
+            delegate_method_names = _state_writers.map { |method_name| "#{method_name}=" } + _state_readers
+            proxy_class.delegate(*delegate_method_names, to: :_state) if delegate_method_names.any?
+          end
+        end
       end
 
       def initialize(state)
-        @state = state
+        @state = state_proxy_class.new(state)
       end
     end
   end

data/lib/flow/operation/error_handler.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# When an exception is raised during during execution, but a handler can rescue, it causes a failure instead.
+# When an exception is raised during execution, but a handler can rescue, it causes a failure instead.
 module Flow
   module Operation
     module ErrorHandler

data/lib/flow/operation/execute.rb

@@ -12,7 +12,7 @@ module Flow
         attr_reader :operation_failure
 
         set_callback :execute, :around, ->(_, block) { surveil(:execute) { block.call } }
-        set_callback :execute, :before, -> { raise Operation::Errors::AlreadyExecuted }, if: :executed?
+        set_callback :execute, :before, -> { raise AlreadyExecutedError }, if: :executed?
       end
 
       def execute!

data/lib/flow/operation_base.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "operation/errors/already_executed"
-require_relative "operation/errors/already_rewound"
-
 require_relative "operation/accessors"
 require_relative "operation/callbacks"
 require_relative "operation/core"
@@ -14,17 +11,15 @@ require_relative "operation/transactions"
 
 # An **Operation** is a service object which is executed with a **State**.
 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
+  class OperationBase < Spicerack::RootObject
+    include TransactionWrapper
+    include Operation::Accessors
+    include Operation::Callbacks
+    include Operation::Core
+    include Operation::ErrorHandler
+    include Operation::Execute
+    include Operation::Failures
+    include Operation::Status
+    include Operation::Transactions
   end
 end