flor 0.15.0 → 0.16.0

data/lib/flor/core/procedure.rb

@@ -6,6 +6,14 @@ class Flor::Procedure < Flor::Node
   #
   RVARS = %w[ idx ]
 
+  # Attributes that when given alone are turned to "true" attributes.
+  #
+  # For example `sequence flank` gets turned to `sequence flank: true`
+  #
+  # The transformation occurs in Flor::Pro::Att ("_att").
+  #
+  TRUE_ATTS = %w[ flank off disabled ]
+
   class << self
 
     def inherited(subclass)
@@ -20,9 +28,12 @@ class Flor::Procedure < Flor::Node
 
     def names(*names)
 
-      names = names.flatten
-      @names = names if names.any?
-      @core = !! caller.find { |l| l.match(/flor\/pcore/) } if names.any?
+      @names = [] unless defined?(@names)
+
+      if (names = names.flatten).any?
+        @names = names
+        @core = !! caller.find { |l| l.match(/flor\/pcore/) }
+      end
 
       @names
     end
@@ -33,18 +44,11 @@ class Flor::Procedure < Flor::Node
 
     def make(executor, node, message)
 
-      heap = node['heat'] ? node['heap'] : nil
-
-      fail ArgumentError.new(
-        "cannot determine procedure " +
-        "#{{ heat: node['heat'], heap: node['heap'] }.inspect}"
-      ) unless heap
-
+      heap = node['heap']
       heac = self[heap]
 
-      fail NameError.new(
-        "unknown procedure #{heap.inspect}"
-      ) unless heac
+      fail NameError.new("unknown procedure #{heap.inspect}") \
+        unless heac
 
       heac.new(executor, node, message)
     end
@@ -55,9 +59,23 @@ class Flor::Procedure < Flor::Node
     # empty default implementation
   end
 
-  def prepare_on_receive_last(tree)
+  def prepare_on_receive_last(on_x, max=-1)
+
+    on_x
+      .inject([]) { |a, (criteria, mop)|
 
-    apply(tree.shift, [ @message ], tree[2])
+        next a if max > 0 && a.size >= max
+        next a unless match_on?(criteria)
+
+        msg = Flor.dup(@message)
+
+        a.concat(
+          if Flor.is_message?(mop)
+            [ Flor.dup(mop).merge!('msg' => msg) ]
+          else # procedure
+            args = [ [ 'msg', msg ], [ 'err', msg['error'] ] ]
+            apply(mop, args, mop[2])
+          end) }
   end
 
   def trigger_on_error
@@ -67,7 +85,7 @@ class Flor::Procedure < Flor::Node
     close_node('on-error')
 
     @node['on_receive_last'] =
-      apply(@node['on_error'].shift, [ @message, @message['error'] ], tree[2])
+      prepare_on_receive_last(@node['on_error'], 1)
 
     do_wrap_cancel_children ||
     do_receive # which should trigger 'on_receive_last'
@@ -94,7 +112,7 @@ class Flor::Procedure < Flor::Node
   def flank
 
     @node['tree'] = Flor.dup(tree)
-    @node['noreply'] = true
+    @node['replyto'] = nil
 
     wrap('nid' => parent, 'flavour' => 'flank')
   end
@@ -181,6 +199,15 @@ class Flor::Procedure < Flor::Node
     nil
   end
 
+  def atts(*keys)
+
+    return nil unless @node['atts']
+
+    @node['atts']
+      .select { |k, _| keys.include?(k == nil ? nil : k.to_s) }
+      .collect { |_, v| v }
+  end
+
   def has_att?(k)
 
     @node['atts'].collect(&:first).include?(k)
@@ -229,6 +256,14 @@ class Flor::Procedure < Flor::Node
     wrap(hh)
   end
 
+  def stays_an_att?(t)
+
+    t[1].length == 1 &&
+    t[1][0].is_a?(Array) &&
+    t[1][0][1] == [] &&
+    TRUE_ATTS.include?(t[1][0][0])
+  end
+
   def unatt_unkeyed_children(first_only=false)
 
     found = false
@@ -237,12 +272,13 @@ class Flor::Procedure < Flor::Node
       att_children.partition { |c|
         if found
           false
+        elsif stays_an_att?(c)
+          false
         else
           is_unkeyed = c[1].size == 1
           found = true if is_unkeyed && first_only
           is_unkeyed
-        end
-      }
+        end }
 
     unkeyed = unkeyed
       .collect { |c| c[1].first }
@@ -253,6 +289,28 @@ class Flor::Procedure < Flor::Node
     @node['tree'] = [ tree[0], cn, tree[2] ] if cn != children
   end
 
+  def rep_first_child
+
+    hd, cn, ln = tree
+
+    ri = cn.index { |ct| ct[0] == '_ref' || Flor.is_single_ref_tree?(ct) }
+
+    return unless ri
+
+    cn1 = cn.dup
+    rt = cn[ri]
+
+    cn1[ri] =
+      if rt[0] == '_ref'
+        [ '_rep', rt[1], rt[2] ]
+      else
+        s, _, l = rt
+        [ '_rep', [ [ '_sqs', s, l ] ], l ]
+      end
+
+    @node['tree'] = [ hd, cn1, ln ]
+  end
+
   def unatt_first_unkeyed_child
 
     unatt_unkeyed_children(true)
@@ -268,7 +326,9 @@ class Flor::Procedure < Flor::Node
     cn = Flor.dup(children)
     cn[ci] = [ '_sqs', c[0], c[2] ]
 
-    @node['tree'] = [ tree[0], cn, tree[2] ]
+    t = tree
+
+    @node['tree'] = [ t[0], cn, t[2] ]
   end
 
   def stringify_first_child
@@ -292,7 +352,7 @@ class Flor::Procedure < Flor::Node
     receive
   end
 
-  # The executor calls #do_receive, while most procedure implementations
+  # The executor calls #do_receive, while procedure implementations
   # override #receive...
   #
   def do_receive
@@ -302,15 +362,28 @@ class Flor::Procedure < Flor::Node
     from_child = nil
     from_child = cnodes.delete(from) if cnodes_any? && remove
 
-    if node_closed?
-      return receive_from_child_when_closed \
-        if from_child || node_status_flavour
-      return receive_when_closed
+    if di = @message['disable']
+      #
+      # the off: and the disable:/disabled: can achieve that
+
+      wrap_reply('disabled' => di)
+
+    elsif node_closed?
+
+      if from_child || node_status_flavour
+        receive_from_child_when_closed
+      else
+        receive_when_closed
+      end
+
     elsif node_ended?
-      return receive_when_ended
-    end
 
-    receive
+      receive_when_ended
+
+    else
+
+      receive
+    end
   end
 
   def message_cause
@@ -328,14 +401,6 @@ class Flor::Procedure < Flor::Node
 
     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 ???
@@ -359,7 +424,7 @@ class Flor::Procedure < Flor::Node
 
   def receive_from_child_when_closed
 
-    (cnodes.empty? && pop_on_receive_last) || wrap_reply
+    (cnodes_empty? && pop_on_receive_last) || wrap_reply
   end
 
   def receive_when_closed
@@ -380,7 +445,21 @@ class Flor::Procedure < Flor::Node
 
   def from_att?
 
-    @fcid && (c = children[@fcid]) && c[0] == '_att'
+    @fcid &&
+    Flor.same_branch?(nid, from) &&
+    (c = children[@fcid]) &&
+    c[0] == '_att'
+  end
+
+  def from_sub_nid
+
+    i = from.split('-')[1]
+    i ? i.to_i : false
+  end
+
+  def from_error_handler?
+
+    message['from_on_error'] == nid
   end
 
   def last_receive?
@@ -448,19 +527,25 @@ class Flor::Procedure < Flor::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']
+  def store_on(key, prc=payload['ret'], criteria=[ '*' ])
 
     return unless Flor.is_func_tree?(prc)
 
+    pnode =
+      @node; loop do
+        pnode = parent_node(pnode)
+        return unless pnode
+        break unless %w[ _if _unless ].include?(pnode['heap'])
+      end
+
     flavour = "on_#{key}"
 
     prc[1][flavour] = true
 
-    (pnode[flavour] ||= []) << prc
+    a = (pnode[flavour] ||= [])
+    i = a.index { |e| e[0] == criteria } || -1
+      #
+    a.insert(i, [ criteria, prc ])
   end
 
   # Used by 'cursor' (and 'loop') when
@@ -491,9 +576,17 @@ class Flor::Procedure < Flor::Node
     m = {}
     m['point'] = 'receive'
     m['exid'] = exid
-    m['nid'] = @node['noreply'] ? nil : parent
     m['from'] = nid
 
+    m['nid'] = # what node should receive this reply?
+      if @node['noreply'] # for backward compatibility 2018-10-29
+        nil
+      elsif @node.has_key?('replyto')
+        @node['replyto'] # nil or something like '0_1' or '0_2-4'
+      else
+        parent
+      end
+
     m['sm'] = @message['m']
 
     m['cause'] = @message['cause'] if @message.has_key?('cause')
@@ -587,43 +680,70 @@ class Flor::Procedure < Flor::Node
     r
   end
 
-  def set_var(mode, k, v)
+  def set_var(mode, path, v)
 
-    fail IndexError.new("cannot set domain variables") if mode == 'd'
+    fail IndexError.new(
+      'cannot set domain variables') if mode == 'd'
 
     begin
 
-      node = lookup_var_node(@node, mode, k)
-      node = lookup_var_node(@node, 'l', k) if node.nil? && mode == ''
+      node = lookup_var_node(@node, mode, path)
+      node = lookup_var_node(@node, 'l', path) if node.nil? && mode == ''
 
-      return Dense.set(node['vars'], k, v) if node
+      return Dense.set(node['vars'], path, v) if node
 
     rescue IndexError
     end
 
-    fail IndexError.new("couldn't set var #{mode}v.#{k}")
+    fail IndexError.new(
+      "couldn't set var #{Flor.path_to_s([ "#{mode}v" ] + path)}")
   end
 
-  def set_field(k, v)
+  def set_field(path, v)
 
-    Dense.set(payload.copy, k, v)
+    Dense.set(payload.copy, path, v)
 
   rescue IndexError
 
-    fail IndexError.new("couldn't set field #{k}")
+    fail IndexError.new(
+      "couldn't set field #{Flor.path_to_s(path)}")
+  end
+
+  def set_value(path, value)
+
+    path = Dense::Path.make(path).to_a if path.is_a?(String)
+#p [ path, '<-', value ]
+
+    if path.length < 2
+      set_var('', path, value)
+    else
+      case path.first
+      when /\Af(?:ld|ield)?\z/
+        set_field(path[1..-1], value)
+      when /\A([lgd]?)v(?:ar|ariable)?\z/
+        set_var($1, path[1..-1], value)
+      else
+        set_var('', path, value)
+      end
+    end
   end
 
-  def set_value(k, v)
+  def splat_value(paths, value)
+
+    val = value.dup
 
-    return if k == '_'
+    while pa = paths.shift
 
-    cat, mod, key = key_split(k)
+      pa = Dense::Path.make(pa).to_a if pa.is_a?(String)
 
-    case cat[0, 1]
-    when 'f' then set_field(key, v)
-    when 'v' then set_var(mod, key, v)
-    #when 'w' then set_war(key, v)
-    else fail IndexError.new("don't know how to set #{k.inspect}")
+      if m = pa.last.match(Flor::SPLAT_REGEX)
+        k, u = m[1, 2]
+        l = (u == '_') ? val.length - paths.length : u.to_i
+        set_value(pa[0..-2] + [ k ], val.take(l)) if k.length > 0
+        val = val.drop(l)
+      else
+        set_value(pa, val.shift)
+      end
     end
   end
 
@@ -639,35 +759,34 @@ class Flor::Procedure < Flor::Node
     cni = fun[1]['cnid'] # closure nid
 
     t = fun[1]['tree']
-    t = t || lookup_tree(fni) # TODO when fun[1]['tree'] is settled, drop me
+    #t = t || lookup_tree(fni) # TODO when fun[1]['tree'] is settled, drop me
     fail ArgumentError.new("couldn't find function at #{fni}") unless t
 
     t = t[0] if t[0].is_a?(Array)
     t = t[1][0] if t[0] == '_att'
 
-    sig = t[1].select { |c| c[0] == '_att' }
-    sig = sig.drop(1) if t[0] == 'define'
+    t[1][0][0] = '_name' if t[0] == 'define'
 
-    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]
-    end
+    #vars = opts[:vars] || {}
+    #vars['arguments'] = args # Should I dup? Dup upstream?
 
     ms = wrap(
       'point' => 'execute',
       'nid' => ani,
       'tree' => [ '_apply', t[1], line ],
-      'vars' => vars,
+      'arguments' => args,
       'cnid' => cni)
 
     if oe = fun[1]['on_error']
       ms.first['on_error'] = oe
     end
 
+    #if fs = opts[:fields]
+    #  ms.first['payload'].merge!(fs)
+    #end
+      #
+      # an idea from "sort" apply, may be useful later on...
+
     ms
   end
 
@@ -739,7 +858,7 @@ class Flor::Procedure < Flor::Node
   end
 
   # Handle an incoming cancel message when the node has closed.
-  # Open for override (overridden by "cursor" and "until")
+  # Open for override (overridden by "sequence", "cursor", and "until")
   #
   def cancel_when_closed