bio 1.0.0 → 1.1.0

data/lib/bio/io/fetch.rb

@@ -1,114 +1,181 @@
 #
 # = bio/io/biofetch.rb - BioFetch access module
 #
-# Copyright::   Copyright (C) 2002, 2005
-#               Toshiaki Katayama <k@bioruby.org>
-# License::     LGPL
+# Copyright::	Copyright (C) 2002, 2005 Toshiaki Katayama <k@bioruby.org>,
+#               Copyright (C) 2006 Jan Aerts <jan.aerts@bbsrc.ac.uk>
+# License::     The Ruby License
 #
-# $Id: fetch.rb,v 1.4 2005/12/18 15:58:42 k Exp $
+#  $Id: fetch.rb,v 1.10 2007/04/05 23:35:41 trevor Exp $
 #
-#--
+# == DESCRIPTION
 #
-#  This library is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU Lesser General Public
-#  License as published by the Free Software Foundation; either
-#  version 2 of the License, or (at your option) any later version.
+# Using BioRuby BioFetch server
 #
-#  This library is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-#  Lesser General Public License for more details.
+#   br_server = Bio::Fetch.new()
+#   puts br_server.databases
+#   puts br_server.formats('embl')
+#   puts br_server.maxids
 #
-#  You should have received a copy of the GNU Lesser General Public
-#  License along with this library; if not, write to the Free Software
-#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
-#
-#++
+# Using EBI BioFetch server
 #
+#   ebi_server = Bio::Fetch.new('http://www.ebi.ac.uk/cgi-bin/dbfetch')
+#   puts ebi_server.fetch('embl', 'J00231', 'raw')
+#   puts ebi_server.fetch('embl', 'J00231', 'html')
+#   puts Bio::Fetch.query('genbank', 'J00231')
+#   puts Bio::Fetch.query('genbank', 'J00231', 'raw', 'fasta')
+# 
 
 require 'uri'
-require 'net/http'
+require 'bio/command'
 
 module Bio
-
-class Fetch
-
-  # Create a new Bio::Fetch server object.
-  # Use Bio::Fetch.new('http://www.ebi.ac.uk/cgi-bin/dbfetch') to connect
-  # to EBI BioFetch server.
-  def initialize(url = 'http://bioruby.org/cgi-bin/biofetch.rb')
-    schema, user, @host, @port, reg, @path, = URI.split(url)
-  end
-
-  # Set default database to dbname (prepare for get_by_id).
-  attr_accessor :database
-
-  # Get raw database entry by id (mainly used by Bio::Registry).
-  def get_by_id(id)
-    fetch(@database, id)
-  end
-
-  # Fetch a database entry as specified by database (db), entry id (id),
-  # 'raw' text or 'html' (style), and format.  When using BioRuby's
-  # BioFetch server, value for the format should not be set.
-  def fetch(db, id, style = 'raw', format = nil)
-    data = [ "db=#{db}", "id=#{id}", "style=#{style}" ]
-    data.push("format=#{format}") if format
-    data = data.join('&')
-
-    responce, result = Net::HTTP.new(@host, @port).post(@path, data)
-    return result
-  end
-
-  # Short cut for using BioRuby's BioFetch server.  You can fetch an entry
-  # without creating instance of BioFetch server.
-  def self.query(*args)
-    self.new.fetch(*args)
-  end
-
-  # What databases are available?
-  def databases
-    query = "info=dbs"
-    responce, result = Net::HTTP.new(@host, @port).post(@path, query)
-    return result
-  end
-
-  # What formats does the database X have?
-  def formats(database = @database)
-    if database
-      query = "info=formats;db=#{database}"
-      responce, result = Net::HTTP.new(@host, @port).post(@path, query)
-      return result
+  # = DESCRIPTION
+  # The Bio::Fetch class provides an interface to dbfetch servers. Given
+  # a database name and an accession number, these servers return the associated
+  # record. For example, for the embl database on the EBI, that would be a
+  # nucleic or amino acid sequence.
+  #
+  # Possible dbfetch servers include:
+  # * http://bioruby.org/cgi-bin/biofetch.rb (default)
+  # * http://www.ebi.ac.uk/cgi-bin/dbfetch
+  #
+  # If you're behind a proxy server, be sure to set your HTTP_PROXY
+  # environment variable accordingly.
+  #
+  # = USAGE
+  #  require 'bio'
+  #
+  #  # Retrieve the sequence of accession number M33388 from the EMBL
+  #  # database.
+  #  server = Bio::Fetch.new()  #uses default server
+  #  puts server.fetch('embl','M33388')
+  #  
+  #  # Do the same thing without creating a Bio::Fetch object. This method always
+  #  # uses the default dbfetch server: http://bioruby.org/cgi-bin/biofetch.rb
+  #  puts Bio::Fetch.query('embl','M33388')
+  #
+  #  # To know what databases are available on the bioruby dbfetch server:
+  #  server = Bio::Fetch.new()
+  #  puts server.databases
+  #
+  #  # Some databases provide their data in different formats (e.g. 'fasta',
+  #  # 'genbank' or 'embl'). To check which formats are supported by a given
+  #  # database:
+  #  puts server.formats('embl')
+  #
+  class Fetch
+  
+    # Create a new Bio::Fetch server object that can subsequently be queried
+    # using the Bio::Fetch#fetch method
+    # ---
+    # *Arguments*:
+    # * _url_: URL of dbfetch server (default = 'http://bioruby.org/cgi-bin/biofetch.rb')
+    # *Returns*:: Bio::Fetch object
+    def initialize(url = 'http://bioruby.org/cgi-bin/biofetch.rb')
+      @url = url
+      schema, user, @host, @port, reg, @path, = URI.split(@url)
     end
+  
+    # The default database to query
+    #--
+    # This will be used by the get_by_id method
+    #++
+    attr_accessor :database
+  
+    # Get raw database entry by id. This method lets the Bio::Registry class
+    # use Bio::Fetch objects.
+    def get_by_id(id)
+      fetch(@database, id)
+    end
+  
+    # Fetch a database entry as specified by database (db), entry id (id),
+    # 'raw' text or 'html' (style), and format.  When using BioRuby's
+    # BioFetch server, value for the format should not be set.
+    # Examples:
+    #   server = Bio::Fetch.new('http://www.ebi.ac.uk/cgi-bin/dbfetch')
+    #   puts server.fetch('embl','M33388','raw','fasta')
+    #   puts server.fetch('refseq','NM_12345','html','embl')
+    # ---
+    # *Arguments*:
+    # * _database_: name of database to query (see Bio::Fetch#databases to get list of supported databases)
+    # * _id_: single ID or ID list separated by commas or white space
+    # * _style_: [raw|html] (default = 'raw')
+    # * _format_: name of output format (see Bio::Fetch#formats)
+    def fetch(db, id, style = 'raw', format = nil)
+      query = [ "db=#{db}", "id=#{id}", "style=#{style}" ]
+      query.push("format=#{format}") if format
+      query = query.join('&')
+  
+      Bio::Command.read_uri(@url + '?' + URI.escape(query))
+    end
+  
+    # Shortcut for using BioRuby's BioFetch server. You can fetch an entry
+    # without creating an instance of BioFetch server. This method uses the 
+    # default dbfetch server, which is http://bioruby.org/cgi-bin/biofetch.rb
+    # 
+    # Example:
+    #   puts Bio::Fetch.query('refseq','NM_12345')
+    #
+    # ---
+    # *Arguments*:
+    # * _database_: name of database to query (see Bio::Fetch#databases to get list of supported databases)
+    # * _id_: single ID or ID list separated by commas or white space
+    # * _style_: [raw|html] (default = 'raw')
+    # * _format_: name of output format (see Bio::Fetch#formats)
+    def self.query(*args)
+      self.new.fetch(*args)
+    end
+  
+    # Using this method, the user can ask a dbfetch server what databases
+    # it supports. This would normally be the first step you'd take when
+    # you use a dbfetch server for the first time.
+    # Example:
+    #  server = Bio::Fetch.new()
+    #  puts server.databases # returns "aa aax bl cpd dgenes dr ec eg emb ..."
+    #
+    # This method only works for the bioruby dbfetch server. For a list
+    # of databases available from the EBI, see the EBI website at 
+    # http://www.ebi.ac.uk/cgi-bin/dbfetch/
+    # ---
+    # *Returns*:: array of database names
+    def databases
+      query = "info=dbs"
+
+      Bio::Command.read_uri(@url + '?' + URI.escape(query)).strip.split(/\s+/)
+    end
+  
+    # Lists the formats that are available for a given database. Like the
+    # Bio::Fetch#databases method, this method is only available on 
+    # the bioruby dbfetch server.
+    # Example:
+    #  server = Bio::Fetch.new()
+    #  puts server.formats('embl') # returns "default fasta"
+    # ---
+    # *Arguments*:
+    # * _database_:: name of database you want the supported formats for
+    # *Returns*:: array of formats
+    def formats(database = @database)
+      if database
+        query = "info=formats;db=#{database}"
+
+        Bio::Command.read_uri(@url + '?' + URI.escape(query)).strip.split(/\s+/)
+      end
+    end
+  
+    # A dbfetch server will only return entries up to a given maximum number.
+    # This method retrieves that number from the server. As for the databases
+    # and formats methods, the maxids method only works for the bioruby
+    # dbfetch server.
+    # ---
+    # *Arguments*: none
+    # *Returns*:: number
+    def maxids
+      query = "info=maxids"
+
+      Bio::Command.read_uri(@url + '?' + URI.escape(query)).to_i
+    end
+  
   end
 
-  # How many entries can be retrieved simultaneously?
-  def maxids
-    query = "info=maxids"
-    responce, result = Net::HTTP.new(@host, @port).post(@path, query)
-    return result
-  end
-
-end
-
 end # module Bio
 
-
-
-if __FILE__ == $0
-
-# bfserv = Bio::Fetch.new('http://www.ebi.ac.uk:80/cgi-bin/dbfetch')
-  bfserv = Bio::Fetch.new('http://www.ebi.ac.uk/cgi-bin/dbfetch')
-  puts "# test 1"
-  puts bfserv.fetch('embl', 'J00231', 'raw')
-  puts "# test 2"
-  puts bfserv.fetch('embl', 'J00231', 'html')
-
-  puts "# test 3"
-  puts Bio::Fetch.query('genbank', 'J00231')
-  puts "# test 4"
-  puts Bio::Fetch.query('genbank', 'J00231', 'raw', 'fasta')
-
-end
-
-

data/lib/bio/io/flatfile.rb

@@ -3,9 +3,9 @@
 #
 #   Copyright (C) 2001-2006 Naohisa Goto <ng@bioruby.org>
 #
-# License:: Ruby's
+# License:: The Ruby License
 #
-#  $Id: flatfile.rb,v 1.46 2006/02/22 10:01:27 ngoto Exp $
+#  $Id: flatfile.rb,v 1.60 2007/07/09 14:08:34 ngoto Exp $
 #
 #
 # Bio::FlatFile is a helper and wrapper class to read a biological data file.
@@ -34,7 +34,6 @@ module Bio
         @path = path
         # initialize prefetch buffer
         @buffer = ''
-        @path = path
       end
 
       # Creates a new input stream wrapper from the given IO object.
@@ -262,6 +261,9 @@ module Bio
         # the last entry read from the stream
         attr_reader :entry
 
+        # a flag to write down entry start and end positions
+        attr_accessor :entry_pos_flag
+
         # start position of the entry
         attr_reader :entry_start_pos
 
@@ -290,6 +292,7 @@ module Bio
             end
           end
           @delimiter_overrun = klass::DELIMITER_OVERRUN rescue nil
+          @entry_pos_flag = nil
         end
 
         # (String) delimiter indicates the end of a entry.
@@ -330,7 +333,7 @@ module Bio
 
         # gets a entry
         def get_entry
-          p0 = @stream.pos
+          p0 = @entry_pos_flag ? @stream.pos : nil
           e  = @stream.gets(@delimiter)
           if e and @delimiter_overrun then
             if e[-@delimiter.size, @delimiter.size ] == @delimiter then
@@ -339,7 +342,7 @@ module Bio
               @stream.ungets(overrun)
             end
           end
-          p1 = @stream.pos
+          p1 = @entry_pos_flag ? @stream.pos : nil
           @entry_start_pos = p0
           @entry = e
           @entry_ended_pos = p1
@@ -422,7 +425,7 @@ module Bio
       # check if file is filename or IO object
       unless file.respond_to?(:gets)
         # 'file' is a filename
-        self.open_file(file, *arg, &block)
+        _open_file(dbclass, file, *arg, &block)
       else
         # 'file' is a IO object
         ff = self.new(dbclass, file)
@@ -462,15 +465,27 @@ module Bio
     # Otherwise, it returns a new FlatFile object.
     #
     def self.open_file(filename, *arg)
+      _open_file(nil, filename, *arg)
+    end
+
+    # Same as FlatFile.open(dbclass, filename, *arg),
+    # except that it only accept filename and doesn't accept IO object.
+    #
+    # It can accept a block.
+    # If a block is given, it returns the block's return value.
+    # Otherwise, it returns a new FlatFile object.
+    #
+    def self._open_file(dbclass, filename, *arg)
       if block_given? then
         BufferedInputStream.open_file(filename, *arg) do |stream|
-          yield self.new(nil, stream)
+          yield self.new(dbclass, stream)
         end
       else
         stream = BufferedInputStream.open_file(filename, *arg)
-        self.new(nil, stream)
+        self.new(dbclass, stream)
       end
     end
+    private_class_method :_open_file
 
     # Opens URI specified as _uri_.
     # _uri_ must be a String or URI object.
@@ -493,6 +508,20 @@ module Bio
       end
     end
 
+    # Executes the block for every entry in the stream.
+    # Same as FlatFile.open(*arg) { |ff| ff.each { |entry| ... }}.
+    # 
+    # * Example
+    #     Bio::FlatFile.foreach('test.fst') { |e| puts e.definition }
+    #
+    def self.foreach(*arg)
+      self.open(*arg) do |flatfileobj|
+        flatfileobj.each do |entry|
+          yield entry
+        end
+      end
+    end
+
     # Same as FlatFile.open, except that 'stream' should be a opened
     # stream object (IO, File, ..., who have the 'gets' method).
     #
@@ -518,13 +547,11 @@ module Bio
     #
     def initialize(dbclass, stream)
       # 2nd arg: IO object
-      if @stream.kind_of?(BufferedInputStream)
+      if stream.kind_of?(BufferedInputStream)
         @stream = stream
       else
         @stream = BufferedInputStream.for_io(stream)
       end
-      # default is raw mode
-      self.raw = false
       # 1st arg: database class (or file format autodetection)
       if dbclass then
 	self.dbclass = dbclass
@@ -534,6 +561,8 @@ module Bio
       #
       @skip_leader_mode = :firsttime
       @firsttime_flag = true
+      # default raw mode is false
+      self.raw = false
     end
 
     # The mode how to skip leader of the data.
@@ -563,8 +592,14 @@ module Bio
       @stream.path
     end
 
+    # Exception class to be raised when data format hasn't been specified.
+    class UnknownDataFormatError < IOError
+    end
+
     # Get next entry.
     def next_entry
+      raise UnknownDataFormatError, 
+      'file format auto-detection failed?' unless @dbclass
       if @skip_leader_mode and
           ((@firsttime_flag and @skip_leader_mode == :firsttime) or
              @skip_leader_mode == :everytime)
@@ -587,6 +622,16 @@ module Bio
       @splitter.entry
     end
 
+    # a flag to write down entry start and end positions
+    def entry_pos_flag
+      @splitter.entry_pos_flag
+    end
+
+    # Sets flag to write down entry start and end positions
+    def entry_pos_flag=(x)
+      @splitter.entry_pos_flag = x
+    end
+
     # start position of the last entry
     def entry_start_pos
       @splitter.entry_start_pos
@@ -736,21 +781,26 @@ module Bio
 
       include TSort
 
+      # Array to store autodetection rules.
+      # This is defined only for inspect.
+      class RulesArray < Array
+        # visualize contents
+        def inspect
+          "[#{self.collect { |e| e.name.inspect }.join(' ')}]"
+        end
+      end #class RulesArray
+
       # Template of a single rule of autodetection
       class RuleTemplate
         # Creates a new element.
         def self.[](*arg)
           self.new(*arg)
         end
-          
+        
         # Creates a new element.
         def initialize
-          a = Array.new
-          def a.inspect
-            "[#{self.collect { |e| e.name.inspect }.join(' ')}]"
-          end
-          @higher_priority_elements = a.clone
-          @lower_priority_elements  = a.clone
+          @higher_priority_elements = RulesArray.new
+          @lower_priority_elements  = RulesArray.new
           @name = nil
         end
 
@@ -784,6 +834,24 @@ module Bio
         def guess(text, meta)
           nil
         end
+
+        private
+        # Gets constant from constant name given as a string.
+        def str2const(str)
+          const = Object
+          str.split(/\:\:/).each do |x|
+            const = const.const_get(x)
+          end
+          const
+        end
+
+        # Gets database class from given object.
+        # Current implementation is: 
+        # if _obj_ is kind of String, regarded as a constant.
+        # Otherwise, returns _obj_ as is.
+        def get_dbclass(obj)
+          obj.kind_of?(String) ? str2const(obj) : obj
+        end
       end #class Rule_Template
 
       # RuleDebug is a class for debugging autodetect classes/methods
@@ -835,40 +903,49 @@ module Bio
         def initialize(dbclass, re)
           super()
           @re = re
-          @dbclass = dbclass
-          @dbclasses = [ dbclass ]
           @name = dbclass.to_s
+          @dbclass = nil
+          @dbclass_lazy = dbclass
+        end
+
+        # database class (lazy evaluation)
+        def dbclass
+          unless @dbclass
+            @dbclass = get_dbclass(@dbclass_lazy)
+          end
+          @dbclass
+        end
+        private :dbclass
+
+        # returns database classes
+        def dbclasses
+          [ dbclass ]
         end
 
         # If given text matches the regexp, returns the database class.
         # Otherwise, returns nil or false.
         # _meta_ is ignored.
         def guess(text, meta)
-          @re =~ text ? @dbclass : nil
+          @re =~ text ? dbclass : nil
         end
       end #class RuleRegexp
 
       # A autodetection rule to use more than two regular expressions.
-      class RuleRegexp2 < RuleTemplate
+      # If given string matches one of the regular expressions,
+      # returns the database class.
+      class RuleRegexp2 < RuleRegexp
         # Creates a new instance.
         def initialize(dbclass, *regexps)
-          super()
+          super(dbclass, nil)
           @regexps = regexps
-          @dbclass = dbclass
-          @dbclasses = [ dbclass ]
-          if name
-            @name = name
-          else
-            @name = @dbclass.to_s
-          end
         end
 
-        # If given text matches the regexp, returns the database class.
+        # If given text matches one of the regexp, returns the database class.
         # Otherwise, returns nil or false.
         # _meta_ is ignored.
         def guess(text, meta)
           @regexps.each do |re|
-            return @dbclass if re =~ text
+            return dbclass if re =~ text
           end
           nil
         end
@@ -880,10 +957,19 @@ module Bio
         def initialize(*dbclasses, &proc)
           super()
           @proc = proc
-          @dbclasses = dbclasses
+          @dbclasses = nil
+          @dbclasses_lazy = dbclasses
           @name = dbclasses.collect { |x| x.to_s }.join('|')
         end
 
+        # database classes (lazy evaluation)
+        def dbclasses
+          unless @dbclasses
+            @dbclasses = @dbclasses_lazy.collect { |x| get_dbclass(x) }
+          end
+          @dbclasses
+        end
+
         # If given text (and/or meta information) is known, returns
         # the database class.
         # Otherwise, returns nil or false.
@@ -1039,22 +1125,23 @@ module Bio
       # make a default of default autodetect object
       def self.make_default
         a = self[
-          genbank  = RuleRegexp[ Bio::GenBank,
+          genbank  = RuleRegexp[ 'Bio::GenBank',
             /^LOCUS       .+ bp .*[a-z]*[DR]?NA/ ],
-          genpept  = RuleRegexp[ Bio::GenPept,
+          genpept  = RuleRegexp[ 'Bio::GenPept',
             /^LOCUS       .+ aa .+/ ],
-          medline  = RuleRegexp[ Bio::MEDLINE,
+          medline  = RuleRegexp[ 'Bio::MEDLINE',
             /^UI  \- [0-9]+$/ ],
-          embl     = RuleRegexp[ Bio::EMBL,
+          embl     = RuleRegexp[ 'Bio::EMBL',
             /^ID   .+\; .*(DNA|RNA|XXX)\;/ ],
-          sptr     = RuleRegexp[ Bio::SPTR,
-            /^ID   .+\; *PRT\;/ ],
-          prosite  = RuleRegexp[ Bio::PROSITE,
+          sptr     = RuleRegexp2[ 'Bio::SPTR',
+            /^ID   .+\; *PRT\;/,
+            /^ID   [-A-Za-z0-9_\.]+ .+\; *[0-9]+ *AA\./ ],
+          prosite  = RuleRegexp[ 'Bio::PROSITE',
             /^ID   [-A-Za-z0-9_\.]+\; (PATTERN|RULE|MATRIX)\.$/ ],
-          transfac = RuleRegexp[ Bio::TRANSFAC,
+          transfac = RuleRegexp[ 'Bio::TRANSFAC',
             /^AC  [-A-Za-z0-9_\.]+$/ ],
 
-          aaindex  = RuleProc.new(Bio::AAindex1, Bio::AAindex2) do |text|
+          aaindex  = RuleProc.new('Bio::AAindex1', 'Bio::AAindex2') do |text|
             if /^H [-A-Z0-9_\.]+$/ =~ text then
               if text =~ /^M [rc]/ then
                 Bio::AAindex2
@@ -1068,33 +1155,35 @@ module Bio
             end
           end,
 
-          litdb    = RuleRegexp[ Bio::LITDB,
+          litdb    = RuleRegexp[ 'Bio::LITDB',
             /^CODE        [0-9]+$/ ],
-          brite    = RuleRegexp[ Bio::KEGG::BRITE,
+          brite    = RuleRegexp[ 'Bio::KEGG::BRITE',
             /^Entry           [A-Z0-9]+/ ],
-          ko       = RuleRegexp[ Bio::KEGG::KO,
+          orthology = RuleRegexp[ 'Bio::KEGG::ORTHOLOGY',
             /^ENTRY       .+ KO\s*/ ],
-          glycan   = RuleRegexp[ Bio::KEGG::GLYCAN,
+          drug     = RuleRegexp[ 'Bio::KEGG::DRUG',
+            /^ENTRY       .+ Drug\s*/ ],
+          glycan   = RuleRegexp[ 'Bio::KEGG::GLYCAN',
             /^ENTRY       .+ Glycan\s*/ ],
-          enzyme   = RuleRegexp2[ Bio::KEGG::ENZYME,
+          enzyme   = RuleRegexp2[ 'Bio::KEGG::ENZYME',
             /^ENTRY       EC [0-9\.]+$/,
             /^ENTRY       .+ Enzyme\s*/
           ],
-          compound = RuleRegexp2[ Bio::KEGG::COMPOUND,
+          compound = RuleRegexp2[ 'Bio::KEGG::COMPOUND',
             /^ENTRY       C[A-Za-z0-9\._]+$/,
             /^ENTRY       .+ Compound\s*/
           ],
-          reaction = RuleRegexp2[ Bio::KEGG::REACTION,
+          reaction = RuleRegexp2[ 'Bio::KEGG::REACTION',
             /^ENTRY       R[A-Za-z0-9\._]+$/,
             /^ENTRY       .+ Reaction\s*/
           ],
-          genes    = RuleRegexp[ Bio::KEGG::GENES,
-            /^ENTRY       .+ (CDS|gene|.*RNA) / ],
-          genome   = RuleRegexp[ Bio::KEGG::GENOME,
+          genes    = RuleRegexp[ 'Bio::KEGG::GENES',
+            /^ENTRY       .+ (CDS|gene|.*RNA|Contig) / ],
+          genome   = RuleRegexp[ 'Bio::KEGG::GENOME',
             /^ENTRY       [a-z]+$/ ],
 
-          fantom = RuleProc.new(Bio::FANTOM::MaXML::Cluster,
-                                Bio::FANTOM::MaXML::Sequence) do |text|
+          fantom = RuleProc.new('Bio::FANTOM::MaXML::Cluster',
+                                'Bio::FANTOM::MaXML::Sequence') do |text|
             if /\<\!DOCTYPE\s+maxml\-(sequences|clusters)\s+SYSTEM/ =~ text
               case $1
               when 'clusters'
@@ -1109,37 +1198,44 @@ module Bio
             end
           end,
 
-          pdb = RuleRegexp[ Bio::PDB,
+          pdb = RuleRegexp[ 'Bio::PDB',
             /^HEADER    .{40}\d\d\-[A-Z]{3}\-\d\d   [0-9A-Z]{4}/ ],
-          het = RuleRegexp[ Bio::PDB::ChemicalComponent,
+          het = RuleRegexp[ 'Bio::PDB::ChemicalComponent',
             /^RESIDUE +.+ +\d+\s*$/ ],
 
-          clustal = RuleRegexp[ Bio::ClustalW::Report,
-          /^CLUSTAL .*\(.*\).*sequence +alignment/ ],
+          clustal = RuleRegexp2[ 'Bio::ClustalW::Report',
+          /^CLUSTAL .*\(.*\).*sequence +alignment/,
+          /^CLUSTAL FORMAT for T-COFFEE/ ],
+
+          gcg_msf = RuleRegexp[ 'Bio::GCG::Msf',
+          /^!!(N|A)A_MULTIPLE_ALIGNMENT .+/ ],
+
+          gcg_seq = RuleRegexp[ 'Bio::GCG::Seq',
+          /^!!(N|A)A_SEQUENCE .+/ ],
 
-          blastxml = RuleRegexp[ Bio::Blast::Report,
+          blastxml = RuleRegexp[ 'Bio::Blast::Report',
             /\<\!DOCTYPE BlastOutput PUBLIC / ],
-          wublast  = RuleRegexp[ Bio::Blast::WU::Report,
+          wublast  = RuleRegexp[ 'Bio::Blast::WU::Report',
             /^BLAST.? +[\-\.\w]+\-WashU +\[[\-\.\w ]+\]/ ],
-          wutblast = RuleRegexp[ Bio::Blast::WU::Report_TBlast,
+          wutblast = RuleRegexp[ 'Bio::Blast::WU::Report_TBlast',
             /^TBLAST.? +[\-\.\w]+\-WashU +\[[\-\.\w ]+\]/ ],
-          blast    = RuleRegexp[ Bio::Blast::Default::Report,
+          blast    = RuleRegexp[ 'Bio::Blast::Default::Report',
             /^BLAST.? +[\-\.\w]+ +\[[\-\.\w ]+\]/ ],
-          tblast   = RuleRegexp[ Bio::Blast::Default::Report_TBlast,
+          tblast   = RuleRegexp[ 'Bio::Blast::Default::Report_TBlast',
             /^TBLAST.? +[\-\.\w]+ +\[[\-\.\w ]+\]/ ],
 
-          blat   = RuleRegexp[ Bio::Blat::Report,
-            /^psLayout version \d+\s*$/ ],
-          spidey = RuleRegexp[ Bio::Spidey::Report,
+          blat   = RuleRegexp[ 'Bio::Blat::Report',
+            /^psLayout version \d+/ ],
+          spidey = RuleRegexp[ 'Bio::Spidey::Report',
             /^\-\-SPIDEY version .+\-\-$/ ],
-          hmmer  = RuleRegexp[ Bio::HMMER::Report,
+          hmmer  = RuleRegexp[ 'Bio::HMMER::Report',
             /^HMMER +\d+\./ ],
-          sim4   = RuleRegexp[ Bio::Sim4::Report,
+          sim4   = RuleRegexp[ 'Bio::Sim4::Report',
             /^seq1 \= .*\, \d+ bp(\r|\r?\n)seq2 \= .*\, \d+ bp(\r|\r?\n)/ ],
 
-          fastaformat = RuleProc.new(Bio::FastaFormat,
-                                     Bio::NBRF,
-                                     Bio::FastaNumericFormat) do |text|
+          fastaformat = RuleProc.new('Bio::FastaFormat',
+                                     'Bio::NBRF',
+                                     'Bio::FastaNumericFormat') do |text|
             if /^>.+$/ =~ text
               case text
               when /^>([PF]1|[DR][LC]|N[13]|XX)\;.+/
@@ -1167,8 +1263,9 @@ module Bio
         # KEGG
         #aaindex.is_prior_to litdb
         #litdb.is_prior_to brite
-        brite.is_prior_to ko
-        ko.is_prior_to glycan
+        brite.is_prior_to orthology
+        orthology.is_prior_to drug
+        drug.is_prior_to glycan
         glycan.is_prior_to enzyme
         enzyme.is_prior_to compound
         compound.is_prior_to reaction