open_nlp 0.0.7-java → 0.1.0-java

data/spec/parser/parse_spec.rb

@@ -1,13 +1,13 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::Parser::Parse do
-  subject { OpenNlp::Parser::Parse }
+RSpec.describe OpenNlp::Parser::Parse do
   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")) }
+  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')) }
+  let(:parser) { OpenNlp::Parser.new(model, token_model) }
 
-  describe "initialization" do
-    it "should initialize a new parse object" do
+  describe 'initialization' do
+    it 'initializes 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),
@@ -16,91 +16,99 @@ describe OpenNlp::Parser::Parse do
         0.to_java(:Integer)
       )
 
-      subject.new(j_parse).should be_a(subject)
+      parse = described_class.new(j_parse)
+      expect(parse.j_instance).to be_a(described_class.java_class)
     end
 
-    it "should raise an argument error when no model is supplied" do
-      lambda { subject.new(nil) }.should raise_error(ArgumentError)
+    it 'raises an argument error when nil is passed as an argumenr' do
+      expect { described_class.new(nil) }.to 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))) (. .)))"
+  describe '#tree_bank_string' do
+    let(:expected_tree_bank_str) do
+      '(TOP (S (NP (DT The) (JJ red) (NN fox)) (VP (VBZ sleeps) (ADVP (RB soundly))) (. .)))'
+    end
+
+    it 'returns proper string value for parsed text' do
+      tree_bank_string = parser.parse(text).tree_bank_string
+      expect(tree_bank_string).to eq(expected_tree_bank_str)
     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 == [
+  describe '#code_tree' do
+    let(:expected_code_tree) do
+      [
         {
-          :type => "S",
-          :parent_type => "TOP",
-          :token => "The red fox sleeps soundly .",
+          :type => 'S',
+          :parent_type => 'TOP',
+          :token => 'The red fox sleeps soundly .',
           :children => [
             {
-              :type => "NP",
-              :parent_type => "S",
-              :token => "The red fox",
+              :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 => '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 => '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 => 'NN',
+                    :parent_type => 'NP',
+                    :token => 'fox',
+                    :children => [{:type => 'TK', :parent_type => 'NN', :token => 'fox'}]
                 }
               ]
             },
             {
-              :type => "VP",
-              :parent_type => "S",
-              :token => "sleeps soundly",
+              :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 => 'VBZ',
+                  :parent_type => 'VP',
+                  :token => 'sleeps',
+                  :children => [{:type => 'TK', :parent_type => 'VBZ', :token => 'sleeps'}]
                 },
                 {
-                  :type => "ADVP",
-                  :parent_type => "VP",
-                  :token => "soundly",
+                  :type => 'ADVP',
+                  :parent_type => 'VP',
+                  :token => 'soundly',
                   :children => [
                     {
-                      :type => "RB",
-                      :parent_type => "ADVP",
-                      :token => "soundly",
-                      :children => [{:type => "TK", :parent_type => "RB", :token => "soundly"}]
+                      :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 => "."}]
+              :type => '.',
+              :parent_type => 'S',
+              :token => '.',
+              :children => [{:type => 'TK', :parent_type => '.', :token => '.'}]
             }
           ]
         }
       ]
     end
+
+    it 'returns proper structure for parsed text' do
+      code_tree = parser.parse(text).code_tree
+      expect(code_tree).to eq(expected_code_tree)
+    end
   end
-end
+end

data/spec/parser_spec.rb

@@ -1,39 +1,44 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::Parser do
-  subject { OpenNlp::Parser }
+RSpec.describe OpenNlp::Parser do
   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")) }
+  let(:parser) { described_class.new(model, token_model) }
 
-  describe "initialization" do
-    it "should initialize a new parser" do
-      parser = subject.new(model, token_model)
-      parser.should be_a(subject)
+  describe 'initialization' do
+    it 'initializes a new parser' do
+      expect(parser.j_instance).to be_a(Java::opennlp.tools.parser.chunking.Parser)
     end
 
-    it "should raise an argument error when no model is supplied" do
-      lambda { subject.new(nil, nil) }.should raise_error(ArgumentError)
+    it 'raises an argument error when no model specified' do
+      expect { described_class.new(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) }.should raise_error(ArgumentError)
+    it 'raises an argument error when no token_model is specified' do
+      expect { described_class.new(model, nil) }.to raise_error(ArgumentError)
     end
   end
 
-  describe "parsing a string" do
-    let(:parser) { subject.new(model, token_model) }
+  describe '#parse' do
+    it 'parses an empty string' do
+      expect(parser.parse('')).to eq({})
+    end
+
+    it 'parses a sentence' do
+      res = parser.parse('The red fox sleeps soundly .')
+      expect(res).to be_a(OpenNlp::Parser::Parse)
+    end
 
-    it "should parse an empty string" do
-      parser.parse("").should == {}
+    it 'raises an error when nil is passed as an argument' do
+      expect { parser.parse(nil) }.to raise_error(ArgumentError)
     end
 
-    it "should parse a sentence" do
-      res = parser.parse("The red fox sleeps soundly .")
-      res.class.should == OpenNlp::Parser::Parse
+    it 'raises an error when fixnum is passed as an argument' do
+      expect { parser.parse(111) }.to raise_error(ArgumentError)
     end
 
-    it "should raise an error when not passed a string" do
-      lambda { parser.parse(nil) }.should raise_error(ArgumentError)
+    it 'raises an error when array is passed as an argument' do
+      expect { parser.parse([1, 2]) }.to raise_error(ArgumentError)
     end
   end
-end
+end

data/spec/pos_tagger_spec.rb

@@ -1,37 +1,36 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::POSTagger do
-  subject { OpenNlp::POSTagger }
+RSpec.describe OpenNlp::POSTagger do
+  let(:model) { OpenNlp::Model::POSTagger.new(File.join(FIXTURES_DIR, 'en-pos-maxent.bin')) }
+  let(:pos_tagger) { described_class.new(model) }
 
-  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)
+  describe 'initialization' do
+    it 'initialize with a valid model' do
+      expect(pos_tagger.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 "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"
+  describe '#tag' do
+    it 'tags parts of a provided document' do
+      tagged = pos_tagger.tag('The quick brown fox jumps over the lazy dog.')
+      expect(tagged).to eq('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
+    it 'tags 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 .)
+      expect(tagged.to_ary).to eq(%w(DT JJ JJ NN NNS IN DT JJ NN .))
+    end
+
+    it 'raises an ArgumentError when nil is passed as an argument' do
+      expect { pos_tagger.tag(nil) }.to raise_error(ArgumentError)
     end
 
-    it "should raise an ArgumentError for a non-string" do
-      lambda { pos_tagger.tag(nil) }.should raise_error(ArgumentError)
+    it 'raises an ArgumentError when fixnum is passed as an argument' do
+      expect { pos_tagger.tag(111) }.to raise_error(ArgumentError)
     end
   end
-end
+end

data/spec/sentence_detector_spec.rb

@@ -1,50 +1,59 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::SentenceDetector do
-  subject { OpenNlp::SentenceDetector }
+RSpec.describe OpenNlp::SentenceDetector do
+  let(:model) { OpenNlp::Model::SentenceDetector.new(File.join(FIXTURES_DIR, 'en-sent.bin')) }
+  let(:sentence_detector) { described_class.new(model) }
 
-  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)
+  describe 'initialization' do
+    it 'initializes with a valid model' do
+      expect(sentence_detector.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 { subject.new(nil) }.to raise_error(ArgumentError)
     end
   end
 
-  describe "#detect" do
-    let(:sent_detector) { subject.new(model) }
+  describe '#detect' do
+    it 'detects no sentences in an empty string' do
+      sentences = sentence_detector.detect('')
+      expect(sentences).to eq([])
+    end
+
+    it 'detects sentences in a string' do
+      sentences = sentence_detector.detect('The sky is blue. The Grass is green.')
+      expect(sentences).to eq(['The sky is blue.', 'The Grass is green.'])
+    end
 
-    it "should detect no sentences in an empty string" do
-      sentences = sent_detector.detect("")
-      sentences.should == []
+    it 'raises an ArgumentError when nil is passed as an argument' do
+      expect { sentence_detector.detect(nil) }.to raise_error(ArgumentError)
     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."]
+    it 'raises an ArgumentError when fixnum is passed as an argument' do
+      expect { sentence_detector.detect(111) }.to raise_error(ArgumentError)
     end
 
-    it "should raise an ArgumentError for a non-string" do
-      lambda { sent_detector.detect(nil) }.should raise_error(ArgumentError)
+    it 'raises an ArgumentError when array is passed as an argument' do
+      expect { sentence_detector.detect([1, 2]) }.to raise_error(ArgumentError)
     end
   end
 
-  describe "#pos_detect" do
-    let(:sent_detector) { subject.new(model) }
+  describe '#pos_detect' do
+    it 'detects sentences in a string' do
+      sentences = sentence_detector.pos_detect('The sky is blue. The Grass is green.')
+      expect(sentences).to eq([OpenNlp::Util::Span.new(0, 16), OpenNlp::Util::Span.new(17, 36)])
+    end
+
+    it 'raises an ArgumentError when nil is passed as an argument' do
+      expect { sentence_detector.pos_detect(nil) }.to raise_error(ArgumentError)
+    end
 
-    it "should detect sentences in a string" do
-      sentences = sent_detector.pos_detect("The sky is blue. The Grass is green.")
-      sentences.should == [OpenNlp::Util::Span.new(0, 16), OpenNlp::Util::Span.new(17, 36)]
+    it 'raises an ArgumentError when fixnum is passed as an argument' do
+      expect { sentence_detector.pos_detect(111) }.to raise_error(ArgumentError)
     end
 
-    it "should raise an ArgumentError for a non-string" do
-      expect { sent_detector.detect(nil) }.to raise_error(ArgumentError)
+    it 'raises an ArgumentError when array is passed as an argument' do
+      expect { sentence_detector.pos_detect([1, 2]) }.to raise_error(ArgumentError)
     end
   end
-end
+end

data/spec/spec_helper.rb

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

data/spec/tokenizer_spec.rb

@@ -1,36 +1,40 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe OpenNlp::Tokenizer do
-  subject { OpenNlp::Tokenizer }
+RSpec.describe OpenNlp::Tokenizer do
+  let(:model) { OpenNlp::Model::Tokenizer.new(File.join(FIXTURES_DIR, 'en-token.bin')) }
+  let(:tokenizer) { described_class.new(model) }
 
-  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)
+  describe 'initialization' do
+    it 'initialize a new tokenizer' do
+      expect(tokenizer.j_instance).to be_a(described_class.java_class)
     end
 
-    it "should raise an argument error when no model is supplied" do
-      lambda { subject.new(nil) }.should raise_error(ArgumentError)
+    it 'raises an argument error when no model is specified' do
+      expect { subject.new(nil) }.to raise_error(ArgumentError)
     end
   end
 
-  describe "tokenize a string" do
-    let(:tokenizer) { subject.new(model) }
+  describe 'tokenize a string' do
+    it 'tokenizes an empty string' do
+      tokens = tokenizer.tokenize('')
+      expect(tokens).to eq([])
+    end
+
+    it 'tokenizes a sentence' do
+      tokens = tokenizer.tokenize('The red fox sleeps soundly.')
+      expect(tokens).to eq(['The', 'red', 'fox', 'sleeps', 'soundly', '.'])
+    end
 
-    it "should tokenize an empty string" do
-      tokens = tokenizer.tokenize("")
-      tokens.should == []
+    it 'raises an error when nil is passed as an argument' do
+      expect { tokenizer.tokenize(nil) }.to raise_error(ArgumentError)
     end
 
-    it "should tokenize a sentence" do
-      tokens = tokenizer.tokenize("The red fox sleeps soundly.")
-      tokens.should == ["The", "red", "fox", "sleeps", "soundly", "."]
+    it 'raises an error when fixnum is passed as an argument' do
+      expect { tokenizer.tokenize(111) }.to raise_error(ArgumentError)
     end
 
-    it "should raise an error when not passed a string" do
-      lambda { tokenizer.tokenize(nil) }.should raise_error(ArgumentError)
+    it 'raises an error when array is passed as an argument' do
+      expect { tokenizer.tokenize([1, 2]) }.to raise_error(ArgumentError)
     end
   end
-end
+end