open_nlp 0.2.0-java → 0.3.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b3d6968e3686d75cbe3875f8381249b6ff289b94
-  data.tar.gz: eadddd4c5e86d4b3654c6e7c83dd59823e5bb6e2
+SHA256:
+  metadata.gz: 611fa39e5357a43ac259dc113b299aede41e5379a1912dcd0bb32120da05356d
+  data.tar.gz: 0ef94231098429a66a11f8d3ab5dc5708156fcc425caa5ab4e29278f5233ab1f
 SHA512:
-  metadata.gz: 424960c23f13b6e9e6f3c85ab137b341075ba118b42b4009e3fb26cb37d62fb9bf4b117405bfd3382cb71a3785da891bc9f0d4fba2aede99b3e7c6ed0cffa5b4
-  data.tar.gz: b047c3e19f850bc46692a3ad58ac8bf7282e9393388f19601571a67e05f2bd4d078aa51d3536ea3f9554dce9a4be498329eb4f586dae1ddc23d026ccdbb29438
+  metadata.gz: 6e5fc1bbbd6059d818bbe3abc9408f497b845dd6e4a314b19a9d47a8e85a3435cdbe8d6c9fd2610f0a643a26974d4b20a0fc995c6660549149f9acaa688d3f52
+  data.tar.gz: c416e14a29512f1935a00289625ea162fac34f8dad4d320a8c8cf940253a6f9ac5c845e07bda12deca699ec5da809bbc733d9e392795e2895faa78e0d826a76c

data/.gitignore

@@ -11,6 +11,7 @@ lib/bundler/man
 pkg
 rdoc
 spec/reports
+spec/examples.txt
 test/tmp
 test/version_tmp
 tmp

data/.rspec

@@ -1 +1,2 @@
 --colour
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,24 @@
+Metrics/AbcSize:
+  Max: 41
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*.rb
+
+Metrics/LineLength:
+  Max: 153
+
+Metrics/MethodLength:
+  Max: 15
+
+Metrics/ParameterLists:
+  Max: 6
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/ColonMethodCall:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false

data/.ruby-version

@@ -1 +1 @@
-jruby-9.0.5.0
+jruby-9.2.4.0

data/.travis.yml

@@ -1,6 +1,4 @@
 language: ruby
 rvm:
-  - jruby-19mode
-  - jruby-1.7.20
-  - jruby-9.0.5.0
+  - jruby-9.2.4.0
 script: JRUBY_OPTS=-J-Xmx768m bundle exec rspec spec

data/Gemfile

@@ -5,4 +5,5 @@ gemspec
 
 group :test do
   gem 'rspec'
-end
+  gem 'rubocop'
+end

data/Gemfile.lock

@@ -1,24 +1,42 @@
 PATH
   remote: .
   specs:
+    open_nlp (0.3.0-java)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    diff-lcs (1.2.5)
-    rspec (3.4.0)
-      rspec-core (~> 3.4.0)
-      rspec-expectations (~> 3.4.0)
-      rspec-mocks (~> 3.4.0)
-    rspec-core (3.4.4)
-      rspec-support (~> 3.4.0)
-    rspec-expectations (3.4.0)
+    ast (2.4.0)
+    diff-lcs (1.3)
+    jaro_winkler (1.5.1-java)
+    parallel (1.12.1)
+    parser (2.5.3.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    rainbow (3.0.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.4.0)
-    rspec-mocks (3.4.1)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.4.0)
-    rspec-support (3.4.1)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rubocop (0.60.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.4.0)
+    ruby-progressbar (1.10.0)
+    unicode-display_width (1.4.0)
 
 PLATFORMS
   java
@@ -26,6 +44,7 @@ PLATFORMS
 DEPENDENCIES
   open_nlp!
   rspec
+  rubocop
 
 BUNDLED WITH
-   1.11.2
+   1.17.1

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'

data/lib/open_nlp/categorizer.rb

@@ -7,10 +7,10 @@ module OpenNlp
     # @param [String] str string to be categorized
     # @return [String] category
     def categorize(str)
-      fail ArgumentError, 'str param must be a String' unless str.is_a?(String)
+      raise ArgumentError, 'str param must be a String' unless str.is_a?(String)
 
       outcomes = j_instance.categorize(str)
       j_instance.getBestCategory(outcomes)
     end
   end
-end
+end

data/lib/open_nlp/chunker.rb

@@ -2,16 +2,19 @@ module OpenNlp
   class Chunker < Tool
     self.java_class = Java::opennlp.tools.chunker.ChunkerME
 
+    # Initializes new instance of Chunker
+    #
+    # @param [OpenNlp::Model] model chunker model
+    # @param [Model::Tokenizer] token_model tokenizer model
+    # @param [Model::POSTagger] pos_model part-of-speech tagging model
     def initialize(model, token_model, pos_model)
       super(model)
 
-      unless token_model.is_a?(Model::Tokenizer)
-        fail ArgumentError, 'token model must be an OpenNlp::Tokenizer::Model'
-      end
+      token_model.is_a?(Model::Tokenizer) ||
+        raise(ArgumentError, 'token model must be an OpenNlp::Tokenizer::Model')
 
-      unless pos_model.is_a?(Model::POSTagger)
-        fail ArgumentError, 'pos model must be an OpenNlp::POSTagger::Model'
-      end
+      pos_model.is_a?(Model::POSTagger) ||
+        raise(ArgumentError, 'pos model must be an OpenNlp::POSTagger::Model')
 
       @tokenizer = Tokenizer.new(token_model)
       @pos_tagger = POSTagger.new(pos_model)
@@ -22,7 +25,7 @@ module OpenNlp
     # @param [String] str string to chunk
     # @return [Array] array of chunks with part-of-sentence information
     def chunk(str)
-      fail ArgumentError, 'str must be a String' unless str.is_a?(String)
+      raise ArgumentError, 'str must be a String' unless str.is_a?(String)
 
       tokens = tokenizer.tokenize(str)
       pos_tags = pos_tagger.tag(tokens).to_ary
@@ -39,24 +42,22 @@ module OpenNlp
     def build_chunks(chunks, tokens, pos_tags)
       data = tokens.zip(pos_tags, chunks)
 
-      data.inject([]) do |acc, val|
+      data.each_with_object([]) do |val, acc|
         chunk = val[2]
-        acc << [{val[0] => val[1]}] if chunk[0] == 'B' # add token to chunk if it is a start of chunk
-
-        if chunk[0] == 'I'
-          if acc.last
-            acc.last << {val[0] => val[1]} # add token to chunk if it is a continuation of chunk
-          else
-            acc << [{val[0] => val[1]}] # add token to new chunk if no chunks exists
-          end
-        end
+        acc << [{ val[0] => val[1] }] if chunk[0] == 'B' # add token to chunk if it is a start of chunk
+
+        next if chunk[0] != 'I'
 
-        acc
+        if acc.last
+          acc.last << { val[0] => val[1] } # add token to chunk if it is a continuation of chunk
+        else
+          acc << [{ val[0] => val[1] }] # add token to new chunk if no chunks exists
+        end
       end
     end
 
-    def get_last_probabilities
+    def last_probabilities
       j_instance.probs.to_ary
     end
   end
-end
+end

data/lib/open_nlp/java_class.rb

@@ -5,13 +5,7 @@ module OpenNlp
     end
 
     module ClassMethods
-      def java_class=(value)
-        @java_class = value
-      end
-
-      def java_class
-        @java_class
-      end
+      attr_accessor :java_class
     end
   end
-end
+end

data/lib/open_nlp/model.rb

@@ -4,6 +4,9 @@ module OpenNlp
 
     attr_reader :j_model
 
+    # Initializes new instance of Model
+    #
+    # @param [String, java.io.FileInputStream] model
     def initialize(model)
       @j_model = self.class.java_class.new(model_stream(model))
     end
@@ -17,7 +20,7 @@ module OpenNlp
       when String
         java.io.FileInputStream.new(model)
       else
-        fail ArgumentError, 'Model must be either a string or a java.io.FileInputStream'
+        raise ArgumentError, 'Model must be either a string or a java.io.FileInputStream'
       end
     end
   end

data/lib/open_nlp/model/categorizer.rb

@@ -1,3 +1,3 @@
 class OpenNlp::Model::Categorizer < OpenNlp::Model
   self.java_class = Java::opennlp.tools.doccat.DoccatModel
-end
+end

data/lib/open_nlp/model/chunker.rb

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

data/lib/open_nlp/model/detokenizer.rb

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

data/lib/open_nlp/model/parser.rb

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

data/lib/open_nlp/model/pos_tagger.rb

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

data/lib/open_nlp/model/sentence_detector.rb

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

data/lib/open_nlp/model/tokenizer.rb

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

data/lib/open_nlp/named_entity_detector.rb

@@ -7,7 +7,8 @@ module OpenNlp
     # @param [Array<String>] tokens tokens to run name detection on
     # @return [Array<Java::opennlp.tools.util.Span>] names detected
     def detect(tokens)
-      fail ArgumentError, 'tokens must be an instance of Array' unless tokens.is_a?(Array)
+      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

data/lib/open_nlp/parser.rb

@@ -1,13 +1,15 @@
 module OpenNlp
   class Parser < Tool
+    # Initializes new instance of Parser
+    #
+    # @param [OpenNlp::Model::Parser] parser_model
+    # @param [OpenNlp::Model::Tokenizer] token_model
     def initialize(parser_model, token_model)
-      unless parser_model.is_a?(OpenNlp::Model)
-        fail ArgumentError, 'parser_model must be an OpenNlp::Model'
-      end
+      parser_model.is_a?(OpenNlp::Model::Parser) ||
+        raise(ArgumentError, 'parser_model must be an OpenNlp::Model')
 
-      unless token_model.is_a?(Model::Tokenizer)
-        fail ArgumentError, 'token_model must be an OpenNlp::Tokenizer::Model'
-      end
+      token_model.is_a?(Model::Tokenizer) ||
+        raise(ArgumentError, 'token_model must be an OpenNlp::Tokenizer::Model')
 
       @j_instance = Java::opennlp.tools.parser.ParserFactory.create(parser_model.j_model)
       @tokenizer = Tokenizer.new(token_model)
@@ -19,6 +21,7 @@ module OpenNlp
     # @return [OpenNlp::Parser::Parse]
     def parse(text)
       raise ArgumentError, 'passed text must be a String' unless text.is_a?(String)
+
       text.empty? ? {} : parse_tokens(tokenizer.tokenize(text), text)
     end
 
@@ -27,16 +30,14 @@ module OpenNlp
     attr_reader :tokenizer
 
     def get_token_offset(text, tokens, index)
-      offset = 0
-      return offset unless index > 0
+      return 0 if index.zero?
 
-      for i in (1..index) do
-        offset = text.index tokens[i], offset + tokens[i - 1].size
+      (1..index).inject(0) do |offset, i|
+        text.index(tokens[i], offset + tokens[i - 1].size)
       end
-      offset
     end
 
-    def build_parse_obj(text, span_start, span_end, type=Java::opennlp.tools.parser.AbstractBottomUpParser::INC_NODE, probability=1, token_index=0)
+    def build_parse_obj(text, span_start, span_end, type = Java::opennlp.tools.parser.AbstractBottomUpParser::INC_NODE, probability = 1, token_index = 0)
       Java::opennlp.tools.parser.Parse.new(
         text.to_java(:String),
         Java::opennlp.tools.util.Span.new(span_start, span_end),

data/lib/open_nlp/parser/parse.rb

@@ -6,36 +6,57 @@ module OpenNlp
 
     self.java_class = Java::opennlp.tools.parser.Parse
 
+    # Initializes instance of Parser::Parse
+    #
+    # @param [Java::opennlp.tools.parser.Parse] java_instance
     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)
+      java_instance.is_a?(self.class.java_class) ||
+        raise(ArgumentError, "java_instance must be an instance of #{self.class.java_class.name}")
 
       @j_instance = java_instance
     end
 
+    # Composes tree bank string, nested string representation of sentence parts, parts-of-speech and words,
+    # for example:
+    #   '(TOP (S (NP (DT The) (JJ red) (NN fox)) (VP (VBZ sleeps) (ADVP (RB soundly))) (. .)))'
+    #
+    # @return [String]
     def tree_bank_string
-      span, text, type, res = j_instance.getSpan, j_instance.getText, j_instance.getType, ''
-      start                 = span.getStart
+      span = j_instance.getSpan
+      text = j_instance.getText
+      type = j_instance.getType
+      res = ''
+      start = span.getStart
 
       res << "(#{type} " if type != Java::opennlp.tools.parser.AbstractBottomUpParser::TOK_NODE
 
       j_instance.getChildren.each do |child|
         child_span = child.span
-        res << text[start..child_span.getStart-1] if start < child_span.getStart
+        res << text[start..child_span.getStart - 1] if start < child_span.getStart
         res << self.class.new(child).tree_bank_string
         start = child_span.getEnd
       end
 
-      res << text[start..span.getEnd-1] if start < span.getEnd
-      res << ")" if type != Java::opennlp.tools.parser.AbstractBottomUpParser::TOK_NODE
+      res << text[start..span.getEnd - 1] if start < span.getEnd
+      res << ')' if type != Java::opennlp.tools.parser.AbstractBottomUpParser::TOK_NODE
 
       res
     end
 
+    # Composes array representation of sentence tree where
+    # each hash has following fields:
+    #
+    #  :type => <[String] node type>,
+    #  :parent_type => <[String] type of parent node>,
+    #  :token => <[String] current token>,
+    #  :children => <Array[Hash] array of child nodes hashes>
+    #
+    # @return [Array<Hash>]
     def code_tree
       kids = j_instance.getChildren
 
       kids.each_with_object([]) do |kid, acc|
-        data    = { :type => kid.getType, :parent_type => self.j_instance.getType, :token => kid.toString }
+        data = { type: kid.getType, parent_type: j_instance.getType, token: kid.toString }
         subtree = self.class.new(kid).code_tree
         data[:children] = subtree unless subtree.empty?
         acc << data

data/lib/open_nlp/pos_tagger.rb

@@ -2,10 +2,13 @@ module OpenNlp
   class POSTagger < Tool
     self.java_class = Java::opennlp.tools.postag.POSTaggerME
 
+    # Adds tags to tokens passed as argument
+    #
+    # @param [Array<String>, String] tokens tokens to tag
+    # @return [Array<String>, String] array of part-of-speech tags or string with added part-of-speech tags
     def tag(tokens)
-      unless (tokens.is_a?(Array) || tokens.is_a?(String))
-        fail ArgumentError, 'tokens must be an instance of String or Array'
-      end
+      !tokens.is_a?(Array) && !tokens.is_a?(String) &&
+        raise(ArgumentError, 'tokens must be an instance of String or Array')
 
       j_instance.tag(tokens.to_java(:String))
     end

data/lib/open_nlp/sentence_detector.rb

@@ -7,7 +7,8 @@ module OpenNlp
     # @param [String] string string to detect sentences in
     # @return [Array<String>] array of detected sentences
     def detect(str)
-      fail ArgumentError, 'str must be a String' unless str.is_a?(String)
+      raise ArgumentError, 'str must be a String' unless str.is_a?(String)
+
       j_instance.sentDetect(str).to_ary
     end
 
@@ -16,10 +17,11 @@ module OpenNlp
     # @param [String] str
     # @return [Array<OpenNlp::Util::Span>] array of spans for detected sentences
     def pos_detect(str)
-      fail ArgumentError, 'str must be a String' unless str.is_a?(String)
+      raise ArgumentError, 'str must be a String' unless str.is_a?(String)
+
       j_instance.sentPosDetect(str).map do |span|
         OpenNlp::Util::Span.new(span.getStart, span.getEnd)
       end
     end
   end
-end
+end

data/lib/open_nlp/tokenizer.rb

@@ -7,13 +7,14 @@ module OpenNlp
     # @param [String] str string to tokenize
     # @return [Array] array of string tokens
     def tokenize(str)
-      fail ArgumentError, 'str must be a String' unless str.is_a?(String)
+      raise ArgumentError, 'str must be a String' unless str.is_a?(String)
+
       j_instance.tokenize(str).to_ary
     end
 
     private
 
-    def get_last_probabilities
+    def last_probabilities
       j_instance.getTokenProbabilities.to_ary
     end
   end

data/lib/open_nlp/tool.rb

@@ -4,9 +4,13 @@ module OpenNlp
 
     attr_reader :j_instance
 
+    # Initializes instance of Tool
+    #
+    # @param [OpenNlp::Model] model instance of model class to initialize a tool object
     def initialize(model)
-      fail ArgumentError, 'model must be an OpenNlp::Model' unless model.is_a?(OpenNlp::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
   end
-end
+end

data/lib/open_nlp/util/span.rb

@@ -5,34 +5,50 @@ class OpenNlp::Util::Span
 
   attr_reader :j_instance
 
-  def initialize(s, e)
-    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)
+  # Initializes new instance of Util::Span
+  #
+  # @param [Integer] start start index of the span
+  # @param [Integer] end end index of the span
+  def initialize(start_pos, end_pos)
+    raise ArgumentError, 'start should be an integer' unless start_pos.is_a?(Integer)
+    raise ArgumentError, 'end should be an integer' unless end_pos.is_a?(Integer)
+
+    @j_instance = self.class.java_class.new(start_pos, end_pos)
   end
 
+  # Returns end index of the span
+  #
+  # @return [Integer]
   def start
     j_instance.getStart
   end
 
+  # Returns end index of the span
+  #
+  # @return [Integer]
   def end
     j_instance.getEnd
   end
 
+  # Returns type of the span
+  #
+  # @return [String]
   def type
     j_instance.getType
   end
 
+  # Returns length of the span
+  #
+  # @return [Integer]
   def length
     j_instance.length
   end
 
-  def ==(obj)
-    return false unless obj.is_a?(self.class)
+  def ==(other)
+    return false unless other.is_a?(self.class)
 
-    [:start, :end, :type].each_with_object(true) do |method, acc|
-      acc = acc && self.public_send(method) == obj.public_send(method)
+    %i[start end type].inject(true) do |acc, method|
+      acc && public_send(method) == other.public_send(method)
     end
   end
 end

data/lib/open_nlp/version.rb

@@ -1,3 +1,3 @@
 module OpenNlp
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'.freeze
 end

data/open_nlp.gemspec

@@ -1,20 +1,19 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'open_nlp/version'
 
 Gem::Specification.new do |gem|
-  gem.name          = "open_nlp"
+  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.homepage      = "http://github.com/hck/open_nlp"
+  gem.authors       = ['Hck']
+  gem.description   = 'JRuby tools wrapper for Apache OpenNLP'
+  gem.summary       = '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) }
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  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.require_paths = ['lib']
 
-  gem.platform = "java"
+  gem.platform = 'java'
 end

data/spec/model/tokenizer_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe OpenNlp::Model::Tokenizer do
+RSpec.describe OpenNlp::Model::Tokenizer do
   let(:model_file_name) { File.join(FIXTURES_DIR, 'en-token.bin') }
 
   it 'accept a string filename parameter' do

data/spec/named_entity_detector_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 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 'initializes with a valid model' do
       expect(ne_detector.j_instance).to be_a(described_class.java_class)

data/spec/parser/parse_spec.rb

@@ -40,66 +40,66 @@ RSpec.describe OpenNlp::Parser::Parse do
     let(:expected_code_tree) do
       [
         {
-          :type => 'S',
-          :parent_type => 'TOP',
-          :token => 'The red fox sleeps soundly .',
-          :children => [
+          type: 'S',
+          parent_type: 'TOP',
+          token: 'The red fox sleeps soundly .',
+          children: [
             {
-              :type => 'NP',
-              :parent_type => 'S',
-              :token => 'The red fox',
-              :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: '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',
-              :children => [
+              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',
-                  :children => [
+                  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: '.' }]
             }
           ]
         }

data/spec/parser_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 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(: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

data/spec/pos_tagger_spec.rb

@@ -21,8 +21,8 @@ RSpec.describe OpenNlp::POSTagger do
     end
 
     it 'tags provided tokens' do
-      tagged = pos_tagger.tag(%w(The quick brown fox jumps over the lazy dog .))
-      expect(tagged.to_ary).to eq(%w(DT JJ JJ NN NNS IN DT JJ NN .))
+      tagged = pos_tagger.tag(%w[The quick brown fox jumps over the lazy dog .])
+      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

data/spec/spec_helper.rb

@@ -3,3 +3,28 @@ require 'java'
 require 'open_nlp'
 
 FIXTURES_DIR = File.join(File.dirname(__FILE__), 'fixtures')
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+
+  config.disable_monkey_patching!
+
+  config.warnings = true
+
+  config.profile_examples = 10
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: open_nlp
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: java
 authors:
 - Hck
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-04-07 00:00:00.000000000 Z
+date: 2018-11-28 00:00:00.000000000 Z
 dependencies: []
 description: JRuby tools wrapper for Apache OpenNLP
 email:
@@ -18,6 +18,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".ruby-version"
 - ".travis.yml"
 - Gemfile
@@ -92,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.4.8
+rubygems_version: 2.7.6
 signing_key:
 specification_version: 4
 summary: A JRuby wrapper for the Apache OpenNLP tools library