mongoid_fulltext 0.6.1 → 0.7.0

data/spec/spec_helper.rb

@@ -6,18 +6,22 @@ require 'mongoid'
 
 ENV['MONGOID_ENV'] = 'test'
 
-Mongoid.load!("#{File.dirname(__FILE__)}/config/mongoid.yml")
-Mongoid.logger = nil
-
-require File.expand_path("../../lib/mongoid_fulltext", __FILE__)
+require File.expand_path('../../lib/mongoid_fulltext', __FILE__)
 Dir["#{File.dirname(__FILE__)}/models/**/*.rb"].each { |f| require f }
 
+Mongoid.configure do |config|
+  config.connect_to('mongoid_fulltext_test')
+end
+
 RSpec.configure do |c|
-  c.before(:each) do
+  c.before :each do
     Mongoid.purge!
   end
-  c.after(:all) do
+  c.after :all do
     Mongoid.purge!
   end
+  c.before :all do
+    Mongoid.logger.level = Logger::INFO
+    Mongo::Logger.logger.level = Logger::INFO if Mongoid::Compatibility::Version.mongoid5?
+  end
 end
-

metadata

@@ -1,117 +1,80 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_fulltext
 version: !ruby/object:Gem::Version
-  version: 0.6.1
-  prerelease: 
+  version: 0.7.0
 platform: ruby
 authors:
 - Aaron Windsor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-03 00:00:00.000000000 Z
+date: 2015-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: unicode_utils
+  name: mongoid-compatibility
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: unicode_utils
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 2.10.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 2.10.0
-- !ruby/object:Gem::Dependency
-  name: jeweler
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.8.3
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.8.3
-description: Full-text search for the Mongoid ORM, using n-grams extracted from text
+description: 
 email: aaron.windsor@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- LICENSE
-- README.md
+extra_rdoc_files: []
 files:
 - .document
+- .gitignore
 - .rspec
+- .rubocop.yml
+- .rubocop_todo.yml
 - .travis.yml
 - CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- VERSION
+- lib/mongoid/full_text_search.rb
+- lib/mongoid/full_text_search/version.rb
+- lib/mongoid/indexable.rb
+- lib/mongoid/indexes.rb
 - lib/mongoid_fulltext.rb
-- lib/mongoid_indexes.rb
 - mongoid_fulltext.gemspec
-- spec/config/mongoid.yml
 - spec/models/accentless_artwork.rb
 - spec/models/advanced_artwork.rb
 - spec/models/basic_artwork.rb
@@ -131,34 +94,30 @@ files:
 - spec/models/russian_artwork.rb
 - spec/models/short_prefixes_artwork.rb
 - spec/models/stopwords_artwork.rb
-- spec/mongoid/fulltext_spec.rb
+- spec/mongoid/full_text_search_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/aaw/mongoid_fulltext
+homepage: https://github.com/artsy/mongoid_fulltext
 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'
-      segments:
-      - 0
-      hash: 2382360387082033861
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.4.5
 signing_key: 
-specification_version: 3
-summary: Full-text search for the Mongoid ORM
+specification_version: 4
+summary: Full-text search for the Mongoid ORM, using n-grams extracted from text.
 test_files: []

data/VERSION

@@ -1 +0,0 @@
-0.6.1

data/lib/mongoid_indexes.rb

@@ -1,12 +0,0 @@
-# hook onto model index creation to create related FT indexes
-module Mongoid::Indexes::ClassMethods
-
-    alias_method :create_fulltext_indexes_hook, :create_indexes
-       
-    def create_indexes
-      create_fulltext_indexes if respond_to?(:create_fulltext_indexes)
-      create_fulltext_indexes_hook
-    end
-
-end
-

data/spec/config/mongoid.yml

@@ -1,6 +0,0 @@
-test:
-  sessions:
-    default:
-      database: mongoid_fulltext_test
-      hosts:
-        - localhost:27017

data/spec/mongoid/fulltext_spec.rb

@@ -1,799 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-module Mongoid
-  describe FullTextSearch do
-
-    context "with several config options defined" do
-
-      let!(:abcdef) { AdvancedArtwork.create(:title => 'abcdefg hijklmn') }
-      let!(:cesar) { AccentlessArtwork.create(:title => "C\u00e9sar Galicia") }
-      let!(:julio) { AccentlessArtwork.create(:title => "Julio Cesar Morales") }
-
-      it "should recognize all options" do
-        # AdvancedArtwork is defined with an ngram_width of 4 and a different alphabet (abcdefg)
-        AdvancedArtwork.fulltext_search('abc').should == []
-        AdvancedArtwork.fulltext_search('abcd').first.should == abcdef
-        AdvancedArtwork.fulltext_search('defg').first.should == abcdef
-        AdvancedArtwork.fulltext_search('hijklmn').should == []
-        # AccentlessArtwork is just like BasicArtwork, except that we set :remove_accents to false,
-        # so this behaves like the ``old'' version of fulltext_search
-        AccentlessArtwork.fulltext_search("cesar").first.should == julio
-      end
-
-    end
-    
-    context "with default settings" do
-      
-      let!(:flower_myth) { BasicArtwork.create(:title => 'Flower Myth') }
-      let!(:flowers)     { BasicArtwork.create(:title => 'Flowers') }
-      let!(:lowered)     { BasicArtwork.create(:title => 'Lowered') }
-      let!(:cookies)     { BasicArtwork.create(:title => 'Cookies') }
-      let!(:empty)       { BasicArtwork.create(:title => '') }
-      let!(:cesar)       { BasicArtwork.create(:title => "C\u00e9sar Galicia") }
-      let!(:julio)       { BasicArtwork.create(:title => "Julio Cesar Morales") }
-      let!(:csar)        { BasicArtwork.create(:title => "Csar") }
-      let!(:percent)     { BasicArtwork.create(:title => "Untitled (cal%desert)") }
-      
-      it "returns empty for empties" do
-        BasicArtwork.fulltext_search(nil, :max_results => 1).should == []
-        BasicArtwork.fulltext_search("", :max_results => 1).should == []
-      end
-      
-      it "finds percents" do
-        BasicArtwork.fulltext_search("cal%desert".force_encoding("ASCII-8BIT"), :max_results => 1).first.should == percent
-        BasicArtwork.fulltext_search("cal%desert".force_encoding("UTF-8"), :max_results => 1).first.should == percent
-      end
-      
-      it "forgets accents" do
-        BasicArtwork.fulltext_search('cesar', :max_results => 1).first.should == cesar
-        BasicArtwork.fulltext_search('cesar g', :max_results => 1).first.should == cesar
-        BasicArtwork.fulltext_search("C\u00e9sar", :max_results => 1).first.should == cesar
-        BasicArtwork.fulltext_search("C\303\251sar".force_encoding("UTF-8"), :max_results => 1).first.should == cesar
-        BasicArtwork.fulltext_search(CGI.unescape("c%C3%A9sar"), :max_results => 1).first.should == cesar
-        BasicArtwork.fulltext_search(CGI.unescape("c%C3%A9sar".encode("ASCII-8BIT")), :max_results => 1).first.should == cesar
-      end
-
-      it "returns exact matches" do
-        BasicArtwork.fulltext_search('Flower Myth', :max_results => 1).first.should == flower_myth
-        BasicArtwork.fulltext_search('Flowers', :max_results => 1).first.should == flowers
-        BasicArtwork.fulltext_search('Cookies', :max_results => 1).first.should == cookies
-        BasicArtwork.fulltext_search('Lowered', :max_results => 1).first.should == lowered
-      end
-
-      it "returns exact matches regardless of case" do
-        BasicArtwork.fulltext_search('fLOWER mYTH', :max_results => 1).first.should == flower_myth
-        BasicArtwork.fulltext_search('FLOWERS', :max_results => 1).first.should == flowers
-        BasicArtwork.fulltext_search('cOOkies', :max_results => 1).first.should == cookies
-        BasicArtwork.fulltext_search('lOWERED', :max_results => 1).first.should == lowered
-      end
-
-      it "returns all relevant results, sorted by relevance" do
-        BasicArtwork.fulltext_search('Flowers').should == [flowers, flower_myth, lowered]
-      end
-
-      it "prefers prefix matches" do
-        [flowers, flower_myth].should include(BasicArtwork.fulltext_search('Floweockies').first)
-        BasicArtwork.fulltext_search('Lowers').first.should == lowered
-        BasicArtwork.fulltext_search('Cookilowers').first.should == cookies
-      end
-
-      it "returns an empty result set for an empty query" do
-        BasicArtwork.fulltext_search('').empty?.should be_true
-      end
-
-      it "returns an empty result set for a query that doesn't contain any characters in the alphabet" do
-        BasicArtwork.fulltext_search('_+=--@!##%#$%%').empty?.should be_true
-      end
-
-      it "returns results for a query that contains only a single ngram" do
-        BasicArtwork.fulltext_search('coo').first.should == cookies
-        BasicArtwork.fulltext_search('c!!!oo').first.should == cookies
-      end
-            
-    end
-    
-    context "with default settings" do
-      
-      let!(:flower_myth) { Gallery::BasicArtwork.create(:title => 'Flower Myth') }
-      let!(:flowers)     { Gallery::BasicArtwork.create(:title => 'Flowers') }
-      let!(:lowered)     { Gallery::BasicArtwork.create(:title => 'Lowered') }
-      let!(:cookies)     { Gallery::BasicArtwork.create(:title => 'Cookies') }
-      let!(:empty)       { Gallery::BasicArtwork.create(:title => '') }
-      
-      it "returns exact matches for model within a module" do
-        Gallery::BasicArtwork.fulltext_search('Flower Myth', :max_results => 1).first.should == flower_myth
-        Gallery::BasicArtwork.fulltext_search('Flowers', :max_results => 1).first.should == flowers
-        Gallery::BasicArtwork.fulltext_search('Cookies', :max_results => 1).first.should == cookies
-        Gallery::BasicArtwork.fulltext_search('Lowered', :max_results => 1).first.should == lowered
-      end
-      
-    end
-
-    context "with default settings" do
-
-      let!(:yellow)             { BasicArtwork.create(:title => 'Yellow') }
-      let!(:yellow_leaves_2)    { BasicArtwork.create(:title => 'Yellow Leaves 2') }
-      let!(:yellow_leaves_3)    { BasicArtwork.create(:title => 'Yellow Leaves 3') }
-      let!(:yellow_leaves_20)   { BasicArtwork.create(:title => 'Yellow Leaves 20') }
-      let!(:yellow_cup)         { BasicArtwork.create(:title => 'Yellow Cup') }
-
-      it "prefers the best prefix that matches a given string" do
-        BasicArtwork.fulltext_search('yellow').first.should == yellow
-        BasicArtwork.fulltext_search('yellow leaves', :max_results => 3).sort_by{ |x| x.title }.should == \
-          [yellow_leaves_2, yellow_leaves_3, yellow_leaves_20].sort_by{ |x| x.title }
-        BasicArtwork.fulltext_search('yellow cup').first.should == yellow_cup
-      end
-      
-    end
-    
-    context "with default settings" do
-      let!(:monet)             { BasicArtwork.create(:title => 'claude monet') }
-      let!(:one_month_weather_permitting)  { BasicArtwork.create(:title => 'one month weather permitting monday') }
-
-      it "finds better matches within exact strings" do
-        BasicArtwork.fulltext_search('monet').first.should == monet
-      end
-    end
-    
-    context "with default settings" do
-      
-      let!(:abc)       { BasicArtwork.create(:title => "abc") }
-      let!(:abcd)      { BasicArtwork.create(:title => "abcd") }
-      let!(:abcde)     { BasicArtwork.create(:title => "abcde") }
-      let!(:abcdef)    { BasicArtwork.create(:title => "abcdef") }
-      let!(:abcdefg)   { BasicArtwork.create(:title => "abcdefg") }
-      let!(:abcdefgh)  { BasicArtwork.create(:title => "abcdefgh") }
-      
-      it "returns exact matches from a list of similar prefixes" do
-        BasicArtwork.fulltext_search('abc').first.should == abc
-        BasicArtwork.fulltext_search('abcd').first.should == abcd
-        BasicArtwork.fulltext_search('abcde').first.should == abcde
-        BasicArtwork.fulltext_search('abcdef').first.should == abcdef
-        BasicArtwork.fulltext_search('abcdefg').first.should == abcdefg
-        BasicArtwork.fulltext_search('abcdefgh').first.should == abcdefgh
-      end
-
-    end
-    
-    context "with an index name specified" do
-      let!(:pablo_picasso)       { ExternalArtist.create(:full_name => 'Pablo Picasso') }
-      let!(:portrait_of_picasso) { ExternalArtwork.create(:title => 'Portrait of Picasso') }
-      let!(:andy_warhol)         { ExternalArtist.create(:full_name => 'Andy Warhol') }
-      let!(:warhol)              { ExternalArtwork.create(:title => 'Warhol') }
-      let!(:empty)               { ExternalArtwork.create(:title => '') }
-
-      it "returns results of different types from the same query" do
-        results = ExternalArtwork.fulltext_search('picasso', :max_results => 2).map{ |result| result }
-        results.member?(portrait_of_picasso).should be_true
-        results.member?(pablo_picasso).should be_true
-        results = ExternalArtist.fulltext_search('picasso', :max_results => 2).map{ |result| result }
-        results.member?(portrait_of_picasso).should be_true
-        results.member?(pablo_picasso).should be_true
-      end
-
-      it "returns exact matches" do
-        ExternalArtwork.fulltext_search('Pablo Picasso', :max_results => 1).first.should == pablo_picasso
-        ExternalArtwork.fulltext_search('Portrait of Picasso', :max_results => 1).first.should == portrait_of_picasso
-        ExternalArtwork.fulltext_search('Andy Warhol', :max_results => 1).first.should == andy_warhol
-        ExternalArtwork.fulltext_search('Warhol', :max_results => 1).first.should == warhol
-        ExternalArtist.fulltext_search('Pablo Picasso', :max_results => 1).first.should == pablo_picasso
-        ExternalArtist.fulltext_search('Portrait of Picasso', :max_results => 1).first.should == portrait_of_picasso
-        ExternalArtist.fulltext_search('Andy Warhol', :max_results => 1).first.should == andy_warhol
-        ExternalArtist.fulltext_search('Warhol', :max_results => 1).first.should == warhol
-      end
-
-      it "returns exact matches regardless of case" do
-        ExternalArtwork.fulltext_search('pABLO pICASSO', :max_results => 1).first.should == pablo_picasso
-        ExternalArtist.fulltext_search('PORTRAIT OF PICASSO', :max_results => 1).first.should == portrait_of_picasso
-        ExternalArtwork.fulltext_search('andy warhol', :max_results => 1).first.should == andy_warhol
-        ExternalArtwork.fulltext_search('wArHoL', :max_results => 1).first.should == warhol
-      end
-
-      it "returns all relevant results, sorted by relevance" do
-        ExternalArtist.fulltext_search('Pablo Picasso').should == [pablo_picasso, portrait_of_picasso]
-        ExternalArtwork.fulltext_search('Pablo Picasso').should == [pablo_picasso, portrait_of_picasso]
-        ExternalArtist.fulltext_search('Portrait of Picasso').should == [portrait_of_picasso, pablo_picasso]
-        ExternalArtwork.fulltext_search('Portrait of Picasso').should == [portrait_of_picasso, pablo_picasso]
-        ExternalArtist.fulltext_search('Andy Warhol').should == [andy_warhol, warhol]
-        ExternalArtwork.fulltext_search('Andy Warhol').should == [andy_warhol, warhol]
-        ExternalArtist.fulltext_search('Warhol').should == [warhol, andy_warhol]
-        ExternalArtwork.fulltext_search('Warhol').should == [warhol, andy_warhol]
-      end
-
-      it "prefers prefix matches" do
-        ExternalArtist.fulltext_search('PabloWarhol').first.should == pablo_picasso
-        ExternalArtist.fulltext_search('AndyPicasso').first.should == andy_warhol
-      end
-
-      it "returns an empty result set for an empty query" do
-        ExternalArtist.fulltext_search('').empty?.should be_true
-      end
-
-      it "returns an empty result set for a query that doesn't contain any characters in the alphabet" do
-        ExternalArtwork.fulltext_search('#$%!$#*%*').empty?.should be_true
-      end
-
-      it "returns results for a query that contains only a single ngram" do
-        ExternalArtist.fulltext_search('and').first.should == andy_warhol
-      end
-
-    end
-    
-    context "with an index name specified" do
-
-      let!(:andy_warhol)         { ExternalArtist.create(:full_name => 'Andy Warhol') }
-      let!(:warhol)              { ExternalArtwork.create(:title => 'Warhol') }
-
-      it "doesn't blow up if garbage is in the index collection" do
-        ExternalArtist.fulltext_search('warhol').should == [warhol, andy_warhol]
-        index_collection = ExternalArtist.collection.database[ExternalArtist.mongoid_fulltext_config.keys.first]
-        index_collection.find('document_id' => warhol.id).each do |idef|
-          index_collection.find('_id' => idef['_id']).update('document_id' => Moped::BSON::ObjectId.new)
-        end
-        # We should no longer be able to find warhol, but that shouldn't keep it from returning results
-        ExternalArtist.fulltext_search('warhol').should == [andy_warhol]
-      end
-      
-    end
-    
-    context "with an index name specified" do
-
-      let!(:pop)                { ExternalArtwork.create(:title => 'Pop') }
-      let!(:pop_culture)        { ExternalArtwork.create(:title => 'Pop Culture') }
-      let!(:contemporary_pop)   { ExternalArtwork.create(:title => 'Contemporary Pop') }
-      let!(:david_poppie)       { ExternalArtist.create(:full_name => 'David Poppie') }
-      let!(:kung_fu_lollipop)   { ExternalArtwork.create(:title => 'Kung-Fu Lollipop') }
-
-      it "prefers the best prefix that matches a given string" do
-        ExternalArtwork.fulltext_search('pop').first.should == pop
-        ExternalArtwork.fulltext_search('poppie').first.should == david_poppie
-        ExternalArtwork.fulltext_search('pop cult').first.should == pop_culture
-        ExternalArtwork.fulltext_search('pop', :max_results => 5)[4].should == kung_fu_lollipop
-      end
-
-    end
-    context "with an index name specified" do
-      
-      let!(:abc)       { ExternalArtwork.create(:title => "abc") }
-      let!(:abcd)      { ExternalArtwork.create(:title => "abcd") }
-      let!(:abcde)     { ExternalArtwork.create(:title => "abcde") }
-      let!(:abcdef)    { ExternalArtwork.create(:title => "abcdef") }
-      let!(:abcdefg)   { ExternalArtwork.create(:title => "abcdefg") }
-      let!(:abcdefgh)  { ExternalArtwork.create(:title => "abcdefgh") }
-      
-      it "returns exact matches from a list of similar prefixes" do
-        ExternalArtwork.fulltext_search('abc').first.should == abc
-        ExternalArtwork.fulltext_search('abcd').first.should == abcd
-        ExternalArtwork.fulltext_search('abcde').first.should == abcde
-        ExternalArtwork.fulltext_search('abcdef').first.should == abcdef
-        ExternalArtwork.fulltext_search('abcdefg').first.should == abcdefg
-        ExternalArtwork.fulltext_search('abcdefgh').first.should == abcdefgh
-      end
-
-    end
-    
-    context "with an index name specified" do
-
-      it "cleans up item from the index after they're destroyed" do
-        foobar = ExternalArtwork.create(:title => "foobar")
-        barfoo = ExternalArtwork.create(:title => "barfoo")
-        ExternalArtwork.fulltext_search('foobar').should == [foobar, barfoo]
-        foobar.destroy
-        ExternalArtwork.fulltext_search('foobar').should == [barfoo]
-        barfoo.destroy
-        ExternalArtwork.fulltext_search('foobar').should == []
-      end
-
-    end
-    
-    context "with an index name specified and no fields provided to index" do
-
-      let!(:big_bang) { ExternalArtworkNoFieldsSupplied.create(:title => 'Big Bang', :artist => 'David Poppie', :year => '2009') }
-
-      it "indexes the string returned by to_s" do
-        ExternalArtworkNoFieldsSupplied.fulltext_search('big bang').first.should == big_bang
-        ExternalArtworkNoFieldsSupplied.fulltext_search('poppie').first.should == big_bang
-        ExternalArtworkNoFieldsSupplied.fulltext_search('2009').first.should == big_bang
-      end
-
-    end
-    
-    context "with multiple indexes defined" do
-      
-      let!(:pop)                { MultiExternalArtwork.create(:title => 'Pop', :year => '1970', :artist => 'Joe Schmoe') }
-      let!(:pop_culture)        { MultiExternalArtwork.create(:title => 'Pop Culture', :year => '1977', :artist => 'Jim Schmoe') }
-      let!(:contemporary_pop)   { MultiExternalArtwork.create(:title => 'Contemporary Pop', :year => '1800', :artist => 'Bill Schmoe') }
-      let!(:kung_fu_lollipop)   { MultiExternalArtwork.create(:title => 'Kung-Fu Lollipop', :year => '2006', :artist => 'Michael Anderson') }
-      
-      it "allows searches to hit a particular index" do
-        title_results = MultiExternalArtwork.fulltext_search('pop', :index => 'mongoid_fulltext.titles').sort_by{ |x| x.title }
-        title_results.should == [pop, pop_culture, contemporary_pop, kung_fu_lollipop].sort_by{ |x| x.title }
-        year_results = MultiExternalArtwork.fulltext_search('197', :index => 'mongoid_fulltext.years').sort_by{ |x| x.title }
-        year_results.should == [pop, pop_culture].sort_by{ |x| x.title }
-        all_results = MultiExternalArtwork.fulltext_search('1800 and', :index => 'mongoid_fulltext.all').sort_by{ |x| x.title }
-        all_results.should == [contemporary_pop, kung_fu_lollipop].sort_by{ |x| x.title }
-      end
-
-      it "should raise an error if you don't specify which index to search with" do
-        lambda { MultiExternalArtwork.fulltext_search('foobar') }.should raise_error(Mongoid::FullTextSearch::UnspecifiedIndexError)
-      end
-
-    end
-    
-    context "with multiple fields indexed and the same index used by multiple models" do
-      
-      let!(:andy_warhol)         { MultiFieldArtist.create(:full_name => 'Andy Warhol', :birth_year => '1928') }
-      let!(:warhol)              { MultiFieldArtwork.create(:title => 'Warhol', :year => '2010') }
-      let!(:pablo_picasso)       { MultiFieldArtist.create(:full_name => 'Pablo Picasso', :birth_year => '1881') }
-      let!(:portrait_of_picasso) { MultiFieldArtwork.create(:title => 'Portrait of Picasso', :year => '1912') }
-
-      it "allows searches across all models on both fields indexed" do
-        MultiFieldArtist.fulltext_search('2010').first.should == warhol
-        MultiFieldArtist.fulltext_search('andy').first.should == andy_warhol
-        MultiFieldArtist.fulltext_search('pablo').first.should == pablo_picasso
-        MultiFieldArtist.fulltext_search('1881').first.should == pablo_picasso
-        MultiFieldArtist.fulltext_search('portrait 1912').first.should == portrait_of_picasso
-        
-        MultiFieldArtwork.fulltext_search('2010').first.should == warhol
-        MultiFieldArtwork.fulltext_search('andy').first.should == andy_warhol
-        MultiFieldArtwork.fulltext_search('pablo').first.should == pablo_picasso
-        MultiFieldArtwork.fulltext_search('1881').first.should == pablo_picasso
-        MultiFieldArtwork.fulltext_search('portrait 1912').first.should == portrait_of_picasso
-      end
-
-    end
-    context "with filters applied to multiple models" do
-      
-      let!(:foobar_artwork)    { FilteredArtwork.create(:title => 'foobar') }
-      let!(:barfoo_artwork)    { FilteredArtwork.create(:title => 'barfoo') }
-      let!(:foobar_artist)     { FilteredArtist.create(:full_name => 'foobar') }
-      let!(:barfoo_artist)     { FilteredArtist.create(:full_name => 'barfoo') }
-
-      it "allows filtered searches" do
-        FilteredArtwork.fulltext_search('foobar', :is_artwork => true).should == [foobar_artwork, barfoo_artwork]
-        FilteredArtist.fulltext_search('foobar', :is_artwork => true).should == [foobar_artwork, barfoo_artwork]
-
-        FilteredArtwork.fulltext_search('foobar', :is_artwork => true, :is_foobar => true).should == [foobar_artwork]
-        FilteredArtwork.fulltext_search('foobar', :is_artwork => true, :is_foobar => false).should == [barfoo_artwork]
-        FilteredArtwork.fulltext_search('foobar', :is_artwork => false, :is_foobar => true).should == [foobar_artist]
-        FilteredArtwork.fulltext_search('foobar', :is_artwork => false, :is_foobar => false).should == [barfoo_artist]
-
-        FilteredArtist.fulltext_search('foobar', :is_artwork => true, :is_foobar => true).should == [foobar_artwork]
-        FilteredArtist.fulltext_search('foobar', :is_artwork => true, :is_foobar => false).should == [barfoo_artwork]
-        FilteredArtist.fulltext_search('foobar', :is_artwork => false, :is_foobar => true).should == [foobar_artist]
-        FilteredArtist.fulltext_search('foobar', :is_artwork => false, :is_foobar => false).should == [barfoo_artist]
-      end
-
-    end
-
-    context "with different filters applied to multiple models" do
-      let!(:foo_artwork)    { FilteredArtwork.create(:title => 'foo') }
-      let!(:bar_artist)     { FilteredArtist.create(:full_name => 'bar') }
-      let!(:baz_other)      { FilteredOther.create(:name => 'baz') }
-
-      # These three models are all indexed by the same mongoid_fulltext index, but have different filters
-      # applied. The index created on the mongoid_fulltext collection should include the ngram and score
-      # fields as well as the union of all the filter fields to allow for efficient lookups.
-
-      it "creates a proper index for searching efficiently" do
-        [ FilteredArtwork, FilteredArtist, FilteredOther].each do |klass|
-          klass.create_indexes
-        end
-        index_collection = FilteredArtwork.collection.database['mongoid_fulltext.artworks_and_artists']
-        ngram_indexes = []
-        index_collection.indexes.each {|idef| ngram_indexes << idef if idef['key'].has_key?('ngram') }
-        ngram_indexes.length.should == 1
-        keys = ngram_indexes.first['key'].keys
-        expected_keys = ['ngram','score', 'filter_values.is_fuzzy', 'filter_values.is_awesome',
-                         'filter_values.is_foobar', 'filter_values.is_artwork', 'filter_values.is_artist', 'filter_values.colors?'].sort
-        keys.sort.should == expected_keys
-      end
-
-    end
-    
-    context "with partitions applied to a model" do
-      
-      let!(:artist_2) { PartitionedArtist.create(:full_name => 'foobar', :exhibitions => [ "Art Basel 2011", "Armory NY" ]) }
-      let!(:artist_1) { PartitionedArtist.create(:full_name => 'foobar', :exhibitions => [ "Art Basel 2011", ]) }
-      let!(:artist_0) { PartitionedArtist.create(:full_name => 'foobar', :exhibitions => [ ]) }
-
-      it "allows partitioned searches" do
-        artists_by_exhibition_length = [ artist_0, artist_1, artist_2 ].sort_by{ |x| x.exhibitions.length }
-        PartitionedArtist.fulltext_search('foobar').sort_by{ |x| x.exhibitions.length }.should == artists_by_exhibition_length
-        PartitionedArtist.fulltext_search('foobar', :exhibitions => [ "Armory NY" ]).should == [ artist_2 ]
-        art_basel_only = PartitionedArtist.fulltext_search('foobar', :exhibitions => [ "Art Basel 2011" ]).sort_by{ |x| x.exhibitions.length }
-        art_basel_only.should == [ artist_1, artist_2 ].sort_by{ |x| x.exhibitions.length }
-        PartitionedArtist.fulltext_search('foobar', :exhibitions => [ "Art Basel 2011", "Armory NY" ]).should == [ artist_2 ]
-      end
-
-    end
-
-    context "using search options" do
-      let!(:patterns)    { BasicArtwork.create(:title => 'Flower Patterns') }
-      let!(:flowers)     { BasicArtwork.create(:title => 'Flowers') }
-
-      it "returns max_results" do
-        BasicArtwork.fulltext_search('flower', { :max_results => 1 }).length.should == 1
-      end
-      
-      it "returns scored results" do
-        results = BasicArtwork.fulltext_search('flowers', { :return_scores => true })
-        first_result = results[0]
-        first_result.is_a?(Array).should be_true
-        first_result.size.should == 2
-        first_result[0].should == flowers
-        first_result[1].is_a?(Float).should be_true
-      end
-    end
-
-    context "with various word separators" do
-      let!(:hard_edged_painting)   { BasicArtwork.create(:title => "Hard-edged painting") }
-      let!(:edgy_painting)         { BasicArtwork.create(:title => "Edgy painting") }
-      let!(:hard_to_find_ledge)    { BasicArtwork.create(:title => "Hard to find ledge") }
-
-      it "should treat dashes as word separators, giving a score boost to each dash-separated word" do
-        BasicArtwork.fulltext_search('hard-edged').first.should == hard_edged_painting
-        BasicArtwork.fulltext_search('hard edge').first.should == hard_edged_painting
-        BasicArtwork.fulltext_search('hard edged').first.should == hard_edged_painting
-      end
-    end
-
-    context "returning scores" do
-      # Since we return scores, let's make some weak guarantees about what they actually mean
-      
-      let!(:mao_yan)      { ExternalArtist.create(:full_name => "Mao Yan") }
-      let!(:mao)          { ExternalArtwork.create(:title => "Mao by Andy Warhol") }
-      let!(:maox)         { ExternalArtwork.create(:title => "Maox by Randy Morehall") }
-      let!(:somao)        { ExternalArtwork.create(:title => "Somao by Randy Morehall") }
-
-      it "returns basic matches that don't match a whole word and aren't prefixes with score < 1" do
-        ['paox', 'porehall'].each do |query|
-          results = ExternalArtist.fulltext_search(query, { :return_scores => true })
-          results.length.should > 0
-          results.map{ |result| result[-1] }.inject(true){ |accum, item| accum &= (item < 1) }.should be_true
-        end
-      end
-      
-      it "returns prefix matches with a score >= 1 but < 2" do
-        ['warho', 'rand'].each do |query|
-          results = ExternalArtist.fulltext_search(query, { :return_scores => true })
-          results.length.should > 0
-          results.map{ |result| result[-1] if result[0].to_s.starts_with?(query)}.compact.inject(true){ |accum, item| accum &= (item >= 1 and item < 2) }.should be_true
-        end
-      end
-      
-      it "returns full-word matches with a score >= 2" do
-        ['andy', 'warhol', 'mao'].each do |query|
-          results = ExternalArtist.fulltext_search(query, { :return_scores => true })
-          results.length.should > 0
-          results.map{ |result| result[-1] if result[0].to_s.split(' ').member?(query) }.compact.inject(true){ |accum, item| accum &= (item >= 2) }.should be_true
-        end
-      end
-      
-    end
-
-    context "with stop words defined" do
-      let!(:flowers)      { StopwordsArtwork.create(:title => "Flowers by Andy Warhol") }
-      let!(:many_ands)    { StopwordsArtwork.create(:title => "Foo and bar and baz and foobar") }
-      let!(:harry)        { StopwordsArtwork.create(:title => "Harry in repose by JK Rowling") }
-
-      it "doesn't give a full-word score boost to stopwords" do
-        StopwordsArtwork.fulltext_search("andy").map{ |a| a.title }.should == [flowers.title, many_ands.title]
-        StopwordsArtwork.fulltext_search("warhol and other stuff").map{ |a| a.title }.should == [flowers.title, many_ands.title]
-      end
-
-      it "allows searching on words that are more than one letter, less than the ngram length and not stopwords" do
-        StopwordsArtwork.fulltext_search("jk").map{ |a| a.title }.should == [harry.title]
-        StopwordsArtwork.fulltext_search("by").map{ |a| a.title }.should == []
-      end
-
-    end
-
-    context "indexing short prefixes" do
-      let!(:dimethyl_mercury)   { ShortPrefixesArtwork.create(:title => "Dimethyl Mercury by Damien Hirst") }
-      let!(:volume)             { ShortPrefixesArtwork.create(:title => "Volume by Dadamaino") }
-      let!(:damaged)            { ShortPrefixesArtwork.create(:title => "Damaged: Photographs from the Chicago Daily News 1902-1933 (Governor) by Lisa Oppenheim") }
-      let!(:frozen)             { ShortPrefixesArtwork.create(:title => "Frozen Fountain XXX by Evelyn Rosenberg") }
-      let!(:skull)              { ShortPrefixesArtwork.create(:title => "Skull by Andy Warhol") }
-
-      it "finds the most relevant items with prefix indexing" do
-        ShortPrefixesArtwork.fulltext_search("damien").first.should == dimethyl_mercury
-        ShortPrefixesArtwork.fulltext_search("dami").first.should == dimethyl_mercury
-        ShortPrefixesArtwork.fulltext_search("dama").first.should == damaged
-        ShortPrefixesArtwork.fulltext_search("dam").first.should_not == volume
-        ShortPrefixesArtwork.fulltext_search("dadamaino").first.should == volume
-        ShortPrefixesArtwork.fulltext_search("kull").first.should == skull
-      end
-
-      it "doesn't index prefixes of stopwords" do
-        # damaged has the word "from" in it, which shouldn't get indexed.
-        ShortPrefixesArtwork.fulltext_search("fro").should == [frozen]
-      end
-
-      it "does index prefixes that would be stopwords taken alone" do
-        # skull has the word "andy" in it, which should get indexed as "and" even though "and" is a stopword
-        ShortPrefixesArtwork.fulltext_search("and").should == [skull]
-      end
-    end
-
-    context "remove_from_ngram_index" do
-      let!(:flowers1)     { BasicArtwork.create(:title => 'Flowers 1') }
-      let!(:flowers2)     { BasicArtwork.create(:title => 'Flowers 1') }
-
-      it "removes all records from the index" do
-        BasicArtwork.remove_from_ngram_index
-        BasicArtwork.fulltext_search('flower').length.should == 0
-      end
-      
-      it "removes a single record from the index" do
-        flowers1.remove_from_ngram_index
-        BasicArtwork.fulltext_search('flower').length.should == 1
-      end
-    end
-    
-    context "update_ngram_index" do
-      let!(:flowers1)     { BasicArtwork.create(:title => 'Flowers 1') }
-      let!(:flowers2)     { BasicArtwork.create(:title => 'Flowers 2') }
-
-      context "when config[:update_if] exists" do
-
-        let(:painting)          { BasicArtwork.new :title => 'Painting' }
-        let(:conditional_index) { BasicArtwork.mongoid_fulltext_config["mongoid_fulltext.index_conditional"] }
-
-        before(:all) do
-          BasicArtwork.class_eval do
-            fulltext_search_in :title, :index_name => "mongoid_fulltext.index_conditional"
-          end
-        end
-
-        after(:all) do
-          # Moped 1.0.0rc raises an error when removing a collection that does not exist
-          # Will be fixed soon.
-          begin
-            Mongoid.default_session["mongoid_fulltext.index_conditional"].drop
-          rescue Moped::Errors::OperationFailure => e
-          end
-          BasicArtwork.mongoid_fulltext_config.delete "mongoid_fulltext.index_conditional"
-        end
-
-        context "and is a symbol" do
-
-          before(:all) do
-            conditional_index[:update_if] = :persisted?
-          end
-
-          context "when sending the symbol to the document evaluates to false" do
-
-            it "doesn't update the index for the document" do
-              painting.update_ngram_index
-              BasicArtwork.fulltext_search('painting', :index => "mongoid_fulltext.index_conditional").length.should be 0
-            end
-
-          end
-        end
-
-        context "and is a string" do
-
-          before(:all) do
-            conditional_index[:update_if] = 'false'
-          end
-
-          context "when evaluating the string within the document's instance evaluates to false" do
-
-            it "doesn't update the index for the document" do
-              painting.update_ngram_index
-              BasicArtwork.fulltext_search('painting', :index => "mongoid_fulltext.index_conditional").length.should be 0
-            end
-
-          end
-        end
-
-        context "and is a proc" do
-
-          before(:all) do
-            conditional_index[:update_if] = Proc.new { false }
-          end
-
-          context "when evaluating the string within the document's instance evaluates to false" do
-
-            it "doesn't update the index for the document" do
-              painting.update_ngram_index
-              BasicArtwork.fulltext_search('painting', :index => "mongoid_fulltext.index_conditional").length.should be 0
-            end
-
-          end
-        end
-
-        context "and is not a symbol, string, or proc" do
-
-          before(:all) do
-            conditional_index[:update_if] = %w(this isn't a symbol, string, or proc)
-          end
-
-          it "doesn't update the index for the document" do
-            painting.update_ngram_index
-            BasicArtwork.fulltext_search('painting', :index => "mongoid_fulltext.index_conditional").length.should be 0
-          end
-
-        end
-      end
-
-      context "from scratch" do
-
-        before(:each) do
-          Mongoid.default_session["mongoid_fulltext.index_basicartwork_0"].drop
-        end
-
-        it "updates index on a single record" do
-          flowers1.update_ngram_index
-          BasicArtwork.fulltext_search('flower').length.should == 1
-        end
-        
-        it "updates index on all records" do
-          BasicArtwork.update_ngram_index
-          BasicArtwork.fulltext_search('flower').length.should == 2
-        end
-
-      end
-      
-      context "incremental" do
-      
-        it "removes an existing record" do
-          coll = Mongoid.default_session["mongoid_fulltext.index_basicartwork_0"]
-          coll.find('document_id' => flowers1._id).remove_all
-          coll.find('document_id' => flowers1._id).one.should == nil
-          flowers1.update_ngram_index
-        end
-        
-      end
-
-      context "mongoid indexes" do
-      
-        it "can re-create dropped indexes" do
-          # there're no indexes by default as Mongoid.autocreate_indexes is set to false
-          # but mongo will automatically attempt to index _id in the background
-          Mongoid.default_session["mongoid_fulltext.index_basicartwork_0"].indexes.count.should <= 1
-          BasicArtwork.create_indexes
-          expected_indexes = ['_id_', 'fts_index', 'document_id_1'].sort
-          current_indexes = []
-          Mongoid.default_session["mongoid_fulltext.index_basicartwork_0"].indexes.each do |idef|
-            current_indexes << idef['name']
-          end
-          current_indexes.sort.should == expected_indexes
-        end
-        
-        it "doesn't fail on models that don't have a fulltext index" do
-          lambda { HiddenDragon.create_indexes }.should_not raise_error
-        end
-
-        it "doesn't blow up when the Mongoid.logger is set to false" do
-          Mongoid.logger = false
-          BasicArtwork.create_indexes
-        end
-        
-      end
-
-    end
-
-    context "batched reindexing" do
-      let!(:flowers1) { DelayedArtwork.create(:title => 'Flowers 1') }
-
-      it "should not rebuild index until explicitly invoked" do
-        DelayedArtwork.fulltext_search("flowers").length.should == 0
-        DelayedArtwork.update_ngram_index
-        DelayedArtwork.fulltext_search("flowers").length.should == 1
-      end
-    end
-
-    # For =~ operator documentation
-    # https://github.com/dchelimsky/rspec/blob/master/lib/spec/matchers/match_array.rb#L53
-    
-    context "with artwork that returns an array of colors as a filter" do
-      let!(:title) {"title"}
-      let!(:nomatch) {"nomatch"}
-      let!(:red) {"red"}
-      let!(:green) {"green"}
-      let!(:blue) {"blue"}
-      let!(:yellow) {"yellow"}
-      let!(:brown) {"brown"}
-
-      let!(:rgb_artwork) {FilteredArtwork.create(:title => "#{title} rgb", :colors => [red,green,blue])}
-      let!(:holiday_artwork) {FilteredArtwork.create(:title => "#{title} holiday", :colors => [red,green])}
-      let!(:aqua_artwork) {FilteredArtwork.create(:title => "#{title} aqua", :colors => [green,blue])}
-
-      context "with a fulltext search passing red, green, and blue to the colors filter" do
-        it "should return the rgb artwork" do
-          FilteredArtwork.fulltext_search(title, :colors? => [red,green,blue]).should == [rgb_artwork]
-        end
-      end
-
-      context "with a fulltext search passing blue and red to the colors filter" do
-        it "should return the rgb artwork" do
-          FilteredArtwork.fulltext_search(title, :colors? => [blue,red]).should == [rgb_artwork]
-        end
-      end
-
-      context "with a fulltext search passing green to the colors filter" do
-        it "should return all artwork" do
-          FilteredArtwork.fulltext_search(title, :colors? => [green]).should =~ [rgb_artwork,holiday_artwork,aqua_artwork]
-        end
-      end
-
-      context "with a fulltext search passing no colors to the filter" do
-        it "should return all artwork" do
-          FilteredArtwork.fulltext_search(title).should =~ [rgb_artwork,holiday_artwork,aqua_artwork]
-        end
-      end
-
-      context "with a fulltext search passing green and yellow to the colors filter" do
-        it "should return no artwork" do
-          FilteredArtwork.fulltext_search(title, :colors? => [green,yellow]).should == []
-        end
-      end
-
-      context "with the query operator overridden to use $in instead of the default $all" do
-        context "with a fulltext search passing green and yellow to the colors filter" do
-          it "should return all of the artwork" do
-            FilteredArtwork.fulltext_search(title, :colors? => {:any => [green,yellow]}).should =~ [rgb_artwork,holiday_artwork,aqua_artwork]
-          end
-        end
-
-        context "with a fulltext search passing brown and yellow to the colors filter" do
-          it "should return none of the artwork" do
-            FilteredArtwork.fulltext_search(title, :colors? => {:any => [brown,yellow]}).should == []
-          end
-        end
-
-        context "with a fulltext search passing blue to the colors filter" do
-          it "should return the rgb and aqua artwork" do
-            FilteredArtwork.fulltext_search(title, :colors? => {:any => [blue]}).should == [rgb_artwork,aqua_artwork]
-          end
-        end
-
-        context "with a fulltext search term that won't match" do
-          it "should return none of the artwork" do
-            FilteredArtwork.fulltext_search(nomatch, :colors? => {:any => [green,yellow]}).should == []
-          end
-        end
-      end
-
-      context "with the query operator overridden to use $all" do
-        context "with a fulltext search passing red, green, and blue to the colors filter" do
-          it "should return the rgb artwork" do
-            FilteredArtwork.fulltext_search(title, :colors? => {:all => [red,green,blue]}).should == [rgb_artwork]
-          end
-        end
-
-        context "with a fulltext search passing green to the colors filter" do
-          it "should return all artwork" do
-            FilteredArtwork.fulltext_search(title, :colors? => {:all => [green]}).should =~ [rgb_artwork,holiday_artwork,aqua_artwork]
-          end
-        end
-      end
-
-      context "with an unknown query operator used to override the default $all" do
-        context "with a fulltext search passing red, green, and blue to the colors filter" do
-          it "should raise an error" do
-            lambda {
-              FilteredArtwork.fulltext_search(title, :colors? => {:unknown => [red,green,blue]})
-            }.should raise_error(Mongoid::FullTextSearch::UnknownFilterQueryOperator)
-          end
-        end
-      end
-
-      context "should properly work with non-latin strings (i.e. cyrillic)" do
-        let!(:morning) { RussianArtwork.create(:title => "Утро в сосновом лесу Шишкин Morning in a Pine Forest Shishkin") }
-
-        it "should find a match if query is non-latin string" do
-          # RussianArtwork is just like BasicArtwork, except that we set :alphabet to
-          # 'abcdefghijklmnopqrstuvwxyz0123456789абвгдежзиклмнопрстуфхцчшщъыьэюя'
-          RussianArtwork.fulltext_search("shishkin").first.should == morning
-          RussianArtwork.fulltext_search("шишкин").first.should == morning
-        end
-
-      end
-    end
-
-  end
-end