ols 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+coverage/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ols.gemspec
+gemspec

data/History.txt

@@ -0,0 +1,6 @@
+=== 0.0.1 2011-04-15
+
+* Initial release:
+  * Basic wrapper around OLS database
+  * Builds tree objects automagically
+  * User configurable connection details

data/README.rdoc

@@ -0,0 +1,117 @@
+= OLS
+
+http://github.com/dazoakley/ols
+
+OLS provides a simple interface to the EBI's Ontology Lookup Service (http://www.ebi.ac.uk/ontology-lookup/).  
+It provides an easy lookup of ontology terms and automagically builds up ontology trees using RubyTree 
+(http://rubytree.rubyforge.org/) as a base library.
+
+<b>PLEASE NOTE</b>: The current version of this gem requires a local install of the OLS database running on MySQL.  
+Please see http://www.ebi.ac.uk/ontology-lookup/databaseExport.do  I will update the code in the future 
+to run off the soap service.
+
+== Install
+
+  gem install ols
+
+== Usage
+
+Include the module in your code:
+  
+  require 'rubygems'
+  require 'ols'
+  
+Then, to lookup an ontology term:
+  
+  ont = OLS::OntologyTerm.new('EMAP:3018')
+  
+This will create a simple tree object for the EMAP term EMAP:3018
+  
+  ont.name          # => "EMAP:3018"
+  ont.term          # => "EMAP:3018"
+  
+  ont.content       # => "TS18,nose"
+  ont.term_name     # => "TS18,nose"
+
+Find out about your ontology term
+  
+  ont.is_root?      # => false
+  ont.is_leaf?      # => false
+  
+<b>NOTE</b>: OntologyTerm's are lazily loaded, so upon initial build the OntologyTerm is just a single node in a 
+tree - no parents, no children.  See here (note the "Total Nodes Loaded" count):
+  
+  ont.to_s          # => "Term: EMAP:3018 Term Name: TS18,nose Root Term?: false Leaf Node?: false  Total Nodes Loaded: 1"
+  
+The tree for the term is built up (parents) and down (children) as it is requested:
+  
+  ont.parentage     # => Array of all parent terms (these will be loaded into the tree now)
+  ont.children      # => Array of all direct child terms (these will also be loaded into the tree now)
+  ont.to_s          # => "Term: EMAP:3018 Term Name: TS18,nose Root Term?: false Leaf Node?: false  Total Nodes Loaded: 4"
+  
+Alternatively, if you want to force load the tree:
+  
+  ont.buld_tree     # => Will load both parents and children into the tree
+  
+Find out more about your tree:
+  
+  ont.root                # => Gives you the root node - in this case: "EMAP:0"
+  ont.all_child_terms     # => An array of all child ontology terms
+  ont.all_child_name      # => An array of all child ontology term names
+  
+For more information on general usage, take a look in the test suite.  Also, OLS::OntologyTerm is a child object of 
+Tree::TreeNode (from the rubytree gem - http://rubytree.rubyforge.org/) and as such inherits all of its methods.
+
+== Database Connection Details
+
+The default database connection details are:
+
+  {
+    :database => 'ols',
+    :host     => '127.0.0.1',
+    :port     => 3306,
+    :user     => 'ols',
+    :password => 'ols'
+  }
+
+If your local copy of the OLS database requires different details, simply do the following once in your code 
+(substituting in your connection details) before any calls to OLS::OntologyTerm are made:
+
+  OLS.db_connection_details = {
+    :database => 'my_ols',
+    :host     => 'ols.example.com',
+    :port     => 3307,
+    :user     => 'user1',
+    :password => 'pass1'
+  }
+
+== Meta
+
+Written by Darren Oakley (daz dot oakley at gmail dot com)
+
+http://github.com/dazoakley/ols
+
+== License
+
+(The MIT License)
+
+Copyright (c) 2011 Darren Oakley
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'shoulda'
+require 'rake/testtask'
+
+desc 'Run the test suite under /test'
+Rake::TestTask.new do |t|
+   t.libs << 'test'
+   t.test_files = FileList['test/test*.rb']
+   t.verbose = true
+end

data/lib/ols.rb

@@ -0,0 +1,422 @@
+
+require 'rubygems'
+require 'tree'
+require 'sequel'
+require 'mysql2'
+require 'json'
+
+# Simple wrapper for interacting with the OLS (Ontology Lookup Service - http://www.ebi.ac.uk/ontology-lookup/) 
+# database (created and managed by the EBI).  Handles interaction with the service and automagically turns 
+# the retieved ontology terms into usable tree stuctures.
+# 
+# @author Darren Oakley
+module OLS
+  
+  class << self
+    attr_accessor :db_connection_details
+    
+    def ols_db
+      @ols_db = connect_to_db() if @ols_db.nil?
+      @ols_db
+    end
+    
+    private
+      
+      def get_db_connection_details
+        defaults = {
+          :database => 'ols',
+          :host     => '127.0.0.1',
+          :port     => 3306,
+          :user     => 'ols',
+          :password => 'ols'
+        }
+        
+        if !OLS.db_connection_details.nil? and OLS.db_connection_details.is_a? Hash
+          defaults.merge!(OLS.db_connection_details)
+        end
+        
+        defaults
+      end
+      
+      def connect_to_db
+        params = { :adapter => 'mysql2', :encoding => 'utf8' }.merge(get_db_connection_details)
+        Sequel.connect(params)
+      end
+  end
+  
+  # Error class for when we can't find a given ontology term.
+  class OntologyTermNotFoundError < StandardError; end
+  
+  # Class representing an ontology term as part of a tree structure. Uses the Tree::TreeNode (rubytree) 
+  # gem as a base class.
+  class OntologyTerm < Tree::TreeNode
+    attr_accessor :already_fetched_parents, :already_fetched_children
+    
+    attr_accessor :root_term, :leaf_node
+    attr_writer   :all_child_terms, :all_child_names
+    protected     :root_term, :leaf_node
+    
+    # @param [String] name The ontology term (id) i.e. GO:00032
+    # @param [String] content The ontology term name/description - optional this will be looked up in the OLS database
+    def initialize( name, content=nil )
+      super
+      
+      @already_fetched_parents  = false
+      @already_fetched_children = false
+      @root_term                = false
+      @leaf_node                = false
+      
+      @all_child_terms          = nil
+      @all_child_names          = nil
+      
+      get_term_details if @content.nil? or @content.empty?
+    end
+    
+    # Override to ensure compatibility with Tree::TreeNode.
+    #
+    # @return [String] The ontology term (id) i.e. GO00032
+    def term
+      self.name
+    end
+
+    # Override to ensure compatibility with Tree::TreeNode.
+    #
+    # @return [String] The ontology term name/description
+    def term_name
+      self.content
+    end
+    
+    # Returns +true+ if the receiver is a root node.  Note that
+    # orphaned children will also be reported as root nodes.
+    #
+    # @return [Boolean] +true+ if this is a root node.
+    def is_root?
+      @root_term
+    end
+    
+    # Returns +true+ if the receiver node is a 'leaf' - i.e., one without
+    # any children.
+    #
+    # @return [Boolean] +true+ if this is a leaf node.
+    def is_leaf?
+      @leaf_node
+    end
+    
+    # Returns string representation of the receiver node.
+    # This method is primarily meant for debugging purposes.
+    #
+    # @return [String] A string representation of the node.
+    def to_s
+      "Term: #{@name}" +
+        " Term Name: " + (@content || "<Empty>") +
+        " Root Term?: #{is_root?}" +
+        " Leaf Node?: #{is_leaf?} " +
+        " Total Nodes Loaded: #{size()}"
+    end
+    
+    # Returns an array of parent OntologyTerm objects.
+    #
+    # @return [Array] An array of parent OntologyTerm objects
+    def parentage
+      get_parents
+      super
+    end
+    
+    # Returns the children of this term as a tree. Will include the current term 
+    # as the 'root' of the tree.
+    #
+    # @return [OntologyTerm] The children of this term as a tree. Will include the current term as the 'root' of the tree.
+    def child_tree
+      build_tree
+      child_tree = self.clone
+      child_tree.remove_from_parent!
+      child_tree
+    end
+
+    # Returns an array of the direct children (OntologyTerm objects) of this term.
+    #
+    # @return [Array] An array of the direct children (OntologyTerm objects) of this term.
+    def children
+      get_children
+      super
+    end
+
+    # Returns a flat array containing all the possible child terms
+    # for this given ontology term.
+    #
+    # @return [Array] An array of all possible child terms (Strings) for this given ontology term
+    def all_child_terms
+      get_all_child_lists
+      return @all_child_terms
+    end
+    
+    # Returns a flat array containing all the possible child term 
+    # names for this given ontology term.
+    #
+    # @return [Array] A flat array containing all the possible child term names (Strings) for this given ontology term
+    def all_child_names
+      get_all_child_lists
+      return @all_child_names
+    end
+    
+    # Function to force the OntologyTerm object to flesh out it's structure 
+    # from the OLS database.  By default OntologyTerm objects are lazy and will 
+    # only retieve child data one level below themselves, so this is used to 
+    # recursivley flesh out a full tree.
+    def build_tree
+      get_parents
+      get_children( self, true )
+    end
+    
+    # Creates a JSON representation of this node including all it's children.   This requires the JSON gem to be
+    # available, or else the operation fails with a warning message.
+    #
+    # @return The JSON representation of this subtree.
+    #
+    # @see {OntologyTerm#json_create}
+    def to_json(*a)
+      json_hash = {
+        "name"            => name,
+        "content"         => content,
+        "root_term"       => @root_term,
+        "leaf_node"       => @leaf_node,
+        "all_child_terms" => @all_child_terms,
+        "all_child_names" => @all_child_names,
+        JSON.create_id    => self.class.name
+      }
+
+      if has_children?
+        json_hash["children"] = children
+      end
+
+      return JSON.generate( json_hash, :max_nesting => false )
+    end
+    
+    # Class level function to build an OntologyTerm object from a serialized JSON hash
+    #
+    # @example
+    #   emap = JSON.parse( File.read("emap.json"), :max_nesting => false )
+    #
+    # @param [Hash] json_hash The parsed JSON hash to de-serialize
+    # @return [OntologyTerm] The de-serialized object 
+    def self.json_create(json_hash)
+      node = new(json_hash["name"], json_hash["content"])
+      node.already_fetched_children = true if json_hash["children"]
+      
+      node.root_term       = true if json_hash["root_term"]
+      node.leaf_node       = true if json_hash["leaf_node"]
+      node.all_child_terms = json_hash["all_child_terms"]
+      node.all_child_names = json_hash["all_child_names"]
+      
+      json_hash["children"].each do |child|
+        child.already_fetched_parents  = true
+        child.already_fetched_children = true if child.has_children?
+        node << child
+      end if json_hash["children"]
+      
+      return node
+    end
+    
+    # Method to set the parent node for the receiver node.
+    # This method should *NOT* be invoked by client code.
+    #
+    # @param [OntologyTerm] parent The parent node.
+    # @return [OntologyTerm] The parent node.
+    def parent=(parent)         # :nodoc:
+      @parent = parent
+    end
+    
+    # Recursive function to query the OLS database and collect all of 
+    # the parent objects and insert them into @parents in the correct 
+    # order.
+    def get_parents( node=self )
+      unless @already_fetched_parents
+        sql = <<-SQL
+          select
+            subject_term.identifier  as child_identifier,
+            subject_term.term_name   as child_term,
+            predicate_term.term_name as relation,
+            object_term.identifier   as parent_identifier,
+            object_term.term_name    as parent_term,
+            object_term.is_root_term as parent_is_root
+          from
+            term_relationship tr
+            join term as subject_term 	on tr.subject_term_pk   = subject_term.term_pk
+            join term as predicate_term on tr.predicate_term_pk = predicate_term.term_pk
+            join term as object_term    on tr.object_term_pk    = object_term.term_pk
+          where
+                predicate_term.term_name in ('part_of','is_a','develops_from')
+            and subject_term.identifier = ?
+        SQL
+        
+        OLS.ols_db[ sql, node.term ].each do |row|
+          parent           = OntologyTerm.new( row[:parent_identifier], row[:parent_term] )
+          parent.root_term = true if row[:parent_is_root].to_i == 1
+          parent << node
+          get_parents( parent )
+        end
+        
+        @already_fetched_parents = true
+      end
+    end
+    
+    # Recursive function to query the OLS database and collect all of 
+    # the child objects and build up a tree of OntologyTerm's.
+    def get_children( node=self, recursively=false )
+      unless @already_fetched_children or node.has_children?
+        sql = <<-SQL
+          select
+            subject_term.identifier  as child_identifier,
+            subject_term.term_name   as child_term,
+            subject_term.is_leaf     as child_is_leaf,
+            predicate_term.term_name as relation,
+            object_term.identifier   as parent_identifier,
+            object_term.term_name    as parent_term
+          from
+            term_relationship tr
+            join term as subject_term   on tr.subject_term_pk   = subject_term.term_pk
+            join term as predicate_term on tr.predicate_term_pk = predicate_term.term_pk
+            join term as object_term    on tr.object_term_pk    = object_term.term_pk
+          where
+                predicate_term.term_name in ('part_of','is_a','develops_from')
+            and object_term.identifier = ?
+        SQL
+        
+        OLS.ols_db[sql,node.term].each do |row|
+          child = OntologyTerm.new( row[:child_identifier], row[:child_term] )
+          child.leaf_node = true if row[:child_is_leaf].to_i == 1
+          child.get_children( child, true ) if recursively and !child.is_leaf?
+          node << child
+        end
+        
+        @already_fetched_children = true
+      end
+    end
+    
+    # Returns a copy of the receiver node, with its parent and children links removed.
+    # The original node remains attached to its tree.
+    #
+    # @return [OntologyTerm] A copy of the receiver node.
+    def detached_copy
+      copy = OLS::OntologyTerm.new(@name, @content ? @content.clone : nil)
+      copy.root_term = @root_term
+      copy.leaf_node = @leaf_node
+      return copy
+    end
+    
+    # Function that merges one OntologyTerm tree into another.
+    #
+    # @param [OntologyTerm] tree The tree that is to be merged into self
+    # @return [OntologyTerm] The merged tree
+    def merge( tree )
+      unless tree.is_a?(OLS::OntologyTerm)
+        raise TypeError, "You can only merge in another OntologyTerm tree!"
+      end
+      
+      unless self.root.name == tree.root.name
+        raise ArgumentError, "Unable to merge trees as they do not share the same root!"
+      end
+      
+      new_tree = merge_subtrees( self.root, tree.root )
+    end
+    
+    private
+      
+      # Utility function to recursivley merge two subtrees
+      #
+      # @param [OntologyTerm] tree1 The target tree to merge into
+      # @param [OntologyTerm] tree2 The donor tree (that will be merged into target)
+      def merge_subtrees( tree1, tree2 )
+        names1 = tree1.has_children? ? tree1.children.map { |child| child.name } : []
+        names2 = tree2.has_children? ? tree2.children.map { |child| child.name } : []
+
+        names_to_merge = names2 - names1
+        names_to_merge.each do |name|
+          tree1 << tree2[name].detached_subtree_copy
+        end
+
+        tree1.children.each do |child|
+          unless tree2[child.name].nil?
+            merge_subtrees( child, tree2[child.name] )
+          end
+        end
+
+        return tree1
+      end
+      
+      # Helper function to query the OLS database and grab the full 
+      # details of the ontology term.
+      def get_term_details
+        # This query ensures we look at the most recent fully loaded ontologies
+        sql = <<-SQL
+          select term.*
+          from term
+          join ontology on ontology.ontology_id = term.ontology_id
+          where term.identifier = ?
+          order by ontology.fully_loaded desc, ontology.load_date asc
+        SQL
+
+        term_set = OLS.ols_db[ sql, @name ].all()
+
+        if term_set.size == 0
+          get_term_from_synonym
+        else
+          subject      = term_set.first
+          @content     = subject[:term_name]
+          @term_pk     = subject[:term_pk]
+          @ontology_id = subject[:ontology_id]
+          @root_term   = true if subject[:is_root_term].to_i == 1
+          @leaf_node   = true if subject[:is_leaf].to_i == 1
+        end
+      end
+      
+      # Helper function to try to find an ontology term via a synonym.
+      def get_term_from_synonym
+        sql = <<-SQL
+          select term.*
+          from term
+          join ontology on ontology.ontology_id = term.ontology_id
+          join term_synonym on term.term_pk = term_synonym.term_pk
+          where term_synonym.synonym_value = ?
+          order by ontology.fully_loaded desc, ontology.load_date asc
+        SQL
+        
+        term_set = OLS.ols_db[ sql, @name ].all()
+        
+        if term_set.size == 0
+          raise OLS::OntologyTermNotFoundError, "Unable to find the term '#{@name}' in the OLS database."
+        end
+        
+        subject      = term_set.first
+        @name        = subject[:identifier]
+        @content     = subject[:term_name]
+        @term_pk     = subject[:term_pk]
+        @ontology_id = subject[:ontology_id]
+        @root_term   = true if subject[:is_root_term].to_i == 1
+        @leaf_node   = true if subject[:is_leaf].to_i == 1
+      end
+      
+      # Helper function to produce the flat lists of all the child
+      # terms and names.
+      def get_all_child_lists
+        get_children
+
+        if @all_child_terms.nil? and @all_child_names.nil?
+          @all_child_terms = []
+          @all_child_names = []
+
+          self.children.each do |child|
+            @all_child_terms.push( child.term )
+            @all_child_terms.push( child.all_child_terms )
+            @all_child_names.push( child.term_name )
+            @all_child_names.push( child.all_child_names )
+          end
+
+          @all_child_terms = @all_child_terms.flatten.uniq
+          @all_child_names = @all_child_names.flatten.uniq
+        end
+      end
+    
+  end
+  
+end

data/lib/ols/version.rb

@@ -0,0 +1,3 @@
+module OLS
+  VERSION = "0.0.1"
+end

data/ols.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ols/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ols"
+  s.version     = OLS::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Darren Oakley"]
+  s.email       = ["daz.oakley@gmail.com"]
+  s.homepage    = "https://github.com/dazoakley/ols"
+  s.summary     = %q{A simple wrapper around a local copy of the OLS database}
+  s.description = %q{
+    OLS provides a simple interface to the EBI's Ontology Lookup Service (http://www.ebi.ac.uk/ontology-lookup/).  
+    It provides an easy lookup of ontology terms and automagically builds up ontology trees using RubyTree 
+    (http://rubytree.rubyforge.org/) as a base library.
+
+    PLEASE NOTE: The current version of this gem requires a local install of the OLS database running on MySQL.  
+    Please see http://www.ebi.ac.uk/ontology-lookup/databaseExport.do  I will update the code in the future 
+    to run off the soap service.
+  }
+
+  s.rubyforge_project = "ols"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency "rubytree"
+  s.add_dependency "sequel"
+  s.add_dependency "mysql2"
+  s.add_dependency "json"
+  
+  s.add_development_dependency "rake"
+  s.add_development_dependency "shoulda"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "simplecov-rcov"
+end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+# Add the lib directory to the search path
+$:.unshift( "#{File.expand_path(File.dirname(__FILE__))}/../lib" )
+
+require 'rubygems'
+
+# Set-up SimpleCov (code coverage tool for Ruby 1.9)
+if /^1.9/ === RUBY_VERSION
+  begin
+    require 'simplecov'
+    require 'simplecov-rcov'
+    
+    class SimpleCov::Formatter::MergedFormatter
+      def format(result)
+         SimpleCov::Formatter::HTMLFormatter.new.format(result)
+         SimpleCov::Formatter::RcovFormatter.new.format(result)
+      end
+    end
+    
+    SimpleCov.formatter = SimpleCov::Formatter::MergedFormatter
+    SimpleCov.start
+  rescue LoadError
+    puts "[ERROR] Unable to load 'simplecov' - please run 'bundle install'"
+  end
+end
+
+require 'shoulda'
+require 'ols'
+
+OLS.db_connection_details = {
+  :port     => 13306,
+  :database => 'htgt_ols',
+  :user     => 'htgt',
+  :password => 'htgt'
+}

data/test/test_ols.rb

@@ -0,0 +1,124 @@
+require 'test_helper'
+
+class OLSTest < Test::Unit::TestCase
+  include OLS
+  
+  context "An OntologyTerm object" do
+    setup do
+      @emap_id   = "EMAP:3018"
+      @emap_name = "TS18,nose"
+      @ont = OntologyTerm.new(@emap_id)
+    end
+    
+    should "have basic attributes" do
+      assert_equal( @emap_id, @ont.name, "OntologyTerm.name does not equal '#{@emap_id}'." )
+      assert_equal( @emap_id, @ont.term, "OntologyTerm.term does not equal '#{@emap_id}'." )
+      
+      assert_equal( @emap_name, @ont.content, "OntologyTerm.content does not equal '#{@emap_name}'." )
+      assert_equal( @emap_name, @ont.term_name, "OntologyTerm.term_name does not equal '#{@emap_name}'." )
+      
+      assert_equal( false, @ont.term_name.nil?, "The OntologyTerm.term_name is nil." )
+      assert_equal( false, @ont.content.nil?, "The OntologyTerm.term_name is nil." )
+    end
+    
+    should "raise appropriate errors" do
+      assert_raise(OntologyTermNotFoundError) { OntologyTerm.new("FLIBBLE:5") }
+    end
+    
+    should "be able to represent itself as a String" do
+      string = @ont.to_s
+      
+      assert( string.include?('Term Name'), "OntologyTerm.to_s does not include 'Term Name'." )
+      assert( string.include?(@ont.content), "OntologyTerm.to_s does not include '@content'." )
+      assert( string.include?('Root Term?'), "OntologyTerm.to_s does not include 'Root Term?'." )
+      assert( string.include?('Leaf Node?'), "OntologyTerm.to_s does not include 'Leaf Node?'." )
+    end
+    
+    should "respond correctly to the .parentage method" do
+      assert( @ont.parentage.is_a?(Array), "OntologyTerm.parentage is not an Array when we have parents." )
+      assert( @ont.parentage[0].is_a?(OntologyTerm), "OntologyTerm.parentage[0] does not return an OntologyTerm tree." )
+      assert_equal( 4, @ont.parentage.size, "OntologyTerm.parentage is not returning the correct number of entries (we expect 4 for #{@emap_id})." )
+    end
+    
+    should "be able to generate its child tree" do
+      assert( @ont.child_tree.is_a?(OntologyTerm), "OntologyTerm.child_tree does not return an OntologyTerm tree." )
+      assert_equal( @ont.term, @ont.child_tree.term, "OntologyTerm.child_tree.root is equal to self." )
+    end
+        
+    should "respond correctly to the .children method" do
+      assert( @ont.children.is_a?(Array), "OntologyTerm.children is not an Array when we have children." )
+      assert( @ont.children[0].is_a?(OntologyTerm), "OntologyTerm.children[0] does not return an OntologyTerm tree." )
+      assert_equal( 3, @ont.children.size, "OntologyTerm.children is not returning the correct number of entries (we expect 3 direct children for #{@emap_id})." )
+    end
+    
+    should "be able to generate a flat list of all child terms/names" do
+      assert( @ont.all_child_terms.is_a?(Array), "OntologyTerm.all_child_terms is not an Array." )
+      assert( @ont.all_child_terms[0].is_a?(String), "OntologyTerm.all_child_terms[0] is not an String." )
+      assert_equal( 14, @ont.all_child_terms.size, "OntologyTerm.all_child_terms is not returning the correct number of entries (we expect 14 children for #{@emap_id})." )
+      
+      assert( @ont.all_child_names.is_a?(Array), "OntologyTerm.all_child_names is not an Array." )
+      assert( @ont.all_child_names[0].is_a?(String), "OntologyTerm.all_child_names[0] is not an String." )
+      assert_equal( 14, @ont.all_child_names.size, "OntologyTerm.all_child_names is not returning the correct number of entries (we expect 14 children for #{@emap_id})." )
+      
+      assert_equal( @ont.all_child_terms.size, @ont.all_child_names.size, "OntologyTerm.all_child_terms and OntologyTerm.all_child_names do not produce an array of the same size." )
+    end
+    
+    should "be able to locate ontology terms via synonyms" do
+      go_id = 'GO:0007242'
+      ont   = OntologyTerm.new(go_id)
+      
+      assert_equal( 'GO:0023034', ont.term, "A synonym search for GO:0007242 has not found GO:0023034." )
+      assert_equal( 'intracellular signaling pathway', ont.term_name, "A synonym search for GO:0007242 has not found 'intracellular signaling pathway'." )
+    end
+    
+    should "be able to serialize/deserialize itself as a JSON string" do
+      @ont.build_tree()
+      
+      json_string = nil
+      assert_nothing_raised(Exception) { json_string = @ont.to_json }
+      assert( json_string.is_a?(String) )
+      
+      duplicate = nil
+      assert_nothing_raised(Exception) { duplicate = JSON.parse(json_string) }
+      assert( duplicate.is_a?(OntologyTerm) )
+      assert_equal( @ont.term, duplicate.term )
+      assert_equal( @ont.term_name, duplicate.term_name )
+      assert_equal( @ont.is_root?, duplicate.is_root? )
+      assert_equal( @ont.is_leaf?, duplicate.is_leaf? )
+    end
+    
+    should "be able to produce a detached copy of itself" do
+      @ont.build_tree()
+      duplicate = @ont.detached_copy
+      
+      assert_equal( @ont.term, duplicate.term )
+      assert_equal( @ont.term_name, duplicate.term_name )
+      assert_equal( @ont.is_root?, duplicate.is_root? )
+      assert_equal( @ont.is_leaf?, duplicate.is_leaf? )
+      
+      assert_equal( false, duplicate.send(:already_fetched_parents) )
+      assert_equal( false, duplicate.send(:already_fetched_children) )
+    end
+    
+    should "be able to merge two ontology trees" do
+      @ont2 = OntologyTerm.new('EMAP:3003')
+      
+      @ont.build_tree
+      @ont2.build_tree
+      
+      merged_tree = @ont.merge(@ont2)
+      
+      assert( merged_tree['EMAP:2636']['EMAP:2822']['EMAP:2987'].is_a?(OntologyTerm) )
+      assert_equal( 2, merged_tree['EMAP:2636']['EMAP:2822']['EMAP:2987'].children.size )
+      assert_equal( 34, merged_tree.size )
+      
+      another_ont     = OntologyTerm.new('GO:0023034')
+      yet_another_ont = OntologyTerm.new('EMAP:3003')
+      another_ont.build_tree
+      yet_another_ont.build_tree
+      
+      assert_raise(ArgumentError) { foo = another_ont.merge(yet_another_ont) }
+      assert_raise(TypeError) { bar = another_ont.merge('EMAP:3003') }
+    end
+  end
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification 
+name: ols
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Darren Oakley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-15 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubytree
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mysql2
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: json
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: simplecov-rcov
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id008
+description: "\n    OLS provides a simple interface to the EBI's Ontology Lookup Service (http://www.ebi.ac.uk/ontology-lookup/).  \n    It provides an easy lookup of ontology terms and automagically builds up ontology trees using RubyTree \n    (http://rubytree.rubyforge.org/) as a base library.\n\n    PLEASE NOTE: The current version of this gem requires a local install of the OLS database running on MySQL.  \n    Please see http://www.ebi.ac.uk/ontology-lookup/databaseExport.do  I will update the code in the future \n    to run off the soap service.\n  "
+email: 
+- daz.oakley@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- History.txt
+- README.rdoc
+- Rakefile
+- lib/ols.rb
+- lib/ols/version.rb
+- ols.gemspec
+- test/test_helper.rb
+- test/test_ols.rb
+has_rdoc: true
+homepage: https://github.com/dazoakley/ols
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -2283321119041692548
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -2283321119041692548
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ols
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A simple wrapper around a local copy of the OLS database
+test_files: 
+- test/test_helper.rb
+- test/test_ols.rb