wwood-bioruby 1.2.11

data/lib/bio/appl/bl2seq/report.rb

@@ -0,0 +1,334 @@
+#
+# = bio/appl/bl2seq/report.rb - bl2seq (BLAST 2 sequences) parser
+# 
+# Copyright:: Copyright (C) 2005 GOTO Naohisa <ng@bioruby.org>
+# License::   The Ruby License
+#
+#  $Id: report.rb,v 1.8 2007/04/05 23:35:39 trevor Exp $
+#
+# Bio::Bl2seq::Report is a NCBI bl2seq (BLAST 2 sequences) output parser.
+#
+# = Acknowledgements
+#
+# Thanks to Tomoaki NISHIYAMA <tomoakin __at__ kenroku.kanazawa-u.ac.jp> 
+# for providing bl2seq parser patches based on
+# lib/bio/appl/blast/format0.rb.
+#
+
+require 'bio/appl/blast/format0'
+
+module Bio
+class Blast
+
+  class Bl2seq
+
+    # Bio::Bl2seq::Report is a NCBI bl2seq (BLAST 2 sequences) output parser.
+    # It inherits Bio::Blast::Default::Report.
+    # Most of its methods are the same as Bio::Blast::Default::Report,
+    # but it lacks many methods.
+    class Report < Bio::Blast::Default::Report
+
+      # Delimiter of each entry. Bio::FlatFile uses it.
+      # In Bio::Bl2seq::Report, it it nil (1 entry 1 file).
+      DELIMITER = RS = nil
+
+      undef format0_parse_header
+      undef program, version, version_number, version_date,
+        message, converged?, reference, db
+
+      # Splits headers.
+      def format0_split_headers(data)
+        @f0query = data.shift
+      end
+      private :format0_split_headers
+
+      # Splits the search results.
+      def format0_split_search(data)
+        iterations = []
+        while r = data[0] and /^\>/ =~ r
+          iterations << Iteration.new(data)
+        end
+        if iterations.size <= 0 then
+          iterations << Iteration.new(data)
+        end
+        iterations
+      end
+      private :format0_split_search
+
+      # Stores format0 database statistics.
+      # Internal use only. Users must not use the class.
+      class F0dbstat < Bio::Blast::Default::Report::F0dbstat #:nodoc:
+        # Returns number of sequences in database.
+        def db_num
+          unless defined?(@db_num)
+            parse_params
+            @db_num = @hash['Number of Sequences'].to_i
+          end
+          @db_num
+        end
+
+        # Returns number of letters in database.
+        def db_len
+          unless defined?(@db_len)
+            parse_params
+            @db_len = @hash['length of database'].to_i
+          end
+          @db_len
+        end
+      end #class F0dbstat
+
+      # Bio::Bl2seq::Report::Iteration stores information about
+      # a iteration.
+      # Normally, it may contain some Bio::Bl2seq::Report::Hit objects.
+      #
+      # Note that its main existance reason is to keep complatibility
+      # between Bio::Blast::Default::Report::* classes.
+      class Iteration < Bio::Blast::Default::Report::Iteration
+        # Creates a new Iteration object.
+        # It is designed to be called only internally from
+        # the Bio::Blast::Default::Report class.
+        # Users shall not use the method directly.
+        def initialize(data)
+          @f0stat = []
+          @f0dbstat = Bio::Blast::Default::Report::AlwaysNil.instance
+          @hits = []
+          @num = 1
+          while r = data[0] and /^\>/ =~ r
+            @hits << Hit.new(data)
+          end
+        end
+
+        # Returns the hits of the iteration.
+        # It returns an array of Bio::Bl2seq::Report::Hit objects.
+        def hits; @hits; end
+
+        undef message, pattern_in_database, 
+          pattern, pattern_positions, hits_found_again,
+          hits_newly_found, hits_for_pattern, parse_hitlist,
+          converged?
+      end #class Iteration
+
+      # Bio::Bl2seq::Report::Hit contains information about a hit.
+      # It may contain some Bio::Blast::Default::Report::HSP objects.
+      # All methods are the same as Bio::Blast::Default::Report::Hit class.
+      # Please refer to Bio::Blast::Default::Report::Hit.
+      class Hit < Bio::Blast::Default::Report::Hit
+      end #class Hit
+
+      # Bio::Bl2seq::Report::HSP holds information about the hsp
+      # (high-scoring segment pair).
+      # NOTE that the HSP class below is NOT used because
+      # Ruby's constants namespace are normally statically determined
+      # and HSP object is created in Bio::Blast::Default::Report::Hit class.
+      # Please refer to Bio::Blast::Default::Report::HSP.
+      class HSP < Bio::Blast::Default::Report::HSP
+      end #class HSP
+
+    end #class Report
+  end #class Bl2seq
+
+end #class Blast
+end #module Bio
+
+######################################################################
+
+if __FILE__ == $0
+
+  Bio::FlatFile.open(Bio::Blast::Bl2seq::Report, ARGF) do |ff|
+  ff.each do |rep|
+
+  print "# === Bio::Blast::Bl2seq::Report\n"
+  puts
+  #@#print "  rep.program           #=> "; p rep.program
+  #@#print "  rep.version           #=> "; p rep.version
+  #@#print "  rep.reference         #=> "; p rep.reference
+  #@#print "  rep.db                #=> "; p rep.db
+  #print "  rep.query_id          #=> "; p rep.query_id
+  print "  rep.query_def         #=> "; p rep.query_def
+  print "  rep.query_len         #=> "; p rep.query_len
+  #puts
+  #@#print "  rep.version_number    #=> "; p rep.version_number
+  #@#print "  rep.version_date      #=> "; p rep.version_date
+  puts
+
+  print "# === Parameters\n"
+  #puts
+  #print "  rep.parameters        #=> "; p rep.parameters
+  puts
+  print "  rep.matrix            #=> "; p rep.matrix
+  print "  rep.expect            #=> "; p rep.expect
+  #print "  rep.inclusion         #=> "; p rep.inclusion
+  print "  rep.sc_match          #=> "; p rep.sc_match
+  print "  rep.sc_mismatch       #=> "; p rep.sc_mismatch
+  print "  rep.gap_open          #=> "; p rep.gap_open
+  print "  rep.gap_extend        #=> "; p rep.gap_extend
+  #print "  rep.filter            #=> "; p rep.filter
+  #@#print "  rep.pattern           #=> "; p rep.pattern
+  #print "  rep.entrez_query      #=> "; p rep.entrez_query
+  #puts
+  #@#print "  rep.pattern_positions  #=> "; p rep.pattern_positions
+  puts
+
+  print "# === Statistics (last iteration's)\n"
+  #puts
+  #print "  rep.statistics        #=> "; p rep.statistics
+  puts
+  print "  rep.db_num            #=> "; p rep.db_num
+  print "  rep.db_len            #=> "; p rep.db_len
+  #print "  rep.hsp_len           #=> "; p rep.hsp_len
+  print "  rep.eff_space         #=> "; p rep.eff_space
+  print "  rep.kappa             #=> "; p rep.kappa
+  print "  rep.lambda            #=> "; p rep.lambda
+  print "  rep.entropy           #=> "; p rep.entropy
+  puts
+  print "  rep.num_hits          #=> "; p rep.num_hits
+  print "  rep.gapped_kappa      #=> "; p rep.gapped_kappa
+  print "  rep.gapped_lambda     #=> "; p rep.gapped_lambda
+  print "  rep.gapped_entropy    #=> "; p rep.gapped_entropy
+  print "  rep.posted_date       #=> "; p rep.posted_date
+  puts
+
+  #@#print "# === Message (last iteration's)\n"
+  #@#puts
+  #@#print "  rep.message           #=> "; p rep.message
+  #puts
+  #@#print "  rep.converged?        #=> "; p rep.converged?
+  #@#puts
+
+  print "# === Iterations\n"
+  puts
+  print "  rep.itrerations.each do |itr|\n"
+  puts
+
+  rep.iterations.each do |itr|
+      
+  print "# --- Bio::Blast::Bl2seq::Report::Iteration\n"
+  puts
+
+  print "    itr.num             #=> "; p itr.num
+  #print "    itr.statistics      #=> "; p itr.statistics
+  #@#print "    itr.message         #=> "; p itr.message
+  print "    itr.hits.size       #=> "; p itr.hits.size
+  #puts
+  #@#print "    itr.hits_newly_found.size    #=> "; p itr.hits_newly_found.size;
+  #@#print "    itr.hits_found_again.size    #=> "; p itr.hits_found_again.size;
+  #@#if itr.hits_for_pattern then
+  #@#itr.hits_for_pattern.each_with_index do |hp, hpi|
+  #@#print "    itr.hits_for_pattern[#{hpi}].size #=> "; p hp.size;
+  #@#end
+  #@#end
+  #@#print "    itr.converged?      #=> "; p itr.converged?
+  puts
+
+  print "    itr.hits.each do |hit|\n"
+  puts
+
+  itr.hits.each_with_index do |hit, i|
+
+  print "# --- Bio::Blast::Bl2seq::Default::Report::Hit"
+  print " ([#{i}])\n"
+  puts
+
+  #print "      hit.num           #=> "; p hit.num
+  #print "      hit.hit_id        #=> "; p hit.hit_id
+  print "      hit.len           #=> "; p hit.len
+  print "      hit.definition    #=> "; p hit.definition
+  #print "      hit.accession     #=> "; p hit.accession
+  #puts
+  print "      hit.found_again?  #=> "; p hit.found_again?
+
+  print "        --- compatible/shortcut ---\n"
+  #print "      hit.query_id      #=> "; p hit.query_id
+  #print "      hit.query_def     #=> "; p hit.query_def
+  #print "      hit.query_len     #=> "; p hit.query_len
+  #print "      hit.target_id     #=> "; p hit.target_id
+  print "      hit.target_def    #=> "; p hit.target_def
+  print "      hit.target_len    #=> "; p hit.target_len
+
+  print "            --- first HSP's values (shortcut) ---\n"
+  print "      hit.evalue        #=> "; p hit.evalue
+  print "      hit.bit_score     #=> "; p hit.bit_score
+  print "      hit.identity      #=> "; p hit.identity
+  #print "      hit.overlap       #=> "; p hit.overlap
+
+  print "      hit.query_seq     #=> "; p hit.query_seq
+  print "      hit.midline       #=> "; p hit.midline
+  print "      hit.target_seq    #=> "; p hit.target_seq
+
+  print "      hit.query_start   #=> "; p hit.query_start
+  print "      hit.query_end     #=> "; p hit.query_end
+  print "      hit.target_start  #=> "; p hit.target_start
+  print "      hit.target_end    #=> "; p hit.target_end
+  print "      hit.lap_at        #=> "; p hit.lap_at
+  print "            --- first HSP's vaules (shortcut) ---\n"
+  print "        --- compatible/shortcut ---\n"
+
+  puts
+  print "      hit.hsps.size     #=> "; p hit.hsps.size
+  if hit.hsps.size == 0 then
+  puts  "          (HSP not found: please see blastall's -b and -v options)"
+  puts
+  else
+
+  puts
+  print "      hit.hsps.each do |hsp|\n"
+  puts
+
+  hit.hsps.each_with_index do |hsp, j|
+
+  print "# --- Bio::Blast::Default::Report::HSP (Bio::Blast::Bl2seq::Report::HSP)"
+  print " ([#{j}])\n"
+  puts
+  #print "        hsp.num         #=> "; p hsp.num
+  print "        hsp.bit_score   #=> "; p hsp.bit_score 
+  print "        hsp.score       #=> "; p hsp.score
+  print "        hsp.evalue      #=> "; p hsp.evalue
+  print "        hsp.identity    #=> "; p hsp.identity
+  print "        hsp.gaps        #=> "; p hsp.gaps
+  print "        hsp.positive    #=> "; p hsp.positive
+  print "        hsp.align_len   #=> "; p hsp.align_len
+  #print "        hsp.density     #=> "; p hsp.density
+
+  print "        hsp.query_frame #=> "; p hsp.query_frame
+  print "        hsp.query_from  #=> "; p hsp.query_from
+  print "        hsp.query_to    #=> "; p hsp.query_to
+
+  print "        hsp.hit_frame   #=> "; p hsp.hit_frame
+  print "        hsp.hit_from    #=> "; p hsp.hit_from
+  print "        hsp.hit_to      #=> "; p hsp.hit_to
+
+  #print "        hsp.pattern_from#=> "; p hsp.pattern_from
+  #print "        hsp.pattern_to  #=> "; p hsp.pattern_to
+
+  print "        hsp.qseq        #=> "; p hsp.qseq
+  print "        hsp.midline     #=> "; p hsp.midline
+  print "        hsp.hseq        #=> "; p hsp.hseq
+  puts
+  print "        hsp.percent_identity  #=> "; p hsp.percent_identity
+  #print "        hsp.mismatch_count    #=> "; p hsp.mismatch_count
+  #
+  print "        hsp.query_strand      #=> "; p hsp.query_strand
+  print "        hsp.hit_strand        #=> "; p hsp.hit_strand
+  print "        hsp.percent_positive  #=> "; p hsp.percent_positive
+  print "        hsp.percent_gaps      #=> "; p hsp.percent_gaps
+  puts
+
+  end #each
+  end #if hit.hsps.size == 0
+  end
+  end
+  end #ff.each
+  end #FlatFile.open
+
+end #if __FILE__ == $0
+
+######################################################################
+
+=begin
+
+= Bio::Blast::Bl2seq::Report
+
+    NCBI bl2seq (BLAST 2 sequences) output parser
+
+=end
+

data/lib/bio/appl/blast.rb

@@ -0,0 +1,505 @@
+#
+# = bio/appl/blast.rb - BLAST wrapper
+# 
+# Copyright::  Copyright (C) 2001,2008  Mitsuteru C. Nakao <n@bioruby.org>
+# Copyright::  Copyright (C) 2002,2003  Toshiaki Katayama <k@bioruby.org>
+# Copyright::  Copyright (C) 2006       Jan Aerts <jan.aerts@bbsrc.ac.uk>
+# Copyright::  Copyright (C) 2008       Naohisa Goto <ng@bioruby.org>
+# License::    The Ruby License
+#
+# $Id:$
+#
+
+require 'bio/command'
+require 'shellwords'
+require 'stringio'
+require 'bio/io/flatfile'
+
+module Bio
+
+  # == Description
+  # 
+  # The Bio::Blast class contains methods for running local or remote BLAST
+  # searches, as well as for parsing of the output of such BLASTs (i.e. the
+  # BLAST reports). For more information on similarity searches and the BLAST
+  # program, see http://www.ncbi.nlm.nih.gov/Education/BLASTinfo/similarity.html.
+  #
+  # == Usage
+  #
+  #   require 'bio'
+  #   
+  #   # To run an actual BLAST analysis:
+  #   #   1. create a BLAST factory
+  #   remote_blast_factory = Bio::Blast.remote('blastp', 'SWISS',
+  #                                            '-e 0.0001', 'genomenet')
+  #   #or:
+  #   local_blast_factory = Bio::Blast.local('blastn','/path/to/db')
+  #
+  #   #   2. run the actual BLAST by querying the factory
+  #   report = remote_blast_factory.query(sequence_text)
+  #
+  #   # Then, to parse the report, see Bio::Blast::Report
+  #
+  # == See also
+  #
+  # * Bio::Blast::Report
+  # * Bio::Blast::Report::Hit
+  # * Bio::Blast::Report::Hsp
+  #
+  # == References
+  # 
+  # * http://www.ncbi.nlm.nih.gov/blast/
+  # * http://www.ncbi.nlm.nih.gov/Education/BLASTinfo/similarity.html
+  # * http://blast.genome.jp/ideas/ideas.html#blast
+  #
+  class Blast
+
+    autoload :Fastacmd,     'bio/io/fastacmd'
+    autoload :Report,       'bio/appl/blast/report'
+    autoload :Report_tab,   'bio/appl/blast/report'
+    autoload :Default,      'bio/appl/blast/format0'
+    autoload :WU,           'bio/appl/blast/wublast'
+    autoload :Bl2seq,       'bio/appl/bl2seq/report'
+    autoload :RPSBlast,     'bio/appl/blast/rpsblast'
+    autoload :NCBIOptions,  'bio/appl/blast/ncbioptions'
+    autoload :Remote,       'bio/appl/blast/remote'
+
+    # This is a shortcut for Bio::Blast.new:
+    #  Bio::Blast.local(program, database, options)
+    # is equivalent to
+    #  Bio::Blast.new(program, database, options, 'local')
+    # ---
+    # *Arguments*:
+    # * _program_ (required): 'blastn', 'blastp', 'blastx', 'tblastn' or 'tblastx'
+    # * _db_ (required): name of the local database
+    # * _options_: blastall options \
+    # (see http://www.genome.jp/dbget-bin/show_man?blast2)
+    # * _blastall_: full path to blastall program (e.g. "/opt/bin/blastall"; DEFAULT: "blastall")
+    # *Returns*:: Bio::Blast factory object
+    def self.local(program, db, options = '', blastall = nil)
+      f = self.new(program, db, options, 'local')
+      if blastall then
+        f.blastall = blastall
+      end
+      f
+    end
+
+    # Bio::Blast.remote does exactly the same as Bio::Blast.new, but sets
+    # the remote server 'genomenet' as its default.
+    # ---
+    # *Arguments*:
+    # * _program_ (required): 'blastn', 'blastp', 'blastx', 'tblastn' or 'tblastx'
+    # * _db_ (required): name of the remote database
+    # * _options_: blastall options \
+    # (see http://www.genome.jp/dbget-bin/show_man?blast2)
+    # * _server_: server to use (DEFAULT = 'genomenet')
+    # *Returns*:: Bio::Blast factory object
+    def self.remote(program, db, option = '', server = 'genomenet')
+      self.new(program, db, option, server)
+    end
+
+ 
+    # Bio::Blast.report parses given data, 
+    # and returns an array of report 
+    # (Bio::Blast::Report or Bio::Blast::Default::Report) objects,
+    # or yields each report object when a block is given.
+    #
+    # Supported formats: NCBI default (-m 0), XML (-m 7), tabular (-m 8).
+    #
+    # ---
+    # *Arguments*:
+    # * _input_ (required): input data
+    # * _parser_: type of parser. see Bio::Blast::Report.new
+    # *Returns*:: Undefiend when a block is given. Otherwise, an Array containing report (Bio::Blast::Report or Bio::Blast::Default::Report) objects.
+    def self.reports(input, parser = nil)
+      begin
+        istr = input.to_str
+      rescue NoMethodError
+        istr = nil
+      end
+      if istr then
+        input = StringIO.new(istr)
+      end
+      raise 'unsupported input data type' unless input.respond_to?(:gets)
+
+      # if proper parser is given, emulates old behavior.
+      case parser
+      when :xmlparser, :rexml
+        ff = Bio::FlatFile.new(Bio::Blast::Report, input)
+        if block_given? then
+          ff.each do |e|
+            yield e
+          end
+          return []
+        else
+          return ff.to_a
+        end
+      when :tab
+        istr = input.read unless istr
+        rep = Report.new(istr, parser)
+        if block_given? then
+          yield rep
+          return []
+        else
+          return [ rep ]
+        end
+      end
+
+      # preparation of the new format autodetection rule if needed
+      if !defined?(@@reports_format_autodetection_rule) or
+          !@@reports_format_autodetection_rule then
+        regrule = Bio::FlatFile::AutoDetect::RuleRegexp
+        blastxml = regrule[ 'Bio::Blast::Report',
+                            /\<\!DOCTYPE BlastOutput PUBLIC / ]
+        blast    = regrule[ 'Bio::Blast::Default::Report',
+                            /^BLAST.? +[\-\.\w]+ +\[[\-\.\w ]+\]/ ]
+        tblast   = regrule[ 'Bio::Blast::Default::Report_TBlast',
+                            /^TBLAST.? +[\-\.\w]+ +\[[\-\.\w ]+\]/ ]
+        tab      = regrule[ 'Bio::Blast::Report_tab',
+                            /^([^\t]*\t){11}[^\t]*$/ ]
+        auto = Bio::FlatFile::AutoDetect[ blastxml,
+                                          blast,
+                                          tblast,
+                                          tab
+                                        ]
+        # sets priorities
+        blastxml.is_prior_to blast
+        blast.is_prior_to tblast
+        tblast.is_prior_to tab
+        # rehash
+        auto.rehash
+        @@report_format_autodetection_rule = auto
+      end
+
+      # Creates a FlatFile object with dummy class
+      ff = Bio::FlatFile.new(Object, input)
+      ff.dbclass = nil
+
+      # file format autodetection
+      3.times do
+        break if ff.eof? or
+          ff.autodetect(31, @@report_format_autodetection_rule)
+      end
+      # If format detection failed, assumed to be tabular (-m 8)
+      ff.dbclass = Bio::Blast::Report_tab unless ff.dbclass
+
+      if block_given? then
+        ff.each do |entry|
+          yield entry
+        end
+        ret = []
+      else
+        ret = ff.to_a
+      end
+      ret
+    end
+
+    #--
+    # the method Bio::Blast.reports is moved from bio/appl/blast/report.rb.
+    #++
+     
+    # Note that this is the old implementation of Bio::Blast.reports.
+    # The aim of this method is keeping compatibility for older BLAST
+    # XML documents which might not be parsed by the new
+    # Bio::Blast.reports nor Bio::FlatFile.
+    # (Though we are not sure whether such documents exist or not.)
+    #
+    # Bio::Blast.reports_xml parses given data, 
+    # and returns an array of Bio::Blast::Report objects, or
+    # yields each Bio::Blast::Report object when a block is given.
+    #
+    # It can be used only for XML format.
+    # For default (-m 0) format, consider using Bio::FlatFile, or
+    # Bio::Blast.reports.
+    #
+    # ---
+    # *Arguments*:
+    # * _input_ (required): input data
+    # * _parser_: type of parser. see Bio::Blast::Report.new
+    # *Returns*:: Undefiend when a block is given. Otherwise, an Array containing Bio::Blast::Report objects.
+    def self.reports_xml(input, parser = nil)
+      ary = []
+      input.each_line("</BlastOutput>\n") do |xml|
+        xml.sub!(/[^<]*(<?)/, '\1') # skip before <?xml> tag
+        next if xml.empty?          # skip trailing no hits
+        rep = Report.new(xml, parser)
+        if rep.reports then
+          if block_given?
+            rep.reports.each { |r| yield r }
+          else
+            ary.concat rep.reports
+          end
+        else
+          if block_given?
+            yield rep
+          else
+            ary.push rep
+          end
+        end
+      end
+      return ary
+    end
+
+
+    # Program name (_-p_ option for blastall): blastp, blastn, blastx, tblastn
+    # or tblastx
+    attr_accessor :program
+
+    # Database name (_-d_ option for blastall)
+    attr_accessor :db
+    
+    # Options for blastall
+    attr_reader :options
+
+    # Sets options for blastall
+    def options=(ary)
+      @options = set_options(ary)
+    end
+
+    # Server to submit the BLASTs to
+    attr_accessor :server
+
+    # Sets server to submit the BLASTs to.
+    # The exec_xxxx method should be defined in Bio::Blast or
+    # Bio::Blast::Remote::Xxxx class.
+    def server=(str)
+      @server = str
+      begin
+        m = Bio::Blast::Remote.const_get(@server.capitalize)
+      rescue NameError
+        m = nil
+      end
+      if m and !(self.is_a?(m)) then
+        # lazy include Bio::Blast::Remote::XXX module
+        self.class.class_eval { include m }
+      end
+      return @server
+    end
+
+    # Full path for blastall. (default: 'blastall').
+    attr_accessor :blastall
+
+    # Substitution matrix for blastall -M
+    attr_accessor :matrix
+
+    # Filter option for blastall -F (T or F).
+    attr_accessor :filter
+
+    # Returns a String containing blast execution output in as is the Bio::Blast#format.
+    attr_reader :output
+
+    # Output report format for blastall -m 
+    #
+    # 0, pairwise; 1; 2; 3; 4; 5; 6; 7, XML Blast outpu;, 8, tabular; 
+    # 9, tabular with comment lines; 10, ASN text; 11, ASN binery [intege].
+    attr_accessor :format
+
+    #
+    attr_writer :parser  # to change :xmlparser, :rexml, :tab
+
+
+    # Creates a Bio::Blast factory object.
+    # 
+    # To run any BLAST searches, a factory has to be created that describes a
+    # certain BLAST pipeline: the program to use, the database to search, any
+    # options and the server to use. E.g.
+    # 
+    #   blast_factory = Bio::Blast.new('blastn','dbsts', '-e 0.0001 -r 4', 'genomenet')
+    # 
+    # ---
+    # *Arguments*:
+    # * _program_ (required): 'blastn', 'blastp', 'blastx', 'tblastn' or 'tblastx'
+    # * _db_ (required): name of the (local or remote) database
+    # * _options_: blastall options \
+    # (see http://www.genome.jp/dbget-bin/show_man?blast2)
+    # * _server_: server to use (e.g. 'genomenet'; DEFAULT = 'local')
+    # *Returns*:: Bio::Blast factory object
+    def initialize(program, db, opt = [], server = 'local')
+      @program  = program
+      @db       = db
+
+      @blastall = 'blastall'
+      @matrix   = nil
+      @filter   = nil
+
+      @output   = ''
+      @parser   = nil
+      @format   = nil
+
+      @options = set_options(opt, program, db)
+      self.server = server
+    end
+
+
+    # This method submits a sequence to a BLAST factory, which performs the
+    # actual BLAST.
+    # 
+    #   # example 1
+    #   seq = Bio::Sequence::NA.new('agggcattgccccggaagatcaagtcgtgctcctg')
+    #   report = blast_factory.query(seq)
+    #
+    #   # example 2
+    #   str <<END_OF_FASTA
+    #   >lcl|MySequence
+    #   MPPSAISKISNSTTPQVQSSSAPNLTMLEGKGISVEKSFRVYSEEENQNQHKAKDSLGF
+    #   KELEKDAIKNSKQDKKDHKNWLETLYDQAEQKWLQEPKKKLQDLIKNSGDNSRVILKDS
+    #   END_OF_FASTA
+    #   report = blast_factory.query(str)
+    #
+    # Bug note: When multi-FASTA is given and the format is 7 (XML) or 8 (tab),
+    # it should return an array of Bio::Blast::Report objects,
+    # but it returns a single Bio::Blast::Report object.
+    # This is a known bug and should be fixed in the future.
+    # 
+    # ---
+    # *Arguments*:
+    # * _query_ (required): single- or multiple-FASTA formatted sequence(s)
+    # *Returns*:: a Bio::Blast::Report (or Bio::Blast::Default::Report) object when single query is given. When multiple sequences are given as the query, it returns an array of Bio::Blast::Report (or Bio::Blast::Default::Report) objects. If it can not parse result, nil will be returnd.
+    def query(query)
+      case query
+      when Bio::Sequence
+        query = query.output(:fasta)
+      when Bio::Sequence::NA, Bio::Sequence::AA, Bio::Sequence::Generic
+        query = query.to_fasta('query', 70)
+      else
+        query = query.to_s
+      end
+
+      @output = self.__send__("exec_#{@server}", query)
+      report = parse_result(@output)
+      return report
+    end
+
+    # Returns options of blastall
+    def option
+      # backward compatibility
+      Bio::Command.make_command_line(options)
+    end
+
+    # Set options for blastall
+    def option=(str)
+      # backward compatibility
+      self.options = Shellwords.shellwords(str)
+    end
+
+    private
+
+    def set_options(opt = nil, program = nil, db = nil)
+      opt = @options unless opt
+
+      # when opt is a String, splits to an array
+      begin
+        a = opt.to_ary
+      rescue NameError #NoMethodError
+        # backward compatibility
+        a = Shellwords.shellwords(opt)
+      end
+      ncbiopt = NCBIOptions.new(a)
+
+      if fmt = ncbiopt.get('-m') then
+        @format = fmt.to_i
+      else
+        Bio::Blast::Report #dummy to load XMLParser or REXML
+        if defined?(XMLParser) or defined?(REXML)
+          @format ||= 7
+        else
+          @format ||= 8
+        end
+      end
+
+      mtrx = ncbiopt.get('-M')
+      @matrix = mtrx if mtrx
+      fltr = ncbiopt.get('-F')
+      @filter = fltr if fltr
+
+      # special treatment for '-p'
+      if program then
+        @program = program
+        ncbiopt.delete('-p')
+      else
+        program = ncbiopt.get('-p')
+        @program = program if program
+      end
+
+      # special treatment for '-d'
+      if db then
+        @db = db
+        ncbiopt.delete('-d')
+      else
+        db = ncbiopt.get('-d')
+        @db = db if db
+      end
+
+      # returns an array of string containing options
+      return ncbiopt.options
+    end
+
+    # parses result
+    def parse_result(str)
+      if @format.to_i == 0 then
+        ary = Bio::FlatFile.open(Bio::Blast::Default::Report,
+                                 StringIO.new(str)) { |ff| ff.to_a }
+        case ary.size
+        when 0
+          return nil
+        when 1
+          return ary[0]
+        else
+          return ary
+        end
+      else
+        Report.new(str, @parser)
+      end
+    end
+
+    # returns an array containing NCBI BLAST options
+    def make_command_line_options
+      set_options
+      cmd = []
+      if @program
+        cmd.concat([ '-p', @program ])
+      end
+      if @db
+        cmd.concat([ '-d', @db ])
+      end
+      if @format
+        cmd.concat([ '-m', @format.to_s ])
+      end
+      if @matrix
+        cmd.concat([ '-M', @matrix ]) 
+      end
+      if @filter
+        cmd.concat([ '-F', @filter ]) 
+      end
+      ncbiopts = NCBIOptions.new(@options)
+      ncbiopts.make_command_line_options(cmd)
+    end
+
+    # makes command line.
+    def make_command_line
+      cmd = make_command_line_options
+      cmd.unshift @blastall
+      cmd
+    end
+
+    # Local execution of blastall
+    def exec_local(query)
+      cmd = make_command_line
+      @output = Bio::Command.query_command(cmd, query)
+      return @output
+    end
+
+    # This method is obsolete.
+    #
+    # Runs genomenet with '-m 8' option.
+    # Note that the format option is overwritten.
+    def exec_genomenet_tab(query)
+      warn "Bio::Blast#server=\"genomenet_tab\" is deprecated."
+      @format = 8
+      exec_genomenet(query)
+    end
+
+  end # class Blast
+
+end # module Bio
+