w_flow 0.1.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea684020b144fcbcb694e2c1df80e7d9244cfd35
-  data.tar.gz: abee114f93512251d671e246fd8a8fdc34dce351
+  metadata.gz: 542302c862a2fd32f275fdcc7ef118fe28d782df
+  data.tar.gz: cdffac74ea395e3869a48dd1d92e6f0381fba377
 SHA512:
-  metadata.gz: 8545ebdf9cd7f084c2a377229807575331e591e4ca0180505657b10f1e6568c20dd9416768f4d46456c33909220b3a43d3573051f91c3f827d8c5ea399dbd9d3
-  data.tar.gz: 0de1290ab22238663fe1ccc87778ede829b15bb6903dca93218ed01e08caac161f8b579d80fc8f18b1943be5b458e524139fbc4d160e547e633cb4c4e62339ec
+  metadata.gz: b1f200b2a3de539ea4328ddc6be29cbf988b784b07c5ca5cd4c1b6bc2622d47613296a66c1d2279952be962b8002a6ae05db9fd0af9ad23b654ee57cbc1c2ece
+  data.tar.gz: ded155f14d82e06a0c437d9b6ef8f273c5b958b3921604302dd146588605e15178ebef0b22a7dda8cfab98007c408a26cd2fe75b601bf34edc00ef07ad8d39ef

data/.gitignore

@@ -13,3 +13,5 @@
 .ruby-version
 
 *.gem
+
+dump.rdb

data/.travis.yml

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

data/README.md

@@ -1,16 +1,26 @@
 # WFlow
 
-[![Gem Version](https://badge.fury.io/rb/rekiq.svg)](http://badge.fury.io/rb/rekiq)
-[![Build Status](https://travis-ci.org/junhanamaki/rekiq.svg?branch=master)](https://travis-ci.org/junhanamaki/rekiq)
-[![Code Climate](https://codeclimate.com/github/junhanamaki/rekiq.png)](https://codeclimate.com/github/junhanamaki/rekiq)
-[![Test Coverage](https://codeclimate.com/github/junhanamaki/rekiq/coverage.png)](https://codeclimate.com/github/junhanamaki/rekiq)
-[![Dependency Status](https://gemnasium.com/junhanamaki/rekiq.svg)](https://gemnasium.com/junhanamaki/rekiq)
+[![Gem Version](https://badge.fury.io/rb/w_flow.svg)](http://badge.fury.io/rb/w_flow)
+[![Build Status](https://travis-ci.org/junhanamaki/w_flow.svg?branch=master)](https://travis-ci.org/junhanamaki/w_flow)
+[![Code Climate](https://codeclimate.com/github/junhanamaki/w_flow.png)](https://codeclimate.com/github/junhanamaki/w_flow)
+[![Test Coverage](https://codeclimate.com/github/junhanamaki/w_flow/coverage.png)](https://codeclimate.com/github/junhanamaki/w_flow)
+[![Dependency Status](https://gemnasium.com/junhanamaki/w_flow.svg)](https://gemnasium.com/junhanamaki/w_flow)
+
+WFlow aims to help on designing workflows based on [Single
+Responsibility Principle](http://en.wikipedia.org/wiki/Single_responsibility_principle). WFlow
+proposes to achieve this by providing tools to build classes where each are responsible for a task
+and one task only, and by providing tools to compose these classes.
+
+Word of appreciation for [usecasing](https://github.com/tdantas/usecasing),
+[interactor](https://github.com/collectiveidea/interactor) and
+[rest_my_case](https://github.com/goncalvesjoao/rest_my_case) that served as
+inspiration for this gem.
 
 ## Dependencies
 
 Tested with:
 
-  * ruby 2.2.0, 2.1.1, 2.0.0
+  * ruby 2.2.1, 2.2.0, 2.1.1, 2.0.0
 
 ## Installation
 
@@ -30,11 +40,29 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+On its most simplest form a task (in WFlow called a Process) is something like this:
+
+```ruby
+class SaveUser
+  include WFlow::Process
+
+  def perform
+    # arguments passed to run will be under flow.data
+    flow.data.user.save
+  end
+end
+
+# run process, it will return a report object
+report = SaveUser.run(user: current_user)
+
+report.data.success?
+```
+
+
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/w_flow/fork )
+1. Fork it ( https://github.com/junhanamaki/w_flow/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/w_flow/configuration.rb

@@ -0,0 +1,29 @@
+module WFlow
+  class Configuration
+    attr_reader :supress_errors
+
+    class << self
+      def config
+        yield configuration
+      end
+
+      def supress_errors?
+        configuration.supress_errors
+      end
+
+      def configuration
+        @configuration ||= new
+      end
+
+      def reset_configuration
+        @configuration = new
+      end
+    end
+
+  protected
+
+    def initialize
+      @supress_errors = false
+    end
+  end
+end

data/lib/w_flow/flow.rb

@@ -1,32 +1,18 @@
 module WFlow
   class Flow
-    attr_reader :data, :failure_message
+    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(data)
-      @data    = Data.new(data)
-      @failure = false
-      @failure_message = nil
-    end
-
-    def success?
-      !failure?
-    end
-
-    def failure?
-      @failure
-    end
-
-    def failure!(message = nil)
-      @failure = true
-      @failure_message = message
-    end
-
-    def stop!
-      throw :stop
-    end
-
-    def skip!
-      throw :skip
+    def initialize(supervisor)
+      @supervisor = supervisor
     end
   end
 end

data/lib/w_flow/node.rb

@@ -0,0 +1,14 @@
+module WFlow
+  class Node
+    def initialize(components, options)
+      @components = components
+      @options    = options
+    end
+
+    def execute(supervisor, process)
+      node_process = NodeProcess.new(@components, @options)
+
+      node_process.execute(supervisor, process)
+    end
+  end
+end

data/lib/w_flow/node_process.rb

@@ -0,0 +1,58 @@
+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/process.rb

@@ -1,58 +1,80 @@
 module WFlow
   module Process
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
     attr_reader :flow
 
-    def initialize(flow)
-      @flow = 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
     end
 
     def setup;    end
     def perform;  end
     def rollback; end
-    def final;    end
-
-    def self.included(klass)
-      klass.extend(ClassMethods)
+    def finalize; end
 
-      klass.instance_variable_set('@process_nodes', [])
-    end
+  protected
 
     module ClassMethods
+      attr_reader :wflow_nodes
+
+      def self.extended(klass)
+        klass.instance_variable_set('@wflow_nodes', [])
+      end
+
+      def inherited(klass)
+        klass.instance_variable_set('@wflow_nodes', wflow_nodes.dup)
+      end
+
       def data_accessor(*keys)
-        data_writer(keys)
-        data_reader(keys)
+        data_writer(*keys)
+        data_reader(*keys)
       end
 
       def data_writer(*keys)
         keys.each do |key|
-          define_method "#{key}=" do |val|
-            flow.data[key] = val
-          end
+          define_method("#{key}=") { |val| flow.data.send("#{key}=", val) }
         end
       end
 
       def data_reader(*keys)
         keys.each do |key|
-          define_method key do
-            flow.data[key]
-          end
+          define_method(key) { flow.data.send(key.to_s) }
         end
       end
 
-      def execute(*args)
-        options = args.pop if args.last.is_a?(Hash)
-        args << Proc.new if block_given?
-
-        @process_nodes << ProcessNode.new(args, options)
+      def execute(*components, &block)
+        options = components.last.is_a?(Hash) ? components.pop : {}
+        components << block if block_given?
+        wflow_nodes << Node.new(components, options)
       end
 
       def run(params = {})
-        unless params.is_a?(Hash)
-          raise InvalidArgument, 'run must be invoked with an Hash'
+        unless params.nil? || params.is_a?(Hash)
+          raise InvalidArgument, INVALID_RUN_PARAMS
         end
-      end
 
-      def run_as_dependency(flow)
+        supervisor = Supervisor.new(params)
+
+        new.wflow_execute(supervisor)
+
+        supervisor.report
       end
     end
   end

data/lib/w_flow/report.rb

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

data/lib/w_flow/supervisor.rb

@@ -0,0 +1,118 @@
+module WFlow
+  class Supervisor
+    attr_reader :data, :message
+
+    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
+
+    def success?
+      !failure?
+    end
+
+    def failure?
+      @failure
+    end
+
+    def report
+      Report.new(self)
+    end
+
+  protected
+
+    def parent_process?
+      !@current_process.nil? && @backlog.empty?
+    end
+
+    def supervise_parent_process
+      catch :wflow_interrupt do
+        yield @flow
+      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
+      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))
+      end
+    end
+
+    def finalize_processes
+      interrupt = catch :wflow_interrupt do
+        @rollbackables.each(&:rollback) if failure?
+        @finalizables.each(&:finalize)
+      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 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/version.rb

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

data/lib/w_flow.rb

@@ -1,9 +1,23 @@
 require "w_flow/version"
-require 'w_flow/exceptions'
-require 'w_flow/data'
-require 'w_flow/flow'
-require 'w_flow/process_node'
-require 'w_flow/process'
+require "w_flow/configuration"
+require "w_flow/data"
+require "w_flow/report"
+require "w_flow/supervisor"
+require "w_flow/flow"
+require "w_flow/node_process"
+require "w_flow/node"
+require "w_flow/process"
 
 module WFlow
+  # WFlow errors
+  class StandardError < ::StandardError; end
+
+  class InvalidArguments < StandardError; end
+  class FlowFailure      < StandardError; end
+  class InvalidOperation < StandardError; end
+
+  # WFlow message constants
+  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

data/w_flow.gemspec

@@ -12,13 +12,15 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{A workflow composer based on Single Responsability Principle to help organize projects}
   spec.description   = %q{WFlow is a workflow composer that helps in organizing projects by splitting logic into reusable modules (processes)}
   spec.homepage      = "https://github.com/junhanamaki/w_flow"
-  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 2.0.0'
+
   spec.add_development_dependency "bundler",   "~> 1.9"
   spec.add_development_dependency "rspec",     '~> 3.2'
   spec.add_development_dependency "pry",       '~> 0.10'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: w_flow
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.10.0
 platform: ruby
 authors:
 - junhanamaki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-10 00:00:00.000000000 Z
+date: 2015-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,11 +95,14 @@ files:
 - README.md
 - Rakefile
 - lib/w_flow.rb
+- lib/w_flow/configuration.rb
 - lib/w_flow/data.rb
-- lib/w_flow/exceptions.rb
 - lib/w_flow/flow.rb
+- lib/w_flow/node.rb
+- lib/w_flow/node_process.rb
 - lib/w_flow/process.rb
-- lib/w_flow/process_node.rb
+- lib/w_flow/report.rb
+- lib/w_flow/supervisor.rb
 - lib/w_flow/version.rb
 - w_flow.gemspec
 homepage: https://github.com/junhanamaki/w_flow
@@ -114,7 +117,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -122,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A workflow composer based on Single Responsability Principle to help organize

data/lib/w_flow/exceptions.rb

@@ -1,7 +0,0 @@
-module WFlow
-  class StandardError < ::StandardError; end
-
-  class InvalidArgument < StandardError; end
-  class FlowFailure < StandardError; end
-  class UnknownTask < StandardError; end
-end

data/lib/w_flow/process_node.rb

@@ -1,45 +0,0 @@
-module WFlow
-  class ProcessNode
-    def initialize(tasks, options)
-      @tasks   = tasks
-      @options = options
-    end
-
-    def execute(owner_process)
-      return unless execute_node?(owner_process)
-
-      @tasks.each do |task|
-        if task.is_a?(String) || task.is_a?(Symbol)
-          owner_process.instance_eval(task.to_s)
-        elsif task.is_a?(Proc)
-          owner_process.instance_eval(&task)
-        elsif task.is_a?(Process)
-          task.run(owner_process.flow)
-        else
-          raise UnknownTask, "don't know how to execute task #{task}"
-        end
-      end
-    end
-
-  protected
-
-    def execute_node?(owner_process)
-      if_condition_allows_execution?(owner_process) &&
-      unless_condition_allows_execution?(owner_process)
-    end
-
-    def if_condition_allows_execution?(owner_process)
-      @options[:if].nil? || eval_condition(@options[:if], owner_process)
-    end
-
-    def unless_condition_allows_execution?(owner_process)
-      @options[:unless].nil? || !eval_condition(@options[:unless], owner_process)
-    end
-
-    def eval_condition?(condition, owner_process)
-      ((condition.is_a?(String) || condition.is_a?(Symbol)) &&
-       owner_process.instance_eval(condition.to_s)) ||
-      (condition.is_a?(Proc) && owner_process.instance_eval(&condition))
-    end
-  end
-end