flow_object 0.1.4 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ffa8dd6903e47060958b6623ed8a8c6b96074130
-  data.tar.gz: 8d7772615968378288dc52f32a83eeb6bfb14db2
+SHA256:
+  metadata.gz: cdecba76df1dc39202b7abcd32a626738447dc90ae0fc1d7cae695ca2aae876e
+  data.tar.gz: a6e4763933194dd419837ab96b75b22bc1e61b31473f6ccee3be052f2ac98e49
 SHA512:
-  metadata.gz: 57215e81d52180ee8d28600be3ae0326834106e270e7c2fc00838fcd067ec5666ab21bc2696128a735e79d1a6ee1ea74dca46fa91de98d324b249bee8572d162
-  data.tar.gz: fc71295067cbc45c298aea3fa0452f6e431ca02ed1ccbc5f370064b8fffc302fee14e66ae7d1b2a0fd63eaca9bd23aaa5dc351b2e93abf6122ae8e3850bc9600
+  metadata.gz: 11fe476ab5eb07624fb4629f520ee88a75b2da05e4393b72907247f84b3a569af961b1bcef5be91a86f47f03f6ebe639d305e6d2a7d80735efe9096e7a82a926
+  data.tar.gz: a1ae38390b9c66abb5f2a1df631eb3391b16563e5c7db1bae885802a93c50d272fa0b7388b8a2896f41fa0d924fba2b891a20bc51482168f028067c469fb222f

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    flow_object (0.1.4)
-      mature_factory (~> 0.2.12)
+    flow_object (0.2.3)
+      mature_factory (~> 0.2.17)
 
 GEM
   remote: https://rubygems.org/
@@ -10,9 +10,8 @@ GEM
     coderay (1.1.3)
     diff-lcs (1.4.4)
     dry-inflector (0.1.2)
-    mature_factory (0.2.12)
+    mature_factory (0.2.17)
       dry-inflector (~> 0.1)
-      simple_facade (~> 0.2)
     method_source (1.0.0)
     pry (0.13.1)
       coderay (~> 1.1)
@@ -33,7 +32,6 @@ GEM
     rspec-support (3.9.3)
     rspec_vars_helper (0.1.0)
       rspec (>= 2.4)
-    simple_facade (0.2.1)
 
 PLATFORMS
   ruby

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.12'
+  spec.add_dependency 'mature_factory', '~> 0.2.17'
 
   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,110 +3,158 @@ 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 self.inherited(subclass)
-      super
-      subclass.from(self.in)
-      subclass.to(self.out)
+    def on_exception(exception = nil)
+      # NOOP
     end
 
-    def self.from(input)
-      self.in = input
-      self
+    def on_failure(failed_step = nil)
+      # NOOP
     end
 
-    def self.to(output)
-      self.out = output
-      self
+    def on_success
+      # NOOP
     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
+    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_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 callbacks
+        @callbacks ||= Callbacks.new
+      end
 
-    def self.accept(*values)
-      self.initial_values = values
-      self
-    end
+      def from(input)
+        @in = input
+        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 to(output)
+        @out = output
+        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 accept(*values)
+        @initial_values = values
+        self
       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 call(flow: :main)
+        __fo_resolve__(__fo_process__(flow: flow))
       end
-    end
 
-    def self.call(flow: :main)
-      failure, previous_step, object = false, :"#{self.in}_input", __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 flow(name = :main, &block)
+        wrap(name, delegate: true, on_exception: :halt, &block)
+      end
 
-    def self.flow(name = 'main', &block)
-      wrap(name, delegate: true, &block)
-    end
+      def link_with_delegation(target, object, accessor, delegate)
+        MatureFactory::Features::Assemble::AbstractBuilder
+          .link_with_delegation(target, object, accessor, delegate)
+      end
 
-    def on_failure(failed_step = nil)
-      # NOOP
-    end
+      private
 
-    def on_success
-      # NOOP
+      def halt_flow?(object, id)
+        false
+      end
+
+      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.public_send(runner.step_name), runner.step_name).tap do |handler|
+          if runner.flow.exceptional?
+            __fo_notify_exception__(handler, runner.flow.exception)
+          elsif runner.failure
+            __fo_notify_error__(handler, runner.step_name)
+          else
+            __fo_notify_success__(handler)
+          end
+        end
+      end
+
+      def __fo_notify_exception__(handler, exception)
+        step = exception.step_id.title
+        if handler.output.respond_to?(:"on_#{step}_exception")
+          handler.output.public_send(:"on_#{step}_exception", exception)
+        elsif handler.output.respond_to?(:on_exception)
+          handler.output.on_exception(exception)
+        elsif handler.respond_to?(:"on_#{step}_exception")
+          handler.public_send(:"on_#{step}_exception", exception)
+        else
+          handler.on_exception(exception)
+        end
+        __fo_notify_error__(handler, exception.step_id.title)
+      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.4'.freeze
+  VERSION = '0.2.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flow_object
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.3
 platform: ruby
 authors:
 - Andrii Baran
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-08 00:00:00.000000000 Z
+date: 2021-04-23 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.12
+        version: 0.2.17
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.12
+        version: 0.2.17
 - !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:
@@ -139,8 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.2.16
 signing_key: 
 specification_version: 4
 summary: Create objects for storing application flows