= 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) - 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' --> - 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