bio 1.0.0 → 1.1.0

data/doc/Tutorial.rd

@@ -2,16 +2,13 @@
 
 See the document in the CVS repository ./doc/((<Tutorial.rd|URL:http://cvs.open-bio.org/cgi-bin/viewcvs/viewcvs.cgi/*checkout*/bioruby/doc/Tutorial.rd?rev=HEAD&cvsroot=bioruby&content-type=text/plain>)) - for a potentially more up-to-date edition. This one was updated:
 
-  $Id: Tutorial.rd,v 1.12 2006/02/17 14:59:26 pjotr Exp $
+  $Id: Tutorial.rd,v 1.13 2007/07/09 12:28:07 pjotr Exp $
 
 Translated into English: Naohisa Goto <ng@bioruby.org>
 
 Editor:                  PjotrPrins <p@bioruby.org>
 
-Copyright (C) 2001-2003 KATAYAMA Toshiaki <k@bioruby.org>, 2005-2006 all
-others
-
-NOTE: This page is a work in progress at this point
+Copyright (C) 2001-2003 KATAYAMA Toshiaki <k@bioruby.org>, 2005-2007 Pjotr Prins, Naohisa Goto and others
 
 IMPORTANT NOTICE: This page is maintained in the BioRuby CVS
 repository. Please edit the file there otherwise changes may get
@@ -38,7 +35,7 @@ version it has with the
 
 command. Showing something like:
 
-  ruby 1.8.2 (2005-04-11) [powerpc-linux]
+  ruby 1.8.5 (2006-08-25) [powerpc-linux]
 
 
 == Trying Bioruby
@@ -96,6 +93,9 @@ defined in codontable.rb).
 
     puts seq.complement.translate       # translation of complemental strand
 
+		counts = {'a'=>seq.count('a'),'c'=>seq.count('c'),'g'=>seq.count('g'),'t'=>seq.count('t')}
+    p randomseq = Bio::Sequence::NA.randomize(counts)  # reshuffle sequence with same freq.
+
 The p, print and puts methods are standard Ruby ways of outputting to
 the screen. If you want to know more about standard Ruby commands you
 can use the 'ri' command on the command line (or the help command in
@@ -462,6 +462,40 @@ Array and BioPerl's Bio::SimpleAlign.  A very simple example is:
   factory = Bio::ClustalW.new
   a2 = a.do_align(factory)
 
+== Restriction Enzymes (Bio::RE)
+
+BioRuby has extensive support for restriction enzymes (REs). It contains a full
+library of commonly used REs (from REBASE) which can be used to cut single
+stranded RNA or dubbel stranded DNA into fragments. To list all enzymes:
+
+  rebase = Bio::RestrictionEnzyme.rebase
+	rebase.each do |enzyme_name, info|
+		p enzyme_name
+  end
+
+and cut a sequence with an enzyme follow up with:
+
+   res = seq.cut_with_enzyme('EcoRII', {:max_permutations => 0}, {:view_ranges => true})
+   if res.kind_of? Symbol #error
+      err = Err.find_by_code(res.to_s)
+      unless err
+        err = Err.new(:code => res.to_s)
+      end
+   end
+	 res.each do |frag|
+	    em = EnzymeMatch.new
+
+      em.p_left = frag.p_left
+      em.p_right = frag.p_right
+      em.c_left = frag.c_left
+      em.c_right = frag.c_right
+
+      em.err = nil
+      em.enzyme = ar_enz
+      em.sequence = ar_seq
+			p em
+    end
+
 
 == Sequence homology search by using the FASTA program (Bio::Fasta)
 
@@ -1123,14 +1157,17 @@ Please refer to KEGG_API.rd.ja (TRANSLATOR'S NOTE: English version: ((<URL:http:
 
   * ((<URL:http://www.genome.jp/kegg/soap/>))
 
+== Comparing BioProjects
+
+For a quick functional comparison of BioRuby, BioPerl, BioPython and Bioconductor (R) see ((<http://sciruby.codeforpeople.com/sr.cgi/BioProjects>))
+
 == Using BioRuby with R
 
-The R libraries can be accessed from Ruby using the @@FIXME
-package. This allows at least use of the standard R library
-functions. Unfortunately there is no binding for dynamic R - so at
-this point you'll have to create some command line interface.
+Using Ruby with R Pjotr wrote a section on SciRuby. See ((<ULR:http://sciruby.codeforpeople.com/sr.cgi/RubyWithRlang>))
+
+== Using BioPerl or BioPython from Ruby
 
-== Using BioPerl from Ruby
+At the moment there is no easy way of accessing BioPerl from Ruby. The best way, perhaps, is to create a Perl server that gets accessed through XML/RPC or SOAP.
 
 == Installing required external library
 

data/lib/bio.rb

@@ -3,14 +3,14 @@
 #
 # Copyright::	Copyright (C) 2001-2006
 #		Toshiaki Katayama <k@bioruby.org>
-# License::	Ruby's
+# License::	The Ruby License
 #
-# $Id: bio.rb,v 1.66 2006/02/27 09:11:01 k Exp $
+# $Id: bio.rb,v 1.86 2007/07/16 12:26:28 ngoto Exp $
 #
 
 module Bio
 
-  BIORUBY_VERSION = [1, 0, 0].extend(Comparable)
+  BIORUBY_VERSION = [1, 1, 0].extend(Comparable)
 
   ### Basic data types
 
@@ -42,7 +42,12 @@ module Bio
 
   autoload :Alignment,      'bio/alignment'
 
+  ## Tree
+  autoload :Tree, 'bio/tree'
 
+  ## Map
+  autoload :Map,            'bio/map'
+	
   ### Constants
 
   autoload :NucleicAcid,    'bio/data/na'
@@ -83,14 +88,15 @@ module Bio
     autoload :GENES,        'bio/db/kegg/genes'
     autoload :ENZYME,       'bio/db/kegg/enzyme'
     autoload :COMPOUND,     'bio/db/kegg/compound'
+    autoload :DRUG,         'bio/db/kegg/drug'
     autoload :GLYCAN,       'bio/db/kegg/glycan'
     autoload :REACTION,     'bio/db/kegg/reaction'
     autoload :BRITE,        'bio/db/kegg/brite'
     autoload :CELL,         'bio/db/kegg/cell'
     autoload :EXPRESSION,   'bio/db/kegg/expression'
-    autoload :Keggtab,      'bio/db/kegg/keggtab'
-    autoload :KO,           'bio/db/kegg/ko'
+    autoload :ORTHOLOGY,    'bio/db/kegg/orthology'
     autoload :KGML,         'bio/db/kegg/kgml'
+    autoload :Taxonomy,     'bio/db/kegg/taxonomy'
   end
 
   ## other formats
@@ -110,13 +116,19 @@ module Bio
   autoload :GO,             'bio/db/go'
   autoload :PDB,            'bio/db/pdb'
   autoload :NBRF,           'bio/db/nbrf'
+  autoload :REBASE,         'bio/db/rebase'
+  autoload :SOFT,           'bio/db/soft'
+  autoload :Lasergene,      'bio/db/lasergene'
 
+  autoload :Newick,         'bio/db/newick'
+  autoload :Nexus,          'bio/db/nexus'
 
   ### IO interface modules
 
   autoload :Registry,       'bio/io/registry'
   autoload :Fetch,          'bio/io/fetch'
   autoload :SQL,            'bio/io/sql'
+  autoload :SOAPWSDL,       'bio/io/soapwsdl'
   autoload :FlatFile,       'bio/io/flatfile'
   autoload :FlatFileIndex,  'bio/io/flatfile/index' # chage to FlatFile::Index ?
   ## below are described in bio/io/flatfile/index.rb
@@ -131,6 +143,8 @@ module Bio
   autoload :DAS,            'bio/io/das'
   autoload :DBGET,          'bio/io/dbget'
 
+  autoload :Ensembl,        'bio/io/ensembl'
+
   ## below are described in bio/appl/blast.rb
   #class Blast
   #  autoload :Fastacmd,     'bio/io/fastacmd'
@@ -149,7 +163,13 @@ module Bio
     autoload :HiGet,        'bio/io/higet'
   end
 
-# autoload :ESOAP,          'bio/io/esoap'      # NCBI::ESOAP ?
+  class EBI
+    autoload :SOAP,         'bio/io/ebisoap'
+  end
+
+  class NCBI
+    autoload :SOAP,       'bio/io/ncbisoap'
+  end
 
 
   ### Applications
@@ -206,6 +226,10 @@ module Bio
   #  autoload :Report,       'bio/appl/mafft/report'
   #end
 
+  autoload :Tcoffee,        'bio/appl/tcoffee'
+  autoload :Muscle,         'bio/appl/muscle'
+  autoload :Probcons,       'bio/appl/probcons'
+
   autoload :Sim4,           'bio/appl/sim4'
   ## below are described in bio/appl/sim4.rb
   #class Sim4
@@ -215,11 +239,40 @@ module Bio
   autoload :Spidey,         'bio/appl/spidey/report'
   autoload :Blat,           'bio/appl/blat/report'
   
+  module GCG
+    autoload :Msf,          'bio/appl/gcg/msf'
+    autoload :Seq,          'bio/appl/gcg/seq'
+  end
+
+  module Phylip
+    autoload :PhylipFormat,   'bio/appl/phylip/alignment'
+    autoload :DistanceMatrix, 'bio/appl/phylip/distance_matrix'
+  end
+
+  autoload :Iprscan,        'bio/appl/iprscan/report'
 
   ### Utilities
 
   autoload :SiRNA,          'bio/util/sirna'
   autoload :ColorScheme,    'bio/util/color_scheme'
+  autoload :ContingencyTable, 'bio/util/contingency_table'
+  autoload :RestrictionEnzyme, 'bio/util/restriction_enzyme'
+
+  ### Service libraries
+  autoload :Command,        'bio/command'
+
+  ### Provide BioRuby shell 'command' also as 'Bio.command' (like ChemRuby)
+
+  def self.method_missing(*args)
+    require 'bio/shell'
+    extend Bio::Shell
+    public_class_method(*Bio::Shell.private_instance_methods)
+    if Bio.respond_to?(args.first)
+      Bio.send(*args)
+    else
+      raise NameError
+    end
+  end
 
 end
 

data/lib/bio/alignment.rb

@@ -1,28 +1,12 @@
 #
 # = bio/alignment.rb - multiple alignment of sequences
 #
-# Copyright:: Copyright (C) 2003, 2005
-#             GOTO Naohisa <ngoto@gen-info.osaka-u.ac.jp>
+# Copyright:: Copyright (C) 2003, 2005, 2006
+#             GOTO Naohisa <ng@bioruby.org>
 #
-# License:: LGPL
+# License:: The Ruby License
 #
-#  $Id: alignment.rb,v 1.15 2006/01/24 14:16:59 ngoto Exp $
-#
-#--
-#  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: alignment.rb,v 1.23 2007/07/16 12:21:39 ngoto Exp $
 #
 # = About Bio::Alignment
 #
@@ -37,52 +21,59 @@
 # http://doc.bioperl.org/releases/bioperl-1.4/Bio/SimpleAlign.html
 #
 
+require 'tempfile'
+require 'bio/command'
 require 'bio/sequence'
 
-module Bio
-
-=begin rdoc
-
-= About Bio::Alignment
-
-Bio::Alignment is a namespace of classes/modules for multiple sequence
-alignment.
-
-= Multiple alignment container classes
-
-== Bio::Alignment::OriginalAlignment
-
-== Bio::Alignment::SequenceArray
-
-== Bio::Alignment::SequenceHash
-
-= Bio::Alignment::Site
-
-= Modules
-
-== Bio::Alignment::EnumerableExtension
-
-Mix-in for classes included Enumerable.
-
-== Bio::Alignment::ArrayExtension
-
-Mix-in for Array or Array-like classes.
+#---
+# (depends on autoload)
+#require 'bio/appl/gcg/seq'
+#+++
 
-== Bio::Alignment::HashExtension
-
-Mix-in for Hash or Hash-like classes.
-
-== Bio::Alignment::SiteMethods
-
-== Bio::Alignment::PropertyMethods
-
-= Bio::Alignment::GAP
-
-= Compatibility from older BioRuby
+module Bio
 
-=end
+# 
+# = About Bio::Alignment
+# 
+# Bio::Alignment is a namespace of classes/modules for multiple sequence
+# alignment.
+# 
+# = Multiple alignment container classes
+# 
+# == Bio::Alignment::OriginalAlignment
+# 
+# == Bio::Alignment::SequenceArray
+# 
+# == Bio::Alignment::SequenceHash
+# 
+# = Bio::Alignment::Site
+# 
+# = Modules
+# 
+# == Bio::Alignment::EnumerableExtension
+# 
+# Mix-in for classes included Enumerable.
+# 
+# == Bio::Alignment::ArrayExtension
+# 
+# Mix-in for Array or Array-like classes.
+# 
+# == Bio::Alignment::HashExtension
+# 
+# Mix-in for Hash or Hash-like classes.
+# 
+# == Bio::Alignment::SiteMethods
+# 
+# == Bio::Alignment::PropertyMethods
+# 
+# = Bio::Alignment::GAP
+# 
+# = Compatibility from older BioRuby
+# 
   module Alignment
 
+    autoload :MultiFastaFormat, 'bio/appl/mafft/report'
+
     # Bio::Alignment::PropertyMethods is a set of methods to treat
     # the gap character and so on.
     module PropertyMethods
@@ -640,10 +631,14 @@ Mix-in for Hash or Hash-like classes.
             amino = true
           elsif seqclass == Bio::Sequence::NA then
             amino = false
-          elsif self.find { |x| /[EFILPQ]/i =~ x } then
-            amino = true
           else
             amino = nil
+            self.each_seq do |x|
+              if /[EFILPQ]/i =~ x
+                amino = true
+                break
+              end
+            end
           end
         end
         if amino then
@@ -873,16 +868,31 @@ Mix-in for Hash or Hash-like classes.
       end
     end #module EnumerableExtension
 
-    # ClustalWFormatter is a module to create ClustalW-formatted text
-    # from an alignment object.
-    #
-    # It will be obsoleted and the methods will be frequently changed.
-    module ClustalWFormatter
-      # Check whether there are same names.
+    module Output
+      def output(format, *arg)
+        case format
+        when :clustal
+          output_clustal(*arg)
+        when :fasta
+          output_fasta(*arg)
+        when :phylip
+          output_phylip(*arg)
+        when :phylipnon
+          output_phylipnon(*arg)
+        when :msf
+          output_msf(*arg)
+        when :molphy
+          output_molphy(*arg)
+        else
+          raise "Unknown format: #{format.inspect}"
+        end
+      end
+
+      # Check whether there are same names for ClustalW format.
       #
       # array:: names of the sequences (array of string)
       # len::   length to check (default:30)
-      def have_same_name?(array, len = 30)
+      def __clustal_have_same_name?(array, len = 30)
         na30 = array.collect do |k|
           k.to_s.split(/[\x00\s]/)[0].to_s[0, len].gsub(/\:\;\,\(\)/, '_').to_s
         end
@@ -909,15 +919,16 @@ Mix-in for Hash or Hash-like classes.
           false
         end
       end
-      private :have_same_name?
+      private :__clustal_have_same_name?
 
-      # Changes sequence names if there are conflicted names.
+      # Changes sequence names if there are conflicted names
+      # for ClustalW format.
       #
       # array:: names of the sequences (array of string)
       # len::   length to check (default:30)
-      def avoid_same_name(array, len = 30)
+      def __clustal_avoid_same_name(array, len = 30)
         na = array.collect { |k| k.to_s.gsub(/[\r\n\x00]/, ' ') }
-        if dupidx = have_same_name?(na, len)
+        if dupidx = __clustal_have_same_name?(na, len)
           procs = [
             Proc.new { |s, i|
               s[0, len].to_s.gsub(/\s/, '_') + s[len..-1].to_s
@@ -931,7 +942,7 @@ Mix-in for Hash or Hash-like classes.
               s = array[i]
               na[i] = pr.call(s.to_s, i)
             end
-            dupidx = have_same_name?(na, len)
+            dupidx = __clustal_have_same_name?(na, len)
             break unless dupidx
           end
           if dupidx then
@@ -942,13 +953,13 @@ Mix-in for Hash or Hash-like classes.
         end
         na
       end
-      private :avoid_same_name
+      private :__clustal_avoid_same_name
 
       # Generates ClustalW-formatted text
       # seqs:: sequences (must be an alignment object)
       # names:: names of the sequences
       # options:: options
-      def clustalw_formatter(seqs, names, options = {})
+      def __clustal_formatter(seqs, names, options = {})
         #(original)
         aln = [ "CLUSTAL   (0.00) multiple sequence alignment\n\n" ]
         len = seqs.seq_length
@@ -963,7 +974,7 @@ Mix-in for Hash or Hash-like classes.
           sn.collect! { |x| x.split(/\s/)[0].to_s }
         end
         if !options.has_key?(:avoid_same_name) or options[:avoid_same_name]
-          sn = avoid_same_name(sn)
+          sn = __clustal_avoid_same_name(sn)
         end
         
         if sn.find { |x| x.length > 10 } then
@@ -988,8 +999,9 @@ Mix-in for Hash or Hash-like classes.
         end
         mline = (options[:match_line] or seqs.match_line(mopt))
         
-        aseqs = seqs.collect do |s|
-          s.to_s.gsub(seqs.gap_regexp, gchar)
+        aseqs = Array.new(seqs.number_of_sequences).clear
+        seqs.each_seq do |s|
+          aseqs << s.to_s.gsub(seqs.gap_regexp, gchar)
         end
         case options[:case].to_s
         when /lower/i
@@ -1023,9 +1035,295 @@ Mix-in for Hash or Hash-like classes.
         end
         aln.join('')
       end
-      private :clustalw_formatter
-    end #module ClustalWFormatter
+      private :__clustal_formatter
+
+      # Generates ClustalW-formatted text
+      # seqs:: sequences (must be an alignment object)
+      # names:: names of the sequences
+      # options:: options
+      def output_clustal(options = {})
+        __clustal_formatter(self, self.sequence_names, options)
+      end
+
+      # to_clustal is deprecated. Instead, please use output_clustal.
+      #---
+      #alias to_clustal output_clustal
+      #+++
+      def to_clustal(*arg)
+        warn "to_clustal is deprecated. Please use output_clustal."
+        output_clustal(*arg)
+      end
+
+      # Generates fasta format text and returns a string.
+      def output_fasta(options={})
+        #(original)
+        width = (options[:width] or 70)
+        if options[:avoid_same_name] then
+          na = __clustal_avoid_same_name(self.sequence_names, 30)
+        else
+          na = self.sequence_names.collect do |k|
+            k.to_s.gsub(/[\r\n\x00]/, ' ')
+          end
+        end
+        if width and width > 0 then
+          w_reg = Regexp.new(".{1,#{width}}")
+          self.collect do |s|
+            ">#{na.shift}\n" + s.to_s.gsub(w_reg, "\\0\n")
+          end.join('')
+        else
+          self.collect do |s|
+            ">#{na.shift}\n" + s.to_s + "\n"
+          end.join('')
+        end
+      end
+
+      # generates phylip interleaved alignment format as a string
+      def output_phylip(options = {})
+        aln, aseqs, lines = __output_phylip_common(options)
+        lines.times do
+          aseqs.each { |a| aln << a.shift }
+          aln << "\n"
+        end
+        aln.pop if aln[-1] == "\n"
+        aln.join('')
+      end
 
+      # generates Phylip3.2 (old) non-interleaved format as a string
+      def output_phylipnon(options = {})
+        aln, aseqs, lines = __output_phylip_common(options)
+        aln.first + aseqs.join('')
+      end
+
+      # common routine for interleaved/non-interleaved phylip format
+      def __output_phylip_common(options = {})
+        len = self.alignment_length
+        aln = [ " #{self.number_of_sequences} #{len}\n" ]
+        sn = self.sequence_names.collect { |x| x.to_s.gsub(/[\r\n\x00]/, ' ') }
+        if options[:replace_space]
+          sn.collect! { |x| x.gsub(/\s/, '_') }
+        end
+        if !options.has_key?(:escape) or options[:escape]
+          sn.collect! { |x| x.gsub(/[\:\;\,\(\)]/, '_') }
+        end
+        if !options.has_key?(:split) or options[:split]
+          sn.collect! { |x| x.split(/\s/)[0].to_s }
+        end
+        if !options.has_key?(:avoid_same_name) or options[:avoid_same_name]
+          sn = __clustal_avoid_same_name(sn, 10)
+        end
+
+        namewidth = 10
+        seqwidth  = (options[:width] or 60)
+        seqwidth = seqwidth.div(10) * 10
+        seqregexp = Regexp.new("(.{1,#{seqwidth.div(10) * 11}})")
+        gchar = (options[:gap_char] or '-')
+
+        aseqs = Array.new(self.number_of_sequences).clear
+        self.each_seq do |s|
+          aseqs << s.to_s.gsub(self.gap_regexp, gchar)
+        end
+        case options[:case].to_s
+        when /lower/i
+          aseqs.each { |s| s.downcase! }
+        when /upper/i
+          aseqs.each { |s| s.upcase! }
+        end
+        
+        aseqs.collect! do |s|
+          snx = sn.shift
+          head = sprintf("%*s", -namewidth, snx.to_s)[0, namewidth]
+          head2 = ' ' * namewidth
+          s << (gchar * (len - s.length))
+          s.gsub!(/(.{1,10})/n, " \\1")
+          s.gsub!(seqregexp, "\\1\n")
+          a = s.split(/^/)
+          head += a.shift
+          ret = a.collect { |x| head2 + x }
+          ret.unshift(head)
+          ret
+        end
+        lines = (len + seqwidth - 1).div(seqwidth)
+        [ aln, aseqs, lines ]
+      end
+
+      # Generates Molphy alignment format text as a string
+      def output_molphy(options = {})
+        len = self.alignment_length
+        header = "#{self.number_of_sequences} #{len}\n"
+        sn = self.sequence_names.collect { |x| x.to_s.gsub(/[\r\n\x00]/, ' ') }
+        if options[:replace_space]
+          sn.collect! { |x| x.gsub(/\s/, '_') }
+        end
+        if !options.has_key?(:escape) or options[:escape]
+          sn.collect! { |x| x.gsub(/[\:\;\,\(\)]/, '_') }
+        end
+        if !options.has_key?(:split) or options[:split]
+          sn.collect! { |x| x.split(/\s/)[0].to_s }
+        end
+        if !options.has_key?(:avoid_same_name) or options[:avoid_same_name]
+          sn = __clustal_avoid_same_name(sn, 30)
+        end
+
+        seqwidth  = (options[:width] or 60)
+        seqregexp = Regexp.new("(.{1,#{seqwidth}})")
+        gchar = (options[:gap_char] or '-')
+
+        aseqs = Array.new(len).clear
+        self.each_seq do |s|
+          aseqs << s.to_s.gsub(self.gap_regexp, gchar)
+        end
+        case options[:case].to_s
+        when /lower/i
+          aseqs.each { |s| s.downcase! }
+        when /upper/i
+          aseqs.each { |s| s.upcase! }
+        end
+        
+        aseqs.collect! do |s|
+          s << (gchar * (len - s.length))
+          s.gsub!(seqregexp, "\\1\n")
+          sn.shift + "\n" + s
+        end
+        aseqs.unshift(header)
+        aseqs.join('')
+      end
+
+      # Generates msf formatted text as a string
+      def output_msf(options = {})
+        len = self.seq_length
+
+        if !options.has_key?(:avoid_same_name) or options[:avoid_same_name]
+          sn = __clustal_avoid_same_name(self.sequence_names)
+        else
+          sn = self.sequence_names.collect do |x|
+            x.to_s.gsub(/[\r\n\x00]/, ' ')
+          end
+        end
+        if !options.has_key?(:replace_space) or options[:replace_space]
+          sn.collect! { |x| x.gsub(/\s/, '_') }
+        end
+        if !options.has_key?(:escape) or options[:escape]
+          sn.collect! { |x| x.gsub(/[\:\;\,\(\)]/, '_') }
+        end
+        if !options.has_key?(:split) or options[:split]
+          sn.collect! { |x| x.split(/\s/)[0].to_s }
+        end
+
+        seqwidth = 50
+        namewidth = [31, sn.collect { |x| x.length }.max ].min
+        sep = ' ' * 2
+
+        seqregexp = Regexp.new("(.{1,#{seqwidth}})")
+        gchar = (options[:gap_char]  or '.')
+        pchar = (options[:padding_char] or '~')
+
+        aseqs = Array.new(self.number_of_sequences).clear
+        self.each_seq do |s|
+          aseqs << s.to_s.gsub(self.gap_regexp, gchar)
+        end
+        aseqs.each do |s|
+          s.sub!(/\A#{Regexp.escape(gchar)}+/) { |x| pchar * x.length }
+          s.sub!(/#{Regexp.escape(gchar)}+\z/, '')
+          s << (pchar * (len - s.length))
+        end
+
+        case options[:case].to_s
+        when /lower/i
+          aseqs.each { |s| s.downcase! }
+        when /upper/i
+          aseqs.each { |s| s.upcase! }
+        else #default upcase
+          aseqs.each { |s| s.upcase! }
+        end
+
+        case options[:type].to_s
+        when /protein/i, /aa/i
+          amino = true
+        when /na/i
+          amino = false
+        else
+          if seqclass == Bio::Sequence::AA then
+            amino = true
+          elsif seqclass == Bio::Sequence::NA then
+            amino = false
+          else
+            # if we can't determine, we asuume as protein.
+            amino = aseqs.size
+            aseqs.each { |x| amino -= 1 if /\A[acgt]\z/i =~ x }
+            amino = false if amino <= 0
+          end
+        end
+
+        seq_type = (amino ? 'P' : 'N')
+
+        fn = (options[:entry_id] or self.__id__.abs.to_s + '.msf')
+        dt = (options[:time] or Time.now).strftime('%B %d, %Y %H:%M')
+
+        sums = aseqs.collect { |s| GCG::Seq.calc_checksum(s) }
+        #sums = aseqs.collect { |s| 0 }
+        sum = 0; sums.each { |x| sum += x }; sum %= 10000
+        msf =
+          [
+           "#{seq_type == 'N' ? 'N' : 'A' }A_MULTIPLE_ALIGNMENT 1.0\n",
+           "\n",
+           "\n",
+           " #{fn}  MSF: #{len}  Type: #{seq_type}  #{dt}  Check: #{sum} ..\n",
+           "\n"
+          ]
+
+        sn.each do |snx|
+          msf << ' Name: ' +
+            sprintf('%*s', -namewidth, snx.to_s)[0, namewidth] +
+            "  Len: #{len}  Check: #{sums.shift}  Weight: 1.00\n"
+        end
+        msf << "\n//\n"
+
+        aseqs.collect! do |s|
+          snx = sn.shift
+          head = sprintf("%*s", namewidth, snx.to_s)[0, namewidth] + sep
+          s.gsub!(seqregexp, "\\1\n")
+          a = s.split(/^/)
+          a.collect { |x| head + x }
+        end
+        lines = (len + seqwidth - 1).div(seqwidth)
+        i = 1
+        lines.times do
+          msf << "\n"
+          n_l = i
+          n_r = [ i + seqwidth - 1, len ].min
+          if n_l != n_r then
+            w = [ n_r - n_l + 1 - n_l.to_s.length - n_r.to_s.length, 1 ].max
+            msf << (' ' * namewidth + sep + n_l.to_s + 
+                    ' ' * w + n_r.to_s + "\n")
+          else
+            msf << (' ' * namewidth + sep + n_l.to_s + "\n")
+          end
+          aseqs.each { |a| msf << a.shift }
+          i += seqwidth
+        end
+        msf << "\n"
+        msf.join('')
+      end
+
+    end #module Output
+
+    module EnumerableExtension
+      include Output
+
+      # Returns number of sequences in this alignment.
+      def number_of_sequences
+        i = 0
+        self.each_seq { |s| i += 1 }
+        i
+      end
+
+      # Returns an array of sequence names.
+      # The order of the names must be the same as
+      # the order of <tt>each_seq</tt>.
+      def sequence_names
+        (0...(self.number_of_sequences)).to_a
+      end
+    end #module EnumerableExtension
 
     # Bio::Alignment::ArrayExtension is a set of useful methods for
     # multiple sequence alignment.
@@ -1046,10 +1344,9 @@ Mix-in for Hash or Hash-like classes.
         each(&block)
       end
 
-      include ClustalWFormatter
-      # Returns a string of Clustal W formatted text of the alignment.
-      def to_clustal(options = {})
-        clustalw_formatter(self, (0...(self.size)).to_a, options)
+      # Returns number of sequences in this alignment.
+      def number_of_sequences
+        self.size
       end
     end #module ArrayExtension
 
@@ -1077,8 +1374,9 @@ Mix-in for Hash or Hash-like classes.
       # Yields a sequence.
       #
       # It works the same as Hash#each_value.
-      def each_seq(&block) #:yields: seq
-        each_value(&block)
+      def each_seq #:yields: seq
+        #each_value(&block)
+        each_key { |k| yield self[k] }
       end
 
       # Iterates over each sequence and each results running block
@@ -1140,15 +1438,16 @@ Mix-in for Hash or Hash-like classes.
         self
       end
 
-      include ClustalWFormatter
-      # Returns a string of Clustal W formatted text of the alignment.
-      def to_clustal(options = {})
-        seqs = SequenceArray.new
-        names = self.keys
-        names.each do |k|
-          seqs << self[k]
-        end
-        clustalw_formatter(seqs, names, options)
+      # Returns number of sequences in this alignment.
+      def number_of_sequences
+        self.size
+      end
+
+      # Returns an array of sequence names.
+      # The order of the names must be the same as
+      # the order of <tt>each_seq</tt>.
+      def sequence_names
+        self.keys
       end
     end #module HashExtension
 
@@ -1423,6 +1722,7 @@ Mix-in for Hash or Hash-like classes.
         #(Hash&Array-like)
         @seqs.size
       end
+      alias number_of_sequences size
 
       # If the key exists, returns true. Otherwise, returns false.
       # (Like Hash#has_key?)
@@ -1800,7 +2100,7 @@ Mix-in for Hash or Hash-like classes.
         options = (arg.shift or {})
         width = options[:width] unless width
         if options[:avoid_same_name] then
-          na = avoid_same_name(self.keys, 30)
+          na = __clustal_avoid_same_name(self.keys, 30)
         else
           na = self.keys.collect { |k| k.to_s.gsub(/[\r\n\x00]/, ' ') }
         end
@@ -1831,17 +2131,15 @@ Mix-in for Hash or Hash-like classes.
       # Converts to fasta format and returns a string.
       #
       # The specification of the argument will be changed.
+      #
+      # Note: <tt>to_fasta</tt> is deprecated.
+      # Please use <tt>output_fasta</tt> instead.
       def to_fasta(*arg)
         #(original)
+        warn "to_fasta is deprecated. Please use output_fasta."
         self.to_fasta_array(*arg).join('')
       end
 
-      include ClustalWFormatter
-      # Returns a string of Clustal W formatted text of the alignment.
-      def to_clustal(options = {})
-        clustalw_formatter(self, self.keys, options)
-      end
-
       # The method name <tt>consensus</tt> will be obsoleted.
       # Please use <tt>consensus_string</tt> instead.
       alias consensus consensus_string
@@ -1900,6 +2198,318 @@ Mix-in for Hash or Hash-like classes.
     def self.readfiles(*files)
       OriginalAlignment.readfiles(*files)
     end
+
+    #---
+    # Service classes for multiple alignment applications
+    #+++
+    #---
+    # Templates of alignment application factory
+    #+++
+
+    # Namespace for templates for alignment application factory
+    module FactoryTemplate
+
+      # Template class for alignment application factory.
+      # The program acts:
+      # input: stdin or file, format = fasta format
+      # output: stdout (parser should be specified by DEFAULT_PARSER)
+      class Simple
+
+        # Creates a new alignment factory
+        def initialize(program = self.class::DEFAULT_PROGRAM, options = [])
+          @program = program
+          @options = options
+          @command = nil
+          @output = nil
+          @report = nil
+          @exit_status = nil
+          @data_stdout = nil
+        end
+
+        # program name
+        attr_accessor :program
+
+        # options
+        attr_accessor :options
+
+        # Last command-line string. Returns nil or an array of String.
+        # Note that filenames described in the command-line may already
+        # be removed because these files may be temporary files.
+        attr_reader :command
+
+        # Last raw result of the program.
+        # Return a string (or nil).
+        attr_reader :output
+
+        # Last result object 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_alignment(seqs)
+          else
+            exec_local(@options)
+            @exit_status.exitstatus == 0 ? true : false
+          end
+        end
+
+        # Performs alignment for seqs.
+        # +seqs+ should be Bio::Alignment or Array of sequences or nil.
+        def query_alignment(seqs)
+          unless seqs.respond_to?(:output_fasta) then
+            seqs = Bio::Alignment.new(seqs)
+          end
+          query_string(seqs.output_fasta(:width => 70))
+        end
+
+        # alias of query_alignment.
+        #
+        # Compatibility Note: query_align will renamed to query_alignment.
+        def query_align(seqs)
+          #warn 'query_align is renamed to query_alignment.'
+          query_alignment(seqs)
+        end
+
+        # Performs alignment for +str+.
+        # The +str+ should be a string that can be recognized by the program.
+        def query_string(str)
+          _query_string(str, @options)
+          @report
+        end
+
+        # Performs alignment of sequences in the file named +fn+.
+        def query_by_filename(filename_in)
+          _query_local(filename_in, @options)
+          @report
+        end
+
+        private
+        # Executes a program in the local machine.
+        def exec_local(opt, data_stdin = nil)
+          @exit_status = nil
+          @command = [ @program, *opt ]
+          #STDERR.print "DEBUG: ", @command.join(" "), "\n"
+          @data_stdout = Bio::Command.query_command(@command, data_stdin)
+          @exit_status = $?
+        end
+
+        # prepare temporary file
+        def _prepare_tempfile(str = nil)
+          tf_in = Tempfile.open(str ? 'alignment_i' :'alignment_o')
+          tf_in.print str if str
+          tf_in.close(false)
+          tf_in
+        end
+
+        # generates options specifying input/output filename.
+        # nil for filename means stdin or stdout.
+        # +options+ must not contain specify filenames.
+        # returns an array of string.
+        def _generate_options(infile, outfile, options)
+          options +
+            (infile ? _option_input_file(infile) : _option_input_stdin) +
+            (outfile ? _option_output_file(outfile) : _option_output_stdout)
+        end
+
+        # generates options specifying input filename.
+        # returns an array of string
+        def _option_input_file(fn)
+          [ fn ]
+        end
+
+        # generates options specifying output filename.
+        # returns an array of string
+        def _option_output_file(fn)
+          raise 'can not specify output file: always stdout'
+        end
+
+        # generates options specifying that input is taken from stdin.
+        # returns an array of string
+        def _option_input_stdin
+          []
+        end
+
+        # generates options specifying output to stdout.
+        # returns an array of string
+        def _option_output_stdout
+          []
+        end
+      end #class Simple
+
+      # mix-in module
+      module WrapInputStdin
+        private
+        # Performs alignment for +str+.
+        # The +str+ should be a string that can be recognized by the program.
+        def _query_string(str, opt)
+          _query_local(nil, opt, str)
+        end
+      end #module WrapInputStdin
+
+      # mix-in module
+      module WrapInputTempfile
+        private
+        # Performs alignment for +str+.
+        # The +str+ should be a string that can be recognized by the program.
+        def _query_string(str, opt)
+          begin
+            tf_in = _prepare_tempfile(str)
+            ret = _query_local(tf_in.path, opt, nil)
+          ensure
+            tf_in.close(true) if tf_in
+          end
+          ret
+        end
+      end #module WrapInputTempfile
+
+      # mix-in module
+      module WrapOutputStdout
+        private
+        # Performs alignment by specified filenames
+        def _query_local(fn_in, opt, data_stdin = nil)
+          opt = _generate_options(fn_in, nil, opt)
+          exec_local(opt, data_stdin)
+          @output = @data_stdout
+          @report = self.class::DEFAULT_PARSER.new(@output)
+          @report
+        end
+      end #module WrapOutputStdout
+
+      # mix-in module
+      module WrapOutputTempfile
+        private
+        # Performs alignment
+        def _query_local(fn_in, opt, data_stdin = nil)
+          begin
+            tf_out = _prepare_tempfile()
+            opt = _generate_options(fn_in, tf_out.path, opt)
+            exec_local(opt, data_stdin)
+            tf_out.open
+            @output = tf_out.read
+          ensure
+            tf_out.close(true) if tf_out
+          end
+          @report = self.class::DEFAULT_PARSER.new(@output)
+          @report
+        end
+      end #module WrapOutputTempfile
+
+      # Template class for alignment application factory.
+      # The program needs:
+      # input: file (cannot accept stdin), format = fasta format
+      # output: stdout (parser should be specified by DEFAULT_PARSER)
+      class FileInStdoutOut < Simple
+        include Bio::Alignment::FactoryTemplate::WrapInputTempfile
+        include Bio::Alignment::FactoryTemplate::WrapOutputStdout
+
+        private
+        # generates options specifying that input is taken from stdin.
+        # returns an array of string
+        def _option_input_stdin
+          raise 'input is always a file'
+        end
+      end #class FileInStdoutOut
+
+      # Template class for alignment application factory.
+      # The program needs:
+      # input: stdin or file, format = fasta format
+      # output: file (parser should be specified by DEFAULT_PARSER)
+      class StdinInFileOut < Simple
+        include Bio::Alignment::FactoryTemplate::WrapInputStdin
+        include Bio::Alignment::FactoryTemplate::WrapOutputTempfile
+
+        private
+        # generates options specifying output to stdout.
+        # returns an array of string
+        def _option_output_stdout
+          raise 'output is always a file'
+        end
+      end #class StdinInFileOut
+
+      # Template class for alignment application factory.
+      # The program needs:
+      # input: file (cannot accept stdin), format = fasta format
+      # output: file (parser should be specified by DEFAULT_PARSER)
+      class FileInFileOut < Simple
+        include Bio::Alignment::FactoryTemplate::WrapInputTempfile
+        include Bio::Alignment::FactoryTemplate::WrapOutputTempfile
+
+        private
+        # generates options specifying that input is taken from stdin.
+        # returns an array of string
+        def _option_input_stdin
+          raise 'input is always a file'
+        end
+
+        # generates options specifying output to stdout.
+        # returns an array of string
+        def _option_output_stdout
+          raise 'output is always a file'
+        end
+      end #class FileInFileOut
+
+      # Template class for alignment application factory.
+      # The program needs:
+      # input: file (cannot accept stdin), format = fasta format
+      # output: file (parser should be specified by DEFAULT_PARSER)
+      # Tree (*.dnd) output is also supported.
+      class FileInFileOutWithTree < FileInFileOut
+
+        # alignment guide tree generated by the program (*.dnd file)
+        attr_reader :output_dnd
+
+        def reset
+          @output_dnd = nil
+          super
+        end
+
+        private
+        # Performs alignment
+        def _query_local(fn_in, opt, data_stdin = nil)
+          begin
+            tf_dnd = _prepare_tempfile()
+            opt = opt + _option_output_dndfile(tf_dnd.path)
+            ret = super(fn_in, opt, data_stdin)
+            tf_dnd.open
+            @output_dnd = tf_dnd.read
+          ensure
+            tf_dnd.close(true) if tf_dnd
+          end
+          ret
+        end
+
+        # generates options specifying output tree file (*.dnd).
+        # returns an array of string
+        def _option_output_dndfile
+          raise NotImplementedError
+        end
+      end #class FileInFileOutWithTree
+
+    end #module FactoryTemplate
+
+
   end #module Alignment
 
 end #module Bio