flow_object 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c4e0bf60b9bd1664f1e627b21f7ab1f9054abba
-  data.tar.gz: e8e9520592e1e9cc689c15be26d744580c774396
+  metadata.gz: b6e87c3678c7dfc6a5b2293cdde82114f9f5630d
+  data.tar.gz: c1cd29c871342cc8a434cf60026fabd2a5d23394
 SHA512:
-  metadata.gz: 8edbfe815c46426494dfb7343f9f9d553e4f5889e79af5d7f09b2cd7202677cef7106c2b1ea6c5eb4892b3be24b6c6422465080c61db58b59f695a5511a1d054
-  data.tar.gz: b57d9c98ce427889d725c8297eadde4c3c190512ed9a9c54b8e2bf0ba224eafb785373cbedb0de56ae62729c4b40006323abad8ac042658d11c455c9373f95b0
+  metadata.gz: bd56f181a60349d8dbfa029d5da3d6e2fd9746fbf1bbbb05b70745082af186ea2985c9928a659f9d9346ee8515f9b1e437bcd513c2845650da6b6c94d62cc2f0
+  data.tar.gz: bfa56fa807813ffe8dce4c3c8fd3d8e2d90587a9e14355fd9ea3d2b7a619fe16039145a87501748b96273145cff6f2186b4ae1fe04866406f489df5f9f7f5ef5

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    flow_object (0.2.0)
-      mature_factory (~> 0.2.13)
+    flow_object (0.2.1)
+      mature_factory (~> 0.2.14)
 
 GEM
   remote: https://rubygems.org/
@@ -10,7 +10,7 @@ GEM
     coderay (1.1.3)
     diff-lcs (1.4.4)
     dry-inflector (0.1.2)
-    mature_factory (0.2.13)
+    mature_factory (0.2.14)
       dry-inflector (~> 0.1)
       simple_facade (~> 0.2)
     method_source (1.0.0)

data/flow_object.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'mature_factory', '~> 0.2.13'
+  spec.add_dependency 'mature_factory', '~> 0.2.14'
 
   spec.add_development_dependency 'bundler', '~> 1.17'
   spec.add_development_dependency 'pry'

data/lib/flow_object.rb

@@ -1,4 +1,6 @@
 require 'mature_factory'
+require 'flow_object/callbacks'
+require 'flow_object/runner'
 require 'flow_object/base'
 require 'flow_object/version'
 

data/lib/flow_object/base.rb

@@ -3,18 +3,21 @@ module FlowObject
     include MatureFactory
     include MatureFactory::Features::Assemble
 
-    composed_of :stages, :inputs, :outputs
+    produces :stages, :inputs, :outputs
 
     class << self
+      extend Forwardable
       attr_reader :in, :out, :initial_values
+      def_delegators :callbacks, :after_input_initialize, :after_flow_initialize,
+        :after_input_check, :after_flow_check, :after_output_initialize
     end
 
-    attr_reader :output, :given
+    attr_reader :output
 
-    def initialize(given)
-      @given = given
+    def initialize(flow, step_name = :flow)
       @output = self.class.send(:__fo_wrap_output__)
-      self.class.after_output_initialize.call(@output) if self.class.after_output_initialize
+      self.class.link_with_delegation(@output, flow, step_name, true)
+      self.class.after_output_initialize.call(@output)
     end
 
     def on_failure(failed_step = nil)
@@ -37,6 +40,10 @@ module FlowObject
         subclass.after_output_initialize(&self.after_output_initialize)
       end
 
+      def callbacks
+        @callbacks ||= Callbacks.new
+      end
+
       def from(input)
         @in = input
         self
@@ -53,31 +60,16 @@ module FlowObject
       end
 
       def call(flow: :main)
-        __fo_resolve_cascade__(*__fo_process__(flow: flow))
+        __fo_resolve__(__fo_process__(flow: flow))
       end
 
       def flow(name = :main, &block)
         wrap(name, delegate: true, &block)
       end
 
-      def after_input_initialize(&block)
-        block_given? ? @after_input_initialize = block : @after_input_initialize
-      end
-
-      def after_flow_initialize(&block)
-        block_given? ? @after_flow_initialize = block : @after_flow_initialize
-      end
-
-      def after_input_check(&block)
-        block_given? ? @after_input_check = block : @after_input_check
-      end
-
-      def after_flow_check(&block)
-        block_given? ? @after_flow_check = block : @after_flow_check
-      end
-
-      def after_output_initialize(&block)
-        block_given? ? @after_output_initialize = block : @after_output_initialize
+      def link_with_delegation(target, object, accessor, delegate)
+        MatureFactory::Features::Assemble::AbstractBuilder
+          .link_with_delegation(target, object, accessor, delegate)
       end
 
       private
@@ -87,36 +79,14 @@ module FlowObject
       end
 
       def __fo_process__(flow: :main)
-        failure, step_name, group = false, self.in, :input
-        plan    = __fo_build_flow__(flow, step_name, group, __fo_wrap_input__)
-        cascade = __fo_run_flow__(plan,
-                    proc{|_,id| step_name = id.title},
-                    proc{ failure = true },
-                    after_input_initialize,
-                    after_flow_initialize)
-        after_flow_check.call(cascade.public_send(step_name)) if after_flow_check
-        [cascade, step_name, failure]
+        plan    = __fo_build_flow__(flow, self.in, :input, __fo_wrap_input__)
+        Runner.new(plan, callbacks, method(:halt_flow?)).execute_plan
       end
 
       def __fo_build_flow__(flow, step_name, group, object)
         public_send(:"build_#{flow}", title: step_name, group: group, object: object)
       end
 
-      def __fo_run_flow__(plan, on_step, on_failure, on_input, on_flow)
-        step_index = 0
-        plan.call do |object, id|
-          on_input.call(object) if on_input && id.group == :input
-          on_flow.call(object) if step_index == 1 && on_flow && id.group == :stage
-          on_step.call(object, id)
-          step_index += 1
-          if halt_flow?(object, id)
-            on_failure.call(object, id)
-            throw :halt
-          end
-          after_input_check.call(object) if after_input_check && id.group == :input
-        end
-      end
-
       def __fo_wrap_input__
         return initial_values if self.in.nil?
         input_class = public_send(:"#{self.in}_input_class")
@@ -134,33 +104,33 @@ module FlowObject
         public_send(:"new_#{self.out}_output_instance")
       end
 
-      def __fo_resolve_cascade__(cascade, step, failure)
-        new(cascade).tap do |flow|
-          if failure
-            __fo_notify_error__(flow, step)
+      def __fo_resolve__(runner)
+        new(runner.flow, runner.step_name).tap do |handler|
+          if runner.failure
+            __fo_notify_error__(handler, runner.step_name)
           else
-            __fo_notify_success__(flow)
+            __fo_notify_success__(handler)
           end
         end
       end
 
-      def __fo_notify_error__(flow, step)
-        if flow.output.respond_to?(:"on_#{step}_failure")
-          flow.output.public_send(:"on_#{step}_failure", flow.given)
-        elsif flow.output.respond_to?(:on_failure)
-          flow.output.on_failure(flow.given, step)
-        elsif flow.respond_to?(:"on_#{step}_failure")
-          flow.public_send(:"on_#{step}_failure")
+      def __fo_notify_error__(handler, step)
+        if handler.output.respond_to?(:"on_#{step}_failure")
+          handler.output.public_send(:"on_#{step}_failure")
+        elsif handler.output.respond_to?(:on_failure)
+          handler.output.on_failure(step)
+        elsif handler.respond_to?(:"on_#{step}_failure")
+          handler.public_send(:"on_#{step}_failure")
         else
-          flow.on_failure(step)
+          handler.on_failure(step)
         end
       end
 
-      def __fo_notify_success__(flow)
-        if flow.output.respond_to?(:on_success)
-          flow.output.on_success(flow.given)
+      def __fo_notify_success__(handler)
+        if handler.output.respond_to?(:on_success)
+          handler.output.on_success
         else
-          flow.on_success
+          handler.on_success
         end
       end
     end

data/lib/flow_object/callbacks.rb

@@ -0,0 +1,29 @@
+module FlowObject
+  class Callbacks
+    SUPPORTED = %i[
+      after_input_initialize
+      after_flow_initialize
+      after_input_check
+      after_flow_check
+      after_output_initialize
+    ].freeze
+
+    NOOP = proc {}.freeze
+
+    def initialize
+      @callbacks = Hash.new { |hash, key| hash[key] = NOOP }
+    end
+
+    def method_missing(name, *_attrs, &block)
+      if SUPPORTED.include?(name)
+        block_given? ? @callbacks[name] = block : @callbacks[name]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, *)
+      SUPPORTED.include?(name)
+    end
+  end
+end

data/lib/flow_object/runner.rb

@@ -0,0 +1,67 @@
+module FlowObject
+  class Runner
+    attr_reader :step_name, :failure, :flow
+
+    def initialize(plan, callbacks, halt_if_proc)
+      @plan = plan
+      @flow = flow
+      @failure = false
+      @step_name = nil
+      @callbacks = callbacks
+      @step_index = 0
+      @halt_if_proc = halt_if_proc
+    end
+
+    def execute_plan
+      @flow = call_flow_builder
+      after_flow_check(flow.public_send(@step_name))
+      self
+    end
+
+    private
+
+    def call_flow_builder
+      @plan.call do |object, id|
+        handle_step(object, id) { throw :halt }
+      end
+    end
+
+    def after_flow_check(object)
+      @callbacks.after_flow_check.call(object)
+    end
+
+    def after_input_initialize(object)
+      @callbacks.after_input_initialize.call(object)
+    end
+
+    def after_flow_initialize(object)
+      @callbacks.after_flow_initialize.call(object)
+    end
+
+    def after_input_check(object)
+      @callbacks.after_input_check.call(object)
+    end
+
+    def second_step?
+      @step_index == 1
+    end
+
+    def input_step?(id)
+      id.group == :input
+    end
+
+    def flow_step?(id)
+      id.group == :stage
+    end
+
+    def handle_step(object, id)
+      after_input_initialize(object) if input_step?(id)
+      after_flow_initialize(object) if second_step? && flow_step?(id)
+      @step_name = id.title
+      @step_index += 1
+      yield if @failure = @halt_if_proc.call(object, id)
+      after_input_check(object) if input_step?(id)
+    end
+
+  end
+end

data/lib/flow_object/version.rb

@@ -1,3 +1,3 @@
 module FlowObject
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.2.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flow_object
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Andrii Baran
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-05 00:00:00.000000000 Z
+date: 2021-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mature_factory
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.13
+        version: 0.2.14
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.13
+        version: 0.2.14
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -116,6 +116,8 @@ files:
 - flow_object.gemspec
 - lib/flow_object.rb
 - lib/flow_object/base.rb
+- lib/flow_object/callbacks.rb
+- lib/flow_object/runner.rb
 - lib/flow_object/version.rb
 homepage: https://github.com/andriy-baran/flow_object
 licenses: