Prepare 0.88.0 release

This replaces calls to `@editor.on` with `@subscribe @editor`. That
causes us to correctly unsubscribe when the editor is removed, avoiding
a memory leak.

keymaps/linux.cson

@@ -16,7 +16,7 @@
   # Sublime Parity
   'ctrl-N': 'application:new-window'
   'ctrl-W': 'window:close'
-  'ctrl-o': 'application:open'
+  'ctrl-o': 'application:open-file'
   'ctrl-q': 'application:quit'
   'ctrl-T': 'pane:reopen-closed-item'
   'ctrl-n': 'application:new-file'

keymaps/win32.cson

@@ -14,7 +14,7 @@
   # Sublime Parity
   'ctrl-N': 'application:new-window'
   'ctrl-W': 'window:close'
-  'ctrl-o': 'application:open'
+  'ctrl-o': 'application:open-file'
   'ctrl-T': 'pane:reopen-closed-item'
   'ctrl-n': 'application:new-file'
   'ctrl-s': 'core:save'

menus/darwin.cson

@@ -4,10 +4,10 @@
     submenu: [
       { label: 'About Atom', command: 'application:about' }
       { label: 'View License', command: 'application:open-license' }
-      { label: "VERSION", enabled: false }
-      { label: "Restart and Install Update", command: 'application:install-update', visible: false}
-      { label: "Check for Update", command: 'application:check-for-update', visible: false}
-      { label: "Downloading Update", command: 'application:check-for-update', enabled: false, visible: false}
+      { label: 'VERSION', enabled: false }
+      { label: 'Restart and Install Update', command: 'application:install-update', visible: false}
+      { label: 'Check for Update', command: 'application:check-for-update', visible: false}
+      { label: 'Downloading Update', enabled: false, visible: false}
       { type: 'separator' }
       { label: 'Preferences...', command: 'application:show-settings' }
       { label: 'Open Your Config', command: 'application:open-your-config' }

menus/linux.cson

@@ -4,7 +4,8 @@
     submenu: [
       { label: 'New &Window', command: 'application:new-window' }
       { label: '&New File', command: 'application:new-file' }
-      { label: '&Open...', command: 'application:open' }
+      { label: '&Open File...', command: 'application:open-file' }
+      { label: 'Open Folder...', command: 'application:open-folder' }
       { label: 'Reopen Last &Item', command: 'pane:reopen-closed-item' }
       { type: 'separator' }
       { label: '&Preferences...', command: 'application:show-settings' }

menus/win32.cson

@@ -4,7 +4,8 @@
     submenu: [
       { label: 'New &Window', command: 'application:new-window' }
       { label: '&New File', command: 'application:new-file' }
-      { label: '&Open...', command: 'application:open' }
+      { label: '&Open File...', command: 'application:open-file' }
+      { label: 'Open Folder...', command: 'application:open-folder' }
       { label: 'Reopen Last &Item', command: 'pane:reopen-closed-item' }
       { type: 'separator' }
       { label: '&Preferences...', command: 'application:show-settings' }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "atom",
   "productName": "Atom",
-  "version": "0.85.0",
+  "version": "0.88.0",
   "description": "A hackable text editor for the 21st Century.",
   "main": "./src/browser/main.js",
   "repository": {
@@ -12,7 +12,7 @@
     "url": "https://github.com/atom/atom/issues"
   },
   "license": "All Rights Reserved",
-  "atomShellVersion": "0.11.8",
+  "atomShellVersion": "0.11.10",
   "dependencies": {
     "async": "0.2.6",
     "atom-keymap": "^0.17.0",
@@ -30,7 +30,6 @@
     "grim": "0.6.0",
     "guid": "0.0.10",
     "jasmine-tagged": "^1.1.1",
-    "keytar": "1.x",
     "less-cache": "0.12.0",
     "mixto": "1.x",
     "mkdirp": "0.3.5",
@@ -73,18 +72,18 @@
     "command-palette": "0.20.0",
     "dev-live-reload": "0.30.0",
     "exception-reporting": "0.17.0",
-    "feedback": "0.29.0",
+    "feedback": "0.30.0",
     "find-and-replace": "0.97.0",
-    "fuzzy-finder": "0.47.0",
+    "fuzzy-finder": "0.49.0",
     "git-diff": "0.28.0",
     "go-to-line": "0.19.0",
     "grammar-selector": "0.24.0",
     "image-view": "0.32.0",
-    "keybinding-resolver": "0.16.0",
-    "link": "0.21.0",
-    "markdown-preview": "0.61.0",
+    "keybinding-resolver": "0.17.0",
+    "link": "0.22.0",
+    "markdown-preview": "0.62.0",
     "metrics": "0.32.0",
-    "open-on-github": "0.27.0",
+    "open-on-github": "0.28.0",
     "package-generator": "0.30.0",
     "release-notes": "0.26.0",
     "settings-view": "0.107.0",
@@ -95,7 +94,7 @@
     "symbols-view": "0.49.0",
     "tabs": "0.34.0",
     "timecop": "0.17.0",
-    "tree-view": "0.87.0",
+    "tree-view": "0.89.0",
     "update-package-dependencies": "0.6.0",
     "welcome": "0.12.0",
     "whitespace": "0.22.0",
@@ -118,14 +117,14 @@
     "language-php": "0.14.0",
     "language-property-list": "0.7.0",
     "language-python": "0.15.0",
-    "language-ruby": "0.21.0",
+    "language-ruby": "0.22.0",
     "language-ruby-on-rails": "0.12.0",
     "language-sass": "0.8.0",
     "language-shellscript": "0.8.0",
     "language-source": "0.7.0",
-    "language-sql": "0.7.0",
+    "language-sql": "0.8.0",
     "language-text": "0.6.0",
-    "language-todo": "0.9.0",
+    "language-todo": "0.10.0",
     "language-toml": "0.12.0",
     "language-xml": "0.11.0",
     "language-yaml": "0.6.0"

spec/editor-spec.coffee

@@ -1424,7 +1424,7 @@ describe "Editor", ->
           editor.undo()
           expect(editor.getCursorBufferPosition()).toEqual [3,4]
 
-      it "indents the new line to the same indent level as the current line when editor.autoIndent is true", ->
+      it "indents the new line to the correct level when editor.autoIndent is true", ->
         atom.config.set('editor.autoIndent', true)
 
         editor.setText('  var test')
@@ -1444,6 +1444,15 @@ describe "Editor", ->
         expect(editor.lineForBufferRow(1)).toBe '  '
         expect(editor.lineForBufferRow(2)).toBe '  var test'
 
+        editor.setText('function() {\n}')
+        editor.setCursorBufferPosition([1,1])
+        editor.insertNewlineAbove()
+
+        expect(editor.getCursorBufferPosition()).toEqual [1,2]
+        expect(editor.lineForBufferRow(0)).toBe 'function() {'
+        expect(editor.lineForBufferRow(1)).toBe '  '
+        expect(editor.lineForBufferRow(2)).toBe '}'
+
     describe ".backspace()", ->
       describe "when there is a single cursor", ->
         changeScreenRangeHandler = null

spec/editor-view-spec.coffee

@@ -432,9 +432,9 @@ describe "EditorView", ->
           editorView.setFontFamily('sans-serif')
 
       it "positions the cursor to the clicked row and column", ->
-          {top, left} = editorView.pixelOffsetForScreenPosition([3, 30])
-          editorView.renderedLines.trigger mousedownEvent(pageX: left, pageY: top)
-          expect(editor.getCursorScreenPosition()).toEqual [3, 30]
+        {top, left} = editorView.pixelOffsetForScreenPosition([3, 30])
+        editorView.renderedLines.trigger mousedownEvent(pageX: left, pageY: top)
+        expect(editor.getCursorScreenPosition()).toEqual [3, 30]
 
     describe "double-click", ->
       it "selects the word under the cursor, and expands the selection wordwise in either direction on a subsequent shift-click", ->
@@ -464,6 +464,20 @@ describe "EditorView", ->
         editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [3, 12], originalEvent: {detail: 1}, shiftKey: true)
         expect(editor.getSelectedBufferRange()).toEqual [[3, 10], [3, 12]]
 
+      it "stops selecting by word when another selection is made", ->
+        expect(editor.getCursorScreenPosition()).toEqual(row: 0, column: 0)
+        editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [0, 8], originalEvent: {detail: 1})
+        editorView.renderedLines.trigger 'mouseup'
+        editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [0, 8], originalEvent: {detail: 2})
+        editorView.renderedLines.trigger 'mouseup'
+        expect(editor.getSelectedText()).toBe "quicksort"
+
+        editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [3, 10])
+        editorView.renderedLines.trigger mousemoveEvent(editorView: editorView, point: [3, 12], which: 1)
+        editorView.renderedLines.trigger 'mouseup'
+
+        expect(editor.getSelectedBufferRange()).toEqual [[3, 10], [3, 12]]
+
       describe "when clicking between a word and a non-word", ->
         it "selects the word", ->
           expect(editor.getCursorScreenPosition()).toEqual(row: 0, column: 0)

spec/project-spec.coffee

@@ -33,21 +33,7 @@ describe "Project", ->
       deserializedProject.getBuffers()[0].destroy()
       expect(deserializedProject.getBuffers().length).toBe 0
 
-  describe "when an edit session is destroyed", ->
-    it "removes edit session and calls destroy on buffer (if buffer is not referenced by other edit sessions)", ->
-      editor = atom.project.openSync("a")
-      anotherEditor = atom.project.openSync("a")
-
-      expect(atom.project.editors.length).toBe 2
-      expect(editor.buffer).toBe anotherEditor.buffer
-
-      editor.destroy()
-      expect(atom.project.editors.length).toBe 1
-
-      anotherEditor.destroy()
-      expect(atom.project.editors.length).toBe 0
-
-  describe "when an edit session is saved and the project has no path", ->
+  describe "when an editor is saved and the project has no path", ->
     it "sets the project's path to the saved file's parent directory", ->
       tempFile = temp.openSync().path
       atom.project.setPath(undefined)
@@ -56,73 +42,49 @@ describe "Project", ->
       editor.saveAs(tempFile)
       expect(atom.project.getPath()).toBe path.dirname(tempFile)
 
-  describe "when an edit session is copied", ->
-    it "emits an 'editor-created' event and stores the edit session", ->
-      handler = jasmine.createSpy('editorCreatedHandler')
-      atom.project.on 'editor-created', handler
-
-      editor1 = atom.project.openSync("a")
-      expect(handler.callCount).toBe 1
-      expect(atom.project.getEditors().length).toBe 1
-      expect(atom.project.getEditors()[0]).toBe editor1
-
-      editor2 = editor1.copy()
-      expect(handler.callCount).toBe 2
-      expect(atom.project.getEditors().length).toBe 2
-      expect(atom.project.getEditors()[0]).toBe editor1
-      expect(atom.project.getEditors()[1]).toBe editor2
-
   describe ".openSync(path)", ->
-    [absolutePath, newBufferHandler, newEditorHandler] = []
+    [absolutePath, newBufferHandler] = []
     beforeEach ->
       absolutePath = require.resolve('./fixtures/dir/a')
       newBufferHandler = jasmine.createSpy('newBufferHandler')
       atom.project.on 'buffer-created', newBufferHandler
-      newEditorHandler = jasmine.createSpy('newEditorHandler')
-      atom.project.on 'editor-created', newEditorHandler
 
     describe "when given an absolute path that hasn't been opened previously", ->
-      it "returns a new edit session for the given path and emits 'buffer-created' and 'editor-created' events", ->
+      it "returns a new edit session for the given path and emits 'buffer-created'", ->
         editor = atom.project.openSync(absolutePath)
         expect(editor.buffer.getPath()).toBe absolutePath
         expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
-        expect(newEditorHandler).toHaveBeenCalledWith editor
 
     describe "when given a relative path that hasn't been opened previously", ->
-      it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'editor-created' events", ->
+      it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created'", ->
         editor = atom.project.openSync('a')
         expect(editor.buffer.getPath()).toBe absolutePath
         expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
-        expect(newEditorHandler).toHaveBeenCalledWith editor
 
     describe "when passed the path to a buffer that has already been opened", ->
-      it "returns a new edit session containing previously opened buffer and emits a 'editor-created' event", ->
+      it "returns a new edit session containing previously opened buffer", ->
         editor = atom.project.openSync(absolutePath)
         newBufferHandler.reset()
         expect(atom.project.openSync(absolutePath).buffer).toBe editor.buffer
         expect(atom.project.openSync('a').buffer).toBe editor.buffer
         expect(newBufferHandler).not.toHaveBeenCalled()
-        expect(newEditorHandler).toHaveBeenCalledWith editor
 
     describe "when not passed a path", ->
-      it "returns a new edit session and emits 'buffer-created' and 'editor-created' events", ->
+      it "returns a new edit session and emits 'buffer-created'", ->
         editor = atom.project.openSync()
         expect(editor.buffer.getPath()).toBeUndefined()
         expect(newBufferHandler).toHaveBeenCalledWith(editor.buffer)
-        expect(newEditorHandler).toHaveBeenCalledWith editor
 
   describe ".open(path)", ->
-    [absolutePath, newBufferHandler, newEditorHandler] = []
+    [absolutePath, newBufferHandler] = []
 
     beforeEach ->
       absolutePath = require.resolve('./fixtures/dir/a')
       newBufferHandler = jasmine.createSpy('newBufferHandler')
       atom.project.on 'buffer-created', newBufferHandler
-      newEditorHandler = jasmine.createSpy('newEditorHandler')
-      atom.project.on 'editor-created', newEditorHandler
 
     describe "when given an absolute path that isn't currently open", ->
-      it "returns a new edit session for the given path and emits 'buffer-created' and 'editor-created' events", ->
+      it "returns a new edit session for the given path and emits 'buffer-created'", ->
         editor = null
         waitsForPromise ->
           atom.project.open(absolutePath).then (o) -> editor = o
@@ -130,10 +92,9 @@ describe "Project", ->
         runs ->
           expect(editor.buffer.getPath()).toBe absolutePath
           expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
-          expect(newEditorHandler).toHaveBeenCalledWith editor
 
     describe "when given a relative path that isn't currently opened", ->
-      it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'editor-created' events", ->
+      it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created'", ->
         editor = null
         waitsForPromise ->
           atom.project.open(absolutePath).then (o) -> editor = o
@@ -141,10 +102,9 @@ describe "Project", ->
         runs ->
           expect(editor.buffer.getPath()).toBe absolutePath
           expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
-          expect(newEditorHandler).toHaveBeenCalledWith editor
 
     describe "when passed the path to a buffer that is currently opened", ->
-      it "returns a new edit session containing currently opened buffer and emits a 'editor-created' event", ->
+      it "returns a new edit session containing currently opened buffer", ->
         editor = null
         waitsForPromise ->
           atom.project.open(absolutePath).then (o) -> editor = o
@@ -154,10 +114,9 @@ describe "Project", ->
           expect(atom.project.openSync(absolutePath).buffer).toBe editor.buffer
           expect(atom.project.openSync('a').buffer).toBe editor.buffer
           expect(newBufferHandler).not.toHaveBeenCalled()
-          expect(newEditorHandler).toHaveBeenCalledWith editor
 
     describe "when not passed a path", ->
-      it "returns a new edit session and emits 'buffer-created' and 'editor-created' events", ->
+      it "returns a new edit session and emits 'buffer-created'", ->
         editor = null
         waitsForPromise ->
           atom.project.open().then (o) -> editor = o
@@ -165,7 +124,6 @@ describe "Project", ->
         runs ->
           expect(editor.buffer.getPath()).toBeUndefined()
           expect(newBufferHandler).toHaveBeenCalledWith(editor.buffer)
-          expect(newEditorHandler).toHaveBeenCalledWith editor
 
     it "returns number of read bytes as progress indicator", ->
       filePath = atom.project.resolve 'a'

spec/workspace-spec.coffee

@@ -5,7 +5,7 @@ describe "Workspace", ->
 
   beforeEach ->
     atom.project.setPath(atom.project.resolve('dir'))
-    workspace = new Workspace
+    atom.workspace = workspace = new Workspace
 
   describe "::open(uri, options)", ->
     beforeEach ->
@@ -152,6 +152,18 @@ describe "Workspace", ->
           workspace.open("bar://baz").then (item) ->
             expect(item).toEqual { bar: "bar://baz" }
 
+    it "emits an 'editor-created' event", ->
+      absolutePath = require.resolve('./fixtures/dir/a')
+      newEditorHandler = jasmine.createSpy('newEditorHandler')
+      workspace.on 'editor-created', newEditorHandler
+
+      editor = null
+      waitsForPromise ->
+        workspace.open(absolutePath).then (e) -> editor = e
+
+      runs ->
+        expect(newEditorHandler).toHaveBeenCalledWith editor
+
   describe "::openSync(uri, options)", ->
     [activePane, initialItemCount] = []
 
@@ -245,3 +257,26 @@ describe "Workspace", ->
     it "opens the license as plain-text in a buffer", ->
       waitsForPromise -> workspace.openLicense()
       runs -> expect(workspace.activePaneItem.getText()).toMatch /Copyright/
+
+  describe "when an editor is destroyed", ->
+    it "removes the editor", ->
+      editor = null
+
+      waitsForPromise ->
+        workspace.open("a").then (e) -> editor = e
+
+      runs ->
+        expect(workspace.getEditors()).toHaveLength 1
+        editor.destroy()
+        expect(workspace.getEditors()).toHaveLength 0
+
+  describe "when an editor is copied", ->
+    it "emits an 'editor-created' event", ->
+      handler = jasmine.createSpy('editorCreatedHandler')
+      workspace.on 'editor-created', handler
+
+      editor1 = workspace.openSync("a")
+      expect(handler.callCount).toBe 1
+
+      editor2 = editor1.copy()
+      expect(handler.callCount).toBe 2

src/atom.coffee

@@ -1,6 +1,5 @@
 crypto = require 'crypto'
 ipc = require 'ipc'
-keytar = require 'keytar'
 os = require 'os'
 path = require 'path'
 remote = require 'remote'
@@ -223,12 +222,26 @@ class Atom extends Model
     else
       @center()
 
+  storeDefaultWindowDimensions: ->
+    dimensions = JSON.stringify(atom.getWindowDimensions())
+    localStorage.setItem("defaultWindowDimensions", dimensions)
+
+  getDefaultWindowDimensions: ->
+    {windowDimensions} = @getLoadSettings()
+    return windowDimensions if windowDimensions?
+
+    dimensions = null
+    try
+      dimensions = JSON.parse(localStorage.getItem("defaultWindowDimensions"))
+    catch error
+      console.warn "Error parsing default window dimensions", error
+      localStorage.removeItem("defaultWindowDimensions")
+
+    {width, height} = screen.getPrimaryDisplay().workAreaSize
+    dimensions ? {x: 0, y: 0, width: Math.min(1024, width), height: height}
+
   restoreWindowDimensions: ->
-    workAreaSize = screen.getPrimaryDisplay().workAreaSize
-    windowDimensions = @state.windowDimensions ? {}
-    {initialSize} = @getLoadSettings()
-    windowDimensions.height ?= initialSize?.height ? workAreaSize.height
-    windowDimensions.width ?= initialSize?.width ? Math.min(workAreaSize.width, 1024)
+    windowDimensions = @state.windowDimensions ? @getDefaultWindowDimensions()
     @setWindowDimensions(windowDimensions)
 
   storeWindowDimensions: ->
@@ -470,17 +483,6 @@ class Atom extends Model
   isReleasedVersion: ->
     @constructor.isReleasedVersion()
 
-  getGitHubAuthTokenName: ->
-    'Atom GitHub API Token'
-
-  # Public: Set the the github token in the keychain
-  setGitHubAuthToken: (token) ->
-    keytar.replacePassword(@getGitHubAuthTokenName(), 'github', token)
-
-  # Public: Get the github token from the keychain
-  getGitHubAuthToken: ->
-    keytar.getPassword(@getGitHubAuthTokenName(), 'github')
-
   # Public: Get the directory path to Atom's configuration area.
   #
   # Returns the absolute path to ~/.atom

src/browser/application-menu.coffee

@@ -12,24 +12,25 @@ class ApplicationMenu
   constructor: (@version) ->
     @menu = Menu.buildFromTemplate @getDefaultTemplate()
     Menu.setApplicationMenu @menu
+    global.atomApplication.autoUpdateManager.on 'state-changed', (state) =>
+      @showUpdateMenuItem(state)
 
   # Public: Updates the entire menu with the given keybindings.
   #
-  # * template:
-  #   The Object which describes the menu to display.
-  # * keystrokesByCommand:
-  #   An Object where the keys are commands and the values are Arrays containing
-  #   the keystroke.
+  # template - The Object which describes the menu to display.
+  # keystrokesByCommand - An Object where the keys are commands and the values
+  #                       are Arrays containing the keystroke.
   update: (template, keystrokesByCommand) ->
     @translateTemplate(template, keystrokesByCommand)
     @substituteVersion(template)
     @menu = Menu.buildFromTemplate(template)
     Menu.setApplicationMenu(@menu)
 
+    @showUpdateMenuItem(global.atomApplication.autoUpdateManager.getState())
+
   # Flattens the given menu and submenu items into an single Array.
   #
-  # * menu:
-  #   A complete menu configuration object for atom-shell's menu API.
+  # menu - A complete menu configuration object for atom-shell's menu API.
   #
   # Returns an Array of native menu items.
   flattenMenuItems: (menu) ->
@@ -41,8 +42,7 @@ class ApplicationMenu
 
   # Flattens the given menu template into an single Array.
   #
-  # * template:
-  #   An object describing the menu item.
+  # template - An object describing the menu item.
   #
   # Returns an Array of native menu items.
   flattenMenuTemplate: (template) ->
@@ -54,44 +54,36 @@ class ApplicationMenu
 
   # Public: Used to make all window related menu items are active.
   #
-  # * enable:
-  #   If true enables all window specific items, if false disables all  window
-  #   specific items.
+  # enable - If true enables all window specific items, if false disables all
+  #          window specific items.
   enableWindowSpecificItems: (enable) ->
     for item in @flattenMenuItems(@menu)
       item.enabled = enable if item.metadata?['windowSpecific']
 
   # Replaces VERSION with the current version.
   substituteVersion: (template) ->
-    if (item = _.find(@flattenMenuTemplate(template), (i) -> i.label == 'VERSION'))
+    if (item = _.find(@flattenMenuTemplate(template), ({label}) -> label == 'VERSION'))
       item.label = "Version #{@version}"
 
-  # Toggles Install Update Item
-  showInstallUpdateItem: (visible=true) ->
-    if visible
-      @showDownloadingUpdateItem(false)
-      @showCheckForUpdateItem(false)
+  # Sets the proper visible state the update menu items
+  showUpdateMenuItem: (state) ->
+    checkForUpdateItem = _.find(@flattenMenuItems(@menu), ({label}) -> label == 'Check for Update')
+    downloadingUpdateItem = _.find(@flattenMenuItems(@menu), ({label}) -> label == 'Downloading Update')
+    installUpdateItem = _.find(@flattenMenuItems(@menu), ({label}) -> label == 'Restart and Install Update')
 
-    if (item = _.find(@flattenMenuItems(@menu), (i) -> i.label == 'Restart and Install Update'))
-      item.visible = visible
+    return unless checkForUpdateItem? and downloadingUpdateItem? and installUpdateItem?
 
-  # Toggles Downloading Update Item
-  showDownloadingUpdateItem: (visible=true) ->
-    if visible
-      @showInstallUpdateItem(false)
-      @showCheckForUpdateItem(false)
+    checkForUpdateItem.visible = false
+    downloadingUpdateItem.visible = false
+    installUpdateItem.visible = false
 
-    if (item = _.find(@flattenMenuItems(@menu), (i) -> i.label == 'Downloading Update'))
-      item.visible = visible
-
-  # Toggles Check For Update Item
-  showCheckForUpdateItem: (visible=true) ->
-    if visible
-      @showDownloadingUpdateItem(false)
-      @showInstallUpdateItem(false)
-
-    if (item = _.find(@flattenMenuItems(@menu), (i) -> i.label == 'Check for Update'))
-      item.visible = visible
+    switch state
+      when 'idle', 'error', 'no-update-available'
+        checkForUpdateItem.visible = true
+      when 'checking', 'downloading'
+        downloadingUpdateItem.visible = true
+      when 'update-available'
+        installUpdateItem.visible = true
 
   # Default list of menu items.
   #
@@ -100,6 +92,7 @@ class ApplicationMenu
     [
       label: "Atom"
       submenu: [
+          { label: "Check for Update", metadata: {autoUpdate: true}}
           { label: 'Reload', accelerator: 'Command+R', click: => @focusedWindow()?.reload() }
           { label: 'Close Window', accelerator: 'Command+Shift+W', click: => @focusedWindow()?.close() }
           { label: 'Toggle Dev Tools', accelerator: 'Command+Alt+I', click: => @focusedWindow()?.toggleDevTools() }
@@ -112,17 +105,15 @@ class ApplicationMenu
 
   # Combines a menu template with the appropriate keystroke.
   #
-  # * template:
-  #   An Object conforming to atom-shell's menu api but lacking accelerator and
-  #   click properties.
-  # * keystrokesByCommand:
-  #   An Object where the keys are commands and the values are Arrays containing
-  #   the keystroke.
+  # template - An Object conforming to atom-shell's menu api but lacking
+  #            accelerator and click properties.
+  # keystrokesByCommand - An Object where the keys are commands and the values
+  #                       are Arrays containing the keystroke.
   #
   # Returns a complete menu configuration object for atom-shell's menu API.
   translateTemplate: (template, keystrokesByCommand) ->
     template.forEach (item) =>
-      item.metadata = {}
+      item.metadata ?= {}
       if item.command
         item.accelerator = @acceleratorForCommand(item.command, keystrokesByCommand)
         item.click = => global.atomApplication.sendCommand(item.command)
@@ -132,11 +123,9 @@ class ApplicationMenu
 
   # Determine the accelerator for a given command.
   #
-  # * command:
-  #   The name of the command.
-  # * keystrokesByCommand:
-  #   An Object where the keys are commands and the values are Arrays containing
-  #   the keystroke.
+  # command - The name of the command.
+  # keystrokesByCommand - An Object where the keys are commands and the values
+  #                       are Arrays containing the keystroke.
   #
   # Returns a String containing the keystroke in a format that can be interpreted
   #   by atom shell to provide nice icons where available.

src/browser/atom-application.coffee

@@ -1,9 +1,9 @@
 AtomWindow = require './atom-window'
 ApplicationMenu = require './application-menu'
 AtomProtocolHandler = require './atom-protocol-handler'
+AutoUpdateManager = require './auto-update-manager'
 BrowserWindow = require 'browser-window'
 Menu = require 'menu'
-autoUpdater = require 'auto-updater'
 app = require 'app'
 dialog = require 'dialog'
 fs = require 'fs'
@@ -66,13 +66,13 @@ class AtomApplication
     @pathsToOpen ?= []
     @windows = []
 
+    @autoUpdateManager = new AutoUpdateManager(@version)
     @applicationMenu = new ApplicationMenu(@version)
     @atomProtocolHandler = new AtomProtocolHandler(@resourcePath)
 
     @listenForArgumentsFromNewProcess()
     @setupJavaScriptArguments()
     @handleEvents()
-    @setupAutoUpdater()
 
     @openWithOptions(options)
 
@@ -96,6 +96,8 @@ class AtomApplication
   addWindow: (window) ->
     @windows.push window
     @applicationMenu?.enableWindowSpecificItems(true)
+    window.once 'window:loaded', =>
+      @autoUpdateManager.emitUpdateAvailableEvent(window)
 
   # Creates server to listen for additional atom application launches.
   #
@@ -127,59 +129,21 @@ class AtomApplication
   setupJavaScriptArguments: ->
     app.commandLine.appendSwitch 'js-flags', '--harmony'
 
-  # Enable updates unless running from a local build of Atom.
-  setupAutoUpdater: ->
-    return if /\w{7}/.test(@version) # Only released versions should check for updates.
-
-    autoUpdater.setFeedUrl "https://atom.io/api/updates?version=#{@version}"
-
-    autoUpdater.on 'checking-for-update', =>
-      @applicationMenu.showDownloadingUpdateItem(false)
-      @applicationMenu.showInstallUpdateItem(false)
-      @applicationMenu.showCheckForUpdateItem(false)
-
-    autoUpdater.on 'update-not-available', =>
-      @applicationMenu.showCheckForUpdateItem(true)
-
-    autoUpdater.on 'update-available', =>
-      @applicationMenu.showDownloadingUpdateItem(true)
-
-    autoUpdater.on 'update-downloaded', (event, releaseNotes, releaseVersion, releaseDate, releaseURL) =>
-      atomWindow.sendCommand('window:update-available', [releaseVersion, releaseNotes]) for atomWindow in @windows
-      @applicationMenu.showInstallUpdateItem(true)
-
-    autoUpdater.on 'error', (event, message) =>
-      @applicationMenu.showCheckForUpdateItem(true)
-
-    # Check for update after Atom has fully started and the menus are created
-    setTimeout((-> autoUpdater.checkForUpdates()), 5000)
-
-  checkForUpdate: ->
-    @onUpdateNotAvailable ?= =>
-      autoUpdater.removeListener 'error', @onUpdateError
-      dialog.showMessageBox type: 'info', buttons: ['OK'], message: 'No update available.', detail: "Version #{@version} is the latest version."
-
-    @onUpdateError ?= (event, message) =>
-      autoUpdater.removeListener 'update-not-available', @onUpdateNotAvailable
-      dialog.showMessageBox type: 'warning', buttons: ['OK'], message: 'There was an error checking for updates.', detail: message
-
-    autoUpdater.once 'update-not-available', @onUpdateNotAvailable
-    autoUpdater.once 'error', @onUpdateError
-    autoUpdater.checkForUpdates()
-
   # Registers basic application commands, non-idempotent.
   handleEvents: ->
     @on 'application:run-all-specs', -> @runSpecs(exitWhenDone: false, resourcePath: global.devResourcePath)
     @on 'application:run-benchmarks', -> @runBenchmarks()
     @on 'application:quit', -> app.quit()
-    @on 'application:new-window', -> @openPath(initialSize: @getFocusedWindowSize())
+    @on 'application:new-window', -> @openPath(windowDimensions: @focusedWindow()?.getDimensions())
     @on 'application:new-file', -> (@focusedWindow() ? this).openPath()
-    @on 'application:open', -> @promptForPath()
+    @on 'application:open', -> @promptForPath(type: 'all')
+    @on 'application:open-file', -> @promptForPath(type: 'file')
+    @on 'application:open-folder', -> @promptForPath(type: 'folder')
     @on 'application:open-dev', -> @promptForPath(devMode: true)
     @on 'application:inspect', ({x,y}) -> @focusedWindow().browserWindow.inspectElement(x, y)
     @on 'application:open-documentation', -> shell.openExternal('https://atom.io/docs/latest/?app')
-    @on 'application:install-update', -> autoUpdater.quitAndInstall()
-    @on 'application:check-for-update', => @checkForUpdate()
+    @on 'application:install-update', -> @autoUpdateManager.install()
+    @on 'application:check-for-update', => @autoUpdateManager.check()
 
     if process.platform is 'darwin'
       @on 'application:about', -> Menu.sendActionToFirstResponder('orderFrontStandardAboutPanel:')
@@ -254,10 +218,8 @@ class AtomApplication
   #
   # If it isn't handled globally, delegate to the currently focused window.
   #
-  # * command:
-  #   The string representing the command.
-  # * args:
-  #   The optional arguments to pass along.
+  # command - The string representing the command.
+  # args - The optional arguments to pass along.
   sendCommand: (command, args...) ->
     unless @emit(command, args...)
       focusedWindow = @focusedWindow()
@@ -286,8 +248,8 @@ class AtomApplication
   #
   # A new window will be created if there is no currently focused window.
   #
-  # * eventName: The event to listen for.
-  # * pathToOpen: The path to open when the event is triggered.
+  # eventName - The event to listen for.
+  # pathToOpen - The path to open when the event is triggered.
   openPathOnEvent: (eventName, pathToOpen) ->
     @on eventName, ->
       if window = @focusedWindow()
@@ -304,45 +266,25 @@ class AtomApplication
   focusedWindow: ->
     _.find @windows, (atomWindow) -> atomWindow.isFocused()
 
-  # Public: Get the height and width of the focused window.
-  #
-  # Returns an object with height and width keys or null if there is no
-  # focused window.
-  getFocusedWindowSize: ->
-    if focusedWindow = @focusedWindow()
-      [width, height] = focusedWindow.getSize()
-      {width, height}
-    else
-      null
-
   # Public: Opens multiple paths, in existing windows if possible.
   #
-  # * options
-  #    + pathsToOpen:
-  #      The array of file paths to open
-  #    + pidToKillWhenClosed:
-  #      The integer of the pid to kill
-  #    + newWindow:
-  #      Boolean of whether this should be opened in a new window.
-  #    + devMode:
-  #      Boolean to control the opened window's dev mode.
+  # options -
+  #   :pathsToOpen - The array of file paths to open
+  #   :pidToKillWhenClosed - The integer of the pid to kill
+  #   :newWindow - Boolean of whether this should be opened in a new window.
+  #   :devMode - Boolean to control the opened window's dev mode.
   openPaths: ({pathsToOpen, pidToKillWhenClosed, newWindow, devMode}) ->
     @openPath({pathToOpen, pidToKillWhenClosed, newWindow, devMode}) for pathToOpen in pathsToOpen ? []
 
   # Public: Opens a single path, in an existing window if possible.
   #
-  # * options
-  #    + pathToOpen:
-  #      The file path to open
-  #    + pidToKillWhenClosed:
-  #      The integer of the pid to kill
-  #    + newWindow:
-  #      Boolean of whether this should be opened in a new window.
-  #    + devMode:
-  #      Boolean to control the opened window's dev mode.
-  #    + initialSize:
-  #      Object with height and width keys.
-  openPath: ({pathToOpen, pidToKillWhenClosed, newWindow, devMode, initialSize}={}) ->
+  # options -
+  #   :pathToOpen - The file path to open
+  #   :pidToKillWhenClosed - The integer of the pid to kill
+  #   :newWindow - Boolean of whether this should be opened in a new window.
+  #   :devMode - Boolean to control the opened window's dev mode.
+  #   :windowDimensions - Object with height and width keys.
+  openPath: ({pathToOpen, pidToKillWhenClosed, newWindow, devMode, windowDimensions}={}) ->
     if pathToOpen
       [basename, initialLine] = path.basename(pathToOpen).split(':')
       if initialLine
@@ -362,7 +304,7 @@ class AtomApplication
 
       bootstrapScript ?= require.resolve('../window-bootstrap')
       resourcePath ?= @resourcePath
-      openedWindow = new AtomWindow({pathToOpen, initialLine, bootstrapScript, resourcePath, devMode, initialSize})
+      openedWindow = new AtomWindow({pathToOpen, initialLine, bootstrapScript, resourcePath, devMode, windowDimensions})
 
     if pidToKillWhenClosed?
       @pidsToOpenWindows[pidToKillWhenClosed] = openedWindow
@@ -394,11 +336,9 @@ class AtomApplication
   # responsible for opening the URL.  A new window will be created with
   # that package's `urlMain` as the bootstrap script.
   #
-  # * options
-  #    + urlToOpen:
-  #      The atom:// url to open.
-  #    + devMode:
-  #      Boolean to control the opened window's dev mode.
+  # options -
+  #   :urlToOpen - The atom:// url to open.
+  #   :devMode - Boolean to control the opened window's dev mode.
   openUrl: ({urlToOpen, devMode}) ->
     unless @packages?
       PackageManager = require '../package-manager'
@@ -414,7 +354,8 @@ class AtomApplication
       if pack.urlMain
         packagePath = @packages.resolvePackagePath(packageName)
         bootstrapScript = path.resolve(packagePath, pack.urlMain)
-        new AtomWindow({bootstrapScript, @resourcePath, devMode, urlToOpen, initialSize: @getFocusedWindowSize()})
+        windowDimensions = @focusedWindow()?.getDimensions()
+        new AtomWindow({bootstrapScript, @resourcePath, devMode, urlToOpen, windowDimensions})
       else
         console.log "Package '#{pack.name}' does not have a url main: #{urlToOpen}"
     else
@@ -422,13 +363,11 @@ class AtomApplication
 
   # Opens up a new {AtomWindow} to run specs within.
   #
-  # * options
-  #    + exitWhenDone:
-  #      A Boolean that if true, will close the window upon completion.
-  #    + resourcePath:
-  #      The path to include specs from.
-  #    + specPath:
-  #      The directory to load specs from.
+  # options -
+  #   :exitWhenDone - A Boolean that if true, will close the window upon
+  #                   completion.
+  #   :resourcePath - The path to include specs from.
+  #   :specPath - The directory to load specs from.
   runSpecs: ({exitWhenDone, resourcePath, specDirectory, logFile}) ->
     if resourcePath isnt @resourcePath and not fs.existsSync(resourcePath)
       resourcePath = @resourcePath
@@ -455,10 +394,18 @@ class AtomApplication
   #
   # Once paths are selected, they're opened in a new or existing {AtomWindow}s.
   #
-  # * options
-  #    + devMode:
-  #      A Boolean which controls whether any newly opened windows should  be in
-  #      dev mode or not.
-  promptForPath: ({devMode}={}) ->
-    dialog.showOpenDialog title: 'Open', properties: ['openFile', 'openDirectory', 'multiSelections', 'createDirectory'], (pathsToOpen) =>
+  # options -
+  #   :type - A String which specifies the type of the dialog, could be 'file',
+  #           'folder' or 'all'. The 'all' is only available on OS X.
+  #   :devMode - A Boolean which controls whether any newly opened windows
+  #              should  be in dev mode or not.
+  promptForPath: ({type, devMode}={}) ->
+    type ?= 'all'
+    properties =
+      switch type
+        when 'file' then ['openFile']
+        when 'folder' then ['openDirectory']
+        when 'all' then ['openFile', 'openDirectory']
+        else throw new Error("#{type} is an invalid type for promptForPath")
+    dialog.showOpenDialog title: 'Open', properties: properties.concat(['multiSelections', 'createDirectory']), (pathsToOpen) =>
       @openPaths({pathsToOpen, devMode})

src/browser/atom-window.coffee

@@ -7,9 +7,12 @@ path = require 'path'
 fs = require 'fs'
 url = require 'url'
 _ = require 'underscore-plus'
+{EventEmitter} = require 'events'
 
 module.exports =
 class AtomWindow
+  _.extend @prototype, EventEmitter.prototype
+
   @iconPath: path.resolve(__dirname, '..', '..', 'resources', 'atom.png')
   @includeShellLoadTime: true
 
@@ -38,7 +41,10 @@ class AtomWindow
       loadSettings.initialPath = path.dirname(pathToOpen)
 
     @browserWindow.loadSettings = loadSettings
-    @browserWindow.once 'window:loaded', => @loaded = true
+    @browserWindow.once 'window:loaded', =>
+      @emit 'window:loaded'
+      @loaded = true
+
     @browserWindow.loadUrl @getUrl(loadSettings)
     @browserWindow.focusOnWebView() if @isSpec
 
@@ -132,12 +138,15 @@ class AtomWindow
     action = if args[0]?.contextCommand then 'context-command' else 'command'
     ipc.sendChannel @browserWindow.getProcessId(), @browserWindow.getRoutingId(), action, command, args...
 
+  getDimensions: ->
+    [x, y] = @browserWindow.getPosition()
+    [width, height] = @browserWindow.getSize()
+    {x, y, width, height}
+
   close: -> @browserWindow.close()
 
   focus: -> @browserWindow.focus()
 
-  getSize: -> @browserWindow.getSize()
-
   minimize: -> @browserWindow.minimize()
 
   maximize: -> @browserWindow.maximize()

src/browser/auto-update-manager.coffee

@@ -0,0 +1,76 @@
+autoUpdater = require 'auto-updater'
+dialog = require 'dialog'
+_ = require 'underscore-plus'
+{EventEmitter} = require 'events'
+
+IDLE_STATE='idle'
+CHECKING_STATE='checking'
+DOWNLOADING_STATE='downloading'
+UPDATE_AVAILABLE_STATE='update-available'
+NO_UPDATE_AVAILABLE_STATE='no-update-available'
+ERROR_STATE='error'
+
+module.exports =
+class AutoUpdateManager
+  _.extend @prototype, EventEmitter.prototype
+
+  constructor: (@version) ->
+    @state = IDLE_STATE
+
+    # Only released versions should check for updates.
+    return if /\w{7}/.test(@version)
+
+    autoUpdater.setFeedUrl "https://atom.io/api/updates?version=#{@version}"
+
+    autoUpdater.on 'checking-for-update', =>
+      @setState(CHECKING_STATE)
+
+    autoUpdater.on 'update-not-available', =>
+      @setState(NO_UPDATE_AVAILABLE_STATE)
+
+    autoUpdater.on 'update-available', =>
+      @setState(DOWNLOADING_STATE)
+
+    autoUpdater.on 'error', (event, message) =>
+      @setState(ERROR_STATE)
+      console.error "Error Downloading Update: #{message}"
+
+    autoUpdater.on 'update-downloaded', (event, @releaseNotes, @releaseVersion) =>
+      @setState(UPDATE_AVAILABLE_STATE)
+      @emitUpdateAvailableEvent(@getWindows()...)
+
+    @check(hidePopups: true)
+
+  emitUpdateAvailableEvent: (windows...) ->
+    return unless @releaseVersion? and @releaseNotes
+    for atomWindow in windows
+      atomWindow.sendCommand('window:update-available', [@releaseVersion, @releaseNotes])
+
+  setState: (state) ->
+    return unless @state != state
+    @state = state
+    @emit 'state-changed', @state
+
+  getState: ->
+    @state
+
+  check: ({hidePopups}={})->
+    unless hidePopups
+      autoUpdater.once 'update-not-available', @onUpdateNotAvailable
+      autoUpdater.once 'error', @onUpdateError
+
+    autoUpdater.checkForUpdates()
+
+  install: ->
+    autoUpdater.quitAndInstall()
+
+  onUpdateNotAvailable: =>
+    autoUpdater.removeListener 'error', @onUpdateError
+    dialog.showMessageBox type: 'info', buttons: ['OK'], message: 'No update available.', detail: "Version #{@version} is the latest version."
+
+  onUpdateError: (event, message) =>
+    autoUpdater.removeListener 'update-not-available', @onUpdateNotAvailable
+    dialog.showMessageBox type: 'warning', buttons: ['OK'], message: 'There was an error checking for updates.', detail: message
+
+  getWindows: ->
+    global.atomApplication.windows

src/editor-view.coffee

@@ -527,7 +527,7 @@ class EditorView extends View
 
     if @editor
       @saveScrollPositionForEditor()
-      @editor.off(".editor")
+      @unsubscribe(@editor)
 
     @editor = editor
 
@@ -535,34 +535,34 @@ class EditorView extends View
 
     @editor.setVisible(true)
 
-    @editor.on "destroyed", =>
+    @subscribe @editor, "destroyed", =>
       @remove()
 
-    @editor.on "contents-conflicted.editor", =>
+    @subscribe @editor, "contents-conflicted", =>
       @showBufferConflictAlert(@editor)
 
-    @editor.on "path-changed.editor", =>
+    @subscribe @editor, "path-changed", =>
       @editor.reloadGrammar()
       @trigger 'editor:path-changed'
 
-    @editor.on "grammar-changed.editor", =>
+    @subscribe @editor, "grammar-changed", =>
       @trigger 'editor:grammar-changed'
 
-    @editor.on 'selection-added.editor', (selection) =>
+    @subscribe @editor, 'selection-added', (selection) =>
       @newCursors.push(selection.cursor)
       @newSelections.push(selection)
       @requestDisplayUpdate()
 
-    @editor.on 'screen-lines-changed.editor', (e) =>
+    @subscribe @editor, 'screen-lines-changed', (e) =>
       @handleScreenLinesChange(e)
 
-    @editor.on 'scroll-top-changed.editor', (scrollTop) =>
+    @subscribe @editor, 'scroll-top-changed', (scrollTop) =>
       @scrollTop(scrollTop)
 
-    @editor.on 'scroll-left-changed.editor', (scrollLeft) =>
+    @subscribe @editor, 'scroll-left-changed', (scrollLeft) =>
       @scrollLeft(scrollLeft)
 
-    @editor.on 'soft-wrap-changed.editor', (softWrap) =>
+    @subscribe @editor, 'soft-wrap-changed', (softWrap) =>
       @setSoftWrap(softWrap)
 
     @trigger 'editor:path-changed'

src/editor.coffee

@@ -182,7 +182,7 @@ class Editor extends Model
     @subscribe @$scrollTop, (scrollTop) => @emit 'scroll-top-changed', scrollTop
     @subscribe @$scrollLeft, (scrollLeft) => @emit 'scroll-left-changed', scrollLeft
 
-    atom.project.addEditor(this) if registerEditor
+    atom.workspace?.editorAdded(this) if registerEditor
 
   serializeParams: ->
     id: @id
@@ -225,19 +225,17 @@ class Editor extends Model
     @buffer.release()
     @displayBuffer.destroy()
     @languageMode.destroy()
-    atom.project?.removeEditor(this)
 
   # Create an {Editor} with its initial state based on this object
   copy: ->
     tabLength = @getTabLength()
     displayBuffer = @displayBuffer.copy()
     softTabs = @getSoftTabs()
-    newEditor = new Editor({@buffer, displayBuffer, tabLength, softTabs, suppressCursorCreation: true})
+    newEditor = new Editor({@buffer, displayBuffer, tabLength, softTabs, suppressCursorCreation: true, registerEditor: true})
     newEditor.setScrollTop(@getScrollTop())
     newEditor.setScrollLeft(@getScrollLeft())
     for marker in @findMarkers(editorId: @id)
       marker.copy(editorId: newEditor.id, preserveFolds: true)
-    atom.project.addEditor(newEditor)
     newEditor
 
   # Public: Get the title the editor's title for display in other parts of the
@@ -630,7 +628,9 @@ class Editor extends Model
       @moveCursorToBeginningOfLine()
       @moveCursorLeft()
       @insertNewline()
-      @setIndentationForBufferRow(bufferRow, indentLevel) if @shouldAutoIndent()
+
+      if @shouldAutoIndent() and @indentationForBufferRow(bufferRow) < indentLevel
+        @setIndentationForBufferRow(bufferRow, indentLevel)
 
       if onFirstLine
         @moveCursorUp()

src/project.coffee

@@ -31,13 +31,11 @@ class Project extends Model
 
   constructor: ({path, @buffers}={}) ->
     @buffers ?= []
-    @openers = []
 
     for buffer in @buffers
       do (buffer) =>
         buffer.once 'destroyed', => @removeBuffer(buffer)
 
-    @editors = []
     @setPath(path)
 
   serializeParams: ->
@@ -49,7 +47,6 @@ class Project extends Model
     params
 
   destroyed: ->
-    editor.destroy() for editor in @getEditors()
     buffer.destroy() for buffer in @getBuffers()
     @destroyRepo()
 
@@ -132,15 +129,6 @@ class Project extends Model
     filePath = @resolve(filePath)
     @buildEditorForBuffer(@bufferForPathSync(filePath), options)
 
-  # Add the given {Editor}.
-  addEditor: (editor) ->
-    @editors.push editor
-    @emit 'editor-created', editor
-
-  # Return and removes the given {Editor}.
-  removeEditor: (editor) ->
-    _.remove(@editors, editor)
-
   # Retrieves all the {TextBuffer}s in the project; that is, the
   # buffers for all open files.
   #
@@ -153,7 +141,7 @@ class Project extends Model
     @findBufferForPath(@resolve(filePath))?.isModified()
 
   findBufferForPath: (filePath) ->
-   _.find @buffers, (buffer) -> buffer.getPath() == filePath
+    _.find @buffers, (buffer) -> buffer.getPath() == filePath
 
   # Only to be used in specs
   bufferForPathSync: (filePath) ->
@@ -304,8 +292,7 @@ class Project extends Model
     deferred.promise
 
   buildEditorForBuffer: (buffer, editorOptions) ->
-    editor = new Editor(_.extend({buffer}, editorOptions))
-    @addEditor(editor)
+    editor = new Editor(_.extend({buffer, registerEditor: true}, editorOptions))
     editor
 
   eachBuffer: (args...) ->
@@ -321,20 +308,19 @@ class Project extends Model
   # Deprecated: delegate
   registerOpener: (opener) ->
     deprecate("Use Workspace::registerOpener instead")
-    @openers.push(opener)
+    atom.workspace.registerOpener(opener)
 
   # Deprecated: delegate
   unregisterOpener: (opener) ->
     deprecate("Use Workspace::unregisterOpener instead")
-    _.remove(@openers, opener)
+    atom.workspace.unregisterOpener(opener)
 
   # Deprecated: delegate
   eachEditor: (callback) ->
     deprecate("Use Workspace::eachEditor instead")
-    callback(editor) for editor in @getEditors()
-    @on 'editor-created', (editor) -> callback(editor)
+    atom.workspace.eachEditor(callback)
 
   # Deprecated: delegate
   getEditors: ->
     deprecate("Use Workspace::getEditors instead")
-    new Array(@editors...)
+    atom.workspace.getEditors()

src/selection.coffee

@@ -99,6 +99,7 @@ class Selection
   clear: ->
     @marker.setAttributes(goalBufferRange: null)
     @marker.clearTail() unless @retainSelection
+    @finalize()
 
   # Public: Modifies the selection to encompass the current word.
   #

src/window-event-handler.coffee

@@ -37,18 +37,21 @@ class WindowEventHandler
       @reloadRequested = false
       confirmed
 
+    @subscribe $(window), 'blur unload', ->
+      atom.storeDefaultWindowDimensions()
+
     @subscribe $(window), 'unload', ->
       atom.storeWindowDimensions()
 
-    @subscribeToCommand $(window), 'window:toggle-full-screen', => atom.toggleFullScreen()
+    @subscribeToCommand $(window), 'window:toggle-full-screen', -> atom.toggleFullScreen()
 
-    @subscribeToCommand $(window), 'window:close', => atom.close()
+    @subscribeToCommand $(window), 'window:close', -> atom.close()
 
     @subscribeToCommand $(window), 'window:reload', =>
       @reloadRequested = true
       atom.reload()
 
-    @subscribeToCommand $(window), 'window:toggle-dev-tools', => atom.toggleDevTools()
+    @subscribeToCommand $(window), 'window:toggle-dev-tools', -> atom.toggleDevTools()
 
     @subscribeToCommand $(document), 'core:focus-next', @focusNext
 
@@ -92,7 +95,7 @@ class WindowEventHandler
     bindCommandToAction('core:redo', 'redo:')
     bindCommandToAction('core:select-all', 'selectAll:')
 
-  openLink: (event) =>
+  openLink: (event) ->
     location = $(event.target).attr('href')
     if location and location[0] isnt '#' and /^https?:\/\//.test(location)
       shell.openExternal(location)

src/workspace-view.coffee

@@ -116,6 +116,8 @@ class WorkspaceView extends View
     @command 'application:new-window', -> ipc.sendChannel('command', 'application:new-window')
     @command 'application:new-file', -> ipc.sendChannel('command', 'application:new-file')
     @command 'application:open', -> ipc.sendChannel('command', 'application:open')
+    @command 'application:open-file', -> ipc.sendChannel('command', 'application:open-file')
+    @command 'application:open-folder', -> ipc.sendChannel('command', 'application:open-folder')
     @command 'application:open-dev', -> ipc.sendChannel('command', 'application:open-dev')
     @command 'application:minimize', -> ipc.sendChannel('command', 'application:minimize')
     @command 'application:zoom', -> ipc.sendChannel('command', 'application:zoom')

src/workspace.coffee

@@ -1,10 +1,11 @@
 {deprecate} = require 'grim'
-{remove, last} = require 'underscore-plus'
+_ = require 'underscore-plus'
 {join} = require 'path'
 {Model} = require 'theorist'
 Q = require 'q'
 Serializable = require 'serializable'
 Delegator = require 'delegato'
+Editor = require './editor'
 PaneContainer = require './pane-container'
 Pane = require './pane'
 
@@ -28,6 +29,9 @@ class Workspace extends Model
 
   constructor: ->
     super
+
+    @openers = []
+
     @subscribe @paneContainer, 'item-destroyed', @onPaneItemDestroyed
     @registerOpener (filePath) =>
       switch filePath
@@ -50,6 +54,9 @@ class Workspace extends Model
     paneContainer: @paneContainer.serialize()
     fullScreen: atom.isFullScreen()
 
+  editorAdded: (editor) ->
+    @emit 'editor-created', editor
+
   # Public: Register a function to be called for every current and future
   # {Editor} in the workspace.
   #
@@ -58,13 +65,18 @@ class Workspace extends Model
   # Returns a subscription object with an `.off` method that you can call to
   # unregister the callback.
   eachEditor: (callback) ->
-    atom.project.eachEditor(callback)
+    callback(editor) for editor in @getEditors()
+    @subscribe this, 'editor-created', (editor) -> callback(editor)
 
   # Public: Get all current editors in the workspace.
   #
   # Returns an {Array} of {Editor}s.
   getEditors: ->
-    atom.project.getEditors()
+    editors = []
+    for pane in @paneContainer.getPanes()
+      editors.push(item) for item in pane.getItems() when item instanceof Editor
+
+    editors
 
   # Public: Open a given a URI in Atom asynchronously.
   #
@@ -172,14 +184,14 @@ class Workspace extends Model
   #
   # opener - A {Function} to be called when a path is being opened.
   registerOpener: (opener) ->
-    atom.project.registerOpener(opener)
+    @openers.push(opener)
 
   # Public: Unregister an opener registered with {::registerOpener}.
   unregisterOpener: (opener) ->
-    atom.project.unregisterOpener(opener)
+    _.remove(@openers, opener)
 
   getOpeners: ->
-    atom.project.openers
+    @openers
 
   # Public: Get the active {Pane}.
   #
@@ -262,7 +274,7 @@ class Workspace extends Model
   # Removes the item's uri from the list of potential items to reopen.
   itemOpened: (item) ->
     if uri = item.getUri?()
-      remove(@destroyedItemUris, uri)
+      _.remove(@destroyedItemUris, uri)
 
   # Adds the destroyed item's uri to the list of items to reopen.
   onPaneItemDestroyed: (item) =>