pg_search 0.2.2 → 0.3

data/lib/pg_search/configuration/association.rb

@@ -4,7 +4,7 @@ module PgSearch
   class Configuration
     class Association
       attr_reader :columns
-      
+
       def initialize(model, name, column_names)
         @model = model
         @name = name
@@ -12,11 +12,11 @@ module PgSearch
           Column.new(column_name, weight, @model, self)
         end
       end
-      
+
       def table_name
         @model.reflect_on_association(@name).table_name
       end
-      
+
       def join(primary_key)
         selects = columns.map do |column|
           "string_agg(#{column.full_name}, ' ') AS #{column.alias}"
@@ -24,10 +24,9 @@ module PgSearch
         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
-        subselect_name = ["pg_search", table_name, @name, "subselect"].compact.join('_')
-        "pg_search_#{Digest::SHA2.hexdigest(subselect_name)}"
+        Configuration.alias(table_name, @name, "subselect")
       end
     end
   end

data/lib/pg_search/configuration/column.rb

@@ -34,8 +34,7 @@ module PgSearch
       end
 
       def alias
-        name = [association.subselect_alias, @column_name].compact.join('_')
-        "pg_search_#{Digest::SHA2.hexdigest(name)}"
+        Configuration.alias(association.subselect_alias, @column_name)
       end
     end
   end

data/lib/pg_search/document.rb

@@ -0,0 +1,21 @@
+require "pg_search/scope"
+
+module PgSearch
+  class Document < ActiveRecord::Base
+    include PgSearch
+    set_table_name :pg_search_documents
+    belongs_to :searchable, :polymorphic => true
+
+    before_validation :update_content
+
+    pg_search_scope :search, :against => :content
+
+    private
+
+    def update_content
+      methods = Array.wrap(searchable.pg_search_multisearchable_options[:against])
+      searchable_text = methods.map { |symbol| searchable.send(symbol) }.join(" ")
+      self.content = searchable_text
+    end
+  end
+end

data/lib/pg_search/features/tsearch.rb

@@ -46,22 +46,31 @@ module PgSearch
           tsquery_sql = "#{tsquery_sql} || #{connection.quote(':*')}" if @options[:prefix]
 
           "to_tsquery(:dictionary, #{tsquery_sql})"
-        end.join(" && ")
+        end.join(@options[:any_word] ? ' || ' : ' && ')
       end
 
       def tsdocument
-        if @options[:tsvector_column]
-          @options[:tsvector_column].to_s
-        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)})"
-          end.join(" || ")
-        end
+        @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)})"
+        end.join(" || ")
+      end
+      
+      # From http://www.postgresql.org/docs/8.3/static/textsearch-controls.html
+      #   0 (the default) ignores the document length
+      #   1 divides the rank by 1 + the logarithm of the document length
+      #   2 divides the rank by the document length
+      #   4 divides the rank by the mean harmonic distance between extents (this is implemented only by ts_rank_cd)
+      #   8 divides the rank by the number of unique words in document
+      #   16 divides the rank by 1 + the logarithm of the number of unique words in document
+      #   32 divides the rank by itself + 1
+      # The integer option controls several behaviors, so it is a bit mask: you can specify one or more behaviors
+      def normalization
+        @options[:normalization] || 0
       end
 
       def tsearch_rank
-        ["ts_rank((#{tsdocument}), (#{tsquery}))", interpolations]
+        ["ts_rank((#{tsdocument}), (#{tsquery}), #{normalization})", interpolations]
       end
 
       def dictionary

data/lib/pg_search/multisearch.rb

@@ -0,0 +1,46 @@
+module PgSearch
+  module Multisearch
+    REBUILD_SQL_TEMPLATE = <<-SQL
+INSERT INTO :documents_table (searchable_type, searchable_id, content)
+  SELECT :model_name AS searchable_type,
+         :model_table.id AS searchable_id,
+         (
+           :content_expressions
+         ) AS content
+  FROM :model_table
+SQL
+
+    class << self
+      def rebuild(model)
+        model.transaction do
+          PgSearch::Document.where(:searchable_type => model.name).delete_all
+          model.connection.execute(rebuild_sql(model))
+        end
+      end
+
+      def rebuild_sql(model)
+        connection = model.connection
+
+        columns = Array.wrap(
+          model.pg_search_multisearchable_options[:against]
+        )
+
+        content_expressions = columns.map do |column|
+          %Q{coalesce(:model_table.#{column}, '')}
+        end.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
+        )
+      end
+    end
+  end
+end
+
+

data/lib/pg_search/multisearchable.rb

@@ -0,0 +1,28 @@
+require "active_support/concern"
+require "active_support/core_ext/class/attribute"
+
+module PgSearch
+  module Multisearchable
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :pg_search_document,
+        :as => :searchable,
+        :class_name => "PgSearch::Document",
+        :dependent => :delete
+
+      after_create :create_pg_search_document,
+        :if => lambda { PgSearch.multisearch_enabled? }
+
+      after_update :update_pg_search_document,
+        :if => lambda { PgSearch.multisearch_enabled? }
+    end
+
+    module InstanceMethods
+      def update_pg_search_document
+        create_pg_search_document unless self.pg_search_document
+        self.pg_search_document.save
+      end
+    end
+  end
+end

data/lib/pg_search/railtie.rb

@@ -1,10 +1,6 @@
-require 'pg_search'
-#require 'rails'
-
 module PgSearch
   class Railtie < Rails::Railtie
     rake_tasks do
-      raise
       load "pg_search/tasks.rb"
     end
   end

data/lib/pg_search/scope.rb

@@ -9,7 +9,7 @@ module PgSearch
     def to_proc
       lambda { |*args|
         config = Configuration.new(@options_proc.call(*args), @model)
-        ScopeOptions.new(@name, @model, config).to_hash
+        ScopeOptions.new(@name, @model, config).to_relation
       }
     end
 

data/lib/pg_search/scope_options.rb

@@ -19,13 +19,8 @@ module PgSearch
       @feature_names = @config.features.map { |feature_name, feature_options| feature_name }
     end
 
-    def to_hash
-      {
-        :select => "#{quoted_table_name}.*, (#{rank}) AS pg_search_rank",
-        :conditions => conditions,
-        :order => "pg_search_rank DESC, #{primary_key} ASC",
-        :joins => joins
-      }
+    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)
     end
 
     private
@@ -34,6 +29,10 @@ module PgSearch
       @feature_names.map { |feature_name| "(#{sanitize_sql_array(feature_for(feature_name).conditions)})" }.join(" OR ")
     end
 
+    def order_within_rank
+      @config.order_within_rank || "#{primary_key} ASC"
+    end
+
     def primary_key
       "#{quoted_table_name}.#{connection.quote_column_name(model.primary_key)}"
     end
@@ -44,14 +43,15 @@ module PgSearch
       end.join(' ')
     end
 
+    FEATURE_CLASSES = {
+      :dmetaphone => Features::DMetaphone,
+      :tsearch => Features::TSearch,
+      :trigram => Features::Trigram
+    }
+
     def feature_for(feature_name)
       feature_name = feature_name.to_sym
-
-      feature_class = {
-        :dmetaphone => Features::DMetaphone,
-        :tsearch => Features::TSearch,
-        :trigram => Features::Trigram
-      }[feature_name]
+      feature_class = FEATURE_CLASSES[feature_name]
 
       raise ArgumentError.new("Unknown feature: #{feature_name}") unless feature_class
 
@@ -60,10 +60,6 @@ module PgSearch
       feature_class.new(@config.query, @feature_options[feature_name], @config.columns, @model, normalizer)
     end
 
-    def tsearch_rank
-      sanitize_sql_array(@feature_names[Features::TSearch].rank)
-    end
-
     def rank
       (@config.ranking_sql || ":tsearch").gsub(/:(\w*)/) do
         sanitize_sql_array(feature_for($1).rank)

data/lib/pg_search/tasks.rb

@@ -2,7 +2,44 @@ require 'rake'
 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
+      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

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.2.2"
+  VERSION = "0.3"
 end

data/pg_search.gemspec

@@ -16,4 +16,7 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+
+  s.add_dependency 'activerecord', '>=3'
+  s.add_dependency 'activesupport', '>=3'
 end

data/spec/associations_spec.rb

@@ -2,314 +2,293 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe PgSearch do
   context "joining to another table" do
-    if defined?(ActiveRecord::Relation)
-      context "with Arel support" do
-        context "without an :against" do
-          with_model :AssociatedModel do
-            table do |t|
-              t.string "title"
-            end
+    context "with Arel support" do
+      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
 
-        context "through a belongs_to association" do
-          with_model :AssociatedModel do
-            table do |t|
-              t.string 'title'
-            end
+        with_model :ModelWithBelongsTo do
+          table do |t|
+            t.string 'title'
+            t.belongs_to 'another_model'
           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'
 
-            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
 
-              pg_search_scope :with_associated, :against => :title, :associated_against => {:another_model => :title}
-            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
 
-          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'))
+        with_model :ModelWithHasMany do
+          table do |t|
+            t.string 'title'
+          end
 
-            results = ModelWithBelongsTo.with_associated('abcdef')
-            results.map(&:title).should =~ included.map(&:title)
-            results.should_not include(excluded)
+          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 has_many association" do
-          with_model :AssociatedModelWithHasMany 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 'ModelWithHasMany'
+              t.belongs_to 'ModelWithManyAssociations'
             end
+            model {}
           end
 
-          with_model :ModelWithHasMany do
+          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
 
             model do
               include PgSearch
-              has_many :other_models, :class_name => 'AssociatedModelWithHasMany', :foreign_key => 'ModelWithHasMany_id'
+              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 => {:other_models => :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
+            matching_second = SecondAssociatedModel.create!(:title => "foo bar")
+            unmatching_second = SecondAssociatedModel.create!(:title => "uiop")
+
             included = [
-              ModelWithHasMany.create!(:title => 'abcdef', :other_models => [
-                                          AssociatedModelWithHasMany.create!(:title => 'foo'),
-                                          AssociatedModelWithHasMany.create!(:title => 'bar')
+              ModelWithManyAssociations.create!(:title => 'abcdef', :models_of_first_type => [
+                                                FirstAssociatedModel.create!(:title => 'foo'),
+                                                FirstAssociatedModel.create!(:title => 'bar')
             ]),
-              ModelWithHasMany.create!(:title => 'ghijkl', :other_models => [
-                                          AssociatedModelWithHasMany.create!(:title => 'foo bar'),
-                                          AssociatedModelWithHasMany.create!(:title => 'mnopqr')
+              ModelWithManyAssociations.create!(:title => 'ghijkl', :models_of_first_type => [
+                                                FirstAssociatedModel.create!(:title => 'foo bar'),
+                                                FirstAssociatedModel.create!(:title => 'mnopqr')
             ]),
-              ModelWithHasMany.create!(:title => 'foo bar')
+              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 = ModelWithHasMany.create!(:title => 'stuvwx', :other_models => [
-                                                   AssociatedModelWithHasMany.create!(:title => 'abcdef')
-            ])
 
-            results = ModelWithHasMany.with_associated('foo bar')
+            results = ModelWithManyAssociations.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 'model_with_many_associations'
-              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
-
-              model do
-                include PgSearch
-                has_many :models_of_first_type, :class_name => 'FirstAssociatedModel', :foreign_key => 'model_with_many_associations_id'
-                belongs_to :model_of_second_type, :class_name => 'SecondAssociatedModel'
-
-                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
-              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
-          end
-
-          context "on the same table" do
-            with_model :DoublyAssociatedModel do
-              table do |t|
-                t.string 'title'
-                t.belongs_to 'model_with_double_association'
-                t.belongs_to 'model_with_double_association_again'
-              end
-              model {}
-            end
-
-            with_model :model_with_double_association do
-              table do |t|
-                t.string 'title'
-              end
-
-              model do
-                include PgSearch
-                has_many :things, :class_name => 'DoublyAssociatedModel', :foreign_key => 'model_with_double_association_id'
-                has_many :thingamabobs, :class_name => 'DoublyAssociatedModel', :foreign_key => 'model_with_double_association_again_id'
-
-                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 = [
-                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
+            excluded.each { |object| results.should_not include(object) }
           end
         end
 
-        context "against multiple attributes on one association" do
-          with_model :AssociatedModel do
+        context "on the same table" do
+          with_model :DoublyAssociatedModel do
             table do |t|
               t.string 'title'
-              t.text 'author'
+              t.belongs_to 'ModelWithDoubleAssociation'
+              t.belongs_to 'ModelWithDoubleAssociation_again'
             end
+            model {}
           end
 
-          with_model :ModelWithAssociation do
+          with_model :ModelWithDoubleAssociation do
             table do |t|
-              t.belongs_to 'another_model'
+              t.string 'title'
             end
 
             model do
               include PgSearch
-              belongs_to :another_model, :class_name => 'AssociatedModel'
+              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, :associated_against => {:another_model => [:title, :author]}
+              pg_search_scope :with_associated, :against => :title,
+                :associated_against => {:things => :title, :thingamabobs => :title}
             end
           end
 
-          it "should only do one join" do
+          it "returns rows that match the query in either its own columns or the columns of the associated model" do
             included = [
-              ModelWithAssociation.create!(
-                :another_model => AssociatedModel.create!(
-                  :title => "foo",
-                  :author => "bar"
-                )
-              ),
-              ModelWithAssociation.create!(
-                :another_model => AssociatedModel.create!(
-                  :title => "foo bar",
-                  :author => "baz"
-                )
-              )
+              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 = [
-              ModelWithAssociation.create!(
-                :another_model => AssociatedModel.create!(
-                  :title => "foo",
-                  :author => "baz"
-                )
-              )
+              ModelWithDoubleAssociation.create!(:title => 'stuvwx', :things => [
+                                                    DoublyAssociatedModel.create!(:title => 'abcdef')
+            ]),
+              ModelWithDoubleAssociation.create!(:title => 'qwerty', :thingamabobs => [
+                                                    DoublyAssociatedModel.create!(:title => "uiop")
+            ])
             ]
 
-            results = ModelWithAssociation.with_associated('foo bar')
-
-            results.to_sql.scan("INNER JOIN").length.should == 1
-            included.each { |object| results.should include(object) }
+            results = ModelWithDoubleAssociation.with_associated('foo bar')
+            results.map(&:title).should =~ included.map(&:title)
             excluded.each { |object| results.should_not include(object) }
           end
-
         end
       end
-    else
-      context "without Arel support" do
-        with_model :Model do
+
+      context "against multiple attributes on one association" do
+        with_model :AssociatedModel do
           table do |t|
             t.string 'title'
+            t.text 'author'
+          end
+        end
+
+        with_model :ModelWithAssociation do
+          table do |t|
+            t.belongs_to 'another_model'
           end
 
           model do
             include PgSearch
-            pg_search_scope :with_joins, :against => :title, :joins => :another_model
+            belongs_to :another_model, :class_name => 'AssociatedModel'
+
+            pg_search_scope :with_associated, :associated_against => {:another_model => [:title, :author]}
           end
         end
 
-        it "should raise an error" do
-          lambda {
-            Model.with_joins('foo')
-          }.should raise_error(ArgumentError, /joins/)
+        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) }
         end
+
       end
     end
   end