pg_search 2.1.4 → 2.1.5

data/spec/integration/pagination_spec.rb

@@ -11,7 +11,7 @@ describe "pagination" do
 
       model do
         include PgSearch
-        pg_search_scope :search_name, :against => :name
+        pg_search_scope :search_name, against: :name
 
         def self.page(page_number)
           offset = (page_number - 1) * 2
@@ -21,18 +21,18 @@ describe "pagination" do
     end
 
     it "is chainable before a search scope" do
-      better = PaginatedModel.create!(:name => "foo foo bar")
-      best = PaginatedModel.create!(:name => "foo foo foo")
-      good = PaginatedModel.create!(:name => "foo bar bar")
+      better = PaginatedModel.create!(name: "foo foo bar")
+      best = PaginatedModel.create!(name: "foo foo foo")
+      good = PaginatedModel.create!(name: "foo bar bar")
 
       expect(PaginatedModel.page(1).search_name("foo")).to eq([best, better])
       expect(PaginatedModel.page(2).search_name("foo")).to eq([good])
     end
 
     it "is chainable after a search scope" do
-      better = PaginatedModel.create!(:name => "foo foo bar")
-      best = PaginatedModel.create!(:name => "foo foo foo")
-      good = PaginatedModel.create!(:name => "foo bar bar")
+      better = PaginatedModel.create!(name: "foo foo bar")
+      best = PaginatedModel.create!(name: "foo foo foo")
+      good = PaginatedModel.create!(name: "foo bar bar")
 
       expect(PaginatedModel.search_name("foo").page(1)).to eq([best, better])
       expect(PaginatedModel.search_name("foo").page(2)).to eq([good])

data/spec/integration/pg_search_spec.rb

@@ -30,7 +30,7 @@ describe "an Active Record model which includes PgSearch" do
 
   describe ".pg_search_scope" do
     it "builds a chainable scope" do
-      ModelWithPgSearch.pg_search_scope "matching_query", :against => []
+      ModelWithPgSearch.pg_search_scope "matching_query", against: []
       scope = ModelWithPgSearch.where("1 = 1").matching_query("foo").where("1 = 1")
       expect(scope).to be_an ActiveRecord::Relation
     end
@@ -40,13 +40,13 @@ describe "an Active Record model which includes PgSearch" do
         ModelWithPgSearch.pg_search_scope :search_title_or_content,
           lambda { |query, pick_content|
             {
-              :query => query.gsub("-remove-", ""),
-              :against => pick_content ? :content : :title
+              query: query.gsub("-remove-", ""),
+              against: pick_content ? :content : :title
             }
           }
 
-        included = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
-        excluded = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
+        included = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
+        excluded = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
 
         expect(ModelWithPgSearch.search_title_or_content('fo-remove-o', false)).to eq([included])
         expect(ModelWithPgSearch.search_title_or_content('b-remove-ar', true)).to eq([included])
@@ -56,8 +56,8 @@ describe "an Active Record model which includes PgSearch" do
     context "when an unknown option is passed in" do
       it "raises an exception when invoked" do
         ModelWithPgSearch.pg_search_scope :with_unknown_option,
-          :against => :content,
-          :foo => :bar
+          against: :content,
+          foo: :bar
 
         expect {
           ModelWithPgSearch.with_unknown_option("foo")
@@ -67,7 +67,7 @@ describe "an Active Record model which includes PgSearch" do
       context "dynamically" do
         it "raises an exception when invoked" do
           ModelWithPgSearch.pg_search_scope :with_unknown_option,
-            ->(*) { { :against => :content, :foo => :bar } }
+            ->(*) { { against: :content, foo: :bar } }
 
           expect {
             ModelWithPgSearch.with_unknown_option("foo")
@@ -79,8 +79,8 @@ describe "an Active Record model which includes PgSearch" do
     context "when an unknown :using is passed" do
       it "raises an exception when invoked" do
         ModelWithPgSearch.pg_search_scope :with_unknown_using,
-          :against => :content,
-          :using => :foo
+          against: :content,
+          using: :foo
 
         expect {
           ModelWithPgSearch.with_unknown_using("foo")
@@ -90,7 +90,7 @@ describe "an Active Record model which includes PgSearch" do
       context "dynamically" do
         it "raises an exception when invoked" do
           ModelWithPgSearch.pg_search_scope :with_unknown_using,
-            ->(*) { { :against => :content, :using => :foo } }
+            ->(*) { { against: :content, using: :foo } }
 
           expect {
             ModelWithPgSearch.with_unknown_using("foo")
@@ -102,8 +102,8 @@ describe "an Active Record model which includes PgSearch" do
     context "when an unknown :ignoring is passed" do
       it "raises an exception when invoked" do
         ModelWithPgSearch.pg_search_scope :with_unknown_ignoring,
-          :against => :content,
-          :ignoring => :foo
+          against: :content,
+          ignoring: :foo
 
         expect {
           ModelWithPgSearch.with_unknown_ignoring("foo")
@@ -113,7 +113,7 @@ describe "an Active Record model which includes PgSearch" do
       context "dynamically" do
         it "raises an exception when invoked" do
           ModelWithPgSearch.pg_search_scope :with_unknown_ignoring,
-            ->(*) { { :against => :content, :ignoring => :foo } }
+            ->(*) { { against: :content, ignoring: :foo } }
 
           expect {
             ModelWithPgSearch.with_unknown_ignoring("foo")
@@ -146,7 +146,7 @@ describe "an Active Record model which includes PgSearch" do
   describe "a search scope" do
     context "against a single column" do
       before do
-        ModelWithPgSearch.pg_search_scope :search_content, :against => :content
+        ModelWithPgSearch.pg_search_scope :search_content, against: :content
       end
 
       context "when chained after a select() scope" do
@@ -288,15 +288,15 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns an empty array when a blank query is passed in" do
-        ModelWithPgSearch.create!(:content => 'foo')
+        ModelWithPgSearch.create!(content: 'foo')
 
         results = ModelWithPgSearch.search_content('')
         expect(results).to eq([])
       end
 
       it "returns rows where the column contains the term in the query" do
-        included = ModelWithPgSearch.create!(:content => 'foo')
-        excluded = ModelWithPgSearch.create!(:content => 'bar')
+        included = ModelWithPgSearch.create!(content: 'foo')
+        excluded = ModelWithPgSearch.create!(content: 'bar')
 
         results = ModelWithPgSearch.search_content('foo')
         expect(results).to include(included)
@@ -304,24 +304,24 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns the correct count" do
-        ModelWithPgSearch.create!(:content => 'foo')
-        ModelWithPgSearch.create!(:content => 'bar')
+        ModelWithPgSearch.create!(content: 'foo')
+        ModelWithPgSearch.create!(content: 'bar')
 
         results = ModelWithPgSearch.search_content('foo')
         expect(results.count).to eq 1
       end
 
       it "returns the correct count(:all)" do
-        ModelWithPgSearch.create!(:content => 'foo')
-        ModelWithPgSearch.create!(:content => 'bar')
+        ModelWithPgSearch.create!(content: 'foo')
+        ModelWithPgSearch.create!(content: 'bar')
 
         results = ModelWithPgSearch.search_content('foo')
         expect(results.count(:all)).to eq 1
       end
 
       it "supports #select" do
-        record = ModelWithPgSearch.create!(:content => 'foo')
-        other_record = ModelWithPgSearch.create!(:content => 'bar')
+        record = ModelWithPgSearch.create!(content: 'foo')
+        other_record = ModelWithPgSearch.create!(content: 'bar')
 
         records_with_only_id = ModelWithPgSearch.search_content('foo').select('id')
         expect(records_with_only_id.length).to eq 1
@@ -332,16 +332,16 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "supports #pluck" do
-        record = ModelWithPgSearch.create!(:content => 'foo')
-        other_record = ModelWithPgSearch.create!(:content => 'bar')
+        record = ModelWithPgSearch.create!(content: 'foo')
+        other_record = ModelWithPgSearch.create!(content: 'bar')
 
         ids = ModelWithPgSearch.search_content('foo').pluck('id')
         expect(ids).to eq [record.id]
       end
 
       it "supports adding where clauses using the pg_search.rank" do
-        once = ModelWithPgSearch.create!(:content => 'foo bar')
-        twice = ModelWithPgSearch.create!(:content => 'foo foo')
+        once = ModelWithPgSearch.create!(content: 'foo bar')
+        twice = ModelWithPgSearch.create!(content: 'foo foo')
 
         records = ModelWithPgSearch.search_content('foo')
                                    .where("#{PgSearch::Configuration.alias(ModelWithPgSearch.table_name)}.rank > 0.07")
@@ -350,9 +350,9 @@ describe "an Active Record model which includes PgSearch" do
       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')
+        included = [ModelWithPgSearch.create!(content: 'foo bar'),
+                    ModelWithPgSearch.create!(content: 'bar foo')]
+        excluded = ModelWithPgSearch.create!(content: 'foo')
 
         results = ModelWithPgSearch.search_content('foo bar')
         expect(results).to match_array(included)
@@ -360,8 +360,8 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns rows that match the query but not its case" do
-        included = [ModelWithPgSearch.create!(:content => "foo"),
-                    ModelWithPgSearch.create!(:content => "FOO")]
+        included = [ModelWithPgSearch.create!(content: "foo"),
+                    ModelWithPgSearch.create!(content: "FOO")]
 
         results = ModelWithPgSearch.search_content("Foo")
         expect(results).to match_array(included)
@@ -371,8 +371,8 @@ describe "an Active Record model which includes PgSearch" 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")
+        included = ModelWithPgSearch.create!(content: "abcd\303\251f")
+        excluded = ModelWithPgSearch.create!(content: "\303\241bcdef")
 
         results = ModelWithPgSearch.search_content("abcd\303\251f")
         expect(results).to eq([included])
@@ -380,8 +380,8 @@ describe "an Active Record model which includes PgSearch" do
       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')
+        included = ModelWithPgSearch.create!(content: 'pre')
+        excluded = ModelWithPgSearch.create!(content: 'prefix')
 
         results = ModelWithPgSearch.search_content("pre")
         expect(results).to eq([included])
@@ -389,17 +389,17 @@ describe "an Active Record model which includes PgSearch" do
       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")]
+        included = ModelWithPgSearch.create!(content: "jumped")
+        excluded = [ModelWithPgSearch.create!(content: "jump"),
+                    ModelWithPgSearch.create!(content: "jumping")]
 
         results = ModelWithPgSearch.search_content("jumped")
         expect(results).to eq([included])
       end
 
       it "returns rows that match sorted by rank" do
-        loser = ModelWithPgSearch.create!(:content => 'foo')
-        winner = ModelWithPgSearch.create!(:content => 'foo foo')
+        loser = ModelWithPgSearch.create!(content: 'foo')
+        winner = ModelWithPgSearch.create!(content: 'foo foo')
 
         results = ModelWithPgSearch.search_content("foo").with_pg_search_rank
         expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
@@ -409,8 +409,8 @@ describe "an Active Record model which includes PgSearch" do
       it 'allows pg_search_rank along with a join' do
         parent_1 = ParentModel.create!(id: 98)
         parent_2 = ParentModel.create!(id: 99)
-        loser = ModelWithPgSearch.create!(:content => 'foo', parent_model: parent_2)
-        winner = ModelWithPgSearch.create!(:content => 'foo foo', parent_model: parent_1)
+        loser = ModelWithPgSearch.create!(content: 'foo', parent_model: parent_2)
+        winner = ModelWithPgSearch.create!(content: 'foo foo', parent_model: parent_1)
 
         results = ModelWithPgSearch.joins(:parent_model).merge(ParentModel.active).search_content("foo").with_pg_search_rank
         expect(results.map(&:id)).to eq [winner.id, loser.id]
@@ -419,8 +419,8 @@ describe "an Active Record model which includes PgSearch" do
       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)
+        sorted_results = [ModelWithPgSearch.create!(content: 'foo'),
+                          ModelWithPgSearch.create!(content: 'foo')].sort_by(&:id)
 
         results = ModelWithPgSearch.search_content("foo")
         expect(results).to eq(sorted_results)
@@ -428,13 +428,13 @@ describe "an Active Record model which includes PgSearch" do
 
       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')
+          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')
+          ModelWithPgSearch.create!(content: 'foo'),
+          ModelWithPgSearch.create!(content: 'foo baz')
         ]
 
         results = ModelWithPgSearch.search_content('foo bar')
@@ -443,15 +443,15 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it "returns rows that match a query with characters that are invalid in a tsquery expression" do
-        included = ModelWithPgSearch.create!(:content => "(:Foo.) Bar?, \\")
+        included = ModelWithPgSearch.create!(content: "(:Foo.) Bar?, \\")
 
         results = ModelWithPgSearch.search_content("foo :bar .,?() \\")
         expect(results).to eq([included])
       end
 
       it "accepts non-string queries and calls #to_s on them" do
-        foo = ModelWithPgSearch.create!(:content => "foo")
-        not_a_string = double(:to_s => "foo")
+        foo = ModelWithPgSearch.create!(content: "foo")
+        not_a_string = double(to_s: "foo")
         expect(ModelWithPgSearch.search_content(not_a_string)).to eq([foo])
       end
 
@@ -467,7 +467,7 @@ describe "an Active Record model which includes PgSearch" do
             # WARNING: searching timestamps is not something PostgreSQL
             # full-text search is good at. Use at your own risk.
             pg_search_scope :search_timestamps,
-              :against => %i[created_at updated_at]
+              against: %i[created_at updated_at]
           end
         end
 
@@ -483,17 +483,17 @@ describe "an Active Record model which includes PgSearch" do
 
     context "against multiple columns" do
       before do
-        ModelWithPgSearch.pg_search_scope :search_title_and_content, :against => %i[title content]
+        ModelWithPgSearch.pg_search_scope :search_title_and_content, against: %i[title content]
       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')
+          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')
+          ModelWithPgSearch.create!(title: 'foo', content: 'foo'),
+          ModelWithPgSearch.create!(title: 'bar', content: 'bar')
         ]
 
         results = ModelWithPgSearch.search_title_and_content('foo bar')
@@ -505,8 +505,8 @@ describe "an Active Record model which includes PgSearch" do
       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')
+        in_title = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
+        in_content = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
 
         results = ModelWithPgSearch.search_title_and_content('foo')
         expect(results).to match_array([in_title, in_content])
@@ -514,7 +514,7 @@ describe "an Active Record model which includes PgSearch" do
 
       # 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)
+        included = ModelWithPgSearch.create!(title: 'foo', content: nil)
         results  = ModelWithPgSearch.search_title_and_content('foo')
         expect(results).to eq([included])
       end
@@ -522,31 +522,31 @@ describe "an Active Record model which includes PgSearch" do
 
     context "using trigram" do
       before do
-        ModelWithPgSearch.pg_search_scope :with_trigrams, :against => %i[title content], :using => :trigram
+        ModelWithPgSearch.pg_search_scope :with_trigrams, against: %i[title content], using: :trigram
       end
 
       it "returns rows where one searchable column and the query share enough trigrams" do
-        included = ModelWithPgSearch.create!(:title => 'abcdefghijkl', :content => nil)
+        included = ModelWithPgSearch.create!(title: 'abcdefghijkl', content: nil)
         results = ModelWithPgSearch.with_trigrams('cdefhijkl')
         expect(results).to eq([included])
       end
 
       it "returns rows where multiple searchable columns and the query share enough trigrams" do
-        included = ModelWithPgSearch.create!(:title => 'abcdef', :content => 'ghijkl')
+        included = ModelWithPgSearch.create!(title: 'abcdef', content: 'ghijkl')
         results = ModelWithPgSearch.with_trigrams('cdefhijkl')
         expect(results).to eq([included])
       end
 
       context "when a threshold is specified" do
         before do
-          ModelWithPgSearch.pg_search_scope :with_strict_trigrams, :against => %i[title content], :using => { trigram: { threshold: 0.5 } }
-          ModelWithPgSearch.pg_search_scope :with_permissive_trigrams, :against => %i[title content], :using => { trigram: { threshold: 0.1 } }
+          ModelWithPgSearch.pg_search_scope :with_strict_trigrams, against: %i[title content], using: { trigram: { threshold: 0.5 } }
+          ModelWithPgSearch.pg_search_scope :with_permissive_trigrams, against: %i[title content], using: { trigram: { threshold: 0.1 } }
         end
 
         it "uses the threshold in the trigram expression" do
-          low_similarity = ModelWithPgSearch.create!(:title => "a")
-          medium_similarity = ModelWithPgSearch.create!(:title => "abc")
-          high_similarity = ModelWithPgSearch.create!(:title => "abcdefghijkl")
+          low_similarity = ModelWithPgSearch.create!(title: "a")
+          medium_similarity = ModelWithPgSearch.create!(title: "abc")
+          high_similarity = ModelWithPgSearch.create!(title: "abcdefghijkl")
 
           results = ModelWithPgSearch.with_strict_trigrams("abcdefg")
           expect(results).to include(high_similarity)
@@ -565,16 +565,16 @@ describe "an Active Record model which includes PgSearch" do
     context "using tsearch" do
       before do
         ModelWithPgSearch.pg_search_scope :search_title_with_prefixes,
-          :against => :title,
-          :using => {
-            :tsearch => { :prefix => true }
+          against: :title,
+          using: {
+            tsearch: { prefix: true }
           }
       end
 
-      context "with :prefix => true" do
+      context "with prefix: true" do
         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')
+          included = ModelWithPgSearch.create!(title: 'prefix')
+          excluded = ModelWithPgSearch.create!(title: 'postfix')
 
           results = ModelWithPgSearch.search_title_with_prefixes("pre")
           expect(results).to eq([included])
@@ -582,8 +582,8 @@ describe "an Active Record model which includes PgSearch" do
         end
 
         it "returns rows that match the query when the query has a hyphen" do
-          included = ModelWithPgSearch.create!(:title => 'foo-bar')
-          excluded = ModelWithPgSearch.create!(:title => 'foo bar')
+          included = ModelWithPgSearch.create!(title: 'foo-bar')
+          excluded = ModelWithPgSearch.create!(title: 'foo bar')
 
           results = ModelWithPgSearch.search_title_with_prefixes("foo-bar")
           expect(results).to include(included)
@@ -594,16 +594,16 @@ describe "an Active Record model which includes PgSearch" do
       context "with the english dictionary" do
         before do
           ModelWithPgSearch.pg_search_scope :search_content_with_english,
-            :against => :content,
-            :using => {
-              :tsearch => { :dictionary => :english }
+            against: :content,
+            using: {
+              tsearch: { dictionary: :english }
             }
         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")]
+          included = [ModelWithPgSearch.create!(content: "jump"),
+                      ModelWithPgSearch.create!(content: "jumped"),
+                      ModelWithPgSearch.create!(content: "jumping")]
 
           results = ModelWithPgSearch.search_content_with_english("jump")
           expect(results).to match_array(included)
@@ -613,14 +613,14 @@ describe "an Active Record model which includes PgSearch" do
       describe "highlighting" do
         before do
           ["Strip Down", "Down", "Down and Out", "Won't Let You Down"].each do |name|
-            ModelWithPgSearch.create! :content => name
+            ModelWithPgSearch.create! content: name
           end
         end
 
         context "with highlight turned on" do
           before do
             ModelWithPgSearch.pg_search_scope :search_content,
-              :against => :content
+              against: :content
           end
 
           it "adds a #pg_search_highlight method to each returned model record" do
@@ -638,19 +638,19 @@ describe "an Active Record model which includes PgSearch" do
 
         context "with custom highlighting options" do
           before do
-            ModelWithPgSearch.create! :content => "#{'text ' * 2}Let #{'text ' * 2}Let #{'text ' * 2}"
+            ModelWithPgSearch.create! content: "#{'text ' * 2}Let #{'text ' * 2}Let #{'text ' * 2}"
 
             ModelWithPgSearch.pg_search_scope :search_content,
-              :against => :content,
-              :using => {
-                :tsearch => {
-                  :highlight => {
-                    :StartSel => '<mark class="highlight">',
-                    :StopSel => '</mark>',
-                    :FragmentDelimiter => '<delim class="my_delim">',
-                    :MaxFragments => 2,
-                    :MaxWords => 2,
-                    :MinWords => 1
+              against: :content,
+              using: {
+                tsearch: {
+                  highlight: {
+                    StartSel: '<mark class="highlight">',
+                    StopSel: '</mark>',
+                    FragmentDelimiter: '<delim class="my_delim">',
+                    MaxFragments: 2,
+                    MaxWords: 2,
+                    MinWords: 1
                   }
                 }
               }
@@ -667,12 +667,12 @@ describe "an Active Record model which includes PgSearch" do
       describe "ranking" do
         before do
           ["Strip Down", "Down", "Down and Out", "Won't Let You Down"].each do |name|
-            ModelWithPgSearch.create! :content => name
+            ModelWithPgSearch.create! content: name
           end
         end
 
         it "adds a #pg_search_rank method to each returned model record" do
-          ModelWithPgSearch.pg_search_scope :search_content, :against => :content
+          ModelWithPgSearch.pg_search_scope :search_content, against: :content
 
           result = ModelWithPgSearch.search_content("Strip Down").with_pg_search_rank.first
 
@@ -682,9 +682,9 @@ describe "an Active Record model which includes PgSearch" do
         context "with a normalization specified" do
           before do
             ModelWithPgSearch.pg_search_scope :search_content_with_normalization,
-              :against => :content,
-              :using => {
-                :tsearch => { :normalization => 2 }
+              against: :content,
+              using: {
+                tsearch: { normalization: 2 }
               }
           end
 
@@ -699,8 +699,8 @@ describe "an Active Record model which includes PgSearch" do
         context "with no normalization" do
           before do
             ModelWithPgSearch.pg_search_scope :search_content_without_normalization,
-              :against => :content,
-              :using => :tsearch
+              against: :content,
+              using: :tsearch
           end
 
           it "ranks the results equally" do
@@ -715,12 +715,12 @@ describe "an Active Record model which includes PgSearch" do
       context "against columns ranked with arrays" do
         before do
           ModelWithPgSearch.pg_search_scope :search_weighted_by_array_of_arrays,
-            :against => [[:content, 'B'], [:title, 'A']]
+            against: [[:content, 'B'], [:title, 'A']]
         end
 
         it "returns results sorted by weighted rank" do
-          loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
+          loser = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
+          winner = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
 
           results = ModelWithPgSearch.search_weighted_by_array_of_arrays('foo').with_pg_search_rank
           expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
@@ -731,12 +731,12 @@ describe "an Active Record model which includes PgSearch" do
       context "against columns ranked with a hash" do
         before do
           ModelWithPgSearch.pg_search_scope :search_weighted_by_hash,
-            :against => { :content => 'B', :title => 'A' }
+            against: { content: 'B', title: 'A' }
         end
 
         it "returns results sorted by weighted rank" do
-          loser = ModelWithPgSearch.create!(:title => 'bar', :content => 'foo')
-          winner = ModelWithPgSearch.create!(:title => 'foo', :content => 'bar')
+          loser = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
+          winner = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
 
           results = ModelWithPgSearch.search_weighted_by_hash('foo').with_pg_search_rank
           expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
@@ -747,12 +747,12 @@ describe "an Active Record model which includes PgSearch" do
       context "against columns of which only some are ranked" do
         before do
           ModelWithPgSearch.pg_search_scope :search_weighted,
-            :against => [:content, [:title, 'A']]
+            against: [:content, [:title, 'A']]
         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')
+          loser = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
+          winner = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
 
           results = ModelWithPgSearch.search_weighted('foo').with_pg_search_rank
           expect(results[0].pg_search_rank).to be > results[1].pg_search_rank
@@ -763,17 +763,17 @@ describe "an Active Record model which includes PgSearch" do
       context "searching any_word option" do
         before do
           ModelWithPgSearch.pg_search_scope :search_title_with_any_word,
-            :against => :title,
-            :using => {
-              :tsearch => { :any_word => true }
+            against: :title,
+            using: {
+              tsearch: { any_word: true }
             }
 
           ModelWithPgSearch.pg_search_scope :search_title_with_all_words,
-            :against => :title
+            against: :title
         end
 
         it "returns all results containing any word in their title" do
-          numbers = %w[one two three four].map { |number| ModelWithPgSearch.create!(:title => number) }
+          numbers = %w[one two three four].map { |number| ModelWithPgSearch.create!(title: number) }
 
           results = ModelWithPgSearch.search_title_with_any_word("one two three four")
 
@@ -788,21 +788,21 @@ describe "an Active Record model which includes PgSearch" do
       context "with :negation" do
         before do
           ModelWithPgSearch.pg_search_scope :search_with_negation,
-            :against => :title,
-            :using => {
-              :tsearch => { :negation => true }
+            against: :title,
+            using: {
+              tsearch: { negation: true }
             }
         end
 
         it "doesn't return results that contain terms prepended with '!'" do
           included = [
-            ModelWithPgSearch.create!(:title => "one fish"),
-            ModelWithPgSearch.create!(:title => "two fish")
+            ModelWithPgSearch.create!(title: "one fish"),
+            ModelWithPgSearch.create!(title: "two fish")
           ]
 
           excluded = [
-            ModelWithPgSearch.create!(:title => "red fish"),
-            ModelWithPgSearch.create!(:title => "blue fish")
+            ModelWithPgSearch.create!(title: "red fish"),
+            ModelWithPgSearch.create!(title: "blue fish")
           ]
 
           results = ModelWithPgSearch.search_with_negation("fish !red !blue")
@@ -815,19 +815,19 @@ describe "an Active Record model which includes PgSearch" do
       context "without :negation" do
         before do
           ModelWithPgSearch.pg_search_scope :search_without_negation,
-            :against => :title,
-            :using => {
-              :tsearch => {}
+            against: :title,
+            using: {
+              tsearch: {}
             }
         end
 
         it "return results that contain terms prepended with '!'" do
           included = [
-            ModelWithPgSearch.create!(:title => "!bang")
+            ModelWithPgSearch.create!(title: "!bang")
           ]
 
           excluded = [
-            ModelWithPgSearch.create!(:title => "?question")
+            ModelWithPgSearch.create!(title: "?question")
           ]
 
           results = ModelWithPgSearch.search_without_negation("!bang")
@@ -841,27 +841,27 @@ describe "an Active Record model which includes PgSearch" do
     context "using dmetaphone" do
       before do
         ModelWithPgSearch.pg_search_scope :with_dmetaphones,
-          :against => %i[title content],
-          :using => :dmetaphone
+          against: %i[title content],
+          using: :dmetaphone
       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)
+        included = ModelWithPgSearch.create!(title: 'Geoff', content: nil)
+        excluded = ModelWithPgSearch.create!(title: 'Bob', content: nil)
         results = ModelWithPgSearch.with_dmetaphones('Jeff')
         expect(results).to eq([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')
+        included = ModelWithPgSearch.create!(title: 'Geoff', content: 'George')
+        excluded = ModelWithPgSearch.create!(title: 'Bob', content: 'Jones')
         results = ModelWithPgSearch.with_dmetaphones('Jeff Jorge')
         expect(results).to eq([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)
+        included = ModelWithPgSearch.create!(title: 'White', content: nil)
+        excluded = ModelWithPgSearch.create!(title: 'Black', content: nil)
         results = ModelWithPgSearch.with_dmetaphones('Wight')
         expect(results).to eq([included])
       end
@@ -869,8 +869,8 @@ describe "an Active Record model which includes PgSearch" do
       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)
+        included = ModelWithPgSearch.create!(title: 'White', content: nil)
+        excluded = ModelWithPgSearch.create!(title: 'Black', content: nil)
 
         results = ModelWithPgSearch.with_dmetaphones('Wight W')
         expect(results).to eq([included])
@@ -880,39 +880,39 @@ describe "an Active Record model which includes PgSearch" do
     context "using multiple features" do
       before do
         ModelWithPgSearch.pg_search_scope :with_tsearch,
-          :against => :title,
-          :using => [
-            [:tsearch, { :dictionary => 'english' }]
+          against: :title,
+          using: [
+            [:tsearch, { dictionary: 'english' }]
           ]
 
         ModelWithPgSearch.pg_search_scope :with_trigram,
-          :against => :title,
-          :using => :trigram
+          against: :title,
+          using: :trigram
 
         ModelWithPgSearch.pg_search_scope :with_trigram_and_ignoring_accents,
-          :against => :title,
-          :ignoring => :accents,
-          :using => :trigram
+          against: :title,
+          ignoring: :accents,
+          using: :trigram
 
         ModelWithPgSearch.pg_search_scope :with_tsearch_and_trigram,
-          :against => :title,
-          :using => [
-            [:tsearch, { :dictionary => 'english' }],
+          against: :title,
+          using: [
+            [:tsearch, { dictionary: 'english' }],
             :trigram
           ]
 
         ModelWithPgSearch.pg_search_scope :complex_search,
-          :against => %i[content title],
-          :ignoring => :accents,
-          :using => {
-            :tsearch => { :dictionary => 'english' },
-            :dmetaphone => {},
-            :trigram => {}
+          against: %i[content title],
+          ignoring: :accents,
+          using: {
+            tsearch: { dictionary: 'english' },
+            dmetaphone: {},
+            trigram: {}
           }
       end
 
       it "returns rows that match using any of the features" do
-        record = ModelWithPgSearch.create!(:title => "tiling is grouty")
+        record = ModelWithPgSearch.create!(title: "tiling is grouty")
 
         # matches trigram only
         trigram_query = "ling is grouty"
@@ -951,21 +951,21 @@ describe "an Active Record model which includes PgSearch" do
 
       context "with feature-specific configuration" do
         before do
-          @tsearch_config = tsearch_config = { :dictionary => 'english' }
-          @trigram_config = trigram_config = { :foo => 'bar' }
+          @tsearch_config = tsearch_config = { dictionary: 'english' }
+          @trigram_config = trigram_config = { foo: 'bar' }
 
           ModelWithPgSearch.pg_search_scope :with_tsearch_and_trigram_using_hash,
-            :against => :title,
-            :using => {
-              :tsearch => tsearch_config,
-              :trigram => trigram_config
+            against: :title,
+            using: {
+              tsearch: tsearch_config,
+              trigram: trigram_config
             }
         end
 
         it "should pass the custom configuration down to the specified feature" do
           stub_feature = double(
-            :conditions => Arel::Nodes::Grouping.new(Arel.sql("1 = 1")),
-            :rank => Arel::Nodes::Grouping.new(Arel.sql("1.0"))
+            conditions: Arel::Nodes::Grouping.new(Arel.sql("1 = 1")),
+            rank: Arel::Nodes::Grouping.new(Arel.sql("1.0"))
           )
 
           expect(PgSearch::Features::TSearch).to receive(:new).with(anything, @tsearch_config, anything, anything, anything).at_least(:once).and_return(stub_feature)
@@ -1013,11 +1013,11 @@ describe "an Active Record model which includes PgSearch" do
         unexpected.comments.create(body: 'commentwo')
 
         Post.pg_search_scope :search_by_content_with_tsvector,
-          :associated_against => { comments: [:body] },
-          :using => {
-            :tsearch => {
-              :tsvector_column => 'content_tsvector',
-              :dictionary => 'english'
+          associated_against: { comments: [:body] },
+          using: {
+            tsearch: {
+              tsvector_column: 'content_tsvector',
+              dictionary: 'english'
             }
           }
       end
@@ -1041,11 +1041,11 @@ describe "an Active Record model which includes PgSearch" do
           include PgSearch
 
           pg_search_scope :search_by_multiple_tsvector_columns,
-            :against => ['content', 'message'],
-            :using => {
-              :tsearch => {
-                :tsvector_column => ['content_tsvector', 'message_tsvector'],
-                :dictionary => 'english'
+            against: ['content', 'message'],
+            using: {
+              tsearch: {
+                tsvector_column: ['content_tsvector', 'message_tsvector'],
+                dictionary: 'english'
               }
             }
         end
@@ -1069,8 +1069,8 @@ describe "an Active Record model which includes PgSearch" do
         model { include PgSearch }
       end
 
-      let!(:expected) { ModelWithTsvector.create!(:content => 'tiling is grouty') }
-      let!(:unexpected) { ModelWithTsvector.create!(:content => 'longcat is looooooooong') }
+      let!(:expected) { ModelWithTsvector.create!(content: 'tiling is grouty') }
+      let!(:unexpected) { ModelWithTsvector.create!(content: 'longcat is looooooooong') }
 
       before do
         ActiveRecord::Base.connection.execute <<-SQL.strip_heredoc
@@ -1079,11 +1079,11 @@ describe "an Active Record model which includes PgSearch" do
         SQL
 
         ModelWithTsvector.pg_search_scope :search_by_content_with_tsvector,
-          :against => :content,
-          :using => {
-            :tsearch => {
-              :tsvector_column => 'content_tsvector',
-              :dictionary => 'english'
+          against: :content,
+          using: {
+            tsearch: {
+              tsvector_column: 'content_tsvector',
+              dictionary: 'english'
             }
           }
       end
@@ -1119,15 +1119,15 @@ describe "an Active Record model which includes PgSearch" do
     context "ignoring accents" do
       before do
         ModelWithPgSearch.pg_search_scope :search_title_without_accents,
-          :against => :title,
-          :ignoring => :accents
+          against: :title,
+          ignoring: :accents
       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")
+        included = ModelWithPgSearch.create!(title: "\303\241bcdef")
 
         results = ModelWithPgSearch.search_title_without_accents("abcd\303\251f")
         expect(results).to eq([included])
@@ -1135,7 +1135,7 @@ describe "an Active Record model which includes PgSearch" do
 
       context "when the query includes accents" do
         it "does not create an erroneous tsquery expression" do
-          included = ModelWithPgSearch.create!(:title => "Weird L‘Content")
+          included = ModelWithPgSearch.create!(title: "Weird L‘Content")
 
           results = ModelWithPgSearch.search_title_without_accents("L‘Content")
           expect(results).to eq([included])
@@ -1146,25 +1146,25 @@ describe "an Active Record model which includes PgSearch" do
     context "when passed a :ranked_by expression" do
       before do
         ModelWithPgSearch.pg_search_scope :search_content_with_default_rank,
-          :against => :content
+          against: :content
 
         ModelWithPgSearch.pg_search_scope :search_content_with_importance_as_rank,
-          :against => :content,
-          :ranked_by => "importance"
+          against: :content,
+          ranked_by: "importance"
 
         ModelWithPgSearch.pg_search_scope :search_content_with_importance_as_rank_multiplier,
-          :against => :content,
-          :ranked_by => ":tsearch * importance"
+          against: :content,
+          ranked_by: ":tsearch * importance"
       end
 
       it "should return records with a rank attribute equal to the :ranked_by expression" do
-        ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
+        ModelWithPgSearch.create!(content: 'foo', importance: 10)
         results = ModelWithPgSearch.search_content_with_importance_as_rank("foo").with_pg_search_rank
         expect(results.first.pg_search_rank).to eq(10)
       end
 
       it "should substitute :tsearch with the tsearch rank expression in the :ranked_by expression" do
-        ModelWithPgSearch.create!(:content => 'foo', :importance => 10)
+        ModelWithPgSearch.create!(content: 'foo', importance: 10)
 
         tsearch_result =
           ModelWithPgSearch.search_content_with_default_rank("foo").with_pg_search_rank.first
@@ -1183,9 +1183,9 @@ describe "an Active Record model which includes PgSearch" do
 
       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)
+          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")
@@ -1197,10 +1197,10 @@ describe "an Active Record model which includes PgSearch" do
           let(:scope_name) { :"search_content_ranked_by_#{feature}" }
           before do
             ModelWithPgSearch.pg_search_scope scope_name,
-              :against => :content,
-              :ranked_by => ":#{feature}"
+              against: :content,
+              ranked_by: ":#{feature}"
 
-            ModelWithPgSearch.create!(:content => 'foo')
+            ModelWithPgSearch.create!(content: 'foo')
           end
 
           context "when .with_pg_search_rank is chained after" do
@@ -1234,12 +1234,12 @@ describe "an Active Record model which includes PgSearch" do
       context "using the tsearch ranking algorithm" do
         it "sorts results by the tsearch rank" do
           ModelWithPgSearch.pg_search_scope :search_content_ranked_by_tsearch,
-            :using => :tsearch,
-            :against => :content,
-            :ranked_by => ":tsearch"
+            using: :tsearch,
+            against: :content,
+            ranked_by: ":tsearch"
 
-          once = ModelWithPgSearch.create!(:content => 'foo bar')
-          twice = ModelWithPgSearch.create!(:content => 'foo foo')
+          once = ModelWithPgSearch.create!(content: 'foo bar')
+          twice = ModelWithPgSearch.create!(content: 'foo foo')
 
           results = ModelWithPgSearch.search_content_ranked_by_tsearch('foo')
           expect(results.find_index(twice)).to be < results.find_index(once)
@@ -1249,12 +1249,12 @@ describe "an Active Record model which includes PgSearch" do
       context "using the trigram ranking algorithm" do
         it "sorts results by the trigram rank" do
           ModelWithPgSearch.pg_search_scope :search_content_ranked_by_trigram,
-            :using => :trigram,
-            :against => :content,
-            :ranked_by => ":trigram"
+            using: :trigram,
+            against: :content,
+            ranked_by: ":trigram"
 
-          close = ModelWithPgSearch.create!(:content => 'abcdef')
-          exact = ModelWithPgSearch.create!(:content => 'abc')
+          close = ModelWithPgSearch.create!(content: 'abcdef')
+          exact = ModelWithPgSearch.create!(content: 'abc')
 
           results = ModelWithPgSearch.search_content_ranked_by_trigram('abc')
           expect(results.find_index(exact)).to be < results.find_index(close)
@@ -1264,12 +1264,12 @@ describe "an Active Record model which includes PgSearch" do
       context "using the dmetaphone ranking algorithm" do
         it "sorts results by the dmetaphone rank" do
           ModelWithPgSearch.pg_search_scope :search_content_ranked_by_dmetaphone,
-            :using => :dmetaphone,
-            :against => :content,
-            :ranked_by => ":dmetaphone"
+            using: :dmetaphone,
+            against: :content,
+            ranked_by: ":dmetaphone"
 
-          once = ModelWithPgSearch.create!(:content => 'Phoo Bar')
-          twice = ModelWithPgSearch.create!(:content => 'Phoo Fu')
+          once = ModelWithPgSearch.create!(content: 'Phoo Bar')
+          twice = ModelWithPgSearch.create!(content: 'Phoo Fu')
 
           results = ModelWithPgSearch.search_content_ranked_by_dmetaphone('foo')
           expect(results.find_index(twice)).to be < results.find_index(once)
@@ -1280,17 +1280,17 @@ describe "an Active Record model which includes PgSearch" do
     context "when there is a sort only feature" do
       it "excludes that feature from the conditions, but uses it in the sorting" do
         ModelWithPgSearch.pg_search_scope :search_content_ranked_by_dmetaphone,
-          :against => :content,
-          :using => {
-            :tsearch => { :any_word => true, :prefix => true },
-            :dmetaphone => { :any_word => true, :prefix => true, :sort_only => true }
+          against: :content,
+          using: {
+            tsearch: { any_word: true, prefix: true },
+            dmetaphone: { any_word: true, prefix: true, sort_only: true }
           },
-          :ranked_by => ":tsearch + (0.5 * :dmetaphone)"
+          ranked_by: ":tsearch + (0.5 * :dmetaphone)"
 
-        exact = ModelWithPgSearch.create!(:content => "ash hines")
-        one_exact_one_close = ModelWithPgSearch.create!(:content => "ash heinz")
-        one_exact = ModelWithPgSearch.create!(:content => "ash smith")
-        one_close = ModelWithPgSearch.create!(:content => "leigh heinz")
+        exact = ModelWithPgSearch.create!(content: "ash hines")
+        one_exact_one_close = ModelWithPgSearch.create!(content: "ash heinz")
+        one_exact = ModelWithPgSearch.create!(content: "ash smith")
+        one_close = ModelWithPgSearch.create!(content: "leigh heinz")
 
         results = ModelWithPgSearch.search_content_ranked_by_dmetaphone("ash hines")
         expect(results).to eq [exact, one_exact_one_close, one_exact]