pg_search 0.7.0 → 0.7.1

data/Rakefile

@@ -11,14 +11,3 @@ desc "Run all specs"
 task "spec" do
   bundle_exec("rspec spec")
 end
-
-task "doc" do
-  bundle_exec("rspec --format d spec")
-end
-
-namespace "doc" do
-  desc "Generate README and preview in browser"
-  task "readme" do
-    sh "rdoc -c utf8 README.rdoc && open doc/README_rdoc.html"
-  end
-end

data/lib/pg_search/features/trigram.rb

@@ -3,7 +3,7 @@ module PgSearch
     class Trigram < Feature
       def conditions
         Arel::Nodes::Grouping.new(
-          Arel::Nodes::InfixOperation.new("%", normalized_document, normalize(query))
+          Arel::Nodes::InfixOperation.new("%", normalized_document, normalized_query)
         )
       end
 
@@ -13,7 +13,7 @@ module PgSearch
             "similarity",
             [
               normalized_document,
-              normalize(query)
+              normalized_query
             ]
           )
         )
@@ -22,7 +22,12 @@ module PgSearch
       private
 
       def normalized_document
-        Arel::Nodes::Grouping.new(normalize(Arel.sql(document)))
+        Arel::Nodes::Grouping.new(Arel.sql(normalize(document)))
+      end
+
+      def normalized_query
+        sanitized_query = connection.quote(query)
+        Arel.sql(normalize(sanitized_query))
       end
     end
   end

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 end

data/pg_search.gemspec

@@ -23,11 +23,9 @@ Gem::Specification.new do |s|
   s.add_dependency 'arel'
 
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'rdoc'
   s.add_development_dependency 'pry'
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', '>= 2.14'
   s.add_development_dependency 'with_model'
-  s.add_development_dependency 'will_paginate'
 
   s.required_ruby_version = ">= 1.9.2"
 end

data/spec/integration/associations_spec.rb

@@ -467,4 +467,46 @@ describe PgSearch do
       results.should_not include(*excluded)
     end
   end
+
+  context "chained onto a has_many association" do
+    with_model :Company do
+      model do
+        has_many :positions
+      end
+    end
+
+    with_model :Position do
+      table do |t|
+        t.string :title
+        t.belongs_to :company
+      end
+
+      model do
+        include PgSearch
+        pg_search_scope :search, :against => :title, :using => [:tsearch, :trigram]
+      end
+    end
+
+    # https://github.com/Casecommons/pg_search/issues/106
+    it "should handle numbers in a trigram query properly" do
+      company = Company.create!
+      another_company = Company.create!
+
+      included = [
+        Position.create!(company_id: company.id, title: "teller 1"),
+        Position.create!(company_id: company.id, title: "teller 2") # close enough
+      ]
+
+      excluded = [
+        Position.create!(company_id: nil, title: "teller 1"),
+        Position.create!(company_id: another_company.id, title: "teller 1"),
+        Position.create!(company_id: company.id, title: "penn 1")
+      ]
+
+      results = company.positions.search('teller 1')
+
+      results.should include(*included)
+      results.should_not include(*excluded)
+    end
+  end
 end

data/spec/integration/pagination_spec.rb

@@ -1,8 +1,7 @@
 require "spec_helper"
 
 describe "pagination" do
-  describe "with will_paginate" do
-    require 'will_paginate/active_record'
+  describe "using LIMIT and OFFSET" do
     with_model :PaginatedModel do
       table do |t|
         t.string :name
@@ -10,8 +9,12 @@ describe "pagination" do
 
       model do
         include PgSearch
-        self.per_page = 2
         pg_search_scope :search_name, :against => :name
+
+        def self.page(page_number)
+          offset = (page_number - 1) * 2
+          limit(2).offset(offset)
+        end
       end
     end
 

data/spec/integration/pg_search_spec.rb

@@ -241,7 +241,7 @@ describe "an Active Record model which includes PgSearch" do
 
       it "accepts non-string queries and calls #to_s on them" do
         foo = ModelWithPgSearch.create!(:content => "foo")
-        not_a_string = stub(:to_s => "foo")
+        not_a_string = double(:to_s => "foo")
         ModelWithPgSearch.search_content(not_a_string).should == [foo]
       end
 
@@ -557,6 +557,11 @@ describe "an Active Record model which includes PgSearch" do
           :against => :title,
           :using => :trigram
 
+        ModelWithPgSearch.pg_search_scope :with_trigram_and_ignoring_accents,
+          :against => :title,
+          :ignoring => :accents,
+          :using => :trigram
+
         ModelWithPgSearch.pg_search_scope :with_tsearch_and_trigram,
           :against => :title,
           :using => [
@@ -566,6 +571,7 @@ describe "an Active Record model which includes PgSearch" do
 
         ModelWithPgSearch.pg_search_scope :complex_search,
           :against => [:content, :title],
+          :ignoring => :accents,
           :using => {
             :tsearch => {:dictionary => 'english'},
             :dmetaphone => {},
@@ -579,14 +585,26 @@ describe "an Active Record model which includes PgSearch" do
         # matches trigram only
         trigram_query = "ling is grouty"
         ModelWithPgSearch.with_trigram(trigram_query).should include(record)
+        ModelWithPgSearch.with_trigram_and_ignoring_accents(trigram_query).should include(record)
         ModelWithPgSearch.with_tsearch(trigram_query).should_not include(record)
         ModelWithPgSearch.with_tsearch_and_trigram(trigram_query).should == [record]
         ModelWithPgSearch.complex_search(trigram_query).should include(record)
 
+        # matches accent
+        # \303\266 is o with diaeresis
+        # \303\272 is u with acute accent
+        accent_query = "gr\303\266\303\272ty"
+        ModelWithPgSearch.with_trigram(accent_query).should_not include(record)
+        ModelWithPgSearch.with_trigram_and_ignoring_accents(accent_query).should include(record)
+        ModelWithPgSearch.with_tsearch(accent_query).should_not include(record)
+        ModelWithPgSearch.with_tsearch_and_trigram(accent_query).should be_empty
+        ModelWithPgSearch.complex_search(accent_query).should include(record)
+
         # matches tsearch only
         tsearch_query = "tiles"
         ModelWithPgSearch.with_tsearch(tsearch_query).should include(record)
         ModelWithPgSearch.with_trigram(tsearch_query).should_not include(record)
+        ModelWithPgSearch.with_trigram_and_ignoring_accents(tsearch_query).should_not include(record)
         ModelWithPgSearch.with_tsearch_and_trigram(tsearch_query).should == [record]
         ModelWithPgSearch.complex_search(tsearch_query).should include(record)
 
@@ -594,6 +612,7 @@ describe "an Active Record model which includes PgSearch" do
         dmetaphone_query = "tyling"
         ModelWithPgSearch.with_tsearch(dmetaphone_query).should_not include(record)
         ModelWithPgSearch.with_trigram(dmetaphone_query).should_not include(record)
+        ModelWithPgSearch.with_trigram_and_ignoring_accents(dmetaphone_query).should_not include(record)
         ModelWithPgSearch.with_tsearch_and_trigram(dmetaphone_query).should_not include(record)
         ModelWithPgSearch.complex_search(dmetaphone_query).should include(record)
       end
@@ -612,7 +631,7 @@ describe "an Active Record model which includes PgSearch" do
         end
 
         it "should pass the custom configuration down to the specified feature" do
-          stub_feature = stub(
+          stub_feature = double(
             :conditions => Arel::Nodes::Grouping.new(Arel.sql("1 = 1")),
             :rank => Arel::Nodes::Grouping.new(Arel.sql("1.0"))
           )

data/spec/lib/pg_search/document_spec.rb

@@ -28,7 +28,7 @@ describe PgSearch::Document do
         let(:multisearchable_options) { {:against => :some_content} }
         let(:text) { "foo bar" }
         before do
-          searchable.stub!(:some_content => text)
+          searchable.stub(:some_content => text)
           document.valid?
         end
 
@@ -38,7 +38,7 @@ describe PgSearch::Document do
       context "when searching against multiple columns" do
         let(:multisearchable_options) { {:against => [:attr1, :attr2]} }
         before do
-          searchable.stub!(:attr1 => "1", :attr2 => "2")
+          searchable.stub(:attr1 => "1", :attr2 => "2")
           document.valid?
         end
 

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

@@ -16,7 +16,7 @@ describe PgSearch::Features::DMetaphone do
         PgSearch::Configuration::Column.new(:content, nil, Model),
       ]
       options = {}
-      config = stub(:config, :ignore => [])
+      config = double(:config, :ignore => [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
@@ -40,7 +40,7 @@ describe PgSearch::Features::DMetaphone do
         PgSearch::Configuration::Column.new(:content, nil, Model),
       ]
       options = {}
-      config = stub(: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,26 +1,45 @@
-require "spec_helper"
+require 'spec_helper'
+require 'ostruct'
 
 describe PgSearch::Features::Trigram do
-  describe "#rank" do
-    with_model :Model do
-      table do |t|
-        t.string :name
-        t.text :content
+  subject(:feature) { described_class.new(query, options, columns, Model, normalizer) }
+  let(:query) { 'lolwut' }
+  let(:options) { {} }
+  let(:columns) {[
+    PgSearch::Configuration::Column.new(:name, nil, Model),
+    PgSearch::Configuration::Column.new(:content, nil, Model)
+  ]}
+  let(:normalizer) { PgSearch::Normalizer.new(config) }
+  let(:config) { OpenStruct.new(:ignore => [], :postgresql_version => 90000) }
+  let(:coalesced_colums) { %Q{coalesce(#{Model.quoted_table_name}."name"::text, '') || ' ' || \
+                           coalesce(#{Model.quoted_table_name}."content"::text, '')}.squeeze(' ') }
+
+  with_model :Model do
+    table do |t|
+      t.string :name
+      t.string :content
+    end
+  end
+
+  describe 'conditions' do
+    context 'paying attention to accents' do
+      it 'escapes the search document and query' do
+        config.ignore = []
+        expect(feature.conditions.to_sql).to eq("((#{coalesced_colums}) % '#{query}')")
       end
     end
 
-    it "returns an expression using the similarity() function" do
-      query = "query"
-      columns = [
-        PgSearch::Configuration::Column.new(:name, nil, Model),
-        PgSearch::Configuration::Column.new(:content, nil, Model),
-      ]
-      options = stub(:options)
-      config = stub(:config, :ignore => [])
-      normalizer = PgSearch::Normalizer.new(config)
+    context 'ignoring to 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_colums})) % unaccent('#{query}'))")
+      end
+    end
+  end
 
-      feature = described_class.new(query, options, columns, Model, normalizer)
-      feature.rank.to_sql.should == %Q{(similarity((coalesce(#{Model.quoted_table_name}."name"::text, '') || ' ' || coalesce(#{Model.quoted_table_name}."content"::text, '')), 'query'))}
+  describe '#rank' do
+    it 'returns an expression using the similarity() function' do
+      expect(feature.rank.to_sql).to eq("(similarity((#{coalesced_colums}), '#{query}'))")
     end
   end
 end

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

@@ -16,7 +16,7 @@ describe PgSearch::Features::TSearch do
         PgSearch::Configuration::Column.new(:content, nil, Model),
       ]
       options = {}
-      config = stub(:config, :ignore => [])
+      config = double(:config, :ignore => [])
       normalizer = PgSearch::Normalizer.new(config)
 
       feature = described_class.new(query, options, columns, Model, normalizer)
@@ -40,7 +40,7 @@ describe PgSearch::Features::TSearch do
         PgSearch::Configuration::Column.new(:content, nil, Model),
       ]
       options = {}
-      config = stub(: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

@@ -84,6 +84,22 @@ describe PgSearch::Multisearch::Rebuilder do
           time = DateTime.parse("2001-01-01")
           rebuilder = PgSearch::Multisearch::Rebuilder.new(Model, lambda { time } )
 
+          # Handle change in precision of DateTime objects in SQL in Active Record 4.0.1
+          # https://github.com/rails/rails/commit/17f5d8e062909f1fcae25351834d8e89967b645e
+          version_4_0_1_or_newer = (
+            (ActiveRecord::VERSION::MAJOR > 4) ||
+            (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR >= 1) ||
+            (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR == 0 && ActiveRecord::VERSION::TINY >= 1)
+          )
+
+          expected_timestamp =
+            if version_4_0_1_or_newer
+              "2001-01-01 00:00:00.000000"
+            else
+              "2001-01-01 00:00:00"
+            end
+
+
           expected_sql = <<-SQL.strip_heredoc
             INSERT INTO "pg_search_documents" (searchable_type, searchable_id, content, created_at, updated_at)
               SELECT 'Model' AS searchable_type,
@@ -91,8 +107,8 @@ describe PgSearch::Multisearch::Rebuilder do
                      (
                        coalesce(#{Model.quoted_table_name}.name::text, '')
                      ) AS content,
-                     '2001-01-01 00:00:00' AS created_at,
-                     '2001-01-01 00:00:00' AS updated_at
+                     '#{expected_timestamp}' AS created_at,
+                     '#{expected_timestamp}' AS updated_at
               FROM #{Model.quoted_table_name}
           SQL
 

data/spec/lib/pg_search/normalizer_spec.rb

@@ -6,7 +6,7 @@ describe PgSearch::Normalizer do
       context "when config[:ignore] includes :accents" do
         context "when passed an Arel node" do
           it "wraps the expression in unaccent()" do
-            config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
+            config = double("config", :ignore => [:accents], :postgresql_version => 90000)
             node = Arel::Nodes::NamedFunction.new("foo", ["bar"])
 
             normalizer = PgSearch::Normalizer.new(config)
@@ -18,7 +18,7 @@ describe PgSearch::Normalizer do
               PgSearch.stub(:unaccent_function).and_return("my_unaccent")
               node = Arel::Nodes::NamedFunction.new("foo", ["bar"])
 
-              config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
+              config = double("config", :ignore => [:accents], :postgresql_version => 90000)
 
               normalizer = PgSearch::Normalizer.new(config)
               normalizer.add_normalization(node).should == "my_unaccent(foo('bar'))"
@@ -28,7 +28,7 @@ describe PgSearch::Normalizer do
 
         context "when passed a String" do
           it "wraps the expression in unaccent()" do
-            config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
+            config = double("config", :ignore => [:accents], :postgresql_version => 90000)
 
             normalizer = PgSearch::Normalizer.new(config)
             normalizer.add_normalization("foo").should == "unaccent(foo)"
@@ -38,7 +38,7 @@ describe PgSearch::Normalizer do
             it "wraps the expression in that function" do
               PgSearch.stub(:unaccent_function).and_return("my_unaccent")
 
-              config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
+              config = double("config", :ignore => [:accents], :postgresql_version => 90000)
 
               normalizer = PgSearch::Normalizer.new(config)
               normalizer.add_normalization("foo").should == "my_unaccent(foo)"
@@ -49,7 +49,7 @@ describe PgSearch::Normalizer do
 
       context "when config[:ignore] does not include :accents" do
         it "passes the expression through" do
-          config = stub("config", :ignore => [], :postgresql_version => 90000)
+          config = double("config", :ignore => [], :postgresql_version => 90000)
 
           normalizer = PgSearch::Normalizer.new(config)
           normalizer.add_normalization("foo").should == "foo"
@@ -60,7 +60,7 @@ describe PgSearch::Normalizer do
     context "for PostgreSQL versions before 9.0" do
       context "when config[:ignore] includes :accents" do
         it "raises a NotSupportedForPostgresqlVersion exception" do
-          config = stub("config", :ignore => [:accents], :postgresql_version => 89999)
+          config = double("config", :ignore => [:accents], :postgresql_version => 89999)
 
           normalizer = PgSearch::Normalizer.new(config)
           expect {
@@ -71,7 +71,7 @@ describe PgSearch::Normalizer do
 
       context "when config[:ignore] does not include :accents" do
         it "passes the expression through" do
-          config = stub("config", :ignore => [], :postgresql_version => 90000)
+          config = double("config", :ignore => [], :postgresql_version => 90000)
 
           normalizer = PgSearch::Normalizer.new(config)
           normalizer.add_normalization("foo").should == "foo"

data/spec/spec_helper.rb

@@ -10,14 +10,12 @@ if ENV["TRAVIS"]
 end
 
 begin
-  require "pg"
-  error_class = PGError
-rescue
-  begin
-    require "arjdbc/jdbc/core_ext"
+  if defined? JRUBY_VERSION
+    require 'activerecord-jdbcpostgresql-adapter'
     error_class = ActiveRecord::JDBCError
-  rescue LoadError, StandardError
-    raise "I don't know what database adapter you're using, sorry."
+  else
+    require "pg"
+    error_class = PGError
   end
 end
 
@@ -35,7 +33,7 @@ begin
   connection = ActiveRecord::Base.connection
   postgresql_version = connection.send(:postgresql_version)
   connection.execute("SELECT 1")
-rescue error_class => e
+rescue error_class
   at_exit do
     puts "-" * 80
     puts "Unable to connect to database.  Please run:"
@@ -43,7 +41,7 @@ rescue error_class => e
     puts "    createdb pg_search_test"
     puts "-" * 80
   end
-  raise e
+  raise $!
 end
 
 if ENV["LOGGER"]