pg_search 0.0.2

data/script/setup-contrib

@@ -0,0 +1,12 @@
+#!/bin/sh
+POSTGRESQL_VERSION=`pg_config --version | awk '{print $2}'`
+
+cd /tmp
+test -e /tmp/postgresql-$POSTGRESQL_VERSION.tar.bz2 || wget http://ftp9.us.postgresql.org/pub/mirrors/postgresql/source/v$POSTGRESQL_VERSION/postgresql-$POSTGRESQL_VERSION.tar.bz2
+test -d /tmp/postgresql-$POSTGRESQL_VERSION || tar zxvf postgresql-$POSTGRESQL_VERSION.tar.bz2
+cd postgresql-$POSTGRESQL_VERSION && eval ./configure `pg_config --configure` && make
+cd contrib/unaccent && make && make install
+cd ..
+cd contrib/pg_trgm && make && make install
+cd ..
+cd contrib/fuzzystrmatch && make && make install

data/spec/associations_spec.rb

@@ -0,0 +1,225 @@
+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 "through a belongs_to association" do
+          with_model :associated_model do
+            table do |t|
+              t.string 'title'
+            end
+          end
+
+          with_model :model_with_belongs_to do
+            table do |t|
+              t.string 'title'
+              t.belongs_to 'another_model'
+            end
+
+            model do
+              include PgSearch
+              belongs_to :another_model, :class_name => 'AssociatedModel'
+
+              pg_search_scope :with_associated, :against => :title, :associated_against => {:another_model => :title}
+            end
+          end
+
+          it "returns rows that match the query in either its own columns or the columns of the associated model" do
+            associated = associated_model.create!(:title => 'abcdef')
+            included = [
+              model_with_belongs_to.create!(:title => 'ghijkl', :another_model => associated),
+              model_with_belongs_to.create!(:title => 'abcdef')
+            ]
+            excluded = model_with_belongs_to.create!(:title => 'mnopqr',
+                                                     :another_model => associated_model.create!(:title => 'stuvwx'))
+
+            results = model_with_belongs_to.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 :associated_model_with_has_many do
+            table do |t|
+              t.string 'title'
+              t.belongs_to 'model_with_has_many'
+            end
+          end
+
+          with_model :model_with_has_many do
+            table do |t|
+              t.string 'title'
+            end
+
+            model do
+              include PgSearch
+              has_many :other_models, :class_name => 'AssociatedModelWithHasMany', :foreign_key => 'model_with_has_many_id'
+
+              pg_search_scope :with_associated, :against => [:title], :associated_against => {:other_models => :title}
+            end
+          end
+
+          it "returns rows that match the query in either its own columns or the columns of the associated model" do
+            included = [
+              model_with_has_many.create!(:title => 'abcdef', :other_models => [
+                                          associated_model_with_has_many.create!(:title => 'foo'),
+                                          associated_model_with_has_many.create!(:title => 'bar')
+            ]),
+              model_with_has_many.create!(:title => 'ghijkl', :other_models => [
+                                          associated_model_with_has_many.create!(:title => 'foo bar'),
+                                          associated_model_with_has_many.create!(:title => 'mnopqr')
+            ]),
+              model_with_has_many.create!(:title => 'foo bar')
+            ]
+            excluded = model_with_has_many.create!(:title => 'stuvwx', :other_models => [
+                                                   associated_model_with_has_many.create!(:title => 'abcdef')
+            ])
+
+            results = model_with_has_many.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 :first_associated_model do
+              table do |t|
+                t.string 'title'
+                t.belongs_to 'model_with_many_associations'
+              end
+              model {}
+            end
+
+            with_model :second_associated_model do
+              table do |t|
+                t.string 'title'
+              end
+              model {}
+            end
+
+            with_model :model_with_many_associations 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 = second_associated_model.create!(:title => "foo bar")
+              unmatching_second = second_associated_model.create!(:title => "uiop")
+
+              included = [
+                ModelWithManyAssociations.create!(:title => 'abcdef', :models_of_first_type => [
+                                                  first_associated_model.create!(:title => 'foo'),
+                                                  first_associated_model.create!(:title => 'bar')
+              ]),
+                ModelWithManyAssociations.create!(:title => 'ghijkl', :models_of_first_type => [
+                                                  first_associated_model.create!(:title => 'foo bar'),
+                                                  first_associated_model.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 => [
+                                                  first_associated_model.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 :doubly_associated_model 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
+          end
+        end
+      end
+    else
+      context "without Arel support" do
+        with_model :model do
+          table do |t|
+            t.string 'title'
+          end
+
+          model do
+            include PgSearch
+            pg_search_scope :with_joins, :against => :title, :joins => :another_model
+          end
+        end
+
+        it "should raise an error" do
+          lambda {
+            Model.with_joins('foo')
+          }.should raise_error(ArgumentError, /joins/)
+        end
+      end
+    end
+  end
+end

data/spec/pg_search_spec.rb

@@ -0,0 +1,596 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "an ActiveRecord model which includes PgSearch" do
+
+  with_model :model_with_pg_search do
+    table do |t|
+      t.string 'title'
+      t.text 'content'
+      t.integer 'importance'
+    end
+
+    model do
+      include PgSearch
+    end
+  end
+
+  describe ".pg_search_scope" do
+    it "builds a scope" do
+      model_with_pg_search.class_eval do
+        pg_search_scope "matching_query", :against => []
+      end
+
+      lambda {
+        model_with_pg_search.scoped({}).matching_query("foo").scoped({})
+      }.should_not raise_error
+    end
+
+    context "when passed a lambda" do
+      it "builds a dynamic scope" do
+        model_with_pg_search.class_eval do
+          pg_search_scope :search_title_or_content, lambda { |query, pick_content|
+            {
+              :query => query.gsub("-remove-", ""),
+              :against => pick_content ? :content : :title
+            }
+          }
+        end
+
+        included = model_with_pg_search.create!(:title => 'foo', :content => 'bar')
+        excluded = model_with_pg_search.create!(:title => 'bar', :content => 'foo')
+
+        model_with_pg_search.search_title_or_content('fo-remove-o', false).should == [included]
+        model_with_pg_search.search_title_or_content('b-remove-ar', true).should == [included]
+      end
+    end
+
+    context "when an unknown option is passed in" do
+      it "raises an exception when invoked" do
+        lambda {
+          model_with_pg_search.class_eval do
+            pg_search_scope :with_unknown_option, :against => :content, :foo => :bar
+          end
+          model_with_pg_search.with_unknown_option("foo")
+        }.should raise_error(ArgumentError, /foo/)
+      end
+
+      context "dynamically" do
+        it "raises an exception when invoked" do
+          lambda {
+            model_with_pg_search.class_eval do
+              pg_search_scope :with_unknown_option, lambda { |*| {:against => :content, :foo => :bar} }
+            end
+            model_with_pg_search.with_unknown_option("foo")
+          }.should raise_error(ArgumentError, /foo/)
+        end
+      end
+    end
+
+    context "when an unknown :using is passed" do
+      it "raises an exception when invoked" do
+        lambda {
+          model_with_pg_search.class_eval do
+            pg_search_scope :with_unknown_using, :against => :content, :using => :foo
+          end
+          model_with_pg_search.with_unknown_using("foo")
+        }.should raise_error(ArgumentError, /foo/)
+      end
+
+      context "dynamically" do
+        it "raises an exception when invoked" do
+          lambda {
+            model_with_pg_search.class_eval do
+              pg_search_scope :with_unknown_using, lambda { |*| {:against => :content, :using => :foo} }
+            end
+            model_with_pg_search.with_unknown_using("foo")
+          }.should raise_error(ArgumentError, /foo/)
+        end
+      end
+    end
+
+    context "when an unknown :normalizing is passed" do
+      it "raises an exception when invoked" do
+        lambda {
+          model_with_pg_search.class_eval do
+            pg_search_scope :with_unknown_normalizing, :against => :content, :normalizing => :foo
+          end
+          model_with_pg_search.with_unknown_normalizing("foo")
+        }.should raise_error(ArgumentError, /normalizing.*foo/)
+      end
+
+      context "dynamically" do
+        it "raises an exception when invoked" do
+          lambda {
+            model_with_pg_search.class_eval do
+              pg_search_scope :with_unknown_normalizing, lambda { |*| {:against => :content, :normalizing => :foo} }
+            end
+            model_with_pg_search.with_unknown_normalizing("foo")
+          }.should raise_error(ArgumentError, /normalizing.*foo/)
+        end
+      end
+
+      context "when :against is not passed in" do
+        it "raises an exception when invoked" do
+          lambda {
+            model_with_pg_search.class_eval do
+              pg_search_scope :with_unknown_normalizing, {}
+            end
+            model_with_pg_search.with_unknown_normalizing("foo")
+          }.should raise_error(ArgumentError, /against/)
+        end
+        context "dynamically" do
+          it "raises an exception when invoked" do
+            lambda {
+              model_with_pg_search.class_eval do
+                pg_search_scope :with_unknown_normalizing, lambda { |*| {} }
+              end
+              model_with_pg_search.with_unknown_normalizing("foo")
+            }.should raise_error(ArgumentError, /against/)
+          end
+        end
+      end
+    end
+  end
+
+  describe "a search scope" do
+    context "against a single column" do
+      before do
+        model_with_pg_search.class_eval do
+          pg_search_scope :search_content, :against => :content
+        end
+      end
+
+      it "returns an empty array when a blank query is passed in" do
+        model_with_pg_search.create!(:content => 'foo')
+
+        results = model_with_pg_search.search_content('')
+        results.should == []
+      end
+
+      it "returns rows where the column contains the term in the query" do
+        included = model_with_pg_search.create!(:content => 'foo')
+        excluded = model_with_pg_search.create!(:content => 'bar')
+
+        results = model_with_pg_search.search_content('foo')
+        results.should include(included)
+        results.should_not include(excluded)
+      end
+
+      it "returns rows where the column contains all the terms in the query in any order" do
+        included = [model_with_pg_search.create!(:content => 'foo bar'),
+                    model_with_pg_search.create!(:content => 'bar foo')]
+        excluded = model_with_pg_search.create!(:content => 'foo')
+
+        results = model_with_pg_search.search_content('foo bar')
+        results.should =~ included
+        results.should_not include(excluded)
+      end
+
+      it "returns rows that match the query but not its case" do
+        # \303\241 is a with acute accent
+        # \303\251 is e with acute accent
+
+        included = [model_with_pg_search.create!(:content => "foo"),
+                    model_with_pg_search.create!(:content => "FOO")]
+
+        results = model_with_pg_search.search_content("Foo")
+        results.should =~ included
+      end
+
+      it "returns rows that match the query only if their diacritics match" do
+        # \303\241 is a with acute accent
+        # \303\251 is e with acute accent
+
+        included = model_with_pg_search.create!(:content => "abcd\303\251f")
+        excluded = model_with_pg_search.create!(:content => "\303\241bcdef")
+
+        results = model_with_pg_search.search_content("abcd\303\251f")
+        results.should == [included]
+        results.should_not include(excluded)
+      end
+
+      it "returns rows that match the query but not rows that are prefixed by the query" do
+        included = model_with_pg_search.create!(:content => 'pre')
+        excluded = model_with_pg_search.create!(:content => 'prefix')
+
+        results = model_with_pg_search.search_content("pre")
+        results.should == [included]
+        results.should_not include(excluded)
+      end
+
+      it "returns rows that match the query when stemmed by the default dictionary (english)" do
+        included = [model_with_pg_search.create!(:content => "jump"),
+                    model_with_pg_search.create!(:content => "jumped"),
+                    model_with_pg_search.create!(:content => "jumping")]
+
+        results = model_with_pg_search.search_content("jump")
+        results.should =~ included
+      end
+
+      it "returns rows that match sorted by rank" do
+        loser = model_with_pg_search.create!(:content => 'foo')
+        winner = model_with_pg_search.create!(:content => 'foo foo')
+
+        results = model_with_pg_search.search_content("foo")
+        results[0].rank.should > results[1].rank
+        results.should == [winner, loser]
+      end
+
+      it "returns results that match sorted by primary key for records that rank the same" do
+        sorted_results = [model_with_pg_search.create!(:content => 'foo'),
+                          model_with_pg_search.create!(:content => 'foo')].sort_by(&:id)
+
+        results = model_with_pg_search.search_content("foo")
+        results.should == sorted_results
+      end
+
+      it "returns results that match a query with multiple space-separated search terms" do
+        included = [
+          model_with_pg_search.create!(:content => 'foo bar'),
+          model_with_pg_search.create!(:content => 'bar foo'),
+          model_with_pg_search.create!(:content => 'bar foo baz'),
+        ]
+        excluded = [
+          model_with_pg_search.create!(:content => 'foo'),
+          model_with_pg_search.create!(:content => 'foo baz')
+        ]
+
+        results = model_with_pg_search.search_content('foo bar')
+        results.should =~ included
+        results.should_not include(excluded)
+      end
+
+      it "returns rows that match a query with characters that are invalid in a tsquery expression" do
+        included = model_with_pg_search.create!(:content => "(Foo.) Bar?, \\")
+
+        results = model_with_pg_search.search_content("foo bar .,?() \\")
+        results.should == [included]
+      end
+      it "accepts non-string queries and calls #to_s on them" do
+        foo = model_with_pg_search.create!(:content => "foo")
+        not_a_string = stub(:to_s => "foo")
+        model_with_pg_search.search_content(not_a_string).should == [foo]
+      end
+    end
+
+    context "against multiple columns" do
+      before do
+        model_with_pg_search.class_eval do
+          pg_search_scope :search_title_and_content, :against => [:title, :content]
+        end
+      end
+
+      it "returns rows whose columns contain all of the terms in the query across columns" do
+        included = [
+          model_with_pg_search.create!(:title => 'foo', :content => 'bar'),
+          model_with_pg_search.create!(:title => 'bar', :content => 'foo')
+        ]
+        excluded = [
+          model_with_pg_search.create!(:title => 'foo', :content => 'foo'),
+          model_with_pg_search.create!(:title => 'bar', :content => 'bar')
+        ]
+
+        results = model_with_pg_search.search_title_and_content('foo bar')
+
+        results.should =~ included
+        excluded.each do |result|
+          results.should_not include(result)
+        end
+      end
+
+      it "returns rows where at one column contains all of the terms in the query and another does not" do
+        in_title = model_with_pg_search.create!(:title => 'foo', :content => 'bar')
+        in_content = model_with_pg_search.create!(:title => 'bar', :content => 'foo')
+
+        results  = model_with_pg_search.search_title_and_content('foo')
+        results.should =~ [in_title, in_content]
+      end
+
+      # Searching with a NULL column will prevent any matches unless we coalesce it.
+      it "returns rows where at one column contains all of the terms in the query and another is NULL" do
+        included = model_with_pg_search.create!(:title => 'foo', :content => nil)
+        results  = model_with_pg_search.search_title_and_content('foo')
+        results.should == [included]
+      end
+    end
+
+    context "using trigram" do
+      before do
+        model_with_pg_search.class_eval do
+          pg_search_scope :with_trigrams, :against => [:title, :content], :using => :trigram
+        end
+      end
+
+      it "returns rows where one searchable column and the query share enough trigrams" do
+        included = model_with_pg_search.create!(:title => 'abcdefghijkl', :content => nil)
+        results = model_with_pg_search.with_trigrams('cdefhijkl')
+        results.should == [included]
+      end
+
+      it "returns rows where multiple searchable columns and the query share enough trigrams" do
+        included = model_with_pg_search.create!(:title => 'abcdef', :content => 'ghijkl')
+        results = model_with_pg_search.with_trigrams('cdefhijkl')
+        results.should == [included]
+      end
+    end
+
+    context "using tsearch" do
+      context "with :prefix => true" do
+        before do
+          model_with_pg_search.class_eval do
+            pg_search_scope :search_title_with_prefixes,
+                            :against => :title,
+                            :using => {
+                              :tsearch => {:prefix => true}
+                            }
+          end
+        end
+
+        it "returns rows that match the query and that are prefixed by the query" do
+          included = model_with_pg_search.create!(:title => 'prefix')
+          excluded = model_with_pg_search.create!(:title => 'postfix')
+
+          results = model_with_pg_search.search_title_with_prefixes("pre")
+          results.should == [included]
+          results.should_not include(excluded)
+        end
+
+        it "returns rows that match the query when the query has a hyphen" do
+          included = [
+            model_with_pg_search.create!(:title => 'foo bar'),
+            model_with_pg_search.create!(:title => 'foo-bar')
+          ]
+          excluded = model_with_pg_search.create!(:title => 'baz quux')
+
+          results = model_with_pg_search.search_title_with_prefixes("foo-bar")
+          results.should =~ included
+          results.should_not include(excluded)
+        end
+      end
+
+      context "with the simple dictionary" do
+        before do
+          model_with_pg_search.class_eval do
+            pg_search_scope :search_title, :against => :title
+
+            pg_search_scope :search_title_with_simple,
+                            :against => :title,
+                            :using => {
+                              :tsearch => {:dictionary => :simple}
+                            }
+          end
+        end
+
+        it "returns rows that match the query exactly but not that match the query when stemmed by the default dictionary" do
+          included = model_with_pg_search.create!(:title => "jumped")
+          excluded = [model_with_pg_search.create!(:title => "jump"),
+                      model_with_pg_search.create!(:title => "jumping")]
+
+          default_results = model_with_pg_search.search_title("jumped")
+          default_results.should =~ [included] + excluded
+
+          simple_results = model_with_pg_search.search_title_with_simple("jumped")
+          simple_results.should == [included]
+          excluded.each do |result|
+            simple_results.should_not include(result)
+          end
+        end
+      end
+
+      context "against columns ranked with arrays" do
+        before do
+          model_with_pg_search.class_eval do
+             pg_search_scope :search_weighted_by_array_of_arrays, :against => [[:content, 'B'], [:title, 'A']]
+           end
+        end
+
+        it "returns results sorted by weighted rank" do
+          loser = model_with_pg_search.create!(:title => 'bar', :content => 'foo')
+          winner = model_with_pg_search.create!(:title => 'foo', :content => 'bar')
+
+          results = model_with_pg_search.search_weighted_by_array_of_arrays('foo')
+          results[0].rank.should > results[1].rank
+          results.should == [winner, loser]
+        end
+      end
+
+      context "against columns ranked with a hash" do
+        before do
+          model_with_pg_search.class_eval do
+            pg_search_scope :search_weighted_by_hash, :against => {:content => 'B', :title => 'A'}
+          end
+        end
+
+        it "returns results sorted by weighted rank" do
+          loser = model_with_pg_search.create!(:title => 'bar', :content => 'foo')
+          winner = model_with_pg_search.create!(:title => 'foo', :content => 'bar')
+
+          results = model_with_pg_search.search_weighted_by_hash('foo')
+          results[0].rank.should > results[1].rank
+          results.should == [winner, loser]
+        end
+      end
+
+      context "against columns of which only some are ranked" do
+        before do
+          model_with_pg_search.class_eval do
+            pg_search_scope :search_weighted, :against => [:content, [:title, 'A']]
+          end
+        end
+
+        it "returns results sorted by weighted rank using an implied low rank for unranked columns" do
+          loser = model_with_pg_search.create!(:title => 'bar', :content => 'foo')
+          winner = model_with_pg_search.create!(:title => 'foo', :content => 'bar')
+
+          results = model_with_pg_search.search_weighted('foo')
+          results[0].rank.should > results[1].rank
+          results.should == [winner, loser]
+        end
+      end
+    end
+
+    context "using dmetaphone" do
+      before do
+        model_with_pg_search.class_eval do
+          pg_search_scope :with_dmetaphones, :against => [:title, :content], :using => :dmetaphone
+        end
+      end
+
+      it "returns rows where one searchable column and the query share enough dmetaphones" do
+        included = model_with_pg_search.create!(:title => 'Geoff', :content => nil)
+        excluded = model_with_pg_search.create!(:title => 'Bob', :content => nil)
+        results = model_with_pg_search.with_dmetaphones('Jeff')
+        results.should == [included]
+      end
+
+      it "returns rows where multiple searchable columns and the query share enough dmetaphones" do
+        included = model_with_pg_search.create!(:title => 'Geoff', :content => 'George')
+        excluded = model_with_pg_search.create!(:title => 'Bob', :content => 'Jones')
+        results = model_with_pg_search.with_dmetaphones('Jeff Jorge')
+        results.should == [included]
+      end
+
+      it "returns rows that match dmetaphones that are English stopwords" do
+        included = model_with_pg_search.create!(:title => 'White', :content => nil)
+        excluded = model_with_pg_search.create!(:title => 'Black', :content => nil)
+        results = model_with_pg_search.with_dmetaphones('Wight')
+        results.should == [included]
+      end
+    end
+
+    context "using multiple features" do
+      before do
+        model_with_pg_search.class_eval do
+          pg_search_scope :with_tsearch, :against => :title, :using => :tsearch
+
+          pg_search_scope :with_trigram, :against => :title, :using => :trigram
+
+          pg_search_scope :with_tsearch_and_trigram_using_array,
+                          :against => :title,
+                          :using => [:tsearch, :trigram]
+
+        end
+      end
+
+      it "returns rows that match using any of the features" do
+        record = model_with_pg_search.create!(:title => "tiling is grouty")
+
+        # matches trigram only
+        trigram_query = "ling is grouty"
+        model_with_pg_search.with_trigram(trigram_query).should include(record)
+        model_with_pg_search.with_tsearch(trigram_query).should_not include(record)
+        model_with_pg_search.with_tsearch_and_trigram_using_array(trigram_query).should == [record]
+
+        # matches tsearch only
+        tsearch_query = "tile"
+        model_with_pg_search.with_tsearch(tsearch_query).should include(record)
+        model_with_pg_search.with_trigram(tsearch_query).should_not include(record)
+        model_with_pg_search.with_tsearch_and_trigram_using_array(tsearch_query).should == [record]
+      end
+
+      context "with feature-specific configuration" do
+        before do
+          @tsearch_config = tsearch_config = {:dictionary => 'english'}
+          @trigram_config = trigram_config = {:foo => 'bar'}
+
+          model_with_pg_search.class_eval do
+            pg_search_scope :with_tsearch_and_trigram_using_hash,
+                            :against => :title,
+                            :using => {
+                              :tsearch => tsearch_config,
+                              :trigram => trigram_config
+                            }
+          end
+        end
+
+        it "should pass the custom configuration down to the specified feature" do
+          stub_feature = stub(:conditions => "1 = 1", :rank => "1.0")
+          PgSearch::Features::TSearch.should_receive(:new).with(anything, @tsearch_config, anything, anything, anything).at_least(:once).and_return(stub_feature)
+          PgSearch::Features::Trigram.should_receive(:new).with(anything, @trigram_config, anything, anything, anything).at_least(:once).and_return(stub_feature)
+
+          model_with_pg_search.with_tsearch_and_trigram_using_hash("foo")
+        end
+      end
+    end
+
+    context "normalizing diacritics" do
+      before do
+        model_with_pg_search.class_eval do
+          pg_search_scope :search_title_without_diacritics, :against => :title, :normalizing => :diacritics
+        end
+      end
+
+      it "returns rows that match the query but not its diacritics" do
+        # \303\241 is a with acute accent
+        # \303\251 is e with acute accent
+
+        included = model_with_pg_search.create!(:title => "\303\241bcdef")
+
+        results = model_with_pg_search.search_title_without_diacritics("abcd\303\251f")
+        results.should == [included]
+      end
+    end
+
+    context "when passed a :ranked_by expression" do
+      before do
+        model_with_pg_search.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
+      end
+
+      it "should return records with a rank attribute equal to the :ranked_by expression" do
+        model_with_pg_search.create!(:content => 'foo', :importance => 10)
+        results = model_with_pg_search.search_content_with_importance_as_rank("foo")
+        results.first.rank.should == 10
+      end
+
+      it "should substitute :tsearch with the tsearch rank expression in the :ranked_by expression" do
+        model_with_pg_search.create!(:content => 'foo', :importance => 10)
+
+        tsearch_rank = model_with_pg_search.search_content_with_default_rank("foo").first.rank
+        multiplied_rank = model_with_pg_search.search_content_with_importance_as_rank_multiplier("foo").first.rank
+
+        multiplied_rank.should be_within(0.001).of(tsearch_rank * 10)
+      end
+
+      it "should return results in descending order of the value of the rank expression" do
+        records = [
+          model_with_pg_search.create!(:content => 'foo', :importance => 1),
+          model_with_pg_search.create!(:content => 'foo', :importance => 3),
+          model_with_pg_search.create!(:content => 'foo', :importance => 2)
+        ]
+
+        results = model_with_pg_search.search_content_with_importance_as_rank("foo")
+        results.should == records.sort_by(&:importance).reverse
+      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}"
+            model_with_pg_search.class_eval do
+              pg_search_scope scope_name,
+                              :against => :content,
+                              :ranked_by => ":#{feature}"
+            end
+          end
+
+          it "should return results with a rank" do
+            model_with_pg_search.create!(:content => 'foo')
+
+            results = model_with_pg_search.send(@scope_name, 'foo')
+            results.first.rank.should_not be_nil
+          end
+        end
+      end
+    end
+  end
+end