ruote 2.1.11 → 2.2.0

data/CHANGELOG.txt

@@ -2,6 +2,66 @@
 = ruote - CHANGELOG.txt
 
 
+== ruote - 2.2.0    not yet released
+
+- Engine#participant(name) returns an instance of any participant
+- :filter => 'participant_name' (consume(wi) / filter(fields))
+- listen block and forget issue fixed (Thanks Nando Sola)
+- @msg always set in FlowExpression
+- aliased 'cancel_process' to 'terminate'
+- Engine#leftovers (Thanks Iuri)
+- $x, $f:x and $v:y vs ${x}, ${f:x} and ${v:y} (literally)
+- :filter common attribute
+- Participant#do_not_thread : optional workitem parameter
+- filter expression
+- LocalParticipant / Receiver #applied_workitem(fei)
+- using Sourcify to store block participant's code as a string
+- CompositeStorage#delete bug fix (Thanks Claudio)
+- ParticipantList#register bug fix (Thanks 'sandbox')
+- StorageHistory#wfids and DefaultHistory#wfids
+- Engine#history -> DefaultHistory (keeping the last 1000 msgs)
+- 'citerator' alias to 'concurrent_iterator'
+- Participant#rtimeout(workitem) (optional)
+- moved Engine#workitem(fei) to ReceiverMixin
+- storage#delete_schedule ignoring nil schedule_id
+- Participant #rtimeout instead of #timeout
+- StorageParticipant making @options available
+- Engine#register, allowing block participants (Thanks Hery)
+- fixed Engine#launch_single relaunch issue (Thanks Gonzalo)
+- 'rset', an alias for the 'set' expression (Thanks Rebo)
+- listen :to => /x/ or "/x/" required for regular expressions
+- engine#on_terminate = participant_name / subprocess_name / tree
+- listen :to => 'tagname', :upon => 'entering' / 'leaving'
+- Ruote::Parser becomes Ruote::Reader
+- :if => "${customer} in ${customer_list}", :if => "4 in {4 => 5}"
+- Ruote::Workitem .from_json #as_json
+- :on_error => redo/retry // undo/pass
+- given : a case/switch ruote equivalent
+- conditionals : "${x} is empty" and "${x} is null"
+- once expression (once, _when, as_soon_as)
+- let expression (a sequence with its own variable scope)
+- engine.ps(wfid=nil)
+- once : made sure child is cancelled as well
+- :if => '${f:a} and ${f:b}'
+- workitem.tags (workitem['fields']['__tags__']
+- better participant initialization (Thanks Neil Pennell)
+- Engine #cancel and #kill (expression or process, whichever)
+- subid (sub_wfid) for every expression
+- undo and redo : more robust (broken tags)
+- cursor : giving a sub_wfid to children (play nice with :forget)
+- Ruote.is_tree?(o) .is_definition_tree?(o) consolidated
+- engine#on_error = [] registering error notifications and the like
+- engine#configuration(key) (counterpart to engine#configure(key, value))
+- implemented the :lose attribute
+- implemented the 'lose' expression
+- fixed issue with "over" (Thanks Daniel 'hassox' Neighman)
+- fixed issue with workitem.command = 'jump to x' (Thanks Fix Peña)
+- fixed issue with ProcessStatus#position and errors in ParticipantExpression
+  (Thanks Eric Smith)
+- 'registerp' and 'unregisterp' expressions
+- ${r:xxx} when ruby_eval_allowed == false now raises an error
+
+
 == ruote - 2.1.11    released 2010/10/01
 
 - Engine#process broken with process where schedule count > 1 (Thanks David)

data/CREDITS.txt

@@ -2,20 +2,24 @@
 CREDITS
 =======
 
-Ruote (OpenWFEru) is an open source Ruby workflow (and sometimes BPM) engine.
+Ruote is an open source Ruby workflow engine.
 
 
 The main project team
 ---------------------
 
 John Mettraux - http://jmettraux.wordpress.com
-Kenneth Kalmer - http://www.opensourcery.co.za
 Torsten Schoenebaum - http://github.com/tosch
+Kenneth Kalmer - http://www.opensourcery.co.za
 
 
 Contributors
 ------------
 
+Neil Pennell - http://github.com/npennel
+Patrick Gannon - fix for compatibility with ruote-mongodb
+Fix Peña - 'jump to' bug patch
+Eric Smith - position when error patch
 David Goodlad - http://github.com/dgoodlad
 Eric Dennis - http://github.com/threetee
 David Greaves - http://github.com/lbt
@@ -43,6 +47,16 @@ Richard Jennings
 Feedback
 --------
 
+Nando Sola - many help
+Iuri Gagnidze - ProcessStatus#definition_name issues, Engine#leftovers
+John Le - https://github.com/sandbox
+Sean Johnson - https://github.com/belucid
+Hery - Engine#register and block participants
+Gonzalo Suarez - many many help
+Rebo - 'set' issue with Sinatra
+Copper Hill - test coverage enhancements
+Claudio Petasecca Donati - many help
+Daniel Neighman "hassox" - :on_timeout => "error" and many issue reports
 Eric Platon - engine.launch_single idea
 Marc Lee - storage.clear consistency
 Nathan Stults - enhanced dollar substitution and service
@@ -50,12 +64,10 @@ Don H. French - Engine#register_from_dir idea
 Kaspar Schiess - http://github.com/kschiess
 Oleg (foenixx) - many suggestions and bug reports
 Avishai Shalom - discussion and ideas about participant/worker locality
-Gonzalo Suarez - many help
 Francisco Kiko - many help
 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
@@ -78,3 +90,9 @@ Jon "Compensator" - first report of the "yamlextras" issue
 
 (see the mailing list at : http://groups.google.com/group/openwferu-users )
 
+
+Last but not least
+------------------
+
+Many thanks to the authors, the contributors and the community of the Ruby language, the various json gems, the builder, mailtrap, sourcify, parsetree gems, and many more.
+

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2001-2010, John Mettraux, jmettraux@gmail.com
+Copyright (c) 2001-2011, 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

data/README.rdoc

@@ -74,16 +74,15 @@ see http://github.com/jmettraux/ruote/tree/ruote2.1/test
 MIT
 
 
-== Links
+== links
 
-http://ruote.rubyforge.org
-http://github.com/jmettraux/ruote
-
-http://jmettraux.wordpress.com (blog)
+* 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
+* mailing list : http://groups.google.com/group/openwferu-users
+* irc : irc.freenode.net #ruote
 

data/Rakefile

@@ -1,80 +1,64 @@
 
-require 'lib/ruote/version.rb'
+$:.unshift('.') # 1.9.2
 
 require 'rubygems'
+require 'rubygems/user_interaction' if Gem::RubyGemsVersion == '1.5.0'
+
 require 'rake'
+require 'rake/clean'
+require 'rake/rdoctask'
+
 
 #
 # clean
 
-require 'rake/clean'
-CLEAN.include('pkg', 'rdoc', 'ruote_work', 'ruote_data', 'logs')
-
-task :default => [ :clean ]
+CLEAN.include('pkg', 'rdoc', 'ruote_work', 'ruote_data')
 
 
 #
-# jeweler tasks
-
-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', 'Torsten Schoenebaum' ]
-    gem.rubyforge_project = 'ruote'
-    gem.test_file = 'test/test.rb'
-
-    gem.add_dependency 'rufus-json', '>= 0.2.5'
-    gem.add_dependency 'rufus-cloche', '>= 0.1.20'
-    gem.add_dependency 'rufus-dollar'
-    gem.add_dependency 'rufus-mnemo', '>= 1.1.0'
-    gem.add_dependency 'rufus-scheduler', '>= 2.0.5'
-    gem.add_dependency 'rufus-treechecker', '>= 1.0.3'
-
-    gem.add_development_dependency 'rake'
-    gem.add_development_dependency 'yard'
-    gem.add_development_dependency 'json'
-    gem.add_development_dependency 'builder'
-    gem.add_development_dependency 'mailtrap'
-    gem.add_development_dependency 'jeweler'
-
-    # Gem::Specification http://www.rubygems.org/read/chapter/20
-  end
-  Jeweler::GemcutterTasks.new
+# test
 
-rescue LoadError
-  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+task :test do
+
+  sh 'ruby -I. test/unit/test.rb'
+  sh 'ruby -I. test/functional/test.rb'
 end
 
+task :default => [ :test ]
+
 
 #
-# rdoc
+# gem
+
+GEMSPEC_FILE = Dir['*.gemspec'].first
+GEMSPEC = eval(File.read(GEMSPEC_FILE))
+GEMSPEC.validate
+
+
+desc %{
+  builds the gem and places it in pkg/
+}
+task :build do
+
+  sh "gem build #{GEMSPEC_FILE}"
+  sh "mkdir pkg" rescue nil
+  sh "mv #{GEMSPEC.name}-#{GEMSPEC.version}.gem pkg/"
+end
+
+desc %{
+  builds the gem and pushes it to rubygems.org
+}
+task :push => :build do
+
+  sh "gem push pkg/#{GEMSPEC.name}-#{GEMSPEC.version}.gem"
+end
 
-#begin
-#  require 'yard'
-#  YARD::Rake::YardocTask.new do |doc|
-#    doc.options = [ '-o', '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
 
 #
-# make sure to have rdoc 2.5.x to run that
+# rdoc
 #
-require 'rake/rdoctask'
+# make sure to have rdoc 2.5.x to run that
+
 Rake::RDocTask.new do |rd|
 
   rd.main = 'README.rdoc'
@@ -83,14 +67,16 @@ Rake::RDocTask.new do |rd|
   rd.rdoc_files.include(
     'README.rdoc', 'CHANGELOG.txt', 'CREDITS.txt', 'lib/**/*.rb')
 
-  rd.title = "ruote #{Ruote::VERSION}"
+  rd.title = "#{GEMSPEC.name} #{GEMSPEC.version}"
 end
 
 
 #
 # upload_rdoc
 
-desc 'Upload the documentation to rubyforge'
+desc %{
+  upload the rdoc to rubyforge
+}
 task :upload_rdoc => [ :clean, :rdoc ] do
 
   account = 'jmettraux@rubyforge.org'
@@ -99,3 +85,16 @@ task :upload_rdoc => [ :clean, :rdoc ] do
   sh "rsync -azv -e ssh rdoc #{account}:#{webdir}/"
 end
 
+
+desc %{
+  attempt at detecting test methods with the same name
+}
+task :doublons do
+
+  lines = `grep -r " def test_" test/ | sort`.split("\n")
+  lines.inject(nil) do |previous, line|
+    p line if line == previous
+    line
+  end
+end
+

data/TODO.txt

@@ -79,7 +79,6 @@
 [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
@@ -234,12 +233,64 @@
 [o] lib/ruote/svc for treechecker, error_handler and co (tree_checker)
 [o] part/template.rb, use Rufus::Json.pretty_encode
 [o] storage.clear OR storage.purge! OR both (cf discussion with marc_lee) !!
-
-[ ] exp : exp (restricted form of eval ?)
-[ ] exp : case (is it necessary ?)
-[ ] exp : filter
-[ ] exp : filter-definition
-[x] exp : lose ?
+[o] Nathan : throw error on ${ruby:...} when ruby_eval_allowed is not set
+[o] engine.kill and engine.cancel should accept fei, fexp or wfid
+[o] participant params['tags'] = [ a, b, c ] ? costly (x expressions to read)
+    but passing them in the workitem could be fun
+    field['__tags__'] ?
+[x] use treetop for more complex "${f:x} AND ${f:y}" ?
+    (systems like Rails require it anyway)
+    NO : using ruby_parser instead
+[o] TreeChecker : exclude_fvccall :at_exit
+[o] _if '${f:x} == ${f:y} || ${f:x} == ${f:z}'
+[x] beanstalk [as a] workqueue ?
+[o] tree.to_xml (require builder ?)
+[o] tree.to_ruby
+[o] __command__ + tag (rewind that cursor there, not the current one)
+[o] rewind 'x' where x is a tagname (command x)
+[o] solve the ps#root_expression_for(fei) dilemma
+[x] condition : "${f:x} [is] empty" / this one is hard
+[o] when : add test for cancelling when child has been triggered / is running
+[o] engine.ps(wfid)
+[x] alias "when" to "whenever" ?
+[x] alias "when" to "on" / "upon"
+[o] alias "when" to "once"  "once x == y do"
+[o] condition : "${'x} [is] empty" since ${array} => "[]"
+[x] simple worker hooks ? (as discussed with @hassox)
+    on_terminate... ? only works in the same process as the worker
+    only for tests...
+[o] on_error => retry / pass
+[o] workitem : #as_json and #from_json
+    since ruote depends on rufus-json...
+[x] engine.on_error = 'participant_name' // 'subprocess_name'
+    done at : http://github.com/jmettraux/ruote/commit/50292d954ff877f1f6615022216f346a7001b483
+    `--> reverting that for now, too dangerous
+[o] process_count and error_count ? (processes(:count => true))
+[o] exp : case (is it necessary ?) (guards ?) (hard for ruote-fluo)
+[o] exp : lose
+[o] conditional : rprefix ! ${r:x} is perhaps sufficient
+[o] implement kill_process! (kill_expression! ?)
+[o] /!\ resurrect CI
+[o] user3 :rif => "!wi.fields['approvers'].include?('user3')" : 'in' operator
+    "${customer} in [ 1, 2, 3 ]"
+    "${customer} in { 'x' => 1 }"
+[o] rename 'parser' to 'reader'
+[o] ft_42 : maybe require storage to output ids already sorted
+[o] Participant#rtimeout(workitem=nil)
+[o] alias concurrent-iterator to citerator
+[o] like we have a default WaitLogger, why not have a default HistoryLogger ?
+    so that context.history always returns something...
+    the default history would be storage based but with LRU turned on
+    for the HashStorage one...
+    like WaitLogger only remembers 147 msgs...
+[o] StorageHistory : add a method to list all wfids (for by_wfid)
+[o] DefaultHistory : add a method to list all wfids (for by_wfid)
+[x] issue with ruote-kit and inpa participants...
+[x] .nil? .empty? .set? for "${x}.nil?"
+
+[ ] exp : exp (restricted form of eval ?) (is it apply ?)
+[x] exp : filter
+[x] exp : filter-definition
 [x] exp : parameter
 [ ] exp : log : or could it be a participant ?
 
@@ -248,25 +299,15 @@
 [ ] exp : field / attribute (not really necessary)
 [ ] exp : variable (not really necessary)
 
-[ ] conditional : rprefix ! ${r:x} is perhaps sufficient
-
 [ ] define without name (__result__)
 
-[ ] pooltool.ru
-
 [ ] participant dispatch thread throttling ?
 
 [ ] 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
@@ -277,9 +318,6 @@
 
 [ ] file/fs_listener [example] ?
 
-[ ] tree.to_xml (require builder ?)
-[ ] tree.to_rb
-
 [ ] concurrence / concurrent_iterator : merge plugin ?
     use participant for that ?
 
@@ -300,26 +338,11 @@
 
 [ ] @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) ?
-
 [ ] :on_timeout => :rewind (break, jump to x)...
-[ ] rewind 'x' where x is a tagname (command x)
+[ ] :on_error => :rewind (break, jump to x)...
 
 [ ] repeat : have a counter in a variable (:to => x maybe) (subprocessid ?)
 
-[ ] when : add test for cancelling when child has been triggered / is running
-
 [ ] engine.cancel_forgotten_children(wfid) ?
 
 [ ] port subprocess on_cancel test from ruote 0.9 http://groups.google.com/group/openwferu-users/t/75f02bdadf7b93eb
@@ -327,30 +350,19 @@
 [ ] double-check on_cancel rewrite (ft_1_process_status)
 
 [ ] verify get_last/get_raw logic, no + 0.0001...
-[ ] 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...
-[ ] at expression ?
 
 [ ] remove abort_on_exception=true
 
 [ ] shell ? irb ? Shell.new(storage)
 [ ] focus on fulldup or json.dup (via fulldup ?)
 
-[ ] listen to participants/errors/tags {in|out}
-
-[x] engine.on_error = 'participant_name' // 'subprocess_name'
-    done at : http://github.com/jmettraux/ruote/commit/50292d954ff877f1f6615022216f346a7001b483
-    `--> reverting that for now, too dangerous
-
-[ ]  should __error__ contain the tree ?
+[ ] should __error__ contain the tree ?
 [ ] engine.on_cancel = 'participant_name' // 'subprocess_name'
-
-[ ] "business days" plugin
-
-[ ] issue with ruote-kit and inpa participants...
+    bof
 
 [ ] participant :ref => '${f:nada}', :or => 'xyz'
     (look at OpenWFE manual, this feature already existed in there)
@@ -360,8 +372,6 @@
 
 [ ] LocalParticipant def consume; handle; reply; end
 
-[ ] lib/ruote/part/participant_list.rb l176 better error message !
-
 [ ] find better solution than "get all schedules"
 
 [ ] worker : minuteman, make it cron triggerable
@@ -369,14 +379,10 @@
     maybe it's expensive to fire a [worker] process each minute
     have to write the $$ (pid) somewhere for cron to pick it up
 
-[ ] detach / attach segments of processes
-[ ] clone process ? (could be used by {de|at}tach)
-
-[ ] dollar.rb ${timestamp} ?
-
 [ ] toto :task => 'maw the lawn', :within => '3d'
-
-[ ] solve the ps#root_expression_for(fei) dilemma
+    alias to timeout
+[ ] "business days" plugin
+[ ] participant 'toto', :while => '${not_good}' (really ?)
 
 [ ] re_apply_stalled
     http://groups.google.com/group/openwferu-users/browse_thread/thread/ff29f26d6b5fd135
@@ -387,21 +393,87 @@
     configuration issue
     maybe fail with a good error message when registering service...
 
-[ ] participant 'toto', :while => '${not_good}' (really ?)
-
 [ ] engine.register_from_dir() have a way to re-evaluate the dir
 [o] OR remove engine.register_from_dir()
 [o] AND provide a better register &block
 [o] provide a mean for a participant to reject a workitem (intra plist)
     on_reply and now filter ?
 
-[ ] rw : upgrade [register_]participant documentation
-
 [ ] StorageParticipant#by_store[_name]
     maybe : reform the store_name system !
 
-[ ] rename 'parser' to 'reader'
+[ ] a run of ruby -w
+
+[x] cursor : previous_command field ? not really necessary with :break_if => x
+
+[ ] register :overwrite { ... } ? (wipes all the participants)
+
+[ ] storage_participant.by_participant([ a, b, c, d ], opts)
+    storage_participant.by_participant(a, b, c, d, opts) too
+      leverage things like
+      http://wiki.apache.org/couchdb/HTTP_view_API#Querying_Options
+    2.1.12
+
+[ ] receiver/base.rb : fexp.lookup_variable --> lookup_variable ?
+
+[ ] engine/receiver #reply(workitem or fexp or fei) ?
+[ ] workitem : short constructor, cf http://groups.google.com/group/openwferu-users/browse_thread/thread/c52d207d85e4b93e
+[ ] engine.force_reply_to_parent(fei) ?
+    but, this is a cancel_expression(fei)
+
+[ ] at expression ? :names :wait, :at
+
+[ ] concurrence : add_child ?
+    How would that impact concurrent_iterator's add_branches ?
+[ ] detach / attach segments of processes
+[ ] clone process ? (could be used by {de|at}tach)
+
+[ ] console for InformatiQ / console or dashboard or tool ?
+[ ] pooltool.ru : there are already storage copy methods
+
+[ ] BlockParticipant : proc.to_source thanks to sourcify
+
+[o] doc : enhance doc on conditional (and, empty, null, ...)
+[o] doc : document engine.on_{error|terminate}
+[o] doc : document on_error = retry and on_error = pass
+[ ] doc : add piece of doc about running workers on their own
+
+[ ] listen to errors {in|out}
+    well... there is already on_error...
+    but on_error is for nested stuff...
+[o] listen to tags {entering|leaving}
+[x] listen to launch/terminate, listen :process => :x, :upon => 'launching'
+    you can now set :tag on a subprocess' define
+[ ] listen to [un]set variable (the events are already in there)
+    not really necessary... there is already 'once' (when)
+[o] listen condition ? :when => '${x} == y', :constraint, :only, ...
+    it's :where and it's not documented :-( but it's tested :-)
+[o] engine#on_terminate, similar to on_error
+[o] let engine#on_error use svc/tracker.rb instead of 'notifications'
+
+[ ] ruote cheatsheet
+[ ] ruote slides
+
+[ ] process supervise other process, listen...
+    launch a process with a designed 'supervisor' ?
+
+[x] ci : ruote-amqp
+[ ] ci : ruote-mongodb
+[ ] ci : jruby
+
+[ ] StorageParticipant#reply : raise if workitem not found ?
+[ ] StorageParticipant#reply : accept fei ?
+[ ] Engine#reply(wi), should remove from storage...
+
+[ ] eft_18 weak with jruby-1.5.1 and 1.5.6
+
+[ ] participant : consume/cancel/accept?/on_reply without params
+
+[ ] worker identification/registration
+    http://groups.google.com/group/openwferu-users/browse_thread/thread/c51b94fb8bb685da
+[ ] worker shutdown initiated by engine (same thread)
+
+[ ] wait_for(:participant) what about 'dispatched' instead of 'dispatch' ?
 
-[ ] process_count and error_count ? (processes(:count => true))
-[ ] engine.ps(wfid) (shortcut ?)
+[ ] expression :concurrent => true idea (reply immediately, cancellable)