mongoid_search 0.2.8 → 0.3.0

data/README.md

@@ -1,7 +1,7 @@
 Mongoid Search
 ============
 
-Mongoid Search is a simple full text search implementation for Mongoid ORM.
+Mongoid Search is a simple full text search implementation for Mongoid ORM. It performs well for small data sets. If your searchable model is big (i.e. 1.000.000+ records), solr or sphinx may suit you better.
 
 Installation
 --------
@@ -10,6 +10,10 @@ In your Gemfile:
 
     gem 'mongoid_search'
 
+If your project is still using mongoid 2.x.x, stick to mongoid_search 0.2.x:
+
+    gem 'mongoid_search', '~> 0.2.8'
+
 Then:
 
     bundle install
@@ -23,8 +27,8 @@ Examples
       field :brand
       field :name
 
-      references_many :tags
-      refereced_in    :category
+      has_many   :tags
+      belongs_to :category
 
       search_in :brand, :name, :tags => :name, :category => :name
     end
@@ -33,14 +37,14 @@ Examples
       include Mongoid::Document
       field :name
 
-      referenced_in :product
+      belongs_to :product
     end
 
     class Category
       include Mongoid::Document
       field :name
 
-      references_many :products
+      has_many :products
     end
 
 Now when you save a product, you get a _keywords field automatically:
@@ -52,70 +56,109 @@ Now when you save a product, you get a _keywords field automatically:
     p.save
     => true
     p._keywords
+    => ["amazing", "apple", "awesome", "iphone", "superb"]
 
 Now you can run search, which will look in the _keywords field and return all matching results:
 
-    Product.search("apple iphone").size
+    Product.full_text_search("apple iphone").size
     => 1
 
 Note that the search is case insensitive, and accept partial searching too:
 
-    Product.search("ipho").size
+    Product.full_text_search("ipho").size
     => 1
-    
-Assuming you have a category with multiple products you can now use the following
-code to search for 'iphone' in products cheaper than $499
 
-    @category.products.where(:price.lt => 499).csearch('iphone').asc(:price)
+Assuming you have a category with multiple products you can use the following
+code to search for 'iphone' in products cheaper than $499
 
-In this case we have to use csearch, an alias for search, because since v2.0.0
-Mongoid defines it's own Criteria.search method.
+    @category.products.where(:price.lt => 499).full_text_search('iphone').asc(:price)
 
 
 Options
 -------
 
 match:
+
   _:any_ - match any occurrence
+
   _:all_ - match all ocurrences
+
   Default is _:any_.
 
-    search_in :brand, :name, { :tags => :name }, { :match => :any }
+    Product.full_text_search("apple motorola", match: :any).size
+    => 1
 
-    Product.search("apple motorola").size
+    Product.full_text_search("apple motorola", match: :all).size
+    => 0
+
+allow\_empty\_search:
+
+  _true_ - will return Model.all
+
+  _false_ - will return []
+
+  Default is _false_.
+
+    Product.full_text_search("", allow_empty_search: true).size
     => 1
 
-    search_in :brand, :name, { :tags => :name }, { :match => :all }
+relevant_search:
 
-    Product.search("apple motorola").size
-    => 0
+  _true_ - Adds relevance information to the results
+
+  _false_ - No relevance information
 
-allow_empty_search:
-  _true_ - match any occurrence
-  _false_ - match all ocurrences
   Default is _false_.
 
-    search_in :brand, :name, { :tags => :name }, { :allow_empty_search => true }
+    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>]
 
-    Product.search("").size
-    => 1
-    
-ignore_list:
-  Pass in an ignore list location. Keywords in that list will be ignored.
-  
-    search_in :brand, :name, { :tags => :name }, { :ignore_list => Rails.root.join("config", "ignorelist.yml") }
-
-  The list should look like:
-    
-    ignorelist:
-      a, an, to, from, as
-      
-  You can include how many keywords you like.
-
-TODO
-----
-
-* Strip html with sanitize (https://github.com/rgrove/sanitize)
-* Rewrite and test relevant search
-* Move all configurations to a configuration file. Maybe /config/mongoid_search.yml.
+ 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.
+
+Initializer
+-----------
+
+Alternatively, you can create an initializer to setup those options:
+
+    Mongoid::Search.setup do |config|
+      ## Default matching type. Match :any or :all searched keywords
+      config.match = :any
+
+      ## If true, an empty search will return all objects
+      config.allow_empty_search = false
+
+      ## If true, will search with relevance information
+      config.relevant_search = false
+
+      ## Stem keywords
+      config.stem_keywords = false
+
+      ## Words to ignore
+      config.ignore_list = []
+
+      ## An array of words
+      # config.ignore_list = %w{ a an to from as }
+
+      ## Or from a file
+      # config.ignore_list = YAML.load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))["ignorelist"]
+
+      ## Search using regex (slower)
+      config.regex_search = true
+
+      ## Regex to search
+
+      ## Match partial words on both sides (slower)
+      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}$/ }
+
+      # Ligatures to be replaced
+      # http://en.wikipedia.org/wiki/Typographic_ligature
+      config.ligatures = { "œ"=>"oe", "æ"=>"ae" }
+
+      # Minimum word size. Words smaller than it won't be indexed
+      config.minimum_word_size = 2
+    end
 

data/lib/mongoid_search/log.rb

@@ -1,4 +1,4 @@
-class Log
+class Mongoid::Search::Log
   cattr_accessor :silent
 
   def self.log(message)

data/lib/mongoid_search/mongoid_search.rb

@@ -1,100 +1,120 @@
 module Mongoid::Search
-  extend ActiveSupport::Concern
+  def self.included(base)
+    base.send(:cattr_accessor, :search_fields)
 
-  included do
-    cattr_accessor :search_fields, :match, :allow_empty_search, :relevant_search, :stem_keywords, :ignore_list
-  end
+    base.extend ClassMethods
 
-  def self.included(base)
-    @classes ||= []
-    @classes << base
+    @@classes ||= []
+    @@classes << base
   end
 
   def self.classes
-    @classes
+    @@classes
   end
 
   module ClassMethods #:nodoc:
     # Set a field or a number of fields as sources for search
     def search_in(*args)
-      options = args.last.is_a?(Hash) && [:match, :allow_empty_search, :relevant_search, :stem_keywords, :ignore_list].include?(args.last.keys.first) ? args.pop : {}
-      self.match              = [:any, :all].include?(options[:match]) ? options[:match] : :any
-      self.allow_empty_search = [true, false].include?(options[:allow_empty_search]) ? options[:allow_empty_search] : false
-      self.relevant_search    = [true, false].include?(options[:relevant_search]) ? options[:allow_empty_search] : false
-      self.stem_keywords      = [true, false].include?(options[:stem_keywords]) ? options[:allow_empty_search] : false
-      self.ignore_list        = YAML.load(File.open(options[:ignore_list]))["ignorelist"] if options[:ignore_list].present?
-      self.search_fields      = (self.search_fields || []).concat args
+      args, options = args_and_options(args)
+      self.search_fields = (self.search_fields || []).concat args
 
       field :_keywords, :type => Array
-      
-      Gem.loaded_specs["mongoid"].version.to_s.include?("3.0") ? (index({_keywords: 1}, {background: true})) : (index :_keywords, :background => true)
+
+      index({ :_keywords => 1 }, { :background => true })
 
       before_save :set_keywords
     end
 
-    def search(query, options={})
-      if relevant_search
+    def full_text_search(query, options={})
+      options = extract_options(options)
+      return (options[:allow_empty_search] ? criteria.all : []) if query.blank?
+
+      if options[:relevant_search]
         search_relevant(query, options)
       else
         search_without_relevance(query, options)
       end
     end
 
-    # Mongoid 2.0.0 introduces Criteria.seach so we need to provide
-    # alternate method
-    alias csearch search
+    # Keeping these aliases for compatibility purposes
+    alias csearch full_text_search
+    alias search full_text_search
 
-    def search_without_relevance(query, options={})
-      return criteria.all if query.blank? && allow_empty_search
-      criteria.send("#{(options[:match]||self.match).to_s}_in", :_keywords => Util.normalize_keywords(query, stem_keywords, ignore_list).map { |q| /#{q}/ })
+    # Goes through all documents in the class that includes Mongoid::Search
+    # and indexes the keywords.
+    def index_keywords!
+      all.each { |d| d.index_keywords! ? Log.green(".") : Log.red("F") }
     end
 
-    def search_relevant(query, options={})
-      return criteria.all if query.blank? && allow_empty_search
+    private
+    def query(keywords, options)
+      keywords_hash = keywords.map do |kw|
+        kw = Mongoid::Search.regex.call(kw) if Mongoid::Search.regex_search
+        { :_keywords => kw }
+      end
 
-      keywords = Util.normalize_keywords(query, stem_keywords, ignore_list)
+      criteria.send("#{(options[:match]).to_s}_of", *keywords_hash)
+    end
 
-      map = <<-EOS
-        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._id, entries)
-        }
-      EOS
-      reduce = <<-EOS
-        function(key, values) {
-          return(values[0])
-        }
-      EOS
+    def args_and_options(args)
+      options = args.last.is_a?(Hash) &&
+                [:match,
+                 :allow_empty_search,
+                 :relevant_search].include?(args.last.keys.first) ? args.pop : {}
 
-      #raise [self.class, self.inspect].inspect
+      [args, extract_options(options)]
+    end
 
-      kw_conditions = keywords.map do |kw|
-        {:_keywords => kw}
-      end
+    def extract_options(options)
+      {
+        :match              => options[:match]              || Mongoid::Search.match,
+        :allow_empty_search => options[:allow_empty_search] || Mongoid::Search.allow_empty_search,
+        :relevant_search    => options[:relevant_search]    || Mongoid::Search.relevant_search
+      }
+    end
 
-      criteria = (criteria || self).any_of(*kw_conditions)
+    def search_without_relevance(query, options)
+      query(Util.normalize_keywords(query), options)
+    end
 
-      query = criteria.selector
+    def search_relevant(query, options)
+      results_with_relevance(query, options).sort { |o| o['value'] }.map do |r|
 
-      options.delete(:limit)
-      options.delete(:skip)
-      options.merge! :scope => {:keywords => keywords}, :query => query
+        new(r['_id'].merge(:relevance => r['value'])) do |o|
+          # Need to match the actual object
+          o.instance_variable_set('@new_record', false)
+          o._id = r['_id']['_id']
+        end
 
-      # res = collection.map_reduce(map, reduce, options)
-      # res.find.sort(['value', -1]) # Cursor
-      collection.map_reduce(map, reduce, options)
+      end
     end
 
-    # Goes through all documents in the class that includes Mongoid::Search
-    # and indexes the keywords.
-    def index_keywords!
-      all.each { |d| d.index_keywords! ? Log.green(".") : Log.red("F") }
+    def results_with_relevance(query, options)
+      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++;
+              }
+            }
+          }
+          if(entries > 0) {
+            emit(this, entries);
+          }
+        }
+      }
+
+      reduce = %Q{
+        function(key, values) {
+          return(values);
+        }
+      }
+
+      query(keywords, options).map_reduce(map, reduce).scope(:keywords => keywords).out(:inline => 1)
     end
   end
 
@@ -105,7 +125,7 @@ module Mongoid::Search
   private
   def set_keywords
     self._keywords = self.search_fields.map do |field|
-      Util.keywords(self, field, stem_keywords, ignore_list)
+      Mongoid::Search::Util.keywords(self, field)
     end.flatten.reject{|k| k.nil? || k.empty?}.uniq.sort
   end
 end

data/lib/mongoid_search/util.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
-module Util
+module Mongoid::Search::Util
 
-  def self.keywords(klass, field, stem_keywords, ignore_list)
+  def self.keywords(klass, field)
     if field.is_a?(Hash)
       field.keys.map do |key|
         attribute = klass.send(key)
@@ -9,30 +9,32 @@ module Util
           method = field[key]
           if attribute.is_a?(Array)
             if method.is_a?(Array)
-              method.map {|m| attribute.map { |a| Util.normalize_keywords a.send(m), stem_keywords, ignore_list } }
+              method.map {|m| attribute.map { |a| normalize_keywords a.send(m) } }
             else
-              attribute.map(&method).map { |t| Util.normalize_keywords t, stem_keywords, ignore_list }
+              attribute.map(&method).map { |t| normalize_keywords t }
             end
           elsif attribute.is_a?(Hash)
             if method.is_a?(Array)
-              method.map {|m| Util.normalize_keywords attribute[m.to_sym], stem_keywords, ignore_list }
+              method.map {|m| normalize_keywords attribute[m.to_sym] }
             else
-              Util.normalize_keywords(attribute[method.to_sym], stem_keywords, ignore_list)
+              normalize_keywords(attribute[method.to_sym])
             end
           else
-            Util.normalize_keywords(attribute.send(method), stem_keywords, ignore_list)
+            normalize_keywords(attribute.send(method))
           end
         end
       end
     else
       value = klass[field]
       value = value.join(' ') if value.respond_to?(:join)
-      Util.normalize_keywords(value, stem_keywords, ignore_list) if value
+      normalize_keywords(value) if value
     end
   end
 
-  def self.normalize_keywords(text, stem_keywords, ignore_list)
-    ligatures = {"œ"=>"oe", "æ"=>"ae"}
+  def self.normalize_keywords(text)
+    ligatures     = Mongoid::Search.ligatures
+    ignore_list   = Mongoid::Search.ignore_list
+    stem_keywords = Mongoid::Search.stem_keywords
 
     return [] if text.blank?
     text = text.to_s.
@@ -44,7 +46,7 @@ module Util
       gsub(/[^[:alnum:]\s]/,'').   # strip accents
       gsub(/[#{ligatures.keys.join("")}]/) {|c| ligatures[c]}.
       split(' ').
-      reject { |word| word.size < 2 }
+      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) if stem_keywords
     text

data/lib/mongoid_search.rb

@@ -1,4 +1,62 @@
+# encoding: utf-8
+
 require 'mongoid_search/railtie' if defined?(Rails)
-require 'mongoid_search/util'
-require 'mongoid_search/log'
 require 'mongoid_search/mongoid_search'
+
+module Mongoid::Search
+  ## Default matching type. Match :any or :all searched keywords
+  mattr_accessor :match
+  @@match = :any
+
+  ## If true, an empty search will return all objects
+  mattr_accessor :allow_empty_search
+  @@allow_empty_search = false
+
+  ## If true, will search with relevance information
+  mattr_accessor :relevant_search
+  @@relevant_search = false
+
+  ## Stem keywords
+  mattr_accessor :stem_keywords
+  @@stem_keywords = false
+
+  ## Words to ignore
+  mattr_accessor :ignore_list
+  @@ignore_list = []
+
+  ## An array of words
+  # @@ignore_list = %w{ a an to from as }
+
+  ## Or from a file
+  # @@ignore_list = YAML.load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))["ignorelist"]
+
+  ## Search using regex (slower)
+  mattr_accessor :regex_search
+  @@regex_search = true
+
+  ## Regex to search
+  mattr_accessor :regex
+
+  ## Match partial words on both sides (slower)
+  @@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}$/ }
+
+  # Ligatures to be replaced
+  # http://en.wikipedia.org/wiki/Typographic_ligature
+  mattr_accessor :ligatures
+  @@ligatures = { "œ"=>"oe", "æ"=>"ae" }
+
+  # Minimum word size. Words smaller than it won't be indexed
+  mattr_accessor :minimum_word_size
+  @@minimum_word_size = 2
+
+  def self.setup
+    yield self
+  end
+end
+
+require 'mongoid_search/util'
+require 'mongoid_search/log'

data/spec/models/category.rb

@@ -2,5 +2,5 @@ class Category
   include Mongoid::Document
   field :name
 
-  references_many :products
+  has_many :products
 end

data/spec/models/product.rb

@@ -6,9 +6,9 @@ class Product
   field :attrs, :type => Array
   field :info, :type => Hash
 
-  references_many :tags
-  referenced_in   :category
-  embeds_many     :subproducts
+  has_many    :tags
+  belongs_to  :category
+  embeds_many :subproducts
 
   search_in :brand, :name, :outlet, :attrs, :tags => :name, :category => :name,
             :subproducts => [:brand, :name], :info => [ :summary, :description ]

data/spec/models/subproduct.rb

@@ -4,5 +4,5 @@ class Subproduct
   field :brand
   field :name
 
-  embedded_in :product, :inverse_of => :subproducts
+  belongs_to :product, :inverse_of => :subproducts
 end

data/spec/models/tag.rb

@@ -2,5 +2,5 @@ class Tag
   include Mongoid::Document
   field :name
 
-  referenced_in :product
+  belongs_to :product
 end

data/spec/mongoid_search_spec.rb

@@ -5,8 +5,9 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe Mongoid::Search do
 
   before(:each) do
-    Product.stem_keywords = false
-    Product.ignore_list   = nil
+    Mongoid::Search.match         = :any
+    Mongoid::Search.stem_keywords = false
+    Mongoid::Search.ignore_list   = nil
     @product = Product.create :brand => "Apple",
                               :name => "iPhone",
                               :tags => ["Amazing", "Awesome", "Olé"].map { |tag| Tag.new(:name => tag) },
@@ -19,8 +20,8 @@ describe Mongoid::Search do
   describe "Serialized hash fields" do
     context "when the hash is populated" do
       it "should return the product" do
-        Product.search("Info-summary").first.should eq @product
-        Product.search("Info-description").first.should eq @product
+        Product.full_text_search("Info-summary").first.should eq @product
+        Product.full_text_search("Info-description").first.should eq @product
       end
     end
 
@@ -31,29 +32,29 @@ describe Mongoid::Search do
       end
 
       it "should not return the product" do
-        Product.search("Info-description").size.should eq 0
-        Product.search("Info-summary").size.should eq 0
+        Product.full_text_search("Info-description").size.should eq 0
+        Product.full_text_search("Info-summary").size.should eq 0
       end
     end
   end
 
   context "utf-8 characters" do
-    before(:each) {
-      Product.stem_keywords = false
-      Product.ignore_list   = nil
+    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 => []
-    }
+    end
 
     it "should leave utf8 characters" do
       @product._keywords.should == ["amazing", "awesome", "ole", "процессор", "процессоры", "эльбрус"]
     end
 
     it "should return results in search when case doesn't match" do
-      Product.search("ЭЛЬБРУС").size.should == 1
+      Product.full_text_search("ЭЛЬБРУС").size.should == 1
     end
   end
 
@@ -83,7 +84,7 @@ describe Mongoid::Search do
                               :subproducts => [Subproduct.new(:brand => "Apple", :name => "Craddle")],
                               :color => :white
     variant._keywords.should include 'white'
-    Variant.search(:name => 'Apple', :color => :white).should eq [variant]
+    Variant.full_text_search(:name => 'Apple', :color => :white).should eq [variant]
   end
 
   it "should expand the ligature to ease searching" do
@@ -91,19 +92,20 @@ 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.search("œuvre").should eq [variant1]
-    Variant.search("oeuvre").should eq [variant1]
-    Variant.search("æquo").should eq [variant2]
-    Variant.search("aequo").should eq [variant2]
+    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]
   end
+
   it "should set the _keywords field with stemmed words if stem is enabled" do
-    Product.stem_keywords = true
+    Mongoid::Search.stem_keywords = true
     @product.save!
     @product._keywords.sort.should == ["amaz", "appl", "awesom", "craddl", "iphon", "mobil", "ol", "info", "descript", "summari"].sort
   end
 
   it "should ignore keywords in an ignore list" do
-    Product.ignore_list = YAML.load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))["ignorelist"]
+    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", "ole", "info", "description", "summary"].sort
   end
@@ -115,67 +117,68 @@ describe Mongoid::Search do
                               :category => Category.new(:name => "Vehicle")
 
       @product.save!
-      @product._keywords.should == ["1908","amazing", "car", "first", "ford",  "vehicle"]
+      @product._keywords.should == ["1908", "amazing", "car", "first", "ford",  "vehicle"]
    end
 
 
   it "should return results in search" do
-    Product.search("apple").size.should == 1
+    Product.full_text_search("apple").size.should == 1
   end
 
   it "should return results in search for dynamic attribute" do
     @product[:outlet] = "online shop"
     @product.save!
-    Product.search("online").size.should == 1
+    Product.full_text_search("online").size.should == 1
   end
 
   it "should return results in search even searching a accented word" do
-    Product.search("Ole").size.should == 1
-    Product.search("Olé").size.should == 1
+    Product.full_text_search("Ole").size.should == 1
+    Product.full_text_search("Olé").size.should == 1
   end
 
   it "should return results in search even if the case doesn't match" do
-    Product.search("oLe").size.should == 1
+    Product.full_text_search("oLe").size.should == 1
   end
 
-  it "should return results in search with a partial word" do
-    Product.search("iph").size.should == 1
+  it "should return results in search with a partial word by default" do
+    Product.full_text_search("iph").size.should == 1
   end
 
   it "should return results for any matching word with default search" do
-    Product.search("apple motorola").size.should == 1
+    Product.full_text_search("apple motorola").size.should == 1
   end
 
   it "should not return results when all words do not match, if using :match => :all" do
-    Product.match = :all
-    Product.search("apple motorola").size.should == 0
+    Mongoid::Search.match = :all
+    Product.full_text_search("apple motorola").size.should == 0
   end
 
-  it "should return results for any matching word, using :match => :all, passing :match => :any to .search" do
-    Product.match = :all
-    Product.search("apple motorola", :match => :any).size.should == 1
+  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
   end
 
-  it "should not return results when all words do not match, passing :match => :all to .search" do
-    Product.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
+    Product.full_text_search("apple motorola", :match => :all).size.should == 0
   end
 
   it "should return no results when a blank search is made" do
-    Product.search("").size.should == 0
+    Mongoid::Search.allow_empty_search = false
+    Product.full_text_search("").size.should == 0
   end
 
   it "should return results when a blank search is made when :allow_empty_search is true" do
-    Product.allow_empty_search = true
-    Product.search("").size.should == 1
+    Mongoid::Search.allow_empty_search = true
+    Product.full_text_search("").size.should == 1
   end
 
   it "should search for embedded documents" do
-    Product.search("craddle").size.should == 1
+    Product.full_text_search("craddle").size.should == 1
   end
 
   it 'should work in a chainable fashion' do
-    @product.category.products.where(:brand => 'Apple').csearch('apple').size.should == 1
-    @product.category.products.csearch('craddle').where(:brand => 'Apple').size.should == 1
+    @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
   end
 
   it 'should return the classes that include the search module' do
@@ -190,5 +193,36 @@ describe Mongoid::Search do
     Product.index_keywords!.should_not include(false)
   end
 
+  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
+    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
+    end
+  end
+
+  context "relevant search" do
+    before do
+      Mongoid::Search.relevant_search = true
+      @imac = Product.create :name => 'apple imac'
+    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]
+    end
+
+    it "results should be recognized as persisted objects" do
+      Product.full_text_search('apple imac').map(&:persisted?).should_not include false
+    end
 
+    it "should include relevance information" do
+      Product.full_text_search('apple imac').map(&:relevance).should == [2, 1]
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -10,8 +10,7 @@ require 'yaml'
 require 'mongoid_search'
 
 Mongoid.configure do |config|
-  name = "mongoid_search_test"
-  config.master = Mongo::Connection.new.db(name)
+  config.connect_to "mongoid_search_test"
 end
 
 Dir["#{File.dirname(__FILE__)}/models/*.rb"].each { |file| require file }

data/spec/util_spec.rb

@@ -1,48 +1,56 @@
 # encoding: utf-8
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe Util do
+describe Mongoid::Search::Util do
+  before do
+    Mongoid::Search.stem_keywords = false
+    Mongoid::Search.ignore_list = ""
+  end
+
   it "should return an empty array if no text is passed" do
-    Util.normalize_keywords("", false, "").should == []
+    Mongoid::Search::Util.normalize_keywords("").should == []
   end
 
   it "should return an array of keywords" do
-    Util.normalize_keywords("keyword", false, "").class.should == Array
+    Mongoid::Search::Util.normalize_keywords("keyword").class.should == Array
   end
 
   it "should return an array of strings" do
-    Util.normalize_keywords("keyword", false, "").first.class.should == String
+    Mongoid::Search::Util.normalize_keywords("keyword").first.class.should == String
   end
 
   it "should remove accents from the text passed" do
-    Util.normalize_keywords("café", false, "").should == ["cafe"]
+    Mongoid::Search::Util.normalize_keywords("café").should == ["cafe"]
   end
 
   it "should downcase the text passed" do
-    Util.normalize_keywords("CaFé", false, "").should == ["cafe"]
+    Mongoid::Search::Util.normalize_keywords("CaFé").should == ["cafe"]
   end
 
   it "should downcase utf-8 chars of the text passed" do
-    Util.normalize_keywords("Кафе", false, "").should == ["кафе"]
+    Mongoid::Search::Util.normalize_keywords("Кафе").should == ["кафе"]
   end
 
   it "should split whitespaces, hifens, dots, underlines, etc.." do
-    Util.normalize_keywords("CaFé-express.com delicious;come visit, and 'win' an \"iPad\"", false, "").should == ["cafe", "express", "com", "delicious", "come", "visit", "and", "win", "an", "ipad"]
+    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"]
   end
 
   it "should stem keywords" do
-    Util.normalize_keywords("A runner running and eating", true, "").should == ["runner", "run", "and", "eat"]
+    Mongoid::Search.stem_keywords = true
+    Mongoid::Search::Util.normalize_keywords("A runner running and eating").should == ["runner", "run", "and", "eat"]
   end
 
   it "should ignore keywords from ignore list" do
-    Util.normalize_keywords("An amazing awesome runner running and eating", true, YAML.load(File.open(File.dirname(__FILE__) + '/config/ignorelist.yml'))["ignorelist"]).should == ["an", "runner", "run", "and", "eat"]
+    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"]
   end
 
   it "should ignore keywords with less than two words" do
-    Util.normalize_keywords("A runner running", false, "").should_not include "a"
+    Mongoid::Search::Util.normalize_keywords("A runner running").should_not include "a"
   end
 
-   it "should not ignore numbers" do
-      Util.normalize_keywords("Ford T 1908", false, "").should include "1908"
-   end
+  it "should not ignore numbers" do
+    Mongoid::Search::Util.normalize_keywords("Ford T 1908").should include "1908"
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_search
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,29 +13,18 @@ date: 2012-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &70364721915420 !ruby/object:Gem::Requirement
+  requirement: &70200267450400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70364721915420
-- !ruby/object:Gem::Dependency
-  name: bson_ext
-  requirement: &70364721930900 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: *70364721930900
+  version_requirements: *70200267450400
 - !ruby/object:Gem::Dependency
   name: fast-stemmer
-  requirement: &70364721929380 !ruby/object:Gem::Requirement
+  requirement: &70200267465820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,21 +32,21 @@ dependencies:
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70364721929380
+  version_requirements: *70200267465820
 - !ruby/object:Gem::Dependency
   name: database_cleaner
-  requirement: &70364721927540 !ruby/object:Gem::Requirement
+  requirement: &70200267464480 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.6.4
+        version: 0.8.0
   type: :development
   prerelease: false
-  version_requirements: *70364721927540
+  version_requirements: *70200267464480
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70364721926220 !ruby/object:Gem::Requirement
+  requirement: &70200267462600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +54,10 @@ dependencies:
         version: 0.8.7
   type: :development
   prerelease: false
-  version_requirements: *70364721926220
+  version_requirements: *70200267462600
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70364721925360 !ruby/object:Gem::Requirement
+  requirement: &70200267461180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,7 +65,7 @@ dependencies:
         version: '2.4'
   type: :development
   prerelease: false
-  version_requirements: *70364721925360
+  version_requirements: *70200267461180
 description: Simple full text search implementation.
 email:
 - mauricio@papodenerd.net