flow_object 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6801b60384e39471a9fa4d760c6cb6d70965a118
-  data.tar.gz: c3425e3bff1f135e63e2a608591a5818cd0287e4
+  metadata.gz: b6e87c3678c7dfc6a5b2293cdde82114f9f5630d
+  data.tar.gz: c1cd29c871342cc8a434cf60026fabd2a5d23394
 SHA512:
-  metadata.gz: d0b6bd4523a523dfbec6a93df29bb0e42af0196b9e00b95f9370024fa99fb69217711eafa71fc2004c309bbe5d865982e53decf3a4120378e3fe4c9219d40e77
-  data.tar.gz: 3940bed1a962c7ce3d7c71a2a52744317c51707a48c412973a8378ea351ec138e95834fce82481fdd9b3e49c34322539df55227dacd2f9f9713f31cd795c22ca
+  metadata.gz: bd56f181a60349d8dbfa029d5da3d6e2fd9746fbf1bbbb05b70745082af186ea2985c9928a659f9d9346ee8515f9b1e437bcd513c2845650da6b6c94d62cc2f0
+  data.tar.gz: bfa56fa807813ffe8dce4c3c8fd3d8e2d90587a9e14355fd9ea3d2b7a619fe16039145a87501748b96273145cff6f2186b4ae1fe04866406f489df5f9f7f5ef5

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    flow_object (0.1.2)
-      mature_factory (~> 0.2.11)
+    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.11)
+    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.11'
+  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,109 +3,138 @@ module FlowObject
     include MatureFactory
     include MatureFactory::Features::Assemble
 
-    composed_of :stages, :inputs, :outputs
+    produces :stages, :inputs, :outputs
 
     class << self
-      attr_accessor :in, :out, :initial_values
+      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
-      @output = self.class.__fo_wrap_output__
+    def initialize(flow, step_name = :flow)
+      @output = self.class.send(:__fo_wrap_output__)
+      self.class.link_with_delegation(@output, flow, step_name, true)
+      self.class.after_output_initialize.call(@output)
     end
 
-    def inherited(subclass)
-      subclass.from(self.in)
-      subclass.to(self.out)
+    def on_failure(failed_step = nil)
+      # NOOP
     end
 
-    def self.from(input)
-      self.in = input
-      self
+    def on_success
+      # NOOP
     end
 
-    def self.to(output)
-      self.out = output
-      self
-    end
+    module ClassMethods
+      def inherited(subclass)
+        super
+        subclass.from(self.in)
+        subclass.to(self.out)
+        subclass.after_input_initialize(&self.after_input_initialize)
+        subclass.after_flow_initialize(&self.after_flow_initialize)
+        subclass.after_input_check(&self.after_input_check)
+        subclass.after_flow_check(&self.after_flow_check)
+        subclass.after_output_initialize(&self.after_output_initialize)
+      end
 
-    def self.__fo_wrap_input__
-      return initial_values if self.in.nil?
-      input_class = public_send(:"#{self.in}_input_class")
-      return initial_values if input_class.nil?
-      public_send(:"new_#{self.in}_input_instance", *initial_values)
-    end
+      def callbacks
+        @callbacks ||= Callbacks.new
+      end
 
-    def self.__fo_wrap_output__
-      # rescue NoMethodError => ex
-      # "You have not define output class. Please add `output :#{self.out}`"
-      return if self.out.nil?
-      return unless self.respond_to?(:"#{self.out}_output_class")
-      output_class = public_send(:"#{self.out}_output_class")
-      return if output_class.nil?
-      public_send(:"new_#{self.out}_output_instance")
-    end
+      def from(input)
+        @in = input
+        self
+      end
 
-    def self.accept(*values)
-      self.initial_values = values
-      self
-    end
+      def to(output)
+        @out = output
+        self
+      end
 
-    def self.__fo_resolve_cascade__(cascade, step, failure)
-      new(cascade).tap do |flow|
-        if failure
-          __fo_notify_error__(flow, step)
-        else
-          __fo_notify_success__(flow)
-        end
+      def accept(*values)
+        @initial_values = values
+        self
       end
-    end
 
-    def self.__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")
-      else
-        flow.on_failure(step)
+      def call(flow: :main)
+        __fo_resolve__(__fo_process__(flow: flow))
       end
-    end
 
-    def self.__fo_notify_success__(flow)
-      if flow.output.respond_to?(:on_success)
-        flow.output.on_success(flow.given)
-      else
-        flow.on_success
+      def flow(name = :main, &block)
+        wrap(name, delegate: true, &block)
       end
-    end
 
-    def self.call(flow: :main)
-      failure, previous_step, object = false, self.in, __fo_wrap_input__
-      plan    = public_send(:"build_#{flow}", previous_step, object)
-      cascade = plan.call do |object, id|
-                  previous_step = id.to_sym
-                  if !object.valid?
-                    failure = true
-                    throw :halt
-                  end
-                end
-      __fo_resolve_cascade__(cascade, previous_step, failure)
-    end
+      def link_with_delegation(target, object, accessor, delegate)
+        MatureFactory::Features::Assemble::AbstractBuilder
+          .link_with_delegation(target, object, accessor, delegate)
+      end
 
-    def self.flow(name = 'main', &block)
-      wrap(name, delegate: true, &block)
-    end
+      private
 
-    def on_failure(failed_step = nil)
-      # NOOP
-    end
+      def halt_flow?(object, id)
+        false
+      end
 
-    def on_success
-      # NOOP
+      def __fo_process__(flow: :main)
+        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_wrap_input__
+        return initial_values if self.in.nil?
+        input_class = public_send(:"#{self.in}_input_class")
+        return initial_values if input_class.nil?
+        public_send(:"new_#{self.in}_input_instance", *initial_values)
+      end
+
+      def __fo_wrap_output__
+        # rescue NoMethodError => ex
+        # "You have not define output class. Please add `output :#{self.out}`"
+        return if self.out.nil?
+        return unless self.respond_to?(:"#{self.out}_output_class")
+        output_class = public_send(:"#{self.out}_output_class")
+        return if output_class.nil?
+        public_send(:"new_#{self.out}_output_instance")
+      end
+
+      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__(handler)
+          end
+        end
+      end
+
+      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
+          handler.on_failure(step)
+        end
+      end
+
+      def __fo_notify_success__(handler)
+        if handler.output.respond_to?(:on_success)
+          handler.output.on_success
+        else
+          handler.on_success
+        end
+      end
     end
+
+    extend ClassMethods
   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.1.2'.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.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Andrii Baran
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-08 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.11
+        version: 0.2.14
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.11
+        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: