bio 1.0.0 → 1.1.0

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

@@ -1,26 +1,10 @@
 #
 # = bio/appl/mafft/report.rb - MAFFT report class
 #
-# Copyright:: Copyright (C) 2003 GOTO Naohisa <ngoto@gen-info.osaka-u.ac.jp>
-# License::   LGPL
+# Copyright:: Copyright (C) 2003, 2007  Naohisa Goto <ng@bioruby.org>
+# License::   The Ruby License
 #
-#--
-#  This library is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU Lesser General Public
-#  License as published by the Free Software Foundation; either
-#  version 2 of the License, or (at your option) any later version.
-#
-#  This library is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-#  Lesser General Public License for more details.
-#
-#  You should have received a copy of the GNU Lesser General Public
-#  License along with this library; if not, write to the Free Software
-#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
-#++
-#
-#  $Id: report.rb,v 1.8 2005/12/18 15:58:40 k Exp $
+#  $Id: report.rb,v 1.13 2007/07/16 12:21:39 ngoto Exp $
 #
 # MAFFT result parser class.
 # MAFFT is a very fast multiple sequence alignment software.
@@ -29,6 +13,10 @@
 # the significance of this class is to keep standard form and
 # interface between Bio::ClustalW::Report.
 #
+# Bio::Alignment::MultiFastaFormat is a generic data class for
+# fasta-formatted multiple sequence alignment data.
+# Bio::MAFFT::Report inherits Bio::Alignment::MultiFastaFormat.
+#
 # == References
 #
 # * K. Katoh, K. Misawa, K. Kuma and T. Miyata.
@@ -38,11 +26,97 @@
 # * http://www.biophys.kyoto-u.ac.jp/~katoh/programs/align/mafft/
 #
 
+require 'stringio'
 require 'bio/db/fasta'
 require 'bio/io/flatfile'
+require 'bio/alignment'
 require 'bio/appl/mafft'
 
 module Bio
+  module Alignment
+    # Data class for fasta-formatted multiple sequence alignment data,
+    # which is simply multiple entiries of fasta formatted sequences.
+    class MultiFastaFormat
+
+      # delimiter for flatfile
+      DELIMITER = RS = nil
+
+      # Creates a new data object.
+      # +str+ should be a (multi-)fasta formatted string.
+      def initialize(str)
+        ff = Bio::FlatFile.new(Bio::FastaFormat, StringIO.new(str))
+        @data = ff.to_a
+        @alignment = nil
+        @seq_method = nil
+      end
+
+      # Gets an multiple alignment.
+      # Returns a Bio::Alignment object.
+      # +method+ should be one of :naseq, :aaseq, :seq, or nil (default).
+      # nil means to automatically determine nucleotide or amino acid.
+      #
+      # This method returns previously parsed object
+      # if the same method is given (or guessed method is the same).
+      def alignment(method = nil)
+        m = determine_seq_method(@data, method)
+        if !@alignment or m != @seq_method then
+          @seq_method = m
+          @alignment = do_parse(@data, @seq_method)
+        end
+        @alignment
+      end
+
+      # Gets an array of the fasta formatted sequence objects.
+      # Returns an array of Bio::FastaFormat objects.
+      def entries
+        @data
+      end
+
+      private
+      # determines seqtype.
+      # if nil is given, try to guess DNA or protein.
+      def determine_seq_method(data, m = nil)
+        case m
+        when :aaseq
+          :aaseq
+        when :naseq
+          :naseq
+        when :seq
+          :seq
+        when nil
+          # auto-detection
+          score = 0
+          data[0, 3].each do |e|
+            k = e.to_seq.guess
+            if k == Bio::Sequence::NA then
+              score += 1
+            elsif k == Bio::Sequence::AA then
+              score -= 1
+            end
+          end
+          if score > 0 then
+            :naseq
+          elsif score < 0 then
+            :aaseq
+          else
+            :seq
+          end
+        else
+          raise 'one of :naseq, :aaseq, :seq, or nil should be given'
+        end
+      end
+
+      # Parses a result.
+      def do_parse(ary, seqmethod)
+        a = Bio::Alignment.new
+        a.add_sequences(ary) do |x|
+          [ x.__send__(seqmethod), x.definition ]
+        end
+        a
+      end
+    end #class MultiFastaFormat
+  end #module Alignment
+
   class MAFFT
 
     # MAFFT result parser class.
@@ -51,26 +125,41 @@ module Bio
     # Since a result of MAFFT is simply a multiple-fasta format,
     # the significance of this class is to keep standard form and
     # interface between Bio::ClustalW::Report.
-    class Report
+    class Report < Bio::Alignment::MultiFastaFormat
 
       # Creates a new Report object.
-      # +ary+ should be an Array of Bio::FastaFormat.
-      # +seqclass+ should on of following:
+      # +str+ should be multi-fasta formatted text as a string.
+      #
+      # Compatibility Note: the old usage (to get array of Bio::FastaFormat
+      # objects) is deprecated.
+      #
+      # Compatibility Note 2: the argument +seqclass+ is deprecated.
+      #
+      # +seqclass+ should be one of following:
       # Class:  Bio::Sequence::AA, Bio::Sequence::NA, ...
       # String: 'PROTEIN', 'DNA', ...
-      def initialize(ary, seqclass = nil)
-        @data = ary
-        @align = nil
-        case seqclass
-        when /PROTEIN/i
-          @seqclass = Bio::Sequence::AA
-        when /[DR]NA/i
-          @seqclass = Bio::Sequence::NA
+      #
+      def initialize(str, seqclass = nil)
+        if str.is_a?(Array) then
+          warn "Array of Bio::FastaFormat objects will be no longer accepted."
+          @data = str
         else
-          if seqclass.is_a?(Module) then
-            @seqclass = seqclass
+          super(str)
+        end
+
+        if seqclass then
+          warn "the 2nd argument (seqclass) will be no deprecated."
+          case seqclass
+          when /PROTEIN/i
+            @seqclass = Bio::Sequence::AA
+          when /[DR]NA/i
+            @seqclass = Bio::Sequence::NA
           else
-            @seqclass = Bio::Sequence
+            if seqclass.is_a?(Module) then
+              @seqclass = seqclass
+            else
+              @seqclass = nil
+            end
           end
         end
       end
@@ -79,24 +168,39 @@ module Bio
       attr_reader :data
 
       # Sequence class (Bio::Sequence::AA, Bio::Sequence::NA, ...)
+      #
+      # Compatibility note: This method will be removed in the tufure.
       attr_reader :seqclass
 
       # Gets an multiple alignment.
-      # Returns an instance of Bio::Alignment class.
+      # Returns a Bio::Alignment object.
+      def alignment(method = nil)
+        super
+      end
+
+      # This method will be deprecated. Instead, please use alignment.
+      #
+      # Gets an multiple alignment.
+      # Returns a Bio::Alignment object.
       def align
-        do_parse() unless @align
-        @align
+        warn "Bio::MAFFT::Report#align is deprecated. Please use \'alignment\'."
+        alignment
       end
-      alias alignment align
 
+      # This will be deprecated. Instead, please use alignment.output_fasta.
+      #
       # Gets an fasta-format string of the sequences.
       # Returns a string.
       # Same as align.to_fasta.
-      # Please refer to Bio::Alignment#to_fasta for arguments.
+      # Please refer to Bio::Alignment#output_fasta for arguments.
       def to_fasta(*arg)
-        align.to_fasta(*arg)
+        warn "Bio::MAFFT::report#to_fasta is deprecated. Please use \'alignment.output_fasta\'"
+        alignment.output_fasta(*arg)
       end
 
+      # Compatibility note: Behavior of the method will be changed
+      # in the future.
+      #
       # Gets an array of the sequences.
       # Returns an array of Bio::FastaFormat instances.
       def to_a
@@ -105,12 +209,15 @@ module Bio
 
       private
       # Parsing a result.
-      def do_parse
-        return nil if @align
-        @align = Bio::Alignment.new(@data) do |x|
-          [ @seqclass.new(x.seq), x.definition ]
+      def do_parse(ary, seqmethod)
+        if @seqclass then
+          a = Bio::Alignment.new
+          a.add_sequences(ary) do |x|
+            [ @seqclass.new(x.seq), x.definition ]
+          end
+        else
+          super(ary, seqmethod)
         end
-        nil
       end
 
     end #class Report

data/lib/bio/appl/muscle.rb

@@ -0,0 +1,52 @@
+#
+# = bio/appl/muscle.rb - MUSCLE application wrapper class
+#
+# Copyright:: Copyright (C) 2006-2007
+#             Jeffrey Blakeslee and John Conery University of Oregon <jeffb@uoregon.edu>
+#             Naohisa Goto <ng@bioruby.org>
+# License::   The Ruby License
+#
+#  $Id: muscle.rb,v 1.1 2007/07/16 12:25:50 ngoto Exp $
+#
+#
+# Bio::Muscle is a wrapper class to execute MUSCLE.
+#
+# == References
+#
+# * http://www.drive5.com/muscle/
+# * Edgar R.C.
+#   MUSCLE: multiple sequence alignment with high accuracy and
+#   high throughput. Nucleic Acids Res. 32: 1792-1797, 2004.
+# * Edgar, R.C.
+#   MUSCLE: a multiple sequence alignment method with reduced time
+#   and space complexity. BMC Bioinformatics 5: 113, 2004.
+#
+
+module Bio
+
+  # Bio::Muscle is a wrapper class to execute MUSCLE.
+  #
+  # Please refer documents in bio/apple/muscle.rb for references.
+  class Muscle < Bio::Alignment::FactoryTemplate::StdinInFileOut
+
+    # default program name
+    DEFAULT_PROGRAM = 'muscle'.freeze
+
+    # default report parser
+    DEFAULT_PARSER = Bio::Alignment::MultiFastaFormat
+
+    private
+    # generates options specifying input filename.
+    # returns an array of string
+    def _option_input_file(fn)
+      [ '-in', fn ]
+    end
+
+    # generates options specifying output filename.
+    # returns an array of string
+    def _option_output_file(fn)
+      [ '-out', fn ]
+    end
+  end #class Muscle
+
+end #module Bio

data/lib/bio/appl/phylip/alignment.rb

@@ -0,0 +1,129 @@
+#
+# = bio/appl/phylip/alignment.rb - phylip multiple alignment format parser
+#
+# Copyright:: Copyright (C) 2006
+#             GOTO Naohisa <ng@bioruby.org>
+#
+# License:: The Ruby License
+#
+#  $Id: alignment.rb,v 1.2 2007/04/05 23:35:40 trevor Exp $
+#
+# = About Bio::Phylip::PhylipFormat
+#
+# Please refer document of Bio::Phylip::PhylipFormat class.
+#
+
+module Bio
+  module Phylip
+
+    # This is phylip multiple alignment format parser.
+    # The two formats, interleaved and non-interleaved, are
+    # automatically determined.
+    #
+    class PhylipFormat
+
+      # create a new object from a string
+      def initialize(str)
+        @data = str.strip.split(/(?:\r\n|\r|\n)/)
+        @first_line = @data.shift
+        @number_of_sequences, @alignment_length =
+          @first_line.to_s.strip.split(/\s+/).collect { |x| x.to_i }
+      end
+
+      # number of sequences
+      attr_reader :number_of_sequences
+
+      # alignment length
+      attr_reader :alignment_length
+
+      # If the alignment format is "interleaved", returns true.
+      # If not, returns false.
+      # It would mistake to determine if the alignment is very short.
+      def interleaved?
+        unless defined? @interleaved_flag then
+          if /\A +/ =~ @data[1].to_s then
+            @interleaved_flag = false
+          else
+            @interleaved_flag = true
+          end
+        end
+        @interleaved_flag
+      end
+
+      # Gets the alignment. Returns a Bio::Alignment object.
+      def alignment
+        unless defined? @alignment then
+          do_parse
+          a = Bio::Alignment.new
+          (0...@number_of_sequences).each do |i|
+            a.add_seq(@sequences[i], @sequence_names[i])
+          end
+          @alignment = a
+        end
+        @alignment
+      end
+
+      private
+
+      def do_parse
+        if interleaved? then
+          do_parse_interleaved
+        else
+          do_parse_noninterleaved
+        end
+      end
+
+      def do_parse_interleaved
+        first_block = @data[0, @number_of_sequences]
+        @data[0, @number_of_sequences] = ''
+        @sequence_names = Array.new(@number_of_sequences) { '' }
+        @sequences = Array.new(@number_of_sequences) do
+          ' ' * @alignment_length
+        end
+        first_block.each_with_index do |x, i|
+          n, s = x.split(/ +/, 2)
+          @sequence_names[i] = n
+          @sequences[i].replace(s.gsub(/\s+/, ''))
+        end
+        i = 0
+        @data.each do |x|
+          if x.strip.length <= 0 then
+            i = 0
+          else
+            @sequences[i] << x.gsub(/\s+/, '')
+            i = (i + 1) % @number_of_sequences
+          end
+        end
+        @data.clear
+        true
+      end
+
+      def do_parse_noninterleaved
+        @sequence_names = Array.new(@number_of_sequences) { '' }
+        @sequences = Array.new(@number_of_sequences) do
+          ' ' * @alignment_length
+        end
+        curseq = nil
+        i = 0
+        @data.each do |x|
+          next if x.strip.length <= 0
+          if !curseq or
+              curseq.length > @alignment_length or /^\s/ !~ x then
+            p i
+            n, s = x.strip.split(/ +/, 2)
+            @sequence_names[i] = n
+            curseq = @sequences[i]
+            curseq.replace(s.gsub(/\s+/, ''))
+            i += 1
+          else
+            curseq << x.gsub(/\s+/, '')
+          end
+        end
+        @data.clear
+        true
+      end
+
+    end #class PhylipFormat
+  end #module Phylip
+end #module Bio
+

data/lib/bio/appl/phylip/distance_matrix.rb

@@ -0,0 +1,96 @@
+#
+# = bio/appl/phylip/distance_matrix.rb - phylip distance matrix parser
+#
+# Copyright:: Copyright (C) 2006
+#             GOTO Naohisa <ng@bioruby.org>
+#
+# License:: The Ruby License
+#
+#  $Id: distance_matrix.rb,v 1.3 2007/04/05 23:35:40 trevor Exp $
+#
+# = About Bio::Phylip::DistanceMatrix
+#
+# Please refer document of Bio::Phylip::DistanceMatrix class.
+#
+
+require 'matrix'
+
+module Bio
+  module Phylip
+
+    # This is a parser class for phylip distance matrix data
+    # created by dnadist, protdist, or restdist commands.
+    #
+    class DistanceMatrix
+
+      # creates a new distance matrix object
+      def initialize(str)
+        data = str.strip.split(/(?:\r\n|\r|\n)/)
+        @otus = data.shift.to_s.strip.to_i
+        prev = nil
+        data.collect! do |x|
+          if /\A +/ =~ x and prev then
+            prev.concat x.strip.split(/\s+/)
+            nil
+          else
+            prev = x.strip.split(/\s+/)
+            prev
+          end
+        end
+        data.compact!
+        if data.size != @otus then
+          raise "inconsistent data (OTUs=#{@otus} but #{data.size} rows)"
+        end
+        @otu_names = data.collect { |x| x.shift }
+        mat = data.collect do |x|
+          if x.size != @otus then
+            raise "inconsistent data (OTUs=#{@otus} but #{x.size} columns)"
+          end
+          x.collect { |y| y.to_f }
+        end
+        @matrix = Matrix.rows(mat, false)
+        @original_matrix = Matrix.rows(data, false)
+      end
+
+      # distance matrix (returns Ruby's Matrix object)
+      attr_reader :matrix
+
+      # matrix contains values as original strings.
+      # Use it when you doubt precision of floating-point numbers.
+      attr_reader :original_matrix
+
+      # number of OTUs
+      attr_reader :otus
+
+      # names of OTUs
+      attr_reader :otu_names
+
+      # Generates a new phylip distance matrix formatted text as a string.
+      def self.generate(matrix, otu_names = nil, options = {})
+        if matrix.row_size != matrix.column_size then
+          raise "must be a square matrix"
+        end
+        otus = matrix.row_size
+        names = (0...otus).collect do |i|
+          name = ((otu_names and otu_names[i]) or "OTU#{i.to_s}")
+          name
+        end
+        data = (0...otus).collect do |i|
+          x = (0...otus).collect { |j|  sprintf("%9.6f", matrix[i, j]) }
+          x.unshift(sprintf("%-10s", names[i])[0, 10])
+
+          str = x[0, 7].join(' ') + "\n"
+          7.step(otus + 1, 7) do |k|
+            str << ' ' + x[k, 7].join(' ') + "\n"
+          end
+          str
+        end
+        sprintf("%5d\n", otus) + data.join('')
+      end
+        
+    end #class DistanceMatrix
+
+  end #module Phylip
+
+end #module Bio
+