mongoid 5.4.1 → 6.0.0.beta

data/lib/mongoid/criteria/queryable/key.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # The key is a representation of a field in a queryable, that can be
+      # expanded to special MongoDB selectors.
+      class Key
+
+        # @attribute [r] name The name of the field.
+        # @attribute [r] block The optional block to transform values.
+        # @attribute [r] operator The MongoDB query operator.
+        # @attribute [r] expanded The MongoDB expanded query operator.
+        # @attribute [r] strategy The name of the merge strategy.
+        attr_reader :block, :name, :operator, :expanded, :strategy
+
+        # Does the key equal another object?
+        #
+        # @example Is the key equal to another?
+        #   key == other
+        #   key.eql? other
+        #
+        # @param [ Object ] other The object to compare to.
+        #
+        # @return [ true, false ] If the objects are equal.
+        #
+        # @since 1.0.0
+        def ==(other)
+          return false unless other.is_a?(Key)
+          name == other.name && operator == other.operator && expanded == other.expanded
+        end
+        alias :eql? :==
+
+        # Calculate the hash code for a key.
+        #
+        # @return [ Fixnum ] The hash code for the key.
+        #
+        # @since 1.1.0
+        def hash
+          [name, operator, expanded].hash
+        end
+
+        # Instantiate the new key.
+        #
+        # @example Instantiate the key.
+        #   Key.new("age", "$gt")
+        #
+        # @param [ String, Symbol ] name The field name.
+        # @param [ Symbol ] strategy The name of the merge strategy.
+        # @param [ String ] operator The Mongo operator.
+        # @param [ String ] expanded The Mongo expanded operator.
+        #
+        # @since 1.0.0
+        def initialize(name, strategy, operator, expanded = nil, &block)
+          @name, @strategy, @operator, @expanded, @block =
+            name, strategy, operator, expanded, block
+        end
+
+        # Gets the raw selector that would be passed to Mongo from this key.
+        #
+        # @example Specify the raw selector.
+        #   key.__expr_part__(50)
+        #
+        # @param [ Object ] object The value to be included.
+        # @param [ true, false ] negating If the selection should be negated.
+        #
+        # @return [ Hash ] The raw MongoDB selector.
+        #
+        # @since 1.0.0
+        def __expr_part__(object, negating = false)
+          value = block ? block[object] : object
+          expression = { operator => expanded ? { expanded => value } : value }
+          { name.to_s => (negating && operator != "$not") ? { "$not" => expression } : expression }
+        end
+
+        # Get the key as raw Mongo sorting options.
+        #
+        # @example Get the key as a sort.
+        #   key.__sort_option__
+        #
+        # @return [ Hash ] The field/direction pair.
+        #
+        # @since 1.0.0
+        def __sort_option__
+          { name => operator }
+        end
+        alias :__sort_pair__ :__sort_option__
+
+        # Convert the key to a string.
+        #
+        # @example Convert the key to a string.
+        #   key.to_s
+        #
+        # @return [ String ] The key as a string.
+        #
+        # @since 1.1.0
+        def to_s
+          @name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/queryable/macroable.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # Adds macro behaviour for adding symbol methods.
+      module Macroable
+
+        # Adds a method on Symbol for convenience in where queries for the
+        # provided operators.
+        #
+        # @example Add a symbol key.
+        #   key :all, "$all
+        #
+        # @param [ Symbol ] name The name of the method.
+        # @param [ Symbol ] strategy The merge strategy.
+        # @param [ String ] operator The MongoDB operator.
+        # @param [ String ] additional The additional MongoDB operator.
+        #
+        # @since 1.0.0
+        def key(name, strategy, operator, additional = nil, &block)
+          ::Symbol.add_key(name, strategy, operator, additional, &block)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/queryable/mergeable.rb

@@ -0,0 +1,271 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # Contains behaviour for merging existing selection with new selection.
+      module Mergeable
+
+        # @attribute [rw] strategy The name of the current strategy.
+        attr_accessor :strategy
+
+        # Instruct the next mergeable call to use intersection.
+        #
+        # @example Use intersection on the next call.
+        #   mergeable.intersect.in(field: [ 1, 2, 3 ])
+        #
+        # @return [ Mergeable ] The intersect flagged mergeable.
+        #
+        # @since 1.0.0
+        def intersect
+          use(:__intersect__)
+        end
+
+        # Instruct the next mergeable call to use override.
+        #
+        # @example Use override on the next call.
+        #   mergeable.override.in(field: [ 1, 2, 3 ])
+        #
+        # @return [ Mergeable ] The override flagged mergeable.
+        #
+        # @since 1.0.0
+        def override
+          use(:__override__)
+        end
+
+        # Instruct the next mergeable call to use union.
+        #
+        # @example Use union on the next call.
+        #   mergeable.union.in(field: [ 1, 2, 3 ])
+        #
+        # @return [ Mergeable ] The union flagged mergeable.
+        #
+        # @since 1.0.0
+        def union
+          use(:__union__)
+        end
+
+        # Reset the stratgies to nil, used after cloning.
+        #
+        # @example Reset the strategies.
+        #   mergeable.reset_strategies!
+        #
+        # @return [ nil ] nil.
+        #
+        # @since 1.0.0
+        def reset_strategies!
+          self.strategy, self.negating = nil, nil
+        end
+
+        private
+
+        # Adds the criterion to the existing selection.
+        #
+        # @api private
+        #
+        # @example Add the criterion.
+        #   mergeable.__add__({ name: 1 }, "$in")
+        #
+        # @param [ Hash ] criterion The criteria.
+        # @param [ String ] operator The MongoDB operator.
+        #
+        # @return [ Mergeable ] The new mergeable.
+        #
+        # @since 1.0.0
+        def __add__(criterion, operator)
+          with_strategy(:__add__, criterion, operator)
+        end
+
+        # Adds the criterion to the existing selection.
+        #
+        # @api private
+        #
+        # @example Add the criterion.
+        #   mergeable.__expanded__([ 1, 10 ], "$within", "$center")
+        #
+        # @param [ Hash ] criterion The criteria.
+        # @param [ String ] outer The outer MongoDB operator.
+        # @param [ String ] inner The inner MongoDB operator.
+        #
+        # @return [ Mergeable ] The new mergeable.
+        #
+        # @since 1.0.0
+        def __expanded__(criterion, outer, inner)
+          selection(criterion) do |selector, field, value|
+            selector.store(field, { outer => { inner => value }})
+          end
+        end
+
+        # Perform a straight merge of the criterion into the selection and let the
+        # symbol overrides do all the work.
+        #
+        # @api private
+        #
+        # @example Straight merge the expanded criterion.
+        #   mergeable.__merge__(location: [ 1, 10 ])
+        #
+        # @param [ Hash ] criterion The criteria.
+        #
+        # @return [ Mergeable ] The cloned object.
+        #
+        # @since 2.0.0
+        def __merge__(criterion)
+          selection(criterion) do |selector, field, value|
+            selector.merge!(field.__expr_part__(value))
+          end
+        end
+
+        # Adds the criterion to the existing selection.
+        #
+        # @api private
+        #
+        # @example Add the criterion.
+        #   mergeable.__intersect__([ 1, 2 ], "$in")
+        #
+        # @param [ Hash ] criterion The criteria.
+        # @param [ String ] operator The MongoDB operator.
+        #
+        # @return [ Mergeable ] The new mergeable.
+        #
+        # @since 1.0.0
+        def __intersect__(criterion, operator)
+          with_strategy(:__intersect__, criterion, operator)
+        end
+
+        # Adds the criterion to the existing selection.
+        #
+        # @api private
+        #
+        # @example Add the criterion.
+        #   mergeable.__multi__([ 1, 2 ], "$in")
+        #
+        # @param [ Hash ] criterion The criteria.
+        # @param [ String ] operator The MongoDB operator.
+        #
+        # @return [ Mergeable ] The new mergeable.
+        #
+        # @since 1.0.0
+        def __multi__(criterion, operator)
+          clone.tap do |query|
+            sel = query.selector
+            criterion.flatten.each do |expr|
+              next unless expr
+              criteria = sel[operator] || []
+              normalized = expr.inject({}) do |hash, (field, value)|
+                hash.merge!(field.__expr_part__(value.__expand_complex__))
+                hash
+              end
+              sel.store(operator, criteria.push(normalized))
+            end
+          end
+        end
+
+        # Adds the criterion to the existing selection.
+        #
+        # @api private
+        #
+        # @example Add the criterion.
+        #   mergeable.__override__([ 1, 2 ], "$in")
+        #
+        # @param [ Hash ] criterion The criteria.
+        # @param [ String ] operator The MongoDB operator.
+        #
+        # @return [ Mergeable ] The new mergeable.
+        #
+        # @since 1.0.0
+        def __override__(criterion, operator)
+          selection(criterion) do |selector, field, value|
+            expression = prepare(field, operator, value)
+            existing = selector[field]
+            if existing.respond_to?(:merge!)
+              selector.store(field, existing.merge!(expression))
+            else
+              selector.store(field, expression)
+            end
+          end
+        end
+
+        # Adds the criterion to the existing selection.
+        #
+        # @api private
+        #
+        # @example Add the criterion.
+        #   mergeable.__union__([ 1, 2 ], "$in")
+        #
+        # @param [ Hash ] criterion The criteria.
+        # @param [ String ] operator The MongoDB operator.
+        #
+        # @return [ Mergeable ] The new mergeable.
+        #
+        # @since 1.0.0
+        def __union__(criterion, operator)
+          with_strategy(:__union__, criterion, operator)
+        end
+
+        # Use the named strategy for the next operation.
+        #
+        # @api private
+        #
+        # @example Use intersection.
+        #   mergeable.use(:__intersect__)
+        #
+        # @param [ Symbol ] strategy The strategy to use.
+        #
+        # @return [ Mergeable ] The existing mergeable.
+        #
+        # @since 1.0.0
+        def use(strategy)
+          tap do |mergeable|
+            mergeable.strategy = strategy
+          end
+        end
+
+        # Add criterion to the selection with the named strategy.
+        #
+        # @api private
+        #
+        # @example Add criterion with a strategy.
+        #   mergeable.with_strategy(:__union__, [ 1, 2, 3 ], "$in")
+        #
+        # @param [ Symbol ] strategy The name of the strategy method.
+        # @param [ Object ] criterion The criterion to add.
+        # @param [ String ] operator The MongoDB operator.
+        #
+        # @return [ Mergeable ] The cloned query.
+        #
+        # @since 1.0.0
+        def with_strategy(strategy, criterion, operator)
+          selection(criterion) do |selector, field, value|
+            selector.store(
+              field,
+              selector[field].send(strategy, prepare(field, operator, value))
+            )
+          end
+        end
+
+        # Prepare the value for merging.
+        #
+        # @api private
+        #
+        # @example Prepare the value.
+        #   mergeable.prepare("field", "$gt", 10)
+        #
+        # @param [ String ] field The name of the field.
+        # @param [ Object ] value The value.
+        #
+        # @return [ Object ] The serialized value.
+        #
+        # @since 1.0.0
+        def prepare(field, operator, value)
+          unless operator =~ /exists|type|size/
+            value = value.__expand_complex__
+            serializer = serializers[field]
+            value = serializer ? serializer.evolve(value) : value
+          end
+          selection = { operator => value }
+          negating? ? { "$not" => selection } : selection
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/queryable/optional.rb

@@ -0,0 +1,411 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # The optional module includes all behaviour that has to do with extra
+      # options surrounding queries, like skip, limit, sorting, etc.
+      module Optional
+        extend Macroable
+
+        # @attribute [rw] options The query options.
+        attr_accessor :options
+
+        # Add ascending sorting options for all the provided fields.
+        #
+        # @example Add ascending sorting.
+        #   optional.ascending(:first_name, :last_name)
+        #
+        # @param [ Array<Symbol> ] fields The fields to sort.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def ascending(*fields)
+          sort_with_list(*fields, 1)
+        end
+        alias :asc :ascending
+        key :asc, :override, 1
+        key :ascending, :override, 1
+
+        # Adds the option for telling MongoDB how many documents to retrieve in
+        # it's batching.
+        #
+        # @example Apply the batch size options.
+        #   optional.batch_size(500)
+        #
+        # @param [ Integer ] value The batch size.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def batch_size(value = nil)
+          option(value) { |options| options.store(:batch_size, value) }
+        end
+
+        # Add descending sorting options for all the provided fields.
+        #
+        # @example Add descending sorting.
+        #   optional.descending(:first_name, :last_name)
+        #
+        # @param [ Array<Symbol> ] fields The fields to sort.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def descending(*fields)
+          sort_with_list(*fields, -1)
+        end
+        alias :desc :descending
+        key :desc, :override, -1
+        key :descending, :override, -1
+
+        # Add an index hint to the query options.
+        #
+        # @example Add an index hint.
+        #   optional.hint("$natural" => 1)
+        #
+        # @param [ Hash ] value The index hint.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def hint(value = nil)
+          option(value) { |options| options.store(:hint, value) }
+        end
+
+        # Add the number of documents to limit in the returned results.
+        #
+        # @example Limit the number of returned documents.
+        #   optional.limit(20)
+        #
+        # @param [ Integer ] value The number of documents to return.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def limit(value = nil)
+          option(value) do |options, query|
+            val = value.to_i
+            options.store(:limit, val)
+            query.pipeline.push("$limit" => val) if aggregating?
+          end
+        end
+
+        # Adds the option to limit the number of documents scanned in the
+        # collection.
+        #
+        # @example Add the max scan limit.
+        #   optional.max_scan(1000)
+        #
+        # @param [ Integer ] value The max number of documents to scan.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def max_scan(value = nil)
+          option(value) { |options| options.store(:max_scan, value) }
+        end
+
+        # Adds a cumulative time limit in milliseconds for processing operations on a cursor.
+        #
+        # @example Add the max time ms option.
+        #   optional.max_time_ms(200)
+        #
+        # @param [ Integer ] value The max time in milliseconds for processing operations on a cursor.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 6.0.0
+        def max_time_ms(value = nil)
+          option(value) { |options| options.store(:max_time_ms, value) }
+        end
+
+        # Tell the query not to timeout.
+        #
+        # @example Tell the query not to timeout.
+        #   optional.no_timeout
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def no_timeout
+          clone.tap { |query| query.options.store(:timeout, false) }
+        end
+
+        # Limits the results to only contain the fields provided.
+        #
+        # @example Limit the results to the provided fields.
+        #   optional.only(:name, :dob)
+        #
+        # @param [ Array<Symbol> ] args The fields to return.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def only(*args)
+          args = args.flatten
+          option(*args) do |options|
+            options.store(
+              :fields, args.inject(options[:fields] || {}){ |sub, field| sub.tap { sub[field] = 1 }}
+            )
+          end
+        end
+
+        # Adds sorting criterion to the options.
+        #
+        # @example Add sorting options via a hash with integer directions.
+        #   optional.order_by(name: 1, dob: -1)
+        #
+        # @example Add sorting options via a hash with symbol directions.
+        #   optional.order_by(name: :asc, dob: :desc)
+        #
+        # @example Add sorting options via a hash with string directions.
+        #   optional.order_by(name: "asc", dob: "desc")
+        #
+        # @example Add sorting options via an array with integer directions.
+        #   optional.order_by([[ name, 1 ], [ dob, -1 ]])
+        #
+        # @example Add sorting options via an array with symbol directions.
+        #   optional.order_by([[ name, :asc ], [ dob, :desc ]])
+        #
+        # @example Add sorting options via an array with string directions.
+        #   optional.order_by([[ name, "asc" ], [ dob, "desc" ]])
+        #
+        # @example Add sorting options with keys.
+        #   optional.order_by(:name.asc, :dob.desc)
+        #
+        # @example Add sorting options via a string.
+        #   optional.order_by("name ASC, dob DESC")
+        #
+        # @param [ Array, Hash, String ] spec The sorting specification.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def order_by(*spec)
+          option(spec) do |options, query|
+            spec.compact.each do |criterion|
+              criterion.__sort_option__.each_pair do |field, direction|
+                add_sort_option(options, field, direction)
+              end
+              query.pipeline.push("$sort" => options[:sort]) if aggregating?
+            end
+          end
+        end
+        alias :order :order_by
+
+        # Instead of merging the order criteria, use this method to completely
+        # replace the existing ordering with the provided.
+        #
+        # @example Replace the ordering.
+        #   optional.reorder(name: :asc)
+        #
+        # @param [ Array, Hash, String ] spec The sorting specification.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 2.1.0
+        def reorder(*spec)
+          clone.tap do |query|
+            query.options.delete(:sort)
+          end.order_by(*spec)
+        end
+
+        # Add the number of documents to skip.
+        #
+        # @example Add the number to skip.
+        #   optional.skip(100)
+        #
+        # @param [ Integer ] value The number to skip.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def skip(value = nil)
+          option(value) do |options, query|
+            val = value.to_i
+            options.store(:skip, val)
+            query.pipeline.push("$skip" => val) if aggregating?
+          end
+        end
+        alias :offset :skip
+
+        # Limit the returned results via slicing embedded arrays.
+        #
+        # @example Slice the returned results.
+        #   optional.slice(aliases: [ 0, 5 ])
+        #
+        # @param [ Hash ] criterion The slice options.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def slice(criterion = nil)
+          option(criterion) do |options|
+            options.__union__(
+              fields: criterion.inject({}) do |option, (field, val)|
+                option.tap { |opt| opt.store(field, { "$slice" => val }) }
+              end
+            )
+          end
+        end
+
+        # Tell the query to operate in snapshot mode.
+        #
+        # @example Add the snapshot option.
+        #   optional.snapshot
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def snapshot
+          clone.tap do |query|
+            query.options.store(:snapshot, true)
+          end
+        end
+
+        # Limits the results to only contain the fields not provided.
+        #
+        # @example Limit the results to the fields not provided.
+        #   optional.without(:name, :dob)
+        #
+        # @param [ Array<Symbol> ] args The fields to ignore.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def without(*args)
+          args = args.flatten
+          option(*args) do |options|
+            options.store(
+              :fields, args.inject(options[:fields] || {}){ |sub, field| sub.tap { sub[field] = 0 }}
+            )
+          end
+        end
+
+        # Associate a comment with the query.
+        #
+        # @example Add a comment.
+        #   optional.comment('slow query')
+        #
+        # @note Set profilingLevel to 2 and the comment will be logged in the profile
+        #   collection along with the query.
+        #
+        # @param [ String ] comment The comment to be associated with the query.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 2.2.0
+        def comment(comment = nil)
+          clone.tap do |query|
+            query.options.store(:comment, comment)
+          end
+        end
+
+        # Set the cursor type.
+        #
+        # @example Set the cursor type.
+        #   optional.cursor_type(:tailable)
+        #   optional.cursor_type(:tailable_await)
+        #
+        # @note The cursor can be type :tailable or :tailable_await.
+        #
+        # @param [ Symbol ] type The type of cursor to create.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 2.2.0
+        def cursor_type(type)
+          clone.tap { |query| query.options.store(:cursor_type, type) }
+        end
+
+        private
+
+        # Add a single sort option.
+        #
+        # @api private
+        #
+        # @example Add a single sort option.
+        #   optional.add_sort_option({}, :name, 1)
+        #
+        # @param [ Hash ] options The options.
+        # @param [ String ] field The field name.
+        # @param [ Integer ] direction The sort direction.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def add_sort_option(options, field, direction)
+          if driver == :mongo1x
+            sorting = (options[:sort] || []).dup
+            sorting.push([ field, direction ])
+            options.store(:sort, sorting)
+          else
+            sorting = (options[:sort] || {}).dup
+            sorting[field] = direction
+            options.store(:sort, sorting)
+          end
+        end
+
+        # Take the provided criterion and store it as an option in the query
+        # options.
+        #
+        # @api private
+        #
+        # @example Store the option.
+        #   optional.option({ skip: 10 })
+        #
+        # @param [ Array ] args The options.
+        #
+        # @return [ Queryable ] The cloned queryable.
+        #
+        # @since 1.0.0
+        def option(*args)
+          clone.tap do |query|
+            unless args.compact.empty?
+              yield(query.options, query)
+            end
+          end
+        end
+
+        # Add multiple sort options at once.
+        #
+        # @api private
+        #
+        # @example Add multiple sort options.
+        #   optional.sort_with_list(:name, :dob, 1)
+        #
+        # @param [ Array<String> ] fields The field names.
+        # @param [ Integer ] direction The sort direction.
+        #
+        # @return [ Optional ] The cloned optional.
+        #
+        # @since 1.0.0
+        def sort_with_list(*fields, direction)
+          option(fields) do |options, query|
+            fields.flatten.compact.each do |field|
+              add_sort_option(options, field, direction)
+            end
+            query.pipeline.push("$sort" => options[:sort]) if aggregating?
+          end
+        end
+
+        class << self
+
+          # Get the methods on the optional that can be forwarded to from a model.
+          #
+          # @example Get the forwardable methods.
+          #   Optional.forwardables
+          #
+          # @return [ Array<Symbol> ] The names of the forwardable methods.
+          #
+          # @since 1.0.0
+          def forwardables
+            public_instance_methods(false) - [ :options, :options= ]
+          end
+        end
+      end
+    end
+  end
+end