chewy 7.1.0 → 7.2.0

data/lib/chewy/{type → index}/adapter/orm.rb

@@ -1,7 +1,7 @@
-require 'chewy/type/adapter/base'
+require 'chewy/index/adapter/base'
 
 module Chewy
-  class Type
+  class Index
     module Adapter
       class Orm < Base
         attr_reader :default_scope
@@ -54,24 +54,23 @@ module Chewy
         #
         #   users = User.all
         #   users.each { |user| user.destroy if user.inactive? }
-        #   UsersIndex::User.import users # inactive users will be deleted from index
+        #   UsersIndex.import users # inactive users will be deleted from index
         #   # or
-        #   UsersIndex::User.import users.map(&:id) # deleted user ids will be deleted from index
+        #   UsersIndex.import users.map(&:id) # deleted user ids will be deleted from index
         #
         # Also there is custom type option `delete_if`. It it returns `true`
         # object will be deleted from index. Note that if this option is defined and
         # return `false` Chewy will still check `destroyed?` method. This is useful
         # for paranoid objects deleting implementation.
         #
-        #   define_type User, delete_if: ->{ deleted_at } do
-        #     ...
-        #   end
+        #   index_scope User, delete_if: ->{ deleted_at }
+        #   ...
         #
         #   users = User.all
         #   users.each { |user| user.deleted_at = Time.now }
-        #   UsersIndex::User.import users # paranoid deleted users will be deleted from index
+        #   UsersIndex.import users # paranoid deleted users will be deleted from index
         #   # or
-        #   UsersIndex::User.import users.map(&:id) # user ids will be deleted from index
+        #   UsersIndex.import users.map(&:id) # user ids will be deleted from index
         #
         def import(*args, &block)
           collection, options = import_args(*args)
@@ -92,16 +91,14 @@ module Chewy
             collection = all_scope_where_ids_in(identify(collection)) unless collection.is_a?(relation_class)
             pluck_in_batches(collection, **options.slice(:fields, :batch_size, :typecast), &block)
           else
-            identify(collection).each_slice(options[:batch_size]) do |batch|
-              yield batch
-            end
+            identify(collection).each_slice(options[:batch_size], &block)
           end
         end
         alias_method :import_references, :import_fields
 
         def load(ids, **options)
           scope = all_scope_where_ids_in(ids)
-          additional_scope = options[options[:_type].type_name.to_sym].try(:[], :scope) || options[:scope]
+          additional_scope = options[options[:_index].to_sym].try(:[], :scope) || options[:scope]
 
           loaded_objects = load_scope_objects(scope, additional_scope)
             .index_by do |object|
@@ -115,7 +112,7 @@ module Chewy
 
         def import_objects(collection, options)
           collection_ids = identify(collection)
-          hash = Hash[collection_ids.map(&:to_s).zip(collection)]
+          hash = collection_ids.map(&:to_s).zip(collection).to_h
 
           indexed = collection_ids.each_slice(options[:batch_size]).map do |ids|
             batch = if options[:raw_import]

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

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     module Crutch
       extend ActiveSupport::Concern
 
@@ -9,13 +9,13 @@ module Chewy
       end
 
       class Crutches
-        def initialize(type, collection)
-          @type = type
+        def initialize(index, collection)
+          @index = index
           @collection = collection
-          @type._crutches.each_key do |name|
+          @index._crutches.each_key do |name|
             singleton_class.class_eval <<-METHOD, __FILE__, __LINE__ + 1
               def #{name}
-                @#{name} ||= @type._crutches[:#{name}].call @collection
+                @#{name} ||= @index._crutches[:#{name}].call @collection
               end
             METHOD
           end

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

@@ -1,39 +1,39 @@
-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
@@ -51,15 +51,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
@@ -87,6 +87,7 @@ module Chewy
         def import!(*args)
           errors = import_routine(*args)
           raise Chewy::ImportFailed.new(self, errors) if errors.present?
+
           true
         end
 
@@ -94,7 +95,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
@@ -111,11 +112,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)
@@ -148,7 +149,7 @@ module Chewy
         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
@@ -162,17 +163,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
 

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

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     module Import
       # This class purpose is to build ES client-acceptable bulk
       # request body from the passed objects for index and deletion.
@@ -9,13 +9,13 @@ module Chewy
       # 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 type [Chewy::Type] desired type
-        # @param index [Array<Object>] objects to index
+        # @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(type, index: [], delete: [], fields: [])
-          @type = type
+        def initialize(index, to_index: [], delete: [], fields: [])
           @index = index
+          @to_index = to_index
           @delete = delete
           @fields = fields.map!(&:to_sym)
         end
@@ -24,7 +24,7 @@ module Chewy
         # @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
-          @bulk_body ||= @index.flat_map(&method(:index_entry)).concat(
+          @bulk_body ||= @to_index.flat_map(&method(:index_entry)).concat(
             @delete.flat_map(&method(:delete_entry))
           )
         end
@@ -40,7 +40,7 @@ module Chewy
       private
 
         def crutches
-          @crutches ||= Chewy::Type::Crutch::Crutches.new @type, @index
+          @crutches ||= Chewy::Index::Crutch::Crutches.new @index, @to_index
         end
 
         def parents
@@ -53,7 +53,7 @@ module Chewy
             ids.concat(@delete.map do |object|
               object.respond_to?(:id) ? object.id : object
             end)
-            @type.filter(ids: {values: ids}).order('_doc').pluck(:_id, :_parent).to_h
+            @index.filter(ids: {values: ids}).order('_doc').pluck(:_id, :_parent).to_h
           end
         end
 
@@ -67,14 +67,15 @@ module Chewy
           end
 
           if parent && entry[:parent].to_s != parent
-            entry[:data] = @type.compose(object, crutches)
+            entry[:data] = @index.compose(object, crutches)
             [{delete: entry.except(:data).merge(parent: parent)}, {index: entry}]
           elsif @fields.present?
             return [] unless entry[:_id]
-            entry[:data] = {doc: @type.compose(object, crutches, fields: @fields)}
+
+            entry[:data] = {doc: @index.compose(object, crutches, fields: @fields)}
             [{update: entry}]
           else
-            entry[:data] = @type.compose(object, crutches)
+            entry[:data] = @index.compose(object, crutches)
             [{index: entry}]
           end
         end
@@ -89,6 +90,7 @@ module Chewy
           if parents
             parent = entry[:_id].present? && parents[entry[:_id].to_s]
             return [] unless parent
+
             entry[:parent] = parent
           end
 
@@ -107,14 +109,14 @@ module Chewy
         end
 
         def index_object_ids
-          @index_object_ids ||= @index.each_with_object({}) do |object, result|
+          @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 ||= @type.root
+          @type_root ||= @index.root
         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,7 +47,7 @@ module Chewy
 
         def request_base
           @request_base ||= {
-            index: @type.index_name(suffix: @suffix)
+            index: @index.index_name(suffix: @suffix)
           }.merge!(@bulk_options)
         end
 

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

@@ -1,18 +1,18 @@
 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|
@@ -26,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
@@ -36,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,12 +61,13 @@ 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 the bulk request body,
@@ -77,11 +78,11 @@ module Chewy
         # @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