mongoid 2.4.9 → 3.0.0.rc

data/lib/mongoid/atomic/paths/embedded.rb

@@ -2,9 +2,9 @@
 require "mongoid/atomic/paths/embedded/one"
 require "mongoid/atomic/paths/embedded/many"
 
-module Mongoid #:nodoc:
-  module Atomic #:nodoc:
-    module Paths #:nodoc:
+module Mongoid
+  module Atomic
+    module Paths
 
       # Common functionality between the two different embedded paths.
       module Embedded
@@ -34,8 +34,7 @@ module Mongoid #:nodoc:
         # @since 2.1.0
         def selector
           parent.atomic_selector.
-            merge!({ "#{path}._id" => document.identifier || document._id }).
-            merge!(document.shard_key_selector)
+            merge!({ "#{path}._id" => document._id }).merge!(document.shard_key_selector)
         end
       end
     end

data/lib/mongoid/atomic/paths/root.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
-  module Atomic #:nodoc:
-    module Paths #:nodoc:
+module Mongoid
+  module Atomic
+    module Paths
 
       # This class encapsulates behaviour for locating and updating root
       # documents atomically.
@@ -31,8 +31,7 @@ module Mongoid #:nodoc:
         #
         # @since 2.1.0
         def selector
-          { "_id" => document.identifier || document._id }.
-            merge!(document.shard_key_selector)
+          { "_id" => document._id }.merge!(document.shard_key_selector)
         end
       end
     end

data/lib/mongoid/atomic.rb

@@ -2,7 +2,7 @@
 require "mongoid/atomic/modifiers"
 require "mongoid/atomic/paths"
 
-module Mongoid #:nodoc:
+module Mongoid
 
   # This module contains the logic for supporting atomic operations against the
   # database.
@@ -99,12 +99,12 @@ module Mongoid #:nodoc:
     #
     # @since 2.1.0
     def atomic_updates
-      Modifiers.new.tap do |mods|
-        generate_atomic_updates(mods, self)
-        _children.each do |child|
-          generate_atomic_updates(mods, child)
-        end
+      mods = Modifiers.new
+      generate_atomic_updates(mods, self)
+      _children.each do |child|
+        generate_atomic_updates(mods, child)
       end
+      mods
     end
     alias :_updates :atomic_updates
 
@@ -151,6 +151,16 @@ module Mongoid #:nodoc:
       atomic_paths.position
     end
 
+    # Returns path of the attribute for modification
+    #
+    # @example Get path of the attribute
+    #   address.atomic_attribute_name(:city)
+    #
+    # @return [ String ] The path to the document attribute in the database
+    def atomic_attribute_name(name)
+      embedded? ? "#{atomic_position}.#{name}" : name
+    end
+
     # Get all the attributes that need to be pulled.
     #
     # @example Get the pulls.

data/lib/mongoid/attributes/processing.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
-  module Attributes #:nodoc:
+module Mongoid
+  module Attributes
 
     # This module contains the behavior for processing attributes.
     module Processing
@@ -11,19 +11,21 @@ module Mongoid #:nodoc:
       # put into the document's attributes.
       #
       # @example Process the attributes.
-      #   person.process(:title => "sir", :age => 40)
+      #   person.process_attributes(:title => "sir", :age => 40)
       #
       # @param [ Hash ] attrs The attributes to set.
       # @param [ Symbol ] role A role for scoped mass assignment.
       # @param [ Boolean ] guard_protected_attributes False to skip mass assignment protection.
       #
       # @since 2.0.0.rc.7
-      def process(attrs = nil, role = :default, guard_protected_attributes = true)
+      def process_attributes(attrs = nil, role = :default, guard_protected_attributes = true)
         attrs ||= {}
-        attrs = sanitize_for_mass_assignment(attrs, role) if guard_protected_attributes
-        attrs.each_pair do |key, value|
-          next if pending_attribute?(key, value)
-          process_attribute(key, value)
+        if attrs.any?
+          attrs = sanitize_for_mass_assignment(attrs, role) if guard_protected_attributes
+          attrs.each_pair do |key, value|
+            next if pending_attribute?(key, value)
+            process_attribute(key, value)
+          end
         end
         yield self if block_given?
         process_pending
@@ -50,7 +52,7 @@ module Mongoid #:nodoc:
           pending_relations[name] = value
           return true
         end
-        if nested_attributes.include?("#{name}=")
+        if nested_attributes.has_key?(name)
           pending_nested[name] = value
           return true
         end
@@ -92,9 +94,11 @@ module Mongoid #:nodoc:
       #
       # @since 2.0.0.rc.7
       def process_attribute(name, value)
-        if Mongoid.allow_dynamic_fields && !respond_to?("#{name}=")
+        responds = respond_to?("#{name}=")
+        if Mongoid.allow_dynamic_fields && !responds
           write_attribute(name, value)
         else
+          raise Errors::UnknownAttribute.new(self.class, name) unless responds
           send("#{name}=", value)
         end
       end

data/lib/mongoid/attributes/readonly.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+module Mongoid
+  module Attributes
+
+    # This module defines behaviour for readonly attributes.
+    module Readonly
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :readonly_attributes
+        self.readonly_attributes = ::Set.new
+      end
+
+      # Are we able to write the attribute with the provided name?
+      #
+      # @example Can we write the attribute?
+      #   model.attribute_writable?(:title)
+      #
+      # @param [ String, Symbol ] name The name of the field.
+      #
+      # @return [ true, false ] If the document is new, or if the field is not
+      #   readonly.
+      #
+      # @since 3.0.0
+      def attribute_writable?(name)
+        new_record? || !readonly_attributes.include?(name.to_s)
+      end
+
+      module ClassMethods
+
+        # Defines an attribute as readonly. This will ensure that the value for
+        # the attribute is only set when the document is new or we are
+        # creating. In other cases, the field write will be ignored with the
+        # exception of #remove_attribute and #update_attribute, where an error
+        # will get raised.
+        #
+        # @example Flag fields as readonly.
+        #   class Band
+        #     include Mongoid::Document
+        #     field :name, type: String
+        #     field :genre, type: String
+        #     attr_readonly :name, :genre
+        #   end
+        #
+        # @param [ Array<Symbol> ] names The names of the fields.
+        #
+        # @since 3.0.0
+        def attr_readonly(*names)
+          names.each do |name|
+            readonly_attributes << name.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/attributes.rb

@@ -1,13 +1,15 @@
 # encoding: utf-8
 require "mongoid/attributes/processing"
+require "mongoid/attributes/readonly"
 
-module Mongoid #:nodoc:
+module Mongoid
 
   # This module contains the logic for handling the internal attributes hash,
   # and how to get and set values.
   module Attributes
     extend ActiveSupport::Concern
     include Processing
+    include Readonly
 
     attr_reader :attributes
     alias :raw_attributes :attributes
@@ -24,9 +26,22 @@ module Mongoid #:nodoc:
     # @since 1.0.0
     def attribute_present?(name)
       attribute = read_attribute(name)
-      ! attribute.blank? || attribute == false
+      !attribute.blank? || attribute == false
+    end
+
+    # Does the document have the provided attribute?
+    #
+    # @example Does the document have the attribute?
+    #   model.has_attribute?(:name)
+    #
+    # @param [ String, Symbol ] name The name of the attribute.
+    #
+    # @return [ true, false ] If the key is present in the attributes.
+    #
+    # @since 3.0.0
+    def has_attribute?(name)
+      attributes.has_key?(name.to_s)
     end
-    alias :has_attribute? :attribute_present?
 
     # Read a value from the document attributes. If the value does not exist
     # it will return nil.
@@ -55,11 +70,18 @@ module Mongoid #:nodoc:
     #
     # @param [ String, Symbol ] name The name of the attribute to remove.
     #
+    # @raise [ Errors::ReadonlyAttribute ] If the field cannot be removed due
+    #   to being flagged as reaodnly.
+    #
     # @since 1.0.0
     def remove_attribute(name)
+      access = name.to_s
+      unless attribute_writable?(name)
+        raise Errors::ReadonlyAttribute.new(name, :nil)
+      end
       _assigning do
-        access = name.to_s
         attribute_will_change!(access)
+        atomic_unsets.push(atomic_attribute_name(access))
         attributes.delete(access)
       end
     end
@@ -74,11 +96,12 @@ module Mongoid #:nodoc:
     # @return [ true, false ] True if it does, false if not.
     #
     # @since 1.0.0
-    def respond_to?(*args)
-      (Mongoid.allow_dynamic_fields &&
+    def respond_to?(name, include_private = false)
+      super || (
+        Mongoid.allow_dynamic_fields &&
         attributes &&
-        attributes.has_key?(args.first.to_s.reader)
-      ) || super
+        attributes.has_key?(name.to_s.reader)
+      )
     end
 
     # Write a single attribute to the document attribute hash. This will
@@ -96,18 +119,20 @@ module Mongoid #:nodoc:
     #
     # @since 1.0.0
     def write_attribute(name, value)
-      _assigning do
-        access = name.to_s
-        localized = fields[access].try(:localized?)
-        typed_value_for(access, value).tap do |value|
-          unless attributes[access] == value || attribute_changed?(access)
+      access = name.to_s
+      if attribute_writable?(access)
+        _assigning do
+          localized = fields[access].try(:localized?)
+          typed_value = typed_value_for(access, value)
+          unless attributes[access] == typed_value || attribute_changed?(access)
             attribute_will_change!(access)
           end
           if localized
-            (attributes[access] ||= {}).merge!(value)
+            (attributes[access] ||= {}).merge!(typed_value)
           else
-            attributes[access] = value
+            attributes[access] = typed_value
           end
+          typed_value
         end
       end
     end
@@ -130,9 +155,7 @@ module Mongoid #:nodoc:
     # @since 2.2.1
     def assign_attributes(attrs = nil, options = {})
       _assigning do
-        process(attrs, options[:as] || :default, !options[:without_protection]) do |document|
-          document.identify if new? && id.blank?
-        end
+        process_attributes(attrs, options[:as] || :default, !options[:without_protection])
       end
     end
 
@@ -151,11 +174,47 @@ module Mongoid #:nodoc:
     #
     # @since 1.0.0
     def write_attributes(attrs = nil, guard_protected_attributes = true)
-      assign_attributes(attrs, :without_protection => !guard_protected_attributes)
+      assign_attributes(attrs, without_protection: !guard_protected_attributes)
     end
     alias :attributes= :write_attributes
 
-    protected
+    private
+
+    # Define a reader method for a dynamic attribute.
+    #
+    # @api private
+    #
+    # @example Define a reader method.
+    #   model.define_dynamic_reader(:field)
+    #
+    # @param [ String ] name The name of the field.
+    #
+    # @since 3.0.0
+    def define_dynamic_reader(name)
+      class_eval <<-READER
+        def #{name}
+          read_attribute(#{name.inspect})
+        end
+      READER
+    end
+
+    # Define a writer method for a dynamic attribute.
+    #
+    # @api private
+    #
+    # @example Define a writer method.
+    #   model.define_dynamic_writer(:field)
+    #
+    # @param [ String ] name The name of the field.
+    #
+    # @since 3.0.0
+    def define_dynamic_writer(name)
+      class_eval <<-WRITER
+        def #{name}=(value)
+          write_attribute(#{name.inspect}, value)
+        end
+      WRITER
+    end
 
     # Used for allowing accessor methods for dynamic attributes.
     #
@@ -165,9 +224,13 @@ module Mongoid #:nodoc:
       attr = name.to_s
       return super unless attributes.has_key?(attr.reader)
       if attr.writer?
-        write_attribute(attr.reader, (args.size > 1) ? args : args.first)
+        getter = attr.reader
+        define_dynamic_writer(getter)
+        write_attribute(getter, args.first)
       else
-        read_attribute(attr.reader)
+        getter = attr.reader
+        define_dynamic_reader(getter)
+        read_attribute(getter)
       end
     end
 
@@ -183,10 +246,10 @@ module Mongoid #:nodoc:
     #
     # @since 1.0.0
     def typed_value_for(key, value)
-      fields.has_key?(key) ? fields[key].serialize(value) : value
+      fields.has_key?(key) ? fields[key].mongoize(value) : value
     end
 
-    module ClassMethods #:nodoc:
+    module ClassMethods
 
       # Alias the provided name to the original field. This will provide an
       # aliased getter, setter, existance check, and all dirty attribute
@@ -205,14 +268,14 @@ module Mongoid #:nodoc:
       # @since 2.3.0
       def alias_attribute(name, original)
         class_eval <<-RUBY
-          alias :#{name} :#{original}
-          alias :#{name}= :#{original}=
-          alias :#{name}? :#{original}?
-          alias :#{name}_change :#{original}_change
-          alias :#{name}_changed? :#{original}_changed?
-          alias :reset_#{name}! :reset_#{original}!
-          alias :#{name}_was :#{original}_was
-          alias :#{name}_will_change! :#{original}_will_change!
+          alias #{name}  #{original}
+          alias #{name}= #{original}=
+          alias #{name}? #{original}?
+          alias #{name}_change   #{original}_change
+          alias #{name}_changed? #{original}_changed?
+          alias reset_#{name}!   reset_#{original}!
+          alias #{name}_was      #{original}_was
+          alias #{name}_will_change! #{original}_will_change!
         RUBY
       end
     end

data/lib/mongoid/callbacks.rb

@@ -1,28 +1,76 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
+module Mongoid
 
   # This module contains all the callback hooks for Mongoid.
   module Callbacks
     extend ActiveSupport::Concern
 
     CALLBACKS = [
-      :before_validation, :after_validation,
-      :after_initialize, :after_build,
-      :before_create, :around_create, :after_create,
-      :before_destroy, :around_destroy, :after_destroy,
-      :before_save, :around_save, :after_save,
-      :before_update, :around_update, :after_update,
+      :after_build,
+      :after_create,
+      :after_destroy,
+      :after_initialize,
+      :after_save,
+      :after_update,
+      :after_validation,
+      :around_create,
+      :around_destroy,
+      :around_save,
+      :around_update,
+      :before_create,
+      :before_destroy,
+      :before_save,
+      :before_update,
+      :before_validation
     ]
 
     included do
       extend ActiveModel::Callbacks
       include ActiveModel::Validations::Callbacks
 
-      define_model_callbacks :initialize, :only => :after
-      define_model_callbacks :build, :only => :after
+      define_model_callbacks :initialize, only: :after
+      define_model_callbacks :build, only: :after
       define_model_callbacks :create, :destroy, :save, :update
     end
 
+    # Run only the after callbacks for the specific event.
+    #
+    # @note ActiveSupport does not allow this type of behaviour by default, so
+    #   Mongoid has to get around it and implement itself.
+    #
+    # @example Run only the after save callbacks.
+    #   model.run_after_callbacks(:save)
+    #
+    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    #
+    # @return [ Object ] The result of the chain executing.
+    #
+    # @since 3.0.0
+    def run_after_callbacks(*kinds)
+      kinds.each do |kind|
+        run_targeted_callbacks(:after, kind)
+      end
+    end
+
+    # Run only the before callbacks for the specific event.
+    #
+    # @note ActiveSupport does not allow this type of behaviour by default, so
+    #   Mongoid has to get around it and implement itself.
+    #
+    # @example Run only the before save callbacks.
+    #   model.run_before_callbacks(:save, :create)
+    #
+    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    #
+    # @return [ Object ] The result of the chain executing.
+    #
+    # @since 3.0.0
+    def run_before_callbacks(*kinds)
+      kinds.each do |kind|
+        run_targeted_callbacks(:before, kind)
+      end
+    end
+
     # Run the callbacks for the document. This overrides active support's
     # functionality to cascade callbacks to embedded documents that have been
     # flagged as such.
@@ -39,35 +87,16 @@ module Mongoid #:nodoc:
     #
     # @since 2.3.0
     def run_callbacks(kind, *args, &block)
-      run_cascading_callbacks(cascadable_children(kind), kind, *args) {}
+      cascadable_children(kind).each do |child|
+        unless child.run_callbacks(child_callback_type(kind, child), *args)
+          return false
+        end
+      end
       super(kind, *args, &block)
     end
 
     private
 
-    # Execute the callbacks, including all children that have cascade callbacks
-    # set to true.
-    #
-    # @example Run the cascading callbacks.
-    #   document.run_cascading_callbacks([], :update)
-    #
-    # @param [ Array<Document> ] children The cascading children.
-    # @param [ Symbol ] kind The callback type.
-    # @param [ Array ] args The options.
-    #
-    # @since 2.3.0
-    def run_cascading_callbacks(children, kind, *args, &block)
-      if child = children.pop
-        run_cascading_callbacks(children, kind, *args) do
-          child.run_callbacks(child_callback_type(kind, child), *args) do
-            block.call
-          end
-        end
-      else
-        block.call
-      end
-    end
-
     # Get all the child embedded documents that are flagged as cascadable.
     #
     # @example Get all the cascading children.
@@ -78,19 +107,21 @@ module Mongoid #:nodoc:
     # @return [ Array<Document> ] The children.
     #
     # @since 2.3.0
-    def cascadable_children(kind)
-      [].tap do |children|
-        relations.each_pair do |name, metadata|
-          next unless metadata.cascading_callbacks?
+    def cascadable_children(kind, children = Set.new)
+      embedded_relations.each_pair do |name, metadata|
+        next unless metadata.cascading_callbacks?
+        without_autobuild do
           delayed_pulls = delayed_atomic_pulls[name]
-          children.concat(delayed_pulls) if delayed_pulls
-          child = send(name)
-          Array.wrap(child).each do |doc|
-            children.push(doc) if cascadable_child?(kind, doc)
-            children.concat(doc.send(:cascadable_children, kind))
+          children.merge(delayed_pulls) if delayed_pulls
+          relation = send(name)
+          Array.wrap(relation).each do |child|
+            next if children.include?(child)
+            children.add(child) if cascadable_child?(kind, child)
+            children.merge(child.send(:cascadable_children, kind, children))
           end
         end
       end
+      children.to_a
     end
 
     # Determine if the child should fire the callback.
@@ -132,5 +163,32 @@ module Mongoid #:nodoc:
         kind
       end
     end
+
+    # Run only the callbacks for the target location (before, after, around)
+    # and kind (save, update, create).
+    #
+    # @example Run the targeted callbacks.
+    #   model.run_targeted_callbacks(:before, :save)
+    #
+    # @param [ Symbol ] place The time to run, :before, :after, :around.
+    # @param [ Symbol ] kind The type of callback, :save, :create, :update.
+    #
+    # @return [ Object ] The result of the chain execution.
+    #
+    # @since 3.0.0
+    def run_targeted_callbacks(place, kind)
+      name = "_run__#{place}__#{kind}__callbacks"
+      unless respond_to?(name)
+        chain = ActiveSupport::Callbacks::CallbackChain.new(name, {})
+        send("_#{kind}_callbacks").each do |callback|
+          chain.push(callback) if callback.kind == place
+        end
+        class_eval <<-EOM
+          def #{name}() #{chain.compile} end
+          protected :#{name}
+        EOM
+      end
+      send(name)
+    end
   end
 end

data/lib/mongoid/collections/retry.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
-  module Collections #:nodoc:
+module Mongoid
+  module Collections
 
     # Provides behaviour for retrying commands on connection failure.
     module Retry
@@ -32,7 +32,6 @@ module Mongoid #:nodoc:
           retry
         rescue Mongo::OperationFailure => ex
           if ex.message =~ /not master/
-            Mongoid.reconnect!
             retries = increase_retry_attempts(retries, ex)
             retry
           else