mongoid 5.4.1 → 6.0.0.beta

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

@@ -0,0 +1,196 @@
+# 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|
+                multi_value?(_key) ? (old_val + new_val).uniq : new_val
+              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(normalized_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> ] 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)
+              [ normalized_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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# 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 normalized value for the key. If localization is in play the
+        # current locale will be appended to the key in MongoDB dot notation.
+        #
+        # @api private
+        #
+        # @example Get the normalized key name.
+        #   smash.normalized_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 normalized_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
@@ -101,11 +110,9 @@ module Mongoid
     #
     # @since 1.0.0
     def initialize(attrs = nil)
-      @__parent = nil
       _building do
         @new_record = true
         @attributes ||= {}
-        with(self.class.persistence_options)
         apply_pre_processed_defaults
         apply_default_scoping
         process_attributes(attrs) do
@@ -243,27 +250,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

data/lib/mongoid/errors.rb

@@ -5,7 +5,6 @@ require "mongoid/errors/callback"
 require "mongoid/errors/document_not_destroyed"
 require "mongoid/errors/document_not_found"
 require "mongoid/errors/eager_load"
-require "mongoid/errors/in_memory_collation_not_supported"
 require "mongoid/errors/invalid_collection"
 require "mongoid/errors/invalid_config_option"
 require "mongoid/errors/invalid_field"
@@ -15,6 +14,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/delete_restriction.rb

@@ -11,8 +11,8 @@ module Mongoid
       # @example Create the new callbacks error.
       #   Callbacks.new(Post, :create!)
       #
-      # @param [ Class ] document
-      # @param [ Symbol ] relation
+      # @param [ Class ] klass The class of the document.
+      # @param [ Symbol ] method The name of the method.
       #
       # @since 3.0.0
       def initialize(document, relation)

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