chewy 0.8.4 → 7.3.4

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,58 +1,57 @@
-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 = {}|
-
+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 :failure_message :failure_message_for_should
-    alias :failure_message_when_negated :failure_message_for_should_not
+    alias_method :failure_message, :failure_message_for_should
+    alias_method :failure_message_when_negated, :failure_message_for_should_not
   end
 
   # 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'}) }
   #
@@ -63,8 +62,8 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
 
   # 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 ||= {}
@@ -74,84 +73,89 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
   # 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|
+  chain(:only) do |*_args|
+    raise 'Use `only` in conjunction with `and_reindex` or `and_delete`' if @reindex.blank? && @delete.blank?
+
     @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|
+  match do |block| # rubocop:disable Metrics/BlockLength
     @reindex ||= {}
     @delete ||= {}
     @missed_reindex = []
     @missed_delete = []
-    @updated = []
-
-    type = Chewy.derive_type(type_name)
 
-    instance_eval <<-RUBY, __FILE__, __LINE__ + 1
-       #{agnostic_stub} do |bulk_options|
-        @updated += bulk_options[:body].map do |updated_document|
-          updated_document.deep_symbolize_keys
-        end
-        {}
-      end
-    RUBY
+    index = Chewy.derive_name(index_name)
+    if defined?(Mocha) && RSpec.configuration.mock_framework.to_s == 'RSpec::Core::MockingAdapters::Mocha'
+      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)
+      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
 
-    ActiveSupport::Deprecation.warn('`atomic: false` option is removed and not effective anymore, use `strategy: :atomic` option instead') if options.key?(:atomic)
     Chewy.strategy(options[:strategy] || :atomic) { block.call }
 
-    @updated.each do |updated_document|
-      if body = updated_document[:index]
-        if document = @reindex[body[:_id].to_s]
+    mock_bulk_request.updates.each do |updated_document|
+      if (body = updated_document[:index])
+        if (document = @reindex[body[:_id].to_s])
           document[:real_count] += 1
           document[:real_attributes].merge!(body[:data])
-        else
-          @missed_reindex.push(body[:_id].to_s) if @only
+        elsif @only
+          @missed_reindex.push(body[:_id].to_s)
         end
-      elsif body = updated_document[:delete]
-        if document = @delete[body[:_id].to_s]
+      elsif (body = updated_document[:delete])
+        if (document = @delete[body[:_id].to_s])
           document[:real_count] += 1
-        else
-          @missed_delete.push(body[:_id].to_s) if @only
+        elsif @only
+          @missed_delete.push(body[:_id].to_s)
         end
       end
     end
 
-    @reindex.each do |_, document|
-      document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
+    @reindex.each_value do |document|
+      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 do |_, document|
-      document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
+    @delete.each_value do |document|
+      document[:match_count] = (!document[:expected_count] && (document[:real_count]).positive?) ||
         (document[:expected_count] && document[:expected_count] == document[:real_count])
     end
 
-    @updated.present? && @missed_reindex.none? && @missed_delete.none? &&
-    @reindex.all? { |_, document| document[:match_count] && document[:match_attributes] } &&
-    @delete.all? { |_, document| document[:match_count] }
+    mock_bulk_request.updates.present? && @missed_reindex.none? && @missed_delete.none? &&
+      @reindex.all? { |_, document| document[:match_count] && document[:match_attributes] } &&
+      @delete.all? { |_, document| document[:match_count] }
   end
 
-  failure_message do
+  failure_message do # rubocop:disable Metrics/BlockLength
     output = ''
 
-    if @updated.none?
-      output << "Expected index `#{type_name}` to be updated, but it was not\n"
+    if mock_bulk_request.updates.none?
+      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,28 +170,32 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
       output << message
     end
 
-    output << @reindex.each.with_object('') do |(id, document), output|
+    output << @reindex.each.with_object('') do |(id, document), result|
       unless document[:match_count] && document[:match_attributes]
-        output << "Expected document with id `#{id}` to be reindexed"
-        if document[:real_count] > 0
-          output << "\n   #{document[:expected_count]} times, but was reindexed #{document[:real_count]} times" if document[:expected_count] && !document[:match_count]
-          output << "\n   with #{document[:expected_attributes]}, but it was reindexed with #{document[:real_attributes]}" if document[:expected_attributes].present? && !document[:match_attributes]
+        result << "Expected document with id `#{id}` to be reindexed"
+        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
-          output << ", but it was not"
+          result << ', but it was not'
         end
-        output << "\n"
+        result << "\n"
       end
     end
 
-    output << @delete.each.with_object('') do |(id, document), output|
+    output << @delete.each.with_object('') do |(id, document), result|
       unless document[:match_count]
-        output << "Expected document with id `#{id}` to be deleted"
-        if document[:real_count] > 0 && document[:expected_count] && !document[:match_count]
-          output << "\n   #{document[:expected_count]} times, but was deleted #{document[:real_count]} times"
+        result << "Expected document with id `#{id}` to be deleted"
+        result << if (document[:real_count]).positive? && document[:expected_count]
+          "\n   #{document[:expected_count]} times, but was deleted #{document[:real_count]} times"
         else
-          output << ", but it was not"
+          ', but it was not'
         end
-        output << "\n"
+        result << "\n"
       end
     end
 
@@ -195,30 +203,24 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
   end
 
   failure_message_when_negated do
-    if @updated.present?
-      "Expected index `#{type_name}` not to be updated, but it was with #{
-        @updated.map(&:values).flatten.group_by { |documents| documents[:_id] }.map do |id, documents|
-          "\n  document id `#{id}` (#{documents.count} times)"
-        end.join
-      }\n"
+    if mock_bulk_request.updates.present?
+      "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
 
-  def agnostic_stub
-    if defined?(Mocha) && RSpec.configuration.mock_framework.to_s == 'RSpec::Core::MockingAdapters::Mocha'
-      "type.stubs(:bulk).with"
-    else
-      "allow(type).to receive(:bulk)"
-    end
+  def mock_bulk_request
+    @mock_bulk_request ||= MockBulkRequest.new
   end
 
-  def extract_documents *args
+  def extract_documents(*args)
     options = args.extract_options!
 
     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,
@@ -227,10 +229,10 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
         real_count: 0,
         real_attributes: {}
       }]
-    end]
+    end.to_h
   end
 
-  def compare_attributes expected, real
+  def compare_attributes(expected, real)
     expected.inject(true) do |result, (key, value)|
       equal = if value.is_a?(Array) && real[key].is_a?(Array)
         array_difference(value, real[key]) && array_difference(real[key], value)
@@ -243,13 +245,27 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     end
   end
 
-  def array_difference first, second
+  def array_difference(first, second)
     difference = first.to_ary.dup
     second.to_ary.each do |element|
-      if index = difference.index(element)
-        difference.delete_at(index)
-      end
+      index = difference.index(element)
+      difference.delete_at(index) if index
     end
     difference.none?
   end
+
+  # Collects request bodies coming through the perform method for
+  # the further analysis.
+  class MockBulkRequest
+    attr_reader :updates
+
+    def initialize
+      @updates = []
+    end
+
+    def perform(body)
+      @updates.concat(body.map(&:deep_symbolize_keys))
+      []
+    end
+  end
 end

data/lib/chewy/rspec.rb

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

data/lib/chewy/runtime/version.rb

@@ -4,21 +4,21 @@ module Chewy
       include Comparable
       attr_reader :major, :minor, :patch
 
-      def initialize version
-        @major, @minor, @patch = *(version.to_s.split('.', 3) + [0]*3).first(3).map(&:to_i)
+      def initialize(version)
+        @major, @minor, @patch = *(version.to_s.split('.', 3) + [0] * 3).first(3).map(&:to_i)
       end
 
       def to_s
         [major, minor, patch].join('.')
       end
 
-      def <=> other
+      def <=>(other)
         other = self.class.new(other) unless other.is_a?(self.class)
         [
           major <=> other.major,
           minor <=> other.minor,
           patch <=> other.patch
-        ].detect { |c| c != 0 } || 0
+        ].detect(&:nonzero?) || 0
       end
     end
   end

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

@@ -0,0 +1,61 @@
+module Chewy
+  module Search
+    # This class is used for two different purposes: load ORM/ODM
+    # source objects.
+    #
+    # @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
+      # @param options [Hash] adapter-specific load options
+      # @see Chewy::Index::Adapter::Base#load
+      def initialize(indexes: [], **options)
+        @indexes = indexes
+        @options = options
+      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
+      # using `hit['_id']`. The returned array is exactly in the same order
+      # as hits were. If source object was not found for some hit, `nil`
+      # will be returned at the corresponding position in array.
+      #
+      # Records/documents are loaded in an efficient manner, performing
+      # 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'] }
+        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 = 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
+
+        hits.map { |hit| loaded_objects[hit] }
+      end
+
+    private
+
+      def indexes_hash
+        @indexes_hash ||= @indexes.index_by(&:index_name)
+      end
+    end
+  end
+end

data/lib/chewy/{query → search}/pagination/kaminari.rb

@@ -1,6 +1,12 @@
 module Chewy
-  class Query
+  module Search
     module Pagination
+      # This module provides `Kaminari` support for {Chewy::Search::Request}
+      # It is included automatically if `Kaminari` is available.
+      #
+      # @example
+      #   PlacesIndex.all.page(3).per(10).order(:name)
+      #   # => <PlacesIndex::Query {..., :body=>{:size=>10, :from=>20, :sort=>["name"]}}>
       module Kaminari
         extend ActiveSupport::Concern
 
@@ -17,11 +23,11 @@ module Chewy
         end
 
         def limit_value
-          (criteria.request_options[:size].presence || default_per_page).to_i
+          (raw_limit_value || default_per_page).to_i
         end
 
         def offset_value
-          criteria.request_options[:from].to_i
+          raw_offset_value.to_i
         end
 
       private
@@ -29,9 +35,11 @@ module Chewy
         def _kaminari_config
           ::Kaminari.config
         end
+
+        def paginated_collection(collection)
+          ::Kaminari.paginate_array(collection, limit: limit_value, offset: offset_value, total_count: total_count)
+        end
       end
     end
   end
 end
-
-Chewy::Query.send :include, Chewy::Query::Pagination::Kaminari

data/lib/chewy/search/parameters/aggs.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#aggregations
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations.html
+      class Aggs < Storage
+        include HashStorage
+      end
+    end
+  end
+end

data/lib/chewy/search/parameters/allow_partial_search_results.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#allow_partial_search_results
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/6.4/search-request-body.html#_parameters_4
+      class AllowPartialSearchResults < 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/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/bool_storage.rb

@@ -0,0 +1,24 @@
+module Chewy
+  module Search
+    class Parameters
+      # Stores a boolean value. Any passed value is coerced to
+      # a boolean value.
+      module BoolStorage
+        # Performs values disjunction on update.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [true, false, Object] any acceptable storage value
+        # @return [true, false] updated value
+        def update!(other_value)
+          replace!(value || normalize(other_value))
+        end
+
+      private
+
+        def normalize(value)
+          !!value
+        end
+      end
+    end
+  end
+end

data/lib/chewy/search/parameters/concerns/hash_storage.rb

@@ -0,0 +1,23 @@
+module Chewy
+  module Search
+    class Parameters
+      # Stores hashes with stringified keys.
+      module HashStorage
+        # Simply merges two value hashes on update
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [{String, Symbol => Object}] any acceptable storage value
+        # @return [{String => Object}] updated value
+        def update!(other_value)
+          value.merge!(normalize(other_value))
+        end
+
+      private
+
+        def normalize(value)
+          (value || {}).stringify_keys
+        end
+      end
+    end
+  end
+end