pg_search 0.5.5 → 0.5.6

data/CHANGELOG.rdoc

@@ -1,5 +1,12 @@
 = PgSearch
 
+== 0.5.6
+
+* PgSearch#multisearchable accepts :if and :unless for conditional inclusion
+  in search documents table. (Francois Harbec)
+
+* Stop using array_to_string() in SQL since it is not indexable.
+
 == 0.5.5
 
 * Fix bug with single table inheritance.

data/Gemfile

@@ -4,6 +4,7 @@ gemspec
 
 gem "rake"
 gem "rdoc"
+gem "pry"
 
 platforms :ruby do
   gem 'pg'

data/README.rdoc

@@ -73,6 +73,20 @@ To add a model to the global search index for your application, call multisearch
 
 Whenever a record is created, updated, or destroyed, an Active Record callback will fire, leading to the creation of a corresponding PgSearch::Document record in the pg_search_documents table. The :against option can be one or several methods which will be called on the record to generate its search text.
 
+You can also pass a Proc or method name to call to determine whether or not a particular record should be included.
+
+ class Convertible < ActiveRecord::Base
+   include PgSearch
+   multisearchable :against => [:make, :model],
+                   :if => :available_in_red?
+ end
+
+ class Jalopy < ActiveRecord::Base
+   include PgSearch
+   multisearchable :against => [:make, :model],
+                   :if => lambda { |record| record.model_year > 1970 }
+ end
+
 ==== Multi-search associations
 
 Two associations are built automatically. On the original record, there is a has_one :pg_search_document association pointing to the PgSearch::Document record, and on the PgSearch::Document record there is a belongs_to :searchable polymorphic association pointing back to the original record.

data/lib/pg_search/features/feature.rb

@@ -14,12 +14,7 @@ module PgSearch
       attr_reader :query, :options, :columns, :model, :normalizer
 
       def document
-        if columns.length == 1
-          columns.first.to_sql
-        else
-          expressions = columns.map { |column| column.to_sql }.join(", ")
-          "array_to_string(ARRAY[#{expressions}], ' ')"
-        end
+        columns.map { |column| column.to_sql }.join(" || ' ' || ")
       end
 
       def normalize(expression)

data/lib/pg_search/multisearch/rebuilder.rb

@@ -1,17 +1,20 @@
 module PgSearch
   module Multisearch
     class Rebuilder
-      def initialize(model)
+      def initialize(model, time_source = Time.method(:now))
         unless model.respond_to?(:pg_search_multisearchable_options)
           raise ModelNotMultisearchable.new(model)
         end
 
         @model = model
+        @time_source = time_source
       end
 
       def rebuild
         if model.respond_to?(:rebuild_pg_search_documents)
           model.rebuild_pg_search_documents
+        elsif model.pg_search_multisearchable_options.key?(:if) || model.pg_search_multisearchable_options.key?(:unless)
+          model.find_each { |record| record.update_pg_search_document }
         else
           model.connection.execute(rebuild_sql)
         end
@@ -70,7 +73,7 @@ SQL
       end
 
       def current_time
-        connection.quote(connection.quoted_date(Time.now))
+        connection.quote(connection.quoted_date(@time_source.call))
       end
     end
   end

data/lib/pg_search/multisearchable.rb

@@ -16,10 +16,17 @@ module PgSearch
     end
 
     def update_pg_search_document
-      if self.pg_search_document
-        self.pg_search_document.save
+      if_conditions = Array(pg_search_multisearchable_options[:if])
+      unless_conditions = Array(pg_search_multisearchable_options[:unless])
+
+      should_have_document =
+        if_conditions.all? { |condition| condition.to_proc.call(self) } &&
+        unless_conditions.all? { |condition| !condition.to_proc.call(self) }
+
+      if should_have_document
+        pg_search_document ? pg_search_document.save : create_pg_search_document
       else
-        create_pg_search_document
+        pg_search_document.destroy if pg_search_document
       end
     end
   end

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.5.5"
+  VERSION = "0.5.6"
 end

data/spec/pg_search/multisearch/rebuilder_spec.rb

@@ -0,0 +1,188 @@
+require "spec_helper"
+
+describe PgSearch::Multisearch::Rebuilder do
+  with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
+
+  describe "#rebuild" do
+    context "when the model defines .rebuild_pg_search_documents" do
+      context "and multisearchable is not conditional" do
+        with_model :Model do
+          model do
+            include PgSearch
+            multisearchable
+
+            def rebuild_pg_search_documents
+            end
+          end
+        end
+
+        it "should call .rebuild_pg_search_documents" do
+          rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+          Model.should_receive(:rebuild_pg_search_documents)
+          rebuilder.rebuild
+        end
+      end
+
+      context "when multisearch is conditional" do
+        [:if, :unless].each do |conditional_key|
+          context "via :#{conditional_key}" do
+            with_model :Model do
+              table do |t|
+                t.boolean :active
+              end
+
+              model do
+                include PgSearch
+                multisearchable conditional_key => :active?
+
+                def rebuild_pg_search_documents
+                end
+              end
+            end
+
+            it "should call .rebuild_pg_search_documents" do
+              rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+              Model.should_receive(:rebuild_pg_search_documents)
+              rebuilder.rebuild
+            end
+          end
+        end
+      end
+    end
+
+    context "when the model does not define .rebuild_pg_search_documents" do
+      context "when multisearchable is not conditional" do
+        with_model :Model do
+          table do |t|
+            t.string :name
+          end
+
+          model do
+            include PgSearch
+            multisearchable :against => :name
+          end
+        end
+
+        it "should not call :rebuild_pg_search_documents" do
+          rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+
+          # stub respond_to? to return false since should_not_receive defines the method
+          original_respond_to = Model.method(:respond_to?)
+          Model.stub(:respond_to?) do |method_name, *args|
+            if method_name == :rebuild_pg_search_documents
+              false
+            else
+              original_respond_to.call(method_name, *args)
+            end
+          end
+
+          Model.should_not_receive(:rebuild_pg_search_documents)
+          rebuilder.rebuild
+        end
+
+        it "should execute the default SQL" do
+          time = DateTime.parse("2001-01-01")
+          rebuilder = PgSearch::Multisearch::Rebuilder.new(Model, lambda { time } )
+
+          expected_sql = <<-SQL
+INSERT INTO "pg_search_documents" (searchable_type, searchable_id, content, created_at, updated_at)
+  SELECT 'Model' AS searchable_type,
+         #{Model.quoted_table_name}.id AS searchable_id,
+         (
+           coalesce(#{Model.quoted_table_name}.name::text, '')
+         ) AS content,
+         '2001-01-01 00:00:00' AS created_at,
+         '2001-01-01 00:00:00' AS updated_at
+  FROM #{Model.quoted_table_name}
+          SQL
+
+          executed_sql = []
+
+          notifier = ActiveSupport::Notifications.subscribe("sql.active_record") do |name, start, finish, id, payload|
+            executed_sql << payload[:sql]
+          end
+
+          rebuilder.rebuild
+          ActiveSupport::Notifications.unsubscribe(notifier)
+
+          executed_sql.length.should == 1
+          executed_sql.first.should == expected_sql
+        end
+      end
+
+      context "when multisearchable is conditional" do
+        context "via :if" do
+          with_model :Model do
+            table do |t|
+              t.boolean :active
+            end
+
+            model do
+              include PgSearch
+              multisearchable :if => :active?
+            end
+          end
+
+          it "calls update_pg_search_document on each record" do
+            record1 = Model.create!(:active => true)
+            record2 = Model.create!(:active => false)
+
+            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+
+            # stub respond_to? to return false since should_not_receive defines the method
+            original_respond_to = Model.method(:respond_to?)
+            Model.stub(:respond_to?) do |method_name, *args|
+              if method_name == :rebuild_pg_search_documents
+                false
+              else
+                original_respond_to.call(method_name, *args)
+              end
+            end
+            Model.should_not_receive(:rebuild_pg_search_documents)
+
+            rebuilder.rebuild
+
+            record1.pg_search_document.should be_present
+            record2.pg_search_document.should_not be_present
+          end
+        end
+
+        context "via :unless" do
+          with_model :Model do
+            table do |t|
+              t.boolean :inactive
+            end
+
+            model do
+              include PgSearch
+              multisearchable :unless => :inactive?
+            end
+          end
+
+          it "calls update_pg_search_document on each record" do
+            record1 = Model.create!(:inactive => true)
+            record2 = Model.create!(:inactive => false)
+
+            rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
+
+            # stub respond_to? to return false since should_not_receive defines the method
+            original_respond_to = Model.method(:respond_to?)
+            Model.stub(:respond_to?) do |method_name, *args|
+              if method_name == :rebuild_pg_search_documents
+                false
+              else
+                original_respond_to.call(method_name, *args)
+              end
+            end
+            Model.should_not_receive(:rebuild_pg_search_documents)
+
+            rebuilder.rebuild
+
+            record1.pg_search_document.should_not be_present
+            record2.pg_search_document.should be_present
+          end
+        end
+      end
+    end
+  end
+end

data/spec/pg_search/multisearchable_spec.rb

@@ -3,14 +3,8 @@ require "spec_helper"
 describe PgSearch::Multisearchable do
   with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
 
-  before { PgSearch.stub(:multisearch_enabled?) { true } }
-
   describe "a model that is multisearchable" do
-    subject { ModelThatIsMultisearchable }
-
     with_model :ModelThatIsMultisearchable do
-      table do |t|
-      end
       model do
         include PgSearch
         multisearchable
@@ -22,27 +16,26 @@ describe PgSearch::Multisearchable do
         let(:record) { ModelThatIsMultisearchable.new }
 
         describe "saving the record" do
-          subject do
-            lambda { record.save! }
-          end
-
-          context "with multisearch enabled" do
-            before { PgSearch.stub(:multisearch_enabled?) { true } }
-            it { should change(PgSearch::Document, :count).by(1) }
+          it "should create a PgSearch::Document record" do
+            expect { record.save! }.to change(PgSearch::Document, :count).by(1)
           end
 
           context "with multisearch disabled" do
-            before { PgSearch.stub(:multisearch_enabled?) { false } }
-            it { should_not change(PgSearch::Document, :count) }
+            before { PgSearch.stub(:multisearch_enabled? => false) }
+
+            it "should not create a PgSearch::Document record" do
+              expect { record.save! }.not_to change(PgSearch::Document, :count)
+            end
           end
         end
 
         describe "the document" do
-          subject { document }
-          before { record.save! }
-          let(:document) { PgSearch::Document.last }
-
-          its(:searchable) { should == record }
+          it "should be associated to the record" do
+            record.save!
+            newest_pg_search_document = PgSearch::Document.last
+            record.pg_search_document.should == newest_pg_search_document
+            newest_pg_search_document.searchable.should == record
+          end
         end
       end
 
@@ -50,23 +43,25 @@ describe PgSearch::Multisearchable do
         let!(:record) { ModelThatIsMultisearchable.create! }
 
         context "when the document is present" do
+          before { record.pg_search_document.should be_present }
+
           describe "saving the record" do
-            subject do
-              lambda { record.save! }
+            it "calls save on the pg_search_document" do
+              record.pg_search_document.should_receive(:save)
+              record.save!
             end
 
-            context "with multisearch enabled" do
-              before { PgSearch.stub(:multisearch_enabled?) { true } }
-
-              before { record.pg_search_document.should_receive(:save) }
-              it { should_not change(PgSearch::Document, :count) }
+            it "should not create a PgSearch::Document record" do
+              expect { record.save! }.not_to change(PgSearch::Document, :count)
             end
 
             context "with multisearch disabled" do
-              before { PgSearch.stub(:multisearch_enabled?) { false } }
+              before { PgSearch.stub(:multisearch_enabled? => false) }
 
-              before { record.pg_search_document.should_not_receive(:save) }
-              it { should_not change(PgSearch::Document, :count) }
+              it "should not create a PgSearch::Document record" do
+                record.pg_search_document.should_not_receive(:save)
+                expect { record.save! }.not_to change(PgSearch::Document, :count)
+              end
             end
           end
         end
@@ -75,18 +70,16 @@ describe PgSearch::Multisearchable do
           before { record.pg_search_document = nil }
 
           describe "saving the record" do
-            subject do
-              lambda { record.save! }
-            end
-
-            context "with multisearch enabled" do
-              before { PgSearch.stub(:multisearch_enabled?) { true } }
-              it { should change(PgSearch::Document, :count).by(1) }
+            it "should create a PgSearch::Document record" do
+              expect { record.save! }.to change(PgSearch::Document, :count).by(1)
             end
 
             context "with multisearch disabled" do
-              before { PgSearch.stub(:multisearch_enabled?) { false } }
-              it { should_not change(PgSearch::Document, :count) }
+              before { PgSearch.stub(:multisearch_enabled? => false) }
+
+              it "should not create a PgSearch::Document record" do
+                expect { record.save! }.not_to change(PgSearch::Document, :count)
+              end
             end
           end
         end
@@ -96,14 +89,531 @@ describe PgSearch::Multisearchable do
         it "should remove its document" do
           record = ModelThatIsMultisearchable.create!
           document = record.pg_search_document
+          expect { record.destroy }.to change(PgSearch::Document, :count).by(-1)
+          expect { PgSearch::Document.find(document.id) }.to raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+    end
+  end
+
+  describe "a model which is conditionally multisearchable using a Proc" do
+    context "via :if" do
+      with_model :ModelThatIsMultisearchable do
+        table do |t|
+          t.boolean :multisearchable
+        end
+
+        model do
+          include PgSearch
+          multisearchable :if => lambda { |record| record.multisearchable? }
+        end
+      end
+
+      describe "callbacks" do
+        describe "after_create" do
+          describe "saving the record" do
+            context "when the condition is true" do
+              let(:record) { ModelThatIsMultisearchable.new(:multisearchable => true) }
+
+              it "should create a PgSearch::Document record" do
+                expect { record.save! }.to change(PgSearch::Document, :count).by(1)
+              end
+
+              context "with multisearch disabled" do
+                before { PgSearch.stub(:multisearch_enabled? => false) }
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+              end
+            end
+
+            context "when the condition is false" do
+              let(:record) { ModelThatIsMultisearchable.new(:multisearchable => false) }
+
+              it "should not create a PgSearch::Document record" do
+                expect { record.save! }.not_to change(PgSearch::Document, :count)
+              end
+            end
+          end
+        end
+
+        describe "after_update" do
+          let(:record) { ModelThatIsMultisearchable.create!(:multisearchable => true) }
+
+          context "when the document is present" do
+            before { record.pg_search_document.should be_present }
+
+            describe "saving the record" do
+              context "when the condition is true" do
+                it "calls save on the pg_search_document" do
+                  record.pg_search_document.should_receive(:save)
+                  record.save!
+                end
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+              end
+
+              context "when the condition is false" do
+                before { record.multisearchable = false }
+
+                it "calls destroy on the pg_search_document" do
+                  record.pg_search_document.should_receive(:destroy)
+                  record.save!
+                end
+
+                it "should remove its document" do
+                  document = record.pg_search_document
+                  expect { record.save! }.to change(PgSearch::Document, :count).by(-1)
+                  expect { PgSearch::Document.find(document.id) }.to raise_error(ActiveRecord::RecordNotFound)
+                end
+              end
+
+              context "with multisearch disabled" do
+                before do
+                  PgSearch.stub(:multisearch_enabled? => false)
+                  record.pg_search_document.should_not_receive(:save)
+                end
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+              end
+            end
+          end
+
+          context "when the document is missing" do
+            before { record.pg_search_document = nil }
 
-          expect {
-            record.destroy
-          }.to change(PgSearch::Document, :count).by(-1)
+            describe "saving the record" do
+              context "when the condition is true" do
+                it "should create a PgSearch::Document record" do
+                  expect { record.save! }.to change(PgSearch::Document, :count).by(1)
+                end
 
-          expect {
-            PgSearch::Document.find(document.id)
-          }.to raise_error(ActiveRecord::RecordNotFound)
+                context "with multisearch disabled" do
+                  before { PgSearch.stub(:multisearch_enabled? => false) }
+
+                  it "should not create a PgSearch::Document record" do
+                    expect { record.save! }.not_to change(PgSearch::Document, :count)
+                  end
+                end
+              end
+
+              context "when the condition is false" do
+                before { record.multisearchable = false }
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+              end
+            end
+          end
+        end
+
+        describe "after_destroy" do
+          let(:record) { ModelThatIsMultisearchable.create!(:multisearchable => true) }
+
+          it "should remove its document" do
+            document = record.pg_search_document
+            expect { record.destroy }.to change(PgSearch::Document, :count).by(-1)
+            expect { PgSearch::Document.find(document.id) }.to raise_error(ActiveRecord::RecordNotFound)
+          end
+        end
+      end
+    end
+
+    context "using :unless" do
+      with_model :ModelThatIsMultisearchable do
+        table do |t|
+          t.boolean :not_multisearchable
+        end
+
+        model do
+          include PgSearch
+          multisearchable :unless => lambda { |record| record.not_multisearchable? }
+        end
+      end
+
+      describe "callbacks" do
+        describe "after_create" do
+          describe "saving the record" do
+            context "when the condition is false" do
+              let(:record) { ModelThatIsMultisearchable.new(:not_multisearchable => false) }
+
+              it "should create a PgSearch::Document record" do
+                expect { record.save! }.to change(PgSearch::Document, :count).by(1)
+              end
+
+              context "with multisearch disabled" do
+                before { PgSearch.stub(:multisearch_enabled? => false) }
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+              end
+            end
+
+            context "when the condition is true" do
+              let(:record) { ModelThatIsMultisearchable.new(:not_multisearchable => true) }
+
+              it "should not create a PgSearch::Document record" do
+                expect { record.save! }.not_to change(PgSearch::Document, :count)
+              end
+            end
+          end
+        end
+
+        describe "after_update" do
+          let!(:record) { ModelThatIsMultisearchable.create!(:not_multisearchable => false) }
+
+          context "when the document is present" do
+            before { record.pg_search_document.should be_present }
+
+            describe "saving the record" do
+              context "when the condition is false" do
+                it "calls save on the pg_search_document" do
+                  record.pg_search_document.should_receive(:save)
+                  record.save!
+                end
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+
+                context "with multisearch disabled" do
+                  before do
+                    PgSearch.stub(:multisearch_enabled? => false)
+                    record.pg_search_document.should_not_receive(:save)
+                  end
+
+                  it "should not create a PgSearch::Document record" do
+                    expect { record.save! }.not_to change(PgSearch::Document, :count)
+                  end
+                end
+              end
+
+              context "when the condition is true" do
+                before { record.not_multisearchable = true }
+
+                it "calls destroy on the pg_search_document" do
+                  record.pg_search_document.should_receive(:destroy)
+                  record.save!
+                end
+
+                it "should remove its document" do
+                  document = record.pg_search_document
+                  expect { record.save! }.to change(PgSearch::Document, :count).by(-1)
+                  expect { PgSearch::Document.find(document.id) }.to raise_error(ActiveRecord::RecordNotFound)
+                end
+              end
+
+            end
+          end
+
+          context "when the document is missing" do
+            before { record.pg_search_document = nil }
+
+            describe "saving the record" do
+              context "when the condition is false" do
+                it "should create a PgSearch::Document record" do
+                  expect { record.save! }.to change(PgSearch::Document, :count).by(1)
+                end
+              end
+
+              context "when the condition is true" do
+                before { record.not_multisearchable = true }
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+              end
+
+              context "with multisearch disabled" do
+                before { PgSearch.stub(:multisearch_enabled? => false) }
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+              end
+            end
+          end
+        end
+
+        describe "after_destroy" do
+          it "should remove its document" do
+            record = ModelThatIsMultisearchable.create!
+            document = record.pg_search_document
+            expect { record.destroy }.to change(PgSearch::Document, :count).by(-1)
+            expect { PgSearch::Document.find(document.id) }.to raise_error(ActiveRecord::RecordNotFound)
+          end
+        end
+      end
+    end
+  end
+
+  describe "a model which is conditionally multisearchable using a Symbol" do
+    context "via :if" do
+      with_model :ModelThatIsMultisearchable do
+        table do |t|
+          t.boolean :multisearchable
+        end
+
+        model do
+          include PgSearch
+          multisearchable :if => :multisearchable?
+        end
+      end
+
+      describe "callbacks" do
+        describe "after_create" do
+          describe "saving the record" do
+            context "when the condition is true" do
+              let(:record) { ModelThatIsMultisearchable.new(:multisearchable => true) }
+
+              it "should create a PgSearch::Document record" do
+                expect { record.save! }.to change(PgSearch::Document, :count).by(1)
+              end
+
+              context "with multisearch disabled" do
+                before { PgSearch.stub(:multisearch_enabled? => false) }
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+              end
+            end
+
+            context "when the condition is false" do
+              let(:record) { ModelThatIsMultisearchable.new(:multisearchable => false) }
+
+              it "should not create a PgSearch::Document record" do
+                expect { record.save! }.not_to change(PgSearch::Document, :count)
+              end
+            end
+          end
+        end
+
+        describe "after_update" do
+          let!(:record) { ModelThatIsMultisearchable.create!(:multisearchable => true) }
+
+          context "when the document is present" do
+            before { record.pg_search_document.should be_present }
+
+            describe "saving the record" do
+              context "when the condition is true" do
+                it "calls save on the pg_search_document" do
+                  record.pg_search_document.should_receive(:save)
+                  record.save!
+                end
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+
+                context "with multisearch disabled" do
+                  before do
+                    PgSearch.stub(:multisearch_enabled? => false)
+                    record.pg_search_document.should_not_receive(:save)
+                  end
+
+                  it "should not create a PgSearch::Document record" do
+                    expect { record.save! }.not_to change(PgSearch::Document, :count)
+                  end
+                end
+              end
+
+              context "when the condition is false" do
+                before { record.multisearchable = false }
+
+                it "calls destroy on the pg_search_document" do
+                  record.pg_search_document.should_receive(:destroy)
+                  record.save!
+                end
+
+                it "should remove its document" do
+                  document = record.pg_search_document
+                  expect { record.save! }.to change(PgSearch::Document, :count).by(-1)
+                  expect { PgSearch::Document.find(document.id) }.to raise_error(ActiveRecord::RecordNotFound)
+                end
+              end
+            end
+          end
+
+          context "when the document is missing" do
+            before { record.pg_search_document = nil }
+
+            describe "saving the record" do
+              context "with multisearch enabled" do
+                before { PgSearch.stub(:multisearch_enabled? => true) }
+
+                context "when the condition is true" do
+                  it "should create a PgSearch::Document record" do
+                    expect { record.save! }.to change(PgSearch::Document, :count).by(1)
+                  end
+                end
+
+                context "when the condition is false" do
+                  before { record.multisearchable = false }
+
+                  it "should not create a PgSearch::Document record" do
+                    expect { record.save! }.not_to change(PgSearch::Document, :count)
+                  end
+                end
+              end
+
+              context "with multisearch disabled" do
+                before { PgSearch.stub(:multisearch_enabled? => false) }
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+              end
+            end
+          end
+        end
+
+        describe "after_destroy" do
+          let(:record) { ModelThatIsMultisearchable.create!(:multisearchable => true) }
+
+          it "should remove its document" do
+            document = record.pg_search_document
+            expect { record.destroy }.to change(PgSearch::Document, :count).by(-1)
+            expect { PgSearch::Document.find(document.id) }.to raise_error(ActiveRecord::RecordNotFound)
+          end
+        end
+      end
+    end
+
+    context "using :unless" do
+      with_model :ModelThatIsMultisearchable do
+        table do |t|
+          t.boolean :not_multisearchable
+        end
+
+        model do
+          include PgSearch
+          multisearchable :unless => :not_multisearchable?
+        end
+      end
+
+      describe "callbacks" do
+        describe "after_create" do
+          describe "saving the record" do
+            context "when the condition is true" do
+              let(:record) { ModelThatIsMultisearchable.new(:not_multisearchable => true) }
+
+              it "should not create a PgSearch::Document record" do
+                expect { record.save! }.not_to change(PgSearch::Document, :count)
+              end
+            end
+
+            context "when the condition is false" do
+              let(:record) { ModelThatIsMultisearchable.new(:not_multisearchable => false) }
+
+              it "should create a PgSearch::Document record" do
+                expect { record.save! }.to change(PgSearch::Document, :count).by(1)
+              end
+
+              context "with multisearch disabled" do
+                before { PgSearch.stub(:multisearch_enabled? => false) }
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+              end
+            end
+          end
+        end
+
+        describe "after_update" do
+          let!(:record) { ModelThatIsMultisearchable.create!(:not_multisearchable => false) }
+
+          context "when the document is present" do
+            before { record.pg_search_document.should be_present }
+
+            describe "saving the record" do
+              context "when the condition is true" do
+                before { record.not_multisearchable = true }
+
+                it "calls destroy on the pg_search_document" do
+                  record.pg_search_document.should_receive(:destroy)
+                  record.save!
+                end
+
+                it "should remove its document" do
+                  document = record.pg_search_document
+                  expect { record.save! }.to change(PgSearch::Document, :count).by(-1)
+                  expect { PgSearch::Document.find(document.id) }.to raise_error(ActiveRecord::RecordNotFound)
+                end
+              end
+
+              context "when the condition is false" do
+                it "calls save on the pg_search_document" do
+                  record.pg_search_document.should_receive(:save)
+                  record.save!
+                end
+
+                it "should not create a PgSearch::Document record" do
+                  expect { record.save! }.not_to change(PgSearch::Document, :count)
+                end
+
+                context "with multisearch disabled" do
+                  before do
+                    PgSearch.stub(:multisearch_enabled? => false)
+                    record.pg_search_document.should_not_receive(:save)
+                  end
+
+                  it "should not create a PgSearch::Document record" do
+                    expect { record.save! }.not_to change(PgSearch::Document, :count)
+                  end
+                end
+              end
+            end
+          end
+
+          context "when the document is missing" do
+            before { record.pg_search_document = nil }
+
+            describe "saving the record" do
+              context "with multisearch enabled" do
+                before { PgSearch.stub(:multisearch_enabled? => true) }
+
+                context "when the condition is true" do
+                  before { record.not_multisearchable = true }
+
+                  it "should not create a PgSearch::Document record" do
+                    expect { record.save! }.not_to change(PgSearch::Document, :count)
+                  end
+                end
+
+                context "when the condition is false" do
+                  it "should create a PgSearch::Document record" do
+                    expect { record.save! }.to change(PgSearch::Document, :count).by(1)
+                  end
+
+                  context "with multisearch disabled" do
+                    before { PgSearch.stub(:multisearch_enabled? => false) }
+
+                    it "should not create a PgSearch::Document record" do
+                      expect { record.save! }.not_to change(PgSearch::Document, :count)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        describe "after_destroy" do
+          let(:record) { ModelThatIsMultisearchable.create!(:not_multisearchable => false) }
+
+          it "should remove its document" do
+            document = record.pg_search_document
+            expect { record.destroy }.to change(PgSearch::Document, :count).by(-1)
+            expect { PgSearch::Document.find(document.id) }.to raise_error(ActiveRecord::RecordNotFound)
+          end
         end
       end
     end

metadata

@@ -1,56 +1,60 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: pg_search
-version: !ruby/object:Gem::Version
-  version: 0.5.5
+version: !ruby/object:Gem::Version 
+  hash: 7
   prerelease: 
+  segments: 
+  - 0
+  - 5
+  - 6
+  version: 0.5.6
 platform: ruby
-authors:
+authors: 
 - Case Commons, LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-16 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: !ruby/object:Gem::Requirement
+
+date: 2012-09-29 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :runtime
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        version: "3"
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '3'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '3'
   type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  name: activerecord
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '3'
-description: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's
-  full text search
-email:
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        version: "3"
+  prerelease: false
+  type: :runtime
+  name: activesupport
+  requirement: *id002
+description: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's full text search
+email: 
 - casecommons-dev@googlegroups.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .autotest
 - .gitignore
 - .rspec
@@ -89,6 +93,7 @@ files:
 - pg_search.gemspec
 - spec/associations_spec.rb
 - spec/pg_search/document_spec.rb
+- spec/pg_search/multisearch/rebuilder_spec.rb
 - spec/pg_search/multisearch_spec.rb
 - spec/pg_search/multisearchable_spec.rb
 - spec/pg_search/normalizer_spec.rb
@@ -102,38 +107,41 @@ files:
 - sql/unnest.sql
 homepage: https://github.com/Casecommons/pg_search
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-      segments:
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
       - 0
-      hash: -4514756727807360588
-required_rubygems_version: !ruby/object:Gem::Requirement
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-      segments:
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
       - 0
-      hash: -4514756727807360588
+      version: "0"
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's
-  full text search
-test_files:
+summary: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's full text search
+test_files: 
 - spec/associations_spec.rb
 - spec/pg_search/document_spec.rb
+- spec/pg_search/multisearch/rebuilder_spec.rb
 - spec/pg_search/multisearch_spec.rb
 - spec/pg_search/multisearchable_spec.rb
 - spec/pg_search/normalizer_spec.rb