open_nlp 0.0.1-java

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Alexander Svirin
+
+MIT License
+
+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/README.md

@@ -0,0 +1,29 @@
+# OpenNlp
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'open_nlp'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install open_nlp
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/open_nlp/chunker.rb

@@ -0,0 +1,42 @@
+module OpenNlp
+  class Chunker < Tool
+    self.java_class = Java::opennlp.tools.chunker.ChunkerME
+
+    def initialize(model, token_model, pos_model)
+      #raise ArgumentError, "model must be an OpenNlp::Chunker::Model" unless model.is_a?(Chunker::Model)
+      super(model)
+
+      raise ArgumentError, "model must be an OpenNlp::Tokenizer::Model" unless token_model.is_a?(Model::Tokenizer)
+      raise ArgumentError, "model must be an OpenNlp::POSTagger::Model" unless pos_model.is_a?(Model::POSTagger)
+
+      @tokenizer = Tokenizer.new(token_model)
+      @pos_tagger = POSTagger.new(pos_model)
+      #@j_instance = self.java_class.new(model.j_model)
+    end
+
+    def chunk(str)
+      raise ArgumentError, "str must be a String" unless str.is_a?(String)
+
+      tokens = @tokenizer.tokenize(str)
+      pos_tags = @pos_tagger.tag(tokens).to_ary
+
+      chunks = @j_instance.chunk(tokens.to_java(:String), pos_tags.to_java(:String)).to_ary
+
+      build_chunks(chunks, tokens, pos_tags)
+    end
+
+    private
+    def build_chunks(chunks, tokens, pos_tags)
+      # data[i] = [token, pos_tag, chunk_val]
+      data = tokens.zip(pos_tags, chunks)
+
+      data.inject([]) do |acc, val|
+        chunk = val[2]
+        acc << [val[0]] if chunk[0] == 'B'
+        acc.last << val[0] if chunk[0] == 'I'
+
+        acc
+      end
+    end
+  end
+end

data/lib/open_nlp/model/chunker.rb

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

data/lib/open_nlp/model/detokenizer.rb

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

data/lib/open_nlp/model/named_entity_detector.rb

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

data/lib/open_nlp/model/pos_tagger.rb

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

data/lib/open_nlp/model/sentence_detector.rb

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

data/lib/open_nlp/model/tokenizer.rb

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

data/lib/open_nlp/model.rb

@@ -0,0 +1,28 @@
+module OpenNlp
+  class Model
+    attr_reader :j_model
+
+    def initialize(model)
+      model_stream = case model
+                     when java.io.FileInputStream
+                       model
+                     when String
+                       java.io.FileInputStream.new(model)
+                     else
+                       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
+    end
+  end
+end

data/lib/open_nlp/named_entity_detector.rb

@@ -0,0 +1,10 @@
+module OpenNlp
+  class NamedEntityDetector < Tool
+    self.java_class = Java::opennlp.tools.namefind.NameFinderME
+
+    def detect(tokens)
+      raise ArgumentError, "tokens must be an instance of Array" unless tokens.is_a?(Array)
+      @j_instance.find(tokens.to_java(:String)).to_ary
+    end
+  end
+end

data/lib/open_nlp/pos_tagger.rb

@@ -0,0 +1,10 @@
+module OpenNlp
+  class POSTagger < Tool
+    self.java_class = Java::opennlp.tools.postag.POSTaggerME
+
+    def tag(tokens)
+      raise ArgumentError, "tokens must be an instance of String or Array" unless (tokens.is_a?(Array) || tokens.is_a?(String))
+      @j_instance.tag(tokens.to_java(:String))
+    end
+  end
+end

data/lib/open_nlp/sentence_detector.rb

@@ -0,0 +1,10 @@
+module OpenNlp
+  class SentenceDetector < Tool
+    self.java_class = Java::opennlp.tools.sentdetect.SentenceDetectorME
+
+    def detect(string)
+      raise ArgumentError, "string must be a String" unless string.is_a?(String)
+      @j_instance.sentDetect(string).to_ary
+    end
+  end
+end

data/lib/open_nlp/tokenizer.rb

@@ -0,0 +1,10 @@
+module OpenNlp
+  class Tokenizer < Tool
+    self.java_class = Java::opennlp.tools.tokenize.TokenizerME
+
+    def tokenize(str)
+      raise ArgumentError, "str must be a String" unless str.is_a?(String)
+      @j_instance.tokenize(str).to_ary
+    end
+  end
+end

data/lib/open_nlp/tool.rb

@@ -0,0 +1,20 @@
+module OpenNlp
+  class Tool
+    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/version.rb

@@ -0,0 +1,3 @@
+module OpenNlp
+  VERSION = '0.0.1'
+end

data/lib/open_nlp.rb

@@ -0,0 +1,20 @@
+require 'open_nlp/version'
+
+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/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/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'

data/open_nlp.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'open_nlp/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "open_nlp"
+  gem.version       = OpenNlp::VERSION
+  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.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.platform = "java"
+end

data/spec/chunker_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe OpenNlp::Chunker do
+  subject { OpenNlp::Chunker }
+
+  let(:model) { OpenNlp::Model::Chunker.new(File.join(FIXTURES_DIR, "en-chunker.bin")) }
+  let(:token_model) { OpenNlp::Model::Tokenizer.new(File.join(FIXTURES_DIR, "en-token.bin")) }
+  let(:pos_model) { OpenNlp::Model::POSTagger.new(File.join(FIXTURES_DIR, "en-pos-maxent.bin")) }
+
+  describe "initialization" do
+    it "should initialize a new chunker" do
+      chunker = subject.new(model, token_model, pos_model)
+      chunker.should be_a(subject)
+    end
+
+    it "should raise an argument error when no model is supplied" do
+      lambda { subject.new(nil, nil, nil) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "chunking a string" do
+    let(:chunker) { subject.new(model, token_model, pos_model) }
+
+    it "should chunk an empty string" do
+      chunks = chunker.chunk("")
+      chunks.should == []
+    end
+
+    it "should chunk a sentence" do
+      chunks = chunker.chunk("The red fox sleeps soundly.")
+      chunks.should == [["The", "red", "fox", "sleeps"], ["soundly"]]
+    end
+
+    it "should raise an error when not passed a string" do
+      lambda { chunker.chunk(nil) }.should raise_error(ArgumentError)
+    end
+  end
+end

data/spec/fixtures/en-detokenizer.xml

@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.    
+-->
+
+<dictionary>
+  <entry operation="RIGHT_LEFT_MATCHING">
+    <token>"</token>
+  </entry>
+  <entry operation="RIGHT_LEFT_MATCHING">
+    <token>'</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>.</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>?</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>!</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>,</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>;</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>:</token>
+  </entry>
+  <entry operation="MOVE_RIGHT">
+    <token>(</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>)</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>}</token>
+  </entry>
+  <entry operation="MOVE_RIGHT">
+    <token>{</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>]</token>
+  </entry>
+  <entry operation="MOVE_RIGHT">
+    <token>[</token>
+  </entry>
+  <entry operation="MOVE_RIGHT">
+    <token>``</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>''</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>%</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>n't</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>'ve</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>'d</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>'ll</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>'s</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>'re</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>'m</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>.org</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>.com</token>
+  </entry>
+  <entry operation="MOVE_LEFT">
+    <token>.net</token>
+  </entry>
+  <entry operation="MOVE_RIGHT">
+    <token>#</token>
+  </entry>
+</dictionary>

data/spec/model/chunker_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe OpenNlp::Model::Chunker do
+  subject { OpenNlp::Model::Chunker }
+  let(:model_file_name) { File.join(FIXTURES_DIR, "en-chunker.bin") }
+
+  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)
+  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)
+  end
+
+  it "should raise an argument error otherwise" do
+    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  end
+end

data/spec/model/detokenizer_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe OpenNlp::Model::Detokenizer do
+  subject { OpenNlp::Model::Detokenizer }
+  let(:model_file_name) { File.join(FIXTURES_DIR, "en-detokenizer.xml") }
+
+  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)
+  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)
+  end
+
+  it "should raise an argument error otherwise" do
+    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  end
+end

data/spec/model/named_entity_detector_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe OpenNlp::Model::NamedEntityDetector do
+  subject { OpenNlp::Model::NamedEntityDetector }
+  let(:model_file_name) { File.join(FIXTURES_DIR, "en-ner-time.bin") }
+
+  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)
+  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)
+  end
+
+  it "should raise an argument error otherwise" do
+    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  end
+end

data/spec/model/pos_tagger_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe OpenNlp::Model::POSTagger do
+  subject { OpenNlp::Model::POSTagger }
+  let(:model_file_name) { File.join(FIXTURES_DIR, "en-pos-maxent.bin") }
+
+  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)
+  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)
+  end
+
+  it "should raise an argument error otherwise" do
+    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  end
+end

data/spec/model/sentence_detector_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe OpenNlp::Model::SentenceDetector do
+  subject { OpenNlp::Model::SentenceDetector }
+  let(:model_file_name) { File.join(FIXTURES_DIR, "en-sent.bin") }
+
+  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)
+  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)
+  end
+
+  it "should raise an argument error otherwise" do
+    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  end
+end

data/spec/model/tokenizer_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe OpenNlp::Model::Tokenizer do
+  subject { OpenNlp::Model::Tokenizer }
+  let(:model_file_name) { File.join(FIXTURES_DIR, "en-token.bin") }
+
+  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)
+  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)
+  end
+
+  it "should raise an argument error otherwise" do
+    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  end
+end

data/spec/named_entity_detector_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe OpenNlp::NamedEntityDetector do
+  subject { OpenNlp::NamedEntityDetector }
+
+  let(:model) { OpenNlp::Model::NamedEntityDetector.new(File.join(FIXTURES_DIR, "en-ner-time.bin")) }
+  
+  describe "initialization" do
+    it "should initialize with a valid model" do
+      ne_detector = subject.new(model)
+      ne_detector.should be_a(subject)
+    end
+
+    it "should raise an ArgumentError otherwise" do
+      lambda { subject.new(nil) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "detection" do
+    let(:ne_detector) { subject.new(model) }
+
+    it "should detect nothing in an empty sentence" do
+      spans = ne_detector.detect([])
+      spans.should be_a(Array)
+      spans.length.should == 0
+    end
+
+    it "should detect the named entities" do
+      spans = ne_detector.detect(["The", "time", "is", "10", ":", "23", "am"])
+      spans.should be_a(Array)
+      spans[0].should be_a(Java::opennlp.tools.util.Span)
+      spans[0].getStart.should == 3
+      spans[0].getEnd.should == 7
+    end
+
+    it "should raise an error if anything but an array is passed" do
+      lambda { ne_detector.detect(nil) }.should raise_error(ArgumentError)
+      lambda { ne_detector.detect('str') }.should raise_error(ArgumentError)
+      lambda { ne_detector.detect(111) }.should raise_error(ArgumentError)
+    end
+  end
+end

data/spec/pos_tagger_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe OpenNlp::POSTagger do
+  subject { OpenNlp::POSTagger }
+
+  let(:model) { OpenNlp::Model::POSTagger.new(File.join(FIXTURES_DIR, "en-pos-maxent.bin")) }
+
+  describe "initialization" do
+    it "should initialize with a valid model" do
+      tagger = subject.new(model)
+      tagger.should be_a(subject)
+      tagger.j_instance.should be_a(subject.java_class)
+    end
+
+    it "should raise an ArgumentError without a valid model" do
+      lambda { subject.new(nil) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "pos tagging" do
+    let(:pos_tagger) { subject.new(model) }
+
+    it "should tag parts of a provided document" do
+      tagged = pos_tagger.tag("The quick brown fox jumps over the lazy dog.")
+      tagged.should == "The/DT quick/JJ brown/JJ fox/NN jumps/NNS over/IN the/DT lazy/JJ dog./NN"
+    end
+
+    it "should tag provided tokens" do
+      tagged = pos_tagger.tag(%w(The quick brown fox jumps over the lazy dog .))
+      tagged.to_ary.should == %w(DT JJ JJ NN NNS IN DT JJ NN .)
+    end
+
+    it "should raise an ArgumentError for a non-string" do
+      lambda { pos_tagger.tag(nil) }.should raise_error(ArgumentError)
+    end
+  end
+end

data/spec/sentence_detector_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe OpenNlp::SentenceDetector do
+  subject { OpenNlp::SentenceDetector }
+
+  let(:model) { OpenNlp::Model::SentenceDetector.new(File.join(FIXTURES_DIR, "en-sent.bin")) }
+
+  describe "initialization" do
+    it "should initialize with a valid model" do
+      sent_detector = subject.new(model)
+      sent_detector.should be_a(subject)
+      sent_detector.j_instance.should be_a(subject.java_class)
+    end
+
+    it "should raise an ArgumentError without a valid model" do
+      lambda { subject.new(nil) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "sentence detection" do
+    let(:sent_detector) { subject.new(model) }
+
+    it "should detect no sentences in an empty string" do
+      sentences = sent_detector.detect("")
+      sentences.should == []
+    end
+
+    it "should detect sentences in a string" do
+      sentences = sent_detector.detect("The sky is blue. The Grass is green.")
+      sentences.should == ["The sky is blue.", "The Grass is green."]
+    end
+
+    it "should raise an ArgumentError for a non-string" do
+      lambda { sent_detector.detect(nil) }.should raise_error(ArgumentError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'java'
+require 'open_nlp'
+
+FIXTURES_DIR = File.join(File.dirname(__FILE__), "fixtures")

data/spec/tokenizer_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe OpenNlp::Tokenizer do
+  subject { OpenNlp::Tokenizer }
+
+  let(:model) { OpenNlp::Model::Tokenizer.new(File.join(FIXTURES_DIR, "en-token.bin")) }
+
+  describe "initialization" do
+    it "should initialize a new tokenizer" do
+      tokenizer = subject.new(model)
+      tokenizer.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 "tokenize a string" do
+    let(:tokenizer) { subject.new(model) }
+
+    it "should tokenize an empty string" do
+      tokens = tokenizer.tokenize("")
+      tokens.should == []
+    end
+
+    it "should tokenize a sentence" do
+      tokens = tokenizer.tokenize("The red fox sleeps soundly.")
+      tokens.should == ["The", "red", "fox", "sleeps", "soundly", "."]
+    end
+
+    it "should raise an error when not passed a string" do
+      lambda { tokenizer.tokenize(nil) }.should raise_error(ArgumentError)
+    end
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: open_nlp
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.0.1
+platform: java
+authors:
+- Hck
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-09-21 00:00:00.000000000 Z
+dependencies: []
+description: JRuby tools wrapper for Apache OpenNLP
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/open_nlp.rb
+- lib/open_nlp/chunker.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/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/pos_tagger.rb
+- lib/open_nlp/sentence_detector.rb
+- lib/open_nlp/tokenizer.rb
+- lib/open_nlp/tool.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-pos-maxent.bin
+- spec/fixtures/en-sent.bin
+- spec/fixtures/en-token.bin
+- spec/model/chunker_spec.rb
+- spec/model/detokenizer_spec.rb
+- spec/model/named_entity_detector_spec.rb
+- spec/model/pos_tagger_spec.rb
+- spec/model/sentence_detector_spec.rb
+- spec/model/tokenizer_spec.rb
+- spec/named_entity_detector_spec.rb
+- spec/pos_tagger_spec.rb
+- spec/sentence_detector_spec.rb
+- spec/spec_helper.rb
+- spec/tokenizer_spec.rb
+homepage:
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: A JRuby wrapper for the Apache OpenNLP tools library
+test_files:
+- spec/chunker_spec.rb
+- spec/fixtures/en-chunker.bin
+- spec/fixtures/en-detokenizer.xml
+- spec/fixtures/en-ner-time.bin
+- spec/fixtures/en-pos-maxent.bin
+- spec/fixtures/en-sent.bin
+- spec/fixtures/en-token.bin
+- spec/model/chunker_spec.rb
+- spec/model/detokenizer_spec.rb
+- spec/model/named_entity_detector_spec.rb
+- spec/model/pos_tagger_spec.rb
+- spec/model/sentence_detector_spec.rb
+- spec/model/tokenizer_spec.rb
+- spec/named_entity_detector_spec.rb
+- spec/pos_tagger_spec.rb
+- spec/sentence_detector_spec.rb
+- spec/spec_helper.rb
+- spec/tokenizer_spec.rb