open_nlp 0.0.2-java → 0.0.3-java

data/.rspec

@@ -0,0 +1 @@
+--colour

data/README.md

@@ -6,6 +6,7 @@ A JRuby wrapper for the Apache OpenNLP tools library, that allows you execute co
  * part-of-speech tagging
  * named entity extraction
  * chunks detection
+ * parsing
 
 ## Installation
 
@@ -29,17 +30,20 @@ To use open_nlp classes, you need to require it in your sources
 
 Then you can create instances of open_nlp classes and use it for your nlp tasks
 
-    # sentence detection
+### Sentence detection
+
     sentence_detect_model = OpenNlp::Model::SentenceDetector.new("nlp_models/en-sent.bin")
     sentence_detector = OpenNlp::SentenceDetector.new(sentence_detect_model)
     sentence_detector.detect('The red fox sleeps soundly.')
 
-    # tokenize
+### Tokenize
+
     token_model = OpenNlp::Model::Tokenizer.new("nlp_models/en-token.bin")
     tokenizer = OpenNlp::Tokenizer.new(token_model)
     tokenizer.tokenize('The red fox sleeps soundly.')
 
-    # part-of-speech tagging
+### Part-of-speech tagging
+
     pos_model = OpenNlp::Model::POSTagger.new(File.join("nlp_models/en-pos-maxent.bin"))
     pos_tagger = OpenNlp::POSTagger.new(pos_model)
 
@@ -49,11 +53,31 @@ Then you can create instances of open_nlp classes and use it for your nlp tasks
     # to tag array of tokens call OpenNlp::POSTagger#tag with Array argument
     pos_tagger.tag(%w|The red fox sleeps soundly .|)
 
-    # chunks detection (chunker also needs tokenizer and pos-tagger models because it uses tokenizing and pos-tagging inside chunk task)
+### Chunks detection
+
+    # chunker also needs tokenizer and pos-tagger models
+    # because it uses tokenizing and pos-tagging inside chunk task
     chunk_model = OpenNlp::Model::Chunker.new(File.join("nlp_models/en-chunker.bin"))
     token_model = OpenNlp::Model::Tokenizer.new("nlp_models/en-token.bin")
     pos_model = OpenNlp::Model::POSTagger.new(File.join("nlp_models/en-pos-maxent.bin"))
     chunker = OpenNlp::Chunker.new(chunk_model, token_model, pos_model)
+    chunker.chunk('The red fox sleeps soundly.')
+
+### Parsing
+
+    # parser also needs tokenizer model because it uses tokenizer inside parse task
+    parse_model = OpenNlp::Model::Parser.new(File.join(FIXTURES_DIR, "en-parser-chunking.bin"))
+    token_model = OpenNlp::Model::Tokenizer.new("nlp_models/en-token.bin")
+    parser = OpenNlp::Parser.new(parse_model, token_model)
+
+    # the result will be an instance of OpenNlp::Parser::Parse
+    parse_info = parser.parse('The red fox sleeps soundly.')
+
+    # you can get tree bank string by calling
+    parse_info.tree_bank_string
+
+    # you can get code tree structure of parse result by calling
+    parse_info.code_tree
 
 ## Contributing
 

data/lib/open_nlp/chunker.rb

@@ -36,5 +36,9 @@ module OpenNlp
         acc
       end
     end
+
+    def get_last_probabilities
+      @j_instance.probs.to_ary
+    end
   end
 end

data/lib/open_nlp/java_class.rb

@@ -0,0 +1,17 @@
+module OpenNlp
+  module JavaClass
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def java_class=(value)
+        @java_class = value
+      end
+
+      def java_class
+        @java_class
+      end
+    end
+  end
+end

data/lib/open_nlp/model/chunker.rb

@@ -1,3 +1,3 @@
 class OpenNlp::Model::Chunker < OpenNlp::Model
-  self.java_class_name = Java::opennlp.tools.chunker.ChunkerModel
+  self.java_class = Java::opennlp.tools.chunker.ChunkerModel
 end

data/lib/open_nlp/model/detokenizer.rb

@@ -1,3 +1,3 @@
 class OpenNlp::Model::Detokenizer < OpenNlp::Model
-  self.java_class_name = Java::opennlp.tools.tokenize.DetokenizationDictionary
+  self.java_class = Java::opennlp.tools.tokenize.DetokenizationDictionary
 end

data/lib/open_nlp/model/named_entity_detector.rb

@@ -1,3 +1,3 @@
 class OpenNlp::Model::NamedEntityDetector < OpenNlp::Model
-  self.java_class_name = Java::opennlp.tools.namefind.TokenNameFinderModel
+  self.java_class = Java::opennlp.tools.namefind.TokenNameFinderModel
 end

data/lib/open_nlp/model/parser.rb

@@ -0,0 +1,3 @@
+class OpenNlp::Model::Parser < OpenNlp::Model
+  self.java_class = Java::opennlp.tools.parser.ParserModel
+end

data/lib/open_nlp/model/pos_tagger.rb

@@ -1,3 +1,3 @@
 class OpenNlp::Model::POSTagger < OpenNlp::Model
-  self.java_class_name = Java::opennlp.tools.postag.POSModel
+  self.java_class = Java::opennlp.tools.postag.POSModel
 end

data/lib/open_nlp/model/sentence_detector.rb

@@ -1,3 +1,3 @@
 class OpenNlp::Model::SentenceDetector < OpenNlp::Model
-  self.java_class_name = Java::opennlp.tools.sentdetect.SentenceModel
+  self.java_class = Java::opennlp.tools.sentdetect.SentenceModel
 end

data/lib/open_nlp/model/tokenizer.rb

@@ -1,3 +1,3 @@
 class OpenNlp::Model::Tokenizer < OpenNlp::Model
-  self.java_class_name = Java::opennlp.tools.tokenize.TokenizerModel
+  self.java_class = Java::opennlp.tools.tokenize.TokenizerModel
 end

data/lib/open_nlp/model.rb

@@ -1,5 +1,7 @@
 module OpenNlp
   class Model
+    include JavaClass
+
     attr_reader :j_model
 
     def initialize(model)
@@ -12,17 +14,7 @@ module OpenNlp
                        raise ArgumentError, "Model must be either a string or a java.io.FileInputStream"
                      end
 
-      @j_model = self.class.java_class_name.new(model_stream)
-    end
-
-    class << self
-      def java_class_name=(value)
-        @java_class = value
-      end
-
-      def java_class_name
-        @java_class
-      end
+      @j_model = self.class.java_class.new(model_stream)
     end
   end
 end

data/lib/open_nlp/parser/parse.rb

@@ -0,0 +1,54 @@
+module OpenNlp
+  class Parser::Parse
+    include JavaClass
+
+    attr_reader :j_instance
+
+    self.java_class = Java::opennlp.tools.parser.Parse
+
+    def initialize(java_instance)
+      raise ArgumentError, "java_instance must be an instance of #{self.class.java_class.name}" unless java_instance.is_a?(self.class.java_class)
+
+      @j_instance = java_instance
+    end
+
+    def tree_bank_string
+      span = j_instance.getSpan
+      text = j_instance.getText
+      type = j_instance.getType
+      start = span.getStart
+
+      res = ''
+
+      res << "(#{type} " unless type == Java::opennlp.tools.parser.AbstractBottomUpParser::TOK_NODE
+
+      j_instance.getChildren.each do |c|
+        s = c.span
+        res << text[start..s.getStart-1] if start < s.getStart
+
+        subtree = self.class.new(c).tree_bank_string
+        res << subtree if subtree
+        start = s.getEnd
+      end
+
+      res << text[start..span.getEnd-1] if start < span.getEnd
+
+      res << ")" unless type == Java::opennlp.tools.parser.AbstractBottomUpParser::TOK_NODE
+
+      res
+    end
+
+    def code_tree
+      kids = j_instance.getChildren
+
+      kids.inject([]) do |acc,kid|
+        data = {type: kid.getType, parent_type: self.j_instance.getType, token: kid.toString}
+        subtree = self.class.new(kid).code_tree
+        data[:children] = subtree unless subtree.empty?
+        acc << data
+
+        acc
+      end
+    end
+  end
+end

data/lib/open_nlp/parser.rb

@@ -0,0 +1,101 @@
+module OpenNlp
+  class Parser < Tool
+    def initialize(model, token_model)
+      raise ArgumentError, "model must be an OpenNlp::Model" unless model.is_a?(OpenNlp::Model)
+      raise ArgumentError, "model must be an OpenNlp::Tokenizer::Model" unless token_model.is_a?(Model::Tokenizer)
+
+      @j_instance = Java::opennlp.tools.parser.ParserFactory.create(model.j_model)
+
+      @tokenizer = Tokenizer.new(token_model)
+    end
+
+    def parse(text)
+      raise ArgumentError, "str must be a String" unless text.is_a?(String)
+      return {} if text.empty?
+
+      parse_obj = Java::opennlp.tools.parser.Parse.new(
+        text.to_java(:String),
+        Java::opennlp.tools.util.Span.new(0, text.size),
+        Java::opennlp.tools.parser.AbstractBottomUpParser::INC_NODE.to_java(:String),
+        1.to_java(:Double), # probability ?
+        0.to_java(:Integer) # the token index of the head of this parse
+      )
+
+      tokens = @tokenizer.tokenize(text)
+
+      tokens.each_with_index do |tok, i|
+        start = get_token_offset text, tokens, i
+
+        parse_obj.insert Java::opennlp.tools.parser.Parse.new(
+                           text.to_java(:String),
+                           Java::opennlp.tools.util.Span.new(start, start + tok.size),
+                           Java::opennlp.tools.parser.AbstractBottomUpParser::TOK_NODE.to_java(:String),
+                           0.to_java(:Double),
+                           i.to_java(:Integer)
+                         )
+      end
+
+      #code_tree @j_instance.parse(parse_obj)
+      Parser::Parse.new(@j_instance.parse(parse_obj))
+    end
+
+    private
+    def get_token_offset(text, tokens, index)
+      offset = 0
+
+      for i in (1..index) do
+        offset = text.index tokens[i], offset + tokens[i - 1].size
+      end if index > 0
+
+      offset
+    end
+
+    #def build_tree(parse_obj)
+    #  span = parse_obj.getSpan
+    #  start = span.getStart
+    #  text = parse_obj.getText
+    #  type = parse_obj.getType
+    #
+    #  res = {}
+    #  res[:type] = type unless type == Java::opennlp.tools.parser.AbstractBottomUpParser::TOK_NODE
+    #
+    #  children = parse_obj.getChildren.inject([]) do |acc,c|
+    #    s = c.span
+    #
+    #    h = {}
+    #
+    #    if start < s.getStart
+    #      token = text[start..s.getStart-1]
+    #      h[:token] = token unless token.strip.empty?
+    #    end
+    #
+    #    subtree = build_tree(c)
+    #    h[:children] = subtree unless subtree.empty?
+    #
+    #    start = s.getEnd
+    #
+    #    acc << h
+    #    acc
+    #  end
+    #
+    #  res[:token] = text[start..span.getEnd-1] if start < span.getEnd
+    #
+    #  res[:children] = children unless children.empty?
+    #
+    #  res
+    #end
+
+    def code_tree(parse_obj)
+      kids = parse_obj.getChildren
+
+      kids.inject([]) do |acc,kid|
+        data = {type: kid.getType, parent_type: parse_obj.getType, token: kid.toString}
+        subtree = code_tree(kid)
+        data[:children] = subtree unless subtree.empty?
+        acc << data
+
+        acc
+      end
+    end
+  end
+end

data/lib/open_nlp/tokenizer.rb

@@ -6,5 +6,10 @@ module OpenNlp
       raise ArgumentError, "str must be a String" unless str.is_a?(String)
       @j_instance.tokenize(str).to_ary
     end
+
+    private
+    def get_last_probabilities
+      @j_instance.getTokenProbabilities.to_ary
+    end
   end
 end

data/lib/open_nlp/tool.rb

@@ -1,20 +1,12 @@
 module OpenNlp
   class Tool
+    include JavaClass
+
     attr_reader :j_instance
 
     def initialize(model)
       raise ArgumentError, "model must be an OpenNlp::Model" unless model.is_a?(OpenNlp::Model)
       @j_instance = self.class.java_class.new(model.j_model)
     end
-
-    class << self
-      def java_class=(value)
-        @java_class = value
-      end
-
-      def java_class
-        @java_class
-      end
-    end
   end
 end

data/lib/open_nlp/utils/span.rb

@@ -0,0 +1,15 @@
+module OpenNlp
+  module Utils
+    class Span
+      include JavaClass
+
+      self.java_class = Java::opennlp.tools.util.Span
+
+      attr_reader :j_instance
+
+      def initialize(start_offset, end_offset)
+        @j_instance = self.class.java_class.new(start_offset, end_offset)
+      end
+    end
+  end
+end

data/lib/open_nlp/version.rb

@@ -1,3 +1,3 @@
 module OpenNlp
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/open_nlp.rb

@@ -4,17 +4,23 @@ require 'java'
 require 'open_nlp/opennlp-tools-1.5.2-incubating.jar'
 require 'open_nlp/opennlp-maxent-3.0.2-incubating.jar'
 
+require 'open_nlp/java_class'
+
 require 'open_nlp/model'
+
 require 'open_nlp/model/chunker'
 require 'open_nlp/model/detokenizer'
 require 'open_nlp/model/named_entity_detector'
 require 'open_nlp/model/pos_tagger'
 require 'open_nlp/model/sentence_detector'
 require 'open_nlp/model/tokenizer'
+require 'open_nlp/model/parser'
 
 require 'open_nlp/tool'
 require 'open_nlp/named_entity_detector'
 require 'open_nlp/pos_tagger'
 require 'open_nlp/sentence_detector'
 require 'open_nlp/tokenizer'
-require 'open_nlp/chunker'
+require 'open_nlp/chunker'
+require 'open_nlp/parser'
+require 'open_nlp/parser/parse'

data/open_nlp.gemspec

@@ -9,6 +9,7 @@ Gem::Specification.new do |gem|
   gem.authors       = ["Hck"]
   gem.description   = %q{JRuby tools wrapper for Apache OpenNLP}
   gem.summary       = %q{A JRuby wrapper for the Apache OpenNLP tools library}
+  gem.homepage      = "http://github.com/hck/open_nlp"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/spec/chunker_spec.rb

@@ -16,6 +16,14 @@ describe OpenNlp::Chunker do
     it "should raise an argument error when no model is supplied" do
       lambda { subject.new(nil, nil, nil) }.should raise_error(ArgumentError)
     end
+
+    it "should raise an argument error when no token_model is supplied" do
+      lambda { subject.new(model, nil, nil) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an argument error when no pos_model is supplied" do
+      lambda { subject.new(model, token_model, nil) }.should raise_error(ArgumentError)
+    end
   end
 
   describe "chunking a string" do

data/spec/model/chunker_spec.rb

@@ -7,14 +7,14 @@ describe OpenNlp::Model::Chunker do
   it "should accept a string filename parameter" do
     chunker_model = subject.new(model_file_name)
     chunker_model.should be_a(subject)
-    chunker_model.j_model.should be_a(subject.java_class_name)
+    chunker_model.j_model.should be_a(subject.java_class)
   end
 
   it "should accept a java.io.FileInputStream object" do
     file_input_stream = java.io.FileInputStream.new(model_file_name)
     chunker_model = subject.new(file_input_stream)
     chunker_model.should be_a(subject)
-    chunker_model.j_model.should be_a(subject.java_class_name)
+    chunker_model.j_model.should be_a(subject.java_class)
   end
 
   it "should raise an argument error otherwise" do

data/spec/model/detokenizer_spec.rb

@@ -7,14 +7,14 @@ describe OpenNlp::Model::Detokenizer do
   it "should accept a string filename parameter" do
     model = subject.new(model_file_name)
     model.should be_a(subject)
-    model.j_model.should be_a(subject.java_class_name)
+    model.j_model.should be_a(subject.java_class)
   end
 
   it "should accept a java.io.FileInputStream object" do
     file_input_stream = java.io.FileInputStream.new(model_file_name)
     model = subject.new(file_input_stream)
     model.should be_a(subject)
-    model.j_model.should be_a(subject.java_class_name)
+    model.j_model.should be_a(subject.java_class)
   end
 
   it "should raise an argument error otherwise" do

data/spec/model/named_entity_detector_spec.rb

@@ -7,14 +7,14 @@ describe OpenNlp::Model::NamedEntityDetector do
   it "should accept a string filename parameter" do
     model = subject.new(model_file_name)
     model.should be_a(subject)
-    model.j_model.should be_a(subject.java_class_name)
+    model.j_model.should be_a(subject.java_class)
   end
 
   it "should accept a java.io.FileInputStream object" do
     file_input_stream = java.io.FileInputStream.new(model_file_name)
     model = subject.new(file_input_stream)
     model.should be_a(subject)
-    model.j_model.should be_a(subject.java_class_name)
+    model.j_model.should be_a(subject.java_class)
   end
 
   it "should raise an argument error otherwise" do

data/spec/model/pos_tagger_spec.rb

@@ -7,14 +7,14 @@ describe OpenNlp::Model::POSTagger do
   it "should accept a string filename parameter" do
     model = subject.new(model_file_name)
     model.should be_a(subject)
-    model.j_model.should be_a(subject.java_class_name)
+    model.j_model.should be_a(subject.java_class)
   end
 
   it "should accept a java.io.FileInputStream object" do
     file_input_stream = java.io.FileInputStream.new(model_file_name)
     model = subject.new(file_input_stream)
     model.should be_a(subject)
-    model.j_model.should be_a(subject.java_class_name)
+    model.j_model.should be_a(subject.java_class)
   end
 
   it "should raise an argument error otherwise" do

data/spec/model/sentence_detector_spec.rb

@@ -7,14 +7,14 @@ describe OpenNlp::Model::SentenceDetector do
   it "should accept a string filename parameter" do
     model = subject.new(model_file_name)
     model.should be_a(subject)
-    model.j_model.should be_a(subject.java_class_name)
+    model.j_model.should be_a(subject.java_class)
   end
 
   it "should accept a java.io.FileInputStream object" do
     file_input_stream = java.io.FileInputStream.new(model_file_name)
     model = subject.new(file_input_stream)
     model.should be_a(subject)
-    model.j_model.should be_a(subject.java_class_name)
+    model.j_model.should be_a(subject.java_class)
   end
 
   it "should raise an argument error otherwise" do

data/spec/model/tokenizer_spec.rb

@@ -7,14 +7,14 @@ describe OpenNlp::Model::Tokenizer do
   it "should accept a string filename parameter" do
     model = subject.new(model_file_name)
     model.should be_a(subject)
-    model.j_model.should be_a(subject.java_class_name)
+    model.j_model.should be_a(subject.java_class)
   end
 
   it "should accept a java.io.FileInputStream object" do
     file_input_stream = java.io.FileInputStream.new(model_file_name)
     model = subject.new(file_input_stream)
     model.should be_a(subject)
-    model.j_model.should be_a(subject.java_class_name)
+    model.j_model.should be_a(subject.java_class)
   end
 
   it "should raise an argument error otherwise" do

data/spec/parser/parse_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+describe OpenNlp::Parser::Parse do
+  subject { OpenNlp::Parser::Parse }
+  let(:text) { 'The red fox sleeps soundly .' }
+  let(:model) { OpenNlp::Model::Parser.new(File.join(FIXTURES_DIR, "en-parser-chunking.bin")) }
+  let(:token_model) { OpenNlp::Model::Tokenizer.new(File.join(FIXTURES_DIR, "en-token.bin")) }
+
+  describe "initialization" do
+    it "should initialize a new parse object" do
+      j_parse = Java::opennlp.tools.parser.Parse.new(
+        text.to_java(:String),
+        Java::opennlp.tools.util.Span.new(0, text.size),
+        Java::opennlp.tools.parser.AbstractBottomUpParser::INC_NODE.to_java(:String),
+        1.to_java(:Double),
+        0.to_java(:Integer)
+      )
+
+      subject.new(j_parse).should be_a(subject)
+    end
+
+    it "should raise an argument error when no model is supplied" do
+      lambda { subject.new(nil) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#tree_bank_string" do
+    it "returns proper string value for parsed text" do
+      parser = OpenNlp::Parser.new(model, token_model)
+      expected = parser.parse(text).tree_bank_string
+      expected.should == "(TOP (S (NP (DT The) (JJ red) (NN fox)) (VP (VBZ sleeps) (ADVP (RB soundly))) (. .)))"
+    end
+  end
+
+  describe "#code_tree" do
+    it "returns proper structure for parsed text" do
+      parser = OpenNlp::Parser.new(model, token_model)
+      parser.parse(text).code_tree.should == [
+        {
+          :type => "S",
+          :parent_type => "TOP",
+          :token => "The red fox sleeps soundly .",
+          :children => [
+            {
+              :type => "NP",
+              :parent_type => "S",
+              :token => "The red fox",
+              :children => [
+                {
+                  :type => "DT",
+                  :parent_type => "NP",
+                  :token => "The",
+                  :children => [{:type => "TK", :parent_type => "DT", :token => "The"}]
+                },
+                {
+                  :type => "JJ",
+                  :parent_type => "NP",
+                  :token => "red",
+                  :children => [{:type => "TK", :parent_type => "JJ", :token => "red"}]
+                },
+                {
+                  :type => "NN",
+                  :parent_type => "NP",
+                  :token => "fox",
+                  :children => [{:type => "TK", :parent_type => "NN", :token => "fox"}]
+                }
+              ]
+            },
+            {
+              :type => "VP",
+              :parent_type => "S",
+              :token => "sleeps soundly",
+              :children => [
+                {
+                  :type => "VBZ",
+                  :parent_type => "VP",
+                  :token => "sleeps",
+                  :children => [{:type => "TK", :parent_type => "VBZ", :token => "sleeps"}]
+                },
+                {
+                  :type => "ADVP",
+                  :parent_type => "VP",
+                  :token => "soundly",
+                  :children => [
+                    {
+                      :type => "RB",
+                      :parent_type => "ADVP",
+                      :token => "soundly",
+                      :children => [{:type => "TK", :parent_type => "RB", :token => "soundly"}]
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              :type => ".",
+              :parent_type => "S",
+              :token => ".",
+              :children => [{:type => "TK", :parent_type => ".", :token => "."}]
+            }
+          ]
+        }
+      ]
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe OpenNlp::Parser do
+  subject { OpenNlp::Parser }
+  let(:model) { OpenNlp::Model::Parser.new(File.join(FIXTURES_DIR, "en-parser-chunking.bin")) }
+  let(:token_model) { OpenNlp::Model::Tokenizer.new(File.join(FIXTURES_DIR, "en-token.bin")) }
+
+  describe "initialization" do
+    it "should initialize a new parser" do
+      parser = subject.new(model, token_model)
+      parser.should be_a(subject)
+    end
+
+    it "should raise an argument error when no model is supplied" do
+      lambda { subject.new(nil, nil) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an argument error when no token_model is supplied" do
+      lambda { subject.new(model, nil) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "parsing a string" do
+    let(:parser) { subject.new(model, token_model) }
+
+    it "should parse an empty string" do
+      parser.parse("").should == {}
+    end
+
+    it "should parse a sentence" do
+      res = parser.parse("The red fox sleeps soundly .")
+      res.class.should == OpenNlp::Parser::Parse
+    end
+
+    it "should raise an error when not passed a string" do
+      lambda { parser.parse(nil) }.should raise_error(ArgumentError)
+    end
+  end
+end

metadata

@@ -2,14 +2,14 @@
 name: open_nlp
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.0.2
+  version: 0.0.3
 platform: java
 authors:
 - Hck
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-09-24 00:00:00.000000000 Z
+date: 2012-09-26 00:00:00.000000000 Z
 dependencies: []
 description: JRuby tools wrapper for Apache OpenNLP
 email:
@@ -18,32 +18,39 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/open_nlp.rb
 - lib/open_nlp/chunker.rb
+- lib/open_nlp/java_class.rb
 - lib/open_nlp/model.rb
 - lib/open_nlp/model/chunker.rb
 - lib/open_nlp/model/detokenizer.rb
 - lib/open_nlp/model/named_entity_detector.rb
+- lib/open_nlp/model/parser.rb
 - lib/open_nlp/model/pos_tagger.rb
 - lib/open_nlp/model/sentence_detector.rb
 - lib/open_nlp/model/tokenizer.rb
 - lib/open_nlp/named_entity_detector.rb
 - lib/open_nlp/opennlp-maxent-3.0.2-incubating.jar
 - lib/open_nlp/opennlp-tools-1.5.2-incubating.jar
+- lib/open_nlp/parser.rb
+- lib/open_nlp/parser/parse.rb
 - lib/open_nlp/pos_tagger.rb
 - lib/open_nlp/sentence_detector.rb
 - lib/open_nlp/tokenizer.rb
 - lib/open_nlp/tool.rb
+- lib/open_nlp/utils/span.rb
 - lib/open_nlp/version.rb
 - open_nlp.gemspec
 - spec/chunker_spec.rb
 - spec/fixtures/en-chunker.bin
 - spec/fixtures/en-detokenizer.xml
 - spec/fixtures/en-ner-time.bin
+- spec/fixtures/en-parser-chunking.bin
 - spec/fixtures/en-pos-maxent.bin
 - spec/fixtures/en-sent.bin
 - spec/fixtures/en-token.bin
@@ -54,11 +61,13 @@ files:
 - spec/model/sentence_detector_spec.rb
 - spec/model/tokenizer_spec.rb
 - spec/named_entity_detector_spec.rb
+- spec/parser/parse_spec.rb
+- spec/parser_spec.rb
 - spec/pos_tagger_spec.rb
 - spec/sentence_detector_spec.rb
 - spec/spec_helper.rb
 - spec/tokenizer_spec.rb
-homepage:
+homepage: http://github.com/hck/open_nlp
 licenses: []
 post_install_message:
 rdoc_options: []
@@ -89,6 +98,7 @@ test_files:
 - spec/fixtures/en-chunker.bin
 - spec/fixtures/en-detokenizer.xml
 - spec/fixtures/en-ner-time.bin
+- spec/fixtures/en-parser-chunking.bin
 - spec/fixtures/en-pos-maxent.bin
 - spec/fixtures/en-sent.bin
 - spec/fixtures/en-token.bin
@@ -99,6 +109,8 @@ test_files:
 - spec/model/sentence_detector_spec.rb
 - spec/model/tokenizer_spec.rb
 - spec/named_entity_detector_spec.rb
+- spec/parser/parse_spec.rb
+- spec/parser_spec.rb
 - spec/pos_tagger_spec.rb
 - spec/sentence_detector_spec.rb
 - spec/spec_helper.rb