flor 0.14.0 → 0.15.0

data/lib/flor/punit/cancel.rb

@@ -9,6 +9,27 @@ class Flor::Pro::Cancel < Flor::Procedure
   #   sequence
   #     cancel ref: 'blue'
   # ```
+  # You can drop the `ref:`
+  # ```
+  # concurrence
+  #   sequence tag: 'blue'
+  #   sequence
+  #     cancel 'blue'
+  # ```
+  #
+  # It's also OK to use nids directly:
+  # ```
+  # concurrence         # 0
+  #   sequence          # 0_0
+  #     # ...
+  #   sequence          # 0_1
+  #     cancel nid: '0_0'
+  #       # or
+  #     #cancel '0_0'
+  # ```
+  # But it's kind of brittle compared to using tags.
+  #
+  # # TODO document "kill"
 
   name 'cancel', 'kill'
     # ruote had "undo" as well...
@@ -26,19 +47,23 @@ class Flor::Pro::Cancel < Flor::Procedure
         .inject([]) { |a, (k, v)|
           v = Array(v)
           a.concat(v) if v.all? { |e| e.is_a?(String) }
-          a
-        } +
+          a } +
       att_a('nid') +
       att_a('ref')
 
     nids, tags = targets.partition { |t| Flor.is_nid?(t) }
-
     nids += tags_to_nids(tags)
+    nids = nids.uniq
 
     fla = @node['heap']
 
-    nids.uniq.map { |nid| wrap_cancel('nid' => nid, 'flavour' => fla)[0] } +
-    wrap_reply
+    messages = nids
+      .collect { |nid| wrap_cancel('nid' => nid, 'flavour' => fla)[0] }
+
+    messages = messages + wrap_reply \
+      unless nids.find { |nid| is_ancestor_node?(nid) }
+
+    messages
   end
 end
 

data/lib/flor/punit/ccollect.rb

@@ -0,0 +1,11 @@
+
+class Flor::Pro::Ccollect < Flor::Macro::Iterator
+
+  name 'ccollect'
+
+  def rewrite_tree
+
+    rewrite_iterator_tree('cmap')
+  end
+end
+

data/lib/flor/punit/cmap.rb

@@ -26,20 +26,25 @@ class Flor::Pro::Cmap < Flor::Procedure
 
     fun = payload['ret']
 
-    fail ArgumentError.new(
-      "cmap expects a function"
-    ) unless Flor.is_func_tree?(fun)
+    fail Flor::FlorError.new("'#{tree[0]}' expects a function", self) \
+      unless Flor.is_func_tree?(fun)
 
     @node['fun'] = fun
 
     att(nil)
-      .collect.with_index { |e, i| apply(fun, [ e, i ], tree[2]) }
+      .collect
+      .with_index { |e, i|
+        apply(fun, [ e, i ], tree[2], vars: { 'idx' => i }) }
       .flatten(1)
   end
 
   def receive_elt
 
-    @node['col'] << payload['ret']
+    idx =
+      (message['rvars'] && message['rvars']['idx']) ||
+      Flor.sub_nid(message['from']) - 1 # fall back :-(
+
+    @node['col'][idx] = payload['ret']
 
     return [] if cnodes_any?
 

data/lib/flor/punit/concurrence.rb

@@ -47,12 +47,25 @@ class Flor::Pro::Concurrence < Flor::Procedure
   # being already gone).
   #
   # `remaining:` may be shortened to `rem:`.
+  #
   # ```
   # concurrence expect: 1 rem: 'forget'
+  #     #
+  #     # will forget child 'alpha' as soon as child 'bravo' replies,
+  #     # and vice versa.
+  #     #
+  #   task 'alpha'
+  #   task 'bravo'
+  # ```
+  #
+  # ```
+  # concurrence expect: 1 rem: 'wait'
+  #     #
+  #     # if 'alpha' replies before 'bravo', the concurrence will wait for
+  #     # 'bravo', without cancelling it. And vice versa.
+  #     #
   #   task 'alpha'
   #   task 'bravo'
-  # # will forget child 'alpha' as soon as child 'bravo' replies,
-  # # and vice versa.
   # ```
 
   name 'concurrence'
@@ -60,12 +73,16 @@ class Flor::Pro::Concurrence < Flor::Procedure
   def pre_execute
 
     @node['atts'] = []
+    @node['payloads'] = {}
   end
 
   def receive_last_att
 
     return wrap_reply unless children[@ncid]
 
+    @node['receiver'] = determine_receiver
+    @node['merger'] = determine_merger
+
     (@ncid..children.size - 1)
       .map { |i| execute_child(i, 0, 'payload' => payload.copy_current) }
       .flatten(1)
@@ -75,23 +92,32 @@ class Flor::Pro::Concurrence < Flor::Procedure
 
   def receive_non_att
 
-    @node['receiver'] ||= determine_receiver
-    @node['merger'] ||= determine_merger
+    @node['payloads'][@message['from']] = @message['payload']
 
-    return [] if @node['over']
+    over = @node['over'] || invoke_receiver
+    just_over = over && ! @node['over']
+    @node['over'] ||= just_over
 
-    over = invoke_receiver
-      # true: the concurrence is over, false: the concurrence is still waiting
+    @node['merged_payload'] ||= just_over ? invoke_merger : nil
+    rem = just_over ? (att(:remaining, :rem) || 'cancel') : nil
 
-    return [] unless over
+    cancel_children(rem) + reply_to_parent(rem)
+  end
 
-    @node['over'] = true
+  def cancel_children(rem)
 
-    pld = invoke_merger
-      # determine post-concurrence payload
+    (rem && rem != 'forget') ? wrap_cancel_children : []
+  end
+
+  def reply_to_parent(rem)
 
-    cancel_remaining +
-    wrap_reply('payload' => pld)
+    return [] \
+      if @node['replied']
+    return [] \
+      if @node['payloads'].size < non_att_count && ( ! rem || rem == 'wait')
+
+    @node['replied'] = true
+    wrap_reply('payload' => @node['merged_payload'])
   end
 
   def receive_from_child_when_closed
@@ -119,51 +145,16 @@ class Flor::Pro::Concurrence < Flor::Procedure
     'default_merge'
   end
 
-  def cancel_remaining
-
-    # remaining:
-    # * 'cancel' (default)
-    # * 'forget'
-    # * 'wait'
-
-    rem = att(:remaining, :rem)
-
-    return [] if rem == 'forget'
-
-    wrap_cancel_children
-  end
-
-  def invoke_receiver
-
-    # TODO: receiver function case
-
-    self.send(@node['receiver'])
-  end
-
-  def invoke_merger
-
-    # TODO: merger function case
-
-    self.send(@node['merger'])
-  end
-
-  def store_payload
-
-    (@node['payloads'] ||= {})[@message['from']] =
-      @message['payload']
-  end
+  def invoke_receiver; self.send(@node['receiver']); end
+  def invoke_merger; self.send(@node['merger']); end
 
   def default_receive
 
-    store_payload
-
-    @node['payloads'].size >= non_att_children.size
+    @node['payloads'].size >= non_att_count
   end
 
   def expect_integer_receive
 
-    store_payload
-
     @node['payloads'].size >= att(:expect)
   end
 

data/lib/flor/punit/cron.rb

@@ -0,0 +1,33 @@
+
+require 'flor/punit/schedule'
+
+
+class Flor::Pro::Cron < Flor::Macro::Schedule
+  #
+  # "cron" is a macro procedure.
+  #
+  # ```
+  # cron '0 0 1 jan *'
+  #   task albert 'take out garbage'
+  # ```
+  #
+  # is automatically turned into:
+  #
+  # ```
+  # schedule cron: '0 0 1 jan *'
+  #   def msg
+  #     task albert 'take out garbage'
+  # ```
+  #
+  # ## see also
+  #
+  # Schedule, and every.
+
+  name 'cron'
+
+  def rewrite_tree
+
+    rewrite_schedule_tree('cron')
+  end
+end
+

data/lib/flor/punit/do_trap.rb

@@ -0,0 +1,42 @@
+
+class Flor::Pro::DoTrap < Flor::Macro
+  #
+  # A version of trap that accepts a block instead of a function.
+  #
+  # do-trap accepts the same attributes as [trap][trap.md] does.
+  #
+  # ```
+  # sequence
+  #   do-trap 'terminated'
+  #     trace "terminated(f:$(msg.from))"
+  #   trace "here($(nid))"
+  # ```
+  # which traces to:
+  # ```
+  # here(0_1_0_0)
+  # terminated(f:0)
+  # ```
+  #
+  # ## see also
+  #
+  # Trap, on, signal.
+
+  name 'do-trap'
+
+  def rewrite_tree
+
+    l = tree[2]
+
+    th = [ 'trap', [], l, *tree[3] ]
+    att_children.each { |ac| th[1] << Flor.dup(ac) }
+
+    td = [ 'def', [], l ]
+    td[1] << [ '_att', [ [ 'msg', [], l ] ], l ]
+    non_att_children.each { |nac| td[1] << Flor.dup(nac) }
+
+    th[1] << td
+
+    th
+  end
+end
+

data/lib/flor/punit/every.rb

@@ -1,22 +1,57 @@
 
-class Flor::Pro::Every < Flor::Macro
+require 'flor/punit/schedule'
+
+
+class Flor::Pro::Every < Flor::Macro::Schedule
+  #
+  # "every" is a macro procedure.
+  #
+  # ```
+  # every 'day at midnight'
+  #   task 'alpha'
+  # ```
+  #
+  # is automatically turned into:
+  #
+  # ```
+  # schedule every: 'day at midnight'
+  #   def msg
+  #     task 'alpha'
+  # ```
+  #
+  # ## time strings
+  #
+  # Every understands time durations and, somehow, frequencies.
+  #
+  # ```
+  # every: "5m10s"
+  # every: "5 minutes and 10 seconds"
+  # ```
+  #
+  # Fugit translates `every: 'day at five'` into `cron: '0 5 * * *'`.
+  #
+  # ```
+  # every: 'day at five'                  # ==> '0 5 * * *'
+  # every: 'weekday at five'              # ==> '0 5 * * 1,2,3,4,5'
+  # every: 'day at 5 pm'                  # ==> '0 17 * * *'
+  # every: 'tuesday at 5 pm'              # ==> '0 17 * * 2'
+  # every: 'wed at 5 pm'                  # ==> '0 17 * * 3'
+  # every: 'day at 16:30'                 # ==> '30 16 * * *'
+  # every: 'day at noon'                  # ==> '0 12 * * *'
+  # every: 'day at midnight'              # ==> '0 0 * * *'
+  # every: 'tuesday and monday at 5pm'    # ==> '0 17 * * 1,2'
+  # every: 'wed or Monday at 5pm and 11'  # ==> '0 11,17 * * 1,3'
+  # ```
+  #
+  # ## see also
+  #
+  # Cron, at, in, every, and sleep.
 
   name 'every'
 
   def rewrite_tree
 
-    l = tree[2]
-
-    th = [ 'schedule', [], l, *tree[3] ]
-    att_children.each { |ac| th[1] << Flor.dup(ac) }
-
-    td = [ 'def', [], l ]
-    td[1] << [ '_att', [ [ 'msg', [], l ] ], l ]
-    non_att_children.each { |nac| td[1] << Flor.dup(nac) }
-
-    th[1] << td
-
-    th
+    rewrite_schedule_tree(nil)
   end
 end
 

data/lib/flor/punit/graft.rb

@@ -56,11 +56,11 @@ class Flor::Pro::Graft < Flor::Procedure
     source_path, source =
       @executor.unit.loader.library(domain, sub, subflows: true)
 
-    fail ArgumentError.new(
-      "no subtree #{sub.inspect} found (domain #{domain.inspect})"
+    fail Flor::FlorError.new(
+      "no subtree #{sub.inspect} found (domain #{domain.inspect})", self
     ) unless source
 
-    tree = Flor::Lang.parse(source, source_path, {})
+    tree = Flor.parse(source, source_path, {})
 
     # graft subtree into parent node
 

data/lib/flor/punit/on_timeout.rb

@@ -0,0 +1,38 @@
+
+class Flor::Pro::OnTimeout < Flor::Procedure
+  #
+  # Counterpart to the on_timeout: attribute.
+  #
+  # Sets the on_timeout "attribute" of the parent procedure.
+  #
+  # ```
+  # set l []
+  # sequence timeout: '1s'
+  #   push l 0
+  #   on_timeout (def msg \ push l "$(msg.point):$(msg.nid)")
+  #   stall _
+  #   push l 2
+  # push l 3
+  # ```
+  # Ends up with `[ 0, 'cancel:0_1', 3 ]` in the variable `l`. The on_timeout
+  # is set on the "sequence".
+  #
+  # ## see also
+  #
+  # On, on_error, on_cancel.
+
+  name 'on_timeout'
+
+  def pre_execute
+
+    unatt_unkeyed_children
+  end
+
+  def receive_non_att
+
+    store_on(:timeout)
+
+    super
+  end
+end
+

data/lib/flor/punit/schedule.rb

@@ -9,7 +9,38 @@ class Flor::Pro::Schedule < Flor::Procedure
   #     check_systems
   # ```
   #
-  # See also: cron, at, in and sleep
+  # It understands `cron:`, `at:`, `in:`, and `every:`.
+  #
+  # The time string parsing is done by the
+  # [fugit](https://github.com/floraison/fugit) gem.
+  #
+  # ## every:
+  #
+  # Every understands time durations and, somehow, frequencies.
+  #
+  # ```
+  # every: "5m10s"
+  # every: "5 minutes and 10 seconds"
+  # ```
+  #
+  # Fugit translates `every: 'day at five'` into `cron: '0 5 * * *'`.
+  #
+  # ```
+  # every: 'day at five'                  # ==> '0 5 * * *'
+  # every: 'weekday at five'              # ==> '0 5 * * 1,2,3,4,5'
+  # every: 'day at 5 pm'                  # ==> '0 17 * * *'
+  # every: 'tuesday at 5 pm'              # ==> '0 17 * * 2'
+  # every: 'wed at 5 pm'                  # ==> '0 17 * * 3'
+  # every: 'day at 16:30'                 # ==> '30 16 * * *'
+  # every: 'day at noon'                  # ==> '0 12 * * *'
+  # every: 'day at midnight'              # ==> '0 0 * * *'
+  # every: 'tuesday and monday at 5pm'    # ==> '0 17 * * 1,2'
+  # every: 'wed or Monday at 5pm and 11'  # ==> '0 11,17 * * 1,3'
+  # ```
+  #
+  # ## see also
+  #
+  # Cron, at, in, every, and sleep.
 
   name 'schedule'
 
@@ -22,18 +53,18 @@ class Flor::Pro::Schedule < Flor::Procedure
 
     fun = @fcid > 0 ? payload['ret'] : nil
 
-    fail ArgumentError.new(
-      "missing a function to call when the scheduler triggers"
+    fail Flor::FlorError.new(
+      "missing a function to call when the scheduler triggers", self
     ) unless fun
 
-    m = apply(fun, [], tree[2], false).first
+    m = apply(fun, [], tree[2], anid: false).first
 
     t, s =
       @node['atts'].find { |k, v| %w[ cron at in every ].include?(k) } ||
       @node['atts'].find { |k, v| k == nil }
 
-    fail ArgumentError.new(
-      "missing a schedule"
+    fail Flor::FlorError.new(
+      "missing a schedule", self
     ) unless s
 
     @node['scheduled'] = true
@@ -57,3 +88,35 @@ class Flor::Pro::Schedule < Flor::Procedure
   end
 end
 
+
+class Flor::Macro::Schedule < Flor::Macro
+
+  def rewrite_schedule_tree(schedule_type)
+
+    atts = att_children
+    schedule_i = atts.index { |at| at[1].size == 1 }
+
+    fail Flor::FlorError.new("schedule not found in #{tree.inspect}", self) \
+      unless schedule_i
+
+    schedule =
+      schedule_type ?
+      Flor.dup(atts.delete_at(schedule_i)[1][0]) :
+      nil
+
+    l = tree[2]
+
+    th = [ 'schedule', [], l, *tree[3] ]
+    th[1] << [ '_att', [ [ schedule_type, [], l ], schedule ], l ] if schedule
+    atts.each { |ac| th[1] << Flor.dup(ac) }
+
+    td = [ 'def', [], l ]
+    td[1] << [ '_att', [ [ 'msg', [], l ] ], l ]
+    non_att_children.each { |nac| td[1] << Flor.dup(nac) }
+
+    th[1] << td
+
+    th
+  end
+end
+