chewy 0.10.0 → 6.0.0

data/lib/chewy/index/settings.rb

@@ -4,12 +4,14 @@ module Chewy
     # hash. At first, you need to store some analyzers or other
     # analysis options to the corresponding repository:
     #
+    # @example
     #   Chewy.analyzer :title_analyzer, type: 'custom', filter: %w(lowercase icu_folding title_nysiis)
     #   Chewy.filter :title_nysiis, type: 'phonetic', encoder: 'nysiis', replace: false
     #
     # `title_nysiis` filter here will be expanded automatically when
     # `title_analyzer` analyser will be used in index settings:
     #
+    # @example
     #   class ProductsIndex < Chewy::Index
     #     settings analysis: {
     #       analyzer: [

data/lib/chewy/index/specification.rb

@@ -2,21 +2,21 @@ module Chewy
   class Index
     # Index specification is a combination of index settings and
     # mappings. The idea behind this class is that specification
-    # can be locked in the `Chewy::Stash` between resets, so it is
-    # possible to track changes. In the future it is planned to
-    # be way smarter but right now `rake chewy:deploy` checks
-    # if there were changes and resets the index only if anything
-    # was changed. Otherwise, the index reset is skipped.
+    # can be locked in the `Chewy::Stash::Specification` between
+    # resets, so it is possible to track changes. In the future
+    # it is planned to be way smarter but right now `rake chewy:deploy`
+    # checks if there were changes and resets the index only if
+    # anything was changed. Otherwise, the index reset is skipped.
     #
-    # @see Chewy::Stash
+    # @see Chewy::Stash::Specification
     class Specification
-      # @see Chewy::Index.specification
+      # @see Chewy::Index::Specification
       # @param index [Chewy::Index] Just a chewy index
       def initialize(index)
         @index = index
       end
 
-      # Stores the current index specification to the `Chewy::Stash`
+      # Stores the current index specification to the `Chewy::Stash::Specification`
       # as json.
       #
       # @raise [Chewy::ImportFailed] if something went wrong
@@ -24,7 +24,7 @@ module Chewy
       def lock!
         Chewy::Stash::Specification.import!([
           id: @index.derivable_name,
-          value: current.to_json
+          specification: Base64.encode64(current.to_json)
         ], journal: false)
       end
 
@@ -34,7 +34,9 @@ module Chewy
       # @return [Hash] hash produced with JSON parser
       def locked
         filter = {ids: {values: [@index.derivable_name]}}
-        JSON.parse(Chewy::Stash::Specification.filter(filter).first.try!(:value) || '{}')
+        document = Chewy::Stash::Specification.filter(filter).first
+        return {} unless document
+        JSON.load(Base64.decode64(document.specification)) # rubocop:disable Security/JSONLoad
       end
 
       # Simply returns `Chewy::Index.specification_hash`, but

data/lib/chewy/minitest/helpers.rb

@@ -6,14 +6,14 @@ module Chewy
       extend ActiveSupport::Concern
 
       # Assert that an index *changes* during a block.
-      # @param (Chewy::Type) index the index / type to watch, eg EntitiesIndex::Entity.
-      # @param (Symbol) strategy the Chewy strategy to use around the block. See Chewy docs.
-      # @param (boolean) assert the index changes
-      # @param (boolean) bypass_actual_index
+      # @param index [Chewy::Type] the index / type to watch, eg EntitiesIndex::Entity.
+      # @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.
       #   Should be set to true unless actually testing search functionality.
       #
-      # @return (SearchIndexReceiver) for optional further assertions on the nature of the index changes.
+      # @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
         receiver = SearchIndexReceiver.new
@@ -43,7 +43,7 @@ module Chewy
 
       # Run indexing for the database changes during the block provided.
       # By default, indexing is run at the end of the block.
-      # @param (Symbol) strategy the Chewy index update strategy see Chewy docs.
+      # @param strategy [Symbol] the Chewy index update strategy see Chewy docs.
       def run_indexing(strategy: :atomic)
         Chewy.strategy strategy do
           yield

data/lib/chewy/minitest/search_index_receiver.rb

@@ -1,17 +1,17 @@
 # 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::Type} class. (See SearchTestHelper)
 #
-# 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::Type.bulk method and
 # aggregate the data for test analysis.
 class SearchIndexReceiver
   def initialize
     @mutations = {}
   end
 
-  # @param bulk_params the bulk_params that should be sent to the Chewy::Type#bulk method.
-  # @param (Chewy::Type) type the Index::Type executing this query.
+  # @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)
     Array.wrap(bulk_params).map { |y| y[:body] }.flatten.each do |update|
       if update[:delete]
@@ -22,8 +22,8 @@ class SearchIndexReceiver
     end
   end
 
-  # @param index return only index requests to the specified Chewy::Type index.
-  # @return the index changes captured by the mock.
+  # @param index [Chewy::Index] return only index requests to the specified {Chewy::Type} index.
+  # @return [Hash] the index changes captured by the mock.
   def indexes_for(index = nil)
     if index
       mutation_for(index).indexes
@@ -35,8 +35,8 @@ class SearchIndexReceiver
   end
   alias_method :indexes, :indexes_for
 
-  # @param index return only delete requests to the specified Chewy::Type index.
-  # @return the index deletes captured by the mock.
+  # @param index [Chewy::Index] return only delete requests to the specified {Chewy::Type} index.
+  # @return [Hash] the index deletes captured by the mock.
   def deletes_for(index = nil)
     if index
       mutation_for(index).deletes
@@ -49,22 +49,22 @@ class SearchIndexReceiver
   alias_method :deletes, :deletes_for
 
   # Check to see if a given object has been indexed.
-  # @param (#id) obj the object to look for.
-  # @param Chewy::Type what type the object should be indexed as.
-  # @return bool if the object was indexed.
+  # @param obj [#id] obj the object to look for.
+  # @param type [Chewy::Type] what type the object should be indexed as.
+  # @return [true, false] if the object was indexed.
   def indexed?(obj, type)
     indexes_for(type).map { |i| i[:_id] }.include? obj.id
   end
 
   # Check to see if a given object has been deleted.
-  # @param (#id) obj the object to look for.
-  # @param Chewy::Type what type the object should have been deleted from.
-  # @return bool if the object was deleted.
+  # @param obj [#id] obj the object to look for.
+  # @param type [Chewy::Type] what type 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
   end
 
-  # @return a list of Chewy::Type indexes changed.
+  # @return [Array<Chewy::Type>] a list of types indexes changed.
   def updated_indexes
     @mutations.keys
   end
@@ -72,8 +72,8 @@ class SearchIndexReceiver
 private
 
   # Get the mutation object for a given type.
-  # @param (Chewy::Type) type the index type to fetch.
-  # @return (#indexes, #deletes) an object with a list of indexes and a list of deletes.
+  # @param type [Chewy::Type] the index type 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: [])
   end

data/lib/chewy/multi_search.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Chewy
+  # `Chewy::MultiSearch` provides an interface for executing multiple
+  # queries via the Elasticsearch Multi Search API. When a MultiSearch
+  # is performed it wraps the responses from Elasticsearch and assigns
+  # them to the appropriate queries.
+  class MultiSearch
+    attr_reader :queries
+
+    # Instantiate a new MultiSearch instance.
+    #
+    # @param queries [Array<Chewy::Search::Request>]
+    # @option [Elasticsearch::Transport::Client] :client (Chewy.client)
+    #   The Elasticsearch client that should be used for issuing requests.
+    def initialize(queries, client: Chewy.client)
+      @client = client
+      @queries = Array(queries)
+    end
+
+    # Adds a query to be performed by the MultiSearch
+    #
+    # @param query [Chewy::Search::Request]
+    def add_query(query)
+      @queries << query
+    end
+
+    # Performs any unperformed queries and returns the responses for all queries.
+    #
+    # @return [Array<Chewy::Search::Response>]
+    def responses
+      perform
+      queries.map(&:response)
+    end
+
+    # Performs any unperformed queries.
+    def perform
+      unperformed_queries = queries.reject(&:performed?)
+      return if unperformed_queries.empty?
+
+      responses = msearch(unperformed_queries)['responses']
+      unperformed_queries.zip(responses).map { |query, response| query.response = response }
+    end
+
+  private
+
+    attr_reader :client
+
+    def msearch(queries_to_search)
+      body = queries_to_search.flat_map do |query|
+        rendered = query.render
+        [rendered.except(:body), rendered[:body]]
+      end
+
+      client.msearch(body: body)
+    end
+  end
+
+  def self.msearch(queries)
+    Chewy::MultiSearch.new(queries)
+  end
+end

data/lib/chewy/railtie.rb

@@ -7,7 +7,6 @@ module Chewy
     class RequestStrategy
       def initialize(app)
         @app = app
-        Chewy.logger.debug("Chewy strategies stack: [1] <- #{Chewy.request_strategy}")
       end
 
       def call(env)
@@ -15,6 +14,8 @@ 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
+          @request_strategy = Chewy.request_strategy
           Chewy.strategy(Chewy.request_strategy) { @app.call(env) }
         end
       end
@@ -42,13 +43,12 @@ module Chewy
     end
 
     console do |app|
-      Chewy.logger = ActiveRecord::Base.logger if defined?(ActiveRecord)
-
       if app.sandbox?
         Chewy.strategy(:bypass)
       else
         Chewy.strategy(:urgent)
       end
+      puts "Chewy console strategy is `#{Chewy.strategy.current.name}`"
     end
 
     initializer 'chewy.logger', after: 'active_record.logger' do
@@ -68,7 +68,7 @@ module Chewy
     end
 
     initializer 'chewy.request_strategy' do |app|
-      app.config.middleware.insert_after(Rails::Rack::Logger, RequestStrategy)
+      app.config.middleware.insert_before(ActionDispatch::ShowExceptions, RequestStrategy)
     end
 
     initializer 'chewy.add_indices_path' do |_app|

data/lib/chewy/rake_helper.rb

@@ -1,9 +1,9 @@
 module Chewy
   module RakeHelper
-    IMPORT_CALLBACK = lambda do |output, _name, start, finish, _id, payload| # rubocop:disable Metrics/ParameterLists
+    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]} for #{human_duration(duration)}, stats: #{stats}"
+      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:"
@@ -15,7 +15,7 @@ module Chewy
       end
     end
 
-    JOURNAL_CALLBACK = lambda do |output, _, _, _, _, payload| # rubocop:disable Metrics/ParameterLists
+    JOURNAL_CALLBACK = lambda do |output, _, _, _, _, payload|
       count = payload[:groups].values.map(&:size).sum
       targets = payload[:groups].keys.sort_by(&:derivable_name)
       output.puts "  Applying journal to #{targets}, #{count} entries, stage #{payload[:stage]}"
@@ -196,12 +196,12 @@ module Chewy
       end
 
       # Eager loads and returns all the indexes defined in the application
-      # except the Chewy::Stash.
+      # except Chewy::Stash::Specification and Chewy::Stash::Journal.
       #
       # @return [Array<Chewy::Index>] indexes found
       def all_indexes
         Chewy.eager_load!
-        Chewy::Index.descendants - [Chewy::Stash]
+        Chewy::Index.descendants - [Chewy::Stash::Journal, Chewy::Stash::Specification]
       end
 
       def normalize_indexes(*identifiers)

data/lib/chewy/rspec/update_index.rb

@@ -83,9 +83,7 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
   #     .to update_index(UsersIndex.user).and_reindex(user1).only }
   #
   chain(:only) do |*_args|
-    if @reindex.blank? && @delete.blank?
-      raise 'Use `only` in conjunction with `and_reindex` or `and_delete`'
-    end
+    raise 'Use `only` in conjunction with `and_reindex` or `and_delete`' if @reindex.blank? && @delete.blank?
 
     @only = true
   end
@@ -128,13 +126,13 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
       end
     end
 
-    @reindex.each do |_, document|
+    @reindex.each_value do |document|
       document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
         (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|
+    @delete.each_value do |document|
       document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
         (document[:expected_count] && document[:expected_count] == document[:real_count])
     end

data/lib/chewy/search.rb

@@ -1,5 +1,4 @@
 require 'chewy/search/scoping'
-require 'chewy/query'
 require 'chewy/search/scrolling'
 require 'chewy/search/query_proxy'
 require 'chewy/search/parameters'
@@ -15,9 +14,7 @@ module Chewy
   # {Chewy::Type}.
   #
   # The class used as a request DSL provider is
-  # inherited from {Chewy::Search::Request} by default, but if you
-  # need ES < 2.0 DSL support - you can switch it to {Chewy::Query}
-  # using {Chewy::Config#search_class}
+  # inherited from {Chewy::Search::Request}
   #
   # Also, the search class is refined with one of the pagination-
   # providing modules: {Chewy::Search::Pagination::Kaminari} or
@@ -58,11 +55,7 @@ module Chewy
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-uri-request.html
       # @return [Hash] the request result
       def search_string(query, options = {})
-        options = options.merge(
-          index: all._indexes.map(&:index_name),
-          type: all._types.map(&:type_name),
-          q: query
-        )
+        options = options.merge(all.render.slice(:index, :type).merge(q: query))
         Chewy.client.search(options)
       end
 
@@ -91,12 +84,12 @@ module Chewy
 
       def build_search_class(base)
         search_class = Class.new(base)
+
         if self < Chewy::Type
           index_scopes = index.scopes - scopes
-
           delegate_scoped index, search_class, index_scopes
-          delegate_scoped index, self, index_scopes
         end
+
         delegate_scoped self, search_class, scopes
         const_set('Query', search_class)
       end

data/lib/chewy/search/loader.rb

@@ -52,7 +52,7 @@ module Chewy
 
           type = derive_type(index_name, type_name)
           ids = hit_group.map { |hit| hit['_id'] }
-          loaded = type.adapter.load(ids, @options.merge(_type: type))
+          loaded = type.adapter.load(ids, **@options.merge(_type: type))
           loaded ||= hit_group.map { |hit| type.build(hit) }
 
           result.merge!(hit_group.zip(loaded).to_h)

data/lib/chewy/search/pagination/will_paginate.rb

@@ -20,7 +20,7 @@ module Chewy
           @page_multiplier = @current_page - 1
           @per_page = (options[:per_page] || @per_page || ::WillPaginate.per_page).to_i
 
-          # call Chewy::Query methods to limit results
+          # call Chewy::Search::Request methods to limit results
           limit(@per_page).offset(@page_multiplier * @per_page)
         end
 
@@ -31,7 +31,9 @@ module Chewy
       private
 
         def paginated_collection(collection)
-          ::WillPaginate::Collection.create(current_page, per_page, total_entries) do |pager|
+          page = current_page || 1
+          per = per_page || ::WillPaginate.per_page
+          ::WillPaginate::Collection.create(page, per, total_entries) do |pager|
             pager.replace collection
           end
         end

data/lib/chewy/search/parameters.rb

@@ -10,6 +10,8 @@ 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
+
       # Default storage classes warehouse. It is probably possible to
       # add your own classes here if necessary, but I'm not sure it will work.
       #
@@ -33,10 +35,11 @@ module Chewy
       #     limit: Chewy::Search::Parameters::Offset.new(10)
       #   )
       # @param initial [{Symbol => Object, Chewy::Search::Parameters::Storage}]
-      def initialize(initial = {})
+      def initialize(initial = {}, **kinitial)
         @storages = Hash.new do |hash, name|
           hash[name] = self.class.storages[name].new
         end
+        initial = initial.deep_dup.merge(kinitial)
         initial.each_with_object(@storages) do |(name, value), result|
           storage_class = self.class.storages[name]
           storage = value.is_a?(storage_class) ? value : storage_class.new(value)
@@ -101,11 +104,7 @@ module Chewy
       #
       # @return [Hash] request body
       def render
-        body = @storages.except(:filter, :query, :none).values.inject({}) do |result, storage|
-          result.merge!(storage.render || {})
-        end
-        body.merge!(render_query || {})
-        body.present? ? {body: body} : {}
+        render_query_string_params.merge(render_body)
       end
 
     protected
@@ -126,6 +125,25 @@ module Chewy
         names
       end
 
+      def render_query_string_params
+        query_string_storages = @storages.select do |storage_name, _|
+          QUERY_STRING_STORAGES.include?(storage_name)
+        end
+
+        query_string_storages.values.inject({}) do |result, storage|
+          result.merge!(storage.render || {})
+        end
+      end
+
+      def render_body
+        exceptions = %i[filter query none] + QUERY_STRING_STORAGES
+        body = @storages.except(*exceptions).values.inject({}) do |result, storage|
+          result.merge!(storage.render || {})
+        end
+        body.merge!(render_query || {})
+        {body: body}
+      end
+
       def render_query
         none = @storages[:none].render