chewy 0.8.4 → 7.3.4

data/lib/chewy/search/parameters.rb

@@ -0,0 +1,170 @@
+Dir.glob(File.join(File.dirname(__FILE__), 'parameters', 'concerns', '*.rb')).sort.each { |f| require f }
+Dir.glob(File.join(File.dirname(__FILE__), 'parameters', '*.rb')).sort.each { |f| require f }
+
+module Chewy
+  module Search
+    # This class is basically a compound storage of the request
+    # parameter storages. It encapsulates some storage-collection-handling
+    # logic.
+    #
+    # @see Chewy::Search::Request#parameters
+    # @see Chewy::Search::Parameters::Storage
+    class Parameters
+      QUERY_STRING_STORAGES = %i[indices preference search_type request_cache allow_partial_search_results ignore_unavailable].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.
+      #
+      # @return [{Symbol => Chewy::Search::Parameters::Storage}]
+      def self.storages
+        @storages ||= Hash.new do |hash, name|
+          hash[name] = "Chewy::Search::Parameters::#{name.to_s.camelize}".constantize
+        end
+      end
+
+      # @return [{Symbol => Chewy::Search::Parameters::Storage}]
+      attr_accessor :storages
+
+      delegate :[], :[]=, to: :storages
+
+      # Accepts an initial hash as basic values or parameter storages.
+      #
+      # @example
+      #   Chewy::Search::Parameters.new(limit: 10, offset 10)
+      #   Chewy::Search::Parameters.new(
+      #     limit: Chewy::Search::Parameters::Limit.new(10),
+      #     limit: Chewy::Search::Parameters::Offset.new(10)
+      #   )
+      # @param initial [{Symbol => Object, Chewy::Search::Parameters::Storage}]
+      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)
+          result[name] = storage
+        end
+      end
+
+      # Compares storages by their values.
+      #
+      # @param other [Object] any object
+      # @return [true, false]
+      def ==(other)
+        super || other.is_a?(self.class) && compare_storages(other)
+      end
+
+      # Clones the specified storage, performs the operation
+      # defined by block on the clone.
+      #
+      # @param name [Symbol] parameter name
+      # @yield the block is executed in the cloned storage instance binding
+      # @return [Chewy::Search::Parameters::Storage]
+      def modify!(name, &block)
+        @storages[name] = @storages[name].clone.tap do |s|
+          s.instance_exec(&block)
+        end
+      end
+
+      # Removes specified storages from the storages hash.
+      #
+      # @param names [Array<String, Symbol>]
+      # @return [{Symbol => Chewy::Search::Parameters::Storage}] removed storages hash
+      def only!(names)
+        @storages.slice!(*assert_storages(names))
+      end
+
+      # Keeps only specified storages removing everything else.
+      #
+      # @param names [Array<String, Symbol>]
+      # @return [{Symbol => Chewy::Search::Parameters::Storage}] kept storages hash
+      def except!(names)
+        @storages.except!(*assert_storages(names))
+      end
+
+      # Takes all the storages and merges them one by one using
+      # {Chewy::Search::Parameters::Storage#merge!} method. Merging
+      # is implemented in different ways for different storages: for
+      # limit, offset and other single-value classes it is a simple
+      # value replacement, for boolean storages (explain, none) it uses
+      # a disjunction result, for compound values - merging and
+      # concatenation, for query, filter, post_filter - it is the
+      # "and" operation.
+      #
+      # @see Chewy::Search::Parameters::Storage#merge!
+      # @return [{Symbol => Chewy::Search::Parameters::Storage}] storages from other parameters
+      def merge!(other)
+        other.storages.each do |name, storage|
+          modify!(name) { merge!(storage) }
+        end
+      end
+
+      # Renders and merges all the parameter storages into a single hash.
+      #
+      # @return [Hash] request body
+      def render
+        render_query_string_params.merge(render_body)
+      end
+
+    protected
+
+      def initialize_clone(origin)
+        @storages = origin.storages.clone
+      end
+
+      def compare_storages(other)
+        keys = (@storages.keys | other.storages.keys)
+        @storages.values_at(*keys) == other.storages.values_at(*keys)
+      end
+
+      def assert_storages(names)
+        raise ArgumentError, 'No storage names were specified' if names.empty?
+
+        names = names.map(&:to_sym)
+        self.class.storages.values_at(*names)
+        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
+
+        return none if none
+
+        filter = @storages[:filter].render
+        query = @storages[:query].render
+
+        return query unless filter
+
+        if query && query[:query][:bool]
+          query[:query][:bool].merge!(filter)
+          query
+        elsif query
+          {query: {bool: {must: query[:query]}.merge!(filter)}}
+        else
+          {query: {bool: filter}}
+        end
+      end
+    end
+  end
+end

data/lib/chewy/search/query_proxy.rb

@@ -0,0 +1,264 @@
+module Chewy
+  module Search
+    # This specialized proxy class is used to provide an ability
+    # of `query`, `filter`, `post_filter` parameters additional
+    # modification.
+    #
+    # @see Chewy::Search::Parameters::Query
+    # @see Chewy::Search::Parameters::Filter
+    # @see Chewy::Search::Parameters::PostFilter
+    # @see Chewy::Search::Parameters::QueryStorage
+    class QueryProxy
+      # @param parameter_name [Symbol] modified parameter name
+      # @param request [Chewy::Search::Request] request instance for modification
+      def initialize(parameter_name, request)
+        @parameter_name = parameter_name
+        @request = request
+      end
+
+      # @!method must(query_hash = nil, &block)
+      #   Executes {Chewy::Search::Parameters::QueryStorage#must} in the scope
+      #   of newly created request object.
+      #
+      #   @see Chewy::Search::Parameters::QueryStorage#must
+      #   @return [Chewy::Search::Request]
+      #
+      #   @overload must(query_hash)
+      #     If pure hash is passed it is added to `must` array of the bool query.
+      #
+      #     @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
+      #     @example
+      #       PlacesIndex.query.must(match: {name: 'Moscow'}).query.must(match: {name: 'London'})
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @param query_hash [Hash] pure query hash
+      #
+      #   @overload must
+      #     If block is passed instead of a pure hash, `elasticsearch-dsl"
+      #     gem will be used to process it.
+      #
+      #     @see https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl
+      #     @example
+      #       PlacesIndex.query.must { match name: 'Moscow' }.query.must { match name: 'London' }
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @yield the block is processed by `elasticsearch-dsl` gem
+      #
+      # @!method should(query_hash = nil, &block)
+      #   Executes {Chewy::Search::Parameters::QueryStorage#should} in the scope
+      #   of newly created request object.
+      #
+      #   @see Chewy::Search::Parameters::QueryStorage#should
+      #   @return [Chewy::Search::Request]
+      #
+      #   @overload should(query_hash)
+      #     If pure hash is passed it is added to `should` array of the bool query.
+      #
+      #     @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
+      #     @example
+      #       PlacesIndex.query.should(match: {name: 'Moscow'}).query.should(match: {name: 'London'})
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :should=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @param query_hash [Hash] pure query hash
+      #
+      #   @overload should
+      #     If block is passed instead of a pure hash, `elasticsearch-dsl"
+      #     gem will be used to process it.
+      #
+      #     @see https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl
+      #     @example
+      #       PlacesIndex.query.should { match name: 'Moscow' }.query.should { match name: 'London' }
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :should=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @yield the block is processed by `elasticsearch-dsl` gem
+      #
+      # @!method must_not(query_hash = nil, &block)
+      #   Executes {Chewy::Search::Parameters::QueryStorage#must_not} in the scope
+      #   of newly created request object.
+      #
+      #   @see Chewy::Search::Parameters::QueryStorage#must_not
+      #   @return [Chewy::Search::Request]
+      #
+      #   @overload must_not(query_hash)
+      #     If pure hash is passed it is added to `must_not` array of the bool query.
+      #
+      #     @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
+      #     @example
+      #       PlacesIndex.query.must_not(match: {name: 'Moscow'}).query.must_not(match: {name: 'London'})
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must_not=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @param query_hash [Hash] pure query hash
+      #
+      #   @overload must_not
+      #     If block is passed instead of a pure hash, `elasticsearch-dsl"
+      #     gem will be used to process it.
+      #
+      #     @see https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl
+      #     @example
+      #       PlacesIndex.query.must_not { match name: 'Moscow' }.query.must_not { match name: 'London' }
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must_not=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @yield the block is processed by `elasticsearch-dsl` gem
+      %i[must should must_not].each do |method|
+        define_method method do |query_hash = nil, &block|
+          raise ArgumentError, "Please provide a parameter or a block to `#{method}`" unless query_hash || block
+
+          @request.send(:modify, @parameter_name) { send(method, block || query_hash) }
+        end
+      end
+
+      # @!method and(query_hash_or_scope = nil, &block)
+      #   Executes {Chewy::Search::Parameters::QueryStorage#and} in the scope
+      #   of newly created request object.
+      #
+      #   @see Chewy::Search::Parameters::QueryStorage#and
+      #   @return [Chewy::Search::Request]
+      #
+      #   @overload and(query_hash)
+      #     If pure hash is passed, the current root `bool` query and
+      #     the passed one are joined into a single `must` array of the
+      #     new root query.
+      #     @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
+      #     @example
+      #       scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
+      #       scope.query.and(match: {name: 'London'})
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>
+      #       scope = PlacesIndex.query(match: {name: 'Moscow'})
+      #       scope.query.and(match: {name: 'London'})
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @param query_hash [Hash] pure query hash
+      #
+      #   @overload and(scope)
+      #     If a scope is passed, the appropriate parameter storage value
+      #     will be extracted from it and used as a second query.
+      #     @example
+      #       scope1 = PlacesIndex.query.must_not(match: {name: 'Moscow'})
+      #       scope2 = PlacesIndex.query(match: {name: 'London'})
+      #       scope1.query.and(scope2)
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @param scope [Chewy::Search::Request] other scope
+      #
+      #   @overload and
+      #     If block is passed instead of a pure hash, `elasticsearch-dsl"
+      #     gem will be used to process it.
+      #     @see https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl
+      #     @example
+      #       scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
+      #       scope.query.and { match name: 'London' }
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @yield the block is processed by `elasticsearch-dsl` gem
+      #
+      # @!method or(query_hash_or_scope = nil, &block)
+      #   Executes {Chewy::Search::Parameters::QueryStorage#or} in the scope
+      #   of newly created request object.
+      #
+      #   @see Chewy::Search::Parameters::QueryStorage#or
+      #   @return [Chewy::Search::Request]
+      #
+      #   @overload or(query_hash)
+      #     If pure hash is passed, the current root `bool` query and
+      #     the passed one are joined into a single `should` array of the
+      #     new root query.
+      #     @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
+      #     @example
+      #       scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
+      #       scope.query.or(match: {name: 'London'})
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :should=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>
+      #       scope = PlacesIndex.query(match: {name: 'Moscow'})
+      #       scope.query.or(match: {name: 'London'})
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :should=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @param query_hash [Hash] pure query hash
+      #
+      #   @overload or(scope)
+      #     If a scope is passed, the appropriate parameter storage value
+      #     will be extracted from it and used as a second query.
+      #     @example
+      #       scope1 = PlacesIndex.query.must_not(match: {name: 'Moscow'})
+      #       scope2 = PlacesIndex.query(match: {name: 'London'})
+      #       scope1.query.or(scope2)
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :should=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @param scope [Chewy::Search::Request] other scope
+      #
+      #   @overload or
+      #     If block is passed instead of a pure hash, `elasticsearch-dsl"
+      #     gem will be used to process it.
+      #     @see https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl
+      #     @example
+      #       scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
+      #       scope.query.or { match name: 'London' }
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :should=>[{:bool=>{:must_not=>{:match=>{:name=>"Moscow"}}}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @yield the block is processed by `elasticsearch-dsl` gem
+      #
+      # @!method not(query_hash_or_scope = nil, &block)
+      #   Executes {Chewy::Search::Parameters::QueryStorage#not} in the scope
+      #   of newly created request object.
+      #   The only difference from {#must_not} is that is accepts another scope additionally.
+      #
+      #   @see Chewy::Search::Parameters::QueryStorage#not
+      #   @return [Chewy::Search::Request]
+      #
+      #   @overload not(query_hash)
+      #     If pure hash is passed it is added to `must_not` array of the bool query.
+      #     @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html
+      #     @example
+      #       scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
+      #       scope.query.not(match: {name: 'London'})
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must_not=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @param query_hash [Hash] pure query hash
+      #
+      #   @overload not(scope)
+      #     If a scope is passed, the appropriate parameter storage value
+      #     will be extracted from it and used as a second query.
+      #     @example
+      #       scope1 = PlacesIndex.query.must_not(match: {name: 'Moscow'})
+      #       scope2 = PlacesIndex.query(match: {name: 'London'})
+      #       scope1.query.not(scope2)
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must_not=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @param scope [Chewy::Search::Request] other scope
+      #
+      #   @overload not
+      #     If block is passed instead of a pure hash, `elasticsearch-dsl"
+      #     gem will be used to process it.
+      #     @see https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl
+      #     @example
+      #       scope = PlacesIndex.query.must_not(match: {name: 'Moscow'})
+      #       scope.query.not { match name: 'London' }
+      #       # => <PlacesIndex::Query {..., :body=>{:query=>{:bool=>{
+      #       #      :must_not=>[{:match=>{:name=>"Moscow"}}, {:match=>{:name=>"London"}}]}}}}>
+      #     @yield the block is processed by `elasticsearch-dsl` gem
+      %i[and or not].each do |method|
+        define_method method do |query_hash_or_scope = nil, &block|
+          unless query_hash_or_scope || block
+            raise ArgumentError,
+                  "Please provide a parameter or a block to `#{method}`"
+          end
+
+          if !block && query_hash_or_scope.is_a?(Chewy::Search::Request)
+            query_hash_or_scope = query_hash_or_scope.parameters[@parameter_name].value
+          end
+          @request.send(:modify, @parameter_name) { send(method, block || query_hash_or_scope) }
+        end
+      end
+
+      # Executes {Chewy::Search::Parameters::QueryStorage#minimum_should_match} in the scope
+      # of newly created request object.
+      #
+      # @see Chewy::Search::Parameters::QueryStorage#minimum_should_match
+      # @param value [String, Integer, nil]
+      # @return [Chewy::Search::Request]
+      def minimum_should_match(value)
+        @request.send(:modify, @parameter_name) { minimum_should_match(value) }
+      end
+    end
+  end
+end