flor 0.15.0 → 0.16.0

data/lib/flor/pcore/_apply.rb

@@ -0,0 +1,108 @@
+
+class Flor::Pro::UnderscoreApply < Flor::Procedure
+
+  name '_apply'
+
+  def execute
+
+    #if oe = message['on_error']
+    #  @node['in_on_error'] = oe
+    #end
+      #
+      # which is equivalent, for now, to
+      #
+    if message['on_error']
+      #@node['in_on_error'] = true
+      @node['in_on_error'] = from
+    end
+
+    vars = @node['vars'] = {}
+    args = message['arguments']
+
+    vars['arguments'] = args
+
+    tr = tree
+    retree = nil
+
+    atts = tr[1].inject([]) { |a, t| a << t[1] if t[0] == '_att'; a }
+    args = args.dup
+#puts "\n---"
+#puts "== atts (sig):"; pp atts;   # signature
+#puts "== args (given):"; pp args  # passed arguments
+#puts
+
+    # first, make 2 passes on atts
+    # 1). grab named args
+    # 2). grab remaining args
+    # then make 1 pass on still remaining args
+    # 1). set vars if not yet set
+
+    seen = []
+
+    atts
+      .each { |(att_key, _), _|
+        arg_i = args.index { |arg_key, arg_val| arg_key == att_key }
+        next unless arg_i
+        arg_key, arg_val = args.delete_at(arg_i)
+        seen << arg_key
+        vars[att_key] = arg_val }
+#puts "== 0 vars:"; pp vars
+    atts
+      .each_with_index { |((att_key, _), att_val), att_i|
+        next if vars.has_key?(att_key)
+        seen << att_key
+        if att_i < args.length
+          arg_key, arg_val = args[att_i]
+          seen << arg_key
+          vars[att_key] = arg_val
+        elsif att_val
+          l = tree[2]
+          retree ||= Flor.dup(tr)
+          retree[1][att_i] = [ 'set', [ [ att_key, [], l ], att_val ], l ]
+        else
+          vars[att_key] = nil
+        end }
+#puts "== seen:"; p seen
+    args
+      .each { |arg_key, arg_val|
+        vars[arg_key] = arg_val unless seen.include?(arg_key) }
+
+#puts "\n== 1 vars: "; pp vars
+#print "vars: "; pp vars.collect { |k, v| [ k, JSON.dump(v)[0, 20] + "..." ] }
+#print "vars: "; vars.each { |k, v| print "#{k.inspect} --> "; pp v }
+
+    @node['tree'] = retree if retree
+#puts "== retree:"; pp retree
+
+    super
+  end
+
+  def execute_child(index=0, sub=nil, h=nil)
+
+    t0 = tree[1][index] && tree[1][index][0]
+
+    if t0 && %w[ _att _name ].include?(t0) # skip those
+      execute_child(index + 1)
+    else
+      super
+    end
+  end
+
+  #def cancel_when_closed
+  #  return cancel if node_status_flavour == 'on-error'
+  #  []
+  #end
+    #
+    # as it was when "_apply" was an alias to "sequence"
+
+  def wrap_reply(h={})
+
+    ms = super
+
+    ioe = @node['in_on_error']
+    ms[0]['from_on_error'] = ioe if ioe
+
+    ms
+  end
+end
+

data/lib/flor/pcore/_atom.rb

@@ -1,15 +1,13 @@
 
 class Flor::Pro::Atom < Flor::Procedure
 
-  names %w[ _num _boo _sqs _dqs _rxs _nul _func ]
+  names %w[ _num _boo _sqs _nul _func ]
 
   def execute
 
     payload['ret'] =
-      case @node['heat0']
+      case heap
       when '_nul' then nil
-      when '_dqs' then expand(tree[1])
-      when '_rxs' then [ tree[0], expand(tree[1]), *tree[2..-1] ]
       when '_func' then tree
       else tree[1]
       end

data/lib/flor/pcore/_att.rb

@@ -31,6 +31,8 @@ class Flor::Pro::Att < Flor::Procedure
   #
   # execute phase
 
+  # For example, turns `sequence flank` into `sequence flank: true`
+  #
   def pre_execute_boolean_attribute
 
     return unless children.size == 1
@@ -39,7 +41,10 @@ class Flor::Pro::Att < Flor::Procedure
     t[1] << [ '_boo', true, @node['tree'][2] ]
   end
 
-  alias pre_execute_flank pre_execute_boolean_attribute
+  TRUE_ATTS
+    .each do |k|
+      alias_method "pre_execute_#{k}", :pre_execute_boolean_attribute
+    end
 
   def pre_execute_vars
 
@@ -49,6 +54,8 @@ class Flor::Pro::Att < Flor::Procedure
 
     return if t[1][1][1] == 0 # [ '_obj', 0, 123 ]
 
+    # add `quote: 'keys'` to the _obj so that they may be `k0:` or `'k0':`
+
     t = @node['tree'] = Flor.dup(t)
 
     t[1][1][1].unshift([
@@ -79,16 +86,13 @@ class Flor::Pro::Att < Flor::Procedure
 
   def unref(k, flavour=:key)
 
-    #return lookup_var_name(@node, k) if Flor.is_func_tree?(k)
-      # old style
-
     return k unless Flor.is_tree?(k)
     return k unless k[1].is_a?(Hash)
-    return k unless %w[ _proc _task _func ].include?(k[0])
+    return k unless %w[ _proc _tasker _func ].include?(k[0])
 
     (flavour == :key ? nil : k[1]['oref']) ||
     k[1]['ref'] ||
-    k[1]['proc'] || k[1]['task']
+    k[1]['proc'] || k[1]['tasker']
   end
 
   def receive_att(key)
@@ -112,27 +116,32 @@ class Flor::Pro::Att < Flor::Procedure
   #
   def receive_vars
 
-    vars =
-      case (vs = payload['ret'])
-      when 'copy', '*' then copy_vars
-      when Array then wlist_vars(vs)
-      else vs
-      end
-
-    (parent_node['vars'] ||= {}).merge!(vars)
+    vs = payload['ret']
 
-    payload['ret'] = @node['ret']
+    if vs.is_a?(Array)
+      key, list = vlist(vs) # 'vwlist' var white iist, 'vblist' black list
+      parent_node[key] = list
+    else
+      (parent_node['vars'] ||= {}).merge!(vdict(vs))
+    end
 
-    wrap_reply
+    wrap('ret' => @node['ret'])
   end
 
-  def copy_vars
+  def vdict(vs)
 
-    @executor.vars(nid)
-      # Returns a hash of all the vars known at point `nid` of the execution
+    case vs
+    when Hash
+      vs
+    when 'copy', '*'
+      @executor.vars(nid) # all the vars known at that point
+    else
+      fail Flor::FlorError.new(
+        "vars: doesn't know how to deal with #{vs.inspect}", self)
+    end
   end
 
-  def wlist_vars(vs)
+  def vlist(vs)
 
     mode =
       case vs.first
@@ -142,24 +151,20 @@ class Flor::Pro::Att < Flor::Procedure
       end
     vs.shift if mode
 
-    vs = vs.collect { |v| Flor.is_regex_tree?(v) ? Flor.to_regex(v) : v }
-    vars = copy_vars
+    vs = vs
+      .collect { |v|
+        if Flor.is_regex_tree?(v)
+          Flor.to_regex(v)
+        else
+          fail Flor::FlorError.new(
+            "vars: is limited to 1st level, #{v.inspect} doesn't comply", self
+          ) if v.index('.')
+          v
+        end }
 
-    if mode == '-'
-      Hash[vars.map { |k, v| [ k, var_match?(vs, k) ? nil : v ] }]
-    else
-      Hash[vars.map { |k, v| [ k, var_match?(vs, k) ? v : nil ] }]
-    end
-  end
-
-  def var_match?(vs, key)
-
-    vs.each do |v|
-      return true if v == key
-      return true if v.is_a?(Regexp) && v =~ key
-    end
+    mode = (mode || '+') == '+' ? 'vwlist' : 'vblist'
 
-    false
+    [ mode, vs ]
   end
 
   def parent_is_trap?
@@ -217,8 +222,20 @@ class Flor::Pro::Att < Flor::Procedure
     return wrap_reply unless Flor.true?(payload['ret'])
     return wrap_reply unless parent_node
 
-    Flor::Procedure.make(@executor, parent_node, @message).flank +
+    parent_node_procedure.flank +
     wrap_reply
   end
+
+  # Might turn the "disable" flag to true, which forces the parent node
+  # (the node bearing the att under evaluation right now) to terminate
+  # immediately (by replying to its own parent node).
+  #
+  def receive_disabled
+
+    wrap_reply('disable' => Flor.true?(payload['ret']))
+  end
+
+  alias receive_off receive_disabled
+  alias receive_disable receive_disabled
 end
 

data/lib/flor/pcore/_dmute.rb

@@ -0,0 +1,18 @@
+
+class Flor::Pro::Dmute < Flor::Procedure
+
+  name '_dmute'
+
+  def pre_execute
+
+    @node['on_error'] = [
+      [ [ '*' ],
+        { 'point' => 'receive',
+          'nid' => nid,
+          'from' => Flor.child_nid(nid, 999 + tree[1].size),
+            # "#{nid}_#{999 + child.count}"
+          'exid' => exid,
+          'payload' => @message['payload'].merge('ret' => '') } ] ]
+  end
+end
+

data/lib/flor/pcore/_dol.rb

@@ -0,0 +1,17 @@
+
+class Flor::Pro::Dol < Flor::Procedure
+
+  name '_dol'
+
+  def receive
+
+    return super unless @message['point'] == 'receive'
+
+    ret = payload['ret']
+
+    return super if (ret.is_a?(String) && ret.length == 0) || ret == false
+
+    wrap
+  end
+end
+

data/lib/flor/pcore/_dqs.rb

@@ -0,0 +1,35 @@
+
+class Flor::Pro::DoubleQuoteString < Flor::Procedure
+
+  name '_dqs'
+
+  def pre_execute
+
+    @node['rets'] = []
+  end
+
+  def execute_child(index=0, sub=nil, h=nil)
+
+    payload['ret'] = node_payload_ret
+      # always pass the noe_payload_ret to children
+
+    super
+  end
+
+  def receive_last
+
+    wrap('ret' => @node['rets'].collect { |e| to_string(e) }.join)
+  end
+
+  protected
+
+  def to_string(result)
+
+    case result
+    when String then result
+    when nil then ''
+    else JSON.dump(result)
+    end
+  end
+end
+

data/lib/flor/pcore/_head.rb

@@ -0,0 +1,25 @@
+
+class Flor::Pro::Head < Flor::Procedure
+
+  name '_head'
+
+  def receive
+
+    return execute_child(1) \
+      if @message['point'] == 'execute'
+        #
+        # notice how it skips the first _sqs child
+
+    h = [ tree[1][0][1], payload['ret'] ]
+    h[1] = node_payload_ret if h[0].match(/\Af(ld|ield)?\.ret\z/)
+
+    fail Flor::FlorError.new("don't know how to apply #{h[0].inspect}") \
+      if h[1] == nil
+
+    return execute_child(2, nil, '__head' => h) \
+      if @message['from'].match(/_1\z/)
+
+    super
+  end
+end
+

data/lib/flor/pcore/_obj.rb

@@ -25,7 +25,6 @@ class Flor::Pro::Obj < Flor::Pro::Coll
   def pre_execute
 
     @node['rets'] = []
-    @node['atts'] = []
   end
 
   def execute_child(index=0, sub=nil, h=nil)
@@ -33,9 +32,8 @@ class Flor::Pro::Obj < Flor::Pro::Coll
     return super if @node['rets'].size.odd?
 
     ct = children[index]
-    q = (att('quote') == 'keys')
 
-    return super unless ct[1] == [] && (deref(ct[0]) == nil || q)
+    return super unless ct[1] == []
 
     t = tree
     t[1][index] = [ '_sqs', ct[0], *ct[2..-1] ]

data/lib/flor/pcore/_pat_guard.rb

@@ -67,7 +67,7 @@ class Flor::Pro::PatGuard < Flor::Pro::PatContainer
 
   def execute_child(index=0, sub=nil, h=nil)
 
-    if (key = @node['key']) && child_type(index) == nil
+    if @node['key'] && child_type(index) == nil
       h ||= {}
       (h['vars'] ||= {}).merge!(@node['binding'])
     end

data/lib/flor/pcore/_pat_obj.rb

@@ -26,6 +26,15 @@ class Flor::Pro::PatObj < Flor::Pro::PatContainer
       @node['tree'] = [ t[0], t[1], *t[1][2..-1] ]
     end
 
+    t = tree
+    changed = false
+    t[1].each_with_index do |ct, j|
+      next if j.odd? || ct[0] != '_ref'
+      ct[0] = '_rep'
+      changed = true
+    end
+    @node['tree'] = t if changed
+
     super
   end
 
@@ -52,8 +61,7 @@ class Flor::Pro::PatObj < Flor::Pro::PatContainer
     ret = payload['ret']
 
     unless key
-      ret = ret.to_s
-      return wrap_no_match_reply unless Dense.has_key?(val, ret)
+      return wrap_no_match_reply unless Dense.has_key?(val, Array(ret))
       @node['key'] = ret
       @node['keys'] << ret if @node['keys']
       return super
@@ -132,7 +140,7 @@ class Flor::Pro::PatObj < Flor::Pro::PatContainer
   def lookup_and_quote_key(t)
 
     return t unless t[1] == []
-    [ '_sqs', lookup(t[0], true) || t[0], t[2] ]
+    [ '_sqs', (lookup_value(t[0]) rescue t[0]), t[2] ]
   end
 
   def sub_val(child_index)

data/lib/flor/pcore/_pat_regex.rb

@@ -6,11 +6,25 @@ class Flor::Pro::PatRegex < Flor::Pro::PatContainer
 
   name '_pat_regex'
 
-  def execute
+  def pre_execute
+
+    @node['rets'] = []
+    @node['atts'] = []
+  end
+
+  def execute_child(index=0, sub=nil, h=nil)
+
+    payload['ret'] = node_payload_ret
+      # always pass the noe_payload_ret to children
+
+    super
+  end
+
+  def receive_last
 
     return wrap_no_match_reply unless val.is_a?(String)
 
-    rex = Flor.to_regex(tree[1])
+    rex = Flor.to_regex(@node['rets'] + [ att('rxopts') ])
     m = rex.match(val)
 
     return wrap_no_match_reply unless m