chewy 5.1.0 → 7.2.7

data/lib/chewy/rspec/update_index.rb

@@ -1,26 +1,26 @@
-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`
-# Simple usage - just pass type as argument.
+# Simple usage - just pass index as argument.
 #
-#   specify { expect { user.save! }.to update_index(UsersIndex::User) }
-#   specify { expect { user.save! }.to update_index('users#user') }
-#   specify { expect { user.save! }.not_to update_index('users#user') }
+#   specify { expect { user.save! }.to update_index(UsersIndex) }
+#   specify { expect { user.save! }.to update_index('users') }
+#   specify { expect { user.save! }.not_to update_index('users') }
 #
 # This example will pass as well because user1 was reindexed
 # and nothing was said about user2:
 #
 #   specify { expect { [user1, user2].map(&:save!) }
-#     .to update_index(UsersIndex.user).and_reindex(user1) }
+#     .to update_index(UsersIndex).and_reindex(user1) }
 #
 # If you need to specify reindexed records strictly - use `only` chain.
 # Combined matcher chain methods:
 #
 #   specify { expect { user1.destroy!; user2.save! } }
-#     .to update_index(UsersIndex::User).and_reindex(user2).and_delete(user1) }
+#     .to update_index(UsersIndex).and_reindex(user2).and_delete(user1) }
 #
-RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disable BlockLength
+RSpec::Matchers.define :update_index do |index_name, options = {}| # rubocop:disable Metrics/BlockLength
   if !respond_to?(:failure_message) && respond_to?(:failure_message_for_should)
     alias_method :failure_message, :failure_message_for_should
     alias_method :failure_message_when_negated, :failure_message_for_should_not
@@ -28,30 +28,30 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
 
   # Specify indexed records by passing record itself or id.
   #
-  #   specify { expect { user.save! }.to update_index(UsersIndex::User).and_reindex(user)
-  #   specify { expect { user.save! }.to update_index(UsersIndex::User).and_reindex(42)
+  #   specify { expect { user.save! }.to update_index(UsersIndex).and_reindex(user)
+  #   specify { expect { user.save! }.to update_index(UsersIndex).and_reindex(42)
   #   specify { expect { [user1, user2].map(&:save!) }
-  #     .to update_index(UsersIndex::User).and_reindex(user1, user2) }
+  #     .to update_index(UsersIndex).and_reindex(user1, user2) }
   #   specify { expect { [user1, user2].map(&:save!) }
-  #     .to update_index(UsersIndex::User).and_reindex(user1).and_reindex(user2) }
+  #     .to update_index(UsersIndex).and_reindex(user1).and_reindex(user2) }
   #
   # Specify indexing count for every particular record. Useful in case
   # urgent index updates.
   #
   #   specify { expect { 2.times { user.save! } }
-  #     .to update_index(UsersIndex::User).and_reindex(user, times: 2) }
+  #     .to update_index(UsersIndex).and_reindex(user, times: 2) }
   #
   # Specify reindexed attributes. Note that arrays are
   # compared position-independently.
   #
   #   specify { expect { user.update_attributes!(name: 'Duke') }
-  #     .to update_index(UsersIndex.user).and_reindex(user, with: {name: 'Duke'}) }
+  #     .to update_index(UsersIndex).and_reindex(user, with: {name: 'Duke'}) }
   #
   # You can combine all the options and chain `and_reindex` method to
   # specify options for every indexed record:
   #
   #   specify { expect { 2.times { [user1, user2].map { |u| u.update_attributes!(name: "Duke#{u.id}") } } }
-  #     .to update_index(UsersIndex.user)
+  #     .to update_index(UsersIndex)
   #     .and_reindex(user1, with: {name: 'Duke42'}) }
   #     .and_reindex(user2, times: 1, with: {name: 'Duke43'}) }
   #
@@ -62,8 +62,8 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
 
   # Specify deleted records with record itself or id passed.
   #
-  #   specify { expect { user.destroy! }.to update_index(UsersIndex::User).and_delete(user) }
-  #   specify { expect { user.destroy! }.to update_index(UsersIndex::User).and_delete(user.id) }
+  #   specify { expect { user.destroy! }.to update_index(UsersIndex).and_delete(user) }
+  #   specify { expect { user.destroy! }.to update_index(UsersIndex).and_delete(user.id) }
   #
   chain(:and_delete) do |*args|
     @delete ||= {}
@@ -73,14 +73,14 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
   # Used for specifying than no other records would be indexed or deleted:
   #
   #   specify { expect { [user1, user2].map(&:save!) }
-  #     .to update_index(UsersIndex.user).and_reindex(user1, user2).only }
+  #     .to update_index(UsersIndex).and_reindex(user1, user2).only }
   #   specify { expect { [user1, user2].map(&:destroy!) }
-  #     .to update_index(UsersIndex.user).and_delete(user1, user2).only }
+  #     .to update_index(UsersIndex).and_delete(user1, user2).only }
   #
   # This example will fail:
   #
   #   specify { expect { [user1, user2].map(&:save!) }
-  #     .to update_index(UsersIndex.user).and_reindex(user1).only }
+  #     .to update_index(UsersIndex).and_reindex(user1).only }
   #
   chain(:only) do |*_args|
     raise 'Use `only` in conjunction with `and_reindex` or `and_delete`' if @reindex.blank? && @delete.blank?
@@ -88,23 +88,30 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
     @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
 
-  match do |block| # rubocop:disable BlockLength
+  match do |block| # rubocop:disable Metrics/BlockLength
     @reindex ||= {}
     @delete ||= {}
     @missed_reindex = []
     @missed_delete = []
 
-    type = Chewy.derive_type(type_name)
+    index = Chewy.derive_name(index_name)
     if defined?(Mocha) && RSpec.configuration.mock_framework.to_s == 'RSpec::Core::MockingAdapters::Mocha'
-      Chewy::Type::Import::BulkRequest.stubs(:new).with(type, 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::Type::Import::BulkRequest).method_double_if_exists_for_message(:new)
-      allow(Chewy::Type::Import::BulkRequest).to receive(:new).and_call_original unless mocked_already
-      allow(Chewy::Type::Import::BulkRequest).to receive(:new).with(type, any_args).and_return(mock_bulk_request)
+      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
+      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 }
@@ -127,13 +134,13 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
     end
 
     @reindex.each_value do |document|
-      document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
+      document[:match_count] = (!document[:expected_count] && (document[:real_count]).positive?) ||
         (document[:expected_count] && document[:expected_count] == document[:real_count])
       document[:match_attributes] = document[:expected_attributes].blank? ||
         compare_attributes(document[:expected_attributes], document[:real_attributes])
     end
     @delete.each_value do |document|
-      document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
+      document[:match_count] = (!document[:expected_count] && (document[:real_count]).positive?) ||
         (document[:expected_count] && document[:expected_count] == document[:real_count])
     end
 
@@ -142,13 +149,13 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
       @delete.all? { |_, document| document[:match_count] }
   end
 
-  failure_message do # rubocop:disable BlockLength
+  failure_message do # rubocop:disable Metrics/BlockLength
     output = ''
 
     if mock_bulk_request.updates.none?
-      output << "Expected index `#{type_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 `#{type_name}` "
+      message = "Expected index `#{index_name}` "
       message << [
         ("to update documents #{@reindex.keys}" if @reindex.present?),
         ("to delete documents #{@delete.keys}" if @delete.present?)
@@ -166,9 +173,13 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
     output << @reindex.each.with_object('') do |(id, document), result|
       unless document[:match_count] && document[:match_attributes]
         result << "Expected document with id `#{id}` to be reindexed"
-        if document[:real_count] > 0
-          result << "\n   #{document[:expected_count]} times, but was reindexed #{document[:real_count]} times" if document[:expected_count] && !document[:match_count]
-          result << "\n   with #{document[:expected_attributes]}, but it was reindexed with #{document[:real_attributes]}" if document[:expected_attributes].present? && !document[:match_attributes]
+        if (document[:real_count]).positive?
+          if document[:expected_count] && !document[:match_count]
+            result << "\n   #{document[:expected_count]} times, but was reindexed #{document[:real_count]} times"
+          end
+          if document[:expected_attributes].present? && !document[:match_attributes]
+            result << "\n   with #{document[:expected_attributes]}, but it was reindexed with #{document[:real_attributes]}"
+          end
         else
           result << ', but it was not'
         end
@@ -179,11 +190,11 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
     output << @delete.each.with_object('') do |(id, document), result|
       unless document[:match_count]
         result << "Expected document with id `#{id}` to be deleted"
-        result << if document[:real_count] > 0 && document[:expected_count]
-                    "\n   #{document[:expected_count]} times, but was deleted #{document[:real_count]} times"
-                  else
-                    ', but it was not'
-                  end
+        result << if (document[:real_count]).positive? && document[:expected_count]
+          "\n   #{document[:expected_count]} times, but was deleted #{document[:real_count]} times"
+        else
+          ', but it was not'
+        end
         result << "\n"
       end
     end
@@ -193,9 +204,9 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
 
   failure_message_when_negated do
     if mock_bulk_request.updates.present?
-      "Expected index `#{type_name}` not to be updated, but it was with #{mock_bulk_request.updates.map(&:values).flatten.group_by { |documents| documents[:_id] }.map do |id, documents|
-                                                                            "\n  document id `#{id}` (#{documents.count} times)"
-                                                                          end.join}\n"
+      "Expected index `#{index_name}` not to be updated, but it was with #{mock_bulk_request.updates.map(&:values).flatten.group_by { |documents| documents[:_id] }.map do |id, documents|
+                                                                             "\n  document id `#{id}` (#{documents.count} times)"
+                                                                           end.join}\n"
     end
   end
 
@@ -209,7 +220,7 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
     expected_count = options[:times] || options[:count]
     expected_attributes = (options[:with] || options[:attributes] || {}).deep_symbolize_keys
 
-    Hash[args.flatten.map do |document|
+    args.flatten.map do |document|
       id = document.respond_to?(:id) ? document.id.to_s : document.to_s
       [id, {
         document: document,
@@ -218,7 +229,7 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
         real_count: 0,
         real_attributes: {}
       }]
-    end]
+    end.to_h
   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.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/loader.rb

@@ -3,36 +3,28 @@ module Chewy
     # This class is used for two different purposes: load ORM/ODM
     # source objects.
     #
-    # @see Chewy::Type::Import
+    # @see Chewy::Index::Import
     # @see Chewy::Search::Request#load
     # @see Chewy::Search::Response#objects
     # @see Chewy::Search::Scrolling#scroll_objects
     class Loader
-      # @param indexes [Array<Chewy::Index>] list of indexes to lookup types
-      # @param only [Array<String, Symbol>] list of selected type names to load
-      # @param except [Array<String, Symbol>] list of type names which will not be loaded
+      # @param indexes [Array<Chewy::Index>] list of indexes to lookup
       # @param options [Hash] adapter-specific load options
-      # @see Chewy::Type::Adapter::Base#load
-      def initialize(indexes: [], only: [], except: [], **options)
+      # @see Chewy::Index::Adapter::Base#load
+      def initialize(indexes: [], **options)
         @indexes = indexes
-        @only = Array.wrap(only).map(&:to_s)
-        @except = Array.wrap(except).map(&:to_s)
         @options = options
       end
 
-      # Returns a {Chewy::Type} object for index name and type name passed. Caches
-      # the result for each pair to make lookup faster.
-      #
-      # @param index [String] index name
-      # @param type [String] type name
-      # @return [Chewy::Type]
-      # @raise [Chewy::UnderivableType] when index or hash were not found
-      def derive_type(index, type)
-        (@derive_type ||= {})[[index, type]] ||= begin
-          index_class = derive_index(index)
-          raise Chewy::UnderivableType, "Can not find index named `#{index}`" unless index_class
-          index_class.type_hash[type] or raise Chewy::UnderivableType, "Index `#{index}` doesn`t have type named `#{type}`"
-        end
+      def derive_index(index_name)
+        index = (@derive_index ||= {})[index_name] ||= indexes_hash[index_name] ||
+          indexes_hash[indexes_hash.keys.sort_by(&:length)
+            .reverse.detect do |name|
+                         index_name.match(/#{name}(_.+|\z)/)
+                       end]
+        raise Chewy::UndefinedIndex, "Can not find index named `#{index}`" unless index
+
+        index
       end
 
       # For each passed hit this method loads an ORM/ORD source object
@@ -41,19 +33,17 @@ module Chewy
       # will be returned at the corresponding position in array.
       #
       # Records/documents are loaded in an efficient manner, performing
-      # a single query for each type present.
+      # a single query for each index present.
       #
       # @param hits [Array<Hash>] ES hits array
       # @return [Array<Object, nil>] the array of corresponding ORM/ODM objects
       def load(hits)
-        hit_groups = hits.group_by { |hit| [hit['_index'], hit['_type']] }
-        loaded_objects = hit_groups.each_with_object({}) do |((index_name, type_name), hit_group), result|
-          next if skip_type?(type_name)
-
-          type = derive_type(index_name, type_name)
+        hit_groups = hits.group_by { |hit| hit['_index'] }
+        loaded_objects = hit_groups.each_with_object({}) do |(index_name, hit_group), result|
+          index = derive_index(index_name)
           ids = hit_group.map { |hit| hit['_id'] }
-          loaded = type.adapter.load(ids, @options.merge(_type: type))
-          loaded ||= hit_group.map { |hit| type.build(hit) }
+          loaded = index.adapter.load(ids, **@options.merge(_index: index.base_name))
+          loaded ||= hit_group.map { |hit| index.build(hit) }
 
           result.merge!(hit_group.zip(loaded).to_h)
         end
@@ -63,21 +53,9 @@ module Chewy
 
     private
 
-      def derive_index(index_name)
-        (@derive_index ||= {})[index_name] ||= indexes_hash[index_name] ||
-          indexes_hash[indexes_hash.keys.sort_by(&:length)
-            .reverse.detect do |name|
-              index_name.match(/#{name}(_.+|\z)/)
-            end]
-      end
-
       def indexes_hash
         @indexes_hash ||= @indexes.index_by(&:index_name)
       end
-
-      def skip_type?(type_name)
-        @except.include?(type_name) || @only.present? && !@only.include?(type_name)
-      end
     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/concerns/query_storage.rb

@@ -5,7 +5,7 @@ module Chewy
     class Parameters
       # This is a basic storage implementation for `query`, `filter`
       # and `post_filter` storages. It uses `bool` query as a root
-      # structure for each of them. The `bool` root is ommited on
+      # structure for each of them. The `bool` root is omitted on
       # rendering if there is only a single query in the `must` or
       # `should` array. Besides the standard parameter storage
       # capabilities, it provides specialized methods for the `bool`
@@ -86,7 +86,7 @@ module Chewy
           def reduce
             value = to_h
               .reject { |_, v| v.blank? }
-              .map { |k, v| [k, v.is_a?(Array) && v.one? ? v.first : v] }.to_h
+              .transform_values { |v| v.is_a?(Array) && v.one? ? v.first : v }
             value.delete(:minimum_should_match) if should.empty?
             value
           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

@@ -3,70 +3,48 @@ require 'chewy/search/parameters/storage'
 module Chewy
   module Search
     class Parameters
-      # Stores indices and/or types to query.
+      # Stores indices to query.
       # Renders it to lists of string accepted by ElasticSearch
       # API.
       #
-      # The semantics behind it can be described in the
-      # following statements:
-      # 1. If index is added to the storage, no matter, a class
+      # If index is added to the storage, no matter, a class
       # or a string/symbol, it gets appended to the list.
-      # 2. If type is added to the storage, it filters out types
-      # assigned via indices.
-      # 3. But when a type class with non-existing index is added,
-      # this index got also added to the list if indices.
-      # 4. In cases when of an index identifier added, type
-      # indetifiers also got appended instead of filtering.
       class Indices < Storage
         # Two index storages are equal if they produce the
         # same output on render.
         #
         # @see Chewy::Search::Parameters::Storage#==
         # @param other [Chewy::Search::Parameters::Storage] any storage instance
-        # @return [true, false] the result of comparision
+        # @return [true, false] the result of comparison
         def ==(other)
           super || other.class == self.class && other.render == render
         end
 
-        # Just adds types to types and indices to indices.
+        # Just adds indices to indices.
         #
         # @see Chewy::Search::Parameters::Storage#update!
-        # @param other_value [{Symbol => Array<Chewy::Index, Chewy::Type, String, Symbol>}] any acceptable storage value
-        # @return [{Symbol => Array<Chewy::Index, Chewy::Type, String, Symbol>}] updated value
+        # @param other_value [{Symbol => Array<Chewy::Index, String, Symbol>}] any acceptable storage value
+        # @return [{Symbol => Array<Chewy::Index, String, Symbol>}] updated value
         def update!(other_value)
           new_value = normalize(other_value)
 
-          @value = {
-            indices: value[:indices] | new_value[:indices],
-            types: value[:types] | new_value[:types]
-          }
+          @value = {indices: value[:indices] | new_value[:indices]}
         end
 
-        # Returns desired index and type names.
+        # Returns desired index names.
         #
         # @see Chewy::Search::Parameters::Storage#render
         # @return [{Symbol => Array<String>}] rendered value with the parameter name
         def render
-          {
-            index: index_names.uniq.sort,
-            type: type_names.uniq.sort
-          }.reject { |_, v| v.blank? }
+          {index: index_names.uniq.sort}.reject { |_, v| v.blank? }
         end
 
         # Returns index classes used for the request.
-        # No strings/symbos included.
+        # No strings/symbols included.
         #
         # @return [Array<Chewy::Index>] a list of index classes
         def indices
-          index_classes | type_classes.map(&:index)
-        end
-
-        # Returns type classes used for the request.
-        # No strings/symbos included.
-        #
-        # @return [Array<Chewy::Type>] a list of types classes
-        def types
-          type_classes | (index_classes - type_classes.map(&:index)).flat_map(&:types)
+          index_classes
         end
 
       private
@@ -78,10 +56,7 @@ module Chewy
         def normalize(value)
           value ||= {}
 
-          {
-            indices: Array.wrap(value[:indices]).flatten.compact,
-            types: Array.wrap(value[:types]).flatten.compact
-          }
+          {indices: Array.wrap(value[:indices]).flatten.compact}
         end
 
         def index_classes
@@ -97,26 +72,6 @@ module Chewy
         def index_names
           indices.map(&:index_name) | index_identifiers.map(&:to_s)
         end
-
-        def type_classes
-          value[:types].select do |klass|
-            klass.is_a?(Class) && klass < Chewy::Type
-          end
-        end
-
-        def type_identifiers
-          value[:types] - type_classes
-        end
-
-        def type_names
-          type_names = types.map(&:type_name)
-
-          if index_identifiers.blank? && type_identifiers.present?
-            (type_names & type_identifiers.map(&:to_s)).presence || type_names
-          else
-            type_names | type_identifiers.map(&:to_s)
-          end
-        end
       end
     end
   end

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

@@ -12,14 +12,12 @@ module Chewy
         include BoolStorage
 
         # Renders `match_none` query if the values is set to true.
-        # Well, we can't really use match none because we need to support
-        # ES2, so we are simulating it with `match_all` negation.
         #
         # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-all-query.html#query-dsl-match-none-query
         # @see Chewy::Search::Request
         # @see Chewy::Search::Request#response
         def render
-          {query: {bool: {filter: {bool: {must_not: {match_all: {}}}}}}} if value.present?
+          {query: {match_none: {}}} if value.present?
         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/source.rb

@@ -17,7 +17,11 @@ module Chewy
         # In case of hash, respective values are concatenated as well.
         #
         # @see Chewy::Search::Parameters::Storage#update!
-        # @param other_value [true, false, {Symbol => Array<String, Symbol>, String, Symbol}, Array<String, Symbol>, String, Symbol] any acceptable storage value
+        # @param other_value
+        #   [true, false, {
+        #     Symbol => Array<String, Symbol>, String, Symbol},
+        #     Array<String, Symbol>, String, Symbol
+        #   ] any acceptable storage value
         # @return [{Symbol => Array<String>, true, false}] updated value
         def update!(other_value)
           new_value = normalize(other_value)

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