Clean up theme check in PackageManager with PackageActivators

You can now call `PackageManager.registerPackageActivator` for specific
package types. On `PackageManager.activate` it will call your
`PackageActivator.activatePackages(packages)` with the proper packages.

spec/atom-spec.coffee

@@ -341,33 +341,37 @@ describe "the `atom` global", ->
           atom.deactivatePackage('language-ruby')
           expect(syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
 
-    describe ".activatePackages()", ->
+    describe ".activate()", ->
+      packageActivator = null
+      themeActivator = null
+
       beforeEach ->
         spyOn(console, 'warn')
         atom.packages.loadPackages()
 
+        loadedPackages = atom.packages.getLoadedPackages()
+        expect(loadedPackages.length).toBeGreaterThan 0
+
+        packageActivator = spyOn(atom.packages, 'activatePackages')
+        themeActivator = spyOn(atom.themes, 'activatePackages')
+
       afterEach ->
-        atom.packages.deactivatePackages()
         atom.packages.unloadPackages()
 
         Syntax = require '../src/syntax'
         atom.syntax = window.syntax = new Syntax()
 
       it "activates all the packages, and none of the themes", ->
-        atom.packages.activatePackages()
-        loadedPackages = atom.packages.getLoadedPackages()
-        expect(loadedPackages.length).toBeGreaterThan 0
-        hasTheme = false
-        for pack in loadedPackages
-          if pack.isTheme()
-            hasTheme = true
-            break
+        atom.packages.activate()
 
-        expect(hasTheme).toBeTruthy()
+        expect(packageActivator).toHaveBeenCalled()
+        expect(themeActivator).toHaveBeenCalled()
 
-        activatedPackages = atom.packages.getActivePackages()
-        expect(activatedPackages.length).toBeGreaterThan 0
-        expect(pack.isTheme()).toBeFalsy() for pack in activatedPackages
+        packages = packageActivator.mostRecentCall.args[0]
+        expect(['atom', 'textmate']).toContain(pack.getType()) for pack in packages
+
+        themes = themeActivator.mostRecentCall.args[0]
+        expect(['theme']).toContain(theme.getType()) for theme in themes
 
     describe ".en/disablePackage()", ->
       describe "with packages", ->

src/package-manager.coffee

@@ -33,6 +33,9 @@ class PackageManager
     @packageStates = {}
     @observingDisabledPackages = false
 
+    @packageActivators = []
+    @registerPackageActivator(this, ['atom', 'textmate'])
+
   getPackageState: (name) ->
     @packageStates[name]
 
@@ -51,12 +54,23 @@ class PackageManager
     pack?.disable()
     pack
 
-  activatePackages: ->
-    # ThemeManager handles themes. Only activate non theme packages
-    # This is the only part I dislike
-    @activatePackage(pack.name) for pack in @getLoadedPackages() when not pack.isTheme()
+  # Internal-only: Activate all the packages that should be activated.
+  activate: ->
+    for [activator, types] in @packageActivators
+      packages = @getLoadedPackagesForTypes(types)
+      activator.activatePackages(packages)
+
+  # Public: another type of package manager can handle other package types.
+  # See ThemeManager
+  registerPackageActivator: (activator, types) ->
+    @packageActivators.push([activator, types])
+
+  # Internal-only:
+  activatePackages: (packages) ->
+    @activatePackage(pack.name) for pack in packages
     @observeDisabledPackages()
 
+  # Internal-only: Activate a single package by name
   activatePackage: (name, options) ->
     return pack if pack = @getActivePackage(name)
     if pack = @loadPackage(name, options)
@@ -143,6 +157,12 @@ class PackageManager
   getLoadedPackages: ->
     _.values(@loadedPackages)
 
+  # Private: Get packages for a certain package type
+  #
+  # * types: an {Array} of {String}s like ['atom', 'textmate']
+  getLoadedPackagesForTypes: (types) ->
+    pack for pack in @getLoadedPackages() when pack.getType() in types
+
   resolvePackagePath: (name) ->
     return name if fsUtils.isDirectorySync(name)
 

src/theme-manager.coffee

@@ -17,6 +17,7 @@ class ThemeManager
 
   constructor: (@packageManager) ->
     @lessCache = null
+    @packageManager.registerPackageActivator(this, ['theme'])
 
   # Internal-only:
   getAvailableNames: ->
@@ -38,6 +39,9 @@ class ThemeManager
   getLoadedThemes: ->
     pack for pack in @packageManager.getLoadedPackages() when pack.isTheme()
 
+  # Internal-only: adhere to the PackageActivator interface
+  activatePackages: (themePackages) -> @activateThemes()
+
   # Internal-only:
   activateThemes: ->
     # atom.config.observe runs the callback once, then on subsequent changes.

src/window.coffee

@@ -52,8 +52,7 @@ window.startEditorWindow = ->
   atom.themes.loadBaseStylesheets()
   atom.packages.loadPackages()
   deserializeEditorWindow()
-  atom.themes.activateThemes()
-  atom.packages.activatePackages()
+  atom.packages.activate()
   atom.keymap.loadUserKeymaps()
   atom.requireUserInitScript()
   atom.menu.update()