chewy 7.2.1 → 7.6.0

data/lib/chewy/rake_helper.rb

@@ -19,6 +19,9 @@ module Chewy
       output.puts "  Applying journal to #{targets}, #{count} entries, stage #{payload[:stage]}"
     end
 
+    DELETE_BY_QUERY_OPTIONS = %w[WAIT_FOR_COMPLETION REQUESTS_PER_SECOND SCROLL_SIZE].freeze
+    FALSE_VALUES = %w[0 f false off].freeze
+
     class << self
       # Performs zero-downtime reindexing of all documents for the specified indexes
       #
@@ -35,6 +38,8 @@ module Chewy
       # @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)
+        warn_missing_index(output)
+
         subscribed_task_stats(output) do
           indexes_from(only: only, except: except).each do |index|
             reset_one(index, output, parallel: parallel)
@@ -58,6 +63,8 @@ module Chewy
       # @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)
+        warn_missing_index(output)
+
         subscribed_task_stats(output) do
           indexes = indexes_from(only: only, except: except)
 
@@ -158,7 +165,7 @@ module Chewy
 
         subscribed_task_stats(output) do
           output.puts "Applying journal entries created after #{time}"
-          count = Chewy::Journal.new(indexes_from(only: only, except: except)).apply(time)
+          count = Chewy::Journal.new(journal_indexes_from(only: only, except: except)).apply(time)
           output.puts 'No journal entries were created after the specified time' if count.zero?
         end
       end
@@ -177,12 +184,29 @@ module Chewy
       # @param except [Array<Chewy::Index, String>, Chewy::Index, String] indexes to exclude from processing
       # @param output [IO] output io for logging
       # @return [Array<Chewy::Index>] indexes that were actually updated
-      def journal_clean(time: nil, only: nil, except: nil, output: $stdout)
+      def journal_clean(time: nil, only: nil, except: nil, delete_by_query_options: {}, output: $stdout)
         subscribed_task_stats(output) do
           output.puts "Cleaning journal entries created before #{time}" if 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"
+          response = Chewy::Journal.new(journal_indexes_from(only: only, except: except)).clean(time, delete_by_query_options: delete_by_query_options)
+          if response.key?('task')
+            output.puts "Task to cleanup the journal has been created, #{response['task']}"
+          else
+            count = response['deleted'] || response['_indices']['_all']['deleted']
+            output.puts "Cleaned up #{count} journal entries"
+          end
+        end
+      end
+
+      # Creates journal index.
+      #
+      # @example
+      #   Chewy::RakeHelper.journal_create # creates journal
+      #
+      # @param output [IO] output io for logging
+      # @return Chewy::Index Returns instance of chewy index
+      def journal_create(output: $stdout)
+        subscribed_task_stats(output) do
+          Chewy::Stash::Journal.create!
         end
       end
 
@@ -224,6 +248,44 @@ module Chewy
         end
       end
 
+      # Reads options that are required to run journal cleanup asynchronously from ENV hash
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete-by-query.html
+      #
+      # @example
+      #   Chewy::RakeHelper.delete_by_query_options_from_env({'WAIT_FOR_COMPLETION' => 'false','REQUESTS_PER_SECOND' => '10','SCROLL_SIZE' => '5000'})
+      #   # => { wait_for_completion: false, requests_per_second: 10.0, scroll_size: 5000 }
+      #
+      def delete_by_query_options_from_env(env)
+        env
+          .slice(*DELETE_BY_QUERY_OPTIONS)
+          .transform_keys { |k| k.downcase.to_sym }
+          .to_h do |key, value|
+            case key
+            when :wait_for_completion then [key, !FALSE_VALUES.include?(value.downcase)]
+            when :requests_per_second then [key, value.to_f]
+            when :scroll_size then [key, value.to_i]
+            end
+          end
+      end
+
+      def create_missing_indexes!(output: $stdout, env: ENV)
+        subscribed_task_stats(output) do
+          Chewy.eager_load!
+          all_indexes = Chewy::Index.descendants
+          all_indexes -= [Chewy::Stash::Journal] unless Chewy.configuration[:journal]
+          all_indexes.each do |index|
+            if index.exists?
+              output.puts "#{index.name} already exists, skipping" if env['VERBOSE']
+              next
+            end
+
+            index.create!
+
+            output.puts "#{index.name} index successfully created"
+          end
+        end
+      end
+
       def normalize_indexes(*identifiers)
         identifiers.flatten(1).map { |identifier| normalize_index(identifier) }
       end
@@ -239,11 +301,18 @@ module Chewy
         ActiveSupport::Notifications.subscribed(JOURNAL_CALLBACK.curry[output], 'apply_journal.chewy') do
           ActiveSupport::Notifications.subscribed(IMPORT_CALLBACK.curry[output], 'import_objects.chewy', &block)
         end
+      ensure
         output.puts "Total: #{human_duration(Time.now - start)}"
       end
 
     private
 
+      def journal_indexes_from(only: nil, except: nil)
+        return if Array.wrap(only).empty? && Array.wrap(except).empty?
+
+        indexes_from(only: only, except: except)
+      end
+
       def indexes_from(only: nil, except: nil)
         indexes = if only.present?
           normalize_indexes(Array.wrap(only))
@@ -251,11 +320,7 @@ module Chewy
           all_indexes
         end
 
-        indexes = if except.present?
-          indexes - normalize_indexes(Array.wrap(except))
-        else
-          indexes
-        end
+        indexes -= normalize_indexes(Array.wrap(except)) if except.present?
 
         indexes.sort_by(&:derivable_name)
       end
@@ -271,7 +336,23 @@ module Chewy
 
       def reset_one(index, output, parallel: false)
         output.puts "Resetting #{index}"
-        index.reset!((Time.now.to_f * 1000).round, parallel: parallel, progressbar: ENV['PROGRESS'] == 'true')
+        index.reset!((Time.now.to_f * 1000).round, parallel: parallel, apply_journal: journal_exists?)
+      end
+
+      def warn_missing_index(output)
+        return if journal_exists?
+
+        output.puts "############################################################\n" \
+                    "WARN: You are risking to lose some changes during the reset.\n      " \
+                    "Please consider enabling journaling.\n      " \
+                    "See https://github.com/toptal/chewy#journaling\n" \
+                    '############################################################'
+      end
+
+      def journal_exists?
+        @journal_exists = Chewy::Stash::Journal.exists? if @journal_exists.nil?
+
+        @journal_exists
       end
     end
   end

data/lib/chewy/rspec/build_query.rb

@@ -0,0 +1,12 @@
+# Rspec helper to compare request and expected query
+# To use it - add `require 'chewy/rspec/build_query'` to the `spec_helper.rb`
+# Simple usage - just pass expected response as argument
+# and then call needed query.
+#
+#   expect { method1.method2...methodN }.to build_query(expected_query)
+#
+RSpec::Matchers.define :build_query do |expected_query = {}|
+  match do |request|
+    request.render == expected_query
+  end
+end

data/lib/chewy/rspec/helpers.rb

@@ -0,0 +1,55 @@
+module Chewy
+  module Rspec
+    module Helpers
+      extend ActiveSupport::Concern
+      # Rspec helper to mock elasticsearch response
+      # To use it - add `require 'chewy/rspec'` to the `spec_helper.rb`
+      #
+      #   mock_elasticsearch_response(CitiesIndex, raw_response)
+      #   expect(CitiesIndex.query({}).hits).to eq(hits)
+      #
+      def mock_elasticsearch_response(index, raw_response)
+        mocked_request = Chewy::Search::Request.new(index)
+        allow(Chewy::Search::Request).to receive(:new).and_return(mocked_request)
+        allow(mocked_request).to receive(:perform).and_return(raw_response)
+      end
+
+      # Rspec helper to mock Elasticsearch response source
+      # To use it - add `require 'chewy/rspec'` to the `spec_helper.rb`
+      #
+      #  mock_elasticsearch_response_sources(CitiesIndex, sources)
+      #  expect(CitiesIndex.query({}).hits).to eq(hits)
+      #
+      def mock_elasticsearch_response_sources(index, hits)
+        raw_response = {
+          'took' => 4,
+          'timed_out' => false,
+          '_shards' => {
+            'total' => 1,
+            'successful' => 1,
+            'skipped' => 0,
+            'failed' => 0
+          },
+          'hits' => {
+            'total' => {
+              'value' => hits.count,
+              'relation' => 'eq'
+            },
+            'max_score' => 1.0,
+            'hits' => hits.each_with_index.map do |hit, i|
+              {
+                '_index' => index.index_name,
+                '_type' => '_doc',
+                '_id' => (i + 1).to_s,
+                '_score' => 3.14,
+                '_source' => hit
+              }
+            end
+          }
+        }
+
+        mock_elasticsearch_response(index, raw_response)
+      end
+    end
+  end
+end

data/lib/chewy/rspec/update_index.rb

@@ -1,4 +1,4 @@
-require 'i18n/core_ext/hash'
+require 'active_support/core_ext/hash/keys'
 
 # Rspec matcher `update_index`
 # To use it - add `require 'chewy/rspec'` to the `spec_helper.rb`
@@ -88,6 +88,11 @@ RSpec::Matchers.define :update_index do |index_name, options = {}| # rubocop:dis
     @only = true
   end
 
+  # Expect import to be called with refresh=false parameter
+  chain(:no_refresh) do
+    @no_refresh = true
+  end
+
   def supports_block_expectations?
     true
   end
@@ -100,11 +105,13 @@ RSpec::Matchers.define :update_index do |index_name, options = {}| # rubocop:dis
 
     index = Chewy.derive_name(index_name)
     if defined?(Mocha) && RSpec.configuration.mock_framework.to_s == 'RSpec::Core::MockingAdapters::Mocha'
-      Chewy::Index::Import::BulkRequest.stubs(:new).with(index, any_parameters).returns(mock_bulk_request)
+      params_matcher = @no_refresh ? has_entry(refresh: false) : any_parameters
+      Chewy::Index::Import::BulkRequest.stubs(:new).with(index, params_matcher).returns(mock_bulk_request)
     else
-      mocked_already = ::RSpec::Mocks.space.proxy_for(Chewy::Index::Import::BulkRequest).method_double_if_exists_for_message(:new)
+      mocked_already = RSpec::Mocks.space.proxy_for(Chewy::Index::Import::BulkRequest).method_double_if_exists_for_message(:new)
       allow(Chewy::Index::Import::BulkRequest).to receive(:new).and_call_original unless mocked_already
-      allow(Chewy::Index::Import::BulkRequest).to receive(:new).with(index, any_args).and_return(mock_bulk_request)
+      params_matcher = @no_refresh ? hash_including(refresh: false) : any_args
+      allow(Chewy::Index::Import::BulkRequest).to receive(:new).with(index, params_matcher).and_return(mock_bulk_request)
     end
 
     Chewy.strategy(options[:strategy] || :atomic) { block.call }
@@ -146,7 +153,7 @@ RSpec::Matchers.define :update_index do |index_name, options = {}| # rubocop:dis
     output = ''
 
     if mock_bulk_request.updates.none?
-      output << "Expected index `#{index_name}` to be updated, but it was not\n"
+      output << "Expected index `#{index_name}` to be updated#{' with no refresh' if @no_refresh}, but it was not\n"
     elsif @missed_reindex.present? || @missed_delete.present?
       message = "Expected index `#{index_name}` "
       message << [
@@ -213,7 +220,7 @@ RSpec::Matchers.define :update_index do |index_name, options = {}| # rubocop:dis
     expected_count = options[:times] || options[:count]
     expected_attributes = (options[:with] || options[:attributes] || {}).deep_symbolize_keys
 
-    args.flatten.map do |document|
+    args.flatten.to_h do |document|
       id = document.respond_to?(:id) ? document.id.to_s : document.to_s
       [id, {
         document: document,
@@ -222,7 +229,7 @@ RSpec::Matchers.define :update_index do |index_name, options = {}| # rubocop:dis
         real_count: 0,
         real_attributes: {}
       }]
-    end.to_h
+    end
   end
 
   def compare_attributes(expected, real)

data/lib/chewy/rspec.rb

@@ -1 +1,3 @@
+require 'chewy/rspec/build_query'
+require 'chewy/rspec/helpers'
 require 'chewy/rspec/update_index'

data/lib/chewy/runtime/version.rb

@@ -5,7 +5,7 @@ module Chewy
       attr_reader :major, :minor, :patch
 
       def initialize(version)
-        @major, @minor, @patch = *(version.to_s.split('.', 3) + [0] * 3).first(3).map(&:to_i)
+        @major, @minor, @patch = *(version.to_s.split('.', 3) + ([0] * 3)).first(3).map(&:to_i)
       end
 
       def to_s

data/lib/chewy/runtime.rb

@@ -3,7 +3,7 @@ require 'chewy/runtime/version'
 module Chewy
   module Runtime
     def self.version
-      Thread.current[:chewy_runtime_version] ||= Version.new(Chewy.client.info['version']['number'])
+      Chewy.current[:chewy_runtime_version] ||= Version.new(Chewy.client.info['version']['number'])
     end
   end
 end

data/lib/chewy/search/parameters/collapse.rb

@@ -0,0 +1,16 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Just a standard hash storage. Nothing to see here.
+      #
+      # @see Chewy::Search::Parameters::HashStorage
+      # @see Chewy::Search::Request#collapse
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/collapse-search-results.html
+      class Collapse < Storage
+        include HashStorage
+      end
+    end
+  end
+end

data/lib/chewy/search/parameters/ignore_unavailable.rb

@@ -0,0 +1,27 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Stores boolean value, but has 3 states: `true`, `false` and `nil`.
+      #
+      # @see Chewy::Search::Request#ignore_unavailable
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/multi-index.html#multi-index
+      class IgnoreUnavailable < Storage
+        # We don't want to render `nil`, but render `true` and `false` values.
+        #
+        # @see Chewy::Search::Parameters::Storage#render
+        # @return [{Symbol => Object}, nil]
+        def render
+          {self.class.param_name => value} unless value.nil?
+        end
+
+      private
+
+        def normalize(value)
+          !!value unless value.nil?
+        end
+      end
+    end
+  end
+end

data/lib/chewy/search/parameters/indices.rb

@@ -17,7 +17,7 @@ module Chewy
         # @param other [Chewy::Search::Parameters::Storage] any storage instance
         # @return [true, false] the result of comparison
         def ==(other)
-          super || other.class == self.class && other.render == render
+          super || (other.class == self.class && other.render == render)
         end
 
         # Just adds indices to indices.

data/lib/chewy/search/parameters/knn.rb

@@ -0,0 +1,16 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Just a standard hash storage. Nothing to see here.
+      #
+      # @see Chewy::Search::Parameters::HashStorage
+      # @see Chewy::Search::Request#knn
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/knn-search.html
+      class Knn < Storage
+        include HashStorage
+      end
+    end
+  end
+end

data/lib/chewy/search/parameters/order.rb

@@ -17,7 +17,7 @@ module Chewy
         # @param other_value [Object] any acceptable storage value
         # @return [Object] updated value
         def update!(other_value)
-          value.merge!(normalize(other_value))
+          value.concat(normalize(other_value))
         end
 
         # Size requires specialized rendering logic, it should return
@@ -28,20 +28,7 @@ module Chewy
         def render
           return if value.blank?
 
-          sort = value.map do |(field, options)|
-            options ? {field => options} : field
-          end
-          {sort: sort}
-        end
-
-        # Comparison also reqires additional logic. Hashes are compared
-        # orderlessly, but for `sort` parameter oder is important, so we
-        # compare hash key collections additionally.
-        #
-        # @see Chewy::Search::Parameters::Storage#==
-        # @return [true, false]
-        def ==(other)
-          super && value.keys == other.value.keys
+          {sort: value}
         end
 
       private
@@ -49,13 +36,13 @@ module Chewy
         def normalize(value)
           case value
           when Array
-            value.each_with_object({}) do |sv, res|
-              res.merge!(normalize(sv))
+            value.each_with_object([]) do |sv, res|
+              res.concat(normalize(sv))
             end
           when Hash
-            value.stringify_keys
+            [value.stringify_keys]
           else
-            value.present? ? {value.to_s => nil} : {}
+            value.present? ? [value.to_s] : []
           end
         end
       end

data/lib/chewy/search/parameters/storage.rb

@@ -35,7 +35,7 @@ module Chewy
         # @param other [Chewy::Search::Parameters::Storage] any storage instance
         # @return [true, false] the result of comparision
         def ==(other)
-          super || other.class == self.class && other.value == value
+          super || (other.class == self.class && other.value == value)
         end
 
         # Replaces current value with normalized provided one. Doesn't

data/lib/chewy/search/parameters/track_total_hits.rb

@@ -0,0 +1,16 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Just a standard boolean storage, nothing to see here.
+      #
+      # @see Chewy::Search::Parameters::BoolStorage
+      # @see Chewy::Search::Request#track_total_hits
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-your-data.html#track-total-hits
+      class TrackTotalHits < Storage
+        include BoolStorage
+      end
+    end
+  end
+end

data/lib/chewy/search/parameters.rb

@@ -1,5 +1,5 @@
-Dir.glob(File.join(File.dirname(__FILE__), 'parameters', 'concerns', '*.rb')).sort.each { |f| require f }
-Dir.glob(File.join(File.dirname(__FILE__), 'parameters', '*.rb')).sort.each { |f| require f }
+Dir.glob(File.join(File.dirname(__FILE__), 'parameters', 'concerns', '*.rb')).each { |f| require f }
+Dir.glob(File.join(File.dirname(__FILE__), 'parameters', '*.rb')).each { |f| require f }
 
 module Chewy
   module Search
@@ -10,7 +10,7 @@ module Chewy
     # @see Chewy::Search::Request#parameters
     # @see Chewy::Search::Parameters::Storage
     class Parameters
-      QUERY_STRING_STORAGES = %i[indices search_type request_cache allow_partial_search_results].freeze
+      QUERY_STRING_STORAGES = %i[indices preference search_type request_cache allow_partial_search_results ignore_unavailable].freeze
 
       # Default storage classes warehouse. It is probably possible to
       # add your own classes here if necessary, but I'm not sure it will work.
@@ -53,7 +53,7 @@ module Chewy
       # @param other [Object] any object
       # @return [true, false]
       def ==(other)
-        super || other.is_a?(self.class) && compare_storages(other)
+        super || (other.is_a?(self.class) && compare_storages(other))
       end
 
       # Clones the specified storage, performs the operation

data/lib/chewy/search/request.rb

@@ -18,17 +18,17 @@ module Chewy
       include Scoping
       include Scrolling
       UNDEFINED = Class.new.freeze
-      EVERFIELDS = %w[_index _type _id _parent].freeze
+      EVERFIELDS = %w[_index _type _id _parent _routing].freeze
       DELEGATED_METHODS = %i[
-        query filter post_filter order reorder docvalue_fields
-        track_scores request_cache explain version profile
+        query filter post_filter knn order reorder docvalue_fields
+        track_scores track_total_hits request_cache explain version profile
         search_type preference limit offset terminate_after
         timeout min_score source stored_fields search_after
-        load script_fields suggest aggs aggregations none
+        load script_fields suggest aggs aggregations collapse none
         indices_boost rescore highlight total total_count
         total_entries indices types delete_all count exists?
         exist? find pluck scroll_batches scroll_hits
-        scroll_results scroll_wrappers
+        scroll_results scroll_wrappers ignore_unavailable
       ].to_set.freeze
       DEFAULT_BATCH_SIZE = 1000
       DEFAULT_PLUCK_BATCH_SIZE = 10_000
@@ -41,7 +41,7 @@ module Chewy
       EXTRA_STORAGES = %i[aggs suggest].freeze
       # An array of storage names that are changing the returned hist collection in any way.
       WHERE_STORAGES = %i[
-        query filter post_filter none min_score rescore indices_boost
+        query filter post_filter knn none min_score rescore indices_boost collapse
       ].freeze
 
       delegate :hits, :wrappers, :objects, :records, :documents,
@@ -336,6 +336,19 @@ module Chewy
       #   @param value [true, false]
       #   @return [Chewy::Search::Request]
       #
+      # @!method track_total_hits(value = true)
+      #   Replaces the value of the `track_total_hits` parameter with the provided value.
+      #
+      #   @example
+      #     PlacesIndex.track_total_hits
+      #     # => <PlacesIndex::Query {..., :body=>{:track_total_hits=>true}}>
+      #     PlacesIndex.track_total_hits.track_total_hits(false)
+      #     # => <PlacesIndex::Query {:index=>["places"]}>
+      #   @see Chewy::Search::Parameters::TrackTotalHits
+      #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-your-data.html#track-total-hits
+      #   @param value [true, false]
+      #   @return [Chewy::Search::Request]
+      #
       # @!method explain(value = true)
       #   Replaces the value of the `explain` parameter with the provided value.
       #
@@ -388,7 +401,7 @@ module Chewy
       #   @see https://en.wikipedia.org/wiki/Null_Object_pattern
       #   @param value [true, false]
       #   @return [Chewy::Search::Request]
-      %i[track_scores explain version profile none].each do |name|
+      %i[track_scores track_total_hits explain version profile none].each do |name|
         define_method name do |value = true|
           modify(name) { replace!(value) }
         end
@@ -485,7 +498,40 @@ module Chewy
       #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html#search-api-min-score
       #   @param value [String, Integer, Float]
       #   @return [Chewy::Search::Request]
-      %i[request_cache search_type preference timeout limit offset terminate_after min_score].each do |name|
+      #
+      # @!method ignore_unavailable(value)
+      #   Replaces the value of the `ignore_unavailable` request part.
+      #
+      #   @example
+      #     PlacesIndex.ignore_unavailable(true)
+      #     <PlacesIndex::Query {..., :ignore_unavailable => true, :body=>{ ... }}>
+      #   @see Chewy::Search::Parameters::IgnoreUnavailable
+      #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/multi-index.html#multi-index
+      #   @param value [true, false, nil]
+      #   @return [Chewy::Search::Request]
+      #
+      # @!method collapse(value)
+      #   Replaces the value of the `collapse` request part.
+      #
+      #   @example
+      #     PlacesIndex.collapse(field: :name)
+      #     # => <PlacesIndex::Query {..., :body=>{:collapse=>{"field"=>:name}}}>
+      #   @see Chewy::Search::Parameters::Collapse
+      #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/collapse-search-results.html
+      #   @param value [Hash]
+      #   @return [Chewy::Search::Request]
+      #
+      # @!method knn(value)
+      #   Replaces the value of the `knn` request part.
+      #
+      #   @example
+      #     PlacesIndex.knn(field: :vector, query_vector: [4, 2], k: 5, num_candidates: 50)
+      #     # => <PlacesIndex::Query {..., :body=>{:knn=>{"field"=>:vector, "query_vector"=>[4, 2], "k"=>5, "num_candidates"=>50}}}>
+      #   @see Chewy::Search::Parameters::Knn
+      #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/knn-search.html
+      #   @param value [Hash]
+      #   @return [Chewy::Search::Request]
+      %i[request_cache search_type preference timeout limit offset terminate_after min_score ignore_unavailable collapse knn].each do |name|
         define_method name do |value|
           modify(name) { replace!(value) }
         end
@@ -776,8 +822,8 @@ module Chewy
       # Returns a new scope containing only specified storages.
       #
       # @example
-      #   PlacesIndex.limit(10).offset(10).order(:name).except(:offset, :order)
-      #   # => <PlacesIndex::Query {..., :body=>{:size=>10}}>
+      #   PlacesIndex.limit(10).offset(10).order(:name).only(:offset, :order)
+      #   # => <PlacesIndex::Query {..., :body=>{:from=>10, :sort=>["name"]}}>
       # @param values [Array<String, Symbol>]
       # @return [Chewy::Search::Request] new scope
       def only(*values)
@@ -787,8 +833,8 @@ module Chewy
       # Returns a new scope containing all the storages except specified.
       #
       # @example
-      #   PlacesIndex.limit(10).offset(10).order(:name).only(:offset, :order)
-      #   # => <PlacesIndex::Query {..., :body=>{:from=>10, :sort=>["name"]}}>
+      #   PlacesIndex.limit(10).offset(10).order(:name).except(:offset, :order)
+      #   # => <PlacesIndex::Query {..., :body=>{:size=>10}}>
       # @param values [Array<String, Symbol>]
       # @return [Chewy::Search::Request] new scope
       def except(*values)
@@ -890,7 +936,7 @@ module Chewy
 
       # Returns and array of values for specified fields.
       # Uses `source` to restrict the list of returned fields.
-      # Fields `_id`, `_type` and `_index` are also supported.
+      # Fields `_id`, `_type`, `_routing` and `_index` are also supported.
       #
       # @overload pluck(field)
       #   If single field is passed - it returns and array of values.
@@ -927,10 +973,22 @@ module Chewy
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete-by-query.html
       # @note The result hash is different for different API used.
-      # @param refresh [true, false] field names
+      # @param refresh [true, false] Refreshes all shards involved in the delete by query
+      # @param wait_for_completion [true, false] wait for request completion or run it asynchronously
+      #    and return task reference at `.tasks/task/${taskId}`.
+      # @param requests_per_second [Float] The throttle for this request in sub-requests per second
+      # @param scroll_size [Integer] Size of the scroll request that powers the operation
+
       # @return [Hash] the result of query execution
-      def delete_all(refresh: true)
-        request_body = only(WHERE_STORAGES).render.merge(refresh: refresh)
+      def delete_all(refresh: true, wait_for_completion: nil, requests_per_second: nil, scroll_size: nil)
+        request_body = only(WHERE_STORAGES).render.merge(
+          {
+            refresh: refresh,
+            wait_for_completion: wait_for_completion,
+            requests_per_second: requests_per_second,
+            scroll_size: scroll_size
+          }.compact
+        )
         ActiveSupport::Notifications.instrument 'delete_query.chewy', notification_payload(request: request_body) do
           request_body[:body] = {query: {match_all: {}}} if request_body[:body].empty?
           Chewy.client.delete_by_query(request_body)

data/lib/chewy/search/scoping.rb

@@ -29,7 +29,7 @@ module Chewy
         #
         # @return [Array<Chewy::Search::Request>] array of scopes
         def scopes
-          Thread.current[:chewy_scopes] ||= []
+          Chewy.current[:chewy_scopes] ||= []
         end
       end