jnunemaker-mongomapper 0.3.2 → 0.3.3

data/History

@@ -1,3 +1,13 @@
+0.3.3 8/16/2009
+  * BACKWORDS COMPATIBILITY BREAK: _id is now once again a string rather than an object id and will stay that way.
+  * Custom id's can now be used because of the change to string id's
+  * Added dynamic finders to document. (dcu)
+  * Added destroy_all, delete_all and nullify for many document association
+  * Added :dependent option for many documents assocation (dcu)
+  * update_attributes now returns true or false instead of the document. (Durran Jordan and me)
+  * Keys no longer require a type
+  * Keys can now be added on the fly using []=
+  
 0.3.2 8/6/2009
   * Added many polymorphic documents association
   * Implemented build and create for many and many polymorphic documents

data/Rakefile

@@ -12,14 +12,16 @@ begin
     gem.rubyforge_project = "mongomapper"
     
     gem.add_dependency('activesupport')
-    gem.add_dependency('mongodb-mongo', '0.10.1')
+    gem.add_dependency('mongodb-mongo', '0.11.1')
     gem.add_dependency('jnunemaker-validatable', '1.7.2')
     
     gem.add_development_dependency('mocha', '0.9.4')
     gem.add_development_dependency('jnunemaker-matchy', '0.4.0')
   end
-
-  Jeweler::RubyforgeTasks.new
+  
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.3.3

data/lib/mongomapper/associations/belongs_to_polymorphic_proxy.rb

@@ -14,7 +14,9 @@ module MongoMapper
       
       protected
         def find_target
-          proxy_class.find(proxy_id) if proxy_id && proxy_class
+          if proxy_id && proxy_class
+            proxy_class.find_by_id(proxy_id)
+          end
         end
         
         def proxy_id

data/lib/mongomapper/associations/belongs_to_proxy.rb

@@ -6,7 +6,7 @@ module MongoMapper
           doc.save if doc.new?
           id = doc.id
         end
-        
+
         @owner.send("#{@association.belongs_to_key_name}=", id)
         reset
       end
@@ -14,7 +14,7 @@ module MongoMapper
       protected
         def find_target
           if association_id = @owner.send(@association.belongs_to_key_name)
-            @association.klass.find(association_id)
+            @association.klass.find_by_id(association_id)
           end
         end
     end

data/lib/mongomapper/associations/many_documents_proxy.rb

@@ -2,38 +2,38 @@ module MongoMapper
   module Associations
     class ManyDocumentsProxy < Proxy
       delegate :klass, :to => :@association
-      
+
       def find(*args)
         options = args.extract_options!
         klass.find(*args << scoped_options(options))
       end
-      
+
       def paginate(options)
         klass.paginate(scoped_options(options))
       end
-      
+
       def all(options={})
         find(:all, scoped_options(options))
       end
-      
+
       def first(options={})
         find(:first, scoped_options(options))
       end
-      
+
       def last(options={})
         find(:last, scoped_options(options))
       end
-      
+
       def count(conditions={})
         klass.count(conditions.deep_merge(scoped_conditions))
       end
-      
+
       def replace(docs)
         @target.map(&:destroy) if load_target
         docs.each { |doc| apply_scope(doc).save }
         reset
       end
-      
+
       def <<(*docs)
         ensure_owner_saved
         flatten_deeper(docs).each { |doc| apply_scope(doc).save }
@@ -41,36 +41,54 @@ module MongoMapper
       end
       alias_method :push, :<<
       alias_method :concat, :<<
-      
+
       def build(attrs={})
         doc = klass.new(attrs)
         apply_scope(doc)
         doc
       end
-      
+
       def create(attrs={})
         doc = klass.new(attrs)
         apply_scope(doc).save
         doc
       end
+
+      def destroy_all(conditions={})
+        all(:conditions => conditions).map(&:destroy)
+        reset
+      end
+
+      def delete_all(conditions={})
+        klass.delete_all(conditions.deep_merge(scoped_conditions))
+        reset
+      end
       
+      def nullify
+        criteria = FinderOptions.to_mongo_criteria(scoped_conditions)
+        all(criteria).each do |doc|
+          doc.update_attributes self.foreign_key => nil
+        end
+        reset
+      end
+
       protected
         def scoped_conditions
           {self.foreign_key => @owner.id}
         end
-        
+
         def scoped_options(options)
           options.deep_merge({:conditions => scoped_conditions})
         end
-        
+
         def find_target
           find(:all)
         end
-        
+
         def ensure_owner_saved
           @owner.save if @owner.new?
         end
-        
+
         def apply_scope(doc)
           ensure_owner_saved
           doc.send("#{self.foreign_key}=", @owner.id)

data/lib/mongomapper/associations/proxy.rb

@@ -1,12 +1,8 @@
 module MongoMapper
   module Associations
-    class Proxy
+    class Proxy < BasicObject
       attr_reader :owner, :association
-
-      instance_methods.each do |m|
-        undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/
-      end
-
+      
       def initialize(owner, association)
         @owner = owner
         @association = association

data/lib/mongomapper/associations.rb

@@ -2,12 +2,12 @@ module MongoMapper
   module Associations
     module ClassMethods
       def belongs_to(association_id, options = {})
-        create_association(:belongs_to, association_id, options)        
+        create_association(:belongs_to, association_id, options)
         self
       end
 
       def many(association_id, options = {})
-        create_association(:many, association_id, options)        
+        create_association(:many, association_id, options)
         self
       end
 
@@ -21,39 +21,74 @@ module MongoMapper
           associations[association.name] = association
           define_association_methods(association)
           define_association_keys(association)
+          define_dependent_callback(association)
           association
         end
-        
+
         def define_association_methods(association)
           define_method(association.name) do
             get_proxy(association)
           end
-          
+
           define_method("#{association.name}=") do |value|
             get_proxy(association).replace(value)
             value
           end
         end
-        
+
         def define_association_keys(association)
           if association.belongs_to?
             key(association.belongs_to_key_name, String)
-            key(association.type_key_name, String) if association.polymorphic?            
+            key(association.type_key_name, String) if association.polymorphic?
           end
-          
+
           if association.many? && association.polymorphic?
             association.klass.send(:key, association.type_key_name, String)
           end
         end
+
+        def define_dependent_callback(association)
+          if association.options[:dependent]
+            if association.many?
+              define_dependent_callback_for_many(association)
+            elsif association.belongs_to?
+              define_dependent_callback_for_belongs_to(association)
+            end
+          end
+        end
+
+        def define_dependent_callback_for_many(association)
+          return if association.embeddable?
+
+          after_destroy do |doc|
+            case association.options[:dependent]
+            when :destroy
+              doc.get_proxy(association).destroy_all
+            when :delete_all
+              doc.get_proxy(association).delete_all
+            when :nullify
+              doc.get_proxy(association).nullify
+            end
+          end
+        end
+
+        def define_dependent_callback_for_belongs_to(association)
+          after_destroy do |doc|
+            case association.options[:dependent]
+            when :destroy
+              doc.get_proxy(association).destroy
+            end
+          end
+        end
     end
 
     module InstanceMethods
       def get_proxy(association)
         unless proxy = self.instance_variable_get(association.ivar)
           proxy = association.proxy_class.new(self, association)
-          self.instance_variable_set(association.ivar, proxy)
+          self.instance_variable_set(association.ivar, proxy) if !frozen?
         end
-        
+
         proxy
       end
     end

data/lib/mongomapper/document.rb

@@ -11,18 +11,18 @@ module MongoMapper
         include SaveWithValidation
         include RailsCompatibility::Document
         extend ClassMethods
-        
+
         key :created_at, Time
         key :updated_at, Time
       end
-      
+
       descendants << model
     end
 
     def self.descendants
       @descendants ||= Set.new
     end
-    
+
     module ClassMethods
       def find(*args)
         options = args.extract_options!
@@ -35,16 +35,15 @@ module MongoMapper
         end
       end
 
-      def paginate(options)        
+      def paginate(options)
         per_page      = options.delete(:per_page)
         page          = options.delete(:page)
         total_entries = count(options[:conditions] || {})
-        
-        collection = Pagination::PaginationProxy.new(total_entries, page, per_page)
-        
-        options[:limit] = collection.limit
+        collection    = Pagination::PaginationProxy.new(total_entries, page, per_page)
+
+        options[:limit]   = collection.limit
         options[:offset]  = collection.offset
-        
+
         collection.subject = find_every(options)
         collection
       end
@@ -67,11 +66,11 @@ module MongoMapper
           new(doc)
         end
       end
-      
+
       def count(conditions={})
         collection.count(FinderOptions.to_mongo_criteria(conditions))
       end
-      
+
       def create(*docs)
         instances = []
         docs = [{}] if docs.blank?
@@ -81,7 +80,7 @@ module MongoMapper
         end
         instances.size == 1 ? instances[0] : instances
       end
-      
+
       # For updating single document
       #   Person.update(1, {:foo => 'bar'})
       #
@@ -96,25 +95,25 @@ module MongoMapper
           update_single(id, attributes)
         end
       end
-      
+
       def delete(*ids)
         criteria = FinderOptions.to_mongo_criteria(:_id => ids.flatten)
         collection.remove(criteria)
       end
-      
+
       def delete_all(conditions={})
         criteria = FinderOptions.to_mongo_criteria(conditions)
         collection.remove(criteria)
       end
-      
+
       def destroy(*ids)
         find_some(ids.flatten).each(&:destroy)
       end
-      
+
       def destroy_all(conditions={})
         find(:all, :conditions => conditions).each(&:destroy)
       end
-      
+
       def connection(mongo_connection=nil)
         if mongo_connection.nil?
           @connection ||= MongoMapper.connection
@@ -123,7 +122,7 @@ module MongoMapper
         end
         @connection
       end
-      
+
       def database(name=nil)
         if name.nil?
           @database ||= MongoMapper.database
@@ -132,7 +131,7 @@ module MongoMapper
         end
         @database
       end
-      
+
       def collection(name=nil)
         if name.nil?
           @collection ||= database.collection(self.to_s.demodulize.tableize)
@@ -141,96 +140,137 @@ module MongoMapper
         end
         @collection
       end
-      
+
       def validates_uniqueness_of(*args)
         add_validations(args, MongoMapper::Validations::ValidatesUniquenessOf)
       end
-      
+
       def validates_exclusion_of(*args)
         add_validations(args, MongoMapper::Validations::ValidatesExclusionOf)
       end
-      
+
       def validates_inclusion_of(*args)
         add_validations(args, MongoMapper::Validations::ValidatesInclusionOf)
       end
       
-    private
-      def find_every(options)
-        criteria, options = FinderOptions.new(options).to_a        
-        collection.find(criteria, options).to_a.map { |doc| new(doc) }
-      end
-      
-      def find_first(options)
-        options.merge!(:limit => 1)
-        find_every({:order => '$natural asc'}.merge(options))[0]
-      end
-      
-      def find_last(options)
-        find_every(options.merge(:limit => 1, :order => '$natural desc'))[0]
-      end
-      
-      def find_some(ids, options={})
-        documents = find_every(options.deep_merge(:conditions => {'_id' => ids}))
-        if ids.size == documents.size
-          documents
-        else
-          raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{documents.size}, but was expecting #{ids.size}"
+      protected
+        def method_missing(method, *args)
+          finder = DynamicFinder.new(self, method)
+          
+          if finder.valid?
+            meta_def(finder.options[:method]) do |*args|
+              find_with_args(args, finder.options)
+            end
+            
+            send(finder.options[:method], *args)
+          else
+            super
+          end
         end
-      end
-      
-      def find_one(id, options={})
-        if doc = find_every(options.deep_merge(:conditions => {:_id => id})).first
-          doc
-        else
-          raise DocumentNotFound, "Document with id of #{id} does not exist in collection named #{collection.name}"
+
+      private
+        def find_every(options)
+          criteria, options = FinderOptions.new(options).to_a
+          collection.find(criteria, options).to_a.map { |doc| new(doc) }
         end
-      end
-      
-      def find_from_ids(ids, options={})
-        ids = ids.flatten.compact.uniq
-        
-        case ids.size
-          when 0
-            raise(DocumentNotFound, "Couldn't find without an ID")
-          when 1
-            find_one(ids[0], options)
+
+        def find_first(options)
+          options.merge!(:limit => 1)
+          find_every({:order => '$natural asc'}.merge(options))[0]
+        end
+
+        def find_last(options)
+          options.merge!(:limit => 1)
+          find_every({:order => '$natural desc'}.merge(options))[0]
+        end
+
+        def find_some(ids, options={})
+          documents = find_every(options.deep_merge(:conditions => {'_id' => ids}))
+          if ids.size == documents.size
+            documents
           else
-            find_some(ids, options)
+            raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{documents.size}, but was expecting #{ids.size}"
+          end
         end
-      end
-      
-      def update_single(id, attrs)
-        if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
-          raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
+
+        def find_one(id, options={})
+          if doc = find_every(options.deep_merge(:conditions => {:_id => id})).first
+            doc
+          else
+            raise DocumentNotFound, "Document with id of #{id} does not exist in collection named #{collection.name}"
+          end
         end
-        
-        find(id).update_attributes(attrs)
-      end
-      
-      def update_multiple(docs)
-        unless docs.is_a?(Hash)
-          raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+
+        def find_from_ids(ids, options={})
+          ids = ids.flatten.compact.uniq
+
+          case ids.size
+            when 0
+              raise(DocumentNotFound, "Couldn't find without an ID")
+            when 1
+              find_one(ids[0], options)
+            else
+              find_some(ids, options)
+          end
         end
         
-        instances = []
-        docs.each_pair { |id, attrs| instances << update(id, attrs) }
-        instances
-      end
+        def find_with_args(args, options)
+          attributes,  = {}
+          find_options = args.extract_options!.deep_merge(:conditions => attributes)
+          
+          options[:attribute_names].each_with_index do |attr, index|
+            attributes[attr] = args[index]
+          end
+
+          result = find(options[:finder], find_options)
+          
+          if result.nil?
+            if options[:bang]
+              raise DocumentNotFound, "Couldn't find Document with #{attributes.inspect} in collection named #{collection.name}"
+            end
+            
+            if options[:instantiator]
+              self.send(options[:instantiator], attributes)
+            end
+          else
+            result
+          end
+        end
+
+        def update_single(id, attrs)
+          if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
+            raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
+          end
+
+          doc = find(id)
+          doc.update_attributes(attrs)
+          doc
+        end
+
+        def update_multiple(docs)
+          unless docs.is_a?(Hash)
+            raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+          end
+
+          instances = []
+          docs.each_pair { |id, attrs| instances << update(id, attrs) }
+          instances
+        end
     end
-    
+
     module InstanceMethods
       def collection
         self.class.collection
       end
-      
+
       def new?
-        read_attribute('_id').blank?
+        read_attribute('_id').blank? || using_custom_id?
       end
-      
+
       def save
         create_or_update
       end
-      
+
       def save!
         create_or_update || raise(DocumentNotValid.new(self))
       end
@@ -238,41 +278,54 @@ module MongoMapper
       def update_attributes(attrs={})
         self.attributes = attrs
         save
-        self
       end
-      
+
       def destroy
+        return false if frozen?
+
         criteria = FinderOptions.to_mongo_criteria(:_id => id)
         collection.remove(criteria) unless new?
         freeze
       end
-      
+
     private
       def create_or_update
         result = new? ? create : update
         result != false
       end
-      
+
       def create
         update_timestamps
-        write_attribute :_id, save_to_collection
+        assign_id
+        save_to_collection
       end
       
+      def assign_id
+        if read_attribute(:_id).blank?
+          write_attribute(:_id, XGen::Mongo::Driver::ObjectID.new.to_s)
+        end
+      end
+
       def update
         update_timestamps
         save_to_collection
       end
-      
+
       # collection.save returns mongoid
       def save_to_collection
+        clear_custom_id_flag
         collection.save(attributes)
       end
-      
+
       def update_timestamps
         now = Time.now.utc
         write_attribute('created_at', now) if new?
         write_attribute('updated_at', now)
       end
+      
+      def clear_custom_id_flag
+        @using_custom_id = nil
+      end
     end
   end # Document
 end # MongoMapper