flor 0.14.0 → 0.15.0

data/lib/flor/core/node.rb

@@ -27,6 +27,9 @@ class Flor::Node
     def copy_current
       Flor.dup(current)
     end
+    def dup_current
+      current ? current.dup : nil
+    end
     def merge(h)
       current.merge(h)
     end
@@ -45,9 +48,9 @@ class Flor::Node
 
     @executor, @execution =
       case executor
-        when nil then [ nil, nil ] # for some tests
-        when Hash then [ nil, executor ] # from some other tests
-        else [ executor, executor.execution ] # vanilla case
+      when nil then [ nil, nil ] # for some tests
+      when Hash then [ nil, executor ] # from some other tests
+      else [ executor, executor.execution ] # vanilla case
       end
 
     @node =
@@ -83,6 +86,9 @@ class Flor::Node
   def node_status
     @node['status'].last
   end
+  def node_status_flavour
+    node_status['flavour']
+  end
   def node_closed?
     node_status['status'] == 'closed'
   end
@@ -160,7 +166,7 @@ class Flor::Node
       lookup_field(mod, key_and_path)
     end
 
-  rescue IndexError
+  rescue KeyError, TypeError
 
     raise unless silence_index_error
     nil
@@ -174,6 +180,7 @@ class Flor::Node
 
       return @node.nid if k == 'nid'
       return @node.exid if k == 'exid'
+      return Flor.domain(@node.exid) if k == 'domain'
       return Flor.tstamp if k == 'tstamp'
 
       r = @node.lookup(k, true)
@@ -251,7 +258,7 @@ class Flor::Node
     nil
   end
 
-  def to_procedure
+  def to_procedure_node
 
     Flor::Procedure.new(@executor, @node, @message)
   end
@@ -316,12 +323,12 @@ class Flor::Node
 
   def lookup_in_node(pth)
 
-    Flor.deep_get(@node, pth)
+    Dense.fetch(@node, pth)
   end
 
   class PseudoVarContainer < Hash
     #
-    # inherit from Hash so that deep.rb is quietly mislead
+    # inherit from Hash so that Dense is quietly mislead
     #
     def initialize(type); @type = type; end
     #def has_key?(key); true; end
@@ -331,23 +338,33 @@ class Flor::Node
   PROC_VAR_CONTAINER = PseudoVarContainer.new('proc')
   TASKER_VAR_CONTAINER = PseudoVarContainer.new('task')
 
+  def escape(k)
+
+    case k
+    when '*', '.' then "\\#{k}"
+    else k
+    end
+  end
+
   def lookup_var(node, mod, key, pth)
 
     c = lookup_var_container(node, mod, key)
 
     kp = [ key, pth ].reject { |x| x == nil || x.size < 1 }.join('.')
+    kp = escape(kp)
 
-    v = Flor.deep_get(c, kp)
-#p [ mod, key, pth, '->', v ]
+    Dense.fetch(c, kp)
 
-    return v unless v.is_a?(Symbol)
+  rescue KeyError => ke
 
-    vs = v.to_s.split('.')
-    tail = vs.pop
-    vs = vs.join('.')
+    return nil if ke.miss[4].empty?
 
-    fail IndexError.new("variable #{tail.inspect} not found") if vs.empty?
-    fail IndexError.new("no key #{tail.inspect} in variable #{vs.inspect}")
+    m = "variable #{ke.miss[3].inspect} not found"
+    m += " at #{Dense::Path.make(ke.miss[1]).to_s.inspect}" if ke.miss[1].any?
+
+    raise ke.relabel(m)
+
+  #rescue TypeError => te # leave as is
   end
 
   def lookup_var_container(node, mod, key)
@@ -420,8 +437,11 @@ class Flor::Node
 
   def lookup_field(mod, key_and_path)
 
-    r = Flor.deep_get(payload.current, key_and_path)
-    r.is_a?(Symbol) ? nil : r
+    Dense.fetch(payload.current, key_and_path)
+
+  rescue IndexError
+
+    nil
   end
 
   def key_split(key) # => category, mode, key
@@ -429,9 +449,6 @@ class Flor::Node
     m = key.match(
       /\A(?:([lgd]?)((?:v|var|variable)|w|f|fld|field|t|tag)\.)?(.+)\z/)
 
-    #fail ArgumentError.new("couldn't split key #{key.inspect}") unless m
-      # spare that
-
     ca = (m[2] || 'v')[0, 1]
     mo = m[1] || ''
     ke = m[3]

data/lib/flor/core/procedure.rb

@@ -1,6 +1,11 @@
 
 class Flor::Procedure < Flor::Node
 
+  # "Returning vars" variables to pass back to pass upon reply.
+  # In the 'receive' messages, it's a hash under the key 'rvars'.
+  #
+  RVARS = %w[ idx ]
+
   class << self
 
     def inherited(subclass)
@@ -50,6 +55,11 @@ class Flor::Procedure < Flor::Node
     # empty default implementation
   end
 
+  def prepare_on_receive_last(tree)
+
+    apply(tree.shift, [ @message ], tree[2])
+  end
+
   def trigger_on_error
 
     @message['on_error'] = true
@@ -57,7 +67,7 @@ class Flor::Procedure < Flor::Node
     close_node('on-error')
 
     @node['on_receive_last'] =
-      apply(@node['on_error'].shift, [ @message ], tree[2])
+      apply(@node['on_error'].shift, [ @message, @message['error'] ], tree[2])
 
     do_wrap_cancel_children ||
     do_receive # which should trigger 'on_receive_last'
@@ -68,7 +78,7 @@ class Flor::Procedure < Flor::Node
     nid ||= self.nid
     tree = lookup_tree(nid)
 
-    Flor.print_tree(tree, nid)
+    puts Flor.tree_to_s(tree, nid)
   end
 
   def debug_msg(msg=message)
@@ -89,6 +99,8 @@ class Flor::Procedure < Flor::Node
     wrap('nid' => parent, 'flavour' => 'flank')
   end
 
+  def heap; @node['heap']; end
+
   protected
 
   def counter_next(k)
@@ -136,6 +148,11 @@ class Flor::Procedure < Flor::Node
     children.select { |c| c[0] != '_att' }
   end
 
+  def non_att_count
+
+    non_att_children.size
+  end
+
   def unkeyed_children
 
     children.select { |c| c[0] != '_att' || c[1].size == 1 }
@@ -171,12 +188,16 @@ class Flor::Procedure < Flor::Node
 
   def att_a(*keys)
 
-    if keys.last == nil
-      keys.pop
-      Flor.to_a(att(*keys))
-    else
-      Array(att(*keys))
-    end
+    a =
+      if keys.last == nil
+        keys.pop
+        Flor.to_a(att(*keys))
+      else
+        Array(att(*keys))
+      end
+
+    return [ a ] if Flor.is_regex_tree?(a)
+    a
   end
 
   def tags_to_nids(tags)
@@ -225,7 +246,7 @@ class Flor::Procedure < Flor::Node
 
     unkeyed = unkeyed
       .collect { |c| c[1].first }
-      .reject { |c| c[0] == '_' && c[1] == [] }
+      #.reject { |c| c[0] == '_' && c[1] == [] }
 
     cn = keyed + unkeyed + non_att_children
 
@@ -282,7 +303,8 @@ class Flor::Procedure < Flor::Node
     from_child = cnodes.delete(from) if cnodes_any? && remove
 
     if node_closed?
-      return receive_from_child_when_closed if from_child
+      return receive_from_child_when_closed \
+        if from_child || node_status_flavour
       return receive_when_closed
     elsif node_ended?
       return receive_when_ended
@@ -291,6 +313,12 @@ class Flor::Procedure < Flor::Node
     receive
   end
 
+  def message_cause
+
+    (@message['cause'] || [])
+      .find { |c| c['nid'] == nid }
+  end
+
   def pop_on_receive_last
 
     orl = @node['on_receive_last']
@@ -298,7 +326,22 @@ class Flor::Procedure < Flor::Node
     return nil unless orl
     return nil if orl.empty?
 
-    open_node unless node_status['flavour'] == 'on-error'
+    c = message_cause
+
+#puts "<<<"
+##p @message
+##p @message['cause']
+#p node_status
+##p @node['on_error']
+#p c
+##puts caller[0, 3]
+#puts ">>>"
+    open_node \
+      unless
+        (node_status_flavour == 'on-error') || # TODO use the cause ???
+        (c && c['cause'] == 'cancel' && @node['on_cancel']) ||
+        (c && c['cause'] == 'timeout' && @node['on_timeout'])
+
     @node['on_receive_last'] = []
 
     @node['mtime'] = Flor.tstamp
@@ -340,6 +383,11 @@ class Flor::Procedure < Flor::Node
     @fcid && (c = children[@fcid]) && c[0] == '_att'
   end
 
+  def last_receive?
+
+    children[@ncid] == nil
+  end
+
   def receive
 
     determine_fcid_and_ncid
@@ -369,10 +417,21 @@ class Flor::Procedure < Flor::Node
     execute_child(@ncid)
   end
 
+  # Prepare incoming ret for storage in @node['ret'] or @node['rets']
+  #
+  def receive_payload_ret
+
+    Flor.dup(payload['ret'])
+  end
+
   def receive_non_att
 
+    if @node.has_key?('ret')
+      @node['ret'] = receive_payload_ret
+      @node['mtime'] = Flor.tstamp
+    end
     if @node['rets']
-      @node['rets'] << Flor.dup(payload['ret'])
+      @node['rets'] << receive_payload_ret
       @node['mtime'] = Flor.tstamp
     end
 
@@ -385,6 +444,25 @@ class Flor::Procedure < Flor::Node
     wrap_reply
   end
 
+  # Grab on_error proc from incoming payload and stores it into parent node.
+  #
+  # Has no effect if there is no parent node.
+  #
+  def store_on(key, prc=nil)
+
+    pnode = parent_node; return unless pnode
+
+    prc ||= payload['ret']
+
+    return unless Flor.is_func_tree?(prc)
+
+    flavour = "on_#{key}"
+
+    prc[1][flavour] = true
+
+    (pnode[flavour] ||= []) << prc
+  end
+
   # Used by 'cursor' (and 'loop') when
   # ```
   # cursor 'main'
@@ -418,6 +496,8 @@ class Flor::Procedure < Flor::Node
 
     m['sm'] = @message['m']
 
+    m['cause'] = @message['cause'] if @message.has_key?('cause')
+
     ret =
       if @node.has_key?('aret') # from the 'ret' common attribute
         @node['aret']
@@ -427,12 +507,21 @@ class Flor::Procedure < Flor::Node
         :no
       end
 
-    m['payload'] = payload.current
+    m['payload'] = payload.dup_current
 
     m.merge!(h)
 
     m['payload']['ret'] = ret if ret != :no
 
+    if vs = @node['vars']
+      (RVARS & vs.keys).each { |k| (m['rvars'] ||= {})[k] = vs[k] }
+    end
+      #
+      # initially for "cmap"
+      #
+      # was considering passing the whole vars back (as 'varz'), but
+      # it got in the way... and it might be heavy
+
     [ m ]
   end
 
@@ -467,11 +556,11 @@ class Flor::Procedure < Flor::Node
 
     if vars
       return node if mode == 'l'
-      return node if mode == '' && Flor.deep_has_key?(vars, k)
+      return node if mode == '' && Dense.has_key?(vars, k)
     end
 
     if cnode = mode == '' && @execution['nodes'][node['cnid']]
-      return cnode if Flor.deep_has_key?(cnode['vars'], k)
+      return cnode if Dense.has_key?(cnode['vars'], k)
     end
 
     par = parent_node(node)
@@ -482,18 +571,34 @@ class Flor::Procedure < Flor::Node
     nil
   end
 
+  # List all the tags the current node is "included" in.
+  #
+  def list_tags
+
+    r = []
+    n = @node
+
+    while n
+      ts = n['tags']
+      r.concat(ts) if ts
+      n = @execution['nodes'][n['parent']]
+    end
+
+    r
+  end
+
   def set_var(mode, k, v)
 
     fail IndexError.new("cannot set domain variables") if mode == 'd'
 
-    node = lookup_var_node(@node, mode, k)
-    node = lookup_var_node(@node, 'l', k) if node.nil? && mode == ''
+    begin
 
-    if node
+      node = lookup_var_node(@node, mode, k)
+      node = lookup_var_node(@node, 'l', k) if node.nil? && mode == ''
 
-      v = Flor.deep_set(node['vars'], k, v)
+      return Dense.set(node['vars'], k, v) if node
 
-      return v unless v.is_a?(Symbol)
+    rescue IndexError
     end
 
     fail IndexError.new("couldn't set var #{mode}v.#{k}")
@@ -501,11 +606,11 @@ class Flor::Procedure < Flor::Node
 
   def set_field(k, v)
 
-    value = Flor.deep_set(payload.copy, k, v)
+    Dense.set(payload.copy, k, v)
 
-    fail IndexError.new("couldn't set field #{k}") if value.is_a?(Symbol)
+  rescue IndexError
 
-    value
+    fail IndexError.new("couldn't set field #{k}")
   end
 
   def set_value(k, v)
@@ -522,7 +627,10 @@ class Flor::Procedure < Flor::Node
     end
   end
 
-  def apply(fun, args, line, anid=true)
+  def apply(fun, args, line, opts={})
+
+    anid = opts.has_key?(:anid) ? opts[:anid] : true
+      # true => generate sub_nid
 
     fni = fun[1]['nid'] # fun nid
     ani = anid ? Flor.sub_nid(fni, counter_next('subs')) : fni
@@ -540,8 +648,10 @@ class Flor::Procedure < Flor::Node
     sig = t[1].select { |c| c[0] == '_att' }
     sig = sig.drop(1) if t[0] == 'define'
 
-    vars = {}
+    vars = opts[:vars] || {}
+      #
     vars['arguments'] = args # should I dup?
+      #
     sig.each_with_index do |att, i|
       key = att[1].first[0]
       vars[key] = args[i]
@@ -570,9 +680,7 @@ class Flor::Procedure < Flor::Node
 
   def wrap_cancelled
 
-    wrap(
-      'cause' => 'cancel',
-      'payload' => @message['payload'] || @node['payload'])
+    wrap('payload' => @message['payload'] || @node['payload'])
   end
 
   def wrap_cancel_children(h={})
@@ -585,37 +693,68 @@ class Flor::Procedure < Flor::Node
     wrap_cancel_children(h).instance_eval { |ms| ms.any? ? ms : nil }
   end
 
-  # The executor calls #do_cancel, while most procedure implementations
-  # override #cancel...
+  # Called by the executor, in turns call cancel and cancel_when_ methods
+  # which may be overriden.
   #
   def do_cancel
 
-    if @message['flavour'] == 'kill'
+    if orl = @message['on_receive_last']
+      #
+      # the message on_receive_last is used by the re_apply feature
+
+      @node['on_receive_last'] = orl
 
-      return [] if node_ended?
-      kill
+    elsif @message['flavour'] == 'timeout' && ot = @node['on_timeout']
 
-    else
+      @node['on_receive_last'] = prepare_on_receive_last(ot)
 
-      orl = @message['on_receive_last']
-      @node['on_receive_last'] = orl if orl
+    elsif oc = @node['on_cancel']
 
-      return cancel_when_ended if node_ended?
-      return cancel_when_closed if node_closed?
-      cancel
+      @node['on_receive_last'] = prepare_on_receive_last(oc)
     end
+
+    return cancel_when_ended if node_ended?
+    return cancel_when_closed if node_closed?
+
+    cancel
+  end
+
+  # Called by the executor, in turns call kill and kill_when_ methods
+  # which may be overriden.
+  #
+  def do_kill
+
+    return kill_when_ended if node_ended?
+    #return kill_when_closed if node_closed? # nothing of the sort
+
+    kill
   end
 
+  # Handle an incoming cancel message when the node has ended.
+  # Open for override.
+  #
   def cancel_when_ended
 
     [] # node has already emitted reply to parent, ignore any later request
   end
 
+  # Handle an incoming cancel message when the node has closed.
+  # Open for override (overridden by "cursor" and "until")
+  #
   def cancel_when_closed
 
     [] # by default, no effect
   end
 
+  # When the node has ended, incoming kill messages are silenced ([] return).
+  #
+  def kill_when_ended
+
+    [] # no effect
+  end
+
+  # The core cancel work, is overriden by some procedure implementations.
+  #
   def cancel
 
     close_node
@@ -625,6 +764,9 @@ class Flor::Procedure < Flor::Node
     wrap_cancelled
   end
 
+  # The core kill work, open for override, but actually no procedure
+  # provides a custom implementation. Kill is kill for every of the procs.
+  #
   def kill
 
     close_node
@@ -645,7 +787,7 @@ class Flor::Macro < Flor::Procedure
   def rewrite
 
     t = rewrite_tree
-#Flor.print_tree(t, nid)
+#puts Flor.tree_to_s(t, nid)
 
     m = @message.dup
     m['tree'] = t