jekyll-algolia 1.0.0 → 1.6.0

data/lib/jekyll/algolia/extractor.rb

@@ -11,13 +11,15 @@ module Jekyll
       # Public: Extract records from the file
       #
       # file - The Jekyll file to process
-      # TOTEST
       def self.run(file)
-        # Getting all hierarchical nodes from the HTML input
+        # Getting all nodes from the HTML input
         raw_records = extract_raw_records(file.content)
         # Getting file metadata
         shared_metadata = FileBrowser.metadata(file)
 
+        # If no content, we still index the metadata
+        raw_records = [shared_metadata] if raw_records.empty?
+
         # Building the list of records
         records = []
         raw_records.map do |record|
@@ -31,7 +33,7 @@ module Jekyll
           # Apply custom user-defined hooks
           # Users can return `nil` from the hook to signal we should not index
           # such a record
-          record = Hooks.apply_each(record, node)
+          record = Hooks.apply_each(record, node, Jekyll::Algolia.site)
           next if record.nil?
 
           records << record
@@ -48,16 +50,24 @@ module Jekyll
       end
 
       # Public: Extract raw records from the file, including content for each
-      # node to index and hierarchy
+      # node and its headings
       #
       # content - The HTML content to parse
       def self.extract_raw_records(content)
-        AlgoliaHTMLExtractor.run(
+        records = AlgoliaHTMLExtractor.run(
           content,
           options: {
-            css_selector: Configurator.algolia('nodes_to_index')
+            css_selector: Configurator.algolia('nodes_to_index'),
+            tags_to_exclude: 'script,style,iframe'
           }
         )
+        # We remove objectIDs, as the will be added at the very end, after all
+        # the hooks and shrinkage
+        records.each do |record|
+          record.delete(:objectID)
+        end
+
+        records
       end
     end
   end

data/lib/jekyll/algolia/file_browser.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'algolia_html_extractor'
+require 'pathname'
+require 'time'
 
 module Jekyll
   module Algolia
@@ -13,6 +15,50 @@ module Jekyll
     module FileBrowser
       include Jekyll::Algolia
 
+      # Public: Return the absolute path of a Jekyll file
+      #
+      # file - The Jekyll file to inspect
+      def self.absolute_path(filepath)
+        pathname = Pathname.new(filepath)
+        return pathname.cleanpath.to_s if pathname.absolute?
+
+        File.expand_path(File.join(Configurator.get('source'), filepath))
+      end
+
+      # Public: Return the path of a Jekyll file relative to the Jekyll source
+      #
+      # file - The Jekyll file to inspect
+      def self.relative_path(filepath)
+        pathname = Pathname.new(filepath)
+        config_source = Configurator.get('source') || ''
+        jekyll_source = Pathname.new(File.expand_path(config_source))
+
+        # Removing any starting ./
+        if pathname.relative?
+          fullpath = File.expand_path(File.join(jekyll_source, pathname))
+          return fullpath.gsub(%r{^#{jekyll_source}/}, '')
+        end
+
+        pathname.relative_path_from(jekyll_source).cleanpath.to_s
+      end
+
+      # Public: Check if the file should be indexed
+      #
+      # file - The Jekyll file
+      #
+      # There are many reasons a file should not be indexed. We need to exclude
+      # all the static assets, only keep the actual content.
+      def self.indexable?(file)
+        return false if static_file?(file)
+        return false if is_404?(file)
+        return false if redirect?(file)
+        return false unless allowed_extension?(file)
+        return false if excluded_from_config?(file)
+        return false if excluded_from_hook?(file)
+
+        true
+      end
+
       # Public: Check if the specified file is a static Jekyll asset
       #
       # file - The Jekyll file
@@ -30,20 +76,27 @@ module Jekyll
       # pages. We don't want to index those.
       # Source: https://help.github.com/articles/creating-a-custom-404-page-for-your-github-pages-site/
       #
-      # rubocop:disable Naming/PredicateName
       def self.is_404?(file)
-        File.basename(file.path, File.extname(file.path)) == '404'
+        ['404.md', '404.html'].include?(File.basename(file.path))
       end
-      # rubocop:enable Naming/PredicateName
 
-      # Public: Check if the page is a pagination page
+      # Public: Check if the file is redirect page
       #
       # file - The Jekyll file
       #
-      # `jekyll-paginate` automatically creates pages to paginate through posts.
-      # We don't want to index those
-      def self.pagination_page?(file)
-        Utils.match?(file.path, %r{page([0-9]*)/index\.html$})
+      # Plugins like jekyll-redirect-from add dynamic pages that only contain
+      # an HTML meta refresh. We need to exclude those files from indexing.
+      # https://github.com/jekyll/jekyll-redirect-from
+      def self.redirect?(file)
+        # When using redirect_from, jekyll-redirect-from creates a page named
+        # `redirect.html`
+        return true if file.respond_to?(:name) && file.name == 'redirect.html'
+        # When using redirect_to, it sets the layout to `redirect`
+        if file.respond_to?(:data) && file.data['layout'] == 'redirect'
+          return true
+        end
+
+        false
       end
 
       # Public: Check if the file has one of the allowed extensions
@@ -55,36 +108,24 @@ module Jekyll
       # and raw HTML files but this list can be extended using the
       # `extensions_to_index` config option.
       def self.allowed_extension?(file)
-        extensions = Configurator.algolia('extensions_to_index')
+        extensions = Configurator.extensions_to_index
         extname = File.extname(file.path)[1..-1]
         extensions.include?(extname)
       end
 
-      # Public: Check if the file has been excluded by the user
-      #
-      # file - The Jekyll file
-      #
-      # Files can be excluded either by setting the `files_to_exclude` option,
-      # or by defining a custom hook
-      def self.excluded_by_user?(file)
-        excluded_from_config?(file) || excluded_from_hook?(file)
-      end
-
       # Public: Check if the file has been excluded by `files_to_exclude`
       #
       # file - The Jekyll file
       def self.excluded_from_config?(file)
         excluded_patterns = Configurator.algolia('files_to_exclude')
-        excluded_files = []
+        jekyll_source = Configurator.get('source')
+        path = absolute_path(file.path)
 
-        # Transform the glob patterns into a real list of files
-        Dir.chdir(Configurator.get('source')) do
-          excluded_patterns.each do |pattern|
-            excluded_files += Dir.glob(pattern)
-          end
+        excluded_patterns.each do |pattern|
+          pattern = File.expand_path(File.join(jekyll_source, pattern))
+          return true if File.fnmatch(pattern, path, File::FNM_PATHNAME)
         end
-
-        excluded_files.include?(file.path)
+        false
       end
 
       # Public: Check if the file has been excluded by running a custom user
@@ -95,34 +136,6 @@ module Jekyll
         Hooks.should_be_excluded?(file.path)
       end
 
-      # Public: Return the path to the original file, relative from the Jekyll
-      # source
-      #
-      # file - The Jekyll file
-      #
-      # Pages have their .path property relative to the source, but collections
-      # (including posts) have an absolute file path.
-      def self.path_from_root(file)
-        source = Configurator.get('source')
-        file.path.gsub(%r{^#{source}/}, '')
-      end
-
-      # Public: Check if the file should be indexed
-      #
-      # file - The Jekyll file
-      #
-      # There are many reasons a file should not be indexed. We need to exclude
-      # all the static assets, only keep the actual content.
-      def self.indexable?(file)
-        return false if static_file?(file)
-        return false if is_404?(file)
-        return false if pagination_page?(file)
-        return false unless allowed_extension?(file)
-        return false if excluded_by_user?(file)
-
-        true
-      end
-
       # Public: Return a hash of all the file metadata
       #
       # file - The Jekyll file
@@ -134,6 +147,8 @@ module Jekyll
         raw_data = raw_data(file)
         specific_data = {
           collection: collection(file),
+          tags: tags(file),
+          categories: categories(file),
           date: date(file),
           excerpt_html: excerpt_html(file),
           excerpt_text: excerpt_text(file),
@@ -164,10 +179,16 @@ module Jekyll
         data.each_key do |key|
           data.delete(key) if respond_to?(key)
         end
-
-        # Also delete keys we manually handle
         data.delete('excerpt')
 
+        # Delete other keys added by Jekyll that are not in the front-matter and
+        # not needed for search
+        data.delete('draft')
+        data.delete('ext')
+
+        # Convert all values to a version that can be serialized to JSON
+        data = Utils.jsonify(data)
+
         # Convert all keys to symbols
         data = Utils.keys_to_symbols(data)
 
@@ -196,29 +217,102 @@ module Jekyll
         file.url
       end
 
+      # Public: Returns the list of tags of a file, defaults to an empty array
+      #
+      # file - The Jekyll file
+      def self.tags(file)
+        file.data['tags'] || []
+      end
+
+      # Public: Returns the list of tags of a file, defaults to an empty array
+      #
+      # file - The Jekyll file
+      def self.categories(file)
+        file.data['categories'] || []
+      end
+
       # Public: Returns a timestamp of the file date
       #
       # file - The Jekyll file
       #
-      # All collections have a date, either taken from the filename, or the
-      # `date` config set in the front-matter. Even if none is set, the current
-      # date is taken by default.
+      # Posts have their date coming from the filepath, or the front-matter.
+      # Pages and other collection items can only have a date set in
+      # front-matter.
       def self.date(file)
-        date = file.data['date']
+        # Collections get their date from .date, while pages read it from .data.
+        # Jekyll by default will set the date of collection to the current date,
+        # but we monkey-patched that so it returns nil for collection items
+        date = if file.respond_to?(:date)
+                 file.date
+               else
+                 file.data['date']
+               end
+
         return nil if date.nil?
 
-        date.to_i
+        # If date is a string, we try to parse it
+        if date.is_a? String
+          begin
+            date = Time.parse(date)
+          rescue StandardError
+            return nil
+          end
+        end
+
+        date.to_time.to_i
       end
 
-      # Public: Returns the HTML version of the excerpt
+      # Public: Returns the raw excerpt of a file, directly as returned by
+      # Jekyll. Swallow any error that could occur when reading.
       #
       # file - The Jekyll file
       #
-      # Only collections (including posts) have an excerpt. Pages don't.
+      # This might throw an exception if the excerpt is invalid. We also
+      # silence all logger output as Jekyll is quite verbose and will display
+      # the potential Liquid error in the terminal, even if we catch the actual
+      # error.
+      def self.excerpt_raw(file)
+        Logger.silent do
+          return file.data['excerpt'].to_s.strip
+        end
+      rescue StandardError
+        nil
+      end
+
+      # Public: Return true if the Jekyll default excerpt should be used for
+      # this file
+      #
+      # file - The Jekyll file
+      #
+      # Most of the time, we'll use our own excerpt (the first matching
+      # element), but in some cases, we'll fallback to Jekyll's default excerpt
+      # if it seems to be what the user wants
+      def self.use_default_excerpt?(file)
+        # Only posts can have excerpt
+        return false unless type(file) == 'post'
+
+        # User defined their own separator in the config
+        custom_separator = file.excerpt_separator.to_s.strip
+        return false if custom_separator.empty?
+
+        # This specific post contains this separator
+        file.content.include?(custom_separator)
+      end
+
+      # Public: Returns the HTML version of the excerpt
+      #
+      # file - The Jekyll file
       def self.excerpt_html(file)
-        excerpt = file.data['excerpt']
-        return nil if excerpt.nil?
-        excerpt.to_s.tr("\n", ' ').strip
+        # If it's a post with a custom separator for the excerpt, we honor it
+        return excerpt_raw(file) if use_default_excerpt?(file)
+
+        # Otherwise we take the first matching node
+        html = file.content
+        selector = Configurator.algolia('nodes_to_index')
+        first_node = Nokogiri::HTML(html).css(selector).first
+        return nil if first_node.nil?
+
+        first_node.to_s
       end
 
       # Public: Returns the text version of the excerpt
@@ -228,7 +322,6 @@ module Jekyll
       # Only collections (including posts) have an excerpt. Pages don't.
       def self.excerpt_text(file)
         html = excerpt_html(file)
-        return nil if html.nil?
         Utils.html_to_text(html)
       end
 

data/lib/jekyll/algolia/hooks.rb

@@ -11,8 +11,15 @@ module Jekyll
       #
       # record - The hash of the record to be pushed
       # node - The Nokogiri node of the element
-      def self.apply_each(record, node)
-        before_indexing_each(record, node)
+      def self.apply_each(record, node, context)
+        case method(:before_indexing_each).arity
+        when 1
+          before_indexing_each(record)
+        when 2
+          before_indexing_each(record, node)
+        else
+          before_indexing_each(record, node, context)
+        end
       end
 
       # Public: Apply the before_indexing_all hook to all records.
@@ -21,8 +28,13 @@ module Jekyll
       # as they can be mocked in tests.
       #
       # records - The list of all records to be indexed
-      def self.apply_all(records)
-        before_indexing_all(records)
+      def self.apply_all(records, context)
+        case method(:before_indexing_all).arity
+        when 1
+          before_indexing_all(records)
+        else
+          before_indexing_all(records, context)
+        end
       end
 
       # Public: Check if the file should be indexed or not
@@ -47,7 +59,7 @@ module Jekyll
       # information from the HTML node.
       #
       # Users can return nil to signal that the record should not be indexed
-      def self.before_indexing_each(record, _node)
+      def self.before_indexing_each(record, _node, _context)
         record
       end
 
@@ -59,7 +71,7 @@ module Jekyll
       # Users can modify the full list from here. It might provide an easier
       # interface than `hook_before_indexing_each` when knowing the full context
       # is necessary
-      def self.before_indexing_all(records)
+      def self.before_indexing_all(records, _context)
         records
       end
     end

data/lib/jekyll/algolia/indexer.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require 'algoliasearch'
+require 'yaml'
+require 'algolia_html_extractor'
 
+# rubocop:disable Metrics/ModuleLength
 module Jekyll
   module Algolia
     # Module to push records to Algolia and configure the index
@@ -9,16 +12,60 @@ module Jekyll
       include Jekyll::Algolia
 
       # Public: Init the module
-      #
-      # This call will instanciate the Algolia API client, set the custom
-      # User Agent and give an easy access to the main index
       def self.init
         ::Algolia.init(
           application_id: Configurator.application_id,
           api_key: Configurator.api_key
         )
+        index_name = Configurator.index_name
+        @index = ::Algolia::Index.new(index_name)
+        index_object_ids_name = Configurator.index_object_ids_name
+        @index_object_ids = ::Algolia::Index.new(index_object_ids_name)
 
         set_user_agent
+
+        self
+      end
+
+      # Public: Returns the Algolia index object
+      def self.index
+        @index
+      end
+
+      # Public: Returns the Algolia index used to store object ids
+      def self.index_object_ids
+        @index_object_ids
+      end
+
+      # Public: Check if an index exists
+      #
+      # index - Index to check
+      #
+      # Note: there is no API endpoint to do that, so we try to get the settings
+      # instead, which will fail if the index does not exist
+      def self.index_exist?(index)
+        index.get_settings
+        true
+      rescue StandardError
+        false
+      end
+
+      # Public: Get the number of records in an index
+      #
+      # index - Index to check
+      #
+      # Note: We'll do an empty query search, to match everything, but we'll
+      # only return the objectID and one element, to get the shortest response
+      # possible. It will still contain the nbHits
+      def self.record_count(index)
+        index.search(
+          '',
+          attributesToRetrieve: 'objectID',
+          distinct: false,
+          hitsPerPage: 1
+        )['nbHits']
+      rescue StandardError
+        0
       end
 
       # Public: Set the User-Agent to send to the API
@@ -38,74 +85,75 @@ module Jekyll
         ::Algolia.set_extra_header('User-Agent', user_agent)
       end
 
-      # Public: Returns an Algolia Index object from an index name
+      # Public: Get an array of all object IDs stored in the main index
       #
-      # index_name - String name of the index
-      def self.index(index_name)
-        ::Algolia::Index.new(index_name)
-      end
+      # Note: As this will be slow (grabbing them 1000 at a time), we display
+      # a progress bar.
+      def self.remote_object_ids_from_main_index
+        Logger.verbose("I:Inspecting existing records in index #{index.name}")
 
-      # Public: Update records of the specified index
-      #
-      # index - Algolia Index to update
-      # records - Array of records to update
-      #
-      # New records will be automatically added. Technically existing records
-      # should be updated but this case should never happen as changing a record
-      # content will change its objectID as well.
-      #
-      # Does nothing in dry run mode
-      def self.update_records(index, records)
-        batch_size = Configurator.algolia('indexing_batch_size')
-        records.each_slice(batch_size) do |batch|
-          Logger.log("I:Pushing #{batch.size} records")
-          next if Configurator.dry_run?
-          begin
-            index.add_objects!(batch)
-          rescue StandardError => error
-            ErrorHandler.stop(error, records: records)
-          end
-        end
-      end
-
-      # Public: Delete records whose objectIDs are passed
-      #
-      # index - Algolia Index to target
-      # ids - Array of objectIDs to delete
-      #
-      # Does nothing in dry run mode
-      def self.delete_records_by_id(index, ids)
-        return if ids.empty?
-        Logger.log("I:Deleting #{ids.length} records")
-        return if Configurator.dry_run?
+        list = []
 
+        # As it might take some time, we display a progress bar
+        progress_bar = ProgressBar.create(
+          total: record_count(index),
+          format: 'Inspecting existing records (%j%%) |%B|'
+        )
         begin
-          index.delete_objects!(ids)
-        rescue StandardError => error
-          ErrorHandler.stop(error)
+          index.browse(
+            attributesToRetrieve: 'objectID',
+            hitsPerPage: 1000
+          ) do |hit|
+            list << hit['objectID']
+            progress_bar.increment
+          end
+        rescue StandardError
+          return []
         end
+
+        list.sort
       end
 
-      # Public: Returns an array of all the objectIDs in the index
-      #
-      # index - Algolia Index to target
+      # Public: Get an array of all the object ids, stored in a dedicated
+      # index
       #
-      # The returned array is sorted. It won't have any impact on the way it is
-      # processed, but makes debugging easier when comparing arrays is needed.
-      def self.remote_object_ids(index)
+      # Note: This will be very fast. Each record contain 100 object id, so it
+      # will fit in one call each time.
+      def self.remote_object_ids_from_dedicated_index
         list = []
         begin
-          index.browse(attributesToRetrieve: 'objectID') do |hit|
-            list << hit['objectID']
+          index_object_ids.browse(
+            attributesToRetrieve: 'content',
+            hitsPerPage: 1000
+          ) do |hit|
+            list += hit['content']
           end
         rescue StandardError
-          # The index might not exist if it's the first time we use the plugin
-          # so we'll consider that it means there are no records there
           return []
         end
+
         list.sort
       end
 
+      # Public: Returns an array of all the objectIDs in the index
+      #
+      # Note: We use a dedicated index to store the objectIDs for faster
+      # browsing, but if the index does not exist we read the main index.
+      def self.remote_object_ids
+        Logger.log('I:Getting list of existing records')
+
+        # Main index empty, the list is empty no matter what (we don't use the
+        # dedicated index in that case)
+        return [] if record_count(index).zero?
+
+        # Fast version, using the dedicated index
+        has_object_id_index = index_exist?(index_object_ids)
+        return remote_object_ids_from_dedicated_index if has_object_id_index
+
+        # Slow version, browsing the full index
+        remote_object_ids_from_main_index
+      end
+
       # Public: Returns an array of the local objectIDs
       #
       # records - Array of all local records
@@ -113,116 +161,211 @@ module Jekyll
         records.map { |record| record[:objectID] }.compact.sort
       end
 
-      # Public: Update settings of the index
+      # Public: Update records of the index
       #
-      # index - The Algolia Index
-      # settings - The hash of settings to pass to the index
+      # records - All records extracted from Jekyll
       #
+      # Note: All operations will be done in one batch, assuring an atomic
+      # update
       # Does nothing in dry run mode
-      def self.update_settings(index, settings)
-        Logger.verbose('I:Updating settings')
-        return if Configurator.dry_run?
-        begin
-          index.set_settings(settings)
-        rescue StandardError => error
-          ErrorHandler.stop(error, settings: settings)
+      def self.update_records(records)
+        # Getting list of objectID in remote and locally
+        remote_ids = remote_object_ids
+        local_ids = local_object_ids(records)
+
+        # Making a diff, to see what to add and what to delete
+        ids_to_delete = remote_ids - local_ids
+        ids_to_add = local_ids - remote_ids
+
+        # What changes should we do to the indexes?
+        has_records_to_update = !ids_to_delete.empty? || !ids_to_add.empty?
+        has_object_id_index = index_exist?(index_object_ids)
+
+        # Stop if nothing to change
+        if !has_records_to_update && has_object_id_index
+          Logger.log('I:Content is already up to date.')
+          return
+        end
+
+        # We group all operations into one batch
+        operations = []
+
+        # We update records only if there are records to update
+        if has_records_to_update
+          Logger.log("I:Updating records in index #{index.name}...")
+          Logger.log("I:Records to delete: #{ids_to_delete.length}")
+          Logger.log("I:Records to add:    #{ids_to_add.length}")
+
+          # Transforming ids into real records to add
+          records_by_id = Hash[records.map { |r| [r[:objectID], r] }]
+          records_to_add = ids_to_add.map { |id| records_by_id[id] }
+
+          # Deletion operations come first, to avoid hitting an overquota too
+          # soon if it can be avoided
+          ids_to_delete.each do |object_id|
+            operations << {
+              action: 'deleteObject', indexName: index.name,
+              body: { objectID: object_id }
+            }
+          end
+          # Then we add the new records
+          operations += records_to_add.map do |new_record|
+            { action: 'addObject', indexName: index.name, body: new_record }
+          end
+        end
+
+        # We update the dedicated index everytime we update records, but we also
+        # create it if it does not exist
+        should_update_object_id_index = has_records_to_update ||
+                                        !has_object_id_index
+        if should_update_object_id_index
+          operations << { action: 'clear', indexName: index_object_ids.name }
+          local_ids.each_slice(100).each do |ids|
+            operations << {
+              action: 'addObject', indexName: index_object_ids.name,
+              body: { content: ids }
+            }
+          end
         end
+
+        execute_operations(operations)
       end
 
-      # Public: Index content following the `diff` indexing mode
+      # Public: Execute a serie of operations in a batch
       #
-      # records - Array of local records
+      # operations - Operations to batch
       #
-      # The `diff` indexing mode will only push new content to the index and
-      # remove old content from it. It won't touch records that haven't been
-      # updated. It will be a bit slower as it will first need to get the list
-      # of all records in the index, but it will consume less operations.
-      def self.run_diff_mode(records)
-        index = index(Configurator.index_name)
-
-        # Update settings
-        update_settings(index, Configurator.settings)
+      # Note: Will split the batch in several calls if too big, and will display
+      # a progress bar if this happens
+      def self.execute_operations(operations)
+        return if Configurator.dry_run?
+        return if operations.empty?
 
-        # Getting list of objectID in remote and locally
-        remote_ids = remote_object_ids(index)
-        local_ids = local_object_ids(records)
+        # Run the batches in slices if they are too large
+        batch_size = Configurator.algolia('indexing_batch_size')
+        slices = operations.each_slice(batch_size).to_a
 
-        old_records_ids = remote_ids - local_ids
-        new_records_ids = local_ids - remote_ids
-        if old_records_ids.empty? && new_records_ids.empty?
-          Logger.log('I:Nothing to index. Your content is already up to date.')
-          return
+        should_have_progress_bar = (slices.length > 1)
+        if should_have_progress_bar
+          progress_bar = ProgressBar.create(
+            total: slices.length,
+            format: 'Updating index (%j%%) |%B|'
+          )
         end
 
-        Logger.log('I:Pushing records to Algolia...')
-
-        # Delete remote records that are no longer available locally
-        delete_records_by_id(index, old_records_ids)
+        slices.each do |slice|
+          begin
+            ::Algolia.batch!(slice)
 
-        # Add only records that are not yet already in the remote
-        new_records = records.select do |record|
-          new_records_ids.include?(record[:objectID])
+            progress_bar.increment if should_have_progress_bar
+          rescue StandardError => e
+            ErrorHandler.stop(e, operations: slice)
+          end
         end
-        update_records(index, new_records)
+      end
 
-        Logger.log('I:✔ Indexing complete')
+      # Public: Get a unique settingID for the current settings
+      #
+      # The settingID is generated as a hash of the current settings. As it will
+      # be stored in the userData key of the resulting config, we exclude that
+      # key from the hashing.
+      def self.local_setting_id
+        settings = Configurator.settings
+        settings.delete('userData')
+        AlgoliaHTMLExtractor.uuid(settings)
       end
 
       # Public: Get the settings of the remote index
       #
-      # index - The Algolia Index
-      def self.remote_settings(index)
+      # In case the index is not accessible, it will return nil
+      def self.remote_settings
         index.get_settings
-      rescue StandardError => error
-        ErrorHandler.stop(error)
+      rescue StandardError
+        nil
       end
 
-      # Public: Rename an index
+      # Public: Smart update of the settings of the index
       #
-      # old_name - Current name of the index
-      # new_name - New name of the index
+      # This will first compare the settings about to be pushed with the
+      # settings already pushed. It will compare userData.settingID for that.
+      # If the settingID is the same, we don't push as this won't change
+      # anything. We will still check if the remote config seem to have been
+      # manually altered though, and warn the user that this is not the
+      # preferred way of doing so.
       #
-      # Does nothing in dry run mode
-      def self.rename_index(old_name, new_name)
-        Logger.verbose("I:Renaming `#{old_name}` to `#{new_name}`")
-        return if Configurator.dry_run?
-        begin
-          ::Algolia.move_index(old_name, new_name)
-        rescue StandardError => error
-          ErrorHandler.stop(error, new_name: new_name)
-        end
-      end
+      # If the settingID are not matching, it means our config is different, so
+      # we push it, overriding the settingID for next push.
+      def self.update_settings
+        return if Configurator.settings.empty?
+
+        current_remote_settings = remote_settings || {}
+        remote_setting_id = current_remote_settings.dig('userData', 'settingID')
+
+        settings = Configurator.settings
+        setting_id = local_setting_id
+
+        are_settings_forced = Configurator.force_settings?
+
+        # The config we're about to push is the same we pushed previously. We
+        # won't push again.
+        if setting_id == remote_setting_id && !are_settings_forced
+          Logger.log('I:Settings are already up to date.')
+          # Check if remote config has been changed outside of the plugin, so we
+          # can warn users that they should not alter their config from outside
+          # of the plugin.
+          current_remote_settings.delete('userData')
+          changed_keys = Utils.diff_keys(settings, current_remote_settings)
+          unless changed_keys.nil?
+            warn_of_manual_dashboard_editing(changed_keys)
+          end
 
-      # Public: Index content following the `atomic` indexing mode
-      #
-      # records - Array of records to push
-      #
-      # The `atomic` indexing mode will push all records to a brand new index,
-      # configure it, and then overwrite the previous index with this new one.
-      # For the end-user, it will make all the changes in one go, making sure
-      # people are always searching into a fully configured index. It will
-      # consume more operations, but will never leave the index in a transient
-      # state.
-      def self.run_atomic_mode(records)
-        index_name = Configurator.index_name
-        index = index(index_name)
-        index_tmp_name = "#{Configurator.index_name}_tmp"
-        index_tmp = index(index_tmp_name)
+          return
+        end
 
-        Logger.verbose("I:Using `#{index_tmp_name}` as temporary index")
+        # Settings have changed, we push them
+        settings['userData'] = {
+          'settingID' => setting_id,
+          'pluginVersion' => VERSION
+        }
 
-        # Copying original settings to the new index
-        remote_settings = remote_settings(index)
-        new_settings = remote_settings.merge(Configurator.settings)
-        update_settings(index_tmp, new_settings)
+        Logger.log("I:Updating settings of index #{index.name}")
+        return if Configurator.dry_run?
 
-        # Pushing everthing to a brand new index
-        update_records(index_tmp, records)
+        set_settings(settings)
+      end
 
-        # Renaming the new index in place of the old
-        rename_index(index_tmp_name, index_name)
+      # Public: Set new settings to an index
+      #
+      # Will dispatch to the error handler if it fails
+      # rubocop:disable Naming/AccessorMethodName
+      def self.set_settings(settings)
+        index.set_settings!(settings)
+      rescue StandardError => e
+        ErrorHandler.stop(e, settings: settings)
+      end
+      # rubocop:enable Naming/AccessorMethodName
 
-        Logger.log('I:✔ Indexing complete')
+      # Public: Warn users that they have some settings manually configured in
+      # their dashboard
+      #
+      # When users change some settings in their dashboard, those settings might
+      # get overwritten by the plugin. We can't prevent that, but we can warn
+      # them when we detect they changed something.
+      def self.warn_of_manual_dashboard_editing(changed_keys)
+        # Transform the hash into readable YAML
+        yaml_lines = changed_keys
+                     .to_yaml(indentation: 2)
+                     .split("\n")[1..-1]
+        yaml_lines.map! do |line|
+          line = line.gsub(/^ */) { |spaces| ' ' * spaces.length }
+          line = line.gsub('- ', '  - ')
+          "W:    #{line}"
+        end
+        Logger.known_message(
+          'settings_manually_edited',
+          settings: yaml_lines.join("\n"),
+          index_name: Configurator.index_name
+        )
       end
 
       # Public: Push all records to Algolia and configure the index
@@ -231,10 +374,8 @@ module Jekyll
       def self.run(records)
         init
 
-        record_count = records.length
-
         # Indexing zero record is surely a misconfiguration
-        if record_count.zero?
+        if records.length.zero?
           files_to_exclude = Configurator.algolia('files_to_exclude').join(', ')
           Logger.known_message(
             'no_records_found',
@@ -244,15 +385,12 @@ module Jekyll
           exit 1
         end
 
-        indexing_mode = Configurator.indexing_mode
-        Logger.verbose("I:Indexing mode: #{indexing_mode}")
-        case indexing_mode
-        when 'diff'
-          run_diff_mode(records)
-        when 'atomic'
-          run_atomic_mode(records)
-        end
+        update_settings
+        update_records(records)
+
+        Logger.log('I:✔ Indexing complete')
       end
     end
   end
 end
+# rubocop:enable Metrics/ModuleLength