pg_search 1.0.6 → 2.0.0

data/lib/pg_search/features/tsearch.rb

@@ -1,4 +1,3 @@
-require "pg_search/compatibility"
 require "active_support/core_ext/module/delegation"
 
 module PgSearch
@@ -8,12 +7,6 @@ module PgSearch
         super + [:dictionary, :prefix, :negation, :any_word, :normalization, :tsvector_column, :highlight]
       end
 
-      def initialize(*args)
-        super
-        checks_for_highlight
-        checks_for_prefix
-      end
-
       def conditions
         Arel::Nodes::Grouping.new(
           Arel::Nodes::InfixOperation.new("@@", arel_wrap(tsdocument), arel_wrap(tsquery))
@@ -30,22 +23,6 @@ module PgSearch
 
       private
 
-      def checks_for_prefix
-        if options[:prefix] && model.connection.send(:postgresql_version) < 80400
-          raise PgSearch::NotSupportedForPostgresqlVersion.new(<<-MESSAGE.strip_heredoc)
-            Sorry, {:using => {:tsearch => {:prefix => true}}} only works in PostgreSQL 8.4 and above.")
-          MESSAGE
-        end
-      end
-
-      def checks_for_highlight
-        if options[:highlight] && model.connection.send(:postgresql_version) < 90000
-          raise PgSearch::NotSupportedForPostgresqlVersion.new(<<-MESSAGE.strip_heredoc)
-            Sorry, {:using => {:tsearch => {:highlight => true}}} only works in PostgreSQL 9.0 and above.")
-          MESSAGE
-        end
-      end
-
       def ts_headline
         "ts_headline((#{document}), (#{tsquery}), '#{ts_headline_options}')"
       end
@@ -81,15 +58,15 @@ module PgSearch
         # If :prefix is true, then the term will have :* appended to the end.
         # If :negated is true, then the term will have ! prepended to the front.
         terms = [
-          (Compatibility.build_quoted('!') if negated),
-          Compatibility.build_quoted("' "),
+          (Arel::Nodes.build_quoted('!') if negated),
+          Arel::Nodes.build_quoted("' "),
           term_sql,
-          Compatibility.build_quoted(" '"),
-          (Compatibility.build_quoted(":*") if options[:prefix])
+          Arel::Nodes.build_quoted(" '"),
+          (Arel::Nodes.build_quoted(":*") if options[:prefix])
         ].compact
 
         tsquery_sql = terms.inject do |memo, term|
-          Arel::Nodes::InfixOperation.new("||", memo, Compatibility.build_quoted(term))
+          Arel::Nodes::InfixOperation.new("||", memo, Arel::Nodes.build_quoted(term))
         end
 
         Arel::Nodes::NamedFunction.new(
@@ -141,7 +118,7 @@ module PgSearch
       end
 
       def dictionary
-        Compatibility.build_quoted(options[:dictionary] || :simple)
+        Arel::Nodes.build_quoted(options[:dictionary] || :simple)
       end
 
       def arel_wrap(sql_string)

data/lib/pg_search/migration/templates/add_pg_search_dmetaphone_support_functions.rb.erb

@@ -1,12 +1,6 @@
 class AddPgSearchDmetaphoneSupportFunctions < ActiveRecord::Migration
   def self.up
     say_with_time("Adding support functions for pg_search :dmetaphone") do
-      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
-        execute <<-'SQL'
-<%= read_sql_file "unnest" %>
-        SQL
-      end
-
       execute <<-'SQL'
 <%= read_sql_file "dmetaphone" %>
       SQL
@@ -18,12 +12,6 @@ class AddPgSearchDmetaphoneSupportFunctions < ActiveRecord::Migration
       execute <<-'SQL'
 <%= read_sql_file "uninstall_dmetaphone" %>
       SQL
-
-      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
-        execute <<-'SQL'
-<%= read_sql_file "uninstall_unnest" %>
-        SQL
-      end
     end
   end
 end

data/lib/pg_search/normalizer.rb

@@ -4,16 +4,9 @@ module PgSearch
       @config = config
     end
 
-    def add_normalization(sql_expression) # rubocop:disable Metrics/AbcSize
+    def add_normalization(sql_expression)
       return sql_expression unless config.ignore.include?(:accents)
 
-      if config.postgresql_version < 90000
-        raise PgSearch::NotSupportedForPostgresqlVersion.new(<<-MESSAGE.strip_heredoc)
-          Sorry, {:ignoring => :accents} only works in PostgreSQL 9.0 and above.
-          #{config.inspect}
-        MESSAGE
-      end
-
       sql_node = case sql_expression
                  when Arel::Nodes::Node
                    sql_expression

data/lib/pg_search/scope_options.rb

@@ -79,6 +79,7 @@ module PgSearch
       private
 
       attr_writer :pg_search_scope_application_count
+
       def pg_search_scope_application_count
         @pg_search_scope_application_count ||= 0
       end
@@ -171,12 +172,9 @@ module PgSearch
     end
 
     def include_table_aliasing_for_rank(scope)
-      if scope.included_modules.include?(PgSearchRankTableAliasing)
-        scope
-      else
-        (::ActiveRecord::VERSION::MAJOR < 4 ? scope.scoped : scope.all.spawn).tap do |new_scope|
-          new_scope.class_eval { include PgSearchRankTableAliasing }
-        end
+      return scope if scope.included_modules.include?(PgSearchRankTableAliasing)
+      scope.all.spawn.tap do |new_scope|
+        new_scope.class_eval { include PgSearchRankTableAliasing }
       end
     end
   end

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "1.0.6".freeze
+  VERSION = "2.0.0".freeze
 end

data/pg_search.gemspec

@@ -1,31 +1,33 @@
 # -*- encoding: utf-8 -*-
 $LOAD_PATH.push File.expand_path('../lib', __FILE__)
-require "pg_search/version"
+require 'pg_search/version'
 
 Gem::Specification.new do |s|
-  s.name        = "pg_search"
+  s.name        = 'pg_search'
   s.version     = PgSearch::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Grant Hutchins", "Case Commons, LLC"]
-  s.email       = ["gems@nertzy.com", "casecommons-dev@googlegroups.com"]
-  s.homepage    = "https://github.com/Casecommons/pg_search"
+  s.authors     = ['Grant Hutchins', 'Case Commons, LLC']
+  s.email       = %w[gems@nertzy.com casecommons-dev@googlegroups.com]
+  s.homepage    = 'https://github.com/Casecommons/pg_search'
   s.summary     = %q(PgSearch builds Active Record named scopes that take advantage of PostgreSQL's full text search)
   s.description = %q(PgSearch builds Active Record named scopes that take advantage of PostgreSQL's full text search)
-  s.licenses    = ["MIT"]
+  s.licenses    = ['MIT']
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.require_paths = ["lib"]
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ['lib']
 
-  s.add_dependency 'activerecord', '>= 3.1'
-  s.add_dependency 'activesupport', '>= 3.1'
-  s.add_dependency 'arel'
+  s.add_dependency 'activerecord', '>= 4.2'
+  s.add_dependency 'activesupport', '>= 4.2'
+  s.add_dependency 'arel', '>= 6'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'pry'
   s.add_development_dependency 'rspec', '>= 3.3'
   s.add_development_dependency 'with_model', '>= 1.2'
   s.add_development_dependency 'rubocop', '>= 0.36'
+  s.add_development_dependency 'codeclimate-test-reporter'
+  s.add_development_dependency 'simplecov'
 
-  s.required_ruby_version = ">= 1.9.2"
+  s.required_ruby_version = '>= 2.1'
 end

data/spec/integration/associations_spec.rb

@@ -12,7 +12,7 @@ describe PgSearch do
       with_model :ModelWithoutAgainst do
         table do |t|
           t.string "title"
-          t.belongs_to :another_model
+          t.belongs_to :another_model, :index => false
         end
 
         model do
@@ -49,7 +49,7 @@ describe PgSearch do
       with_model :ModelWithBelongsTo do
         table do |t|
           t.string 'title'
-          t.belongs_to 'another_model'
+          t.belongs_to 'another_model', index: false
         end
 
         model do
@@ -79,7 +79,7 @@ describe PgSearch do
       with_model :AssociatedModelWithHasMany do
         table do |t|
           t.string 'title'
-          t.belongs_to 'ModelWithHasMany'
+          t.belongs_to 'ModelWithHasMany', index: false
         end
       end
 
@@ -144,22 +144,20 @@ describe PgSearch do
         with_model :FirstAssociatedModel do
           table do |t|
             t.string 'title'
-            t.belongs_to 'ModelWithManyAssociations'
+            t.belongs_to 'ModelWithManyAssociations', index: false
           end
-          model {}
         end
 
         with_model :SecondAssociatedModel do
           table do |t|
             t.string 'title'
           end
-          model {}
         end
 
         with_model :ModelWithManyAssociations do
           table do |t|
             t.string 'title'
-            t.belongs_to 'model_of_second_type'
+            t.belongs_to 'model_of_second_type', index: false
           end
 
           model do
@@ -211,10 +209,9 @@ describe PgSearch do
         with_model :DoublyAssociatedModel do
           table do |t|
             t.string 'title'
-            t.belongs_to 'ModelWithDoubleAssociation'
-            t.belongs_to 'ModelWithDoubleAssociation_again'
+            t.belongs_to 'ModelWithDoubleAssociation', index: false
+            t.belongs_to 'ModelWithDoubleAssociation_again', index: false
           end
-          model {}
         end
 
         with_model :ModelWithDoubleAssociation do
@@ -279,7 +276,7 @@ describe PgSearch do
 
       with_model :ModelWithAssociation do
         table do |t|
-          t.belongs_to 'another_model'
+          t.belongs_to 'another_model', index: false
         end
 
         model do
@@ -406,7 +403,7 @@ describe PgSearch do
     with_model :AssociatedModel do
       table do |t|
         t.string :content
-        t.belongs_to :model_with_association
+        t.belongs_to :model_with_association, index: false
       end
 
       model do

data/spec/integration/pg_search_spec.rb

@@ -329,14 +329,12 @@ describe "an Active Record model which includes PgSearch" do
         expect(returned_record.attributes).to eq("id" => record.id)
       end
 
-      unless ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 2
-        it "supports #pluck" do
-          record = ModelWithPgSearch.create!(:content => 'foo')
-          other_record = ModelWithPgSearch.create!(:content => 'bar')
+      it "supports #pluck" do
+        record = ModelWithPgSearch.create!(:content => 'foo')
+        other_record = ModelWithPgSearch.create!(:content => 'bar')
 
-          ids = ModelWithPgSearch.search_content('foo').pluck('id')
-          expect(ids).to eq [record.id]
-        end
+        ids = ModelWithPgSearch.search_content('foo').pluck('id')
+        expect(ids).to eq [record.id]
       end
 
       it "supports adding where clauses using the pg_search.rank" do
@@ -407,10 +405,10 @@ describe "an Active Record model which includes PgSearch" do
       end
 
       it 'allows pg_search_rank along with a join' do
-        parent1 = ParentModel.create!(id: 98)
-        parent2 = ParentModel.create!(id: 99)
-        loser = ModelWithPgSearch.create!(:content => 'foo', parent_model: parent2)
-        winner = ModelWithPgSearch.create!(:content => 'foo foo', parent_model: parent1)
+        parent_1 = ParentModel.create!(id: 98)
+        parent_2 = ParentModel.create!(id: 99)
+        loser = ModelWithPgSearch.create!(:content => 'foo', parent_model: parent_2)
+        winner = ModelWithPgSearch.create!(:content => 'foo foo', parent_model: parent_1)
 
         results = ModelWithPgSearch.joins(:parent_model).merge(ParentModel.active).search_content("foo").with_pg_search_rank
         expect(results.map(&:id)).to eq [winner.id, loser.id]
@@ -571,31 +569,23 @@ describe "an Active Record model which includes PgSearch" do
           }
       end
 
-      if ActiveRecord::Base.connection.send(:postgresql_version) < 80400
-        it "is unsupported in PostgreSQL 8.3 and earlier" do
-          expect {
-            ModelWithPgSearch.search_title_with_prefixes("abcd\303\251f")
-          }.to raise_exception(PgSearch::NotSupportedForPostgresqlVersion)
+      context "with :prefix => true" do
+        it "returns rows that match the query and that are prefixed by the query" do
+          included = ModelWithPgSearch.create!(:title => 'prefix')
+          excluded = ModelWithPgSearch.create!(:title => 'postfix')
+
+          results = ModelWithPgSearch.search_title_with_prefixes("pre")
+          expect(results).to eq([included])
+          expect(results).not_to include(excluded)
         end
-      else
-        context "with :prefix => true" do
-          it "returns rows that match the query and that are prefixed by the query" do
-            included = ModelWithPgSearch.create!(:title => 'prefix')
-            excluded = ModelWithPgSearch.create!(:title => 'postfix')
-
-            results = ModelWithPgSearch.search_title_with_prefixes("pre")
-            expect(results).to eq([included])
-            expect(results).not_to include(excluded)
-          end
 
-          it "returns rows that match the query when the query has a hyphen" do
-            included = ModelWithPgSearch.create!(:title => 'foo-bar')
-            excluded = ModelWithPgSearch.create!(:title => 'foo bar')
+        it "returns rows that match the query when the query has a hyphen" do
+          included = ModelWithPgSearch.create!(:title => 'foo-bar')
+          excluded = ModelWithPgSearch.create!(:title => 'foo bar')
 
-            results = ModelWithPgSearch.search_title_with_prefixes("foo-bar")
-            expect(results).to include(included)
-            expect(results).not_to include(excluded)
-          end
+          results = ModelWithPgSearch.search_title_with_prefixes("foo-bar")
+          expect(results).to include(included)
+          expect(results).not_to include(excluded)
         end
       end
 
@@ -1104,22 +1094,14 @@ describe "an Active Record model which includes PgSearch" do
           :ignoring => :accents
       end
 
-      if ActiveRecord::Base.connection.send(:postgresql_version) < 90000
-        it "is unsupported in PostgreSQL 8.x" do
-          expect {
-            ModelWithPgSearch.search_title_without_accents("abcd\303\251f")
-          }.to raise_exception(PgSearch::NotSupportedForPostgresqlVersion)
-        end
-      else
-        it "returns rows that match the query but not its accents" do
-          # \303\241 is a with acute accent
-          # \303\251 is e with acute accent
+      it "returns rows that match the query but not its accents" do
+        # \303\241 is a with acute accent
+        # \303\251 is e with acute accent
 
-          included = ModelWithPgSearch.create!(:title => "\303\241bcdef")
+        included = ModelWithPgSearch.create!(:title => "\303\241bcdef")
 
-          results = ModelWithPgSearch.search_title_without_accents("abcd\303\251f")
-          expect(results).to eq([included])
-        end
+        results = ModelWithPgSearch.search_title_without_accents("abcd\303\251f")
+        expect(results).to eq([included])
       end
     end
 
@@ -1222,7 +1204,7 @@ describe "an Active Record model which includes PgSearch" do
           twice = ModelWithPgSearch.create!(:content => 'foo foo')
 
           results = ModelWithPgSearch.search_content_ranked_by_tsearch('foo')
-          expect(results.index(twice)).to be < results.index(once)
+          expect(results.find_index(twice)).to be < results.find_index(once)
         end
       end
 
@@ -1237,7 +1219,7 @@ describe "an Active Record model which includes PgSearch" do
           exact = ModelWithPgSearch.create!(:content => 'abc')
 
           results = ModelWithPgSearch.search_content_ranked_by_trigram('abc')
-          expect(results.index(exact)).to be < results.index(close)
+          expect(results.find_index(exact)).to be < results.find_index(close)
         end
       end
 
@@ -1252,7 +1234,7 @@ describe "an Active Record model which includes PgSearch" do
           twice = ModelWithPgSearch.create!(:content => 'Phoo Fu')
 
           results = ModelWithPgSearch.search_content_ranked_by_dmetaphone('foo')
-          expect(results.index(twice)).to be < results.index(once)
+          expect(results.find_index(twice)).to be < results.find_index(once)
         end
       end
     end

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

@@ -1,76 +1,138 @@
 require "spec_helper"
 
 describe PgSearch::Configuration::Association do
-  with_model :AssociatedModel do
+  with_model :Avatar do
     table do |t|
-      t.string "title"
+      t.string :url
+      t.references :user
     end
   end
 
-  with_model :Model do
+  with_model :User do
     table do |t|
-      t.string "title"
-      t.belongs_to :another_model
+      t.string :name
+      t.belongs_to :site
     end
 
     model do
       include PgSearch
-      belongs_to :another_model, :class_name => 'AssociatedModel'
+      has_one :avatar, :class_name => "Avatar"
+      belongs_to :site
 
-      pg_search_scope :with_another, :associated_against => {:another_model => :title}
+      pg_search_scope :with_avatar, :associated_against => {:avatar => :url}
+      pg_search_scope :with_site, :associated_against => {:site => :title}
     end
   end
 
-  let(:association) { described_class.new(Model, :another_model, :title) }
+  with_model :Site do
+    table do |t|
+      t.string :title
+    end
 
-  describe "#table_name" do
-    it "returns the table name for the associated model" do
-      expect(association.table_name).to eq AssociatedModel.table_name
+    model do
+      include PgSearch
+      has_many :users, :class_name => "User"
+
+      pg_search_scope :with_users, :associated_against => {:users => :name}
     end
   end
 
-  describe "#join" do
-    let(:expected_sql) do
-      <<-EOS.gsub(/\s+/, ' ').strip
-        LEFT OUTER JOIN
-          (SELECT model_id AS id,
-                  #{column_select} AS #{association.columns.first.alias}
-          FROM \"#{Model.table_name}\"
-          INNER JOIN \"#{association.table_name}\"
-          ON \"#{association.table_name}\".\"id\" = \"#{Model.table_name}\".\"another_model_id\"
-          GROUP BY model_id) #{association.subselect_alias}
-        ON #{association.subselect_alias}.id = model_id
-      EOS
+  context "has_one" do
+    let(:association) { described_class.new(User, :avatar, :url) }
+
+    describe "#table_name" do
+      it "returns the table name for the associated model" do
+        expect(association.table_name).to eq Avatar.table_name
+      end
     end
 
-    context "given postgresql_version 0..90_000" do
+    describe "#join" do
+      let(:expected_sql) do
+        <<-EOS.gsub(/\s+/, ' ').strip
+          LEFT OUTER JOIN
+            (SELECT model_id AS id,
+                    #{column_select} AS #{association.columns.first.alias}
+            FROM \"#{User.table_name}\"
+            INNER JOIN \"#{association.table_name}\"
+            ON \"#{association.table_name}\".\"user_id\" = \"#{User.table_name}\".\"id\") #{association.subselect_alias}
+          ON #{association.subselect_alias}.id = model_id
+        EOS
+      end
       let(:column_select) do
-        "array_to_string(array_agg(\"#{association.table_name}\".\"title\"::text), ' ')"
+        "\"#{association.table_name}\".\"url\"::text"
       end
 
       it "returns the correct SQL join" do
-        allow(Model.connection).to receive(:postgresql_version).and_return(1)
         expect(association.join("model_id")).to eq(expected_sql)
       end
     end
+  end
+
+  context "belongs_to" do
+    let(:association) { described_class.new(User, :site, :title) }
+
+    describe "#table_name" do
+      it "returns the table name for the associated model" do
+        expect(association.table_name).to eq Site.table_name
+      end
+    end
 
-    context "given any other postgresql_version" do
+    describe "#join" do
+      let(:expected_sql) do
+        <<-EOS.gsub(/\s+/, ' ').strip
+          LEFT OUTER JOIN
+            (SELECT model_id AS id,
+                    #{column_select} AS #{association.columns.first.alias}
+            FROM \"#{User.table_name}\"
+            INNER JOIN \"#{association.table_name}\"
+            ON \"#{association.table_name}\".\"id\" = \"#{User.table_name}\".\"site_id\") #{association.subselect_alias}
+          ON #{association.subselect_alias}.id = model_id
+        EOS
+      end
       let(:column_select) do
-        "string_agg(\"#{association.table_name}\".\"title\"::text, ' ')"
+        "\"#{association.table_name}\".\"title\"::text"
       end
 
       it "returns the correct SQL join" do
-        allow(Model.connection).to receive(:postgresql_version).and_return(100_000)
         expect(association.join("model_id")).to eq(expected_sql)
       end
     end
   end
 
-  describe "#subselect_alias" do
-    it "returns a consistent string" do
-      subselect_alias = association.subselect_alias
-      expect(subselect_alias).to be_a String
-      expect(association.subselect_alias).to eq subselect_alias
+  context "has_many" do
+    let(:association) { described_class.new(Site, :users, :name) }
+
+    describe "#table_name" do
+      it "returns the table name for the associated model" do
+        expect(association.table_name).to eq User.table_name
+      end
+    end
+
+    describe "#join" do
+      let(:expected_sql) do
+        <<-EOS.gsub(/\s+/, ' ').strip
+          LEFT OUTER JOIN
+            (SELECT model_id AS id,
+                    string_agg(\"#{association.table_name}\".\"name\"::text, ' ') AS #{association.columns.first.alias}
+            FROM \"#{Site.table_name}\"
+            INNER JOIN \"#{association.table_name}\"
+            ON \"#{association.table_name}\".\"site_id\" = \"#{Site.table_name}\".\"id\"
+            GROUP BY model_id) #{association.subselect_alias}
+          ON #{association.subselect_alias}.id = model_id
+        EOS
+      end
+
+      it "returns the correct SQL join" do
+        expect(association.join("model_id")).to eq(expected_sql)
+      end
+
+      describe "#subselect_alias" do
+        it "returns a consistent string" do
+          subselect_alias = association.subselect_alias
+          expect(subselect_alias).to be_a String
+          expect(association.subselect_alias).to eq subselect_alias
+        end
+      end
     end
   end
 end