algoliasearch-rails 1.25.0 → 3.0.1

data/lib/algoliasearch-rails.rb

@@ -1,4 +1,4 @@
-require 'algoliasearch'
+require 'algolia'
 
 require 'algoliasearch/version'
 require 'algoliasearch/utilities'
@@ -53,9 +53,8 @@ module AlgoliaSearch
     OPTIONS = [
       # Attributes
       :searchableAttributes, :attributesForFaceting, :unretrievableAttributes, :attributesToRetrieve,
-      :attributesToIndex, #Legacy name of searchableAttributes
       # Ranking
-      :ranking, :customRanking, # Replicas are handled via `add_replica`
+      :ranking, :customRanking, :relevancyStrictness, # Replicas are handled via `add_replica`
       # Faceting
       :maxValuesPerFacet, :sortFacetValuesBy,
       # Highlighting / Snippeting
@@ -76,7 +75,6 @@ module AlgoliaSearch
       :disablePrefixOnAttributes, :disableExactOnAttributes, :exactOnSingleWordQuery, :alternativesAsExact,
       # Performance
       :numericAttributesForFiltering, :allowCompressionOfIntegerArray,
-      :numericAttributesToIndex, # Legacy name of numericAttributesForFiltering
       # Advanced
       :attributeForDistinct, :distinct, :replaceSynonymsInHighlight, :minProximity, :responseFields,
       :maxFacetHits,
@@ -97,12 +95,11 @@ module AlgoliaSearch
 
     def use_serializer(serializer)
       @serializer = serializer
-      # instance_variable_set("@serializer", serializer)
     end
 
     def attribute(*names, &block)
       raise ArgumentError.new('Cannot pass multiple attribute names if block given') if block_given? and names.length > 1
-      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:slave] || @options[:replica]
+      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:replica]
       @attributes ||= {}
       names.flatten.each do |name|
         @attributes[name.to_s] = block_given? ? Proc.new { |o| o.instance_eval(&block) } : Proc.new { |o| o.send(name) }
@@ -112,7 +109,7 @@ module AlgoliaSearch
 
     def add_attribute(*names, &block)
       raise ArgumentError.new('Cannot pass multiple attribute names if block given') if block_given? and names.length > 1
-      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:slave] || @options[:replica]
+      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:replica]
       @additional_attributes ||= {}
       names.each do |name|
         @additional_attributes[name.to_s] = block_given? ? Proc.new { |o| o.instance_eval(&block) } : Proc.new { |o| o.send(name) }
@@ -125,7 +122,7 @@ module AlgoliaSearch
     end
 
     def is_sequel?(object)
-      defined?(::Sequel) && object.class < ::Sequel::Model
+      defined?(::Sequel) && defined?(::Sequel::Model) && object.class < ::Sequel::Model
     end
 
     def is_active_record?(object)
@@ -179,16 +176,7 @@ module AlgoliaSearch
       end
 
       attributes.merge!(attributes_to_hash(@additional_attributes, object)) if @additional_attributes
-
-      if @options[:sanitize]
-        sanitizer = begin
-          ::HTML::FullSanitizer.new
-        rescue NameError
-          # from rails 4.2
-          ::Rails::Html::FullSanitizer.new
-        end
-        attributes = sanitize_attributes(attributes, sanitizer)
-      end
+      attributes = sanitize_attributes(attributes, Rails::Html::FullSanitizer.new) if @options[:sanitize]
 
       if @options[:force_utf8_encoding] && Object.const_defined?(:RUBY_VERSION) && RUBY_VERSION.to_f > 1.8
         attributes = encode_attributes(attributes)
@@ -213,7 +201,7 @@ module AlgoliaSearch
     def encode_attributes(v)
       case v
       when String
-        v.force_encoding('utf-8')
+        v.dup.force_encoding('utf-8')
       when Hash
         v.each { |key, value| v[key] = encode_attributes(value) }
       when Array
@@ -224,14 +212,14 @@ module AlgoliaSearch
     end
 
     def geoloc(lat_attr = nil, lng_attr = nil, &block)
-      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:slave] || @options[:replica]
+      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:replica]
       add_attribute :_geoloc do |o|
         block_given? ? o.instance_eval(&block) : { :lat => o.send(lat_attr).to_f, :lng => o.send(lng_attr).to_f }
       end
     end
 
     def tags(*args, &block)
-      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:slave] || @options[:replica]
+      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:replica]
       add_attribute :_tags do |o|
         v = block_given? ? o.instance_eval(&block) : args
         v.is_a?(Array) ? v : [v]
@@ -243,50 +231,58 @@ module AlgoliaSearch
     end
 
     def to_settings
+      settings = to_hash
+
+      # Remove the synonyms setting since those need to be set separately
+      settings.delete(:synonyms)
+      settings.delete("synonyms")
+
+      Algolia::Search::IndexSettings.new(settings)
+    end
+
+    def to_hash
       settings = {}
       OPTIONS.each do |k|
         v = get_setting(k)
-        settings[k] = v if !v.nil?
+        settings[setting_name(k)] = v if !v.nil?
       end
-      if !@options[:slave] && !@options[:replica]
-        settings[:slaves] = additional_indexes.select { |opts, s| opts[:slave] }.map do |opts, s|
-          name = opts[:index_name]
-          name = "#{name}_#{Rails.env.to_s}" if opts[:per_environment]
-          name
-        end
-        settings.delete(:slaves) if settings[:slaves].empty?
+
+      if !@options[:replica]
         settings[:replicas] = additional_indexes.select { |opts, s| opts[:replica] }.map do |opts, s|
           name = opts[:index_name]
           name = "#{name}_#{Rails.env.to_s}" if opts[:per_environment]
+          name = "virtual(#{name})" if opts[:virtual]
           name
         end
         settings.delete(:replicas) if settings[:replicas].empty?
       end
+
       settings
     end
 
+    def setting_name(name)
+      name.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+    end
+
     def add_index(index_name, options = {}, &block)
-      raise ArgumentError.new('Cannot specify additional index on a replica index') if @options[:slave] || @options[:replica]
+      raise ArgumentError.new('Cannot specify additional index on a replica index') if @options[:replica]
       raise ArgumentError.new('No block given') if !block_given?
       raise ArgumentError.new('Options auto_index and auto_remove cannot be set on nested indexes') if options[:auto_index] || options[:auto_remove]
       @additional_indexes ||= {}
-      raise MixedSlavesAndReplicas.new('Cannot mix slaves and replicas in the same configuration (add_slave is deprecated)') if (options[:slave] && @additional_indexes.any? { |opts, _| opts[:replica] }) || (options[:replica] && @additional_indexes.any? { |opts, _| opts[:slave] })
       options[:index_name] = index_name
       @additional_indexes[options] = IndexSettings.new(options, &block)
     end
 
     def add_replica(index_name, options = {}, &block)
-      raise ArgumentError.new('Cannot specify additional replicas on a replica index') if @options[:slave] || @options[:replica]
+      raise ArgumentError.new('Cannot specify additional replicas on a replica index') if @options[:replica]
       raise ArgumentError.new('No block given') if !block_given?
       add_index(index_name, options.merge({ :replica => true, :primary_settings => self }), &block)
     end
 
-    def add_slave(index_name, options = {}, &block)
-      raise ArgumentError.new('Cannot specify additional slaves on a slave index') if @options[:slave] || @options[:replica]
-      raise ArgumentError.new('No block given') if !block_given?
-      add_index(index_name, options.merge({ :slave => true, :primary_settings => self }), &block)
-    end
-
     def additional_indexes
       @additional_indexes || {}
     end
@@ -300,70 +296,6 @@ module AlgoliaSearch
     autoload :AlgoliaJob, 'algoliasearch/algolia_job'
   end
 
-  # this class wraps an Algolia::Index object ensuring all raised exceptions
-  # are correctly logged or thrown depending on the `raise_on_failure` option
-  class SafeIndex
-    def initialize(name, raise_on_failure)
-      @index = ::Algolia::Index.new(name)
-      @raise_on_failure = raise_on_failure.nil? || raise_on_failure
-    end
-
-    ::Algolia::Index.instance_methods(false).each do |m|
-      define_method(m) do |*args, &block|
-        SafeIndex.log_or_throw(m, @raise_on_failure) do
-          @index.send(m, *args, &block)
-        end
-      end
-    end
-
-    # special handling of wait_task to handle null task_id
-    def wait_task(task_id)
-      return if task_id.nil? && !@raise_on_failure # ok
-      SafeIndex.log_or_throw(:wait_task, @raise_on_failure) do
-        @index.wait_task(task_id)
-      end
-    end
-
-    # special handling of get_settings to avoid raising errors on 404
-    def get_settings(*args)
-      SafeIndex.log_or_throw(:get_settings, @raise_on_failure) do
-        begin
-          @index.get_settings(*args)
-        rescue Algolia::AlgoliaError => e
-          return {} if e.code == 404 # not fatal
-          raise e
-        end
-      end
-    end
-
-    # expose move as well
-    def self.move_index(old_name, new_name)
-      SafeIndex.log_or_throw(:move_index, true) do
-        ::Algolia.move_index(old_name, new_name)
-      end
-    end
-
-    private
-    def self.log_or_throw(method, raise_on_failure, &block)
-      begin
-        yield
-      rescue Algolia::AlgoliaError => e
-        raise e if raise_on_failure
-        # log the error
-        (Rails.logger || Logger.new(STDOUT)).error("[algoliasearch-rails] #{e.message}")
-        # return something
-        case method.to_s
-        when 'search'
-          # some attributes are required
-          { 'hits' => [], 'hitsPerPage' => 0, 'page' => 0, 'facets' => {}, 'error' => e }
-        else
-          # empty answer
-          { 'error' => e }
-        end
-      end
-    end
-  end
-
   # these are the class methods added when AlgoliaSearch is included
   module ClassMethods
 
@@ -380,7 +312,6 @@ module AlgoliaSearch
         alias_method :raw_search, :algolia_raw_search unless method_defined? :raw_search
         alias_method :search_facet, :algolia_search_facet unless method_defined? :search_facet
         alias_method :search_for_facet_values, :algolia_search_for_facet_values unless method_defined? :search_for_facet_values
-        alias_method :index, :algolia_index unless method_defined? :index
         alias_method :index_name, :algolia_index_name unless method_defined? :index_name
         alias_method :must_reindex?, :algolia_must_reindex? unless method_defined? :must_reindex?
       end
@@ -395,7 +326,7 @@ module AlgoliaSearch
       attr_accessor :highlight_result, :snippet_result
 
       if options[:synchronous] == true
-        if defined?(::Sequel) && self < Sequel::Model
+        if defined?(::Sequel) && defined?(::Sequel::Model) && self < Sequel::Model
           class_eval do
             copy_after_validation = instance_method(:after_validation)
             define_method(:after_validation) do |*args|
@@ -426,7 +357,7 @@ module AlgoliaSearch
         end
       end
       unless options[:auto_index] == false
-        if defined?(::Sequel) && self < Sequel::Model
+        if defined?(::Sequel) && defined?(::Sequel::Model) && self < Sequel::Model
           class_eval do
             copy_after_validation = instance_method(:after_validation)
             copy_before_save = instance_method(:before_save)
@@ -473,7 +404,7 @@ module AlgoliaSearch
         end
       end
       unless options[:auto_remove] == false
-        if defined?(::Sequel) && self < Sequel::Model
+        if defined?(::Sequel) && defined?(::Sequel::Model) && self < Sequel::Model
           class_eval do
             copy_after_destroy = instance_method(:after_destroy)
 
@@ -510,15 +441,16 @@ module AlgoliaSearch
       return if algolia_without_auto_index_scope
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
-        index = algolia_ensure_init(options, settings)
-        next if options[:slave] || options[:replica]
+        algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
+        next if options[:replica]
         last_task = nil
 
         algolia_find_in_batches(batch_size) do |group|
           if algolia_conditional_index?(options)
             # delete non-indexable objects
             ids = group.select { |o| !algolia_indexable?(o, options) }.map { |o| algolia_object_id_of(o, options) }
-            index.delete_objects(ids.select { |id| !id.blank? })
+            AlgoliaSearch.client.delete_objects(index_name, ids.select { |id| !id.blank? })
             # select only indexable objects
             group = group.select { |o| algolia_indexable?(o, options) }
           end
@@ -529,9 +461,10 @@ module AlgoliaSearch
             end
             attributes.merge 'objectID' => algolia_object_id_of(o, options)
           end
-          last_task = index.save_objects(objects)
+          save_tasks = AlgoliaSearch.client.save_objects(index_name, objects)
+          last_task = save_tasks.present? ? save_tasks.last.task_id : last_task
         end
-        index.wait_task(last_task["taskID"]) if last_task and (synchronous || options[:synchronous])
+        AlgoliaSearch.client.wait_for_task(index_name, last_task) if last_task and (synchronous || options[:synchronous])
       end
       nil
     end
@@ -541,44 +474,51 @@ module AlgoliaSearch
       return if algolia_without_auto_index_scope
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
-        next if options[:slave] || options[:replica]
+        next if options[:replica]
+
+        algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
 
         # fetch the master settings
-        master_index = algolia_ensure_init(options, settings)
-        master_settings = master_index.get_settings rescue {} # if master doesn't exist yet
-        master_settings.merge!(JSON.parse(settings.to_settings.to_json)) # convert symbols to strings
+        master_settings = AlgoliaSearch.client.get_settings(index_name).to_hash rescue {} # if master doesn't exist yet
+        master_exists = master_settings != {}
+        master_settings.merge!(settings.to_hash)
 
         # remove the replicas of the temporary index
-        master_settings.delete :slaves
-        master_settings.delete 'slaves'
         master_settings.delete :replicas
         master_settings.delete 'replicas'
 
         # init temporary index
-        src_index_name = algolia_index_name(options)
-        tmp_index_name = "#{src_index_name}.tmp"
+        tmp_index_name = "#{index_name}.tmp"
         tmp_options = options.merge({ :index_name => tmp_index_name })
         tmp_options.delete(:per_environment) # already included in the temporary index_name
         tmp_settings = settings.dup
 
-        if options[:check_settings] == false
-          ::Algolia::copy_index!(src_index_name, tmp_index_name, %w(settings synonyms rules))
-          tmp_index = SafeIndex.new(tmp_index_name, !!options[:raise_on_failure])
+        if options[:check_settings] == false && master_exists
+          task_id = AlgoliaSearch.client.operation_index(
+            index_name,
+            Algolia::Search::OperationIndexParams.new(operation: Algolia::Search::OperationType::COPY, destination: tmp_index_name, scope: %w[settings synonyms rules])
+          ).task_id
+          AlgoliaSearch.client.wait_for_task(index_name, task_id)
         else
-          tmp_index = algolia_ensure_init(tmp_options, tmp_settings, master_settings)
+          algolia_ensure_init(tmp_options, tmp_settings, master_settings)
         end
 
-          algolia_find_in_batches(batch_size) do |group|
+        algolia_find_in_batches(batch_size) do |group|
           if algolia_conditional_index?(options)
             # select only indexable objects
             group = group.select { |o| algolia_indexable?(o, tmp_options) }
           end
           objects = group.map { |o| tmp_settings.get_attributes(o).merge 'objectID' => algolia_object_id_of(o, tmp_options) }
-          tmp_index.save_objects(objects)
+
+          AlgoliaSearch.client.save_objects(tmp_index_name, objects)
         end
 
-        move_task = SafeIndex.move_index(tmp_index.name, src_index_name)
-        master_index.wait_task(move_task["taskID"]) if synchronous || options[:synchronous]
+        task_id = AlgoliaSearch.client.operation_index(
+          tmp_index_name,
+          Algolia::Search::OperationIndexParams.new(operation: "move", destination: index_name)
+        ).task_id
+        AlgoliaSearch.client.wait_for_task(index_name, task_id) if synchronous || options[:synchronous]
       end
       nil
     end
@@ -586,29 +526,40 @@ module AlgoliaSearch
     def algolia_set_settings(synchronous = false)
       algolia_configurations.each do |options, settings|
         if options[:primary_settings] && options[:inherit]
-          primary = options[:primary_settings].to_settings
-          primary.delete :slaves
-          primary.delete 'slaves'
+          primary = options[:primary_settings].to_settings.to_hash
           primary.delete :replicas
           primary.delete 'replicas'
-          final_settings = primary.merge(settings.to_settings)
+          final_settings = primary.merge(settings.to_settings.to_hash)
         else
-          final_settings = settings.to_settings
+          final_settings = settings.to_settings.to_hash
+        end
+
+        s = final_settings.map do |k, v|
+          [settings.setting_name(k), v]
+        end.to_h
+
+        synonyms = s.delete("synonyms") || s.delete(:synonyms)
+        unless synonyms.nil? || synonyms.empty?
+          resp = AlgoliaSearch.client.save_synonyms(index_name,synonyms.map {|s| Algolia::Search::SynonymHit.new({object_id: s.join("-"), synonyms: s, type: "synonym"}) } )
+          AlgoliaSearch.client.wait_for_task(index_name, resp.task_id) if synchronous || options[:synchronous]
         end
 
-        index = SafeIndex.new(algolia_index_name(options), true)
-        task = index.set_settings(final_settings)
-        index.wait_task(task["taskID"]) if synchronous
+        resp = AlgoliaSearch.client.set_settings(index_name, Algolia::Search::IndexSettings.new(s))
+        AlgoliaSearch.client.wait_for_task(index_name, resp.task_id) if synchronous || options[:synchronous]
       end
     end
 
     def algolia_index_objects(objects, synchronous = false)
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
-        index = algolia_ensure_init(options, settings)
-        next if options[:slave] || options[:replica]
-        task = index.save_objects(objects.map { |o| settings.get_attributes(o).merge 'objectID' => algolia_object_id_of(o, options) })
-        index.wait_task(task["taskID"]) if synchronous || options[:synchronous]
+        algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
+
+        next if options[:replica]
+        tasks = AlgoliaSearch.client.save_objects(index_name, objects.map { |o| settings.get_attributes(o).merge 'objectID' => algolia_object_id_of(o, options) })
+        tasks.each do |task|
+          AlgoliaSearch.client.wait_for_task(index_name, task.task_id) if synchronous || options[:synchronous]
+        end
       end
     end
 
@@ -616,22 +567,23 @@ module AlgoliaSearch
       return if algolia_without_auto_index_scope
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
+
         object_id = algolia_object_id_of(object, options)
-        index = algolia_ensure_init(options, settings)
-        next if options[:slave] || options[:replica]
+        index_name = algolia_index_name(options)
+        algolia_ensure_init(options, settings)
+        next if options[:replica]
+
         if algolia_indexable?(object, options)
           raise ArgumentError.new("Cannot index a record with a blank objectID") if object_id.blank?
+          resp = AlgoliaSearch.client.save_object(index_name, settings.get_attributes(object).merge({ 'objectID' => algolia_object_id_of(object, options) }))
           if synchronous || options[:synchronous]
-            index.add_object!(settings.get_attributes(object), object_id)
-          else
-            index.add_object(settings.get_attributes(object), object_id)
+            AlgoliaSearch.client.wait_for_task(index_name, resp.task_id)
           end
         elsif algolia_conditional_index?(options) && !object_id.blank?
           # remove non-indexable objects
+          resp = AlgoliaSearch.client.delete_object(index_name, object_id)
           if synchronous || options[:synchronous]
-            index.delete_object!(object_id)
-          else
-            index.delete_object(object_id)
+            AlgoliaSearch.client.wait_for_task(index_name, resp.task_id)
           end
         end
       end
@@ -644,12 +596,14 @@ module AlgoliaSearch
       raise ArgumentError.new("Cannot index a record with a blank objectID") if object_id.blank?
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
-        index = algolia_ensure_init(options, settings)
-        next if options[:slave] || options[:replica]
+        algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
+
+        next if options[:replica]
+
+        resp = AlgoliaSearch.client.delete_object(index_name, object_id)
         if synchronous || options[:synchronous]
-          index.delete_object!(object_id)
-        else
-          index.delete_object(object_id)
+          AlgoliaSearch.client.wait_for_task(index_name, resp.task_id)
         end
       end
       nil
@@ -657,24 +611,38 @@ module AlgoliaSearch
 
     def algolia_clear_index!(synchronous = false)
       algolia_configurations.each do |options, settings|
-        next if algolia_indexing_disabled?(options)
-        index = algolia_ensure_init(options, settings)
-        next if options[:slave] || options[:replica]
-        synchronous || options[:synchronous] ? index.clear! : index.clear
-        @algolia_indexes[settings] = nil
+        next if algolia_indexing_disabled?(options) || options[:replica]
+
+        algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
+        res = AlgoliaSearch.client.clear_objects(index_name)
+
+        if synchronous || options[:synchronous]
+          AlgoliaSearch.client.wait_for_task(index_name, res.task_id)
+        end
       end
       nil
     end
 
+
     def algolia_raw_search(q, params = {})
-      index_name = params.delete(:index) ||
+      index_name_base = params.delete(:index) ||
                    params.delete('index') ||
-                   params.delete(:slave) ||
-                   params.delete('slave') ||
                    params.delete(:replica) ||
                    params.delete('replica')
-      index = algolia_index(index_name)
-      index.search(q, Hash[params.map { |k,v| [k.to_s, v.to_s] }])
+
+      opts = algoliasearch_options
+      unless index_name_base.nil?
+        algolia_configurations.each do |o, s|
+          if o[:index_name].to_s == index_name_base.to_s
+            opts = o
+            ensure_algolia_index(index_name_base)
+          end
+        end
+      end
+
+      index_name = algolia_index_name(opts, index_name_base)
+      AlgoliaSearch.client.search_single_index(index_name,Hash[params.to_h.map { |k,v| [k.to_s, v.to_s] }].merge({query: q})).to_hash
     end
 
     module AdditionalMethods
@@ -690,7 +658,7 @@ module AlgoliaSearch
       end
 
       def algolia_facets
-        @algolia_json['facets']
+        @algolia_json[:facets]
       end
 
       private
@@ -701,12 +669,12 @@ module AlgoliaSearch
 
     def algolia_search(q, params = {})
       if AlgoliaSearch.configuration[:pagination_backend]
-        # kaminari and will_paginate start pagination at 1, Algolia starts at 0
+        # kaminari, will_paginate, and pagy start pagination at 1, Algolia starts at 0
         params[:page] = (params.delete('page') || params.delete(:page)).to_i
         params[:page] -= 1 if params[:page].to_i > 0
       end
       json = algolia_raw_search(q, params)
-      hit_ids = json['hits'].map { |hit| hit['objectID'] }
+      hit_ids = json[:hits].map { |hit| hit[:objectID] }
       if defined?(::Mongoid::Document) && self.include?(::Mongoid::Document)
         condition_key = algolia_object_id_method.in
       else
@@ -715,18 +683,18 @@ module AlgoliaSearch
       results_by_id = algoliasearch_options[:type].where(condition_key => hit_ids).index_by do |hit|
         algolia_object_id_of(hit)
       end
-      results = json['hits'].map do |hit|
-        o = results_by_id[hit['objectID'].to_s]
+      results = json[:hits].map do |hit|
+        o = results_by_id[hit[:objectID].to_s]
         if o
-          o.highlight_result = hit['_highlightResult']
-          o.snippet_result = hit['_snippetResult']
+          o.highlight_result = hit[:_highlightResult]
+          o.snippet_result = hit[:_snippetResult]
           o
         end
       end.compact
       # Algolia has a default limit of 1000 retrievable hits
-      total_hits = json['nbHits'].to_i < json['nbPages'].to_i * json['hitsPerPage'].to_i ?
-        json['nbHits'].to_i: json['nbPages'].to_i * json['hitsPerPage'].to_i
-      res = AlgoliaSearch::Pagination.create(results, total_hits, algoliasearch_options.merge({ :page => json['page'].to_i + 1, :per_page => json['hitsPerPage'] }))
+      total_hits = json[:nbHits].to_i < json[:nbPages].to_i * json[:hitsPerPage].to_i ?
+        json[:nbHits].to_i: json[:nbPages].to_i * json[:hitsPerPage].to_i
+      res = AlgoliaSearch::Pagination.create(results, total_hits, algoliasearch_options.merge({ :page => json[:page].to_i + 1, :per_page => json[:hitsPerPage] }))
       res.extend(AdditionalMethods)
       res.send(:algolia_init_raw_answer, json)
       res
@@ -735,19 +703,18 @@ module AlgoliaSearch
     def algolia_search_for_facet_values(facet, text, params = {})
       index_name = params.delete(:index) ||
                    params.delete('index') ||
-                   params.delete(:slave) ||
-                   params.delete('slave') ||
                    params.delete(:replica) ||
                    params.delete('replicas')
-      index = algolia_index(index_name)
-      query = Hash[params.map { |k, v| [k.to_s, v.to_s] }]
-      index.search_facet(facet, text, query)['facetHits']
+      index_name ||= algolia_index_name(algoliasearch_options)
+      req = Algolia::Search::SearchForFacetValuesRequest.new({facet_query: text, params: params.to_query})
+
+      AlgoliaSearch.client.search_for_facet_values(index_name, facet, req).facet_hits
     end
 
     # deprecated (renaming)
     alias :algolia_search_facet :algolia_search_for_facet_values
 
-    def algolia_index(name = nil)
+    def ensure_algolia_index(name = nil)
       if name
         algolia_configurations.each do |o, s|
           return algolia_ensure_init(o, s) if o[:index_name].to_s == name.to_s
@@ -757,9 +724,9 @@ module AlgoliaSearch
       algolia_ensure_init
     end
 
-    def algolia_index_name(options = nil)
+    def algolia_index_name(options = nil, index_name = nil)
       options ||= algoliasearch_options
-      name = options[:index_name] || model_name.to_s.gsub('::', '_')
+      name = index_name || options[:index_name] || model_name.to_s.gsub('::', '_')
       name = "#{name}_#{Rails.env.to_s}" if options[:per_environment]
       name
     end
@@ -770,17 +737,16 @@ module AlgoliaSearch
       # Loop over each index to see if a attribute used in records has changed
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
-        next if options[:slave] || options[:replica]
+        next if options[:replica]
         return true if algolia_object_id_changed?(object, options)
         settings.get_attribute_names(object).each do |k|
-          return true if algolia_attribute_changed?(object, k)
-          # return true if !object.respond_to?(changed_method) || object.send(changed_method)
+          return true if algolia_attribute_changed?(object, k, true)
         end
         [options[:if], options[:unless]].each do |condition|
           case condition
           when nil
           when String, Symbol
-            return true if algolia_attribute_changed?(object, condition)
+            return true if algolia_attribute_changed?(object, condition, true)
           else
             # if the :if, :unless condition is a anything else,
             # we have no idea whether we should reindex or not
@@ -795,36 +761,46 @@ module AlgoliaSearch
 
     protected
 
-    def algolia_ensure_init(options = nil, settings = nil, index_settings = nil)
+    def algolia_ensure_init(options = nil, settings = nil, index_settings_hash = nil)
       raise ArgumentError.new('No `algoliasearch` block found in your model.') if algoliasearch_settings.nil?
 
-      @algolia_indexes ||= {}
+      @algolia_indexes_init ||= {}
 
       options ||= algoliasearch_options
       settings ||= algoliasearch_settings
 
-      return @algolia_indexes[settings] if @algolia_indexes[settings]
+      return if @algolia_indexes_init[settings]
 
-      @algolia_indexes[settings] = SafeIndex.new(algolia_index_name(options), algoliasearch_options[:raise_on_failure])
+      index_name = algolia_index_name(options)
 
-      current_settings = @algolia_indexes[settings].get_settings(:getVersion => 1) rescue nil # if the index doesn't exist
 
-      index_settings ||= settings.to_settings
-      index_settings = options[:primary_settings].to_settings.merge(index_settings) if options[:inherit]
+      index_settings_hash ||= settings.to_settings.to_hash
+      index_settings_hash = options[:primary_settings].to_settings.to_hash.merge(index_settings_hash) if options[:inherit]
+      replicas = index_settings_hash.delete(:replicas) || index_settings_hash.delete('replicas')
+      index_settings_hash[:replicas] = replicas unless replicas.nil? || options[:inherit]
 
       options[:check_settings] = true if options[:check_settings].nil?
 
-      if !algolia_indexing_disabled?(options) && options[:check_settings] && algoliasearch_settings_changed?(current_settings, index_settings)
-        used_slaves = !current_settings.nil? && !current_settings['slaves'].nil?
-        replicas = index_settings.delete(:replicas) ||
-                   index_settings.delete('replicas') ||
-                   index_settings.delete(:slaves) ||
-                   index_settings.delete('slaves')
-        index_settings[used_slaves ? :slaves : :replicas] = replicas unless replicas.nil? || options[:inherit]
-        @algolia_indexes[settings].set_settings(index_settings)
+      current_settings = if options[:check_settings] && !algolia_indexing_disabled?(options)
+                           AlgoliaSearch.client.get_settings(index_name, {:getVersion => 1}).to_hash rescue nil # if the index doesn't exist
+                         end
+
+      if !algolia_indexing_disabled?(options) && options[:check_settings] && algoliasearch_settings_changed?(current_settings, index_settings_hash)
+        s = index_settings_hash.map do |k, v|
+          [settings.setting_name(k), v]
+        end.to_h
+
+        synonyms = s.delete("synonyms") || s.delete(:synonyms)
+        unless synonyms.nil? || synonyms.empty?
+          resp = AlgoliaSearch.client.save_synonyms(index_name,synonyms.map {|s| Algolia::Search::SynonymHit.new({object_id: s.join("-"), synonyms: s, type: "synonym"}) } )
+          AlgoliaSearch.client.wait_for_task(index_name, resp.task_id) if options[:synchronous]
+        end
+
+        resp = AlgoliaSearch.client.set_settings(index_name, Algolia::Search::IndexSettings.new(s))
+        AlgoliaSearch.client.wait_for_task(index_name, resp.task_id) if options[:synchronous]
       end
 
-      @algolia_indexes[settings]
+      return
     end
 
     private
@@ -857,17 +833,19 @@ module AlgoliaSearch
     end
 
     def algolia_object_id_changed?(o, options = nil)
-      changed = algolia_attribute_changed?(o, algolia_object_id_method(options))
+      changed = algolia_attribute_changed?(o, algolia_object_id_method(options), false)
       changed.nil? ? false : changed
     end
 
     def algoliasearch_settings_changed?(prev, current)
       return true if prev.nil?
       current.each do |k, v|
-        prev_v = prev[k.to_s]
+        prev_v = prev[k.to_sym] || prev[k.to_s]
         if v.is_a?(Array) and prev_v.is_a?(Array)
           # compare array of strings, avoiding symbols VS strings comparison
           return true if v.map { |x| x.to_s } != prev_v.map { |x| x.to_s }
+        elsif v.blank? # blank? check is needed to compare [] and null
+          return true unless prev_v.blank?
         else
           return true if prev_v != v
         end
@@ -936,7 +914,7 @@ module AlgoliaSearch
     def algolia_find_in_batches(batch_size, &block)
       if (defined?(::ActiveRecord) && ancestors.include?(::ActiveRecord::Base)) || respond_to?(:find_in_batches)
         find_in_batches(:batch_size => batch_size, &block)
-      elsif defined?(::Sequel) && self < Sequel::Model
+      elsif defined?(::Sequel) && defined?(::Sequel::Model) && self < Sequel::Model
         dataset.extension(:pagination).each_page(batch_size, &block)
       else
         # don't worry, mongoid has its own underlying cursor/streaming mechanism
@@ -952,7 +930,7 @@ module AlgoliaSearch
       end
     end
 
-    def algolia_attribute_changed?(object, attr_name)
+    def algolia_attribute_changed?(object, attr_name, default)
       # if one of two method is implemented, we return its result
       # true/false means whether it has changed or not
       # +#{attr_name}_changed?+ always defined for automatic attributes but deprecated after Rails 5.2
@@ -981,8 +959,8 @@ module AlgoliaSearch
         return object.send("will_save_change_to_#{attr_name}?")
       end
 
-      # We don't know if the attribute has changed, so conservatively assume it has
-      true
+      # We don't know if the attribute has changed, so return the default passed
+      default
     end
 
     def automatic_changed_method?(object, method_name)
@@ -1049,7 +1027,7 @@ module AlgoliaSearch
       # algolia_must_reindex flag is reset after every commit as part. If we must reindex at any point in
       # a stransaction, keep flag set until it is explicitly unset
       @algolia_must_reindex ||=
-       if defined?(::Sequel) && is_a?(Sequel::Model)
+       if defined?(::Sequel) && defined?(::Sequel::Model) && is_a?(Sequel::Model)
          new? || self.class.algolia_must_reindex?(self)
        else
          new_record? || self.class.algolia_must_reindex?(self)