mgnu 2.1.1

data/lib/mgnu/parser/blast.rb

@@ -0,0 +1,87 @@
+# require 'xml/libxml'
+require 'mgnu/loggable'
+require 'ox'
+
+module MgNu
+  module Parser
+    class Blast
+      require_relative 'blast/format7'
+      require_relative 'blast/format8'
+      require_relative 'blast/format0'
+
+      include Loggable
+      include Enumerable
+
+      attr_accessor :format, :input
+
+      # create a new blast parser
+      def initialize(input = nil, format = nil)
+        if input
+          if File.exists?(input) and File.readable?(input)
+            @file = File.open(input)
+            @input_type = File
+          elsif input.class == String
+            # assume a string containing the blast report
+            @input_type = String
+          else
+            raise "\n\n -- No file by that name (#{input}).  Exiting\n\n"
+            exit(1)
+          end
+        else
+          error("MgNu::Parser::Blast.new(): needs a filename or atring of Blast data")
+          exit(1)
+        end
+        
+        @input = input
+        @format = format
+
+        # don't overwrite a format if given one
+        if @format.nil?
+          @format = 7 if @input =~ /.*\.xml/ and @input_type == File
+          @format = 8 if @input =~ /.*8$/ and @input_type == File
+        end
+       
+        if @format.nil?
+          error("Please set the format type!");
+          exit(1)
+        end
+
+        case @format
+        when 7
+          #XML::SaxParser.file(@input)
+          if @input_type == File
+            @parser = Format7.new()
+          else
+            # string input?
+          end
+        when 8
+          if @input_type == File
+            @parser = Format8.new(@file)
+          elsif @input_type == String
+            @parser = Format8.new(@input)
+          end
+        when 0
+          if @input_type == File
+            @parser = Format0.new(@file)
+          elsif @input_type == String
+            @parser = Format0.new(@input)
+          end
+        end
+      end # end initialize
+
+      def parse
+        if @format == 7
+          Ox.sax_parse(@parser, @file)
+        else
+          @parser.parse
+        end
+        return(@parser.queries)
+      end
+
+      def each(&b)
+        @parser.each(&b)
+      end
+    end # end of MgNu::Parser::Blast class
+
+  end # end of MgNu::File module
+end # end of MgNu module

data/lib/mgnu/parser/blast/format0.rb

@@ -0,0 +1,290 @@
+require 'mgnu/parser/blast/query'
+require 'mgnu/parser/blast/sbjct'
+require 'mgnu/parser/blast/hsp'
+
+module MgNu
+  module Parser
+    class Blast
+      class Format0
+        include MgNu::Parser
+
+        attr_accessor :queries, :blast_type
+
+        # create a new Format0 parser
+        def initialize(file)
+          @query = nil
+          @sbjct = nil
+          @sbjct_number = 0
+          @blast_type = nil
+          @queries = []
+
+          @file = file
+        end
+
+        # parse the input blast file
+        def parse
+          line = @file.readline
+          @blast_type = line.split[0]
+          buffer = parse_until(@file,/^Query=/) # get the 1st chunk of the blast report
+          while buffer.length > 0
+            if buffer[0] =~ /^Query=/
+              process_buffer(buffer)
+            end
+            buffer = parse_until(@file,/^Query=/) 
+          end # end while
+        end # end parse
+
+        # filter a blast query entry for important parts
+        # @param [Array] buffer containing a "Query=" block from
+        #   the blast output file
+        # @return [Bool] success or failure of the processing
+        def process_buffer(buffer)
+          return false if buffer.length == 0
+          extract_query(buffer)
+          @queries << @query
+        end # end process_buffer
+
+        def extract_query(buffer)
+          str = ""
+          while line = buffer.shift
+            break if line =~ /^\s*$/ # empty line, break
+            str += line.chomp
+          end
+          str.gsub!(/\s+/, " ")
+          @query = Query.new
+          if str =~ /^Query= (.+?) (.*) ?\(([0-9,]+) letters\)/
+            @query.query_id = $1
+            @query.definition = $2
+            @query.length = $3.gsub(",","").to_i
+          else
+            # Blast+ output has query id/definition and length on separate lines
+            while line = buffer.shift
+              str += line.chomp
+              break if line =~ /Length=/
+            end
+            if str =~ /^Query=\s([^\s]+)\s?(.*)\s?Length=([,\d]+)/
+              @query.query_id = $1
+              @query.definition = $2
+              @query.length = $3.gsub(",","").to_i
+            end
+          end
+          extract_dbinfo(buffer)
+
+          sbjct_buffer = Array.new
+          while line = buffer.shift
+            if line =~ /^>/ and sbjct_buffer.length > 0
+              extract_sbjct(sbjct_buffer)
+              sbjct_buffer.clear
+              buffer.unshift(line)
+            else
+              sbjct_buffer << line
+            end
+          end
+          extract_sbjct(sbjct_buffer) if sbjct_buffer.length > 0
+
+        end # end extract_query
+        
+        def extract_dbinfo(buffer)
+          str = ""
+          while line = buffer.shift
+            break if line =~ /^\s*$/ # empty line, break
+            str += line.chomp
+          end
+          
+          str.gsub!(/\s+/," ")
+          if str =~ /Database:\s+(.+)\.?\s+([0-9,]+)\s+sequences;\s+([0-9,]+)\s+total\s+letters/
+            db_name, db_seq_count, db_total_letters = $1, $2, $3
+            @query.database = db_name
+            @query.database_sequence_count = db_seq_count.gsub(",","").to_i
+            @query.database_total_letters = db_total_letters.gsub(",","").to_i
+          else
+            $stderr.puts "extract_dbinfo: Database line mismatch!"
+            $stderr.puts "database, database_sequence_count and database_total_letters are not set"
+            $stderr.puts str
+          end
+
+          # eat up single-line summary cruft until beginning of subjects
+          while line = buffer.shift
+            if line =~ /^>/ # first sbjct, break
+              buffer.unshift(line)
+              break
+            end
+          end
+        end
+
+        def extract_sbjct(buffer)
+          if buffer[0] !~ /^>/
+            $stderr.puts "can't process subject buffer - missing fasta header line!"
+            exit(1)
+          end
+
+          str = ""
+          # read until blank line to get header, but ensure that we already have Length= line
+          while line = buffer.shift
+            break if line =~ /^\s*$/ && str =~ /Length\s*=/
+            str += line.chomp
+          end
+          str.gsub!(/\s+/," ") # shrink spaces
+          @sbjct = Sbjct.new
+          if str =~ />(.+?)\s+(.*)\s*Length\s+=\s+(\d+)/m or
+             str =~ />\s(.+?)\s+(.*)\s*Length=\s?(\d+)/m
+            @sbjct.number = @query.sbjcts.length + 1
+            @sbjct.sbjct_id = $1
+            @sbjct.definition = $2.rstrip
+            @sbjct.length = $3.to_i
+            @sbjct.query = @query
+          end
+         
+          hsp_buffer = Array.new
+          while line = buffer.shift
+            if line =~ /^>/ and hsp_buffer.length > 0
+              extract_all_hsps(hsp_buffer)
+              hsp_buffer.clear
+              buffer.unshift(line)
+              break
+            else
+              hsp_buffer << line
+            end
+          end
+          extract_all_hsps(hsp_buffer) if hsp_buffer.length > 0
+          
+          @query.sbjcts << @sbjct
+        end
+
+        # create Hsp objects from the complete alignment section
+        #
+        # @param [Array] buffer containing all the lines from the
+        #   alignment section
+        def extract_all_hsps(buffer)
+          unless buffer[0] =~ /^\s+Score =/
+            $stderr.puts "can't process HSP buffer - missing Score = line!"
+            exit(1)
+          end
+
+          hsp_buffer = Array.new
+          while line = buffer.shift
+            if line =~ /^\s+Score =/ and hsp_buffer.length > 0
+              process_hsp(hsp_buffer)              
+              hsp_buffer.clear
+              buffer.unshift(line)
+            else
+              hsp_buffer << line
+            end
+          end
+          process_hsp(hsp_buffer) if hsp_buffer.length > 0
+        end
+
+        def process_hsp(buffer)
+          unless buffer[0] =~ /^\s+Score =/
+            $stderr.puts "can't process HSP buffer - missing Score = line!"
+            exit(1)
+          end
+
+          str = ""
+          # read until blank line to get header
+          while line = buffer.shift
+            break if line =~ /^\s*$/
+            str += line.chomp
+          end
+
+          hsp = Hsp.new
+          if str =~ / Score =\s+(\d+(?:\.\d+)?)\s+bits\s+\((\d+)\)/
+            hsp.bit_score = $1.to_f
+            hsp.score = $2.to_i
+          end
+
+          if str =~ /Expect.*\s+=\s+(\d+\.\d+)/ or
+             str =~ /Expect.*\s+=\s+(\d+e-\d+)/ or
+             str =~ /Expect.*\s+=\s+(e-\d+)/
+            hsp.evalue = $1.to_f 
+          end
+
+          if str =~ /Identities\s+=\s+(\d+)\/(\d+)\s+\((\d+%)\)/
+            hsp.length = $2.to_i
+            hsp.identity = $3.to_i
+          end
+
+          if str =~ /Positives\s+=\s+(\d+)\/(\d+)\s+\((\d+)%\)/
+            hsp.positive = $1.to_i
+          end
+
+          if str =~ /Gaps\s+=\s+(\d+)\/(\d+)\s+\((\d+%)\)/
+            hsp.gap_count = $1.to_i
+          end
+
+          if str =~ /Frame\s+=\s+([+-]\d)/
+            hsp.query_frame = $1
+          elsif str =~ /Frame\s+=\s+([+-]\d)\s+\/\s+([+-]\d)/
+            hsp.query_frame = $1
+            hsp.sbjct_frame = $2
+          end
+          
+          if str =~ /Strand\s+=\s+(Plus|Minus)\s+\/\s+(Plus|Minus)/
+            hsp.query_frame = $1 == "Plus" ? 1 : -1
+            hsp.sbjct_frame = $2 == "Plus" ? 1 : -1
+          end
+
+          # read remaining buffer lines for the alignment
+          # buffer.delete_if {|x| x =~ /^\s*$/} # drop empty lines
+
+          query_to = nil
+          sbjct_to = nil
+          while buffer.length > 0
+            line = buffer.shift
+            if line =~ /Query/
+              q_line = line
+              m_line = buffer.shift
+              s_line = buffer.shift
+              leader = 0
+             
+              break if q_line =~ /#{@blast_type}/ # end of hsps so exit
+              if q_line =~ /\s+Database:\s+#{@query.database}/ # end of report so exit
+                break
+              else
+              end
+
+              # process query line
+              unless q_line =~ /^Query/
+                $stderr.puts "Query line is malformed - skipping alignment"
+                $stderr.puts q_line
+                break
+              end
+
+              q_line =~ /^Query:?\s+(\d+)\s*(.+?)\s+(\d+)$/
+              if hsp.query_from.nil?
+                hsp.query_from = $1.to_i
+              end
+              hsp.query_sequence += $2
+              query_to = $3.to_i
+
+              if leader == 0
+                q_line =~ /^(Query:?\s+\d+\s*)/
+                leader = $1.length
+              end
+              
+              # process mid line
+              hsp.midline += m_line[leader,m_line.length]
+              
+              # process sbjct line
+              unless s_line =~ /^Sbjct/
+                $stderr.puts "Sbjct line is malformed - skipping alignment"
+                $stderr.puts s_line
+                break
+              end
+
+              s_line =~ /^Sbjct:?\s+(\d+)\s+(.+?)\s+(\d+)$/
+              if hsp.sbjct_from.nil?
+                hsp.sbjct_from = $1.to_i
+              end
+              hsp.sbjct_sequence += $2
+              sbjct_to = $3.to_i
+            end # end of if line =~ /Query/
+          end # end while buffer.length > 0
+          hsp.query_to = query_to
+          hsp.sbjct_to = sbjct_to
+          @sbjct.hsps << hsp # add this hsp to the sbjct
+        end # end extract_hsp
+      end # end of MgNu::Parser::Blast::Format0 class
+    end # end of MgNu::Parser::Blast class
+  end # end of MgNu::Parser module
+end # end of MgNu module

data/lib/mgnu/parser/blast/format7.rb

@@ -0,0 +1,121 @@
+# require 'xml/libxml'
+require 'ox'
+require 'mgnu/parser/blast/query'
+require 'mgnu/parser/blast/sbjct'
+require 'mgnu/parser/blast/hsp'
+
+module MgNu
+  module Parser
+    class Blast
+      class Format7 < ::Ox::Sax
+
+        attr_accessor :queries
+
+        # create a new Format7 parser
+        def initialize()
+          @query = nil
+          @sbjct = nil
+          @hsp = nil
+          @current_element = nil
+          @queries = []
+        end
+
+        def start_element(element)
+          # set the current element - used during character parsing
+          @current_element = element
+
+          case element
+          when :Iteration
+            # start a new Query
+            @query = Query.new if @query.nil?
+          when :Hit
+            # start a new Sbjct
+            @sbjct = Sbjct.new if @sbjct.nil?
+            @sbjct.query = @query
+          when :Hsp
+            # start a new Hsp
+            @hsp = Hsp.new if @hsp.nil?
+            @hsp.sbjct = @sbjct
+            @hsp.query = @query
+          end
+        end
+
+        def text(characters = '')
+          return if characters =~ /^\s+$/
+          case @current_element
+          when :"Iteration_iter-num"
+            @query.number = characters.to_i
+          when :"Iteration_query-ID"
+            @query.query_id += characters
+          when :"Iteration_query-def"
+            @query.definition += characters
+          when :"Iteration_query-len"
+            @query.length = characters.to_i
+
+          when :Hit_num
+            @sbjct.number = characters.to_i
+          when :Hit_id
+            @sbjct.sbjct_id += characters
+          when :Hit_def
+            @sbjct.definition += characters
+          when :Hit_accession
+            @sbjct.accession += characters
+          when :Hit_len
+            @sbjct.length = characters.to_i
+
+          when :Hsp_num
+            @hsp.number = characters.to_i
+          when :"Hsp_bit-score"
+            @hsp.bit_score = characters.to_i
+          when :Hsp_score
+            @hsp.score = characters.to_i
+          when :Hsp_evalue
+            @hsp.evalue = characters.to_f
+          when :"Hsp_query-from"
+            @hsp.query_from = characters.to_i
+          when :"Hsp_query-to"
+            @hsp.query_to = characters.to_i
+          when :"Hsp_hit-from"
+            @hsp.sbjct_from = characters.to_i
+          when :"Hsp_hit-to"
+            @hsp.sbjct_to = characters.to_i
+          when :"Hsp_query-frame"
+            @hsp.query_frame = characters.to_i
+          when :"Hsp_hit-frame"
+            @hsp.sbjct_frame = characters.to_i
+          when :Hsp_identity
+            @hsp.identity = characters.to_i
+          when :Hsp_positive
+            @hsp.positive = characters.to_i
+          when :"Hsp_align-len"
+            @hsp.length = characters.to_i
+          when :Hsp_qseq
+            @hsp.query_sequence += characters
+          when :Hsp_hseq
+            @hsp.sbjct_sequence += characters
+          when :Hsp_midline
+            @hsp.midline += characters
+          end
+        end
+
+        def end_element(element)
+          case element
+          when :Iteration
+            # end of a query
+            @queries << @query
+            @query = Query.new
+          when :Hit
+            # end of a sbjct
+            @query.sbjcts << @sbjct
+            @sbjct = Sbjct.new
+          when :Hsp
+            # end of a hsp
+            @sbjct.hsps << @hsp
+            @hsp = Hsp.new
+          end
+        end
+        
+      end # end of MgNu::Parser::Blast::Format7 class
+    end # end of MgNu::Parser::Blast class
+  end # end of MgNu::Parser module
+end # end of MgNu module