bio 1.0.0 → 1.1.0

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

@@ -5,9 +5,9 @@
 #               Hiroshi Suga <suga@biophys.kyoto-u.ac.jp>,
 # Copyright::   Copyright (C) 2005 
 #               Masashi Fujita <fujita@kuicr.kyoto-u.ac.jp>
-# Lisence::     LGPL
+# License::     The Ruby License
 #
-# $Id: report.rb,v 1.10 2006/02/02 17:08:36 nakao Exp $
+# $Id: report.rb,v 1.13 2007/04/05 23:35:40 trevor Exp $
 #
 # == Description
 #
@@ -38,24 +38,6 @@
 # * HMMER
 #   http://hmmer.wustl.edu/
 #
-#--
-#
-#  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
-#
-#++
-#
 
 require 'bio/appl/hmmer'
 

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

@@ -0,0 +1,374 @@
+#
+# = bio/appl/iprscan/report.rb - a class for iprscan output.
+#
+# Copyright::   Copyright (C) 2006
+#               Mitsuteru C. Nakao <mn@kazusa.or.jp>
+# License::     The Ruby License
+#
+#  $Id: report.rb,v 1.9 2007/07/18 11:11:57 nakao Exp $
+#
+# == Report classes for the iprscan program.
+# 
+
+
+module Bio
+
+  class Iprscan
+
+    # = DESCRIPTION
+    # Class for InterProScan report. It is used to parse results and reformat 
+    # results from (raw|xml|txt) into (html, xml, ebihtml, txt, gff3) format.
+    #
+    # See ftp://ftp.ebi.ac.uk/pub/software/unix/iprscan/README.html
+    # 
+    # == USAGE
+    #  # Read a marged.txt and split each entry.
+    #  Bio::Iprscan::Report.parse_txt(File.read("marged.txt")) do |report| 
+    #    report.query_id
+    #    report.matches.size
+    #    report.matches.each do |match|
+    #      match.ipr_id #=> 'IPR...'
+    #      match.ipr_description
+    #      match.method
+    #      match.accession
+    #      match.description
+    #      match.match_start
+    #      match.match_end
+    #      match.evalue    
+    #    end
+    #    # report.to_gff3 
+    #    # report.to_html
+    #  end
+    #
+    #  Bio::Iprscan::Report.parse_raw(File.read("marged.raw")) do |report| 
+    #    report.class #=> Bio::Iprscan::Report
+    #  end
+    #
+    class Report
+      # Entry delimiter pattern.
+      RS = DELIMITER = "\n\/\/\n"
+
+      # Qeury sequence name (entry_id).
+      attr_accessor :query_id
+      alias :entry_id :query_id
+
+      # Qeury sequence length.
+      attr_accessor :query_length
+
+      # CRC64 checksum of query sequence.
+      attr_accessor :crc64
+
+      # Matched InterPro motifs in Hash. Each InterPro motif have :name, 
+      # :definition, :accession and :motifs keys. And :motifs key contains
+      # motifs in Array. Each motif have :method, :accession, :definition, 
+      # :score, :location_from and :location_to keys.
+      attr_accessor :matches
+      
+      # == USAGE
+      #  Bio::Iprscan::Report.parse_raw(File.open("merged.raw")) do |report|
+      #    report
+      #  end
+      #
+      def self.parse_raw(io)
+        entry = ''
+        while line = io.gets
+          if entry != '' and entry.split("\t").first == line.split("\t").first
+            entry << line
+          elsif entry != ''
+            yield Bio::Iprscan::Report.parse_raw_entry(entry)
+            entry = line
+          else
+            entry << line
+          end
+        end
+        yield Bio::Iprscan::Report.parse_raw_entry(entry) if entry != ''
+      end
+    
+      # Parser method for a raw formated entry. Retruns a Bio::Iprscan::Report 
+      # object.
+      def self.parse_raw_entry(str)
+        report = self.new
+        str.split(/\n/).each do |line|
+          line = line.split("\t")
+          report.matches << Match.new(:query_id => line[0],
+                                      :crc64    => line[1],
+                                      :query_length => line[2].to_i,
+                                      :method       => line[3], 
+                                      :accession    => line[4],
+                                      :description => line[5], 
+                                      :match_start => line[6].to_i,
+                                      :match_end   => line[7].to_i,
+                                      :evalue => line[8],
+                                      :status => line[9],
+                                      :date   => line[10])
+          if line[11]
+            report.matches.last.ipr_id = line[11]
+            report.matches.last.ipr_description = line[12]
+          end
+          report.matches.last.go_terms = line[13].scan(/(\w+ \w+\:.+? \(GO:\d+\))/).flatten if line[13]          
+        end
+        report.query_id = report.matches.first.query_id
+        report.query_length = report.matches.first.query_length
+        report
+      end
+
+
+
+      # Parser method for a xml formated entry. Retruns a Bio::Iprscan::Report 
+      # object.
+#      def self.parse_xml(str)
+#      end
+
+      # Splits the entry stream.
+      # 
+      # == Usage
+      #
+      #  Bio::Iprscan::Report.reports_txt(File.open("merged.txt")) do |report|
+      #    report.class #=> Bio::Iprscan::Report
+      #  end
+      #
+      def self.parse_txt(io)
+        io.each("\n\nSequence") do |entry|
+          if entry =~ /Sequence$/
+            entry = entry.sub(/Sequence$/, '')
+          end
+          unless entry =~ /^Sequence/
+            entry = 'Sequence' + entry
+          end
+          yield self.parse_txt_entry(entry)
+        end
+      end
+
+
+
+      # Parser method for a txt formated entry. Returns a Bio::Iprscan::Report
+      # object.
+      #
+      def self.parse_txt_entry(str)
+        unless str =~ /^Sequence /
+          raise ArgumentError, "Invalid format:  \n\n#{str}"
+        end
+        header, *matches = str.split(/\n\n/)
+        report = self.new
+        report.query_id = if header =~ /Sequence \"(.+)\" / then $1 else '' end
+        report.query_length = if header =~ /length: (\d+) aa./ then $1.to_i else nil end
+        report.crc64 = if header =~ /crc64 checksum: (\S+) / then $1 else nil end
+        ipr_line = ''
+        go_annotation = ''
+        matches.each do |m|
+          m = m.split(/\n/).map {|x| x.split(/  +/) }
+          m.each do |match|
+            case match[0]
+            when 'method'
+            when /(Molecular Function|Cellular Component|Biological Process):/
+              go_annotation = match[0].scan(/([MCB]\w+ \w+): (\S.+?\S) \((GO:\d+)\),*/)
+            when 'InterPro'
+              ipr_line = match
+            else
+              pos_scores = match[3].scan(/(\S)\[(\d+)-(\d+)\] (\S+) */)
+              pos_scores.each do |pos_score|
+                report.matches << Match.new(:ipr_id          => ipr_line[1],
+                                            :ipr_description => ipr_line[2],
+                                            :method      => match[0], 
+                                            :accession   => match[1],
+                                            :description => match[2], 
+                                            :evalue      => pos_score[3],
+                                            :status      => pos_score[0],
+                                            :match_start => pos_score[1].to_i,
+                                            :match_end   => pos_score[2].to_i,
+                                            :go_terms => go_annotation)
+              end
+            end
+          end
+        end
+        return report
+      end 
+
+
+      # Splits entry stream.
+      # 
+      # == Usage
+      #  Bio::Iprscan::Report.parse_ptxt(File.open("merged.txt")) do |report|
+      #    report
+      #  end
+      def self.parse_ptxt(io)
+        io.each("\n\/\/\n") do |entry|
+          yield self.parse_ptxt_entry(entry)
+        end
+      end
+
+      # Parser method for a pseudo-txt formated entry. Retruns a Bio::Iprscan::Report 
+      # object.
+      # 
+      # == Usage
+      #
+      #  File.read("marged.txt").each(Bio::Iprscan::Report::RS) do |e| 
+      #    report = Bio::Iprscan::Report.parse_ptxt_entry(e)
+      #  end
+      #
+      def self.parse_ptxt_entry(str)
+        report = self.new
+        ipr_line = ''
+        str.split(/\n/).each do |line|
+          line = line.split("\t")
+          if line.size == 2
+            report.query_id = line[0]
+            report.query_length = line[1].to_i
+          elsif line.first == '//'
+          elsif line.first == 'InterPro'
+            ipr_line = line
+          else
+            startp, endp = line[4].split("-")
+            report.matches << Match.new(:ipr_id => ipr_line[1], 
+                                        :ipr_description => ipr_line[2],
+                                        :method => line[0], 
+                                        :accession => line[1],
+                                        :description => line[2], 
+                                        :evalue => line[3],
+                                        :match_start => startp.to_i,
+                                        :match_end => endp.to_i)
+          end
+        end
+        report
+      end
+
+      # 
+      def initialize
+        @query_id = nil
+        @query_length = nil
+        @crc64 = nil
+        @matches = []
+      end
+
+
+      # Output interpro matches in the format_type.
+      def output(format_type)
+        case format_type
+        when 'raw', :raw
+          format_raw
+        else
+          raise NameError, "Invalid format_type."
+        end
+      end
+
+#      def format_html
+#      end
+      
+#      def format_xml
+#      end
+      
+#      def format_ebixml
+#      end
+      
+#      def format_txt
+#      end
+      
+      def format_raw
+        @matches.map { |match|
+          [self.query_id,
+           self.crc64,
+           self.query_length,
+           match.method_name,
+           match.accession,
+           match.description,
+           match.match_start,
+           match.match_end,
+           match.evalue,
+           match.status,
+           match.date,
+           match.ipr_id,
+           match.ipr_description,
+           match.go_terms.map {|x| x[0] + ': ' + x[1] + ' (' + x[2] + ')' }.join(', ')
+          ].join("\t")
+        }.join("\n")
+      end
+      
+#      def format_gff3
+#      end
+
+
+      # Returns a Hash (key as an Interpro ID and value as a Match).
+      #
+      #   report.to_hash.each do |ipr_id, matches|
+      #     matches.each do |match|
+      #       report.matches.ipr_id == ipr_id #=> true
+      #     end
+      #   end
+      #
+      def to_hash
+        unless @ipr_ids
+          @ipr_ids = {} 
+          @matches.each_with_index do |match, i|
+            @ipr_ids[match.ipr_id] ||= []
+            @ipr_ids[match.ipr_id] << match
+          end
+          return @ipr_ids
+        else
+          return @ipr_ids
+        end
+      end
+
+
+
+      # == Description
+      # Container class for InterProScan matches.
+      #
+      # == Usage
+      #  match = Match.new(:query_id => ...)
+      #
+      #  match.ipr_id = 'IPR001234'
+      #  match.ipr_id #=> 'IPR001234'
+      #
+      class Match
+        def initialize(hash)
+          @data = Hash.new
+          hash.each do |key, value|
+            @data[key.to_sym] = value
+          end
+        end
+
+        # Date for computation.
+        def date;            @data[:date];            end
+        # CRC64 checksum of query sequence.
+        def crc64;           @data[:crc64];           end
+        # E-value of the match
+        def evalue;          @data[:evalue];          end
+        # Status of the match (T for true / M for marginal).
+        def status;          @data[:status];          end
+        # the corresponding InterPro entry (if any).
+        def ipr_id;          @data[:ipr_id];          end
+        # the length of the sequence in AA.
+        def length;          @data[:length];          end
+        # the analysis method launched.
+        def method_name;          @data[:method];          end
+        # the Gene Ontology description for the InterPro entry, in "Aspect :term (ID)" format.
+        def go_terms;        @data[:go_terms];        end
+        # Id of the input sequence.
+        def query_id;        @data[:query_id];        end
+        # the end of the domain match.
+        def match_end;       @data[:match_end];       end
+        # the database members entry for this match.
+        def accession;       @data[:accession];       end
+        # the database mambers description for this match.
+        def description;     @data[:description];     end
+        # the start of the domain match.
+        def match_start;     @data[:match_start];     end
+        # the descriotion of the InterPro entry.
+        def ipr_odescription; @data[:ipr_description]; end
+
+        def method_missing(name, arg = nil)
+          if arg
+            name = name.to_s.sub(/=$/, '') 
+            @data[name.to_sym] = arg 
+          else
+            @data[name.to_sym]
+          end
+        end
+
+      end # class Match
+
+    end # class Report
+
+  end # class Iprscan
+
+end # module Bio

data/lib/bio/appl/mafft.rb

@@ -2,25 +2,9 @@
 # = bio/appl/mafft.rb - MAFFT wrapper class
 #
 # Copyright:: Copyright (C) 2003 GOTO Naohisa <ngoto@gen-info.osaka-u.ac.jp>
-# License::   LGPL
+# 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: mafft.rb,v 1.9 2005/12/18 15:58:40 k Exp $
+#  $Id: mafft.rb,v 1.18 2007/07/16 12:27:29 ngoto Exp $
 #
 # Bio::MAFFT is a wrapper class to execute MAFFT.
 # MAFFT is a very fast multiple sequence alignment software.
@@ -39,14 +23,13 @@
 # * http://www.biophys.kyoto-u.ac.jp/~katoh/programs/align/mafft/
 #
 
+require 'tempfile'
+
+require 'bio/command'
+
 require 'bio/db/fasta'
 require 'bio/io/flatfile'
 
-#--
-# We use Open3.popen3, because MAFFT on win32 requires Cygwin.
-#++
-require 'open3'
-
 module Bio
 
   # Bio::MAFFT is a wrapper class to execute MAFFT.
@@ -122,62 +105,116 @@ module Bio
     # Creates a new alignment factory.
     # +program+ is the name of the program.
     # +opt+ is options of the program.
-    def initialize(program, option)
+    def initialize(program = 'mafft', opt = [])
       @program = program
-      @option = option
+      @options = opt
       @command = nil
       @output = nil
       @report = nil
-      @log = nil
+      @data_stdout = nil
+      @exit_status = nil
     end
 
-    # program name
+    # program name (usually 'mafft' in UNIX)
     attr_accessor :program
 
     # options
-    attr_accessor :option
+    attr_accessor :options
+
+    # option is deprecated. Instead, please use options.
+    def option
+      warn "Bio::MAFFT#option is deprecated. Please use options."
+      options
+    end
 
     # Shows last command-line string. Returns nil or an array of String.
     # Note that filenames described in the command-line may already
     # be removed because they are temporary files.
     attr_reader :command
 
+    #---
     # last message to STDERR when executing the program.
-    attr_reader :log
+    #attr_reader :log
+    #+++
+
+    #log is deprecated (no replacement) and returns empty string.
+    def log
+      warn "Bio::MAFFT#log is deprecated (no replacement) and returns empty string."
+      ''
+    end
 
     # Shows latest raw alignment result.
-    # Since a result of MAFFT is simply a multiple-fasta format,
-    # it returns an array of Bio::FastaFormat instances
-    # instead of raw string.
+    # Return a string. (Changed in bioruby-1.1.0).
+    # Compatibility note:
+    # If you want an array of Bio::FastaFormat instances,
+    # you should use report.data instead.
     attr_reader :output
 
     # Shows last alignment result (instance of Bio::MAFFT::Report class)
     # performed by the factory.
     attr_reader :report
 
+    # Last exit status
+    attr_reader :exit_status
+
+    # Last output to the stdout.
+    attr_accessor :data_stdout
+    
+    # Clear the internal data and status, except program and options.
+    def reset
+      @command = nil
+      @output = nil
+      @report = nil
+      @exit_status = nil
+      @data_stdout = nil
+    end
+
     # Executes the program.
     # If +seqs+ is not nil, perform alignment for seqs.
     # If +seqs+ is nil, simply executes the program.
+    #
+    # Compatibility note: When seqs is nil,
+    # returns true if the program exits normally, and
+    # returns false if the program exits abnormally.
     def query(seqs)
       if seqs then
         query_align(seqs)
       else
-        exec_local(@option)
+        exec_local(@options)
+        @exit_status.exitstatus == 0 ? true : false
       end
     end
 
+    # Note that this method will be renamed to query_alignment.
+    #
     # Performs alignment for seqs.
     # +seqs+ should be Bio::Alignment or Array of sequences or nil.
+    #
+    # Compatibility Note: arg is deprecated and ignored.
     def query_align(seqs, *arg)
+      if arg.size > 0 then
+        warn '2nd and other arguments of Bio::MAFFT#query_align is ignored'
+      end
       unless seqs.is_a?(Bio::Alignment)
-        seqs = Bio::Alignment.new(seqs, *arg)
+        seqs = Bio::Alignment.new(seqs)
       end
-      query_string(seqs.to_fasta(70))
+      query_string(seqs.output_fasta(:width => 70))
+    end
+
+    # Performs alignment for seqs.
+    # +seqs+ should be Bio::Alignment or Array of sequences or nil.
+    def query_alignment(seqs)
+      query_align(seqs)
     end
 
     # Performs alignment for +str+.
     # Str should be a string that can be recognized by the program.
+    #
+    # Compatibility Note: arg is deprecated and ignored.
     def query_string(str, *arg)
+      if arg.size > 0 then
+        warn '2nd and other arguments of Bio::MAFFT#query_string is ignored'
+      end
       begin
         tf_in = Tempfile.open('align')
         tf_in.print str
@@ -190,10 +227,15 @@ module Bio
     end
 
     # Performs alignment of sequences in the file named +fn+.
-    def query_by_filename(fn, seqtype = nil)
-      opt = @option + [ fn ]
+    #
+    # Compatibility Note: 2nd argument (seqtype) is deprecated and ignored.
+    def query_by_filename(fn, *arg)
+      if arg.size > 0 then
+        warn '2nd argument of Bio::MAFFT#query_filename is ignored'
+      end
+      opt = @options + [ fn ]
       exec_local(opt)
-      @report = Report.new(@output, seqtype)
+      @report = Report.new(@output)
       @report
     end
 
@@ -202,19 +244,14 @@ module Bio
     def exec_local(opt)
       @command = [ @program, *opt ]
       #STDERR.print "DEBUG: ", @command.join(" "), "\n"
-      @output = nil
-      @log = nil
-      Open3.popen3(*@command) do |din, dout, derr|
-        din.close
-        derr.sync = true
-        t = Thread.start do
-          @log = derr.read
-        end
-        ff = Bio::FlatFile.new(Bio::FastaFormat, dout)
-        @output = ff.to_a
-        t.join
+      @data_stdout = nil
+      @exit_status = nil
+      Bio::Command.call_command(@command) do |io|
+        io.close_write
+        @data_stdout = io.read
       end
-      @log
+      @output = @data_stdout
+      @exit_status = $?
     end
 
   end #class MAFFT