picky 1.4.0 → 1.4.1

data/spec/lib/tokenizers/base_spec.rb

@@ -5,68 +5,65 @@ require 'spec_helper'
 describe Tokenizers::Base do
   
   context 'with special instance' do
-    before(:each) do
-      @tokenizer = Tokenizers::Base.new reject_token_if: lambda { |token| token.to_s.length < 2 || token == :hello }
-    end
+    let (:tokenizer) { Tokenizers::Base.new reject_token_if: lambda { |token| token.to_s.length < 2 || token == :hello } }
     it 'rejects tokens with length < 2' do
-      @tokenizer.reject([:'', :a, :ab, :abc]).should == [:ab, :abc]
+      tokenizer.reject([:'', :a, :ab, :abc]).should == [:ab, :abc]
     end
     it 'rejects tokens that are called :hello' do
-      @tokenizer.reject([:hel, :hell, :hello]).should == [:hel, :hell]
+      tokenizer.reject([:hel, :hell, :hello]).should == [:hel, :hell]
     end
   end
   
   context 'with normal instance' do
-    before(:each) do
-      @tokenizer = Tokenizers::Base.new
-    end
+    let(:tokenizer) { Tokenizers::Base.new }
 
     describe 'reject_token_if' do
       it 'rejects empty tokens by default' do
-        @tokenizer.reject(['a', nil, '', 'b']).should == ['a', 'b']
+        tokenizer.reject(['a', nil, '', 'b']).should == ['a', 'b']
       end
       it 'rejects tokens based on the given rejection criteria if set' do
-        @tokenizer.reject_token_if &:nil?
+        tokenizer.reject_token_if &:nil?
 
-        @tokenizer.reject(['a', nil, '', 'b']).should == ['a', '', 'b']
+        tokenizer.reject(['a', nil, '', 'b']).should == ['a', '', 'b']
       end
     end
 
     describe "substitute(s)_characters*" do
       it "doesn't substitute if there is no substituter" do
-        @tokenizer.substitute_characters('abcdefghijklmnopqrstuvwxyzäöü').should == 'abcdefghijklmnopqrstuvwxyzäöü'
+        tokenizer.substitute_characters('abcdefghijklmnopqrstuvwxyzäöü').should == 'abcdefghijklmnopqrstuvwxyzäöü'
       end
       it "uses the substituter to replace characters" do
-        @tokenizer.substitutes_characters_with CharacterSubstituters::WestEuropean.new
+        tokenizer.substitutes_characters_with CharacterSubstituters::WestEuropean.new
 
-        @tokenizer.substitute_characters('abcdefghijklmnopqrstuvwxyzäöü').should == 'abcdefghijklmnopqrstuvwxyzaeoeue'
+        tokenizer.substitute_characters('abcdefghijklmnopqrstuvwxyzäöü').should == 'abcdefghijklmnopqrstuvwxyzaeoeue'
       end
       it "uses the european substituter as default" do
-        @tokenizer.substitutes_characters_with
+        tokenizer.substitutes_characters_with
 
-        @tokenizer.substitute_characters('abcdefghijklmnopqrstuvwxyzäöü').should == 'abcdefghijklmnopqrstuvwxyzaeoeue'
+        tokenizer.substitute_characters('abcdefghijklmnopqrstuvwxyzäöü').should == 'abcdefghijklmnopqrstuvwxyzaeoeue'
       end
     end
 
     describe "removes_characters_after_splitting" do
       context "without removes_characters_after_splitting called" do
         it "has remove_after_normalizing_illegals" do
-          lambda { @tokenizer.remove_after_normalizing_illegals('any') }.should_not raise_error
+          expect { tokenizer.remove_after_normalizing_illegals('any') }.to_not raise_error
         end
         it 'should define a remove_after_normalizing_illegals normalize_with_patterns does nothing' do
           unchanging = stub :unchanging
-          @tokenizer.remove_after_normalizing_illegals unchanging
+          
+          tokenizer.remove_after_normalizing_illegals unchanging
         end
       end
       context "with removes_characters_after_splitting called" do
         before(:each) do
-          @tokenizer.removes_characters_after_splitting(/[afo]/)
+          tokenizer.removes_characters_after_splitting(/[afo]/)
         end
         it "has remove_after_normalizing_illegals" do
-          lambda { @tokenizer.remove_after_normalizing_illegals('abcdefghijklmnop') }.should_not raise_error
+          expect { tokenizer.remove_after_normalizing_illegals('abcdefghijklmnop') }.to_not raise_error
         end
         it "removes illegal characters" do
-          @tokenizer.remove_after_normalizing_illegals('abcdefghijklmnop').should == 'bcdeghijklmnp'
+          tokenizer.remove_after_normalizing_illegals('abcdefghijklmnop').should == 'bcdeghijklmnp'
         end
       end
     end
@@ -74,25 +71,26 @@ describe Tokenizers::Base do
     describe "normalizes_words" do
       context "without normalizes_words called" do
         it "has normalize_with_patterns" do
-          lambda { @tokenizer.normalize_with_patterns('any') }.should_not raise_error
+          expect { tokenizer.normalize_with_patterns('any') }.to_not raise_error
         end
         it 'should define a method normalize_with_patterns does nothing' do
           unchanging = stub :unchanging
-          @tokenizer.normalize_with_patterns(unchanging).should == unchanging
+          
+          tokenizer.normalize_with_patterns(unchanging).should == unchanging
         end
       end
       context "with normalizes_words called" do
         before(:each) do
-          @tokenizer.normalizes_words([
+          tokenizer.normalizes_words([
             [/st\./, 'sankt'],
             [/stras?s?e?/, 'str']
           ])
         end
         it "has normalize_with_patterns" do
-          lambda { @tokenizer.normalize_with_patterns('a b/c.d') }.should_not raise_error
+          expect { tokenizer.normalize_with_patterns('a b/c.d') }.to_not raise_error
         end
         it "normalizes, but just the first one" do
-          @tokenizer.normalize_with_patterns('st. wegstrasse').should == 'sankt wegstrasse'
+          tokenizer.normalize_with_patterns('st. wegstrasse').should == 'sankt wegstrasse'
         end
       end
     end
@@ -100,24 +98,24 @@ describe Tokenizers::Base do
     describe "splits_text_on" do
       context "without splits_text_on called" do
         it "has split" do
-          lambda { @tokenizer.split('any') }.should_not raise_error
+          lambda { tokenizer.split('any') }.should_not raise_error
         end
         it 'should define a method split that splits by default on \s' do
-          @tokenizer.split('a b/c.d').should == ['a', 'b/c.d']
+          tokenizer.split('a b/c.d').should == ['a', 'b/c.d']
         end
         it 'splits text on /\s/ by default' do
-          @tokenizer.split('this is a test').should == ['this', 'is', 'a', 'test']
+          tokenizer.split('this is a test').should == ['this', 'is', 'a', 'test']
         end
       end
       context "with removes_characters called" do
         before(:each) do
-          @tokenizer.splits_text_on(/[\s\.\/]/)
+          tokenizer.splits_text_on(/[\s\.\/]/)
         end
         it "has split" do
-          lambda { @tokenizer.split('a b/c.d') }.should_not raise_error
+          expect { tokenizer.split('a b/c.d') }.to_not raise_error
         end
         it "removes illegal characters" do
-          @tokenizer.split('a b/c.d').should == ['a','b','c','d']
+          tokenizer.split('a b/c.d').should == ['a','b','c','d']
         end
       end
     end
@@ -125,22 +123,23 @@ describe Tokenizers::Base do
     describe "removes_characters" do
       context "without removes_characters called" do
         it "has remove_illegals" do
-          lambda { @tokenizer.remove_illegals('any') }.should_not raise_error
+          expect { tokenizer.remove_illegals('any') }.to_not raise_error
         end
         it 'should define a method remove_illegals that does nothing' do
           unchanging = stub :unchanging
-          @tokenizer.remove_illegals unchanging
+          
+          tokenizer.remove_illegals unchanging
         end
       end
       context "with removes_characters called" do
         before(:each) do
-          @tokenizer.removes_characters(/[afo]/)
+          tokenizer.removes_characters(/[afo]/)
         end
         it "has remove_illegals" do
-          lambda { @tokenizer.remove_illegals('abcdefghijklmnop') }.should_not raise_error
+          expect { tokenizer.remove_illegals('abcdefghijklmnop') }.to_not raise_error
         end
         it "removes illegal characters" do
-          @tokenizer.remove_illegals('abcdefghijklmnop').should == 'bcdeghijklmnp'
+          tokenizer.remove_illegals('abcdefghijklmnop').should == 'bcdeghijklmnp'
         end
       end
     end
@@ -148,45 +147,44 @@ describe Tokenizers::Base do
     describe 'stopwords' do
       context 'without stopwords given' do
         it 'should define a method remove_stopwords' do
-          lambda { @tokenizer.remove_stopwords('from this text') }.should_not raise_error
+          lambda { tokenizer.remove_stopwords('from this text') }.should_not raise_error
         end
         it 'should define a method remove_stopwords that does nothing' do
-          @tokenizer.remove_stopwords('from this text').should == 'from this text'
+          tokenizer.remove_stopwords('from this text').should == 'from this text'
         end
         it 'should define a method remove_non_single_stopwords' do
-          lambda { @tokenizer.remove_non_single_stopwords('from this text') }.should_not raise_error
-
+          expect { tokenizer.remove_non_single_stopwords('from this text') }.to_not raise_error
         end
       end
       context 'with stopwords given' do
         before(:each) do
-          @tokenizer.stopwords(/r|e/)
+          tokenizer.stopwords(/r|e/)
         end
         it 'should define a method remove_stopwords' do
-          lambda { @tokenizer.remove_stopwords('from this text') }.should_not raise_error
+          lambda { tokenizer.remove_stopwords('from this text') }.should_not raise_error
         end
         it 'should define a method stopwords that removes stopwords' do
-          @tokenizer.remove_stopwords('from this text').should == 'fom this txt'
+          tokenizer.remove_stopwords('from this text').should == 'fom this txt'
         end
         it 'should define a method remove_non_single_stopwords' do
-          lambda { @tokenizer.remove_non_single_stopwords('from this text') }.should_not raise_error
+          expect { tokenizer.remove_non_single_stopwords('from this text') }.to_not raise_error
         end
         it 'should define a method remove_non_single_stopwords that removes non-single stopwords' do
-          @tokenizer.remove_non_single_stopwords('rerere rerere').should == ' '
+          tokenizer.remove_non_single_stopwords('rerere rerere').should == ' '
         end
         it 'should define a method remove_non_single_stopwords that does not single stopwords' do
-          @tokenizer.remove_non_single_stopwords('rerere').should == 'rerere'
+          tokenizer.remove_non_single_stopwords('rerere').should == 'rerere'
         end
       end
       context 'error case' do
         before(:each) do
-          @tokenizer.stopwords(/any/)
+          tokenizer.stopwords(/any/)
         end
         it 'should not remove non-single stopwords with a star' do
-          @tokenizer.remove_non_single_stopwords('a*').should == 'a*'
+          tokenizer.remove_non_single_stopwords('a*').should == 'a*'
         end
         it 'should not remove non-single stopwords with a tilde' do
-          @tokenizer.remove_non_single_stopwords('a~').should == 'a~'
+          tokenizer.remove_non_single_stopwords('a~').should == 'a~'
         end
       end
     end

data/spec/lib/tokenizers/index_spec.rb

@@ -4,9 +4,7 @@ require 'spec_helper'
 
 describe Tokenizers::Index do
   
-  before(:each) do
-    @tokenizer = Tokenizers::Index.new
-  end
+  let(:tokenizer) { Tokenizers::Index.new }
   
   describe "default*" do
     before(:all) do
@@ -33,13 +31,13 @@ describe Tokenizers::Index do
   
   describe "remove_removes_characters" do
     it "should not remove ' from a query by default" do
-      @tokenizer.remove_illegals("Lugi's").should == "Lugi's"
+      tokenizer.remove_illegals("Lugi's").should == "Lugi's"
     end
   end
 
   describe "reject!" do
     it "should reject tokens if blank" do
-      @tokenizer.reject(['', 'not blank', '']).should == ['not blank']
+      tokenizer.reject(['', 'not blank', '']).should == ['not blank']
     end
   end
   
@@ -47,7 +45,7 @@ describe Tokenizers::Index do
     describe "normalizing" do
       def self.it_should_normalize_token(text, expected)
         it "should handle the #{text} case" do
-          @tokenizer.tokenize(text).to_a.should == [expected].compact
+          tokenizer.tokenize(text).to_a.should == [expected].compact
         end
       end
       # defaults
@@ -57,7 +55,7 @@ describe Tokenizers::Index do
     describe "tokenizing" do
       def self.it_should_tokenize_token(text, expected)
         it "should handle the #{text} case" do
-          @tokenizer.tokenize(text).to_a.should == expected
+          tokenizer.tokenize(text).to_a.should == expected
         end
       end
       # defaults

data/spec/lib/tokenizers/query_spec.rb

@@ -3,9 +3,7 @@ require 'spec_helper'
 
 describe Tokenizers::Query do
 
-  before(:each) do
-    @tokenizer = Tokenizers::Query.new
-  end
+  let(:tokenizer) { Tokenizers::Query.new }
   
   describe "default*" do
     before(:all) do
@@ -32,7 +30,7 @@ describe Tokenizers::Query do
   
   describe "maximum_tokens" do
     it "should be set to 5 by default" do
-      @tokenizer.maximum_tokens.should == 5
+      tokenizer.maximum_tokens.should == 5
     end
     it "should be settable" do
       Tokenizers::Query.new(maximum_tokens: 3).maximum_tokens.should == 3
@@ -43,15 +41,15 @@ describe Tokenizers::Query do
     it 'should call methods in order' do
       text = stub :text
       
-      @tokenizer.should_receive(:remove_illegals).once.ordered.with text
-      @tokenizer.should_receive(:remove_non_single_stopwords).once.ordered.with text
+      tokenizer.should_receive(:remove_illegals).once.ordered.with text
+      tokenizer.should_receive(:remove_non_single_stopwords).once.ordered.with text
       
-      @tokenizer.preprocess text
+      tokenizer.preprocess text
     end
     it 'should return the text unchanged by default' do
       text = "some text"
       
-      @tokenizer.preprocess(text).should == text
+      tokenizer.preprocess(text).should == text
     end
   end
   
@@ -60,9 +58,9 @@ describe Tokenizers::Query do
       @tokens = mock :tokens, :null_object => true
     end
     it 'should tokenize the tokens' do
-      @tokens.should_receive(:tokenize_with).once.with @tokenizer
+      @tokens.should_receive(:tokenize_with).once.with tokenizer
 
-      @tokenizer.process @tokens
+      tokenizer.process @tokens
     end
     it 'should call methods on the tokens in order' do
       @tokens.should_receive(:tokenize_with).once.ordered
@@ -70,17 +68,17 @@ describe Tokenizers::Query do
       @tokens.should_receive(:cap).once.ordered
       @tokens.should_receive(:partialize_last).once.ordered
 
-      @tokenizer.process @tokens
+      tokenizer.process @tokens
     end
     it 'should return the tokens' do
-      @tokenizer.process(@tokens).should == @tokens
+      tokenizer.process(@tokens).should == @tokens
     end
   end
 
   describe 'pretokenize' do
     def self.it_should_pretokenize text, expected
       it "should pretokenize #{text} as #{expected}" do
-        @tokenizer.pretokenize(text).should == expected
+        tokenizer.pretokenize(text).should == expected
       end
     end
     it_should_pretokenize 'test miau test', ['test', 'miau', 'test']
@@ -89,7 +87,7 @@ describe Tokenizers::Query do
   describe "tokenizing" do
     def self.it_should_tokenize_token(text, expected)
       it "should handle the #{text} case" do
-        @tokenizer.tokenize(text).map(&:text).should == expected
+        tokenizer.tokenize(text).map(&:text).should == expected
       end
     end
     it_should_tokenize_token 'simple tokenizing on \s', [:simple, :tokenizing, :on, :'\s']
@@ -98,7 +96,7 @@ describe Tokenizers::Query do
   describe 'normalize_with_patterns' do
     def self.it_should_pattern_normalize original, expected
       it "should normalize #{original} with pattern into #{expected}" do
-        @tokenizer.normalize_with_patterns(original).should == expected
+        tokenizer.normalize_with_patterns(original).should == expected
       end
     end
     it_should_pattern_normalize 'no pattern normalization', 'no pattern normalization'
@@ -106,22 +104,22 @@ describe Tokenizers::Query do
   
   describe 'reject' do
     it 'should reject blank tokens' do
-      @tokenizer.reject(["some token answering to blank?", nil, nil]).should == ["some token answering to blank?"]
+      tokenizer.reject(["some token answering to blank?", nil, nil]).should == ["some token answering to blank?"]
     end
   end
   
   describe "last token" do
     it "should be partial" do
-      @tokenizer.tokenize("First Second Third Last").last.instance_variable_get(:@partial).should be_true
+      tokenizer.tokenize("First Second Third Last").last.instance_variable_get(:@partial).should be_true
     end
   end
   
   describe ".tokenize" do
     it "should return an Array of tokens" do
-      @tokenizer.tokenize('test test').to_a.should be_instance_of(Array)
+      tokenizer.tokenize('test test').to_a.should be_instance_of(Array)
     end
     it "should return an empty tokenized query if the query string is blank or empty" do
-      @tokenizer.tokenize('').map(&:to_s).should == []
+      tokenizer.tokenize('').map(&:to_s).should == []
     end
   end
   describe "token_for" do
@@ -129,7 +127,7 @@ describe Tokenizers::Query do
       text = stub(:text)
       Query::Token.should_receive(:processed).with text
       
-      @tokenizer.token_for text
+      tokenizer.token_for text
     end
   end
   

metadata

@@ -2,7 +2,7 @@
 name: picky
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors: 
 - Florian Hanke