redi_search 1.0.3 → 2.0.2

data/lib/redi_search/log_subscriber.rb

@@ -1,82 +1,53 @@
 # frozen_string_literal: true
 
+require "active_support/log_subscriber"
+
 module RediSearch
   class LogSubscriber < ActiveSupport::LogSubscriber
     def self.runtime=(value)
-      Thread.current[:searchkick_runtime] = value
+      Thread.current[:redi_search_runtime] = value
     end
 
     def self.runtime
-      Thread.current[:searchkick_runtime] ||= 0
+      Thread.current[:redi_search_runtime] ||= 0
     end
 
     #:nocov:
     def self.reset_runtime
-      rt = runtime
-      self.runtime = 0
+      rt, self.runtime = runtime, 0
       rt
     end
     #:nocov:
 
-    def search(event)
-      log_command(event, YELLOW)
-    end
-
-    def create(event)
-      log_command(event, GREEN)
-    end
-
-    def drop(event)
-      log_command(event, RED)
-    end
-
-    def add(event)
-      log_command(event, GREEN)
-    end
-
-    def info(event)
-      log_command(event, CYAN)
-    end
-
-    def pipeline(event)
-      log_command(event, MAGENTA)
-    end
-
-    def get(event)
-      log_command(event, CYAN)
-    end
-
-    def mget(event)
-      log_command(event, CYAN)
-    end
-
-    def del(event)
-      log_command(event, RED)
-    end
-
-    def spellcheck(event)
-      log_command(event, YELLOW)
-    end
-
-    def explaincli(event)
-      log_command(event, BLUE)
-    end
-
-    private
-
-    def log_command(event, debug_color)
+    def action(event)
       self.class.runtime += event.duration
       return unless logger.debug?
 
       command = command_string(event)
+      debug_color = action_color(event.payload[:action])
 
       debug "  #{log_name(event)}  #{color(command, debug_color, true)}"
     end
 
+    private
+
     def log_name(event)
       color("#{event.payload[:name]} (#{event.duration.round(1)}ms)", RED, true)
     end
 
+    # rubocop:disable Metrics/MethodLength
+    def action_color(action)
+      case action.to_sym
+      when :search, :spellcheck then YELLOW
+      when :create, :add then GREEN
+      when :drop, :del then RED
+      when :get, :mget, :info then CYAN
+      when :pipeline then MAGENTA
+      when :explaincli then BLUE
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
     def command_string(event)
       event.payload[:query].flatten.map.with_index do |arg, i|
         arg = "FT.#{arg}" if prepend_ft?(arg, i)
@@ -86,7 +57,7 @@ module RediSearch
     end
 
     def multiword?(string)
-      !string.to_s.starts_with?(/\(-?@/) && string.to_s.split(/\s|\|/).size > 1
+      !string.to_s.start_with?(/\(-?@/) && string.to_s.split(/\s|\|/).size > 1
     end
 
     def prepend_ft?(arg, index)

data/lib/redi_search/model.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
 require "redi_search/index"
-require "active_support/concern"
 
 module RediSearch
   module Model
-    extend ActiveSupport::Concern
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-    # rubocop:disable Metrics/BlockLength
-    class_methods do
+    module ClassMethods
       attr_reader :redi_search_index, :redi_search_serializer
 
-      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
       def redi_search(schema:, **options)
         @redi_search_index = Index.new(
           [options[:index_prefix],
@@ -24,26 +24,10 @@ module RediSearch
 
         scope :search_import, -> { all }
 
-        class << self
-          def search(term = nil, **term_options)
-            redi_search_index.search(term, **term_options)
-          end
-
-          def spellcheck(term, distance: 1)
-            redi_search_index.spellcheck(term, distance: distance)
-          end
-
-          def reindex(only: [], **options)
-            search_import.find_in_batches.all? do |group|
-              redi_search_index.reindex(
-                group.map { |record| record.redi_search_document(only: only) },
-                **options.deep_merge(replace: { partial: true })
-              )
-            end
-          end
-        end
+        include InstanceMethods
+        extend ModelClassMethods
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
 
       private
 
@@ -54,27 +38,47 @@ module RediSearch
           respond_to?(:after_destroy_commit)
       end
     end
-    # rubocop:enable Metrics/BlockLength
 
-    def redi_search_document(only: [])
-      Document.for_object(
-        self.class.redi_search_index, self,
-        only: only, serializer: self.class.redi_search_serializer
-      )
-    end
+    module ModelClassMethods
+      def search(term = nil, **term_options)
+        redi_search_index.search(term, **term_options)
+      end
 
-    def redi_search_delete_document
-      return unless self.class.redi_search_index.exist?
+      def spellcheck(term, distance: 1)
+        redi_search_index.spellcheck(term, distance: distance)
+      end
 
-      self.class.redi_search_index.del(
-        redi_search_document, delete_document: true
-      )
+      def reindex(recreate: false, only: [], **options)
+        search_import.find_in_batches.all? do |group|
+          redi_search_index.reindex(
+            group.map { |record| record.redi_search_document(only: only) },
+            recreate: recreate, **options.deep_merge(replace: { partial: true })
+          )
+        end
+      end
     end
 
-    def redi_search_add_document
-      return unless self.class.redi_search_index.exist?
+    module InstanceMethods
+      def redi_search_document(only: [])
+        Document.for_object(
+          self.class.redi_search_index, self,
+          only: only, serializer: self.class.redi_search_serializer
+        )
+      end
+
+      def redi_search_delete_document
+        return unless self.class.redi_search_index.exist?
 
-      self.class.redi_search_index.add(redi_search_document, replace: true)
+        self.class.redi_search_index.del(
+          redi_search_document, delete_document: true
+        )
+      end
+
+      def redi_search_add_document
+        return unless self.class.redi_search_index.exist?
+
+        self.class.redi_search_index.add(redi_search_document, replace: true)
+      end
     end
   end
 end

data/lib/redi_search/schema.rb

@@ -11,8 +11,8 @@ module RediSearch
       options = [options] if options.is_a? Symbol
       schema, options = options.to_a.flatten
 
-      "RediSearch::Schema::#{schema.to_s.capitalize}Field".
-        constantize.new(field_name, **options.to_h).to_a
+      Object.const_get("RediSearch::Schema::#{schema.to_s.capitalize}Field").
+        new(field_name, **options.to_h).to_a
     end
 
     def initialize(raw)
@@ -29,7 +29,7 @@ module RediSearch
       raw.keys
     end
 
-    def alter(field_name, options)
+    def add_field(field_name, options)
       raw[field_name] = options
       self
     end

data/lib/redi_search/schema/field.rb

@@ -11,9 +11,8 @@ module RediSearch
 
       def boolean_options_string
         boolean_options.map do |option|
-          unless FALSES.include?(send(option))
-            option.to_s.upcase.split("_").join
-          end
+          option.to_s.upcase.split("_").join unless
+            FALSES.include?(send(option))
         end.compact
       end
     end

data/lib/redi_search/schema/tag_field.rb

@@ -14,8 +14,8 @@ module RediSearch
 
       def to_a
         query = [name.to_s, "TAG"]
-        query += boolean_options_string
         query += ["SEPARATOR", separator] if separator
+        query += boolean_options_string
 
         query
       end

data/lib/redi_search/schema/text_field.rb

@@ -15,9 +15,9 @@ module RediSearch
 
       def to_a
         query = [name.to_s, "TEXT"]
-        query += boolean_options_string
         query += ["WEIGHT", weight] if weight
         query += ["PHONETIC", phonetic] if phonetic
+        query += boolean_options_string
 
         query
       end

data/lib/redi_search/search.rb

@@ -8,22 +8,28 @@ require "redi_search/search/result"
 
 module RediSearch
   class Search
-    include Enumerable
+    extend Forwardable
     include LazilyLoad
     include Clauses
 
+    attr_reader :term_clause, :used_clauses, :index, :clauses
+
+    def_delegator :index, :model
+
     def initialize(index, term = nil, **term_options)
       @index = index
       @clauses = []
       @used_clauses = Set.new
 
-      @term_clause = term.presence &&
+      @term_clause = term &&
         And.new(self, term, nil, **term_options)
     end
 
     def results
-      if index.model.present?
-        index.model.where(id: to_a.map(&:document_id_without_index))
+      if model
+        no_content unless loaded?
+
+        model.where(id: to_a.map(&:document_id_without_index))
       else
         to_a
       end
@@ -31,45 +37,28 @@ module RediSearch
 
     def explain
       RediSearch.client.call!(
-        "EXPLAINCLI", index.name, term_clause
+        "EXPLAINCLI", index.name, term_clause.to_s
       ).join(" ").strip
     end
 
-    def to_redis
-      command.map do |arg|
-        inspect_command_arg(arg)
-      end.join(" ")
-    end
-
     def dup
       self.class.new(index)
     end
 
-    attr_reader :term_clause
-
     private
 
-    attr_reader :documents, :used_clauses
-    attr_accessor :index, :clauses
+    attr_writer :index, :clauses
 
     def command
-      ["SEARCH", index.name, term_clause, *clauses.uniq]
+      ["SEARCH", index.name, term_clause.to_s, *clauses]
     end
 
     def parse_response(response)
-      @documents = Result.new(index, used_clauses, response[0], response[1..-1])
-    end
-
-    def inspect_command_arg(arg)
-      if !arg.to_s.starts_with?(/\(-?@/) && arg.to_s.split(/\s|\|/).size > 1
-        arg.inspect
-      else
-        arg
-      end
+      @documents = Result.new(self, response[0], response[1..-1])
     end
 
     def valid?
-      term_clause.present?
+      !term_clause.to_s.empty?
     end
   end
 end

data/lib/redi_search/search/clauses.rb

@@ -68,15 +68,15 @@ module RediSearch
       def count
         return to_a.size if loaded?
 
-        call!(
-          "SEARCH", index.name, term_clause, *Limit.new(total: 0).clause
+        RediSearch.client.call!(
+          "SEARCH", index.name, term_clause.to_s, *Limit.new(total: 0).clause
         ).first
       end
 
       def where(**condition)
         @term_clause = Where.new(self, condition, @term_clause)
 
-        if condition.blank?
+        if condition.empty?
           @term_clause
         else
           self
@@ -86,7 +86,7 @@ module RediSearch
       def and(new_term = nil, **term_options)
         @term_clause = And.new(self, new_term, @term_clause, **term_options)
 
-        if new_term.blank?
+        if new_term.nil?
           @term_clause
         else
           self
@@ -96,7 +96,7 @@ module RediSearch
       def or(new_term = nil, **term_options)
         @term_clause = Or.new(self, new_term, @term_clause, **term_options)
 
-        if new_term.blank?
+        if new_term.nil?
           @term_clause
         else
           self
@@ -106,8 +106,7 @@ module RediSearch
       private
 
       def add_to_clause(clause)
-        used_clauses.add(clause.class.name.demodulize.underscore)
-        clauses.push(*clause.clause)
+        clauses.push(*clause.clause) if used_clauses.add?(clause.class)
 
         self
       end

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

@@ -1,15 +1,30 @@
 # frozen_string_literal: true
 
+require "redi_search/validatable"
+
 module RediSearch
   class Search
     module Clauses
       class ApplicationClause
-        include ActiveModel::Validations
+        include Validatable
+
+        class << self
+          def clause_term(term, **validations)
+            attr_reader term
+
+            validations.each do |validation_type, options|
+              define_validation(term, validation_type, options)
+            end
+          end
+
+          private
 
-        def self.clause_term(term, *validations)
-          attr_reader term
-          validations.each do |validation|
-            validates term, validation
+          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