pg_search 0.5.7 → 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 953137586cb6148bd40249e053348adc9d1e4c4e
+  data.tar.gz: bd82cbede7a515ea77280bb2667617abcbb3ba6a
+SHA512:
+  metadata.gz: 4054d7eb7e376aee61ed698ccda4f8573752823e4b8de9e7bc192eefc84845aa2f3b0162f8de12704f5696367187bc1db2202f03c28aca1816128145e6aeebf9
+  data.tar.gz: 3a2031283e5b9a8e80e19607dc1b6bf044c4bd9340febdc0fd6606dffeff9729be7a36e214dddd877a915e6ae02e61b9099aab4b6d972d8a43afd314fc218dd0

data/.gitignore

@@ -6,3 +6,6 @@ doc
 tags
 *~
 Gemfile.lock
+.rbx
+coverage/
+tmp/

data/.travis.yml

@@ -2,14 +2,35 @@ language: ruby
 
 rvm:
   - 1.8.7
-  - 1.9.2
   - 1.9.3
+  - 2.0.0
   - jruby-18mode
   - jruby-19mode
   - rbx-18mode
   - rbx-19mode
   - ree
 
+env:
+  - ACTIVE_RECORD_VERSION="~> 4.0.0.beta1"
+  - ACTIVE_RECORD_VERSION="~> 3.2.0"
+  - ACTIVE_RECORD_VERSION="~> 3.1.0"
+
+matrix:
+  allow_failures:
+    - rvm: rbx-18mode
+    - rvm: rbx-19mode
+    - env: ACTIVE_RECORD_VERSION="~> 4.0.0.beta1"
+  exclude:
+    - rvm: 1.8.7
+      env: ACTIVE_RECORD_VERSION="~> 4.0.0.beta1"
+    - rvm: jruby-18mode
+      env: ACTIVE_RECORD_VERSION="~> 4.0.0.beta1"
+    - rvm: rbx-18mode
+      env: ACTIVE_RECORD_VERSION="~> 4.0.0.beta1"
+    - rvm: ree
+      env: ACTIVE_RECORD_VERSION="~> 4.0.0.beta1"
+
+
 before_script:
   - "psql -c 'create database pg_search_test;' -U postgres >/dev/null"
 

data/CHANGELOG.rdoc

@@ -1,5 +1,19 @@
 = PgSearch
 
+== 0.6.0
+
+* Drop support for Active Record 3.0.
+
+* Address warnings in Ruby 2.0.
+
+* Remove all usages of sanitize_sql_array for future Rails 4 compatibility.
+
+* Start using Arel internally to build SQL strings (not yet complete).
+
+* Disable eager loading, fixes issue #14.
+
+* Support named schemas in pg_search:multisearch:rebuild. (Victor Olteanu)
+
 == 0.5.7
 
 * Fix issue with eager loading now that the Scope class has been removed. (Piotr Murach)

data/Gemfile

@@ -6,15 +6,19 @@ gem "rake"
 gem "rdoc"
 gem "pry"
 
-platforms :ruby do
-  gem 'pg'
-end
-
-platforms :jruby do
-  gem "activerecord-jdbcpostgresql-adapter"
-end
+gem 'pg', :platform => :ruby
+gem "activerecord-jdbcpostgresql-adapter", :platform => :jruby
 
 gem "rspec"
 gem "with_model"
 
-gem "activerecord", "~> #{ENV["ACTIVE_RECORD_VERSION"]}.0" if ENV["ACTIVE_RECORD_VERSION"]
+gem "activerecord", ENV["ACTIVE_RECORD_VERSION"] if ENV["ACTIVE_RECORD_VERSION"]
+
+gem 'coveralls', :require => false, :platform => :mri_20
+
+group :development do
+  gem 'guard-rspec', :require => false
+  gem 'rb-inotify', :require => false
+  gem 'rb-fsevent', :require => false
+  gem 'rb-fchange', :require => false
+end

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-12 Case Commons, LLC
+Copyright (c) 2010-13 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/README.rdoc

@@ -2,31 +2,51 @@
 
 * http://github.com/casecommons/pg_search/
 
-{<img src="https://secure.travis-ci.org/Casecommons/pg_search.png?branch=master" alt="Build Status" />}[http://travis-ci.org/Casecommons/pg_search] {<img src="https://gemnasium.com/Casecommons/pg_search.png" alt="Dependency Status" />}[https://gemnasium.com/Casecommons/pg_search] {<img src="https://codeclimate.com/badge.png" />}[https://codeclimate.com/github/Casecommons/pg_search]
+{<img src="https://secure.travis-ci.org/Casecommons/pg_search.png?branch=master" alt="Build Status" />}[http://travis-ci.org/Casecommons/pg_search] 
+{<img src="https://gemnasium.com/Casecommons/pg_search.png" alt="Dependency Status" />}[https://gemnasium.com/Casecommons/pg_search] 
+{<img src="https://codeclimate.com/github/Casecommons/pg_search.png" />}[https://codeclimate.com/github/Casecommons/pg_search]
+{<img src="https://coveralls.io/repos/Casecommons/pg_search/badge.png?branch=master" alt="Coverage Status" />}[https://coveralls.io/r/Casecommons/pg_search]
+{<img src="https://badge.fury.io/rb/pg_search.png" alt="Gem Version" />}[http://badge.fury.io/rb/pg_search]
 
 == DESCRIPTION
 
 PgSearch builds named scopes that take advantage of PostgreSQL's full text search
 
-Read the blog post introducing PgSearch at http://bit.ly/pg_search
+Read the blog post introducing PgSearch at http://pivotallabs.com/pg-search/
+
+== REQUIREMENTS
+
+* Active Record 3.1 or later
+* PostgreSQL
+* {PostgreSQL contrib packages for certain features}[https://github.com/Casecommons/pg_search/wiki/Installing-Postgres-Contrib-Modules]
 
 == INSTALL
 
  gem install pg_search
 
-=== Rails 3
+=== Rails 3.1 or later
 
 In Gemfile
 
  gem 'pg_search'
 
+=== Rails 3.0
+
+The newest versions of PgSearch no longer support Rails 3.0. However, the 0.5 series still works. It's not actively maintained, but submissions are welcome for backports and bugfixes.
+
+ gem 'pg_search', "~> 0.5.7"
+
+The 0.5 branch lives at https://github.com/Casecommons/pg_search/tree/0.5-stable
+
 === Rails 2
 
 The newest versions of PgSearch no longer support Rails 2. However, the 0.2 series still works. It's not actively maintained, but submissions are welcome for backports and bugfixes.
 
+ gem 'pg_search', "~> 0.2.0"
+
 The 0.2 branch lives at https://github.com/Casecommons/pg_search/tree/0.2-stable
 
-=== Other ActiveRecord-based projects
+=== Other Active Record projects
 
 In addition to installing and requiring the gem, you may want to include the PgSearch rake tasks in your Rakefile. This isn't necessary for Rails projects, which gain the Rake tasks via a Railtie.
 
@@ -34,7 +54,7 @@ In addition to installing and requiring the gem, you may want to include the PgS
 
 == USAGE
 
-To add PgSearch to an ActiveRecord model, simply include the PgSearch module.
+To add PgSearch to an Active Record model, simply include the PgSearch module.
 
  class Shape < ActiveRecord::Base
    include PgSearch
@@ -71,6 +91,8 @@ To add a model to the global search index for your application, call multisearch
    multisearchable :against => :color
  end
 
+If this model already has existing records, you will need to reindex this model to get existing records into the pg_search_documents table. See the rebuild task below.
+
 Whenever a record is created, updated, or destroyed, an Active Record callback will fire, leading to the creation of a corresponding PgSearch::Document record in the pg_search_documents table. The :against option can be one or several methods which will be called on the record to generate its search text.
 
 You can also pass a Proc or method name to call to determine whether or not a particular record should be included.
@@ -164,16 +186,23 @@ To remove all of the documents for a given class, you can simply delete all of t
 
  PgSearch::Document.delete_all(:searchable_type => "Animal")
 
-Run this Rake task to regenerate all of the documents for a given class.
+To regenerate the documents for a given class, run:
+
+ PgSearch::Multisearch.rebuild(Product)
+
+This is also available as a Rake task, for convenience.
 
  $ rake pg_search:multisearch:rebuild[BlogPost]
 
-Currently this is only supported for :against methods that directly map to Active Record attributes. Until that is fixed, you could also manually rebuild all of the documents.
+A second optional argument can be passed to specify the PostgreSQL schema search path to use, for multi-tenant databases that have multiple pg_search_documents tables. The following will set the schema search path to "my_schema" before reindexing.
+
+ $ rake pg_search:multisearch:rebuild[BlogPost,my_schema]
+
+For models that are multisearchable :against methods that directly map to Active Record attributes, an efficient single SQL statement is run to update the pg_search_documents table all at once. However, if you call any dynamic methods in :against, the following strategy will be used:
 
  PgSearch::Document.delete_all(:searchable_type => "Ingredient")
  Ingredient.find_each { |record| record.update_pg_search_document }
 
-
 You can also provide a custom implementation for rebuilding the documents by adding a class method called `rebuild_pg_search_documents` to your model.
 
  class Movie < ActiveRecord::Base
@@ -569,12 +598,6 @@ To use this functionality you'll need to do a few things:
 
 Please note that the :against column is only used when the tsvector_column is not present for the search type.
 
-== REQUIREMENTS
-
-* ActiveRecord 3
-* PostgreSQL
-* {PostgreSQL contrib packages for certain features}[https://github.com/Casecommons/pg_search/wiki/Installing-Postgres-Contrib-Modules]
-
 == ATTRIBUTIONS
 
 PgSearch would not have been possible without inspiration from

data/lib/pg_search/configuration.rb

@@ -59,6 +59,14 @@ module PgSearch
       Array(options[:using])
     end
 
+    def feature_options
+      @feature_options ||= Hash.new.tap do |hash|
+        features.map do |feature_name, feature_options|
+          hash[feature_name] = feature_options
+        end
+      end
+    end
+
     def order_within_rank
       options[:order_within_rank]
     end
@@ -85,11 +93,7 @@ module PgSearch
 
     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
-
-      if options[:associated_against] && !defined?(ActiveRecord::Relation)
-        raise ArgumentError, ":associated_against requires Active Record 3 or later"
+        raise ArgumentError, "the search scope #{@name} must have :against or :associated_against in its options"
       end
 
       options.assert_valid_keys(VALID_KEYS)

data/lib/pg_search/features/feature.rb

@@ -1,6 +1,8 @@
 module PgSearch
   module Features
     class Feature
+      delegate :connection, :quoted_table_name, :to => :'@model'
+
       def initialize(query, options, columns, model, normalizer)
         @query = query
         @options = options || {}

data/lib/pg_search/features/trigram.rb

@@ -2,17 +2,27 @@ module PgSearch
   module Features
     class Trigram < Feature
       def conditions
-        [
-          "(#{normalize(document)}) % #{normalize(":query")}",
-          {:query => query}
-        ]
+        Arel::Nodes::Grouping.new(
+          Arel::Nodes::InfixOperation.new("%", normalized_document, normalize(query))
+        )
       end
 
       def rank
-        [
-          "similarity((#{normalize(document)}), #{normalize(":query")})",
-          {:query => query}
-        ]
+        Arel::Nodes::Grouping.new(
+          Arel::Nodes::NamedFunction.new(
+            "similarity",
+            [
+              normalized_document,
+              normalize(query)
+            ]
+          )
+        )
+      end
+
+      private
+
+      def normalized_document
+        Arel::Nodes::Grouping.new(normalize(Arel.sql(document)))
       end
     end
   end

data/lib/pg_search/features/tsearch.rb

@@ -3,8 +3,6 @@ require "active_support/core_ext/module/delegation"
 module PgSearch
   module Features
     class TSearch < Feature
-      delegate :connection, :quoted_table_name, :to => :'@model'
-
       def initialize(*args)
         super
 
@@ -16,19 +14,17 @@ module PgSearch
       end
 
       def conditions
-        ["(#{tsdocument}) @@ (#{tsquery})", interpolations]
+        Arel::Nodes::Grouping.new(
+          Arel::Nodes::InfixOperation.new("@@", arel_wrap(tsdocument), arel_wrap(tsquery))
+        )
       end
 
       def rank
-        tsearch_rank
+        arel_wrap(tsearch_rank)
       end
 
       private
 
-      def interpolations
-        {:query => query.to_s, :dictionary => dictionary.to_s}
-      end
-
       DISALLOWED_TSQUERY_CHARACTERS = /['?\\:]/
 
       def tsquery_for_term(term)
@@ -45,7 +41,10 @@ module PgSearch
           (connection.quote(':*') if options[:prefix])
         ].compact.join(" || ")
 
-        "to_tsquery(:dictionary, #{tsquery_sql})"
+        Arel::Nodes::NamedFunction.new(
+          "to_tsquery",
+          [dictionary, Arel.sql(tsquery_sql)]
+        ).to_sql
       end
 
       def tsquery
@@ -61,7 +60,11 @@ module PgSearch
           "#{quoted_table_name}.#{column_name}"
         else
           columns.map do |search_column|
-            tsvector = "to_tsvector(:dictionary, #{normalize(search_column.to_sql)})"
+            tsvector = Arel::Nodes::NamedFunction.new(
+              "to_tsvector",
+              [dictionary, Arel.sql(normalize(search_column.to_sql))]
+            ).to_sql
+
             if search_column.weight.nil?
               tsvector
             else
@@ -85,12 +88,16 @@ module PgSearch
       end
 
       def tsearch_rank
-        ["ts_rank((#{tsdocument}), (#{tsquery}), #{normalization})", interpolations]
+        "ts_rank((#{tsdocument}), (#{tsquery}), #{normalization})"
       end
 
       def dictionary
         options[:dictionary] || :simple
       end
+
+      def arel_wrap(sql_string)
+        Arel::Nodes::Grouping.new(Arel.sql(sql_string))
+      end
     end
   end
 end

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

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

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

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

data/lib/pg_search/normalizer.rb

@@ -5,18 +5,26 @@ module PgSearch
     end
 
     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}
-          MESSAGE
-        else
-          "#{PgSearch.unaccent_function}(#{sql_expression})"
-        end
-      else
-        sql_expression
+      return sql_expression unless 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}
+        MESSAGE
       end
+
+      sql_node = case sql_expression
+                 when Arel::Nodes::Node
+                   sql_expression
+                 else
+                   Arel.sql(sql_expression)
+                 end
+
+      Arel::Nodes::NamedFunction.new(
+        PgSearch.unaccent_function,
+        [sql_node]
+      ).to_sql
     end
 
     private

data/lib/pg_search/scope_options.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require "active_support/core_ext/module/delegation"
 
 module PgSearch
@@ -7,21 +9,35 @@ module PgSearch
     def initialize(config)
       @config = config
       @model = config.model
-      @feature_options = Hash[config.features]
+      @feature_options = config.feature_options
     end
 
     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)
+      scope.
+        select("#{quoted_table_name}.*, (#{rank}) AS pg_search_rank").
+        where(conditions).
+        order("pg_search_rank DESC, #{order_within_rank}").
+        joins(joins).
+        extend(DisableEagerLoading)
+    end
+
+    # workaround for https://github.com/Casecommons/pg_search/issues/14
+    module DisableEagerLoading
+      def eager_loading?
+        return false
+      end
     end
 
     private
 
-    delegate :connection, :quoted_table_name, :sanitize_sql_array, :to => :@model
+    delegate :connection, :quoted_table_name, :to => :@model
 
     def conditions
       config.features.map do |feature_name, feature_options|
-        "(#{sanitize_sql_array(feature_for(feature_name).conditions)})"
-      end.join(" OR ")
+        feature_for(feature_name).conditions
+      end.inject do |accumulator, expression|
+        Arel::Nodes::Or.new(accumulator, expression)
+      end
     end
 
     def order_within_rank
@@ -63,7 +79,7 @@ module PgSearch
 
     def rank
       (config.ranking_sql || ":tsearch").gsub(/:(\w*)/) do
-        sanitize_sql_array(feature_for($1).rank)
+        feature_for($1).rank.to_sql
       end
     end
   end

data/lib/pg_search/tasks.rb

@@ -4,13 +4,20 @@ require 'pg_search'
 namespace :pg_search do
   namespace :multisearch do
     desc "Rebuild PgSearch multisearch records for a given model"
-    task :rebuild, [:model] => :environment do |task, args|
+    task :rebuild, [:model,:schema] => :environment do |task, args|
       raise ArgumentError, <<-MESSAGE unless args.model
 You must pass a model as an argument.
 Example: rake pg_search:multisearch:rebuild[BlogPost]
       MESSAGE
       model_class = args.model.classify.constantize
-      PgSearch::Multisearch.rebuild(model_class)
+      connection = PgSearch::Document.connection
+      original_schema_search_path = connection.schema_search_path
+      begin
+        connection.schema_search_path = args.schema if args.schema
+        PgSearch::Multisearch.rebuild(model_class)
+      ensure
+        connection.schema_search_path = original_schema_search_path
+      end
     end
   end
 end

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.5.7"
+  VERSION = "0.6.0"
 end

data/pg_search.gemspec

@@ -6,17 +6,18 @@ Gem::Specification.new do |s|
   s.name        = "pg_search"
   s.version     = PgSearch::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Case Commons, LLC"]
-  s.email       = ["casecommons-dev@googlegroups.com"]
+  s.authors     = ["Grant Hutchins", "Case Commons, LLC"]
+  s.email       = ["gems@nertzy.com", "casecommons-dev@googlegroups.com"]
   s.homepage    = "https://github.com/Casecommons/pg_search"
-  s.summary     = %q{PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's full text search}
-  s.description = %q{PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's full text search}
+  s.summary     = %q{PgSearch builds Active Record named scopes that take advantage of PostgreSQL's full text search}
+  s.description = %q{PgSearch builds Active Record named scopes that take advantage of PostgreSQL's full text search}
+  s.licenses    = ["MIT"]
 
   s.files         = `git ls-files`.split("\n")
   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'
+  s.add_dependency 'activerecord', '>=3.1'
+  s.add_dependency 'activesupport', '>=3.1'
 end

data/spec/{associations_spec.rb → integration/associations_spec.rb}

@@ -343,6 +343,42 @@ describe PgSearch do
         results.should_not include(excluded)
       end
     end
+
+    context "when including the associated model" do
+      with_model :Parent do
+        table do |t|
+          t.text :name
+        end
+
+        model do
+          has_many :children
+          include PgSearch
+          pg_search_scope :search_name, :against => :name
+        end
+      end
+
+      with_model :Child do
+        table do |t|
+          t.belongs_to :parent
+        end
+
+        model do
+          belongs_to :parent
+        end
+      end
+
+      # https://github.com/Casecommons/pg_search/issues/14
+      it "supports queries with periods" do
+        included = Parent.create!(:name => 'bar.foo')
+        excluded = Parent.create!(:name => 'foo.bar')
+
+        results = Parent.search_name('bar.foo').includes(:children)
+        results.to_a
+
+        results.should include(included)
+        results.should_not include(excluded)
+      end
+    end
   end
 
   context "merging a pg_search_scope into another model's scope" do

data/spec/{pg_search_spec.rb → integration/pg_search_spec.rb}

@@ -1,7 +1,6 @@
 require "spec_helper"
 
-describe "an ActiveRecord model which includes PgSearch" do
-
+describe "an Active Record model which includes PgSearch" do
   with_model :ModelWithPgSearch do
     table do |t|
       t.string 'title'
@@ -163,9 +162,6 @@ describe "an ActiveRecord model which includes PgSearch" do
       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 = [ModelWithPgSearch.create!(:content => "foo"),
                     ModelWithPgSearch.create!(:content => "FOO")]
 
@@ -600,7 +596,11 @@ describe "an ActiveRecord model which includes PgSearch" do
         end
 
         it "should pass the custom configuration down to the specified feature" do
-          stub_feature = stub(:conditions => "1 = 1", :rank => "1.0")
+          stub_feature = stub(
+            :conditions => Arel::Nodes::Grouping.new(Arel.sql("1 = 1")),
+            :rank => Arel::Nodes::Grouping.new(Arel.sql("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)
 
@@ -734,22 +734,66 @@ describe "an ActiveRecord model which includes PgSearch" do
 
       %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}"
+          it "should return results with a rank" do
+            scope_name = :"search_content_ranked_by_#{feature}"
 
             ModelWithPgSearch.pg_search_scope scope_name,
               :against => :content,
               :ranked_by => ":#{feature}"
-          end
 
-          it "should return results with a rank" do
             ModelWithPgSearch.create!(:content => 'foo')
 
-            results = ModelWithPgSearch.send(@scope_name, 'foo')
+            results = ModelWithPgSearch.send(scope_name, 'foo')
             results.first.pg_search_rank.should be_a Float
           end
         end
       end
+
+      context "using the tsearch ranking algorithm" do
+        it "sorts results by the tsearch rank" do
+          ModelWithPgSearch.pg_search_scope :search_content_ranked_by_tsearch,
+            :using => :tsearch,
+            :against => :content,
+            :ranked_by => ":tsearch"
+
+
+          once = ModelWithPgSearch.create!(:content => 'foo bar')
+          twice = ModelWithPgSearch.create!(:content => 'foo foo')
+
+          results = ModelWithPgSearch.search_content_ranked_by_tsearch('foo')
+          results.index(twice).should be < results.index(once)
+        end
+      end
+
+      context "using the trigram ranking algorithm" do
+        it "sorts results by the trigram rank" do
+          ModelWithPgSearch.pg_search_scope :search_content_ranked_by_trigram,
+            :using => :trigram,
+            :against => :content,
+            :ranked_by => ":trigram"
+
+          close = ModelWithPgSearch.create!(:content => 'abcdef')
+          exact = ModelWithPgSearch.create!(:content => 'abc')
+
+          results = ModelWithPgSearch.search_content_ranked_by_trigram('abc')
+          results.index(exact).should be < results.index(close)
+        end
+      end
+
+      context "using the dmetaphone ranking algorithm" do
+        it "sorts results by the dmetaphone rank" do
+          ModelWithPgSearch.pg_search_scope :search_content_ranked_by_dmetaphone,
+            :using => :dmetaphone,
+            :against => :content,
+            :ranked_by => ":dmetaphone"
+
+          once = ModelWithPgSearch.create!(:content => 'Phoo Bar')
+          twice = ModelWithPgSearch.create!(:content => 'Phoo Fu')
+
+          results = ModelWithPgSearch.search_content_ranked_by_dmetaphone('foo')
+          results.index(twice).should be < results.index(once)
+        end
+      end
     end
 
     context "on an STI subclass" do

data/spec/lib/pg_search/features/trigram_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe PgSearch::Features::Trigram do
+  describe "#rank" do
+    with_model :Model do
+      table do |t|
+        t.string :name
+        t.text :content
+      end
+    end
+
+    it "returns an expression using the similarity() function" do
+      query = "query"
+      columns = [
+        PgSearch::Configuration::Column.new(:name, nil, Model),
+        PgSearch::Configuration::Column.new(:content, nil, Model),
+      ]
+      options = stub(:options)
+      config = stub(:config, :ignore => [])
+      normalizer = PgSearch::Normalizer.new(config)
+
+      feature = described_class.new(query, options, columns, Model, normalizer)
+      feature.rank.to_sql.should == %Q{(similarity((coalesce(#{Model.quoted_table_name}."name"::text, '') || ' ' || coalesce(#{Model.quoted_table_name}."content"::text, '')), 'query'))}
+    end
+  end
+end

data/spec/lib/pg_search/features/tsearch_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe PgSearch::Features::TSearch do
+  describe "#rank" do
+    with_model :Model do
+      table do |t|
+        t.string :name
+        t.text :content
+      end
+    end
+
+    it "returns an expression using the ts_rank() function" do
+      query = "query"
+      columns = [
+        PgSearch::Configuration::Column.new(:name, nil, Model),
+        PgSearch::Configuration::Column.new(:content, nil, Model),
+      ]
+      options = {}
+      config = stub(:config, :ignore => [])
+      normalizer = PgSearch::Normalizer.new(config)
+
+      feature = described_class.new(query, options, columns, Model, normalizer)
+      feature.rank.to_sql.should ==
+        %Q{(ts_rank((to_tsvector('simple', coalesce(#{Model.quoted_table_name}."name"::text, '')) || to_tsvector('simple', coalesce(#{Model.quoted_table_name}."content"::text, ''))), (to_tsquery('simple', ''' ' || 'query' || ' ''')), 0))}
+    end
+  end
+
+  describe "#conditions" do
+    with_model :Model do
+      table do |t|
+        t.string :name
+        t.text :content
+      end
+    end
+
+    it "returns an expression using the @@ infix operator" do
+      query = "query"
+      columns = [
+        PgSearch::Configuration::Column.new(:name, nil, Model),
+        PgSearch::Configuration::Column.new(:content, nil, Model),
+      ]
+      options = {}
+      config = stub(:config, :ignore => [])
+      normalizer = PgSearch::Normalizer.new(config)
+
+      feature = described_class.new(query, options, columns, Model, normalizer)
+      feature.conditions.to_sql.should ==
+        %Q{((to_tsvector('simple', coalesce(#{Model.quoted_table_name}."name"::text, '')) || to_tsvector('simple', coalesce(#{Model.quoted_table_name}."content"::text, ''))) @@ (to_tsquery('simple', ''' ' || 'query' || ' ''')))}
+    end
+  end
+end

data/spec/lib/pg_search/normalizer_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe PgSearch::Normalizer do
+  describe "#add_normalization" do
+    context "for PostgreSQL 9.0 and above" do
+      context "when config[:ignore] includes :accents" do
+        context "when passed an Arel node" do
+          it "wraps the expression in unaccent()" do
+            config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
+            node = Arel::Nodes::NamedFunction.new("foo", ["bar"])
+
+            normalizer = PgSearch::Normalizer.new(config)
+            normalizer.add_normalization(node).should == "unaccent(foo('bar'))"
+          end
+
+          context "when a custom unaccent function is specified" do
+            it "wraps the expression in that function" do
+              PgSearch.stub(:unaccent_function).and_return("my_unaccent")
+              node = Arel::Nodes::NamedFunction.new("foo", ["bar"])
+
+              config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
+
+              normalizer = PgSearch::Normalizer.new(config)
+              normalizer.add_normalization(node).should == "my_unaccent(foo('bar'))"
+            end
+          end
+        end
+
+        context "when passed a String" do
+          it "wraps the expression in unaccent()" do
+            config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
+
+            normalizer = PgSearch::Normalizer.new(config)
+            normalizer.add_normalization("foo").should == "unaccent(foo)"
+          end
+
+          context "when a custom unaccent function is specified" do
+            it "wraps the expression in that function" do
+              PgSearch.stub(:unaccent_function).and_return("my_unaccent")
+
+              config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
+
+              normalizer = PgSearch::Normalizer.new(config)
+              normalizer.add_normalization("foo").should == "my_unaccent(foo)"
+            end
+          end
+        end
+      end
+
+      context "when config[:ignore] does not include :accents" do
+        it "passes the expression through" do
+          config = stub("config", :ignore => [], :postgresql_version => 90000)
+
+          normalizer = PgSearch::Normalizer.new(config)
+          normalizer.add_normalization("foo").should == "foo"
+        end
+      end
+    end
+
+    context "for PostgreSQL versions before 9.0" do
+      context "when config[:ignore] includes :accents" do
+        it "raises a NotSupportedForPostgresqlVersion exception" do
+          config = stub("config", :ignore => [:accents], :postgresql_version => 89999)
+
+          normalizer = PgSearch::Normalizer.new(config)
+          expect {
+            normalizer.add_normalization("foo")
+          }.to raise_exception(PgSearch::NotSupportedForPostgresqlVersion)
+        end
+      end
+
+      context "when config[:ignore] does not include :accents" do
+        it "passes the expression through" do
+          config = stub("config", :ignore => [], :postgresql_version => 90000)
+
+          normalizer = PgSearch::Normalizer.new(config)
+          normalizer.add_normalization("foo").should == "foo"
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,12 @@
 require "bundler/setup"
 require "pg_search"
 
+begin
+  require 'coveralls'
+  Coveralls.wear!
+rescue LoadError
+end
+
 begin
   require "pg"
   error_class = PGError
@@ -73,13 +79,19 @@ unless postgresql_version < 90000
 end
 install_extension_if_missing("fuzzystrmatch", "SELECT dmetaphone('foo')", "f")
 
+def load_sql(filename)
+  connection = ActiveRecord::Base.connection
+  file_contents = File.read(File.join(File.dirname(__FILE__), '..', 'sql', filename))
+  connection.execute(file_contents)
+end
+
 if postgresql_version < 80400
   unless connection.select_value("SELECT 1 FROM pg_catalog.pg_aggregate WHERE aggfnoid = 'array_agg'::REGPROC") == "1"
-    connection.execute(File.read(File.join(File.dirname(__FILE__), '..', 'sql', 'array_agg.sql')))
+    load_sql("array_agg.sql")
   end
-  connection.execute(File.read(File.join(File.dirname(__FILE__), '..', 'sql', 'unnest.sql')))
+  load_sql("unnest.sql")
 end
-connection.execute(File.read(File.join(File.dirname(__FILE__), '..', 'sql', 'dmetaphone.sql')))
+load_sql("dmetaphone.sql")
 
 require "with_model"
 
@@ -94,45 +106,3 @@ DOCUMENTS_SCHEMA = lambda do |t|
   t.text :content
   t.timestamps
 end
-
-require 'irb'
-
-class IRB::Irb
-  alias initialize_orig initialize
-  def initialize(workspace = nil, *args)
-    default = IRB.conf[:DEFAULT_OBJECT]
-    workspace ||= IRB::WorkSpace.new default if default
-    initialize_orig(workspace, *args)
-  end
-end
-
-# Drop into an IRB session for whatever object you pass in:
-#
-#     class Dude
-#       def abides
-#         true
-#       end
-#     end
-#
-#     console_for(Dude.new)
-#
-# Then type "quit" or "exit" to get out. In a step definition, it should look like:
-#
-#     When /^I console/ do
-#       console_for(self)
-#     end
-#
-# Also, I definitely stole this hack from some mailing list post somewhere. I wish I
-# could remember who did it, but I can't. Sorry!
-def console_for(target)
-  puts "== ENTERING CONSOLE MODE. ==\nType 'exit' to move on.\nContext: #{target.inspect}"
-
-  begin
-    oldargs = ARGV.dup
-    ARGV.clear
-    IRB.conf[:DEFAULT_OBJECT] = target
-    IRB.start
-  ensure
-    ARGV.replace(oldargs)
-  end
-end

data/sql/dmetaphone.sql

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

metadata

@@ -1,51 +1,48 @@
 --- !ruby/object:Gem::Specification
 name: pg_search
 version: !ruby/object:Gem::Version
-  version: 0.5.7
-  prerelease: 
+  version: 0.6.0
 platform: ruby
 authors:
+- Grant Hutchins
 - Case Commons, LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-07 00:00:00.000000000 Z
+date: 2013-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3'
-description: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's
+        version: '3.1'
+description: PgSearch builds Active Record named scopes that take advantage of PostgreSQL's
   full text search
 email:
+- gems@nertzy.com
 - casecommons-dev@googlegroups.com
 executables: []
 extensions: []
@@ -54,10 +51,10 @@ files:
 - .autotest
 - .gitignore
 - .rspec
-- .rvmrc
 - .travis.yml
 - CHANGELOG.rdoc
 - Gemfile
+- Guardfile
 - LICENSE
 - README.rdoc
 - Rakefile
@@ -87,13 +84,15 @@ files:
 - lib/pg_search/tasks.rb
 - lib/pg_search/version.rb
 - pg_search.gemspec
-- spec/associations_spec.rb
-- spec/pg_search/document_spec.rb
-- spec/pg_search/multisearch/rebuilder_spec.rb
-- spec/pg_search/multisearch_spec.rb
-- spec/pg_search/multisearchable_spec.rb
-- spec/pg_search/normalizer_spec.rb
-- spec/pg_search_spec.rb
+- spec/integration/associations_spec.rb
+- spec/integration/pg_search_spec.rb
+- spec/lib/pg_search/document_spec.rb
+- spec/lib/pg_search/features/trigram_spec.rb
+- spec/lib/pg_search/features/tsearch_spec.rb
+- spec/lib/pg_search/multisearch/rebuilder_spec.rb
+- spec/lib/pg_search/multisearch_spec.rb
+- spec/lib/pg_search/multisearchable_spec.rb
+- spec/lib/pg_search/normalizer_spec.rb
 - spec/spec_helper.rb
 - sql/array_agg.sql
 - sql/dmetaphone.sql
@@ -102,42 +101,38 @@ files:
 - sql/uninstall_unnest.sql
 - sql/unnest.sql
 homepage: https://github.com/Casecommons/pg_search
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1475822108196160881
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1475822108196160881
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
-summary: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's
+specification_version: 4
+summary: PgSearch builds Active Record named scopes that take advantage of PostgreSQL's
   full text search
 test_files:
-- spec/associations_spec.rb
-- spec/pg_search/document_spec.rb
-- spec/pg_search/multisearch/rebuilder_spec.rb
-- spec/pg_search/multisearch_spec.rb
-- spec/pg_search/multisearchable_spec.rb
-- spec/pg_search/normalizer_spec.rb
-- spec/pg_search_spec.rb
+- spec/integration/associations_spec.rb
+- spec/integration/pg_search_spec.rb
+- spec/lib/pg_search/document_spec.rb
+- spec/lib/pg_search/features/trigram_spec.rb
+- spec/lib/pg_search/features/tsearch_spec.rb
+- spec/lib/pg_search/multisearch/rebuilder_spec.rb
+- spec/lib/pg_search/multisearch_spec.rb
+- spec/lib/pg_search/multisearchable_spec.rb
+- spec/lib/pg_search/normalizer_spec.rb
 - spec/spec_helper.rb

data/.rvmrc

@@ -1,52 +0,0 @@
-#!/usr/bin/env bash
-
-# This is an RVM Project .rvmrc file, used to automatically load the ruby
-# development environment upon cd'ing into the directory
-
-# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
-# Only full ruby name is supported here, for short names use:
-#     echo "rvm use 1.9.3" > .rvmrc
-environment_id="ruby-1.9.3-p194@pg_search"
-
-# Uncomment the following lines if you want to verify rvm version per project
-# rvmrc_rvm_version="1.12.4 ()" # 1.10.1 seams as a safe start
-# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
-#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
-#   return 1
-# }
-
-# First we attempt to load the desired environment directly from the environment
-# file. This is very fast and efficient compared to running through the entire
-# CLI and selector. If you want feedback on which environment was used then
-# insert the word 'use' after --create as this triggers verbose mode.
-if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
-  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
-then
-  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
-  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
-    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
-  if [[ $- == *i* ]] # check for interactive shells
-  then echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
-  else echo "Using: $GEM_HOME" # don't use colors in non-interactive shells
-  fi
-else
-  # If the environment file has not yet been created, use the RVM CLI to select.
-  rvm --create use  "$environment_id" || {
-    echo "Failed to create RVM environment '${environment_id}'."
-    return 1
-  }
-fi
-
-# If you use bundler, this might be useful to you:
-if [[ -s Gemfile ]] && {
-  ! builtin command -v bundle >/dev/null ||
-  builtin command -v bundle | grep $rvm_path/bin/bundle >/dev/null
-}
-then
-  printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
-  gem install bundler
-fi
-if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
-then
-  bundle install | grep -vE '^Using|Your bundle is complete'
-fi

data/spec/pg_search/normalizer_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-
-describe PgSearch::Normalizer do
-  describe "#add_normalization" do
-    context "for PostgreSQL 9.0 and above" do
-      context "when config[:ignore] includes :accents" do
-        it "wraps the expression in unaccent()" do
-          config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
-
-          normalizer = PgSearch::Normalizer.new(config)
-          normalizer.add_normalization("foo").should == "unaccent(foo)"
-        end
-
-        context "when a custom unaccent function is specified" do
-          it "wraps the expression in that function" do
-            PgSearch.stub(:unaccent_function).and_return("my_unaccent")
-
-            config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
-
-            normalizer = PgSearch::Normalizer.new(config)
-            normalizer.add_normalization("foo").should == "my_unaccent(foo)"
-          end
-        end
-      end
-
-      context "when config[:ignore] does not include :accents" do
-        it "passes the expression through" do
-          config = stub("config", :ignore => [], :postgresql_version => 90000)
-
-          normalizer = PgSearch::Normalizer.new(config)
-          normalizer.add_normalization("foo").should == "foo"
-        end
-      end
-    end
-
-    context "for PostgreSQL versions before 9.0" do
-      context "when config[:ignore] includes :accents" do
-        it "raises a NotSupportedForPostgresqlVersion exception" do
-          config = stub("config", :ignore => [:accents], :postgresql_version => 89999)
-
-          normalizer = PgSearch::Normalizer.new(config)
-          expect {
-            normalizer.add_normalization("foo")
-          }.to raise_exception(PgSearch::NotSupportedForPostgresqlVersion)
-        end
-      end
-
-      context "when config[:ignore] does not include :accents" do
-        it "passes the expression through" do
-          config = stub("config", :ignore => [], :postgresql_version => 90000)
-
-          normalizer = PgSearch::Normalizer.new(config)
-          normalizer.add_normalization("foo").should == "foo"
-        end
-      end
-    end
-  end
-end