chewy 0.9.0 → 5.2.0

data/lib/chewy/search/parameters/request_cache.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#request_cache
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/shard-request-cache.html#_enabling_and_disabling_caching_per_request
+      class RequestCache < 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/rescore.rb

@@ -0,0 +1,29 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Stores data as an array of hashes, exactly the same way
+      # ES requires `rescore` to be provided.
+      #
+      # @see Chewy::Search::Request#rescore
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-rescore.html
+      class Rescore < Storage
+        # Adds new data to the existing data array.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [Hash, Array<Hash>] any acceptable storage value
+        # @return [Array<Hash>] updated value
+        def update!(other_value)
+          @value = value | normalize(other_value)
+        end
+
+      private
+
+        def normalize(value)
+          Array.wrap(value).flatten(1).reject(&:blank?)
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,20 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Almost standard array storage without any typecasting.
+      # The value is simply replaced on update.
+      #
+      # @see Chewy::Search::Request#search_after
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-search-after.html
+      class SearchAfter < Storage
+      private
+
+        def normalize(value)
+          Array.wrap(value) if value
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,73 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # This storage handles either an array of strings/symbols
+      # or a hash with `includes` and `excludes` keys and
+      # arrays of strings/symbols as values. Any other key is ignored.
+      #
+      # @see Chewy::Search::Request#source
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-source-filtering.html
+      class Source < Storage
+        self.param_name = :_source
+
+        # If array or simple string/symbol is passed, it is treated
+        # as a part of `includes` array and gets concatenated with it.
+        # In case of hash, respective values are concatenated as well.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [true, false, {Symbol => Array<String, Symbol>, String, Symbol}, Array<String, Symbol>, 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[:includes] = value[:includes] | new_value[:includes]
+          new_value[:excludes] = value[:excludes] | new_value[:excludes]
+          @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)
+          super
+          update!(other.value[:enabled])
+        end
+
+        # Renders `false` if `source` is disabled, otherwise renders the
+        # contents of `includes` value or even the entire hash if `excludes`
+        # also specified.
+        #
+        # @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 => false}
+          elsif value[:excludes].present?
+            {self.class.param_name => value.slice(:includes, :excludes).reject { |_, v| v.blank? }}
+          elsif value[:includes].present?
+            {self.class.param_name => value[:includes]}
+          end
+        end
+
+      private
+
+        def normalize(value)
+          includes, excludes, enabled = case value
+          when TrueClass, FalseClass
+            [[], [], value]
+          when Hash
+            [*value.values_at(:includes, :excludes), true]
+          else
+            [value, [], true]
+          end
+          {includes: Array.wrap(includes).reject(&:blank?).map(&:to_s),
+           excludes: Array.wrap(excludes).reject(&:blank?).map(&:to_s),
+           enabled: enabled}
+        end
+      end
+    end
+  end
+end

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