mongoid_fulltext 0.5.8 → 0.6.0

data/VERSION

@@ -1 +1 @@
-0.5.8
+0.6.0

data/lib/mongoid_fulltext.rb

@@ -23,7 +23,7 @@ module Mongoid::FullTextSearch
         index_name = 'mongoid_fulltext.index_%s_%s' % [self.name.downcase, self.mongoid_fulltext_config.count]
       end
 
-      config = { 
+      config = {
         :alphabet => 'abcdefghijklmnopqrstuvwxyz0123456789 ',
         :word_separators => "-_ \n\t",
         :ngram_width => 3,
@@ -34,17 +34,17 @@ module Mongoid::FullTextSearch
         :max_candidate_set_size => 1000,
         :remove_accents => true,
         :reindex_immediately => true,
-        :stop_words => Hash[['i', 'a', 's', 't', 'me', 'my', 'we', 'he', 'it', 'am', 'is', 'be', 'do', 'an', 'if', 
-                             'or', 'as', 'of', 'at', 'by', 'to', 'up', 'in', 'on', 'no', 'so', 'our', 'you', 'him', 
-                             'his', 'she', 'her', 'its', 'who', 'are', 'was', 'has', 'had', 'did', 'the', 'and', 
-                             'but', 'for', 'out', 'off', 'why', 'how', 'all', 'any', 'few', 'nor', 'not', 'own', 
-                             'too', 'can', 'don', 'now', 'ours', 'your', 'hers', 'they', 'them', 'what', 'whom', 
-                             'this', 'that', 'were', 'been', 'have', 'does', 'with', 'into', 'from', 'down', 'over', 
-                             'then', 'once', 'here', 'when', 'both', 'each', 'more', 'most', 'some', 'such', 'only', 
-                             'same', 'than', 'very', 'will', 'just', 'yours', 'their', 'which', 'these', 'those', 
-                             'being', 'doing', 'until', 'while', 'about', 'after', 'above', 'below', 'under', 
-                             'again', 'there', 'where', 'other', 'myself', 'itself', 'theirs', 'having', 'during', 
-                             'before', 'should', 'himself', 'herself', 'because', 'against', 'between', 'through', 
+        :stop_words => Hash[['i', 'a', 's', 't', 'me', 'my', 'we', 'he', 'it', 'am', 'is', 'be', 'do', 'an', 'if',
+                             'or', 'as', 'of', 'at', 'by', 'to', 'up', 'in', 'on', 'no', 'so', 'our', 'you', 'him',
+                             'his', 'she', 'her', 'its', 'who', 'are', 'was', 'has', 'had', 'did', 'the', 'and',
+                             'but', 'for', 'out', 'off', 'why', 'how', 'all', 'any', 'few', 'nor', 'not', 'own',
+                             'too', 'can', 'don', 'now', 'ours', 'your', 'hers', 'they', 'them', 'what', 'whom',
+                             'this', 'that', 'were', 'been', 'have', 'does', 'with', 'into', 'from', 'down', 'over',
+                             'then', 'once', 'here', 'when', 'both', 'each', 'more', 'most', 'some', 'such', 'only',
+                             'same', 'than', 'very', 'will', 'just', 'yours', 'their', 'which', 'these', 'those',
+                             'being', 'doing', 'until', 'while', 'about', 'after', 'above', 'below', 'under',
+                             'again', 'there', 'where', 'other', 'myself', 'itself', 'theirs', 'having', 'during',
+                             'before', 'should', 'himself', 'herself', 'because', 'against', 'between', 'through',
                              'further', 'yourself', 'ourselves', 'yourselves', 'themselves'].map{ |x| [x,true] }]
       }
       
@@ -68,45 +68,46 @@ module Mongoid::FullTextSearch
     end
 
     def fulltext_search_ensure_indexes(index_name, config)
-      db = collection.db
-      coll = db.collection(index_name)
+      db = collection.database
+      coll = db[index_name]
 
       # The order of filters matters when the same index is used from two or more collections.
       filter_indexes = (config[:filters] || []).map do |key,value|
-        ["filter_values.#{key}", Mongo::ASCENDING]
+        ["filter_values.#{key}", 1]
       end.sort_by { |filter_index| filter_index[0] }
       
-      index_definition = [['ngram', Mongo::ASCENDING], ['score', Mongo::DESCENDING]].concat(filter_indexes)
+      index_definition = [['ngram', 1], ['score', -1]].concat(filter_indexes)
 
       # Since the definition of the index could have changed, we'll clean up by
       # removing any indexes that aren't on the exact.
       correct_keys = index_definition.map{ |field_def| field_def[0] }
       all_filter_keys = filter_indexes.map{ |field_def| field_def[0] }
-      coll.index_information.each do |name, definition|
-        keys = definition['key'].keys
+      coll.indexes.each do |idef|
+        keys = idef['key'].keys
         next if !keys.member?('ngram')
         all_filter_keys |= keys.find_all{ |key| key.starts_with?('filter_values.') }
         if keys & correct_keys != correct_keys
-          Mongoid.logger.info "Dropping #{name} [#{keys & correct_keys} <=> #{correct_keys}]" if Mongoid.logger
-          coll.drop_index(name)
+          Mongoid.logger.info "Dropping #{idef['name']} [#{keys & correct_keys} <=> #{correct_keys}]" if Mongoid.logger
+          coll.indexes.drop(idef['key'])
         end
       end
 
       if all_filter_keys.length > filter_indexes.length
-        filter_indexes = all_filter_keys.map { |key| [key, Mongo::ASCENDING] }.sort_by { |filter_index| filter_index[0] }
-        index_definition = [['ngram', Mongo::ASCENDING], ['score', Mongo::DESCENDING]].concat(filter_indexes)        
+        filter_indexes = all_filter_keys.map {|key| [key, 1] }.sort_by { |filter_index| filter_index[0] }
+        index_definition = [['ngram', 1], ['score', -1]].concat(filter_indexes)
       end
       
       Mongoid.logger.info "Ensuring fts_index on #{coll.name}: #{index_definition}" if Mongoid.logger
-      coll.ensure_index(index_definition, { :name => 'fts_index' })
+      coll.indexes.create(Hash[index_definition], { :name => 'fts_index' })
+
       Mongoid.logger.info "Ensuring document_id index on #{coll.name}" if Mongoid.logger
-      coll.ensure_index([['document_id', Mongo::ASCENDING]]) # to make removes fast
+      coll.indexes.create('document_id' => 1) # to make removes fast
     end
     
     def fulltext_search(query_string, options={})
       max_results = options.has_key?(:max_results) ? options.delete(:max_results) : 10
       return_scores = options.has_key?(:return_scores) ? options.delete(:return_scores) : false
-      if self.mongoid_fulltext_config.count > 1 and !options.has_key?(:index) 
+      if self.mongoid_fulltext_config.count > 1 and !options.has_key?(:index)
         error_message = '%s is indexed by multiple full-text indexes. You must specify one by passing an :index_name parameter'
         raise UnspecifiedIndexError, error_message % self.name, caller
       end
@@ -117,12 +118,12 @@ module Mongoid::FullTextSearch
       ngrams = all_ngrams(query_string, self.mongoid_fulltext_config[index_name])
       return [] if ngrams.empty?
 
-      # For each ngram, construct the query we'll use to pull index documents and 
+      # For each ngram, construct the query we'll use to pull index documents and
       # get a count of the number of index documents containing that n-gram
-      ordering = [['score', Mongo::DESCENDING]]
+      ordering = {'score' => -1}
       limit = self.mongoid_fulltext_config[index_name][:max_candidate_set_size]
-      coll = collection.db.collection(index_name)
-      cursors = ngrams.map do |ngram| 
+      coll = collection.database[index_name]
+      cursors = ngrams.map do |ngram|
         query = {'ngram' => ngram[0]}
         query.update(map_query_filters options)
         count = coll.find(query).count
@@ -130,23 +131,23 @@ module Mongoid::FullTextSearch
       end.sort!{ |record1, record2| record1[:count] <=> record2[:count] }
 
       # Using the queries we just constructed and the n-gram frequency counts we
-      # just computed, pull in about *:max_candidate_set_size* candidates by 
-      # considering the n-grams in order of increasing frequency. When we've 
-      # spent all *:max_candidate_set_size* candidates, pull the top-scoring 
+      # just computed, pull in about *:max_candidate_set_size* candidates by
+      # considering the n-grams in order of increasing frequency. When we've
+      # spent all *:max_candidate_set_size* candidates, pull the top-scoring
       # *max_results* candidates for each remaining n-gram.
       results_so_far = 0
       candidates_list = cursors.map do |doc|
         next if doc[:count] == 0
-        query_options = {}
+        query_result = coll.find(doc[:query])
         if results_so_far >= limit
-          query_options = {:sort => ordering, :limit => max_results}
+          query_result = query_result.sort(ordering).limit(max_results)
         elsif doc[:count] > limit - results_so_far
-          query_options = {:sort => ordering, :limit => limit - results_so_far}
+          query_result = query_result.sort(ordering).limit(limit - results_so_far)
         end
         results_so_far += doc[:count]
         ngram_score = ngrams[doc[:ngram][0]]
-        Hash[coll.find(doc[:query], query_options).map do |candidate|
-               [candidate['document_id'], 
+        Hash[query_result.map do |candidate|
+               [candidate['document_id'],
                 {:clazz => candidate['class'], :score => candidate['score'] * ngram_score}]
              end]
       end.compact
@@ -161,8 +162,8 @@ module Mongoid::FullTextSearch
       while !candidates_list.empty?
         candidates = candidates_list.pop
         scores = candidates.map do |candidate_id, data|
-          {:id => candidate_id, 
-           :clazz => data[:clazz], 
+          {:id => candidate_id,
+           :clazz => data[:clazz],
            :score => data[:score] + candidates_list.map{ |others| (others.delete(candidate_id) || {:score => 0})[:score] }.sum
            }
         end
@@ -173,7 +174,7 @@ module Mongoid::FullTextSearch
     end
     
     def instantiate_mapreduce_result(result)
-      result[:clazz].constantize.find(:first, :conditions => {'_id' => result[:id]})
+      result[:clazz].constantize.find(result[:id])
     end
     
     def instantiate_mapreduce_results(results, options)
@@ -188,11 +189,15 @@ module Mongoid::FullTextSearch
       return {} if str.nil?
 
       if config[:remove_accents]
-        str = UnicodeUtils.nfkd(str).gsub(/[^\x00-\x7F]/,'')
+        if defined?(UnicodeUtils)
+          str = UnicodeUtils.nfkd(str)
+        elsif defined?(DiacriticsFu)
+          str = DiacriticsFu::escape(str)
+        end
       end
 
       # Remove any characters that aren't in the alphabet and aren't word separators
-      filtered_str = str.mb_chars.to_s.downcase.split('').find_all{ |ch| config[:alphabet][ch] or config[:word_separators][ch] }.join('')
+      filtered_str = str.mb_chars.downcase.to_s.split('').find_all{ |ch| config[:alphabet][ch] or config[:word_separators][ch] }.join('')
       
       # Figure out how many ngrams to extract from the string. If we can't afford to extract all ngrams,
       # step over the string in evenly spaced strides to extract ngrams. For example, to extract 3 3-letter
@@ -203,7 +208,7 @@ module Mongoid::FullTextSearch
         step_size = 1
       end
       
-      # Create an array of records of the form {:ngram => x, :score => y} for all ngrams that occur in the 
+      # Create an array of records of the form {:ngram => x, :score => y} for all ngrams that occur in the
       # input string using the step size that we just computed. Let score(x,y) be the score of string x
       # compared with string y - assigning scores to ngrams with the square root-based scoring function
       # below and multiplying scores of matching ngrams together yields a score function that has the
@@ -258,8 +263,8 @@ module Mongoid::FullTextSearch
     
     def remove_from_ngram_index
       self.mongoid_fulltext_config.each_pair do |index_name, fulltext_config|
-        coll = collection.db.collection(index_name)
-        coll.remove({'class' => self.name})
+        coll = collection.database[index_name]
+        coll.find({'class' => self.name}).remove_all
       end
     end
     
@@ -300,8 +305,8 @@ module Mongoid::FullTextSearch
       end
 
       # remove existing ngrams from external index
-      coll = collection.db.collection(index_name)
-      coll.remove({'document_id' => self._id})
+      coll = collection.database[index_name.to_sym]
+      coll.find({'document_id' => self._id}).remove_all
       # extract ngrams from fields
       field_values = fulltext_config[:ngram_fields].map { |field| self.send(field) }
       ngrams = field_values.inject({}) { |accum, item| accum.update(self.class.all_ngrams(item, fulltext_config, false))}
@@ -310,9 +315,9 @@ module Mongoid::FullTextSearch
       filter_values = nil
       if fulltext_config.has_key?(:filters)
         filter_values = Hash[fulltext_config[:filters].map do |key,value|
-          begin 
-            [key, value.call(self)] 
-          rescue 
+          begin
+            [key, value.call(self)]
+          rescue
             # Suppress any exceptions caused by filters
           end
         end.compact]
@@ -328,8 +333,8 @@ module Mongoid::FullTextSearch
 
   def remove_from_ngram_index
     self.mongoid_fulltext_config.each_pair do |index_name, fulltext_config|
-      coll = collection.db.collection(index_name)
-      coll.remove({'document_id' => self._id})
+      coll = collection.database[index_name]
+      coll.find({'document_id' => self._id}).remove_all
     end
   end
 

data/mongoid_fulltext.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "mongoid_fulltext"
-  s.version = "0.5.8"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aaron Windsor"]
-  s.date = "2012-03-08"
+  s.date = "2012-07-16"
   s.description = "Full-text search for the Mongoid ORM, using n-grams extracted from text"
   s.email = "aaron.windsor@gmail.com"
   s.extra_rdoc_files = [
@@ -19,6 +19,8 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
     ".rspec",
+    ".travis.yml",
+    "CHANGELOG.md",
     "Gemfile",
     "LICENSE",
     "README.md",
@@ -27,6 +29,7 @@ Gem::Specification.new do |s|
     "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",
@@ -43,6 +46,7 @@ Gem::Specification.new do |s|
     "spec/models/multi_field_artist.rb",
     "spec/models/multi_field_artwork.rb",
     "spec/models/partitioned_artist.rb",
+    "spec/models/russian_artwork.rb",
     "spec/models/short_prefixes_artwork.rb",
     "spec/models/stopwords_artwork.rb",
     "spec/mongoid/fulltext_spec.rb",
@@ -51,53 +55,31 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/aaw/mongoid_fulltext"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.10"
+  s.rubygems_version = "1.8.24"
   s.summary = "Full-text search for the Mongoid ORM"
-  s.test_files = [
-    "spec/models/accentless_artwork.rb",
-    "spec/models/advanced_artwork.rb",
-    "spec/models/basic_artwork.rb",
-    "spec/models/delayed_artwork.rb",
-    "spec/models/external_artist.rb",
-    "spec/models/external_artwork.rb",
-    "spec/models/external_artwork_no_fields_supplied.rb",
-    "spec/models/filtered_artist.rb",
-    "spec/models/filtered_artwork.rb",
-    "spec/models/filtered_other.rb",
-    "spec/models/gallery/basic_artwork.rb",
-    "spec/models/hidden_dragon.rb",
-    "spec/models/multi_external_artwork.rb",
-    "spec/models/multi_field_artist.rb",
-    "spec/models/multi_field_artwork.rb",
-    "spec/models/partitioned_artist.rb",
-    "spec/models/short_prefixes_artwork.rb",
-    "spec/models/stopwords_artwork.rb",
-    "spec/mongoid/fulltext_spec.rb",
-    "spec/spec_helper.rb"
-  ]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mongoid>, ["~> 3.0.1"])
       s.add_runtime_dependency(%q<unicode_utils>, ["~> 1.0.0"])
-      s.add_development_dependency(%q<mongoid>, ["~> 2.0.0"])
-      s.add_development_dependency(%q<bson_ext>, ["~> 1.5.2"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.5.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.10.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
     else
+      s.add_dependency(%q<mongoid>, ["~> 3.0.1"])
       s.add_dependency(%q<unicode_utils>, ["~> 1.0.0"])
-      s.add_dependency(%q<mongoid>, ["~> 2.0.0"])
-      s.add_dependency(%q<bson_ext>, ["~> 1.5.2"])
-      s.add_dependency(%q<rspec>, ["~> 2.5.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.10.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
     end
   else
+    s.add_dependency(%q<mongoid>, ["~> 3.0.1"])
     s.add_dependency(%q<unicode_utils>, ["~> 1.0.0"])
-    s.add_dependency(%q<mongoid>, ["~> 2.0.0"])
-    s.add_dependency(%q<bson_ext>, ["~> 1.5.2"])
-    s.add_dependency(%q<rspec>, ["~> 2.5.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.10.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
   end
 end
 

data/spec/config/mongoid.yml

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

data/spec/models/filtered_artwork.rb

@@ -1,8 +1,8 @@
 class FilteredArtwork
   include Mongoid::Document
   include Mongoid::FullTextSearch
-  field :title, type: String
-  field :colors, type: Array, default: []
+  field :title, :type => String
+  field :colors, :type => Array, :default => []
   fulltext_search_in :title, :index_name => 'mongoid_fulltext.artworks_and_artists',
                      :filters => { :is_foobar => lambda { |x| x.title == 'foobar' },
                                    :is_artwork => lambda { |x| true },

data/spec/models/russian_artwork.rb

@@ -0,0 +1,10 @@
+# coding: utf-8
+class RussianArtwork
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+
+  Alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789абвгдежзиклмнопрстуфхцчшщъыьэюя'
+
+  field :title
+  fulltext_search_in :title, :alphabet => Alphabet
+end

data/spec/mongoid/fulltext_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'spec_helper'
 
 module Mongoid
@@ -7,7 +8,7 @@ module Mongoid
 
       let!(:abcdef) { AdvancedArtwork.create(:title => 'abcdefg hijklmn') }
       let!(:cesar) { AccentlessArtwork.create(:title => "C\u00e9sar Galicia") }
-      let!(:julio) { AccentlessArtwork.create(:title => "Julio Cesar Morales") } 
+      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)
@@ -226,8 +227,10 @@ module Mongoid
 
       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.db.collection(ExternalArtist.mongoid_fulltext_config.keys.first)
-        index_collection.update({'document_id' => warhol.id}, {'$set' => { 'document_id' => BSON::ObjectId.new }}, :multi => true)
+        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
@@ -374,14 +377,15 @@ module Mongoid
       # 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| 
+        [ FilteredArtwork, FilteredArtist, FilteredOther].each do |klass|
           klass.create_indexes
         end
-        index_collection = FilteredArtwork.collection.db.collection('mongoid_fulltext.artworks_and_artists')
-        ngram_indexes = index_collection.index_information.find_all{ |name, definition| definition['key'].has_key?('ngram') }
+        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[1]['key'].keys
-        expected_keys = ['ngram','score', 'filter_values.is_fuzzy', 'filter_values.is_awesome', 
+        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
@@ -455,10 +459,7 @@ module Mongoid
         ['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
+          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
       
@@ -466,10 +467,7 @@ module Mongoid
         ['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
+          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
       
@@ -530,8 +528,8 @@ module Mongoid
       
       it "removes a single record from the index" do
         flowers1.remove_from_ngram_index
-        BasicArtwork.fulltext_search('flower').length.should == 1        
-      end      
+        BasicArtwork.fulltext_search('flower').length.should == 1
+      end
     end
     
     context "update_ngram_index" do
@@ -550,7 +548,12 @@ module Mongoid
         end
 
         after(:all) do
-          Mongoid.master["mongoid_fulltext.index_conditional"].remove
+          # 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
 
@@ -619,7 +622,7 @@ module Mongoid
       context "from scratch" do
 
         before(:each) do
-          Mongoid.master["mongoid_fulltext.index_basicartwork_0"].remove
+          Mongoid.default_session["mongoid_fulltext.index_basicartwork_0"].drop
         end
 
         it "updates index on a single record" do
@@ -637,9 +640,9 @@ module Mongoid
       context "incremental" do
       
         it "removes an existing record" do
-          coll = Mongoid.master["mongoid_fulltext.index_basicartwork_0"]
-          Mongoid.master.stub(:collection).with("mongoid_fulltext.index_basicartwork_0").and_return { coll }
-          coll.should_receive(:remove).once.with({'document_id' => flowers1._id})
+          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
         
@@ -650,10 +653,14 @@ module Mongoid
         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.master["mongoid_fulltext.index_basicartwork_0"].index_information.size.should <= 1
+          Mongoid.default_session["mongoid_fulltext.index_basicartwork_0"].indexes.count.should <= 1
           BasicArtwork.create_indexes
           expected_indexes = ['_id_', 'fts_index', 'document_id_1'].sort
-          Mongoid.master["mongoid_fulltext.index_basicartwork_0"].index_information.keys.sort.should == expected_indexes
+          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
@@ -768,10 +775,24 @@ module Mongoid
       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
-            -> {FilteredArtwork.fulltext_search(title, :colors? => {:unknown => [red,green,blue]})}.should raise_error(Mongoid::FullTextSearch::UnknownFilterQueryOperator)
+            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