pg_search 2.1.7 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 154a4037a4ee2795a1cfa074afb2e762969db793cbbdecfbee26325ceaac6d7e
-  data.tar.gz: ae17fccdcae3305c410acf036c28fd2bd5bbede25f5e13afe722cfcfb7a8c188
+  metadata.gz: 292701a98892eef31e95d8b5d723e94ce71fd47e4956e8bed595b8f87797f49c
+  data.tar.gz: cc08372ce5c032e288c28b2f6409c218d361b271fc271de08acbe8e5430c8dcb
 SHA512:
-  metadata.gz: aa942ecd16fbc913a084f17e06493f05ab95b7520bc212aa002fe1fc6386678e80638505fb2b5640ecaecd69212b956a1e7d03ed6475a30811db96d3de33a16e
-  data.tar.gz: 6f648d0b981a95d4eb35ab1ab81c3fb199e25aefd3378032c3f7407fe8722c780c3542264f4dc99c5e7b9780dff02619ba6cd0fd34b36cd0ca4ae1565c7e083d
+  metadata.gz: e95e7240968269703ae6d010639f2b4380e7616962c7a07f4932ad5e21c77affae6ea3c90e9a8171641a506988fa076ecdb30224f2b081d1468fb13618713d2e
+  data.tar.gz: 4910a636f53e444c3995e0ca728bd21475d11347d8a4d8223a1e881f3360bf8dc7e4f5689bd05cc559dad106a08b077abda1b3f50c6108221e4dbf75c4d73ffa

data/.rubocop.yml

@@ -45,7 +45,7 @@ Bundler/DuplicatedGem:
 Style/EmptyMethod:
   EnforcedStyle: expanded
   
-Layout/IndentArray:
+Layout/IndentFirstArrayElement:
   EnforcedStyle: consistent
 
 Style/Documentation:

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # pg_search changelog
 
+## 2.2.0
+
+* Add word_similarity option to trigram search (Severin Räz)
+
 ## 2.1.7
 
 * Restore link to GitHub repository to original location

data/README.md

@@ -877,6 +877,37 @@ Vegetable.roughly_spelled_like("collyflower") # => [cauliflower]
 Vegetable.strictly_spelled_like("collyflower") # => []
 ```
 
+##### :word_similarity
+
+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 
+and the word with greatest similarity.
+
+```ruby
+class Sentence < ActiveRecord::Base
+  include PgSearch
+
+  pg_search_scope :similarity_like,
+                  against: :words,
+                  using: {
+                    trigram: {
+                      word_similarity: true
+                    }
+                  }
+
+  pg_search_scope :word_similarity_like,
+                  against: :words,
+                  using: [:trigram]
+end
+
+sentence = Sentence.create! name: "Those are two words."
+
+Sentence.similarity_like("word") # => []
+Sentence.word_similarity_like("word") # => [sentence]
+```
+
 ### Limiting Fields When Combining Features 
 
 Sometimes when doing queries combining different features you 

data/lib/pg_search/features/trigram.rb

@@ -4,7 +4,7 @@ module PgSearch
   module Features
     class Trigram < Feature
       def self.valid_options
-        super + [:threshold]
+        super + %i[threshold word_similarity]
       end
 
       def conditions
@@ -14,7 +14,11 @@ module PgSearch
           )
         else
           Arel::Nodes::Grouping.new(
-            Arel::Nodes::InfixOperation.new("%", normalized_document, normalized_query)
+            Arel::Nodes::InfixOperation.new(
+              infix_operator,
+              normalized_query,
+              normalized_document
+            )
           )
         end
       end
@@ -25,12 +29,32 @@ module PgSearch
 
       private
 
+      def word_similarity?
+        options[:word_similarity]
+      end
+
+      def similarity_function
+        if word_similarity?
+          'word_similarity'
+        else
+          'similarity'
+        end
+      end
+
+      def infix_operator
+        if word_similarity?
+          '<%'
+        else
+          '%'
+        end
+      end
+
       def similarity
         Arel::Nodes::NamedFunction.new(
-          "similarity",
+          similarity_function,
           [
-            normalized_document,
-            normalized_query
+            normalized_query,
+            normalized_document
           ]
         )
       end

data/lib/pg_search/multisearchable.rb

@@ -7,12 +7,12 @@ module PgSearch
     def self.included(mod)
       mod.class_eval do
         has_one :pg_search_document,
-          as: :searchable,
-          class_name: "PgSearch::Document",
-          dependent: :delete
+                as: :searchable,
+                class_name: "PgSearch::Document",
+                dependent: :delete
 
         after_save :update_pg_search_document,
-          if: -> { PgSearch.multisearch_enabled? }
+                   if: -> { PgSearch.multisearch_enabled? }
       end
     end
 

data/lib/pg_search/scope_options.rb

@@ -19,18 +19,10 @@ module PgSearch
       scope
         .joins(rank_join(rank_table_alias))
         .order(Arel.sql("#{rank_table_alias}.rank DESC, #{order_within_rank}"))
-        .extend(DisableEagerLoading)
         .extend(WithPgSearchRank)
         .extend(WithPgSearchHighlight[feature_for(:tsearch)])
     end
 
-    # workaround for https://github.com/Casecommons/pg_search/issues/14
-    module DisableEagerLoading
-      def eager_loading?
-        false
-      end
-    end
-
     module WithPgSearchHighlight
       def self.[](tsearch)
         Module.new do

data/lib/pg_search/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgSearch
-  VERSION = '2.1.7'
+  VERSION = '2.2.0'
 end

data/pg_search.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', '>= 3.3'
-  s.add_development_dependency 'rubocop', '>= 0.67.2'
+  s.add_development_dependency 'rubocop', '>= 0.68.1'
   s.add_development_dependency 'rubocop-performance'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'with_model', '>= 1.2'

data/spec/integration/associations_spec.rb

@@ -166,15 +166,15 @@ describe PgSearch do
             include PgSearch
 
             has_many :models_of_first_type,
-              class_name: 'FirstAssociatedModel',
-              foreign_key: 'ModelWithManyAssociations_id'
+                     class_name: 'FirstAssociatedModel',
+                     foreign_key: 'ModelWithManyAssociations_id'
 
             belongs_to :model_of_second_type,
-              class_name: 'SecondAssociatedModel'
+                       class_name: 'SecondAssociatedModel'
 
             pg_search_scope :with_associated,
-              against: :title,
-              associated_against: { models_of_first_type: :title, model_of_second_type: :title }
+                            against: :title,
+                            associated_against: { models_of_first_type: :title, model_of_second_type: :title }
           end
         end
 
@@ -225,12 +225,12 @@ describe PgSearch do
             include PgSearch
 
             has_many :things,
-              class_name: 'DoublyAssociatedModel',
-              foreign_key: 'ModelWithDoubleAssociation_id'
+                     class_name: 'DoublyAssociatedModel',
+                     foreign_key: 'ModelWithDoubleAssociation_id'
 
             has_many :thingamabobs,
-              class_name: 'DoublyAssociatedModel',
-              foreign_key: 'ModelWithDoubleAssociation_again_id'
+                     class_name: 'DoublyAssociatedModel',
+                     foreign_key: 'ModelWithDoubleAssociation_again_id'
 
             pg_search_scope :with_associated, against: :title,
                                               associated_against: { things: :title, thingamabobs: :title }

data/spec/integration/pg_search_spec.rb

@@ -38,12 +38,12 @@ describe "an Active Record model which includes PgSearch" do
     context "when passed a lambda" do
       it "builds a dynamic scope" do
         ModelWithPgSearch.pg_search_scope :search_title_or_content,
-          lambda { |query, pick_content|
-            {
-              query: query.gsub("-remove-", ""),
-              against: pick_content ? :content : :title
-            }
-          }
+                                          lambda { |query, pick_content|
+                                            {
+                                              query: query.gsub("-remove-", ""),
+                                              against: pick_content ? :content : :title
+                                            }
+                                          }
 
         included = ModelWithPgSearch.create!(title: 'foo', content: 'bar')
         excluded = ModelWithPgSearch.create!(title: 'bar', content: 'foo')
@@ -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")
@@ -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
 
@@ -565,10 +565,10 @@ 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
@@ -594,10 +594,10 @@ 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
@@ -620,7 +620,7 @@ describe "an Active Record model which includes PgSearch" do
         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
@@ -641,19 +641,19 @@ describe "an Active Record model which includes PgSearch" do
             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
+                                                  }
+                                                }
+                                              }
           end
 
           it "applies the options to the excerpts" do
@@ -682,10 +682,10 @@ 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
 
           it "ranks the results for documents with less text higher" do
@@ -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,7 +715,7 @@ 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
@@ -731,7 +731,7 @@ 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
@@ -747,7 +747,7 @@ 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
@@ -763,13 +763,13 @@ 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
@@ -788,10 +788,10 @@ 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
@@ -815,10 +815,10 @@ 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
@@ -841,8 +841,8 @@ 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
@@ -880,35 +880,35 @@ 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' }],
-            :trigram
-          ]
+                                          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
@@ -955,11 +955,11 @@ describe "an Active Record model which includes PgSearch" do
           @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
@@ -1013,13 +1013,13 @@ 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
 
       it "should find by the tsvector column" do
@@ -1041,13 +1041,13 @@ 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
       end
 
@@ -1079,13 +1079,13 @@ 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
 
       it "should not use to_tsvector in the query" do
@@ -1119,8 +1119,8 @@ 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
@@ -1146,15 +1146,15 @@ 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
@@ -1197,8 +1197,8 @@ 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')
           end
@@ -1234,9 +1234,9 @@ 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')
@@ -1249,9 +1249,9 @@ 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')
@@ -1264,9 +1264,9 @@ 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')
@@ -1280,12 +1280,12 @@ 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 }
-          },
-          ranked_by: ":tsearch + (0.5 * :dmetaphone)"
+                                          against: :content,
+                                          using: {
+                                            tsearch: { any_word: true, prefix: true },
+                                            dmetaphone: { any_word: true, prefix: true, sort_only: true }
+                                          },
+                                          ranked_by: ":tsearch + (0.5 * :dmetaphone)"
 
         exact = ModelWithPgSearch.create!(content: "ash hines")
         one_exact_one_close = ModelWithPgSearch.create!(content: "ash heinz")

data/spec/lib/pg_search/configuration/foreign_column_spec.rb

@@ -26,8 +26,8 @@ describe PgSearch::Configuration::ForeignColumn do
 
     it "returns a consistent string" do
       association = PgSearch::Configuration::Association.new(Model,
-        :another_model,
-        :title)
+                                                             :another_model,
+                                                             :title)
       foreign_column = described_class.new("title", nil, Model, association)
 
       column_alias = foreign_column.alias

data/spec/lib/pg_search/features/trigram_spec.rb

@@ -32,25 +32,50 @@ describe PgSearch::Features::Trigram do
   describe 'conditions' do
     it 'escapes the search document and query' do
       config.ignore = []
-      expect(feature.conditions.to_sql).to eq("((#{coalesced_columns}) % '#{query}')")
+      expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_columns}))")
+    end
+
+    context 'searching by word_similarity' do
+      let(:options) do
+        { word_similarity: true }
+      end
+
+      it 'uses the "<%" operator when searching by word_similarity' do
+        config.ignore = []
+        expect(feature.conditions.to_sql).to eq("('#{query}' <% (#{coalesced_columns}))")
+      end
     end
 
     context 'ignoring accents' do
       it 'escapes the search document and query, but not the accent function' do
         config.ignore = [:accents]
-        expect(feature.conditions.to_sql).to eq("((unaccent(#{coalesced_columns})) % unaccent('#{query}'))")
+        expect(feature.conditions.to_sql).to eq("(unaccent('#{query}') % (unaccent(#{coalesced_columns})))")
       end
     end
 
     context 'when a threshold is specified' do
-      let(:options) do
-        { threshold: 0.5 }
+      context 'searching by similarity' do
+        let(:options) do
+          { threshold: 0.5 }
+        end
+
+        it 'uses a minimum similarity expression instead of the "%" operator' do
+          expect(feature.conditions.to_sql).to eq(
+            "(similarity('#{query}', (#{coalesced_columns})) >= 0.5)"
+          )
+        end
       end
 
-      it 'uses a minimum similarity expression instead of the "%" operator' do
-        expect(feature.conditions.to_sql).to eq(
-          "(similarity((#{coalesced_columns}), '#{query}') >= 0.5)"
-        )
+      context 'searching by word_similarity' do
+        let(:options) do
+          { threshold: 0.5, word_similarity: true }
+        end
+
+        it 'uses a minimum similarity expression instead of the "<%" operator' do
+          expect(feature.conditions.to_sql).to eq(
+            "(word_similarity('#{query}', (#{coalesced_columns})) >= 0.5)"
+          )
+        end
       end
     end
 
@@ -61,7 +86,7 @@ describe PgSearch::Features::Trigram do
         it 'only searches against the select column' do
           options = { only: :name }
           coalesced_column = "coalesce(#{Model.quoted_table_name}.\"name\"::text, '')"
-          expect(feature.conditions.to_sql).to eq("((#{coalesced_column}) % '#{query}')")
+          expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_column}))")
         end
       end
       context 'multiple columns' do
@@ -69,7 +94,7 @@ describe PgSearch::Features::Trigram do
 
         it 'concatenates when multiples columns are selected' do
           options = { only: %i[name content] }
-          expect(feature.conditions.to_sql).to eq("((#{coalesced_columns}) % '#{query}')")
+          expect(feature.conditions.to_sql).to eq("('#{query}' % (#{coalesced_columns}))")
         end
       end
     end
@@ -77,7 +102,7 @@ describe PgSearch::Features::Trigram do
 
   describe '#rank' do
     it 'returns an expression using the similarity() function' do
-      expect(feature.rank.to_sql).to eq("(similarity((#{coalesced_columns}), '#{query}'))")
+      expect(feature.rank.to_sql).to eq("(similarity('#{query}', (#{coalesced_columns})))")
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_search
 version: !ruby/object:Gem::Version
-  version: 2.1.7
+  version: 2.2.0
 platform: ruby
 authors:
 - Grant Hutchins
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-20 00:00:00.000000000 Z
+date: 2019-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -87,14 +87,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.67.2
+        version: 0.68.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.67.2
+        version: 0.68.1
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement