ruote-maestrodev 2.2.1

data/CHANGELOG.txt

@@ -0,0 +1,290 @@
+
+= ruote - CHANGELOG.txt
+
+
+== ruote - 2.2.1    not yet released
+
+- dollar substitution in expression name as well
+- Engine#replay_at_error(err_or_fei_or_wi)
+- Engine#error(wi_or_fei)
+- storages : #replace_engine_configuration(opts)
+- FsStorage : saving newer configuration (Thanks Nicholas Faiz)
+- ProcessStatus context : linking expression <-> error
+- ProcessStatus#root_workitem
+- ProcessStatus#leaves
+- filter 'includes' and 'is' (Thanks Nando Sola)
+- trailing fields (a Simone Carletti idea)
+- concurrence vs history issue fixed (Thanks Juris Galang)
+- unset and fields : made sure the field is removed (Thanks jpgilman)
+- sourcify, using to_raw_source from now on
+- filter expression and blocks
+- set 'v:display' => 'echo', aliasing of expressions
+- Reader.read(s) : better error raised when failed to 'parse'
+- :on_field => 'my.nested.field' now possible
+- [concurrent-]iterator :to => 'v:x' / 'f:y' / 'y'
+- concurrence :merge_type => 'union'
+- Reader.to_radial(tree)
+- Workitem#param_or_field(key) and #field_or_param(key)
+- Workitem#param_text
+- ProcessError#deviations (cf filter and Ruote::ValidationError)
+- reworked (process definition) Reader
+- filter top-level 'or'
+- filter field => 'x|y' (or on field names)
+- 'radial' process definitions
+- fixed Tracker#add_tracker (2nd try) issue (Thanks Pedro Texeira)
+- Engine#register :on_workitem / :on_reply / ...
+- set 'v:participant' => lambda { |wi| wi.fields['x'] = 'y' }
+- listen :to => :errors, :class => string / :message/:msg => string / regex
+- listen :to => :errors
+- dropped require 'json' and co from fs_storage (Thanks Torsten)
+- cursor : 'reset' command and :reset_if attribute
+- Engine#resume(wfid, :anyway => true) resumes any paused expression in a
+  given process
+- Engine#pause(fei, :breakpoint => true) pauses only one expression (and not
+  its children)
+- CompositeStorage#delete_schedule fix (Thanks Greg)
+- read 'http://'|'file', :to => 'f:a' / :to => 'v:b'
+- save :to => 'f:a' / :to => 'v:b'
+- pause(fei/wfid), resume(fei/wfid)
+- participant list, multiple participants with same regex now ok, allowing
+  for cascading participants (at consume and at on_error)
+- register block : fixed issue with lonely pname and block
+- register_participant : after/before/over
+- register block : now clearing by default
+- fixed issue with deep set and unset (Thanks Nando Sola)
+- improved conditional evaluation for dollar notation
+- register block : catchall and catch_all
+- Workitem #wf_name and #wf_revision
+- StorageParticipant :skip and :limit issues (Thanks Jan Topiński)
+- StorageParticipant #proceed deprecates #reply
+- fix for :if => '${a}' when a like '456ab' (Thanks John Le)
+- StorageParticipant :count => true uniformization (Thanks Jan Topiński)
+- StorageParticipant#by_fei (alias for #[])
+
+
+== ruote - 2.2.0    released 2011/03/01
+
+- 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)
+- Engine#launch_single for 1! instance processes (Thanks Eric)
+- Workitem#command and #command= helpers
+- ProcessError#workitem helper
+- fetch_flow_expression made public and aliased to fexp
+- ${r:workitem_field} (idea: Nathan Stults)
+- Ruote::Dollar::Dict and Ruote::Dollar::RubyContext
+- made Ruote.dsub a service : @context.dollar_sub.s(...) (idea: Nathan Stults)
+- moved simpler services to ruote/svc/
+- using BlankSlate for ruby process definitions
+- Engine.new(worker, :join => true) will let the worker run in the current
+  thread (and not return)
+- StorageParticipant#query(:count => true)
+- storage.get_many(type, keys, :descending => true)
+- engine.processes(:skip => 50, limit => 50)
+- listen expression : using lwfid instead of wfid (storage change)
+- fixed issue when re-applying root expressions (Thanks Brett)
+- storage_participant.query using :skip and :limit
+- engine.schedules([wfid]) and ProcessStatus#schedules
+- differentiating on_re_apply from on_cancel (process gardening)
+- engine.participant_list= more tolerant about its input
+- engine.process(wfid).stored_workitems
+- engine.process(wfid).workitems and .position
+- engine.process(wfid).last_active
+- engine.errors(wfid=nil) now returns array of ProcessError instances
+- engine.register { block } (Torsten)
+- participant.accept?(workitem)
+- 'ref' expression (pointing to participants or subprocesses)
+- engine.process_wfids (list process instance wfids)
+- set 'v:alpha' => [ 'MyParticipant', { 'flavour' => 'vanilla' }]
+  participants registered as variables (just for that process instance)
+- engine.participant_list and .participant_list=
+- engine.register_participant 'al', 'AlParticipant', :require_path => 'pa/th'
+- engine.register_participant 'al', 'AlParticipant', :load_path => 'pa/th'
+- engine.[un]register for .[un]register_participant
+- engine.noisy = true (a shortcut)
+- engine.storage_participant (a shortcut)
+- removed direct dependency on rufus-lru
+- WaitLogger : a transient @seen (Thanks Kaspar)
+- error_handler : more error catching
+- storage#copy_to(other_storage) item by item implementation
+- Engine#wait_for OK with multiple threads
+- ExpressionMap now loads all expressions in Ruote::Exp:: namespace
+- 'error_intercepted' msg now features error_class, _message and _backtrace (RM)
+- Engine#join and Worker#join
+- workitem.error now includes error's backtrace (contributed by Rich Meyers)
+
+
+== ruote - 2.1.10    released 2010/06/15
+
+- storage#copy_to(other_storage) implemented
+- #launch moved from Engine to ReceiverMixin
+- participants without initialize(opts) are now allowed
+- engine.wait_for(:inactive)
+- engine.wait_for(*interests) unlocked
+- engine.wait_for(:empty)
+- fixed issue with participant 'x' and :on_error. Thanks Oleg.
+- receiver : reply and reply_to_engine : from aliases to wrappers
+- Ruote::StorageParticipant more flexibility for method args
+- Ruote::FlowExpressionId .extract_h and .extract
+- dropped fs_history (storage_history is better)
+- parser to_xml _if 'x == b' --> <if test="x == b">
+- workitem.sid shortcut for workitem.fei.to_storage_id
+- workitem.wfid shorcut for workitem.fei.wfid
+- new error_handler service
+- Receiver.new(x), x can be worker, engine, context or storage
+- Participant#on_reply(workitem) manipulating workitems when they come back
+- set '${v:customers.0.name}' => 'x' now OK, was limited to fields. Thanks Oleg
+- LocalParticipant#put(fei, hash) #get(fei, key) for stashing info
+- LocalParticipant#re_dispatch(wi, opts)
+- bug in HashStorage, apply over apply didn't raise a persist error. Fixed.
+- keeping track of workitem fields as they were right before a participant error
+- Workitem.error holds the error when on_error. Thanks Oleg.
+- Workitem#error and Workitem#timed_out shortcuts
+- participant :on_error => 'x' broken. Fixed. Thanks Oleg.
+- Engine#workitem(fei) for advanced users
+- LocalParticipant : added a reject(workitem) method
+- participant exp : dispatched = true set right after dispatch
+
+
+== ruote - 2.1.9    released 2010/03/22
+
+- made participant.cancel occur asynchronously (as should be)
+- lookup_variable : making sure not to break when the parent exp is gone
+- workitem.fields['__dispatch_time__'] is now set
+
+
+== ruote - 2.1.8    released 2010/03/15
+
+- participant#schedule_timeout workaround for issue with JRuby 1.4.0 (1.8.7)
+- implemented Ruote::CompositeStorage
+- leveraging rufus-cloche 0.1.16 and the 'cloche_nolock' option (FsStorage)
+- SmtpParticipant and ruote/part/template.rb reorganization
+- StorageParticipant when returned by engine#register was unusable. Fixed.
+- string keys for SmtpParticipant. Thanks Gonzalo
+- fixed every('10m') bug. Thanks Gonzalo Suarez
+- Ruote::FlowExpressionId.from_id(s) more permissive
+- concurrence (and concurrent-iterator) :merge_type => :stack
+
+
+== ruote - 2.1.7    released 2010/02/15
+
+- now works on WinXP, Ruby 1.8.7
+- reformed msgs ids and adapted Ruote::StorageHistory
+- engine.register_participant(x, Ruote::StorageParticipant) now returning
+  a instance of the participant, for easy query
+- StorageParticipant, added #query(criteria), thanks Torsten and Brett
+- Ruote::Workitem #lookup('deep.field') and #set_field('deep.field') are back
+- Ruote::Workitem added == and hash (list.uniq friendly), thanks Brett
+- Engine#configure(key, value), thanks Torsten
+- Ruote.to_tree (lightweight version of Ruote.process_definition)
+- ParticipantList#names, thanks Kenneth
+
+
+== ruote - 2.1.6    released 2010/02/08
+
+- welcoming ruote-dm (datamapper persistency)
+- Engine#re_apply(fei, opts) where opts in [ :tree, :fields, :merge_in_fields ]
+- fixed issue about StorageParticipant#update, thanks Torsten
+
+
+== ruote - 2.1.5    released 2010/01/28
+
+- fixed StorageParticipant a to b flow, fix by Torsten
+- fixed StorageParticipant#cancel
+- dollar : made sure of ${fei} and ${wfid}
+- implemented ProcessStatus#to_dot
+- if a participant implementation cancel method returns false,
+  reply_to_parent will not get called
+- changes about errors without [stored] expressions, they now appear in process
+  statuses
+- EngineParticipant implemented
+- 'ruby_eval_allowed' instead of :ruby_eval_allowed
+- ${v:customer.address.1} deep trick now ok (as it was ok for fields)
+- added d() to the $ notation : echo "${r: d('f:toto') }"
+- Engine#kill_process(wfid) can cure errored participant expressions
+- made sure ${r:wi} and ${r:workitem} is and instance of Ruote::Workitem
+- implemented StorageParticipant#by_field
+
+
+== ruote - 2.1.4    released 2010/01/11
+
+- implemented StorageHistory
+- using yyyy-mm-dd instead of yyyy/mm/dd for Ruote.time_to_utc_s(t)
+- implemented Storage#purge_type!(t)
+- Engine#add_service now returning just bound service
+
+
+== ruote - 2.1.3    released 2010/01/04
+
+- fixed issue with Rufus.is_cron_string (thanks Torsten)
+- fixed issue with FlowExpression#cancel (Kenneth)
+
+
+== ruote - 2.1.2    released 2010/01/03
+
+- fixed issue when initializing engine without worker. Thanks Matt Nichols.
+
+
+== ruote - 2.1.1    released 2009/12/31
+
+== OpenWFEru - 0.9.2       released 2007/01/26
+== openwfe-ruby - 1.7.0    released 2006/05/08
+

data/CREDITS.txt

@@ -0,0 +1,99 @@
+
+= CREDITS
+
+Ruote is an open source Ruby workflow engine.
+
+
+== The main project team
+
+John Mettraux - http://jmettraux.wordpress.com
+Torsten Schoenebaum - http://github.com/tosch
+Kenneth Kalmer - http://www.opensourcery.co.za
+
+
+== Contributors
+
+Simone Carletti - documentation, bug hunting and various ideas
+Raphael Simon - error handling + filters design
+Nando Sola - lots of help
+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
+Rich Meyers - http://github.com/richmeyers
+Oleg Pudeyev - http://github.com/p
+Brett Anthoine - http://github.com/anb
+Matt Nichols - http://github.com/mattnichols
+Nicholas Faiz - http://github.com/biv
+Chris Beer - http://github.com/cbeer
+Enrico Bianco - http://github.com/enricob
+Andrew Timberlake - timeout 'at'
+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
+
+Juris Galang - https://github.com/jurisgalang (concurrence vs history issue)
+John 'jpgilman' - timed_out and name of the participant
+Pedro Texeira - add_tracker issue
+Greg Lazarev - composite storage issues
+Jan Topiński - https://github.com/simcha
+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
+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
+Francisco Kiko - many help
+David Goldhirsch - EM participant block
+dlamotte - set :val => nil
+jpr5 + asm
+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 )
+
+
+= 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, parslet gems, and many more.
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+
+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
+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,88 @@
+
+= 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
+
+grab ruote
+
+  gem install ruote
+  gem install yajl-ruby
+
+Note : the json gem has a serious bug :
+
+  http://github.com/flori/json/issues#issue/21
+
+So yajl-ruby is seriously recommended.
+
+Then
+
+  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/master/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
+