Extract serialize functionality from ::deactivatePackage. Tests WIP

spec/package-manager-spec.coffee

@@ -444,20 +444,18 @@ describe "PackageManager", ->
         runs ->
           expect(console.warn).not.toHaveBeenCalled()
 
-    it "passes the activate method the package's previously serialized state if it exists", ->
-      pack = null
+    fit "passes the activate method the package's previously serialized state if it exists", ->
+      pack = atom.packages.loadPackage("package-with-serialization")
       waitsForPromise ->
-        atom.packages.activatePackage("package-with-serialization").then (p) -> pack = p
-
+        pack.activate()  # require main module
       runs ->
-        expect(pack.mainModule.someNumber).not.toBe 77
-        pack.mainModule.someNumber = 77
+        atom.packages.setPackageState("package-with-serialization", {someNumber: 77})
         atom.packages.deactivatePackage("package-with-serialization")
         spyOn(pack.mainModule, 'activate').andCallThrough()
-        waitsForPromise ->
-          atom.packages.activatePackage("package-with-serialization")
-        runs ->
-          expect(pack.mainModule.activate).toHaveBeenCalledWith({someNumber: 77})
+      waitsForPromise ->
+        atom.packages.activatePackage("package-with-serialization")
+      runs ->
+        expect(pack.mainModule.activate).toHaveBeenCalledWith({someNumber: 77})
 
     it "invokes ::onDidActivatePackage listeners with the activated package", ->
       activatedPackage = null
@@ -821,6 +819,40 @@ describe "PackageManager", ->
           expect(atom.packages.isPackageActive("package-with-missing-provided-services")).toBe true
           expect(addErrorHandler.callCount).toBe 0
 
+  describe "::serialize", ->
+    # TODO
+
+  describe "::serializePackage(pack)", ->
+    # afterEach ->
+    #   atom.packages.unloadPackages()
+
+    fit "does not serialize packages that have not been activated called on their main module", ->
+      spyOn(console, 'warn')
+      badPack = null
+      waitsForPromise ->
+        atom.packages.activatePackage("package-that-throws-on-activate").then (p) -> badPack = p
+
+      runs ->
+        spyOn(badPack.mainModule, 'serialize').andCallThrough()
+
+        atom.packages.serializePackage(badPack)
+        expect(badPack.mainModule.serialize).not.toHaveBeenCalled()
+
+    fit "absorbs exceptions that are thrown by the package module's serialize method", ->
+      spyOn(console, 'error')
+
+      waitsForPromise ->
+        atom.packages.activatePackage('package-with-serialize-error')
+
+      waitsForPromise ->
+        atom.packages.activatePackage('package-with-serialization')
+
+      runs ->
+        atom.packages.deactivatePackages()
+        expect(atom.packages.packageStates['package-with-serialize-error']).toBeUndefined()
+        expect(atom.packages.packageStates['package-with-serialization']).toEqual someNumber: 1
+        expect(console.error).toHaveBeenCalled()
+
   describe "::deactivatePackage(id)", ->
     afterEach ->
       atom.packages.unloadPackages()
@@ -852,33 +884,6 @@ describe "PackageManager", ->
         expect(badPack.mainModule.deactivate).not.toHaveBeenCalled()
         expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeFalsy()
 
-    it "does not serialize packages that have not been activated called on their main module", ->
-      spyOn(console, 'warn')
-      badPack = null
-      waitsForPromise ->
-        atom.packages.activatePackage("package-that-throws-on-activate").then (p) -> badPack = p
-
-      runs ->
-        spyOn(badPack.mainModule, 'serialize').andCallThrough()
-
-        atom.packages.deactivatePackage("package-that-throws-on-activate")
-        expect(badPack.mainModule.serialize).not.toHaveBeenCalled()
-
-    it "absorbs exceptions that are thrown by the package module's serialize method", ->
-      spyOn(console, 'error')
-
-      waitsForPromise ->
-        atom.packages.activatePackage('package-with-serialize-error')
-
-      waitsForPromise ->
-        atom.packages.activatePackage('package-with-serialization')
-
-      runs ->
-        atom.packages.deactivatePackages()
-        expect(atom.packages.packageStates['package-with-serialize-error']).toBeUndefined()
-        expect(atom.packages.packageStates['package-with-serialization']).toEqual someNumber: 1
-        expect(console.error).toHaveBeenCalled()
-
     it "absorbs exceptions that are thrown by the package module's deactivate method", ->
       spyOn(console, 'error')
 

src/package-manager.coffee

@@ -467,6 +467,15 @@ class PackageManager
     return unless hook? and _.isString(hook) and hook.length > 0
     @activationHookEmitter.on(hook, callback)
 
+  serialize: ->
+    for pack in @getLoadedPackages()
+      @serializePackage(pack)
+    @packageStates
+
+  serializePackage: (pack) ->
+    if @isPackageActive(pack.name)
+      @setPackageState(pack.name, state) if state = pack.serialize?()
+
   # Deactivate all packages
   deactivatePackages: ->
     @config.transact =>
@@ -478,8 +487,6 @@ class PackageManager
   # Deactivate the package with the given name
   deactivatePackage: (name) ->
     pack = @getLoadedPackage(name)
-    if @isPackageActive(name)
-      @setPackageState(pack.name, state) if state = pack.serialize?()
     pack.deactivate()
     delete @activePackages[pack.name]
     delete @activatingPackages[pack.name]