business_flow 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa83401ab6f440779738905d43a9b7114ed03e68
-  data.tar.gz: 5af8dbff7edf19b183a8201f418ef3555aadd54a
+  metadata.gz: 430484fefee99d40a5f0043d018409179459cf87
+  data.tar.gz: 28aa9f6aabb03d731824498e96c00d7bb23aa224
 SHA512:
-  metadata.gz: 9d44e6d0dd4d71e140fe4f4fff24b1243295355cd71c4e128585a08c0abab3cb93f5da9ea28db39cdd25a7088fa8e03c53ca4fe35623fe63b2c7dbd45df71cd2
-  data.tar.gz: f16efd204e218ffd86a0850cefa452b338171164d7fb1ded0bb157745637459e9c49a843acfb4ee5366a8bddc7f370dab3252df8fe7d7abd7762702d8c35da7f
+  metadata.gz: 2bb43af5b2ff636c7e1cd78cf6b6b0e5c4211969c5edac41d999a75f6e3f768921053dd6c4c4acd8119de9f61a290636095fc784fbc3af19a188ccc1577d2d9d
+  data.tar.gz: 775da5c4e2a71d925e7963d34ec97e78773fd69bf057e85f476b578788740ea7bf7f25832bd0ff9b89a9f1336ee60f114b208e9ef1071bf620ef99717df87cb0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    business_flow (0.7.0)
+    business_flow (0.8.0)
       activemodel (>= 3.0)
       activesupport (>= 3.0)
 

data/lib/business_flow/base.rb

@@ -1,40 +1,9 @@
 module BusinessFlow
   # include BusinessFlow::Base in any object to get a flow!
-  # :reek:ModuleInitialize
   module Base
     def self.included(klass)
       klass.include(DSL)
-      klass.prepend(InstanceMethods)
-    end
-
-    # "Helper" methods which we put on an object to provide some default
-    # behavior.
-    module InstanceMethods
-      attr_reader :parameter_object
-      private :parameter_object
-
-      # Initialize is here so that we can set the parameter object, and then
-      # allow our "parent" class to handle any additional initialization that
-      # it needs to do.
-      def initialize(parameter_object)
-        @parameter_object = parameter_object
-        catch(:halt_step) do
-          super()
-        end
-      end
-
-      def call
-        # If our initialization process set any errors, return
-        return if errors.any? || invalid?
-        if defined?(super)
-          catch(:halt_step) do
-            super
-          end
-        else
-          ::BusinessFlow::DefaultStepExecutor.new(self.class.step_queue, self)
-                                             .call
-        end
-      end
+      klass.include(Validations)
     end
   end
 end

data/lib/business_flow/cacheable.rb

@@ -13,6 +13,21 @@ module BusinessFlow
 
     # DSL Methods
     module ClassMethods
+      # Responsible for converting our DSL options into cache store options
+      CacheOptions = Struct.new(:ttl) do
+        def to_store_options
+          # compact is not available in Ruby <2.4 or ActiveSupport < 4, so
+          # we can't use it here.
+          options = {}
+          options[:expires_in] = ttl if ttl
+          options
+        end
+      end
+
+      def cache_options
+        @cache_options ||= CacheOptions.new
+      end
+
       def cache_store(store = nil)
         if store
           @cache_store = store
@@ -27,45 +42,28 @@ module BusinessFlow
 
       def cache_ttl(ttl = nil)
         if ttl
-          @cache_ttl = ttl
+          cache_options.ttl = ttl
         else
-          @cache_ttl
+          cache_options.ttl
         end
       end
 
       def cache_key(key = nil)
         if key
-          @cache_key = Callable.new(key, self)
+          @cache_key = Callable.new(key)
         else
-          @cache_key ||= Callable.new(:parameter_object, self)
+          @cache_key ||= Callable.new(:parameter_object)
         end
       end
 
-      def call(*args)
-        flow = new(*args)
-        PrivateHelpers.execute(self, flow)
-      rescue FlowFailedException
-        flow
-      end
-    end
-
-    # Avoid polluting the namespace of whoever includes us
-    module PrivateHelpers
-      def self.execute(klass, flow)
-        klass.cache_store.fetch(flow.cache_key, cache_options(klass)) do
-          flow.call
+      def execute(flow)
+        cache_store.fetch(flow.cache_key, cache_options.to_store_options) do
+          super(flow)
           raise FlowFailedException, flow if flow.errors.any?
           flow
         end
-      end
-
-      def self.cache_options(klass)
-        # compact is not available in Ruby <2.4 or ActiveSupport < 4, so
-        # we can't use it here.
-        options = {}
-        ttl = klass.cache_ttl
-        options[:expires_in] = ttl if ttl
-        options
+      rescue FlowFailedException
+        flow
       end
     end
   end

data/lib/business_flow/callable.rb

@@ -3,14 +3,21 @@ module BusinessFlow
   # method, a symbol representing another class which implements .call, or a
   # proc/lambda
   class Callable
-    def initialize(callable, metaclass)
-      @metaclass = metaclass
+    def initialize(callable)
       @callable = callable
       check_callable
     end
 
+    # :reek:ManualDispatch
     def call(instance, inputs)
-      cached_proc.call(instance, inputs)
+      if instance.respond_to?(@callable, true)
+        send_callable(instance, inputs)
+      else
+        @callable = lookup_callable(instance) ||
+                    raise(NameError, "undefined constant #{@callable}")
+        check_callable
+        call(instance, inputs)
+      end
     end
 
     def to_s
@@ -19,55 +26,74 @@ module BusinessFlow
 
     private
 
-    # :reek:ManualDispatch Look reek I don't know what you want me to do.
+    def send_callable(instance, inputs)
+      instance_eval %{
+        def call(instance, _inputs)
+          instance.send(@callable)
+        end
+      }, __FILE__, __LINE__ - 4
+      call(instance, inputs)
+    end
+
     def check_callable
       if @callable.is_a?(Proc)
-        @cached_proc = proc_callable
-      elsif @callable.respond_to?(:call)
-        @cached_proc = call_callable
-      elsif !@callable.is_a?(Symbol)
+        proc_callable
+      else
+        call_callable
+      end
+    rescue NameError
+      unless @callable.is_a?(Symbol)
         raise ArgumentError, 'callable must be a symbol or respond to #call'
       end
     end
 
-    def cached_proc
-      @cached_proc ||=
-        if @metaclass.method_defined?(@callable) ||
-           @metaclass.private_method_defined?(@callable)
-          proc { |instance, _| instance.send(@callable) }
-        else
-          @callable = lookup_callable ||
-                      raise(NameError, "undefined constant #{@callable}")
-          check_callable
+    def proc_callable
+      instance_eval %{
+        def call(instance, inputs)
+          instance.instance_exec(
+            #{@callable.arity.zero? ? '' : 'inputs, '}&@callable
+          )
         end
+      }, __FILE__, __LINE__ - 6
     end
 
-    def proc_callable
-      proc do |instance, inputs|
-        if @callable.arity.zero?
-          instance.instance_exec(&@callable)
-        else
-          instance.instance_exec(inputs, &@callable)
-        end
+    def call_callable
+      case @callable.method(:call).arity
+      when 1, -1
+        single_inputs_callable
+      when 0
+        zero_inputs_callable
+      else two_inputs_callable
       end
     end
 
-    def call_callable
-      proc do |instance, inputs|
-        case @callable.method(:call).arity
-        when 1, -1
+    def single_inputs_callable
+      instance_eval %{
+        def call(_instance, inputs)
           @callable.call(inputs)
-        when 0
+        end
+      }, __FILE__, __LINE__ - 4
+    end
+
+    def zero_inputs_callable
+      instance_eval %{
+        def call(_instance, _inputs)
           @callable.call
-        else
+        end
+      }, __FILE__, __LINE__ - 4
+    end
+
+    def two_inputs_callable
+      instance_eval %{
+        def call(instance, inputs)
           @callable.call(instance, inputs)
         end
-      end
+      }, __FILE__, __LINE__ - 4
     end
 
-    def lookup_callable
+    def lookup_callable(first_instance)
       constant_name = @callable.to_s.camelcase
-      @metaclass.parents.each do |parent|
+      first_instance.class.parents.each do |parent|
         begin
           return parent.const_get(constant_name)
         rescue NameError

data/lib/business_flow/default_step_executor.rb

@@ -9,49 +9,22 @@ module BusinessFlow
     end
 
     def call
-      return if @flow.errors.present?
-      ActiveSupport::Notifications.instrument(flow_event_name, flow: @flow) do
-        @step_queue.each do |step|
-          break unless process_step(step)
-        end
+      @step_queue.each do |step|
+        break if @flow.errors?
+        execute_step(step)
       end
     end
 
     protected
 
-    def process_step(step)
-      catch(:halt_step) { execute_step(step) }
-      return true if @flow.errors.blank?
-      ActiveSupport::Notifications.publish(
-        event_name(step) + '.error', step: step, flow: @flow
-      )
-      false
-    end
+    attr_reader :flow, :step_queue
 
     def execute_step(step)
-      ActiveSupport::Notifications.instrument(
-        event_name(step), flow: @flow, step: step
-      ) do |payload|
-        payload[:step_result] = result = step.call(@flow)
+      catch(:halt_step) do
+        result = step.call(@flow)
         result.merge_into(@flow)
         result
       end
     end
-
-    def flow_name
-      @flow_name ||= @flow.class.to_s.underscore
-    end
-
-    def flow_event_name
-      @flow_event_name ||= "business_flow.flow.#{flow_name}"
-    end
-
-    def step_event_name(step)
-      "#{flow_name}.#{step.to_s.underscore}"
-    end
-
-    def event_name(step)
-      "business_flow.step.#{step_event_name(step)}"
-    end
   end
 end

data/lib/business_flow/dsl.rb

@@ -3,10 +3,6 @@ module BusinessFlow
   # ClassMethods.
   module DSL
     # Contains the DSL for BusinessFlow
-    # The class that includes this must implement a parameter_object reader
-    # which returns a hash or object representing the parameters the flow
-    # was initialized with. The provided .call will instantiate the including
-    # class with a parameter_object as the only argument.
     module ClassMethods
       # Requires that a field be retrievable from the initialization parameters
       #
@@ -15,200 +11,297 @@ module BusinessFlow
       #
       # @param fields The fields required from the initialization parameters
       def needs(*fields)
-        @needs ||= []
-        return @needs if fields.blank?
-        @needs.push(*fields)
-        fields.each do |field|
-          PrivateHelpers.create_parameter_field(self, field)
-        end
+        @needs ||= FieldList.new([], ParameterField, self)
+        @needs.add_fields(fields)
       end
 
       # Allows a field to be retrieved from the initialiaztion parameters
       def wants(field, default = proc { nil }, opts = {})
         internal_name = "wants_#{field}".to_sym
         uses(internal_name, default, opts)
-        PrivateHelpers.create_parameter_field(self, field, internal_name)
+        ParameterField.new(field, internal_name).add_to(self)
       end
 
       # Declares that you will expose a field to the outside world.
       def provides(*fields)
-        @provides ||= []
-        return @provides if fields.blank?
-        @provides.push(*fields)
-        fields.each { |field| PrivateHelpers.create_field(self, field) }
-      end
-
-      # Declares that you expect to set this field during the course of
-      # processing, and that it should meet the given ActiveModel
-      # validations.
-      def expects(field, options = {})
-        validates field, options.merge(on: field)
-        PrivateHelpers.create_field(self, field)
+        @provides ||= FieldList.new([], PublicField, self)
+        @provides.add_fields(fields)
       end
 
       def uses(field, klass, opts = {})
-        callable = Callable.new(klass, self)
-        step = Step.new(callable, opts)
-        PrivateHelpers.create_memoized_field(self, field, step)
-        private field
+        step = Step.new(Callable.new(klass), opts)
+        retriever = proc { step.call(self).output }
+        UsesField.new(field, retriever).add_to(self)
       end
 
       def step(klass, opts = {})
-        callable = Callable.new(klass, self)
-        opts = opts.merge(
-          condition: PrivateHelpers.create_conditional_callable(self, opts)
-        )
-        step_queue << step = Step.new(callable, opts)
-        step.outputs.values.each do |field|
-          PrivateHelpers.create_field(self, field)
-        end
+        step = Step.new(Callable.new(klass), opts)
+        step_queue.push(step)
+        step.outputs.values.each { |field| Field.new(field).add_to(self) }
       end
 
       def call(parameter_object)
-        new(parameter_object).tap(&:call)
+        allocate.tap do |flow|
+          catch(:halt_step) do
+            flow.send(:_business_flow_dsl_initialize,
+                      ParameterObject.new(parameter_object), needs)
+            execute(flow)
+          end
+        end
+      end
+
+      # :reek:UtilityFunction
+      def execute(flow)
+        flow.call
+      end
+
+      def build(parameter_object)
+        call(parameter_object)
       end
 
       def call!(*args)
-        ret = call(*args)
-        raise FlowFailedException, ret if ret.errors.any?
-        ret
+        flow = call(*args)
+        raise FlowFailedException, flow if flow.errors.any?
+        flow
       end
 
       def step_queue
         @step_queue ||= []
       end
+
+      def step_executor(executor_class = nil)
+        if executor_class
+          @executor_class = executor_class
+        else
+          @executor_class ||= ::BusinessFlow::DefaultStepExecutor
+        end
+      end
     end
 
     def self.included(klass)
-      # That we include ActiveModel::Validations is considered part of our
-      # public API, even though we provide our own aliases.
-      klass.include(ActiveModel::Validations)
       klass.extend(ClassMethods)
-      klass.instance_eval do
-        class << self
-          # See above -- that this is an alias is considered public API.
-          alias invariant validates
+    end
+
+    attr_reader :parameter_object
+    private :parameter_object
+
+    def call
+      return if invalid?
+      klass = self.class
+      klass.step_executor.new(klass.step_queue, self).call
+    end
+
+    # Responsible for setting the parameter object and validating inputs.
+    # This is a method directly on the object instead of something we
+    # handle through instance_eval/exec for performance reasons.
+    # :reek:NilCheck
+    private def _business_flow_dsl_initialize(parameter_object, needs)
+      @parameter_object = parameter_object
+      needs.each do |need|
+        if send(need).nil?
+          errors[need] << 'must not be nil'
+          throw :halt_step
         end
-        validates_with NotNilValidator
       end
+      initialize
     end
 
-    # Keep our internal helpers in a different module to avoid polluting the
-    # namespace of whoever includes us.
-    module PrivateHelpers
-      # Handle some logic around conditions
-      class ConditionList
-        def initialize(if_stmts, unless_stmts, klass)
-          @klass = klass
-          @conditions = Array.wrap(if_stmts).map(&method(:to_if)) +
-                        Array.wrap(unless_stmts).map(&method(:to_unless))
-        end
+    def errors
+      @errors ||= ActiveModel::Errors.new(self)
+    end
 
-        def call(instance, inputs)
-          @conditions.all? { |cond| cond.call(instance, inputs) }
-        end
+    def errors?
+      @errors.present?
+    end
 
-        private
+    def valid?(_context = nil)
+      @errors.blank?
+    end
 
-        def to_if(cond)
-          Callable.new(cond, @klass)
-        end
+    def invalid?(context = nil)
+      !valid?(context)
+    end
 
-        def to_unless(cond)
-          if_stmt = to_if(cond)
-          unless_stmt = proc do |instance, input|
-            !if_stmt.call(instance, input)
-          end
-          to_if(unless_stmt)
-        end
+    # Responsible for creating fields on a class and noting the of field
+    class FieldList
+      attr_reader :field_list
+
+      def initialize(field_list, field_klass, klass)
+        @field_list = field_list
+        @field_klass = field_klass
+        @klass = klass
       end
 
-      def self.create_parameter_field(klass, field, fallback = nil)
-        klass.send(:define_method, field, &parameter_proc(field, fallback))
-        klass.send(:private, field)
+      def add_fields(fields)
+        fields.each { |field| @field_klass.new(field).add_to(@klass) }
+        @field_list.concat(fields)
       end
+    end
 
-      def self.read_from_parameter_object(field)
-        proc do
-          if parameter_object.is_a?(Hash) && parameter_object.key?(field)
-            parameter_object[field]
-          else
-            parameter_object.public_send(field)
+    # Helper class to manage logic around adding fields
+    class Field
+      def initialize(field)
+        @field = field
+        # For proc bindings.
+        ivar_name = instance_variable_name
+        @getter = ivar_name
+        @setter = self.class.setter_factory(field, ivar_name)
+      end
+
+      def add_to(klass)
+        Field.eval_method(klass, field, getter)
+        Field.eval_method(klass, setter_name, setter)
+      end
+
+      def self.eval_method(klass, name, str)
+        return if klass.method_defined?(name) ||
+                  klass.private_method_defined?(name)
+        unsafe_eval_method(klass, name, str)
+      end
+
+      def self.unsafe_eval_method(klass, name, str)
+        body = ["private def #{name}", str, 'end'].join("\n")
+        klass.class_eval body, __FILE__, __LINE__
+      end
+
+      def self.setter_factory(field, ivar_name)
+        <<-SETTER
+          #{ivar_name} = new_value
+          throw :halt_step unless valid?(:#{field})
+          new_value
+        SETTER
+      end
+
+      private
+
+      attr_reader :field, :getter, :setter
+
+      def setter_name
+        @setter_name ||= "#{field}=(new_value)"
+      end
+
+      def instance_variable_name
+        @instance_variable_name ||= "@#{field}"
+      end
+    end
+
+    # Create a field with a public getter
+    class PublicField
+      def initialize(field)
+        @name = field
+        @field = Field.new(field)
+      end
+
+      def add_to(klass)
+        @field.add_to(klass)
+        klass.send(:public, @name)
+      end
+    end
+
+    # Helper class around memoized fields
+    class MemoizedField
+      def initialize(field, retriever, setter_factory)
+        @field = field
+        @retriever = retriever
+        @setter_factory = setter_factory
+      end
+
+      def add_to(klass)
+        setter = setter_factory.call(field, safe_ivar_name)
+        Field.unsafe_eval_method(
+          klass, field, memoized(safe_ivar_name, setter, retriever)
+        )
+      end
+
+      private
+
+      attr_reader :field, :retriever, :setter_factory
+
+      def memoized(ivar_name, setter, retriever)
+        <<-MEMOIZED
+          return #{ivar_name} if defined?(#{ivar_name})
+          new_value = begin
+            #{retriever}
           end
-        end
+          #{setter}
+        MEMOIZED
       end
 
-      def self.parameter_proc(field, fallback)
-        read = read_from_parameter_object(field)
-        proc do
-          begin
-            instance_exec(&read)
-          rescue NoMethodError
-            nil
-          end || (fallback && send(fallback))
+      def safe_ivar_name
+        @safe_ivar_name ||= begin
+          "@business_flow_dsl_#{field}"
+            .sub(/\?$/, '_query')
+            .sub(/\!$/, '_bang')
+            .to_sym
         end
       end
+    end
+
+    # Responsible for declaring fields which will be memoized and validated
+    # when first set
+    class UsesField
+      def initialize(field, retriever)
+        @name = field
+        @retriever = retriever
+        @field = MemoizedField.new(field, retriever_method_name,
+                                   Field.method(:setter_factory))
+      end
 
-      def self.create_conditional_callable(klass, opts)
-        return unless opts[:if] || opts[:unless]
-        Callable.new(condition(klass, opts), klass)
+      def add_to(klass)
+        klass.send(:define_method, retriever_method_name, &@retriever)
+        klass.send(:private, retriever_method_name)
+        @field.add_to(klass)
       end
 
-      def self.condition(klass, opts)
-        if_stmts = opts.fetch(:if, proc { true })
-        unless_stmts = opts.fetch(:unless, proc { false })
-        ConditionList.new(if_stmts, unless_stmts, klass)
+      private
+
+      def retriever_method_name
+        @retriever_method_name ||=
+          "_business_flow_dsl_execute_step_for_#{@name}".to_sym
       end
+    end
 
-      def self.create_field(klass, field)
-        return unless field.is_a?(Symbol)
-        define_getter(klass, field)
-        setter_name = "#{field}=".to_sym
-        define_setter(klass, setter_name, field)
-        klass.send(:private, setter_name)
+    # Helper class around input parameter fields
+    class ParameterField
+      def initialize(field, fallback = nil)
+        retriever = "@parameter_object.fetch(:#{field})"
+        retriever += " { send(:#{fallback}) }" if fallback
+        @field = MemoizedField.new(field, retriever, method(:setter_factory))
       end
 
-      def self.define_getter(klass, field)
-        return if klass.method_defined?(field) ||
-                  klass.private_method_defined?(field)
-        klass.send(:attr_reader, field)
+      def add_to(klass)
+        @field.add_to(klass)
       end
 
-      def self.define_setter(klass, setter_name, field)
-        return if klass.method_defined?(setter_name) ||
-                  klass.private_method_defined?(setter_name)
-        klass.send(:define_method, setter_name,
-                   &setter_proc("@#{field}", field))
+      private
+
+      def setter_factory(_field, ivar_name)
+        "#{ivar_name} = new_value"
       end
+    end
 
-      def self.safe_ivar_name(field)
-        ivar_name = "@business_flow_dsl_#{field}"
-        if ivar_name.end_with?('?')
-          ivar_name.sub!(/\?$/, '_query')
-        elsif ivar_name.end_with?('!')
-          ivar_name.sub!(/\!$/, '_bang')
-        end
-        ivar_name.to_sym
+    # Manage logic around input parameters
+    class ParameterObject
+      def initialize(parameters)
+        @parameters = parameters
       end
 
-      def self.setter_proc(ivar_name, field)
-        proc do |new_value|
-          instance_variable_set(ivar_name, new_value)
-          throw :halt_step unless valid?(field)
-          new_value
-        end
+      def fetch(key)
+        value = inner_fetch(key)
+        return yield if !value && block_given?
+        value
       end
 
-      def self.create_memoized_field(klass, field, step)
-        ivar_name = safe_ivar_name(field)
-        setter_proc = self.setter_proc(ivar_name, field)
-        klass.send(:define_method, field) do
-          if instance_variable_defined?(ivar_name)
-            instance_variable_get(ivar_name)
-          else
-            instance_exec(step.call(self).output, &setter_proc)
-          end
+      private
+
+      def inner_fetch(key)
+        if @parameters.is_a?(Hash) && @parameters.key?(key)
+          @parameters[key]
+        else
+          @parameters.public_send(key)
         end
+      rescue NoMethodError
+        nil
       end
     end
   end

data/lib/business_flow/instrument.rb

@@ -0,0 +1,17 @@
+module BusinessFlow
+  # Include me to fire ActiveSupport notifications on the flow, every step,
+  # and for any errors that happen.
+  module Instrument
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.step_executor ::BusinessFlow::InstrumentedExecutor
+    end
+
+    # Contains methods that we add to the DSL
+    module ClassMethods
+      def instrument_steps
+        step_executor ::BusinessFlow::InstrumentedStepExecutor
+      end
+    end
+  end
+end

data/lib/business_flow/instrumented_executor.rb

@@ -0,0 +1,28 @@
+module BusinessFlow
+  # Fire ActiveSupport events for every step that's run and on errors
+  class InstrumentedExecutor < DefaultStepExecutor
+    def call
+      name = flow_event_name
+      payload = { flow: flow }
+      ActiveSupport::Notifications.instrument(name, payload) do
+        super
+      end
+      notify_errors(name, payload)
+    end
+
+    protected
+
+    def notify_errors(name, payload)
+      return unless flow.errors?
+      ActiveSupport::Notifications.publish(name + '.error', payload)
+    end
+
+    def flow_name
+      @flow_name ||= flow.class.to_s.underscore
+    end
+
+    def flow_event_name
+      @flow_event_name ||= "business_flow.flow.#{flow_name}"
+    end
+  end
+end

data/lib/business_flow/instrumented_step_executor.rb

@@ -0,0 +1,23 @@
+module BusinessFlow
+  # Fire ActiveSupport events for every step that's run and on errors
+  class InstrumentedStepExecutor < InstrumentedExecutor
+    protected
+
+    def execute_step(step)
+      i_name = event_name(step)
+      i_payload = { flow: flow, step: step }
+      ActiveSupport::Notifications.instrument(i_name, i_payload) do |payload|
+        payload[:step_result] = super
+      end
+      notify_errors(i_name, i_payload)
+    end
+
+    def step_event_name(step)
+      "#{flow_name}.#{step.to_s.underscore}"
+    end
+
+    def event_name(step)
+      "business_flow.step.#{step_event_name(step)}"
+    end
+  end
+end

data/lib/business_flow/step.rb

@@ -35,19 +35,17 @@ module BusinessFlow
     # Represents the result of a step, and allows setting response values on
     # an object, and merging error data into the same object.
     class Result
+      # :reek:ManualDispatch Checking respond_to? is signficantly faster than
+      # eating the NoMethodError when grabbing our error object.
       def initialize(result, output_map, output_callable)
         @result = result
         @output_map = output_map
         @output_callable = output_callable
-        @result_errors = begin
-                           result.errors
-                         rescue NoMethodError
-                           nil
-                         end
+        @result_errors = result.respond_to?(:errors) ? result.errors : nil
       end
 
       def merge_into(object)
-        merge_errors_into(object.errors)
+        merge_errors_into(object)
         merge_outputs_into(object)
       end
 
@@ -74,11 +72,11 @@ module BusinessFlow
 
       private
 
-      def merge_errors_into(errors)
+      def merge_errors_into(object)
         return if @result_errors.blank?
         @result_errors.each do |attribute, message|
           attribute = "#{@result.class.name.underscore}.#{attribute}"
-          (errors[attribute] << message).uniq!
+          (object.errors[attribute] << message).uniq!
         end
         throw :halt_step
       end
@@ -111,13 +109,56 @@ module BusinessFlow
       end
     end
 
+    # Handle some logic around conditions
+    class ConditionList
+      def initialize(if_stmts, unless_stmts)
+        @conditions = Array.wrap(if_stmts).map(&Callable.method(:new)) +
+                      Array.wrap(unless_stmts).map(&method(:to_unless))
+      end
+
+      def call(instance, inputs)
+        @conditions.all? { |cond| cond.call(instance, inputs) }
+      end
+
+      private
+
+      def to_unless(cond)
+        if_stmt = Callable.new(cond)
+        unless_stmt = proc do |instance, input|
+          !if_stmt.call(instance, input)
+        end
+        Callable.new(unless_stmt)
+      end
+    end
+
+    # Responsible for creating objects based on our input options
+    Options = Struct.new(:opts) do
+      def input_object
+        Inputs.new(opts[:inputs] || {})
+      end
+
+      def result_factory
+        ResultFactory.new(opts[:outputs] || {},
+                          opts[:output] || ->(result) { result })
+      end
+
+      def condition
+        opts.fetch(:condition) do
+          if_stmts = opts[:if]
+          unless_stmts = opts[:unless]
+          if if_stmts.present? || unless_stmts.present?
+            ConditionList.new(if_stmts, unless_stmts)
+          end
+        end || proc { true }
+      end
+    end
+
     def initialize(callable, opts)
       @callable = callable
-      @input_object = Inputs.new(opts[:inputs] || {})
-      outputs = opts[:outputs] || {}
-      output = opts[:output] || ->(result) { result }
-      @result_factory = ResultFactory.new(outputs, output)
-      @condition = opts[:condition] || proc { true }
+      opts = Options.new(opts)
+      @input_object = opts.input_object
+      @result_factory = opts.result_factory
+      @condition = opts.condition
     end
 
     def call(parameter_source)

data/lib/business_flow/validations.rb

@@ -0,0 +1,25 @@
+module BusinessFlow
+  # Responsible for adding validations to flow objects
+  module Validations
+    # Additions to the DSL
+    module ClassMethods
+      # Declares that you expect to set this field during the course of
+      # processing, and that it should meet the given ActiveModel
+      # validations.
+      def expects(field, options = {})
+        validates field, options.merge(on: field)
+        ::BusinessFlow::DSL::Field.new(field).add_to(self)
+      end
+    end
+
+    def self.included(klass)
+      klass.include(ActiveModel::Validations)
+      klass.class_eval do
+        class << self
+          alias_method :invariant, :validates
+        end
+      end
+      klass.extend ClassMethods
+    end
+  end
+end

data/lib/business_flow/version.rb

@@ -1,3 +1,3 @@
 module BusinessFlow
-  VERSION = '0.7.0'.freeze
+  VERSION = '0.8.0'.freeze
 end

data/lib/business_flow.rb

@@ -1,14 +1,17 @@
 require 'active_model'
 require 'active_support/core_ext'
 require 'business_flow/version'
-require 'business_flow/not_nil_validator'
 require 'business_flow/flow_failed_exception'
 require 'business_flow/callable'
 require 'business_flow/step'
 require 'business_flow/default_step_executor'
+require 'business_flow/instrumented_executor'
+require 'business_flow/instrumented_step_executor'
 require 'business_flow/dsl'
+require 'business_flow/validations'
 require 'business_flow/base'
 require 'business_flow/cacheable'
+require 'business_flow/instrument'
 
 # Makes the magic happen.
 module BusinessFlow

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: business_flow
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Alex Scarborough
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-30 00:00:00.000000000 Z
+date: 2018-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -175,8 +175,11 @@ files:
 - lib/business_flow/default_step_executor.rb
 - lib/business_flow/dsl.rb
 - lib/business_flow/flow_failed_exception.rb
-- lib/business_flow/not_nil_validator.rb
+- lib/business_flow/instrument.rb
+- lib/business_flow/instrumented_executor.rb
+- lib/business_flow/instrumented_step_executor.rb
 - lib/business_flow/step.rb
+- lib/business_flow/validations.rb
 - lib/business_flow/version.rb
 homepage: https://teak.io
 licenses:

data/lib/business_flow/not_nil_validator.rb

@@ -1,14 +0,0 @@
-module BusinessFlow
-  # Validate that a given value is not nil, but allow blank/empty values.
-  class NotNilValidator < ActiveModel::Validator
-    # :reek:NilCheck :reek:UtilityFunction
-    # Dear reek -- I didn't decided the ActiveModel Validator API, I just
-    # have to live with it.
-    def validate(record)
-      record.class.needs.each do |attribute|
-        value = record.read_attribute_for_validation(attribute)
-        record.errors[attribute] << 'must not be nil' if value.nil?
-      end
-    end
-  end
-end