chewy 7.1.0 → 7.2.0

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

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     module Wrapper
       extend ActiveSupport::Concern
 
@@ -28,7 +28,7 @@ module Chewy
       def ==(other)
         return true if super
 
-        if other.is_a?(Chewy::Type)
+        if other.is_a?(Chewy::Index)
           self.class == other.class && (respond_to?(:id) ? id == other.id : attributes == other.attributes)
         elsif other.respond_to?(:id)
           self.class.adapter.target.is_a?(Class) &&

data/lib/chewy/journal.rb

@@ -2,18 +2,18 @@ module Chewy
   # A class to perform journal-related actions for the specified indexes/types.
   #
   # @example
-  #   journal = Chewy::Journal.new('places#city', UsersIndex)
+  #   journal = Chewy::Journal.new('places', UsersIndex)
   #   journal.apply(20.minutes.ago)
   #   journal.clean
   #
   class Journal
-    # @param only [Array<String, Chewy::Index, Chewy::Type>] indexes/types or even string references to perform actions on
+    # @param only [Array<String, Chewy::Index>] indexes or string references to perform actions on
     def initialize(*only)
       @only = only
     end
 
     # Applies all changes that were done since the specified time to the
-    # specified indexes/types.
+    # specified indexes.
     #
     # @param since_time [Time, DateTime] timestamp from which changes will be applied
     # @param retries [Integer] maximum number of attempts to make journal empty, 10 by default
@@ -27,8 +27,8 @@ module Chewy
         count += entries.size
         groups = reference_groups(entries)
         ActiveSupport::Notifications.instrument 'apply_journal.chewy', stage: stage, groups: groups
-        groups.each do |type, references|
-          type.import(references, import_options.merge(journal: false))
+        groups.each do |index, references|
+          index.import(references, import_options.merge(journal: false))
         end
         stage += 1
         since_time = entries.map(&:created_at).max
@@ -47,9 +47,9 @@ module Chewy
   private
 
     def reference_groups(entries)
-      entries.group_by(&:type).map do |type, grouped_entries|
-        [type, grouped_entries.map(&:references).inject(:|)]
-      end.to_h
+      entries.group_by(&:index_name)
+        .transform_keys { |index_name| Chewy.derive_name(index_name) }
+        .transform_values { |grouped_entries| grouped_entries.map(&:references).inject(:|) }
     end
   end
 end

data/lib/chewy/minitest/helpers.rb

@@ -6,7 +6,7 @@ module Chewy
       extend ActiveSupport::Concern
 
       # Assert that an index *changes* during a block.
-      # @param index [Chewy::Type] the index / type to watch, eg EntitiesIndex::Entity.
+      # @param index [Chewy::Index] the index to watch, eg EntitiesIndex.
       # @param strategy [Symbol] the Chewy strategy to use around the block. See Chewy docs.
       # @param bypass_actual_index [true, false]
       #   True to preempt the http call to Elastic, false otherwise.
@@ -14,11 +14,11 @@ module Chewy
       #
       # @return [SearchIndexReceiver] for optional further assertions on the nature of the index changes.
       #
-      def assert_indexes(index, strategy: :atomic, bypass_actual_index: true)
-        type = Chewy.derive_type index
+      def assert_indexes(index, strategy: :atomic, bypass_actual_index: true, &block)
+        index_class = Chewy.derive_name index
         receiver = SearchIndexReceiver.new
 
-        bulk_method = type.method :bulk
+        bulk_method = index_class.method :bulk
         # Manually mocking #bulk because we need to properly capture `self`
         bulk_mock = lambda do |*bulk_args|
           receiver.catch bulk_args, self
@@ -28,13 +28,11 @@ module Chewy
           {}
         end
 
-        type.define_singleton_method :bulk, bulk_mock
+        index_class.define_singleton_method :bulk, bulk_mock
 
-        Chewy.strategy(strategy) do
-          yield
-        end
+        Chewy.strategy(strategy, &block)
 
-        type.define_singleton_method :bulk, bulk_method
+        index_class.define_singleton_method :bulk, bulk_method
 
         assert_includes receiver.updated_indexes, index, "Expected #{index} to be updated but it wasn't"
 
@@ -44,10 +42,8 @@ module Chewy
       # Run indexing for the database changes during the block provided.
       # By default, indexing is run at the end of the block.
       # @param strategy [Symbol] the Chewy index update strategy see Chewy docs.
-      def run_indexing(strategy: :atomic)
-        Chewy.strategy strategy do
-          yield
-        end
+      def run_indexing(strategy: :atomic, &block)
+        Chewy.strategy strategy, &block
       end
 
       module ClassMethods

data/lib/chewy/minitest/search_index_receiver.rb

@@ -1,80 +1,76 @@
 # Test helper class to provide minitest hooks for Chewy::Index testing.
 #
 # @note Intended to be used in conjunction with a test helper which mocks over the #bulk
-#   method on a {Chewy::Type} class. (See SearchTestHelper)
+#   method on a {Chewy::Index} class. (See {Chewy::Minitest::Helpers})
 #
-# The class will capture the data from the *param on the Chewy::Type.bulk method and
+# The class will capture the data from the *param on the Chewy::Index.bulk method and
 # aggregate the data for test analysis.
 class SearchIndexReceiver
   def initialize
     @mutations = {}
   end
 
-  # @param bulk_params [Hash] the bulk_params that should be sent to the Chewy::Type.bulk method.
-  # @param type [Chewy::Type] the type executing this query.
-  def catch(bulk_params, type)
+  # @param bulk_params [Hash] the bulk_params that should be sent to the Chewy::Index.bulk method.
+  # @param index [Chewy::Index] the index executing this query.
+  def catch(bulk_params, index)
     Array.wrap(bulk_params).map { |y| y[:body] }.flatten.each do |update|
       if update[:delete]
-        mutation_for(type).deletes << update[:delete][:_id]
+        mutation_for(index).deletes << update[:delete][:_id]
       elsif update[:index]
-        mutation_for(type).indexes << update[:index]
+        mutation_for(index).indexes << update[:index]
       end
     end
   end
 
-  # @param index [Chewy::Index] return only index requests to the specified {Chewy::Type} index.
+  # @param index [Chewy::Index] return only index requests to the specified {Chewy::Index} index.
   # @return [Hash] the index changes captured by the mock.
   def indexes_for(index = nil)
     if index
       mutation_for(index).indexes
     else
-      Hash[
-        @mutations.map { |a, b| [a, b.indexes] }
-      ]
+      @mutations.transform_values(&:indexes)
     end
   end
   alias_method :indexes, :indexes_for
 
-  # @param index [Chewy::Index] return only delete requests to the specified {Chewy::Type} index.
+  # @param index [Chewy::Index] return only delete requests to the specified {Chewy::Index} index.
   # @return [Hash] the index deletes captured by the mock.
   def deletes_for(index = nil)
     if index
       mutation_for(index).deletes
     else
-      Hash[
-        @mutations.map { |a, b| [a, b.deletes] }
-      ]
+      @mutations.transform_values(&:deletes)
     end
   end
   alias_method :deletes, :deletes_for
 
   # Check to see if a given object has been indexed.
   # @param obj [#id] obj the object to look for.
-  # @param type [Chewy::Type] what type the object should be indexed as.
+  # @param index [Chewy::Index] what index the object should be indexed in.
   # @return [true, false] if the object was indexed.
-  def indexed?(obj, type)
-    indexes_for(type).map { |i| i[:_id] }.include? obj.id
+  def indexed?(obj, index)
+    indexes_for(index).map { |i| i[:_id] }.include? obj.id
   end
 
   # Check to see if a given object has been deleted.
   # @param obj [#id] obj the object to look for.
-  # @param type [Chewy::Type] what type the object should have been deleted from.
+  # @param index [Chewy::Index] what index the object should have been deleted from.
   # @return [true, false] if the object was deleted.
-  def deleted?(obj, type)
-    deletes_for(type).include? obj.id
+  def deleted?(obj, index)
+    deletes_for(index).include? obj.id
   end
 
-  # @return [Array<Chewy::Type>] a list of types indexes changed.
+  # @return [Array<Chewy::Index>] a list of indexes changed.
   def updated_indexes
     @mutations.keys
   end
 
 private
 
-  # Get the mutation object for a given type.
-  # @param type [Chewy::Type] the index type to fetch.
+  # Get the mutation object for a given index.
+  # @param index [Chewy::Index] the index to fetch.
   # @return [#indexes, #deletes] an object with a list of indexes and a list of deletes.
-  def mutation_for(type)
-    @mutations[type] ||= OpenStruct.new(indexes: [], deletes: [])
+  def mutation_for(index)
+    @mutations[index] ||= OpenStruct.new(indexes: [], deletes: [])
   end
 end

data/lib/chewy/railtie.rb

@@ -14,7 +14,9 @@ module Chewy
         if Rails.application.config.respond_to?(:assets) && env['PATH_INFO'].start_with?(Rails.application.config.assets.prefix)
           @app.call(env)
         else
-          Chewy.logger.info("Chewy request strategy is `#{Chewy.request_strategy}`") if Chewy.logger && @request_strategy != Chewy.request_strategy
+          if Chewy.logger && @request_strategy != Chewy.request_strategy
+            Chewy.logger.info("Chewy request strategy is `#{Chewy.request_strategy}`")
+          end
           @request_strategy = Chewy.request_strategy
           Chewy.strategy(Chewy.request_strategy) { @app.call(env) }
         end
@@ -35,7 +37,7 @@ module Chewy
       if app.sandbox?
         Chewy.strategy(:bypass)
       else
-        Chewy.strategy(:urgent)
+        Chewy.strategy(Chewy.console_strategy)
       end
       puts "Chewy console strategy is `#{Chewy.strategy.current.name}`"
     end

data/lib/chewy/rake_helper.rb

@@ -3,14 +3,12 @@ module Chewy
     IMPORT_CALLBACK = lambda do |output, _name, start, finish, _id, payload|
       duration = (finish - start).ceil
       stats = payload.fetch(:import, {}).map { |key, count| "#{key} #{count}" }.join(', ')
-      output.puts "  Imported #{payload[:type]} in #{human_duration(duration)}, stats: #{stats}"
-      if payload[:errors]
-        payload[:errors].each do |action, errors|
-          output.puts "    #{action.to_s.humanize} errors:"
-          errors.each do |error, documents|
-            output.puts "      `#{error}`"
-            output.puts "        on #{documents.count} documents: #{documents}"
-          end
+      output.puts "  Imported #{payload[:index]} in #{human_duration(duration)}, stats: #{stats}"
+      payload[:errors]&.each do |action, errors|
+        output.puts "    #{action.to_s.humanize} errors:"
+        errors.each do |error, documents|
+          output.puts "      `#{error}`"
+          output.puts "        on #{documents.count} documents: #{documents}"
         end
       end
     end
@@ -36,7 +34,7 @@ module Chewy
       # @param parallel [true, Integer, Hash] any acceptable parallel options for import
       # @param output [IO] output io for logging
       # @return [Array<Chewy::Index>] indexes that were reset
-      def reset(only: nil, except: nil, parallel: nil, output: STDOUT)
+      def reset(only: nil, except: nil, parallel: nil, output: $stdout)
         subscribed_task_stats(output) do
           indexes_from(only: only, except: except).each do |index|
             reset_one(index, output, parallel: parallel)
@@ -59,7 +57,7 @@ module Chewy
       # @param parallel [true, Integer, Hash] any acceptable parallel options for import
       # @param output [IO] output io for logging
       # @return [Array<Chewy::Index>] indexes that were actually reset
-      def upgrade(only: nil, except: nil, parallel: nil, output: STDOUT)
+      def upgrade(only: nil, except: nil, parallel: nil, output: $stdout)
         subscribed_task_stats(output) do
           indexes = indexes_from(only: only, except: except)
 
@@ -87,23 +85,21 @@ module Chewy
       #
       # @example
       #   Chewy::RakeHelper.update # updates everything
-      #   Chewy::RakeHelper.update(only: 'places') # updates only PlacesIndex::City and PlacesIndex::Country
-      #   Chewy::RakeHelper.update(only: 'places#city') # updates PlacesIndex::City only
-      #   Chewy::RakeHelper.update(except: PlacesIndex::Country) # updates everything, but PlacesIndex::Country
-      #   Chewy::RakeHelper.update(only: 'places', except: 'places#country') # updates PlacesIndex::City only
+      #   Chewy::RakeHelper.update(only: 'places') # updates only PlacesIndex
+      #   Chewy::RakeHelper.update(except: PlacesIndex) # updates everything, but PlacesIndex
       #
-      # @param only [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to update; if nothing is passed - uses all the types defined in the app
-      # @param except [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to exclude from processing
+      # @param only [Array<Chewy::Index, String>, Chewy::Index, String] indexes to update; if nothing is passed - uses all the indexes defined in the app
+      # @param except [Array<Chewy::Index, String>, Chewy::Index, String] indexes to exclude from processing
       # @param parallel [true, Integer, Hash] any acceptable parallel options for import
       # @param output [IO] output io for logging
-      # @return [Array<Chewy::Type>] types that were actually updated
-      def update(only: nil, except: nil, parallel: nil, output: STDOUT)
+      # @return [Array<Chewy::Index>] indexes that were actually updated
+      def update(only: nil, except: nil, parallel: nil, output: $stdout)
         subscribed_task_stats(output) do
-          types_from(only: only, except: except).group_by(&:index).each_with_object([]) do |(index, types), update_types|
+          indexes_from(only: only, except: except).each_with_object([]) do |index, updated_indexes|
             if index.exists?
               output.puts "Updating #{index}"
-              types.each { |type| type.import(parallel: parallel) }
-              update_types.concat(types)
+              index.import(parallel: parallel)
+              updated_indexes.push(index)
             else
               output.puts "Skipping #{index}, it does not exists (use rake chewy:reset[#{index.derivable_name}] to create and update it)"
             end
@@ -115,31 +111,29 @@ module Chewy
       #
       # @example
       #   Chewy::RakeHelper.sync # synchronizes everything
-      #   Chewy::RakeHelper.sync(only: 'places') # synchronizes only PlacesIndex::City and PlacesIndex::Country
-      #   Chewy::RakeHelper.sync(only: 'places#city') # synchronizes PlacesIndex::City only
-      #   Chewy::RakeHelper.sync(except: PlacesIndex::Country) # synchronizes everything, but PlacesIndex::Country
-      #   Chewy::RakeHelper.sync(only: 'places', except: 'places#country') # synchronizes PlacesIndex::City only
+      #   Chewy::RakeHelper.sync(only: 'places') # synchronizes only PlacesIndex
+      #   Chewy::RakeHelper.sync(except: PlacesIndex) # synchronizes everything, but PlacesIndex
       #
-      # @param only [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to synchronize; if nothing is passed - uses all the types defined in the app
-      # @param except [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to exclude from processing
+      # @param only [Array<Chewy::Index, String>, Chewy::Index, String] indexes to synchronize; if nothing is passed - uses all the indexes defined in the app
+      # @param except [Array<Chewy::Index, String>, Chewy::Index, String] indexes to exclude from processing
       # @param parallel [true, Integer, Hash] any acceptable parallel options for sync
       # @param output [IO] output io for logging
-      # @return [Array<Chewy::Type>] types that were actually updated
-      def sync(only: nil, except: nil, parallel: nil, output: STDOUT)
+      # @return [Array<Chewy::Index>] indexes that were actually updated
+      def sync(only: nil, except: nil, parallel: nil, output: $stdout)
         subscribed_task_stats(output) do
-          types_from(only: only, except: except).each_with_object([]) do |type, synced_types|
-            output.puts "Synchronizing #{type}"
-            output.puts "  #{type} doesn't support outdated synchronization" unless type.supports_outdated_sync?
+          indexes_from(only: only, except: except).each_with_object([]) do |index, synced_indexes|
+            output.puts "Synchronizing #{index}"
+            output.puts "  #{index} doesn't support outdated synchronization" unless index.supports_outdated_sync?
             time = Time.now
-            sync_result = type.sync(parallel: parallel)
+            sync_result = index.sync(parallel: parallel)
             if !sync_result
-              output.puts "  Something went wrong with the #{type} synchronization"
-            elsif sync_result[:count] > 0
+              output.puts "  Something went wrong with the #{index} synchronization"
+            elsif (sync_result[:count]).positive?
               output.puts "  Missing documents: #{sync_result[:missing]}" if sync_result[:missing].present?
               output.puts "  Outdated documents: #{sync_result[:outdated]}" if sync_result[:outdated].present?
-              synced_types.push(type)
+              synced_indexes.push(index)
             else
-              output.puts "  Skipping #{type}, up to date"
+              output.puts "  Skipping #{index}, up to date"
             end
             output.puts "  Took #{human_duration(Time.now - time)}"
           end
@@ -147,49 +141,46 @@ module Chewy
       end
 
       # Applies changes that were done after the specified time for the
-      # specified indexes/types or all of them.
+      # specified indexes or all of them.
       #
       # @example
       #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago) # applies entries created for the last minute
-      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago, only: 'places') # applies only PlacesIndex::City and PlacesIndex::Country entries reated for the last minute
-      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago, only: 'places#city') # applies PlacesIndex::City entries reated for the last minute only
-      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago, except: PlacesIndex::Country) # applies everything, but PlacesIndex::Country entries reated for the last minute
-      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago, only: 'places', except: 'places#country') # applies PlacesIndex::City entries reated for the last minute only
+      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago, only: 'places') # applies only PlacesIndex entries created for the last minute
+      #   Chewy::RakeHelper.journal_apply(time: 1.minute.ago, except: PlacesIndex) # applies everything, but PlacesIndex, entries created for the last minute
       #
       # @param time [Time, DateTime] use only journal entries created after this time
-      # @param only [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to synchronize; if nothing is passed - uses all the types defined in the app
-      # @param except [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to exclude from processing
+      # @param only [Array<Chewy::Index, String>, Chewy::Index, String] indexes to synchronize; if nothing is passed - uses all the indexes defined in the app
+      # @param except [Array<Chewy::Index, String>, Chewy::Index, String] indexes to exclude from processing
       # @param output [IO] output io for logging
-      # @return [Array<Chewy::Type>] types that were actually updated
-      def journal_apply(time: nil, only: nil, except: nil, output: STDOUT)
+      # @return [Array<Chewy::Index>] indexes that were actually updated
+      def journal_apply(time: nil, only: nil, except: nil, output: $stdout)
         raise ArgumentError, 'Please specify the time to start with' unless time
+
         subscribed_task_stats(output) do
           output.puts "Applying journal entries created after #{time}"
-          count = Chewy::Journal.new(types_from(only: only, except: except)).apply(time)
+          count = Chewy::Journal.new(indexes_from(only: only, except: except)).apply(time)
           output.puts 'No journal entries were created after the specified time' if count.zero?
         end
       end
 
       # Removes journal records created before the specified timestamp for
-      # the specified indexes/types or all of them.
+      # the specified indexes or all of them.
       #
       # @example
       #   Chewy::RakeHelper.journal_clean # cleans everything
       #   Chewy::RakeHelper.journal_clean(time: 1.minute.ago) # leaves only entries created for the last minute
-      #   Chewy::RakeHelper.journal_clean(only: 'places') # cleans only PlacesIndex::City and PlacesIndex::Country entries
-      #   Chewy::RakeHelper.journal_clean(only: 'places#city') # cleans PlacesIndex::City entries only
-      #   Chewy::RakeHelper.journal_clean(except: PlacesIndex::Country) # cleans everything, but PlacesIndex::Country entries
-      #   Chewy::RakeHelper.journal_clean(only: 'places', except: 'places#country') # cleans PlacesIndex::City entries only
+      #   Chewy::RakeHelper.journal_clean(only: 'places') # cleans only PlacesIndex entries
+      #   Chewy::RakeHelper.journal_clean(except: PlacesIndex) # cleans everything, but PlacesIndex entries
       #
       # @param time [Time, DateTime] clean all the journal entries created before this time
-      # @param only [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to synchronize; if nothing is passed - uses all the types defined in the app
-      # @param except [Array<Chewy::Index, Chewy::Type, String>, Chewy::Index, Chewy::Type, String] indexes or types to exclude from processing
+      # @param only [Array<Chewy::Index, String>, Chewy::Index, String] indexes to synchronize; if nothing is passed - uses all the indexes defined in the app
+      # @param except [Array<Chewy::Index, String>, Chewy::Index, String] indexes to exclude from processing
       # @param output [IO] output io for logging
-      # @return [Array<Chewy::Type>] types that were actually updated
-      def journal_clean(time: nil, only: nil, except: nil, output: STDOUT)
+      # @return [Array<Chewy::Index>] indexes that were actually updated
+      def journal_clean(time: nil, only: nil, except: nil, output: $stdout)
         subscribed_task_stats(output) do
           output.puts "Cleaning journal entries created before #{time}" if time
-          response = Chewy::Journal.new(types_from(only: only, except: except)).clean(time)
+          response = Chewy::Journal.new(indexes_from(only: only, except: except)).clean(time)
           count = response['deleted'] || response['_indices']['_all']['deleted']
           output.puts "Cleaned up #{count} journal entries"
         end
@@ -204,45 +195,53 @@ module Chewy
         Chewy::Index.descendants - [Chewy::Stash::Journal, Chewy::Stash::Specification]
       end
 
+      # Reindex data from source index to destination index
+      #
+      # @example
+      #   Chewy::RakeHelper.reindex(source: 'users_index', dest: 'cities_index') reindex data from 'users_index' index to 'cities_index'
+      #
+      # @param source [String], dest [String] indexes to reindex
+      def reindex(source:, dest:, output: $stdout)
+        subscribed_task_stats(output) do
+          output.puts "Source index is #{source}\nDestination index is #{dest}"
+          Chewy::Index.reindex(source: source, dest: dest)
+          output.puts "#{source} index successfully reindexed with #{dest} index data"
+        end
+      end
+
+      # Adds new fields to an existing data stream or index.
+      # Change the search settings of existing fields.
+      #
+      # @example
+      #   Chewy::RakeHelper.update_mapping('cities', {properties: {new_field: {type: :text}}}) update 'cities' index with new_field of text type
+      #
+      # @param name [String], body_hash [Hash] index name and body hash to update
+      def update_mapping(name:, output: $stdout)
+        subscribed_task_stats(output) do
+          output.puts "Index name is #{name}"
+          normalize_index(name).update_mapping
+          output.puts "#{name} index successfully updated"
+        end
+      end
+
       def normalize_indexes(*identifiers)
         identifiers.flatten(1).map { |identifier| normalize_index(identifier) }
       end
 
       def normalize_index(identifier)
         return identifier if identifier.is_a?(Class) && identifier < Chewy::Index
-        "#{identifier.to_s.gsub(/identifier\z/i, '').camelize}Index".constantize
+
+        "#{identifier.to_s.camelize}Index".constantize
       end
 
-      def subscribed_task_stats(output = STDOUT)
+      def subscribed_task_stats(output = $stdout, &block)
         start = Time.now
         ActiveSupport::Notifications.subscribed(JOURNAL_CALLBACK.curry[output], 'apply_journal.chewy') do
-          ActiveSupport::Notifications.subscribed(IMPORT_CALLBACK.curry[output], 'import_objects.chewy') do
-            yield
-          end
+          ActiveSupport::Notifications.subscribed(IMPORT_CALLBACK.curry[output], 'import_objects.chewy', &block)
         end
         output.puts "Total: #{human_duration(Time.now - start)}"
       end
 
-      def reset_index(*indexes)
-        ActiveSupport::Deprecation.warn '`Chewy::RakeHelper.reset_index` is deprecated and will be removed soon, use `Chewy::RakeHelper.reset` instead'
-        reset(only: indexes)
-      end
-
-      def reset_all(*except)
-        ActiveSupport::Deprecation.warn '`Chewy::RakeHelper.reset_all` is deprecated and will be removed soon, use `Chewy::RakeHelper.reset` instead'
-        reset(except: except)
-      end
-
-      def update_index(*indexes)
-        ActiveSupport::Deprecation.warn '`Chewy::RakeHelper.update_index` is deprecated and will be removed soon, use `Chewy::RakeHelper.update` instead'
-        update(only: indexes)
-      end
-
-      def update_all(*except)
-        ActiveSupport::Deprecation.warn '`Chewy::RakeHelper.update_all` is deprecated and will be removed soon, use `Chewy::RakeHelper.update` instead'
-        update(except: except)
-      end
-
     private
 
       def indexes_from(only: nil, except: nil)
@@ -261,33 +260,9 @@ module Chewy
         indexes.sort_by(&:derivable_name)
       end
 
-      def types_from(only: nil, except: nil)
-        types = if only.present?
-          normalize_types(Array.wrap(only))
-        else
-          all_indexes.flat_map(&:types)
-        end
-
-        types = if except.present?
-          types - normalize_types(Array.wrap(except))
-        else
-          types
-        end
-
-        types.sort_by(&:derivable_name)
-      end
-
-      def normalize_types(*identifiers)
-        identifiers.flatten(1).flat_map { |identifier| normalize_type(identifier) }
-      end
-
-      def normalize_type(identifier)
-        Chewy.derive_types(identifier)
-      end
-
       def human_duration(seconds)
         [[60, :s], [60, :m], [24, :h]].map do |amount, unit|
-          if seconds > 0
+          if seconds.positive?
             seconds, n = seconds.divmod(amount)
             "#{n.to_i}#{unit}"
           end