ruote 0.9.20 → 2.1.1

data/.gitignore

@@ -0,0 +1,3 @@
+.yardoc
+ruote_rdoc/
+work/

data/CHANGELOG.txt

@@ -0,0 +1,8 @@
+
+= ruote (OpenWFEru) - CHANGELOG.txt
+
+== ruote - 2.0.0    not yet released
+
+== OpenWFEru - 0.9.2      released 2007/01/26
+== openwfe-ruby - 1.7.0   released 2006-05-08
+

data/CREDITS.txt

@@ -0,0 +1,65 @@
+
+CREDITS
+=======
+
+Ruote (OpenWFEru) is an open source Ruby workflow (and sometimes BPM) engine.
+
+
+The main project team
+---------------------
+
+John Mettraux  http://jmettraux.wordpress.com
+Kenneth Kalmer  http://www.opensourcery.co.za
+
+
+Contributors
+------------
+
+Nicholas Faiz - http://github.com/biv
+Chris Beer - http://github.com/cbeer
+Enrico Bianco - http://github.com/enricob
+Andrew Timberlake - timeout 'at'
+Torsten Schoenebaum - ActiveResourceParticipant and more
+Raphael Simon - error handling mechanism design and QA
+Maarten Oelering - bug reports and test cases
+Nick Petrella - socket listener issues and Python interactivity, dollar patch
+Sakaguchi Masa - japanese website and articles in Japanese magazines
+Patrice Cappelaere - lots of feedback and ideas
+Tomaso Tosolini - database persisted engine implementation and patches
+Alain Hoang (configuration managaer)
+Matt Zukowski (senior developer)
+Jamandru Reynolds (http://geometron.net)
+Frederic Piccand
+Richard Jennings
+
+
+Feedback
+--------
+
+Francisco Kiko - "is set" issue
+David Goldhirsch - EM participant block
+dlamotte - set :val => nil
+jpr5 + asm
+Daniel Neighman "hassox" - :on_timeout => "error"
+Jason Allen - multi-instance considerations
+Petia Wohed - workflow patterns implementation evaluation
+Ralph DeGuelle - sleep silent death report
+Leo Venegas - various bug reports
+Corin Moss - sync launch and ruote-rest balancing
+Scott Sproule - missing read() method in rufus-verbs fopen()
+Aye Thu - missing 'atom-tools' dependency
+Machiel Groeneveld - missing 'rufus-mnemo' dependency
+Harshal Hayat - :on_field => :executions idea
+Ralf KaoticEntity - concurrence mix feedback
+Graeme Lockley - every jobs {re/un}scheduling
+JimJin - various feedback and bug reports
+Andreas Baumann - bug reports and test cases
+Fu Zhang - csv tables 'accumulate' and 'range' ideas
+Lee Fyock - suggested the Scheduler 'tag' feature.
+Art Schumer - cron scheduler bug
+ara.t.howard on the ruby talk ml pointed out a weakness in scheduler.
+Tomek "Tomash" Stachewicz - scheduler feedback
+Jon "Compensator" - first report of the "yamlextras" issue
+
+(see the mailing list at : http://groups.google.com/group/openwferu-users )
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+
+Copyright (c) 2001-2010, John Mettraux, jmettraux@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,76 @@
+
+= ruote
+
+Ruote is a Ruby workflow engine. It's thus a workflow definition interpreter. If you're enterprisey, you might say business process definition.
+
+Instances of these definitions are meant to run for a long time, so Ruote is oriented towards persistency / modifiability instead of transience / performance like a regular interpreter is. A Ruote engine may run multiple instances of workflow definitions.
+
+Persistent mostly means that you can stop Ruote and later restart it without losing processes. Modifiability means that you can modify a workflow instance on the fly.
+
+Process definitions are mainly describing how workitems are routed to participants. These participants may represent worklists for users or group of users, pieces of code, ...
+
+
+== usage
+
+  require 'rubygems'
+  require 'ruote'
+  require 'ruote/storage/fs_storage'
+
+  # preparing the engine
+
+  engine = Ruote::Engine.new(
+    Ruote::Worker.new(
+      Ruote::FsStorage.new('ruote_work')))
+
+  # registering participants
+
+  engine.register_participant :alpha do |workitem|
+    workitem.fields['message'] = { 'text' => 'hello !', 'author' => 'Alice' }
+  end
+
+  engine.register_participant :bravo do |workitem|
+    puts "I received a message from #{workitem.fields['message']['author']}"
+  end
+
+  # defining a process
+
+  pdef = Ruote.process_definition :name => 'test' do
+    sequence do
+      participant :alpha
+      participant :bravo
+    end
+  end
+
+  # launching, creating a process instance
+
+  wfid = engine.launch(pdef)
+
+  engine.wait_for(wfid)
+    # blocks current thread until our process instance terminates
+
+  # => 'I received a message from Alice'
+
+
+== test suite
+
+see http://github.com/jmettraux/ruote/tree/ruote2.1/test
+
+
+== license
+
+MIT
+
+
+== Links
+
+http://ruote.rubyforge.org
+http://github.com/jmettraux/ruote
+
+http://jmettraux.wordpress.com (blog)
+
+
+== feedback
+
+mailing list : http://groups.google.com/group/openwferu-users
+irc : irc.freenode.net #ruote
+

data/Rakefile

@@ -0,0 +1,68 @@
+
+require 'rubygems'
+require 'rake'
+
+$:.unshift( File.join(File.dirname(__FILE__), 'lib') )
+require File.join(File.dirname(__FILE__), %w[ lib ruote worker.rb ])
+
+begin
+
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+
+    gem.version = Ruote::VERSION
+    gem.name = 'ruote'
+    gem.summary = 'an open source ruby workflow engine'
+    gem.description = %{
+ruote is an open source ruby workflow engine.
+    }
+    gem.email = 'jmettraux@gmail.com'
+    gem.homepage = 'http://ruote.rubyforge.org'
+    gem.authors = [ 'John Mettraux', 'Kenneth Kalmer' ]
+    gem.rubyforge_project = 'ruote'
+    gem.test_file = 'test/test.rb'
+
+    gem.add_dependency 'rufus-cloche', '>= 0.1.6'
+    gem.add_dependency 'rufus-dollar'
+    gem.add_dependency 'rufus-json'
+    gem.add_dependency 'rufus-lru'
+    gem.add_dependency 'rufus-mnemo', '>= 1.1.0'
+    gem.add_dependency 'rufus-scheduler', '>= 2.0.3'
+    gem.add_dependency 'rufus-treechecker', '>= 1.0.3'
+
+    gem.add_development_dependency 'json'
+    gem.add_development_dependency 'yard'
+
+    # Gem::Specification http://www.rubygems.org/read/chapter/20
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new do |doc|
+    doc.options = [ '-o', 'ruote_rdoc', '--title', "ruote #{Ruote::VERSION}" ]
+  end
+rescue LoadError
+  task :yard do
+    abort 'YARD is not available. In order to run yardoc, you must: sudo gem install yard'
+  end
+end
+
+require 'rake/clean'
+CLEAN.include('pkg', 'rdoc', 'work', 'logs')
+
+task :default => [ :clean ]
+
+desc 'Upload the documentation to rubyforge'
+task :upload_rdoc => :rdoc do
+  sh %{
+    rsync -azv -e ssh \
+      ruote_rdoc \
+      jmettraux@rubyforge.org:/var/www/gforge-projects/ruote/
+  }
+end
+

data/TODO.txt

@@ -0,0 +1,287 @@
+
+[o] port load26 (requires BlockParticipant)
+[o] logger service
+[o] test logger
+[o] object full_dup
+[o] engine#remove_service
+[o] :receive or :receive_back for when workitems come back from participant
+[o] emit :processes :launch :wfid
+[o] emit :processes :terminate :wfid only
+[o] arch doc
+[o] verbose always on
+[o] ev : :participants :register/:unregister
+[o] test logger always on for tests (in-memory only)
+[o] NullParticipant
+[o] NoOpParticipant
+[o] rufus-dollar
+[o] variables in ProcessStatus (process level only)
+[o] ProcessStatus#tree
+[o] subprocess binding
+[o] subprocess lookup
+[o] participant lookup
+[o] event : launch_sub
+[o] event : :processes, :cancelled ?
+[o] concurrence : over_if
+[o] pool cleanup
+[o] fexp : created_time
+[o] ps : launched_time
+[o] ps : #tags
+[o] wi test (and fix) ${f:xyz}
+[o] wi#to_h #from_h
+[o] wi.params
+[o] self rec for [main] process
+[o] fexp.modified_time
+[o] wfid_gen : rufus-mnemo
+[o] fs_error_journal
+[o] fs_error_journal : restart test
+[o] do errors get removed after being replayed ? yes.
+[o] cache storage
+[o] fs storage
+[o] tag (which implies variables)
+[o] event : upon setting tag !
+[o] event : upon leaving tag
+[o] undo
+[o] redo
+[o] cancel-process (exp)
+[o] cancel_process
+[o] cancel
+[o] on_error
+[o] on_cancel
+[o] iterator
+[o] iterator : break, cancel, ...
+[o] cursor
+[o] cursor : jump to tag
+[o] loop
+[o] if
+[o] equals
+[o] unset
+[o] cursor/loop/iterator : break-if rewind-if
+[o] stop passing full exp in message, except for expression updates
+[x] engine#reload
+[o] participants shutdown
+[o] stalled [participant] expressions restart (apply/reply ?)
+    "re-apply on reload"
+    http://groups.google.com/group/openwferu-users/browse_thread/thread/c2aa4b53d1664d45
+[x] workitem.__result__ / why, the workitem itself is the result
+[o] tracker
+[o] sleep
+[o] listen
+[o] listen wfid="x"
+[o] exploded scheduler
+[x] wfid --> piid (stick with the funny old name)
+[o] persisted tracker
+[o] wfidgen.shutdown (close wfidgen.last)
+[o] conditional for everybody
+[o] timeout for everybody
+[o] __timed_out__ = true ? (wi.fields)
+[o] engine.processes()
+[o] kill_process != cancel_process (need a way to not trigger on_cancel)
+[o] pdef.to_dot (a beginning)
+[o] @in_cancel, @in_error --> @state (active|cancelling|killing)
+[o] wait
+[o] listen
+[o] Jason Allen's check about concurrence
+[x] on_cancel => 'error' NO
+[o] event on [un]setting variable
+[o] condition : != ~= >= ....
+[o] fs_participant
+[o] participant : do thread (and do_not_thread)
+[o] add test for error replay in participant
+[o] forget : participant ? subprocess ? everybody
+[o] Ruote.VERSION = "2.0.0" for Kenneth
+[o] on_timeout => 'part|sub' (idea by hassox)
+[o] on_timeout => 'error' (idea by hassox)
+[o] exp : concurrent-iterator < concurrence
+[o] exp : reserve
+[o] exp : unset
+[o] exp : save
+[o] exp : restore (and its set-fields alias)
+[o] participant : if EM is present use next_ or defer instead of Thread.new
+[o] XML process definitions
+[o] remote process definitions
+[o] json process definitions
+[o] check nested ${f:a.b.c}
+[o] test : participant in error timeout (error should cancel timeout)
+[o] nested set wi.fields['a.b.0'] = x
+[o] nested save wi.fields['a.b.0'] = x
+[o] parser.rb : test security check
+[o] add Ruote::Launchitem
+[o] participant#cancel pass flavour as well nil|:kill|:timeout
+[o] BlockParticipant : |workitem, fexp|
+[o] listeners
+[o] engine.wait_for
+[o] func tests : wire assert_no_errors back in
+[o] timeout set by participant [implementation]
+[o] test for wfids of errors in subprocesses !
+[o] Ruote::Exp:: namespace for expressions
+[o] exp : apply (ex-eval)
+[o] apply : attributes to variables
+[o] subprocess : attributes to variables
+[o] concurrent_iterator :times => X
+[o] iterator defaults to :to_v => 'i'
+[o] concurrent_iterator defaults to :to_v => 'i'
+[o] set "f:x" => "blah"; set "v:y" => [ 1, 2 ] (defaults to f:)
+[o] subprocess :ref => uri
+[o] participants : pass the &block under the option :block
+[o] concurrence : :over_unless
+[x] engine#register_subprocess (replaced by engine#variables)
+[x] switch to JSON friendly pers format for flow expressions
+[o] switch to JSON friendly pers format for workitems
+[o] rewind :ref => 'tag_of_cursor_exp' (direct) :tag oriented.
+[o] exp : error
+[o] wait 0.500 / wait 60
+[x] exp : reval : not needed, participants are here
+[o] exp : inc ? if target is array, becomes append (not cons)
+[o] exp : dec ? if target is array, then pop (not car)
+[o] _if '${f:x} == ${f:y}'
+[x] equals : equals "v:v" => "true"  NO => evokes assignment
+[x] if : _if "v:v" => "true" ?  NO => evokes assignement
+[x] deferred apply technique / not OK, with EM and next_tick / pro
+[o] reserve : perhaps it's better to have an atomic get and set variable...
+[o] clean up lookup_var/set_var into locate_var/lookup_var/set_var
+[x] Sun Hao's up-to-date-tree idea ${f:participant_name} ps#resolved_tree
+[o] error : when an error expression is cancelled, should the err get remove 
+    from the process status ? yes.
+[o] file logger / history service
+[o] engine.process_history(wfid)
+[o] add_branch :times/:branches
+[o] cursor : :break_if / :break_unless
+[o] exp : when (exploit :var :set event, or frequency)
+[o] when : restart test
+[o] when : cron frequency
+[o] let listeners accept launchitems
+[o] exp : cron
+[o] exp : every
+[o] write rt test for 'timeout'
+[o] undo exp : alias to 'cancel'
+[o] Andrew's at for timeouts (Chronic maybe)
+[x] timeout :at and :after (timeout expression vanished)
+
+[ ] exp : exp (restricted form of eval ?)
+[ ] exp : case (is it necessary ?)
+[ ] exp : filter
+[ ] exp : filter-definition
+[x] exp : lose ?
+[x] exp : parameter
+[ ] exp : log
+
+[ ] exp : defined (not really necessary)
+[ ] exp : quote (not really necessary)
+[ ] exp : field / attribute (not really necessary)
+[ ] exp : variable (not really necessary)
+
+[ ] exp : step (jump to cursor tag ?)
+
+[ ] conditional : rprefix ! ${r:x} is perhaps sufficient
+
+[ ] auto-participant re-apply
+
+[ ] define without name (__result__)
+
+[ ] pooltool.ru
+
+[ ] participant dispatch thread throttling ?
+
+[ ] expstorage.to_dot
+
+[ ] tailcall
+[ ] subprocesses participants (alias ?)
+
+[ ] __command__ + tag (rewind that cursor there, not the current one)
+
+[ ] beanstalk [as a] workqueue ?
+
+[ ] recursion : should cope with modified trees 'main' => :tree ??
+
+[ ] user3 :rif => "!wi.fields['approvers'].include?('user3')" : 'in' operator
+
+[ ] set :var => 'y' { '2342342' }
+
+[ ] pause engine
+[ ] pause process instance
+
+[ ] file/fs_listener [example] ?
+
+[ ] tree.to_xml (require builder ?)
+[ ] tree.to_rb
+
+[ ] concurrence / concurrent_iterator : merge plugin ?
+    use participant for that ?
+
+[ ] restore : implement merge strategies
+
+[ ] one file, no multi-process, persistence ? LateHashStorage ?
+
+[ ] apply : ruby or xml (instead of just ast) ?
+
+[ ] unify ruote/util/json and ruote/util/serializer
+
+[ ] history.to_tree ?
+
+[ ] Ruote.process_definition ... Ruote.method_missing or sequence ?
+
+[ ] concurrence / concurrent_iterator : merge_type => 'discard' / 'ignore'
+    keep track of the first "process sub id" ?
+
+[ ] @children diff/undiff idea ?
+
+[ ] write doc about engine options (multi-process !)
+[ ] _if '${f:x} == ${f:y} || ${f:x} == ${f:z}'
+
+[ ] document the dollar notation / substitution / extrapolation
+
+[ ] condition : "${f:x} [is] empty" / this one is hard
+
+[ ] ruote/exp/fe_set.rb:147: warning: already initialized constant PREFIX_REGEX
+
+[ ] implement kill_process! (kill_expression! ?)
+
+[ ] engine.force_reply_to_parent(fei) ?
+
+[ ] break fs_history, prepare for dm_history
+
+[ ] :on_timeout => :rewind (break, jump to x)...
+[ ] rewind 'x' where x is a tagname (command x)
+
+[ ] repeat : have a counter in a variable (:to => x maybe) (subprocessid ?)
+
+[ ] when : add test for cancelling when child has been triggered / is running
+[x] listen : should it forget its triggered children ? yes
+
+[ ] engine.cancel_forgotten_children(wfid) ?
+
+[ ] port subprocess on_cancel test from ruote 0.9 http://groups.google.com/group/openwferu-users/t/75f02bdadf7b93eb
+
+[ ] double-check on_cancel rewrite (ft_1_process_status)
+
+[o] limit the number of msgs returned
+[o] should redo/undo follow the example of command and add_branches ?
+    everything through reply (receive)
+    should re_apply not touch the state of its expression ?
+[o] test undo when cancelling parent expression
+[o] issue with :unless => '${f:index} == 2000'
+[o] implement Engine#reply (Engine simply has to include ReceiverMixin
+[o] listeners X receivers
+[o] add_service(name, path, klass, opts={}) opts local to services (really?)
+[o] add_branches : pass message to concurrent_iterator like a command expression
+
+[ ] verify get_last/get_raw logic, no + 0.0001...
+[ ] clean up persists present in #apply
+[ ] case exp : smarter one ?
+[ ] spare 1 get_msg by caching msg (but keep 'deleting')
+[ ] [un]set_var : via message ? should be ok like that... Not much traffic there
+
+[ ] empty iterator or concurrent-iterator, log ? crash ? empty while...
+[ ] maybe cancel should have a safely / redo_reply thing
+[ ] at expression ?
+[ ] listen to participants/errors/tags {in|out}
+
+[ ] implement StorageHistory
+[ ] nuke FsHistory ?
+
+[ ] remove abort_on_exception=true
+
+[ ] check : what if a reply on a concurrence wants to save, whereas the
+    concurrence terminated (got removed) meanwhile ?
+    the reply returns true...
+