mongoid 2.4.0 → 2.4.12

data/lib/mongoid/relations/proxy.rb

@@ -5,19 +5,22 @@ module Mongoid # :nodoc:
     # This class is the superclass for all relation proxy objects, and contains
     # common behaviour for all of them.
     class Proxy
-      include Threaded::Lifecycle
+      alias :extend_proxy :extend
 
       # We undefine most methods to get them sent through to the target.
       instance_methods.each do |method|
         undef_method(method) unless
-          method =~ /(^__|^send$|^object_id$|^extend$|^respond_to\?$|^tap$)/
+          method =~ /(^__|^send|^object_id|^respond_to|^tap|extend_proxy)/
       end
 
+      include Threaded::Lifecycle
+
       attr_accessor :base, :loaded, :metadata, :target
 
       # Backwards compatibility with Mongoid beta releases.
       delegate :klass, :to => :metadata
       delegate :bind_one, :unbind_one, :to => :binding
+      delegate :collection_name, :to => :base
 
       # Convenience for setting the target and the metadata properties since
       # all proxies will need to do this.
@@ -33,7 +36,7 @@ module Mongoid # :nodoc:
       def init(base, target, metadata)
         @base, @target, @metadata = base, target, metadata
         yield(self) if block_given?
-        extend metadata.extension if metadata.extension?
+        extend_proxy(metadata.extension) if metadata.extension?
       end
 
       # The default substitutable object for a relation proxy is the clone of

data/lib/mongoid/relations/referenced/many.rb

@@ -89,6 +89,7 @@ module Mongoid #:nodoc:
 
           Factory.build(type || klass, attributes, options).tap do |doc|
             append(doc)
+            doc.apply_proc_defaults
             yield(doc) if block_given?
             doc.run_callbacks(:build) { doc }
           end
@@ -319,15 +320,13 @@ module Mongoid #:nodoc:
         def substitute(replacement)
           tap do |proxy|
             if replacement
-              if replacement != proxy.in_memory
-                new_docs, docs = replacement.compact.uniq, []
-                new_ids = new_docs.map { |doc| doc.id }
-                remove_not_in(new_ids)
-                new_docs.each do |doc|
-                  docs.push(doc) if doc.send(metadata.foreign_key) != base.id
-                end
-                proxy.concat(docs)
+              new_docs, docs = replacement.compact.uniq, []
+              new_ids = new_docs.map { |doc| doc.id }
+              remove_not_in(new_ids)
+              new_docs.each do |doc|
+                docs.push(doc) if doc.send(metadata.foreign_key) != base.id
               end
+              proxy.concat(docs)
             else
               proxy.purge
             end
@@ -564,9 +563,15 @@ module Mongoid #:nodoc:
           #
           # @since 2.2.0
           def eager_load(metadata, ids)
+            cleared = false
             klass, foreign_key = metadata.klass, metadata.foreign_key
             klass.any_in(foreign_key => ids).each do |doc|
-              IdentityMap.set_many(doc, foreign_key => doc.send(foreign_key))
+              base_id = doc.send(foreign_key)
+              unless cleared
+                IdentityMap.clear_many(klass, foreign_key => base_id)
+                cleared = true
+              end
+              IdentityMap.set_many(doc, foreign_key => base_id)
             end
           end
 

data/lib/mongoid/relations/referenced/many_to_many.rb

@@ -75,6 +75,7 @@ module Mongoid # :nodoc:
           Factory.build(type || klass, attributes, options).tap do |doc|
             base.send(metadata.foreign_key).push(doc.id)
             append(doc)
+            doc.apply_proc_defaults
             doc.synced[metadata.inverse_foreign_key] = false
             yield(doc) if block_given?
           end
@@ -142,10 +143,8 @@ module Mongoid # :nodoc:
         # @since 2.0.0.rc.1
         def substitute(replacement)
           tap do |proxy|
-            if replacement != proxy.in_memory
-              proxy.purge
-              proxy.push(replacement.compact.uniq) if replacement
-            end
+            proxy.purge
+            proxy.push(replacement.compact.uniq) unless replacement.blank?
           end
         end
 

data/lib/mongoid/relations/targets/enumerable.rb

@@ -151,8 +151,9 @@ module Mongoid #:nodoc:
             end
           else
             unloaded.each do |doc|
-              yield(doc)
-              loaded.push(added.delete_one(doc) || loaded.delete_one(doc) || doc)
+              document = added.delete_one(doc) || loaded.delete_one(doc) || doc
+              yield(document)
+              loaded.push(document)
             end
           end
           added.each do |doc|
@@ -315,7 +316,12 @@ module Mongoid #:nodoc:
         #
         # @since 2.1.0
         def size
-          (unloaded ? unloaded.count : loaded.count) + added.count{ |d| d.new? }
+          count = (unloaded ? unloaded.count : loaded.count)
+          if count.zero?
+            count + added.count
+          else
+            count + added.count{ |d| d.new_record? }
+          end
         end
         alias :length :size
 

data/lib/mongoid/relations.rb

@@ -119,7 +119,9 @@ module Mongoid # :nodoc:
     def reload_relations
       relations.each_pair do |name, meta|
         if instance_variable_defined?("@#{name}")
-          remove_instance_variable("@#{name}")
+          if _parent.nil? || instance_variable_get("@#{name}") != _parent
+            remove_instance_variable("@#{name}")
+          end
         end
       end
     end

data/lib/mongoid/serialization.rb

@@ -31,18 +31,31 @@ module Mongoid # :nodoc:
       only   = Array.wrap(options[:only]).map(&:to_s)
       except = Array.wrap(options[:except]).map(&:to_s)
 
-      except |= ['_type']
+      except |= ['_type'] unless Mongoid.include_type_for_serialization
 
       field_names = fields.keys.map { |field| field.to_s }
-      attribute_names = (attributes.keys + field_names).sort
+      attribute_names = (as_document.keys + field_names).sort
       if only.any?
         attribute_names &= only
       elsif except.any?
         attribute_names -= except
       end
 
-      method_names = Array.wrap(options[:methods]).map { |n| n.to_s if respond_to?(n.to_s) }.compact
-      Hash[(attribute_names + method_names).map { |n| [n, send(n)] }].tap do |attrs|
+      method_names = Array.wrap(options[:methods]).map do |name|
+        name.to_s if respond_to?(name)
+      end.compact
+
+      {}.tap do |attrs|
+        (attribute_names + method_names).each do |name|
+          if relations.has_key?(name)
+            value = send(name)
+            attrs[name] = value ? value.serializable_hash(options) : nil
+          elsif attribute_names.include?(name) && !fields.has_key?(name)
+            attrs[name] = read_attribute(name)
+          else
+            attrs[name] = send(name)
+          end
+        end
         serialize_relations(attrs, options) if options[:include]
       end
     end
@@ -88,8 +101,7 @@ module Mongoid # :nodoc:
       inclusions = options[:include]
       relation_names(inclusions).each do |name|
         metadata = relations[name.to_s]
-        relation = send(metadata.name)
-        if relation
+        if metadata && relation = send(metadata.name)
           attributes[metadata.name.to_s] =
             relation.serializable_hash(relation_options(inclusions, options, name))
         end

data/lib/mongoid/state.rb

@@ -67,7 +67,7 @@ module Mongoid #:nodoc:
       new? &&
         embedded_many? &&
         _parent.persisted? &&
-        !_parent.delayed_atomic_sets[metadata.name.to_s]
+        !_parent.delayed_atomic_sets[atomic_path]
     end
 
     # Determine if the document can be set.

data/lib/mongoid/threaded.rb

@@ -175,6 +175,32 @@ module Mongoid #:nodoc:
       Thread.current[:"[mongoid]:safety-options"] = options
     end
 
+    # Get the field selection options from the current thread.
+    #
+    # @example Get the field selection options.
+    #   Threaded.selection
+    #
+    # @return [ Hash ] The field selection.
+    #
+    # @since 2.4.4
+    def selection
+      Thread.current[:"[mongoid]:selection"]
+    end
+
+    # Set the field selection on the current thread.
+    #
+    # @example Set the field selection.
+    #   Threaded.selection = { field: 1 }
+    #
+    # @param [ Hash ] value The current field selection.
+    #
+    # @return [ Hash ] The field selection.
+    #
+    # @since 2.4.4
+    def selection=(value)
+      Thread.current[:"[mongoid]:selection"] = value
+    end
+
     # Get the mongoid scope stack for chained criteria.
     #
     # @example Get the scope stack.

data/lib/mongoid/timestamps/updated.rb

@@ -7,7 +7,7 @@ module Mongoid #:nodoc:
       extend ActiveSupport::Concern
 
       included do
-        field :updated_at, :type => Time, :versioned => false
+        field :updated_at, :type => Time
         set_callback :save, :before, :set_updated_at, :if => :able_to_set_updated_at?
       end
 

data/lib/mongoid/validations/format.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Validations #:nodoc:
+
+    # Validates that the specified attributes do or do not match a certain
+    # regular expression.
+    #
+    # @example Set up the format validator.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :website
+    #
+    #     validates_format_of :website, :with => URI.regexp
+    #   end
+    class FormatValidator < ActiveModel::Validations::FormatValidator
+      include Localizable
+    end
+  end
+end

data/lib/mongoid/validations/length.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid
+  module Validations
+
+    # Validates that the specified attributes do or do not match a certain
+    # length.
+    #
+    # @example Set up the length validator.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :website
+    #
+    #     validates_length_of :website, in: 1..10
+    #   end
+    class LengthValidator < ActiveModel::Validations::LengthValidator
+      include Localizable
+    end
+  end
+end

data/lib/mongoid/validations/localizable.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mongoid
+  module Validations
+
+    # Adds localization support to validations.
+    module Localizable
+
+      # Validates each for localized fields.
+      #
+      # @example Validate localized fields.
+      #   validator.validate_each(model, :name, "value")
+      #
+      # @param [ Document ] document The document.
+      # @param [ Symbol, String ] attribute The attribute to validate.
+      # @param [ Object ] value The attribute value.
+      #
+      # @since 2.4.2
+      def validate_each(document, attribute, value)
+        field = document.fields[attribute.to_s]
+        if field.try(:localized?) && !value.blank?
+          value.values.each do |_value|
+            super(document, attribute, _value)
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/validations/presence.rb

@@ -27,9 +27,13 @@ module Mongoid #:nodoc:
       # @since 2.4.0
       def validate_each(document, attribute, value)
         field = document.fields[attribute.to_s]
-        if field && field.localized? && !value.blank?
+        if field.try(:localized?) && !value.blank?
           value.each_pair do |locale, value|
-            document.errors.add(attribute, :blank, options) if value.blank?
+            document.errors.add(attribute, :blank_on_locale, options.merge(:location => locale)) if value.blank?
+          end
+        elsif document.relations.has_key?(attribute.to_s)
+          if value.blank? && document.send(attribute).blank?
+            document.errors.add(attribute, :blank, options)
           end
         else
           document.errors.add(attribute, :blank, options) if value.blank?

data/lib/mongoid/validations/uniqueness.rb

@@ -41,38 +41,39 @@ module Mongoid #:nodoc:
       #
       # @since 1.0.0
       def validate_each(document, attribute, value)
+        attrib, val = to_validate(document, attribute, value)
+        return unless validation_required?(document, attrib)
         if document.embedded?
-          return if skip_validation?(document)
-          relation = document._parent.send(document.metadata.name)
-          criteria = relation.where(criterion(document, attribute, value))
-          criteria = scope(criteria, document, attribute)
-          if document.primary_key == Array.wrap(attribute)
-            if criteria.count > 1
-              document.errors.add(
-                attribute,
-                :taken, options.except(:case_sensitive, :scope).merge(:value => value)
-              )
-            end
-          else
-            if criteria.exists?
-              document.errors.add(
-                attribute,
-                :taken,
-                options.except(:case_sensitive, :scope).merge(:value => value)
-              )
-            end
-          end
+          validate_embedded(document, attrib, val)
         else
-          criteria = klass.where(criterion(document, attribute, value))
-          criteria = scope(criteria, document, attribute)
-          document.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value)) if criteria.exists?
+          validate_root(document, attrib, val)
         end
       end
 
-      protected
+      private
+
+      # Add the error to the document.
+      #
+      # @api private
+      #
+      # @example Add the error.
+      #   validator.add_error(doc, :name, "test")
+      #
+      # @param [ Document ] document The document to validate.
+      # @param [ Symbol ] attribute The name of the attribute.
+      # @param [ Object ] value The value of the object.
+      #
+      # @since 2.4.10
+      def add_error(document, attribute, value)
+        document.errors.add(
+          attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value)
+        )
+      end
 
       # Should the uniqueness validation be case sensitive?
       #
+      # @api private
+      #
       # @example Is the validation case sensitive?
       #   validator.case_sensitive?
       #
@@ -83,8 +84,38 @@ module Mongoid #:nodoc:
         !(options[:case_sensitive] == false)
       end
 
+      # Create the validation criteria.
+      #
+      # @api private
+      #
+      # @example Create the criteria.
+      #   validator.create_criteria(User, user, :name, "syd")
+      #
+      # @param [ Class, Proxy ] base The base to execute the criteria from.
+      # @param [ Document ] document The document to validate.
+      # @param [ Symbol ] attribute The name of the attribute.
+      # @param [ Object ] value The value of the object.
+      #
+      # @return [ Criteria ] The criteria.
+      #
+      # @since 2.4.10
+      def create_criteria(base, document, attribute, value)
+        field = document.fields[attribute.to_s]
+        criteria = base.paranoid ? base.unscoped.where(:deleted_at => nil) : base.unscoped
+        if field.try(:localized?)
+          criterion(document, attribute, value).each_pair do |key, value|
+            criteria.selector.store(key, value)
+          end
+        else
+          criteria = criteria.where(criterion(document, attribute, value))
+        end
+        scope(criteria, document, attribute)
+      end
+
       # Get the default criteria for checking uniqueness.
       #
+      # @api private
+      #
       # @example Get the criteria.
       #   validator.criterion(person, :title, "Sir")
       #
@@ -97,8 +128,7 @@ module Mongoid #:nodoc:
       # @since 2.3.0
       def criterion(document, attribute, value)
         { attribute => filter(value) }.tap do |selector|
-          if document.persisted? ||
-            (document.embedded? && (document.primary_key != Array.wrap(attribute)))
+          if document.persisted? && !document.embedded?
             selector.merge!(:_id => { "$ne" => document.id })
           end
         end
@@ -106,6 +136,8 @@ module Mongoid #:nodoc:
 
       # Filter the value based on whether the check is case sensitive or not.
       #
+      # @api private
+      #
       # @example Filter the value.
       #   validator.filter("testing")
       #
@@ -120,6 +152,8 @@ module Mongoid #:nodoc:
 
       # Scope the criteria to the scope options provided.
       #
+      # @api private
+      #
       # @example Scope the criteria.
       #   validator.scope(criteria, document)
       #
@@ -130,16 +164,17 @@ module Mongoid #:nodoc:
       #
       # @since 2.3.0
       def scope(criteria, document, attribute)
-        unless document.primary_key == Array.wrap(attribute)
-          Array.wrap(options[:scope]).each do |item|
-            criteria = criteria.where(item => document.attributes[item.to_s])
-          end
+        Array.wrap(options[:scope]).each do |item|
+          criteria = criteria.where(item => document.attributes[item.to_s])
         end
+        criteria = criteria.where(:deleted_at => nil) if document.paranoid?
         criteria
       end
 
       # Should validation be skipped?
       #
+      # @api private
+      #
       # @example Should the validation be skipped?
       #   validator.skip_validation?(doc)
       #
@@ -151,6 +186,103 @@ module Mongoid #:nodoc:
       def skip_validation?(document)
         !document._parent || document.embedded_one?
       end
+
+      # Scope reference has changed?
+      #
+      # @api private
+      #
+      # @example Has scope reference changed?
+      #   validator.scope_value_changed?(doc)
+      #
+      # @param [ Document ] document The embedded document.
+      #
+      # @return [ true, false ] If the scope reference has changed.
+      #
+      # @since
+      def scope_value_changed?(document)
+        Array.wrap(options[:scope]).any? do |item|
+          document.send("attribute_changed?", item.to_s)
+        end
+      end
+
+      # Get the name of the field and the value to validate. This is for the
+      # case when we validate a relation via the relation name and not the key,
+      # we need to send the key name and value to the db, not the relation
+      # object.
+      #
+      # @api private
+      #
+      # @example Get the name and key to validate.
+      #   validator.to_validate(doc, :parent, Parent.new)
+      #
+      # @param [ Document ] document The doc getting validated.
+      # @param [ Symbol ] attribute The attribute getting validated.
+      # @param [ Object ] value The value of the attribute.
+      #
+      # @return [ Array<Object, Object> ] The field and value.
+      #
+      # @since 2.4.4
+      def to_validate(document, attribute, value)
+        metadata = document.relations[attribute.to_s]
+        if metadata && metadata.stores_foreign_key?
+          [ metadata.foreign_key, value.id ]
+        else
+          [ attribute, value ]
+        end
+      end
+
+      # Validate an embedded document.
+      #
+      # @api private
+      #
+      # @example Validate the embedded document.
+      #   validator.validate_embedded(doc, :name, "test")
+      #
+      # @param [ Document ] document The document.
+      # @param [ Symbol ] attribute The attribute name.
+      # @param [ Object ] value The value.
+      #
+      # @since 2.4.10
+      def validate_embedded(document, attribute, value)
+        return if skip_validation?(document)
+        relation = document._parent.send(document.metadata.name)
+        criteria = create_criteria(relation, document, attribute, value)
+        add_error(document, attribute, value) if criteria.count > 1
+      end
+
+      # Validate a root document.
+      #
+      # @api private
+      #
+      # @example Validate the root document.
+      #   validator.validate_root(doc, :name, "test")
+      #
+      # @param [ Document ] document The document.
+      # @param [ Symbol ] attribute The attribute name.
+      # @param [ Object ] value The value.
+      #
+      # @since 2.4.10
+      def validate_root(document, attribute, value)
+        criteria = create_criteria(klass, document, attribute, value)
+        add_error(document, attribute, value) if criteria.exists?
+      end
+
+      # Are we required to validate the document?
+      #
+      # @example Is validation needed?
+      #   validator.validation_required?(doc, :field)
+      #
+      # @param [ Document ] document The document getting validated.
+      # @param [ Symbol ] attribute The attribute to validate.
+      #
+      # @return [ true, false ] If we need to validate.
+      #
+      # @since 2.4.4
+      def validation_required?(document, attribute)
+        document.new_record? ||
+          document.send("attribute_changed?", attribute.to_s) ||
+          scope_value_changed?(document)
+      end
     end
   end
 end

data/lib/mongoid/validations.rb

@@ -1,7 +1,10 @@
 # encoding: utf-8
+require "mongoid/validations/localizable"
 require "mongoid/validations/associated"
-require "mongoid/validations/uniqueness"
+require "mongoid/validations/format"
+require "mongoid/validations/length"
 require "mongoid/validations/presence"
+require "mongoid/validations/uniqueness"
 
 module Mongoid #:nodoc:
 
@@ -45,7 +48,7 @@ module Mongoid #:nodoc:
     # @since 2.0.0.rc.1
     def read_attribute_for_validation(attr)
       attribute = attr.to_s
-      if relations[attribute]
+      if relations.has_key?(attribute)
         begin_validate
         relation = send(attr)
         exit_validate
@@ -88,6 +91,21 @@ module Mongoid #:nodoc:
 
     module ClassMethods #:nodoc:
 
+      # Validates whether or not a field matches a certain regular expression.
+      #
+      # @example
+      #   class Person
+      #     include Mongoid::Document
+      #     field :website
+      #
+      #     validates_format_of :website, :with => URI.regexp
+      #   end
+      #
+      # @param [ Array ] *args The arguments to pass to the validator.
+      def validates_format_of(*args)
+        validates_with(FormatValidator, _merge_attributes(args))
+      end
+
       # Validates whether or not an association is valid or not. Will correctly
       # handle has one and has many associations.
       #
@@ -123,6 +141,40 @@ module Mongoid #:nodoc:
         validates_with(UniquenessValidator, _merge_attributes(args))
       end
 
+      # Validates the format of a field.
+      #
+      # @example
+      #   class Person
+      #     include Mongoid::Document
+      #     field :title
+      #
+      #     validates_format_of :title, with: /^[a-z0-9 \-_]*$/i
+      #   end
+      #
+      # @param [ Array ] args The names of the fields to validate.
+      #
+      # @since 2.4.0
+      def validates_format_of(*args)
+        validates_with(Mongoid::Validations::FormatValidator, _merge_attributes(args))
+      end
+
+      # Validates the length of a field.
+      #
+      # @example
+      #   class Person
+      #     include Mongoid::Document
+      #     field :title
+      #
+      #     validates_length_of :title, minimum: 100
+      #   end
+      #
+      # @param [ Array ] args The names of the fields to validate.
+      #
+      # @since 2.4.0
+      def validates_length_of(*args)
+        validates_with(Mongoid::Validations::LengthValidator, _merge_attributes(args))
+      end
+
       # Validates whether or not a field is present - meaning nil or empty.
       #
       # @example

data/lib/mongoid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Mongoid #:nodoc
-  VERSION = "2.4.0"
+  VERSION = "2.4.12"
 end