mgnu 2.1.1

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

@@ -0,0 +1,120 @@
+require 'mgnu/parser/blast/query'
+require 'mgnu/parser/blast/sbjct'
+require 'mgnu/parser/blast/hsp'
+
+
+module MgNu
+  module Parser
+    class Blast
+      class Format8
+        include Enumerable
+
+        attr_accessor :queries
+
+        # create a new Format8 parser object
+        def initialize(input)
+          @query = nil
+          @sbjct = nil
+          @queries = []
+
+          @input = input
+        end
+
+        def each
+          @input.each do |line|
+            next if line =~ /^#/ # skip comments
+
+            temp = line.split(/\t/)
+
+            query_id = temp.shift
+
+            if @query.nil?
+              @query = Query.new
+              @query.query_id = query_id
+            end
+
+            if @query.query_id == query_id
+              # already on this query, so just add the sbject
+              extract_sbjct(temp)
+            else
+              # new query_id, save this one and start on new one
+              @query.sbjcts << @sbjct
+              @sbjct = nil
+              yield @query
+              @query = Query.new
+              @query.query_id = query_id
+              extract_sbjct(temp)
+            end
+          end
+        end
+        
+        def parse
+          @input.each do |line|
+            next if line =~ /^#/ # skip comments
+
+            temp = line.split
+
+            query_id = temp.shift
+
+            if @query.nil?
+              @query = Query.new
+              @query.query_id = query_id
+            end
+
+            if @query.query_id == query_id
+              # already on this query, so just add the sbject
+              extract_sbjct(temp)
+            else
+              # new query_id, save this one and start on new one
+              @query.sbjcts << @sbjct
+              @queries << @query
+              @sbjct = nil
+              @query = Query.new
+              @query.query_id = query_id
+              extract_sbjct(temp)
+            end
+          end # end of input.each do |line|
+
+          #grab the last ones, if present
+          unless @query.nil?
+            @query.sbjcts << @sbjct
+            @queries << @query
+          end
+        end
+
+        def extract_sbjct(input)
+          sbjct_id = input.shift
+          if @sbjct.nil?
+            @sbjct = Sbjct.new
+            @sbjct.sbjct_id = sbjct_id
+          end
+
+          if @sbjct.sbjct_id == sbjct_id
+            extract_hsp(input)
+          else
+            @query.sbjcts << @sbjct
+            @sbjct = Sbjct.new
+            @sbjct.sbjct_id = sbjct_id
+            extract_hsp(input)
+          end
+        end
+
+        def extract_hsp(input)
+          hsp = Hsp.new
+          hsp.identity = input.shift.to_f
+          hsp.length = input.shift.to_i
+          hsp.mismatches = input.shift.to_i
+          hsp.gap_count = input.shift.to_i
+          hsp.query_from = input.shift.to_i
+          hsp.query_to = input.shift.to_i
+          hsp.sbjct_from = input.shift.to_i
+          hsp.sbjct_to = input.shift.to_i
+          hsp.evalue = input.shift.to_f
+          hsp.bit_score = input.shift.to_f
+          @sbjct.hsps << hsp
+        end
+
+      end # end of MgNu::Parser::Blast::Format8 class
+    end # end of MgNu::Parser::Blast class
+  end # end of MgNu::Parser module
+end # end of MgNu module

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

@@ -0,0 +1,75 @@
+module MgNu
+  module Parser
+    class Blast
+      class Hsp
+
+        attr_accessor :number, :bit_score, :score, :evalue
+        attr_accessor :query_from, :query_to, :sbjct_from, :sbjct_to
+        attr_accessor :query_frame, :sbjct_frame, :identity, :positive
+        attr_accessor :length, :query_sequence, :sbjct_sequence, :midline
+        attr_accessor :gap_count, :mismatches, :sbjct, :query
+
+        # create a new Hsp object
+        def initialize
+          @number = nil
+          @bit_score = nil
+          @score = nil
+          @evalue = nil
+          @query_from = nil
+          @query_to = nil
+          @sbjct_from = nil
+          @sbjct_to = nil
+          @query_frame = nil
+          @sbjct_frame = nil
+          @identity = nil
+          @positive = nil
+          @length = nil
+          @query_sequence = ""
+          @sbjct_sequence = ""
+          @midline = ""
+          @gap_count = nil
+          @mismatches = nil
+          @sbjct = nil
+          @query = nil
+        end
+
+        def query_frameshifts
+          if @query_sequence =~ /(?:\/|\\)/
+            loc2frame = Hash.new
+            re = /[\/\\]{1,2}/
+            re.global_match(@query_sequence.gsub(/[- ]/,'')) do |m|
+              frame = nil
+              # m.begin(0) is location of char match
+              # (m.begin(0) - 1) * 3 is the length of the coding dna
+              #    up to the (but not including) the char match
+              # (m.begin(0) - 1) * 3 + @query_from - 1 is the corrected
+              #   position taking into account the start of the query
+              #   sequence.  query_from is reported in nt
+              if @query_from > @query_to
+                location = @query_from - (m.begin(0) * 3 - 1)
+              else
+                location = (m.begin(0) * 3 - 1) + @query_from
+              end
+              case m[0]
+              when '/'
+                frame = 1
+              when '//'
+                frame = 2
+              when '\\'
+                frame = -1
+              when '\\\\'
+                frame = -2
+              end
+              loc2frame[location] = frame
+            end # end re.global_match
+            return loc2frame
+          else
+            return nil
+          end # end if @query_sequence =~ /(?:\/|\\)/
+        end # end query_frameshifts
+
+      end # end of MgNu::Parser::Blast::Hsp class
+    end # end of MgNu::Parser::Blast class
+
+  end # end of MgNu::Parser module
+end # end of MgNu module

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

@@ -0,0 +1,45 @@
+module MgNu
+  module Parser
+    class Blast
+      class Query
+
+        attr_accessor :number, :query_id, :definition, :length, :sbjcts
+        attr_accessor :database, :database_sequence_count, :database_total_letters
+
+        # create a new Query object
+        def initialize
+          @number = nil
+          @query_id = ""
+          @definition = ""
+          @length = nil
+          @sbjcts = []
+          @best_hit = nil
+          @database = nil
+          @database_sequence_count = 0
+          @database_total_letters = 0
+        end
+
+        # Returns the @best_hit instance variable.  If not set, it
+        # will search this query's sbjcts and find the one with the best
+        # evalue and return it
+        #
+        # @return [MgNu::Parser::Blast::Sbjct] the best hit for this
+        # query
+        def best_hit
+          return @best_hit unless @best_hit.nil?
+          if @sbjcts.length > 0 # make sure there are some hits
+            best_hit = @sbjcts[0]
+            @sbjcts.each do |s|
+              if s.evalue < best_hit.evalue
+                best_hit = s
+              end
+            end
+            @best_hit = best_hit
+            return best_hit
+          end
+          return nil
+        end
+      end # end of MgNu::Parser::Blast::Query class
+    end # end of MgNu::Parser::Blast class
+  end # end of MgNu::Parser module
+end # end of MgNu module

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

@@ -0,0 +1,62 @@
+module MgNu
+  module Parser
+    class Blast
+      class Sbjct
+
+        attr_accessor :hsps
+        attr_accessor :number, :sbjct_id, :definition, :length
+        attr_accessor :accession, :query
+
+        # create a new Sbjct object
+        def initialize
+          @number = nil
+          @sbjct_id = ""
+          @definition = ""
+          @length = nil
+          @accession = ""
+          @hsps = []
+          @best_hsp = nil
+          @query = nil
+        end
+        
+        # searches hsps and looks for the best and returns it's evalue
+        def evalue
+          # call the best_hsp method and see if result is nil
+          best_hsp.nil? ? nil : @best_hsp.evalue
+        end # end of Sbjct#evalue
+        
+        # searches hsps and looks for the best and returns it's
+        # bit_score
+        def bit_score
+          # call the best_hsp method and see if result is nil
+          best_hsp.nil? ? nil : @best_hsp.bit_score
+        end # end of Sbjct#bit_score
+ 
+        # searches hsps and looks for the best and returns it's
+        # identity
+        def identity
+          # call the best_hsp method and see if result is nil
+          best_hsp.nil? ? nil : @best_hsp.identity
+        end # end of Sbjct#bit_score
+
+        # searches hsps and looks for the best and sets the instance
+        # variable
+        def best_hsp
+          if @best_hsp.nil?
+            if @hsps.length > 0 # have some hsps for this hit
+              temp_best = @hsps[0]
+              @hsps.each do |h|
+                if h.evalue < temp_best.evalue
+                  temp_best = h
+                end
+              end
+              @best_hsp = temp_best
+            end
+          end
+          @best_hsp
+        end # end of Sbjct#evalue
+      end # end of MgNu::Parser::Blast::Sbjct class
+    end # end of MgNu::Parser::Blast class
+
+  end # end of MgNu::Parser module
+end # end of MgNu module

data/lib/mgnu/parser/clustalw.rb

@@ -0,0 +1,72 @@
+module MgNu
+  module Parser
+    # ClustalW is the class used for parsing clustalw multiple alignment output.
+    class ClustalW
+      attr_accessor :buffer, :raw
+      attr_reader :file, :alignment
+
+      # params [String] alignment file (*.aln)
+      # params [Boolean] is this a file (default is true), or a string?
+      # returns [MgNu::Alignment]
+      def initialize(input = nil, file = true)
+        if input
+          if file
+            if File.exists?(input) and File.readable?(input)
+              @raw = File.read(input)
+            end # end of exists and readable file checks
+          else # file is false, so this must be a string with input
+            @raw = input
+          end
+          @buffer = @raw.split(/\r?\n\r?\n/)
+          @alignment = nil
+          self.parse
+          if @buffer.length == 0
+            puts "ClustalW alignment file #{input} did not parse!"
+            exit(1);
+          end
+        else
+          error("MgNu::Parser::ClustalW.new(): need an existing file")
+        end
+      end
+
+      # process the input multiple alignement
+      def parse
+        if @alignment == nil
+          header = @buffer.shift
+          @buffer[0].gsub!(/^(\r?\n)+/, '') # drop newline at start of section
+          @buffer.collect! { |section| section.split(/\r?\n/) }
+          
+          match_lines = []
+          # drop numbers if the alignment was run with "-SEQNOS=on"
+          @buffer.each do |section|
+              section.each { |line| line.sub!(/\s+\d+\s*$/, '') }
+              match_lines << section.pop
+          end
+
+          # get the 1st position of a space from the right using
+          # rindex.  Increment this by 1 to get the seq_start
+          seq_start = (@buffer[0][0].rindex(/\s/) || -1) + 1
+
+          # create ordered array of hashes with
+          # seqname => sequence and create an array with a order of
+          # sequences (seqname as value)
+          order = Array.new
+          h = Hash.new
+          @buffer.each do |section|
+            section.each do |line|
+              name = line[0, seq_start].sub(/\s+\z/, '')
+              sequence = line[seq_start..-1]
+              if h.has_key?(name)
+                h[name] += sequence
+              else
+                order << name
+                h[name] = sequence
+              end
+            end
+          end
+        end
+        @alignment = MgNu::Alignment.new(h, order)
+      end # end of #parse method
+    end # end of MgNu::Parser::ClustalW class
+  end # end of MgNu::Parser module
+end # end of MgNu module

data/lib/mgnu/parser/fasta.rb

@@ -0,0 +1,61 @@
+module MgNu
+  module Parser
+    class Fasta
+      include Enumerable
+
+      attr_reader :file, :filename
+
+      # create a new Fasta parser
+      def initialize(filename = nil, quality_file = false)
+        @quality_file = quality_file
+        @filename = filename
+        if filename
+          if File.exists?(filename) and File.readable?(filename)
+            @file = File.open(filename)
+          else
+            raise "\n\n -- No file by that name (#{filename}).  Exiting\n\n"
+            exit(1)
+            #@file = File.new(filename, "w")
+          end
+        else
+          error("MgNu::Parser::Fasta.new(): need a filename or an existing file")
+        end
+      end
+
+      # override enumerables
+      def each
+        @buffer = [] # temp storage
+        @file.each_line do |line|
+          line.chomp!
+          if line =~ />(.*)/  # got a header line
+            if @buffer.length > 0
+              if @quality_file
+                yield MgNu::Sequence::Fasta.new(:header => @buffer.shift,
+                                                  :sequence => @buffer.join(" "))
+              else
+                yield MgNu::Sequence::Fasta.new(:header => @buffer.shift,
+                                                  :sequence => @buffer.join(""))
+              end
+            end
+            @buffer = []
+            @buffer << $1
+          else  # got a sequence line
+            @buffer << line
+          end
+        end # end of file io
+        @file.close
+
+        # don't forget to yield the last one
+        if @buffer.length > 0
+          if @quality_file
+            yield MgNu::Sequence::Fasta.new(:header   => @buffer.shift,
+                                              :sequence => @buffer.join(" "))
+          else
+            yield MgNu::Sequence::Fasta.new(:header   => @buffer.shift,
+                                              :sequence => @buffer.join(""))
+          end
+        end
+      end # end of #each
+    end # end of MgNu::Parser::Fasta class
+  end # end of MgNu::File module
+end # end of MgNu module

data/lib/mgnu/parser/fasta_header_index.rb

@@ -0,0 +1,39 @@
+require 'moneta'
+module MgNu
+  module Parser
+    class FastaHeaderIndex
+      attr_reader :filename, :db_name, :db
+
+      def initialize(filename)
+        @filename = filename
+        if filename =~ /^.+\.hdr\.tch$/
+          @db_name = @filename
+        else
+          @db_name = @filename + ".hdr.tch"
+        end
+
+        if File.exist?(@db_name)
+          @db = Moneta.new(:TokyoCabinet, file: @db_name)
+        else
+          @db = Moneta.new(:TokyoCabinet, file: @db_name)
+          parse
+        end
+      end
+
+      # setup parse method for creating tokyo cabinet
+      def parse
+        MgNu::Parser::Fasta.new(@filename).each do |f|
+          @db[f.header_name] = f.header_description
+        end
+      end # end of #parse
+
+      def [](name)
+        @db[name] ? @db[name] : nil
+      end
+
+      def close
+        @db.close unless @db.nil?
+      end
+    end # end of MgNu::Parser::FastaHeaderIndex class
+  end # end of MgNu::Parser module
+end # end of MgNu module