chewy 0.9.0 → 0.10.0

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

@@ -0,0 +1,95 @@
+module Chewy
+  module Search
+    class Parameters
+      # Base parameter storage, defines a conventional API and
+      # its default behavior.
+      class Storage
+        class << self
+          attr_writer :param_name
+
+          # @!attribute [rw] param_name
+          # The parameter name is used on rendering, derived from the class
+          # name by default, but can be easily redefined for child classes.
+          #
+          # @example
+          #   class Limit < Storage
+          #     self.param_name = :size
+          #   end
+          # @return [Symbol] parameter name
+          def param_name
+            @param_name ||= name.demodulize.underscore.to_sym
+          end
+        end
+
+        # Returns normalized storage value.
+        attr_reader :value
+
+        # @param value [Object] any acceptable storage value
+        def initialize(value = nil)
+          replace!(value)
+        end
+
+        # Compares two storages, basically, classes and values should
+        # be identical.
+        #
+        # @param other [Chewy::Search::Parameters::Storage] any storage instance
+        # @return [true, false] the result of comparision
+        def ==(other)
+          super || other.class == self.class && other.value == value
+        end
+
+        # Replaces current value with normalized provided one. Doesn't
+        # make sense to redefine it in child classes, the replacement
+        # logic should be kept as is.
+        #
+        # @see Chewy::Search::Request
+        # @param new_value [Object] any acceptable storage value
+        # @return [Object] new normalized value
+        def replace!(new_value)
+          @value = normalize(new_value)
+        end
+
+        # Implements the storage update logic, picks the first present
+        # value by default, but can be redefined if necessary.
+        #
+        # @see Chewy::Search::Request
+        # @param other_value [Object] any acceptable storage value
+        # @return [Object] updated value
+        def update!(other_value)
+          replace!([value, normalize(other_value)].compact.last)
+        end
+
+        # Merges one storage with another one using update by default.
+        # Requires redefinition sometimes.
+        #
+        # @see Chewy::Search::Parameters#merge!
+        # @see Chewy::Search::Request#merge
+        # @param other [Chewy::Search::Parameters::Storage] other storage
+        # @return [Object] updated value
+        def merge!(other)
+          update!(other.value)
+        end
+
+        # Basic parameter rendering logic, don't need to return anything
+        # if parameter doesn't require rendering for the current value.
+        #
+        # @see Chewy::Search::Parameters#render
+        # @see Chewy::Search::Request#render
+        # @return [{Symbol => Object}, nil] rendered value with the parameter name
+        def render
+          {self.class.param_name => value} if value.present?
+        end
+
+      private
+
+        def initialize_clone(origin)
+          @value = origin.value.deep_dup
+        end
+
+        def normalize(value)
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # This storage is basically an array storage, but with an
+      # additional ability to pass `enabled` option.
+      #
+      # @see Chewy::Search::Request#stored_fields
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-stored-fields.html
+      class StoredFields < Storage
+        # If array or just a field name is passed - it gets concatenated
+        # to the storage array. `true` or `false` values are modifying
+        # `enabled` parameter.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [true, false, String, Symbol, Array<String, Symbol>] any acceptable storage value
+        # @return [{Symbol => Array<String>, true, false}] updated value
+        def update!(other_value)
+          new_value = normalize(other_value)
+          new_value[:stored_fields] = value[:stored_fields] | new_value[:stored_fields]
+          @value = new_value
+        end
+
+        # Requires an additional logic to merge `enabled` value.
+        #
+        # @see Chewy::Search::Parameters::Storage#merge!
+        # @param other [Chewy::Search::Parameters::Storage] other storage
+        # @return [{Symbol => Array<String>, true, false}] updated value
+        def merge!(other)
+          update!(other.value[:stored_fields])
+          update!(other.value[:enabled])
+        end
+
+        # Renders `_none_` if `stored_fields` are disabled, otherwise renders the
+        # array of stored field names.
+        #
+        # @see Chewy::Search::Parameters::Storage#render
+        # @return [{Symbol => Object}, nil] rendered value with the parameter name
+        def render
+          if !value[:enabled]
+            {self.class.param_name => '_none_'}
+          elsif value[:stored_fields].present?
+            {self.class.param_name => value[:stored_fields]}
+          end
+        end
+
+      private
+
+        def normalize(raw_value)
+          stored_fields, enabled = case raw_value
+          when TrueClass, FalseClass
+            [[], raw_value]
+          else
+            [raw_value, true]
+          end
+          {stored_fields: Array.wrap(stored_fields).reject(&:blank?).map(&:to_s),
+           enabled: enabled}
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,16 @@
+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#terminate_after
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-body.html
+      class TerminateAfter < Storage
+        include IntegerStorage
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Just a standard string value storage, nothing to see here.
+      #
+      # @see Chewy::Search::Parameters::StringStorage
+      # @see Chewy::Search::Request#timeout
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/common-options.html#time-units
+      class Timeout < Storage
+        include StringStorage
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,20 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # A standard string array storage with one exception: rendering is empty.
+      #
+      # @see Chewy::Search::Parameters::StringArrayStorage
+      class Types < Storage
+        include StringArrayStorage
+
+        # Doesn't render anything, has specialized rendering logic in
+        # {Chewy::Search::Request}
+        #
+        # @return [nil]
+        def render; end
+      end
+    end
+  end
+end

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

data/lib/chewy/search/query_proxy.rb

@@ -0,0 +1,257 @@
+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|
+          raise ArgumentError, "Please provide a parameter or a block to `#{method}`" unless query_hash_or_scope || block
+          query_hash_or_scope = query_hash_or_scope.parameters[@parameter_name].value if !block && query_hash_or_scope.is_a?(Chewy::Search::Request)
+          @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