mongoid_search 0.3.2 → 0.4.0

data/lib/mongoid_search/railtie.rb

@@ -1,10 +1,7 @@
-require 'mongoid_search'
-require 'rails'
-
 module Mongoid::Search
   class Railtie < Rails::Railtie
     rake_tasks do
-      Dir[File.join(File.dirname(__FILE__), '../../tasks/*.rake')].each { |f| load f }
+      Dir[File.join(File.dirname(__FILE__), 'tasks/*.rake')].each { |f| load f }
     end
   end
-end
+end

data/lib/mongoid_search/tasks/mongoid_search.rake

@@ -0,0 +1,16 @@
+namespace :mongoid_search do
+  desc 'Goes through all documents with search enabled and indexes the keywords.'
+  task index: :environment do
+    ::Rails.application.eager_load!
+    if Mongoid::Search.classes.blank?
+      Mongoid::Search::Log.log "No model to index keywords.\n"
+    else
+      Mongoid::Search.classes.each do |klass|
+        Mongoid::Search::Log.silent = ENV['SILENT']
+        Mongoid::Search::Log.log "\nIndexing documents for #{klass.name}:\n"
+        klass.index_keywords!
+      end
+      Mongoid::Search::Log.log "\n\nDone.\n"
+    end
+  end
+end

data/lib/mongoid_search/util.rb

@@ -1,28 +1,28 @@
-# encoding: utf-8
+
 module Mongoid::Search::Util
   def self.keywords(klass, fields)
     if fields.is_a?(Array)
       fields.map do |field|
-        self.keywords(klass, field)
+        keywords(klass, field)
       end
     elsif fields.is_a?(Hash)
       fields.keys.map do |field|
         attribute = klass.send(field)
         unless attribute.blank?
           if attribute.is_a?(Array)
-            attribute.map{ |a| self.keywords(a, fields[field]) }
+            attribute.map { |a| keywords(a, fields[field]) }
           else
-            self.keywords(attribute, fields[field])
+            keywords(attribute, fields[field])
           end
         end
       end
     else
-      value = if klass.respond_to?(fields.to_s + "_translations")
-                klass.send(fields.to_s + "_translations").values
+      value = if klass.respond_to?(fields.to_s + '_translations')
+                klass.send(fields.to_s + '_translations').values
               elsif klass.respond_to?(fields)
                 klass.send(fields)
               else
-                value = klass[fields];
+                value = klass[fields]
               end
       value = value.join(' ') if value.respond_to?(:join)
       normalize_keywords(value) if value
@@ -34,21 +34,22 @@ module Mongoid::Search::Util
     ignore_list   = Mongoid::Search.ignore_list
     stem_keywords = Mongoid::Search.stem_keywords
     stem_proc     = Mongoid::Search.stem_proc
+    strip_symbols = Mongoid::Search.strip_symbols
+    strip_accents = Mongoid::Search.strip_accents
 
     return [] if text.blank?
-    text = text.to_s.
-      mb_chars.
-      normalize(:kd).
-      downcase.
-      to_s.
-      gsub(/[._:;'"`,?|+={}()!@#%^&*<>~\$\-\\\/\[\]]/, ' '). # strip punctuation
-      gsub(/[^[:alnum:]\s]/,'').   # strip accents
-      gsub(/[#{ligatures.keys.join("")}]/) {|c| ligatures[c]}.
-      split(' ').
-      reject { |word| word.size < Mongoid::Search.minimum_word_size }
+    text = text.to_s
+               .mb_chars
+               .unicode_normalize(:nfkd)
+               .downcase
+               .to_s
+               .gsub(strip_symbols, ' ') # strip symbols
+               .gsub(strip_accents, '')  # strip accents
+               .gsub(/[#{ligatures.keys.join("")}]/) { |c| ligatures[c] }
+               .split(' ')
+               .reject { |word| word.size < Mongoid::Search.minimum_word_size }
     text = text.reject { |word| ignore_list.include?(word) } unless ignore_list.blank?
     text = text.map(&stem_proc) if stem_keywords
     text
   end
-
 end

data/spec/models/category.rb

@@ -1,5 +1,7 @@
 class Category
   include Mongoid::Document
+  include Mongoid::Attributes::Dynamic if ::Mongoid::VERSION >= '4'
+
   field :name, localize: true
   field :description
 

data/spec/models/product.rb

@@ -1,15 +1,24 @@
 class Product
   include Mongoid::Document
   include Mongoid::Search
+  include Mongoid::Attributes::Dynamic if ::Mongoid::VERSION >= '4'
+
   field :brand
   field :name
-  field :attrs, :type => Array
-  field :info, :type => Hash
+  field :unit
+  field :measures, type: Array
+  field :attrs, type: Array
+  field :info, type: Hash
 
-  has_many    :tags
-  belongs_to  :category
+  has_many :tags
+  if Mongoid::Compatibility::Version.mongoid6_or_newer?
+    belongs_to  :category, required: false
+  else
+    belongs_to  :category
+  end
   embeds_many :subproducts
 
-  search_in :brand, :name, :outlet, :attrs, :tags => :name, :category => [:name, :description],
-            :subproducts => [:brand, :name], :info => [ :summary, :description ]
+  search_in :brand, :name, :outlet, :attrs, tags: :name, category: %i[name description],
+                                            subproducts: %i[brand name], info: %i[summary description]
+  search_in :unit, :measures, index: :_unit_keywords
 end

data/spec/models/subproduct.rb

@@ -1,8 +1,9 @@
 class Subproduct
   include Mongoid::Document
+  include Mongoid::Attributes::Dynamic if ::Mongoid::VERSION >= '4'
 
   field :brand
   field :name
 
-  belongs_to :product, :inverse_of => :subproducts
+  embedded_in :product, inverse_of: :subproducts
 end

data/spec/models/tag.rb

@@ -1,14 +1,15 @@
 class Tag
   include Mongoid::Document
   include Mongoid::Search
+  include Mongoid::Attributes::Dynamic if ::Mongoid::VERSION >= '4'
 
   field :name
 
   belongs_to :product
 
   def title
-      self.name
+    name
   end
 
-  search_in :title, :product => [:name, { :info => [ :summary, :description ], :category => [:name, :description]}]
+  search_in :title, product: [:name, { info: %i[summary description], category: %i[name description] }]
 end

data/spec/models/variant.rb

@@ -1,5 +1,7 @@
-autoload :Product, "models/product.rb"
+autoload :Product, 'models/product.rb'
 class Variant < Product
   field :color
+  field :size
   search_in :color
+  search_in :size, index: :_unit_keywords
 end

data/spec/mongoid_search_spec.rb

@@ -1,11 +1,10 @@
-# encoding: utf-8
-
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe Mongoid::Search do
-
   before(:all) do
     @default_proc = Mongoid::Search.stem_proc
+    @default_strip_symbols = Mongoid::Search.strip_symbols
+    @default_strip_accents = Mongoid::Search.strip_accents
   end
 
   after(:all) do
@@ -17,257 +16,356 @@ describe Mongoid::Search do
     Mongoid::Search.stem_keywords = false
     Mongoid::Search.ignore_list   = nil
     Mongoid::Search.stem_proc     = @default_proc
-    @product = Product.create :brand => "Apple",
-                              :name => "iPhone",
-                              :tags => (@tags = ["Amazing", "Awesome", "Olé"].map { |tag| Tag.new(:name => tag) }),
-                              :category => Category.new(:name => "Mobile", :description => "Reviews"),
-                              :subproducts => [Subproduct.new(:brand => "Apple", :name => "Craddle")],
-                              :info => { :summary => "Info-summary",
-                                         :description => "Info-description"}
-  end
-
-  describe "Serialized hash fields" do
-    context "when the hash is populated" do
-      it "should return the product" do
-        Product.full_text_search("Info-summary").first.should eq @product
-        Product.full_text_search("Info-description").first.should eq @product
+    @product = Product.create brand: 'Apple',
+                              name: 'iPhone',
+                              unit: 'mobile olé awesome',
+                              tags: (@tags = %w[Amazing Awesome Olé].map { |tag| Tag.new(name: tag) }),
+                              category: Category.new(name: 'Mobile', description: 'Reviews'),
+                              subproducts: [Subproduct.new(brand: 'Apple', name: 'Craddle')],
+                              info: { summary: 'Info-summary',
+                                      description: 'Info-description' }
+  end
+
+  describe 'Serialized hash fields' do
+    context 'when the hash is populated' do
+      it 'should return the product' do
+        expect(Product.full_text_search('Info-summary').first).to eq @product
+        expect(Product.full_text_search('Info-description').first).to eq @product
       end
     end
 
-    context "when the hash is empty" do
+    context 'when the hash is empty' do
       before(:each) do
         @product.info = nil
         @product.save
       end
 
-      it "should not return the product" do
-        Product.full_text_search("Info-description").size.should eq 0
-        Product.full_text_search("Info-summary").size.should eq 0
+      it 'should not return the product' do
+        expect(Product.full_text_search('Info-description').size).to eq 0
+        expect(Product.full_text_search('Info-summary').size).to eq 0
       end
     end
   end
 
-  context "utf-8 characters" do
+  context 'utf-8 characters' do
     before do
       Mongoid::Search.stem_keywords = false
       Mongoid::Search.ignore_list   = nil
-      @product = Product.create :brand => "Эльбрус",
-                                :name => "Процессор",
-                                :tags => ["Amazing", "Awesome", "Olé"].map { |tag| Tag.new(:name => tag) },
-                                :category => Category.new(:name => "процессоры"),
-                                :subproducts => []
+      @product = Product.create brand: 'Эльбрус',
+                                name: 'Процессор',
+                                unit: 'kílográm Olé',
+                                tags: %w[Amazing Awesome Olé].map { |tag| Tag.new(name: tag) },
+                                category: Category.new(name: 'процессоры'),
+                                subproducts: []
     end
 
-    it "should leave utf8 characters" do
-      @product._keywords.should == ["amazing", "awesome", "ole", "процессор", "процессоры", "эльбрус"]
+    it 'should leave utf8 characters' do
+      expect(@product._keywords).to eq %w[amazing awesome ole процессор процессоры эльбрус]
+      expect(@product._unit_keywords).to eq %w[kilogram ole]
     end
 
     it "should return results in search when case doesn't match" do
-      Product.full_text_search("ЭЛЬБРУС").size.should == 1
+      expect(Product.full_text_search('ЭЛЬБРУС').size).to eq 1
+      expect(Product.full_text_search('KILOGRAM', index: :_unit_keywords).size).to eq 1
     end
   end
 
-  context "when references are nil" do
-    context "when instance is being created" do
-      it "should not complain about method missing" do
-        lambda { Product.create! }.should_not raise_error
+  context 'when references are nil' do
+    context 'when instance is being created' do
+      it 'should not complain about method missing' do
+        expect { Product.create! }.not_to raise_error
       end
     end
 
-    subject { Product.create :brand => "Apple", :name => "iPhone" }
-
-    its(:_keywords) { should == ["apple", "iphone"] }
+    it 'should validate keywords' do
+      product = Product.create brand: 'Apple', name: 'iPhone', unit: 'box'
+      expect(product._keywords).to eq(%w[apple iphone])
+      expect(product._unit_keywords).to eq(%w[box])
+    end
   end
 
-
-  it "should set the _keywords field for array fields also" do
+  it 'should set the _keywords field for array fields also' do
     @product.attrs = ['lightweight', 'plastic', :red]
+    @product.measures = ['box', 'bunch', :bag]
     @product.save!
-    @product._keywords.should include 'lightweight', 'plastic', 'red'
+    expect(@product._keywords).to include 'lightweight', 'plastic', 'red'
+    expect(@product._unit_keywords).to include 'box', 'bunch', 'bag'
   end
 
-  it "should inherit _keywords field and build upon" do
-    variant = Variant.create :brand => "Apple",
-                              :name => "iPhone",
-                              :tags => ["Amazing", "Awesome", "Olé"].map { |tag| Tag.new(:name => tag) },
-                              :category => Category.new(:name => "Mobile"),
-                              :subproducts => [Subproduct.new(:brand => "Apple", :name => "Craddle")],
-                              :color => :white
-    variant._keywords.should include 'white'
-    Variant.full_text_search(:name => 'Apple', :color => :white).should eq [variant]
+  it 'should inherit _keywords field and build upon' do
+    variant = Variant.create brand: 'Apple',
+                             name: 'iPhone',
+                             tags: %w[Amazing Awesome Olé].map { |tag| Tag.new(name: tag) },
+                             category: Category.new(name: 'Mobile'),
+                             subproducts: [Subproduct.new(brand: 'Apple', name: 'Craddle')],
+                             color: :white,
+                             size: :big
+    expect(variant._keywords).to include 'white'
+    expect(variant._unit_keywords).to include 'big'
+    expect(Variant.full_text_search(name: 'Apple', color: :white)).to eq [variant]
+    expect(Variant.full_text_search({ size: 'big' }, index: :_unit_keywords)).to eq [variant]
   end
 
-  it "should expand the ligature to ease searching" do
+  it 'should expand the ligature to ease searching' do
     # ref: http://en.wikipedia.org/wiki/Typographic_ligature, only for french right now. Rules for other languages are not know
-    variant1 = Variant.create :tags => ["œuvre"].map {|tag| Tag.new(:name => tag)}
-    variant2 = Variant.create :tags => ["æquo"].map {|tag| Tag.new(:name => tag)}
+    variant1 = Variant.create tags: ['œuvre'].map { |tag| Tag.new(name: tag) }
+    variant2 = Variant.create tags: ['æquo'].map { |tag| Tag.new(name: tag) }
+    variant3 = Variant.create measures: ['ꜵquo'].map { |measure| measure }
 
-    Variant.full_text_search("œuvre").should eq [variant1]
-    Variant.full_text_search("oeuvre").should eq [variant1]
-    Variant.full_text_search("æquo").should eq [variant2]
-    Variant.full_text_search("aequo").should eq [variant2]
+    expect(Variant.full_text_search('œuvre')).to eq [variant1]
+    expect(Variant.full_text_search('oeuvre')).to eq [variant1]
+    expect(Variant.full_text_search('æquo')).to eq [variant2]
+    expect(Variant.full_text_search('aequo')).to eq [variant2]
+    expect(Variant.full_text_search('aoquo', index: :_unit_keywords)).to eq [variant3]
+    expect(Variant.full_text_search('ꜵquo', index: :_unit_keywords)).to eq [variant3]
   end
 
-  it "should set the _keywords field with stemmed words if stem is enabled" do
+  it 'should set the keywords fields with stemmed words if stem is enabled' do
     Mongoid::Search.stem_keywords = true
     @product.save!
-    @product._keywords.sort.should == ["amaz", "appl", "awesom", "craddl", "iphon", "mobil", "review", "ol", "info", "descript", "summari"].sort
+    expect(@product._keywords.sort).to eq %w[amaz appl awesom craddl iphon mobil review ol info descript summari].sort
+    expect(@product._unit_keywords.sort).to eq %w[mobil awesom ol].sort
   end
 
-  it "should set the _keywords field with custom stemmed words if stem is enabled with a custom lambda" do
+  it 'should set the keywords fields with custom stemmed words if stem is enabled with a custom lambda' do
     Mongoid::Search.stem_keywords = true
-    Mongoid::Search.stem_proc     = Proc.new { |word| word.upcase }
+    Mongoid::Search.stem_proc     = proc { |word| word.upcase }
     @product.save!
-    @product._keywords.sort.should == ["AMAZING", "APPLE", "AWESOME", "CRADDLE", "DESCRIPTION", "INFO", "IPHONE", "MOBILE", "OLE", "REVIEWS", "SUMMARY"]
+    expect(@product._keywords.sort).to eq %w[AMAZING APPLE AWESOME CRADDLE DESCRIPTION INFO IPHONE MOBILE OLE REVIEWS SUMMARY]
+    expect(@product._unit_keywords.sort).to eq %w[AWESOME MOBILE OLE]
   end
 
-  it "should ignore keywords in an ignore list" do
-    Mongoid::Search.ignore_list = YAML.load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))["ignorelist"]
+  it 'should ignore keywords in an ignore list' do
+    Mongoid::Search.ignore_list = YAML.safe_load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))['ignorelist']
     @product.save!
-    @product._keywords.sort.should == ["apple", "craddle", "iphone", "mobile", "reviews", "ole", "info", "description", "summary"].sort
+    expect(@product._keywords.sort).to eq %w[apple craddle iphone mobile reviews ole info description summary].sort
+    expect(@product._unit_keywords.sort).to eq %w[mobile ole].sort
   end
 
-   it "should incorporate numbers as keywords" do
-        @product = Product.create :brand => "Ford",
-                              :name => "T 1908",
-                              :tags => ["Amazing", "First", "Car"].map { |tag| Tag.new(:name => tag) },
-                              :category => Category.new(:name => "Vehicle")
+  it 'should incorporate numbers as keywords' do
+    @product = Product.create brand: 'Ford',
+                              name: 'T 1908',
+                              tags: %w[Amazing First Car].map { |tag| Tag.new(name: tag) },
+                              category: Category.new(name: 'Vehicle')
 
-      @product.save!
-      @product._keywords.should == ["1908", "amazing", "car", "first", "ford",  "vehicle"]
-   end
+    @product.save!
+    expect(@product._keywords).to eq %w[1908 amazing car first ford vehicle]
+  end
 
-  it "should return results in search" do
-    Product.full_text_search("apple").size.should == 1
+  it 'should return results in search' do
+    expect(Product.full_text_search('apple').size).to eq 1
   end
 
-  it "should return results in search for dynamic attribute" do
-    @product[:outlet] = "online shop"
+  it 'should return results in search for dynamic attribute' do
+    @product[:outlet] = 'online shop'
     @product.save!
-    Product.full_text_search("online").size.should == 1
+    expect(Product.full_text_search('online').size).to eq 1
   end
 
-  it "should return results in search even searching a accented word" do
-    Product.full_text_search("Ole").size.should == 1
-    Product.full_text_search("Olé").size.should == 1
+  it 'should return results in search even searching a accented word' do
+    expect(Product.full_text_search('Ole').size).to eq 1
+    expect(Product.full_text_search('Olé').size).to eq 1
   end
 
   it "should return results in search even if the case doesn't match" do
-    Product.full_text_search("oLe").size.should == 1
+    expect(Product.full_text_search('oLe').size).to eq 1
   end
 
-  it "should return results in search with a partial word by default" do
-    Product.full_text_search("iph").size.should == 1
+  it 'should return results in search with a partial word by default' do
+    expect(Product.full_text_search('iph').size).to eq 1
   end
 
-  it "should return results for any matching word with default search" do
-    Product.full_text_search("apple motorola").size.should == 1
+  it 'should return results for any matching word with default search' do
+    expect(Product.full_text_search('apple motorola').size).to eq 1
   end
 
-  it "should not return results when all words do not match, if using :match => :all" do
+  it 'should not return results when all words do not match, if using :match => :all' do
     Mongoid::Search.match = :all
-    Product.full_text_search("apple motorola").size.should == 0
+    expect(Product.full_text_search('apple motorola').size).to eq 0
   end
 
-  it "should return results for any matching word, using :match => :all, passing :match => :any to .full_text_search" do
+  it 'should return results for any matching word, using :match => :all, passing :match => :any to .full_text_search' do
     Mongoid::Search.match = :all
-    Product.full_text_search("apple motorola", :match => :any).size.should == 1
+    expect(Product.full_text_search('apple motorola', match: :any).size).to eq 1
   end
 
-  it "should not return results when all words do not match, passing :match => :all to .full_text_search" do
-    Product.full_text_search("apple motorola", :match => :all).size.should == 0
+  it 'should not return results when all words do not match, passing :match => :all to .full_text_search' do
+    expect(Product.full_text_search('apple motorola', match: :all).size).to eq 0
   end
 
-  it "should return no results when a blank search is made" do
+  it 'should return no results when a blank search is made' do
     Mongoid::Search.allow_empty_search = false
-    Product.full_text_search("").size.should == 0
+    expect(Product.full_text_search('').size).to eq 0
   end
 
-  it "should return results when a blank search is made when :allow_empty_search is true" do
+  it 'should return results when a blank search is made when :allow_empty_search is true' do
     Mongoid::Search.allow_empty_search = true
-    Product.full_text_search("").size.should == 1
+    expect(Product.full_text_search('').size).to eq 1
   end
 
-  it "should search for embedded documents" do
-    Product.full_text_search("craddle").size.should == 1
+  it 'should search for embedded documents' do
+    expect(Product.full_text_search('craddle').size).to eq 1
   end
 
-  it "should search for reference documents" do
-    Product.full_text_search("reviews").size.should == 1
+  it 'should search for reference documents' do
+    expect(Product.full_text_search('reviews').size).to eq 1
   end
 
   it 'should work in a chainable fashion' do
-    @product.category.products.where(:brand => 'Apple').full_text_search('apple').size.should == 1
-    @product.category.products.full_text_search('craddle').where(:brand => 'Apple').size.should == 1
+    expect(@product.category.products.where(brand: 'Apple').full_text_search('apple').size).to eq 1
+    expect(@product.category.products.full_text_search('craddle').where(brand: 'Apple').size).to eq 1
   end
 
   it 'should return the classes that include the search module' do
-    Mongoid::Search.classes.should == [Product, Tag]
+    expect(Mongoid::Search.classes.sort_by(&:name)).to eq [Product, Tag]
   end
 
   it 'should have a method to index keywords' do
-    @product.index_keywords!.should == true
+    expect(@product.index_keywords!).to include(true)
   end
 
   it 'should have a class method to index all documents keywords' do
-    Product.index_keywords!.should_not include(false)
+    expect(Product.index_keywords!).not_to include(false)
   end
 
-  context "when regex search is false" do
+  context 'when regex search is false' do
     before do
       Mongoid::Search.regex_search = false
     end
 
-    it "should not return results in search with a partial word if not using regex search" do
-      Product.full_text_search("iph").size.should == 0
+    it 'should not return results in search with a partial word if not using regex search' do
+      expect(Product.full_text_search('iph').size).to eq 0
     end
 
-    it "should return results in search with a full word if not using regex search" do
-      Product.full_text_search("iphone").size.should == 1
+    it 'should return results in search with a full word if not using regex search' do
+      expect(Product.full_text_search('iphone').size).to eq 1
     end
   end
 
-  context "relevant search" do
+  context 'when regex search is true' do
+    before do
+      Mongoid::Search.regex_search = true
+    end
+
+    after do
+      Mongoid::Search.regex_search = false
+    end
+
+    it 'should not return results in search with a partial word if using regex search' do
+      expect(Product.full_text_search('iph').size).to eq 1
+    end
+
+    it 'should return results in search with a full word if using regex search' do
+      expect(Product.full_text_search('iphone').size).to eq 1
+    end
+
+    context 'when query include special characters that should not be stripped' do
+      before do
+        Mongoid::Search.strip_symbols = /[\n]/
+        Mongoid::Search.strip_accents = /[^\s\p{Graph}]/
+      end
+
+      after do
+        Mongoid::Search.strip_symbols = @default_strip_symbols
+        Mongoid::Search.strip_accents = @default_strip_accents
+      end
+
+      it 'should escape regex special characters' do
+        expect(Product.full_text_search('iphone (steve').size).to eq 1
+      end
+    end
+
+    context 'Match partial words on the beginning' do
+      before do
+        Mongoid::Search.regex = proc { |query| /^#{query}/ }
+      end
+
+      it 'should return results in search which starts with query string' do
+        expect(Product.full_text_search('iphone').size).to eq 1
+      end
+
+      it 'should not return results in search which does not start with query string' do
+        expect(Product.full_text_search('phone').size).to eq 0
+      end
+    end
+
+    context 'Match partial words on the end' do
+      before do
+        Mongoid::Search.regex = proc { |query| /#{query}$/ }
+      end
+
+      it 'should return results in search which ends with query string' do
+        expect(Product.full_text_search('phone').size).to eq 1
+      end
+
+      it 'should not return results in search which does not end with query string' do
+        expect(Product.full_text_search('phon').size).to eq 0
+      end
+    end
+  end
+
+  context 'relevant search' do
     before do
       Mongoid::Search.relevant_search = true
-      @imac = Product.create :name => 'apple imac'
+      @imac = Product.create name: 'apple imac'
+    end
+
+    it 'should return results ordered by relevance and with correct ids' do
+      expect(Product.full_text_search('apple imac').map(&:_id)).to eq [@imac._id, @product._id]
     end
 
-    it "should return results ordered by relevance and with correct ids" do
-      Product.full_text_search('apple imac').map(&:_id).should == [@imac._id, @product._id]
+    it 'results should be recognized as persisted objects' do
+      expect(Product.full_text_search('apple imac').map(&:persisted?)).not_to include false
     end
 
-    it "results should be recognized as persisted objects" do
-      Product.full_text_search('apple imac').map(&:persisted?).should_not include false
+    it 'should include relevance information' do
+      expect(Product.full_text_search('apple imac').map(&:relevance)).to eq [2, 1]
     end
+  end
 
-    it "should include relevance information" do
-      Product.full_text_search('apple imac').map(&:relevance).should == [2, 1]
+  context 'when using methods for keywords' do
+    it 'should set the _keywords from methods' do
+      expect(@tags.first._keywords).to include 'amazing'
     end
   end
 
-  context "when using methods for keywords" do
-    it "should set the _keywords from methods" do
-      @tags.first._keywords.should include "amazing"
+  context 'when using deeply nested fields for keywords' do
+    context 'when explicitly calling set_keywords' do
+      it 'should set the _keywords from parent' do
+        @tags.first.send(:set_keywords)
+        expect(@tags.first._keywords).to eq %w[amazing description info iphone mobile reviews summary]
+      end
     end
   end
 
-  context "when using deeply nested fields for keywords" do
-    context "when explicitly calling set_keywords" do
-        it "should set the _keywords from parent" do
-          @tags.first.send(:set_keywords)
-          @tags.first._keywords.should == ["amazing", "description", "info", "iphone", "mobile", "reviews", "summary"]
-        end
+  context 'when using localized fields' do
+    it 'should set the keywords from all localizations' do
+      @product = Product.create brand: 'Ford',
+                                name: 'T 1908',
+                                tags: %w[Amazing First Car].map { |tag| Tag.new(name: tag) },
+                                category: Category.new(name_translations: { en: 'Vehicle', de: 'Fahrzeug' })
+      expect(@product._keywords).to include('fahrzeug')
     end
   end
 
-  context "when using localized fields" do
-    it "should set the keywords from all localizations" do
-      @product = Product.create :brand => "Ford",
-                            :name => "T 1908",
-                            :tags => ["Amazing", "First", "Car"].map { |tag| Tag.new(:name => tag) },
-                            :category => Category.new(:name_translations => { :en => "Vehicle", :de => "Fahrzeug" })
-      @product._keywords.should include("fahrzeug")
+  context 'minimum word size' do
+    before(:each) do
+      Mongoid::Search.minimum_word_size = 3
+    end
+
+    after(:each) do
+      Mongoid::Search.minimum_word_size = 2
+    end
+
+    it 'should ignore keywords with length less than minimum word size' do
+      @product = Product.create name: 'a'
+      expect(@product._keywords.size).to eq 0
+
+      @product = Product.create name: 'ap'
+      expect(@product._keywords.size).to eq 0
+
+      @product = Product.create name: 'app'
+      expect(@product._keywords.size).to eq 1
     end
   end
 end