pg_search 0.5 → 0.5.1

data/.rvmrc

@@ -3,79 +3,50 @@
 # This is an RVM Project .rvmrc file, used to automatically load the ruby
 # development environment upon cd'ing into the directory
 
-# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
-environment_id="ree-1.8.7-2011.12@pg_search"
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-1.9.3-p194@pg_search"
 
-#
 # Uncomment the following lines if you want to verify rvm version per project
-#
-# rvmrc_rvm_version="1.10.2" # 1.10.1 seams as a safe start
+# rvmrc_rvm_version="1.12.4 ()" # 1.10.1 seams as a safe start
 # eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
 #   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
 #   return 1
 # }
-#
 
-#
-# Uncomment following line if you want options to be set only for given project.
-#
-# PROJECT_JRUBY_OPTS=( --1.9 )
-#
-# The variable PROJECT_JRUBY_OPTS requires the following to be run in shell:
-#
-#    chmod +x ${rvm_path}/hooks/after_use_jruby_opts
-#
-
-#
 # First we attempt to load the desired environment directly from the environment
 # file. This is very fast and efficient compared to running through the entire
 # CLI and selector. If you want feedback on which environment was used then
 # insert the word 'use' after --create as this triggers verbose mode.
-#
-if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
   && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
 then
   \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
-
-  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
-  then
-    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+  if [[ $- == *i* ]] # check for interactive shells
+  then echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+  else echo "Using: $GEM_HOME" # don't use colors in non-interactive shells
   fi
 else
   # If the environment file has not yet been created, use the RVM CLI to select.
-  if ! rvm --create use  "$environment_id"
-  then
+  rvm --create use  "$environment_id" || {
     echo "Failed to create RVM environment '${environment_id}'."
     return 1
-  fi
+  }
 fi
 
-#
-# If you use an RVM gemset file to install a list of gems (*.gems), you can have
-# it be automatically loaded. Uncomment the following and adjust the filename if
-# necessary.
-#
-# filename=".gems"
-# if [[ -s "$filename" ]]
-# then
-#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
-# fi
-
 # If you use bundler, this might be useful to you:
-# if [[ -s Gemfile ]] && ! command -v bundle >/dev/null
-# then
-#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
-#   gem install bundler
-# fi
-# if [[ -s Gemfile ]] && command -v bundle
-# then
-#   bundle install
-# fi
-
-if [[ $- == *i* ]] # check for interactive shells
+if [[ -s Gemfile ]] && {
+  ! builtin command -v bundle >/dev/null ||
+  builtin command -v bundle | grep $rvm_path/bin/bundle >/dev/null
+}
 then
-    echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
-else 
-	echo "Using: $GEM_HOME" # don't use colors in interactive shells
+  printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+  gem install bundler
+fi
+if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+then
+  bundle install | grep -vE '^Using|Your bundle is complete'
 fi
-

data/.travis.yml

@@ -1,2 +1,14 @@
+language: ruby
+
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+  - ree
+
 before_script:
   - "psql -c 'create database pg_search_test;' -U postgres >/dev/null"

data/CHANGELOG.rdoc

@@ -1,5 +1,9 @@
 = PgSearch
 
+== 0.5.1
+
+* Add ability to override multisearch rebuild SQL
+
 == 0.5
 
 * Convert migration rake tasks into generators.

data/Gemfile

@@ -4,7 +4,15 @@ gemspec
 
 gem "rake"
 gem "rdoc"
-gem "pg"
+
+platforms :ruby do
+  gem 'pg'
+end
+
+platforms :jruby do
+  gem "activerecord-jdbcpostgresql-adapter"
+end
+
 gem "rspec"
 gem "with_model"
 

data/README.rdoc

@@ -2,6 +2,8 @@
 
 * http://github.com/casecommons/pg_search/
 
+{<img src="https://secure.travis-ci.org/Casecommons/pg_search.png?branch=master" alt="Build Status" />}[http://travis-ci.org/Casecommons/pg_search] {<img src="https://gemnasium.com/Casecommons/pg_search.png" alt="Dependency Status" />}[https://gemnasium.com/Casecommons/pg_search] {<img src="https://codeclimate.com/badge.png" />}[https://codeclimate.com/github/Casecommons/pg_search]
+
 == DESCRIPTION
 
 PgSearch builds named scopes that take advantage of PostgreSQL's full text search
@@ -95,7 +97,7 @@ PgSearch.multisearch returns an ActiveRecord::Relation, just like scopes do, so
  PgSearch.multisearch("Bertha").limit(10)
  PgSearch.multisearch("Juggler").where(:searchable_type => "Occupation")
  PgSearch.multisearch("Alamo").page(3).per_page(30)
- PgSearch.mulitsearch("Diagonal").find_each do |document|
+ PgSearch.multisearch("Diagonal").find_each do |document|
    puts document.searchable.updated_at
  end
 
@@ -127,6 +129,39 @@ Currently this is only supported for :against methods that directly map to Activ
  PgSearch::Document.delete_all(:searchable_type => "Ingredient")
  Ingredient.find_each { |record| record.update_pg_search_document }
 
+
+You can also provide a custom implementation for rebuilding the documents by adding a class method called `rebuild_pg_search_documents` to your model.
+
+ class Movie < ActiveRecord::Base
+   belongs_to :director
+
+   def director_name
+     director.name
+   end
+
+   multisearchable against: [:name, :director_name]
+
+   # Naive approach
+   def self.rebuild_pg_search_documents
+     find_each { |record| record.update_pg_search_document }
+   end
+
+   # More sophisticated approach
+   def self.rebuild_pg_search_documents
+     connection.execute <<-SQL
+      INSERT INTO pg_search_documents (searchable_type, searchable_id, content, created_at, updated_at)
+        SELECT 'Movie' AS searchable_type,
+               movies.id AS searchable_id,
+               (movies.name || ' ' || directors.name) AS content,
+               now() AS created_at,
+               now() AS updated_at
+        FROM movies
+        LEFT JOIN directors
+          ON directors.id = movies.director_id
+     SQL
+   end
+ end
+
 ==== Disabling multi-search indexing temporarily
 
 If you have a large bulk operation to perform, such as importing a lot of records from an external source, you might want to speed things up by turning off indexing temporarily. You could then use one of the techniques above to rebuild the search documents off-line.
@@ -490,7 +525,7 @@ Please note that the :against column is only used when the tsvector_column is no
 
 * ActiveRecord 3
 * PostgreSQL
-* PostgreSQL contrib packages for certain features
+* {PostgreSQL contrib packages for certain features}[https://github.com/Casecommons/pg_search/wiki/Installing-Postgres-Contrib-Modules]
 
 == ATTRIBUTIONS
 

data/lib/pg_search/features/tsearch.rb

@@ -63,7 +63,8 @@ module PgSearch
 
       def tsdocument
         if @options[:tsvector_column]
-          @options[:tsvector_column].to_s
+          column_name = connection.quote_column_name(@options[:tsvector_column])
+          "#{quoted_table_name}.#{column_name}"
         else
           @columns.map do |search_column|
             tsvector = "to_tsvector(:dictionary, #{@normalizer.add_normalization(search_column.to_sql)})"

data/lib/pg_search/multisearch.rb

@@ -13,10 +13,14 @@ INSERT INTO :documents_table (searchable_type, searchable_id, content, created_a
 SQL
 
     class << self
-      def rebuild(model)
+      def rebuild(model, clean_up=true)
         model.transaction do
-          PgSearch::Document.where(:searchable_type => model.name).delete_all
-          model.connection.execute(rebuild_sql(model))
+          PgSearch::Document.where(:searchable_type => model.name).delete_all if clean_up
+          if model.respond_to?(:rebuild_pg_search_documents)
+            model.rebuild_pg_search_documents
+          else
+            model.connection.execute(rebuild_sql(model))
+          end
         end
       end
 

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.5"
+  VERSION = "0.5.1"
 end

data/spec/pg_search/multisearch_spec.rb

@@ -14,8 +14,96 @@ describe PgSearch::Multisearch do
     end
   end
 
+  let(:model) { MultisearchableModel }
+  let(:connection) { model.connection }
+  let(:documents) { double(:documents) }
+
   describe ".rebuild" do
-    it "should fetch the proper columns from the model" do
+    before do
+      model.multisearchable :against => :title
+    end
+
+    it "should operate inside a transaction" do
+      model.should_receive(:transaction).once
+
+      PgSearch::Multisearch.rebuild(model)
+    end
+
+    describe "cleaning up search documents for this model" do
+      before do
+        connection.execute <<-SQL
+          INSERT INTO pg_search_documents
+            (searchable_type, searchable_id, content, created_at, updated_at)
+            VALUES
+            ('#{model.name}', 123, 'foo', now(), now());
+          INSERT INTO pg_search_documents
+            (searchable_type, searchable_id, content, created_at, updated_at)
+            VALUES
+            ('Bar', 123, 'foo', now(), now());
+        SQL
+        PgSearch::Document.count.should == 2
+      end
+
+      context "when clean_up is not passed" do
+        it "should delete the document for the model" do
+          PgSearch::Multisearch.rebuild(model)
+          PgSearch::Document.count.should == 1
+          PgSearch::Document.first.searchable_type.should == "Bar"
+        end
+      end
+
+      context "when clean_up is true" do
+        let(:clean_up) { true }
+
+        it "should delete the document for the model" do
+          PgSearch::Multisearch.rebuild(model, clean_up)
+          PgSearch::Document.count.should == 1
+          PgSearch::Document.first.searchable_type.should == "Bar"
+        end
+      end
+
+      context "when clean_up is false" do
+        let(:clean_up) { false }
+
+        it "should not delete the document for the model" do
+          PgSearch::Multisearch.rebuild(model, clean_up)
+          PgSearch::Document.count.should == 2
+        end
+      end
+
+      context "when the model implements .rebuild_pg_search_documents" do
+        before do
+          def model.rebuild_pg_search_documents
+            connection.execute <<-SQL
+              INSERT INTO pg_search_documents
+                (searchable_type, searchable_id, content, created_at, updated_at)
+                VALUES
+                ('Baz', 789, 'baz', now(), now());
+            SQL
+          end
+        end
+
+        it "should call .rebuild_pg_search_documents and skip the default behavior" do
+          PgSearch::Multisearch.should_not_receive(:rebuild_sql)
+          PgSearch::Multisearch.rebuild(model)
+
+          record = PgSearch::Document.find_by_searchable_type_and_searchable_id("Baz", 789)
+          record.content.should == "baz"
+        end
+      end
+    end
+
+    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")
+      end
+
+      it "should create new documents for the two models" do
+        PgSearch::Multisearch.rebuild(model)
+        PgSearch::Document.last(2).map(&:searchable).map(&:title).should =~ new_models.map(&:title)
+      end
     end
   end
 
@@ -27,12 +115,11 @@ describe PgSearch::Multisearch do
     end
 
     context "with one attribute" do
-      it "should generate the proper SQL code" do
-        model = MultisearchableModel
-        connection = model.connection
-
-        model.multisearchable :against => :title
+      before do
+        model.multisearchable :against => [:title]
+      end
 
+      it "should generate the proper SQL code" do
         expected_sql = <<-SQL
 INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable_id, content, created_at, updated_at)
   SELECT #{connection.quote(model.name)} AS searchable_type,
@@ -43,19 +130,18 @@ INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable
          #{connection.quote(connection.quoted_date(now))} AS created_at,
          #{connection.quote(connection.quoted_date(now))} AS updated_at
   FROM #{model.quoted_table_name}
-SQL
+  SQL
 
-        PgSearch::Multisearch.rebuild_sql(MultisearchableModel).should == expected_sql
+        PgSearch::Multisearch.rebuild_sql(model).should == expected_sql
       end
     end
 
     context "with multiple attributes" do
-      it "should generate the proper SQL code" do
-        model = MultisearchableModel
-        connection = model.connection
-
+      before do
         model.multisearchable :against => [:title, :content]
+      end
 
+      it "should generate the proper SQL code" do
         expected_sql = <<-SQL
 INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable_id, content, created_at, updated_at)
   SELECT #{connection.quote(model.name)} AS searchable_type,
@@ -66,11 +152,10 @@ INSERT INTO #{PgSearch::Document.quoted_table_name} (searchable_type, searchable
          #{connection.quote(connection.quoted_date(now))} AS created_at,
          #{connection.quote(connection.quoted_date(now))} AS updated_at
   FROM #{model.quoted_table_name}
-SQL
+  SQL
 
-        PgSearch::Multisearch.rebuild_sql(MultisearchableModel).should == expected_sql
+        PgSearch::Multisearch.rebuild_sql(model).should == expected_sql
       end
     end
-
   end
 end

data/spec/pg_search_spec.rb

@@ -610,7 +610,7 @@ describe "an ActiveRecord model which includes PgSearch" do
     end
 
     context "using a tsvector column" do
-      with_model :ModelWithPgSearchUsingTsVectorColumn do
+      with_model :ModelWithTsvector do
         table do |t|
           t.text 'content'
           t.tsvector 'content_tsvector'
@@ -619,16 +619,16 @@ describe "an ActiveRecord model which includes PgSearch" do
         model { include PgSearch }
       end
 
-      let!(:expected) { ModelWithPgSearchUsingTsVectorColumn.create!(:content => 'tiling is grouty') }
-      let!(:unexpected) { ModelWithPgSearchUsingTsVectorColumn.create!(:content => 'longcat is looooooooong') }
+      let!(:expected) { ModelWithTsvector.create!(:content => 'tiling is grouty') }
+      let!(:unexpected) { ModelWithTsvector.create!(:content => 'longcat is looooooooong') }
 
       before do
         ActiveRecord::Base.connection.execute <<-SQL
-          UPDATE #{ModelWithPgSearchUsingTsVectorColumn.table_name}
-          SET content_tsvector = to_tsvector('english'::regconfig, "#{ModelWithPgSearchUsingTsVectorColumn.table_name}"."content")
+          UPDATE #{ModelWithTsvector.table_name}
+          SET content_tsvector = to_tsvector('english'::regconfig, "#{ModelWithTsvector.table_name}"."content")
         SQL
 
-        ModelWithPgSearchUsingTsVectorColumn.pg_search_scope :search_by_content_with_tsvector,
+        ModelWithTsvector.pg_search_scope :search_by_content_with_tsvector,
           :against => :content,
           :using => {
             :tsearch => {
@@ -639,11 +639,30 @@ describe "an ActiveRecord model which includes PgSearch" do
       end
 
       it "should not use to_tsvector in the query" do
-        ModelWithPgSearchUsingTsVectorColumn.search_by_content_with_tsvector("tiles").to_sql.should_not =~ /to_tsvector/
+        ModelWithTsvector.search_by_content_with_tsvector("tiles").to_sql.should_not =~ /to_tsvector/
       end
 
       it "should find the expected result" do
-        ModelWithPgSearchUsingTsVectorColumn.search_by_content_with_tsvector("tiles").map(&:id).should == [expected.id]
+        ModelWithTsvector.search_by_content_with_tsvector("tiles").map(&:id).should == [expected.id]
+      end
+
+      context "when joining to a table with a column of the same name" do
+        with_model :AnotherModel do
+          table do |t|
+            t.string :content_tsvector # the type of the column doesn't matter
+            t.belongs_to :model_with_tsvector
+          end
+        end
+
+        before do
+          ModelWithTsvector.has_many :another_models
+        end
+
+        it "should refer to the tsvector column in the query unambiguously" do
+          expect {
+            ModelWithTsvector.joins(:another_models).search_by_content_with_tsvector("test").all
+          }.not_to raise_exception
+        end
       end
     end
 

data/spec/spec_helper.rb

@@ -2,14 +2,32 @@ require "bundler/setup"
 require "pg_search"
 
 begin
+  require "pg"
+  error_class = PGError
+rescue
+  begin
+    require "arjdbc/jdbc/core_ext"
+    error_class = ActiveRecord::JDBCError
+  rescue LoadError, StandardError
+    raise "I don't know what database adapter you're using, sorry."
+  end
+end
+
+begin
+  database_user = if ENV["TRAVIS"]
+                    "postgres"
+                  else
+                    ENV["USER"]
+                  end
+
   ActiveRecord::Base.establish_connection(:adapter  => 'postgresql',
                                           :database => 'pg_search_test',
-                                          :username => ('postgres' if ENV["TRAVIS"]),
+                                          :username => database_user,
                                           :min_messages => 'warning')
   connection = ActiveRecord::Base.connection
   postgresql_version = connection.send(:postgresql_version)
   connection.execute("SELECT 1")
-rescue PGError => e
+rescue error_class => e
   puts "-" * 80
   puts "Unable to connect to database.  Please run:"
   puts
@@ -70,6 +88,7 @@ RSpec::Matchers::OperatorMatcher.register(ActiveRecord::Relation, '=~', RSpec::M
 DOCUMENTS_SCHEMA = lambda do |t|
   t.belongs_to :searchable, :polymorphic => true
   t.text :content
+  t.timestamps
 end
 
 require 'irb'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_search
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: 0.5.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-13 00:00:00.000000000 Z
+date: 2012-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -109,12 +109,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1351986722427483921
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1351986722427483921
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24