chewy 0.8.4 → 5.1.0

data/lib/chewy/search/loader.rb

@@ -0,0 +1,83 @@
+module Chewy
+  module Search
+    # This class is used for two different purposes: load ORM/ODM
+    # source objects.
+    #
+    # @see Chewy::Type::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 options [Hash] adapter-specific load options
+      # @see Chewy::Type::Adapter::Base#load
+      def initialize(indexes: [], only: [], except: [], **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
+      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 type 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)
+          ids = hit_group.map { |hit| hit['_id'] }
+          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)
+        end
+
+        hits.map { |hit| loaded_objects[hit] }
+      end
+
+    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/{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/pagination/will_paginate.rb

@@ -0,0 +1,43 @@
+module Chewy
+  module Search
+    module Pagination
+      # This module provides `WillPaginate` support for {Chewy::Search::Request}
+      # It is included automatically if `WillPaginate` is available.
+      #
+      # @example
+      #   PlacesIndex.all.paginate(page: 3, per_page: 10).order(:name)
+      #   # => <PlacesIndex::Query {..., :body=>{:size=>10, :from=>20, :sort=>["name"]}}>
+      module WillPaginate
+        extend ActiveSupport::Concern
+
+        included do
+          include ::WillPaginate::CollectionMethods
+          attr_reader :current_page, :per_page
+        end
+
+        def paginate(options = {})
+          @current_page = ::WillPaginate::PageNumber(options[:page] || @current_page || 1)
+          @page_multiplier = @current_page - 1
+          @per_page = (options[:per_page] || @per_page || ::WillPaginate.per_page).to_i
+
+          # call Chewy::Query methods to limit results
+          limit(@per_page).offset(@page_multiplier * @per_page)
+        end
+
+        def page(page)
+          paginate(page: page)
+        end
+
+      private
+
+        def paginated_collection(collection)
+          page = current_page || 1
+          per = per_page || ::WillPaginate.per_page
+          ::WillPaginate::Collection.create(page, per, total_entries) do |pager|
+            pager.replace collection
+          end
+        end
+      end
+    end
+  end
+end

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/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

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

@@ -0,0 +1,14 @@
+module Chewy
+  module Search
+    class Parameters
+      # Just a simple value storage, all the values are coerced to integer.
+      module IntegerStorage
+      private
+
+        def normalize(value)
+          Integer(value) if value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,238 @@
+require 'elasticsearch/dsl'
+
+module Chewy
+  module Search
+    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
+      # 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`
+      # query component arrays separate update.
+      #
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html
+      # @see Chewy::Search::Parameters::Query
+      # @see Chewy::Search::Parameters::Filter
+      # @see Chewy::Search::Parameters::PostFilter
+      module QueryStorage
+        # Bool storage value object, encapsulates update and query
+        # rendering logic.
+        #
+        # @!attribute must
+        #   @return [Array<Hash>, Hash, nil]
+        # @!attribute should
+        #   @return [Array<Hash>, Hash, nil]
+        # @!attribute must_not
+        #   @return [[Array<Hash>, Hash, nil]
+        # @!attribute minimum_should_match
+        #   @return [String, Integer, nil]
+        class Bool
+          # Acceptable bool query keys
+          KEYS = %i[must should must_not minimum_should_match].freeze
+          # @!ignorewarning
+          attr_reader(*KEYS)
+
+          # @param must [Array<Hash>, Hash, nil]
+          # @param should [Array<Hash>, Hash, nil]
+          # @param must_not [Array<Hash>, Hash, nil]
+          # @param minimum_should_match [String, Integer, nil]
+          def initialize(must: [], should: [], must_not: [], minimum_should_match: nil)
+            @must = normalize(must)
+            @should = normalize(should)
+            @must_not = normalize(must_not)
+            @minimum_should_match = minimum_should_match
+          end
+
+          # Merges 2 values, returns new value object.
+          #
+          # @param other [Chewy::Search::Parameters::QueryStorage::Bool]
+          # @return [Chewy::Search::Parameters::QueryStorage::Bool]
+          def update(other)
+            self.class.new(
+              must: must + other.must,
+              should: should + other.should,
+              must_not: must_not + other.must_not,
+              minimum_should_match: other.minimum_should_match
+            )
+          end
+
+          # Renders `bool` query.
+          #
+          # @return [Hash, nil]
+          def query
+            if must.one? && should.empty? && must_not.empty?
+              must.first
+            else
+              reduced = reduce
+              {bool: reduce} if reduced.present?
+            end
+          end
+
+          # Just a convention.
+          #
+          # @return [{Symbol => Array<Hash>, String, Integer, nil}]
+          def to_h
+            {
+              must: must,
+              should: should,
+              must_not: must_not,
+              minimum_should_match: minimum_should_match
+            }
+          end
+
+        private
+
+          def reduce
+            value = to_h
+              .reject { |_, v| v.blank? }
+              .map { |k, v| [k, v.is_a?(Array) && v.one? ? v.first : v] }.to_h
+            value.delete(:minimum_should_match) if should.empty?
+            value
+          end
+
+          def normalize(queries)
+            Array.wrap(queries).map do |query|
+              if query.is_a?(Proc)
+                Elasticsearch::DSL::Search::Query.new(&query).to_hash
+              else
+                query
+              end
+            end.reject(&:blank?)
+          end
+        end
+
+        # Directly modifies `must` array of the root `bool` query.
+        # Pushes the passed query to the end of the array.
+        #
+        # @see Chewy::Search::QueryProxy#must
+        # @param other_value [Hash, Array] any acceptable storage value
+        # @return [{Symbol => Array<Hash>}]
+        def must(other_value)
+          update!(must: other_value)
+        end
+
+        # Directly modifies `should` array of the root `bool` query.
+        # Pushes the passed query to the end of the array.
+        #
+        # @see Chewy::Search::QueryProxy#should
+        # @param other_value [Hash, Array] any acceptable storage value
+        # @return [{Symbol => Array<Hash>}]
+        def should(other_value)
+          update!(should: other_value)
+        end
+
+        # Directly modifies `must_not` array of the root `bool` query.
+        # Pushes the passed query to the end of the array.
+        #
+        # @see Chewy::Search::QueryProxy#must_not
+        # @param other_value [Hash, Array] any acceptable storage value
+        # @return [{Symbol => Array<Hash>}]
+        def must_not(other_value)
+          update!(must_not: other_value)
+        end
+
+        # Unlike {#must} doesn't modify `must` array, but joins 2 queries
+        # into a single `must` array of the new root `bool` query.
+        # If any of the used queries is a `bool` query from the storage
+        # and contains a single query in `must` or `should` array, it will
+        # be reduced to this query, so in some cases it will act exactly
+        # the same way as {#must}.
+        #
+        # @see Chewy::Search::QueryProxy#and
+        # @param other_value [Hash, Array] any acceptable storage value
+        # @return [{Symbol => Array<Hash>}]
+        def and(other_value)
+          join_into(:must, other_value)
+        end
+
+        # Unlike {#should} doesn't modify `should` array, but joins 2 queries
+        # into a single `should` array of the new root `bool` query.
+        # If any of the used queries is a `bool` query from the storage
+        # and contains a single query in `must` or `should` array, it will
+        # be reduced to this query, so in some cases it will act exactly
+        # the same way as {#should}.
+        #
+        # @see Chewy::Search::QueryProxy#or
+        # @param other_value [Hash, Array] any acceptable storage value
+        # @return [{Symbol => Array<Hash>}]
+        def or(other_value)
+          join_into(:should, other_value)
+        end
+
+        # Basically, an alias for {#must_not}.
+        #
+        # @see #must_not
+        # @see Chewy::Search::QueryProxy#not
+        # @param other_value [Hash, Array] any acceptable storage value
+        # @return [{Symbol => Array<Hash>}]
+        def not(other_value)
+          update!(must_not: normalize(other_value).query)
+        end
+
+        # Replaces `minimum_should_match` bool query value
+        #
+        # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-minimum-should-match.html
+        # @param new_value [String, Integer] minimum_should_match value
+        # @return [{Symbol => Array<Hash>}]
+        def minimum_should_match(new_value)
+          update!(minimum_should_match: new_value)
+        end
+
+        # Uses `and` logic to merge storages.
+        #
+        # @see #and
+        # @see Chewy::Search::Parameters::Storage#merge!
+        # @param other [Chewy::Search::Parameters::Storage] other storage
+        # @return [{Symbol => Array<Hash>}]
+        def merge!(other)
+          self.and(other.value)
+        end
+
+        # Every query value is a hash of arrays and each array is
+        # glued with the corresponding array from the provided value.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [Hash, Array] any acceptable storage value
+        # @return [{Symbol => Array<Hash>}]
+        def update!(other_value)
+          @value = value.update(normalize(other_value))
+        end
+
+        # Almost standard rendering logic, some reduction logic is
+        # applied to the value additionally.
+        #
+        # @see Chewy::Search::Parameters::Storage#render
+        # @return [{Symbol => Hash}]
+        def render
+          rendered_bool = value.query
+          {self.class.param_name => rendered_bool} if rendered_bool.present?
+        end
+
+      private
+
+        def join_into(place, other_value)
+          values = [value, normalize(other_value)]
+          queries = values.map(&:query)
+          if queries.all?
+            replace!(place => queries)
+          elsif queries.none?
+            @value
+          else
+            replace!(values[queries.index(&:present?)])
+          end
+        end
+
+        def normalize(value)
+          value ||= {}
+          if value.is_a?(Hash)
+            value = value.symbolize_keys
+            value = Bool.new(**value.slice(*Bool::KEYS)) if (value.keys & Bool::KEYS).present?
+          end
+          value = Bool.new(must: value) unless value.is_a?(Bool)
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Chewy
+  module Search
+    class Parameters
+      # Stores value as an array of strings.
+      module StringArrayStorage
+        # Unions two arrays.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [String, Symbol, Array<String, Symbol>] any acceptable storage value
+        # @return [Array<String, Symbol>] updated value
+        def update!(other_value)
+          @value = value | normalize(other_value)
+        end
+
+      private
+
+        def normalize(value)
+          Array.wrap(value).flatten(1).map(&:to_s).reject(&:blank?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Chewy
+  module Search
+    class Parameters
+      # Just a simple value storage, all the values are coerced to string.
+      module StringStorage
+      private
+
+        def normalize(value)
+          value.to_s if value.present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # @see Chewy::Search::Parameters::StringArrayStorage
+      class DocvalueFields < Storage
+        include StringArrayStorage
+      end
+    end
+  end
+end

data/lib/chewy/search/parameters/explain.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#explain
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-explain.html
+      class Explain < Storage
+        include BoolStorage
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # This parameter storage doesn't have its own parameter at the
+      # ES request body. Instead, it is embedded to the root `bool`
+      # query of the `query` request parameter. Some additional query
+      # reduction is performed in case of only several `must` filters
+      # presence.
+      #
+      # @example
+      #   scope = PlacesIndex.filter(term: {name: 'Moscow'})
+      #   # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{:filter=>{:term=>{:name=>"Moscow"}}}}}}>
+      #   scope.query(match: {name: 'London'})
+      #   # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #   #      :must=>{:match=>{:name=>"London"}},
+      #   #      :filter=>{:term=>{:name=>"Moscow"}}}}}}>
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-filter-context.html
+      # @see Chewy::Search::Parameters::QueryStorage
+      class Filter < Storage
+        include QueryStorage
+
+        # Even more reduction added here, we don't need to wrap with
+        # `bool` query consists on `must` only.
+        #
+        # @see Chewy::Search::Parameters::Storage#render
+        # @return [{Symbol => Hash}]
+        def render
+          rendered_bool = filter_query(value.query)
+          {self.class.param_name => rendered_bool} if rendered_bool.present?
+        end
+
+      private
+
+        def filter_query(value)
+          bool = value[:bool] if value
+          if bool && bool[:must].present? && bool[:should].blank? && bool[:must_not].blank?
+            bool[:must]
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chewy/search/parameters/highlight.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#highlight
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-highlighting.html
+      class Highlight < Storage
+        include HashStorage
+      end
+    end
+  end
+end