flor 0.14.0 → 0.15.0

data/lib/flor/dollar.rb

@@ -85,8 +85,8 @@ module Flor
     def stringify(v)
 
       case v
-        when Array, Hash then JSON.dump(v)
-        else v.to_s
+      when Array, Hash then JSON.dump(v)
+      else v.to_s
       end
     end
 
@@ -118,21 +118,21 @@ module Flor
       l = s.length
 
       case cmp
-        when '>' then l > len
-        when '>=' then l >= len
-        when '<' then l < len
-        when '<=' then l <= len
-        when '=', '==' then l == len
-        when '!=', '<>' then l != len
-        else false
+      when '>' then l > len
+      when '>=' then l >= len
+      when '<' then l < len
+      when '<=' then l <= len
+      when '=', '==' then l == len
+      when '!=', '<>' then l != len
+      else false
       end
     end
 
     def to_json(o)
 
       case o
-        when Array, Hash then JSON.dump(o)
-        else JSON.dump([ o ])[1..-2]
+      when Array, Hash then JSON.dump(o)
+      else JSON.dump([ o ])[1..-2]
       end
     end
 
@@ -142,31 +142,32 @@ module Flor
 
       case fun
 
-        when 'u' then o.to_s.upcase
-        when 'd' then o.to_s.downcase
-        when 'r' then o.reverse
-        when 'c' then o.to_s.capitalize.gsub(/\s[a-z]/) { |c| c.upcase }
-        when 'q' then quote(o, false)
-        when 'Q' then quote(o, true)
+      when 'u' then o.to_s.upcase
+      when 'd' then o.to_s.downcase
+      when 'r' then o.reverse
+      when 'c' then o.to_s.capitalize.gsub(/\s[a-z]/) { |c| c.upcase }
+      when 'q' then quote(o, false)
+      when 'Q' then quote(o, true)
+      when 'l' then o.length.to_s
 
-        when 'json' then to_json(o)
+      when 'json' then to_json(o)
 
-        when /^j(.+)/
-          o.respond_to?(:join) ? o.join($1) : o
+      when /^j(.+)/
+        o.respond_to?(:join) ? o.join($1) : o
 
-        when /\Am\/(.+)\/\z/
-          match($1, o.to_s)
-        when /\As\/(.*[^\\]\/)(.+)\/([gix]*)\z/
-          substitute($1.chop, $2, $3, o.to_s)
+      when /\Am\/(.+)\/\z/
+        match($1, o.to_s)
+      when /\As\/(.*[^\\]\/)(.+)\/([gix]*)\z/
+        substitute($1.chop, $2, $3, o.to_s)
 
-        when /\A-?\d+\z/ then o.to_s[fun.to_i]
-        when /\A(-?\d+), *(-?\d+)\z/ then o.to_s[$1.to_i, $2.to_i]
-        when /\A(-?\d+)\.\.(-?\d+)\z/ then o.to_s[$1.to_i..$2.to_i]
+      when /\A-?\d+\z/ then o.to_s[fun.to_i]
+      when /\A(-?\d+), *(-?\d+)\z/ then o.to_s[$1.to_i, $2.to_i]
+      when /\A(-?\d+)\.\.(-?\d+)\z/ then o.to_s[$1.to_i..$2.to_i]
 
-        when /\A\s*l\s*([><=!]=?|<>)\s*(\d+)\z/
-          lfilter(o.to_s, $1, $2.to_i) ? o.to_s : nil
+      when /\A\s*l\s*([><=!]=?|<>)\s*(\d+)\z/
+        lfilter(o.to_s, $1, $2.to_i) ? o.to_s : nil
 
-        else o
+      else o
       end
     end
 

data/lib/flor/flor.rb

@@ -1,180 +1,247 @@
 
 module Flor
 
-  def self.to_a(o)
+  NAME_REX = '[a-zA-Z0-9_]+'
+  UNIT_NAME_REX = /\A#{NAME_REX}\z/
+  DOMAIN_NAME_REX = /\A#{NAME_REX}(\.#{NAME_REX})*\z/
+  FLOW_NAME_REX = /\A(#{NAME_REX}(?:\.#{NAME_REX})*)\.([a-zA-Z0-9_-]+)\z/
 
-    o.nil? ? nil : Array(o)
-  end
+  DOMAIN_UNIT_REX = /\A(#{NAME_REX}(?:\.#{NAME_REX})*)-(#{NAME_REX})[-\z]/
 
-  #
-  # misc
-  #
-  # miscellaneous functions
+  SPLAT_REGEX = /\A(.*)__(_|\d+)\z/.freeze
 
-  def self.env_i(k)
+  POINTS = %w[
+    execute receive
+    return
+    entered left
+    task detask
+    schedule trigger
+    signal cancel
+    terminated failed ceased
+    idle
+  ]
 
-    v = ENV[k]; (v && v.match(/\A\d+\z/)) ? v.to_i : nil
-  end
+  class << self
 
-  def self.dup(o)
+    def to_a(o)
 
-    Marshal.load(Marshal.dump(o))
-  end
+      o.nil? ? nil : Array(o)
+    end
 
-  def self.dup_and_merge(h, hh)
+    #
+    # misc
+    #
+    # miscellaneous functions
 
-    self.dup(h).merge(hh)
-  end
-  def self.dupm(h, hh); self.dup_and_merge(h, hh); end
+    def env_i(k)
 
-  def self.deep_freeze(o)
+      v = ENV[k]; (v && v.match(/\A\d+\z/)) ? v.to_i : nil
+    end
 
-    if o.is_a?(Array)
-      o.each { |e| e.freeze }
-    elsif o.is_a?(Hash)
-      o.each { |k, v| k.freeze; v.freeze }
+    def dup(o)
+
+      Marshal.load(Marshal.dump(o))
     end
 
-    o.freeze
-  end
+    def dup_and_merge(h, hh)
 
-  def self.false?(o)
+      self.dup(h).merge(hh)
+    end
+    def dupm(h, hh); self.dup_and_merge(h, hh); end
 
-    o == nil || o == false
-  end
+    def deep_freeze(o)
 
-  def self.true?(o)
+      if o.is_a?(Array)
+        o.each { |e| e.freeze }
+      elsif o.is_a?(Hash)
+        o.each { |k, v| k.freeze; v.freeze }
+      end
 
-    o != nil && o != false
-  end
+      o.freeze
+    end
+
+    def false?(o)
+
+      o == nil || o == false
+    end
 
-  def self.to_error(o)
+    def true?(o)
 
-    h = {}
-    h['kla'] = o.class.to_s
-    t = nil
+      o != nil && o != false
+    end
 
-    if o.is_a?(::Exception)
+    def to_error(o)
 
-      h['msg'] = o.message
+      h = {}
+      h['kla'] = o.class.to_s
 
-      t = o.backtrace
+      m, t =
+        if o.is_a?(::Exception)
+          [ o.message, o.backtrace ]
+        else
+          [ o.to_s, caller[1..-1] ]
+        end
 
       if n = o.respond_to?(:node) && o.node
+        h['prc'] = n.tree[0]
         h['lin'] = n.tree[2]
-        #h['tre'] = n.tree
       end
 
-    else
+      h['msg'] = m
+      h['trc'] = t[0..(t.rindex { |l| l.match(/\/lib\/flor\//) }) + 1] if t
+      h['cwd'] = Dir.pwd
+      h['rlp'] = $: if o.is_a?(::LoadError)
+
+      h
+    end
 
-      h['msg'] = o.to_s
+    def const_lookup(s)
 
-      t = caller[1..-1]
+      s.split('::')
+        .select { |ss| ss.length > 0 }
+        .inject(Kernel) { |k, sk| k.const_get(sk, k == Kernel) }
     end
 
-    h['trc'] = t[0..(t.rindex { |l| l.match(/\/lib\/flor\//) }) + 1] if t
-    h['cwd'] = Dir.pwd
-    h['rlp'] = $: if o.is_a?(::LoadError)
+    def to_coll(o)
 
-    h
-  end
+      #o.respond_to?(:to_a) ? o.to_a : [ a ]
+      Array(o)
+    end
 
-  def self.const_lookup(s)
+    def relativize_path(path, from=Dir.getwd)
 
-    s.split('::').inject(Kernel) { |k, sk| k.const_get(sk) }
-  end
+      path = File.absolute_path(path)
 
-  def self.to_coll(o)
+      path = path[from.length + 1..-1] if path[0, from.length] == from
 
-    #o.respond_to?(:to_a) ? o.to_a : [ a ]
-    Array(o)
-  end
+      path || '.'
+    end
 
-  def self.relativize_path(path, from=Dir.getwd)
+    def is_array_of_messages?(o)
 
-    path = File.absolute_path(path)
+      o.is_a?(Array) &&
+      o.all? { |e|
+        e.is_a?(Hash) &&
+        e['point'].is_a?(String) &&
+        e.keys.all? { |k| k.is_a?(String) } }
+    end
 
-    path = path[from.length + 1..-1] if path[0, from.length] == from
+    def h_fetch(h, *keys)
 
-    path || '.'
-  end
+      k = keys.find { |k| h.has_key?(k) }
+      k ? h[k] : nil
+    end
 
-  def self.is_array_of_messages?(o)
+    def h_fetch_a(h, *keys)
 
-    o.is_a?(Array) &&
-    o.all? { |e|
-      e.is_a?(Hash) &&
-      e['point'].is_a?(String) &&
-      e.keys.all? { |k| k.is_a?(String) } }
-  end
+      default = keys.last.is_a?(String) ? [] : keys.pop
 
-  def self.h_fetch_a(h, *keys)
+      k = keys.find { |k| h.has_key?(k) }
+      v = k ? h[k] : nil
 
-    default = keys.last.is_a?(String) ? [] : keys.pop
+      v_to_a(v) || default
+    end
 
-    k = keys.find { |k| h.has_key?(k) }
-    v = k ? h[k] : nil
+    def v_to_a(o)
 
-    v_to_a(v) || default
-  end
+      return o if o.is_a?(Array)
+      return o.split(',') if o.is_a?(String)
+      return nil if o.nil?
 
-  def self.v_to_a(o)
+      fail ArgumentError.new("cannot turn instance of #{o.class} into an array")
+    end
 
-    return o if o.is_a?(Array)
-    return o.split(',') if o.is_a?(String)
-    return nil if o.nil?
+    def is_regex_string?(s)
 
-    fail ArgumentError.new("cannot turn instance of #{o.class} into an array")
-  end
+      !! (
+        s.is_a?(String) &&
+        s[0] == '/' &&
+        s.match(/\/[imxouesn]*\z/)
+      )
+    end
 
-  #
-  # functions about time
+    def to_regex(o)
 
-  def self.isostamp(show_date, show_time, show_usec, time)
+      s =
+        case o
+        when String then o
+        when Array then o[1].to_s # hopefully regex tree
+        else o.to_s
+        end
 
-    t = (time || Time.now).utc
-    s = StringIO.new
+      m = s.match(/\A\/(.*)\/([imxouesn]*)\z/)
 
-    s << t.strftime('%Y-%m-%d') if show_date
-    s << t.strftime('T%H:%M:%S') if show_time
-    s << sprintf('.%06d', t.usec) if show_time && show_usec
-    s << 'Z' if show_time
+      return Regexp.new(s) unless m
 
-    s.string
-  end
+      m1 = m[1]
+      e = (m[2].match(/[uesn]/) || [])[0]
 
-  def self.tstamp(t=Time.now)
+      m1 =
+        case e
+        when 'u' then m1.encode('UTF-8')
+        when 'e' then m1.encode('EUC-JP')
+        when 's' then m1.encode('Windows-31J')
+        when 'n' then m1.encode('ASCII-8BIT')
+        else m1
+        end
 
-    isostamp(true, true, true, t)
-  end
+      flags = 0
+      flags = flags | Regexp::EXTENDED if m[2].index('x')
+      flags = flags | Regexp::IGNORECASE if m[2].index('i')
+      #flags = flags | Regexp::MULTILINE if m[2].index('m')
+      flags = flags | Regexp::FIXEDENCODING if e
 
-  def self.ststamp(t=Time.now)
+      Regexp.new(m1, flags)
+    end
 
-    isostamp(true, true, false, t)
-  end
+    #
+    # functions about time
 
-  def self.dstamp(t=Time.now)
+    def isostamp(show_date, show_time, show_usec, time)
 
-    isostamp(true, false, false, t)
-  end
+      t = (time || Time.now).utc
+      s = StringIO.new
 
-  def self.tamp(t=Time.now)
+      s << t.strftime('%Y-%m-%d') if show_date
+      s << t.strftime('T%H:%M:%S') if show_time
+      s << sprintf('.%06d', t.usec) if show_time && show_usec
+      s << 'Z' if show_time
 
-    t = t.utc
-    s = StringIO.new
-    s << t.strftime('%Y%m%dT%H%M%S') << sprintf('.%06dZ', t.usec)
+      s.string
+    end
 
-    s.string
-  end
+    def tstamp(t=Time.now)
 
-  # hour stamp
-  #
-  def self.hstamp(t=Time.now)
+      isostamp(true, true, true, t)
+    end
 
-    isostamp(false, true, true, t)
-  end
+    def ststamp(t=Time.now)
+
+      isostamp(true, true, false, t)
+    end
+
+    def dstamp(t=Time.now)
+
+      isostamp(true, false, false, t)
+    end
+
+    def tamp(t=Time.now)
+
+      t = t.utc
+      s = StringIO.new
+      s << t.strftime('%Y%m%dT%H%M%S') << sprintf('.%06dZ', t.usec)
+
+      s.string
+    end
 
-#  def self.to_time(ts)
+    # hour stamp
+    #
+    def hstamp(t=Time.now)
+
+      isostamp(false, true, true, t)
+    end
+
+#  def to_time(ts)
 #
 #    m = ts.match(/\A(\d{4})(\d{2})(\d{2})\.(\d{2})(\d{2})(\d{2})(\d+)([uU]?)\z/)
 #    fail ArgumentError.new("cannot parse timestamp #{ts.inspect}") unless m
@@ -183,194 +250,204 @@ module Flor
 #    Time.local(*m[1, 7].collect(&:to_i))
 #  end
 
-  #
-  # functions about domains and units
-
-  NAME_REX = '[a-zA-Z0-9_]+'
-  UNIT_NAME_REX = /\A#{NAME_REX}\z/
-  DOMAIN_NAME_REX = /\A#{NAME_REX}(\.#{NAME_REX})*\z/
-  FLOW_NAME_REX = /\A(#{NAME_REX}(?:\.#{NAME_REX})*)\.([a-zA-Z0-9_-]+)\z/
+    #
+    # functions about domains and units
 
-  def self.potential_unit_name?(s)
+    def potential_unit_name?(s)
 
-    s.is_a?(String) && s.match(UNIT_NAME_REX)
-  end
+      s.is_a?(String) && !! s.match(UNIT_NAME_REX)
+    end
 
-  def self.potential_domain_name?(s)
+    def potential_domain_name?(s)
 
-    s.is_a?(String) && s.match(DOMAIN_NAME_REX)
-  end
+      s.is_a?(String) && !! s.match(DOMAIN_NAME_REX)
+    end
 
-  def self.split_flow_name(s)
+    def split_flow_name(s)
 
-    if s.is_a?(String) && m = s.match(FLOW_NAME_REX)
-      [ m[1], m[2] ]
-    else
-      nil
+      if s.is_a?(String) && m = s.match(FLOW_NAME_REX)
+        [ m[1], m[2] ]
+      else
+        nil
+      end
     end
-  end
-
-  def self.is_sub_domain?(dom, sub)
 
-    fail ArgumentError.new(
-      "not a domain #{dom.inspect}"
-    ) unless potential_domain_name?(dom)
+    def is_sub_domain?(dom, sub)
 
-    fail ArgumentError.new(
-      "not a sub domain #{sub.inspect}"
-    ) unless potential_domain_name?(sub)
+      fail ArgumentError.new(
+        "not a domain #{dom.inspect}"
+      ) unless potential_domain_name?(dom)
 
-    sub == dom || sub[0, dom.length + 1] == dom + '.'
-  end
+      fail ArgumentError.new(
+        "not a sub domain #{sub.inspect}"
+      ) unless potential_domain_name?(sub)
 
-  DOMAIN_UNIT_REX = /\A(#{NAME_REX}(?:\.#{NAME_REX})*)-(#{NAME_REX})[-\z]/
+      sub == dom || sub[0, dom.length + 1] == dom + '.'
+    end
 
-  def self.split_domain_unit(s)
+    def split_domain_unit(s)
 
-    if m = DOMAIN_UNIT_REX.match(s)
-      [ m[1], m[2] ]
-    else
-      []
+      if m = DOMAIN_UNIT_REX.match(s)
+        [ m[1], m[2] ]
+      else
+        []
+      end
     end
-  end
 
-  def self.domain(s)
+    def domain(s)
 
-    split_domain_unit(s).first
-  end
+      split_domain_unit(s).first
+    end
 
-  def self.unit(s)
+    def unit(s)
 
-    split_domain_unit(s).last
-  end
+      split_domain_unit(s).last
+    end
 
-  def self.to_pretty_s(o, twidth=79)
+    def to_pretty_s(o, twidth=79)
 
-    sio = StringIO.new
-    PP.pp(o, sio, twidth)
+      sio = StringIO.new
+      PP.pp(o, sio, twidth)
 
-    sio.string
-  end
+      sio.string
+    end
 
 
-  #
-  # tree
+    #
+    # tree
 
-  def self.is_tree?(t)
+    def is_tree?(t)
 
-    t.is_a?(Array) &&
-    t.size > 2 &&
-    (t[0].is_a?(String) || Flor.is_tree?(t[0])) &&
-    t[2].is_a?(Integer)
-  end
+      t.is_a?(Array) &&
+      t.size > 2 &&
+      (t[0].is_a?(String) || Flor.is_tree?(t[0])) &&
+      t[2].is_a?(Integer)
+    end
 
-  def self.is_string_tree?(t, s=nil)
+    def is_string_tree?(t, s=nil)
 
-    t.is_a?(Array) &&
-    t[2].is_a?(Integer) &&
-    %w[ _sqs _dqs ].include?(t[0]) &&
-    (s ? (t[1] == s) : t[1].is_a?(String))
-  end
+      t.is_a?(Array) &&
+      t[2].is_a?(Integer) &&
+      %w[ _sqs _dqs ].include?(t[0]) &&
+      (s ? (t[1] == s) : t[1].is_a?(String))
+    end
 
-  def self.is_att_tree?(t)
+    def is_att_tree?(t)
 
-    t.is_a?(Array) &&
-    t[2].is_a?(Integer) &&
-    t[0] == '_att' &&
-    t[1].is_a?(Array)
-  end
+      t.is_a?(Array) &&
+      t[2].is_a?(Integer) &&
+      t[0] == '_att' &&
+      t[1].is_a?(Array)
+    end
 
-  def self.is_array_of_trees?(o)
+    def is_array_of_trees?(o)
 
-    o.is_a?(Array) &&
-    o.all? { |e| Flor.is_tree?(e) }
-  end
+      o.is_a?(Array) &&
+      o.all? { |e| Flor.is_tree?(e) }
+    end
 
 #  # Array, object or atom tree
 #  #
-#  def self.is_value_tree?(o)
+#  def is_value_tree?(o)
 #
 #    o.is_a?(Array) &&
 #    %w[ _num _boo _sqs _dqs _rxs _nul _arr _obj ].include?(o[0]) &&
 #    o[2].is_a?(Integer)
 #  end
 
-  def self.is_proc_tree?(o)
-
-    o.is_a?(Array) &&
-    o[0] == '_proc' &&
-    o[2].is_a?(Integer) &&
-    o[1].is_a?(Hash) &&
-    o[1]['proc'].is_a?(String)
-  end
-
-  def self.is_func_tree?(o)
+    def is_proc_tree?(o)
 
-    o.is_a?(Array) &&
-    o[0] == '_func' &&
-    o[2].is_a?(Integer) &&
-    o[1].is_a?(Hash) && (o[1].keys & %w[ nid cnid fun ]).size == 3
-  end
+      o.is_a?(Array) &&
+      o[0] == '_proc' &&
+      o[2].is_a?(Integer) &&
+      o[1].is_a?(Hash) &&
+      o[1]['proc'].is_a?(String)
+    end
 
-  def self.is_task_tree?(o)
+    def is_func_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
+      o.is_a?(Array) &&
+      o[0] == '_func' &&
+      o[2].is_a?(Integer) &&
+      o[1].is_a?(Hash) && (o[1].keys & %w[ nid cnid fun ]).size == 3
+    end
 
-  # Returns [ st, i ], the parent subtree for the final i index of the nid
-  # Used when inserting updated subtrees.
-  #
-  def self.parent_tree_locate(t, nid)
+#    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_regex_tree?(o)
+
+      o.is_a?(Array) &&
+      o[0] == '_rxs' &&
+      o[2].is_a?(Integer) &&
+      o[1].is_a?(String) &&
+      o[1].match(/\A\/.*\/[a-zA-Z]*\z/)
+    end
 
-    return nil if t == nil
+    # Returns [ st, i ], the parent subtree for the final i index of the nid
+    # Used when inserting updated subtrees.
+    #
+    def parent_tree_locate(t, nid)
 
-    n, i, d = nid.split('_', 3)
+      return nil if t == nil
 
-    return [ t, nil ] if i == nil
-    return [ t, i.to_i ] if ! d
-    parent_tree_locate(t[1][i.to_i], [ i, d ].join('_'))
-  end
+      n, i, d = nid.split('_', 3)
 
-  # Returns the subtree down at the given nid
-  #
-  def self.tree_locate(t, nid)
+      return [ t, nil ] if i == nil
+      return [ t, i.to_i ] if ! d
+      parent_tree_locate(t[1][i.to_i], [ i, d ].join('_'))
+    end
 
-    st, i = parent_tree_locate(t, nid)
+    # Returns the subtree down at the given nid
+    #
+    def tree_locate(t, nid)
 
-    return nil if st == nil
-    return st if i == nil
-    st[1][i]
-  end
+      st, i = parent_tree_locate(t, nid)
 
+      return nil if st == nil
+      return st if i == nil
+      st[1][i]
+    end
 
-  #
-  # splat
 
-  SPLAT_REGEX = /\A(.*)__(_|\d+)\z/.freeze
+    #
+    # splat
 
-  def self.splat(keys, array)
+    def splat(keys, array)
 
-    ks = keys.dup
-    a = array.dup
-    h = {}
+      ks = keys.dup
+      a = array.dup
+      h = {}
 
-    while k = ks.shift
+      while k = ks.shift
 
-      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
+        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
       end
+
+      h
     end
 
-    h
+
+    #
+    # misc
+
+    def point?(s)
+
+      POINTS.include?(s)
+    end
   end
 end