mongoid 2.0.0.beta.20 → 2.0.0.rc.1

data/README.rdoc

@@ -1,3 +1,8 @@
+= PLEASE READ (03 JAN 2011)
+
+USERS CURRENTLY POINTED AT master, PLEASE MOVE TO safe_master UNTIL
+FURTHER NOTICE.
+
 = Overview
 
 == About Mongoid
@@ -18,6 +23,9 @@ Mongoid is developed against Ruby 1.8.7, 1.9.1, 1.9.2, and REE.
 Please see the new Mongoid website for up-to-date documentation:
 {mongoid.org}[http://mongoid.org]
 
+= Donating
+* {Support Mongoid at Pledgie}[http://www.pledgie.com/campaigns/7757]
+
 = License
 
 Copyright (c) 2009, 2010 Durran Jordan

data/Rakefile

@@ -0,0 +1,51 @@
+require "bundler"
+Bundler.setup
+
+require "rake"
+require "rake/rdoctask"
+require "rspec"
+require "rspec/core/rake_task"
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "mongoid/version"
+
+task :gem => :build
+task :build do
+  system "gem build mongoid.gemspec"
+end
+
+task :install => :build do
+  system "sudo gem install mongoid-#{Mongoid::VERSION}.gem"
+end
+
+task :release => :build do
+  system "git tag -a #{Mongoid::VERSION} -m 'Tagging #{Mongoid::VERSION}'"
+  system "git push --tags"
+  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
+
+Rspec::Core::RakeTask.new("spec:integration") do |spec|
+  spec.pattern = "spec/integration/**/*_spec.rb"
+end
+
+Rspec::Core::RakeTask.new('spec:progress') do |spec|
+  spec.rspec_opts = %w(--format progress)
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "mongoid #{Mongoid::VERSION}"
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+task :default => :spec

data/lib/config/locales/nl.yml

@@ -0,0 +1,39 @@
+nl:
+  activemodel:
+    errors:
+      messages:
+        taken: al in gebruik
+
+  mongoid:
+    errors:
+      messages:
+        document_not_found:
+          Document niet gevonden voor class %{klass} met de id(s) %{identifiers}.
+        invalid_database:
+          Database moet een Mongo::DB zijn, niet een %{name}.
+        invalid_type:
+          Veld was gedefinieerd als een %{klass}, maar ontvangen als %{other} met
+          de waarde %{value}.
+        unsupported_version:
+          MongoDB %{version} wordt niet ondersteund, upgrade naar versie %{mongo_version}.
+        validations:
+          Gefaalde validatie - %{errors}.
+        invalid_collection:
+          Toegang tot de collectie voor %{klass} is niet toegestaan aangezien het
+          een embedded document is, benader de collectie van een root document.
+        invalid_field:
+          Het is niet toegestaan om een veld genaamd %{name} te definiëren.
+          Definieer geen velden die conflicteren met de Mongoid interne attributen of methode namen.
+          Gerbuik Document#instance_methods om welke namen dit gaat.
+        too_many_nested_attribute_records:
+          Het accepteren van nested attributes voor %{association} is gelimiteerd tot %{limit} records.
+        embedded_in_must_have_inverse_of:
+          Opties voor embedded_in association moet gebruik maken van de inverse_of optie.
+        dependent_only_references_one_or_many:
+          De dependent => destroy|delete optie die was meegegeven is alleen geldig
+          op references_one en references_many associations.
+        association_cant_have_inverse_of:
+          Het definieren van een inverse_of op deze association is niet toegestaan. Gebruik
+          alleen deze optie met embedded_in en references_many as array.
+        calling_document_find_with_nil_is_invalid:
+          Het is niet toegestaan om Document#find aan te roepen met de waarde nil.

data/lib/config/locales/ro.yml

@@ -1,4 +1,4 @@
-en:
+ro:
   activemodel:
     errors:
       messages:

data/lib/mongoid.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 # Copyright (c) 2009, 2010 Durran Jordan
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -19,9 +20,7 @@
 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
 require "delegate"
-require "singleton"
 require "time"
 require "ostruct"
 require "active_support/core_ext"
@@ -43,7 +42,6 @@ require "mongo"
 require "mongoid/errors"
 require "mongoid/extensions"
 require "mongoid/safe"
-require "mongoid/associations"
 require "mongoid/atomicity"
 require "mongoid/attributes"
 require "mongoid/callbacks"
@@ -51,9 +49,11 @@ require "mongoid/collection"
 require "mongoid/collections"
 require "mongoid/config"
 require "mongoid/contexts"
+require "mongoid/copyable"
 require "mongoid/criteria"
 require "mongoid/cursor"
 require "mongoid/deprecation"
+require "mongoid/default_scope"
 require "mongoid/dirty"
 require "mongoid/extras"
 require "mongoid/factory"
@@ -63,17 +63,20 @@ require "mongoid/finders"
 require "mongoid/hierarchy"
 require "mongoid/identity"
 require "mongoid/indexes"
+require "mongoid/inspection"
 require "mongoid/javascript"
 require "mongoid/json"
 require "mongoid/keys"
 require "mongoid/logger"
 require "mongoid/matchers"
-require "mongoid/memoization"
 require "mongoid/modifiers"
 require "mongoid/multi_parameter_attributes"
+require "mongoid/multi_database"
 require "mongoid/named_scope"
+require "mongoid/nested_attributes"
 require "mongoid/paths"
 require "mongoid/persistence"
+require "mongoid/relations"
 require "mongoid/safety"
 require "mongoid/scope"
 require "mongoid/state"
@@ -100,7 +103,7 @@ module Mongoid #:nodoc
 
     # Sets the Mongoid configuration options. Best used by passing a block.
     #
-    # Example:
+    # @example Set up configuration options.
     #
     #   Mongoid.configure do |config|
     #     name = "mongoid_test"
@@ -113,33 +116,30 @@ module Mongoid #:nodoc
     #     ]
     #   end
     #
-    # Returns:
-    #
-    # The Mongoid +Config+ singleton instance.
+    # @return [ Config ] The configuration obejct.
     def configure
-      config = Mongoid::Config.instance
+      config = Mongoid::Config
       block_given? ? yield(config) : config
     end
+    alias :config :configure
 
     # Easy convenience method for generating an alert from the
     # deprecation module.
     #
-    # Example:
+    # @example Alert a deprecation.
+    #   Mongoid.deprecate("Method no longer used")
     #
-    # <tt>Mongoid.deprecate("Method no longer used")</tt>
+    # @param [ String ] message The message to print.
     def deprecate(message)
-      Mongoid::Deprecation.instance.alert(message)
+      Mongoid::Deprecation.alert(message)
     end
-
-    alias :config :configure
   end
 
   # Take all the public instance methods from the Config singleton and allow
   # them to be accessed through the Mongoid module directly.
   #
-  # Example:
-  #
-  # <tt>Mongoid.database = Mongo::Connection.new.db("test")</tt>
+  # @example Delegate the configuration methods.
+  #   Mongoid.database = Mongo::Connection.new.db("test")
   Mongoid::Config.public_instance_methods(false).each do |name|
     (class << self; self; end).class_eval <<-EOT
       def #{name}(*args)

data/lib/mongoid/atomicity.rb

@@ -1,46 +1,52 @@
 # encoding: utf-8
 module Mongoid #:nodoc:
-  module Atomicity #:nodoc:
+
+  # This module contains the logic for supporting atomic operations against the
+  # database.
+  #
+  # @todo Durran: Refactor class out into separate objects for each type of
+  #   update.
+  module Atomicity
     extend ActiveSupport::Concern
 
     # Get all the atomic updates that need to happen for the current
     # +Document+. This includes all changes that need to happen in the
     # entire hierarchy that exists below where the save call was made.
     #
-    # Example:
-    #
-    # <tt>person.save</tt> # Saves entire tree
+    # @note
+    #   MongoDB does not allow "conflicting modifications" to be
+    #   performed in a single operation.  Conflicting modifications are
+    #   detected by the 'haveConflictingMod' function in MongoDB.
+    #   Examination of the code suggests that two modifications (a $set
+    #   and a $pushAll, for example) conflict if:
+    #     (1) the key paths being modified are equal.
+    #     (2) one key path is a prefix of the other.
+    #   So a $set of 'addresses.0.street' will conflict with a $pushAll
+    #   to 'addresses', and we will need to split our update into two
+    #   pieces.  We do not, however, attempt to match MongoDB's logic
+    #   exactly.  Instead, we assume that two updates conflict if the
+    #   first component of the two key paths matches.
     #
-    # Returns:
+    # @example Get the updates that need to occur.
+    #   person._updates
     #
-    # A +Hash+ of all atomic updates that need to occur.
+    # @return [ Hash ] The updates and their modifiers.
     def _updates
       processed = {}
-      
+
       _children.inject({ "$set" => _sets, "$pushAll" => {}, :other => {} }) do |updates, child|
         changes = child._sets
         updates["$set"].update(changes)
         unless changes.empty?
           processed[child._conficting_modification_key] = true
         end
-        
-        # MongoDB does not allow "conflicting modifications" to be
-        # performed in a single operation.  Conflicting modifications are
-        # detected by the 'haveConflictingMod' function in MongoDB.
-        # Examination of the code suggests that two modifications (a $set
-        # and a $pushAll, for example) conflict if (1) the key paths being
-        # modified are equal or (2) one key path is a prefix of the other.
-        # So a $set of 'addresses.0.street' will conflict with a $pushAll
-        # to 'addresses', and we will need to split our update into two
-        # pieces.  We do not, however, attempt to match MongoDB's logic
-        # exactly.  Instead, we assume that two updates conflict if the
-        # first component of the two key paths matches.
+
         if processed.has_key?(child._conficting_modification_key)
           target = :other
         else
           target = "$pushAll"
         end
-        
+
         child._pushes.each do |attr, val|
           if updates[target].has_key?(attr)
             updates[target][attr] << val
@@ -55,24 +61,50 @@ module Mongoid #:nodoc:
     end
 
     protected
+
     # Get the key used to check for conflicting modifications.  For now, we
     # just use the first component of _path, and discard the first period
     # and everything that follows.
+    #
+    # @example Get the key.
+    #   person._conflicting_modification_key
+    #
+    # @return [ String ] The conflicting key.
     def _conficting_modification_key
       _path.sub(/\..*/, '')
     end
 
     # Get all the push attributes that need to occur.
+    #
+    # @example Get the pushes.
+    #   person._pushes
+    #
+    # @return [ Hash ] The $pushAll operations.
     def _pushes
-      (new_record? && embedded_many? && !_parent.new_record?) ? { _path => raw_attributes } : {}
+      pushable? ? { _path => to_hash } : {}
+    end
+
+    # Determine if the document can be pushed.
+    #
+    # @example Is this pushable?
+    #   person.pushable?
+    #
+    # @return [ true, false ] Is the document new and embedded?
+    def pushable?
+      new_record? && embedded_many? && _parent.persisted?
     end
 
     # Get all the attributes that need to be set.
+    #
+    # @example Get the sets.
+    #   person._sets
+    #
+    # @return [ Hash ] The $set operations.
     def _sets
       if changed? && !new_record?
         setters
       else
-        embedded_one? && new_record? ? { _path => raw_attributes } : {}
+        embedded_one? && new_record? ? { _path => to_hash } : {}
       end
     end
   end

data/lib/mongoid/attributes.rb

@@ -1,23 +1,75 @@
 # encoding: utf-8
 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
+
+    # Returns the object type. This corresponds to the name of the class that
+    # this document is, which is used in determining the class to
+    # instantiate in various cases.
+    #
+    # @example Get the type.
+    #   person._type
+    #
+    # @return [ String ] The name of the class the document is.
+    def _type
+      @attributes["_type"]
+    end
+
+    # Set the type of the document. This should be the name of the class.
+    #
+    # @example Set the type
+    #   person._type = "Person"
+    #
+    # @param [ String ] new_type The name of the class.
+    #
+    # @return [ String ] the new type.
+    def _type=(new_type)
+      @attributes["_type"] = new_type
+    end
+
+    # Determine if an attribute is present.
+    #
+    # @example Is the attribute present?
+    #   person.attribute_present?("title")
+    #
+    # @param [ String, Symbol ] name The name of the attribute.
+    #
+    # @return [ true, false ] True if present, false if not.
+    def attribute_present?(name)
+      !read_attribute(name).blank?
+    end
 
     # Get the id associated with this object. This will pull the _id value out
-    # of the attributes +Hash+.
+    # of the attributes.
+    #
+    # @example Get the id.
+    #   person.id
+    #
+    # @return [ BSON::ObjectId, String ] The id of the document.
     def id
       @attributes["_id"]
     end
+    alias :_id :id
 
-    # Set the id of the +Document+ to a new one.
+    # Set the id of the document to a new one.
+    #
+    # @example Set the id.
+    #   person.id = BSON::ObjectId.new
+    #
+    # @param [ BSON::ObjectId, String ] new_id The new id.
+    #
+    # @return [ BSON::ObjectId, String ] The new id.
     def id=(new_id)
       @attributes["_id"] = new_id
     end
-
-    alias :_id :id
     alias :_id= :id=
 
     # Used for allowing accessor methods for dynamic attributes.
+    #
+    # @param [ String, Symbol ] name The name of the method.
+    # @param [ Array ] *args The arguments to the method.
     def method_missing(name, *args)
       attr = name.to_s
       return super unless @attributes.has_key?(attr.reader)
@@ -29,44 +81,42 @@ module Mongoid #:nodoc:
       end
     end
 
-    # Override respond_to? so it responds properly for dynamic attributes
-    def respond_to?(*args)
-      (Mongoid.allow_dynamic_fields && @attributes && @attributes.has_key?(args.first.to_s)) || super
-    end
-
     # Process the provided attributes casting them to their proper values if a
-    # field exists for them on the +Document+. This will be limited to only the
+    # field exists for them on the document. This will be limited to only the
     # attributes provided in the suppied +Hash+ so that no extra nil values get
     # put into the document's attributes.
+    #
+    # @example Process the attributes.
+    #   person.process(:title => "sir", :age => 40)
+    #
+    # @param [ Hash ] attrs The attributes to set.
     def process(attrs = nil)
+      pending = {}
       sanitize_for_mass_assignment(attrs || {}).each_pair do |key, value|
         if set_allowed?(key)
           write_attribute(key, value)
         else
-          if associations.include?(key.to_s) and associations[key.to_s].embedded? and value.is_a?(Hash)
-            if association = send(key)
-              association.nested_build(value)
-            else
-              send("build_#{key}", value)
-            end
-          else
-            send("#{key}=", value)
-          end
+          pending[key.to_s] = value and next if relations.has_key?(key.to_s)
+          send("#{key}=", value)
         end
       end
+      yield self if block_given?
+      process_relations(pending)
       setup_modifications
     end
 
-    # Read a value from the +Document+ attributes. If the value does not exist
+    # Read a value from the document attributes. If the value does not exist
     # it will return nil.
     #
-    # Options:
+    # @example Read an attribute.
+    #   person.read_attribute(:title)
     #
-    # name: The name of the attribute to get.
+    # @example Read an attribute (alternate syntax.)
+    #   person[:title]
     #
-    # Example:
+    # @param [ String, Symbol ] name The name of the attribute to get.
     #
-    # <tt>person.read_attribute(:title)</tt>
+    # @return [ Object ] The value of the attribute.
     def read_attribute(name)
       access = name.to_s
       value = @attributes[access]
@@ -78,93 +128,75 @@ module Mongoid #:nodoc:
     # Remove a value from the +Document+ attributes. If the value does not exist
     # it will fail gracefully.
     #
-    # Options:
-    #
-    # name: The name of the attribute to remove.
+    # @example Remove the attribute.
+    #   person.remove_attribute(:title)
     #
-    # Example:
-    #
-    # <tt>person.remove_attribute(:title)</tt>
+    # @param [ String, Symbol ] name The name of the attribute to remove.
     def remove_attribute(name)
       access = name.to_s
       modify(access, @attributes.delete(name.to_s), nil)
     end
 
-    # Returns true when attribute is present.
+    # Override respond_to? so it responds properly for dynamic attributes.
     #
-    # Options:
+    # @example Does this object respond to the method?
+    #   person.respond_to?(:title)
     #
-    # name: The name of the attribute to request presence on.
-    def attribute_present?(name)
-      value = read_attribute(name)
-      !value.blank?
-    end
-
-    # Returns the object type. This corresponds to the name of the class that
-    # this +Document+ is, which is used in determining the class to
-    # instantiate in various cases.
-    def _type
-      @attributes["_type"]
-    end
-
-    # Set the type of the +Document+. This should be the name of the class.
-    def _type=(new_type)
-      @attributes["_type"] = new_type
+    # @param [ Array ] *args The name of the method.
+    #
+    # @return [ true, false ] True if it does, false if not.
+    def respond_to?(*args)
+      (Mongoid.allow_dynamic_fields &&
+        @attributes &&
+        @attributes.has_key?(args.first.to_s)
+      ) || super
     end
 
-    # Write a single attribute to the +Document+ attribute +Hash+. This will
+    # Write a single attribute to the document attribute hash. This will
     # also fire the before and after update callbacks, and perform any
     # necessary typecasting.
     #
-    # Options:
-    #
-    # name: The name of the attribute to update.
-    # value: The value to set for the attribute.
-    #
-    # Example:
+    # @example Write the attribute.
+    #   person.write_attribute(:title, "Mr.")
     #
-    # <tt>person.write_attribute(:title, "Mr.")</tt>
+    # @example Write the attribute (alternate syntax.)
+    #   person[:title] = "Mr."
     #
-    # This will also cause the observing +Document+ to notify it's parent if
-    # there is any.
+    # @param [ String, Symbol ] name The name of the attribute to update.
+    # @param [ Object ] value The value to set for the attribute.
     def write_attribute(name, value)
       access = name.to_s
       modify(access, @attributes[access], typed_value_for(access, value))
-      notify if !id.blank? && new_record?
     end
     alias :[]= :write_attribute
 
-    # Writes the supplied attributes +Hash+ to the +Document+. This will only
+    # 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.
     #
-    # Options:
+    # @example Write the attributes.
+    #   person.write_attributes(:title => "Mr.")
     #
-    # attrs: The +Hash+ of new attributes to set on the +Document+
+    # @example Write the attributes (alternate syntax.)
+    #   person.attributes = { :title => "Mr." }
     #
-    # Example:
-    #
-    # <tt>person.write_attributes(:title => "Mr.")</tt>
-    #
-    # This will also cause the observing +Document+ to notify it's parent if
-    # there is any.
+    # @param [ Hash ] attrs The new attributes to set.
     def write_attributes(attrs = nil)
       process(attrs || {})
-      identified = !id.blank?
-      if new_record? && !identified
-        identify; notify
+      if new_record? && id.blank?
+        identify
       end
     end
     alias :attributes= :write_attributes
 
     protected
 
-    # Return the typecast value for a field.
-    def typed_value_for(key, value)
-      fields.has_key?(key) ? fields[key].set(value) : value
-    end
-
-    # apply default values to attributes - calling procs as required
+    # Get the default values for the attributes.
+    #
+    # @example Get the defaults.
+    #   person.default_attributes
+    #
+    # @return [ Hash ] The default values for each field.
     def default_attributes
       default_values = defaults
       default_values.each_pair do |key, val|
@@ -173,59 +205,47 @@ module Mongoid #:nodoc:
       default_values || {}
     end
 
-    # Return true if dynamic field setting is enabled.
-    def set_allowed?(key)
-      Mongoid.allow_dynamic_fields && !respond_to?("#{key}=")
-    end
-
-    # Used when supplying a :reject_if block as an option to
-    # accepts_nested_attributes_for
-    def reject(attributes, options)
-      rejector = options[:reject_if]
-      if rejector
-        attributes.delete_if do |key, value|
-          rejector.call(value)
+    # Process all the pending relations that needed to wait until ids were set
+    # to fire off.
+    #
+    # @example Process the relations.
+    #   document.process_relations({ "addressable" => person })
+    #
+    # @param [ Hash ] pending The pending relation values.
+    def process_relations(pending)
+      pending.each_pair do |name, value|
+        metadata = relations[name]
+        if value.is_a?(Hash)
+          metadata.nested_builder(value, {}).build(self)
+        else
+          send("#{name}=", value)
         end
       end
     end
 
-    # Used when supplying a :limit as an option to accepts_nested_attributes_for
-    def limit(attributes, name, options)
-      if options[:limit] && attributes.size > options[:limit]
-        raise Mongoid::Errors::TooManyNestedAttributeRecords.new(name, options[:limit])
-      end
+    # Return true if dynamic field setting is enabled.
+    #
+    # @example Is a set allowed for this name?
+    #   person.set_allowed?(:title)
+    #
+    # @param [ String, Symbol ] key The name of the field.
+    #
+    # @return [ true, false ] True if allowed, false if not.
+    def set_allowed?(key)
+      Mongoid.allow_dynamic_fields && !respond_to?("#{key}=")
     end
 
-    module ClassMethods
-      # Defines attribute setters for the associations specified by the names.
-      # This will work for a has one or has many association.
-      #
-      # Example:
-      #
-      #   class Person
-      #     include Mongoid::Document
-      #     embeds_one :name
-      #     embeds_many :addresses
-      #
-      #     accepts_nested_attributes_for :name, :addresses
-      #   end
-      def accepts_nested_attributes_for(*args)
-        associations = args.flatten
-        options = associations.last.is_a?(Hash) ? associations.pop : {}
-        associations.each do |name|
-          define_method("#{name}_attributes=") do |attrs|
-            reject(attrs, options)
-            limit(attrs, name, options)
-            association = send(name)
-            if association
-              # observe(association, true)
-              association.nested_build(attrs, options)
-            else
-              send("build_#{name}", attrs, options)
-            end
-          end
-        end
-      end
+    # Return the typecasted value for a field.
+    #
+    # @example Get the value typecasted.
+    #   person.typed_value_for(:title, :sir)
+    #
+    # @param [ String, Symbol ] key The field name.
+    # @param [ Object ] value The uncast value.
+    #
+    # @return [ Object ] The cast value.
+    def typed_value_for(key, value)
+      fields.has_key?(key) ? fields[key].set(value) : value
     end
   end
 end