chewy 5.1.0 → 7.2.7

data/lib/chewy/index/import/bulk_builder.rb

@@ -0,0 +1,311 @@
+module Chewy
+  class Index
+    module Import
+      # This class purpose is to build ES client-acceptable bulk
+      # request body from the passed objects for index and deletion.
+      # It handles parent-child relationships as well by fetching
+      # existing documents from ES and database, taking their join field values and
+      # using it in the bulk body.
+      # If fields are passed - it creates partial update entries except for
+      # the cases when the type has parent and parent_id has been changed.
+      class BulkBuilder
+        # @param index [Chewy::Index] desired index
+        # @param to_index [Array<Object>] objects to index
+        # @param delete [Array<Object>] objects or ids to delete
+        # @param fields [Array<Symbol, String>] and array of fields for documents update
+        def initialize(index, to_index: [], delete: [], fields: [])
+          @index = index
+          @to_index = to_index
+          @delete = delete
+          @fields = fields.map!(&:to_sym)
+        end
+
+        # Returns ES API-ready bulk requiest body.
+        # @see https://github.com/elastic/elasticsearch-ruby/blob/master/elasticsearch-api/lib/elasticsearch/api/actions/bulk.rb
+        # @return [Array<Hash>] bulk body
+        def bulk_body
+          populate_cache
+
+          @bulk_body ||= @to_index.flat_map(&method(:index_entry)).concat(
+            @delete.flat_map(&method(:delete_entry))
+          ).uniq
+        end
+
+        # The only purpose of this method is to cache document ids for
+        # all the passed object for index to avoid ids recalculation.
+        #
+        # @return [Hash[String => Object]] an ids-objects index hash
+        def index_objects_by_id
+          @index_objects_by_id ||= index_object_ids.invert.stringify_keys!
+        end
+
+      private
+
+        def crutches_for_index
+          @crutches_for_index ||= Chewy::Index::Crutch::Crutches.new @index, @to_index
+        end
+
+        def index_entry(object)
+          entry = {}
+          entry[:_id] = index_object_ids[object] if index_object_ids[object]
+          entry[:routing] = routing(object) if join_field?
+
+          parent = cache(entry[:_id])
+          data = data_for(object) if parent.present?
+          if parent.present? && parent_changed?(data, parent)
+            reindex_entries(object, data) + reindex_descendants(object)
+          elsif @fields.present?
+            return [] unless entry[:_id]
+
+            entry[:data] = {doc: data_for(object, fields: @fields)}
+            [{update: entry}]
+          else
+            entry[:data] = data || data_for(object)
+            [{index: entry}]
+          end
+        end
+
+        def reindex_entries(object, data, root: object)
+          entry = {}
+          entry[:_id] = index_object_ids[object] || entry_id(object)
+          entry[:data] = data
+          entry[:routing] = routing(root) || routing(object) if join_field?
+          delete = delete_single_entry(object, root: root).first
+          index = {index: entry}
+          [delete, index]
+        end
+
+        def reindex_descendants(root)
+          descendants = load_descendants(root)
+          crutches = Chewy::Index::Crutch::Crutches.new @index, [root, *descendants]
+          descendants.flat_map do |object|
+            reindex_entries(
+              object,
+              data_for(object, crutches: crutches),
+              root: root
+            )
+          end
+        end
+
+        def delete_entry(object)
+          delete_single_entry(object)
+        end
+
+        def delete_single_entry(object, root: object)
+          entry = {}
+          entry[:_id] = entry_id(object)
+          entry[:_id] ||= object.as_json
+
+          return [] if entry[:_id].blank?
+
+          if join_field?
+            cached_parent = cache(entry[:_id])
+            entry_parent_id =
+              if cached_parent
+                cached_parent[:parent_id]
+              else
+                find_parent_id(object)
+              end
+
+            entry[:routing] = existing_routing(root.try(:id)) || existing_routing(object.id)
+            entry[:parent] = entry_parent_id if entry_parent_id
+          end
+
+          [{delete: entry}]
+        end
+
+        def load_descendants(root)
+          root_type = join_field_type(root)
+          return [] unless root_type
+
+          descendant_ids = []
+          grouped_parents = {root_type => [root.id]}
+          # iteratively fetch all the descendants (with grouped_parents as a queue for next iteration)
+          until grouped_parents.empty?
+            children_data = grouped_parents.flat_map do |parent_type, parent_ids|
+              @index.query(
+                has_parent: {
+                  parent_type: parent_type,
+                  # ignore_unmapped to avoid error for the leaves of the tree
+                  # (types without children)
+                  ignore_unmapped: true,
+                  query: {ids: {values: parent_ids}}
+                }
+              ).pluck(:_id, join_field).map { |id, join| [join['name'], id] }
+            end
+            descendant_ids |= children_data.map(&:last)
+
+            grouped_parents = {}
+            children_data.each do |name, id|
+              next unless name
+
+              grouped_parents[name] ||= []
+              grouped_parents[name] << id
+            end
+          end
+          # query the primary database to load the descentants' records
+          @index.adapter.load(descendant_ids, _index: @index.base_name, raw_import: @index._default_import_options[:raw_import])
+        end
+
+        def populate_cache
+          @cache = load_cache
+        end
+
+        def cache(id)
+          @cache[id.to_s]
+        end
+
+        def load_cache
+          return {} unless join_field?
+
+          @index
+            .filter(ids: {values: ids_for_cache})
+            .order('_doc')
+            .pluck(:_id, :_routing, join_field)
+            .map do |id, routing, join|
+              [
+                id,
+                {routing: routing, parent_id: join['parent']}
+              ]
+            end.to_h
+        end
+
+        def existing_routing(id)
+          # All objects needed here should be cached in #load_cache,
+          # if not, we return nil. In some cases we don't have existing routing cached,
+          # e.g. for loaded descendants
+          return unless cache(id)
+
+          cache(id)[:routing]
+        end
+
+        # Two types of ids:
+        # * of parents of the objects to be indexed
+        # * of objects to be deleted
+        def ids_for_cache
+          ids = @to_index.flat_map do |object|
+            [find_parent_id(object), object.id] if object.respond_to?(:id)
+          end
+          ids.concat(@delete.map do |object|
+            object.id if object.respond_to?(:id)
+          end)
+          ids.uniq.compact
+        end
+
+        def routing(object)
+          # filter out non-model objects, early return on object==nil
+          return unless object.respond_to?(:id)
+
+          parent_id = find_parent_id(object)
+          if parent_id
+            routing(index_objects_by_id[parent_id.to_s]) || existing_routing(parent_id)
+          else
+            object.id.to_s
+          end
+        end
+
+        def find_parent_id(object)
+          return unless object.respond_to?(:id)
+
+          join = data_for(object, fields: [join_field.to_sym])[join_field]
+          join['parent'] if join
+        end
+
+        def join_field
+          return @join_field if defined?(@join_field)
+
+          @join_field = find_join_field
+        end
+
+        def find_join_field
+          type_settings = @index.mappings_hash[:mappings]
+          return unless type_settings
+
+          properties = type_settings[:properties]
+          join_fields = properties.find { |_, options| options[:type] == :join }
+          return unless join_fields
+
+          join_fields.first.to_s
+        end
+
+        def join_field_type(object)
+          return unless join_field?
+
+          raw_object =
+            if @index._default_import_options[:raw_import]
+              @index._default_import_options[:raw_import].call(object.attributes)
+            else
+              object
+            end
+
+          join_field_value = data_for(
+            raw_object,
+            fields: [join_field.to_sym], # build only the field that is needed
+            crutches: Chewy::Index::Crutch::Crutches.new(@index, [raw_object])
+          )[join_field]
+
+          case join_field_value
+          when String
+            join_field_value
+          when Hash
+            join_field_value['name']
+          end
+        end
+
+        def join_field?
+          join_field && !join_field.empty?
+        end
+
+        def data_for(object, fields: [], crutches: crutches_for_index)
+          @index.compose(object, crutches, fields: fields)
+        end
+
+        def parent_changed?(data, old_parent)
+          return false unless old_parent
+          return false unless join_field?
+          return false unless @fields.include?(join_field.to_sym)
+          return false unless data.key?(join_field)
+
+          # The join field value can be a hash, e.g.:
+          # {"name": "child", "parent": "123"} for a child
+          # {"name": "parent"} for a parent
+          # but it can also be a string: (e.g. "parent") for a parent:
+          # https://www.elastic.co/guide/en/elasticsearch/reference/current/parent-join.html#parent-join
+          new_join_field_value = data[join_field]
+          if new_join_field_value.is_a? Hash
+            # If we have a hash in the join field,
+            # we're taking the `parent` field that holds the parent id.
+            new_parent_id = new_join_field_value['parent']
+            new_parent_id != old_parent[:parent_id]
+          else
+            # If there is a non-hash value (String or nil), it means that the join field is changed
+            # and the current object is no longer a child.
+            true
+          end
+        end
+
+        def entry_id(object)
+          if type_root.id
+            type_root.compose_id(object)
+          else
+            id = object.id if object.respond_to?(:id)
+            id ||= object[:id] || object['id'] if object.is_a?(Hash)
+            id = id.to_s if defined?(BSON) && id.is_a?(BSON::ObjectId)
+            id
+          end
+        end
+
+        def index_object_ids
+          @index_object_ids ||= @to_index.each_with_object({}) do |object, result|
+            id = entry_id(object)
+            result[object] = id if id.present?
+          end
+        end
+
+        def type_root
+          @type_root ||= @index.root
+        end
+      end
+    end
+  end
+end

data/lib/chewy/{type → index}/import/bulk_request.rb

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     module Import
       # Adds additional features to elasticsearch-api bulk method:
       # * supports Chewy index suffix if necessary;
@@ -10,12 +10,12 @@ module Chewy
       #
       # @see https://github.com/elastic/elasticsearch-ruby/blob/master/elasticsearch-api/lib/elasticsearch/api/actions/bulk.rb
       class BulkRequest
-        # @param type [Chewy::Type] a type for the request
+        # @param index [Chewy::Index] an index for the request
         # @param suffix [String] an index name optional suffix
         # @param bulk_size [Integer] bulk size in bytes
         # @param bulk_options [Hash] options passed to the elasticsearch-api bulk method
-        def initialize(type, suffix: nil, bulk_size: nil, **bulk_options)
-          @type = type
+        def initialize(index, suffix: nil, bulk_size: nil, **bulk_options)
+          @index = index
           @suffix = suffix
           @bulk_size = bulk_size - 1.kilobyte if bulk_size # 1 kilobyte for request header and newlines
           @bulk_options = bulk_options
@@ -33,7 +33,7 @@ module Chewy
           return [] if body.blank?
 
           request_bodies(body).each_with_object([]) do |request_body, results|
-            response = @type.client.bulk request_base.merge(body: request_body) if request_body.present?
+            response = @index.client.bulk(**request_base.merge(body: request_body)) if request_body.present?
 
             next unless response.try(:[], 'errors')
 
@@ -47,8 +47,7 @@ module Chewy
 
         def request_base
           @request_base ||= {
-            index: @type.index_name(suffix: @suffix),
-            type: @type.type_name
+            index: @index.index_name(suffix: @suffix)
           }.merge!(@bulk_options)
         end
 

data/lib/chewy/{type → index}/import/journal_builder.rb

@@ -1,24 +1,23 @@
 module Chewy
-  class Type
+  class Index
     module Import
       class JournalBuilder
-        def initialize(type, index: [], delete: [])
-          @type = type
+        def initialize(index, to_index: [], delete: [])
           @index = index
+          @to_index = to_index
           @delete = delete
         end
 
         def bulk_body
-          Chewy::Type::Import::BulkBuilder.new(
-            Chewy::Stash::Journal::Journal,
-            index: [
-              entries(:index, @index),
+          Chewy::Index::Import::BulkBuilder.new(
+            Chewy::Stash::Journal,
+            to_index: [
+              entries(:index, @to_index),
               entries(:delete, @delete)
             ].compact
           ).bulk_body.each do |item|
             item.values.first.merge!(
-              _index: Chewy::Stash::Journal.index_name,
-              _type: Chewy::Stash::Journal::Journal.type_name
+              _index: Chewy::Stash::Journal.index_name
             )
           end
         end
@@ -27,9 +26,9 @@ module Chewy
 
         def entries(action, objects)
           return unless objects.present?
+
           {
-            index_name: @type.index.derivable_name,
-            type_name: @type.type_name,
+            index_name: @index.derivable_name,
             action: action,
             references: identify(objects).map { |item| Base64.encode64(::Elasticsearch::API.serializer.dump(item)) },
             created_at: Time.now.utc
@@ -37,7 +36,7 @@ module Chewy
         end
 
         def identify(objects)
-          @type.adapter.identify(objects)
+          @index.adapter.identify(objects)
         end
       end
     end

data/lib/chewy/{type → index}/import/routine.rb

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     module Import
       # This class performs the import routine for the options and objects given.
       #
@@ -20,7 +20,7 @@ module Chewy
       # when the document doesn't exist only if `update_failover` option is true. In order to
       # restore, it indexes such an objects completely on the next iteration.
       #
-      # @see Chewy::Type::Import::ClassMethods#import
+      # @see Chewy::Index::Import::ClassMethods#import
       class Routine
         BULK_OPTIONS = %i[
           suffix bulk_size
@@ -33,18 +33,18 @@ module Chewy
           refresh: true,
           update_fields: [],
           update_failover: true,
-          batch_size: Chewy::Type::Adapter::Base::BATCH_SIZE
+          batch_size: Chewy::Index::Adapter::Base::BATCH_SIZE
         }.freeze
 
         attr_reader :options, :parallel_options, :errors, :stats, :leftovers
 
         # Basically, processes passed options, extracting bulk request specific options.
-        # @param type [Chewy::Type] chewy type
-        # @param options [Hash] import options, see {Chewy::Type::Import::ClassMethods#import}
-        def initialize(type, **options)
-          @type = type
+        # @param index [Chewy::Index] chewy index
+        # @param options [Hash] import options, see {Chewy::Index::Import::ClassMethods#import}
+        def initialize(index, **options)
+          @index = index
           @options = options
-          @options.reverse_merge!(@type._default_import_options)
+          @options.reverse_merge!(@index._default_import_options)
           @options.reverse_merge!(journal: Chewy.configuration[:journal])
           @options.reverse_merge!(DEFAULT_OPTIONS)
           @bulk_options = @options.slice(*BULK_OPTIONS)
@@ -61,27 +61,28 @@ module Chewy
           @leftovers = []
         end
 
-        # Creates the journal index and the type corresponding index if necessary.
+        # Creates the journal index and the corresponding index if necessary.
         # @return [Object] whatever
         def create_indexes!
           Chewy::Stash::Journal.create if @options[:journal]
           return if Chewy.configuration[:skip_index_creation_on_import]
-          @type.index.create!(@bulk_options.slice(:suffix)) unless @type.index.exists?
+
+          @index.create!(**@bulk_options.slice(:suffix)) unless @index.exists?
         end
 
-        # The main process method. Converts passed objects to thr bulk request body,
-        # appends journal entires, performs this request and handles errors performing
+        # The main process method. Converts passed objects to the bulk request body,
+        # appends journal entries, performs this request and handles errors performing
         # failover procedures if applicable.
         #
         # @param index [Array<Object>] any acceptable objects for indexing
         # @param delete [Array<Object>] any acceptable objects for deleting
         # @return [true, false] the result of the request, true if no errors
         def process(index: [], delete: [])
-          bulk_builder = BulkBuilder.new(@type, index: index, delete: delete, fields: @options[:update_fields])
+          bulk_builder = BulkBuilder.new(@index, to_index: index, delete: delete, fields: @options[:update_fields])
           bulk_body = bulk_builder.bulk_body
 
           if @options[:journal]
-            journal_builder = JournalBuilder.new(@type, index: index, delete: delete)
+            journal_builder = JournalBuilder.new(@index, to_index: index, delete: delete)
             bulk_body.concat(journal_builder.bulk_body)
           end
 
@@ -126,11 +127,11 @@ module Chewy
           errors_to_cleanup.each { |error| errors.delete(error) }
 
           failed_objects = index_objects_by_id.values_at(*failed_ids_for_reimport)
-          BulkBuilder.new(@type, index: failed_objects).bulk_body
+          BulkBuilder.new(@index, to_index: failed_objects).bulk_body
         end
 
         def bulk
-          @bulk ||= BulkRequest.new(@type, **@bulk_options)
+          @bulk ||= BulkRequest.new(@index, **@bulk_options)
         end
       end
     end

data/lib/chewy/{type → index}/import.rb

@@ -1,43 +1,42 @@
-require 'chewy/type/import/journal_builder'
-require 'chewy/type/import/bulk_builder'
-require 'chewy/type/import/bulk_request'
-require 'chewy/type/import/routine'
+require 'chewy/index/import/journal_builder'
+require 'chewy/index/import/bulk_builder'
+require 'chewy/index/import/bulk_request'
+require 'chewy/index/import/routine'
 
 module Chewy
-  class Type
+  class Index
     module Import
       extend ActiveSupport::Concern
 
-      IMPORT_WORKER = lambda do |type, options, total, ids, index|
-        ::Process.setproctitle("chewy [#{type}]: import data (#{index + 1}/#{total})")
-        routine = Routine.new(type, options)
-        type.adapter.import(*ids, routine.options) do |action_objects|
+      IMPORT_WORKER = lambda do |index, options, total, ids, iteration|
+        ::Process.setproctitle("chewy [#{index}]: import data (#{iteration + 1}/#{total})")
+        routine = Routine.new(index, **options)
+        index.adapter.import(*ids, routine.options) do |action_objects|
           routine.process(**action_objects)
         end
         {errors: routine.errors, import: routine.stats, leftovers: routine.leftovers}
       end
 
-      LEFTOVERS_WORKER = lambda do |type, options, total, body, index|
-        ::Process.setproctitle("chewy [#{type}]: import leftovers (#{index + 1}/#{total})")
-        routine = Routine.new(type, options)
+      LEFTOVERS_WORKER = lambda do |index, options, total, body, iteration|
+        ::Process.setproctitle("chewy [#{index}]: import leftovers (#{iteration + 1}/#{total})")
+        routine = Routine.new(index, **options)
         routine.perform_bulk(body)
         routine.errors
       end
 
       module ClassMethods
         # @!method import(*collection, **options)
-        # Basically, one of the main methods for type. Performs any objects import
-        # to the index for a specified type. Does all the objects handling routines.
+        # Basically, one of the main methods for an index. Performs any objects import
+        # to the index. Does all the objects handling routines.
         # Performs document import by utilizing bulk API. Bulk size and objects batch
         # size are controlled by the corresponding options.
         #
         # It accepts ORM/ODM objects, PORO, hashes, ids which are used by adapter to
-        # fetch objects from the source depenting on the used adapter. It destroys
-        # passed objects from the index if they are not in the default type scope
+        # fetch objects from the source depending on the used adapter. It destroys
+        # passed objects from the index if they are not in the default scope
         # or marked for destruction.
         #
-        # It handles parent-child relationships: if the object parent_id has been
-        # changed it destroys the object and recreates it from scratch.
+        # It handles parent-child relationships with a join field reindexing children when the parent is reindexed.
         #
         # Performs journaling if enabled: it stores all the ids of the imported
         # objects to a specialized index. It is possible to replay particular import
@@ -51,15 +50,15 @@ module Chewy
         #
         # Utilizes `ActiveSupport::Notifications`, so it is possible to get imported
         # objects later by listening to the `import_objects.chewy` queue. It is also
-        # possible to get the list of occured errors from the payload if something
+        # possible to get the list of occurred errors from the payload if something
         # went wrong.
         #
         # Import can also be run in parallel using the Parallel gem functionality.
         #
         # @example
-        #   UsersIndex::User.import(parallel: true) # imports everything in parallel with automatic workers number
-        #   UsersIndex::User.import(parallel: 3) # using 3 workers
-        #   UsersIndex::User.import(parallel: {in_threads: 10}) # in 10 threads
+        #   UsersIndex.import(parallel: true) # imports everything in parallel with automatic workers number
+        #   UsersIndex.import(parallel: 3) # using 3 workers
+        #   UsersIndex.import(parallel: {in_threads: 10}) # in 10 threads
         #
         # @see https://github.com/elastic/elasticsearch-ruby/blob/master/elasticsearch-api/lib/elasticsearch/api/actions/bulk.rb
         # @param collection [Array<Object>] and array or anything to import
@@ -67,12 +66,13 @@ module Chewy
         # @option options [String] suffix an index name suffix, used for zero-downtime reset mostly, no suffix by default
         # @option options [Integer] bulk_size bulk API chunk size in bytes; if passed, the request is performed several times for each chunk, empty by default
         # @option options [Integer] batch_size passed to the adapter import method, used to split imported objects in chunks, 1000 by default
+        # @option options [Boolean] direct_import skips object reloading in ORM adapter, `false` by default
         # @option options [true, false] journal enables imported objects journaling, false by default
         # @option options [Array<Symbol, String>] update_fields list of fields for the partial import, empty by default
         # @option options [true, false] update_failover enables full objects reimport in cases of partial update errors, `true` by default
         # @option options [true, Integer, Hash] parallel enables parallel import processing with the Parallel gem, accepts the number of workers or any Parallel gem acceptable options
         # @return [true, false] false in case of errors
-        def import(*args)
+        ruby2_keywords def import(*args)
           import_routine(*args).blank?
         end
 
@@ -83,9 +83,10 @@ module Chewy
         # in case of any import errors.
         #
         # @raise [Chewy::ImportFailed] in case of errors
-        def import!(*args)
+        ruby2_keywords def import!(*args)
           errors = import_routine(*args)
           raise Chewy::ImportFailed.new(self, errors) if errors.present?
+
           true
         end
 
@@ -93,7 +94,7 @@ module Chewy
         # `bulk_size` and `suffix`.
         #
         # @see https://github.com/elastic/elasticsearch-ruby/blob/master/elasticsearch-api/lib/elasticsearch/api/actions/bulk.rb
-        # @see Chewy::Type::Import::Bulk
+        # @see Chewy::Index::Import::BulkRequest
         # @param options [Hash{Symbol => Object}] besides specific import options, it accepts all the options suitable for the bulk API call like `refresh` or `timeout`
         # @option options [String] suffix bulk API chunk size in bytes; if passed, the request is performed several times for each chunk, empty by default
         # @option options [Integer] bulk_size bulk API chunk size in bytes; if passed, the request is performed several times for each chunk, empty by default
@@ -110,11 +111,11 @@ module Chewy
         # or normal composing under the hood.
         #
         # @param object [Object] a data source object
-        # @param crutches [Object] optional crutches object; if ommited - a crutch for the single passed object is created as a fallback
+        # @param crutches [Object] optional crutches object; if omitted - a crutch for the single passed object is created as a fallback
         # @param fields [Array<Symbol>] and array of fields to restrict the generated document
         # @return [Hash] a JSON-ready hash
         def compose(object, crutches = nil, fields: [])
-          crutches ||= Chewy::Type::Crutch::Crutches.new self, [object]
+          crutches ||= Chewy::Index::Crutch::Crutches.new self, [object]
 
           if witchcraft? && root.children.present?
             cauldron(fields: fields).brew(object, crutches)
@@ -126,8 +127,9 @@ module Chewy
       private
 
         def import_routine(*args)
-          return if args.first.blank? && !args.first.nil?
-          routine = Routine.new(self, args.extract_options!)
+          return if !args.first.nil? && empty_objects_or_scope?(args.first)
+
+          routine = Routine.new(self, **args.extract_options!)
           routine.create_indexes!
 
           if routine.parallel_options
@@ -137,8 +139,16 @@ module Chewy
           end
         end
 
+        def empty_objects_or_scope?(objects_or_scope)
+          if objects_or_scope.respond_to?(:empty?)
+            objects_or_scope.empty?
+          else
+            objects_or_scope.blank?
+          end
+        end
+
         def import_linear(objects, routine)
-          ActiveSupport::Notifications.instrument 'import_objects.chewy', type: self do |payload|
+          ActiveSupport::Notifications.instrument 'import_objects.chewy', index: self do |payload|
             adapter.import(*objects, routine.options) do |action_objects|
               routine.process(**action_objects)
             end
@@ -152,17 +162,25 @@ module Chewy
         def import_parallel(objects, routine)
           raise "The `parallel` gem is required for parallel import, please add `gem 'parallel'` to your Gemfile" unless '::Parallel'.safe_constantize
 
-          ActiveSupport::Notifications.instrument 'import_objects.chewy', type: self do |payload|
+          ActiveSupport::Notifications.instrument 'import_objects.chewy', index: self do |payload|
             batches = adapter.import_references(*objects, routine.options.slice(:batch_size)).to_a
 
             ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
-            results = ::Parallel.map_with_index(batches, routine.parallel_options, &IMPORT_WORKER.curry[self, routine.options, batches.size])
+            results = ::Parallel.map_with_index(
+              batches,
+              routine.parallel_options,
+              &IMPORT_WORKER.curry[self, routine.options, batches.size]
+            )
             ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
             errors, import, leftovers = process_parallel_import_results(results)
 
             if leftovers.present?
               batches = leftovers.each_slice(routine.options[:batch_size])
-              results = ::Parallel.map_with_index(batches, routine.parallel_options, &LEFTOVERS_WORKER.curry[self, routine.options, batches.size])
+              results = ::Parallel.map_with_index(
+                batches,
+                routine.parallel_options,
+                &LEFTOVERS_WORKER.curry[self, routine.options, batches.size]
+              )
               errors.concat(results.flatten(1))
             end