open_nlp 0.0.7-java → 0.1.0-java

data/lib/open_nlp/tool.rb

@@ -5,7 +5,7 @@ module OpenNlp
     attr_reader :j_instance
 
     def initialize(model)
-      raise ArgumentError, "model must be an OpenNlp::Model" unless model.is_a?(OpenNlp::Model)
+      fail ArgumentError, 'model must be an OpenNlp::Model' unless model.is_a?(OpenNlp::Model)
       @j_instance = self.class.java_class.new(model.j_model)
     end
   end

data/lib/open_nlp/util.rb

@@ -1,5 +1,4 @@
 module OpenNlp
   module Util
-
   end
-end
+end

data/lib/open_nlp/util/span.rb

@@ -6,8 +6,8 @@ class OpenNlp::Util::Span
   attr_reader :j_instance
 
   def initialize(s, e)
-    raise ArgumentError, "s should be an integer" unless s.is_a?(Fixnum)
-    raise ArgumentError, "e should be an integer" unless e.is_a?(Fixnum)
+    fail ArgumentError, 's should be an integer' unless s.is_a?(Fixnum)
+    fail ArgumentError, 'e should be an integer' unless e.is_a?(Fixnum)
 
     @j_instance = self.class.java_class.new(s, e)
   end
@@ -31,8 +31,8 @@ class OpenNlp::Util::Span
   def ==(obj)
     return false unless obj.is_a?(self.class)
 
-    [:start, :end, :type].each_with_object(true) do |m,res|
-      res = res && self.public_send(m) == obj.public_send(m)
+    [:start, :end, :type].each_with_object(true) do |method, acc|
+      acc = acc && self.public_send(method) == obj.public_send(method)
     end
   end
-end
+end

data/lib/open_nlp/version.rb

@@ -1,3 +1,3 @@
 module OpenNlp
-  VERSION = '0.0.7'
+  VERSION = '0.1.0'
 end

data/spec/categorizer_spec.rb

@@ -1,36 +1,38 @@
 require 'spec_helper'
 
-describe OpenNlp::Categorizer do
-  subject { OpenNlp::Categorizer }
-  let(:model){ OpenNlp::Model::Categorizer.new(File.join(FIXTURES_DIR, "en-doccat.bin")) }
-
-  describe "initialization" do
-    it "should initialize with a valid model" do
-      categorizer = subject.new(model)
-      categorizer.should be_a(subject)
-      categorizer.j_instance.should be_a(subject.java_class)
+RSpec.describe OpenNlp::Categorizer do
+  let(:model) { OpenNlp::Model::Categorizer.new(File.join(FIXTURES_DIR, 'en-doccat.bin')) }
+
+  describe 'initialization' do
+    it 'is initialized with a valid model' do
+      categorizer = described_class.new(model)
+      expect(categorizer.j_instance).to be_a(described_class.java_class)
     end
 
-    it "should raise an ArgumentError without a valid model" do
-      lambda { subject.new(nil) }.should raise_error(ArgumentError)
+    it 'raises an ArgumentError without a valid model' do
+      expect { described_class.new(nil) }.to raise_error(ArgumentError)
     end
   end
 
-  describe "categorizing a string" do
-    let(:categorizer) { subject.new(model) }
+  describe '#categorize' do
+    let(:categorizer) { described_class.new(model) }
+
+    it 'categorizes a provided document to positive' do
+      category = categorizer.categorize('The fox is a good worker.')
+      expect(category).to eq('Positive')
+    end
 
-    it "should categorize a provided document to positive" do
-      category = categorizer.categorize("The fox is a good worker.")
-      category.should == "Positive"
+    it 'categorizes a provided document to negative' do
+      category = categorizer.categorize('Quick brown fox jumps very bad.')
+      expect(category).to eq('Negative')
     end
 
-    it "should categorize a provided document to negative" do
-      category = categorizer.categorize("Quick brown fox jumps very bad.")
-      category.should == "Negative"
+    it 'raises an ArgumentError when nil is passed as a param' do
+      expect { categorizer.categorize(nil) }.to raise_error(ArgumentError)
     end
 
-    it "should raise an ArgumentError for a non-string" do
-      lambda { categorizer.categorize(nil) }.should raise_error(ArgumentError)
+    it 'raises an ArgumentError when Fixnum is passed a param' do
+      expect { categorizer.categorize(123) }.to raise_error(ArgumentError)
     end
   end
-end
+end

data/spec/chunker_spec.rb

@@ -1,46 +1,47 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::Chunker do
-  subject { OpenNlp::Chunker }
+RSpec.describe OpenNlp::Chunker do
+  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')) }
+  let(:chunker) { described_class.new(model, token_model, pos_model) }
 
-  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)
+  describe 'initialization' do
+    it 'initializes a new chunker' do
+      expect(chunker).to be_a(described_class)
     end
 
-    it "should raise an argument error when no model is supplied" do
-      lambda { subject.new(nil, nil, nil) }.should raise_error(ArgumentError)
+    it 'raises an argument error when no model is specified' do
+      expect { subject.new(nil, nil, nil) }.to 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)
+    it 'raises an argument error when no token_model is specified' do
+      expect { subject.new(model, nil, nil) }.to 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)
+    it 'raises an argument error when no pos_model is specified' do
+      expect { subject.new(model, token_model, nil) }.to 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 == []
+  describe 'chunking a string' do
+    it 'chunks an empty string' do
+      chunks = chunker.chunk('')
+      expect(chunks).to eq([])
     end
 
-    it "should chunk a sentence" do
-      chunks = chunker.chunk("The red fox sleeps soundly.")
-      chunks.should == [[{"The"=>"DT"}, {"red"=>"JJ"}, {"fox"=>"NN"}, {"sleeps"=>"NNS"}], [{"soundly"=>"RB"}]]
+    it 'chunks a sentence' do
+      chunks = chunker.chunk('The red fox sleeps soundly.')
+      expect(chunks).to eq(
+        [
+          [{ 'The' => 'DT' }, { 'red' => 'JJ' }, { 'fox' => 'NN' }, { 'sleeps' => 'NNS' }],
+          [{ 'soundly' => 'RB' }]
+        ]
+      )
     end
 
-    it "should raise an error when not passed a string" do
-      lambda { chunker.chunk(nil) }.should raise_error(ArgumentError)
+    it 'raises an error when not passed a string' do
+      expect { chunker.chunk(nil) }.to raise_error(ArgumentError)
     end
   end
 end

data/spec/model/chunker_spec.rb

@@ -1,23 +1,20 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::Model::Chunker do
-  subject { OpenNlp::Model::Chunker }
-  let(:model_file_name) { File.join(FIXTURES_DIR, "en-chunker.bin") }
+RSpec.describe OpenNlp::Model::Chunker do
+  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)
+  it 'accepts a string filename parameter' do
+    chunker_model = described_class.new(model_file_name)
+    expect(chunker_model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should accept a java.io.FileInputStream object" do
+  it 'accepts 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)
+    chunker_model = described_class.new(file_input_stream)
+    expect(chunker_model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should raise an argument error otherwise" do
-    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  it 'raises an argument error when nil is passed as a model' do
+    expect { described_class.new(nil) }.to raise_error(ArgumentError)
   end
-end
+end

data/spec/model/detokenizer_spec.rb

@@ -1,23 +1,20 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::Model::Detokenizer do
-  subject { OpenNlp::Model::Detokenizer }
-  let(:model_file_name) { File.join(FIXTURES_DIR, "en-detokenizer.xml") }
+RSpec.describe OpenNlp::Model::Detokenizer do
+  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)
+  it 'accepts a string filename parameter' do
+    model = described_class.new(model_file_name)
+    expect(model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should accept a java.io.FileInputStream object" do
+  it 'accepts 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)
+    model = described_class.new(file_input_stream)
+    expect(model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should raise an argument error otherwise" do
-    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  it 'raises an argument error when nil is passed as a model' do
+    expect { described_class.new(nil) }.to raise_error(ArgumentError)
   end
 end

data/spec/model/named_entity_detector_spec.rb

@@ -1,23 +1,20 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::Model::NamedEntityDetector do
-  subject { OpenNlp::Model::NamedEntityDetector }
-  let(:model_file_name) { File.join(FIXTURES_DIR, "en-ner-time.bin") }
+RSpec.describe OpenNlp::Model::NamedEntityDetector do
+  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)
+  it 'accepts a string filename parameter' do
+    model = described_class.new(model_file_name)
+    expect(model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should accept a java.io.FileInputStream object" do
+  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)
+    model = described_class.new(file_input_stream)
+    expect(model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should raise an argument error otherwise" do
-    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  it 'raises an argument error when nil is passed as a model' do
+    expect { described_class.new(nil) }.to raise_error(ArgumentError)
   end
 end

data/spec/model/pos_tagger_spec.rb

@@ -1,23 +1,20 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::Model::POSTagger do
-  subject { OpenNlp::Model::POSTagger }
-  let(:model_file_name) { File.join(FIXTURES_DIR, "en-pos-maxent.bin") }
+RSpec.describe OpenNlp::Model::POSTagger do
+  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)
+  it 'accepts a string filename parameter' do
+    model = described_class.new(model_file_name)
+    expect(model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should accept a java.io.FileInputStream object" do
+  it 'accepts 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)
+    model = described_class.new(file_input_stream)
+    expect(model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should raise an argument error otherwise" do
-    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  it 'raises an argument error when nil is passed as a model' do
+    expect { described_class.new(nil) }.to raise_error(ArgumentError)
   end
-end
+end

data/spec/model/sentence_detector_spec.rb

@@ -1,23 +1,20 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::Model::SentenceDetector do
-  subject { OpenNlp::Model::SentenceDetector }
-  let(:model_file_name) { File.join(FIXTURES_DIR, "en-sent.bin") }
+RSpec.describe OpenNlp::Model::SentenceDetector do
+  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)
+  it 'accepts a string filename parameter' do
+    model = described_class.new(model_file_name)
+    expect(model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should accept a java.io.FileInputStream object" do
+  it 'accepts 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)
+    model = described_class.new(file_input_stream)
+    expect(model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should raise an argument error otherwise" do
-    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  it 'raises an argument error when nil is passed as a model' do
+    expect { described_class.new(nil) }.to raise_error(ArgumentError)
   end
 end

data/spec/model/tokenizer_spec.rb

@@ -1,23 +1,20 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe OpenNlp::Model::Tokenizer do
-  subject { OpenNlp::Model::Tokenizer }
-  let(:model_file_name) { File.join(FIXTURES_DIR, "en-token.bin") }
+  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)
+  it 'accept a string filename parameter' do
+    model = described_class.new(model_file_name)
+    expect(model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should accept a java.io.FileInputStream object" do
+  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)
+    model = described_class.new(file_input_stream)
+    expect(model.j_model).to be_a(described_class.java_class)
   end
 
-  it "should raise an argument error otherwise" do
-    lambda { subject.new(nil) }.should raise_error(ArgumentError)
+  it 'raises an argument error when nil is passed as a model' do
+    expect { described_class.new(nil) }.to raise_error(ArgumentError)
   end
-end
+end

data/spec/named_entity_detector_spec.rb

@@ -1,42 +1,43 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::NamedEntityDetector do
-  subject { OpenNlp::NamedEntityDetector }
-
-  let(:model) { OpenNlp::Model::NamedEntityDetector.new(File.join(FIXTURES_DIR, "en-ner-time.bin")) }
+RSpec.describe OpenNlp::NamedEntityDetector do
+  let(:model) { OpenNlp::Model::NamedEntityDetector.new(File.join(FIXTURES_DIR, 'en-ner-time.bin')) }
+  let(:ne_detector) { described_class.new(model) }
   
-  describe "initialization" do
-    it "should initialize with a valid model" do
-      ne_detector = subject.new(model)
-      ne_detector.should be_a(subject)
+  describe 'initialization' do
+    it 'initializes with a valid model' do
+      expect(ne_detector.j_instance).to be_a(described_class.java_class)
     end
 
-    it "should raise an ArgumentError otherwise" do
-      lambda { subject.new(nil) }.should raise_error(ArgumentError)
+    it 'raises an ArgumentError otherwise' do
+      expect { subject.new(nil) }.to raise_error(ArgumentError)
     end
   end
 
-  describe "detection" do
-    let(:ne_detector) { subject.new(model) }
-
-    it "should detect nothing in an empty sentence" do
+  describe '#detect' do
+    it 'detects nothing for empty sentence' do
       spans = ne_detector.detect([])
-      spans.should be_a(Array)
-      spans.length.should == 0
+      expect(spans).to eq([])
+    end
+
+    it 'detects the named entities' do
+      spans = ne_detector.detect(['The', 'time', 'is', '10', ':', '23', 'am'])
+      expect(spans.size).to eq(1)
+      expect(spans.first).to be_a(Java::opennlp.tools.util.Span)
+      expect(spans.first.getStart).to eq(3)
+      expect(spans.first.getEnd).to eq(7)
+    end
+
+    it 'raises an error if nil is passed as an argument' do
+      expect { ne_detector.detect(nil) }.to raise_error(ArgumentError)
     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
+    it 'raises an error if string is passed as an argument' do
+      expect { ne_detector.detect('str') }.to raise_error(ArgumentError)
     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)
+    it 'raises an error if fixnum is passed as an argument' do
+      expect { ne_detector.detect(111) }.to raise_error(ArgumentError)
     end
   end
 end