pg_search 2.3.6 → 2.3.8

data/README.md

@@ -13,10 +13,10 @@ Read the blog post introducing PgSearch at https://tanzu.vmware.com/content/blog
 
 ## REQUIREMENTS
 
-*   Ruby 2.6+
-*   ActiveRecord 5.2+
-*   PostgreSQL 9.2+
-*   [PostgreSQL extensions](https://github.com/Casecommons/pg_search/wiki/Installing-PostgreSQL-Extensions) for certain features
+- Ruby 3.3+
+- Active Record 7.2+
+- PostgreSQL 9.2+
+- [PostgreSQL extensions](https://github.com/Casecommons/pg_search/wiki/Installing-PostgreSQL-Extensions) for certain features
 
 ## INSTALL
 
@@ -48,48 +48,49 @@ To add PgSearch to an Active Record model, simply include the PgSearch module.
 class Shape < ActiveRecord::Base
   include PgSearch::Model
 end
-```    
+```
 
 ### Contents
-* [Multi-search vs. search scopes](#multi-search-vs-search-scopes)
-* [Multi-search](#multi-search)
-  * [Setup](#setup)
-  * [`multisearchable`](#multisearchable)
-  * [More Options ](#more-options)
-  * [Multi-search associations](#multi-search-associations)
-  * [Searching in the global search index](#searching-in-the-global-search-index)
-  * [Chaining method calls onto the results](#chaining-method-calls-onto-the-results)
-  * [Configuring multi-search](#configuring-multi-search)
-  * [Rebuilding search documents for a given class](#rebuilding-search-documents-for-a-given-class)
-  * [Disabling multi-search indexing temporarily](#disabling-multi-search-indexing-temporarily)
-* [`pg_search_scope`](#pg_search_scope)
-  * [Searching against one column](#searching-against-one-column)
-  * [Searching against multiple columns](#searching-against-multiple-columns)
-  * [Dynamic search scopes](#dynamic-search-scopes)
-  * [Searching through associations](#searching-through-associations)
-* [Searching using different search features](#searching-using-different-search-features)
-  * [`:tsearch` (Full Text Search)](#tsearch-full-text-search)
-    * [Weighting](#weighting)
-    * [`:prefix` (PostgreSQL 8.4 and newer only)](#prefix-postgresql-84-and-newer-only)
-    * [`:negation`](#negation)
-    * [`:dictionary`](#dictionary)
-    * [`:normalization`](#normalization)
-    * [`:any_word`](#any_word)
-    * [`:sort_only`](#sort_only)
-    * [`:highlight`](#highlight)
-  * [`:dmetaphone` (Double Metaphone soundalike search)](#dmetaphone-double-metaphone-soundalike-search)
-  * [`:trigram` (Trigram search)](#trigram-trigram-search)
-    * [`:threshold`](#threshold)
-    * [`:word_similarity`](#word_similarity)
-* [Limiting Fields When Combining Features](#limiting-fields-when-combining-features)
-* [Ignoring accent marks](#ignoring-accent-marks)
-* [Using tsvector columns](#using-tsvector-columns)
-  * [Combining multiple tsvectors](#combining-multiple-tsvectors)
-* [Configuring ranking and ordering](#configuring-ranking-and-ordering)
-  * [`:ranked_by` (Choosing a ranking algorithm)](#ranked_by-choosing-a-ranking-algorithm)
-  * [`:order_within_rank` (Breaking ties)](#order_within_rank-breaking-ties)
-  * [`PgSearch#pg_search_rank` (Reading a record's rank as a Float)](#pgsearchpg_search_rank-reading-a-records-rank-as-a-float)
-  * [Search rank and chained scopes](#search-rank-and-chained-scopes)
+
+- [Multi-search vs. search scopes](#multi-search-vs-search-scopes)
+- [Multi-search](#multi-search)
+  - [Setup](#setup)
+  - [`multisearchable`](#multisearchable)
+  - [More Options ](#more-options)
+  - [Multi-search associations](#multi-search-associations)
+  - [Searching in the global search index](#searching-in-the-global-search-index)
+  - [Chaining method calls onto the results](#chaining-method-calls-onto-the-results)
+  - [Configuring multi-search](#configuring-multi-search)
+  - [Rebuilding search documents for a given class](#rebuilding-search-documents-for-a-given-class)
+  - [Disabling multi-search indexing temporarily](#disabling-multi-search-indexing-temporarily)
+- [`pg_search_scope`](#pg_search_scope)
+  - [Searching against one column](#searching-against-one-column)
+  - [Searching against multiple columns](#searching-against-multiple-columns)
+  - [Dynamic search scopes](#dynamic-search-scopes)
+  - [Searching through associations](#searching-through-associations)
+- [Searching using different search features](#searching-using-different-search-features)
+  - [`:tsearch` (Full Text Search)](#tsearch-full-text-search)
+    - [Weighting](#weighting)
+    - [`:prefix` (PostgreSQL 8.4 and newer only)](#prefix-postgresql-84-and-newer-only)
+    - [`:negation`](#negation)
+    - [`:dictionary`](#dictionary)
+    - [`:normalization`](#normalization)
+    - [`:any_word`](#any_word)
+    - [`:sort_only`](#sort_only)
+    - [`:highlight`](#highlight)
+  - [`:dmetaphone` (Double Metaphone soundalike search)](#dmetaphone-double-metaphone-soundalike-search)
+  - [`:trigram` (Trigram search)](#trigram-trigram-search)
+    - [`:threshold`](#threshold)
+    - [`:word_similarity`](#word_similarity)
+- [Limiting Fields When Combining Features](#limiting-fields-when-combining-features)
+- [Ignoring accent marks](#ignoring-accent-marks)
+- [Using tsvector columns](#using-tsvector-columns)
+  - [Combining multiple tsvectors](#combining-multiple-tsvectors)
+- [Configuring ranking and ordering](#configuring-ranking-and-ordering)
+  - [`:ranked_by` (Choosing a ranking algorithm)](#ranked_by-choosing-a-ranking-algorithm)
+  - [`:order_within_rank` (Breaking ties)](#order_within_rank-breaking-ties)
+  - [`PgSearch#pg_search_rank` (Reading a record's rank as a Float)](#pgsearchpg_search_rank-reading-a-records-rank-as-a-float)
+  - [Search rank and chained scopes](#search-rank-and-chained-scopes)
 
 ### Multi-search vs. search scopes
 
@@ -198,17 +199,22 @@ problematic_record.published?     # => true
 PgSearch.multisearch("timestamp") # => Includes problematic_record
 ```
 
-#### More Options 
+#### More Options
 
 **Conditionally update pg_search_documents**
 
-You can specify an `:update_if` parameter to conditionally update pg_search documents. For example:
+You can also use the `:update_if` option to pass a Proc or method name to call
+to determine whether or not a particular record should be updated.
+
+Note that the Proc or method name is called in an `after_save` hook, so if you
+are relying on ActiveRecord dirty flags use `*_previously_changed?`.
 
 ```ruby
-multisearchable(
-    against: [:body],
-    update_if: :body_changed?
-  )
+class Message < ActiveRecord::Base
+  include PgSearch::Model
+  multisearchable against: [:body],
+                  update_if: :body_previously_changed?
+end
 ```
 
 **Specify additional attributes to be saved on the pg_search_documents table**
@@ -241,7 +247,8 @@ 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*
+_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
 
@@ -325,18 +332,18 @@ To regenerate the documents for a given class, run:
 PgSearch::Multisearch.rebuild(Product)
 ```
 
-The ```rebuild``` method will delete all the documents for the given class
+The `rebuild` method will delete all the documents for the given class
 before regenerating them. In some situations this may not be desirable,
-such as when you're using single-table inheritance and ```searchable_type```
-is your base class. You can prevent ```rebuild``` from deleting your records
+such as when you're using single-table inheritance and `searchable_type`
+is your base class. You can prevent `rebuild` from deleting your records
 like so:
 
 ```ruby
 PgSearch::Multisearch.rebuild(Product, clean_up: false)
 ```
 
-```rebuild``` runs inside a single transaction. To run outside of a transaction,
-you can pass ```transactional: false``` like so:
+`rebuild` runs inside a single transaction. To run outside of a transaction,
+you can pass `transactional: false` like so:
 
 ```ruby
 PgSearch::Multisearch.rebuild(Product, transactional: false)
@@ -353,15 +360,11 @@ pg_search_documents tables. The following will set the schema search path to
 
     $ rake pg_search:multisearch:rebuild[BlogPost,my_schema]
 
-For models that are multisearchable :against methods that directly map to
+For models that are multisearchable `:against` methods that directly map to
 Active Record attributes, an efficient single SQL statement is run to update
-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")
-Ingredient.find_each { |record| record.update_pg_search_document }
-```
+the `pg_search_documents` table all at once. However, if you call any dynamic
+methods in `:against` then `update_pg_search_document` will be called on the
+individual records being indexed in batches.
 
 You can also provide a custom implementation for rebuilding the documents by
 adding a class method called `rebuild_pg_search_documents` to your model.
@@ -397,7 +400,8 @@ class Movie < ActiveRecord::Base
   end
 end
 ```
-**Note:** If using PostgreSQL before 9.1, replace the `CONCAT_WS()` function call with double-pipe concatenation, eg. `(movies.name || ' ' || directors.name)`. However, now be aware that if *any* of the joined values is NULL then the final `content` value will also be NULL, whereas `CONCAT_WS()` will selectively ignore NULL values.
+
+**Note:** If using PostgreSQL before 9.1, replace the `CONCAT_WS()` function call with double-pipe concatenation, eg. `(movies.name || ' ' || directors.name)`. However, now be aware that if _any_ of the joined values is NULL then the final `content` value will also be NULL, whereas `CONCAT_WS()` will selectively ignore NULL values.
 
 #### Disabling multi-search indexing temporarily
 
@@ -550,13 +554,27 @@ class Beer < ActiveRecord::Base
 end
 ```
 
-The currently implemented features are
+Here's an example if you pass multiple :using options with additional configurations.
+
+```ruby
+class Beer < ActiveRecord::Base
+  include PgSearch::Model
+  pg_search_scope :search_name,
+  against: :name,
+  using: {
+      :trigram => {},
+      :dmetaphone => {},
+      :tsearch => { :prefix => true }
+  }
+end
+```
 
-*   :tsearch - [Full text search](http://www.postgresql.org/docs/current/static/textsearch-intro.html), which is built-in to PostgreSQL
-*   :trigram - [Trigram search](http://www.postgresql.org/docs/current/static/pgtrgm.html), which
-    requires the trigram extension
-*   :dmetaphone - [Double Metaphone search](http://www.postgresql.org/docs/current/static/fuzzystrmatch.html#AEN177521), which requires the fuzzystrmatch extension
+The currently implemented features are
 
+- :tsearch - [Full text search](http://www.postgresql.org/docs/current/static/textsearch-intro.html), which is built-in to PostgreSQL
+- :trigram - [Trigram search](http://www.postgresql.org/docs/current/static/pgtrgm.html), which
+  requires the trigram extension
+- :dmetaphone - [Double Metaphone search](http://www.postgresql.org/docs/current/static/fuzzystrmatch.html#AEN177521), which requires the fuzzystrmatch extension
 
 #### :tsearch (Full Text Search)
 
@@ -564,6 +582,7 @@ 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
@@ -627,6 +646,7 @@ robin = Superhero.create name: 'Robin'
 
 Superhero.whose_name_starts_with("Bat") # => [batman, batgirl]
 ```
+
 ##### :negation
 
 PostgreSQL's full text search matches all search terms by default. If you want
@@ -662,7 +682,7 @@ Animal.with_name_matching("fish !red !blue") # => [one_fish, two_fish]
 
 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). 
+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
@@ -684,12 +704,12 @@ class BoringTweet < ActiveRecord::Base
                   }
 end
 
-sleepy = BoringTweet.create! text: "I snoozed my alarm for fourteen hours today. I bet I can beat that tomorrow! #sleepy"
+sleep = BoringTweet.create! text: "I snoozed my alarm for fourteen hours today. I bet I can beat that tomorrow! #sleep"
 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"
+sleeps = BoringTweet.create! text: "In the jungle, the mighty jungle, the lion sleeps #tonight"
 
-BoringTweet.kinda_matching("sleeping") # => [sleepy, sleeping, sleeper]
-BoringTweet.literally_matching("sleeping") # => [sleeping]
+BoringTweet.kinda_matching("sleeping") # => [sleep, sleeping, sleeps]
+BoringTweet.literally_matching("sleeps") # => [sleeps]
 ```
 
 ##### :normalization
@@ -787,7 +807,6 @@ Person.search('ash hines') # => [exact, one_exact_one_close, one_exact]
 Adding .with_pg_search_highlight after the pg_search_scope you can access to
 `pg_highlight` attribute for each object.
 
-
 ```ruby
 class Person < ActiveRecord::Base
   include PgSearch::Model
@@ -798,8 +817,8 @@ class Person < ActiveRecord::Base
                       highlight: {
                         StartSel: '<b>',
                         StopSel: '</b>',
-                        MaxWords: 123,
-                        MinWords: 456,
+                        MinWords: 123,
+                        MaxWords: 456,
                         ShortWord: 4,
                         HighlightAll: true,
                         MaxFragments: 3,
@@ -834,7 +853,7 @@ used for searching.
 Double Metaphone support is currently available as part of the [fuzzystrmatch
 extension](http://www.postgresql.org/docs/current/static/fuzzystrmatch.html)
 that must be installed before this feature can be used. In addition to the
-extension, you must install a utility function into your database. To generate 
+extension, you must install a utility function into your database. To generate
 and run a migration for this, run:
 
     $ rails g pg_search:migration:dmetaphone
@@ -869,7 +888,7 @@ Trigram search works by counting how many three-letter substrings (or
 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 
+Trigram support is currently available as part of the
 [pg_trgm extension](http://www.postgresql.org/docs/current/static/pgtrgm.html) that must be installed before this
 feature can be used.
 
@@ -933,7 +952,7 @@ Vegetable.strictly_spelled_like("collyflower") # => []
 Allows you to match words in longer strings.
 By default, trigram searches use `%` or `similarity()` as a similarity value.
 Set `word_similarity` to `true` to opt for `<%` and `word_similarity` instead.
-This causes the trigram search to use the similarity of the query term 
+This causes the trigram search to use the similarity of the query term
 and the word with greatest similarity.
 
 ```ruby
@@ -959,12 +978,12 @@ Sentence.similarity_like("word") # => []
 Sentence.word_similarity_like("word") # => [sentence]
 ```
 
-### Limiting Fields When Combining Features 
+### Limiting Fields When Combining Features
 
-Sometimes when doing queries combining different features you 
-might want to searching against only some of the fields with certain features.
+Sometimes when doing queries combining different features you
+might want to search against only some of the fields with certain features.
 For example perhaps you want to only do a trigram search against the shorter fields
-so that you don't need to reduce the threshold excessively. You can specify 
+so that you don't need to reduce the threshold excessively. You can specify
 which fields using the 'only' option:
 
 ```ruby
@@ -983,7 +1002,7 @@ class Image < ActiveRecord::Base
 end
 ```
 
-Now you can succesfully retrieve an Image with a file_name: 'image_foo.jpg' 
+Now you can succesfully retrieve an Image with a file_name: 'image_foo.jpg'
 and long_description: 'This description is so long that it would make a trigram search
 fail any reasonable threshold limit' with:
 
@@ -1036,31 +1055,31 @@ 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:
-    [the PostgreSQL documentation for text search triggers](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:
-
-    ```ruby
-    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
-                    }
-    ```
+- 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:
+  [the PostgreSQL documentation for text search triggers](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:
+
+  ```ruby
+  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.
@@ -1173,9 +1192,9 @@ shirt_brands[1].pg_search_rank #=> 0.0607927
 
 #### Search rank and chained scopes
 
-Each PgSearch scope generates a named subquery for the search rank.  If you
+Each PgSearch scope generates a named subquery for the search rank. If you
 chain multiple scopes then PgSearch will generate a ranking query for each
-scope, so the ranking queries must have unique names.  If you need to reference
+scope, so the ranking queries must have unique names. If you need to reference
 the ranking query (e.g. in a GROUP BY clause) you can regenerate the subquery
 name with the `PgScope::Configuration.alias` method by passing the name of the
 queried table.
@@ -1201,5 +1220,5 @@ for discussing pg_search and other Casebook PBC open source projects.
 
 ## LICENSE
 
-Copyright © 2010–2021 [Casebook PBC](http://www.casebook.net).
+Copyright © 2010–2022 [Casebook PBC](http://www.casebook.net).
 Licensed under the MIT license, see [LICENSE](/LICENSE) file.

data/Rakefile

@@ -1,20 +1,11 @@
 # frozen_string_literal: true
 
-require 'bundler'
+require "bundler"
 Bundler::GemHelper.install_tasks
 
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 
-require "rubocop/rake_task"
-RuboCop::RakeTask.new do |t|
-  t.options = %w[--display-cop-names]
-end
+require "standard/rake"
 
-desc "Check test coverage"
-task :undercover do
-  system("git fetch --unshallow") if ENV["CI"]
-  exit(1) unless system("bin/undercover --compare origin/master")
-end
-
-task default: %w[spec rubocop undercover]
+task default: %w[spec standard]

data/lib/pg_search/configuration/column.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest'
+require "digest"
 
 module PgSearch
   class Configuration
@@ -9,18 +9,20 @@ module PgSearch
 
       def initialize(column_name, weight, model)
         @name = column_name.to_s
-        @column_name = column_name.to_s
+        @column_name = column_name
         @weight = weight
         @model = model
         @connection = model.connection
       end
 
       def full_name
+        return @column_name if @column_name.is_a?(Arel::Nodes::SqlLiteral)
+
         "#{table_name}.#{column_name}"
       end
 
       def to_sql
-        "coalesce(#{expression}::text, '')"
+        "coalesce((#{expression})::text, '')"
       end
 
       private
@@ -30,7 +32,7 @@ module PgSearch
       end
 
       def column_name
-        @connection.quote_column_name(@column_name)
+        @connection.quote_column_name(@name)
       end
 
       def expression

data/lib/pg_search/configuration/foreign_column.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest'
+require "digest"
 
 module PgSearch
   class Configuration

data/lib/pg_search/configuration.rb

@@ -23,9 +23,7 @@ module PgSearch
       end
     end
 
-    def columns
-      regular_columns + associated_columns
-    end
+    def columns = regular_columns + associated_columns
 
     def regular_columns
       return [] unless options[:against]
@@ -43,46 +41,31 @@ module PgSearch
       end.flatten
     end
 
-    def associated_columns
-      associations.map(&:columns).flatten
-    end
+    def associated_columns = associations.map(&:columns).flatten
 
-    def query
-      options[:query].to_s
-    end
+    def query = options[:query].to_s
 
-    def ignore
-      Array(options[:ignoring])
-    end
+    def ignore = Array(options[:ignoring])
 
-    def ranking_sql
-      options[:ranked_by]
-    end
+    def ranking_sql = options[:ranked_by]
 
-    def features
-      Array(options[:using])
-    end
+    def features = Array(options[:using])
 
     def feature_options
-      @feature_options ||= {}.tap do |hash|
-        features.map do |feature_name, feature_options|
-          hash[feature_name] = feature_options
-        end
-      end
+      @feature_options ||= features.to_h { |name, opts| [name, opts] }
     end
 
-    def order_within_rank
-      options[:order_within_rank]
-    end
+    def order_within_rank = options[:order_within_rank]
 
     private
 
     attr_reader :options
 
     def default_options
-      { using: :tsearch }
+      {using: :tsearch}
     end
 
+    # standard:disable Lint/UselessConstantScoping
     VALID_KEYS = %w[
       against ranked_by ignoring using query associated_against order_within_rank
     ].map(&:to_sym)
@@ -90,6 +73,7 @@ module PgSearch
     VALID_VALUES = {
       ignoring: [:accents]
     }.freeze
+    # standard:enable Lint/UselessConstantScoping
 
     def assert_valid_options(options)
       unless options[:against] || options[:associated_against] || using_tsvector_column?(options[:using])

data/lib/pg_search/document.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'logger'
+require "logger"
 
 module PgSearch
-  class Document < ActiveRecord::Base
+  class Document < ActiveRecord::Base # standard:disable Rails/ApplicationRecord
     include PgSearch::Model
 
-    self.table_name = 'pg_search_documents'
+    self.table_name = "pg_search_documents"
     belongs_to :searchable, polymorphic: true
 
     # The logger might not have loaded yet.
@@ -17,12 +17,12 @@ module PgSearch
 
     pg_search_scope :search, lambda { |*args|
       options = if PgSearch.multisearch_options.respond_to?(:call)
-                  PgSearch.multisearch_options.call(*args)
-                else
-                  { query: args.first }.merge(PgSearch.multisearch_options)
-                end
+        PgSearch.multisearch_options.call(*args)
+      else
+        {query: args.first}.merge(PgSearch.multisearch_options)
+      end
 
-      { against: :content }.merge(options)
+      {against: :content}.merge(options)
     }
   end
 end

data/lib/pg_search/features/dmetaphone.rb

@@ -7,7 +7,7 @@ module PgSearch
     class DMetaphone
       def initialize(query, options, columns, model, normalizer)
         dmetaphone_normalizer = Normalizer.new(normalizer)
-        options = (options || {}).merge(dictionary: 'simple')
+        options = (options || {}).merge(dictionary: "simple")
         @tsearch = TSearch.new(query, options, columns, model, dmetaphone_normalizer)
       end
 

data/lib/pg_search/features/trigram.rb

@@ -35,17 +35,17 @@ module PgSearch
 
       def similarity_function
         if word_similarity?
-          'word_similarity'
+          "word_similarity"
         else
-          'similarity'
+          "similarity"
         end
       end
 
       def infix_operator
         if word_similarity?
-          '<%'
+          "<%"
         else
-          '%'
+          "%"
         end
       end