flor 0.13.0 → 0.14.0

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 # flor CHANGELOG.md
 
 
+## flor 0.14.0  released 2017-06-13
+
+- Implement "match"
+- Implement "range"
+- Implement "for-each"
+- Merge enhancements by @jfrioux
+
+
 ## flor 0.13.0  released 2017-04-24
 
 - Simplify "trace" implementation

data/lib/flor.rb

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

data/lib/flor/core.rb

@@ -44,6 +44,13 @@ module Flor
     pl = opts[:payload] || opts[:fields] || {}
     vs = opts[:variables] || opts[:vars] || {}
 
+    fail ArgumentError.new(
+      "given launch payload should be a Hash, but it's a #{pl.class}"
+    ) unless pl.is_a?(Hash)
+    fail ArgumentError.new(
+      "given launch variables should come in a Hash, but it's a #{vs.class}"
+    ) unless vs.is_a?(Hash)
+
     msg =
       { 'point' => 'execute',
         'exid' => exid,

data/lib/flor/core/executor.rb

@@ -182,18 +182,23 @@ module Flor
 
       # "exceptions"
 
-# TODO could those two ifs go upstream (top of this method)
-#      and thus become smaller
-#
-      if message['accept_symbol'] && node['heat'] == nil
+      if heat == nil && tree[0].index('.') && tree[1].empty?
+        #
+        # a field reference that points to nothing returns null
+
+        node['heat0'] = '_nul'
+        node['heat'] = '_nul'
+        node['heap'] = '_nul'
+
+      elsif message['accept_symbol'] && heat == nil
         #
         # tag: et al
 
-        tree = node['tree'] = message['tree'] = [ '_dqs', tree[0], tree[2] ]
+        node['tree'] = message['tree'] = t = [ '_dqs', tree[0], tree[2] ]
 
-        node['heat0'] = tree[0]
-        node['heat'] = heat = n.deref(tree[0])
-        node['heap'] = heap = n.reheap(tree, heat)
+        node['heat0'] = t[0]
+        node['heat'] = h = n.deref(t[0])
+        node['heap'] = n.reheap(t, h)
 
       elsif heap == 'task' && heat[0] == '_task'
         #
@@ -296,11 +301,41 @@ module Flor
       @unit.archive_node(message['exid'], node)
         # archiving is only active during testing
 
+      #update_parent_node_tree(node)
+
       @execution['nodes'].delete(nid)
 
       cancels
     end
 
+  # This saves the modified trees in the parent when the node is removed
+  # it works ok except for 3 (2017-05-9) failing specs.
+  #
+  # Introducing 3 exceptions for this is not interesting.
+  #
+#    def update_parent_node_tree(node)
+#
+#      t = node['tree']; return unless t
+##return if t[0] == '_apply'
+#      pnode = @execution['nodes'][node['parent']]; return unless pnode
+#
+#      pt =
+#        pnode['tree'] ||
+#        Flor::Node.new(self, pnode, nil).lookup_tree(pnode['nid'])
+#      cid =
+#        Flor.child_id(node['nid'])
+#
+#      if cid == pt[1].size # head "exception"
+#        return if pt[0] == t
+#        pt[0] = t
+#        pnode['tree'] = pt
+#        return
+#      end
+#
+#      pt[1][cid] = t
+#      pnode['tree'] = pt
+#    end
+
     def leave_tags(message, node)
 
       ts = node['tags']; return [] unless ts && ts.any?

data/lib/flor/core/node.rb

@@ -145,27 +145,25 @@ class Flor::Node
     #
     # that might be the way...
 
-  def lookup(name)
-
-    cat, mod, key = key_split(name)
-    key, pth = key.split('.', 2)
-
-    val =
-      if [ cat, mod, key ] == [ 'v', '', 'node' ]
-        @node
-      elsif cat == 'v'
-        lookup_var(@node, mod, key)
-      elsif cat == 't'
-        lookup_tag(mod, key)
-      else
-        lookup_field(mod, key)
-      end
+  def lookup(name, silence_index_error=false)
+
+    cat, mod, key_and_path = key_split(name)
+    key, pth = key_and_path.split('.', 2)
 
-    if pth
-      Flor.deep_get(val, pth)[1]
+    if [ cat, mod, key ] == [ 'v', '', 'node' ]
+      lookup_in_node(pth)
+    elsif cat == 'v'
+      lookup_var(@node, mod, key, pth)
+    elsif cat == 't'
+      lookup_tag(mod, key)
     else
-      val
+      lookup_field(mod, key_and_path)
     end
+
+  rescue IndexError
+
+    raise unless silence_index_error
+    nil
   end
 
   class Expander < Flor::Dollar
@@ -178,7 +176,8 @@ class Flor::Node
       return @node.exid if k == 'exid'
       return Flor.tstamp if k == 'tstamp'
 
-      @node.lookup(k)
+      r = @node.lookup(k, true)
+      r.is_a?(Symbol) ? nil : r
     end
   end
 
@@ -202,10 +201,10 @@ class Flor::Node
 
     ref =
       case v[0]
-        when '_func' then true
-        when '_proc' then v[1]['proc'] != o
-        when '_task' then v[1]['task'] != o
-        else false
+      when '_func' then true
+      when '_proc' then v[1]['proc'] != o
+      when '_task' then v[1]['task'] != o
+      else false
       end
 
     v[1]['oref'] ||= v[1]['ref'] if ref && v[1]['ref']
@@ -226,8 +225,6 @@ class Flor::Node
       'apply'
     elsif heat[0] == '_task'
       'task'
-    elsif Flor.is_tree_head_tree?(tree)
-      '_happly'
     else
       '_val'
     end
@@ -317,54 +314,86 @@ class Flor::Node
   #  @execution['nodes'][node['cnid']]
   #end
 
-  def lookup_dvar(mod, key)
+  def lookup_in_node(pth)
 
-    if mod != 'd' && Flor::Procedure[key]
-      return [ '_proc', { 'proc' => key }, -1 ]
-    end
+    Flor.deep_get(@node, pth)
+  end
 
-    l = @executor.unit.loader
-    vdomain = @node['vdomain']
-      #
-    if l && vdomain != false
-      v = l.variables(vdomain || domain).fetch(key) { :no }
-      return v unless v == :no
-    end
+  class PseudoVarContainer < Hash
+    #
+    # inherit from Hash so that deep.rb is quietly mislead
+    #
+    def initialize(type); @type = type; end
+    #def has_key?(key); true; end
+    def [](key); [ "_#{@type}", { @type => key }, -1 ]; end
+  end
+    #
+  PROC_VAR_CONTAINER = PseudoVarContainer.new('proc')
+  TASKER_VAR_CONTAINER = PseudoVarContainer.new('task')
 
-    if mod != 'd' && @executor.unit.has_tasker?(@executor.exid, key)
-      return [ '_task', { 'task' => key }, -1 ]
-    end
+  def lookup_var(node, mod, key, pth)
 
-    nil
+    c = lookup_var_container(node, mod, key)
+
+    kp = [ key, pth ].reject { |x| x == nil || x.size < 1 }.join('.')
+
+    v = Flor.deep_get(c, kp)
+#p [ mod, key, pth, '->', v ]
+
+    return v unless v.is_a?(Symbol)
+
+    vs = v.to_s.split('.')
+    tail = vs.pop
+    vs = vs.join('.')
+
+    fail IndexError.new("variable #{tail.inspect} not found") if vs.empty?
+    fail IndexError.new("no key #{tail.inspect} in variable #{vs.inspect}")
   end
 
-  def lookup_var(node, mod, key)
+  def lookup_var_container(node, mod, key)
 
-    return lookup_dvar(mod, key) if node == nil || mod == 'd'
+    return lookup_dvar_container(mod, key) if node == nil || mod == 'd'
 
     pnode = parent_node(node)
-    #cnode = closure_node(node)
+    vars = node['vars']
 
     if mod == 'g'
-      vars = node['vars']
-      return lookup_var(pnode, mod, key) if pnode
-      return vars[key] if vars
-      #return lookup_var(cnode, mod, key) if cnode
+      return lookup_var_container(pnode, mod, key) if pnode
+      return vars if vars
       fail "node #{node['nid']} has no vars and no parent"
     end
 
-    vars = node['vars']
-
-    return vars[key] if vars && vars.has_key?(key)
+    return vars if vars && vars.has_key?(key)
 
     if cnid = node['cnid']
       cvars = (@execution['nodes'][cnid] || {})['vars']
-      return cvars[key] if cvars && cvars.has_key?(key)
+      return cvars if cvars && cvars.has_key?(key)
     end
       #
       # look into closure, just one level deep...
 
-    lookup_var(pnode, mod, key)
+    lookup_var_container(pnode, mod, key)
+  end
+
+  def lookup_dvar_container(mod, key)
+
+    if mod != 'd' && Flor::Procedure[key]
+      return PROC_VAR_CONTAINER
+    end
+
+    l = @executor.unit.loader
+    vdomain = @node['vdomain']
+      #
+    if l && vdomain != false
+      vars = l.variables(vdomain || domain)
+      return vars if vars.has_key?(key)
+    end
+
+    if mod != 'd' && @executor.unit.has_tasker?(@executor.exid, key)
+      return TASKER_VAR_CONTAINER
+    end
+
+    {}
   end
 
   def lookup_var_name(node, val)
@@ -389,9 +418,10 @@ class Flor::Node
     nids.empty? ? [ '_nul', nil, -1 ] : nids
   end
 
-  def lookup_field(mod, key)
+  def lookup_field(mod, key_and_path)
 
-    Flor.deep_get(payload.current, key)[1]
+    r = Flor.deep_get(payload.current, key_and_path)
+    r.is_a?(Symbol) ? nil : r
   end
 
   def key_split(key) # => category, mode, key

data/lib/flor/core/procedure.rb

@@ -17,12 +17,15 @@ class Flor::Procedure < Flor::Node
 
       names = names.flatten
       @names = names if names.any?
+      @core = !! caller.find { |l| l.match(/flor\/pcore/) } if names.any?
 
       @names
     end
 
     alias :name :names
 
+    def core?; @core; end
+
     def make(executor, node, message)
 
       heap = node['heat'] ? node['heap'] : nil
@@ -234,9 +237,9 @@ class Flor::Procedure < Flor::Node
     unatt_unkeyed_children(true)
   end
 
-  def stringify_first_child
+  def stringify_child(non_att_index)
 
-    c = non_att_children.first
+    c = non_att_children[non_att_index]
     return unless c
     return unless c[1] == [] && c[0].is_a?(String)
 
@@ -247,6 +250,11 @@ class Flor::Procedure < Flor::Node
     @node['tree'] = [ tree[0], cn, tree[2] ]
   end
 
+  def stringify_first_child
+
+    stringify_child(0)
+  end
+
   def do_execute
 
     pre_execute
@@ -321,31 +329,37 @@ class Flor::Procedure < Flor::Node
     []
   end
 
-  def receive
+  def determine_fcid_and_ncid
 
     @fcid = point == 'receive' ? Flor.child_id(from) : nil
     @ncid = (@fcid || -1) + 1
+  end
 
-    return receive_first if @fcid == nil
+  def from_att?
+
+    @fcid && (c = children[@fcid]) && c[0] == '_att'
+  end
 
-    child = children[@fcid]
+  def receive
 
-    return receive_att if child && child[0] == '_att'
+    determine_fcid_and_ncid
 
+    return receive_first if @fcid == nil
+    return receive_att if from_att?
     receive_non_att
   end
 
   def receive_first
 
-    return receive_last_att if children[0] && children[0][0] != '_att'
+    return receive_last_att if (c = children[0]) && c[0] != '_att'
     execute_child(@ncid)
   end
 
   def receive_att
 
-    nctree = children[@ncid]
+    nt = children[@ncid]
 
-    return receive_last_att if nctree == nil || nctree[0] != '_att'
+    return receive_last_att if nt == nil || nt[0] != '_att'
     execute_child(@ncid)
   end
 
@@ -477,9 +491,9 @@ class Flor::Procedure < Flor::Node
 
     if node
 
-      b, v = Flor.deep_set(node['vars'], k, v)
+      v = Flor.deep_set(node['vars'], k, v)
 
-      return v if b
+      return v unless v.is_a?(Symbol)
     end
 
     fail IndexError.new("couldn't set var #{mode}v.#{k}")
@@ -487,9 +501,9 @@ class Flor::Procedure < Flor::Node
 
   def set_field(k, v)
 
-    success, value = Flor.deep_set(payload.copy, k, v)
+    value = Flor.deep_set(payload.copy, k, v)
 
-    fail IndexError.new("couldn't set field #{k}") unless success
+    fail IndexError.new("couldn't set field #{k}") if value.is_a?(Symbol)
 
     value
   end
@@ -501,10 +515,10 @@ class Flor::Procedure < Flor::Node
     cat, mod, key = key_split(k)
 
     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}")
+    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}")
     end
   end
 
@@ -516,10 +530,12 @@ class Flor::Procedure < Flor::Node
 
     cni = fun[1]['cnid'] # closure nid
 
-    t = lookup_tree(fni)
+    t = fun[1]['tree']
+    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 fun[1]['head']
+    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'
@@ -629,6 +645,7 @@ class Flor::Macro < Flor::Procedure
   def rewrite
 
     t = rewrite_tree
+#Flor.print_tree(t, nid)
 
     m = @message.dup
     m['tree'] = t