mongoid 2.0.0.alpha → 2.0.0.beta.5

data/lib/mongoid/associations/proxy.rb

@@ -1,30 +1,23 @@
 # encoding: utf-8
 module Mongoid #:nodoc
   module Associations #:nodoc
-    module Proxy #:nodoc
-      def self.included(base)
-        base.class_eval do
-          instance_methods.each do |method|
-            undef_method(method) unless method =~ /(^__|^nil\?$|^send$|^object_id$|^extend$)/
-          end
-          include InstanceMethods
-        end
+    class Proxy #:nodoc
+      instance_methods.each do |method|
+        undef_method(method) unless method =~ /(^__|^nil\?$|^send$|^object_id$|^extend$)/
       end
-      module InstanceMethods #:nodoc:
-        attr_reader \
-          :options,
-          :target
+      attr_reader \
+        :options,
+        :target
 
-        # Default behavior of method missing should be to delegate all calls
-        # to the target of the proxy. This can be overridden in special cases.
-        def method_missing(name, *args, &block)
-          @target.send(name, *args, &block)
-        end
+      # Default behavior of method missing should be to delegate all calls
+      # to the target of the proxy. This can be overridden in special cases.
+      def method_missing(name, *args, &block)
+        @target.send(name, *args, &block)
+      end
 
-        # If anonymous extensions are added this will take care of them.
-        def extends(options)
-          extend Module.new(&options.extension) if options.extension?
-        end
+      # If anonymous extensions are added this will take care of them.
+      def extends(options)
+        extend Module.new(&options.extension) if options.extension?
       end
     end
   end

data/lib/mongoid/attributes.rb

@@ -41,6 +41,7 @@ module Mongoid #:nodoc:
             send("#{key}=", value)
           end
         end
+        setup_modifications
       end
 
       # Read a value from the +Document+ attributes. If the value does not exist
@@ -55,7 +56,7 @@ module Mongoid #:nodoc:
       # <tt>person.read_attribute(:title)</tt>
       def read_attribute(name)
         access = name.to_s
-        fields[access].get(@attributes[access])
+        accessed(access, fields[access].get(@attributes[access]))
       end
 
       # Remove a value from the +Document+ attributes. If the value does not exist
@@ -69,7 +70,8 @@ module Mongoid #:nodoc:
       #
       # <tt>person.remove_attribute(:title)</tt>
       def remove_attribute(name)
-        @attributes.delete(name.to_s)
+        access = name.to_s
+        modify(access, @attributes.delete(name.to_s), nil)
       end
 
       # Returns the object type. This corresponds to the name of the class that
@@ -101,8 +103,8 @@ module Mongoid #:nodoc:
       # there is any.
       def write_attribute(name, value)
         access = name.to_s
-        @attributes[access] = fields[access].set(value)
-        notify unless id.blank?
+        modify(access, @attributes[access], fields[access].set(value))
+        notify if !id.blank? && new_record?
       end
 
       # Writes the supplied attributes +Hash+ to the +Document+. This will only
@@ -121,12 +123,23 @@ module Mongoid #:nodoc:
       # there is any.
       def write_attributes(attrs = nil)
         process(attrs || {})
-        identify if id.blank?
-        notify
+        identified = !id.blank?
+        if new_record? && !identified
+          identify; notify
+        end
       end
       alias :attributes= :write_attributes
 
       protected
+      # apply default values to attributes - calling procs as required
+      def default_attributes
+        default_values = defaults
+        default_values.each_pair do |key, val|
+          default_values[key] = val.call if val.respond_to?(:call)
+        end
+        default_values || {}
+      end
+
       # Return true if dynamic field setting is enabled.
       def set_allowed?(key)
         Mongoid.allow_dynamic_fields && !respond_to?("#{key}=")
@@ -143,10 +156,17 @@ module Mongoid #:nodoc:
         end
       end
 
+      # Used when supplying a :limit as an option to accepts_nested_attributes_for
+      def limit(attributes, name, options)
+        raise Mongoid::Errors::TooManyNestedAttributeRecords.new(name, options[:limit]) if options[:limit] && attributes.size > options[:limit]
+      end
+
       # Return true if writing to the given field is allowed
       def write_allowed?(key)
-        return true unless fields[key.to_s]
-        fields[key.to_s].accessible?
+        name = key.to_s
+        existing = fields[name]
+        return true unless existing
+        existing.accessible?
       end
     end
 
@@ -158,8 +178,8 @@ module Mongoid #:nodoc:
       #
       #   class Person
       #     include Mongoid::Document
-      #     embed_one :name
-      #     embed_many :addresses
+      #     embeds_one :name
+      #     embeds_many :addresses
       #
       #     accepts_nested_attributes_for :name, :addresses
       #   end
@@ -169,12 +189,13 @@ module Mongoid #:nodoc:
         associations.each do |name|
           define_method("#{name}_attributes=") do |attrs|
             reject(attrs, options)
+            limit(attrs, name, options)
             association = send(name)
             if association
-              update(association, true)
-              association.nested_build(attrs)
+              # observe(association, true)
+              association.nested_build(attrs, options)
             else
-              send("build_#{name}", attrs)
+              send("build_#{name}", attrs, options)
             end
           end
         end

data/lib/mongoid/callbacks.rb

@@ -11,8 +11,7 @@ module Mongoid #:nodoc:
         :destroy,
         :save,
         :update,
-        :validate,
-        :terminator => false
+        :validate
     end
   end
 end

data/lib/mongoid/collection.rb

@@ -1,13 +1,12 @@
 # encoding: utf-8
 require "mongoid/collections/operations"
 require "mongoid/collections/cyclic_iterator"
-require "mongoid/collections/mimic"
 require "mongoid/collections/master"
 require "mongoid/collections/slaves"
 
 module Mongoid #:nodoc
+  # The Mongoid wrapper to the Mongo Ruby driver's collection object.
   class Collection
-    include Collections::Mimic
     attr_reader :counter, :name
 
     # All write operations should delegate to the master connection. These
@@ -16,7 +15,9 @@ module Mongoid #:nodoc
     # Example:
     #
     # <tt>collection.save({ :name => "Al" })</tt>
-    proxy(:master, Collections::Operations::PROXIED)
+    Collections::Operations::PROXIED.each do |name|
+      define_method(name) { |*args| master.send(name, *args) }
+    end
 
     # Determines where to send the next read query. If the slaves are not
     # defined then send to master. If the read counter is under the configured

data/lib/mongoid/collections.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  # The collections module is used for providing functionality around setting
+  # up and updating collections.
+  module Collections
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :_collection, :collection_name
+      self.collection_name = self.name.collectionize
+      delegate :collection, :to => "self.class"
+    end
+
+    module ClassMethods #:nodoc:
+      # Returns the collection associated with this +Document+. If the
+      # document is embedded, there will be no collection associated
+      # with it.
+      #
+      # Returns: <tt>Mongo::Collection</tt>
+      def collection
+        raise Errors::InvalidCollection.new(self) if embedded?
+        self._collection || set_collection
+        add_indexes; self._collection
+      end
+
+      # Macro for setting the collection name to store in.
+      #
+      # Example:
+      #
+      # <tt>Person.store_in :populdation</tt>
+      def store_in(name)
+        self.collection_name = name.to_s
+        set_collection
+      end
+
+      protected
+      def set_collection
+        self._collection = Mongoid::Collection.new(self, self.collection_name)
+      end
+    end
+  end
+end

data/lib/mongoid/collections/master.rb

@@ -2,7 +2,6 @@
 module Mongoid #:nodoc:
   module Collections #:nodoc:
     class Master
-      include Mimic
 
       attr_reader :collection
 
@@ -12,7 +11,9 @@ module Mongoid #:nodoc:
       # Example:
       #
       # <tt>collection.save({ :name => "Al" })</tt>
-      proxy(:collection, Operations::ALL)
+      Operations::ALL.each do |name|
+        define_method(name) { |*args| collection.send(name, *args) }
+      end
 
       # Create the new database writer. Will create a collection from the
       # master database.

data/lib/mongoid/collections/slaves.rb

@@ -2,7 +2,6 @@
 module Mongoid #:nodoc:
   module Collections #:nodoc:
     class Slaves
-      include Mimic
 
       attr_reader :iterator
 
@@ -12,7 +11,9 @@ module Mongoid #:nodoc:
       # Example:
       #
       # <tt>collection.save({ :name => "Al" })</tt>
-      proxy(:collection, Operations::READ)
+      Operations::READ.each do |name|
+        define_method(name) { |*args| collection.send(name, *args) }
+      end
 
       # Is the collection of slaves empty or not?
       #

data/lib/mongoid/components.rb

@@ -8,10 +8,12 @@ module Mongoid #:nodoc
       include ActiveModel::Conversion
       include ActiveModel::Naming
       include ActiveModel::Serialization
+      include ActiveModel::Serializers::JSON
       include Mongoid::Associations
       include Mongoid::Attributes
       include Mongoid::Callbacks
-      include Mongoid::Commands
+      include Mongoid::Collections
+      include Mongoid::Dirty
       include Mongoid::Extras
       include Mongoid::Fields
       include Mongoid::Indexes
@@ -19,6 +21,7 @@ module Mongoid #:nodoc
       include Mongoid::Memoization
       include Mongoid::Observable
       include Mongoid::Paths
+      include Mongoid::Persistence
       include Mongoid::State
       include Mongoid::Validations
       extend ActiveModel::Translation

data/lib/mongoid/config.rb

@@ -1,4 +1,6 @@
 # encoding: utf-8
+require "uri"
+
 module Mongoid #:nodoc
   class Config #:nodoc
     include Singleton
@@ -8,23 +10,45 @@ module Mongoid #:nodoc
       :reconnect_time,
       :parameterize_keys,
       :persist_in_safe_mode,
-      :persist_types,
       :raise_not_found_error,
-      :use_object_ids
+      :use_object_ids,
+      :skip_version_check
 
     # Defaults the configuration options to true.
     def initialize
-      @allow_dynamic_fields = true
-      @parameterize_keys = true
-      @persist_in_safe_mode = true
-      @persist_types = true
-      @raise_not_found_error = true
-      @reconnect_time = 3
-      @use_object_ids = false
+      reset
+    end
+
+    # Sets whether the times returned from the database are in UTC or local time.
+    # If you omit this setting, then times will be returned in
+    # the local time zone.
+    #
+    # Example:
+    #
+    # <tt>Config.use_utc = true</tt>
+    #
+    # Returns:
+    #
+    # A boolean
+    def use_utc=(value)
+      @use_utc = value || false
     end
 
-    # Sets the Mongo::DB master database to be used. If the object trying to me
-    # set is not a valid +Mongo::DB+, then an error will be raise.
+    # Returns whether times are return from the database in UTC. If
+    # this setting is false, then times will be returned in the local time zone.
+    #
+    # Example:
+    #
+    # <tt>Config.use_utc</tt>
+    #
+    # Returns:
+    #
+    # A boolean
+    attr_reader :use_utc
+    alias_method :use_utc?, :use_utc
+
+    # Sets the Mongo::DB master database to be used. If the object trying to be
+    # set is not a valid +Mongo::DB+, then an error will be raised.
     #
     # Example:
     #
@@ -34,7 +58,7 @@ module Mongoid #:nodoc
     #
     # The Master DB instance.
     def master=(db)
-      raise Errors::InvalidDatabase.new(db) unless db.kind_of?(Mongo::DB)
+      check_database!(db)
       @master = db
     end
 
@@ -66,7 +90,10 @@ module Mongoid #:nodoc
     #
     # The slaves DB instances.
     def slaves=(dbs)
-      dbs.each { |db| raise Errors::InvalidDatabase.new(db) unless db.kind_of?(Mongo::DB) }
+      return unless dbs
+      dbs.each do |db|
+        check_database!(db)
+      end
       @slaves = dbs
     end
 
@@ -82,5 +109,128 @@ module Mongoid #:nodoc
     def slaves
       @slaves
     end
+
+    # Return field names that could cause destructive things to happen if
+    # defined in a Mongoid::Document
+    #
+    # Example:
+    #
+    # <tt>Config.destructive_fields</tt>
+    #
+    # Returns:
+    #
+    # An array of bad field names.
+    def destructive_fields
+      @destructive_fields ||= lambda {
+        klass = Class.new do
+          include Mongoid::Document
+        end
+        klass.instance_methods(true).collect { |method| method.to_s }
+      }.call
+    end
+
+    # Configure mongoid from a hash that was usually parsed out of yml.
+    #
+    # Example:
+    #
+    # <tt>Mongoid::Config.instance.from_hash({})</tt>
+    def from_hash(settings)
+      _master(settings)
+      _slaves(settings)
+      settings.except("database").each_pair do |name, value|
+        send("#{name}=", value) if respond_to?(name)
+      end
+    end
+
+    # Reset the configuration options to the defaults.
+    #
+    # Example:
+    #
+    # <tt>config.reset</tt>
+    def reset
+      @allow_dynamic_fields = true
+      @parameterize_keys = true
+      @persist_in_safe_mode = true
+      @raise_not_found_error = true
+      @reconnect_time = 3
+      @use_object_ids = false
+      @skip_version_check = false
+      @time_zone = nil
+    end
+
+    protected
+
+    # Check if the database is valid and the correct version.
+    #
+    # Example:
+    #
+    # <tt>config.check_database!</tt>
+    def check_database!(database)
+      raise Errors::InvalidDatabase.new(database) unless database.kind_of?(Mongo::DB)
+      unless Mongoid.skip_version_check
+        version = database.connection.server_version
+        raise Errors::UnsupportedVersion.new(version) if version < Mongoid::MONGODB_VERSION
+      end
+    end
+
+    # Get a Rails logger or stdout logger.
+    #
+    # Example:
+    #
+    # <tt>config.logger</tt>
+    def logger
+      defined?(Rails) ? Rails.logger : Logger.new($stdout)
+    end
+
+    # Get a master database from settings.
+    #
+    # Example:
+    #
+    # <tt>config._master({}, "test")</tt>
+    def _master(settings)
+      mongo_uri = settings["uri"].present? ? URI.parse(settings["uri"]) : OpenStruct.new
+
+      name = settings["database"] || mongo_uri.path.to_s.sub("/", "")
+      host = settings["host"] || mongo_uri.host || "localhost"
+      port = settings["port"] || mongo_uri.port || 27017
+      username = settings["username"] || mongo_uri.user
+      password = settings["password"] || mongo_uri.password
+
+      connection = Mongo::Connection.new(host, port, :logger => logger)
+      if username || password
+        connection.add_auth(name, username, password)
+        connection.apply_saved_authentication
+      end
+      self.master = connection.db(name)
+    end
+
+    # Get a bunch-o-slaves from settings and names.
+    #
+    # Example:
+    #
+    # <tt>config._slaves({}, "test")</tt>
+    def _slaves(settings)
+      mongo_uri = settings["uri"].present? ? URI.parse(settings["uri"]) : OpenStruct.new
+      name = settings["database"] || mongo_uri.path.to_s.sub("/", "")
+      self.slaves = []
+      slaves = settings["slaves"]
+      slaves.to_a.each do |slave|
+        slave_uri = slave["uri"].present? ? URI.parse(slave["uri"]) : OpenStruct.new
+        slave_username = slave["username"] || slave_uri.user
+        slave_password = slave["password"] || slave_uri.password
+
+        slave_connection = Mongo::Connection.new(
+          slave["host"] || slave_uri.host || "localhost",
+          slave["port"] || slave_uri.port,
+          :slave_ok => true
+        )
+
+        if slave_username || slave_password
+          slave_connection.add_auth(name, slave_username, slave_password)
+          slave_connection.apply_saved_authentication
+        end
+        self.slaves << slave_connection.db(name)
+      end
+    end
   end
 end