obo_parser 0.2.1 → 0.3.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 mjy
+Copyright (c) 2010 Matt Yoder
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,16 +1,44 @@
 = obo_parser
 
-A simple OBO file format parsing library.
+A simple Ruby gem for parsing OBO formatted ontology files.  Useful for reporting, comparing, and mapping data to other databases.  There is presently no functionality for logical inference across the ontology.
 
-== Note on Patches/Pull Requests
+== Installation
+
+  gem install obo_parser
+
+== Use
+
+    require 'rubygems'
+    require 'obo_parser'
+    foo = parse_obo_file(File.read('my_ontology.obo'))  # => An OboParser instance.  Targets OBO v. 1.4
+    first_term = foo.terms.first                        # => An OboParser#Term instance 
+    d = first_term.def                                  # => An OboParser#Tag instance
  
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+    d.tag                                               # => 'def'
+    d.value                                             # => 'Some defintition'
+    d.xrefs                                             # => ['xref:123', 'xref:456'] 
+    d.comment                                           # => 'Some comment'
+    
+    t = first_term.name                                 # => An OboParser#Tag instance    
+    t.tag                                               # => 'name'
+    t.value                                             # => 'Some Term name' 
+
+    o = first_term.other_tags                           # => [OboParser#Tag, ... ] An array of tags that are not specially referenced in an OboParser::Stanza
+    o.first                                             # => An OboParser#Tag instance    
+
+    first_typedef = foo.typdefs.first                   # => An OboParser#Typdef instance 
+    first_typdef.id.value                               # => 'Some typedef id'
+    first_typdef.name.value                             # => 'Some typedef name'
+
+    foo.terms.first.tags_named('is_a')                  # => [OboParser#Tag, ... ]
+    foo.terms.first.tags_named('is_a').first.tag        # => 'is_a'
+    foo.terms.first.tags_named('is_a').first.value      # => 'Some Term id'
+
+See also /test/test_obo_parser.rb
+
+== Utilties
+
+A small set of methods (e.g. comparing OBO ontologies) utilizing the gem are included in utilities.rb. See /lib/utilities.rb.  For example, shared labels across sets of ontologies can be found and returned.
 
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/lib/lexer.rb

@@ -56,4 +56,5 @@ class OboParser::Lexer
       return false
     end
   end
+
 end

data/lib/obo_parser.rb

@@ -2,113 +2,159 @@
 # uses the PhyloTree parser/lexer engine by Krishna Dole which in turn was based on
 # Thomas Mailund's <mailund@birc.dk> 'newick-1.0.5' Python library
 
-# outstanding issues:
+#== Outstanding issues:
+# * Better documentation
+# * More tests
 
 module OboParser
 
-require File.expand_path(File.join(File.dirname(__FILE__), 'tokens'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'parser'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'lexer'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'utilities'))
+  require File.expand_path(File.join(File.dirname(__FILE__), 'tokens'))
+  require File.expand_path(File.join(File.dirname(__FILE__), 'parser'))
+  require File.expand_path(File.join(File.dirname(__FILE__), 'lexer'))
+  require File.expand_path(File.join(File.dirname(__FILE__), 'utilities'))
 
+  class OboParser 
+    attr_accessor :terms, :typedefs
 
-class OboParser # Node
-  attr_accessor :terms, :typedefs
+    def initialize 
+      @terms = []
+      @typedefs = [] 
+      true
+    end
 
-  def initialize # :yields: true
-    @terms = []
-    @typedefs = [] 
-    true
-  end
+    def term_strings # :yields: Array of Strings
+      @terms.collect{|t| t.name.value}.sort
+    end
 
-  def term_strings # :yields: Array of Strings
-    @terms.collect{|t| t.name}.sort
-  end
+    # Warning! This assumes terms are unique, they are NOT required to be so in an OBO file.
+    def term_hash # :yields: Hash (String => String) (name => id)
+      @terms.inject({}) {|sum, t| sum.update(t.name.value => t.id.value)}
+    end
 
-  def term_hash # :yields: Hash (String => String) (name => id)
-    # Warning! This assumes terms are unqiue, they are not required to be so. 
-    @terms.inject({}) {|sum, t| sum.update(t.name => t.id)}
-  end
+    def id_hash # :yields: Hash (String => String (id => name))
+      @terms.inject({}) {|sum, t| sum.update(t.id.value => t.name.value)}
+    end
 
-  def id_hash # :yields: Hash (String => String (id => name)
-    # ids are unique
-    @terms.inject({}) {|sum, t| sum.update(t.id => t.name)}
-  end
+    class Stanza
+      # Make special reference to several specific types of tags (:name, :id), subclasses will remove additional special typs from :other_tags
+      attr_accessor :name, :id, :other_tags
+
+      def initialize(tags)
+        @other_tags = []
+
+        while tags.length != 0
+          t = tags.shift
+
+          new_tag = OboParser::Tag.new
+          new_tag.tag = t.tag
+          new_tag.value = t.value
+          new_tag.comment = t.comment
+          new_tag.xrefs = t.xrefs
+
+          case new_tag.tag
+          when 'id' 
+            @id = new_tag
+          when 'name'
+            @name = new_tag
+          else
+            @other_tags.push(new_tag)
+          end
+        end
+      end
 
-  class Stanza
-    attr_accessor :name, :id, :tags
-    # we can have only one of id, name, and some others (but this is a loose setup now)
-    # can have many of some other things- put them in tags
-    
-    def initialize(tags)
-      @tags = {}
-      tags.each do |t|
-        case t[0]
-        when 'id' 
-          @id = t[1] 
-        when 'name'
-          @name = t[1]
-        else
-          @tags[t[0]] = [] if !@tags[t[0]] 
-          @tags[t[0]].push t[1]
+      #=== Convienience methods
+
+      def tags_named(tag_name = nil)
+        return nil if tag_name.nil?
+        result = []
+        @other_tags.each do |t|
+          result.push t if t.tag == tag_name
         end
+        result
       end
+
     end
-  end
 
-  class Term < Stanza
-    attr_accessor :def
-    def initialize(tags)
-      super
+    class Term < Stanza
+      attr_accessor :def
+      def initialize(tags)
+        super
+
+        anonymous_tags = [] 
+
+        # Loop through "unclaimed" tags and reference those specific to Term
+        while @other_tags.size != 0
+          t = @other_tags.shift
+          case t.tag
+          when 'def' 
+            @def = t
+          else
+            anonymous_tags.push(t)
+          end
+        end
+        @other_tags = anonymous_tags
+      end
+    end
+
+    class Typedef < Stanza
+      def initialize(tags)
+        super
+        #anonymous_tags = [] 
+        ## Loop through "unclaimed" tags and reference those specific to Typedef
+        #while @other_tags.size != 0
+        #  t = @other_tags.shift
+        #  case t.tag
+        #  when 'def' 
+        #    @def = t
+        #  else
+        #    anonymous_tags.push(t)
+        #  end
+        #  @other_tags = anonymous_tags
+        #end
+      end
     end
-  end
 
-  class Typedef < Stanza
-    def initialize(tags)
-      super
+    class Tag
+      attr_accessor :tag, :value, :xrefs, :comment
     end
+
   end
 
-end
+  class OboParserBuilder
+    def initialize
+      @of =  OboParser.new 
+    end
 
+    def add_term(tags)
+      @of.terms.push OboParser::Term.new(tags)
+    end
 
-class OboParserBuilder
-  def initialize
-    @of =  OboParser.new 
-  end
+    def add_typedef(tags)
+      @of.typedefs.push OboParser::Typedef.new(tags)
+    end
 
-  def add_term(tags)
-    @of.terms.push OboParser::Term.new(tags)
-  end
+    def obo_file
+      @of
+    end
 
-  def add_typedef(tags)
-    @of.typedefs.push OboParser::Typedef.new(tags)
   end
 
-  def obo_file
-    @of
+  class ParseError < StandardError
   end
 
-end
-
-class ParseError < StandardError
-end
-
 end # end module
 
-# the actual method
+#= Implementation
+
 def parse_obo_file(input)
   @input = input
-   raise(OboParser::ParseError, "Nothing passed to parse!") if  !@input ||  @input.size == 0
+  raise(OboParser::ParseError, "Nothing passed to parse!") if !@input || @input.size == 0
+
+  # Comments are handled now.
+  # @input.gsub!(/(\s*?![^!'"]*?\n)/i, "\n")  # strip out comments - this is a kludge, likely needs fixing!!
 
-  @input.gsub!(/(\s*?![^!'"]*?\n)/i, "\n")  # strip out comments - this is a kludge, likely needs fixing!!
-    
   builder = OboParser::OboParserBuilder.new
   lexer = OboParser::Lexer.new(@input)
   OboParser::Parser.new(lexer, builder).parse_file
   return builder.obo_file  
 end
-
-
-
-

data/lib/parser.rb

@@ -5,21 +5,21 @@ class OboParser::Parser
   end
 
   def parse_file
-    # toss everything right now, we just want the terms
+    # At present we ignore the header lines
     while !@lexer.peek(OboParser::Tokens::Term)
       @lexer.pop(OboParser::Tokens::TagValuePair)
     end
 
     i = 0
     while !@lexer.peek(OboParser::Tokens::Typedef) && !@lexer.peek(OboParser::Tokens::EndOfFile)
-      raise OboParser::ParseError, "infinite loop in Terms" if i > 10000000 
+      raise OboParser::ParseError, "infinite loop in Terms" if i > 10000000 # there aren't that many words! 
       parse_term
       i += 1
     end
 
     i = 0
     while @lexer.peek(OboParser::Tokens::Typedef) 
-      raise OboParser::ParseError,"infinite loop in Terms" if i > 1000000 # there aren't that many words!
+      raise OboParser::ParseError,"infinite loop in Typedefs" if i > 1000000 
       parse_typedef
       i += 1
     end    
@@ -29,11 +29,11 @@ class OboParser::Parser
     t = @lexer.pop(OboParser::Tokens::Term)
     tags = []
     while !@lexer.peek(OboParser::Tokens::Term) && !@lexer.peek(OboParser::Tokens::Typedef) && !@lexer.peek(OboParser::Tokens::EndOfFile) 
-      if @lexer.peek(OboParser::Tokens::TagValuePair)
+      begin
         t = @lexer.pop(OboParser::Tokens::TagValuePair)
-        tags.push [t.tag, t.value]
-      else
-        raise(OboParser::ParseError, "Expected a tag-value pair, but did not get one following this tag/value: [#{t.tag} / #{t.value}]")
+        tags.push(t) 
+      rescue 
+        raise 
       end
     end
     @builder.add_term(tags)
@@ -41,11 +41,14 @@ class OboParser::Parser
 
   def parse_typedef
     @lexer.pop(OboParser::Tokens::Typedef)
-    #  @t = @builder.stub_typdef
     tags = []
     while !@lexer.peek(OboParser::Tokens::Typedef) && @lexer.peek(OboParser::Tokens::TagValuePair)
-      t = @lexer.pop(OboParser::Tokens::TagValuePair)
-      tags.push [t.tag, t.value]
+      begin
+        t = @lexer.pop(OboParser::Tokens::TagValuePair)
+        tags.push(t) 
+      rescue
+        raise 
+      end
     end
     @builder.add_typedef(tags)
   end

data/lib/tokens.rb

@@ -9,9 +9,6 @@ module OboParser::Tokens
     end
   end
 
-  # in ruby, \A is needed if you want to only match at the beginning of the string, we need this everywhere, as we're
-  # moving along popping off
- 
   class Term < Token
     @regexp = Regexp.new(/\A\s*(\[term\])\s*/i)
   end
@@ -20,19 +17,52 @@ module OboParser::Tokens
     @regexp = Regexp.new(/\A\s*(\[typedef\])\s*/i)
   end
 
-
   class TagValuePair < Token
-    attr_reader :tag, :value
-    @regexp = Regexp.new(/\A\s*([^:]+:.+)\s*\n*/i) #  returns key => value hash for tokens like 'foo=bar' or foo = 'b a ar'
+    attr_reader :tag, :comment, :xrefs
+    @regexp = Regexp.new(/\A\s*([^:]+:.+)\s*\n*/i) 
     def initialize(str)
       str.strip!
-      str = str.split(':',2)      
-      
-      str[1].strip!
-      # strip trailing comments
+      tag, value = str.split(':',2)      
+
+      value.strip!
+
+      # Handle comments 
+      if value =~ /(!\s*.+)\Z/i
+        @comment = $1
+        value.gsub!(@comment, '')
+        @comment.gsub!(/\A!\s*/, '')
+      end 
+
+      # Break out the xrefs, could be made made robust 
+      # Assumes non-quoted comma delimited in format 'foo:bar, stuff:things'
+      if value =~ /(\s*\[.*\]\s*)/i 
+        xref_list = $1
+        value.gsub!(xref_list, '')
+        xref_list.strip!
+        xref_list = xref_list[1..-2] # strip []
+        @xrefs = xref_list.split(",") 
+      end
 
-      @tag = str[0]
-      @value = str[1]
+      @tag = tag.strip
+      @value = value.strip
+
+      @value = @value[1..-2] if @value[0..0] == "\"" # get rid of quote marks
+      @value = @value[1..-2] if @value[0..0] == "'"  # get rid of quote marks
+
+      @tag = @tag.strip
+      @value = @value.strip
+    end
+  end
+
+  class XrefList < Token
+    @regexp = Regexp.new(/\A\s*\[(.+)\]\s*\n*/i) #  returns key => value hash for tokens like 'foo=bar' or foo = 'b a ar'
+    def initialize(str)
+      str.strip!
+      @value = {}
+      str.split(",").each do |s| 
+        i = s.split(":")
+        @value.merge!(i[0].strip => i[1].strip)
+      end
     end
   end
 
@@ -56,8 +86,6 @@ module OboParser::Tokens
     end
   end
 
-
-
   # note we grab EOL and ; here 
   class ValuePair < Token
     @regexp = Regexp.new(/\A\s*([\w\d\_\&]+\s*=\s*((\'[^\']+\')|(\(.*\))|(\"[^\"]+\")|([^\s\n\t;]+)))[\s\n\t;]+/i) #  returns key => value hash for tokens like 'foo=bar' or foo = 'b a ar'
@@ -71,90 +99,73 @@ module OboParser::Tokens
     end
   end
 
-  class Matrix < Token
-    @regexp = Regexp.new(/\A\s*(matrix)\s*/i)
-  end
-
-  class RowVec < Token
-    @regexp = Regexp.new(/\A\s*(.+)\s*\n/i)
-     def initialize(str)
-      s = str.split(/\(|\)/).collect{|s| s=~ /[\,|\s]/ ? s.split(/[\,|\s]/) : s}.inject([]){|sum, x| x.class == Array ? sum << x.delete_if {|y| y == "" } : sum + x.strip.split(//)}
-      @value = s
-    end
+  class EndOfFile < Token
+    @regexp = Regexp.new('\A(\s*\n*)\Z')
   end
 
-
-
   ## punctuation
 
   class LBracket < Token
     @regexp = Regexp.new('\A\s*(\[)\s*')
   end
 
-  class RBracket < Token
-    @regexp = Regexp.new('\A\s*(\])\s*')
-  end
-
-  class LParen < Token
-      @regexp = Regexp.new('\A\s*(\()\s*')
-  end
-
-  class RParen < Token
-    @regexp = Regexp.new('\A\s*(\))\s*')
-  end
+  #class LParen < Token
+  #  @regexp = Regexp.new('\A\s*(\()\s*')
+  #end
+  
+  #class RBracket < Token
+  #  @regexp = Regexp.new('\A\s*(\])\s*')
+  #end
+  
+  #class RParen < Token
+  #  @regexp = Regexp.new('\A\s*(\))\s*')
+  #end
+  
+  #class Equals < Token
+  #  @regexp = Regexp.new('\A\s*(=)\s*')
+  #end
+  
+  #class BckSlash < Token
+  #  @regexp = Regexp.new('\A\s*(\/)\s*')
+  #end
+  
+  #class Colon < Token
+  #  @regexp = Regexp.new('\A\s*(:)\s*')
+  #end
+  
+  #class SemiColon < Token
+  #  @regexp = Regexp.new('\A\s*(;)\s*')
+  #end
+  
+  #class Comma < Token
+  #  @regexp = Regexp.new('\A\s*(\,)\s*')
+  #end
  
-  class Equals < Token
-    @regexp = Regexp.new('\A\s*(=)\s*')
-  end
-
-  class BckSlash < Token
-    @regexp = Regexp.new('\A\s*(\/)\s*')
-  end
-
-
-  class Colon < Token
-    @regexp = Regexp.new('\A\s*(:)\s*')
-  end
-
-  class SemiColon < Token
-    @regexp = Regexp.new('\A\s*(;)\s*')
-  end
-
-  class Comma < Token
-    @regexp = Regexp.new('\A\s*(\,)\s*')
-  end
-
-  class EndOfFile < Token
-    @regexp = Regexp.new('\A(\s*\n*)\Z')
-  end
-
-  class Number < Token
-    @regexp = Regexp.new('\A\s*(-?\d+(\.\d+)?([eE][+-]?\d+)?)\s*')
-    def initialize(str)
-      # a little oddness here, in some case we don't want to include the .0
-      # see issues with numbers as labels
-      if str =~ /\./
-        @value = str.to_f
-      else
-        @value = str.to_i
-      end
-
-    end
-  end
-
-  # Tokens::NexusComment
-
-  # this list also defines priority, i.e. if tokens have overlap (which they shouldn't!!) then the earlier indexed token will match first
+  #class Number < Token
+  #  @regexp = Regexp.new('\A\s*(-?\d+(\.\d+)?([eE][+-]?\d+)?)\s*')
+  #  def initialize(str)
+  #    # a little oddness here, in some case we don't want to include the .0
+  #    # see issues with numbers as labels
+  #    if str =~ /\./
+  #      @value = str.to_f
+  #    else
+  #      @value = str.to_i
+  #    end
+  #  end
+  #end
+
+  # This list defines inclusion and priority, i.e. if tokens have overlap then the earlier indexed token will match first
   def self.obo_file_token_list
     [ 
       OboParser::Tokens::Term,
       OboParser::Tokens::Typedef,
-      OboParser::Tokens::TagValuePair,
-      OboParser::Tokens::NameValuePair,  # not implemented
-      OboParser::Tokens::Dbxref,         # not implemented
       OboParser::Tokens::LBracket,
+      OboParser::Tokens::TagValuePair,
+      OboParser::Tokens::XrefList,
       OboParser::Tokens::EndOfFile
+      # OboParser::Tokens::NameValuePair,  # not implemented
+      # OboParser::Tokens::Dbxref,         # not implemented
     ]   
   end
-  
+
 end

data/lib/utilities.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'ruby-debug'
-require 'obo_parser'
+require File.expand_path(File.join(File.dirname(__FILE__), 'obo_parser')) 
 
 module OboParser::Utilities
 
@@ -11,7 +11,6 @@ module OboParser::Utilities
 	#	of4 = File.read('hao4.obo')	
   #
   #  OboParser::Utilities::dump_comparison_by_id([of1, of2, of3, of4])
-
   def self.dump_comparison_by_id(files = []) # :yields: String
     of = [] 
     files.each_with_index do |f, i|
@@ -39,10 +38,9 @@ module OboParser::Utilities
     end
   end
 
+  # infile is a tab delimited 2 column file that contains IDs in the from FOO_1234
+  # The file is replicated to STDOUT replacing the ID with the Term
   def self.alignment_translate(infile = nil) # :yields: String
-    # infile is a tab delimited 2 column file that contains IDs in the from FOO_1234
-    # The file is replicated to STDOUT replacing the ID with the Term
-
     agreement = ARGV[0]
     raise "Provide a file with comparison." if agreement.nil? 
     comparison = File.read(agreement)
@@ -70,22 +68,15 @@ module OboParser::Utilities
             "\t" +
            (identifiers[v2].nil? ? 'NOT FOUND' : identifiers[v2]) 
     end
-
   end 
 
-
-  def self.shared_labels(files = []) # :yields: String
-
   # Returns labels found in all passed ontologies 
-
   # Usage:
-
-  # of1 = File.read('fly_anatomy.obo')	
-  # of2 = File.read('hao.obo')	
-  # of3 = File.read('mosquito_anatomy.obo')	
-
-  # shared_labels([of1, of6])
-
+  #  of1 = File.read('fly_anatomy.obo')	
+  #  of2 = File.read('hao.obo')	
+  #  of3 = File.read('mosquito_anatomy.obo')	
+  #  shared_labels([of1, of6])
+  def self.shared_labels(files = []) # :yields: String
     comparison = {}
 
     files.each do |f|
@@ -109,10 +100,8 @@ module OboParser::Utilities
     end
 
    puts  match.sort.join("\n")
-
    puts "\n#{match.length} total."
 
   end 
-
  
 end

data/obo_parser.gemspec

@@ -5,23 +5,21 @@
 
 Gem::Specification.new do |s|
   s.name = %q{obo_parser}
-  s.version = "0.2.1"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["mjy"]
-  s.date = %q{2011-02-28}
+  s.date = %q{2011-04-05}
   s.description = %q{Provides all-in-one object containing the contents of an OBO formatted file.  OBO version 1.2 is targeted, though this should work for 1.0. }
   s.email = %q{diapriid@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README",
      "README.rdoc"
   ]
   s.files = [
     ".document",
      ".gitignore",
      "LICENSE",
-     "README",
      "README.rdoc",
      "Rakefile",
      "VERSION",
@@ -43,17 +41,16 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/mjy/obo_parser}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.5.3}
   s.summary = %q{A simple OBO file handler.}
   s.test_files = [
     "test/test_obo_parser.rb"
   ]
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
     else
     end
   else

data/test/cell.obo

@@ -5865,3 +5865,4 @@ is_a: CL:0000349 ! extraembryonic cell
 id: develops_from
 name: develops_from
 is_transitive: true
+

data/test/test_obo_parser.rb

@@ -2,7 +2,7 @@ require 'test/unit'
 require 'rubygems'
 require 'ruby-debug'
 
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/obo_parser'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/obo_parser')) 
 
 class OboParserTest < Test::Unit::TestCase
   def test_truth
@@ -16,15 +16,12 @@ class Test_OboParserBuilder < Test::Unit::TestCase
   end
 end
 
-
 class Test_Regex < Test::Unit::TestCase
 
-  def test_comment_stripping
-    # hackish, likely will fail with complex combinations of "!"
-    txt = "line without note\nBegin taxa; ! comment\n! not this line\n'this ok!'\n\"this too!!\""
-    r2 = Regexp.new(/(\s*?![^!'"]*?\n)/i)
-    assert_equal "line without note\nBegin taxa;\n\n'this ok!'\n\"this too!!\"" , txt.gsub(r2, "\n")    
+  def test_some_regex
+    assert true 
   end
+
 end
 
 class Test_Lexer < Test::Unit::TestCase
@@ -60,7 +57,8 @@ class Test_Lexer < Test::Unit::TestCase
 
     assert t = lexer.pop(OboParser::Tokens::TagValuePair)
     assert_equal 'def', t.tag
-    assert_equal '"A chromatic scalar-circular quality inhering in an object that manifests in an observer by virtue of the dominant wavelength of the visible light; may be subject to fiat divisions, typically into 7 or 8 spectra." [PATOC:cjm]', t.value
+    assert_equal 'A chromatic scalar-circular quality inhering in an object that manifests in an observer by virtue of the dominant wavelength of the visible light; may be subject to fiat divisions, typically into 7 or 8 spectra.', t.value
+    assert_equal(['PATOC:cjm'], t.xrefs) 
 
     assert t = lexer.pop(OboParser::Tokens::TagValuePair)
     assert_equal 'subset', t.tag
@@ -76,10 +74,27 @@ class Test_Lexer < Test::Unit::TestCase
      assert lexer.pop(OboParser::Tokens::Term)
   end
 
+  def test_xref_list
+     lexer = OboParser::Lexer.new("[foo:bar, stuff:things]") 
+     assert t = lexer.pop(OboParser::Tokens::XrefList)
+     hsh = {'foo' => 'bar', 'stuff' => 'things'} 
+     assert_equal hsh, t.value
+  end
+
   def test_tagvaluepair
      lexer = OboParser::Lexer.new("id: PATO:0000179")
      assert lexer.pop(OboParser::Tokens::TagValuePair)
   end
+
+  def test_tagvaluepair_with_comments_and_xrefs
+    lexer = OboParser::Lexer.new("def: \"The foo that is bar.\" [PATO:0000179] ! FOO! \n")
+    assert t = lexer.pop(OboParser::Tokens::TagValuePair)
+    assert_equal 'def', t.tag
+    assert_equal 'The foo that is bar.', t.value
+    assert_equal 'FOO!', t.comment
+    assert_equal(['PATO:0000179'], t.xrefs)
+  end
+ 
 end
 
 class Test_Parser < Test::Unit::TestCase
@@ -89,10 +104,13 @@ class Test_Parser < Test::Unit::TestCase
 
   def test_file_parsing
     foo = parse_obo_file(@of)
-    assert_equal 'pato', foo.terms[0].name
-    assert_equal 'quality', foo.terms[1].name
-    assert_equal 'part_of', foo.typedefs.last.name
-    assert_equal 'OBO_REL:part_of', foo.typedefs.last.id
+    assert_equal 'pato', foo.terms[0].name.value
+    assert_equal 'quality', foo.terms[1].name.value
+    assert_equal 'part_of', foo.typedefs.last.name.value
+    assert_equal 'OBO_REL:part_of', foo.typedefs.last.id.value
+    assert_equal(['PATOC:GVG'], foo.terms[1].def.xrefs)
+    assert_equal 'is_obsolete', foo.terms.first.tags_named('is_obsolete').first.tag
+    assert_equal 'true', foo.terms.first.tags_named('is_obsolete').first.value
   end
 
   def teardown
@@ -106,3 +124,9 @@ class Test_Parser < Test::Unit::TestCase
 
 end 
 
+
+
+
+
+
+

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: obo_parser
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  hash: 19
+  prerelease: 
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - mjy
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-28 00:00:00 -05:00
+date: 2011-04-05 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -26,13 +27,11 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README
 - README.rdoc
 files: 
 - .document
 - .gitignore
 - LICENSE
-- README
 - README.rdoc
 - Rakefile
 - VERSION
@@ -60,23 +59,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.5.3
 signing_key: 
 specification_version: 3
 summary: A simple OBO file handler.

data/README

@@ -1,13 +0,0 @@
-NexusParser
-===========
-
-Introduction goes here.
-
-
-Example
-=======
-
-Example goes here.
-
-
-Copyright (c) 2008 Matt Yoder, released under the MIT license