obo_parser 0.1.0 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/lexer.rb

@@ -1,4 +1,4 @@
-class OboFile::Lexer
+class OboParser::Lexer
   attr_reader :input
   def initialize(input)
     @input = input
@@ -17,7 +17,7 @@ class OboFile::Lexer
     token = read_next_token(token_class)
     @next_token = nil
     if token.class != token_class
-      raise(OboFile::ParseError,"expected #{token_class.to_s} but received #{token.class.to_s} at #{@input[0..10]}...", caller)
+      raise(OboParser::ParseError,"expected #{token_class.to_s} but received #{token.class.to_s} at #{@input[0..10]}...", caller)
     else
       return token
     end
@@ -34,13 +34,13 @@ class OboFile::Lexer
         return @next_token
       else
         # now check all the tokens for a match
-        OboFile::Tokens.obo_file_token_list.each {|t|
+        OboParser::Tokens.obo_file_token_list.each {|t|
           return @next_token if match(t)
         }
       end
        # no match, either end of string or lex-error
        if @input != ''
-           raise(OboFile::ParseError, "Lex Error, unknown token at #{@input[0..10]}...", caller)
+           raise(OboParser::ParseError, "Lex Error, unknown token at #{@input[0..10]}...", caller)
        else
         return nil
       end

data/lib/{obo_file.rb → obo_parser.rb}

@@ -4,14 +4,14 @@
 
 # outstanding issues:
 
-module OboFile
+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'))
 
 
-class OboFile # Node
+class OboParser # Node
   attr_accessor :terms, :typedefs
 
   def initialize
@@ -65,17 +65,17 @@ class OboFile # Node
 end
 
 
-class OboFileBuilder
+class OboParserBuilder
   def initialize
-    @of =  OboFile.new 
+    @of =  OboParser.new 
   end
 
   def add_term(tags)
-    @of.terms.push OboFile::Term.new(tags)
+    @of.terms.push OboParser::Term.new(tags)
   end
 
   def add_typedef(tags)
-    @of.typedefs.push OboFile::Typedef.new(tags)
+    @of.typedefs.push OboParser::Typedef.new(tags)
   end
 
   def obo_file
@@ -92,13 +92,13 @@ end # end module
 # the actual method
 def parse_obo_file(input)
   @input = input
-   raise(OboFile::ParseError, "Nothing passed to parse!") if  !@input ||  @input.size == 0
+   raise(OboParser::ParseError, "Nothing passed to parse!") if  !@input ||  @input.size == 0
 
   @input.gsub!(/(\s*?![^!'"]*?\n)/i, "\n")  # strip out comments - this is a kludge, likely needs fixing!!
     
-  builder = OboFile::OboFileBuilder.new
-  lexer = OboFile::Lexer.new(@input)
-  OboFile::Parser.new(lexer, builder).parse_file
+  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

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

data/lib/tokens.rb

@@ -1,4 +1,4 @@
-module OboFile::Tokens
+module OboParser::Tokens
 
   class Token 
     # this allows access the the class attribute regexp, without using a class variable
@@ -147,13 +147,13 @@ module OboFile::Tokens
   # this list also defines priority, i.e. if tokens have overlap (which they shouldn't!!) then the earlier indexed token will match first
   def self.obo_file_token_list
     [ 
-      OboFile::Tokens::Term,
-      OboFile::Tokens::Typedef,
-      OboFile::Tokens::TagValuePair,
-      OboFile::Tokens::NameValuePair,  # not implemented
-      OboFile::Tokens::Dbxref,         # not implemented
-      OboFile::Tokens::LBracket,
-      OboFile::Tokens::EndOfFile
+      OboParser::Tokens::Term,
+      OboParser::Tokens::Typedef,
+      OboParser::Tokens::TagValuePair,
+      OboParser::Tokens::NameValuePair,  # not implemented
+      OboParser::Tokens::Dbxref,         # not implemented
+      OboParser::Tokens::LBracket,
+      OboParser::Tokens::EndOfFile
     ]   
   end
   

data/obo_parser.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{obo_parser}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["mjy"]
@@ -28,7 +28,7 @@ Gem::Specification.new do |s|
      "init.rb",
      "install.rb",
      "lib/lexer.rb",
-     "lib/obo_file.rb",
+     "lib/obo_parser.rb",
      "lib/parser.rb",
      "lib/tokens.rb",
      "obo_parser.gemspec",

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_file'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/obo_parser'))
 
 class OboParserTest < Test::Unit::TestCase
   def test_truth
@@ -10,9 +10,9 @@ class OboParserTest < Test::Unit::TestCase
   end
 end
 
-class Test_OboFileBuilder < Test::Unit::TestCase
+class Test_OboParserBuilder < Test::Unit::TestCase
   def test_builder
-    b = OboFile::OboFileBuilder.new
+    b = OboParser::OboParserBuilder.new
   end
 end
 
@@ -30,16 +30,16 @@ end
 class Test_Lexer < Test::Unit::TestCase
   
   def test_term
-     lexer = OboFile::Lexer.new("[Term]")
-     assert lexer.pop(OboFile::Tokens::Term)
+     lexer = OboParser::Lexer.new("[Term]")
+     assert lexer.pop(OboParser::Tokens::Term)
   end
   
   def test_end_of_file
-     lexer = OboFile::Lexer.new("    \n\n")
-     assert lexer.pop(OboFile::Tokens::EndOfFile)
+     lexer = OboParser::Lexer.new("    \n\n")
+     assert lexer.pop(OboParser::Tokens::EndOfFile)
   
-     lexer = OboFile::Lexer.new("\n")
-     assert lexer.pop(OboFile::Tokens::EndOfFile)
+     lexer = OboParser::Lexer.new("\n")
+     assert lexer.pop(OboParser::Tokens::EndOfFile)
   end
 
   def test_parse_term_stanza
@@ -49,37 +49,37 @@ class Test_Lexer < Test::Unit::TestCase
       def: "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]
       subset: attribute_slim
       is_a: PATO:0001301'
-    lexer = OboFile::Lexer.new(input)
-    assert t = lexer.pop(OboFile::Tokens::TagValuePair)
+    lexer = OboParser::Lexer.new(input)
+    assert t = lexer.pop(OboParser::Tokens::TagValuePair)
     assert_equal 'id', t.tag
     assert_equal 'PATO:0000015', t.value
 
-    assert t = lexer.pop(OboFile::Tokens::TagValuePair)
+    assert t = lexer.pop(OboParser::Tokens::TagValuePair)
     assert_equal 'name', t.tag
     assert_equal 'color hue', t.value
 
-    assert t = lexer.pop(OboFile::Tokens::TagValuePair)
+    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 t = lexer.pop(OboFile::Tokens::TagValuePair)
+    assert t = lexer.pop(OboParser::Tokens::TagValuePair)
     assert_equal 'subset', t.tag
     assert_equal 'attribute_slim', t.value
 
-    assert t = lexer.pop(OboFile::Tokens::TagValuePair)
+    assert t = lexer.pop(OboParser::Tokens::TagValuePair)
     assert_equal 'is_a', t.tag
     assert_equal 'PATO:0001301', t.value
   end
 
 
   def test_parse_term
-     lexer = OboFile::Lexer.new("[Term]")
-     assert lexer.pop(OboFile::Tokens::Term)
+     lexer = OboParser::Lexer.new("[Term]")
+     assert lexer.pop(OboParser::Tokens::Term)
   end
 
   def test_tagvaluepair
-     lexer = OboFile::Lexer.new("id: PATO:0000179")
-     assert lexer.pop(OboFile::Tokens::TagValuePair)
+     lexer = OboParser::Lexer.new("id: PATO:0000179")
+     assert lexer.pop(OboParser::Tokens::TagValuePair)
   end
 end
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - mjy
@@ -39,7 +39,7 @@ files:
 - init.rb
 - install.rb
 - lib/lexer.rb
-- lib/obo_file.rb
+- lib/obo_parser.rb
 - lib/parser.rb
 - lib/tokens.rb
 - obo_parser.gemspec