redi_search 0.1.0

data/lib/redi_search/index.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "redi_search/schema"
+require "redi_search/search"
+require "redi_search/spellcheck"
+
+module RediSearch
+  class Index
+    attr_reader :name, :schema, :model
+
+    def initialize(name, schema, model = nil)
+      @name = name
+      @schema = Schema.new(schema)
+      @model = model
+    end
+
+    def search(term = nil, **term_options)
+      Search.new(self, term, model, **term_options)
+    end
+
+    def spellcheck(query, distance: 1)
+      Spellcheck.new(self, query, distance: distance)
+    end
+
+    def create
+      create!
+    rescue Redis::CommandError
+      false
+    end
+
+    def create!
+      client.call!("CREATE", name, "SCHEMA", schema.to_a).ok?
+    end
+
+    def drop
+      drop!
+    rescue Redis::CommandError
+      false
+    end
+
+    def drop!
+      client.call!("DROP", name).ok?
+    end
+
+    def add(record, score = 1.0)
+      add!(record, score)
+    rescue Redis::CommandError
+      false
+    end
+
+    def add!(record, score = 1.0)
+      client.call!(
+        "ADD", name, record.id, score, "REPLACE", "FIELDS",
+        Document::Converter.new(self, record).document.to_a
+      )
+    end
+
+    def add_multiple!(records)
+      client.pipelined do
+        records.each do |record|
+          add!(record)
+        end
+      end.ok?
+    end
+
+    def del(record, delete_document: false)
+      client.call!("DEL", name, record.id, ("DD" if delete_document))
+    end
+
+    def exist?
+      !client.call!("INFO", name).empty?
+    rescue Redis::CommandError
+      false
+    end
+
+    def info
+      hash = Hash[*client.call!("INFO", name)]
+      info_struct = Struct.new(*hash.keys.map(&:to_sym))
+      info_struct.new(*hash.values)
+    rescue Redis::CommandError
+      nil
+    end
+
+    def fields
+      @fields ||= schema.fields.map(&:to_s)
+    end
+
+    def reindex(docs)
+      drop if exist?
+      create
+      add_multiple! docs
+    end
+
+    private
+
+    def client
+      RediSearch.client
+    end
+  end
+end

data/lib/redi_search/log_subscriber.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.runtime=(value)
+      Thread.current[:searchkick_runtime] = value
+    end
+
+    def self.runtime
+      Thread.current[:searchkick_runtime] ||= 0
+    end
+
+    #:nocov:
+    def self.reset_runtime
+      rt = runtime
+      self.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
+
+    private
+
+    def log_command(event, debug_color)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+      name = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      command = command_string(payload)
+
+      debug "  #{color(name, RED, true)}  #{color(command, debug_color, true)}"
+    end
+
+    def command_string(payload)
+      payload[:query].flatten.map.with_index do |arg, i|
+        arg = "FT.#{arg}" if prepend_ft?(arg, i)
+        arg = arg.inspect if inspect_arg?(payload, arg)
+        arg
+      end.join(" ")
+    end
+
+    def multiword?(string)
+      !string.to_s.starts_with?(/\(-?@/) && string.to_s.split(/\s|\|/).size > 1
+    end
+
+    def prepend_ft?(arg, index)
+      index.zero? && !multiword?(arg)
+    end
+
+    def inspect_arg?(payload, arg)
+      multiword?(arg) && payload[:query].flatten.count > 1
+    end
+  end
+end

data/lib/redi_search/model.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "redi_search/index"
+require "redi_search/document/converter"
+
+require "active_support/concern"
+
+module RediSearch
+  module Model
+    extend ActiveSupport::Concern
+
+    class_methods do
+      attr_reader :redi_search_index
+
+      def redi_search(**options) # rubocop:disable Metrics/MethodLength
+        @redi_search_index = Index.new(
+          options[:index_name] || "#{name.underscore}_idx",
+          options[:schema],
+          self
+        )
+
+        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
+
+        class << self
+          def search(term = nil, **term_options)
+            redi_search_index.search(term, **term_options)
+          end
+
+          def reindex
+            redi_search_index.reindex(all)
+          end
+        end
+      end
+    end
+
+    def redi_search_document
+      Document::Converter.new(self.class.redi_search_index, self).document
+    end
+
+    def redi_search_delete_document
+      return unless self.class.redi_search_index.exist?
+
+      self.class.redi_search_index.del(self, delete_document: true)
+    end
+
+    def redi_search_add_document
+      return unless self.class.redi_search_index.exist?
+
+      self.class.redi_search_index.add(self)
+    end
+  end
+end

data/lib/redi_search/result/collection.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Result
+    class Collection < Array
+      def initialize(index, count, records)
+        @count = count
+        super(Hash[*records].map do |doc_id, fields|
+          Document.new(index, doc_id, Hash[*fields])
+        end)
+      end
+
+      def count
+        @count || super
+      end
+
+      def size
+        @count || super
+      end
+    end
+  end
+end

data/lib/redi_search/schema/field.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Schema
+    class Field
+      private
+
+      FALSES = [
+        nil, "", false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"
+      ].freeze
+
+      def boolean_options_string
+        boolean_options.map do |option|
+          unless FALSES.include?(send(option))
+            option.to_s.upcase.split("_").join
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/redi_search/schema/geo_field.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "redi_search/schema/field"
+
+module RediSearch
+  class Schema
+    class GeoField < Field
+      def initialize(name, sortable: false, no_index: false)
+        @name = name
+        @sortable = sortable
+        @no_index = no_index
+      end
+
+      def to_a
+        query = [name.to_s, "GEO"]
+        query += boolean_options_string
+
+        query
+      end
+
+      private
+
+      attr_reader :name, :sortable, :no_index
+
+      def boolean_options
+        %i(sortable no_index)
+      end
+    end
+  end
+end

data/lib/redi_search/schema/numeric_field.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "redi_search/schema/field"
+
+module RediSearch
+  class Schema
+    class NumericField < Field
+      def initialize(name, sortable: false, no_index: false)
+        @name = name
+        @sortable = sortable
+        @no_index = no_index
+      end
+
+      def to_a
+        query = [name.to_s, "NUMERIC"]
+        query += boolean_options_string
+
+        query
+      end
+
+      private
+
+      attr_reader :name, :sortable, :no_index
+
+      def boolean_options
+        %i(sortable no_index)
+      end
+    end
+  end
+end

data/lib/redi_search/schema/tag_field.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "redi_search/schema/field"
+
+module RediSearch
+  class Schema
+    class TagField < Field
+      def initialize(name, separator: ",", sortable: false, no_index: false)
+        @name = name
+        @separator = separator
+        @sortable = sortable
+        @no_index = no_index
+      end
+
+      def to_a
+        query = [name.to_s, "TAG"]
+        query += boolean_options_string
+        query += ["SEPARATOR", separator] if separator
+
+        query
+      end
+
+      private
+
+      attr_reader :name, :separator, :sortable, :no_index
+
+      def boolean_options
+        %i(sortable no_index)
+      end
+    end
+  end
+end

data/lib/redi_search/schema/text_field.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_record/type"
+
+module RediSearch
+  class Schema
+    class TextField < Field
+      def initialize(name, weight: 1.0, phonetic: nil, sortable: false,
+                     no_index: false, no_stem: false)
+        @name = name
+        @weight = weight
+        @phonetic = phonetic
+        @sortable = sortable
+        @no_index = no_index
+        @no_stem = no_stem
+      end
+
+      def to_a
+        query = [name.to_s, "TEXT"]
+        query += boolean_options_string
+        query += ["WEIGHT", weight] if weight
+        query += ["PHONETIC", phonetic] if phonetic
+
+        query
+      end
+
+      private
+
+      attr_reader :name, :weight, :phonetic, :sortable, :no_index, :no_stem
+
+      def boolean_options
+        %i(sortable no_index no_stem)
+      end
+    end
+  end
+end

data/lib/redi_search/schema.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "redi_search/schema/geo_field"
+require "redi_search/schema/numeric_field"
+require "redi_search/schema/tag_field"
+require "redi_search/schema/text_field"
+
+module RediSearch
+  class Schema
+    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
+      end.flatten
+    end
+
+    def fields
+      raw.keys
+    end
+
+    private
+
+    attr_reader :raw
+  end
+end

data/lib/redi_search/search/and_clause.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "redi_search/search/boolean_clause"
+
+module RediSearch
+  class Search
+    class AndClause < BooleanClause
+      private
+
+      def operand
+        " "
+      end
+    end
+  end
+end

data/lib/redi_search/search/boolean_clause.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Search
+    class BooleanClause
+      def initialize(search, term, prior_clause = nil, **term_options)
+        @search = search
+        @prior_clause = prior_clause
+        @not = false
+
+        initialize_term(term, **term_options)
+      end
+
+      def to_s
+        raise ArgumentError, "missing query terms" if term.blank?
+
+        [
+          prior_clause.presence,
+          queryify_term.dup.prepend(not_operator)
+        ].compact.join(operand)
+      end
+
+      def inspect
+        to_s.inspect
+      end
+
+      def not(term, **term_options)
+        @not = true
+
+        initialize_term(term, **term_options)
+
+        search
+      end
+
+      private
+
+      attr_reader :prior_clause, :term, :search
+
+      def operand
+        raise NotImplementedError
+      end
+
+      def not_operator
+        return "" unless @not
+
+        "-"
+      end
+
+      def initialize_term(term, **term_options)
+        return if term.blank?
+
+        @term =
+          if term.is_a? RediSearch::Search
+            term
+          else
+            Term.new(term, term_options)
+          end
+      end
+
+      def queryify_term
+        if term.is_a?(RediSearch::Search) &&
+           !term.term_clause.is_a?(RediSearch::Search::WhereClause)
+          "(#{term.term_clause})"
+        elsif term.is_a?(RediSearch::Search)
+          term.term_clause
+        else
+          term
+        end.to_s
+      end
+    end
+  end
+end

data/lib/redi_search/search/clauses.rb

@@ -0,0 +1,89 @@
+# 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"
+
+module RediSearch
+  class Search
+    module Clauses
+      def highlight(**options)
+        clauses.push(*HighlightClause.new(**options).clause)
+
+        self
+      end
+
+      def slop(slop)
+        clauses.push("SLOP", slop)
+
+        self
+      end
+
+      def in_order
+        clauses.push("INORDER")
+
+        self
+      end
+
+      def no_content
+        @no_content = true
+        clauses.push("NOCONTENT")
+
+        self
+      end
+
+      def language(language)
+        clauses.push("LANGUAGE", language)
+
+        self
+      end
+
+      def sort_by(field, order: :asc)
+        raise ArgumentError unless %i(asc desc).include?(order.to_sym)
+
+        clauses.push("SORTBY", field, order)
+
+        self
+      end
+
+      def limit(num, offset = 0)
+        clauses.push("LIMIT", offset, num)
+
+        self
+      end
+
+      def where(**condition)
+        @term_clause = WhereClause.new(self, condition, @term_clause)
+
+        if condition.blank?
+          @term_clause
+        else
+          self
+        end
+      end
+
+      def and(new_term = nil, **term_options)
+        @term_clause =
+          AndClause.new(self, new_term, @term_clause, **term_options)
+
+        if new_term.blank?
+          @term_clause
+        else
+          self
+        end
+      end
+
+      def or(new_term = nil, **term_options)
+        @term_clause =
+          OrClause.new(self, new_term, @term_clause, **term_options)
+
+        if new_term.blank?
+          @term_clause
+        else
+          self
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/search/highlight_clause.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Search
+    class HighlightClause
+      def initialize(**options)
+        @options = options.to_h
+
+        parse_options
+      end
+
+      def clause
+        [
+          "HIGHLIGHT",
+          (fields_clause(**options[:fields]) if options.key?(:fields)),
+          (tags_clause(**options[:tags]) if options.key? :tags),
+        ].compact.flatten(1)
+      end
+
+      private
+
+      attr_reader :options, :tags_args, :fields_args
+
+      def parse_options
+        return if options.except(:fields, :tags).empty?
+
+        arg_error "Unsupported argument: #{options}"
+      end
+
+      def tags_clause(open:, close:)
+        ["TAGS", open, close]
+      end
+
+      def fields_clause(num:, field:)
+        ["FIELDS", num, field]
+      end
+
+      def arg_error(msg)
+        raise ArgumentError, "Highlight: #{msg}"
+      end
+    end
+  end
+end

data/lib/redi_search/search/or_clause.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "redi_search/search/boolean_clause"
+
+module RediSearch
+  class Search
+    class OrClause < BooleanClause
+      def where(**condition)
+        @term = search.dup.where(condition)
+
+        search
+      end
+
+      private
+
+      def operand
+        "|"
+      end
+    end
+  end
+end