mongoid 5.4.1 → 6.1.1

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/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.
@@ -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.rb

@@ -15,6 +15,8 @@ require "mongoid/errors/invalid_includes"
 require "mongoid/errors/invalid_index"
 require "mongoid/errors/invalid_options"
 require "mongoid/errors/invalid_path"
+require "mongoid/errors/invalid_persistence_option"
+require "mongoid/errors/invalid_relation"
 require "mongoid/errors/invalid_scope"
 require "mongoid/errors/invalid_set_polymorphic_relation"
 require "mongoid/errors/invalid_storage_options"

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