pg_search 0.7.9 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e2af7110ee0301accace6b1a5143605fdddaf59b
-  data.tar.gz: ae0a9e2e5da80e29afd0449057685d64f20cb08c
+  metadata.gz: f2c1314fe8a375215c28cab705710050ceffcef3
+  data.tar.gz: 4055f33418dfca0cbb94259b0a3fb0befc53342c
 SHA512:
-  metadata.gz: 6d5b4e6084872eac490fa2e7e923a3c9e53bd5acf77596a6a2a42547ecf90cee8f75a9c1d9a5819bcf4bc3546fc2dcc8f1ba46848dd5561c62172235d8ffff6b
-  data.tar.gz: baf8e2bcf8fd110c8db6f1bd68acdb62af2510ec5eab40bfd607494f83c202282238db599b95c30e44b64d7a13338b894b2dd074d7104779512fd0efac7b5ad0
+  metadata.gz: 7ce28204b8e03ecaf75d5d65d810f84d20a4104fd82a9eafed9e4abcc25849466861b86075fab54212c6974228f1a8b873ac2aa805e74d46c0f15d25d9040588
+  data.tar.gz: de01412dbad07868ed1f71ad29bb992fcfa7b085e2cf9301e5c47c2afacbf16de7c6f602692c60e474a77bc15dd26b4405c9a2f59773262f75141cc749b338f0

data/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_BIN: bin

data/.gitignore

@@ -1,12 +1,10 @@
-pkg/*
-doc
 *.gem
-.bundle
-.idea
+.rbx
 .yardoc
-tags
-*~
+/bin/
+/coverage/
+/pkg/*
+/tmp/
 Gemfile.lock
-.rbx
-coverage/
-tmp/
+doc
+tags

data/.rubocop.yml

@@ -3,6 +3,6 @@ inherit_from: .rubocop_todo.yml
 Style/StringLiterals:
   Enabled: false
 
-# # Offense count: 2
-# Lint/HandleExceptions:
-  # Enabled: false
+AllCops:
+  Exclude:
+    - bin/**/*

data/.rubocop_todo.yml

@@ -58,7 +58,7 @@ Style/BlockEndNewline:
 
 # Offense count: 14
 # Cop supports --auto-correct.
-Style/Blocks:
+Style/BlockDelimiters:
   Enabled: false
 
 # Offense count: 1
@@ -194,10 +194,6 @@ Style/RaiseArgs:
 Style/RedundantReturn:
   Enabled: false
 
-# Offense count: 2
-Style/RegexpLiteral:
-  MaxSlashes: 0
-
 # Offense count: 10
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle, SupportedStyles.

data/CHANGELOG.md

@@ -1,8 +1,14 @@
 # pg_search changelog
 
+## 1.0.0
+
+*   Support more `ActiveRecord::Relation` methods, such as `#pluck` and `#select` by moving search-related operations to subquery.
+*   Generate index by default in migration for `pg_search_documents` table.
+*   Start officially using [Semantic Versioning 2.0.0](http://semver.org/spec/v2.0.0.html).
+
 ## 0.7.9
 
-*   Improve support for single table inheritance (STI) models (Ewan McDougall)
+*   Improve support for single table inheritance (STI) models. (Ewan McDougall)
 
 ## 0.7.8
 

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-13 Case Commons, LLC
+Copyright (c) 2010–2015 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.md

@@ -5,6 +5,7 @@
 [![Gem Version](https://img.shields.io/gem/v/pg_search.svg?style=flat)](https://rubygems.org/gems/pg_search)
 [![Dependency Status](https://img.shields.io/gemnasium/Casecommons/pg_search.svg?style=flat)](https://gemnasium.com/Casecommons/pg_search)
 [![Inline docs](http://inch-ci.org/github/Casecommons/pg_search.svg?branch=master&style=flat)](http://inch-ci.org/github/Casecommons/pg_search)
+[![Join the chat at https://gitter.im/Casecommons/pg_search](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/Casecommons/pg_search?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## DESCRIPTION
 
@@ -24,13 +25,17 @@ Read the blog post introducing PgSearch at http://pivotallabs.com/pg-search/
 
 ## INSTALL
 
-    gem install pg_search
+```bash
+$ gem install pg_search
+```
 
 ### Rails 3.1, 3.2, 4.0 or later, Ruby 1.9.2, 2.0, or later
 
 In Gemfile
 
-    gem 'pg_search'
+```ruby
+gem 'pg_search'
+```
 
 ### Rails 3.0
 
@@ -38,7 +43,9 @@ 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"
+```ruby
+gem 'pg_search', "~> 0.5.7"
+```
 
 The 0.5 branch lives at
 https://github.com/Casecommons/pg_search/tree/0.5-stable
@@ -49,7 +56,9 @@ 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"
+```ruby
+gem 'pg_search', "~> 0.2.0"
+```
 
 The 0.2 branch lives at
 https://github.com/Casecommons/pg_search/tree/0.2-stable
@@ -60,7 +69,9 @@ In addition to installing and requiring the gem, you may want to include the
 PgSearch rake tasks in your Rakefile. This isn't necessary for Rails projects,
 which gain the Rake tasks via a Railtie.
 
-    load "pg_search/tasks.rb"
+```ruby
+load "pg_search/tasks.rb"
+```
 
 ### Ruby 1.8.7 or earlier
 
@@ -68,7 +79,9 @@ The newest versions of PgSearch no longer support Ruby 1.8.7. However, the 0.6
 series still works. It's not actively maintained, but submissions are welcome
 for backports and bugfixes.
 
-    gem 'pg_search', "~> 0.6.4"
+```ruby
+gem 'pg_search', "~> 0.6.4"
+```
 
 The 0.6 branch lives at
 https://github.com/Casecommons/pg_search/tree/0.6-stable
@@ -105,8 +118,10 @@ search.
 Before using multi-search, you must generate and run a migration to create the
 pg_search_documents database table.
 
-    $ rails g pg_search:migration:multisearch
-    $ rake db:migrate
+```bash
+$ rails g pg_search:migration:multisearch
+$ rake db:migrate
+```
 
 #### multisearchable
 

data/lib/pg_search/compatibility.rb

@@ -1,11 +1,5 @@
 module PgSearch
   module Compatibility
-    module ActiveRecord3
-      def pg_search_rank
-        read_attribute(:pg_search_rank).to_f
-      end
-    end
-
     def self.build_quoted(string)
       if defined?(Arel::Nodes::Quoted)
         Arel::Nodes.build_quoted(string)

data/lib/pg_search/configuration.rb

@@ -61,7 +61,7 @@ module PgSearch
     end
 
     def feature_options
-      @feature_options ||= Hash.new.tap do |hash|
+      @feature_options ||= {}.tap do |hash|
         features.map do |feature_name, feature_options|
           hash[feature_name] = feature_options
         end

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

@@ -3,7 +3,7 @@ class CreatePgSearchDocuments < ActiveRecord::Migration
     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.belongs_to :searchable, :polymorphic => true, :index => true
         t.timestamps null: false
       end
     end

data/lib/pg_search/scope_options.rb

@@ -4,7 +4,7 @@ require "active_support/core_ext/module/delegation"
 
 module PgSearch
   class ScopeOptions
-    attr_reader :config, :feature_options
+    attr_reader :config, :feature_options, :model
 
     def initialize(config)
       @config = config
@@ -13,12 +13,11 @@ module PgSearch
     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).
-        extend(DisableEagerLoading)
+      scope
+        .joins(rank_join)
+        .order("pg_search.rank DESC, #{order_within_rank}")
+        .extend(DisableEagerLoading)
+        .extend(WithPgSearchRank)
     end
 
     # workaround for https://github.com/Casecommons/pg_search/issues/14
@@ -28,9 +27,28 @@ module PgSearch
       end
     end
 
+    module WithPgSearchRank
+      def with_pg_search_rank
+        scope = self
+        scope = scope.select("*") unless scope.select_values.any?
+        scope.select("pg_search.rank AS pg_search_rank")
+      end
+    end
+
     private
 
-    delegate :connection, :quoted_table_name, :to => :@model
+    delegate :connection, :quoted_table_name, :to => :model
+
+    def subquery
+      model
+        .except(:select)
+        .select("#{primary_key} AS pg_search_id")
+        .select("#{rank} AS rank")
+        .joins(subquery_join)
+        .where(conditions)
+        .limit(nil)
+        .offset(nil)
+    end
 
     def conditions
       config.features.reject do |feature_name, feature_options|
@@ -47,10 +65,10 @@ module PgSearch
     end
 
     def primary_key
-      "#{quoted_table_name}.#{connection.quote_column_name(@model.primary_key)}"
+      "#{quoted_table_name}.#{connection.quote_column_name(model.primary_key)}"
     end
 
-    def joins
+    def subquery_join
       if config.associations.any?
         config.associations.map do |association|
           association.join(primary_key)
@@ -86,5 +104,9 @@ module PgSearch
         feature_for($1).rank.to_sql
       end
     end
+
+    def rank_join
+      "INNER JOIN (#{subquery.to_sql}) pg_search ON #{primary_key} = pg_search.pg_search_id"
+    end
   end
 end

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.7.9".freeze
+  VERSION = "1.0.0".freeze
 end

data/lib/pg_search.rb

@@ -15,7 +15,6 @@ require "pg_search/version"
 
 module PgSearch
   extend ActiveSupport::Concern
-  include Compatibility::ActiveRecord3 if ActiveRecord::VERSION::MAJOR == 3
 
   mattr_accessor :multisearch_options
   self.multisearch_options = {}
@@ -75,7 +74,33 @@ module PgSearch
     end
   end
 
+  def method_missing(symbol, *args)
+    case symbol
+    when :pg_search_rank
+      raise PgSearchRankNotSelected.new unless respond_to?(:pg_search_rank)
+      read_attribute(:pg_search_rank).to_f
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(symbol, *args)
+    case symbol
+    when :pg_search_rank
+      attributes.key?(:pg_search_rank)
+    else
+      super
+    end
+  end
+
+
   class NotSupportedForPostgresqlVersion < StandardError; end
+
+  class PgSearchRankNotSelected < StandardError
+    def message
+      "You must chain .with_pg_search_rank after the pg_search_scope to access the pg_search_rank attribute on returned records"
+    end
+  end
 end
 
 require "pg_search/document"

data/pg_search.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'with_model', '>= 1.2'
-  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'rubocop', '>= 0.30.0'
 
   s.required_ruby_version = ">= 1.9.2"
 end

data/spec/integration/associations_spec.rb

@@ -117,10 +117,11 @@ describe PgSearch do
         expect(results).not_to include(excluded)
       end
 
-      it "uses an unscoped relation of the assocated model" do
+      it "uses an unscoped relation of the associated model" do
         excluded = ModelWithHasMany.create!(:title => 'abcdef', :other_models => [
           AssociatedModelWithHasMany.create!(:title => 'abcdef')
         ])
+
         included = [
           ModelWithHasMany.create!(:title => 'abcdef', :other_models => [
             AssociatedModelWithHasMany.create!(:title => 'foo'),
@@ -128,7 +129,11 @@ describe PgSearch do
           ])
         ]
 
-        results = ModelWithHasMany.limit(1).order("id ASC").with_associated('foo bar')
+        results = ModelWithHasMany
+                  .limit(1)
+                  .order("#{ModelWithHasMany.quoted_table_name}.id ASC")
+                  .with_associated('foo bar')
+
         expect(results.map(&:title)).to match_array(included.map(&:title))
         expect(results).not_to include(excluded)
       end
@@ -300,7 +305,7 @@ describe PgSearch do
 
         results = ModelWithAssociation.with_associated('foo bar')
 
-        expect(results.to_sql.scan("INNER JOIN").length).to eq(1)
+        expect(results.to_sql.scan("INNER JOIN #{AssociatedModel.quoted_table_name}").length).to eq(1)
         included.each { |object| expect(results).to include(object) }
         excluded.each { |object| expect(results).not_to include(object) }
       end

data/spec/integration/pg_search_spec.rb

@@ -135,6 +135,57 @@ describe "an Active Record model which includes PgSearch" do
         ModelWithPgSearch.pg_search_scope :search_content, :against => :content
       end
 
+      context "when chained after a select() scope" do
+        it "honors the select" do
+          included = ModelWithPgSearch.create!(content: 'foo', title: 'bar')
+          excluded = ModelWithPgSearch.create!(content: 'bar', title: 'foo')
+
+          results = ModelWithPgSearch.select('id, title').search_content('foo')
+
+          expect(results).to include(included)
+          expect(results).to_not include(excluded)
+
+          expect(results.first.attributes.key?('content')).to eq false
+
+          expect(results.select { |record| record.title == "bar" }).to eq [included]
+          expect(results.select { |record| record.title != "bar" }).to be_empty
+        end
+      end
+
+      context "when chained before a select() scope" do
+        it "honors the select" do
+          included = ModelWithPgSearch.create!(content: 'foo', title: 'bar')
+          excluded = ModelWithPgSearch.create!(content: 'bar', title: 'foo')
+
+          results = ModelWithPgSearch.search_content('foo').select('id, title')
+
+          expect(results).to include(included)
+          expect(results).to_not include(excluded)
+
+          expect(results.first.attributes.key?('content')).to eq false
+
+          expect(results.select { |record| record.title == "bar" }).to eq [included]
+          expect(results.select { |record| record.title != "bar" }).to be_empty
+        end
+      end
+
+      context "when surrouned by select() scopes" do
+        it "honors the select" do
+          included = ModelWithPgSearch.create!(content: 'foo', title: 'bar')
+          excluded = ModelWithPgSearch.create!(content: 'bar', title: 'foo')
+
+          results = ModelWithPgSearch.select('id').search_content('foo').select('title')
+
+          expect(results).to include(included)
+          expect(results).to_not include(excluded)
+
+          expect(results.first.attributes.key?('content')).to eq false
+
+          expect(results.select { |record| record.title == "bar" }).to eq [included]
+          expect(results.select { |record| record.title != "bar" }).to be_empty
+        end
+      end
+
       it "returns an empty array when a blank query is passed in" do
         ModelWithPgSearch.create!(:content => 'foo')
 
@@ -155,10 +206,50 @@ describe "an Active Record model which includes PgSearch" do
         ModelWithPgSearch.create!(:content => 'foo')
         ModelWithPgSearch.create!(:content => 'bar')
 
+        results = ModelWithPgSearch.search_content('foo')
+        expect(results.count).to eq 1
+      end
+
+      it "returns the correct count(:all)" do
+        ModelWithPgSearch.create!(:content => 'foo')
+        ModelWithPgSearch.create!(:content => 'bar')
+
         results = ModelWithPgSearch.search_content('foo')
         expect(results.count(:all)).to eq 1
       end
 
+      it "supports #select" do
+        record = ModelWithPgSearch.create!(:content => 'foo')
+        other_record = ModelWithPgSearch.create!(:content => 'bar')
+
+        records_with_only_id = ModelWithPgSearch.search_content('foo').select('id')
+        expect(records_with_only_id.length).to eq 1
+
+        returned_record = records_with_only_id.first
+
+        expect(returned_record.attributes).to eq({"id" => record.id})
+      end
+
+      unless ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 2
+        it "supports #pluck" do
+          record = ModelWithPgSearch.create!(:content => 'foo')
+          other_record = ModelWithPgSearch.create!(:content => 'bar')
+
+          ids = ModelWithPgSearch.search_content('foo').pluck('id')
+          expect(ids).to eq [record.id]
+        end
+      end
+
+      it "supports adding where clauses using the pg_search.rank" do
+        once = ModelWithPgSearch.create!(:content => 'foo bar')
+        twice = ModelWithPgSearch.create!(:content => 'foo foo')
+
+        records = ModelWithPgSearch.search_content('foo')
+                  .where("pg_search.rank > 0.07")
+
+        expect(records).to eq [twice]
+      end
+
       it "returns rows where the column contains all the terms in the query in any order" do
         included = [ModelWithPgSearch.create!(:content => 'foo bar'),
                     ModelWithPgSearch.create!(:content => 'bar foo')]
@@ -211,7 +302,7 @@ describe "an Active Record model which includes PgSearch" do
         loser = ModelWithPgSearch.create!(:content => 'foo')
         winner = ModelWithPgSearch.create!(:content => 'foo foo')
 
-        results = ModelWithPgSearch.search_content("foo")
+        results = ModelWithPgSearch.search_content("foo").with_pg_search_rank
         expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
         expect(results).to eq([winner, loser])
       end
@@ -426,7 +517,7 @@ describe "an Active Record model which includes PgSearch" do
         it "adds a #pg_search_rank method to each returned model record" do
           ModelWithPgSearch.pg_search_scope :search_content, :against => :content
 
-          result = ModelWithPgSearch.search_content("Strip Down").first
+          result = ModelWithPgSearch.search_content("Strip Down").with_pg_search_rank.first
 
           expect(result.pg_search_rank).to be_a(Float)
         end
@@ -441,7 +532,7 @@ describe "an Active Record model which includes PgSearch" do
           end
 
           it "ranks the results for documents with less text higher" do
-            results = ModelWithPgSearch.search_content_with_normalization("down")
+            results = ModelWithPgSearch.search_content_with_normalization("down").with_pg_search_rank
 
             expect(results.map(&:content)).to eq(["Down", "Strip Down", "Down and Out", "Won't Let You Down"])
             expect(results.first.pg_search_rank).to be > results.last.pg_search_rank
@@ -456,7 +547,7 @@ describe "an Active Record model which includes PgSearch" do
           end
 
           it "ranks the results equally" do
-            results = ModelWithPgSearch.search_content_without_normalization("down")
+            results = ModelWithPgSearch.search_content_without_normalization("down").with_pg_search_rank
 
             expect(results.map(&:content)).to eq(["Strip Down", "Down", "Down and Out", "Won't Let You Down"])
             expect(results.first.pg_search_rank).to eq(results.last.pg_search_rank)
@@ -474,7 +565,7 @@ describe "an Active Record model which includes PgSearch" do
           loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
           winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
-          results = ModelWithPgSearch.search_weighted_by_array_of_arrays('foo')
+          results = ModelWithPgSearch.search_weighted_by_array_of_arrays('foo').with_pg_search_rank
           expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
           expect(results).to eq([winner, loser])
         end
@@ -490,7 +581,7 @@ describe "an Active Record model which includes PgSearch" do
           loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
           winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
-          results = ModelWithPgSearch.search_weighted_by_hash('foo')
+          results = ModelWithPgSearch.search_weighted_by_hash('foo').with_pg_search_rank
           expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
           expect(results).to eq([winner, loser])
         end
@@ -506,7 +597,7 @@ describe "an Active Record model which includes PgSearch" do
           loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
           winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
 
-          results = ModelWithPgSearch.search_weighted('foo')
+          results = ModelWithPgSearch.search_weighted('foo').with_pg_search_rank
           expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
           expect(results).to eq([winner, loser])
         end
@@ -910,15 +1001,24 @@ describe "an Active Record model which includes PgSearch" do
 
       it "should return records with a rank attribute equal to the :ranked_by expression" do
         ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
-        results = ModelWithPgSearch.search_content_with_importance_as_rank("foo")
+        results = ModelWithPgSearch.search_content_with_importance_as_rank("foo").with_pg_search_rank
         expect(results.first.pg_search_rank).to eq(10)
       end
 
       it "should substitute :tsearch with the tsearch rank expression in the :ranked_by expression" do
         ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
 
-        tsearch_rank = ModelWithPgSearch.search_content_with_default_rank("foo").first.pg_search_rank
-        multiplied_rank = ModelWithPgSearch.search_content_with_importance_as_rank_multiplier("foo").first.pg_search_rank
+        tsearch_result =
+          ModelWithPgSearch.search_content_with_default_rank("foo").with_pg_search_rank.first
+
+        tsearch_rank = tsearch_result.pg_search_rank
+
+        multiplied_result =
+          ModelWithPgSearch.search_content_with_importance_as_rank_multiplier("foo")
+          .with_pg_search_rank
+          .first
+
+        multiplied_rank = multiplied_result.pg_search_rank
 
         expect(multiplied_rank).to be_within(0.001).of(tsearch_rank * 10)
       end
@@ -936,17 +1036,39 @@ describe "an Active Record model which includes PgSearch" do
 
       %w[tsearch trigram dmetaphone].each do |feature|
         context "using the #{feature} ranking algorithm" do
-          it "should return results with a rank" do
-            scope_name = :"search_content_ranked_by_#{feature}"
-
+          let(:scope_name) { :"search_content_ranked_by_#{feature}" }
+          before do
             ModelWithPgSearch.pg_search_scope scope_name,
               :against => :content,
               :ranked_by => ":#{feature}"
 
             ModelWithPgSearch.create!(:content => 'foo')
+          end
 
-            results = ModelWithPgSearch.send(scope_name, 'foo')
-            expect(results.first.pg_search_rank).to be_a Float
+          context "when .with_pg_search_rank is chained after" do
+            specify "its results respond to #pg_search_rank" do
+              result = ModelWithPgSearch.send(scope_name, 'foo').with_pg_search_rank.first
+              expect(result).to respond_to(:pg_search_rank)
+            end
+
+            it "returns the rank when #pg_search_rank is called on a result" do
+              results = ModelWithPgSearch.send(scope_name, 'foo').with_pg_search_rank
+              expect(results.first.pg_search_rank).to be_a Float
+            end
+          end
+
+          context "when .with_pg_search_rank is not chained after" do
+            specify "its results do not respond to #pg_search_rank" do
+              result = ModelWithPgSearch.send(scope_name, 'foo').first
+              expect(result).not_to respond_to(:pg_search_rank)
+            end
+
+            it "raises PgSearch::PgSearchRankNotSelected when #pg_search_rank is called on a result" do
+              result = ModelWithPgSearch.send(scope_name, 'foo').first
+              expect {
+                result.pg_search_rank
+              }.to raise_exception(PgSearch::PgSearchRankNotSelected)
+            end
           end
         end
       end
@@ -1075,222 +1197,4 @@ describe "an Active Record model which includes PgSearch" do
       expect(ModelWithPgSearch.pg_search_multisearchable_options).to eq(options)
     end
   end
-
-  describe ".multisearch" do
-    with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
-
-    describe "delegation to PgSearch::Document.search" do
-      subject { PgSearch.multisearch(query) }
-
-      let(:query) { double(:query) }
-      let(:relation) { double(:relation) }
-      before do
-        expect(PgSearch::Document).to receive(:search).with(query).and_return(relation)
-      end
-
-      it { is_expected.to eq(relation) }
-    end
-
-    context "with PgSearch.multisearch_options set to a Hash" do
-      before { allow(PgSearch).to receive(:multisearch_options).and_return({:using => :dmetaphone}) }
-      subject { PgSearch.multisearch(query).map(&:searchable) }
-
-      with_model :MultisearchableModel do
-        table do |t|
-          t.string :title
-        end
-        model do
-          include PgSearch
-          multisearchable :against => :title
-        end
-      end
-
-      let!(:soundalike_record) { MultisearchableModel.create!(:title => 'foning') }
-      let(:query) { "Phoning" }
-      it { is_expected.to include(soundalike_record) }
-    end
-
-    context "with PgSearch.multisearch_options set to a Proc" do
-      subject { PgSearch.multisearch(query, soundalike).map(&:searchable) }
-
-      before do
-        allow(PgSearch).to receive(:multisearch_options) do
-          lambda do |query, soundalike|
-            if soundalike
-              {:using => :dmetaphone, :query => query}
-            else
-              {:query => query}
-            end
-          end
-        end
-      end
-
-      with_model :MultisearchableModel do
-        table do |t|
-          t.string :title
-        end
-        model do
-          include PgSearch
-          multisearchable :against => :title
-        end
-      end
-
-      let!(:soundalike_record) { MultisearchableModel.create!(:title => 'foning') }
-      let(:query) { "Phoning" }
-
-      context "with soundalike true" do
-        let(:soundalike) { true }
-        it { is_expected.to include(soundalike_record) }
-      end
-
-      context "with soundalike false" do
-        let(:soundalike) { false }
-        it { is_expected.not_to include(soundalike_record) }
-      end
-    end
-
-    context "on an STI subclass" do
-      with_model :SuperclassModel do
-        table do |t|
-          t.text 'content'
-          t.string 'type'
-        end
-      end
-
-      before do
-        searchable_subclass_model = Class.new(SuperclassModel) do
-          include PgSearch
-          multisearchable :against => :content
-        end
-        stub_const("SearchableSubclassModel", searchable_subclass_model)
-        stub_const("AnotherSearchableSubclassModel", searchable_subclass_model)
-        stub_const("NonSearchableSubclassModel", Class.new(SuperclassModel))
-      end
-
-      it "returns only results for that subclass" do
-        included = [
-          SearchableSubclassModel.create!(:content => "foo bar")
-        ]
-        excluded = [
-          SearchableSubclassModel.create!(:content => "baz"),
-          SuperclassModel.create!(:content => "foo bar"),
-          SuperclassModel.create!(:content => "baz"),
-          NonSearchableSubclassModel.create!(:content => "foo bar"),
-          NonSearchableSubclassModel.create!(:content => "baz")
-        ]
-
-        expect(SuperclassModel.count).to be 6
-        expect(SearchableSubclassModel.count).to be 2
-
-        expect(PgSearch::Document.count).to be 2
-
-        results = PgSearch.multisearch("foo bar")
-
-        expect(results.length).to be 1
-        expect(results.first.searchable.class).to be SearchableSubclassModel
-        expect(results.first.searchable).to eq included.first
-      end
-
-      it "updates an existing STI model does not create a new pg_search document" do
-        model = SearchableSubclassModel.create!(:content => "foo bar")
-        expect(SearchableSubclassModel.count).to eq(1)
-        # We fetch the model from the database again otherwise
-        # the pg_search_document from the cache is used.
-        model = SearchableSubclassModel.find(model.id)
-        model.content = "foo"
-        model.save!
-        results = PgSearch.multisearch("foo")
-        expect(results.size).to eq(SearchableSubclassModel.count)
-      end
-
-      it "reindexing works" do
-        NonSearchableSubclassModel.create!(:content => "foo bar")
-        NonSearchableSubclassModel.create!(:content => "baz")
-        expected = SearchableSubclassModel.create!(:content => "baz")
-        SuperclassModel.create!(:content => "foo bar")
-        SuperclassModel.create!(:content => "baz")
-        SuperclassModel.create!(:content => "baz2")
-
-        expect(SuperclassModel.count).to be 6
-        expect(NonSearchableSubclassModel.count).to be 2
-        expect(SearchableSubclassModel.count).to be 1
-
-        expect(PgSearch::Document.count).to be 1
-
-        PgSearch::Multisearch.rebuild(SearchableSubclassModel)
-
-        expect(PgSearch::Document.count).to be 1
-        expect(PgSearch::Document.first.searchable.class).to be SearchableSubclassModel
-        expect(PgSearch::Document.first.searchable).to eq expected
-      end
-
-      it "reindexing searchable STI doesn't clobber other related STI models" do
-        searchable_s = SearchableSubclassModel.create!(:content => "baz")
-        searchable_a = AnotherSearchableSubclassModel.create!(:content => "baz")
-
-        expect(PgSearch::Document.count).to be 2
-        PgSearch::Multisearch.rebuild(SearchableSubclassModel)
-        expect(PgSearch::Document.count).to be 2
-
-        classes = PgSearch::Document.all.collect {|d| d.searchable.class }
-        expect(classes).to include SearchableSubclassModel
-        expect(classes).to include AnotherSearchableSubclassModel
-      end
-    end
-  end
-
-  describe ".disable_multisearch" do
-    it "should temporarily disable multisearch" do
-      @multisearch_enabled_before = PgSearch.multisearch_enabled?
-      PgSearch.disable_multisearch do
-        @multisearch_enabled_inside = PgSearch.multisearch_enabled?
-      end
-      @multisearch_enabled_after = PgSearch.multisearch_enabled?
-
-      expect(@multisearch_enabled_before).to be(true)
-      expect(@multisearch_enabled_inside).to be(false)
-      expect(@multisearch_enabled_after).to be(true)
-    end
-
-    it "should reenable multisearch after an error" do
-      @multisearch_enabled_before = PgSearch.multisearch_enabled?
-      begin
-        PgSearch.disable_multisearch do
-          @multisearch_enabled_inside = PgSearch.multisearch_enabled?
-          raise
-        end
-      rescue # rubocop:disable Lint/HandleExceptions
-      end
-
-      @multisearch_enabled_after = PgSearch.multisearch_enabled?
-
-      expect(@multisearch_enabled_before).to be(true)
-      expect(@multisearch_enabled_inside).to be(false)
-      expect(@multisearch_enabled_after).to be(true)
-    end
-
-    it "should not disable multisearch on other threads" do
-      values = Queue.new
-      sync = Queue.new
-      Thread.new do
-        values.push PgSearch.multisearch_enabled?
-        sync.pop # wait
-        values.push PgSearch.multisearch_enabled?
-        sync.pop # wait
-        values.push PgSearch.multisearch_enabled?
-      end
-
-      @multisearch_enabled_before = values.pop
-      PgSearch.disable_multisearch do
-        sync.push :go
-        @multisearch_enabled_inside = values.pop
-      end
-      sync.push :go
-      @multisearch_enabled_after = values.pop
-
-      expect(@multisearch_enabled_before).to be(true)
-      expect(@multisearch_enabled_inside).to be(true)
-      expect(@multisearch_enabled_after).to be(true)
-    end
-  end
 end

data/spec/lib/pg_search_spec.rb

@@ -0,0 +1,221 @@
+require "spec_helper"
+
+describe PgSearch do
+  describe ".multisearch" do
+    with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
+
+    describe "delegation to PgSearch::Document.search" do
+      subject { PgSearch.multisearch(query) }
+
+      let(:query) { double(:query) }
+      let(:relation) { double(:relation) }
+      before do
+        expect(PgSearch::Document).to receive(:search).with(query).and_return(relation)
+      end
+
+      it { is_expected.to eq(relation) }
+    end
+
+    context "with PgSearch.multisearch_options set to a Hash" do
+      before { allow(PgSearch).to receive(:multisearch_options).and_return({:using => :dmetaphone}) }
+      subject { PgSearch.multisearch(query).map(&:searchable) }
+
+      with_model :MultisearchableModel do
+        table do |t|
+          t.string :title
+        end
+        model do
+          include PgSearch
+          multisearchable :against => :title
+        end
+      end
+
+      let!(:soundalike_record) { MultisearchableModel.create!(:title => 'foning') }
+      let(:query) { "Phoning" }
+      it { is_expected.to include(soundalike_record) }
+    end
+
+    context "with PgSearch.multisearch_options set to a Proc" do
+      subject { PgSearch.multisearch(query, soundalike).map(&:searchable) }
+
+      before do
+        allow(PgSearch).to receive(:multisearch_options) do
+          lambda do |query, soundalike|
+            if soundalike
+              {:using => :dmetaphone, :query => query}
+            else
+              {:query => query}
+            end
+          end
+        end
+      end
+
+      with_model :MultisearchableModel do
+        table do |t|
+          t.string :title
+        end
+        model do
+          include PgSearch
+          multisearchable :against => :title
+        end
+      end
+
+      let!(:soundalike_record) { MultisearchableModel.create!(:title => 'foning') }
+      let(:query) { "Phoning" }
+
+      context "with soundalike true" do
+        let(:soundalike) { true }
+        it { is_expected.to include(soundalike_record) }
+      end
+
+      context "with soundalike false" do
+        let(:soundalike) { false }
+        it { is_expected.not_to include(soundalike_record) }
+      end
+    end
+
+    context "on an STI subclass" do
+      with_model :SuperclassModel do
+        table do |t|
+          t.text 'content'
+          t.string 'type'
+        end
+      end
+
+      before do
+        searchable_subclass_model = Class.new(SuperclassModel) do
+          include PgSearch
+          multisearchable :against => :content
+        end
+        stub_const("SearchableSubclassModel", searchable_subclass_model)
+        stub_const("AnotherSearchableSubclassModel", searchable_subclass_model)
+        stub_const("NonSearchableSubclassModel", Class.new(SuperclassModel))
+      end
+
+      it "returns only results for that subclass" do
+        included = [
+          SearchableSubclassModel.create!(:content => "foo bar")
+        ]
+        excluded = [
+          SearchableSubclassModel.create!(:content => "baz"),
+          SuperclassModel.create!(:content => "foo bar"),
+          SuperclassModel.create!(:content => "baz"),
+          NonSearchableSubclassModel.create!(:content => "foo bar"),
+          NonSearchableSubclassModel.create!(:content => "baz")
+        ]
+
+        expect(SuperclassModel.count).to be 6
+        expect(SearchableSubclassModel.count).to be 2
+
+        expect(PgSearch::Document.count).to be 2
+
+        results = PgSearch.multisearch("foo bar")
+
+        expect(results.length).to be 1
+        expect(results.first.searchable.class).to be SearchableSubclassModel
+        expect(results.first.searchable).to eq included.first
+      end
+
+      it "updates an existing STI model does not create a new pg_search document" do
+        model = SearchableSubclassModel.create!(:content => "foo bar")
+        expect(SearchableSubclassModel.count).to eq(1)
+        # We fetch the model from the database again otherwise
+        # the pg_search_document from the cache is used.
+        model = SearchableSubclassModel.find(model.id)
+        model.content = "foo"
+        model.save!
+        results = PgSearch.multisearch("foo")
+        expect(results.size).to eq(SearchableSubclassModel.count)
+      end
+
+      it "reindexing works" do
+        NonSearchableSubclassModel.create!(:content => "foo bar")
+        NonSearchableSubclassModel.create!(:content => "baz")
+        expected = SearchableSubclassModel.create!(:content => "baz")
+        SuperclassModel.create!(:content => "foo bar")
+        SuperclassModel.create!(:content => "baz")
+        SuperclassModel.create!(:content => "baz2")
+
+        expect(SuperclassModel.count).to be 6
+        expect(NonSearchableSubclassModel.count).to be 2
+        expect(SearchableSubclassModel.count).to be 1
+
+        expect(PgSearch::Document.count).to be 1
+
+        PgSearch::Multisearch.rebuild(SearchableSubclassModel)
+
+        expect(PgSearch::Document.count).to be 1
+        expect(PgSearch::Document.first.searchable.class).to be SearchableSubclassModel
+        expect(PgSearch::Document.first.searchable).to eq expected
+      end
+
+      it "reindexing searchable STI doesn't clobber other related STI models" do
+        searchable_s = SearchableSubclassModel.create!(:content => "baz")
+        searchable_a = AnotherSearchableSubclassModel.create!(:content => "baz")
+
+        expect(PgSearch::Document.count).to be 2
+        PgSearch::Multisearch.rebuild(SearchableSubclassModel)
+        expect(PgSearch::Document.count).to be 2
+
+        classes = PgSearch::Document.all.collect {|d| d.searchable.class }
+        expect(classes).to include SearchableSubclassModel
+        expect(classes).to include AnotherSearchableSubclassModel
+      end
+    end
+  end
+
+  describe ".disable_multisearch" do
+    it "should temporarily disable multisearch" do
+      @multisearch_enabled_before = PgSearch.multisearch_enabled?
+      PgSearch.disable_multisearch do
+        @multisearch_enabled_inside = PgSearch.multisearch_enabled?
+      end
+      @multisearch_enabled_after = PgSearch.multisearch_enabled?
+
+      expect(@multisearch_enabled_before).to be(true)
+      expect(@multisearch_enabled_inside).to be(false)
+      expect(@multisearch_enabled_after).to be(true)
+    end
+
+    it "should reenable multisearch after an error" do
+      @multisearch_enabled_before = PgSearch.multisearch_enabled?
+      begin
+        PgSearch.disable_multisearch do
+          @multisearch_enabled_inside = PgSearch.multisearch_enabled?
+          raise
+        end
+      rescue # rubocop:disable Lint/HandleExceptions
+      end
+
+      @multisearch_enabled_after = PgSearch.multisearch_enabled?
+
+      expect(@multisearch_enabled_before).to be(true)
+      expect(@multisearch_enabled_inside).to be(false)
+      expect(@multisearch_enabled_after).to be(true)
+    end
+
+    it "should not disable multisearch on other threads" do
+      values = Queue.new
+      sync = Queue.new
+      Thread.new do
+        values.push PgSearch.multisearch_enabled?
+        sync.pop # wait
+        values.push PgSearch.multisearch_enabled?
+        sync.pop # wait
+        values.push PgSearch.multisearch_enabled?
+      end
+
+      @multisearch_enabled_before = values.pop
+      PgSearch.disable_multisearch do
+        sync.push :go
+        @multisearch_enabled_inside = values.pop
+      end
+      sync.push :go
+      @multisearch_enabled_after = values.pop
+
+      expect(@multisearch_enabled_before).to be(true)
+      expect(@multisearch_enabled_inside).to be(true)
+      expect(@multisearch_enabled_after).to be(true)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -15,7 +15,7 @@ require 'support/database'
 require 'support/with_model'
 
 DOCUMENTS_SCHEMA = lambda do |t|
-  t.belongs_to :searchable, :polymorphic => true
+  t.belongs_to :searchable, :polymorphic => true, :index => true
   t.text :content
   t.timestamps null: false
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_search
 version: !ruby/object:Gem::Version
-  version: 0.7.9
+  version: 1.0.0
 platform: ruby
 authors:
 - Grant Hutchins
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -115,14 +115,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.30.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.30.0
 description: PgSearch builds Active Record named scopes that take advantage of PostgreSQL's
   full text search
 email:
@@ -133,6 +133,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".autotest"
+- ".bundle/config"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -145,9 +146,6 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- bin/guard
-- bin/rake
-- bin/rspec
 - lib/pg_search.rb
 - lib/pg_search/compatibility.rb
 - lib/pg_search/configuration.rb
@@ -191,6 +189,7 @@ files:
 - spec/lib/pg_search/multisearch_spec.rb
 - spec/lib/pg_search/multisearchable_spec.rb
 - spec/lib/pg_search/normalizer_spec.rb
+- spec/lib/pg_search_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.rb
 - spec/support/with_model.rb
@@ -240,6 +239,7 @@ test_files:
 - spec/lib/pg_search/multisearch_spec.rb
 - spec/lib/pg_search/multisearchable_spec.rb
 - spec/lib/pg_search/normalizer_spec.rb
+- spec/lib/pg_search_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.rb
 - spec/support/with_model.rb

data/bin/guard

@@ -1,16 +0,0 @@
-#!/usr/bin/env ruby
-#
-# This file was generated by Bundler.
-#
-# The application 'guard' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require 'pathname'
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-require 'rubygems'
-require 'bundler/setup'
-
-load Gem.bin_path('guard', 'guard')

data/bin/rake

@@ -1,16 +0,0 @@
-#!/usr/bin/env ruby
-#
-# This file was generated by Bundler.
-#
-# The application 'rake' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require 'pathname'
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-require 'rubygems'
-require 'bundler/setup'
-
-load Gem.bin_path('rake', 'rake')

data/bin/rspec

@@ -1,16 +0,0 @@
-#!/usr/bin/env ruby
-#
-# This file was generated by Bundler.
-#
-# The application 'rspec' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require 'pathname'
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-require 'rubygems'
-require 'bundler/setup'
-
-load Gem.bin_path('rspec-core', 'rspec')