business_flow 0.14.3 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d092e9b5f888ba0d28ec1c9cbdfce342b0ba04f
-  data.tar.gz: 8a646af9cb30e6508bbec4071b0cd68a2a4658a8
+  metadata.gz: 25f54a9a721877633ad76d93f973d3baf0e84d0d
+  data.tar.gz: 7c4e8e3b4f997cf91d1d663194930ccf3807e34a
 SHA512:
-  metadata.gz: cd0382fa43d0a787c73619acf21c9dfe3053f97647a2604a3206150eff8a6fa02f4552ac17df9327e49c3c2fcc03bf14f2e4a8cef3488f10f54720c7384152e2
-  data.tar.gz: 1a4701642f270245dff8f06241b9973dd775819810ce152cc3f8f0f777384cb6283d4db5b8f74c9e1d8cacad9c607ed74026ff7dc62fb45a09d2dff1d775a37a
+  metadata.gz: 398c6d9402cb210f13a5bce50646d00c1cbbda22c18571526066483521f559a7002c87bdc0210f6f74a72cf6a5ff2f79d54cb4fe61155a3e3d54ded720e02ae3
+  data.tar.gz: dd18129f71f57d0f5a7032c45643a81a5ffe439a5bdaa500e5143a8c52630921bd049d5994ce0292d7f0f353c1e63821ab3472341f83543555d864517467a84e

data/Gemfile.lock

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

data/lib/business_flow/cacheable.rb

@@ -54,10 +54,15 @@ module BusinessFlow
         if key
           @cache_key = Callable.new(key)
         else
-          @cache_key ||= Callable.new(:parameter_object)
+          @cache_key ||= default_cache_key
         end
       end
 
+      # :reek:UtilityFunction
+      def default_cache_key
+        Callable.new(:_business_flow_dsl_parameters)
+      end
+
       def execute(flow)
         with_cache(flow) do
           super(flow)._business_flow_cacheable_finalize(flow.cache_key)

data/lib/business_flow/dsl.rb

@@ -4,6 +4,32 @@ module BusinessFlow
   module DSL
     # Contains the DSL for BusinessFlow
     module ClassMethods
+      # Holds metadata about inputs to a flow
+      class Inputs
+        attr_reader :all, :needs, :optionals
+
+        def initialize(klass)
+          @needs = FieldList.new([], ParameterField, klass)
+          @optionals = FieldList.new([], ParameterField, klass)
+          @all = []
+        end
+
+        def add_needs(fields)
+          @all += fields
+          @needs.add_fields(fields)
+        end
+
+        def add_optional(fields)
+          @all += fields
+          @optionals.add_fields(fields)
+        end
+
+        def add_wants(field)
+          @all << field.name
+          @optionals.add_field(field)
+        end
+      end
+
       # Requires that a field be retrievable from the initialization parameters
       #
       # This will only require that the field is not nil. The field may still
@@ -11,22 +37,24 @@ module BusinessFlow
       #
       # @param fields The fields required from the initialization parameters
       def needs(*fields)
-        @needs ||= FieldList.new([], ParameterField, self)
-        @needs.add_fields(fields)
+        inputs.add_needs(fields)
       end
 
       # Allows a field to be retieved form the initialization paramters,
       # but does not require it to be non-nil
       def optional(*fields)
-        @optionals ||= FieldList.new([], ParameterField, self)
-        @optionals.add_fields(fields)
+        inputs.add_optional(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)
-        ParameterField.new(field, internal_name).add_to(self)
+        inputs.add_wants(ParameterField.new(field, internal_name))
+      end
+
+      def inputs
+        @inputs ||= Inputs.new(self)
       end
 
       # Declares that you will expose a field to the outside world.
@@ -38,8 +66,11 @@ module BusinessFlow
         @provides.add_fields(fields)
       end
 
-      def uses(field, klass, opts = {})
-        step = Step.new(Callable.new(klass), opts)
+      # :reek:ControlParameter It's just nicer to have this fall back to a
+      # block than have a different DSL method when using/not using blocks
+      def uses(field, klass = nil, opts = {}, &blk)
+        step = Step.new(Callable.new(klass || blk),
+                        { default_output: field }.merge(opts))
         retriever = proc { step.call(self).output }
         UsesField.new(field, retriever).add_to(self)
       end
@@ -68,8 +99,7 @@ module BusinessFlow
         finalize_initializer
         allocate.tap do |flow|
           catch(:halt_step) do
-            flow.send(:_business_flow_dsl_initialize,
-                      ParameterObject.new(parameter_object))
+            flow.send(:_business_flow_dsl_initialize, parameter_object)
           end
         end
       end
@@ -203,6 +233,33 @@ module BusinessFlow
       initialize
     end
 
+    # :reek:NilCheck
+    private def _business_flow_parameter_fetch(key)
+      value = _business_flow_parameter_inner_fetch(key)
+      # We only want to fall back to a default if we were
+      # given nil. Other falsy vlues should be directly used.
+      return yield if value.nil? && block_given?
+      value
+    end
+
+    private def _business_flow_parameter_inner_fetch(key)
+      if @parameter_object.is_a?(Hash) && @parameter_object.key?(key)
+        @parameter_object[key]
+      else
+        @parameter_object.public_send(key)
+      end
+    rescue NoMethodError
+      nil
+    end
+
+    private def _business_flow_dsl_parameters
+      @_business_flow_dsl_parameters ||= Hash[
+        self.class.inputs.all.map do |input|
+          [input, _business_flow_parameter_inner_fetch(input)]
+        end
+      ]
+    end
+
     def errors
       @errors ||= ActiveModel::Errors.new(self)
     end
@@ -239,13 +296,12 @@ module BusinessFlow
         fields.each do |field|
           add_field(@field_klass.new(field))
         end
-        @field_list.concat(fields)
+        @field_list
       end
 
-      private
-
       def add_field(field)
         @klasses.each { |klass| field.add_to(klass) }
+        @field_list.push(field.name)
       end
     end
 
@@ -264,6 +320,10 @@ module BusinessFlow
         Field.eval_method(klass, setter_name, setter)
       end
 
+      def name
+        field
+      end
+
       def self.eval_method(klass, name, str)
         return if klass.method_defined?(name) ||
                   klass.private_method_defined?(name)
@@ -307,6 +367,10 @@ module BusinessFlow
         @field.add_to(klass)
         klass.send(:public, @name)
       end
+
+      def name
+        @field.name
+      end
     end
 
     # Helper class around memoized fields
@@ -326,6 +390,10 @@ module BusinessFlow
         )
       end
 
+      def name
+        field
+      end
+
       private
 
       attr_reader :retriever, :setter_factory
@@ -353,6 +421,8 @@ module BusinessFlow
     # Responsible for declaring fields which will be memoized and validated
     # when first set
     class UsesField
+      attr_reader :name
+
       def initialize(field, retriever)
         @name = field
         @retriever = retriever
@@ -364,6 +434,7 @@ module BusinessFlow
         klass.send(:define_method, retriever_method_name, &@retriever)
         klass.send(:private, retriever_method_name)
         @field.add_to(klass)
+        klass.send(:public, @name)
       end
 
       private
@@ -377,7 +448,7 @@ module BusinessFlow
     # Helper class around input parameter fields
     class ParameterField
       def initialize(field, fallback = nil)
-        retriever = "@parameter_object.fetch(:#{field})"
+        retriever = "_business_flow_parameter_fetch(:#{field})"
         retriever += " { send(:#{fallback}) }" if fallback
         @field = MemoizedField.new(field, retriever, method(:setter_factory))
       end
@@ -387,42 +458,14 @@ module BusinessFlow
         klass.send(:public, @field.field)
       end
 
-      private
-
-      def setter_factory(_field, ivar_name)
-        "#{ivar_name} = new_value"
-      end
-    end
-
-    # Manage logic around input parameters
-    class ParameterObject
-      def initialize(parameters)
-        @parameters = parameters
-      end
-
-      # :reek:NilCheck
-      def fetch(key)
-        value = inner_fetch(key)
-        # We only want to fall back to a default if we were
-        # given nil. Other falsy vlues should be directly used.
-        return yield if value.nil? && block_given?
-        value
-      end
-
-      def to_s
-        @parameters.to_s
+      def name
+        @field.name
       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
+      def setter_factory(_field, ivar_name)
+        "#{ivar_name} = new_value"
       end
     end
   end

data/lib/business_flow/step.rb

@@ -35,11 +35,12 @@ 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
-      def initialize(parameter_source, result, output_map, output_callable)
-        @parameter_source = parameter_source
+      attr_reader :output
+
+      def initialize(result, output_map, output)
         @result = result
+        @output = output
         @output_map = output_map
-        @output_callable = output_callable
       end
 
       def merge_into(object)
@@ -69,10 +70,6 @@ module BusinessFlow
         end
       end
 
-      def output
-        @parameter_source.instance_exec(@result, &@output_callable)
-      end
-
       def self.process_output(object, output, output_setter)
         case output_setter
         when Symbol
@@ -120,10 +117,31 @@ module BusinessFlow
       def merge_into(_object); end
     end
 
+    CONDITION_FAILED = ConditionFailedResult.new.freeze
+
     # Manage creating results for our step
-    ResultFactory = Struct.new(:outputs, :output_callable) do
+    ResultFactory = Struct.new(:outputs, :output_callable, :default_output) do
       def result(step_result, parameter_source)
-        Result.new(parameter_source, step_result, outputs, output_callable)
+        callable = callable_for(step_result)
+
+        output = if callable
+                   parameter_source.instance_exec(step_result, &callable)
+                 else
+                   step_result
+                 end
+
+        Result.new(step_result, outputs, output)
+      end
+
+    private
+
+      # :reek:ManualDispatch This is faster.
+      def callable_for(step_result)
+        if output_callable
+          output_callable
+        elsif default_output && step_result.respond_to?(default_output)
+          default_output
+        end
       end
     end
 
@@ -152,12 +170,14 @@ module BusinessFlow
     # Responsible for creating objects based on our input options
     Options = Struct.new(:opts) do
       def input_object
-        Inputs.new(opts[:inputs] || {})
+        inputs = opts[:inputs]
+        inputs.present? ? Inputs.new(inputs) : nil
       end
 
       def result_factory
         ResultFactory.new(opts[:outputs] || {},
-                          opts[:output] || ->(result) { result })
+                          opts[:output],
+                          opts[:default_output])
       end
 
       def condition
@@ -167,7 +187,7 @@ module BusinessFlow
           if if_stmts.present? || unless_stmts.present?
             ConditionList.new(if_stmts, unless_stmts)
           end
-        end || proc { true }
+        end
       end
     end
 
@@ -177,15 +197,17 @@ module BusinessFlow
       @input_object = opts.input_object
       @result_factory = opts.result_factory
       @condition = opts.condition
+
+      update_call_method
     end
 
     def call(parameter_source)
       parameters = @input_object.parameters_from_source(parameter_source)
-      if @condition.call(parameter_source, parameters)
+      if !@condition || @condition.call(parameter_source, parameters)
         @result_factory.result(@callable.call(parameter_source, parameters),
                                parameter_source)
       else
-        ConditionFailedResult.new
+        CONDITION_FAILED
       end
     end
 
@@ -200,5 +222,33 @@ module BusinessFlow
     def to_s
       @callable.to_s
     end
+
+    private
+
+    PARAMETERS_NO_INPUT = 'parameter_source'.freeze
+    PARAMETERS_WITH_INPUT =
+      '@input_object.parameters_from_source(parameter_source)'.freeze
+    WITHOUT_CONDITION = %(
+      @result_factory.result(@callable.call(parameter_source, parameters),
+                             parameter_source)
+    ).freeze
+    WITH_CONDITION = %(
+      if @condition.call(parameter_source, parameters)
+        #{WITHOUT_CONDITION}
+      else
+        CONDITION_FAILED
+      end
+    ).freeze
+
+    def update_call_method
+      params = @input_object ? PARAMETERS_WITH_INPUT : PARAMETERS_NO_INPUT
+      code = %(
+        def call(parameter_source)
+          parameters = #{params}
+          #{@condition ? WITH_CONDITION : WITHOUT_CONDITION}
+        end
+      )
+      instance_eval code
+    end
   end
 end

data/lib/business_flow/version.rb

@@ -1,3 +1,3 @@
 module BusinessFlow
-  VERSION = '0.14.3'.freeze
+  VERSION = '0.15.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: business_flow
 version: !ruby/object:Gem::Version
-  version: 0.14.3
+  version: 0.15.0
 platform: ruby
 authors:
 - Alex Scarborough
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-17 00:00:00.000000000 Z
+date: 2019-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel