Invoke handlers on detached DOM nodes

This ensures that all listeners slot into the correct location in a
single dispatch, regardless of whether they are added with
Node::addEventListener or via CommandRegistry::listen/capture. This
allows selector-based listeners to integrate into the rest of events
in a global way.

CONTRIBUTING.md

@@ -101,23 +101,30 @@ For more information on how to work with Atom's official packages, see
 
 ## Documentation Styleguide
 
-* Use [AtomDoc](https://github.com/atom/atomdoc).
+* Use [TomDoc](http://tomdoc.org).
 * Use [Markdown](https://daringfireball.net/projects/markdown).
 * Reference methods and classes in markdown with the custom `{}` notation:
     * Reference classes with `{ClassName}`
     * Reference instance methods with `{ClassName::methodName}`
     * Reference class methods with `{ClassName.methodName}`
+    * Delegate to comments elsewhere with `{Delegates to: ClassName.methodName}`
+      style notation.
 
 ### Example
 
 ```coffee
 # Public: Disable the package with the given name.
 #
-# * `name`    The {String} name of the package to disable.
-# * `options` (optional) The {Object} with disable options (default: {}):
-#   * `trackTime`     A {Boolean}, `true` to track the amount of time taken.
-#   * `ignoreErrors`  A {Boolean}, `true` to catch and ignore errors thrown.
-# * `callback` The {Function} to call after the package has been disabled.
+# This method emits multiple events:
+#
+# * `package-will-be-disabled` - before the package is disabled.
+# * `package-disabled`         - after the package is disabled.
+#
+# name     - The {String} name of the package to disable.
+# options  - The {Object} with disable options (default: {}):
+#   :trackTime - `true` to track the amount of time disabling took.
+#   :ignoreErrors - `true` to catch and ignore errors thrown.
+# callback - The {Function} to call after the package has been disabled.
 #
 # Returns `undefined`.
 disablePackage: (name, options, callback) ->

build/tasks/license-overrides.coffee

@@ -60,18 +60,3 @@ module.exports =
         ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
         IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
       """
-
-  'jschardet@1.1.0':
-    license: 'LGPL'
-    source: 'README.md in the repository'
-    sourceText: """
-      JsChardet
-      =========
-
-      Port of python's chardet (http://chardet.feedparser.org/).
-
-      License
-      -------
-
-      LGPL
-    """

menus/darwin.cson

@@ -190,12 +190,6 @@
     submenu: [
       { label: 'Terms of Use', command: 'application:open-terms-of-use' }
       { label: 'Documentation', command: 'application:open-documentation' }
-      { label: 'Roadmap', command: 'application:open-roadmap' }
-      { label: 'Frequently Asked Questions', command: 'application:open-faq' }
-      { type: 'separator' }
-      { label: 'Community Discussions', command: 'application:open-discussions' }
-      { label: 'Report Issue', command: 'application:report-issue' }
-      { label: 'Search Issues', command: 'application:search-issues' }
       { type: 'separator' }
     ]
   }

menus/linux.cson

@@ -147,12 +147,6 @@
       { label: "VERSION", enabled: false }
       { type: 'separator' }
       { label: '&Documentation', command: 'application:open-documentation' }
-      { label: 'Roadmap', command: 'application:open-roadmap' }
-      { label: 'Frequently Asked Questions', command: 'application:open-faq' }
-      { type: 'separator' }
-      { label: 'Community Discussions', command: 'application:open-discussions' }
-      { label: 'Report Issue', command: 'application:report-issue' }
-      { label: 'Search Issues', command: 'application:search-issues' }
       { type: 'separator' }
     ]
   }

menus/win32.cson

@@ -165,12 +165,6 @@
       { label: "VERSION", enabled: false }
       { type: 'separator' }
       { label: '&Documentation', command: 'application:open-documentation' }
-      { label: 'Roadmap', command: 'application:open-roadmap' }
-      { label: 'Frequently Asked Questions', command: 'application:open-faq' }
-      { type: 'separator' }
-      { label: 'Community Discussions', command: 'application:open-discussions' }
-      { label: 'Report Issue', command: 'application:report-issue' }
-      { label: 'Search Issues', command: 'application:search-issues' }
       { type: 'separator' }
     ]
   }

package.json

@@ -43,7 +43,7 @@
     "nslog": "^1.0.1",
     "oniguruma": "^3.0.4",
     "optimist": "0.4.0",
-    "pathwatcher": "^2.3.2",
+    "pathwatcher": "^2.1.3",
     "property-accessors": "^1",
     "q": "^1.0.1",
     "random-words": "0.0.1",
@@ -58,7 +58,7 @@
     "serializable": "^1",
     "space-pen": "3.8.0",
     "temp": "0.7.0",
-    "text-buffer": "^3.4",
+    "text-buffer": "^3.3.0",
     "theorist": "^1.0.2",
     "underscore-plus": "^1.6.1",
     "vm-compatibility-layer": "0.1.0"
@@ -81,15 +81,15 @@
     "bracket-matcher": "0.62.0",
     "command-palette": "0.27.0",
     "deprecation-cop": "0.11.0",
-    "dev-live-reload": "0.35.0",
-    "encoding-selector": "0.5.0",
+    "dev-live-reload": "0.34.0",
     "exception-reporting": "0.20.0",
+    "feedback": "0.33.0",
     "find-and-replace": "0.141.0",
     "fuzzy-finder": "0.60.0",
     "git-diff": "0.42.0",
     "go-to-line": "0.26.0",
-    "grammar-selector": "0.37.0",
-    "image-view": "0.40.0",
+    "grammar-selector": "0.35.0",
+    "image-view": "0.38.0",
     "incompatible-packages": "0.10.0",
     "keybinding-resolver": "0.20.0",
     "link": "0.26.0",
@@ -98,7 +98,7 @@
     "open-on-github": "0.30.0",
     "package-generator": "0.31.0",
     "release-notes": "0.36.0",
-    "settings-view": "0.154.0",
+    "settings-view": "0.153.0",
     "snippets": "0.56.0",
     "spell-check": "0.43.0",
     "status-bar": "0.46.0",

spec/command-registry-spec.coffee

@@ -15,14 +15,18 @@ describe "CommandRegistry", ->
     document.querySelector('#jasmine-content').appendChild(parent)
 
     registry = new CommandRegistry
+    atom.commands.restoreDOMEventMethods()
+    registry.patchDOMEventMethods()
 
   afterEach ->
+    registry.restoreDOMEventMethods()
+    atom.commands.patchDOMEventMethods()
     registry.destroy()
 
   describe "when a command event is dispatched on an element", ->
     it "invokes callbacks with selectors matching the target", ->
       called = false
-      registry.add '.grandchild', 'command', (event) ->
+      registry.listen '.grandchild', 'command', (event) ->
         expect(this).toBe grandchild
         expect(event.type).toBe 'command'
         expect(event.eventPhase).toBe Event.BUBBLING_PHASE
@@ -36,13 +40,13 @@ describe "CommandRegistry", ->
     it "invokes callbacks with selectors matching ancestors of the target", ->
       calls = []
 
-      registry.add '.child', 'command', (event) ->
+      registry.listen '.child', 'command', (event) ->
         expect(this).toBe child
         expect(event.target).toBe grandchild
         expect(event.currentTarget).toBe child
         calls.push('child')
 
-      registry.add '.parent', 'command', (event) ->
+      registry.listen '.parent', 'command', (event) ->
         expect(this).toBe parent
         expect(event.target).toBe grandchild
         expect(event.currentTarget).toBe parent
@@ -53,10 +57,10 @@ describe "CommandRegistry", ->
 
     it "invokes inline listeners prior to listeners applied via selectors", ->
       calls = []
-      registry.add '.grandchild', 'command', -> calls.push('grandchild')
-      registry.add child, 'command', -> calls.push('child-inline')
-      registry.add '.child', 'command', -> calls.push('child')
-      registry.add '.parent', 'command', -> calls.push('parent')
+      registry.listen '.grandchild', 'command', -> calls.push('grandchild')
+      registry.listen child, 'command', -> calls.push('child-inline')
+      registry.listen '.child', 'command', -> calls.push('child')
+      registry.listen '.parent', 'command', -> calls.push('parent')
 
       grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
       expect(calls).toEqual ['grandchild', 'child-inline', 'child', 'parent']
@@ -65,41 +69,77 @@ describe "CommandRegistry", ->
       child.classList.add('foo', 'bar')
       calls = []
 
-      registry.add '.foo.bar', 'command', -> calls.push('.foo.bar')
-      registry.add '.foo', 'command', -> calls.push('.foo')
-      registry.add '.bar', 'command', -> calls.push('.bar') # specificity ties favor commands added later, like CSS
+      registry.listen '.foo.bar', 'command', -> calls.push('.foo.bar')
+      registry.listen '.foo', 'command', -> calls.push('.foo')
+      registry.listen '.bar', 'command', -> calls.push('.bar') # specificity ties favor commands added later, like CSS
 
       grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
       expect(calls).toEqual ['.foo.bar', '.bar', '.foo']
 
+    it "does not bubble the event if the ::bubbles property is false on the dispatched event", ->
+      calls = []
+
+      registry.listen '.grandchild', 'command', -> calls.push('grandchild')
+      registry.listen '.child', 'command', -> calls.push('child')
+      registry.listen '.parent', 'command', -> calls.push('parent')
+
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: false))
+      expect(calls).toEqual ['grandchild']
+
+    it "invokes capture-phase listeners before bubble-phase listeners", ->
+      calls = []
+
+      # Spot-check event details for both capture and bubbling phase
+      registry.capture '.grandchild', 'command', (event) ->
+        expect(this).toBe grandchild
+        expect(event.type).toBe 'command'
+        expect(event.eventPhase).toBe Event.CAPTURING_PHASE
+        expect(event.target).toBe grandchild
+        expect(event.currentTarget).toBe grandchild
+        calls.push('grandchild-capture')
+
+      registry.listen '.grandchild', 'command', (event) ->
+        expect(this).toBe grandchild
+        expect(event.type).toBe 'command'
+        expect(event.eventPhase).toBe Event.BUBBLING_PHASE
+        expect(event.target).toBe grandchild
+        expect(event.currentTarget).toBe grandchild
+        calls.push('grandchild-bubble')
+
+      registry.capture child, 'command', -> calls.push('child-inline-capture')
+      registry.listen child, 'command', -> calls.push('child-inline-bubble')
+      registry.capture '.child', 'command', -> calls.push('child-capture')
+      registry.capture '.parent', 'command', -> calls.push('parent-capture')
+
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual ['parent-capture', 'child-inline-capture', 'child-capture', 'grandchild-capture', 'grandchild-bubble', 'child-inline-bubble']
+
     it "stops bubbling through ancestors when .stopPropagation() is called on the event", ->
       calls = []
 
-      registry.add '.parent', 'command', -> calls.push('parent')
-      registry.add '.child', 'command', -> calls.push('child-2')
-      registry.add '.child', 'command', (event) -> calls.push('child-1'); event.stopPropagation()
+      registry.listen '.parent', 'command', -> calls.push('parent')
+      registry.listen '.child', 'command', -> calls.push('child-2')
+      registry.listen '.child', 'command', (event) -> calls.push('child-1'); event.stopPropagation()
 
       dispatchedEvent = new CustomEvent('command', bubbles: true)
       spyOn(dispatchedEvent, 'stopPropagation')
       grandchild.dispatchEvent(dispatchedEvent)
       expect(calls).toEqual ['child-1', 'child-2']
-      expect(dispatchedEvent.stopPropagation).toHaveBeenCalled()
 
     it "stops invoking callbacks when .stopImmediatePropagation() is called on the event", ->
       calls = []
 
-      registry.add '.parent', 'command', -> calls.push('parent')
-      registry.add '.child', 'command', -> calls.push('child-2')
-      registry.add '.child', 'command', (event) -> calls.push('child-1'); event.stopImmediatePropagation()
+      registry.listen '.parent', 'command', -> calls.push('parent')
+      registry.listen '.child', 'command', -> calls.push('child-2')
+      registry.listen '.child', 'command', (event) -> calls.push('child-1'); event.stopImmediatePropagation()
 
       dispatchedEvent = new CustomEvent('command', bubbles: true)
       spyOn(dispatchedEvent, 'stopImmediatePropagation')
       grandchild.dispatchEvent(dispatchedEvent)
       expect(calls).toEqual ['child-1']
-      expect(dispatchedEvent.stopImmediatePropagation).toHaveBeenCalled()
 
     it "forwards .preventDefault() calls from the synthetic event to the original", ->
-      registry.add '.child', 'command', (event) -> event.preventDefault()
+      registry.listen '.child', 'command', (event) -> event.preventDefault()
 
       dispatchedEvent = new CustomEvent('command', bubbles: true)
       spyOn(dispatchedEvent, 'preventDefault')
@@ -107,7 +147,7 @@ describe "CommandRegistry", ->
       expect(dispatchedEvent.preventDefault).toHaveBeenCalled()
 
     it "forwards .abortKeyBinding() calls from the synthetic event to the original", ->
-      registry.add '.child', 'command', (event) -> event.abortKeyBinding()
+      registry.listen '.child', 'command', (event) -> event.abortKeyBinding()
 
       dispatchedEvent = new CustomEvent('command', bubbles: true)
       dispatchedEvent.abortKeyBinding = jasmine.createSpy('abortKeyBinding')
@@ -117,8 +157,8 @@ describe "CommandRegistry", ->
     it "allows listeners to be removed via a disposable returned by ::add", ->
       calls = []
 
-      disposable1 = registry.add '.parent', 'command', -> calls.push('parent')
-      disposable2 = registry.add '.child', 'command', -> calls.push('child')
+      disposable1 = registry.listen '.parent', 'command', -> calls.push('parent')
+      disposable2 = registry.listen '.child', 'command', -> calls.push('child')
 
       disposable1.dispose()
       grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
@@ -132,7 +172,7 @@ describe "CommandRegistry", ->
     it "allows multiple commands to be registered under one selector when called with an object", ->
       calls = []
 
-      disposable = registry.add '.child',
+      disposable = registry.listen '.child',
         'command-1': -> calls.push('command-1')
         'command-2': -> calls.push('command-2')
 
@@ -149,10 +189,10 @@ describe "CommandRegistry", ->
 
   describe "::findCommands({target})", ->
     it "returns commands that can be invoked on the target or its ancestors", ->
-      registry.add '.parent', 'namespace:command-1', ->
-      registry.add '.child', 'namespace:command-2', ->
-      registry.add '.grandchild', 'namespace:command-3', ->
-      registry.add '.grandchild.no-match', 'namespace:command-4', ->
+      registry.listen '.parent', 'namespace:command-1', ->
+      registry.listen '.child', 'namespace:command-2', ->
+      registry.listen '.grandchild', 'namespace:command-3', ->
+      registry.listen '.grandchild.no-match', 'namespace:command-4', ->
 
       expect(registry.findCommands(target: grandchild)[0..2]).toEqual [
         {name: 'namespace:command-3', displayName: 'Namespace: Command 3'}
@@ -163,7 +203,7 @@ describe "CommandRegistry", ->
   describe "::dispatch(target, commandName)", ->
     it "simulates invocation of the given command ", ->
       called = false
-      registry.add '.grandchild', 'command', (event) ->
+      registry.listen '.grandchild', 'command', (event) ->
         expect(this).toBe grandchild
         expect(event.type).toBe 'command'
         expect(event.eventPhase).toBe Event.BUBBLING_PHASE
@@ -175,18 +215,42 @@ describe "CommandRegistry", ->
       expect(called).toBe true
 
     it "returns a boolean indicating whether any listeners matched the command", ->
-      registry.add '.grandchild', 'command', ->
+      registry.listen '.grandchild', 'command', ->
 
       expect(registry.dispatch(grandchild, 'command')).toBe true
       expect(registry.dispatch(grandchild, 'bogus')).toBe false
       expect(registry.dispatch(parent, 'command')).toBe false
 
+    it "does not perform bubbling for native event names that should not bubble", ->
+      calls = []
+
+      registry.listen '.grandchild', 'focus', -> calls.push('grandchild')
+      registry.listen '.child', 'focus', -> calls.push('child')
+      registry.listen '.parent', 'focus', -> calls.push('parent')
+
+      registry.dispatch(grandchild, 'focus')
+      expect(calls).toEqual ['grandchild']
+
+    it "allows an event object to be passed instead of an event name", ->
+      called = false
+      registry.listen '.grandchild', 'command', (event) ->
+        expect(this).toBe grandchild
+        expect(event.type).toBe 'command'
+        expect(event.eventPhase).toBe Event.BUBBLING_PHASE
+        expect(event.target).toBe grandchild
+        expect(event.currentTarget).toBe grandchild
+        expect(event.detail).toEqual {a: 1}
+        called = true
+
+      registry.dispatch(grandchild, new CustomEvent('command', bubbles: true), {a: 1})
+      expect(called).toBe true
+
   describe "::getSnapshot and ::restoreSnapshot", ->
     it "removes all command handlers except for those in the snapshot", ->
-      registry.add '.parent', 'namespace:command-1', ->
-      registry.add '.child', 'namespace:command-2', ->
+      registry.listen '.parent', 'namespace:command-1', ->
+      registry.listen '.child', 'namespace:command-2', ->
       snapshot = registry.getSnapshot()
-      registry.add '.grandchild', 'namespace:command-3', ->
+      registry.listen '.grandchild', 'namespace:command-3', ->
 
       expect(registry.findCommands(target: grandchild)[0..2]).toEqual [
         {name: 'namespace:command-3', displayName: 'Namespace: Command 3'}
@@ -201,10 +265,39 @@ describe "CommandRegistry", ->
         {name: 'namespace:command-1', displayName: 'Namespace: Command 1'}
       ]
 
-      registry.add '.grandchild', 'namespace:command-3', ->
+      registry.listen '.grandchild', 'namespace:command-3', ->
       registry.restoreSnapshot(snapshot)
 
       expect(registry.findCommands(target: grandchild)[0..1]).toEqual [
         {name: 'namespace:command-2', displayName: 'Namespace: Command 2'}
         {name: 'namespace:command-1', displayName: 'Namespace: Command 1'}
       ]
+
+  describe "::addEventListener and ::removeEventListener overrides", ->
+    it "mixes listeners registered via ::addEventListener with selector-based listeners", ->
+      calls = []
+      registry.listen '.grandchild', 'command', -> calls.push('grandchild')
+      registry.listen '.child', 'command', -> calls.push('child')
+      registry.listen '.parent', 'command', -> calls.push('parent')
+
+      bubbleListener = -> calls.push('child-inline-bubble')
+      captureListener = -> calls.push('child-inline-capture')
+      child.addEventListener('command', bubbleListener)
+      child.addEventListener('command', captureListener, true)
+
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual ['child-inline-capture', 'grandchild', 'child-inline-bubble', 'child', 'parent']
+
+      child.removeEventListener('command', bubbleListener)
+      child.removeEventListener('command', captureListener, true)
+
+      calls = []
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual ['grandchild', 'child', 'parent']
+
+    it "invokes handlers on detached DOM nodes", ->
+      detachedNode = document.createElement('div')
+      called = false
+      detachedNode.addEventListener 'command', -> called = true
+      detachedNode.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(called).toBe true

spec/fixtures/packages/package-with-activation-commands/index.coffee

@@ -6,7 +6,7 @@ module.exports =
   activate: ->
     @activateCallCount++
 
-    atom.commands.add 'atom-workspace', 'activation-command', =>
+    atom.commands.listen 'atom-workspace', 'activation-command', =>
       @activationCommandCallCount++
 
     atom.workspaceView.getActiveView()?.command 'activation-command', =>

spec/fixtures/packages/theme-with-syntax-variables/package.json

@@ -1,4 +0,0 @@
-{
-  "theme": "syntax",
-  "stylesheets": ["editor.less"]
-}

spec/package-manager-spec.coffee

@@ -118,7 +118,7 @@ describe "PackageManager", ->
             spyOn(Package.prototype, 'requireMainModule').andCallThrough()
 
             workspaceCommandListener = jasmine.createSpy('workspaceCommandListener')
-            atom.commands.add '.workspace', 'activation-command', workspaceCommandListener
+            atom.commands.listen '.workspace', 'activation-command', workspaceCommandListener
 
             promise = atom.packages.activatePackage('package-with-activation-commands')
 
@@ -138,7 +138,7 @@ describe "PackageManager", ->
               legacyCommandListener = jasmine.createSpy("legacyCommandListener")
               editorView.command 'activation-command', legacyCommandListener
               editorCommandListener = jasmine.createSpy("editorCommandListener")
-              atom.commands.add 'atom-text-editor', 'activation-command', editorCommandListener
+              atom.commands.listen 'atom-text-editor', 'activation-command', editorCommandListener
               editorView[0].dispatchEvent(new CustomEvent('activation-command', bubbles: true))
               expect(mainModule.activate.callCount).toBe 1
               expect(mainModule.legacyActivationCommandCallCount).toBe 1

spec/spec-helper.coffee

@@ -351,11 +351,7 @@ $.fn.resultOfTrigger = (type) ->
   event.result
 
 $.fn.enableKeymap = ->
-  @on 'keydown', (e) ->
-    originalEvent = e.originalEvent ? e
-    Object.defineProperty(originalEvent, 'target', get: -> e.target) unless originalEvent.target?
-    atom.keymaps.handleKeyboardEvent(originalEvent)
-    not e.originalEvent.defaultPrevented
+  @element.addEventListener 'keydown', (event) -> atom.keymaps.handleKeyboardEvent(event)
 
 $.fn.attachToDom = ->
   @appendTo($('#jasmine-content')) unless @isOnDom()

spec/text-editor-component-spec.coffee

@@ -2286,12 +2286,6 @@ describe "TextEditorComponent", ->
       editor.setGrammar(atom.syntax.nullGrammar)
       expect(wrapperNode.dataset.grammar).toBe 'text plain null-grammar'
 
-  describe "encoding data attributes", ->
-    it "adds and updates the encoding data attribute based on the current encoding", ->
-      expect(wrapperNode.dataset.encoding).toBe 'utf8'
-      editor.setEncoding('utf16le')
-      expect(wrapperNode.dataset.encoding).toBe 'utf16le'
-
   describe "detaching and reattaching the editor (regression)", ->
     it "does not throw an exception", ->
       wrapperView.detach()

spec/text-editor-spec.coffee

@@ -157,19 +157,6 @@ describe "TextEditor", ->
 
       expect(observed).toEqual [__filename, undefined]
 
-  describe "encoding", ->
-    it "notifies ::onDidChangeEncoding observers when the editor encoding changes", ->
-      observed = []
-      editor.onDidChangeEncoding (encoding) -> observed.push(encoding)
-
-      editor.setEncoding('utf16le')
-      editor.setEncoding('utf16le')
-      editor.setEncoding('utf16be')
-      editor.setEncoding()
-      editor.setEncoding()
-
-      expect(observed).toEqual ['utf16le', 'utf16be', 'utf8']
-
   describe "cursor", ->
     describe ".getLastCursor()", ->
       it "returns the most recently created cursor", ->

spec/theme-manager-spec.coffee

@@ -92,8 +92,8 @@ describe "ThemeManager", ->
 
       runs ->
         reloadHandler.reset()
-        expect($('style[group=theme]')).toHaveLength 2
-        expect($('style[group=theme]:eq(1)').attr('source-path')).toMatch /atom-dark-syntax/
+        expect($('style[group=theme]')).toHaveLength 1
+        expect($('style[group=theme]:eq(0)').attr('source-path')).toMatch /atom-dark-syntax/
         atom.config.set('core.themes', ['atom-light-syntax', 'atom-dark-syntax'])
 
       waitsFor ->
@@ -111,7 +111,7 @@ describe "ThemeManager", ->
 
       runs ->
         reloadHandler.reset()
-        expect($('style[group=theme]')).toHaveLength 2
+        expect($('style[group=theme]')).toHaveLength 0
         # atom-dark-ui has an directory path, the syntax one doesn't
         atom.config.set('core.themes', ['theme-with-index-less', 'atom-dark-ui'])
 
@@ -217,7 +217,7 @@ describe "ThemeManager", ->
 
     it "loads the correct values from the theme's ui-variables file", ->
       themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
-      atom.config.set('core.themes', ['theme-with-ui-variables', 'theme-with-syntax-variables'])
+      atom.config.set('core.themes', ['theme-with-ui-variables'])
 
       waitsFor ->
         reloadHandler.callCount > 0
@@ -234,7 +234,7 @@ 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()
-        atom.config.set('core.themes', ['theme-with-incomplete-ui-variables', 'theme-with-syntax-variables'])
+        atom.config.set('core.themes', ['theme-with-incomplete-ui-variables'])
 
         waitsFor ->
           reloadHandler.callCount > 0
@@ -251,7 +251,7 @@ describe "ThemeManager", ->
         expect(atom.workspaceView).toHaveClass 'theme-atom-dark-ui'
 
         themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
-        atom.config.set('core.themes', ['theme-with-ui-variables', 'theme-with-syntax-variables'])
+        atom.config.set('core.themes', ['theme-with-ui-variables'])
 
         waitsFor ->
           reloadHandler.callCount > 0
@@ -259,9 +259,7 @@ describe "ThemeManager", ->
         runs ->
           # `theme-` twice as it prefixes the name with `theme-`
           expect(atom.workspaceView).toHaveClass 'theme-theme-with-ui-variables'
-          expect(atom.workspaceView).toHaveClass 'theme-theme-with-syntax-variables'
           expect(atom.workspaceView).not.toHaveClass 'theme-atom-dark-ui'
-          expect(atom.workspaceView).not.toHaveClass 'theme-atom-dark-syntax'
 
   describe "when the user stylesheet changes", ->
     it "reloads it", ->
@@ -310,19 +308,24 @@ describe "ThemeManager", ->
         expect(stylesheetsChangedHandler).toHaveBeenCalled()
 
   describe "when a non-existent theme is present in the config", ->
-    beforeEach ->
-      spyOn(console, 'warn')
-      atom.config.set('core.themes', ['non-existent-dark-ui', 'non-existent-dark-syntax'])
+    it "logs a warning but does not throw an exception (regression)", ->
+      reloaded = false
 
       waitsForPromise ->
         themeManager.activateThemes()
 
-    it 'uses the default dark UI and syntax themes and logs a warning', ->
-      activeThemeNames = themeManager.getActiveNames()
-      expect(console.warn.callCount).toBe 2
-      expect(activeThemeNames.length).toBe(2)
-      expect(activeThemeNames).toContain('atom-dark-ui')
-      expect(activeThemeNames).toContain('atom-dark-syntax')
+      runs ->
+        disposable = themeManager.onDidReloadAll ->
+          disposable.dispose()
+          reloaded = true
+        spyOn(console, 'warn')
+        expect(-> atom.config.set('core.themes', ['atom-light-ui', 'theme-really-does-not-exist'])).not.toThrow()
+
+      waitsFor -> reloaded
+
+      runs ->
+        expect(console.warn.callCount).toBe 1
+        expect(console.warn.argsForCall[0][0].length).toBeGreaterThan 0
 
   describe "when in safe mode", ->
     beforeEach ->

spec/window-spec.coffee

@@ -14,14 +14,9 @@ describe "Window", ->
       loadSettings.initialPath = initialPath
       loadSettings
     atom.project.destroy()
-    windowEventHandler = new WindowEventHandler()
     atom.deserializeEditorWindow()
     projectPath = atom.project.getPaths()[0]
 
-  afterEach ->
-    windowEventHandler.unsubscribe()
-    $(window).off 'beforeunload'
-
   describe "when the window is loaded", ->
     it "doesn't have .is-blurred on the body tag", ->
       expect($("body")).not.toHaveClass("is-blurred")
@@ -107,6 +102,8 @@ describe "Window", ->
 
   describe ".removeEditorWindow()", ->
     it "unsubscribes from all buffers", ->
+      spyOn(atom.windowEventHandler, 'unsubscribe') # don't unsubscribe from window events
+
       waitsForPromise ->
         atom.workspace.open("sample.js")
 

src/atom.coffee

@@ -209,6 +209,7 @@ class Atom extends Model
     @keymaps = new KeymapManager({configDirPath, resourcePath})
     @keymap = @keymaps # Deprecated
     @commands = new CommandRegistry
+    @commands.patchDOMEventMethods()
     @packages = new PackageManager({devMode, configDirPath, resourcePath, safeMode})
     @styles = new StyleManager
     document.head.appendChild(new StylesElement)

src/browser/application-menu.coffee

@@ -22,10 +22,14 @@ class ApplicationMenu
   # keystrokesByCommand - An Object where the keys are commands and the values
   #                       are Arrays containing the keystroke.
   update: (window, template, keystrokesByCommand) ->
+    return unless window is @lastFocusedWindow
+
     @translateTemplate(template, keystrokesByCommand)
     @substituteVersion(template)
     @windowTemplates.set(window, template)
-    @setActiveTemplate(template) if window is @lastFocusedWindow
+    @setActiveTemplate(template)
+
+    @showUpdateMenuItem(global.atomApplication.autoUpdateManager.getState())
 
   setActiveTemplate: (template) ->
     unless _.isEqual(template, @activeTemplate)
@@ -33,8 +37,6 @@ class ApplicationMenu
       @menu = Menu.buildFromTemplate(_.deepClone(template))
       Menu.setApplicationMenu(@menu)
 
-    @showUpdateMenuItem(global.atomApplication.autoUpdateManager.getState())
-
   # Register a BrowserWindow with this application menu.
   addWindow: (window) ->
     @lastFocusedWindow ?= window

src/browser/atom-application.coffee

@@ -155,13 +155,7 @@ class AtomApplication
       atomWindow?.browserWindow.inspectElement(x, y)
 
     @on 'application:open-documentation', -> require('shell').openExternal('https://atom.io/docs/latest/?app')
-    @on 'application:open-discussions', -> require('shell').openExternal('https://discuss.atom.io')
-    @on 'application:open-roadmap', -> require('shell').openExternal('https://atom.io/roadmap?app')
-    @on 'application:open-faq', -> require('shell').openExternal('https://atom.io/faq')
     @on 'application:open-terms-of-use', -> require('shell').openExternal('https://atom.io/terms')
-    @on 'application:report-issue', -> require('shell').openExternal('https://github.com/atom/atom/issues/new')
-    @on 'application:search-issues', -> require('shell').openExternal('https://github.com/issues?q=+is%3Aissue+user%3Aatom')
-
     @on 'application:install-update', -> @autoUpdateManager.install()
     @on 'application:check-for-update', => @autoUpdateManager.check()
 

src/command-registry.coffee

@@ -1,15 +1,50 @@
 {Emitter, Disposable, CompositeDisposable} = require 'event-kit'
 {specificity} = require 'clear-cut'
 _ = require 'underscore-plus'
+Grim = require 'grim'
 {$} = require './space-pen-extensions'
 
 SequenceCount = 0
 SpecificityCache = {}
 
-# Public: Associates listener functions with commands in a
-# context-sensitive way using CSS selectors. You can access a global instance of
-# this class via `atom.commands`, and commands registered there will be
-# presented in the command palette.
+NativeEventBubbling =
+  abort: false
+  beforeinput: true
+  blur: false
+  click: true
+  compositionstart: true
+  compositionupdate: true
+  compositionend: true
+  dblclick: true
+  error: false
+  focus: false
+  focusin: true
+  focusout: true
+  input: true
+  keydown: true
+  keyup: true
+  load: false
+  mousedown: true
+  mouseenter: false
+  mouseleave: false
+  mousemove: true
+  mouseout: true
+  mouseover: true
+  mouseup: true
+  resize: false
+  scroll: false
+  select: true
+  textInput: true
+  unload: false
+  wheel: true
+  mousewheel: true
+
+module.exports =
+
+# Public: Associates listener functions with commands in a context-sensitive way
+# using CSS selectors. You can access a global instance of this class via
+# `atom.commands`, and commands registered there will be presented in the
+# command palette.
 #
 # The global command registry facilitates a style of event handling known as
 # *event delegation* that was popularized by jQuery. Atom commands are expressed
@@ -33,7 +68,7 @@ SpecificityCache = {}
 # Here is a command that inserts the current date in an editor:
 #
 # ```coffee
-# atom.commands.add 'atom-text-editor',
+# atom.commands.listen 'atom-text-editor',
 #   'user:insert-date': (event) ->
 #     editor = $(this).view().getModel()
 #     # soon the above above line will be:
@@ -42,8 +77,13 @@ SpecificityCache = {}
 # ```
 module.exports =
 class CommandRegistry
+  patchedDOMEventMethods: false
+  originalAddEventListener: Node::addEventListener
+  originalRemoveEventListener: Node::removeEventListener
+
   constructor: (@rootNode) ->
     @registeredCommands = {}
+    @registeredCommandsByInlineNode = new WeakMap
     @selectorBasedListenersByCommandName = {}
     @inlineListenersByCommandName = {}
     @emitter = new Emitter
@@ -52,6 +92,52 @@ class CommandRegistry
     for commandName of @registeredCommands
       window.removeEventListener(commandName, @handleCommandEvent, true)
 
+  patchDOMEventMethods: ->
+    if @patchedDOMEventMethods
+      throw new Error("Already patched DOM event methods for this registry.")
+    else
+      @patchedDOMEventMethods = true
+
+    registry = this
+    disposablesByEventName = {}
+
+    @originalAddEventListener = Node::addEventListener
+    @originalRemoveEventListener = Node::originalRemoveEventListener
+
+    Node::addEventListener = (eventName, callback, useCapture=false) ->
+      return unless callback?
+
+      target = this
+      disposable = registry.listen(target, eventName, callback, useCapture)
+
+      disposablesByEventName[eventName] ?= {}
+      disposablesByUseCapture = disposablesByEventName[eventName]
+      disposablesByUseCapture[useCapture] ?= new WeakMap
+      disposablesByTarget = disposablesByUseCapture[useCapture]
+      disposablesByTarget.set(target, new WeakMap) unless disposablesByTarget.has(target)
+      disposablesByCallback = disposablesByTarget.get(target)
+      disposablesByCallback.set(callback, new CompositeDisposable) unless disposablesByCallback.has(callback)
+      disposablesByCallback.get(callback).add(disposable)
+      return
+
+    Node::removeEventListener = (eventName, callback, useCapture=false) ->
+      return unless callback?
+
+      target = this
+      disposablesByEventName[eventName]?[useCapture]?.get(target)?.get(callback)?.dispose()
+      return
+
+  restoreDOMEventMethods: ->
+    Node::addEventListener = @originalAddEventListener
+    Node::removeEventListener = @originalRemoveEventListener
+    @patchedDOMEventMethods = false
+
+  addEventListener: (target, eventName, callback, useCapture) ->
+    @originalAddEventListener.call(target, eventName, callback, useCapture)
+
+  removeEventListener: (target, eventName, callback, useCapture) ->
+    @originalRemoveEventListener.call(target, eventName, callback, useCapture)
+
   # Public: Add one or more command listeners associated with a selector.
   #
   # ## Arguments: Registering One Command
@@ -77,23 +163,30 @@ class CommandRegistry
   #
   # Returns a {Disposable} on which `.dispose()` can be called to remove the
   # added command handler(s).
-  add: (target, commandName, callback) ->
+  listen: (target, commandName, callback, useCapture=false) ->
     if typeof commandName is 'object'
       commands = commandName
       disposable = new CompositeDisposable
       for commandName, callback of commands
-        disposable.add @add(target, commandName, callback)
+        disposable.add @listen(target, commandName, callback, useCapture)
       return disposable
 
     if typeof target is 'string'
-      @addSelectorBasedListener(target, commandName, callback)
+      @addSelectorBasedListener(target, commandName, callback, useCapture)
     else
-      @addInlineListener(target, commandName, callback)
+      @addInlineListener(target, commandName, callback, useCapture)
 
-  addSelectorBasedListener: (selector, commandName, callback) ->
+  add: (target, commandName, callback) ->
+    Grim.deprecate("Use CommandRegistry::listen instead")
+    @listen(target, commandName, callback)
+
+  capture: (target, commandName, callback) ->
+    @listen(target, commandName, callback, true)
+
+  addSelectorBasedListener: (selector, commandName, callback, useCapture) ->
     @selectorBasedListenersByCommandName[commandName] ?= []
     listenersForCommand = @selectorBasedListenersByCommandName[commandName]
-    listener = new SelectorBasedListener(selector, callback)
+    listener = new SelectorBasedListener(selector, callback, useCapture)
     listenersForCommand.push(listener)
 
     @commandRegistered(commandName)
@@ -102,17 +195,17 @@ class CommandRegistry
       listenersForCommand.splice(listenersForCommand.indexOf(listener), 1)
       delete @selectorBasedListenersByCommandName[commandName] if listenersForCommand.length is 0
 
-  addInlineListener: (element, commandName, callback) ->
+  addInlineListener: (element, commandName, callback, useCapture) ->
     @inlineListenersByCommandName[commandName] ?= new WeakMap
 
     listenersForCommand = @inlineListenersByCommandName[commandName]
     unless listenersForElement = listenersForCommand.get(element)
       listenersForElement = []
       listenersForCommand.set(element, listenersForElement)
-    listener = new InlineListener(callback)
+    listener = new InlineListener(callback, useCapture)
     listenersForElement.push(listener)
 
-    @commandRegistered(commandName)
+    @commandRegistered(commandName, element)
 
     new Disposable ->
       listenersForElement.splice(listenersForElement.indexOf(listener), 1)
@@ -160,11 +253,17 @@ class CommandRegistry
   # processed.
   #
   # * `target` The DOM node at which to start bubbling the command event.
-  # * `commandName` {String} indicating the name of the command to dispatch.
-  dispatch: (target, commandName, detail) ->
-    event = new CustomEvent(commandName, {bubbles: true, detail})
+  # * `event` {String} indicating the name of the command to dispatch or a
+  #     DOM event object.
+  # * `detail` The detail to associate with the dispatched DOM event. If present
+  #     overrides the `detail` of the `event` if it is a DOM event object.
+  dispatch: (target, event, detail) ->
+    if typeof event is 'string'
+      event = new CustomEvent(event, {bubbles: NativeEventBubbling[event] ? true})
+
     eventWithTarget = Object.create event,
       target: value: target
+      detail: value: detail ? event.detail
       preventDefault: value: ->
       stopPropagation: value: ->
       stopImmediatePropagation: value: ->
@@ -185,56 +284,93 @@ class CommandRegistry
       @selectorBasedListenersByCommandName[commandName] = listeners.slice()
 
   handleCommandEvent: (originalEvent) =>
+    originalEvent.stopImmediatePropagation()
+
     propagationStopped = false
     immediatePropagationStopped = false
-    matched = false
-    currentTarget = originalEvent.target
+    invokedListener = false
+    {target, type} = originalEvent
+    currentTarget = null
+    bubbles = NativeEventBubbling[type] ? originalEvent.bubbles
 
     syntheticEvent = Object.create originalEvent,
-      eventPhase: value: Event.BUBBLING_PHASE
+      eventPhase: get: -> eventPhase
       currentTarget: get: -> currentTarget
-      preventDefault: value: ->
-        originalEvent.preventDefault()
       stopPropagation: value: ->
-        originalEvent.stopPropagation()
         propagationStopped = true
       stopImmediatePropagation: value: ->
-        originalEvent.stopImmediatePropagation()
         propagationStopped = true
         immediatePropagationStopped = true
+      preventDefault: value: ->
+        originalEvent.preventDefault()
       abortKeyBinding: value: ->
         originalEvent.abortKeyBinding?()
 
     @emitter.emit 'will-dispatch', syntheticEvent
 
-    loop
-      listeners = @inlineListenersByCommandName[originalEvent.type]?.get(currentTarget) ? []
-      if currentTarget.webkitMatchesSelector?
-        selectorBasedListeners =
-          (@selectorBasedListenersByCommandName[originalEvent.type] ? [])
-            .filter (listener) -> currentTarget.webkitMatchesSelector(listener.selector)
-            .sort (a, b) -> a.compare(b)
-        listeners = listeners.concat(selectorBasedListeners)
+    path = @getBubblePath(target)
 
-      matched = true if listeners.length > 0
-
-      for listener in listeners
+    # Capture phase: Invoke listeners registered via {::capture}, starting with
+    # the window and moving downward towards the event target.
+    eventPhase = Event.CAPTURING_PHASE
+    for pathIndex in [(path.length - 1)..0]
+      currentTarget = path[pathIndex]
+      listeners = @listenersForNode(currentTarget, type)
+      for listener in listeners when listener.useCapture
         break if immediatePropagationStopped
+        invokedListener = true
+        listener.callback.call(currentTarget, syntheticEvent)
+      break if propagationStopped
+
+    return invokedListener if propagationStopped
+
+    # Bubble phase: Invoke listeners registered via {::listen}, starting with
+    # the event target and moving upward towards the window. If the event's
+    # `.bubbles` property is false, we abort after dispatching on the target.
+    eventPhase = Event.BUBBLING_PHASE
+    for currentTarget in path
+      listeners = @listenersForNode(currentTarget, type)
+      for listener in listeners when not listener.useCapture
+        break if immediatePropagationStopped
+        invokedListener = true
         listener.callback.call(currentTarget, syntheticEvent)
 
-      break if currentTarget is window
+      break unless bubbles
       break if propagationStopped
-      currentTarget = currentTarget.parentNode ? window
 
-    matched
+    invokedListener
 
-  commandRegistered: (commandName) ->
+  commandRegistered: (commandName, inlineNode) ->
     unless @registeredCommands[commandName]
-      window.addEventListener(commandName, @handleCommandEvent, true)
+      @addEventListener(window, commandName, @handleCommandEvent, true)
       @registeredCommands[commandName] = true
 
+    if inlineNode? and not @registeredCommandsByInlineNode.get(inlineNode)?[commandName]
+      @addEventListener(inlineNode, commandName, @handleCommandEvent, true)
+      @registeredCommandsByInlineNode.set(inlineNode, {}) unless @registeredCommandsByInlineNode.has(inlineNode)
+      @registeredCommandsByInlineNode.get(inlineNode)[commandName] = true
+
+  getBubblePath: (target) ->
+    path = []
+    currentTarget = target
+    loop
+      path.push(currentTarget)
+      break if currentTarget is window
+      currentTarget = currentTarget.parentNode ? window
+    path
+
+  listenersForNode: (node, eventType) ->
+    listeners = @inlineListenersByCommandName[eventType]?.get(node) ? []
+    if node.matches?
+      selectorBasedListeners =
+        (@selectorBasedListenersByCommandName[eventType] ? [])
+          .filter (listener) -> node.matches(listener.selector)
+          .sort (a, b) -> a.compare(b)
+      listeners = listeners.concat(selectorBasedListeners)
+    listeners
+
 class SelectorBasedListener
-  constructor: (@selector, @callback) ->
+  constructor: (@selector, @callback, @useCapture) ->
     @specificity = (SpecificityCache[@selector] ?= specificity(@selector))
     @sequenceNumber = SequenceCount++
 
@@ -243,4 +379,4 @@ class SelectorBasedListener
       other.sequenceNumber - @sequenceNumber
 
 class InlineListener
-  constructor: (@callback) ->
+  constructor: (@callback, @useCapture) ->

src/package.coffee

@@ -375,7 +375,7 @@ class Package
         do (selector, command) =>
           # Add dummy command so it appears in menu.
           # The real command will be registered on package activation
-          @activationCommandSubscriptions.add atom.commands.add selector, command, ->
+          @activationCommandSubscriptions.add atom.commands.listen selector, command, ->
           @activationCommandSubscriptions.add atom.commands.onWillDispatch (event) =>
             return unless event.type is command
             currentTarget = event.target

src/space-pen-extensions.coffee

@@ -15,46 +15,53 @@ SpacePen.callRemoveHooks = (element) ->
   view.unsubscribe() for view in SpacePen.viewsForElement(element)
   SpacePenCallRemoveHooks(element)
 
-NativeEventNames = new Set
-NativeEventNames.add(nativeEvent) for nativeEvent in ["blur", "focus", "focusin",
-"focusout", "load", "resize", "scroll", "unload", "click", "dblclick", "mousedown",
-"mouseup", "mousemove", "mouseover", "mouseout", "mouseenter", "mouseleave", "change",
-"select", "submit", "keydown", "keypress", "keyup", "error", "contextmenu", "textInput",
-"textinput"]
-
 JQueryTrigger = jQuery.fn.trigger
-jQuery.fn.trigger = (eventName, data) ->
-  if NativeEventNames.has(eventName) or typeof eventName is 'object'
-    JQueryTrigger.call(this, eventName, data)
+jQuery.fn.trigger = (event, data) ->
+  if typeof event is 'object'
+    {type, target, originalEvent} = event
+    if originalEvent?
+      originalEvent.type ?= type
+      event = originalEvent
+  else
+    type = event
+
+  specialTrigger = jQuery.event.special[event]?.trigger
+
+  # Don't deal with namespaces
+  return JQueryTrigger.apply(this, arguments) unless type.indexOf('.') is -1
+
+  if target?
+    atom.commands.dispatch(target, event, data)
   else
     for element in this
-      atom.commands.dispatch(element, eventName, data)
-    this
+      continue if specialTrigger?.apply(element) is false
+      atom.commands.dispatch(element, event, data)
+  this
+
+# Allow command registry integration with focusin and focusout events
+# Otherwise jQuery registers these event handlers in a special way for bubbling
+# compatibility
+delete jQuery.event.special.focusin
+delete jQuery.event.special.focusout
 
 HandlersByOriginalHandler = new WeakMap
 CommandDisposablesByElement = new WeakMap
 
 AddEventListener = (element, type, listener) ->
-  if NativeEventNames.has(type)
-    element.addEventListener(type, listener)
-  else
-    disposable = atom.commands.add(element, type, listener)
+  disposable = atom.commands.listen(element, type, listener)
 
-    unless disposablesByType = CommandDisposablesByElement.get(element)
-      disposablesByType = {}
-      CommandDisposablesByElement.set(element, disposablesByType)
+  unless disposablesByType = CommandDisposablesByElement.get(element)
+    disposablesByType = {}
+    CommandDisposablesByElement.set(element, disposablesByType)
 
-    unless disposablesByListener = disposablesByType[type]
-      disposablesByListener = new WeakMap
-      disposablesByType[type] = disposablesByListener
+  unless disposablesByListener = disposablesByType[type]
+    disposablesByListener = new WeakMap
+    disposablesByType[type] = disposablesByListener
 
-    disposablesByListener.set(listener, disposable)
+  disposablesByListener.set(listener, disposable)
 
 RemoveEventListener = (element, type, listener) ->
-  if NativeEventNames.has(type)
-    element.removeEventListener(type, listener)
-  else
-    CommandDisposablesByElement.get(element)?[type]?.get(listener)?.dispose()
+  CommandDisposablesByElement.get(element)?[type]?.get(listener)?.dispose()
 
 JQueryEventAdd = jQuery.event.add
 jQuery.event.add = (elem, types, originalHandler, data, selector) ->

src/text-editor-component.coffee

@@ -197,7 +197,6 @@ TextEditorComponent = React.createClass
 
     parentView.__spacePenView.trigger 'editor:will-be-removed', [parentView.__spacePenView]
     @unsubscribe()
-    @scopedConfigSubscriptions.dispose()
     window.removeEventListener 'resize', @requestHeightAndWidthMeasurement
     clearInterval(@domPollingIntervalId)
     @domPollingIntervalId = null

src/text-editor-element.coffee

@@ -43,8 +43,6 @@ class TextEditorElement extends HTMLElement
     @mountComponent()
     @addGrammarScopeAttribute()
     @model.onDidChangeGrammar => @addGrammarScopeAttribute()
-    @addEncodingAttribute()
-    @model.onDidChangeEncoding => @addEncodingAttribute()
     @model.onDidDestroy => @unmountComponent()
     @__spacePenView.setModel(@model)
     @model
@@ -91,10 +89,7 @@ class TextEditorElement extends HTMLElement
 
   addGrammarScopeAttribute: ->
     grammarScope = @model.getGrammar()?.scopeName?.replace(/\./g, ' ')
-    @dataset.grammar = grammarScope
-
-  addEncodingAttribute: ->
-    @dataset.encoding = @model.getEncoding()
+    @setAttribute('data-grammar', grammarScope)
 
   hasFocus: ->
     this is document.activeElement or @contains(document.activeElement)
@@ -108,7 +103,7 @@ stopCommandEventPropagation = (commandListeners) ->
         commandListener.call(this, event)
   newCommandListeners
 
-atom.commands.add 'atom-text-editor', stopCommandEventPropagation(
+atom.commands.listen 'atom-text-editor', stopCommandEventPropagation(
   'core:move-left': -> @getModel().moveLeft()
   'core:move-right': -> @getModel().moveRight()
   'core:select-left': -> @getModel().selectLeft()
@@ -158,7 +153,7 @@ atom.commands.add 'atom-text-editor', stopCommandEventPropagation(
   'editor:lower-case': -> @getModel().lowerCase()
 )
 
-atom.commands.add 'atom-text-editor:not(.mini)', stopCommandEventPropagation(
+atom.commands.listen 'atom-text-editor:not(.mini)', stopCommandEventPropagation(
   'core:move-up': -> @getModel().moveUp()
   'core:move-down': -> @getModel().moveDown()
   'core:move-to-top': -> @getModel().moveToTop()

src/text-editor.coffee

@@ -134,11 +134,9 @@ class TextEditor extends Model
       @emitter.emit 'did-change-title', @getTitle()
       @emit "path-changed"
       @emitter.emit 'did-change-path', @getPath()
-    @subscribe @buffer.onDidChangeEncoding =>
-      @emitter.emit 'did-change-encoding', @getEncoding()
     @subscribe @buffer.onDidDestroy => @destroy()
 
-    # TODO: remove these when we remove the deprecations. They are old events.
+    # TODO: remove these thwne we remove the deprecations. They are old events.
     @subscribe @buffer.onDidStopChanging => @emit "contents-modified"
     @subscribe @buffer.onDidConflict => @emit "contents-conflicted"
     @subscribe @buffer.onDidChangeModified => @emit "modified-status-changed"
@@ -262,14 +260,6 @@ class TextEditor extends Model
   onDidChangeSoftWrapped: (callback) ->
     @displayBuffer.onDidChangeSoftWrapped(callback)
 
-  # Extended: Calls your `callback` when the buffer's encoding has changed.
-  #
-  # * `callback` {Function}
-  #
-  # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
-  onDidChangeEncoding: (callback) ->
-    @emitter.on 'did-change-encoding', callback
-
   # Extended: Calls your `callback` when the grammar that interprets and
   # colorizes the text has been changed. Immediately calls your callback with
   # the current grammar.
@@ -578,16 +568,6 @@ class TextEditor extends Model
   # Essential: Returns the {String} path of this editor's text buffer.
   getPath: -> @buffer.getPath()
 
-  # Extended: Returns the {String} character set encoding of this editor's text
-  # buffer.
-  getEncoding: -> @buffer.getEncoding()
-
-  # Extended: Set the character set encoding to use in this editor's text
-  # buffer.
-  #
-  # * `encoding` The {String} character set encoding name such as 'utf8'
-  setEncoding: (encoding) -> @buffer.setEncoding(encoding)
-
   # Essential: Returns {Boolean} `true` if this editor has been modified.
   isModified: -> @buffer.isModified()
 

src/theme-manager.coffee

@@ -159,14 +159,11 @@ class ThemeManager
     themeNames = atom.config.get('core.themes') ? []
     themeNames = [themeNames] unless _.isArray(themeNames)
     themeNames = themeNames.filter (themeName) ->
-      if themeName and typeof themeName is 'string'
-        return true if atom.packages.resolvePackagePath(themeName)
-        console.warn("Enabled theme '#{themeName}' is not installed.")
-      false
+      themeName and typeof themeName is 'string'
 
-    # Use a built-in syntax and UI theme any time the configured themes are not
-    # available.
-    if themeNames.length < 2
+    # Use a built-in syntax and UI theme when in safe mode since themes
+    # installed to ~/.atom/packages will not be loaded.
+    if @safeMode
       builtInThemeNames = [
         'atom-dark-syntax'
         'atom-dark-ui'

src/window-event-handler.coffee

@@ -65,7 +65,7 @@ class WindowEventHandler
 
     @subscribeToCommand $(document), 'core:focus-previous', @focusPrevious
 
-    document.addEventListener 'keydown', @onKeydown
+    atom.commands.listen window, 'keydown', @onKeydown
 
     @subscribe $(document), 'drop', (e) ->
       e.preventDefault()

src/workspace-element.coffee

@@ -114,7 +114,7 @@ class WorkspaceElement extends HTMLElement
 
   focusPaneViewOnRight: -> @paneContainer.focusPaneViewOnRight()
 
-atom.commands.add 'atom-workspace',
+atom.commands.listen 'atom-workspace',
   'window:increase-font-size': -> @getModel().increaseFontSize()
   'window:decrease-font-size': -> @getModel().decreaseFontSize()
   'window:reset-font-size': -> @getModel().resetFontSize()
@@ -160,6 +160,6 @@ atom.commands.add 'atom-workspace',
   'core:save-as': -> @getModel().saveActivePaneItemAs()
 
 if process.platform is 'darwin'
-  atom.commands.add 'atom-workspace', 'window:install-shell-commands', -> @getModel().installShellCommands()
+  atom.commands.listen 'atom-workspace', 'window:install-shell-commands', -> @getModel().installShellCommands()
 
 module.exports = WorkspaceElement = document.registerElement 'atom-workspace', prototype: WorkspaceElement.prototype

src/workspace.coffee

@@ -402,6 +402,8 @@ class Workspace extends Model
       item ?= opener(atom.project.resolve(uri), options) for opener in @getOpeners() when !item
     item ?= atom.project.open(uri, options)
 
+    console.profile('open')
+
     Q(item)
       .then (item) =>
         if not pane
@@ -413,6 +415,7 @@ class Workspace extends Model
         index = pane.getActiveItemIndex()
         @emit "uri-opened"
         @emitter.emit 'did-open', {uri, pane, item, index}
+        console.profileEnd('open')
         item
       .catch (error) ->
         console.error(error.stack ? error)

static/index.js

@@ -2,15 +2,10 @@ window.onload = function() {
   try {
     var startTime = Date.now();
 
-    var path = require('path');
-
     // Skip "?loadSettings=".
     var loadSettings = JSON.parse(decodeURIComponent(location.search.substr(14)));
 
-    // Normalize to make sure drive letter case is consistent on Windows
-    process.resourcesPath = path.normalize(process.resourcesPath);
-
-    var devMode = loadSettings.devMode || !loadSettings.resourcePath.startsWith(process.resourcesPath + path.sep);
+    var devMode = loadSettings.devMode || !loadSettings.resourcePath.startsWith(process.resourcesPath + require('path').sep);
 
     // Require before the module cache in dev mode
     if (devMode) {