mongoid_fulltext 0.3.6

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "mongoid", "~> 2.0.0"
+  gem 'database_cleaner', '~> 0.6.0'
+  gem 'rspec', '~> 2.5.0' 
+  gem "jeweler", "~> 1.5.2"
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 by Artsy, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,259 @@
+Mongoid Fulltext Search
+=======================
+
+Full-text search using n-gram matching for the Mongoid ODM. Tested on MongoDB 1.6 and above, but
+probably works on earlier versions as well.
+
+Some examples:
+--------------
+    
+Suppose you have an `Artist` model and want to index each artist's name:
+
+    class Artist
+      include Mongoid::Document
+      include Mongoid::FullTextSearch
+
+      field :first_name
+      field :last_name
+
+      def name
+        [first_name, last_name].join(' ')
+      end
+
+      fulltext_search_in :name
+    end
+
+The `fulltext_search_in` directive will index the full name of the artist, so now
+you can call:
+
+    Artist.fulltext_search("vince vangogh")
+
+which will return an array of the Artist instances that best match the search string. Most likely,
+Vincent van Gogh will be included in the results. You can index multiple fields with the same
+index, so we can get the same effect of our Artist index above using:
+
+    class Artist
+      include Mongoid::Document
+      include Mongoid::FullTextSearch
+
+      field :first_name
+      field :last_name
+
+      fulltext_search_in :first_name, :last_name
+    end
+
+To restrict the number of results returned, pass the `:max_results` parameter to `fulltext_search`:
+
+    Artist.fulltext_search("vince vangogh", { :max_results => 5 })
+
+To return a pair of `[ result, score ]` instead of an array of results, pass the `:return_scores` parameter to `fulltext_search`:
+
+    Artist.fulltext_search("vince vangogh", { :return_scores => true })
+
+If you don't specify a field to index, the default is the result of `to_s` called on the object.
+The following definition will index the first and last name of an artist:
+
+    class Artist
+      include Mongoid::Document
+      include Mongoid::FullTextSearch
+
+      field :first_name
+      field :last_name
+
+      def to_s
+        '%s %s' % [first_name, last_name]
+      end
+
+      fulltext_search_in
+    end 
+
+The full-text index is stored in a separate MongoDB collection in the same database as the
+models you're indexing. By default, the name of this collection is generated for you. Above,
+a collection named something like `mongoid_fulltext.index_artist_0` will be created to
+hold the index data. You can override this naming and provide your own collection name with 
+the :index_name parameter:
+
+    class Artwork
+      include Mongoid::Document
+      include Mongoid::FullTextSearch
+
+      field :title
+      fulltext_search_in :title, :index_name => 'mongoid_fulltext.foobar'
+    end
+
+You can also create multiple indexes on a single model, in which case you'll want to
+provide index names:
+
+    class Artwork
+      include Mongoid::Document
+      include Mongoid::FullTextSearch
+
+      field :title
+      field :artist_name
+      field :gallery_name
+      filed :gallery_address
+
+      fulltext_search_in :title, :index_name => 'title_index'
+      fulltext_search_in :artist_name, :index_name => 'artist_name_index'
+      fulltext_search_in :gallery_name, :gallery_address, :index_name => 'gallery_index'
+    end
+
+The index names are helpful now because you'll have to specify which one you want to use when you
+call `fulltext_search`:
+
+    Artwork.fulltext_search('warhol', :index => 'artist_name_index')
+
+If you have multiple indexes specified and you don't supply a name to `fulltext_search`, the
+method call will raise an exception.
+
+If you're indexing multiple models, you may find that you need to combine results to create
+a single result set. For example, if both the `Artist` model and the `Artwork` model are
+indexed for full-text search, then to get results from both, you'd have to call 
+`Artist.fulltext_search` and `Artwork.fulltext_search` and combine the results yourself. If
+your intention is instead to get the top k results from both Artists and Artworks, you can
+merge both into a single index by using the same `:external_index` parameter:
+
+    class Artwork
+      include Mongoid::Document
+      include Mongoid::FullTextSearch
+
+      field :title
+      fulltext_search_in :title, :index_name => 'artwork_and_artists'
+    end
+
+    class Artist
+      include Mongoid::Document
+      include Mongoid::FullTextSearch
+
+      field :name
+      fulltext_search_in :name, :index_name => 'artwork_and_artists'
+    end
+
+Now that these two models share the same external index collection, we can search them both through
+either model's `fulltext_search` method:
+
+    Artwork.fulltext_search('picasso')  # returns same results as Artist.fulltext_search('picasso')
+
+If you want to filter the results from full-text search, you set up filters when the indexes are
+defined. For example, suppose that in addition to wanting to use the `artwork_and_artists` index
+defined above to search for `Artwork`s or `Artist`s, we want to be able to run full-text searches
+for artists only and for artworks priced above $10,000. Instead of creating two new indexes or
+attempting to filter the results after the query is run, we can specify the filter predicates
+at the time of index definition:
+
+    class Artwork
+      include Mongoid::Document
+      include Mongoid::FullTextSearch
+
+      field :title
+      field :price
+      fulltext_search_in :title, :index_name => 'artwork_and_artists',
+                         :filters => { :is_expensive => lambda { |x| x.price > 10000 },
+                                       :has_long_name => lambda { |x| x.title.length > 20 }}
+    end
+
+    class Artist
+      include Mongoid::Document
+      include Mongoid::FullTextSearch
+
+      field :name
+      field :birth_year
+      fulltext_search_in :name, :index_name => 'artwork_and_artists',
+                         :filters => { :born_before_1900 => lambda { |x| x.birth_year < 1900 },
+                                       :has_long_name => lambda { |x| x.name.length > 20}}
+    end
+
+After defining filters, you can query for results that match particular values of filters:
+
+    # Only return artists born before 1900 that match 'foobar'
+    Artist.fulltext_search('foobar', :born_before_1900 => true)
+
+    # Return artists or artworks that match 'foobar' and have short names
+    Artist.fulltext_search('foobar', :has_long_name => false)
+
+    # Only return artworks with prices over 10000 that match 'mona lisa'
+    Artwork.fulltext_search('mona lisa', :is_expensive => true)
+
+    # Only return artworks with prices less than 10000 that match 'mona lisa'
+    Artwork.fulltext_search('mona lisa', :is_expensive => false)
+
+Note that in all of the example queries above, supplying a filter that is defined on exactly 
+one of the models will restrict the search to results from that model only. For example,
+since `:is_expensive` is defined only on `Artwork`s, a call to `fulltext_search` with either
+`:is_expensive => true` or `:is_expensive => false` will return only `Artwork` results.
+
+You can specify multiple filters per index and per model. Each filter is a predicate that will 
+be called on objects as they're inserted into the full-text index (any time the model is saved.) 
+Filters are only called on instances of models they're defined on, so in the example above, the 
+`is_expensive` filter is only applied to instances of `Artwork` and the `born_before_1900` filter 
+is only applied to instances of `Artist`, although both filters can be used when querying from 
+either model. The `has_long_name` filter, on the other hand, will return instances of both 
+`Artwork` and `Artist` since it's defined on each model.
+
+Filters shouldn't ever throw, but if they do, the filter is just ignored. If you apply filters to
+indexes that are on multiple fields, the filter is applied to each field and the filter result is
+the AND of all of the individual results for each of the fields. Finally, if a filter is defined 
+but criteria for that filter aren't passed to `fulltext_search`, the result is as if the filter 
+had never been defined - you see both models that both pass and fail the filter in the results.
+
+Indexing Options
+----------------
+
+Additional indexing/query options can be used as parameters to `fulltext_search_in`.
+
+* `alphabet`: letters to index, default is `abcdefghijklmnopqrstuvwxyz0123456789 `
+* `word_separators`: word separators, default is ` `
+* `ngram_width`: ngram width, default is `3`
+* `index_full_words`: index full words, which improves exact matches, default is `true` 
+* `apply_prefix_scoring_to_all_words`: score n-grams at beginning of words higher, default is `true`
+* `max_ngrams_to_search`: maximum number of ngrams to query at any given time, default is `6`
+
+Array filters
+-------------
+
+A filter may also return an Array. Consider the following example.
+
+    class Artist
+      include Mongoid::Document
+      include Mongoid::FullTextSearch
+
+      field :name
+      field :exhibitions, as: Array, default: []
+
+      fulltext_search_in :name, :index_name => 'exhibited_artist',
+        :filters => { 
+          :exhibitions => lambda { |artist| artist.exhibitions }
+        }
+    end
+
+You can now find all artists that are at the Art Basel exhibition or all artists that have exhibited
+at both the Art Basel and the New York Armory exhibition.
+
+    # All artists
+    Artist.fulltext_search('foobar')
+
+    # Artists at the Art Basel exhibition only
+    Artist.fulltext_search('foobar', :exhibitions => [ "Art Basel" ])
+
+    # Artists at both the Art Basel and the New York Armory exhibition
+    Artist.fulltext_search('foobar', :exhibitions => [ "Art Basel", "New York Armory" ])
+
+Building the index
+------------------
+
+The fulltext index is built and maintained incrementally by hooking into `before_save` and 
+`before_destroy` callbacks on each model that's being indexed. If you want to build an index
+on existing models, you can call the `update_ngram_index` method on each instance:
+
+    Artwork.all.each { |artwork| artwork.update_ngram_index }
+
+You can also remove instances in bulk from the index with the `remove_from_ngram_index`
+method:
+
+    Artwork.all.each { |artwork| artwork.remove_from_ngram_index }
+
+Running the specs
+-----------------
+
+To run the specs, execute `rake spec`. You need a local MongoDB instance to run the specs.
+

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require 'rspec/core/rake_task'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mongoid_fulltext"
+  gem.homepage = "http://github.com/aaw/mongoid_fulltext"
+  gem.license = "MIT"
+  gem.summary = %Q{Full-text search for the Mongoid ORM}
+  gem.description = %Q{Full-text search for the Mongoid ORM, using n-grams extracted from text}
+  gem.email = "aaron.windsor@gmail.com"
+  gem.authors = ["Aaron Windsor"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+
+desc "Run all tests"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.3.6

data/lib/mongoid_fulltext.rb

@@ -0,0 +1,183 @@
+module Mongoid::FullTextSearch
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :mongoid_fulltext_config
+  end
+
+  class UnspecifiedIndexError < StandardError; end
+
+  module ClassMethods
+
+    def fulltext_search_in(*args)
+      self.mongoid_fulltext_config = {} if self.mongoid_fulltext_config.nil?
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      if options.has_key?(:index_name)
+        index_name = options[:index_name]
+      else
+        index_name = 'mongoid_fulltext.index_%s_%s' % [self.name.downcase, self.mongoid_fulltext_config.count]
+      end
+
+      config = { 
+        :alphabet => 'abcdefghijklmnopqrstuvwxyz0123456789 ',
+        :word_separators => ' ',
+        :ngram_width => 3,
+        :max_ngrams_to_search => 6,
+        :apply_prefix_scoring_to_all_words => true,
+        :index_full_words => true
+      }
+      
+      config.update(options)
+
+      args = [:to_s] if args.empty?
+      config[:ngram_fields] = args
+      config[:alphabet] = Hash[config[:alphabet].split('').map{ |ch| [ch,ch] }]
+      config[:word_separators] = Hash[config[:word_separators].split('').map{ |ch| [ch,ch] }]
+      self.mongoid_fulltext_config[index_name] = config
+
+      coll = collection.db.collection(index_name)
+      coll.ensure_index([['ngram', Mongo::ASCENDING]])
+      coll.ensure_index([['document_id', Mongo::ASCENDING]])
+      
+      before_save :update_ngram_index
+      before_destroy :remove_from_ngram_index
+    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) 
+        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
+      index_name = options.has_key?(:index) ? options.delete(:index) : self.mongoid_fulltext_config.keys.first
+      
+      # options hash should only contain filters after this point      
+      ngrams = all_ngrams(query_string, self.mongoid_fulltext_config[index_name])
+      return [] if ngrams.empty?
+      
+      query = {'ngram' => {'$in' => ngrams.keys}}
+      query.update(Hash[options.map { |key,value| [ 'filter_values.%s' % key, { '$all' => [ value ].flatten } ] }])
+      map = <<-EOS
+        function() {
+          emit(this['document_id'], {'class': this['class'], 'score': this['score']*ngrams[this['ngram']] })
+        }
+      EOS
+      reduce = <<-EOS
+        function(key, values) {
+          score = 0.0
+          for (i in values) {
+            score += values[i]['score']
+          }
+          return({'class': values[0]['class'], 'score': score})
+        }
+      EOS
+      mr_options = {:scope => {:ngrams => ngrams }, :query => query, :raw => true}
+      rc_options = { :return_scores => return_scores }
+      coll = collection.db.collection(index_name)
+      if collection.db.connection.server_version >= '1.7.4'
+        mr_options[:out] = {:inline => 1}
+        results = coll.map_reduce(map, reduce, mr_options)['results'].sort_by{ |x| -x['value']['score'] }
+        max_results = results.count if max_results.nil?
+        instantiate_mapreduce_results(results.first(max_results), rc_options)
+      else
+        result_collection = coll.map_reduce(map, reduce, mr_options)['result']
+        results = collection.db.collection(result_collection).find.sort(['value.score',-1])
+        results = results.limit(max_results) if !max_results.nil?
+        models = instantiate_mapreduce_results(results, rc_options)
+        collection.db.collection(result_collection).drop
+        models
+      end
+    end
+    
+    def instantiate_mapreduce_result(result)
+      Object::const_get(result['value']['class']).find(:first, :conditions => {:id => result['_id']})
+    end
+    
+    def instantiate_mapreduce_results(results, options)
+      if (options[:return_scores])
+        results.map { |result| [ instantiate_mapreduce_result(result), result['value']['score'] ] }.find_all { |result| ! result[0].nil? }
+      else
+        results.map { |result| instantiate_mapreduce_result(result) }.find_all { |result| ! result.nil? }
+      end
+    end
+
+    # returns an [ngram, score] [ngram, position] pair
+    def all_ngrams(str, config, bound_number_returned = true)
+      return {} if str.nil? or str.length < config[:ngram_width]
+      filtered_str = str.downcase.split('').map{ |ch| config[:alphabet][ch] }.find_all{ |ch| !ch.nil? }.join('')
+      
+      if bound_number_returned
+        step_size = [((filtered_str.length - config[:ngram_width]).to_f / config[:max_ngrams_to_search]).ceil, 1].max
+      else
+        step_size = 1
+      end
+      
+      # array of ngrams
+      ngram_ary = (0..filtered_str.length - config[:ngram_width]).step(step_size).map do |i|
+        if i == 0 or (config[:apply_prefix_scoring_to_all_words] and \
+                      config[:word_separators].has_key?(filtered_str[i-1].chr))
+          score = Math.sqrt(1 + 1.0/filtered_str.length)
+        else
+          score = Math.sqrt(2.0/filtered_str.length)
+        end
+        [filtered_str[i..i+config[:ngram_width]-1], score]
+      end
+      
+      if (config[:index_full_words])
+        filtered_str.split(Regexp.compile(config[:word_separators].keys.join)).each do |word|
+          if word.length >= config[:ngram_width]
+            ngram_ary << [ word, 1 ]
+          end
+        end
+      end
+      
+      ngram_hash = {}
+      
+      # deduplicate, and keep the highest score
+      ngram_ary.each do |ngram, score, position|        
+        ngram_hash[ngram] = [ngram_hash[ngram] || 0, score].max
+      end
+      
+      ngram_hash
+    end
+
+  end
+
+  def update_ngram_index
+    self.mongoid_fulltext_config.each_pair do |index_name, fulltext_config|
+      # remove existing ngrams from external index
+      coll = collection.db.collection(index_name)
+      coll.remove({'document_id' => self._id})
+      # 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))}
+      return if ngrams.empty?
+      # apply filters, if necessary
+      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 
+            # Suppress any exceptions caused by filters
+          end
+        end.find_all{ |x| !x.nil? }]
+      end
+      # insert new ngrams in external index
+      ngrams.each_pair do |ngram, score|
+        index_document = {'ngram' => ngram, 'document_id' => self._id, 'score' => score, 'class' => self.class.name}
+        index_document['filter_values'] = filter_values if fulltext_config.has_key?(:filters)
+        coll.insert(index_document)
+      end
+    end
+  end
+
+  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})
+    end
+  end
+
+end

data/mongoid_fulltext.gemspec

@@ -0,0 +1,85 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mongoid_fulltext}
+  s.version = "0.3.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aaron Windsor"]
+  s.date = %q{2011-05-27}
+  s.description = %q{Full-text search for the Mongoid ORM, using n-grams extracted from text}
+  s.email = %q{aaron.windsor@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/mongoid_fulltext.rb",
+    "mongoid_fulltext.gemspec",
+    "spec/models/advanced_artwork.rb",
+    "spec/models/basic_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/multi_external_artwork.rb",
+    "spec/models/multi_field_artist.rb",
+    "spec/models/multi_field_artwork.rb",
+    "spec/models/partitioned_artist.rb",
+    "spec/mongoid/fulltext_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/aaw/mongoid_fulltext}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Full-text search for the Mongoid ORM}
+  s.test_files = [
+    "spec/models/advanced_artwork.rb",
+    "spec/models/basic_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/multi_external_artwork.rb",
+    "spec/models/multi_field_artist.rb",
+    "spec/models/multi_field_artwork.rb",
+    "spec/models/partitioned_artist.rb",
+    "spec/mongoid/fulltext_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<mongoid>, ["~> 2.0.0"])
+      s.add_development_dependency(%q<database_cleaner>, ["~> 0.6.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.5.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+    else
+      s.add_dependency(%q<mongoid>, ["~> 2.0.0"])
+      s.add_dependency(%q<database_cleaner>, ["~> 0.6.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.5.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    end
+  else
+    s.add_dependency(%q<mongoid>, ["~> 2.0.0"])
+    s.add_dependency(%q<database_cleaner>, ["~> 0.6.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.5.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+  end
+end
+

data/spec/models/advanced_artwork.rb

@@ -0,0 +1,7 @@
+class AdvancedArtwork
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+
+  field :title
+  fulltext_search_in :title, :ngram_width => 4, :alphabet => 'abcdefg'
+end

data/spec/models/basic_artwork.rb

@@ -0,0 +1,8 @@
+class BasicArtwork
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+
+  field :title
+  fulltext_search_in :title
+
+end

data/spec/models/external_artist.rb

@@ -0,0 +1,6 @@
+class ExternalArtist
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+  field :full_name
+  fulltext_search_in :full_name, :index_name => 'mongoid_fulltext.artworks_and_artists'
+end

data/spec/models/external_artwork.rb

@@ -0,0 +1,6 @@
+class ExternalArtwork
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+  field :title
+  fulltext_search_in :title, :index_name => 'mongoid_fulltext.artworks_and_artists'
+end

data/spec/models/external_artwork_no_fields_supplied.rb

@@ -0,0 +1,12 @@
+class ExternalArtworkNoFieldsSupplied
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+  field :title
+  field :year
+  field :artist
+  fulltext_search_in :index_name => 'mongoid_fulltext.artworks_and_artists'
+
+  def to_s
+    '%s (%s %s)' % [title, artist, year] 
+  end
+end

data/spec/models/filtered_artist.rb

@@ -0,0 +1,10 @@
+class FilteredArtist
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+  field :full_name
+  fulltext_search_in :full_name, :index_name => 'mongoid_fulltext.artworks_and_artists',
+                     :filters => { :is_foobar => lambda { |x| x.full_name == 'foobar' },
+                                   :is_artist => lambda { |x| true },
+                                   :is_artwork => lambda { |x| false }
+                                  }
+end

data/spec/models/filtered_artwork.rb

@@ -0,0 +1,10 @@
+class FilteredArtwork
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+  field :title
+  fulltext_search_in :title, :index_name => 'mongoid_fulltext.artworks_and_artists',
+                     :filters => { :is_foobar => lambda { |x| x.title == 'foobar' },
+                                   :is_artwork => lambda { |x| true },
+                                   :is_artist => lambda { |x| false }
+                                  }
+end

data/spec/models/multi_external_artwork.rb

@@ -0,0 +1,10 @@
+class MultiExternalArtwork
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+  field :title
+  field :year
+  field :artist
+  fulltext_search_in :title, :index_name => 'mongoid_fulltext.titles'
+  fulltext_search_in :year, :index_name => 'mongoid_fulltext.years'
+  fulltext_search_in :title, :year, :artist, :index_name => 'mongoid_fulltext.all'
+end

data/spec/models/multi_field_artist.rb

@@ -0,0 +1,7 @@
+class MultiFieldArtist
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+  field :full_name
+  field :birth_year
+  fulltext_search_in :full_name, :birth_year, :index_name => 'mongoid_fulltext.artworks_and_artists'
+end

data/spec/models/multi_field_artwork.rb

@@ -0,0 +1,7 @@
+class MultiFieldArtwork
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+  field :title
+  field :year
+  fulltext_search_in :title, :year, :index_name => 'mongoid_fulltext.artworks_and_artists'
+end

data/spec/models/partitioned_artist.rb

@@ -0,0 +1,15 @@
+class PartitionedArtist
+  include Mongoid::Document
+  include Mongoid::FullTextSearch
+  
+  field :full_name
+  field :exhibitions, type: Array, default: []
+  
+  fulltext_search_in :full_name, 
+    :index_name => 'mongoid_fulltext.partitioned_artists',
+    :filters => { 
+      :has_exhibitions => lambda { |x| x.exhibitions.size > 0 },
+      :exhibitions => lambda { |x| [ x.exhibitions ].flatten },
+    }
+
+end

data/spec/mongoid/fulltext_spec.rb

@@ -0,0 +1,348 @@
+require 'spec_helper'
+
+module Mongoid
+  describe FullTextSearch do
+
+    context "with several config options defined" do
+
+      let!(:abcdef) { AdvancedArtwork.create(:title => 'abcdefg hijklmn') }
+
+      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 == []
+      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 => '') }
+
+      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!(: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.db.collection(ExternalArtist.mongoid_fulltext_config.keys.first)
+        index_collection.update({'document_id' => warhol.id}, {'$set' => { 'document_id' => BSON::ObjectId.new }}, :multi => true)
+        # 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 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
+        PartitionedArtist.fulltext_search('foobar').should == [ artist_2, artist_1, artist_0 ]
+        PartitionedArtist.fulltext_search('foobar', :exhibitions => [ "Armory NY" ]).should == [ artist_2 ]
+        PartitionedArtist.fulltext_search('foobar', :exhibitions => [ "Art Basel 2011" ]).should == [ artist_2, artist_1 ]
+        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
+    
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+
+require 'mongoid'
+require 'database_cleaner'
+
+Mongoid.configure do |config|
+  name = "mongoid_fulltext_test"
+  config.master = Mongo::Connection.new.db(name)
+end
+
+require File.expand_path("../../lib/mongoid_fulltext", __FILE__)
+Dir["#{File.dirname(__FILE__)}/models/*.rb"].each { |f| require f }
+
+Rspec.configure do |c|
+  c.before(:all)  { DatabaseCleaner.strategy = :truncation }
+  c.before(:each) { DatabaseCleaner.clean }
+end
+

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: mongoid_fulltext
+version: !ruby/object:Gem::Version
+  version: 0.3.6
+  prerelease: 
+platform: ruby
+authors:
+- Aaron Windsor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-05-27 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: &82366030 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *82366030
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: &82365790 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *82365790
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &82365550 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: *82365550
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &82365310 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *82365310
+description: Full-text search for the Mongoid ORM, using n-grams extracted from text
+email: aaron.windsor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- .document
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/mongoid_fulltext.rb
+- mongoid_fulltext.gemspec
+- spec/models/advanced_artwork.rb
+- spec/models/basic_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/multi_external_artwork.rb
+- spec/models/multi_field_artist.rb
+- spec/models/multi_field_artwork.rb
+- spec/models/partitioned_artist.rb
+- spec/mongoid/fulltext_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/aaw/mongoid_fulltext
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Full-text search for the Mongoid ORM
+test_files:
+- spec/models/advanced_artwork.rb
+- spec/models/basic_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/multi_external_artwork.rb
+- spec/models/multi_field_artist.rb
+- spec/models/multi_field_artwork.rb
+- spec/models/partitioned_artist.rb
+- spec/mongoid/fulltext_spec.rb
+- spec/spec_helper.rb