algolia 2.3.3 → 3.0.0.alpha.2

data/lib/algolia/search_index.rb

@@ -1,1059 +0,0 @@
-module Algolia
-  module Search
-    # Class Index
-    class Index
-      include CallType
-      include Helpers
-
-      attr_reader :name, :transporter, :config, :logger
-
-      # Initialize an index
-      #
-      # @param name [String] name of the index
-      # @param transporter [Object] transport object used for the connection
-      # @param config [Config] a Config object which contains your APP_ID and API_KEY
-      # @param logger [LoggerHelper] an optional LoggerHelper object to use
-      #
-      def initialize(name, transporter, config, logger = nil)
-        @name        = name
-        @transporter = transporter
-        @config      = config
-        @logger      = logger || LoggerHelper.create
-      end
-
-      # # # # # # # # # # # # # # # # # # # # #
-      # MISC
-      # # # # # # # # # # # # # # # # # # # # #
-
-      # Wait the publication of a task on the server.
-      # All server task are asynchronous and you can check with this method that the task is published.
-      #
-      # @param task_id the id of the task returned by server
-      # @param time_before_retry the time in milliseconds before retry (default = 100ms)
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      def wait_task(task_id, time_before_retry = Defaults::WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY, opts = {})
-        loop do
-          status = get_task_status(task_id, opts)
-          if status == 'published'
-            return
-          end
-          sleep(time_before_retry.to_f / 1000)
-        end
-      end
-
-      # Check the status of a task on the server.
-      # All server task are asynchronous and you can check the status of a task with this method.
-      #
-      # @param task_id [Integer] the id of the task returned by server
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      def get_task_status(task_id, opts = {})
-        res    = @transporter.read(:GET, path_encode('/1/indexes/%s/task/%s', @name, task_id), {}, opts)
-        get_option(res, 'status')
-      end
-
-      # Delete the index content
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      def clear_objects(opts = {})
-        response = @transporter.write(:POST, path_encode('/1/indexes/%s/clear', @name), {}, opts)
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Delete the index content and wait for operation to complete
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      def clear_objects!(opts = {})
-        response = clear_objects(opts)
-        response.wait(opts)
-      end
-
-      # Delete an existing index
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      def delete(opts = {})
-        response = @transporter.write(:DELETE, path_encode('/1/indexes/%s', @name), opts)
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Delete an existing index and wait for operation to complete
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      def delete!(opts = {})
-        response = delete(opts)
-        response.wait(opts)
-      end
-
-      # Find object by the given condition.
-      #
-      # Options can be passed in request_options body:
-      #  - query (string): pass a query
-      #  - paginate (bool): choose if you want to iterate through all the
-      # documents (true) or only the first page (false). Default is true.
-      # The function takes a block to filter the results from search query
-      # Usage example:
-      #  index.find_object({'query' => '', 'paginate' => true}) {|obj| obj.key?('company') and obj['company'] == 'Apple'}
-      #
-      # @param callback [Lambda] contains extra parameters to send with your query
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Hash|AlgoliaHttpError] the matching object and its position in the result set
-      #
-      def find_object(callback, opts = {})
-        request_options = symbolize_hash(opts)
-        paginate        = true
-        page            = 0
-
-        query    = request_options.delete(:query) || ''
-        paginate = request_options.delete(:paginate) if request_options.has_key?(:paginate)
-
-        has_next_page = true
-        while has_next_page
-          request_options[:page] = page
-          res                    = symbolize_hash(search(query, request_options))
-
-          res[:hits].each_with_index do |hit, i|
-            if callback.call(hit)
-              return {
-                object: hit,
-                position: i,
-                page: page
-              }
-            end
-          end
-
-          has_next_page = page + 1 < res[:nbPages]
-          raise AlgoliaHttpError.new(404, 'Object not found') unless paginate && has_next_page
-
-          page += 1
-        end
-      end
-
-      # Retrieve the given object position in a set of results.
-      #
-      # @param [Array] objects the result set to browse
-      # @param [String] object_id the object to look for
-      #
-      # @return [Integer] position of the object, or -1 if it's not in the array
-      #
-      def self.get_object_position(objects, object_id)
-        hits = get_option(objects, 'hits')
-        hits.find_index { |hit| get_option(hit, 'objectID') == object_id } || -1
-      end
-
-      # Copy the current index to the given destination name
-      #
-      # @param name [String] destination index name
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def copy_to(name, opts = {})
-        response = @transporter.write(:POST, path_encode('/1/indexes/%s/operation', @name), { operation: 'copy', destination: name }, opts)
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Move the current index to the given destination name
-      #
-      # @param name [String] destination index name
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def move_to(name, opts = {})
-        response = @transporter.write(:POST, path_encode('/1/indexes/%s/operation', @name), { operation: 'move', destination: name }, opts)
-
-        IndexingResponse.new(self, response)
-      end
-
-      # # # # # # # # # # # # # # # # # # # # #
-      # INDEXING
-      # # # # # # # # # # # # # # # # # # # # #
-
-      # Retrieve one object from the index
-      #
-      # @param object_id [String]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Hash]
-      #
-      def get_object(object_id, opts = {})
-        @transporter.read(:GET, path_encode('/1/indexes/%s/%s', @name, object_id), {}, opts)
-      end
-
-      # Retrieve one or more objects in a single API call
-      #
-      # @param object_ids [Array]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Hash]
-      #
-      def get_objects(object_ids, opts = {})
-        request_options        = symbolize_hash(opts)
-        attributes_to_retrieve = get_option(request_options, 'attributesToRetrieve')
-        request_options.delete(:attributesToRetrieve)
-
-        requests = []
-        object_ids.each do |object_id|
-          request = { indexName: @name, objectID: object_id.to_s }
-
-          if attributes_to_retrieve
-            request[:attributesToRetrieve] = attributes_to_retrieve
-          end
-
-          requests.push(request)
-        end
-
-        @transporter.read(:POST, '/1/indexes/*/objects', { 'requests': requests }, opts)
-      end
-
-      # Add an object to the index
-      #
-      # @param object [Hash] the object to save
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def save_object(object, opts = {})
-        save_objects([object], opts)
-      end
-
-      # Add an object to the index and wait for operation to complete
-      #
-      # @param object [Hash] the object to save
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def save_object!(object, opts = {})
-        response = save_objects([object], opts)
-        response.wait(opts)
-      end
-
-      # Add several objects to the index
-      #
-      # @param objects [Array] the objects to save
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def save_objects(objects, opts = {})
-        request_options    = symbolize_hash(opts)
-        generate_object_id = request_options[:auto_generate_object_id_if_not_exist] || false
-        request_options.delete(:auto_generate_object_id_if_not_exist)
-        if generate_object_id
-          IndexingResponse.new(self, raw_batch(chunk('addObject', objects), request_options))
-        else
-          IndexingResponse.new(self, raw_batch(chunk('updateObject', objects, true), request_options))
-        end
-      end
-
-      # Add several objects to the index and wait for operation to complete
-      #
-      # @param objects [Array] the objects to save
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def save_objects!(objects, opts = {})
-        response = save_objects(objects, opts)
-        response.wait(opts)
-      end
-
-      # Partially update an object
-      #
-      # @param object [String] object ID to partially update
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def partial_update_object(object, opts = {})
-        partial_update_objects([object], opts)
-      end
-
-      # Partially update an object and wait for operation to complete
-      #
-      # @param object [String] object ID to partially update
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def partial_update_object!(object, opts = {})
-        response     = partial_update_objects([object], opts)
-        response.wait(opts)
-      end
-
-      # Partially update several objects
-      #
-      # @param objects [Array] array of objectIDs to partially update
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def partial_update_objects(objects, opts = {})
-        generate_object_id = false
-        request_options    = symbolize_hash(opts)
-        if get_option(request_options, 'createIfNotExists')
-          generate_object_id = true
-        end
-        request_options.delete(:createIfNotExists)
-
-        if generate_object_id
-          IndexingResponse.new(self, raw_batch(chunk('partialUpdateObject', objects), request_options))
-        else
-          IndexingResponse.new(self, raw_batch(chunk('partialUpdateObjectNoCreate', objects), request_options))
-        end
-      end
-
-      # Partially update several objects and wait for operation to complete
-      #
-      # @param objects [Array] array of objectIDs to partially update
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def partial_update_objects!(objects, opts = {})
-        response = partial_update_objects(objects, opts)
-        response.wait(opts)
-      end
-
-      # Delete an existing object from an index
-      #
-      # @param object_id [String]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def delete_object(object_id, opts = {})
-        delete_objects([object_id], opts)
-      end
-
-      # Delete an existing object from an index and wait for operation to complete
-      #
-      # @param object_id [String]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def delete_object!(object_id, opts = {})
-        response = delete_objects([object_id], opts)
-        response.wait(opts)
-      end
-
-      # Delete several existing objects from an index
-      #
-      # @param object_ids [Array]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def delete_objects(object_ids, opts = {})
-        objects = object_ids.map do |object_id|
-          { objectID: object_id }
-        end
-
-        IndexingResponse.new(self, raw_batch(chunk('deleteObject', objects), opts))
-      end
-
-      # Delete several existing objects from an index and wait for operation to complete
-      #
-      # @param object_ids [Array]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def delete_objects!(object_ids, opts = {})
-        response     = delete_objects(object_ids, opts)
-        response.wait(opts)
-      end
-
-      # Delete all records matching the query
-      #
-      # @param filters [Hash]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def delete_by(filters, opts = {})
-        response = @transporter.write(:POST, path_encode('/1/indexes/%s/deleteByQuery', @name), filters, opts)
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Delete all records matching the query and wait for operation to complete
-      #
-      # @param filters [Hash]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def delete_by!(filters, opts = {})
-        response = delete_by(filters, opts)
-
-        response.wait(opts)
-      end
-
-      # Send a batch request
-      #
-      # @param requests [Hash] hash containing the requests to batch
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def batch(requests, opts = {})
-        response = raw_batch(requests, opts)
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Send a batch request and wait for operation to complete
-      #
-      # @param requests [Hash] hash containing the requests to batch
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def batch!(requests, opts = {})
-        response     = batch(requests, opts)
-        response.wait(opts)
-      end
-
-      # # # # # # # # # # # # # # # # # # # # #
-      # QUERY RULES
-      # # # # # # # # # # # # # # # # # # # # #
-
-      # Retrieve the Rule with the specified objectID
-      #
-      # @param object_id [String]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Hash]
-      #
-      def get_rule(object_id, opts = {})
-        @transporter.read(:GET, path_encode('/1/indexes/%s/rules/%s', @name, object_id), {}, opts)
-      end
-
-      # Create or update a rule
-      #
-      # @param rule [Hash] a hash containing a rule objectID and different conditions/consequences
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def save_rule(rule, opts = {})
-        save_rules([rule], opts)
-      end
-
-      # Create or update a rule and wait for operation to complete
-      #
-      # @param rule [Hash] a hash containing a rule objectID and different conditions/consequences
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def save_rule!(rule, opts = {})
-        response = save_rules([rule], opts)
-        response.wait(opts)
-      end
-
-      # Create or update rules
-      #
-      # @param rules [Array] an array of hashes containing a rule objectID and different conditions/consequences
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def save_rules(rules, opts = {})
-        if rules.is_a?(RuleIterator)
-          iterated = []
-          rules.each do |rule|
-            iterated.push(rule)
-          end
-          rules    = iterated
-        end
-
-        if rules.empty?
-          return []
-        end
-
-        forward_to_replicas  = false
-        clear_existing_rules = false
-        request_options      = symbolize_hash(opts)
-
-        if request_options[:forwardToReplicas]
-          forward_to_replicas = true
-          request_options.delete(:forwardToReplicas)
-        end
-
-        if request_options[:clearExistingRules]
-          clear_existing_rules = true
-          request_options.delete(:clearExistingRules)
-        end
-
-        rules.each do |rule|
-          get_object_id(rule)
-        end
-
-        response = @transporter.write(:POST, path_encode('/1/indexes/%s/rules/batch', @name) + handle_params({ forwardToReplicas: forward_to_replicas, clearExistingRules: clear_existing_rules }), rules, request_options)
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Create or update rules and wait for operation to complete
-      #
-      # @param rules [Array] an array of hashes containing a rule objectID and different conditions/consequences
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def save_rules!(rules, opts = {})
-        response = save_rules(rules, opts)
-        response.wait(opts)
-      end
-
-      # Delete all Rules in the index
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def clear_rules(opts = {})
-        forward_to_replicas = false
-        request_options     = symbolize_hash(opts)
-
-        if request_options[:forwardToReplicas]
-          forward_to_replicas = true
-          request_options.delete(:forwardToReplicas)
-        end
-
-        response = @transporter.write(:POST, path_encode('1/indexes/%s/rules/clear', @name) + handle_params({ forwardToReplicas: forward_to_replicas }), '', request_options)
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Delete all Rules in the index and wait for operation to complete
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def clear_rules!(opts = {})
-        response     = clear_rules(opts)
-        response.wait(opts)
-      end
-
-      # Delete the Rule with the specified objectID
-      #
-      # @param object_id [String]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def delete_rule(object_id, opts = {})
-        forward_to_replicas = false
-        request_options     = symbolize_hash(opts)
-
-        if request_options[:forwardToReplicas]
-          forward_to_replicas = true
-          request_options.delete(:forwardToReplicas)
-        end
-
-        response = @transporter.write(
-          :DELETE,
-          path_encode('1/indexes/%s/rules/%s', @name, object_id) + handle_params({ forwardToReplicas: forward_to_replicas }),
-          '',
-          request_options
-        )
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Delete the Rule with the specified objectID and wait for operation to complete
-      #
-      # @param object_id [String]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def delete_rule!(object_id, opts = {})
-        response = delete_rule(object_id, opts)
-        response.wait(opts)
-      end
-
-      # # # # # # # # # # # # # # # # # # # # #
-      # SYNONYMS
-      # # # # # # # # # # # # # # # # # # # # #
-
-      # Fetch a synonym object identified by its objectID
-      #
-      # @param object_id [String]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Hash]
-      #
-      def get_synonym(object_id, opts = {})
-        @transporter.read(:GET, path_encode('/1/indexes/%s/synonyms/%s', @name, object_id), {}, opts)
-      end
-
-      # Create a new synonym object or update the existing synonym object with the given object ID
-      #
-      # @param synonym [Hash] Synonym object
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def save_synonym(synonym, opts = {})
-        save_synonyms([synonym], opts)
-      end
-
-      # Create a new synonym object or update the existing synonym object with the given object ID
-      # and wait for operation to finish
-      #
-      # @param synonym [Hash] Synonym object
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def save_synonym!(synonym, opts = {})
-        response     = save_synonyms([synonym], opts)
-        response.wait(opts)
-      end
-
-      # Create/update multiple synonym objects at once, potentially replacing the entire list of synonyms if
-      # replaceExistingSynonyms is true
-      #
-      # @param synonyms [Array] Array of Synonym objects
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def save_synonyms(synonyms, opts = {})
-        if synonyms.is_a?(SynonymIterator)
-          iterated = []
-          synonyms.each do |synonym|
-            iterated.push(synonym)
-          end
-          synonyms = iterated
-        end
-
-        if synonyms.empty?
-          return []
-        end
-
-        synonyms.each do |synonym|
-          get_object_id(synonym)
-        end
-
-        forward_to_replicas       = false
-        replace_existing_synonyms = false
-
-        request_options = symbolize_hash(opts)
-
-        if request_options[:forwardToReplicas]
-          forward_to_replicas = true
-          request_options.delete(:forwardToReplicas)
-        end
-
-        if request_options[:replaceExistingSynonyms]
-          replace_existing_synonyms = true
-          request_options.delete(:replaceExistingSynonyms)
-        end
-        response = @transporter.write(
-          :POST,
-          path_encode('/1/indexes/%s/synonyms/batch', @name) + handle_params({ forwardToReplicas: forward_to_replicas, replaceExistingSynonyms: replace_existing_synonyms }),
-          synonyms,
-          request_options
-        )
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Create/update multiple synonym objects at once, potentially replacing the entire list of synonyms if
-      # replaceExistingSynonyms is true and wait for operation to complete
-      #
-      # @param synonyms [Array] Array of Synonym objects
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def save_synonyms!(synonyms, opts = {})
-        response = save_synonyms(synonyms, opts)
-        response.wait(opts)
-      end
-
-      # Delete all synonyms from the index
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def clear_synonyms(opts = {})
-        forward_to_replicas = false
-        request_options     = symbolize_hash(opts)
-
-        if request_options[:forwardToReplicas]
-          forward_to_replicas = true
-          request_options.delete(:forwardToReplicas)
-        end
-        response = @transporter.write(
-          :POST,
-          path_encode('1/indexes/%s/synonyms/clear', @name) + handle_params({ forwardToReplicas: forward_to_replicas }),
-          '',
-          request_options
-        )
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Delete all synonyms from the index and wait for operation to complete
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def clear_synonyms!(opts = {})
-        response     = clear_synonyms(opts)
-        response.wait(opts)
-      end
-
-      # Delete a single synonyms set, identified by the given objectID
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def delete_synonym(object_id, opts = {})
-        forward_to_replicas = false
-        request_options     = symbolize_hash(opts)
-
-        if request_options[:forwardToReplicas]
-          forward_to_replicas = true
-          request_options.delete(:forwardToReplicas)
-        end
-        response = @transporter.write(
-          :DELETE,
-          path_encode('1/indexes/%s/synonyms/%s', @name, object_id) + handle_params({ forwardToReplicas: forward_to_replicas }),
-          '',
-          request_options
-        )
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Delete a single synonyms set, identified by the given objectID and wait for operation to complete
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def delete_synonym!(object_id, opts = {})
-        response     = delete_synonym(object_id, opts)
-        response.wait(opts)
-      end
-
-      # # # # # # # # # # # # # # # # # # # # #
-      # BROWSING
-      # # # # # # # # # # # # # # # # # # # # #
-
-      # Browse all index content
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Enumerator, ObjectIterator]
-      #
-      def browse_objects(opts = {}, &block)
-        if block_given?
-          ObjectIterator.new(@transporter, @name, opts).each(&block)
-        else
-          ObjectIterator.new(@transporter, @name, opts)
-        end
-      end
-
-      # Browse all rules
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Enumerator, RuleIterator]
-      #
-      def browse_rules(opts = {}, &block)
-        if block_given?
-          RuleIterator.new(@transporter, @name, opts).each(&block)
-        else
-          RuleIterator.new(@transporter, @name, opts)
-        end
-      end
-
-      # Browse all synonyms
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Enumerator, SynonymIterator]
-      #
-      def browse_synonyms(opts = {}, &block)
-        if block_given?
-          SynonymIterator.new(@transporter, @name, opts).each(&block)
-        else
-          SynonymIterator.new(@transporter, @name, opts)
-        end
-      end
-
-      # # # # # # # # # # # # # # # # # # # # #
-      # REPLACING
-      # # # # # # # # # # # # # # # # # # # # #
-
-      # Replace all objects in the index
-      #
-      # @param objects [Array] Array of objects
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Enumerator, SynonymIterator]
-      #
-      def replace_all_objects(objects, opts = {})
-        safe            = false
-        request_options = symbolize_hash(opts)
-        if request_options[:safe]
-          safe = true
-          request_options.delete(:safe)
-        end
-
-        tmp_index_name   = @name + '_tmp_' + rand(10000000).to_s
-        copy_to_response = copy_to(tmp_index_name, request_options.merge({ scope: %w(settings synonyms rules) }))
-
-        if safe
-          copy_to_response.wait
-        end
-
-        # TODO: consider create a new client with state of retry is shared
-        tmp_client = Algolia::Search::Client.new(@config, { logger: logger })
-        tmp_index  = tmp_client.init_index(tmp_index_name)
-
-        save_objects_response = tmp_index.save_objects(objects, request_options)
-
-        if safe
-          save_objects_response.wait
-        end
-
-        move_to_response = tmp_index.move_to(@name)
-        if safe
-          move_to_response.wait
-        end
-      end
-
-      # Replace all objects in the index and wait for the operation to complete
-      #
-      # @param objects [Array] Array of objects
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Enumerator, SynonymIterator]
-      #
-      def replace_all_objects!(objects, opts = {})
-        replace_all_objects(objects, opts.merge(safe: true))
-      end
-
-      # Replace all rules in the index
-      #
-      # @param rules [Array] Array of rules
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def replace_all_rules(rules, opts = {})
-        request_options                      = symbolize_hash(opts)
-        request_options[:clearExistingRules] = true
-
-        save_rules(rules, request_options)
-      end
-
-      # Replace all rules in the index and wait for the operation to complete
-      #
-      # @param rules [Array] Array of rules
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def replace_all_rules!(rules, opts = {})
-        request_options                      = symbolize_hash(opts)
-        request_options[:clearExistingRules] = true
-
-        save_rules!(rules, request_options)
-      end
-
-      # Replace all synonyms in the index
-      #
-      # @param synonyms [Array] Array of synonyms
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def replace_all_synonyms(synonyms, opts = {})
-        request_options                           = symbolize_hash(opts)
-        request_options[:replaceExistingSynonyms] = true
-
-        save_synonyms(synonyms, request_options)
-      end
-
-      # Replace all synonyms in the index and wait for the operation to complete
-      #
-      # @param synonyms [Array] Array of synonyms
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Array, IndexingResponse]
-      #
-      def replace_all_synonyms!(synonyms, opts = {})
-        request_options                           = symbolize_hash(opts)
-        request_options[:replaceExistingSynonyms] = true
-
-        save_synonyms!(synonyms, request_options)
-      end
-
-      # # # # # # # # # # # # # # # # # # # # #
-      # SEARCHING
-      # # # # # # # # # # # # # # # # # # # # #
-
-      # Perform a search on the index
-      #
-      # @param query the full text query
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Hash]
-      #
-      def search(query, opts = {})
-        @transporter.read(:POST, path_encode('/1/indexes/%s/query', @name), { 'query': query.to_s }, opts)
-      end
-
-      # Search for values of a given facet, optionally restricting the returned values to those contained
-      # in objects matching other search criteria
-      #
-      # @param facet_name [String]
-      # @param facet_query [String]
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Hash]
-      #
-      def search_for_facet_values(facet_name, facet_query, opts = {})
-        @transporter.read(:POST, path_encode('/1/indexes/%s/facets/%s/query', @name, facet_name),
-                          { 'facetQuery': facet_query }, opts)
-      end
-
-      # Search or browse all synonyms, optionally filtering them by type
-      #
-      # @param query [String] Search for specific synonyms matching this string
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Hash]
-      #
-      def search_synonyms(query, opts = {})
-        @transporter.read(:POST, path_encode('/1/indexes/%s/synonyms/search', @name), { query: query.to_s }, opts)
-      end
-
-      # Search or browse all rules, optionally filtering them by type
-      #
-      # @param query [String] Search for specific rules matching this string
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Hash]
-      #
-      def search_rules(query, opts = {})
-        @transporter.read(:POST, path_encode('/1/indexes/%s/rules/search', @name), { query: query.to_s }, opts)
-      end
-
-      # # # # # # # # # # # # # # # # # # # # #
-      # SETTINGS
-      # # # # # # # # # # # # # # # # # # # # #
-
-      # Retrieve index settings
-      #
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [Hash]
-      #
-      def get_settings(opts = {})
-        opts_default = {
-          getVersion: 2
-        }
-        opts         = opts_default.merge(opts)
-        response     = @transporter.read(:GET, path_encode('/1/indexes/%s/settings', @name), {}, opts)
-
-        deserialize_settings(response, @config.symbolize_keys)
-      end
-
-      # Update some index settings. Only specified settings are overridden
-      #
-      # @param settings [Hash] the settings to update
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def set_settings(settings, opts = {})
-        request_options      = symbolize_hash(opts)
-        forward_to_replicas  = request_options.delete(:forwardToReplicas) || false
-
-        response = @transporter.write(
-          :PUT,
-          path_encode('/1/indexes/%s/settings', @name) + handle_params({ forwardToReplicas: forward_to_replicas }),
-          settings,
-          request_options
-        )
-
-        IndexingResponse.new(self, response)
-      end
-
-      # Update some index settings and wait for operation to complete.
-      # Only specified settings are overridden
-      #
-      # @param settings [Hash] the settings to update
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      # @return [IndexingResponse]
-      #
-      def set_settings!(settings, opts = {})
-        response = set_settings(settings, opts)
-        response.wait(opts)
-      end
-
-      # # # # # # # # # # # # # # # # # # # # #
-      # EXISTS
-      # # # # # # # # # # # # # # # # # # # # #
-
-      # Checks if the current index exists
-      #
-      # @return [Boolean]
-      #
-      def exists
-        begin
-          get_settings
-        rescue AlgoliaHttpError => e
-          if e.code == 404
-            return false
-          end
-
-          raise e
-        end
-        true
-      end
-
-      #
-      # Aliases the exists method
-      #
-      alias_method :exists?, :exists
-
-      # # # # # # # # # # # # # # # # # # # # #
-      # PRIVATE
-      # # # # # # # # # # # # # # # # # # # # #
-
-      private
-
-      def raw_batch(requests, opts)
-        @transporter.write(:POST, path_encode('/1/indexes/%s/batch', @name), { requests: requests }, opts)
-      end
-    end
-  end
-end