mongoid 2.4.10 → 3.0.0

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

@@ -1,8 +1,8 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
-  module Atomic #:nodoc:
-    module Paths #:nodoc:
-      module Embedded #:nodoc:
+module Mongoid
+  module Atomic
+    module Paths
+      module Embedded
 
         # This class encapsulates behaviour for locating and updating
         # documents that are defined as an embedded 1-1.
@@ -34,7 +34,7 @@ module Mongoid #:nodoc:
           # @since 2.1.0
           def position
             pos = parent.atomic_position
-            "#{pos}#{"." unless pos.blank?}#{document.metadata.name}"
+            "#{pos}#{"." unless pos.blank?}#{document.metadata.store_as}"
           end
         end
       end

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.
@@ -14,9 +14,9 @@ module Mongoid #:nodoc:
       :atomic_array_pulls,
       :atomic_array_add_to_sets,
       :atomic_pulls,
-      :atomic_unsets,
       :delayed_atomic_sets,
-      :delayed_atomic_pulls
+      :delayed_atomic_pulls,
+      :delayed_atomic_unsets
     ]
 
     included do
@@ -36,7 +36,22 @@ module Mongoid #:nodoc:
     # @since 2.2.0
     def add_atomic_pull(document)
       document.flagged_for_destroy = true
-      (delayed_atomic_pulls[document.metadata.name.to_s] ||= []).push(document)
+      (delayed_atomic_pulls[document.metadata_name.to_s] ||= []).push(document)
+    end
+
+    # Add an atomic unset for the document.
+    #
+    # @example Add an atomic unset.
+    #   document.add_atomic_unset(doc)
+    #
+    # @param [ Document ] document The child document.
+    #
+    # @return [ Array<Document> ] The children.
+    #
+    # @since 3.0.0
+    def add_atomic_unset(document)
+      document.flagged_for_destroy = true
+      (delayed_atomic_unsets[document.metadata_name.to_s] ||= []).push(document)
     end
 
     # For array fields these are the pushes that need to happen.
@@ -99,12 +114,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 +166,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.
@@ -164,9 +189,7 @@ module Mongoid #:nodoc:
       delayed_atomic_pulls.each_pair do |_, docs|
         path = nil
         ids = docs.map do |doc|
-          path ||= doc.atomic_path
-          doc.destroyed = true
-          doc.flagged_for_destroy = false
+          path ||= doc.flag_as_destroyed
           doc.id
         end
         pulls[path] = { "_id" => { "$in" => ids }} and path = nil
@@ -218,7 +241,15 @@ module Mongoid #:nodoc:
     #
     # @since 2.2.0
     def atomic_unsets
-      @atomic_unsets ||= []
+      unsets = []
+      delayed_atomic_unsets.each_pair do |name, docs|
+        path = nil
+        docs.each do |doc|
+          path ||= doc.flag_as_destroyed
+        end
+        unsets.push(path || name)
+      end
+      unsets
     end
 
     # Get all the atomic sets that have had their saves delayed.
@@ -245,6 +276,32 @@ module Mongoid #:nodoc:
       @delayed_atomic_pulls ||= {}
     end
 
+    # Get the delayed atomic unsets.
+    #
+    # @example Get the delayed atomic unsets.
+    #   document.delayed_atomic_unsets
+    #
+    # @return [ Hash ] The atomic unsets
+    #
+    # @since 3.0.0
+    def delayed_atomic_unsets
+      @delayed_atomic_unsets ||= {}
+    end
+
+    # Flag the document as destroyed and return the atomic path.
+    #
+    # @example Flag destroyed and return path.
+    #   document.flag_as_destroyed
+    #
+    # @return [ String ] The atomic path.
+    #
+    # @since 3.0.0
+    def flag_as_destroyed
+      self.destroyed = true
+      self.flagged_for_destroy = false
+      atomic_path
+    end
+
     private
 
     # Get the atomic paths utility for this document.
@@ -252,9 +309,6 @@ module Mongoid #:nodoc:
     # @example Get the atomic paths.
     #   document.atomic_paths
     #
-    # @todo: Durran: Should probably raise error for embedded docs w/o
-    #   metadata.
-    #
     # @return [ Object ] The associated path.
     #
     # @since 2.1.0

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.empty?
+          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)
+        delayed_atomic_unsets[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