flor 0.11.0 → 0.12.0

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 # flor CHANGELOG.md
 
 
+## flor 0.12.0  released 2017-04-14
+
+- Implementation of 'flank' and application to "trap" and "schedule"
+- Introduce `{ a : 0 } quote: 'keys'`
+- Introduce `vars: copy` or `vars: '*'`
+
+
 ## flor 0.11.0  released 2017-03-17
 
 - Simplification of the tasker configuration files

data/Makefile

@@ -55,6 +55,9 @@ start:
 backup_notes_and_todos:
 	tar czvf flor_notes_$(shell date "+%Y%m%d_%H%M").tgz .notes.md .todo.md && mv flor_notes_*.tgz ~/Dropbox/backup/
 ba: backup_notes_and_todos
+backup_src:
+	cd .. && tar czvf flor_$(shell date "+%Y%m%d_%H%M").tgz flor && mv flor_*.tgz ~/Dropbox/backup/
+bak: backup_src
 
 t:
 	tree spec/unit/loader

data/lib/flor.rb

@@ -12,7 +12,7 @@ require 'raabro'
 
 module Flor
 
-  VERSION = '0.11.0'
+  VERSION = '0.12.0'
 end
 
 require 'flor/colours'

data/lib/flor/colours.rb

@@ -69,12 +69,16 @@ module Flor
 
     o = opts[:out] || $stdout
 
-    (o.respond_to?(:log_colours?) ? o.log_colours? : o.tty?) ?
-      @colours :
-      @no_colours
+    col =
+      (o.respond_to?(:log_colours?) ? o.log_colours? : o.tty?) ||
+      ($0[-6..-1] == '/rspec' &&
+        (ARGV.include?('--tty') || ARGV.include?('--color')))
+
+    col ? @colours : @no_colours
   end
 
   def self.decolour(s)
+
     s.gsub(/\x1b\[\d+(;\d+)?m/, '')
   end
 

data/lib/flor/conf.rb

@@ -67,22 +67,24 @@ module Flor
     #
     #   For example `debug: 'msg,stdout'`
 
-    def self.read(s)
+    def self.prepare(conf, over_conf)
 
-      h = {}
-      h.merge!(Flor::ConfExecutor.interpret(s))
-      h.merge!(interpret_flor_debug(h['flor_debug'] || h['debug']))
+      c = conf
+      c = Flor::ConfExecutor.interpret(c) if c.is_a?(String)
 
-      h
-    end
+      fail ArgumentError.new(
+        "cannot extract conf out of #{c.inspect} (#{conf.class})"
+      ) unless c.is_a?(Hash)
 
-    def self.read_env
+      unless c['conf'] == true
+        #
+        # don't read FLOR_DEBUG if this executor is only meant to read the conf
 
-      h = {}
-      h.merge!(interpret_env)
-      h.merge!(interpret_flor_debug(ENV['FLOR_DEBUG']))
+        c.merge!(interpret_flor_debug(c))
+        c.merge!(interpret_env)
+      end
 
-      h
+      c.merge!(over_conf)
     end
 
     def self.get_class(conf, key)
@@ -99,11 +101,15 @@ module Flor
     LOG_DBG_KEYS = %w[ dbg msg err src tree tree_rw run ]
     LOG_ALL_KEYS = %w[ all log sto ] + LOG_DBG_KEYS
 
-    def self.interpret_flor_debug(v)
+    def self.interpret_flor_debug(c)
 
-      a = v || ''
-      a = a.split(',') if a.is_a?(String)
-      a = a.collect(&:strip)
+      plus, minus = [ c['flor_debug'], c['debug'], ENV['FLOR_DEBUG'] ]
+        .collect { |v| (v || '').split(/\s*,\s*/) }
+        .flatten(1)
+        .partition { |v| v[0, 1] != '-' }
+      plus = plus.collect { |v| v[0, 1] == '+' ? v[1..-1] : v }
+      minus = minus.collect { |v| v[0, 1] == '-' ? v[1..-1] : v }
+      a = plus - minus
 
       h =
         a.inject({}) { |h, kv|

data/lib/flor/core/executor.rb

@@ -94,14 +94,16 @@ module Flor
       (n['vars'] || {})
         .each { |k, v| vs[k] = Flor.dup(v) unless vs.has_key?(k) }
 
-      if @unit.loader && n['parent'] == nil && n['vdomain'] != false
+      pnid = n['parent']
+
+      if @unit.loader && pnid == nil && n['vdomain'] != false
 
         @unit.loader.variables(n['vdomain'] || Flor.domain(@exid))
           .each { |k, v| vs[k] = Flor.dup(v) unless vs.has_key?(k) }
       end
 
       if cn = n['cnid']; vars(cn, vs); end
-      if pa = n['parent']; vars(pa, vs); end
+      vars(pnid, vs) if pnid
 
       vs
     end
@@ -132,7 +134,7 @@ module Flor
         'ctime' => now,
         'mtime' => now }
 
-      %w[ vars vdomain cnid noreply dbg ].each do |k|
+      %w[ vars vdomain cnid dbg ].each do |k|
         v = message[k]
         node[k] = v if v != nil
       end
@@ -140,7 +142,6 @@ module Flor
         # vars: variables
         # vdomain: variable domain (used in conjuction with the loader)
         # cnid: closure nid
-        # noreply: this new node has a parent but shouldn't reply to it
         # dbg: used to debug messages (useful @node['dbg'] when 'receive')
 
       @execution['nodes'][nid] = node
@@ -179,7 +180,22 @@ module Flor
       node['heat'] = heat = n.deref(t0)
       node['heap'] = heap = n.reheap(tree, heat)
 
-      if heap == 'task' && heat[0] == '_task'
+      # "exceptions"
+
+# TODO could those two ifs go upstream (top of this method)
+#      and thus become smaller
+#
+      if message['accept_symbol'] && node['heat'] == nil
+        #
+        # tag: et al
+
+        tree = node['tree'] = message['tree'] = [ '_dqs', tree[0], tree[2] ]
+
+        node['heat0'] = tree[0]
+        node['heat'] = heat = n.deref(tree[0])
+        node['heap'] = heap = n.reheap(tree, heat)
+
+      elsif heap == 'task' && heat[0] == '_task'
         #
         # rewrite `alpha` into `task alpha`
 
@@ -208,13 +224,6 @@ module Flor
           node['failure'] ? '_err' : nil
         end
 
-      return ([{
-        'point' => 'receive',
-        'nid' => message['from'], 'from' => message['nid'],
-        'exid' => message['exid'],
-        'payload' => Flor.dupm(message['payload'], 'ret' => node['heat0'])
-      }]) if heap == nil && message['accept_symbol'] == true
-
       return error_reply(
         node, message, "don't know how to apply #{node['heat0'].inspect}"
       ) if heap == nil
@@ -224,99 +233,85 @@ module Flor
 
       head = heac.new(self, node, message)
 
-      #return process(head.rewrite) if head.is_a?(Flor::Macro)
       return [ head.rewrite ] if head.is_a?(Flor::Macro)
 
-      nid = message['nid']
-      pt = message['point']
-      pt = "do_#{pt}" if pt == 'receive' || pt == 'cancel'
-
-      if pt == 'execute'
-        head.pre_execute
-        pnode = @execution['nodes'][node['parent']]
-        cnodes = pnode && (pnode['cnodes'] ||= [])
-        cnodes << nid if cnodes && ( ! cnodes.include?(nid))
-      end
-      head.send(pt)
+      head.send("do_#{message['point']}")
     end
 
-    def remove_node(n)
+    def toc_messages(message)
 
-      return unless n
+      return [] if message['flavour'] == 'flank'
 
-      n['removed'] = true # or should I use "status" => "removed" ?
+      m = message.select { |k, v| %w[ exid nid from payload ].include?(k) }
+      m['sm'] = message['m']
+      m['point'] = message['from'] == '0' ? 'terminated' : 'ceased'
 
-      @unit.remove_node(exid, n)
-        # remove timers/waiters for this node, if any
+      [ m ]
+    end
 
-      return if (n['closures'] || []).any?
-        # don't remove the node if it's a closure for some other nodes
+    def receive(message)
 
-      nid = n['nid']
+      messages = leave_node(message)
 
-      return if nid == '0'
-        # don't remove if it's the "root" node
+      nid = message['nid']
 
-      @execution['nodes'].delete(nid)
-    end
+      return messages + toc_messages(message) unless nid
+        # 'terminated' or 'ceased'
 
-    def leave(node, message)
+      node = @execution['nodes'][nid]
 
-      ts = node && node['tags']
-      return [] unless ts && ts.any?
+      return messages unless node
+        # node gone...
 
-      [
-        { 'point' => 'left',
-          'tags' => ts,
-          'exid' => exid,
-          'nid' => node['nid'],
-          'payload' => message['payload'] }
-      ]
+      messages + apply(node, message)
     end
 
-    # "receive_terminated_or_ceased"
-    #
-    def receive_toc(message, fnode)
+    def leave_node(message)
 
-      msg =
-        %w[
-          exid nid from payload
-        ].inject({}) { |h, k| h[k] = message[k] if message.has_key?(k); h }
+      fnid = message['from']; return [] unless fnid
+      fnode = @execution['nodes'][fnid]; return [] unless fnode
 
-      msg['sm'] = message['m']
+      return [] if message['flavour'] == 'flank'
 
-      msg['point'] =
-        if message['from'] == '0' || @execution['nodes'].empty? # termination?
-          'terminated'
-        else
-          'ceased'
-        end
-
-      [ msg ]
+      remove_node(message, fnode) +
+      leave_tags(message, fnode)
     end
 
-    def receive(message)
+    def remove_node(message, node)
 
-      from = message['from']
-      fnode = @execution['nodes'][from]
+      nid = node['nid']
+      cls = node['closures']
 
-      if fnode && fnode.has_key?('aret')
-        message['payload']['ret'] = fnode['aret']
-      end
+      pro = Flor::Procedure.make(self, node, message)
+      pro.end
 
-      remove_node(fnode)
-      messages = leave(fnode, message)
+      cancels = pro.send(:wrap_cancel_children, 'cancel_trailing' => true)
 
-      nid = message['nid']
-      nid = nil if fnode && fnode['noreply']
+      return cancels if cls && cls.any?
+        # don't remove the node if it's a closure for some other nodes
 
-      return messages + receive_toc(message, fnode) unless nid
+      return cancels if nid == '0'
+        # don't remove if it's the "root" node
 
-      node = @execution['nodes'][nid]
+      @unit.archive_node(message['exid'], node)
+        # archiving is only active during testing
 
-      return messages unless node
+      @execution['nodes'].delete(nid)
 
-      messages + apply(node, message)
+      cancels
+    end
+
+    def leave_tags(message, node)
+
+      ts = node['tags']; return [] unless ts && ts.any?
+
+      [
+        { 'point' => 'left',
+          'tags' => ts,
+          'exid' => exid,
+          'nid' => node['nid'],
+          'payload' => message['payload'] }
+      ]
     end
 
     def error_reply(node, message, err)
@@ -439,7 +434,6 @@ module Flor
       []
     end
 
-
     def failed(message)
 
       n = node(message['nid'])

data/lib/flor/core/node.rb

@@ -73,6 +73,9 @@ class Flor::Node
   def point; @message['point']; end
   def from; @message['from']; end
 
+  def cnodes; @node['cnodes']; end
+  def cnodes_any?; cnodes && cnodes.any?; end
+
   def payload
     @message_payload ||= Payload.new(self, :message)
   end
@@ -354,10 +357,12 @@ class Flor::Node
 
     return vars[key] if vars && vars.has_key?(key)
 
-    if cnid = node['cnid'] # look into closure
+    if cnid = node['cnid']
       cvars = (@execution['nodes'][cnid] || {})['vars']
       return cvars[key] if cvars && cvars.has_key?(key)
     end
+      #
+      # look into closure, just one level deep...
 
     lookup_var(pnode, mod, key)
   end

data/lib/flor/core/procedure.rb

@@ -1,17 +1,17 @@
 
 class Flor::Procedure < Flor::Node
 
-  def self.inherited(subclass)
+  class << self
 
-    (@@inherited ||= []) << subclass
-  end
+    def inherited(subclass)
 
-  def self.[](name)
+      (@@inherited ||= []) << subclass
+    end
 
-    @@inherited.find { |k| k.names && k.names.include?(name) }
-  end
+    def [](name)
 
-  class << self
+      @@inherited.find { |k| k.names && k.names.include?(name) }
+    end
 
     def names(*names)
 
@@ -22,6 +22,24 @@ class Flor::Procedure < Flor::Node
     end
 
     alias :name :names
+
+    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
+
+      heac = self[heap]
+
+      fail NameError.new(
+        "unknown procedure #{heap.inspect}"
+      ) unless heac
+
+      heac.new(executor, node, message)
+    end
   end
 
   def pre_execute
@@ -38,13 +56,8 @@ class Flor::Procedure < Flor::Node
     @node['on_receive_last'] =
       apply(@node['on_error'].shift, [ @message ], tree[2])
 
-    nids = @node['cnodes']
-
-    if nids && nids.any?
-      cancel_children
-    else
-      do_receive # which should trigger 'on_receive_last'
-    end
+    do_wrap_cancel_children ||
+    do_receive # which should trigger 'on_receive_last'
   end
 
   def debug_tree(nid=nil)
@@ -60,6 +73,19 @@ class Flor::Procedure < Flor::Node
     puts Flor.detail_msg(@executor, msg)
   end
 
+  def end
+
+    end_node
+  end
+
+  def flank
+
+    @node['tree'] = Flor.dup(tree)
+    @node['noreply'] = true
+
+    wrap('nid' => parent, 'flavour' => 'flank')
+  end
+
   protected
 
   def counter_next(k)
@@ -162,7 +188,7 @@ class Flor::Procedure < Flor::Node
 
   def execute_child(index=0, sub=nil, h=nil)
 
-    return reply \
+    return wrap_reply \
       if index < 0 || ( ! tree[1].is_a?(Array)) || tree[1][index] == nil
 
     sub = counter_next('subs') if sub == true
@@ -176,7 +202,7 @@ class Flor::Procedure < Flor::Node
       'payload' => payload.current }
     hh.merge!(h) if h
 
-    reply(hh)
+    wrap(hh)
   end
 
   def unatt_unkeyed_children(first_only=false)
@@ -221,6 +247,17 @@ class Flor::Procedure < Flor::Node
     @node['tree'] = [ tree[0], cn, tree[2] ]
   end
 
+  def do_execute
+
+    pre_execute
+
+    pnode = @execution['nodes'][parent]
+    cnodes = pnode && (pnode['cnodes'] ||= [])
+    cnodes << nid if cnodes && ( ! cnodes.include?(nid))
+
+    execute
+  end
+
   def execute
 
     receive
@@ -231,12 +268,10 @@ class Flor::Procedure < Flor::Node
   #
   def do_receive
 
-    from_child =
-      if ns = @node['cnodes']
-        ns.delete(from)
-      else
-        nil
-      end
+    remove = @message['flavour'] != 'flank'
+
+    from_child = nil
+    from_child = cnodes.delete(from) if cnodes_any? && remove
 
     if node_closed?
       return receive_from_child_when_closed if from_child
@@ -273,7 +308,7 @@ class Flor::Procedure < Flor::Node
 
   def receive_from_child_when_closed
 
-    (@node['cnodes'].empty? && pop_on_receive_last) || reply
+    (cnodes.empty? && pop_on_receive_last) || wrap_reply
   end
 
   def receive_when_closed
@@ -333,7 +368,7 @@ class Flor::Procedure < Flor::Node
 
   def receive_last
 
-    reply
+    wrap_reply
   end
 
   # Used by 'cursor' (and 'loop') when
@@ -356,21 +391,27 @@ class Flor::Procedure < Flor::Node
 
     (@node['tags'] ||= []).concat(ret)
 
-    reply('point' => 'entered', 'nid' => nid, 'tags' => ret)
+    wrap('point' => 'entered', 'nid' => nid, 'tags' => ret)
   end
 
-  def reply(h={})
+  def wrap(h={})
 
     m = {}
     m['point'] = 'receive'
     m['exid'] = exid
-    m['nid'] = parent
+    m['nid'] = @node['noreply'] ? nil : parent
     m['from'] = nid
 
     m['sm'] = @message['m']
 
-    ret = :no
-    ret = h.delete('ret') if h.has_key?('ret')
+    ret =
+      if @node.has_key?('aret') # from the 'ret' common attribute
+        @node['aret']
+      elsif h.has_key?('ret')
+        h.delete('ret')
+      else
+        :no
+      end
 
     m['payload'] = payload.current
 
@@ -378,25 +419,32 @@ class Flor::Procedure < Flor::Node
 
     m['payload']['ret'] = ret if ret != :no
 
-    end_node if m['nid'] == parent && m['point'] == 'receive'
-
     [ m ]
   end
 
-  def queue(h); reply(h); end
+  alias wrap_reply wrap
+
+  def wrap_error(o)
+
+    wrap('point' => 'failed', 'error' => Flor.to_error(o))
+  end
+
+  def wrap_cancel(h)
 
-  def error_reply(o)
+    h['point'] ||= 'cancel'
+    h['nid'] ||= nid
+    #h['flavour'] ||= 'xxx'
 
-    reply('point' => 'failed', 'error' => Flor.to_error(o))
+    wrap(h)
   end
 
-  def schedule(h)
+  def wrap_schedule(h)
 
     h['point'] ||= 'schedule'
     h['payload'] ||= {}
     h['nid'] ||= nid
 
-    reply(h)
+    wrap(h)
   end
 
   def lookup_var_node(node, mode, k=nil)
@@ -483,7 +531,7 @@ class Flor::Procedure < Flor::Node
       vars[key] = args[i]
     end
 
-    ms = reply(
+    ms = wrap(
       'point' => 'execute',
       'nid' => ani,
       'tree' => [ '_apply', t[1], line ],
@@ -497,23 +545,28 @@ class Flor::Procedure < Flor::Node
     ms
   end
 
-  def cancel_nodes(nids)
+  def wrap_cancel_nodes(nids, h)
 
     (nids || [])
-      .collect { |i| reply('point' => 'cancel', 'nid' => i, 'from' => nid) }
+      .collect { |i| wrap_cancel(h.merge('nid' => i, 'from' => nid)) }
       .flatten(1)
   end
 
-  def cancel_reply # "cancel" as a noun
+  def wrap_cancelled
 
-    reply(
+    wrap(
       'cause' => 'cancel',
       'payload' => @message['payload'] || @node['payload'])
   end
 
-  def cancel_children
+  def wrap_cancel_children(h={})
+
+    wrap_cancel_nodes(cnodes, h)
+  end
+
+  def do_wrap_cancel_children(h={})
 
-    cancel_nodes(@node['cnodes'])
+    wrap_cancel_children(h).instance_eval { |ms| ms.any? ? ms : nil }
   end
 
   # The executor calls #do_cancel, while most procedure implementations
@@ -521,15 +574,20 @@ class Flor::Procedure < Flor::Node
   #
   def do_cancel
 
-    return kill if @message['flavour'] == 'kill'
+    if @message['flavour'] == 'kill'
+
+      return [] if node_ended?
+      kill
 
-    orl = @message['on_receive_last']
-    @node['on_receive_last'] = orl if orl
+    else
 
-    return cancel_when_ended if node_ended?
-    return cancel_when_closed if node_closed?
+      orl = @message['on_receive_last']
+      @node['on_receive_last'] = orl if orl
 
-    cancel
+      return cancel_when_ended if node_ended?
+      return cancel_when_closed if node_closed?
+      cancel
+    end
   end
 
   def cancel_when_ended
@@ -546,20 +604,16 @@ class Flor::Procedure < Flor::Node
 
     close_node
 
-    nids = @node['cnodes']
-
-    if nids && nids.any?
-      cancel_children
-    else
-      cancel_reply
-    end
+    do_wrap_cancel_children ||
+    wrap_cancelled
   end
 
   def kill
 
-    return [] if node_ended?
+    close_node
 
-    reply + cancel_children
+    wrap_cancel_children('flavour' => 'kill') +
+    wrap_cancelled
   end
 end