chewy 0.8.4 → 7.3.4

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 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`
+      # 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? }
+              .transform_values { |v| v.is_a?(Array) && v.one? ? v.first : v }
+            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

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

@@ -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/indices_boost.rb

@@ -0,0 +1,52 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Stores provided values as a string-float hash, but also takes
+      # keys order into account.
+      #
+      # @see Chewy::Search::Request#indices_boost
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-index-boost.html
+      class IndicesBoost < Storage
+        # Merges two hashes, but puts keys from the second hash
+        # at the end of the result hash.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [{String, Symbol => String, Integer, Float}] any acceptable storage value
+        # @return [{String => Float}] updated value
+        def update!(other_value)
+          new_value = normalize(other_value)
+          value.except!(*new_value.keys).merge!(new_value)
+        end
+
+        # Renders the value hash as an array of hashes for
+        # each key-value pair.
+        #
+        # @see Chewy::Search::Parameters::Storage#render
+        # @return [Array<{String => Float}>] updated value
+        def render
+          {self.class.param_name => value.map { |k, v| {k => v} }} if value.present?
+        end
+
+        # Comparison also reqires additional logic. Since indexes boost
+        # is sensitive to the order index templates are provided, we have
+        # to compare stored hashes keys as well.
+        #
+        # @see Chewy::Search::Parameters::Storage#==
+        # @return [true, false]
+        def ==(other)
+          super && value.keys == other.value.keys
+        end
+
+      private
+
+        def normalize(value)
+          value = (value || {}).stringify_keys
+          value.each { |k, v| value[k] = Float(v) }
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Just a standard integer value storage, nothing to see here.
+      #
+      # @see Chewy::Search::Parameters::IntegerStorage
+      # @see Chewy::Search::Request#limit
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-from-size.html
+      class Limit < Storage
+        include IntegerStorage
+        self.param_name = :size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Acts like standard hash storage, with one exception:
+      # all the keys are deeply symbolized for convenience.
+      #
+      # @see Chewy::Search::Request#load
+      # @see Chewy::Search::Loader
+      class Load < Storage
+        # Simply merges two value hashes on update
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [{String, Symbol => Object}] any acceptable storage value
+        # @return [{Symbol => Object}] updated value
+        def update!(other_value)
+          value.merge!(normalize(other_value))
+        end
+
+        # Doesn't render anythig, has specific handling logic.
+        def render; end
+
+      private
+
+        def normalize(value)
+          (value || {}).deep_symbolize_keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Just a simple value storage, all the values are coerced to float.
+      class MinScore < Storage
+      private
+
+        def normalize(value)
+          Float(value) if value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Just a standard boolean storage, except the rendering logic.
+      #
+      # @see Chewy::Search::Parameters::BoolStorage
+      # @see Chewy::Search::Request#none
+      # @see https://en.wikipedia.org/wiki/Null_Object_pattern
+      class None < Storage
+        include BoolStorage
+
+        # Renders `match_none` query if the values is set to true.
+        #
+        # @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: {match_none: {}}} if value.present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Just a standard integer value storage, nothing to see here.
+      #
+      # @see Chewy::Search::Parameters::IntegerStorage
+      # @see Chewy::Search::Request#offset
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-from-size.html
+      class Offset < Storage
+        include IntegerStorage
+        self.param_name = :from
+      end
+    end
+  end
+end