rbbt-util 5.11.9 → 5.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2dfad08e355d768565decb173f5a86198c3600e2
-  data.tar.gz: 64421ddf30a3066b1313c1762a9c1b41cb9a719b
+  metadata.gz: fea2c562a8e3611c8c9767589ec160a36c1b988d
+  data.tar.gz: 42c868b4354a14c64c9eb5ea45b4d447c3d1c757
 SHA512:
-  metadata.gz: f415797c4922dea7a9f3ecc8ff636cd3681da6f22b0111c34e1210e9beed4430c8c17c4787e9fe5ad4ad2e63d014be2308a533d220f87e2f40224b9d91daadaa
-  data.tar.gz: 8b7ad6d7440ece8580bab37f20c6e7e86158953a73dce168816b26e6003cb9966dd40359a798a0eb4abc152393c86c922f93ce3d2a27c272a47ebbbba5907d35
+  metadata.gz: c85bd1f0ed345e6277daed12a41145134f81914e5d1b678db4676296dcb9a8e1ae1bc66c0b3dcc866dc9cab1ebcb80d50cb7181f4e71d755ecb721e3dffa9f55
+  data.tar.gz: fd38d3d2ef666f8b8b4eae6ce66b8ce45b8c5cb6a57e3bbc28c2900f239495a9f991080026e09dc7fbaca480518095e426f482afcc104d07f656835b80509bf2

data/lib/rbbt/persist.rb

@@ -465,7 +465,7 @@ module Persist
                 res.abort if res.respond_to? :abort
                 raise $!
               end
-            when TSV::Dumper
+            when (defined? TSV and TSV::Dumper)
               begin
                 io = res.stream
                 res = TSV.open(io)

data/lib/rbbt/tsv.rb

@@ -15,6 +15,7 @@ require 'rbbt/tsv/attach'
 require 'rbbt/tsv/filter'
 require 'rbbt/tsv/field_index'
 require 'rbbt/tsv/parallel'
+require 'rbbt/tsv/stream'
 
 module TSV
   class << self

data/lib/rbbt/tsv/dumper.rb

@@ -64,8 +64,7 @@ module TSV
     end
 
     def close_out
-      Log.debug "Close out #{@stream.inspect}"
-      @stream.close
+      @stream.close unless @stream.closed?
     end
 
     def close_in

data/lib/rbbt/tsv/parallel/traverse.rb

@@ -69,8 +69,8 @@ module TSV
   def self.traverse_io_array(io, options = {}, &block)
     callback = Misc.process_options options, :callback
     if callback
-      while not io.eof?
-        res = yield io.gets.strip
+      while line = io.gets
+        res = yield line.strip
         callback.call res
       end
     else

data/lib/rbbt/tsv/parser.rb

@@ -65,7 +65,7 @@ module TSV
     end
 
     def chop_line(line)
-      line.split(@sep, -1)
+      @sep == " " ? line.split(/ /, -1) : line.split(@sep, -1)
     end
 
     def get_values_single_from_flat(parts)
@@ -448,8 +448,12 @@ module TSV
     def options
       options = {}
       TSV::ENTRIES.each do |entry|
-        options[entry.to_sym] = self.send(entry) if self.respond_to? entry
+        if self.respond_to? entry
+          value = self.send(entry) 
+          options[entry.to_sym] = value unless value.nil?
+        end
       end
+      options[:sep] = @sep if @sep and @sep != "\t" and @sep != /\t/
       IndiferentHash.setup options
     end
 

data/lib/rbbt/tsv/stream.rb

@@ -0,0 +1,55 @@
+require 'rbbt/tsv/parser'
+require 'rbbt/tsv/dumper'
+module TSV
+
+  def self.collapse_stream(input, options = {})
+    options = Misc.add_defaults options, :sep => "\t"
+    input_stream = TSV.get_stream input
+
+    sorted_input_stream = Misc.sort_stream input_stream
+
+    parser = TSV::Parser.new sorted_input_stream, options.dup
+    dumper = TSV::Dumper.new parser
+    header = TSV.header_lines(parser.key_field, parser.fields, parser.options)
+    dumper.close_in
+    dumper.close_out
+    dumper.stream = Misc.collapse_stream parser.stream, parser.first_line, parser.sep, header
+    dumper
+  end
+ 
+  def self.paste_streams(inputs, options = {})
+    options = Misc.add_defaults options, :sep => "\t", :sort => false
+    sort = Misc.process_options options, :sort
+
+    input_streams = []
+    input_lines = []
+    input_fields = []
+    input_key_fields = []
+    input_options = []
+
+    input_source_streams = inputs.collect do |input|
+      stream = TSV.get_stream input
+      stream = sort ? Misc.sort_stream(stream) : stream
+    end
+
+    input_source_streams.each do |stream|
+      parser = TSV::Parser.new stream, options
+      input_streams << parser.stream
+      input_lines << parser.first_line
+      input_fields << parser.fields
+      input_key_fields << parser.key_field
+      input_options << parser.options
+    end
+
+    key_field = input_key_fields.first
+    fields = input_fields.flatten
+    options = options.merge(input_options.first)
+
+    dumper = TSV::Dumper.new options.merge(:key_field => key_field, :fields => fields)
+    dumper.close_in
+    dumper.close_out
+    header = TSV.header_lines(key_field, fields, options)
+    dumper.stream = Misc.paste_streams input_streams, input_lines, options[:sep], header
+    dumper
+  end
+end

data/lib/rbbt/tsv/util.rb

@@ -61,6 +61,7 @@ module TSV
       begin
         TSV.open(CMD.cmd(cmd), :key_field => 1, :type => :single, :cast => :to_i)
       rescue
+        Log.exception $!
         TSV.setup({}, :type => :single, :cast => :to_i)
       end
     end
@@ -106,6 +107,11 @@ module TSV
     when String
       raise "Could not open file given by String: #{Misc.fingerprint file}" unless Open.remote?(file) or File.exists? file
       Open.open(file, open_options)
+    when (defined? Step and Step)
+      stream = file.get_stream
+      stream || get_stream(file.join.path)
+    when TSV::Dumper
+      file.stream
     else
       raise "Cannot get stream from: #{file.inspect}"
     end
@@ -134,7 +140,7 @@ module TSV
     sep = (Hash === entry_hash and entry_hash[:sep]) ? entry_hash[:sep] : "\t"
 
     str = "" 
-    str << "#: " << Misc.hash2string(entry_hash) << "\n" if entry_hash and entry_hash.any?
+    str << "#: " << Misc.hash2string(entry_hash.merge(:key_field => nil, :fields => nil)) << "\n" if entry_hash and entry_hash.any?
     if fields
       str << "#" << key_field << sep << fields * sep << "\n"
     end

data/lib/rbbt/util/misc.rb

@@ -1,9 +1,9 @@
 require 'lockfile'
-require 'net/smtp'
 require 'digest/md5'
 require 'cgi'
 require 'zlib'
 require 'rubygems/package'
+
 require 'rbbt/util/tar'
 require 'rbbt/util/misc/exceptions'
 require 'rbbt/util/misc/concurrent_stream'
@@ -15,769 +15,12 @@ require 'rbbt/util/misc/inspect'
 require 'rbbt/util/misc/math'
 require 'rbbt/util/misc/development'
 require 'rbbt/util/misc/lock'
-
-
-class Hash
-  def chunked_values_at(keys, max = 5000)
-    Misc.ordered_divide(keys, max).inject([]) do |acc,c|
-      new = self.values_at(*c)
-      new.annotate acc if new.respond_to? :annotate and acc.empty?
-      acc.concat(new)
-    end
-  end
-end
-
-module LaterString
-  def to_s
-    yield
-  end
-end
+require 'rbbt/util/misc/options'
+require 'rbbt/util/misc/system'
+require 'rbbt/util/misc/objects'
+require 'rbbt/util/misc/manipulation'
 
 module Misc
-
-  def self.parse_cmd_params(str)
-    return str if Array === str
-    str.scan(/
-             (?:["']([^"']*?)["']) |
-             ([^"'\s]+)
-    /x).flatten.compact
-  end
-
-  def self.pid_exists?(pid)
-    return false if pid.nil?
-    begin
-      Process.getpgid(pid.to_i)
-      true
-    rescue Errno::ESRCH
-      false
-    end
-  end
-
-  def self.collapse_ranges(ranges)
-    processed = []
-    last = nil
-    final = []
-    ranges.sort_by{|range| range.begin }.each do |range|
-      rbegin = range.begin
-      rend = range.end
-      if last.nil? or rbegin > last
-        processed << [rbegin, rend]
-        last = rend
-      else
-       new_processed = []
-        processed.each do |pbegin,pend|
-          if pend < rbegin
-            final << [pbegin, pend]
-          else
-            eend = [rend, pend].max
-            new_processed << [pbegin, eend]
-            break
-          end
-        end
-        processed = new_processed
-        last = rend if rend > last
-      end
-    end
-
-    final.concat processed
-    final.collect{|b,e| (b..e)}
-  end
-
-  def self.total_length(ranges)
-    Misc.collapse_ranges(ranges).inject(0) do |total,range| total += range.end - range.begin + 1 end
-  end
-
-  def self.random_sample_in_range(total, size)
-    p = Set.new
-
-    if size > total / 10
-      template = (0..total - 1).to_a
-      size.times do |i|
-        pos = (rand * (total - i)).floor
-        if pos == template.length - 1
-          v = template.pop
-        else
-          v, n = template[pos], template[-1]
-          template.pop
-          template[pos] = n 
-        end
-        p << v
-      end
-    else
-      size.times do 
-        pos = nil
-        while pos.nil? 
-          pos = (rand * total).floor
-          if p.include? pos
-            pos = nil
-          end
-        end
-        p << pos
-      end
-    end
-    p
-  end
-
-  def self.sample(ary, size, replacement = false)
-    if ary.respond_to? :sample
-      ary.sample size
-    else
-      total = ary.length
-      p = random_sample_in_range(total, size)
-      ary.values_at *p
-    end
-  end
-
-
-  def self.prepare_entity(entity, field, options = {})
-    return entity unless defined? Entity
-    return entity unless String === entity or Array === entity
-    options ||= {}
-
-    dup_array = options.delete :dup_array
-
-    if Annotated === field or Entity.respond_to?(:formats) and Entity.formats.include? field
-      params = options.dup
-
-      params[:format] ||= params.delete "format"
-      params.merge!(:format => field) unless params.include?(:format) and not ((f = params[:format]).nil? or (String === f and f.empty?))
-
-      mod = Entity === field ? field : Entity.formats[field]
-      entity = mod.setup(
-        ((entity.frozen? and not entity.nil?) ? entity.dup : ((Array === entity and dup_array) ? entity.collect{|e| e.nil? ? e : e.dup} : entity) ),
-        params
-      ) 
-    end
-
-    entity
-  end
- 
-  def self.ensembl_server(organism)
-    date = organism.split("/")[1]
-    if date.nil?
-      "www.ensembl.org"
-    else
-      "#{ date }.archive.ensembl.org"
-    end
-  end
-
-
-  def self.google_venn(list1, list2, list3, name1 = nil, name2 = nil, name3 = nil, total = nil)
-    name1 ||= "list 1"
-    name2 ||= "list 2"
-    name3 ||= "list 3"
-
-    sizes = [list1, list2, list3, list1 & list2, list1 & list3, list2 & list3, list1 & list2 & list3].collect{|l| l.length}
-
-    total = total.length if Array === total
-
-    label = "#{name1}: #{sizes[0]} (#{name2}: #{sizes[3]}, #{name3}: #{sizes[4]})"
-    label << "|#{name2}: #{sizes[1]} (#{name1}: #{sizes[3]}, #{name3}: #{sizes[5]})"
-      label << "|#{name3}: #{sizes[2]} (#{name1}: #{sizes[4]}, #{name2}: #{sizes[5]})"
-      if total
-        label << "| INTERSECTION: #{sizes[6]} TOTAL: #{total}"
-      else
-        label << "| INTERSECTION: #{sizes[6]}"
-      end
-
-    max = total || sizes.max
-    sizes = sizes.collect{|v| (v.to_f/max * 100).to_i.to_f / 100}
-    url = "https://chart.googleapis.com/chart?cht=v&chs=500x300&chd=t:#{sizes * ","}&chco=FF6342,ADDE63,63C6DE,FFFFFF&chdl=#{label}"
-  end
-
-  def self.consolidate(list)
-    list.inject(nil){|acc,e|
-      if acc.nil?
-        acc = e
-      else
-        acc.concat e
-        acc
-      end
-    }
-  end
-
-  def self.positional2hash(keys, *values)
-    if Hash === values.last
-      extra = values.pop
-      inputs = Misc.zip2hash(keys, values)
-      inputs.delete_if{|k,v| v.nil? or (String === v and v.empty?)}
-      inputs = Misc.add_defaults inputs, extra
-      inputs.delete_if{|k,v| not keys.include?(k) and not (Symbol === k ? keys.include?(k.to_s) : keys.include?(k.to_sym))}
-      inputs
-    else
-      Misc.zip2hash(keys, values)
-    end
-  end
-
-  def self.send_email(from, to, subject, message, options = {})
-    IndiferentHash.setup(options)
-    options = Misc.add_defaults options, :from_alias => nil, :to_alias => nil, :server => 'localhost', :port => 25, :user => nil, :pass => nil, :auth => :login
-
-    server, port, user, pass, from_alias, to_alias, auth = Misc.process_options options, :server, :port, :user, :pass, :from_alias, :to_alias, :auth
-
-    msg = <<-END_OF_MESSAGE
-From: #{from_alias} <#{from}>
-To: #{to_alias} <#{to}>
-Subject: #{subject}
-
-#{message}
-END_OF_MESSAGE
-
-Net::SMTP.start(server, port, server, user, pass, auth) do |smtp|
-  smtp.send_message msg, from, to
-end
-  end
-
-  def self.counts(array)
-    counts = {}
-    array.each do |e|
-      counts[e] ||= 0
-      counts[e] += 1
-    end
-
-    counts
-  end
-
-  def self.proportions(array)
-    total = array.length
-
-    proportions = Hash.new 0
-
-    array.each do |e|
-      proportions[e] += 1.0 / total
-    end
-
-    class << proportions; self;end.class_eval do
-      def to_s
-        sort{|a,b| a[1] == b[1] ? a[0] <=> b[0] : a[1] <=> b[1]}.collect{|k,c| "%3d\t%s" % [c, k]} * "\n"
-      end
-    end
-
-    proportions
-  end
-
-
-  def self.sorted_array_hits(a1, a2)
-    e1, e2 = a1.shift, a2.shift
-    counter = 0
-    match = []
-    while true
-      break if e1.nil? or e2.nil?
-      case e1 <=> e2
-      when 0
-        match << counter
-        e1, e2 = a1.shift, a2.shift
-        counter += 1
-      when -1
-        while not e1.nil? and e1 < e2
-          e1 = a1.shift 
-          counter += 1
-        end
-      when 1
-        e2 = a2.shift
-        e2 = a2.shift while not e2.nil? and e2 < e1
-      end
-    end
-    match
-  end
-
-  def self.intersect_sorted_arrays(a1, a2)
-    e1, e2 = a1.shift, a2.shift
-    intersect = []
-    while true
-      break if e1.nil? or e2.nil?
-      case e1 <=> e2
-      when 0
-        intersect << e1
-        e1, e2 = a1.shift, a2.shift
-      when -1
-        e1 = a1.shift while not e1.nil? and e1 < e2
-      when 1
-        e2 = a2.shift
-        e2 = a2.shift while not e2.nil? and e2 < e1
-      end
-    end
-    intersect
-  end
-
-  def self.merge_sorted_arrays(a1, a2)
-    e1, e2 = a1.shift, a2.shift
-    new = []
-    while true
-      case
-      when (e1 and e2)
-        case e1 <=> e2
-        when 0
-          new << e1 
-          e1, e2 = a1.shift, a2.shift
-        when -1
-          new << e1
-          e1 = a1.shift
-        when 1
-          new << e2
-          e2 = a2.shift
-        end
-      when e2
-        new << e2
-        new.concat a2
-        break
-      when e1
-        new << e1
-        new.concat a1
-        break
-      else
-        break
-      end
-    end
-    new
-  end
-
-  def self.binary_include?(array, elem)
-    upper = array.size - 1
-    lower = 0
-
-    return -1 if upper < lower
-
-    while(upper >= lower) do
-      idx = lower + (upper - lower) / 2
-      value = array[idx]
-
-      case elem <=> value
-      when 0
-        return true
-      when -1
-        upper = idx - 1
-      when 1
-        lower = idx + 1
-      else
-        raise "Cannot compare #{[elem.inspect, value.inspect] * " with "}"
-      end
-    end
-
-    return false
-  end
-
-
-
-  def self.array2hash(array, default = nil)
-    hash = {}
-    array.each do |key, value|
-      value = default.dup if value.nil? and not default.nil?
-      hash[key] = value
-    end
-    hash
-  end
-
-  def self.zip2hash(list1, list2)
-    hash = {}
-    list1.each_with_index do |e,i|
-      hash[e] = list2[i]
-    end
-    hash
-  end
-
-  def self.process_to_hash(list)
-    result = yield list
-    zip2hash(list, result)
-  end
-
-  def self.env_add(var, value, sep = ":", prepend = true)
-    ENV[var] ||= ""
-    return if ENV[var] =~ /(#{sep}|^)#{Regexp.quote value}(#{sep}|$)/
-      if prepend
-        ENV[var] = value + sep + ENV[var]
-      else
-        ENV[var] += sep + ENV[var]
-      end
-  end
-
-  def self.do_once(&block)
-    return nil if $__did_once
-    $__did_once = true
-    yield
-    nil
-  end
-
-  def self.reset_do_once
-    $__did_once = false
-  end
-
-  def self.insist(times = 3, sleep = nil, msg = nil)
-    if Array === times
-      sleep_array = times
-      times = sleep_array.length
-      sleep = sleep_array.shift
-    end
-    try = 0
-    begin
-      yield
-    rescue
-      if msg
-        Log.warn("Insisting after exception: #{$!.message} -- #{msg}")
-      else
-        Log.warn("Insisting after exception: #{$!.message}")
-      end
-      if sleep and try > 0
-        sleep sleep
-        sleep = sleep_array.shift if sleep_array
-      else
-        Thread.pass
-      end
-      try += 1
-      retry if try < times
-      raise $!
-    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.GET_params2hash(string)
-    hash = {}
-    string.split('&').collect{|item|
-      key, value = item.split("=").values_at 0, 1
-      hash[key] = value.nil? ? "" : CGI.unescape(value)
-    }
-    hash
-  end
-
-  def self.hash2GET_params(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 Array).include? v.class.to_s
-      v = case 
-          when Symbol === v
-            v.to_s
-          when Array === v
-            v * ","
-          else
-            CGI.escape(v.to_s)
-          end
-      [ Symbol === k ? k.to_s : k,  v] * "="
-    }.compact * "&"
-  end
-
-  def self.hash_to_html_tag_attributes(hash)
-    return "" if hash.nil? or hash.empty?
-    hash.collect{|k,v| 
-      case 
-      when (k.nil? or v.nil? or (String === v and v.empty?))
-        nil
-      when Array === v
-        [k,"'" << v * " " << "'"] * "="
-      when String === v
-        [k,"'" << v << "'"] * "="
-      when Symbol === v
-        [k,"'" << v.to_s << "'"] * "="
-      when TrueClass === v
-        [k,"'" << v.to_s << "'"] * "="
-      when (Fixnum === v or Float === v)
-        [k,"'" << v.to_s << "'"] * "="
-      else
-        nil
-      end
-    }.compact * " "
-  end
-
-  def self.html_tag(tag, content = nil, params = {})
-    attr_str = hash_to_html_tag_attributes(params)
-    attr_str = " " << attr_str if String === attr_str and attr_str != ""
-    html = if content.nil?
-      "<#{ tag }#{attr_str}/>"
-    else
-      "<#{ tag }#{attr_str}>#{ content }</#{ tag }>"
-    end
-
-    html
-  end
-
-  def self.path_relative_to(basedir, path)
-    path = File.expand_path(path) unless path[0] == "/"
-    basedir = File.expand_path(basedir) unless basedir[0] == "/"
-
-    if path.index(basedir) == 0
-      if basedir[-1] == "/"
-        return path[basedir.length..-1]
-      else
-        return path[basedir.length+1..-1]
-      end
-    else
-      return nil
-    end
-  end
-
-  def self.hostname
-    @hostanem ||= `hostname`.strip
-  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
-
-  # WARN: probably not thread safe...
-  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.add_defaults(options, defaults = {})
-    case
-    when Hash === options
-      new_options = options.dup
-    when String === options
-      new_options = string2hash options
-    else
-      raise "Format of '#{options.inspect}' not understood. It should be a hash"
-    end
-
-    defaults.each do |key, value|
-      next if options.include? key
-
-      new_options[key] = value 
-    end
-
-    new_options
-  end
-
-  def self.process_options(hash, *keys)
-    if keys.length == 1
-      hash.include?(keys.first.to_sym) ? hash.delete(keys.first.to_sym) : hash.delete(keys.first.to_s) 
-    else
-      keys.collect do |key| hash.include?(key.to_sym) ? 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_old(string)
-
-    options = {}
-    string.split(/#/).each do |str|
-      if str.match(/(.*)=(.*)/)
-        option, value = $1, $2
-      else
-        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 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
-        end.value
-      end
-    end
-
-    options
-  end
-
-  def self.string2hash(string)
-    options = {}
-
-    string.split('#').each do |str|
-      key, sep, value = str.partition "="
-
-      key = key[1..-1].to_sym if key[0] == ":"
-
-      options[key] = true and next if value.empty?
-      options[key] = value[1..-1].to_sym and next if value[0] == ":"
-      options[key] = Regexp.new(/#{value[1..-2]}/) and next if value[0] == "/" and value[-1] == "/"
-      options[key] = value[1..-2] and next if value =~ /^['"].*['"]$/
-      options[key] = value.to_i and next if value =~ /^\d+$/
-      options[key] = value.to_f and next if value =~ /^\d*\.\d+$/
-      options[key] = true and next if value == "true"
-      options[key] = false and next if value == "false"
-      options[key] = value and next 
-
-      options[key] = begin
-                       saved_safe = $SAFE
-                       $SAFE = 0
-                       eval(value)
-                     rescue Exception
-                       value
-                     ensure
-                       $SAFE = saved_safe
-                     end
-    end
-
-    return options
-
-    options = {}
-    string.split(/#/).each do |str|
-      if str.match(/(.*)=(.*)/)
-        option, value = $1, $2
-      else
-        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 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
-        end.value
-      end
-    end
-
-    options
-  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
-    fields.each_with_index{|f,i| return i if f == field}
-    field_re = Regexp.new /^#{field}$/i
-    fields.each_with_index{|f,i| return i if f =~ field_re}
-    raise FieldNotFoundError, "Field #{ field.inspect } was not found" unless quiet
-  end
-
-  # Divides the array into +num+ chunks of the same size by placing one
-  # element in each chunk iteratively.
-  def self.divide(array, num)
-    num = 1 if num == 0
-    chunks = []
-    num.to_i.times do chunks << [] end
-    array.each_with_index{|e, i|
-      c = i % num
-      chunks[c] << e
-    }
-    chunks
-  end
-
-  # Divides the array into chunks of +num+ same size by placing one
-  # element in each chunk iteratively.
-  def self.ordered_divide(array, num)
-    last = array.length - 1
-    chunks = []
-    current = 0
-    while current <= last
-      next_current = [last, current + num - 1].min
-      chunks << array[current..next_current]
-      current = next_current + 1
-    end
-    chunks
-  end
-
-  def self.append_zipped(current, new)
-    current.each do |v|
-      n = new.shift
-      if Array === n
-        v.concat new
-      else
-        v << n
-      end
-    end
-    current
-  end
-
-  def self.zip_fields(array)
-    return [] if array.empty? or (first = array.first).nil?
-    first.zip(*array[1..-1])
-  end
 end
 
 module PDF2Text