Return a Disposable instance from DeserializerManager::add

spec/deserializer-manager-spec.coffee

@@ -1,33 +1,44 @@
 DeserializerManager = require '../src/deserializer-manager'
 
-describe ".deserialize(state)", ->
+describe "DeserializerManager", ->
-  deserializer = null
+  manager = null
 
   class Foo
     @deserialize: ({name}) -> new Foo(name)
     constructor: (@name) ->
 
   beforeEach ->
-    deserializer = new DeserializerManager()
+    manager = new DeserializerManager
-    deserializer.add(Foo)
 
-  it "calls deserialize on the deserializer for the given state object, or returns undefined if one can't be found", ->
+  describe "::add(deserializer)", ->
-    spyOn(console, 'warn')
+    it "returns a disposable that can be used to remove the manager", ->
-    object = deserializer.deserialize({ deserializer: 'Foo', name: 'Bar' })
+      disposable = manager.add(Foo)
-    expect(object.name).toBe 'Bar'
+      expect(manager.deserialize({deserializer: 'Foo', name: 'Bar'})).toBeDefined()
-    expect(deserializer.deserialize({ deserializer: 'Bogus' })).toBeUndefined()
+      disposable.dispose()
+      spyOn(console, 'warn')
+      expect(manager.deserialize({deserializer: 'Foo', name: 'Bar'})).toBeUndefined()
 
-  describe "when the deserializer has a version", ->
+  describe "::deserialize(state)", ->
     beforeEach ->
-      Foo.version = 2
+      manager.add(Foo)
 
-    describe "when the deserialized state has a matching version", ->
+    it "calls deserialize on the manager for the given state object, or returns undefined if one can't be found", ->
-      it "attempts to deserialize the state", ->
+      spyOn(console, 'warn')
-        object = deserializer.deserialize({ deserializer: 'Foo', version: 2, name: 'Bar' })
+      object = manager.deserialize({deserializer: 'Foo', name: 'Bar'})
-        expect(object.name).toBe 'Bar'
+      expect(object.name).toBe 'Bar'
+      expect(manager.deserialize({deserializer: 'Bogus'})).toBeUndefined()
 
-    describe "when the deserialized state has a non-matching version", ->
+    describe "when the manager has a version", ->
-      it "returns undefined", ->
+      beforeEach ->
-        expect(deserializer.deserialize({ deserializer: 'Foo', version: 3, name: 'Bar' })).toBeUndefined()
+        Foo.version = 2
-        expect(deserializer.deserialize({ deserializer: 'Foo', version: 1, name: 'Bar' })).toBeUndefined()
+
-        expect(deserializer.deserialize({ deserializer: 'Foo', name: 'Bar' })).toBeUndefined()
+      describe "when the deserialized state has a matching version", ->
+        it "attempts to deserialize the state", ->
+          object = manager.deserialize({deserializer: 'Foo', version: 2, name: 'Bar'})
+          expect(object.name).toBe 'Bar'
+
+      describe "when the deserialized state has a non-matching version", ->
+        it "returns undefined", ->
+          expect(manager.deserialize({deserializer: 'Foo', version: 3, name: 'Bar'})).toBeUndefined()
+          expect(manager.deserialize({deserializer: 'Foo', version: 1, name: 'Bar'})).toBeUndefined()
+          expect(manager.deserialize({deserializer: 'Foo', name: 'Bar'})).toBeUndefined()

src/deserializer-manager.coffee

@@ -1,3 +1,5 @@
+{Disposable} = require 'event-kit'
+
 # Extended: Manages the deserializers used for serialized state
 #
 # An instance of this class is always available as the `atom.deserializers`
@@ -27,6 +29,8 @@ class DeserializerManager
   # * `classes` One or more classes to register.
   add: (classes...) ->
     @deserializers[klass.name] = klass for klass in classes
+    new Disposable =>
+      delete @deserializers[klass.name] for klass in classes
 
   # Public: Remove the given class(es) as deserializers.
   #