chewy 5.0.0 → 7.1.0

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
 

data/lib/chewy/search/loader.rb

@@ -9,14 +9,10 @@ module Chewy
     # @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 options [Hash] adapter-specific load options
       # @see Chewy::Type::Adapter::Base#load
-      def initialize(indexes: [], only: [], except: [], **options)
+      def initialize(indexes: [], **options)
         @indexes = indexes
-        @only = Array.wrap(only).map(&:to_s)
-        @except = Array.wrap(except).map(&:to_s)
         @options = options
       end
 
@@ -31,7 +27,7 @@ module Chewy
         (@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}`"
+          index_class.type_hash.values.first
         end
       end
 
@@ -48,11 +44,9 @@ module Chewy
       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)
           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)
@@ -74,10 +68,6 @@ module Chewy
       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/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
 

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
 

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/indices.rb

@@ -0,0 +1,78 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Stores indices to query.
+      # Renders it to lists of string accepted by ElasticSearch
+      # API.
+      #
+      # If index is added to the storage, no matter, a class
+      # or a string/symbol, it gets appended to the list.
+      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 comparison
+        def ==(other)
+          super || other.class == self.class && other.render == render
+        end
+
+        # Just adds indices to indices.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @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]}
+        end
+
+        # 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}.reject { |_, v| v.blank? }
+        end
+
+        # Returns index classes used for the request.
+        # No strings/symbols included.
+        #
+        # @return [Array<Chewy::Index>] a list of index classes
+        def indices
+          index_classes
+        end
+
+      private
+
+        def initialize_clone(origin)
+          @value = origin.value.dup
+        end
+
+        def normalize(value)
+          value ||= {}
+
+          {indices: Array.wrap(value[:indices]).flatten.compact}
+        end
+
+        def index_classes
+          value[:indices].select do |klass|
+            klass.is_a?(Class) && klass < Chewy::Index
+          end
+        end
+
+        def index_identifiers
+          value[:indices] - index_classes
+        end
+
+        def index_names
+          indices.map(&:index_name) | index_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/request.rb

@@ -1,7 +1,7 @@
 module Chewy
   module Search
-    # The main requset DSL class. Supports multiple index requests.
-    # Supports ES2 and ES5 search API and query DSL.
+    # The main request DSL class. Supports multiple index requests.
+    # Supports ES5 search API and query DSL.
     #
     # @note The class tries to be as immutable as possible,
     #   so most of the methods return a new instance of the class.
@@ -26,8 +26,9 @@ module Chewy
         timeout min_score source stored_fields search_after
         load script_fields suggest aggs aggregations none
         indices_boost rescore highlight total total_count
-        total_entries types delete_all count exists? exist? find pluck
-        scroll_batches scroll_hits scroll_results scroll_wrappers
+        total_entries indices types delete_all count exists?
+        exist? find pluck scroll_batches scroll_hits
+        scroll_results scroll_wrappers
       ].to_set.freeze
       DEFAULT_BATCH_SIZE = 1000
       DEFAULT_PLUCK_BATCH_SIZE = 10_000
@@ -40,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 types min_score rescore indices_boost
+        query filter post_filter none min_score rescore indices_boost
       ].freeze
 
       delegate :hits, :wrappers, :objects, :records, :documents,
@@ -51,24 +52,34 @@ module Chewy
       alias_method :total_count, :total
       alias_method :total_entries, :total
 
-      attr_reader :_indexes, :_types
-
       # The class is initialized with the list of chewy indexes and/or
       # types, which are later used to compose requests.
+      # Any symbol/string passed is treated as an index identifier.
       #
       # @example
+      #   Chewy::Search::Request.new(:places)
+      #   # => <Chewy::Search::Request {:index=>["places"]}>
       #   Chewy::Search::Request.new(PlacesIndex)
-      #   # => <Chewy::Search::Request {:index=>["places"], :type=>["city", "country"]}>
+      #   # => <Chewy::Search::Request {:index=>["places"]}>
       #   Chewy::Search::Request.new(PlacesIndex::City)
-      #   # => <Chewy::Search::Request {:index=>["places"], :type=>["city"]}>
+      #   # => <Chewy::Search::Request {:index=>["places"]}>
       #   Chewy::Search::Request.new(UsersIndex, PlacesIndex::City)
-      #   # => <Chewy::Search::Request {:index=>["users", "places"], :type=>["city", "user"]}>
-      # @param indexes_or_types [Array<Chewy::Index, Chewy::Type>] indexes and types in any combinations
-      def initialize(*indexes_or_types)
-        @_types = indexes_or_types.select { |klass| klass < Chewy::Type }
-        @_indexes = indexes_or_types.select { |klass| klass < Chewy::Index }
-        @_types |= @_indexes.flat_map(&:types)
-        @_indexes |= @_types.map(&:index)
+      #   # => <Chewy::Search::Request {:index=>["users", "places"]}>
+      # @param indexes_or_types [Array<Chewy::Index, Chewy::Type, String, Symbol>] indices and types in any combinations
+      def initialize(*indices_or_types)
+        indices = indices_or_types.reject do |klass|
+          klass.is_a?(Class) && klass < Chewy::Type
+        end
+
+        types = indices_or_types.select do |klass|
+          klass.is_a?(Class) && klass < Chewy::Type
+        end
+
+        indices += types.map(&:index)
+
+        parameters.modify!(:indices) do
+          replace!(indices: indices)
+        end
       end
 
       # Underlying parameter storage collection.
@@ -103,14 +114,23 @@ module Chewy
       # @see Chewy::Search::Response
       # @return [Chewy::Search::Response] a response object instance
       def response
-        @response ||= Response.new(perform, loader, collection_paginator)
+        @response ||= build_response(perform)
+      end
+
+      # Wraps and sets the raw Elasticsearch response to provide access
+      # to convenience methods.
+      #
+      # @see Chewy::Search::Response
+      # @param from_elasticsearch [Hash] An Elasticsearch response
+      def response=(from_elasticsearch)
+        @response = build_response(from_elasticsearch)
       end
 
       # ES request body
       #
       # @return [Hash] request body
       def render
-        @render ||= render_base.merge(parameters.render)
+        @render ||= parameters.render
       end
 
       # Includes the class name and the result of rendering.
@@ -281,24 +301,26 @@ module Chewy
       #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-docvalue-fields.html
       #   @param values [Array<String, Symbol>] field names
       #   @return [Chewy::Search::Request]
-      #
-      # @!method types(*values)
-      #   Modifies `types` request parameter. Updates the storage on every call.
-      #   Constrains types passed on the request initialization.
-      #
-      #   @example
-      #     PlacesIndex.types(:city).types(:unexistent)
-      #     # => <PlacesIndex::Query {:index=>["places"], :type=>["city"]}>
-      #   @see Chewy::Search::Parameters::Types
-      #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html
-      #   @param values [Array<String, Symbol>] type names
-      #   @return [Chewy::Search::Request]
-      %i[order docvalue_fields types].each do |name|
+      %i[order docvalue_fields].each do |name|
         define_method name do |value, *values|
           modify(name) { update!([value, *values]) }
         end
       end
 
+      # Modifies `index` request parameter. Updates the storage on every call.
+      # Added passed indexes to the parameter list.
+      #
+      # @example
+      #   UsersIndex.indices(CitiesIndex).indices(:another)
+      #   # => <UsersIndex::Query {:index=>["another", "cities", "users"]}>
+      # @see Chewy::Search::Parameters::Indices
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html
+      # @param values [Array<Chewy::Index, String, Symbol>] index names
+      # @return [Chewy::Search::Request]
+      def indices(value, *values)
+        modify(:indices) { update!(indices: [value, *values]) }
+      end
+
       # @overload reorder(*values)
       #   Replaces the value of the `sort` parameter with the provided value.
       #
@@ -759,7 +781,7 @@ module Chewy
       # @param values [Array<String, Symbol>]
       # @return [Chewy::Search::Request] new scope
       def only(*values)
-        chain { parameters.only!(values.flatten(1)) }
+        chain { parameters.only!(values.flatten(1) + [:indices]) }
       end
 
       # Returns a new scope containing all the storages except specified.
@@ -901,28 +923,28 @@ module Chewy
       end
 
       # Deletes all the documents from the specified scope it uses
-      # `delete_by_query` API. For ES < 5.0 it uses `delete_by_query`
-      # plugin, which requires additional installation effort.
+      # `delete_by_query`
       #
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-delete-by-query.html
-      # @see https://www.elastic.co/guide/en/elasticsearch/plugins/2.0/plugins-delete-by-query.html
       # @note The result hash is different for different API used.
       # @param refresh [true, false] field names
       # @return [Hash] the result of query execution
       def delete_all(refresh: true)
         request_body = only(WHERE_STORAGES).render.merge(refresh: refresh)
         ActiveSupport::Notifications.instrument 'delete_query.chewy',
-          request: request_body, indexes: _indexes, types: _types,
-          index: _indexes.one? ? _indexes.first : _indexes,
-          type: _types.one? ? _types.first : _types do
-            if Runtime.version < '5.0'
-              delete_by_query_plugin(request_body)
-            else
-              Chewy.client.delete_by_query(request_body)
-            end
+          notification_payload(request: request_body) do
+            request_body[:body] = {query: {match_all: {}}} if request_body[:body].empty?
+            Chewy.client.delete_by_query(request_body)
           end
       end
 
+      # Returns whether or not the query has been performed.
+      #
+      # @return [true, false]
+      def performed?
+        !@response.nil?
+      end
+
     protected
 
       def initialize_clone(origin)
@@ -932,10 +954,12 @@ module Chewy
 
     private
 
+      def build_response(raw_response)
+        Response.new(raw_response, loader, collection_paginator)
+      end
+
       def compare_internals(other)
-        _indexes.sort_by(&:derivable_name) == other._indexes.sort_by(&:derivable_name) &&
-          _types.sort_by(&:derivable_name) == other._types.sort_by(&:derivable_name) &&
-          parameters == other.parameters
+        parameters == other.parameters
       end
 
       def modify(name, &block)
@@ -947,58 +971,45 @@ module Chewy
       end
 
       def reset
-        @response, @render, @render_base, @type_names, @index_names, @loader = nil
+        @response, @render, @loader = nil
       end
 
       def perform(additional = {})
         request_body = render.merge(additional)
         ActiveSupport::Notifications.instrument 'search_query.chewy',
-          request: request_body, indexes: _indexes, types: _types,
-          index: _indexes.one? ? _indexes.first : _indexes,
-          type: _types.one? ? _types.first : _types do
-          begin
-            Chewy.client.search(request_body)
-          rescue Elasticsearch::Transport::Transport::Errors::NotFound
-            {}
+          notification_payload(request: request_body) do
+            begin
+              Chewy.client.search(request_body)
+            rescue Elasticsearch::Transport::Transport::Errors::NotFound
+              {}
+            end
           end
-        end
       end
 
-      def raw_limit_value
-        parameters[:limit].value
+      def notification_payload(additional)
+        {
+          indexes: _indices,
+          index: _indices.one? ? _indices.first : _indices
+        }.merge(additional)
       end
 
-      def raw_offset_value
-        parameters[:offset].value
-      end
-
-      def index_names
-        @index_names ||= _indexes.map(&:index_name).uniq
+      def _indices
+        parameters[:indices].indices
       end
 
-      def type_names
-        @type_names ||= if parameters[:types].value.present?
-          _types.map(&:type_name).uniq & parameters[:types].value
-        else
-          _types.map(&:type_name).uniq
-        end
-      end
-
-      def render_base
-        @render_base ||= {index: index_names, type: type_names, body: {}}
+      def raw_limit_value
+        parameters[:limit].value
       end
 
-      def delete_by_query_plugin(request)
-        path = Elasticsearch::API::Utils.__pathify(
-          Elasticsearch::API::Utils.__listify(request[:index]),
-          Elasticsearch::API::Utils.__listify(request[:type]),
-          '_query'
-        )
-        Chewy.client.perform_request(Elasticsearch::API::HTTP_DELETE, path, {}, request[:body]).body
+      def raw_offset_value
+        parameters[:offset].value
       end
 
       def loader
-        @loader ||= Loader.new(indexes: @_indexes, **parameters[:load].value)
+        @loader ||= Loader.new(
+          indexes: parameters[:indices].indices,
+          **parameters[:load].value
+        )
       end
 
       def fetch_field(hit, field)
@@ -1009,10 +1020,6 @@ module Chewy
         end
       end
 
-      def performed?
-        !@response.nil?
-      end
-
       def collection_paginator
         method(:paginated_collection).to_proc if respond_to?(:paginated_collection, true)
       end