mongo_mapper 0.11.2 → 0.12.0

data/examples/identity_map.rb

@@ -4,21 +4,19 @@ require 'pp'
 
 MongoMapper.database = 'testing'
 
+MongoMapper::Plugins::IdentityMap.enabled = true
+
 class User
   include MongoMapper::Document
-  plugin MongoMapper::Plugins::IdentityMap
 
   key :name, String
 end
 User.delete_all
 
-user = User.create(:name => 'John')
-
 # User gets added to map on save
-pp User.identity_map[user.id]
+user = User.create(:name => 'John')
 
 # Does not matter how you find user, it is always the same object until the identity map is cleared
-puts "#{User.identity_map[user.id].object_id} == #{user.object_id}"
 puts "#{User.find(user.id).object_id} == #{user.object_id}"
 puts "#{User.all[0].object_id} == #{user.object_id}"
 
@@ -28,6 +26,3 @@ puts "#{User.find(user.id).object_id} != #{user.object_id}"
 # User gets removed from map on destroy
 user = User.create
 user.destroy
-puts "Should be nil: " + User.identity_map[user.id].inspect
-
-

data/examples/identity_map/automatic.rb

@@ -1,2 +1,2 @@
 # Using the following will turn on identity map for all models
-MongoMapper::Document.plugin(MongoMapper::Plugins::IdentityMap)
+MongoMapper::Plugins::IdentityMap.enabled = true

data/lib/mongo_mapper/connection.rb

@@ -70,7 +70,11 @@ module MongoMapper
       end
 
       MongoMapper.connection = if env['hosts']
-        Mongo::ReplSetConnection.new( *env['hosts'].push(options) )
+        if env['hosts'].first.is_a?(String)
+          Mongo::ReplSetConnection.new( env['hosts'], options )
+        else
+          Mongo::ReplSetConnection.new( *env['hosts'].push(options) )
+        end
       else
         Mongo::Connection.new(env['host'], env['port'], options)
       end

data/lib/mongo_mapper/document.rb

@@ -33,6 +33,7 @@ module MongoMapper
     include Plugins::Validations
     include Plugins::EmbeddedCallbacks
     include Plugins::Callbacks # for now callbacks needs to be after validations
+    include Plugins::IdentityMap
 
     included do
       extend Plugins

data/lib/mongo_mapper/middleware/identity_map.rb

@@ -1,16 +1,42 @@
 module MongoMapper
   module Middleware
+    # Usage:
+    #
+    #   config.middleware.insert_after \
+    #     ActionDispatch::Callbacks,
+    #     MongoMapper::Middleware::IdentityMap
+    #
+    # You have to insert after callbacks so the entire request is wrapped.
     class IdentityMap
+      class Body
+        def initialize(target, original)
+          @target   = target
+          @original = original
+        end
+
+        def each(&block)
+          @target.each(&block)
+        end
+
+        def close
+          @target.close if @target.respond_to?(:close)
+        ensure
+          MongoMapper::Plugins::IdentityMap.enabled = @original
+          MongoMapper::Plugins::IdentityMap.clear
+        end
+      end
+
       def initialize(app)
         @app = app
       end
 
       def call(env)
         MongoMapper::Plugins::IdentityMap.clear
-        @app.call(env)
-      ensure
-        MongoMapper::Plugins::IdentityMap.clear
+        enabled = MongoMapper::Plugins::IdentityMap.enabled
+        MongoMapper::Plugins::IdentityMap.enabled = true
+        status, headers, body = @app.call(env)
+        [status, headers, Body.new(body, enabled)]
       end
     end
   end
-end
+end

data/lib/mongo_mapper/plugins/identity_map.rb

@@ -6,30 +6,55 @@ module MongoMapper
     module IdentityMap
       extend ActiveSupport::Concern
 
-      def self.models
-        @models ||= Set.new
+      def self.enabled=(flag)
+        Thread.current[:mongo_mapper_identity_map_enabled] = flag
+      end
+
+      def self.enabled
+        Thread.current[:mongo_mapper_identity_map_enabled]
+      end
+
+      def self.enabled?
+        enabled == true
+      end
+
+      def self.repository
+        Thread.current[:mongo_mapper_identity_map] ||= {}
       end
 
       def self.clear
-        models.each { |m| m.identity_map.clear }
+        repository.clear
       end
 
-      included do
-        IdentityMap.models << self
+      def self.include?(document)
+        repository.key?(IdentityMap.key(document.class, document._id))
       end
 
-      module ClassMethods
-        def inherited(descendant)
-          descendant.identity_map = identity_map
-          super
-        end
+      def self.key(model, id)
+        "#{model.single_collection_root.name}:#{id}"
+      end
 
-        def identity_map
-          @identity_map ||= {}
-        end
+      def self.use
+        old, self.enabled = enabled, true
 
-        def identity_map=(v)
-          @identity_map = v
+        yield if block_given?
+      ensure
+        self.enabled = old
+        clear
+      end
+
+      def self.without
+        old, self.enabled = enabled, false
+
+        yield if block_given?
+      ensure
+        self.enabled = old
+      end
+
+      module ClassMethods
+        # Private - Looks for a document in the identity map
+        def get_from_identity_map(id)
+          IdentityMap.repository[IdentityMap.key(self, id)]
         end
 
         module IdentityMapQueryMethods
@@ -43,14 +68,22 @@ module MongoMapper
           def find_one(opts={})
             query = clone.amend(opts)
 
-            if model.identity_map_on? && query.simple? && model.identity_map[query[:_id]]
-              model.identity_map[query[:_id]]
+            if IdentityMap.enabled? && query.simple? && (document = model.get_from_identity_map(query[:_id]))
+              document
             else
               super.tap do |doc|
                 model.remove_documents_from_map(doc) if query.fields?
               end
             end
           end
+
+          def find_each(opts={}, &block)
+            query = clone.amend(opts)
+            super(opts) do |doc|
+              model.remove_documents_from_map(doc) if query.fields?
+              block.call(doc) unless block.nil?
+            end
+          end
         end
 
         def query(opts={})
@@ -59,70 +92,44 @@ module MongoMapper
 
         def remove_documents_from_map(*documents)
           documents.flatten.compact.each do |document|
-            identity_map.delete(document['_id'])
+            document.remove_from_identity_map
           end
         end
 
         def load(attrs)
           return nil if attrs.nil?
-          document = identity_map[attrs['_id']]
+          document = get_from_identity_map(attrs['_id'])
 
-          if document.nil? || identity_map_off?
+          if document.nil?
             document = super
-            identity_map[document._id] = document if identity_map_on?
+            document.add_to_identity_map
           end
 
           document
         end
+      end
 
-        def identity_map_status
-          defined?(@identity_map_status) ? @identity_map_status : true
-        end
-
-        def identity_map_on
-          @identity_map_status = true
-        end
-
-        def identity_map_off
-          @identity_map_status = false
-        end
-
-        def identity_map_on?
-          identity_map_status
-        end
-
-        def identity_map_off?
-          !identity_map_on?
-        end
-
-        def without_identity_map(&block)
-          identity_map_off
-          yield
-        ensure
-          identity_map_on
-        end
-
-        private
-          def selecting_fields?(options)
-            !options[:fields].nil?
-          end
+      def save(*args)
+        super.tap { |result| add_to_identity_map if result }
       end
 
-      def identity_map
-        self.class.identity_map
+      def delete
+        super.tap { remove_from_identity_map }
       end
 
-      def save(*args)
-        if result = super
-          identity_map[_id] = self if self.class.identity_map_on?
+      def add_to_identity_map
+        if IdentityMap.enabled?
+          key = IdentityMap.key(self.class, _id)
+          IdentityMap.repository[key] = self
         end
-        result
       end
 
-      def delete
-        identity_map.delete(_id) if self.class.identity_map_on?
-        super
+      def remove_from_identity_map
+        if IdentityMap.enabled?
+          key = IdentityMap.key(self.class, _id)
+          IdentityMap.repository.delete(key)
+        end
       end
     end
   end
-end
+end

data/lib/mongo_mapper/plugins/sci.rb

@@ -13,9 +13,30 @@ module MongoMapper
           key :_type, String unless key?(:_type)
           subclass.instance_variable_set("@single_collection_inherited", true)
           subclass.set_collection_name(collection_name) unless subclass.embeddable?
+          subclass.single_collection_parent = self
           super
         end
 
+        def single_collection_root
+          parent = single_collection_parent || self
+          root = parent
+
+          while parent
+            parent = parent.single_collection_parent
+            root = parent unless parent.nil?
+          end
+
+          root
+        end
+
+        def single_collection_parent
+          @single_collection_parent
+        end
+
+        def single_collection_parent=(parent)
+          @single_collection_parent = parent
+        end
+
         def single_collection_inherited?
           @single_collection_inherited == true
         end

data/lib/mongo_mapper/railtie.rb

@@ -28,21 +28,5 @@ module MongoMapper
         MongoMapper.setup(config, Rails.env, :logger => Rails.logger)
       end
     end
-
-    # Clear the identity map after each request
-    initializer "mongo_mapper.clear_identity_map" do |app|
-      app.config.middleware.use 'MongoMapper::Middleware::IdentityMap'
-    end
-
-    initializer "mongo_mapper.prepare_dispatcher" do |app|
-      # See http://groups.google.com/group/mongomapper/browse_thread/thread/68f62e8eda43b43a/4841dba76938290c
-      # to_prepare is called before each request in development mode and the first request in production.
-
-      ActionDispatch::Callbacks.to_prepare do
-        unless app.config.cache_classes
-          MongoMapper::Plugins::IdentityMap.models.clear
-        end
-      end
-    end
   end
 end

data/lib/mongo_mapper/version.rb

@@ -1,4 +1,4 @@
 # encoding: UTF-8
 module MongoMapper
-  Version = '0.11.2'
+  Version = '0.12.0'
 end

data/test/functional/test_identity_map.rb

@@ -3,15 +3,13 @@ require 'test_helper'
 class IdentityMapTest < Test::Unit::TestCase
   def assert_in_map(*resources)
     [resources].flatten.each do |resource|
-      resource.identity_map.keys.should include(resource._id)
-      mapped_resource = resource.identity_map[resource._id]
-      resource.should equal(mapped_resource)
+      MongoMapper::Plugins::IdentityMap.include?(resource).should be_true
     end
   end
 
   def assert_not_in_map(*resources)
     [resources].flatten.each do |resource|
-      resource.identity_map.keys.should_not include(resource._id)
+      MongoMapper::Plugins::IdentityMap.include?(resource).should be_false
     end
   end
 
@@ -24,19 +22,24 @@ class IdentityMapTest < Test::Unit::TestCase
     Mongo::Collection.any_instance.expects(:find_one).once.returns({})
   end
 
+  def clear_identity_map
+    MongoMapper::Plugins::IdentityMap.clear
+  end
+
+  should "default identity map to off" do
+    MongoMapper::Plugins::IdentityMap.enabled?.should be_false
+  end
+
   context "Document" do
     setup do
-      MongoMapper::Plugins::IdentityMap.models.clear
+      @original_identity_map_enabled = MongoMapper::Plugins::IdentityMap.enabled
+      MongoMapper::Plugins::IdentityMap.enabled = true
 
       @person_class = Doc('Person') do
-        plugin MongoMapper::Plugins::IdentityMap
-
         key :name, String
       end
 
       @post_class = Doc('Post') do
-        plugin MongoMapper::Plugins::IdentityMap
-
         key :title, String
         key :person_id, ObjectId
       end
@@ -44,58 +47,80 @@ class IdentityMapTest < Test::Unit::TestCase
       @post_class.belongs_to :person, :class => @person_class
       @person_class.many :posts, :class => @post_class
 
-      @post_class.identity_map_on
-      @person_class.identity_map_on
-      MongoMapper::Plugins::IdentityMap.clear
+      clear_identity_map
     end
 
-    should "track identity mapped models" do
-      MongoMapper::Plugins::IdentityMap.models.should == [@person_class, @post_class].to_set
+    teardown do
+      MongoMapper::Plugins::IdentityMap.enabled = @original_identity_map_enabled
     end
 
     should "be able to clear the map of all models" do
       person = @person_class.create(:name => 'John')
       post = @post_class.create(:title => 'IM 4eva')
-      assert_in_map(person, post)
-
-      MongoMapper::Plugins::IdentityMap.clear
 
+      assert_in_map(person, post)
+      clear_identity_map
       assert_not_in_map(person, post)
 
-      [@person_class, @post_class].each { |klass| klass.identity_map.should == {} }
+      MongoMapper::Plugins::IdentityMap.repository.should be_empty
     end
 
-    context "IM on off status" do
-      teardown do
-        @post_class.identity_map_on
-        @person_class.identity_map_on
+    context ".use" do
+      setup do
+        @person = @person_class.create
+        clear_identity_map
       end
 
-      should "default identity map status to on" do
-        Doc { plugin MongoMapper::Plugins::IdentityMap }.identity_map_status.should be_true
+      should "use the identity map" do
+        MongoMapper::Plugins::IdentityMap.enabled = false
+        MongoMapper::Plugins::IdentityMap.use do
+          @person_class.find(@person.id).should equal(@person_class.find(@person.id))
+        end
+      end
+
+      should "clear the map" do
+        MongoMapper::Plugins::IdentityMap.enabled = false
+        MongoMapper::Plugins::IdentityMap.repository['hello'] = 'world'
+        MongoMapper::Plugins::IdentityMap.use do
+          @person_class.find(@person.id)
+        end
+        MongoMapper::Plugins::IdentityMap.repository.empty?.should be_true
       end
 
-      should "be true if on" do
-        @post_class.identity_map_on
-        @post_class.should be_identity_map_on
-        @post_class.should_not be_identity_map_off
+      should "set enabled back to original status" do
+        MongoMapper::Plugins::IdentityMap.enabled = false
+        MongoMapper::Plugins::IdentityMap.enabled?.should be_false
+        MongoMapper::Plugins::IdentityMap.use do
+          MongoMapper::Plugins::IdentityMap.enabled?.should be_true
+        end
+        MongoMapper::Plugins::IdentityMap.enabled?.should be_false
       end
+    end
 
-      should "be false if off" do
-        @post_class.identity_map_off
-        @post_class.should be_identity_map_off
-        @post_class.should_not be_identity_map_on
+    context ".without" do
+      setup do
+        @person = @person_class.create
+        clear_identity_map
       end
 
-      should "not share with other classes" do
-        @post_class.identity_map_off
-        @person_class.identity_map_on
-        @post_class.identity_map_status.should_not == @person_class.identity_map_status
+      should "skip the map" do
+        MongoMapper::Plugins::IdentityMap.without do
+          @person_class.find(@person.id).should_not equal(@person_class.find(@person.id))
+        end
+      end
+
+      should "set enabled back to original value" do
+        MongoMapper::Plugins::IdentityMap.enabled = true
+        MongoMapper::Plugins::IdentityMap.enabled?.should be_true
+        MongoMapper::Plugins::IdentityMap.without do
+          MongoMapper::Plugins::IdentityMap.enabled?.should be_false
+        end
+        MongoMapper::Plugins::IdentityMap.enabled?.should be_true
       end
     end
 
     should "default identity map to hash" do
-      Doc { plugin MongoMapper::Plugins::IdentityMap }.identity_map.should == {}
+      MongoMapper::Plugins::IdentityMap.repository.should == {}
     end
 
     should "add key to map when saved" do
@@ -107,35 +132,35 @@ class IdentityMapTest < Test::Unit::TestCase
 
     should "allow saving with options" do
       person = @person_class.new
-      assert_nothing_raised do
-        person.save(:validate => false).should be_true
-      end
+      assert_not_in_map(person)
+      person.save(:validate => false).should be_true
+      assert_in_map(person)
     end
 
     should "remove key from map when deleted" do
+      person = @person_class.create(:name => 'Fred')
+      assert_in_map(person)
+      person.delete
+      assert_not_in_map(person)
+    end
+
+    should "remove key from map when destroyed" do
       person = @person_class.create(:name => 'Fred')
       assert_in_map(person)
       person.destroy
       assert_not_in_map(person)
     end
 
-    context "reload" do
+    context "#reload" do
       setup do
         @person = @person_class.create(:name => 'Fred')
       end
 
-      should "remove object from identity and re-query" do
+      should "re-query the object" do
         assert_in_map(@person)
         expects_one_query
         @person.reload
       end
-
-      should "add object back into map" do
-        assert_in_map(@person)
-        before_reload = @person
-        @person.reload.should equal(before_reload)
-        assert_in_map(@person)
-      end
     end
 
     context "#load" do
@@ -144,23 +169,26 @@ class IdentityMapTest < Test::Unit::TestCase
       end
 
       should "add document to map" do
-        loaded = @person_class.load({'_id' => @id, 'name' => 'Frank'})
+        loaded = @person_class.load('_id' => @id, 'name' => 'Frank')
         assert_in_map(loaded)
       end
 
       should "return document if already in map" do
-        first_load = @person_class.load({'_id' => @id, 'name' => 'Frank'})
-        @person_class.identity_map.expects(:[]=).never
-        second_load = @person_class.load({'_id' => @id, 'name' => 'Frank'})
+        first_load = @person_class.load('_id' => @id, 'name' => 'Frank')
+        second_load = @person_class.load('_id' => @id, 'name' => 'Frank')
         first_load.should equal(second_load)
       end
     end
 
     context "#find (with one id)" do
+      should "return nil if not found " do
+        @person_class.find(1234).should be_nil
+      end
+
       context "for object not in map" do
         setup do
           @person = @person_class.create(:name => 'Fred')
-          @person_class.identity_map.clear
+          clear_identity_map
         end
 
         should "query the database" do
@@ -173,10 +201,6 @@ class IdentityMapTest < Test::Unit::TestCase
           found_person = @person_class.find(@person.id)
           assert_in_map(found_person)
         end
-
-        should "return nil if not found " do
-          @person_class.find(1234).should be_nil
-        end
       end
 
       context "for object in map" do
@@ -218,8 +242,8 @@ class IdentityMapTest < Test::Unit::TestCase
 
       should "return exact object" do
         assert_in_map(@post1)
-        @person.posts.find(@post1.id)
-        assert_in_map(@post1)
+        post = @person.posts.find(@post1.id)
+        post.should equal(@post1)
       end
 
       should "return nil if not found " do
@@ -232,7 +256,7 @@ class IdentityMapTest < Test::Unit::TestCase
         person1 = @person_class.create(:name => 'Fred')
         person2 = @person_class.create(:name => 'Bill')
         person3 = @person_class.create(:name => 'Jesse')
-        @person_class.identity_map.clear
+        clear_identity_map
 
         people = @person_class.find(person1.id, person2.id, person3.id)
         assert_in_map(people)
@@ -240,7 +264,7 @@ class IdentityMapTest < Test::Unit::TestCase
 
       should "add missing documents to map and return existing ones" do
         person1 = @person_class.create(:name => 'Fred')
-        @person_class.identity_map.clear
+        clear_identity_map
         person2 = @person_class.create(:name => 'Bill')
         person3 = @person_class.create(:name => 'Jesse')
 
@@ -248,6 +272,7 @@ class IdentityMapTest < Test::Unit::TestCase
         assert_in_map(person2, person3)
 
         people = @person_class.find(person1.id, person2.id, person3.id)
+
         assert_in_map(people.first) # making sure one that wasn't mapped now is
         assert_in_map(person2, person3)
       end
@@ -257,7 +282,7 @@ class IdentityMapTest < Test::Unit::TestCase
       context "for object not in map" do
         setup do
           @person = @person_class.create(:name => 'Fred')
-          @person_class.identity_map.clear
+          clear_identity_map
         end
 
         should "query the database" do
@@ -299,7 +324,7 @@ class IdentityMapTest < Test::Unit::TestCase
         person1 = @person_class.create(:name => 'Fred')
         person2 = @person_class.create(:name => 'Bill')
         person3 = @person_class.create(:name => 'Jesse')
-        @person_class.identity_map.clear
+        clear_identity_map
 
         people = @person_class.all(:_id => [person1.id, person2.id, person3.id])
         assert_in_map(people)
@@ -307,7 +332,7 @@ class IdentityMapTest < Test::Unit::TestCase
 
       should "add missing documents to map and return existing ones" do
         person1 = @person_class.create(:name => 'Fred')
-        @person_class.identity_map.clear
+        clear_identity_map
         person2 = @person_class.create(:name => 'Bill')
         person3 = @person_class.create(:name => 'Jesse')
 
@@ -334,7 +359,7 @@ class IdentityMapTest < Test::Unit::TestCase
     context "querying and selecting certain fields" do
       setup do
         @person = @person_class.create(:name => 'Bill')
-        @person_class.identity_map.clear
+        clear_identity_map
       end
 
       should "not add to map" do
@@ -347,6 +372,13 @@ class IdentityMapTest < Test::Unit::TestCase
         assert_not_in_map(@person)
       end
 
+      should "not add to map using where and each" do
+        @person_class.where(:id => @person.id).each{|_|}
+        assert_in_map(@person)
+        @person_class.where(:id => @person.id).only(:id).each{|_|}
+        assert_not_in_map(@person)
+      end
+
       should "return nil if not found" do
         @person_class.fields(:name).find(BSON::ObjectId.new).should be_nil
       end
@@ -356,7 +388,6 @@ class IdentityMapTest < Test::Unit::TestCase
       setup do
         class ::Item
           include MongoMapper::Document
-          plugin MongoMapper::Plugins::IdentityMap
 
           key :title, String
           key :parent_id, ObjectId
@@ -375,21 +406,15 @@ class IdentityMapTest < Test::Unit::TestCase
       end
 
       teardown do
-        Object.send :remove_const, 'Item'   if defined?(::Item)
+        Object.send :remove_const, 'Item' if defined?(::Item)
         Object.send :remove_const, 'Blog' if defined?(::Blog)
         Object.send :remove_const, 'BlogPost' if defined?(::BlogPost)
       end
 
-      should "share the same identity map" do
-        blog = Blog.create(:title => 'Jill')
-        assert_in_map(blog)
-        Item.identity_map.should equal(Blog.identity_map)
-      end
-
       should "not query when finding by _id and _type" do
         blog = Blog.create(:title => 'Blog')
         post = BlogPost.create(:title => 'Mongo Rocks', :blog => blog)
-        Item.identity_map.clear
+        clear_identity_map
 
         blog = Item.find(blog.id)
         post = Item.find(post.id)
@@ -429,85 +454,5 @@ class IdentityMapTest < Test::Unit::TestCase
         blog.parent.should equal(root)
       end
     end
-
-    context "without identity map" do
-      should "not add to map on save" do
-        @post_class.without_identity_map do
-          post = @post_class.create(:title => 'Bill')
-          assert_not_in_map(post)
-        end
-      end
-
-      should "not remove from map on delete" do
-        post = @post_class.create(:title => 'Bill')
-        assert_in_map(post)
-
-        @post_class.without_identity_map do
-          post.destroy
-        end
-
-        assert_in_map(post)
-      end
-
-      should "not add to map when loading" do
-        @post_class.without_identity_map do
-          post = @post_class.load({'_id' => BSON::ObjectId.new, 'title' => 'Awesome!'})
-          assert_not_in_map(post)
-        end
-      end
-
-      should "not load from map when loading" do
-        post = @post_class.create(:title => 'Awesome!')
-
-        @post_class.without_identity_map do
-          loaded = @post_class.load('_id' => post._id, 'title' => 'Awesome!')
-          loaded.should_not equal(post)
-        end
-      end
-
-      should "not load attributes from map when finding" do
-        post = @post_class.create(:title => 'Awesome!')
-        post.title = 'Temporary'
-        @post_class.without_identity_map do
-          @post_class.find(post.id).title.should == 'Awesome!'
-        end
-      end
-
-      context "all" do
-        should "not add to map" do
-          @post_class.without_identity_map do
-            post1 = @post_class.create(:title => 'Foo')
-            post2 = @post_class.create(:title => 'Bar')
-            @post_class.identity_map.clear
-
-            assert_not_in_map(@post_class.all)
-          end
-        end
-      end
-
-      context "first" do
-        should "not add to map" do
-          @post_class.without_identity_map do
-            post1 = @post_class.create(:title => 'Foo')
-            post2 = @post_class.create(:title => 'Bar')
-            @post_class.identity_map.clear
-
-            assert_not_in_map(@post_class.first)
-          end
-        end
-      end
-
-      context "last" do
-        should "not add to map" do
-          @post_class.without_identity_map do
-            post1 = @post_class.create(:title => 'Foo')
-            post2 = @post_class.create(:title => 'Bar')
-            @post_class.identity_map.clear
-
-            assert_not_in_map(@post_class.last(:order => 'title'))
-          end
-        end
-      end
-    end
   end
-end
+end

data/test/functional/test_sci.rb

@@ -36,6 +36,22 @@ class SciTest < Test::Unit::TestCase
       DocDaughter.collection.name.should == DocParent.collection.name
     end
 
+    should "know single_collection_parent" do
+      DocParent.single_collection_parent.should be_nil
+      DocDaughter.single_collection_parent.should      == DocParent
+      DocSon.single_collection_parent.should           == DocParent
+      DocGrandSon.single_collection_parent.should      == DocSon
+      DocGrandGrandSon.single_collection_parent.should == DocGrandSon
+    end
+
+    should "know single_collection_root" do
+      DocParent.single_collection_root.should        == DocParent
+      DocDaughter.single_collection_root.should      == DocParent
+      DocSon.single_collection_root.should           == DocParent
+      DocGrandSon.single_collection_root.should      == DocParent
+      DocGrandGrandSon.single_collection_root.should == DocParent
+    end
+
     context ".single_collection_inherited?" do
       should "be false if has not inherited" do
         DocParent.should_not be_single_collection_inherited

data/test/unit/test_identity_map_middleware.rb

@@ -7,28 +7,126 @@ class IdentityMapMiddlewareTest < Test::Unit::TestCase
   def app
     @app ||= Rack::Builder.new do
       use MongoMapper::Middleware::IdentityMap
+
       map "/" do
         run lambda {|env| [200, {}, []] }
       end
+
       map "/fail" do
         run lambda {|env| raise "FAIL!" }
       end
     end.to_app
   end
 
-  context "with a successful request" do
-    should "clear the identity map" do
-      MongoMapper::Plugins::IdentityMap.expects(:clear).twice
-      get '/'
+  context "" do
+    setup do
+      @enabled = MongoMapper::Plugins::IdentityMap.enabled
+      MongoMapper::Plugins::IdentityMap.enabled = false
     end
-  end
 
-  context "when the request raises an error" do
-    should "clear the identity map" do
-      MongoMapper::Plugins::IdentityMap.expects(:clear).twice
-      get '/fail' rescue nil
+    teardown do
+      MongoMapper::Plugins::IdentityMap.enabled = @enabled
     end
-  end
 
+    should "delegate" do
+      called = false
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
+        called = true
+        [200, {}, nil]
+      }
+      mw.call({})
+      called.should be_true
+    end
+
+    should "enable identity map during delegation" do
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
+        MongoMapper::Plugins::IdentityMap.should be_enabled
+        [200, {}, nil]
+      }
+      mw.call({})
+    end
+
+    class Enum < Struct.new(:iter)
+      def each(&b)
+        iter.call(&b)
+      end
+    end
+
+    should "enable IM for body each" do
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
+        [200, {}, Enum.new(lambda { |&b|
+          MongoMapper::Plugins::IdentityMap.should be_enabled
+          b.call "hello"
+        })]
+      }
+      body = mw.call({}).last
+      body.each { |x| x.should eql('hello') }
+    end
+
+    should "disable IM after body close" do
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env| [200, {}, []] }
+      body = mw.call({}).last
+      MongoMapper::Plugins::IdentityMap.should be_enabled
+      body.close
+      MongoMapper::Plugins::IdentityMap.should_not be_enabled
+    end
+
+    should "clear IM after body close" do
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env| [200, {}, []] }
+      body = mw.call({}).last
+
+      MongoMapper::Plugins::IdentityMap.repository['hello'] = 'world'
+      MongoMapper::Plugins::IdentityMap.repository.should_not be_empty
 
+      body.close
+
+      MongoMapper::Plugins::IdentityMap.repository.should be_empty
+    end
+
+    context "with a successful request" do
+      should "clear the identity map" do
+        MongoMapper::Plugins::IdentityMap.expects(:clear).twice
+        get '/'
+      end
+    end
+
+    context "when the request raises an error" do
+      should "clear the identity map" do
+        MongoMapper::Plugins::IdentityMap.expects(:clear).once
+        get '/fail' rescue nil
+      end
+    end
+  end
 end
+
+# class IdentityMapMiddlewareTest < Test::Unit::TestCase
+#   include Rack::Test::Methods
+
+#   def app
+#     @app ||= Rack::Builder.new do
+#       use MongoMapper::Middleware::IdentityMap
+#       map "/" do
+#         run lambda {|env| [200, {}, []] }
+#       end
+#       map "/fail" do
+#         run lambda {|env| raise "FAIL!" }
+#       end
+#     end.to_app
+#   end
+
+#   context "with a successful request" do
+#     should "clear the identity map" do
+#       MongoMapper::Plugins::IdentityMap.expects(:clear).twice
+#       get '/'
+#     end
+#   end
+
+#   context "when the request raises an error" do
+#     should "clear the identity map" do
+#       MongoMapper::Plugins::IdentityMap.expects(:clear).twice
+#       get '/fail' rescue nil
+#     end
+#   end
+
+
+# end

data/test/unit/test_mongo_mapper.rb

@@ -116,7 +116,7 @@ class MongoMapperTest < Test::Unit::TestCase
       assert_raises(MongoMapper::InvalidScheme) { MongoMapper.connect('development') }
     end
 
-    should "create a replica set connection if config contains multiple hosts" do
+    should "create a replica set connection if config contains multiple hosts in the old format" do
       MongoMapper.config = {
         'development' => {
           'hosts' => [ ['127.0.0.1', 27017], ['localhost', 27017] ],
@@ -129,6 +129,20 @@ class MongoMapperTest < Test::Unit::TestCase
       Mongo::DB.any_instance.expects(:authenticate).never
       MongoMapper.connect('development', 'read_secondary' => true)
     end
+
+    should "create a replica set connection if config contains multiple hosts in the new format" do
+      MongoMapper.config = {
+        'development' => {
+          'hosts' => ['127.0.0.1:27017', 'localhost:27017'],
+          'database' => 'test'
+        }
+      }
+
+      Mongo::ReplSetConnection.expects(:new).with( ['127.0.0.1:27017', 'localhost:27017'], {'read_secondary' => true} )
+      MongoMapper.expects(:database=).with('test')
+      Mongo::DB.any_instance.expects(:authenticate).never
+      MongoMapper.connect('development', 'read_secondary' => true)
+    end
   end
 
   context "setup" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongo_mapper
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.12.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-21 00:00:00.000000000 Z
+date: 2012-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
-  requirement: &70319139905420 !ruby/object:Gem::Requirement
+  requirement: &70247394230160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70319139905420
+  version_requirements: *70247394230160
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70319139904940 !ruby/object:Gem::Requirement
+  requirement: &70247394229680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,18 +32,18 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70319139904940
+  version_requirements: *70247394229680
 - !ruby/object:Gem::Dependency
   name: plucky
-  requirement: &70319139904480 !ruby/object:Gem::Requirement
+  requirement: &70247394229220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.5.2
   type: :runtime
   prerelease: false
-  version_requirements: *70319139904480
+  version_requirements: *70247394229220
 description: 
 email:
 - nunemaker@gmail.com
@@ -219,7 +219,6 @@ files:
 - test/unit/test_rails.rb
 - test/unit/test_rails_compatibility.rb
 - test/unit/test_rails_reflect_on_association.rb
-- test/unit/test_railtie.rb
 - test/unit/test_serialization.rb
 - test/unit/test_time_zones.rb
 - test/unit/test_translation.rb
@@ -227,7 +226,7 @@ files:
 - LICENSE
 - UPGRADES
 - README.rdoc
-homepage: http://github.com/jnunemaker/mongomapper
+homepage: http://mongomapper.com
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -241,7 +240,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1944766579498551313
+      hash: -335898215056105210
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -250,7 +249,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1944766579498551313
+      hash: -335898215056105210
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10

data/test/unit/test_railtie.rb

@@ -1,66 +0,0 @@
-require 'test_helper'
-require "rails"
-require 'mongo_mapper/railtie'
-
-class TestRailtie < Test::Unit::TestCase
-
-  def expect_descendants(expectation)
-    # Keep expectation a string so we don't accidentally load in a class
-    Railtie::Parent.descendants.map(&:to_s).sort.should == expectation.sort
-  end
-
-  def run_initializer(mod, name)
-    initializer = mod.initializers.detect do |i|
-      i.name == name
-    end
-
-    if initializer.nil?
-      raise 'Initializer not found'
-    end
-
-    initializer.block.arity == -1 ? initializer.run : initializer.run(FakeRails)
-    # mongo_mapper.prepare_dispatcher takes a Rails app as its one arg,
-    # set_clear_dependencies_hook takes no args
-  end
-
-  def load_autoloaded_class
-    Railtie::Autoloaded.presence
-  end
-
-  class FakeRails
-    def self.config
-      return Class.new { def cache_classes ; false ; end }.new
-    end
-  end
-
-  context "Railtie" do
-    include Rails::Application::Bootstrap
-
-    setup do
-      require 'support/railtie'
-      require 'support/railtie/parent'
-      require 'support/railtie/not_autoloaded'
-
-      ActiveSupport::Dependencies.autoload_paths << File.join(File.dirname(__FILE__), '..', 'support')
-
-      # These initializers don't actually run anything, they just register cleanup and prepare hooks
-      run_initializer Rails::Application::Bootstrap, :set_clear_dependencies_hook
-      run_initializer MongoMapper::Railtie, 'mongo_mapper.prepare_dispatcher'
-    end
-
-    should "not clear ActiveSupport::DescendantsTracker" do
-      expect_descendants %w( Railtie::NotAutoloaded )
-      load_autoloaded_class
-      expect_descendants %w( Railtie::NotAutoloaded Railtie::Autoloaded )
-
-      ActionDispatch::Reloader.cleanup! # cleanup 'last request'
-
-      expect_descendants %w( Railtie::NotAutoloaded )
-      load_autoloaded_class
-      expect_descendants %w( Railtie::NotAutoloaded Railtie::Autoloaded )
-
-      ActionDispatch::Reloader.prepare! # prepare 'next request'
-      expect_descendants %w( Railtie::NotAutoloaded Railtie::Autoloaded )
-    end
-  end
-end