pg_search 0.4.1 → 0.4.2

data/CHANGELOG.rdoc

@@ -1,5 +1,17 @@
 = PgSearch
 
+== 0.4.2
+
+* Fill in timestamps correctly when rebuilding multisearch documents. (Barton McGuire)
+
+* Fix various issues with rebuilding multisearch documents. (Eugen Neagoe)
+
+* Fix syntax error in pg_search_dmetaphone() migration (Casey Foster)
+
+* Rename PgSearch#rank to PgSearch#pg_search_rank and always return a Float.
+
+* Fix issue with :associated_against and non-text columns.
+
 == 0.4.1
 
 * Fix Active Record 3.2 deprecation warnings. (Steven Harman)

data/Gemfile

@@ -5,8 +5,7 @@ gemspec
 gem "rake"
 gem "rdoc"
 gem "pg"
-gem "rspec", ">=2.4"
-gem "autotest"
+gem "rspec"
 gem "with_model"
 
-gem "activerecord", "~> #{ENV["ACTIVE_RECORD_VERSION"]}.0" if ENV["ACTIVE_RECORD_VERSION"]
+gem "activerecord", "~> #{ENV["ACTIVE_RECORD_VERSION"]}.0" if ENV["ACTIVE_RECORD_VERSION"]

data/Rakefile

@@ -16,11 +16,6 @@ task "doc" do
   bundle_exec("rspec --format d spec")
 end
 
-desc "Launch autotest"
-task "autotest" do
-  bundle_exec("autotest -s rspec2")
-end
-
 namespace "doc" do
   desc "Generate README and preview in browser"
   task "readme" do

data/lib/pg_search.rb

@@ -23,8 +23,8 @@ module PgSearch
     end
   end
 
-  def rank
-    attributes['pg_search_rank'].to_f
+  def pg_search_rank
+    read_attribute(:pg_search_rank).to_f
   end
 
   class << self

data/lib/pg_search/configuration/association.rb

@@ -23,7 +23,7 @@ module PgSearch
           when 0..90000
             "array_to_string(array_agg(#{column.full_name}), ' ') AS #{column.alias}"
           else
-            "string_agg(#{column.full_name}, ' ') AS #{column.alias}"
+            "string_agg(#{column.full_name}::text, ' ') AS #{column.alias}"
           end
         end.join(", ")
         relation = @model.joins(@name).select("#{primary_key} AS id, #{selects}").group(primary_key)

data/lib/pg_search/multisearch.rb

@@ -1,12 +1,14 @@
 module PgSearch
   module Multisearch
     REBUILD_SQL_TEMPLATE = <<-SQL
-INSERT INTO :documents_table (searchable_type, searchable_id, content)
+INSERT INTO :documents_table (searchable_type, searchable_id, content, created_at, updated_at)
   SELECT :model_name AS searchable_type,
          :model_table.id AS searchable_id,
          (
            :content_expressions
-         ) AS content
+         ) AS content,
+         :current_time AS created_at,
+         :current_time AS updated_at
   FROM :model_table
 SQL
 
@@ -21,13 +23,17 @@ SQL
       def rebuild_sql(model)
         connection = model.connection
 
+        unless model.respond_to?(:pg_search_multisearchable_options)
+          raise ModelNotMultisearchable.new(model)
+        end
+
         columns = Array.wrap(
           model.pg_search_multisearchable_options[:against]
         )
 
-        content_expressions = columns.map do |column|
+        content_expressions = columns.map { |column|
           %Q{coalesce(:model_table.#{column}, '')}
-        end.join(" || ' ' || ")
+        }.join(" || ' ' || ")
 
         REBUILD_SQL_TEMPLATE.gsub(
           ":content_expressions", content_expressions
@@ -37,9 +43,21 @@ SQL
           ":model_table", model.quoted_table_name
         ).gsub(
           ":documents_table", PgSearch::Document.quoted_table_name
+        ).gsub(
+          ":current_time", connection.quote(connection.quoted_date(Time.now))
         )
       end
     end
+
+    class ModelNotMultisearchable < StandardError
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      def message
+        "#{@model_class.name} is not multisearchable. See PgSearch::ClassMethods#multisearchable"
+      end
+    end
   end
 end
 

data/lib/pg_search/tasks.rb

@@ -75,7 +75,7 @@ class AddPgSearchDmetaphoneSupportFunctions < ActiveRecord::Migration
       if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
         ActiveRecord::Base.connection.execute(<<-SQL)
           #{uninstall_unnest_sql}
-        end
+        SQL
       end
     end
   end

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

data/spec/associations_spec.rb

@@ -1,294 +1,329 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require "spec_helper"
 
 describe PgSearch do
   context "joining to another table" do
-    context "with Arel support" do
-      context "without an :against" do
-        with_model :AssociatedModel do
-          table do |t|
-            t.string "title"
-          end
+    context "without an :against" do
+      with_model :AssociatedModel do
+        table do |t|
+          t.string "title"
         end
+      end
 
-        with_model :ModelWithoutAgainst do
-          table do |t|
-            t.string "title"
-            t.belongs_to :another_model
-          end
+      with_model :ModelWithoutAgainst do
+        table do |t|
+          t.string "title"
+          t.belongs_to :another_model
+        end
 
-          model do
-            include PgSearch
-            belongs_to :another_model, :class_name => 'AssociatedModel'
+        model do
+          include PgSearch
+          belongs_to :another_model, :class_name => 'AssociatedModel'
 
-            pg_search_scope :with_another, :associated_against => {:another_model => :title}
-          end
+          pg_search_scope :with_another, :associated_against => {:another_model => :title}
         end
+      end
 
-        it "returns rows that match the query in the columns of the associated model only" do
-          associated = AssociatedModel.create!(:title => 'abcdef')
-          included = [
-            ModelWithoutAgainst.create!(:title => 'abcdef', :another_model => associated),
-            ModelWithoutAgainst.create!(:title => 'ghijkl', :another_model => associated)
-          ]
-          excluded = [
-            ModelWithoutAgainst.create!(:title => 'abcdef')
-          ]
+      it "returns rows that match the query in the columns of the associated model only" do
+        associated = AssociatedModel.create!(:title => 'abcdef')
+        included = [
+          ModelWithoutAgainst.create!(:title => 'abcdef', :another_model => associated),
+          ModelWithoutAgainst.create!(:title => 'ghijkl', :another_model => associated)
+        ]
+        excluded = [
+          ModelWithoutAgainst.create!(:title => 'abcdef')
+        ]
+
+        results = ModelWithoutAgainst.with_another('abcdef')
+        results.map(&:title).should =~ included.map(&:title)
+        results.should_not include(excluded)
+      end
+    end
 
-          results = ModelWithoutAgainst.with_another('abcdef')
-          results.map(&:title).should =~ included.map(&:title)
-          results.should_not include(excluded)
+    context "through a belongs_to association" do
+      with_model :AssociatedModel do
+        table do |t|
+          t.string 'title'
+        end
+      end
+
+      with_model :ModelWithBelongsTo do
+        table do |t|
+          t.string 'title'
+          t.belongs_to 'another_model'
+        end
+
+        model do
+          include PgSearch
+          belongs_to :another_model, :class_name => 'AssociatedModel'
+
+          pg_search_scope :with_associated, :against => :title, :associated_against => {:another_model => :title}
+        end
+      end
+
+      it "returns rows that match the query in either its own columns or the columns of the associated model" do
+        associated = AssociatedModel.create!(:title => 'abcdef')
+        included = [
+          ModelWithBelongsTo.create!(:title => 'ghijkl', :another_model => associated),
+          ModelWithBelongsTo.create!(:title => 'abcdef')
+        ]
+        excluded = ModelWithBelongsTo.create!(:title => 'mnopqr',
+                                                 :another_model => AssociatedModel.create!(:title => 'stuvwx'))
+
+        results = ModelWithBelongsTo.with_associated('abcdef')
+        results.map(&:title).should =~ included.map(&:title)
+        results.should_not include(excluded)
+      end
+    end
+
+    context "through a has_many association" do
+      with_model :AssociatedModelWithHasMany do
+        table do |t|
+          t.string 'title'
+          t.belongs_to 'ModelWithHasMany'
+        end
+      end
+
+      with_model :ModelWithHasMany do
+        table do |t|
+          t.string 'title'
+        end
+
+        model do
+          include PgSearch
+          has_many :other_models, :class_name => 'AssociatedModelWithHasMany', :foreign_key => 'ModelWithHasMany_id'
+
+          pg_search_scope :with_associated, :against => [:title], :associated_against => {:other_models => :title}
         end
       end
 
-      context "through a belongs_to association" do
-        with_model :AssociatedModel do
+      it "returns rows that match the query in either its own columns or the columns of the associated model" do
+        included = [
+          ModelWithHasMany.create!(:title => 'abcdef', :other_models => [
+                                      AssociatedModelWithHasMany.create!(:title => 'foo'),
+                                      AssociatedModelWithHasMany.create!(:title => 'bar')
+        ]),
+          ModelWithHasMany.create!(:title => 'ghijkl', :other_models => [
+                                      AssociatedModelWithHasMany.create!(:title => 'foo bar'),
+                                      AssociatedModelWithHasMany.create!(:title => 'mnopqr')
+        ]),
+          ModelWithHasMany.create!(:title => 'foo bar')
+        ]
+        excluded = ModelWithHasMany.create!(:title => 'stuvwx', :other_models => [
+                                               AssociatedModelWithHasMany.create!(:title => 'abcdef')
+        ])
+
+        results = ModelWithHasMany.with_associated('foo bar')
+        results.map(&:title).should =~ included.map(&:title)
+        results.should_not include(excluded)
+      end
+    end
+
+    context "across multiple associations" do
+      context "on different tables" do
+        with_model :FirstAssociatedModel do
+          table do |t|
+            t.string 'title'
+            t.belongs_to 'ModelWithManyAssociations'
+          end
+          model {}
+        end
+
+        with_model :SecondAssociatedModel do
           table do |t|
             t.string 'title'
           end
+          model {}
         end
 
-        with_model :ModelWithBelongsTo do
+        with_model :ModelWithManyAssociations do
           table do |t|
             t.string 'title'
-            t.belongs_to 'another_model'
+            t.belongs_to 'model_of_second_type'
           end
 
           model do
             include PgSearch
-            belongs_to :another_model, :class_name => 'AssociatedModel'
+            has_many :models_of_first_type, :class_name => 'FirstAssociatedModel', :foreign_key => 'ModelWithManyAssociations_id'
+            belongs_to :model_of_second_type, :class_name => 'SecondAssociatedModel'
 
-            pg_search_scope :with_associated, :against => :title, :associated_against => {:another_model => :title}
+            pg_search_scope :with_associated, :against => :title,
+              :associated_against => {:models_of_first_type => :title, :model_of_second_type => :title}
           end
         end
 
         it "returns rows that match the query in either its own columns or the columns of the associated model" do
-          associated = AssociatedModel.create!(:title => 'abcdef')
+          matching_second = SecondAssociatedModel.create!(:title => "foo bar")
+          unmatching_second = SecondAssociatedModel.create!(:title => "uiop")
+
           included = [
-            ModelWithBelongsTo.create!(:title => 'ghijkl', :another_model => associated),
-            ModelWithBelongsTo.create!(:title => 'abcdef')
+            ModelWithManyAssociations.create!(:title => 'abcdef', :models_of_first_type => [
+                                              FirstAssociatedModel.create!(:title => 'foo'),
+                                              FirstAssociatedModel.create!(:title => 'bar')
+          ]),
+            ModelWithManyAssociations.create!(:title => 'ghijkl', :models_of_first_type => [
+                                              FirstAssociatedModel.create!(:title => 'foo bar'),
+                                              FirstAssociatedModel.create!(:title => 'mnopqr')
+          ]),
+            ModelWithManyAssociations.create!(:title => 'foo bar'),
+            ModelWithManyAssociations.create!(:title => 'qwerty', :model_of_second_type => matching_second)
+          ]
+          excluded = [
+            ModelWithManyAssociations.create!(:title => 'stuvwx', :models_of_first_type => [
+                                              FirstAssociatedModel.create!(:title => 'abcdef')
+          ]),
+            ModelWithManyAssociations.create!(:title => 'qwerty', :model_of_second_type => unmatching_second)
           ]
-          excluded = ModelWithBelongsTo.create!(:title => 'mnopqr',
-                                                   :another_model => AssociatedModel.create!(:title => 'stuvwx'))
 
-          results = ModelWithBelongsTo.with_associated('abcdef')
+          results = ModelWithManyAssociations.with_associated('foo bar')
           results.map(&:title).should =~ included.map(&:title)
-          results.should_not include(excluded)
+          excluded.each { |object| results.should_not include(object) }
         end
       end
 
-      context "through a has_many association" do
-        with_model :AssociatedModelWithHasMany do
+      context "on the same table" do
+        with_model :DoublyAssociatedModel do
           table do |t|
             t.string 'title'
-            t.belongs_to 'ModelWithHasMany'
+            t.belongs_to 'ModelWithDoubleAssociation'
+            t.belongs_to 'ModelWithDoubleAssociation_again'
           end
+          model {}
         end
 
-        with_model :ModelWithHasMany do
+        with_model :ModelWithDoubleAssociation do
           table do |t|
             t.string 'title'
           end
 
           model do
             include PgSearch
-            has_many :other_models, :class_name => 'AssociatedModelWithHasMany', :foreign_key => 'ModelWithHasMany_id'
+            has_many :things, :class_name => 'DoublyAssociatedModel', :foreign_key => 'ModelWithDoubleAssociation_id'
+            has_many :thingamabobs, :class_name => 'DoublyAssociatedModel', :foreign_key => 'ModelWithDoubleAssociation_again_id'
 
-            pg_search_scope :with_associated, :against => [:title], :associated_against => {:other_models => :title}
+            pg_search_scope :with_associated, :against => :title,
+              :associated_against => {:things => :title, :thingamabobs => :title}
           end
         end
 
         it "returns rows that match the query in either its own columns or the columns of the associated model" do
           included = [
-            ModelWithHasMany.create!(:title => 'abcdef', :other_models => [
-                                        AssociatedModelWithHasMany.create!(:title => 'foo'),
-                                        AssociatedModelWithHasMany.create!(:title => 'bar')
+            ModelWithDoubleAssociation.create!(:title => 'abcdef', :things => [
+                                                  DoublyAssociatedModel.create!(:title => 'foo'),
+                                                  DoublyAssociatedModel.create!(:title => 'bar')
           ]),
-            ModelWithHasMany.create!(:title => 'ghijkl', :other_models => [
-                                        AssociatedModelWithHasMany.create!(:title => 'foo bar'),
-                                        AssociatedModelWithHasMany.create!(:title => 'mnopqr')
+            ModelWithDoubleAssociation.create!(:title => 'ghijkl', :things => [
+                                                  DoublyAssociatedModel.create!(:title => 'foo bar'),
+                                                  DoublyAssociatedModel.create!(:title => 'mnopqr')
           ]),
-            ModelWithHasMany.create!(:title => 'foo bar')
+            ModelWithDoubleAssociation.create!(:title => 'foo bar'),
+            ModelWithDoubleAssociation.create!(:title => 'qwerty', :thingamabobs => [
+                                                  DoublyAssociatedModel.create!(:title => "foo bar")
+          ])
           ]
-          excluded = ModelWithHasMany.create!(:title => 'stuvwx', :other_models => [
-                                                 AssociatedModelWithHasMany.create!(:title => 'abcdef')
+          excluded = [
+            ModelWithDoubleAssociation.create!(:title => 'stuvwx', :things => [
+                                                  DoublyAssociatedModel.create!(:title => 'abcdef')
+          ]),
+            ModelWithDoubleAssociation.create!(:title => 'qwerty', :thingamabobs => [
+                                                  DoublyAssociatedModel.create!(:title => "uiop")
           ])
+          ]
 
-          results = ModelWithHasMany.with_associated('foo bar')
+          results = ModelWithDoubleAssociation.with_associated('foo bar')
           results.map(&:title).should =~ included.map(&:title)
-          results.should_not include(excluded)
+          excluded.each { |object| results.should_not include(object) }
         end
       end
+    end
 
-      context "across multiple associations" do
-        context "on different tables" do
-          with_model :FirstAssociatedModel do
-            table do |t|
-              t.string 'title'
-              t.belongs_to 'ModelWithManyAssociations'
-            end
-            model {}
-          end
-
-          with_model :SecondAssociatedModel do
-            table do |t|
-              t.string 'title'
-            end
-            model {}
-          end
-
-          with_model :ModelWithManyAssociations do
-            table do |t|
-              t.string 'title'
-              t.belongs_to 'model_of_second_type'
-            end
+    context "against multiple attributes on one association" do
+      with_model :AssociatedModel do
+        table do |t|
+          t.string 'title'
+          t.text 'author'
+        end
+      end
 
-            model do
-              include PgSearch
-              has_many :models_of_first_type, :class_name => 'FirstAssociatedModel', :foreign_key => 'ModelWithManyAssociations_id'
-              belongs_to :model_of_second_type, :class_name => 'SecondAssociatedModel'
+      with_model :ModelWithAssociation do
+        table do |t|
+          t.belongs_to 'another_model'
+        end
 
-              pg_search_scope :with_associated, :against => :title,
-                :associated_against => {:models_of_first_type => :title, :model_of_second_type => :title}
-            end
-          end
+        model do
+          include PgSearch
+          belongs_to :another_model, :class_name => 'AssociatedModel'
 
-          it "returns rows that match the query in either its own columns or the columns of the associated model" do
-            matching_second = SecondAssociatedModel.create!(:title => "foo bar")
-            unmatching_second = SecondAssociatedModel.create!(:title => "uiop")
-
-            included = [
-              ModelWithManyAssociations.create!(:title => 'abcdef', :models_of_first_type => [
-                                                FirstAssociatedModel.create!(:title => 'foo'),
-                                                FirstAssociatedModel.create!(:title => 'bar')
-            ]),
-              ModelWithManyAssociations.create!(:title => 'ghijkl', :models_of_first_type => [
-                                                FirstAssociatedModel.create!(:title => 'foo bar'),
-                                                FirstAssociatedModel.create!(:title => 'mnopqr')
-            ]),
-              ModelWithManyAssociations.create!(:title => 'foo bar'),
-              ModelWithManyAssociations.create!(:title => 'qwerty', :model_of_second_type => matching_second)
-            ]
-            excluded = [
-              ModelWithManyAssociations.create!(:title => 'stuvwx', :models_of_first_type => [
-                                                FirstAssociatedModel.create!(:title => 'abcdef')
-            ]),
-              ModelWithManyAssociations.create!(:title => 'qwerty', :model_of_second_type => unmatching_second)
-            ]
-
-            results = ModelWithManyAssociations.with_associated('foo bar')
-            results.map(&:title).should =~ included.map(&:title)
-            excluded.each { |object| results.should_not include(object) }
-          end
+          pg_search_scope :with_associated, :associated_against => {:another_model => [:title, :author]}
         end
+      end
 
-        context "on the same table" do
-          with_model :DoublyAssociatedModel do
-            table do |t|
-              t.string 'title'
-              t.belongs_to 'ModelWithDoubleAssociation'
-              t.belongs_to 'ModelWithDoubleAssociation_again'
-            end
-            model {}
-          end
+      it "should only do one join" do
+        included = [
+          ModelWithAssociation.create!(
+            :another_model => AssociatedModel.create!(
+              :title => "foo",
+              :author => "bar"
+            )
+          ),
+          ModelWithAssociation.create!(
+            :another_model => AssociatedModel.create!(
+              :title => "foo bar",
+              :author => "baz"
+            )
+          )
+        ]
+        excluded = [
+          ModelWithAssociation.create!(
+            :another_model => AssociatedModel.create!(
+              :title => "foo",
+              :author => "baz"
+            )
+          )
+        ]
 
-          with_model :ModelWithDoubleAssociation do
-            table do |t|
-              t.string 'title'
-            end
+        results = ModelWithAssociation.with_associated('foo bar')
 
-            model do
-              include PgSearch
-              has_many :things, :class_name => 'DoublyAssociatedModel', :foreign_key => 'ModelWithDoubleAssociation_id'
-              has_many :thingamabobs, :class_name => 'DoublyAssociatedModel', :foreign_key => 'ModelWithDoubleAssociation_again_id'
+        results.to_sql.scan("INNER JOIN").length.should == 1
+        included.each { |object| results.should include(object) }
+        excluded.each { |object| results.should_not include(object) }
+      end
 
-              pg_search_scope :with_associated, :against => :title,
-                :associated_against => {:things => :title, :thingamabobs => :title}
-            end
-          end
+    end
 
-          it "returns rows that match the query in either its own columns or the columns of the associated model" do
-            included = [
-              ModelWithDoubleAssociation.create!(:title => 'abcdef', :things => [
-                                                    DoublyAssociatedModel.create!(:title => 'foo'),
-                                                    DoublyAssociatedModel.create!(:title => 'bar')
-            ]),
-              ModelWithDoubleAssociation.create!(:title => 'ghijkl', :things => [
-                                                    DoublyAssociatedModel.create!(:title => 'foo bar'),
-                                                    DoublyAssociatedModel.create!(:title => 'mnopqr')
-            ]),
-              ModelWithDoubleAssociation.create!(:title => 'foo bar'),
-              ModelWithDoubleAssociation.create!(:title => 'qwerty', :thingamabobs => [
-                                                    DoublyAssociatedModel.create!(:title => "foo bar")
-            ])
-            ]
-            excluded = [
-              ModelWithDoubleAssociation.create!(:title => 'stuvwx', :things => [
-                                                    DoublyAssociatedModel.create!(:title => 'abcdef')
-            ]),
-              ModelWithDoubleAssociation.create!(:title => 'qwerty', :thingamabobs => [
-                                                    DoublyAssociatedModel.create!(:title => "uiop")
-            ])
-            ]
-
-            results = ModelWithDoubleAssociation.with_associated('foo bar')
-            results.map(&:title).should =~ included.map(&:title)
-            excluded.each { |object| results.should_not include(object) }
-          end
+    context "against non-text columns" do
+      with_model :AssociatedModel do
+        table do |t|
+          t.integer 'number'
         end
       end
 
-      context "against multiple attributes on one association" do
-        with_model :AssociatedModel do
-          table do |t|
-            t.string 'title'
-            t.text 'author'
-          end
+      with_model :Model do
+        table do |t|
+          t.integer 'number'
+          t.belongs_to 'another_model'
         end
 
-        with_model :ModelWithAssociation do
-          table do |t|
-            t.belongs_to 'another_model'
-          end
-
-          model do
-            include PgSearch
-            belongs_to :another_model, :class_name => 'AssociatedModel'
+        model do
+          include PgSearch
+          belongs_to :another_model, :class_name => 'AssociatedModel'
 
-            pg_search_scope :with_associated, :associated_against => {:another_model => [:title, :author]}
-          end
-        end
-
-        it "should only do one join" do
-          included = [
-            ModelWithAssociation.create!(
-              :another_model => AssociatedModel.create!(
-                :title => "foo",
-                :author => "bar"
-              )
-            ),
-            ModelWithAssociation.create!(
-              :another_model => AssociatedModel.create!(
-                :title => "foo bar",
-                :author => "baz"
-              )
-            )
-          ]
-          excluded = [
-            ModelWithAssociation.create!(
-              :another_model => AssociatedModel.create!(
-                :title => "foo",
-                :author => "baz"
-              )
-            )
-          ]
-
-          results = ModelWithAssociation.with_associated('foo bar')
-
-          results.to_sql.scan("INNER JOIN").length.should == 1
-          included.each { |object| results.should include(object) }
-          excluded.each { |object| results.should_not include(object) }
+          pg_search_scope :with_associated, :associated_against => {:another_model => :number}
         end
+      end
 
+      it "should cast the columns to text" do
+        associated = AssociatedModel.create!(:number => 123)
+        included = [
+          Model.create!(:number => 123, :another_model => associated),
+          Model.create!(:number => 456, :another_model => associated)
+        ]
+        excluded = [
+          Model.create!(:number => 123)
+        ]
+
+        results = Model.with_associated('123')
+        results.map(&:number).should =~ included.map(&:number)
+        results.should_not include(excluded)
       end
     end
   end

data/spec/pg_search/document_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "spec_helper"
 
 describe PgSearch::Document do
   with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA

data/spec/pg_search/multisearch_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "spec_helper"
 
 describe PgSearch::Multisearch do
   with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
@@ -20,6 +20,12 @@ describe PgSearch::Multisearch do
   end
 
   describe ".rebuild_sql" do
+    let(:now) { Time.now }
+
+    before do
+      Time.stub(:now => now)
+    end
+
     context "with one attribute" do
       it "should generate the proper SQL code" do
         model = MultisearchableModel
@@ -28,12 +34,14 @@ describe PgSearch::Multisearch do
         model.multisearchable :against => :title
 
         expected_sql = <<-SQL
-INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable_id, content)
+INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable_id, content, created_at, updated_at)
   SELECT #{connection.quote(model.name)} AS searchable_type,
          #{model.quoted_table_name}.id AS searchable_id,
          (
            coalesce(#{model.quoted_table_name}.title, '')
-         ) AS content
+         ) AS content,
+         #{connection.quote(connection.quoted_date(now))} AS created_at,
+         #{connection.quote(connection.quoted_date(now))} AS updated_at
   FROM #{model.quoted_table_name}
 SQL
 
@@ -49,12 +57,14 @@ SQL
         model.multisearchable :against => [:title, :content]
 
         expected_sql = <<-SQL
-INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable_id, content)
+INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable_id, content, created_at, updated_at)
   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
+         ) AS content,
+         #{connection.quote(connection.quoted_date(now))} AS created_at,
+         #{connection.quote(connection.quoted_date(now))} AS updated_at
   FROM #{model.quoted_table_name}
 SQL
 

data/spec/pg_search/multisearchable_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "spec_helper"
 
 describe PgSearch::Multisearchable do
   with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA

data/spec/pg_search_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require "spec_helper"
 
 describe "an ActiveRecord model which includes PgSearch" do
 
@@ -212,7 +212,7 @@ describe "an ActiveRecord model which includes PgSearch" do
         winner = ModelWithPgSearch.create!(:content => 'foo foo')
 
         results = ModelWithPgSearch.search_content("foo")
-        results[0].rank.should > results[1].rank
+        results[0].pg_search_rank.should > results[1].pg_search_rank
         results.should == [winner, loser]
       end
 
@@ -382,6 +382,16 @@ describe "an ActiveRecord model which includes PgSearch" do
           end
         end
 
+        it "adds a #pg_search_rank method to each returned model record" do
+          ModelWithPgSearch.class_eval do
+            pg_search_scope :search_content, :against => :content
+          end
+
+          result = ModelWithPgSearch.search_content("Strip Down").first
+
+          result.pg_search_rank.should be_a(Float)
+        end
+
         context "with a normalization specified" do
           before do
             ModelWithPgSearch.class_eval do
@@ -392,11 +402,12 @@ describe "an ActiveRecord model which includes PgSearch" do
                               }
             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
+            results.first.pg_search_rank.should be > results.last.pg_search_rank
           end
         end
 
@@ -408,11 +419,12 @@ describe "an ActiveRecord model which includes PgSearch" do
                               :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
+            results.first.pg_search_rank.should == results.last.pg_search_rank
           end
         end
       end
@@ -421,7 +433,7 @@ describe "an ActiveRecord model which includes PgSearch" do
         before do
           ModelWithPgSearch.class_eval do
              pg_search_scope :search_weighted_by_array_of_arrays, :against => [[:content, 'B'], [:title, 'A']]
-           end
+          end
         end
 
         it "returns results sorted by weighted rank" do
@@ -429,7 +441,7 @@ describe "an ActiveRecord model which includes PgSearch" do
           winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
           results = ModelWithPgSearch.search_weighted_by_array_of_arrays('foo')
-          results[0].rank.should > results[1].rank
+          results[0].pg_search_rank.should > results[1].pg_search_rank
           results.should == [winner, loser]
         end
       end
@@ -446,7 +458,7 @@ describe "an ActiveRecord model which includes PgSearch" do
           winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
           results = ModelWithPgSearch.search_weighted_by_hash('foo')
-          results[0].rank.should > results[1].rank
+          results[0].pg_search_rank.should > results[1].pg_search_rank
           results.should == [winner, loser]
         end
       end
@@ -463,7 +475,7 @@ describe "an ActiveRecord model which includes PgSearch" do
           winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
           results = ModelWithPgSearch.search_weighted('foo')
-          results[0].rank.should > results[1].rank
+          results[0].pg_search_rank.should > results[1].pg_search_rank
           results.should == [winner, loser]
         end
       end
@@ -680,14 +692,14 @@ describe "an ActiveRecord model which includes PgSearch" do
       it "should return records with a rank attribute equal to the :ranked_by expression" do
         ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
         results = ModelWithPgSearch.search_content_with_importance_as_rank("foo")
-        results.first.rank.should == 10
+        results.first.pg_search_rank.should == 10
       end
 
       it "should substitute :tsearch with the tsearch rank expression in the :ranked_by expression" do
         ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
 
-        tsearch_rank = ModelWithPgSearch.search_content_with_default_rank("foo").first.rank
-        multiplied_rank = ModelWithPgSearch.search_content_with_importance_as_rank_multiplier("foo").first.rank
+        tsearch_rank = ModelWithPgSearch.search_content_with_default_rank("foo").first.pg_search_rank
+        multiplied_rank = ModelWithPgSearch.search_content_with_importance_as_rank_multiplier("foo").first.pg_search_rank
 
         multiplied_rank.should be_within(0.001).of(tsearch_rank * 10)
       end
@@ -719,7 +731,7 @@ describe "an ActiveRecord model which includes PgSearch" do
             ModelWithPgSearch.create!(:content => 'foo')
 
             results = ModelWithPgSearch.send(@scope_name, 'foo')
-            results.first.rank.should_not be_nil
+            results.first.pg_search_rank.should_not be_nil
           end
         end
       end

data/spec/spec_helper.rb

@@ -9,7 +9,6 @@ begin
   connection = ActiveRecord::Base.connection
   postgresql_version = connection.send(:postgresql_version)
   connection.execute("SELECT 1")
-  puts "postgresql_version = #{postgresql_version}"
 rescue PGError => e
   puts "-" * 80
   puts "Unable to connect to database.  Please run:"
@@ -66,7 +65,7 @@ RSpec.configure do |config|
   config.extend WithModel
 end
 
-RSpec::Matchers::OperatorMatcher.register(ActiveRecord::Relation, '=~', RSpec::Matchers::MatchArray)
+RSpec::Matchers::OperatorMatcher.register(ActiveRecord::Relation, '=~', RSpec::Matchers::BuiltIn::MatchArray)
 
 DOCUMENTS_SCHEMA = lambda do |t|
   t.belongs_to :searchable, :polymorphic => true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_search
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-13 00:00:00.000000000 Z
+date: 2012-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70164267785940 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '3'
   type: :runtime
   prerelease: false
-  version_requirements: *70164267785940
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70164267784280 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +37,12 @@ dependencies:
         version: '3'
   type: :runtime
   prerelease: false
-  version_requirements: *70164267784280
+  version_requirements: !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:
@@ -101,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's