mongoid 2.2.6 → 2.3.0

data/Rakefile

@@ -24,10 +24,6 @@ task :release => :build do
   system "gem push mongoid-#{Mongoid::VERSION}.gem"
 end
 
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = "spec/**/*_spec.rb"
-end
-
 RSpec::Core::RakeTask.new("spec:unit") do |spec|
   spec.pattern = "spec/unit/**/*_spec.rb"
 end
@@ -49,4 +45,5 @@ RDoc::Task.new do |rdoc|
   rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
-task :default => [ "spec:functional", "spec:unit" ]
+task :spec => [ "spec:functional", "spec:unit" ]
+task :default => :spec

data/lib/mongoid.rb

@@ -94,7 +94,7 @@ I18n.load_path << File.join(File.dirname(__FILE__), "config", "locales", "en.yml
 module Mongoid #:nodoc
   extend self
 
-  MONGODB_VERSION = "1.8.0"
+  MONGODB_VERSION = "2.0.0"
 
   # Sets the Mongoid configuration options. Best used by passing a block.
   #

data/lib/mongoid/attributes.rb

@@ -6,6 +6,7 @@ module Mongoid #:nodoc:
   # 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
 
     attr_reader :attributes
@@ -56,7 +57,7 @@ module Mongoid #:nodoc:
     #
     # @since 1.0.0
     def remove_attribute(name)
-      assigning do
+      _assigning do
         access = name.to_s
         attribute_will_change!(access)
         attributes.delete(access)
@@ -95,18 +96,46 @@ module Mongoid #:nodoc:
     #
     # @since 1.0.0
     def write_attribute(name, value)
-      assigning do
+      _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)
             attribute_will_change!(access)
           end
-          attributes[access] = value
+          if localized
+            (attributes[access] ||= {}).merge!(value)
+          else
+            attributes[access] = value
+          end
         end
       end
     end
     alias :[]= :write_attribute
 
+    # Allows you to set all the attributes for a particular mass-assignment security role
+    # by passing in a hash of attributes with keys matching the attribute names
+    # (which again matches the column names)  and the role name using the :as option.
+    # To bypass mass-assignment security you can use the :without_protection => true option.
+    #
+    # @example Assign the attributes.
+    #   person.assign_attributes(:title => "Mr.")
+    #
+    # @example Assign the attributes (with a role).
+    #   person.assign_attributes({ :title => "Mr." }, :as => :admin)
+    #
+    # @param [ Hash ] attrs The new attributes to set.
+    # @param [ Hash ] options Supported options: :without_protection, :as
+    #
+    # @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
+      end
+    end
+
     # Writes the supplied attributes hash to the document. This will only
     # overwrite existing attributes if they are present in the new +Hash+, all
     # others will be preserved.
@@ -122,11 +151,7 @@ module Mongoid #:nodoc:
     #
     # @since 1.0.0
     def write_attributes(attrs = nil, guard_protected_attributes = true)
-      assigning do
-        process(attrs, guard_protected_attributes) do |document|
-          document.identify if new? && id.blank?
-        end
-      end
+      assign_attributes(attrs, :without_protection => !guard_protected_attributes)
     end
     alias :attributes= :write_attributes
 
@@ -135,18 +160,16 @@ module Mongoid #:nodoc:
     # Set any missing default values in the attributes.
     #
     # @example Get the raw attributes after defaults have been applied.
-    #   person.apply_default_attributes
+    #   person.apply_defaults
     #
     # @return [ Hash ] The raw attributes.
     #
     # @since 2.0.0.rc.8
-    def apply_default_attributes
-      (@attributes ||= {}).tap do |attrs|
-        defaults.each do |name|
-          unless attrs.has_key?(name)
-            if field = fields[name]
-              attrs[name] = field.eval_default(self)
-            end
+    def apply_defaults
+      defaults.each do |name|
+        unless attributes.has_key?(name)
+          if field = fields[name]
+            attributes[name] = field.eval_default(self)
           end
         end
       end
@@ -157,14 +180,14 @@ module Mongoid #:nodoc:
     # be in a valid state.
     #
     # @example Execute the assignment.
-    #   assigning do
+    #   _assigning do
     #     person.attributes = { :addresses => [ address ] }
     #   end
     #
     # @return [ Object ] The yielded value.
     #
     # @since 2.2.0
-    def assigning
+    def _assigning
       begin
         Threaded.begin_assign
         yield
@@ -201,5 +224,32 @@ module Mongoid #:nodoc:
     def typed_value_for(key, value)
       fields.has_key?(key) ? fields[key].serialize(value) : value
     end
+
+    module ClassMethods #:nodoc:
+
+      # Alias the provided name to the original field. This will provide an
+      # aliased getter, setter, existance check, and all dirty attribute
+      # methods.
+      #
+      # @example Alias the attribute.
+      #   class Product
+      #     include Mongoid::Document
+      #     field :price, :type => Float
+      #     alias_attribute :cost, :price
+      #   end
+      #
+      # @param [ Symbol ] name The new name.
+      # @param [ Symbol ] original The original name.
+      #
+      # @since 2.3.0
+      def alias_attribute(name, original)
+        class_eval <<-RUBY
+          alias :#{name} :#{original}
+          alias :#{name}= :#{original}=
+          alias :#{name}? :#{original}?
+        RUBY
+        super
+      end
+    end
   end
 end

data/lib/mongoid/attributes/processing.rb

@@ -14,12 +14,13 @@ module Mongoid #:nodoc:
       #   person.process(: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, guard_protected_attributes = true)
+      def process(attrs = nil, role = :default, guard_protected_attributes = true)
         attrs ||= {}
-        attrs = sanitize_for_mass_assignment(attrs) if guard_protected_attributes
+        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)
@@ -37,7 +38,7 @@ module Mongoid #:nodoc:
       # @example Is the attribute pending?
       #   document.pending_attribute?(:name, "Durran")
       #
-      # @param [ Synbol ] key The name of the attribute.
+      # @param [ Symbol ] key The name of the attribute.
       # @param [ Object ] value The value of the attribute.
       #
       # @return [ true, false ] True if pending, false if not.

data/lib/mongoid/callbacks.rb

@@ -21,5 +21,107 @@ module Mongoid #:nodoc:
       define_model_callbacks :initialize, :only => :after
       define_model_callbacks :create, :destroy, :save, :update
     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.
+    #
+    # @example Run the callbacks.
+    #   run_callbacks :save do
+    #     save!
+    #   end
+    #
+    # @param [ Symbol ] kind The type of callback to execute.
+    # @param [ Array ] *args Any options.
+    #
+    # @return [ Document ] The document
+    #
+    # @since 2.3.0
+    def run_callbacks(kind, *args, &block)
+      run_cascading_callbacks(cascadable_children(kind), kind, *args) do
+        super(kind, *args, &block)
+      end
+    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.
+    #   document.cascadable_children(:update)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    #
+    # @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?
+          child = send(name)
+          Array.wrap(child).each do |doc|
+            children.push(doc) if cascadable_child?(kind, doc)
+            children.concat(doc.send(:cascadable_children, kind))
+          end
+        end
+      end
+    end
+
+    # Determine if the child should fire the callback.
+    #
+    # @example Should the child fire the callback?
+    #   document.cascadable_child?(:update, doc)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    # @param [ Document ] child The child document.
+    #
+    # @return [ true, false ] If the child should fire the callback.
+    #
+    # @since 2.3.0
+    def cascadable_child?(kind, child)
+      [ :create, :destroy ].include?(kind) || child.changed? || child.new_record?
+    end
+
+    # Get the name of the callback that the child should fire. This changes
+    # depending on whether or not the child is new. A persisted parent with a
+    # new child would fire :update from the parent, but needs to fire :create
+    # on the child.
+    #
+    # @example Get the callback type.
+    #   document.child_callback_type(:update, doc)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    # @param [ Document ] child The child document
+    #
+    # @return [ Symbol ] The name of the callback.
+    #
+    # @since 2.3.0
+    def child_callback_type(kind, child)
+      kind == :update && child.new_record? ? :create : kind
+    end
   end
 end

data/lib/mongoid/collection.rb

@@ -142,7 +142,7 @@ module Mongoid #:nodoc
     #
     # @since 2.0.0
     def update(selector, document, options = {})
-      updater = Threaded.update_consumer(name)
+      updater = Threaded.update_consumer(klass)
       if updater
         updater.consume(selector, document, options)
       else

data/lib/mongoid/components.rb

@@ -17,11 +17,11 @@ module Mongoid #:nodoc
     include ActiveModel::Serializers::JSON
     include ActiveModel::Serializers::Xml
     include Mongoid::Atomic
+    include Mongoid::Dirty
     include Mongoid::Attributes
     include Mongoid::Collections
     include Mongoid::Copyable
     include Mongoid::DefaultScope
-    include Mongoid::Dirty
     include Mongoid::Extras
     include Mongoid::Fields
     include Mongoid::Hierarchy
@@ -38,6 +38,7 @@ module Mongoid #:nodoc
     include Mongoid::Serialization
     include Mongoid::Sharding
     include Mongoid::State
+    include Mongoid::Timestamps::Timeless
     include Mongoid::Validations
     include Mongoid::Callbacks
     include Mongoid::MultiDatabase

data/lib/mongoid/contexts/enumerable.rb

@@ -210,18 +210,6 @@ module Mongoid #:nodoc:
 
       protected
 
-      # Get the root class collection name.
-      #
-      # @example Get the root class collection name.
-      #   context.collection_name
-      #
-      # @return [ String ] The name of the collection.
-      #
-      # @since 2.4.3
-      def collection_name
-        root ? root.collection_name : nil
-      end
-
       # Filters the documents against the criteria's selector
       #
       # @example Filter the documents.
@@ -263,22 +251,10 @@ module Mongoid #:nodoc:
         documents
       end
 
-      # Get the root document for the enumerable.
-      #
-      # @example Get the root document.
-      #   context.root
-      #
-      # @return [ Document ] The root.
       def root
         @root ||= documents.first.try(:_root)
       end
 
-      # Get the root class for the enumerable.
-      #
-      # @example Get the root class.
-      #   context.root_class
-      #
-      # @return [ Class ] The root class.
       def root_class
         @root_class ||= root ? root.class : nil
       end

data/lib/mongoid/contexts/mongo.rb

@@ -330,7 +330,7 @@ module Mongoid #:nodoc:
           { "$set" => attributes },
           Safety.merge_safety_options(:multi => true)
         ).tap do
-          Threaded.clear_safety_options!
+          Threaded.clear_options!
         end
       end
       alias :update :update_all
@@ -371,7 +371,7 @@ module Mongoid #:nodoc:
           :reduce => reduce.gsub("[field]", field)
         )
         value = collection.empty? ? nil : collection.first[start.to_s]
-        value ? (value.nan? ? nil : value) : value
+        value && value.try(:nan?) ? nil : value
       end
 
       # Filters the field list. If no fields have been supplied, then it will be

data/lib/mongoid/copyable.rb

@@ -38,7 +38,9 @@ module Mongoid #:nodoc:
         instance_variable_set(name, value ? value.dup : nil)
       end
       attributes.delete("_id")
-      attributes.delete("versions")
+      if attributes.delete("versions")
+        attributes["version"] = 1
+      end
       @new_record = true
       identify
     end

data/lib/mongoid/criteria.rb

@@ -153,6 +153,19 @@ module Mongoid #:nodoc:
       context.count > 0
     end
 
+    # Extract a single id from the provided criteria. Could be in an $and
+    # query or a straight _id query.
+    #
+    # @example Extract the id.
+    #   criteria.extract_id
+    #
+    # @return [ Object ] The id.
+    #
+    # @since 2.3.0
+    def extract_id
+      selector[:_id]
+    end
+
     # When freezing a criteria we need to initialize the context first
     # otherwise the setting of the context on attempted iteration will raise a
     # runtime error.
@@ -383,19 +396,14 @@ module Mongoid #:nodoc:
       clone.tap do |crit|
         converted = BSON::ObjectId.convert(klass, attributes || {})
         converted.each_pair do |key, value|
-          existing = crit.selector[key]
-          unless existing
+          unless crit.selector[key]
             crit.selector[key] = { operator => value }
           else
-            if existing.respond_to?(:merge)
-              if existing.has_key?(operator)
-                new_value = existing.values.first.send(combine, value)
-                crit.selector[key] = { operator => new_value }
-              else
-                crit.selector[key][operator] = value
-              end
+            if crit.selector[key].has_key?(operator)
+              new_value = crit.selector[key].values.first.send(combine, value)
+              crit.selector[key] = { operator => new_value }
             else
-              crit.selector[key] = { operator => value }
+              crit.selector[key][operator] = value
             end
           end
         end