mongoid 5.4.1 → 6.1.1

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # Allows for easy delegation of queryable queryable instance methods to a
+      # specific method.
+      module Forwardable
+
+        # Tells queryable with method on the class to delegate to when calling an
+        # original selectable or optional method on the class.
+        #
+        # @example Tell queryable where to select from.
+        #   class Band
+        #     extend Queryable::Forwardable
+        #     select_with :criteria
+        #
+        #     def self.criteria
+        #       Query.new
+        #     end
+        #   end
+        #
+        # @param [ Symbol ] receiver The name of the receiver method.
+        #
+        # @return [ Array<Symbol> ] The names of the forwarded methods.
+        #
+        # @since 1.0.0
+        def select_with(receiver)
+          (Selectable.forwardables + Optional.forwardables).each do |name|
+            __forward__(name, receiver)
+          end
+        end
+
+        private
+
+        # Forwards the method name to the provided receiver method.
+        #
+        # @api private
+        #
+        # @example Define the forwarding.
+        #   Model.__forward__(:exists, :criteria)
+        #
+        # @param [ Symbol ] name The name of the method.
+        # @param [ Symbol ] receiver The name of the receiver method.
+        #
+        # @since 1.0.0
+        def __forward__(name, receiver)
+          if self.class == Module
+            module_eval <<-SEL, __FILE__, __LINE__ + 1
+              def #{name}(*args, &block)
+                #{receiver}.__send__(:#{name}, *args, &block)
+              end
+            SEL
+          else
+            singleton_class.class_eval <<-SEL, __FILE__, __LINE__ + 1
+              def #{name}(*args, &block)
+                #{receiver}.__send__(:#{name}, *args, &block)
+              end
+            SEL
+          end
+        end
+      end
+    end
+  end
+end

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