pg_search 2.1.2 → 2.2.0

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
@@ -10,7 +12,7 @@ describe "a pg_search_scope on an STI subclass" do
 
       model do
         include PgSearch
-        pg_search_scope :search_content, :against => :content
+        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)
@@ -51,7 +53,7 @@ describe "a pg_search_scope on an STI subclass" do
       model do
         include PgSearch
         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,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe PgSearch::Configuration::Association do
@@ -16,11 +18,11 @@ describe PgSearch::Configuration::Association do
 
     model do
       include PgSearch
-      has_one :avatar, :class_name => "Avatar"
+      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
 
@@ -31,9 +33,9 @@ describe PgSearch::Configuration::Association do
 
     model do
       include PgSearch
-      has_many :users, :class_name => "User"
+      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
 

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
@@ -18,14 +20,14 @@ describe PgSearch::Configuration::ForeignColumn do
         include PgSearch
         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 = double(: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 = double(: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,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'ostruct'
 
@@ -12,7 +14,7 @@ describe PgSearch::Features::Trigram do
     ]
   }
   let(:normalizer) { PgSearch::Normalizer.new(config) }
-  let(:config) { OpenStruct.new(:ignore => []) }
+  let(:config) { OpenStruct.new(ignore: []) }
 
   let(:coalesced_columns) do
     <<-SQL.strip_heredoc.chomp
@@ -30,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
 
@@ -59,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
@@ -67,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
@@ -75,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

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 = double(: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 = double(: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 = double(: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 = double(: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 = double(: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 = double(: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 = double(:config, ignore: [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
@@ -153,7 +155,7 @@ 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 = {
           dictionary: "spanish",
@@ -163,7 +165,7 @@ describe PgSearch::Features::TSearch do
           }
         }
 
-        config = double(:config, :ignore => [])
+        config = double(:config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
@@ -193,7 +195,7 @@ describe PgSearch::Features::TSearch do
           }
         }
 
-        config = double(:config, :ignore => [])
+        config = double(:config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)
@@ -221,7 +223,7 @@ describe PgSearch::Features::TSearch do
           }
         }
 
-        config = double(:config, :ignore => [])
+        config = double(:config, ignore: [])
         normalizer = PgSearch::Normalizer.new(config)
 
         feature = described_class.new(query, options, columns, Model, normalizer)

data/spec/lib/pg_search/multisearch/rebuilder_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 def has_microsecond_precision?
@@ -8,7 +10,7 @@ end
 describe PgSearch::Multisearch::Rebuilder do
   with_table "pg_search_documents", {}, &DOCUMENTS_SCHEMA
 
-  describe 'when intialized with a model that is not multisearchable' do
+  describe 'when initialized with a model that is not multisearchable' do
     with_model :not_multisearchable
 
     it 'raises an exception' do
@@ -78,7 +80,7 @@ describe PgSearch::Multisearch::Rebuilder do
 
             model do
               include PgSearch
-              multisearchable :against => :name
+              multisearchable against: :name
             end
           end
 
@@ -112,7 +114,7 @@ describe PgSearch::Multisearch::Rebuilder do
               SELECT 'Model' AS searchable_type,
                      #{Model.quoted_table_name}.#{Model.primary_key} AS searchable_id,
                      (
-                       coalesce(#{Model.quoted_table_name}.name::text, '')
+                       coalesce(#{Model.quoted_table_name}."name"::text, '')
                      ) AS content,
                      '#{expected_timestamp}' AS created_at,
                      '#{expected_timestamp}' AS updated_at
@@ -132,6 +134,25 @@ describe PgSearch::Multisearch::Rebuilder do
             expect(executed_sql.first.strip).to eq(expected_sql.strip)
           end
 
+          context "for a model with a camel case column" do
+            with_model :ModelWithCamelCaseColumn do
+              table do |t|
+                t.string :camelName
+              end
+
+              model do
+                include PgSearch
+                multisearchable against: :name
+              end
+            end
+
+            it "creates search document without PG error" do
+              time = Time.utc(2001, 1, 1, 0, 0, 0)
+              rebuilder = PgSearch::Multisearch::Rebuilder.new(Model, -> { time })
+              rebuilder.rebuild
+            end
+          end
+
           context "for a model with a non-standard primary key" do
             with_model :ModelWithNonStandardPrimaryKey do
               table primary_key: :non_standard_primary_key do |t|
@@ -140,7 +161,7 @@ describe PgSearch::Multisearch::Rebuilder do
 
               model do
                 include PgSearch
-                multisearchable :against => :name
+                multisearchable against: :name
               end
             end
 
@@ -157,7 +178,7 @@ describe PgSearch::Multisearch::Rebuilder do
                 SELECT 'ModelWithNonStandardPrimaryKey' AS searchable_type,
                        #{ModelWithNonStandardPrimaryKey.quoted_table_name}.non_standard_primary_key AS searchable_id,
                        (
-                         coalesce(#{ModelWithNonStandardPrimaryKey.quoted_table_name}.name::text, '')
+                         coalesce(#{ModelWithNonStandardPrimaryKey.quoted_table_name}."name"::text, '')
                        ) AS content,
                        '#{expected_timestamp}' AS created_at,
                        '#{expected_timestamp}' AS updated_at
@@ -226,13 +247,13 @@ describe PgSearch::Multisearch::Rebuilder do
 
             model do
               include PgSearch
-              multisearchable :if => :active?
+              multisearchable if: :active?
             end
           end
 
           it "calls update_pg_search_document on each record" do
-            record_1 = Model.create!(:active => true)
-            record_2 = Model.create!(:active => false)
+            record_1 = Model.create!(active: true)
+            record_2 = Model.create!(active: false)
 
             rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
 
@@ -262,13 +283,13 @@ describe PgSearch::Multisearch::Rebuilder do
 
             model do
               include PgSearch
-              multisearchable :unless => :inactive?
+              multisearchable unless: :inactive?
             end
           end
 
           it "calls update_pg_search_document on each record" do
-            record_1 = Model.create!(:inactive => true)
-            record_2 = Model.create!(:inactive => false)
+            record_1 = Model.create!(inactive: true)
+            record_2 = Model.create!(inactive: false)
 
             rebuilder = PgSearch::Multisearch::Rebuilder.new(Model)
 

data/spec/lib/pg_search/multisearch_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe PgSearch::Multisearch do
@@ -20,7 +22,7 @@ describe PgSearch::Multisearch do
 
   describe ".rebuild" do
     before do
-      model.multisearchable :against => :title
+      model.multisearchable against: :title
     end
 
     it "should operate inside a transaction" do
@@ -96,8 +98,8 @@ describe PgSearch::Multisearch do
     describe "inserting the new documents" do
       let!(:new_models) { [] }
       before do
-        new_models << model.create!(:title => "Foo", :content => "Bar")
-        new_models << model.create!(:title => "Baz", :content => "Bar")
+        new_models << model.create!(title: "Foo", content: "Bar")
+        new_models << model.create!(title: "Baz", content: "Bar")
       end
 
       it "should create new documents for the two models" do
@@ -112,7 +114,7 @@ describe PgSearch::Multisearch do
 
       context "with one attribute" do
         before do
-          model.multisearchable :against => [:title]
+          model.multisearchable against: [:title]
         end
 
         it "should generate the proper SQL code" do
@@ -121,7 +123,7 @@ describe PgSearch::Multisearch do
               SELECT #{connection.quote(model.name)} AS searchable_type,
                      #{model.quoted_table_name}.id AS searchable_id,
                      (
-                       coalesce(#{model.quoted_table_name}.title::text, '')
+                       coalesce(#{model.quoted_table_name}."title"::text, '')
                      ) AS content,
                      #{connection.quote(connection.quoted_date(now))} AS created_at,
                      #{connection.quote(connection.quoted_date(now))} AS updated_at
@@ -139,7 +141,7 @@ describe PgSearch::Multisearch do
 
       context "with multiple attributes" do
         before do
-          model.multisearchable :against => %i[title content]
+          model.multisearchable against: %i[title content]
         end
 
         it "should generate the proper SQL code" do
@@ -148,7 +150,7 @@ describe PgSearch::Multisearch do
               SELECT #{connection.quote(model.name)} AS searchable_type,
                      #{model.quoted_table_name}.id AS searchable_id,
                      (
-                       coalesce(#{model.quoted_table_name}.title::text, '') || ' ' || coalesce(#{model.quoted_table_name}.content::text, '')
+                       coalesce(#{model.quoted_table_name}."title"::text, '') || ' ' || coalesce(#{model.quoted_table_name}."content"::text, '')
                      ) AS content,
                      #{connection.quote(connection.quoted_date(now))} AS created_at,
                      #{connection.quote(connection.quoted_date(now))} AS updated_at