redi_search 0.1.0 → 1.0.0

data/lib/redi_search.rb

@@ -2,6 +2,7 @@
 
 require "redis"
 require "active_support"
+require "active_model"
 require "active_support/core_ext/object"
 require "active_support/core_ext/module/delegation"
 
@@ -28,8 +29,10 @@ module RediSearch
       yield(configuration)
     end
 
-    def client
-      configuration.client
+    delegate :client, to: :configuration
+
+    def env
+      @env ||= ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
     end
   end
 end

data/lib/redi_search/add.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Add
+    include ActiveModel::Validations
+
+    validates :score, numericality: {
+      greater_than_or_equal_to: 0.0, less_than_or_equal_to: 1.0
+    }
+
+    def initialize(index, document, score: 1.0, replace: {}, language: nil,
+                   no_save: false)
+      @index = index
+      @document = document
+      @score = score || 1.0
+      @replace = replace
+      @language = language
+      @no_save = no_save
+    end
+
+    def call!
+      validate!
+
+      RediSearch.client.call!(*command).ok?
+    end
+
+    def call
+      call!
+    rescue Redis::CommandError
+      false
+    end
+
+    private
+
+    attr_reader :index, :document, :score, :replace, :language, :no_save
+
+    def command
+      [
+        "ADD",
+        index.name,
+        document.document_id,
+        score,
+        *extract_options,
+        "FIELDS",
+        document.redis_attributes
+      ].compact
+    end
+
+    def extract_options
+      opts = []
+      opts << ["LANGUAGE", language] if language
+      opts << "NOSAVE" if no_save
+      opts << replace_options if replace?
+      opts
+    end
+
+    def replace?
+      replace.present?
+    end
+
+    def replace_options
+      ["REPLACE"].tap do |replace_option|
+        if replace.is_a?(Hash)
+          replace_option << "PARTIAL" if replace[:partial]
+          # replace_option << "NOCREATE" if replace[:no_create]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/alter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Alter
+    def initialize(index, field_name, schema)
+      @index = index
+      @field_name = field_name
+      @raw_schema = schema
+    end
+
+    def call!
+      index.schema.alter(field_name, raw_schema)
+      RediSearch.client.call!(
+        "ALTER",
+        index.name,
+        "SCHEMA",
+        "ADD",
+        *field_schema
+      ).ok?
+    end
+
+    private
+
+    attr_reader :index, :field_name, :raw_schema
+
+    def field_schema
+      @field_schema ||= Schema.make_field(field_name, raw_schema)
+    end
+  end
+end

data/lib/redi_search/create.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Create
+    OPTION_MAPPER = {
+      max_text_fields: "MAXTEXTFIELDS",
+      no_offsets: "NOOFFSETS",
+      no_highlight: "NOHL",
+      no_fields: "NOFIELDS",
+      no_frequencies: "NOFREQS"
+    }.freeze
+
+    def initialize(index, schema, options)
+      @index = index
+      @schema = schema
+      @options = options
+    end
+
+    def call!
+      RediSearch.client.call!(
+        "CREATE",
+        index.name,
+        *extract_options.compact,
+        "SCHEMA",
+        schema.to_a
+      ).ok?
+    end
+
+    def call
+      call!
+    rescue Redis::CommandError
+      false
+    end
+
+    private
+
+    attr_reader :index, :schema, :options
+
+    def extract_options
+      options.map do |clause, switch|
+        next unless OPTION_MAPPER.key?(clause.to_sym) && switch
+
+        OPTION_MAPPER[clause.to_sym]
+      end << temporary_option
+    end
+
+    def temporary_option
+      return [] unless options[:temporary]
+
+      ["TEMPORARY", options[:temporary]]
+    end
+  end
+end

data/lib/redi_search/document.rb

@@ -3,8 +3,22 @@
 module RediSearch
   class Document
     class << self
+      def for_object(index, record, serializer: nil, only: [])
+        object_to_serialize = serializer&.new(record) || record
+
+        field_values = index.schema.fields.map do |field|
+          next if only.present? && !only.include?(field.to_sym)
+
+          [field.to_s, object_to_serialize.public_send(field)]
+        end.compact.to_h
+
+        new(index, object_to_serialize.id, field_values)
+      end
+
       def get(index, document_id)
-        response = RediSearch.client.call!("GET", index.name, document_id)
+        response = RediSearch.client.call!(
+          "GET", index.name, prepend_document_id(index, document_id)
+        )
 
         return if response.blank?
 
@@ -12,41 +26,62 @@ module RediSearch
       end
 
       def mget(index, *document_ids)
+        unique_document_ids = document_ids.map do |id|
+          prepend_document_id(index, id)
+        end
         document_ids.zip(
-          RediSearch.client.call!("MGET", index.name, *document_ids)
+          RediSearch.client.call!("MGET", index.name, *unique_document_ids)
         ).map do |document|
           next if document[1].blank?
 
           new(index, document[0], Hash[*document[1]])
         end.compact
       end
+
+      def prepend_document_id(index, document_id)
+        if document_id.to_s.starts_with? index.name
+          document_id
+        else
+          "#{index.name}#{document_id}"
+        end
+      end
     end
 
-    attr_reader :document_id
+    attr_reader :attributes, :score
 
-    def initialize(index, document_id, fields)
+    def initialize(index, document_id, fields, score = nil)
       @index = index
       @document_id = document_id
-      @to_a = []
+      @attributes = fields
+      @score = score
 
-      schema_fields.each do |field|
-        @to_a.push([field, fields[field]])
-        instance_variable_set(:"@#{field}", fields[field])
-        define_singleton_method field do
-          fields[field]
-        end
+      attributes.each do |field, value|
+        next unless schema_fields.include? field
+
+        instance_variable_set(:"@#{field}", value)
+        define_singleton_method(field) { value }
       end
     end
 
-    def del
-      client.call!("DEL", index.name, document_id).ok?
+    def del(delete_document: false)
+      client.call!(
+        "DEL", index.name, document_id, ("DD" if delete_document)
+      ) == 1
     end
 
     #:nocov:
+    def inspect
+      inspection = pretty_print_attributes.map do |field_name|
+        "#{field_name}: #{public_send(field_name)}"
+      end.compact.join(", ")
+
+      "#<#{self.class} #{inspection}>"
+    end
+
     def pretty_print(printer) # rubocop:disable Metrics/MethodLength
       printer.object_address_group(self) do
         printer.seplist(
-          schema_fields.append("document_id"), proc { printer.text "," }
+          pretty_print_attributes , proc { printer.text "," }
         ) do |field_name|
           printer.breakable " "
           printer.group(1) do
@@ -58,14 +93,34 @@ module RediSearch
         end
       end
     end
+
+    def pretty_print_attributes
+      pp_attrs = attributes.keys.dup
+      pp_attrs.push("document_id")
+      pp_attrs.push("score") if score.present?
+
+      pp_attrs.compact
+    end
     #:nocov:
 
     def schema_fields
       @schema_fields ||= index.schema.fields.map(&:to_s)
     end
 
-    def to_a
-      @to_a.flatten
+    def redis_attributes
+      attributes.to_a.flatten
+    end
+
+    def document_id
+      self.class.prepend_document_id(index, @document_id)
+    end
+
+    def document_id_without_index
+      if @document_id.to_s.starts_with? index.name
+        @document_id.gsub(index.name, "")
+      else
+        @document_id
+      end
     end
 
     private

data/lib/redi_search/index.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require "redi_search/add"
+require "redi_search/create"
 require "redi_search/schema"
 require "redi_search/search"
 require "redi_search/spellcheck"
+require "redi_search/alter"
 
 module RediSearch
   class Index
@@ -15,21 +18,19 @@ module RediSearch
     end
 
     def search(term = nil, **term_options)
-      Search.new(self, term, model, **term_options)
+      Search.new(self, term, **term_options)
     end
 
     def spellcheck(query, distance: 1)
       Spellcheck.new(self, query, distance: distance)
     end
 
-    def create
-      create!
-    rescue Redis::CommandError
-      false
+    def create(**options)
+      Create.new(self, schema, options).call
     end
 
-    def create!
-      client.call!("CREATE", name, "SCHEMA", schema.to_a).ok?
+    def create!(**options)
+      Create.new(self, schema, options).call!
     end
 
     def drop
@@ -42,29 +43,24 @@ module RediSearch
       client.call!("DROP", name).ok?
     end
 
-    def add(record, score = 1.0)
-      add!(record, score)
-    rescue Redis::CommandError
-      false
+    def add(document, **options)
+      Add.new(self, document, **options).call
     end
 
-    def add!(record, score = 1.0)
-      client.call!(
-        "ADD", name, record.id, score, "REPLACE", "FIELDS",
-        Document::Converter.new(self, record).document.to_a
-      )
+    def add!(document, **options)
+      Add.new(self, document, **options).call!
     end
 
-    def add_multiple!(records)
+    def add_multiple!(documents, **options)
       client.pipelined do
-        records.each do |record|
-          add!(record)
+        documents.each do |document|
+          add!(document, **options)
         end
       end.ok?
     end
 
-    def del(record, delete_document: false)
-      client.call!("DEL", name, record.id, ("DD" if delete_document))
+    def del(document, delete_document: false)
+      document.del(delete_document: delete_document)
     end
 
     def exist?
@@ -82,13 +78,22 @@ module RediSearch
     end
 
     def fields
-      @fields ||= schema.fields.map(&:to_s)
+      schema.fields.map(&:to_s)
+    end
+
+    def reindex(documents, recreate: false, **options)
+      drop if recreate
+      create unless exist?
+
+      add_multiple! documents, **options
+    end
+
+    def document_count
+      info["num_docs"].to_i
     end
 
-    def reindex(docs)
-      drop if exist?
-      create
-      add_multiple! docs
+    def alter(field_name, schema)
+      Alter.new(self, field_name, schema).call!
     end
 
     private

data/lib/redi_search/lazily_load.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RediSearch
+  module LazilyLoad
+    extend ActiveSupport::Concern
+
+    include Enumerable
+
+    included do
+      delegate :size, :each, to: :to_a
+    end
+
+    def loaded?
+      @loaded = false unless defined? @loaded
+
+      @loaded
+    end
+
+    def to_a
+      execute unless loaded?
+
+      @documents
+    end
+
+    alias load to_a
+
+    #:nocov:
+    def inspect
+      execute unless loaded?
+
+      to_a
+    end
+
+    def pretty_print(printer)
+      execute unless loaded?
+
+      printer.pp(documents)
+    rescue Redis::CommandError => e
+      printer.pp(e.message)
+    end
+    #:nocov:
+
+    def count
+      to_a.size
+    end
+
+    private
+
+    def command
+      raise NotImplementedError, "included class did not define #{__method__}"
+    end
+
+    def execute
+      @loaded = true
+
+      RediSearch.client.call!(*command).yield_self do |response|
+        parse_response(response)
+      end
+    end
+
+    def parse_response(_response)
+      raise NotImplementedError, "included class did not define #{__method__}"
+    end
+  end
+end