mongo_mapper 0.6.10 → 0.7.0

data/README.rdoc

@@ -13,25 +13,16 @@ Releases are tagged on github and released on gemcutter. Master is pushed to whe
 * Send me a pull request. Bonus points for topic branches.
 
 == Install
- 
- $ gem install mongo_mapper
-
-== Dependencies
-
-* ActiveSupport (typically the latest version)
-* Mongo Ruby Driver (mongo)
-* My fork of the validatable gem (jnunemaker-validatable)
 
-== Documentation
+ $ gem install mongo_mapper
 
-Documentation is lacking right now because if you can't look through the code right now and feel comfortable, this is probably too young for you to use. Wait til it stabilizes a bit more.
+== Problems or Questions?
 
+Hit up the google group.
 http://groups.google.com/group/mongomapper
 
-== More Info
-
-* http://www.mongodb.org/
-* http://github.com/mongodb/mongo-ruby-driver/
+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
 
 == Copyright
 

data/Rakefile

@@ -12,7 +12,7 @@ Jeweler::Tasks.new do |gem|
   gem.authors     = ["John Nunemaker"]
   
   gem.add_dependency('activesupport', '>= 2.3')
-  gem.add_dependency('mongo', '0.18.2')
+  gem.add_dependency('mongo', '0.18.3')
   gem.add_dependency('jnunemaker-validatable', '1.8.1')
   
   gem.add_development_dependency('jnunemaker-matchy', '0.4.0')

data/VERSION

@@ -1 +1 @@
-0.6.10
+0.7.0

data/lib/mongo_mapper.rb

@@ -1,10 +1,12 @@
+require 'set'
+
 # 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
 # so i want to make sure that if you are using gems you do in fact have the correct versions
 # 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.2'
+  gem 'mongo', '0.18.3'
   gem 'jnunemaker-validatable', '1.8.1'
 end
 
@@ -15,112 +17,102 @@ require 'validatable'
 module MongoMapper
   # generic MM error
   class MongoMapperError < StandardError; end
-  
+
   # raised when key expected to exist but not found
   class KeyNotFound < MongoMapperError; end
-  
+
   # raised when document expected but not found
   class DocumentNotFound < MongoMapperError; end
-  
+
   # raised when document not valid and using !
   class DocumentNotValid < MongoMapperError
     def initialize(document)
       super("Validation failed: #{document.errors.full_messages.join(", ")}")
     end
   end
-  
+
   # @api public
   def self.connection
     @@connection ||= Mongo::Connection.new
   end
-  
+
   # @api public
   def self.connection=(new_connection)
     @@connection = new_connection
   end
-  
+
   # @api public
   def self.logger
     connection.logger
   end
-  
+
   # @api public
   def self.database=(name)
     @@database = nil
     @@database_name = name
   end
-  
+
   # @api public
   def self.database
     if @@database_name.blank?
       raise 'You forgot to set the default database name: MongoMapper.database = "foobar"'
     end
-    
+
     @@database ||= MongoMapper.connection.db(@@database_name)
   end
-  
-  # @api private
-  def self.ensured_indexes
-    @@ensured_indexes ||= []
+
+  def self.config=(hash)
+    @@config = hash
   end
-  
-  # @api private
-  def self.ensured_indexes=(value)
-    @@ensured_indexes = value
+
+  def self.config
+    raise 'Set config before connecting. MongoMapper.config = {...}' unless defined?(@@config)
+    @@config
   end
-  
-  # @api private
-  def self.ensure_index(klass, keys, options={})
-    ensured_indexes << {:klass => klass, :keys => keys, :options => options}
+
+  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
   end
-  
-  # @api public
-  def self.ensure_indexes!
-    ensured_indexes.each do |index|
-      unique = index[:options].delete(:unique)
-      index[:klass].collection.create_index(index[:keys], unique)
+
+  def self.setup(config, environment, options={})
+    using_passenger = options.delete(:passenger)
+    handle_passenger_forking if using_passenger
+    self.config = config
+    connect(environment, options)
+  end
+
+  def self.handle_passenger_forking
+    if defined?(PhusionPassenger)
+      PhusionPassenger.on_event(:starting_worker_process) do |forked|
+        connection.connect_to_master if forked
+      end
     end
   end
-  
+
   # @api private
   def self.use_time_zone?
     Time.respond_to?(:zone) && Time.zone ? true : false
   end
-  
+
   # @api private
   def self.time_class
     use_time_zone? ? Time.zone : Time
   end
-  
+
   # @api private
   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'
 end
 
 require 'mongo_mapper/support'
-require 'mongo_mapper/callbacks'
-require 'mongo_mapper/finder_options'
-require 'mongo_mapper/dirty'
-require 'mongo_mapper/dynamic_finder'
-require 'mongo_mapper/key'
-require 'mongo_mapper/pagination'
-require 'mongo_mapper/serialization'
-require 'mongo_mapper/validations'
-require 'mongo_mapper/rails_compatibility/document'
-require 'mongo_mapper/rails_compatibility/embedded_document'
-require 'mongo_mapper/embedded_document'
-require 'mongo_mapper/document'
-require 'mongo_mapper/associations'
-require 'mongo_mapper/associations/base'
-require 'mongo_mapper/associations/proxy'
-require 'mongo_mapper/associations/collection'
-require 'mongo_mapper/associations/many_documents_proxy'
-require 'mongo_mapper/associations/belongs_to_proxy'
-require 'mongo_mapper/associations/belongs_to_polymorphic_proxy'
-require 'mongo_mapper/associations/many_polymorphic_proxy'
-require 'mongo_mapper/associations/many_embedded_proxy'
-require 'mongo_mapper/associations/many_embedded_polymorphic_proxy'
-require 'mongo_mapper/associations/many_documents_as_proxy'
-require 'mongo_mapper/associations/one_proxy'
-require 'mongo_mapper/associations/in_array_proxy'
+require 'mongo_mapper/plugins'

data/lib/mongo_mapper/document.rb

@@ -1,66 +1,39 @@
-require 'set'
-
 module MongoMapper
   module Document
+    extend Support::DescendantAppends
+
     def self.included(model)
       model.class_eval do
-        include EmbeddedDocument
         include InstanceMethods
-        include Callbacks
-        include Dirty
-        include RailsCompatibility::Document
-        extend Validations::Macros
-        extend ClassMethods
-        extend Finders
-
-        def self.per_page
-          25
-        end unless respond_to?(:per_page)
-      end
-
-      extra_extensions.each { |extension| model.extend(extension) }
-      extra_inclusions.each { |inclusion| model.send(:include, inclusion) }
-
-      descendants << model
-    end
-
-    def self.descendants
-      @descendants ||= Set.new
-    end
-
-    def self.append_extensions(*extensions)
-      extra_extensions.concat extensions
-
-      # Add the extension to existing descendants
-      descendants.each do |model|
-        extensions.each { |extension| model.extend(extension) }
-      end
+        extend  Support::Find
+        extend  ClassMethods
+        extend  Plugins
+
+        plugin Plugins::Associations
+        plugin Plugins::Clone
+        plugin Plugins::Descendants
+        plugin Plugins::Equality
+        plugin Plugins::Inspect
+        plugin Plugins::Keys
+        plugin Plugins::Dirty # for now dirty needs to be after keys
+        plugin Plugins::Logger
+        plugin Plugins::Pagination
+        plugin Plugins::Protected
+        plugin Plugins::Rails
+        plugin Plugins::Serialization
+        plugin Plugins::Validations
+        plugin Plugins::Callbacks # for now callbacks needs to be after validations
+        
+        extend Plugins::Validations::DocumentMacros
+      end
+
+      super
     end
 
-    # @api private
-    def self.extra_extensions
-      @extra_extensions ||= []
-    end
-
-    def self.append_inclusions(*inclusions)
-      extra_inclusions.concat inclusions
-
-      # Add the inclusion to existing descendants
-      descendants.each do |model|
-        inclusions.each { |inclusion| model.send :include, inclusion }
-      end
-    end
-
-    # @api private
-    def self.extra_inclusions
-      @extra_inclusions ||= []
-    end
-    
     module ClassMethods
-      def key(*args)
-        key = super
-        create_indexes_for(key)
-        key
+      def inherited(subclass)
+        subclass.set_collection_name(collection_name)
+        super
       end
 
       def ensure_index(name_or_array, options={})
@@ -70,43 +43,50 @@ module MongoMapper
           name_or_array
         end
 
-        MongoMapper.ensure_index(self, keys_to_index, options)
+        collection.create_index(keys_to_index, options[:unique])
+      end
+
+      def find(*args)
+        assert_no_first_last_or_all(args)
+        options = args.extract_options!
+        return nil if args.size == 0
+
+        if args.first.is_a?(Array) || args.size > 1
+          find_some(args, options)
+        else
+          find_one(options.merge({:_id => args[0]}))
+        end
       end
 
       def find!(*args)
+        assert_no_first_last_or_all(args)
         options = args.extract_options!
-        case args.first
-          when :first then first(options)
-          when :last  then last(options)
-          when :all   then find_every(options)
-          when Array  then find_some(args, options)
-          else
-            case args.size
-              when 0
-                raise DocumentNotFound, "Couldn't find without an ID"
-              when 1
-                find_one!(options.merge({:_id => args[0]}))
-              else
-                find_some(args, options)
-            end
+        raise DocumentNotFound, "Couldn't find without an ID" if args.size == 0
+
+        if args.first.is_a?(Array) || args.size > 1
+          find_some!(args, options)
+        else
+          find_one(options.merge({:_id => args[0]})) || raise(DocumentNotFound, "Document match #{options.inspect} does not exist in #{collection.name} collection")
         end
       end
-      
-      def find(*args)
-        find!(*args)
-      rescue DocumentNotFound
-        nil
+
+      def find_each(options={})
+        criteria, options = to_query(options)
+        collection.find(criteria, options).each do |doc|
+          yield load(doc)
+        end
       end
 
-      def paginate(options)
-        per_page      = options.delete(:per_page) || self.per_page
-        page          = options.delete(:page)
-        total_entries = count(options)
-        pagination    = Pagination::PaginationProxy.new(total_entries, page, per_page)
+      def find_by_id(id)
+        find(id)
+      end
 
-        options.merge!(:limit => pagination.limit, :skip => pagination.skip)
-        pagination.subject = find_every(options)
-        pagination
+      def first_or_create(arg)
+        first(arg) || create(arg)
+      end
+
+      def first_or_new(arg)
+        first(arg) || new(arg)
       end
 
       def first(options={})
@@ -119,11 +99,7 @@ module MongoMapper
       end
 
       def all(options={})
-        find_every(options)
-      end
-
-      def find_by_id(id)
-        find(id)
+        find_many(options)
       end
 
       def count(options={})
@@ -160,63 +136,57 @@ module MongoMapper
       end
 
       def destroy(*ids)
-        find_some(ids.flatten).each(&:destroy)
+        find_some!(ids.flatten).each(&:destroy)
       end
 
       def destroy_all(options={})
-        all(options).each(&:destroy)
+        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 modifier_update(modifier, args)
-        criteria, keys = criteria_and_keys_from_args(args)
-        modifiers = {modifier => keys}
-        collection.update(criteria, modifiers, :multi => true)
+
+      def pop(*args)
+        modifier_update('$pop', args)
       end
-      private :modifier_update
-      
-      def criteria_and_keys_from_args(args)
-        keys     = args.pop
-        criteria = args[0].is_a?(Hash) ? args[0] : {:id => args}
-        [to_criteria(criteria), keys]
+
+      def embeddable?
+        false
       end
-      private :criteria_and_keys_from_args
 
       def connection(mongo_connection=nil)
         if mongo_connection.nil?
@@ -269,39 +239,51 @@ module MongoMapper
       end
 
       def single_collection_inherited?
-        keys.has_key?('_type') && single_collection_inherited_superclass?
+        keys.key?(:_type) && single_collection_inherited_superclass?
       end
 
       def single_collection_inherited_superclass?
-        superclass.respond_to?(:keys) && superclass.keys.has_key?('_type')
+        superclass.respond_to?(:keys) && superclass.keys.key?(:_type)
       end
 
       private
-        def create_indexes_for(key)
-          ensure_index key.name if key.options[:index]
-        end
-
         def initialize_each(*docs)
           instances = []
           docs = [{}] if docs.blank?
           docs.flatten.each do |attrs|
-            doc = initialize_doc(attrs)
+            doc = new(attrs)
             yield(doc)
             instances << doc
           end
           instances.size == 1 ? instances[0] : instances
         end
 
-        def find_every(options)
-          criteria, options = to_finder_options(options)
-          collection.find(criteria, options).to_a.map do |doc|
-            initialize_doc(doc)
+        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."
           end
         end
 
         def find_some(ids, options={})
-          ids       = ids.flatten.compact.uniq
-          documents = find_every(options.merge(:_id => ids))
+          ids = ids.flatten.compact.uniq
+          find_many(options.merge(:_id => ids)).compact
+        end
+
+        def find_some!(ids, options={})
+          ids = ids.flatten.compact.uniq
+          documents = find_some(ids, options)
 
           if ids.size == documents.size
             documents
@@ -310,15 +292,20 @@ module MongoMapper
           end
         end
 
+        # All query methods that load documents pass through find_one or find_many
         def find_one(options={})
-          criteria, options = to_finder_options(options)
+          criteria, options = to_query(options)
           if doc = collection.find_one(criteria, options)
-            initialize_doc(doc)
+            load(doc)
           end
         end
 
-        def find_one!(options={})
-          find_one(options) || raise(DocumentNotFound, "Document match #{options.inspect} does not exist in #{collection.name} collection")
+        # All query methods that load documents pass through find_one or find_many
+        def find_many(options)
+          criteria, options = to_query(options)
+          collection.find(criteria, options).to_a.map do |doc|
+            load(doc)
+          end
         end
 
         def invert_order_clause(order)
@@ -354,11 +341,11 @@ module MongoMapper
         end
 
         def to_criteria(options={})
-          FinderOptions.new(self, options).criteria
+          Query.new(self, options).criteria
         end
 
-        def to_finder_options(options={})
-          FinderOptions.new(self, options).to_a
+        def to_query(options={})
+          Query.new(self, options).to_a
         end
     end
 
@@ -366,42 +353,38 @@ module MongoMapper
       def collection
         self.class.collection
       end
-      
+
       def database
         self.class.database
       end
 
-      def new?
-        read_attribute('_id').blank? || using_custom_id?
-      end
-
       def save(options={})
-        if options === false
-          ActiveSupport::Deprecation.warn "save with true/false is deprecated. You should now use :validate => true/false."
-          options = {:validate => false}
-        end
+        options.assert_valid_keys(:validate, :safe)
         options.reverse_merge!(:validate => true)
-        perform_validations = options.delete(:validate)
-        !perform_validations || valid? ? create_or_update(options) : false
+        !options[:validate] || valid? ? create_or_update(options) : false
       end
 
-      def save!
-        save || raise(DocumentNotValid.new(self))
+      def save!(options={})
+        options.assert_valid_keys(:safe)
+        save(options) || raise(DocumentNotValid.new(self))
       end
 
       def destroy
-        self.class.delete(id) unless new?
+        delete
       end
-      
+
       def delete
         self.class.delete(id) unless new?
       end
 
       def reload
-        doc = self.class.find(_id)
-        self.class.associations.each { |name, assoc| send(name).reset if respond_to?(name) }
-        self.attributes = doc.attributes
-        self
+        if attrs = collection.find_one({:_id => _id})
+          self.class.associations.each { |name, assoc| send(name).reset if respond_to?(name) }
+          self.attributes = attrs
+          self
+        else
+          raise DocumentNotFound, "Document match #{_id.inspect} does not exist in #{collection.name} collection"
+        end
       end
 
     private
@@ -411,34 +394,23 @@ module MongoMapper
       end
 
       def create(options={})
-        assign_id
         save_to_collection(options)
       end
 
-      def assign_id
-        if read_attribute(:_id).blank?
-          write_attribute :_id, Mongo::ObjectID.new
-        end
-      end
-
       def update(options={})
         save_to_collection(options)
       end
 
       def save_to_collection(options={})
-        clear_custom_id_flag
-        safe = options.delete(:safe) || false
+        safe = options[:safe] || false
+        @new = false
         collection.save(to_mongo, :safe => safe)
       end
 
       def update_timestamps
         now = Time.now.utc
-        write_attribute('created_at', now) if new? && read_attribute('created_at').blank?
-        write_attribute('updated_at', now)
-      end
-
-      def clear_custom_id_flag
-        @using_custom_id = nil
+        self[:created_at] = now if new? && !created_at?
+        self[:updated_at] = now
       end
     end
   end # Document