flor 0.15.0 → 0.16.0

data/lib/flor/core/texecutor.rb

@@ -90,9 +90,7 @@ module Flor
         [], # no traps
         {
           'exid' => Flor.generate_exid('eval', 'u0'),
-          'nodes' => {}, 'errors' => [], 'counters' => {},
-          #'ashes' => {},
-          'start' => Flor.tstamp
+          'nodes' => {}, 'counters' => {}, 'start' => Flor.tstamp
         })
 
       @unit.archive = {} if conf['archive']
@@ -198,9 +196,10 @@ module Flor
           if path.match(/[\r\n]/)
             path.strip
           else
-            ls = File.readlines(path)
-            ls.reject! { |l| l.strip[0, 1] == '#' }
-            s = ls.join("\n").strip
+            File.readlines(path)
+              .reject { |l| l.strip[0, 1] == '#' }
+              .join("\n")
+              .strip
           end
 
         az = "#{src[0, 1]}#{src[-1, 1]}"
@@ -251,7 +250,7 @@ module Flor
           o['_path'] = path
           o['root'] ||= Flor.relativize_path(vs['root'])
         elsif o.is_a?(Array)
-          o.each { |e| e['_path'] = path }
+          o.each { |ee| ee['_path'] = path }
         end
 
         o

data/lib/flor/djan.rb

@@ -4,25 +4,39 @@ require 'io/console'
 
 module Flor
 
-  def self.to_djan(x, opts={}); to_d(x, opts); end
+  class << self
 
-  def self.to_d(x, opts={})
+    def to_djan(x, opts={})
 
-    out = StringIO.new
-    opts[:c] = Flor.colours(opts)
+      out = StringIO.new
+      out.set_encoding('UTF-8')
 
-    if [ :console, true ].include?(opts[:width])
-      opts[:width] = IO.console.winsize[1] rescue 80
-    #elsif opts[:width].is_a?(Integer)
-      # let it go
-    elsif mw = (opts[:mw] || opts[:maxwidth] || opts[:max_width])
-      opts[:width] = [ (IO.console.winsize[1] rescue 80), mw ].min
+      opts[:c] = Flor.colours(opts)
+
+      if [ :console, true ].include?(opts[:width])
+        opts[:width] = IO.console.winsize[1] rescue 80
+      #elsif opts[:width].is_a?(Integer)
+        # let it go
+      elsif mw = (opts[:mw] || opts[:maxwidth] || opts[:max_width])
+        opts[:width] = [ (IO.console.winsize[1] rescue 80), mw ].min
+      end
+      opts[:indent] ||= 0 if opts[:width]
+
+      opts[:str_escape] ||= []
+
+      Djan.to_d(x, out, opts)
+
+      out.string
     end
-    opts[:indent] ||= 0 if opts[:width]
 
-    Djan.to_d(x, out, opts)
+    alias to_d to_djan
 
-    out.string
+    # to_d, but without colours
+    #
+    def to_dnc(x)
+
+      to_d(x, colours: false)
+    end
   end
 
   module Djan
@@ -132,9 +146,9 @@ module Flor
           end
         end
 
-      x.each_with_index do |(k, v), i|
+      x.each_with_index do |(k, v), ii|
 
-        kl = string_to_d(k, out, indent(opts, first: i == 0))
+        kl = string_to_d(k, out, indent(opts, first: ii == 0))
         c_inf(':', out, opts)
 
         kt = key_max_len ? key_max_len - kl : nil
@@ -142,7 +156,7 @@ module Flor
 
         to_d(v, out, indent(opts, inc: 2, keytab: kt))
 
-        if i < x.size - 1
+        if ii < x.size - 1
           c_inf(',', out, opts)
           newline_or_space(out, opts)
         end
@@ -190,12 +204,12 @@ module Flor
         opts[:json] ||
         x.match(/\A[^: \b\f\n\r\t"',()\[\]{}#\\+%\/><^!=-]+\z/) == nil ||
         x.to_i.to_s == x ||
-        x.to_f.to_s == x
+        x.to_f.to_s == x ||
+        opts[:str_escape].include?(x)
       ) then
-        c_inf('"', out, opts)
-        c_str(x.inspect[1..-2], out, opts)
-        c_inf('"', out, opts)
-        x.inspect[1..-2].length + 2
+        s = x.inspect
+        c_str(s, out, opts)
+        s.length
       else
         c_str(x, out, opts)
         x.length
@@ -222,7 +236,12 @@ module Flor
     def c_nil(s, out, opts); out << opts[:c].dark_gray(s); end
     def c_tru(s, out, opts); out << opts[:c].green(s); end
     def c_fal(s, out, opts); out << opts[:c].red(s); end
-    def c_str(s, out, opts); out << opts[:c].brown(s); end
+    #def c_str(s, out, opts); out << opts[:c].brown(s); end
+    def c_str(s, out, opts)
+      out << opts[:c].brown(s)
+      #out << opts[:c].brown(s).tap { |x| p [ x, x.encoding ] }
+      #out << opts[:c].brown(s).encode('UTF-8')
+    end
     def c_num(s, out, opts); out << opts[:c].light_blue(s); end
   end
 end

data/lib/flor/flor.rb

@@ -6,7 +6,8 @@ module Flor
   DOMAIN_NAME_REX = /\A#{NAME_REX}(\.#{NAME_REX})*\z/
   FLOW_NAME_REX = /\A(#{NAME_REX}(?:\.#{NAME_REX})*)\.([a-zA-Z0-9_-]+)\z/
 
-  DOMAIN_UNIT_REX = /\A(#{NAME_REX}(?:\.#{NAME_REX})*)-(#{NAME_REX})[-\z]/
+  #DOMAIN_UNIT_REX = /\A(#{NAME_REX}(?:\.#{NAME_REX})*)-(#{NAME_REX})[-\z]/
+  DOMAIN_UNIT_REX = /\A(#{NAME_REX}(?:\.#{NAME_REX})*)-(#{NAME_REX})[-$]/
 
   SPLAT_REGEX = /\A(.*)__(_|\d+)\z/.freeze
 
@@ -38,6 +39,8 @@ module Flor
       v = ENV[k]; (v && v.match(/\A\d+\z/)) ? v.to_i : nil
     end
 
+    # Returns a new, complete (not shallow), copy of the target instance.
+    #
     def dup(o)
 
       Marshal.load(Marshal.dump(o))
@@ -45,7 +48,7 @@ module Flor
 
     def dup_and_merge(h, hh)
 
-      self.dup(h).merge(hh)
+      self.dup(h).merge!(hh)
     end
     def dupm(h, hh); self.dup_and_merge(h, hh); end
 
@@ -73,7 +76,7 @@ module Flor
     def to_error(o)
 
       h = {}
-      h['kla'] = o.class.to_s
+      h['kla'] = o.class == String ? 'Flor::FlorError' : o.class.to_s
 
       m, t =
         if o.is_a?(::Exception)
@@ -95,6 +98,20 @@ module Flor
       h
     end
 
+    def to_error_message(message, err)
+
+      m = message
+        .select { |k, v|
+          %w[ sm exid nid from payload tree er tasker ].include?(k) }
+
+      m['point'] = 'failed'
+      m['fpoint'] = message['point']
+      m['fm'] = message['m']
+      m['error'] = to_error(err)
+
+      m
+    end
+
     def const_lookup(s)
 
       s.split('::')
@@ -102,6 +119,11 @@ module Flor
         .inject(Kernel) { |k, sk| k.const_get(sk, k == Kernel) }
     end
 
+    def is_collection?(o)
+
+      o.is_a?(Array) || o.is_a?(Hash)
+    end
+
     def to_coll(o)
 
       #o.respond_to?(:to_a) ? o.to_a : [ a ]
@@ -117,18 +139,22 @@ module Flor
       path || '.'
     end
 
+    def is_message?(o)
+
+      o.is_a?(Hash) &&
+      o['point'].is_a?(String) &&
+      o.keys.all? { |k| k.is_a?(String) }
+    end
+
     def is_array_of_messages?(o)
 
       o.is_a?(Array) &&
-      o.all? { |e|
-        e.is_a?(Hash) &&
-        e['point'].is_a?(String) &&
-        e.keys.all? { |k| k.is_a?(String) } }
+      o.all? { |e| is_message?(o) }
     end
 
     def h_fetch(h, *keys)
 
-      k = keys.find { |k| h.has_key?(k) }
+      k = keys.find { |kk| h.has_key?(kk) }
       k ? h[k] : nil
     end
 
@@ -136,7 +162,7 @@ module Flor
 
       default = keys.last.is_a?(String) ? [] : keys.pop
 
-      k = keys.find { |k| h.has_key?(k) }
+      k = keys.find { |kk| h.has_key?(kk) }
       v = k ? h[k] : nil
 
       v_to_a(v) || default
@@ -163,10 +189,16 @@ module Flor
     def to_regex(o)
 
       s =
-        case o
-        when String then o
-        when Array then o[1].to_s # hopefully regex tree
-        else o.to_s
+        if o.is_a?(String)
+          o
+        elsif o.is_a?(Array)
+          if (o[0] == '_rxs' || o[0] == 'regex') && o[2].is_a?(Integer)
+            o[1].to_s
+          else
+            "/#{o[0..-2].join}/#{o[-1]}"
+          end
+        else
+          o.to_s
         end
 
       m = s.match(/\A\/(.*)\/([imxouesn]*)\z/)
@@ -340,12 +372,31 @@ module Flor
       t[1].is_a?(Array)
     end
 
+    def is_definition_tree?(t)
+
+      t.is_a?(Array) &&
+      Flor::Pro::Define.names.include?(t[0]) &&
+      t[2].is_a?(Integer) &&
+      t[1].is_a?(Array)
+    end
+
+    def is_def_tree?(t)
+
+      is_definition_tree?(t) &&
+      t[0] != 'define'
+    end
+
     def is_array_of_trees?(o)
 
       o.is_a?(Array) &&
       o.all? { |e| Flor.is_tree?(e) }
     end
 
+    def is_single_ref_tree?(t)
+
+      t.is_a?(Array) && t[0].is_a?(String) && t[0] != '_' && t[1] == []
+    end
+
 #  # Array, object or atom tree
 #  #
 #  def is_value_tree?(o)
@@ -372,14 +423,16 @@ module Flor
       o[1].is_a?(Hash) && (o[1].keys & %w[ nid cnid fun ]).size == 3
     end
 
-#    def is_task_tree?(o)
-#
-#      o.is_a?(Array) &&
-#      o[0] == '_task' &&
-#      o[2].is_a?(Integer) &&
-#      o[1].is_a?(Hash) &&
-#      o[1]['task'].is_a?(String)
-#    end
+    def is_tasker_tree?(o)
+
+      # [ '_tasker', { 'tasker' => 'alan' }, -1 ]
+
+      o.is_a?(Array) &&
+      o[0] == '_tasker' &&
+      o[2].is_a?(Integer) &&
+      o[1].is_a?(Hash) &&
+      o[1]['tasker'].is_a?(String)
+    end
 
     def is_regex_tree?(o)
 
@@ -397,10 +450,10 @@ module Flor
 
       return nil if t == nil
 
-      n, i, d = nid.split('_', 3)
+      _, i, d = nid.split('_', 3)
 
       return [ t, nil ] if i == nil
-      return [ t, i.to_i ] if ! d
+      return [ t, i.to_i ] if d == nil
       parent_tree_locate(t[1][i.to_i], [ i, d ].join('_'))
     end
 
@@ -417,36 +470,78 @@ module Flor
 
 
     #
-    # splat
+    # misc
 
-    def splat(keys, array)
+    def point?(s)
 
-      ks = keys.dup
-      a = array.dup
-      h = {}
+      POINTS.include?(s)
+    end
 
-      while k = ks.shift
+    def type(o)
 
-        if m = SPLAT_REGEX.match(k)
-          r, l = m[1, 2]
-          l = (l == '_') ? a.length - ks.length : l.to_i
-          h[r] = a.take(l) if r.length > 0
-          a = a.drop(l)
-        else
-          h[k] = a.shift
-        end
+      case o
+      when Array then :array
+      when Hash then :object
+      when String then :string
+      when true, false then :boolean
+      when Numeric then :number
+      when nil then :null
+      else nil
       end
-
-      h
     end
 
 
     #
-    # misc
+    # Dense paths
 
-    def point?(s)
+    def path_to_s(path)
 
-      POINTS.include?(s)
+      path_to_dense_path(path).to_s
+    end
+
+    def path_to_dense_path(path)
+
+      Dense::Path.make(path.collect { |e| path_elt_to_dense_path_elt(e) })
+    end
+
+    def path_elt_to_dense_path_elt(elt)
+
+      case elt
+      #when String then elt
+      #when Integer then elt
+      when { 'dot' => true } then :dot
+      when { 'star' => true } then :star
+      when { 'dotstar' => true } then :star
+      when Array then elt.collect { |e| path_elt_to_dense_path_elt(e) }
+# TODO regexes
+      else elt
+      end
+    end
+
+    def tree_to_pp_s(t, out=StringIO.new, indent='')
+
+      out.print("#{indent}[ '#{t[0]}', ")
+      if t[1] == []
+        out.print("[]")
+      elsif t[1].is_a?(Array)
+        out.print("[\n")
+        t[1].each_with_index do |ct, i|
+          tree_to_pp_s(ct, out, indent + '  ')
+          if i < t[1].length - 1
+            out.print(",\n")
+          else
+            out.print("\n#{indent}")
+          end
+        end
+        out.print("]")
+      else
+        out.print(t[1].inspect)
+      end
+      out.print(", #{t[2]}")
+      out.print(", '#{t[3]}'") if t[3]
+      out.print(" ]")
+
+      indent == '' ? out.string : nil
     end
   end
 end

data/lib/flor/id.rb

@@ -1,95 +1,113 @@
 
 module Flor
 
-  #
-  # ids
-  #
-  # functions about exids, nids, sub_nids, ...
+  class << self
 
-  def self.split_fei(fei)
+    #
+    # ids
+    #
+    # functions about exids, nids, sub_nids, ...
 
-    if m = fei.match(/\A([^-]+-[^-]+-\d+\.\d+\.[^-]+)-(.*)\z/)
-      [ m[1], m[2] ]
-    else
-      [ nil ]
+    def split_fei(fei)
+
+      if m = fei.match(/\A([^-]+-[^-]+-\d+\.\d+\.[^-]+)-(.*)\z/)
+        [ m[1], m[2] ]
+      else
+        [ nil ]
+      end
     end
-  end
 
-  def self.exid(fei)
+    def exid(fei)
 
-    split_fei(fei).first
-  end
+      split_fei(fei).first
+    end
 
-  def self.split_nid(nid)
+    def split_nid(nid)
 
-    nid.split('-')
-  end
+      nid.split('-')
+    end
 
-  def self.child_id(nid)
+    def child_id(nid)
 
-    nid ? nid.split('_').last.split('-').first.to_i : nil
-  end
+      nid ? nid.split('_').last.split('-').first.to_i : nil
+    end
 
-  def self.next_child_id(nid)
+    def next_child_id(nid)
 
-    child_id(nid) + 1
-  end
+      child_id(nid) + 1
+    end
 
-  def self.sub_nid(nid, subid=nil)
+    def sub_nid(nid, subid=nil)
 
-    if subid
-      "#{nid.split('-').first}-#{subid}"
-    else
-      ss = nid.split('-')
-      ss.length > 1 ? ss.last.to_i : 0
+      if subid
+        "#{nid.split('-').first}-#{subid}"
+      else
+        ss = nid.split('-')
+        ss.length > 1 ? ss.last.to_i : 0
+      end
     end
-  end
 
-  # Remove the sub_nid if any.
-  #
-  def self.master_nid(nid)
+    def same_sub?(nid0, nid1)
 
-    nid.split('-').first
-  end
+      sub_nid(nid0) == sub_nid(nid1)
+    end
 
-  def self.child_nid(nid, i, sub=nil)
+    def same_branch?(nid0, nid1)
 
-    nid, subnid = nid.split('-')
-    subnid = sub if sub && sub > 0
+      return false unless same_sub?(nid0, nid1)
 
-    "#{nid}_#{i}#{subnid ? "-#{subnid}" : ''}"
-  end
+      n0, n1 = [ nid0, nid1 ].collect { |i| Flor.master_nid(i) }.sort
+      n = n1[0, n0.length]
 
-  def self.parent_id(nid)
+      n == n0
+    end
 
-    if i = nid.rindex('_')
-      nid[0, i]
-    else
-      nil
+    # Remove the sub_nid if any.
+    #
+    def master_nid(nid)
+
+      nid.split('-').first
     end
-  end
 
-  def self.parent_nid(nid, remove_subnid=false)
+    def child_nid(nid, i, sub=nil)
 
-    _, sub = nid.split('-')
-    i = nid.rindex('_')
+      nid, subnid = nid.split('-')
+      subnid = sub if sub && sub > 0
 
-    return nil unless i
-    "#{nid[0, i]}#{remove_subnid || sub.nil? ? nil : "-#{sub}"}"
-  end
+      "#{nid}_#{i}#{subnid ? "-#{subnid}" : ''}"
+    end
 
-  def self.is_nid?(s)
+    def parent_id(nid)
 
-    !! (s.is_a?(String) && s.match(/\A[0-9]+(?:_[0-9]+)*(?:-[0-9]+)?\z/))
-  end
+      if i = nid.rindex('_')
+        nid[0, i]
+      else
+        nil
+      end
+    end
+
+    def parent_nid(nid, remove_subnid=false)
 
-  # Returns [ exid, nid ]
-  #
-  def self.extract_exid_and_nid(s)
+      _, sub = nid.split('-')
+      i = nid.rindex('_')
 
-    m = s.match(/(\d{8}\.\d{4}\.[a-z]+)-(\d+(?:_\d+)*)(-\d+)?/)
+      return nil unless i
+      "#{nid[0, i]}#{remove_subnid || sub.nil? ? nil : "-#{sub}"}"
+    end
+
+    def is_nid?(s)
+
+      !! (s.is_a?(String) && s.match(/\A[0-9]+(?:_[0-9]+)*(?:-[0-9]+)?\z/))
+    end
 
-    m ? [ m[1], [ m[2], m[3] ].compact.join ] : nil
+    # Returns [ exid, nid ]
+    #
+    def extract_exid_and_nid(s)
+
+      m = s.match(/(\d{8}\.\d{4}\.[a-z]+)-(\d+(?:_\d+)*)(-\d+)?/)
+
+      m ? [ m[1], [ m[2], m[3] ].compact.join ] : nil
+    end
   end
 end