jandot-bio 1.2.1

data/lib/bio/command.rb

@@ -0,0 +1,337 @@
+#
+# = bio/command.rb - general methods for external command execution
+#
+# Copyright::	Copyright (C) 2003-2006
+# 		Naohisa Goto <ng@bioruby.org>,
+#		Toshiaki Katayama <k@bioruby.org>
+# License::	The Ruby License
+#
+#  $Id: command.rb,v 1.17 2007/04/05 23:35:39 trevor Exp $
+#
+
+require 'open3'
+require 'uri'
+require 'open-uri'
+require 'net/http'
+
+module Bio
+
+# = Bio::Command
+#
+# Bio::Command is a collection of useful methods for execution
+# of external commands or web applications.
+# Any wrapper class for applications shall use this class.
+#
+# Library internal use only. Users should not directly use it.
+module Command
+
+  UNSAFE_CHARS_UNIX   = /[^A-Za-z0-9\_\-\.\:\,\/\@\x1b\x80-\xfe]/n
+  QUOTE_CHARS_WINDOWS = /[^A-Za-z0-9\_\-\.\:\,\/\@\\]/n
+  UNESCAPABLE_CHARS   = /[\x00-\x08\x10-\x1a\x1c-\x1f\x7f\xff]/n
+
+  module_function
+
+  # Escape special characters in command line string for cmd.exe on Windows.
+  def escape_shell_windows(str)
+    str = str.to_s
+    raise 'cannot escape control characters' if UNESCAPABLE_CHARS =~ str
+    if QUOTE_CHARS_WINDOWS =~ str then
+      '"' + str.gsub(/\"/, '""') + '"'
+    else
+      String.new(str)
+    end
+  end
+
+  # Escape special characters in command line string for UNIX shells.
+  def escape_shell_unix(str)
+    str = str.to_s
+    raise 'cannot escape control characters' if UNESCAPABLE_CHARS =~ str
+    str.gsub(UNSAFE_CHARS_UNIX) { |x| "\\#{x}" }
+  end
+
+  # Escape special characters in command line string.
+  def escape_shell(str)
+    case RUBY_PLATFORM
+    when /mswin32|bccwin32/
+      escape_shell_windows(str)
+    else
+      escape_shell_unix(str)
+    end
+  end
+
+  # Generate command line string with special characters escaped.
+  def make_command_line(ary)
+    case RUBY_PLATFORM
+    when /mswin32|bccwin32/
+      make_command_line_windows(ary)
+    else
+      make_command_line_unix(ary)
+    end
+  end
+
+  # Generate command line string with special characters escaped
+  # for cmd.exe on Windows.
+  def make_command_line_windows(ary)
+    ary.collect { |str| escape_shell_windows(str) }.join(" ")
+  end
+
+  # Generate command line string with special characters escaped
+  # for UNIX shells.
+  def make_command_line_unix(ary)
+    ary.collect { |str| escape_shell_unix(str) }.join(" ")
+  end
+
+  # Executes the program.  Automatically select popen for Windows
+  # environment and fork for the others.
+  # A block must be given. An IO object is passed to the block.
+  def call_command(cmd, &block)
+    case RUBY_PLATFORM
+    when /mswin32|bccwin32/
+      call_command_popen(cmd, &block)
+    else
+      call_command_fork(cmd, &block)
+    end
+  end
+
+  # Executes the program via IO.popen for OS which doesn't support fork.
+  # A block must be given. An IO object is passed to the block.
+  def call_command_popen(cmd)
+    str = make_command_line(cmd)
+    IO.popen(str, "w+") do |io|
+      io.sync = true
+      yield io
+    end
+  end
+
+  # Executes the program via fork (by using IO.popen("-")) and exec.
+  # A block must be given. An IO object is passed to the block.
+  #
+  # From the view point of security, this method is recommended
+  # rather than call_command_popen.
+  def call_command_fork(cmd)
+    IO.popen("-", "r+") do |io|
+      if io then
+        # parent
+        yield io
+      else
+        # child
+        begin
+          Kernel.exec(*cmd)
+        rescue Errno::ENOENT, Errno::EACCES
+          Process.exit!(127)
+        rescue Exception
+        end
+        Process.exit!(1)
+      end
+    end
+  end
+
+  # Executes the program via Open3.popen3
+  # A block must be given. IO objects are passed to the block.
+  #
+  # You would use this method only when you really need to get stderr.
+  def call_command_open3(cmd)
+    cmd = cmd.collect { |x| x.to_s }
+    Open3.popen3(*cmd) do |pin, pout, perr|
+      yield pin, pout, perr
+    end
+  end
+
+  # Executes the program with the query (String) given to the standard input,
+  # waits the program termination, and returns the output data printed to the
+  # standard output as a string.
+  # 
+  # Automatically select popen for Windows environment and fork for the others.
+  def query_command(cmd, query = nil)
+    case RUBY_PLATFORM
+    when /mswin32|bccwin32/
+      query_command_popen(cmd, query)
+    else
+      query_command_fork(cmd, query)
+    end
+  end
+
+  # Executes the program with the query (String) given to the standard input,
+  # waits the program termination, and returns the output data printed to the
+  # standard output as a string.
+  #
+  # IO.popen is used for OS which doesn't support fork.
+  def query_command_popen(cmd, query = nil)
+    str = make_command_line(cmd)
+    IO.popen(str, "w+") do |io|
+      io.sync = true
+      io.print query if query
+      io.close_write
+      io.read
+    end
+  end
+
+  # Executes the program with the query (String) given to the standard input,
+  # waits the program termination, and returns the output data printed to the
+  # standard output as a string.
+  #
+  # Fork (by using IO.popen("-")) and exec is used to execute the program.
+  #
+  # From the view point of security, this method is recommended
+  # rather than query_popen.
+  def query_command_fork(cmd, query = nil)
+    IO.popen("-", "r+") do |io|
+      if io then
+        # parent
+        io.sync = true
+        io.print query if query
+        io.close_write
+        io.read
+      else
+        # child
+        begin
+          Kernel.exec(*cmd)
+        rescue Errno::ENOENT, Errno::EACCES
+          Process.exit!(127)
+        rescue Exception
+        end
+        Process.exit!(1)
+      end
+    end
+  end
+
+  # Executes the program via Open3.popen3 with the query (String) given
+  # to the stain, waits the program termination, and
+  # returns the data from stdout and stderr as an array of the strings.
+  #
+  # From the view point of security, this method is recommended
+  # rather than exec_local_popen.
+  def query_command_open3(cmd, query = nil)
+    errorlog = nil
+    cmd = cmd.collect { |x| x.to_s }
+    Open3.popen3(*cmd) do |pin, pout, perr|
+      perr.sync = true
+      t = Thread.start { errorlog = perr.read }
+      begin
+        pin.print query if query
+        pin.close
+        output = pout.read
+      ensure
+        t.join
+      end
+      [ output, errorlog ]
+    end
+  end
+
+  # Same as OpenURI.open_uri(uri).read.
+  def read_uri(uri)
+    OpenURI.open_uri(uri).read
+  end
+
+  # Same as:
+  #   Net::HTTP.start(address, port)
+  # and 
+  # it uses proxy if an environment variable (same as OpenURI.open_uri)
+  # is set.
+  #
+  def start_http(address, port = 80, &block)
+    uri = URI.parse("http://#{address}:#{port}")
+    # Note: URI#find_proxy is an unofficial method defined in open-uri.rb.
+    # If the spec of open-uri.rb would be changed, we should change below.
+    if proxyuri = uri.find_proxy then
+      raise 'Non-HTTP proxy' if proxyuri.class != URI::HTTP
+      http = Net::HTTP.Proxy(proxyuri.host, proxyuri.port)
+    else
+      http = Net::HTTP
+    end
+    http.start(address, port, &block)
+  end
+
+  # Same as:
+  #   Net::HTTP.new(address, port)
+  # and 
+  # it uses proxy if an environment variable (same as OpenURI.open_uri)
+  # is set.
+  #
+  def new_http(address, port = 80)
+    uri = URI.parse("http://#{address}:#{port}")
+    # Note: URI#find_proxy is an unofficial method defined in open-uri.rb.
+    # If the spec of open-uri.rb would be changed, we should change below.
+    if proxyuri = uri.find_proxy then
+      raise 'Non-HTTP proxy' if proxyuri.class != URI::HTTP
+      Net::HTTP.new(address, port, proxyuri.host, proxyuri.port)
+    else
+      Net::HTTP.new(address, port)
+    end
+  end
+
+  # Same as:
+  # Net::HTTP.post_form(uri, params)
+  # and 
+  # it uses proxy if an environment variable (same as OpenURI.open_uri)
+  # is set.
+  # In addition, +header+ can be set.
+  # (Note that Content-Type and Content-Length are automatically
+  # set by default.)
+  # +uri+ must be a URI object, +params+ must be a hash, and
+  # +header+ must be a hash.
+  #
+  def post_form(uri, params = nil, header = {})
+    unless uri.is_a?(URI)
+      uri = URI.parse(uri)
+    end
+
+    data = make_cgi_params(params)
+
+    hash = {
+      'Content-Type'   => 'application/x-www-form-urlencoded',
+      'Content-Length' => data.length.to_s
+    }
+    hash.update(header)
+
+    start_http(uri.host, uri.port) do |http|
+      http.post(uri.path, data, hash)
+    end
+  end
+
+  def make_cgi_params(params)
+    data = ""
+    case params
+    when Hash
+      data = params.map do |key, val|
+        make_cgi_params_key_value(key, val)
+      end.join('&')
+    when Array
+      case params.first
+      when Hash
+        data = params.map do |hash|
+          hash.map do |key, val|
+            make_cgi_params_key_value(key, val)
+          end
+        end.join('&')
+      when Array
+        data = params.map do |key, val|
+          make_cgi_params_key_value(key, val)
+        end.join('&')
+      when String
+        data = params.map do |str|
+          URI.escape(str.strip)
+        end.join('&')
+      end
+    when String
+      data = URI.escape(params.strip)
+    end
+    return data
+  end
+
+  def make_cgi_params_key_value(key, value)
+    result = []
+    case value
+    when Array
+      value.each do |val|
+        result << [key, val].map {|x| URI.escape(x.to_s) }.join('=')
+      end
+    else
+      result << [key, value].map {|x| URI.escape(x.to_s) }.join('=')
+    end
+    return result
+  end
+
+end # module Command
+end # module Bio
+

data/lib/bio/data/aa.rb

@@ -0,0 +1,349 @@
+#
+# = bio/data/aa.rb - Amino Acids
+#
+# Copyright::	Copyright (C) 2001, 2005
+#		Toshiaki Katayama <k@bioruby.org>
+# License::	The Ruby License
+#
+# $Id: aa.rb,v 0.22 2007/04/06 04:44:51 k Exp $
+#
+
+module Bio
+
+class AminoAcid
+
+  module Data
+
+    # IUPAC code
+    # * http://www.iupac.org/
+    # * http://www.chem.qmw.ac.uk/iubmb/newsletter/1999/item3.html
+    # * http://www.ebi.ac.uk/RESID/faq.html
+
+    NAMES = {
+
+      'A' => 'Ala',
+      'C' => 'Cys',
+      'D' => 'Asp',
+      'E' => 'Glu',
+      'F' => 'Phe',
+      'G' => 'Gly',
+      'H' => 'His',
+      'I' => 'Ile',
+      'K' => 'Lys',
+      'L' => 'Leu',
+      'M' => 'Met',
+      'N' => 'Asn',
+      'P' => 'Pro',
+      'Q' => 'Gln',
+      'R' => 'Arg',
+      'S' => 'Ser',
+      'T' => 'Thr',
+      'V' => 'Val',
+      'W' => 'Trp',
+      'Y' => 'Tyr',
+      'B' => 'Asx',	# D/N
+      'Z' => 'Glx',	# E/Q
+      'J' => 'Xle',	# I/L
+      'U' => 'Sec',	# 'uga' (stop)
+      'O' => 'Pyl',	# 'uag' (stop)
+      'X' => 'Xaa',	# (unknown)
+     
+      'Ala' => 'alanine',
+      'Cys' => 'cysteine',
+      'Asp' => 'aspartic acid',
+      'Glu' => 'glutamic acid',
+      'Phe' => 'phenylalanine',
+      'Gly' => 'glycine',
+      'His' => 'histidine',
+      'Ile' => 'isoleucine',
+      'Lys' => 'lysine',
+      'Leu' => 'leucine',
+      'Met' => 'methionine',
+      'Asn' => 'asparagine',
+      'Pro' => 'proline',
+      'Gln' => 'glutamine',
+      'Arg' => 'arginine',
+      'Ser' => 'serine',
+      'Thr' => 'threonine',
+      'Val' => 'valine',
+      'Trp' => 'tryptophan',
+      'Tyr' => 'tyrosine',
+      'Asx' => 'asparagine/aspartic acid [DN]',
+      'Glx' => 'glutamine/glutamic acid [EQ]',
+      'Xle' => 'isoleucine/leucine [IL]',
+      'Sec' => 'selenocysteine',
+      'Pyl' => 'pyrrolysine',
+      'Xaa' => 'unknown [A-Z]',
+
+    }
+
+    # AAindex FASG760101 - Molecular weight (Fasman, 1976)
+    #   Fasman, G.D., ed.
+    #   Handbook of Biochemistry and Molecular Biology", 3rd ed.,
+    #   Proteins - Volume 1, CRC Press, Cleveland (1976)
+
+    WEIGHT = {
+
+      'A' => 89.09,
+      'C' => 121.15,	# 121.16 according to the Wikipedia
+      'D' => 133.10,
+      'E' => 147.13,
+      'F' => 165.19,
+      'G' => 75.07,
+      'H' => 155.16,
+      'I' => 131.17,
+      'K' => 146.19,
+      'L' => 131.17,
+      'M' => 149.21,
+      'N' => 132.12,
+      'P' => 115.13,
+      'Q' => 146.15,
+      'R' => 174.20,
+      'S' => 105.09,
+      'T' => 119.12,
+      'U' => 168.06,
+      'V' => 117.15,
+      'W' => 204.23,
+      'Y' => 181.19,
+    }
+
+    def weight(x = nil)
+      if x
+        if x.length > 1
+          total = 0.0
+          x.each_byte do |byte|
+            aa = byte.chr.upcase
+            if WEIGHT[aa]
+              total += WEIGHT[aa]
+            else
+              raise "Error: invalid amino acid '#{aa}'"
+            end
+          end
+          total -= NucleicAcid.weight[:water] * (x.length - 1)
+        else
+          WEIGHT[x]
+        end
+      else
+        WEIGHT
+      end
+    end
+
+    def [](x)
+      NAMES[x]
+    end
+
+    # backward compatibility
+    def names
+      NAMES
+    end
+    alias aa names
+
+    def name(x)
+      str = NAMES[x]
+      if str and str.length == 3
+        NAMES[str]
+      else
+        str
+      end
+    end
+
+    def to_1(x)
+      case x.to_s.length
+      when 1
+        x
+      when 3
+        three2one(x)
+      else
+        name2one(x)
+      end
+    end
+    alias one to_1
+
+    def to_3(x)
+      case x.to_s.length
+      when 1
+        one2three(x)
+      when 3
+        x
+      else
+        name2three(x)
+      end
+    end
+    alias three to_3
+
+    def one2three(x)
+      if x and x.length != 1
+        raise ArgumentError
+      else
+        NAMES[x]
+      end
+    end
+
+    def three2one(x)
+      if x and x.length != 3
+        raise ArgumentError
+      else
+        reverse[x]
+      end
+    end
+
+    def one2name(x)
+      if x and x.length != 1
+        raise ArgumentError
+      else
+        three2name(NAMES[x])
+      end
+    end
+
+    def name2one(x)
+      str = reverse[x.to_s.downcase]
+      if str and str.length == 3
+        three2one(str)
+      else
+        str
+      end
+    end
+
+    def three2name(x)
+      if x and x.length != 3
+        raise ArgumentError
+      else
+        NAMES[x]
+      end
+    end
+
+    def name2three(x)
+      reverse[x.downcase]
+    end
+
+    def to_re(seq)
+      replace = {
+        'B' => '[DNB]',
+        'Z' => '[EQZ]',
+        'J' => '[ILJ]',
+        'X' => '[ACDEFGHIKLMNPQRSTVWYUOX]',
+      }
+      replace.default = '.'
+
+      str = seq.to_s.upcase
+      str.gsub!(/[^ACDEFGHIKLMNPQRSTVWYUO]/) { |aa|
+        replace[aa]
+      }
+      Regexp.new(str)
+    end
+
+
+    private
+
+
+    def reverse
+      hash = Hash.new
+      NAMES.each do |k, v|
+        hash[v] = k
+      end
+      hash
+    end
+
+  end
+
+
+  # as instance methods
+  include Data
+
+  # as class methods
+  extend Data
+
+
+  private
+
+
+  # override when used as an instance method to improve performance
+  alias orig_reverse reverse
+  def reverse
+    unless @reverse
+      @reverse = orig_reverse
+    end
+    @reverse
+  end
+
+end
+
+end # module Bio
+
+
+if __FILE__ == $0
+
+  puts "### aa = Bio::AminoAcid.new"
+  aa = Bio::AminoAcid.new
+
+  puts "# Bio::AminoAcid['A']"
+  p Bio::AminoAcid['A']
+  puts "# aa['A']"
+  p aa['A']
+
+  puts "# Bio::AminoAcid.name('A'), Bio::AminoAcid.name('Ala')"
+  p Bio::AminoAcid.name('A'), Bio::AminoAcid.name('Ala')
+  puts "# aa.name('A'), aa.name('Ala')"
+  p aa.name('A'), aa.name('Ala')
+
+  puts "# Bio::AminoAcid.to_1('alanine'), Bio::AminoAcid.one('alanine')"
+  p Bio::AminoAcid.to_1('alanine'), Bio::AminoAcid.one('alanine')
+  puts "# aa.to_1('alanine'), aa.one('alanine')"
+  p aa.to_1('alanine'), aa.one('alanine')
+  puts "# Bio::AminoAcid.to_1('Ala'), Bio::AminoAcid.one('Ala')"
+  p Bio::AminoAcid.to_1('Ala'), Bio::AminoAcid.one('Ala')
+  puts "# aa.to_1('Ala'), aa.one('Ala')"
+  p aa.to_1('Ala'), aa.one('Ala')
+  puts "# Bio::AminoAcid.to_1('A'), Bio::AminoAcid.one('A')"
+  p Bio::AminoAcid.to_1('A'), Bio::AminoAcid.one('A')
+  puts "# aa.to_1('A'), aa.one('A')"
+  p aa.to_1('A'), aa.one('A')
+
+  puts "# Bio::AminoAcid.to_3('alanine'), Bio::AminoAcid.three('alanine')"
+  p Bio::AminoAcid.to_3('alanine'), Bio::AminoAcid.three('alanine')
+  puts "# aa.to_3('alanine'), aa.three('alanine')"
+  p aa.to_3('alanine'), aa.three('alanine')
+  puts "# Bio::AminoAcid.to_3('Ala'), Bio::AminoAcid.three('Ala')"
+  p Bio::AminoAcid.to_3('Ala'), Bio::AminoAcid.three('Ala')
+  puts "# aa.to_3('Ala'), aa.three('Ala')"
+  p aa.to_3('Ala'), aa.three('Ala')
+  puts "# Bio::AminoAcid.to_3('A'), Bio::AminoAcid.three('A')"
+  p Bio::AminoAcid.to_3('A'), Bio::AminoAcid.three('A')
+  puts "# aa.to_3('A'), aa.three('A')"
+  p aa.to_3('A'), aa.three('A')
+
+  puts "# Bio::AminoAcid.one2three('A')"
+  p Bio::AminoAcid.one2three('A')
+  puts "# aa.one2three('A')"
+  p aa.one2three('A')
+
+  puts "# Bio::AminoAcid.three2one('Ala')"
+  p Bio::AminoAcid.three2one('Ala')
+  puts "# aa.three2one('Ala')"
+  p aa.three2one('Ala')
+
+  puts "# Bio::AminoAcid.one2name('A')"
+  p Bio::AminoAcid.one2name('A')
+  puts "# aa.one2name('A')"
+  p aa.one2name('A')
+
+  puts "# Bio::AminoAcid.name2one('alanine')"
+  p Bio::AminoAcid.name2one('alanine')
+  puts "# aa.name2one('alanine')"
+  p aa.name2one('alanine')
+
+  puts "# Bio::AminoAcid.three2name('Ala')"
+  p Bio::AminoAcid.three2name('Ala')
+  puts "# aa.three2name('Ala')"
+  p aa.three2name('Ala')
+
+  puts "# Bio::AminoAcid.name2three('alanine')"
+  p Bio::AminoAcid.name2three('alanine')
+  puts "# aa.name2three('alanine')"
+  p aa.name2three('alanine')
+
+  puts "# Bio::AminoAcid.to_re('BZACDEFGHIKLMNPQRSTVWYU')"
+  p Bio::AminoAcid.to_re('BZACDEFGHIKLMNPQRSTVWYU')
+
+end
+