bio 1.3.1 → 1.4.0

data/lib/bio/db/phyloxml/phyloxml_writer.rb

@@ -0,0 +1,228 @@
+#
+# = bio/db/phyloxml_writer.rb - PhyloXML writer
+#
+# Copyright::   Copyright (C) 2009
+#               Diana Jaunzeikare <latvianlinuxgirl@gmail.com>
+# License::     The Ruby License
+#
+# $Id:$
+#
+# == Description
+#
+# This file containts writer for PhyloXML.
+#
+# == Requirements
+#
+# Libxml2 XML parser is required. Install libxml-ruby bindings from
+# http://libxml.rubyforge.org or
+#
+#   gem install -r libxml-ruby
+#
+# == References
+#
+# * http://www.phyloxml.org
+#
+# * https://www.nescent.org/wg_phyloinformatics/PhyloSoC:PhyloXML_support_in_BioRuby
+
+require 'libxml'
+require 'bio/db/phyloxml/phyloxml_elements'
+
+module Bio
+
+  module PhyloXML
+
+  # == Description
+  #
+  # Bio::PhyloXML::Writer is for writing phyloXML (version 1.10) format files.
+  #
+  # == Requirements
+  #
+  # Libxml2 XML parser is required. Install libxml-ruby bindings from
+  # http://libxml.rubyforge.org or
+  #
+  #   gem install -r libxml-ruby
+  #
+  # == Usage
+  #
+  #   require 'bio'
+  #
+  #  # Create new phyloxml parser
+  #  phyloxml = Bio::PhyloXML::Parser.open('example.xml')
+  #
+  #  # Read in some trees from file
+  #  tree1 = phyloxml.next_tree
+  #  tree2 = phyloxml.next_tree
+  #
+  #  # Create new phyloxml writer
+  #  writer = Bio::PhyloXML::Writer.new('tree.xml')
+  #
+  #  # Write tree to the file tree.xml
+  #  writer.write(tree1)
+  #
+  #  # Add another tree to the file
+  #  writer.write(tree2)
+  #
+  # == References
+  #
+  # http://www.phyloxml.org/documentation/version_100/phyloxml.xsd.html
+
+    class Writer
+
+      include LibXML
+
+      SCHEMA_LOCATION = 'http://www.phyloxml.org http://www.phyloxml.org/1.10/phyloxml.xsd'
+            
+      attr_accessor :write_branch_length_as_subelement
+
+      #
+      # Create new Writer object. As parameters provide filename of xml file
+      # you wish to create. Optional parameter is whether to indent or no.
+      # Default is true. By default branch_length is written as subelement of
+      # clade element.
+      #
+      def initialize(filename, indent=true)
+      @write_branch_length_as_subelement = true #default value
+      @filename = filename
+      @indent = indent
+
+      @doc = XML::Document.new()
+      @doc.root = XML::Node.new('phyloxml')
+      @root = @doc.root
+      @root['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'
+      @root['xsi:schemaLocation'] = SCHEMA_LOCATION
+      @root['xmlns'] = 'http://www.phyloxml.org'
+
+      #@todo save encoding to be UTF-8. (However it is the default one).
+      #it gives error NameError: uninitialized constant LibXML::XML::Encoding
+      #@doc.encoding = XML::Encoding::UTF_8
+
+      @doc.save(@filename, :indent => true)
+      end
+
+      #
+      # Write a tree to a file in phyloxml format.
+      #
+      #  require 'Bio'
+      #  writer = Bio::PhyloXML::Writer.new
+      #  writer.write(tree)
+      #
+      def write(tree)
+        @root << phylogeny = XML::Node.new('phylogeny')        
+        
+        PhyloXML::Writer.generate_xml(phylogeny, tree, [
+            [:attr, 'rooted'],
+            [:simple, 'name', tree.name],
+            [:complex, 'id', tree.phylogeny_id],
+            [:simple, 'description', tree.description],
+            [:simple, 'date', tree.date],
+            [:objarr, 'confidence', 'confidences']])
+
+        root_clade = tree.root.to_xml(nil, @write_branch_length_as_subelement)
+        
+        phylogeny << root_clade 
+
+        tree.children(tree.root).each do |node|
+          root_clade << node_to_xml(tree, node, tree.root)
+        end
+
+        Bio::PhyloXML::Writer::generate_xml(phylogeny, tree, [
+            [:objarr, 'clade_relation', 'clade_relations'],
+            [:objarr, 'sequence_relation', 'sequence_relations'],
+            [:objarr, 'property', 'properties']] )
+
+        @doc.save(@filename, :indent => @indent)
+      end #writer#write
+
+
+      #
+      # PhyloXML Schema allows to save data in different xml format after all
+      # phylogeny elements. This method is to write these additional data.
+      #
+      #  parser = PhyloXML::Parser.open('phyloxml_examples.xml')
+      #  writer = PhyloXML::Writer.new('new.xml')
+      #
+      #  parser.each do |tree|
+      #    writer.write(tree)
+      #  end
+      #
+      #  # When all the trees are read in by the parser, whats left is saved at
+      #  # PhyloXML::Parser#other
+      #  writer.write(parser.other)
+      #
+
+      def write_other(other_arr)
+        other_arr.each do |other_obj|
+          @root << other_obj.to_xml
+        end
+        @doc.save(@filename, :indent => @indent)
+      end
+
+      #class method
+
+      #
+      # Used by to_xml methods of PhyloXML element classes. Generally not to be
+      # invoked directly. 
+      #
+      def self.generate_xml(root, elem, subelement_array)
+       #example usage: generate_xml(node, self, [[ :complex,'accession', ], [:simple, 'name',  @name], [:simple, 'location', @location]])
+      subelement_array.each do |subelem|
+        if subelem[0] == :simple         
+          root << XML::Node.new(subelem[1], subelem[2].to_s) if subelem[2] != nil and not subelem[2].to_s.empty?
+
+        elsif subelem[0] == :complex
+          root << subelem[2].send("to_xml") if subelem[2] != nil
+
+        elsif subelem[0] == :pattern
+          #seq, self, [[:pattern, 'symbol', @symbol, "\S{1,10}"]
+          if subelem[2] != nil
+            if subelem[2] =~ subelem[3]
+              root << XML::Node.new(subelem[1], subelem[2])
+            else
+              raise "#{subelem[2]} is not a valid value of #{subelem[1]}. It should follow pattern #{subelem[3]}"
+            end
+          end
+
+        elsif subelem[0] == :objarr
+          #[:objarr, 'annotation', 'annotations']])
+          obj_arr = elem.send(subelem[2])
+          obj_arr.each do |arr_elem|
+            root << arr_elem.to_xml
+          end
+
+        elsif subelem[0] == :simplearr
+          #  [:simplearr, 'common_name', @common_names]
+          subelem[2].each do |elem_val|
+            root << XML::Node.new(subelem[1], elem_val)
+          end
+        elsif subelem[0] == :attr
+          #[:attr, 'rooted']
+          obj = elem.send(subelem[1])
+          if obj != nil
+            root[subelem[1]] = obj.to_s
+          end
+        else
+          raise "Not supported type of element by method generate_xml."
+        end
+      end
+      return root
+     end
+
+      private
+
+      def node_to_xml(tree, node, parent)
+        edge = tree.get_edge(parent, node)
+        branch_length = edge.distance
+
+        clade = node.to_xml(branch_length, @write_branch_length_as_subelement)
+
+        tree.children(node).each do |new_node|
+          clade << node_to_xml(tree, new_node, node)
+        end
+
+        return clade
+      end
+
+    end
+
+  end
+end

data/lib/bio/db/prosite.rb

@@ -2,9 +2,9 @@
 # = bio/db/prosite.rb - PROSITE database class
 #
 # Copyright::  Copyright (C) 2001 Toshiaki Katayama <k@bioruby.org>
-# Licence::    Ruby's
+# License::    The Ruby License
 #
-# $Id: prosite.rb,v 0.16 2006/09/19 06:03:51 k Exp $
+# $Id:$
 #
 
 require 'bio/db'
@@ -502,96 +502,3 @@ end # PROSITE
 
 end # Bio
 
-
-if __FILE__ == $0
-
-  begin
-    require 'pp'
-    alias p pp
-  rescue LoadError
-  end
-
-  ps = Bio::PROSITE.new(ARGF.read)
-
-  list = %w(
-    name
-    division
-    ac
-    entry_id
-    dt
-    date
-    de
-    definition
-    pa
-    pattern
-    ma
-    profile
-    ru
-    rule
-    nr
-    statistics
-    release
-    swissprot_release_number
-    swissprot_release_sequences
-    total
-    total_hits
-    total_sequences
-    positive
-    positive_hits
-    positive_sequences
-    unknown
-    unknown_hits
-    unknown_sequences
-    false_pos
-    false_positive_hits
-    false_positive_sequences
-    false_neg
-    false_negative_hits
-    partial
-    cc
-    comment
-    max_repeat
-    site
-    skip_flag
-    dr
-    sp_xref
-    pdb_xref
-    pdoc_xref
-  )
-
-  list.each do |method|
-    puts ">>> #{method}"
-    p ps.send(method)
-  end
-
-  puts ">>> taxon_range"
-  p ps.taxon_range
-  puts ">>> taxon_range(expand)"
-  p ps.taxon_range(true)
-
-  puts ">>> list_truepositive"
-  p ps.list_truepositive
-  puts ">>> list_truepositive(by_name)"
-  p ps.list_truepositive(true)
-
-  puts ">>> list_falsenegative"
-  p ps.list_falsenegative
-  puts ">>> list_falsenegative(by_name)"
-  p ps.list_falsenegative(true)
-
-  puts ">>> list_falsepositive"
-  p ps.list_falsepositive
-  puts ">>> list_falsepositive(by_name)"
-  p ps.list_falsepositive(true)
-
-  puts ">>> list_potentialhit"
-  p ps.list_potentialhit
-  puts ">>> list_potentialhit(by_name)"
-  p ps.list_potentialhit(true)
-
-  puts ">>> list_unknown"
-  p ps.list_unknown
-  puts ">>> list_unknown(by_name)"
-  p ps.list_unknown(true)
-
-end

data/lib/bio/db/rebase.rb

@@ -40,7 +40,7 @@ module Bio
 # To easily get started with the data you can simply type this command
 # at your shell prompt:
 # 
-#   % wget ftp://ftp.neb.com/pub/rebase/emboss*
+#   % wget "ftp://ftp.neb.com/pub/rebase/emboss_*"
 # 
 # 
 # = Usage
@@ -195,7 +195,7 @@ class REBASE
   # * _none_
   # *Returns*:: +Array+ sorted enzyme names
   def enzymes
-    @data.keys.sort
+    @enzyme_names
   end
   
   # Check if supplied name is the name of an available enzyme
@@ -205,10 +205,7 @@ class REBASE
   # * +name+: Enzyme name
   # *Returns*:: +true/false+
   def enzyme_name?(name)
-    enzymes.each do |e|
-      return true if e.downcase == name.downcase
-    end
-    return false
+    @enzyme_names_downcased.include?(name.downcase)
   end
 
   # Save the current data
@@ -290,6 +287,8 @@ class REBASE
       d.references = []
     end
 
+    @enzyme_names = @data.keys.sort
+    @enzyme_names_downcased = @enzyme_names.map{|a| a.downcase}
     setup_enzyme_and_reference_association
   end
 

data/lib/bio/db/sanger_chromatogram/abif.rb

@@ -0,0 +1,120 @@
+#
+# = bio/db/sanger_chromatogram/abif.rb - Abif class 
+#
+# Copyright::	Copyright (C) 2009 Anthony Underwood <anthony.underwood@hpa.org.uk>, <email2ants@gmail.com>
+# License::	The Ruby License
+#
+
+require 'bio/db/sanger_chromatogram/chromatogram'
+
+module Bio
+  # == Description
+  #
+  # This class inherits from the SangerChromatogram superclass. It captures the information contained
+  # within an ABIF format chromatogram file generated by DNA sequencing. See the SangerChromatogram class
+  # for usage.
+  class Abif < SangerChromatogram
+    DATA_TYPES = { 1 => 'byte', 2 => 'char', 3 => 'word', 4 => 'short', 5 => 'long',
+      7 => 'float', 8 => 'double', 10 => 'date', 11 => 'time', 18 => 'pString',
+      19 => 'cString', 12 => 'thumb', 13 => 'bool', 6 => 'rational', 9 => 'BCD',
+      14 => 'point', 15 => 'rect', 16 => 'vPoint', 17 => 'vRect', 20 => 'tag',
+      128 => 'deltaComp', 256 => 'LZWComp', 384 => 'deltaLZW', 1024 => 'user'} # User defined data types have tags numbers >= 1024
+
+    PACK_TYPES = { 'byte' => 'C', 'char' => 'c', 'word' => 'n', 'short' => 'n', 'long' => 'N',
+      'date' => 'nCC', 'time' => 'CCCC', 'pString' => 'CA*', 'cString' => 'Z*',
+      'float' => 'g', 'double' => 'G',
+      'bool' => 'C', 'thumb' => 'NNCC', 'rational' => 'NN', 'point' => 'nn', 
+      'rect' => 'nnnn', 'vPoint' => 'NN', 'vRect' => 'NNNN', 'tag' => 'NN'} # Specifies how to pack each data type
+
+    #sequence attributes
+    
+    # The sample title as entered when sequencing the sample (String)
+    attr_accessor :sample_title
+    # The chemistry used when sequencing e.g Dye terminators => 'term.' (String)
+    attr_accessor :chemistry
+    
+    # see SangerChromatogram class for how to create an Abif object and its usage
+    def initialize(string)
+      header = string.slice(0,128)
+      # read in header info
+      @chromatogram_type, @version, @directory_tag_name, @directory_tag_number, @directory_element_type, @directory_element_size, @directory_number_of_elements, @directory_data_size, @directory_data_offset, @directory_data_handle= header.unpack("a4 n a4 N n n N N N N")
+      @version = @version/100.to_f
+      get_directory_entries(string)
+      # get sequence
+      @sequence = @directory_entries["PBAS"][1].data.map{|char| char.chr.downcase}.join("")
+      #get peak indices
+      @peak_indices = @directory_entries["PLOC"][1].data
+      #get qualities
+      @qualities = @directory_entries["PCON"][1].data
+      # get sample title
+      @sample_title = @directory_entries["SMPL"][1].data
+      @directory_entries["PDMF"].size > 2 ? @dye_mobility = @directory_entries["PDMF"][2].data : @dye_mobility = @directory_entries["PDMF"][1].data
+      #get trace data
+      @chemistry = @directory_entries["phCH"][1].data
+      base_order = @directory_entries["FWO_"][1].data.map{|char| char.chr.downcase}
+      (9..12).each do |data_index|
+        self.instance_variable_set("@#{base_order[data_index-9]}trace", @directory_entries["DATA"][data_index].data)
+      end
+
+    end
+
+    # Returns the data for the name.
+    # If not found, returns nil.
+    # ---
+    # *Arguments*:
+    # * (required) _name_: (String) name of the data
+    # * (required) <em>tag_number</em>: (Integer) tag number (default 1)
+    # *Returns*:: any data type or nil
+    def data(name, tag_number = 1)
+      d = @directory_entries[name]
+      d ? d[tag_number].data : nil
+    end
+
+    private
+    def get_directory_entries(string)
+      @directory_entries = Hash.new
+      offset = @directory_data_offset
+      @directory_number_of_elements.times do
+        entry = DirectoryEntry.new
+        entry_fields = string.slice(offset, @directory_element_size)
+        entry.name, entry.tag_number, entry.element_type, entry.element_size, entry.number_of_elements, entry.data_size, entry.data_offset = entry_fields.unpack("a4 N n n N N N")
+        # populate the entry with the data it refers to
+        if entry.data_size > 4
+          get_entry_data(entry, string)
+        else
+          get_entry_data(entry, entry_fields)
+        end
+        if @directory_entries.has_key?(entry.name)
+          @directory_entries[entry.name][entry.tag_number] = entry
+        else
+          @directory_entries[entry.name] = Array.new
+          @directory_entries[entry.name][entry.tag_number] = entry
+        end
+        offset += @directory_element_size
+      end
+    end
+    def get_entry_data(entry, string)
+      if entry.data_size > 4
+        raw_data = string.slice(entry.data_offset, entry.data_size)
+      else
+        raw_data = string.slice(20,4)
+      end
+      if entry.element_type > 1023
+        # user defined data: not processed as yet by this bioruby module
+        entry.data = raw_data
+      else
+        pack_type = PACK_TYPES[DATA_TYPES[entry.element_type]]
+        pack_type.match(/\*/) ? unpack_string = pack_type : unpack_string = "#{pack_type}#{entry.number_of_elements}"
+        entry.data = raw_data.unpack(unpack_string)
+        if pack_type == "CA*" # pascal string where the first byte is a charcter count and should therefore be removed
+          entry.data.shift
+        end
+      end
+    end
+      
+    class DirectoryEntry
+      attr_accessor :name, :tag_number, :element_type, :element_size, :number_of_elements, :data_size, :data_offset
+      attr_accessor :data
+    end
+  end
+end