pg_search 0.5.1 → 0.5.2

data/.travis.yml

@@ -12,3 +12,5 @@ rvm:
 
 before_script:
   - "psql -c 'create database pg_search_test;' -U postgres >/dev/null"
+
+script: "bundle exec rspec spec"

data/CHANGELOG.rdoc

@@ -1,5 +1,9 @@
 = PgSearch
 
+== 0.5.2
+
+* Don't save twice if pg_search_document is missing on update
+
 == 0.5.1
 
 * Add ability to override multisearch rebuild SQL

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-11 Case Commons, LLC
+Copyright (c) 2010-12 Case Commons, LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/pg_search.rb

@@ -3,6 +3,16 @@ require "active_support/concern"
 require "active_support/core_ext/module/attribute_accessors"
 
 module PgSearch
+  autoload :Configuration, "pg_search/configuration"
+  autoload :Document, "pg_search/document"
+  autoload :Features, "pg_search/features"
+  autoload :Multisearch, "pg_search/multisearch"
+  autoload :Multisearchable, "pg_search/multisearchable"
+  autoload :Normalizer, "pg_search/normalizer"
+  autoload :Scope, "pg_search/scope"
+  autoload :ScopeOptions, "pg_search/scope_options"
+  autoload :Version, "pg_search/version"
+
   extend ActiveSupport::Concern
 
   mattr_accessor :multisearch_options
@@ -10,10 +20,15 @@ module PgSearch
 
   module ClassMethods
     def pg_search_scope(name, options)
-      self.scope(
-        name,
-        PgSearch::Scope.new(name, self, options).to_proc
-      )
+      scope = PgSearch::Scope.new(name, self, options)
+
+      method_proc = scope.method(:build_relation)
+
+      if respond_to?(:define_singleton_method)
+        define_singleton_method name, &method_proc
+      else
+        (class << self; self; end).send :define_method, name, &method_proc
+      end
     end
 
     def multisearchable(options = {})
@@ -40,21 +55,15 @@ module PgSearch
     end
 
     def multisearch_enabled?
-      Thread.current.key?("PgSearch.enable_multisearch") ? Thread.current["PgSearch.enable_multisearch"] : true
+      if Thread.current.key?("PgSearch.enable_multisearch")
+        Thread.current["PgSearch.enable_multisearch"]
+      else
+        true
+      end
     end
   end
 
   class NotSupportedForPostgresqlVersion < StandardError; end
 end
 
-require "pg_search/configuration"
-require "pg_search/document"
-require "pg_search/features"
-require "pg_search/multisearch"
-require "pg_search/multisearchable"
-require "pg_search/normalizer"
-require "pg_search/scope"
-require "pg_search/scope_options"
-require "pg_search/version"
-
 require "pg_search/railtie" if defined?(Rails)

data/lib/pg_search/configuration.rb

@@ -1,13 +1,16 @@
-require "pg_search/configuration/association"
-require "pg_search/configuration/column"
-
 module PgSearch
   class Configuration
+    autoload :Association, "pg_search/configuration/association"
+    autoload :Column, "pg_search/configuration/column"
+    autoload :ForeignColumn, "pg_search/configuration/foreign_column"
+
+    attr_reader :model
+
     def initialize(options, model)
-      options = options.reverse_merge(default_options)
-      assert_valid_options(options)
-      @options = options
+      @options = default_options.merge(options)
       @model = model
+
+      assert_valid_options(@options)
     end
 
     class << self
@@ -32,8 +35,7 @@ module PgSearch
     def associations
       return [] unless @options[:associated_against]
       @options[:associated_against].map do |association, column_names|
-        association = Association.new(@model, association, column_names)
-        association
+        Association.new(@model, association, column_names)
       end.flatten
     end
 
@@ -75,20 +77,26 @@ module PgSearch
       {:using => :tsearch}
     end
 
-    def assert_valid_options(options)
-      valid_keys = [:against, :ranked_by, :ignoring, :using, :query, :associated_against, :order_within_rank]
-      valid_values = {
-        :ignoring => [:accents]
-      }
+    VALID_KEYS = %w[
+      against ranked_by ignoring using query associated_against order_within_rank
+    ].map(&:to_sym)
 
+    VALID_VALUES = {
+      :ignoring => [:accents]
+    }
+
+    def assert_valid_options(options)
       unless options[:against] || options[:associated_against]
         raise ArgumentError, "the search scope #{@name} must have :against#{" or :associated_against" if defined?(ActiveRecord::Relation)} in its options"
       end
-      raise ArgumentError, ":associated_against requires ActiveRecord 3 or later" if options[:associated_against] && !defined?(ActiveRecord::Relation)
 
-      options.assert_valid_keys(valid_keys)
+      if options[:associated_against] && !defined?(ActiveRecord::Relation)
+        raise ArgumentError, ":associated_against requires Active Record 3 or later"
+      end
+
+      options.assert_valid_keys(VALID_KEYS)
 
-      valid_values.each do |key, values_for_key|
+      VALID_VALUES.each do |key, values_for_key|
         Array.wrap(options[key]).each do |value|
           unless values_for_key.include?(value)
             raise ArgumentError, ":#{key} cannot accept #{value}"

data/lib/pg_search/configuration/association.rb

@@ -9,7 +9,7 @@ module PgSearch
         @model = model
         @name = name
         @columns = Array(column_names).map do |column_name, weight|
-          Column.new(column_name, weight, @model, self)
+          ForeignColumn.new(column_name, weight, @model, self)
         end
       end
 
@@ -18,20 +18,30 @@ module PgSearch
       end
 
       def join(primary_key)
-        selects = columns.map do |column|
-          case @model.connection.send(:postgresql_version)
+        "LEFT OUTER JOIN (#{relation(primary_key).to_sql}) #{subselect_alias} ON #{subselect_alias}.id = #{primary_key}"
+      end
+
+      def subselect_alias
+        Configuration.alias(table_name, @name, "subselect")
+      end
+
+      private
+
+      def selects
+        postgresql_version = @model.connection.send(:postgresql_version)
+
+        columns.map do |column|
+          case postgresql_version
           when 0..90000
-            "array_to_string(array_agg(#{column.full_name}), ' ') AS #{column.alias}"
+            "array_to_string(array_agg(#{column.full_name}::text), ' ') AS #{column.alias}"
           else
             "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)
-        "LEFT OUTER JOIN (#{relation.to_sql}) #{subselect_alias} ON #{subselect_alias}.id = #{primary_key}"
       end
 
-      def subselect_alias
-        Configuration.alias(table_name, @name, "subselect")
+      def relation(primary_key)
+        @model.joins(@name).select("#{primary_key} AS id, #{selects}").group(primary_key)
       end
     end
   end

data/lib/pg_search/configuration/column.rb

@@ -3,34 +3,35 @@ require 'digest'
 module PgSearch
   class Configuration
     class Column
-      attr_reader :weight, :association
+      attr_reader :weight
 
-      def initialize(column_name, weight, model, association = nil)
+      def initialize(column_name, weight, model)
         @column_name = column_name.to_s
         @weight = weight
         @model = model
-        @association = association
-      end
-
-      def table
-        foreign? ? @association.table_name : @model.table_name
+        @connection = model.connection
       end
 
       def full_name
-        "#{@model.connection.quote_table_name(table)}.#{@model.connection.quote_column_name(@column_name)}"
+        "#{table_name}.#{column_name}"
       end
 
       def to_sql
-        name = if foreign?
-                 "#{@association.subselect_alias}.#{self.alias}"
-               else
-                 full_name
-               end
-        "coalesce(#{name}::text, '')"
+        "coalesce(#{expression}::text, '')"
+      end
+
+      private
+
+      def table_name
+        @connection.quote_table_name(@model.table_name)
+      end
+
+      def column_name
+        @connection.quote_column_name(@column_name)
       end
 
-      def foreign?
-        @association.present?
+      def expression
+        full_name
       end
 
       def alias

data/lib/pg_search/configuration/foreign_column.rb

@@ -0,0 +1,28 @@
+require 'digest'
+
+module PgSearch
+  class Configuration
+    class ForeignColumn < Column
+      attr_reader :weight
+
+      def initialize(column_name, weight, model, association)
+        super(column_name, weight, model)
+        @association = association
+      end
+
+      def alias
+        Configuration.alias(@association.subselect_alias, @column_name)
+      end
+
+      private
+
+      def expression
+        "#{@association.subselect_alias}.#{self.alias}"
+      end
+
+      def table_name
+        @connection.quote_table_name(@association.table_name)
+      end
+    end
+  end
+end

data/lib/pg_search/document.rb

@@ -1,5 +1,4 @@
 require "logger"
-require "pg_search/scope"
 
 module PgSearch
   class Document < ActiveRecord::Base
@@ -19,9 +18,10 @@ module PgSearch
       options = if PgSearch.multisearch_options.respond_to?(:call)
         PgSearch.multisearch_options.call(*args)
       else
-        PgSearch.multisearch_options.reverse_merge(:query => args.first)
+        {:query => args.first}.merge(PgSearch.multisearch_options)
       end
-      options.reverse_merge(:against => :content)
+
+      {:against => :content}.merge(options)
     }
 
     private

data/lib/pg_search/features.rb

@@ -1,7 +1,9 @@
 module PgSearch
   module Features
+    autoload :Feature, "pg_search/features/feature"
+
+    autoload :DMetaphone, "pg_search/features/dmetaphone"
+    autoload :Trigram, "pg_search/features/trigram"
+    autoload :TSearch, "pg_search/features/tsearch"
   end
 end
-require 'pg_search/features/dmetaphone'
-require 'pg_search/features/trigram'
-require 'pg_search/features/tsearch'

data/lib/pg_search/features/dmetaphone.rb

@@ -1,15 +1,18 @@
-require "active_support/core_ext/module/delegation"
-
 module PgSearch
   module Features
     class DMetaphone
-      delegate :conditions, :rank, :to => :'@tsearch'
-
-      # config is temporary as we refactor
-      def initialize(query, options, config, model, normalizer)
+      def initialize(query, options, columns, model, normalizer)
         dmetaphone_normalizer = Normalizer.new(normalizer)
         options = (options || {}).merge(:dictionary => 'simple')
-        @tsearch = TSearch.new(query, options, config, model, dmetaphone_normalizer)
+        @tsearch = TSearch.new(query, options, columns, model, dmetaphone_normalizer)
+      end
+
+      def conditions
+        @tsearch.conditions
+      end
+
+      def rank
+        @tsearch.rank
       end
 
       # Decorates a normalizer with dmetaphone processing.

data/lib/pg_search/features/feature.rb

@@ -0,0 +1,28 @@
+module PgSearch
+  module Features
+    class Feature
+      def initialize(query, options, columns, model, normalizer)
+        @query = query
+        @options = options || {}
+        @columns = columns
+        @model = model
+        @normalizer = normalizer
+      end
+
+      private
+
+      def document
+        if @columns.length == 1
+          @columns.first.to_sql
+        else
+          expressions = @columns.map { |column| column.to_sql }.join(", ")
+          "array_to_string(ARRAY[#{expressions}], ' ')"
+        end
+      end
+
+      def normalize(expression)
+        @normalizer.add_normalization(expression)
+      end
+    end
+  end
+end

data/lib/pg_search/features/trigram.rb

@@ -1,28 +1,18 @@
-require "active_support/core_ext/module/delegation"
-
 module PgSearch
   module Features
-    class Trigram
-      def initialize(query, options, columns, model, normalizer)
-        @query = query
-        @options = options
-        @columns = columns
-        @model = model
-        @normalizer = normalizer
-      end
-
+    class Trigram < Feature
       def conditions
-        ["(#{@normalizer.add_normalization(document)}) % #{@normalizer.add_normalization(":query")}", {:query => @query}]
+        [
+          "(#{normalize(document)}) % #{normalize(":query")}",
+          {:query => @query}
+        ]
       end
 
       def rank
-        ["similarity((#{@normalizer.add_normalization(document)}), #{@normalizer.add_normalization(":query")})", {:query => @query}]
-      end
-
-      private
-
-      def document
-        @columns.map { |column| column.to_sql }.join(" || ' ' || ")
+        [
+          "similarity((#{normalize(document)}), #{normalize(":query")})",
+          {:query => @query}
+        ]
       end
     end
   end

data/lib/pg_search/features/tsearch.rb

@@ -2,15 +2,11 @@ require "active_support/core_ext/module/delegation"
 
 module PgSearch
   module Features
-    class TSearch
+    class TSearch < Feature
       delegate :connection, :quoted_table_name, :to => :'@model'
 
       def initialize(query, options, columns, model, normalizer)
-        @query = query
-        @options = options || {}
-        @model = model
-        @columns = columns
-        @normalizer = normalizer
+        super
 
         if @options[:prefix] && @model.connection.send(:postgresql_version) < 80400
           raise PgSearch::NotSupportedForPostgresqlVersion.new(<<-MESSAGE.gsub /^\s*/, '')
@@ -33,24 +29,20 @@ module PgSearch
         {:query => @query.to_s, :dictionary => dictionary.to_s}
       end
 
-      def document
-        @columns.map { |column| column.to_sql }.join(" || ' ' || ")
-      end
-
       DISALLOWED_TSQUERY_CHARACTERS = /['?\\:]/
 
       def tsquery_for_term(term)
         sanitized_term = term.gsub(DISALLOWED_TSQUERY_CHARACTERS, " ")
 
-        term_sql = @normalizer.add_normalization(connection.quote(sanitized_term))
+        term_sql = normalize(connection.quote(sanitized_term))
 
         # After this, the SQL expression evaluates to a string containing the term surrounded by single-quotes.
         # If :prefix is true, then the term will also have :* appended to the end.
         tsquery_sql = [
-            connection.quote("' "),
-            term_sql,
-            connection.quote(" '"),
-            (connection.quote(':*') if @options[:prefix])
+          connection.quote("' "),
+          term_sql,
+          connection.quote(" '"),
+          (connection.quote(':*') if @options[:prefix])
         ].compact.join(" || ")
 
         "to_tsquery(:dictionary, #{tsquery_sql})"
@@ -58,7 +50,9 @@ module PgSearch
 
       def tsquery
         return "''" if @query.blank?
-        @query.split(" ").compact.map { |term| tsquery_for_term(term) }.join(@options[:any_word] ? ' || ' : ' && ')
+        query_terms = @query.split(" ").compact
+        tsquery_terms = query_terms.map { |term| tsquery_for_term(term) }
+        tsquery_terms.join(@options[:any_word] ? ' || ' : ' && ')
       end
 
       def tsdocument
@@ -67,8 +61,12 @@ module PgSearch
           "#{quoted_table_name}.#{column_name}"
         else
           @columns.map do |search_column|
-            tsvector = "to_tsvector(:dictionary, #{@normalizer.add_normalization(search_column.to_sql)})"
-            search_column.weight.nil? ? tsvector : "setweight(#{tsvector}, #{connection.quote(search_column.weight)})"
+            tsvector = "to_tsvector(:dictionary, #{normalize(search_column.to_sql)})"
+            if search_column.weight.nil?
+              tsvector
+            else
+              "setweight(#{tsvector}, #{connection.quote(search_column.weight)})"
+            end
           end.join(" || ")
         end
       end

data/lib/pg_search/multisearch.rb

@@ -1,56 +1,14 @@
 module PgSearch
   module Multisearch
-    REBUILD_SQL_TEMPLATE = <<-SQL
-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,
-         :current_time AS created_at,
-         :current_time AS updated_at
-  FROM :model_table
-SQL
+    autoload :Rebuilder, "pg_search/multisearch/rebuilder"
 
     class << self
       def rebuild(model, clean_up=true)
         model.transaction do
           PgSearch::Document.where(:searchable_type => model.name).delete_all if clean_up
-          if model.respond_to?(:rebuild_pg_search_documents)
-            model.rebuild_pg_search_documents
-          else
-            model.connection.execute(rebuild_sql(model))
-          end
+          Rebuilder.new(model).rebuild
         end
       end
-
-      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 { |column|
-          %Q{coalesce(:model_table.#{column}::text, '')}
-        }.join(" || ' ' || ")
-
-        REBUILD_SQL_TEMPLATE.gsub(
-          ":content_expressions", content_expressions
-        ).gsub(
-          ":model_name", connection.quote(model.name)
-        ).gsub(
-          ":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

data/lib/pg_search/multisearch/rebuilder.rb

@@ -0,0 +1,75 @@
+module PgSearch
+  module Multisearch
+    class Rebuilder
+      REBUILD_SQL_TEMPLATE = <<-SQL
+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,
+         :current_time AS created_at,
+         :current_time AS updated_at
+  FROM :model_table
+SQL
+
+      def initialize(model)
+        unless model.respond_to?(:pg_search_multisearchable_options)
+          raise ModelNotMultisearchable.new(model)
+        end
+
+        @model = model
+      end
+
+      def rebuild
+        if @model.respond_to?(:rebuild_pg_search_documents)
+          @model.rebuild_pg_search_documents
+        else
+          @model.connection.execute(rebuild_sql)
+        end
+      end
+
+      private
+
+      def connection
+        @model.connection
+      end
+
+      def rebuild_sql
+        replacements.inject(REBUILD_SQL_TEMPLATE) do |sql, key|
+          sql.gsub ":#{key}", send(key)
+        end
+      end
+
+      def replacements
+        %w[content_expressions model_name model_table documents_table current_time]
+      end
+
+      def content_expressions
+        columns.map { |column|
+          %Q{coalesce(:model_table.#{column}::text, '')}
+        }.join(" || ' ' || ")
+      end
+
+      def columns
+        Array.wrap(@model.pg_search_multisearchable_options[:against])
+      end
+
+      def model_name
+        connection.quote(@model.name)
+      end
+
+      def model_table
+        @model.quoted_table_name
+      end
+
+      def documents_table
+        PgSearch::Document.quoted_table_name
+      end
+
+      def current_time
+        connection.quote(connection.quoted_date(Time.now))
+      end
+    end
+  end
+end

data/lib/pg_search/multisearchable.rb

@@ -19,8 +19,11 @@ module PgSearch
     end
 
     def update_pg_search_document
-      create_pg_search_document unless self.pg_search_document
-      self.pg_search_document.save
+      if self.pg_search_document
+        self.pg_search_document.save
+      else
+        create_pg_search_document
+      end
     end
   end
 end

data/lib/pg_search/normalizer.rb

@@ -4,19 +4,19 @@ module PgSearch
       @config = config
     end
 
-    def add_normalization(original_sql)
-      normalized_sql = original_sql
+    def add_normalization(sql_expression)
       if @config.ignore.include?(:accents)
         if @config.postgresql_version < 90000
           raise PgSearch::NotSupportedForPostgresqlVersion.new(<<-MESSAGE.gsub /^\s*/, '')
-          Sorry, {:ignoring => :accents} only works in PostgreSQL 9.0 and above.
-          #{@config.inspect}
+            Sorry, {:ignoring => :accents} only works in PostgreSQL 9.0 and above.
+            #{@config.inspect}
           MESSAGE
         else
-          normalized_sql = "unaccent(#{normalized_sql})"
+          "unaccent(#{sql_expression})"
         end
+      else
+        sql_expression
       end
-      normalized_sql
     end
   end
 end

data/lib/pg_search/scope.rb

@@ -6,26 +6,22 @@ module PgSearch
       @options_proc = build_options_proc(scope_options_or_proc)
     end
 
-    def to_proc
-      lambda { |*args|
-        config = Configuration.new(@options_proc.call(*args), @model)
-        ScopeOptions.new(@name, @model, config).to_relation
-      }
+    def build_relation(*args)
+      config = Configuration.new(@options_proc.call(*args), @model)
+      scope_options = ScopeOptions.new(@name, config)
+      scope_options.apply(@model)
     end
 
     private
 
-    def build_options_proc(scope_options_or_proc)
-      case scope_options_or_proc
-        when Proc
-          scope_options_or_proc
-        when Hash
-          lambda { |query|
-            scope_options_or_proc.reverse_merge(:query => query)
-          }
-        else
-          raise ArgumentError, "A PgSearch scope expects a Proc or Hash for its options"
+    def build_options_proc(scope_options)
+      return scope_options if scope_options.respond_to?(:call)
+
+      unless scope_options.respond_to?(:merge)
+        raise ArgumentError, "pg_search_scope expects a Hash or Proc"
       end
+
+      lambda { |query| {:query => query}.merge(scope_options) }
     end
   end
 end

data/lib/pg_search/scope_options.rb

@@ -2,31 +2,25 @@ require "active_support/core_ext/module/delegation"
 
 module PgSearch
   class ScopeOptions
-    attr_reader :model
+    delegate :connection, :quoted_table_name, :sanitize_sql_array, :to => :@model
 
-    delegate :connection, :quoted_table_name, :sanitize_sql_array, :to => :model
-
-    def initialize(name, model, config)
+    def initialize(name, config)
       @name = name
-      @model = model
       @config = config
-
-      @feature_options = @config.features.inject({}) do |features_hash, (feature_name, feature_options)|
-        features_hash.merge(
-          feature_name => feature_options
-        )
-      end
-      @feature_names = @config.features.map { |feature_name, feature_options| feature_name }
+      @model = config.model
+      @feature_options = Hash[config.features]
     end
 
-    def to_relation
-      @model.select("#{quoted_table_name}.*, (#{rank}) AS pg_search_rank").where(conditions).order("pg_search_rank DESC, #{order_within_rank}").joins(joins)
+    def apply(scope)
+      scope.select("#{quoted_table_name}.*, (#{rank}) AS pg_search_rank").where(conditions).order("pg_search_rank DESC, #{order_within_rank}").joins(joins)
     end
 
     private
 
     def conditions
-      @feature_names.map { |feature_name| "(#{sanitize_sql_array(feature_for(feature_name).conditions)})" }.join(" OR ")
+      @config.features.map do |feature_name, feature_options|
+        "(#{sanitize_sql_array(feature_for(feature_name).conditions)})"
+      end.join(" OR ")
     end
 
     def order_within_rank
@@ -34,7 +28,7 @@ module PgSearch
     end
 
     def primary_key
-      "#{quoted_table_name}.#{connection.quote_column_name(model.primary_key)}"
+      "#{quoted_table_name}.#{connection.quote_column_name(@model.primary_key)}"
     end
 
     def joins
@@ -57,7 +51,13 @@ module PgSearch
 
       normalizer = Normalizer.new(@config)
 
-      feature_class.new(@config.query, @feature_options[feature_name], @config.columns, @model, normalizer)
+      feature_class.new(
+        @config.query,
+        @feature_options[feature_name],
+        @config.columns,
+        @config.model,
+        normalizer
+      )
     end
 
     def rank

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end

data/spec/pg_search/multisearch_spec.rb

@@ -105,22 +105,21 @@ describe PgSearch::Multisearch do
         PgSearch::Document.last(2).map(&:searchable).map(&:title).should =~ new_models.map(&:title)
       end
     end
-  end
-
-  describe ".rebuild_sql" do
-    let(:now) { Time.now }
 
-    before do
-      Time.stub(:now => now)
-    end
+    describe "the generated SQL" do
+      let(:now) { Time.now }
 
-    context "with one attribute" do
       before do
-        model.multisearchable :against => [:title]
+        Time.stub(:now => now)
       end
 
-      it "should generate the proper SQL code" do
-        expected_sql = <<-SQL
+      context "with one attribute" do
+        before do
+          model.multisearchable :against => [:title]
+        end
+
+        it "should generate the proper SQL code" do
+          expected_sql = <<-SQL
 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,
@@ -132,17 +131,22 @@ INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable
   FROM #{model.quoted_table_name}
   SQL
 
-        PgSearch::Multisearch.rebuild_sql(model).should == expected_sql
-      end
-    end
+          statements = []
+          connection.stub(:execute) { |sql| statements << sql }
 
-    context "with multiple attributes" do
-      before do
-        model.multisearchable :against => [:title, :content]
+          PgSearch::Multisearch.rebuild(model)
+
+          statements.should include(expected_sql)
+        end
       end
 
-      it "should generate the proper SQL code" do
-        expected_sql = <<-SQL
+      context "with multiple attributes" do
+        before do
+          model.multisearchable :against => [:title, :content]
+        end
+
+        it "should generate the proper SQL code" do
+          expected_sql = <<-SQL
 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,
@@ -152,9 +156,15 @@ INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable
          #{connection.quote(connection.quoted_date(now))} AS created_at,
          #{connection.quote(connection.quoted_date(now))} AS updated_at
   FROM #{model.quoted_table_name}
-  SQL
+SQL
+
+          statements = []
+          connection.stub(:execute) { |sql| statements << sql }
 
-        PgSearch::Multisearch.rebuild_sql(model).should == expected_sql
+          PgSearch::Multisearch.rebuild(model)
+
+          statements.should include(expected_sql)
+        end
       end
     end
   end

data/spec/spec_helper.rb

@@ -28,11 +28,13 @@ begin
   postgresql_version = connection.send(:postgresql_version)
   connection.execute("SELECT 1")
 rescue error_class => e
-  puts "-" * 80
-  puts "Unable to connect to database.  Please run:"
-  puts
-  puts "    createdb pg_search_test"
-  puts "-" * 80
+  at_exit do
+    puts "-" * 80
+    puts "Unable to connect to database.  Please run:"
+    puts
+    puts "    createdb pg_search_test"
+    puts "-" * 80
+  end
   raise e
 end
 
@@ -56,9 +58,11 @@ rescue => e
       puts $!.message
     end
   rescue => e2
-    puts "-" * 80
-    puts "Please install the #{name} contrib module"
-    puts "-" * 80
+    at_exit do
+      puts "-" * 80
+      puts "Please install the #{name} contrib module"
+      puts "-" * 80
+    end
     raise e2
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_search
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-01 00:00:00.000000000 Z
+date: 2012-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -65,9 +65,11 @@ files:
 - lib/pg_search/configuration.rb
 - lib/pg_search/configuration/association.rb
 - lib/pg_search/configuration/column.rb
+- lib/pg_search/configuration/foreign_column.rb
 - lib/pg_search/document.rb
 - lib/pg_search/features.rb
 - lib/pg_search/features/dmetaphone.rb
+- lib/pg_search/features/feature.rb
 - lib/pg_search/features/trigram.rb
 - lib/pg_search/features/tsearch.rb
 - lib/pg_search/migration/associated_against_generator.rb
@@ -77,6 +79,7 @@ files:
 - 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/multisearch/rebuilder.rb
 - lib/pg_search/multisearchable.rb
 - lib/pg_search/normalizer.rb
 - lib/pg_search/railtie.rb
@@ -111,7 +114,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1351986722427483921
+      hash: -1173780423204059667
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -120,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1351986722427483921
+      hash: -1173780423204059667
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24