Class Ruote::Exp::FlowExpression
In: lib/ruote/exp/ro_attributes.rb
lib/ruote/exp/flowexpression.rb
lib/ruote/exp/ro_variables.rb
lib/ruote/exp/ro_persist.rb
Parent: Object

Reopening the FlowExpression class to add [un]persist methods.

Methods

ancestor?   apply_child   att   attribute   attribute_text   attributes   cancel   compile_atts   compile_variables   consider_tag   consider_timeout   determine_tos   do_action   do_apply   do_cancel   do_fail   do_p   do_persist   do_receive   do_reply   do_schedule_timeout   do_unpersist   expand_atts   fei   fetch   from_h   get_next_sub_wfid   h=   handle_on_error   has_att   has_attribute   initial_persist   iterative_var_lookup   launch_sub   locate_var   lookup_on_error   lookup_val   lookup_val_prefix   lookup_variable   lv   lval   name   names   new   parent   parent_id   persist   persist_or_raise   pre_apply_child   register_child   reply   reply_to_parent   s_cartesian   set_variable   split_prefix   supplant_with   to_dot   to_h   tree   tree_children   trigger   try_persist   try_unpersist   un_set_variable   unpersist   unpersist_or_raise   unset_variable   update_tree   v   variables  

Included Modules

Ruote::WithH Ruote::WithMeta

Constants

VV = %w[ val value ]
COMMON_ATT_KEYS = %w[ if unless forget timeout on_error on_cancel on_timeout ]
VAR_PREFIX_REGEX = /^(\/*)/

Attributes

context  [R] 
h  [R] 

Public Class methods

fetch(context, fei)

Fetches an expression from the storage and readies it for service.

from_h(context, h)

Instantiates expression back from hash.

names(*exp_names)

Keeping track of names and aliases for the expression

Public Instance methods

ancestor?(fei)

Returns true if the given fei points to an expression in the parent chain of this expression.

att(key, values, opts={})

Returns the value for attribute ‘key’, this value should be present in the array list ‘values’. If not, the default value is returned. By default, the default value is the first element of ‘values’.

attribute_text(workitem=h.applied_workitem)

Given something like 

  sequence do
    participant 'alpha'
  end

in the context of the participant expression 

  attribute_text()

will yield ‘alpha’.

cancel(flavour)

This default implementation cancels all the [registered] children of this expression.

compile_atts(opts={})

Returns a Hash containing all attributes set for an expression with their values resolved.

compile_variables()

Returns a fresh hash of all the variables visible from this expression.

This is used mainly when forgetting an expression.

do_cancel(msg)

The raw handling of messages passed to expressions (the fine handling is done in the cancel method).

do_receive(msg)

Alias for do_reply

expand_atts(opts={})

Like compile_atts, but the keys are expanded as well.

Useful for things like 

  set "f:${v:field_name}" => "${v:that_variable}"
get_next_sub_wfid()

Generates a sub_wfid, without hitting storage.

There‘s a better implementation for sure…

handle_on_error(msg, error)

Looks up parent with on_error attribute and triggers it

has_att(*args)

Alias for has_attribute

has_attribute(*args)

Given a list of attribute names, returns the first attribute name for which there is a value.

initial_persist()

Persists and fetches the _rev identifier from the storage.

Only used by the worker when creating the expression.

iterative_var_lookup(k)

TODO : redoc rewrite needed

This method is mostly used by the worker when looking up a process name or participant name bound under a variable.

lookup_on_error()

Looks up "on_error" attribute

lookup_val_prefix(prefix, att_options={})

prefix = ‘on’ => will lookup on, on_val, on_value, on_v, on_var, on_variable, on_f, on_fld, on_field…

lookup_variable(var, prefix=nil)

Looks up the value of a variable in expression tree (seen from a leaf, it looks more like a stack than a tree)

lv(var, prefix=nil)

Alias for lookup_variable

persist()

Alias for persist_or_raise

reply(workitem)

A default implementation for all the expressions.

set_variable(var, val)

Sets a variable to a given value. (will set at the appropriate level).

to_h()

Turns this FlowExpression instance into a Hash (well, just hands back the base hash behind it.

tree()

Returns the current version of the tree (returns the updated version if it got updated.

unpersist()

Alias for unpersist_or_raise

update_tree(t=nil)

Updates the tree of this expression 

  update_tree(t)

will set the updated tree to t 

  update_tree

will copy (deep copy) the original tree as the updated_tree.

Adding a child to a sequence expression : 

  seq.update_tree
  seq.updated_tree[2] << [ 'participant', { 'ref' => 'bob' }, [] ]
  seq.do_persist
v(var, prefix=nil)

Alias for lookup_variable

variables()

A shortcut to the variables held in the expression (nil if none held).

Protected Instance methods

locate_var(var, prefix=nil)

Returns the flow expression that owns a variable (or the one that should own it) and the var without its potential / prefixes.

split_prefix(var, prefix)

Used by lookup_variable and set_variable to extract the prefix in a variable name

supplant_with(tree, opts)

(Called by trigger_on_cancel & co)

trigger(on, workitem)

‘on_{error|timeout|cancel}’ triggering

un_set_variable(op, var, val, should_persist)

Sets (or unsets) the value of a local variable

val should be nil in case of ‘unset’.

[Validate]