From d999b4eca002f43aeb5a8c256183eee7a7d9b7c6 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 13:39:44 -0800 Subject: [PATCH 01/13] Deprecate ThemeManager::setEnabledThemes Suggest direct config write instead. Signed-off-by: Max Brunsfeld --- src/theme-manager.coffee | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/theme-manager.coffee b/src/theme-manager.coffee index 0379066ca..99fb7ccd2 100644 --- a/src/theme-manager.coffee +++ b/src/theme-manager.coffee @@ -195,10 +195,11 @@ class ThemeManager # the first/top theme to override later themes in the stack. themeNames.reverse() - # Public: Set the list of enabled themes. + # Set the list of enabled themes. # # * `enabledThemeNames` An {Array} of {String} theme names. setEnabledThemes: (enabledThemeNames) -> + Grim.deprecate("Use `atom.config.set('core.themes', arrayOfThemeNames)` instead") atom.config.set('core.themes', enabledThemeNames) ### From 30513cfde0c36ebdf07da7621d44cda7f1926df6 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 17:51:09 -0800 Subject: [PATCH 02/13] Rename ThemeManager methods for clarity/consistency Signed-off-by: Max Brunsfeld --- spec/package-manager-spec.coffee | 11 +++++---- spec/text-editor-element-spec.coffee | 2 +- spec/theme-manager-spec.coffee | 36 ++++++++++++++-------------- src/atom.coffee | 2 +- src/text-editor-component.coffee | 2 +- src/theme-manager.coffee | 20 ++++++++++++---- 6 files changed, 43 insertions(+), 30 deletions(-) diff --git a/spec/package-manager-spec.coffee b/spec/package-manager-spec.coffee index 66c6167dd..6539f6faa 100644 --- a/spec/package-manager-spec.coffee +++ b/spec/package-manager-spec.coffee @@ -645,7 +645,7 @@ describe "PackageManager", -> expect(console.warn.callCount).toBe 1 describe "with themes", -> - reloadedHandler = null + didChangeActiveThemesHandler = null beforeEach -> waitsForPromise -> @@ -670,17 +670,18 @@ describe "PackageManager", -> expect(atom.config.get('core.themes')).toContain packageName expect(atom.config.get('core.disabledPackages')).not.toContain packageName - reloadedHandler = jasmine.createSpy('reloadedHandler') - reloadedHandler.reset() - atom.themes.onDidReloadAll reloadedHandler + didChangeActiveThemesHandler = jasmine.createSpy('didChangeActiveThemesHandler') + didChangeActiveThemesHandler.reset() + atom.themes.onDidChangeActiveThemes didChangeActiveThemesHandler pack = atom.packages.disablePackage(packageName) waitsFor -> - reloadedHandler.callCount is 1 + didChangeActiveThemesHandler.callCount is 1 runs -> expect(atom.packages.getActivePackages()).not.toContain pack expect(atom.config.get('core.themes')).not.toContain packageName expect(atom.config.get('core.themes')).not.toContain packageName expect(atom.config.get('core.disabledPackages')).not.toContain packageName + diff --git a/spec/text-editor-element-spec.coffee b/spec/text-editor-element-spec.coffee index 9517b1c34..35e13fb17 100644 --- a/spec/text-editor-element-spec.coffee +++ b/spec/text-editor-element-spec.coffee @@ -107,7 +107,7 @@ describe "TextEditorElement", -> spyOn(atom.themes, 'isInitialLoadComplete').andCallFake -> initialThemeLoadComplete - spyOn(atom.themes, 'onDidReloadAll').andCallFake (fn) -> + spyOn(atom.themes, 'onDidChangeActiveThemes').andCallFake (fn) -> themeReloadCallback = fn atom.config.set("editor.useShadowDOM", false) diff --git a/spec/theme-manager-spec.coffee b/spec/theme-manager-spec.coffee index fc9624f93..d74e9d74b 100644 --- a/spec/theme-manager-spec.coffee +++ b/spec/theme-manager-spec.coffee @@ -73,54 +73,54 @@ describe "ThemeManager", -> describe "when the core.themes config value changes", -> it "add/removes stylesheets to reflect the new config value", -> - themeManager.onDidReloadAll reloadHandler = jasmine.createSpy() + themeManager.onDidChangeActiveThemes didChangeActiveThemesHandler = jasmine.createSpy() spyOn(atom.styles, 'getUserStyleSheetPath').andCallFake -> null waitsForPromise -> themeManager.activateThemes() runs -> - reloadHandler.reset() + didChangeActiveThemesHandler.reset() atom.config.set('core.themes', []) waitsFor -> - reloadHandler.callCount == 1 + didChangeActiveThemesHandler.callCount == 1 runs -> - reloadHandler.reset() + didChangeActiveThemesHandler.reset() expect($('style.theme')).toHaveLength 0 atom.config.set('core.themes', ['atom-dark-ui']) waitsFor -> - reloadHandler.callCount == 1 + didChangeActiveThemesHandler.callCount == 1 runs -> - reloadHandler.reset() + didChangeActiveThemesHandler.reset() expect($('style[priority=1]')).toHaveLength 2 expect($('style[priority=1]:eq(0)').attr('source-path')).toMatch /atom-dark-ui/ atom.config.set('core.themes', ['atom-light-ui', 'atom-dark-ui']) waitsFor -> - reloadHandler.callCount == 1 + didChangeActiveThemesHandler.callCount == 1 runs -> - reloadHandler.reset() + didChangeActiveThemesHandler.reset() expect($('style[priority=1]')).toHaveLength 2 expect($('style[priority=1]:eq(0)').attr('source-path')).toMatch /atom-dark-ui/ expect($('style[priority=1]:eq(1)').attr('source-path')).toMatch /atom-light-ui/ atom.config.set('core.themes', []) waitsFor -> - reloadHandler.callCount == 1 + didChangeActiveThemesHandler.callCount == 1 runs -> - reloadHandler.reset() + didChangeActiveThemesHandler.reset() expect($('style[priority=1]')).toHaveLength 2 # atom-dark-ui has an directory path, the syntax one doesn't atom.config.set('core.themes', ['theme-with-index-less', 'atom-dark-ui']) waitsFor -> - reloadHandler.callCount == 1 + didChangeActiveThemesHandler.callCount == 1 runs -> expect($('style[priority=1]')).toHaveLength 2 @@ -130,7 +130,7 @@ describe "ThemeManager", -> it 'adds theme-* classes to the workspace for each active theme', -> workspaceElement = atom.views.getView(atom.workspace) - themeManager.onDidReloadAll reloadHandler = jasmine.createSpy() + themeManager.onDidChangeActiveThemes didChangeActiveThemesHandler = jasmine.createSpy() waitsForPromise -> themeManager.activateThemes() @@ -138,11 +138,11 @@ describe "ThemeManager", -> runs -> expect(workspaceElement).toHaveClass 'theme-atom-dark-ui' - themeManager.onDidReloadAll reloadHandler = jasmine.createSpy() + themeManager.onDidChangeActiveThemes didChangeActiveThemesHandler = jasmine.createSpy() atom.config.set('core.themes', ['theme-with-ui-variables', 'theme-with-syntax-variables']) waitsFor -> - reloadHandler.callCount > 0 + didChangeActiveThemesHandler.callCount > 0 runs -> # `theme-` twice as it prefixes the name with `theme-` @@ -259,11 +259,11 @@ describe "ThemeManager", -> themeManager.activateThemes() it "loads the correct values from the theme's ui-variables file", -> - themeManager.onDidReloadAll reloadHandler = jasmine.createSpy() + themeManager.onDidChangeActiveThemes didChangeActiveThemesHandler = jasmine.createSpy() atom.config.set('core.themes', ['theme-with-ui-variables', 'theme-with-syntax-variables']) waitsFor -> - reloadHandler.callCount > 0 + didChangeActiveThemesHandler.callCount > 0 runs -> # an override loaded in the base css @@ -276,11 +276,11 @@ describe "ThemeManager", -> describe "when there is a theme with incomplete variables", -> it "loads the correct values from the fallback ui-variables", -> - themeManager.onDidReloadAll reloadHandler = jasmine.createSpy() + themeManager.onDidChangeActiveThemes didChangeActiveThemesHandler = jasmine.createSpy() atom.config.set('core.themes', ['theme-with-incomplete-ui-variables', 'theme-with-syntax-variables']) waitsFor -> - reloadHandler.callCount > 0 + didChangeActiveThemesHandler.callCount > 0 runs -> # an override loaded in the base css diff --git a/src/atom.coffee b/src/atom.coffee index 891ae9273..8d5053254 100644 --- a/src/atom.coffee +++ b/src/atom.coffee @@ -721,7 +721,7 @@ class Atom extends Model @themes.load() watchThemes: -> - @themes.onDidReloadAll => + @themes.onDidChangeActiveThemes => # Only reload stylesheets from non-theme packages for pack in @packages.getActivePackages() when pack.getType() isnt 'theme' pack.reloadStylesheets?() diff --git a/src/text-editor-component.coffee b/src/text-editor-component.coffee index e009c16e4..9edbfc99b 100644 --- a/src/text-editor-component.coffee +++ b/src/text-editor-component.coffee @@ -185,7 +185,7 @@ TextEditorComponent = React.createClass @subscribe stylesElement.onDidUpdateStyleElement @onStylesheetsChanged @subscribe stylesElement.onDidRemoveStyleElement @onStylesheetsChanged unless atom.themes.isInitialLoadComplete() - @subscribe atom.themes.onDidReloadAll @onAllThemesLoaded + @subscribe atom.themes.onDidChangeActiveThemes @onAllThemesLoaded @subscribe scrollbarStyle.changes, @refreshScrollbars @domPollingIntervalId = setInterval(@pollDOM, @domPollingInterval) diff --git a/src/theme-manager.coffee b/src/theme-manager.coffee index 99fb7ccd2..e9c21a6d2 100644 --- a/src/theme-manager.coffee +++ b/src/theme-manager.coffee @@ -61,8 +61,12 @@ class ThemeManager # updating the list of active themes have completed. # # * `callback` {Function} + onDidChangeActiveThemes: (callback) -> + @emitter.on 'did-change-active-themes', callback + onDidReloadAll: (callback) -> - @emitter.on 'did-reload-all', callback + Grim.deprecate("Use `::onDidChangeActiveThemes` instead.") + @onDidChangeActiveThemes(callback) # Deprecated: Invoke `callback` when a stylesheet has been added to the dom. # @@ -132,9 +136,13 @@ class ThemeManager ### # Public: Get an array of all the loaded theme names. - getLoadedNames: -> + getLoadedThemeNames: -> theme.name for theme in @getLoadedThemes() + getLoadedNames: -> + Grim.deprecate("Use `::getLoadedThemeNames` instead.") + @getLoadedThemeNames() + # Public: Get an array of all the loaded themes. getLoadedThemes: -> pack for pack in @packageManager.getLoadedPackages() when pack.isTheme() @@ -144,9 +152,13 @@ class ThemeManager ### # Public: Get an array of all the active theme names. - getActiveNames: -> + getActiveThemeNames: -> theme.name for theme in @getActiveThemes() + getActiveNames: -> + Grim.deprecate("Use `::getActiveThemeNames` instead.") + @getActiveThemeNames() + # Public: Get an array of all the active themes. getActiveThemes: -> pack for pack in @packageManager.getActivePackages() when pack.isTheme() @@ -323,7 +335,7 @@ class ThemeManager @reloadBaseStylesheets() @initialLoadComplete = true @emit 'reloaded' - @emitter.emit 'did-reload-all' + @emitter.emit 'did-change-active-themes' deferred.resolve() deferred.promise From 15fa19efa351b35356a18829f399a70b4b1f89ab Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 14:02:51 -0800 Subject: [PATCH 03/13] Rename onDidLoadAll -> onDidLoadInitialPackages Signed-off-by: Max Brunsfeld --- src/package-manager.coffee | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/package-manager.coffee b/src/package-manager.coffee index 4e39ce81f..e9064e01e 100644 --- a/src/package-manager.coffee +++ b/src/package-manager.coffee @@ -53,8 +53,12 @@ class PackageManager # * `callback` {Function} # # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe. + onDidLoadInitialPackages: (callback) -> + @emitter.on 'did-load-initial-packages', callback + onDidLoadAll: (callback) -> - @emitter.on 'did-load-all', callback + Grim.deprecate("Use `::onDidLoadInitialPackages` instead.") + @onDidLoadInitialPackages(callback) # Public: Invoke the given callback when all packages have been activated. # @@ -278,7 +282,7 @@ class PackageManager packagePaths = _.uniq packagePaths, (packagePath) -> path.basename(packagePath) @loadPackage(packagePath) for packagePath in packagePaths @emit 'loaded' - @emitter.emit 'did-load-all' + @emitter.emit 'did-load-initial-packages' loadPackage: (nameOrPath) -> return pack if pack = @getLoadedPackage(nameOrPath) From 010bd643c036832d4d3db7fefe82a126a70ba8e3 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 14:44:32 -0800 Subject: [PATCH 04/13] Rename onDidActivateAll -> onDidActivateInitialPackages Signed-off-by: Max Brunsfeld --- src/atom.coffee | 2 +- src/menu-manager.coffee | 2 +- src/package-manager.coffee | 10 +++++++--- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/src/atom.coffee b/src/atom.coffee index 8d5053254..c515f26be 100644 --- a/src/atom.coffee +++ b/src/atom.coffee @@ -280,7 +280,7 @@ class Atom extends Model deprecate "The atom.syntax global is deprecated. Use atom.grammars instead." @grammars - @subscribe @packages.onDidActivateAll => @watchThemes() + @subscribe @packages.onDidActivateInitialPackages => @watchThemes() Project = require './project' TextBuffer = require 'text-buffer' diff --git a/src/menu-manager.coffee b/src/menu-manager.coffee index bb4bfb2af..2c022cc32 100644 --- a/src/menu-manager.coffee +++ b/src/menu-manager.coffee @@ -61,7 +61,7 @@ class MenuManager @pendingUpdateOperation = null @template = [] atom.keymaps.onDidLoadBundledKeymaps => @loadPlatformItems() - atom.packages.onDidActivateAll => @sortPackagesMenu() + atom.packages.onDidActivateInitialPackages => @sortPackagesMenu() # Public: Adds the given items to the application menu. # diff --git a/src/package-manager.coffee b/src/package-manager.coffee index e9064e01e..e3cc1c2a2 100644 --- a/src/package-manager.coffee +++ b/src/package-manager.coffee @@ -65,15 +65,19 @@ class PackageManager # * `callback` {Function} # # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe. + onDidActivateInitialPackages: (callback) -> + @emitter.on 'did-activate-initial-packages', callback + onDidActivateAll: (callback) -> - @emitter.on 'did-activate-all', callback + Grim.deprecate("Use `::onDidActivateInitialPackages` instead.") + @onDidActivateInitialPackages(callback) on: (eventName) -> switch eventName when 'loaded' deprecate 'Use PackageManager::onDidLoadAll instead' when 'activated' - deprecate 'Use PackageManager::onDidActivateAll instead' + deprecate 'Use PackageManager::onDidActivateInitialPackages instead' else deprecate 'PackageManager::on is deprecated. Use event subscription methods instead.' EmitterMixin::on.apply(this, arguments) @@ -325,7 +329,7 @@ class PackageManager packages = @getLoadedPackagesForTypes(types) activator.activatePackages(packages) @emit 'activated' - @emitter.emit 'did-activate-all' + @emitter.emit 'did-activate-initial-packages' # another type of package manager can handle other package types. # See ThemeManager From 18ac0091a8cd200894f9270107a27e9dab8b59f3 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 15:33:56 -0800 Subject: [PATCH 05/13] =?UTF-8?q?Don=E2=80=99t=20call=20onDidActivateIniti?= =?UTF-8?q?alPackages=20listeners=20until=20the=20right=20time?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We wait until all packages without activation commands actually activate. Signed-off-by: Max Brunsfeld --- spec/package-manager-spec.coffee | 27 ++++++++++++++++++++------- src/package-manager.coffee | 14 ++++++++++---- 2 files changed, 30 insertions(+), 11 deletions(-) diff --git a/spec/package-manager-spec.coffee b/spec/package-manager-spec.coffee index 6539f6faa..baf65a277 100644 --- a/spec/package-manager-spec.coffee +++ b/spec/package-manager-spec.coffee @@ -570,9 +570,6 @@ describe "PackageManager", -> expect(atom.config.get('editor.commentStart', scope: ['.source.ruby'])).toBeUndefined() describe "::activate()", -> - packageActivator = null - themeActivator = null - beforeEach -> jasmine.snapshotDeprecations() spyOn(console, 'warn') @@ -581,9 +578,6 @@ describe "PackageManager", -> 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() @@ -593,6 +587,9 @@ describe "PackageManager", -> jasmine.restoreDeprecationsSnapshot() it "activates all the packages, and none of the themes", -> + packageActivator = spyOn(atom.packages, 'activatePackages') + themeActivator = spyOn(atom.themes, 'activatePackages') + atom.packages.activate() expect(packageActivator).toHaveBeenCalled() @@ -604,6 +601,23 @@ describe "PackageManager", -> themes = themeActivator.mostRecentCall.args[0] expect(['theme']).toContain(theme.getType()) for theme in themes + it "calls callbacks registered with ::onDidActivateInitialPackages", -> + package1 = atom.packages.loadPackage('package-with-main') + package2 = atom.packages.loadPackage('package-with-index') + package3 = atom.packages.loadPackage('package-with-activation-commands') + spyOn(atom.packages, 'getLoadedPackages').andReturn([package1, package2]) + + activateSpy = jasmine.createSpy('activateSpy') + atom.packages.onDidActivateInitialPackages(activateSpy) + + atom.packages.activate() + waitsFor -> activateSpy.callCount > 0 + runs -> + jasmine.unspy(atom.packages, 'getLoadedPackages') + expect(package1 in atom.packages.getActivePackages()).toBe true + expect(package2 in atom.packages.getActivePackages()).toBe true + expect(package3 in atom.packages.getActivePackages()).toBe false + describe "::enablePackage(id) and ::disablePackage(id)", -> describe "with packages", -> it "enables a disabled package", -> @@ -684,4 +698,3 @@ describe "PackageManager", -> expect(atom.config.get('core.themes')).not.toContain packageName expect(atom.config.get('core.themes')).not.toContain packageName expect(atom.config.get('core.disabledPackages')).not.toContain packageName - diff --git a/src/package-manager.coffee b/src/package-manager.coffee index e3cc1c2a2..cc335ce6a 100644 --- a/src/package-manager.coffee +++ b/src/package-manager.coffee @@ -325,11 +325,13 @@ class PackageManager # Activate all the packages that should be activated. activate: -> + promises = [] for [activator, types] in @packageActivators packages = @getLoadedPackagesForTypes(types) - activator.activatePackages(packages) - @emit 'activated' - @emitter.emit 'did-activate-initial-packages' + promises = promises.concat(activator.activatePackages(packages)) + Q.all(promises).then => + @emit 'activated' + @emitter.emit 'did-activate-initial-packages' # another type of package manager can handle other package types. # See ThemeManager @@ -337,9 +339,13 @@ class PackageManager @packageActivators.push([activator, types]) activatePackages: (packages) -> + promises = [] atom.config.transact => - @activatePackage(pack.name) for pack in packages + for pack in packages + promise = @activatePackage(pack.name) + promises.push(promise) unless pack.hasActivationCommands() @observeDisabledPackages() + promises # Activate a single package by name activatePackage: (name) -> From dbc88bde18bbb65ad8e3f6b12f1c7d28da536757 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 15:37:18 -0800 Subject: [PATCH 06/13] Remove special case in spec for packages converted from text-mate Signed-off-by: Max Brunsfeld --- spec/package-manager-spec.coffee | 622 +++++++++++++++---------------- 1 file changed, 301 insertions(+), 321 deletions(-) diff --git a/spec/package-manager-spec.coffee b/spec/package-manager-spec.coffee index baf65a277..603852cd1 100644 --- a/spec/package-manager-spec.coffee +++ b/spec/package-manager-spec.coffee @@ -62,383 +62,363 @@ describe "PackageManager", -> expect(atom.packages.isPackageLoaded(pack.name)).toBeFalsy() describe "::activatePackage(id)", -> - describe "atom packages", -> - describe "when called multiple times", -> - it "it only calls activate on the package once", -> - spyOn(Package.prototype, 'activateNow').andCallThrough() - waitsForPromise -> - atom.packages.activatePackage('package-with-index') - waitsForPromise -> - atom.packages.activatePackage('package-with-index') - waitsForPromise -> - atom.packages.activatePackage('package-with-index') - - runs -> - expect(Package.prototype.activateNow.callCount).toBe 1 - - describe "when the package has a main module", -> - describe "when the metadata specifies a main module path˜", -> - it "requires the module at the specified path", -> - mainModule = require('./fixtures/packages/package-with-main/main-module') - spyOn(mainModule, 'activate') - pack = null - waitsForPromise -> - atom.packages.activatePackage('package-with-main').then (p) -> pack = p - - runs -> - expect(mainModule.activate).toHaveBeenCalled() - expect(pack.mainModule).toBe mainModule - - describe "when the metadata does not specify a main module", -> - it "requires index.coffee", -> - indexModule = require('./fixtures/packages/package-with-index/index') - spyOn(indexModule, 'activate') - pack = null - waitsForPromise -> - atom.packages.activatePackage('package-with-index').then (p) -> pack = p - - runs -> - expect(indexModule.activate).toHaveBeenCalled() - expect(pack.mainModule).toBe indexModule - - it "assigns config schema, including defaults when package contains a schema", -> - expect(atom.config.get('package-with-config-schema.numbers.one')).toBeUndefined() - - waitsForPromise -> - atom.packages.activatePackage('package-with-config-schema') - - runs -> - expect(atom.config.get('package-with-config-schema.numbers.one')).toBe 1 - expect(atom.config.get('package-with-config-schema.numbers.two')).toBe 2 - - expect(atom.config.set('package-with-config-schema.numbers.one', 'nope')).toBe false - expect(atom.config.set('package-with-config-schema.numbers.one', '10')).toBe true - expect(atom.config.get('package-with-config-schema.numbers.one')).toBe 10 - - describe "when a package has configDefaults", -> - beforeEach -> - jasmine.snapshotDeprecations() - - afterEach -> - jasmine.restoreDeprecationsSnapshot() - - it "still assigns configDefaults from the module though deprecated", -> - - expect(atom.config.get('package-with-config-defaults.numbers.one')).toBeUndefined() - - waitsForPromise -> - atom.packages.activatePackage('package-with-config-defaults') - - runs -> - expect(atom.config.get('package-with-config-defaults.numbers.one')).toBe 1 - expect(atom.config.get('package-with-config-defaults.numbers.two')).toBe 2 - - describe "when the package metadata includes `activationCommands`", -> - [mainModule, promise, workspaceCommandListener] = [] - - beforeEach -> - jasmine.attachToDOM(workspaceElement) - mainModule = require './fixtures/packages/package-with-activation-commands/index' - mainModule.legacyActivationCommandCallCount = 0 - mainModule.activationCommandCallCount = 0 - spyOn(mainModule, 'activate').andCallThrough() - spyOn(Package.prototype, 'requireMainModule').andCallThrough() - - workspaceCommandListener = jasmine.createSpy('workspaceCommandListener') - atom.commands.add '.workspace', 'activation-command', workspaceCommandListener - - promise = atom.packages.activatePackage('package-with-activation-commands') - - it "defers requiring/activating the main module until an activation event bubbles to the root view", -> - expect(promise.isFulfilled()).not.toBeTruthy() - workspaceElement.dispatchEvent(new CustomEvent('activation-command', bubbles: true)) - - waitsForPromise -> - promise - - it "triggers the activation event on all handlers registered during activation", -> - waitsForPromise -> - atom.workspace.open() - - runs -> - editorView = atom.views.getView(atom.workspace.getActiveTextEditor()).__spacePenView - legacyCommandListener = jasmine.createSpy("legacyCommandListener") - editorView.command 'activation-command', legacyCommandListener - editorCommandListener = jasmine.createSpy("editorCommandListener") - atom.commands.add 'atom-text-editor', 'activation-command', editorCommandListener - atom.commands.dispatch(editorView[0], 'activation-command') - expect(mainModule.activate.callCount).toBe 1 - expect(mainModule.legacyActivationCommandCallCount).toBe 1 - expect(mainModule.activationCommandCallCount).toBe 1 - expect(legacyCommandListener.callCount).toBe 1 - expect(editorCommandListener.callCount).toBe 1 - expect(workspaceCommandListener.callCount).toBe 1 - atom.commands.dispatch(editorView[0], 'activation-command') - expect(mainModule.legacyActivationCommandCallCount).toBe 2 - expect(mainModule.activationCommandCallCount).toBe 2 - expect(legacyCommandListener.callCount).toBe 2 - expect(editorCommandListener.callCount).toBe 2 - expect(workspaceCommandListener.callCount).toBe 2 - expect(mainModule.activate.callCount).toBe 1 - - it "activates the package immediately when the events are empty", -> - mainModule = require './fixtures/packages/package-with-empty-activation-commands/index' - spyOn(mainModule, 'activate').andCallThrough() - - waitsForPromise -> - atom.packages.activatePackage('package-with-empty-activation-commands') - - runs -> - expect(mainModule.activate.callCount).toBe 1 - - describe "when the package has no main module", -> - it "does not throw an exception", -> - spyOn(console, "error") - spyOn(console, "warn").andCallThrough() - expect(-> atom.packages.activatePackage('package-without-module')).not.toThrow() - expect(console.error).not.toHaveBeenCalled() - expect(console.warn).not.toHaveBeenCalled() - - it "passes the activate method the package's previously serialized state if it exists", -> - pack = null + describe "when called multiple times", -> + it "it only calls activate on the package once", -> + spyOn(Package.prototype, 'activateNow').andCallThrough() waitsForPromise -> - atom.packages.activatePackage("package-with-serialization").then (p) -> pack = p + atom.packages.activatePackage('package-with-index') + waitsForPromise -> + atom.packages.activatePackage('package-with-index') + waitsForPromise -> + atom.packages.activatePackage('package-with-index') runs -> - expect(pack.mainModule.someNumber).not.toBe 77 - pack.mainModule.someNumber = 77 - atom.packages.deactivatePackage("package-with-serialization") - spyOn(pack.mainModule, 'activate').andCallThrough() + expect(Package.prototype.activateNow.callCount).toBe 1 + + describe "when the package has a main module", -> + describe "when the metadata specifies a main module path˜", -> + it "requires the module at the specified path", -> + mainModule = require('./fixtures/packages/package-with-main/main-module') + spyOn(mainModule, 'activate') + pack = null waitsForPromise -> - atom.packages.activatePackage("package-with-serialization") - runs -> - expect(pack.mainModule.activate).toHaveBeenCalledWith({someNumber: 77}) - - describe "when the package throws an error while loading", -> - it "logs a warning instead of throwing an exception", -> - atom.config.set("core.disabledPackages", []) - spyOn(console, "warn") - expect(-> atom.packages.activatePackage("package-that-throws-an-exception")).not.toThrow() - expect(console.warn).toHaveBeenCalled() - - describe "when the package is not found", -> - it "rejects the promise", -> - atom.config.set("core.disabledPackages", []) - - onSuccess = jasmine.createSpy('onSuccess') - onFailure = jasmine.createSpy('onFailure') - spyOn(console, 'warn') - - atom.packages.activatePackage("this-doesnt-exist").then(onSuccess, onFailure) - - waitsFor "promise to be rejected", -> - onFailure.callCount > 0 + atom.packages.activatePackage('package-with-main').then (p) -> pack = p runs -> - expect(console.warn.callCount).toBe 1 - expect(onFailure.mostRecentCall.args[0] instanceof Error).toBe true - expect(onFailure.mostRecentCall.args[0].message).toContain "Failed to load package 'this-doesnt-exist'" + expect(mainModule.activate).toHaveBeenCalled() + expect(pack.mainModule).toBe mainModule - describe "keymap loading", -> - describe "when the metadata does not contain a 'keymaps' manifest", -> - it "loads all the .cson/.json files in the keymaps directory", -> - element1 = $$ -> @div class: 'test-1' - element2 = $$ -> @div class: 'test-2' - element3 = $$ -> @div class: 'test-3' + describe "when the metadata does not specify a main module", -> + it "requires index.coffee", -> + indexModule = require('./fixtures/packages/package-with-index/index') + spyOn(indexModule, 'activate') + pack = null + waitsForPromise -> + atom.packages.activatePackage('package-with-index').then (p) -> pack = p - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])).toHaveLength 0 - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element2[0])).toHaveLength 0 + runs -> + expect(indexModule.activate).toHaveBeenCalled() + expect(pack.mainModule).toBe indexModule + + it "assigns config schema, including defaults when package contains a schema", -> + expect(atom.config.get('package-with-config-schema.numbers.one')).toBeUndefined() + + waitsForPromise -> + atom.packages.activatePackage('package-with-config-schema') + + runs -> + expect(atom.config.get('package-with-config-schema.numbers.one')).toBe 1 + expect(atom.config.get('package-with-config-schema.numbers.two')).toBe 2 + + expect(atom.config.set('package-with-config-schema.numbers.one', 'nope')).toBe false + expect(atom.config.set('package-with-config-schema.numbers.one', '10')).toBe true + expect(atom.config.get('package-with-config-schema.numbers.one')).toBe 10 + + describe "when a package has configDefaults", -> + beforeEach -> + jasmine.snapshotDeprecations() + + afterEach -> + jasmine.restoreDeprecationsSnapshot() + + it "still assigns configDefaults from the module though deprecated", -> + + expect(atom.config.get('package-with-config-defaults.numbers.one')).toBeUndefined() + + waitsForPromise -> + atom.packages.activatePackage('package-with-config-defaults') + + runs -> + expect(atom.config.get('package-with-config-defaults.numbers.one')).toBe 1 + expect(atom.config.get('package-with-config-defaults.numbers.two')).toBe 2 + + describe "when the package metadata includes `activationCommands`", -> + [mainModule, promise, workspaceCommandListener] = [] + + beforeEach -> + jasmine.attachToDOM(workspaceElement) + mainModule = require './fixtures/packages/package-with-activation-commands/index' + mainModule.legacyActivationCommandCallCount = 0 + mainModule.activationCommandCallCount = 0 + spyOn(mainModule, 'activate').andCallThrough() + spyOn(Package.prototype, 'requireMainModule').andCallThrough() + + workspaceCommandListener = jasmine.createSpy('workspaceCommandListener') + atom.commands.add '.workspace', 'activation-command', workspaceCommandListener + + promise = atom.packages.activatePackage('package-with-activation-commands') + + it "defers requiring/activating the main module until an activation event bubbles to the root view", -> + expect(promise.isFulfilled()).not.toBeTruthy() + workspaceElement.dispatchEvent(new CustomEvent('activation-command', bubbles: true)) + + waitsForPromise -> + promise + + it "triggers the activation event on all handlers registered during activation", -> + waitsForPromise -> + atom.workspace.open() + + runs -> + editorView = atom.views.getView(atom.workspace.getActiveTextEditor()).__spacePenView + legacyCommandListener = jasmine.createSpy("legacyCommandListener") + editorView.command 'activation-command', legacyCommandListener + editorCommandListener = jasmine.createSpy("editorCommandListener") + atom.commands.add 'atom-text-editor', 'activation-command', editorCommandListener + atom.commands.dispatch(editorView[0], 'activation-command') + expect(mainModule.activate.callCount).toBe 1 + expect(mainModule.legacyActivationCommandCallCount).toBe 1 + expect(mainModule.activationCommandCallCount).toBe 1 + expect(legacyCommandListener.callCount).toBe 1 + expect(editorCommandListener.callCount).toBe 1 + expect(workspaceCommandListener.callCount).toBe 1 + atom.commands.dispatch(editorView[0], 'activation-command') + expect(mainModule.legacyActivationCommandCallCount).toBe 2 + expect(mainModule.activationCommandCallCount).toBe 2 + expect(legacyCommandListener.callCount).toBe 2 + expect(editorCommandListener.callCount).toBe 2 + expect(workspaceCommandListener.callCount).toBe 2 + expect(mainModule.activate.callCount).toBe 1 + + it "activates the package immediately when the events are empty", -> + mainModule = require './fixtures/packages/package-with-empty-activation-commands/index' + spyOn(mainModule, 'activate').andCallThrough() + + waitsForPromise -> + atom.packages.activatePackage('package-with-empty-activation-commands') + + runs -> + expect(mainModule.activate.callCount).toBe 1 + + describe "when the package has no main module", -> + it "does not throw an exception", -> + spyOn(console, "error") + spyOn(console, "warn").andCallThrough() + expect(-> atom.packages.activatePackage('package-without-module')).not.toThrow() + expect(console.error).not.toHaveBeenCalled() + expect(console.warn).not.toHaveBeenCalled() + + it "passes the activate method the package's previously serialized state if it exists", -> + pack = null + waitsForPromise -> + atom.packages.activatePackage("package-with-serialization").then (p) -> pack = p + + runs -> + expect(pack.mainModule.someNumber).not.toBe 77 + pack.mainModule.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}) + + describe "when the package throws an error while loading", -> + it "logs a warning instead of throwing an exception", -> + atom.config.set("core.disabledPackages", []) + spyOn(console, "warn") + expect(-> atom.packages.activatePackage("package-that-throws-an-exception")).not.toThrow() + expect(console.warn).toHaveBeenCalled() + + describe "when the package is not found", -> + it "rejects the promise", -> + atom.config.set("core.disabledPackages", []) + + onSuccess = jasmine.createSpy('onSuccess') + onFailure = jasmine.createSpy('onFailure') + spyOn(console, 'warn') + + atom.packages.activatePackage("this-doesnt-exist").then(onSuccess, onFailure) + + waitsFor "promise to be rejected", -> + onFailure.callCount > 0 + + runs -> + expect(console.warn.callCount).toBe 1 + expect(onFailure.mostRecentCall.args[0] instanceof Error).toBe true + expect(onFailure.mostRecentCall.args[0].message).toContain "Failed to load package 'this-doesnt-exist'" + + describe "keymap loading", -> + describe "when the metadata does not contain a 'keymaps' manifest", -> + it "loads all the .cson/.json files in the keymaps directory", -> + element1 = $$ -> @div class: 'test-1' + element2 = $$ -> @div class: 'test-2' + element3 = $$ -> @div class: 'test-3' + + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])).toHaveLength 0 + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element2[0])).toHaveLength 0 + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element3[0])).toHaveLength 0 + + waitsForPromise -> + atom.packages.activatePackage("package-with-keymaps") + + runs -> + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])[0].command).toBe "test-1" + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element2[0])[0].command).toBe "test-2" expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element3[0])).toHaveLength 0 - waitsForPromise -> - atom.packages.activatePackage("package-with-keymaps") + describe "when the metadata contains a 'keymaps' manifest", -> + it "loads only the keymaps specified by the manifest, in the specified order", -> + element1 = $$ -> @div class: 'test-1' + element3 = $$ -> @div class: 'test-3' - runs -> - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])[0].command).toBe "test-1" - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element2[0])[0].command).toBe "test-2" - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element3[0])).toHaveLength 0 + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])).toHaveLength 0 - describe "when the metadata contains a 'keymaps' manifest", -> - it "loads only the keymaps specified by the manifest, in the specified order", -> - element1 = $$ -> @div class: 'test-1' - element3 = $$ -> @div class: 'test-3' + waitsForPromise -> + atom.packages.activatePackage("package-with-keymaps-manifest") - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])).toHaveLength 0 + runs -> + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])[0].command).toBe 'keymap-1' + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-n', target:element1[0])[0].command).toBe 'keymap-2' + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-y', target:element3[0])).toHaveLength 0 - waitsForPromise -> - atom.packages.activatePackage("package-with-keymaps-manifest") + describe "when the keymap file is empty", -> + it "does not throw an error on activation", -> + waitsForPromise -> + atom.packages.activatePackage("package-with-empty-keymap") - runs -> - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])[0].command).toBe 'keymap-1' - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-n', target:element1[0])[0].command).toBe 'keymap-2' - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-y', target:element3[0])).toHaveLength 0 + runs -> + expect(atom.packages.isPackageActive("package-with-empty-keymap")).toBe true - describe "when the keymap file is empty", -> - it "does not throw an error on activation", -> - waitsForPromise -> - atom.packages.activatePackage("package-with-empty-keymap") + describe "menu loading", -> + beforeEach -> + atom.contextMenu.definitions = [] + atom.menu.template = [] - runs -> - expect(atom.packages.isPackageActive("package-with-empty-keymap")).toBe true + describe "when the metadata does not contain a 'menus' manifest", -> + it "loads all the .cson/.json files in the menus directory", -> + element = ($$ -> @div class: 'test-1')[0] - describe "menu loading", -> - beforeEach -> - atom.contextMenu.definitions = [] - atom.menu.template = [] + expect(atom.contextMenu.templateForElement(element)).toEqual [] - describe "when the metadata does not contain a 'menus' manifest", -> - it "loads all the .cson/.json files in the menus directory", -> - element = ($$ -> @div class: 'test-1')[0] + waitsForPromise -> + atom.packages.activatePackage("package-with-menus") - expect(atom.contextMenu.templateForElement(element)).toEqual [] + runs -> + expect(atom.menu.template.length).toBe 2 + expect(atom.menu.template[0].label).toBe "Second to Last" + expect(atom.menu.template[1].label).toBe "Last" + expect(atom.contextMenu.templateForElement(element)[0].label).toBe "Menu item 1" + expect(atom.contextMenu.templateForElement(element)[1].label).toBe "Menu item 2" + expect(atom.contextMenu.templateForElement(element)[2].label).toBe "Menu item 3" - waitsForPromise -> - atom.packages.activatePackage("package-with-menus") + describe "when the metadata contains a 'menus' manifest", -> + it "loads only the menus specified by the manifest, in the specified order", -> + element = ($$ -> @div class: 'test-1')[0] - runs -> - expect(atom.menu.template.length).toBe 2 - expect(atom.menu.template[0].label).toBe "Second to Last" - expect(atom.menu.template[1].label).toBe "Last" - expect(atom.contextMenu.templateForElement(element)[0].label).toBe "Menu item 1" - expect(atom.contextMenu.templateForElement(element)[1].label).toBe "Menu item 2" - expect(atom.contextMenu.templateForElement(element)[2].label).toBe "Menu item 3" + expect(atom.contextMenu.templateForElement(element)).toEqual [] - describe "when the metadata contains a 'menus' manifest", -> - it "loads only the menus specified by the manifest, in the specified order", -> - element = ($$ -> @div class: 'test-1')[0] + waitsForPromise -> + atom.packages.activatePackage("package-with-menus-manifest") - expect(atom.contextMenu.templateForElement(element)).toEqual [] + runs -> + expect(atom.menu.template[0].label).toBe "Second to Last" + expect(atom.menu.template[1].label).toBe "Last" + expect(atom.contextMenu.templateForElement(element)[0].label).toBe "Menu item 2" + expect(atom.contextMenu.templateForElement(element)[1].label).toBe "Menu item 1" + expect(atom.contextMenu.templateForElement(element)[2]).toBeUndefined() - waitsForPromise -> - atom.packages.activatePackage("package-with-menus-manifest") + describe "when the menu file is empty", -> + it "does not throw an error on activation", -> + waitsForPromise -> + atom.packages.activatePackage("package-with-empty-menu") - runs -> - expect(atom.menu.template[0].label).toBe "Second to Last" - expect(atom.menu.template[1].label).toBe "Last" - expect(atom.contextMenu.templateForElement(element)[0].label).toBe "Menu item 2" - expect(atom.contextMenu.templateForElement(element)[1].label).toBe "Menu item 1" - expect(atom.contextMenu.templateForElement(element)[2]).toBeUndefined() + runs -> + expect(atom.packages.isPackageActive("package-with-empty-menu")).toBe true - describe "when the menu file is empty", -> - it "does not throw an error on activation", -> - waitsForPromise -> - atom.packages.activatePackage("package-with-empty-menu") + describe "stylesheet loading", -> + describe "when the metadata contains a 'stylesheets' manifest", -> + it "loads stylesheets from the stylesheets directory as specified by the manifest", -> + one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css") + two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less") + three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css") - runs -> - expect(atom.packages.isPackageActive("package-with-empty-menu")).toBe true + one = atom.themes.stringToId(one) + two = atom.themes.stringToId(two) + three = atom.themes.stringToId(three) - describe "stylesheet loading", -> - describe "when the metadata contains a 'stylesheets' manifest", -> - it "loads stylesheets from the stylesheets directory as specified by the manifest", -> - one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css") - two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less") - three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css") + expect(atom.themes.stylesheetElementForId(one)).toBeNull() + expect(atom.themes.stylesheetElementForId(two)).toBeNull() + expect(atom.themes.stylesheetElementForId(three)).toBeNull() - one = atom.themes.stringToId(one) - two = atom.themes.stringToId(two) - three = atom.themes.stringToId(three) + waitsForPromise -> + atom.packages.activatePackage("package-with-stylesheets-manifest") - expect(atom.themes.stylesheetElementForId(one)).toBeNull() - expect(atom.themes.stylesheetElementForId(two)).toBeNull() + runs -> + expect(atom.themes.stylesheetElementForId(one)).not.toBeNull() + expect(atom.themes.stylesheetElementForId(two)).not.toBeNull() expect(atom.themes.stylesheetElementForId(three)).toBeNull() + expect($('#jasmine-content').css('font-size')).toBe '1px' - waitsForPromise -> - atom.packages.activatePackage("package-with-stylesheets-manifest") + describe "when the metadata does not contain a 'stylesheets' manifest", -> + it "loads all stylesheets from the stylesheets directory", -> + one = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/1.css") + two = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/2.less") + three = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/3.test-context.css") + four = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/4.css") - runs -> - expect(atom.themes.stylesheetElementForId(one)).not.toBeNull() - expect(atom.themes.stylesheetElementForId(two)).not.toBeNull() - expect(atom.themes.stylesheetElementForId(three)).toBeNull() - expect($('#jasmine-content').css('font-size')).toBe '1px' + one = atom.themes.stringToId(one) + two = atom.themes.stringToId(two) + three = atom.themes.stringToId(three) + four = atom.themes.stringToId(four) - describe "when the metadata does not contain a 'stylesheets' manifest", -> - it "loads all stylesheets from the stylesheets directory", -> - one = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/1.css") - two = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/2.less") - three = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/3.test-context.css") - four = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/4.css") + expect(atom.themes.stylesheetElementForId(one)).toBeNull() + expect(atom.themes.stylesheetElementForId(two)).toBeNull() + expect(atom.themes.stylesheetElementForId(three)).toBeNull() + expect(atom.themes.stylesheetElementForId(four)).toBeNull() - one = atom.themes.stringToId(one) - two = atom.themes.stringToId(two) - three = atom.themes.stringToId(three) - four = atom.themes.stringToId(four) - - expect(atom.themes.stylesheetElementForId(one)).toBeNull() - expect(atom.themes.stylesheetElementForId(two)).toBeNull() - expect(atom.themes.stylesheetElementForId(three)).toBeNull() - expect(atom.themes.stylesheetElementForId(four)).toBeNull() - - waitsForPromise -> - atom.packages.activatePackage("package-with-stylesheets") - - runs -> - expect(atom.themes.stylesheetElementForId(one)).not.toBeNull() - expect(atom.themes.stylesheetElementForId(two)).not.toBeNull() - expect(atom.themes.stylesheetElementForId(three)).not.toBeNull() - expect(atom.themes.stylesheetElementForId(four)).not.toBeNull() - expect($('#jasmine-content').css('font-size')).toBe '3px' - - it "assigns the stylesheet's context based on the filename", -> waitsForPromise -> atom.packages.activatePackage("package-with-stylesheets") runs -> - count = 0 + expect(atom.themes.stylesheetElementForId(one)).not.toBeNull() + expect(atom.themes.stylesheetElementForId(two)).not.toBeNull() + expect(atom.themes.stylesheetElementForId(three)).not.toBeNull() + expect(atom.themes.stylesheetElementForId(four)).not.toBeNull() + expect($('#jasmine-content').css('font-size')).toBe '3px' - for styleElement in atom.styles.getStyleElements() - if styleElement.sourcePath.match /1.css/ - expect(styleElement.context).toBe undefined - count++ + it "assigns the stylesheet's context based on the filename", -> + waitsForPromise -> + atom.packages.activatePackage("package-with-stylesheets") - if styleElement.sourcePath.match /2.less/ - expect(styleElement.context).toBe undefined - count++ + runs -> + count = 0 - if styleElement.sourcePath.match /3.test-context.css/ - expect(styleElement.context).toBe 'test-context' - count++ + for styleElement in atom.styles.getStyleElements() + if styleElement.sourcePath.match /1.css/ + expect(styleElement.context).toBe undefined + count++ - if styleElement.sourcePath.match /4.css/ - expect(styleElement.context).toBe undefined - count++ + if styleElement.sourcePath.match /2.less/ + expect(styleElement.context).toBe undefined + count++ - expect(count).toBe 4 + if styleElement.sourcePath.match /3.test-context.css/ + expect(styleElement.context).toBe 'test-context' + count++ - describe "grammar loading", -> - it "loads the package's grammars", -> - waitsForPromise -> - atom.packages.activatePackage('package-with-grammars') + if styleElement.sourcePath.match /4.css/ + expect(styleElement.context).toBe undefined + count++ - runs -> - expect(atom.grammars.selectGrammar('a.alot').name).toBe 'Alot' - expect(atom.grammars.selectGrammar('a.alittle').name).toBe 'Alittle' + expect(count).toBe 4 - describe "scoped-property loading", -> - it "loads the scoped properties", -> - waitsForPromise -> - atom.packages.activatePackage("package-with-settings") - - runs -> - expect(atom.config.get 'editor.increaseIndentPattern', scope: ['.source.omg']).toBe '^a' - - describe "converted textmate packages", -> + describe "grammar loading", -> it "loads the package's grammars", -> - expect(atom.grammars.selectGrammar("file.rb").name).toBe "Null Grammar" - waitsForPromise -> - atom.packages.activatePackage('language-ruby') + atom.packages.activatePackage('package-with-grammars') runs -> - expect(atom.grammars.selectGrammar("file.rb").name).toBe "Ruby" - - it "loads the translated scoped properties", -> - expect(atom.config.get('editor.commentStart', scope: ['.source.ruby'])).toBeUndefined() + expect(atom.grammars.selectGrammar('a.alot').name).toBe 'Alot' + expect(atom.grammars.selectGrammar('a.alittle').name).toBe 'Alittle' + describe "scoped-property loading", -> + it "loads the scoped properties", -> waitsForPromise -> - atom.packages.activatePackage('language-ruby') + atom.packages.activatePackage("package-with-settings") runs -> - expect(atom.config.get('editor.commentStart', scope: ['.source.ruby'])).toBe '# ' + expect(atom.config.get 'editor.increaseIndentPattern', scope: ['.source.omg']).toBe '^a' describe "::deactivatePackage(id)", -> afterEach -> From a6c9244c77c27143ca4f351595521e729f6568e4 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 15:48:34 -0800 Subject: [PATCH 07/13] Add PackageManager::onDidActivatePackage Signed-off-by: Max Brunsfeld --- spec/package-manager-spec.coffee | 10 ++++++++++ src/package-manager.coffee | 10 ++++++++++ 2 files changed, 20 insertions(+) diff --git a/spec/package-manager-spec.coffee b/spec/package-manager-spec.coffee index 603852cd1..4628886e1 100644 --- a/spec/package-manager-spec.coffee +++ b/spec/package-manager-spec.coffee @@ -213,6 +213,16 @@ describe "PackageManager", -> runs -> expect(pack.mainModule.activate).toHaveBeenCalledWith({someNumber: 77}) + it "invokes ::onDidActivatePackage listeners with the activated package", -> + activatedPackage = null + atom.packages.onDidActivatePackage (pack) -> + activatedPackage = pack + + atom.packages.activatePackage('package-with-main') + + waitsFor -> activatedPackage? + runs -> expect(activatedPackage.name).toBe 'package-with-main' + describe "when the package throws an error while loading", -> it "logs a warning instead of throwing an exception", -> atom.config.set("core.disabledPackages", []) diff --git a/src/package-manager.coffee b/src/package-manager.coffee index cc335ce6a..e7f2aed3a 100644 --- a/src/package-manager.coffee +++ b/src/package-manager.coffee @@ -72,6 +72,15 @@ class PackageManager Grim.deprecate("Use `::onDidActivateInitialPackages` instead.") @onDidActivateInitialPackages(callback) + # Public: Invoke the given callback when a package is activated. + # + # * `callback` A {Function} to be invoked when a package is activated. + # * `package` The {Package} that was activated. + # + # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe. + onDidActivatePackage: (callback) -> + @emitter.on 'did-activate-package', callback + on: (eventName) -> switch eventName when 'loaded' @@ -354,6 +363,7 @@ class PackageManager else if pack = @loadPackage(name) pack.activate().then => @activePackages[pack.name] = pack + @emitter.emit 'did-activate-package', pack pack else Q.reject(new Error("Failed to load package '#{name}'")) From 6dd9834ae1e509fa8bf5b0c2d05e82ca0a5272cd Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 15:48:48 -0800 Subject: [PATCH 08/13] Remove defunct text-mate package specs --- spec/package-manager-spec.coffee | 177 ++++++++++++++----------------- 1 file changed, 78 insertions(+), 99 deletions(-) diff --git a/spec/package-manager-spec.coffee b/spec/package-manager-spec.coffee index 4628886e1..1c4c5cd41 100644 --- a/spec/package-manager-spec.coffee +++ b/spec/package-manager-spec.coffee @@ -434,130 +434,109 @@ describe "PackageManager", -> afterEach -> atom.packages.unloadPackages() - describe "atom packages", -> - it "calls `deactivate` on the package's main module if activate was successful", -> - pack = null - waitsForPromise -> - atom.packages.activatePackage("package-with-deactivate").then (p) -> pack = p + it "calls `deactivate` on the package's main module if activate was successful", -> + pack = null + waitsForPromise -> + atom.packages.activatePackage("package-with-deactivate").then (p) -> pack = p - runs -> - expect(atom.packages.isPackageActive("package-with-deactivate")).toBeTruthy() - spyOn(pack.mainModule, 'deactivate').andCallThrough() + runs -> + expect(atom.packages.isPackageActive("package-with-deactivate")).toBeTruthy() + spyOn(pack.mainModule, 'deactivate').andCallThrough() - atom.packages.deactivatePackage("package-with-deactivate") - expect(pack.mainModule.deactivate).toHaveBeenCalled() - expect(atom.packages.isPackageActive("package-with-module")).toBeFalsy() + atom.packages.deactivatePackage("package-with-deactivate") + expect(pack.mainModule.deactivate).toHaveBeenCalled() + expect(atom.packages.isPackageActive("package-with-module")).toBeFalsy() - spyOn(console, 'warn') - - badPack = null - waitsForPromise -> - atom.packages.activatePackage("package-that-throws-on-activate").then (p) -> badPack = p - - runs -> - expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeTruthy() - spyOn(badPack.mainModule, 'deactivate').andCallThrough() - - atom.packages.deactivatePackage("package-that-throws-on-activate") - 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() + badPack = null + waitsForPromise -> + atom.packages.activatePackage("package-that-throws-on-activate").then (p) -> badPack = p - atom.packages.deactivatePackage("package-that-throws-on-activate") - expect(badPack.mainModule.serialize).not.toHaveBeenCalled() + runs -> + expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeTruthy() + spyOn(badPack.mainModule, 'deactivate').andCallThrough() - it "absorbs exceptions that are thrown by the package module's serialize method", -> - spyOn(console, 'error') + atom.packages.deactivatePackage("package-that-throws-on-activate") + expect(badPack.mainModule.deactivate).not.toHaveBeenCalled() + expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeFalsy() - waitsForPromise -> - atom.packages.activatePackage('package-with-serialize-error') + 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 - waitsForPromise -> - atom.packages.activatePackage('package-with-serialization') + runs -> + spyOn(badPack.mainModule, 'serialize').andCallThrough() - 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() + 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 deactivate method", -> - spyOn(console, 'error') + it "absorbs exceptions that are thrown by the package module's serialize method", -> + spyOn(console, 'error') - waitsForPromise -> - atom.packages.activatePackage("package-that-throws-on-deactivate") + waitsForPromise -> + atom.packages.activatePackage('package-with-serialize-error') - runs -> - expect(-> atom.packages.deactivatePackage("package-that-throws-on-deactivate")).not.toThrow() - expect(console.error).toHaveBeenCalled() + waitsForPromise -> + atom.packages.activatePackage('package-with-serialization') - it "removes the package's grammars", -> - waitsForPromise -> - atom.packages.activatePackage('package-with-grammars') + 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() - runs -> - atom.packages.deactivatePackage('package-with-grammars') - expect(atom.grammars.selectGrammar('a.alot').name).toBe 'Null Grammar' - expect(atom.grammars.selectGrammar('a.alittle').name).toBe 'Null Grammar' + it "absorbs exceptions that are thrown by the package module's deactivate method", -> + spyOn(console, 'error') - it "removes the package's keymaps", -> - waitsForPromise -> - atom.packages.activatePackage('package-with-keymaps') + waitsForPromise -> + atom.packages.activatePackage("package-that-throws-on-deactivate") - runs -> - atom.packages.deactivatePackage('package-with-keymaps') - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target: ($$ -> @div class: 'test-1')[0])).toHaveLength 0 - expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target: ($$ -> @div class: 'test-2')[0])).toHaveLength 0 + runs -> + expect(-> atom.packages.deactivatePackage("package-that-throws-on-deactivate")).not.toThrow() + expect(console.error).toHaveBeenCalled() - it "removes the package's stylesheets", -> - waitsForPromise -> - atom.packages.activatePackage('package-with-stylesheets') + it "removes the package's grammars", -> + waitsForPromise -> + atom.packages.activatePackage('package-with-grammars') - runs -> - atom.packages.deactivatePackage('package-with-stylesheets') - one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css") - two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less") - three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css") - expect(atom.themes.stylesheetElementForId(one)).not.toExist() - expect(atom.themes.stylesheetElementForId(two)).not.toExist() - expect(atom.themes.stylesheetElementForId(three)).not.toExist() + runs -> + atom.packages.deactivatePackage('package-with-grammars') + expect(atom.grammars.selectGrammar('a.alot').name).toBe 'Null Grammar' + expect(atom.grammars.selectGrammar('a.alittle').name).toBe 'Null Grammar' - it "removes the package's scoped-properties", -> - waitsForPromise -> - atom.packages.activatePackage("package-with-settings") + it "removes the package's keymaps", -> + waitsForPromise -> + atom.packages.activatePackage('package-with-keymaps') - runs -> - expect(atom.config.get 'editor.increaseIndentPattern', scope: ['.source.omg']).toBe '^a' - atom.packages.deactivatePackage("package-with-settings") - expect(atom.config.get 'editor.increaseIndentPattern', scope: ['.source.omg']).toBeUndefined() + runs -> + atom.packages.deactivatePackage('package-with-keymaps') + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target: ($$ -> @div class: 'test-1')[0])).toHaveLength 0 + expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target: ($$ -> @div class: 'test-2')[0])).toHaveLength 0 - describe "textmate packages", -> - it "removes the package's grammars", -> - expect(atom.grammars.selectGrammar("file.rb").name).toBe "Null Grammar" + it "removes the package's stylesheets", -> + waitsForPromise -> + atom.packages.activatePackage('package-with-stylesheets') - waitsForPromise -> - atom.packages.activatePackage('language-ruby') + runs -> + atom.packages.deactivatePackage('package-with-stylesheets') + one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css") + two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less") + three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css") + expect(atom.themes.stylesheetElementForId(one)).not.toExist() + expect(atom.themes.stylesheetElementForId(two)).not.toExist() + expect(atom.themes.stylesheetElementForId(three)).not.toExist() - runs -> - expect(atom.grammars.selectGrammar("file.rb").name).toBe "Ruby" - atom.packages.deactivatePackage('language-ruby') - expect(atom.grammars.selectGrammar("file.rb").name).toBe "Null Grammar" + it "removes the package's scoped-properties", -> + waitsForPromise -> + atom.packages.activatePackage("package-with-settings") - it "removes the package's scoped properties", -> - waitsForPromise -> - atom.packages.activatePackage('language-ruby') - - runs -> - atom.packages.deactivatePackage('language-ruby') - expect(atom.config.get('editor.commentStart', scope: ['.source.ruby'])).toBeUndefined() + runs -> + expect(atom.config.get 'editor.increaseIndentPattern', scope: ['.source.omg']).toBe '^a' + atom.packages.deactivatePackage("package-with-settings") + expect(atom.config.get 'editor.increaseIndentPattern', scope: ['.source.omg']).toBeUndefined() describe "::activate()", -> beforeEach -> From 7acf3d4d6b9eb25d8fdd54f6a1b51cf82fbb3283 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 15:52:46 -0800 Subject: [PATCH 09/13] Add PackageManager::onDidDeactivatePackage --- spec/package-manager-spec.coffee | 10 ++++++++++ src/package-manager.coffee | 10 ++++++++++ 2 files changed, 20 insertions(+) diff --git a/spec/package-manager-spec.coffee b/spec/package-manager-spec.coffee index 1c4c5cd41..75aada8fa 100644 --- a/spec/package-manager-spec.coffee +++ b/spec/package-manager-spec.coffee @@ -538,6 +538,16 @@ describe "PackageManager", -> atom.packages.deactivatePackage("package-with-settings") expect(atom.config.get 'editor.increaseIndentPattern', scope: ['.source.omg']).toBeUndefined() + it "invokes ::onDidDeactivatePackage listeners with the deactivated package", -> + waitsForPromise -> + atom.packages.activatePackage("package-with-main") + + runs -> + deactivatedPackage = null + atom.packages.onDidDeactivatePackage (pack) -> deactivatedPackage = pack + atom.packages.deactivatePackage("package-with-main") + expect(deactivatedPackage.name).toBe "package-with-main" + describe "::activate()", -> beforeEach -> jasmine.snapshotDeprecations() diff --git a/src/package-manager.coffee b/src/package-manager.coffee index e7f2aed3a..9eb1441b5 100644 --- a/src/package-manager.coffee +++ b/src/package-manager.coffee @@ -81,6 +81,15 @@ class PackageManager onDidActivatePackage: (callback) -> @emitter.on 'did-activate-package', callback + # Public: Invoke the given callback when a package is deactivated. + # + # * `callback` A {Function} to be invoked when a package is deactivated. + # * `package` The {Package} that was deactivated. + # + # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe. + onDidDeactivatePackage: (callback) -> + @emitter.on 'did-deactivate-package', callback + on: (eventName) -> switch eventName when 'loaded' @@ -381,3 +390,4 @@ class PackageManager @setPackageState(pack.name, state) if state = pack.serialize?() pack.deactivate() delete @activePackages[pack.name] + @emitter.emit 'did-deactivate-package', pack From 4ab33890fcb8ad13f20c0dd60cd07686f5f995d7 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 15:58:59 -0800 Subject: [PATCH 10/13] Add PackageManager::onDidLoad/UnloadPackage Signed-off-by: Max Brunsfeld --- spec/package-manager-spec.coffee | 15 +++++++++++++++ src/package-manager.coffee | 20 ++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/spec/package-manager-spec.coffee b/spec/package-manager-spec.coffee index 75aada8fa..52ef023bd 100644 --- a/spec/package-manager-spec.coffee +++ b/spec/package-manager-spec.coffee @@ -34,6 +34,14 @@ describe "PackageManager", -> expect(console.warn.callCount).toBe(1) expect(console.warn.argsForCall[0][0]).toContain("Could not resolve") + it "invokes ::onDidLoadPackage listeners with the loaded package", -> + loadedPackage = null + atom.packages.onDidLoadPackage (pack) -> loadedPackage = pack + + atom.packages.loadPackage("package-with-main") + + expect(loadedPackage.name).toBe "package-with-main" + describe "::unloadPackage(name)", -> describe "when the package is active", -> it "throws an error", -> @@ -61,6 +69,13 @@ describe "PackageManager", -> atom.packages.unloadPackage(pack.name) expect(atom.packages.isPackageLoaded(pack.name)).toBeFalsy() + it "invokes ::onDidUnloadPackage listeners with the unloaded package", -> + atom.packages.loadPackage('package-with-main') + unloadedPackage = null + atom.packages.onDidUnloadPackage (pack) -> unloadedPackage = pack + atom.packages.unloadPackage('package-with-main') + expect(unloadedPackage.name).toBe 'package-with-main' + describe "::activatePackage(id)", -> describe "when called multiple times", -> it "it only calls activate on the package once", -> diff --git a/src/package-manager.coffee b/src/package-manager.coffee index 9eb1441b5..82c5ba8ba 100644 --- a/src/package-manager.coffee +++ b/src/package-manager.coffee @@ -90,6 +90,24 @@ class PackageManager onDidDeactivatePackage: (callback) -> @emitter.on 'did-deactivate-package', callback + # Public: Invoke the given callback when a package is loaded. + # + # * `callback` A {Function} to be invoked when a package is loaded. + # * `package` The {Package} that was loaded. + # + # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe. + onDidLoadPackage: (callback) -> + @emitter.on 'did-load-package', callback + + # Public: Invoke the given callback when a package is unloaded. + # + # * `callback` A {Function} to be invoked when a package is unloaded. + # * `package` The {Package} that was unloaded. + # + # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe. + onDidUnloadPackage: (callback) -> + @emitter.on 'did-unload-package', callback + on: (eventName) -> switch eventName when 'loaded' @@ -321,6 +339,7 @@ class PackageManager pack = new Package(packagePath, metadata) pack.load() @loadedPackages[pack.name] = pack + @emitter.emit 'did-load-package', pack return pack catch error console.warn "Failed to load package.json '#{path.basename(packagePath)}'", error.stack ? error @@ -338,6 +357,7 @@ class PackageManager if pack = @getLoadedPackage(name) delete @loadedPackages[pack.name] + @emitter.emit 'did-unload-package', pack else throw new Error("No loaded package for name '#{name}'") From 723b4d2787662857d89ddf03b5f7fb01709100c2 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 16:06:03 -0800 Subject: [PATCH 11/13] Fix undefined Grim references --- src/package-manager.coffee | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/package-manager.coffee b/src/package-manager.coffee index 82c5ba8ba..5181f8eb0 100644 --- a/src/package-manager.coffee +++ b/src/package-manager.coffee @@ -5,7 +5,7 @@ EmitterMixin = require('emissary').Emitter {Emitter} = require 'event-kit' fs = require 'fs-plus' Q = require 'q' -{deprecate} = require 'grim' +Grim = require 'grim' Package = require './package' ThemePackage = require './theme-package' @@ -111,11 +111,11 @@ class PackageManager on: (eventName) -> switch eventName when 'loaded' - deprecate 'Use PackageManager::onDidLoadAll instead' + Grim.deprecate 'Use PackageManager::onDidLoadAll instead' when 'activated' - deprecate 'Use PackageManager::onDidActivateInitialPackages instead' + Grim.deprecate 'Use PackageManager::onDidActivateInitialPackages instead' else - deprecate 'PackageManager::on is deprecated. Use event subscription methods instead.' + Grim.deprecate 'PackageManager::on is deprecated. Use event subscription methods instead.' EmitterMixin::on.apply(this, arguments) ### From a945725a2fca24363b1ac24380a4c0951ebb5f7d Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 17:06:20 -0800 Subject: [PATCH 12/13] Add shims for tests that manually dispatch deprecated events --- src/package-manager.coffee | 2 ++ src/theme-manager.coffee | 1 + 2 files changed, 3 insertions(+) diff --git a/src/package-manager.coffee b/src/package-manager.coffee index 5181f8eb0..bf8280612 100644 --- a/src/package-manager.coffee +++ b/src/package-manager.coffee @@ -55,6 +55,7 @@ class PackageManager # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe. onDidLoadInitialPackages: (callback) -> @emitter.on 'did-load-initial-packages', callback + @emitter.on 'did-load-all', callback # TODO: Remove once deprecated pre-1.0 APIs are gone onDidLoadAll: (callback) -> Grim.deprecate("Use `::onDidLoadInitialPackages` instead.") @@ -67,6 +68,7 @@ class PackageManager # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe. onDidActivateInitialPackages: (callback) -> @emitter.on 'did-activate-initial-packages', callback + @emitter.on 'did-activate-all', callback # TODO: Remove once deprecated pre-1.0 APIs are gone onDidActivateAll: (callback) -> Grim.deprecate("Use `::onDidActivateInitialPackages` instead.") diff --git a/src/theme-manager.coffee b/src/theme-manager.coffee index e9c21a6d2..edaa10415 100644 --- a/src/theme-manager.coffee +++ b/src/theme-manager.coffee @@ -63,6 +63,7 @@ class ThemeManager # * `callback` {Function} onDidChangeActiveThemes: (callback) -> @emitter.on 'did-change-active-themes', callback + @emitter.on 'did-reload-all', callback # TODO: Remove once deprecated pre-1.0 APIs are gone onDidReloadAll: (callback) -> Grim.deprecate("Use `::onDidChangeActiveThemes` instead.") From c3efed0a2cb131957ad9e5fbec50b89bd23233dc Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Thu, 8 Jan 2015 18:21:07 -0800 Subject: [PATCH 13/13] Update deprecation messages --- src/package-manager.coffee | 2 +- src/theme-manager.coffee | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/package-manager.coffee b/src/package-manager.coffee index bf8280612..f657517f9 100644 --- a/src/package-manager.coffee +++ b/src/package-manager.coffee @@ -113,7 +113,7 @@ class PackageManager on: (eventName) -> switch eventName when 'loaded' - Grim.deprecate 'Use PackageManager::onDidLoadAll instead' + Grim.deprecate 'Use PackageManager::onDidLoadInitialPackages instead' when 'activated' Grim.deprecate 'Use PackageManager::onDidActivateInitialPackages instead' else diff --git a/src/theme-manager.coffee b/src/theme-manager.coffee index edaa10415..cec36657d 100644 --- a/src/theme-manager.coffee +++ b/src/theme-manager.coffee @@ -111,7 +111,7 @@ class ThemeManager on: (eventName) -> switch eventName when 'reloaded' - Grim.deprecate 'Use ThemeManager::onDidReloadAll instead' + Grim.deprecate 'Use ThemeManager::onDidChangeActiveThemes instead' when 'stylesheet-added' Grim.deprecate 'Use ThemeManager::onDidAddStylesheet instead' when 'stylesheet-removed'