pg_search 2.1.2 → 2.3.6

data/spec/integration/single_table_inheritance_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe "a pg_search_scope on an STI subclass" do
@@ -9,8 +11,8 @@ describe "a pg_search_scope on an STI subclass" do
       end
 
       model do
-        include PgSearch
-        pg_search_scope :search_content, :against => :content
+        include PgSearch::Model
+        pg_search_scope :search_content, against: :content
       end
     end
 
@@ -21,14 +23,14 @@ describe "a pg_search_scope on an STI subclass" do
 
     it "returns only results for that subclass" do
       included = [
-        SearchableSubclassModel.create!(:content => "foo bar")
+        SearchableSubclassModel.create!(content: "foo bar")
       ]
       excluded = [
-        SearchableSubclassModel.create!(:content => "baz"),
-        SuperclassModel.create!(:content => "foo bar"),
-        SuperclassModel.create!(:content => "baz"),
-        AnotherSearchableSubclassModel.create!(:content => "foo bar"),
-        AnotherSearchableSubclassModel.create!(:content => "baz")
+        SearchableSubclassModel.create!(content: "baz"),
+        SuperclassModel.create!(content: "foo bar"),
+        SuperclassModel.create!(content: "baz"),
+        AnotherSearchableSubclassModel.create!(content: "foo bar"),
+        AnotherSearchableSubclassModel.create!(content: "baz")
       ]
 
       expect(SuperclassModel.count).to eq(6)
@@ -49,9 +51,9 @@ describe "a pg_search_scope on an STI subclass" do
       end
 
       model do
-        include PgSearch
+        include PgSearch::Model
         self.inheritance_column = 'custom_type'
-        pg_search_scope :search_content, :against => :content
+        pg_search_scope :search_content, against: :content
       end
     end
 
@@ -62,14 +64,14 @@ describe "a pg_search_scope on an STI subclass" do
 
     it "returns only results for that subclass" do
       included = [
-        SearchableSubclassModel.create!(:content => "foo bar")
+        SearchableSubclassModel.create!(content: "foo bar")
       ]
       excluded = [
-        SearchableSubclassModel.create!(:content => "baz"),
-        SuperclassModel.create!(:content => "foo bar"),
-        SuperclassModel.create!(:content => "baz"),
-        AnotherSearchableSubclassModel.create!(:content => "foo bar"),
-        AnotherSearchableSubclassModel.create!(:content => "baz")
+        SearchableSubclassModel.create!(content: "baz"),
+        SuperclassModel.create!(content: "foo bar"),
+        SuperclassModel.create!(content: "baz"),
+        AnotherSearchableSubclassModel.create!(content: "foo bar"),
+        AnotherSearchableSubclassModel.create!(content: "baz")
       ]
 
       expect(SuperclassModel.count).to eq(6)
@@ -82,4 +84,3 @@ describe "a pg_search_scope on an STI subclass" do
     end
   end
 end
-

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

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
+# rubocop:disable RSpec/NestedGroups
 describe PgSearch::Configuration::Association do
   with_model :Avatar do
     table do |t|
@@ -15,12 +18,12 @@ describe PgSearch::Configuration::Association do
     end
 
     model do
-      include PgSearch
-      has_one :avatar, :class_name => "Avatar"
+      include PgSearch::Model
+      has_one :avatar, class_name: "Avatar"
       belongs_to :site
 
-      pg_search_scope :with_avatar, :associated_against => {:avatar => :url}
-      pg_search_scope :with_site, :associated_against => {:site => :title}
+      pg_search_scope :with_avatar, associated_against: { avatar: :url }
+      pg_search_scope :with_site, associated_against: { site: :title }
     end
   end
 
@@ -30,14 +33,14 @@ describe PgSearch::Configuration::Association do
     end
 
     model do
-      include PgSearch
-      has_many :users, :class_name => "User"
+      include PgSearch::Model
+      has_many :users, class_name: "User"
 
-      pg_search_scope :with_users, :associated_against => {:users => :name}
+      pg_search_scope :with_users, associated_against: { users: :name }
     end
   end
 
-  context "has_one" do
+  context "with has_one" do
     let(:association) { described_class.new(User, :avatar, :url) }
 
     describe "#table_name" do
@@ -48,7 +51,7 @@ describe PgSearch::Configuration::Association do
 
     describe "#join" do
       let(:expected_sql) do
-        <<-SQL.gsub(/\s+/, ' ').strip
+        <<~SQL.squish
           LEFT OUTER JOIN
             (SELECT model_id AS id,
                     #{column_select} AS #{association.columns.first.alias}
@@ -68,7 +71,7 @@ describe PgSearch::Configuration::Association do
     end
   end
 
-  context "belongs_to" do
+  context "with belongs_to" do
     let(:association) { described_class.new(User, :site, :title) }
 
     describe "#table_name" do
@@ -79,7 +82,7 @@ describe PgSearch::Configuration::Association do
 
     describe "#join" do
       let(:expected_sql) do
-        <<-SQL.gsub(/\s+/, ' ').strip
+        <<~SQL.squish
           LEFT OUTER JOIN
             (SELECT model_id AS id,
                     #{column_select} AS #{association.columns.first.alias}
@@ -99,7 +102,7 @@ describe PgSearch::Configuration::Association do
     end
   end
 
-  context "has_many" do
+  context "with has_many" do
     let(:association) { described_class.new(Site, :users, :name) }
 
     describe "#table_name" do
@@ -110,7 +113,7 @@ describe PgSearch::Configuration::Association do
 
     describe "#join" do
       let(:expected_sql) do
-        <<-SQL.gsub(/\s+/, ' ').strip
+        <<~SQL.squish
           LEFT OUTER JOIN
             (SELECT model_id AS id,
                     string_agg(\"#{association.table_name}\".\"name\"::text, ' ') AS #{association.columns.first.alias}
@@ -136,3 +139,4 @@ describe PgSearch::Configuration::Association do
     end
   end
 end
+# rubocop:enable RSpec/NestedGroups

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe PgSearch::Configuration::Column do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe PgSearch::Configuration::ForeignColumn do
@@ -15,17 +17,17 @@ describe PgSearch::Configuration::ForeignColumn do
       end
 
       model do
-        include PgSearch
+        include PgSearch::Model
         belongs_to :another_model, class_name: 'AssociatedModel'
 
-        pg_search_scope :with_another, :associated_against => {:another_model => :title}
+        pg_search_scope :with_another, associated_against: { another_model: :title }
       end
     end
 
     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/dmetaphone_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe PgSearch::Features::DMetaphone do
@@ -13,10 +15,10 @@ describe PgSearch::Features::DMetaphone do
       query = "query"
       columns = [
         PgSearch::Configuration::Column.new(:name, nil, Model),
-        PgSearch::Configuration::Column.new(:content, nil, Model),
+        PgSearch::Configuration::Column.new(:content, nil, Model)
       ]
       options = {}
-      config = double(:config, :ignore => [])
+      config = instance_double("PgSearch::Configuration", :config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
@@ -38,10 +40,10 @@ describe PgSearch::Features::DMetaphone do
       query = "query"
       columns = [
         PgSearch::Configuration::Column.new(:name, nil, Model),
-        PgSearch::Configuration::Column.new(:content, nil, Model),
+        PgSearch::Configuration::Column.new(:content, nil, Model)
       ]
       options = {}
-      config = double(:config, :ignore => [])
+      config = instance_double("PgSearch::Configuration", :config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)

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

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'ostruct'
 
+# rubocop:disable RSpec/MultipleMemoizedHelpers, RSpec/NestedGroups
 describe PgSearch::Features::Trigram do
   subject(:feature) { described_class.new(query, options, columns, Model, normalizer) }
+
   let(:query) { 'lolwut' }
   let(:options) { {} }
   let(:columns) {
@@ -12,11 +16,13 @@ describe PgSearch::Features::Trigram do
     ]
   }
   let(:normalizer) { PgSearch::Normalizer.new(config) }
-  let(:config) { OpenStruct.new(:ignore => []) }
+  let(:config) { OpenStruct.new(ignore: []) } # rubocop:disable Style/OpenStructUse
 
   let(:coalesced_columns) do
-    <<-SQL.strip_heredoc.chomp
-      coalesce(#{Model.quoted_table_name}."name"::text, '') || ' ' || coalesce(#{Model.quoted_table_name}."content"::text, '')
+    <<~SQL.squish
+      coalesce(#{Model.quoted_table_name}."name"::text, '')
+        || ' '
+        || coalesce(#{Model.quoted_table_name}."content"::text, '')
     SQL
   end
 
@@ -30,44 +36,68 @@ 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 'when 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
+    context 'when 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 'when 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 'when 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
 
-    context 'only certain columns are selected' do
-      context 'one column' do
+    context 'when only certain columns are selected' do
+      context 'with one column' do
         let(:options) { { only: :name } }
 
         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
+
+      context 'with multiple columns' do
         let(:options) { { only: %i[name content] } }
 
         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
@@ -75,7 +105,8 @@ 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
+# rubocop:enable RSpec/MultipleMemoizedHelpers, RSpec/NestedGroups

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "active_support/deprecation"
 
@@ -14,10 +16,10 @@ describe PgSearch::Features::TSearch do
       query = "query"
       columns = [
         PgSearch::Configuration::Column.new(:name, nil, Model),
-        PgSearch::Configuration::Column.new(:content, nil, Model),
+        PgSearch::Configuration::Column.new(:content, nil, Model)
       ]
       options = {}
-      config = double(:config, :ignore => [])
+      config = instance_double("PgSearch::Configuration", :config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
@@ -39,10 +41,10 @@ describe PgSearch::Features::TSearch do
       query = "query"
       columns = [
         PgSearch::Configuration::Column.new(:name, nil, Model),
-        PgSearch::Configuration::Column.new(:content, nil, Model),
+        PgSearch::Configuration::Column.new(:content, nil, Model)
       ]
       options = {}
-      config = double(:config, :ignore => [])
+      config = instance_double("PgSearch::Configuration", :config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
@@ -56,10 +58,10 @@ describe PgSearch::Features::TSearch do
         query = "!query"
         columns = [
           PgSearch::Configuration::Column.new(:name, nil, Model),
-          PgSearch::Configuration::Column.new(:content, nil, Model),
+          PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
-        options = {:negation => true}
-        config = double(:config, :ignore => [])
+        options = { negation: true }
+        config = instance_double("PgSearch::Configuration", :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
@@ -74,10 +76,10 @@ describe PgSearch::Features::TSearch do
         query = "!query"
         columns = [
           PgSearch::Configuration::Column.new(:name, nil, Model),
-          PgSearch::Configuration::Column.new(:content, nil, Model),
+          PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
-        options = {:negation => false}
-        config = double(:config, :ignore => [])
+        options = { negation: false }
+        config = instance_double("PgSearch::Configuration", :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
@@ -92,10 +94,10 @@ describe PgSearch::Features::TSearch do
         query = "query"
         columns = [
           PgSearch::Configuration::Column.new(:name, nil, Model),
-          PgSearch::Configuration::Column.new(:content, nil, Model),
+          PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
-        options = {tsvector_column: "my_tsvector"}
-        config = double(:config, :ignore => [])
+        options = { tsvector_column: "my_tsvector" }
+        config = instance_double("PgSearch::Configuration", :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
@@ -110,10 +112,10 @@ describe PgSearch::Features::TSearch do
         query = "query"
         columns = [
           PgSearch::Configuration::Column.new(:name, nil, Model),
-          PgSearch::Configuration::Column.new(:content, nil, Model),
+          PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
-        options = {tsvector_column: ["tsvector1", "tsvector2"]}
-        config = double(:config, :ignore => [])
+        options = { tsvector_column: ["tsvector1", "tsvector2"] }
+        config = instance_double("PgSearch::Configuration", :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
@@ -139,7 +141,7 @@ describe PgSearch::Features::TSearch do
       ]
       options = {}
 
-      config = double(:config, :ignore => [])
+      config = instance_double("PgSearch::Configuration", :config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
@@ -149,11 +151,12 @@ describe PgSearch::Features::TSearch do
     end
 
     context "when options[:dictionary] is passed" do
+      # rubocop:disable RSpec/ExampleLength
       it 'uses the provided dictionary' do
         query = "query"
         columns = [
           PgSearch::Configuration::Column.new(:name, nil, Model),
-          PgSearch::Configuration::Column.new(:content, nil, Model),
+          PgSearch::Configuration::Column.new(:content, nil, Model)
         ]
         options = {
           dictionary: "spanish",
@@ -163,7 +166,7 @@ describe PgSearch::Features::TSearch do
           }
         }
 
-        config = double(:config, :ignore => [])
+        config = instance_double("PgSearch::Configuration", :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
@@ -172,9 +175,11 @@ describe PgSearch::Features::TSearch do
 
         expect(feature.highlight.to_sql).to eq(expected_sql)
       end
+      # rubocop:enable RSpec/ExampleLength
     end
 
     context "when options[:highlight] has options set" do
+      # rubocop:disable RSpec/ExampleLength
       it "passes the options to ts_headline" do
         query = "query"
         columns = [
@@ -193,7 +198,7 @@ describe PgSearch::Features::TSearch do
           }
         }
 
-        config = double(:config, :ignore => [])
+        config = instance_double("PgSearch::Configuration", :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
@@ -202,7 +207,9 @@ describe PgSearch::Features::TSearch do
 
         expect(feature.highlight.to_sql).to eq(expected_sql)
       end
+      # rubocop:enable RSpec/ExampleLength
 
+      # rubocop:disable RSpec/ExampleLength
       it "passes deprecated options to ts_headline" do
         query = "query"
         columns = [
@@ -221,7 +228,7 @@ describe PgSearch::Features::TSearch do
           }
         }
 
-        config = double(:config, :ignore => [])
+        config = instance_double("PgSearch::Configuration", :config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
@@ -231,6 +238,7 @@ describe PgSearch::Features::TSearch do
 
         expect(highlight_sql).to eq(expected_sql)
       end
+      # rubocop:enable RSpec/ExampleLength
     end
   end
 end