pg_search 0.5.4 → 0.5.5

data/CHANGELOG.rdoc

@@ -1,5 +1,11 @@
 = PgSearch
 
+== 0.5.5
+
+* Fix bug with single table inheritance.
+
+* Allow option for specifying an alternate function for unaccent().
+
 == 0.5.4
 
 * Fix bug in associated_against join clause when search scope is chained after other scopes.

data/README.rdoc

@@ -495,6 +495,10 @@ Ignoring accents uses the {unaccent contrib package}[http://www.postgresql.org/d
   SpanishQuestion.gringo_search("Que") # => [what]
   SpanishQuestion.gringo_search("Cüåñtô") # => [how_many]
 
+Advanced users may wish to add indexes for the expressions that pg_search generates. Unfortunately, the unaccent function supplied by this contrib package is not indexable (as of PostgreSQL 9.1). Thus, you may want to write your own wrapper function and use it instead. This can be configured by calling the following code, perhaps in an initializer.
+
+  PgSearch.unaccent_function = "my_unaccent"
+
 === Using tsvector columns
 
 PostgreSQL allows you the ability to search against a column with type tsvector instead of using an expression; this speeds up searching dramatically as it offloads creation of the tsvector that the tsquery is evaluated against.

data/lib/pg_search.rb

@@ -18,11 +18,25 @@ module PgSearch
   mattr_accessor :multisearch_options
   self.multisearch_options = {}
 
+  mattr_accessor :unaccent_function
+  self.unaccent_function = "unaccent"
+
   module ClassMethods
     def pg_search_scope(name, options)
-      scope = PgSearch::Scope.new(name, self, options)
+      options_proc = if options.respond_to?(:call)
+                       options
+                     else
+                       unless options.respond_to?(:merge)
+                         raise ArgumentError, "pg_search_scope expects a Hash or Proc"
+                       end
+                       lambda { |query| {:query => query}.merge(options) }
+                     end
 
-      method_proc = scope.method(:build_relation)
+      method_proc = lambda do |*args|
+        config = Configuration.new(options_proc.call(*args), self)
+        scope_options = ScopeOptions.new(config)
+        scope_options.apply(self)
+      end
 
       if respond_to?(:define_singleton_method)
         define_singleton_method name, &method_proc

data/lib/pg_search/configuration.rb

@@ -15,7 +15,7 @@ module PgSearch
 
     class << self
       def alias(*strings)
-        name = Array.wrap(strings).compact.join("_")
+        name = Array(strings).compact.join("_")
         # By default, PostgreSQL limits names to 32 characters, so we hash and limit to 32 characters.
         "pg_search_#{Digest::SHA2.hexdigest(name)}"[0,32]
       end
@@ -26,16 +26,16 @@ module PgSearch
     end
 
     def regular_columns
-      return [] unless @options[:against]
-      Array(@options[:against]).map do |column_name, weight|
-        Column.new(column_name, weight, @model)
+      return [] unless options[:against]
+      Array(options[:against]).map do |column_name, weight|
+        Column.new(column_name, weight, model)
       end
     end
 
     def associations
-      return [] unless @options[:associated_against]
-      @options[:associated_against].map do |association, column_names|
-        Association.new(@model, association, column_names)
+      return [] unless options[:associated_against]
+      options[:associated_against].map do |association, column_names|
+        Association.new(model, association, column_names)
       end.flatten
     end
 
@@ -44,35 +44,33 @@ module PgSearch
     end
 
     def query
-      @options[:query].to_s
+      options[:query].to_s
     end
 
     def ignore
-      Array.wrap(@options[:ignoring])
+      Array(options[:ignoring])
     end
 
     def ranking_sql
-      @options[:ranked_by]
+      options[:ranked_by]
     end
 
     def features
-      Array(@options[:using])
+      Array(options[:using])
     end
 
     def order_within_rank
-      @options[:order_within_rank]
+      options[:order_within_rank]
     end
 
     def postgresql_version
-      @model.connection.send(:postgresql_version)
-    end
-
-    def logger
-      @model.logger
+      model.connection.send(:postgresql_version)
     end
 
     private
 
+    attr_reader :options
+
     def default_options
       {:using => :tsearch}
     end
@@ -97,7 +95,7 @@ module PgSearch
       options.assert_valid_keys(VALID_KEYS)
 
       VALID_VALUES.each do |key, values_for_key|
-        Array.wrap(options[key]).each do |value|
+        Array(options[key]).each do |value|
           unless values_for_key.include?(value)
             raise ArgumentError, ":#{key} cannot accept #{value}"
           end

data/lib/pg_search/document.rb

@@ -27,7 +27,7 @@ module PgSearch
     private
 
     def update_content
-      methods = Array.wrap(searchable.pg_search_multisearchable_options[:against])
+      methods = Array(searchable.pg_search_multisearchable_options[:against])
       searchable_text = methods.map { |symbol| searchable.send(symbol) }.join(" ")
       self.content = searchable_text
     end

data/lib/pg_search/features/dmetaphone.rb

@@ -8,23 +8,31 @@ module PgSearch
       end
 
       def conditions
-        @tsearch.conditions
+        tsearch.conditions
       end
 
       def rank
-        @tsearch.rank
+        tsearch.rank
       end
 
+      private
+
+      attr_reader :tsearch
+
       # Decorates a normalizer with dmetaphone processing.
       class Normalizer
         def initialize(normalizer_to_wrap)
-          @decorated_normalizer = normalizer_to_wrap
+          @normalizer_to_wrap = normalizer_to_wrap
         end
 
         def add_normalization(original_sql)
-          otherwise_normalized_sql = @decorated_normalizer.add_normalization(original_sql)
+          otherwise_normalized_sql = normalizer_to_wrap.add_normalization(original_sql)
           "pg_search_dmetaphone(#{otherwise_normalized_sql})"
         end
+
+        private
+
+        attr_reader :normalizer_to_wrap
       end
     end
   end

data/lib/pg_search/features/feature.rb

@@ -11,17 +11,19 @@ module PgSearch
 
       private
 
+      attr_reader :query, :options, :columns, :model, :normalizer
+
       def document
-        if @columns.length == 1
-          @columns.first.to_sql
+        if columns.length == 1
+          columns.first.to_sql
         else
-          expressions = @columns.map { |column| column.to_sql }.join(", ")
+          expressions = columns.map { |column| column.to_sql }.join(", ")
           "array_to_string(ARRAY[#{expressions}], ' ')"
         end
       end
 
       def normalize(expression)
-        @normalizer.add_normalization(expression)
+        normalizer.add_normalization(expression)
       end
     end
   end

data/lib/pg_search/features/trigram.rb

@@ -4,14 +4,14 @@ module PgSearch
       def conditions
         [
           "(#{normalize(document)}) % #{normalize(":query")}",
-          {:query => @query}
+          {:query => query}
         ]
       end
 
       def rank
         [
           "similarity((#{normalize(document)}), #{normalize(":query")})",
-          {:query => @query}
+          {:query => query}
         ]
       end
     end

data/lib/pg_search/features/tsearch.rb

@@ -5,10 +5,10 @@ module PgSearch
     class TSearch < Feature
       delegate :connection, :quoted_table_name, :to => :'@model'
 
-      def initialize(query, options, columns, model, normalizer)
+      def initialize(*args)
         super
 
-        if @options[:prefix] && @model.connection.send(:postgresql_version) < 80400
+        if options[:prefix] && model.connection.send(:postgresql_version) < 80400
           raise PgSearch::NotSupportedForPostgresqlVersion.new(<<-MESSAGE.gsub /^\s*/, '')
             Sorry, {:using => {:tsearch => {:prefix => true}}} only works in PostgreSQL 8.4 and above.")
           MESSAGE
@@ -26,7 +26,7 @@ module PgSearch
       private
 
       def interpolations
-        {:query => @query.to_s, :dictionary => dictionary.to_s}
+        {:query => query.to_s, :dictionary => dictionary.to_s}
       end
 
       DISALLOWED_TSQUERY_CHARACTERS = /['?\\:]/
@@ -42,25 +42,25 @@ module PgSearch
           connection.quote("' "),
           term_sql,
           connection.quote(" '"),
-          (connection.quote(':*') if @options[:prefix])
+          (connection.quote(':*') if options[:prefix])
         ].compact.join(" || ")
 
         "to_tsquery(:dictionary, #{tsquery_sql})"
       end
 
       def tsquery
-        return "''" if @query.blank?
-        query_terms = @query.split(" ").compact
+        return "''" if query.blank?
+        query_terms = query.split(" ").compact
         tsquery_terms = query_terms.map { |term| tsquery_for_term(term) }
-        tsquery_terms.join(@options[:any_word] ? ' || ' : ' && ')
+        tsquery_terms.join(options[:any_word] ? ' || ' : ' && ')
       end
 
       def tsdocument
-        if @options[:tsvector_column]
-          column_name = connection.quote_column_name(@options[:tsvector_column])
+        if options[:tsvector_column]
+          column_name = connection.quote_column_name(options[:tsvector_column])
           "#{quoted_table_name}.#{column_name}"
         else
-          @columns.map do |search_column|
+          columns.map do |search_column|
             tsvector = "to_tsvector(:dictionary, #{normalize(search_column.to_sql)})"
             if search_column.weight.nil?
               tsvector
@@ -81,7 +81,7 @@ module PgSearch
       #   32 divides the rank by itself + 1
       # The integer option controls several behaviors, so it is a bit mask: you can specify one or more behaviors
       def normalization
-        @options[:normalization] || 0
+        options[:normalization] || 0
       end
 
       def tsearch_rank
@@ -89,7 +89,7 @@ module PgSearch
       end
 
       def dictionary
-        @options[:dictionary] || :simple
+        options[:dictionary] || :simple
       end
     end
   end

data/lib/pg_search/multisearch/rebuilder.rb

@@ -1,18 +1,6 @@
 module PgSearch
   module Multisearch
     class Rebuilder
-      REBUILD_SQL_TEMPLATE = <<-SQL
-INSERT INTO :documents_table (searchable_type, searchable_id, content, created_at, updated_at)
-  SELECT :model_name AS searchable_type,
-         :model_table.id AS searchable_id,
-         (
-           :content_expressions
-         ) AS content,
-         :current_time AS created_at,
-         :current_time AS updated_at
-  FROM :model_table
-SQL
-
       def initialize(model)
         unless model.respond_to?(:pg_search_multisearchable_options)
           raise ModelNotMultisearchable.new(model)
@@ -22,19 +10,33 @@ SQL
       end
 
       def rebuild
-        if @model.respond_to?(:rebuild_pg_search_documents)
-          @model.rebuild_pg_search_documents
+        if model.respond_to?(:rebuild_pg_search_documents)
+          model.rebuild_pg_search_documents
         else
-          @model.connection.execute(rebuild_sql)
+          model.connection.execute(rebuild_sql)
         end
       end
 
       private
 
+      attr_reader :model
+
       def connection
-        @model.connection
+        model.connection
       end
 
+      REBUILD_SQL_TEMPLATE = <<-SQL
+INSERT INTO :documents_table (searchable_type, searchable_id, content, created_at, updated_at)
+  SELECT :model_name AS searchable_type,
+         :model_table.id AS searchable_id,
+         (
+           :content_expressions
+         ) AS content,
+         :current_time AS created_at,
+         :current_time AS updated_at
+  FROM :model_table
+SQL
+
       def rebuild_sql
         replacements.inject(REBUILD_SQL_TEMPLATE) do |sql, key|
           sql.gsub ":#{key}", send(key)
@@ -52,15 +54,15 @@ SQL
       end
 
       def columns
-        Array.wrap(@model.pg_search_multisearchable_options[:against])
+        Array(model.pg_search_multisearchable_options[:against])
       end
 
       def model_name
-        connection.quote(@model.name)
+        connection.quote(model.name)
       end
 
       def model_table
-        @model.quoted_table_name
+        model.quoted_table_name
       end
 
       def documents_table

data/lib/pg_search/normalizer.rb

@@ -5,18 +5,22 @@ module PgSearch
     end
 
     def add_normalization(sql_expression)
-      if @config.ignore.include?(:accents)
-        if @config.postgresql_version < 90000
+      if config.ignore.include?(:accents)
+        if config.postgresql_version < 90000
           raise PgSearch::NotSupportedForPostgresqlVersion.new(<<-MESSAGE.gsub /^\s*/, '')
             Sorry, {:ignoring => :accents} only works in PostgreSQL 9.0 and above.
-            #{@config.inspect}
+            #{config.inspect}
           MESSAGE
         else
-          "unaccent(#{sql_expression})"
+          "#{PgSearch.unaccent_function}(#{sql_expression})"
         end
       else
         sql_expression
       end
     end
+
+    private
+
+    attr_reader :config
   end
 end

data/lib/pg_search/scope_options.rb

@@ -2,10 +2,9 @@ require "active_support/core_ext/module/delegation"
 
 module PgSearch
   class ScopeOptions
-    delegate :connection, :quoted_table_name, :sanitize_sql_array, :to => :@model
+    attr_reader :config, :feature_options
 
-    def initialize(name, config)
-      @name = name
+    def initialize(config)
       @config = config
       @model = config.model
       @feature_options = Hash[config.features]
@@ -17,14 +16,16 @@ module PgSearch
 
     private
 
+    delegate :connection, :quoted_table_name, :sanitize_sql_array, :to => :@model
+
     def conditions
-      @config.features.map do |feature_name, feature_options|
+      config.features.map do |feature_name, feature_options|
         "(#{sanitize_sql_array(feature_for(feature_name).conditions)})"
       end.join(" OR ")
     end
 
     def order_within_rank
-      @config.order_within_rank || "#{primary_key} ASC"
+      config.order_within_rank || "#{primary_key} ASC"
     end
 
     def primary_key
@@ -32,7 +33,7 @@ module PgSearch
     end
 
     def joins
-      @config.associations.map do |association|
+      config.associations.map do |association|
         association.join(primary_key)
       end.join(' ')
     end
@@ -49,19 +50,19 @@ module PgSearch
 
       raise ArgumentError.new("Unknown feature: #{feature_name}") unless feature_class
 
-      normalizer = Normalizer.new(@config)
+      normalizer = Normalizer.new(config)
 
       feature_class.new(
-        @config.query,
-        @feature_options[feature_name],
-        @config.columns,
-        @config.model,
+        config.query,
+        feature_options[feature_name],
+        config.columns,
+        config.model,
         normalizer
       )
     end
 
     def rank
-      (@config.ranking_sql || ":tsearch").gsub(/:(\w*)/) do
+      (config.ranking_sql || ":tsearch").gsub(/:(\w*)/) do
         sanitize_sql_array(feature_for($1).rank)
       end
     end

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.5.4"
+  VERSION = "0.5.5"
 end

data/spec/pg_search/document_spec.rb

@@ -7,7 +7,7 @@ describe PgSearch::Document do
     table
     model do
       include PgSearch
-      multisearchable({})
+      multisearchable
     end
   end
 

data/spec/pg_search/normalizer_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe PgSearch::Normalizer do
+  describe "#add_normalization" do
+    context "for PostgreSQL 9.0 and above" do
+      context "when config[:ignore] includes :accents" do
+        it "wraps the expression in unaccent()" do
+          config = stub("config", :ignore => [:accents], :postgresql_version => 90000)
+
+          normalizer = PgSearch::Normalizer.new(config)
+          normalizer.add_normalization("foo").should == "unaccent(foo)"
+        end
+
+        context "when a custom unaccent function is specified" 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)
+
+            normalizer = PgSearch::Normalizer.new(config)
+            normalizer.add_normalization("foo").should == "my_unaccent(foo)"
+          end
+        end
+      end
+
+      context "when config[:ignore] does not include :accents" do
+        it "passes the expression through" do
+          config = stub("config", :ignore => [], :postgresql_version => 90000)
+
+          normalizer = PgSearch::Normalizer.new(config)
+          normalizer.add_normalization("foo").should == "foo"
+        end
+      end
+    end
+
+    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)
+
+          normalizer = PgSearch::Normalizer.new(config)
+          expect {
+            normalizer.add_normalization("foo")
+          }.to raise_exception(PgSearch::NotSupportedForPostgresqlVersion)
+        end
+      end
+
+      context "when config[:ignore] does not include :accents" do
+        it "passes the expression through" do
+          config = stub("config", :ignore => [], :postgresql_version => 90000)
+
+          normalizer = PgSearch::Normalizer.new(config)
+          normalizer.add_normalization("foo").should == "foo"
+        end
+      end
+    end
+  end
+end

data/spec/pg_search_spec.rb

@@ -751,6 +751,50 @@ describe "an ActiveRecord model which includes PgSearch" do
         end
       end
     end
+
+    context "on an STI subclass" do
+      with_model :SuperclassModel do
+        table do |t|
+          t.text 'content'
+          t.string 'type'
+        end
+
+        model do
+          include PgSearch
+        end
+      end
+
+      before do
+        SuperclassModel.pg_search_scope :search_content, :against => :content
+
+        class SubclassModel < SuperclassModel
+        end
+
+        class AnotherSubclassModel < SuperclassModel
+        end
+      end
+
+      it "should returns only results for that subclass" do
+        included = [
+          SubclassModel.create!(:content => "foo bar")
+        ]
+        excluded = [
+          SubclassModel.create!(:content => "baz"),
+          SuperclassModel.create!(:content => "foo bar"),
+          SuperclassModel.create!(:content => "baz"),
+          AnotherSubclassModel.create!(:content => "foo bar"),
+          AnotherSubclassModel.create!(:content => "baz")
+        ]
+
+        SuperclassModel.count.should == 6
+        SubclassModel.count.should == 2
+
+        results = SubclassModel.search_content("foo bar")
+
+        results.should include(*included)
+        results.should_not include(*excluded)
+      end
+    end
   end
 
   describe ".multisearchable" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_search
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-07 00:00:00.000000000 Z
+date: 2012-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -83,7 +83,6 @@ files:
 - lib/pg_search/multisearchable.rb
 - lib/pg_search/normalizer.rb
 - lib/pg_search/railtie.rb
-- lib/pg_search/scope.rb
 - lib/pg_search/scope_options.rb
 - lib/pg_search/tasks.rb
 - lib/pg_search/version.rb
@@ -92,6 +91,7 @@ files:
 - spec/pg_search/document_spec.rb
 - spec/pg_search/multisearch_spec.rb
 - spec/pg_search/multisearchable_spec.rb
+- spec/pg_search/normalizer_spec.rb
 - spec/pg_search_spec.rb
 - spec/spec_helper.rb
 - sql/array_agg.sql
@@ -114,7 +114,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1787882256283338763
+      hash: -4514756727807360588
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -123,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1787882256283338763
+      hash: -4514756727807360588
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -136,5 +136,6 @@ test_files:
 - spec/pg_search/document_spec.rb
 - spec/pg_search/multisearch_spec.rb
 - spec/pg_search/multisearchable_spec.rb
+- spec/pg_search/normalizer_spec.rb
 - spec/pg_search_spec.rb
 - spec/spec_helper.rb

data/lib/pg_search/scope.rb

@@ -1,27 +0,0 @@
-module PgSearch
-  class Scope
-    def initialize(name, model, scope_options_or_proc)
-      @name = name
-      @model = model
-      @options_proc = build_options_proc(scope_options_or_proc)
-    end
-
-    def build_relation(*args)
-      config = Configuration.new(@options_proc.call(*args), @model)
-      scope_options = ScopeOptions.new(@name, config)
-      scope_options.apply(@model)
-    end
-
-    private
-
-    def build_options_proc(scope_options)
-      return scope_options if scope_options.respond_to?(:call)
-
-      unless scope_options.respond_to?(:merge)
-        raise ArgumentError, "pg_search_scope expects a Hash or Proc"
-      end
-
-      lambda { |query| {:query => query}.merge(scope_options) }
-    end
-  end
-end