flor 0.16.1 → 0.16.2

data/lib/flor/id.rb

@@ -76,6 +76,7 @@ module Flor
 
       "#{nid}_#{i}#{subnid ? "-#{subnid}" : ''}"
     end
+    alias make_child_nid child_nid
 
     def parent_id(nid)
 
@@ -100,6 +101,24 @@ module Flor
       !! (s.is_a?(String) && s.match(/\A[0-9]+(?:_[0-9]+)*(?:-[0-9]+)?\z/))
     end
 
+    def split_exid(s)
+
+      return nil unless s.is_a?(String)
+
+      _, d, u, t = s
+        .match(/\A([^-\s]+)-([^-\s]+)-(\d{8,9}\.\d{4}\.[a-z]+)\z/)
+        .to_a
+
+      return nil unless d && u && t
+
+      [ d, u, t ]
+    end
+
+    def is_exid?(s)
+
+      !! split_exid(s)
+    end
+
     # Returns [ exid, nid ]
     #
     def extract_exid_and_nid(s)

data/lib/flor/migrations/0001_tables.rb

@@ -5,7 +5,7 @@ Sequel.migration do
 
     create_table :flor_messages do
 
-      primary_key :id, type: :Integer
+      primary_key :id
       String :domain, null: false
       String :exid, null: false
       String :point, null: false # 'execute', 'task', 'receive', 'schedule', ...
@@ -19,7 +19,7 @@ Sequel.migration do
 
     create_table :flor_executions do
 
-      primary_key :id, type: :Integer
+      primary_key :id
       String :domain, null: false
       String :exid, null: false
       File :content # JSON
@@ -32,7 +32,7 @@ Sequel.migration do
 
     create_table :flor_timers do
 
-      primary_key :id, type: :Integer
+      primary_key :id
       String :domain, null: false
       String :exid, null: false
       String :nid, null: false
@@ -51,7 +51,7 @@ Sequel.migration do
 
     create_table :flor_traps do
 
-      primary_key :id, type: :Integer
+      primary_key :id
       String :domain, null: false
       String :exid, null: false
       String :onid, null: false
@@ -76,7 +76,7 @@ Sequel.migration do
 
     create_table :flor_pointers do
 
-      primary_key :id, type: :Integer
+      primary_key :id
       String :domain, null: false
       String :exid, null: false
       String :nid, null: false
@@ -97,7 +97,7 @@ Sequel.migration do
 
     create_table :flor_traces do
 
-      primary_key :id, type: :Integer
+      primary_key :id
       String :domain, null: false
       String :exid, null: false
       String :nid, null: true

data/lib/flor/migrations/0005_pointer_content.rb

@@ -0,0 +1,20 @@
+
+Sequel.migration do
+
+  up do
+
+    alter_table :flor_pointers do
+
+      add_column :content, File
+    end
+  end
+
+  down do
+
+    alter_table :flor_pointers do
+
+      drop_column :content
+    end
+  end
+end
+

data/lib/flor/pcore/_apply.rb

@@ -16,63 +16,7 @@ class Flor::Pro::UnderscoreApply < Flor::Procedure
       @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
+    map_arguments_to_parameters
 
     super
   end
@@ -104,5 +48,107 @@ class Flor::Pro::UnderscoreApply < Flor::Procedure
 
     ms
   end
+
+  protected
+
+  def compute_param_key(t)
+
+    t0 = t[0]
+    k = t0[0]
+
+    if k == '_ref' && t0[1].is_a?(Array) && t0[1].length > 0
+      t[0][1].collect { |tt| tt[1].to_s }.join('.')
+    else
+      k
+    end
+  end
+
+  def map_arguments_to_parameters
+
+    @node['vars'] = {}
+
+    args = message['arguments']
+
+    @node['vars']['arguments'] = args
+
+    tr = tree
+    retree = nil
+
+    params = tr[1]
+      .select { |t| t[0] == '_att' }
+      .inject([]) { |a, t|
+        t1 = t[1]
+        a << [ compute_param_key(t1), t[1][0], t[1][1] ]
+        a }
+    args = args.dup
+#puts "\n---"
+#puts "== params:"
+#params.each_with_index { |a, i| printf "%2d: %s\n", i, a.inspect }
+#puts "== args:"
+#args.each_with_index { |a, i| printf "%2d: %s\n", i, a.inspect }
+#puts
+
+    # first, make 2 passes on params
+    # 1). grab named args
+    # 2). grab remaining args
+    # then make 1 pass on still remaining args
+    # 1). set vars if not yet set
+
+    seen = []
+
+    params.each do |param_key, param_tree|
+      next if param_tree[0] == '_ref'
+      arg_i = args.index { |arg_key, arg_val| arg_key == param_key }
+      next unless arg_i
+      arg_key, arg_val = args.delete_at(arg_i)
+      seen << arg_key
+      set_param(param_key, arg_val)
+    end
+#puts "== 0 vars:"; pp @node['vars']
+    params.each_with_index do |(param_key, param_tree, param_val), param_i|
+      ref = param_tree[0] == '_ref'
+      next if ! ref && @node['vars'].has_key?(param_key)
+      seen << param_key
+      if param_i < args.length
+        arg_key, arg_val = args[param_i]
+        seen << arg_key
+        set_param(param_key, arg_val)
+      elsif param_val
+        l = tree[2]
+        retree ||= Flor.dup(tr)
+        retree[1][param_i] = [ 'set', [ [ param_key, [], l ], param_val ], l ]
+      else
+        set_param(param_key, nil) unless ref
+      end
+    end
+#puts "== seen:"; p seen
+    args.each do |arg_key, arg_val|
+      set_param(arg_key, arg_val) unless seen.include?(arg_key)
+    end
+
+#puts "\n== 1 vars: "; pp @node['vars']
+#puts "\n== 1 fields: "; pp payload.current
+  #
+#print "vars: "
+#pp @node['vars'].collect { |k, v| [ k, JSON.dump(v)[0, 20] + "..." ] }
+#print "vars: "
+#@node['vars'].each { |k, v| print "#{k.inspect} --> "; pp v }
+
+#puts "== retree:"; pp retree; puts
+    @node['tree'] = retree if retree
+  end
+
+  def set_param(key, val)
+
+    return unless key
+
+    if m = key.match(/\A(?:field|fld|f)\.(.+)\z/)
+      Dense.set(payload.copy, m[1], val)
+    elsif m = key.match(/\A(?:variable|var|v)\.(.+)\z/)
+      Dense.set(@node['vars'], m[1], val)
+    else
+      Dense.set(@node['vars'], key, val)
+    end
+  end
 end
 

data/lib/flor/pcore/_att.rb

@@ -234,8 +234,22 @@ class Flor::Pro::Att < Flor::Procedure
 
     wrap_reply('disable' => Flor.true?(payload['ret']))
   end
-
+    #
   alias receive_off receive_disabled
   alias receive_disable receive_disabled
+
+  def receive_child_on_error
+    if pn = parent_node; pn['child_on_error'] = payload_ret; end; wrap_reply
+  end
+  def receive_child_on_cancel
+    if pn = parent_node; pn['child_on_cancel'] = payload_ret; end; wrap_reply
+  end
+  def receive_child_on_timeout
+    if pn = parent_node; pn['child_on_timeout'] = payload_ret; end; wrap_reply
+  end
+    #
+  alias receive_children_on_error receive_child_on_error
+  alias receive_children_on_cancel receive_child_on_cancel
+  alias receive_children_on_timeout receive_child_on_timeout
 end
 

data/lib/flor/pcore/_ref.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Ref < Flor::Procedure
 
-  names %w[ _ref _rep ]
+  names %w[ _ref _rep _reff ]
 
   def pre_execute
 
@@ -44,6 +44,7 @@ class Flor::Pro::Ref < Flor::Procedure
     return nil if field?(ke.work_path)
     return nil if child_id == 1 && (n = parent_node) && n['heat0'] == '_head'
     return nil if ke.miss[1].any? && ke.miss[4].empty?
+    return nil if tree[0] == '_reff'
 
     raise
   end

data/lib/flor/pcore/arith.rb

@@ -23,7 +23,19 @@ class Flor::Pro::Arith < Flor::Procedure
   #   3 # ==> -4
   # ```
   #
-  # ...
+  # ```
+  # [ 1 2 3 ]
+  # + _ # ==> 6
+  #
+  # [ 2 3 4 ]
+  # * _ # ==> 24
+  # ```
+  #
+  # ```
+  # + "hell" "o"
+  # "hel" + "lo"
+  #   # both yield "hello"
+  # ```
 
   names %w[ + - * / % ]
 
@@ -32,26 +44,41 @@ class Flor::Pro::Arith < Flor::Procedure
   def pre_execute
 
     @node['rets'] = []
+    @node['atts'] = []
+
+    unatt_unkeyed_children
   end
 
   def receive_last
 
     sign = tree.first.to_sym
-    count = @node['rets'].size
+
+    rets = @node['rets']
+    rets << node_payload_ret \
+      if rets.empty? && node_payload_ret.is_a?(Array)
+    rets = rets[0] \
+      if rets.size == 1 && rets[0].is_a?(Array)
 
     fail Flor::FlorError.new('modulo % requires at least 2 arguments', self) \
-      if sign == :% && count < 2
+      if sign == :% && rets.size < 2
+
+    if j = att('join')
+      max = rets.size - 1
+      rets = rets.each_with_index.inject([]) { |a, (e, i)|
+        a << e
+        a << j if i < max
+        a }
+      rets[0] = stringify(rets[0]) \
+        if rets.any? && j.is_a?(String)
+    end
 
     ret =
-      if @node['rets'].compact.empty?
+      if rets.compact.empty?
         DEFAULTS[sign]
       elsif sign == :+
-        @node['rets'].reduce { |r, e|
-          # TODO use djan instead of #to_s?
-          # TODO use JSON instead of #to_s or djan?
-          r + (r.is_a?(String) ? e.to_s : e) }
+        rets.reduce { |r, e|
+          r + (r.is_a?(String) ? stringify(e) : e) }
       else
-        rets = @node['rets']
         rets = rets.collect(&:to_f) \
           if sign == :/ || rets.find { |r| r.is_a?(Float) }
         rets.reduce(&sign)
@@ -65,5 +92,15 @@ class Flor::Pro::Arith < Flor::Procedure
 
     wrap_reply('ret' => ret)
   end
+
+  protected
+
+  def stringify(o)
+
+    # TODO use djan instead of #to_s?
+    # TODO use JSON instead of #to_s or djan?
+
+    o.to_s
+  end
 end
 

data/lib/flor/pcore/break.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Break < Flor::Procedure
   #
-  # Breaks or continues a "while", "until", "loop" or an "cursor".
+  # Breaks or continues a "while", "until", "loop" or a "cursor".
   #
   # ```
   # until false

data/lib/flor/pcore/case.rb

@@ -85,6 +85,47 @@ class Flor::Pro::Case < Flor::Procedure
   # # yields "matched:molzin"
   # ```
   #
+  # ### defaulting to f.ret
+  #
+  # When nothing is explicitely provided for consideration by "case", the
+  # incoming `f.ret` is used.
+  #
+  # ```
+  # 2
+  # case
+  #   [ 0 1 2 ]; 'low'
+  #   6; 'high'
+  #   else; 'over'
+  # # yields 'low'
+  # ```
+  #
+  # ### incoming f.ret is preserved
+  #
+  # "case" makes sure `f.ret` gets to its upon-entering-"case" value
+  # when considered inside:
+  #
+  # ```
+  #  7
+  #  case (+ 3 4)
+  #    5; 'cinq'
+  #    [ f.ret ]; 'sept'
+  #    6; 'six'
+  #    else; 'whatever...'
+  #
+  #  # yields 'sept'
+  # ```
+  #
+  # ```
+  # "six"
+  # case 6
+  #   5; 'cinq'
+  #   7; 'sept'
+  #   6; "six $( f.ret | upcase _ )"
+  #   else; 'je ne sais pas'
+  #
+  # # yields "six SIX"
+  # ```
+  #
   # ## see also
   #
   # Match, cond, if.