pg_search 2.1.4 → 2.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3d24ca431eaf08e99b0d374bd21f24ad6c6c5c3ae39b5d6d4339be5ca8f556e
-  data.tar.gz: 5be5841ec1e98be066cdb1f92f055721bf1a79fb10fa1b3a3ac52be0f0f539e4
+  metadata.gz: 37f3b1c59cc5c10933bcec4bdb40902714172e666537bb7ac43f8c43a4acd43c
+  data.tar.gz: 30132ced7cbe402c69ccdc0affeb3224ab31690d2cf6ca260b00d21d7602d42c
 SHA512:
-  metadata.gz: e9a08bd5e623a50c863ce0e8abe8b2d1411ce64d3055ebba3d88e3d560884da92c423113e263d680b5489a200cbda743d4926d455a4b015b136a9207de8de5c5
-  data.tar.gz: 92c05e6b51c64753ddc04ee4c39e2328b22b374d2bd891cbdcf30d54dc0fa9b693cd2e0d99a1e2d31e73416215f4844f8297d3406ed365e3f12aa52877f2060a
+  metadata.gz: 9157dc3eeb50d6bcdf20745c89888ff855a01679de95135c84f58f6b5efe88df0a5d9e813d18acc16376041e63eed118785847667da46e429abf46ef955fcde3
+  data.tar.gz: c548d7841d812553ed0dbbf6ab50decd833a0b271fe799be9989c7ff03c320451f8658930c8abaca87da70d812dc18c904a900ff91b44b96305eb7fdf55a70f8

data/.rubocop.yml

@@ -1,7 +1,8 @@
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.4
   Exclude:
     - bin/**/*
+    - vendor/**/*
 
 Style/StringLiterals:
   Enabled: false
@@ -19,9 +20,6 @@ Metrics/BlockLength:
 Layout/AlignParameters:
   EnforcedStyle: with_fixed_indentation
 
-Style/HashSyntax:
-  Enabled: false
-
 Style/NumericPredicate:
   Enabled: false
 

data/.travis.yml

@@ -1,23 +1,25 @@
 language: ruby
 sudo: false
 bundler_args: --binstubs
-before_install: gem install bundler
+cache: bundler
 
 rvm:
-  - "2.6.0"
-  - "2.5.3"
-  - "2.4.5"
-  - "2.3.8"
-  - "jruby-9.2.5.0"
+  - 2.6.2
+  - 2.5.5
+  - 2.4.5
+  - jruby-9.2.6.0
 
 env:
-  - ACTIVE_RECORD_BRANCH="master"
-  - ACTIVE_RECORD_BRANCH="5-2-stable"
-  - ACTIVE_RECORD_VERSION="~> 6.0.0.beta1"
-  - ACTIVE_RECORD_VERSION="~> 5.2.0"
-  - ACTIVE_RECORD_VERSION="~> 5.1.0"
-  - ACTIVE_RECORD_VERSION="~> 5.0.0"
-  - ACTIVE_RECORD_VERSION="~> 4.2.9"
+  global:
+    - CC_TEST_REPORTER_ID=0a0e3e45118bc447e677d52c21d056a5471c4921d54f96ed7b2550d9fc5043ea
+  matrix:
+    - ACTIVE_RECORD_BRANCH="master"
+    - ACTIVE_RECORD_BRANCH="5-2-stable"
+    - ACTIVE_RECORD_VERSION="~> 6.0.0.beta1"
+    - ACTIVE_RECORD_VERSION="~> 5.2.0"
+    - ACTIVE_RECORD_VERSION="~> 5.1.0"
+    - ACTIVE_RECORD_VERSION="~> 5.0.0"
+    - ACTIVE_RECORD_VERSION="~> 4.2.9"
 
 matrix:
   allow_failures:
@@ -25,24 +27,24 @@ matrix:
     - env: ACTIVE_RECORD_BRANCH="5-2-stable"
     - env: ACTIVE_RECORD_VERSION="~> 6.0.0.beta1"
   exclude:
-    - rvm: "2.3.8"
+    - rvm: 2.4.5
       env: ACTIVE_RECORD_BRANCH="master"
-    - rvm: "2.4.5"
-      env: ACTIVE_RECORD_BRANCH="master"
-    - rvm: jruby-9.2.5.0
+    - rvm: jruby-9.2.6.0
       env: ACTIVE_RECORD_VERSION="~> 4.2.9"
-    - rvm: "2.3.8"
-      env: ACTIVE_RECORD_VERSION="~> 6.0.0.beta1"
-    - rvm: "2.4.5"
+    - rvm: 2.4.5
       env: ACTIVE_RECORD_VERSION="~> 6.0.0.beta1"
 
 before_script:
-  - "psql --version"
-  - "psql -c 'create database pg_search_test;' -U postgres >/dev/null"
+  - psql --version
+  - psql -c 'create database pg_search_test;' -U postgres >/dev/null
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+
+script: bin/rake
 
-script: "bin/rake"
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT
 
 addons:
   postgresql: "9.6"
-  code_climate:
-    repo_token: 0a0e3e45118bc447e677d52c21d056a5471c4921d54f96ed7b2550d9fc5043ea

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # pg_search changelog
 
+## 2.1.5
+
+* Drop support for Ruby < 2.4
+
 ## 2.1.4
 
 * Drop support for Ruby < 2.3

data/Gemfile

@@ -4,12 +4,12 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'pg', '>= 0.21.0', '< 1.0.0', :platform => :ruby
-gem "activerecord-jdbcpostgresql-adapter", ">= 1.3.1", :platform => :jruby
+gem 'pg', '>= 0.21.0', '< 1.0.0', platform: :ruby
+gem "activerecord-jdbcpostgresql-adapter", ">= 1.3.1", platform: :jruby
 
 if ENV['ACTIVE_RECORD_BRANCH']
-  gem 'activerecord', :git => 'https://github.com/rails/rails.git', :branch => ENV['ACTIVE_RECORD_BRANCH']
-  gem 'arel', :git => 'https://github.com/rails/arel.git' if ENV['ACTIVE_RECORD_BRANCH'] == 'master'
+  gem 'activerecord', git: 'https://github.com/rails/rails.git', branch: ENV['ACTIVE_RECORD_BRANCH']
+  gem 'arel', git: 'https://github.com/rails/arel.git' if ENV['ACTIVE_RECORD_BRANCH'] == 'master'
 end
 
 gem 'activerecord', ENV['ACTIVE_RECORD_VERSION'] if ENV['ACTIVE_RECORD_VERSION']

data/README.md

@@ -17,7 +17,7 @@ Read the blog post introducing PgSearch at https://content.pivotal.io/blog/pg-se
 
 ## REQUIREMENTS
 
-*   Ruby 2.3+
+*   Ruby 2.4+
 *   ActiveRecord 4.2+
 *   PostgreSQL 9.2+
 *   [PostgreSQL extensions](https://github.com/Casecommons/pg_search/wiki/Installing-PostgreSQL-Extensions) for certain features
@@ -89,12 +89,12 @@ multisearchable in its class definition.
 ```ruby
 class EpicPoem < ActiveRecord::Base
   include PgSearch
-  multisearchable :against => [:title, :author]
+  multisearchable against: [:title, :author]
 end
 
 class Flower < ActiveRecord::Base
   include PgSearch
-  multisearchable :against => :color
+  multisearchable against: :color
 end
 ```
 
@@ -114,14 +114,14 @@ particular record should be included.
 ```ruby
 class Convertible < ActiveRecord::Base
   include PgSearch
-  multisearchable :against => [:make, :model],
-                  :if => :available_in_red?
+  multisearchable against: [:make, :model],
+                  if: :available_in_red?
 end
 
 class Jalopy < ActiveRecord::Base
   include PgSearch
-  multisearchable :against => [:make, :model],
-                  :if => lambda { |record| record.model_year > 1970 }
+  multisearchable against: [:make, :model],
+                  if: lambda { |record| record.model_year > 1970 }
 end
 ```
 
@@ -134,8 +134,8 @@ timestamp.
 ```ruby
 class AntipatternExample
   include PgSearch
-  multisearchable :against => [:contents],
-                  :if => :published?
+  multisearchable against: [:contents],
+                  if: :published?
 
   def published?
     published_at < Time.now
@@ -143,8 +143,8 @@ class AntipatternExample
 end
 
 problematic_record = AntipatternExample.create!(
-  :contents => "Using :if with a timestamp",
-  :published_at => 10.minutes.from_now
+  contents: "Using :if with a timestamp",
+  published_at: 10.minutes.from_now
 )
 
 problematic_record.published?     # => false
@@ -161,6 +161,46 @@ problematic_record.published?     # => true
 PgSearch.multisearch("timestamp") # => Includes problematic_record
 ```
 
+#### More Options 
+
+**Conditionally update pg_search_documents**
+
+You can specify an `:update_if` parameter to conditionally update pg_search documents. For example:
+
+```ruby
+multisearchable(
+    against: [:body],
+    update_if: :body_changed?
+  )
+```
+
+**Specify additional attributes to be saved on the pg_search_documents table**
+
+You can specify `:additional_attributes` to be saved within the pg_search_documents table. For example, perhaps you are indexing a book model and an article model and wanted to include the author_id.
+
+First, we need to add `author_id` to the migration creating our pg_search_documents table.
+
+```ruby
+  create_table :pg_search_documents do |t|
+        t.text :content
+        t.integer :author_id
+        t.belongs_to :searchable, polymorphic: true, index: true
+```
+
+Then, we can send in this additional attribute in a lambda
+
+```ruby
+  multisearchable(
+    against: [:title, :body],
+    additional_attributes: -> (article) { { author_id: article.author_id } }
+  )
+```
+
+This allows much faster searches without joins later on by doing something like:
+`PgSearch.multisearch(params['search']).where(author_id: 2)`
+
+*NOTE: You must currently manually call `record.update_pg_search_document` for the additional attribute to be included in the pg_search_documents table*
+
 #### Multi-search associations
 
 Two associations are built automatically. On the original record, there is a
@@ -169,7 +209,7 @@ record, and on the PgSearch::Document record there is a belongs_to :searchable
 polymorphic association pointing back to the original record.
 
 ```ruby
-odyssey = EpicPoem.create!(:title => "Odyssey", :author => "Homer")
+odyssey = EpicPoem.create!(title: "Odyssey", author: "Homer")
 search_document = odyssey.pg_search_document #=> PgSearch::Document instance
 search_document.searchable #=> #<EpicPoem id: 1, title: "Odyssey", author: "Homer">
 ```
@@ -180,8 +220,8 @@ To fetch the PgSearch::Document entries for all of the records that match a
 given query, use PgSearch.multisearch.
 
 ```ruby
-odyssey = EpicPoem.create!(:title => "Odyssey", :author => "Homer")
-rose = Flower.create!(:color => "Red")
+odyssey = EpicPoem.create!(title: "Odyssey", author: "Homer")
+rose = Flower.create!(color: "Red")
 PgSearch.multisearch("Homer") #=> [#<PgSearch::Document searchable: odyssey>]
 PgSearch.multisearch("Red") #=> [#<PgSearch::Document searchable: rose>]
 ```
@@ -195,7 +235,7 @@ receive SQL requests when necessary.
 
 ```ruby
 PgSearch.multisearch("Bertha").limit(10)
-PgSearch.multisearch("Juggler").where(:searchable_type => "Occupation")
+PgSearch.multisearch("Juggler").where(searchable_type: "Occupation")
 PgSearch.multisearch("Alamo").page(3).per(30)
 PgSearch.multisearch("Diagonal").find_each do |document|
   puts document.searchable.updated_at
@@ -212,8 +252,8 @@ PgSearch.multisearch_options in an initializer:
 
 ```ruby
 PgSearch.multisearch_options = {
-  :using => [:tsearch, :trigram],
-  :ignoring => :accents
+  using: [:tsearch, :trigram],
+  ignoring: :accents
 }
 ```
 
@@ -234,7 +274,7 @@ To remove all of the documents for a given class, you can simply delete all of
 the PgSearch::Document records.
 
 ```ruby
-PgSearch::Document.delete_all(:searchable_type => "Animal")
+PgSearch::Document.delete_all(searchable_type: "Animal")
 ```
 
 To regenerate the documents for a given class, run:
@@ -270,7 +310,7 @@ the pg_search_documents table all at once. However, if you call any dynamic
 methods in :against, the following strategy will be used:
 
 ```ruby
-PgSearch::Document.delete_all(:searchable_type => "Ingredient")
+PgSearch::Document.delete_all(searchable_type: "Ingredient")
 Ingredient.find_each { |record| record.update_pg_search_document }
 ```
 
@@ -336,7 +376,7 @@ To search against a column, pass a symbol as the :against option.
 ```ruby
 class BlogPost < ActiveRecord::Base
   include PgSearch
-  pg_search_scope :search_by_title, :against => :title
+  pg_search_scope :search_by_title, against: :title
 end
 ```
 
@@ -344,8 +384,8 @@ We now have an ActiveRecord scope named search_by_title on our BlogPost model.
 It takes one parameter, a search query string.
 
 ```ruby
-BlogPost.create!(:title => "Recent Developments in the World of Pastrami")
-BlogPost.create!(:title => "Prosciutto and You: A Retrospective")
+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">]
 ```
 
@@ -356,15 +396,15 @@ Just pass an Array if you'd like to search more than one column.
 ```ruby
 class Person < ActiveRecord::Base
   include PgSearch
-  pg_search_scope :search_by_full_name, :against => [:first_name, :last_name]
+  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.
 
 ```ruby
-person_1 = Person.create!(:first_name => "Grant", :last_name => "Hill")
-person_2 = Person.create!(:first_name => "Hugh", :last_name => "Grant")
+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]
@@ -386,14 +426,14 @@ class Person < ActiveRecord::Base
   pg_search_scope :search_by_name, lambda { |name_part, query|
     raise ArgumentError unless [:first, :last].include?(name_part)
     {
-      :against => name_part,
-      :query => query
+      against: name_part,
+      query: query
     }
   }
 end
 
-person_1 = Person.create!(:first_name => "Grant", :last_name => "Hill")
-person_2 = Person.create!(:first_name => "Hugh", :last_name => "Grant")
+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]
@@ -423,11 +463,11 @@ class Salami < ActiveRecord::Base
   include PgSearch
 
   belongs_to :cracker
-  has_many :cheeses, :through => :cracker
+  has_many :cheeses, through: :cracker
 
-  pg_search_scope :tasty_search, :associated_against => {
-    :cheeses => [:kind, :brand],
-    :cracker => :kind
+  pg_search_scope :tasty_search, associated_against: {
+    cheeses: [:kind, :brand],
+    cracker: :kind
   }
 end
 
@@ -435,13 +475,13 @@ 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")
+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)
+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]
 ```
@@ -456,7 +496,7 @@ search techniques.
 ```ruby
 class Beer < ActiveRecord::Base
   include PgSearch
-  pg_search_scope :search_name, :against => :name, :using => [:tsearch, :trigram, :dmetaphone]
+  pg_search_scope :search_name, against: :name, using: [:tsearch, :trigram, :dmetaphone]
 end
 ```
 
@@ -482,10 +522,10 @@ subtitle, and finally the content.
 ```ruby
 class NewsArticle < ActiveRecord::Base
   include PgSearch
-  pg_search_scope :search_full_text, :against => {
-    :title => 'A',
-    :subtitle => 'B',
-    :content => 'C'
+  pg_search_scope :search_full_text, against: {
+    title: 'A',
+    subtitle: 'B',
+    content: 'C'
   }
 end
 ```
@@ -497,7 +537,7 @@ weight. If you omit the weight, a default will be used.
 ```ruby
 class NewsArticle < ActiveRecord::Base
   include PgSearch
-  pg_search_scope :search_full_text, :against => [
+  pg_search_scope :search_full_text, against: [
     [:title, 'A'],
     [:subtitle, 'B'],
     [:content, 'C']
@@ -506,9 +546,9 @@ end
 
 class NewsArticle < ActiveRecord::Base
   include PgSearch
-  pg_search_scope :search_full_text, :against => [
+  pg_search_scope :search_full_text, against: [
     [:title, 'A'],
-    {:subtitle => 'B'},
+    {subtitle: 'B'},
     :content
   ]
 end
@@ -525,15 +565,15 @@ shown in the following example.
 class Superhero < ActiveRecord::Base
   include PgSearch
   pg_search_scope :whose_name_starts_with,
-                  :against => :name,
-                  :using => {
-                    :tsearch => {:prefix => true}
+                  against: :name,
+                  using: {
+                    tsearch: { prefix: true }
                   }
 end
 
-batman = Superhero.create :name => 'Batman'
-batgirl = Superhero.create :name => 'Batgirl'
-robin = Superhero.create :name => 'Robin'
+batman = Superhero.create name: 'Batman'
+batgirl = Superhero.create name: 'Batgirl'
+robin = Superhero.create name: 'Robin'
 
 Superhero.whose_name_starts_with("Bat") # => [batman, batgirl]
 ```
@@ -554,16 +594,16 @@ term that you were trying to exclude.
 class Animal < ActiveRecord::Base
   include PgSearch
   pg_search_scope :with_name_matching,
-                  :against => :name,
-                  :using => {
-                    :tsearch => {:negation => true}
+                  against: :name,
+                  using: {
+                    tsearch: {negation: true}
                   }
 end
 
-one_fish = Animal.create(:name => "one fish")
-two_fish = Animal.create(:name => "two fish")
-red_fish = Animal.create(:name => "red fish")
-blue_fish = Animal.create(:name => "blue fish")
+one_fish = Animal.create(name: "one fish")
+two_fish = Animal.create(name: "two fish")
+red_fish = Animal.create(name: "red fish")
+blue_fish = Animal.create(name: "blue fish")
 
 Animal.with_name_matching("fish !red !blue") # => [one_fish, two_fish]
 ```
@@ -583,20 +623,20 @@ dictionary will be used.
 class BoringTweet < ActiveRecord::Base
   include PgSearch
   pg_search_scope :kinda_matching,
-                  :against => :text,
-                  :using => {
-                    :tsearch => {:dictionary => "english"}
+                  against: :text,
+                  using: {
+                    tsearch: {dictionary: "english"}
                   }
   pg_search_scope :literally_matching,
-                  :against => :text,
-                  :using => {
-                    :tsearch => {:dictionary => "simple"}
+                  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"
+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]
@@ -627,16 +667,16 @@ their numbers together.
 class BigLongDocument < ActiveRecord::Base
   include PgSearch
   pg_search_scope :regular_search,
-                  :against => :text
+                  against: :text
 
   pg_search_scope :short_search,
-                  :against => :text,
-                  :using => {
-                    :tsearch => {:normalization => 2}
+                  against: :text,
+                  using: {
+                    tsearch: {normalization: 2}
                   }
 
-long = BigLongDocument.create!(:text => "Four score and twenty years ago")
-short = BigLongDocument.create!(:text => "Four score")
+long = BigLongDocument.create!(text: "Four score and twenty years ago")
+short = BigLongDocument.create!(text: "Four score")
 
 BigLongDocument.regular_search("four score") #=> [long, short]
 BigLongDocument.short_search("four score") #=> [short, long]
@@ -651,18 +691,18 @@ models containing any word in the search terms.
 class Number < ActiveRecord::Base
   include PgSearch
   pg_search_scope :search_any_word,
-                  :against => :text,
-                  :using => {
-                    :tsearch => {:any_word => true}
+                  against: :text,
+                  using: {
+                    tsearch: {any_word: true}
                   }
 
   pg_search_scope :search_all_words,
-                  :against => :text
+                  against: :text
 end
 
-one = Number.create! :text => 'one'
-two = Number.create! :text => 'two'
-three = Number.create! :text => 'three'
+one = Number.create! text: 'one'
+two = Number.create! text: 'two'
+three = Number.create! text: 'three'
 
 Number.search_any_word('one two three') # => [one, two, three]
 Number.search_all_words('one two three') # => []
@@ -677,17 +717,17 @@ but will not include it in the query's WHERE condition.
 class Person < ActiveRecord::Base
   include PgSearch
   pg_search_scope :search,
-                  :against => :name,
-                  :using => {
-                    :tsearch => {:any_word => true}
-                    :dmetaphone => {:any_word => true, :sort_only => true}
+                  against: :name,
+                  using: {
+                    tsearch: {any_word: true}
+                    dmetaphone: {any_word: true, sort_only: true}
                   }
 end
 
-exact = Person.create!(:name => 'ash hines')
-one_exact_one_close = Person.create!(:name => 'ash heinz')
-one_exact = Person.create!(:name => 'ash smith')
-one_close = Person.create!(:name => 'leigh heinz')
+exact = Person.create!(name: 'ash hines')
+one_exact_one_close = Person.create!(name: 'ash heinz')
+one_exact = Person.create!(name: 'ash smith')
+one_close = Person.create!(name: 'leigh heinz')
 
 Person.search('ash hines') # => [exact, one_exact_one_close, one_exact]
 ```
@@ -706,8 +746,8 @@ class Person < ActiveRecord::Base
                   using: {
                     tsearch: {
                       highlight: {
-                        StartSel: '<start>',
-                        StopSel: '<stop>',
+                        StartSel: '<b>',
+                        StopSel: '</b>',
                         MaxWords: 123,
                         MinWords: 456,
                         ShortWord: 4,
@@ -756,14 +796,14 @@ The following example shows how to use :dmetaphone.
 class Word < ActiveRecord::Base
   include PgSearch
   pg_search_scope :that_sounds_like,
-                  :against => :spelling,
-                  :using => :dmetaphone
+                  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'
+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]
 ```
@@ -787,14 +827,14 @@ feature can be used.
 class Website < ActiveRecord::Base
   include PgSearch
   pg_search_scope :kinda_spelled_like,
-                  :against => :name,
-                  :using => :trigram
+                  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"
+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]
 ```
@@ -813,23 +853,23 @@ class Vegetable < ActiveRecord::Base
   include PgSearch
 
   pg_search_scope :strictly_spelled_like,
-                  :against => :name,
-                  :using => {
-                    :trigram => {
-                      :threshold => 0.5
+                  against: :name,
+                  using: {
+                    trigram: {
+                      threshold: 0.5
                     }
                   }
 
   pg_search_scope :roughly_spelled_like,
-                  :against => :name,
-                  :using => {
-                    :trigram => {
-                      :threshold => 0.1
+                  against: :name,
+                  using: {
+                    trigram: {
+                      threshold: 0.1
                     }
                   }
 end
 
-cauliflower = Vegetable.create! :name => "cauliflower"
+cauliflower = Vegetable.create! name: "cauliflower"
 
 Vegetable.roughly_spelled_like("couliflower") # => [cauliflower]
 Vegetable.strictly_spelled_like("couliflower") # => [cauliflower]
@@ -851,11 +891,11 @@ class Image < ActiveRecord::Base
   include PgSearch
 
   pg_search_scope :combined_search,
-                  :against => [:file_name, :short_description, :long_description]
-                  :using => {
-                    :tsearch => { :dictionary  => 'english' },
-                    :trigram => {
-                      :only => [:file_name, :short_description]
+                  against: [:file_name, :short_description, :long_description]
+                  using: {
+                    tsearch: { dictionary: 'english' },
+                    trigram: {
+                      only: [:file_name, :short_description]
                     }
                   }
 
@@ -885,13 +925,13 @@ must be installed before this feature can be used.
 class SpanishQuestion < ActiveRecord::Base
   include PgSearch
   pg_search_scope :gringo_search,
-                  :against => :word,
-                  :ignoring => :accents
+                  against: :word,
+                  ignoring: :accents
 end
 
-what = SpanishQuestion.create(:word => "Qué")
-how_many = SpanishQuestion.create(:word => "Cuánto")
-how = SpanishQuestion.create(:word => "Cómo")
+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]
@@ -928,8 +968,8 @@ To use this functionality you'll need to do a few things:
 
     ```ruby
     pg_search_scope :fast_content_search,
-                    :against => :content,
-                    :using => {
+                    against: :content,
+                    using: {
                       dmetaphone: {
                         tsvector_column: 'tsvector_content_dmetaphone'
                       },
@@ -940,13 +980,6 @@ To use this functionality you'll need to do a few things:
                       trigram: {} # trigram does not use tsvectors
                     }
     ```
-*   You cannot dump a `tsvector` column to `schema.rb`. Instead, you need to switch to using the native PostgreSQL SQL format schema dump.
-    In your `config/application.rb` you should set
-
-        config.active_record.schema_format = :sql
-        
-    Read more about it here: http://guides.rubyonrails.org/migrations.html#types-of-schema-dumps
-
 
 Please note that the :against column is only used when the tsvector_column is
 not present for the search type.
@@ -957,26 +990,26 @@ It's possible to search against more than one tsvector at a time. This could be
 
 ```ruby
 pg_search_scope :search_title,
-                :against => :title,
-                :using => {
-                  :tsearch => {
-                    :tsvector_column => "title_tsvector"
+                against: :title,
+                using: {
+                  tsearch: {
+                    tsvector_column: "title_tsvector"
                   }
                 }
 
 pg_search_scope :search_body,
-                :against => :body,
-                :using => {
-                  :tsearch => {
-                    :tsvector_column => "body_tsvector"
+                against: :body,
+                using: {
+                  tsearch: {
+                    tsvector_column: "body_tsvector"
                   }
                 }
 
 pg_search_scope :search_title_and_body,
-                :against => [:title, :body],
-                :using => {
-                  :tsearch => {
-                    :tsvector_column => ["title_tsvector", "body_tsvector"]
+                against: [:title, :body],
+                using: {
+                  tsearch: {
+                    tsvector_column: ["title_tsvector", "body_tsvector"]
                   }
                 }
 ```
@@ -991,9 +1024,9 @@ can pass a :ranked_by option to pg_search_scope.
 
 ```ruby
 pg_search_scope :search_by_tsearch_but_rank_by_trigram,
-                :against => :title,
-                :using => [:tsearch],
-                :ranked_by => ":trigram"
+                against: :title,
+                using: [:tsearch],
+                ranked_by: ":trigram"
 ```
 
 Note that :ranked_by using a String to represent the ranking expression. This
@@ -1003,10 +1036,10 @@ expressions.
 
 ```ruby
 # Weighted ranking to balance multiple approaches
-:ranked_by => ":dmetaphone + (0.25 * :trigram)"
+ranked_by: ":dmetaphone + (0.25 * :trigram)"
 
 # A more complex example, where books.num_pages is an integer column in the table itself
-:ranked_by => "(books.num_pages * :trigram) + (:tsearch / 2.0)"
+ranked_by: "(books.num_pages * :trigram) + (:tsearch / 2.0)"
 ```
 
 #### :order_within_rank (Breaking ties)
@@ -1038,8 +1071,8 @@ descending by updated_at, to rank the most recently updated records first.
 
 ```ruby
 pg_search_scope :search_and_break_ties_by_latest_update,
-                :against => [:title, :content],
-                :order_within_rank => "blog_posts.updated_at DESC"
+                against: [:title, :content],
+                order_within_rank: "blog_posts.updated_at DESC"
 ```
 
 #### PgSearch#pg_search_rank (Reading a record's rank as a Float)