chewy 0.8.4 → 5.1.0

data/lib/chewy/query/compose.rb

@@ -1,46 +1,45 @@
 module Chewy
   class Query
     module Compose
-
     protected
 
-      def _filtered_query query, filter, options = {}
-        query = { match_all: {} } if !query.present? && filter.present?
+      def _filtered_query(query, filter, options = {})
+        query = {match_all: {}} if !query.present? && filter.present?
 
         if filter.present?
           filtered = if query.present?
-            { query: { filtered: {
+            {query: {filtered: {
               query: query,
               filter: filter
-            } } }
+            }}}
           else
-            { query: { filtered: {
+            {query: {filtered: {
               filter: filter
-            } } }
+            }}}
           end
-          filtered[:query][:filtered].merge!(strategy: options[:strategy].to_s) if options[:strategy].present?
+          filtered[:query][:filtered][:strategy] = options[:strategy].to_s if options[:strategy].present?
           filtered
         elsif query.present?
-          { query: query }
+          {query: query}
         else
-          { }
+          {}
         end
       end
 
-      def _queries_join queries, logic
+      def _queries_join(queries, logic)
         queries = queries.compact
 
         if queries.many? || (queries.present? && logic == :must_not)
           case logic
           when :dis_max
-            { dis_max: { queries: queries } }
+            {dis_max: {queries: queries}}
           when :must, :should, :must_not
-            { bool: { logic => queries } }
+            {bool: {logic => queries}}
           else
             if logic.is_a?(Float)
-              { dis_max: { queries: queries, tie_breaker: logic } }
+              {dis_max: {queries: queries, tie_breaker: logic}}
             else
-              { bool: { should: queries, minimum_should_match: logic } }
+              {bool: {should: queries, minimum_should_match: logic}}
             end
           end
         else
@@ -48,17 +47,17 @@ module Chewy
         end
       end
 
-      def _filters_join filters, logic
+      def _filters_join(filters, logic)
         filters = filters.compact
 
         if filters.many? || (filters.present? && logic == :must_not)
           case logic
           when :and, :or
-            { logic => filters }
+            {logic => filters}
           when :must, :should, :must_not
-            { bool: { logic => filters } }
+            {bool: {logic => filters}}
           else
-            { bool: { should: filters, minimum_should_match: logic } }
+            {bool: {should: filters, minimum_should_match: logic}}
           end
         else
           filters.first

data/lib/chewy/query/criteria.rb

@@ -4,11 +4,11 @@ module Chewy
   class Query
     class Criteria
       include Compose
-      ARRAY_STORAGES = [:queries, :filters, :post_filters, :sort, :fields, :types, :scores]
-      HASH_STORAGES = [:options, :request_options, :facets, :aggregations, :suggest, :script_fields]
+      ARRAY_STORAGES = %i[queries filters post_filters sort fields types scores].freeze
+      HASH_STORAGES = %i[options search_options request_options facets aggregations suggest script_fields].freeze
       STORAGES = ARRAY_STORAGES + HASH_STORAGES
 
-      def initialize options = {}
+      def initialize(options = {})
         @options = options.merge(
           query_mode: Chewy.query_mode,
           filter_mode: Chewy.filter_mode,
@@ -16,11 +16,11 @@ module Chewy
         )
       end
 
-      def == other
+      def ==(other)
         other.is_a?(self.class) && storages == other.storages
       end
 
-      { ARRAY_STORAGES => '[]', HASH_STORAGES => '{}' }.each do |storages, default|
+      {ARRAY_STORAGES => '[]', HASH_STORAGES => '{}'}.each do |storages, default|
         storages.each do |storage|
           class_eval <<-METHODS, __FILE__, __LINE__ + 1
             def #{storage}
@@ -32,7 +32,7 @@ module Chewy
 
       STORAGES.each do |storage|
         define_method "#{storage}?" do
-          send(storage).present?
+          send(storage).any?
         end
       end
 
@@ -48,6 +48,10 @@ module Chewy
         request_options.merge!(modifier)
       end
 
+      def update_search_options(modifier)
+        search_options.merge!(modifier)
+      end
+
       def update_facets(modifier)
         facets.merge!(modifier)
       end
@@ -68,7 +72,7 @@ module Chewy
         script_fields.merge!(modifier)
       end
 
-      [:filters, :queries, :post_filters].each do |storage|
+      %i[filters queries post_filters].each do |storage|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def update_#{storage}(modifier)
             @#{storage} = #{storage} + Array.wrap(modifier).reject(&:blank?)
@@ -84,7 +88,7 @@ module Chewy
         @sort = sort + modifier
       end
 
-      %w(fields types).each do |storage|
+      %w[fields types].each do |storage|
         define_method "update_#{storage}" do |modifier, options = {}|
           variable = "@#{storage}"
           instance_variable_set(variable, nil) if options[:purge]
@@ -93,14 +97,14 @@ module Chewy
         end
       end
 
-      def merge! other
+      def merge!(other)
         STORAGES.each do |storage|
           send("update_#{storage}", other.send(storage))
         end
         self
       end
 
-      def merge other
+      def merge(other)
         clone.merge!(other)
       end
 
@@ -108,19 +112,19 @@ module Chewy
         body = _filtered_query(_request_query, _request_filter, options.slice(:strategy))
 
         if options[:simple]
-          { body: body.presence || { query: { match_all: {} } } }
+          {body: body.presence || {query: {match_all: {}}}}
         else
-          body.merge!(post_filter: _request_post_filter) if post_filters?
-          body.merge!(facets: facets) if facets?
-          body.merge!(aggregations: aggregations) if aggregations?
-          body.merge!(suggest: suggest) if suggest?
-          body.merge!(sort: sort) if sort?
-          body.merge!(_source: fields) if fields?
-          body.merge!(script_fields: script_fields) if script_fields?
+          body[:post_filter] = _request_post_filter if post_filters?
+          body[:facets] = facets if facets?
+          body[:aggregations] = aggregations if aggregations?
+          body[:suggest] = suggest if suggest?
+          body[:sort] = sort if sort?
+          body[:_source] = fields if fields?
+          body[:script_fields] = script_fields if script_fields?
 
           body = _boost_query(body)
 
-          { body: body.merge!(request_options) }
+          {body: body.merge!(_request_options)}.merge!(search_options)
         end
       end
 
@@ -130,9 +134,9 @@ module Chewy
         STORAGES.map { |storage| send(storage) }
       end
 
-      def initialize_clone(other)
+      def initialize_clone(origin)
         STORAGES.each do |storage|
-          value = other.send(storage)
+          value = origin.send(storage)
           instance_variable_set("@#{storage}", value.deep_dup)
         end
       end
@@ -142,7 +146,7 @@ module Chewy
         query = body.delete :query
         filter = body.delete :filter
         if query && filter
-          query = { filtered: { query: query, filter: filter } }
+          query = {filtered: {query: query, filter: filter}}
           filter = nil
         end
         score = {}
@@ -151,7 +155,13 @@ module Chewy
         score[:score_mode] = options[:score_mode] if options[:score_mode]
         score[:query] = query if query
         score[:filter] = filter if filter
-        body.tap { |b| b[:query] = { function_score: score } }
+        body.tap { |b| b[:query] = {function_score: score} }
+      end
+
+      def _request_options
+        Hash[request_options.map do |key, value|
+          [key, value.is_a?(Proc) ? value.call : value]
+        end]
       end
 
       def _request_query
@@ -170,7 +180,7 @@ module Chewy
       end
 
       def _request_types
-        _filters_join(types.map { |type| { type: { value: type } } }, :or)
+        _filters_join(types.map { |type| {type: {value: type}} }, :or)
       end
 
       def _request_post_filter

data/lib/chewy/query/filters.rb

@@ -24,25 +24,27 @@ module Chewy
     # You can use logic operations <tt>&</tt> and <tt>|</tt> to concat
     # expressions.
     #
+    # @example
     #   UsersIndex.filter{ (article.title =~ /Honey/) & (age < 42) & !rate }
     #
     #
     class Filters
-      def initialize outer = nil, &block
+      def initialize(outer = nil, &block)
         @block = block
-        @outer = outer || eval('self', block.binding)
+        @outer = outer || eval('self', block.binding, __FILE__, __LINE__)
       end
 
       # Outer scope call
       # Block evaluates in the external context
       #
+      # @example
       #   def name
       #     'Friend'
       #   end
       #
       #   UsersIndex.filter{ name == o{ name } } # => {filter: {term: {name: 'Friend'}}}
       #
-      def o &block
+      def o(&block)
         @outer.instance_exec(&block)
       end
 
@@ -50,19 +52,21 @@ module Chewy
       # Used if method_missing is not working by some reason.
       # Additional expression options might be passed as second argument hash.
       #
+      # @example
       #   UsersIndex.filter{ f(:name) == 'Name' } == UsersIndex.filter{ name == 'Name' } # => true
       #   UsersIndex.filter{ f(:name, execution: :bool) == ['Name1', 'Name2'] } ==
       #     UsersIndex.filter{ name(execution: :bool) == ['Name1', 'Name2'] } # => true
       #
       # Supports block for getting field name from the outer scope
       #
+      # @example
       #   def field
       #     :name
       #   end
       #
       #   UsersIndex.filter{ f{ field } == 'Name' } == UsersIndex.filter{ name == 'Name' } # => true
       #
-      def f name = nil, *args, &block
+      def f(name = nil, *args, &block)
         name = block ? o(&block) : name
         Nodes::Field.new name, *args
       end
@@ -70,11 +74,13 @@ module Chewy
       # Returns script filter
       # Just script filter. Supports additional params.
       #
+      # @example
       #   UsersIndex.filter{ s('doc["num1"].value > 1') }
       #   UsersIndex.filter{ s('doc["num1"].value > param1', param1: 42) }
       #
       # Supports block for getting script from the outer scope
       #
+      # @example
       #   def script
       #     'doc["num1"].value > param1 || 1'
       #   end
@@ -82,7 +88,7 @@ module Chewy
       #   UsersIndex.filter{ s{ script } } == UsersIndex.filter{ s('doc["num1"].value > 1') } # => true
       #   UsersIndex.filter{ s(param1: 42) { script } } == UsersIndex.filter{ s('doc["num1"].value > 1', param1: 42) } # => true
       #
-      def s *args, &block
+      def s(*args, &block)
         params = args.extract_options!
         script = block ? o(&block) : args.first
         Nodes::Script.new script, params
@@ -90,28 +96,32 @@ module Chewy
 
       # Returns query filter
       #
+      # @example
       #   UsersIndex.filter{ q(query_string: {query: 'name: hello'}) }
       #
       # Supports block for getting query from the outer scope
       #
+      # @example
       #   def query
       #     {query_string: {query: 'name: hello'}}
       #   end
       #
       #   UsersIndex.filter{ q{ query } } == UsersIndex.filter{ q(query_string: {query: 'name: hello'}) } # => true
       #
-      def q query = nil, &block
+      def q(query = nil, &block)
         Nodes::Query.new block ? o(&block) : query
       end
 
       # Returns raw expression
       # Same as filter with arguments instead of block, but can participate in expressions
       #
+      # @example
       #   UsersIndex.filter{ r(term: {name: 'Name'}) }
       #   UsersIndex.filter{ r(term: {name: 'Name'}) & (age < 42) }
       #
       # Supports block for getting raw filter from the outer scope
       #
+      # @example
       #   def filter
       #     {term: {name: 'Name'}}
       #   end
@@ -119,19 +129,20 @@ module Chewy
       #   UsersIndex.filter{ r{ filter } } == UsersIndex.filter{ r(term: {name: 'Name'}) } # => true
       #   UsersIndex.filter{ r{ filter } } == UsersIndex.filter(term: {name: 'Name'}) # => true
       #
-      def r raw = nil, &block
+      def r(raw = nil, &block)
         Nodes::Raw.new block ? o(&block) : raw
       end
 
       # Bool filter chainable methods
       # Used to create bool query. Nodes are passed as arguments.
       #
+      # @example
       #   UsersIndex.filter{ must(age < 42, name == 'Name') }
       #   UsersIndex.filter{ should(age < 42, name == 'Name') }
       #   UsersIndex.filter{ must(age < 42).should(name == 'Name1', name == 'Name2') }
       #   UsersIndex.filter{ should_not(age >= 42).must(name == 'Name1') }
       #
-      %w(must must_not should).each do |method|
+      %w[must must_not should].each do |method|
         define_method method do |*exprs|
           Nodes::Bool.new.send(method, *exprs)
         end
@@ -141,12 +152,14 @@ module Chewy
       # Chainable interface acts the same as main query interface. You can pass plain
       # filters or plain queries or filter with DSL block.
       #
+      # @example
       #   UsersIndex.filter{ has_child('user').filter(term: {role: 'Admin'}) }
       #   UsersIndex.filter{ has_child('user').filter{ role == 'Admin' } }
       #   UsersIndex.filter{ has_child('user').query(match: {name: 'borogoves'}) }
       #
       # Filters and queries might be combined and filter_mode and query_mode are configurable:
       #
+      # @example
       #   UsersIndex.filter do
       #     has_child('user')
       #       .filter{ name: 'Peter' }
@@ -155,7 +168,7 @@ module Chewy
       #       .filter_mode(:or)
       #   end
       #
-      def has_child type
+      def has_child(type) # rubocop:disable Naming/PredicateName
         Nodes::HasChild.new(type, @outer)
       end
 
@@ -163,12 +176,14 @@ module Chewy
       # Chainable interface acts the same as main query interface. You can pass plain
       # filters or plain queries or filter with DSL block.
       #
+      # @example
       #   UsersIndex.filter{ has_parent('user').filter(term: {role: 'Admin'}) }
       #   UsersIndex.filter{ has_parent('user').filter{ role == 'Admin' } }
       #   UsersIndex.filter{ has_parent('user').query(match: {name: 'borogoves'}) }
       #
       # Filters and queries might be combined and filter_mode and query_mode are configurable:
       #
+      # @example
       #   UsersIndex.filter do
       #     has_parent('user')
       #       .filter{ name: 'Peter' }
@@ -177,7 +192,7 @@ module Chewy
       #       .filter_mode(:or)
       #   end
       #
-      def has_parent type
+      def has_parent(type) # rubocop:disable Naming/PredicateName
         Nodes::HasParent.new(type, @outer)
       end
 
@@ -190,6 +205,7 @@ module Chewy
       # Creates field or exists node
       # Additional options for further expression might be passed as hash
       #
+      # @example
       #   UsersIndex.filter{ name == 'Name' } == UsersIndex.filter(term: {name: 'Name'}) # => true
       #   UsersIndex.filter{ name? } == UsersIndex.filter(exists: {term: 'name'}) # => true
       #   UsersIndex.filter{ name(execution: :bool) == ['Name1', 'Name2'] } ==
@@ -197,10 +213,11 @@ module Chewy
       #
       # Also field names might be chained to use dot-notation for ES field names
       #
+      # @example
       #   UsersIndex.filter{ article.title =~ 'Hello' }
       #   UsersIndex.filter{ article.tags? }
       #
-      def method_missing method, *args, &block
+      def method_missing(method, *args) # rubocop:disable Style/MethodMissing
         method = method.to_s
         if method =~ /\?\Z/
           Nodes::Exists.new method.gsub(/\?\Z/, '')

data/lib/chewy/query/loading.rb

@@ -94,10 +94,9 @@ module Chewy
         loaded_objects = Hash[_results.group_by(&:class).map do |type, objects|
           next if except.include?(type.type_name)
           next if only.present? && !only.include?(type.type_name)
-
-          loaded = type.adapter.load(objects, options.merge(_type: type))
-          [type, loaded.index_by.with_index do |loaded, i|
-            objects[i]._object = loaded
+          loaded = type.adapter.load(objects.map(&:id), options.merge(_type: type)) || objects
+          [type, loaded.index_by.with_index do |loaded_object, i|
+            objects[i]._object = loaded_object
             objects[i]
           end]
         end.compact]

data/lib/chewy/query/nodes/and.rb

@@ -2,7 +2,7 @@ module Chewy
   class Query
     module Nodes
       class And < Expr
-        def initialize *nodes
+        def initialize(*nodes)
           @options = nodes.extract_options!
           @nodes = nodes.flatten.map { |node| node.is_a?(self.class) ? node.__nodes__ : node }.flatten
         end

data/lib/chewy/query/nodes/base.rb

@@ -6,7 +6,7 @@ module Chewy
           raise NotImplementedError
         end
 
-        def eql? other
+        def eql?(other)
           other.is_a?(self.class) && instance_variables.all? do |ivar|
             instance_variable_get(ivar).eql? other.instance_variable_get(ivar)
           end

data/lib/chewy/query/nodes/bool.rb

@@ -2,16 +2,18 @@ module Chewy
   class Query
     module Nodes
       class Bool < Expr
-        METHODS = %w(must must_not should)
+        METHODS = %w[must must_not should].freeze
 
-        def initialize options = {}
+        def initialize(options = {})
           @options = options
-          @must, @must_not, @should = [], [], []
+          @must = []
+          @must_not = []
+          @should = []
         end
 
         METHODS.each do |method|
           define_method method do |*exprs|
-            instance_variable_get("@#{method}").push(*exprs)
+            instance_variable_get("@#{method}").concat(exprs)
             self
           end
         end

data/lib/chewy/query/nodes/equal.rb

@@ -10,10 +10,10 @@ module Chewy
           :b => :bool,
           :bool => :bool,
           :f => :fielddata,
-          :fielddata => :fielddata,
-        }
+          :fielddata => :fielddata
+        }.freeze
 
-        def initialize name, value, *args
+        def initialize(name, value, *args)
           @name = name.to_s
           @value = value
           @options = args.extract_options!
@@ -25,7 +25,7 @@ module Chewy
           filter = (@value.is_a?(Array) ? :terms : :term)
           body = {@name => @value}
           body.merge!(@options.slice(:execution)) if filter == :terms
-          body.merge!(_cache: !!@options[:cache]) if @options.key?(:cache)
+          body[:_cache] = !!@options[:cache] if @options.key?(:cache)
           {filter => body}
         end
       end

data/lib/chewy/query/nodes/exists.rb

@@ -2,7 +2,7 @@ module Chewy
   class Query
     module Nodes
       class Exists < Expr
-        def initialize name, options = {}
+        def initialize(name, options = {})
           @name = name.to_s
           @options = options
         end

data/lib/chewy/query/nodes/expr.rb

@@ -2,11 +2,11 @@ module Chewy
   class Query
     module Nodes
       class Expr < Base
-        def & other
+        def &(other)
           Nodes::And.new self, other
         end
 
-        def | other
+        def |(other)
           Nodes::Or.new self, other
         end
 

data/lib/chewy/query/nodes/field.rb

@@ -2,7 +2,7 @@ module Chewy
   class Query
     module Nodes
       class Field < Base
-        def initialize name, *args
+        def initialize(name, *args)
           @name = name.to_s
           @args = args
         end
@@ -16,70 +16,74 @@ module Chewy
           self
         end
 
-        def > value
-          Nodes::Range.new @name, *__options_merge__(gt: value)
+        def >(other)
+          Nodes::Range.new @name, *__options_merge__(gt: other)
         end
 
-        def < value
-          Nodes::Range.new @name, *__options_merge__(lt: value)
+        def <(other)
+          Nodes::Range.new @name, *__options_merge__(lt: other)
         end
 
-        def >= value
-          Nodes::Range.new @name, *__options_merge__(gt: value, left_closed: true)
+        def >=(other)
+          Nodes::Range.new @name, *__options_merge__(gt: other, left_closed: true)
         end
 
-        def <= value
-          Nodes::Range.new @name, *__options_merge__(lt: value, right_closed: true)
+        def <=(other)
+          Nodes::Range.new @name, *__options_merge__(lt: other, right_closed: true)
         end
 
-        def == value
-          case value
+        def ==(other)
+          case other
           when nil
-            Nodes::Missing.new @name, existence: false, null_value: true
+            nil?
           when ::Regexp
-            Nodes::Regexp.new @name, value, *@args
+            Nodes::Regexp.new @name, other, *@args
           when ::Range
-            Nodes::Range.new @name, *__options_merge__(gt: value.first, lt: value.last)
+            Nodes::Range.new @name, *__options_merge__(gt: other.first, lt: other.last)
           else
-            if value.is_a?(Array) && value.first.is_a?(::Range)
+            if other.is_a?(Array) && other.first.is_a?(::Range)
               Nodes::Range.new @name, *__options_merge__(
-                gt: value.first.first, lt: value.first.last,
+                gt: other.first.first, lt: other.first.last,
                 left_closed: true, right_closed: true
               )
             else
-              Nodes::Equal.new @name, value, *@args
+              Nodes::Equal.new @name, other, *@args
             end
           end
         end
 
-        def != value
-          case value
+        def !=(other)
+          case other
           when nil
             Nodes::Exists.new @name
           else
-            Nodes::Not.new self == value
+            Nodes::Not.new self == other
           end
         end
 
-        def =~ value
-          case value
+        def =~(other)
+          case other
           when ::Regexp
-            Nodes::Regexp.new @name, value, *@args
+            Nodes::Regexp.new @name, other, *@args
           else
-            Nodes::Prefix.new @name, value, @args.extract_options!
+            Nodes::Prefix.new @name, other, @args.extract_options!
           end
         end
 
-        def !~ value
-          Not.new(self =~ value)
+        def !~(other)
+          Not.new(self =~ other)
         end
 
-        def method_missing method, *args, &block
+        def nil?
+          Nodes::Missing.new @name, existence: false, null_value: true
+        end
+
+        def method_missing(method, *args) # rubocop:disable Style/MethodMissing
           method = method.to_s
           if method =~ /\?\Z/
-            Nodes::Exists.new [@name, method.gsub(/\?\Z/, '')].join(?.)
+            Nodes::Exists.new [@name, method.gsub(/\?\Z/, '')].join('.')
           else
-            self.class.new [@name, method].join(?.), *args
+            self.class.new [@name, method].join('.'), *args
           end
         end
 
@@ -89,13 +93,13 @@ module Chewy
 
       private
 
-        def __options_merge__! additional = {}
+        def __options_merge__!(additional = {})
           options = @args.extract_options!
           options = options.merge(additional)
           @args.push(options)
         end
 
-        def __options_merge__ additional = {}
+        def __options_merge__(additional = {})
           options = @args.extract_options!
           options = options.merge(additional)
           @args + [options]