mongo_mapper 0.5.5 → 0.5.6

data/Rakefile

@@ -1,89 +1,49 @@
 require 'rubygems'
 require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "mongo_mapper"
-    gem.summary = %Q{Awesome gem for modeling your domain and storing it in mongo}
-    gem.email = "nunemaker@gmail.com"
-    gem.homepage = "http://github.com/jnunemaker/mongomapper"
-    gem.authors = ["John Nunemaker"]
-    gem.rubyforge_project = "mongomapper"
-    
-    gem.add_dependency('activesupport', '>= 2.3')
-    gem.add_dependency('mongo', '0.15.1')
-    gem.add_dependency('jnunemaker-validatable', '1.7.4')
-    
-    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')
-    gem.add_development_dependency('mocha', '0.9.4')
-  end
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name        = "mongo_mapper"
+  gem.summary     = %Q{Awesome gem for modeling your domain and storing it in mongo}
+  gem.description = %Q{Awesome gem for modeling your domain and storing it in mongo}
+  gem.email       = "nunemaker@gmail.com"
+  gem.homepage    = "http://github.com/jnunemaker/mongomapper"
+  gem.authors     = ["John Nunemaker"]
   
-  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"
+  gem.add_dependency('activesupport', '>= 2.3')
+  gem.add_dependency('mongo', '0.15.1')
+  gem.add_dependency('jnunemaker-validatable', '1.8.0')
+  
+  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')
+  gem.add_development_dependency('mocha', '0.9.4')
 end
 
+Jeweler::GemcutterTasks.new
+
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
+  test.libs << 'test'
+  test.ruby_opts << '-rubygems'
   test.pattern = 'test/**/test_*.rb'
   test.verbose = true
 end
 
 namespace :test do
   Rake::TestTask.new(:units) do |test|
-    test.libs << 'lib' << 'test'
+    test.libs << 'test'
+    test.ruby_opts << '-rubygems'
     test.pattern = 'test/unit/**/test_*.rb'
     test.verbose = true
   end
   
   Rake::TestTask.new(:functionals) do |test|
-    test.libs << 'lib' << 'test'
-    test.pattern = 'test/functional/**/test_*.rb'
-    test.verbose = true
-  end
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
     test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
+    test.ruby_opts << '-rubygems'
+    test.pattern = 'test/functional/**/test_*.rb'
     test.verbose = true
   end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
-
-begin
-  require 'cucumber/rake/task'
-  Cucumber::Rake::Task.new(:features)
-rescue LoadError
-  task :features do
-    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
-  end
 end
 
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION.yml')
-    config = YAML.load(File.read('VERSION.yml'))
-    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
-  else
-    version = ""
-  end
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "MongoMapper #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+task :default  => :test
+task :test     => :check_dependencies

data/VERSION

@@ -1 +1 @@
-0.5.5
+0.5.6

data/lib/mongo_mapper.rb

@@ -1,10 +1,4 @@
-require 'rubygems'
-
-gem 'activesupport', '>= 2.3'
-gem 'mongo', '0.15.1'
-gem 'jnunemaker-validatable', '1.7.4'
-
-require 'activesupport'
+require 'active_support'
 require 'mongo'
 require 'validatable'
 

data/lib/mongo_mapper/associations.rb

@@ -41,8 +41,6 @@ module MongoMapper
           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
@@ -62,14 +60,6 @@ module MongoMapper
           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

data/lib/mongo_mapper/associations/many_documents_proxy.rb

@@ -68,7 +68,7 @@ module MongoMapper
       end
       
       def nullify
-        criteria = FinderOptions.to_mongo_criteria(scoped_conditions)
+        criteria = FinderOptions.to_mongo_criteria(klass, scoped_conditions)
         all(criteria).each do |doc|
           doc.update_attributes self.foreign_key => nil
         end

data/lib/mongo_mapper/document.rb

@@ -95,14 +95,14 @@ module MongoMapper
       end
 
       def find_by_id(id)
-        criteria = FinderOptions.to_mongo_criteria(:_id => id)
+        criteria = FinderOptions.to_mongo_criteria(self, :_id => id)
         if doc = collection.find_one(criteria)
           new(doc)
         end
       end
 
       def count(conditions={})
-        collection.find(FinderOptions.to_mongo_criteria(conditions)).count
+        collection.find(FinderOptions.to_mongo_criteria(self, conditions)).count
       end
 
       def exists?(conditions={})
@@ -133,12 +133,12 @@ module MongoMapper
       end
 
       def delete(*ids)
-        criteria = FinderOptions.to_mongo_criteria(:_id => ids.flatten)
+        criteria = FinderOptions.to_mongo_criteria(self, :_id => ids.flatten)
         collection.remove(criteria)
       end
 
       def delete_all(conditions={})
-        criteria = FinderOptions.to_mongo_criteria(conditions)
+        criteria = FinderOptions.to_mongo_criteria(self, conditions)
         collection.remove(criteria)
       end
 
@@ -147,7 +147,7 @@ module MongoMapper
       end
 
       def destroy_all(conditions={})
-        find(:all, :conditions => conditions).each(&:destroy)
+        all(conditions).each(&:destroy)
       end
 
       def connection(mongo_connection=nil)
@@ -191,6 +191,14 @@ module MongoMapper
         class_eval { before_save :update_timestamps }
       end
       
+      def single_collection_inherited?
+        keys.has_key?('_type') && single_collection_inherited_superclass?
+      end
+      
+      def single_collection_inherited_superclass?
+        superclass.respond_to?(:keys) && superclass.keys.has_key?('_type')
+      end
+            
       protected
         def method_missing(method, *args)
           finder = DynamicFinder.new(method)
@@ -221,7 +229,7 @@ module MongoMapper
         end
         
         def find_every(options)
-          criteria, options = FinderOptions.new(options).to_a
+          criteria, options = FinderOptions.new(self, options).to_a
           collection.find(criteria, options).to_a.map do |doc|
             begin
               klass = doc['_type'].present? ? doc['_type'].constantize : self
@@ -304,7 +312,7 @@ module MongoMapper
       def destroy
         return false if frozen?
 
-        criteria = FinderOptions.to_mongo_criteria(:_id => id)
+        criteria = FinderOptions.to_mongo_criteria(self.class, :_id => id)
         collection.remove(criteria) unless new?
         freeze
       end

data/lib/mongo_mapper/finder_options.rb

@@ -1,9 +1,9 @@
 module MongoMapper
-  class FinderOptions
-    attr_reader :options
-    
-    def self.to_mongo_criteria(conditions, parent_key=nil)
+  class FinderOptions    
+    def self.to_mongo_criteria(model, conditions, parent_key=nil)
       criteria = {}
+      add_sci_scope(model, criteria)
+      
       conditions.each_pair do |field, value|
         field = field_normalized(field)
         case value
@@ -15,7 +15,7 @@ module MongoMapper
                                 {'$in' => value}
                               end
           when Hash
-            criteria[field] = to_mongo_criteria(value, field)
+            criteria[field] = to_mongo_criteria(model, value, field)
           else            
             criteria[field] = value
         end
@@ -23,8 +23,15 @@ module MongoMapper
       
       criteria
     end
+    
+    # adds _type single collection inheritance scope for models that need it
+    def self.add_sci_scope(model, criteria)
+      if model.single_collection_inherited?
+        criteria[:_type] = model.to_s
+      end
+    end
         
-    def self.to_mongo_options(options)
+    def self.to_mongo_options(model, options)
       options = options.dup
       {
         :fields => to_mongo_fields(options.delete(:fields) || options.delete(:select)),
@@ -44,9 +51,13 @@ module MongoMapper
     
     OptionKeys = [:fields, :select, :skip, :offset, :limit, :sort, :order]
     
-    def initialize(options)
+    attr_reader :model, :options
+    
+    def initialize(model, options)
       raise ArgumentError, "FinderOptions must be a hash" unless options.is_a?(Hash)
       
+      @model = model
+      
       options = options.symbolize_keys
       @options, @conditions = {}, options.delete(:conditions) || {}
       
@@ -60,11 +71,11 @@ module MongoMapper
     end
     
     def criteria
-      self.class.to_mongo_criteria(@conditions)
+      self.class.to_mongo_criteria(model, @conditions)
     end
     
     def options
-      self.class.to_mongo_options(@options)
+      self.class.to_mongo_options(model, @options)
     end
     
     def to_a

data/mongo_mapper.gemspec

@@ -1,16 +1,17 @@
 # Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{mongo_mapper}
-  s.version = "0.5.5"
+  s.version = "0.5.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Nunemaker"]
-  s.date = %q{2009-10-16}
+  s.date = %q{2009-10-22}
   s.default_executable = %q{mmconsole}
+  s.description = %q{Awesome gem for modeling your domain and storing it in mongo}
   s.email = %q{nunemaker@gmail.com}
   s.executables = ["mmconsole"]
   s.extra_rdoc_files = [
@@ -94,7 +95,6 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/jnunemaker/mongomapper}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubyforge_project = %q{mongomapper}
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{Awesome gem for modeling your domain and storing it in mongo}
   s.test_files = [
@@ -143,7 +143,7 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activesupport>, [">= 2.3"])
       s.add_runtime_dependency(%q<mongo>, ["= 0.15.1"])
-      s.add_runtime_dependency(%q<jnunemaker-validatable>, ["= 1.7.4"])
+      s.add_runtime_dependency(%q<jnunemaker-validatable>, ["= 1.8.0"])
       s.add_development_dependency(%q<jnunemaker-matchy>, ["= 0.4.0"])
       s.add_development_dependency(%q<shoulda>, ["= 2.10.2"])
       s.add_development_dependency(%q<timecop>, ["= 0.3.1"])
@@ -151,7 +151,7 @@ Gem::Specification.new do |s|
     else
       s.add_dependency(%q<activesupport>, [">= 2.3"])
       s.add_dependency(%q<mongo>, ["= 0.15.1"])
-      s.add_dependency(%q<jnunemaker-validatable>, ["= 1.7.4"])
+      s.add_dependency(%q<jnunemaker-validatable>, ["= 1.8.0"])
       s.add_dependency(%q<jnunemaker-matchy>, ["= 0.4.0"])
       s.add_dependency(%q<shoulda>, ["= 2.10.2"])
       s.add_dependency(%q<timecop>, ["= 0.3.1"])
@@ -160,10 +160,11 @@ Gem::Specification.new do |s|
   else
     s.add_dependency(%q<activesupport>, [">= 2.3"])
     s.add_dependency(%q<mongo>, ["= 0.15.1"])
-    s.add_dependency(%q<jnunemaker-validatable>, ["= 1.7.4"])
+    s.add_dependency(%q<jnunemaker-validatable>, ["= 1.8.0"])
     s.add_dependency(%q<jnunemaker-matchy>, ["= 0.4.0"])
     s.add_dependency(%q<shoulda>, ["= 2.10.2"])
     s.add_dependency(%q<timecop>, ["= 0.3.1"])
     s.add_dependency(%q<mocha>, ["= 0.9.4"])
   end
 end
+

data/specs.watchr

@@ -4,7 +4,7 @@ def run(cmd)
 end
 
 def run_test_file(file)
-  run "ruby -Itest #{file}"
+  run %Q(ruby -I"lib:test" -rubygems #{file})
 end
 
 def run_all_tests
@@ -12,7 +12,7 @@ def run_all_tests
 end
 
 def related_test_files(path)
-  Dir['test/**/*.rb'].select { |file| file =~ /#{File.basename(path)}/ }
+  Dir['test/**/*.rb'].select { |file| file =~ /test_#{File.basename(path)}/ }
 end
 
 watch('test/test_helper\.rb') { run_all_tests }

data/test/functional/test_document.rb

@@ -23,7 +23,7 @@ class DocumentTest < Test::Unit::TestCase
       doc.using_custom_id?.should be_false
     end
   end
-  
+
   context "Saving a document with a blank binary value" do
     setup do
       @document.key :file, Binary
@@ -40,9 +40,9 @@ class DocumentTest < Test::Unit::TestCase
       @id = Mongo::ObjectID.new.to_s
       @document.collection.insert({
         :_id            => @id,
-        :first_name     => 'John', 
-        :last_name      => 'Nunemaker', 
-        :age            => 27, 
+        :first_name     => 'John',
+        :last_name      => 'Nunemaker',
+        :age            => 27,
         :favorite_color => 'red',
         :skills         => ['ruby', 'rails', 'javascript', 'xhtml', 'css']
       })
@@ -57,7 +57,7 @@ class DocumentTest < Test::Unit::TestCase
       doc.skills.should == ['ruby', 'rails', 'javascript', 'xhtml', 'css']
     end
   end
-  
+
   context "Document Class Methods" do
     context "Using key with type Array" do
       setup do
@@ -140,7 +140,7 @@ class DocumentTest < Test::Unit::TestCase
         doc.foo['baz'].should == 'bar'
       end
     end
-    
+
     context "Using key with custom type with default" do
       setup do
         @document.key :window, WindowSize, :default => WindowSize.new(600, 480)
@@ -149,19 +149,19 @@ class DocumentTest < Test::Unit::TestCase
       should "default to default" do
         doc = @document.new
         doc.window.should == WindowSize.new(600, 480)
-        
+
       end
-      
+
       should "save and load from mongo" do
         doc = @document.new
         doc.save
-        
+
         from_db = @document.find(doc.id)
         from_db.window.should == WindowSize.new(600, 480)
       end
     end
-    
-    
+
+
     context "Creating a single document" do
       setup do
         @doc_instance = @document.create({:first_name => 'John', :last_name => 'Nunemaker', :age => '27'})
@@ -310,17 +310,17 @@ class DocumentTest < Test::Unit::TestCase
         should "work as array" do
           @document.find([@doc1.id, @doc2.id]).should == [@doc1, @doc2]
         end
-        
+
         should "return array if array only has one element" do
           @document.find([@doc1.id]).should == [@doc1]
         end
       end
-      
+
       should "be able to find using condition auto-detection" do
         @document.first(:first_name => 'John').should == @doc1
         @document.all(:last_name => 'Nunemaker', :order => 'age desc').should == [@doc1, @doc3]
       end
-      
+
       context "with :all" do
         should "find all documents" do
           @document.find(:all, :order => 'first_name').should == [@doc1, @doc3, @doc2]
@@ -362,11 +362,11 @@ class DocumentTest < Test::Unit::TestCase
           @document.last(:order => 'age').should == @doc2
           @document.last(:order => 'age', :conditions => {:age => 28}).should == @doc2
         end
-        
+
         should "raise error if no order provided" do
           lambda { @document.last() }.should raise_error
         end
-      end      
+      end
 
       context "with :find_by" do
         should "find document based on argument" do
@@ -668,11 +668,11 @@ class DocumentTest < Test::Unit::TestCase
             @thing.properties << @property3
           end
 
-          should "destroy the thing" do
+          should "not execute on a belongs_to association" do
             Thing.count.should == 1
             @property1.destroy
-            Thing.count.should == 0
-            @property1.thing.should be_frozen
+            Thing.count.should == 1
+            @property1.should be_frozen
           end
         end
       end
@@ -721,14 +721,14 @@ class DocumentTest < Test::Unit::TestCase
       should "allow creating index for a key" do
         @document.ensure_index :first_name
         MongoMapper.ensure_indexes!
-        
-        @document.should have_index('first_name_1')        
+
+        @document.should have_index('first_name_1')
       end
 
       should "allow creating unique index for a key" do
         @document.ensure_index :first_name, :unique => true
         MongoMapper.ensure_indexes!
-        
+
         @document.should have_index('first_name_1')
       end
 
@@ -736,13 +736,19 @@ class DocumentTest < Test::Unit::TestCase
         @document.ensure_index [[:first_name, 1], [:last_name, -1]]
         MongoMapper.ensure_indexes!
         
-        @document.should have_index('last_name_-1_first_name_1')        
+        # order is different for different versions of ruby so instead of 
+        # just checking have_index('first_name_1_last_name_-1') I'm checking
+        # the values of the indexes to make sure the index creation was successful
+        @document.collection.index_information.detect do |index|
+          keys = index[1]
+          keys.include?(['first_name', 1]) && keys.include?(['last_name', -1])
+        end.should_not be_nil
       end
 
       should "work with :index shortcut when defining key" do
         @document.key :father, String, :index => true
         MongoMapper.ensure_indexes!
-        
+
         @document.should have_index('father_1')
       end
     end
@@ -789,7 +795,7 @@ class DocumentTest < Test::Unit::TestCase
       from_db = RealPerson.find(person.id)
       from_db.name.should == "David"
     end
-    
+
     context "with key of type date" do
       should "save the date value as a Time object" do
         doc = @document.new(:first_name => 'John', :age => '27', :date => "12/01/2009")
@@ -886,16 +892,16 @@ class DocumentTest < Test::Unit::TestCase
       from_db.age.should == 30
     end
   end
-  
+
   context "update_attributes" do
     setup do
       @document.key :foo, String, :required => true
     end
-    
+
     should "return true if document valid" do
       @document.new.update_attributes(:foo => 'bar').should be_true
     end
-    
+
     should "return false if document not valid" do
       @document.new.update_attributes({}).should be_false
     end
@@ -936,63 +942,158 @@ class DocumentTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   context "Single collection inheritance" do
     setup do
       class ::DocParent
         include MongoMapper::Document
         key :_type, String
+        key :name, String
       end
-      
-      class ::DocChild < ::DocParent; end
       DocParent.collection.clear
       
+      class ::DocDaughter < ::DocParent; end
+      class ::DocSon < ::DocParent; end
+      class ::DocGrandSon < ::DocSon; end
+      
       @parent = DocParent.new({:name => "Daddy Warbucks"})
-      @child = DocChild.new({:name => "Little Orphan Annie"})
+      @daughter = DocDaughter.new({:name => "Little Orphan Annie"})
     end
 
     teardown do
-      Object.send :remove_const, 'DocParent' if defined?(::DocParent)
-      Object.send :remove_const, 'DocChild' if defined?(::DocChild)
+      Object.send :remove_const, 'DocParent'   if defined?(::DocParent)
+      Object.send :remove_const, 'DocDaughter' if defined?(::DocDaughter)
+      Object.send :remove_const, 'DocSon'      if defined?(::DocSon)
+      Object.send :remove_const, 'DocGrandSon' if defined?(::DocGrandSon)
     end
 
     should "use the same collection in the subclass" do
-      DocChild.collection.name.should == DocParent.collection.name
+      DocDaughter.collection.name.should == DocParent.collection.name
     end
 
     should "assign the class name into the _type property" do
       @parent._type.should == 'DocParent'
-      @child._type.should == 'DocChild'
+      @daughter._type.should == 'DocDaughter'
     end
 
     should "load the document with the assigned type" do
       @parent.save
-      @child.save
-
+      @daughter.save
+            
       collection = DocParent.find(:all)
       collection.size.should == 2
       collection.first.should be_kind_of(DocParent)
       collection.first.name.should == "Daddy Warbucks"
-      collection.last.should be_kind_of(DocChild)
+      collection.last.should be_kind_of(DocDaughter)
       collection.last.name.should == "Little Orphan Annie"
     end
-    
+
     should "gracefully handle when the type can't be constantized" do
       doc = DocParent.new(:name => 'Nunes')
       doc._type = 'FoobarBaz'
       doc.save
-      
+
       collection = DocParent.all
       collection.last.should == doc
       collection.last.should be_kind_of(DocParent)
     end
+    
+    should "find scoped to class" do
+      john = DocSon.create(:name => 'John')
+      steve = DocSon.create(:name => 'Steve')
+      steph = DocDaughter.create(:name => 'Steph')
+      carrie = DocDaughter.create(:name => 'Carrie')
+      
+      DocGrandSon.all(:order => 'name').should  == []
+      DocSon.all(:order => 'name').should       == [john, steve]
+      DocDaughter.all(:order => 'name').should  == [carrie, steph]
+      DocParent.all(:order => 'name').should    == [carrie, john, steph, steve]
+    end
+    
+    should "raise error if not found scoped to class" do
+      john = DocSon.create(:name => 'John')
+      steph = DocDaughter.create(:name => 'Steph')
+      
+      lambda {
+        DocSon.find(steph.id)
+      }.should raise_error(MongoMapper::DocumentNotFound)
+    end
+    
+    should "not raise error for find with parent" do
+      john = DocSon.create(:name => 'John')
+      
+      DocParent.find(john.id).should == john
+    end
+    
+    should "count scoped to class" do
+      john = DocSon.create(:name => 'John')
+      steve = DocSon.create(:name => 'Steve')
+      steph = DocDaughter.create(:name => 'Steph')
+      carrie = DocDaughter.create(:name => 'Carrie')
+      
+      DocGrandSon.count.should  == 0
+      DocSon.count.should       == 2
+      DocDaughter.count.should  == 2
+      DocParent.count.should    == 4
+    end
+    
+    should "know if it is single_collection_inherited?" do
+      DocParent.single_collection_inherited?.should be_false
+      
+      DocDaughter.single_collection_inherited?.should be_true
+      DocSon.single_collection_inherited?.should be_true
+    end
+    
+    should "know if single_collection_inherited_superclass?" do
+      DocParent.single_collection_inherited_superclass?.should be_false
+      
+      DocDaughter.single_collection_inherited_superclass?.should be_true
+      DocSon.single_collection_inherited_superclass?.should be_true
+      DocGrandSon.single_collection_inherited_superclass?.should be_true
+    end
+    
+    should "not be able to destroy each other" do
+      john = DocSon.create(:name => 'John')
+      steph = DocDaughter.create(:name => 'Steph')
+      
+      lambda {
+        DocSon.destroy(steph.id)
+      }.should raise_error(MongoMapper::DocumentNotFound)
+    end
+    
+    should "not be able to delete each other" do
+      john = DocSon.create(:name => 'John')
+      steph = DocDaughter.create(:name => 'Steph')
+      
+      lambda {
+        DocSon.delete(steph.id)
+      }.should_not change { DocParent.count }
+    end
+    
+    should "be able to destroy using parent" do
+      john = DocSon.create(:name => 'John')
+      steph = DocDaughter.create(:name => 'Steph')
+      
+      lambda {
+        DocParent.destroy_all
+      }.should change { DocParent.count }.by(-2)
+    end
+    
+    should "be able to delete using parent" do
+      john = DocSon.create(:name => 'John')
+      steph = DocDaughter.create(:name => 'Steph')
+      
+      lambda {
+        DocParent.delete_all
+      }.should change { DocParent.count }.by(-2)
+    end
   end
 
   context "timestamping" do
     setup do
       @document.timestamps!
     end
-    
+
     should "set created_at and updated_at on create" do
       doc = @document.new(:first_name => 'John', :age => 27)
       doc.created_at.should be(nil)
@@ -1007,11 +1108,11 @@ class DocumentTest < Test::Unit::TestCase
       old_created_at = doc.created_at
       old_updated_at = doc.updated_at
       doc.first_name = 'Johnny'
-      
+
       Timecop.freeze(Time.now + 5.seconds) do
         doc.save
       end
-      
+
       doc.created_at.should == old_created_at
       doc.updated_at.should_not == old_updated_at
     end
@@ -1020,7 +1121,7 @@ class DocumentTest < Test::Unit::TestCase
       doc = @document.create(:first_name => 'John', :age => 27)
       old_created_at = doc.created_at
       old_updated_at = doc.updated_at
-      
+
       Timecop.freeze(Time.now + 5.seconds) do
         @document.update(doc._id, { :first_name => 'Johnny' })
       end

data/test/models.rb

@@ -68,12 +68,6 @@ class Message
   belongs_to :room
 end
 
-class Answer
-  include MongoMapper::Document
-
-  key :body, String
-end
-
 class Enter < Message; end
 class Exit < Message;  end
 class Chat < Message;  end
@@ -85,6 +79,12 @@ class Room
   many :messages, :polymorphic => true
 end
 
+class Answer
+  include MongoMapper::Document
+
+  key :body, String
+end
+
 class Project
   include MongoMapper::Document
 

data/test/unit/test_finder_options.rb

@@ -1,73 +1,87 @@
 require 'test_helper'
+require 'models'
 
 class FinderOptionsTest < Test::Unit::TestCase
   include MongoMapper
   
   should "raise error if provided something other than a hash" do
-    lambda { FinderOptions.new }.should raise_error(ArgumentError)
-    lambda { FinderOptions.new(1) }.should raise_error(ArgumentError)
+    lambda { FinderOptions.new(Room) }.should raise_error(ArgumentError)
+    lambda { FinderOptions.new(Room, 1) }.should raise_error(ArgumentError)
   end
   
   should "symbolize the keys of the hash provided" do
-    FinderOptions.new('offset' => 1).options.keys.map do |key|
+    FinderOptions.new(Room, 'offset' => 1).options.keys.map do |key|
       key.should be_instance_of(Symbol)
     end
   end
   
   context "#criteria" do
     should "convert conditions to criteria" do
-      FinderOptions.expects(:to_mongo_criteria).with(:foo => 1).returns({})
-      FinderOptions.new(:conditions => {:foo => 1}).criteria
+      FinderOptions.expects(:to_mongo_criteria).with(Room, :foo => 1).returns({})
+      FinderOptions.new(Room, :conditions => {:foo => 1}).criteria
     end
   end
   
   context "#options" do
     should "convert options to mongo options" do
-      FinderOptions.expects(:to_mongo_options).with(:order => 'foo asc', :select => 'foo,bar').returns({})
-      FinderOptions.new(:order => 'foo asc', :select => 'foo,bar').options
+      FinderOptions.expects(:to_mongo_options).with(Room, :order => 'foo asc', :select => 'foo,bar').returns({})
+      FinderOptions.new(Room, :order => 'foo asc', :select => 'foo,bar').options
     end
   end
   
   context "Converting conditions to criteria" do
+    should "not add _type to query if model does not have superclass that is single collection inherited" do
+      FinderOptions.to_mongo_criteria(Message, :foo => 'bar').should == {
+        :foo => 'bar'
+      }
+    end
+    
+    should "automatically add _type to query if model is single collection inherited" do
+      FinderOptions.to_mongo_criteria(Enter, :foo => 'bar').should == {
+        :foo => 'bar',
+        :_type => 'Enter'
+      }
+    end
+    
     should "work with simple criteria" do
-      FinderOptions.to_mongo_criteria(:foo => 'bar').should == {
+      FinderOptions.to_mongo_criteria(Room, :foo => 'bar').should == {
         :foo => 'bar'
       }
       
-      FinderOptions.to_mongo_criteria(:foo => 'bar', :baz => 'wick').should == {
+      FinderOptions.to_mongo_criteria(Room, :foo => 'bar', :baz => 'wick').should == {
         :foo => 'bar', 
         :baz => 'wick'
       }
     end
     
     should "convert id to _id" do
-      FinderOptions.to_mongo_criteria(:id => '1').should == {
+      FinderOptions.to_mongo_criteria(Room, :id => '1').should == {
         :_id => '1'
       }
     end
     
     should "use $in for arrays" do
-      FinderOptions.to_mongo_criteria(:foo => [1,2,3]).should == {
+      FinderOptions.to_mongo_criteria(Room, :foo => [1,2,3]).should == {
         :foo => {'$in' => [1,2,3]}
       }
     end
     
     should "not use $in for arrays if already using array operator" do
-      FinderOptions.to_mongo_criteria(:foo => {'$all' => [1,2,3]}).should == {
+      FinderOptions.to_mongo_criteria(Room, :foo => {'$all' => [1,2,3]}).should == {
         :foo => {'$all' => [1,2,3]}
       }
 
-      FinderOptions.to_mongo_criteria(:foo => {'$any' => [1,2,3]}).should == {
+      FinderOptions.to_mongo_criteria(Room, :foo => {'$any' => [1,2,3]}).should == {
         :foo => {'$any' => [1,2,3]}
       }
     end
     
     should "work arbitrarily deep" do
-      FinderOptions.to_mongo_criteria(:foo => {:bar => [1,2,3]}).should == {
+      FinderOptions.to_mongo_criteria(Room, :foo => {:bar => [1,2,3]}).should == {
         :foo => {:bar => {'$in' => [1,2,3]}}
       }
       
-      FinderOptions.to_mongo_criteria(:foo => {:bar => {'$any' => [1,2,3]}}).should == {
+      FinderOptions.to_mongo_criteria(Room, :foo => {:bar => {'$any' => [1,2,3]}}).should == {
         :foo => {:bar => {'$any' => [1,2,3]}}
       }
     end
@@ -76,166 +90,166 @@ class FinderOptionsTest < Test::Unit::TestCase
   context "ordering" do
     should "single field with ascending direction" do
       sort = [['foo', 1]]
-      FinderOptions.to_mongo_options(:order => 'foo asc')[:sort].should == sort
-      FinderOptions.to_mongo_options(:order => 'foo ASC')[:sort].should == sort
+      FinderOptions.to_mongo_options(Room, :order => 'foo asc')[:sort].should == sort
+      FinderOptions.to_mongo_options(Room, :order => 'foo ASC')[:sort].should == sort
     end
     
     should "single field with descending direction" do
       sort = [['foo', -1]]
-      FinderOptions.to_mongo_options(:order => 'foo desc')[:sort].should == sort
-      FinderOptions.to_mongo_options(:order => 'foo DESC')[:sort].should == sort
+      FinderOptions.to_mongo_options(Room, :order => 'foo desc')[:sort].should == sort
+      FinderOptions.to_mongo_options(Room, :order => 'foo DESC')[:sort].should == sort
     end
     
     should "convert field without direction to ascending" do
       sort = [['foo', 1]]
-      FinderOptions.to_mongo_options(:order => 'foo')[:sort].should == sort
+      FinderOptions.to_mongo_options(Room, :order => 'foo')[:sort].should == sort
     end
     
     should "convert multiple fields with directions" do
       sort = [['foo', -1], ['bar', 1], ['baz', -1]]
-      FinderOptions.to_mongo_options(:order => 'foo desc, bar asc, baz desc')[:sort].should == sort
+      FinderOptions.to_mongo_options(Room, :order => 'foo desc, bar asc, baz desc')[:sort].should == sort
     end
     
     should "convert multiple fields with some missing directions" do
       sort = [['foo', -1], ['bar', 1], ['baz', 1]]
-      FinderOptions.to_mongo_options(:order => 'foo desc, bar, baz')[:sort].should == sort
+      FinderOptions.to_mongo_options(Room, :order => 'foo desc, bar, baz')[:sort].should == sort
     end
     
     should "just use sort if sort and order are present" do
       sort = [['$natural', 1]]
-      FinderOptions.to_mongo_options(:sort => sort, :order => 'foo asc')[:sort].should == sort
+      FinderOptions.to_mongo_options(Room, :sort => sort, :order => 'foo asc')[:sort].should == sort
     end
     
     should "convert natural in order to proper" do
       sort = [['$natural', 1]]
-      FinderOptions.to_mongo_options(:order => '$natural asc')[:sort].should == sort
+      FinderOptions.to_mongo_options(Room, :order => '$natural asc')[:sort].should == sort
       sort = [['$natural', -1]]
-      FinderOptions.to_mongo_options(:order => '$natural desc')[:sort].should == sort
+      FinderOptions.to_mongo_options(Room, :order => '$natural desc')[:sort].should == sort
     end
     
     should "work for natural order ascending" do
-      FinderOptions.to_mongo_options(:sort => {'$natural' => 1})[:sort]['$natural'].should == 1
+      FinderOptions.to_mongo_options(Room, :sort => {'$natural' => 1})[:sort]['$natural'].should == 1
     end
     
     should "work for natural order descending" do
-      FinderOptions.to_mongo_options(:sort => {'$natural' => -1})[:sort]['$natural'].should == -1
+      FinderOptions.to_mongo_options(Room, :sort => {'$natural' => -1})[:sort]['$natural'].should == -1
     end
   end
   
   context "skip" do
     should "default to 0" do
-      FinderOptions.to_mongo_options({})[:skip].should == 0
+      FinderOptions.to_mongo_options(Room, {})[:skip].should == 0
     end
     
     should "use skip provided" do
-      FinderOptions.to_mongo_options(:skip => 2)[:skip].should == 2
+      FinderOptions.to_mongo_options(Room, :skip => 2)[:skip].should == 2
     end
     
     should "covert string to integer" do
-      FinderOptions.to_mongo_options(:skip => '2')[:skip].should == 2
+      FinderOptions.to_mongo_options(Room, :skip => '2')[:skip].should == 2
     end
     
     should "convert offset to skip" do
-      FinderOptions.to_mongo_options(:offset => 1)[:skip].should == 1
+      FinderOptions.to_mongo_options(Room, :offset => 1)[:skip].should == 1
     end
   end
   
   context "limit" do
     should "default to 0" do
-      FinderOptions.to_mongo_options({})[:limit].should == 0
+      FinderOptions.to_mongo_options(Room, {})[:limit].should == 0
     end
     
     should "use limit provided" do
-      FinderOptions.to_mongo_options(:limit => 2)[:limit].should == 2
+      FinderOptions.to_mongo_options(Room, :limit => 2)[:limit].should == 2
     end
     
     should "covert string to integer" do
-      FinderOptions.to_mongo_options(:limit => '2')[:limit].should == 2
+      FinderOptions.to_mongo_options(Room, :limit => '2')[:limit].should == 2
     end
   end
   
   context "fields" do
     should "default to nil" do
-      FinderOptions.to_mongo_options({})[:fields].should be(nil)
+      FinderOptions.to_mongo_options(Room, {})[:fields].should be(nil)
     end
     
     should "be converted to nil if empty string" do
-      FinderOptions.to_mongo_options(:fields => '')[:fields].should be(nil)
+      FinderOptions.to_mongo_options(Room, :fields => '')[:fields].should be(nil)
     end
     
     should "be converted to nil if []" do
-      FinderOptions.to_mongo_options(:fields => [])[:fields].should be(nil)
+      FinderOptions.to_mongo_options(Room, :fields => [])[:fields].should be(nil)
     end
     
     should "should work with array" do
-      FinderOptions.to_mongo_options({:fields => %w(a b)})[:fields].should == %w(a b)
+      FinderOptions.to_mongo_options(Room, {:fields => %w(a b)})[:fields].should == %w(a b)
     end
     
     should "convert comma separated list to array" do
-      FinderOptions.to_mongo_options({:fields => 'a, b'})[:fields].should == %w(a b)
+      FinderOptions.to_mongo_options(Room, {:fields => 'a, b'})[:fields].should == %w(a b)
     end
     
     should "also work as select" do
-      FinderOptions.new(:select => %w(a b)).options[:fields].should == %w(a b)
+      FinderOptions.new(Room, :select => %w(a b)).options[:fields].should == %w(a b)
     end
   end
   
   context "Condition auto-detection" do
     should "know :conditions are criteria" do
-      finder = FinderOptions.new(:conditions => {:foo => 'bar'})
+      finder = FinderOptions.new(Room, :conditions => {:foo => 'bar'})
       finder.criteria.should == {:foo => 'bar'}
       finder.options.keys.should_not include(:conditions)
     end
     
     should "know fields is an option" do
-      finder = FinderOptions.new(:fields => ['foo'])
+      finder = FinderOptions.new(Room, :fields => ['foo'])
       finder.options[:fields].should == ['foo']
       finder.criteria.keys.should_not include(:fields)
     end
     
     # select gets converted to fields so just checking keys
     should "know select is an option" do
-      finder = FinderOptions.new(:select => 'foo')
+      finder = FinderOptions.new(Room, :select => 'foo')
       finder.options.keys.should include(:sort)
       finder.criteria.keys.should_not include(:select)
       finder.criteria.keys.should_not include(:fields)
     end
     
     should "know skip is an option" do
-      finder = FinderOptions.new(:skip => 10)
+      finder = FinderOptions.new(Room, :skip => 10)
       finder.options[:skip].should == 10
       finder.criteria.keys.should_not include(:skip)
     end
     
     # offset gets converted to skip so just checking keys
     should "know offset is an option" do
-      finder = FinderOptions.new(:offset => 10)
+      finder = FinderOptions.new(Room, :offset => 10)
       finder.options.keys.should include(:skip)
       finder.criteria.keys.should_not include(:skip)
       finder.criteria.keys.should_not include(:offset)
     end
 
     should "know limit is an option" do
-      finder = FinderOptions.new(:limit => 10)
+      finder = FinderOptions.new(Room, :limit => 10)
       finder.options[:limit].should == 10
       finder.criteria.keys.should_not include(:limit)
     end
 
     should "know sort is an option" do
-      finder = FinderOptions.new(:sort => [['foo', 1]])
+      finder = FinderOptions.new(Room, :sort => [['foo', 1]])
       finder.options[:sort].should == [['foo', 1]]
       finder.criteria.keys.should_not include(:sort)
     end
 
     # order gets converted to sort so just checking keys
     should "know order is an option" do
-      finder = FinderOptions.new(:order => 'foo')
+      finder = FinderOptions.new(Room, :order => 'foo')
       finder.options.keys.should include(:sort)
       finder.criteria.keys.should_not include(:sort)
     end
         
     should "work with full range of things" do
-      finder_options = FinderOptions.new({
+      finder_options = FinderOptions.new(Room, {
         :foo => 'bar',
         :baz => true,
         :sort => [['foo', 1]],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongo_mapper
 version: !ruby/object:Gem::Version 
-  version: 0.5.5
+  version: 0.5.6
 platform: ruby
 authors: 
 - John Nunemaker
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-16 00:00:00 -04:00
+date: 2009-10-22 00:00:00 -04:00
 default_executable: mmconsole
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,7 +40,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 1.7.4
+        version: 1.8.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: jnunemaker-matchy
@@ -82,7 +82,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.9.4
     version: 
-description: 
+description: Awesome gem for modeling your domain and storing it in mongo
 email: nunemaker@gmail.com
 executables: 
 - mmconsole
@@ -187,7 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: mongomapper
+rubyforge_project: 
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3