mongoid 2.0.0.rc.7 → 2.0.0.rc.8

data/lib/mongoid/keys.rb

@@ -1,45 +1,83 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
+
+  # This module defines the behaviour for overriding the default ids on
+  # documents.
   module Keys
     extend ActiveSupport::Concern
-    included do
-      cattr_accessor :primary_key, :_identity
-      self._identity = { :type => BSON::ObjectId }
 
-      delegate \
-        :_id_type,
-        :primary_key,
-        :using_object_ids?, :to => "self.class"
+    included do
+      cattr_accessor :primary_key, :object_ids
+      delegate :primary_key, :using_object_ids?, :to => "self.class"
     end
 
-    module ClassMethods #:nodoc:
+    private
 
-      # Convenience method for returning the type of the id for this class.
-      #
-      # Example:
-      #
-      # <tt>Person._id_type</tt>
-      #
-      # Returns:
-      #
-      # The type of the id.
-      def _id_type
-        _identity[:type]
+    # Determines if any field that the document id is composed of has changed.
+    #
+    # @example Has any key field changed?
+    #   document.key_field_changed?
+    #
+    # @return [ true, false ] Has a key field changed?
+    #
+    # @since 2.0.0
+    def key_field_changed?
+      primary_key.any? { |field| changed.include?(field.to_s) }
+    end
+
+    # Sits around a save when composite keys are in play to handle the id magic
+    # if a key field has changed.
+    #
+    # @example Set the composite key.
+    #   document.set_composite_key
+    #
+    # @param [ Proc ] block The block this surrounds.
+    #
+    # @since 2.0.0
+    def set_composite_key(&block)
+      if persisted? && key_field_changed?
+        swap_composite_keys(&block)
+      else
+        identify and block.call
       end
+    end
+
+    # Swap out the composite key only after the document has been saved.
+    #
+    # @example Swap out the keys.
+    #   document.swap_composite_keys
+    #
+    # @param [ Proc ] block The save block getting called.
+    #
+    # @since 2.0.0
+    def swap_composite_keys(&block)
+      old_id, new_id = id.dup, identify
+      @attributes["_id"] = old_id
+      block.call
+      @attributes["_id"] = new_id
+    end
+
+    module ClassMethods #:nodoc:
 
       # Used for telling Mongoid on a per model basis whether to override the
       # default +BSON::ObjectId+ and use a different type. This will be
       # expanded in the future for requiring a PkFactory if the type is not a
       # +BSON::ObjectId+ or +String+.
       #
-      # Example:
-      #
+      # @example Change the documents key type.
       #   class Person
       #     include Mongoid::Document
       #     identity :type => String
       #   end
+      #
+      # @param [ Hash ] options The options.
+      #
+      # @option options [ Class ] :type The type of the id.
+      #
+      # @since 2.0.0.beta.1
       def identity(options = {})
-        self._identity = options
+        fields["_id"].type = options[:type]
+        @object_ids = id_is_object
       end
 
       # Defines the field that will be used for the id of this +Document+. This
@@ -47,30 +85,46 @@ module Mongoid #:nodoc:
       # the field that was supplied. This is good for use for readable URLS in
       # web applications.
       #
-      # Example:
-      #
+      # @example Create a composite id.
       #   class Person
       #     include Mongoid::Document
       #     key :first_name, :last_name
       #   end
+      #
+      # @param [ Array<Symbol> ] The fields the key is composed of.
+      #
+      # @since 1.0.0
       def key(*fields)
         self.primary_key = fields
         identity(:type => String)
-        set_callback :save, :before, :identify
+        set_callback(:save, :around, :set_composite_key)
       end
 
       # Convenience method for determining if we are using +BSON::ObjectIds+ as
       # our id.
       #
-      # Example:
+      # @example Does this class use object ids?
+      #   person.using_object_ids?
       #
-      # <tt>person.using_object_ids?</tt>
+      # @return [ true, false ] If the class uses BSON::ObjectIds for the id.
       #
-      # Returns:
-      #
-      # true if we are using BSON::ObjectIds
+      # @since 1.0.0
       def using_object_ids?
-        _id_type == BSON::ObjectId
+        @object_ids ||= id_is_object
+      end
+
+      private
+
+      # Is the id field type an object id?
+      #
+      # @example Is type an object id.
+      #   Class.id_is_object
+      #
+      # @return [ true, false ] Is the id an object id.
+      #
+      # @since 2.0.0
+      def id_is_object
+        fields["_id"].type == BSON::ObjectId
       end
     end
   end

data/lib/mongoid/multi_parameter_attributes.rb

@@ -27,7 +27,7 @@ module Mongoid #:nodoc:
       end
     end
 
-    def process(attrs = nil)
+    def process(attrs = nil, guard_protected_attributes = true)
       if attrs
         errors = []
         attributes = {}
@@ -56,7 +56,7 @@ module Mongoid #:nodoc:
           raise Errors::MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
         end
 
-        super attributes
+        super attributes, guard_protected_attributes
       else
         super
       end

data/lib/mongoid/named_scope.rb

@@ -1,36 +1,137 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
+
+  # This module contains the named scoping behaviour.
   module NamedScope
-    # Creates a named_scope for the +Document+, similar to ActiveRecord's
-    # named_scopes. +NamedScopes+ are proxied +Criteria+ objects that can be
-    # chained.
-    #
-    # Example:
-    #
-    #   class Person
-    #     include Mongoid::Document
-    #     field :active, :type => Boolean
-    #     field :count, :type => Integer
-    #
-    #     named_scope :active, :where => { :active => true }
-    #     named_scope :count_gt_one, :where => { :count.gt => 1 }
-    #     named_scope :at_least_count, lambda { |count| { :where => { :count.gt => count } } }
-    #   end
-    def named_scope(name, conditions = {}, &block)
-      name = name.to_sym
-      scopes[name] = Scope.new(conditions, &block)
-      (class << self; self; end).class_eval <<-EOT
-        def #{name}(*args)
-          scope = scopes[:#{name}]
-          scope.extend(criteria.fuse(scope.conditions.scoped(*args)))
-        end
-      EOT
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :scopes
+      self.scopes = {}
     end
-    alias :scope :named_scope
 
-    # Return the scopes or default to an empty +Hash+.
-    def scopes
-      read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+    module ClassMethods #:nodoc:
+
+      # Gets either the last scope on the stack or creates a new criteria.
+      #
+      # @example Get the last or new.
+      #   Person.scoping(true)
+      #
+      # @param [ true, false ] embedded Is this scope for an embedded doc?
+      # @param [ true, false ] scoped Are we applying default scoping?
+      #
+      # @return [ Criteria ] The last scope or a new one.
+      #
+      # @since 2.0.0
+      def criteria(embedded = false, scoped = true)
+        scope_stack.last || Criteria.new(self, embedded).tap do |crit|
+          return crit.fuse(default_scoping) if default_scoping && scoped
+        end
+      end
+
+      # Creates a named_scope for the +Document+, similar to ActiveRecord's
+      # named_scopes. +NamedScopes+ are proxied +Criteria+ objects that can be
+      # chained.
+      #
+      # @example Create named scopes.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :active, :type => Boolean
+      #     field :count, :type => Integer
+      #
+      #     scope :active, :where => { :active => true }
+      #     scope :count_gt_one, :where => { :count.gt => 1 }
+      #     scope :at_least_count, lambda { |count| { :where => { :count.gt => count } } }
+      #   end
+      #
+      # @param [ Symbol ] name The name of the scope.
+      # @param [ Hash, Criteria ] conditions The conditions of the scope.
+      #
+      # @since 1.0.0
+      def scope(name, conditions = {}, &block)
+        name = name.to_sym
+        valid_scope_name?(name)
+        scopes[name] = Scope.new(conditions, &block)
+        (class << self; self; end).class_eval <<-EOT
+          def #{name}(*args)
+            scope = scopes[:#{name}]
+            scope.extend(criteria.fuse(scope.conditions.scoped(*args)))
+          end
+        EOT
+      end
+      alias :named_scope :scope
+
+      # Get a criteria object for the class, scoped to the default if defined.
+      #
+      # @example Get a scoped criteria.
+      #   Person.scoped
+      #
+      # @param [ true, false ] embedded Is the criteria for embedded docs?
+      #
+      # @return [ Criteria ] The scoped criteria.
+      #
+      # @since 2.0.0
+      def scoped(embedded = false)
+        criteria(embedded, true)
+      end
+
+      # Initializes and returns the current scope stack.
+      #
+      # @example Get the scope stack.
+      #   Person.scope_stack
+      #
+      # @return [ Array<Criteria> ] The scope stack.
+      #
+      # @since 1.0.0
+      def scope_stack
+        scope_stack_for = Thread.current[:mongoid_scope_stack] ||= {}
+        scope_stack_for[object_id] ||= []
+      end
+
+      # Get a criteria object for the class, ignoring default scoping.
+      #
+      # @example Get an unscoped criteria.
+      #   Person.scoped
+      #
+      # @param [ true, false ] embedded Is the criteria for embedded docs?
+      #
+      # @return [ Criteria ] The unscoped criteria.
+      #
+      # @since 2.0.0
+      def unscoped(embedded = false)
+        criteria(embedded, false)
+      end
+
+      # Pushes the provided criteria onto the scope stack, and removes it after the
+      # provided block is yielded.
+      #
+      # @example Yield to the criteria.
+      #   Person.with_scope(criteria)
+      #
+      # @param [ Criteria ] criteria The criteria to apply.
+      #
+      # @return [ Criteria ] The yielded criteria.
+      #
+      # @since 1.0.0
+      def with_scope(criteria)
+        scope_stack = self.scope_stack
+        scope_stack << criteria
+        begin
+          yield criteria
+        ensure
+          scope_stack.pop
+        end
+      end
+
+    protected
+
+      def valid_scope_name?(name)
+        if !scopes[name] && respond_to?(name, true)
+          Mongoid.logger.warn "Creating scope :#{name}. " \
+                                    "Overwriting existing method #{self.name}.#{name}."
+        end
+      end
     end
   end
 end

data/lib/mongoid/observer.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Observer < ActiveModel::Observer
+    def initialize
+      super
+      observed_descendants.each { |klass| add_observer!(klass) }
+    end
+
+    protected
+
+    def observed_descendants
+      observed_classes.sum([]) { |klass| klass.descendants }
+    end
+
+    def add_observer!(klass)
+      super
+      define_callbacks klass
+    end
+
+    def define_callbacks(klass)
+      observer = self
+      observer_name = observer.class.name.underscore.gsub('/', '__')
+
+      Mongoid::Callbacks::CALLBACKS.each do |callback|
+        next unless respond_to?(callback)
+        callback_meth = :"_notify_#{observer_name}_for_#{callback}"
+        unless klass.respond_to?(callback_meth)
+          klass.send(:define_method, callback_meth) do |&block|
+            observer.send(callback, self, &block)
+          end
+          klass.send(callback, callback_meth)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/paranoia.rb

@@ -42,19 +42,19 @@ module Mongoid #:nodoc:
     #
     # Example:
     #
-    # <tt>document._remove</tt>
+    # <tt>document.remove</tt>
     #
     # Returns:
     #
     # true
-    def _remove(options = {})
+    def remove(options = {})
       now = Time.now
       collection.update({ :_id => self.id }, { '$set' => { :deleted_at => Time.now } })
       @attributes["deleted_at"] = now
       true
     end
 
-    alias :delete :_remove
+    alias :delete :remove
 
     # Determines if this document is destroyed.
     #

data/lib/mongoid/paths.rb

@@ -55,7 +55,7 @@ module Mongoid #:nodoc:
     #
     # <tt>address.selector</tt>
     def _selector
-      embedded? ? _parent._selector.merge("#{_path}._id" => id) : { "_id" => id }
+      (embedded? ? _parent._selector.merge("#{_path}._id" => id) : { "_id" => id }).merge(shard_key_selector)
     end
   end
 end

data/lib/mongoid/persistence.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+require "mongoid/persistence/atomic"
 require "mongoid/persistence/command"
 require "mongoid/persistence/insert"
 require "mongoid/persistence/insert_embedded"
@@ -19,6 +20,7 @@ module Mongoid #:nodoc:
   #   document.upsert
   module Persistence
     extend ActiveSupport::Concern
+    include Atomic
 
     # Remove the document from the datbase with callbacks.
     #

data/lib/mongoid/persistence/atomic.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+require "mongoid/persistence/atomic/operation"
+require "mongoid/persistence/atomic/add_to_set"
+require "mongoid/persistence/atomic/inc"
+require "mongoid/persistence/atomic/pull_all"
+require "mongoid/persistence/atomic/push"
+
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+
+    # This module provides the explicit atomic operations helpers on the
+    # document itself.
+    module Atomic
+
+      # Performs an atomic $addToSet of the provided value on the supplied field.
+      # If the field does not exist it will be initialized as an empty array.
+      #
+      # If the value already exists on the array it will not be added.
+      #
+      # @example Add only a unique value on the field.
+      #   person.add_to_set(:aliases, "Bond")
+      #
+      # @param [ Symbol ] field The name of the field.
+      # @param [ Object ] value The value to add.
+      # @param [ Hash ] options The mongo persistence options.
+      #
+      # @return [ Array<Object> ] The new value of the field.
+      #
+      # @since 2.0.0
+      def add_to_set(field, value, options = {})
+        AddToSet.new(self, field, value, options).persist
+      end
+
+      # Performs an atomic $inc of the provided value on the supplied
+      # field. If the field does not exist it will be initialized as
+      # the provided value.
+      #
+      # @example Increment a field.
+      #   person.inc(:score, 2)
+      #
+      # @param [ Symbol ] field The name of the field.
+      # @param [ Integer ] value The value to increment.
+      # @param [ Hash ] options The mongo persistence options.
+      #
+      # @return [ Array<Object> ] The new value of the field.
+      #
+      # @since 2.0.0
+      def inc(field, value, options = {})
+        Inc.new(self, field, value, options).persist
+      end
+
+      # Performs an atomic $pullAll of the provided value on the supplied
+      # field. If the field does not exist it will be initialized as an
+      # empty array.
+      #
+      # @example Pull the values from the field.
+      #   person.pull_all(:aliases, [ "Bond", "James" ])
+      #
+      # @param [ Symbol ] field The name of the field.
+      # @param [ Array<Object> ] value The values to pull.
+      # @param [ Hash ] options The mongo persistence options.
+      #
+      # @return [ Array<Object> ] The new value of the field.
+      #
+      # @since 2.0.0
+      def pull_all(field, value, options = {})
+        PullAll.new(self, field, value, options).persist
+      end
+
+      # Performs an atomic $push of the provided value on the supplied field. If
+      # the field does not exist it will be initialized as an empty array.
+      #
+      # @example Push a value on the field.
+      #   person.push(:aliases, "Bond")
+      #
+      # @param [ Symbol ] field The name of the field.
+      # @param [ Object ] value The value to push.
+      # @param [ Hash ] options The mongo persistence options.
+      #
+      # @return [ Array<Object> ] The new value of the field.
+      #
+      # @since 2.0.0
+      def push(field, value, options = {})
+        Push.new(self, field, value, options).persist
+      end
+    end
+  end
+end