w_flow 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 542302c862a2fd32f275fdcc7ef118fe28d782df
-  data.tar.gz: cdffac74ea395e3869a48dd1d92e6f0381fba377
+  metadata.gz: 30c37c21823d83b687e0751155b7bb9a353233ff
+  data.tar.gz: 4cfb08e1e2966154536b8746e5d60e5db25208f8
 SHA512:
-  metadata.gz: b1f200b2a3de539ea4328ddc6be29cbf988b784b07c5ca5cd4c1b6bc2622d47613296a66c1d2279952be962b8002a6ae05db9fd0af9ad23b654ee57cbc1c2ece
-  data.tar.gz: ded155f14d82e06a0c437d9b6ef8f273c5b958b3921604302dd146588605e15178ebef0b22a7dda8cfab98007c408a26cd2fe75b601bf34edc00ef07ad8d39ef
+  metadata.gz: 337e619cfbffce4225809913df1a0843f87312c3125e4826e35612799625583278ec9467c7952b86e3f2724027e7d54b94e7dc366baa0bee2bd89f35e6f5ebd0
+  data.tar.gz: bd40ac136446646d0985ee0bc4f4ed92c37a56fc70c41380803275a2318d8aa85e14f38b363c963fde4754a421c18772b105ad8f235b0dee1365cfd23b04be92

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 rvm:
+  - 2.2.2
   - 2.2.1
   - 2.2.0
   - 2.1.1

data/README.md

@@ -20,7 +20,7 @@ inspiration for this gem.
 
 Tested with:
 
-  * ruby 2.2.1, 2.2.0, 2.1.1, 2.0.0
+  * ruby 2.2.2, 2.2.1, 2.2.0, 2.1.1, 2.0.0
 
 ## Installation
 
@@ -40,25 +40,66 @@ Or install it yourself as:
 
 ## Usage
 
-On its most simplest form a task (in WFlow called a Process) is something like this:
+Imagine a situation where we want to update an appointment, notify the user of that update,
+and publish it in google calendar if needed:
 
 ```ruby
-class SaveUser
+class Find
   include WFlow::Process
 
+  # helper for flow.data
+  data_reader :appointment_id
+  data_writer :appointment
+
+  # perform is the name of the method that will be invoked when calling 'run'
   def perform
-    # arguments passed to run will be under flow.data
-    flow.data.user.save
+    self.appointment = Appointment.find(appointment_id)
+
+    # the previous code is the same as:
+    # flow.data.appointment = Appointment.find(flow.data.appointment_id)
+  end
+end
+
+class UpdateAppointment
+  include WFlow::Process
+
+  execute Find, Update, NotifyUser
+
+  execute PublishInGoogleCalendar, if: :publish_in_google_calendar?
+
+protected
+
+  def publish_in_google_calendar?
+    flow.data.appointment.synch_in_google_calendar?
   end
 end
 
-# run process, it will return a report object
-report = SaveUser.run(user: current_user)
+# imagining that we have the id of the appointment to be updated and the new attributes for the appointment
+report = UpdateAppointment.run(appointment_id: appointment_id, attributes: new_attributes)
 
-report.data.success?
+# ask if workflow was a success
+report.success?
 ```
 
+So what's going on here? We first declare a class and included the module WFlow::Process, so that
+we can compose the workflow for this process:
+
+```ruby
+class UpdateAppointment
+  include WFlow::Process
+```
+
+Now we can start composing. We compose by reusing other processes like this:
+
+```ruby
+  # this indicates that it will first Find, Update next and NotifyUser last
+  execute Find, Update, NotifyUser
+
+  # execute this process, only if method returns true
+  execute PublishInGoogleCalendar, if: :publish_in_google_calendar?
+```
 
+TODO: more documentation
 
 ## Contributing
 

data/lib/w_flow/flow.rb

@@ -1,18 +1,42 @@
 module WFlow
   class Flow
-    extend Forwardable
-    def_delegator  :@supervisor, :add_to_finalizables,  :finalizable!
-    def_delegator  :@supervisor, :add_to_rollbackables, :rollbackable!
-    def_delegators :@supervisor,
-                   :skip!,
-                   :stop!,
-                   :failure!,
-                   :data,
-                   :success?,
-                   :failure?
-
-    def initialize(supervisor)
-      @supervisor = supervisor
+
+    attr_reader :data
+
+    def initialize(params)
+      @data        = Data.new(params)
+      @failure     = false
+      @failure_log = []
     end
+
+    def skip!
+      Supervisor.signal_skip!
+    end
+
+    def stop!
+      Supervisor.signal_stop!
+    end
+
+    def failure!(message = nil)
+      Supervisor.signal_failure!(message)
+    end
+
+    def success?
+      !failure?
+    end
+
+    def failure?
+      @failure
+    end
+
+    def log_failure(message)
+      @failure_log << message unless message.nil?
+    end
+
+    def set_failure_and_log(message)
+      @failure = true
+      log_failure(message)
+    end
+
   end
 end

data/lib/w_flow/flow_report.rb

@@ -0,0 +1,12 @@
+module WFlow
+  class FlowReport
+
+    extend Forwardable
+    def_delegators :@flow, :data, :success?, :failure?, :failure_log
+
+    def initialize(flow)
+      @flow = flow
+    end
+
+  end
+end

data/lib/w_flow/node.rb

@@ -1,14 +1,118 @@
 module WFlow
   class Node
-    def initialize(components, options)
-      @components = components
-      @options    = options
+
+    class << self
+
+      attr_reader :components,
+                  :if_condition,
+                  :unless_condition,
+                  :stop_condition,
+                  :failure_condition,
+                  :around_handler
+
+      def build(components, options)
+        Class.new(self) do |klass|
+          @components        = components
+          @if_condition      = options[:if]
+          @unless_condition  = options[:unless]
+          @stop_condition    = options[:stop]
+          @failure_condition = options[:failure]
+          @around_handler    = options[:around]
+        end
+      end
+
+      def execute?(process)
+        (if_condition.nil?     || process_eval(process, if_condition)) &&
+        (unless_condition.nil? || !process_eval(process, unless_condition))
+      end
+
+      def cancel_stop?(process)
+        !stop_condition.nil? && !process_eval(process, stop_condition)
+      end
+
+      def cancel_failure?(process)
+        !failure_condition.nil? && !process_eval(process, failure_condition)
+      end
+
+      def process_eval(process, object, *args)
+        if object.is_a?(String) || object.is_a?(Symbol)
+          process.send(object.to_s, *args)
+        elsif object.is_a?(Proc)
+          process.instance_exec(*args, &object)
+        else
+          raise InvalidArguments, UNKNOWN_EXPRESSION
+        end
+      end
+
+    end
+
+    def initialize(owner_process)
+      @owner_process     = owner_process
+      @components        = self.class.components
+      @around_handler    = self.class.around_handler
+    end
+
+    def run(flow)
+      @flow             = flow
+      @execution_chains = []
+
+      if @around_handler.nil?
+        execute_components
+      else
+        @around_handler.call(method(:execute_components))
+      end
+    end
+
+    def finalize
+      @execution_chains.reverse_each do |execution_chain|
+        execution_chain.reverse_each(&:finalize)
+      end
     end
 
-    def execute(supervisor, process)
-      node_process = NodeProcess.new(@components, @options)
+    def rollback
+      @execution_chains.reverse_each do |execution_chain|
+        execution_chain.reverse_each(&:rollback)
+      end
+    end
+
+  protected
+
+    def execute_components(options = {})
+      execution_chain = []
 
-      node_process.execute(supervisor, process)
+      @components.each do |component|
+        report = Supervisor.supervise do
+          if component.is_a?(Class) && component <= Process
+            process_worker = ProcessWorker.new(component)
+
+            execution_chain << process_worker
+
+            process_worker.run_as_child(@flow)
+          else
+            self.class.process_eval(@owner_process, component)
+          end
+        end
+
+        if report.failed?
+          execution_chain.reverse_each(&:rollback)
+          execution_chain.reverse_each(&:finalize)
+
+          if options[:failure].nil? || options[:failure].call
+            @flow.log_failure(report.message)
+            return
+          else
+            Supervisor.resignal!(report)
+          end
+        else
+          if report.stopped? && (options[:stop].nil? || !options[:stop].call)
+            @execution_chains << execution_chain
+            Supervisor.resignal!(report)
+          end
+        end
+      end
+
+      @execution_chains << execution_chain
     end
+
   end
 end

data/lib/w_flow/process.rb

@@ -1,27 +1,14 @@
 module WFlow
   module Process
+
     def self.included(klass)
       klass.extend(ClassMethods)
     end
 
     attr_reader :flow
 
-    def wflow_execute(supervisor)
-      supervisor.supervise(self) do |flow|
-        @flow = flow
-
-        setup
-
-        flow.finalizable!
-
-        self.class.wflow_nodes.each do |node|
-          node.execute(supervisor, self)
-        end
-
-        perform
-
-        flow.rollbackable!
-      end
+    def initialize(flow)
+      @flow = flow
     end
 
     def setup;    end
@@ -62,7 +49,7 @@ module WFlow
       def execute(*components, &block)
         options = components.last.is_a?(Hash) ? components.pop : {}
         components << block if block_given?
-        wflow_nodes << Node.new(components, options)
+        wflow_nodes << Node.build(components, options)
       end
 
       def run(params = {})
@@ -70,12 +57,19 @@ module WFlow
           raise InvalidArgument, INVALID_RUN_PARAMS
         end
 
-        supervisor = Supervisor.new(params)
+        flow = Flow.new(params)
+
+        ProcessWorker.new(self).run_as_main(flow)
 
-        new.wflow_execute(supervisor)
+        FlowReport.new(flow)
+      rescue ::StandardError => e
+        raise if e.is_a?(StandardError) || !Configuration.supress_errors?
 
-        supervisor.report
+        set_failure_and_log(message: e.message, backtrace: e.backtrace)
+
+        FlowReport.new(flow)
       end
+
     end
   end
 end

data/lib/w_flow/process_worker.rb

@@ -0,0 +1,86 @@
+module WFlow
+  class ProcessWorker
+    def initialize(process_class)
+      @process_class = process_class
+    end
+
+    def run_as_main(flow)
+      setup(flow)
+
+      process_report = Supervisor.supervise { run }
+
+      report = Supervisor.supervise do
+        if process_report.failed?
+          flow.set_failure_and_log(process_report.message)
+          rollback
+        end
+
+        finalize
+      end
+
+      raise InvalidOperation, INVALID_OPERATION unless report.success?
+    end
+
+    def run_as_child(flow)
+      setup(flow)
+
+      run
+    end
+
+    def finalize
+      @nodes.reverse_each(&:finalize)
+
+      @process.finalize if @setup_completed
+    end
+
+    def rollback
+      @nodes.reverse_each(&:rollback)
+
+      @process.rollback if @perform_completed
+    end
+
+  protected
+
+    def run
+      @process.setup
+      @setup_completed = true
+
+      @process_class.wflow_nodes.each do |node_class|
+        next unless node_class.execute?(@process)
+
+        node = node_class.new(@process)
+
+        report = Supervisor.supervise { node.run(@flow) }
+
+        if report.failed?
+          node.rollback
+          node.finalize
+
+          if node_class.cancel_failure?(@process)
+            @flow.log_failure(report.message)
+          else
+            Supervisor.resignal!(report)
+          end
+        else
+          @nodes << node
+
+          if report.stopped? && !node_class.cancel_stop?(@process)
+            Supervisor.resignal!(report)
+          end
+        end
+      end
+
+      @process.perform
+      @perform_completed = true
+    end
+
+    def setup(flow)
+      @flow    = flow
+      @process = @process_class.new(flow)
+      @nodes   = []
+      @setup_completed   = false
+      @perform_completed = false
+    end
+
+  end
+end

data/lib/w_flow/supervisor.rb

@@ -1,118 +1,37 @@
 module WFlow
-  class Supervisor
-    attr_reader :data, :message
+  module Supervisor
 
-    def initialize(params)
-      @data    = Data.new(params)
-      @flow    = Flow.new(self)
-      @failure = false
-      @message = false
-      @backlog = []
-      @finalizables  = []
-      @rollbackables = []
-    end
-
-    def supervise(process, &block)
-      @backlog << @current_process unless @current_process.nil?
-      @current_process = process
-
-      if parent_process?
-        supervise_parent_process(&block)
-        finalize_processes
-      else
-        supervise_child_process(&block)
-      end
-    ensure
-      @current_process = @backlog.pop
-    end
-
-    def add_to_finalizables
-      @finalizables.unshift(@current_process)
-    end
-
-    def add_to_rollbackables
-      @rollbackables << @current_process
-    end
-
-    def skip!
-      throw :wflow_interrupt, :wflow_skip
-    end
-
-    def stop!
-      throw :wflow_interrupt, :wflow_stop
-    end
-
-    def failure!(message = nil)
-      raise FlowFailure, Marshal.dump(message)
-    end
+    @succeeded = SupervisorReport.new
+    @skipped   = SupervisorReport.new(:skip)
+    @stopped   = SupervisorReport.new(:stop)
 
-    def success?
-      !failure?
-    end
-
-    def failure?
-      @failure
-    end
-
-    def report
-      Report.new(self)
-    end
-
-  protected
+    class << self
 
-    def parent_process?
-      !@current_process.nil? && @backlog.empty?
-    end
+      def supervise
+        catch :wflow_interrupt do
+          yield
 
-    def supervise_parent_process
-      catch :wflow_interrupt do
-        yield @flow
+          @succeeded
+        end
       end
-    rescue FlowFailure => e
-      set_failure(true, Marshal.load(e.message))
-    rescue ::StandardError => e
-      raise unless Configuration.supress_errors?
 
-      set_failure(true, message: e.message, backtrace: e.backtrace)
-    end
-
-    def supervise_child_process
-      interrupt = catch :wflow_interrupt do
-        yield @flow
+      def signal_skip!
+        throw :wflow_interrupt, @skipped
       end
 
-      stop! if interrupt == :wflow_stop && rethrow_stop?
-    rescue FlowFailure => e
-      if reraise_error?
-        set_failure(true, Marshal.load(e.message))
-        raise
-      else
-        set_failure(false, Marshal.load(e.message))
+      def signal_stop!
+        throw :wflow_interrupt, @stopped
       end
-    end
 
-    def finalize_processes
-      interrupt = catch :wflow_interrupt do
-        @rollbackables.each(&:rollback) if failure?
-        @finalizables.each(&:finalize)
+      def signal_failure!(message = nil)
+        throw :wflow_interrupt, SupervisorReport.new(:failure, message)
       end
 
-      raise FlowFailure if [:wflow_stop, :wflow_skip].include?(interrupt)
-    rescue FlowFailure
-      raise InvalidOperation, INVALID_OPERATION
-    end
-
-    def set_failure(state, message)
-      @failure = state
-      @message << message unless message.nil?
-    end
+      def resignal!(report)
+        throw :wflow_interrupt, report
+      end
 
-    def rethrow_stop?
-      !@current_process.is_a?(NodeProcess) || !@current_process.cancel_stop?
     end
 
-    def reraise_error?
-      !@current_process.is_a?(NodeProcess) || !@current_process.cancel_failure?
-    end
   end
 end

data/lib/w_flow/supervisor_report.rb

@@ -0,0 +1,28 @@
+module WFlow
+  class SupervisorReport
+
+    attr_reader :key, :message
+
+    def initialize(key = :success, message = nil)
+      @key     = key
+      @message = message
+    end
+
+    def success?
+      @key == :success
+    end
+
+    def skipped?
+      @key == :skip
+    end
+
+    def stopped?
+      @key == :stop
+    end
+
+    def failed?
+      @key == :failure
+    end
+
+  end
+end

data/lib/w_flow/version.rb

@@ -1,3 +1,3 @@
 module WFlow
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/lib/w_flow.rb

@@ -1,14 +1,16 @@
 require "w_flow/version"
 require "w_flow/configuration"
 require "w_flow/data"
-require "w_flow/report"
+require "w_flow/supervisor_report"
 require "w_flow/supervisor"
 require "w_flow/flow"
-require "w_flow/node_process"
+require "w_flow/flow_report"
 require "w_flow/node"
 require "w_flow/process"
+require "w_flow/process_worker"
 
 module WFlow
+
   # WFlow errors
   class StandardError < ::StandardError; end
 
@@ -20,4 +22,5 @@ module WFlow
   INVALID_RUN_PARAMS = "run must be invoked without arguments or an Hash"
   UNKNOWN_EXPRESSION = "can't evaluate expression"
   INVALID_OPERATION  = "skip!, stop! or failure! can't be invoked during finalize/rollback"
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: w_flow
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - junhanamaki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-26 00:00:00.000000000 Z
+date: 2015-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -98,11 +98,12 @@ files:
 - lib/w_flow/configuration.rb
 - lib/w_flow/data.rb
 - lib/w_flow/flow.rb
+- lib/w_flow/flow_report.rb
 - lib/w_flow/node.rb
-- lib/w_flow/node_process.rb
 - lib/w_flow/process.rb
-- lib/w_flow/report.rb
+- lib/w_flow/process_worker.rb
 - lib/w_flow/supervisor.rb
+- lib/w_flow/supervisor_report.rb
 - lib/w_flow/version.rb
 - w_flow.gemspec
 homepage: https://github.com/junhanamaki/w_flow
@@ -125,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: A workflow composer based on Single Responsability Principle to help organize

data/lib/w_flow/node_process.rb

@@ -1,58 +0,0 @@
-module WFlow
-  class NodeProcess
-    def initialize(components, options)
-      @components     = components
-      @around_option  = options[:around]
-      @if_option      = options[:if]
-      @unless_option  = options[:unless]
-      @stop_option    = options[:stop]
-      @failure_option = options[:failure]
-    end
-
-    def execute(supervisor, process)
-      @supervisor = supervisor
-      @process    = process
-
-      if execute_node?
-        supervisor.supervise(self) do
-          if @around_option.nil?
-            execute_components
-          else
-            process_eval(@around_option, method(:execute_components))
-          end
-        end
-      end
-    end
-
-    def cancel_stop?
-      !@stop_option.nil? && !process_eval(@stop_option)
-    end
-
-    def cancel_failure?
-      !@failure_option.nil? && !process_eval(@failure_option)
-    end
-
-  protected
-
-    def execute_node?
-      (@if_option.nil?     || process_eval(@if_option)) &&
-      (@unless_option.nil? || !process_eval(@unless_option))
-    end
-
-    def execute_components
-      @components.each { |component| process_eval(component) }
-    end
-
-    def process_eval(object, *args)
-      if object.is_a?(String) || object.is_a?(Symbol)
-        @process.send(object.to_s, *args)
-      elsif object.is_a?(Proc)
-        @process.instance_exec(*args, &object)
-      elsif object <= Process
-        object.new.wflow_execute(@supervisor, *args)
-      else
-        raise InvalidArguments, UNKNOWN_EXPRESSION
-      end
-    end
-  end
-end

data/lib/w_flow/report.rb

@@ -1,10 +0,0 @@
-module WFlow
-  class Report
-    extend Forwardable
-    def_delegators :@supervisor, :data, :message, :success?, :failure?
-
-    def initialize(supervisor)
-      @supervisor = supervisor
-    end
-  end
-end