pg_search 0.1.1 → 0.2

data/CHANGELOG

@@ -1,18 +1,32 @@
+### 0.2
+
+ * Set dictionary to :simple by default for :tsearch. Before it was unset,
+   which would fall back to PostgreSQL's default dictionary, usually
+   "english".
+
+ * Fix a bug with search strings containing a colon ":"
+
+ * Improve performance of :associated_against by only doing one INNER JOIN per
+   association
+
 ### 0.1.1
 
-Fix a bug with dmetaphone searches containing " w " (which dmetaphone maps to
-an empty string)
+ * Fix a bug with dmetaphone searches containing " w " (which dmetaphone maps
+   to an empty string)
 
 ### 0.1
 
-Change API to {:ignoring => :accents} from {:normalizing => :diacritics}
-Improve documentation
-Fix bug where :associated_against would not work without an :against present
+ * Change API to {:ignoring => :accents} from {:normalizing => :diacritics}
+
+ * Improve documentation
+
+ * Fix bug where :associated_against would not work without an :against
+   present
 
 ### 0.0.2
 
-Fix gem ownership.
+ * Fix gem ownership.
 
 ### 0.0.1
 
-Initial release.
+ * Initial release.

data/README.rdoc

@@ -6,6 +6,8 @@
 
 PgSearch builds named scopes that take advantage of PostgreSQL's full text search
 
+Read the blog post introducing PgSearch at http://bit.ly/pg_search
+
 == INSTALL
 
  gem install pg_search
@@ -203,7 +205,7 @@ PostgreSQL's full text search matches on whole words by default. If you want to
 
 ===== :dictionary
 
-PostgreSQL full text search also support multiple dictionaries for stemming. The default dictionary depends on your PostgreSQL setup. You can learn more about how dictionaries work by reading the {PostgreSQL documention}[http://www.postgresql.org/docs/current/static/textsearch-dictionaries.html]. If you use one of the language dictionaries, such as "english", then variants of words (e.g. "jumping" and "jumped") will match each other. If you don't want stemming, you should pick the "simple" dictionary which does not do any stemming.
+PostgreSQL full text search also support multiple dictionaries for stemming. You can learn more about how dictionaries work by reading the {PostgreSQL documention}[http://www.postgresql.org/docs/current/static/textsearch-dictionaries.html]. If you use one of the language dictionaries, such as "english", then variants of words (e.g. "jumping" and "jumped") will match each other. If you don't want stemming, you should pick the "simple" dictionary which does not do any stemming. If you don't specify a dictionary, the "simple" dictionary will be used.
 
   class BoringTweet < ActiveRecord::Base
     include PgSearch
@@ -306,6 +308,18 @@ Ignoring accents uses the {unaccent contrib package}[http://www.postgresql.org/d
 * Postgresql
 * Postgresql contrib modules for certain features
 
+== ATTRIBUTIONS
+
+PgSearch would not have been possible without inspiration from
+{texticle}[https://github.com/tenderlove/texticle]. Thanks to 
+{Aaron Patterson}[http://tenderlovemaking.com/]!
+
+== CONTRIBUTIONS AND FEEDBACK
+
+Welcomed! Feel free to join and contribute to our {public Pivotal Tracker project}[https://www.pivotaltracker.com/projects/228645] where we manage new feature ideas and bugs.
+
+We also have a {Google Group}[http://groups.google.com/group/casecommons-dev] for discussing pg_search and other Case Commons open source projects.
+
 == LICENSE
 
 MIT

data/Rakefile

@@ -4,6 +4,7 @@ Bundler::GemHelper.install_tasks
 task :default => :spec
 
 environments = %w[rails2 rails3]
+major, minor, revision = RUBY_VERSION.split(".").map{|str| str.to_i }
 
 in_environment = lambda do |environment, command|
   sh %Q{export BUNDLE_GEMFILE="gemfiles/#{environment}/Gemfile"; bundle update && bundle exec #{command}}
@@ -11,6 +12,7 @@ end
 
 in_all_environments = lambda do |command|
   environments.each do |environment|
+    next if environment == "rails2" && major == 1 && minor > 8
     puts "\n---#{environment}---\n"
     in_environment.call(environment, command)
   end

data/gemfiles/Gemfile.common

@@ -5,5 +5,5 @@ gem "pg"
 group :test do
   gem "rspec", ">=2.4"
   gem "autotest"
-  gem "with_model", '0.1'
+  gem "with_model"
 end

data/lib/pg_search/configuration.rb

@@ -1,3 +1,4 @@
+require "pg_search/configuration/association"
 require "pg_search/configuration/column"
 
 module PgSearch
@@ -20,15 +21,18 @@ module PgSearch
       end
     end
 
-    def associated_columns
+    def associations
       return [] unless @options[:associated_against]
-      @options[:associated_against].map do |association, against|
-        Array(against).map do |column_name, weight|
-          Column.new(column_name, weight, @model, association)
-        end
+      @options[:associated_against].map do |association, column_names|
+        association = Association.new(@model, association, column_names)
+        association
       end.flatten
     end
 
+    def associated_columns
+      associations.map(&:columns).flatten
+    end
+
     def query
       @options[:query].to_s
     end

data/lib/pg_search/configuration/association.rb

@@ -0,0 +1,34 @@
+require "digest"
+
+module PgSearch
+  class Configuration
+    class Association
+      attr_reader :columns
+      
+      def initialize(model, name, column_names)
+        @model = model
+        @name = name
+        @columns = Array(column_names).map do |column_name, weight|
+          Column.new(column_name, weight, @model, self)
+        end
+      end
+      
+      def table_name
+        @model.reflect_on_association(@name).table_name
+      end
+      
+      def join(primary_key)
+        selects = columns.map do |column|
+          "string_agg(#{column.full_name}, ' ') AS #{column.alias}"
+        end.join(", ")
+        relation = @model.joins(@name).select("#{primary_key} AS id, #{selects}").group(primary_key)
+        "LEFT OUTER JOIN (#{relation.to_sql}) #{subselect_alias} ON #{subselect_alias}.id = #{primary_key}"
+      end
+      
+      def subselect_alias
+        subselect_name = ["pg_search", table_name, @name, "subselect"].compact.join('_')
+        "pg_search_#{Digest::SHA2.hexdigest(subselect_name)}"
+      end
+    end
+  end
+end

data/lib/pg_search/configuration/column.rb

@@ -1,3 +1,5 @@
+require 'digest'
+
 module PgSearch
   class Configuration
     class Column
@@ -11,7 +13,7 @@ module PgSearch
       end
 
       def table
-        foreign? ? @model.reflect_on_association(association).table_name : @model.table_name
+        foreign? ? @association.table_name : @model.table_name
       end
 
       def full_name
@@ -20,7 +22,7 @@ module PgSearch
 
       def to_sql
         name = if foreign?
-                 "#{self.subselect_alias}.#{self.alias}"
+                 "#{@association.subselect_alias}.#{self.alias}"
                else
                  full_name
                end
@@ -32,11 +34,8 @@ module PgSearch
       end
 
       def alias
-        ["pg_search", table, association, @column_name].compact.join('_')
-      end
-
-      def subselect_alias
-        "#{self.alias}_subselect"
+        name = [association.subselect_alias, @column_name].compact.join('_')
+        "pg_search_#{Digest::SHA2.hexdigest(name)}"
       end
     end
   end

data/lib/pg_search/features/tsearch.rb

@@ -24,7 +24,7 @@ module PgSearch
       private
 
       def interpolations
-        {:query => @query.to_s, :dictionary => @options[:dictionary].to_s}
+        {:query => @query.to_s, :dictionary => dictionary.to_s}
       end
 
       def document
@@ -35,7 +35,7 @@ module PgSearch
         return "''" if @query.blank?
 
         @query.split(" ").compact.map do |term|
-          sanitized_term = term.gsub(/['?\-\\]/, " ")
+          sanitized_term = term.gsub(/['?\-\\:]/, " ")
 
           term_sql = @normalizer.add_normalization(connection.quote(sanitized_term))
 
@@ -45,13 +45,13 @@ module PgSearch
           # Add tsearch prefix operator if we're using a prefix search.
           tsquery_sql = "#{tsquery_sql} || #{connection.quote(':*')}" if @options[:prefix]
 
-          "to_tsquery(#{":dictionary," if @options[:dictionary]} #{tsquery_sql})"
+          "to_tsquery(:dictionary, #{tsquery_sql})"
         end.join(" && ")
       end
 
       def tsdocument
         @columns.map do |search_column|
-          tsvector = "to_tsvector(#{":dictionary," if @options[:dictionary]} #{@normalizer.add_normalization(search_column.to_sql)})"
+          tsvector = "to_tsvector(:dictionary, #{@normalizer.add_normalization(search_column.to_sql)})"
           search_column.weight.nil? ? tsvector : "setweight(#{tsvector}, #{connection.quote(search_column.weight)})"
         end.join(" || ")
       end
@@ -59,6 +59,10 @@ module PgSearch
       def tsearch_rank
         ["ts_rank((#{tsdocument}), (#{tsquery}))", interpolations]
       end
+
+      def dictionary
+        @options[:dictionary] || :simple
+      end
     end
   end
 end

data/lib/pg_search/scope_options.rb

@@ -39,10 +39,8 @@ module PgSearch
     end
 
     def joins
-      @config.associated_columns.map do |column|
-        select = "string_agg(#{column.full_name}, ' ') AS #{column.alias}"
-        relation = model.joins(column.association).select("#{primary_key} AS id, #{select}").group(primary_key)
-        "LEFT OUTER JOIN (#{relation.to_sql}) #{column.subselect_alias} ON #{column.subselect_alias}.id = #{primary_key}"
+      @config.associations.map do |association|
+        association.join(primary_key)
       end.join(' ')
     end
 

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.1.1"
+  VERSION = "0.2"
 end

data/spec/associations_spec.rb

@@ -237,6 +237,60 @@ describe PgSearch do
             end
           end
         end
+        
+        context "against multiple attributes on one association" do
+          with_model :associated_model do
+            table do |t|
+              t.string 'title'
+              t.text 'author'
+            end
+          end
+
+          with_model :model_with_association do
+            table do |t|
+              t.belongs_to 'another_model'
+            end
+
+            model do
+              include PgSearch
+              belongs_to :another_model, :class_name => 'AssociatedModel'
+
+              pg_search_scope :with_associated, :associated_against => {:another_model => [:title, :author]}
+            end
+          end
+          
+          it "should only do one join" do
+            included = [
+              ModelWithAssociation.create!(
+                :another_model => AssociatedModel.create!(
+                  :title => "foo",
+                  :author => "bar"
+                )
+              ),
+              ModelWithAssociation.create!(
+                :another_model => AssociatedModel.create!(
+                  :title => "foo bar",
+                  :author => "baz"
+                )
+              )
+            ]
+            excluded = [
+              ModelWithAssociation.create!(
+                :another_model => AssociatedModel.create!(
+                  :title => "foo",
+                  :author => "baz"
+                )
+              )
+            ]
+
+            results = ModelWithAssociation.with_associated('foo bar')
+
+            results.to_sql.scan("INNER JOIN").length.should == 1
+            included.each { |object| results.should include(object) }
+            excluded.each { |object| results.should_not include(object) }
+          end
+          
+        end
       end
     else
       context "without Arel support" do

data/spec/pg_search_spec.rb

@@ -198,13 +198,13 @@ describe "an ActiveRecord model which includes PgSearch" do
         results.should_not include(excluded)
       end
 
-      it "returns rows that match the query when stemmed by the default dictionary (english)" do
-        included = [model_with_pg_search.create!(:content => "jump"),
-                    model_with_pg_search.create!(:content => "jumped"),
+      it "returns rows that match the query exactly and not those that match the query when stemmed by the default english dictionary" do
+        included = model_with_pg_search.create!(:content => "jumped")
+        excluded = [model_with_pg_search.create!(:content => "jump"),
                     model_with_pg_search.create!(:content => "jumping")]
 
-        results = model_with_pg_search.search_content("jump")
-        results.should =~ included
+        results = model_with_pg_search.search_content("jumped")
+        results.should == [included]
       end
 
       it "returns rows that match sorted by rank" do
@@ -241,9 +241,9 @@ describe "an ActiveRecord model which includes PgSearch" do
       end
 
       it "returns rows that match a query with characters that are invalid in a tsquery expression" do
-        included = model_with_pg_search.create!(:content => "(Foo.) Bar?, \\")
+        included = model_with_pg_search.create!(:content => "(:Foo.) Bar?, \\")
 
-        results = model_with_pg_search.search_content("foo bar .,?() \\")
+        results = model_with_pg_search.search_content("foo :bar .,?() \\")
         results.should == [included]
       end
 
@@ -349,32 +349,24 @@ describe "an ActiveRecord model which includes PgSearch" do
         end
       end
 
-      context "with the simple dictionary" do
+      context "with the english dictionary" do
         before do
           model_with_pg_search.class_eval do
-            pg_search_scope :search_title, :against => :title
-
-            pg_search_scope :search_title_with_simple,
-                            :against => :title,
+            pg_search_scope :search_content_with_english,
+                            :against => :content,
                             :using => {
-                              :tsearch => {:dictionary => :simple}
+                              :tsearch => {:dictionary => :english}
                             }
           end
         end
 
-        it "returns rows that match the query exactly but not that match the query when stemmed by the default dictionary" do
-          included = model_with_pg_search.create!(:title => "jumped")
-          excluded = [model_with_pg_search.create!(:title => "jump"),
-                      model_with_pg_search.create!(:title => "jumping")]
+        it "returns rows that match the query when stemmed by the english dictionary" do
+          included = [model_with_pg_search.create!(:content => "jump"),
+                      model_with_pg_search.create!(:content => "jumped"),
+                      model_with_pg_search.create!(:content => "jumping")]
 
-          default_results = model_with_pg_search.search_title("jumped")
-          default_results.should =~ [included] + excluded
-
-          simple_results = model_with_pg_search.search_title_with_simple("jumped")
-          simple_results.should == [included]
-          excluded.each do |result|
-            simple_results.should_not include(result)
-          end
+          results = model_with_pg_search.search_content_with_english("jump")
+          results.should =~ included
         end
       end
 
@@ -472,13 +464,20 @@ describe "an ActiveRecord model which includes PgSearch" do
     context "using multiple features" do
       before do
         model_with_pg_search.class_eval do
-          pg_search_scope :with_tsearch, :against => :title, :using => :tsearch
+          pg_search_scope :with_tsearch,
+                          :against => :title,
+                          :using => [
+                            [:tsearch, {:prefix => true}]
+                          ]
 
           pg_search_scope :with_trigram, :against => :title, :using => :trigram
 
           pg_search_scope :with_tsearch_and_trigram_using_array,
                           :against => :title,
-                          :using => [:tsearch, :trigram]
+                          :using => [
+                            [:tsearch, {:prefix => true}],
+                            :trigram
+                          ]
 
         end
       end
@@ -493,7 +492,7 @@ describe "an ActiveRecord model which includes PgSearch" do
         model_with_pg_search.with_tsearch_and_trigram_using_array(trigram_query).should == [record]
 
         # matches tsearch only
-        tsearch_query = "tile"
+        tsearch_query = "til"
         model_with_pg_search.with_tsearch(tsearch_query).should include(record)
         model_with_pg_search.with_trigram(tsearch_query).should_not include(record)
         model_with_pg_search.with_tsearch_and_trigram_using_array(tsearch_query).should == [record]

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: pg_search
 version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: false
+  hash: 15
+  prerelease: 
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: "0.2"
 platform: ruby
 authors: 
 - Case Commons, LLC
@@ -15,8 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-20 00:00:00 -05:00
-default_executable: 
+date: 2011-05-11 00:00:00 Z
 dependencies: []
 
 description: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's full text search
@@ -40,11 +38,10 @@ files:
 - TODO
 - gemfiles/Gemfile.common
 - gemfiles/rails2/Gemfile
-- gemfiles/rails2/Gemfile.lock
 - gemfiles/rails3/Gemfile
-- gemfiles/rails3/Gemfile.lock
 - lib/pg_search.rb
 - lib/pg_search/configuration.rb
+- lib/pg_search/configuration/association.rb
 - lib/pg_search/configuration/column.rb
 - lib/pg_search/features.rb
 - lib/pg_search/features/dmetaphone.rb
@@ -63,7 +60,6 @@ files:
 - spec/spec_helper.rb
 - sql/dmetaphone.sql
 - sql/uninstall_dmetaphone.sql
-has_rdoc: true
 homepage: https://github.com/Casecommons/pg_search
 licenses: []
 
@@ -93,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.1
 signing_key: 
 specification_version: 3
 summary: PgSearch builds ActiveRecord named scopes that take advantage of PostgreSQL's full text search