business_flow 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b485a68eacf74616f5f9e0fe635e210e017c9249
-  data.tar.gz: a3f786a40733abc5299058190545226953178450
+  metadata.gz: aa83401ab6f440779738905d43a9b7114ed03e68
+  data.tar.gz: 5af8dbff7edf19b183a8201f418ef3555aadd54a
 SHA512:
-  metadata.gz: f74896456557f2042328b355973aabbe77b311466f76470fff9483a6d13a732c4847da248848bc61d4609115be75ff3eed27927e0c717ddaee58de7784fdaf25
-  data.tar.gz: 327b5cda58ad5add151556a4ad164ec360f0a0421f66827f4ba431f8bc21b075131f92aabc113b4ff491c80029357c9188b01e9c194801a7c543beadfdfb9990
+  metadata.gz: 9d44e6d0dd4d71e140fe4f4fff24b1243295355cd71c4e128585a08c0abab3cb93f5da9ea28db39cdd25a7088fa8e03c53ca4fe35623fe63b2c7dbd45df71cd2
+  data.tar.gz: f16efd204e218ffd86a0850cefa452b338171164d7fb1ded0bb157745637459e9c49a843acfb4ee5366a8bddc7f370dab3252df8fe7d7abd7762702d8c35da7f

data/Gemfile.lock

@@ -1,18 +1,18 @@
 PATH
   remote: .
   specs:
-    business_flow (0.6.0)
+    business_flow (0.7.0)
       activemodel (>= 3.0)
       activesupport (>= 3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (5.1.5)
-      activesupport (= 5.1.5)
-    activesupport (5.1.5)
+    activemodel (5.1.6)
+      activesupport (= 5.1.6)
+    activesupport (5.1.6)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (~> 0.7)
+      i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
     ast (2.4.0)
@@ -30,7 +30,7 @@ GEM
     diff-lcs (1.3)
     docile (1.1.5)
     equalizer (0.0.11)
-    i18n (0.9.5)
+    i18n (1.0.0)
       concurrent-ruby (~> 1.0)
     ice_nine (0.11.2)
     json (2.1.0)

data/lib/business_flow/cacheable.rb

@@ -7,7 +7,8 @@ module BusinessFlow
 
     def cache_key
       klass = self.class
-      "#{klass.name}/#{klass.cache_key.call(self, nil)}"
+      key = Digest::SHA256.hexdigest(klass.cache_key.call(self, nil).to_s)
+      "#{klass.name.underscore}/#{key}"
     end
 
     # DSL Methods
@@ -16,7 +17,11 @@ module BusinessFlow
         if store
           @cache_store = store
         else
-          @cache_store ||= ActiveSupport::Cache::MemoryStore.new
+          @cache_store ||= if defined?(Rails)
+                             Rails.cache
+                           else
+                             ActiveSupport::Cache::MemoryStore.new
+                           end
         end
       end
 

data/lib/business_flow/dsl.rb

@@ -8,8 +8,6 @@ module BusinessFlow
     # was initialized with. The provided .call will instantiate the including
     # class with a parameter_object as the only argument.
     module ClassMethods
-      attr_reader :requirements
-
       # Requires that a field be retrievable from the initialization parameters
       #
       # This will only require that the field is not nil. The field may still
@@ -17,25 +15,26 @@ module BusinessFlow
       #
       # @param fields The fields required from the initialization parameters
       def needs(*fields)
-        @requirements ||= []
-        @requirements.push(*fields)
-        wants(*fields)
-      end
-
-      # Allows a field to be retrieved from the initialiaztoin parameters
-      #
-      # Unlike needs, this applies no validation to the field. It may
-      # be nil.
-      #
-      # @param (see #needs)
-      def wants(*fields)
+        @needs ||= []
+        return @needs if fields.blank?
+        @needs.push(*fields)
         fields.each do |field|
           PrivateHelpers.create_parameter_field(self, field)
         end
       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)
+      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
 
@@ -44,7 +43,14 @@ module BusinessFlow
       # validations.
       def expects(field, options = {})
         validates field, options.merge(on: field)
-        provides field
+        PrivateHelpers.create_field(self, field)
+      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
       end
 
       def step(klass, opts = {})
@@ -53,7 +59,9 @@ module BusinessFlow
           condition: PrivateHelpers.create_conditional_callable(self, opts)
         )
         step_queue << step = Step.new(callable, opts)
-        provides(*step.outputs.values)
+        step.outputs.values.each do |field|
+          PrivateHelpers.create_field(self, field)
+        end
       end
 
       def call(parameter_object)
@@ -115,15 +123,30 @@ module BusinessFlow
         end
       end
 
-      def self.create_parameter_field(klass, field)
-        klass.send(:define_method, field) do
+      def self.create_parameter_field(klass, field, fallback = nil)
+        klass.send(:define_method, field, &parameter_proc(field, fallback))
+        klass.send(:private, field)
+      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)
           end
         end
-        klass.send(:private, field)
+      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))
+        end
       end
 
       def self.create_conditional_callable(klass, opts)
@@ -139,21 +162,54 @@ module BusinessFlow
 
       def self.create_field(klass, field)
         return unless field.is_a?(Symbol)
-        klass.send(:attr_reader, field)
+        define_getter(klass, field)
         setter_name = "#{field}=".to_sym
         define_setter(klass, setter_name, field)
         klass.send(:private, setter_name)
       end
 
+      def self.define_getter(klass, field)
+        return if klass.method_defined?(field) ||
+                  klass.private_method_defined?(field)
+        klass.send(:attr_reader, field)
+      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) do |new_value|
-          instance_variable_set("@#{field}".to_sym, new_value)
+        klass.send(:define_method, setter_name,
+                   &setter_proc("@#{field}", field))
+      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
+      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
       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
+        end
+      end
     end
   end
 end

data/lib/business_flow/not_nil_validator.rb

@@ -5,8 +5,7 @@ module BusinessFlow
     # Dear reek -- I didn't decided the ActiveModel Validator API, I just
     # have to live with it.
     def validate(record)
-      requirements = record.class.requirements || []
-      requirements.each do |attribute|
+      record.class.needs.each do |attribute|
         value = record.read_attribute_for_validation(attribute)
         record.errors[attribute] << 'must not be nil' if value.nil?
       end

data/lib/business_flow/step.rb

@@ -35,9 +35,10 @@ 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(result, output_map)
+      def initialize(result, output_map, output_callable)
         @result = result
         @output_map = output_map
+        @output_callable = output_callable
         @result_errors = begin
                            result.errors
                          rescue NoMethodError
@@ -58,6 +59,10 @@ module BusinessFlow
         @result_errors.present?
       end
 
+      def output
+        @output_callable.call(@result)
+      end
+
       def self.process_output(object, output, output_setter)
         case output_setter
         when Symbol
@@ -99,19 +104,26 @@ module BusinessFlow
       def merge_into(_object); end
     end
 
-    attr_reader :outputs
+    # Manage creating results for our step
+    ResultFactory = Struct.new(:outputs, :output_callable) do
+      def result(step_result)
+        Result.new(step_result, outputs, output_callable)
+      end
+    end
 
     def initialize(callable, opts)
       @callable = callable
       @input_object = Inputs.new(opts[:inputs] || {})
-      @outputs = opts[:outputs] || {}
+      outputs = opts[:outputs] || {}
+      output = opts[:output] || ->(result) { result }
+      @result_factory = ResultFactory.new(outputs, output)
       @condition = opts[:condition] || proc { true }
     end
 
     def call(parameter_source)
       parameters = @input_object.parameters_from_source(parameter_source)
       if @condition.call(parameter_source, parameters)
-        Result.new(@callable.call(parameter_source, parameters), outputs)
+        @result_factory.result(@callable.call(parameter_source, parameters))
       else
         ConditionFailedResult.new
       end
@@ -121,6 +133,10 @@ module BusinessFlow
       @input_object.inputs
     end
 
+    def outputs
+      @result_factory.outputs
+    end
+
     def to_s
       @callable.to_s
     end

data/lib/business_flow/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: business_flow
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Alex Scarborough
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-29 00:00:00.000000000 Z
+date: 2018-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel