mongoid 5.4.0 → 6.4.8

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

@@ -0,0 +1,212 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # The selector is a special kind of hash that knows how to serialize values
+      # coming into it as well as being alias and locale aware for key names.
+      class Selector < Smash
+
+        # Merges another selector into this one.
+        #
+        # @example Merge in another selector.
+        #   selector.merge!(name: "test")
+        #
+        # @param [ Hash, Selector ] other The object to merge in.
+        #
+        # @return [ Selector ] The selector.
+        #
+        # @since 1.0.0
+        def merge!(other)
+          other.each_pair do |key, value|
+            if value.is_a?(Hash) && self[key.to_s].is_a?(Hash)
+              value = self[key.to_s].merge(value) do |_key, old_val, new_val|
+                if in?(_key)
+                  new_val & old_val
+                elsif nin?(_key)
+                  (old_val + new_val).uniq
+                else
+                  new_val
+                end
+              end
+            end
+            if multi_selection?(key)
+              value = (self[key.to_s] || []).concat(value)
+            end
+            store(key, value)
+          end
+        end
+
+        # Store the value in the selector for the provided key. The selector will
+        # handle all necessary serialization and localization in this step.
+        #
+        # @example Store a value in the selector.
+        #   selector.store(:key, "testing")
+        #
+        # @param [ String, Symbol ] key The name of the attribute.
+        # @param [ Object ] value The value to add.
+        #
+        # @return [ Object ] The stored object.
+        #
+        # @since 1.0.0
+        def store(key, value)
+          name, serializer = storage_pair(key)
+          if multi_selection?(name)
+            super(name, evolve_multi(value))
+          else
+            super(localized_key(name, serializer), evolve(serializer, value))
+          end
+        end
+        alias :[]= :store
+
+        # Convert the selector to an aggregation pipeline entry.
+        #
+        # @example Convert the selector to a pipeline.
+        #   selector.to_pipeline
+        #
+        # @return [ Array<Hash> ] The pipeline entry for the selector.
+        #
+        # @since 2.0.0
+        def to_pipeline
+          pipeline = []
+          pipeline.push({ "$match" => self }) unless empty?
+          pipeline
+        end
+
+        private
+
+        # Evolves a multi-list selection, like an $and or $or criterion, and
+        # performs the necessary serialization.
+        #
+        # @api private
+        #
+        # @example Evolve the multi-selection.
+        #   selector.evolve_multi([{ field: "value" }])
+        #
+        # @param [ Array<Hash> ] value The multi-selection.
+        #
+        # @return [ Array<Hash> ] The serialized values.
+        #
+        # @since 1.0.0
+        def evolve_multi(value)
+          value.map do |val|
+            Hash[val.map do |key, _value|
+              _value = evolve_multi(_value) if multi_selection?(key)
+              name, serializer = storage_pair(key)
+              [ localized_key(name, serializer), evolve(serializer, _value) ]
+            end]
+          end.uniq
+        end
+
+        # Evolve a single key selection with various types of values.
+        #
+        # @api private
+        #
+        # @example Evolve a simple selection.
+        #   selector.evolve(field, 5)
+        #
+        # @param [ Object ] serializer The optional serializer for the field.
+        # @param [ Object ] value The value to serialize.
+        #
+        # @return [ Object ] The serialized object.
+        #
+        # @since 1.0.0
+        def evolve(serializer, value)
+          case value
+          when Hash
+            evolve_hash(serializer, value)
+          when Array
+            evolve_array(serializer, value)
+          else
+            (serializer || value.class).evolve(value)
+          end
+        end
+
+        # Evolve a single key selection with array values.
+        #
+        # @api private
+        #
+        # @example Evolve a simple selection.
+        #   selector.evolve(field, [ 1, 2, 3 ])
+        #
+        # @param [ Object ] serializer The optional serializer for the field.
+        # @param [ Array<Object> ] value The array to serialize.
+        #
+        # @return [ Object ] The serialized array.
+        #
+        # @since 1.0.0
+        def evolve_array(serializer, value)
+          value.map do |_value|
+            evolve(serializer, _value)
+          end
+        end
+
+        # Evolve a single key selection with hash values.
+        #
+        # @api private
+        #
+        # @example Evolve a simple selection.
+        #   selector.evolve(field, { "$gt" => 5 })
+        #
+        # @param [ Object ] serializer The optional serializer for the field.
+        # @param [ Hash ] value The hash to serialize.
+        #
+        # @return [ Object ] The serialized hash.
+        #
+        # @since 1.0.0
+        def evolve_hash(serializer, value)
+          value.each_pair do |operator, _value|
+            if operator =~ /exists|type|size/
+              value[operator] = _value
+            else
+              value[operator] = evolve(serializer, _value)
+            end
+          end
+        end
+
+        # Determines if the selection is a multi-select, like an $and or $or or $nor
+        # selection.
+        #
+        # @api private
+        #
+        # @example Is the selection a multi-select?
+        #   selector.multi_selection?("$and")
+        #
+        # @param [ String ] key The key to check.
+        #
+        # @return [ true, false ] If the key is for a multi-select.
+        #
+        # @since 1.0.0
+        def multi_selection?(key)
+          key =~ /\$and|\$or|\$nor/
+        end
+
+        # Determines if the selection operator takes a list. Returns true for $in and $nin.
+        #
+        # @api private
+        #
+        # @example Does the selection operator take multiple values?
+        #   selector.multi_value?("$nin")
+        #
+        # @param [ String ] key The key to check.
+        #
+        # @return [ true, false ] If the key is $in or $nin.
+        #
+        # @since 2.1.1
+        def multi_value?(key)
+          key =~ /\$nin|\$in/
+        end
+
+        private
+
+        def in?(key)
+          key =~ /\$in/
+        end
+
+        def nin?(key)
+          key =~ /\$nin/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# encoding: utf-8
+module Mongoid
+  class Criteria
+    module Queryable
+
+      # This is a smart hash for use with options and selectors.
+      class Smash < Hash
+
+        # @attribute [r] aliases The aliases.
+        # @attribute [r] serializers The serializers.
+        attr_reader :aliases, :serializers
+
+        # Perform a deep copy of the smash.
+        #
+        # @example Perform a deep copy.
+        #   smash.__deep_copy__
+        #
+        # @return [ Smash ] The copied hash.
+        #
+        # @since 1.0.0
+        def __deep_copy__
+          self.class.new(aliases, serializers) do |copy|
+            each_pair do |key, value|
+              copy.store(key, value.__deep_copy__)
+            end
+          end
+        end
+
+        # Initialize the new selector.
+        #
+        # @example Initialize the new selector.
+        #   Queryable::Smash.new(aliases, serializers)
+        #
+        # @param [ Hash ] aliases A hash of mappings from aliases to the actual
+        #   field names in the database.
+        # @param [ Hash ] serializers An optional hash of objects that are
+        #   responsible for serializing values. The keys of the hash must be
+        #   strings that match the field name, and the values must respond to
+        #   #localized? and #evolve(object).
+        #
+        # @since 1.0.0
+        def initialize(aliases = {}, serializers = {})
+          @aliases, @serializers = aliases, serializers
+          yield(self) if block_given?
+        end
+
+        # Get an item from the smart hash by the provided key.
+        #
+        # @example Get an item by the key.
+        #   smash["test"]
+        #
+        # @param [ String ] key The key.
+        #
+        # @return [ Object ] The found object.
+        #
+        # @since 2.0.0
+        def [](key)
+          fetch(aliases[key]) { super }
+        end
+
+        private
+
+        # Get the localized value for the key if needed. If the field uses
+        # localization the current locale will be appended to the key in
+        # MongoDB dot notation.
+        #
+        # @api private
+        #
+        # @example Get the normalized key name.
+        #   smash.localized_key("field", serializer)
+        #
+        # @param [ String ] name The name of the field.
+        # @param [ Object ] serializer The optional field serializer.
+        #
+        # @return [ String ] The normalized key.
+        #
+        # @since 1.0.0
+        def localized_key(name, serializer)
+          serializer && serializer.localized? ? "#{name}.#{::I18n.locale}" : name
+        end
+
+        # Get the pair of objects needed to store the value in a hash by the
+        # provided key. This is the database field name and the serializer.
+        #
+        # @api private
+        #
+        # @example Get the name and serializer.
+        #   smash.storage_pair("id")
+        #
+        # @param [ Symbol, String ] key The key provided to the selection.
+        #
+        # @return [ Array<String, Object> ] The name of the db field and
+        #   serializer.
+        #
+        # @since 1.0.0
+        def storage_pair(key)
+          field = key.to_s
+          name = aliases[field] || field
+          [ name, serializers[name] ]
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/criteria/queryable.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+require "mongoid/criteria/queryable/extensions"
+require "mongoid/criteria/queryable/forwardable"
+require "mongoid/criteria/queryable/key"
+require "mongoid/criteria/queryable/macroable"
+require "mongoid/criteria/queryable/mergeable"
+require "mongoid/criteria/queryable/smash"
+require "mongoid/criteria/queryable/aggregable"
+require "mongoid/criteria/queryable/pipeline"
+require "mongoid/criteria/queryable/optional"
+require "mongoid/criteria/queryable/options"
+require "mongoid/criteria/queryable/selectable"
+require "mongoid/criteria/queryable/selector"
+
+module Mongoid
+  class Criteria
+
+    # A queryable is any object that needs queryable's dsl injected into it to build
+    # MongoDB queries. For example, a Mongoid::Criteria is an Queryable.
+    #
+    # @example Include queryable functionality.
+    #   class Criteria
+    #     include Queryable
+    #   end
+    module Queryable
+      include Mergeable
+      include Aggregable
+      include Selectable
+      include Optional
+
+      # @attribute [r] aliases The aliases.
+      # @attribute [r] driver The Mongo driver being used.
+      # @attribute [r] serializers The serializers.
+      attr_reader :aliases, :driver, :serializers
+
+      # Is this queryable equal to another object? Is true if the selector and
+      # options are equal.
+      #
+      # @example Are the objects equal?
+      #   queryable == criteria
+      #
+      # @param [ Object ] other The object to compare against.
+      #
+      # @return [ true, false ] If the objects are equal.
+      #
+      # @since 1.0.0
+      def ==(other)
+        return false unless other.is_a?(Queryable)
+        selector == other.selector && options == other.options
+      end
+
+      # Initialize the new queryable. Will yield itself to the block if a block
+      # is provided for objects that need additional behaviour.
+      #
+      # @example Initialize the queryable.
+      #   Queryable.new
+      #
+      # @param [ Hash ] aliases The optional field aliases.
+      # @param [ Hash ] serializers The optional field serializers.
+      # @param [ Symbol ] driver The driver being used.
+      #
+      # @since 1.0.0
+      def initialize(aliases = {}, serializers = {}, driver = :mongo)
+        @aliases, @driver, @serializers = aliases, driver.to_sym, serializers
+        @options = Options.new(aliases, serializers)
+        @selector = Selector.new(aliases, serializers)
+        @pipeline = Pipeline.new(aliases)
+        @aggregating = nil
+        yield(self) if block_given?
+      end
+
+      # Handle the creation of a copy via #clone or #dup.
+      #
+      # @example Handle copy initialization.
+      #   queryable.initialize_copy(criteria)
+      #
+      # @param [ Queryable ] other The original copy.
+      #
+      # @since 1.0.0
+      def initialize_copy(other)
+        @options = other.options.__deep_copy__
+        @selector = other.selector.__deep_copy__
+        @pipeline = other.pipeline.__deep_copy__
+      end
+    end
+  end
+end

data/lib/mongoid/criteria.rb

@@ -4,7 +4,9 @@ require "mongoid/criteria/includable"
 require "mongoid/criteria/inspectable"
 require "mongoid/criteria/marshalable"
 require "mongoid/criteria/modifiable"
+require "mongoid/criteria/queryable"
 require "mongoid/criteria/scopable"
+require "mongoid/criteria/options"
 
 module Mongoid
 
@@ -17,7 +19,7 @@ module Mongoid
   class Criteria
     include Enumerable
     include Contextual
-    include Origin::Queryable
+    include Queryable
     include Findable
     include Inspectable
     include Includable
@@ -25,6 +27,8 @@ module Mongoid
     include Modifiable
     include Scopable
     include Clients::Options
+    include Options
+    include Clients::Sessions
 
     # Static array used to check with method missing - we only need to ever
     # instantiate once.
@@ -208,7 +212,7 @@ module Mongoid
     #
     # @example Merge the criteria with a hash. The hash must contain a klass
     #   key and the key/value pairs correspond to method names/args.
-
+    #
     #   criteria.merge({
     #     klass: Band,
     #     where: { name: "Depeche Mode" },

data/lib/mongoid/document.rb

@@ -31,6 +31,15 @@ module Mongoid
       Mongoid.register_model(self)
     end
 
+    # Regex for matching illegal BSON keys.
+    # Note that bson 4.1 has the constant BSON::String::ILLEGAL_KEY
+    # that should be used instead.
+    # When ruby driver 2.3.0 is released and Mongoid can be updated
+    # to require >= 2.3.0, the BSON constant can be used.
+    #
+    # @since 6.0.0
+    ILLEGAL_KEY = /(\A[$])|(\.)/.freeze
+
     # Freezes the internal attributes of the document.
     #
     # @example Freeze the document
@@ -40,7 +49,7 @@ module Mongoid
     #
     # @since 2.0.0
     def freeze
-      as_document.freeze and self
+      as_attributes.freeze and self
     end
 
     # Checks if the document is frozen
@@ -105,7 +114,6 @@ module Mongoid
       _building do
         @new_record = true
         @attributes ||= {}
-        with(self.class.persistence_options)
         apply_pre_processed_defaults
         apply_default_scoping
         process_attributes(attrs) do
@@ -165,20 +173,7 @@ module Mongoid
     #
     # @since 1.0.0
     def as_document
-      return attributes if frozen?
-      embedded_relations.each_pair do |name, meta|
-        without_autobuild do
-          relation, stored = send(name), meta.store_as
-          if attributes.key?(stored) || !relation.blank?
-            if relation
-              attributes[stored] = relation.as_document
-            else
-              attributes.delete(stored)
-            end
-          end
-        end
-      end
-      attributes
+      BSON::Document.new(as_attributes)
     end
 
     # Calls #as_json on the document with additional, Mongoid-specific options.
@@ -195,11 +190,11 @@ module Mongoid
     #
     # @since 5.1.0
     def as_json(options = nil)
-      if options && (options[:compact] == true)
-        super(options).reject! { |k,v| v.nil? }
-      else
-        super(options)
+      rv = super
+      if options && options[:compact]
+        rv = rv.compact
       end
+      rv
     end
 
     # Returns an instance of the specified class with the attributes,
@@ -243,27 +238,6 @@ module Mongoid
       became
     end
 
-    # Print out the cache key. This will append different values on the
-    # plural model name.
-    #
-    # If new_record?     - will append /new
-    # If not             - will append /id-updated_at.to_s(:nsec)
-    # Without updated_at - will append /id
-    #
-    # This is usually called insode a cache() block
-    #
-    # @example Returns the cache key
-    #   document.cache_key
-    #
-    # @return [ String ] the string with or without updated_at
-    #
-    # @since 2.4.0
-    def cache_key
-      return "#{model_key}/new" if new_record?
-      return "#{model_key}/#{id}-#{updated_at.utc.to_s(:nsec)}" if do_or_do_not(:updated_at)
-      "#{model_key}/#{id}"
-    end
-
     private
 
     # Returns the logger
@@ -299,6 +273,25 @@ module Mongoid
       nil
     end
 
+    private
+
+    def as_attributes
+      return attributes if frozen?
+      embedded_relations.each_pair do |name, meta|
+        without_autobuild do
+          relation, stored = send(name), meta.store_as
+          if attributes.key?(stored) || !relation.blank?
+            if relation
+              attributes[stored] = relation.send(:as_attributes)
+            else
+              attributes.delete(stored)
+            end
+          end
+        end
+      end
+      attributes
+    end
+
     module ClassMethods
 
       # Performs class equality checking.

data/lib/mongoid/errors/ambiguous_relationship.rb

@@ -24,7 +24,7 @@ module Mongoid
       #
       # @example Create the error.
       #   AmbiguousRelationship.new(
-      #     Person, Drug, :person, [ :drugs, #   :evil_drugs ]
+      #     Person, Drug, :person, [ :drugs, :evil_drugs ]
       #   )
       #
       # @param [ Class ] klass The base class.

data/lib/mongoid/errors/in_memory_collation_not_supported.rb

@@ -11,7 +11,7 @@ module Mongoid
       # @example Create the new unsupported collation error.
       #   InMemoryCollationNotSupported.new
       #
-      # @since 5.2.0
+      # @since 6.1.0
       def initialize
         super(compose_message("in_memory_collation_not_supported"))
       end

data/lib/mongoid/errors/invalid_field.rb

@@ -29,10 +29,10 @@ module Mongoid
 
       private
 
-      # Get the origin of the method.
+      # Get the queryable of the method.
       #
       # @example Get the originating class or module.
-      #   error.origin(Person, :crazy_method_name)
+      #   error.queryable(Person, :crazy_method_name)
       #
       # @param [ Class ] klass The document class.
       # @param [ Symbol ] name The method name.

data/lib/mongoid/errors/invalid_persistence_option.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module Mongoid
+  module Errors
+
+    # Raised when invalid options are used to create a persistence context.
+    #
+    # @since 6.0.0
+    class InvalidPersistenceOption < MongoidError
+
+      # Instantiate the persistence context option error.
+      #
+      # @example Create the error.
+      #   InvalidPersistenceOption.new(:invalid_option, [ :connect_timeout, :database ])
+      #
+      # @param [ Symbol ] invalid The invalid option.
+      # @param [ Array<Symbol> ] valid The allowed options.
+      #
+      # @since 6.0.0
+      def initialize(invalid, valid)
+        super(
+            compose_message(
+                "invalid_persistence_option",
+                { invalid: invalid, valid: valid }
+            )
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/errors/invalid_relation.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+module Mongoid
+  module Errors
+
+    # This error is raised when trying to create a relation that conflicts with
+    # an already defined method.
+    #
+    # @since 6.0.0
+    class InvalidRelation < MongoidError
+
+      # Create the new error.
+      #
+      # @example Create the error.
+      #   InvalidRelation.new(person, :crazy_relation_name)
+      #
+      # @param [ Class ] klass The document class.
+      # @param [ Symbol ] name The method name.
+      def initialize(klass, name)
+        super(
+            compose_message(
+                "invalid_relation",
+                {
+                    name: name,
+                    origin: origin(klass, name),
+                    file: location(klass, name)[0],
+                    line: location(klass, name)[1]
+                }
+            )
+        )
+      end
+
+      private
+
+      # Get the queryable of the method.
+      #
+      # @example Get the originating class or module.
+      #   error.queryable(Person, :crazy_method_name)
+      #
+      # @param [ Class ] klass The document class.
+      # @param [ Symbol ] name The method name.
+      #
+      # @return [ Class, Module ] The originating class or module.
+      #
+      # @since 6.0.0
+      def origin(klass, name)
+        klass.instance_method(name).owner
+      end
+
+      # Get the location of the relation definition.
+      #
+      # @example Get the location of the method on the filesystem.
+      #   error.location(Person, :crazy_method_name)
+      #
+      # @param [ Class ] klass The document class.
+      # @param [ Symbol ] name The method name.
+      #
+      # @return [ Array<String, Integer> ] The location of the method.
+      #
+      # @since 6.0.0
+      def location(klass, name)
+        @location ||=
+            (klass.instance_method(name).source_location || [ "Unknown", 0 ])
+      end
+    end
+  end
+end