business_flow 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad421ec64fb9e1b5b196c149b715a27c0a2c4f41
-  data.tar.gz: 8088761788568a2246509d4b89c44ee62e4ce1f2
+  metadata.gz: 59f3aeae56b561faae00b90ca42cda1eb822124b
+  data.tar.gz: 937c3212f40c0dcfa708e94b846f225f9d46e161
 SHA512:
-  metadata.gz: 80f20f73dcb164fedefbd6248e9d498505f684e4ac81c21fd9469d68524dae6c3f1cbad775982f68f198ed154dc566a299c0098ac3d81b03ee21b73e8b3f4e14
-  data.tar.gz: 16e5ee6e8c62b0b69724b19503f0e989d3d46334df6f058c041ad459ed0b1d43096ccd6d12a112f9445000975bd284ae3c897fea262e24e716b3b4255f21b1f0
+  metadata.gz: 6ae409cc67496b6e54c228c7f93cb93cbf6efe837878c15a5be5dce789036e9bcdbf5e38ded9b178016026a73d3ccc30b9e402f71097353d97c3e649a73b4add
+  data.tar.gz: d31ee7ddf43d7d5ac03f0d1d51e3d64d3893a38de3939e434dfe3d340f7a2449fba0b317258b22b059c2251a750299f038fbebafbfbeedf34b18501a37d3d154

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    business_flow (0.1.0)
+    business_flow (0.1.2)
       activemodel (>= 3.0)
 
 GEM

data/lib/business_flow/base.rb

@@ -10,84 +10,11 @@ module BusinessFlow
   # ActiveSupport notifiers
   class Base
     include ActiveModel::Validations
+    include DSL
 
-    class << self
-      alias invariant validates
-    end
-
-    class_attribute :step_queue, :requirements
     attr_reader :parameter_object
     private :parameter_object
 
-    def self.add_requirement(fields)
-      @requirements ||= []
-      @requirements.concat(fields)
-      fields.each do |field|
-        validates_with NotNilValidator, attributes: [field]
-      end
-    end
-
-    def self.needs(*fields)
-      add_requirement(fields)
-      wants(*fields)
-    end
-
-    def self.wants(*fields)
-      fields.each { |field| add_field(field) }
-    end
-
-    def self.provides(*fields)
-      attr_reader(*fields)
-    end
-
-    def self.expects(field, options = {})
-      validates field, options.merge(on: field)
-    end
-
-    def self.add_field(field)
-      define_method field do
-        if parameter_object.is_a?(Hash) && parameter_object.key?(field)
-          parameter_object[field]
-        else
-          parameter_object.public_send(field)
-        end
-      end
-    end
-
-    def self.steps(*step_queue)
-      self.step_queue = step_queue.map do |step|
-        if !step.is_a?(Step)
-          Step.new(step, {}, {}, self)
-        else
-          step
-        end
-      end
-    end
-
-    def self.step(klass, inputs = {}, outputs = {})
-      create_fields_for_step_outputs(outputs)
-      Step.new(klass, inputs, outputs, self)
-    end
-
-    def self.create_fields_for_step_outputs(outputs)
-      outputs.values.select { |field| field.is_a?(Symbol) }.map do |field|
-        attr_reader field
-        create_setter(field)
-      end
-    end
-
-    def self.create_setter(field)
-      define_method "#{field}=" do |new_value|
-        instance_variable_set("@#{field}", new_value)
-        valid?(field)
-        new_value
-      end
-    end
-
-    def self.call(parameter_object)
-      new(parameter_object).tap(&:call)
-    end
-
     def initialize(parameter_object)
       @parameter_object = parameter_object
     end
@@ -97,18 +24,13 @@ module BusinessFlow
       process_steps
     end
 
-    def merge_errors_into(other_errors)
-      errors.each do |attribute, message|
-        attribute = "#{self.class.name.underscore}.#{attribute}"
-        (other_errors[attribute] << message).uniq!
-      end
-    end
-
     private
 
     def process_steps
       steps.each do |step_name|
-        process_step(step_name)
+        catch(:halt_step) do
+          process_step(step_name)
+        end
         break if errors.any?
       end
     end
@@ -131,12 +53,18 @@ module BusinessFlow
     end
 
     def marshall_outputs(result, output_object)
-      result.merge_errors_into(errors)
-      return if errors.any? || output_object.blank?
+      merge_other_errors(result.errors, result.class.name.underscore)
       output_object.each do |(output_name, output_setter)|
+        break if errors.any?
         output = result.public_send(output_name)
         process_output(output, output_setter)
-        break if errors.any?
+      end
+    end
+
+    def merge_other_errors(other_errors, base_name)
+      other_errors.each do |attribute, message|
+        attribute = "#{base_name}.#{attribute}"
+        (errors[attribute] << message).uniq!
       end
     end
 

data/lib/business_flow/callable.rb

@@ -0,0 +1,54 @@
+module BusinessFlow
+  # Isolate the logic around invoking a 'callable' -- a symbol representing a
+  # method, a symbol representing another class which implements .call, or a
+  # proc/lambda
+  class Callable
+    def initialize(callable, metaclass)
+      @metaclass = metaclass
+      @callable = callable
+      check_callable
+    end
+
+    def call(instance, inputs)
+      cached_proc.call(instance, inputs)
+    end
+
+    private
+
+    # :reek:ManualDispatch Look reek I don't know what you want me to do.
+    def check_callable
+      if @callable.is_a?(Proc)
+        @cached_proc = proc do |instance, inputs|
+          instance.instance_exec(inputs, &@callable)
+        end
+      elsif @callable.respond_to?(:call)
+        @cached_proc = proc { |_, inputs| @callable.call(inputs) }
+      elsif !@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) && nil }
+        else
+          @callable = lookup_callable ||
+                      raise(NameError, "undefined constant #{@klass}")
+          proc { |_, inputs| @callable.call(inputs) }
+        end
+    end
+
+    def lookup_callable
+      constant_name = @callable.to_s.camelcase
+      @metaclass.parents.each do |parent|
+        begin
+          break parent.const_get(constant_name)
+        rescue NameError
+          next
+        end
+      end
+    end
+  end
+end

data/lib/business_flow/dsl.rb

@@ -0,0 +1,88 @@
+module BusinessFlow
+  module DSL
+    def self.included(klass)
+      klass.include(ActiveModel::Validations)
+      klass.extend(ClassMethods)
+      klass.instance_eval do
+        class << self
+          alias invariant validates
+        end
+      end
+    end
+
+    module ClassMethods
+      def step_queue
+        @step_queue ||= []
+      end
+
+      def add_requirement(fields)
+        @requirements ||= []
+        @requirements.concat(fields)
+        fields.each do |field|
+          validates_with NotNilValidator, attributes: [field]
+        end
+      end
+
+      def needs(*fields)
+        add_requirement(fields)
+        wants(*fields)
+      end
+
+      def wants(*fields)
+        fields.each { |field| add_parameter_field(field) }
+      end
+
+      def provides(*fields)
+        attr_reader(*fields)
+        attr_writer(*fields)
+        fields.each { |field| private("#{field}=") }
+      end
+
+      def expects(field, options = {})
+        attr_reader field
+        validates field, options.merge(on: field)
+        setter_name = "#{field}=".to_sym
+        unless method_defined?(setter_name) ||
+               private_method_defined?(setter_name)
+          create_setter(field)
+        end
+      end
+
+      def add_parameter_field(field)
+        define_method field do
+          if parameter_object.is_a?(Hash) && parameter_object.key?(field)
+            parameter_object[field]
+          else
+            parameter_object.public_send(field)
+          end
+        end
+      end
+
+      def step(klass, opts = {})
+        create_fields_for_step_outputs(opts.fetch(:outputs, {}))
+        step_queue << Step.new(klass, opts, self)
+      end
+
+      def create_fields_for_step_outputs(outputs)
+        outputs.values.select { |field| field.is_a?(Symbol) }.map do |field|
+          attr_reader field
+          create_setter(field)
+        end
+      end
+
+      def create_setter(field)
+        setter_name = "#{field}=".to_sym
+        define_method setter_name do |new_value|
+          instance_variable_set("@#{field}".to_sym, new_value)
+          throw :halt_step unless valid?(field)
+          new_value
+        end
+        private(setter_name)
+      end
+
+      def call(parameter_object)
+        new(parameter_object).tap(&:call)
+      end
+    end
+  end
+end

data/lib/business_flow/step.rb

@@ -1,43 +1,19 @@
 module BusinessFlow
   class Step
     attr_reader :klass, :inputs, :outputs
-    def initialize(klass, inputs, outputs, flow_klass)
+    def initialize(klass, opts, flow_klass)
       @klass = klass
-      @inputs = inputs
-      @outputs = outputs
-      @flow_klass = flow_klass
+      @inputs = opts.fetch(:inputs, {})
+      @outputs = opts.fetch(:outputs, {})
+      if_condition = opts[:if]
+      @condition = Callable.new(if_condition, flow_klass) if if_condition
+      @callable = Callable.new(@klass, flow_klass)
     end
 
     # @klass can be a symbol or class
     def dispatch(flow, inputs)
-      callable.call(flow, inputs)
-    end
-
-    private
-
-    def callable
-      @callable ||=
-        if @klass.is_a?(Symbol) &&
-           @flow_klass.method_defined?(@klass) ||
-           @flow_klass.private_method_defined?(@klass)
-          proc { |flow, _| flow.send(@klass) && nil }
-        else
-          @klass = lookup_klass ||
-                   raise(NameError, "undefined constant #{@klass}")
-          proc { |_, inputs| @klass.call(inputs) }
-        end
-    end
-
-    def lookup_klass
-      return @klass unless @klass.is_a?(Symbol)
-      constant_name = @klass.to_s.camelcase
-      @flow_klass.parents.each do |parent|
-        begin
-          break parent.const_get(constant_name)
-        rescue NameError
-          next
-        end
-      end
+      return if @condition && !@condition.call(flow, inputs)
+      @callable.call(flow, inputs)
     end
   end
 end

data/lib/business_flow/version.rb

@@ -1,3 +1,3 @@
 module BusinessFlow
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/lib/business_flow.rb

@@ -1,7 +1,9 @@
 require 'active_model'
 require 'business_flow/version'
 require 'business_flow/not_nil_validator'
+require 'business_flow/callable'
 require 'business_flow/step'
+require 'business_flow/dsl'
 require 'business_flow/base'
 
 module BusienssFlow

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: business_flow
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Alex Scarborough
@@ -114,6 +114,8 @@ files:
 - business_flow.gemspec
 - lib/business_flow.rb
 - lib/business_flow/base.rb
+- lib/business_flow/callable.rb
+- lib/business_flow/dsl.rb
 - lib/business_flow/not_nil_validator.rb
 - lib/business_flow/step.rb
 - lib/business_flow/version.rb