redi_search 0.1.0 → 1.0.0

data/lib/redi_search/log_subscriber.rb

@@ -58,6 +58,10 @@ module RediSearch
       log_command(event, YELLOW)
     end
 
+    def explaincli(event)
+      log_command(event, BLUE)
+    end
+
     private
 
     def log_command(event, debug_color)

data/lib/redi_search/model.rb

@@ -1,57 +1,80 @@
 # frozen_string_literal: true
 
 require "redi_search/index"
-require "redi_search/document/converter"
-
 require "active_support/concern"
 
 module RediSearch
   module Model
     extend ActiveSupport::Concern
 
+    # rubocop:disable Metrics/BlockLength
     class_methods do
-      attr_reader :redi_search_index
+      attr_reader :redi_search_index, :redi_search_serializer
 
-      def redi_search(**options) # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def redi_search(schema:, **options)
         @redi_search_index = Index.new(
-          options[:index_name] || "#{name.underscore}_idx",
-          options[:schema],
+          [options[:index_prefix],
+           model_name.plural, RediSearch.env].compact.join("_"),
+          schema,
           self
         )
+        @redi_search_serializer = options[:serializer]
+        register_redi_search_commit_hooks
 
-        if respond_to? :after_commit
-          after_commit :redi_search_add_document, on: [:create, :update]
-        end
-        if respond_to? :after_destroy_commit
-          after_destroy_commit :redi_search_delete_document
-        end
+        scope :search_import, -> { all }
 
         class << self
           def search(term = nil, **term_options)
             redi_search_index.search(term, **term_options)
           end
 
-          def reindex
-            redi_search_index.reindex(all)
+          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
       end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      private
+
+      def register_redi_search_commit_hooks
+        after_commit(:redi_search_add_document, on: %i(create update)) if
+          respond_to?(:after_commit)
+        after_destroy_commit(:redi_search_delete_document) if
+          respond_to?(:after_destroy_commit)
+      end
     end
+    # rubocop:enable Metrics/BlockLength
 
-    def redi_search_document
-      Document::Converter.new(self.class.redi_search_index, self).document
+    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.del(self, delete_document: 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(self)
+      self.class.redi_search_index.add(redi_search_document, replace: true)
     end
   end
 end

data/lib/redi_search/schema.rb

@@ -7,19 +7,23 @@ require "redi_search/schema/text_field"
 
 module RediSearch
   class Schema
+    def self.make_field(field_name, options)
+      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
+    end
+
     def initialize(raw)
       @raw = raw
     end
 
     def to_a
       raw.map do |field_name, options|
-        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
+        self.class.make_field(field_name, options)
       end.flatten
     end
 
@@ -27,8 +31,13 @@ module RediSearch
       raw.keys
     end
 
+    def alter(field_name, options)
+      raw[field_name] = options
+      self
+    end
+
     private
 
-    attr_reader :raw
+    attr_accessor :raw
   end
 end

data/lib/redi_search/schema/text_field.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_record/type"
-
 module RediSearch
   class Schema
     class TextField < Field

data/lib/redi_search/search.rb

@@ -1,51 +1,39 @@
 # frozen_string_literal: true
 
+require "redi_search/lazily_load"
+
 require "redi_search/search/clauses"
 require "redi_search/search/term"
-require "redi_search/search/highlight_clause"
-require "redi_search/result/collection"
+require "redi_search/search/result"
 
 module RediSearch
   class Search
     include Enumerable
+    include LazilyLoad
     include Clauses
 
-    def initialize(index, term = nil, model = nil, **term_options)
+    def initialize(index, term = nil, **term_options)
       @index = index
-      @model = model
-      @loaded = false
-      @no_content = false
       @clauses = []
+      @used_clauses = Set.new
 
       @term_clause = term.presence &&
-        AndClause.new(self, term, nil, **term_options)
-    end
-
-    #:nocov:
-    def pretty_print(printer)
-      execute unless loaded?
-
-      printer.pp(records)
-    rescue Redis::CommandError => e
-      printer.pp(e.message)
-    end
-    #:nocov:
-
-    def loaded?
-      @loaded
-    end
-
-    def to_a
-      execute unless loaded?
-
-      @records
+        And.new(self, term, nil, **term_options)
     end
 
     def results
-      model.where(id: to_a.map(&:document_id))
+      if index.model.present?
+        index.model.where(id: to_a.map(&:document_id_without_index))
+      else
+        to_a
+      end
     end
 
-    delegate :count, :each, to: :to_a
+    def explain
+      RediSearch.client.call!(
+        "EXPLAINCLI", index.name, term_clause
+      ).join(" ").strip
+    end
 
     def to_redis
       command.map do |arg|
@@ -65,25 +53,15 @@ module RediSearch
 
     private
 
-    attr_reader :records
-    attr_accessor :index, :model, :clauses
+    attr_reader :documents, :used_clauses
+    attr_accessor :index, :clauses
 
     def command
-      ["SEARCH", index.name, term_clause, *clauses]
+      ["SEARCH", index.name, term_clause, *clauses.uniq]
     end
 
-    def execute
-      @loaded = true
-
-      RediSearch.client.call!(*command).then do |results|
-        @records = Result::Collection.new(
-          index, results[0], results[1..-1].then do |docs|
-            next docs unless @no_content
-
-            docs.zip([[]] * results[0]).flatten(1)
-          end
-        )
-      end
+    def parse_response(response)
+      @documents = Result.new(index, used_clauses, response[0], response[1..-1])
     end
   end
 end

data/lib/redi_search/search/clauses.rb

@@ -1,60 +1,82 @@
 # frozen_string_literal: true
 
 require "redi_search/search/term"
-require "redi_search/search/and_clause"
-require "redi_search/search/or_clause"
-require "redi_search/search/where_clause"
+require "redi_search/search/clauses/slop"
+require "redi_search/search/clauses/in_order"
+require "redi_search/search/clauses/language"
+require "redi_search/search/clauses/sort_by"
+require "redi_search/search/clauses/limit"
+require "redi_search/search/clauses/no_content"
+require "redi_search/search/clauses/verbatim"
+require "redi_search/search/clauses/no_stop_words"
+require "redi_search/search/clauses/return"
+require "redi_search/search/clauses/with_scores"
+require "redi_search/search/clauses/highlight"
+require "redi_search/search/clauses/and"
+require "redi_search/search/clauses/or"
+require "redi_search/search/clauses/where"
 
 module RediSearch
   class Search
     module Clauses
-      def highlight(**options)
-        clauses.push(*HighlightClause.new(**options).clause)
-
-        self
+      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)
-        clauses.push("SLOP", slop)
-
-        self
+        add_to_clause(Slop.new(slop: slop))
       end
 
       def in_order
-        clauses.push("INORDER")
+        add_to_clause(InOrder.new)
+      end
 
-        self
+      def verbatim
+        add_to_clause(Verbatim.new)
+      end
+
+      def no_stop_words
+        add_to_clause(NoStopWords.new)
+      end
+
+      def with_scores
+        add_to_clause(WithScores.new)
       end
 
       def no_content
-        @no_content = true
-        clauses.push("NOCONTENT")
+        add_to_clause(NoContent.new)
+      end
 
-        self
+      def return(*fields)
+        add_to_clause(Return.new(fields: fields))
       end
 
       def language(language)
-        clauses.push("LANGUAGE", language)
-
-        self
+        add_to_clause(Language.new(language: language))
       end
 
       def sort_by(field, order: :asc)
-        raise ArgumentError unless %i(asc desc).include?(order.to_sym)
-
-        clauses.push("SORTBY", field, order)
-
-        self
+        add_to_clause(SortBy.new(field: field, order: order))
       end
 
-      def limit(num, offset = 0)
-        clauses.push("LIMIT", offset, num)
+      def limit(total, offset = 0)
+        add_to_clause(Limit.new(total: total, offset: offset))
+      end
 
-        self
+      def count
+        if @loaded
+          to_a.size
+        else
+          RediSearch.client.call!(
+            "SEARCH", index.name, term_clause, *Limit.new(total: 0).clause
+          ).first
+        end
       end
 
       def where(**condition)
-        @term_clause = WhereClause.new(self, condition, @term_clause)
+        @term_clause = Where.new(self, condition, @term_clause)
 
         if condition.blank?
           @term_clause
@@ -64,8 +86,7 @@ module RediSearch
       end
 
       def and(new_term = nil, **term_options)
-        @term_clause =
-          AndClause.new(self, new_term, @term_clause, **term_options)
+        @term_clause = And.new(self, new_term, @term_clause, **term_options)
 
         if new_term.blank?
           @term_clause
@@ -75,8 +96,7 @@ module RediSearch
       end
 
       def or(new_term = nil, **term_options)
-        @term_clause =
-          OrClause.new(self, new_term, @term_clause, **term_options)
+        @term_clause = Or.new(self, new_term, @term_clause, **term_options)
 
         if new_term.blank?
           @term_clause
@@ -84,6 +104,15 @@ module RediSearch
           self
         end
       end
+
+      private
+
+      def add_to_clause(clause)
+        used_clauses.add(clause.class.name.demodulize.underscore)
+        clauses.push(*clause.clause)
+
+        self
+      end
     end
   end
 end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "redi_search/search/clauses/boolean"
+
+module RediSearch
+  class Search
+    module Clauses
+      class And < Boolean
+        private
+
+        def operand
+          " "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Search
+    module Clauses
+      class ApplicationClause
+        include ActiveModel::Validations
+
+        def self.clause_term(term, *validations)
+          attr_reader term
+          validations.each do |validation|
+            validates term, validation
+          end
+        end
+      end
+    end
+  end
+end