wwood-bioruby 1.2.11

data/lib/bio/appl/blast/rexml.rb

@@ -0,0 +1,144 @@
+#
+# = bio/appl/blast/rexml.rb - BLAST XML output (-m 7) parser by REXML
+# 
+# Copyright::  Copyright (C) 2002, 2003 Toshiaki Katayama <k@bioruby.org>
+# License::    The Ruby License
+#
+# $Id:$
+#
+# == Note
+# 
+# This file is automatically loaded by bio/appl/blast/report.rb
+# 
+
+begin
+  require 'rexml/document'
+rescue LoadError
+end
+
+module Bio
+  class Blast
+    class Report
+
+      private
+
+      def rexml_parse(xml)
+        dom = REXML::Document.new(xml)
+        rexml_parse_program(dom)
+        dom.elements.each("*//Iteration") do |e|
+          @iterations.push(rexml_parse_iteration(e))
+        end
+      end
+
+      def rexml_parse_program(dom)
+        hash = {}
+        dom.root.each_element_with_text do |e|
+          name, text = e.name, e.text
+          case name
+          when 'BlastOutput_param'
+            e.elements["Parameters"].each_element_with_text do |p|
+              xml_set_parameter(p.name, p.text)
+            end
+          else
+            hash[name] = text if text.strip.size > 0
+          end
+        end
+        @program	= hash['BlastOutput_program']
+        @version	= hash['BlastOutput_version']
+        @reference	= hash['BlastOutput_reference']
+        @db		= hash['BlastOutput_db']
+        @query_id	= hash['BlastOutput_query-ID']
+        @query_def	= hash['BlastOutput_query-def']
+        @query_len	= hash['BlastOutput_query-len'].to_i
+      end
+
+      def rexml_parse_iteration(e)
+        iteration = Iteration.new
+        e.elements.each do |i|
+          case i.name
+          when 'Iteration_iter-num'
+            iteration.num = i.text.to_i
+          when 'Iteration_hits'
+            i.elements.each("Hit") do |h|
+              iteration.hits.push(rexml_parse_hit(h))
+            end
+          when 'Iteration_message'
+            iteration.message = i.text
+          when 'Iteration_stat'
+            i.elements["Statistics"].each_element_with_text do |s|
+              k = s.name.sub(/Statistics_/, '')
+              v = s.text =~ /\D/ ? s.text.to_f : s.text.to_i
+              iteration.statistics[k] = v
+            end
+
+          # for new BLAST XML format
+          when 'Iteration_query-ID'
+            iteration.query_id = i.text
+          when 'Iteration_query-def'
+            iteration.query_def = i.text
+          when 'Iteration_query-len'
+            iteration.query_len = i.text.to_i
+          end
+        end #case i.name
+
+        return iteration
+      end
+
+      def rexml_parse_hit(e)
+        hit = Hit.new
+        hash = {}
+        hit.query_id = @query_id
+        hit.query_def = @query_def
+        hit.query_len = @query_len
+        e.elements.each do |h|
+          case h.name
+          when 'Hit_hsps'
+            h.elements.each("Hsp") do |s|
+              hit.hsps.push(rexml_parse_hsp(s))
+            end
+          else
+            hash[h.name] = h.text
+          end
+        end
+        hit.num		= hash['Hit_num'].to_i
+        hit.hit_id	= hash['Hit_id']
+        hit.len		= hash['Hit_len'].to_i
+        hit.definition	= hash['Hit_def']
+        hit.accession	= hash['Hit_accession']
+        return hit
+      end
+
+      def rexml_parse_hsp(e)
+        hsp = Hsp.new
+        hash = {}
+        e.each_element_with_text do |h|
+          hash[h.name] = h.text
+        end
+        hsp.num			= hash['Hsp_num'].to_i
+        hsp.bit_score		= hash['Hsp_bit-score'].to_f
+        hsp.score		= hash['Hsp_score'].to_i
+        hsp.evalue		= hash['Hsp_evalue'].to_f
+        hsp.query_from		= hash['Hsp_query-from'].to_i
+        hsp.query_to		= hash['Hsp_query-to'].to_i
+        hsp.hit_from		= hash['Hsp_hit-from'].to_i
+        hsp.hit_to		= hash['Hsp_hit-to'].to_i
+        hsp.pattern_from	= hash['Hsp_pattern-from'].to_i
+        hsp.pattern_to		= hash['Hsp_pattern-to'].to_i
+        hsp.query_frame		= hash['Hsp_query-frame'].to_i
+        hsp.hit_frame		= hash['Hsp_hit-frame'].to_i
+        hsp.identity		= hash['Hsp_identity'].to_i
+        hsp.positive		= hash['Hsp_positive'].to_i
+        hsp.gaps		= hash['Hsp_gaps'].to_i
+        hsp.align_len		= hash['Hsp_align-len'].to_i
+        hsp.density		= hash['Hsp_density'].to_i
+        hsp.qseq		= hash['Hsp_qseq']
+        hsp.hseq		= hash['Hsp_hseq']
+        hsp.midline		= hash['Hsp_midline']
+        return hsp
+      end
+
+    end
+  end
+end
+
+

data/lib/bio/appl/blast/rpsblast.rb

@@ -0,0 +1,277 @@
+#
+# = bio/appl/blast/rpsblast.rb - NCBI RPS Blast default output parser
+# 
+# Copyright::  Copyright (C) 2008 Naohisa Goto <ng@bioruby.org>
+# License::    The Ruby License
+#
+# $Id:$
+#
+# == Description
+#
+# NCBI RPS Blast (Reversed Position Specific Blast) default
+# (-m 0 option) output parser class, Bio::Blast::RPSBlast::Report
+# and related classes/modules.
+#
+# == References
+#
+# * Altschul, Stephen F., Thomas L. Madden, Alejandro A. Schaffer,
+#   Jinghui Zhang, Zheng Zhang, Webb Miller, and David J. Lipman (1997),
+#   "Gapped BLAST and PSI-BLAST: a new generation of protein database search
+#   programs", Nucleic Acids Res. 25:3389-3402.
+# * ftp://ftp.ncbi.nih.gov/blast/documents/rpsblast.html
+# * http://www.ncbi.nlm.nih.gov/Structure/cdd/cdd_help.shtml
+#
+
+require 'bio/appl/blast/format0'
+require 'bio/io/flatfile'
+
+module Bio
+class Blast
+
+  # NCBI RPS Blast (Reversed Position Specific Blast) namespace.
+  # Currently, this module is existing only for separating namespace.
+  # To parse RPSBlast results, see Bio::Blast::RPSBlast::Report documents.
+  module RPSBlast
+
+    # Flatfile splitter for RPS-BLAST reports.
+    # It is internally used when reading RPS-BLAST report.
+    # Normally, users do not need to use it directly.
+    #
+    # Note for Windows: RPS-BLAST results generated in Microsoft Windows
+    # may not be parsed correctly due to the line feed code problem.
+    # For a workaroud, convert line feed codes from Windows(DOS) to UNIX.
+    #
+    class RPSBlastSplitter < Bio::FlatFile::Splitter::Template
+
+      # Separator used to distinguish start of each report
+      ReportHead =  /\A\n*(RPS\-BLAST|Query\=)/
+        
+      # Delimiter used for IO#gets
+      Delimiter = "\n\n"
+
+      # creates a new splitter object
+      def initialize(klass, bstream)
+        super(klass, bstream)
+        @entry_head = nil
+      end
+
+      # Skips leader of the entry.
+      # In this class, only skips space characters.
+      def skip_leader
+        stream.skip_spaces
+        return nil
+      end
+
+      # Rewinds the stream
+      def rewind
+        @entry_head = nil
+        super
+      end
+        
+      # gets an entry
+      def get_entry
+        p0 = stream_pos()
+        pieces = []
+        flag_head = false # reached to start of header
+        flag_body = false # reached to start of body (Query=...)
+        while x = stream.gets(Delimiter)
+          if ReportHead =~ x then
+            case $1
+            when 'RPS-BLAST'
+              if pieces.empty? then
+                @entry_head = nil
+                flag_head = true
+              else
+                stream.ungets(x)
+                break
+              end
+            when 'Query='
+              if flag_body then
+                stream.ungets(x)
+                break
+              else
+                @entry_head = pieces.join('') if flag_head
+                flag_body = true
+              end
+            else
+              raise 'Bug: should not reach here'
+            end
+          end #if ReportHead...
+          pieces.push x
+        end #while
+        p1 = stream_pos()
+
+        self.entry_start_pos = p0
+        self.entry = 
+          if pieces.empty? then
+            nil
+          elsif !flag_head and @entry_head then
+            @entry_head + pieces.join('')
+          else
+            pieces.join('')
+          end
+        self.entry_ended_pos = p1
+        return self.entry
+      end
+    end #class RPSBlastSplitter
+
+    # NCBI RPS Blast (Reversed Position Specific Blast)
+    # default output parser.
+    #
+    # It supports defalut (-m 0 option) output of the "rpsblast" command.
+    #
+    # Because this class inherits Bio::Blast::Default::Report,
+    # almost all methods are eqaul to Bio::Blast::Default::Report.
+    # Only DELIMITER (and RS) and few methods are different.
+    #
+    # By using Bio::FlatFile, (for example, Bio::FlatFile.open),
+    # rpsblast result generated from multiple query sequences is
+    # automatically splitted into multiple 
+    # Bio::BLast::RPSBlast::Report objects corresponding to
+    # query sequences.
+    #
+    # Note for multi-fasta results WITH using Bio::FlatFile:
+    # Each splitted result is concatenated with header of the
+    # result which describes RPS-BLAST version and database
+    # information, if possible.
+    #
+    # Note for multi-fasta results WITHOUT using Bio::FlatFile:
+    # When parsing an output of rpsblast command running with
+    # multi-fasta sequences WITHOUT using Bio::FlatFile,
+    # each query's result is stored as an "iteration" of PSI-Blast.
+    # This behavior may be changed in the future.
+    #
+    # Note for nucleotide results: This class is not tested with
+    # nucleotide query and/or nucleotide databases.
+    #
+    class Report < Bio::Blast::Default::Report
+      # Delimter of each entry for RPS-BLAST.
+      DELIMITER = RS = "\nRPS-BLAST"
+
+      # (Integer) excess read size included in DELIMITER.
+      DELIMITER_OVERRUN = 9 # "RPS-BLAST"
+
+      # splitter for Bio::FlatFile support
+      FLATFILE_SPLITTER = RPSBlastSplitter
+
+      # Creates a new Report object from a string.
+      #
+      # Using Bio::FlatFile.open (or some other methods)
+      # is recommended instead of using this method directly.
+      # Refer Bio::Blast::RPSBlast::Report document for more information.
+      #
+      # Note for multi-fasta results WITHOUT using Bio::FlatFile:
+      # When parsing an output of rpsblast command running with
+      # multi-fasta sequences WITHOUT using Bio::FlatFile,
+      # each query's result is stored as an "iteration" of PSI-Blast.
+      # This behavior may be changed in the future.
+      #
+      # Note for nucleotide results: This class is not tested with
+      # nucleotide query and/or nucleotide databases.
+      #
+      def initialize(str)
+        str = str.sub(/\A\s+/, '')
+        # remove trailing entries for sure
+        str.sub!(/\n(RPS\-BLAST.*)/m, "\n") 
+        @entry_overrun = $1
+        @entry = str
+        data = str.split(/(?:^[ \t]*\n)+/)
+
+        if data[0] and /\AQuery\=/ !~ data[0] then
+          format0_split_headers(data)
+        end
+        @iterations = format0_split_search(data)
+        format0_split_stat_params(data)
+      end
+
+      # Returns definition of the query.
+      # For a result of multi-fasta input, the first query's definition
+      # is returned (The same as <tt>iterations.first.query_def</tt>).
+      def query_def
+        iterations.first.query_def
+      end
+
+      # Returns length of the query.
+      # For a result of multi-fasta input, the first query's length
+      # is returned (The same as <tt>iterations.first.query_len</tt>).
+      def query_len
+        iterations.first.query_len
+      end
+
+      private
+
+      # Splits headers into the first line, reference, query line and
+      # database line.
+      def format0_split_headers(data)
+        @f0header = data.shift
+        @f0references = []
+        while data[0] and /\ADatabase\:/ !~ data[0]
+          @f0references.push data.shift
+        end
+        @f0database = data.shift
+        # In special case, a void line is inserted after database name.
+        if /\A +[\d\,]+ +sequences\; +[\d\,]+ total +letters\s*\z/ =~ data[0] then
+          @f0database.concat "\n"
+          @f0database.concat data.shift
+        end
+      end
+
+      # Splits the search results.
+      def format0_split_search(data)
+        iterations = []
+        dummystr = 'Searching..................................................done'
+        if r = data[0] and /^Searching/ =~ r then
+          dummystr = data.shift
+        end
+        while r = data[0] and /^Query\=/ =~ r
+          iterations << Iteration.new(data, dummystr)
+        end
+        iterations
+      end
+
+      # Iteration class for RPS-Blast.
+      # Though RPS-Blast does not iterate like PSI-BLAST, 
+      # it aims to store a result of single query sequence.
+      #
+      # Normally, the instance of the class is generated
+      # by Bio::Blast::RPSBlast::Report object.
+      # 
+      class Iteration < Bio::Blast::Default::Report::Iteration
+        # Creates a new Iteration object.
+        # It is designed to be called only internally from
+        # the Bio::Blast::RPSBlast::Report class.
+        # Users shall not use the method directly.
+        def initialize(data, dummystr)
+          if /\AQuery\=/ =~ data[0] then
+            sc = StringScanner.new(data.shift)
+            sc.skip(/\s*/)
+            if sc.skip_until(/Query\= */) then
+              q = []
+              begin
+                q << sc.scan(/.*/)
+                sc.skip(/\s*^ ?/)
+              end until !sc.rest or r = sc.skip(/ *\( *([\,\d]+) *letters *\)\s*\z/)
+              @query_len = sc[1].delete(',').to_i if r
+              @query_def = q.join(' ')
+            end
+          end
+          data.unshift(dummystr)
+          
+          super(data)
+        end
+
+        # definition of the query
+        attr_reader :query_def
+
+        # length of the query sequence
+        attr_reader :query_len
+        
+      end #class Iteration
+      
+    end #class Report
+
+  end #module RPSBlast
+
+end #module Blast
+end #module Bio
+

data/lib/bio/appl/blast/wublast.rb

@@ -0,0 +1,635 @@
+#
+# = bio/appl/blast/wublast.rb - WU-BLAST default output parser
+# 
+# Copyright::  Copyright (C) 2003, 2008 Naohisa GOTO <ng@bioruby.org>
+# License::    The Ruby License
+#
+# $Id:$
+#
+# == Description
+#
+# WU-BLAST default output parser.
+#
+# The parser is still incomplete and may contain many bugs,
+# because I didn't have WU-BLAST license.
+# It was tested under web-based WU-BLAST results and
+# obsolete version downloaded from http://blast.wustl.edu/ .
+#
+# == References
+#
+# * http://blast.wustl.edu/
+# * http://www.ebi.ac.uk/blast2/
+#
+
+require 'bio/appl/blast/format0'
+
+module Bio
+  class Blast
+    module WU #:nodoc:
+
+      # Bio::Blast::WU::Report parses WU-BLAST default output
+      # and stores information in the data.
+      # It may contain a Bio::Blast::WU::Report::Iteration object.
+      # Because it inherits Bio::Blast::Default::Report,
+      # please also refer Bio::Blast::Default::Report.
+      class Report < Default::Report
+
+        # Returns parameters (???)
+        def parameters
+          parse_parameters
+          @parameters
+        end
+
+        # Returns parameter matrix (???)
+        def parameter_matrix
+          parse_parameters
+          @parameter_matrix
+        end
+
+        # Returns e-value threshold specified when BLAST was executed.
+        def expect; parse_parameters; @parameters['E']; end
+
+        # Returns warning messages.
+        def warnings
+          unless defined?(@warnings)
+            @warnings = @f0warnings
+            iterations.each { |x| @warnings.concat(x.warnings) }
+          end
+          @warnings
+        end
+
+        # Returns notice messages.
+        def notice
+          unless defined?(@notice)
+            @notice = @f0notice.to_s.gsub(/\s+/, ' ').strip
+          end #unless
+          @notice
+        end
+
+        # (WU-BLAST) Returns record number of the query.
+        # It may only be available for reports with multiple queries.
+        # Returns an Integer or nil.
+        def query_record_number
+          format0_parse_query
+          @query_record_number
+        end
+
+        # (WU-BLAST) Returns exit code for the execution.
+        # Returns an Integer or nil.
+        def exit_code
+          if defined? @exit_code then
+            @exit_code
+          else
+            nil
+          end
+        end
+
+        # (WU-BLAST) Returns fatal error information.
+        # Returns nil or an array containing String.
+        def fatal_errors
+          if defined? @fatal_errors then
+            @fatal_errors
+          else
+            nil
+          end
+        end
+
+        # Returns the name (filename or title) of the database.
+        def db
+          unless defined?(@db)
+            if /Database *\: *(.*)/m =~ @f0database then
+              a = $1.split(/^/)
+              if a.size > 1 and /\ASearching\..+ done\s*\z/ =~ a[-1] then
+                a.pop
+              end
+              if a.size > 1 and /\A +[\d\,]+ +sequences\; +[\d\,]+ total +letters\.?\s*\z/ =~ a[-1] then
+                a.pop
+              end
+              @db = a.collect { |x| x.sub(/\s+\z/, '') }.join(' ')
+            end
+          end #unless
+          @db
+        end
+
+        private
+        # Parses the query lines (begins with "Query = ").
+        def format0_parse_query
+          unless defined?(@query_def)
+            sc = StringScanner.new(@f0query)
+            sc.skip(/\s*/)
+            if sc.skip_until(/Query\= */) then
+              q = []
+              begin
+                q << sc.scan(/.*/)
+                sc.skip(/\s*^ ?/)
+              end until !sc.rest or r = sc.skip(/ *\( *([\,\d]+) *letters *(\; *record *([\,\d]+) *)?\)\s*\z/)
+              @query_len = sc[1].delete(',').to_i if r
+              @query_record_number = sc[3].delete(',').to_i if r and sc[2]
+              @query_def = q.join(' ')
+            end
+          end
+        end
+
+        # Splits headers.
+        def format0_split_headers(data)
+          @f0header = data.shift
+          @f0references = []
+          while r = data.first
+            case r
+            when /^Reference\: /
+              @f0references.push data.shift
+            when /^Copyright /
+              @f0copyright = data.shift
+            when /^Notice\: /
+              @f0notice = data.shift
+            when /^Query\= /
+              break
+            else
+              break
+            end
+          end
+          @f0query = data.shift
+          @f0warnings ||= []
+          while r = data.first and r =~ /^WARNING\: /
+            @f0warnings << data.shift
+          end
+          return if r = data.first and /\AParameters\:/ =~ r
+          if r = data.first and !(/^Database\: / =~ r)
+            @f0translate_info = data.shift
+          end
+          @f0database = data.shift
+        end
+
+        # Splits search data.
+        def format0_split_search(data)
+          @f0warnings ||= []
+          while r = data.first and r =~ /^WARNING\: /
+            @f0warnings << data.shift
+          end
+          [ Iteration.new(data) ]
+        end
+
+        # Splits statistics parameters.
+        def format0_split_stat_params(data)
+          @f0warnings ||= []
+          while r = data.first and r =~ /^WARNING\: /
+            @f0warnings << data.shift
+          end
+          @f0wu_params = []
+          @f0wu_stats = []
+          ary = @f0wu_params
+          while r = data.shift 
+            case r
+            when /\AStatistics\:/
+              ary = @f0wu_stats
+            when /\AEXIT CODE *(\d+)\s*$/
+              @exit_code = $1.to_i
+              r = nil
+            when /\AFATAL\: /
+              @fatal_errors ||= []
+              @fatal_errors.push r
+              r = nil
+            when /\AWARNING\: /
+              @f0warnings ||= []
+              @f0warnings << r
+              r = nil
+            end
+            ary << r if r
+          end
+          @f0dbstat = F0dbstat.new(@f0wu_stats)
+          itr = @iterations[0]
+          x = @f0dbstat
+          itr.instance_eval { @f0dbstat = x } if itr
+        end
+
+        # Splits parameters.
+        def parse_parameters
+          unless defined?(@parse_parameters)
+            @parameters = {}
+            @parameter_matrix = []
+            @f0wu_params.each do |x|
+              if /^  Query/ =~ x then
+                @parameter_matrix << x
+              else
+                x.split(/^/).each do |y|
+                  if /\A\s*(.+)\s*\=\s*(.*)\s*/ =~ y then
+                    @parameters[$1] = $2
+                  elsif /\AParameters\:/ =~ y then
+                    ; #ignore this
+                  elsif /\A\s*(.+)\s*$/ =~ y then
+                    @parameters[$1] = true
+                  end
+                end
+              end
+            end
+            if ev = @parameters['E'] then
+              ev = '1' + ev if ev[0] == ?e
+              @parameters['E'] = ev.to_f
+            end
+            @parse_parameters = true
+          end
+        end
+
+        # Stores database statistics.
+        # Internal use only. Users must not use the class.
+        class F0dbstat < Default::Report::F0dbstat #:nodoc:
+          def initialize(ary)
+            @f0stat = ary
+            @hash = {}
+          end
+
+          #--
+          #undef :f0params
+          #undef :matrix, :gap_open, :gap_extend,
+          #  :eff_space, :expect, :sc_match, :sc_mismatch,
+          #  :num_hits
+          #++
+
+          # Parses database statistics.
+          def parse_dbstat
+            unless defined?(@parse_dbstat)
+              parse_colon_separated_params(@hash, @f0stat)
+              @database = @hash['Database']
+              @posted_date = @hash['Posted']
+              if val = @hash['# of letters in database'] then
+                @db_len =  val.tr(',', '').to_i
+              end
+              if val = @hash['# of sequences in database'] then
+                @db_num = val.tr(',', '').to_i
+              end
+              @parse_dbstat = true
+            end #unless
+          end #def
+          private :parse_dbstat
+
+        end #class F0dbstat
+
+        #--
+        #class Frame
+        #end #class FrameParams
+        #++
+
+        # Iteration class for WU-BLAST report.
+        # Though WU-BLAST does not iterate like PSI-BLAST,
+        # Bio::Blast::WU::Report::Iteration aims to keep compatibility
+        # with Bio::Blast::Default::Report::* classes.
+        # It may contain some Bio::Blast::WU::Report::Hit objects.
+        # Because it inherits Bio::Blast::Default::Report::Iteration,
+        # please also refer Bio::Blast::Default::Report::Iteration.
+        class Iteration < Default::Report::Iteration
+          # Creates a new Iteration object.
+          # It is designed to be called only internally from
+          # the Bio::Blast::WU::Report class.
+          # Users shall not use the method directly.
+          def initialize(data)
+            @f0stat = []
+            @f0dbstat = Default::Report::AlwaysNil.instance
+            @f0hitlist = []
+            @hits = []
+            @num = 1
+            @f0message = []
+            @f0warnings = []
+            return unless r = data.first
+            return if /\AParameters\:$/ =~ r
+            @f0hitlist << data.shift
+            return unless r = data.shift
+            unless /\*{3} +NONE +\*{3}/ =~ r then
+              @f0hitlist << r
+              while r = data.first and /^WARNING\: / =~ r
+                @f0warnings << data.shift
+              end
+              while r = data.first and /^\>/ =~ r
+                @hits << Hit.new(data)
+              end
+            end #unless
+          end
+
+          # Returns warning messages.
+          def warnings
+            @f0warnings
+          end
+
+          private
+          # Parses hit list.
+          def parse_hitlist
+            unless defined?(@parse_hitlist)
+              r = @f0hitlist.shift.to_s
+              if /Reading/ =~ r and /Frame/ =~ r then
+                flag_tblast = true 
+                spnum = 5
+              else
+                flag_tblast = nil
+                spnum = 4
+              end
+              i = 0
+              @f0hitlist.each do |x|
+                b = x.split(/^/)
+                b.collect! { |y| y.empty? ? nil : y }
+                b.compact!
+                b.each do |y|
+                  y.strip!
+                  y.reverse!
+                  z = y.split(/\s+/, spnum)
+                  z.each { |y| y.reverse! }
+                  dfl  = z.pop
+                  h = @hits[i] 
+                  unless h then
+                    h = Hit.new([ dfl.to_s.sub(/\.+\z/, '') ])
+                    @hits[i] = h
+                  end
+                  z.pop if flag_tblast #ignore Reading Frame
+                  scr = z.pop
+                  scr = (scr ? scr.to_i : nil)
+                  pval = z.pop.to_s
+                  pval = '1' + pval if pval[0] == ?e
+                  pval = (pval.empty? ? (1.0/0.0) : pval.to_f)
+                  nnum = z.pop.to_i
+                  h.instance_eval {
+                    @score = scr
+                    @pvalue = pval
+                    @n_number = nnum
+                  }
+                  i += 1
+                end
+              end #each
+              @parse_hitlist = true
+            end #unless
+          end
+        end #class Iteration
+
+        # Bio::Blast::WU::Report::Hit contains information about a hit.
+        # It may contain some Bio::Blast::WU::Report::HSP objects.
+        #
+        # Because it inherits Bio::Blast::Default::Report::Hit,
+        # please also refer Bio::Blast::Default::Report::Hit.
+        class Hit < Default::Report::Hit
+          # Creates a new Hit object.
+          # It is designed to be called only internally from the
+          # Bio::Blast::WU::Report::Iteration class.
+          # Users should not call the method directly.
+          def initialize(data)
+            @f0hitname = data.shift
+            @hsps = []
+            while r = data.first
+              if r =~ /^\s*(?:Plus|Minus) +Strand +HSPs\:/ then
+                data.shift
+                r = data.first
+              end
+              if /\A\s+Score/ =~ r then
+                @hsps << HSP.new(data)
+              else
+                break
+              end
+            end
+            @again = false
+          end
+
+          # Returns score.
+          def score
+            @score
+          end
+          # p-value
+          attr_reader :pvalue
+          # n-number (???)
+          attr_reader :n_number
+        end #class Hit
+
+        # Bio::Blast::WU::Report::HSP holds information about the hsp
+        # (high-scoring segment pair).
+        #
+        # Because it inherits Bio::Blast::Default::Report::HSP,
+        # please also refer Bio::Blast::Default::Report::HSP.
+        class HSP < Default::Report::HSP
+          # p-value
+          attr_reader :pvalue if false #dummy
+          method_after_parse_score :pvalue
+          # p_sum_n (???)
+          attr_reader :p_sum_n if false #dummy
+          method_after_parse_score :p_sum_n
+        end #class HSP
+
+      end #class Report
+
+      # WU-BLAST default output parser for TBLAST.
+      # All methods are equal to Bio::Blast::WU::Report.
+      # Only DELIMITER (and RS) is different.
+      class Report_TBlast < Report
+        # Delimter of each entry for TBLAST. Bio::FlatFile uses it.
+        DELIMITER = RS = "\nTBLAST"
+
+        # (Integer) excess read size included in DELIMITER.
+        DELIMITER_OVERRUN = 6 # "TBLAST"
+      end #class Report_TBlast
+
+    end #module WU
+  end #class Blast
+end #module Bio
+
+######################################################################
+
+if __FILE__ == $0
+
+  Bio::FlatFile.open(Bio::Blast::WU::Report, ARGF) do |ff|
+  ff.each do |rep|
+
+  print "# === Bio::Blast::WU::Report\n"
+  puts
+  print "  rep.program           #=> "; p rep.program
+  print "  rep.version           #=> "; p rep.version
+  print "  rep.reference         #=> "; p rep.reference
+  print "  rep.notice            #=> "; p rep.notice
+  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 "# === Warning messages\n"
+  print "  rep.warnings        #=> "; p rep.warnings
+
+  print "# === Iterations\n"
+  puts
+  print "  rep.itrerations.each do |itr|\n"
+  puts
+
+  rep.iterations.each do |itr|
+      
+  print "# --- Bio::Blast::WU::Report::Iteration\n"
+  puts
+
+  print "    itr.num             #=> "; p itr.num
+  #print "    itr.statistics      #=> "; p itr.statistics
+  puts
+  print "    itr.warnings        #=> "; p itr.warnings
+  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::WU::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?
+  #puts
+  print "      hit.score         #=> "; p hit.score
+  print "      hit.pvalue        #=> "; p hit.pvalue
+  print "      hit.n_number      #=> "; p hit.n_number
+
+  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::WU::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
+  puts
+  print "        hsp.pvalue      #=> "; p hsp.pvalue
+  print "        hsp.p_sum_n     #=> "; p hsp.p_sum_n
+  puts
+
+  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
+
+######################################################################
+