chewy 0.8.4 → 5.1.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/parameters.rb

@@ -0,0 +1,167 @@
+Dir.glob(File.join(File.dirname(__FILE__), 'parameters', 'concerns', '*.rb')) { |f| require f }
+Dir.glob(File.join(File.dirname(__FILE__), 'parameters', '*.rb')) { |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 search_type request_cache allow_partial_search_results].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 = {})
+        @storages = Hash.new do |hash, name|
+          hash[name] = self.class.storages[name].new
+        end
+        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