chewy 0.8.4 → 5.1.0

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

@@ -0,0 +1,123 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Stores indices and/or types to query.
+      # Renders it to lists of string accepted by ElasticSearch
+      # API.
+      #
+      # The semantics behind it can be described in the
+      # following statements:
+      # 1. If index is added to the storage, no matter, a class
+      # or a string/symbol, it gets appended to the list.
+      # 2. If type is added to the storage, it filters out types
+      # assigned via indices.
+      # 3. But when a type class with non-existing index is added,
+      # this index got also added to the list if indices.
+      # 4. In cases when of an index identifier added, type
+      # indetifiers also got appended instead of filtering.
+      class Indices < Storage
+        # Two index storages are equal if they produce the
+        # same output on render.
+        #
+        # @see Chewy::Search::Parameters::Storage#==
+        # @param other [Chewy::Search::Parameters::Storage] any storage instance
+        # @return [true, false] the result of comparision
+        def ==(other)
+          super || other.class == self.class && other.render == render
+        end
+
+        # Just adds types to types and indices to indices.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [{Symbol => Array<Chewy::Index, Chewy::Type, String, Symbol>}] any acceptable storage value
+        # @return [{Symbol => Array<Chewy::Index, Chewy::Type, String, Symbol>}] updated value
+        def update!(other_value)
+          new_value = normalize(other_value)
+
+          @value = {
+            indices: value[:indices] | new_value[:indices],
+            types: value[:types] | new_value[:types]
+          }
+        end
+
+        # Returns desired index and type names.
+        #
+        # @see Chewy::Search::Parameters::Storage#render
+        # @return [{Symbol => Array<String>}] rendered value with the parameter name
+        def render
+          {
+            index: index_names.uniq.sort,
+            type: type_names.uniq.sort
+          }.reject { |_, v| v.blank? }
+        end
+
+        # Returns index classes used for the request.
+        # No strings/symbos included.
+        #
+        # @return [Array<Chewy::Index>] a list of index classes
+        def indices
+          index_classes | type_classes.map(&:index)
+        end
+
+        # Returns type classes used for the request.
+        # No strings/symbos included.
+        #
+        # @return [Array<Chewy::Type>] a list of types classes
+        def types
+          type_classes | (index_classes - type_classes.map(&:index)).flat_map(&:types)
+        end
+
+      private
+
+        def initialize_clone(origin)
+          @value = origin.value.dup
+        end
+
+        def normalize(value)
+          value ||= {}
+
+          {
+            indices: Array.wrap(value[:indices]).flatten.compact,
+            types: Array.wrap(value[:types]).flatten.compact
+          }
+        end
+
+        def index_classes
+          value[:indices].select do |klass|
+            klass.is_a?(Class) && klass < Chewy::Index
+          end
+        end
+
+        def index_identifiers
+          value[:indices] - index_classes
+        end
+
+        def index_names
+          indices.map(&:index_name) | index_identifiers.map(&:to_s)
+        end
+
+        def type_classes
+          value[:types].select do |klass|
+            klass.is_a?(Class) && klass < Chewy::Type
+          end
+        end
+
+        def type_identifiers
+          value[:types] - type_classes
+        end
+
+        def type_names
+          type_names = types.map(&:type_name)
+
+          if index_identifiers.blank? && type_identifiers.present?
+            (type_names & type_identifiers.map(&:to_s)).presence || type_names
+          else
+            type_names | type_identifiers.map(&:to_s)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Stores provided values as a string-float hash, but also takes
+      # keys order into account.
+      #
+      # @see Chewy::Search::Request#indices_boost
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-index-boost.html
+      class IndicesBoost < Storage
+        # Merges two hashes, but puts keys from the second hash
+        # at the end of the result hash.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [{String, Symbol => String, Integer, Float}] any acceptable storage value
+        # @return [{String => Float}] updated value
+        def update!(other_value)
+          new_value = normalize(other_value)
+          value.except!(*new_value.keys).merge!(new_value)
+        end
+
+        # Renders the value hash as an array of hashes for
+        # each key-value pair.
+        #
+        # @see Chewy::Search::Parameters::Storage#render
+        # @return [Array<{String => Float}>] updated value
+        def render
+          {self.class.param_name => value.map { |k, v| {k => v} }} if value.present?
+        end
+
+        # Comparison also reqires additional logic. Since indexes boost
+        # is sensitive to the order index templates are provided, we have
+        # to compare stored hashes keys as well.
+        #
+        # @see Chewy::Search::Parameters::Storage#==
+        # @return [true, false]
+        def ==(other)
+          super && value.keys == other.value.keys
+        end
+
+      private
+
+        def normalize(value)
+          value = (value || {}).stringify_keys
+          value.each { |k, v| value[k] = Float(v) }
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+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#limit
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-from-size.html
+      class Limit < Storage
+        include IntegerStorage
+        self.param_name = :size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Acts like standard hash storage, with one exception:
+      # all the keys are deeply symbolized for convenience.
+      #
+      # @see Chewy::Search::Request#load
+      # @see Chewy::Search::Loader
+      class Load < Storage
+        # Simply merges two value hashes on update
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [{String, Symbol => Object}] any acceptable storage value
+        # @return [{Symbol => Object}] updated value
+        def update!(other_value)
+          value.merge!(normalize(other_value))
+        end
+
+        # Doesn't render anythig, has specific handling logic.
+        def render; end
+
+      private
+
+        def normalize(value)
+          (value || {}).deep_symbolize_keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Just a simple value storage, all the values are coerced to float.
+      class MinScore < Storage
+      private
+
+        def normalize(value)
+          Float(value) if value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Just a standard boolean storage, except the rendering logic.
+      #
+      # @see Chewy::Search::Parameters::BoolStorage
+      # @see Chewy::Search::Request#none
+      # @see https://en.wikipedia.org/wiki/Null_Object_pattern
+      class None < Storage
+        include BoolStorage
+
+        # Renders `match_none` query if the values is set to true.
+        # Well, we can't really use match none because we need to support
+        # ES2, so we are simulating it with `match_all` negation.
+        #
+        # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-all-query.html#query-dsl-match-none-query
+        # @see Chewy::Search::Request
+        # @see Chewy::Search::Request#response
+        def render
+          {query: {bool: {filter: {bool: {must_not: {match_all: {}}}}}}} if value.present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+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#offset
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/5.4/search-request-from-size.html
+      class Offset < Storage
+        include IntegerStorage
+        self.param_name = :from
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # Sort parameter storage. Stores a hash of fields with the `nil`
+      # key if no options for the field were specified. Normalizer
+      # accepts an array of any hash-string-symbols combinations, or a hash.
+      #
+      # @see Chewy::Search::Request#order
+      # @see Chewy::Search::Request#reorder
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-sort.html
+      class Order < Storage
+        # Merges two hashes.
+        #
+        # @see Chewy::Search::Parameters::Storage#update!
+        # @param other_value [Object] any acceptable storage value
+        # @return [Object] updated value
+        def update!(other_value)
+          value.merge!(normalize(other_value))
+        end
+
+        # Size requires specialized rendering logic, it should return
+        # an array to satisfy ES.
+        #
+        # @see Chewy::Search::Parameters::Storage#render
+        # @return [{Symbol => Array<Hash, String, Symbol>}]
+        def render
+          return if value.blank?
+
+          sort = value.map do |(field, options)|
+            options ? {field => options} : field
+          end
+          {sort: sort}
+        end
+
+        # Comparison also reqires additional logic. Hashes are compared
+        # orderlessly, but for `sort` parameter oder is important, so we
+        # compare hash key collections additionally.
+        #
+        # @see Chewy::Search::Parameters::Storage#==
+        # @return [true, false]
+        def ==(other)
+          super && value.keys == other.value.keys
+        end
+
+      private
+
+        def normalize(value)
+          case value
+          when Array
+            value.each_with_object({}) do |sv, res|
+              res.merge!(normalize(sv))
+            end
+          when Hash
+            value.stringify_keys
+          else
+            value.present? ? {value.to_s => nil} : {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # A standard parameter storage, which updates `post_filter` parameter
+      # of the ES request.
+      #
+      # @example
+      #   PlacesIndex.post_filter(match: {name: 'Moscow'})
+      #   # => <PlacesIndex::Query {..., :body=>{:post_filter=>{:match=>{:name=>"Moscow"}}}}>
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-post-filter.html
+      # @see Chewy::Search::Parameters::QueryStorage
+      class PostFilter < Storage
+        include QueryStorage
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+require 'chewy/search/parameters/storage'
+
+module Chewy
+  module Search
+    class Parameters
+      # A standard parameter storage, which updates `query` parameter
+      # of the ES request.
+      #
+      # @example
+      #   PlacesIndex.query(match: {name: 'Moscow'})
+      #   # => <PlacesIndex::Query {..., :body=>{:query=>{:match=>{:name=>"Moscow"}}}}>
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-query.html
+      # @see Chewy::Search::Parameters::QueryStorage
+      class Query < Storage
+        include QueryStorage
+      end
+    end
+  end
+end

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