Starting postgres search engine plugin

Rodrigo Souto
1 parent ead9b1fb
Showing 36 changed files with 2144 additions and 0 deletions Show diff stats
plugins/pg_search/dependencies.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
plugins/pg_search/lib/pg_search/lib/pg_search/configuration/column.rb
plugins/pg_search/lib/pg_search/lib/pg_search/features.rb
plugins/pg_search/lib/pg_search/lib/pg_search/features/dmetaphone.rb
plugins/pg_search/lib/pg_search/lib/pg_search/features/trigram.rb
@@ -0,0 +1 @@
+# Test if database is postgres
@@ -0,0 +1,5 @@
+Autotest.add_hook :initialize do |at|
+  at.add_mapping(%r%^lib/.*\.rb$%, true) { |filename, _|
+    at.files_matching %r%^spec/.*_spec.rb$%
+  }
+end
@@ -0,0 +1 @@
+rvm use ree@pg_search
 \ No newline at end of file
@@ -0,0 +1,36 @@
+### 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.
@@ -0,0 +1,5 @@
+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
@@ -0,0 +1,19 @@
+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.
@@ -0,0 +1,351 @@
+= 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
@@ -0,0 +1,44 @@
+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
@@ -0,0 +1,10 @@
+ * 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
@@ -0,0 +1,8 @@
+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
@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem "pg"
+
+group :test do
+  gem "rspec", ">=2.4"
+  gem "autotest"
+  gem "with_model"
+end
@@ -0,0 +1,4 @@
+filename = File.join(File.dirname(__FILE__), '..', 'Gemfile.common')
+eval(File.read(filename), binding, filename, 1)
+
+gem "activerecord", "~>2.3.5"
@@ -0,0 +1,4 @@
+filename = File.join(File.dirname(__FILE__), '..', 'Gemfile.common')
+eval(File.read(filename), binding, filename, 1)
+
+gem "activerecord", "~>3.0.1"
@@ -0,0 +1,32 @@
+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
@@ -0,0 +1,80 @@
+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
@@ -0,0 +1,34 @@
+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
@@ -0,0 +1,42 @@
+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
@@ -0,0 +1,7 @@
+module PgSearch
+  module Features
+  end
+end
+require 'pg_search/features/dmetaphone'
+require 'pg_search/features/trigram'
+require 'pg_search/features/tsearch'
@@ -0,0 +1,28 @@
+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
@@ -0,0 +1,29 @@
+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
@@ -0,0 +1,72 @@
+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
@@ -0,0 +1,13 @@
+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
@@ -0,0 +1,11 @@
+require 'pg_search'
+#require 'rails'
+
+module PgSearch
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      raise
+      load "pg_search/tasks.rb"
+    end
+  end
+end
@@ -0,0 +1,31 @@
+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
@@ -0,0 +1,73 @@
+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
@@ -0,0 +1,37 @@
+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
@@ -0,0 +1,3 @@
+module PgSearch
+  VERSION = "0.2.1"
+end
@@ -0,0 +1,19 @@
+# -*- 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
@@ -0,0 +1,12 @@
+#!/bin/sh
+POSTGRESQL_VERSION=`pg_config --version | awk '{print $2}'`
+
+cd /tmp
+test -e /tmp/postgresql-$POSTGRESQL_VERSION.tar.bz2 || wget http://ftp9.us.postgresql.org/pub/mirrors/postgresql/source/v$POSTGRESQL_VERSION/postgresql-$POSTGRESQL_VERSION.tar.bz2
+test -d /tmp/postgresql-$POSTGRESQL_VERSION || tar zxvf postgresql-$POSTGRESQL_VERSION.tar.bz2
+cd postgresql-$POSTGRESQL_VERSION && eval ./configure `pg_config --configure` && make
+cd contrib/unaccent && make && make install
+cd ..
+cd contrib/pg_trgm && make && make install
+cd ..
+cd contrib/fuzzystrmatch && make && make install
@@ -0,0 +1,316 @@
+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
@@ -0,0 +1,648 @@
+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
@@ -0,0 +1,92 @@
+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
@@ -0,0 +1,4 @@
+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$;
+
@@ -0,0 +1 @@
+DROP FUNCTION pg_search_dmetaphone(text);
@@ -0,0 +1,31 @@
+lib_path = File.join(File.dirname(__FILE__), 'pg_search', 'lib')
+ActiveSupport::Dependencies.load_paths << lib_path
+$: << lib_path
+require 'pg_search'
+
+class PgSearchPlugin < Noosfero::Plugin
+
+  def self.plugin_name
+    "Postgres Full-Text Search"
+  end
+
+  def self.plugin_description
+    _("Search engine that uses Postgres Full-Text Search.")
+  end
+
+  def find_by_contents(asset, scope, query, paginate_options={}, options={})
+    scope.pg_search_plugin_search(query)
+  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
@@ -0,0 +1,32 @@
+require 'test_helper'
+require 'benchmark'
+
+class PerformanceTest < ActionController::IntegrationTest
+
+  searchables = %w[ article comment qualifier national_region certifier profile license scrap category ]
+  quantities = [10, 100, 1000]
+
+  searchables.each do |searchable|
+    self.send(:define_method, "test_#{searchable}_performance") do
+      klass = searchable.camelize.constantize
+      asset = searchable.pluralize.to_sym
+      quantities.each do |quantity|
+        create(klass, quantity)
+        get 'index'
+        like = Benchmark.measure { 10.times { @controller.send(:find_by_contents, asset, klass, searchable) } }
+        puts "Like for #{quantity}: #{like}"
+        Environment.default.enable_plugin(PgSearchPlugin)
+        get 'index'
+        like = Benchmark.measure { 10.times { @controller.send(:find_by_contents, asset, klass, searchable) } }
+        puts "Pg for #{quantity}: #{pg}"
+      end
+    end
+  end
+
+  private
+
+  def create(klass, quantity)
+    klass.destroy_all
+    quantity.times.each {fast_create(klass)}
+  end
+end
...	...	@@ -0,0 +1,5 @@
	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
...	...
...	...	@@ -0,0 +1 @@
	1	+rvm use ree@pg_search
0	2	\ No newline at end of file
...	...
...	...	@@ -0,0 +1,36 @@
	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.
...	...
...	...	@@ -0,0 +1,5 @@
	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
0	6	\ No newline at end of file
...	...
...	...	@@ -0,0 +1,19 @@
	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.
...	...
...	...	@@ -0,0 +1,351 @@
	1	+= pg_search
	2	+
	3	+* http://github.com/casecommons/pg_search/
	4	+
	5	+== DESCRIPTION
	6	+
	7	+PgSearch builds named scopes that take advantage of PostgreSQL's full text search
	8	+
	9	+Read the blog post introducing PgSearch at http://bit.ly/pg_search
	10	+
	11	+== INSTALL
	12	+
	13	+ gem install pg_search
	14	+
	15	+=== Rails 3
	16	+
	17	+In Gemfile
	18	+
	19	+ gem 'pg_search'
	20	+
	21	+=== Rails 2
	22	+
	23	+In environment.rb
	24	+
	25	+ config.gem 'pg_search'
	26	+
	27	+In Rakefile
	28	+
	29	+ require 'rubygems'
	30	+ require 'pg_search/tasks'
	31	+
	32	+== USAGE
	33	+
	34	+To add PgSearch to an ActiveRecord model, simply include the PgSearch module.
	35	+
	36	+ class Shape < ActiveRecord::Base
	37	+ include PgSearch
	38	+ end
	39	+
	40	+=== pg_search_scope
	41	+
	42	+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.
	43	+
	44	+==== Searching against one column
	45	+
	46	+To search against a column, pass a symbol as the :against option.
	47	+
	48	+ class BlogPost < ActiveRecord::Base
	49	+ include PgSearch
	50	+ pg_search_scope :search_by_title, :against => :title
	51	+ end
	52	+
	53	+We now have an ActiveRecord scope named search_by_title on our BlogPost model. It takes one parameter, a search query string.
	54	+
	55	+ BlogPost.create!(:title => "Recent Developments in the World of Pastrami")
	56	+ BlogPost.create!(:title => "Prosciutto and You: A Retrospective")
	57	+ BlogPost.search_by_title("pastrami") # => [#<BlogPost id: 2, title: "Recent Developments in the World of Pastrami">]
	58	+
	59	+==== Searching against multiple columns
	60	+
	61	+Just pass an Array if you'd like to search more than one column.
	62	+
	63	+ class Person < ActiveRecord::Base
	64	+ include PgSearch
	65	+ pg_search_scope :search_by_full_name, :against => [:first_name, :last_name]
	66	+ end
	67	+
	68	+Now our search query can match either or both of the columns.
	69	+
	70	+ person_1 = Person.create!(:first_name => "Grant", :last_name => "Hill")
	71	+ person_2 = Person.create!(:first_name => "Hugh", :last_name => "Grant")
	72	+
	73	+ Person.search_by_full_name("Grant") # => [person_1, person_2]
	74	+ Person.search_by_full_name("Grant Hill") # => [person_1]
	75	+
	76	+==== Dynamic search scopes
	77	+
	78	+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.
	79	+
	80	+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.
	81	+
	82	+ class Person < ActiveRecord::Base
	83	+ include PgSearch
	84	+ pg_search_scope :search_by_name, lambda do \|name_part, query\|
	85	+ raise ArgumentError unless [:first, :last].include?(name_part)
	86	+ {
	87	+ :against => name_part,
	88	+ :query => query
	89	+ }
	90	+ end
	91	+ end
	92	+
	93	+ person_1 = Person.create!(:first_name => "Grant", :last_name => "Hill")
	94	+ person_2 = Person.create!(:first_name => "Hugh", :last_name => "Grant")
	95	+
	96	+ Person.search_by_name :first, "Grant" # => [person_1]
	97	+ Person.search_by_name :last, "Grant" # => [person_2]
	98	+
	99	+==== Searching through associations
	100	+
	101	+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.
	102	+
	103	+ class Cracker < ActiveRecord::Base
	104	+ has_many :cheeses
	105	+ end
	106	+
	107	+ class Cheese < ActiveRecord::Base
	108	+ end
	109	+
	110	+ class Salami < ActiveRecord::Base
	111	+ include PgSearch
	112	+
	113	+ belongs_to :cracker
	114	+ has_many :cheeses, :through => :cracker
	115	+
	116	+ pg_search_scope :tasty_search, :associated_against => {
	117	+ :cheeses => [:kind, :brand],
	118	+ :cracker => :kind
	119	+ }
	120	+ end
	121	+
	122	+ salami_1 = Salami.create!
	123	+ salami_2 = Salami.create!
	124	+ salami_3 = Salami.create!
	125	+
	126	+ limburger = Cheese.create!(:kind => "Limburger")
	127	+ brie = Cheese.create!(:kind => "Brie")
	128	+ pepper_jack = Cheese.create!(:kind => "Pepper Jack")
	129	+
	130	+ Cracker.create!(:kind => "Black Pepper", :cheeses => [brie], :salami => salami_1)
	131	+ Cracker.create!(:kind => "Ritz", :cheeses => [limburger, pepper_jack], :salami => salami_2)
	132	+ Cracker.create!(:kind => "Graham", :cheeses => [limburger], :salami => salami_3)
	133	+
	134	+ Salami.tasty_search("pepper") # => [salami_1, salami_2]
	135	+
	136	+=== Searching using different search features
	137	+
	138	+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.
	139	+
	140	+ class Beer < ActiveRecord::Base
	141	+ include PgSearch
	142	+ pg_search_scope :against => :name, :features => [:tsearch, :trigram, :dmetaphone]
	143	+ end
	144	+
	145	+The currently implemented features are
	146	+
	147	+* :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)
	148	+* :trigram - {Trigram search}[http://www.postgresql.org/docs/current/static/pgtrgm.html], which requires the trigram contrib package
	149	+* :dmetaphone - {Double Metaphone search}[http://www.postgresql.org/docs/9.0/static/fuzzystrmatch.html#AEN120188], which requires the fuzzystrmatch contrib package
	150	+
	151	+==== :tsearch (Full Text Search)
	152	+
	153	+PostgreSQL's built-in full text search supports weighting, prefix searches, and stemming in multiple languages.
	154	+
	155	+===== Weighting
	156	+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.
	157	+
	158	+ class NewsArticle < ActiveRecord::Base
	159	+ include PgSearch
	160	+ pg_search_scope :against => {
	161	+ :title => 'A',
	162	+ :subtitle => 'B',
	163	+ :content => 'C'
	164	+ }
	165	+ end
	166	+
	167	+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.
	168	+
	169	+ class NewsArticle < ActiveRecord::Base
	170	+ include PgSearch
	171	+ pg_search_scope :against => [
	172	+ [:title, 'A'],
	173	+ [:subtitle, 'B'],
	174	+ [:content, 'C']
	175	+ ]
	176	+ end
	177	+
	178	+ class NewsArticle < ActiveRecord::Base
	179	+ include PgSearch
	180	+ pg_search_scope :against => [
	181	+ [:title, 'A'],
	182	+ {:subtitle => 'B'},
	183	+ :content
	184	+ ]
	185	+ end
	186	+
	187	+===== :prefix
	188	+
	189	+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.
	190	+
	191	+ class Superhero < ActiveRecord::Base
	192	+ include PgSearch
	193	+ pg_search_scope :whose_name_starts_with,
	194	+ :against => :name,
	195	+ :using => {
	196	+ :tsearch => {:prefix => true}
	197	+ }
	198	+ end
	199	+
	200	+ batman = Superhero.create :name => 'Batman'
	201	+ batgirl = Superhero.create :name => 'Batgirl'
	202	+ robin = Superhero.create :name => 'Robin'
	203	+
	204	+ Superhero.whose_name_starts_with("Bat") # => [batman, batgirl]
	205	+
	206	+===== :dictionary
	207	+
	208	+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.
	209	+
	210	+ class BoringTweet < ActiveRecord::Base
	211	+ include PgSearch
	212	+ pg_search_scope :kinda_matching,
	213	+ :against => :text,
	214	+ :using => {
	215	+ :tsearch => {:dictionary => "english"}
	216	+ }
	217	+ pg_search_scope :literally_matching,
	218	+ :against => :text,
	219	+ :using => {
	220	+ :tsearch => {:dictionary => "simple"}
	221	+ }
	222	+ end
	223	+
	224	+ sleepy = BoringTweet.create! :text => "I snoozed my alarm for fourteen hours today. I bet I can beat that tomorrow! #sleepy"
	225	+ sleeping = BoringTweet.create! :text => "You know what I like? Sleeping. That's what. #enjoyment"
	226	+ sleeper = BoringTweet.create! :text => "Have you seen Woody Allen's movie entitled Sleeper? Me neither. #boycott"
	227	+
	228	+ BoringTweet.kinda_matching("sleeping") # => [sleepy, sleeping, sleeper]
	229	+ BoringTweet.literally_matching("sleeping") # => [sleeping]
	230	+
	231	+==== :dmetaphone (Double Metaphone soundalike search)
	232	+
	233	+{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.
	234	+
	235	+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:
	236	+
	237	+ include "pg_search/tasks"
	238	+
	239	+and then run:
	240	+
	241	+ $ rake pg_search:migration:dmetaphone
	242	+
	243	+The following example shows how to use :dmetaphone.
	244	+
	245	+ class Word < ActiveRecord::Base
	246	+ include PgSearch
	247	+ pg_search_scope :that_sounds_like,
	248	+ :against => :spelling,
	249	+ :using => :dmetaphone
	250	+ end
	251	+
	252	+ four = Word.create! :spelling => 'four'
	253	+ far = Word.create! :spelling => 'far'
	254	+ fur = Word.create! :spelling => 'fur'
	255	+ five = Word.create! :spelling => 'five'
	256	+
	257	+ Word.that_sounds_like("fir") # => [four, far, fur]
	258	+
	259	+==== :trigram (Trigram search)
	260	+
	261	+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:
	262	+
	263	+ [" Lo", "Lor", "ore", "rem", "em ", "m i", " ip", "ips", "psu", "sum", "um ", "m "]
	264	+
	265	+Trigram search has some ability to work even with typos and misspellings in the query or text.
	266	+
	267	+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.
	268	+
	269	+
	270	+ class Website < ActiveRecord::Base
	271	+ include PgSearch
	272	+ pg_search_scope :kinda_spelled_like,
	273	+ :against => :name,
	274	+ :using => :trigram
	275	+ end
	276	+
	277	+ yahooo = Website.create! :name => "Yahooo!"
	278	+ yohoo = Website.create! :name => "Yohoo!"
	279	+ gogle = Website.create! :name => "Gogle"
	280	+ facebook = Website.create! :name => "Facebook"
	281	+
	282	+ Website.kinda_spelled_like("Yahoo!") # => [yahooo, yohoo]
	283	+
	284	+=== Ignoring accent marks
	285	+
	286	+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.
	287	+
	288	+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.
	289	+
	290	+
	291	+ class SpanishQuestion < ActiveRecord::Base
	292	+ include PgSearch
	293	+ pg_search_scope :gringo_search,
	294	+ :against => :word,
	295	+ :ignoring => :accents
	296	+ end
	297	+
	298	+ what = SpanishQuestion.create(:word => "Qué")
	299	+ how_many = SpanishQuestion.create(:word => "Cuánto")
	300	+ how = SpanishQuestion.create(:word => "Cómo")
	301	+
	302	+ SpanishQuestion.gringo_search("Que") # => [what]
	303	+ SpanishQuestion.gringo_search("Cüåñtô") # => [how_many]
	304	+
	305	+=== Using tsvector columns
	306	+
	307	+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.
	308	+
	309	+To use this functionality you'll need to do a few things:
	310	+
	311	+* 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.
	312	+* 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
	313	+* Should you have any pre-existing data in the table, update the newly-created tsvector columns with the expression that your trigger function uses.
	314	+* Add the option to pg_search_scope, e.g:
	315	+
	316	+ pg_search_scope :fast_content_search,
	317	+ :against => :content,
	318	+ :using => {
	319	+ dmetaphone: {
	320	+ tsvector_column: 'tsvector_content_dmetaphone'
	321	+ },
	322	+ tsearch: {
	323	+ dictionary: 'english',
	324	+ tsvector_column: 'tsvector_content_tsearch'
	325	+ }
	326	+ trigram: {} # trigram does not use tsvectors
	327	+ }
	328	+
	329	+Please note that the :against column is only used when the tsvector_column is not present for the search type.
	330	+
	331	+== REQUIREMENTS
	332	+
	333	+* ActiveRecord 2 or 3
	334	+* Postgresql
	335	+* Postgresql contrib modules for certain features
	336	+
	337	+== ATTRIBUTIONS
	338	+
	339	+PgSearch would not have been possible without inspiration from
	340	+{texticle}[https://github.com/tenderlove/texticle]. Thanks to
	341	+{Aaron Patterson}[http://tenderlovemaking.com/]!
	342	+
	343	+== CONTRIBUTIONS AND FEEDBACK
	344	+
	345	+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.
	346	+
	347	+We also have a {Google Group}[http://groups.google.com/group/casecommons-dev] for discussing pg_search and other Case Commons open source projects.
	348	+
	349	+== LICENSE
	350	+
	351	+MIT
...	...
...	...	@@ -0,0 +1,44 @@
	1	+require 'bundler'
	2	+Bundler::GemHelper.install_tasks
	3	+
	4	+task :default => :spec
	5	+
	6	+environments = %w[rails2 rails3]
	7	+major, minor, revision = RUBY_VERSION.split(".").map{\|str\| str.to_i }
	8	+
	9	+in_environment = lambda do \|environment, command\|
	10	+ sh %Q{export BUNDLE_GEMFILE="gemfiles/#{environment}/Gemfile"; bundle update && bundle exec #{command}}
	11	+end
	12	+
	13	+in_all_environments = lambda do \|command\|
	14	+ environments.each do \|environment\|
	15	+ next if environment == "rails2" && major == 1 && minor > 8
	16	+ puts "\n---#{environment}---\n"
	17	+ in_environment.call(environment, command)
	18	+ end
	19	+end
	20	+
	21	+desc "Run all specs against ActiveRecord 2 and 3"
	22	+task "spec" do
	23	+ in_all_environments.call('rspec spec')
	24	+end
	25	+
	26	+task "doc" do
	27	+ in_environment.call("rails3", "rspec --format d spec")
	28	+end
	29	+
	30	+namespace "autotest" do
	31	+ environments.each do \|environment\|
	32	+ desc "Run autotest in #{environment}"
	33	+ task environment do
	34	+ in_environment.call(environment, 'autotest -s rspec2')
	35	+ end
	36	+ end
	37	+end
	38	+
	39	+namespace "doc" do
	40	+ desc "Generate README and preview in browser"
	41	+ task "readme" do
	42	+ sh "rdoc -c utf8 README.rdoc && open doc/files/README_rdoc.html"
	43	+ end
	44	+end
...	...
...	...	@@ -0,0 +1,10 @@
	1	+ * Railtie for rake tasks
	2	+ * Tracker project
	3	+ * Exceptions for missing trigram, dmetaphone, etc. support
	4	+ * LIKE search
	5	+ * accept a block and pass it to the underlying scope
	6	+ * ability to search again a tsvector column
	7	+ * Generate indexes
	8	+ * Allow for chaining multiple pg_search scopes
	9	+
	10	+Also see https://github.com/Casecommons/pg_search/issues
...	...
...	...	@@ -0,0 +1,8 @@
	1	+searchables = %w[ article comment qualifier article national_region certifier profile license scrap category ]
	2	+searchables.each { \|searchable\| require_dependency searchable }
	3	+klasses = searchables.map {\|searchable\| searchable.camelize.constantize}
	4	+
	5	+klasses.module_eval do
	6	+ include PgSearch
	7	+ pg_search_scope :pg_search_plugin_search, :against => SEARCHABLE_FIELDS
	8	+end
...	...
...	...	@@ -0,0 +1,9 @@
	1	+source "http://rubygems.org"
	2	+
	3	+gem "pg"
	4	+
	5	+group :test do
	6	+ gem "rspec", ">=2.4"
	7	+ gem "autotest"
	8	+ gem "with_model"
	9	+end
...	...