flor 0.16.1 → 0.16.2

data/lib/flor/pcore/collect.rb

@@ -38,7 +38,7 @@ class Flor::Pro::Collect < Flor::Macro::Iterator
   #
   # ## see also
   #
-  # Map, cmap, ccollect.
+  # Map, c_map, c_collect.
 
   name 'collect'
 

data/lib/flor/pcore/cursor.rb

@@ -30,7 +30,7 @@ class Flor::Pro::Cursor < Flor::Procedure
   #   sales_team "fill in customer details"
   #   ops_team "attribute account number"
   #   continue _ if f.ops_decision == 'reject'
-  #   create_account
+  #   create_account _
   # ```
   #
   # ## move

data/lib/flor/pcore/define.rb

@@ -50,7 +50,19 @@ class Flor::Pro::Define < Flor::Procedure
 
   def receive_att
 
-    t = flatten_tree
+    t, sig = flatten_tree
+
+    bad_param =
+      sig.inject(nil) { |r, a|
+        a10 = a[1][0]
+        pa = a10[0] == '_ref' && a10[1].size > 1 && a10[1].collect { |e| e[1] }
+        break pa.join('.') if pa && ! pa[0].match(/\A(f|fld|field)\z/)
+        nil }
+
+    fail Flor::FlorError.new(
+      "cannot accept #{bad_param.inspect} as parameter", self
+    ) if bad_param
+
     cnode = lookup_var_node(@node, 'l')
     cnid = cnode['nid']
     fun = counter_next('funs') - 1
@@ -79,16 +91,22 @@ class Flor::Pro::Define < Flor::Procedure
 
   def flatten_tree
 
+#puts "== tree"
+#pp tree
+    tre = tree
     off = heap == 'define' ? 1 : 0
-    sig = tree[1][off..-1].select { |t| t[0] == '_att' }
+    sig = tre[1][off..-1].select { |t| t[0] == '_att' }
+#puts "sig: " + sig.inspect
+#p sig[0][0]
+#p sig[0][1][0]
 
-    return tree if sig.all? { |a| a[1][0][1] == [] }
+    return [ tre, sig ] unless wrapped?(sig)
 
     # There is a parenthese around the parameters, let's unwrap that...
 
-    hed = Flor.dup(tree[1][0, off])
+    hed = Flor.dup(tre[1][0, off])
     sig = Flor.dup(sig)
-    bdy = Flor.dup(tree[1][(off + sig.length)..-1])
+    bdy = Flor.dup(tre[1][(off + sig.length)..-1])
 
     att0 = sig[0][1][0]
     att0atts = att0[1]
@@ -96,7 +114,15 @@ class Flor::Pro::Define < Flor::Procedure
 
     sig = sig + att0atts
 
-    [ heap, hed + sig + bdy, *tree[2..-1] ]
+    [ [ heap, hed + sig + bdy, *tre[2..-1] ],
+      sig ]
+  end
+
+  def wrapped?(sig)
+
+    return false if sig.length != 1
+    return false if sig[0][1][0][0] == '_ref'
+    sig[0][1][1] != []
   end
 end
 

data/lib/flor/pcore/iterator.rb

@@ -26,6 +26,18 @@ class Flor::Pro::Iterator < Flor::Procedure
     end
   end
 
+  def add
+
+    elts = message['elements']
+
+    elts = elts.inject([]) { |a, e| a.concat(e.to_a) } \
+      if @node['ocol'].is_a?(Hash)
+
+    @node['col'].concat(elts)
+
+    [] # no new messages to queue
+  end
+
   protected
 
   def receive_argument

data/lib/flor/pcore/on_cancel.rb

@@ -44,7 +44,7 @@ class Flor::Pro::OnCancel < Flor::Procedure
     unatt_unkeyed_children
   end
 
-  def receive_non_att
+  def receive_last
 
     store_on(:cancel)
 

data/lib/flor/pcore/set.rb

@@ -9,6 +9,7 @@ class Flor::Pro::Set < Flor::Procedure
   #   set a false      # sets the `false` in the variable 'a'
   #   set v.b [ 1 2 ]  # sets `[ 1, 2 ]` in the variable 'b'
   #   set v.c.0 -1     # sets `-1` in first slot of the array in var 'c'
+  #   set v.a f.a.0    # copy the value in field 'a' (first elt) into var 'a'
   # ```
   #
   # When set has a single child, it uses as value to copy the content of
@@ -27,6 +28,15 @@ class Flor::Pro::Set < Flor::Procedure
   #
   # ## splat
   #
+  # There is a splat system using underscores to extract array values and
+  # assign them to variables.
+  #
+  # 3 underscores following a variable name instructs "set" to place
+  # as many values as possible into an array under the given variable name.
+  # 2 underscores following a variable name and followed by an integer
+  # restrict the number of values thus globbed.
+  # Underscores following nothing simply discard the array values.
+  #
   # ```
   # sequence
   #   set a b___ c
@@ -56,10 +66,10 @@ class Flor::Pro::Set < Flor::Procedure
   # value set by its last child (usually the value set).
   #
   # ```
-  #   sequence
-  #     123         # payload.ret is set to `123`
-  #     set a 456   # var 'a' is set to 456, payload.ret is reset to `123`
-  #     setr b 789  # var 'b' is set to `789`, payload.ret as well
+  # sequence
+  #   123         # payload.ret is set to `123`
+  #   set a 456   # var 'a' is set to 456, payload.ret is reset to `123`
+  #   setr b 789  # var 'b' is set to `789`, payload.ret as well
   # ```
 
   names %w[ set setr ]

data/lib/flor/punit/{ccollect.rb → c_collect.rb}

@@ -28,9 +28,9 @@ class Flor::Pro::Ccollect < Flor::Macro::Iterator
   #
   # ## see also
   #
-  # Collect, map, cmap.
+  # Collect, map, c-map.
 
-  name 'ccollect'
+  names %w[ ccollect c-collect ]
 
   def rewrite_tree
 

data/lib/flor/punit/c_each.rb

@@ -0,0 +1,11 @@
+
+class Flor::Pro::Ceach < Flor::Macro::Iterator
+
+  names %w[ ceach c-each ]
+
+  def rewrite_tree
+
+    rewrite_iterator_tree('c-for-each')
+  end
+end
+

data/lib/flor/punit/c_for_each.rb

@@ -0,0 +1,41 @@
+
+require 'flor/punit/c_iterator'
+
+
+class Flor::Pro::CforEach < Flor::Pro::ConcurrentIterator
+  #
+  # Concurrent "for-each", launches a concurrent branch for each elt or entry
+  # of the incoming collection.
+  #
+  # ```
+  # c-for-each [ 'alice' 'bob' 'charly' ]
+  #   def user \ task user 'contact customer group'
+  #     #
+  #     # is thus equivalent to
+  #     #
+  # task 'alice' 'contact customer group'
+  # task 'bob' 'contact customer group'
+  # task 'charly' 'contact customer group'
+  # ```
+  #
+  # By default, the incoming `f.ret` collection is used:
+  # ```
+  # [ 'alice' 'bob' 'charly' ]
+  # c-for-each
+  #   def user \ task user 'contact customer group'
+  # ```
+  #
+  # ## see also
+  #
+  # For-each, cmap, and ceach.
+
+  name 'c-for-each'
+
+  protected
+
+  def post_merge
+
+    @node['merged_payload'].merge!('ret' => @node['col'])
+  end
+end
+

data/lib/flor/punit/c_iterator.rb

@@ -0,0 +1,160 @@
+
+require 'flor/punit/m_ram'
+
+
+# Parent class for "c-for-each" and "c-map"
+#
+class Flor::Pro::ConcurrentIterator < Flor::Procedure
+
+  include Flor::Pro::ReceiveAndMerge
+
+  def pre_execute
+
+    @node['atts'] = []
+    @node['args'] = []
+    @node['col'] = nil
+
+    reff_att_children
+    unatt_unkeyed_children
+  end
+
+  def receive_non_att
+
+    if Flor.same_sub?(nid, from)
+      @node['args'] << payload['ret']
+      super
+    elsif @node['on_receive_nids'] && @node['on_receive_nids'][0] == from
+      receive_from_receiver
+    elsif @node['merging']
+      receive_from_merger
+    else
+      receive_from_branch
+    end
+  end
+
+  def receive_last
+
+    t1 = tree[1]
+
+    col = nil
+    fun = nil
+    refs = []
+      #
+    @node['args'].each_with_index do |a, i|
+      if ( ! fun) && Flor.is_func_tree?(a)
+        fun = a
+      elsif ( ! col) && Flor.is_collection?(a)
+        col = a
+      else
+        tt = t1[i]
+        refs << Flor.ref_to_path(tt) if Flor.is_ref_tree?(tt)
+      end
+    end
+      #
+    col ||= node_payload_ret
+
+    fail Flor::FlorError.new("collection not given to #{heap.inspect}", self) \
+      unless Flor.is_collection?(col)
+    return wrap('ret' => col) \
+      unless Flor.is_func_tree?(fun)
+
+    @node['col'] = col
+    @node['cnt'] = col.size
+    @node['fun'] = fun
+    @node['refs'] = refs
+
+    col
+      .collect
+      .with_index { |e, i|
+        apply(fun, determine_iteration_args(col, i), tree[2]) }
+      .flatten(1)
+  end
+
+  def add
+
+    col = @node['col']
+    elts = message['elements']
+
+    fail Flor::FlorError.new(
+      "cannot add branches to #{heap}", self
+    ) unless elts
+
+    tcol = Flor.type(col)
+
+    x =
+      if tcol == :object
+        elts.inject(nil) { |r, e|
+          next r if r
+          t = Flor.type(e)
+          t != :object ? t : r }
+      else
+        nil
+      end
+    fail Flor::FlorError.new("cannot add #{x} to object", self) \
+      if x
+
+    if tcol == :array
+      col.concat(elts)
+    else # tcol == :object
+      elts.each { |e| col.merge!(e) }
+    end
+
+    cnt = @node['cnt']
+    @node['cnt'] += elts.size
+
+    pl = message['payload'] || node_payload.current
+
+    elts
+      .collect
+      .with_index { |e, i|
+        apply(
+          @node['fun'], determine_iteration_args(col, cnt + i), tree[2],
+          payload: Flor.dup(pl)) }
+      .flatten(1)
+  end
+
+  protected
+
+  def branch_count
+
+    @node['col'].size
+  end
+
+  def determine_iteration_args(col, idx)
+
+    refs = @node['refs'].dup
+
+    args =
+      if col.is_a?(Array)
+        [ [ refs.shift || 'elt', col[idx] ] ]
+      else
+        e = col.to_a[idx]
+        [ [ refs.shift || 'key', e[0] ], [ refs.shift || 'val', e[1] ] ]
+      end
+    args << [ refs.shift || 'idx', idx ]
+    args << [ refs.shift || 'len', col.length ]
+
+    args
+  end
+
+    # TODO: eventually move me up to Flor::Procedure, as Flor::Iterator might
+    #       use me
+    #
+  def reff_att_children
+
+    t = tree
+    t1 = t[1]
+
+    is = t1.each.with_index.inject([]) { |a, (tt, i)|
+      a << i \
+        if tt[0] == '_att' && tt[1].size == 1 && Flor.is_ref_tree?(tt[1][0])
+      a }
+
+    return if is.empty?
+
+    is.each { |i| t1[i][1][0][0] = '_reff' }
+
+    @node['tree'] = [ t[0], t1, *t[2..-1] ]
+  end
+end
+

data/lib/flor/punit/c_map.rb

@@ -0,0 +1,43 @@
+
+require 'flor/punit/c_iterator'
+
+
+class Flor::Pro::Cmap < Flor::Pro::ConcurrentIterator
+  #
+  # Concurrent version of "map". Spins a concurrent child for each
+  # element of the incoming/argument collection.
+  #
+  # ```
+  # cmap [ 1 2 3 ]
+  #   def x \ * x 2
+  # # yields: [ 2, 4, 6 ]
+  #
+  # [ 1 2 3 ]
+  # cmap (def x \ * x 2)
+  # # yields: [ 2, 4, 6 ]
+  #
+  # define double x \ * x 2
+  # cmap double [ 1 2 3 ]
+  # # yields: [ 2, 4, 6 ]
+  # ```
+  #
+  # "cmap" is over when all the children have answered. For more complex
+  # concurrent behaviours, look at [concurrence](concurrence.md).
+  #
+  # ## see also
+  #
+  # Map, concurrence.
+
+  names %w[ cmap c-map ]
+
+  protected
+
+  def post_merge
+
+    @node['merged_payload'].merge!(
+      'ret' => @node['payloads']
+        .sort_by { |k, v| k.split('-').last }
+        .collect { |_, v| v['ret'] })
+  end
+end
+

data/lib/flor/punit/concurrence.rb

@@ -1,4 +1,7 @@
 
+require 'flor/punit/m_ram'
+
+
 class Flor::Pro::Concurrence < Flor::Procedure
   #
   # Executes its children concurrently.
@@ -144,7 +147,7 @@ class Flor::Pro::Concurrence < Flor::Procedure
   #   + 56 78
   # ```
   #
-  # ## on_merge: / merger:
+  # ## on_merge: / merger: / merge:
   #
   # the function given to `on_merge:` or `merger:` is called once the
   # concurrence has gathered enough replies (or the right replies,
@@ -180,6 +183,25 @@ class Flor::Pro::Concurrence < Flor::Procedure
   # * _branch_count_ simply contains the count of branches. It should be
   #   superior or equal to the size of _rets_ and _replies_.
   #
+  # ### merge: and string values
+  #
+  # By default, the merge technique is a deep merge favouring the first
+  # branches to reply. By passing a string value to merge:/merger:/on_merge:
+  # one can select a different merge technique.
+  #
+  # * "first" (the default) - the first branch to reply has priority in the deep  #   merge
+  # * "last" - the last branch to reply has priority in the deep merge
+  # * "top" or "north" - the branch are prioritized in the order they are
+  #   in the flow definition
+  # * "bottom" or "south" - the branch are prioritized in the reverse order of
+  #   the flow definition
+  #
+  # Adding "plain" (for example "south plain") tells the "concurrence" not to
+  # use a deep merge but the plain/vanilla merge found in Ruby.
+  #
+  # "north plain" can be abbreviated to "np", "bottom" to "b", "first plain" to
+  # "fp", etc...
+  #
   # ## on_merge (non-attribute)
   #
   # Like `receiver:` / `:on_receive` has the `on_receive` construct, there
@@ -271,15 +293,13 @@ class Flor::Pro::Concurrence < Flor::Procedure
   #   push l 2
   # ```
 
+  include Flor::Pro::ReceiveAndMerge
+
   name 'concurrence'
 
   def pre_execute
 
     @node['atts'] = []
-    @node['payloads'] = {}
-
-    @node['on_receive_nids'] = nil
-    @node['on_receive_queue'] = []
 
     pre_execute_rewrite
   end
@@ -288,20 +308,11 @@ class Flor::Pro::Concurrence < Flor::Procedure
 
     return wrap_reply unless children[@ncid]
 
-    @node['receiver'] = determine_receiver
-    @node['merger'] = determine_merger
-
-
     branches = (@ncid..children.size - 1).to_a
     @node['branch_count'] = branches.count
 
-    coe = att('children_on_error', 'child_on_error')
-      # might be nil
-
     branches
-      .map { |i|
-        execute_child(
-         i, 0, 'payload' => payload.copy_current, 'on_error_handler' => coe) }
+      .map { |i| execute_child(i, 0, 'payload' => payload.copy_current) }
       .flatten(1)
         #
         # call execute for each of the (non _att) children
@@ -323,202 +334,34 @@ class Flor::Pro::Concurrence < Flor::Procedure
     end
   end
 
-  protected
-
-
-  def receive_from_child_when_closed
-
-    ms = receive
-
-    return [] if ms.empty?
-
-    pop_on_receive_last || ms
-  end
-
-  def receive_from_branch
-
-    @node['payloads'][from] = @message['payload']
-
-    apply_receiver
-  end
-
-  def apply_receiver
-
-    if @node['receiver'].is_a?(String)
-      apply_receiver_method
-    else
-      apply_receiver_function
-    end
-  end
-
-  def apply_receiver_method
-
-    ret = send('rm__' + @node['receiver'])
-    msg = { 'payload' => { 'ret' => ret } }
-
-    receive_from_receiver(msg)
-  end
-
-  def apply_receiver_function
-
-    @node['on_receive_queue'] << from
-
-    dequeue_receiver_function
-  end
-
-  def dequeue_receiver_function
-
-    if @node['on_receive_nids']
-      []
-    elsif f = @node['on_receive_queue'].shift
-      ms = apply(@node['receiver'], receiver_args(f), tree[2])
-      @node['on_receive_nids'] = [ ms.first['nid'], f ]
-      ms
-    else
-      []
-    end
-  end
-
-  def receiver_args(from)
-
-    rs = Flor.dup(@node['payloads'])
-
-    [ [ 'reply', rs[from] ],
-      [ 'from', from ],
-      [ 'replies', rs ],
-      [ 'branch_count', @node['branch_count'] ],
-      [ 'over', !! @node['over'] ] ]
-  end
-
-  def receive_from_receiver(msg=message)
-
-    ret = msg['payload']['ret']
-    over = @node['over']
-
-    if ret.is_a?(Hash) && ret.keys == %w[ done payload ]
-      over = over || ret['done']
-      from = @node['on_receive_nids'][1]
-      @node['payloads'][from] = ret['payload']
-    else
-      over = over || ret
-    end
-
-    @node['on_receive_nids'] = nil
-
-    just_over = over && ! @node['over']
-
-    @node['over'] ||= just_over
-
-    if just_over
-      apply_merger
-    elsif ! over
-      [] # wait for more branches
-    else
-      receive_from_merger(nil)
-    end +
-    dequeue_receiver_function
-  end
-
-  def apply_merger
-
-    if @node['merger'].is_a?(String)
-      apply_merger_method
-    else
-      apply_merger_function
-    end
-  end
-
-  def apply_merger_method
+  def add
 
-    pld = send('mm__' + @node['merger'])
-    msg = { 'payload' => pld }
+    super
 
-    receive_from_merger(msg)
-  end
+    i = Flor.child_id(message['tnid'])
+    ts = message['trees']
 
-  def apply_merger_function
+    @node['branch_count'] += ts.size
 
-    apply(@node['merger'], merger_args, tree[2])
-  end
-
-  def merger_args
-
-    rs = Flor.dup(@node['payloads'])
-
-    [ [ 'rets', rs.inject({}) { |h, (k, v)| h[k] = v['ret']; h } ],
-      [ 'replies', rs ],
-      [ 'branch_count', @node['branch_count'] ] ]
-  end
-
-  def receive_from_merger(msg=message)
-
-    pl = msg ? msg['payload'] : {}
-    ret = pl['ret']
-
-    pl = ret['payload'] \
-      if ret.is_a?(Hash) && ret.keys == %w[ done payload ]
-
-    # TODO somehow, what if done is false, should we un-over the concurrence?
-
-    @node['merged_payload'] = pl \
-      if msg && ! @node.has_key?('merged_payload')
-
-    rem = determine_remainder
-
-    cancel_children(rem) + reply_to_parent(rem)
-  end
-
-  def rm__default_receive
-
-    @node['payloads'].size >= non_att_count
-  end
-
-  def rm__expect_integer_receive
-
-    @node['payloads'].size >= att(:expect)
-  end
-
-  def mm__default_merge
-
-    @node['payloads'].values
-      .reverse
-      .inject({}) { |h, pl| h.merge!(pl) }
-  end
-
-  def determine_remainder
-
-    att(:remaining, :rem) || 'cancel'
-  end
-
-  def determine_receiver
-
-    ex = att(:expect)
-
-    return 'expect_integer_receive' if ex && ex.is_a?(Integer) && ex > 0
-
-    att(:on_receive, :receiver) || 'default_receive'
-  end
-
-  def determine_merger
-
-    att(:on_merge, :merger) || 'default_merge'
+    ts
+      .collect.with_index { |t, j|
+        pl = Flor.dup(message['payload'] || node_payload.copy)
+        execute_child(i + j, 0, 'payload' => pl) }
+      .flatten(1)
   end
 
-  def cancel_children(rem)
+  protected
 
-    (rem && rem != 'forget') ? wrap_cancel_children : []
-  end
+  alias branch_count non_att_count
+    # used by ReceiveAndMerge to determine procedure end
 
-  def reply_to_parent(rem)
+  def receive_from_child_when_closed
 
-    return [] \
-      if @node['replied']
-    return [] \
-      if @node['payloads'].size < non_att_count && ( ! rem || rem == 'wait')
+    ms = receive
 
-    @node['replied'] = true
+    return [] if ms.empty?
 
-    wrap_reply('payload' => @node['merged_payload'])
+    pop_on_receive_last || ms
   end
 
   def make_on_def(cn, l)