pg_search 2.3.7 → 2.4.0

data/lib/pg_search/features/trigram.rb

@@ -29,43 +29,29 @@ module PgSearch
 
       private
 
-      def word_similarity?
-        options[:word_similarity]
-      end
+      def word_similarity? = options[:word_similarity]
 
       def similarity_function
-        if word_similarity?
-          "word_similarity"
-        else
-          "similarity"
-        end
+        word_similarity? ? "word_similarity" : "similarity"
       end
 
       def infix_operator
-        if word_similarity?
-          "<%"
-        else
-          "%"
-        end
+        word_similarity? ? "<%" : "%"
       end
 
       def similarity
         Arel::Nodes::NamedFunction.new(
           similarity_function,
-          [
-            normalized_query,
-            normalized_document
-          ]
+          [normalized_query, normalized_document]
         )
       end
 
       def normalized_document
-        Arel::Nodes::Grouping.new(Arel.sql(normalize(document)))
+        Arel::Nodes::Grouping.new(normalize(document))
       end
 
       def normalized_query
-        sanitized_query = connection.quote(query)
-        Arel.sql(normalize(sanitized_query))
+        normalize(Arel::Nodes.build_quoted(query))
       end
     end
   end

data/lib/pg_search/features/tsearch.rb

@@ -12,16 +12,16 @@ module PgSearch
 
       def conditions
         Arel::Nodes::Grouping.new(
-          Arel::Nodes::InfixOperation.new("@@", arel_wrap(tsdocument), arel_wrap(tsquery))
+          Arel::Nodes::InfixOperation.new("@@", Arel::Nodes::Grouping.new(tsdocument), Arel::Nodes::Grouping.new(tsquery))
         )
       end
 
       def rank
-        arel_wrap(tsearch_rank)
+        Arel::Nodes::Grouping.new(tsearch_rank)
       end
 
       def highlight
-        arel_wrap(ts_headline)
+        Arel::Nodes::Grouping.new(ts_headline)
       end
 
       private
@@ -29,10 +29,10 @@ module PgSearch
       def ts_headline
         Arel::Nodes::NamedFunction.new("ts_headline", [
           dictionary,
-          arel_wrap(document),
-          arel_wrap(tsquery),
+          Arel::Nodes::Grouping.new(document),
+          Arel::Nodes::Grouping.new(tsquery),
           Arel::Nodes.build_quoted(ts_headline_options)
-        ]).to_sql
+        ])
       end
 
       def ts_headline_options
@@ -49,12 +49,8 @@ module PgSearch
 
         %w[
           StartSel StopSel MaxFragments MaxWords MinWords ShortWord FragmentDelimiter HighlightAll
-        ].reduce({}) do |hash, key|
-          hash.tap do
-            value = indifferent_options[:highlight][key]
-
-            hash[key] = ts_headline_option_value(value)
-          end
+        ].to_h do |key|
+          [key, ts_headline_option_value(indifferent_options[:highlight][key])]
         end
       end
 
@@ -63,23 +59,20 @@ module PgSearch
 
         %w[
           start_sel stop_sel max_fragments max_words min_words short_word fragment_delimiter highlight_all
-        ].reduce({}) do |hash, deprecated_key|
-          hash.tap do
-            value = indifferent_options[:highlight][deprecated_key]
-
-            unless value.nil?
-              key = deprecated_key.camelize
-
-              warn(
-                "pg_search 3.0 will no longer accept :#{deprecated_key} as an argument to :ts_headline, " \
-                "use :#{key} instead.",
-                category: :deprecated,
-                uplevel: 1
-              )
-
-              hash[key] = ts_headline_option_value(value)
-            end
-          end
+        ].each_with_object({}) do |deprecated_key, hash|
+          value = indifferent_options[:highlight][deprecated_key]
+          next if value.nil?
+
+          key = deprecated_key.camelize
+
+          warn(
+            "pg_search 3.0 will no longer accept :#{deprecated_key} as an argument to :ts_headline, " \
+            "use :#{key} instead.",
+            category: :deprecated,
+            uplevel: 1
+          )
+
+          hash[key] = ts_headline_option_value(value)
         end
       end
 
@@ -96,8 +89,7 @@ module PgSearch
         end
       end
 
-      DISALLOWED_TSQUERY_CHARACTERS = /['?\\:‘’ʻʼ]/
-
+      DISALLOWED_TSQUERY_CHARACTERS = /['?\\:]/ # standard:disable Lint/UselessConstantScoping
       def tsquery_for_term(unsanitized_term)
         if options[:negation] && unsanitized_term.start_with?("!")
           unsanitized_term[0] = ""
@@ -105,22 +97,20 @@ module PgSearch
         end
 
         sanitized_term = unsanitized_term.gsub(DISALLOWED_TSQUERY_CHARACTERS, " ")
+        term_node = normalize(Arel::Nodes.build_quoted(sanitized_term))
+        tsquery_expr = tsquery_expression(term_node, negated: negated, prefix: options[:prefix])
 
-        term_sql = Arel.sql(normalize(connection.quote(sanitized_term)))
-
-        tsquery = tsquery_expression(term_sql, negated: negated, prefix: options[:prefix])
-
-        Arel::Nodes::NamedFunction.new("to_tsquery", [dictionary, tsquery]).to_sql
+        Arel::Nodes::NamedFunction.new("to_tsquery", [dictionary, tsquery_expr])
       end
 
       # After this, the SQL expression evaluates to a string containing the term surrounded by single-quotes.
       # 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.
-      def tsquery_expression(term_sql, negated:, prefix:)
+      def tsquery_expression(term_node, negated:, prefix:)
         terms = [
           (Arel::Nodes.build_quoted("!") if negated),
           Arel::Nodes.build_quoted("' "),
-          term_sql,
+          term_node,
           Arel::Nodes.build_quoted(" '"),
           (Arel::Nodes.build_quoted(":*") if prefix)
         ].compact
@@ -131,29 +121,26 @@ module PgSearch
       end
 
       def tsquery
-        return "''" if query.blank?
+        return Arel::Nodes.build_quoted("") if query.blank?
 
         query_terms = query.split.compact
-        tsquery_terms = query_terms.map { |term| tsquery_for_term(term) }
-        tsquery_terms.join(options[:any_word] ? " || " : " && ")
+        query_terms.map { |term| tsquery_for_term(term) }
+          .inject { |memo, t| Arel::Nodes::InfixOperation.new(options[:any_word] ? "||" : "&&", memo, t) }
       end
 
       def tsdocument
-        tsdocument_terms = (columns_to_use || []).map do |search_column|
-          column_to_tsvector(search_column)
-        end
+        terms = (columns_to_use || []).map { |col| column_to_tsvector(col) }
 
         if options[:tsvector_column]
-          tsvector_columns = Array.wrap(options[:tsvector_column])
-
-          tsdocument_terms << tsvector_columns.map do |tsvector_column|
-            column_name = connection.quote_column_name(tsvector_column)
-
-            "#{quoted_table_name}.#{column_name}"
+          Array.wrap(options[:tsvector_column]).each do |tsvector_column|
+            terms << Arel::Attributes::Attribute.new(
+              model.arel_table,
+              tsvector_column.to_s
+            )
           end
         end
 
-        tsdocument_terms.join(" || ")
+        terms.inject { |memo, t| Arel::Nodes::InfixOperation.new("||", memo, t) } || Arel.sql("")
       end
 
       # From http://www.postgresql.org/docs/8.3/static/textsearch-controls.html
@@ -171,20 +158,16 @@ module PgSearch
 
       def tsearch_rank
         Arel::Nodes::NamedFunction.new("ts_rank", [
-          arel_wrap(tsdocument),
-          arel_wrap(tsquery),
+          Arel::Nodes::Grouping.new(tsdocument),
+          Arel::Nodes::Grouping.new(tsquery),
           normalization
-        ]).to_sql
+        ])
       end
 
       def dictionary
         Arel::Nodes.build_quoted(options[:dictionary] || :simple)
       end
 
-      def arel_wrap(sql_string)
-        Arel::Nodes::Grouping.new(Arel.sql(sql_string))
-      end
-
       def columns_to_use
         if options[:tsvector_column]
           columns.select { |c| c.is_a?(PgSearch::Configuration::ForeignColumn) }
@@ -196,13 +179,16 @@ module PgSearch
       def column_to_tsvector(search_column)
         tsvector = Arel::Nodes::NamedFunction.new(
           "to_tsvector",
-          [dictionary, Arel.sql(normalize(search_column.to_sql))]
-        ).to_sql
+          [dictionary, normalize(search_column.to_arel)]
+        )
 
         if search_column.weight.nil?
           tsvector
         else
-          "setweight(#{tsvector}, #{connection.quote(search_column.weight)})"
+          Arel::Nodes::NamedFunction.new(
+            "setweight",
+            [tsvector, Arel::Nodes.build_quoted(search_column.weight)]
+          )
         end
       end
     end

data/lib/pg_search/features.rb

@@ -7,6 +7,8 @@ require "pg_search/features/trigram"
 require "pg_search/features/tsearch"
 
 module PgSearch
+  # Search features provide conditions and rank as composable Arel expressions,
+  # not SQL Strings. TSearch also provides a highlight expression for selection.
   module Features
   end
 end

data/lib/pg_search/migration/generator.rb

@@ -28,11 +28,7 @@ module PgSearch
       end
 
       def migration_version
-        if ActiveRecord::VERSION::MAJOR >= 5
-          "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
-        else
-          ""
-        end
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
       end
     end
   end

data/lib/pg_search/model.rb

@@ -23,13 +23,14 @@ module PgSearch
 
       def multisearchable(options = {})
         include PgSearch::Multisearchable
+
         class_attribute :pg_search_multisearchable_options
         self.pg_search_multisearchable_options = options
       end
     end
 
-    def method_missing(symbol, *args)
-      case symbol
+    def method_missing(method, *, **)
+      case method
       when :pg_search_rank
         raise PgSearchRankNotSelected unless respond_to?(:pg_search_rank)
 
@@ -43,12 +44,9 @@ module PgSearch
       end
     end
 
-    def respond_to_missing?(symbol, *args)
-      case symbol
-      when :pg_search_rank
-        attributes.key?(:pg_search_rank)
-      when :pg_search_highlight
-        attributes.key?(:pg_search_highlight)
+    def respond_to_missing?(method, *, **)
+      if method.in?(%i[pg_search_rank pg_search_highlight])
+        attributes.key?(method)
       else
         super
       end

data/lib/pg_search/multisearch/rebuilder.rb

@@ -3,6 +3,16 @@
 module PgSearch
   module Multisearch
     class Rebuilder
+      # Arguments
+      #
+      # +model+:: Active Record model configured for multisearch.
+      # +time_source+:: Clock returning a timestamp for bulk inserts. Defaults to
+      #                 +Time.method(:now)+ and is called once per bulk rebuild so
+      #                 +created_at+ and +updated_at+ share a timestamp.
+      #
+      # Raises
+      #
+      # ModelNotMultisearchable:: If +model+ is not configured for multisearch.
       def initialize(model, time_source = Time.method(:now))
         raise ModelNotMultisearchable, model unless model.respond_to?(:pg_search_multisearchable_options)
 
@@ -10,6 +20,10 @@ module PgSearch
         @time_source = time_source
       end
 
+      # Populates search documents without first clearing existing documents.
+      # Uses the model's rebuild_pg_search_documents override when available;
+      # otherwise updates records individually for conditions, dynamic content,
+      # or additional attributes, and bulk-inserts for plain column content.
       def rebuild
         if model.respond_to?(:rebuild_pg_search_documents)
           model.rebuild_pg_search_documents
@@ -25,7 +39,8 @@ module PgSearch
       attr_reader :model
 
       def conditional?
-        model.pg_search_multisearchable_options.key?(:if) || model.pg_search_multisearchable_options.key?(:unless)
+        model.pg_search_multisearchable_options.key?(:if) ||
+          model.pg_search_multisearchable_options.key?(:unless)
       end
 
       def dynamic?
@@ -37,76 +52,66 @@ module PgSearch
         model.pg_search_multisearchable_options.key?(:additional_attributes)
       end
 
-      def connection
-        model.connection
-      end
-
-      def primary_key
-        model.primary_key
-      end
-
-      def rebuild_sql_template
-        <<~SQL.squish
-          INSERT INTO :documents_table (searchable_type, searchable_id, content, created_at, updated_at)
-            SELECT :base_model_name AS searchable_type,
-                   :model_table.#{primary_key} AS searchable_id,
-                   (
-                     :content_expressions
-                   ) AS content,
-                   :current_time AS created_at,
-                   :current_time AS updated_at
-            FROM :model_table :sti_clause
-        SQL
-      end
-
-      def rebuild_sql
-        replacements.inject(rebuild_sql_template) do |sql, key|
-          sql.gsub ":#{key}", send(key)
+      def connection = model.connection
+
+      def rebuild_sql = connection.to_sql(insert_manager.ast)
+
+      def insert_manager
+        time = @time_source.call
+        quoted_time = Arel::Nodes.build_quoted(time)
+        src = model.arel_table
+        doc = PgSearch::Document.arel_table
+
+        sel = Arel::SelectManager.new(src)
+        sel.project(
+          Arel::Nodes.build_quoted(model.base_class.name).as("searchable_type"),
+          src[model.primary_key].as("searchable_id"),
+          content_expression.as("content"),
+          quoted_time.as("created_at"),
+          quoted_time.as("updated_at")
+        )
+
+        apply_sti_condition(sel, src)
+
+        mgr = Arel::InsertManager.new
+        mgr.into(doc)
+        mgr.columns.concat([
+          doc[:searchable_type],
+          doc[:searchable_id],
+          doc[:content],
+          doc[:created_at],
+          doc[:updated_at]
+        ])
+        mgr.select(sel.ast)
+        mgr
+      end
+
+      def content_expression
+        expressions = columns.map { |column| Configuration::Column.new(column, nil, model).to_arel }
+        expressions.inject do |document, expression|
+          Arel::Nodes::InfixOperation.new(
+            "||",
+            Arel::Nodes::InfixOperation.new("||", document, Arel::Nodes.build_quoted(" ")),
+            expression
+          )
         end
       end
 
-      def sti_clause
-        clause = ""
-        if model.column_names.include? model.inheritance_column
-          clause = "WHERE"
-          clause = "#{clause} #{model.inheritance_column} IS NULL OR" if model.base_class == model
-          clause = "#{clause} #{model.inheritance_column} = #{model_name}"
-        end
-        clause
-      end
+      def columns = Array(model.pg_search_multisearchable_options[:against])
 
-      def replacements
-        %w[content_expressions base_model_name model_name model_table documents_table current_time sti_clause]
-      end
+      def apply_sti_condition(select_manager, src_table)
+        return unless model.column_names.include?(model.inheritance_column)
 
-      def content_expressions
-        columns.map do |column|
-          %{coalesce(:model_table.#{connection.quote_column_name(column)}::text, '')}
-        end.join(" || ' ' || ")
-      end
+        inheritance_col = src_table[model.inheritance_column]
+        type_match = inheritance_col.eq(model.name)
 
-      def columns
-        Array(model.pg_search_multisearchable_options[:against])
-      end
-
-      def model_name
-        connection.quote(model.name)
-      end
-
-      def base_model_name
-        connection.quote(model.base_class.name)
-      end
-
-      def model_table
-        model.quoted_table_name
-      end
-
-      def documents_table
-        PgSearch::Document.quoted_table_name
-      end
+        condition = if model.base_class == model
+          inheritance_col.eq(nil).or(type_match)
+        else
+          type_match
+        end
 
-      def current_time
-        connection.quote(connection.quoted_date(@time_source.call))
+        select_manager.where(condition)
       end
     end
   end

data/lib/pg_search/normalizer.rb

@@ -2,28 +2,57 @@
 
 module PgSearch
   class Normalizer
+    # Arguments
+    #
+    # +config+:: Search configuration whose ignore list controls accent
+    #            normalization.
     def initialize(config)
       @config = config
     end
 
-    def add_normalization(sql_expression)
-      return sql_expression unless config.ignore.include?(:accents)
+    DISALLOWED_CHARACTERS = "['?\\:]"
 
-      sql_node = case sql_expression
-      when Arel::Nodes::Node
-        sql_expression
-      else
-        Arel.sql(sql_expression)
-      end
+    # Applies configured accent normalization, preserving the input expression
+    # without an unaccent wrapper when accents are not ignored.
+    #
+    # Arguments
+    #
+    # +expression+:: An Arel node, attribute, or trusted SQL String. A String is
+    #                an SQL expression, not a value to quote.
+    #
+    # Returns a composable Arel expression.
+    #
+    # Raises
+    #
+    # TypeError:: If +expression+ is not an Arel node, attribute, or String.
+    def add_normalization(expression)
+      node = to_node(expression)
+      return node unless config.ignore.include?(:accents)
 
       Arel::Nodes::NamedFunction.new(
-        PgSearch.unaccent_function,
-        [sql_node]
-      ).to_sql
+        "regexp_replace",
+        [
+          Arel::Nodes::NamedFunction.new(PgSearch.unaccent_function, [node]),
+          Arel::Nodes.build_quoted(DISALLOWED_CHARACTERS),
+          Arel::Nodes.build_quoted(""),
+          Arel::Nodes.build_quoted("g")
+        ]
+      )
     end
 
     private
 
     attr_reader :config
+
+    def to_node(expression)
+      case expression
+      when Arel::Nodes::Node, Arel::Attributes::Attribute
+        expression
+      when String
+        Arel.sql(expression)
+      else
+        raise TypeError
+      end
+    end
   end
 end