algoliasearch-rails 1.16.3 → 1.25.0

data/algoliasearch-rails.gemspec

@@ -1,10 +1,12 @@
 # -*- encoding: utf-8 -*-
 
-VERSION = File.read(File.join(File.dirname(__FILE__), 'VERSION')).strip
+require File.join(File.dirname(__FILE__), 'lib', 'algoliasearch', 'version')
+
+require 'date'
 
 Gem::Specification.new do |s|
   s.name = "algoliasearch-rails"
-  s.version = VERSION
+  s.version = AlgoliaSearch::VERSION
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Algolia"]
@@ -12,7 +14,7 @@ Gem::Specification.new do |s|
   s.description = "AlgoliaSearch integration to your favorite ORM"
   s.email = "contact@algolia.com"
   s.extra_rdoc_files = [
-    "ChangeLog",
+    "CHANGELOG.MD",
     "LICENSE",
     "README.md"
   ]
@@ -20,13 +22,12 @@ Gem::Specification.new do |s|
     ".document",
     ".rspec",
     ".travis.yml",
-    "ChangeLog",
+    "CHANGELOG.MD",
     "Gemfile",
     "Gemfile.lock",
     "LICENSE",
     "README.md",
     "Rakefile",
-    "VERSION",
     "algoliasearch-rails.gemspec",
     "lib/algoliasearch-rails.rb",
     "lib/algoliasearch/algolia_job.rb",
@@ -37,6 +38,7 @@ Gem::Specification.new do |s|
     "lib/algoliasearch/railtie.rb",
     "lib/algoliasearch/tasks/algoliasearch.rake",
     "lib/algoliasearch/utilities.rb",
+    "lib/algoliasearch/version.rb",
     "spec/spec_helper.rb",
     "spec/utilities_spec.rb",
     "vendor/assets/javascripts/algolia/algoliasearch.angular.js",
@@ -77,7 +79,7 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<json>, [">= 1.5.1"])
-      s.add_runtime_dependency(%q<algoliasearch>, ["~> 1.12.1"])
+      s.add_runtime_dependency(%q<algoliasearch>, [">= 1.26.0", "< 2.0.0"])
       s.add_development_dependency(%q<will_paginate>, [">= 2.3.15"])
       s.add_development_dependency(%q<kaminari>, [">= 0"])
       s.add_development_dependency "travis"
@@ -85,11 +87,11 @@ Gem::Specification.new do |s|
       s.add_development_dependency "rdoc"
     else
       s.add_dependency(%q<json>, [">= 1.5.1"])
-      s.add_dependency(%q<algoliasearch>, ["~> 1.12.1"])
+      s.add_dependency(%q<algoliasearch>, [">= 1.26.0", "< 2.0.0"])
     end
   else
     s.add_dependency(%q<json>, [">= 1.5.1"])
-    s.add_dependency(%q<algoliasearch>, ["~> 1.12.1"])
+    s.add_dependency(%q<algoliasearch>, [">= 1.26.0", "< 2.0.0"])
   end
 end
 

data/lib/algoliasearch-rails.rb

@@ -1,13 +1,6 @@
-begin
-  require "rubygems"
-  require "bundler"
-
-  Bundler.setup :default
-rescue => e
-  puts "AlgoliaSearch: #{e.message}"
-end
 require 'algoliasearch'
 
+require 'algoliasearch/version'
 require 'algoliasearch/utilities'
 
 if defined? Rails
@@ -30,6 +23,7 @@ module AlgoliaSearch
   class NotConfigured < StandardError; end
   class BadConfiguration < StandardError; end
   class NoBlockGiven < StandardError; end
+  class MixedSlavesAndReplicas < StandardError; end
 
   autoload :Configuration, 'algoliasearch/configuration'
   extend Configuration
@@ -53,33 +47,62 @@ module AlgoliaSearch
   end
 
   class IndexSettings
+    DEFAULT_BATCH_SIZE = 1000
 
     # AlgoliaSearch settings
-    OPTIONS = [:minWordSizefor1Typo, :minWordSizefor2Typos, :typoTolerance,
-      :hitsPerPage, :attributesToRetrieve,
-      :attributesToHighlight, :attributesToSnippet, :attributesToIndex,
-      :highlightPreTag, :highlightPostTag,
-      :ranking, :customRanking, :queryType, :attributesForFaceting,
-      :separatorsToIndex, :optionalWords, :attributeForDistinct,
-      :synonyms, :placeholders, :removeWordsIfNoResults, :replaceSynonymsInHighlight,
-      :unretrievableAttributes, :disableTypoToleranceOnWords, :disableTypoToleranceOnAttributes, :altCorrections,
-      :ignorePlurals, :maxValuesPerFacet, :distinct, :numericAttributesToIndex,
-      :allowTyposOnNumericTokens, :allowCompressionOfIntegerArray,
-      :advancedSyntax]
+    OPTIONS = [
+      # Attributes
+      :searchableAttributes, :attributesForFaceting, :unretrievableAttributes, :attributesToRetrieve,
+      :attributesToIndex, #Legacy name of searchableAttributes
+      # Ranking
+      :ranking, :customRanking, # Replicas are handled via `add_replica`
+      # Faceting
+      :maxValuesPerFacet, :sortFacetValuesBy,
+      # Highlighting / Snippeting
+      :attributesToHighlight, :attributesToSnippet, :highlightPreTag, :highlightPostTag,
+      :snippetEllipsisText, :restrictHighlightAndSnippetArrays,
+      # Pagination
+      :hitsPerPage, :paginationLimitedTo,
+      # Typo
+      :minWordSizefor1Typo, :minWordSizefor2Typos, :typoTolerance, :allowTyposOnNumericTokens,
+      :disableTypoToleranceOnAttributes, :disableTypoToleranceOnWords, :separatorsToIndex,
+      # Language
+      :ignorePlurals, :removeStopWords, :camelCaseAttributes, :decompoundedAttributes,
+      :keepDiacriticsOnCharacters, :queryLanguages, :indexLanguages,
+      # Query Rules
+      :enableRules,
+      # Query Strategy
+      :queryType, :removeWordsIfNoResults, :advancedSyntax, :optionalWords,
+      :disablePrefixOnAttributes, :disableExactOnAttributes, :exactOnSingleWordQuery, :alternativesAsExact,
+      # Performance
+      :numericAttributesForFiltering, :allowCompressionOfIntegerArray,
+      :numericAttributesToIndex, # Legacy name of numericAttributesForFiltering
+      # Advanced
+      :attributeForDistinct, :distinct, :replaceSynonymsInHighlight, :minProximity, :responseFields,
+      :maxFacetHits,
+
+      # Rails-specific
+      :synonyms, :placeholders, :altCorrections,
+    ]
     OPTIONS.each do |k|
       define_method k do |v|
         instance_variable_set("@#{k}", v)
       end
     end
 
-    def initialize(options, block)
+    def initialize(options, &block)
       @options = options
-      instance_exec(&block) if block
+      instance_exec(&block) if block_given?
+    end
+
+    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 slave index') if @options[:slave]
+      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:slave] || @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) }
@@ -89,7 +112,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 slave index') if @options[:slave]
+      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:slave] || @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) }
@@ -123,15 +146,7 @@ module AlgoliaSearch
     end
 
     def get_attribute_names(object)
-      res = if @attributes.nil? || @attributes.length == 0
-        get_default_attributes(object).keys
-      else
-        @attributes.keys
-      end
-
-      res += @additional_attributes.keys if @additional_attributes
-
-      res
+      get_attributes(object).keys
     end
 
     def attributes_to_hash(attributes, object)
@@ -143,19 +158,27 @@ module AlgoliaSearch
     end
 
     def get_attributes(object)
-      attributes = if @attributes.nil? || @attributes.length == 0
-        get_default_attributes(object)
+      # If a serializer is set, we ignore attributes
+      # everything should be done via the serializer
+      if not @serializer.nil?
+        attributes = @serializer.new(object).attributes
       else
-        if is_active_record?(object)
-          object.class.unscoped do
-            attributes_to_hash(@attributes, object)
-          end
+        if @attributes.nil? || @attributes.length == 0
+          # no `attribute ...` have been configured, use the default attributes of the model
+          attributes = get_default_attributes(object)
         else
-          attributes_to_hash(@attributes, object)
+          # at least 1 `attribute ...` has been configured, therefore use ONLY the one configured
+          if is_active_record?(object)
+            object.class.unscoped do
+              attributes = attributes_to_hash(@attributes, object)
+            end
+          else
+            attributes = attributes_to_hash(@attributes, object)
+          end
         end
       end
 
-      attributes.merge!(attributes_to_hash(@additional_attributes, object))
+      attributes.merge!(attributes_to_hash(@additional_attributes, object)) if @additional_attributes
 
       if @options[:sanitize]
         sanitizer = begin
@@ -200,15 +223,15 @@ module AlgoliaSearch
       end
     end
 
-    def geoloc(lat_attr, lng_attr)
-      raise ArgumentError.new('Cannot specify additional attributes on a slave index') if @options[:slave]
+    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]
       add_attribute :_geoloc do |o|
-        { :lat => o.send(lat_attr).to_f, :lng => o.send(lng_attr).to_f }
+        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 slave index') if @options[:slave]
+      raise ArgumentError.new('Cannot specify additional attributes on a replica index') if @options[:slave] || @options[:replica]
       add_attribute :_tags do |o|
         v = block_given? ? o.instance_eval(&block) : args
         v.is_a?(Array) ? v : [v]
@@ -225,27 +248,43 @@ module AlgoliaSearch
         v = get_setting(k)
         settings[k] = v if !v.nil?
       end
-      settings[:slaves] = additional_indexes.select { |options, s| options[:slave] }.map do |options, s|
-        name = options[:index_name]
-        name = "#{name}_#{Rails.env.to_s}" if options[:per_environment]
-        name
-      end if !@options[:slave]
+      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?
+        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
+        end
+        settings.delete(:replicas) if settings[:replicas].empty?
+      end
       settings
     end
 
     def add_index(index_name, options = {}, &block)
-      raise ArgumentError.new('Cannot specify additional index on a slave index') if @options[:slave]
+      raise ArgumentError.new('Cannot specify additional index on a replica index') if @options[:slave] || @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]
-      options[:index_name] = index_name
       @additional_indexes ||= {}
-      @additional_indexes[options] = IndexSettings.new(options, Proc.new)
+      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('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]
+      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 }), &block)
+      add_index(index_name, options.merge({ :slave => true, :primary_settings => self }), &block)
     end
 
     def additional_indexes
@@ -271,7 +310,7 @@ module AlgoliaSearch
 
     ::Algolia::Index.instance_methods(false).each do |m|
       define_method(m) do |*args, &block|
-        SafeIndex.log_or_throw(m) do
+        SafeIndex.log_or_throw(m, @raise_on_failure) do
           @index.send(m, *args, &block)
         end
       end
@@ -280,18 +319,18 @@ module AlgoliaSearch
     # 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) do
+      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(:move_index) do
+      SafeIndex.log_or_throw(:get_settings, @raise_on_failure) do
         begin
           @index.get_settings(*args)
         rescue Algolia::AlgoliaError => e
-          return {} if e.status == 404 # not fatal
+          return {} if e.code == 404 # not fatal
           raise e
         end
       end
@@ -299,17 +338,17 @@ module AlgoliaSearch
 
     # expose move as well
     def self.move_index(old_name, new_name)
-      SafeIndex.log_or_throw(:move_index) do
+      SafeIndex.log_or_throw(:move_index, true) do
         ::Algolia.move_index(old_name, new_name)
       end
     end
 
     private
-    def self.log_or_throw(method, &block)
+    def self.log_or_throw(method, raise_on_failure, &block)
       begin
         yield
       rescue Algolia::AlgoliaError => e
-        raise e if @raise_on_failure
+        raise e if raise_on_failure
         # log the error
         (Rails.logger || Logger.new(STDOUT)).error("[algoliasearch-rails] #{e.message}")
         # return something
@@ -350,7 +389,7 @@ module AlgoliaSearch
     end
 
     def algoliasearch(options = {}, &block)
-      self.algoliasearch_settings = IndexSettings.new(options, block_given? ? Proc.new : nil)
+      self.algoliasearch_settings = IndexSettings.new(options, &block)
       self.algoliasearch_options = { :type => algolia_full_const_get(model_name.to_s), :per_page => algoliasearch_settings.get_setting(:hitsPerPage) || 10, :page => 1 }.merge(options)
 
       attr_accessor :highlight_result, :snippet_result
@@ -383,7 +422,7 @@ module AlgoliaSearch
           raise ArgumentError.new("Invalid `enqueue` option: #{options[:enqueue]}")
         end
         algoliasearch_options[:enqueue] = Proc.new do |record, remove|
-          proc.call(record, remove) unless @algolia_without_auto_index_scope
+          proc.call(record, remove) unless algolia_without_auto_index_scope
         end
       end
       unless options[:auto_index] == false
@@ -391,7 +430,6 @@ module AlgoliaSearch
           class_eval do
             copy_after_validation = instance_method(:after_validation)
             copy_before_save = instance_method(:before_save)
-            copy_after_commit = instance_method(:after_commit)
 
             define_method(:after_validation) do |*args|
               super(*args)
@@ -405,10 +443,23 @@ module AlgoliaSearch
               super(*args)
             end
 
-            define_method(:after_commit) do |*args|
-              super(*args)
-              copy_after_commit.bind(self).call
-              algolia_perform_index_tasks
+            sequel_version = Gem::Version.new(Sequel.version)
+            if sequel_version >= Gem::Version.new('4.0.0') && sequel_version < Gem::Version.new('5.0.0')
+              copy_after_commit = instance_method(:after_commit)
+              define_method(:after_commit) do |*args|
+                super(*args)
+                copy_after_commit.bind(self).call
+                algolia_perform_index_tasks
+              end
+            else
+              copy_after_save = instance_method(:after_save)
+              define_method(:after_save) do |*args|
+                super(*args)
+                copy_after_save.bind(self).call
+                self.db.after_commit do
+                  algolia_perform_index_tasks
+                end
+              end
             end
           end
         else
@@ -439,20 +490,28 @@ module AlgoliaSearch
     end
 
     def algolia_without_auto_index(&block)
-      @algolia_without_auto_index_scope = true
+      self.algolia_without_auto_index_scope = true
       begin
         yield
       ensure
-        @algolia_without_auto_index_scope = false
+        self.algolia_without_auto_index_scope = false
       end
     end
 
-    def algolia_reindex!(batch_size = 1000, synchronous = false)
-      return if @algolia_without_auto_index_scope
+    def algolia_without_auto_index_scope=(value)
+      Thread.current["algolia_without_auto_index_scope_for_#{self.model_name}"] = value
+    end
+
+    def algolia_without_auto_index_scope
+      Thread.current["algolia_without_auto_index_scope_for_#{self.model_name}"]
+    end
+
+    def algolia_reindex!(batch_size = AlgoliaSearch::IndexSettings::DEFAULT_BATCH_SIZE, synchronous = false)
+      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]
+        next if options[:slave] || options[:replica]
         last_task = nil
 
         algolia_find_in_batches(batch_size) do |group|
@@ -472,36 +531,45 @@ module AlgoliaSearch
           end
           last_task = index.save_objects(objects)
         end
-        index.wait_task(last_task["taskID"]) if last_task and synchronous == true
+        index.wait_task(last_task["taskID"]) if last_task and (synchronous || options[:synchronous])
       end
       nil
     end
 
     # reindex whole database using a extra temporary index + move operation
-    def algolia_reindex(batch_size = 1000, synchronous = false)
-      return if @algolia_without_auto_index_scope
+    def algolia_reindex(batch_size = AlgoliaSearch::IndexSettings::DEFAULT_BATCH_SIZE, synchronous = false)
+      return if algolia_without_auto_index_scope
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
-        next if options[:slave]
+        next if options[:slave] || options[:replica]
 
         # 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
 
-        # remove the slaves of the temporary index
+        # 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
-        index_name = algolia_index_name(options)
-        tmp_options = options.merge({ :index_name => "#{index_name}.tmp" })
+        src_index_name = algolia_index_name(options)
+        tmp_index_name = "#{src_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
-        tmp_index = algolia_ensure_init(tmp_options, tmp_settings, master_settings)
 
-        algolia_find_in_batches(batch_size) do |group|
-          if algolia_conditional_index?(tmp_options)
+        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])
+        else
+          tmp_index = algolia_ensure_init(tmp_options, tmp_settings, master_settings)
+        end
+
+          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
@@ -509,39 +577,58 @@ module AlgoliaSearch
           tmp_index.save_objects(objects)
         end
 
-        move_task = SafeIndex.move_index(tmp_index.name, index_name)
-        tmp_index.wait_task(move_task["taskID"]) if synchronous == true
+        move_task = SafeIndex.move_index(tmp_index.name, src_index_name)
+        master_index.wait_task(move_task["taskID"]) if synchronous || options[:synchronous]
       end
       nil
     end
 
+    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.delete :replicas
+          primary.delete 'replicas'
+          final_settings = primary.merge(settings.to_settings)
+        else
+          final_settings = settings.to_settings
+        end
+
+        index = SafeIndex.new(algolia_index_name(options), true)
+        task = index.set_settings(final_settings)
+        index.wait_task(task["taskID"]) if 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]
+        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 == true
+        index.wait_task(task["taskID"]) if synchronous || options[:synchronous]
       end
     end
 
     def algolia_index!(object, synchronous = false)
-      return if @algolia_without_auto_index_scope
+      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]
+        next if options[:slave] || options[:replica]
         if algolia_indexable?(object, options)
           raise ArgumentError.new("Cannot index a record with a blank objectID") if object_id.blank?
-          if synchronous
+          if synchronous || options[:synchronous]
             index.add_object!(settings.get_attributes(object), object_id)
           else
             index.add_object(settings.get_attributes(object), object_id)
           end
         elsif algolia_conditional_index?(options) && !object_id.blank?
           # remove non-indexable objects
-          if synchronous
+          if synchronous || options[:synchronous]
             index.delete_object!(object_id)
           else
             index.delete_object(object_id)
@@ -552,14 +639,14 @@ module AlgoliaSearch
     end
 
     def algolia_remove_from_index!(object, synchronous = false)
-      return if @algolia_without_auto_index_scope
+      return if algolia_without_auto_index_scope
       object_id = algolia_object_id_of(object)
       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]
-        if synchronous
+        next if options[:slave] || options[:replica]
+        if synchronous || options[:synchronous]
           index.delete_object!(object_id)
         else
           index.delete_object(object_id)
@@ -572,15 +659,20 @@ module AlgoliaSearch
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
         index = algolia_ensure_init(options, settings)
-        next if options[:slave]
-        synchronous ? index.clear! : index.clear
+        next if options[:slave] || options[:replica]
+        synchronous || options[:synchronous] ? index.clear! : index.clear
         @algolia_indexes[settings] = nil
       end
       nil
     end
 
     def algolia_raw_search(q, params = {})
-      index_name = params.delete(:index) || params.delete('index') || params.delete(:slave) || params.delete('slave')
+      index_name = 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] }])
     end
@@ -624,7 +716,7 @@ module AlgoliaSearch
         algolia_object_id_of(hit)
       end
       results = json['hits'].map do |hit|
-        o = results_by_id[hit['objectID']]
+        o = results_by_id[hit['objectID'].to_s]
         if o
           o.highlight_result = hit['_highlightResult']
           o.snippet_result = hit['_snippetResult']
@@ -632,16 +724,21 @@ module AlgoliaSearch
         end
       end.compact
       # Algolia has a default limit of 1000 retrievable hits
-      total_hits = json['nbHits'] < json['nbPages'] * json['hitsPerPage'] ?
-        json['nbHits'] : json['nbPages'] * json['hitsPerPage']
-      res = AlgoliaSearch::Pagination.create(results, total_hits, algoliasearch_options.merge({ :page => json['page'] + 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
     end
 
     def algolia_search_for_facet_values(facet, text, params = {})
-      index_name = params.delete(:index) || params.delete('index') || params.delete(:slave) || params.delete('slave')
+      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']
@@ -655,7 +752,7 @@ module AlgoliaSearch
         algolia_configurations.each do |o, s|
           return algolia_ensure_init(o, s) if o[:index_name].to_s == name.to_s
         end
-        raise ArgumentError.new("Invalid index/slave name: #{name}")
+        raise ArgumentError.new("Invalid index/replica name: #{name}")
       end
       algolia_ensure_init
     end
@@ -668,23 +765,31 @@ module AlgoliaSearch
     end
 
     def algolia_must_reindex?(object)
+      # use +algolia_dirty?+ method if implemented
+      return object.send(:algolia_dirty?) if (object.respond_to?(:algolia_dirty?))
+      # Loop over each index to see if a attribute used in records has changed
       algolia_configurations.each do |options, settings|
-        next if options[:slave]
+        next if algolia_indexing_disabled?(options)
+        next if options[:slave] || options[:replica]
         return true if algolia_object_id_changed?(object, options)
         settings.get_attribute_names(object).each do |k|
-          changed_method = "#{k}_changed?"
-          return true if !object.respond_to?(changed_method) || object.send(changed_method)
+          return true if algolia_attribute_changed?(object, k)
+          # return true if !object.respond_to?(changed_method) || object.send(changed_method)
         end
         [options[:if], options[:unless]].each do |condition|
           case condition
           when nil
           when String, Symbol
-            changed_method = "#{condition}_changed?"
-            return true if !object.respond_to?(changed_method) || object.send(changed_method)
+            return true if algolia_attribute_changed?(object, condition)
           else
+            # if the :if, :unless condition is a anything else,
+            # we have no idea whether we should reindex or not
+            # let's always reindex then
+            return true
           end
         end
       end
+      # By default, we don't reindex
       return false
     end
 
@@ -692,16 +797,33 @@ module AlgoliaSearch
 
     def algolia_ensure_init(options = nil, settings = nil, index_settings = nil)
       raise ArgumentError.new('No `algoliasearch` block found in your model.') if algoliasearch_settings.nil?
+
       @algolia_indexes ||= {}
+
       options ||= algoliasearch_options
       settings ||= algoliasearch_settings
+
       return @algolia_indexes[settings] if @algolia_indexes[settings]
+
       @algolia_indexes[settings] = SafeIndex.new(algolia_index_name(options), algoliasearch_options[:raise_on_failure])
-      current_settings = @algolia_indexes[settings].get_settings rescue nil # if the index doesn't exist
-      if !algolia_indexing_disabled?(options) && (index_settings || algoliasearch_settings_changed?(current_settings, settings.to_settings))
-        index_settings ||= settings.to_settings
+
+      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]
+
+      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)
       end
+
       @algolia_indexes[settings]
     end
 
@@ -735,8 +857,8 @@ module AlgoliaSearch
     end
 
     def algolia_object_id_changed?(o, options = nil)
-      m = "#{algolia_object_id_method(options)}_changed?"
-      o.respond_to?(m) ? o.send(m) : false
+      changed = algolia_attribute_changed?(o, algolia_object_id_method(options))
+      changed.nil? ? false : changed
     end
 
     def algoliasearch_settings_changed?(prev, current)
@@ -829,6 +951,50 @@ module AlgoliaSearch
         yield items unless items.empty?
       end
     end
+
+    def algolia_attribute_changed?(object, attr_name)
+      # 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
+      # +will_save_change_to_#{attr_name}?+ should be use instead for Rails 5.2+, also defined for automatic attributes.
+      # If none of the method are defined, it's a dynamic attribute
+
+      method_name = "#{attr_name}_changed?"
+      if object.respond_to?(method_name)
+        # If +#{attr_name}_changed?+ respond we want to see if the method is user defined or if it's automatically
+        # defined by Rails.
+        # If it's user-defined, we call it.
+        # If it's automatic we check ActiveRecord version to see if this method is deprecated
+        # and try to call +will_save_change_to_#{attr_name}?+ instead.
+        # See: https://github.com/algolia/algoliasearch-rails/pull/338
+        # This feature is not compatible with Ruby 1.8
+        # In this case, we always call #{attr_name}_changed?
+        if Object.const_defined?(:RUBY_VERSION) && RUBY_VERSION.to_f < 1.9
+          return object.send(method_name)
+        end
+        unless automatic_changed_method?(object, method_name) && automatic_changed_method_deprecated?
+          return object.send(method_name)
+        end
+      end
+
+      if object.respond_to?("will_save_change_to_#{attr_name}?")
+        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
+    end
+
+    def automatic_changed_method?(object, method_name)
+      raise ArgumentError.new("Method #{method_name} doesn't exist on #{object.class.name}") unless object.respond_to?(method_name)
+      file = object.method(method_name).source_location[0]
+      file.end_with?("active_model/attribute_methods.rb")
+    end
+
+    def automatic_changed_method_deprecated?
+      (defined?(::ActiveRecord) && ActiveRecord::VERSION::MAJOR >= 5 && ActiveRecord::VERSION::MINOR >= 1) ||
+          (defined?(::ActiveRecord) && ActiveRecord::VERSION::MAJOR > 5)
+    end
   end
 
   # these are the instance methods included
@@ -851,15 +1017,15 @@ module AlgoliaSearch
 
     def algolia_enqueue_remove_from_index!(synchronous)
       if algoliasearch_options[:enqueue]
-        algoliasearch_options[:enqueue].call(self, true)
+        algoliasearch_options[:enqueue].call(self, true) unless self.class.send(:algolia_indexing_disabled?, algoliasearch_options)
       else
-        algolia_remove_from_index!(synchronous)
+        algolia_remove_from_index!(synchronous || algolia_synchronous?)
       end
     end
 
     def algolia_enqueue_index!(synchronous)
       if algoliasearch_options[:enqueue]
-        algoliasearch_options[:enqueue].call(self, false)
+        algoliasearch_options[:enqueue].call(self, false) unless self.class.send(:algolia_indexing_disabled?, algoliasearch_options)
       else
         algolia_index!(synchronous)
       end
@@ -880,7 +1046,9 @@ module AlgoliaSearch
     end
 
     def algolia_mark_must_reindex
-      @algolia_must_reindex =
+      # 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)
          new? || self.class.algolia_must_reindex?(self)
        else