bio 1.0.0 → 1.1.0

data/lib/bio/db/kegg/kgml.rb

@@ -3,17 +3,43 @@
 #
 # Copyright::	Copyright (C) 2005
 # 		Toshiaki Katayama <k@bioruby.org>
-# License::	LGPL
+# License::	The Ruby License
 #
-# $Id: kgml.rb,v 1.2 2005/11/05 08:29:53 k Exp $
+# $Id: kgml.rb,v 1.7 2007/04/05 23:35:41 trevor Exp $
 #
+
+autoload :REXML, 'rexml/document'
+
+module Bio
+class KEGG
+
 # == KGML (KEGG XML) parser
 #
 # See http://www.genome.jp/kegg/xml/ for more details on KGML.
 #
+# === Incompatible attribute names with KGML tags
+#
+# <entry>
+#  :id -> :entry_id
+#  :type -> :category
+#  :map -> :pathway
+#  names()
+#  <graphics>
+#  :name -> :label
+#  :type -> :shape
+# <relation>
+#  :entry1 -> :node1
+#  :entry2 -> :node2
+#  :type -> :rel
+#  <subtype>
+#  edge()
+# <reaction>
+#  :name -> :entry_id
+#  :type -> :direction
+#
 # === Examples
 #
-#  file = ARGF.read
+#  file = File.read("kgml/hsa/hsa00010.xml")
 #  kgml = Bio::KEGG::KGML.new(file)
 #
 #  # <pathway> attributes
@@ -26,117 +52,102 @@
 #
 #  kgml.entries.each do |entry|
 #    # <entry> attributes
-#    puts entry.id
+#    puts entry.entry_id
 #    puts entry.name
-#    puts entry.names
-#    puts entry.type
+#    puts entry.category
 #    puts entry.link
 #    puts entry.reaction
-#    puts entry.map
+#    puts entry.pathway
 #    # <graphics> attributes
-#    puts entry.label	# This is an accessor for <graphics name="">
+#    puts entry.label	      # name
+#    puts entry.shape         # type
 #    puts entry.x
 #    puts entry.y
-#    puts entry.type
 #    puts entry.width
 #    puts entry.height
 #    puts entry.fgcolor
 #    puts entry.bgcolor
+#    # <component> attributes
+#    puts entry.components
+#    # methood
+#    puts entry.names
 #  end
 #
 #  kgml.relations.each do |relation|
 #    # <relation> attributes
-#    puts relation.entry1
-#    puts relation.entry2
-#    puts relation.type
+#    puts relation.node1      # entry1
+#    puts relation.node2      # entry2
+#    puts relation.rel        # type
+#    # method
+#    puts relation.edge
 #    # <subtype> attributes
 #    puts relation.name
 #    puts relation.value
-#    # or
-#    relation.subtype.each do |value, name|
-#      puts value, name
-#    end
 #  end
 #
 #  kgml.reactions.each do |reaction|
 #    # <reaction> attributes
-#    puts reaction.name
-#    puts reaction.type
+#    puts reaction.entry_id   # name
+#    puts reaction.direction  # type
 #    # <substrate> attributes
-#    reaction.substrates.each do |name|
-#      puts name
+#    reaction.substrates.each do |entry_id|
+#      puts entry_id
 #      # <alt> attributes
-#      altnames = reaction.alt[name]
-#      altnames.each do |altname|
-#        puts altname
+#      altnames = reaction.alt[entry_id]
+#      altnames.each do |name|
+#        puts name
 #      end
 #    end
 #    # <product> attributes
-#    reaction.products.each do |name|
-#      puts name
+#    reaction.products.each do |entry_id|
+#      puts entry_id
 #      # <alt> attributes
-#      altnames = reaction.alt[name]
-#      altnames.each do |altname|
-#        puts altname
+#      altnames = reaction.alt[entry_id]
+#      altnames.each do |name|
+#        puts name
 #      end
 #    end
 #  end
 #
-#--
-#
-#  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 'rexml/document'
-
-module Bio
-class KEGG
-
 class KGML
 
   def initialize(xml)
-    @dom = REXML::Document.new(xml)
-    parse_root
-    parse_entry
-    parse_relation
-    parse_reaction
+    dom = REXML::Document.new(xml)
+    parse_root(dom)
+    parse_entry(dom)
+    parse_relation(dom)
+    parse_reaction(dom)
   end
   attr_reader :name, :org, :number, :title, :image, :link
-  attr_reader :entries, :relations, :reactions		# Array
+  attr_accessor :entries, :relations, :reactions
 
   class Entry
-    attr_accessor :id, :name, :names, :type, :link, :reaction, :map
-    attr_accessor :label, :x, :y, :type, :width, :height, :fgcolor, :bgcolor
+    attr_accessor :entry_id, :name, :category, :link, :reaction, :pathway
+    attr_accessor :label, :shape, :x, :y, :width, :height, :fgcolor, :bgcolor
+    attr_accessor :components
+    def names
+      @name.split(/\s+/)
+    end
   end
 
   class Relation
-    attr_accessor :entry1, :entry2, :type
+    attr_accessor :node1, :node2, :rel
     attr_accessor :name, :value
-    attr_accessor :subtype      			# Hash
+    def edge
+      @value.to_i
+    end
   end
 
   class Reaction
-    attr_accessor :name, :type
-    attr_accessor :substrates, :products		# Array
-    attr_accessor :alt					# Hash
+    attr_accessor :entry_id, :direction
+    attr_accessor :substrates, :products	# Array
+    attr_accessor :alt				# Hash
   end
 
-  def parse_root
-    root    = @dom.root.attributes
+  private
+
+  def parse_root(dom)
+    root    = dom.root.attributes
     @name   = root["name"]
     @org    = root["org"]
     @number = root["number"]
@@ -145,69 +156,73 @@ class KGML
     @link   = root["link"]
   end
 
-  def parse_entry
+  def parse_entry(dom)
     @entries = Array.new
 
-    @dom.elements.each("/pathway/entry") { |node|
+    dom.elements.each("/pathway/entry") { |node|
       attr = node.attributes
       entry = Entry.new
-      entry.id        = attr["id"].to_i
-      entry.map       = attr["map"]
-      entry.name      = attr["name"]
-      entry.names     = entry.name.split(/\s+/)
-      entry.type      = attr["type"]
-      entry.link      = attr["link"]
-      entry.reaction  = attr["reaction"]
+      entry.entry_id = attr["id"].to_i
+      entry.name     = attr["name"]
+      entry.category = attr["type"]
+      # implied
+      entry.link     = attr["link"]
+      entry.reaction = attr["reaction"]
+      entry.pathway  = attr["map"]
 
       node.elements.each("graphics") { |graphics|
         attr = graphics.attributes
-        entry.x       = attr["x"].to_i
-        entry.y       = attr["y"].to_i
-        entry.type    = attr["type"]
-        entry.label   = attr["label"]	# name
-        entry.width   = attr["width"].to_i
-        entry.height  = attr["height"].to_i
-        entry.fgcolor = attr["fgcolor"]
-        entry.bgcolor = attr["bgcolor"]
+        entry.x        = attr["x"].to_i
+        entry.y        = attr["y"].to_i
+        entry.shape    = attr["type"]
+        entry.label    = attr["name"]
+        entry.width    = attr["width"].to_i
+        entry.height   = attr["height"].to_i
+        entry.fgcolor  = attr["fgcolor"]
+        entry.bgcolor  = attr["bgcolor"]
+      }
+
+      node.elements.each("component") { |component|
+        attr = component.attributes
+        entry.components ||= []
+        entry.components << attr["id"].to_i
       }
+
       @entries << entry
     }
   end
 
-  def parse_relation
+  def parse_relation(dom)
     @relations = Array.new
 
-    @dom.elements.each("/pathway/relation") { |node|
+    dom.elements.each("/pathway/relation") { |node|
       attr = node.attributes
       relation = Relation.new
-      relation.entry1 = attr["entry1"].to_i
-      relation.entry2 = attr["entry2"].to_i
-      relation.type   = attr["type"]
+      relation.node1   = attr["entry1"].to_i
+      relation.node2   = attr["entry2"].to_i
+      relation.rel     = attr["type"]
 
-      hash = Hash.new
       node.elements.each("subtype") { |subtype|
         attr = subtype.attributes
-        relation.name  = name  = attr["name"]
-        relation.value = value = attr["value"].to_i
-        hash[value] = name
+        relation.name  = attr["name"]
+        relation.value = attr["value"]
       }
-      relation.subtype = hash
       @relations << relation
     }
   end
 
-  def parse_reaction
+  def parse_reaction(dom)
     @reactions = Array.new
 
-    @dom.elements.each("/pathway/reaction") { |node|
+    dom.elements.each("/pathway/reaction") { |node|
       attr = node.attributes
       reaction = Reaction.new
-      reaction.name = attr["name"]
-      reaction.type = attr["type"]
+      reaction.entry_id  = attr["name"]
+      reaction.direction = attr["type"]
 
       substrates = Array.new
       products   = Array.new
-      hash       = Hash.new
+      hash        = Hash.new
 
       node.elements.each("substrate") { |substrate|
         name = substrate.attributes["name"]
@@ -225,75 +240,17 @@ class KGML
           hash[name] << alt.attributes["name"]
         }
       }
-
       reaction.substrates = substrates
-      reaction.products   = products
-      reaction.alt        = hash
+      reaction.products = products
+      reaction.alt = hash
 
       @reactions << reaction
     }
   end
 
 end # KGML
+
 end # KEGG
 end # Bio
 
 
-if __FILE__ == $0
-  require 'pp'
-  xml = ARGF.read
-  pp Bio::KEGG::KGML.new(xml)
-end
-
-
-=begin
-
-# This is a test implementation which reflects original KGML data structure.
-
-class KGML
-
-  class Pathway
-    attr_accessor :name, :org, :number, :title, :image, :link
-    attr_accessor :entries, :relations, :reactions
-
-    class Entry
-      attr_accessor :id, :name, :type, :link, :reaction, :map
-      attr_accessor :components, :graphics
-
-      class Component
-        attr_accessor :id
-      end
-
-      class Graphics
-        attr_accessor :name, :x, :y, :type, :width, :height, :fgcolor, :bgcolor
-      end
-    end
-
-    class Relation
-      attr_accessor :entry1, :entry2, :type
-      attr_accessor :
-
-      class Subtype
-        attr_accessor :name, :value
-      end
-    end
-
-    class Reaction
-      attr_accessor :name, :type
-
-      class Substrate
-        attr_accessor :name
-      end
-
-      class Product
-        attr_accessor :name
-      end
-
-      class Alt
-        attr_accessor :name
-      end
-    end
-  end
-
-end
-=end

data/lib/bio/db/kegg/orthology.rb

@@ -0,0 +1,112 @@
+#
+# = bio/db/kegg/orthology.rb - KEGG ORTHOLOGY database class
+#
+# Copyright::  Copyright (C) 2003-2007 Toshiaki Katayama <k@bioruby.org>
+# Copyright::  Copyright (C) 2003 Masumi Itoh <m@bioruby.org>
+# License::    The Ruby License
+#
+# $Id: orthology.rb,v 1.9 2007/04/05 15:42:59 k Exp $
+#
+
+require 'bio/db'
+
+module Bio
+class KEGG
+
+# == Description
+#
+# KO (KEGG Orthology) entry parser.
+#
+# == References
+#
+# * http://www.genome.jp/dbget-bin/get_htext?KO
+# * ftp://ftp.genome.jp/pub/kegg/genes/ko
+#
+class ORTHOLOGY < KEGGDB
+  
+  DELIMITER	= RS = "\n///\n"
+  TAGSIZE	= 12
+
+  # Reads a flat file format entry of the KO database.
+  def initialize(entry)
+    super(entry, TAGSIZE)
+  end
+  
+  # Returns ID of the entry.
+  def entry_id
+    field_fetch('ENTRY')[/\S+/]
+  end
+
+  # Returns NAME field of the entry.
+  def name
+    field_fetch('NAME')
+  end
+
+  # Returns an Array of names in NAME field.
+  def names
+    name.split(', ')
+  end
+
+  # Returns DEFINITION field of the entry.
+  def definition
+    field_fetch('DEFINITION')
+  end
+
+  # Returns CLASS field of the entry.
+  def keggclass
+    field_fetch('CLASS')
+  end
+
+  # Returns an Array of biological classes in CLASS field.
+  def keggclasses
+    keggclass.gsub(/ \[[^\]]+/, '').split(/\] ?/)
+  end
+
+  # Returns an Array of KEGG/PATHWAY ID in CLASS field.
+  def pathways
+    keggclass.scan(/\[PATH:(.*?)\]/).flatten
+  end
+  
+  # Returns a Hash of Array of a database name and entry IDs in DBLINKS field.
+  def dblinks
+    unless @data['DBLINKS']
+      @data['DBLINKS'] = lines_fetch('DBLINKS')
+    end
+    @data['DBLINKS']
+  end
+
+  # Returns a Hash of Array of the organism ID and entry IDs in GENES field.
+  def genes
+    unless @data['GENES']
+      @data['GENES'] = lines_fetch('GENES')
+    end
+    @data['GENES']
+  end
+  
+end # ORTHOLOGY
+    
+end # KEGG
+end # Bio
+
+
+
+if __FILE__ == $0
+
+  require 'bio/io/fetch'
+
+  flat = Bio::Fetch.query('ko', 'K00001')
+  entry = Bio::KEGG::ORTHOLOGY.new(flat)
+
+  p entry.entry_id
+  p entry.name
+  p entry.names
+  p entry.definition
+  p entry.keggclass
+  p entry.keggclasses
+  p entry.pathways
+  p entry.dblinks
+  p entry.genes
+
+end
+
+