pg_search 0.4.2 → 0.5

data/CHANGELOG.rdoc

@@ -1,12 +1,21 @@
 = PgSearch
 
+== 0.5
+
+* Convert migration rake tasks into generators.
+
+* Use rake task arguments for multisearch rebuild instead of environment
+  variable.
+
+* Always cast columns to text.
+
 == 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)
+* Fix syntax error in pg_search_dmetaphone() migration. (Casey Foster)
 
 * Rename PgSearch#rank to PgSearch#pg_search_rank and always return a Float.
 

data/README.rdoc

@@ -26,7 +26,7 @@ The 0.2 branch lives at https://github.com/Casecommons/pg_search/tree/0.2-stable
 
 === Other ActiveRecord-based projects
 
-In addition to installing and requiring the gem, you may want to include the PgSearch rake tasks in your Rakefile:
+In addition to installing and requiring the gem, you may want to include the PgSearch rake tasks in your Rakefile. This isn't necessary for Rails projects, which gain the Rake tasks via a Railtie.
 
  load "pg_search/tasks.rb"
 
@@ -52,7 +52,7 @@ The other technique is search scopes, which allow you to do more advanced search
 
 Before using multi-search, you must generate and run a migration to create the pg_search_documents database table.
 
- $ rake pg_search:migration:multisearch
+ $ rails g pg_search:migration:multisearch
  $ rake db:migrate
 
 ==== multisearchable
@@ -120,7 +120,7 @@ To remove all of the documents for a given class, you can simply delete all of t
 
 Run this Rake task to regenerate all of the documents for a given class.
 
- $ rake pg_search:multisearch:rebuild MODEL=BlogPost
+ $ rake pg_search:multisearch:rebuild[BlogPost]
 
 Currently this is only supported for :against methods that directly map to Active Record attributes. Until that is fixed, you could also manually rebuild all of the documents.
 
@@ -198,9 +198,10 @@ Important: The returned hash must include a :query key. Its value does not neces
 
 It is possible to search columns on associated models. Note that if you do this, it will be impossible to speed up searches with database indexes. However, it is supported as a quick way to try out cross-model searching.
 
-In PostgreSQL 8.3 and earlier, you must install a utility function into your database. To generate a migration for this, run:
+In PostgreSQL 8.3 and earlier, you must install a utility function into your database. To generate and run a migration for this, run:
 
-  $ rake pg_search:migration:associated_against
+  $ rails g pg_search:migration:associated_against
+  $ rake db:migrate
 
 This migration is safe to run against newer versions of PostgreSQL as well. It will essentially do nothing.
 
@@ -392,9 +393,10 @@ Setting this attribute to true will perform a search which will return all model
 
 {Double Metaphone}[http://en.wikipedia.org/wiki/Double_Metaphone] is an algorithm for matching words that sound alike even if they are spelled very differently. For example, "Geoff" and "Jeff" sound identical and thus match. Currently, this is not a true double-metaphone, as only the first metaphone is used for searching.
 
-Double Metaphone support is currently available as part of the {fuzzystrmatch contrib package}[http://www.postgresql.org/docs/current/static/fuzzystrmatch.html] that must be installed before this feature can be used. In addition to the contrib package, you must install a utility function into your database. To generate a migration for this, run:
+Double Metaphone support is currently available as part of the {fuzzystrmatch contrib package}[http://www.postgresql.org/docs/current/static/fuzzystrmatch.html] that must be installed before this feature can be used. In addition to the contrib package, you must install a utility function into your database. To generate and run a migration for this, run:
 
-  $ rake pg_search:migration:dmetaphone
+  $ rails g pg_search:migration:dmetaphone
+  $ rake db:migrate
 
 The following example shows how to use :dmetaphone.
 

data/lib/pg_search/configuration/column.rb

@@ -26,7 +26,7 @@ module PgSearch
                else
                  full_name
                end
-        "coalesce(#{name}, '')"
+        "coalesce(#{name}::text, '')"
       end
 
       def foreign?

data/lib/pg_search/migration/associated_against_generator.rb

@@ -0,0 +1,23 @@
+require "rails/generators/base"
+
+module PgSearch
+  module Migration
+    class AssociatedAgainstGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      def create_migration
+        now = Time.now.utc
+        filename = "#{now.strftime('%Y%m%d%H%M%S')}_add_pg_search_associated_against_support_functions.rb"
+        template "add_pg_search_associated_against_support_functions.rb.erb", "db/migrate/#{filename}"
+      end
+
+      private
+
+      def read_sql_file(filename)
+        sql_directory = File.expand_path("../../../../sql", __FILE__)
+        source_path = File.join(sql_directory, "#{filename}.sql")
+        File.read(source_path)
+      end
+    end
+  end
+end

data/lib/pg_search/migration/dmetaphone_generator.rb

@@ -0,0 +1,23 @@
+require "rails/generators/base"
+
+module PgSearch
+  module Migration
+    class DmetaphoneGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      def create_migration
+        now = Time.now.utc
+        filename = "#{now.strftime('%Y%m%d%H%M%S')}_add_pg_search_dmetaphone_support_functions.rb"
+        template "add_pg_search_dmetaphone_support_functions.rb.erb", "db/migrate/#{filename}"
+      end
+
+      private
+
+      def read_sql_file(filename)
+        sql_directory = File.expand_path("../../../../sql", __FILE__)
+        source_path = File.join(sql_directory, "#{filename}.sql")
+        File.read(source_path)
+      end
+    end
+  end
+end

data/lib/pg_search/migration/multisearch_generator.rb

@@ -0,0 +1,16 @@
+require "rails/generators/base"
+
+module PgSearch
+  module Migration
+    class MultisearchGenerator < Rails::Generators::Base
+      source_root Pathname.new(File.dirname(__FILE__)).join("templates")
+
+      def create_migration
+        now = Time.now.utc
+        filename = "#{now.strftime('%Y%m%d%H%M%S')}_create_pg_search_documents.rb"
+        copy_file "create_pg_search_documents.rb", "db/migrate/#{filename}"
+      end
+    end
+  end
+end
+

data/lib/pg_search/migration/templates/add_pg_search_associated_against_support_functions.rb.erb

@@ -0,0 +1,21 @@
+class AddPgSearchAssociatedAgainstSupportFunctions < ActiveRecord::Migration
+  def self.up
+    say_with_time("Adding support functions for pg_search :associated_against") do
+      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
+        execute <<-SQL
+          <%= read_sql_file "array_agg" %>
+        SQL
+      end
+    end
+  end
+
+  def self.down
+    say_with_time("Dropping support functions for pg_search :associated_against") do
+      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
+        execute <<-SQL
+          <%= read_sql_file "uninstall_array_agg" %>
+        SQL
+      end
+    end
+  end
+end

data/lib/pg_search/migration/templates/add_pg_search_dmetaphone_support_functions.rb.erb

@@ -0,0 +1,29 @@
+class AddPgSearchDmetaphoneSupportFunctions < ActiveRecord::Migration
+  def self.up
+    say_with_time("Adding support functions for pg_search :dmetaphone") do
+      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
+        execute <<-SQL
+<%= read_sql_file "unnest" %>
+        SQL
+      end
+
+      execute <<-SQL
+<%= read_sql_file "dmetaphone" %>
+      SQL
+    end
+  end
+
+  def self.down
+    say_with_time("Dropping support functions for pg_search :dmetaphone") do
+      execute <<-SQL
+<%= read_sql_file "uninstall_dmetaphone" %>
+      SQL
+
+      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
+        execute <<-SQL
+<%= read_sql_file "uninstall_unnest" %>
+        SQL
+      end
+    end
+  end
+end

data/lib/pg_search/migration/templates/create_pg_search_documents.rb

@@ -0,0 +1,17 @@
+class CreatePgSearchDocuments < ActiveRecord::Migration
+  def self.up
+    say_with_time("Creating table for pg_search multisearch") do
+      create_table :pg_search_documents do |t|
+        t.text :content
+        t.belongs_to :searchable, :polymorphic => true
+        t.timestamps
+      end
+    end
+  end
+
+  def self.down
+    say_with_time("Dropping table for pg_search multisearch") do
+      drop_table :pg_search_documents
+    end
+  end
+end

data/lib/pg_search/multisearch.rb

@@ -32,7 +32,7 @@ SQL
         )
 
         content_expressions = columns.map { |column|
-          %Q{coalesce(:model_table.#{column}, '')}
+          %Q{coalesce(:model_table.#{column}::text, '')}
         }.join(" || ' ' || ")
 
         REBUILD_SQL_TEMPLATE.gsub(

data/lib/pg_search/railtie.rb

@@ -3,5 +3,11 @@ module PgSearch
     rake_tasks do
       load "pg_search/tasks.rb"
     end
+
+    generators do
+      require "pg_search/migration/multisearch_generator"
+      require "pg_search/migration/dmetaphone_generator"
+      require "pg_search/migration/associated_against_generator"
+    end
   end
 end

data/lib/pg_search/tasks.rb

@@ -3,120 +3,14 @@ require 'pg_search'
 
 namespace :pg_search do
   namespace :multisearch do
-    desc "Rebuild PgSearch multisearch records for MODEL"
-    task :rebuild => :environment do
-      raise "must set MODEL=<model name>" unless ENV["MODEL"]
-      model_class = ENV["MODEL"].classify.constantize
+    desc "Rebuild PgSearch multisearch records for a given model"
+    task :rebuild, [:model] => :environment do |task, args|
+      raise ArgumentError, <<-MESSAGE unless args.model
+You must pass a model as an argument.
+Example: rake pg_search:multisearch:rebuild[BlogPost]
+      MESSAGE
+      model_class = args.model.classify.constantize
       PgSearch::Multisearch.rebuild(model_class)
     end
   end
-
-  namespace :migration do
-    desc "Generate migration to add table for multisearch"
-    task :multisearch do
-      now = Time.now.utc
-      filename = "#{now.strftime('%Y%m%d%H%M%S')}_create_pg_search_documents.rb"
-
-      File.open(Rails.root + 'db' + 'migrate' + filename, 'wb') do |migration_file|
-        migration_file.puts <<-RUBY
-class CreatePgSearchDocuments < ActiveRecord::Migration
-  def self.up
-    say_with_time("Creating table for pg_search multisearch") do
-      create_table :pg_search_documents do |t|
-        t.text :content
-        t.belongs_to :searchable, :polymorphic => true
-        t.timestamps
-      end
-    end
-  end
-
-  def self.down
-    say_with_time("Dropping table for pg_search multisearch") do
-      drop_table :pg_search_documents
-    end
-  end
-end
-        RUBY
-      end
-    end
-
-    desc "Generate migration to add support functions for :dmetaphone"
-    task :dmetaphone do
-      now = Time.now.utc
-      filename = "#{now.strftime('%Y%m%d%H%M%S')}_add_pg_search_dmetaphone_support_functions.rb"
-
-      dmetaphone_sql = File.read(File.join(File.dirname(__FILE__), '..', '..', 'sql', 'dmetaphone.sql')).chomp
-      uninstall_dmetaphone_sql = File.read(File.join(File.dirname(__FILE__), '..', '..', 'sql', 'uninstall_dmetaphone.sql')).chomp
-
-      unnest_sql = File.read(File.join(File.dirname(__FILE__), '..', '..', 'sql', 'unnest.sql')).chomp
-      uninstall_unnest_sql = File.read(File.join(File.dirname(__FILE__), '..', '..', 'sql', 'uninstall_unnest.sql')).chomp
-
-      File.open(Rails.root + 'db' + 'migrate' + filename, 'wb') do |migration_file|
-        migration_file.puts <<-RUBY
-class AddPgSearchDmetaphoneSupportFunctions < ActiveRecord::Migration
-  def self.up
-    say_with_time("Adding support functions for pg_search :dmetaphone") do
-      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
-        ActiveRecord::Base.connection.execute(<<-SQL)
-          #{unnest_sql}
-        SQL
-      end
-      ActiveRecord::Base.connection.execute(<<-SQL)
-        #{dmetaphone_sql}
-      SQL
-    end
-  end
-
-  def self.down
-    say_with_time("Dropping support functions for pg_search :dmetaphone") do
-      ActiveRecord::Base.connection.execute(<<-SQL)
-        #{uninstall_dmetaphone_sql}
-      SQL
-      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
-        ActiveRecord::Base.connection.execute(<<-SQL)
-          #{uninstall_unnest_sql}
-        SQL
-      end
-    end
-  end
-end
-        RUBY
-      end
-    end
-
-    desc "Generate migration to add support functions for :associated_against in PostgreSQL 8.3 and earlier"
-    task :associated_against do
-      now = Time.now.utc
-      filename = "#{now.strftime('%Y%m%d%H%M%S')}_add_pg_search_associated_against_support_functions.rb"
-
-      array_agg_sql = File.read(File.join(File.dirname(__FILE__), '..', '..', 'sql', 'array_agg.sql')).chomp
-      uninstall_array_agg_sql = File.read(File.join(File.dirname(__FILE__), '..', '..', 'sql', 'uninstall_array_agg.sql')).chomp
-
-      File.open(Rails.root + 'db' + 'migrate' + filename, 'wb') do |migration_file|
-        migration_file.puts <<-RUBY
-class AddPgSearchAssociatedAgainstSupportFunctions < ActiveRecord::Migration
-  def self.up
-    say_with_time("Adding support functions for pg_search :associated_against") do
-      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
-        ActiveRecord::Base.connection.execute(<<-SQL)
-          #{array_agg_sql}
-        SQL
-      end
-    end
-  end
-
-  def self.down
-    say_with_time("Dropping support functions for pg_search :associated_against") do
-      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
-        ActiveRecord::Base.connection.execute(<<-SQL)
-          #{uninstall_array_agg_sql}
-        SQL
-      end
-    end
-  end
-end
-        RUBY
-      end
-    end
-  end
 end

data/lib/pg_search/version.rb

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

data/spec/pg_search/multisearch_spec.rb

@@ -38,7 +38,7 @@ INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable
   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}.title::text, '')
          ) AS content,
          #{connection.quote(connection.quoted_date(now))} AS created_at,
          #{connection.quote(connection.quoted_date(now))} AS updated_at
@@ -61,7 +61,7 @@ INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable
   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, '')
+           coalesce(#{model.quoted_table_name}.title::text, '') || ' ' || coalesce(#{model.quoted_table_name}.content::text, '')
          ) AS content,
          #{connection.quote(connection.quoted_date(now))} AS created_at,
          #{connection.quote(connection.quoted_date(now))} AS updated_at

data/spec/pg_search/multisearchable_spec.rb

@@ -97,10 +97,13 @@ describe PgSearch::Multisearchable do
           record = ModelThatIsMultisearchable.create!
           document = record.pg_search_document
 
-          lambda { record.destroy }.should change(PgSearch::Document, :count).by(-1)
-          lambda {
+          expect {
+            record.destroy
+          }.to change(PgSearch::Document, :count).by(-1)
+
+          expect {
             PgSearch::Document.find(document.id)
-          }.should raise_error(ActiveRecord::RecordNotFound)
+          }.to raise_error(ActiveRecord::RecordNotFound)
         end
       end
     end

data/spec/pg_search_spec.rb

@@ -15,26 +15,21 @@ describe "an ActiveRecord model which includes PgSearch" do
   end
 
   describe ".pg_search_scope" do
-    it "builds a scope" do
-      ModelWithPgSearch.class_eval do
-        pg_search_scope "matching_query", :against => []
-      end
-
-      lambda {
-        ModelWithPgSearch.scoped({}).matching_query("foo").scoped({})
-      }.should_not raise_error
+    it "builds a chainable scope" do
+      ModelWithPgSearch.pg_search_scope "matching_query", :against => []
+      scope = ModelWithPgSearch.scoped({}).matching_query("foo").scoped({})
+      scope.should be_an ActiveRecord::Relation
     end
 
     context "when passed a lambda" do
       it "builds a dynamic scope" do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :search_title_or_content, lambda { |query, pick_content|
+        ModelWithPgSearch.pg_search_scope :search_title_or_content,
+          lambda { |query, pick_content|
             {
               :query => query.gsub("-remove-", ""),
               :against => pick_content ? :content : :title
             }
           }
-        end
 
         included = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
         excluded = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
@@ -46,86 +41,89 @@ describe "an ActiveRecord model which includes PgSearch" do
 
     context "when an unknown option is passed in" do
       it "raises an exception when invoked" do
-        lambda {
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :with_unknown_option, :against => :content, :foo => :bar
-          end
+        ModelWithPgSearch.pg_search_scope :with_unknown_option,
+          :against => :content,
+          :foo => :bar
+
+        expect {
           ModelWithPgSearch.with_unknown_option("foo")
-        }.should raise_error(ArgumentError, /foo/)
+        }.to raise_error(ArgumentError, /foo/)
       end
 
       context "dynamically" do
         it "raises an exception when invoked" do
-          lambda {
-            ModelWithPgSearch.class_eval do
-              pg_search_scope :with_unknown_option, lambda { |*| {:against => :content, :foo => :bar} }
-            end
+          ModelWithPgSearch.pg_search_scope :with_unknown_option,
+            lambda { |*| {:against => :content, :foo => :bar} }
+
+          expect {
             ModelWithPgSearch.with_unknown_option("foo")
-          }.should raise_error(ArgumentError, /foo/)
+          }.to raise_error(ArgumentError, /foo/)
         end
       end
     end
 
     context "when an unknown :using is passed" do
       it "raises an exception when invoked" do
-        lambda {
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :with_unknown_using, :against => :content, :using => :foo
-          end
+        ModelWithPgSearch.pg_search_scope :with_unknown_using,
+          :against => :content,
+          :using => :foo
+
+        expect {
           ModelWithPgSearch.with_unknown_using("foo")
-        }.should raise_error(ArgumentError, /foo/)
+        }.to raise_error(ArgumentError, /foo/)
       end
 
       context "dynamically" do
         it "raises an exception when invoked" do
-          lambda {
-            ModelWithPgSearch.class_eval do
-              pg_search_scope :with_unknown_using, lambda { |*| {:against => :content, :using => :foo} }
-            end
+          ModelWithPgSearch.pg_search_scope :with_unknown_using,
+            lambda { |*| {:against => :content, :using => :foo} }
+
+          expect {
             ModelWithPgSearch.with_unknown_using("foo")
-          }.should raise_error(ArgumentError, /foo/)
+          }.to raise_error(ArgumentError, /foo/)
         end
       end
     end
 
     context "when an unknown :ignoring is passed" do
       it "raises an exception when invoked" do
-        lambda {
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :with_unknown_ignoring, :against => :content, :ignoring => :foo
-          end
+        ModelWithPgSearch.pg_search_scope :with_unknown_ignoring,
+          :against => :content,
+          :ignoring => :foo
+
+        expect {
           ModelWithPgSearch.with_unknown_ignoring("foo")
-        }.should raise_error(ArgumentError, /ignoring.*foo/)
+        }.to raise_error(ArgumentError, /ignoring.*foo/)
       end
 
       context "dynamically" do
         it "raises an exception when invoked" do
-          lambda {
-            ModelWithPgSearch.class_eval do
-              pg_search_scope :with_unknown_ignoring, lambda { |*| {:against => :content, :ignoring => :foo} }
-            end
+          ModelWithPgSearch.pg_search_scope :with_unknown_ignoring,
+            lambda { |*| {:against => :content, :ignoring => :foo} }
+
+          expect {
             ModelWithPgSearch.with_unknown_ignoring("foo")
-          }.should raise_error(ArgumentError, /ignoring.*foo/)
+          }.to raise_error(ArgumentError, /ignoring.*foo/)
         end
       end
 
       context "when :against is not passed in" do
         it "raises an exception when invoked" do
-          lambda {
-            ModelWithPgSearch.class_eval do
-              pg_search_scope :with_unknown_ignoring, {}
-            end
+          ModelWithPgSearch.pg_search_scope :with_unknown_ignoring, {}
+
+          expect {
             ModelWithPgSearch.with_unknown_ignoring("foo")
-          }.should raise_error(ArgumentError, /against/)
+          }.to raise_error(ArgumentError, /against/)
         end
+
         context "dynamically" do
           it "raises an exception when invoked" do
-            lambda {
-              ModelWithPgSearch.class_eval do
-                pg_search_scope :with_unknown_ignoring, lambda { |*| {} }
-              end
+            ModelWithPgSearch.pg_search_scope :with_unknown_ignoring,
+              lambda { |*| {} }
+
+            expect {
               ModelWithPgSearch.with_unknown_ignoring("foo")
-            }.should raise_error(ArgumentError, /against/)
+            }.to raise_error(ArgumentError, /against/)
           end
         end
       end
@@ -135,9 +133,7 @@ describe "an ActiveRecord model which includes PgSearch" do
   describe "a search scope" do
     context "against a single column" do
       before do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :search_content, :against => :content
-        end
+        ModelWithPgSearch.pg_search_scope :search_content, :against => :content
       end
 
       it "returns an empty array when a blank query is passed in" do
@@ -252,13 +248,36 @@ describe "an ActiveRecord model which includes PgSearch" do
         not_a_string = stub(:to_s => "foo")
         ModelWithPgSearch.search_content(not_a_string).should == [foo]
       end
+
+      context "when the column is not text" do
+        with_model :ModelWithTimestamps do
+          table do |t|
+            t.timestamps
+          end
+
+          model do
+            include PgSearch
+
+            # WARNING: searching timestamps is not something PostgreSQL
+            # full-text search is good at. Use at your own risk.
+            pg_search_scope :search_timestamps,
+              :against => [:created_at, :updated_at]
+          end
+        end
+
+        it "casts the column to text" do
+          record = ModelWithTimestamps.create!
+
+          query = record.created_at.strftime("%Y-%m-%d")
+          results = ModelWithTimestamps.search_timestamps(query)
+          results.should == [record]
+        end
+      end
     end
 
     context "against multiple columns" do
       before do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :search_title_and_content, :against => [:title, :content]
-        end
+        ModelWithPgSearch.pg_search_scope :search_title_and_content, :against => [:title, :content]
       end
 
       it "returns rows whose columns contain all of the terms in the query across columns" do
@@ -297,9 +316,7 @@ describe "an ActiveRecord model which includes PgSearch" do
 
     context "using trigram" do
       before do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :with_trigrams, :against => [:title, :content], :using => :trigram
-        end
+        ModelWithPgSearch.pg_search_scope :with_trigrams, :against => [:title, :content], :using => :trigram
       end
 
       it "returns rows where one searchable column and the query share enough trigrams" do
@@ -317,20 +334,18 @@ describe "an ActiveRecord model which includes PgSearch" do
 
     context "using tsearch" do
       before do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :search_title_with_prefixes,
-                          :against => :title,
-                          :using => {
-                            :tsearch => {:prefix => true}
-                          }
-        end
+        ModelWithPgSearch.pg_search_scope :search_title_with_prefixes,
+                                          :against => :title,
+                                          :using => {
+                                            :tsearch => {:prefix => true}
+                                          }
       end
 
       if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
         it "is unsupported in PostgreSQL 8.3 and earlier" do
-          lambda do
+          expect {
             ModelWithPgSearch.search_title_with_prefixes("abcd\303\251f")
-          end.should raise_exception(PgSearch::NotSupportedForPostgresqlVersion)
+          }.to raise_exception(PgSearch::NotSupportedForPostgresqlVersion)
         end
       else
         context "with :prefix => true" do
@@ -356,13 +371,11 @@ describe "an ActiveRecord model which includes PgSearch" do
 
       context "with the english dictionary" do
         before do
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :search_content_with_english,
-                            :against => :content,
-                            :using => {
-                              :tsearch => {:dictionary => :english}
-                            }
-          end
+          ModelWithPgSearch.pg_search_scope :search_content_with_english,
+            :against => :content,
+            :using => {
+              :tsearch => {:dictionary => :english}
+            }
         end
 
         it "returns rows that match the query when stemmed by the english dictionary" do
@@ -383,9 +396,7 @@ describe "an ActiveRecord model which includes PgSearch" do
         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
+          ModelWithPgSearch.pg_search_scope :search_content, :against => :content
 
           result = ModelWithPgSearch.search_content("Strip Down").first
 
@@ -394,13 +405,11 @@ describe "an ActiveRecord model which includes PgSearch" do
 
         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
+            ModelWithPgSearch.pg_search_scope :search_content_with_normalization,
+              :against => :content,
+              :using => {
+                :tsearch => {:normalization => 2}
+              }
           end
 
           it "ranks the results for documents with less text higher" do
@@ -413,11 +422,9 @@ describe "an ActiveRecord model which includes PgSearch" do
 
         context "with no normalization" do
           before do
-            ModelWithPgSearch.class_eval do
-              pg_search_scope :search_content_without_normalization,
-                              :against => :content,
-                              :using => :tsearch
-            end
+            ModelWithPgSearch.pg_search_scope :search_content_without_normalization,
+              :against => :content,
+              :using => :tsearch
           end
 
           it "ranks the results equally" do
@@ -431,9 +438,8 @@ describe "an ActiveRecord model which includes PgSearch" do
 
       context "against columns ranked with arrays" do
         before do
-          ModelWithPgSearch.class_eval do
-             pg_search_scope :search_weighted_by_array_of_arrays, :against => [[:content, 'B'], [:title, 'A']]
-          end
+          ModelWithPgSearch.pg_search_scope :search_weighted_by_array_of_arrays,
+            :against => [[:content, 'B'], [:title, 'A']]
         end
 
         it "returns results sorted by weighted rank" do
@@ -448,9 +454,8 @@ describe "an ActiveRecord model which includes PgSearch" do
 
       context "against columns ranked with a hash" do
         before do
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :search_weighted_by_hash, :against => {:content => 'B', :title => 'A'}
-          end
+          ModelWithPgSearch.pg_search_scope :search_weighted_by_hash,
+            :against => {:content => 'B', :title => 'A'}
         end
 
         it "returns results sorted by weighted rank" do
@@ -465,9 +470,8 @@ describe "an ActiveRecord model which includes PgSearch" do
 
       context "against columns of which only some are ranked" do
         before do
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :search_weighted, :against => [:content, [:title, 'A']]
-          end
+          ModelWithPgSearch.pg_search_scope :search_weighted,
+            :against => [:content, [:title, 'A']]
         end
 
         it "returns results sorted by weighted rank using an implied low rank for unranked columns" do
@@ -482,16 +486,14 @@ describe "an ActiveRecord model which includes PgSearch" do
 
       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
+          ModelWithPgSearch.pg_search_scope :search_title_with_any_word,
+            :against => :title,
+            :using => {
+              :tsearch => {:any_word => true}
+            }
+
+            ModelWithPgSearch.pg_search_scope :search_title_with_all_words,
+              :against => :title
         end
 
         it "returns all results containing any word in their title" do
@@ -510,9 +512,9 @@ describe "an ActiveRecord model which includes PgSearch" do
 
     context "using dmetaphone" do
       before do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :with_dmetaphones, :against => [:title, :content], :using => :dmetaphone
-        end
+        ModelWithPgSearch.pg_search_scope :with_dmetaphones,
+          :against => [:title, :content],
+          :using => :dmetaphone
       end
 
       it "returns rows where one searchable column and the query share enough dmetaphones" do
@@ -549,23 +551,23 @@ describe "an ActiveRecord model which includes PgSearch" do
 
     context "using multiple features" do
       before do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :with_tsearch,
-                          :against => :title,
-                          :using => [
-                            [:tsearch, {:dictionary => 'english'}]
-                          ]
+        ModelWithPgSearch.pg_search_scope :with_tsearch,
+          :against => :title,
+          :using => [
+            [:tsearch, {:dictionary => 'english'}]
+          ]
 
-          pg_search_scope :with_trigram, :against => :title, :using => :trigram
+        ModelWithPgSearch.pg_search_scope :with_trigram,
+          :against => :title,
+          :using => :trigram
 
-          pg_search_scope :with_tsearch_and_trigram_using_array,
-                          :against => :title,
-                          :using => [
-                            [:tsearch, {:dictionary => 'english'}],
-                            :trigram
-                          ]
+        ModelWithPgSearch.pg_search_scope :with_tsearch_and_trigram,
+          :against => :title,
+          :using => [
+            [:tsearch, {:dictionary => 'english'}],
+            :trigram
+          ]
 
-        end
       end
 
       it "returns rows that match using any of the features" do
@@ -575,13 +577,13 @@ describe "an ActiveRecord model which includes PgSearch" do
         trigram_query = "ling is grouty"
         ModelWithPgSearch.with_trigram(trigram_query).should include(record)
         ModelWithPgSearch.with_tsearch(trigram_query).should_not include(record)
-        ModelWithPgSearch.with_tsearch_and_trigram_using_array(trigram_query).should == [record]
+        ModelWithPgSearch.with_tsearch_and_trigram(trigram_query).should == [record]
 
         # matches tsearch only
         tsearch_query = "tiles"
         ModelWithPgSearch.with_tsearch(tsearch_query).should include(record)
         ModelWithPgSearch.with_trigram(tsearch_query).should_not include(record)
-        ModelWithPgSearch.with_tsearch_and_trigram_using_array(tsearch_query).should == [record]
+        ModelWithPgSearch.with_tsearch_and_trigram(tsearch_query).should == [record]
       end
 
       context "with feature-specific configuration" do
@@ -589,14 +591,12 @@ describe "an ActiveRecord model which includes PgSearch" do
           @tsearch_config = tsearch_config = {:dictionary => 'english'}
           @trigram_config = trigram_config = {:foo => 'bar'}
 
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :with_tsearch_and_trigram_using_hash,
-                            :against => :title,
-                            :using => {
-                              :tsearch => tsearch_config,
-                              :trigram => trigram_config
-                            }
-          end
+          ModelWithPgSearch.pg_search_scope :with_tsearch_and_trigram_using_hash,
+            :against => :title,
+            :using => {
+              :tsearch => tsearch_config,
+              :trigram => trigram_config
+            }
         end
 
         it "should pass the custom configuration down to the specified feature" do
@@ -628,16 +628,14 @@ describe "an ActiveRecord model which includes PgSearch" do
           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'
-              }
+        ModelWithPgSearchUsingTsVectorColumn.pg_search_scope :search_by_content_with_tsvector,
+          :against => :content,
+          :using => {
+            :tsearch => {
+              :tsvector_column => 'content_tsvector',
+              :dictionary => 'english'
             }
-        end
+          }
       end
 
       it "should not use to_tsvector in the query" do
@@ -651,16 +649,16 @@ describe "an ActiveRecord model which includes PgSearch" do
 
     context "ignoring accents" do
       before do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :search_title_without_accents, :against => :title, :ignoring => :accents
-        end
+        ModelWithPgSearch.pg_search_scope :search_title_without_accents,
+          :against => :title,
+          :ignoring => :accents
       end
 
       if ActiveRecord::Base.connection.send(:postgresql_version) < 90000
         it "is unsupported in PostgreSQL 8.x" do
-          lambda do
+          expect {
             ModelWithPgSearch.search_title_without_accents("abcd\303\251f")
-          end.should raise_exception(PgSearch::NotSupportedForPostgresqlVersion)
+          }.to raise_exception(PgSearch::NotSupportedForPostgresqlVersion)
         end
       else
         it "returns rows that match the query but not its accents" do
@@ -677,16 +675,16 @@ describe "an ActiveRecord model which includes PgSearch" do
 
     context "when passed a :ranked_by expression" do
       before do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :search_content_with_default_rank,
-                          :against => :content
-          pg_search_scope :search_content_with_importance_as_rank,
-                          :against => :content,
-                          :ranked_by => "importance"
-          pg_search_scope :search_content_with_importance_as_rank_multiplier,
-                          :against => :content,
-                          :ranked_by => ":tsearch * importance"
-        end
+        ModelWithPgSearch.pg_search_scope :search_content_with_default_rank,
+          :against => :content
+
+        ModelWithPgSearch.pg_search_scope :search_content_with_importance_as_rank,
+          :against => :content,
+          :ranked_by => "importance"
+
+        ModelWithPgSearch.pg_search_scope :search_content_with_importance_as_rank_multiplier,
+          :against => :content,
+          :ranked_by => ":tsearch * importance"
       end
 
       it "should return records with a rank attribute equal to the :ranked_by expression" do
@@ -716,22 +714,20 @@ describe "an ActiveRecord model which includes PgSearch" do
       end
 
       %w[tsearch trigram dmetaphone].each do |feature|
-
         context "using the #{feature} ranking algorithm" do
           before do
             @scope_name = scope_name = :"search_content_ranked_by_#{feature}"
-            ModelWithPgSearch.class_eval do
-              pg_search_scope scope_name,
-                              :against => :content,
-                              :ranked_by => ":#{feature}"
-            end
+
+            ModelWithPgSearch.pg_search_scope scope_name,
+              :against => :content,
+              :ranked_by => ":#{feature}"
           end
 
           it "should return results with a rank" do
             ModelWithPgSearch.create!(:content => 'foo')
 
             results = ModelWithPgSearch.send(@scope_name, 'foo')
-            results.first.pg_search_rank.should_not be_nil
+            results.first.pg_search_rank.should be_a Float
           end
         end
       end

data/sql/dmetaphone.sql

@@ -1,4 +1,3 @@
 CREATE OR REPLACE FUNCTION pg_search_dmetaphone(text) RETURNS text LANGUAGE SQL IMMUTABLE STRICT AS $function$
   SELECT array_to_string(ARRAY(SELECT dmetaphone(unnest(regexp_split_to_array($1, E'\\\\s+')))), ' ')
 $function$;
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_search
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: '0.5'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-09 00:00:00.000000000 Z
+date: 2012-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -70,6 +70,12 @@ files:
 - lib/pg_search/features/dmetaphone.rb
 - lib/pg_search/features/trigram.rb
 - lib/pg_search/features/tsearch.rb
+- lib/pg_search/migration/associated_against_generator.rb
+- lib/pg_search/migration/dmetaphone_generator.rb
+- lib/pg_search/migration/multisearch_generator.rb
+- lib/pg_search/migration/templates/add_pg_search_associated_against_support_functions.rb.erb
+- lib/pg_search/migration/templates/add_pg_search_dmetaphone_support_functions.rb.erb
+- lib/pg_search/migration/templates/create_pg_search_documents.rb
 - lib/pg_search/multisearch.rb
 - lib/pg_search/multisearchable.rb
 - lib/pg_search/normalizer.rb