chewy 0.9.0 → 0.10.0

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/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,237 @@
+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>]
+        # @!attribute should
+        #   @return [Array<Hash>]
+        # @!attribute must_not
+        #   @return [Array<Hash>]
+        # @!attribute minimum_should_match
+        #   @return [String, Integer, nil]
+        class Bool
+          # Acceptable bool query keys
+          KEYS = %i[must should must_not minimum_should_match].freeze
+          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