chewy 5.0.0 → 7.0.1

data/lib/chewy/query/loading.rb

@@ -1,110 +0,0 @@
-module Chewy
-  class Query
-    module Loading
-      extend ActiveSupport::Concern
-
-      # Lazily loads actual ORM/ODM objects for search result.
-      # Returns scope marked to return loaded objects array instead of
-      # chewy wrappers. In case when object can not be loaded because it
-      # was deleted or don't satisfy given scope or options - the
-      # result collection will contain nil value in the place of this
-      # object. Use `compact` method to avoid this if necessary.
-      #
-      #   UsersIndex.query(...).load #=> [#<User id: 42...>, ...]
-      #   UsersIndex.query(...).load.filter(...) #=> [#<User id: 42...>, ...]
-      #
-      # Possible options:
-      #
-      #   <tt>:scope</tt> - used to give a scope for _every_ loaded type.
-      #
-      #       PlacesIndex.query(...).load(scope: ->{ includes(:testimonials) })
-      #
-      #     If places here contain cities and countries then preload will be
-      #     done like this:
-      #
-      #       City.where(id: [...]).includes(:testimonials)
-      #       Country.where(id: [...]).includes(:testimonials)
-      #
-      #     It is also possible to pass own scope for every loaded type:
-      #
-      #       PlacesIndex.query(...).load(
-      #         city: { scope: ->{ includes(:testimonials, :country) }}
-      #         country: { scope: ->{ includes(:testimonials, :cities) }}
-      #       )
-      #
-      #     And loading will be performed as:
-      #
-      #       City.where(id: [...]).includes(:testimonials, :country)
-      #       Country.where(id: [...]).includes(:testimonials, :cities)
-      #
-      #     In case of ActiveRecord objects loading the same result
-      #     will be reached using ActiveRecord scopes instead of
-      #     lambdas. But it works only with per-type scopes,
-      #     and doesn't work with the common scope.
-      #
-      #       PlacesIndex.query(...).load(
-      #         city: { scope: City.includes(:testimonials, :country) }
-      #         country: { scope: Country.includes(:testimonials, :cities) }
-      #       )
-      #
-      #   <tt>:only</tt> - loads objects for the specified types
-      #
-      #     PlacesIndex.query(...).load(only: :city)
-      #     PlacesIndex.query(...).load(only: [:city])
-      #     PlacesIndex.query(...).load(only: [:city, :country])
-      #
-      #   <tt>:except</tt> - doesn't load listed types
-      #
-      #     PlacesIndex.query(...).load(except: :city)
-      #     PlacesIndex.query(...).load(except: [:city])
-      #     PlacesIndex.query(...).load(except: [:city, :country])
-      #
-      def load(options = {})
-        chain { criteria.update_options preload: options, loaded_objects: true }
-      end
-
-      # This methods is just convenient way to preload some ORM/ODM
-      # objects and continue to work with Chewy wrappers. Returns
-      # Chewy query scope. Note that `load` method performs ES request
-      # so preload method should also be the last in scope methods chain.
-      # Takes the same options as the `load` method
-      #
-      #   PlacesIndex.query(...).preload(only: :city)
-      #
-      # Loaded objects are also attached to corresponding Chewy
-      # type wrapper objects and available with `_object` accessor.
-      #
-      #    scope = PlacesIndex.query(...)
-      #    preload_scope = scope.preload
-      #    preload_scope.first #=> PlacesIndex::City wrapper instance
-      #    preload_scope.first._object #=> City model instance
-      #    scope.load == preload_scope.map(&:_object) #=> true
-      #
-      def preload(options = {})
-        chain { criteria.update_options preload: options, loaded_objects: false }
-      end
-
-    private
-
-      def _load_objects!
-        options = criteria.options[:preload]
-        only = Array.wrap(options[:only]).map(&:to_s)
-        except = Array.wrap(options[:except]).map(&:to_s)
-
-        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.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]
-
-        _results.map do |result|
-          loaded_objects[result.class][result] if loaded_objects[result.class]
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Chewy
-  class Query
-    module Nodes
-      class And < Expr
-        def initialize(*nodes)
-          @options = nodes.extract_options!
-          @nodes = nodes.flatten.map { |node| node.is_a?(self.class) ? node.__nodes__ : node }.flatten
-        end
-
-        def __nodes__
-          @nodes
-        end
-
-        def __render__
-          nodes = @nodes.map(&:__render__)
-          if @options.key?(:cache)
-            {and: {filters: nodes, _cache: !!@options[:cache]}}
-          else
-            {and: nodes}
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Chewy
-  class Query
-    module Nodes
-      class Base
-        def render
-          raise NotImplementedError
-        end
-
-        def eql?(other)
-          other.is_a?(self.class) && instance_variables.all? do |ivar|
-            instance_variable_get(ivar).eql? other.instance_variable_get(ivar)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-module Chewy
-  class Query
-    module Nodes
-      class Bool < Expr
-        METHODS = %w[must must_not should].freeze
-
-        def initialize(options = {})
-          @options = options
-          @must = []
-          @must_not = []
-          @should = []
-        end
-
-        METHODS.each do |method|
-          define_method method do |*exprs|
-            instance_variable_get("@#{method}").concat(exprs)
-            self
-          end
-        end
-
-        def __render__
-          bool = {
-            bool: Hash[METHODS.map do |method|
-              value = instance_variable_get("@#{method}")
-              [method.to_sym, value.map(&:__render__)] if value.present?
-            end.compact]
-          }
-          bool[:bool][:_cache] = !!@options[:cache] if @options.key?(:cache)
-          bool
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-module Chewy
-  class Query
-    module Nodes
-      class Equal < Expr
-        EXECUTION = {
-          :| => :or,
-          :or => :or,
-          :& => :and,
-          :and => :and,
-          :b => :bool,
-          :bool => :bool,
-          :f => :fielddata,
-          :fielddata => :fielddata
-        }.freeze
-
-        def initialize(name, value, *args)
-          @name = name.to_s
-          @value = value
-          @options = args.extract_options!
-          execution = EXECUTION[args.first.to_sym] if args.first
-          @options[:execution] = execution if execution
-        end
-
-        def __render__
-          filter = (@value.is_a?(Array) ? :terms : :term)
-          body = {@name => @value}
-          body.merge!(@options.slice(:execution)) if filter == :terms
-          body[:_cache] = !!@options[:cache] if @options.key?(:cache)
-          {filter => body}
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Chewy
-  class Query
-    module Nodes
-      class Exists < Expr
-        def initialize(name, options = {})
-          @name = name.to_s
-          @options = options
-        end
-
-        def !
-          Nodes::Missing.new @name, null_value: true
-        end
-
-        def __render__
-          {exists: {field: @name}}
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module Chewy
-  class Query
-    module Nodes
-      class Expr < Base
-        def &(other)
-          Nodes::And.new self, other
-        end
-
-        def |(other)
-          Nodes::Or.new self, other
-        end
-
-        def !
-          Nodes::Not.new self
-        end
-
-        def ~
-          @options[:cache] = true
-          self
-        end
-
-        def __render__
-          raise NotImplementedError
-        end
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-module Chewy
-  class Query
-    module Nodes
-      class Field < Base
-        def initialize(name, *args)
-          @name = name.to_s
-          @args = args
-        end
-
-        def !
-          Nodes::Missing.new @name
-        end
-
-        def ~
-          __options_merge__!(cache: true)
-          self
-        end
-
-        def >(other)
-          Nodes::Range.new @name, *__options_merge__(gt: other)
-        end
-
-        def <(other)
-          Nodes::Range.new @name, *__options_merge__(lt: other)
-        end
-
-        def >=(other)
-          Nodes::Range.new @name, *__options_merge__(gt: other, left_closed: true)
-        end
-
-        def <=(other)
-          Nodes::Range.new @name, *__options_merge__(lt: other, right_closed: true)
-        end
-
-        def ==(other)
-          case other
-          when nil
-            nil?
-          when ::Regexp
-            Nodes::Regexp.new @name, other, *@args
-          when ::Range
-            Nodes::Range.new @name, *__options_merge__(gt: other.first, lt: other.last)
-          else
-            if other.is_a?(Array) && other.first.is_a?(::Range)
-              Nodes::Range.new @name, *__options_merge__(
-                gt: other.first.first, lt: other.first.last,
-                left_closed: true, right_closed: true
-              )
-            else
-              Nodes::Equal.new @name, other, *@args
-            end
-          end
-        end
-
-        def !=(other)
-          case other
-          when nil
-            Nodes::Exists.new @name
-          else
-            Nodes::Not.new self == other
-          end
-        end
-
-        def =~(other)
-          case other
-          when ::Regexp
-            Nodes::Regexp.new @name, other, *@args
-          else
-            Nodes::Prefix.new @name, other, @args.extract_options!
-          end
-        end
-
-        def !~(other)
-          Not.new(self =~ other)
-        end
-
-        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('.')
-          else
-            self.class.new [@name, method].join('.'), *args
-          end
-        end
-
-        def to_ary
-          nil
-        end
-
-      private
-
-        def __options_merge__!(additional = {})
-          options = @args.extract_options!
-          options = options.merge(additional)
-          @args.push(options)
-        end
-
-        def __options_merge__(additional = {})
-          options = @args.extract_options!
-          options = options.merge(additional)
-          @args + [options]
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-require 'chewy/query/nodes/has_relation'
-
-module Chewy
-  class Query
-    module Nodes
-      class HasChild < HasRelation
-      private
-
-        def _relation
-          :has_child
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-require 'chewy/query/nodes/has_relation'
-
-module Chewy
-  class Query
-    module Nodes
-      class HasParent < HasRelation
-      private
-
-        def _relation
-          :has_parent
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-require 'chewy/query/compose'
-
-module Chewy
-  class Query
-    module Nodes
-      class HasRelation < Expr
-        include Compose
-
-        def initialize(type, outer = nil)
-          @type = type.to_s
-          @outer = outer
-          @query_mode = :must
-          @filter_mode = :and
-          @queries = []
-          @filters = []
-        end
-
-        def query_mode(mode)
-          @query_mode = mode
-          self
-        end
-
-        def filter_mode(mode)
-          @filter_mode = mode
-          self
-        end
-
-        def query(params = nil, &block)
-          raise 'Query DLS is not supported yet' if block
-          @queries.push(params)
-          self
-        end
-
-        def filter(params = nil, &block)
-          if block
-            @filters.push(Chewy::Query::Filters.new(@outer, &block).__render__)
-          else
-            @filters.push(params)
-          end
-          self
-        end
-
-        def __render__
-          queries = _queries_join @queries, @query_mode
-          filters = _filters_join @filters, @filter_mode
-
-          body = if filters && !queries
-            {filter: filters}
-          else
-            _filtered_query(queries, filters)
-          end
-          body ||= {}
-
-          {_relation => body.merge(type: @type)}
-        end
-      end
-    end
-  end
-end