alib 0.3.1 → 0.4.0

data/lib/alib-0.4.0/open4.rb

@@ -0,0 +1,175 @@
+require 'fcntl'
+
+module Open4
+#--{{{
+  def self.version
+    '0.4.0'
+  end
+
+  def popen4(*cmd)
+#--{{{
+    pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
+
+    verbose = $VERBOSE
+    begin
+      $VERBOSE = nil
+      ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+      cid = fork {
+        pw.last.close
+        STDIN.reopen pw.first
+        pw.first.close
+
+        pr.first.close
+        STDOUT.reopen pr.last
+        pr.last.close
+
+        pe.first.close
+        STDERR.reopen pe.last
+        pe.last.close
+
+        STDOUT.sync = STDERR.sync = true
+
+        begin
+          exec(*cmd)
+          raise "exec failed!"
+        rescue Exception => e
+          Marshal.dump(e, ps.last)
+          ps.last.flush
+        end
+        ps.last.close unless (ps.last.closed?)
+        exit!
+      }
+    ensure
+      $VERBOSE = verbose
+    end
+
+    [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close}
+
+    begin
+      e = Marshal.load ps.first
+      raise(Exception === e ? e : "unknown failure!")
+    rescue EOFError # If we get an EOF error, then the exec was successful
+      42
+    end
+
+    pw.last.sync = true
+
+    pi = [pw.last, pr.first, pe.first]
+
+    if defined? yield
+      begin
+        yield(cid, *pi)
+        Process.waitpid2(cid).last
+      ensure
+        pi.each{|fd| fd.close unless fd.closed?}
+      end
+    else
+      [cid, pw.last, pr.first, pe.first]
+    end
+#--}}}
+  end
+  alias open4 popen4
+  module_function :popen4
+  module_function :open4
+
+  class Error < ::StandardError; end
+  class SpawnError < Error
+#--{{{
+    attr 'cmd'
+    attr 'status'
+    def exitstatus
+      @status.exitstatus
+    end
+    def initialize cmd, status
+      @cmd, @status = cmd, status
+      super "cmd <#{ cmd }> failed with <#{ exitstatus }>"
+    end
+#--}}}
+  end
+  def spawn cmd, opts = {} 
+#--{{{
+    getopt = lambda do |*args|
+      keys, default, ignored = args
+      catch('opt') do
+        [keys].flatten.each do |key|
+          [key, key.to_s, key.to_s.intern].each do |key|
+            throw 'opt', opts[key] if opts.has_key?(key)
+          end
+        end
+        default
+      end
+    end
+
+    ignore_exit_failure = getopt[ 'ignore_exit_failure', getopt['quiet', false] ]
+    ignore_exec_failure = getopt[ 'ignore_exec_failure', !getopt['raise', true] ]
+    exitstatus = getopt[ %w( exitstatus exit_status status ), 0 ]
+    stdin = getopt[ ['stdin', 'in', '0', 0] ]
+    stdout = getopt[ ['stdout', 'out', '1', 1] ]
+    stderr = getopt[ ['stderr', 'err', '2', 2] ]
+    pid = getopt[ 'pid' ]
+
+    started = false
+
+    status =
+      begin
+        popen4(cmd) do |c, i, o, e|
+          started = true
+
+          if pid.respond_to? '<<'
+            pid << c
+          end
+
+          it = Thread.new(i,stdin) do |i,stdin|
+            if stdin
+              if stdin.respond_to? :each
+                stdin.each{|buf| i << buf}
+              elsif stdin.respond_to? :read
+                i << stdin.read
+              else
+                i << stdin.to_s
+              end
+            end
+            i.close
+          end
+
+          ot = Thread.new(o,stdout){|o,stdout| o.each{|buf| stdout << buf if stdout}}
+          et = Thread.new(e,stderr){|e,stderr| e.each{|buf| stderr << buf if stderr}}
+
+          it.join
+          ot.join if ot
+          et.join if et
+        end
+      rescue
+        raise unless(not started and ignore_exec_failure)
+      end
+
+    raise SpawnError.new(cmd, status) unless
+      (ignore_exit_failure or (status.nil? and ignore_exec_failure) or (status.exitstatus == exitstatus))
+
+    status
+#--}}}
+  end
+  module_function :spawn
+
+  def background cmd, opts = {}
+#--{{{
+    require 'thread'
+    q = Queue.new
+    opts['pid'] = opts[:pid] = q
+    thread = Thread.new(cmd, opts){|cmd, opts| spawn cmd, opts}
+    pid = q.pop
+    sc = class << thread; self; end
+    sc.module_eval {
+      define_method(:pid){ pid }
+      define_method(:spawn_status){ @spawn_status ||= value }
+      define_method(:exitstatus){ spawn_status.exitstatus }
+    }
+    thread
+#--}}}
+  end
+  alias bg background
+  module_function :background
+  module_function :bg
+#--}}}
+end

data/lib/alib-0.4.0/orderedautohash.rb

@@ -0,0 +1,23 @@
+#
+# auto vivifying ordered hash that dumps as yaml nicely
+#
+class ALib::AutoOrderedHash < ALib::OrderedHash
+#--{{{
+  def initialize(*args)
+#--{{{
+    super(*args){|a,k| a[k] = __class__.new(*args)}
+#--}}}
+  end
+  def class # for nice yaml
+#--{{{
+    Hash
+#--}}}
+  end
+  def __class__
+#--{{{
+    ALib::AutoOrderedHash
+#--}}}
+  end
+#--}}}
+end # class AutoOrderedHash
+ALib::OrderedAutoHash = ALib::AutoOrderedHash

data/lib/alib-0.4.0/orderedhash.rb

@@ -0,0 +1,243 @@
+# AUTHOR
+#    jan molic /mig/at/1984/dot/cz/
+#
+# DESCRIPTION
+#    Hash with preserved order and some array-like extensions
+#    Public domain. 
+#
+# THANKS
+#    Andrew Johnson for his suggestions and fixes of Hash[],
+#    merge, to_a, inspect and shift
+class ALib::OrderedHash < ::Hash
+#--{{{
+    attr_accessor :order
+
+    class << self
+#--{{{
+        def [] *args
+#--{{{
+            hsh = OrderedHash.new
+            if Hash === args[0]
+                hsh.replace args[0]
+            elsif (args.size % 2) != 0
+                raise ArgumentError, "odd number of elements for Hash"
+            else
+                hsh[args.shift] = args.shift while args.size > 0
+            end
+            hsh
+#--}}}
+        end
+#--}}}
+    end
+#        def initialize 
+##--{{{
+#            @order = []
+##--}}}
+#        end
+    def initialize(*a, &b)
+#--{{{
+      super
+      @order = []
+#--}}}
+    end
+    def store_only a,b
+#--{{{
+        store a,b
+#--}}}
+    end
+    alias orig_store store    
+    def store a,b
+#--{{{
+        @order.push a unless has_key? a
+        super a,b
+#--}}}
+    end
+    alias []= store
+    def == hsh2
+#--{{{
+        return false if @order != hsh2.order
+        super hsh2
+#--}}}
+    end
+    def clear
+#--{{{
+        @order = []
+        super
+#--}}}
+    end
+    def delete key
+#--{{{
+        @order.delete key
+        super
+#--}}}
+    end
+    def each_key
+#--{{{
+        @order.each { |k| yield k }
+        self
+#--}}}
+    end
+    def each_value
+#--{{{
+        @order.each { |k| yield self[k] }
+        self
+#--}}}
+    end
+    def each
+#--{{{
+        @order.each { |k| yield k,self[k] }
+        self
+#--}}}
+    end
+    alias each_pair each    
+    def delete_if
+#--{{{
+        @order.clone.each { |k| 
+            delete k if yield
+        }
+        self
+#--}}}
+    end
+    def values
+#--{{{
+        ary = []
+        @order.each { |k| ary.push self[k] }
+        ary
+#--}}}
+    end
+    def keys
+#--{{{
+        @order
+#--}}}
+    end
+    def invert
+#--{{{
+        hsh2 = Hash.new    
+        @order.each { |k| hsh2[self[k]] = k }
+        hsh2
+#--}}}
+    end
+    def reject &block
+#--{{{
+        self.dup.delete_if &block
+#--}}}
+    end
+    def reject! &block
+#--{{{
+        hsh2 = reject &block
+        self == hsh2 ? nil : hsh2
+#--}}}
+    end
+    def replace hsh2
+#--{{{
+        @order = hsh2.keys 
+        super hsh2
+#--}}}
+    end
+    def shift
+#--{{{
+        key = @order.first
+        key ? [key,delete(key)] : super
+#--}}}
+    end
+    def unshift k,v
+#--{{{
+        unless self.include? k
+            @order.unshift k
+            orig_store(k,v)
+            true
+        else
+            false
+        end
+#--}}}
+    end
+    def push k,v
+#--{{{
+        unless self.include? k
+            @order.push k
+            orig_store(k,v)
+            true
+        else
+            false
+        end
+#--}}}
+    end
+    def pop
+#--{{{
+        key = @order.last
+        key ? [key,delete(key)] : nil
+#--}}}
+    end
+    def to_a
+#--{{{
+        ary = []
+        each { |k,v| ary << [k,v] }
+        ary
+#--}}}
+    end
+    def to_s
+#--{{{
+        self.to_a.to_s
+#--}}}
+    end
+    def inspect
+#--{{{
+        ary = []
+        each {|k,v| ary << k.inspect + "=>" + v.inspect}
+        '{' + ary.join(", ") + '}'
+#--}}}
+    end
+    def update hsh2
+#--{{{
+        hsh2.each { |k,v| self[k] = v }
+        self
+#--}}}
+    end
+    alias :merge! update
+    def merge hsh2
+#--{{{
+        self.dup update(hsh2)
+#--}}}
+    end
+    def select
+#--{{{
+        ary = []
+        each { |k,v| ary << [k,v] if yield k,v }
+        ary
+#--}}}
+    end
+    def class
+#--{{{
+      Hash
+#--}}}
+    end
+
+    attr_accessor "to_yaml_style"
+    def yaml_inline= bool
+      if respond_to?("to_yaml_style")
+        self.to_yaml_style = :inline
+      else
+        unless defined? @__yaml_inline_meth
+          @__yaml_inline_meth =
+            lambda {|opts|
+              YAML::quick_emit(object_id, opts) {|emitter|
+                emitter << '{ ' << map{|kv| kv.join ': '}.join(', ') << ' }'
+              }
+            }
+          class << self
+            def to_yaml opts = {}
+              begin
+                @__yaml_inline ? @__yaml_inline_meth[ opts ] : super
+              rescue
+                @to_yaml_style = :inline
+                super
+              end
+            end
+          end
+        end
+      end
+      @__yaml_inline = bool
+    end
+    def yaml_inline!() self.yaml_inline = true end
+#--}}}
+end # class OrderedHash

data/lib/alib-0.4.0/util.rb

@@ -0,0 +1,1167 @@
+#
+# the utility module is a namespace for things which otherwise wouldn't have a
+# home.  the methods of Util can be used as module methods or included into a
+# class and then used as instance OR class methods
+#
+module ALib::Util
+#--{{{
+  class << self
+#--{{{
+    def export(*syms)
+#--{{{
+      syms.each do |sym|
+        sym = "#{ sym }".intern
+        module_function sym 
+        public sym
+      end
+#--}}}
+    end
+    def append_features c
+#--{{{
+      super
+      c.extend self 
+#--}}}  
+    end
+#--}}}
+  end
+#
+# requires a certain version of ruby or higher
+#   require_version '1.8.0'
+#
+  def require_version version
+#--{{{
+    major, minor, teeny = "#{ version }".split(%r/\./o).map{|n| Integer(n)}
+    required = "#{ major }.#{ minor }.#{ teeny }"
+    _major, _minor, _teeny = 
+      %w( MAJOR MINOR TEENY ).map{|k| Integer(::Config::CONFIG[k])}
+    actual = "#{ _major }.#{ _minor }.#{ _teeny }"
+    unless _major > major  or _major == major and _minor >= minor 
+      STDERR.puts("=" * 79)
+      STDERR.puts "this program requires a ruby version >= <#{ required }>"
+      STDERR.puts 
+      STDERR.puts "you are currenlty running ruby version <#{ actual }>"
+      STDERR.puts 
+      STDERR.puts "possible problems which could cause this are:"
+      STDERR.puts "  - improper PATH environment variable setting"
+      STDERR.puts "  - ruby > <#{ required }> has not been installed"
+      STDERR.puts("=" * 79)
+      exit 1
+    end
+#--}}}
+  end
+#
+# the basename of $0  
+#
+  def prognam
+#--{{{
+    File::basename $0
+#--}}}
+  end
+  export 'prognam'
+#
+# marshal'd 'deep' copy of obj
+#
+  def mcp obj
+#--{{{
+    Marshal.load(Marshal.dump(obj))
+#--}}}
+  end
+  export 'mcp'
+#
+# self.class 
+#
+  def klass
+#--{{{
+    Module === self ? self : self.class
+#--}}}
+  end
+  export 'klass'
+#
+# evaluates block in singleton scope or simply returns singleton_class
+#
+  def singleton_class &b
+#--{{{
+    sc = 
+      class << self; self; end
+    b ? sc.module_eval(&b) : sc
+#--}}}
+  end
+#
+# File::expand_path + link resolution 
+#
+  def realpath path
+#--{{{
+    path = File::expand_path "#{ path }"
+    begin
+      Pathname.new(path).realpath.to_s
+    rescue Errno::ENOENT, Errno::ENOTDIR
+      path
+    end
+#--}}}
+  end
+  export 'realpath'
+#
+# collect n hashed into one hash - later keys overried earlier keys 
+#
+  def hashify(*hashes)
+#--{{{
+    hashes.inject(accum={}){|accum,hash| accum.update hash}
+#--}}}
+  end
+  export 'hashify'
+#
+# look up key in hash as key, then string of key, then intern of key -
+# returning the value or, if key is not found, nil or default  
+#
+  def getopt opt, hash, default = nil
+#--{{{
+    keys = opt.respond_to?('each') ? opt : [opt]
+
+    keys.each do |key|
+      return hash[key] if hash.has_key? key
+      key = "#{ key }"
+      return hash[key] if hash.has_key? key
+      key = key.intern
+      return hash[key] if hash.has_key? key
+    end
+
+    return default
+#--}}}
+  end
+  alias get_opt getopt
+  export 'getopt'
+  export 'get_opt'
+#
+# determine if a key, key.to_s, or key.to_s.intern is in hash 
+# see getopt
+#
+  def hasopt opt, hash, default = false 
+#--{{{
+    keys = opt.respond_to?('each') ? opt : [opt]
+
+    keys.each do |key|
+      return key if hash.has_key? key
+      key = "#{ key }"
+      return key if hash.has_key? key
+      key = key.intern
+      return key if hash.has_key? key
+    end
+
+    return default
+#--}}}
+  end
+  alias has_opt hasopt
+  alias hasopt? hasopt
+  alias has_opt? hasopt
+  export 'hasopt'
+  export 'hasopt?'
+  export 'has_opt'
+  export 'has_opt?'
+#
+# delete key in hash as key, then string of key, then intern of key -
+# returning the value or, if key is not found, nil or default  
+#
+  def delopt opt, hash, default = nil
+#--{{{
+    keys = opt.respond_to?('each') ? opt : [opt]
+
+    keys.each do |key|
+      return hash.delete(key) if hash.has_key? key
+      key = "#{ key }"
+      return hash.delete(key) if hash.has_key? key
+      key = key.intern
+      return hash.delete(key) if hash.has_key? key
+    end
+
+    return default
+#--}}}
+  end
+  alias delete_opt delopt
+  alias extract_opt delopt
+  alias extractopt delopt
+  alias xopt delopt
+  export 'delete_opt'
+  export 'extract_opt'
+  export 'extractopt'
+  export 'xopt'
+  export 'delopt'
+#
+# returns true if pid is running, false otherwise
+#
+  def alive pid
+#--{{{
+    pid = Integer("#{ pid }")
+    begin
+      Process::kill 0, pid
+      true
+    rescue Errno::ESRCH
+      false
+    end
+#--}}}
+  end
+  alias alive? alive
+  export 'alive', 'alive?'
+#
+# brutally shut down a process.  opts can contain the keys 'signals' which
+# should be a list of signals used to send to the process and the key
+# 'suspend' which is the amount of time to wait after firing each signal
+# before seeing if the process is dead.  the defaults are %w(TERM QUIT KILL)
+# and 4 respectively
+#
+  def maim(pid, opts = {})
+#--{{{
+    sigs = getopt 'signals', opts, %w(SIGTERM SIGQUIT SIGKILL)
+    suspend = getopt 'suspend', opts, 4
+    pid = Integer("#{ pid }")
+    existed = false
+    sigs.each do |sig|
+      begin
+        Process::kill(sig, pid)
+        existed = true 
+      rescue Errno::ESRCH
+        unless existed
+          return nil 
+        else
+          return true 
+        end
+      end
+      return true unless alive?(pid)
+      sleep suspend
+      return true unless alive?(pid)
+    end
+    return(not alive?(pid)) 
+#--}}}
+  end
+  export 'maim'
+#
+# YYYY-MM-DD hh:mm:ss.uuuuuu representation of time.  if the option
+# 'nospace' is true spaces are replaced with underscores/or the value of the
+# nospace option - useful for constructing filenames
+#
+  def timestamp arg = Time::now
+#--{{{
+    if Time === arg 
+      arg.iso8601 2
+    else
+      opts =
+        case arg
+          when Hash
+            opts = arg
+          when Time
+            {'time' => arg}
+          else
+            raise ArgumentError, "#{ arg.inspect } (#{ arg.class })"
+        end
+      time = getopt 'time', opts, Time::now
+      local = getopt 'local', opts, false 
+      nospace = getopt('nospace', opts, getopt('no_space', opts, false))
+      dateonly = getopt('dateonly', opts, getopt('date_only', opts, false))
+      time = time.utc unless local
+      usec = "#{ time.usec }"
+      usec << ('0' * (6 - usec.size)) if usec.size < 6 
+      stamp =
+      unless dateonly
+        time.strftime('%Y-%m-%d %H:%M:%S.') << usec
+      else
+        time.strftime('%Y-%m-%d')
+      end
+      if nospace
+        spc = TrueClass === nospace ? 'T' : "#{ nospace }"
+        stamp.gsub! %r/\s+/, spc
+      end
+      stamp
+    end
+#--}}}
+  end
+  export 'timestamp'
+#
+# inverse of timestamp.  the option 'local' determines whether the timestamp
+# is interpreted as a local or utc time.
+#
+# TODO - review hack to fix Time::parse bug with ms and tz
+# TODO - review hack to fix Time::parse bug with ms and tz
+# TODO - review hack to fix Time::parse bug with ms and tz
+  def stamptime string, opts = {} 
+#--{{{
+    tz = string[ %r/-\d\d:\d\d\s*$/ ]
+    time = nil
+    if opts.empty? or tz
+      u = string[%r/\.\d+/]
+      string[%r/\.\d+/] = '' if u 
+      time = Time::parse string
+      time += u.to_f if u
+    else
+      local = getopt 'local', opts, false 
+      string = "#{ string }"
+      pat = %r/^\s*(\d\d\d\d)-(\d\d)-(\d\d)[\s_tT]+(\d\d):(\d\d):(\d\d)(?:.(\d+))?\s*$/o
+      match = pat.match string
+      raise ArgumentError, "<#{ string.inspect }>" unless match
+      yyyy,mm,dd,h,m,s,u = match.to_a[1..-1].map{|m| (m || 0).to_i}
+      if local
+        time = Time::local yyyy,mm,dd,h,m,s,u
+      else
+        time = Time::gm yyyy,mm,dd,h,m,s,u
+      end
+    end
+    return time
+#--}}}
+  end
+
+  def version_cmp a, b
+#--{{{
+    to_v = lambda{|v| v.to_s.scan(%r/\d+/).map{|c| Integer c}}
+    to_v[a] <=> to_v[b]
+#--}}}
+  end
+  export 'version_cmp'
+
+# TODO - 1.8.4 parses usec but 1.8.2 does not.  handle differently.
+  def stamptime string, opts = {} 
+#--{{{
+    string = string.to_s
+    local = getopt('local', opts, getopt('localtime', opts, false))
+    utc = getopt('utc', opts, false)
+
+    gte_184 = (defined?(RUBY_VERSION) and [0,1].include?(version_cmp(RUBY_VERSION, "1.8.4")))
+
+    time = nil
+
+    tz_pat = %r/([\+\-]\d\d:\d\d|Z)\s*$/
+
+    if utc and string !~ tz_pat 
+      string = "#{ string }Z"
+    end
+
+    if gte_184 
+      time = Time::parse string.to_s
+    else
+      # strip time zone
+      z = string[ tz_pat ]
+      string[ tz_pat ] = "" if z
+
+      # yank out usec
+      u = string[ %r/\.\d+\s*$/ ]
+      string[ %r/\.\d+\s*$/ ] = "" if u
+
+      # parse with time zone restored, adding usec
+      time = Time::parse "#{ string }#{ z }"
+      time += u.to_f if u
+    end
+
+    local ? time.localtime : time#.utc
+#--}}}
+  end
+  export 'stamptime'
+#
+# escapes any occurances of char in s with esc modifying s inplace
+#
+  def escape! s, char, esc
+#--{{{
+    # re = %r/([#{ 0x5c.chr << esc }]*)#{ char }/
+    re = %r/([#{ Regexp::quote esc }]*)#{ Regexp::quote char }/
+    s.gsub!(re) do
+      (($1.size % 2 == 0) ? ($1 << esc) : $1) + char 
+    end
+#--}}}
+  end
+  export 'escape!'
+#
+# new copy of s with any occurances of char escaped with esc
+#
+  def escape s, char, esc
+#--{{{
+    escape! "#{ s }", char, esc
+#--}}}
+  end
+  export 'escape'
+#
+# a quiet fork
+#
+  def fork(*args, &block)
+#--{{{
+    begin
+      verbose = $VERBOSE
+      $VERBOSE = nil
+      Process::fork(*args, &block)
+    ensure
+      $VERBOSE = verbose
+    end
+#--}}}
+  end
+  export 'fork'
+#
+# an quiet exec
+#
+  def exec(*args, &block)
+#--{{{
+    begin
+      verbose = $VERBOSE
+      $VERBOSE = nil
+      Kernel::exec(*args, &block)
+    ensure
+      $VERBOSE = verbose
+    end
+#--}}}
+  end
+  export 'exec'
+#
+# a quiet system
+#
+  def system(*args, &block)
+#--{{{
+    begin
+      verbose = $VERBOSE
+      $VERBOSE = nil
+      Kernel::system(*args, &block)
+    ensure
+      $VERBOSE = verbose
+    end
+#--}}}
+  end
+  export 'system'
+#
+# lookup, and cache, the hostname
+#
+  def hostname
+#--{{{
+    @__hostname__ ||= Socket::gethostname
+#--}}}
+  end
+  export 'hostname'
+#
+# lookup, and cache, the host (first bit of hostname quad)
+#
+  def host
+#--{{{
+    @__host__ ||= hostname.gsub(%r/\..*$/o,'')
+#--}}}
+  end
+  export 'host'
+#
+# format exception as Logger class does - no backtrace
+#
+  def emsg e
+#--{{{
+    "#{ e.message } - (#{ e.class })"
+#--}}}
+  end
+  export 'emsg'
+#
+# format exception backtrace as string 
+#
+  def btrace e
+#--{{{
+    (e.backtrace or []).join("\n")
+#--}}}
+  end
+  export 'btrace'
+#
+# format exception as Logger class does - with backtrace
+#
+  def errmsg e
+#--{{{
+    emsg(e) << "\n" << btrace(e)
+#--}}}
+  end
+  export 'errmsg'
+#
+# determine equality of two exceptions
+#
+  def erreq a, b
+#--{{{
+    a.class == b.class and
+    a.message == b.message and
+    a.backtrace == b.backtrace
+#--}}}
+  end
+  export 'erreq'
+#
+# generate a temporary filename for the directory dir using seed as a
+# basename 
+#
+  def tmpnam(*argv)
+#--{{{
+    args, opts = argv_split argv
+    dirname = argv.shift || getopt(%w(dir base prefix), opts, '.')
+    seed = getopt 'seed', opts, prognam
+    reap = getopt 'reap', opts, true
+
+    dirname = File.expand_path dirname
+
+    seed = seed.gsub(%r/[^0-9a-zA-Z]/,'_').gsub(%r/\s+/, '')
+    host = hostname.gsub(%r/\./, '_')
+
+    if reap
+      begin
+        baseglob = "%s__*__*__*__%s" % [ host, seed ] 
+        glob = File.join(dirname, baseglob)
+        host_re = %r/^#{ host }$/
+        candidates = Dir[glob]
+        candidates.each do |candidate|
+          basename = File.basename candidate
+          parts = basename.split %r/__/, 5
+          if parts[0] =~ host_re
+            pid = Integer parts[1]
+            unless alive? pid
+              FileUtils.rm_rf candidate
+            end
+          end
+        end
+      rescue => e
+        warn(errmsg(e)) rescue nil
+      end
+    end
+
+    basename = 
+      "%s__%s__%s__%s__%s" % [
+        host, 
+        Process::pid, 
+        timestamp('nospace' => true),
+        rand,
+        seed,
+      ] 
+
+    File.join(dirname, basename)
+#--}}}
+  end
+  export 'tmpnam'
+#
+# generate a temporary directory
+#
+  def tmpdir(*argv)
+#--{{{
+    args, opts = argv_split argv
+    retries = getopt 'retries', opts, 42
+    turd = getopt 'turd', opts
+    dir =  args.first || getopt(%w(dir base prefix), opts)
+    dir ||= ENV['ALIB_TMP'] || ENV['ALIB_TEMP']
+    dir ||= '.' 
+    opts['dir'] = dir
+    d = nil
+    retries.times do
+      td = tmpnam(opts)
+      break if ((d = FileUtils::mkdir_p td rescue nil))
+    end
+    raise "surpassed max retries <#{ retries }>" unless d
+    d = File::expand_path d
+
+    delete = lambda do
+      Dir::glob(File::join(d, "**")).each{|e| FileUtils::rm_rf e}
+      FileUtils::rm_rf d
+    end
+
+    if block_given?
+      cwd = Dir::pwd
+      begin
+        Dir::chdir d
+        yield [cwd,d]
+      ensure
+        Dir::chdir cwd if cwd
+        delete.call unless turd
+      end
+    else
+      at_exit &delete unless turd
+      return d
+    end
+
+#--}}}
+  end
+  export 'tmpdir'
+#
+# make best effort to invalidate any inode caching done by nfs clients
+#
+  def uncache file 
+#--{{{
+    refresh = nil
+    begin
+      is_a_file = File === file
+      path = (is_a_file ? file.path : file.to_s) 
+      stat = (is_a_file ? file.stat : File::stat(file.to_s)) 
+      refresh = tmpnam(File::dirname(path))
+      File::link path, refresh rescue File::symlink path, refresh
+      File::chmod stat.mode, path
+      File::utime stat.atime, stat.mtime, path
+      open(File::dirname(path)){|d| d.fsync rescue nil}
+    ensure 
+      begin
+        File::unlink refresh if refresh
+      rescue Errno::ENOENT
+      end
+    end
+#--}}}
+  end
+  export 'uncache'
+#
+# wrap a string using options width (default 80) and indent using the indent
+# option (default 0)
+#
+  def columnize buf, opts = {}
+#--{{{
+    width = getopt 'width', opts, 80
+    indent = getopt 'indent', opts
+    indent = Fixnum === indent ? (' ' * indent) : "#{ indent }"
+    column = []
+    words = buf.split %r/\s+/o
+    row = "#{ indent }"
+    while((word = words.shift))
+      if((row.size + word.size) < (width - 1))
+        row << word
+      else
+        column << row
+        row = "#{ indent }"
+        row << word
+      end
+      row << ' ' unless row.size == (width - 1)
+    end
+    column << row unless row.strip.empty?
+    column.join "\n"
+#--}}}
+  end
+  export 'columnize'
+#
+# search for a default value for 'var' using
+#   * DEFAULT_VAR 
+#   * self.class.var 
+# returning the option default, or nil
+#
+  def defval var, opts = {} 
+#--{{{  
+    default = getopt 'default', opts, nil
+    c = getopt 'class', opts, klass
+
+    d0, d1 = "default_#{ var }".intern, "#{ var }".intern
+    c0, c1 = "DEFAULT_#{ var }".upcase.intern, "#{ var }".upcase.intern
+
+    [d0, d1].each{|x| return(c.send(x)) if c.respond_to?(x)}
+    [c0, c1].each{|x| return(c.const_get(x)) if c.const_defined?(x)}
+
+    return default
+#--}}}
+  end
+  export 'defval'
+#
+# initiates a catch block to do 'something'.  if the method try_again! is
+# called the block is done over - if the method give_up! is called the block
+# is aborted.  calls to attempt may be nested.
+#
+  def attempt label = 'attempt'
+#--{{{
+    ret = nil
+    n_attempts = 0
+    loop{ break unless catch("#{ label }"){ ret = yield(n_attempts += 1) } == 'try_again' }
+    ret
+#--}}}
+  end 
+  export 'attempt'
+#
+# see attempt
+#
+  def try_again! label = 'attempt'
+#--{{{
+    throw "#{ label }", 'try_again'
+#--}}}
+  end
+  alias try_again try_again!
+  alias again! try_again!
+  export 'try_again!', 'again!', 'try_again'
+#
+# see attempt
+#
+  def give_up! label = 'attempt'
+#--{{{
+    throw "#{ label }", 'give_up'
+#--}}}
+  end
+  alias giveup! give_up! 
+  alias give_up give_up! 
+  export 'give_up!', 'giveup!', 'give_up'
+#
+# a better const_get
+#
+  def constant_get(hierachy)
+#--{{{
+    ancestors = hierachy.split(%r/::/)
+    parent = Object
+    while((child = ancestors.shift))
+      klass = parent.const_get child
+      parent = klass
+    end
+    klass
+#--}}}
+  end
+  export 'constant_get'
+#
+# creates a class by class name
+#
+  def klass_stamp(hierachy, *a, &b)
+#--{{{
+    constant_get(hierachy)::new(*a, &b)
+#--}}}
+  end
+  export 'klass_stamp'
+#
+# shortcut to Find2
+#
+  def find(*a, &b)
+#--{{{
+    a << '.' if a.empty?
+    ALib::Find2::find(*a, &b)
+#--}}}
+  end
+  export 'find'
+#
+# shortcut to Find2
+#
+  def find2(*a, &b)
+#--{{{
+    a << '.' if a.empty?
+    ALib::Find2::find2(*a, &b)
+#--}}}
+  end
+  export 'find2'
+#
+# shortcut to Find2.prune
+#
+  def prune
+#--{{{
+    ALib::Find2.prune
+#--}}}
+  end
+  export 'prune'
+#
+# pull out options from arglist
+#
+  def optfilter(*list)
+#--{{{
+    args, opts = [ list ].flatten.partition{|item| not Hash === item}
+    [args, hashify(*opts)]
+#--}}}
+  end
+  export 'optfilter'
+#
+# pop of options from an arglist
+#
+  def argv_split(argv)
+#--{{{
+    args = argv
+    opts = Hash === args.last ? args.pop : {}
+    [args, opts]
+#--}}}
+  end
+  export 'argv_split'
+#
+# split a path into dirname, basename, extension
+#
+  def splitpath path
+#--{{{
+    path = "#{ path }"
+    dirname, basename = File::split path
+    [ dirname, (%r/^([^\.]*)(.*)$/).match(basename)[1,2] ].flatten
+#--}}}
+  end
+  export 'splitpath'
+#
+# handle a pathname after unzipping (iff needed)
+#
+  def unzipped path, z_pat = %r/\.(?:z|gz)$/io
+#--{{{
+    zipped = zipped?(path, z_pat)
+    unless zipped
+      yield path
+    else
+      unzipped = unzip path
+      begin
+        yield unzipped
+      ensure
+        zip unzipped
+      end
+    end
+#--}}}
+  end
+  export 'unzipped'
+#
+# zip a file - return zipped name
+#
+  def zip path, z_ext = nil 
+#--{{{
+    z_ext ||= '.gz'
+    z_ext.gsub! %r/^\s*\.+/, '.'
+    spawn "gzip --suffix #{ z_ext } --force #{ path }"
+    zipped = "#{ path }#{ z_ext }"
+    raise "could not create <#{ zipped }>" unless test ?e, zipped
+    if block_given?
+      yield zipped
+    else
+      zipped
+    end
+#--}}}
+  end
+  alias gzip zip
+  export 'gzip'
+  export 'zip'
+#
+# return the zipped name of a path
+#
+  def zipped_name path, z_ext = nil 
+#--{{{
+    z_ext ||= '.gz'
+    z_ext.gsub! %r/^\s*\.+/, '.'
+    "#{ path }#{ z_ext }"
+#--}}}
+  end
+  export 'zipped_name'
+#
+# unzip a file - return unzipped name
+#
+  def unzip path, z_pat = nil 
+#--{{{
+    z_pat ||= %r/\.(?:z|gz)$/io
+    spawn "gzip --force --decompress #{ path }" if zipped?(path, z_pat)
+    #spawn "gzip --force --decompress #{ path }"
+    uzn = unzipped_name path, z_pat 
+    if block_given?
+      yield uzn
+    else
+      uzn
+    end
+#--}}}
+  end
+  alias gunzip unzip
+  export 'gunzip'
+  export 'unzip'
+#
+# return the unzipped name of a path
+#
+  def unzipped_name path, z_pat = nil 
+#--{{{
+    z_pat ||= %r/\.(?:z|gz)$/io
+    path.gsub z_pat, ''
+#--}}}
+  end
+  export 'unzipped_name'
+#
+# guess if a file is zipped based on pathname
+#
+  def zipped? path, z_pat = %r/\.(?:z|gz)$/io
+#--{{{
+    path =~ z_pat
+#--}}}
+  end
+  alias gzipped? zipped?
+  alias zipped zipped?
+  export 'zipped'
+  export 'gzipped?'
+  export 'zipped?'
+#
+# convert a string to an integer of any base
+#
+  def strtod(s, opts = {})
+#--{{{
+    base = getopt 'base', opts, 10
+    case base
+      when 2
+        s = "0b#{ s }" unless s =~ %r/^0b\d/
+      when 8
+        s = "0#{ s }" unless s =~ %r/^0\d/
+      when 16 
+        s = "0x#{ s }" unless s =~ %r/^0x\d/
+    end
+    Integer s
+#--}}}
+  end
+  export 'strtod'
+#
+# convert a string to an integer
+#
+  def atoi(s, opts = {})
+#--{{{
+    strtod("#{ s }".gsub(%r/^0+/,''), 'base' => 10)
+#--}}}
+  end
+  export 'atoi'
+#
+# bin a integer into a int range using modulo logic
+#
+  def rangemod n, ir
+#--{{{
+    a, b = Integer(ir.first), Integer(ir.last)
+    a, b = b, a if a >= b
+    exclusive = ir.exclude_end?
+    size = b - a 
+    size += 1 unless exclusive
+    offset = a - 0
+    x = (n + offset).modulo size
+    x += offset
+#--}}}
+  end
+#
+# bin a integer into a int range using modulo logic
+#
+  def rangemod n, ir
+#--{{{
+    a, b = [ir.first.to_i, ir.last.to_i].sort
+    b += 1 if ir.exclude_end?
+    size = b - a 
+    if n < a
+      v = n - a
+      d = v.abs
+      r = d % size
+      n = b - r
+    elsif n > b
+      v = n - b
+      d = v.abs
+      r = d % size
+      n = a + r
+    end
+    raise "failed to rangemod #{ n } => #{ ir }" unless
+      ir.include? n
+    n
+#--}}}
+  end
+  export 'rangemod'
+#
+# explode a 
+#
+  def hms s
+#--{{{
+    h, s = s.divmod 3600
+    m, s = s.divmod 60
+    [h.to_i, m.to_i, s]
+#--}}}
+  end
+  export 'hms'
+#
+# expand variables in a string destructively (to the string)
+#
+  def expand! string, vars = {} 
+#--{{{
+    loop do
+      changed = false
+      vars.each do |var, value|
+        var.gsub! %r/[^a-zA-Z0-9_]/, ''
+        [ 
+          %r/\$#{ var }\b/, 
+          %r/\@#{ var }\b/, 
+          %r/\${\s*#{ var }\s*}/, 
+          %r/\@{\s*#{ var }\s*}/ 
+        ].each do |pat|
+          changed = string.gsub! pat, "#{ value }"
+        end
+      end
+      break unless changed
+    end
+    string
+#--}}}
+  end
+  export 'expand!'
+  def expand string, opts = {}
+#--{{{
+    expand! string.dup, opts
+#--}}}
+  end
+  export 'expand'
+#
+# determine path of current ruby interpreter (argv[0] in c)
+#
+  def which_ruby
+#--{{{
+    c = ::Config::CONFIG
+    File::join(c['bindir'], c['ruby_install_name']) << c['EXEEXT']
+#--}}}
+  end
+  export 'which_ruby'
+#
+# declare multi-dimensional arrays as in md[2,3,4]
+#
+  def md
+#--{{{
+    @__md__ ||=
+      lambda{|*ds| Array::new(ds.shift||0).map{md[*ds] unless ds.empty?}}
+#--}}}
+  end
+  export 'md'
+#
+# find natural left margin of a here-doc and un-indent it
+#
+  def unindent! s
+#--{{{
+    indent = nil
+    s.each do |line|
+      next if line =~ %r/^\s*$/
+      indent = line[%r/^\s*/] and break
+    end
+    s.gsub! %r/^#{ indent }/, "" if indent
+    indent ? s : nil
+#--}}}
+  end
+  export 'unindent!'
+
+  def unindent s
+#--{{{
+    s = "#{ s }"
+    unindent! s
+    s
+#--}}}
+  end
+  export 'unindent'
+
+  def parse_timespec spec
+#--{{{
+  ret = nil
+  pat = %r/(\d+(?:\.\d+)?)\s*([sSmMhHdD][^\d]*)?/
+  begin
+    "#{ spec }".scan(pat) do |m|
+      n = Float m[0]
+      unit = m[1]
+      if unit
+        factor =
+          case unit
+            when %r/^m/i
+              60
+            when %r/^h/i
+              60 * 60
+            when %r/^d/i
+              60 * 60 * 24
+            else
+              1
+          end
+        n *= factor
+      end
+      ret ||= 0.0
+      ret += n
+    end
+  rescue
+    raise "bad time spec <#{ spec }>"
+  end
+  ret
+#--}}}
+  end
+  export 'parse_timespec'
+
+  def snake_case string
+#--{{{
+    return string unless string =~ %r/[A-Z]/
+    string.reverse.scan(%r/[A-Z]+|[^A-Z]*[A-Z]+?/).reverse.map{|word| word.reverse.downcase}.join '_'
+#--}}}
+  end
+  export 'snake_case'
+
+  def camel_case string
+#--{{{
+    return string if string =~ %r/[A-Z]/ and string !~ %r/_/
+    words = string.strip.split %r/\s*_+\s*/
+    words.map!{|w| w.downcase.sub(%r/^./){|c| c.upcase}}
+    words.join
+#--}}}
+  end
+  export 'camel_case'
+
+  def atomic_copy src, dst
+#--{{{
+    f, fu = File, FileUtils
+    src_dirname, src_basename = f.split src
+
+    dst = f.join dst, src_basename if test ?d, dst
+
+    dst_dirname, dst_basename = f.split dst
+
+    tmp = f.join dst_dirname, ".#{ src_basename }.#{ hostname }.tmp"
+
+    begin
+      fu.cp_r src, tmp, :preserve => true
+      begin 
+        fu.mv tmp, dst
+      rescue
+        uncache tmp rescue nil
+        uncache dst rescue nil
+        sleep 42
+        fu.mv tmp, dst
+      end
+    ensure
+      fu.rm_f tmp
+    end
+
+    dst
+#--}}}
+  end
+  export 'atomic_copy'
+
+  def child_object
+#--{{{
+    r, w = IO.pipe
+    IO.popen('-') do |pipe|
+      if pipe
+        w.close
+        buf = pipe.read
+        Process.wait
+        unless $? == 0
+          loaded = Marshal.load r.read
+          case loaded
+            when Exception
+              raise loaded
+            else
+              klass, message, backtrace = loaded
+              e = klass.new message
+              e.set_backtrace backtrace
+              raise e
+          end
+        end
+        Marshal.load(buf)
+      else
+        r.close
+        begin
+          print(Marshal.dump(yield))
+        rescue Exception => e
+          dumped =
+            begin
+              Marshal.dump e # we can't do this in ruby 1.8.1
+            rescue
+              Marshal.dump [e.class, e.message, e.backtrace]
+            end
+          w.write dumped
+          exit! 42
+        end
+      end
+    end
+  ensure
+    r.close rescue nil
+#--}}}
+  end
+  export 'child_object'
+
+  def curl uri, opts = {}
+#--{{{
+    retries = begin;(getopt 'retries', opts, 42).to_i;rescue NoMethodError;0;end
+    wait = Float(getopt('wait', opts, 2))
+    begin
+      uri = URI === uri ? uri : URI::parse(uri.to_s)
+      req = Net::HTTP::Get.new(uri.path || 'index.html')
+      res = Net::HTTP::start(uri.host, uri.port){|http| http.request(req)}
+      res.body
+    rescue Timeout::Error, Errno::ECONNREFUSED => e
+      if retries > 0 
+        retries -= 1
+        #Kernel::warn(errmsg(e))
+        sleep wait 
+        retry
+      else
+        raise
+      end
+    end
+#--}}}
+  end
+  export 'curl'
+
+#
+# import open4 methods
+#
+  %w(spawn open4 bg background).each do |m|
+    module_eval <<-code
+      def #{ m }(*a, &b)
+        ::Open4::#{ m }(*a, &b)
+      end
+      export '#{ m }'
+    code
+  end
+#--}}}
+end # module Util