rbbt-util 3.2.1 → 4.0.0

data/lib/rbbt/tsv/serializers.rb

@@ -0,0 +1,79 @@
+module TSV
+  class IntegerSerializer
+    def self.dump(i); [i].pack("l"); end
+    def self.load(str); str.unpack("l").first; end
+  end
+
+  class FloatSerializer
+    def self.dump(i); [i].pack("d"); end
+    def self.load(str); str.unpack("d").first; end
+  end
+
+  class IntegerArraySerializer
+    def self.dump(a); a.pack("l*"); end
+    def self.load(str); str.unpack("l*"); end
+  end
+
+  class StringSerializer
+    def self.dump(str); str.to_s; end
+    def self.load(str); str; end
+  end
+
+  class StringArraySerializer
+    def self.dump(array)
+      array.collect{|a| a.to_s} * "\t"
+    end
+
+    def self.load(string)
+      return [] if string.nil?
+      string.split("\t", -1)
+    end
+  end
+
+  class StringDoubleArraySerializer
+    def self.dump(array)
+      array.collect{|a| a.collect{|a| a.to_s} * "|"} * "\t"
+    end
+
+    def self.load(string)
+      return [] if string.nil?
+      string.split("\t", -1).collect{|l| l.split("|", -1)}
+    end
+  end
+
+  class TSVMarshalSerializer
+    def self.dump(tsv)
+      Marshal.dump(tsv.dup)
+    end
+
+    def self.load(string)
+      TSV.setup Marshal.load(string)
+    end
+  end
+
+
+  class TSVSerializer
+    def self.dump(tsv)
+      tsv.to_s
+    end
+
+    def self.load(string)
+      TSV.open StringIO.new(string)
+    end
+  end
+
+  SERIALIZER_ALIAS = {
+    :integer => IntegerSerializer, 
+    :float => FloatSerializer, 
+    :integer_array => IntegerArraySerializer,
+    :marshal => Marshal,
+    :single => StringSerializer,
+    :string => StringSerializer,
+    :list => StringArraySerializer,
+    :flat => StringArraySerializer,
+    :double => StringDoubleArraySerializer,
+    :tsv => TSVSerializer,
+    :marshal_tsv => TSVMarshalSerializer
+  }
+
+end

data/lib/rbbt/tsv/util.rb

@@ -0,0 +1,67 @@
+require 'rbbt/resource/path'
+module TSV
+
+  def self.field_match_counts(file, values)
+    fields = TSV.parse_header(Open.open(file)).all_fields
+
+    counts = {}
+    TmpFile.with_file do |tmpfile|
+      if Array === values
+        Open.write(tmpfile, values * "\n")
+      else
+        FileUtils.ln_s values, tmpfile
+      end
+
+      fields.each_with_index do |field,i|
+        counts[field] = begin
+                          CMD.cmd("cat #{ file } |grep -v ^#|cut -f #{i + 1}|tr '|' '\\n' |sort -u |grep [[:alpha:]]|grep -f #{tmpfile} -F -w").read.count("\n")
+                        rescue
+                          0
+                        end
+      end
+    end
+
+    counts
+  end
+  def self.get_filename(file)
+    case
+    when String === file
+      filename = file
+    when file.respond_to?(:gets)
+      filename = file.filename if file.respond_to? :filename
+    else
+      raise "Cannot get stream from: #{file.inspect}"
+    end
+    filename
+  end
+
+  def self.get_stream(file)
+    case
+    when Path === file
+      file.open
+    when String === file
+      File.open(file)
+    when file.respond_to?(:gets)
+      file
+    else
+      raise "Cannot get stream from: #{file.inspect}"
+    end
+  end
+
+  def self.identify_field(key_field, fields, field)
+    case
+    when Integer === field
+      field
+    when (field.nil? or field == :key or key_field == field)
+      :key
+    when String === field
+      fields.index field
+    end
+  end
+
+  def identify_field(field)
+    TSV.identify_field(key_field, fields, field)
+  end
+
+
+end

data/lib/rbbt/util/R.rb

@@ -1,5 +1,5 @@
 require 'rbbt/util/cmd'
-require 'rbbt/util/tsv'
+require 'rbbt/tsv'
 
 module R
 
@@ -24,7 +24,7 @@ module R
 
 end
 
-class TSV
+module TSV
   def R(script, open_options = {})
     TmpFile.with_file do |f|
       Open.write(f, self.to_s)
@@ -36,7 +36,7 @@ rbbt.tsv.write('#{f}', data);
       EOF
       ).read)
       open_options = Misc.add_defaults open_options, :type => :list
-      TSV.new(f, open_options)
+      TSV.open(f, open_options)
     end
   end
 end

data/lib/rbbt/util/chain_methods.rb

@@ -0,0 +1,64 @@
+require 'rbbt/util/log'
+
+module ChainMethods
+  def self.extended(base)
+    if not base.respond_to? :chain_prefix
+      metaclass = class << base
+        attr_accessor :chain_prefix, :chained_methods
+
+        def chained_methods
+          @chained_methods ||= instance_methods.select{|method| method =~ /^#{chain_prefix}/}
+        end
+        self
+      end
+
+      metaclass.module_eval do
+        def setup_chain(object)
+          object.extend self
+        end
+
+        def setup_chains(base)
+          raise "No prefix specified for #{self.to_s}" if self.chain_prefix.nil? or (String === self.chain_prefix and self.chain_prefix.empty?)
+          #methods = self.instance_methods.select{|method| method =~ /^#{self.chain_prefix}/}
+          methods = self.chained_methods
+
+          return if methods.empty?
+
+          prefix = self.chain_prefix
+
+          new_method = methods.first
+          original = new_method.sub(prefix.to_s + '_', '')
+          first_clean_method = prefix.to_s + '_clean_' + original
+
+          if not base.respond_to? first_clean_method
+            class << base; self; end.module_eval do
+              methods.each do |new_method|
+                original = new_method.sub(prefix.to_s + '_', '')
+                clean_method = prefix.to_s + '_clean_' + original
+
+                original = "[]" if original == "get_brackets"
+                original = "[]=" if original == "set_brackets"
+
+                begin
+                  alias_method clean_method, original 
+                rescue
+                end
+                alias_method original, new_method
+              end
+            end
+          end
+        end
+      end
+
+      if not metaclass.respond_to? :extended
+        metaclass.module_eval do
+          def extended(base)
+            setup_chains(base)
+          end
+        end
+      end
+    end
+
+    base.chain_prefix = base.to_s.downcase.to_sym
+  end
+end

data/lib/rbbt/util/cmd.rb

@@ -4,10 +4,11 @@ require 'stringio'
 
 module CMD
 
-  class CMDError < RBBTError; end
+  class CMDError < StandardError; end
+
   module SmartIO 
-    attr_accessor :pid, :cmd, :post, :in, :out, :err
-    def self.tie(io, pid = nil, cmd = "",  post = nil, sin = nil, out = nil, err = nil)
+    attr_accessor :pid, :cmd, :post, :in, :out, :err, :log
+    def self.tie(io, pid = nil, cmd = "",  post = nil, sin = nil, out = nil, err = nil, log = true)
       io.extend SmartIO
       io.pid = pid
       io.cmd = cmd
@@ -15,6 +16,7 @@ module CMD
       io.out  = out 
       io.err  = err 
       io.post = post
+      io.log = log
 
       io.class.send(:alias_method, :original_close, :close)
       io.class.send(:alias_method, :original_read, :read)
@@ -28,10 +30,10 @@ module CMD
         rescue
         end
 
-        Log.debug "Process #{ cmd } succeded" if $? and $?.success?
+        Log.debug "Process #{ cmd } succeded" if $? and $?.success? and log
 
         if $? and not $?.success?
-          Log.debug "Raising exception"
+          Log.debug "Raising exception" if log
           exception = CMDError.new "Command [#{@pid}] #{@cmd} failed with error status #{$?.exitstatus}"
           original_close
           raise exception
@@ -51,7 +53,7 @@ module CMD
 
     def force_close
       if @pid
-        Log.debug "Forcing close by killing '#{@pid}'"
+        Log.debug "Forcing close by killing '#{@pid}'" if log
         Process.kill("KILL", @pid)
         Process.waitpid(@pid)
       end
@@ -98,6 +100,9 @@ module CMD
     stderr     = options.delete(:stderr)
     pipe       = options.delete(:pipe)
     post       = options.delete(:post)
+    log        = options.delete(:log)
+
+    log = true if log.nil?
 
     if stderr == true
       stderr = Log::HIGH
@@ -149,8 +154,8 @@ module CMD
 
         exit(-1)
       rescue Exception
-        Log.debug("CMDError: #{$!.message}")
-        ddd $!.backtrace
+        Log.debug("CMDError: #{$!.message}") if log
+        ddd $!.backtrace if log
         raise CMDError, $!.message
       end
     }
@@ -164,7 +169,7 @@ module CMD
     serr = serr.first
     
 
-    Log.debug "CMD: [#{pid}] #{cmd}"
+    Log.debug "CMD: [#{pid}] #{cmd}" if log
 
     if in_content.respond_to?(:read)
       Thread.new do
@@ -190,7 +195,7 @@ module CMD
     if pipe
       Thread.new do
         while line = serr.gets
-          Log.log line, stderr if Integer === stderr
+          Log.log line, stderr if Integer === stderr and log
         end
         serr.close
         Thread.exit
@@ -216,11 +221,10 @@ module CMD
       Process.waitpid pid
 
       if not $?.success?
-        exception      = CMDError.new "Command [#{pid}] #{cmd} failed with error status #{$?.exitstatus}"
-        exception.info = err if Integer === stderr and stderr >= Log.severity
+        exception      = CMDError.new "Command [#{pid}] #{cmd} failed with error status #{$?.exitstatus}.\n#{err}"
         raise exception
       else
-        Log.log err, stderr if Integer === stderr
+        Log.log err, stderr if Integer === stderr and log
       end
 
       out

data/lib/rbbt/util/excel2tsv.rb

@@ -1,7 +1,8 @@
 require 'spreadsheet'
-require 'rbbt/util/tsv'
+require 'rbbt/tsv'
 require 'rbbt/util/tmpfile'
-class TSV
+
+module TSV
   def self.excel2tsv(file, options = {})
     sheet = options.delete :sheet
     header = options.delete :header
@@ -26,7 +27,7 @@ class TSV
         rows.each do |row| f.puts row * "\t" end
       end
 
-      TSV.new(filename, options)
+      TSV.open(filename, options)
     end
   end
 end

data/lib/rbbt/util/log.rb

@@ -19,6 +19,7 @@ module Log
   SEVERITY_COLOR = ["0;37m", "0;32m", "0;33m", "0;31m", "1;0m" ].collect{|e| "\033[#{e}"}
 
   def self.log(message, severity = MEDIUM)
+    message ||= ""
     severity_color = SEVERITY_COLOR[severity]
     font_color = {false => "\033[0;37m", true => "\033[0m"}[severity >= INFO]
 

data/lib/rbbt/util/misc.rb

@@ -1,46 +1,46 @@
-require 'iconv'
 require 'lockfile'
-require 'digest/md5'
+require 'rbbt/util/chain_methods'
+require 'rbbt/resource/path'
 
-class RBBTError < StandardError
-  attr_accessor :info
+module Misc
+  class FieldNotFoundError < StandardError;end
 
-  alias old_to_s to_s
-  def to_s
-    str = old_to_s.dup
-    if info
-      str << "\n" << "Additional Info:\n---\n" << info << "---"
-    end
-    str
-  end
-end
+  
+  IUPAC2BASE = {
+    "A" => ["A"],
+    "C" => ["C"],
+    "G" => ["G"],
+    "T" => ["T"],
+    "U" => ["U"],
+    "R" => "A or G".split(" or "),
+    "Y" => "C or T".split(" or "),
+    "S" => "G or C".split(" or "),
+    "W" => "A or T".split(" or "),
+    "K" => "G or T".split(" or "),
+    "M" => "A or C".split(" or "),
+    "B" => "C or G or T".split(" or "),
+    "D" => "A or G or T".split(" or "),
+    "H" => "A or C or T".split(" or "),
+    "V" => "A or C or G".split(" or "),
+    "N" => %w(A C T G),
+  }
 
-module IndiferentHash
-  def indiferent_get(key)
-    old_get(key) || 
-    old_get(key.to_s) || 
-    old_get(key.to_sym) 
-  end
+  BASE2COMPLEMENT = {
+    "A" => "T",
+    "C" => "G",
+    "G" => "C",
+    "T" => "A",
+    "U" => "A",
+  }
 
-  def self.extended(base)
-    class << base
-      alias_method :old_get, :[]
-      alias_method :[], :indiferent_get
-    end
+  def self.IUPAC_to_base(iupac)
+    IUPAC2BASE[iupac]
   end
-end
 
-module Misc
-  class FieldNotFoundError < StandardError;end
-
-  def self.in_dir(dir)
-    old_pwd = FileUtils.pwd
-    begin
-      FileUtils.cd dir
-      yield
-    ensure
-      FileUtils.cd old_pwd
-    end
+  def self.is_filename?(string)
+    return true if Path === string
+    return true if String === string and string.length < 265 and File.exists? string
+    return false
   end
 
   def self.intersect_sorted_arrays(a1, a2)
@@ -97,73 +97,21 @@ module Misc
     new
   end
 
-  def self.digest(text)
-    Digest::MD5.hexdigest(text)
-  end
-
-  def self.add_method(object, method_name, &block)
-    class << object
-      self
-    end.send :define_method, method_name, block
-  end
-
-  def self.redefine_method(object, old_method, new_method_name, &block)
-    return if object.respond_to? new_method_name
-    metaclass = class << object; self end
-    metaclass.send :alias_method, new_method_name, old_method
-    metaclass.send :define_method, old_method, &block
-  end
-
-  def self.filename?(filename)
-    String === filename and filename.length < 1024 and filename.index("\n").nil? and File.exists? filename
-  end
-
-  def self.lock(file, *args)
-    FileUtils.mkdir_p File.dirname(File.expand_path(file)) unless File.exists?  File.dirname(File.expand_path(file))
-    lockfile = Lockfile.new(file + '.lock')
-    lockfile.lock do
-      yield file, *args
-    end
-  end
-
-  def self.string2const(string)
-    return nil if string.nil?
-    mod = Kernel
-
-    string.to_s.split('::').each do |str|
-      mod = mod.const_get str
-    end
-
-    mod
-  end
-
-  def self.path_relative_to(path, subdir)
-    File.expand_path(path).sub(/^#{Regexp.quote File.expand_path(subdir)}\/?/,'')
-  end
-
-  def self.in_directory?(file, directory)
-    if File.expand_path(file) =~ /^#{Regexp.quote File.expand_path(directory)}/
-      true
-    else
-      false
+  def self.array2hash(array)
+    hash = {}
+    array.each do |key, value|
+      hash[key] = value
     end
+    hash
   end
 
-  def self.find_files_back_to(path, target, subdir)
-    return [] if path.nil?
-    files = []
-    while in_directory?(path, subdir)
-      path = path.dirname
-      if path[target].exists?
-        files << path[target]
-      end
-    end
-
-    files
+  def self.zip2hash(list1, list2)
+    array2hash(list1.zip(list2))
   end
 
-  def self.this_dir
-    File.expand_path(File.dirname(caller[0]))
+  def self.process_to_hash(list)
+    result = yield list
+    zip2hash(list, result)
   end
 
   def self.env_add(var, value, sep = ":", prepend = true)
@@ -176,15 +124,6 @@ module Misc
       end
   end
 
-  def self.count(list)
-    counts = Hash.new 0
-    list.each do |item|
-      counts[item] += 1
-    end
-
-    counts
-  end
-
   def self.benchmark(repeats = 1)
     require 'benchmark'
     res = nil
@@ -220,6 +159,73 @@ module Misc
     res
   end
 
+  def self.insist(times = 3)
+    try = 0
+    begin
+      yield
+    rescue
+      try += 1
+      retry if try < times
+    end
+  end
+
+  def self.try3times(&block)
+    insist(3, &block)
+  end
+
+  def self.hash2string(hash)
+    hash.sort_by{|k,v| k.to_s}.collect{|k,v| 
+      next unless %w(Symbol String Float Fixnum Integer TrueClass FalseClass Module Class Object).include? v.class.to_s
+      [ Symbol === k ? ":" << k.to_s : k,
+        Symbol === v ? ":" << v.to_s : v] * "="
+    }.compact * "#"
+  end
+
+  def self.path_relative_to(basedir, path)
+    path = File.expand_path(path)
+    basedir = File.expand_path(basedir)
+
+    if path =~ /#{Regexp.quote basedir}\/(.*)/
+      return $1
+    else
+      return nil
+    end
+  end
+
+  def self.lock(file, *args)
+    FileUtils.mkdir_p File.dirname(File.expand_path(file)) unless File.exists?  File.dirname(File.expand_path(file))
+    lockfile = Lockfile.new(file + '.lock')
+    lockfile.lock do
+      yield file, *args
+    end
+  end
+
+  def self.common_path(dir, file)
+    file = File.expand_path file
+    dir = File.expand_path dir
+
+    return true if file == dir
+    while File.dirname(file) != file
+      file = File.dirname(file)
+      return true if file == dir
+    end
+
+    return false
+  end
+
+  def self.in_dir(dir)
+    old_pwd = FileUtils.pwd
+    res = nil
+    begin
+      FileUtils.mkdir_p dir unless File.exists? dir
+      FileUtils.cd dir
+      res = yield
+    ensure
+      FileUtils.cd old_pwd
+    end
+    res
+  end
+
   def self.fixutf8(string)
     if string.respond_to?(:valid_encoding?) and ! string.valid_encoding?
       @@ic ||= Iconv.new('UTF-8//IGNORE', 'UTF-8')
@@ -229,6 +235,25 @@ module Misc
     end
   end
 
+  def self.sensiblewrite(path, content)
+    begin
+      case
+      when String === content
+        File.open(path, 'w') do |f|  f.write content  end
+      when (IO === content or StringIO === content)
+        File.open(path, 'w') do |f|  while l = content.gets; f.write l; end  end
+      else
+        File.open(path, 'w') do |f|  end
+      end
+    rescue Interrupt
+      FileUtils.rm_f path
+      raise "Interrupted (Ctrl-c)"
+    rescue Exception
+      FileUtils.rm_f path
+      raise $!
+    end
+  end
+
   def self.add_defaults(options, defaults = {})
     case
     when Hash === options
@@ -246,20 +271,8 @@ module Misc
     new_options
   end
 
-  def self.process_options(hash, *keys)
-    if keys.length == 1
-      hash.delete keys.first.to_sym
-    else
-      keys.collect do |key| hash.delete(key.to_sym) || hash.delete(key.to_s) end
-    end
-  end
-
-  def self.hash2string(hash)
-    hash.sort_by{|k,v| k.to_s}.collect{|k,v| 
-      next unless %w(Symbol String Float Fixnum Integer TrueClass FalseClass Module Class Object).include? v.class.to_s
-      [ Symbol === k ? ":" << k.to_s : k,
-        Symbol === v ? ":" << v.to_s : v] * "="
-    }.compact * "#"
+  def self.digest(text)
+    Digest::MD5.hexdigest(text)
   end
 
   def self.hash2md5(hash)
@@ -270,14 +283,57 @@ module Misc
       case
       when v.inspect =~ /:0x0/
         o[k] = v.inspect.sub(/:0x[a-f0-9]+@/,'')
-      when Resource::Path === v
-        o[k] = "" << String.new(v.to_s)
+        #when Resource::Path === v
+        #  o[k] = "" << String.new(v.to_s)
       else
         o[k] = v
       end
     end
 
-    Digest::MD5.hexdigest(o.sort_by{|k| k.to_s}.inspect)
+    if o.empty?
+      ""
+    else
+      Digest::MD5.hexdigest(o.sort_by{|k| k.to_s}.inspect)
+    end
+  end
+
+  def self.process_options(hash, *keys)
+    if keys.length == 1
+      hash.delete keys.first.to_sym
+    else
+      keys.collect do |key| hash.delete(key.to_sym) || hash.delete(key.to_s) end
+    end
+  end
+
+  def self.pull_keys(hash, prefix)
+    new = {}
+    hash.keys.each do |key|
+      if key.to_s =~ /#{ prefix }_(.*)/
+        case
+        when String === key
+          new[$1] = hash.delete key
+        when Symbol === key
+          new[$1.to_sym] = hash.delete key
+        end
+      else
+        if key.to_s == prefix.to_s
+          new[key] = hash.delete key
+        end
+      end
+    end
+
+    new
+  end
+
+  def self.string2const(string)
+    return nil if string.nil?
+    mod = Kernel
+
+    string.to_s.split('::').each do |str|
+      mod = mod.const_get str
+    end
+
+    mod
   end
 
   def self.string2hash(string)
@@ -290,58 +346,42 @@ module Misc
         option, value = str, true
       end
 
-      option = option.sub(":",'').to_sym if option.chars.first == ':'
-      value  = value.sub(":",'').to_sym if String === value and value.chars.first == ':'
-      
-      if value == true
-        options[option] = option.to_s.chars.first != '!' 
-      else
-        options[option] = Thread.start do
-          $SAFE = 0;
-          case 
-          when value =~ /^(?:true|T)$/i
-            true
-          when value =~ /^(?:false|F)$/i
-            false
-          when (String === value and value =~ /^\/(.*)\/$/)
-            Regexp.new /#{$1}/
-          else
-            begin
-              Kernel.const_get value
-            rescue
-              begin  
-                eval(value) 
-              rescue Exception
-                value 
-              end
+    option = option.sub(":",'').to_sym if option.chars.first == ':'
+    value  = value.sub(":",'').to_sym if String === value and value.chars.first == ':'
+
+    if value == true
+      options[option] = option.to_s.chars.first != '!' 
+    else
+      options[option] = Thread.start do
+        $SAFE = 0;
+        case 
+        when value =~ /^(?:true|T)$/i
+          true
+        when value =~ /^(?:false|F)$/i
+          false
+        when Symbol === value
+          value
+        when (String === value and value =~ /^\/(.*)\/$/)
+          Regexp.new /#{$1}/
+        else
+          begin
+            Kernel.const_get value
+          rescue
+            begin  
+              raise if value =~ /[a-z]/ and defined? value
+              eval(value) 
+            rescue Exception
+              value 
             end
           end
-        end.value
-      end
+        end
+      end.value
+    end
     end
 
     options
   end
 
-  def self.sensiblewrite(path, content)
-    begin
-      case
-      when String === content
-        File.open(path, 'w') do |f|  f.write content  end
-      when (IO === content or StringIO === content)
-        File.open(path, 'w') do |f|  while l = content.gets; f.write l; end  end
-      else
-        File.open(path, 'w') do |f|  end
-      end
-    rescue Interrupt
-      FileUtils.rm_f path
-      raise "Interrupted (Ctrl-c)"
-    rescue Exception
-      FileUtils.rm_f path
-      raise $!
-    end
-  end
-
   def self.field_position(fields, field, quiet = false)
     return field if Integer === field or Range === field
     raise FieldNotFoundError, "Field information missing" if fields.nil? && ! quiet
@@ -351,30 +391,6 @@ module Misc
     raise FieldNotFoundError, "Field #{ field.inspect } was not found" unless quiet
   end
 
-  def self.first(list)
-    return nil if list.nil?
-    return list.first
-  end
-
-  def self.chunk(text, split)
-    text.split(split)[1..-1]
-  end
-
-  def self.insist(times = 3)
-    try = 0
-    begin
-      yield
-    rescue
-      try += 1
-      retry if try < times
-    end
-  end
-
-  def self.try3times(&block)
-    insist(3, &block)
-  end
-
-
   # Divides the array into +num+ chunks of the same size by placing one
   # element in each chunk iteratively.
   def self.divide(array, num)
@@ -387,70 +403,21 @@ module Misc
     chunks
   end
 
-  def self.merge2hash(list1, list2)
-    hash = {}
-    list1.zip(list2).each do |k,v| hash[k] = v end
-    hash
+  def self.zip_fields(array)
+    array[0].zip(*array[1..-1])
   end
 
-
-  def self.process_to_hash(list)
-    result = yield list
-    merge2hash(list, result)
-  end
-
-  IUPAC2BASE = {
-    "A" => ["A"],
-    "C" => ["C"],
-    "G" => ["G"],
-    "T" => ["T"],
-    "U" => ["U"],
-    "R" => "A or G".split(" or "),
-    "Y" => "C or T".split(" or "),
-    "S" => "G or C".split(" or "),
-    "W" => "A or T".split(" or "),
-    "K" => "G or T".split(" or "),
-    "M" => "A or C".split(" or "),
-    "B" => "C or G or T".split(" or "),
-    "D" => "A or G or T".split(" or "),
-    "H" => "A or C or T".split(" or "),
-    "V" => "A or C or G".split(" or "),
-    "N" => %w(A C T G),
-  }
-
-  BASE2COMPLEMENT = {
-    "A" => "T",
-    "C" => "G",
-    "G" => "C",
-    "T" => "A",
-    "U" => "A",
-  }
-
-  def self.IUPAC_to_base(iupac)
-    IUPAC2BASE[iupac]
-  end
-end
-
-module PDF2Text
-  def self.pdf2text(filename)
-    require 'rbbt/util/cmd'
-    require 'rbbt/util/tmpfile'
-    require 'rbbt/util/open'
-
-
-    TmpFile.with_file(Open.open(filename, :nocache => true).read) do |pdf_file|
-      CMD.cmd("pdftotext #{pdf_file} -", :pipe => false, :stderr => true)
-    end
-  end
 end
 
-class NamedArray < Array
+module NamedArray
+  extend ChainMethods
+  self.chain_prefix = :named_array
   attr_accessor :fields
 
-  def self.name(array, fields)
-    a = self.new(array)
-    a.fields = fields
-    a
+  def self.setup(array, fields)
+    array.extend NamedArray
+    array.fields = fields
+    array
   end
 
   def merge(array)
@@ -476,26 +443,23 @@ class NamedArray < Array
     end
   end
 
-  alias original_get_brackets []
-  def [](key)
-    original_get_brackets(Misc.field_position(fields, key))
+  def named_array_get_brackets(key)
+    named_array_clean_get_brackets(Misc.field_position(fields, key))
   end
 
-  alias original_set_brackets []=
-    def []=(key,value)
-      original_set_brackets(Misc.field_position(fields, key), value)
-    end
+  def named_array_set_brackets(key,value)
+    named_array_clean_set_brackets(Misc.field_position(fields, key), value)
+  end
 
-  alias original_values_at values_at
-  def values_at(*keys)
+  def named_array_values_at(*keys)
     keys = keys.collect{|k| Misc.field_position(fields, k) }
-    original_values_at(*keys)
+    named_array_clean_values_at(*keys)
   end
 
   def zip_fields
     return [] if self.empty?
-    zipped = self[0].zip(*self[1..-1])
-    zipped = zipped.collect{|v| NamedArray.name(v, fields)}
+    zipped = Misc.zip_fields(self)
+    zipped = zipped.collect{|v| NamedArray.setup(v, fields)}
     zipped 
   end
 
@@ -511,38 +475,85 @@ class NamedArray < Array
 
   def report
     fields.zip(self).collect do |field,value|
-      "* #{ field }: #{ Array === value ? value * "|" : value }"
+      "\nAttributes:\n* #{ field }: #{ Array === value ? value * "|" : value }"
     end * "\n"
   end
 
 end
 
-def benchmark(bench = true)
-  require 'benchmark'
-  if bench
-    res = nil
-    puts(Benchmark.measure do
-      res = yield
-    end)
-    res
-  else
-    yield
+class RBBTError < StandardError
+  attr_accessor :info
+
+  alias old_to_s to_s
+  def to_s
+    str = old_to_s.dup
+    if info
+      str << "\n" << "Additional Info:\n---\n" << info << "---"
+    end
+    str
   end
 end
 
-def profile(prof = true)
-  require 'ruby-prof'
-  if prof
-    RubyProf.start
-    res = yield
-    result = RubyProf.stop
+module IndiferentHash
+  extend ChainMethods
+  self.chain_prefix = :indiferent
+
+  def indiferent_get_brackets(key)
+    case 
+    when (Symbol === key and indiferent_clean_include? key)
+      indiferent_clean_get_brackets(key)
+    when (Symbol === key and indiferent_clean_include? key.to_s)
+      indiferent_clean_get_brackets(key.to_s)
+    when (String === key and indiferent_clean_include? key)
+      indiferent_clean_get_brackets(key)
+    when (String === key and indiferent_clean_include? key.to_sym)
+      indiferent_clean_get_brackets(key.to_sym)
+    else
+      indiferent_clean_get_brackets(key) 
+    end
+  end
 
-    # Print a flat profile to text
-    printer = RubyProf::FlatPrinter.new(result)
-    printer.print(STDOUT, 0)
+  def indiferent_values_at(*key_list)
+    res = []
+    key_list.each{|key| res << indiferent_get_brackets(key)}
     res
-  else
-    yield
+  end
+
+  def indiferent_include?(key)
+    case
+    when Symbol === key
+      indiferent_clean_include?(key) or indiferent_clean_include?(key.to_s) 
+    when String === key
+      indiferent_clean_include?(key) or indiferent_clean_include?(key.to_sym) 
+    else
+      indiferent_clean_include?(key)
+    end
+  end
+
+  def indiferent_delete(value)
+    if indiferent_clean_include? value.to_s
+      indiferent_clean_delete(value.to_s) 
+    else
+      indiferent_clean_delete(value.to_sym) 
+    end
+  end
+
+  def self.setup(hash)
+    return hash if IndiferentHash === hash
+    hash.extend IndiferentHash
+    hash
   end
 end
 
+module PDF2Text
+  def self.pdftotext(filename)
+    require 'rbbt/util/cmd'
+    require 'rbbt/util/tmpfile'
+    require 'rbbt/util/open'
+
+
+    TmpFile.with_file(Open.open(filename, :nocache => true).read) do |pdf_file|
+      CMD.cmd("pdftotext #{pdf_file} -", :pipe => false, :stderr => true)
+    end
+  end
+end