redi_search 6.3.0 → 7.0.0

data/lib/redi_search/aggregate.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    class MissingGroupByClause < StandardError
+    end
+
+    extend Forwardable
+    include LazilyLoad
+    include Search::Queries
+
+    attr_reader :query, :used_clauses, :index, :clauses
+
+    def_delegator :index, :model
+
+    def initialize(index, term = nil, **term_options)
+      @index = index
+      @clauses = []
+      @used_clauses = Set.new
+
+      @query = term && Search::Queries::And.new(self, term, nil, **term_options)
+    end
+
+    def verbatim
+      add_to_clauses(Clauses::Verbatim.new)
+    end
+
+    def load(*fields)
+      add_to_clauses(Clauses::Load.new(fields: fields))
+    end
+
+    def group_by(*fields)
+      add_to_clauses(Clauses::GroupBy.new(fields: fields))
+    end
+
+    def count(as: nil)
+      clause = clauses.reverse.find { |cl| cl.is_a?(Clauses::GroupBy) } ||
+        raise(MissingGroupByClause, "call group_by first")
+
+      clause.count(as: as)
+      self
+    end
+
+    def quantile(property: nil, quantile: nil, as: nil)
+      clause = clauses.reverse.find { |cl| cl.is_a?(Clauses::GroupBy) } ||
+        raise(MissingGroupByClause, "call group_by first")
+
+      clause.count(property: property, quantile: quantile, as: as)
+
+      self
+    end
+
+    %i(distinct_count distinctish_count sum min max average stdev to_list).
+      each do |reducer|
+      define_method(reducer) do |property, as: nil|
+        clause = clauses.reverse.find { |cl| cl.is_a?(Clauses::GroupBy) } ||
+          raise(MissingGroupByClause, "call group_by first")
+
+        clause.public_send(reducer, property: property, as: as)
+        self
+      end
+    end
+
+    def sort_by(*fields)
+      add_to_clauses(Clauses::SortBy.new(fields: fields))
+    end
+
+    def apply(expression, as:)
+      add_to_clauses(Clauses::Apply.new(expression: expression, as: as))
+    end
+
+    def filter(expression)
+      add_to_clauses(Clauses::Filter.new(expression: expression))
+    end
+
+    def limit(total, offset = 0)
+      add_to_clauses(Clauses::Limit.new(total: total, offset: offset))
+    end
+
+    private
+
+    attr_writer :index, :clauses
+
+    def command
+      ["AGGREGATE", index.name, query.to_s,
+       *clauses.sort_by(&:clause_order).flat_map(&:clause)]
+    end
+
+    def parse_response(response)
+      @documents = response
+    end
+
+    def valid?
+      !query.to_s.empty?
+    end
+
+    def add_to_clauses(clause)
+      clause.validate! && clauses.push(clause) if
+        used_clauses.add?(clause.class)
+
+      self
+    end
+  end
+end

data/lib/redi_search/application_clause.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class ApplicationClause
+    include Validatable
+
+    def clause_order
+      self.class.order
+    end
+
+    class << self
+      def clause_term(term, **validations)
+        attr_reader term
+
+        validations.each do |validation_type, options|
+          define_validation(term, validation_type, options)
+        end
+      end
+
+      attr_reader :order
+
+      def clause_order(number)
+        @order = number
+      end
+
+      private
+
+      def define_validation(term, type, options)
+        if options.is_a? Hash
+          public_send("validates_#{type}_of", term, **options)
+        else
+          public_send("validates_#{type}_of", term)
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/client.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "redis"
 require "active_support/notifications"
 
 module RediSearch
@@ -18,11 +17,12 @@ module RediSearch
     end
 
     def multi
-      Response.new(redis.multi do |pipeline|
-        instrument("pipeline", query: ["begin pipeline"])
+      instrument("pipeline", query: ["begin pipeline"])
+      Response.new(redis.pipelined do |pipeline|
         capture_pipeline(pipeline) { yield }
-        instrument("pipeline", query: ["finish pipeline"])
       end)
+    ensure
+      instrument("pipeline", query: ["finish pipeline"])
     end
 
     private
@@ -33,6 +33,7 @@ module RediSearch
     def capture_pipeline(pipeline)
       self.pipeline = pipeline
       yield
+    ensure
       self.pipeline = false
     end
 

data/lib/redi_search/index.rb

@@ -14,6 +14,10 @@ module RediSearch
       Search.new(self, term, **term_options)
     end
 
+    def aggregate(term = nil, **term_options)
+      Aggregate.new(self, term, **term_options)
+    end
+
     def spellcheck(query, distance: 1)
       Spellcheck.new(self, query, distance: distance)
     end
@@ -87,9 +91,11 @@ module RediSearch
       info.num_docs.to_i
     end
 
+    # rubocop:disable Style/ArgumentsForwarding
     def add_field(name, type, **options, &block)
       AddField.new(self, name, type, **options, &block).call!
     end
+    # rubocop:enable Style/ArgumentsForwarding
 
     private
 

data/lib/redi_search/log_subscriber.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 require "active_support/version"
+if ActiveSupport::VERSION::MAJOR >= 7 && ActiveSupport::VERSION::MINOR >= 1
+  require "active_support/deprecation"
+  require "active_support/deprecator"
+end
 require "active_support/log_subscriber"
 if ActiveSupport::VERSION::MAJOR > 6
   require "active_support/isolated_execution_state"
@@ -30,19 +34,20 @@ module RediSearch
       command = command_string(event)
       debug_color = action_color(event.payload[:action])
 
-      debug "  #{log_name(event)}  #{color(command, debug_color, true)}"
+      debug "  #{log_name(event)}  #{color(command, debug_color, bold: true)}"
     end
 
     private
 
     def log_name(event)
-      color("#{event.payload[:name]} (#{event.duration.round(1)}ms)", RED, true)
+      color("#{event.payload[:name]} (#{event.duration.round(1)}ms)",
+            RED, bold: true)
     end
 
     # rubocop:disable Metrics/MethodLength
     def action_color(action)
       case action.to_sym
-      when :search, :spellcheck then YELLOW
+      when :search, :spellcheck, :aggregate then YELLOW
       when :create, :hset then GREEN
       when :dropindex, :del then RED
       when :hgetall, :info then CYAN

data/lib/redi_search/model.rb

@@ -18,7 +18,7 @@ module RediSearch
         )
         register_search_commit_hooks
 
-        scope :search_import, -> { all }
+        scope :search_import, -> { all } unless defined?(search_import)
 
         include InstanceMethods
         extend ModelClassMethods
@@ -39,6 +39,10 @@ module RediSearch
         search_index.search(term, **term_options)
       end
 
+      def aggregate(term = nil, **term_options)
+        search_index.aggregate(term, **term_options)
+      end
+
       def spellcheck(term, distance: 1)
         search_index.spellcheck(term, distance: distance)
       end

data/lib/redi_search/schema/tag_field.rb

@@ -28,6 +28,14 @@ module RediSearch
         value.split(separator)
       end
 
+      def serialize(record)
+        if value_block
+          record.instance_exec(&value_block)
+        else
+          record.public_send(name)
+        end.to_a
+      end
+
       private
 
       attr_reader :separator, :sortable, :no_index

data/lib/redi_search/schema.rb

@@ -10,29 +10,29 @@ module RediSearch
       instance_exec(&block)
     end
 
-    def text_field(name, **options, &block)
-      self[name] || push(Schema::TextField.new(name, **options, &block))
+    def text_field(name, ...)
+      self[name] || push(Schema::TextField.new(name, ...))
     end
 
-    def numeric_field(name, **options, &block)
-      self[name] || push(Schema::NumericField.new(name, **options, &block))
+    def numeric_field(name, ...)
+      self[name] || push(Schema::NumericField.new(name, ...))
     end
 
-    def tag_field(name, **options, &block)
-      self[name] || push(Schema::TagField.new(name, **options, &block))
+    def tag_field(name, ...)
+      self[name] || push(Schema::TagField.new(name, ...))
     end
 
-    def geo_field(name, **options, &block)
-      self[name] || push(Schema::GeoField.new(name, **options, &block))
+    def geo_field(name, ...)
+      self[name] || push(Schema::GeoField.new(name, ...))
     end
 
-    def add_field(name, type, **options, &block)
+    def add_field(name, type, ...)
       case type
       when :text then method(:text_field)
       when :numeric then method(:numeric_field)
       when :tag then method(:tag_field)
       when :geo then method(:geo_field)
-      end.call(name, **options, &block)
+      end.call(name, ...)
     end
 
     def to_a

data/lib/redi_search/search/clauses/highlight.rb

@@ -3,7 +3,9 @@
 module RediSearch
   class Search
     module Clauses
-      class Highlight
+      class Highlight < ApplicationClause
+        clause_order 12
+
         def initialize(fields: [], opening_tag: "<b>", closing_tag: "</b>")
           @fields = fields
           @opening_tag = opening_tag

data/lib/redi_search/search/clauses/in_order.rb

@@ -4,6 +4,8 @@ module RediSearch
   class Search
     module Clauses
       class InOrder < ApplicationClause
+        clause_order 15
+
         def clause
           validate!
 

data/lib/redi_search/search/clauses/language.rb

@@ -5,6 +5,7 @@ module RediSearch
     module Clauses
       class Language < ApplicationClause
         clause_term :language, presence: true
+        clause_order 16
 
         def initialize(language:)
           @language = language

data/lib/redi_search/search/clauses/limit.rb

@@ -10,6 +10,7 @@ module RediSearch
         clause_term :offset, presence: true, numericality: {
           within: 0..Float::INFINITY, only_integer: true
         }
+        clause_order 22
 
         def initialize(total:, offset: 0)
           @total = total

data/lib/redi_search/search/clauses/no_content.rb

@@ -4,6 +4,8 @@ module RediSearch
   class Search
     module Clauses
       class NoContent < ApplicationClause
+        clause_order 1
+
         def clause
           validate!
 

data/lib/redi_search/search/clauses/no_stop_words.rb

@@ -4,6 +4,8 @@ module RediSearch
   class Search
     module Clauses
       class NoStopWords < ApplicationClause
+        clause_order 3
+
         def clause
           validate!
 

data/lib/redi_search/search/clauses/return.rb

@@ -5,6 +5,7 @@ module RediSearch
     module Clauses
       class Return < ApplicationClause
         clause_term :fields, presence: true
+        clause_order 10
 
         def initialize(fields:)
           @fields = fields

data/lib/redi_search/search/clauses/slop.rb

@@ -5,6 +5,7 @@ module RediSearch
     module Clauses
       class Slop < ApplicationClause
         clause_term :slop, numericality: { within: 0..Float::INFINITY }
+        clause_order 13
 
         def initialize(slop:)
           @slop = slop

data/lib/redi_search/search/clauses/sort_by.rb

@@ -6,6 +6,7 @@ module RediSearch
       class SortBy < ApplicationClause
         clause_term :field, presence: true
         clause_term :order, presence: true, inclusion: { within: %i(asc desc) }
+        clause_order 21
 
         def initialize(field:, order: :asc)
           @field = field

data/lib/redi_search/search/clauses/timeout.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Search
+    module Clauses
+      class Timeout < ApplicationClause
+        clause_term :timeout,
+                    numericality: { within: 0..Float::INFINITY,
+                                    only_integer: true }
+        clause_order 14
+
+        def initialize(timeout:)
+          @timeout = timeout
+        end
+
+        def clause
+          validate!
+
+          ["TIMEOUT", timeout]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/search/clauses/verbatim.rb

@@ -4,6 +4,8 @@ module RediSearch
   class Search
     module Clauses
       class Verbatim < ApplicationClause
+        clause_order 2
+
         def clause
           validate!
 

data/lib/redi_search/search/clauses/with_payloads.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Search
+    module Clauses
+      class WithPayloads < ApplicationClause
+        clause_order 5
+
+        def clause
+          validate!
+
+          ["WITHPAYLOADS"]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/search/clauses/with_scores.rb

@@ -4,6 +4,8 @@ module RediSearch
   class Search
     module Clauses
       class WithScores < ApplicationClause
+        clause_order 4
+
         def clause
           validate!
 

data/lib/redi_search/search/clauses/with_sort_keys.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Search
+    module Clauses
+      class WithSortKeys < ApplicationClause
+        clause_order 6
+
+        def clause
+          validate!
+
+          ["WITHSORTKEYS"]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/search/clauses.rb

@@ -3,96 +3,77 @@
 module RediSearch
   class Search
     module Clauses
-      def highlight(fields: [], opening_tag: "<b>", closing_tag: "</b>")
-        add_to_clause(Highlight.new(
-          fields: fields, opening_tag: opening_tag, closing_tag: closing_tag
-        ))
-      end
-
-      def slop(slop)
-        add_to_clause(Slop.new(slop: slop))
-      end
-
-      def in_order
-        add_to_clause(InOrder.new)
+      def no_content
+        add_to_clauses(NoContent.new)
       end
 
       def verbatim
-        add_to_clause(Verbatim.new)
+        add_to_clauses(Verbatim.new)
       end
 
       def no_stop_words
-        add_to_clause(NoStopWords.new)
+        add_to_clauses(NoStopWords.new)
       end
 
       def with_scores
-        add_to_clause(WithScores.new)
+        add_to_clauses(WithScores.new)
       end
 
-      def no_content
-        add_to_clause(NoContent.new)
+      def with_payloads
+        add_to_clauses(WithPayloads.new)
       end
 
-      def return(*fields)
-        add_to_clause(Return.new(fields: fields))
+      def with_sort_keys
+        add_to_clauses(WithSortKeys.new)
       end
 
-      def language(language)
-        add_to_clause(Language.new(language: language))
+      def return(*fields)
+        add_to_clauses(Return.new(fields: fields))
       end
 
-      def sort_by(field, order: :asc)
-        add_to_clause(SortBy.new(field: field, order: order))
+      def highlight(fields: [], opening_tag: "<b>", closing_tag: "</b>")
+        add_to_clauses(Highlight.new(
+          fields: fields, opening_tag: opening_tag, closing_tag: closing_tag
+        ))
       end
 
-      def limit(total, offset = 0)
-        add_to_clause(Limit.new(total: total, offset: offset))
+      def slop(slop)
+        add_to_clauses(Slop.new(slop: slop))
       end
 
-      def count
-        return to_a.size if loaded?
-
-        RediSearch.client.call!(
-          "SEARCH", index.name, term_clause.to_s, *Limit.new(total: 0).clause
-        ).first
+      def timeout(timeout)
+        add_to_clauses(Timeout.new(timeout: timeout))
       end
 
-      def where(**condition)
-        @term_clause = Where.new(self, condition, @term_clause)
-
-        self
+      def in_order
+        add_to_clauses(InOrder.new)
       end
 
-      def not(**condition)
-        raise NoMethodError unless @term_clause.is_a?(Where)
-
-        @term_clause.not(condition)
+      def language(language)
+        add_to_clauses(Language.new(language: language))
       end
 
-      def and(new_term = nil, **term_options)
-        @term_clause = And.new(self, new_term, @term_clause, **term_options)
+      def sort_by(field, order: :asc)
+        add_to_clauses(SortBy.new(field: field, order: order))
+      end
 
-        if new_term.nil?
-          @term_clause
-        else
-          self
-        end
+      def limit(total, offset = 0)
+        add_to_clauses(Limit.new(total: total, offset: offset))
       end
 
-      def or(new_term = nil, **term_options)
-        @term_clause = Or.new(self, new_term, @term_clause, **term_options)
+      def count
+        return to_a.size if loaded?
 
-        if new_term.nil?
-          @term_clause
-        else
-          self
-        end
+        RediSearch.client.call!(
+          "SEARCH", index.name, query.to_s, *Limit.new(total: 0).clause
+        ).first
       end
 
       private
 
-      def add_to_clause(clause)
-        clauses.push(*clause.clause) if used_clauses.add?(clause.class)
+      def add_to_clauses(clause)
+        clause.validate! && clauses.push(clause) if
+          used_clauses.add?(clause.class)
 
         self
       end

data/lib/redi_search/search/{clauses → queries}/and.rb

@@ -2,7 +2,7 @@
 
 module RediSearch
   class Search
-    module Clauses
+    module Queries
       class And < Boolean
         private
 

data/lib/redi_search/search/{clauses → queries}/boolean.rb

@@ -2,7 +2,7 @@
 
 module RediSearch
   class Search
-    module Clauses
+    module Queries
       class Boolean
         extend Forwardable
 
@@ -65,10 +65,10 @@ module RediSearch
         end
 
         def queryify_search
-          if term.term_clause.is_a?(RediSearch::Search::Clauses::Where)
-            term.term_clause
+          if term.query.is_a?(RediSearch::Search::Queries::Where)
+            term.query
           else
-            "(#{term.term_clause})"
+            "(#{term.query})"
           end
         end
       end

data/lib/redi_search/search/{clauses → queries}/or.rb

@@ -2,7 +2,7 @@
 
 module RediSearch
   class Search
-    module Clauses
+    module Queries
       class Or < Boolean
         def where(**condition)
           @term = search.dup.where(**condition)

data/lib/redi_search/search/{clauses → queries}/where.rb

@@ -2,7 +2,7 @@
 
 module RediSearch
   class Search
-    module Clauses
+    module Queries
       class Where
         extend Forwardable
 
@@ -39,7 +39,7 @@ module RediSearch
 
         def queryify_term
           if term.is_a? RediSearch::Search
-            "(#{term.term_clause})"
+            "(#{term.query})"
           else
             term.to_s
           end