mongoid_search 0.3.2 → 0.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eaeb19566825291c03bd018b9013d0c06a8b01c4
+  data.tar.gz: 2b930fec009de9031350c4b7fbc658c928224eed
+SHA512:
+  metadata.gz: 3111148a9311c26712eb3bbbccf7ec3c8c8d1db7283ac3e8435244558a16d157cdc22e039715bef5192234dc1a1ca80308d2a3805f7a8479eb27d8de4f689b92
+  data.tar.gz: 9ed30923429cba88f73916057671a598ecc0589ea67016817b74ffb68b4721ded77c58c07af285914dcad92998c70b69c5a5f64d81fc53670a15ef73c6e3e9f4

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Mauricio Zaffari
+Copyright (c) 2009 Mauricio Zaffari, 2013 Semenyuk Dmitriy (additions)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -26,11 +26,12 @@ Examples
       include Mongoid::Search
       field :brand
       field :name
+      field :info, :type => Hash
 
       has_many   :tags
       belongs_to :category
 
-      search_in :brand, :name, :tags => :name, :category => :name
+      search_in :brand, :name, :tags => :name, :category => :name, :info => [:summary, :description]
     end
 
     class Tag
@@ -49,14 +50,14 @@ Examples
 
 Now when you save a product, you get a _keywords field automatically:
 
-    p = Product.new :brand => "Apple", :name => "iPhone"
+    p = Product.new :brand => "Apple", :name => "iPhone", :info => {:summary => "Info-summary", :description => "Info-description"}
     p.tags << Tag.new(:name => "Amazing")
     p.tags << Tag.new(:name => "Awesome")
     p.tags << Tag.new(:name => "Superb")
     p.save
     => true
     p._keywords
-    => ["amazing", "apple", "awesome", "iphone", "superb"]
+    => ["amazing", "apple", "awesome", "iphone", "superb", "Info-summary", "Info-description"]
 
 Now you can run search, which will look in the _keywords field and return all matching results:
 
@@ -73,6 +74,9 @@ code to search for 'iphone' in products cheaper than $499
 
     @category.products.where(:price.lt => 499).full_text_search('iphone').asc(:price)
 
+To index or reindex all existing records, run this rake task
+
+    $ rake mongoid_search:index
 
 Options
 -------
@@ -113,7 +117,7 @@ relevant_search:
     Product.full_text_search('amazing apple', relevant_search: true)
     => [#<Product _id: 5016e7d16af54efe1c000001, _type: nil, brand: "Apple", name: "iPhone", attrs: nil, info: nil, category_id: nil, _keywords: ["amazing", "apple", "awesome", "iphone", "superb"], relevance: 2.0>]
 
- Please note that relevant_search will return an Array and not a Criteria object. The search method shoud always be called in the end of the method chain.
+ Please note that relevant_search will return an Array and not a Criteria object. The search method should always be called in the end of the method chain.
 
 Initializer
 -----------
@@ -155,7 +159,7 @@ Alternatively, you can create an initializer to setup those options:
       config.regex = Proc.new { |query| /#{query}/ }
 
       ## Match partial words on the beginning or in the end (slightly faster)
-      # config.regex = Proc.new { |query| /ˆ#{query}/ }
+      # config.regex = Proc.new { |query| /^#{query}/ }
       # config.regex = Proc.new { |query| /#{query}$/ }
 
       # Ligatures to be replaced
@@ -165,4 +169,3 @@ Alternatively, you can create an initializer to setup those options:
       # Minimum word size. Words smaller than it won't be indexed
       config.minimum_word_size = 2
     end
-

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.3

data/lib/mongoid_search.rb

@@ -1,8 +1,11 @@
 # encoding: utf-8
 
-require 'mongoid_search/railtie' if defined?(Rails)
 require 'mongoid_search/mongoid_search'
 
+if defined?(Rails)
+  require 'mongoid_search/railtie'
+end
+
 module Mongoid::Search
   ## Default matching type. Match :any or :all searched keywords
   mattr_accessor :match
@@ -45,7 +48,7 @@ module Mongoid::Search
   @@regex = Proc.new { |query| /#{query}/ }
 
   ## Match partial words on the beginning or in the end (slightly faster)
-  # @@regex = Proc.new { |query| /ˆ#{query}/ }
+  # @@regex = Proc.new { |query| /^#{query}/ }
   # @@regex = Proc.new { |query| /#{query}$/ }
 
   # Ligatures to be replaced
@@ -63,4 +66,4 @@ module Mongoid::Search
 end
 
 require 'mongoid_search/util'
-require 'mongoid_search/log'
+require 'mongoid_search/log'

data/lib/mongoid_search/mongoid_search.rb

@@ -1,11 +1,10 @@
 module Mongoid::Search
-  def self.included(base)
-    base.send(:cattr_accessor, :search_fields)
-
-    base.extend ClassMethods
+  extend ActiveSupport::Concern
 
+  included do
+    cattr_accessor :search_fields
     @@classes ||= []
-    @@classes << base
+    @@classes << self
   end
 
   def self.classes
@@ -15,7 +14,7 @@ module Mongoid::Search
   module ClassMethods #:nodoc:
     # Set a field or a number of fields as sources for search
     def search_in(*args)
-      args, options = args_and_options(args)
+      args, _options = args_and_options(args)
       self.search_fields = (self.search_fields || []).concat args
 
       field :_keywords, :type => Array
@@ -27,6 +26,8 @@ module Mongoid::Search
 
     def full_text_search(query, options={})
       options = extract_options(options)
+      attr_accessor :relevance if options[:relevant_search].eql? true
+
       return (options[:allow_empty_search] ? criteria.all : []) if query.blank?
 
       if options[:relevant_search]
@@ -47,6 +48,7 @@ module Mongoid::Search
     end
 
     private
+
     def query(keywords, options)
       keywords_hash = keywords.map do |kw|
         kw = Mongoid::Search.regex.call(kw) if Mongoid::Search.regex_search
@@ -58,9 +60,9 @@ module Mongoid::Search
 
     def args_and_options(args)
       options = args.last.is_a?(Hash) &&
-                [:match,
-                 :allow_empty_search,
-                 :relevant_search].include?(args.last.keys.first) ? args.pop : {}
+        [:match,
+         :allow_empty_search,
+         :relevant_search].include?(args.last.keys.first) ? args.pop : {}
 
       [args, extract_options(options)]
     end
@@ -93,25 +95,25 @@ module Mongoid::Search
       keywords = Mongoid::Search::Util.normalize_keywords(query)
 
       map = %Q{
-        function() {
-          var entries = 0;
-          for(i in keywords) {
-            for(j in this._keywords) {
-              if(this._keywords[j] == keywords[i]) {
-                entries++;
+          function() {
+            var entries = 0;
+            for(i in keywords) {
+              for(j in this._keywords) {
+                if(this._keywords[j] == keywords[i]) {
+                  entries++;
+                }
               }
             }
+            if(entries > 0) {
+              emit(this, entries);
+            }
           }
-          if(entries > 0) {
-            emit(this, entries);
-          }
-        }
       }
 
       reduce = %Q{
-        function(key, values) {
-          return(values);
-        }
+          function(key, values) {
+            return(values);
+          }
       }
 
       query(keywords, options).map_reduce(map, reduce).scope(:keywords => keywords).out(:inline => 1)
@@ -122,7 +124,6 @@ module Mongoid::Search
     update_attribute(:_keywords, set_keywords)
   end
 
-  private
   def set_keywords
     self._keywords = Mongoid::Search::Util.keywords(self, self.search_fields).
       flatten.reject{|k| k.nil? || k.empty?}.uniq.sort

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

@@ -42,7 +42,7 @@ module Mongoid::Search::Util
       downcase.
       to_s.
       gsub(/[._:;'"`,?|+={}()!@#%^&*<>~\$\-\\\/\[\]]/, ' '). # strip punctuation
-      gsub(/[^[:alnum:]\s]/,'').   # strip accents
+      gsub(/[^\s\p{Alnum}]/,'').   # strip accents
       gsub(/[#{ligatures.keys.join("")}]/) {|c| ligatures[c]}.
       split(' ').
       reject { |word| word.size < Mongoid::Search.minimum_word_size }

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,6 +1,8 @@
 class Product
   include Mongoid::Document
   include Mongoid::Search
+  include Mongoid::Attributes::Dynamic if ::Mongoid::VERSION >= '4'
+
   field :brand
   field :name
   field :attrs, :type => Array

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,6 +1,7 @@
 class Tag
   include Mongoid::Document
   include Mongoid::Search
+  include Mongoid::Attributes::Dynamic if ::Mongoid::VERSION >= '4'
 
   field :name
 

data/spec/mongoid_search_spec.rb

@@ -18,19 +18,19 @@ describe Mongoid::Search do
     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"}
+      :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
+        expect(Product.full_text_search("Info-summary").first).to eq @product
+        expect(Product.full_text_search("Info-description").first).to eq @product
       end
     end
 
@@ -41,8 +41,8 @@ describe Mongoid::Search do
       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
+        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
@@ -52,49 +52,50 @@ describe Mongoid::Search 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 => []
+        :name => "Процессор",
+        :tags => ["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", "процессор", "процессоры", "эльбрус"]
+      expect(@product._keywords).to eq ["amazing", "awesome", "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
     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
+        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" 
+      expect(product._keywords).to eq(["apple", "iphone"])
+    end
   end
 
 
   it "should set the _keywords field for array fields also" do
     @product.attrs = ['lightweight', 'plastic', :red]
     @product.save!
-    @product._keywords.should include 'lightweight', 'plastic', 'red'
+    expect(@product._keywords).to include 'lightweight', 'plastic', 'red'
   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]
+      :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
+    expect(variant._keywords).to include 'white'
+    expect(Variant.full_text_search(:name => 'Apple', :color => :white)).to eq [variant]
   end
 
   it "should expand the ligature to ease searching" do
@@ -102,115 +103,115 @@ describe Mongoid::Search do
     variant1 = Variant.create :tags => ["œuvre"].map {|tag| Tag.new(:name => tag)}
     variant2 = Variant.create :tags => ["æquo"].map {|tag| Tag.new(:name => tag)}
 
-    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]
   end
 
   it "should set the _keywords field 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 ["amaz", "appl", "awesom", "craddl", "iphon", "mobil", "review", "ol", "info", "descript", "summari"].sort
   end
 
   it "should set the _keywords field 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 }
     @product.save!
-    @product._keywords.sort.should == ["AMAZING", "APPLE", "AWESOME", "CRADDLE", "DESCRIPTION", "INFO", "IPHONE", "MOBILE", "OLE", "REVIEWS", "SUMMARY"]
+    expect(@product._keywords.sort).to eq ["AMAZING", "APPLE", "AWESOME", "CRADDLE", "DESCRIPTION", "INFO", "IPHONE", "MOBILE", "OLE", "REVIEWS", "SUMMARY"]
   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"]
     @product.save!
-    @product._keywords.sort.should == ["apple", "craddle", "iphone", "mobile", "reviews", "ole", "info", "description", "summary"].sort
+    expect(@product._keywords.sort).to eq ["apple", "craddle", "iphone", "mobile", "reviews", "ole", "info", "description", "summary"].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 => ["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 ["1908", "amazing", "car", "first", "ford",  "vehicle"]
+  end
 
   it "should return results in search" do
-    Product.full_text_search("apple").size.should == 1
+   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"
     @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
+   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
+   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
+   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
     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
     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
+   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
     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
     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
+   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
+   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).to eq [Product, Tag]
   end
 
   it 'should have a method to index keywords' do
-    @product.index_keywords!.should == true
+    expect(@product.index_keywords!).to eq 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
@@ -219,11 +220,60 @@ describe Mongoid::Search do
     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
+     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
+     expect(Product.full_text_search("iphone").size).to eq 1
+    end
+  end
+
+  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 'Match partial words on the beginning' do
+    
+      before do
+        Mongoid::Search.regex = Proc.new { |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.new { |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
 
@@ -234,40 +284,61 @@ describe Mongoid::Search do
     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]
+     expect(Product.full_text_search('apple imac').map(&:_id)).to eq [@imac._id, @product._id]
     end
 
     it "results should be recognized as persisted objects" do
-      Product.full_text_search('apple imac').map(&:persisted?).should_not include false
+     expect(Product.full_text_search('apple imac').map(&:persisted?)).not_to include false
     end
 
     it "should include relevance information" do
-      Product.full_text_search('apple imac').map(&:relevance).should == [2, 1]
+     expect(Product.full_text_search('apple imac').map(&:relevance)).to eq [2, 1]
     end
   end
 
   context "when using methods for keywords" do
     it "should set the _keywords from methods" do
-      @tags.first._keywords.should include "amazing"
+      expect(@tags.first._keywords).to include "amazing"
     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
+      it "should set the _keywords from parent" do
+        @tags.first.send(:set_keywords)
+        expect(@tags.first._keywords).to eq ["amazing", "description", "info", "iphone", "mobile", "reviews", "summary"]
+      end
     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")
+        :name => "T 1908",
+        :tags => ["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 "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

data/spec/util_spec.rb

@@ -18,56 +18,56 @@ describe Mongoid::Search::Util do
   end
 
   it "should return an empty array if no text is passed" do
-    Mongoid::Search::Util.normalize_keywords("").should == []
+    expect(Mongoid::Search::Util.normalize_keywords("")).to eq []
   end
 
   it "should return an array of keywords" do
-    Mongoid::Search::Util.normalize_keywords("keyword").class.should == Array
+    expect(Mongoid::Search::Util.normalize_keywords("keyword").class).to eq Array
   end
 
   it "should return an array of strings" do
-    Mongoid::Search::Util.normalize_keywords("keyword").first.class.should == String
+    expect(Mongoid::Search::Util.normalize_keywords("keyword").first.class).to eq String
   end
 
   it "should remove accents from the text passed" do
-    Mongoid::Search::Util.normalize_keywords("café").should == ["cafe"]
+    expect(Mongoid::Search::Util.normalize_keywords("café")).to eq ["cafe"]
   end
 
   it "should downcase the text passed" do
-    Mongoid::Search::Util.normalize_keywords("CaFé").should == ["cafe"]
+    expect(Mongoid::Search::Util.normalize_keywords("CaFé")).to eq ["cafe"]
   end
 
   it "should downcase utf-8 chars of the text passed" do
-    Mongoid::Search::Util.normalize_keywords("Кафе").should == ["кафе"]
+    expect(Mongoid::Search::Util.normalize_keywords("Кафе")).to eq ["кафе"]
   end
 
   it "should split whitespaces, hifens, dots, underlines, etc.." do
-    Mongoid::Search::Util.normalize_keywords("CaFé-express.com delicious;come visit, and 'win' an \"iPad\"").should == ["cafe", "express", "com", "delicious", "come", "visit", "and", "win", "an", "ipad"]
+    expect(Mongoid::Search::Util.normalize_keywords("CaFé-express.com delicious;come visit, and 'win' an \"iPad\"")).to eq ["cafe", "express", "com", "delicious", "come", "visit", "and", "win", "an", "ipad"]
   end
 
   it "should stem keywords" do
     Mongoid::Search.stem_keywords = true
-    Mongoid::Search::Util.normalize_keywords("A runner running and eating").should == ["runner", "run", "and", "eat"]
+    expect(Mongoid::Search::Util.normalize_keywords("A runner running and eating")).to eq ["runner", "run", "and", "eat"]
   end
 
   it "should stem keywords using a custom proc" do
     Mongoid::Search.stem_keywords = true
     Mongoid::Search.stem_proc = lambda { |word| word.upcase }
 
-    Mongoid::Search::Util.normalize_keywords("A runner running and eating").should == ["RUNNER", "RUNNING", "AND", "EATING"]
+    expect(Mongoid::Search::Util.normalize_keywords("A runner running and eating")).to eq ["RUNNER", "RUNNING", "AND", "EATING"]
   end
 
   it "should ignore keywords from ignore list" do
     Mongoid::Search.stem_keywords = true
     Mongoid::Search.ignore_list = YAML.load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))["ignorelist"]
-    Mongoid::Search::Util.normalize_keywords("An amazing awesome runner running and eating").should == ["an", "runner", "run", "and", "eat"]
+    expect(Mongoid::Search::Util.normalize_keywords("An amazing awesome runner running and eating")).to eq ["an", "runner", "run", "and", "eat"]
   end
 
   it "should ignore keywords with less than two words" do
-    Mongoid::Search::Util.normalize_keywords("A runner running").should_not include "a"
+    expect(Mongoid::Search::Util.normalize_keywords("A runner running")).not_to include "a"
   end
 
   it "should not ignore numbers" do
-    Mongoid::Search::Util.normalize_keywords("Ford T 1908").should include "1908"
+    expect(Mongoid::Search::Util.normalize_keywords("Ford T 1908")).to include "1908"
   end
 end

metadata

@@ -1,94 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_search
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Mauricio Zaffari
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-15 00:00:00.000000000 Z
+date: 2017-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
-  type: :runtime
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: fast-stemmer
-  type: :runtime
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: database_cleaner
-  type: :development
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.0
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: rake
-  type: :development
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '11.0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '11.0'
 - !ruby/object:Gem::Dependency
   name: rspec
-  type: :development
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
 description: Simple full text search implementation.
@@ -98,15 +87,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/mongoid_search/log.rb
-- lib/mongoid_search/mongoid_search.rb
-- lib/mongoid_search/railtie.rb
-- lib/mongoid_search/util.rb
-- lib/mongoid_search.rb
 - LICENSE
 - README.md
 - Rakefile
 - VERSION
+- lib/mongoid_search.rb
+- lib/mongoid_search/log.rb
+- lib/mongoid_search/mongoid_search.rb
+- lib/mongoid_search/railtie.rb
+- lib/mongoid_search/tasks/mongoid_search.rake
+- lib/mongoid_search/util.rb
 - spec/config/ignorelist.yml
 - spec/models/category.rb
 - spec/models/product.rb
@@ -117,36 +107,36 @@ files:
 - spec/spec_helper.rb
 - spec/util_spec.rb
 homepage: http://www.papodenerd.net/mongoid-search-full-text-search-for-your-mongoid-models/
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.6.12
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Search implementation for Mongoid ORM
 test_files:
-- spec/config/ignorelist.yml
+- spec/models/variant.rb
 - spec/models/category.rb
 - spec/models/product.rb
-- spec/models/subproduct.rb
 - spec/models/tag.rb
-- spec/models/variant.rb
-- spec/mongoid_search_spec.rb
+- spec/models/subproduct.rb
+- spec/config/ignorelist.yml
 - spec/spec_helper.rb
 - spec/util_spec.rb
+- spec/mongoid_search_spec.rb