flow_object 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de4cd7409a15ea3447cf1427523fd3f8221c301d
-  data.tar.gz: bff8cba338ee8d0c5bfb7a3d83f853ea72e523ec
+  metadata.gz: 0c4e0bf60b9bd1664f1e627b21f7ab1f9054abba
+  data.tar.gz: e8e9520592e1e9cc689c15be26d744580c774396
 SHA512:
-  metadata.gz: 663072aed50253c0a99888f64572ba157509dc1fa52df45533e1fa9111ad85a5c684321d1dbb00e5ffbf779eb9aff88de868d76f6c3e08519a0787594e7e91ed
-  data.tar.gz: fa40fafa6f7be856feadc55d470159b6bde8c10df534cb1ed7e3cb4258a4a0c83902a370b0351ffe616dfeb1aa2ed91bba8c90fa800edfe6f60edadbcef7507b
+  metadata.gz: 8edbfe815c46426494dfb7343f9f9d553e4f5889e79af5d7f09b2cd7202677cef7106c2b1ea6c5eb4892b3be24b6c6422465080c61db58b59f695a5511a1d054
+  data.tar.gz: b57d9c98ce427889d725c8297eadde4c3c190512ed9a9c54b8e2bf0ba224eafb785373cbedb0de56ae62729c4b40006323abad8ac042658d11c455c9373f95b0

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    flow_object (0.1.1)
-      mature_factory (~> 0.2.10)
+    flow_object (0.2.0)
+      mature_factory (~> 0.2.13)
 
 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.10)
+    mature_factory (0.2.13)
       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.10'
+  spec.add_dependency 'mature_factory', '~> 0.2.13'
 
   spec.add_development_dependency 'bundler', '~> 1.17'
   spec.add_development_dependency 'pry'

data/lib/flow_object/base.rb

@@ -6,106 +6,165 @@ module FlowObject
     composed_of :stages, :inputs, :outputs
 
     class << self
-      attr_accessor :in, :out, :initial_values
+      attr_reader :in, :out, :initial_values
     end
 
     attr_reader :output, :given
 
     def initialize(given)
       @given = given
-      @output = self.class.__fo_wrap_output__
+      @output = self.class.send(:__fo_wrap_output__)
+      self.class.after_output_initialize.call(@output) if self.class.after_output_initialize
     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 from(input)
+        @in = input
+        self
+      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 to(output)
+        @out = output
+        self
+      end
 
-    def self.accept(*values)
-      self.initial_values = values
-      self
-    end
+      def accept(*values)
+        @initial_values = values
+        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)
+      def call(flow: :main)
+        __fo_resolve_cascade__(*__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
+      end
+
+      private
+
+      def halt_flow?(object, id)
+        false
+      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]
+      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
-    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 __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
-    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 __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
-    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 __fo_resolve_cascade__(cascade, step, failure)
+        new(cascade).tap do |flow|
+          if failure
+            __fo_notify_error__(flow, step)
+          else
+            __fo_notify_success__(flow)
+          end
+        end
+      end
 
-    def self.flow(name = 'main', &block)
-      wrap(name, delegate: true, &block)
-    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")
+        else
+          flow.on_failure(step)
+        end
+      end
 
-    def on_failure(failed_step = nil)
-      # NOOP
+      def __fo_notify_success__(flow)
+        if flow.output.respond_to?(:on_success)
+          flow.output.on_success(flow.given)
+        else
+          flow.on_success
+        end
+      end
     end
 
-    def on_success
-      # NOOP
-    end
+    extend ClassMethods
   end
 end

data/lib/flow_object/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flow_object
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrii Baran
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-08 00:00:00.000000000 Z
+date: 2021-03-05 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.10
+        version: 0.2.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.10
+        version: 0.2.13
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement