Prepare 0.43.0 release

Update to atom-shell v0.7.6.

CONTRIBUTING.md

@@ -1,67 +1,57 @@
-# :rotating_light: Contributing to Atom :rotating_light:
+# :tada: Contributing to Atom :tada:
 
+These are just guidelines, not rules, use your best judgement and feel free
+to propose changes to this document in a pull request.
 
 ## Issues
   * Include screenshots and animated GIFs whenever possible, they are immensely
-    helpful
+    helpful.
   * Include the behavior you expected to happen and other places you've seen
     that behavior such as Emacs, vi, Xcode, etc.
-  * Check the Console app for stack traces to include if reporting a crash
-  * Check the Dev tools (`alt-cmd-i`) for errors and stack traces to include
+  * Check the Console app for stack traces to include if reporting a crash.
+  * Check the Dev tools (`alt-cmd-i`) for errors and stack traces to include.
+  
+### Package Repositories
 
-## Code
+This is the repository for the core Atom editor only. Atom comes bundled with
+many packages and themes that are stored in other repos under the
+[atom org](https://github.com/atom) such as [tabs](https://github.com/atom/tabs),
+[find-and-replace](https://github.com/atom/find-and-replace),
+[language-javascript](https://github.com/atom/language-javascript),
+and [atom-light-ui](http://github.com/atom/atom-light-ui).
+
+If you think you know which package is causing the issue you are reporting, feel
+free to open up the issue in that specific repository instead. When in doubt
+just open the issue here but be aware that it may get closed here and reopened
+in the proper package's repository.
+
+## Pull Requests
+  * Include screenshots and animated GIFs whenever possible.
   * Follow the [JavaScript](https://github.com/styleguide/javascript) and
     [CSS](https://github.com/styleguide/css) styleguides
   * Include thoughtfully worded [Jasmine](http://pivotal.github.com/jasmine/)
     specs
-  * Add 3rd-party packages as a `package.json` dependency
-  * Commit messages are in the present tense
-  * Commit messages that improve the format of the code start with :lipstick:
-  * Commit messages that improve the performance start with :racehorse:
-  * Commit messages that remove memory leaks start with :non-potable_water:
-  * Commit messages that improve documentation start with :memo:
-  * Files end with a newline
+  * Avoid placing files in `vendor`. 3rd-party packages should be added as a
+    `package.json` dependency.
+  * Files end with a newline.
+  * Requires should be in the following order:
+    * Built in Node Modules (such as `path`)
+    * Built in Atom and Atom Shell Modules (such as `atom`, `shell`)
+    * Local Modules (using relative paths)
   * Class variables and methods should be in the following order:
-    * Class variables (variables starting with a `@`)
     * Class methods (methods starting with a `@`)
-    * Instance variables
     * Instance methods
   * Beware of platform differences
-    * The home directory is `process.env.USERPROFILE` on Windows, while on OS X
-      and Linux it's `process.env.HOME`
-    * Path separator is `\` on Windows, and is `/` on OS X and Linux, so use
-      `path.join` to concatenate filenames
+    * Use `require('atom').fs.getHomeDirectory()` to get the home directory.
+    * Use `path.join()` to concatenate filenames.
     * Temporary directory is not `/tmp` on Windows, use `os.tmpdir()` when
       possible
 
-## Philosophy
-
-### Write Beautiful Code
-Once you get something working, take the time to consider whether you can achieve it in a more elegant way. We're planning on open-sourcing Atom, so let's put our best foot forward.
-
-### When in doubt, pair-up
-Pairing can be an effective and fun way to pass on culture, knowledge, and taste. If you can find the time, we encourage you to work synchronously with other community members of all experience levels to help the knowledge-mulching process. It doesn't have to be all the time; a little pairing goes a long way.
-
-### Write tests, and write them first
-The test suite keeps protects our codebase from the ravages of entropy, but it only works when we have thorough coverage. Before you write implementation code, write a  failing test proving that it's needed.
-
-### Leave the test suite better than you found it
-Consider how the specs you are adding fit into the spec-file as a whole. Is this the right place for your spec? Does the spec need to be reorganized now that you're adding this extra dimension? Specs are only as useful as the next person's ability to understand them.
-
-### Solve today's problem
-Avoid adding flexibility that isn't needed *today*. Nothing is ever set in stone, and we can always go back and add flexibility later. Adding it early just means we have to pay for complexity that we might not end up using.
-
-### Favor clarity over brevity or cleverness.
-Three lines that someone else can read are better than one line that's tricky.
-
-### Don't be defensive
-Only catch exceptions that are truly exceptional. Assume that components we control will honor their contracts. If they don't, the solution is to find and fix the problem in code rather than cluttering the code with attempts to foresee all potential issues at runtime.
-
-### Don't be afraid to add classes and methods
-Code rarely suffers from too many methods and classes, and  often suffers from too few. Err on the side of numerous short, well-named methods. Pull out classes with well-defined roles.
-
-### Rip shit out
-Don't be afraid to delete code. Don't be afraid to rewrite something that needs to be refreshed. If it's in version control, we can always resurrect it.
-
-### Maintain a consistent level of abstraction
-Every line in a method should read at the same basic level of abstraction. If there's a section of a method that goes into a lot more detail than the rest of the method, consider extracting a new method and giving it a clear name.
+## Git Commit Messages
+  * Use the present tense
+  * Reference issues and pull requests liberally
+  * Consider starting the commit message with an applicable emoji:
+    * :lipstick: when improving the format/structure of the code
+    * :racehorse: when improving performance
+    * :non-potable_water: when plugging memory leaks
+    * :memo: when writing docs

Gruntfile.coffee

@@ -7,6 +7,10 @@ _ = require 'underscore-plus'
 
 packageJson = require './package.json'
 
+# OAuth token for atom-bot
+# TODO Remove once all repositories are public
+process.env.ATOM_ACCESS_TOKEN ?= '362295be4c5258d3f7b967bbabae662a455ca2a7'
+
 module.exports = (grunt) ->
   if not grunt.option('verbose')
     grunt.log.writeln = (args...) -> grunt.log
@@ -20,6 +24,7 @@ module.exports = (grunt) ->
     buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
     shellAppDir = path.join(buildDir, appName)
     appDir = path.join(shellAppDir, 'resources', 'app')
+    atomShellDownloadDir = path.join(os.tmpdir(), 'atom-cached-atom-shells')
   else
     appName = 'Atom.app'
     tmpDir = '/tmp'
@@ -28,6 +33,7 @@ module.exports = (grunt) ->
     shellAppDir = path.join(buildDir, appName)
     contentsDir = path.join(shellAppDir, 'Contents')
     appDir = path.join(contentsDir, 'Resources', 'app')
+    atomShellDownloadDir = '/tmp/atom-cached-atom-shells'
 
   installDir = path.join(installRoot, appName)
 
@@ -168,6 +174,12 @@ module.exports = (grunt) ->
             _.extend(context, parsed.attributes)
             parsed.body
 
+    'download-atom-shell':
+      version: packageJson.atomShellVersion
+      outputDir: 'atom-shell'
+      downloadDir: atomShellDownloadDir
+      rebuild: true  # rebuild native modules after atom-shell is updated
+
     shell:
       'kill-atom':
         command: 'pkill -9 Atom'
@@ -183,13 +195,14 @@ module.exports = (grunt) ->
   grunt.loadNpmTasks('grunt-contrib-coffee')
   grunt.loadNpmTasks('grunt-contrib-less')
   grunt.loadNpmTasks('grunt-markdown')
+  grunt.loadNpmTasks('grunt-download-atom-shell')
   grunt.loadNpmTasks('grunt-shell')
   grunt.loadTasks('tasks')
 
   grunt.registerTask('compile', ['coffee', 'prebuild-less', 'cson'])
   grunt.registerTask('lint', ['coffeelint', 'csslint', 'lesslint'])
   grunt.registerTask('test', ['shell:kill-atom', 'run-specs'])
-  grunt.registerTask('ci', ['update-atom-shell', 'build', 'set-development-version', 'lint', 'test'])
-  grunt.registerTask('deploy', ['partial-clean', 'update-atom-shell', 'build', 'codesign'])
+  grunt.registerTask('ci', ['download-atom-shell', 'build', 'set-development-version', 'lint', 'test'])
+  grunt.registerTask('deploy', ['partial-clean', 'download-atom-shell', 'build', 'codesign'])
   grunt.registerTask('docs', ['markdown:guides', 'build-docs'])
-  grunt.registerTask('default', ['update-atom-shell', 'build', 'set-development-version', 'install'])
+  grunt.registerTask('default', ['download-atom-shell', 'build', 'set-development-version', 'install'])

LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2013 GitHub Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -1,30 +1,17 @@
-# Atom — Futuristic Text Editing
+# Atom — The hackable, ~~collaborative~~ editor of tomorrow!
 
-![atom](https://s3.amazonaws.com/speakeasy/apps/icons/27/medium/7db16e44-ba57-11e2-8c6f-981faf658e00.png)
+![Atom](http://i.imgur.com/OrTvUAD.png)
 
-Check out our [guides](https://www.atom.io/docs/latest/) and [API documentation](https://www.atom.io/docs/api/v34.0.0/api/)
+Check out our [guides and API documentation](https://www.atom.io/docs/latest/).
 
 ## Installing
 
-Download the latest Atom release from [speakeasy](https://speakeasy.githubapp.com/apps/27).
+Download the latest [Atom release](https://github.com/atom/atom/releases/latest).
 
-It will automatically update when a new release is available.
+Atom will automatically update when a new release is available.
 
 ## Building
 
-### Requirements
-
-  * Mountain Lion
-    * Looking for Windows support? Read [here][building].
-  * Boxen (Obviously Atom won't release with this requirement)
-
-### Installation
-
-  1. `gh-setup atom`
-
-  2. `cd ~/github/atom`
-
-  3. `script/build`
-
+Follow the instructions in the [build docs][building].
 
 [building]: https://github.com/atom/atom/blob/master/docs/building-atom.md

benchmark/benchmark-helper.coffee

@@ -73,8 +73,8 @@ window.clickEvent = (properties={}) ->
 
 window.mouseEvent = (type, properties) ->
   if properties.point
-    {point, editor} = properties
-    {top, left} = @pagePixelPositionForPoint(editor, point)
+    {point, editorView} = properties
+    {top, left} = @pagePixelPositionForPoint(editorView, point)
     properties.pageX = left + 1
     properties.pageY = top + 1
   properties.originalEvent ?= {detail: 1}
@@ -86,14 +86,14 @@ window.mousedownEvent = (properties={}) ->
 window.mousemoveEvent = (properties={}) ->
   window.mouseEvent('mousemove', properties)
 
-window.pagePixelPositionForPoint = (editor, point) ->
+window.pagePixelPositionForPoint = (editorView, point) ->
   point = Point.fromObject point
-  top = editor.lines.offset().top + point.row * editor.lineHeight
-  left = editor.lines.offset().left + point.column * editor.charWidth - editor.lines.scrollLeft()
+  top = editorView.lines.offset().top + point.row * editorView.lineHeight
+  left = editorView.lines.offset().left + point.column * editorView.charWidth - editorView.lines.scrollLeft()
   { top, left }
 
-window.setEditorWidthInChars = (editor, widthInChars, charWidth=editor.charWidth) ->
-  editor.width(charWidth * widthInChars + editor.lines.position().left)
+window.seteditorViewWidthInChars = (editorView, widthInChars, charWidth=editorView.charWidth) ->
+  editorView.width(charWidth * widthInChars + editorView.lines.position().left)
 
 $.fn.resultOfTrigger = (type) ->
   event = $.Event(type)

benchmark/benchmark-suite.coffee

@@ -1,30 +1,30 @@
 require './benchmark-helper'
-{$, _, RootView} = require 'atom'
+{$, _, WorkspaceView} = require 'atom'
 TokenizedBuffer = require '../src/tokenized-buffer'
 
-describe "editor.", ->
-  editor = null
+describe "editorView.", ->
+  editorView = null
 
   beforeEach ->
-    window.rootViewParentSelector = '#jasmine-content'
-    window.rootView = new RootView
-    window.rootView.attachToDom()
+    atom.workspaceViewParentSelector = '#jasmine-content'
+    atom.workspaceView = new WorkspaceView
+    atom.workspaceView.attachToDom()
 
-    rootView.width(1024)
-    rootView.height(768)
-    rootView.openSync() # open blank editor
-    editor = rootView.getActiveView()
+    atom.workspaceView.width(1024)
+    atom.workspaceView.height(768)
+    atom.workspaceView.openSync()
+    editorView = atom.workspaceView.getActiveView()
 
   afterEach ->
-    if editor.pendingDisplayUpdate
+    if editorView.pendingDisplayUpdate
       waitsFor "editor to finish rendering", (done) ->
-        editor.on 'editor:display-updated', done
+        editorView.on 'editor:display-updated', done
 
   describe "keymap.", ->
     event = null
 
     beforeEach ->
-      event = keydownEvent('x', target: editor.hiddenInput[0])
+      event = keydownEvent('x', target: editorView.hiddenInput[0])
 
     benchmark "keydown-event-with-no-binding", 10, ->
       keymap.handleKeyEvent(event)
@@ -35,90 +35,90 @@ describe "editor.", ->
 
   describe "empty-file.", ->
     benchmark "insert-delete", ->
-      editor.insertText('x')
-      editor.backspace()
+      editorView.insertText('x')
+      editorView.backspace()
 
   describe "300-line-file.", ->
     beforeEach ->
-      rootView.openSync('medium.coffee')
+      atom.workspaceView.openSync('medium.coffee')
 
     describe "at-begining.", ->
       benchmark "insert-delete", ->
-        editor.insertText('x')
-        editor.backspace()
+        editorView.insertText('x')
+        editorView.backspace()
 
       benchmark "insert-delete-rehighlight", ->
-        editor.insertText('"')
-        editor.backspace()
+        editorView.insertText('"')
+        editorView.backspace()
 
     describe "at-end.", ->
       beforeEach ->
-        editor.moveCursorToBottom()
+        editorView.moveCursorToBottom()
 
       benchmark "insert-delete", ->
-        editor.insertText('"')
-        editor.backspace()
+        editorView.insertText('"')
+        editorView.backspace()
 
     describe "empty-vs-set-innerHTML.", ->
       [firstRow, lastRow] = []
       beforeEach ->
-        firstRow = editor.getFirstVisibleScreenRow()
-        lastRow = editor.getLastVisibleScreenRow()
+        firstRow = editorView.getFirstVisibleScreenRow()
+        lastRow = editorView.getLastVisibleScreenRow()
 
       benchmark "build-gutter-html.", 1000, ->
-        editor.gutter.renderLineNumbers(null, firstRow, lastRow)
+        editorView.gutter.renderLineNumbers(null, firstRow, lastRow)
 
       benchmark "set-innerHTML.", 1000, ->
-        editor.gutter.renderLineNumbers(null, firstRow, lastRow)
-        editor.gutter.lineNumbers[0].innerHtml = ''
+        editorView.gutter.renderLineNumbers(null, firstRow, lastRow)
+        editorView.gutter.lineNumbers[0].innerHtml = ''
 
       benchmark "empty.", 1000, ->
-        editor.gutter.renderLineNumbers(null, firstRow, lastRow)
-        editor.gutter.lineNumbers.empty()
+        editorView.gutter.renderLineNumbers(null, firstRow, lastRow)
+        editorView.gutter.lineNumbers.empty()
 
     describe "positionLeftForLineAndColumn.", ->
       line = null
       beforeEach ->
-        editor.scrollTop(2000)
-        editor.resetDisplay()
-        line = editor.lineElementForScreenRow(106)[0]
+        editorView.scrollTop(2000)
+        editorView.resetDisplay()
+        line = editorView.lineElementForScreenRow(106)[0]
 
       describe "one-line.", ->
         beforeEach ->
-          editor.clearCharacterWidthCache()
+          editorView.clearCharacterWidthCache()
 
         benchmark "uncached", 5000, ->
-          editor.positionLeftForLineAndColumn(line, 106, 82)
-          editor.clearCharacterWidthCache()
+          editorView.positionLeftForLineAndColumn(line, 106, 82)
+          editorView.clearCharacterWidthCache()
 
         benchmark "cached", 5000, ->
-          editor.positionLeftForLineAndColumn(line, 106, 82)
+          editorView.positionLeftForLineAndColumn(line, 106, 82)
 
       describe "multiple-lines.", ->
         [firstRow, lastRow] = []
         beforeEach ->
-          firstRow = editor.getFirstVisibleScreenRow()
-          lastRow = editor.getLastVisibleScreenRow()
+          firstRow = editorView.getFirstVisibleScreenRow()
+          lastRow = editorView.getLastVisibleScreenRow()
 
         benchmark "cache-entire-visible-area", 100, ->
           for i in [firstRow..lastRow]
-            line = editor.lineElementForScreenRow(i)[0]
-            editor.positionLeftForLineAndColumn(line, i, Math.max(0, editor.lineLengthForBufferRow(i)))
+            line = editorView.lineElementForScreenRow(i)[0]
+            editorView.positionLeftForLineAndColumn(line, i, Math.max(0, editorView.lineLengthForBufferRow(i)))
 
     describe "text-rendering.", ->
       beforeEach ->
-        editor.scrollTop(2000)
+        editorView.scrollTop(2000)
 
       benchmark "resetDisplay", 50, ->
-        editor.resetDisplay()
+        editorView.resetDisplay()
 
       benchmark "htmlForScreenRows", 1000, ->
-        lastRow = editor.getLastScreenRow()
-        editor.htmlForScreenRows(0, lastRow)
+        lastRow = editorView.getLastScreenRow()
+        editorView.htmlForScreenRows(0, lastRow)
 
       benchmark "htmlForScreenRows.htmlParsing", 50, ->
-        lastRow = editor.getLastScreenRow()
-        html = editor.htmlForScreenRows(0, lastRow)
+        lastRow = editorView.getLastScreenRow()
+        html = editorView.htmlForScreenRows(0, lastRow)
 
         div = document.createElement('div')
         div.innerHTML = html
@@ -126,44 +126,44 @@ describe "editor.", ->
     describe "gutter-api.", ->
       describe "getLineNumberElementsForClass.", ->
         beforeEach ->
-          editor.gutter.addClassToLine(20, 'omgwow')
-          editor.gutter.addClassToLine(40, 'omgwow')
+          editorView.gutter.addClassToLine(20, 'omgwow')
+          editorView.gutter.addClassToLine(40, 'omgwow')
 
         benchmark "DOM", 20000, ->
-          editor.gutter.getLineNumberElementsForClass('omgwow')
+          editorView.gutter.getLineNumberElementsForClass('omgwow')
 
       benchmark "getLineNumberElement.DOM", 20000, ->
-        editor.gutter.getLineNumberElement(12)
+        editorView.gutter.getLineNumberElement(12)
 
       benchmark "toggle-class", 2000, ->
-        editor.gutter.addClassToLine(40, 'omgwow')
-        editor.gutter.removeClassFromLine(40, 'omgwow')
+        editorView.gutter.addClassToLine(40, 'omgwow')
+        editorView.gutter.removeClassFromLine(40, 'omgwow')
 
       describe "find-then-unset.", ->
         classes = ['one', 'two', 'three', 'four']
 
         benchmark "single-class", 200, ->
-          editor.gutter.addClassToLine(30, 'omgwow')
-          editor.gutter.addClassToLine(40, 'omgwow')
-          editor.gutter.removeClassFromAllLines('omgwow')
+          editorView.gutter.addClassToLine(30, 'omgwow')
+          editorView.gutter.addClassToLine(40, 'omgwow')
+          editorView.gutter.removeClassFromAllLines('omgwow')
 
         benchmark "multiple-class", 200, ->
-          editor.gutter.addClassToLine(30, 'one')
-          editor.gutter.addClassToLine(30, 'two')
+          editorView.gutter.addClassToLine(30, 'one')
+          editorView.gutter.addClassToLine(30, 'two')
 
-          editor.gutter.addClassToLine(40, 'two')
-          editor.gutter.addClassToLine(40, 'three')
-          editor.gutter.addClassToLine(40, 'four')
+          editorView.gutter.addClassToLine(40, 'two')
+          editorView.gutter.addClassToLine(40, 'three')
+          editorView.gutter.addClassToLine(40, 'four')
 
           for klass in classes
-            editor.gutter.removeClassFromAllLines(klass)
+            editorView.gutter.removeClassFromAllLines(klass)
 
     describe "line-htmlification.", ->
       div = null
       html = null
       beforeEach ->
-        lastRow = editor.getLastScreenRow()
-        html = editor.htmlForScreenRows(0, lastRow)
+        lastRow = editorView.getLastScreenRow()
+        html = editorView.htmlForScreenRows(0, lastRow)
         div = document.createElement('div')
 
       benchmark "setInnerHTML", 1, ->
@@ -171,47 +171,47 @@ describe "editor.", ->
 
   describe "9000-line-file.", ->
     benchmark "opening.", 5, ->
-      rootView.openSync('huge.js')
+      atom.workspaceView.openSync('huge.js')
 
     describe "after-opening.", ->
       beforeEach ->
-        rootView.openSync('huge.js')
+        atom.workspaceView.openSync('huge.js')
 
       benchmark "moving-to-eof.", 1, ->
-        editor.moveCursorToBottom()
+        editorView.moveCursorToBottom()
 
       describe "on-first-line.", ->
         benchmark "inserting-newline", 5, ->
-          editor.insertNewline()
+          editorView.insertNewline()
 
       describe "on-last-visible-line.", ->
         beforeEach ->
-          editor.setCursorScreenPosition([editor.getLastVisibleScreenRow(), 0])
+          editorView.setCursorScreenPosition([editorView.getLastVisibleScreenRow(), 0])
 
         benchmark "move-down-and-scroll", 300, ->
-          editor.trigger 'move-down'
+          editorView.trigger 'move-down'
 
       describe "at-eof.", ->
         endPosition = null
 
         beforeEach ->
-          editor.moveCursorToBottom()
-          endPosition = editor.getCursorScreenPosition()
+          editorView.moveCursorToBottom()
+          endPosition = editorView.getCursorScreenPosition()
 
         benchmark "move-to-beginning-of-word", ->
-          editor.moveCursorToBeginningOfWord()
-          editor.setCursorScreenPosition(endPosition)
+          editorView.moveCursorToBeginningOfWord()
+          editorView.setCursorScreenPosition(endPosition)
 
         benchmark "insert", ->
-          editor.insertText('x')
+          editorView.insertText('x')
 
 describe "TokenizedBuffer.", ->
   describe "coffee-script-grammar.", ->
     [languageMode, buffer] = []
 
     beforeEach ->
-      editSession = benchmarkFixturesProject.openSync('medium.coffee')
-      { languageMode, buffer } = editSession
+      editor = benchmarkFixturesProject.openSync('medium.coffee')
+      { languageMode, buffer } = editor
 
     benchmark "construction", 20, ->
       new TokenizedBuffer(buffer, { languageMode, tabLength: 2})

docs/building-atom.md

@@ -6,10 +6,10 @@ atom][download].
 
 ## OSX
 
-* Use Mountain Lion
+* Use OS X 10.8 or later
 * Install the latest node 0.10.x release (32bit preferable)
 * Clone [atom][atom-git] to `~/github/atom`
-* Run `~/github/atom/script/bootstrap`
+* Run `~/github/atom/script/build`
 
 ## Windows
 
@@ -26,7 +26,7 @@ atom][download].
 * Use the Windows GitHub shell and cd into `C:\Users\<user>\github\atom`
 * Run `script\bootstrap`
 
-[download]: http://www.atom.io
+[download]: https://github.com/atom/atom/releases/latest
 [win-node]: http://nodejs.org/download/
 [win-python]: http://www.python.org/download/
 [win-github]: http://windows.github.com/

docs/creating-a-package.md

@@ -67,11 +67,11 @@ object.
 
 Your package's top-level module should implement the following methods:
 
-- `activate(rootView, state)`: This **required** method is called when your
-package is loaded. It is always passed the window's global `rootView`, and is
-sometimes passed state data if the window has been reloaded and your module
-implements the `serialize` method. Use this to do initialization work when your
-package is started (like setting up DOM elements or binding events).
+- `activate(state)`: This **required** method is called when your
+package is activated. It is passed the state data from the last time the window
+was serialized if your module implements the `serialize()` method. Use this to
+do initialization work when your package is started (like setting up DOM
+elements or binding events).
 
 - `serialize()`: This **optional** method is called when the window is shutting
 down, allowing you to return JSON to represent the state of your component. When
@@ -104,7 +104,7 @@ module.exports = require "./lib/my-package"
 `my-package/my-package.coffee` might start:
 ```coffeescript
 module.exports =
-  activate: (rootView, state) -> # ...
+  activate: (state) -> # ...
   deactivate: -> # ...
   serialize: -> # ...
 ```
@@ -126,7 +126,7 @@ is recommended).
 Ideally, you won't need much in the way of styling. We've provided a standard
 set of components which define both the colors and UI elements for any package
 that fits into Atom seamlessly. You can view all of Atom's UI components by opening
-the styleguide: open the command palette (`cmd-p`) and search for _styleguide_,
+the styleguide: open the command palette (`cmd-shift-P`) and search for _styleguide_,
 or just type `cmd-ctrl-G`.
 
 If you _do_ need special styling, try to keep only structural styles in the package
@@ -206,7 +206,7 @@ specific parts of the interface, like adding a file in the tree-view:
 'context-menu':
   '.tree-view':
     'Add file': 'tree-view:add-file'
-  '#root-view':
+  '.workspace':
     'Inspect Element': 'core:inspect'
 ```
 
@@ -311,7 +311,7 @@ protocol URLs to load resources in the package.
 
 The URLs should be in the format of
 `atom://package-name/relative-path-to-package-of-resource`, for example, the
-`atom://image-view/images/transparent-background.gif` would be equivablent to
+`atom://image-view/images/transparent-background.gif` would be equivalent to
 `~/.atom/packages/image-view/images/transparent-background.gif`.
 
 You can also use the `atom` protocol URLs in themes.

docs/creating-a-theme.md

@@ -34,7 +34,7 @@ target elements which are outside of the editor.
 
 Let's create your first theme.
 
-To get started, hit `cmd-p`, and start typing "Generate Theme" to generate
+To get started, hit `cmd-shift-P`, and start typing "Generate Theme" to generate
 a package. Select "Generate Theme," and you'll be asked for a theme name. Let's
 call ours _motif_.
 
@@ -114,7 +114,7 @@ If you are creating an interface theme, you'll want a way to see how your theme
 changes affect all the components in the system. The [styleguide] is a page with
 every component Atom supports rendered.
 
-To open the styleguide, open the command palette (`cmd-p`) and search for
+To open the styleguide, open the command palette (`cmd-shift-P`) and search for
 _styleguide_, or use the shortcut `cmd-ctrl-shift-g`.
 
 ![styleguide-img]

docs/customizing-atom.md

@@ -19,6 +19,16 @@ Themes` section on the `Packages` tab within the Settings panel.
 You can install non-bundled packages by going to the `Available Packages`
 section on the `Packages` tab within the Settings panel (`cmd-,`).
 
+You can also install packages from the command line using the
+[apm](https://github.com/atom/apm) command:
+
+`apm install <package_name>` to install the latest version.
+
+`apm install <package_name>@<package_version>` to install a specific version.
+
+For example `apm install emmet@0.1.5` installs the `0.1.5` release of the
+[Emmet](https://github.com/atom/emmet) package into `~/.atom/packages`.
+
 ## Customizing Key Bindings
 
 Atom keymaps work similarly to stylesheets. Just as stylesheets use selectors

docs/getting-started.md

@@ -6,13 +6,12 @@ productive as quickly as possible. There are also guides which cover
 
 ## The Command Palette
 
-If there's one key-command you must remember in Atom, it should be `cmd-p`. You
-can always hit `cmd-p` to bring up a list of commands that are relevant to the
-currently focused interface element. If there is a key binding for a given
-command, it is also displayed. This is a great way to explore the system and get
-to know the key commands interactively. If you'd like to learn about adding or
-changing a binding for a command, refer to the [key bindings][key-bindings]
-section below.
+If there's one key-command you remember in Atom, it should be `cmd-shift-P`. You
+can always press `cmd-shift-P` to bring up a list of commands (and key bindings)
+that are relevant to the currently focused interface element. This is a great
+way to explore the system and learn key bindings interactively. For information
+about adding or changing a key binding refer to the [customizing key
+bindings][key-bindings] section.
 
 ![Command Palette]
 
@@ -20,24 +19,24 @@ section below.
 
 ### Working With Files
 
-Atom windows are scoped to the directory in which they're opened from. So if you
-launch Atom from the command line, everything will be relative to the current
-directory. This means that the tree view on the left will only show files
-contained within that directory.
+Atom windows are scoped to the directory they're opened from. If you launch Atom
+from the command line everything will be relative to the current directory. This
+means that the tree view on the left will only show files contained within that
+directory.
 
 This can be a useful way to organize multiple projects, as each project will be
-contained within it's own window and it's state will be unique to that window.
+contained within its own window.
 
 #### Finding Files
 
-The fastest way to find a file in your project is to use the fuzzy finder. Just
-hit `cmd-t` and start typing the name of the file you're looking for. If you
-already have the file open as a tab and want to jump to it, hit `cmd-b` to bring
-up a searchable list of open buffers.
+The fastest way to find a file is to use the fuzzy finder. Press `cmd-t` and
+begin typing the name of the file you're looking for. If you are looking for a
+file that is already open press `cmd-b` to bring up a searchable list of open
+files.
 
 You can also use the tree view to navigate to a file. To open or move focus to
-the tree view, hit `cmd-\`. You can then navigate to a file and select it with
-`return`.
+the tree view, press `cmd-\`. You can then navigate to a file using the arrow
+keys and select it with `return`.
 
 #### Adding, Moving, Deleting Files
 
@@ -46,50 +45,50 @@ select a directory in the tree view and press `a`. Then type the name of the
 file. Any intermediate directories you type will be created automatically if
 needed.
 
-To move or rename a file or directory, select it in the tree view and hit `m`.
-To delete a file, select it in the tree view and hit `delete`.
+To move or rename a file or directory, select it in the tree view and press `m`.
+
+To delete a file, select it in the tree view and press `delete`.
 
 ### Searching
 
 #### Find and Replace
 
 To search within a buffer use `cmd-f`. To search the entire project use
-`cmd-shift-f`. To find and replace within the current buffer use `cmd-alt-f`.
+`cmd-shift-f`.
 
 #### Navigating By Symbols
 
-If you want to jump to a method, the `cmd-j` binding opens a list of all symbols
-in the current file. `cmd-.` jumps to the tag for the word currently under the
-cursor.
+If you want to jump to a method press `cmd-r`. It opens a list of all symbols
+in the current file.
 
-To search for symbols across your project use `cmd-shift-j`, but you'll need to
-make sure you have a tags file generated for the project Also, if you're editing
-CoffeeScript, it's a good idea to update your `~/.ctags` file to understand the
-language. Here is [a good example][ctags].
+To search for symbols across your project use `cmd-shift-r`, but you'll need to
+make sure you have a ctags installed and a tags file generated for your project.
+Also, if you're editing CoffeeScript, it's a good idea to update your `~/.ctags`
+file to understand the language. Here is [a good example][ctags].
 
 ### Split Panes
 
-You can split any editor pane horizontally or vertically by using `ctrl-w s` or
-`ctrl-w v`. Once you have a split pane, you can move focus between them with
-`ctrl-tab` or `ctrl-w w`. To close a pane, close all tabs inside it.
+You can split any editor pane horizontally or vertically by using `cmd-k right` or
+`cmd-k down`. Once you have a split pane, you can move focus between them with
+`cmd-k cmd-right` or `cmd-k cmd-down`. To close a pane, close all tabs inside it.
 
 ### Folding
 
-You can fold everything with `ctrl-{` and unfold everything with
-`ctrl-}`. Or, you can fold / unfold by a single level with `ctrl-[` and
-`ctrl-]`.
+You can fold everything with `alt-cmd-{` and unfold everything with
+`alt-cmd-}`. Or, you can fold / unfold by a single level with `alt-cmd-[` and
+`alt-cmd-]`.
 
 ### Soft-Wrap
 
 If you want to toggle soft wrap, trigger the command from the command palette.
-Hit `cmd-p` to open the palette, then type "wrap" to find the correct
+Press `cmd-shift-P` to open the palette, then type "wrap" to find the correct
 command.
 
 ## Configuration
 
-If you press `cmd-,`, a configuration panel will appear in the currently focused
-pane. This serves as the primary interface for adjusting settings, installing
-packages and changing themes.
+Press `cmd-,` to display the a settings pane. This serves as the primary
+interface for adjusting config settings, installing packages and changing
+themes.
 
 For more advanced configuration see the [customization guide][customization].
 
@@ -97,6 +96,6 @@ For more advanced configuration see the [customization guide][customization].
 [theming]: creating-a-theme.md
 [extending]: creating-a-package.md
 [customization]: customizing-atom.md
-[key-bindings]: #customizing-key-bindings
+[key-bindings]: customizing-atom.md#customizing-key-bindings
 [command palette]: https://f.cloud.github.com/assets/1424/1091618/ee7c3554-166a-11e3-9955-aaa61bb5509c.png
 [ctags]: https://github.com/kevinsawicki/dotfiles/blob/master/.ctags

docs/internals/configuration.md

@@ -23,7 +23,7 @@ The `observeConfig` method will call the given callback immediately with the
 current value for the specified key path, and it will also call it in the future
 whenever the value of that key path changes.
 
-Subscriptions made with `observeConfig` are automatically cancelled when the
+Subscriptions made with `observeConfig` are automatically canceled when the
 view is removed. You can cancel config subscriptions manually via the
 `unobserveConfig` method.
 

docs/internals/keymaps.md

@@ -23,7 +23,7 @@ Note that the last example describes multiple keystrokes in succession:
 
 A semantic event is the name of the custom event that will be triggered on the
 target of the keydown event when a key binding matches. You can use the command
-palette (bound to `cmd-p`), to get a list of relevant events and their bindings
+palette (bound to `cmd-shift-P`), to get a list of relevant events and their bindings
 in any focused context in Atom.
 
 ### Rules for Mapping A Keydown Event to A Semantic Event

docs/internals/view-system.md

@@ -8,11 +8,11 @@ view objects inherit from the jQuery prototype, and wrap DOM nodes
 View objects are actually jQuery wrappers around DOM fragments, supporting all
 the typical jQuery traversal and manipulation methods. In addition, view objects
 have methods that are view-specific. For example, you could call both general
-and view-specific on the global `rootView` instance:
+and view-specific on the global `atom.workspaceView` instance:
 
 ```coffeescript
-rootView.find('.editor.active') # standard jQuery method
-rootView.getActiveEditor()      # view-specific method
+atom.workspaceView.find('.editor.active') # standard jQuery method
+atom.workspaceView.getActiveEditor()      # view-specific method
 ```
 
 If you retrieve a jQuery wrapper for an element associated with a view, use the
@@ -20,7 +20,7 @@ If you retrieve a jQuery wrapper for an element associated with a view, use the
 
 ```coffeescript
 # this is a plain jQuery object; you can't call view-specific methods
-editorElement = rootView.find('.editor.active')
+editorElement = atom.workspaceView.find('.editor.active')
 
 # get the view object by calling `.view()` to call view-specific methods
 editorView = editorElement.view()
@@ -29,18 +29,18 @@ editorView.setCursorBufferPosition([1, 2])
 
 Refer to the [SpacePen] documentation for more details.
 
-### RootView
+### WorkspaceView
 
-The root of Atom's view hierarchy is a global called `rootView`, which is a
-singleton instance of the `RootView` view class. The root view fills the entire
+The root of Atom's view hierarchy is a global called `atom.workspaceView`, which is a
+singleton instance of the `WorkspaceView` view class. The root view fills the entire
 window, and contains every other view. If you open Atom's inspector with
-`alt-cmd-i`, you can see the internal structure of `RootView`:
+`alt-cmd-i`, you can see the internal structure of `WorkspaceView`:
 
-![RootView in the inspector][rootview-inspector]
+![WorkspaceView in the inspector][workspaceview-inspector]
 
 #### Panes
 
-The `RootView` contains a `#horizontal` and a `#vertical` axis surrounding
+The `WorkspaceView` contains a `#horizontal` and a `#vertical` axis surrounding
 `#panes`. Elements in the horizontal axis will tile across the window
 horizontally, appearing to have a vertical orientation. Items in the vertical
 axis will tile across the window vertically, appearing to have a horizontal
@@ -55,11 +55,11 @@ outlets as follows:
 
 ```coffeescript
 # place a view to the left of the panes (or use .append() to place it to the right)
-rootView.horizontal.prepend(new MyView)
+atom.workspaceView.horizontal.prepend(new MyView)
 
 # place a view below the panes (or use .prepend() to place it above)
-rootView.vertical.append(new MyOtherView)
+atom.workspaceView.vertical.append(new MyOtherView)
 ```
 
 [spacepen]: http://github.com/nathansobo/space-pen
-[rootview-inspector]: https://f.cloud.github.com/assets/1424/1091631/1932c2d6-166b-11e3-8adf-9690fe82d3b8.png
+[workspaceView-inspector]: https://f.cloud.github.com/assets/1424/1091631/1932c2d6-166b-11e3-8adf-9690fe82d3b8.png

docs/your-first-package.md

@@ -2,12 +2,12 @@
 
 Let's take a look at creating your first package.
 
-To get started, hit `cmd-p`, and start typing "Generate Package" to generate
+To get started, hit `cmd-shift-P`, and start typing "Generate Package" to generate
 a package. Once you select the "Generate Package" command, it'll ask you for a
 name for your new package. Let's call ours _changer_.
 
 Atom will pop open a new window, showing the _changer_ package with a default set of
-folders and files created for us. Hit `cmd-p` and start typing "Changer." You'll
+folders and files created for us. Hit `cmd-shift-P` and start typing "Changer." You'll
 see a new `Changer:Toggle` command which, if selected, pops up a greeting. So far,
 so good!
 
@@ -44,12 +44,12 @@ you can map to `body` if you want to scope to anywhere in Atom, or just `.editor
 for the editor portion.
 
 To bind keybindings to a command, we'll need to do a bit of association in our
-CoffeeScript code using the `rootView.command` method. This method takes a command
+CoffeeScript code using the `atom.workspaceView.command` method. This method takes a command
 name and executes a callback function. Open up _lib/changer-view.coffee_, and
-change `rootView.command "changer:toggle"` to look like this:
+change `atom.workspaceView.command "changer:toggle"` to look like this:
 
 ```coffeescript
-rootView.command "changer:magic", => @magic()
+atom.workspaceView.command "changer:magic", => @magic()
 ```
 
 It's common practice to namespace your commands with your package name, separated
@@ -180,7 +180,7 @@ ul.modified-files-list {
 We'll add one more line to the end of the `magic` method to make this pane appear:
 
 ```coffeescript
-rootView.vertical.append(this)
+atom.workspaceView.vertical.append(this)
 ```
 
 If you refresh Atom and hit the key command, you'll see a box appear right underneath
@@ -188,21 +188,21 @@ the editor:
 
 ![Changer_Panel_Append]
 
-As you might have guessed, `rootView.vertical.append` tells Atom to append `this`
+As you might have guessed, `atom.workspaceView.vertical.append` tells Atom to append `this`
 item (_i.e._, whatever is defined by`@content`) _vertically_ to the editor. If
-we had called `rootView.horizontal.append`, the pane would be attached to the
+we had called `atom.workspaceView.horizontal.append`, the pane would be attached to the
 right-hand side of the editor.
 
 Before we populate this panel for real, let's apply some logic to toggle the pane
-off and on, just like we did with the tree view. Replace the `rootView.vertical.append`
+off and on, just like we did with the tree view. Replace the `atom.workspaceView.vertical.append`
 call with this code:
 
 ```coffeescript
 # toggles the pane
 if @hasParent()
-  rootView.vertical.children().last().remove()
+  atom.workspaceView.vertical.children().last().remove()
 else
-  rootView.vertical.append(this)
+  atom.workspaceView.vertical.append(this)
 ```
 
 There are about a hundred different ways to toggle a pane on and off, and this
@@ -245,7 +245,7 @@ $('ol.entries li.file.status-modified span.name').each (i, el) ->
   parents.each (i, el) ->
     filePath.unshift($(el).find('div.header span.name').eq(0).text())
 
-  modifiedFilePath = path.join(project.rootDirectory.path, filePath.join(path.sep))
+  modifiedFilePath = path.join(atom.project.rootDirectory.path, filePath.join(path.sep))
   modifiedFiles.push modifiedFilePath
 ```
 
@@ -261,13 +261,13 @@ appending it to `modifiedFilesList`:
 ```coffeescript
 # toggles the pane
 if @hasParent()
-  rootView.vertical.children().last().remove()
+  atom.workspaceView.vertical.children().last().remove()
 else
   for file in modifiedFiles
     stat = fs.lstatSync(file)
     mtime = stat.mtime
     @modifiedFilesList.append("<li>#{file} - Modified at #{mtime}")
-  rootView.vertical.append(this)
+  atom.workspaceView.vertical.append(this)
 ```
 
 When you toggle the modified files list, your pane is now populated with the
@@ -283,13 +283,13 @@ this demonstration, we'll just clear the `modifiedFilesList` each time it's clos
 # toggles the pane
 if @hasParent()
   @modifiedFilesList.empty() # added this to clear the list on close
-  rootView.vertical.children().last().remove()
+  atom.workspaceView.vertical.children().last().remove()
 else
   for file in modifiedFiles
     stat = fs.lstatSync(file)
     mtime = stat.mtime
     @modifiedFilesList.append("<li>#{file} - Modified at #{mtime}")
-  rootView.vertical.append(this)
+  atom.workspaceView.vertical.append(this)
 ```
 
 ## Coloring UI Elements

exports/atom.coffee

@@ -1,4 +1,4 @@
-{Document, Point, Range, Site} = require 'telepath'
+{Document, Point, Range} = require 'telepath'
 
 module.exports =
   _: require 'underscore-plus'
@@ -11,7 +11,6 @@ module.exports =
   Git: require '../src/git'
   Point: Point
   Range: Range
-  Site: Site
 
 # The following classes can't be used from a Task handler and should therefore
 # only be exported when not running as a child node process
@@ -21,9 +20,8 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
   module.exports.$ = $
   module.exports.$$ = $$
   module.exports.$$$ = $$$
-  module.exports.Editor = require '../src/editor'
-  module.exports.pathForRepositoryUrl = require('../src/project').pathForRepositoryUrl
-  module.exports.RootView = require '../src/root-view'
+  module.exports.EditorView = require '../src/editor-view'
+  module.exports.WorkspaceView = require '../src/workspace-view'
   module.exports.SelectList = require '../src/select-list'
   module.exports.ScrollView = require '../src/scroll-view'
   module.exports.Task = require '../src/task'

keymaps/base.cson

@@ -0,0 +1,81 @@
+'.editor':
+  # Platform Bindings
+  'alt-left': 'editor:move-to-previous-word-boundary'
+  'alt-right': 'editor:move-to-next-word-boundary'
+  'alt-shift-left': 'editor:select-to-previous-word-boundary'
+  'alt-shift-right': 'editor:select-to-next-word-boundary'
+  'home': 'editor:move-to-first-character-of-line'
+  'end': 'editor:move-to-end-of-line'
+  'shift-home': 'editor:select-to-first-character-of-line'
+  'shift-end': 'editor:select-to-end-of-line'
+
+  # Sublime Parity
+  'ctrl-t': 'editor:transpose'
+
+'.editor:not(.mini)':
+  # Atom Specific
+  'ctrl-C': 'editor:copy-path'
+
+  # Sublime Parity
+  'tab': 'editor:indent'
+  'enter': 'editor:newline'
+  'shift-tab': 'editor:outdent-selected-rows'
+  'ctrl-K': 'editor:delete-line'
+  'ctrl-shift-up': 'editor:add-selection-above'
+  'ctrl-shift-down': 'editor:add-selection-below'
+
+'.tool-panel':
+  'escape': 'core:close'
+
+'.tool-panel.panel-left, .tool-panel.panel-right':
+  'escape': 'tool-panel:unfocus'
+
+'.editor !important, .editor.mini !important':
+  'escape': 'editor:consolidate-selections'
+
+# allow standard input fields to work correctly
+'body .native-key-bindings':
+  'tab': 'core:focus-next'
+  'shift-tab': 'core:focus-previous'
+  'enter': 'native!'
+  'backspace': 'native!'
+  'shift-backspace': 'native!'
+  'delete': 'native!'
+  'up': 'native!'
+  'down': 'native!'
+  'shift-up': 'native!'
+  'shift-down': 'native!'
+  'alt-up': 'native!'
+  'alt-down': 'native!'
+  'alt-shift-up': 'native!'
+  'alt-shift-down': 'native!'
+  'cmd-up': 'native!'
+  'cmd-down': 'native!'
+  'cmd-shift-up': 'native!'
+  'cmd-shift-down': 'native!'
+  'ctrl-up': 'native!'
+  'ctrl-down': 'native!'
+  'ctrl-shift-up': 'native!'
+  'ctrl-shift-down': 'native!'
+  'left': 'native!'
+  'right': 'native!'
+  'shift-left': 'native!'
+  'shift-right': 'native!'
+  'alt-left': 'native!'
+  'alt-right': 'native!'
+  'alt-shift-left': 'native!'
+  'alt-shift-right': 'native!'
+  'cmd-left': 'native!'
+  'cmd-right': 'native!'
+  'cmd-shift-left': 'native!'
+  'cmd-shift-right': 'native!'
+  'ctrl-left': 'native!'
+  'ctrl-right': 'native!'
+  'ctrl-shift-left': 'native!'
+  'ctrl-shift-right': 'native!'
+  'ctrl-b': 'native!'
+  'ctrl-f': 'native!'
+  'ctrl-F': 'native!'
+  'ctrl-B': 'native!'
+  'ctrl-h': 'native!'
+  'ctrl-d': 'native!'

keymaps/darwin.cson

@@ -0,0 +1,154 @@
+'.platform-darwin':
+  # Apple specific
+  'cmd-q': 'application:quit'
+  'cmd-h': 'application:hide'
+  'cmd-H': 'application:hide-other-applications'
+  'cmd-m': 'application:minimize'
+  'alt-cmd-ctrl-m': 'application:zoom'
+
+  'ctrl-p': 'core:move-up'
+  'ctrl-n': 'core:move-down'
+  'ctrl-b': 'core:move-left'
+  'ctrl-f': 'core:move-right'
+  'ctrl-P': 'core:select-up'
+  'ctrl-N': 'core:select-down'
+  'ctrl-F': 'core:select-right'
+  'ctrl-B': 'core:select-left'
+  'ctrl-h': 'core:backspace'
+  'ctrl-d': 'core:delete'
+
+  # Atom Specific
+  'cmd-O': 'application:open-dev'
+  'cmd-alt-ctrl-s': 'application:run-all-specs'
+  'enter': 'core:confirm'
+  'escape': 'core:cancel'
+  'up': 'core:move-up'
+  'down': 'core:move-down'
+  'left': 'core:move-left'
+  'right': 'core:move-right'
+  'ctrl-alt-cmd-r': 'window:reload'
+  'alt-cmd-i': 'window:toggle-dev-tools'
+  'cmd-alt-ctrl-p': 'window:run-package-specs'
+
+  # Sublime Parity
+  'cmd-,': 'application:show-settings'
+  'cmd-N': 'application:new-window'
+  'cmd-W': 'window:close'
+  'cmd-o': 'application:open'
+  'cmd-T': 'pane:reopen-closed-item'
+  'cmd-n': 'application:new-file'
+  'cmd-s': 'core:save'
+  'cmd-S': 'core:save-as'
+  'cmd-alt-s': 'window:save-all'
+  'cmd-w': 'core:close'
+  'cmd-ctrl-f': 'window:toggle-full-screen'
+  'cmd-z': 'core:undo'
+  'cmd-Z': 'core:redo'
+  'cmd-y': 'core:redo'
+  'cmd-x': 'core:cut'
+  'cmd-c': 'core:copy'
+  'cmd-v': 'core:paste'
+  'shift-up': 'core:select-up'
+  'shift-down': 'core:select-down'
+  'shift-left': 'core:select-left'
+  'shift-right': 'core:select-right'
+  'delete': 'core:delete'
+  'pageup': 'core:page-up'
+  'pagedown': 'core:page-down'
+  'backspace': 'core:backspace'
+  'shift-backspace': 'core:backspace'
+  'cmd-up': 'core:move-to-top'
+  'cmd-down': 'core:move-to-bottom'
+  'cmd-shift-up': 'core:select-to-top'
+  'cmd-shift-down': 'core:select-to-bottom'
+  'cmd-{': 'pane:show-previous-item'
+  'cmd-}': 'pane:show-next-item'
+  'cmd-alt-left': 'pane:show-previous-item'
+  'cmd-alt-right': 'pane:show-next-item'
+  'cmd-=': 'window:increase-font-size'
+  'cmd-+': 'window:increase-font-size'
+  'cmd--': 'window:decrease-font-size'
+
+  'cmd-k up': 'pane:split-up' # Atom Specific
+  'cmd-k down': 'pane:split-down' # Atom Specific
+  'cmd-k left': 'pane:split-left' # Atom Specific
+  'cmd-k right': 'pane:split-right' # Atom Specific
+  'cmd-k cmd-w': 'pane:close' # Atom Specific
+  'cmd-k alt-cmd-w': 'pane:close-other-items' # Atom Specific
+  'cmd-k cmd-left': 'window:focus-previous-pane'
+  'cmd-k cmd-right': 'window:focus-next-pane'
+  'cmd-1': 'pane:show-item-1'
+  'cmd-2': 'pane:show-item-2'
+  'cmd-3': 'pane:show-item-3'
+  'cmd-4': 'pane:show-item-4'
+  'cmd-5': 'pane:show-item-5'
+  'cmd-6': 'pane:show-item-6'
+  'cmd-7': 'pane:show-item-7'
+  'cmd-8': 'pane:show-item-8'
+  'cmd-9': 'pane:show-item-9'
+
+'.platform-darwin .editor':
+  # Apple Specific
+  'cmd-backspace': 'editor:backspace-to-beginning-of-line'
+  'cmd-delete': 'editor:backspace-to-beginning-of-line'
+  'ctrl-A': 'editor:select-to-first-character-of-line'
+  'ctrl-E': 'editor:select-to-end-of-line'
+  'cmd-left': 'editor:move-to-first-character-of-line'
+  'cmd-right': 'editor:move-to-end-of-line'
+  'cmd-shift-left': 'editor:select-to-first-character-of-line'
+  'cmd-shift-right': 'editor:select-to-end-of-line'
+  'alt-backspace': 'editor:backspace-to-beginning-of-word'
+  'alt-delete': 'editor:delete-to-end-of-word'
+  'ctrl-a': 'editor:move-to-first-character-of-line'
+  'ctrl-e': 'editor:move-to-end-of-line'
+  'ctrl-k': 'editor:cut-to-end-of-line'
+
+  # Atom Specific
+  'ctrl-W': 'editor:select-word'
+
+  # Sublime Parity
+  'cmd-a': 'core:select-all'
+  'cmd-alt-p': 'editor:log-cursor-scope'
+  'cmd-k cmd-u': 'editor:upper-case'
+  'cmd-k cmd-l': 'editor:lower-case'
+
+'body.platform-darwin .editor:not(.mini)':
+  # Atom specific
+  'alt-cmd-z': 'editor:checkout-head-revision'
+  'cmd-<': 'editor:scroll-to-cursor'
+  'alt-cmd-ctrl-f': 'editor:fold-selection'
+  'cmd-=': 'editor:auto-indent'
+
+  # Sublime Parity
+  'cmd-enter': 'editor:newline-below'
+  'cmd-shift-enter': 'editor:newline-above'
+  'cmd-]': 'editor:indent-selected-rows'
+  'cmd-[': 'editor:outdent-selected-rows'
+  'ctrl-cmd-up': 'editor:move-line-up'
+  'ctrl-cmd-down': 'editor:move-line-down'
+  'cmd-/': 'editor:toggle-line-comments'
+  'cmd-j': 'editor:join-line'
+  'cmd-D': 'editor:duplicate-line'
+
+  'cmd-alt-[': 'editor:fold-current-row'
+  'cmd-alt-]': 'editor:unfold-current-row'
+  'cmd-alt-{': 'editor:fold-all' # Atom Specific
+  'cmd-alt-}': 'editor:unfold-all' # Atom Specific
+  'cmd-k cmd-0': 'editor:unfold-all'
+  'cmd-k cmd-1': 'editor:fold-at-indent-level-1'
+  'cmd-k cmd-2': 'editor:fold-at-indent-level-2'
+  'cmd-k cmd-3': 'editor:fold-at-indent-level-3'
+  'cmd-k cmd-4': 'editor:fold-at-indent-level-4'
+  'cmd-k cmd-5': 'editor:fold-at-indent-level-5'
+  'cmd-k cmd-6': 'editor:fold-at-indent-level-6'
+  'cmd-k cmd-7': 'editor:fold-at-indent-level-7'
+  'cmd-k cmd-8': 'editor:fold-at-indent-level-8'
+  'cmd-k cmd-9': 'editor:fold-at-indent-level-9'
+
+# allow standard input fields to work correctly
+'body.platform-darwin .native-key-bindings':
+  'cmd-z': 'native!'
+  'cmd-Z': 'native!'
+  'cmd-x': 'native!'
+  'cmd-c': 'native!'
+  'cmd-v': 'native!'

keymaps/default.cson

@@ -1,194 +0,0 @@
-'body':
-  # Apple specific
-  'meta-q': 'application:quit'
-  'meta-h': 'application:hide'
-  'meta-H': 'application:hide-other-applications'
-  'meta-m': 'application:minimize'
-  'alt-meta-ctrl-m': 'application:zoom'
-
-  'ctrl-p': 'core:move-up'
-  'ctrl-n': 'core:move-down'
-  'ctrl-b': 'core:move-left'
-  'ctrl-f': 'core:move-right'
-  'ctrl-P': 'core:select-up'
-  'ctrl-N': 'core:select-down'
-  'ctrl-F': 'core:select-right'
-  'ctrl-B': 'core:select-left'
-  'ctrl-h': 'core:backspace'
-  'ctrl-d': 'core:delete'
-
-  # Atom Specific
-  'meta-O': 'application:open-dev'
-  'meta-alt-ctrl-s': 'application:run-all-specs'
-  'enter': 'core:confirm'
-  'escape': 'core:cancel'
-  'up': 'core:move-up'
-  'down': 'core:move-down'
-  'left': 'core:move-left'
-  'right': 'core:move-right'
-  'ctrl-alt-meta-r': 'window:reload'
-  'alt-meta-i': 'window:toggle-dev-tools'
-  'meta-alt-ctrl-p': 'window:run-package-specs'
-
-  # Sublime Parity
-  'meta-,': 'application:show-settings'
-  'meta-N': 'application:new-window'
-  'meta-W': 'window:close'
-  'meta-o': 'application:open'
-  'meta-T': 'pane:reopen-closed-item'
-  'meta-n': 'application:new-file'
-  'meta-s': 'core:save'
-  'meta-S': 'core:save-as'
-  'meta-alt-s': 'window:save-all'
-  'meta-w': 'core:close'
-  'meta-ctrl-f': 'window:toggle-full-screen'
-  'meta-z': 'core:undo'
-  'meta-Z': 'core:redo'
-  'meta-y': 'core:redo'
-  'meta-x': 'core:cut'
-  'meta-c': 'core:copy'
-  'meta-v': 'core:paste'
-  'shift-up': 'core:select-up'
-  'shift-down': 'core:select-down'
-  'shift-left': 'core:select-left'
-  'shift-right': 'core:select-right'
-  'delete': 'core:delete'
-  'pageup': 'core:page-up'
-  'pagedown': 'core:page-down'
-  'backspace': 'core:backspace'
-  'shift-backspace': 'core:backspace'
-  'meta-up': 'core:move-to-top'
-  'meta-down': 'core:move-to-bottom'
-  'meta-shift-up': 'core:select-to-top'
-  'meta-shift-down': 'core:select-to-bottom'
-  'meta-{': 'pane:show-previous-item'
-  'meta-}': 'pane:show-next-item'
-  'meta-alt-left': 'pane:show-previous-item'
-  'meta-alt-right': 'pane:show-next-item'
-  'meta-=': 'window:increase-font-size'
-  'meta-+': 'window:increase-font-size'
-  'meta--': 'window:decrease-font-size'
-
-  'meta-k up': 'pane:split-up' # Atom Specific
-  'meta-k down': 'pane:split-down' # Atom Specific
-  'meta-k left': 'pane:split-left' # Atom Specific
-  'meta-k right': 'pane:split-right' # Atom Specific
-  'meta-k meta-w': 'pane:close' # Atom Specific
-  'meta-k alt-meta-w': 'pane:close-other-items' # Atom Specific
-  'meta-k meta-left': 'window:focus-previous-pane'
-  'meta-k meta-right': 'window:focus-next-pane'
-  'meta-1': 'pane:show-item-1'
-  'meta-2': 'pane:show-item-2'
-  'meta-3': 'pane:show-item-3'
-  'meta-4': 'pane:show-item-4'
-  'meta-5': 'pane:show-item-5'
-  'meta-6': 'pane:show-item-6'
-  'meta-7': 'pane:show-item-7'
-  'meta-8': 'pane:show-item-8'
-  'meta-9': 'pane:show-item-9'
-
-'.editor':
-  # Apple Specific
-  'alt-left': 'editor:move-to-previous-word-boundary'
-  'alt-right': 'editor:move-to-next-word-boundary'
-  'alt-shift-left': 'editor:select-to-previous-word-boundary'
-  'alt-shift-right': 'editor:select-to-next-word-boundary'
-  'meta-backspace': 'editor:backspace-to-beginning-of-line'
-  'meta-delete': 'editor:backspace-to-beginning-of-line'
-  'ctrl-A': 'editor:select-to-first-character-of-line'
-  'ctrl-E': 'editor:select-to-end-of-line'
-  'meta-left': 'editor:move-to-first-character-of-line'
-  'meta-right': 'editor:move-to-end-of-line'
-  'meta-shift-left': 'editor:select-to-first-character-of-line'
-  'meta-shift-right': 'editor:select-to-end-of-line'
-  'home': 'editor:move-to-first-character-of-line'
-  'end': 'editor:move-to-end-of-line'
-  'shift-home': 'editor:select-to-first-character-of-line'
-  'shift-end': 'editor:select-to-end-of-line'
-  'alt-backspace': 'editor:backspace-to-beginning-of-word'
-  'alt-delete': 'editor:delete-to-end-of-word'
-  'ctrl-a': 'editor:move-to-first-character-of-line'
-  'ctrl-e': 'editor:move-to-end-of-line'
-  'ctrl-k': 'editor:cut-to-end-of-line'
-
-  # Atom Specific
-  'ctrl-W': 'editor:select-word'
-
-  # Sublime Parity
-  'meta-a': 'core:select-all'
-  'meta-alt-p': 'editor:log-cursor-scope'
-  'ctrl-t': 'editor:transpose'
-  'meta-k meta-u': 'editor:upper-case'
-  'meta-k meta-l': 'editor:lower-case'
-
-'.editor:not(.mini)':
-  # Atom Specific
-  'alt-meta-z': 'editor:checkout-head-revision'
-  'meta-<': 'editor:scroll-to-cursor'
-  'ctrl-C': 'editor:copy-path'
-  'alt-meta-ctrl-f': 'editor:fold-selection'
-  'meta-=': 'editor:auto-indent'
-
-  # Sublime Parity
-  'tab': 'editor:indent'
-  'enter': 'editor:newline'
-  'meta-enter': 'editor:newline-below'
-  'meta-shift-enter': 'editor:newline-above'
-  'meta-]': 'editor:indent-selected-rows'
-  'meta-[': 'editor:outdent-selected-rows'
-  'shift-tab': 'editor:outdent-selected-rows'
-  'ctrl-meta-up': 'editor:move-line-up'
-  'ctrl-meta-down': 'editor:move-line-down'
-  'meta-/': 'editor:toggle-line-comments'
-  'meta-j': 'editor:join-line'
-  'meta-D': 'editor:duplicate-line'
-  'ctrl-K': 'editor:delete-line'
-  'ctrl-shift-up': 'editor:add-selection-above'
-  'ctrl-shift-down': 'editor:add-selection-below'
-
-  'meta-alt-[': 'editor:fold-current-row'
-  'meta-alt-]': 'editor:unfold-current-row'
-  'meta-alt-{': 'editor:fold-all' # Atom Specific
-  'meta-alt-}': 'editor:unfold-all' # Atom Specific
-  'meta-k meta-0': 'editor:unfold-all'
-  'meta-k meta-1': 'editor:fold-at-indent-level-1'
-  'meta-k meta-2': 'editor:fold-at-indent-level-2'
-  'meta-k meta-3': 'editor:fold-at-indent-level-3'
-  'meta-k meta-4': 'editor:fold-at-indent-level-4'
-  'meta-k meta-5': 'editor:fold-at-indent-level-5'
-  'meta-k meta-6': 'editor:fold-at-indent-level-6'
-  'meta-k meta-7': 'editor:fold-at-indent-level-7'
-  'meta-k meta-8': 'editor:fold-at-indent-level-8'
-  'meta-k meta-9': 'editor:fold-at-indent-level-9'
-
-'.tool-panel':
-  'escape': 'core:close'
-
-'.tool-panel.panel-left, .tool-panel.panel-right':
-  'escape': 'tool-panel:unfocus'
-
-'.editor !important, .editor.mini !important':
-  'escape': 'editor:consolidate-selections'
-
-# allow standard input fields to work correctly
-'input:not(.hidden-input), .native-key-bindings':
-  'tab': 'core:focus-next'
-  'shift-tab': 'core:focus-previous'
-  'left': 'native!'
-  'right': 'native!'
-  'shift-left': 'native!'
-  'shift-right': 'native!'
-  'backspace': 'native!'
-  'shift-backspace': 'native!'
-  'delete': 'native!'
-  'meta-z': 'native!'
-  'meta-Z': 'native!'
-  'meta-x': 'native!'
-  'meta-c': 'native!'
-  'meta-v': 'native!'
-  'ctrl-b': 'native!'
-  'ctrl-f': 'native!'
-  'ctrl-F': 'native!'
-  'ctrl-B': 'native!'
-  'ctrl-h': 'native!'
-  'ctrl-d': 'native!'

keymaps/win32.cson

@@ -0,0 +1,102 @@
+'.platform-win32':
+  # Atom Specific
+  'enter': 'core:confirm'
+  'escape': 'core:cancel'
+  'up': 'core:move-up'
+  'down': 'core:move-down'
+  'left': 'core:move-left'
+  'right': 'core:move-right'
+  'ctrl-alt-r': 'window:reload'
+  'ctrl-alt-i': 'window:toggle-dev-tools'
+  'ctrl-alt-p': 'window:run-package-specs'
+  'ctrl-alt-s': 'application:run-all-specs'
+
+  # Sublime Parity
+  'ctrl-N': 'application:new-window'
+  'ctrl-W': 'window:close'
+  'ctrl-o': 'application:open'
+  'ctrl-T': 'pane:reopen-closed-item'
+  'ctrl-n': 'application:new-file'
+  'ctrl-s': 'core:save'
+  'ctrl-S': 'core:save-as'
+  'ctrl-w': 'core:close'
+  'ctrl-z': 'core:undo'
+  'ctrl-y': 'core:redo'
+  'ctrl-x': 'core:cut'
+  'ctrl-c': 'core:copy'
+  'ctrl-v': 'core:paste'
+  'shift-up': 'core:select-up'
+  'shift-down': 'core:select-down'
+  'shift-left': 'core:select-left'
+  'shift-right': 'core:select-right'
+  'delete': 'core:delete'
+  'pageup': 'core:page-up'
+  'pagedown': 'core:page-down'
+  'backspace': 'core:backspace'
+  'ctrl-tab': 'pane:show-next-item'
+  'ctrl-shift-tab': 'pane:show-previous-item'
+  'ctrl-shift-up': 'core:move-up'
+  'ctrl-shift-down': 'core:move-down'
+  'ctrl-=': 'window:increase-font-size'
+  'ctrl-+': 'window:increase-font-size'
+  'ctrl--': 'window:decrease-font-size'
+
+  'ctrl-k up': 'pane:split-up' # Atom Specific
+  'ctrl-k down': 'pane:split-down' # Atom Specific
+  'ctrl-k left': 'pane:split-left' # Atom Specific
+  'ctrl-k right': 'pane:split-right' # Atom Specific
+  'ctrl-k ctrl-w': 'pane:close' # Atom Specific
+  'ctrl-k alt-ctrl-w': 'pane:close-other-items' # Atom Specific
+  'ctrl-k ctrl-left': 'window:focus-previous-pane'
+  'ctrl-k ctrl-right': 'window:focus-next-pane'
+
+'.platform-win32 .editor':
+  # Windows specific
+  'ctrl-delete': 'editor:backspace-to-beginning-of-word'
+
+  # Sublime Parity
+  'ctrl-a': 'core:select-all'
+  'ctrl-alt-p': 'editor:log-cursor-scope'
+  'ctrl-k ctrl-u': 'editor:upper-case'
+  'ctrl-k ctrl-l': 'editor:lower-case'
+
+'.platform-win32 .editor:not(.mini)':
+  # Atom specific
+  'alt-ctrl-z': 'editor:checkout-head-revision'
+  'ctrl-<': 'editor:scroll-to-cursor'
+  'alt-ctrl-f': 'editor:fold-selection'
+  'ctrl-=': 'editor:auto-indent'
+
+  # Sublime Parity
+  'ctrl-enter': 'editor:newline-below'
+  'ctrl-shift-enter': 'editor:newline-above'
+  'ctrl-]': 'editor:indent-selected-rows'
+  'ctrl-[': 'editor:outdent-selected-rows'
+  'ctrl-up': 'editor:move-line-up'
+  'ctrl-down': 'editor:move-line-down'
+  'ctrl-/': 'editor:toggle-line-comments'
+  'ctrl-j': 'editor:join-line'
+  'ctrl-D': 'editor:duplicate-line'
+
+  'ctrl-alt-[': 'editor:fold-current-row'
+  'ctrl-alt-]': 'editor:unfold-current-row'
+  'ctrl-alt-{': 'editor:fold-all' # Atom Specific
+  'ctrl-alt-}': 'editor:unfold-all' # Atom Specific
+  'ctrl-k ctrl-0': 'editor:unfold-all'
+  'ctrl-k ctrl-1': 'editor:fold-at-indent-level-1'
+  'ctrl-k ctrl-2': 'editor:fold-at-indent-level-2'
+  'ctrl-k ctrl-3': 'editor:fold-at-indent-level-3'
+  'ctrl-k ctrl-4': 'editor:fold-at-indent-level-4'
+  'ctrl-k ctrl-5': 'editor:fold-at-indent-level-5'
+  'ctrl-k ctrl-6': 'editor:fold-at-indent-level-6'
+  'ctrl-k ctrl-7': 'editor:fold-at-indent-level-7'
+  'ctrl-k ctrl-8': 'editor:fold-at-indent-level-8'
+  'ctrl-k ctrl-9': 'editor:fold-at-indent-level-9'
+
+# allow standard input fields to work correctly
+'.platform-win32 input:not(.hidden-input), .platform-win32 .native-key-bindings':
+  'ctrl-z': 'native!'
+  'ctrl-Z': 'native!'
+  'ctrl-x': 'native!'
+  'ctrl-c': 'native!'
+  'ctrl-v': 'native!'

menus/win32.cson

@@ -165,7 +165,6 @@
       { label: "Install &update", command: 'application:install-update', visible: false }
       { type: 'separator' }
       { label: '&Documentation', command: 'application:open-documentation' }
-      { label: 'Report an &Issue', command: 'application:report-issue' }
       { type: 'separator' }
     ]
   }

package.json

@@ -1,6 +1,7 @@
 {
   "name": "atom",
-  "version": "36.0.0",
+  "productName": "Atom",
+  "version": "0.43.0",
   "main": "./src/browser/main.js",
   "repository": {
     "type": "git",
@@ -9,21 +10,28 @@
   "bugs": {
     "url": "https://github.com/atom/atom/issues"
   },
-  "atomShellVersion": "0.6.10",
+  "licenses": [
+    {
+      "type": "Apache",
+      "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
+    }
+  ],
+  "atomShellVersion": "0.7.6",
   "dependencies": {
     "async": "0.2.6",
-    "bootstrap": "git://github.com/twbs/bootstrap.git#v3.0.0",
+    "bootstrap": "git://github.com/benogle/bootstrap.git",
     "clear-cut": "0.2.0",
     "coffee-script": "1.6.3",
     "coffeestack": "0.6.0",
-    "emissary": "0.17.0",
+    "emissary": "0.19.0",
     "first-mate": "0.5.0",
-    "fs-plus": "0.9.0",
+    "fs-plus": "0.10.0",
     "fuzzaldrin": "0.1.0",
     "git-utils": "0.29.0",
     "guid": "0.0.10",
     "jasmine-focused": "~0.15.0",
     "mkdirp": "0.3.5",
+    "keytar": "0.13.0",
     "less-cache": "0.10.0",
     "nslog": "0.1.0",
     "oniguruma": "0.24.0",
@@ -34,8 +42,8 @@
     "scandal": "0.8.0",
     "season": "0.14.0",
     "semver": "1.1.4",
-    "space-pen": "2.0.0",
-    "telepath": "0.38.0",
+    "space-pen": "2.0.1",
+    "telepath": "0.61.0",
     "temp": "0.5.0",
     "underscore-plus": "0.3.0"
   },
@@ -64,56 +72,58 @@
     "rimraf": "~2.2.2"
   },
   "packageDependencies": {
-    "atom-light-ui": "0.7.0",
-    "atom-light-syntax": "0.6.0",
-    "atom-dark-ui": "0.7.0",
-    "atom-dark-syntax": "0.6.0",
+    "atom-dark-syntax": "0.8.0",
+    "atom-dark-ui": "0.13.0",
+    "atom-light-syntax": "0.9.0",
+    "atom-light-ui": "0.13.0",
     "base16-tomorrow-dark-theme": "0.6.0",
     "solarized-dark-syntax": "0.4.0",
-    "archive-view": "0.11.0",
-    "autocomplete": "0.12.0",
-    "autoflow": "0.5.0",
-    "autosave": "0.6.0",
-    "bookmarks": "0.10.0",
-    "bracket-matcher": "0.11.0",
-    "command-logger": "0.6.0",
-    "command-palette": "0.8.0",
-    "dev-live-reload": "0.15.0",
-    "editor-stats": "0.5.0",
-    "exception-reporting": "0.7.0",
-    "find-and-replace": "0.41.0",
-    "fuzzy-finder": "0.20.0",
-    "gists": "0.6.0",
-    "git-diff": "0.13.0",
-    "github-sign-in": "0.9.0",
-    "go-to-line": "0.8.0",
-    "grammar-selector": "0.8.0",
-    "image-view": "0.7.0",
-    "keybinding-resolver": "0.2.0",
-    "link": "0.7.0",
-    "markdown-preview": "0.15.0",
-    "metrics": "0.11.0",
-    "package-generator": "0.19.0",
-    "release-notes": "0.11.0",
-    "settings-view": "0.41.0",
-    "snippets": "0.13.0",
-    "spell-check": "0.13.0",
-    "status-bar": "0.16.0",
-    "styleguide": "0.10.0",
-    "symbols-view": "0.19.0",
-    "tabs": "0.8.0",
-    "terminal": "0.16.0",
-    "timecop": "0.9.0",
-    "to-the-hubs": "0.9.0",
-    "tree-view": "0.30.0",
-    "visual-bell": "0.3.0",
-    "whitespace": "0.8.0",
-    "wrap-guide": "0.5.0",
+    "archive-view": "0.16.0",
+    "autocomplete": "0.18.0",
+    "autoflow": "0.11.0",
+    "autosave": "0.10.0",
+    "bookmarks": "0.15.0",
+    "bracket-matcher": "0.15.0",
+    "command-logger": "0.8.0",
+    "command-palette": "0.11.0",
+    "dev-live-reload": "0.18.0",
+    "editor-stats": "0.8.0",
+    "exception-reporting": "0.8.0",
+    "feedback": "0.16.0",
+    "find-and-replace": "0.57.0",
+    "fuzzy-finder": "0.27.0",
+    "gists": "0.12.0",
+    "git-diff": "0.20.0",
+    "github-sign-in": "0.15.0",
+    "go-to-line": "0.12.0",
+    "grammar-selector": "0.13.0",
+    "image-view": "0.10.0",
+    "keybinding-resolver": "0.6.0",
+    "link": "0.11.0",
+    "markdown-preview": "0.22.0",
+    "metrics": "0.14.0",
+    "package-generator": "0.23.0",
+    "release-notes": "0.15.0",
+    "settings-view": "0.50.0",
+    "snippets": "0.17.0",
+    "spell-check": "0.17.0",
+    "status-bar": "0.24.0",
+    "styleguide": "0.17.0",
+    "symbols-view": "0.27.0",
+    "tabs": "0.15.0",
+    "terminal": "0.23.0",
+    "timecop": "0.11.0",
+    "to-the-hubs": "0.15.0",
+    "tree-view": "0.43.0",
+    "visual-bell": "0.6.0",
+    "welcome": "0.3.0",
+    "whitespace": "0.10.0",
+    "wrap-guide": "0.8.0",
     "language-c": "0.2.0",
     "language-clojure": "0.1.0",
     "language-coffee-script": "0.3.0",
     "language-css": "0.2.0",
-    "language-gfm": "0.8.0",
+    "language-gfm": "0.9.0",
     "language-git": "0.3.0",
     "language-go": "0.2.0",
     "language-html": "0.2.0",
@@ -131,7 +141,7 @@
     "language-property-list": "0.2.0",
     "language-puppet": "0.2.0",
     "language-python": "0.2.0",
-    "language-ruby": "0.4.0",
+    "language-ruby": "0.6.0",
     "language-ruby-on-rails": "0.3.0",
     "language-sass": "0.3.0",
     "language-shellscript": "0.2.0",
@@ -139,9 +149,10 @@
     "language-sql": "0.2.0",
     "language-text": "0.2.0",
     "language-todo": "0.2.0",
-    "language-toml": "0.6.0",
+    "language-toml": "0.7.0",
     "language-xml": "0.2.0",
-    "language-yaml": "0.1.0"
+    "language-yaml": "0.1.0",
+    "grunt-download-atom-shell": "0.1.3"
   },
   "private": true,
   "scripts": {

script/bootstrap

@@ -2,6 +2,11 @@
 var safeExec = require('./utils/child-process-wrapper.js').safeExec;
 var path = require('path');
 
+// OAuth token for atom-bot
+// TODO Remove once all repositories are public
+if (!process.env.ATOM_ACCESS_TOKEN)
+  process.env.ATOM_ACCESS_TOKEN = '362295be4c5258d3f7b967bbabae662a455ca2a7';
+
 // Executes an array of commands one by one.
 function executeCommands(commands, done, index) {
   index = (index == undefined ? 0 : index);

script/install-cli

@@ -0,0 +1,11 @@
+#!/usr/bin/env coffee
+
+path = require 'path'
+CommandInstaller = require '../src/command-installer'
+
+callback = (error, sourcePath, destinationPath) ->
+  unless error?
+    console.log "#{sourcePath} intalled to #{destinationPath}"
+
+CommandInstaller.installAtomCommand(path.resolve(__dirname, '..'), callback)
+CommandInstaller.installApmCommand(path.resolve(__dirname, '..'), callback)

script/set-version

@@ -3,11 +3,11 @@
 set -e
 
 BUILT_PRODUCTS_DIR=$1
+VERSION=$2
 PLIST_PATH="$BUILT_PRODUCTS_DIR/Atom.app/Contents/Info.plist"
 HELPER_PLIST_PATH="$BUILT_PRODUCTS_DIR/Atom.app/Contents/Frameworks/Atom Helper.app/Contents/Info.plist"
 
 # Update version
-VERSION=$(git rev-parse --short HEAD | tr -d "\n")
 /usr/libexec/PlistBuddy -c "Set CFBundleShortVersionString $VERSION" "$PLIST_PATH"
 /usr/libexec/PlistBuddy -c "Set CFBundleVersion $VERSION" "$PLIST_PATH"
 /usr/libexec/PlistBuddy -c "Set CFBundleShortVersionString $VERSION" "$HELPER_PLIST_PATH"

spec/atom-package-spec.coffee

@@ -15,14 +15,14 @@ describe "AtomPackage", ->
     describe "when the theme contains a single style file", ->
       it "loads and applies css", ->
         expect($(".editor").css("padding-bottom")).not.toBe "1234px"
-        themePath = project.resolve('packages/theme-with-index-css')
+        themePath = atom.project.resolve('packages/theme-with-index-css')
         theme = Package.load(themePath)
         theme.activate()
         expect($(".editor").css("padding-top")).toBe "1234px"
 
       it "parses, loads and applies less", ->
         expect($(".editor").css("padding-bottom")).not.toBe "1234px"
-        themePath = project.resolve('packages/theme-with-index-less')
+        themePath = atom.project.resolve('packages/theme-with-index-less')
         theme = Package.load(themePath)
         theme.activate()
         expect($(".editor").css("padding-top")).toBe "4321px"
@@ -33,7 +33,7 @@ describe "AtomPackage", ->
         expect($(".editor").css("padding-right")).not.toBe("102px")
         expect($(".editor").css("padding-bottom")).not.toBe("103px")
 
-        themePath = project.resolve('packages/theme-with-package-file')
+        themePath = atom.project.resolve('packages/theme-with-package-file')
         theme = Package.load(themePath)
         theme.activate()
         expect($(".editor").css("padding-top")).toBe("101px")
@@ -46,7 +46,7 @@ describe "AtomPackage", ->
         expect($(".editor").css("padding-right")).not.toBe "20px"
         expect($(".editor").css("padding-bottom")).not.toBe "30px"
 
-        themePath = project.resolve('packages/theme-without-package-file')
+        themePath = atom.project.resolve('packages/theme-without-package-file')
         theme = Package.load(themePath)
         theme.activate()
         expect($(".editor").css("padding-top")).toBe "10px"
@@ -55,7 +55,7 @@ describe "AtomPackage", ->
 
     describe "reloading a theme", ->
       beforeEach ->
-        themePath = project.resolve('packages/theme-with-package-file')
+        themePath = atom.project.resolve('packages/theme-with-package-file')
         theme = Package.load(themePath)
         theme.activate()
 
@@ -66,7 +66,7 @@ describe "AtomPackage", ->
 
     describe "events", ->
       beforeEach ->
-        themePath = project.resolve('packages/theme-with-package-file')
+        themePath = atom.project.resolve('packages/theme-with-package-file')
         theme = Package.load(themePath)
         theme.activate()
 

spec/atom-spec.coffee

@@ -1,20 +1,20 @@
-{$, $$, fs, RootView}  = require 'atom'
+{$, $$, fs, WorkspaceView}  = require 'atom'
 Exec = require('child_process').exec
 path = require 'path'
 ThemeManager = require '../src/theme-manager'
 
 describe "the `atom` global", ->
   beforeEach ->
-    window.rootView = new RootView
+    atom.workspaceView = new WorkspaceView
 
   describe "package lifecycle methods", ->
     describe ".loadPackage(name)", ->
       describe "when the package has deferred deserializers", ->
         it "requires the package's main module if one of its deferred deserializers is referenced", ->
-          pack = atom.loadPackage('package-with-activation-events')
+          pack = atom.packages.loadPackage('package-with-activation-events')
           spyOn(pack, 'activateStylesheets').andCallThrough()
           expect(pack.mainModule).toBeNull()
-          object = deserialize({deserializer: 'Foo', data: 5})
+          object = atom.deserializers.deserialize({deserializer: 'Foo', data: 5})
           expect(pack.mainModule).toBeDefined()
           expect(object.constructor.name).toBe 'Foo'
           expect(object.data).toBe 5
@@ -23,34 +23,34 @@ describe "the `atom` global", ->
         it "continues if the package has an invalid package.json", ->
           spyOn(console, 'warn')
           atom.config.set("core.disabledPackages", [])
-          expect(-> atom.loadPackage("package-with-broken-package-json")).not.toThrow()
+          expect(-> atom.packages.loadPackage("package-with-broken-package-json")).not.toThrow()
 
         it "continues if the package has an invalid keymap", ->
           atom.config.set("core.disabledPackages", [])
-          expect(-> atom.loadPackage("package-with-broken-keymap")).not.toThrow()
+          expect(-> atom.packages.loadPackage("package-with-broken-keymap")).not.toThrow()
 
     describe ".unloadPackage(name)", ->
       describe "when the package is active", ->
         it "throws an error", ->
-          pack = atom.activatePackage('package-with-main')
-          expect(atom.isPackageLoaded(pack.name)).toBeTruthy()
-          expect(atom.isPackageActive(pack.name)).toBeTruthy()
-          expect( -> atom.unloadPackage(pack.name)).toThrow()
-          expect(atom.isPackageLoaded(pack.name)).toBeTruthy()
-          expect(atom.isPackageActive(pack.name)).toBeTruthy()
+          pack = atom.packages.activatePackage('package-with-main')
+          expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
+          expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
+          expect( -> atom.packages.unloadPackage(pack.name)).toThrow()
+          expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
+          expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
 
       describe "when the package is not loaded", ->
         it "throws an error", ->
-          expect(atom.isPackageLoaded('unloaded')).toBeFalsy()
-          expect( -> atom.unloadPackage('unloaded')).toThrow()
-          expect(atom.isPackageLoaded('unloaded')).toBeFalsy()
+          expect(atom.packages.isPackageLoaded('unloaded')).toBeFalsy()
+          expect( -> atom.packages.unloadPackage('unloaded')).toThrow()
+          expect(atom.packages.isPackageLoaded('unloaded')).toBeFalsy()
 
       describe "when the package is loaded", ->
         it "no longers reports it as being loaded", ->
-          pack = atom.loadPackage('package-with-main')
-          expect(atom.isPackageLoaded(pack.name)).toBeTruthy()
-          atom.unloadPackage(pack.name)
-          expect(atom.isPackageLoaded(pack.name)).toBeFalsy()
+          pack = atom.packages.loadPackage('package-with-main')
+          expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
+          atom.packages.unloadPackage(pack.name)
+          expect(atom.packages.isPackageLoaded(pack.name)).toBeFalsy()
 
     describe ".activatePackage(id)", ->
       describe "atom packages", ->
@@ -59,7 +59,7 @@ describe "the `atom` global", ->
             it "requires the module at the specified path", ->
               mainModule = require('./fixtures/packages/package-with-main/main-module')
               spyOn(mainModule, 'activate')
-              pack = atom.activatePackage('package-with-main')
+              pack = atom.packages.activatePackage('package-with-main')
               expect(mainModule.activate).toHaveBeenCalled()
               expect(pack.mainModule).toBe mainModule
 
@@ -67,13 +67,13 @@ describe "the `atom` global", ->
             it "requires index.coffee", ->
               indexModule = require('./fixtures/packages/package-with-index/index')
               spyOn(indexModule, 'activate')
-              pack = atom.activatePackage('package-with-index')
+              pack = atom.packages.activatePackage('package-with-index')
               expect(indexModule.activate).toHaveBeenCalled()
               expect(pack.mainModule).toBe indexModule
 
           it "assigns config defaults from the module", ->
             expect(atom.config.get('package-with-config-defaults.numbers.one')).toBeUndefined()
-            atom.activatePackage('package-with-config-defaults')
+            atom.packages.activatePackage('package-with-config-defaults')
             expect(atom.config.get('package-with-config-defaults.numbers.one')).toBe 1
             expect(atom.config.get('package-with-config-defaults.numbers.two')).toBe 2
 
@@ -85,24 +85,24 @@ describe "the `atom` global", ->
               spyOn(mainModule, 'activate').andCallThrough()
               AtomPackage = require '../src/atom-package'
               spyOn(AtomPackage.prototype, 'requireMainModule').andCallThrough()
-              pack = atom.activatePackage('package-with-activation-events')
+              pack = atom.packages.activatePackage('package-with-activation-events')
 
             it "defers requiring/activating the main module until an activation event bubbles to the root view", ->
               expect(pack.requireMainModule).not.toHaveBeenCalled()
               expect(mainModule.activate).not.toHaveBeenCalled()
-              rootView.trigger 'activation-event'
+              atom.workspaceView.trigger 'activation-event'
               expect(mainModule.activate).toHaveBeenCalled()
 
             it "triggers the activation event on all handlers registered during activation", ->
-              rootView.openSync()
-              editor = rootView.getActiveView()
+              atom.workspaceView.openSync()
+              editorView = atom.workspaceView.getActiveView()
               eventHandler = jasmine.createSpy("activation-event")
-              editor.command 'activation-event', eventHandler
-              editor.trigger 'activation-event'
+              editorView.command 'activation-event', eventHandler
+              editorView.trigger 'activation-event'
               expect(mainModule.activate.callCount).toBe 1
               expect(mainModule.activationEventCallCount).toBe 1
               expect(eventHandler.callCount).toBe 1
-              editor.trigger 'activation-event'
+              editorView.trigger 'activation-event'
               expect(mainModule.activationEventCallCount).toBe 2
               expect(eventHandler.callCount).toBe 2
               expect(mainModule.activate.callCount).toBe 1
@@ -111,23 +111,23 @@ describe "the `atom` global", ->
           it "does not throw an exception", ->
             spyOn(console, "error")
             spyOn(console, "warn").andCallThrough()
-            expect(-> atom.activatePackage('package-without-module')).not.toThrow()
+            expect(-> atom.packages.activatePackage('package-without-module')).not.toThrow()
             expect(console.error).not.toHaveBeenCalled()
             expect(console.warn).not.toHaveBeenCalled()
 
         it "passes the activate method the package's previously serialized state if it exists", ->
-          pack = atom.activatePackage("package-with-serialization")
+          pack = atom.packages.activatePackage("package-with-serialization")
           expect(pack.mainModule.someNumber).not.toBe 77
           pack.mainModule.someNumber = 77
-          atom.deactivatePackage("package-with-serialization")
+          atom.packages.deactivatePackage("package-with-serialization")
           spyOn(pack.mainModule, 'activate').andCallThrough()
-          atom.activatePackage("package-with-serialization")
+          atom.packages.activatePackage("package-with-serialization")
           expect(pack.mainModule.activate).toHaveBeenCalledWith({someNumber: 77})
 
         it "logs warning instead of throwing an exception if the package fails to load", ->
           atom.config.set("core.disabledPackages", [])
           spyOn(console, "warn")
-          expect(-> atom.activatePackage("package-that-throws-an-exception")).not.toThrow()
+          expect(-> atom.packages.activatePackage("package-that-throws-an-exception")).not.toThrow()
           expect(console.warn).toHaveBeenCalled()
 
         describe "keymap loading", ->
@@ -141,7 +141,7 @@ describe "the `atom` global", ->
               expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element2)).toHaveLength 0
               expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element3)).toHaveLength 0
 
-              atom.activatePackage("package-with-keymaps")
+              atom.packages.activatePackage("package-with-keymaps")
 
               expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe "test-1"
               expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element2)[0].command).toBe "test-2"
@@ -154,7 +154,7 @@ describe "the `atom` global", ->
 
               expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)).toHaveLength 0
 
-              atom.activatePackage("package-with-keymaps-manifest")
+              atom.packages.activatePackage("package-with-keymaps-manifest")
 
               expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe 'keymap-1'
               expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-n', element1)[0].command).toBe 'keymap-2'
@@ -171,7 +171,7 @@ describe "the `atom` global", ->
 
               expect(atom.contextMenu.definitionsForElement(element)).toEqual []
 
-              atom.activatePackage("package-with-menus")
+              atom.packages.activatePackage("package-with-menus")
 
               expect(atom.menu.template.length).toBe 2
               expect(atom.menu.template[0].label).toBe "Second to Last"
@@ -186,7 +186,7 @@ describe "the `atom` global", ->
 
               expect(atom.contextMenu.definitionsForElement(element)).toEqual []
 
-              atom.activatePackage("package-with-menus-manifest")
+              atom.packages.activatePackage("package-with-menus-manifest")
 
               expect(atom.menu.template[0].label).toBe "Second to Last"
               expect(atom.menu.template[1].label).toBe "Last"
@@ -209,7 +209,7 @@ describe "the `atom` global", ->
               expect(atom.themes.stylesheetElementForId(two)).not.toExist()
               expect(atom.themes.stylesheetElementForId(three)).not.toExist()
 
-              atom.activatePackage("package-with-stylesheets-manifest")
+              atom.packages.activatePackage("package-with-stylesheets-manifest")
 
               expect(atom.themes.stylesheetElementForId(one)).toExist()
               expect(atom.themes.stylesheetElementForId(two)).toExist()
@@ -231,7 +231,7 @@ describe "the `atom` global", ->
               expect(atom.themes.stylesheetElementForId(two)).not.toExist()
               expect(atom.themes.stylesheetElementForId(three)).not.toExist()
 
-              atom.activatePackage("package-with-stylesheets")
+              atom.packages.activatePackage("package-with-stylesheets")
               expect(atom.themes.stylesheetElementForId(one)).toExist()
               expect(atom.themes.stylesheetElementForId(two)).toExist()
               expect(atom.themes.stylesheetElementForId(three)).toExist()
@@ -239,90 +239,91 @@ describe "the `atom` global", ->
 
         describe "grammar loading", ->
           it "loads the package's grammars", ->
-            atom.activatePackage('package-with-grammars')
+            atom.packages.activatePackage('package-with-grammars')
             expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Alot'
             expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Alittle'
 
         describe "scoped-property loading", ->
           it "loads the scoped properties", ->
-            atom.activatePackage("package-with-scoped-properties")
+            atom.packages.activatePackage("package-with-scoped-properties")
             expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
 
       describe "textmate packages", ->
         it "loads the package's grammars", ->
           expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-          atom.activatePackage('language-ruby', sync: true)
+          atom.packages.activatePackage('language-ruby', sync: true)
           expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
 
         it "translates the package's scoped properties to Atom terms", ->
           expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
-          atom.activatePackage('language-ruby', sync: true)
+          atom.packages.activatePackage('language-ruby', sync: true)
           expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBe '# '
 
         describe "when the package has no grammars but does have preferences", ->
           it "loads the package's preferences as scoped properties", ->
             jasmine.unspy(window, 'setTimeout')
-            spyOn(syntax, 'addProperties').andCallThrough()
+            spyOn(atom.syntax, 'addProperties').andCallThrough()
 
-            atom.activatePackage('package-with-preferences-tmbundle')
+            atom.packages.activatePackage('package-with-preferences-tmbundle')
 
             waitsFor ->
               atom.syntax.addProperties.callCount > 0
+
             runs ->
               expect(atom.syntax.getProperty(['.source.pref'], 'editor.increaseIndentPattern')).toBe '^abc$'
 
     describe ".deactivatePackage(id)", ->
       describe "atom packages", ->
         it "calls `deactivate` on the package's main module if activate was successful", ->
-          pack = atom.activatePackage("package-with-deactivate")
-          expect(atom.isPackageActive("package-with-deactivate")).toBeTruthy()
+          pack = atom.packages.activatePackage("package-with-deactivate")
+          expect(atom.packages.isPackageActive("package-with-deactivate")).toBeTruthy()
           spyOn(pack.mainModule, 'deactivate').andCallThrough()
 
-          atom.deactivatePackage("package-with-deactivate")
+          atom.packages.deactivatePackage("package-with-deactivate")
           expect(pack.mainModule.deactivate).toHaveBeenCalled()
-          expect(atom.isPackageActive("package-with-module")).toBeFalsy()
+          expect(atom.packages.isPackageActive("package-with-module")).toBeFalsy()
 
           spyOn(console, 'warn')
-          badPack = atom.activatePackage("package-that-throws-on-activate")
-          expect(atom.isPackageActive("package-that-throws-on-activate")).toBeTruthy()
+          badPack = atom.packages.activatePackage("package-that-throws-on-activate")
+          expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeTruthy()
           spyOn(badPack.mainModule, 'deactivate').andCallThrough()
 
-          atom.deactivatePackage("package-that-throws-on-activate")
+          atom.packages.deactivatePackage("package-that-throws-on-activate")
           expect(badPack.mainModule.deactivate).not.toHaveBeenCalled()
-          expect(atom.isPackageActive("package-that-throws-on-activate")).toBeFalsy()
+          expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeFalsy()
 
         it "does not serialize packages that have not been activated called on their main module", ->
           spyOn(console, 'warn')
-          badPack = atom.activatePackage("package-that-throws-on-activate")
+          badPack = atom.packages.activatePackage("package-that-throws-on-activate")
           spyOn(badPack.mainModule, 'serialize').andCallThrough()
 
-          atom.deactivatePackage("package-that-throws-on-activate")
+          atom.packages.deactivatePackage("package-that-throws-on-activate")
           expect(badPack.mainModule.serialize).not.toHaveBeenCalled()
 
         it "absorbs exceptions that are thrown by the package module's serialize methods", ->
           spyOn(console, 'error')
-          atom.activatePackage('package-with-serialize-error',  immediate: true)
-          atom.activatePackage('package-with-serialization', immediate: true)
-          atom.deactivatePackages()
+          atom.packages.activatePackage('package-with-serialize-error',  immediate: true)
+          atom.packages.activatePackage('package-with-serialization', immediate: true)
+          atom.packages.deactivatePackages()
           expect(atom.packages.packageStates['package-with-serialize-error']).toBeUndefined()
           expect(atom.packages.packageStates['package-with-serialization']).toEqual someNumber: 1
           expect(console.error).toHaveBeenCalled()
 
         it "removes the package's grammars", ->
-          atom.activatePackage('package-with-grammars')
-          atom.deactivatePackage('package-with-grammars')
+          atom.packages.activatePackage('package-with-grammars')
+          atom.packages.deactivatePackage('package-with-grammars')
           expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Null Grammar'
           expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Null Grammar'
 
         it "removes the package's keymaps", ->
-          atom.activatePackage('package-with-keymaps')
-          atom.deactivatePackage('package-with-keymaps')
+          atom.packages.activatePackage('package-with-keymaps')
+          atom.packages.deactivatePackage('package-with-keymaps')
           expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', $$ -> @div class: 'test-1')).toHaveLength 0
           expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', $$ -> @div class: 'test-2')).toHaveLength 0
 
         it "removes the package's stylesheets", ->
-          atom.activatePackage('package-with-stylesheets')
-          atom.deactivatePackage('package-with-stylesheets')
+          atom.packages.activatePackage('package-with-stylesheets')
+          atom.packages.deactivatePackage('package-with-stylesheets')
           one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css")
           two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less")
           three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css")
@@ -331,22 +332,22 @@ describe "the `atom` global", ->
           expect(atom.themes.stylesheetElementForId(three)).not.toExist()
 
         it "removes the package's scoped-properties", ->
-          atom.activatePackage("package-with-scoped-properties")
+          atom.packages.activatePackage("package-with-scoped-properties")
           expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
-          atom.deactivatePackage("package-with-scoped-properties")
+          atom.packages.deactivatePackage("package-with-scoped-properties")
           expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBeUndefined()
 
       describe "textmate packages", ->
         it "removes the package's grammars", ->
           expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-          atom.activatePackage('language-ruby', sync: true)
+          atom.packages.activatePackage('language-ruby', sync: true)
           expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
-          atom.deactivatePackage('language-ruby')
+          atom.packages.deactivatePackage('language-ruby')
           expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
 
         it "removes the package's scoped properties", ->
-          atom.activatePackage('language-ruby', sync: true)
-          atom.deactivatePackage('language-ruby')
+          atom.packages.activatePackage('language-ruby', sync: true)
+          atom.packages.deactivatePackage('language-ruby')
           expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
 
     describe ".activate()", ->

spec/config-spec.coffee

@@ -108,11 +108,11 @@ describe "Config", ->
       expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
 
   describe ".save()", ->
-    nodeFs = require 'fs'
+    CSON = require 'season'
 
     beforeEach ->
-      spyOn(nodeFs, 'writeFileSync')
-      jasmine.unspy config, 'save'
+      spyOn(CSON, 'writeFileSync')
+      jasmine.unspy atom.config, 'save'
 
     describe "when ~/.atom/config.json exists", ->
       it "writes any non-default properties to ~/.atom/config.json", ->
@@ -122,12 +122,12 @@ describe "Config", ->
         atom.config.set("x.y.z", 3)
         atom.config.setDefaults("a.b", e: 4, f: 5)
 
-        nodeFs.writeFileSync.reset()
+        CSON.writeFileSync.reset()
         atom.config.save()
 
-        expect(nodeFs.writeFileSync.argsForCall[0][0]).toBe(path.join(atom.config.configDirPath, "atom.config.json"))
-        writtenConfig = JSON.parse(nodeFs.writeFileSync.argsForCall[0][1])
-        expect(writtenConfig).toEqual atom.config.settings
+        expect(CSON.writeFileSync.argsForCall[0][0]).toBe(path.join(atom.config.configDirPath, "atom.config.json"))
+        writtenConfig = CSON.writeFileSync.argsForCall[0][1]
+        expect(writtenConfig).toBe atom.config.settings
 
     describe "when ~/.atom/config.json doesn't exist", ->
       it "writes any non-default properties to ~/.atom/config.cson", ->
@@ -137,12 +137,12 @@ describe "Config", ->
         atom.config.set("x.y.z", 3)
         atom.config.setDefaults("a.b", e: 4, f: 5)
 
-        nodeFs.writeFileSync.reset()
+        CSON.writeFileSync.reset()
         atom.config.save()
 
-        expect(nodeFs.writeFileSync.argsForCall[0][0]).toBe(path.join(atom.config.configDirPath, "atom.config.cson"))
+        expect(CSON.writeFileSync.argsForCall[0][0]).toBe(path.join(atom.config.configDirPath, "atom.config.cson"))
         CoffeeScript = require 'coffee-script'
-        writtenConfig = CoffeeScript.eval(nodeFs.writeFileSync.argsForCall[0][1], bare: true)
+        writtenConfig = CSON.writeFileSync.argsForCall[0][1]
         expect(writtenConfig).toEqual atom.config.settings
 
   describe ".setDefaults(keyPath, defaults)", ->
@@ -158,12 +158,12 @@ describe "Config", ->
       expect(atom.config.get("foo.quux.y")).toBe 1
 
   describe ".observe(keyPath)", ->
-    observeHandler = null
+    [observeHandler, observeSubscription] = []
 
     beforeEach ->
       observeHandler = jasmine.createSpy("observeHandler")
       atom.config.set("foo.bar.baz", "value 1")
-      atom.config.observe "foo.bar.baz", observeHandler
+      observeSubscription = atom.config.observe "foo.bar.baz", observeHandler
 
     it "fires the given callback with the current value at the keypath", ->
       expect(observeHandler).toHaveBeenCalledWith("value 1")
@@ -192,6 +192,12 @@ describe "Config", ->
       atom.config.set("foo.bar.baz", "i'm back")
       expect(observeHandler).toHaveBeenCalledWith("i'm back", {previous: undefined})
 
+    it "does not fire the callback once the observe subscription is off'ed", ->
+      observeHandler.reset() # clear the initial call
+      observeSubscription.off()
+      atom.config.set('foo.bar.baz', "value 2")
+      expect(observeHandler).not.toHaveBeenCalled()
+
   describe ".initializeConfigDirectory()", ->
     beforeEach ->
       atom.config.configDirPath = dotAtomPath

spec/display-buffer-spec.coffee

@@ -5,8 +5,8 @@ describe "DisplayBuffer", ->
   [displayBuffer, buffer, changeHandler, tabLength] = []
   beforeEach ->
     tabLength = 2
-    atom.activatePackage('language-javascript', sync: true)
-    buffer = project.bufferForPathSync('sample.js')
+    atom.packages.activatePackage('language-javascript', sync: true)
+    buffer = atom.project.bufferForPathSync('sample.js')
     displayBuffer = new DisplayBuffer({buffer, tabLength})
     changeHandler = jasmine.createSpy 'changeHandler'
     displayBuffer.on 'changed', changeHandler
@@ -20,7 +20,7 @@ describe "DisplayBuffer", ->
       displayBuffer.setTabLength(4)
       displayBuffer.setEditorWidthInChars(64)
       displayBuffer.createFold(2, 4)
-      displayBuffer2 = deserialize(displayBuffer.serialize())
+      displayBuffer2 = atom.deserializers.deserialize(displayBuffer.serialize())
       expect(displayBuffer2.id).toBe displayBuffer.id
       expect(displayBuffer2.buffer).toBe displayBuffer.buffer
       expect(displayBuffer2.tokenizedBuffer.buffer).toBe displayBuffer.tokenizedBuffer.buffer
@@ -154,7 +154,7 @@ describe "DisplayBuffer", ->
 
       describe "when a newline is inserted, deleted, and re-inserted at the end of a wrapped line (regression)", ->
         it "correctly renders the original wrapped line", ->
-          buffer = project.buildBufferSync(null, '')
+          buffer = atom.project.buildBufferSync(null, '')
           displayBuffer = new DisplayBuffer({buffer, tabLength, editorWidthInChars: 30, softWrap: true})
 
           buffer.insert([0, 0], "the quick brown fox jumps over the lazy dog.")
@@ -206,7 +206,7 @@ describe "DisplayBuffer", ->
     beforeEach ->
       displayBuffer.destroy()
       buffer.release()
-      buffer = project.bufferForPathSync('two-hundred.txt')
+      buffer = atom.project.bufferForPathSync('two-hundred.txt')
       displayBuffer = new DisplayBuffer({buffer, tabLength})
       displayBuffer.on 'changed', changeHandler
 
@@ -600,7 +600,7 @@ describe "DisplayBuffer", ->
     it "unsubscribes all display buffer markers from their underlying buffer marker (regression)", ->
       marker = displayBuffer.markBufferPosition([12, 2])
       displayBuffer.destroy()
-      expect(marker.bufferMarker.subscriptionCount()).toBe 0
+      expect(marker.bufferMarker.getSubscriptionCount()).toBe 0
       expect( -> buffer.insert([12, 2], '\n')).not.toThrow()
 
   describe "markers", ->

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

@@ -1,5 +1,5 @@
 class Foo
-  registerDeserializer(this)
+  atom.deserializers.add(this)
   @deserialize: ({data}) -> new Foo(data)
   constructor: (@data) ->
 
@@ -9,5 +9,5 @@ module.exports =
 
   activate: ->
     @activateCallCount++
-    rootView.getActiveView()?.command 'activation-event', =>
+    atom.workspaceView.getActiveView()?.command 'activation-event', =>
       @activationEventCallCount++

spec/fixtures/packages/package-with-serialize-error/package.cson

@@ -1,5 +1,5 @@
 # This package loads async, otherwise it would log errors when it
-# is automatically serialized when rootView is deactivatated
+# is automatically serialized when workspaceView is deactivatated
 
 'main': 'index.coffee'
 'activationEvents': ['activation-event']

spec/git-spec.coffee

@@ -182,10 +182,10 @@ describe "Git", ->
 
     beforeEach ->
       repo = new Git(path.join(__dirname, 'fixtures', 'git', 'working-dir'))
-      modifiedPath = project.resolve('git/working-dir/file.txt')
+      modifiedPath = atom.project.resolve('git/working-dir/file.txt')
       originalModifiedPathText = fs.readFileSync(modifiedPath, 'utf8')
-      newPath = project.resolve('git/working-dir/untracked.txt')
-      cleanPath = project.resolve('git/working-dir/other.txt')
+      newPath = atom.project.resolve('git/working-dir/untracked.txt')
+      cleanPath = atom.project.resolve('git/working-dir/other.txt')
       fs.writeFileSync(newPath, '')
 
     afterEach ->
@@ -208,44 +208,44 @@ describe "Git", ->
         expect(repo.isStatusModified(statuses[modifiedPath])).toBeTruthy()
 
   describe "buffer events", ->
-    [originalContent, editSession] = []
+    [originalContent, editor] = []
 
     beforeEach ->
-      editSession = project.openSync('sample.js')
-      originalContent = editSession.getText()
+      editor = atom.project.openSync('sample.js')
+      originalContent = editor.getText()
 
     afterEach ->
-      fs.writeFileSync(editSession.getPath(), originalContent)
+      fs.writeFileSync(editor.getPath(), originalContent)
 
     it "emits a status-changed event when a buffer is saved", ->
-      editSession.insertNewline()
+      editor.insertNewline()
 
       statusHandler = jasmine.createSpy('statusHandler')
-      project.getRepo().on 'status-changed', statusHandler
-      editSession.save()
+      atom.project.getRepo().on 'status-changed', statusHandler
+      editor.save()
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler).toHaveBeenCalledWith editSession.getPath(), 256
+      expect(statusHandler).toHaveBeenCalledWith editor.getPath(), 256
 
     it "emits a status-changed event when a buffer is reloaded", ->
-      fs.writeFileSync(editSession.getPath(), 'changed')
+      fs.writeFileSync(editor.getPath(), 'changed')
 
       statusHandler = jasmine.createSpy('statusHandler')
-      project.getRepo().on 'status-changed', statusHandler
-      editSession.getBuffer().reload()
+      atom.project.getRepo().on 'status-changed', statusHandler
+      editor.getBuffer().reload()
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler).toHaveBeenCalledWith editSession.getPath(), 256
-      editSession.getBuffer().reload()
+      expect(statusHandler).toHaveBeenCalledWith editor.getPath(), 256
+      editor.getBuffer().reload()
       expect(statusHandler.callCount).toBe 1
 
     it "emits a status-changed event when a buffer's path changes", ->
-      fs.writeFileSync(editSession.getPath(), 'changed')
+      fs.writeFileSync(editor.getPath(), 'changed')
 
       statusHandler = jasmine.createSpy('statusHandler')
-      project.getRepo().on 'status-changed', statusHandler
-      editSession.getBuffer().trigger 'path-changed'
+      atom.project.getRepo().on 'status-changed', statusHandler
+      editor.getBuffer().emit 'path-changed'
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler).toHaveBeenCalledWith editSession.getPath(), 256
-      editSession.getBuffer().trigger 'path-changed'
+      expect(statusHandler).toHaveBeenCalledWith editor.getPath(), 256
+      editor.getBuffer().emit 'path-changed'
       expect(statusHandler.callCount).toBe 1
 
   describe "when a project is deserialized", ->
@@ -256,7 +256,7 @@ describe "Git", ->
       project2?.destroy()
 
     it "subscribes to all the serialized buffers in the project", ->
-      project.openSync('sample.js')
+      atom.project.openSync('sample.js')
       #TODO Replace with atom.replicate().project when Atom is a telepath model
       project2 = atom.replicate().get('project')
       buffer = project2.getBuffers()[0]

spec/keymap-spec.coffee

@@ -1,7 +1,7 @@
 path = require 'path'
 
 Keymap = require '../src/keymap'
-{$, $$, RootView} = require 'atom'
+{$, $$, WorkspaceView} = require 'atom'
 
 describe "Keymap", ->
   fragment = null
@@ -21,19 +21,19 @@ describe "Keymap", ->
   describe ".handleKeyEvent(event)", ->
     deleteCharHandler = null
     insertCharHandler = null
-    metaZHandler = null
+    commandZHandler = null
 
     beforeEach ->
       keymap.bindKeys 'name', '.command-mode', 'x': 'deleteChar'
       keymap.bindKeys 'name', '.insert-mode', 'x': 'insertChar'
-      keymap.bindKeys 'name', '.command-mode', 'meta-z': 'metaZPressed'
+      keymap.bindKeys 'name', '.command-mode', 'cmd-z': 'commandZPressed'
 
       deleteCharHandler = jasmine.createSpy('deleteCharHandler')
       insertCharHandler = jasmine.createSpy('insertCharHandler')
-      metaZHandler = jasmine.createSpy('metaZHandler')
+      commandZHandler = jasmine.createSpy('commandZHandler')
       fragment.on 'deleteChar', deleteCharHandler
       fragment.on 'insertChar', insertCharHandler
-      fragment.on 'metaZPressed', metaZHandler
+      fragment.on 'commandZPressed', commandZHandler
 
     describe "when no binding matches the event's keystroke", ->
       it "does not return false so the event continues to propagate", ->
@@ -45,7 +45,7 @@ describe "Keymap", ->
         result = keymap.handleKeyEvent(event)
 
         expect(result).toBe(false)
-        expect(metaZHandler).toHaveBeenCalled()
+        expect(commandZHandler).toHaveBeenCalled()
 
     describe "when at least one binding fully matches the event's keystroke", ->
       describe "when the event's target node matches a selector with a matching binding", ->
@@ -158,12 +158,12 @@ describe "Keymap", ->
             expect(bazHandler).toHaveBeenCalled()
 
       describe "when the event's target is the document body", ->
-        it "triggers the mapped event on the rootView", ->
-          window.rootView = new RootView
-          rootView.attachToDom()
+        it "triggers the mapped event on the workspaceView", ->
+          atom.workspaceView = new WorkspaceView
+          atom.workspaceView.attachToDom()
           keymap.bindKeys 'name', 'body', 'x': 'foo'
           fooHandler = jasmine.createSpy("fooHandler")
-          rootView.on 'foo', fooHandler
+          atom.workspaceView.on 'foo', fooHandler
 
           result = keymap.handleKeyEvent(keydownEvent('x', target: document.body))
           expect(result).toBe(false)
@@ -291,12 +291,12 @@ describe "Keymap", ->
         expect(keymap.keystrokeStringForEvent(keydownEvent('left'))).toBe 'left'
         expect(keymap.keystrokeStringForEvent(keydownEvent('\b'))).toBe 'backspace'
 
-    describe "when ctrl, alt or meta is pressed with a non-modifier key", ->
+    describe "when ctrl, alt or command is pressed with a non-modifier key", ->
       it "returns a string that identifies the key pressed", ->
         expect(keymap.keystrokeStringForEvent(keydownEvent('a', altKey: true))).toBe 'alt-a'
-        expect(keymap.keystrokeStringForEvent(keydownEvent('[', metaKey: true))).toBe 'meta-['
+        expect(keymap.keystrokeStringForEvent(keydownEvent('[', metaKey: true))).toBe 'cmd-['
         expect(keymap.keystrokeStringForEvent(keydownEvent('*', ctrlKey: true))).toBe 'ctrl-*'
-        expect(keymap.keystrokeStringForEvent(keydownEvent('left', ctrlKey: true, metaKey: true, altKey: true))).toBe 'alt-ctrl-meta-left'
+        expect(keymap.keystrokeStringForEvent(keydownEvent('left', ctrlKey: true, metaKey: true, altKey: true))).toBe 'alt-cmd-ctrl-left'
 
     describe "when shift is pressed when a non-modifer key", ->
       it "returns a string that identifies the key pressed", ->
@@ -317,10 +317,33 @@ describe "Keymap", ->
 
     describe "when multiple bindings match a keystroke", ->
       it "only returns bindings that match the most specific selector", ->
-        keymap.bindKeys 'name', '.command-mode', 'g': 'command-mode'
-        keymap.bindKeys 'name', '.command-mode .grandchild-node', 'g': 'command-and-grandchild-node'
+        keymap.bindKeys 'name', '.command-mode', 'g': 'cmd-mode'
+        keymap.bindKeys 'name', '.command-mode .grandchild-node', 'g': 'cmd-and-grandchild-node'
         keymap.bindKeys 'name', '.grandchild-node', 'g': 'grandchild-node'
 
         bindings = keymap.keyBindingsMatchingElement(fragment.find('.grandchild-node'))
         expect(bindings).toHaveLength 3
-        expect(bindings[0].command).toEqual "command-and-grandchild-node"
+        expect(bindings[0].command).toEqual "cmd-and-grandchild-node"
+
+  describe ".keyBindingsForCommandMatchingElement(element)", ->
+    beforeEach ->
+      keymap.add 'nature',
+        '.green':
+          'ctrl-c': 'cultivate'
+        '.green-2':
+          'ctrl-o': 'cultivate'
+        '.brown':
+          'ctrl-h': 'harvest'
+        '.blue':
+          'ctrl-c': 'fly'
+
+    it "finds a keymap for an element", ->
+      el = $$ -> @div class: 'green'
+      bindings = keymap.keyBindingsForCommandMatchingElement('cultivate', el)
+      expect(bindings).toHaveLength 1
+      expect(bindings[0].keystroke).toEqual "ctrl-c"
+
+    it "no keymap an element without that map", ->
+      el = $$ -> @div class: 'brown'
+      bindings = keymap.keyBindingsForCommandMatchingElement('cultivate', el)
+      expect(bindings).toHaveLength 0

spec/language-mode-spec.coffee

@@ -1,14 +1,14 @@
 describe "LanguageMode", ->
-  [editSession, buffer, languageMode] = []
+  [editor, buffer, languageMode] = []
 
   afterEach ->
-    editSession.destroy()
+    editor.destroy()
 
   describe "javascript", ->
     beforeEach ->
-      atom.activatePackage('language-javascript', sync: true)
-      editSession = project.openSync('sample.js', autoIndent: false)
-      {buffer, languageMode} = editSession
+      atom.packages.activatePackage('language-javascript', sync: true)
+      editor = atom.project.openSync('sample.js', autoIndent: false)
+      {buffer, languageMode} = editor
 
     describe ".minIndentLevelForRowRange(startRow, endRow)", ->
       it "returns the minimum indent level for the given row range", ->
@@ -109,9 +109,9 @@ describe "LanguageMode", ->
 
   describe "coffeescript", ->
     beforeEach ->
-      atom.activatePackage('language-coffee-script', sync: true)
-      editSession = project.openSync('coffee.coffee', autoIndent: false)
-      {buffer, languageMode} = editSession
+      atom.packages.activatePackage('language-coffee-script', sync: true)
+      editor = atom.project.openSync('coffee.coffee', autoIndent: false)
+      {buffer, languageMode} = editor
 
     describe ".toggleLineCommentsForBufferRows(start, end)", ->
       it "comments/uncomments lines in the given range", ->
@@ -156,9 +156,9 @@ describe "LanguageMode", ->
 
   describe "css", ->
     beforeEach ->
-      atom.activatePackage('language-css', sync: true)
-      editSession = project.openSync('css.css', autoIndent: false)
-      {buffer, languageMode} = editSession
+      atom.packages.activatePackage('language-css', sync: true)
+      editor = atom.project.openSync('css.css', autoIndent: false)
+      {buffer, languageMode} = editor
 
     describe ".toggleLineCommentsForBufferRows(start, end)", ->
       it "comments/uncomments lines in the given range", ->
@@ -197,10 +197,10 @@ describe "LanguageMode", ->
 
   describe "less", ->
     beforeEach ->
-      atom.activatePackage('language-less', sync: true)
-      atom.activatePackage('language-css', sync: true)
-      editSession = project.openSync('sample.less', autoIndent: false)
-      {buffer, languageMode} = editSession
+      atom.packages.activatePackage('language-less', sync: true)
+      atom.packages.activatePackage('language-css', sync: true)
+      editor = atom.project.openSync('sample.less', autoIndent: false)
+      {buffer, languageMode} = editor
 
     describe "when commenting lines", ->
       it "only uses the `commentEnd` pattern if it comes from the same grammar as the `commentStart`", ->
@@ -209,68 +209,68 @@ describe "LanguageMode", ->
 
   describe "folding", ->
     beforeEach ->
-      atom.activatePackage('language-javascript', sync: true)
-      editSession = project.openSync('sample.js', autoIndent: false)
-      {buffer, languageMode} = editSession
+      atom.packages.activatePackage('language-javascript', sync: true)
+      editor = atom.project.openSync('sample.js', autoIndent: false)
+      {buffer, languageMode} = editor
 
     it "maintains cursor buffer position when a folding/unfolding", ->
-      editSession.setCursorBufferPosition([5,5])
+      editor.setCursorBufferPosition([5,5])
       languageMode.foldAll()
-      expect(editSession.getCursorBufferPosition()).toEqual([5,5])
+      expect(editor.getCursorBufferPosition()).toEqual([5,5])
 
     describe ".unfoldAll()", ->
       it "unfolds every folded line", ->
-        initialScreenLineCount = editSession.getScreenLineCount()
+        initialScreenLineCount = editor.getScreenLineCount()
         languageMode.foldBufferRow(0)
         languageMode.foldBufferRow(1)
-        expect(editSession.getScreenLineCount()).toBeLessThan initialScreenLineCount
+        expect(editor.getScreenLineCount()).toBeLessThan initialScreenLineCount
         languageMode.unfoldAll()
-        expect(editSession.getScreenLineCount()).toBe initialScreenLineCount
+        expect(editor.getScreenLineCount()).toBe initialScreenLineCount
 
     describe ".foldAll()", ->
       it "folds every foldable line", ->
         languageMode.foldAll()
 
-        fold1 = editSession.lineForScreenRow(0).fold
+        fold1 = editor.lineForScreenRow(0).fold
         expect([fold1.getStartRow(), fold1.getEndRow()]).toEqual [0, 12]
         fold1.destroy()
 
-        fold2 = editSession.lineForScreenRow(1).fold
+        fold2 = editor.lineForScreenRow(1).fold
         expect([fold2.getStartRow(), fold2.getEndRow()]).toEqual [1, 9]
         fold2.destroy()
 
-        fold3 = editSession.lineForScreenRow(4).fold
+        fold3 = editor.lineForScreenRow(4).fold
         expect([fold3.getStartRow(), fold3.getEndRow()]).toEqual [4, 7]
 
     describe ".foldBufferRow(bufferRow)", ->
       describe "when bufferRow can be folded", ->
         it "creates a fold based on the syntactic region starting at the given row", ->
           languageMode.foldBufferRow(1)
-          fold = editSession.lineForScreenRow(1).fold
+          fold = editor.lineForScreenRow(1).fold
           expect(fold.getStartRow()).toBe 1
           expect(fold.getEndRow()).toBe 9
 
       describe "when bufferRow can't be folded", ->
         it "searches upward for the first row that begins a syntatic region containing the given buffer row (and folds it)", ->
           languageMode.foldBufferRow(8)
-          fold = editSession.lineForScreenRow(1).fold
+          fold = editor.lineForScreenRow(1).fold
           expect(fold.getStartRow()).toBe 1
           expect(fold.getEndRow()).toBe 9
 
       describe "when the bufferRow is already folded", ->
         it "searches upward for the first row that begins a syntatic region containing the folded row (and folds it)", ->
           languageMode.foldBufferRow(2)
-          expect(editSession.lineForScreenRow(1).fold).toBeDefined()
-          expect(editSession.lineForScreenRow(0).fold).not.toBeDefined()
+          expect(editor.lineForScreenRow(1).fold).toBeDefined()
+          expect(editor.lineForScreenRow(0).fold).not.toBeDefined()
 
           languageMode.foldBufferRow(1)
-          expect(editSession.lineForScreenRow(0).fold).toBeDefined()
+          expect(editor.lineForScreenRow(0).fold).toBeDefined()
 
       describe "when the bufferRow is in a multi-line comment", ->
         it "searches upward and downward for surrounding comment lines and folds them as a single fold", ->
           buffer.insert([1,0], "  //this is a comment\n  // and\n  //more docs\n\n//second comment")
           languageMode.foldBufferRow(1)
-          fold = editSession.lineForScreenRow(1).fold
+          fold = editor.lineForScreenRow(1).fold
           expect(fold.getStartRow()).toBe 1
           expect(fold.getEndRow()).toBe 3
 
@@ -278,7 +278,7 @@ describe "LanguageMode", ->
         it "searches upward for the first row that begins a syntatic region containing the folded row (and folds it)", ->
           buffer.insert([1,0], "  //this is a single line comment\n")
           languageMode.foldBufferRow(1)
-          fold = editSession.lineForScreenRow(0).fold
+          fold = editor.lineForScreenRow(0).fold
           expect(fold.getStartRow()).toBe 0
           expect(fold.getEndRow()).toBe 13
 
@@ -286,77 +286,77 @@ describe "LanguageMode", ->
       describe "when bufferRow can be unfolded", ->
         it "destroys a fold based on the syntactic region starting at the given row", ->
           languageMode.foldBufferRow(1)
-          expect(editSession.lineForScreenRow(1).fold).toBeDefined()
+          expect(editor.lineForScreenRow(1).fold).toBeDefined()
 
           languageMode.unfoldBufferRow(1)
-          expect(editSession.lineForScreenRow(1).fold).toBeUndefined()
+          expect(editor.lineForScreenRow(1).fold).toBeUndefined()
 
       describe "when bufferRow can't be unfolded", ->
         it "does not throw an error", ->
-          expect(editSession.lineForScreenRow(1).fold).toBeUndefined()
+          expect(editor.lineForScreenRow(1).fold).toBeUndefined()
           languageMode.unfoldBufferRow(1)
-          expect(editSession.lineForScreenRow(1).fold).toBeUndefined()
+          expect(editor.lineForScreenRow(1).fold).toBeUndefined()
 
   describe "folding with comments", ->
     beforeEach ->
-      atom.activatePackage('language-javascript', sync: true)
-      editSession = project.openSync('sample-with-comments.js', autoIndent: false)
-      {buffer, languageMode} = editSession
+      atom.packages.activatePackage('language-javascript', sync: true)
+      editor = atom.project.openSync('sample-with-comments.js', autoIndent: false)
+      {buffer, languageMode} = editor
 
     describe ".unfoldAll()", ->
       it "unfolds every folded line", ->
-        initialScreenLineCount = editSession.getScreenLineCount()
+        initialScreenLineCount = editor.getScreenLineCount()
         languageMode.foldBufferRow(0)
         languageMode.foldBufferRow(5)
-        expect(editSession.getScreenLineCount()).toBeLessThan initialScreenLineCount
+        expect(editor.getScreenLineCount()).toBeLessThan initialScreenLineCount
         languageMode.unfoldAll()
-        expect(editSession.getScreenLineCount()).toBe initialScreenLineCount
+        expect(editor.getScreenLineCount()).toBe initialScreenLineCount
 
     describe ".foldAll()", ->
       it "folds every foldable line", ->
         languageMode.foldAll()
 
-        fold1 = editSession.lineForScreenRow(0).fold
+        fold1 = editor.lineForScreenRow(0).fold
         expect([fold1.getStartRow(), fold1.getEndRow()]).toEqual [0, 19]
         fold1.destroy()
 
-        fold2 = editSession.lineForScreenRow(1).fold
+        fold2 = editor.lineForScreenRow(1).fold
         expect([fold2.getStartRow(), fold2.getEndRow()]).toEqual [1, 4]
 
-        fold3 = editSession.lineForScreenRow(2).fold.destroy()
+        fold3 = editor.lineForScreenRow(2).fold.destroy()
 
-        fold4 = editSession.lineForScreenRow(3).fold
+        fold4 = editor.lineForScreenRow(3).fold
         expect([fold4.getStartRow(), fold4.getEndRow()]).toEqual [6, 8]
 
     describe ".foldAllAtIndentLevel()", ->
       it "folds every foldable range at a given indentLevel", ->
         languageMode.foldAllAtIndentLevel(2)
 
-        fold1 = editSession.lineForScreenRow(6).fold
+        fold1 = editor.lineForScreenRow(6).fold
         expect([fold1.getStartRow(), fold1.getEndRow()]).toEqual [6, 8]
         fold1.destroy()
 
-        fold2 = editSession.lineForScreenRow(11).fold
+        fold2 = editor.lineForScreenRow(11).fold
         expect([fold2.getStartRow(), fold2.getEndRow()]).toEqual [11, 14]
         fold2.destroy()
 
       it "does not fold anything but the indentLevel", ->
         languageMode.foldAllAtIndentLevel(0)
 
-        fold1 = editSession.lineForScreenRow(0).fold
+        fold1 = editor.lineForScreenRow(0).fold
         expect([fold1.getStartRow(), fold1.getEndRow()]).toEqual [0, 19]
         fold1.destroy()
 
-        fold2 = editSession.lineForScreenRow(5).fold
+        fold2 = editor.lineForScreenRow(5).fold
         expect(fold2).toBeFalsy()
 
   describe "css", ->
     beforeEach ->
-      atom.activatePackage('language-source', sync: true)
-      atom.activatePackage('language-css', sync: true)
-      editSession = project.openSync('css.css', autoIndent: true)
+      atom.packages.activatePackage('language-source', sync: true)
+      atom.packages.activatePackage('language-css', sync: true)
+      editor = atom.project.openSync('css.css', autoIndent: true)
 
     describe "suggestedIndentForBufferRow", ->
       it "does not return negative values (regression)", ->
-        editSession.setText('.test {\npadding: 0;\n}')
-        expect(editSession.suggestedIndentForBufferRow(2)).toBe 0
+        editor.setText('.test {\npadding: 0;\n}')
+        expect(editor.suggestedIndentForBufferRow(2)).toBe 0

spec/pane-container-spec.coffee

@@ -9,7 +9,7 @@ describe "PaneContainer", ->
 
   beforeEach ->
     class TestView extends View
-      registerDeserializer(this)
+      atom.deserializers.add(this)
       @deserialize: ({name}) -> new TestView(name)
       @content: -> @div tabindex: -1
       initialize: (@name) -> @text(@name)
@@ -25,7 +25,7 @@ describe "PaneContainer", ->
     pane3 = pane2.splitDown(new TestView('3'))
 
   afterEach ->
-    unregisterDeserializer(TestView)
+    atom.deserializers.remove(TestView)
 
   describe ".focusNextPane()", ->
     it "focuses the pane following the focused pane or the first pane if no pane has focus", ->
@@ -84,7 +84,7 @@ describe "PaneContainer", ->
       expect(panes).toEqual [pane4]
 
       panes = []
-      subscription.cancel()
+      subscription.off()
       pane4.splitDown()
       expect(panes).toEqual []
 
@@ -111,11 +111,11 @@ describe "PaneContainer", ->
 
       describe "when the last-closed pane item is an edit session", ->
         it "reopens the edit session (regression)", ->
-          editSession = project.openSync('sample.js')
-          pane3.showItem(editSession)
-          pane3.destroyItem(editSession)
+          editor = atom.project.openSync('sample.js')
+          pane3.showItem(editor)
+          pane3.destroyItem(editor)
           expect(container.reopenItem()).toBeTruthy()
-          expect(pane3.activeItem.getPath()).toBe editSession.getPath()
+          expect(pane3.activeItem.getPath()).toBe editor.getPath()
           expect(container.reopenItem()).toBeFalsy()
 
     describe "when there is no active pane", ->
@@ -169,28 +169,28 @@ describe "PaneContainer", ->
     it "returns true after modified files are saved", ->
       pane1.itemAtIndex(0).shouldPromptToSave = -> true
       pane2.itemAtIndex(0).shouldPromptToSave = -> true
-      spyOn(atom, "confirmSync").andReturn(0)
+      spyOn(atom, "confirm").andReturn(0)
 
       saved = container.confirmClose()
 
       runs ->
         expect(saved).toBeTruthy()
-        expect(atom.confirmSync).toHaveBeenCalled()
+        expect(atom.confirm).toHaveBeenCalled()
 
     it "returns false if the user cancels saving", ->
       pane1.itemAtIndex(0).shouldPromptToSave = -> true
       pane2.itemAtIndex(0).shouldPromptToSave = -> true
-      spyOn(atom, "confirmSync").andReturn(1)
+      spyOn(atom, "confirm").andReturn(1)
 
       saved = container.confirmClose()
 
       runs ->
         expect(saved).toBeFalsy()
-        expect(atom.confirmSync).toHaveBeenCalled()
+        expect(atom.confirm).toHaveBeenCalled()
 
   describe "serialization", ->
     it "can be serialized and deserialized, and correctly adjusts dimensions of deserialized panes after attach", ->
-      newContainer = deserialize(container.serialize())
+      newContainer = atom.deserializers.deserialize(container.serialize())
       expect(newContainer.find('.row > :contains(1)')).toExist()
       expect(newContainer.find('.row > .column > :contains(2)')).toExist()
       expect(newContainer.find('.row > .column > :contains(3)')).toExist()
@@ -202,7 +202,7 @@ describe "PaneContainer", ->
     xit "removes empty panes on deserialization", ->
       # only deserialize pane 1's view successfully
       TestView.deserialize = ({name}) -> new TestView(name) if name is '1'
-      newContainer = deserialize(container.serialize())
+      newContainer = atom.deserializers.deserialize(container.serialize())
       expect(newContainer.find('.row, .column')).not.toExist()
       expect(newContainer.find('> :contains(1)')).toExist()
 

spec/pane-spec.coffee

@@ -5,7 +5,7 @@ path = require 'path'
 temp = require 'temp'
 
 describe "Pane", ->
-  [container, view1, view2, editSession1, editSession2, pane] = []
+  [container, view1, view2, editor1, editor2, pane] = []
 
   class TestView extends View
     @deserialize: ({id, text}) -> new TestView({id, text})
@@ -16,17 +16,17 @@ describe "Pane", ->
     isEqual: (other) -> @id == other.id and @text == other.text
 
   beforeEach ->
-    registerDeserializer(TestView)
+    atom.deserializers.add(TestView)
     container = new PaneContainer
     view1 = new TestView(id: 'view-1', text: 'View 1')
     view2 = new TestView(id: 'view-2', text: 'View 2')
-    editSession1 = project.openSync('sample.js')
-    editSession2 = project.openSync('sample.txt')
-    pane = new Pane(view1, editSession1, view2, editSession2)
+    editor1 = atom.project.openSync('sample.js')
+    editor2 = atom.project.openSync('sample.txt')
+    pane = new Pane(view1, editor1, view2, editor2)
     container.setRoot(pane)
 
   afterEach ->
-    unregisterDeserializer(TestView)
+    atom.deserializers.remove(TestView)
 
   describe ".initialize(items...)", ->
     it "displays the first item in the pane", ->
@@ -52,9 +52,9 @@ describe "Pane", ->
       expect(itemChangedHandler.argsForCall[0][1]).toBe view2
       itemChangedHandler.reset()
 
-      pane.showItem(editSession1)
+      pane.showItem(editor1)
       expect(itemChangedHandler).toHaveBeenCalled()
-      expect(itemChangedHandler.argsForCall[0][1]).toBe editSession1
+      expect(itemChangedHandler.argsForCall[0][1]).toBe editor1
       itemChangedHandler.reset()
 
     describe "if the pane's active view is focused before calling showItem", ->
@@ -70,12 +70,12 @@ describe "Pane", ->
       view3 = null
       beforeEach ->
         view3 = new TestView(id: 'view-3', text: "View 3")
-        pane.showItem(editSession1)
+        pane.showItem(editor1)
         expect(pane.getActiveItemIndex()).toBe 1
 
       it "adds it to the items list after the active item", ->
         pane.showItem(view3)
-        expect(pane.getItems()).toEqual [view1, editSession1, view3, view2, editSession2]
+        expect(pane.getItems()).toEqual [view1, editor1, view3, view2, editor2]
         expect(pane.activeItem).toBe view3
         expect(pane.getActiveItemIndex()).toBe 2
 
@@ -89,19 +89,19 @@ describe "Pane", ->
     describe "when showing a model item", ->
       describe "when no view has yet been appended for that item", ->
         it "appends and shows a view to display the item based on its `.getViewClass` method", ->
-          pane.showItem(editSession1)
-          editor = pane.activeView
-          expect(editor.css('display')).not.toBe 'none'
-          expect(editor.activeEditSession).toBe editSession1
+          pane.showItem(editor1)
+          editorView = pane.activeView
+          expect(editorView.css('display')).not.toBe 'none'
+          expect(editorView.editor).toBe editor1
 
       describe "when a valid view has already been appended for another item", ->
         it "multiple views are created for multiple items", ->
-          pane.showItem(editSession1)
-          pane.showItem(editSession2)
+          pane.showItem(editor1)
+          pane.showItem(editor2)
           expect(pane.itemViews.find('.editor').length).toBe 2
-          editor = pane.activeView
-          expect(editor.css('display')).not.toBe 'none'
-          expect(editor.activeEditSession).toBe editSession2
+          editorView = pane.activeView
+          expect(editorView.css('display')).not.toBe 'none'
+          expect(editorView.editor).toBe editor2
 
         it "creates a new view with the item", ->
           initialViewCount = pane.itemViews.find('.test-view').length
@@ -141,77 +141,77 @@ describe "Pane", ->
   describe ".destroyItem(item)", ->
     describe "if the item is not modified", ->
       it "removes the item and tries to call destroy on it", ->
-        pane.destroyItem(editSession2)
-        expect(pane.getItems().indexOf(editSession2)).toBe -1
-        expect(editSession2.destroyed).toBeTruthy()
+        pane.destroyItem(editor2)
+        expect(pane.getItems().indexOf(editor2)).toBe -1
+        expect(editor2.destroyed).toBeTruthy()
 
     describe "if the item is modified", ->
       beforeEach ->
-        spyOn(editSession2, 'save')
-        spyOn(editSession2, 'saveAs')
+        spyOn(editor2, 'save')
+        spyOn(editor2, 'saveAs')
 
-        editSession2.insertText('a')
-        expect(editSession2.isModified()).toBeTruthy()
+        editor2.insertText('a')
+        expect(editor2.isModified()).toBeTruthy()
 
       describe "if the [Save] option is selected", ->
         describe "when the item has a uri", ->
           it "saves the item before removing and destroying it", ->
-            spyOn(atom, 'confirmSync').andReturn(0)
-            pane.destroyItem(editSession2)
+            spyOn(atom, 'confirm').andReturn(0)
+            pane.destroyItem(editor2)
 
-            expect(editSession2.save).toHaveBeenCalled()
-            expect(pane.getItems().indexOf(editSession2)).toBe -1
-            expect(editSession2.destroyed).toBeTruthy()
+            expect(editor2.save).toHaveBeenCalled()
+            expect(pane.getItems().indexOf(editor2)).toBe -1
+            expect(editor2.destroyed).toBeTruthy()
 
         describe "when the item has no uri", ->
           it "presents a save-as dialog, then saves the item with the given uri before removing and destroying it", ->
-            editSession2.buffer.setPath(undefined)
+            editor2.buffer.setPath(undefined)
 
             spyOn(atom, 'showSaveDialogSync').andReturn("/selected/path")
-            spyOn(atom, 'confirmSync').andReturn(0)
-            pane.destroyItem(editSession2)
+            spyOn(atom, 'confirm').andReturn(0)
+            pane.destroyItem(editor2)
 
             expect(atom.showSaveDialogSync).toHaveBeenCalled()
 
-            expect(editSession2.saveAs).toHaveBeenCalledWith("/selected/path")
-            expect(pane.getItems().indexOf(editSession2)).toBe -1
-            expect(editSession2.destroyed).toBeTruthy()
+            expect(editor2.saveAs).toHaveBeenCalledWith("/selected/path")
+            expect(pane.getItems().indexOf(editor2)).toBe -1
+            expect(editor2.destroyed).toBeTruthy()
 
       describe "if the [Don't Save] option is selected", ->
         it "removes and destroys the item without saving it", ->
-          spyOn(atom, 'confirmSync').andReturn(2)
-          pane.destroyItem(editSession2)
+          spyOn(atom, 'confirm').andReturn(2)
+          pane.destroyItem(editor2)
 
-          expect(editSession2.save).not.toHaveBeenCalled()
-          expect(pane.getItems().indexOf(editSession2)).toBe -1
-          expect(editSession2.destroyed).toBeTruthy()
+          expect(editor2.save).not.toHaveBeenCalled()
+          expect(pane.getItems().indexOf(editor2)).toBe -1
+          expect(editor2.destroyed).toBeTruthy()
 
       describe "if the [Cancel] option is selected", ->
         it "does not save, remove, or destroy the item", ->
-          spyOn(atom, 'confirmSync').andReturn(1)
-          pane.destroyItem(editSession2)
+          spyOn(atom, 'confirm').andReturn(1)
+          pane.destroyItem(editor2)
 
-          expect(editSession2.save).not.toHaveBeenCalled()
-          expect(pane.getItems().indexOf(editSession2)).not.toBe -1
-          expect(editSession2.destroyed).toBeFalsy()
+          expect(editor2.save).not.toHaveBeenCalled()
+          expect(pane.getItems().indexOf(editor2)).not.toBe -1
+          expect(editor2.destroyed).toBeFalsy()
 
   describe ".removeItem(item)", ->
     it "removes the item from the items list and shows the next item if it was showing", ->
       pane.removeItem(view1)
-      expect(pane.getItems()).toEqual [editSession1, view2, editSession2]
-      expect(pane.activeItem).toBe editSession1
+      expect(pane.getItems()).toEqual [editor1, view2, editor2]
+      expect(pane.activeItem).toBe editor1
 
-      pane.showItem(editSession2)
-      pane.removeItem(editSession2)
-      expect(pane.getItems()).toEqual [editSession1, view2]
-      expect(pane.activeItem).toBe editSession1
+      pane.showItem(editor2)
+      pane.removeItem(editor2)
+      expect(pane.getItems()).toEqual [editor1, view2]
+      expect(pane.activeItem).toBe editor1
 
     it "triggers 'pane:item-removed' with the item and its former index", ->
       itemRemovedHandler = jasmine.createSpy("itemRemovedHandler")
       pane.on 'pane:item-removed', itemRemovedHandler
-      pane.removeItem(editSession1)
+      pane.removeItem(editor1)
       expect(itemRemovedHandler).toHaveBeenCalled()
-      expect(itemRemovedHandler.argsForCall[0][1..2]).toEqual [editSession1, 1]
+      expect(itemRemovedHandler.argsForCall[0][1..2]).toEqual [editor1, 1]
 
     describe "when removing the last item", ->
       it "removes the pane", ->
@@ -236,11 +236,11 @@ describe "Pane", ->
 
     describe "when the item is a model", ->
       it "removes the associated view only when all items that require it have been removed", ->
-        pane.showItem(editSession1)
-        pane.showItem(editSession2)
-        pane.removeItem(editSession2)
+        pane.showItem(editor1)
+        pane.showItem(editor2)
+        pane.removeItem(editor2)
         expect(pane.itemViews.find('.editor')).toExist()
-        pane.removeItem(editSession1)
+        pane.removeItem(editor1)
         expect(pane.itemViews.find('.editor')).not.toExist()
 
   describe ".moveItem(item, index)", ->
@@ -249,21 +249,21 @@ describe "Pane", ->
       pane.on 'pane:item-moved', itemMovedHandler
 
       pane.moveItem(view1, 2)
-      expect(pane.getItems()).toEqual [editSession1, view2, view1, editSession2]
+      expect(pane.getItems()).toEqual [editor1, view2, view1, editor2]
       expect(itemMovedHandler).toHaveBeenCalled()
       expect(itemMovedHandler.argsForCall[0][1..2]).toEqual [view1, 2]
       itemMovedHandler.reset()
 
-      pane.moveItem(editSession1, 3)
-      expect(pane.getItems()).toEqual [view2, view1, editSession2, editSession1]
+      pane.moveItem(editor1, 3)
+      expect(pane.getItems()).toEqual [view2, view1, editor2, editor1]
       expect(itemMovedHandler).toHaveBeenCalled()
-      expect(itemMovedHandler.argsForCall[0][1..2]).toEqual [editSession1, 3]
+      expect(itemMovedHandler.argsForCall[0][1..2]).toEqual [editor1, 3]
       itemMovedHandler.reset()
 
-      pane.moveItem(editSession1, 1)
-      expect(pane.getItems()).toEqual [view2, editSession1, view1, editSession2]
+      pane.moveItem(editor1, 1)
+      expect(pane.getItems()).toEqual [view2, editor1, view1, editor2]
       expect(itemMovedHandler).toHaveBeenCalled()
-      expect(itemMovedHandler.argsForCall[0][1..2]).toEqual [editSession1, 1]
+      expect(itemMovedHandler.argsForCall[0][1..2]).toEqual [editor1, 1]
       itemMovedHandler.reset()
 
   describe ".moveItemToPane(item, pane, index)", ->
@@ -275,21 +275,21 @@ describe "Pane", ->
 
     it "moves the item to the given pane at the given index", ->
       pane.moveItemToPane(view1, pane2, 1)
-      expect(pane.getItems()).toEqual [editSession1, view2, editSession2]
+      expect(pane.getItems()).toEqual [editor1, view2, editor2]
       expect(pane2.getItems()).toEqual [view3, view1]
 
     describe "when it is the last item on the source pane", ->
       it "removes the source pane, but does not destroy the item", ->
         pane.removeItem(view1)
         pane.removeItem(view2)
-        pane.removeItem(editSession2)
+        pane.removeItem(editor2)
 
-        expect(pane.getItems()).toEqual [editSession1]
-        pane.moveItemToPane(editSession1, pane2, 1)
+        expect(pane.getItems()).toEqual [editor1]
+        pane.moveItemToPane(editor1, pane2, 1)
 
         expect(pane.hasParent()).toBeFalsy()
-        expect(pane2.getItems()).toEqual [view3, editSession1]
-        expect(editSession1.destroyed).toBeFalsy()
+        expect(pane2.getItems()).toEqual [view3, editor1]
+        expect(editor1.destroyed).toBeFalsy()
 
     describe "when the item is a jQuery object", ->
       it "preserves data by detaching instead of removing", ->
@@ -303,37 +303,37 @@ describe "Pane", ->
       containerCloseHandler = jasmine.createSpy("containerCloseHandler")
       container.on 'core:close', containerCloseHandler
 
-      pane.showItem(editSession1)
+      pane.showItem(editor1)
       initialItemCount = pane.getItems().length
       pane.trigger 'core:close'
       expect(pane.getItems().length).toBe initialItemCount - 1
-      expect(editSession1.destroyed).toBeTruthy()
+      expect(editor1.destroyed).toBeTruthy()
 
       expect(containerCloseHandler).not.toHaveBeenCalled()
 
   describe "pane:close", ->
     it "destroys all items and removes the pane", ->
-      pane.showItem(editSession1)
+      pane.showItem(editor1)
       pane.trigger 'pane:close'
       expect(pane.hasParent()).toBeFalsy()
-      expect(editSession2.destroyed).toBeTruthy()
-      expect(editSession1.destroyed).toBeTruthy()
+      expect(editor2.destroyed).toBeTruthy()
+      expect(editor1.destroyed).toBeTruthy()
 
   describe "pane:close-other-items", ->
     it "destroys all items except the current", ->
-      pane.showItem(editSession1)
+      pane.showItem(editor1)
       pane.trigger 'pane:close-other-items'
-      expect(editSession2.destroyed).toBeTruthy()
-      expect(pane.getItems()).toEqual [editSession1]
+      expect(editor2.destroyed).toBeTruthy()
+      expect(pane.getItems()).toEqual [editor1]
 
   describe "core:save", ->
     describe "when the current item has a uri", ->
       describe "when the current item has a save method", ->
         it "saves the current item", ->
-          spyOn(editSession2, 'save')
-          pane.showItem(editSession2)
+          spyOn(editor2, 'save')
+          pane.showItem(editor2)
           pane.trigger 'core:save'
-          expect(editSession2.save).toHaveBeenCalled()
+          expect(editor2.save).toHaveBeenCalled()
 
       describe "when the current item has no save method", ->
         it "does nothing", ->
@@ -347,14 +347,14 @@ describe "Pane", ->
 
       describe "when the current item has a saveAs method", ->
         it "opens a save dialog and saves the current item as the selected path", ->
-          spyOn(editSession2, 'saveAs')
-          editSession2.buffer.setPath(undefined)
-          pane.showItem(editSession2)
+          spyOn(editor2, 'saveAs')
+          editor2.buffer.setPath(undefined)
+          pane.showItem(editor2)
 
           pane.trigger 'core:save'
 
           expect(atom.showSaveDialogSync).toHaveBeenCalled()
-          expect(editSession2.saveAs).toHaveBeenCalledWith('/selected/path')
+          expect(editor2.saveAs).toHaveBeenCalledWith('/selected/path')
 
       describe "when the current item has no saveAs method", ->
         it "does nothing", ->
@@ -368,13 +368,13 @@ describe "Pane", ->
 
     describe "when the current item has a saveAs method", ->
       it "opens the save dialog and calls saveAs on the item with the selected path", ->
-        spyOn(editSession2, 'saveAs')
-        pane.showItem(editSession2)
+        spyOn(editor2, 'saveAs')
+        pane.showItem(editor2)
 
         pane.trigger 'core:save-as'
 
-        expect(atom.showSaveDialogSync).toHaveBeenCalledWith(path.dirname(editSession2.getPath()))
-        expect(editSession2.saveAs).toHaveBeenCalledWith('/selected/path')
+        expect(atom.showSaveDialogSync).toHaveBeenCalledWith(path.dirname(editor2.getPath()))
+        expect(editor2.saveAs).toHaveBeenCalledWith('/selected/path')
 
     describe "when the current item does not have a saveAs method", ->
       it "does nothing", ->
@@ -386,11 +386,11 @@ describe "Pane", ->
     it "advances forward/backward through the pane's items, looping around at either end", ->
       expect(pane.activeItem).toBe view1
       pane.trigger 'pane:show-previous-item'
-      expect(pane.activeItem).toBe editSession2
+      expect(pane.activeItem).toBe editor2
       pane.trigger 'pane:show-previous-item'
       expect(pane.activeItem).toBe view2
       pane.trigger 'pane:show-next-item'
-      expect(pane.activeItem).toBe editSession2
+      expect(pane.activeItem).toBe editor2
       pane.trigger 'pane:show-next-item'
       expect(pane.activeItem).toBe view1
 
@@ -424,8 +424,8 @@ describe "Pane", ->
   describe ".remove()", ->
     it "destroys all the pane's items", ->
       pane.remove()
-      expect(editSession1.destroyed).toBeTruthy()
-      expect(editSession2.destroyed).toBeTruthy()
+      expect(editor1.destroyed).toBeTruthy()
+      expect(editor2.destroyed).toBeTruthy()
 
     it "triggers a 'pane:removed' event with the pane", ->
       removedHandler = jasmine.createSpy("removedHandler")
@@ -438,7 +438,7 @@ describe "Pane", ->
       [paneToLeft, paneToRight] = []
 
       beforeEach ->
-        pane.showItem(editSession1)
+        pane.showItem(editor1)
         paneToLeft = pane.splitLeft(pane.copyActiveItem())
         paneToRight = pane.splitRight(pane.copyActiveItem())
         container.attachToDom()
@@ -475,24 +475,24 @@ describe "Pane", ->
     describe "when it is the last pane", ->
       beforeEach ->
         expect(container.getPanes().length).toBe 1
-        window.rootView = focus: jasmine.createSpy("rootView.focus")
+        atom.workspaceView = focus: jasmine.createSpy("workspaceView.focus")
 
       describe "when the removed pane is focused", ->
-        it "calls focus on rootView so we don't lose focus", ->
+        it "calls focus on workspaceView so we don't lose focus", ->
           container.attachToDom()
           pane.focus()
           pane.remove()
-          expect(rootView.focus).toHaveBeenCalled()
+          expect(atom.workspaceView.focus).toHaveBeenCalled()
 
       describe "when the removed pane is not focused", ->
         it "does not call focus on root view", ->
           expect(pane).not.toMatchSelector ':has(:focus)'
           pane.remove()
-          expect(rootView.focus).not.toHaveBeenCalled()
+          expect(atom.workspaceView.focus).not.toHaveBeenCalled()
 
   describe ".getNextPane()", ->
     it "returns the next pane if one exists, wrapping around from the last pane to the first", ->
-      pane.showItem(editSession1)
+      pane.showItem(editor1)
       expect(pane.getNextPane()).toBeUndefined
       pane2 = pane.splitRight(pane.copyActiveItem())
       expect(pane.getNextPane()).toBe pane2
@@ -538,7 +538,7 @@ describe "Pane", ->
     [pane1, view3, view4] = []
     beforeEach ->
       pane1 = pane
-      pane.showItem(editSession1)
+      pane.showItem(editor1)
       view3 = new TestView(id: 'view-3', text: 'View 3')
       view4 = new TestView(id: 'view-4', text: 'View 4')
 
@@ -547,8 +547,8 @@ describe "Pane", ->
         # creates the new pane with a copy of the active item if none are given
         pane2 = pane1.splitRight(pane1.copyActiveItem())
         expect(container.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-        expect(pane2.items).toEqual [editSession1]
-        expect(pane2.activeItem).not.toBe editSession1 # it's a copy
+        expect(pane2.items).toEqual [editor1]
+        expect(pane2.activeItem).not.toBe editor1 # it's a copy
 
         pane3 = pane2.splitRight(view3, view4)
         expect(pane3.getItems()).toEqual [view3, view4]
@@ -571,8 +571,8 @@ describe "Pane", ->
         # creates the new pane with a copy of the active item if none are given
         pane2 = pane.splitLeft(pane1.copyActiveItem())
         expect(container.find('.row .pane').toArray()).toEqual [pane2[0], pane[0]]
-        expect(pane2.items).toEqual [editSession1]
-        expect(pane2.activeItem).not.toBe editSession1 # it's a copy
+        expect(pane2.items).toEqual [editor1]
+        expect(pane2.activeItem).not.toBe editor1 # it's a copy
 
         pane3 = pane2.splitLeft(view3, view4)
         expect(pane3.getItems()).toEqual [view3, view4]
@@ -583,8 +583,8 @@ describe "Pane", ->
         # creates the new pane with a copy of the active item if none are given
         pane2 = pane.splitDown(pane1.copyActiveItem())
         expect(container.find('.column .pane').toArray()).toEqual [pane[0], pane2[0]]
-        expect(pane2.items).toEqual [editSession1]
-        expect(pane2.activeItem).not.toBe editSession1 # it's a copy
+        expect(pane2.items).toEqual [editor1]
+        expect(pane2.activeItem).not.toBe editor1 # it's a copy
 
         pane3 = pane2.splitDown(view3, view4)
         expect(pane3.getItems()).toEqual [view3, view4]
@@ -595,8 +595,8 @@ describe "Pane", ->
         # creates the new pane with a copy of the active item if none are given
         pane2 = pane.splitUp(pane1.copyActiveItem())
         expect(container.find('.column .pane').toArray()).toEqual [pane2[0], pane[0]]
-        expect(pane2.items).toEqual [editSession1]
-        expect(pane2.activeItem).not.toBe editSession1 # it's a copy
+        expect(pane2.items).toEqual [editor1]
+        expect(pane2.activeItem).not.toBe editor1 # it's a copy
 
         pane3 = pane2.splitUp(view3, view4)
         expect(pane3.getItems()).toEqual [view3, view4]
@@ -673,18 +673,18 @@ describe "Pane", ->
 
   describe ".itemForUri(uri)", ->
     it "returns the item for which a call to .getUri() returns the given uri", ->
-      expect(pane.itemForUri(editSession1.getUri())).toBe editSession1
-      expect(pane.itemForUri(editSession2.getUri())).toBe editSession2
+      expect(pane.itemForUri(editor1.getUri())).toBe editor1
+      expect(pane.itemForUri(editor2.getUri())).toBe editor2
 
   describe "serialization", ->
     it "can serialize and deserialize the pane and all its items", ->
-      newPane = deserialize(pane.serialize())
-      expect(newPane.getItems()).toEqual [view1, editSession1, view2, editSession2]
+      newPane = atom.deserializers.deserialize(pane.serialize())
+      expect(newPane.getItems()).toEqual [view1, editor1, view2, editor2]
 
     it "restores the active item on deserialization", ->
-      pane.showItem(editSession2)
-      newPane = deserialize(pane.serialize())
-      expect(newPane.activeItem).toEqual editSession2
+      pane.showItem(editor2)
+      newPane = atom.deserializers.deserialize(pane.serialize())
+      expect(newPane.activeItem).toEqual editor2
 
     it "does not show items that cannot be deserialized", ->
       spyOn(console, 'warn')
@@ -693,18 +693,15 @@ describe "Pane", ->
       paneState = pane.serialize()
       paneState.get('items').set(pane.items.indexOf(view2), {deserializer: 'Bogus'}) # nuke serialized state of active item
 
-      newPane = deserialize(paneState)
+      newPane = atom.deserializers.deserialize(paneState)
       expect(newPane.activeItem).toEqual pane.items[0]
       expect(newPane.items.length).toBe pane.items.length - 1
 
     it "focuses the pane after attach only if had focus when serialized", ->
       reloadContainer = ->
-        projectReplica = atom.replicate().get('project')
         containerState = container.serialize()
         container.remove()
-        project.destroy()
-        window.project = projectReplica
-        container = deserialize(containerState)
+        container = atom.deserializers.deserialize(containerState)
         pane = container.getRoot()
         container.attachToDom()
 

spec/project-spec.coffee

@@ -8,7 +8,7 @@ BufferedProcess = require '../src/buffered-process'
 
 describe "Project", ->
   beforeEach ->
-    project.setPath(project.resolve('dir'))
+    atom.project.setPath(atom.project.resolve('dir'))
 
   describe "serialization", ->
     deserializedProject = null
@@ -17,204 +17,216 @@ describe "Project", ->
       deserializedProject?.destroy()
 
     it "destroys unretained buffers and does not include them in the serialized state", ->
-      project.bufferForPathSync('a')
-      expect(project.getBuffers().length).toBe 1
-      project.getState().serializeForPersistence()
+      atom.project.bufferForPathSync('a')
+      expect(atom.project.getBuffers().length).toBe 1
+
+      atom.project.getState().serializeForPersistence()
       deserializedProject = atom.replicate().get('project')
+
+      expect(deserializedProject.getBuffers().length).toBe 0
+      expect(atom.project.getBuffers().length).toBe 0
+
+    it "listens for destroyed events on deserialized buffers and removes them when they are destroyed", ->
+      atom.project.openSync('a')
+      expect(atom.project.getBuffers().length).toBe 1
+      atom.project.getState().serializeForPersistence()
+      deserializedProject = atom.replicate().get('project')
+
+      expect(deserializedProject.getBuffers().length).toBe 1
+      deserializedProject.getBuffers()[0].destroy()
       expect(deserializedProject.getBuffers().length).toBe 0
-      expect(project.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)", ->
-      editSession = project.openSync("a")
-      anotherEditSession = project.openSync("a")
+      editor = atom.project.openSync("a")
+      anotherEditor = atom.project.openSync("a")
 
-      expect(project.editSessions.length).toBe 2
-      expect(editSession.buffer).toBe anotherEditSession.buffer
+      expect(atom.project.editors.length).toBe 2
+      expect(editor.buffer).toBe anotherEditor.buffer
 
-      editSession.destroy()
-      expect(project.editSessions.length).toBe 1
+      editor.destroy()
+      expect(atom.project.editors.length).toBe 1
 
-      anotherEditSession.destroy()
-      expect(project.editSessions.length).toBe 0
+      anotherEditor.destroy()
+      expect(atom.project.editors.length).toBe 0
 
   describe "when an edit session 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
-      project.setPath(undefined)
-      expect(project.getPath()).toBeUndefined()
-      editSession = project.openSync()
-      editSession.saveAs(tempFile)
-      expect(project.getPath()).toBe path.dirname(tempFile)
+      atom.project.setPath(undefined)
+      expect(atom.project.getPath()).toBeUndefined()
+      editor = atom.project.openSync()
+      editor.saveAs(tempFile)
+      expect(atom.project.getPath()).toBe path.dirname(tempFile)
 
   describe "when an edit session is deserialized", ->
-    it "emits an 'edit-session-created' event and stores the edit session", ->
-      handler = jasmine.createSpy('editSessionCreatedHandler')
-      project.on 'edit-session-created', handler
+    it "emits an 'editor-created' event and stores the edit session", ->
+      handler = jasmine.createSpy('editorCreatedHandler')
+      atom.project.on 'editor-created', handler
 
-      editSession1 = project.openSync("a")
+      editor1 = atom.project.openSync("a")
       expect(handler.callCount).toBe 1
-      expect(project.getEditSessions().length).toBe 1
-      expect(project.getEditSessions()[0]).toBe editSession1
+      expect(atom.project.getEditors().length).toBe 1
+      expect(atom.project.getEditors()[0]).toBe editor1
 
-      editSession2 = deserialize(editSession1.serialize())
+      editor2 = atom.deserializers.deserialize(editor1.serialize())
       expect(handler.callCount).toBe 2
-      expect(project.getEditSessions().length).toBe 2
-      expect(project.getEditSessions()[0]).toBe editSession1
-      expect(project.getEditSessions()[1]).toBe editSession2
+      expect(atom.project.getEditors().length).toBe 2
+      expect(atom.project.getEditors()[0]).toBe editor1
+      expect(atom.project.getEditors()[1]).toBe editor2
 
   describe "when an edit session is copied", ->
-    it "emits an 'edit-session-created' event and stores the edit session", ->
-      handler = jasmine.createSpy('editSessionCreatedHandler')
-      project.on 'edit-session-created', handler
+    it "emits an 'editor-created' event and stores the edit session", ->
+      handler = jasmine.createSpy('editorCreatedHandler')
+      atom.project.on 'editor-created', handler
 
-      editSession1 = project.openSync("a")
+      editor1 = atom.project.openSync("a")
       expect(handler.callCount).toBe 1
-      expect(project.getEditSessions().length).toBe 1
-      expect(project.getEditSessions()[0]).toBe editSession1
+      expect(atom.project.getEditors().length).toBe 1
+      expect(atom.project.getEditors()[0]).toBe editor1
 
-      editSession2 = editSession1.copy()
+      editor2 = editor1.copy()
       expect(handler.callCount).toBe 2
-      expect(project.getEditSessions().length).toBe 2
-      expect(project.getEditSessions()[0]).toBe editSession1
-      expect(project.getEditSessions()[1]).toBe editSession2
+      expect(atom.project.getEditors().length).toBe 2
+      expect(atom.project.getEditors()[0]).toBe editor1
+      expect(atom.project.getEditors()[1]).toBe editor2
 
   describe ".openSync(path)", ->
-    [fooOpener, barOpener, absolutePath, newBufferHandler, newEditSessionHandler] = []
+    [fooOpener, barOpener, absolutePath, newBufferHandler, newEditorHandler] = []
     beforeEach ->
       absolutePath = require.resolve('./fixtures/dir/a')
       newBufferHandler = jasmine.createSpy('newBufferHandler')
-      project.on 'buffer-created', newBufferHandler
-      newEditSessionHandler = jasmine.createSpy('newEditSessionHandler')
-      project.on 'edit-session-created', newEditSessionHandler
+      atom.project.on 'buffer-created', newBufferHandler
+      newEditorHandler = jasmine.createSpy('newEditorHandler')
+      atom.project.on 'editor-created', newEditorHandler
 
       fooOpener = (pathToOpen, options) -> { foo: pathToOpen, options } if pathToOpen?.match(/\.foo/)
       barOpener = (pathToOpen) -> { bar: pathToOpen } if pathToOpen?.match(/^bar:\/\//)
-      project.registerOpener(fooOpener)
-      project.registerOpener(barOpener)
+      atom.project.registerOpener(fooOpener)
+      atom.project.registerOpener(barOpener)
 
     afterEach ->
-      project.unregisterOpener(fooOpener)
-      project.unregisterOpener(barOpener)
+      atom.project.unregisterOpener(fooOpener)
+      atom.project.unregisterOpener(barOpener)
 
     describe "when passed a path that doesn't match a custom opener", ->
       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 'edit-session-created' events", ->
-          editSession = project.openSync(absolutePath)
-          expect(editSession.buffer.getPath()).toBe absolutePath
-          expect(newBufferHandler).toHaveBeenCalledWith editSession.buffer
-          expect(newEditSessionHandler).toHaveBeenCalledWith editSession
+        it "returns a new edit session for the given path and emits 'buffer-created' and 'editor-created' events", ->
+          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 'edit-session-created' events", ->
-          editSession = project.openSync('a')
-          expect(editSession.buffer.getPath()).toBe absolutePath
-          expect(newBufferHandler).toHaveBeenCalledWith editSession.buffer
-          expect(newEditSessionHandler).toHaveBeenCalledWith editSession
+        it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'editor-created' events", ->
+          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 'edit-session-created' event", ->
-          editSession = project.openSync(absolutePath)
+        it "returns a new edit session containing previously opened buffer and emits a 'editor-created' event", ->
+          editor = atom.project.openSync(absolutePath)
           newBufferHandler.reset()
-          expect(project.openSync(absolutePath).buffer).toBe editSession.buffer
-          expect(project.openSync('a').buffer).toBe editSession.buffer
+          expect(atom.project.openSync(absolutePath).buffer).toBe editor.buffer
+          expect(atom.project.openSync('a').buffer).toBe editor.buffer
           expect(newBufferHandler).not.toHaveBeenCalled()
-          expect(newEditSessionHandler).toHaveBeenCalledWith editSession
+          expect(newEditorHandler).toHaveBeenCalledWith editor
 
       describe "when not passed a path", ->
-        it "returns a new edit session and emits 'buffer-created' and 'edit-session-created' events", ->
-          editSession = project.openSync()
-          expect(editSession.buffer.getPath()).toBeUndefined()
-          expect(newBufferHandler).toHaveBeenCalledWith(editSession.buffer)
-          expect(newEditSessionHandler).toHaveBeenCalledWith editSession
+        it "returns a new edit session and emits 'buffer-created' and 'editor-created' events", ->
+          editor = atom.project.openSync()
+          expect(editor.buffer.getPath()).toBeUndefined()
+          expect(newBufferHandler).toHaveBeenCalledWith(editor.buffer)
+          expect(newEditorHandler).toHaveBeenCalledWith editor
 
     describe "when passed a path that matches a custom opener", ->
       it "returns the resource returned by the custom opener", ->
-        pathToOpen = project.resolve('a.foo')
-        expect(project.openSync(pathToOpen, hey: "there")).toEqual { foo: pathToOpen, options: {hey: "there"} }
-        expect(project.openSync("bar://baz")).toEqual { bar: "bar://baz" }
+        pathToOpen = atom.project.resolve('a.foo')
+        expect(atom.project.openSync(pathToOpen, hey: "there")).toEqual { foo: pathToOpen, options: {hey: "there"} }
+        expect(atom.project.openSync("bar://baz")).toEqual { bar: "bar://baz" }
 
   describe ".open(path)", ->
-    [fooOpener, barOpener, absolutePath, newBufferHandler, newEditSessionHandler] = []
+    [fooOpener, barOpener, absolutePath, newBufferHandler, newEditorHandler] = []
 
     beforeEach ->
       absolutePath = require.resolve('./fixtures/dir/a')
       newBufferHandler = jasmine.createSpy('newBufferHandler')
-      project.on 'buffer-created', newBufferHandler
-      newEditSessionHandler = jasmine.createSpy('newEditSessionHandler')
-      project.on 'edit-session-created', newEditSessionHandler
+      atom.project.on 'buffer-created', newBufferHandler
+      newEditorHandler = jasmine.createSpy('newEditorHandler')
+      atom.project.on 'editor-created', newEditorHandler
 
       fooOpener = (pathToOpen, options) -> { foo: pathToOpen, options } if pathToOpen?.match(/\.foo/)
       barOpener = (pathToOpen) -> { bar: pathToOpen } if pathToOpen?.match(/^bar:\/\//)
-      project.registerOpener(fooOpener)
-      project.registerOpener(barOpener)
+      atom.project.registerOpener(fooOpener)
+      atom.project.registerOpener(barOpener)
 
     afterEach ->
-      project.unregisterOpener(fooOpener)
-      project.unregisterOpener(barOpener)
+      atom.project.unregisterOpener(fooOpener)
+      atom.project.unregisterOpener(barOpener)
 
     describe "when passed a path that doesn't match a custom opener", ->
       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 'edit-session-created' events", ->
-          editSession = null
+        it "returns a new edit session for the given path and emits 'buffer-created' and 'editor-created' events", ->
+          editor = null
           waitsForPromise ->
-            project.open(absolutePath).then (o) -> editSession = o
+            atom.project.open(absolutePath).then (o) -> editor = o
 
           runs ->
-            expect(editSession.buffer.getPath()).toBe absolutePath
-            expect(newBufferHandler).toHaveBeenCalledWith editSession.buffer
-            expect(newEditSessionHandler).toHaveBeenCalledWith editSession
+            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 'edit-session-created' events", ->
-          editSession = null
+        it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'editor-created' events", ->
+          editor = null
           waitsForPromise ->
-            project.open(absolutePath).then (o) -> editSession = o
+            atom.project.open(absolutePath).then (o) -> editor = o
 
           runs ->
-            expect(editSession.buffer.getPath()).toBe absolutePath
-            expect(newBufferHandler).toHaveBeenCalledWith editSession.buffer
-            expect(newEditSessionHandler).toHaveBeenCalledWith editSession
+            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 'edit-session-created' event", ->
-          editSession = null
+        it "returns a new edit session containing currently opened buffer and emits a 'editor-created' event", ->
+          editor = null
           waitsForPromise ->
-            project.open(absolutePath).then (o) -> editSession = o
+            atom.project.open(absolutePath).then (o) -> editor = o
 
           runs ->
             newBufferHandler.reset()
-            expect(project.openSync(absolutePath).buffer).toBe editSession.buffer
-            expect(project.openSync('a').buffer).toBe editSession.buffer
+            expect(atom.project.openSync(absolutePath).buffer).toBe editor.buffer
+            expect(atom.project.openSync('a').buffer).toBe editor.buffer
             expect(newBufferHandler).not.toHaveBeenCalled()
-            expect(newEditSessionHandler).toHaveBeenCalledWith editSession
+            expect(newEditorHandler).toHaveBeenCalledWith editor
 
       describe "when not passed a path", ->
-        it "returns a new edit session and emits 'buffer-created' and 'edit-session-created' events", ->
-          editSession = null
+        it "returns a new edit session and emits 'buffer-created' and 'editor-created' events", ->
+          editor = null
           waitsForPromise ->
-            project.open().then (o) -> editSession = o
+            atom.project.open().then (o) -> editor = o
 
           runs ->
-            expect(editSession.buffer.getPath()).toBeUndefined()
-            expect(newBufferHandler).toHaveBeenCalledWith(editSession.buffer)
-            expect(newEditSessionHandler).toHaveBeenCalledWith editSession
+            expect(editor.buffer.getPath()).toBeUndefined()
+            expect(newBufferHandler).toHaveBeenCalledWith(editor.buffer)
+            expect(newEditorHandler).toHaveBeenCalledWith editor
 
     describe "when passed a path that matches a custom opener", ->
       it "returns the resource returned by the custom opener", ->
         waitsForPromise ->
-          pathToOpen = project.resolve('a.foo')
-          project.open(pathToOpen, hey: "there").then (item) ->
+          pathToOpen = atom.project.resolve('a.foo')
+          atom.project.open(pathToOpen, hey: "there").then (item) ->
             expect(item).toEqual { foo: pathToOpen, options: {hey: "there"} }
 
         waitsForPromise ->
-          project.open("bar://baz").then (item) ->
+          atom.project.open("bar://baz").then (item) ->
             expect(item).toEqual { bar: "bar://baz" }
 
     it "returns number of read bytes as progress indicator", ->
-      filePath = project.resolve 'a'
+      filePath = atom.project.resolve 'a'
       totalBytes = 0
-      promise = project.open(filePath)
+      promise = atom.project.open(filePath)
       promise.progress (bytesRead) -> totalBytes = bytesRead
 
       waitsForPromise ->
@@ -226,22 +238,22 @@ describe "Project", ->
   describe ".bufferForPathSync(path)", ->
     describe "when opening a previously opened path", ->
       it "does not create a new buffer", ->
-        buffer = project.bufferForPathSync("a").retain()
-        expect(project.bufferForPathSync("a")).toBe buffer
+        buffer = atom.project.bufferForPathSync("a").retain()
+        expect(atom.project.bufferForPathSync("a")).toBe buffer
 
-        alternativeBuffer = project.bufferForPathSync("b").retain().release()
+        alternativeBuffer = atom.project.bufferForPathSync("b").retain().release()
         expect(alternativeBuffer).not.toBe buffer
         buffer.release()
 
       it "creates a new buffer if the previous buffer was destroyed", ->
-        buffer = project.bufferForPathSync("a").retain().release()
-        expect(project.bufferForPathSync("a").retain().release()).not.toBe buffer
+        buffer = atom.project.bufferForPathSync("a").retain().release()
+        expect(atom.project.bufferForPathSync("a").retain().release()).not.toBe buffer
 
   describe ".bufferForPath(path)", ->
     [buffer] = []
     beforeEach ->
       waitsForPromise ->
-        project.bufferForPath("a").then (o) ->
+        atom.project.bufferForPath("a").then (o) ->
           buffer = o
           buffer.retain()
 
@@ -251,60 +263,60 @@ describe "Project", ->
     describe "when opening a previously opened path", ->
       it "does not create a new buffer", ->
         waitsForPromise ->
-          project.bufferForPath("a").then (anotherBuffer) ->
+          atom.project.bufferForPath("a").then (anotherBuffer) ->
             expect(anotherBuffer).toBe buffer
 
         waitsForPromise ->
-          project.bufferForPath("b").then (anotherBuffer) ->
+          atom.project.bufferForPath("b").then (anotherBuffer) ->
             expect(anotherBuffer).not.toBe buffer
 
       it "creates a new buffer if the previous buffer was destroyed", ->
         buffer.release()
 
         waitsForPromise ->
-          project.bufferForPath("b").then (anotherBuffer) ->
+          atom.project.bufferForPath("b").then (anotherBuffer) ->
             expect(anotherBuffer).not.toBe buffer
 
   describe ".resolve(uri)", ->
     describe "when passed an absolute or relative path", ->
-      it "returns an absolute path based on the project's root", ->
+      it "returns an absolute path based on the atom.project's root", ->
         absolutePath = require.resolve('./fixtures/dir/a')
-        expect(project.resolve('a')).toBe absolutePath
-        expect(project.resolve(absolutePath + '/../a')).toBe absolutePath
-        expect(project.resolve('a/../a')).toBe absolutePath
+        expect(atom.project.resolve('a')).toBe absolutePath
+        expect(atom.project.resolve(absolutePath + '/../a')).toBe absolutePath
+        expect(atom.project.resolve('a/../a')).toBe absolutePath
 
     describe "when passed a uri with a scheme", ->
       it "does not modify uris that begin with a scheme", ->
-        expect(project.resolve('http://zombo.com')).toBe 'http://zombo.com'
+        expect(atom.project.resolve('http://zombo.com')).toBe 'http://zombo.com'
 
   describe ".setPath(path)", ->
     describe "when path is a file", ->
       it "sets its path to the files parent directory and updates the root directory", ->
-        project.setPath(require.resolve('./fixtures/dir/a'))
-        expect(project.getPath()).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
-        expect(project.getRootDirectory().path).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
+        atom.project.setPath(require.resolve('./fixtures/dir/a'))
+        expect(atom.project.getPath()).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
+        expect(atom.project.getRootDirectory().path).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
 
     describe "when path is a directory", ->
       it "sets its path to the directory and updates the root directory", ->
         directory = fs.absolute(path.join(__dirname, 'fixtures', 'dir', 'a-dir'))
-        project.setPath(directory)
-        expect(project.getPath()).toEqual directory
-        expect(project.getRootDirectory().path).toEqual directory
+        atom.project.setPath(directory)
+        expect(atom.project.getPath()).toEqual directory
+        expect(atom.project.getRootDirectory().path).toEqual directory
 
     describe "when path is null", ->
       it "sets its path and root directory to null", ->
-        project.setPath(null)
-        expect(project.getPath()?).toBeFalsy()
-        expect(project.getRootDirectory()?).toBeFalsy()
+        atom.project.setPath(null)
+        expect(atom.project.getPath()?).toBeFalsy()
+        expect(atom.project.getRootDirectory()?).toBeFalsy()
 
   describe ".replace()", ->
     [filePath, commentFilePath, sampleContent, sampleCommentContent] = []
 
     beforeEach ->
-      project.setPath(project.resolve('../'))
+      atom.project.setPath(atom.project.resolve('../'))
 
-      filePath = project.resolve('sample.js')
-      commentFilePath = project.resolve('sample-with-comments.js')
+      filePath = atom.project.resolve('sample.js')
+      commentFilePath = atom.project.resolve('sample-with-comments.js')
       sampleContent = fs.readFileSync(filePath).toString()
       sampleCommentContent = fs.readFileSync(commentFilePath).toString()
 
@@ -316,7 +328,7 @@ describe "Project", ->
       it "replaces properly", ->
         results = []
         waitsForPromise ->
-          project.replace /items/gi, 'items', [filePath], (result) ->
+          atom.project.replace /items/gi, 'items', [filePath], (result) ->
             results.push(result)
 
         runs ->
@@ -326,12 +338,12 @@ describe "Project", ->
 
     describe "when a buffer is already open", ->
       it "replaces properly and saves when not modified", ->
-        editSession = project.openSync('sample.js')
-        expect(editSession.isModified()).toBeFalsy()
+        editor = atom.project.openSync('sample.js')
+        expect(editor.isModified()).toBeFalsy()
 
         results = []
         waitsForPromise ->
-          project.replace /items/gi, 'items', [filePath], (result) ->
+          atom.project.replace /items/gi, 'items', [filePath], (result) ->
             results.push(result)
 
         runs ->
@@ -339,16 +351,29 @@ describe "Project", ->
           expect(results[0].filePath).toBe filePath
           expect(results[0].replacements).toBe 6
 
-          expect(editSession.isModified()).toBeFalsy()
+          expect(editor.isModified()).toBeFalsy()
+
+      it "does not replace when the path is not specified", ->
+        editor = atom.project.openSync('sample.js')
+        editor = atom.project.openSync('sample-with-comments.js')
+
+        results = []
+        waitsForPromise ->
+          atom.project.replace /items/gi, 'items', [commentFilePath], (result) ->
+            results.push(result)
+
+        runs ->
+          expect(results).toHaveLength 1
+          expect(results[0].filePath).toBe commentFilePath
 
       it "does NOT save when modified", ->
-        editSession = project.openSync('sample.js')
-        editSession.buffer.change([[0,0],[0,0]], 'omg')
-        expect(editSession.isModified()).toBeTruthy()
+        editor = atom.project.openSync('sample.js')
+        editor.buffer.change([[0,0],[0,0]], 'omg')
+        expect(editor.isModified()).toBeTruthy()
 
         results = []
         waitsForPromise ->
-          project.replace /items/gi, 'okthen', [filePath], (result) ->
+          atom.project.replace /items/gi, 'okthen', [filePath], (result) ->
             results.push(result)
 
         runs ->
@@ -356,19 +381,19 @@ describe "Project", ->
           expect(results[0].filePath).toBe filePath
           expect(results[0].replacements).toBe 6
 
-          expect(editSession.isModified()).toBeTruthy()
+          expect(editor.isModified()).toBeTruthy()
 
   describe ".scan(options, callback)", ->
     describe "when called with a regex", ->
       it "calls the callback with all regex results in all files in the project", ->
         results = []
         waitsForPromise ->
-          project.scan /(a)+/, (result) ->
+          atom.project.scan /(a)+/, (result) ->
             results.push(result)
 
         runs ->
           expect(results).toHaveLength(3)
-          expect(results[0].filePath).toBe project.resolve('a')
+          expect(results[0].filePath).toBe atom.project.resolve('a')
           expect(results[0].matches).toHaveLength(3)
           expect(results[0].matches[0]).toEqual
             matchText: 'aaa'
@@ -379,13 +404,13 @@ describe "Project", ->
       it "works with with escaped literals (like $ and ^)", ->
         results = []
         waitsForPromise ->
-          project.scan /\$\w+/, (result) -> results.push(result)
+          atom.project.scan /\$\w+/, (result) -> results.push(result)
 
         runs ->
           expect(results.length).toBe 1
 
           {filePath, matches} = results[0]
-          expect(filePath).toBe project.resolve('a')
+          expect(filePath).toBe atom.project.resolve('a')
           expect(matches).toHaveLength 1
           expect(matches[0]).toEqual
             matchText: '$bill'
@@ -394,11 +419,11 @@ describe "Project", ->
             range: [[2, 6], [2, 11]]
 
       it "works on evil filenames", ->
-        project.setPath(path.join(__dirname, 'fixtures', 'evil-files'))
+        atom.project.setPath(path.join(__dirname, 'fixtures', 'evil-files'))
         paths = []
         matches = []
         waitsForPromise ->
-          project.scan /evil/, (result) ->
+          atom.project.scan /evil/, (result) ->
             paths.push(result.filePath)
             matches = matches.concat(result.matches)
 
@@ -421,7 +446,7 @@ describe "Project", ->
       it "ignores case if the regex includes the `i` flag", ->
         results = []
         waitsForPromise ->
-          project.scan /DOLLAR/i, (result) -> results.push(result)
+          atom.project.scan /DOLLAR/i, (result) -> results.push(result)
 
         runs ->
           expect(results).toHaveLength 1
@@ -449,11 +474,11 @@ describe "Project", ->
           fs.removeSync(projectPath) if fs.existsSync(projectPath)
 
         it "excludes ignored files", ->
-          project.setPath(projectPath)
+          atom.project.setPath(projectPath)
           atom.config.set('core.excludeVcsIgnoredPaths', true)
           resultHandler = jasmine.createSpy("result found")
           waitsForPromise ->
-            project.scan /match/, (results) ->
+            atom.project.scan /match/, (results) ->
               resultHandler()
 
           runs ->
@@ -461,14 +486,14 @@ describe "Project", ->
 
       it "includes only files when a directory filter is specified", ->
         projectPath = path.join(path.join(__dirname, 'fixtures', 'dir'))
-        project.setPath(projectPath)
+        atom.project.setPath(projectPath)
 
         filePath = path.join(projectPath, 'a-dir', 'oh-git')
 
         paths = []
         matches = []
         waitsForPromise ->
-          project.scan /aaa/, paths: ["a-dir#{path.sep}"], (result) ->
+          atom.project.scan /aaa/, paths: ["a-dir#{path.sep}"], (result) ->
             paths.push(result.filePath)
             matches = matches.concat(result.matches)
 
@@ -481,11 +506,11 @@ describe "Project", ->
         projectPath = temp.mkdirSync()
         filePath = path.join(projectPath, '.text')
         fs.writeFileSync(filePath, 'match this')
-        project.setPath(projectPath)
+        atom.project.setPath(projectPath)
         paths = []
         matches = []
         waitsForPromise ->
-          project.scan /match this/, (result) ->
+          atom.project.scan /match this/, (result) ->
             paths.push(result.filePath)
             matches = matches.concat(result.matches)
 
@@ -502,21 +527,50 @@ describe "Project", ->
 
         resultHandler = jasmine.createSpy("result found")
         waitsForPromise ->
-          project.scan /dollar/, (results) ->
+          atom.project.scan /dollar/, (results) ->
             resultHandler()
 
         runs ->
           expect(resultHandler).not.toHaveBeenCalled()
 
       it "scans buffer contents if the buffer is modified", ->
-        editSession = project.openSync("a")
-        editSession.setText("Elephant")
+        editor = atom.project.openSync("a")
+        editor.setText("Elephant")
         results = []
         waitsForPromise ->
-          project.scan /a|Elephant/, (result) -> results.push result
+          atom.project.scan /a|Elephant/, (result) -> results.push result
 
         runs ->
           expect(results).toHaveLength 3
           resultForA = _.find results, ({filePath}) -> path.basename(filePath) == 'a'
           expect(resultForA.matches).toHaveLength 1
           expect(resultForA.matches[0].matchText).toBe 'Elephant'
+
+  describe ".eachBuffer(callback)", ->
+    beforeEach ->
+      atom.project.bufferForPathSync('a')
+
+    it "invokes the callback for existing buffer", ->
+      count = 0
+      count = 0
+      callbackBuffer = null
+      callback = (buffer) ->
+        callbackBuffer = buffer
+        count++
+      atom.project.eachBuffer(callback)
+      expect(count).toBe 1
+      expect(callbackBuffer).toBe atom.project.getBuffers()[0]
+
+    it "invokes the callback for new buffers", ->
+      count = 0
+      callbackBuffer = null
+      callback = (buffer) ->
+        callbackBuffer = buffer
+        count++
+
+      atom.project.eachBuffer(callback)
+      count = 0
+      callbackBuffer = null
+      atom.project.bufferForPathSync(require.resolve('./fixtures/sample.txt'))
+      expect(count).toBe 1
+      expect(callbackBuffer).toBe atom.project.getBuffers()[1]

spec/root-view-spec.coffee

@@ -1,557 +0,0 @@
-{$, $$, fs, RootView, View} = require 'atom'
-Q = require 'q'
-path = require 'path'
-temp = require 'temp'
-Pane = require '../src/pane'
-
-describe "RootView", ->
-  pathToOpen = null
-
-  beforeEach ->
-    project.setPath(project.resolve('dir'))
-    pathToOpen = project.resolve('a')
-    window.rootView = new RootView
-    rootView.enableKeymap()
-    rootView.openSync(pathToOpen)
-    rootView.focus()
-
-  describe "@deserialize()", ->
-    viewState = null
-
-    refreshRootViewAndProject = ->
-      rootViewState = rootView.serialize()
-      project.getState().serializeForPersistence()
-      project2 = atom.replicate().get('project')
-      rootView.remove()
-      project.destroy()
-      window.project = project2
-      window.rootView = deserialize(rootViewState)
-      rootView.attachToDom()
-
-    describe "when the serialized RootView has an unsaved buffer", ->
-      it "constructs the view with the same panes", ->
-        rootView.attachToDom()
-        rootView.openSync()
-        editor1 = rootView.getActiveView()
-        buffer = editor1.getBuffer()
-        editor1.splitRight()
-        expect(rootView.getActiveView()).toBe rootView.getEditors()[2]
-
-        refreshRootViewAndProject()
-
-        expect(rootView.getEditors().length).toBe 2
-        expect(rootView.getActiveView()).toBe rootView.getEditors()[1]
-        expect(rootView.title).toBe "untitled - #{project.getPath()}"
-
-    describe "when there are open editors", ->
-      it "constructs the view with the same panes", ->
-        rootView.attachToDom()
-        pane1 = rootView.getActivePane()
-        pane2 = pane1.splitRight()
-        pane3 = pane2.splitRight()
-        pane4 = pane2.splitDown()
-        pane2.showItem(project.openSync('b'))
-        pane3.showItem(project.openSync('../sample.js'))
-        pane3.activeItem.setCursorScreenPosition([2, 4])
-        pane4.showItem(project.openSync('../sample.txt'))
-        pane4.activeItem.setCursorScreenPosition([0, 2])
-        pane2.focus()
-
-        refreshRootViewAndProject()
-
-        expect(rootView.getEditors().length).toBe 4
-        editor1 = rootView.panes.find('.row > .pane .editor:eq(0)').view()
-        editor3 = rootView.panes.find('.row > .pane .editor:eq(1)').view()
-        editor2 = rootView.panes.find('.row > .column > .pane .editor:eq(0)').view()
-        editor4 = rootView.panes.find('.row > .column > .pane .editor:eq(1)').view()
-
-        expect(editor1.getPath()).toBe project.resolve('a')
-        expect(editor2.getPath()).toBe project.resolve('b')
-        expect(editor3.getPath()).toBe project.resolve('../sample.js')
-        expect(editor3.getCursorScreenPosition()).toEqual [2, 4]
-        expect(editor4.getPath()).toBe project.resolve('../sample.txt')
-        expect(editor4.getCursorScreenPosition()).toEqual [0, 2]
-
-        # ensure adjust pane dimensions is called
-        expect(editor1.width()).toBeGreaterThan 0
-        expect(editor2.width()).toBeGreaterThan 0
-        expect(editor3.width()).toBeGreaterThan 0
-        expect(editor4.width()).toBeGreaterThan 0
-
-        # ensure correct editor is focused again
-        expect(editor2.isFocused).toBeTruthy()
-        expect(editor1.isFocused).toBeFalsy()
-        expect(editor3.isFocused).toBeFalsy()
-        expect(editor4.isFocused).toBeFalsy()
-
-        expect(rootView.title).toBe "#{path.basename(editor2.getPath())} - #{project.getPath()}"
-
-    describe "where there are no open editors", ->
-      it "constructs the view with no open editors", ->
-        rootView.getActivePane().remove()
-        expect(rootView.getEditors().length).toBe 0
-        refreshRootViewAndProject()
-        expect(rootView.getEditors().length).toBe 0
-
-  describe "focus", ->
-    beforeEach ->
-      rootView.attachToDom()
-
-    describe "when there is an active view", ->
-      it "hands off focus to the active view", ->
-        editor = rootView.getActiveView()
-        editor.isFocused = false
-        rootView.focus()
-        expect(editor.isFocused).toBeTruthy()
-
-    describe "when there is no active view", ->
-      beforeEach ->
-        rootView.getActivePane().remove()
-        expect(rootView.getActiveView()).toBeUndefined()
-        rootView.attachToDom()
-        expect(document.activeElement).toBe document.body
-
-      describe "when are visible focusable elements (with a -1 tabindex)", ->
-        it "passes focus to the first focusable element", ->
-          focusable1 = $$ -> @div "One", id: 'one', tabindex: -1
-          focusable2 = $$ -> @div "Two", id: 'two', tabindex: -1
-          rootView.horizontal.append(focusable1, focusable2)
-          expect(document.activeElement).toBe document.body
-
-          rootView.focus()
-          expect(document.activeElement).toBe focusable1[0]
-
-      describe "when there are no visible focusable elements", ->
-        it "surrenders focus to the body", ->
-          focusable = $$ -> @div "One", id: 'one', tabindex: -1
-          rootView.horizontal.append(focusable)
-          focusable.hide()
-          expect(document.activeElement).toBe document.body
-
-          rootView.focus()
-          expect(document.activeElement).toBe document.body
-
-  describe "keymap wiring", ->
-    commandHandler = null
-    beforeEach ->
-      commandHandler = jasmine.createSpy('commandHandler')
-      rootView.on('foo-command', commandHandler)
-
-      atom.keymap.bindKeys('name', '*', 'x': 'foo-command')
-
-    describe "when a keydown event is triggered in the RootView", ->
-      it "triggers matching keybindings for that event", ->
-        event = keydownEvent 'x', target: rootView[0]
-
-        rootView.trigger(event)
-        expect(commandHandler).toHaveBeenCalled()
-
-  describe "window title", ->
-    describe "when the project has no path", ->
-      it "sets the title to 'untitled'", ->
-        project.setPath(undefined)
-        expect(rootView.title).toBe 'untitled'
-
-    describe "when the project has a path", ->
-      beforeEach ->
-        rootView.openSync('b')
-
-      describe "when there is an active pane item", ->
-        it "sets the title to the pane item's title plus the project path", ->
-          item = rootView.getActivePaneItem()
-          expect(rootView.title).toBe "#{item.getTitle()} - #{project.getPath()}"
-
-      describe "when the title of the active pane item changes", ->
-        it "updates the window title based on the item's new title", ->
-          editSession = rootView.getActivePaneItem()
-          editSession.buffer.setPath(path.join(temp.dir, 'hi'))
-          expect(rootView.title).toBe "#{editSession.getTitle()} - #{project.getPath()}"
-
-      describe "when the active pane's item changes", ->
-        it "updates the title to the new item's title plus the project path", ->
-          rootView.getActivePane().showNextItem()
-          item = rootView.getActivePaneItem()
-          expect(rootView.title).toBe "#{item.getTitle()} - #{project.getPath()}"
-
-      describe "when the last pane item is removed", ->
-        it "updates the title to contain the project's path", ->
-          rootView.getActivePane().remove()
-          expect(rootView.getActivePaneItem()).toBeUndefined()
-          expect(rootView.title).toBe project.getPath()
-
-      describe "when an inactive pane's item changes", ->
-        it "does not update the title", ->
-          pane = rootView.getActivePane()
-          pane.splitRight()
-          initialTitle = rootView.title
-          pane.showNextItem()
-          expect(rootView.title).toBe initialTitle
-
-    describe "when the root view is deserialized", ->
-      it "updates the title to contain the project's path", ->
-        rootView2 = atom.deserializers.deserialize(rootView.serialize())
-        item = rootView.getActivePaneItem()
-        expect(rootView2.title).toBe "#{item.getTitle()} - #{project.getPath()}"
-        rootView2.remove()
-
-  describe "font size adjustment", ->
-    it "increases/decreases font size when increase/decrease-font-size events are triggered", ->
-      fontSizeBefore = atom.config.get('editor.fontSize')
-      rootView.trigger 'window:increase-font-size'
-      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore + 1
-      rootView.trigger 'window:increase-font-size'
-      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore + 2
-      rootView.trigger 'window:decrease-font-size'
-      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore + 1
-      rootView.trigger 'window:decrease-font-size'
-      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore
-
-    it "does not allow the font size to be less than 1", ->
-      atom.config.set("editor.fontSize", 1)
-      rootView.trigger 'window:decrease-font-size'
-      expect(atom.config.get('editor.fontSize')).toBe 1
-
-  describe ".openSync(filePath, options)", ->
-    describe "when there is no active pane", ->
-      beforeEach ->
-        spyOn(Pane.prototype, 'focus')
-        rootView.getActivePane().remove()
-        expect(rootView.getActivePane()).toBeUndefined()
-
-      describe "when called with no path", ->
-        it "creates a empty edit session as an item on a new pane, and focuses the pane", ->
-          editSession = rootView.openSync()
-          expect(rootView.getActivePane().activeItem).toBe editSession
-          expect(editSession.getPath()).toBeUndefined()
-          expect(rootView.getActivePane().focus).toHaveBeenCalled()
-
-        it "can create multiple empty edit sessions as an item on a new pane", ->
-          editSession = rootView.openSync()
-          editSession2 = rootView.openSync()
-          expect(rootView.getActivePane().getItems().length).toBe 2
-          expect(editSession).not.toBe editSession2
-
-      describe "when called with a path", ->
-        it "creates an edit session for the given path as an item on a new pane, and focuses the pane", ->
-          editSession = rootView.openSync('b')
-          expect(rootView.getActivePane().activeItem).toBe editSession
-          expect(editSession.getPath()).toBe require.resolve('./fixtures/dir/b')
-          expect(rootView.getActivePane().focus).toHaveBeenCalled()
-
-      describe "when the changeFocus option is false", ->
-        it "does not focus the new pane", ->
-          editSession = rootView.openSync('b', changeFocus: false)
-          expect(rootView.getActivePane().focus).not.toHaveBeenCalled()
-
-      describe "when the split option is 'right'", ->
-        it "creates a new pane and opens the file in said pane", ->
-          editSession = rootView.openSync('b', split: 'right')
-          expect(rootView.getActivePane().activeItem).toBe editSession
-          expect(editSession.getPath()).toBe require.resolve('./fixtures/dir/b')
-
-    describe "when there is an active pane", ->
-      [activePane, initialItemCount] = []
-      beforeEach ->
-        activePane = rootView.getActivePane()
-        spyOn(activePane, 'focus')
-        initialItemCount = activePane.getItems().length
-
-      describe "when called with no path", ->
-        it "opens an edit session with an empty buffer as an item in the active pane and focuses it", ->
-          editSession = rootView.openSync()
-          expect(activePane.getItems().length).toBe initialItemCount + 1
-          expect(activePane.activeItem).toBe editSession
-          expect(editSession.getPath()).toBeUndefined()
-          expect(activePane.focus).toHaveBeenCalled()
-
-      describe "when called with a path", ->
-        describe "when the active pane already has an edit session item for the path being opened", ->
-          it "shows the existing edit session in the pane", ->
-            previousEditSession = activePane.activeItem
-
-            editSession = rootView.openSync('b')
-            expect(activePane.activeItem).toBe editSession
-            expect(editSession).not.toBe previousEditSession
-
-            editSession = rootView.openSync(previousEditSession.getPath())
-            expect(editSession).toBe previousEditSession
-            expect(activePane.activeItem).toBe editSession
-
-            expect(activePane.focus).toHaveBeenCalled()
-
-        describe "when the active pane does not have an edit session item for the path being opened", ->
-          it "creates a new edit session for the given path in the active editor", ->
-            editSession = rootView.openSync('b')
-            expect(activePane.items.length).toBe 2
-            expect(activePane.activeItem).toBe editSession
-            expect(activePane.focus).toHaveBeenCalled()
-
-      describe "when the changeFocus option is false", ->
-        it "does not focus the active pane", ->
-          editSession = rootView.openSync('b', changeFocus: false)
-          expect(activePane.focus).not.toHaveBeenCalled()
-
-      describe "when the split option is 'right'", ->
-        it "creates a new pane and opens the file in said pane", ->
-          pane1 = rootView.getActivePane()
-
-          editSession = rootView.openSync('b', split: 'right')
-          pane2 = rootView.getActivePane()
-          expect(pane2[0]).not.toBe pane1[0]
-          expect(editSession.getPath()).toBe require.resolve('./fixtures/dir/b')
-
-          expect(rootView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-          editSession = rootView.openSync('file1', split: 'right')
-          pane3 = rootView.getActivePane()
-          expect(pane3[0]).toBe pane2[0]
-          expect(editSession.getPath()).toBe require.resolve('./fixtures/dir/file1')
-
-          expect(rootView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-  describe ".openSingletonSync(filePath, options)", ->
-    describe "when there is an active pane", ->
-      [pane1] = []
-      beforeEach ->
-        spyOn(Pane.prototype, 'focus').andCallFake -> @makeActive()
-        pane1 = rootView.getActivePane()
-
-      it "creates a new pane and reuses the file when already open", ->
-        rootView.openSingletonSync('b', split: 'right')
-        pane2 = rootView.getActivePane()
-        expect(pane2[0]).not.toBe pane1[0]
-        expect(pane1.itemForUri('b')).toBeFalsy()
-        expect(pane2.itemForUri('b')).not.toBeFalsy()
-        expect(rootView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-        pane1.focus()
-        expect(rootView.getActivePane()[0]).toBe pane1[0]
-
-        rootView.openSingletonSync('b', split: 'right')
-        pane3 = rootView.getActivePane()
-        expect(pane3[0]).toBe pane2[0]
-        expect(pane1.itemForUri('b')).toBeFalsy()
-        expect(pane2.itemForUri('b')).not.toBeFalsy()
-        expect(rootView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-      it "handles split: left by opening to the left pane when necessary", ->
-        rootView.openSingletonSync('b', split: 'right')
-        pane2 = rootView.getActivePane()
-        expect(pane2[0]).not.toBe pane1[0]
-
-        rootView.openSingletonSync('file1', split: 'left')
-
-        activePane = rootView.getActivePane()
-        expect(activePane[0]).toBe pane1[0]
-
-        expect(pane1.itemForUri('file1')).toBeTruthy()
-        expect(pane2.itemForUri('file1')).toBeFalsy()
-        expect(rootView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-        pane2.focus()
-        expect(rootView.getActivePane()[0]).toBe pane2[0]
-
-        rootView.openSingletonSync('file1', split: 'left')
-        activePane = rootView.getActivePane()
-        expect(activePane[0]).toBe pane1[0]
-        expect(rootView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-      it "reuses the file when already open", ->
-        rootView.openSync('b')
-        rootView.openSingletonSync('b', split: 'right')
-        expect(rootView.panes.find('.pane').toArray()).toEqual [pane1[0]]
-
-  describe ".open(filePath)", ->
-    beforeEach ->
-      spyOn(Pane.prototype, 'focus')
-
-    describe "when there is no active pane", ->
-      beforeEach ->
-        rootView.getActivePane().remove()
-        expect(rootView.getActivePane()).toBeUndefined()
-
-      describe "when called with no path", ->
-        it "creates a empty edit session as an item on a new pane, and focuses the pane", ->
-          editSession = null
-
-          waitsForPromise ->
-            rootView.open().then (o) -> editSession = o
-
-          runs ->
-            expect(rootView.getActivePane().activeItem).toBe editSession
-            expect(editSession.getPath()).toBeUndefined()
-            expect(rootView.getActivePane().focus).toHaveBeenCalled()
-
-        it "can create multiple empty edit sessions as items on a pane", ->
-          editSession1 = null
-          editSession2 = null
-
-          waitsForPromise ->
-            rootView.open()
-              .then (o) ->
-                editSession1 = o
-                rootView.open()
-              .then (o) ->
-                editSession2 = o
-
-          runs ->
-            expect(rootView.getActivePane().getItems().length).toBe 2
-            expect(editSession1).not.toBe editSession2
-
-      describe "when called with a path", ->
-        it "creates an edit session for the given path as an item on a new pane, and focuses the pane", ->
-          editSession = null
-          waitsForPromise ->
-            rootView.open('b').then (o) -> editSession = o
-
-          runs ->
-            expect(rootView.getActivePane().activeItem).toBe editSession
-            expect(editSession.getPath()).toBe require.resolve('./fixtures/dir/b')
-            expect(rootView.getActivePane().focus).toHaveBeenCalled()
-
-    describe "when there is an active pane", ->
-      [activePane] = []
-
-      beforeEach ->
-        activePane = rootView.getActivePane()
-
-      describe "when called with no path", ->
-        it "opens an edit session with an empty buffer as an item in the active pane and focuses it", ->
-          editSession = null
-
-          waitsForPromise ->
-            rootView.open().then (o) -> editSession = o
-
-          runs ->
-            expect(activePane.getItems().length).toBe 2
-            expect(activePane.activeItem).toBe editSession
-            expect(editSession.getPath()).toBeUndefined()
-            expect(activePane.focus).toHaveBeenCalled()
-
-      describe "when called with a path", ->
-        describe "when the active pane already has an item for the given path", ->
-          it "shows the existing edit session in the pane", ->
-            previousEditSession = activePane.activeItem
-
-            editSession = null
-            waitsForPromise ->
-              rootView.open('b').then (o) -> editSession = o
-
-            runs ->
-              expect(activePane.activeItem).toBe editSession
-              expect(editSession).not.toBe previousEditSession
-
-            waitsForPromise ->
-              rootView.open(previousEditSession.getPath()).then (o) -> editSession = o
-
-            runs ->
-              expect(editSession).toBe previousEditSession
-              expect(activePane.activeItem).toBe editSession
-              expect(activePane.focus).toHaveBeenCalled()
-
-        describe "when the active pane does not have an existing item for the given path", ->
-          it "creates a new edit session for the given path in the active pane", ->
-            editSession = null
-
-            waitsForPromise ->
-              rootView.open('b').then (o) -> editSession = o
-
-            runs ->
-              expect(activePane.activeItem).toBe editSession
-              expect(activePane.getItems().length).toBe 2
-              expect(activePane.focus).toHaveBeenCalled()
-
-  describe "window:toggle-invisibles event", ->
-    it "shows/hides invisibles in all open and future editors", ->
-      rootView.height(200)
-      rootView.attachToDom()
-      rightEditor = rootView.getActiveView()
-      rightEditor.setText(" \t ")
-      leftEditor = rightEditor.splitLeft()
-      expect(rightEditor.find(".line:first").text()).toBe "    "
-      expect(leftEditor.find(".line:first").text()).toBe "    "
-
-      withInvisiblesShowing = "#{rightEditor.invisibles.space}#{rightEditor.invisibles.tab} #{rightEditor.invisibles.space}#{rightEditor.invisibles.eol}"
-
-      rootView.trigger "window:toggle-invisibles"
-      expect(rightEditor.find(".line:first").text()).toBe withInvisiblesShowing
-      expect(leftEditor.find(".line:first").text()).toBe withInvisiblesShowing
-
-      lowerLeftEditor = leftEditor.splitDown()
-      expect(lowerLeftEditor.find(".line:first").text()).toBe withInvisiblesShowing
-
-      rootView.trigger "window:toggle-invisibles"
-      expect(rightEditor.find(".line:first").text()).toBe "    "
-      expect(leftEditor.find(".line:first").text()).toBe "    "
-
-      lowerRightEditor = rightEditor.splitDown()
-      expect(lowerRightEditor.find(".line:first").text()).toBe "    "
-
-  describe ".eachEditor(callback)", ->
-    beforeEach ->
-      rootView.attachToDom()
-
-    it "invokes the callback for existing editor", ->
-      count = 0
-      callbackEditor = null
-      callback = (editor) ->
-        callbackEditor = editor
-        count++
-      rootView.eachEditor(callback)
-      expect(count).toBe 1
-      expect(callbackEditor).toBe rootView.getActiveView()
-
-    it "invokes the callback for new editor", ->
-      count = 0
-      callbackEditor = null
-      callback = (editor) ->
-        callbackEditor = editor
-        count++
-
-      rootView.eachEditor(callback)
-      count = 0
-      callbackEditor = null
-      rootView.getActiveView().splitRight()
-      expect(count).toBe 1
-      expect(callbackEditor).toBe rootView.getActiveView()
-
-    it "returns a subscription that can be disabled", ->
-      count = 0
-      callback = (editor) -> count++
-
-      subscription = rootView.eachEditor(callback)
-      expect(count).toBe 1
-      rootView.getActiveView().splitRight()
-      expect(count).toBe 2
-      subscription.off()
-      rootView.getActiveView().splitRight()
-      expect(count).toBe 2
-
-  describe ".eachBuffer(callback)", ->
-    beforeEach ->
-      rootView.attachToDom()
-
-    it "invokes the callback for existing buffer", ->
-      count = 0
-      count = 0
-      callbackBuffer = null
-      callback = (buffer) ->
-        callbackBuffer = buffer
-        count++
-      rootView.eachBuffer(callback)
-      expect(count).toBe 1
-      expect(callbackBuffer).toBe rootView.getActiveView().getBuffer()
-
-    it "invokes the callback for new buffer", ->
-      count = 0
-      callbackBuffer = null
-      callback = (buffer) ->
-        callbackBuffer = buffer
-        count++
-
-      rootView.eachBuffer(callback)
-      count = 0
-      callbackBuffer = null
-      rootView.openSync(require.resolve('./fixtures/sample.txt'))
-      expect(count).toBe 1
-      expect(callbackBuffer).toBe rootView.getActiveView().getBuffer()

spec/selection-spec.coffee

@@ -1,12 +1,12 @@
-EditSession = require '../src/edit-session'
+Editor = require '../src/editor'
 
 describe "Selection", ->
-  [buffer, editSession, selection] = []
+  [buffer, editor, selection] = []
 
   beforeEach ->
-    buffer = project.bufferForPathSync('sample.js')
-    editSession = new EditSession(buffer: buffer, tabLength: 2)
-    selection = editSession.getSelection()
+    buffer = atom.project.bufferForPathSync('sample.js')
+    editor = new Editor(buffer: buffer, tabLength: 2)
+    selection = editor.getSelection()
 
   afterEach ->
     buffer.destroy()

spec/space-pen-extensions-spec.coffee

@@ -1,4 +1,4 @@
-{View, $$} = require 'atom'
+{View, $, $$} = require 'atom'
 
 describe "SpacePen extensions", ->
   class TestView extends View
@@ -51,3 +51,17 @@ describe "SpacePen extensions", ->
     it "subscribes to the given event emitter and unsubscribes when unsubscribe is called", ->
       emitter.trigger "foo"
       expect(eventHandler).toHaveBeenCalled()
+
+  describe "tooltips", ->
+    describe "replaceModifiers", ->
+      replaceModifiers = $.fn.setTooltip.replaceModifiers
+
+      it "replaces single keystroke", ->
+        expect(replaceModifiers('cmd-O')).toEqual '⌘⇧O'
+        expect(replaceModifiers('cmd-shift-up')).toEqual '⌘⇧↑'
+        expect(replaceModifiers('cmd-option-down')).toEqual '⌘⌥↓'
+        expect(replaceModifiers('cmd-option-left')).toEqual '⌘⌥←'
+        expect(replaceModifiers('cmd-option-right')).toEqual '⌘⌥→'
+
+      it "replaces multiple keystroke", ->
+        expect(replaceModifiers('cmd-o ctrl-2')).toEqual '⌘O ⌃2'

spec/spec-bootstrap.coffee

@@ -1,3 +1,6 @@
+# Start the crash reporter before anything else.
+require('crash-reporter').start(productName: 'Atom', companyName: 'GitHub')
+
 try
   require '../src/window'
   Atom = require '../src/atom'

spec/spec-helper.coffee

@@ -1,15 +1,15 @@
 require '../src/window'
-window.setUpEnvironment('spec')
+atom.setUpEnvironment('spec')
 atom.restoreDimensions()
 
 require '../vendor/jasmine-jquery'
 path = require 'path'
-{_, $, File, RootView, fs} = require 'atom'
+{_, $, File, WorkspaceView, fs} = require 'atom'
 Keymap = require '../src/keymap'
 Config = require '../src/config'
 {Point} = require 'telepath'
 Project = require '../src/project'
-Editor = require '../src/editor'
+EditorView = require '../src/editor-view'
 TokenizedBuffer = require '../src/tokenized-buffer'
 pathwatcher = require 'pathwatcher'
 platform = require './spec-helper-platform'
@@ -39,7 +39,9 @@ specPackageName = null
 specPackagePath = null
 specProjectPath = null
 
-if specDirectory = atom.getLoadSettings().specDirectory
+{specDirectory, resourcePath} = atom.getLoadSettings()
+
+if specDirectory
   specPackagePath = path.resolve(specDirectory, '..')
   try
     specPackageName = fs.readObjectSync(path.join(specPackagePath, 'package.json'))?.name
@@ -49,12 +51,14 @@ beforeEach ->
   $.fx.off = true
   projectPath = specProjectPath ? path.join(@specDirectory, 'fixtures')
   atom.project = atom.getWindowState().set('project', new Project(path: projectPath))
-  window.project = atom.project
   atom.keymap.keyBindings = _.clone(keyBindingsToRestore)
 
   window.resetTimeouts()
   atom.packages.packageStates = {}
-  spyOn(atom, 'saveWindowState')
+
+  serializedWindowState = null
+  spyOn(atom, 'saveWindowState').andCallFake -> serializedWindowState = @getWindowState().serialize()
+  spyOn(atom, 'loadSerializedWindowState').andCallFake -> serializedWindowState
   atom.syntax.clearGrammarOverrides()
   atom.syntax.clearProperties()
 
@@ -69,13 +73,11 @@ beforeEach ->
   spyOn(atom.menu, 'sendToBrowserProcess')
 
   # reset config before each spec; don't load or save from/to `config.json`
-  config = new Config
-    resourcePath: window.resourcePath
-    configDirPath: atom.getConfigDirPath()
+  config = new Config({resourcePath, configDirPath: atom.getConfigDirPath()})
   spyOn(config, 'load')
   spyOn(config, 'save')
-  config.setDefaults('core', RootView.configDefaults)
-  config.setDefaults('editor', Editor.configDefaults)
+  config.setDefaults('core', WorkspaceView.configDefaults)
+  config.setDefaults('editor', EditorView.configDefaults)
   config.set "editor.fontFamily", "Courier"
   config.set "editor.fontSize", 16
   config.set "editor.autoIndent", false
@@ -83,11 +85,10 @@ beforeEach ->
     "package-with-broken-package-json", "package-with-broken-keymap"]
   config.save.reset()
   atom.config = config
-  window.config = config
 
   # make editor display updates synchronous
-  spyOn(Editor.prototype, 'requestDisplayUpdate').andCallFake -> @updateDisplay()
-  spyOn(RootView.prototype, 'setTitle').andCallFake (@title) ->
+  spyOn(EditorView.prototype, 'requestDisplayUpdate').andCallFake -> @updateDisplay()
+  spyOn(WorkspaceView.prototype, 'setTitle').andCallFake (@title) ->
   spyOn(window, "setTimeout").andCallFake window.fakeSetTimeout
   spyOn(window, "clearTimeout").andCallFake window.fakeClearTimeout
   spyOn(File.prototype, "detectResurrectionAfterDelay").andCallFake -> @detectResurrection()
@@ -103,17 +104,13 @@ beforeEach ->
   addCustomMatchers(this)
 
 afterEach ->
-  atom.deactivatePackages()
+  atom.packages.deactivatePackages()
   atom.menu.template = []
 
-  window.rootView?.remove?()
-  atom.rootView?.remove?() if atom.rootView isnt window.rootView
-  window.rootView = null
-  atom.rootView = null
+  atom.workspaceView?.remove?()
+  atom.workspaceView = null
 
-  window.project?.destroy?()
-  atom.project?.destroy?() if atom.project isnt window.project
-  window.project = null
+  atom.project?.destroy?()
   atom.project = null
 
   $('#jasmine-content').empty() unless window.debugContent
@@ -174,8 +171,8 @@ window.keydownEvent = (key, properties={}) ->
 
 window.mouseEvent = (type, properties) ->
   if properties.point
-    {point, editor} = properties
-    {top, left} = @pagePixelPositionForPoint(editor, point)
+    {point, editorView} = properties
+    {top, left} = @pagePixelPositionForPoint(editorView, point)
     properties.pageX = left + 1
     properties.pageY = top + 1
   properties.originalEvent ?= {detail: 1}
@@ -236,22 +233,22 @@ window.advanceClock = (delta=1) ->
 
   callback() for callback in callbacks
 
-window.pagePixelPositionForPoint = (editor, point) ->
+window.pagePixelPositionForPoint = (editorView, point) ->
   point = Point.fromObject point
-  top = editor.renderedLines.offset().top + point.row * editor.lineHeight
-  left = editor.renderedLines.offset().left + point.column * editor.charWidth - editor.renderedLines.scrollLeft()
+  top = editorView.renderedLines.offset().top + point.row * editorView.lineHeight
+  left = editorView.renderedLines.offset().left + point.column * editorView.charWidth - editorView.renderedLines.scrollLeft()
   { top, left }
 
 window.tokensText = (tokens) ->
   _.pluck(tokens, 'value').join('')
 
-window.setEditorWidthInChars = (editor, widthInChars, charWidth=editor.charWidth) ->
-  editor.width(charWidth * widthInChars + editor.gutter.outerWidth())
-  $(window).trigger 'resize' # update width of editor's on-screen lines
+window.setEditorWidthInChars = (editorView, widthInChars, charWidth=editorView.charWidth) ->
+  editorView.width(charWidth * widthInChars + editorView.gutter.outerWidth())
+  $(window).trigger 'resize' # update width of editor view's on-screen lines
 
-window.setEditorHeightInLines = (editor, heightInChars, charHeight=editor.lineHeight) ->
-  editor.height(charHeight * heightInChars + editor.renderedLines.position().top)
-  $(window).trigger 'resize' # update editor's on-screen lines
+window.setEditorHeightInLines = (editorView, heightInChars, charHeight=editorView.lineHeight) ->
+  editorView.height(charHeight * heightInChars + editorView.renderedLines.position().top)
+  $(window).trigger 'resize' # update editor view's on-screen lines
 
 $.fn.resultOfTrigger = (type) ->
   event = $.Event(type)

spec/spec-suite.coffee

@@ -23,17 +23,19 @@ setSpecDirectory = (specDirectory) ->
   setSpecField('specDirectory', specDirectory)
 
 runAllSpecs = ->
+  {resourcePath} = atom.getLoadSettings()
   # Only run core specs when resource path is the Atom repository
-  if Git.exists(window.resourcePath)
-    requireSpecs(path.join(window.resourcePath, 'spec'))
+  if Git.exists(resourcePath)
+    requireSpecs(path.join(resourcePath, 'spec'))
     setSpecType('core')
 
   fixturesPackagesPath = path.join(__dirname, 'fixtures', 'packages')
-  packagePaths = atom.getAvailablePackageNames().map (packageName) -> atom.resolvePackagePath(packageName)
+  packagePaths = atom.packages.getAvailablePackageNames().map (packageName) ->
+    atom.packages.resolvePackagePath(packageName)
   packagePaths = _.groupBy packagePaths, (packagePath) ->
     if packagePath.indexOf("#{fixturesPackagesPath}#{path.sep}") is 0
       'fixtures'
-    else if packagePath.indexOf("#{window.resourcePath}#{path.sep}") is 0
+    else if packagePath.indexOf("#{resourcePath}#{path.sep}") is 0
       'bundled'
     else
       'user'

spec/syntax-spec.coffee

@@ -5,23 +5,23 @@ TextMateGrammar = require '../src/text-mate-grammar'
 
 describe "the `syntax` global", ->
   beforeEach ->
-    atom.activatePackage('language-text', sync: true)
-    atom.activatePackage('language-javascript', sync: true)
-    atom.activatePackage('language-coffee-script', sync: true)
-    atom.activatePackage('language-ruby', sync: true)
+    atom.packages.activatePackage('language-text', sync: true)
+    atom.packages.activatePackage('language-javascript', sync: true)
+    atom.packages.activatePackage('language-coffee-script', sync: true)
+    atom.packages.activatePackage('language-ruby', sync: true)
 
   describe "serialization", ->
     it "remembers grammar overrides by path", ->
       filePath = '/foo/bar/file.js'
       expect(atom.syntax.selectGrammar(filePath).name).not.toBe 'Ruby'
       atom.syntax.setGrammarOverrideForPath(filePath, 'source.ruby')
-      syntax2 = deserialize(atom.syntax.serialize())
+      syntax2 = atom.deserializers.deserialize(atom.syntax.serialize())
       syntax2.addGrammar(grammar) for grammar in atom.syntax.grammars when grammar isnt atom.syntax.nullGrammar
       expect(syntax2.selectGrammar(filePath).name).toBe 'Ruby'
 
   describe ".selectGrammar(filePath)", ->
     it "can use the filePath to load the correct grammar based on the grammar's filetype", ->
-      atom.activatePackage('language-git', sync: true)
+      atom.packages.activatePackage('language-git', sync: true)
 
       expect(atom.syntax.selectGrammar("file.js").name).toBe "JavaScript" # based on extension (.js)
       expect(atom.syntax.selectGrammar(path.join(temp.dir, '.git', 'config')).name).toBe "Git Config" # based on end of the path (.git/config)
@@ -34,7 +34,7 @@ describe "the `syntax` global", ->
       expect(atom.syntax.selectGrammar(filePath).name).toBe "Ruby"
 
     it "uses the number of newlines in the first line regex to determine the number of lines to test against", ->
-      atom.activatePackage('language-property-list', sync: true)
+      atom.packages.activatePackage('language-property-list', sync: true)
 
       fileContent = "first-line\n<html>"
       expect(atom.syntax.selectGrammar("dummy.coffee", fileContent).name).toBe "CoffeeScript"

spec/text-buffer-spec.coffee

@@ -10,7 +10,7 @@ describe 'TextBuffer', ->
   beforeEach ->
     filePath = require.resolve('./fixtures/sample.js')
     fileContents = fs.readFileSync(filePath, 'utf8')
-    buffer = project.bufferForPathSync(filePath)
+    buffer = atom.project.bufferForPathSync(filePath)
 
   afterEach ->
     buffer?.destroy()
@@ -24,12 +24,12 @@ describe 'TextBuffer', ->
       describe "when a file exists for the path", ->
         it "loads the contents of that file", ->
           filePath = require.resolve './fixtures/sample.txt'
-          buffer = project.bufferForPathSync(filePath)
+          buffer = atom.project.bufferForPathSync(filePath)
           expect(buffer.getText()).toBe fs.readFileSync(filePath, 'utf8')
 
         it "does not allow the initial state of the buffer to be undone", ->
           filePath = require.resolve './fixtures/sample.txt'
-          buffer = project.bufferForPathSync(filePath)
+          buffer = atom.project.bufferForPathSync(filePath)
           buffer.undo()
           expect(buffer.getText()).toBe fs.readFileSync(filePath, 'utf8')
 
@@ -37,13 +37,13 @@ describe 'TextBuffer', ->
         it "is modified and is initially empty", ->
           filePath = "does-not-exist.txt"
           expect(fs.existsSync(filePath)).toBeFalsy()
-          buffer = project.bufferForPathSync(filePath)
+          buffer = atom.project.bufferForPathSync(filePath)
           expect(buffer.isModified()).toBeTruthy()
           expect(buffer.getText()).toBe ''
 
     describe "when no path is given", ->
       it "creates an empty buffer", ->
-        buffer = project.bufferForPathSync(null)
+        buffer = atom.project.bufferForPathSync(null)
         expect(buffer .getText()).toBe ""
 
   describe "path-changed event", ->
@@ -53,7 +53,7 @@ describe 'TextBuffer', ->
       filePath = path.join(__dirname, "fixtures", "atom-manipulate-me")
       newPath = "#{filePath}-i-moved"
       fs.writeFileSync(filePath, "")
-      bufferToChange = project.bufferForPathSync(filePath)
+      bufferToChange = atom.project.bufferForPathSync(filePath)
       eventHandler = jasmine.createSpy('eventHandler')
       bufferToChange.on 'path-changed', eventHandler
 
@@ -85,7 +85,7 @@ describe 'TextBuffer', ->
       buffer.release()
       filePath = temp.openSync('atom').path
       fs.writeFileSync(filePath, "first")
-      buffer = project.bufferForPathSync(filePath).retain()
+      buffer = atom.project.bufferForPathSync(filePath).retain()
 
     afterEach ->
       buffer.release()
@@ -156,7 +156,7 @@ describe 'TextBuffer', ->
     beforeEach ->
       filePath = path.join(temp.dir, 'atom-file-to-delete.txt')
       fs.writeFileSync(filePath, 'delete me')
-      bufferToDelete = project.bufferForPathSync(filePath)
+      bufferToDelete = atom.project.bufferForPathSync(filePath)
       filePath = bufferToDelete.getPath() # symlinks may have been converted
 
       expect(bufferToDelete.getPath()).toBe filePath
@@ -214,7 +214,7 @@ describe 'TextBuffer', ->
       buffer.release()
       filePath = path.join(temp.dir, 'atom-tmp-file')
       fs.writeFileSync(filePath, 'delete me')
-      buffer = project.bufferForPathSync(filePath)
+      buffer = atom.project.bufferForPathSync(filePath)
       modifiedHandler = jasmine.createSpy("modifiedHandler")
       buffer.on 'modified-status-changed', modifiedHandler
 
@@ -227,7 +227,7 @@ describe 'TextBuffer', ->
       filePath = path.join(temp.dir, 'atom-tmp-file')
       fs.writeFileSync(filePath, '')
       buffer.release()
-      buffer = project.bufferForPathSync(filePath)
+      buffer = atom.project.bufferForPathSync(filePath)
       modifiedHandler = jasmine.createSpy("modifiedHandler")
       buffer.on 'modified-status-changed', modifiedHandler
 
@@ -251,7 +251,7 @@ describe 'TextBuffer', ->
       filePath = path.join(temp.dir, 'atom-tmp-file')
       fs.writeFileSync(filePath, '')
       buffer.release()
-      buffer = project.bufferForPathSync(filePath)
+      buffer = atom.project.bufferForPathSync(filePath)
       modifiedHandler = jasmine.createSpy("modifiedHandler")
       buffer.on 'modified-status-changed', modifiedHandler
 
@@ -275,7 +275,7 @@ describe 'TextBuffer', ->
       fs.removeSync(filePath) if fs.existsSync(filePath)
       expect(fs.existsSync(filePath)).toBeFalsy()
       buffer.release()
-      buffer = project.bufferForPathSync(filePath)
+      buffer = atom.project.bufferForPathSync(filePath)
       modifiedHandler = jasmine.createSpy("modifiedHandler")
       buffer.on 'modified-status-changed', modifiedHandler
 
@@ -298,12 +298,12 @@ describe 'TextBuffer', ->
 
     it "returns false for an empty buffer with no path", ->
       buffer.release()
-      buffer = project.bufferForPathSync(null)
+      buffer = atom.project.bufferForPathSync(null)
       expect(buffer.isModified()).toBeFalsy()
 
     it "returns true for a non-empty buffer with no path", ->
       buffer.release()
-      buffer = project.bufferForPathSync(null)
+      buffer = atom.project.bufferForPathSync(null)
       buffer.setText('a')
       expect(buffer.isModified()).toBeTruthy()
       buffer.setText('\n')
@@ -312,7 +312,7 @@ describe 'TextBuffer', ->
     it "returns false until the buffer is fully loaded", ->
       buffer.release()
       buffer = new TextBuffer({filePath: temp.openSync('atom').path})
-      project.addBuffer(buffer)
+      atom.project.addBuffer(buffer)
 
       expect(buffer.isModified()).toBeFalsy()
 
@@ -432,7 +432,7 @@ describe 'TextBuffer', ->
         expect(event.newText).toBe "foo\nbar"
 
     it "allows a 'changed' event handler to safely undo the change", ->
-      buffer.one 'changed', -> buffer.undo()
+      buffer.once 'changed', -> buffer.undo()
       buffer.change([0, 0], "hello")
       expect(buffer.lineForRow(0)).toBe "var quicksort = function () {"
 
@@ -466,7 +466,7 @@ describe 'TextBuffer', ->
       beforeEach ->
         filePath = path.join(temp.dir, 'temp.txt')
         fs.writeFileSync(filePath, "")
-        saveBuffer = project.bufferForPathSync(filePath)
+        saveBuffer = atom.project.bufferForPathSync(filePath)
         saveBuffer.setText("blah")
 
       it "saves the contents of the buffer to the path", ->
@@ -500,7 +500,7 @@ describe 'TextBuffer', ->
 
     describe "when the buffer has no path", ->
       it "throws an exception", ->
-        saveBuffer = project.bufferForPathSync(null)
+        saveBuffer = atom.project.bufferForPathSync(null)
         saveBuffer.setText "hi"
         expect(-> saveBuffer.save()).toThrow()
 
@@ -524,7 +524,7 @@ describe 'TextBuffer', ->
       filePath = path.join(temp.dir, 'temp.txt')
       fs.removeSync filePath if fs.existsSync(filePath)
 
-      saveAsBuffer = project.bufferForPathSync(null).retain()
+      saveAsBuffer = atom.project.bufferForPathSync(null).retain()
       eventHandler = jasmine.createSpy('eventHandler')
       saveAsBuffer.on 'path-changed', eventHandler
 
@@ -539,7 +539,7 @@ describe 'TextBuffer', ->
       newPath = path.join(temp.dir, 'new.txt')
       fs.writeFileSync(originalPath, "")
 
-      saveAsBuffer = project.bufferForPathSync(originalPath).retain()
+      saveAsBuffer = atom.project.bufferForPathSync(originalPath).retain()
       changeHandler = jasmine.createSpy('changeHandler')
       saveAsBuffer.on 'changed', changeHandler
       saveAsBuffer.saveAs(newPath)
@@ -904,7 +904,7 @@ describe 'TextBuffer', ->
 
       filePath = temp.openSync('atom').path
       fs.writeFileSync(filePath, "words")
-      buffer = project.bufferForPathSync(filePath)
+      buffer = atom.project.bufferForPathSync(filePath)
 
     afterEach ->
       buffer2?.release()
@@ -966,13 +966,13 @@ describe 'TextBuffer', ->
       it "restores the previous unsaved state of the buffer", ->
         buffer.release()
 
-        buffer = project.bufferForPathSync()
+        buffer = atom.project.bufferForPathSync()
         buffer.setText("abc")
 
         state = buffer.getState().clone()
         expect(state.get('path')).toBeUndefined()
         expect(state.getObject('text')).toBe 'abc'
 
-        buffer2 = project.addBuffer(new TextBuffer(state))
+        buffer2 = atom.project.addBuffer(new TextBuffer(state))
         expect(buffer2.getPath()).toBeUndefined()
         expect(buffer2.getText()).toBe("abc")

spec/text-mate-grammar-spec.coffee

@@ -6,13 +6,13 @@ describe "TextMateGrammar", ->
   grammar = null
 
   beforeEach ->
-    atom.activatePackage('language-text', sync: true)
-    atom.activatePackage('language-javascript', sync: true)
-    atom.activatePackage('language-coffee-script', sync: true)
-    atom.activatePackage('language-ruby', sync: true)
-    atom.activatePackage('language-html', sync: true)
-    atom.activatePackage('language-php', sync: true)
-    atom.activatePackage('language-python', sync: true)
+    atom.packages.activatePackage('language-text', sync: true)
+    atom.packages.activatePackage('language-javascript', sync: true)
+    atom.packages.activatePackage('language-coffee-script', sync: true)
+    atom.packages.activatePackage('language-ruby', sync: true)
+    atom.packages.activatePackage('language-html', sync: true)
+    atom.packages.activatePackage('language-php', sync: true)
+    atom.packages.activatePackage('language-python', sync: true)
     grammar = atom.syntax.selectGrammar("hello.coffee")
 
   describe "@loadSync(path)", ->
@@ -211,8 +211,8 @@ describe "TextMateGrammar", ->
       describe "when the pattern includes rules from another grammar", ->
         describe "when a grammar matching the desired scope is available", ->
           it "parses tokens inside the begin/end patterns based on the included grammar's rules", ->
-            atom.activatePackage('language-html', sync: true)
-            atom.activatePackage('language-ruby-on-rails', sync: true)
+            atom.packages.activatePackage('language-html', sync: true)
+            atom.packages.activatePackage('language-ruby-on-rails', sync: true)
 
             grammar = atom.syntax.grammarForScopeName('text.html.ruby')
             {tokens} = grammar.tokenizeLine("<div class='name'><%= User.find(2).full_name %></div>")
@@ -242,8 +242,8 @@ describe "TextMateGrammar", ->
             expect(tokens[22]).toEqual value: '>', scopes: ["text.html.ruby","meta.tag.block.any.html","punctuation.definition.tag.end.html"]
 
           it "updates the grammar if the included grammar is updated later", ->
-            atom.activatePackage('language-html', sync: true)
-            atom.activatePackage('language-ruby-on-rails', sync: true)
+            atom.packages.activatePackage('language-html', sync: true)
+            atom.packages.activatePackage('language-ruby-on-rails', sync: true)
 
             grammar = atom.syntax.selectGrammar('foo.html.erb')
             grammarUpdatedHandler = jasmine.createSpy("grammarUpdatedHandler")
@@ -252,7 +252,7 @@ describe "TextMateGrammar", ->
             {tokens} = grammar.tokenizeLine("<div class='name'><% <<-SQL select * from users;")
             expect(tokens[12].value).toBe " select * from users;"
 
-            atom.activatePackage('language-sql', sync: true)
+            atom.packages.activatePackage('language-sql', sync: true)
             expect(grammarUpdatedHandler).toHaveBeenCalled()
             {tokens} = grammar.tokenizeLine("<div class='name'><% <<-SQL select * from users;")
             expect(tokens[12].value).toBe " "
@@ -260,8 +260,8 @@ describe "TextMateGrammar", ->
 
         describe "when a grammar matching the desired scope is unavailable", ->
           it "updates the grammar if a matching grammar is added later", ->
-            atom.deactivatePackage('language-html')
-            atom.activatePackage('language-ruby-on-rails', sync: true)
+            atom.packages.deactivatePackage('language-html')
+            atom.packages.activatePackage('language-ruby-on-rails', sync: true)
 
             grammar = atom.syntax.grammarForScopeName('text.html.ruby')
             {tokens} = grammar.tokenizeLine("<div class='name'><%= User.find(2).full_name %></div>")
@@ -270,7 +270,7 @@ describe "TextMateGrammar", ->
             expect(tokens[2]).toEqual value: ' ', scopes: ["text.html.ruby","source.ruby.rails.embedded.html"]
             expect(tokens[3]).toEqual value: 'User', scopes: ["text.html.ruby","source.ruby.rails.embedded.html","support.class.ruby"]
 
-            atom.activatePackage('language-html', sync: true)
+            atom.packages.activatePackage('language-html', sync: true)
             {tokens} = grammar.tokenizeLine("<div class='name'><%= User.find(2).full_name %></div>")
             expect(tokens[0]).toEqual value: '<', scopes: ["text.html.ruby","meta.tag.block.any.html","punctuation.definition.tag.begin.html"]
             expect(tokens[1]).toEqual value: 'div', scopes: ["text.html.ruby","meta.tag.block.any.html","entity.name.tag.block.any.html"]
@@ -314,7 +314,7 @@ describe "TextMateGrammar", ->
 
     describe "when inside a C block", ->
       beforeEach ->
-        atom.activatePackage('language-c', sync: true)
+        atom.packages.activatePackage('language-c', sync: true)
 
       it "correctly parses a method. (regression)", ->
         grammar = atom.syntax.selectGrammar("hello.c")
@@ -330,7 +330,7 @@ describe "TextMateGrammar", ->
     describe "when the grammar can infinitely loop over a line", ->
       it "aborts tokenization", ->
         spyOn(console, 'error')
-        atom.activatePackage("package-with-infinite-loop-grammar")
+        atom.packages.activatePackage("package-with-infinite-loop-grammar")
         grammar = atom.syntax.selectGrammar("something.package-with-infinite-loop-grammar")
         {tokens} = grammar.tokenizeLine("abc")
         expect(tokens[0].value).toBe "a"
@@ -339,7 +339,7 @@ describe "TextMateGrammar", ->
 
     describe "when a grammar has a pattern that has back references in the match value", ->
       it "does not special handle the back references and instead allows oniguruma to resolve them", ->
-        atom.activatePackage('language-sass', sync: true)
+        atom.packages.activatePackage('language-sass', sync: true)
         grammar = atom.syntax.selectGrammar("style.scss")
         {tokens} = grammar.tokenizeLine("@mixin x() { -moz-selector: whatever; }")
         expect(tokens[9]).toEqual value: "-moz-selector", scopes: ["source.css.scss", "meta.property-list.scss", "meta.property-name.scss"]
@@ -428,14 +428,14 @@ describe "TextMateGrammar", ->
 
     describe "when the grammar's pattern name has a group number in it", ->
       it "replaces the group number with the matched captured text", ->
-        atom.activatePackage('language-hyperlink', sync: true)
+        atom.packages.activatePackage('language-hyperlink', sync: true)
         grammar = atom.syntax.grammarForScopeName("text.hyperlink")
         {tokens} = grammar.tokenizeLine("https://github.com")
         expect(tokens[0].scopes).toEqual ["text.hyperlink", "markup.underline.link.https.hyperlink"]
 
     describe "when the grammar has an injection selector", ->
       it "includes the grammar's patterns when the selector matches the current scope in other grammars", ->
-        atom.activatePackage('language-hyperlink', sync: true)
+        atom.packages.activatePackage('language-hyperlink', sync: true)
         grammar = atom.syntax.selectGrammar("text.js")
         {tokens} = grammar.tokenizeLine("var i; // http://github.com")
 
@@ -447,25 +447,25 @@ describe "TextMateGrammar", ->
 
       describe "when the grammar is added", ->
         it "retokenizes existing buffers that contain tokens that match the injection selector", ->
-          editSession = project.openSync('sample.js')
-          editSession.setText("// http://github.com")
+          editor = atom.project.openSync('sample.js')
+          editor.setText("// http://github.com")
 
-          {tokens} = editSession.lineForScreenRow(0)
+          {tokens} = editor.lineForScreenRow(0)
           expect(tokens[1].value).toBe " http://github.com"
           expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
 
-          atom.activatePackage('language-hyperlink', sync: true)
+          atom.packages.activatePackage('language-hyperlink', sync: true)
 
-          {tokens} = editSession.lineForScreenRow(0)
+          {tokens} = editor.lineForScreenRow(0)
           expect(tokens[2].value).toBe "http://github.com"
           expect(tokens[2].scopes).toEqual ["source.js", "comment.line.double-slash.js", "markup.underline.link.http.hyperlink"]
 
       describe "when the grammar is updated", ->
         it "retokenizes existing buffers that contain tokens that match the injection selector", ->
-          editSession = project.openSync('sample.js')
-          editSession.setText("// SELECT * FROM OCTOCATS")
+          editor = atom.project.openSync('sample.js')
+          editor.setText("// SELECT * FROM OCTOCATS")
 
-          {tokens} = editSession.lineForScreenRow(0)
+          {tokens} = editor.lineForScreenRow(0)
           expect(tokens[1].value).toBe " SELECT * FROM OCTOCATS"
           expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
 
@@ -477,13 +477,13 @@ describe "TextMateGrammar", ->
             patterns: [ { include: "source.sql" } ]
           ))
 
-          {tokens} = editSession.lineForScreenRow(0)
+          {tokens} = editor.lineForScreenRow(0)
           expect(tokens[1].value).toBe " SELECT * FROM OCTOCATS"
           expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
 
-          atom.activatePackage('language-sql', sync: true)
+          atom.packages.activatePackage('language-sql', sync: true)
 
-          {tokens} = editSession.lineForScreenRow(0)
+          {tokens} = editor.lineForScreenRow(0)
           expect(tokens[2].value).toBe "SELECT"
           expect(tokens[2].scopes).toEqual ["source.js", "comment.line.double-slash.js", "keyword.other.DML.sql"]
 
@@ -514,7 +514,7 @@ describe "TextMateGrammar", ->
       lines = null
 
       beforeEach ->
-        atom.activatePackage('language-todo', sync: true)
+        atom.packages.activatePackage('language-todo', sync: true)
         grammar = atom.syntax.selectGrammar('main.rb')
         lines = grammar.tokenizeLines "# TODO be nicer"
 
@@ -528,7 +528,7 @@ describe "TextMateGrammar", ->
 
     describe "Git commit messages", ->
       beforeEach ->
-        atom.activatePackage('language-git', sync: true)
+        atom.packages.activatePackage('language-git', sync: true)
         grammar = atom.syntax.selectGrammar('COMMIT_EDITMSG')
         lines = grammar.tokenizeLines """
           longggggggggggggggggggggggggggggggggggggggggggggggg
@@ -547,7 +547,7 @@ describe "TextMateGrammar", ->
 
     describe "C++", ->
       beforeEach ->
-        atom.activatePackage('language-c', sync: true)
+        atom.packages.activatePackage('language-c', sync: true)
         grammar = atom.syntax.selectGrammar('includes.cc')
         lines = grammar.tokenizeLines """
           #include "a.h"
@@ -585,8 +585,8 @@ describe "TextMateGrammar", ->
 
     describe "Objective-C", ->
       beforeEach ->
-        atom.activatePackage('language-c', sync: true)
-        atom.activatePackage('language-objective-c', sync: true)
+        atom.packages.activatePackage('language-c', sync: true)
+        atom.packages.activatePackage('language-objective-c', sync: true)
         grammar = atom.syntax.selectGrammar('function.mm')
         lines = grammar.tokenizeLines """
           void test() {
@@ -612,7 +612,7 @@ describe "TextMateGrammar", ->
 
     describe "Java", ->
       beforeEach ->
-        atom.activatePackage('language-java', sync: true)
+        atom.packages.activatePackage('language-java', sync: true)
         grammar = atom.syntax.selectGrammar('Function.java')
 
       it "correctly parses single line comments", ->
@@ -635,11 +635,9 @@ describe "TextMateGrammar", ->
         expect(lastToken.value).toEqual ';'
 
     describe "HTML (Ruby - ERB)", ->
-      beforeEach ->
+      it "correctly parses strings inside tags", ->
         grammar = atom.syntax.selectGrammar('page.erb')
         lines = grammar.tokenizeLines '<% page_title "My Page" %>'
-
-      it "correctly parses strings inside tags", ->
         tokens = lines[0]
 
         expect(tokens[2].value).toEqual '"'
@@ -649,6 +647,16 @@ describe "TextMateGrammar", ->
         expect(tokens[4].value).toEqual '"'
         expect(tokens[4].scopes).toEqual ["text.html.erb", "meta.embedded.line.erb", "string.quoted.double.ruby", "punctuation.definition.string.end.ruby"]
 
+      it "does not loop infinitely on <%>", ->
+        atom.packages.activatePackage('language-html', sync: true)
+        atom.packages.activatePackage('language-ruby-on-rails', sync: true)
+
+        grammar = atom.syntax.selectGrammar('foo.html.erb')
+        [tokens] = grammar.tokenizeLines '<%>'
+        expect(tokens.length).toBe 1
+        expect(tokens[0].value).toEqual '<%>'
+        expect(tokens[0].scopes).toEqual ["text.html.erb"]
+
     describe "Unicode support", ->
       describe "Surrogate pair characters", ->
         beforeEach ->
@@ -664,7 +672,7 @@ describe "TextMateGrammar", ->
 
       describe "when the line contains unicode characters", ->
         it "correctly parses tokens starting after them", ->
-          atom.activatePackage('language-json', sync: true)
+          atom.packages.activatePackage('language-json', sync: true)
           grammar = atom.syntax.selectGrammar('package.json')
           {tokens} = grammar.tokenizeLine '{"\u2026": 1}'
 

spec/theme-manager-spec.coffee

@@ -1,5 +1,5 @@
 path = require 'path'
-{$, $$, fs, RootView} = require 'atom'
+{$, $$, fs, WorkspaceView} = require 'atom'
 
 ThemeManager = require '../src/theme-manager'
 AtomPackage = require '../src/atom-package'
@@ -32,7 +32,7 @@ describe "ThemeManager", ->
 
   describe "getImportPaths()", ->
     it "returns the theme directories before the themes are loaded", ->
-      atom.config.set('core.themes', ['atom-dark-syntax', 'atom-dark-ui', 'atom-light-ui'])
+      atom.config.set('core.themes', ['theme-with-index-less', 'atom-dark-ui', 'atom-light-ui'])
 
       paths = themeManager.getImportPaths()
 
@@ -67,8 +67,8 @@ describe "ThemeManager", ->
       atom.config.set('core.themes', [])
       expect($('style.theme').length).toBe 0
 
-      # atom-dark-ui has an directory path, the syntax ones dont.
-      atom.config.set('core.themes', ['atom-light-syntax', 'atom-dark-ui', 'atom-dark-syntax'])
+      # atom-dark-ui has an directory path, the syntax one doesn't
+      atom.config.set('core.themes', ['theme-with-index-less', 'atom-dark-ui'])
       importPaths = themeManager.getImportPaths()
       expect(importPaths.length).toBe 1
       expect(importPaths[0]).toContain 'atom-dark-ui'
@@ -80,7 +80,7 @@ describe "ThemeManager", ->
 
   describe "requireStylesheet(path)", ->
     it "synchronously loads css at the given path and installs a style tag for it in the head", ->
-      cssPath = project.resolve('css.css')
+      cssPath = atom.project.resolve('css.css')
       lengthBefore = $('head style').length
 
       themeManager.requireStylesheet(cssPath)
@@ -97,7 +97,7 @@ describe "ThemeManager", ->
       $('head style[id*="css.css"]').remove()
 
     it "synchronously loads and parses less files at the given path and installs a style tag for it in the head", ->
-      lessPath = project.resolve('sample.less')
+      lessPath = atom.project.resolve('sample.less')
       lengthBefore = $('head style').length
       themeManager.requireStylesheet(lessPath)
       expect($('head style').length).toBe lengthBefore + 1
@@ -121,9 +121,9 @@ describe "ThemeManager", ->
 
     it "supports requiring css and less stylesheets without an explicit extension", ->
       themeManager.requireStylesheet path.join(__dirname, 'fixtures', 'css')
-      expect($('head style[id*="css.css"]').attr('id')).toBe themeManager.stringToId(project.resolve('css.css'))
+      expect($('head style[id*="css.css"]').attr('id')).toBe themeManager.stringToId(atom.project.resolve('css.css'))
       themeManager.requireStylesheet path.join(__dirname, 'fixtures', 'sample')
-      expect($('head style[id*="sample.less"]').attr('id')).toBe themeManager.stringToId(project.resolve('sample.less'))
+      expect($('head style[id*="sample.less"]').attr('id')).toBe themeManager.stringToId(atom.project.resolve('sample.less'))
 
       $('head style[id*="css.css"]').remove()
       $('head style[id*="sample.less"]').remove()
@@ -140,16 +140,16 @@ describe "ThemeManager", ->
 
   describe "base stylesheet loading", ->
     beforeEach ->
-      window.rootView = new RootView
-      rootView.append $$ -> @div class: 'editor'
-      rootView.attachToDom()
+      atom.workspaceView = new WorkspaceView
+      atom.workspaceView.append $$ -> @div class: 'editor'
+      atom.workspaceView.attachToDom()
       themeManager.activateThemes()
 
     it "loads the correct values from the theme's ui-variables file", ->
       atom.config.set('core.themes', ['theme-with-ui-variables'])
 
       # an override loaded in the base css
-      expect(rootView.css("background-color")).toBe "rgb(0, 0, 255)"
+      expect(atom.workspaceView.css("background-color")).toBe "rgb(0, 0, 255)"
 
       # from within the theme itself
       expect($(".editor").css("padding-top")).toBe "150px"

spec/tokenized-buffer-spec.coffee

@@ -5,7 +5,7 @@ describe "TokenizedBuffer", ->
   [tokenizedBuffer, buffer, changeHandler] = []
 
   beforeEach ->
-    atom.activatePackage('language-javascript', sync: true)
+    atom.packages.activatePackage('language-javascript', sync: true)
     # enable async tokenization
     TokenizedBuffer.prototype.chunkSize = 5
     jasmine.unspy(TokenizedBuffer.prototype, 'tokenizeInBackground')
@@ -20,15 +20,15 @@ describe "TokenizedBuffer", ->
 
   describe "@deserialize(state)", ->
     it "constructs a tokenized buffer with the same buffer and tabLength setting", ->
-      buffer = project.bufferForPathSync('sample.js')
+      buffer = atom.project.bufferForPathSync('sample.js')
       tokenizedBuffer1 = new TokenizedBuffer(buffer: buffer, tabLength: 4)
-      tokenizedBuffer2 = deserialize(tokenizedBuffer1.serialize())
+      tokenizedBuffer2 = atom.deserializers.deserialize(tokenizedBuffer1.serialize())
       expect(tokenizedBuffer2.buffer).toBe tokenizedBuffer1.buffer
       expect(tokenizedBuffer2.getTabLength()).toBe tokenizedBuffer1.getTabLength()
 
   describe "when the buffer is destroyed", ->
     beforeEach ->
-      buffer = project.bufferForPathSync('sample.js')
+      buffer = atom.project.bufferForPathSync('sample.js')
       tokenizedBuffer = new TokenizedBuffer({buffer})
       startTokenizing(tokenizedBuffer)
 
@@ -40,7 +40,7 @@ describe "TokenizedBuffer", ->
 
   describe "when the buffer contains soft-tabs", ->
     beforeEach ->
-      buffer = project.bufferForPathSync('sample.js')
+      buffer = atom.project.bufferForPathSync('sample.js')
       tokenizedBuffer = new TokenizedBuffer({buffer})
       startTokenizing(tokenizedBuffer)
       tokenizedBuffer.on "changed", changeHandler = jasmine.createSpy('changeHandler')
@@ -319,8 +319,8 @@ describe "TokenizedBuffer", ->
 
   describe "when the buffer contains hard-tabs", ->
     beforeEach ->
-      atom.activatePackage('language-coffee-script', sync: true)
-      buffer = project.bufferForPathSync('sample-with-tabs.coffee')
+      atom.packages.activatePackage('language-coffee-script', sync: true)
+      buffer = atom.project.bufferForPathSync('sample-with-tabs.coffee')
       tokenizedBuffer = new TokenizedBuffer({buffer})
       startTokenizing(tokenizedBuffer)
 
@@ -349,8 +349,8 @@ describe "TokenizedBuffer", ->
 
   describe "when the buffer contains surrogate pairs", ->
     beforeEach ->
-      atom.activatePackage('language-javascript', sync: true)
-      buffer = project.bufferForPathSync 'sample-with-pairs.js'
+      atom.packages.activatePackage('language-javascript', sync: true)
+      buffer = atom.project.bufferForPathSync 'sample-with-pairs.js'
       buffer.setText """
         'abc\uD835\uDF97def'
         //\uD835\uDF97xyz
@@ -387,10 +387,10 @@ describe "TokenizedBuffer", ->
 
   describe "when the grammar is updated because a grammar it includes is activated", ->
     it "retokenizes the buffer", ->
-      atom.activatePackage('language-ruby-on-rails', sync: true)
-      atom.activatePackage('language-ruby', sync: true)
+      atom.packages.activatePackage('language-ruby-on-rails', sync: true)
+      atom.packages.activatePackage('language-ruby', sync: true)
 
-      buffer = project.bufferForPathSync()
+      buffer = atom.project.bufferForPathSync()
       buffer.setText "<div class='name'><%= User.find(2).full_name %></div>"
       tokenizedBuffer = new TokenizedBuffer({buffer})
       tokenizedBuffer.setGrammar(atom.syntax.selectGrammar('test.erb'))
@@ -399,7 +399,7 @@ describe "TokenizedBuffer", ->
       {tokens} = tokenizedBuffer.lineForScreenRow(0)
       expect(tokens[0]).toEqual value: "<div class='name'>", scopes: ["text.html.ruby"]
 
-      atom.activatePackage('language-html', sync: true)
+      atom.packages.activatePackage('language-html', sync: true)
       fullyTokenize(tokenizedBuffer)
       {tokens} = tokenizedBuffer.lineForScreenRow(0)
       expect(tokens[0]).toEqual value: '<', scopes: ["text.html.ruby","meta.tag.block.any.html","punctuation.definition.tag.begin.html"]
@@ -410,7 +410,7 @@ describe "TokenizedBuffer", ->
       buffer.release()
 
     it "returns the correct token (regression)", ->
-      buffer = project.bufferForPathSync('sample.js')
+      buffer = atom.project.bufferForPathSync('sample.js')
       tokenizedBuffer = new TokenizedBuffer({buffer})
       fullyTokenize(tokenizedBuffer)
       expect(tokenizedBuffer.tokenForPosition([1,0]).scopes).toEqual ["source.js"]
@@ -419,7 +419,7 @@ describe "TokenizedBuffer", ->
 
   describe ".bufferRangeForScopeAtPosition(selector, position)", ->
     beforeEach ->
-      buffer = project.bufferForPathSync('sample.js')
+      buffer = atom.project.bufferForPathSync('sample.js')
       tokenizedBuffer = new TokenizedBuffer({buffer})
       fullyTokenize(tokenizedBuffer)
 
@@ -434,3 +434,13 @@ describe "TokenizedBuffer", ->
     describe "when the selector matches a run of multiple tokens at the position", ->
       it "returns the range covered by all contigous tokens (within a single line)", ->
         expect(tokenizedBuffer.bufferRangeForScopeAtPosition('.function', [1, 18])).toEqual [[1, 6], [1, 28]]
+
+  describe "when the editor.tabLength config value changes", ->
+    it "updates the tab length of the tokenized lines", ->
+      buffer = atom.project.bufferForPathSync('sample.js')
+      buffer.setText('\ttest')
+      tokenizedBuffer = new TokenizedBuffer({buffer})
+      fullyTokenize(tokenizedBuffer)
+      expect(tokenizedBuffer.tokenForPosition([0,0]).value).toBe '  '
+      atom.config.set('editor.tabLength', 6)
+      expect(tokenizedBuffer.tokenForPosition([0,0]).value).toBe '      '

spec/window-spec.coffee

@@ -8,11 +8,11 @@ describe "Window", ->
   beforeEach ->
     spyOn(atom, 'hide')
     atom.getLoadSettings() # Causes atom.loadSettings to be initialized
-    atom.loadSettings.initialPath = project.getPath()
-    project.destroy()
+    atom.loadSettings.initialPath = atom.project.getPath()
+    atom.project.destroy()
     windowEventHandler = new WindowEventHandler()
-    window.deserializeEditorWindow()
-    projectPath = project.getPath()
+    atom.deserializeEditorWindow()
+    projectPath = atom.project.getPath()
 
   afterEach ->
     windowEventHandler.unsubscribe()
@@ -58,50 +58,50 @@ describe "Window", ->
       beforeUnloadEvent = $.Event(new Event('beforeunload'))
 
     describe "when pane items are are modified", ->
-      it "prompts user to save and and calls rootView.confirmClose", ->
-        spyOn(rootView, 'confirmClose').andCallThrough()
-        spyOn(atom, "confirmSync").andReturn(2)
-        editSession = rootView.openSync("sample.js")
-        editSession.insertText("I look different, I feel different.")
+      it "prompts user to save and and calls workspaceView.confirmClose", ->
+        spyOn(atom.workspaceView, 'confirmClose').andCallThrough()
+        spyOn(atom, "confirm").andReturn(2)
+        editor = atom.workspaceView.openSync("sample.js")
+        editor.insertText("I look different, I feel different.")
         $(window).trigger(beforeUnloadEvent)
-        expect(rootView.confirmClose).toHaveBeenCalled()
-        expect(atom.confirmSync).toHaveBeenCalled()
+        expect(atom.workspaceView.confirmClose).toHaveBeenCalled()
+        expect(atom.confirm).toHaveBeenCalled()
 
       it "prompts user to save and handler returns true if don't save", ->
-        spyOn(atom, "confirmSync").andReturn(2)
-        editSession = rootView.openSync("sample.js")
-        editSession.insertText("I look different, I feel different.")
+        spyOn(atom, "confirm").andReturn(2)
+        editor = atom.workspaceView.openSync("sample.js")
+        editor.insertText("I look different, I feel different.")
         $(window).trigger(beforeUnloadEvent)
-        expect(atom.confirmSync).toHaveBeenCalled()
+        expect(atom.confirm).toHaveBeenCalled()
 
       it "prompts user to save and handler returns false if dialog is canceled", ->
-        spyOn(atom, "confirmSync").andReturn(1)
-        editSession = rootView.openSync("sample.js")
-        editSession.insertText("I look different, I feel different.")
+        spyOn(atom, "confirm").andReturn(1)
+        editor = atom.workspaceView.openSync("sample.js")
+        editor.insertText("I look different, I feel different.")
         $(window).trigger(beforeUnloadEvent)
-        expect(atom.confirmSync).toHaveBeenCalled()
+        expect(atom.confirm).toHaveBeenCalled()
 
   describe ".unloadEditorWindow()", ->
     it "saves the serialized state of the window so it can be deserialized after reload", ->
-      rootViewState = rootView.serialize()
+      workspaceViewState = atom.workspaceView.serialize()
       syntaxState = atom.syntax.serialize()
 
-      window.unloadEditorWindow()
+      atom.unloadEditorWindow()
 
-      expect(atom.getWindowState().getObject('rootView')).toEqual rootViewState.toObject()
+      expect(atom.getWindowState().getObject('workspaceView')).toEqual workspaceViewState.toObject()
       expect(atom.getWindowState().getObject('syntax')).toEqual syntaxState
       expect(atom.saveWindowState).toHaveBeenCalled()
 
     it "unsubscribes from all buffers", ->
-      rootView.openSync('sample.js')
-      buffer = rootView.getActivePaneItem().buffer
-      pane = rootView.getActivePane()
+      atom.workspaceView.openSync('sample.js')
+      buffer = atom.workspaceView.getActivePaneItem().buffer
+      pane = atom.workspaceView.getActivePane()
       pane.splitRight(pane.copyActiveItem())
-      expect(window.rootView.find('.editor').length).toBe 2
+      expect(atom.workspaceView.find('.editor').length).toBe 2
 
-      window.unloadEditorWindow()
+      atom.unloadEditorWindow()
 
-      expect(buffer.subscriptionCount()).toBe 0
+      expect(buffer.getSubscriptionCount()).toBe 0
 
   describe "drag and drop", ->
     buildDragEvent = (type, files) ->

spec/workspace-view-spec.coffee

@@ -0,0 +1,522 @@
+{$, $$, fs, WorkspaceView, View} = require 'atom'
+Q = require 'q'
+path = require 'path'
+temp = require 'temp'
+Pane = require '../src/pane'
+
+describe "WorkspaceView", ->
+  pathToOpen = null
+
+  beforeEach ->
+    atom.project.setPath(atom.project.resolve('dir'))
+    pathToOpen = atom.project.resolve('a')
+    atom.workspaceView = new WorkspaceView
+    atom.workspaceView.enableKeymap()
+    atom.workspaceView.openSync(pathToOpen)
+    atom.workspaceView.focus()
+
+  describe "@deserialize()", ->
+    viewState = null
+
+    simulateReload = ->
+      atom.unloadEditorWindow()
+      atom.deserializeEditorWindow()
+
+    describe "when the serialized WorkspaceView has an unsaved buffer", ->
+      it "constructs the view with the same panes", ->
+        atom.workspaceView.attachToDom()
+        atom.workspaceView.openSync()
+        editor1 = atom.workspaceView.getActiveView()
+        buffer = editor1.getBuffer()
+        editor1.splitRight()
+        expect(atom.workspaceView.getActiveView()).toBe atom.workspaceView.getEditorViews()[2]
+
+        simulateReload()
+
+        expect(atom.workspaceView.getEditorViews().length).toBe 2
+        expect(atom.workspaceView.getActiveView()).toBe atom.workspaceView.getEditorViews()[1]
+        expect(atom.workspaceView.title).toBe "untitled - #{atom.project.getPath()}"
+
+    describe "when there are open editors", ->
+      it "constructs the view with the same panes", ->
+        atom.workspaceView.attachToDom()
+        pane1 = atom.workspaceView.getActivePane()
+        pane2 = pane1.splitRight()
+        pane3 = pane2.splitRight()
+        pane4 = pane2.splitDown()
+        pane2.showItem(atom.project.openSync('b'))
+        pane3.showItem(atom.project.openSync('../sample.js'))
+        pane3.activeItem.setCursorScreenPosition([2, 4])
+        pane4.showItem(atom.project.openSync('../sample.txt'))
+        pane4.activeItem.setCursorScreenPosition([0, 2])
+        pane2.focus()
+
+        simulateReload()
+
+        expect(atom.workspaceView.getEditorViews().length).toBe 4
+        editor1 = atom.workspaceView.panes.find('.row > .pane .editor:eq(0)').view()
+        editor3 = atom.workspaceView.panes.find('.row > .pane .editor:eq(1)').view()
+        editor2 = atom.workspaceView.panes.find('.row > .column > .pane .editor:eq(0)').view()
+        editor4 = atom.workspaceView.panes.find('.row > .column > .pane .editor:eq(1)').view()
+
+        expect(editor1.getPath()).toBe atom.project.resolve('a')
+        expect(editor2.getPath()).toBe atom.project.resolve('b')
+        expect(editor3.getPath()).toBe atom.project.resolve('../sample.js')
+        expect(editor3.getCursorScreenPosition()).toEqual [2, 4]
+        expect(editor4.getPath()).toBe atom.project.resolve('../sample.txt')
+        expect(editor4.getCursorScreenPosition()).toEqual [0, 2]
+
+        # ensure adjust pane dimensions is called
+        expect(editor1.width()).toBeGreaterThan 0
+        expect(editor2.width()).toBeGreaterThan 0
+        expect(editor3.width()).toBeGreaterThan 0
+        expect(editor4.width()).toBeGreaterThan 0
+
+        # ensure correct editor is focused again
+        expect(editor2.isFocused).toBeTruthy()
+        expect(editor1.isFocused).toBeFalsy()
+        expect(editor3.isFocused).toBeFalsy()
+        expect(editor4.isFocused).toBeFalsy()
+
+        expect(atom.workspaceView.title).toBe "#{path.basename(editor2.getPath())} - #{atom.project.getPath()}"
+
+    describe "where there are no open editors", ->
+      it "constructs the view with no open editors", ->
+        atom.workspaceView.getActivePane().remove()
+        expect(atom.workspaceView.getEditorViews().length).toBe 0
+        simulateReload()
+        expect(atom.workspaceView.getEditorViews().length).toBe 0
+
+  describe "focus", ->
+    beforeEach ->
+      atom.workspaceView.attachToDom()
+
+    describe "when there is an active view", ->
+      it "hands off focus to the active view", ->
+        editorView = atom.workspaceView.getActiveView()
+        editorView.isFocused = false
+        atom.workspaceView.focus()
+        expect(editorView.isFocused).toBeTruthy()
+
+    describe "when there is no active view", ->
+      beforeEach ->
+        atom.workspaceView.getActivePane().remove()
+        expect(atom.workspaceView.getActiveView()).toBeUndefined()
+        atom.workspaceView.attachToDom()
+        expect(document.activeElement).toBe document.body
+
+      describe "when are visible focusable elements (with a -1 tabindex)", ->
+        it "passes focus to the first focusable element", ->
+          focusable1 = $$ -> @div "One", id: 'one', tabindex: -1
+          focusable2 = $$ -> @div "Two", id: 'two', tabindex: -1
+          atom.workspaceView.horizontal.append(focusable1, focusable2)
+          expect(document.activeElement).toBe document.body
+
+          atom.workspaceView.focus()
+          expect(document.activeElement).toBe focusable1[0]
+
+      describe "when there are no visible focusable elements", ->
+        it "surrenders focus to the body", ->
+          focusable = $$ -> @div "One", id: 'one', tabindex: -1
+          atom.workspaceView.horizontal.append(focusable)
+          focusable.hide()
+          expect(document.activeElement).toBe document.body
+
+          atom.workspaceView.focus()
+          expect(document.activeElement).toBe document.body
+
+  describe "keymap wiring", ->
+    commandHandler = null
+    beforeEach ->
+      commandHandler = jasmine.createSpy('commandHandler')
+      atom.workspaceView.on('foo-command', commandHandler)
+
+      atom.keymap.bindKeys('name', '*', 'x': 'foo-command')
+
+    describe "when a keydown event is triggered in the WorkspaceView", ->
+      it "triggers matching keybindings for that event", ->
+        event = keydownEvent 'x', target: atom.workspaceView[0]
+
+        atom.workspaceView.trigger(event)
+        expect(commandHandler).toHaveBeenCalled()
+
+  describe "window title", ->
+    describe "when the project has no path", ->
+      it "sets the title to 'untitled'", ->
+        atom.project.setPath(undefined)
+        expect(atom.workspaceView.title).toBe 'untitled'
+
+    describe "when the project has a path", ->
+      beforeEach ->
+        atom.workspaceView.openSync('b')
+
+      describe "when there is an active pane item", ->
+        it "sets the title to the pane item's title plus the project path", ->
+          item = atom.workspaceView.getActivePaneItem()
+          expect(atom.workspaceView.title).toBe "#{item.getTitle()} - #{atom.project.getPath()}"
+
+      describe "when the title of the active pane item changes", ->
+        it "updates the window title based on the item's new title", ->
+          editor = atom.workspaceView.getActivePaneItem()
+          editor.buffer.setPath(path.join(temp.dir, 'hi'))
+          expect(atom.workspaceView.title).toBe "#{editor.getTitle()} - #{atom.project.getPath()}"
+
+      describe "when the active pane's item changes", ->
+        it "updates the title to the new item's title plus the project path", ->
+          atom.workspaceView.getActivePane().showNextItem()
+          item = atom.workspaceView.getActivePaneItem()
+          expect(atom.workspaceView.title).toBe "#{item.getTitle()} - #{atom.project.getPath()}"
+
+      describe "when the last pane item is removed", ->
+        it "updates the title to contain the project's path", ->
+          atom.workspaceView.getActivePane().remove()
+          expect(atom.workspaceView.getActivePaneItem()).toBeUndefined()
+          expect(atom.workspaceView.title).toBe atom.project.getPath()
+
+      describe "when an inactive pane's item changes", ->
+        it "does not update the title", ->
+          pane = atom.workspaceView.getActivePane()
+          pane.splitRight()
+          initialTitle = atom.workspaceView.title
+          pane.showNextItem()
+          expect(atom.workspaceView.title).toBe initialTitle
+
+    describe "when the root view is deserialized", ->
+      it "updates the title to contain the project's path", ->
+        workspaceView2 = atom.deserializers.deserialize(atom.workspaceView.serialize())
+        item = atom.workspaceView.getActivePaneItem()
+        expect(workspaceView2.title).toBe "#{item.getTitle()} - #{atom.project.getPath()}"
+        workspaceView2.remove()
+
+  describe "font size adjustment", ->
+    it "increases/decreases font size when increase/decrease-font-size events are triggered", ->
+      fontSizeBefore = atom.config.get('editor.fontSize')
+      atom.workspaceView.trigger 'window:increase-font-size'
+      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore + 1
+      atom.workspaceView.trigger 'window:increase-font-size'
+      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore + 2
+      atom.workspaceView.trigger 'window:decrease-font-size'
+      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore + 1
+      atom.workspaceView.trigger 'window:decrease-font-size'
+      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore
+
+    it "does not allow the font size to be less than 1", ->
+      atom.config.set("editor.fontSize", 1)
+      atom.workspaceView.trigger 'window:decrease-font-size'
+      expect(atom.config.get('editor.fontSize')).toBe 1
+
+  describe ".openSync(filePath, options)", ->
+    describe "when there is no active pane", ->
+      beforeEach ->
+        spyOn(Pane.prototype, 'focus')
+        atom.workspaceView.getActivePane().remove()
+        expect(atom.workspaceView.getActivePane()).toBeUndefined()
+
+      describe "when called with no path", ->
+        it "creates a empty edit session as an item on a new pane, and focuses the pane", ->
+          editor = atom.workspaceView.openSync()
+          expect(atom.workspaceView.getActivePane().activeItem).toBe editor
+          expect(editor.getPath()).toBeUndefined()
+          expect(atom.workspaceView.getActivePane().focus).toHaveBeenCalled()
+
+        it "can create multiple empty edit sessions as an item on a new pane", ->
+          editor = atom.workspaceView.openSync()
+          editor2 = atom.workspaceView.openSync()
+          expect(atom.workspaceView.getActivePane().getItems().length).toBe 2
+          expect(editor).not.toBe editor2
+
+      describe "when called with a path", ->
+        it "creates an edit session for the given path as an item on a new pane, and focuses the pane", ->
+          editor = atom.workspaceView.openSync('b')
+          expect(atom.workspaceView.getActivePane().activeItem).toBe editor
+          expect(editor.getPath()).toBe require.resolve('./fixtures/dir/b')
+          expect(atom.workspaceView.getActivePane().focus).toHaveBeenCalled()
+
+      describe "when the changeFocus option is false", ->
+        it "does not focus the new pane", ->
+          editor = atom.workspaceView.openSync('b', changeFocus: false)
+          expect(atom.workspaceView.getActivePane().focus).not.toHaveBeenCalled()
+
+      describe "when the split option is 'right'", ->
+        it "creates a new pane and opens the file in said pane", ->
+          editor = atom.workspaceView.openSync('b', split: 'right')
+          expect(atom.workspaceView.getActivePane().activeItem).toBe editor
+          expect(editor.getPath()).toBe require.resolve('./fixtures/dir/b')
+
+    describe "when there is an active pane", ->
+      [activePane, initialItemCount] = []
+      beforeEach ->
+        activePane = atom.workspaceView.getActivePane()
+        spyOn(activePane, 'focus')
+        initialItemCount = activePane.getItems().length
+
+      describe "when called with no path", ->
+        it "opens an edit session with an empty buffer as an item in the active pane and focuses it", ->
+          editor = atom.workspaceView.openSync()
+          expect(activePane.getItems().length).toBe initialItemCount + 1
+          expect(activePane.activeItem).toBe editor
+          expect(editor.getPath()).toBeUndefined()
+          expect(activePane.focus).toHaveBeenCalled()
+
+      describe "when called with a path", ->
+        describe "when the active pane already has an edit session item for the path being opened", ->
+          it "shows the existing edit session in the pane", ->
+            previousEditor = activePane.activeItem
+
+            editor = atom.workspaceView.openSync('b')
+            expect(activePane.activeItem).toBe editor
+            expect(editor).not.toBe previousEditor
+
+            editor = atom.workspaceView.openSync(previousEditor.getPath())
+            expect(editor).toBe previousEditor
+            expect(activePane.activeItem).toBe editor
+
+            expect(activePane.focus).toHaveBeenCalled()
+
+        describe "when the active pane does not have an edit session item for the path being opened", ->
+          it "creates a new edit session for the given path in the active editor", ->
+            editor = atom.workspaceView.openSync('b')
+            expect(activePane.items.length).toBe 2
+            expect(activePane.activeItem).toBe editor
+            expect(activePane.focus).toHaveBeenCalled()
+
+      describe "when the changeFocus option is false", ->
+        it "does not focus the active pane", ->
+          editor = atom.workspaceView.openSync('b', changeFocus: false)
+          expect(activePane.focus).not.toHaveBeenCalled()
+
+      describe "when the split option is 'right'", ->
+        it "creates a new pane and opens the file in said pane", ->
+          pane1 = atom.workspaceView.getActivePane()
+
+          editor = atom.workspaceView.openSync('b', split: 'right')
+          pane2 = atom.workspaceView.getActivePane()
+          expect(pane2[0]).not.toBe pane1[0]
+          expect(editor.getPath()).toBe require.resolve('./fixtures/dir/b')
+
+          expect(atom.workspaceView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
+
+          editor = atom.workspaceView.openSync('file1', split: 'right')
+          pane3 = atom.workspaceView.getActivePane()
+          expect(pane3[0]).toBe pane2[0]
+          expect(editor.getPath()).toBe require.resolve('./fixtures/dir/file1')
+
+          expect(atom.workspaceView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
+
+  describe ".openSingletonSync(filePath, options)", ->
+    describe "when there is an active pane", ->
+      [pane1] = []
+      beforeEach ->
+        spyOn(Pane.prototype, 'focus').andCallFake -> @makeActive()
+        pane1 = atom.workspaceView.getActivePane()
+
+      it "creates a new pane and reuses the file when already open", ->
+        atom.workspaceView.openSingletonSync('b', split: 'right')
+        pane2 = atom.workspaceView.getActivePane()
+        expect(pane2[0]).not.toBe pane1[0]
+        expect(pane1.itemForUri('b')).toBeFalsy()
+        expect(pane2.itemForUri('b')).not.toBeFalsy()
+        expect(atom.workspaceView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
+
+        pane1.focus()
+        expect(atom.workspaceView.getActivePane()[0]).toBe pane1[0]
+
+        atom.workspaceView.openSingletonSync('b', split: 'right')
+        pane3 = atom.workspaceView.getActivePane()
+        expect(pane3[0]).toBe pane2[0]
+        expect(pane1.itemForUri('b')).toBeFalsy()
+        expect(pane2.itemForUri('b')).not.toBeFalsy()
+        expect(atom.workspaceView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
+
+      it "handles split: left by opening to the left pane when necessary", ->
+        atom.workspaceView.openSingletonSync('b', split: 'right')
+        pane2 = atom.workspaceView.getActivePane()
+        expect(pane2[0]).not.toBe pane1[0]
+
+        atom.workspaceView.openSingletonSync('file1', split: 'left')
+
+        activePane = atom.workspaceView.getActivePane()
+        expect(activePane[0]).toBe pane1[0]
+
+        expect(pane1.itemForUri('file1')).toBeTruthy()
+        expect(pane2.itemForUri('file1')).toBeFalsy()
+        expect(atom.workspaceView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
+
+        pane2.focus()
+        expect(atom.workspaceView.getActivePane()[0]).toBe pane2[0]
+
+        atom.workspaceView.openSingletonSync('file1', split: 'left')
+        activePane = atom.workspaceView.getActivePane()
+        expect(activePane[0]).toBe pane1[0]
+        expect(atom.workspaceView.panes.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
+
+      it "reuses the file when already open", ->
+        atom.workspaceView.openSync('b')
+        atom.workspaceView.openSingletonSync('b', split: 'right')
+        expect(atom.workspaceView.panes.find('.pane').toArray()).toEqual [pane1[0]]
+
+  describe ".open(filePath)", ->
+    beforeEach ->
+      spyOn(Pane.prototype, 'focus')
+
+    describe "when there is no active pane", ->
+      beforeEach ->
+        atom.workspaceView.getActivePane().remove()
+        expect(atom.workspaceView.getActivePane()).toBeUndefined()
+
+      describe "when called with no path", ->
+        it "creates a empty edit session as an item on a new pane, and focuses the pane", ->
+          editor = null
+
+          waitsForPromise ->
+            atom.workspaceView.open().then (o) -> editor = o
+
+          runs ->
+            expect(atom.workspaceView.getActivePane().activeItem).toBe editor
+            expect(editor.getPath()).toBeUndefined()
+            expect(atom.workspaceView.getActivePane().focus).toHaveBeenCalled()
+
+        it "can create multiple empty edit sessions as items on a pane", ->
+          editor1 = null
+          editor2 = null
+
+          waitsForPromise ->
+            atom.workspaceView.open()
+              .then (o) ->
+                editor1 = o
+                atom.workspaceView.open()
+              .then (o) ->
+                editor2 = o
+
+          runs ->
+            expect(atom.workspaceView.getActivePane().getItems().length).toBe 2
+            expect(editor1).not.toBe editor2
+
+      describe "when called with a path", ->
+        it "creates an edit session for the given path as an item on a new pane, and focuses the pane", ->
+          editor = null
+          waitsForPromise ->
+            atom.workspaceView.open('b').then (o) -> editor = o
+
+          runs ->
+            expect(atom.workspaceView.getActivePane().activeItem).toBe editor
+            expect(editor.getPath()).toBe require.resolve('./fixtures/dir/b')
+            expect(atom.workspaceView.getActivePane().focus).toHaveBeenCalled()
+
+    describe "when there is an active pane", ->
+      [activePane] = []
+
+      beforeEach ->
+        activePane = atom.workspaceView.getActivePane()
+
+      describe "when called with no path", ->
+        it "opens an edit session with an empty buffer as an item in the active pane and focuses it", ->
+          editor = null
+
+          waitsForPromise ->
+            atom.workspaceView.open().then (o) -> editor = o
+
+          runs ->
+            expect(activePane.getItems().length).toBe 2
+            expect(activePane.activeItem).toBe editor
+            expect(editor.getPath()).toBeUndefined()
+            expect(activePane.focus).toHaveBeenCalled()
+
+      describe "when called with a path", ->
+        describe "when the active pane already has an item for the given path", ->
+          it "shows the existing edit session in the pane", ->
+            previousEditor = activePane.activeItem
+
+            editor = null
+            waitsForPromise ->
+              atom.workspaceView.open('b').then (o) -> editor = o
+
+            runs ->
+              expect(activePane.activeItem).toBe editor
+              expect(editor).not.toBe previousEditor
+
+            waitsForPromise ->
+              atom.workspaceView.open(previousEditor.getPath()).then (o) -> editor = o
+
+            runs ->
+              expect(editor).toBe previousEditor
+              expect(activePane.activeItem).toBe editor
+              expect(activePane.focus).toHaveBeenCalled()
+
+        describe "when the active pane does not have an existing item for the given path", ->
+          it "creates a new edit session for the given path in the active pane", ->
+            editor = null
+
+            waitsForPromise ->
+              atom.workspaceView.open('b').then (o) -> editor = o
+
+            runs ->
+              expect(activePane.activeItem).toBe editor
+              expect(activePane.getItems().length).toBe 2
+              expect(activePane.focus).toHaveBeenCalled()
+
+  describe "window:toggle-invisibles event", ->
+    it "shows/hides invisibles in all open and future editors", ->
+      atom.workspaceView.height(200)
+      atom.workspaceView.attachToDom()
+      rightEditor = atom.workspaceView.getActiveView()
+      rightEditor.setText(" \t ")
+      leftEditor = rightEditor.splitLeft()
+      expect(rightEditor.find(".line:first").text()).toBe "    "
+      expect(leftEditor.find(".line:first").text()).toBe "    "
+
+      withInvisiblesShowing = "#{rightEditor.invisibles.space}#{rightEditor.invisibles.tab} #{rightEditor.invisibles.space}#{rightEditor.invisibles.eol}"
+
+      atom.workspaceView.trigger "window:toggle-invisibles"
+      expect(rightEditor.find(".line:first").text()).toBe withInvisiblesShowing
+      expect(leftEditor.find(".line:first").text()).toBe withInvisiblesShowing
+
+      lowerLeftEditor = leftEditor.splitDown()
+      expect(lowerLeftEditor.find(".line:first").text()).toBe withInvisiblesShowing
+
+      atom.workspaceView.trigger "window:toggle-invisibles"
+      expect(rightEditor.find(".line:first").text()).toBe "    "
+      expect(leftEditor.find(".line:first").text()).toBe "    "
+
+      lowerRightEditor = rightEditor.splitDown()
+      expect(lowerRightEditor.find(".line:first").text()).toBe "    "
+
+  describe ".eachEditorView(callback)", ->
+    beforeEach ->
+      atom.workspaceView.attachToDom()
+
+    it "invokes the callback for existing editor", ->
+      count = 0
+      callbackEditor = null
+      callback = (editor) ->
+        callbackEditor = editor
+        count++
+      atom.workspaceView.eachEditorView(callback)
+      expect(count).toBe 1
+      expect(callbackEditor).toBe atom.workspaceView.getActiveView()
+
+    it "invokes the callback for new editor", ->
+      count = 0
+      callbackEditor = null
+      callback = (editor) ->
+        callbackEditor = editor
+        count++
+
+      atom.workspaceView.eachEditorView(callback)
+      count = 0
+      callbackEditor = null
+      atom.workspaceView.getActiveView().splitRight()
+      expect(count).toBe 1
+      expect(callbackEditor).toBe atom.workspaceView.getActiveView()
+
+    it "returns a subscription that can be disabled", ->
+      count = 0
+      callback = (editor) -> count++
+
+      subscription = atom.workspaceView.eachEditorView(callback)
+      expect(count).toBe 1
+      atom.workspaceView.getActiveView().splitRight()
+      expect(count).toBe 2
+      subscription.off()
+      atom.workspaceView.getActiveView().splitRight()
+      expect(count).toBe 2

src/atom-package.coffee

@@ -212,18 +212,18 @@ class AtomPackage extends Package
 
   registerDeferredDeserializers: ->
     for deserializerName in @metadata.deferredDeserializers ? []
-      registerDeferredDeserializer deserializerName, =>
+      atom.deserializers.addDeferred deserializerName, =>
         @activateStylesheets()
         @requireMainModule()
 
   subscribeToActivationEvents: ->
     return unless @metadata.activationEvents?
     if _.isArray(@metadata.activationEvents)
-      rootView.command(event, @handleActivationEvent) for event in @metadata.activationEvents
+      atom.workspaceView.command(event, @handleActivationEvent) for event in @metadata.activationEvents
     else if _.isString(@metadata.activationEvents)
-      rootView.command(@metadata.activationEvents, @handleActivationEvent)
+      atom.workspaceView.command(@metadata.activationEvents, @handleActivationEvent)
     else
-      rootView.command(event, selector, @handleActivationEvent) for event, selector of @metadata.activationEvents
+      atom.workspaceView.command(event, selector, @handleActivationEvent) for event, selector of @metadata.activationEvents
 
   handleActivationEvent: (event) =>
     bubblePathEventHandlers = @disableEventHandlersOnBubblePath(event)
@@ -234,11 +234,11 @@ class AtomPackage extends Package
 
   unsubscribeFromActivationEvents: ->
     if _.isArray(@metadata.activationEvents)
-      rootView.off(event, @handleActivationEvent) for event in @metadata.activationEvents
+      atom.workspaceView.off(event, @handleActivationEvent) for event in @metadata.activationEvents
     else if _.isString(@metadata.activationEvents)
-      rootView.off(@metadata.activationEvents, @handleActivationEvent)
+      atom.workspaceView.off(@metadata.activationEvents, @handleActivationEvent)
     else
-      rootView.off(event, selector, @handleActivationEvent) for event, selector of @metadata.activationEvents
+      atom.workspaceView.off(event, selector, @handleActivationEvent) for event, selector of @metadata.activationEvents
 
   disableEventHandlersOnBubblePath: (event) ->
     bubblePathEventHandlers = []

src/atom.coffee

@@ -1,49 +1,53 @@
-#TODO remove once all packages have been updated
-{Emitter} = require 'emissary'
-Emitter::one = (args...) -> @once(args...)
-Emitter::trigger = (args...) -> @emit(args...)
-Emitter::subscriptionCount = (args...) -> @getSubscriptionCount(args...)
-
-#TODO remove once all packages have been updated
-fs = require 'fs-plus'
-fs.exists = fs.existsSync
-fs.makeTree = fs.makeTreeSync
-fs.move = fs.moveSync
-fs.read = (filePath) -> fs.readFileSync(filePath, 'utf8')
-fs.remove = fs.removeSync
-fs.write = fs.writeFile
-fs.writeSync = fs.writeFileSync
-
-fs = require 'fs-plus'
-{$} = require './space-pen-extensions'
-_ = require 'underscore-plus'
-Package = require './package'
+crypto = require 'crypto'
 ipc = require 'ipc'
+keytar = require 'keytar'
+os = require 'os'
+path = require 'path'
 remote = require 'remote'
 shell = require 'shell'
-crypto = require 'crypto'
-path = require 'path'
-os = require 'os'
 dialog = remote.require 'dialog'
 app = remote.require 'app'
+
+_ = require 'underscore-plus'
 {Document} = require 'telepath'
-DeserializerManager = require './deserializer-manager'
+fs = require 'fs-plus'
 {Subscriber} = require 'emissary'
+
+{$} = require './space-pen-extensions'
+DeserializerManager = require './deserializer-manager'
+Package = require './package'
 SiteShim = require './site-shim'
+WindowEventHandler = require './window-event-handler'
 
 # Public: Atom global for dealing with packages, themes, menus, and the window.
 #
 # An instance of this class is always available as the `atom` global.
+#
+# ## Useful properties available:
+#
+#  * `atom.config`      - A {Config} instance
+#  * `atom.contextMenu` - A {ContextMenuManager} instance
+#  * `atom.keymap`      - A {Keymap} instance
+#  * `atom.menu`        - A {MenuManager} instance
+#  * `atom.workspaceView`    - A {WorkspaceView} instance
+#  * `atom.packages`    - A {PackageManager} instance
+#  * `atom.pasteboard`  - A {Pasteboard} instance
+#  * `atom.project`     - A {Project} instance
+#  * `atom.syntax`      - A {Syntax} instance
+#  * `atom.themes`      - A {ThemeManager} instance
 module.exports =
 class Atom
   Subscriber.includeInto(this)
 
+  # Private:
   constructor: ->
-    @rootViewParentSelector = 'body'
+    @workspaceViewParentSelector = 'body'
     @deserializers = new DeserializerManager()
 
+  # Private: Initialize all the properties in this object.
   initialize: ->
     @unsubscribe()
+    @setBodyPlatformClass()
 
     {devMode, resourcePath} = atom.getLoadSettings()
     configDirPath = @getConfigDirPath()
@@ -66,8 +70,17 @@ class Atom
     @contextMenu = new ContextMenuManager(devMode)
     @menu = new MenuManager({resourcePath})
     @pasteboard = new Pasteboard()
-    @syntax = deserialize(@getWindowState('syntax')) ? new Syntax()
+    @syntax = @deserializers.deserialize(@getWindowState('syntax')) ? new Syntax()
 
+  # Private: This method is called in any window needing a general environment, including specs
+  setUpEnvironment: (@windowMode) ->
+    @initialize()
+
+  # Private:
+  setBodyPlatformClass: ->
+    document.body.classList.add("platform-#{process.platform}")
+
+  # Public: Get the current window
   getCurrentWindow: ->
     remote.getCurrentWindow()
 
@@ -102,6 +115,7 @@ class Atom
     else
       browserWindow.center()
 
+  # Private:
   restoreDimensions: ->
     dimensions = @getWindowState().getObject('dimensions')
     unless dimensions?.width and dimensions?.height
@@ -118,6 +132,7 @@ class Atom
     @loadSettings ?= _.deepClone(@getCurrentWindow().loadSettings)
     _.deepClone(@loadSettings)
 
+  # Private:
   deserializeProject: ->
     Project = require './project'
     @project = @getWindowState('project')
@@ -125,46 +140,88 @@ class Atom
       @project = new Project(path: @getLoadSettings().initialPath)
       @setWindowState('project', @project)
 
-  deserializeRootView: ->
-    RootView = require './root-view'
+  # Private:
+  deserializeWorkspaceView: ->
+    WorkspaceView = require './workspace-view'
     state = @getWindowState()
-    @rootView = deserialize(state.get('rootView'))
-    unless @rootView?
-      @rootView = new RootView()
-      state.set('rootView', @rootView.getState())
-    $(@rootViewParentSelector).append(@rootView)
+    @workspaceView = @deserializers.deserialize(state.get('workspaceView'))
+    unless @workspaceView?
+      @workspaceView = new WorkspaceView()
+      state.set('workspaceView', @workspaceView.getState())
+    $(@workspaceViewParentSelector).append(@workspaceView)
 
+  # Private:
   deserializePackageStates: ->
     state = @getWindowState()
     @packages.packageStates = state.getObject('packageStates') ? {}
     state.remove('packageStates')
 
-  #TODO Remove theses once packages have been migrated
-  getPackageState: (args...) -> @packages.getPackageState(args...)
-  setPackageState: (args...) -> @packages.setPackageState(args...)
-  activatePackages: (args...) -> @packages.activatePackages(args...)
-  activatePackage: (args...) -> @packages.activatePackage(args...)
-  deactivatePackages: (args...) -> @packages.deactivatePackages(args...)
-  deactivatePackage: (args...) -> @packages.deactivatePackage(args...)
-  getActivePackage: (args...) -> @packages.getActivePackage(args...)
-  isPackageActive: (args...) -> @packages.isPackageActive(args...)
-  getActivePackages: (args...) -> @packages.getActivePackages(args...)
-  loadPackages: (args...) -> @packages.loadPackages(args...)
-  loadPackage: (args...) -> @packages.loadPackage(args...)
-  unloadPackage: (args...) -> @packages.unloadPackage(args...)
-  resolvePackagePath: (args...) -> @packages.resolvePackagePath(args...)
-  isInternalPackage: (args...) -> @packages.isInternalPackage(args...)
-  getLoadedPackage: (args...) -> @packages.getLoadedPackage(args...)
-  isPackageLoaded: (args...) -> @packages.isPackageLoaded(args...)
-  getLoadedPackages: (args...) -> @packages.getLoadedPackages(args...)
-  isPackageDisabled: (args...) -> @packages.isPackageDisabled(args...)
-  getAvailablePackagePaths: (args...) -> @packages.getAvailablePackagePaths(args...)
-  getAvailablePackageNames: (args...) -> @packages.getAvailablePackageNames(args...)
-  getAvailablePackageMetadata: (args...)-> @packages.getAvailablePackageMetadata(args...)
+  # Private:
+  deserializeEditorWindow: ->
+    @deserializePackageStates()
+    @deserializeProject()
+    @deserializeWorkspaceView()
 
+  # Private: This method is only called when opening a real application window
+  startEditorWindow: ->
+    if process.platform is 'darwin'
+      CommandInstaller = require './command-installer'
+      CommandInstaller.installAtomCommand()
+      CommandInstaller.installApmCommand()
+
+    @windowEventHandler = new WindowEventHandler
+    @restoreDimensions()
+    @config.load()
+    @config.setDefaults('core', require('./workspace-view').configDefaults)
+    @config.setDefaults('editor', require('./editor-view').configDefaults)
+    @keymap.loadBundledKeymaps()
+    @themes.loadBaseStylesheets()
+    @packages.loadPackages()
+    @deserializeEditorWindow()
+    @packages.activate()
+    @keymap.loadUserKeymap()
+    @requireUserInitScript()
+    @menu.update()
+
+    $(window).on 'unload', =>
+      $(document.body).hide()
+      @unloadEditorWindow()
+      false
+
+    @displayWindow()
+
+  # Private:
+  unloadEditorWindow: ->
+    return if not @project and not @workspaceView
+
+    windowState = @getWindowState()
+    windowState.set('project', @project)
+    windowState.set('syntax', @syntax.serialize())
+    windowState.set('workspaceView', @workspaceView.serialize())
+    @packages.deactivatePackages()
+    windowState.set('packageStates', @packages.packageStates)
+    @saveWindowState()
+    @workspaceView.remove()
+    @project.destroy()
+    @windowEventHandler?.unsubscribe()
+    @windowState = null
+
+  # Set up the default event handlers and menus for a non-editor window.
+  #
+  # This can be used by packages to have a minimum level of keybindings and
+  # menus available when not using the standard editor window.
+  #
+  # This should only be called after setUpEnvironment() has been called.
+  setUpDefaultEvents: ->
+    @windowEventHandler = new WindowEventHandler
+    @keymap.loadBundledKeymaps()
+    @menu.update()
+
+  # Private:
   loadThemes: ->
     @themes.load()
 
+  # Private:
   watchThemes: ->
     @themes.on 'reloaded', =>
       # Only reload stylesheets from non-theme packages
@@ -172,91 +229,155 @@ class Atom
         pack.reloadStylesheets?()
       null
 
+  # Public: Open a new Atom window using the given options.
+  #
+  # Calling this method without an options parameter will open a prompt to pick
+  # a file/folder to open in the new window.
+  #
+  # * options
+  #   * pathsToOpen: A string array of paths to open
   open: (options) ->
     ipc.sendChannel('open', options)
 
-  confirm: (message, detailedMessage, buttonLabelsAndCallbacks...) ->
-    buttons = []
-    callbacks = []
-    while buttonLabelsAndCallbacks.length
-      do =>
-        buttons.push buttonLabelsAndCallbacks.shift()
-        callbacks.push buttonLabelsAndCallbacks.shift()
+  # Public: Open a confirm dialog.
+  #
+  # ## Example:
+  # ```coffeescript
+  #   atom.confirm
+  #      message: 'How you feeling?'
+  #      detailedMessage: 'Be honest.'
+  #      buttons:
+  #        Good: -> window.alert('good to hear')
+  #        Bad: ->  window.alert('bummer')
+  # ```
+  #
+  # * options:
+  #    + message: The string message to display.
+  #    + detailedMessage: The string detailed message to display.
+  #    + buttons: Either an array of strings or an object where the values
+  #      are callbacks to invoke when clicked.
+  #
+  # Returns the chosen index if buttons was an array or the return of the
+  # callback if buttons was an object.
+  confirm: ({message, detailedMessage, buttons}={}) ->
+    buttons ?= {}
+    if _.isArray(buttons)
+      buttonLabels = buttons
+    else
+      buttonLabels = Object.keys(buttons)
 
-    chosen = @confirmSync(message, detailedMessage, buttons)
-    callbacks[chosen]?()
-
-  confirmSync: (message, detailedMessage, buttons, browserWindow=@getCurrentWindow()) ->
-    dialog.showMessageBox browserWindow,
+    chosen = dialog.showMessageBox @getCurrentWindow(),
       type: 'info'
       message: message
       detail: detailedMessage
-      buttons: buttons
+      buttons: buttonLabels
 
+    if _.isArray(buttons)
+      chosen
+    else
+      callback = buttons[buttonLabels[chosen]]
+      callback?()
+
+  # Private:
   showSaveDialog: (callback) ->
     callback(showSaveDialogSync())
 
+  # Private:
   showSaveDialogSync: (defaultPath) ->
-    defaultPath ?= project?.getPath()
+    defaultPath ?= @project?.getPath()
     currentWindow = @getCurrentWindow()
     dialog.showSaveDialog currentWindow, {title: 'Save File', defaultPath}
 
+  # Public: Open the dev tools for the current window.
   openDevTools: ->
     @getCurrentWindow().openDevTools()
 
+  # Public: Toggle the visibility of the dev tools for the current window.
   toggleDevTools: ->
     @getCurrentWindow().toggleDevTools()
 
+  # Public: Reload the current window.
   reload: ->
     @getCurrentWindow().restart()
 
+  # Public: Focus the current window.
   focus: ->
     @getCurrentWindow().focus()
     $(window).focus()
 
+  # Public: Show the current window.
   show: ->
     @getCurrentWindow().show()
 
+  # Public: Hide the current window.
   hide: ->
     @getCurrentWindow().hide()
 
+  # Private: Schedule the window to be shown and focused on the next tick.
+  #
+  # This is done in a next tick to prevent a white flicker from occurring
+  # if called synchronously.
+  displayWindow: ->
+    setImmediate =>
+      @show()
+      @focus()
+      @setFullScreen(true) if @workspaceView.getState().get('fullScreen')
+
+  # Public: Close the current window.
   close: ->
     @getCurrentWindow().close()
 
+  # Private:
   exit: (status) -> app.exit(status)
 
+  # Public: Is the current window in development mode?
   inDevMode: ->
     @getLoadSettings().devMode
 
+  # Public: Is the current window running specs?
   inSpecMode: ->
     @getLoadSettings().isSpec
 
+  # Public: Toggle the full screen state of the current window.
   toggleFullScreen: ->
     @setFullScreen(!@isFullScreen())
 
+  # Public: Set the full screen state of the current window.
   setFullScreen: (fullScreen=false) ->
     @getCurrentWindow().setFullScreen(fullScreen)
 
+  # Public: Is the current window in full screen mode?
   isFullScreen: ->
     @getCurrentWindow().isFullScreen()
 
+  # Public: Get the version of the Atom application.
   getVersion: ->
     app.getVersion()
 
-  getHomeDirPath: ->
-    process.env[if process.platform is 'win32' then 'USERPROFILE' else 'HOME']
+  getGitHubAuthTokenName: ->
+    'Atom GitHub API Token'
 
-  getTempDirPath: ->
-    if process.platform is 'win32' then os.tmpdir() else '/tmp'
+  # 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
   getConfigDirPath: ->
     @configDirPath ?= fs.absolute('~/.atom')
 
   # Public: Get the directory path to Atom's storage area.
+  #
+  # Returns the absoluste path to ~/.atom/storage
   getStorageDirPath: ->
     @storageDirPath ?= path.join(@getConfigDirPath(), 'storage')
 
+  # Private:
   getWindowStatePath: ->
     switch @windowMode
       when 'spec'
@@ -272,12 +393,14 @@ class Atom
     else
       null
 
+  # Public: Set the window state of the given keypath to the value.
   setWindowState: (keyPath, value) ->
     windowState = @getWindowState()
     windowState.set(keyPath, value)
     windowState
 
-  loadWindowState: ->
+  # Private
+  loadSerializedWindowState: ->
     if windowStatePath = @getWindowStatePath()
       if fs.existsSync(windowStatePath)
         try
@@ -292,7 +415,10 @@ class Atom
     catch error
       console.warn "Error parsing window state: #{windowStatePath}", error.stack, error
 
-    doc = Document.deserialize(documentState) if documentState?
+  # Private:
+  loadWindowState: ->
+    serializedWindowState = @loadSerializedWindowState()
+    doc = Document.deserialize(serializedWindowState) if serializedWindowState?
     doc ?= Document.create()
     doc.registerModelClasses(require('./text-buffer'), require('./project'))
     # TODO: Remove this when everything is using telepath models
@@ -302,13 +428,15 @@ class Atom
       @site = new SiteShim(doc)
     doc
 
+  # Private:
   saveWindowState: ->
     windowState = @getWindowState()
     if windowStatePath = @getWindowStatePath()
       windowState.saveSync(windowStatePath)
     else
-      @getCurrentWindow().loadSettings.windowState = JSON.stringify(windowState.serialize())
+      @getCurrentWindow().loadSettings.windowState = JSON.stringify(windowState.serializeForPersistence())
 
+  # Public: Get the window state for the key path.
   getWindowState: (keyPath) ->
     @windowState ?= @loadWindowState()
     if keyPath
@@ -320,23 +448,31 @@ class Atom
   replicate: ->
     @getWindowState().replicate()
 
+  # Private:
   crashMainProcess: ->
     remote.process.crash()
 
+  # Private:
   crashRenderProcess: ->
     process.crash()
 
+  # Public: Visually and audibly trigger a beep.
   beep: ->
     shell.beep() if @config.get('core.audioBeep')
-    @rootView.trigger 'beep'
+    @workspaceView.trigger 'beep'
 
+  # Private:
   requireUserInitScript: ->
-    userInitScriptPath = path.join(@getConfigDirPath(), "user.coffee")
-    try
-      require userInitScriptPath if fs.isFileSync(userInitScriptPath)
-    catch error
-      console.error "Failed to load `#{userInitScriptPath}`", error.stack, error
+    if userInitScriptPath = fs.resolve(@getConfigDirPath(), 'user', ['js', 'coffee'])
+      try
+        require userInitScriptPath
+      catch error
+        console.error "Failed to load `#{userInitScriptPath}`", error.stack, error
 
+  # Public: Require the module with the given globals.
+  #
+  # The globals will be set on the `window` object and removed after the
+  # require completes.
   requireWithGlobals: (id, globals={}) ->
     existingGlobals = {}
     for key, value of globals

src/browser/application-menu.coffee

@@ -137,7 +137,7 @@ class ApplicationMenu
     modifiers.push("Shift") if key != key.toLowerCase()
     modifiers = modifiers.map (modifier) ->
       modifier.replace(/shift/ig, "Shift")
-              .replace(/meta/ig, "Command")
+              .replace(/cmd/ig, "Command")
               .replace(/ctrl/ig, "Ctrl")
               .replace(/alt/ig, "Alt")
 

src/browser/atom-application.coffee

@@ -138,7 +138,7 @@ class AtomApplication
     @on 'application:zoom', -> Menu.sendActionToFirstResponder('zoom:')
     @on 'application:bring-all-windows-to-front', -> Menu.sendActionToFirstResponder('arrangeInFront:')
     @on 'application:inspect', ({x,y}) -> @focusedWindow().browserWindow.inspectElement(x, y)
-    @on 'application:open-documentation', -> shell.openExternal('https://github-atom-io.herokuapp.com/docs/latest/?app=true')
+    @on 'application:open-documentation', -> shell.openExternal('https://www.atom.io/docs/latest/?app')
     @on 'application:report-issue', -> shell.openExternal('https://github.com/atom/atom/issues/new')
     @on 'application:show-settings', ->
       if @focusedWindow()
@@ -245,6 +245,14 @@ class AtomApplication
   #    + initialSize:
   #      Object with height and width keys.
   openPath: ({pathToOpen, pidToKillWhenClosed, newWindow, devMode, initialSize}={}) ->
+    if devMode and not fs.existsSync(global.devResourcePath)
+      dialog.showMessageBox
+        type: 'warning'
+        buttons: ['OK']
+        message: 'Atom source directory not found.'
+        detail: 'To run a window in dev mode you need to have the atom/atom repo cloned to ~/github/atom'
+      return
+
     if pathToOpen
       [basename, initialLine] = path.basename(pathToOpen).split(':')
       if initialLine
@@ -349,8 +357,8 @@ class AtomApplication
   #      A Boolean which controls whether any newly opened windows should  be in
   #      dev mode or not.
   promptForPath: ({devMode}={}) ->
-    pathsToOpen = dialog.showOpenDialog title: 'Open', properties: ['openFile', 'openDirectory', 'multiSelections', 'createDirectory']
-    @openPaths({pathsToOpen, devMode})
+    dialog.showOpenDialog title: 'Open', properties: ['openFile', 'openDirectory', 'multiSelections', 'createDirectory'], (pathsToOpen) =>
+      @openPaths({pathsToOpen, devMode})
 
   # Public: If an update is available, it returns the new version string
   # otherwise it returns null.

src/browser/atom-window.coffee

@@ -10,7 +10,7 @@ _ = require 'underscore-plus'
 # Private:
 module.exports =
 class AtomWindow
-  @iconPath: path.resolve(__dirname, '..', '..', 'atom.png')
+  @iconPath: path.resolve(__dirname, '..', '..', 'resources', 'atom.png')
 
   browserWindow: null
   loaded: null
@@ -70,7 +70,7 @@ class AtomWindow
       chosen = dialog.showMessageBox @browserWindow,
         type: 'warning'
         buttons: ['Close', 'Keep Waiting']
-        message: 'Editor is not responsing'
+        message: 'Editor is not responding'
         detail: 'The editor is not responding. Would you like to force close it or just keep waiting?'
       @browserWindow.destroy() if chosen is 0
 

src/browser/context-menu.coffee

@@ -1,5 +1,6 @@
 Menu = require 'menu'
 
+# Private:
 module.exports =
 class ContextMenu
   constructor: (template, browserWindow) ->

src/browser/main.coffee

@@ -67,9 +67,7 @@ delegate.browserMainParts.preMainMessageLoopRun = ->
 global.devResourcePath = path.join(app.getHomeDir(), 'github', 'atom')
 
 setupCrashReporter = ->
-  crashReporter.setCompanyName 'GitHub'
-  crashReporter.setSubmissionUrl 'https://speakeasy.githubapp.com/submit_crash_log'
-  crashReporter.setAutoSubmit true
+  crashReporter.start(productName: 'Atom', companyName: 'GitHub')
 
 setupAutoUpdater = ->
   autoUpdater.setFeedUrl 'https://speakeasy.githubapp.com/apps/27/appcast.xml'
@@ -92,11 +90,11 @@ parseCommandLine = ->
   options.alias('w', 'wait').boolean('w').describe('w', 'Wait for window to be closed before returning.')
   args = options.argv
 
-  if args.h
+  if args.help
     process.stdout.write(options.help())
     process.exit(0)
 
-  if args.v
+  if args.version
     process.stdout.write("#{version}\n")
     process.exit(0)
 

src/command-installer.coffee

@@ -32,10 +32,10 @@ module.exports =
       callback = commandName
       commandName = path.basename(commandPath, path.extname(commandPath))
 
-    installCallback = (error) ->
+    installCallback = (error, sourcePath, destinationPath) ->
       if error?
         console.warn "Failed to install `#{commandName}` binary", error
-      callback?(error)
+      callback?(error, sourcePath, destinationPath)
 
     @findInstallDirectory (directory) ->
       if directory?
@@ -44,6 +44,25 @@ module.exports =
           if error?
             installCallback(error)
           else
-            symlinkCommand(commandPath, destinationPath, installCallback)
+            symlinkCommand commandPath, destinationPath, (error) ->
+              installCallback(error, commandPath, destinationPath)
       else
         installCallback(new Error("No destination directory exists to install"))
+
+  installAtomCommand: (resourcePath, callback) ->
+    if _.isFunction(resourcePath)
+      callback = resourcePath
+      resourcePath = null
+
+    resourcePath ?= atom.getLoadSettings().resourcePath
+    commandPath = path.join(resourcePath, 'atom.sh')
+    @install(commandPath, callback)
+
+  installApmCommand: (resourcePath, callback) ->
+    if _.isFunction(resourcePath)
+      callback = resourcePath
+      resourcePath = null
+
+    resourcePath ?= atom.getLoadSettings().resourcePath
+    commandPath = path.join(resourcePath, 'node_modules', '.bin', 'apm')
+    @install(commandPath, callback)

src/config-observer.coffee

@@ -5,5 +5,5 @@ module.exports =
 
   unobserveConfig: ->
     if @configSubscriptions?
-      subscription.cancel() for keyPath, subscription of @configSubscriptions
+      subscription.off() for keyPath, subscription of @configSubscriptions
       @configSubscriptions = null

src/config.coffee

@@ -125,11 +125,11 @@ class Config
   #
   # keyPath - The {String} name of the key to retrieve
   # defaultValue - The integer {Number} to fall back to if the value isn't
-  #                positive
+  #                positive, defaults to 0.
   #
   # Returns the value from Atom's default settings, the user's configuration file,
   # or `defaultValue` if the key value isn't greater than zero.
-  getPositiveInt: (keyPath, defaultValue) ->
+  getPositiveInt: (keyPath, defaultValue=0) ->
     Math.max(@getInt(keyPath), 0) or defaultValue
 
   # Public: Sets the value for a configuration setting.
@@ -216,8 +216,7 @@ class Config
         callback(value, {previous})
 
     eventName = "updated.#{keyPath.replace(/\./, '-')}"
-    subscription = { cancel: => @off eventName, updateCallback  }
-    @on eventName, updateCallback
+    subscription = @on eventName, updateCallback
     callback(value) if options.callNow ? true
     subscription
 

src/context-menu-manager.coffee

@@ -14,7 +14,7 @@ class ContextMenuManager
     @devModeDefinitions = {}
     @activeElement = null
 
-    @devModeDefinitions['#root-view'] = [
+    @devModeDefinitions['.workspace'] = [
       label: 'Inspect Element'
       command: 'application:inspect'
       executeAtBuild: (e) ->

src/cursor-view.coffee

@@ -9,14 +9,14 @@ class CursorView extends View
     @div class: 'cursor idle', => @raw ' '
 
   blinkPeriod: 800
-  editor: null
+  editorView: null
   visible: true
 
   needsUpdate: true
   needsRemoval: false
   shouldPauseBlinking: false
 
-  initialize: (@cursor, @editor) ->
+  initialize: (@cursor, @editorView) ->
     @cursor.on 'moved.cursor-view', =>
       @needsUpdate = true
       @shouldPauseBlinking = true
@@ -25,7 +25,7 @@ class CursorView extends View
       @needsUpdate = true
 
     @cursor.on 'autoscrolled.cursor-view', =>
-      @editor.requestDisplayUpdate()
+      @editorView.requestDisplayUpdate()
 
     @cursor.on 'destroyed.cursor-view', =>
       @needsRemoval = true
@@ -34,7 +34,7 @@ class CursorView extends View
       @addClass("site-#{@cursor.marker.getOriginSiteId()}")
 
   beforeRemove: ->
-    @editor.removeCursorView(this)
+    @editorView.removeCursorView(this)
     @cursor.off('.cursor-view')
     @stopBlinking()
 
@@ -52,7 +52,7 @@ class CursorView extends View
     else if !@startBlinkingTimeout
       @startBlinking()
 
-    @setVisible(@cursor.isVisible() and not @editor.isFoldedAtScreenRow(screenPosition.row))
+    @setVisible(@cursor.isVisible() and not @editorView.isFoldedAtScreenRow(screenPosition.row))
 
   # Override for speed. The base function checks the computedStyle
   isHidden: ->
@@ -69,7 +69,7 @@ class CursorView extends View
     @cursor.clearAutoscroll()
 
   getPixelPosition: ->
-    @editor.pixelPositionForScreenPosition(@getScreenPosition())
+    @editorView.pixelPositionForScreenPosition(@getScreenPosition())
 
   setVisible: (visible) ->
     unless @visible == visible

src/cursor.coffee

@@ -5,7 +5,7 @@ _ = require 'underscore-plus'
 # Public: The `Cursor` class represents the little blinking line identifying
 # where text can be inserted.
 #
-# Cursors belong to {EditSession}s and have some metadata attached in the form
+# Cursors belong to {Editor}s and have some metadata attached in the form
 # of a {StringMarker}.
 module.exports =
 class Cursor
@@ -17,8 +17,8 @@ class Cursor
   visible: true
   needsAutoscroll: null
 
-  # Private: Instantiated by an {EditSession}
-  constructor: ({@editSession, @marker}) ->
+  # Private: Instantiated by an {Editor}
+  constructor: ({@editor, @marker}) ->
     @updateVisibility()
     @marker.on 'changed', (e) =>
       @updateVisibility()
@@ -37,10 +37,10 @@ class Cursor
         textChanged: textChanged
 
       @emit 'moved', movedEvent
-      @editSession.emit 'cursor-moved', movedEvent
+      @editor.emit 'cursor-moved', movedEvent
     @marker.on 'destroyed', =>
       @destroyed = true
-      @editSession.removeCursor(this)
+      @editor.removeCursor(this)
       @emit 'destroyed'
     @needsAutoscroll = true
 
@@ -62,7 +62,7 @@ class Cursor
   #   An {Array} of two numbers: the screen row, and the screen column.
   # * options:
   #    + autoscroll:
-  #      A Boolean which, if `true`, scrolls the {EditSession} to wherever the
+  #      A Boolean which, if `true`, scrolls the {Editor} to wherever the
   #      cursor moves to.
   setScreenPosition: (screenPosition, options={}) ->
     @changePosition options, =>
@@ -78,7 +78,7 @@ class Cursor
   #   An {Array} of two numbers: the buffer row, and the buffer column.
   # * options:
   #    + autoscroll:
-  #      A Boolean which, if `true`, scrolls the {EditSession} to wherever the
+  #      A Boolean which, if `true`, scrolls the {Editor} to wherever the
   #      cursor moves to.
   setBufferPosition: (bufferPosition, options={}) ->
     @changePosition options, =>
@@ -118,13 +118,13 @@ class Cursor
       segments.push("[#{_.escapeRegExp(nonWordCharacters)}]+")
     new RegExp(segments.join("|"), "g")
 
-  # Public: Identifies if this cursor is the last in the {EditSession}.
+  # Public: Identifies if this cursor is the last in the {Editor}.
   #
   # "Last" is defined as the most recently added cursor.
   #
   # Returns a Boolean.
   isLastCursor: ->
-    this == @editSession.getCursor()
+    this == @editor.getCursor()
 
   # Public: Identifies if the cursor is surrounded by whitespace.
   #
@@ -135,7 +135,7 @@ class Cursor
   isSurroundedByWhitespace: ->
     {row, column} = @getBufferPosition()
     range = [[row, Math.min(0, column - 1)], [row, Math.max(0, column + 1)]]
-    /^\s+$/.test @editSession.getTextInBufferRange(range)
+    /^\s+$/.test @editor.getTextInBufferRange(range)
 
   # Public: Returns whether the cursor is currently between a word and non-word
   # character. The non-word characters are defined by the
@@ -150,7 +150,7 @@ class Cursor
 
     {row, column} = @getBufferPosition()
     range = [[row, column - 1], [row, column + 1]]
-    [before, after] = @editSession.getTextInBufferRange(range)
+    [before, after] = @editor.getTextInBufferRange(range)
     return false if /\s/.test(before) or /\s/.test(after)
 
     nonWordCharacters = atom.config.get('editor.nonWordCharacters').split('')
@@ -160,7 +160,7 @@ class Cursor
   isInsideWord: ->
     {row, column} = @getBufferPosition()
     range = [[row, column], [row, Infinity]]
-    @editSession.getTextInBufferRange(range).search(@wordRegExp()) == 0
+    @editor.getTextInBufferRange(range).search(@wordRegExp()) == 0
 
   # Public: Prevents this cursor from causing scrolling.
   clearAutoscroll: ->
@@ -189,7 +189,7 @@ class Cursor
   # Public: Returns the cursor's current buffer row of text excluding its line
   # ending.
   getCurrentBufferLine: ->
-    @editSession.lineForBufferRow(@getBufferRow())
+    @editor.lineForBufferRow(@getBufferRow())
 
   # Public: Moves the cursor up one screen row.
   moveUp: (rowCount = 1, {moveToEndOfSelection}={}) ->
@@ -248,7 +248,7 @@ class Cursor
 
   # Public: Moves the cursor to the bottom of the buffer.
   moveToBottom: ->
-    @setBufferPosition(@editSession.getEofBufferPosition())
+    @setBufferPosition(@editor.getEofBufferPosition())
 
   # Public: Moves the cursor to the beginning of the screen line.
   moveToBeginningOfLine: ->
@@ -258,7 +258,7 @@ class Cursor
   # line.
   moveToFirstCharacterOfLine: ->
     {row, column} = @getScreenPosition()
-    screenline = @editSession.lineForScreenRow(row)
+    screenline = @editor.lineForScreenRow(row)
 
     goalColumn = screenline.text.search(/\S/)
     return if goalColumn == -1
@@ -272,7 +272,7 @@ class Cursor
     position = @getBufferPosition()
     scanRange = @getCurrentLineBufferRange()
     endOfLeadingWhitespace = null
-    @editSession.scanInBufferRange /^[ \t]*/, scanRange, ({range}) =>
+    @editor.scanInBufferRange /^[ \t]*/, scanRange, ({range}) =>
       endOfLeadingWhitespace = range.end
 
     @setBufferPosition(endOfLeadingWhitespace) if endOfLeadingWhitespace.isGreaterThan(position)
@@ -318,11 +318,11 @@ class Cursor
   getBeginningOfCurrentWordBufferPosition: (options = {}) ->
     allowPrevious = options.allowPrevious ? true
     currentBufferPosition = @getBufferPosition()
-    previousNonBlankRow = @editSession.buffer.previousNonBlankRow(currentBufferPosition.row)
+    previousNonBlankRow = @editor.buffer.previousNonBlankRow(currentBufferPosition.row)
     scanRange = [[previousNonBlankRow, 0], currentBufferPosition]
 
     beginningOfWordPosition = null
-    @editSession.backwardsScanInBufferRange (options.wordRegex ? @wordRegExp(options)), scanRange, ({range, stop}) =>
+    @editor.backwardsScanInBufferRange (options.wordRegex ? @wordRegExp(options)), scanRange, ({range, stop}) =>
       if range.end.isGreaterThanOrEqual(currentBufferPosition) or allowPrevious
         beginningOfWordPosition = range.start
       if not beginningOfWordPosition?.isEqual(currentBufferPosition)
@@ -334,11 +334,11 @@ class Cursor
   # the current word, or the previous word.
   getPreviousWordBoundaryBufferPosition: (options = {}) ->
     currentBufferPosition = @getBufferPosition()
-    previousNonBlankRow = @editSession.buffer.previousNonBlankRow(currentBufferPosition.row)
+    previousNonBlankRow = @editor.buffer.previousNonBlankRow(currentBufferPosition.row)
     scanRange = [[previousNonBlankRow, 0], currentBufferPosition]
 
     beginningOfWordPosition = null
-    @editSession.backwardsScanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) =>
+    @editor.backwardsScanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) =>
       if range.start.row < currentBufferPosition.row and currentBufferPosition.column > 0
         # force it to stop at the beginning of each line
         beginningOfWordPosition = new Point(currentBufferPosition.row, 0)
@@ -356,10 +356,10 @@ class Cursor
   # the current word, or the previous word.
   getMoveNextWordBoundaryBufferPosition: (options = {}) ->
     currentBufferPosition = @getBufferPosition()
-    scanRange = [currentBufferPosition, @editSession.getEofBufferPosition()]
+    scanRange = [currentBufferPosition, @editor.getEofBufferPosition()]
 
     endOfWordPosition = null
-    @editSession.scanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) =>
+    @editor.scanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) =>
       if range.start.row > currentBufferPosition.row
         # force it to stop at the beginning of each line
         endOfWordPosition = new Point(range.start.row, 0)
@@ -386,10 +386,10 @@ class Cursor
   getEndOfCurrentWordBufferPosition: (options = {}) ->
     allowNext = options.allowNext ? true
     currentBufferPosition = @getBufferPosition()
-    scanRange = [currentBufferPosition, @editSession.getEofBufferPosition()]
+    scanRange = [currentBufferPosition, @editor.getEofBufferPosition()]
 
     endOfWordPosition = null
-    @editSession.scanInBufferRange (options.wordRegex ? @wordRegExp(options)), scanRange, ({range, stop}) =>
+    @editor.scanInBufferRange (options.wordRegex ? @wordRegExp(options)), scanRange, ({range, stop}) =>
       if range.start.isLessThanOrEqual(currentBufferPosition) or allowNext
         endOfWordPosition = range.end
       if not endOfWordPosition?.isEqual(currentBufferPosition)
@@ -407,10 +407,10 @@ class Cursor
   getBeginningOfNextWordBufferPosition: (options = {}) ->
     currentBufferPosition = @getBufferPosition()
     start = if @isInsideWord() then @getEndOfCurrentWordBufferPosition() else currentBufferPosition
-    scanRange = [start, @editSession.getEofBufferPosition()]
+    scanRange = [start, @editor.getEofBufferPosition()]
 
     beginningOfNextWordPosition = null
-    @editSession.scanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) =>
+    @editor.scanInBufferRange (options.wordRegex ? @wordRegExp()), scanRange, ({range, stop}) =>
       beginningOfNextWordPosition = range.start
       stop()
 
@@ -432,7 +432,7 @@ class Cursor
   #    + includeNewline:
   #      A boolean which controls whether the Range should include the newline.
   getCurrentLineBufferRange: (options) ->
-    @editSession.bufferRangeForBufferRow(@getBufferRow(), options)
+    @editor.bufferRangeForBufferRow(@getBufferRow(), options)
 
   # Public: Retrieves the range for the current paragraph.
   #
@@ -440,11 +440,11 @@ class Cursor
   #
   # Returns a {Range}.
   getCurrentParagraphBufferRange: ->
-    @editSession.languageMode.rowRangeForParagraphAtBufferRow(@getBufferRow())
+    @editor.languageMode.rowRangeForParagraphAtBufferRow(@getBufferRow())
 
   # Public: Returns the characters preceeding the cursor in the current word.
   getCurrentWordPrefix: ->
-    @editSession.getTextInBufferRange([@getBeginningOfCurrentWordBufferPosition(), @getBufferPosition()])
+    @editor.getTextInBufferRange([@getBeginningOfCurrentWordBufferPosition(), @getBufferPosition()])
 
   # Public: Returns whether the cursor is at the start of a line.
   isAtBeginningOfLine: ->
@@ -452,8 +452,8 @@ class Cursor
 
   # Public: Returns the indentation level of the current line.
   getIndentLevel: ->
-    if @editSession.getSoftTabs()
-      @getBufferColumn() / @editSession.getTabLength()
+    if @editor.getSoftTabs()
+      @getBufferColumn() / @editor.getTabLength()
     else
       @getBufferColumn()
 
@@ -465,4 +465,16 @@ class Cursor
   #
   # Returns an {Array} of {String}s.
   getScopes: ->
-    @editSession.scopesForBufferPosition(@getBufferPosition())
+    @editor.scopesForBufferPosition(@getBufferPosition())
+
+  # Public: Returns true if this cursor has no non-whitespace characters before
+  # its current position.
+  hasPrecedingCharactersOnLine: ->
+    bufferPosition = @getBufferPosition()
+    line = @editor.lineForBufferRow(bufferPosition.row)
+    firstCharacterColumn = line.search(/\S/)
+
+    if firstCharacterColumn is -1
+      false
+    else
+      bufferPosition.column > firstCharacterColumn

src/deserializer-manager.coffee

@@ -1,21 +1,23 @@
 {Document} = require 'telepath'
 
 # Public: Manages the deserializers used for serialized state
+#
+# Should be accessed via `atom.deserializers`
 module.exports =
 class DeserializerManager
   constructor: ->
     @deserializers = {}
     @deferredDeserializers = {}
 
-  # Public: Add a deserializer.
+  # Public: Register the given class(es) as deserializers.
   add: (klasses...) ->
     @deserializers[klass.name] = klass for klass in klasses
 
-  # Public: Add a deferred deserializer.
+  # Public: Add a deferred deserializer for the given class name.
   addDeferred: (name, fn) ->
     @deferredDeserializers[name] = fn
 
-  # Public: Remove a deserializer.
+  # Public: Remove the given class(es) as deserializers.
   remove: (klasses...) ->
     delete @deserializers[klass.name] for klass in klasses
 
@@ -32,7 +34,7 @@ class DeserializerManager
     else
       console.warn "No deserializer found for", state
 
-  # Public: Get the deserializer for the state.
+  # Private: Get the deserializer for the state.
   get: (state) ->
     return unless state?
 

src/display-buffer.coffee

@@ -18,7 +18,7 @@ class DisplayBuffer
   _.extend @prototype, ConfigObserver
 
   @acceptsDocuments: true
-  registerDeserializer(this)
+  atom.deserializers.add(this)
   @version: 2
 
   @deserialize: (state) -> new this(state)
@@ -27,7 +27,7 @@ class DisplayBuffer
     if optionsOrState instanceof telepath.Document
       @state = optionsOrState
       @id = @state.get('id')
-      @tokenizedBuffer = deserialize(@state.get('tokenizedBuffer'))
+      @tokenizedBuffer = atom.deserializers.deserialize(@state.get('tokenizedBuffer'))
       @buffer = @tokenizedBuffer.buffer
     else
       {@buffer, softWrap, editorWidthInChars} = optionsOrState
@@ -584,12 +584,6 @@ class DisplayBuffer
       line = @lineForRow(row).text
       console.log row, line, line.length
 
-  getDebugSnapshot: ->
-    lines = ["Display Buffer:"]
-    for screenLine, row in @linesForRows(0, @getLastRow())
-      lines.push "#{row}: #{screenLine.text}"
-    lines.join('\n')
-
   ### Internal ###
 
   handleTokenizedBufferChange: (tokenizedBufferChange) =>

src/file.coffee

@@ -58,7 +58,7 @@ class File
     previouslyExisted = @exists()
     @cachedContents = text
     fs.writeFileSync(@getPath(), text)
-    @subscribeToNativeChangeEvents() if not previouslyExisted and @subscriptionCount() > 0
+    @subscribeToNativeChangeEvents() if not previouslyExisted and @hasSubscriptions()
 
   # Private: Deprecated
   readSync: (flushCache) ->
@@ -112,9 +112,11 @@ class File
   exists: ->
     fs.existsSync(@getPath())
 
+  # Private:
   setDigest: (contents) ->
     @digest = crypto.createHash('sha1').update(contents ? '').digest('hex')
 
+  # Public: Get the SHA-1 digest of this file
   getDigest: ->
     @digest ? @setDigest(@readSync())
 

src/git.coffee

@@ -12,7 +12,7 @@ GitUtils = require 'git-utils'
 # ## Example
 #
 # ```coffeescript
-# git = global.project.getRepo()
+# git = atom.project.getRepo()
 # console.log git.getOriginUrl()
 # ```
 module.exports =
@@ -61,7 +61,7 @@ class Git
 
     @statuses = {}
     @upstream = {ahead: 0, behind: 0}
-    {project, refreshOnWindowFocus} = options
+    {@project, refreshOnWindowFocus} = options
 
     refreshOnWindowFocus ?= true
     if refreshOnWindowFocus
@@ -70,8 +70,8 @@ class Git
         @refreshIndex()
         @refreshStatus()
 
-    if project?
-      @subscribe project.buffers.onEach (buffer) => @subscribeToBuffer(buffer)
+    if @project?
+      @subscribe @project.buffers.onEach (buffer) => @subscribeToBuffer(buffer)
 
   # Private: Subscribes to buffer events.
   subscribeToBuffer: (buffer) ->
@@ -145,7 +145,7 @@ class Git
   # Public: Returns true if at the root, false if in a subfolder of the
   # repository.
   isProjectAtRoot: ->
-    @projectAtRoot ?= project.relativize(@getWorkingDirectory()) is ''
+    @projectAtRoot ?= @project?.relativize(@getWorkingDirectory()) is ''
 
   # Public: Makes a path relative to the repository's working directory.
   relativize: (path) -> @getRepo().relativize(path)

src/gutter.coffee

@@ -2,7 +2,7 @@
 {Range} = require 'telepath'
 _ = require 'underscore-plus'
 
-# Private: Represents the portion of the {Editor} containing row numbers.
+# Private: Represents the portion of the {EditorView} containing row numbers.
 #
 # The gutter also indicates if rows are folded.
 module.exports =
@@ -25,37 +25,37 @@ class Gutter extends View
     @attached = true
 
     highlightLines = => @highlightLines()
-    @getEditor().on 'cursor:moved', highlightLines
-    @getEditor().on 'selection:changed', highlightLines
+    @getEditorView().on 'cursor:moved', highlightLines
+    @getEditorView().on 'selection:changed', highlightLines
     @on 'mousedown', (e) => @handleMouseEvents(e)
 
   beforeRemove: ->
-    $(document).off(".gutter-#{@getEditor().id}")
+    $(document).off(".gutter-#{@getEditorView().id}")
 
   handleMouseEvents: (e) ->
-    editor = @getEditor()
-    startRow = editor.screenPositionFromMouseEvent(e).row
+    editorView = @getEditorView()
+    startRow = editorView.screenPositionFromMouseEvent(e).row
     if e.shiftKey
-      editor.selectToScreenPosition([startRow + 1, 0])
+      editorView.selectToScreenPosition([startRow + 1, 0])
       return
     else
-      editor.getSelection().setScreenRange([[startRow, 0], [startRow, 0]])
+      editorView.getSelection().setScreenRange([[startRow, 0], [startRow, 0]])
 
     moveHandler = (e) =>
       start = startRow
-      end = editor.screenPositionFromMouseEvent(e).row
+      end = editorView.screenPositionFromMouseEvent(e).row
       if end > start then end++ else start++
-      editor.getSelection().setScreenRange([[start, 0], [end, 0]])
+      editorView.getSelection().setScreenRange([[start, 0], [end, 0]])
 
-    $(document).on "mousemove.gutter-#{@getEditor().id}", moveHandler
-    $(document).one "mouseup.gutter-#{@getEditor().id}", => $(document).off 'mousemove', moveHandler
+    $(document).on "mousemove.gutter-#{@getEditorView().id}", moveHandler
+    $(document).one "mouseup.gutter-#{@getEditorView().id}", => $(document).off 'mousemove', moveHandler
 
   ### Public ###
 
-  # Retrieves the containing {Editor}.
+  # Retrieves the containing {EditorView}.
   #
-  # Returns an {Editor}.
-  getEditor: ->
+  # Returns an {EditorView}.
+  getEditorView: ->
     @parentView
 
   # Defines whether to show the gutter or not.
@@ -192,9 +192,9 @@ class Gutter extends View
     @elementBuilder.children
 
   buildLineElementsHtml: (startScreenRow, endScreenRow) =>
-    editor = @getEditor()
-    maxDigits = editor.getLineCount().toString().length
-    rows = editor.bufferRowsForScreenRows(startScreenRow, endScreenRow)
+    editorView = @getEditorView()
+    maxDigits = editorView.getLineCount().toString().length
+    rows = editorView.bufferRowsForScreenRows(startScreenRow, endScreenRow)
 
     html = ''
     for row in rows
@@ -204,7 +204,7 @@ class Gutter extends View
         rowValue = (row + 1).toString()
 
       classes = "line-number line-number-#{row}"
-      classes += ' fold' if editor.isFoldedAtBufferRow(row)
+      classes += ' fold' if editorView.isFoldedAtBufferRow(row)
 
       rowValuePadding = _.multiplyString(' ', maxDigits - rowValue.length)
 
@@ -230,8 +230,8 @@ class Gutter extends View
       @highlightedLineNumbers.push(highlightedLineNumber)
 
   highlightLines: ->
-    if @getEditor().getSelection().isEmpty()
-      row = @getEditor().getCursorScreenPosition().row
+    if @getEditorView().getSelection().isEmpty()
+      row = @getEditorView().getCursorScreenPosition().row
       rowRange = new Range([row, 0], [row, 0])
       return if @selectionEmpty and @highlightedRows?.isEqual(rowRange)
 
@@ -240,7 +240,7 @@ class Gutter extends View
       @highlightedRows = rowRange
       @selectionEmpty = true
     else
-      selectedRows = @getEditor().getSelection().getScreenRange()
+      selectedRows = @getEditorView().getSelection().getScreenRange()
       endRow = selectedRows.end.row
       endRow-- if selectedRows.end.column is 0
       selectedRows = new Range([selectedRows.start.row, 0], [endRow, 0])

src/keymap.coffee

@@ -6,7 +6,7 @@ CSON = require 'season'
 KeyBinding = require './key-binding'
 {Emitter} = require 'emissary'
 
-Modifiers = ['alt', 'control', 'ctrl', 'shift', 'meta']
+Modifiers = ['alt', 'control', 'ctrl', 'shift', 'cmd']
 
 # Internal: Associates keymaps with actions.
 #
@@ -43,12 +43,29 @@ class Keymap
     keyBindings = @keyBindingsForKeystroke(keystroke)
     @keyBindingsMatchingElement(element, keyBindings)
 
+  # Public: Returns a array of {KeyBinding}s (sorted by selector specificity)
+  # that match a command.
+  #
+  # * command:
+  #   The string representing the command (tree-view:toggle)
+  # * element:
+  #   The DOM node that will match a {KeyBinding}'s selector.
+  keyBindingsForCommandMatchingElement: (command, element) ->
+    keyBindings = @keyBindingsForCommand(command)
+    @keyBindingsMatchingElement(element, keyBindings)
+
   # Public: Returns an array of {KeyBinding}s that match a keystroke
   # * keystroke:
   #   The string representing the keys pressed (e.g. ctrl-P)
   keyBindingsForKeystroke: (keystroke) ->
     keystroke = KeyBinding.normalizeKeystroke(keystroke)
-    keyBindings = @keyBindings.filter (keyBinding) -> keyBinding.matches(keystroke)
+    @keyBindings.filter (keyBinding) -> keyBinding.matches(keystroke)
+
+  # Public: Returns an array of {KeyBinding}s that match a command
+  # * keystroke:
+  #   The string representing the keys pressed (e.g. ctrl-P)
+  keyBindingsForCommand: (command) ->
+    @keyBindings.filter (keyBinding) -> keyBinding.command == command
 
   # Public: Returns a array of {KeyBinding}s (sorted by selector specificity)
   # whos selector matches the element.
@@ -76,10 +93,10 @@ class Keymap
     modifiers = []
     if event.altKey and key not in Modifiers
       modifiers.push 'alt'
+    if event.metaKey and key not in Modifiers
+      modifiers.push 'cmd'
     if event.ctrlKey and key not in Modifiers
       modifiers.push 'ctrl'
-    if event.metaKey and key not in Modifiers
-      modifiers.push 'meta'
 
     if event.shiftKey and key not in Modifiers
       isNamedKey = key.length > 1
@@ -124,7 +141,7 @@ class Keymap
 
   handleKeyEvent: (event) ->
     element = event.target
-    element = rootView if element == document.body
+    element = atom.workspaceView if element == document.body
     keystroke = @keystrokeStringForEvent(event, @queuedKeystroke)
     keyBindings = @keyBindingsForKeystrokeMatchingElement(keystroke, element)
 
@@ -142,15 +159,16 @@ class Keymap
       else
         if keyBinding.command is 'native!'
           shouldBubble = true
-        else if @triggerCommandEvent(element, keyBinding.command)
+        else if @triggerCommandEvent(element, keyBinding.command, event)
           shouldBubble = false
 
       break if shouldBubble?
 
     shouldBubble ? true
 
-  triggerCommandEvent: (element, commandName) ->
+  triggerCommandEvent: (element, commandName, event) ->
     commandEvent = $.Event(commandName)
+    commandEvent.originalEvent = event
     commandEvent.abortKeyBinding = -> commandEvent.stopImmediatePropagation()
     $(element).trigger(commandEvent)
     not commandEvent.isImmediatePropagationStopped()

src/language-mode.coffee

@@ -12,7 +12,7 @@ class LanguageMode
 
   buffer: null
   grammar: null
-  editSession: null
+  editor: null
   currentGrammarScore: null
 
   ### Internal ###
@@ -22,11 +22,11 @@ class LanguageMode
 
   ### Public ###
 
-  # Sets up a `LanguageMode` for the given {EditSession}.
+  # Sets up a `LanguageMode` for the given {Editor}.
   #
-  # editSession - The {EditSession} to associate with
-  constructor: (@editSession) ->
-    @buffer = @editSession.buffer
+  # editor - The {Editor} to associate with
+  constructor: (@editor) ->
+    @buffer = @editor.buffer
 
   # Wraps the lines between two rows in comments.
   #
@@ -37,7 +37,7 @@ class LanguageMode
   #
   # Returns an {Array} of the commented {Ranges}.
   toggleLineCommentsForBufferRows: (start, end) ->
-    scopes = @editSession.scopesForBufferPosition([start, 0])
+    scopes = @editor.scopesForBufferPosition([start, 0])
     properties = atom.syntax.propertiesForScope(scopes, "editor.commentStart")[0]
     return unless properties
 
@@ -46,7 +46,7 @@ class LanguageMode
 
     return unless commentStartString
 
-    buffer = @editSession.buffer
+    buffer = @editor.buffer
     commentStartRegexString = _.escapeRegExp(commentStartString).replace(/(\s+)$/, '($1)?')
     commentStartRegex = new OnigRegExp("^(\\s*)(#{commentStartRegexString})")
     shouldUncomment = commentStartRegex.test(buffer.lineForRow(start))
@@ -83,8 +83,8 @@ class LanguageMode
             buffer.change([[row, columnStart], [row, columnEnd]], "")
       else
         indent = @minIndentLevelForRowRange(start, end)
-        indentString = @editSession.buildIndentString(indent)
-        tabLength = @editSession.getTabLength()
+        indentString = @editor.buildIndentString(indent)
+        tabLength = @editor.getTabLength()
         indentRegex = new RegExp("(\t|[ ]{#{tabLength}}){#{Math.floor(indent)}}")
         for row in [start..end]
           line = buffer.lineForRow(row)
@@ -98,12 +98,12 @@ class LanguageMode
     for currentRow in [0..@buffer.getLastRow()]
       [startRow, endRow] = @rowRangeForFoldAtBufferRow(currentRow) ? []
       continue unless startRow?
-      @editSession.createFold(startRow, endRow)
+      @editor.createFold(startRow, endRow)
 
   # Unfolds all the foldable lines in the buffer.
   unfoldAll: ->
     for row in [@buffer.getLastRow()..0]
-      fold.destroy() for fold in @editSession.displayBuffer.foldsStartingAtBufferRow(row)
+      fold.destroy() for fold in @editor.displayBuffer.foldsStartingAtBufferRow(row)
 
   # Fold all comment and code blocks at a given indentLevel
   #
@@ -114,8 +114,8 @@ class LanguageMode
       continue unless startRow?
 
       # assumption: startRow will always be the min indent level for the entire range
-      if @editSession.indentationForBufferRow(startRow) == indentLevel
-        @editSession.createFold(startRow, endRow)
+      if @editor.indentationForBufferRow(startRow) == indentLevel
+        @editor.createFold(startRow, endRow)
 
   # Given a buffer row, creates a fold at it.
   #
@@ -126,14 +126,14 @@ class LanguageMode
     for currentRow in [bufferRow..0]
       [startRow, endRow] = @rowRangeForFoldAtBufferRow(currentRow) ? []
       continue unless startRow? and startRow <= bufferRow <= endRow
-      fold = @editSession.displayBuffer.largestFoldStartingAtBufferRow(startRow)
-      return @editSession.createFold(startRow, endRow) unless fold
+      fold = @editor.displayBuffer.largestFoldStartingAtBufferRow(startRow)
+      return @editor.createFold(startRow, endRow) unless fold
 
   # Given a buffer row, this unfolds it.
   #
   # bufferRow - A {Number} indicating the buffer row
   unfoldBufferRow: (bufferRow) ->
-    @editSession.displayBuffer.largestFoldContainingBufferRow(bufferRow)?.destroy()
+    @editor.displayBuffer.largestFoldContainingBufferRow(bufferRow)?.destroy()
 
   # Find the row range for a fold at a given bufferRow. Will handle comments
   # and code.
@@ -147,30 +147,30 @@ class LanguageMode
     rowRange
 
   rowRangeForCommentAtBufferRow: (bufferRow) ->
-    return unless @editSession.displayBuffer.tokenizedBuffer.lineForScreenRow(bufferRow).isComment()
+    return unless @editor.displayBuffer.tokenizedBuffer.lineForScreenRow(bufferRow).isComment()
 
     startRow = bufferRow
     for currentRow in [bufferRow-1..0]
       break if @buffer.isRowBlank(currentRow)
-      break unless @editSession.displayBuffer.tokenizedBuffer.lineForScreenRow(currentRow).isComment()
+      break unless @editor.displayBuffer.tokenizedBuffer.lineForScreenRow(currentRow).isComment()
       startRow = currentRow
     endRow = bufferRow
     for currentRow in [bufferRow+1..@buffer.getLastRow()]
       break if @buffer.isRowBlank(currentRow)
-      break unless @editSession.displayBuffer.tokenizedBuffer.lineForScreenRow(currentRow).isComment()
+      break unless @editor.displayBuffer.tokenizedBuffer.lineForScreenRow(currentRow).isComment()
       endRow = currentRow
     return [startRow, endRow] if startRow isnt endRow
 
   rowRangeForCodeFoldAtBufferRow: (bufferRow) ->
     return null unless @doesBufferRowStartFold(bufferRow)
 
-    startIndentLevel = @editSession.indentationForBufferRow(bufferRow)
-    scopes = @editSession.scopesForBufferPosition([bufferRow, 0])
-    for row in [(bufferRow + 1)..@editSession.getLastBufferRow()]
-      continue if @editSession.isBufferRowBlank(row)
-      indentation = @editSession.indentationForBufferRow(row)
+    startIndentLevel = @editor.indentationForBufferRow(bufferRow)
+    scopes = @editor.scopesForBufferPosition([bufferRow, 0])
+    for row in [(bufferRow + 1)..@editor.getLastBufferRow()]
+      continue if @editor.isBufferRowBlank(row)
+      indentation = @editor.indentationForBufferRow(row)
       if indentation <= startIndentLevel
-        includeRowInFold = indentation == startIndentLevel and @foldEndRegexForScopes(scopes)?.search(@editSession.lineForBufferRow(row))
+        includeRowInFold = indentation == startIndentLevel and @foldEndRegexForScopes(scopes)?.search(@editor.lineForBufferRow(row))
         foldEndRow = row if includeRowInFold
         break
 
@@ -179,19 +179,19 @@ class LanguageMode
     [bufferRow, foldEndRow]
 
   doesBufferRowStartFold: (bufferRow) ->
-    return false if @editSession.isBufferRowBlank(bufferRow)
-    nextNonEmptyRow = @editSession.nextNonBlankBufferRow(bufferRow)
+    return false if @editor.isBufferRowBlank(bufferRow)
+    nextNonEmptyRow = @editor.nextNonBlankBufferRow(bufferRow)
     return false unless nextNonEmptyRow?
-    @editSession.indentationForBufferRow(nextNonEmptyRow) > @editSession.indentationForBufferRow(bufferRow)
+    @editor.indentationForBufferRow(nextNonEmptyRow) > @editor.indentationForBufferRow(bufferRow)
 
   # Find a row range for a 'paragraph' around specified bufferRow.
   # Right now, a paragraph is a block of text bounded by and empty line or a
   # block of text that is not the same type (comments next to source code).
   rowRangeForParagraphAtBufferRow: (bufferRow) ->
-    return unless /\w/.test(@editSession.lineForBufferRow(bufferRow))
+    return unless /\w/.test(@editor.lineForBufferRow(bufferRow))
 
     isRowComment = (row) =>
-      @editSession.displayBuffer.tokenizedBuffer.lineForScreenRow(row).isComment()
+      @editor.displayBuffer.tokenizedBuffer.lineForScreenRow(row).isComment()
 
     if isRowComment(bufferRow)
       isOriginalRowComment = true
@@ -199,22 +199,22 @@ class LanguageMode
       [firstRow, lastRow] = range or [bufferRow, bufferRow]
     else
       isOriginalRowComment = false
-      [firstRow, lastRow] = [0, @editSession.getLastBufferRow()-1]
+      [firstRow, lastRow] = [0, @editor.getLastBufferRow()-1]
 
     startRow = bufferRow
     while startRow > firstRow
       break if isRowComment(startRow - 1) != isOriginalRowComment
-      break unless /\w/.test(@editSession.lineForBufferRow(startRow - 1))
+      break unless /\w/.test(@editor.lineForBufferRow(startRow - 1))
       startRow--
 
     endRow = bufferRow
-    lastRow = @editSession.getLastBufferRow()
+    lastRow = @editor.getLastBufferRow()
     while endRow < lastRow
       break if isRowComment(endRow + 1) != isOriginalRowComment
-      break unless /\w/.test(@editSession.lineForBufferRow(endRow + 1))
+      break unless /\w/.test(@editor.lineForBufferRow(endRow + 1))
       endRow++
 
-    new Range([startRow, 0], [endRow, @editSession.lineLengthForBufferRow(endRow)])
+    new Range([startRow, 0], [endRow, @editor.lineLengthForBufferRow(endRow)])
 
   # Given a buffer row, this returns a suggested indentation level.
   #
@@ -224,8 +224,8 @@ class LanguageMode
   #
   # Returns a {Number}.
   suggestedIndentForBufferRow: (bufferRow) ->
-    currentIndentLevel = @editSession.indentationForBufferRow(bufferRow)
-    scopes = @editSession.scopesForBufferPosition([bufferRow, 0])
+    currentIndentLevel = @editor.indentationForBufferRow(bufferRow)
+    scopes = @editor.scopesForBufferPosition([bufferRow, 0])
     return currentIndentLevel unless increaseIndentRegex = @increaseIndentRegexForScopes(scopes)
 
     currentLine = @buffer.lineForRow(bufferRow)
@@ -233,8 +233,8 @@ class LanguageMode
     return currentIndentLevel unless precedingRow?
 
     precedingLine = @buffer.lineForRow(precedingRow)
-    desiredIndentLevel = @editSession.indentationForBufferRow(precedingRow)
-    desiredIndentLevel += 1 if increaseIndentRegex.test(precedingLine) and not @editSession.isBufferRowCommented(precedingRow)
+    desiredIndentLevel = @editor.indentationForBufferRow(precedingRow)
+    desiredIndentLevel += 1 if increaseIndentRegex.test(precedingLine) and not @editor.isBufferRowCommented(precedingRow)
 
     return desiredIndentLevel unless decreaseIndentRegex = @decreaseIndentRegexForScopes(scopes)
     desiredIndentLevel -= 1 if decreaseIndentRegex.test(currentLine)
@@ -248,7 +248,7 @@ class LanguageMode
   #
   # Returns a {Number} of the indent level of the block of lines.
   minIndentLevelForRowRange: (startRow, endRow) ->
-    indents = (@editSession.indentationForBufferRow(row) for row in [startRow..endRow] when not @editSession.isBufferRowBlank(row))
+    indents = (@editor.indentationForBufferRow(row) for row in [startRow..endRow] when not @editor.isBufferRowBlank(row))
     indents = [0] unless indents.length
     Math.min(indents...)
 
@@ -264,13 +264,13 @@ class LanguageMode
   # bufferRow - The row {Number}
   autoIndentBufferRow: (bufferRow) ->
     indentLevel = @suggestedIndentForBufferRow(bufferRow)
-    @editSession.setIndentationForBufferRow(bufferRow, indentLevel)
+    @editor.setIndentationForBufferRow(bufferRow, indentLevel)
 
   # Given a buffer row, this decreases the indentation.
   #
   # bufferRow - The row {Number}
   autoDecreaseIndentForBufferRow: (bufferRow) ->
-    scopes = @editSession.scopesForBufferPosition([bufferRow, 0])
+    scopes = @editor.scopesForBufferPosition([bufferRow, 0])
     increaseIndentRegex = @increaseIndentRegexForScopes(scopes)
     decreaseIndentRegex = @decreaseIndentRegexForScopes(scopes)
     return unless increaseIndentRegex and decreaseIndentRegex
@@ -278,16 +278,16 @@ class LanguageMode
     line = @buffer.lineForRow(bufferRow)
     return unless decreaseIndentRegex.test(line)
 
-    currentIndentLevel = @editSession.indentationForBufferRow(bufferRow)
+    currentIndentLevel = @editor.indentationForBufferRow(bufferRow)
     return if currentIndentLevel is 0
     precedingRow = @buffer.previousNonBlankRow(bufferRow)
     return unless precedingRow?
     precedingLine = @buffer.lineForRow(precedingRow)
 
-    desiredIndentLevel = @editSession.indentationForBufferRow(precedingRow)
+    desiredIndentLevel = @editor.indentationForBufferRow(precedingRow)
     desiredIndentLevel -= 1 unless increaseIndentRegex.test(precedingLine)
     if desiredIndentLevel >= 0 and desiredIndentLevel < currentIndentLevel
-      @editSession.setIndentationForBufferRow(bufferRow, desiredIndentLevel)
+      @editor.setIndentationForBufferRow(bufferRow, desiredIndentLevel)
 
   tokenizeLine: (line, stack, firstLine) ->
     {tokens, stack} = @grammar.tokenizeLine(line, stack, firstLine)

src/less-compile-cache.coffee

@@ -5,27 +5,32 @@ LessCache = require 'less-cache'
 
 tmpDir = if process.platform is 'win32' then os.tmpdir() else '/tmp'
 
+# Private: {LessCache} wrapper used by {ThemeManager} to read stylesheets.
 module.exports =
 class LessCompileCache
   Subscriber.includeInto(this)
 
   @cacheDir: path.join(tmpDir, 'atom-compile-cache', 'less')
 
-  constructor: ({resourcePath}) ->
+  constructor: ({resourcePath, importPaths}) ->
     @lessSearchPaths = [
       path.join(resourcePath, 'static', 'variables')
       path.join(resourcePath, 'static')
     ]
 
+    if importPaths?
+      importPaths = importPaths.concat(@lessSearchPaths)
+    else
+      importPaths = @lessSearchPaths
+
     @cache = new LessCache
       cacheDir: @constructor.cacheDir
-      importPaths: @getImportPaths()
+      importPaths: importPaths
       resourcePath: resourcePath
       fallbackDir: path.join(resourcePath, 'less-compile-cache')
 
-    @subscribe atom.themes, 'reloaded', => @cache.setImportPaths(@getImportPaths())
-
-  getImportPaths: -> atom.themes.getImportPaths().concat(@lessSearchPaths)
+  setImportPaths: (importPaths=[]) ->
+    @cache.setImportPaths(importPaths.concat(@lessSearchPaths))
 
   read: (stylesheetPath) -> @cache.readFileSync(stylesheetPath)
 

src/menu-manager.coffee

@@ -27,21 +27,40 @@ class MenuManager
     @merge(@template, item) for item in items
     @update()
 
+  # Private: Should the binding for the given selector be included in the menu
+  # commands.
+  #
+  # * selector: A String selector to check.
+  #
+  # Returns true to include the selector, false otherwise.
+  includeSelector: (selector) ->
+    return true if document.body.webkitMatchesSelector(selector)
+
+    # Simulate an .editor element attached to a body element that has the same
+    # classes as the current body element.
+    unless @testEditor?
+      @testEditor = document.createElement('div')
+      @testEditor.classList.add('editor')
+      testBody = document.createElement('body')
+      testBody.classList.add(document.body.classList.toString().split(' ')...)
+      testBody.appendChild(@testEditor)
+
+    @testEditor.webkitMatchesSelector(selector)
+
   # Public: Refreshes the currently visible menu.
   update: ->
     keystrokesByCommand = {}
-    selectors = ['body', '.editor', '.editor:not(.mini)']
-    for binding in atom.keymap.getKeyBindings() when binding.selector in selectors
+    for binding in atom.keymap.getKeyBindings() when @includeSelector(binding.selector)
       keystrokesByCommand[binding.command] ?= []
       keystrokesByCommand[binding.command].push binding.keystroke
     @sendToBrowserProcess(@template, keystrokesByCommand)
 
-  # Private
+  # Private:
   loadPlatformItems: ->
     menusDirPath = path.join(@resourcePath, 'menus')
     platformMenuPath = fs.resolve(menusDirPath, process.platform, ['cson', 'json'])
-    data = CSON.readFileSync(platformMenuPath)
-    @add(data.menu)
+    {menu} = CSON.readFileSync(platformMenuPath)
+    @add(menu)
 
   # Private: Merges an item in a submenu aware way such that new items are always
   # appended to the bottom of existing menus where possible.
@@ -66,13 +85,15 @@ class MenuManager
         filtered[key].push(binding)
     filtered
 
-  # Private
+  # Private:
   sendToBrowserProcess: (template, keystrokesByCommand) ->
     keystrokesByCommand = @filterMultipleKeystroke(keystrokesByCommand)
     ipc.sendChannel 'update-application-menu', template, keystrokesByCommand
 
-  # Private
+  # Private:
   normalizeLabel: (label) ->
+    return undefined unless label?
+
     if process.platform is 'win32'
       label.replace(/\&/g, '')
     else

src/package-manager.coffee

@@ -4,25 +4,26 @@ _ = require 'underscore-plus'
 Package = require './package'
 path = require 'path'
 
-###
-Packages have a lifecycle
-
-* The paths to all non-disabled packages and themes are found on disk (these are available packages)
-* Every package (except those in core.disabledPackages) is 'loaded', meaning
-  `Package` objects are created, and their metadata loaded. This includes themes,
-  as themes are packages
-* The ThemeManager.activateThemes() is called 'activating' all the themes, meaning
-  their stylesheets are loaded into the window.
-* The PackageManager.activatePackages() function is called 'activating' non-theme
-  package, meaning its resources -- keymaps, classes, etc. -- are loaded, and
-  the package's activate() method is called.
-* Packages and themes can then be enabled and disabled via the public
-  .enablePackage(name) and .disablePackage(name) functions.
-###
+# Public: Package manager for coordinating the lifecycle of Atom packages.
+#
+# Packages can be loaded, activated, and deactivated, and unloaded:
+#  * Loading a package reads and parses the package's metadata and resources
+#    such as keymaps, menus, stylesheets, etc.
+#  * Activating a package registers the loaded resources and calls `activate()`
+#    on the package's main module.
+#  * Deactivating a package unregisters the package's resources  and calls
+#    `deactivate()` on the package's main module.
+#  * Unloading a package removes it completely from the package manager.
+#
+# Packages can also be enabled/disabled via the `core.disabledPackages` config
+# settings and also by calling `enablePackage()/disablePackage()`.
+#
+# An instance of this class is globally available via `atom.packages`.
 module.exports =
 class PackageManager
   Emitter.includeInto(this)
 
+  # Private:
   constructor: ({configDirPath, devMode, @resourcePath}) ->
     @packageDirPaths = [path.join(configDirPath, "packages")]
     if devMode
@@ -46,42 +47,44 @@ class PackageManager
   getPackageDirPaths: ->
     _.clone(@packageDirPaths)
 
+  # Private:
   getPackageState: (name) ->
     @packageStates[name]
 
+  # Private:
   setPackageState: (name, state) ->
     @packageStates[name] = state
 
-  # Public:
+  # Public: Enable the package with the given name
   enablePackage: (name) ->
     pack = @loadPackage(name)
     pack?.enable()
     pack
 
-  # Public:
+  # Public: Disable the package with the given name
   disablePackage: (name) ->
     pack = @loadPackage(name)
     pack?.disable()
     pack
 
-  # Internal-only: Activate all the packages that should be activated.
+  # Private: Activate all the packages that should be activated.
   activate: ->
     for [activator, types] in @packageActivators
       packages = @getLoadedPackagesForTypes(types)
       activator.activatePackages(packages)
     @emit 'activated'
 
-  # Public: another type of package manager can handle other package types.
+  # Private: another type of package manager can handle other package types.
   # See ThemeManager
   registerPackageActivator: (activator, types) ->
     @packageActivators.push([activator, types])
 
-  # Internal-only:
+  # Private:
   activatePackages: (packages) ->
     @activatePackage(pack.name) for pack in packages
     @observeDisabledPackages()
 
-  # Internal-only: Activate a single package by name
+  # Private: Activate a single package by name
   activatePackage: (name, options) ->
     return pack if pack = @getActivePackage(name)
     if pack = @loadPackage(name, options)
@@ -89,10 +92,12 @@ class PackageManager
       pack.activate(options)
       pack
 
+  # Private: Deactivate all packages
   deactivatePackages: ->
     @deactivatePackage(pack.name) for pack in @getActivePackages()
     @unobserveDisabledPackages()
 
+  # Private: Deactivate the package with the given name
   deactivatePackage: (name) ->
     if pack = @getActivePackage(name)
       @setPackageState(pack.name, state) if state = pack.serialize?()
@@ -101,20 +106,25 @@ class PackageManager
     else
       throw new Error("No active package for name '#{name}'")
 
+  # Public: Get an array of all the active packages
   getActivePackages: ->
     _.values(@activePackages)
 
+  # Public: Get the active package with the given name
   getActivePackage: (name) ->
     @activePackages[name]
 
+  # Public: Is the package with the given name active?
   isPackageActive: (name) ->
     @getActivePackage(name)?
 
+  # Private:
   unobserveDisabledPackages: ->
     return unless @observingDisabledPackages
     atom.config.unobserve('core.disabledPackages')
     @observingDisabledPackages = false
 
+  # Private:
   observeDisabledPackages: ->
     return if @observingDisabledPackages
 
@@ -128,6 +138,7 @@ class PackageManager
 
     @observingDisabledPackages = true
 
+  # Private:
   loadPackages: (options) ->
     # Ensure atom exports is already in the require cache so the load time
     # of the first package isn't skewed by being the first to require atom
@@ -139,6 +150,7 @@ class PackageManager
     @loadPackage(packagePath, options) for packagePath in packagePaths
     @emit 'loaded'
 
+  # Private:
   loadPackage: (nameOrPath, options) ->
     if packagePath = @resolvePackagePath(nameOrPath)
       name = path.basename(nameOrPath)
@@ -150,10 +162,12 @@ class PackageManager
     else
       throw new Error("Could not resolve '#{nameOrPath}' to a package path")
 
+  # Private:
   unloadPackages: ->
     @unloadPackage(name) for name in _.keys(@loadedPackages)
     null
 
+  # Private:
   unloadPackage: (name) ->
     if @isPackageActive(name)
       throw new Error("Tried to unload active package '#{name}'")
@@ -163,12 +177,15 @@ class PackageManager
     else
       throw new Error("No loaded package for name '#{name}'")
 
+  # Public: Get the loaded package with the given name
   getLoadedPackage: (name) ->
     @loadedPackages[name]
 
+  # Public: Is the package with the given name loaded?
   isPackageLoaded: (name) ->
     @getLoadedPackage(name)?
 
+  # Public: Get an array of all the loaded packages
   getLoadedPackages: ->
     _.values(@loadedPackages)
 
@@ -178,6 +195,7 @@ class PackageManager
   getLoadedPackagesForTypes: (types) ->
     pack for pack in @getLoadedPackages() when pack.getType() in types
 
+  # Public: Resolve the given package name to a path on disk.
   resolvePackagePath: (name) ->
     return name if fs.isDirectorySync(name)
 
@@ -185,18 +203,22 @@ class PackageManager
     return packagePath if fs.isDirectorySync(packagePath)
 
     packagePath = path.join(@resourcePath, 'node_modules', name)
-    return packagePath if @isInternalPackage(packagePath)
+    return packagePath if @hasAtomEngine(packagePath)
 
+  # Public: Is the package with the given name disabled?
   isPackageDisabled: (name) ->
     _.include(atom.config.get('core.disabledPackages') ? [], name)
 
-  isInternalPackage: (packagePath) ->
-    {engines} = Package.loadMetadata(packagePath, true)
-    engines?.atom?
+  # Private:
+  hasAtomEngine: (packagePath) ->
+    metadata = Package.loadMetadata(packagePath, true)
+    metadata?.engines?.atom?
 
-  isBundledPackage: (packageName) ->
-    @getPackageDependencies().hasOwnProperty(packageName)
+  # Public: Is the package with the given name bundled with Atom?
+  isBundledPackage: (name) ->
+    @getPackageDependencies().hasOwnProperty(name)
 
+  # Private:
   getPackageDependencies: ->
     unless @packageDependencies?
       try
@@ -204,8 +226,13 @@ class PackageManager
         {@packageDependencies} = JSON.parse(fs.readFileSync(metadataPath)) ? {}
       @packageDependencies ?= {}
 
+    # Temporarily ignore 'grunt-download-atom-shell' here, should remove this
+    # when it became a public npm module.
+    delete @packageDependencies['grunt-download-atom-shell']
+
     @packageDependencies
 
+  # Public: Get an array of all the available package paths.
   getAvailablePackagePaths: ->
     packagePaths = []
 
@@ -220,9 +247,11 @@ class PackageManager
 
     _.uniq(packagePaths)
 
+  # Public: Get an array of all the available package names.
   getAvailablePackageNames: ->
     _.uniq _.map @getAvailablePackagePaths(), (packagePath) -> path.basename(packagePath)
 
+  # Public: Get an array of all the available package metadata.
   getAvailablePackageMetadata: ->
     packages = []
     for packagePath in @getAvailablePackagePaths()

src/package.coffee

@@ -45,7 +45,7 @@ class Package
     @name = basename(@path)
 
   isActive: ->
-    atom.isPackageActive(@name)
+    atom.packages.isPackageActive(@name)
 
   isTheme: ->
     !!@metadata?.theme

src/pane-axis.coffee

@@ -12,7 +12,8 @@ class PaneAxis extends View
   initialize: (args...) ->
     if args[0] instanceof telepath.Document
       @state = args[0]
-      @state.get('children').each (child, index) => @addChild(deserialize(child), index, updateState: false)
+      @state.get('children').each (child, index) =>
+        @addChild(atom.deserializers.deserialize(child), index, updateState: false)
     else
       @state = atom.site.createDocument(deserializer: @className(), children: [])
       @addChild(child) for child in args
@@ -22,7 +23,7 @@ class PaneAxis extends View
       for childState in removedValues
         @removeChild(@children(":eq(#{index})").view(), updateState: false)
       for childState, i in insertedValues
-        @addChild(deserialize(childState), index + i, updateState: false)
+        @addChild(atom.deserializers.deserialize(childState), index + i, updateState: false)
 
   addChild: (child, index=@children().length, options={}) ->
     @insertAt(index, child)
@@ -69,7 +70,7 @@ class PaneAxis extends View
     child.detach()
 
   getContainer: ->
-    @closest('#panes').view()
+    @closest('.panes').view()
 
   getActivePaneItem: ->
     @getActivePane()?.activeItem

src/pane-container.coffee

@@ -2,10 +2,10 @@
 Pane = require './pane'
 telepath = require 'telepath'
 
-# Private: Manages the list of panes within a {RootView}
+# Private: Manages the list of panes within a {WorkspaceView}
 module.exports =
 class PaneContainer extends View
-  registerDeserializer(this)
+  atom.deserializers.add(this)
 
   ### Internal ###
   @acceptsDocuments: true
@@ -16,14 +16,14 @@ class PaneContainer extends View
     container
 
   @content: ->
-    @div id: 'panes'
+    @div class: 'panes'
 
   initialize: (state) ->
     @destroyedItemStates = []
 
     if state instanceof telepath.Document
       @state = state
-      @setRoot(deserialize(@state.get('root')))
+      @setRoot(atom.deserializers.deserialize(@state.get('root')))
     else
       @state = atom.site.createDocument(deserializer: 'PaneContainer')
 
@@ -89,10 +89,10 @@ class PaneContainer extends View
   reopenItem: ->
     if lastItemState = @destroyedItemStates.pop()
       if activePane = @getActivePane()
-        activePane.showItem(deserialize(lastItemState))
+        activePane.showItem(atom.deserializers.deserialize(lastItemState))
         true
       else
-        newPane = new Pane(deserialize(lastItemState))
+        newPane = new Pane(atom.deserializers.deserialize(lastItemState))
         @setRoot(newPane)
         newPane.focus()
 
@@ -147,7 +147,7 @@ class PaneContainer extends View
     callback(pane) for pane in @getPanes()
     paneAttached = (e) -> callback($(e.target).view())
     @on 'pane:attached', paneAttached
-    cancel: => @off 'pane:attached', paneAttached
+    off: => @off 'pane:attached', paneAttached
 
   getFocusedPane: ->
     @find('.pane:has(:focus)').view()

src/pane.coffee

@@ -7,7 +7,7 @@ PaneColumn = require './pane-column'
 
 # Public: A container which can contains multiple items to be switched between.
 #
-# Items can be almost anything however most commonly they're {Editor}s.
+# Items can be almost anything however most commonly they're {EditorView}s.
 #
 # Most packages won't need to use this class, unless you're interested in
 # building a package that deals with switching between panes or tiems.
@@ -33,7 +33,8 @@ class Pane extends View
   initialize: (args...) ->
     if args[0] instanceof telepath.Document
       @state = args[0]
-      @items = _.compact(@state.get('items').map (item) -> deserialize(item))
+      @items = _.compact @state.get('items').map (item) ->
+        atom.deserializers.deserialize(item)
     else
       @items = args
       @state = atom.site.createDocument
@@ -45,10 +46,10 @@ class Pane extends View
       for itemState in removedValues
         @removeItemAtIndex(index, updateState: false)
       for itemState, i in insertedValues
-        @addItem(deserialize(itemState), index + i, updateState: false)
+        @addItem(atom.deserializers.deserialize(itemState), index + i, updateState: false)
 
     @subscribe @state, 'changed', ({newValues, siteId}) =>
-      return if site is @state.siteId
+      return if siteId is @state.siteId
       if newValues.activeItemUri
         @showItemForUri(newValues.activeItemUri)
 
@@ -219,12 +220,11 @@ class Pane extends View
     return true unless item.shouldPromptToSave?()
 
     uri = item.getUri()
-    chosen = atom.confirmSync(
-      "'#{item.getTitle?() ? item.getUri()}' has changes, do you want to save them?"
-      "Your changes will be lost if you close this item without saving."
-      ["Save", "Cancel", "Don't Save"]
-      atom.getCurrentWindow()
-    )
+    chosen = atom.confirm
+      message: "'#{item.getTitle?() ? item.getUri()}' has changes, do you want to save them?"
+      detailedMessage: "Your changes will be lost if you close this item without saving."
+      buttons: ["Save", "Cancel", "Don't Save"]
+
     switch chosen
       when 0 then @saveItem(item, -> true)
       when 1 then false
@@ -412,11 +412,11 @@ class Pane extends View
 
   # Private:
   getContainer: ->
-    @closest('#panes').view()
+    @closest('.panes').view()
 
   # Private:
   copyActiveItem: ->
-    @activeItem.copy?() ? deserialize(@activeItem.serialize())
+    @activeItem.copy?() ? atom.deserializers.deserialize(@activeItem.serialize())
 
   # Private:
   remove: (selector, keepData) ->
@@ -426,7 +426,7 @@ class Pane extends View
   # Private:
   beforeRemove: ->
     if @is(':has(:focus)')
-      @getContainer().focusNextPane() or rootView?.focus()
+      @getContainer().focusNextPane() or atom.workspaceView?.focus()
     else if @isActive()
       @getContainer().makeNextPaneActive()
 

src/project.coffee

@@ -7,7 +7,7 @@ Q = require 'q'
 telepath = require 'telepath'
 
 TextBuffer = require './text-buffer'
-EditSession = require './edit-session'
+Editor = require './editor'
 {Emitter} = require 'emissary'
 Directory = require './directory'
 Task = require './task'
@@ -32,24 +32,38 @@ class Project extends telepath.Model
     path.join(atom.config.get('core.projectHome'), repoName)
 
   # Private: Called by telepath.
-  attached: ->
+  created: ->
+    for buffer in @buffers.getValues()
+      buffer.once 'destroyed', (buffer) => @removeBuffer(buffer)
+
     @openers = []
-    @editSessions = []
+    @editors = []
     @setPath(@path)
 
   # Private: Called by telepath.
   beforePersistence: ->
     @destroyUnretainedBuffers()
 
-  # Public:
+  # Public: Register an opener for project files.
+  #
+  # An {Editor} will be used if no openers return a value.
+  #
+  # ## Example:
+  # ```coffeescript
+  #   atom.project.registerOpener (filePath) ->
+  #     if path.extname(filePath) is '.toml'
+  #       return new TomlEditor(filePath)
+  # ```
+  #
+  # * opener: A function to be called when a path is being opened.
   registerOpener: (opener) -> @openers.push(opener)
 
-  # Public:
+  # Public: Remove a previously registered opener.
   unregisterOpener: (opener) -> _.remove(@openers, opener)
 
   # Private:
-  destroy: ->
-    editSession.destroy() for editSession in @getEditSessions()
+  destroyed: ->
+    editor.destroy() for editor in @getEditors()
     buffer.release() for buffer in @getBuffers()
     @destroyRepo()
 
@@ -87,22 +101,10 @@ class Project extends telepath.Model
 
     @emit "path-changed"
 
-  # Public: Returns the name of the root directory.
+  # Public: Returns the root {Directory} object for this project.
   getRootDirectory: ->
     @rootDirectory
 
-  # Public: Determines if a path is ignored via Atom configuration.
-  isPathIgnored: (path) ->
-    for segment in path.split("/")
-      ignoredNames = atom.config.get("core.ignoredNames") or []
-      return true if _.contains(ignoredNames, segment)
-
-    @ignoreRepositoryPath(path)
-
-  # Public: Determines if a given path is ignored via repository configuration.
-  ignoreRepositoryPath: (repositoryPath) ->
-    atom.config.get("core.hideGitIgnoredFiles") and @repo?.isPathIgnored(path.join(@getPath(), repositoryPath))
-
   # Public: Given a uri, this resolves it relative to the project directory. If
   # the path is already absolute or if it is prefixed with a scheme, it is
   # returned unchanged.
@@ -130,14 +132,14 @@ class Project extends telepath.Model
     @rootDirectory?.contains(pathToCheck) ? false
 
   # Public: Given a path to a file, this constructs and associates a new
-  # {EditSession}, showing the file.
+  # {Editor}, showing the file.
   #
   # * filePath:
   #   The {String} path of the file to associate with
-  # * editSessionOptions:
-  #   Options that you can pass to the {EditSession} constructor
+  # * options:
+  #   Options that you can pass to the {Editor} constructor
   #
-  # Returns a promise that resolves to an {EditSession}.
+  # Returns a promise that resolves to an {Editor}.
   open: (filePath, options={}) ->
     filePath = @resolve(filePath)
     resource = null
@@ -147,7 +149,7 @@ class Project extends telepath.Model
       Q(resource)
     else
       @bufferForPath(filePath).then (buffer) =>
-        @buildEditSessionForBuffer(buffer, options)
+        @buildEditorForBuffer(buffer, options)
 
   # Private: Only be used in specs
   openSync: (filePath, options={}) ->
@@ -155,22 +157,22 @@ class Project extends telepath.Model
     for opener in @openers
       return resource if resource = opener(filePath, options)
 
-    @buildEditSessionForBuffer(@bufferForPathSync(filePath), options)
+    @buildEditorForBuffer(@bufferForPathSync(filePath), options)
 
-  # Public: Retrieves all {EditSession}s for all open files.
+  # Public: Retrieves all {Editor}s for all open files.
   #
-  # Returns an {Array} of {EditSession}s.
-  getEditSessions: ->
-    new Array(@editSessions...)
+  # Returns an {Array} of {Editor}s.
+  getEditors: ->
+    new Array(@editors...)
 
-  # Public: Add the given {EditSession}.
-  addEditSession: (editSession) ->
-    @editSessions.push editSession
-    @emit 'edit-session-created', editSession
+  # Public: Add the given {Editor}.
+  addEditor: (editor) ->
+    @editors.push editor
+    @emit 'editor-created', editor
 
-  # Public: Return and removes the given {EditSession}.
-  removeEditSession: (editSession) ->
-    _.remove(@editSessions, editSession)
+  # Public: Return and removes the given {Editor}.
+  removeEditor: (editor) ->
+    _.remove(@editors, editor)
 
   # Private: Retrieves all the {TextBuffer}s in the project; that is, the
   # buffers for all open files.
@@ -179,11 +181,13 @@ class Project extends telepath.Model
   getBuffers: ->
     new Array(@buffers.getValues()...)
 
+  # Private: Is the buffer for the given path modified?
   isPathModified: (filePath) ->
     @findBufferForPath(@resolve(filePath))?.isModified()
 
+  # Private:
   findBufferForPath: (filePath) ->
-    _.find @buffers.getValues(), (buffer) -> buffer.getPath() == filePath
+   _.find @buffers.getValues(), (buffer) -> buffer.getPath() == filePath
 
   # Private: Only to be used in specs
   bufferForPathSync: (filePath) ->
@@ -319,6 +323,7 @@ class Project extends telepath.Model
       task.on 'replace:path-replaced', iterator
 
     for buffer in @buffers.getValues()
+      continue unless buffer.getPath() in filePaths
       replacements = buffer.replace(regex, replacementText, iterator)
       iterator({filePath: buffer.getPath(), replacements}) if replacements
 
@@ -328,15 +333,15 @@ class Project extends telepath.Model
     deferred.promise
 
   # Private:
-  buildEditSessionForBuffer: (buffer, editSessionOptions) ->
-    editSession = new EditSession(_.extend({buffer}, editSessionOptions))
-    @addEditSession(editSession)
-    editSession
+  buildEditorForBuffer: (buffer, editorOptions) ->
+    editor = new Editor(_.extend({buffer}, editorOptions))
+    @addEditor(editor)
+    editor
 
   # Private:
-  eachEditSession: (callback) ->
-    callback(editSession) for editSession in @getEditSessions()
-    @on 'edit-session-created', (editSession) -> callback(editSession)
+  eachEditor: (callback) ->
+    callback(editor) for editor in @getEditors()
+    @on 'editor-created', (editor) -> callback(editor)
 
   # Private:
   eachBuffer: (args...) ->

src/select-list.coffee

@@ -1,5 +1,5 @@
 {$, View} = require './space-pen-extensions'
-Editor = require './editor'
+EditorView = require './editor-view'
 fuzzyFilter = require('fuzzaldrin').filter
 
 # Public: Provides a widget for users to make a selection from a list of
@@ -10,7 +10,7 @@ class SelectList extends View
   # Private:
   @content: ->
     @div class: @viewClass(), =>
-      @subview 'miniEditor', new Editor(mini: true)
+      @subview 'miniEditor', new EditorView(mini: true)
       @div class: 'error-message', outlet: 'error'
       @div class: 'loading', outlet: 'loadingArea', =>
         @span class: 'loading-message', outlet: 'loading'
@@ -25,7 +25,10 @@ class SelectList extends View
   inputThrottle: 50
   cancelling: false
 
-  # Public:
+  # Public: Initialize the select list view.
+  #
+  # This method can be overridden by subclasses but `super` should always
+  # be called.
   initialize: ->
     @miniEditor.getBuffer().on 'changed', => @schedulePopulateList()
     @miniEditor.hiddenInput.on 'focusout', => @cancel() unless @cancelling
@@ -57,12 +60,16 @@ class SelectList extends View
       @populateList() if @isOnDom()
     @scheduleTimeout = setTimeout(populateCallback,  @inputThrottle)
 
-  # Public:
-  setArray: (@array) ->
+  # Public: Set the array of items to display in the list.
+  #
+  # * array: The array of model elements to display in the list.
+  setArray: (@array=[]) ->
     @populateList()
     @setLoading()
 
-  # Public:
+  # Public: Set the error message to display.
+  #
+  # * message: The error message.
   setError: (message='') ->
     if message.length is 0
       @error.text('').hide()
@@ -70,7 +77,9 @@ class SelectList extends View
       @setLoading()
       @error.text(message).show()
 
-  # Public:
+  # Public: Set the loading message to display.
+  #
+  # * message: The loading message.
   setLoading: (message='') ->
     if message.length is 0
       @loading.text("")
@@ -81,11 +90,18 @@ class SelectList extends View
       @loading.text(message)
       @loadingArea.show()
 
-  # Public:
+  # Public: Get the filter query to use when fuzzy filtering the visible
+  # elements.
+  #
+  # By default this method returns the text in the mini editor but it can be
+  # overridden by subclasses if needed.
+  #
+  # Returns a {String} to use when fuzzy filtering the elements to display.
   getFilterQuery: ->
     @miniEditor.getText()
 
-  # Public:
+  # Public: Build the DOM elements using the array from the last call to
+  # {.setArray}.
   populateList: ->
     return unless @array?
 
@@ -109,7 +125,12 @@ class SelectList extends View
     else
       @setError(@getEmptyMessage(@array.length, filteredArray.length))
 
-  # Public:
+  # Public: Get the message to display when there are no items.
+  #
+  # Subclasses may override this method to customize the message.
+  #
+  # * itemCount: The number of items in the array specified to {.setArray}
+  # * filteredItemCount: The number of items that pass the fuzzy filter test.
   getEmptyMessage: (itemCount, filteredItemCount) -> 'No matches found'
 
   # Private:
@@ -124,14 +145,14 @@ class SelectList extends View
     item = @list.find('li:first') unless item.length
     @selectItem(item)
 
-  # Public:
+  # Private:
   selectItem: (item) ->
     return unless item.length
     @list.find('.selected').removeClass('selected')
     item.addClass 'selected'
     @scrollToItem(item)
 
-  # Public:
+  # Private:
   scrollToItem: (item) ->
     scrollTop = @list.scrollTop()
     desiredTop = item.position().top + scrollTop
@@ -142,15 +163,19 @@ class SelectList extends View
     else if desiredBottom > @list.scrollBottom()
       @list.scrollBottom(desiredBottom)
 
-  # Public:
+  # Public: Get the selected DOM element.
+  #
+  # Call {.getSelectedElement} to get the selected model element.
   getSelectedItem: ->
     @list.find('li.selected')
 
-  # Public:
+  # Public: Get the selected model element.
+  #
+  # Call {.getSelectedItem} to get the selected DOM element.
   getSelectedElement: ->
     @getSelectedItem().data('select-list-element')
 
-  # Public:
+  # Private:
   confirmSelection: ->
     element = @getSelectedElement()
     if element?
@@ -158,6 +183,13 @@ class SelectList extends View
     else
       @cancel()
 
+  # Public: Callback function for when a selection is made.
+  #
+  # This method should be overridden by subclasses.
+  #
+  # * element: The selected model element.
+  confirmed: (element) ->
+
   # Private:
   attach: ->
     @storeFocusedElement()
@@ -171,14 +203,14 @@ class SelectList extends View
     if @previouslyFocusedElement?.isOnDom()
       @previouslyFocusedElement.focus()
     else
-      rootView.focus()
+      atom.workspaceView.focus()
 
-  # Public:
+  # Private:
   cancelled: ->
     @miniEditor.setText('')
     @miniEditor.updateDisplay()
 
-  # Public:
+  # Public: Cancel and close the select list dialog.
   cancel: ->
     @list.empty()
     @cancelling = true

src/selection-view.coffee

@@ -11,12 +11,12 @@ class SelectionView extends View
   regions: null
   needsRemoval: false
 
-  initialize: ({@editor, @selection} = {}) ->
+  initialize: ({@editorView, @selection} = {}) ->
     @regions = []
-    @selection.on 'screen-range-changed', => @editor.requestDisplayUpdate()
+    @selection.on 'screen-range-changed', => @editorView.requestDisplayUpdate()
     @selection.on 'destroyed', =>
       @needsRemoval = true
-      @editor.requestDisplayUpdate()
+      @editorView.requestDisplayUpdate()
 
     if @selection.marker.isRemote()
       @addClass("site-#{@selection.marker.getOriginSiteId()}")
@@ -26,7 +26,7 @@ class SelectionView extends View
     range = @getScreenRange()
 
     @trigger 'selection:changed'
-    @editor.highlightFoldsContainingBufferRange(@getBufferRange())
+    @editorView.highlightFoldsContainingBufferRange(@getBufferRange())
     return if range.isEmpty()
 
     rowSpan = range.end.row - range.start.row
@@ -40,11 +40,11 @@ class SelectionView extends View
       @appendRegion(1, { row: range.end.row, column: 0 }, range.end)
 
   appendRegion: (rows, start, end) ->
-    { lineHeight, charWidth } = @editor
-    css = @editor.pixelPositionForScreenPosition(start)
+    { lineHeight, charWidth } = @editorView
+    css = @editorView.pixelPositionForScreenPosition(start)
     css.height = lineHeight * rows
     if end
-      css.width = @editor.pixelPositionForScreenPosition(end).left - css.left
+      css.width = @editorView.pixelPositionForScreenPosition(end).left - css.left
     else
       css.right = 0
 
@@ -57,7 +57,7 @@ class SelectionView extends View
     startRow = start.row
     endRow = end.row
     endRow-- if end.column == 0
-    @editor.pixelPositionForScreenPosition([((startRow + endRow + 1) / 2), start.column])
+    @editorView.pixelPositionForScreenPosition([((startRow + endRow + 1) / 2), start.column])
 
   clearRegions: ->
     region.remove() for region in @regions
@@ -85,5 +85,5 @@ class SelectionView extends View
     @removeClass('highlighted')
 
   remove: ->
-    @editor.removeSelectionView(this)
+    @editorView.removeSelectionView(this)
     super

src/selection.coffee

@@ -2,27 +2,26 @@
 {Emitter} = require 'emissary'
 {pick} = require 'underscore-plus'
 
-# Public: Represents a selection in the {EditSession}.
+# Public: Represents a selection in the {Editor}.
 module.exports =
 class Selection
   Emitter.includeInto(this)
 
   cursor: null
   marker: null
-  editSession: null
+  editor: null
   initialScreenRange: null
   wordwise: false
   needsAutoscroll: null
 
-
   # Private:
-  constructor: ({@cursor, @marker, @editSession}) ->
+  constructor: ({@cursor, @marker, @editor}) ->
     @cursor.selection = this
     @marker.on 'changed', => @screenRangeChanged()
     @marker.on 'destroyed', =>
       @destroyed = true
-      @editSession.removeSelection(this)
-      @emit 'destroyed' unless @editSession.destroyed
+      @editor.removeSelection(this)
+      @emit 'destroyed' unless @editor.destroyed
 
   # Private:
   destroy: ->
@@ -65,7 +64,7 @@ class Selection
   # * options:
   #   + A hash of options matching those found in {.setBufferRange}
   setScreenRange: (screenRange, options) ->
-    @setBufferRange(@editSession.bufferRangeForScreenRange(screenRange), options)
+    @setBufferRange(@editor.bufferRangeForScreenRange(screenRange), options)
 
   # Public: Returns the buffer {Range} for the selection.
   getBufferRange: ->
@@ -79,12 +78,12 @@ class Selection
   #    + preserveFolds:
   #      if `true`, the fold settings are preserved after the selection moves
   #    + autoscroll:
-  #      if `true`, the {EditSession} scrolls to the new selection
+  #      if `true`, the {Editor} scrolls to the new selection
   setBufferRange: (bufferRange, options={}) ->
     bufferRange = Range.fromObject(bufferRange)
     @needsAutoscroll = options.autoscroll
     options.isReversed ?= @isReversed()
-    @editSession.destroyFoldsIntersectingBufferRange(bufferRange) unless options.preserveFolds
+    @editor.destroyFoldsIntersectingBufferRange(bufferRange) unless options.preserveFolds
     @modifySelection =>
       @cursor.needsAutoscroll = false if options.autoscroll?
       @marker.setBufferRange(bufferRange, options)
@@ -102,7 +101,7 @@ class Selection
 
   # Public: Returns the text in the selection.
   getText: ->
-    @editSession.buffer.getTextInRange(@getBufferRange())
+    @editor.buffer.getTextInRange(@getBufferRange())
 
   # Public: Clears the selection, moving the marker to the head.
   clear: ->
@@ -132,7 +131,7 @@ class Selection
   # * row:
   #   The line Number to select (default: the row of the cursor)
   selectLine: (row=@cursor.getBufferPosition().row) ->
-    range = @editSession.bufferRangeForBufferRow(row, includeNewline: true)
+    range = @editor.bufferRangeForBufferRow(row, includeNewline: true)
     @setBufferRange(range)
     @linewise = true
     @wordwise = false
@@ -202,7 +201,7 @@ class Selection
 
   # Public: Selects all the text in the buffer.
   selectAll: ->
-    @setBufferRange(@editSession.buffer.getRange(), autoscroll: false)
+    @setBufferRange(@editor.buffer.getRange(), autoscroll: false)
 
   # Public: Selects all the text from the current cursor position to the
   # beginning of the line.
@@ -247,17 +246,17 @@ class Selection
     range = (@getGoalBufferRange() ? @getBufferRange()).copy()
     nextRow = range.end.row + 1
 
-    for row in [nextRow..@editSession.getLastBufferRow()]
+    for row in [nextRow..@editor.getLastBufferRow()]
       range.start.row = row
       range.end.row = row
-      clippedRange = @editSession.clipBufferRange(range)
+      clippedRange = @editor.clipBufferRange(range)
 
       if range.isEmpty()
         continue if range.end.column > 0 and clippedRange.end.column is 0
       else
         continue if clippedRange.isEmpty()
 
-      @editSession.addSelectionForBufferRange(range, goalBufferRange: range)
+      @editor.addSelectionForBufferRange(range, goalBufferRange: range)
       break
 
   # Public:
@@ -274,14 +273,14 @@ class Selection
     for row in [previousRow..0]
       range.start.row = row
       range.end.row = row
-      clippedRange = @editSession.clipBufferRange(range)
+      clippedRange = @editor.clipBufferRange(range)
 
       if range.isEmpty()
         continue if range.end.column > 0 and clippedRange.end.column is 0
       else
         continue if clippedRange.isEmpty()
 
-      @editSession.addSelectionForBufferRange(range, goalBufferRange: range)
+      @editor.addSelectionForBufferRange(range, goalBufferRange: range)
       break
 
   # Public: Replaces text at the current selection.
@@ -302,7 +301,7 @@ class Selection
   #      if `skip`, skips the undo stack for this operation.
   insertText: (text, options={}) ->
     oldBufferRange = @getBufferRange()
-    @editSession.destroyFoldsContainingBufferRow(oldBufferRange.end.row)
+    @editor.destroyFoldsContainingBufferRow(oldBufferRange.end.row)
     wasReversed = @isReversed()
     @clear()
     @cursor.needsAutoscroll = @cursor.isLastCursor()
@@ -310,18 +309,18 @@ class Selection
     if options.indentBasis? and not options.autoIndent
       text = @normalizeIndents(text, options.indentBasis)
 
-    newBufferRange = @editSession.buffer.change(oldBufferRange, text, pick(options, 'undo'))
+    newBufferRange = @editor.buffer.change(oldBufferRange, text, pick(options, 'undo'))
     if options.select
       @setBufferRange(newBufferRange, isReversed: wasReversed)
     else
       @cursor.setBufferPosition(newBufferRange.end, skipAtomicTokens: true) if wasReversed
 
     if options.autoIndent
-      @editSession.autoIndentBufferRow(row) for row in newBufferRange.getRows()
+      @editor.autoIndentBufferRow(row) for row in newBufferRange.getRows()
     else if options.autoIndentNewline and text == '\n'
-      @editSession.autoIndentBufferRow(newBufferRange.end.row)
+      @editor.autoIndentBufferRow(newBufferRange.end.row)
     else if options.autoDecreaseIndent and /\S/.test text
-      @editSession.autoDecreaseIndentForBufferRow(newBufferRange.start.row)
+      @editor.autoDecreaseIndentForBufferRow(newBufferRange.start.row)
 
     newBufferRange
 
@@ -336,9 +335,9 @@ class Selection
     isCursorInsideExistingLine = /\S/.test(textPrecedingCursor)
 
     lines = text.split('\n')
-    firstLineIndentLevel = @editSession.indentLevelForLine(lines[0])
+    firstLineIndentLevel = @editor.indentLevelForLine(lines[0])
     if isCursorInsideExistingLine
-      minimumIndentLevel = @editSession.indentationForBufferRow(@cursor.getBufferRow())
+      minimumIndentLevel = @editor.indentationForBufferRow(@cursor.getBufferRow())
     else
       minimumIndentLevel = @cursor.getIndentLevel()
 
@@ -349,7 +348,7 @@ class Selection
       else if line == '' # remove all indentation from empty lines
         indentLevel = 0
       else
-        lineIndentLevel = @editSession.indentLevelForLine(lines[i])
+        lineIndentLevel = @editor.indentLevelForLine(lines[i])
         indentLevel = minimumIndentLevel + (lineIndentLevel - indentBasis)
 
       normalizedLines.push(@setIndentationForLine(line, indentLevel))
@@ -361,19 +360,19 @@ class Selection
   # * options - A hash with one key,
   #    + autoIndent:
   #      If `true`, the indentation is performed appropriately. Otherwise,
-  #      {EditSession.getTabText} is used
+  #      {Editor.getTabText} is used
   indent: ({ autoIndent }={})->
     { row, column } = @cursor.getBufferPosition()
 
     if @isEmpty()
       @cursor.skipLeadingWhitespace()
-      desiredIndent = @editSession.suggestedIndentForBufferRow(row)
+      desiredIndent = @editor.suggestedIndentForBufferRow(row)
       delta = desiredIndent - @cursor.getIndentLevel()
 
       if autoIndent and delta > 0
-        @insertText(@editSession.buildIndentString(delta))
+        @insertText(@editor.buildIndentString(delta))
       else
-        @insertText(@editSession.getTabText())
+        @insertText(@editor.getTabText())
     else
       @indentSelectedRows()
 
@@ -381,18 +380,18 @@ class Selection
   indentSelectedRows: ->
     [start, end] = @getBufferRowRange()
     for row in [start..end]
-      @editSession.buffer.insert([row, 0], @editSession.getTabText()) unless @editSession.buffer.lineLengthForRow(row) == 0
+      @editor.buffer.insert([row, 0], @editor.getTabText()) unless @editor.buffer.lineLengthForRow(row) == 0
 
   # Public: ?
   setIndentationForLine: (line, indentLevel) ->
     desiredIndentLevel = Math.max(0, indentLevel)
-    desiredIndentString = @editSession.buildIndentString(desiredIndentLevel)
+    desiredIndentString = @editor.buildIndentString(desiredIndentLevel)
     line.replace(/^[\t ]*/, desiredIndentString)
 
   # Public: Removes the first character before the selection if the selection
   # is empty otherwise it deletes the selection.
   backspace: ->
-    @selectLeft() if @isEmpty() and not @editSession.isFoldedAtScreenRow(@cursor.getScreenRow())
+    @selectLeft() if @isEmpty() and not @editor.isFoldedAtScreenRow(@cursor.getScreenRow())
     @deleteSelectedText()
 
   # Public: Removes from the start of the selection to the beginning of the
@@ -414,7 +413,7 @@ class Selection
   # selection if the selection is empty.
   delete: ->
     if @isEmpty()
-      if @cursor.isAtEndOfLine() and fold = @editSession.largestFoldStartingAtScreenRow(@cursor.getScreenRow() + 1)
+      if @cursor.isAtEndOfLine() and fold = @editor.largestFoldStartingAtScreenRow(@cursor.getScreenRow() + 1)
         @selectToBufferPosition(fold.getBufferRange().end)
       else
         @selectRight()
@@ -429,9 +428,9 @@ class Selection
   # Public: Removes only the selected text.
   deleteSelectedText: ->
     bufferRange = @getBufferRange()
-    if bufferRange.isEmpty() and fold = @editSession.largestFoldContainingBufferRow(bufferRange.start.row)
+    if bufferRange.isEmpty() and fold = @editor.largestFoldContainingBufferRow(bufferRange.start.row)
       bufferRange = bufferRange.union(fold.getBufferRange(includeNewline: true))
-    @editSession.buffer.delete(bufferRange) unless bufferRange.isEmpty()
+    @editor.buffer.delete(bufferRange) unless bufferRange.isEmpty()
     @cursor?.setBufferPosition(bufferRange.start)
 
   # Public: Removes the line at the beginning of the selection if the selection
@@ -440,18 +439,18 @@ class Selection
   deleteLine: ->
     if @isEmpty()
       start = @cursor.getScreenRow()
-      range = @editSession.bufferRowsForScreenRows(start, start + 1)
+      range = @editor.bufferRowsForScreenRows(start, start + 1)
       if range[1] > range[0]
-        @editSession.buffer.deleteRows(range[0], range[1] - 1)
+        @editor.buffer.deleteRows(range[0], range[1] - 1)
       else
-        @editSession.buffer.deleteRow(range[0])
+        @editor.buffer.deleteRow(range[0])
     else
       range = @getBufferRange()
       start = range.start.row
       end = range.end.row
-      if end isnt @editSession.buffer.getLastRow() and range.end.column is 0
+      if end isnt @editor.buffer.getLastRow() and range.end.column is 0
         end--
-      @editSession.buffer.deleteRows(start, end)
+      @editor.buffer.deleteRows(start, end)
 
   # Public: Joins the current line with the one below it.
   #
@@ -459,16 +458,16 @@ class Selection
   joinLine: ->
     selectedRange = @getBufferRange()
     if selectedRange.isEmpty()
-      return if selectedRange.start.row is @editSession.buffer.getLastRow()
+      return if selectedRange.start.row is @editor.buffer.getLastRow()
     else
-      joinMarker = @editSession.markBufferRange(selectedRange, invalidationStrategy: 'never')
+      joinMarker = @editor.markBufferRange(selectedRange, invalidationStrategy: 'never')
 
     rowCount = Math.max(1, selectedRange.getRowCount() - 1)
     for row in [0...rowCount]
       @cursor.setBufferPosition([selectedRange.start.row])
       @cursor.moveToEndOfLine()
       nextRow = selectedRange.start.row + 1
-      if nextRow <= @editSession.buffer.getLastRow() and @editSession.buffer.lineLengthForRow(nextRow) > 0
+      if nextRow <= @editor.buffer.getLastRow() and @editor.buffer.lineLengthForRow(nextRow) > 0
         @insertText(' ')
         @cursor.moveToEndOfLine()
       @modifySelection =>
@@ -484,8 +483,8 @@ class Selection
   # Public: Removes one level of indent from the currently selected rows.
   outdentSelectedRows: ->
     [start, end] = @getBufferRowRange()
-    buffer = @editSession.buffer
-    leadingTabRegex = new RegExp("^ {1,#{@editSession.getTabLength()}}|\t")
+    buffer = @editor.buffer
+    leadingTabRegex = new RegExp("^ {1,#{@editor.getTabLength()}}|\t")
     for row in [start..end]
       if matchLength = buffer.lineForRow(row).match(leadingTabRegex)?[0].length
         buffer.delete [[row, 0], [row, matchLength]]
@@ -494,7 +493,7 @@ class Selection
   # by the relevant grammars.
   autoIndentSelectedRows: ->
     [start, end] = @getBufferRowRange()
-    @editSession.autoIndentBufferRows(start, end)
+    @editor.autoIndentBufferRows(start, end)
 
   # Public: Wraps the selected lines in comments if they aren't currently part
   # of a comment.
@@ -503,7 +502,7 @@ class Selection
   #
   # Returns an Array of the commented {Range}s.
   toggleLineComments: ->
-    @editSession.toggleLineCommentsForBufferRows(@getBufferRowRange()...)
+    @editor.toggleLineCommentsForBufferRows(@getBufferRowRange()...)
 
   # Public: Cuts the selection until the end of the line.
   #
@@ -527,19 +526,19 @@ class Selection
   #   ?
   copy: (maintainPasteboard=false) ->
     return if @isEmpty()
-    text = @editSession.buffer.getTextInRange(@getBufferRange())
+    text = @editor.buffer.getTextInRange(@getBufferRange())
     if maintainPasteboard
       [currentText, metadata] = atom.pasteboard.read()
       text = currentText + '\n' + text
     else
-      metadata = { indentBasis: @editSession.indentationForBufferRow(@getBufferRange().start.row) }
+      metadata = { indentBasis: @editor.indentationForBufferRow(@getBufferRange().start.row) }
 
     atom.pasteboard.write(text, metadata)
 
   # Public: Creates a fold containing the current selection.
   fold: ->
     range = @getBufferRange()
-    @editSession.createFold(range.start.row, range.end.row)
+    @editor.createFold(range.start.row, range.end.row)
     @cursor.setBufferPosition([range.end.row + 1, 0])
 
   # Public: ?
@@ -592,9 +591,15 @@ class Selection
     @setBufferRange(@getBufferRange().union(otherSelection.getBufferRange()), options)
     otherSelection.destroy()
 
-  # Public: ?
-  compare: (other) ->
-    @getBufferRange().compare(other.getBufferRange())
+  # Public: Compare this selection's buffer range to another selection's buffer
+  # range.
+  #
+  # See {Range.compare} for more details.
+  #
+  # * otherSelection:
+  #   A {Selection} to compare with.
+  compare: (otherSelection) ->
+    @getBufferRange().compare(otherSelection.getBufferRange())
 
   # Public: Returns true if it was locally created.
   isLocal: ->

src/site-shim.coffee

@@ -1,3 +1,4 @@
+# Private: TODO remove once telepath upgrades are complete.
 module.exports =
 class SiteShim
   constructor: (document) ->
@@ -5,7 +6,6 @@ class SiteShim
 
   setRootDocument: (@document) ->
     @id = @document.siteId
-    @document.set('looseDocuments', [])
 
   createDocument: (values) ->
-    @document.get('looseDocuments').push(values)
+    @document.create({values})

src/space-pen-extensions.coffee

@@ -15,4 +15,78 @@ jQuery.cleanData = (elements) ->
       view.unsubscribe()
   originalCleanData(elements)
 
+tooltipDefaults =
+  delay:
+    show: 1000
+    hide: 100
+  container: 'body'
+  html: true
+  placement: 'auto top'
+  viewportPadding: 2
+
+modifiers =
+  cmd: '⌘'
+  ctrl: '⌃'
+  alt: '⌥'
+  option: '⌥'
+  shift: '⇧'
+  enter: '⏎'
+  left: '←'
+  right: '→'
+  up: '↑'
+  down: '↓'
+
+replaceKey = (key) ->
+  if modifiers[key]
+    modifiers[key]
+  else if key.length == 1 and key == key.toUpperCase() and key.toUpperCase() != key.toLowerCase()
+    [modifiers.shift, key.toUpperCase()]
+  else if key.length == 1
+    key.toUpperCase()
+  else
+    key
+
+replaceModifiersInSingleKeystroke = (keystroke) ->
+  keys = keystroke.split('-')
+  keys = _.flatten(replaceKey(key) for key in keys)
+  keys.join('')
+
+replaceModifiers = (keystroke) ->
+  keystrokes = keystroke.split(' ')
+  keystrokes = (replaceModifiersInSingleKeystroke(stroke) for stroke in keystrokes)
+  keystrokes.join(' ')
+
+getKeystroke = (bindings) ->
+  if bindings?.length
+    "<span class=\"keystroke\">#{replaceModifiers(bindings[0].keystroke)}</span>"
+  else
+    ''
+# options from http://getbootstrap.com/javascript/#tooltips
+jQuery.fn.setTooltip = (tooltipOptions, {command, commandElement}={}) ->
+  atom.requireWithGlobals('bootstrap/js/tooltip', {jQuery})
+
+  tooltipOptions = {title: tooltipOptions} if _.isString(tooltipOptions)
+
+  bindings = if commandElement
+    atom.keymap.keyBindingsForCommandMatchingElement(command, commandElement)
+  else
+    atom.keymap.keyBindingsForCommand(command)
+
+  tooltipOptions.title = "#{tooltipOptions.title} #{getKeystroke(bindings)}"
+
+  this.tooltip(jQuery.extend({}, tooltipDefaults, tooltipOptions))
+
+jQuery.fn.hideTooltip = ->
+  tip = @data('bs.tooltip')
+  if tip
+    tip.leave(currentTarget: this)
+    tip.hide()
+
+jQuery.fn.destroyTooltip = ->
+  @hideTooltip()
+  @tooltip('destroy')
+
+jQuery.fn.setTooltip.getKeystroke = getKeystroke
+jQuery.fn.setTooltip.replaceModifiers = replaceModifiers
+
 module.exports = spacePen

src/syntax.coffee

@@ -11,7 +11,7 @@ module.exports =
 class Syntax
   Emitter.includeInto(this)
 
-  registerDeserializer(this)
+  atom.deserializers.add(this)
 
   @deserialize: ({grammarOverridesByPath}) ->
     syntax = new Syntax()

src/task.coffee

@@ -86,7 +86,7 @@ class Task
     @callback = args.pop() if _.isFunction(args[args.length - 1])
     @send({event: 'start', args})
 
-  # Public: Send message to the task
+  # Public: Send message to the task.
   #
   # * message:
   #   The message to send

src/text-buffer.coffee

@@ -38,7 +38,7 @@ class TextBuffer extends telepath.Model
     @loadWhenAttached = @getState()?
 
   # Private: Called by telepath.
-  attached: ->
+  created: ->
     @loaded = false
     @useSerializedText = @modifiedWhenLastPersisted != false
 
@@ -63,12 +63,13 @@ class TextBuffer extends telepath.Model
     @updateCachedDiskContents().then => @finishLoading()
 
   finishLoading: ->
-    @loaded = true
-    if @useSerializedText and @digestWhenLastPersisted is @file?.getDigest()
-      @emitModifiedStatusChanged(true)
-    else
-      @reload()
-    @text.clearUndoStack()
+    if @isAlive()
+      @loaded = true
+      if @useSerializedText and @digestWhenLastPersisted is @file?.getDigest()
+        @emitModifiedStatusChanged(true)
+      else
+        @reload()
+      @text.clearUndoStack()
     this
 
   ### Internal ###
@@ -86,7 +87,7 @@ class TextBuffer extends telepath.Model
       @file?.off()
       @unsubscribe()
       @destroyed = true
-      @emit 'destroyed'
+      @emit 'destroyed', this
 
   isRetained: -> @refcount > 0
 
@@ -126,12 +127,12 @@ class TextBuffer extends telepath.Model
 
   # Identifies if the buffer belongs to multiple editors.
   #
-  # For example, if the {Editor} was split.
+  # For example, if the {EditorView} was split.
   #
   # Returns a {Boolean}.
   hasMultipleEditors: -> @refcount > 1
 
-  # Reloads a file in the {EditSession}.
+  # Reloads a file in the {Editor}.
   #
   # Sets the buffer's content to the cached disk contents
   reload: ->
@@ -670,9 +671,3 @@ class TextBuffer extends telepath.Model
     for row in [start..end]
       line = @lineForRow(row)
       console.log row, line, line.length
-
-  getDebugSnapshot: ->
-    lines = ['TextBuffer:']
-    for row in [0..@getLastRow()]
-      lines.push "#{row}: #{@lineForRow(row)}"
-    lines.join('\n')

src/text-mate-grammar.coffee

@@ -157,7 +157,16 @@ class TextMateGrammar
           ruleStack.pop()
         else if ruleStack.length > previousRuleStackLength # Stack size increased with zero length match
           [penultimateRule, lastRule] = ruleStack[-2..]
+
+          # Same exact rule was pushed but position wasn't advanced
+          if lastRule? and lastRule == penultimateRule
+            popStack = true
+
+          # Rule with same scope name as previous rule was pushed but position wasn't advanced
           if lastRule?.scopeName? and penultimateRule.scopeName == lastRule.scopeName
+            popStack = true
+
+          if popStack
             ruleStack.pop()
             tokens.push(new Token(
               value: line[position...line.length]

src/theme-manager.coffee

@@ -8,11 +8,9 @@ Package = require './package'
 AtomPackage = require './atom-package'
 {$} = require './space-pen-extensions'
 
-
 # Private: Handles discovering and loading available themes.
-###
-Themes are a subset of packages
-###
+#
+# Themes are a subset of packages
 module.exports =
 class ThemeManager
   Emitter.includeInto(this)
@@ -55,9 +53,13 @@ class ThemeManager
       # the first/top theme to override later themes in the stack.
       themeNames = _.clone(themeNames).reverse()
 
+      @refreshLessCache() # Update cache for packages in core.themes config
       @packageManager.activatePackage(themeName) for themeName in themeNames
+
+      @refreshLessCache() # Update cache again now that @getActiveThemes() is populated
       @loadUserStylesheet()
       @reloadBaseStylesheets()
+
       @emit('reloaded')
 
   # Internal-only:
@@ -66,6 +68,10 @@ class ThemeManager
     @packageManager.deactivatePackage(pack.name) for pack in @getActiveThemes()
     null
 
+  # Internal-only:
+  refreshLessCache: ->
+    @lessCache?.setImportPaths(@getImportPaths())
+
   # Public: Set the list of enabled themes.
   #
   # * enabledThemeNames: An {Array} of {String} theme names.
@@ -112,8 +118,8 @@ class ThemeManager
       @requireStylesheet(nativeStylesheetPath)
 
   # Internal-only:
-  stylesheetElementForId: (id) ->
-    $("""head style[id="#{id}"]""")
+  stylesheetElementForId: (id, htmlElement=$('html')) ->
+    htmlElement.find("""head style[id="#{id}"]""")
 
   # Internal-only:
   resolveStylesheet: (stylesheetPath) ->
@@ -128,10 +134,10 @@ class ThemeManager
   #   LESS file in the stylesheets path.
   #
   # Returns the absolute path to the stylesheet
-  requireStylesheet: (stylesheetPath) ->
+  requireStylesheet: (stylesheetPath, ttype = 'bundled', htmlElement) ->
     if fullPath = @resolveStylesheet(stylesheetPath)
       content = @loadStylesheet(fullPath)
-      @applyStylesheet(fullPath, content)
+      @applyStylesheet(fullPath, content, ttype = 'bundled', htmlElement)
     else
       throw new Error("Could not find a file at path '#{stylesheetPath}'")
 
@@ -146,9 +152,9 @@ class ThemeManager
 
   # Internal-only:
   loadLessStylesheet: (lessStylesheetPath) ->
-    unless lessCache?
+    unless @lessCache?
       LessCompileCache = require './less-compile-cache'
-      @lessCache = new LessCompileCache({@resourcePath})
+      @lessCache = new LessCompileCache({@resourcePath, importPaths: @getImportPaths()})
 
     try
       @lessCache.read(lessStylesheetPath)
@@ -170,12 +176,12 @@ class ThemeManager
     @stylesheetElementForId(@stringToId(fullPath)).remove()
 
   # Internal-only:
-  applyStylesheet: (path, text, ttype = 'bundled') ->
-    styleElement = @stylesheetElementForId(@stringToId(path))
+  applyStylesheet: (path, text, ttype = 'bundled', htmlElement=$('html')) ->
+    styleElement = @stylesheetElementForId(@stringToId(path), htmlElement)
     if styleElement.length
       styleElement.text(text)
     else
-      if $("head style.#{ttype}").length
-        $("head style.#{ttype}:last").after "<style class='#{ttype}' id='#{@stringToId(path)}'>#{text}</style>"
+      if htmlElement.find("head style.#{ttype}").length
+        htmlElement.find("head style.#{ttype}:last").after "<style class='#{ttype}' id='#{@stringToId(path)}'>#{text}</style>"
       else
-        $("head").append "<style class='#{ttype}' id='#{@stringToId(path)}'>#{text}</style>"
+        htmlElement.find("head").append "<style class='#{ttype}' id='#{@stringToId(path)}'>#{text}</style>"

src/token.coffee

@@ -135,9 +135,8 @@ class Token
       classes = 'hard-tab'
       classes += ' indent-guide' if hasIndentGuide
       classes += ' invisible-character' if invisibles.tab
-      html = @value.replace StartCharacterRegex, (match) =>
-        match = invisibles.tab ? match
-        "<span class='#{classes}'>#{@escapeString(match)}</span>"
+      value = if invisibles.tab then @value.replace(StartCharacterRegex, invisibles.tab) else @value
+      html = "<span class='#{classes}'>#{@escapeString(value)}</span>"
     else
       startIndex = 0
       endIndex = @value.length

src/tokenized-buffer.coffee

@@ -21,7 +21,7 @@ class TokenizedBuffer
   visible: false
 
   @acceptsDocuments: true
-  registerDeserializer(this)
+  atom.deserializers.add(this)
 
   @deserialize: (state) ->
     new this(state)
@@ -31,7 +31,7 @@ class TokenizedBuffer
       @state = optionsOrState
 
       # TODO: This needs to be made async, but should wait until the new Telepath changes land
-      @buffer = project.bufferForPathSync(optionsOrState.get('bufferPath'))
+      @buffer = atom.project.bufferForPathSync(optionsOrState.get('bufferPath'))
     else
       { @buffer, tabLength } = optionsOrState
       @state = atom.site.createDocument
@@ -39,7 +39,7 @@ class TokenizedBuffer
         bufferPath: @buffer.getPath()
         tabLength: tabLength ? atom.config.get('editor.tabLength') ? 2
 
-    @subscribe syntax, 'grammar-added grammar-updated', (grammar) =>
+    @subscribe atom.syntax, 'grammar-added grammar-updated', (grammar) =>
       if grammar.injectionSelector?
         @resetTokenizedLines() if @hasTokenForSelector(grammar.injectionSelector)
       else
@@ -50,6 +50,9 @@ class TokenizedBuffer
     @subscribe @buffer, "changed", (e) => @handleBufferChange(e)
     @subscribe @buffer, "path-changed", => @state.set('bufferPath', @buffer.getPath())
 
+    @subscribe atom.config.observe 'editor.tabLength', callNow: false, =>
+      @setTabLength(atom.config.getPositiveInt('editor.tabLength'))
+
     @reloadGrammar()
 
   serialize: -> @state.clone()
@@ -322,9 +325,3 @@ class TokenizedBuffer
     for row in [start..end]
       line = @lineForScreenRow(row).text
       console.log row, line, line.length
-
-  getDebugSnapshot: ->
-    lines = ["Tokenized Buffer:"]
-    for screenLine, row in @linesForScreenRows(0, @getLastRow())
-      lines.push "#{row}: #{screenLine.text}"
-    lines.join('\n')

src/window-bootstrap.coffee

@@ -1,10 +1,13 @@
 # Like sands through the hourglass, so are the days of our lives.
 startTime = Date.now()
 
+# Start the crash reporter before anything else.
+require('crash-reporter').start(productName: 'Atom', companyName: 'GitHub')
+
 require './window'
 
 Atom = require './atom'
 window.atom = new Atom()
-window.setUpEnvironment('editor')
-window.startEditorWindow()
+atom.setUpEnvironment('editor')
+atom.startEditorWindow()
 console.log "Window load time: #{Date.now() - startTime}ms"

src/window-event-handler.coffee

@@ -16,8 +16,8 @@ class WindowEventHandler
     @subscribe ipc, 'command', (command, args...) ->
       activeElement = document.activeElement
       # Use root view if body has focus
-      if activeElement is document.body and atom.rootView?
-        activeElement = atom.rootView
+      if activeElement is document.body and atom.workspaceView?
+        activeElement = atom.workspaceView
       $(activeElement).trigger(command, args...)
 
     @subscribe ipc, 'context-command', (command, args...) ->
@@ -29,10 +29,10 @@ class WindowEventHandler
 
     @subscribe $(window), 'window:open-path', (event, {pathToOpen, initialLine}) ->
       unless fs.isDirectorySync(pathToOpen)
-        atom.rootView?.open(pathToOpen, {initialLine})
+        atom.workspaceView?.open(pathToOpen, {initialLine})
 
     @subscribe $(window), 'beforeunload', =>
-      confirmed = atom.rootView?.confirmClose()
+      confirmed = atom.workspaceView?.confirmClose()
       atom.hide() if confirmed and not @reloadRequested and atom.getCurrentWindow().isWebViewFocused()
       @reloadRequested = false
       confirmed

src/window.coffee

@@ -1,120 +1,6 @@
-path = require 'path'
-{$} = require './space-pen-extensions'
-_ = require 'underscore-plus'
-ipc = require 'ipc'
-WindowEventHandler = require './window-event-handler'
-
-### Internal ###
-
-windowEventHandler = null
-
-# Schedule the window to be shown and focused on the next tick
-#
-# This is done in a next tick to prevent a white flicker from occurring
-# if called synchronously.
-displayWindow = ->
-  setImmediate ->
-    atom.show()
-    atom.focus()
-
-# This method is called in any window needing a general environment, including specs
-window.setUpEnvironment = (windowMode) ->
-  atom.windowMode = windowMode
-  window.resourcePath = atom.getLoadSettings().resourcePath
-  atom.initialize()
-  #TODO remove once all packages use the atom global
-  window.config = atom.config
-  window.syntax = atom.syntax
-  window.pasteboard = atom.pasteboard
-  window.keymap = atom.keymap
-  window.site = atom.site
-
-# Set up the default event handlers and menus for a non-editor windows.
-#
-# This can be used by packages to have a minimum level of keybindings and
-# menus available when not using the standard editor window.
-#
-# This should only be called after setUpEnvironment() has been called.
-window.setUpDefaultEvents = ->
-  windowEventHandler = new WindowEventHandler
-  atom.keymap.loadBundledKeymaps()
-  atom.menu.update()
-
-# This method is only called when opening a real application window
-window.startEditorWindow = ->
-  if process.platform is 'darwin'
-    installAtomCommand()
-    installApmCommand()
-
-  windowEventHandler = new WindowEventHandler
-  atom.restoreDimensions()
-  atom.config.load()
-  atom.config.setDefaults('core', require('./root-view').configDefaults)
-  atom.config.setDefaults('editor', require('./editor').configDefaults)
-  atom.keymap.loadBundledKeymaps()
-  atom.themes.loadBaseStylesheets()
-  atom.packages.loadPackages()
-  deserializeEditorWindow()
-  atom.packages.activate()
-  atom.keymap.loadUserKeymap()
-  atom.requireUserInitScript()
-  atom.menu.update()
-  $(window).on 'unload', ->
-    $(document.body).hide()
-    unloadEditorWindow()
-    false
-
-  displayWindow()
-
-window.unloadEditorWindow = ->
-  return if not atom.project and not atom.rootView
-  windowState = atom.getWindowState()
-  windowState.set('project', atom.project)
-  windowState.set('syntax', atom.syntax.serialize())
-  windowState.set('rootView', atom.rootView.serialize())
-  atom.packages.deactivatePackages()
-  windowState.set('packageStates', atom.packages.packageStates)
-  atom.saveWindowState()
-  atom.rootView.remove()
-  atom.project.destroy()
-  windowEventHandler?.unsubscribe()
-  window.rootView = null
-  window.project = null
-
-installAtomCommand = (callback) ->
-  commandPath = path.join(window.resourcePath, 'atom.sh')
-  require('./command-installer').install(commandPath, callback)
-
-installApmCommand = (callback) ->
-  commandPath = path.join(window.resourcePath, 'node_modules', '.bin', 'apm')
-  require('./command-installer').install(commandPath, callback)
-
-window.deserializeEditorWindow = ->
-  atom.deserializePackageStates()
-  atom.deserializeProject()
-  window.project = atom.project
-  atom.deserializeRootView()
-  window.rootView = atom.rootView
-
 window.onerror = ->
   atom.openDevTools()
 
-#TODO remove once all packages use the atom global
-window.registerDeserializers = (args...) ->
-  atom.deserializers.add(args...)
-window.registerDeserializer = (args...) ->
-  atom.deserializers.add(args...)
-window.registerDeferredDeserializer = (args...) ->
-  atom.deserializers.addDeferred(args...)
-window.unregisterDeserializer = (args...) ->
-  atom.deserializers.remove(args...)
-window.deserialize = (args...) ->
-  atom.deserializers.deserialize(args...)
-window.getDeserializer = (args...) ->
-  atom.deserializers.get(args...)
-window.requireWithGlobals = (args...) ->
-  atom.requireWithGlobals(args...)
-
 # Public: Measure how long a function takes to run.
 #
 # * description:
@@ -124,9 +10,9 @@ window.requireWithGlobals = (args...) ->
 #
 # Returns the value returned by the given function.
 window.measure = (description, fn) ->
-  start = new Date().getTime()
+  start = Date.now()
   value = fn()
-  result = new Date().getTime() - start
+  result = Date.now() - start
   console.log description, result
   value