mongo_mapper 0.7.0 → 0.7.1

data/README.rdoc

@@ -1,6 +1,6 @@
 = MongoMapper
 
-Awesome gem for modeling your domain and storing it in mongo.
+A Ruby Object Mapper for Mongo.
 
 Releases are tagged on github and released on gemcutter. Master is pushed to whenever I add a patch or a new feature, but I do not release a new gem version each time I push.
 
@@ -24,6 +24,8 @@ http://groups.google.com/group/mongomapper
 To see if the problem you are having is a verified issue, you can see the MM pivotal tracker project:
 http://www.pivotaltracker.com/projects/33576
 
+There is no need to request to join the Pivotal Tracker project as I am only granting access to a select few (easier to keep things organized). If you have a problem, please use the mailing list. If I confirm it to be a bug, I am happy to add it to PT. Thanks!
+
 == Copyright
 
 Copyright (c) 2009 John Nunemaker. See LICENSE for details.

data/Rakefile

@@ -1,20 +1,21 @@
 require 'rubygems'
 require 'rake'
 require 'jeweler'
-require 'yard'
-require 'yard/rake/yardoc_task'
+
+require File.dirname(__FILE__) + '/lib/mongo_mapper/version'
 
 Jeweler::Tasks.new do |gem|
   gem.name        = "mongo_mapper"
-  gem.summary     = %Q{Awesome gem for modeling your domain and storing it in mongo}
+  gem.summary     = %Q{A Ruby Object Mapper for Mongo}
   gem.email       = "nunemaker@gmail.com"
   gem.homepage    = "http://github.com/jnunemaker/mongomapper"
   gem.authors     = ["John Nunemaker"]
-  
+  gem.version     = MongoMapper::Version
+
   gem.add_dependency('activesupport', '>= 2.3')
-  gem.add_dependency('mongo', '0.18.3')
-  gem.add_dependency('jnunemaker-validatable', '1.8.1')
-  
+  gem.add_dependency('mongo', '0.19.1')
+  gem.add_dependency('jnunemaker-validatable', '1.8.3')
+
   gem.add_development_dependency('jnunemaker-matchy', '0.4.0')
   gem.add_development_dependency('shoulda', '2.10.2')
   gem.add_development_dependency('timecop', '0.3.1')
@@ -38,7 +39,7 @@ namespace :test do
     test.pattern = 'test/unit/**/test_*.rb'
     test.verbose = true
   end
-  
+
   Rake::TestTask.new(:functionals) do |test|
     test.libs << 'test'
     test.ruby_opts << '-rubygems'
@@ -49,7 +50,3 @@ end
 
 task :default  => :test
 task :test     => :check_dependencies
-
-YARD::Rake::YardocTask.new(:doc) do |t|
-  t.options = ["--legacy"] if RUBY_VERSION < "1.9.0"
-end

data/lib/mongo_mapper.rb

@@ -1,4 +1,5 @@
 require 'set'
+require 'uri'
 
 # if Gem is defined i'll assume you are using rubygems and lock specific versions
 # call me crazy but a plain old require will just get the latest version you have installed
@@ -6,11 +7,11 @@ require 'set'
 # if there is a better way to do this, please enlighten me!
 if self.class.const_defined?(:Gem)
   gem 'activesupport', '>= 2.3'
-  gem 'mongo', '0.18.3'
-  gem 'jnunemaker-validatable', '1.8.1'
+  gem 'mongo', '0.19.1'
+  gem 'jnunemaker-validatable', '1.8.3'
 end
 
-require 'active_support'
+require 'active_support/all'
 require 'mongo'
 require 'validatable'
 
@@ -24,6 +25,9 @@ module MongoMapper
   # raised when document expected but not found
   class DocumentNotFound < MongoMapperError; end
 
+  # raised when trying to connect using uri with incorrect scheme
+  class InvalidScheme < MongoMapperError; end
+
   # raised when document not valid and using !
   class DocumentNotValid < MongoMapperError
     def initialize(document)
@@ -70,13 +74,28 @@ module MongoMapper
     @@config
   end
 
+  # @api private
+  def self.config_for_environment(environment)
+    env = config[environment]
+    return env if env['uri'].blank?
+    
+    uri = URI.parse(env['uri'])
+    raise InvalidScheme.new('must be mongodb') unless uri.scheme == 'mongodb'
+    {
+      'host'     => uri.host,
+      'port'     => uri.port,
+      'database' => uri.path.gsub(/^\//, ''),
+      'username' => uri.user,
+      'password' => uri.password,
+    }
+  end
+
   def self.connect(environment, options={})
     raise 'Set config before connecting. MongoMapper.config = {...}' if config.blank?
-    MongoMapper.connection = Mongo::Connection.new(config[environment]['host'], config[environment]['port'], options)
-    MongoMapper.database = config[environment]['database']
-    if config[environment]['username'].present? && config[environment]['password'].present?
-      MongoMapper.database.authenticate(config[environment]['username'], config[environment]['password'])
-    end
+    env = config_for_environment(environment)
+    MongoMapper.connection = Mongo::Connection.new(env['host'], env['port'], options)
+    MongoMapper.database = env['database']
+    MongoMapper.database.authenticate(env['username'], env['password']) if env['username'] && env['password']
   end
 
   def self.setup(config, environment, options={})
@@ -108,11 +127,12 @@ module MongoMapper
   def self.normalize_object_id(value)
     value.is_a?(String) ? Mongo::ObjectID.from_string(value) : value
   end
-  
+
   autoload :Query,            'mongo_mapper/query'
   autoload :Document,         'mongo_mapper/document'
   autoload :EmbeddedDocument, 'mongo_mapper/embedded_document'
+  autoload :Version,          'mongo_mapper/version'
 end
 
 require 'mongo_mapper/support'
-require 'mongo_mapper/plugins'
+require 'mongo_mapper/plugins'

data/lib/mongo_mapper/document.rb

@@ -17,13 +17,16 @@ module MongoMapper
         plugin Plugins::Keys
         plugin Plugins::Dirty # for now dirty needs to be after keys
         plugin Plugins::Logger
+        plugin Plugins::Modifiers
         plugin Plugins::Pagination
         plugin Plugins::Protected
         plugin Plugins::Rails
         plugin Plugins::Serialization
+        plugin Plugins::Timestamps
+        plugin Plugins::Userstamps
         plugin Plugins::Validations
         plugin Plugins::Callbacks # for now callbacks needs to be after validations
-        
+
         extend Plugins::Validations::DocumentMacros
       end
 
@@ -143,47 +146,6 @@ module MongoMapper
         find_each(options) { |document| document.destroy }
       end
 
-      def increment(*args)
-        modifier_update('$inc', args)
-      end
-
-      def decrement(*args)
-        criteria, keys = criteria_and_keys_from_args(args)
-        values, to_decrement = keys.values, {}
-        keys.keys.each_with_index { |k, i| to_decrement[k] = -values[i].abs }
-        collection.update(criteria, {'$inc' => to_decrement}, :multi => true)
-      end
-
-      def set(*args)
-        modifier_update('$set', args)
-      end
-
-      def push(*args)
-        modifier_update('$push', args)
-      end
-
-      def push_all(*args)
-        modifier_update('$pushAll', args)
-      end
-
-      def push_uniq(*args)
-        criteria, keys = criteria_and_keys_from_args(args)
-        keys.each { |key, value | criteria[key] = {'$ne' => value} }
-        collection.update(criteria, {'$push' => keys}, :multi => true)
-      end
-
-      def pull(*args)
-        modifier_update('$pull', args)
-      end
-
-      def pull_all(*args)
-        modifier_update('$pullAll', args)
-      end
-
-      def pop(*args)
-        modifier_update('$pop', args)
-      end
-
       def embeddable?
         false
       end
@@ -200,7 +162,7 @@ module MongoMapper
       def set_database_name(name)
         @database_name = name
       end
-      
+
       def database_name
         @database_name
       end
@@ -225,19 +187,6 @@ module MongoMapper
         database.collection(collection_name)
       end
 
-      def timestamps!
-        key :created_at, Time
-        key :updated_at, Time
-        class_eval { before_save :update_timestamps }
-      end
-
-      def userstamps!
-        key :creator_id, ObjectId
-        key :updater_id, ObjectId
-        belongs_to :creator, :class_name => 'User'
-        belongs_to :updater, :class_name => 'User'
-      end
-
       def single_collection_inherited?
         keys.key?(:_type) && single_collection_inherited_superclass?
       end
@@ -258,18 +207,6 @@ module MongoMapper
           instances.size == 1 ? instances[0] : instances
         end
 
-        def modifier_update(modifier, args)
-          criteria, keys = criteria_and_keys_from_args(args)
-          modifiers = {modifier => keys}
-          collection.update(criteria, modifiers, :multi => true)
-        end
-
-        def criteria_and_keys_from_args(args)
-          keys     = args.pop
-          criteria = args[0].is_a?(Hash) ? args[0] : {:id => args}
-          [to_criteria(criteria), keys]
-        end
-
         def assert_no_first_last_or_all(args)
           if args[0] == :first || args[0] == :last || args[0] == :all
             raise ArgumentError, "#{self}.find(:#{args}) is no longer supported, use #{self}.#{args} instead."
@@ -374,9 +311,14 @@ module MongoMapper
       end
 
       def delete
+        @_destroyed = true
         self.class.delete(id) unless new?
       end
 
+      def destroyed?
+        @_destroyed == true
+      end
+
       def reload
         if attrs = collection.find_one({:_id => _id})
           self.class.associations.each { |name, assoc| send(name).reset if respond_to?(name) }
@@ -387,6 +329,12 @@ module MongoMapper
         end
       end
 
+      # Used by embedded docs to find root easily without if/respond_to? stuff.
+      # Documents are always root documents.
+      def _root_document
+        self
+      end
+
     private
       def create_or_update(options={})
         result = new? ? create(options) : update(options)
@@ -406,12 +354,6 @@ module MongoMapper
         @new = false
         collection.save(to_mongo, :safe => safe)
       end
-
-      def update_timestamps
-        now = Time.now.utc
-        self[:created_at] = now if new? && !created_at?
-        self[:updated_at] = now
-      end
     end
   end # Document
 end # MongoMapper

data/lib/mongo_mapper/embedded_document.rb

@@ -19,8 +19,9 @@ module MongoMapper
         plugin Plugins::Rails
         plugin Plugins::Serialization
         plugin Plugins::Validations
+        plugin Plugins::Callbacks
 
-        attr_accessor :_root_document, :_parent_document
+        attr_reader :_root_document, :_parent_document
       end
 
       super
@@ -50,6 +51,11 @@ module MongoMapper
         end
         result
       end
+      
+      def _parent_document=(value)
+        @_root_document   = value._root_document
+        @_parent_document = value
+      end
     end # InstanceMethods
   end # EmbeddedDocument
 end # MongoMapper

data/lib/mongo_mapper/plugins.rb

@@ -20,9 +20,12 @@ module MongoMapper
     autoload :Inspect,        'mongo_mapper/plugins/inspect'
     autoload :Keys,           'mongo_mapper/plugins/keys'
     autoload :Logger,         'mongo_mapper/plugins/logger'
+    autoload :Modifiers,      'mongo_mapper/plugins/modifiers'
     autoload :Protected,      'mongo_mapper/plugins/protected'
     autoload :Rails,          'mongo_mapper/plugins/rails'
     autoload :Serialization,  'mongo_mapper/plugins/serialization'
+    autoload :Timestamps,     'mongo_mapper/plugins/timestamps'
+    autoload :Userstamps,     'mongo_mapper/plugins/userstamps'
     autoload :Validations,    'mongo_mapper/plugins/validations'
   end
 end

data/lib/mongo_mapper/plugins/associations/embedded_collection.rb

@@ -30,19 +30,8 @@ module MongoMapper
         alias_method :concat, :<<
 
         private
-          def _root_document
-            if owner.respond_to?(:_root_document)
-              owner._root_document
-            else
-              owner
-            end
-          end
-
           def assign_references(*docs)
-            docs.each do |doc|
-              doc._root_document = _root_document
-              doc._parent_document = owner
-            end
+            docs.each { |doc| doc._parent_document = owner }
           end
       end
     end

data/lib/mongo_mapper/plugins/associations/in_array_proxy.rb

@@ -79,6 +79,7 @@ module MongoMapper
           unless doc.new?
             ids << doc.id
             owner.save
+            reset
           end
           doc
         end
@@ -88,6 +89,7 @@ module MongoMapper
           unless doc.new?
             ids << doc.id
             owner.save
+            reset
           end
           doc
         end
@@ -123,7 +125,10 @@ module MongoMapper
           end
 
           def scoped_ids(args)
-            args.flatten.reject { |id| !ids.include?(id) }
+            args.flatten.select do |id|
+              id = ObjectId.to_mongo(id) if klass.using_object_id?
+              ids.include?(id)
+            end
           end
 
           def find_target

data/lib/mongo_mapper/plugins/associations/many_documents_proxy.rb

@@ -52,18 +52,21 @@ module MongoMapper
         def build(attrs={})
           doc = klass.new(attrs)
           apply_scope(doc)
+          reset
           doc
         end
 
         def create(attrs={})
           doc = klass.new(attrs)
           apply_scope(doc).save
+          reset
           doc
         end
 
         def create!(attrs={})
           doc = klass.new(attrs)
           apply_scope(doc).save!
+          reset
           doc
         end
 
@@ -109,7 +112,7 @@ module MongoMapper
           end
 
           def foreign_key
-            options[:foreign_key] || owner.class.name.underscore.gsub("/", "_") + "_id"
+            options[:foreign_key] || owner.class.name.to_s.underscore.gsub("/", "_") + "_id"
           end
       end
     end

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -1,35 +1,74 @@
+# Almost all of this callback stuff is pulled directly from ActiveSupport
+# in the interest of support rails 2 and 3 at the same time and is the
+# same copyright as rails.
 module MongoMapper
   module Plugins
     module Callbacks
       def self.configure(model)
         model.class_eval do
-          include ActiveSupport::Callbacks
-
           define_callbacks(
-            :before_save, :after_save, 
-            :before_create, :after_create, 
-            :before_update, :after_update, 
-            :before_validation, :after_validation, 
-            :before_validation_on_create, :after_validation_on_create, 
-            :before_validation_on_update, :after_validation_on_update, 
-            :before_destroy, :after_destroy
+            :before_save,                 :after_save,
+            :before_create,               :after_create,
+            :before_update,               :after_update,
+            :before_validation,           :after_validation,
+            :before_validation_on_create, :after_validation_on_create,
+            :before_validation_on_update, :after_validation_on_update,
+            :before_destroy,              :after_destroy,
+            :validate_on_create,          :validate_on_update,
+            :validate
           )
         end
       end
-      
+
+      module ClassMethods
+        def define_callbacks(*callbacks)
+          callbacks.each do |callback|
+            class_eval <<-"end_eval"
+              def self.#{callback}(*methods, &block)
+                callbacks = CallbackChain.build(:#{callback}, *methods, &block)
+                @#{callback}_callbacks ||= CallbackChain.new
+                @#{callback}_callbacks.concat callbacks
+              end
+
+              def self.#{callback}_callback_chain
+                @#{callback}_callbacks ||= CallbackChain.new
+
+                if superclass.respond_to?(:#{callback}_callback_chain)
+                  CallbackChain.new(
+                    superclass.#{callback}_callback_chain +
+                    @#{callback}_callbacks
+                  )
+                else
+                  @#{callback}_callbacks
+                end
+              end
+            end_eval
+          end
+        end
+      end
+
       module InstanceMethods
         def valid?
           action = new? ? 'create' : 'update'
-
           run_callbacks(:before_validation)
           run_callbacks("before_validation_on_#{action}".to_sym)
           result = super
           run_callbacks("after_validation_on_#{action}".to_sym)
           run_callbacks(:after_validation)
-
           result
         end
 
+        # Overriding validatable's valid_for_group? to integrate validation callbacks
+        def valid_for_group?(group) #:nodoc:
+          errors.clear
+          run_before_validations
+          run_callbacks(:validate)
+          new? ? run_callbacks(:validate_on_create) : run_callbacks(:validate_on_update)
+          self.class.validate_children(self, group)
+          self.validate_group(group)
+          errors.empty?
+        end
+
         def destroy
           run_callbacks(:before_destroy)
           result = super
@@ -37,6 +76,17 @@ module MongoMapper
           result
         end
 
+        def run_callbacks(kind, options = {}, &block)
+          callback_chain_method = "#{kind}_callback_chain"
+          return unless self.class.respond_to?(callback_chain_method)
+          self.class.send(callback_chain_method).run(self, options, &block)
+          self.embedded_associations.each do |association|
+            self.send(association.name).each do |document|
+              document.run_callbacks(kind, options, &block)
+            end
+          end
+        end
+
         private
           def create_or_update(*args)
             run_callbacks(:before_save)
@@ -60,6 +110,127 @@ module MongoMapper
             result
           end
       end
+
+      class CallbackChain < Array
+        def self.build(kind, *methods, &block)
+          methods, options = extract_options(*methods, &block)
+          methods.map! { |method| Callback.new(kind, method, options) }
+          new(methods)
+        end
+
+        def run(object, options = {}, &terminator)
+          enumerator = options[:enumerator] || :each
+
+          unless block_given?
+            send(enumerator) { |callback| callback.call(object) }
+          else
+            send(enumerator) do |callback|
+              result = callback.call(object)
+              break result if terminator.call(result, object)
+            end
+          end
+        end
+
+        # TODO: Decompose into more Array like behavior
+        def replace_or_append!(chain)
+          if index = index(chain)
+            self[index] = chain
+          else
+            self << chain
+          end
+          self
+        end
+
+        def find(callback, &block)
+          select { |c| c == callback && (!block_given? || yield(c)) }.first
+        end
+
+        def delete(callback)
+          super(callback.is_a?(Callback) ? callback : find(callback))
+        end
+
+        private
+          def self.extract_options(*methods, &block)
+            methods.flatten!
+            options = methods.extract_options!
+            methods << block if block_given?
+            return methods, options
+          end
+
+          def extract_options(*methods, &block)
+            self.class.extract_options(*methods, &block)
+          end
+      end
+
+      class Callback
+        attr_reader :kind, :method, :identifier, :options
+
+        def initialize(kind, method, options = {})
+          @kind       = kind
+          @method     = method
+          @identifier = options[:identifier]
+          @options    = options
+        end
+
+        def ==(other)
+          case other
+          when Callback
+            (self.identifier && self.identifier == other.identifier) || self.method == other.method
+          else
+            (self.identifier && self.identifier == other) || self.method == other
+          end
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def dup
+          self.class.new(@kind, @method, @options.dup)
+        end
+
+        def hash
+          if @identifier
+            @identifier.hash
+          else
+            @method.hash
+          end
+        end
+
+        def call(*args, &block)
+          evaluate_method(method, *args, &block) if should_run_callback?(*args)
+        rescue LocalJumpError
+          raise ArgumentError,
+            "Cannot yield from a Proc type filter. The Proc must take two " +
+            "arguments and execute #call on the second argument."
+        end
+
+        private
+          def evaluate_method(method, *args, &block)
+            case method
+              when Symbol
+                object = args.shift
+                object.send(method, *args, &block)
+              when String
+                eval(method, args.first.instance_eval { binding })
+              when Proc, Method
+                method.call(*args, &block)
+              else
+                if method.respond_to?(kind)
+                  method.send(kind, *args, &block)
+                else
+                  raise ArgumentError,
+                    "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
+                    "a block to be invoked, or an object responding to the callback method."
+                end
+            end
+          end
+
+          def should_run_callback?(*args)
+            [options[:if]].flatten.compact.all? { |a| evaluate_method(a, *args) } &&
+            ![options[:unless]].flatten.compact.any? { |a| evaluate_method(a, *args) }
+          end
+      end
     end
   end
 end