pg_search 0.2.2 → 0.3

data/spec/pg_search/document_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe PgSearch::Document do
+  with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
+
+  with_model :Searchable do
+    table
+    model do
+      include PgSearch
+      multisearchable({})
+    end
+  end
+
+  it { should be_an(ActiveRecord::Base) }
+
+  describe "callbacks" do
+    describe "before_validation" do
+      subject { document }
+      let(:document) { PgSearch::Document.new(:searchable => searchable) }
+      let(:searchable) { Searchable.new }
+
+      before do
+        # Redefine the options for multisearchable
+        Searchable.multisearchable(multisearchable_options)
+      end
+
+      context "when searching against a single column" do
+        let(:multisearchable_options) { {:against => :some_content} }
+        let(:text) { "foo bar" }
+        before do
+          searchable.stub!(:some_content => text)
+          document.valid?
+        end
+
+        its(:content) { should == text }
+      end
+
+      context "when searching against multiple columns" do
+        let(:multisearchable_options) { {:against => [:attr1, :attr2]} }
+        before do
+          searchable.stub!(:attr1 => "1", :attr2 => "2")
+          document.valid?
+        end
+
+        its(:content) { should == "1 2" }
+      end
+    end
+  end
+end

data/spec/pg_search/multisearch_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe PgSearch::Multisearch do
+  with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
+
+  with_model :MultisearchableModel do
+    table do |t|
+      t.string :title
+      t.text :content
+      t.timestamps
+    end
+    model do
+      include PgSearch
+    end
+  end
+
+  describe ".rebuild" do
+    it "should fetch the proper columns from the model" do
+    end
+  end
+
+  describe ".rebuild_sql" do
+    context "with one attribute" do
+      it "should generate the proper SQL code" do
+        model = MultisearchableModel
+        connection = model.connection
+
+        model.multisearchable :against => :title
+
+        expected_sql = <<-SQL
+INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable_id, content)
+  SELECT #{connection.quote(model.name)} AS searchable_type,
+         #{model.quoted_table_name}.id AS searchable_id,
+         (
+           coalesce(#{model.quoted_table_name}.title, '')
+         ) AS content
+  FROM #{model.quoted_table_name}
+SQL
+
+        PgSearch::Multisearch.rebuild_sql(MultisearchableModel).should == expected_sql
+      end
+    end
+
+    context "with multiple attributes" do
+      it "should generate the proper SQL code" do
+        model = MultisearchableModel
+        connection = model.connection
+
+        model.multisearchable :against => [:title, :content]
+
+        expected_sql = <<-SQL
+INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable_id, content)
+  SELECT #{connection.quote(model.name)} AS searchable_type,
+         #{model.quoted_table_name}.id AS searchable_id,
+         (
+           coalesce(#{model.quoted_table_name}.title, '') || ' ' || coalesce(#{model.quoted_table_name}.content, '')
+         ) AS content
+  FROM #{model.quoted_table_name}
+SQL
+
+        PgSearch::Multisearch.rebuild_sql(MultisearchableModel).should == expected_sql
+      end
+    end
+
+  end
+end

data/spec/pg_search/multisearchable_spec.rb

@@ -0,0 +1,108 @@
+require File.expand_path(File.dirname(__FILE__) + '/../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
+      end
+    end
+
+    describe "callbacks" do
+      describe "after_create" 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) }
+          end
+
+          context "with multisearch disabled" do
+            before { PgSearch.stub(:multisearch_enabled?) { false } }
+            it { should_not change(PgSearch::Document, :count) }
+          end
+        end
+
+        describe "the document" do
+          subject { document }
+          before { record.save! }
+          let(:document) { PgSearch::Document.last }
+
+          its(:searchable) { should == record }
+        end
+      end
+
+      describe "after_update" do
+        let!(:record) { ModelThatIsMultisearchable.create! }
+
+        context "when the document is present" do
+          describe "saving the record" do
+            subject do
+              lambda { 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) }
+            end
+
+            context "with multisearch disabled" do
+              before { PgSearch.stub(:multisearch_enabled?) { false } }
+
+              before { record.pg_search_document.should_not_receive(:save) }
+              it { should_not change(PgSearch::Document, :count) }
+            end
+          end
+        end
+
+        context "when the document is missing" 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) }
+            end
+
+            context "with multisearch disabled" do
+              before { PgSearch.stub(:multisearch_enabled?) { false } }
+              it { should_not change(PgSearch::Document, :count) }
+            end
+          end
+        end
+      end
+
+      describe "after_destroy" do
+        it "should remove its document" do
+          record = ModelThatIsMultisearchable.create!
+          document = record.pg_search_document
+
+          lambda { record.destroy }.should change(PgSearch::Document, :count).by(-1)
+          lambda {
+            PgSearch::Document.find(document.id)
+          }.should raise_error(ActiveRecord::RecordNotFound)
+        end
+      end
+    end
+  end
+end

data/spec/pg_search_spec.rb

@@ -369,6 +369,48 @@ describe "an ActiveRecord model which includes PgSearch" do
           results.should =~ included
         end
       end
+      
+      describe "ranking" do
+        before do
+          ["Strip Down", "Down", "Down and Out", "Won't Let You Down"].each do |name|
+            ModelWithPgSearch.create! :content => name
+          end
+        end
+        
+        context "with a normalization specified" do
+          before do
+            ModelWithPgSearch.class_eval do
+              pg_search_scope :search_content_with_normalization,
+                              :against => :content,
+                              :using => {
+                                :tsearch => {:normalization => 2}
+                              }
+            end
+          end
+          it "ranks the results for documents with less text higher" do
+            results = ModelWithPgSearch.search_content_with_normalization("down")
+            
+            results.map(&:content).should == ["Down", "Strip Down", "Down and Out", "Won't Let You Down"]
+            results.first.rank.should be > results.last.rank
+          end
+        end
+        
+        context "with no normalization" do
+          before do
+            ModelWithPgSearch.class_eval do
+              pg_search_scope :search_content_without_normalization,
+                              :against => :content,
+                              :using => :tsearch
+            end
+          end
+          it "ranks the results equally" do
+            results = ModelWithPgSearch.search_content_without_normalization("down")
+            
+            results.map(&:content).should == ["Strip Down", "Down", "Down and Out", "Won't Let You Down"]
+            results.first.rank.should == results.last.rank
+          end
+        end
+      end
 
       context "against columns ranked with arrays" do
         before do
@@ -420,6 +462,33 @@ describe "an ActiveRecord model which includes PgSearch" do
           results.should == [winner, loser]
         end
       end
+
+      context "searching any_word option" do
+        before do
+          ModelWithPgSearch.class_eval do
+            pg_search_scope :search_title_with_any_word,
+                            :against => :title,
+                            :using => {
+                              :tsearch => {:any_word => true}
+                            }
+
+            pg_search_scope :search_title_with_all_words,
+                            :against => :title
+          end
+        end
+
+        it "returns all results containing any word in their title" do
+          numbers = %w(one two three four).map{|number| ModelWithPgSearch.create!(:title => number)}
+
+          results = ModelWithPgSearch.search_title_with_any_word("one two three four")
+
+          results.map(&:title).should == %w(one two three four)
+
+          results = ModelWithPgSearch.search_title_with_all_words("one two three four")
+
+          results.map(&:title).should == []
+        end
+      end
     end
 
     context "using dmetaphone" do
@@ -523,48 +592,6 @@ describe "an ActiveRecord model which includes PgSearch" do
       end
     end
 
-    context "using a tsvector column" do
-      with_model :ModelWithPgSearchUsingTsVectorColumn do
-        table do |t|
-          t.text 'content'
-          t.column 'content_tsvector', :tsvector
-        end
-
-        model { include PgSearch }
-      end
-
-      let!(:expected) { ModelWithPgSearchUsingTsVectorColumn.create!(:content => 'tiling is grouty') }
-      let!(:unexpected) { ModelWithPgSearchUsingTsVectorColumn.create!(:content => 'longcat is looooooooong') }
-
-      before do
-        ActiveRecord::Base.connection.execute <<-SQL
-          UPDATE #{ModelWithPgSearchUsingTsVectorColumn.table_name}
-          SET content_tsvector = to_tsvector('english'::regconfig, "#{ModelWithPgSearchUsingTsVectorColumn.table_name}"."content")
-        SQL
-
-        ModelWithPgSearchUsingTsVectorColumn.class_eval do
-          pg_search_scope :search_by_content_with_tsvector,
-            :against => :content,
-            :using => {
-              :tsearch => {
-                :tsvector_column => 'content_tsvector',
-                :dictionary => 'english'
-              }
-            }
-        end
-      end
-
-      if defined?(ActiveRecord::Relation)
-        it "should not use to_tsvector in the query" do
-          ModelWithPgSearchUsingTsVectorColumn.search_by_content_with_tsvector("tiles").to_sql.should_not =~ /to_tsvector/
-        end
-      end
-
-      it "should find the expected result" do
-        ModelWithPgSearchUsingTsVectorColumn.search_by_content_with_tsvector("tiles").map(&:id).should == [expected.id]
-      end
-    end
-
     context "ignoring accents" do
       before do
         ModelWithPgSearch.class_eval do
@@ -645,4 +672,83 @@ describe "an ActiveRecord model which includes PgSearch" do
       end
     end
   end
+
+  describe ".multisearchable" do
+    it "should include the Multisearchable module" do
+      ModelWithPgSearch.should_receive(:include).with(PgSearch::Multisearchable)
+      ModelWithPgSearch.multisearchable
+    end
+
+    it "should set pg_search_multisearchable_options on the class" do
+      options = double(:options)
+      ModelWithPgSearch.multisearchable(options)
+      ModelWithPgSearch.pg_search_multisearchable_options.should == options
+    end
+  end
+
+  describe ".multisearch" do
+    subject { PgSearch.multisearch(query) }
+    let(:query) { double(:query) }
+    let(:relation) { double(:relation) }
+    before do
+      PgSearch::Document.should_receive(:search).with(query).and_return(relation)
+    end
+
+    it { should == relation }
+  end
+
+  describe ".disable_multisearch" do
+    it "should temporarily disable multisearch" do
+      @multisearch_enabled_before = PgSearch.multisearch_enabled?
+      PgSearch.disable_multisearch do
+        @multisearch_enabled_inside = PgSearch.multisearch_enabled?
+      end
+      @multisearch_enabled_after = PgSearch.multisearch_enabled?
+
+      @multisearch_enabled_before.should be(true)
+      @multisearch_enabled_inside.should be(false)
+      @multisearch_enabled_after.should be(true)
+    end
+
+    it "should reenable multisearch after an error" do
+      @multisearch_enabled_before = PgSearch.multisearch_enabled?
+      begin
+        PgSearch.disable_multisearch do
+          @multisearch_enabled_inside = PgSearch.multisearch_enabled?
+          raise
+        end
+      rescue
+      end
+
+      @multisearch_enabled_after = PgSearch.multisearch_enabled?
+
+      @multisearch_enabled_before.should be(true)
+      @multisearch_enabled_inside.should be(false)
+      @multisearch_enabled_after.should be(true)
+    end
+
+    it "should not disable multisearch on other threads" do
+      values = Queue.new
+      sync = Queue.new
+      Thread.new do
+        values.push PgSearch.multisearch_enabled?
+        sync.pop # wait
+        values.push PgSearch.multisearch_enabled?
+        sync.pop # wait
+        values.push PgSearch.multisearch_enabled?
+      end
+
+      @multisearch_enabled_before = values.pop
+      PgSearch.disable_multisearch do
+        sync.push :go
+        @multisearch_enabled_inside = values.pop
+      end
+      sync.push :go
+      @multisearch_enabled_after = values.pop
+
+      @multisearch_enabled_before.should be(true)
+      @multisearch_enabled_inside.should be(true)
+      @multisearch_enabled_after.should be(true)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ require "pg_search"
 begin
   ActiveRecord::Base.establish_connection(:adapter  => 'postgresql',
                                           :database => 'pg_search_test',
+                                          :username => ('postgres' if ENV["TRAVIS"]),
                                           :min_messages => 'warning')
   connection = ActiveRecord::Base.connection
   connection.execute("SELECT 1")
@@ -45,8 +46,11 @@ RSpec.configure do |config|
   config.extend WithModel
 end
 
-if defined?(ActiveRecord::Relation)
-  RSpec::Matchers::OperatorMatcher.register(ActiveRecord::Relation, '=~', RSpec::Matchers::MatchArray)
+RSpec::Matchers::OperatorMatcher.register(ActiveRecord::Relation, '=~', RSpec::Matchers::MatchArray)
+
+DOCUMENTS_SCHEMA = lambda do |t|
+  t.belongs_to :searchable, :polymorphic => true
+  t.text :content
 end
 
 require 'irb'