flow_object 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ffa8dd6903e47060958b6623ed8a8c6b96074130
-  data.tar.gz: 8d7772615968378288dc52f32a83eeb6bfb14db2
+  metadata.gz: fcfa33b52598259445a736e3e46b7eedd2012bc5
+  data.tar.gz: 0f4b07df841d4e15bc50ecddd09e1ea15e652f3d
 SHA512:
-  metadata.gz: 57215e81d52180ee8d28600be3ae0326834106e270e7c2fc00838fcd067ec5666ab21bc2696128a735e79d1a6ee1ea74dca46fa91de98d324b249bee8572d162
-  data.tar.gz: fc71295067cbc45c298aea3fa0452f6e431ca02ed1ccbc5f370064b8fffc302fee14e66ae7d1b2a0fd63eaca9bd23aaa5dc351b2e93abf6122ae8e3850bc9600
+  metadata.gz: 84817e3b8c4f23f6958bdaf77cb197e37664e4c95b70df31713b012e4edb327d9407ab2856d76b61701829685ea45a7b3392653d99385d05fc47df3cadbd158e
+  data.tar.gz: bdbe490405595d43a22fd33b55a97f697c4ede5abc6777ffb044f68884ae1d702dd05c9118a1add981c31a0e161bb1758f6497215ce2832bbde275c3997a1d53

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    flow_object (0.1.4)
+    flow_object (0.1.5)
       mature_factory (~> 0.2.12)
 
 GEM

data/lib/flow_object/base.rb

@@ -13,100 +13,124 @@ module FlowObject
 
     def initialize(given)
       @given = given
-      @output = self.class.__fo_wrap_output__
+      @output = self.class.send(:__fo_wrap_output__)
     end
 
-    def self.inherited(subclass)
-      super
-      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)
+      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)
+        self.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)
+        self.out = output
+        self
+      end
 
-    def self.accept(*values)
-      self.initial_values = values
-      self
-    end
+      def accept(*values)
+        self.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
+
+      private
+
+      def halt_flow?(object, id)
+        !object.valid?
+      end
+
+      def __fo_process__(flow: :main)
+        failure, step_name = false, self.in
+        plan    = __fo_build_flow__(flow, step_name, __fo_wrap_input__)
+        cascade = __fo_run_flow__(plan,
+                    proc{|_,id| step_name = id.title},
+                    proc{ failure = true })
+        [cascade, step_name, failure]
+      end
+
+      def __fo_build_flow__(flow, step_name, object)
+        public_send(:"build_#{flow}", step_name, object)
+      end
+
+      def __fo_run_flow__(plan, on_step, on_failure)
+        plan.call do |object, id|
+          on_step.call(object, id)
+          if halt_flow?(object, id)
+            on_failure.call(object, id)
+            throw :halt
+          end
         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}_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 __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.4'.freeze
+  VERSION = '0.1.5'.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.1.5
 platform: ruby
 authors:
 - Andrii Baran
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-08 00:00:00.000000000 Z
+date: 2021-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mature_factory