Adding pg_search

Rodrigo Souto
1 parent 07b7133b
Showing 39 changed files with 98 additions and 2102 deletions Show diff stats
app/controllers/application_controller.rb
lib/noosfero/core_ext/active_record.rb
plugins/pg_search/README
plugins/pg_search/db/migrate/20130320010051_create_indexes_for_search.rb
plugins/pg_search/lib/ext/active_record.rb
plugins/pg_search/lib/pg_search/.autotest
plugins/pg_search/lib/pg_search/.rvmrc
plugins/pg_search/lib/pg_search/CHANGELOG
plugins/pg_search/lib/pg_search/Gemfile
plugins/pg_search/lib/pg_search/LICENSE
plugins/pg_search/lib/pg_search/README.rdoc
plugins/pg_search/lib/pg_search/Rakefile
plugins/pg_search/lib/pg_search/TODO
plugins/pg_search/lib/pg_search/defaut_search.rb
plugins/pg_search/lib/pg_search/gemfiles/Gemfile.common
plugins/pg_search/lib/pg_search/gemfiles/rails2/Gemfile
plugins/pg_search/lib/pg_search/gemfiles/rails3/Gemfile
plugins/pg_search/lib/pg_search/lib/pg_search.rb
plugins/pg_search/lib/pg_search/lib/pg_search/configuration.rb
plugins/pg_search/lib/pg_search/lib/pg_search/configuration/association.rb
@@ -165,12 +165,7 @@ class ApplicationController &lt; ActionController::Base
  
   def fallback_find_by_contents(asset, scope, query, paginate_options, options)
     return {:results => scope.paginate(paginate_options)} if query.blank?
-    klass = asset.to_s.singularize.camelize.constantize
-    fields = klass::SEARCHABLE_FIELDS.keys.map(&:to_s) & klass.column_names
-    conditions = fields.map do |field|
-      "lower(#{klass.table_name}.#{field}) LIKE \"%#{query.downcase.strip}%\""
-    end.join(' OR ')
-    {:results => scope.where(conditions).paginate(paginate_options)}
+    {:results => scope.like_search(conditions).paginate(paginate_options)}
   end
  
 end
@@ -13,4 +13,17 @@ class ActiveRecord::Base
     key.join('/')
   end
  
+  def self.like_search(query)
+    if defined?(self::SEARCHABLE_FIELDS)
+      fields = self::SEARCHABLE_FIELDS.keys.map(&:to_s) & column_names
+      query = query.downcase.strip
+      conditions = fields.map do |field|
+        "lower(#{table_name}.#{field}) LIKE '%#{query}%'"
+      end.join(' OR ')
+      where(conditions)
+    else
+      raise "No searchable fields defined for #{self.name}"
+    end
+  end
+
 end
@@ -0,0 +1,51 @@
+== Future
+
+If in the future you're considering to make use of weight and ranking on
+the search, you might use the pg_search lib:
+
+https://github.com/Casecommons/pg_search/tree/0.2-stable
+
+Here is how it would be done:
+
+== lib/pg_search_plugin.rb
+
+searchables = %w[ article comment qualifier national_region certifier profile license scrap category ]
+searchables.each { |searchable| require_dependency searchable }
+klasses = searchables.map {|searchable| searchable.camelize.constantize }
+
+klass.class_eval do
+  include PgSearch
+  pg_search_scope :pg_search_plugin_search,
+                  :against => klass::SEARCHABLE_FIELDS.keys,
+                  :using => { :tsearch => {:prefix => true, :tsvector_column => 'pg_search_plugin_tsv' } }
+end
+
+==
+
+You also would want to add the adequate indexes to the this searches. Here is
+an example with the profiles table:
+
+== db/migrate/000_create_indexes_for_profile_search.rb
+
+class CreateTsvIndexesForProfile < ActiveRecord::Migration
+  def self.up
+    execute "ALTER TABLE profiles ADD COLUMN pg_search_plugin_tsv tsvector"
+    fields = Profile::SEARCHABLE_FIELDS.map {|field, weight| "to_tsvector('simple', coalesce(\"profiles\".\"#{field}\", ''))"}.join(' || ')
+    execute <<-QUERY
+    UPDATE profiles SET pg_search_plugin_tsv = (#{fields});
+    QUERY
+
+    triggers = "pg_search_plugin_tsv, 'pg_catalog.simple', "
+    triggers += Profile::SEARCHABLE_FIELDS.keys.join(', ')
+    execute "CREATE TRIGGER pg_search_plugin_profiles_tsvectorupdate BEFORE INSERT OR UPDATE
+             ON profiles FOR EACH ROW EXECUTE PROCEDURE
+             tsvector_update_trigger(#{triggers});"
+  end
+
+  def self.down
+    execute "drop trigger pg_search_plugin_profiles_tsvectorupdate on profiles"
+    execute "alter table profiles drop column pg_search_plugin_tsv"
+  end
+end
+
+==
@@ -0,0 +1,19 @@
+class CreateIndexesForSearch < ActiveRecord::Migration
+  def self.up
+    searchables = %w[ article comment qualifier national_region certifier profile license scrap category ]
+    klasses = searchables.map {|searchable| searchable.camelize.constantize }
+    klasses.each do |klass|
+      klass::SEARCHABLE_FIELDS.keys.each do |field|
+        execute "create index pg_search_plugin_#{klass.name.singularize.downcase}_#{field} on #{klass.table_name} using gin(to_tsvector('simple', #{field}))"
+      end
+    end
+  end
+
+  def self.down
+    klasses.each do |klass|
+      klass::SEARCHABLE_FIELDS.keys.each do |field|
+        execute "drop index pg_search_plugin_#{klass.name.singularize.downcase}_#{field}"
+      end
+    end
+  end
+end
@@ -0,0 +1,12 @@
+require_dependency 'active_record'
+
+class ActiveRecord::Base
+  def self.pg_search_plugin_search(query)
+    if defined?(self::SEARCHABLE_FIELDS)
+      conditions = self::SEARCHABLE_FIELDS.map {|field, weight| "to_tsvector('simple', #{field}) @@ '#{query}'"}.join(' OR ')
+      where(conditions)
+    else
+      raise "No searchable fields defined for #{self.name}"
+    end
+  end
+end
@@ -1,5 +0,0 @@
-Autotest.add_hook :initialize do |at|
-  at.add_mapping(%r%^lib/.*\.rb$%, true) { |filename, _|
-    at.files_matching %r%^spec/.*_spec.rb$%
-  }
-end
@@ -1 +0,0 @@
-rvm use ree@pg_search
 \ No newline at end of file
@@ -1,36 +0,0 @@
-### 0.2.1
-
- * Backport support for searching against tsvector columns (Kris Hicks)
-
-### 0.2
-
- * Set dictionary to :simple by default for :tsearch. Before it was unset,
-   which would fall back to PostgreSQL's default dictionary, usually
-   "english".
-
- * Fix a bug with search strings containing a colon ":"
-
- * Improve performance of :associated_against by only doing one INNER JOIN per
-   association
-
-### 0.1.1
-
- * Fix a bug with dmetaphone searches containing " w " (which dmetaphone maps
-   to an empty string)
-
-### 0.1
-
- * Change API to {:ignoring => :accents} from {:normalizing => :diacritics}
-
- * Improve documentation
-
- * Fix bug where :associated_against would not work without an :against
-   present
-
-### 0.0.2
-
- * Fix gem ownership.
-
-### 0.0.1
-
- * Initial release.
@@ -1,5 +0,0 @@
-puts <<-MESSAGE
-This project uses multiple Gemfiles in subdirectories of ./gemfiles.
-The rake tasks automatically install these bundles as necessary. See rake -T.
-MESSAGE
-exit 1
 \ No newline at end of file
@@ -1,19 +0,0 @@
-Copyright (c) 2010-11 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
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
@@ -1,351 +0,0 @@
-= pg_search
-
-* http://github.com/casecommons/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
-
-== INSTALL
-
- gem install pg_search
-
-=== Rails 3
-
-In Gemfile
-
- gem 'pg_search'
-
-=== Rails 2
-
-In environment.rb
-
- config.gem 'pg_search'
-
-In Rakefile
-
- require 'rubygems'
- require 'pg_search/tasks'
-
-== USAGE
-
-To add PgSearch to an ActiveRecord model, simply include the PgSearch module.
-
- class Shape < ActiveRecord::Base
-   include PgSearch
- end
-
-=== pg_search_scope
-
-You can use pg_search_scope to build a search scope. The first parameter is a scope name, and the second parameter is an options hash. The only required option is :against, which tells pg_search_scope which column or columns to search against.
-
-==== Searching against one column
-
-To search against a column, pass a symbol as the :against option.
-
- class BlogPost < ActiveRecord::Base
-   include PgSearch
-   pg_search_scope :search_by_title, :against => :title
- end
-
-We now have an ActiveRecord scope named search_by_title on our BlogPost model. It takes one parameter, a search query string.
-
- BlogPost.create!(:title => "Recent Developments in the World of Pastrami")
- BlogPost.create!(:title => "Prosciutto and You: A Retrospective")
- BlogPost.search_by_title("pastrami") # => [#<BlogPost id: 2, title: "Recent Developments in the World of Pastrami">]
-
-==== Searching against multiple columns
-
-Just pass an Array if you'd like to search more than one column.
-
- class Person < ActiveRecord::Base
-   include PgSearch
-   pg_search_scope :search_by_full_name, :against => [:first_name, :last_name]
- end
-
-Now our search query can match either or both of the columns.
-
- person_1 = Person.create!(:first_name => "Grant", :last_name => "Hill")
- person_2 = Person.create!(:first_name => "Hugh", :last_name => "Grant")
-
- Person.search_by_full_name("Grant") # => [person_1, person_2]
- Person.search_by_full_name("Grant Hill") # => [person_1]
-
-==== Dynamic search scopes
-
-Just like with Active Record named scopes, you can pass in a Proc object that returns a hash of options. For instance, the following scope takes a parameter that dynamically chooses which column to search against.
-
-Important: The returned hash must include a :query key. Its value does not necessary have to be dynamic. You could choose to hard-code it to a specific value if you wanted.
-
- class Person < ActiveRecord::Base
-   include PgSearch
-   pg_search_scope :search_by_name, lambda do |name_part, query|
-     raise ArgumentError unless [:first, :last].include?(name_part)
-     {
-       :against => name_part,
-       :query => query
-     }
-   end
- end
-
- person_1 = Person.create!(:first_name => "Grant", :last_name => "Hill")
- person_2 = Person.create!(:first_name => "Hugh", :last_name => "Grant")
-
- Person.search_by_name :first, "Grant" # => [person_1]
- Person.search_by_name :last, "Grant" # => [person_2]
-
-==== Searching through associations
-
-You can pass a Hash into the :associated_against option to search columns on other models. The keys are the names of the associations and the value works just like an :against option for the other model.
-
-  class Cracker < ActiveRecord::Base
-    has_many :cheeses
-  end
-
-  class Cheese < ActiveRecord::Base
-  end
-
-  class Salami < ActiveRecord::Base
-    include PgSearch
-
-    belongs_to :cracker
-    has_many :cheeses, :through => :cracker
-
-    pg_search_scope :tasty_search, :associated_against => {
-      :cheeses => [:kind, :brand],
-      :cracker => :kind
-    }
-  end
-
-  salami_1 = Salami.create!
-  salami_2 = Salami.create!
-  salami_3 = Salami.create!
-
-  limburger = Cheese.create!(:kind => "Limburger")
-  brie = Cheese.create!(:kind => "Brie")
-  pepper_jack = Cheese.create!(:kind => "Pepper Jack")
-
-  Cracker.create!(:kind => "Black Pepper", :cheeses => [brie], :salami => salami_1)
-  Cracker.create!(:kind => "Ritz", :cheeses => [limburger, pepper_jack], :salami => salami_2)
-  Cracker.create!(:kind => "Graham", :cheeses => [limburger], :salami => salami_3)
-
-  Salami.tasty_search("pepper") # => [salami_1, salami_2]
-
-=== Searching using different search features
-
-By default, pg_search_scope uses the built-in {PostgreSQL text search}[http://www.postgresql.org/docs/current/static/textsearch-intro.html]. If you pass the :features option to pg_search_scope, you can choose alternative search techniques.
-
-  class Beer < ActiveRecord::Base
-    include PgSearch
-    pg_search_scope :against => :name, :features => [:tsearch, :trigram, :dmetaphone]
-  end
-
-The currently implemented features are
-
-* :tsearch - {Full text search}[http://www.postgresql.org/docs/current/static/textsearch-intro.html] (built-in with 8.3 and later, available as a contrib package for some earlier versions)
-* :trigram - {Trigram search}[http://www.postgresql.org/docs/current/static/pgtrgm.html], which requires the trigram contrib package
-* :dmetaphone - {Double Metaphone search}[http://www.postgresql.org/docs/9.0/static/fuzzystrmatch.html#AEN120188], which requires the fuzzystrmatch contrib package
-
-==== :tsearch (Full Text Search)
-
-PostgreSQL's built-in full text search supports weighting, prefix searches, and stemming in multiple languages.
-
-===== Weighting
-Each searchable column can be given a weight of "A", "B", "C", or "D". Columns with earlier letters are weighted higher than those with later letters. So, in the following example, the title is the most important, followed by the subtitle, and finally the content.
-
- class NewsArticle < ActiveRecord::Base
-   include PgSearch
-   pg_search_scope :against => {
-     :title => 'A',
-     :subtitle => 'B',
-     :content => 'C'
-   }
- end
-
-You can also pass the weights in as an array of arrays, or any other structure that responds to #each and yields either a single symbol or a symbol and a weight. If you omit the weight, a default will be used.
-
- class NewsArticle < ActiveRecord::Base
-   include PgSearch
-   pg_search_scope :against => [
-     [:title, 'A'],
-     [:subtitle, 'B'],
-     [:content, 'C']
-   ]
- end
-
- class NewsArticle < ActiveRecord::Base
-   include PgSearch
-   pg_search_scope :against => [
-     [:title, 'A'],
-     {:subtitle => 'B'},
-     :content
-   ]
- end
-
-===== :prefix
-
-PostgreSQL's full text search matches on whole words by default. If you want to search for partial words, however, you can set :prefix to true. Since this is a :tsearch-specific option, you should pass it to :tsearch directly, as shown in the following example.
-
-  class Superhero < ActiveRecord::Base
-    include PgSearch
-    pg_search_scope :whose_name_starts_with,
-                    :against => :name,
-                    :using => {
-                      :tsearch => {:prefix => true}
-                    }
-  end
-
-  batman = Superhero.create :name => 'Batman'
-  batgirl = Superhero.create :name => 'Batgirl'
-  robin = Superhero.create :name => 'Robin'
-
-  Superhero.whose_name_starts_with("Bat") # => [batman, batgirl]
-
-===== :dictionary
-
-PostgreSQL full text search also support multiple dictionaries for stemming. You can learn more about how dictionaries work by reading the {PostgreSQL documention}[http://www.postgresql.org/docs/current/static/textsearch-dictionaries.html]. If you use one of the language dictionaries, such as "english", then variants of words (e.g. "jumping" and "jumped") will match each other. If you don't want stemming, you should pick the "simple" dictionary which does not do any stemming. If you don't specify a dictionary, the "simple" dictionary will be used.
-
-  class BoringTweet < ActiveRecord::Base
-    include PgSearch
-    pg_search_scope :kinda_matching,
-                    :against => :text,
-                    :using => {
-                      :tsearch => {:dictionary => "english"}
-                    }
-    pg_search_scope :literally_matching,
-                    :against => :text,
-                    :using => {
-                      :tsearch => {:dictionary => "simple"}
-                    }
-  end
-
-  sleepy = BoringTweet.create! :text => "I snoozed my alarm for fourteen hours today. I bet I can beat that tomorrow! #sleepy"
-  sleeping = BoringTweet.create! :text => "You know what I like? Sleeping. That's what. #enjoyment"
-  sleeper = BoringTweet.create! :text => "Have you seen Woody Allen's movie entitled Sleeper? Me neither. #boycott"
-
-  BoringTweet.kinda_matching("sleeping") # => [sleepy, sleeping, sleeper]
-  BoringTweet.literally_matching("sleeping") # => [sleeping]
-
-==== :dmetaphone (Double Metaphone soundalike search)
-
-{Double Metaphone}[http://en.wikipedia.org/wiki/Double_Metaphone] is an algorithm for matching words that sound alike even if they are spelled very differently. For example, "Geoff" and "Jeff" sound identical and thus match. Currently, this is not a true double-metaphone, as only the first metaphone is used for searching.
-
-Double Metaphone support is currently available as part of the {fuzzystrmatch contrib package}[http://www.postgresql.org/docs/current/static/fuzzystrmatch.html] that must be installed before this feature can be used. In addition to the contrib package, you must install a utility function into your database. To generate a migration for this, add the following line to your Rakefile:
-
-  include "pg_search/tasks"
-
-and then run:
-
-  $ rake pg_search:migration:dmetaphone
-
-The following example shows how to use :dmetaphone.
-
-  class Word < ActiveRecord::Base
-    include PgSearch
-    pg_search_scope :that_sounds_like,
-                    :against => :spelling,
-                    :using => :dmetaphone
-  end
-
-  four = Word.create! :spelling => 'four'
-  far = Word.create! :spelling => 'far'
-  fur = Word.create! :spelling => 'fur'
-  five = Word.create! :spelling => 'five'
-
-  Word.that_sounds_like("fir") # => [four, far, fur]
-
-==== :trigram (Trigram search)
-
-Trigram search works by counting how many three-letter substrings (or "trigrams") match between the query and the text. For example, the string "Lorem ipsum" can be split into the following trigrams:
-
-  [" Lo", "Lor", "ore", "rem", "em ", "m i", " ip", "ips", "psu", "sum", "um ", "m  "]
-
-Trigram search has some ability to work even with typos and misspellings in the query or text.
-
-Trigram support is currently available as part of the {pg_trgm contrib package}[http://www.postgresql.org/docs/current/static/pgtrgm.html] that must be installed before this feature can be used.
-
-
-  class Website < ActiveRecord::Base
-    include PgSearch
-    pg_search_scope :kinda_spelled_like,
-                    :against => :name,
-                    :using => :trigram
-  end
-
-  yahooo = Website.create! :name => "Yahooo!"
-  yohoo = Website.create! :name => "Yohoo!"
-  gogle = Website.create! :name => "Gogle"
-  facebook = Website.create! :name => "Facebook"
-
-  Website.kinda_spelled_like("Yahoo!") # => [yahooo, yohoo]
-
-=== Ignoring accent marks
-
-Most of the time you will want to ignore accent marks when searching. This makes it possible to find words like "piñata" when searching with the query "pinata". If you set a pg_search_scope to ignore accents, it will ignore accents in both the searchable text and the query terms.
-
-Ignoring accents uses the {unaccent contrib package}[http://www.postgresql.org/docs/current/static/unaccent.html] that must be installed before this feature can be used.
-
-
-  class SpanishQuestion < ActiveRecord::Base
-    include PgSearch
-    pg_search_scope :gringo_search,
-                    :against => :word,
-                    :ignoring => :accents
-  end
-
-  what = SpanishQuestion.create(:word => "Qué")
-  how_many = SpanishQuestion.create(:word => "Cuánto")
-  how = SpanishQuestion.create(:word => "Cómo")
-
-  SpanishQuestion.gringo_search("Que") # => [what]
-  SpanishQuestion.gringo_search("Cüåñtô") # => [how_many]
-
-=== Using tsvector columns
-
-PostgreSQL allows you the ability to search against a column with type tsvector instead of using an expression; this speeds up searching dramatically as it offloads creation of the tsvector that the tsquery is evaluated against.
-
-To use this functionality you'll need to do a few things:
-
-* Create a column of type tsvector that you'd like to search against. If you want to search using multiple search methods, for example tsearch and dmetaphone, you'll need a column for each.
-* Create a trigger function that will update the column(s) using the expression appropriate for that type of search. See: http://www.postgresql.org/docs/current/static/textsearch-features.html#TEXTSEARCH-UPDATE-TRIGGERS
-* Should you have any pre-existing data in the table, update the newly-created tsvector columns with the expression that your trigger function uses.
-* Add the option to pg_search_scope, e.g:
-
-  pg_search_scope :fast_content_search,
-                  :against => :content,
-                  :using => {
-                    dmetaphone: {
-                      tsvector_column: 'tsvector_content_dmetaphone'
-                    },
-                    tsearch: {
-                      dictionary: 'english',
-                      tsvector_column: 'tsvector_content_tsearch'
-                    }
-                    trigram: {} # trigram does not use tsvectors
-                  }
-
-Please note that the :against column is only used when the tsvector_column is not present for the search type.
-
-== REQUIREMENTS
-
-* ActiveRecord 2 or 3
-* Postgresql
-* Postgresql contrib modules for certain features
-
-== ATTRIBUTIONS
-
-PgSearch would not have been possible without inspiration from
-{texticle}[https://github.com/tenderlove/texticle]. Thanks to 
-{Aaron Patterson}[http://tenderlovemaking.com/]!
-
-== CONTRIBUTIONS AND FEEDBACK
-
-Welcomed! Feel free to join and contribute to our {public Pivotal Tracker project}[https://www.pivotaltracker.com/projects/228645] where we manage new feature ideas and bugs.
-
-We also have a {Google Group}[http://groups.google.com/group/casecommons-dev] for discussing pg_search and other Case Commons open source projects.
-
-== LICENSE
-
-MIT
@@ -1,44 +0,0 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-task :default => :spec
-
-environments = %w[rails2 rails3]
-major, minor, revision = RUBY_VERSION.split(".").map{|str| str.to_i }
-
-in_environment = lambda do |environment, command|
-  sh %Q{export BUNDLE_GEMFILE="gemfiles/#{environment}/Gemfile"; bundle update && bundle exec #{command}}
-end
-
-in_all_environments = lambda do |command|
-  environments.each do |environment|
-    next if environment == "rails2" && major == 1 && minor > 8
-    puts "\n---#{environment}---\n"
-    in_environment.call(environment, command)
-  end
-end
-
-desc "Run all specs against ActiveRecord 2 and 3"
-task "spec" do
-  in_all_environments.call('rspec spec')
-end
-
-task "doc" do
-  in_environment.call("rails3", "rspec --format d spec")
-end
-
-namespace "autotest" do
-  environments.each do |environment|
-    desc "Run autotest in #{environment}"
-    task environment do
-      in_environment.call(environment, 'autotest -s rspec2')
-    end
-  end
-end
-
-namespace "doc" do
-  desc "Generate README and preview in browser"
-  task "readme" do
-    sh "rdoc -c utf8 README.rdoc && open doc/files/README_rdoc.html"
-  end
-end
@@ -1,10 +0,0 @@
- * Railtie for rake tasks
- * Tracker project
- * Exceptions for missing trigram, dmetaphone, etc. support
- * LIKE search
- * accept a block and pass it to the underlying scope
- * ability to search again a tsvector column
- * Generate indexes
- * Allow for chaining multiple pg_search scopes
-
-Also see https://github.com/Casecommons/pg_search/issues
@@ -1,8 +0,0 @@
-searchables = %w[ article comment qualifier article national_region certifier profile license scrap category ]
-searchables.each { |searchable| require_dependency searchable }
-klasses = searchables.map {|searchable| searchable.camelize.constantize}
-
-klasses.module_eval do
-  include PgSearch
-  pg_search_scope :pg_search_plugin_search, :against => SEARCHABLE_FIELDS
-end
@@ -1,9 +0,0 @@
-source "http://rubygems.org"
-
-gem "pg"
-
-group :test do
-  gem "rspec", ">=2.4"
-  gem "autotest"
-  gem "with_model"
-end
@@ -1,4 +0,0 @@
-filename = File.join(File.dirname(__FILE__), '..', 'Gemfile.common')
-eval(File.read(filename), binding, filename, 1)
-
-gem "activerecord", "~>2.3.5"
@@ -1,4 +0,0 @@
-filename = File.join(File.dirname(__FILE__), '..', 'Gemfile.common')
-eval(File.read(filename), binding, filename, 1)
-
-gem "activerecord", "~>3.0.1"
@@ -1,32 +0,0 @@
-require "active_record"
-require "pg_search/configuration"
-require "pg_search/features"
-require "pg_search/normalizer"
-require "pg_search/scope"
-require "pg_search/scope_options"
-require "pg_search/version"
-#require "pg_search/railtie" if defined?(Rails) && defined?(Rails::Railtie)
-
-module PgSearch
-  def self.included(base)
-    base.send(:extend, ClassMethods)
-  end
-
-  module ClassMethods
-    def pg_search_scope(name, options)
-      scope = PgSearch::Scope.new(name, self, options)
-      scope_method =
-        if respond_to?(:scope) && !protected_methods.include?('scope')
-          :scope # ActiveRecord 3.x
-        else
-          :named_scope # ActiveRecord 2.x
-        end
-
-      send(scope_method, name, scope.to_proc)
-    end
-  end
-
-  def rank
-    attributes['pg_search_rank'].to_f
-  end
-end
@@ -1,80 +0,0 @@
-require "pg_search/configuration/association"
-require "pg_search/configuration/column"
-
-module PgSearch
-  class Configuration
-    def initialize(options, model)
-      options = options.reverse_merge(default_options)
-      assert_valid_options(options)
-      @options = options
-      @model = model
-    end
-
-    def columns
-      regular_columns + associated_columns
-    end
-
-    def regular_columns
-      return [] unless @options[:against]
-      Array(@options[:against]).map do |column_name, weight|
-        Column.new(column_name, weight, @model)
-      end
-    end
-
-    def associations
-      return [] unless @options[:associated_against]
-      @options[:associated_against].map do |association, column_names|
-        association = Association.new(@model, association, column_names)
-        association
-      end.flatten
-    end
-
-    def associated_columns
-      associations.map(&:columns).flatten
-    end
-
-    def query
-      @options[:query].to_s
-    end
-
-    def ignore
-      Array.wrap(@options[:ignoring])
-    end
-
-    def ranking_sql
-      @options[:ranked_by]
-    end
-
-    def features
-      Array(@options[:using])
-    end
-
-    private
-
-    def default_options
-      {:using => :tsearch}
-    end
-
-    def assert_valid_options(options)
-      valid_keys = [:against, :ranked_by, :ignoring, :using, :query, :associated_against]
-      valid_values = {
-        :ignoring => [:accents]
-      }
-
-      unless options[:against] || options[:associated_against]
-        raise ArgumentError, "the search scope #{@name} must have :against#{" or :associated_against" if defined?(ActiveRecord::Relation)} in its options"
-      end
-      raise ArgumentError, ":associated_against requires ActiveRecord 3 or later" if options[:associated_against] && !defined?(ActiveRecord::Relation)
-
-      options.assert_valid_keys(valid_keys)
-
-      valid_values.each do |key, values_for_key|
-        Array.wrap(options[key]).each do |value|
-          unless values_for_key.include?(value)
-            raise ArgumentError, ":#{key} cannot accept #{value}"
-          end
-        end
-      end
-    end
-  end
-end
@@ -1,34 +0,0 @@
-require "digest"
-
-module PgSearch
-  class Configuration
-    class Association
-      attr_reader :columns
-      
-      def initialize(model, name, column_names)
-        @model = model
-        @name = name
-        @columns = Array(column_names).map do |column_name, weight|
-          Column.new(column_name, weight, @model, self)
-        end
-      end
-      
-      def table_name
-        @model.reflect_on_association(@name).table_name
-      end
-      
-      def join(primary_key)
-        selects = columns.map do |column|
-          "string_agg(#{column.full_name}, ' ') AS #{column.alias}"
-        end.join(", ")
-        relation = @model.joins(@name).select("#{primary_key} AS id, #{selects}").group(primary_key)
-        "LEFT OUTER JOIN (#{relation.to_sql}) #{subselect_alias} ON #{subselect_alias}.id = #{primary_key}"
-      end
-      
-      def subselect_alias
-        subselect_name = ["pg_search", table_name, @name, "subselect"].compact.join('_')
-        "pg_search_#{Digest::SHA2.hexdigest(subselect_name)}"
-      end
-    end
-  end
-end
@@ -1,42 +0,0 @@
-require 'digest'
-
-module PgSearch
-  class Configuration
-    class Column
-      attr_reader :weight, :association
-
-      def initialize(column_name, weight, model, association = nil)
-        @column_name = column_name.to_s
-        @weight = weight
-        @model = model
-        @association = association
-      end
-
-      def table
-        foreign? ? @association.table_name : @model.table_name
-      end
-
-      def full_name
-        "#{@model.connection.quote_table_name(table)}.#{@model.connection.quote_column_name(@column_name)}"
-      end
-
-      def to_sql
-        name = if foreign?
-                 "#{@association.subselect_alias}.#{self.alias}"
-               else
-                 full_name
-               end
-        "coalesce(#{name}, '')"
-      end
-
-      def foreign?
-        @association.present?
-      end
-
-      def alias
-        name = [association.subselect_alias, @column_name].compact.join('_')
-        "pg_search_#{Digest::SHA2.hexdigest(name)}"
-      end
-    end
-  end
-end
@@ -1,7 +0,0 @@
-module PgSearch
-  module Features
-  end
-end
-require 'pg_search/features/dmetaphone'
-require 'pg_search/features/trigram'
-require 'pg_search/features/tsearch'
@@ -1,28 +0,0 @@
-require "active_support/core_ext/module/delegation"
-
-module PgSearch
-  module Features
-    class DMetaphone
-      delegate :conditions, :rank, :to => :'@tsearch'
-
-      # config is temporary as we refactor
-      def initialize(query, options, config, model, normalizer)
-        dmetaphone_normalizer = Normalizer.new(normalizer)
-        options = (options || {}).merge(:dictionary => 'simple')
-        @tsearch = TSearch.new(query, options, config, model, dmetaphone_normalizer)
-      end
-
-      # Decorates a normalizer with dmetaphone processing.
-      class Normalizer
-        def initialize(normalizer_to_wrap)
-          @decorated_normalizer = normalizer_to_wrap
-        end
-
-        def add_normalization(original_sql)
-          otherwise_normalized_sql = @decorated_normalizer.add_normalization(original_sql)
-          "pg_search_dmetaphone(#{otherwise_normalized_sql})"
-        end
-      end
-    end
-  end
-end
@@ -1,29 +0,0 @@
-require "active_support/core_ext/module/delegation"
-
-module PgSearch
-  module Features
-    class Trigram
-      def initialize(query, options, columns, model, normalizer)
-        @query = query
-        @options = options
-        @columns = columns
-        @model = model
-        @normalizer = normalizer
-      end
-
-      def conditions
-        ["(#{@normalizer.add_normalization(document)}) % #{@normalizer.add_normalization(":query")}", {:query => @query}]
-      end
-
-      def rank
-        ["similarity((#{@normalizer.add_normalization(document)}), #{@normalizer.add_normalization(":query")})", {:query => @query}]
-      end
-
-      private
-
-      def document
-        @columns.map { |column| column.to_sql }.join(" || ' ' || ")
-      end
-    end
-  end
-end
@@ -1,72 +0,0 @@
-require "active_support/core_ext/module/delegation"
-
-module PgSearch
-  module Features
-    class TSearch
-      delegate :connection, :quoted_table_name, :to => :'@model'
-
-      def initialize(query, options, columns, model, normalizer)
-        @query = query
-        @options = options || {}
-        @model = model
-        @columns = columns
-        @normalizer = normalizer
-      end
-
-      def conditions
-        ["(#{tsdocument}) @@ (#{tsquery})", interpolations]
-      end
-
-      def rank
-        tsearch_rank
-      end
-
-      private
-
-      def interpolations
-        {:query => @query.to_s, :dictionary => dictionary.to_s}
-      end
-
-      def document
-        @columns.map { |column| column.to_sql }.join(" || ' ' || ")
-      end
-
-      def tsquery
-        return "''" if @query.blank?
-
-        @query.split(" ").compact.map do |term|
-          sanitized_term = term.gsub(/['?\-\\:]/, " ")
-
-          term_sql = @normalizer.add_normalization(connection.quote(sanitized_term))
-
-          # After this, the SQL expression evaluates to a string containing the term surrounded by single-quotes.
-          tsquery_sql = "#{connection.quote("' ")} || #{term_sql} || #{connection.quote(" '")}"
-
-          # Add tsearch prefix operator if we're using a prefix search.
-          tsquery_sql = "#{tsquery_sql} || #{connection.quote(':*')}" if @options[:prefix]
-
-          "to_tsquery(:dictionary, #{tsquery_sql})"
-        end.join(" && ")
-      end
-
-      def tsdocument
-        if @options[:tsvector_column]
-          @options[:tsvector_column].to_s
-        else
-          @columns.map do |search_column|
-            tsvector = "to_tsvector(:dictionary, #{@normalizer.add_normalization(search_column.to_sql)})"
-            search_column.weight.nil? ? tsvector : "setweight(#{tsvector}, #{connection.quote(search_column.weight)})"
-          end.join(" || ")
-        end
-      end
-
-      def tsearch_rank
-        ["ts_rank((#{tsdocument}), (#{tsquery}))", interpolations]
-      end
-
-      def dictionary
-        @options[:dictionary] || :simple
-      end
-    end
-  end
-end
@@ -1,13 +0,0 @@
-module PgSearch
-  class Normalizer
-    def initialize(config)
-      @config = config
-    end
-
-    def add_normalization(original_sql)
-      normalized_sql = original_sql
-      normalized_sql = "unaccent(#{normalized_sql})" if @config.ignore.include?(:accents)
-      normalized_sql
-    end
-  end
-end
@@ -1,11 +0,0 @@
-require 'pg_search'
-#require 'rails'
-
-module PgSearch
-  class Railtie < Rails::Railtie
-    rake_tasks do
-      raise
-      load "pg_search/tasks.rb"
-    end
-  end
-end
@@ -1,31 +0,0 @@
-module PgSearch
-  class Scope
-    def initialize(name, model, scope_options_or_proc)
-      @name = name
-      @model = model
-      @options_proc = build_options_proc(scope_options_or_proc)
-    end
-
-    def to_proc
-      lambda { |*args|
-        config = Configuration.new(@options_proc.call(*args), @model)
-        ScopeOptions.new(@name, @model, config).to_hash
-      }
-    end
-
-    private
-
-    def build_options_proc(scope_options_or_proc)
-      case scope_options_or_proc
-        when Proc
-          scope_options_or_proc
-        when Hash
-          lambda { |query|
-            scope_options_or_proc.reverse_merge(:query => query)
-          }
-        else
-          raise ArgumentError, "A PgSearch scope expects a Proc or Hash for its options"
-      end
-    end
-  end
-end
@@ -1,73 +0,0 @@
-require "active_support/core_ext/module/delegation"
-
-module PgSearch
-  class ScopeOptions
-    attr_reader :model
-
-    delegate :connection, :quoted_table_name, :sanitize_sql_array, :to => :model
-
-    def initialize(name, model, config)
-      @name = name
-      @model = model
-      @config = config
-
-      @feature_options = @config.features.inject({}) do |features_hash, (feature_name, feature_options)|
-        features_hash.merge(
-          feature_name => feature_options
-        )
-      end
-      @feature_names = @config.features.map { |feature_name, feature_options| feature_name }
-    end
-
-    def to_hash
-      {
-        :select => "#{quoted_table_name}.*, (#{rank}) AS pg_search_rank",
-        :conditions => conditions,
-        :order => "pg_search_rank DESC, #{primary_key} ASC",
-        :joins => joins
-      }
-    end
-
-    private
-
-    def conditions
-      @feature_names.map { |feature_name| "(#{sanitize_sql_array(feature_for(feature_name).conditions)})" }.join(" OR ")
-    end
-
-    def primary_key
-      "#{quoted_table_name}.#{connection.quote_column_name(model.primary_key)}"
-    end
-
-    def joins
-      @config.associations.map do |association|
-        association.join(primary_key)
-      end.join(' ')
-    end
-
-    def feature_for(feature_name)
-      feature_name = feature_name.to_sym
-
-      feature_class = {
-        :dmetaphone => Features::DMetaphone,
-        :tsearch => Features::TSearch,
-        :trigram => Features::Trigram
-      }[feature_name]
-
-      raise ArgumentError.new("Unknown feature: #{feature_name}") unless feature_class
-
-      normalizer = Normalizer.new(@config)
-
-      feature_class.new(@config.query, @feature_options[feature_name], @config.columns, @model, normalizer)
-    end
-
-    def tsearch_rank
-      sanitize_sql_array(@feature_names[Features::TSearch].rank)
-    end
-
-    def rank
-      (@config.ranking_sql || ":tsearch").gsub(/:(\w*)/) do
-        sanitize_sql_array(feature_for($1).rank)
-      end
-    end
-  end
-end
@@ -1,37 +0,0 @@
-require 'rake'
-require 'pg_search'
-
-namespace :pg_search do
-  namespace :migration do
-    desc "Generate migration to add support functions for :dmetaphone"
-    task :dmetaphone do
-      now = Time.now.utc
-      filename = "#{now.strftime('%Y%m%d%H%M%S')}_add_pg_search_dmetaphone_support_functions.rb"
-
-      dmetaphone_sql = File.read(File.join(File.dirname(__FILE__), '..', '..', 'sql', 'dmetaphone.sql')).chomp
-      uninstall_dmetaphone_sql = File.read(File.join(File.dirname(__FILE__), '..', '..', 'sql', 'uninstall_dmetaphone.sql')).chomp
-
-      File.open(Rails.root + 'db' + 'migrate' + filename, 'wb') do |migration_file|
-        migration_file.puts <<-RUBY
-class AddPgSearchDmetaphoneSupportFunctions < ActiveRecord::Migration
-  def self.up
-    say_with_time("Adding support functions for pg_search :dmetaphone") do
-      ActiveRecord::Base.connection.execute(<<-SQL)
-        #{dmetaphone_sql}
-      SQL
-    end
-  end
-
-  def self.down
-    say_with_time("Dropping support functions for pg_search :dmetaphone") do
-      ActiveRecord::Base.connection.execute(<<-SQL)
-        #{uninstall_dmetaphone_sql}
-      SQL
-    end
-  end
-end
-        RUBY
-      end
-    end
-  end
-end
@@ -1,3 +0,0 @@
-module PgSearch
-  VERSION = "0.2.1"
-end
@@ -1,19 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "pg_search/version"
-
-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.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.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"]
-end
@@ -1,12 +0,0 @@
-#!/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
@@ -1,316 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe PgSearch do
-  context "joining to another table" do
-    if defined?(ActiveRecord::Relation)
-      context "with Arel support" do
-        context "without an :against" do
-          with_model :AssociatedModel do
-            table do |t|
-              t.string "title"
-            end
-          end
-
-          with_model :ModelWithoutAgainst do
-            table do |t|
-              t.string "title"
-              t.belongs_to :another_model
-            end
-
-            model do
-              include PgSearch
-              belongs_to :another_model, :class_name => 'AssociatedModel'
-
-              pg_search_scope :with_another, :associated_against => {:another_model => :title}
-            end
-          end
-
-          it "returns rows that match the query in the columns of the associated model only" do
-            associated = AssociatedModel.create!(:title => 'abcdef')
-            included = [
-              ModelWithoutAgainst.create!(:title => 'abcdef', :another_model => associated),
-              ModelWithoutAgainst.create!(:title => 'ghijkl', :another_model => associated)
-            ]
-            excluded = [
-              ModelWithoutAgainst.create!(:title => 'abcdef')
-            ]
-
-            results = ModelWithoutAgainst.with_another('abcdef')
-            results.map(&:title).should =~ included.map(&:title)
-            results.should_not include(excluded)
-          end
-        end
-
-        context "through a belongs_to association" do
-          with_model :AssociatedModel do
-            table do |t|
-              t.string 'title'
-            end
-          end
-
-          with_model :ModelWithBelongsTo do
-            table do |t|
-              t.string 'title'
-              t.belongs_to 'another_model'
-            end
-
-            model do
-              include PgSearch
-              belongs_to :another_model, :class_name => 'AssociatedModel'
-
-              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 = AssociatedModel.create!(:title => 'abcdef')
-            included = [
-              ModelWithBelongsTo.create!(:title => 'ghijkl', :another_model => associated),
-              ModelWithBelongsTo.create!(:title => 'abcdef')
-            ]
-            excluded = ModelWithBelongsTo.create!(:title => 'mnopqr',
-                                                     :another_model => AssociatedModel.create!(:title => 'stuvwx'))
-
-            results = ModelWithBelongsTo.with_associated('abcdef')
-            results.map(&:title).should =~ included.map(&:title)
-            results.should_not include(excluded)
-          end
-        end
-
-        context "through a has_many association" do
-          with_model :AssociatedModelWithHasMany do
-            table do |t|
-              t.string 'title'
-              t.belongs_to 'ModelWithHasMany'
-            end
-          end
-
-          with_model :ModelWithHasMany do
-            table do |t|
-              t.string 'title'
-            end
-
-            model do
-              include PgSearch
-              has_many :other_models, :class_name => 'AssociatedModelWithHasMany', :foreign_key => 'ModelWithHasMany_id'
-
-              pg_search_scope :with_associated, :against => [:title], :associated_against => {:other_models => :title}
-            end
-          end
-
-          it "returns rows that match the query in either its own columns or the columns of the associated model" do
-            included = [
-              ModelWithHasMany.create!(:title => 'abcdef', :other_models => [
-                                          AssociatedModelWithHasMany.create!(:title => 'foo'),
-                                          AssociatedModelWithHasMany.create!(:title => 'bar')
-            ]),
-              ModelWithHasMany.create!(:title => 'ghijkl', :other_models => [
-                                          AssociatedModelWithHasMany.create!(:title => 'foo bar'),
-                                          AssociatedModelWithHasMany.create!(:title => 'mnopqr')
-            ]),
-              ModelWithHasMany.create!(:title => 'foo bar')
-            ]
-            excluded = ModelWithHasMany.create!(:title => 'stuvwx', :other_models => [
-                                                   AssociatedModelWithHasMany.create!(:title => 'abcdef')
-            ])
-
-            results = ModelWithHasMany.with_associated('foo bar')
-            results.map(&:title).should =~ included.map(&:title)
-            results.should_not include(excluded)
-          end
-        end
-
-        context "across multiple associations" do
-          context "on different tables" do
-            with_model :FirstAssociatedModel do
-              table do |t|
-                t.string 'title'
-                t.belongs_to 'model_with_many_associations'
-              end
-              model {}
-            end
-
-            with_model :SecondAssociatedModel do
-              table do |t|
-                t.string 'title'
-              end
-              model {}
-            end
-
-            with_model :ModelWithManyAssociations do
-              table do |t|
-                t.string 'title'
-                t.belongs_to 'model_of_second_type'
-              end
-
-              model do
-                include PgSearch
-                has_many :models_of_first_type, :class_name => 'FirstAssociatedModel', :foreign_key => 'model_with_many_associations_id'
-                belongs_to :model_of_second_type, :class_name => 'SecondAssociatedModel'
-
-                pg_search_scope :with_associated, :against => :title,
-                  :associated_against => {:models_of_first_type => :title, :model_of_second_type => :title}
-              end
-            end
-
-            it "returns rows that match the query in either its own columns or the columns of the associated model" do
-              matching_second = SecondAssociatedModel.create!(:title => "foo bar")
-              unmatching_second = SecondAssociatedModel.create!(:title => "uiop")
-
-              included = [
-                ModelWithManyAssociations.create!(:title => 'abcdef', :models_of_first_type => [
-                                                  FirstAssociatedModel.create!(:title => 'foo'),
-                                                  FirstAssociatedModel.create!(:title => 'bar')
-              ]),
-                ModelWithManyAssociations.create!(:title => 'ghijkl', :models_of_first_type => [
-                                                  FirstAssociatedModel.create!(:title => 'foo bar'),
-                                                  FirstAssociatedModel.create!(:title => 'mnopqr')
-              ]),
-                ModelWithManyAssociations.create!(:title => 'foo bar'),
-                ModelWithManyAssociations.create!(:title => 'qwerty', :model_of_second_type => matching_second)
-              ]
-              excluded = [
-                ModelWithManyAssociations.create!(:title => 'stuvwx', :models_of_first_type => [
-                                                  FirstAssociatedModel.create!(:title => 'abcdef')
-              ]),
-                ModelWithManyAssociations.create!(:title => 'qwerty', :model_of_second_type => unmatching_second)
-              ]
-
-              results = ModelWithManyAssociations.with_associated('foo bar')
-              results.map(&:title).should =~ included.map(&:title)
-              excluded.each { |object| results.should_not include(object) }
-            end
-          end
-
-          context "on the same table" do
-            with_model :DoublyAssociatedModel do
-              table do |t|
-                t.string 'title'
-                t.belongs_to 'model_with_double_association'
-                t.belongs_to 'model_with_double_association_again'
-              end
-              model {}
-            end
-
-            with_model :model_with_double_association do
-              table do |t|
-                t.string 'title'
-              end
-
-              model do
-                include PgSearch
-                has_many :things, :class_name => 'DoublyAssociatedModel', :foreign_key => 'model_with_double_association_id'
-                has_many :thingamabobs, :class_name => 'DoublyAssociatedModel', :foreign_key => 'model_with_double_association_again_id'
-
-                pg_search_scope :with_associated, :against => :title,
-                  :associated_against => {:things => :title, :thingamabobs => :title}
-              end
-            end
-
-            it "returns rows that match the query in either its own columns or the columns of the associated model" do
-              included = [
-                ModelWithDoubleAssociation.create!(:title => 'abcdef', :things => [
-                                                      DoublyAssociatedModel.create!(:title => 'foo'),
-                                                      DoublyAssociatedModel.create!(:title => 'bar')
-              ]),
-                ModelWithDoubleAssociation.create!(:title => 'ghijkl', :things => [
-                                                      DoublyAssociatedModel.create!(:title => 'foo bar'),
-                                                      DoublyAssociatedModel.create!(:title => 'mnopqr')
-              ]),
-                ModelWithDoubleAssociation.create!(:title => 'foo bar'),
-                ModelWithDoubleAssociation.create!(:title => 'qwerty', :thingamabobs => [
-                                                      DoublyAssociatedModel.create!(:title => "foo bar")
-              ])
-              ]
-              excluded = [
-                ModelWithDoubleAssociation.create!(:title => 'stuvwx', :things => [
-                                                      DoublyAssociatedModel.create!(:title => 'abcdef')
-              ]),
-                ModelWithDoubleAssociation.create!(:title => 'qwerty', :thingamabobs => [
-                                                      DoublyAssociatedModel.create!(:title => "uiop")
-              ])
-              ]
-
-              results = ModelWithDoubleAssociation.with_associated('foo bar')
-              results.map(&:title).should =~ included.map(&:title)
-              excluded.each { |object| results.should_not include(object) }
-            end
-          end
-        end
-
-        context "against multiple attributes on one association" do
-          with_model :AssociatedModel do
-            table do |t|
-              t.string 'title'
-              t.text 'author'
-            end
-          end
-
-          with_model :ModelWithAssociation do
-            table do |t|
-              t.belongs_to 'another_model'
-            end
-
-            model do
-              include PgSearch
-              belongs_to :another_model, :class_name => 'AssociatedModel'
-
-              pg_search_scope :with_associated, :associated_against => {:another_model => [:title, :author]}
-            end
-          end
-
-          it "should only do one join" do
-            included = [
-              ModelWithAssociation.create!(
-                :another_model => AssociatedModel.create!(
-                  :title => "foo",
-                  :author => "bar"
-                )
-              ),
-              ModelWithAssociation.create!(
-                :another_model => AssociatedModel.create!(
-                  :title => "foo bar",
-                  :author => "baz"
-                )
-              )
-            ]
-            excluded = [
-              ModelWithAssociation.create!(
-                :another_model => AssociatedModel.create!(
-                  :title => "foo",
-                  :author => "baz"
-                )
-              )
-            ]
-
-            results = ModelWithAssociation.with_associated('foo bar')
-
-            results.to_sql.scan("INNER JOIN").length.should == 1
-            included.each { |object| results.should include(object) }
-            excluded.each { |object| results.should_not include(object) }
-          end
-
-        end
-      end
-    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
@@ -1,648 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "an ActiveRecord model which includes PgSearch" do
-
-  with_model :ModelWithPgSearch 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
-      ModelWithPgSearch.class_eval do
-        pg_search_scope "matching_query", :against => []
-      end
-
-      lambda {
-        ModelWithPgSearch.scoped({}).matching_query("foo").scoped({})
-      }.should_not raise_error
-    end
-
-    context "when passed a lambda" do
-      it "builds a dynamic scope" do
-        ModelWithPgSearch.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 = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
-        excluded = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-
-        ModelWithPgSearch.search_title_or_content('fo-remove-o', false).should == [included]
-        ModelWithPgSearch.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 {
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :with_unknown_option, :against => :content, :foo => :bar
-          end
-          ModelWithPgSearch.with_unknown_option("foo")
-        }.should raise_error(ArgumentError, /foo/)
-      end
-
-      context "dynamically" do
-        it "raises an exception when invoked" do
-          lambda {
-            ModelWithPgSearch.class_eval do
-              pg_search_scope :with_unknown_option, lambda { |*| {:against => :content, :foo => :bar} }
-            end
-            ModelWithPgSearch.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 {
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :with_unknown_using, :against => :content, :using => :foo
-          end
-          ModelWithPgSearch.with_unknown_using("foo")
-        }.should raise_error(ArgumentError, /foo/)
-      end
-
-      context "dynamically" do
-        it "raises an exception when invoked" do
-          lambda {
-            ModelWithPgSearch.class_eval do
-              pg_search_scope :with_unknown_using, lambda { |*| {:against => :content, :using => :foo} }
-            end
-            ModelWithPgSearch.with_unknown_using("foo")
-          }.should raise_error(ArgumentError, /foo/)
-        end
-      end
-    end
-
-    context "when an unknown :ignoring is passed" do
-      it "raises an exception when invoked" do
-        lambda {
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :with_unknown_ignoring, :against => :content, :ignoring => :foo
-          end
-          ModelWithPgSearch.with_unknown_ignoring("foo")
-        }.should raise_error(ArgumentError, /ignoring.*foo/)
-      end
-
-      context "dynamically" do
-        it "raises an exception when invoked" do
-          lambda {
-            ModelWithPgSearch.class_eval do
-              pg_search_scope :with_unknown_ignoring, lambda { |*| {:against => :content, :ignoring => :foo} }
-            end
-            ModelWithPgSearch.with_unknown_ignoring("foo")
-          }.should raise_error(ArgumentError, /ignoring.*foo/)
-        end
-      end
-
-      context "when :against is not passed in" do
-        it "raises an exception when invoked" do
-          lambda {
-            ModelWithPgSearch.class_eval do
-              pg_search_scope :with_unknown_ignoring, {}
-            end
-            ModelWithPgSearch.with_unknown_ignoring("foo")
-          }.should raise_error(ArgumentError, /against/)
-        end
-        context "dynamically" do
-          it "raises an exception when invoked" do
-            lambda {
-              ModelWithPgSearch.class_eval do
-                pg_search_scope :with_unknown_ignoring, lambda { |*| {} }
-              end
-              ModelWithPgSearch.with_unknown_ignoring("foo")
-            }.should raise_error(ArgumentError, /against/)
-          end
-        end
-      end
-    end
-  end
-
-  describe "a search scope" do
-    context "against a single column" do
-      before do
-        ModelWithPgSearch.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
-        ModelWithPgSearch.create!(:content => 'foo')
-
-        results = ModelWithPgSearch.search_content('')
-        results.should == []
-      end
-
-      it "returns rows where the column contains the term in the query" do
-        included = ModelWithPgSearch.create!(:content => 'foo')
-        excluded = ModelWithPgSearch.create!(:content => 'bar')
-
-        results = ModelWithPgSearch.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 = [ModelWithPgSearch.create!(:content => 'foo bar'),
-                    ModelWithPgSearch.create!(:content => 'bar foo')]
-        excluded = ModelWithPgSearch.create!(:content => 'foo')
-
-        results = ModelWithPgSearch.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 = [ModelWithPgSearch.create!(:content => "foo"),
-                    ModelWithPgSearch.create!(:content => "FOO")]
-
-        results = ModelWithPgSearch.search_content("Foo")
-        results.should =~ included
-      end
-
-      it "returns rows that match the query only if their accents match" do
-        # \303\241 is a with acute accent
-        # \303\251 is e with acute accent
-
-        included = ModelWithPgSearch.create!(:content => "abcd\303\251f")
-        excluded = ModelWithPgSearch.create!(:content => "\303\241bcdef")
-
-        results = ModelWithPgSearch.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 = ModelWithPgSearch.create!(:content => 'pre')
-        excluded = ModelWithPgSearch.create!(:content => 'prefix')
-
-        results = ModelWithPgSearch.search_content("pre")
-        results.should == [included]
-        results.should_not include(excluded)
-      end
-
-      it "returns rows that match the query exactly and not those that match the query when stemmed by the default english dictionary" do
-        included = ModelWithPgSearch.create!(:content => "jumped")
-        excluded = [ModelWithPgSearch.create!(:content => "jump"),
-                    ModelWithPgSearch.create!(:content => "jumping")]
-
-        results = ModelWithPgSearch.search_content("jumped")
-        results.should == [included]
-      end
-
-      it "returns rows that match sorted by rank" do
-        loser = ModelWithPgSearch.create!(:content => 'foo')
-        winner = ModelWithPgSearch.create!(:content => 'foo foo')
-
-        results = ModelWithPgSearch.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 = [ModelWithPgSearch.create!(:content => 'foo'),
-                          ModelWithPgSearch.create!(:content => 'foo')].sort_by(&:id)
-
-        results = ModelWithPgSearch.search_content("foo")
-        results.should == sorted_results
-      end
-
-      it "returns results that match a query with multiple space-separated search terms" do
-        included = [
-          ModelWithPgSearch.create!(:content => 'foo bar'),
-          ModelWithPgSearch.create!(:content => 'bar foo'),
-          ModelWithPgSearch.create!(:content => 'bar foo baz'),
-        ]
-        excluded = [
-          ModelWithPgSearch.create!(:content => 'foo'),
-          ModelWithPgSearch.create!(:content => 'foo baz')
-        ]
-
-        results = ModelWithPgSearch.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 = ModelWithPgSearch.create!(:content => "(:Foo.) Bar?, \\")
-
-        results = ModelWithPgSearch.search_content("foo :bar .,?() \\")
-        results.should == [included]
-      end
-
-      it "accepts non-string queries and calls #to_s on them" do
-        foo = ModelWithPgSearch.create!(:content => "foo")
-        not_a_string = stub(:to_s => "foo")
-        ModelWithPgSearch.search_content(not_a_string).should == [foo]
-      end
-    end
-
-    context "against multiple columns" do
-      before do
-        ModelWithPgSearch.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 = [
-          ModelWithPgSearch.create!(:title => 'foo', :content => 'bar'),
-          ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-        ]
-        excluded = [
-          ModelWithPgSearch.create!(:title => 'foo', :content => 'foo'),
-          ModelWithPgSearch.create!(:title => 'bar', :content => 'bar')
-        ]
-
-        results = ModelWithPgSearch.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 = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
-        in_content = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-
-        results  = ModelWithPgSearch.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 = ModelWithPgSearch.create!(:title => 'foo', :content => nil)
-        results  = ModelWithPgSearch.search_title_and_content('foo')
-        results.should == [included]
-      end
-    end
-
-    context "using trigram" do
-      before do
-        ModelWithPgSearch.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 = ModelWithPgSearch.create!(:title => 'abcdefghijkl', :content => nil)
-        results = ModelWithPgSearch.with_trigrams('cdefhijkl')
-        results.should == [included]
-      end
-
-      it "returns rows where multiple searchable columns and the query share enough trigrams" do
-        included = ModelWithPgSearch.create!(:title => 'abcdef', :content => 'ghijkl')
-        results = ModelWithPgSearch.with_trigrams('cdefhijkl')
-        results.should == [included]
-      end
-    end
-
-    context "using tsearch" do
-      context "with :prefix => true" do
-        before do
-          ModelWithPgSearch.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 = ModelWithPgSearch.create!(:title => 'prefix')
-          excluded = ModelWithPgSearch.create!(:title => 'postfix')
-
-          results = ModelWithPgSearch.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 = [
-            ModelWithPgSearch.create!(:title => 'foo bar'),
-            ModelWithPgSearch.create!(:title => 'foo-bar')
-          ]
-          excluded = ModelWithPgSearch.create!(:title => 'baz quux')
-
-          results = ModelWithPgSearch.search_title_with_prefixes("foo-bar")
-          results.should =~ included
-          results.should_not include(excluded)
-        end
-      end
-
-      context "with the english dictionary" do
-        before do
-          ModelWithPgSearch.class_eval do
-            pg_search_scope :search_content_with_english,
-                            :against => :content,
-                            :using => {
-                              :tsearch => {:dictionary => :english}
-                            }
-          end
-        end
-
-        it "returns rows that match the query when stemmed by the english dictionary" do
-          included = [ModelWithPgSearch.create!(:content => "jump"),
-                      ModelWithPgSearch.create!(:content => "jumped"),
-                      ModelWithPgSearch.create!(:content => "jumping")]
-
-          results = ModelWithPgSearch.search_content_with_english("jump")
-          results.should =~ included
-        end
-      end
-
-      context "against columns ranked with arrays" do
-        before do
-          ModelWithPgSearch.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 = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
-
-          results = ModelWithPgSearch.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
-          ModelWithPgSearch.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 = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
-
-          results = ModelWithPgSearch.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
-          ModelWithPgSearch.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 = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
-
-          results = ModelWithPgSearch.search_weighted('foo')
-          results[0].rank.should > results[1].rank
-          results.should == [winner, loser]
-        end
-      end
-    end
-
-    context "using dmetaphone" do
-      before do
-        ModelWithPgSearch.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 = ModelWithPgSearch.create!(:title => 'Geoff', :content => nil)
-        excluded = ModelWithPgSearch.create!(:title => 'Bob', :content => nil)
-        results = ModelWithPgSearch.with_dmetaphones('Jeff')
-        results.should == [included]
-      end
-
-      it "returns rows where multiple searchable columns and the query share enough dmetaphones" do
-        included = ModelWithPgSearch.create!(:title => 'Geoff', :content => 'George')
-        excluded = ModelWithPgSearch.create!(:title => 'Bob', :content => 'Jones')
-        results = ModelWithPgSearch.with_dmetaphones('Jeff Jorge')
-        results.should == [included]
-      end
-
-      it "returns rows that match dmetaphones that are English stopwords" do
-        included = ModelWithPgSearch.create!(:title => 'White', :content => nil)
-        excluded = ModelWithPgSearch.create!(:title => 'Black', :content => nil)
-        results = ModelWithPgSearch.with_dmetaphones('Wight')
-        results.should == [included]
-      end
-
-      it "can handle terms that do not have a dmetaphone equivalent" do
-        term_with_blank_metaphone = "w"
-
-        included = ModelWithPgSearch.create!(:title => 'White', :content => nil)
-        excluded = ModelWithPgSearch.create!(:title => 'Black', :content => nil)
-
-        results = ModelWithPgSearch.with_dmetaphones('Wight W')
-        results.should == [included]
-      end
-    end
-
-    context "using multiple features" do
-      before do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :with_tsearch,
-                          :against => :title,
-                          :using => [
-                            [:tsearch, {:prefix => true}]
-                          ]
-
-          pg_search_scope :with_trigram, :against => :title, :using => :trigram
-
-          pg_search_scope :with_tsearch_and_trigram_using_array,
-                          :against => :title,
-                          :using => [
-                            [:tsearch, {:prefix => true}],
-                            :trigram
-                          ]
-
-        end
-      end
-
-      it "returns rows that match using any of the features" do
-        record = ModelWithPgSearch.create!(:title => "tiling is grouty")
-
-        # matches trigram only
-        trigram_query = "ling is grouty"
-        ModelWithPgSearch.with_trigram(trigram_query).should include(record)
-        ModelWithPgSearch.with_tsearch(trigram_query).should_not include(record)
-        ModelWithPgSearch.with_tsearch_and_trigram_using_array(trigram_query).should == [record]
-
-        # matches tsearch only
-        tsearch_query = "til"
-        ModelWithPgSearch.with_tsearch(tsearch_query).should include(record)
-        ModelWithPgSearch.with_trigram(tsearch_query).should_not include(record)
-        ModelWithPgSearch.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'}
-
-          ModelWithPgSearch.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)
-
-          ModelWithPgSearch.with_tsearch_and_trigram_using_hash("foo")
-        end
-      end
-    end
-
-    context "using a tsvector column" do
-      with_model :ModelWithPgSearchUsingTsVectorColumn do
-        table do |t|
-          t.text 'content'
-          t.column 'content_tsvector', :tsvector
-        end
-
-        model { include PgSearch }
-      end
-
-      let!(:expected) { ModelWithPgSearchUsingTsVectorColumn.create!(:content => 'tiling is grouty') }
-      let!(:unexpected) { ModelWithPgSearchUsingTsVectorColumn.create!(:content => 'longcat is looooooooong') }
-
-      before do
-        ActiveRecord::Base.connection.execute <<-SQL
-          UPDATE #{ModelWithPgSearchUsingTsVectorColumn.table_name}
-          SET content_tsvector = to_tsvector('english'::regconfig, "#{ModelWithPgSearchUsingTsVectorColumn.table_name}"."content")
-        SQL
-
-        ModelWithPgSearchUsingTsVectorColumn.class_eval do
-          pg_search_scope :search_by_content_with_tsvector,
-            :against => :content,
-            :using => {
-              :tsearch => {
-                :tsvector_column => 'content_tsvector',
-                :dictionary => 'english'
-              }
-            }
-        end
-      end
-
-      if defined?(ActiveRecord::Relation)
-        it "should not use to_tsvector in the query" do
-          ModelWithPgSearchUsingTsVectorColumn.search_by_content_with_tsvector("tiles").to_sql.should_not =~ /to_tsvector/
-        end
-      end
-
-      it "should find the expected result" do
-        ModelWithPgSearchUsingTsVectorColumn.search_by_content_with_tsvector("tiles").map(&:id).should == [expected.id]
-      end
-    end
-
-    context "ignoring accents" do
-      before do
-        ModelWithPgSearch.class_eval do
-          pg_search_scope :search_title_without_accents, :against => :title, :ignoring => :accents
-        end
-      end
-
-      it "returns rows that match the query but not its accents" do
-        # \303\241 is a with acute accent
-        # \303\251 is e with acute accent
-
-        included = ModelWithPgSearch.create!(:title => "\303\241bcdef")
-
-        results = ModelWithPgSearch.search_title_without_accents("abcd\303\251f")
-        results.should == [included]
-      end
-    end
-
-    context "when passed a :ranked_by expression" do
-      before do
-        ModelWithPgSearch.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
-        ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
-        results = ModelWithPgSearch.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
-        ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
-
-        tsearch_rank = ModelWithPgSearch.search_content_with_default_rank("foo").first.rank
-        multiplied_rank = ModelWithPgSearch.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 = [
-          ModelWithPgSearch.create!(:content => 'foo', :importance => 1),
-          ModelWithPgSearch.create!(:content => 'foo', :importance => 3),
-          ModelWithPgSearch.create!(:content => 'foo', :importance => 2)
-        ]
-
-        results = ModelWithPgSearch.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}"
-            ModelWithPgSearch.class_eval do
-              pg_search_scope scope_name,
-                              :against => :content,
-                              :ranked_by => ":#{feature}"
-            end
-          end
-
-          it "should return results with a rank" do
-            ModelWithPgSearch.create!(:content => 'foo')
-
-            results = ModelWithPgSearch.send(@scope_name, 'foo')
-            results.first.rank.should_not be_nil
-          end
-        end
-      end
-    end
-  end
-end
@@ -1,92 +0,0 @@
-require "bundler/setup"
-require "pg_search"
-
-begin
-  ActiveRecord::Base.establish_connection(:adapter  => 'postgresql',
-                                          :database => 'pg_search_test',
-                                          :min_messages => 'warning')
-  connection = ActiveRecord::Base.connection
-  connection.execute("SELECT 1")
-rescue PGError => e
-  puts "-" * 80
-  puts "Unable to connect to database.  Please run:"
-  puts
-  puts "    createdb pg_search_test"
-  puts "-" * 80
-  raise e
-end
-
-def install_contrib_module_if_missing(name, query, expected_result)
-  connection = ActiveRecord::Base.connection
-  result = connection.select_value(query)
-  raise "Unexpected output for #{query}: #{result.inspect}" unless result.downcase == expected_result.downcase
-rescue => e
-  begin
-    share_path = `pg_config --sharedir`.strip
-    ActiveRecord::Base.connection.execute File.read(File.join(share_path, 'contrib', "#{name}.sql"))
-    puts $!.message
-  rescue
-    puts "-" * 80
-    puts "Please install the #{name} contrib module"
-    puts "-" * 80
-    raise e
-  end
-end
-
-install_contrib_module_if_missing("pg_trgm", "SELECT 'abcdef' % 'cdef'", "t")
-install_contrib_module_if_missing("unaccent", "SELECT unaccent('foo')", "foo")
-install_contrib_module_if_missing("fuzzystrmatch", "SELECT dmetaphone('foo')", "f")
-
-ActiveRecord::Base.connection.execute(File.read(File.join(File.dirname(__FILE__), '..', 'sql', 'dmetaphone.sql')))
-
-require "with_model"
-
-RSpec.configure do |config|
-  config.extend WithModel
-end
-
-if defined?(ActiveRecord::Relation)
-  RSpec::Matchers::OperatorMatcher.register(ActiveRecord::Relation, '=~', RSpec::Matchers::MatchArray)
-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
@@ -1,4 +0,0 @@
-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+')))), ' ')
-$function$;
-
@@ -1 +0,0 @@
-DROP FUNCTION pg_search_dmetaphone(text);
-lib_path = File.join(File.dirname(__FILE__), 'pg_search', 'lib')
-ActiveSupport::Dependencies.load_paths << lib_path
-$: << lib_path
-require 'pg_search'
+require 'ext/active_record'
  
 class PgSearchPlugin < Noosfero::Plugin
  
@@ -14,18 +11,7 @@ class PgSearchPlugin &lt; Noosfero::Plugin
   end
  
   def find_by_contents(asset, scope, query, paginate_options={}, options={})
-    scope.pg_search_plugin_search(query)
+    {:results => scope.pg_search_plugin_search(query).paginate(paginate_options)}
   end
  
 end
-
-searchables = %w[ article comment qualifier national_region certifier profile license scrap category ]
-searchables.each { |searchable| require_dependency searchable }
-klasses = searchables.map {|searchable| searchable.camelize.constantize }
-
-klasses.each do |klass|
-  klass.class_eval do
-    include PgSearch
-    pg_search_scope :pg_search_plugin_search, :against => klass::SEARCHABLE_FIELDS
-  end
-end
...	...	@@ -165,12 +165,7 @@ class ApplicationController < ActionController::Base
165	165
166	166	def fallback_find_by_contents(asset, scope, query, paginate_options, options)
167	167	return {:results => scope.paginate(paginate_options)} if query.blank?
168		- klass = asset.to_s.singularize.camelize.constantize
169		- fields = klass::SEARCHABLE_FIELDS.keys.map(&:to_s) & klass.column_names
170		- conditions = fields.map do \|field\|
171		- "lower(#{klass.table_name}.#{field}) LIKE \"%#{query.downcase.strip}%\""
172		- end.join(' OR ')
173		- {:results => scope.where(conditions).paginate(paginate_options)}
	168	+ {:results => scope.like_search(conditions).paginate(paginate_options)}
174	169	end
175	170
176	171	end
...	...
...	...	@@ -13,4 +13,17 @@ class ActiveRecord::Base
13	13	key.join('/')
14	14	end
15	15
	16	+ def self.like_search(query)
	17	+ if defined?(self::SEARCHABLE_FIELDS)
	18	+ fields = self::SEARCHABLE_FIELDS.keys.map(&:to_s) & column_names
	19	+ query = query.downcase.strip
	20	+ conditions = fields.map do \|field\|
	21	+ "lower(#{table_name}.#{field}) LIKE '%#{query}%'"
	22	+ end.join(' OR ')
	23	+ where(conditions)
	24	+ else
	25	+ raise "No searchable fields defined for #{self.name}"
	26	+ end
	27	+ end
	28	+
16	29	end
...	...
...	...	@@ -0,0 +1,51 @@
	1	+== Future
	2	+
	3	+If in the future you're considering to make use of weight and ranking on
	4	+the search, you might use the pg_search lib:
	5	+
	6	+https://github.com/Casecommons/pg_search/tree/0.2-stable
	7	+
	8	+Here is how it would be done:
	9	+
	10	+== lib/pg_search_plugin.rb
	11	+
	12	+searchables = %w[ article comment qualifier national_region certifier profile license scrap category ]
	13	+searchables.each { \|searchable\| require_dependency searchable }
	14	+klasses = searchables.map {\|searchable\| searchable.camelize.constantize }
	15	+
	16	+klass.class_eval do
	17	+ include PgSearch
	18	+ pg_search_scope :pg_search_plugin_search,
	19	+ :against => klass::SEARCHABLE_FIELDS.keys,
	20	+ :using => { :tsearch => {:prefix => true, :tsvector_column => 'pg_search_plugin_tsv' } }
	21	+end
	22	+
	23	+==
	24	+
	25	+You also would want to add the adequate indexes to the this searches. Here is
	26	+an example with the profiles table:
	27	+
	28	+== db/migrate/000_create_indexes_for_profile_search.rb
	29	+
	30	+class CreateTsvIndexesForProfile < ActiveRecord::Migration
	31	+ def self.up
	32	+ execute "ALTER TABLE profiles ADD COLUMN pg_search_plugin_tsv tsvector"
	33	+ fields = Profile::SEARCHABLE_FIELDS.map {\|field, weight\| "to_tsvector('simple', coalesce(\"profiles\".\"#{field}\", ''))"}.join(' \|\| ')
	34	+ execute <<-QUERY
	35	+ UPDATE profiles SET pg_search_plugin_tsv = (#{fields});
	36	+ QUERY
	37	+
	38	+ triggers = "pg_search_plugin_tsv, 'pg_catalog.simple', "
	39	+ triggers += Profile::SEARCHABLE_FIELDS.keys.join(', ')
	40	+ execute "CREATE TRIGGER pg_search_plugin_profiles_tsvectorupdate BEFORE INSERT OR UPDATE
	41	+ ON profiles FOR EACH ROW EXECUTE PROCEDURE
	42	+ tsvector_update_trigger(#{triggers});"
	43	+ end
	44	+
	45	+ def self.down
	46	+ execute "drop trigger pg_search_plugin_profiles_tsvectorupdate on profiles"
	47	+ execute "alter table profiles drop column pg_search_plugin_tsv"
	48	+ end
	49	+end
	50	+
	51	+==
...	...
...	...	@@ -0,0 +1,19 @@
	1	+class CreateIndexesForSearch < ActiveRecord::Migration
	2	+ def self.up
	3	+ searchables = %w[ article comment qualifier national_region certifier profile license scrap category ]
	4	+ klasses = searchables.map {\|searchable\| searchable.camelize.constantize }
	5	+ klasses.each do \|klass\|
	6	+ klass::SEARCHABLE_FIELDS.keys.each do \|field\|
	7	+ execute "create index pg_search_plugin_#{klass.name.singularize.downcase}_#{field} on #{klass.table_name} using gin(to_tsvector('simple', #{field}))"
	8	+ end
	9	+ end
	10	+ end
	11	+
	12	+ def self.down
	13	+ klasses.each do \|klass\|
	14	+ klass::SEARCHABLE_FIELDS.keys.each do \|field\|
	15	+ execute "drop index pg_search_plugin_#{klass.name.singularize.downcase}_#{field}"
	16	+ end
	17	+ end
	18	+ end
	19	+end
...	...
...	...	@@ -0,0 +1,12 @@
	1	+require_dependency 'active_record'
	2	+
	3	+class ActiveRecord::Base
	4	+ def self.pg_search_plugin_search(query)
	5	+ if defined?(self::SEARCHABLE_FIELDS)
	6	+ conditions = self::SEARCHABLE_FIELDS.map {\|field, weight\| "to_tsvector('simple', #{field}) @@ '#{query}'"}.join(' OR ')
	7	+ where(conditions)
	8	+ else
	9	+ raise "No searchable fields defined for #{self.name}"
	10	+ end
	11	+ end
	12	+end
...	...
...	...	@@ -1,5 +0,0 @@
1		-Autotest.add_hook :initialize do \|at\|
2		- at.add_mapping(%r%^lib/.*\.rb$%, true) { \|filename, _\|
3		- at.files_matching %r%^spec/.*_spec.rb$%
4		- }
5		-end
...	...	@@ -1 +0,0 @@
1		-rvm use ree@pg_search
2	0	\ No newline at end of file
...	...	@@ -1,36 +0,0 @@
1		-### 0.2.1
2		-
3		- * Backport support for searching against tsvector columns (Kris Hicks)
4		-
5		-### 0.2
6		-
7		- * Set dictionary to :simple by default for :tsearch. Before it was unset,
8		- which would fall back to PostgreSQL's default dictionary, usually
9		- "english".
10		-
11		- * Fix a bug with search strings containing a colon ":"
12		-
13		- * Improve performance of :associated_against by only doing one INNER JOIN per
14		- association
15		-
16		-### 0.1.1
17		-
18		- * Fix a bug with dmetaphone searches containing " w " (which dmetaphone maps
19		- to an empty string)
20		-
21		-### 0.1
22		-
23		- * Change API to {:ignoring => :accents} from {:normalizing => :diacritics}
24		-
25		- * Improve documentation
26		-
27		- * Fix bug where :associated_against would not work without an :against
28		- present
29		-
30		-### 0.0.2
31		-
32		- * Fix gem ownership.
33		-
34		-### 0.0.1
35		-
36		- * Initial release.
...	...	@@ -1,5 +0,0 @@
1		-puts <<-MESSAGE
2		-This project uses multiple Gemfiles in subdirectories of ./gemfiles.
3		-The rake tasks automatically install these bundles as necessary. See rake -T.
4		-MESSAGE
5		-exit 1
6	0	\ No newline at end of file
...	...	@@ -1,19 +0,0 @@
1		-Copyright (c) 2010-11 Case Commons, LLC
2		-
3		-Permission is hereby granted, free of charge, to any person obtaining a copy
4		-of this software and associated documentation files (the "Software"), to deal
5		-in the Software without restriction, including without limitation the rights
6		-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7		-copies of the Software, and to permit persons to whom the Software is
8		-furnished to do so, subject to the following conditions:
9		-
10		-The above copyright notice and this permission notice shall be included in
11		-all copies or substantial portions of the Software.
12		-
13		-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14		-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15		-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16		-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17		-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18		-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19		-THE SOFTWARE.