redi_search 1.0.4 → 3.0.0

data/gemfiles/{rails_6.gemfile → activerecord_61.gemfile}

@@ -2,16 +2,15 @@
 
 source "https://rubygems.org"
 
+gem "appraisal", "~> 2.2"
 gem "faker"
-gem "minitest", "~> 5.0"
 gem "mocha"
 gem "pry"
-gem "pry-rails"
 gem "rubocop"
+gem "rubocop-minitest"
 gem "rubocop-performance"
-gem "rubocop-rails"
 gem "simplecov"
 gem "sqlite3"
-gem "rails", "6.0.0.rc1"
+gem "activerecord", "6.1.0.rc1"
 
 gemspec path: "../"

data/lib/redi_search.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
+require "delegate"
+require "forwardable"
 require "redis"
-require "active_support"
-require "active_model"
-require "active_support/core_ext/object/blank"
+require "active_support/lazy_load_hooks"
 
 require "redi_search/configuration"
+require "redi_search/client"
 
 require "redi_search/model"
 require "redi_search/index"
@@ -14,8 +15,6 @@ require "redi_search/document"
 
 module RediSearch
   class << self
-    extend Forwardable
-
     attr_writer :configuration
 
     def configuration
@@ -30,10 +29,12 @@ module RediSearch
       yield(configuration)
     end
 
-    def_delegator :configuration, :client
+    def client
+      @client ||= Client.new(Redis.new(configuration.redis_config.to_h))
+    end
 
     def env
-      @env ||= ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+      ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
     end
   end
 end

data/lib/redi_search/{alter.rb → add_field.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RediSearch
-  class Alter
+  class AddField
     def initialize(index, field_name, schema)
       @index = index
       @field_name = field_name
@@ -9,17 +9,25 @@ module RediSearch
     end
 
     def call!
-      index.schema.alter(field_name, raw_schema)
+      index.schema.add_field(field_name, raw_schema)
 
-      RediSearch.client.call!(
-        "ALTER", index.name, "SCHEMA", "ADD", *field_schema
-      ).ok?
+      RediSearch.client.call!(*command).ok?
+    end
+
+    def call
+      call!
+    rescue Redis::CommandError
+      false
     end
 
     private
 
     attr_reader :index, :field_name, :raw_schema
 
+    def command
+      ["ALTER", index.name, "SCHEMA", "ADD", *field_schema]
+    end
+
     def field_schema
       @field_schema ||= Schema.make_field(field_name, raw_schema)
     end

data/lib/redi_search/client.rb

@@ -1,41 +1,53 @@
 # frozen_string_literal: true
 
 require "redis"
+require "active_support/notifications"
+
 require "redi_search/client/response"
 
 module RediSearch
   class Client
-    def initialize(redis_config)
-      @redis = Redis.new(redis_config)
+    def initialize(redis = Redis.new)
+      @redis = redis
+      @pipeline = false
     end
 
-    def call!(command, *params)
+    def call!(command, *params, skip_ft: false)
       instrument(command.downcase, query: [command, params]) do
+        command = "FT.#{command}" unless skip_ft
         send_command(command, *params)
       end
     end
 
-    def pipelined
-      Response.new(redis.pipelined do
+    def multi
+      Response.new(redis.multi do
         instrument("pipeline", query: ["begin pipeline"])
-        yield
+        capture_pipeline { yield }
         instrument("pipeline", query: ["finish pipeline"])
       end)
     end
 
     private
 
-    attr_reader :redis
+    attr_reader   :redis
+    attr_accessor :pipeline
+
+    def capture_pipeline
+      self.pipeline = true
+      yield
+      self.pipeline = false
+    end
 
     def send_command(command, *params)
-      Response.new(redis.call("FT.#{command}", *params))
+      Response.new(redis.call(command, *params))
     end
 
     def instrument(action, payload, &block)
       ActiveSupport::Notifications.instrument(
-        "#{action}.redi_search",
-        { name: "RediSearch" }.merge(payload),
-        &Proc.new(&(block || proc {}))
+        "action.redi_search",
+        { name: "RediSearch", action: action, inside_pipeline: pipeline }.
+          merge(payload),
+        &Proc.new(&(block || proc {})) # rubocop:disable Lint/EmptyBlock
       )
     end
   end

data/lib/redi_search/client/response.rb

@@ -6,12 +6,16 @@ module RediSearch
       def ok?
         case response
         when String then response == "OK"
-        when Integer then response == 1
+        when Integer then response >= 1
         when Array then array_ok?
         else response
         end
       end
 
+      def nil?
+        response.nil?
+      end
+
       private
 
       def array_ok?

data/lib/redi_search/configuration.rb

@@ -1,17 +1,7 @@
 # frozen_string_literal: true
 
-require "redi_search/client"
-
 module RediSearch
   class Configuration
-    attr_writer :redis_config
-
-    def client
-      @client ||= Client.new(redis_config)
-    end
-
-    def redis_config
-      @redis_config ||= { host: "127.0.0.1", port: "6379" }
-    end
+    attr_accessor :redis_config
   end
 end

data/lib/redi_search/create.rb

@@ -17,9 +17,7 @@ module RediSearch
     end
 
     def call!
-      RediSearch.client.call!(
-        "CREATE", index.name, *extract_options.compact, "SCHEMA", schema.to_a
-      ).ok?
+      RediSearch.client.call!(*command).ok?
     end
 
     def call
@@ -32,12 +30,17 @@ module RediSearch
 
     attr_reader :index, :schema, :options
 
+    def command
+      ["CREATE", index.name, "ON", "HASH", "PREFIX", 1, index.name,
+       *extract_options.compact, "SCHEMA", schema.to_a]
+    end
+
     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 + temporary_option
     end
 
     def temporary_option

data/lib/redi_search/document.rb

@@ -12,7 +12,7 @@ module RediSearch
         object_to_serialize = serializer&.new(record) || record
 
         field_values = index.schema.fields.map do |field|
-          next if only.present? && !only.include?(field.to_sym)
+          next unless only.empty? || only.include?(field.to_sym)
 
           [field.to_s, object_to_serialize.public_send(field)]
         end.compact.to_h
@@ -23,10 +23,6 @@ module RediSearch
       def get(index, document_id)
         Finder.new(index, document_id).find
       end
-
-      def mget(index, *document_ids)
-        Finder.new(index, *document_ids).find
-      end
     end
 
     attr_reader :attributes, :score
@@ -40,8 +36,8 @@ module RediSearch
       load_attributes
     end
 
-    def del(delete_document: false)
-      call!("DEL", index.name, document_id, ("DD" if delete_document)).ok?
+    def del
+      RediSearch.client.call!("DEL", document_id, skip_ft: true).ok?
     end
 
     def schema_fields
@@ -61,7 +57,7 @@ module RediSearch
     end
 
     def document_id_without_index
-      if @document_id.to_s.starts_with? index.name
+      if @document_id.to_s.start_with? index.name
         @document_id.gsub(index.name, "")
       else
         @document_id
@@ -72,13 +68,9 @@ module RediSearch
 
     attr_reader :index
 
-    def call!(*command)
-      RediSearch.client.call!(*command)
-    end
-
     def load_attributes
       attributes.each do |field, value|
-        next unless schema_fields.include? field
+        next unless schema_fields.include? field.to_s
 
         instance_variable_set(:"@#{field}", value)
         define_singleton_method(field) { value }

data/lib/redi_search/document/display.rb

@@ -3,7 +3,6 @@
 module RediSearch
   class Document
     module Display
-      #:nocov:
       def inspect
         inspection = pretty_print_attributes.map do |field_name|
           "#{field_name}: #{public_send(field_name)}"
@@ -12,6 +11,15 @@ module RediSearch
         "#<#{self.class} #{inspection}>"
       end
 
+      def pretty_print_attributes
+        pp_attrs = attributes.keys.dup
+        pp_attrs.push("document_id")
+        pp_attrs.push("score") if score
+
+        pp_attrs.compact
+      end
+
+      #:nocov:
       def pretty_print(printer) # rubocop:disable Metrics/MethodLength
         printer.object_address_group(self) do
           printer.seplist(
@@ -27,14 +35,6 @@ 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:
     end
   end

data/lib/redi_search/document/finder.rb

@@ -3,67 +3,37 @@
 module RediSearch
   class Document
     class Finder
-      def initialize(index, *document_ids)
+      def initialize(index, document_id)
         @index = index
-        @document_ids = Array.wrap(document_ids)
+        @document_id = document_id
       end
 
       def find
-        if multi?
-          parse_multi_documents
-        else
-          parse_document(document_ids.first, response)
-        end
+        Document.new(index, document_id, Hash[*response]) if response?
       end
 
       private
 
-      attr_reader :index, :document_ids
+      attr_reader :index, :document_id
 
       def response
-        @response ||= call!(get_command, index.name, *prepended_document_ids)
+        @response ||= call!("HGETALL", prepended_document_id)
       end
 
       def call!(*command)
-        RediSearch.client.call!(*command)
-      end
-
-      def get_command
-        if multi?
-          "MGET"
-        else
-          "GET"
-        end
-      end
-
-      def multi?
-        document_ids.size > 1
-      end
-
-      def prepended_document_ids
-        document_ids.map do |document_id|
-          prepend_document_id(document_id)
-        end
+        RediSearch.client.call!(*command, skip_ft: true)
       end
 
-      def prepend_document_id(id)
-        if id.to_s.start_with? index.name
-          id
+      def prepended_document_id
+        if document_id.to_s.start_with? index.name
+          document_id
         else
-          "#{index.name}#{id}"
+          "#{index.name}#{document_id}"
         end
       end
 
-      def parse_multi_documents
-        document_ids.map.with_index do |document_id, index|
-          parse_document(document_id, response[index])
-        end.compact
-      end
-
-      def parse_document(document_id, document_response)
-        return if document_response.blank?
-
-        Document.new(index, document_id, Hash[*document_response])
+      def response?
+        !response.to_a.empty?
       end
     end
   end

data/lib/redi_search/hset.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Hset
+    def initialize(index, document)
+      @index = index
+      @document = document
+    end
+
+    def call!
+      RediSearch.client.call!(*command, skip_ft: true)
+    end
+
+    def call
+      call!
+    rescue Redis::CommandError
+      false
+    end
+
+    private
+
+    attr_reader :index, :document
+
+    def command
+      ["HSET", document.document_id, document.redis_attributes].compact
+    end
+  end
+end

data/lib/redi_search/index.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require "redi_search/add"
+require "redi_search/hset"
 require "redi_search/create"
 require "redi_search/schema"
 require "redi_search/search"
 require "redi_search/spellcheck"
-require "redi_search/alter"
+require "redi_search/add_field"
 
 module RediSearch
   class Index
     attr_reader :name, :schema, :model
 
     def initialize(name, schema, model = nil)
-      @name = name
+      @name = name.to_s
       @schema = Schema.new(schema)
       @model = model
     end
@@ -33,34 +33,36 @@ module RediSearch
       Create.new(self, schema, options).call!
     end
 
-    def drop
-      drop!
+    def drop(keep_docs: false)
+      drop!(keep_docs: keep_docs)
     rescue Redis::CommandError
       false
     end
 
-    def drop!
-      client.call!("DROP", name).ok?
+    def drop!(keep_docs: false)
+      command = ["DROPINDEX", name]
+      command << "DD" unless keep_docs
+      client.call!(*command.compact).ok?
     end
 
-    def add(document, **options)
-      Add.new(self, document, **options).call
+    def add(document)
+      Hset.new(self, document).call
     end
 
-    def add!(document, **options)
-      Add.new(self, document, **options).call!
+    def add!(document)
+      Hset.new(self, document).call!
     end
 
-    def add_multiple!(documents, **options)
-      client.pipelined do
+    def add_multiple(documents)
+      client.multi do
         documents.each do |document|
-          add!(document, **options)
+          add(document)
         end
-      end.ok?
+      end.all? { |response| response >= 0 }
     end
 
-    def del(document, delete_document: false)
-      document.del(delete_document: delete_document)
+    def del(document)
+      document.del
     end
 
     def exist?
@@ -81,19 +83,19 @@ module RediSearch
       schema.fields.map(&:to_s)
     end
 
-    def reindex(documents, recreate: false, **options)
+    def reindex(documents, recreate: false)
       drop if recreate
       create unless exist?
 
-      add_multiple! documents, **options
+      add_multiple documents
     end
 
     def document_count
-      info["num_docs"].to_i
+      info.num_docs.to_i
     end
 
-    def alter(field_name, schema)
-      Alter.new(self, field_name, schema).call!
+    def add_field(field_name, schema)
+      AddField.new(self, field_name, schema).call!
     end
 
     private