search_magic 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in search_magic.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    search_magic (0.0.1)
+      mongoid (>= 2.0.0.rc.7)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.4)
+      activesupport (= 3.0.4)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activesupport (3.0.4)
+    bson (1.2.4)
+    bson_ext (1.2.4)
+    builder (2.1.2)
+    database_cleaner (0.6.4)
+    diff-lcs (1.1.2)
+    i18n (0.5.0)
+    mongo (1.2.4)
+      bson (>= 1.2.4)
+    mongoid (2.0.0.rc.7)
+      activemodel (~> 3.0)
+      mongo (~> 1.2)
+      tzinfo (~> 0.3.22)
+      will_paginate (~> 3.0.pre)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    tzinfo (0.3.24)
+    will_paginate (3.0.pre2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bson_ext
+  database_cleaner
+  mongoid (>= 2.0.0.rc.7)
+  rspec
+  search_magic!

data/README.textile

@@ -0,0 +1,129 @@
+h1. SearchMagic
+
+SearchMagic provides full-text search capabilities to "mongoid":http://github.com/mongoid/mongoid documents, embedded documents, and referenced documents with a clean, consistent, and easy to use syntax. Searching can be performed on either word fragments, such as *foo*, or can use a selector-syntax, *foo:bar*, to target which fields of the document the search is to be restricted to.
+
+h2. Installation
+
+SearchMagic is built on top of the latest pre-release version of mongoid; in all likelihood, it will only work with versions greater than or equal to _2.0.0.rc.7_. For environments where bundler is being used, it can be installed by adding the following to your Gemfile and running @bundle@.
+
+bc. gem 'search_magic'
+
+h2. Getting Started
+
+h3. Adding FullTextSearch capabilities
+
+Adding FullTextSearch is as simple as including the appropriate module into a mongoid document and defining which fields are to be searchable. In the following example, the *SearchMagic::FullTextSearch* module is included and each field of the model is made searchable.
+
+bc.. class Address
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :street
+  field :city
+  field :state
+  field :post_code
+  embedded_in :person
+  
+  search_on :street
+  search_on :city
+  search_on :state
+  search_on :post_code
+end
+
+p. At this point, *Address* can be searched by calling its @:search@ method:
+
+bc. Address.search("state:ca")
+
+h3. :search_on
+
+Fields that are made searchable by :search_on have their values cached in an embedded array within each document. This array, *:searchable_values*, should contain entries of the form *field_name:value*. The selector, *field_name*, represents a filter which can be used when searching to narrow the search space; it can be manually renamed by passing the *:as* option to :search_on:
+
+bc. search_on :post_code, :as => :zip_code 
+
+The example in the previous section showcased using :search_on on basic *Mongoid::Document* fields. It can, however, be used on fields within a document which denote an association.
+
+bc.. class Person
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :name
+  embeds_one :address
+  
+  search_on :name
+  search_on :address
+end
+
+p. When an association is searched on, all of its searchable fields are automatically made searchable in the first document. In the previous example, this means that the four fields of *Address*, @[:street, :city, :state, :post_code]@ are now searchable from within *Person*. As such, each association will end up adding entries into the *:searchable_values* array. The searchable fields which are introduced from an association can be restricted by use of the *:only* and *:except* options, which may either take an array or an individual field name:
+
+bc. search_on :address, :only => [:street, :state]
+search_on :address, :except => :post_code
+
+By default, an association's fields will be prefixed by name of the association. Therefore, the previous example would add entries to *:searchable_values* with the selectors @[:address_street, :address_city, :address_state, :address_post_code]@. The *:as* option alters the prefix:
+
+bc. search_on :address, :as => :location # results in :location_street, :location_city, ...
+
+It is also possible to prevent the prefix from being added to each absorbed searchable field through use of the *:skip_prefix* option:
+
+bc. search_on :address, :skip_prefix => true # results in :street, :city, ...
+
+:skip_prefix and :as cannot be used concurrently: :skip_prefix will always take precedence. 
+
+Values added to *:searchable_values* automatically are split on whitespace and have their punctuation removed. For most cases, searches performed on models are not going to need punctuation support. However, if it is desired to keep the punctuation present on a particular field, that can easily be done through the *:keep_punctuation* option:
+
+bc.. class Asset
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :tags, :type => Array
+  
+  search_on :tags, :keep_punctuation => true
+end
+
+p. Now all entries within *:searchable_values* for *:tags* will retain meaningful punctuation. The previous example is interesting for another reason: embedded arrays are handled specially. Specifically, the selector for an embedded array will be singularized. In the case of the previous example, this would result in a selector of "tag".
+
+Finally, it should be noted that nesting of searchable documents is possible. (Currently, cyclic searches, where, for documents A and B, A searching on B which also searches on A should be avoided. Doing so is not prohibited, but will likely cause the environment to crash.) If a given document searches on an association with another document which, in and of itself, searches on a third document, the first automatically has access to the third document's searchable fields.
+
+bc.. class Part
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :serial
+  references_in :part_number
+  
+  search_on :serial
+  search_on :part_number, :skip_prefix => true
+end
+
+class PartNumber
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :value
+  references_many :parts
+  referenced_in :part_category
+  
+  search_on :number
+  search_on :part_category, :as => :category
+end
+
+class PartCategory
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :name
+  references_many :part_numbers
+  
+  search_on :name
+end
+
+p. *PartNumber* will be able to search on both _:number_ and _:category_name_. *Part*, on the other hand, will absorb all of the searchable fields of PartNumber, including its associations. So, it can be searched on _:serial_, _:number_, and _:category_name_
+
+h3. :search
+
+Searching a model with SearchMagic is simple: each model gains a class method called _:search_ which accepts one parameter, the search pattern. This method is a "mongoid scope":http://mongoid.org/docs/querying/; it will always return a criteria object after executing. As such, it plays nicely with other scopes on your models.
+
+SearchMagic expects the incoming _pattern_ to be a string containing whitespace delimited phrases. Each phrase can either be a single word, or a _selector:value_ pair. Multiple phrases will narrow the search field: each additional phrase places an additional requirement on a matching document. Single word phrases are matched across all entries in a model's _:searchable_values_ array. The pairs, on the other hand, restrict the search for _value_ against only those entries which match _selector_. In either case, _word_ or _value_ may contain fragments of whole entries stored within _:searchable_values_.
+
+Using the models defined in the previous section, the following searches are all perfectly valid:
+
+bc. Part.search("table") # full text search on "table"
+Part.search("category_name:table") # restricts the search for "table" to "category_name"
+Part.search("bike serial:b1234") # full text search on "bike", with an extra requirement that the serial be "b1234"
+
+h2. Problems? Comments?
+
+Feel free to add an "issue on GitHub":search_magic/issues or fork the project and send a pull request. I'm always looking for new ways of bending hardware to my will, so suggestions are welcome.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/search_magic/full_text_search.rb

@@ -0,0 +1,104 @@
+module SearchMagic
+  module FullTextSearch
+    module ClassMethods
+      def self.extended(receiver)
+        receiver.send :class_attribute, :searchable_fields, :instance_writer => false
+        receiver.send :searchable_fields=, {}
+        receiver.send :field, :searchable_values, :type => Array, :default => []
+        receiver.send :before_save, :update_searchable_values
+      end
+      
+      def search_on(field_name, options = {})
+        metadata = reflect_on_association(field_name)
+        send(:searchable_fields)[field_name] = Metadata.new(:field_name => field_name, :field => fields[field_name.to_s], :association => metadata, :options => options)
+      end
+      
+      def searchables
+        @searchables ||= Hash[*searchable_fields.values.map {|metadata| metadata.searchable_names(nil).map {|a| [a.first, a.last]}}.flatten].tap do |hash|
+          hash.keys.each do |name|
+            if self.method_defined?(name) && reflect_on_association(name).nil?
+              alias_method(:"_#{name}", name)
+            else
+              define_method(:"_#{name}") {find_searchable_value(name)}
+            end
+          end
+        end
+      end
+      
+      def search(pattern)
+        rval = /("[^"]+"|\S+)/
+        rsearch = /(?:(#{searchables.keys.join('|')}):#{rval})|#{rval}/i
+        unless pattern.blank?
+          terms = pattern.scan(rsearch).map(&:compact).map do |term|
+            term.last.scan(/\b(\S+)\b/).flatten.map do |word|
+              /#{term.length > 1 ? Regexp.escape(term.first) : '[^:]+'}:.*#{Regexp.escape(word)}/i
+            end
+          end.flatten
+          all_in(:searchable_values => terms)
+        else
+          criteria
+        end
+      end
+    end
+  
+    module InstanceMethods
+      private
+      
+      def update_searchable_values
+        send :searchable_values=, self.searchable_fields.values.map {|metadata| metadata.searchable_value(self)}.flatten
+      end
+      
+      def find_searchable_value(name)
+        matches = self.searchable_values.grep(/^#{name}:(.*)/){$1}
+        matches.count == 1 ? matches.first : matches
+      end
+    end
+    
+    class Metadata
+      attr_accessor :field_name, :field, :association, :options
+
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          send(:"#{key}=", value)
+        end
+        options[:only] = [options[:only]].flatten.compact
+        options[:except] = [options[:except]].flatten.compact
+      end
+      
+      def searchable_value(model)
+        searchable_names(model).map {|searchable_name, value, sub_name, options| value_for(searchable_name, value, sub_name, options)}
+      end
+      
+      def searchable_names(model)
+        name = options[:skip_prefix].presence ? nil : (options[:as] || self.field_name)
+        value = model.present? ? model.send(self.field_name) : nil
+        sub_fields = self.association.class_name.constantize.searchables if self.association
+        fields = (sub_fields.keys - options[:except]) & (options[:only].blank? ? sub_fields.keys : options[:only]) if sub_fields
+        case self.association.try(:macro)
+        when nil
+          [[self.field.type == Array ? name.to_s.singularize.to_sym : name, value, nil, self.options]]
+        when :embedded_in, :embeds_one, :referenced_in, :references_one
+          fields.map {|sub_name| [create_nested_name(name, sub_name), value, sub_name, self.options.merge(sub_fields[sub_name])]}
+        else
+          fields.map {|sub_name| [create_nested_name(name.to_s.singularize, sub_name.to_s.pluralize), value, sub_name, self.options.merge(sub_fields[sub_name])]}
+        end
+      end
+      
+      def create_nested_name(owning_name, sub_name)
+        [owning_name, sub_name].compact.join("_").to_sym
+      end
+      
+      def value_for(searchable_name, value, field_name, options)
+        v = field_name.present? && value.present? ? [value].flatten.map{|i| i.send("_#{field_name}")} : value
+        v = v.is_a?(Array) ? v.join(" ") : v.to_s
+        v = v.gsub(/[[:punct:]]/, '') unless options[:keep_punctuation]
+        v.downcase.split.map {|word| [searchable_name, word].join(":")}
+      end
+    end
+  
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+end

data/lib/search_magic/version.rb

@@ -0,0 +1,3 @@
+module SearchMagic
+  VERSION = "0.0.1"
+end

data/lib/search_magic.rb

@@ -0,0 +1,3 @@
+module SearchMagic
+  require 'search_magic/full_text_search'
+end

data/search_magic.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "search_magic/version"
+
+Gem::Specification.new do |s|
+  s.name        = "search_magic"
+  s.version     = SearchMagic::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Joshua Bowers"]
+  s.email       = ["joshua.bowers+code@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{SearchMagic provides scoped full text search and sort capabilities to Mongoid documents}
+  s.description = %q{Adds scopes to a Mongoid document providing search and sort capabilities on arbitrary fields and associations.}
+  
+  s.add_dependency("mongoid", ">= 2.0.0.rc.7")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("database_cleaner")
+  s.add_development_dependency("bson_ext")
+
+  s.rubyforge_project = "search_magic"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/models/address.rb

@@ -0,0 +1,14 @@
+class Address
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :street
+  field :city
+  field :state
+  field :post_code
+  embedded_in :person
+  
+  search_on :street
+  search_on :city
+  search_on :state
+  search_on :post_code
+end

data/spec/models/asset.rb

@@ -0,0 +1,12 @@
+class Asset
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :title
+  field :description
+  field :tags, :type => Array, :default => []
+  field :uuid
+  
+  search_on :title
+  search_on :description
+  search_on :tags, :keep_punctuation => true
+end

data/spec/models/no_searchables.rb

@@ -0,0 +1,5 @@
+class NoSearchables
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :foo
+end

data/spec/models/part.rb

@@ -0,0 +1,12 @@
+class Part
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :serial
+  field :status
+  
+  referenced_in :part_number
+  
+  search_on :serial
+  search_on :status
+  search_on :part_number, :skip_prefix => true
+end

data/spec/models/part_category.rb

@@ -0,0 +1,9 @@
+class PartCategory
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :name
+  
+  references_many :part_numbers
+  
+  search_on :name
+end

data/spec/models/part_number.rb

@@ -0,0 +1,11 @@
+class PartNumber
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :value
+  
+  references_many :parts
+  referenced_in :part_category
+  
+  search_on :value, :as => :part_number
+  search_on :part_category, :as => :category
+end

data/spec/models/person.rb

@@ -0,0 +1,13 @@
+class Person
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :name
+  embeds_one :address
+  embeds_many :phones
+  
+  accepts_nested_attributes_for :address, :phones
+  
+  search_on :name
+  search_on :address
+  search_on :phones, :as => :mobile, :only => [:number]
+end

data/spec/models/phone.rb

@@ -0,0 +1,10 @@
+class Phone
+  include Mongoid::Document
+  include SearchMagic::FullTextSearch
+  field :country_code, :type => Integer, :default => 1
+  field :number
+  embedded_in :person
+  
+  search_on :country_code
+  search_on :number, :keep_punctuation => true
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'mongoid'
+require 'search_magic'
+
+MODELS = File.join(File.dirname(__FILE__), "models")
+
+Mongoid.configure do |config|
+  name = "search_magic_test"
+  config.master = Mongo::Connection.new.db(name)
+  config.logger = nil
+end
+
+Dir[ File.join(MODELS, "*.rb") ].sort.each {|file| require file}
+
+RSpec::configure do |config|
+  config.mock_with :rspec
+  
+  require 'database_cleaner'
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.orm = "mongoid"
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.clean
+  end
+end

data/spec/unit/search_magic/associations_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe SearchMagic::FullTextSearch do
+  describe "model includes embedded document fields in :searchable_fields" do
+    subject { Person }
+    it { subject.searchable_fields.keys.should include(:address) }
+    it { subject.searchable_fields.keys.should include(:phones) }
+    it { should respond_to(:searchables)}
+    its(:searchables) { should include(:address_street, :address_city, :address_state, :address_post_code, :mobile_numbers)}
+  end
+  
+  describe "model includes referenced document fields in :searchable_fields" do
+    subject { Part }
+    it { subject.searchable_fields.keys.should include(:part_number) }
+    its(:searchables) { should include(:part_number, :category_name) }
+  end
+  
+  context "when a model embeds one other document" do
+    before(:each) do
+      Person.create(:name => "Joshua", :address => {:street => "123 Example St.", :city => "Nowhereland", :state => "CA", :post_code => 12345}, :phones => [{:country_code => 1, :number => "555-1234"}, {:country_code => 2, :number => "333-7890"}])
+      Person.create(:name => "Samuel", :address => {:street => "4010 Arbitrary Ave.", :city => "New Somewhere", :state => "MO", :post_code => 54321}, :phones => [{:country_code => 5, :number => "444-4321"}, {:country_code => 1, :number => "555-0987"}])
+    end
+    
+    describe "model should have embedded document fields in :searchable_values" do
+      subject { Person.where(:name => "Joshua").first }
+      its(:address) { should_not be_nil }
+      its(:phones) { should_not be_empty }
+      its(:searchable_values) { should include("address_street:123", "address_street:example", "address_street:st") }
+      it { should respond_to(:_address_street, :_address_city, :_address_state, :_address_post_code, :_mobile_numbers)}
+      its(:_address_street) { should include("123", "example", "st") }
+      its(:_address_state) { should == "ca" }
+      its(:_address_city) { should == "nowhereland" }
+      its(:_address_post_code) { should == "12345" }
+      its(:_mobile_numbers) { should include("555-1234", "333-7890") }
+    end
+    
+    context "when searching for 'address_city:nowhereland'" do
+      subject { Person.search("address_city:nowhereland") }
+      its("selector.keys") { should include(:searchable_values) }
+      its(:count) { should == 1 }
+      its("first.name") { should == "Joshua" }
+    end
+    
+    context "when searching for 'arbitrary address_post_code:54321'" do
+      subject { Person.search("arbitrary address_post_code:54321") }
+      its(:count) { should == 1 }
+      its("first.name") { should == "Samuel" }
+    end
+  end
+  
+  context "when a model references other documents" do
+    before(:each) do
+      PartCategory.create(:name => "Table").tap do |category|
+        category.part_numbers.create(:value => "T11001").tap do |number|
+          number.parts.create(:status => "available", :serial => "T0411001")
+          number.parts.create(:status => "broken", :serial => "T0511010")
+        end
+        category.part_numbers.create(:value => "T11002").tap do |number|
+          number.parts.create(:status => "available", :serial => "T0411037")
+          number.parts.create(:status => "broken", :serial => "T0511178")
+        end
+      end
+      PartCategory.create(:name => "Chair").tap do |category|
+        category.part_numbers.create(:value => "C11001").tap do |number|
+          number.parts.create(:status => "available", :serial => "C0411001")
+          number.parts.create(:status => "broken", :serial => "C0511010")
+        end
+        category.part_numbers.create(:value => "C11002").tap do |number|
+          number.parts.create(:status => "available", :serial => "C0411001")
+          number.parts.create(:status => "broken", :serial => "C0511010")
+        end
+      end
+    end
+    
+    context "when a model directly references another document" do
+      describe "model should have referenced document fields in :searchable_values" do
+        subject { PartNumber.where(:value => "T11001").first }
+        it { should be }
+        its(:part_category) { should_not be_nil }
+        its(:searchable_values) { should include("part_number:t11001", "category_name:table") }
+      end
+    
+      context "when searching for 'category_name:table'" do
+        subject { PartNumber.search("category_name:table").map(&:value) }
+        its(:count) { should == 2 }
+        it { should include("T11001", "T11002") }
+      end
+    
+      context "when searching for '11001'" do
+        subject { PartNumber.search("11001").map(&:value) }
+        its(:count) { should == 2 }
+        it { should include("T11001", "C11001") }
+      end
+    end
+    
+    context "when a model references a document which references another document" do
+      describe "model should have :searchables from the indirect reference" do
+        subject { Part.where(:serial => "T0411001").first }
+        it { Part.count.should == 8 }
+        it { should be }
+        its(:part_number) { should_not be_nil }
+        its(:searchable_values) { should include("part_number:t11001", "category_name:table", "status:available", "serial:t0411001") }
+        its(:_part_number) { should == "t11001" }
+        its(:_category_name) { should == "table" }
+        its(:_status) { should == "available" }
+        its(:_serial) { should == "T0411001" }
+      end
+      
+      context "when searching for 'category_name:table'" do
+        subject { Part.search("category_name:table").map(&:serial) }
+        its(:count) { should == 4 }
+        it { should include("T0411001", "T0511010", "T0411037", "T0511178") }
+      end
+      
+      context "when searching for 'broken chair'" do
+        subject { Part.search("broken chair").map(&:serial) }
+        its(:count) { should == 2 }
+        it { should include("C0511010", "C0511010") }
+      end
+      
+      context "when searching for 'part_number:T11001'" do
+        subject { Part.search("part_number:T11001").map(&:serial) }
+        its(:count) { should == 2 }
+        it { should include("T0411001", "T0511010") }
+      end
+    end
+  end
+end

data/spec/unit/search_magic/fields_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe SearchMagic::FullTextSearch do
+  context "when included in a model without :searchables" do
+    subject { NoSearchables }
+    
+    it { should respond_to(:search_on).with(2).arguments }
+    
+    it { should respond_to(:searchable_fields) }
+    its(:searchable_fields) { should be_a(Hash) }  
+    its(:searchable_fields) { should be_blank }
+    
+    its("fields.keys") { should include("searchable_values") }
+    describe "searchable_values" do
+      subject { NoSearchables.fields["searchable_values"] }
+      its(:type) { should == Array }
+      its(:default) { should == [] }
+    end
+    
+    it { should respond_to(:search).with(1).argument }
+  end
+  
+  context "when :search_on called with [:title, :description, :tags]" do
+    subject { Asset }
+    its("searchable_fields.keys") { should include(:title, :description, :tags) }
+    its("searchable_fields.keys") { should_not include(:uuid) }
+    
+    its(:searchables) { should include(:title, :description, :tag) }
+    its(:searchables) { should_not include(:uuid) }
+  end
+  
+  describe "saving a model should run the :update_searchable_values callback" do
+    subject { Asset.new }
+    after(:each) { subject.save }
+    it { subject.should_receive :update_searchable_values }
+  end
+  
+  context "when a model is saved, its :_searchable_values update" do
+    subject { Asset.new(:title => "Foo Bar: The Bazzening", :description => "Sequel to last years hit summer blockbuster.", :tags => ["movies", "foo.bar", "the-bazzening"], :uuid => "ae9d14ee-be93-11df-9fec-78ca39fffe11")}
+    before(:each) { subject.save }
+    its(:searchable_values) { should_not be_empty }
+    its(:searchable_values) { should include("title:foo", "title:bar", "title:the", "title:bazzening")}
+    its(:searchable_values) { should include("description:sequel", "description:to", "description:last", "description:years", "description:hit", "description:summer", "description:blockbuster")}
+    its(:searchable_values) { should_not include("uuid:ae9d14ee-be93-11df-9fec-78ca39fffe11", "uuid:ae9d14ee")}
+    its(:searchable_values) { should include("tag:movies", "tag:foo.bar", "tag:the-bazzening")}
+  end
+  
+  context "when :search is performed on a model without :searchables" do
+    subject { NoSearchables.search("foo") }
+    it { should be_a(Mongoid::Criteria) }
+    its(:count) { should == 0 }
+  end
+  
+  context "when :search is performed on a model with :searchables" do
+    before(:each) do
+      Asset.create(:title => "Foo Bar: The Bazzening", :description => "Sequel to last years hit summer blockbuster.", :tags => ["movies", "foo.bar", "the-bazzening"])
+      Asset.create(:title => "Undercover Foo", :description => "When a foo goes undercover, how far will he go to protect those he loves?", :tags => ["undercover.foo", "action"])
+      Asset.create(:title => "Cheese of the Damned", :description => "This is not your father's munster.", :tags => ["movies", "cheese", "munster", "horror"])
+    end
+
+    context "when searching for nil" do
+      subject { Asset.search(nil) }
+      it { should be_a(Mongoid::Criteria) }
+      its("selector.keys") { should_not include(:searchable_values) }
+    end
+    
+    context "when searching on an empty string" do
+      subject { Asset.search("") }
+      it { should be_a(Mongoid::Criteria) }
+      its("selector.keys") { should_not include(:searchable_values) }
+    end
+    
+    context "when searching for anything" do
+      subject { Asset.search("foo") }
+      it { should be_a(Mongoid::Criteria) }
+      its("selector.keys") { should include(:searchable_values) }
+    end
+    
+    context "when searching for 'foo'" do
+      subject { Asset.search("foo").map(&:title) }
+      its(:count) { should == 2 }
+      it { should include("Foo Bar: The Bazzening", "Undercover Foo") }
+    end
+    
+    context "when searching for 'title:foo'" do
+      subject { Asset.search("title:foo").map(&:title) }
+      its(:count) { should == 2 }
+      it { should include("Foo Bar: The Bazzening", "Undercover Foo") }
+    end
+    
+    context "when searching for 'description:bazzening'" do
+      subject { Asset.search("description:bazzening") }
+      its(:count) { should == 0 }
+    end
+    
+    context "when searching for 'tag:foo.bar'" do
+      subject { Asset.search("tag:foo.bar").map(&:title) }
+      its(:count) { should == 1 }
+      its(:first) { should == "Foo Bar: The Bazzening" }
+    end
+    
+    context "when searching for 'tag:movies cheese" do
+      subject { Asset.search("tag:movies cheese").map(&:title) }
+      its(:count) { should == 1 }
+      its(:first) { should == "Cheese of the Damned" }
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification 
+name: search_magic
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Joshua Bowers
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        - rc
+        - 7
+        version: 2.0.0.rc.7
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Adds scopes to a Mongoid document providing search and sort capabilities on arbitrary fields and associations.
+email: 
+- joshua.bowers+code@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.textile
+- Rakefile
+- lib/search_magic.rb
+- lib/search_magic/full_text_search.rb
+- lib/search_magic/version.rb
+- search_magic.gemspec
+- spec/models/address.rb
+- spec/models/asset.rb
+- spec/models/no_searchables.rb
+- spec/models/part.rb
+- spec/models/part_category.rb
+- spec/models/part_number.rb
+- spec/models/person.rb
+- spec/models/phone.rb
+- spec/spec_helper.rb
+- spec/unit/search_magic/associations_spec.rb
+- spec/unit/search_magic/fields_spec.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: search_magic
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: SearchMagic provides scoped full text search and sort capabilities to Mongoid documents
+test_files: 
+- spec/models/address.rb
+- spec/models/asset.rb
+- spec/models/no_searchables.rb
+- spec/models/part.rb
+- spec/models/part_category.rb
+- spec/models/part_number.rb
+- spec/models/person.rb
+- spec/models/phone.rb
+- spec/spec_helper.rb
+- spec/unit/search_magic/associations_spec.rb
+- spec/unit/search_magic/fields_spec.rb