Prepare 0.43.0 release

Update to atom-shell v0.7.6.

.gitattributes

@@ -0,0 +1,8 @@
+# Specs depend on character counts, if we don't specify the line endings the
+# fixtures will vary depending on platform
+spec/fixtures/**/*.js text eol=lf
+spec/fixtures/**/*.coffee text eol=lf
+spec/fixtures/**/*.less text eol=lf
+spec/fixtures/**/*.css text eol=lf
+spec/fixtures/**/*.txt text eol=lf
+spec/fixtures/dir/**/* text eol=lf

.gitignore

@@ -5,6 +5,7 @@
 .nvm-version
 node_modules
 npm-debug.log
+debug.log
 /tags
 /atom-shell/
 docs/output

CONTRIBUTING.md

@@ -1,69 +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
-  * Follow the [JavaScript](https://github.com/styleguide/javascript),
-    [CSS](https://github.com/styleguide/css),
-    and [Objective-C](https://github.com/github/objective-c-conventions)
-    styleguides
+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
-  * Be ware 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.
+  * Beware of platform differences
+    * 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,7 +7,15 @@ _ = 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
+    grunt.log.write = (args...) -> grunt.log
+
   [major, minor, patch] = packageJson.version.split('.')
   if process.platform is 'win32'
     appName = 'Atom'
@@ -16,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'
@@ -24,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)
 
@@ -164,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'
@@ -179,17 +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'])
-
-  defaultTasks = ['update-atom-shell', 'build']
-  defaultTasks.push('set-development-version') if process.platform is 'darwin'
-  defaultTasks.push('install')
-  grunt.registerTask('default', defaultTasks)
+  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,26 +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://atom-docs.githubapp.com/v26.0/index.html) and [API documentation](https://atom-docs.githubapp.com/v26.0/api/index.html).
+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
+Follow the instructions in the [build docs][building].
 
-  * Mountain Lion
-  * Boxen (Obviously Atom won't release with this requirement)
-
-### Installation
-
-  1. `gh-setup atom`
-
-  2. `cd ~/github/atom`
-
-  3. `script/build`
+[building]: https://github.com/atom/atom/blob/master/docs/building-atom.md

benchmark/benchmark-helper.coffee

@@ -3,7 +3,6 @@ require '../spec/spec-helper'
 path = require 'path'
 {$, _, Point, fs} = require 'atom'
 Project = require '../src/project'
-fsUtils = require '../src/fs-utils'
 TokenizedBuffer = require '../src/tokenized-buffer'
 
 defaultCount = 100
@@ -74,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}
@@ -87,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

@@ -0,0 +1,34 @@
+## Building Atom
+
+These guide is meant only for users who wish to help develop atom core,
+if you're just interested in using atom you should just [download
+atom][download].
+
+## OSX
+
+* 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/build`
+
+## Windows
+
+* Install [Visual C++ 2010 Express][win-vs2010]
+* Install the [latest 32bit Node 0.10.x][win-node]
+* Install the [latest Python 2.7.x][win-python]
+* Install [GitHub for Windows][win-github]
+* Clone [atom/atom][atom-git] to `C:\Users\<user>\github\atom\`
+* Add `C:\Python27;C:\Program Files\nodejs;C:\Users\<user>\github\atom\node_modules\`
+  to your PATH
+* Set ATOM_ACCESS_TOKEN to your oauth2 credentials (run `security -q
+  find-generic-password -ws 'GitHub API Token'` on OSX to get your
+  credentials).
+* Use the Windows GitHub shell and cd into `C:\Users\<user>\github\atom`
+* Run `script\bootstrap`
+
+[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/
+[win-vs2010]: http://www.microsoft.com/visualstudio/eng/products/visual-studio-2010-express
+[atom-git]: https://github.com/atom/atom/

docs/creating-a-package.md

@@ -1,12 +1,11 @@
-# Authoring Packages
+# Creating Packages
 
 Packages are at the core of Atom. Nearly everything outside of the main editor
-is handled by a package. That includes "core" pieces like the file tree, status
-bar and more.
+is handled by a package. That includes "core" pieces like the [file tree][file-tree],
+[status bar][status-bar], [syntax highlighting][cs-syntax], and more.
 
 A package can contain a variety of different resource types to change Atom's
-behavior. The basic package layout is as follows (though not every package will
-have all of these directories):
+behavior. The basic package layout is as follows:
 
 ```text
 my-package/
@@ -21,9 +20,13 @@ my-package/
   package.json
 ```
 
+Not every package will have (or need) all of these directories.
+
+We have [a tutorial on creating your first package][first-package].
+
 ## package.json
 
-Similar to [npm packages][npm], Atom packages can contain a _package.json_ file
+Similar to [npm packages][npm], Atom packages contain a _package.json_ file
 in their top-level directory. This file contains metadata about the package,
 such as the path to its "main" module, library dependencies, and manifests
 specifying the order in which its resources should be loaded.
@@ -64,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
@@ -83,23 +86,25 @@ you don't need to worry because that's getting torn down anyway.
 
 ### Simple Package Code
 
+Your directory would look like this:
+
 ```text
 my-package/
-  package.json # optional
+  package.json
   index.coffee
   lib/
     my-package.coffee
 ```
 
-`index.coffee`:
+`index.coffee` might be:
 ```coffeescript
 module.exports = require "./lib/my-package"
 ```
 
-`my-package/my-package.coffee`:
+`my-package/my-package.coffee` might start:
 ```coffeescript
 module.exports =
-  activate: (rootView, state) -> # ...
+  activate: (state) -> # ...
   deactivate: -> # ...
   serialize: -> # ...
 ```
@@ -111,8 +116,6 @@ Also, please collaborate with us if you need an API that doesn't exist. Our goal
 is to build out Atom's API organically based on the needs of package authors
 like you.
 
-Check out [wrap-guide] for a simple example of Atom's package API in action.
-
 ## Stylesheets
 
 Stylesheets for your package should be placed in the _stylesheets_ directory.
@@ -120,14 +123,16 @@ Any stylesheets in this directory will be loaded and attached to the DOM when
 your package is activated. Stylesheets can be written as CSS or [LESS] (but LESS
 is recommended).
 
-Ideally you will not need much in the way of styling. We've provided a standard
-set of components. You can view all components by opening the styleguide: open
-the command palette (`cmd-p`) and search for _styleguide_ or just
-`cmd-ctrl-shift-g`.
+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-shift-P`) and search for _styleguide_,
+or just type `cmd-ctrl-G`.
 
-If you do need styling, we try to keep only structural styles in the package
-stylesheets. Colors and sizing should be taken from the active theme's
-[ui-variables.less][ui-variables]. If you follow this guideline, your package
+If you _do_ need special styling, try to keep only structural styles in the package
+stylesheets. If you _must_ specify colors and sizing, these should be taken from
+the active theme's [ui-variables.less][ui-variables]. For more information, see the
+[theme variables docs][theme-variables]. If you follow this guideline, your package
 will look good out of the box with any theme!
 
 An optional `stylesheets` array in your _package.json_ can list the stylesheets
@@ -136,18 +141,23 @@ alphabetically.
 
 ## Keymaps
 
+It's recommended that you provide key bindings for commonly used actions for
+your extension, especially if you're also adding a new command:
+
 ```coffeescript
 '.tree-view-scroller':
   'ctrl-V': 'changer:magic'
 ```
 
-It's recommended that you provide key bindings for commonly used actions for
-your extension, especially if you're also adding a new command.
-
 Keymaps are placed in the _keymaps_ subdirectory. By default, all keymaps are
 loaded in alphabetical order. An optional `keymaps` array in your _package.json_
 can specify which keymaps to load and in what order.
 
+
+Keybindings are executed by determining which element the keypress occured on. In
+the example above, `changer:magic` command is executed when pressing `ctrl-V` on
+the `.tree-view-scroller` element.
+
 See the [main keymaps documentation][keymaps] for more detailed information on
 how keymaps work.
 
@@ -159,6 +169,9 @@ specify which menus to load and in what order.
 
 ### Application Menu
 
+It's recommended that you create an application menu item for common actions
+with your package that aren't tied to a specific element:
+
 ```coffee-script
 'menu': [
   {
@@ -178,32 +191,28 @@ specify which menus to load and in what order.
 ]
 ```
 
-It's recommended that you create an application menu item for common actions
-with your package that aren't tied to a specific element.
-
-To add your own item to the application menu simply create a top level `menu`
-key in any menu configuration file in _menus_ (since the above is [CSON] it
-should end with `.cson`)
+To add your own item to the application menu, simply create a top level `menu`
+key in any menu configuration file in _menus_. This can be a JSON or [CSON] file.
 
 The menu templates you specify are merged with all other templates provided
 by other packages in the order which they were loaded.
 
 ### Context Menu
 
+It's recommended to specify a context menu item for commands that are linked to
+specific parts of the interface, like adding a file in the tree-view:
+
 ```coffee-script
 'context-menu':
   '.tree-view':
     'Add file': 'tree-view:add-file'
-  '#root-view':
+  '.workspace':
     'Inspect Element': 'core:inspect'
 ```
 
-It's recommended to specify a context menu item for commands that are linked to
-specific parts of the interface, like adding a file in the tree-view.
-
 To add your own item to the application menu simply create a top level
-`context-menu` key in any menu configuration file in _menus_ (since the above is
-[CSON] it should end with `.cson`)
+`context-menu` key in any menu configuration file in _menus_. This can be a
+JSON or [CSON] file.
 
 Context menus are created by determining which element was selected and
 then adding all of the menu items whose selectors match that element (in
@@ -216,7 +225,7 @@ or one of its parents has the `tree-view` class applied to it.
 ## Snippets
 
 An extension can supply language snippets in the _snippets_ directory which
-allows the user to enter repetitive text quickly.
+allows the user to enter repetitive text quickly:
 
 ```coffeescript
 ".source.coffee .specs":
@@ -302,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.
@@ -312,8 +321,8 @@ You can also use the `atom` protocol URLs in themes.
 Your package **should** have tests, and if they're placed in the _spec_
 directory, they can be run by Atom.
 
-Under the hood, [Jasmine] is being used to execute the tests, so you can
-assume that any DSL available there is available to your package as well.
+Under the hood, [Jasmine] executes your tests, so you can assume that any DSL
+available there is available to your package as well.
 
 **FIXME: Explain the following**
 
@@ -323,7 +332,9 @@ assume that any DSL available there is available to your package as well.
 * setTimeout
 * whatever else is different in spec-helper
 
-## Running tests
+## Running Tests
+
+TODO: Probably use the menu option now.
 
 Once you've got your test suite written, the recommended way to run it is `apm
 test`. `apm test` prints its output to the console and returns the proper status
@@ -349,257 +360,7 @@ registry.
 Run `apm help publish` to see all the available options and `apm help` to see
 all the other available commands.
 
-
-# Full Example
-
-Let's take a look at creating our first package.
-
-To get started hit `cmd-p`, and start typing "Package Generator." to generate
-the package. Once you select the package generator command, it'll ask you for a
-name for your new package. Let's call ours _changer_.
-
-Now, _changer_ is going to have a default set of folders and files created for
-us. Hit `cmd-r` to reload Atom, then hit `cmd-p` and start typing "Changer."
-You'll see a new `Changer:Toggle` command which, if selected, pops up a new
-message. So far, so good!
-
-In order to demonstrate the capabilities of Atom and its API, our Changer plugin
-is going to do two things:
-
-1. It'll show only modified files in the file tree
-2. It'll append a new pane to the editor with some information about the modified
-files
-
-Let's get started!
-
-## Changing Keybindings and Commands
-
-Since Changer is primarily concerned with the file tree, let's write a
-key binding that works only when the tree is focused. Instead of using the
-default `toggle`, our keybinding executes a new command called `magic`.
-
-_keymaps/changer.cson_ can easily become this:
-
-```coffeescript
-'.tree-view':
-  'ctrl-V': 'changer:magic'
-```
-
-Notice that the keybinding is called `ctrl-V` — that's actually `ctrl-shift-v`.
-You can use capital letters to denote using `shift` for your binding.
-
-`.tree-view` represents the parent container for the tree view.
-Keybindings only work within the context of where they're entered. For example,
-hitting `ctrl-V` anywhere other than tree won't do anything. 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 use the `rootView.command` method. This
-takes a command name and executes a function in the code. For example:
-
-```coffeescript
-rootView.command "changer:magic", => @magic()
-```
-
-It's common practice to namespace your commands with your package name, and
-separate it with a colon (`:`). Rename the existing `toggle` method to `magic`
-to get the binding to work.
-
-Reload the editor, click on the tree, hit your keybinding, and...nothing
-happens! What the heck?!
-
-Open up the _package.json_ file, and notice the key that says
-`activationEvents`. Basically, this tells Atom to not load a package until it
-hears a certain event. Let's change the event to `changer:magic` and reload the
-editor.
-
-Hitting the key binding on the tree now works!
-
-## Working with Styles
-
-The next step is to hide elements in the tree that aren't modified. To do that,
-we'll first try and get a list of files that have not changed.
-
-All packages are able to use jQuery in their code. In fact, we have [a list of
-some of the bundled libraries Atom provides by default](#included-libraries).
-
-Let's bring in jQuery:
-
-```coffeescript
-{$} = require 'atom'
-```
-
-Now, we can query the tree to get us a list of every file that _wasn't_
-modified:
-
-```coffeescript
-magic: ->
-  $('ol.entries li').each (i, el) ->
-    if !$(el).hasClass("modified")
-      console.log el
-```
-
-You can access the dev console by hitting `alt-cmd-i`. When we execute the
-`changer:magic` command, the browser console lists the items that are not being
-modified. Let's add a class to each of these elements called `hide-me`:
-
-```coffeescript
-magic: ->
-  $('ol.entries li').each (i, el) ->
-    if !$(el).hasClass("modified")
-      $(el).addClass("hide-me")
-```
-
-With our newly added class, we can manipulate the visibility of the elements
-with a simple stylesheet. Open up _changer.css_ in the _stylesheets_ directory,
-and add a single entry:
-
-```css
-ol.entries .hide-me {
-  display: none;
-}
-```
-
-Refresh atom, and run the `changer` command. You'll see all the non-changed
-files disappear from the tree. There are a number of ways you can get the list
-back; let's just naively iterate over the same elements and remove the class:
-
-```coffeescript
-magic: ->
-  $('ol.entries li').each (i, el) ->
-    if !$(el).hasClass("modified")
-      if !$(el).hasClass("hide-me")
-        $(el).addClass("hide-me")
-      else
-        $(el).removeClass("hide-me")
-```
-
-## Creating a New Panel
-
-The next goal of this package is to append a panel to the Atom editor that lists
-some information about the modified files.
-
-To do that, we're going to first create a new class method called `content`.
-Every package that extends from the `View` class can provide an optional class
-method called `content`. The `content` method constructs the DOM that your
-package uses as its UI. The principals of `content` are built entirely on
-[SpacePen], which we'll touch upon only briefly here.
-
-Our display will simply be an unordered list of the file names, and their
-modified times. Let's start by carving out a `div` to hold the filenames:
-
-```coffeescript
-@content: ->
-  @div class: 'modified-files-container', =>
-    @ul class: 'modified-files-list', outlet: 'modifiedFilesList', =>
-      @li 'Test'
-      @li 'Test2'
-```
-
-You can add any HTML5 attribute you like. `outlet` names the variable your
-package can uses to manipulate the element directly. The fat pipe (`=>`)
-indicates that the next set are nested children.
-
-We'll add one more line to `magic` to make this pane appear:
-
-```coffeescript
-rootView.vertical.append(this)
-```
-
-If you hit the key command, you'll see a box appear right underneath the editor.
-Success!
-
-Before we populate this, let's apply some logic to toggle the pane off and on,
-just like we did with the tree view:
-
-```coffeescript
-# toggles the pane
-if @hasParent()
-  rootView.vertical.children().last().remove()
-else
-  rootView.vertical.append(this)
-```
-
-There are about a hundred different ways to toggle a pane on and off, and this
-might not be the most efficient one. If you know your package needs to be
-toggled on and off more freely, it might be better to draw the interface during the
-initialization, then immediately call `hide()` on the element to remove it from
-the view. You can then swap between `show()` and `hide()`, and instead of
-forcing Atom to add and remove the element as we're doing here, it'll just set a
-CSS property to control your package's visibility.
-
-Refresh Atom, hit the key combo, and see your test list.
-
-## Calling Node.js Code
-
-Since Atom is built on top of Node.js, you can call any of its libraries,
-including other modules that your package requires.
-
-We'll iterate through our resulting tree, and construct the path to our modified
-file based on its depth in the tree:
-
-```coffeescript
-path = require 'path'
-
-# ...
-
-modifiedFiles = []
-# for each single entry...
-$('ol.entries li.file.modified span.name').each (i, el) ->
-  filePath = []
-  # ...grab its name...
-  filePath.unshift($(el).text())
-
-  # ... then find its parent directories, and grab their names
-  parents = $(el).parents('.directory.modified')
-  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))
-  modifiedFiles.push modifiedFilePath
-```
-
-`modifiedFiles` is an array containing a list of our modified files. We're also
-using the node.js [`path` library][path] to get the proper directory separator
-for our system.
-
-Let's remove the two `@li` elements we added in `@content`, so that we can
-populate our `modifiedFilesList` with real information. We'll do that by
-iterating over `modifiedFiles`, accessing a file's last modified time, and
-appending it to `modifiedFilesList`:
-
-```coffeescript
-# toggles the pane
-if @hasParent()
-  rootView.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)
-```
-
-When you toggle the modified files list, your pane is now populated with the
-filenames and modified times of files in your project. You might notice that
-subsequent calls to this command reduplicate information. We could provide an
-elegant way of rechecking files already in the list, but for this demonstration,
-we'll just clear the `modifiedFilesList` each time it's closed:
-
-```coffeescript
-# toggles the pane
-if @hasParent()
-  @modifiedFilesList.empty()
-  rootView.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)
-```
-
-# Included Libraries
+## Included Libraries
 
 FIXME: Describe `require 'atom'
 
@@ -612,12 +373,16 @@ popular libraries into their packages:
 
 Additional libraries can be found by browsing Atom's *node_modules* folder.
 
+[file-tree]: https://github.com/atom/tree-view
+[status-bar]: https://github.com/atom/status-bar
+[cs-syntax]: https://github.com/atom/language-coffee-script
 [npm]: http://en.wikipedia.org/wiki/Npm_(software)
 [npm-keys]: https://npmjs.org/doc/json.html
 [apm]: https://github.com/atom/apm
 [git-tag]: http://git-scm.com/book/en/Git-Basics-Tagging
 [wrap-guide]: https://github.com/atom/wrap-guide/
 [keymaps]: internals/keymaps.md
+[theme-variables]: theme-variables.md
 [tm-tokens]: http://manual.macromates.com/en/language_grammars.html
 [spacepen]: https://github.com/nathansobo/space-pen
 [path]: http://nodejs.org/docs/latest/api/path.html
@@ -627,3 +392,4 @@ Additional libraries can be found by browsing Atom's *node_modules* folder.
 [cson]: https://github.com/atom/season
 [less]: http://lesscss.org
 [ui-variables]: https://github.com/atom/atom-dark-ui/blob/master/stylesheets/ui-variables.less
+[first-package]: your-first-package.html

docs/creating-a-theme.md

@@ -1,72 +1,67 @@
 # Creating a Theme
 
-Atom's interface is rendered using HTML and it's styled via [LESS] (a superset
-of CSS). Don't worry if you haven't heard of LESS before, it's just like CSS but
+Atom's interface is rendered using HTML, and it's styled via [LESS] (a superset
+of CSS). Don't worry if you haven't heard of LESS before; it's just like CSS, but
 with a few handy extensions.
 
 Since CSS is the basis of the theming system, we can load multiple themes within
-Atom and they behaves just as they would on a website. Themes loaded first are overridden by
-themes which are loaded later (the order is controlled from within the Settings
-pane).
+Atom, and the themes behave just as they would on a website. Themes loaded first
+are overridden by themes which are loaded later. The order of theme loading is
+controlled within the Settings/Themes pane.
 
-This flexibility is helpful for users which prefer a light interface with a dark
-syntax theme. Atom currently has only interface and syntax themes but it is
-possible to create a theme to style something specific — say a changing
+This flexibility is helpful for users that prefer a light interface with a dark
+syntax theme. Atom currently has only interface and syntax themes, but it is
+possible to create a theme to style something specific — say, changing
 the colors in the tree view or creating a language specific syntax theme.
 
 ## Getting Started
 
-To create your own theme you'll need a few things:
-
-* A working install of [Atom], so you can work on your new theme.
-* A working install of [git] to track changes.
-* And a [GitHub] account, so you can distribute your themes.
-
 Themes are pretty straight forward but it's still helpful to be familiar with
 a few things before starting:
 
-* LESS is a superset of CSS but it has some really handy features like
+* LESS is a superset of CSS, but it has some really handy features like
   variables. If you aren't familiar with its syntax take a few minutes
   to [familiarize yourself][less-tutorial].
-* Atom uses Chrome at its core, so you can use Chrome devtools to
-  inspect the current state of the interface. Checkout Google's
-  [extensive tutorial][devtools-tutorial] for a short introduction.
+* You may also want to review the concept of a _[package.json]_, too. This file
+is used to help distribute your theme to Atom users.
 
-## Creating a Minimal Syntax Theme
+There are two types of themes you can create: syntax themes and interface themes.
+The differences between them are simply a matter of what they target and what
+they provide. Syntax themes focus on the entire editor pane, while interface themes
+target elements which are outside of the editor.
 
-1. Open the Command Palette (`cmd-p`)
-1. Search for `Package Generator: Generate Syntax Theme` and select it.
-1. Choose a name for your theme. A folder will be created with this name.
-1. Press enter to create your theme. After creation, your theme will be
-   installed and enabled.
-1. An Atom window will open with your newly created theme.
-  1. Open `package.json` and update the relevant parts.
-  1. Open `stylesheets/colors.less` to change the various colors variables which
-     have been already been defined.
-  1. Open `stylesheets/base.less` and modify the various syntax CSS selectors
-     that have been already been defined.
-  1. When you're ready, update the `README.md` and include an example screenshot
-     of your new theme in action.
-1. Reload atom (`cmd-r`) to see changes you made reflected in your Atom window.
-1. Look in the theme settings, your new theme should be show in the enabled themes section
-    ![themesettings-img]
-1. Open a terminal to your new theme directory; it should be in `~/.atom/packages/<my-name>`.  
-  1. To publish, initialize a git repository, push to GitHub, and run
-     `apm publish`.
+## Creating a Syntax Theme
 
-Want to make edits and have them immediately show up without reloading? Open a
-development window (__View > Developer > Open in Dev Mode__ menu) to the
-directory of your choice &mdash; even the new theme itself. Then just edit away!
-Changes will be instantly reflected in the editor without having to reload.
+Let's create your first theme.
 
-## Interface Themes
+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_.
 
-There are only two differences between interface and syntax themes - what
-they target and what they provide. Interface themes only target elements which
-are outside of the editor and **must** provide a `ui-variables.less` file which
-contains all of the variables provided by the [core themes][ui-variables].
+Atom will pop open a new window, showing the _motif_ theme, with a default set of
+folders and files created for us. If you hit `cmd-,` and navigate to the Themes
+menu option, you'll see the `motif` theme already available. Drag it over from
+"Enabled Themes" to "Available Themes."
 
-To create a UI theme, do the following:
+Open up _stylesheets/colors.less_ to change the various colors variables which
+have been already been defined. For example, turn `@red` into `#f4c2c1`.
+
+Then, open _stylesheets/base.less_, and modify the various syntax CSS selectors
+that have been already been defined. Each of these selectors represents a different
+part of the Atom window. Themes that don't need to modify a particular region
+can simply remove the selectors they don't need.
+
+As an example, let's make the `.gutter` `background-color` into `@red`.
+
+Reload Atom by hitting `cmd-r` to see the changes you made reflected in your Atom
+window. Pretty neat!
+
+## Creating an Interface Theme
+
+Interface themes  **must** provide a `ui-variables.less` file which contains all
+of the variables provided by the [core themes][ui-variables].
+
+To create an interface UI theme, do the following:
 
 1. Fork one of the following repos
   1. [atom-dark-ui]
@@ -82,50 +77,55 @@ To create a UI theme, do the following:
 
 ## Development workflow
 
-There are a few of tools to help make theme development fast.
+There are a few of tools to help make theme development faster.
 
 ### Live Reload
 
-Reloading via `cmd-r` after you make changes to your theme less than ideal. Atom
-supports [live updating][livereload] of styles on Dev Mode Atom windows.
+Reloading by hitting `cmd-r` after you make changes to your theme is less than ideal.
+Atom supports [live updating][livereload] of styles on Dev Mode Atom windows.
 
-1. Open your theme directory in a dev window by either using the
-__View > Developer > Open in Dev Mode__ menu or the `cmd-shift-o` shortcut
-1. Make a change to your theme file and save &mdash; your change should be
+To enable a Dev Mode window:
+
+1. Open your theme directory in a dev window by either going to the
+__View > Developer > Open in Dev Mode__ menu or by hitting the `cmd-shift-o`
+shortcut
+1. Make a change to your theme file and save it. Your change should be
 immediately applied!
 
-If you'd like to reload all styles at any time, you can use the shortcut
-`cmd-ctrl-shift-r`.
+If you'd like to reload all the styles at any time, you can use the shortcut
+`cmd-ctrl-R`.
 
 ### Developer Tools
 
 Atom is based on the Chrome browser, and supports Chrome's Developer Tools. You
-can open them by selecting the __View > Toggle Developer Tools__ menu or by using the
-`cmd-option-i` shortcut.
+can open them by selecting the __View > Toggle Developer Tools__ menu, or by using
+the `cmd-option-i` shortcut.
 
 The dev tools allow you to inspect elements and take a look at their CSS
 properties.
 
 ![devtools-img]
 
+Check out Google's [extensive tutorial][devtools-tutorial] for a short introduction.
+
 ### Atom Styleguide
 
 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
-_styleguide_ or use the shortcut `cmd-ctrl-shift-g`.
+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]
 
 [less]: http://lesscss.org/
 [git]: http://git-scm.com/
 [atom]: https://atom.io/
-[github]: https://github.com/
+[package.json]: ./creating-a-package.html#package-json
 [less-tutorial]: https://speakerdeck.com/danmatthews/less-css
 [devtools-tutorial]: https://developers.google.com/chrome-developer-tools/docs/elements
-[ui-variables]: https://github.com/atom/atom-dark-ui/blob/master/stylesheets/ui-variables.less
+[ui-variables]: ./theme-variables.html
 [livereload]: https://github.com/atom/dev-live-reload
 [styleguide]: https://github.com/atom/styleguide
 [atom-dark-ui]: https://github.com/atom/atom-dark-ui

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
@@ -45,6 +55,10 @@ By default, `~/.atom/keymap.cson` is loaded when Atom is started. It will always
 be loaded last, giving you the chance to override bindings that are defined by
 Atom's core keymaps or third-party packages.
 
+You'll want to know all the commands available to you. Open the Settings panel
+(`cmd-,`) and select the _Keybindings_ tab. It will show you all the keybindings
+currently in use.
+
 ## Advanced Configuration
 
 Atom loads configuration settings from the `config.cson` file in your _~/.atom_

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/index.md

@@ -6,6 +6,7 @@
 * [Creating a Theme](creating-a-theme.md)
 
 ### Advanced Topics
+
 * [Configuration](internals/configuration.md)
 * [Keymaps](internals/keymaps.md)
 * [Serialization](internals/serialization.md)

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/template.jst

@@ -0,0 +1,150 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
+    <link href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css" rel="stylesheet">
+    <link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap-theme.min.css">
+    <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
+    <!--[if lt IE 9]>
+      <script src="../../assets/js/html5shiv.js"></script>
+      <script src="../../assets/js/respond.min.js"></script>
+    <![endif]-->
+
+    <title>Atom - <%= title %></title>
+    <style>
+      /*github.com style (c) Vasily Polovnyov <vast@whiteants.net>*/
+      pre code {
+        display: block; padding: 0.5em;
+        color: #333;
+        background: #f8f8ff
+      }
+      pre .comment,
+      pre .template_comment,
+      pre .diff .header,
+      pre .javadoc {
+        color: #998;
+        font-style: italic
+      }
+      pre .keyword,
+      pre .css .rule .keyword,
+      pre .winutils,
+      pre .javascript .title,
+      pre .nginx .title,
+      pre .subst,
+      pre .request,
+      pre .status {
+        color: #333;
+        font-weight: bold
+      }
+      pre .number,
+      pre .hexcolor,
+      pre .ruby .constant {
+        color: #099;
+      }
+      pre .string,
+      pre .tag .value,
+      pre .phpdoc,
+      pre .tex .formula {
+        color: #d14
+      }
+      pre .title,
+      pre .id {
+        color: #900;
+        font-weight: bold
+      }
+      pre .javascript .title,
+      pre .lisp .title,
+      pre .clojure .title,
+      pre .subst {
+        font-weight: normal
+      }
+      pre .class .title,
+      pre .haskell .type,
+      pre .vhdl .literal,
+      pre .tex .command {
+        color: #458;
+        font-weight: bold
+      }
+      pre .tag,
+      pre .tag .title,
+      pre .rules .property,
+      pre .django .tag .keyword {
+        color: #000080;
+        font-weight: normal
+      }
+      pre .attribute,
+      pre .variable,
+      pre .lisp .body {
+        color: #008080
+      }
+      pre .regexp {
+        color: #009926
+      }
+      pre .class {
+        color: #458;
+        font-weight: bold
+      }
+      pre .symbol,
+      pre .ruby .symbol .string,
+      pre .lisp .keyword,
+      pre .tex .special,
+      pre .prompt {
+        color: #990073
+      }
+      pre .built_in,
+      pre .lisp .title,
+      pre .clojure .built_in {
+        color: #0086b3
+      }
+      pre .preprocessor,
+      pre .pi,
+      pre .doctype,
+      pre .shebang,
+      pre .cdata {
+        color: #999;
+        font-weight: bold
+      }
+      pre .deletion {
+        background: #fdd
+      }
+      pre .addition {
+        background: #dfd
+      }
+      pre .diff .change {
+        background: #0086b3
+      }
+      pre .chunk {
+        color: #aaa
+      }
+
+      body {
+        padding-top: 50px;
+      }
+    </style>
+  </head>
+  <body>
+   <div class="navbar navbar-inverse navbar-fixed-top">
+      <div class="container">
+        <div class="navbar-header">
+          <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+          </button>
+          <a class="navbar-brand" href="/<%= tag %>/index.html">Atom Documentation</a>
+        </div>
+        <div class="collapse navbar-collapse">
+          <ul class="nav navbar-nav">
+            <li><a href="/docs/api/<%= tag %>/api/index.html">API</a></li>
+          </ul>
+        </div><!--/.nav-collapse -->
+      </div>
+    </div>
+
+    <div class="container">
+      <%= content %>
+    </div>
+  </body>
+</html>

docs/theme-variables.md

@@ -0,0 +1,116 @@
+# Style variables
+
+Atom's UI provides a set of variables you can use in your own themes and packages.
+
+## Use in Themes
+
+Each custom theme must specify a `ui-variables.less` file with all of the
+following variables defined. The top-most theme specified in the theme settings
+will be loaded and available for import.
+
+## Use in Packages
+
+In any of your package's `.less` files, you can access the theme variables
+by importing the `ui-variables` file from Atom.
+
+Your package should generally only specify structural styling, and these should
+come from [the style guide][styleguide]. Your package shouldn't specify colors,
+padding sizes, or anything in absolute pixels. You should instead use the theme
+variables. If you follow this guideline, your package will look good out of the
+box with any theme!
+
+Here's an example `.less` file that a package can define using theme variables:
+
+```css
+@import "ui-variables";
+
+.my-selector{
+  background-color: @base-background-color;
+  padding: @component-padding;
+}
+```
+
+## Variables
+
+### Text colors
+
+* `@text-color`
+* `@text-color-subtle`
+* `@text-color-highlight`
+* `@text-color-selected`
+* `@text-color-info` - A blue
+* `@text-color-success`- A green
+* `@text-color-warning`- An orange or yellow
+* `@text-color-error` - A red
+
+### Background colors
+
+* `@background-color-info` - A blue
+* `@background-color-success` - A green
+* `@background-color-warning` - An orange or yellow
+* `@background-color-error` - A red
+* `@background-color-highlight`
+* `@background-color-selected`
+* `@app-background-color` - The app's background under all the editor components
+
+### Component colors
+
+* `@base-background-color` -
+* `@base-border-color` -
+
+* `@pane-item-background-color` -
+* `@pane-item-border-color` -
+
+* `@input-background-color` -
+* `@input-border-color` -
+
+* `@tool-panel-background-color` -
+* `@tool-panel-border-color` -
+
+* `@inset-panel-background-color` -
+* `@inset-panel-border-color` -
+
+* `@panel-heading-background-color` -
+* `@panel-heading-border-color` -
+
+* `@overlay-background-color` -
+* `@overlay-border-color` -
+
+* `@button-background-color` -
+* `@button-background-color-hover` -
+* `@button-background-color-selected` -
+* `@button-border-color` -
+
+* `@tab-bar-background-color` -
+* `@tab-bar-border-color` -
+* `@tab-background-color` -
+* `@tab-background-color-active` -
+* `@tab-border-color` -
+
+* `@tree-view-background-color` -
+* `@tree-view-border-color` -
+
+* `@ui-site-color-1` -
+* `@ui-site-color-2` -
+* `@ui-site-color-3` -
+* `@ui-site-color-4` -
+* `@ui-site-color-5` -
+
+### Component sizes
+
+* `@disclosure-arrow-size` -
+
+* `@component-padding` -
+* `@component-icon-padding` -
+* `@component-icon-size` -
+* `@component-line-height` -
+* `@component-border-radius` -
+
+* `@tab-height` -
+
+### Fonts
+
+* `@font-size` -
+* `@font-family` -
+
+[styleguide]: https://github.com/atom/styleguide

docs/your-first-package.md

@@ -0,0 +1,334 @@
+# Creating Your First Package
+
+Let's take a look at creating your first package.
+
+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-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!
+
+In order to demonstrate the capabilities of Atom and its API, our Changer plugin
+is going to do two things:
+
+1. It'll show only modified files in the file tree
+2. It'll append a new pane to the editor with some information about the modified
+files
+
+Let's get started!
+
+## Changing Keybindings and Commands
+
+Since Changer is primarily concerned with the file tree, let's write a
+key binding that works only when the tree is focused. Instead of using the
+default `toggle`, our keybinding executes a new command called `magic`.
+
+_keymaps/changer.cson_ should change to look like this:
+
+```coffeescript
+'.tree-view':
+  'ctrl-V': 'changer:magic'
+```
+
+Notice that the keybinding is called `ctrl-V` — that's actually `ctrl-shift-v`.
+You can use capital letters to denote using `shift` for your binding.
+
+`.tree-view` represents the parent container for the tree view.
+Keybindings only work within the context of where they're entered. In this case,
+hitting `ctrl-V` anywhere other than tree won't do anything. Obviously, you can
+bind to any part of the editor using element, id, or class names. For example,
+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 `atom.workspaceView.command` method. This method takes a command
+name and executes a callback function. Open up _lib/changer-view.coffee_, and
+change `atom.workspaceView.command "changer:toggle"` to look like this:
+
+```coffeescript
+atom.workspaceView.command "changer:magic", => @magic()
+```
+
+It's common practice to namespace your commands with your package name, separated
+with a colon (`:`). Make sure to rename your `toggle` method to `magic` as well.
+
+Every time you reload the Atom editor, changes to your package code will be reevaluated,
+just as if you were writing a script for the browser. Reload the editor, click on
+the tree, hit your keybinding, and...nothing happens! What the heck?!
+
+Open up the _package.json_ file, and find the property called `activationEvents`.
+Basically, this key tells Atom to not load a package until it hears a certain event.
+Change the event to `changer:magic` and reload the editor:
+
+```json
+"activationEvents": ["changer:magic"]
+```
+
+Hitting the key binding on the tree now works!
+
+## Working with Styles
+
+The next step is to hide elements in the tree that aren't modified. To do that,
+we'll first try and get a list of files that have not changed.
+
+All packages are able to use jQuery in their code. In fact, there's [a list of
+the bundled libraries Atom provides by default][bundled-libs].
+
+We bring in jQuery by requiring the `atom` package and binding it to the `$` variable:
+
+```coffeescript
+{$, View} = require 'atom'
+```
+
+Now, we can define the `magic` method to query the tree to get us a list of every
+file that _wasn't_ modified:
+
+```coffeescript
+magic: ->
+  $('ol.entries li').each (i, el) ->
+    if !$(el).hasClass("status-modified")
+      console.log el
+```
+
+You can access the dev console by hitting `alt-cmd-i`. Here, you'll see all the
+statements from `console` calls. When we execute the `changer:magic` command, the
+browser console lists items that are not being modified (_i.e._, those without the
+`status-modified` class). Let's add a class to each of these elements called `hide-me`:
+
+```coffeescript
+magic: ->
+  $('ol.entries li').each (i, el) ->
+    if !$(el).hasClass("status-modified")
+      $(el).addClass("hide-me")
+```
+
+With our newly added class, we can manipulate the visibility of the elements
+with a simple stylesheet. Open up _changer.css_ in the _stylesheets_ directory,
+and add a single entry:
+
+```css
+ol.entries .hide-me {
+  display: none;
+}
+```
+
+Refresh Atom, and run the `changer` command. You'll see all the non-changed
+files disappear from the tree. Success!
+
+![Changer_File_View]
+
+There are a number of ways you can get the list back; let's just naively iterate
+over the same elements and remove the class:
+
+```coffeescript
+magic: ->
+  $('ol.entries li').each (i, el) ->
+    if !$(el).hasClass("status-modified")
+      if !$(el).hasClass("hide-me")
+        $(el).addClass("hide-me")
+      else
+        $(el).removeClass("hide-me")
+```
+
+## Creating a New Panel
+
+The next goal of this package is to append a panel to the Atom editor that lists
+some information about the modified files.
+
+To do that, we're going to first open up [the style guide][styleguide]. The Style
+Guide lists every type of UI element that can be created by an Atom package. Aside
+from helping you avoid writing fresh code from scratch, it ensures that packages
+have the same look and feel no matter how they're built.
+
+Every package that extends from the `View` class can provide an optional class
+method called `content`. The `content` method constructs the DOM that your
+package uses as its UI. The principals of `content` are built entirely on
+[SpacePen][space-pen], which we'll touch upon only briefly here.
+
+Our display will simply be an unordered list of the file names, and their
+modified times. We'll append this list to a panel on the bottom of the editor. A
+basic `panel` element inside a `tool-panel` will work well for us. Let's start by carving out a
+`div` to hold the filenames:
+
+```coffeescript
+@content: ->
+  @div class: "changer tool-panel panel-bottom", =>
+    @div class: "panel", =>
+      @div class: "panel-heading", "Modified Files"
+      @div class: "panel-body padded", outlet: 'modifiedFilesContainer', =>
+        @ul class: 'modified-files-list', outlet: 'modifiedFilesList', =>
+          @li 'Modified File Test'
+          @li 'Modified File Test'
+```
+
+You can add any HTML attribute you like. `outlet` names the variable your
+package can use to manipulate the element directly. The fat arrow (`=>`)
+indicates that the next DOM set are nested children.
+
+Once again, you can style `li` elements using your stylesheets. Let's test that
+out by adding these lines to the _changer.css_ file:
+
+```css
+ul.modified-files-list {
+  color: white;
+}
+```
+
+We'll add one more line to the end of the `magic` method to make this pane appear:
+
+```coffeescript
+atom.workspaceView.vertical.append(this)
+```
+
+If you refresh Atom and hit the key command, you'll see a box appear right underneath
+the editor:
+
+![Changer_Panel_Append]
+
+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 `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 `atom.workspaceView.vertical.append`
+call with this code:
+
+```coffeescript
+# toggles the pane
+if @hasParent()
+  atom.workspaceView.vertical.children().last().remove()
+else
+  atom.workspaceView.vertical.append(this)
+```
+
+There are about a hundred different ways to toggle a pane on and off, and this
+might not be the most efficient one. If you know your package needs to be
+toggled on and off more freely, it might be better to draw the interface during the
+initialization, then immediately call `hide()` on the element to remove it from
+the view. You can then swap between `show()` and `hide()`, and instead of
+forcing Atom to add and remove the element as we're doing here, it'll just set a
+CSS property to control your package's visibility.
+
+Refresh Atom, hit the key combo, and watch your test list appear and disappear.
+
+## Calling Node.js Code
+
+Since Atom is built on top of [Node.js][node], you can call any of its libraries,
+including other modules that your package requires.
+
+We'll iterate through our resulting tree, and construct the path to our modified
+file based on its depth in the tree. We'll use Node to handle path joining for
+directories.
+
+Add the following Node module to the top of your file:
+
+```coffeescript
+path = require 'path'
+```
+
+Then, add these lines to your `magic` method, _before_ your pane drawing code:
+
+```coffeescript
+modifiedFiles = []
+# for each single entry...
+$('ol.entries li.file.status-modified span.name').each (i, el) ->
+  filePath = []
+  # ...grab its name...
+  filePath.unshift($(el).text())
+
+  # ... then find its parent directories, and grab their names
+  parents = $(el).parents('.directory.status-modified')
+  parents.each (i, el) ->
+    filePath.unshift($(el).find('div.header span.name').eq(0).text())
+
+  modifiedFilePath = path.join(atom.project.rootDirectory.path, filePath.join(path.sep))
+  modifiedFiles.push modifiedFilePath
+```
+
+`modifiedFiles` is an array containing a list of our modified files. We're also
+using the node.js [`path` library][path] to get the proper directory separator
+for our system.
+
+Remove the two `@li` elements we added in `@content`, so that we can
+populate our `modifiedFilesList` with real information. We'll do that by
+iterating over `modifiedFiles`, accessing a file's last modified time, and
+appending it to `modifiedFilesList`:
+
+```coffeescript
+# toggles the pane
+if @hasParent()
+  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}")
+  atom.workspaceView.vertical.append(this)
+```
+
+When you toggle the modified files list, your pane is now populated with the
+filenames and modified times of files in your project:
+
+![Changer_Panel_Timestamps]
+
+You might notice that subsequent calls to this command reduplicate information.
+We could provide an elegant way of rechecking files already in the list, but for
+this demonstration, we'll just clear the `modifiedFilesList` each time it's closed:
+
+```coffeescript
+# toggles the pane
+if @hasParent()
+  @modifiedFilesList.empty() # added this to clear the list on close
+  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}")
+  atom.workspaceView.vertical.append(this)
+```
+
+## Coloring UI Elements
+
+For packages that create new UI elements, adhering to the style guide is just one
+part to keeping visual consistency. Packages dealing with color, fonts, padding,
+margins, and other visual cues should rely on [Theme Variables][theme-vars], instead
+of developing individual styles. Theme variables are variables defined by Atom
+for use in packages and themes. They're only available in [`LESS`](http://lesscss.org/)
+stylesheets.
+
+For our package, let's remove the style defined by `ul.modified-files-list` in
+_changer.css_. Create a new file under the _stylesheets_ directory called _text-colors.less_.
+Here, we'll import the _ui-variables.less_ file, and define some Atom-specific
+styles:
+
+```less
+@import "ui-variables";
+
+ul.modified-files-list {
+  color: @text-color;
+  background-color: @background-color-info;
+}
+```
+
+Using theme variables ensures that packages look great alongside any theme.
+
+## Further reading
+
+For more information on the mechanics of packages, check out
+[Creating a Package][creating-a-package].
+
+[bundled-libs]: creating-a-package.html#included-libraries
+[styleguide]: https://github.com/atom/styleguide
+[space-pen]: https://github.com/atom/space-pen
+[node]: http://nodejs.org/
+[path]: http://nodejs.org/docs/latest/api/path.html
+[changer_file_view]: https://f.cloud.github.com/assets/69169/1441187/d7a7cb46-41a7-11e3-8128-d93f70a5d5c1.png
+[changer_panel_append]: https://f.cloud.github.com/assets/69169/1441189/db0c74da-41a7-11e3-8286-b82dd9190c34.png
+[changer_panel_timestamps]: https://f.cloud.github.com/assets/69169/1441190/dcc8eeb6-41a7-11e3-830f-1f1b33072fcd.png
+[theme-vars]: theme-variables.html
+[creating-a-package]: creating-a-package.html

exports/atom.coffee

@@ -1,18 +1,16 @@
-{Document, Point, Range, Site} = require 'telepath'
-_ = require 'underscore-plus'
+{Document, Point, Range} = require 'telepath'
 
 module.exports =
-  _: _
+  _: require 'underscore-plus'
   BufferedNodeProcess: require '../src/buffered-node-process'
   BufferedProcess: require '../src/buffered-process'
   Directory: require '../src/directory'
   Document: Document
   File: require '../src/file'
-  fs: require '../src/fs-utils'
+  fs: require 'fs-plus'
   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
@@ -22,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/apple.cson

@@ -1,29 +0,0 @@
-'body':
-  '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'
-
-'.editor':
-  '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-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'
-
-  'alt-backspace': 'editor:backspace-to-beginning-of-word'
-  'meta-backspace': 'editor:backspace-to-beginning-of-line'
-
-  'alt-delete': 'editor:delete-to-end-of-word'
-  'ctrl-t': 'editor:transpose'
-  'ctrl-A': 'editor:select-to-first-character-of-line'
-  'ctrl-E': 'editor:select-to-end-of-line'

keymaps/atom.cson

@@ -1,97 +0,0 @@
-'body':
-  'meta-q': 'application:quit'
-  'meta-h': 'application:hide'
-  'meta-H': 'application:hide-other-applications'
-  'meta-n': 'application:new-file'
-  'meta-N': 'application:new-window'
-  'meta-o': 'application:open'
-  'meta-O': 'application:open-dev'
-  'meta-m': 'application:minimize'
-  'meta-,': 'application:show-settings'
-  'alt-meta-ctrl-m': 'application:zoom'
-  'meta-alt-ctrl-s': 'application:run-all-specs'
-
-  'meta-s': 'core:save'
-  'meta-S': 'core:save-as'
-  'enter': 'core:confirm'
-  'escape': 'core:cancel'
-  'meta-w': 'core:close'
-  'up': 'core:move-up'
-  'down': 'core:move-down'
-  'left': 'core:move-left'
-  'right': 'core:move-right'
-  'shift-up': 'core:select-up'
-  'shift-down': 'core:select-down'
-  'shift-left': 'core:select-left'
-  'shift-right': 'core:select-right'
-  'meta-a': 'core:select-all'
-  'backspace': 'core:backspace'
-  'shift-backspace': 'core:backspace'
-  'delete': 'core:delete'
-  'meta-z': 'core:undo'
-  'meta-Z': 'core:redo'
-  'meta-y': 'core:redo'
-  'meta-x': 'core:cut'
-  'meta-c': 'core:copy'
-  'meta-v': 'core:paste'
-  'pageup': 'core:page-up'
-  'pagedown': 'core:page-down'
-
-  'meta-alt-s': 'window:save-all'
-  'meta-W': 'window:close'
-  'meta-+': 'window:increase-font-size'
-  'meta--': 'window:decrease-font-size'
-  'ctrl-w w': 'window:focus-next-pane'
-  'ctrl-tab': 'window:focus-next-pane'
-  'ctrl-meta-f': 'window:toggle-full-screen'
-  'ctrl-alt-meta-r': 'window:reload'
-  'alt-meta-i': 'window:toggle-dev-tools'
-  'meta-alt-ctrl-p': 'window:run-package-specs'
-
-  'ctrl-|': 'pane:split-right'
-  'ctrl-w v': 'pane:split-right'
-  'ctrl--': 'pane:split-down'
-  'ctrl-w s': 'pane:split-down'
-
-  'meta-{': 'pane:show-previous-item'
-  'meta-}': 'pane:show-next-item'
-  'alt-meta-left': 'pane:show-previous-item'
-  'alt-meta-right': 'pane:show-next-item'
-  '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'
-  'meta-T': 'pane:reopen-closed-item'
-  'alt-meta-w': 'pane:close-other-items'
-  'meta-P': 'pane:close'
-
-'.tool-panel':
-  'meta-escape': 'tool-panel:unfocus'
-  'escape': 'core:close'
-  'meta-w': 'noop'
-
-# allow standard input fields to work correctly
-'input:not(.hidden-input)':
-  '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!'
-
-'button':
-  'tab': 'core:focus-next'
-  'shift-tab': 'core:focus-previous'

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/editor.cson

@@ -1,50 +0,0 @@
-'.editor':
-  'ctrl-K': 'editor:delete-line'
-  'ctrl-W': 'editor:select-word'
-  'meta-alt-p': 'editor:log-cursor-scope'
-  'meta-u': 'editor:upper-case'
-  'meta-U': 'editor:lower-case'
-
-'.editor:not(.mini)':
-  'enter': 'editor:newline'
-  'meta-enter': 'editor:newline-below'
-  'meta-shift-enter': 'editor:newline-above'
-  'tab': 'editor:indent'
-  'meta-=': 'editor:auto-indent'
-
-  'ctrl-[': 'editor:fold-current-row'
-  'ctrl-]': 'editor:unfold-current-row'
-  'ctrl-{': 'editor:fold-all'
-  'ctrl-}': 'editor:unfold-all'
-  'ctrl-meta-1': 'editor:fold-at-indent-level-1'
-  'ctrl-meta-2': 'editor:fold-at-indent-level-2'
-  'ctrl-meta-3': 'editor:fold-at-indent-level-3'
-  'ctrl-meta-4': 'editor:fold-at-indent-level-4'
-  'ctrl-meta-5': 'editor:fold-at-indent-level-5'
-  'ctrl-meta-6': 'editor:fold-at-indent-level-6'
-  'ctrl-meta-7': 'editor:fold-at-indent-level-7'
-  'ctrl-meta-8': 'editor:fold-at-indent-level-8'
-  'ctrl-meta-9': 'editor:fold-at-indent-level-9'
-
-  'alt-shift-down': 'editor:add-selection-below'
-  'alt-shift-up': 'editor:add-selection-above'
-  'alt-meta-ctrl-f': 'editor:fold-selection'
-  'shift-tab': 'editor:outdent-selected-rows'
-  'meta-[': 'editor:outdent-selected-rows'
-  'meta-]': 'editor:indent-selected-rows'
-
-  'meta-/': 'editor:toggle-line-comments'
-  'ctrl-C': 'editor:copy-path'
-  'ctrl-meta-up': 'editor:move-line-up'
-  'ctrl-meta-down': 'editor:move-line-down'
-  'meta-D': 'editor:duplicate-line'
-  'meta-j': 'editor:join-line'
-  'meta-<': 'editor:scroll-to-cursor'
-
-'.editor.mini':
-  'enter': 'core:confirm',
-  'escape': 'core:cancel'
-  'meta-w': 'core:cancel'
-
-'.editor !important, .editor.mini !important':
-  'escape': 'editor:consolidate-selections'

keymaps/emacs.cson

@@ -1,33 +1,7 @@
-'body':
-  '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'
-  'alt-ctrl-n': 'editor:add-selection-below'
-  'alt-ctrl-p': 'editor:add-selection-above'
-  'ctrl-h': 'core:backspace'
-  'ctrl-d': 'core:delete'
-
 '.editor':
   'alt-f': 'editor:move-to-end-of-word'
   'alt-F': 'editor:select-to-end-of-word'
   'alt-b': 'editor:move-to-beginning-of-word'
   'alt-B': 'editor:select-to-beginning-of-word'
-  'ctrl-a': 'editor:move-to-first-character-of-line'
-  'ctrl-e': 'editor:move-to-end-of-line'
   'alt-h': 'editor:backspace-to-beginning-of-word'
   'alt-d': 'editor:delete-to-end-of-word'
-  'ctrl-k': 'editor:cut-to-end-of-line'
-
-# allow standard input fields to work correctly
-'input:not(.hidden-input)':
-  'ctrl-b': 'native!'
-  'ctrl-f': 'native!'
-  'ctrl-F': 'native!'
-  'ctrl-B': 'native!'
-  'ctrl-h': 'native!'
-  'ctrl-d': 'native!'

keymaps/git.cson

@@ -1,2 +0,0 @@
-'.editor':
-  'alt-meta-z': 'editor:checkout-head-revision'

keymaps/select-list.cson

@@ -1,4 +0,0 @@
-'.select-list .mini.editor':
-  'enter': 'core:confirm'
-  'escape': 'core:cancel'
-  'meta-w': 'core:cancel'

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/darwin.cson

@@ -154,11 +154,6 @@
     ]
   }
 
-  {
-    label: 'Collaboration'
-    submenu: []
-  }
-
   {
     label: 'Packages'
     submenu: []

menus/win32.cson

@@ -0,0 +1,171 @@
+'menu': [
+  {
+    label: '&File'
+    submenu: [
+      { label: 'New &Window', command: 'application:new-window' }
+      { label: '&New File', command: 'application:new-file' }
+      { label: '&Open...', command: 'application:open' }
+      { label: 'Reopen Last &Item', command: 'pane:reopen-closed-item' }
+      { type: 'separator' }
+      { label: '&Preferences...', command: 'application:show-settings' }
+      { type: 'separator' }
+      { label: '&Save', command: 'core:save' }
+      { label: 'Save &As...', command: 'core:save-as' }
+      { label: 'Save A&ll', command: 'window:save-all' }
+      { type: 'separator' }
+      { label: '&Close Buffer', command: 'core:close' }
+      { label: 'Close All &Buffers', command: 'pane:close' }
+      { label: 'Clos&e Window', command: 'window:close' }
+      { type: 'separator' }
+      { label: 'E&xit', command: 'application:quit' }
+    ]
+  }
+
+  {
+    label: '&Edit'
+    submenu: [
+      { label: '&Undo', command: 'core:undo' }
+      { label: '&Redo', command: 'core:redo' }
+      { type: 'separator' }
+      { label: '&Cut', command: 'core:cut' }
+      { label: 'C&opy', command: 'core:copy' }
+      { label: 'Copy Pat&h', command: 'editor:copy-path' }
+      { label: '&Paste', command: 'core:paste' }
+      { label: 'Select &All', command: 'core:select-all' }
+      { type: 'separator' }
+      { label: '&Toggle Comments', command: 'editor:toggle-line-comments' }
+      {
+        label: 'Lines',
+        submenu: [
+          { label: '&Indent', command: 'editor:indent-selected-rows' }
+          { label: '&Outdent', command: 'editor:outdent-selected-rows' }
+          { label: '&Auto Indent', command: 'editor:auto-indent' }
+          { type: 'separator' }
+          { label: 'Move Line &Up', command: 'editor:move-line-up' }
+          { label: 'Move Line &Down', command: 'editor:move-line-down' }
+          { label: 'Du&plicate Line', command: 'editor:duplicate-line' }
+          { label: 'D&elete Line', command: 'editor:delete-line' }
+          { label: '&Join Lines', command: 'editor:join-line' }
+        ]
+      }
+      {
+        label: 'Text',
+        submenu: [
+          { label: '&Upper Case', command: 'editor:upper-case' }
+          { label: '&Lower Case', command: 'editor:lower-case' }
+          { type: 'separator' }
+          { label: 'Delete to End of &Word', command: 'editor:delete-to-end-of-word' }
+          { label: '&Delete Line', command: 'editor:delete-line' }
+          { type: 'separator' }
+          { label: '&Transpose', command: 'editor:transpose' }
+        ]
+      }
+      {
+        label: 'Folding',
+        submenu: [
+          { label: '&Fold', command: 'editor:fold-current-row' }
+          { label: '&Unfold', command: 'editor:unfold-current-row' }
+          { label: 'Unfold &All', command: 'editor:unfold-all' }
+          { type: 'separator' }
+          { label: 'Fol&d All', command: 'editor:fold-all' }
+          { label: 'Fold Level 1', command: 'editor:fold-at-indent-level-1' }
+          { label: 'Fold Level 2', command: 'editor:fold-at-indent-level-2' }
+          { label: 'Fold Level 3', command: 'editor:fold-at-indent-level-3' }
+          { label: 'Fold Level 4', command: 'editor:fold-at-indent-level-4' }
+          { label: 'Fold Level 5', command: 'editor:fold-at-indent-level-5' }
+          { label: 'Fold Level 6', command: 'editor:fold-at-indent-level-6' }
+          { label: 'Fold Level 7', command: 'editor:fold-at-indent-level-7' }
+          { label: 'Fold Level 8', command: 'editor:fold-at-indent-level-8' }
+          { label: 'Fold Level 9', command: 'editor:fold-at-indent-level-9' }
+        ]
+      }
+    ]
+  }
+
+  {
+    label: '&View'
+    submenu: [
+      { label: '&Reload', command: 'window:reload' }
+      { label: 'Toggle &Full Screen', command: 'window:toggle-full-screen' }
+      {
+        label: 'Developer'
+        submenu: [
+          { label: 'Open In &Dev Mode...', command: 'application:open-dev' }
+          { label: 'Run &Atom Specs', command: 'application:run-all-specs' }
+          { label: 'Run Package &Specs', command: 'window:run-package-specs' }
+          { label: 'Toggle Developer &Tools', command: 'window:toggle-dev-tools' }
+        ]
+      }
+      { type: 'separator' }
+      { label: 'Toggle Soft &Wrap', command: 'editor:toggle-soft-wrap' }
+    ]
+  }
+
+  {
+    label: '&Selection'
+    submenu: [
+      { label: 'Add Selection &Above', command: 'editor:add-selection-above' }
+      { label: 'Add Selection &Below', command: 'editor:add-selection-below' }
+      { type: 'separator' }
+      { label: 'Select to &Top', command: 'core:select-to-top' }
+      { label: 'Select to Botto&m', command: 'core:select-to-bottom' }
+      { type: 'separator' }
+      { label: 'Select &Line', command: 'editor:select-line' }
+      { label: 'Select &Word', command: 'editor:select-word' }
+      { label: 'Select to Beginning of W&ord', command: 'editor:select-to-beginning-of-word' }
+      { label: 'Select to Beginning of L&ine', command: 'editor:select-to-beginning-of-line' }
+      { label: 'Select to First &Character of Line', command: 'editor:select-to-first-character-of-line' }
+      { label: 'Select to End of Wor&d', command: 'editor:select-to-end-of-word' }
+      { label: 'Select to End of Lin&e', command: 'editor:select-to-end-of-line' }
+    ]
+  }
+
+  {
+    label: '&Movement'
+    submenu: [
+      { label: 'Move to &Top', command: 'core:move-to-top' }
+      { label: 'Move to &Bottom', command: 'core:move-to-bottom' }
+      { type: 'separator' }
+      { label: 'Move to Beginning of &Line', command: 'editor:move-to-beginning-of-line' }
+      { label: 'Move to &First Character of Line', command: 'editor:move-to-first-character-of-line' }
+      { label: 'Move to &End of Line', command: 'editor:move-to-end-of-line' }
+      { type: 'separator' }
+      { label: 'Move to Beginning of &Word', command: 'editor:move-to-beginning-of-word' }
+      { label: 'Move to End of Wor&d', command: 'editor:move-to-end-of-word' }
+      { label: 'Move to &Next Word', command: 'editor:move-to-next-word-boundary' }
+      { label: 'Move to &Previous Word', command: 'editor:move-to-previous-word-boundary' }
+    ]
+  }
+
+  {
+    label: 'F&ind'
+    submenu: []
+  }
+
+  {
+    label: '&Packages'
+    submenu: []
+  }
+
+  {
+    label: '&Window'
+    submenu: [
+      { label: 'Mi&nimize', command: 'application:minimize' }
+      { label: 'Ma&ximize', command: 'application:zoom' }
+      { type: 'separator' }
+      { label: 'Bring &All to Front', command: 'application:bring-all-windows-to-front' }
+    ]
+  }
+
+  {
+    label: '&Help'
+    submenu: [
+      { label: '&About Atom...', command: 'application:about' }
+      { label: "VERSION", enabled: false }
+      { label: "Install &update", command: 'application:install-update', visible: false }
+      { type: 'separator' }
+      { label: '&Documentation', command: 'application:open-documentation' }
+      { type: 'separator' }
+    ]
+  }
+]

package.json

@@ -1,6 +1,7 @@
 {
   "name": "atom",
-  "version": "33.0.0",
+  "productName": "Atom",
+  "version": "0.43.0",
   "main": "./src/browser/main.js",
   "repository": {
     "type": "git",
@@ -9,36 +10,42 @@
   "bugs": {
     "url": "https://github.com/atom/atom/issues"
   },
-  "atomShellVersion": "0.6.6",
+  "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",
-    "clear-cut": "0.1.0",
+    "bootstrap": "git://github.com/benogle/bootstrap.git",
+    "clear-cut": "0.2.0",
     "coffee-script": "1.6.3",
     "coffeestack": "0.6.0",
-    "emissary": "0.9.0",
+    "emissary": "0.19.0",
     "first-mate": "0.5.0",
+    "fs-plus": "0.10.0",
     "fuzzaldrin": "0.1.0",
-    "git-utils": "0.28.0",
+    "git-utils": "0.29.0",
     "guid": "0.0.10",
     "jasmine-focused": "~0.15.0",
     "mkdirp": "0.3.5",
-    "less-cache": "0.9.0",
+    "keytar": "0.13.0",
+    "less-cache": "0.10.0",
     "nslog": "0.1.0",
-    "oniguruma": "0.22.0",
+    "oniguruma": "0.24.0",
     "optimist": "0.4.0",
-    "pathwatcher": "0.8.0",
+    "pathwatcher": "0.10.0",
     "pegjs": "0.7.0",
-    "plist": "git://github.com/nathansobo/node-plist.git",
     "q": "0.9.7",
-    "rimraf": "2.1.4",
-    "scandal": "0.6.0",
+    "scandal": "0.8.0",
     "season": "0.14.0",
     "semver": "1.1.4",
-    "space-pen": "2.0.0",
-    "telepath": "0.8.1",
+    "space-pen": "2.0.1",
+    "telepath": "0.61.0",
     "temp": "0.5.0",
-    "underscore-plus": "0.2.0"
+    "underscore-plus": "0.3.0"
   },
   "devDependencies": {
     "biscotto": "0.0.17",
@@ -46,76 +53,78 @@
     "fstream": "0.1.24",
     "grunt": "~0.4.1",
     "grunt-cli": "~0.1.9",
-    "grunt-coffeelint": "0.0.6",
+    "grunt-coffeelint": "git://github.com/atom/grunt-coffeelint.git",
     "grunt-lesslint": "0.13.0",
     "grunt-cson": "0.5.0",
     "grunt-contrib-csslint": "~0.1.2",
     "grunt-contrib-coffee": "~0.7.0",
     "grunt-contrib-less": "~0.8.0",
     "walkdir": "0.0.7",
-    "ws": "0.4.27",
     "js-yaml": "~2.1.0",
     "grunt-markdown": "~0.4.0",
     "json-front-matter": "~0.1.3",
     "grunt-shell": "~0.3.1",
     "jasmine-node": "git://github.com/kevinsawicki/jasmine-node.git#short-stacks",
-    "request": "~2.27.0"
+    "jasmine-tagged": "0.2.0",
+    "request": "~2.27.0",
+    "unzip": "~0.1.9",
+    "rcedit": "~0.1.2",
+    "rimraf": "~2.2.2"
   },
-  "packageDependencies" : {
-    "atom-light-ui": "0.5.0",
-    "atom-light-syntax": "0.5.0",
-    "atom-dark-ui": "0.5.0",
-    "atom-dark-syntax": "0.5.0",
-    "base16-tomorrow-dark-theme": "0.2.0",
-    "solarized-dark-syntax": "0.3.0",
-
-    "archive-view": "0.11.0",
-    "autocomplete": "0.11.0",
-    "autoflow": "0.5.0",
-    "autosave": "0.3.0",
-    "bookmarks": "0.8.0",
-    "bracket-matcher": "0.7.0",
-    "collaboration": "0.34.0",
-    "command-logger": "0.6.0",
-    "command-palette": "0.6.0",
-    "dev-live-reload": "0.12.0",
-    "editor-stats": "0.5.0",
-    "exception-reporting": "0.5.0",
-    "find-and-replace": "0.32.0",
-    "fuzzy-finder": "0.15.0",
-    "gfm": "0.5.0",
-    "gists": "0.6.0",
-    "git-diff": "0.12.0",
-    "github-sign-in": "0.9.0",
-    "go-to-line": "0.8.0",
-    "grammar-selector": "0.8.0",
-    "image-view": "0.7.0",
-    "link": "0.7.0",
-    "markdown-preview": "0.12.0",
-    "metrics": "0.8.0",
-    "package-generator": "0.14.0",
-    "release-notes": "0.11.0",
-    "settings-view": "0.34.0",
-    "snippets": "0.11.0",
-    "spell-check": "0.9.0",
-    "status-bar": "0.15.0",
-    "styleguide": "0.9.0",
-    "symbols-view": "0.15.0",
-    "tabs": "0.7.0",
-    "terminal": "0.14.0",
-    "timecop": "0.9.0",
-    "to-the-hubs": "0.8.0",
-    "toml": "0.3.0",
-    "tree-view": "0.22.0",
-    "visual-bell": "0.3.0",
-    "whitespace": "0.7.0",
-    "wrap-guide": "0.4.0",
-
+  "packageDependencies": {
+    "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.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.1.0",
+    "language-coffee-script": "0.3.0",
     "language-css": "0.2.0",
-    "language-git": "0.2.0",
+    "language-gfm": "0.9.0",
+    "language-git": "0.3.0",
     "language-go": "0.2.0",
     "language-html": "0.2.0",
     "language-hyperlink": "0.3.0",
@@ -132,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",
@@ -140,8 +149,10 @@
     "language-sql": "0.2.0",
     "language-text": "0.2.0",
     "language-todo": "0.2.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,12 +2,23 @@
 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);
-  if (index < commands.length)
-    safeExec(commands[index], executeCommands.bind(this, commands, done, index + 1));
-  else
+  if (index < commands.length) {
+    var command = commands[index];
+    var options = null;
+    if (typeof command !== 'string') {
+      options = command.options;
+      command = command.command;
+    }
+    safeExec(command, options, executeCommands.bind(this, commands, done, index + 1));
+  } else
     done(null);
 }
 
@@ -21,10 +32,11 @@ var echoNewLine = process.platform == 'win32' ? 'echo.' : 'echo';
 var commands = [
   'git submodule --quiet sync',
   'git submodule --quiet update --recursive --init',
-  joinCommands('cd vendor/apm', 'npm install --silent .'),
-  'npm install --silent vendor/apm',
+  {command: joinCommands('cd vendor/apm', 'npm install --silent .'), options: {ignoreStdout: true}},
+  {command: 'npm install --silent vendor/apm', options: {ignoreStdout: true}},
   echoNewLine,
-  'node node_modules/.bin/apm install --silent'
+  'node node_modules/atom-package-manager/bin/apm clean',
+  'node node_modules/atom-package-manager/bin/apm install --silent',
 ];
 
 process.chdir(path.dirname(__dirname));

script/build

@@ -5,8 +5,8 @@ var path = require('path');
 process.chdir(path.dirname(__dirname));
 
 cp.safeExec('node script/bootstrap', function() {
-  // ./node_modules/.bin/grunt "$@"
-  var gruntPath = path.join('node_modules', '.bin', 'grunt');
+  // node node_modules/grunt-cli/bin/grunt "$@"
+  var gruntPath = path.join('node_modules', 'grunt-cli', 'bin', 'grunt');
   var args = [gruntPath].concat(process.argv.slice(2));
   cp.safeSpawn(process.execPath, args, process.exit);
 });

script/build.cmd

@@ -0,0 +1,5 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\build" %*
+) ELSE (
+  node  "%~dp0\build" %*
+)

script/cibuild

@@ -32,8 +32,7 @@ cp.safeExec.bind(global, 'node script/bootstrap', function(error) {
   async.series([
     require('rimraf').bind(global, path.join(homeDir, '.atom')),
     cp.safeExec.bind(global, 'git clean -dff'),
-    cp.safeExec.bind(global, 'node node_modules/.bin/apm clean'),
-    cp.safeExec.bind(global, 'node node_modules/.bin/grunt ci --stack --no-color'),
+    cp.safeExec.bind(global, 'node node_modules/grunt-cli/bin/grunt ci --stack --no-color'),
   ], function(error) {
     process.exit(error ? 1 : 0);
   });

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"

script/test

@@ -5,5 +5,5 @@ var path = require('path');
 process.chdir(path.dirname(__dirname));
 
 safeExec('node script/bootstrap', function() {
-  safeExec('node node_modules/.bin/grunt ci --stack --no-color', process.exit);
+  safeExec('node node_modules/grunt-cli/bin/grunt ci --stack --no-color', process.exit);
 });

script/utils/child-process-wrapper.js

@@ -7,14 +7,22 @@ exports.safeExec = function(command, options, callback) {
     callback = options;
     options = {};
   }
+  if (!options)
+    options = {};
+
+  // This needed to be increased for `apm test` runs that generate many failures
+  // The default is 200KB.
+  options.maxBuffer = 1024 * 1024;
+
   var child = childProcess.exec(command, options, function(error, stdout, stderr) {
     if (error)
-      process.exit(error.code);
+      process.exit(error.code || 1);
     else
       callback(null);
   });
   child.stderr.pipe(process.stderr);
-  child.stdout.pipe(process.stdout);
+  if (!options.ignoreStdout)
+    child.stdout.pipe(process.stdout);
 }
 
 // Same with safeExec but call child_process.spawn instead.

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
@@ -22,35 +22,35 @@ describe "the `atom` global", ->
 
         it "continues if the package has an invalid package.json", ->
           spyOn(console, 'warn')
-          config.set("core.disabledPackages", [])
-          expect(-> atom.loadPackage("package-with-broken-package-json")).not.toThrow()
+          atom.config.set("core.disabledPackages", [])
+          expect(-> atom.packages.loadPackage("package-with-broken-package-json")).not.toThrow()
 
         it "continues if the package has an invalid keymap", ->
-          config.set("core.disabledPackages", [])
-          expect(-> atom.loadPackage("package-with-broken-keymap")).not.toThrow()
+          atom.config.set("core.disabledPackages", [])
+          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,15 +67,15 @@ 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(config.get('package-with-config-defaults.numbers.one')).toBeUndefined()
-            atom.activatePackage('package-with-config-defaults')
-            expect(config.get('package-with-config-defaults.numbers.one')).toBe 1
-            expect(config.get('package-with-config-defaults.numbers.two')).toBe 2
+            expect(atom.config.get('package-with-config-defaults.numbers.one')).toBeUndefined()
+            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
 
           describe "when the package metadata includes activation events", ->
             [mainModule, pack] = []
@@ -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", ->
-          config.set("core.disabledPackages", [])
+          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", ->
@@ -137,28 +137,28 @@ describe "the `atom` global", ->
               element2 = $$ -> @div class: 'test-2'
               element3 = $$ -> @div class: 'test-3'
 
-              expect(keymap.bindingsForElement(element1)['ctrl-z']).toBeUndefined()
-              expect(keymap.bindingsForElement(element2)['ctrl-z']).toBeUndefined()
-              expect(keymap.bindingsForElement(element3)['ctrl-z']).toBeUndefined()
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)).toHaveLength 0
+              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(keymap.bindingsForElement(element1)['ctrl-z']).toBe "test-1"
-              expect(keymap.bindingsForElement(element2)['ctrl-z']).toBe "test-2"
-              expect(keymap.bindingsForElement(element3)['ctrl-z']).toBeUndefined()
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe "test-1"
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element2)[0].command).toBe "test-2"
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element3)).toHaveLength 0
 
           describe "when the metadata contains a 'keymaps' manifest", ->
             it "loads only the keymaps specified by the manifest, in the specified order", ->
               element1 = $$ -> @div class: 'test-1'
               element3 = $$ -> @div class: 'test-3'
 
-              expect(keymap.bindingsForElement(element1)['ctrl-z']).toBeUndefined()
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)).toHaveLength 0
 
-              atom.activatePackage("package-with-keymaps-manifest")
+              atom.packages.activatePackage("package-with-keymaps-manifest")
 
-              expect(keymap.bindingsForElement(element1)['ctrl-z']).toBe 'keymap-1'
-              expect(keymap.bindingsForElement(element1)['ctrl-n']).toBe 'keymap-2'
-              expect(keymap.bindingsForElement(element3)['ctrl-y']).toBeUndefined()
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe 'keymap-1'
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-n', element1)[0].command).toBe 'keymap-2'
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-y', element3)).toHaveLength 0
 
         describe "menu loading", ->
           beforeEach ->
@@ -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"
@@ -200,11 +200,16 @@ describe "the `atom` global", ->
               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")
+
+              one = atom.themes.stringToId(one)
+              two = atom.themes.stringToId(two)
+              three = atom.themes.stringToId(three)
+
               expect(atom.themes.stylesheetElementForId(one)).not.toExist()
               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()
@@ -216,11 +221,17 @@ describe "the `atom` global", ->
               one = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/1.css")
               two = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/2.less")
               three = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/3.css")
+
+
+              one = atom.themes.stringToId(one)
+              two = atom.themes.stringToId(two)
+              three = atom.themes.stringToId(three)
+
               expect(atom.themes.stylesheetElementForId(one)).not.toExist()
               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()
@@ -228,90 +239,91 @@ describe "the `atom` global", ->
 
         describe "grammar loading", ->
           it "loads the package's grammars", ->
-            atom.activatePackage('package-with-grammars')
-            expect(syntax.selectGrammar('a.alot').name).toBe 'Alot'
-            expect(syntax.selectGrammar('a.alittle').name).toBe 'Alittle'
+            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")
-            expect(syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
+            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(syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-          atom.activatePackage('language-ruby', sync: true)
-          expect(syntax.selectGrammar("file.rb").name).toBe "Ruby"
+          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+          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(syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
-          atom.activatePackage('language-ruby', sync: true)
-          expect(syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBe '# '
+          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
+          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 ->
-              syntax.addProperties.callCount > 0
+              atom.syntax.addProperties.callCount > 0
+
             runs ->
-              expect(syntax.getProperty(['.source.pref'], 'editor.increaseIndentPattern')).toBe '^abc$'
+              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')
-          expect(syntax.selectGrammar('a.alot').name).toBe 'Null Grammar'
-          expect(syntax.selectGrammar('a.alittle').name).toBe 'Null Grammar'
+          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')
-          expect(keymap.bindingsForElement($$ -> @div class: 'test-1')['ctrl-z']).toBeUndefined()
-          expect(keymap.bindingsForElement($$ -> @div class: 'test-2')['ctrl-z']).toBeUndefined()
+          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")
@@ -320,23 +332,23 @@ describe "the `atom` global", ->
           expect(atom.themes.stylesheetElementForId(three)).not.toExist()
 
         it "removes the package's scoped-properties", ->
-          atom.activatePackage("package-with-scoped-properties")
-          expect(syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
-          atom.deactivatePackage("package-with-scoped-properties")
-          expect(syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBeUndefined()
+          atom.packages.activatePackage("package-with-scoped-properties")
+          expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
+          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(syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-          atom.activatePackage('language-ruby', sync: true)
-          expect(syntax.selectGrammar("file.rb").name).toBe "Ruby"
-          atom.deactivatePackage('language-ruby')
-          expect(syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+          atom.packages.activatePackage('language-ruby', sync: true)
+          expect(atom.syntax.selectGrammar("file.rb").name).toBe "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')
-          expect(syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
+          atom.packages.activatePackage('language-ruby', sync: true)
+          atom.packages.deactivatePackage('language-ruby')
+          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
 
     describe ".activate()", ->
       packageActivator = null
@@ -376,7 +388,7 @@ describe "the `atom` global", ->
           packageName = 'package-with-main'
           atom.config.pushAtKeyPath('core.disabledPackages', packageName)
           atom.packages.observeDisabledPackages()
-          expect(config.get('core.disabledPackages')).toContain packageName
+          expect(atom.config.get('core.disabledPackages')).toContain packageName
 
           pack = atom.packages.enablePackage(packageName)
 
@@ -384,19 +396,19 @@ describe "the `atom` global", ->
           activatedPackages = atom.packages.getActivePackages()
           expect(loadedPackages).toContain(pack)
           expect(activatedPackages).toContain(pack)
-          expect(config.get('core.disabledPackages')).not.toContain packageName
+          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
 
         it ".disablePackage() disables an enabled package", ->
           packageName = 'package-with-main'
           atom.packages.activatePackage(packageName)
           atom.packages.observeDisabledPackages()
-          expect(config.get('core.disabledPackages')).not.toContain packageName
+          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
 
           pack = atom.packages.disablePackage(packageName)
 
           activatedPackages = atom.packages.getActivePackages()
           expect(activatedPackages).not.toContain(pack)
-          expect(config.get('core.disabledPackages')).toContain packageName
+          expect(atom.config.get('core.disabledPackages')).toContain packageName
 
       describe "with themes", ->
         beforeEach ->
@@ -409,20 +421,20 @@ describe "the `atom` global", ->
         it ".enablePackage() and .disablePackage() enables and disables a theme", ->
           packageName = 'theme-with-package-file'
 
-          expect(config.get('core.themes')).not.toContain packageName
-          expect(config.get('core.disabledPackages')).not.toContain packageName
+          expect(atom.config.get('core.themes')).not.toContain packageName
+          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
 
           # enabling of theme
           pack = atom.packages.enablePackage(packageName)
           activatedPackages = atom.packages.getActivePackages()
           expect(activatedPackages).toContain(pack)
-          expect(config.get('core.themes')).toContain packageName
-          expect(config.get('core.disabledPackages')).not.toContain packageName
+          expect(atom.config.get('core.themes')).toContain packageName
+          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
 
           # disabling of theme
           pack = atom.packages.disablePackage(packageName)
           activatedPackages = atom.packages.getActivePackages()
           expect(activatedPackages).not.toContain(pack)
-          expect(config.get('core.themes')).not.toContain packageName
-          expect(config.get('core.themes')).not.toContain packageName
-          expect(config.get('core.disabledPackages')).not.toContain packageName
+          expect(atom.config.get('core.themes')).not.toContain packageName
+          expect(atom.config.get('core.themes')).not.toContain packageName
+          expect(atom.config.get('core.disabledPackages')).not.toContain packageName

spec/command-installer-spec.coffee

@@ -12,24 +12,25 @@ describe "install(commandPath, callback)", ->
     spyOn(installer, 'findInstallDirectory').andCallFake (callback) ->
       callback(directory)
 
-    fs.remove(directory) if fs.exists(directory)
+    fs.removeSync(directory) if fs.existsSync(directory)
 
-  it "symlinks the command and makes it executable", ->
-    fs.writeSync(commandPath, 'test')
-    expect(fs.isFileSync(commandPath)).toBeTruthy()
-    expect(fs.isExecutableSync(commandPath)).toBeFalsy()
-    expect(fs.isFileSync(destinationPath)).toBeFalsy()
+  describe "on #darwin", ->
+    it "symlinks the command and makes it executable", ->
+      fs.writeFileSync(commandPath, 'test')
+      expect(fs.isFileSync(commandPath)).toBeTruthy()
+      expect(fs.isExecutableSync(commandPath)).toBeFalsy()
+      expect(fs.isFileSync(destinationPath)).toBeFalsy()
 
-    installDone = false
-    installError = null
-    installer.install commandPath, (error) ->
-      installDone = true
-      installError = error
+      installDone = false
+      installError = null
+      installer.install commandPath, (error) ->
+        installDone = true
+        installError = error
 
-    waitsFor -> installDone
+      waitsFor -> installDone
 
-    runs ->
-      expect(installError).toBeNull()
-      expect(fs.isFileSync(destinationPath)).toBeTruthy()
-      expect(fs.realpathSync(destinationPath)).toBe fs.realpathSync(commandPath)
-      expect(fs.isExecutableSync(destinationPath)).toBeTruthy()
+      runs ->
+        expect(installError).toBeNull()
+        expect(fs.isFileSync(destinationPath)).toBeTruthy()
+        expect(fs.realpathSync(destinationPath)).toBe fs.realpathSync(commandPath)
+        expect(fs.isExecutableSync(destinationPath)).toBeTruthy()

spec/config-spec.coffee

@@ -8,272 +8,296 @@ describe "Config", ->
 
   describe ".get(keyPath)", ->
     it "allows a key path's value to be read", ->
-      expect(config.set("foo.bar.baz", 42)).toBe 42
-      expect(config.get("foo.bar.baz")).toBe 42
-      expect(config.get("bogus.key.path")).toBeUndefined()
+      expect(atom.config.set("foo.bar.baz", 42)).toBe 42
+      expect(atom.config.get("foo.bar.baz")).toBe 42
+      expect(atom.config.get("bogus.key.path")).toBeUndefined()
 
     it "returns a deep clone of the key path's value", ->
-      config.set('value', array: [1, b: 2, 3])
-      retrievedValue = config.get('value')
+      atom.config.set('value', array: [1, b: 2, 3])
+      retrievedValue = atom.config.get('value')
       retrievedValue.array[0] = 4
       retrievedValue.array[1].b = 2.1
-      expect(config.get('value')).toEqual(array: [1, b: 2, 3])
+      expect(atom.config.get('value')).toEqual(array: [1, b: 2, 3])
 
   describe ".set(keyPath, value)", ->
     it "allows a key path's value to be written", ->
-      expect(config.set("foo.bar.baz", 42)).toBe 42
-      expect(config.get("foo.bar.baz")).toBe 42
+      expect(atom.config.set("foo.bar.baz", 42)).toBe 42
+      expect(atom.config.get("foo.bar.baz")).toBe 42
 
     it "updates observers and saves when a key path is set", ->
       observeHandler = jasmine.createSpy "observeHandler"
-      config.observe "foo.bar.baz", observeHandler
+      atom.config.observe "foo.bar.baz", observeHandler
       observeHandler.reset()
 
-      config.set("foo.bar.baz", 42)
+      atom.config.set("foo.bar.baz", 42)
 
-      expect(config.save).toHaveBeenCalled()
+      expect(atom.config.save).toHaveBeenCalled()
       expect(observeHandler).toHaveBeenCalledWith 42, {previous: undefined}
 
     describe "when the value equals the default value", ->
       it "does not store the value", ->
-        config.setDefaults("foo", same: 1, changes: 1)
-        expect(config.settings.foo).toBeUndefined()
-        config.set('foo.same', 1)
-        config.set('foo.changes', 2)
-        expect(config.settings.foo).toEqual {changes: 2}
+        atom.config.setDefaults("foo", same: 1, changes: 1)
+        expect(atom.config.settings.foo).toBeUndefined()
+        atom.config.set('foo.same', 1)
+        atom.config.set('foo.changes', 2)
+        expect(atom.config.settings.foo).toEqual {changes: 2}
 
-        config.set('foo.changes', 1)
-        expect(config.settings.foo).toEqual {}
+        atom.config.set('foo.changes', 1)
+        expect(atom.config.settings.foo).toEqual {}
+
+  describe ".toggle(keyPath)", ->
+    it "negates the boolean value of the current key path value", ->
+      atom.config.set('foo.a', 1)
+      atom.config.toggle('foo.a')
+      expect(atom.config.get('foo.a')).toBe false
+
+      atom.config.set('foo.a', '')
+      atom.config.toggle('foo.a')
+      expect(atom.config.get('foo.a')).toBe true
+
+      atom.config.set('foo.a', null)
+      atom.config.toggle('foo.a')
+      expect(atom.config.get('foo.a')).toBe true
+
+      atom.config.set('foo.a', true)
+      atom.config.toggle('foo.a')
+      expect(atom.config.get('foo.a')).toBe false
 
   describe ".pushAtKeyPath(keyPath, value)", ->
     it "pushes the given value to the array at the key path and updates observers", ->
-      config.set("foo.bar.baz", ["a"])
+      atom.config.set("foo.bar.baz", ["a"])
       observeHandler = jasmine.createSpy "observeHandler"
-      config.observe "foo.bar.baz", observeHandler
+      atom.config.observe "foo.bar.baz", observeHandler
       observeHandler.reset()
 
-      expect(config.pushAtKeyPath("foo.bar.baz", "b")).toBe 2
-      expect(config.get("foo.bar.baz")).toEqual ["a", "b"]
-      expect(observeHandler).toHaveBeenCalledWith config.get("foo.bar.baz"), {previous: ['a']}
+      expect(atom.config.pushAtKeyPath("foo.bar.baz", "b")).toBe 2
+      expect(atom.config.get("foo.bar.baz")).toEqual ["a", "b"]
+      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz"), {previous: ['a']}
 
   describe ".unshiftAtKeyPath(keyPath, value)", ->
     it "unshifts the given value to the array at the key path and updates observers", ->
-      config.set("foo.bar.baz", ["b"])
+      atom.config.set("foo.bar.baz", ["b"])
       observeHandler = jasmine.createSpy "observeHandler"
-      config.observe "foo.bar.baz", observeHandler
+      atom.config.observe "foo.bar.baz", observeHandler
       observeHandler.reset()
 
-      expect(config.unshiftAtKeyPath("foo.bar.baz", "a")).toBe 2
-      expect(config.get("foo.bar.baz")).toEqual ["a", "b"]
-      expect(observeHandler).toHaveBeenCalledWith config.get("foo.bar.baz"), {previous: ['b']}
+      expect(atom.config.unshiftAtKeyPath("foo.bar.baz", "a")).toBe 2
+      expect(atom.config.get("foo.bar.baz")).toEqual ["a", "b"]
+      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz"), {previous: ['b']}
 
   describe ".removeAtKeyPath(keyPath, value)", ->
     it "removes the given value from the array at the key path and updates observers", ->
-      config.set("foo.bar.baz", ["a", "b", "c"])
+      atom.config.set("foo.bar.baz", ["a", "b", "c"])
       observeHandler = jasmine.createSpy "observeHandler"
-      config.observe "foo.bar.baz", observeHandler
+      atom.config.observe "foo.bar.baz", observeHandler
       observeHandler.reset()
 
-      expect(config.removeAtKeyPath("foo.bar.baz", "b")).toEqual ["a", "c"]
-      expect(config.get("foo.bar.baz")).toEqual ["a", "c"]
-      expect(observeHandler).toHaveBeenCalledWith config.get("foo.bar.baz"), {previous: ['a', 'b', 'c']}
+      expect(atom.config.removeAtKeyPath("foo.bar.baz", "b")).toEqual ["a", "c"]
+      expect(atom.config.get("foo.bar.baz")).toEqual ["a", "c"]
+      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz"), {previous: ['a', 'b', 'c']}
 
   describe ".getPositiveInt(keyPath, defaultValue)", ->
     it "returns the proper current or default value", ->
-      config.set('editor.preferredLineLength', 0)
-      expect(config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
-      config.set('editor.preferredLineLength', -1234)
-      expect(config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
-      config.set('editor.preferredLineLength', 'abcd')
-      expect(config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
-      config.set('editor.preferredLineLength', null)
-      expect(config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+      atom.config.set('editor.preferredLineLength', 0)
+      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+      atom.config.set('editor.preferredLineLength', -1234)
+      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+      atom.config.set('editor.preferredLineLength', 'abcd')
+      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+      atom.config.set('editor.preferredLineLength', null)
+      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", ->
-        config.configFilePath = path.join(config.configDirPath, "config.json")
-        config.set("a.b.c", 1)
-        config.set("a.b.d", 2)
-        config.set("x.y.z", 3)
-        config.setDefaults("a.b", e: 4, f: 5)
+        atom.config.configFilePath = path.join(atom.config.configDirPath, "atom.config.json")
+        atom.config.set("a.b.c", 1)
+        atom.config.set("a.b.d", 2)
+        atom.config.set("x.y.z", 3)
+        atom.config.setDefaults("a.b", e: 4, f: 5)
 
-        nodeFs.writeFileSync.reset()
-        config.save()
+        CSON.writeFileSync.reset()
+        atom.config.save()
 
-        expect(nodeFs.writeFileSync.argsForCall[0][0]).toBe(path.join(config.configDirPath, "config.json"))
-        writtenConfig = JSON.parse(nodeFs.writeFileSync.argsForCall[0][1])
-        expect(writtenConfig).toEqual 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", ->
-        config.configFilePath = path.join(config.configDirPath, "config.cson")
-        config.set("a.b.c", 1)
-        config.set("a.b.d", 2)
-        config.set("x.y.z", 3)
-        config.setDefaults("a.b", e: 4, f: 5)
+        atom.config.configFilePath = path.join(atom.config.configDirPath, "atom.config.cson")
+        atom.config.set("a.b.c", 1)
+        atom.config.set("a.b.d", 2)
+        atom.config.set("x.y.z", 3)
+        atom.config.setDefaults("a.b", e: 4, f: 5)
 
-        nodeFs.writeFileSync.reset()
-        config.save()
+        CSON.writeFileSync.reset()
+        atom.config.save()
 
-        expect(nodeFs.writeFileSync.argsForCall[0][0]).toBe(path.join(config.configDirPath, "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)
-        expect(writtenConfig).toEqual config.settings
+        writtenConfig = CSON.writeFileSync.argsForCall[0][1]
+        expect(writtenConfig).toEqual atom.config.settings
 
   describe ".setDefaults(keyPath, defaults)", ->
     it "assigns any previously-unassigned keys to the object at the key path", ->
-      config.set("foo.bar.baz", a: 1)
-      config.setDefaults("foo.bar.baz", a: 2, b: 3, c: 4)
-      expect(config.get("foo.bar.baz.a")).toBe 1
-      expect(config.get("foo.bar.baz.b")).toBe 3
-      expect(config.get("foo.bar.baz.c")).toBe 4
+      atom.config.set("foo.bar.baz", a: 1)
+      atom.config.setDefaults("foo.bar.baz", a: 2, b: 3, c: 4)
+      expect(atom.config.get("foo.bar.baz.a")).toBe 1
+      expect(atom.config.get("foo.bar.baz.b")).toBe 3
+      expect(atom.config.get("foo.bar.baz.c")).toBe 4
 
-      config.setDefaults("foo.quux", x: 0, y: 1)
-      expect(config.get("foo.quux.x")).toBe 0
-      expect(config.get("foo.quux.y")).toBe 1
+      atom.config.setDefaults("foo.quux", x: 0, y: 1)
+      expect(atom.config.get("foo.quux.x")).toBe 0
+      expect(atom.config.get("foo.quux.y")).toBe 1
 
   describe ".observe(keyPath)", ->
-    observeHandler = null
+    [observeHandler, observeSubscription] = []
 
     beforeEach ->
       observeHandler = jasmine.createSpy("observeHandler")
-      config.set("foo.bar.baz", "value 1")
-      config.observe "foo.bar.baz", observeHandler
+      atom.config.set("foo.bar.baz", "value 1")
+      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")
 
     it "fires the callback every time the observed value changes", ->
       observeHandler.reset() # clear the initial call
-      config.set('foo.bar.baz', "value 2")
+      atom.config.set('foo.bar.baz', "value 2")
       expect(observeHandler).toHaveBeenCalledWith("value 2", {previous: 'value 1'})
       observeHandler.reset()
 
-      config.set('foo.bar.baz', "value 1")
+      atom.config.set('foo.bar.baz', "value 1")
       expect(observeHandler).toHaveBeenCalledWith("value 1", {previous: 'value 2'})
 
     it "fires the callback when the observed value is deleted", ->
       observeHandler.reset() # clear the initial call
-      config.set('foo.bar.baz', undefined)
+      atom.config.set('foo.bar.baz', undefined)
       expect(observeHandler).toHaveBeenCalledWith(undefined, {previous: 'value 1'})
 
     it "fires the callback when the full key path goes into and out of existence", ->
       observeHandler.reset() # clear the initial call
-      config.set("foo.bar", undefined)
+      atom.config.set("foo.bar", undefined)
 
       expect(observeHandler).toHaveBeenCalledWith(undefined, {previous: 'value 1'})
       observeHandler.reset()
 
-      config.set("foo.bar.baz", "i'm back")
+      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 ->
-      config.configDirPath = dotAtomPath
-      expect(fs.exists(config.configDirPath)).toBeFalsy()
+      atom.config.configDirPath = dotAtomPath
+      expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
 
     afterEach ->
-      fs.remove(dotAtomPath) if fs.exists(dotAtomPath)
+      fs.removeSync(dotAtomPath) if fs.existsSync(dotAtomPath)
 
     describe "when the configDirPath doesn't exist", ->
       it "copies the contents of dot-atom to ~/.atom", ->
         initializationDone = false
         jasmine.unspy(window, "setTimeout")
-        config.initializeConfigDirectory ->
+        atom.config.initializeConfigDirectory ->
           initializationDone = true
 
         waitsFor -> initializationDone
 
         runs ->
-          expect(fs.exists(config.configDirPath)).toBeTruthy()
-          expect(fs.exists(path.join(config.configDirPath, 'packages'))).toBeTruthy()
-          expect(fs.exists(path.join(config.configDirPath, 'snippets'))).toBeTruthy()
-          expect(fs.isFileSync(path.join(config.configDirPath, 'config.cson'))).toBeTruthy()
+          expect(fs.existsSync(atom.config.configDirPath)).toBeTruthy()
+          expect(fs.existsSync(path.join(atom.config.configDirPath, 'packages'))).toBeTruthy()
+          expect(fs.existsSync(path.join(atom.config.configDirPath, 'snippets'))).toBeTruthy()
+          expect(fs.isFileSync(path.join(atom.config.configDirPath, 'config.cson'))).toBeTruthy()
 
   describe ".loadUserConfig()", ->
     beforeEach ->
-      config.configDirPath = dotAtomPath
-      config.configFilePath = path.join(config.configDirPath, "config.cson")
-      expect(fs.exists(config.configDirPath)).toBeFalsy()
+      atom.config.configDirPath = dotAtomPath
+      atom.config.configFilePath = path.join(atom.config.configDirPath, "atom.config.cson")
+      expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
 
     afterEach ->
-      fs.remove(dotAtomPath) if fs.exists(dotAtomPath)
+      fs.removeSync(dotAtomPath) if fs.existsSync(dotAtomPath)
 
     describe "when the config file contains valid cson", ->
       beforeEach ->
-        fs.writeSync(config.configFilePath, "foo: bar: 'baz'")
-        config.loadUserConfig()
+        fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'baz'")
+        atom.config.loadUserConfig()
 
       it "updates the config data based on the file contents", ->
-        expect(config.get("foo.bar")).toBe 'baz'
+        expect(atom.config.get("foo.bar")).toBe 'baz'
 
     describe "when the config file contains invalid cson", ->
       beforeEach ->
         spyOn(console, 'error')
-        fs.writeSync(config.configFilePath, "{{{{{")
+        fs.writeFileSync(atom.config.configFilePath, "{{{{{")
 
       it "logs an error to the console and does not overwrite the config file on a subsequent save", ->
-        config.loadUserConfig()
+        atom.config.loadUserConfig()
         expect(console.error).toHaveBeenCalled()
-        config.set("hair", "blonde") # trigger a save
-        expect(config.save).not.toHaveBeenCalled()
+        atom.config.set("hair", "blonde") # trigger a save
+        expect(atom.config.save).not.toHaveBeenCalled()
 
     describe "when the config file does not exist", ->
       it "creates it with an empty object", ->
-        fs.makeTree(config.configDirPath)
-        config.loadUserConfig()
-        expect(fs.exists(config.configFilePath)).toBe true
-        expect(CSON.readFileSync(config.configFilePath)).toEqual {}
+        fs.makeTreeSync(atom.config.configDirPath)
+        atom.config.loadUserConfig()
+        expect(fs.existsSync(atom.config.configFilePath)).toBe true
+        expect(CSON.readFileSync(atom.config.configFilePath)).toEqual {}
 
   describe ".observeUserConfig()", ->
     updatedHandler = null
 
     beforeEach ->
-      config.configDirPath = dotAtomPath
-      config.configFilePath = path.join(config.configDirPath, "config.cson")
-      expect(fs.exists(config.configDirPath)).toBeFalsy()
-      fs.writeSync(config.configFilePath, "foo: bar: 'baz'")
-      config.loadUserConfig()
-      config.observeUserConfig()
+      atom.config.configDirPath = dotAtomPath
+      atom.config.configFilePath = path.join(atom.config.configDirPath, "atom.config.cson")
+      expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
+      fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'baz'")
+      atom.config.loadUserConfig()
+      atom.config.observeUserConfig()
       updatedHandler = jasmine.createSpy("updatedHandler")
-      config.on 'updated', updatedHandler
+      atom.config.on 'updated', updatedHandler
 
     afterEach ->
-      config.unobserveUserConfig()
-      fs.remove(dotAtomPath) if fs.exists(dotAtomPath)
+      atom.config.unobserveUserConfig()
+      fs.removeSync(dotAtomPath) if fs.existsSync(dotAtomPath)
 
     describe "when the config file changes to contain valid cson", ->
       it "updates the config data", ->
-        fs.writeSync(config.configFilePath, "foo: { bar: 'quux', baz: 'bar'}")
+        fs.writeFileSync(atom.config.configFilePath, "foo: { bar: 'quux', baz: 'bar'}")
         waitsFor 'update event', -> updatedHandler.callCount > 0
         runs ->
-          expect(config.get('foo.bar')).toBe 'quux'
-          expect(config.get('foo.baz')).toBe 'bar'
+          expect(atom.config.get('foo.bar')).toBe 'quux'
+          expect(atom.config.get('foo.baz')).toBe 'bar'
 
     describe "when the config file changes to contain invalid cson", ->
       beforeEach ->
         spyOn(console, 'error')
-        fs.writeSync(config.configFilePath, "}}}")
+        fs.writeFileSync(atom.config.configFilePath, "}}}")
         waitsFor "error to be logged", -> console.error.callCount > 0
 
       it "logs a warning and does not update config data", ->
         expect(updatedHandler.callCount).toBe 0
-        expect(config.get('foo.bar')).toBe 'baz'
-        config.set("hair", "blonde") # trigger a save
-        expect(config.save).not.toHaveBeenCalled()
+        expect(atom.config.get('foo.bar')).toBe 'baz'
+        atom.config.set("hair", "blonde") # trigger a save
+        expect(atom.config.save).not.toHaveBeenCalled()
 
       describe "when the config file subsequently changes again to contain valid cson", ->
         beforeEach ->
-          fs.writeSync(config.configFilePath, "foo: bar: 'baz'")
+          fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'baz'")
           waitsFor 'update event', -> updatedHandler.callCount > 0
 
         it "updates the config data and resumes saving", ->
-          config.set("hair", "blonde")
-          expect(config.save).toHaveBeenCalled()
+          atom.config.set("hair", "blonde")
+          expect(atom.config.save).toHaveBeenCalled()

spec/directory-spec.coffee

@@ -16,10 +16,10 @@ describe "Directory", ->
 
     beforeEach ->
       temporaryFilePath = path.join(__dirname, 'fixtures', 'temporary')
-      fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
+      fs.removeSync(temporaryFilePath) if fs.existsSync(temporaryFilePath)
 
     afterEach ->
-      fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
+      fs.removeSync(temporaryFilePath) if fs.existsSync(temporaryFilePath)
 
     it "triggers 'contents-changed' event handlers", ->
       changeHandler = null
@@ -27,13 +27,13 @@ describe "Directory", ->
       runs ->
         changeHandler = jasmine.createSpy('changeHandler')
         directory.on 'contents-changed', changeHandler
-        fs.writeSync(temporaryFilePath, '')
+        fs.writeFileSync(temporaryFilePath, '')
 
       waitsFor "first change", -> changeHandler.callCount > 0
 
       runs ->
         changeHandler.reset()
-        fs.remove(temporaryFilePath)
+        fs.removeSync(temporaryFilePath)
 
       waitsFor "second change", -> changeHandler.callCount > 0
 
@@ -42,10 +42,10 @@ describe "Directory", ->
 
     beforeEach ->
       temporaryFilePath = path.join(directory.path, 'temporary')
-      fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
+      fs.removeSync(temporaryFilePath) if fs.existsSync(temporaryFilePath)
 
     afterEach ->
-      fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
+      fs.removeSync(temporaryFilePath) if fs.existsSync(temporaryFilePath)
 
     it "no longer triggers events", ->
       changeHandler = null
@@ -53,7 +53,7 @@ describe "Directory", ->
       runs ->
         changeHandler = jasmine.createSpy('changeHandler')
         directory.on 'contents-changed', changeHandler
-        fs.writeSync(temporaryFilePath, '')
+        fs.writeFileSync(temporaryFilePath, '')
 
       waitsFor "change event", -> changeHandler.callCount > 0
 
@@ -62,36 +62,49 @@ describe "Directory", ->
         directory.off()
       waits 20
 
-      runs -> fs.remove(temporaryFilePath)
+      runs -> fs.removeSync(temporaryFilePath)
       waits 20
       runs -> expect(changeHandler.callCount).toBe 0
 
-  it "includes symlink information about entries", ->
-    entries = directory.getEntries()
-    for entry in entries
-      name = entry.getBaseName()
-      if name is 'symlink-to-dir' or name is 'symlink-to-file'
-        expect(entry.symlink).toBeTruthy()
-      else
-        expect(entry.symlink).toBeFalsy()
+  describe "on #darwin or #linux", ->
+    it "includes symlink information about entries", ->
+      entries = directory.getEntries()
+      for entry in entries
+        name = entry.getBaseName()
+        if name is 'symlink-to-dir' or name is 'symlink-to-file'
+          expect(entry.symlink).toBeTruthy()
+        else
+          expect(entry.symlink).toBeFalsy()
 
   describe ".relativize(path)", ->
-    it "returns a relative path based on the directory's path", ->
-      absolutePath = directory.getPath()
-      expect(directory.relativize(absolutePath)).toBe ''
-      expect(directory.relativize(path.join(absolutePath, "b"))).toBe "b"
-      expect(directory.relativize(path.join(absolutePath, "b/file.coffee"))).toBe "b/file.coffee"
-      expect(directory.relativize(path.join(absolutePath, "file.coffee"))).toBe "file.coffee"
+    describe "on #darwin or #linux", ->
+      it "returns a relative path based on the directory's path", ->
+        absolutePath = directory.getPath()
+        expect(directory.relativize(absolutePath)).toBe ''
+        expect(directory.relativize(path.join(absolutePath, "b"))).toBe "b"
+        expect(directory.relativize(path.join(absolutePath, "b/file.coffee"))).toBe "b/file.coffee"
+        expect(directory.relativize(path.join(absolutePath, "file.coffee"))).toBe "file.coffee"
 
-    it "returns a relative path based on the directory's symlinked source path", ->
-      symlinkPath = path.join(__dirname, 'fixtures', 'symlink-to-dir')
-      symlinkDirectory = new Directory(symlinkPath)
-      realFilePath = require.resolve('./fixtures/dir/a')
-      expect(symlinkDirectory.relativize(symlinkPath)).toBe ''
-      expect(symlinkDirectory.relativize(realFilePath)).toBe 'a'
+      it "returns a relative path based on the directory's symlinked source path", ->
+        symlinkPath = path.join(__dirname, 'fixtures', 'symlink-to-dir')
+        symlinkDirectory = new Directory(symlinkPath)
+        realFilePath = require.resolve('./fixtures/dir/a')
+        expect(symlinkDirectory.relativize(symlinkPath)).toBe ''
+        expect(symlinkDirectory.relativize(realFilePath)).toBe 'a'
 
-    it "returns the full path if the directory's path is not a prefix of the path", ->
-      expect(directory.relativize('/not/relative')).toBe '/not/relative'
+      it "returns the full path if the directory's path is not a prefix of the path", ->
+        expect(directory.relativize('/not/relative')).toBe '/not/relative'
+
+    describe "on #win32", ->
+      it "returns a relative path based on the directory's path", ->
+        absolutePath = directory.getPath()
+        expect(directory.relativize(absolutePath)).toBe ''
+        expect(directory.relativize(path.join(absolutePath, "b"))).toBe "b"
+        expect(directory.relativize(path.join(absolutePath, "b/file.coffee"))).toBe "b\\file.coffee"
+        expect(directory.relativize(path.join(absolutePath, "file.coffee"))).toBe "file.coffee"
+
+      it "returns the full path if the directory's path is not a prefix of the path", ->
+        expect(directory.relativize('/not/relative')).toBe "\\not\\relative"
 
   describe ".contains(path)", ->
     it "returns true if the path is a child of the directory's path", ->
@@ -100,11 +113,12 @@ describe "Directory", ->
       expect(directory.contains(path.join(absolutePath, "b", "file.coffee"))).toBe true
       expect(directory.contains(path.join(absolutePath, "file.coffee"))).toBe true
 
-    it "returns true if the path is a child of the directory's symlinked source path", ->
-      symlinkPath = path.join(__dirname, 'fixtures', 'symlink-to-dir')
-      symlinkDirectory = new Directory(symlinkPath)
-      realFilePath = require.resolve('./fixtures/dir/a')
-      expect(symlinkDirectory.contains(realFilePath)).toBe true
-
     it "returns false if the directory's path is not a prefix of the path", ->
       expect(directory.contains('/not/relative')).toBe false
+
+    describe "on #darwin or #linux", ->
+      it "returns true if the path is a child of the directory's symlinked source path", ->
+        symlinkPath = path.join(__dirname, 'fixtures', 'symlink-to-dir')
+        symlinkDirectory = new Directory(symlinkPath)
+        realFilePath = require.resolve('./fixtures/dir/a')
+        expect(symlinkDirectory.contains(realFilePath)).toBe true

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
@@ -66,14 +66,14 @@ describe "DisplayBuffer", ->
     describe "rendering of soft-wrapped lines", ->
       describe "when editor.softWrapAtPreferredLineLength is set", ->
         it "uses the preferred line length as the soft wrap column when it is less than the configured soft wrap column", ->
-          config.set('editor.preferredLineLength', 100)
-          config.set('editor.softWrapAtPreferredLineLength', true)
+          atom.config.set('editor.preferredLineLength', 100)
+          atom.config.set('editor.softWrapAtPreferredLineLength', true)
           expect(displayBuffer.lineForRow(10).text).toBe '    return '
 
-          config.set('editor.preferredLineLength', 5)
+          atom.config.set('editor.preferredLineLength', 5)
           expect(displayBuffer.lineForRow(10).text).toBe 'funct'
 
-          config.set('editor.softWrapAtPreferredLineLength', false)
+          atom.config.set('editor.softWrapAtPreferredLineLength', false)
           expect(displayBuffer.lineForRow(10).text).toBe '    return '
 
       describe "when the line is shorter than the max line length", ->
@@ -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/edit-session-replication-spec.coffee

@@ -1,62 +0,0 @@
-{Site} = require 'telepath'
-Environment = require './environment'
-
-describe "EditSession replication", ->
-  [env1, env2, editSession1, editSession2] = []
-  beforeEach ->
-    env1 = new Environment(siteId: 1)
-    env2 = env1.clone(siteId: 2)
-    envConnection = env1.connect(env2)
-    doc2 = null
-
-    env1.run ->
-      editSession1 = project.openSync('sample.js')
-      editSession1.setScrollTop(5)
-      editSession1.setScrollLeft(5)
-      editSession1.setCursorScreenPosition([0, 5])
-      editSession1.addSelectionForBufferRange([[1, 2], [3, 4]])
-      doc1 = editSession1.getState()
-      doc2 = doc1.clone(env2.site)
-      envConnection.connect(doc1, doc2)
-
-    env2.run ->
-      editSession2 = deserialize(doc2)
-
-  afterEach ->
-    env1.destroy()
-    env2.destroy()
-
-  it "replicates the selections of existing replicas", ->
-    expect(editSession2.getRemoteSelectedBufferRanges()).toEqual editSession1.getSelectedBufferRanges()
-
-    editSession1.getLastSelection().setBufferRange([[2, 3], [4, 5]])
-    expect(editSession2.getRemoteSelectedBufferRanges()).toEqual editSession1.getSelectedBufferRanges()
-
-    editSession1.addCursorAtBufferPosition([5, 6])
-    expect(editSession2.getRemoteSelectedBufferRanges()).toEqual editSession1.getSelectedBufferRanges()
-
-    editSession1.consolidateSelections()
-    expect(editSession2.getRemoteSelectedBufferRanges()).toEqual editSession1.getSelectedBufferRanges()
-
-  it "introduces a local cursor for a new replica at the position of the last remote cursor", ->
-    expect(editSession2.getCursors().length).toBe 1
-    expect(editSession2.getSelections().length).toBe 1
-    expect(editSession2.getCursorBufferPosition()).toEqual [3, 4]
-    expect(editSession2.getSelectedBufferRanges()).toEqual [[[3, 4], [3, 4]]]
-
-    expect(editSession1.getRemoteCursors().length).toBe 1
-    expect(editSession1.getRemoteSelections().length).toBe 1
-    [cursor] = editSession1.getRemoteCursors()
-    [selection] = editSession1.getRemoteSelections()
-    expect(cursor.getBufferPosition()).toEqual [3, 4]
-    expect(selection.getBufferRange()).toEqual [[3, 4], [3, 4]]
-
-  it "replicates the scroll position", ->
-    expect(editSession2.getScrollTop()).toBe editSession1.getScrollTop()
-    expect(editSession2.getScrollLeft()).toBe editSession1.getScrollLeft()
-
-    editSession1.setScrollTop(10)
-    expect(editSession2.getScrollTop()).toBe 10
-
-    editSession2.setScrollLeft(20)
-    expect(editSession1.getScrollLeft()).toBe 20

spec/editor-replication-spec.coffee

@@ -1,37 +0,0 @@
-{Site} = require 'telepath'
-Editor = require '../src/editor'
-Environment = require './environment'
-
-describe "Editor replication", ->
-  [env1, env2, editSession1, editSession2, editor1, editor2] = []
-
-  beforeEach ->
-    env1 = new Environment(siteId: 1)
-    env2 = env1.clone(siteId: 2)
-    envConnection = env1.connect(env2)
-    doc2 = null
-
-    env1.run ->
-      editSession1 = project.openSync('sample.js')
-      editSession1.setSelectedBufferRange([[1, 2], [3, 4]])
-      doc1 = editSession1.getState()
-      doc2 = doc1.clone(env2.site)
-      envConnection.connect(doc1, doc2)
-      editor1 = new Editor(editSession1)
-      editor1.attachToDom()
-
-    env2.run ->
-      editSession2 = deserialize(doc2)
-      editor2 = new Editor(editSession2)
-      editor2.attachToDom()
-
-  afterEach ->
-    env1.destroy()
-    env2.destroy()
-
-  it "displays the cursors and selections from all replicas", ->
-    expect(editor1.getSelectionViews().length).toBe 2
-    expect(editor2.getSelectionViews().length).toBe 2
-
-    expect(editor1.getCursorViews().length).toBe 2
-    expect(editor2.getCursorViews().length).toBe 2

spec/environment.coffee

@@ -1,59 +0,0 @@
-path = require 'path'
-{Site} = require 'telepath'
-{fs} = require 'atom'
-Project = require '../src/project'
-
-module.exports =
-class Environment
-  constructor: ({@site, @state, siteId, projectPath}={}) ->
-    @site ?= new Site(siteId ? 1)
-    if @state?
-      @run => @project = deserialize(@state.get('project'))
-    else
-      @state = @site.createDocument({})
-      @project = new Project(projectPath ? path.join(__dirname, 'fixtures'))
-      @state.set(project: @project.getState())
-
-  clone: (params) ->
-    site = new Site(params.siteId)
-    new Environment(site: site, state: @state.clone(site))
-
-  destroy: ->
-    @project.destroy()
-
-  getState: -> @state
-
-  run: (fn) ->
-    uninstall = @install()
-    fn()
-    uninstall()
-
-  install: ->
-    oldSite = window.site
-    oldProject = window.project
-    window.site = @site
-    window.project = @project
-    ->
-      window.site = oldSite
-      window.project = oldProject
-
-  connect: (otherEnv) ->
-    new EnvironmentConnection(this, otherEnv)
-
-
-  connectDocuments: (docA, docB, envB) ->
-
-class EnvironmentConnection
-  constructor: (@envA, @envB) ->
-    @envA.getState().connect(@envB.getState())
-
-  connect: (docA, docB) ->
-    unless docA.site is @envA.site
-      throw new Error("Document and environment sites do not match (doc: site #{docA.site.id}, env: site #{@envA.site.id})")
-    unless docB.site is @envB.site
-      throw new Error("Document and environment sites do not match (doc: site #{docB.site.id}, env: site #{@envB.site.id})")
-
-    connection = docA.connect(docB)
-    connection.abFilter = (fn) => @envB.run(fn)
-    connection.baFilter = (fn) => @envA.run(fn)
-    connection

spec/file-spec.coffee

@@ -6,19 +6,19 @@ describe 'File', ->
 
   beforeEach ->
     filePath = path.join(__dirname, 'fixtures', 'atom-file-test.txt') # Don't put in /tmp because /tmp symlinks to /private/tmp and screws up the rename test
-    fs.remove(filePath) if fs.exists(filePath)
-    fs.writeSync(filePath, "this is old!")
+    fs.removeSync(filePath) if fs.existsSync(filePath)
+    fs.writeFileSync(filePath, "this is old!")
     file = new File(filePath)
 
   afterEach ->
     file.off()
-    fs.remove(filePath) if fs.exists(filePath)
+    fs.removeSync(filePath) if fs.existsSync(filePath)
 
   describe "when the file has not been read", ->
     describe "when the contents of the file change", ->
       it "triggers 'contents-changed' event handlers", ->
         file.on 'contents-changed', changeHandler = jasmine.createSpy('changeHandler')
-        fs.writeSync(file.getPath(), "this is new!")
+        fs.writeFileSync(file.getPath(), "this is new!")
 
         waitsFor "change event", ->
           changeHandler.callCount > 0
@@ -32,14 +32,14 @@ describe 'File', ->
         changeHandler = null
         changeHandler = jasmine.createSpy('changeHandler')
         file.on 'contents-changed', changeHandler
-        fs.writeSync(file.getPath(), "this is new!")
+        fs.writeFileSync(file.getPath(), "this is new!")
 
         waitsFor "change event", ->
           changeHandler.callCount > 0
 
         runs ->
           changeHandler.reset()
-          fs.writeSync(file.getPath(), "this is newer!")
+          fs.writeFileSync(file.getPath(), "this is newer!")
 
         waitsFor "second change event", ->
           changeHandler.callCount > 0
@@ -49,7 +49,7 @@ describe 'File', ->
         removeHandler = null
         removeHandler = jasmine.createSpy('removeHandler')
         file.on 'removed', removeHandler
-        fs.remove(file.getPath())
+        fs.removeSync(file.getPath())
 
         waitsFor "remove event", ->
           removeHandler.callCount > 0
@@ -61,8 +61,8 @@ describe 'File', ->
         newPath = path.join(path.dirname(filePath), "atom-file-was-moved-test.txt")
 
       afterEach ->
-        if fs.exists(newPath)
-          fs.remove(newPath)
+        if fs.existsSync(newPath)
+          fs.removeSync(newPath)
           waitsFor "remove event", (done) -> file.on 'removed', done
 
       it "it updates its path", ->
@@ -71,7 +71,7 @@ describe 'File', ->
         moveHandler = jasmine.createSpy('moveHandler')
         file.on 'moved', moveHandler
 
-        fs.move(filePath, newPath)
+        fs.moveSync(filePath, newPath)
 
         waitsFor "move event", ->
           moveHandler.callCount > 0
@@ -88,14 +88,14 @@ describe 'File', ->
         changeHandler = jasmine.createSpy('changeHandler')
         file.on 'contents-changed', changeHandler
 
-        fs.move(filePath, newPath)
+        fs.moveSync(filePath, newPath)
 
         waitsFor "move event", ->
           moveHandler.callCount > 0
 
         runs ->
           expect(changeHandler).not.toHaveBeenCalled()
-          fs.writeSync(file.getPath(), "this is new!")
+          fs.writeFileSync(file.getPath(), "this is new!")
 
         waitsFor "change event", ->
           changeHandler.callCount > 0
@@ -112,12 +112,12 @@ describe 'File', ->
 
         expect(changeHandler).not.toHaveBeenCalled()
 
-        fs.remove(filePath)
+        fs.removeSync(filePath)
 
         expect(changeHandler).not.toHaveBeenCalled()
         waits 20
         runs ->
-          fs.writeSync(filePath, "HE HAS RISEN!")
+          fs.writeFileSync(filePath, "HE HAS RISEN!")
           expect(changeHandler).not.toHaveBeenCalled()
 
         waitsFor "resurrection change event", ->
@@ -125,7 +125,7 @@ describe 'File', ->
 
         runs ->
           expect(removeHandler).not.toHaveBeenCalled()
-          fs.writeSync(filePath, "Hallelujah!")
+          fs.writeFileSync(filePath, "Hallelujah!")
           changeHandler.reset()
 
         waitsFor "post-resurrection change event", ->

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/fs-utils-spec.coffee

@@ -1,140 +0,0 @@
-{fs} = require 'atom'
-path = require 'path'
-temp = require 'temp'
-
-describe "fs", ->
-  fixturesDir = path.join(__dirname, 'fixtures')
-
-  describe ".read(path)", ->
-    it "return contents of file", ->
-      expect(fs.read(require.resolve("./fixtures/sample.txt"))).toBe "Some text.\n"
-
-    it "does not through an exception when the path is a binary file", ->
-      expect(-> fs.read(require.resolve("./fixtures/binary-file.png"))).not.toThrow()
-
-  describe ".isFileSync(path)", ->
-    it "returns true with a file path", ->
-      expect(fs.isFileSync(path.join(fixturesDir,  'sample.js'))).toBe true
-
-    it "returns false with a directory path", ->
-      expect(fs.isFileSync(fixturesDir)).toBe false
-
-    it "returns false with a non-existent path", ->
-      expect(fs.isFileSync(path.join(fixturesDir, 'non-existent'))).toBe false
-      expect(fs.isFileSync(null)).toBe false
-
-  describe ".exists(path)", ->
-    it "returns true when path exsits", ->
-      expect(fs.exists(fixturesDir)).toBe true
-
-    it "returns false when path doesn't exsit", ->
-      expect(fs.exists(path.join(fixturesDir, "-nope-does-not-exist"))).toBe false
-      expect(fs.exists("")).toBe false
-      expect(fs.exists(null)).toBe false
-
-  describe ".makeTree(path)", ->
-    aPath = path.join(temp.dir, 'a')
-
-    beforeEach ->
-      fs.remove(aPath) if fs.exists(aPath)
-
-    it "creates all directories in path including any missing parent directories", ->
-      abcPath = path.join(aPath, 'b', 'c')
-      fs.makeTree(abcPath)
-      expect(fs.exists(abcPath)).toBeTruthy()
-
-  describe ".traverseTreeSync(path, onFile, onDirectory)", ->
-    it "calls fn for every path in the tree at the given path", ->
-      paths = []
-      onPath = (childPath) ->
-        paths.push(childPath)
-        true
-      fs.traverseTreeSync fixturesDir, onPath, onPath
-      expect(paths).toEqual fs.listTreeSync(fixturesDir)
-
-    it "does not recurse into a directory if it is pruned", ->
-      paths = []
-      onPath = (childPath) ->
-        if childPath.match(/\/dir$/)
-          false
-        else
-          paths.push(childPath)
-          true
-      fs.traverseTreeSync fixturesDir, onPath, onPath
-
-      expect(paths.length).toBeGreaterThan 0
-      for filePath in paths
-        expect(filePath).not.toMatch /\/dir\//
-
-    it "returns entries if path is a symlink", ->
-      symlinkPath = path.join(fixturesDir, 'symlink-to-dir')
-      symlinkPaths = []
-      onSymlinkPath = (path) -> symlinkPaths.push(path.substring(symlinkPath.length + 1))
-
-      regularPath = path.join(fixturesDir, 'dir')
-      paths = []
-      onPath = (path) -> paths.push(path.substring(regularPath.length + 1))
-
-      fs.traverseTreeSync(symlinkPath, onSymlinkPath, onSymlinkPath)
-      fs.traverseTreeSync(regularPath, onPath, onPath)
-
-      expect(symlinkPaths).toEqual(paths)
-
-    it "ignores missing symlinks", ->
-      directory = temp.mkdirSync('symlink-in-here')
-      paths = []
-      onPath = (childPath) -> paths.push(childPath)
-      fs.symlinkSync(path.join(directory, 'source'), path.join(directory, 'destination'))
-      fs.traverseTreeSync(directory, onPath)
-      expect(paths.length).toBe 0
-
-  describe ".md5ForPath(path)", ->
-    it "returns the MD5 hash of the file at the given path", ->
-      expect(fs.md5ForPath(require.resolve('./fixtures/sample.js'))).toBe 'dd38087d0d7e3e4802a6d3f9b9745f2b'
-
-  describe ".list(path, extensions)", ->
-    it "returns the absolute paths of entries within the given directory", ->
-      paths = fs.listSync(project.getPath())
-      expect(paths).toContain project.resolve('css.css')
-      expect(paths).toContain project.resolve('coffee.coffee')
-      expect(paths).toContain project.resolve('two-hundred.txt')
-
-    it "returns an empty array for paths that aren't directories or don't exist", ->
-      expect(fs.listSync(project.resolve('sample.js'))).toEqual []
-      expect(fs.listSync('/non/existent/directory')).toEqual []
-
-    it "can filter the paths by an optional array of file extensions", ->
-      paths = fs.listSync(project.getPath(), ['.css', 'coffee'])
-      expect(paths).toContain project.resolve('css.css')
-      expect(paths).toContain project.resolve('coffee.coffee')
-      expect(listedPath).toMatch /(css|coffee)$/ for listedPath in paths
-
-  describe ".list(path, [extensions,] callback)", ->
-    paths = null
-
-    it "calls the callback with the absolute paths of entries within the given directory", ->
-      waitsFor (done) ->
-        fs.list project.getPath(), (err, result) ->
-          paths = result
-          done()
-      runs ->
-        expect(paths).toContain project.resolve('css.css')
-        expect(paths).toContain project.resolve('coffee.coffee')
-        expect(paths).toContain project.resolve('two-hundred.txt')
-
-    it "can filter the paths by an optional array of file extensions", ->
-      waitsFor (done) ->
-        fs.list project.getPath(), ['css', '.coffee'], (err, result) ->
-          paths = result
-          done()
-      runs ->
-        expect(paths).toContain project.resolve('css.css')
-        expect(paths).toContain project.resolve('coffee.coffee')
-        expect(listedPath).toMatch /(css|coffee)$/ for listedPath in paths
-
-  describe ".absolute(relativePath)", ->
-    it "converts a leading ~ segment to the HOME directory", ->
-      homeDir = atom.getHomeDirPath()
-      expect(fs.absolute('~')).toBe fs.realpathSync(homeDir)
-      expect(fs.absolute(path.join('~', 'does', 'not', 'exist'))).toBe path.join(homeDir, 'does', 'not', 'exist')
-      expect(fs.absolute('~test')).toBe '~test'

spec/git-spec.coffee

@@ -9,7 +9,7 @@ describe "Git", ->
 
   beforeEach ->
     gitPath = path.join(temp.dir, '.git')
-    fs.remove(gitPath) if fs.isDirectorySync(gitPath)
+    fs.removeSync(gitPath) if fs.isDirectorySync(gitPath)
 
   afterEach ->
     repo.destroy() if repo?.repo?
@@ -47,22 +47,22 @@ describe "Git", ->
       repo = new Git(path.join(__dirname, 'fixtures', 'git', 'working-dir'))
       filePath = require.resolve('./fixtures/git/working-dir/file.txt')
       newPath = path.join(__dirname, 'fixtures', 'git', 'working-dir', 'new-path.txt')
-      originalPathText = fs.read(filePath)
+      originalPathText = fs.readFileSync(filePath, 'utf8')
 
     afterEach ->
-      fs.writeSync(filePath, originalPathText)
-      fs.remove(newPath) if fs.exists(newPath)
+      fs.writeFileSync(filePath, originalPathText)
+      fs.removeSync(newPath) if fs.existsSync(newPath)
 
     describe "when the path is unstaged", ->
       it "returns false if the path has not been modified", ->
         expect(repo.isPathModified(filePath)).toBeFalsy()
 
       it "returns true if the path is modified", ->
-        fs.writeSync(filePath, "change")
+        fs.writeFileSync(filePath, "change")
         expect(repo.isPathModified(filePath)).toBeTruthy()
 
       it "returns true if the path is deleted", ->
-        fs.remove(filePath)
+        fs.removeSync(filePath)
         expect(repo.isPathModified(filePath)).toBeTruthy()
 
       it "returns false if the path is new", ->
@@ -75,10 +75,10 @@ describe "Git", ->
       repo = new Git(path.join(__dirname, 'fixtures', 'git', 'working-dir'))
       filePath = require.resolve('./fixtures/git/working-dir/file.txt')
       newPath = path.join(__dirname, 'fixtures', 'git', 'working-dir', 'new-path.txt')
-      fs.writeSync(newPath, "i'm new here")
+      fs.writeFileSync(newPath, "i'm new here")
 
     afterEach ->
-      fs.remove(newPath) if fs.exists(newPath)
+      fs.removeSync(newPath) if fs.existsSync(newPath)
 
     describe "when the path is unstaged", ->
       it "returns true if the path is new", ->
@@ -93,35 +93,35 @@ describe "Git", ->
     beforeEach ->
       repo = new Git(path.join(__dirname, 'fixtures', 'git', 'working-dir'))
       path1 = require.resolve('./fixtures/git/working-dir/file.txt')
-      originalPath1Text = fs.read(path1)
+      originalPath1Text = fs.readFileSync(path1, 'utf8')
       path2 = require.resolve('./fixtures/git/working-dir/other.txt')
-      originalPath2Text = fs.read(path2)
+      originalPath2Text = fs.readFileSync(path2, 'utf8')
 
     afterEach ->
-      fs.writeSync(path1, originalPath1Text)
-      fs.writeSync(path2, originalPath2Text)
+      fs.writeFileSync(path1, originalPath1Text)
+      fs.writeFileSync(path2, originalPath2Text)
 
     it "no longer reports a path as modified after checkout", ->
       expect(repo.isPathModified(path1)).toBeFalsy()
-      fs.writeSync(path1, '')
+      fs.writeFileSync(path1, '')
       expect(repo.isPathModified(path1)).toBeTruthy()
       expect(repo.checkoutHead(path1)).toBeTruthy()
       expect(repo.isPathModified(path1)).toBeFalsy()
 
     it "restores the contents of the path to the original text", ->
-      fs.writeSync(path1, '')
+      fs.writeFileSync(path1, '')
       expect(repo.checkoutHead(path1)).toBeTruthy()
-      expect(fs.read(path1)).toBe(originalPath1Text)
+      expect(fs.readFileSync(path1, 'utf8')).toBe(originalPath1Text)
 
     it "only restores the path specified", ->
-      fs.writeSync(path2, 'path 2 is edited')
+      fs.writeFileSync(path2, 'path 2 is edited')
       expect(repo.isPathModified(path2)).toBeTruthy()
       expect(repo.checkoutHead(path1)).toBeTruthy()
-      expect(fs.read(path2)).toBe('path 2 is edited')
+      expect(fs.readFileSync(path2, 'utf8')).toBe('path 2 is edited')
       expect(repo.isPathModified(path2)).toBeTruthy()
 
     it "fires a status-changed event if the checkout completes successfully", ->
-      fs.writeSync(path1, '')
+      fs.writeFileSync(path1, '')
       repo.getPathStatus(path1)
       statusHandler = jasmine.createSpy('statusHandler')
       repo.on 'status-changed', statusHandler
@@ -144,14 +144,14 @@ describe "Git", ->
     beforeEach ->
       repo = new Git(path.join(__dirname, 'fixtures', 'git', 'working-dir'))
       filePath = require.resolve('./fixtures/git/working-dir/file.txt')
-      originalPathText = fs.read(filePath)
+      originalPathText = fs.readFileSync(filePath, 'utf8')
 
     afterEach ->
-      fs.writeSync(filePath, originalPathText)
+      fs.writeFileSync(filePath, originalPathText)
 
     it "returns the number of lines added and deleted", ->
       expect(repo.getDiffStats(filePath)).toEqual {added: 0, deleted: 0}
-      fs.writeSync(filePath, "#{originalPathText} edited line")
+      fs.writeFileSync(filePath, "#{originalPathText} edited line")
       expect(repo.getDiffStats(filePath)).toEqual {added: 1, deleted: 1}
 
   describe ".getPathStatus(path)", ->
@@ -160,20 +160,20 @@ describe "Git", ->
     beforeEach ->
       repo = new Git(path.join(__dirname, 'fixtures', 'git', 'working-dir'))
       filePath = require.resolve('./fixtures/git/working-dir/file.txt')
-      originalPathText = fs.read(filePath)
+      originalPathText = fs.readFileSync(filePath, 'utf8')
 
     afterEach ->
-      fs.writeSync(filePath, originalPathText)
+      fs.writeFileSync(filePath, originalPathText)
 
     it "trigger a status-changed event when the new status differs from the last cached one", ->
       statusHandler = jasmine.createSpy("statusHandler")
       repo.on 'status-changed', statusHandler
-      fs.writeSync(filePath, '')
+      fs.writeFileSync(filePath, '')
       status = repo.getPathStatus(filePath)
       expect(statusHandler.callCount).toBe 1
       expect(statusHandler.argsForCall[0][0..1]).toEqual [filePath, status]
 
-      fs.writeSync(filePath, 'abc')
+      fs.writeFileSync(filePath, 'abc')
       status = repo.getPathStatus(filePath)
       expect(statusHandler.callCount).toBe 1
 
@@ -182,18 +182,18 @@ describe "Git", ->
 
     beforeEach ->
       repo = new Git(path.join(__dirname, 'fixtures', 'git', 'working-dir'))
-      modifiedPath = project.resolve('git/working-dir/file.txt')
-      originalModifiedPathText = fs.read(modifiedPath)
-      newPath = project.resolve('git/working-dir/untracked.txt')
-      cleanPath = project.resolve('git/working-dir/other.txt')
-      fs.writeSync(newPath, '')
+      modifiedPath = atom.project.resolve('git/working-dir/file.txt')
+      originalModifiedPathText = fs.readFileSync(modifiedPath, 'utf8')
+      newPath = atom.project.resolve('git/working-dir/untracked.txt')
+      cleanPath = atom.project.resolve('git/working-dir/other.txt')
+      fs.writeFileSync(newPath, '')
 
     afterEach ->
-      fs.writeSync(modifiedPath, originalModifiedPathText)
-      fs.remove(newPath) if fs.exists(newPath)
+      fs.writeFileSync(modifiedPath, originalModifiedPathText)
+      fs.removeSync(newPath) if fs.existsSync(newPath)
 
     it "returns status information for all new and modified files", ->
-      fs.writeSync(modifiedPath, 'making this path modified')
+      fs.writeFileSync(modifiedPath, 'making this path modified')
       statusHandler = jasmine.createSpy('statusHandler')
       repo.on 'statuses-changed', statusHandler
       repo.refreshStatus()
@@ -207,52 +207,58 @@ describe "Git", ->
         expect(repo.isStatusNew(statuses[newPath])).toBeTruthy()
         expect(repo.isStatusModified(statuses[modifiedPath])).toBeTruthy()
 
-  describe "when a buffer is changed and then saved", ->
-    [originalContent, editSession] = []
+  describe "buffer events", ->
+    [originalContent, editor] = []
+
+    beforeEach ->
+      editor = atom.project.openSync('sample.js')
+      originalContent = editor.getText()
 
     afterEach ->
-      fs.writeSync(editSession.getPath(), originalContent)
+      fs.writeFileSync(editor.getPath(), originalContent)
 
-    it "emits a status-changed event", ->
-      editSession = project.openSync('sample.js')
-      originalContent = editSession.getText()
-      editSession.insertNewline()
+    it "emits a status-changed event when a buffer is saved", ->
+      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
 
-  describe "when a buffer is reloaded and has been changed", ->
-    [originalContent, editSession] = []
-
-    afterEach ->
-      fs.writeSync(editSession.getPath(), originalContent)
-
-    it "emits a status-changed event", ->
-      editSession = project.openSync('sample.js')
-      originalContent = editSession.getText()
-      fs.writeSync(editSession.getPath(), 'changed')
+    it "emits a status-changed event when a buffer is reloaded", ->
+      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(editor.getPath(), 'changed')
+
+      statusHandler = jasmine.createSpy('statusHandler')
+      atom.project.getRepo().on 'status-changed', statusHandler
+      editor.getBuffer().emit 'path-changed'
+      expect(statusHandler.callCount).toBe 1
+      expect(statusHandler).toHaveBeenCalledWith editor.getPath(), 256
+      editor.getBuffer().emit 'path-changed'
       expect(statusHandler.callCount).toBe 1
 
   describe "when a project is deserialized", ->
     [originalContent, buffer, project2] = []
 
     afterEach ->
-      fs.writeSync(buffer.getPath(), originalContent)
+      fs.writeFileSync(buffer.getPath(), originalContent)
       project2?.destroy()
 
     it "subscribes to all the serialized buffers in the project", ->
-      project.openSync('sample.js')
-      project2 = deserialize(project.serialize())
+      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]
 
       waitsFor ->

spec/jasmine-helper.coffee

@@ -3,6 +3,7 @@ module.exports.runSpecSuite = (specSuite, logErrors=true) ->
   window[key] = value for key, value of require '../vendor/jasmine'
 
   require 'jasmine-focused'
+  require 'jasmine-tagged'
 
   TimeReporter = require './time-reporter'
   timeReporter = new TimeReporter()
@@ -27,6 +28,7 @@ module.exports.runSpecSuite = (specSuite, logErrors=true) ->
   jasmineEnv = jasmine.getEnv()
   jasmineEnv.addReporter(reporter)
   jasmineEnv.addReporter(timeReporter)
+  jasmineEnv.setIncludedTags([process.platform])
 
   $('body').append $$ -> @div id: 'jasmine-content'
 

spec/keymap-spec.coffee

@@ -1,12 +1,15 @@
+path = require 'path'
+
 Keymap = require '../src/keymap'
-{$, $$, RootView} = require 'atom'
+{$, $$, WorkspaceView} = require 'atom'
 
 describe "Keymap", ->
   fragment = null
   keymap = null
+  resourcePath = atom.getLoadSettings().resourcePath
 
   beforeEach ->
-    keymap = new Keymap
+    keymap = new Keymap({configDirPath: atom.getConfigDirPath(), resourcePath})
     fragment = $ """
       <div class="command-mode">
         <div class="child-node">
@@ -18,25 +21,19 @@ describe "Keymap", ->
   describe ".handleKeyEvent(event)", ->
     deleteCharHandler = null
     insertCharHandler = null
+    commandZHandler = null
 
     beforeEach ->
-      keymap.bindKeys '.command-mode', 'x': 'deleteChar'
-      keymap.bindKeys '.insert-mode', 'x': 'insertChar'
+      keymap.bindKeys 'name', '.command-mode', 'x': 'deleteChar'
+      keymap.bindKeys 'name', '.insert-mode', 'x': 'insertChar'
+      keymap.bindKeys 'name', '.command-mode', 'cmd-z': 'commandZPressed'
 
       deleteCharHandler = jasmine.createSpy('deleteCharHandler')
       insertCharHandler = jasmine.createSpy('insertCharHandler')
+      commandZHandler = jasmine.createSpy('commandZHandler')
       fragment.on 'deleteChar', deleteCharHandler
       fragment.on 'insertChar', insertCharHandler
-
-    it "adds a 'keystrokes' string to the event object", ->
-      event = keydownEvent('x', altKey: true, metaKey: true)
-      keymap.handleKeyEvent(event)
-      expect(event.keystrokes).toBe 'alt-meta-x'
-
-      event = keydownEvent(',', metaKey: true)
-      event.which = 188
-      keymap.handleKeyEvent(event)
-      expect(event.keystrokes).toBe 'meta-,'
+      fragment.on 'commandZPressed', commandZHandler
 
     describe "when no binding matches the event's keystroke", ->
       it "does not return false so the event continues to propagate", ->
@@ -44,10 +41,11 @@ describe "Keymap", ->
 
     describe "when a non-English keyboard language is used", ->
       it "uses the physical character pressed instead of the character it maps to in the current language", ->
-        event = keydownEvent('U+03B6', metaKey: true) # This is the 'z' key using the Greek keyboard layout
-        event.which = 122
-        keymap.handleKeyEvent(event)
-        expect(event.keystrokes).toBe 'meta-z'
+        event = keydownEvent('U+03B6', metaKey: true, which: 122, target: fragment[0]) # This is the 'z' key using the Greek keyboard layout
+        result = keymap.handleKeyEvent(event)
+
+        expect(result).toBe(false)
+        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", ->
@@ -64,9 +62,6 @@ describe "Keymap", ->
           keymap.handleKeyEvent(event)
           expect(deleteCharHandler).not.toHaveBeenCalled()
           expect(insertCharHandler).toHaveBeenCalled()
-          commandEvent = insertCharHandler.argsForCall[0][0]
-          expect(commandEvent.keyEvent).toBe event
-          expect(event.keystrokes).toBe 'x'
 
       describe "when the event's target node *descends* from a selector with a matching binding", ->
         it "triggers the command event associated with that binding on the target node and returns false", ->
@@ -85,7 +80,7 @@ describe "Keymap", ->
 
       describe "when the event's target node descends from multiple nodes that match selectors with a binding", ->
         beforeEach ->
-          keymap.bindKeys '.child-node', 'x': 'foo'
+          keymap.bindKeys 'name', '.child-node', 'x': 'foo'
 
         it "only triggers bindings on selectors associated with the closest ancestor node", ->
           fooHandler = jasmine.createSpy 'fooHandler'
@@ -122,10 +117,10 @@ describe "Keymap", ->
       describe "when the event bubbles to a node that matches multiple selectors", ->
         describe "when the matching selectors differ in specificity", ->
           it "triggers the binding for the most specific selector", ->
-            keymap.bindKeys 'div .child-node', 'x': 'foo'
-            keymap.bindKeys '.command-mode .child-node !important', 'x': 'baz'
-            keymap.bindKeys '.command-mode .child-node', 'x': 'quux'
-            keymap.bindKeys '.child-node', 'x': 'bar'
+            keymap.bindKeys 'name', 'div .child-node', 'x': 'foo'
+            keymap.bindKeys 'name', '.command-mode .child-node !important', 'x': 'baz'
+            keymap.bindKeys 'name', '.command-mode .child-node', 'x': 'quux'
+            keymap.bindKeys 'name', '.child-node', 'x': 'bar'
 
             fooHandler = jasmine.createSpy 'fooHandler'
             barHandler = jasmine.createSpy 'barHandler'
@@ -143,8 +138,8 @@ describe "Keymap", ->
 
         describe "when the matching selectors have the same specificity", ->
           it "triggers the bindings for the most recently declared selector", ->
-            keymap.bindKeys '.child-node', 'x': 'foo', 'y': 'baz'
-            keymap.bindKeys '.child-node', 'x': 'bar'
+            keymap.bindKeys 'name', '.child-node', 'x': 'foo', 'y': 'baz'
+            keymap.bindKeys 'name', '.child-node', 'x': 'bar'
 
             fooHandler = jasmine.createSpy 'fooHandler'
             barHandler = jasmine.createSpy 'barHandler'
@@ -163,11 +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
-          keymap.bindKeys 'body', 'x': 'foo'
+        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)
@@ -177,7 +173,7 @@ describe "Keymap", ->
 
       describe "when the event matches a 'native!' binding", ->
         it "returns true, allowing the browser's native key handling to process the event", ->
-          keymap.bindKeys '.grandchild-node', 'x': 'native!'
+          keymap.bindKeys 'name', '.grandchild-node', 'x': 'native!'
           nativeHandler = jasmine.createSpy("nativeHandler")
           fragment.on 'native!', nativeHandler
           expect(keymap.handleKeyEvent(keydownEvent('x', target: fragment.find('.grandchild-node')[0]))).toBe true
@@ -187,7 +183,7 @@ describe "Keymap", ->
       [quitHandler, closeOtherWindowsHandler] = []
 
       beforeEach ->
-        keymap.bindKeys "*",
+        keymap.bindKeys 'name', "*",
           'ctrl-x ctrl-c': 'quit'
           'ctrl-x 1': 'close-other-windows'
 
@@ -203,6 +199,7 @@ describe "Keymap", ->
         describe "when a second keystroke added to the first to match a multi-stroke binding completely", ->
           it "triggers the event associated with the matched multi-stroke binding", ->
             expect(keymap.handleKeyEvent(keydownEvent('x', target: fragment[0], ctrlKey: true))).toBeFalsy()
+            expect(keymap.handleKeyEvent(keydownEvent('ctrl', target: fragment[0]))).toBeFalsy() # This simulates actual key event behavior
             expect(keymap.handleKeyEvent(keydownEvent('c', target: fragment[0], ctrlKey: true))).toBeFalsy()
 
             expect(quitHandler).toHaveBeenCalled()
@@ -216,7 +213,7 @@ describe "Keymap", ->
             expect(closeOtherWindowsHandler).toHaveBeenCalled()
 
         describe "when a second keystroke added to the first doesn't match any bindings", ->
-          it "clears the queued keystrokes without triggering any events", ->
+          it "clears the queued keystroke without triggering any events", ->
             expect(keymap.handleKeyEvent(keydownEvent('x', target: fragment[0], ctrlKey: true))).toBe false
             expect(keymap.handleKeyEvent(keydownEvent('c', target: fragment[0]))).toBe false
             expect(quitHandler).not.toHaveBeenCalled()
@@ -226,7 +223,7 @@ describe "Keymap", ->
 
       describe "when the event's target node descends from multiple nodes that match selectors with a partial binding match", ->
         it "allows any of the bindings to be triggered upon a second keystroke, favoring the most specific selector", ->
-          keymap.bindKeys ".grandchild-node", 'ctrl-x ctrl-c': 'more-specific-quit'
+          keymap.bindKeys 'name', ".grandchild-node", 'ctrl-x ctrl-c': 'more-specific-quit'
           grandchildNode = fragment.find('.grandchild-node')[0]
           moreSpecificQuitHandler = jasmine.createSpy('moreSpecificQuitHandler')
           fragment.on 'more-specific-quit', moreSpecificQuitHandler
@@ -250,39 +247,17 @@ describe "Keymap", ->
       describe "when there is a complete binding with a more specific selector", ->
         it "favors the more specific complete match", ->
 
-    describe "when a tab keystroke does not match any bindings", ->
-      it "returns false to prevent the browser from transferring focus", ->
-        expect(keymap.handleKeyEvent(keydownEvent('U+0009', target: fragment[0]))).toBe false
-
-  describe ".keystrokesByCommandForSelector(selector)", ->
-    it "returns a hash of all commands and their keybindings", ->
-      keymap.bindKeys 'body', 'a': 'letter'
-      keymap.bindKeys '.editor', 'b': 'letter'
-      keymap.bindKeys '.editor', '1': 'number'
-      keymap.bindKeys '.editor', 'meta-alt-1': 'number-with-modifiers'
-
-      expect(keymap.keystrokesByCommandForSelector()).toEqual
-        'letter': ['b', 'a']
-        'number': ['1']
-        'number-with-modifiers': ['alt-meta-1']
-
-      expect(keymap.keystrokesByCommandForSelector('.editor')).toEqual
-        'letter': ['b']
-        'number': ['1']
-        'number-with-modifiers': ['alt-meta-1']
-
-
-  describe ".bindKeys(selector, bindings)", ->
+  describe ".bindKeys(name, selector, bindings)", ->
     it "normalizes the key patterns in the hash to put the modifiers in alphabetical order", ->
       fooHandler = jasmine.createSpy('fooHandler')
       fragment.on 'foo', fooHandler
-      keymap.bindKeys '*', 'ctrl-alt-delete': 'foo'
+      keymap.bindKeys 'name', '*', 'ctrl-alt-delete': 'foo'
       result = keymap.handleKeyEvent(keydownEvent('delete', ctrlKey: true, altKey: true, target: fragment[0]))
       expect(result).toBe(false)
       expect(fooHandler).toHaveBeenCalled()
 
       fooHandler.reset()
-      keymap.bindKeys '*', 'ctrl-alt--': 'foo'
+      keymap.bindKeys 'name', '*', 'ctrl-alt--': 'foo'
       result = keymap.handleKeyEvent(keydownEvent('-', ctrlKey: true, altKey: true, target: fragment[0]))
       expect(result).toBe(false)
       expect(fooHandler).toHaveBeenCalled()
@@ -295,15 +270,17 @@ describe "Keymap", ->
         '.brown':
           'ctrl-h': 'harvest'
 
-      expect(keymap.bindingsForElement($$ -> @div class: 'green')).toEqual { 'ctrl-c': 'cultivate' }
-      expect(keymap.bindingsForElement($$ -> @div class: 'brown')).toEqual { 'ctrl-h': 'harvest' }
+      keymap.add 'medical',
+        '.green':
+          'ctrl-v': 'vomit'
+
+      expect(keymap.keyBindingsMatchingElement($$ -> @div class: 'green')).toHaveLength 2
+      expect(keymap.keyBindingsMatchingElement($$ -> @div class: 'brown')).toHaveLength 1
 
       keymap.remove('nature')
 
-      expect(keymap.bindingsForElement($$ -> @div class: 'green')).toEqual {}
-      expect(keymap.bindingsForElement($$ -> @div class: 'brown')).toEqual {}
-      expect(keymap.bindingSetsByFirstKeystroke['ctrl-c']).toEqual []
-      expect(keymap.bindingSetsByFirstKeystroke['ctrl-h']).toEqual []
+      expect(keymap.keyBindingsMatchingElement($$ -> @div class: 'green')).toHaveLength 1
+      expect(keymap.keyBindingsMatchingElement($$ -> @div class: 'brown')).toEqual []
 
   describe ".keystrokeStringForEvent(event)", ->
     describe "when no modifiers are pressed", ->
@@ -314,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", ->
@@ -328,54 +305,45 @@ describe "Keymap", ->
         expect(keymap.keystrokeStringForEvent(keydownEvent('left', shiftKey: true))).toBe 'shift-left'
         expect(keymap.keystrokeStringForEvent(keydownEvent('Left', shiftKey: true))).toBe 'shift-left'
 
-  describe ".bindingsForElement(element)", ->
+  describe ".keyBindingsMatchingElement(element)", ->
     it "returns the matching bindings for the element", ->
-      keymap.bindKeys '.command-mode', 'c': 'c'
-      keymap.bindKeys '.grandchild-node', 'g': 'g'
+      keymap.bindKeys 'name', '.command-mode', 'c': 'c'
+      keymap.bindKeys 'name', '.grandchild-node', 'g': 'g'
 
-      bindings = keymap.bindingsForElement(fragment.find('.grandchild-node'))
-      expect(Object.keys(bindings).length).toBe 2
-      expect(bindings['c']).toEqual "c"
-      expect(bindings['g']).toEqual "g"
+      bindings = keymap.keyBindingsMatchingElement(fragment.find('.grandchild-node'))
+      expect(bindings).toHaveLength 2
+      expect(bindings[0].command).toEqual "g"
+      expect(bindings[1].command).toEqual "c"
 
     describe "when multiple bindings match a keystroke", ->
       it "only returns bindings that match the most specific selector", ->
-        keymap.bindKeys '.command-mode', 'g': 'command-mode'
-        keymap.bindKeys '.command-mode .grandchild-node', 'g': 'command-and-grandchild-node'
-        keymap.bindKeys '.grandchild-node', 'g': '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.bindingsForElement(fragment.find('.grandchild-node'))
-        expect(Object.keys(bindings).length).toBe 1
-        expect(bindings['g']).toEqual "command-and-grandchild-node"
+        bindings = keymap.keyBindingsMatchingElement(fragment.find('.grandchild-node'))
+        expect(bindings).toHaveLength 3
+        expect(bindings[0].command).toEqual "cmd-and-grandchild-node"
 
-  describe ".getAllKeyMappings", ->
-    it "returns the all bindings", ->
-      keymap.bindKeys '~/.atom/packages/dummy/keymaps/a.cson', '.command-mode', 'k': 'c'
+  describe ".keyBindingsForCommandMatchingElement(element)", ->
+    beforeEach ->
+      keymap.add 'nature',
+        '.green':
+          'ctrl-c': 'cultivate'
+        '.green-2':
+          'ctrl-o': 'cultivate'
+        '.brown':
+          'ctrl-h': 'harvest'
+        '.blue':
+          'ctrl-c': 'fly'
 
-      mappings = keymap.getAllKeyMappings()
-      expect(mappings.length).toBe 1
-      expect(mappings[0].source).toEqual 'dummy'
-      expect(mappings[0].keystrokes).toEqual 'k'
-      expect(mappings[0].command).toEqual 'c'
-      expect(mappings[0].selector).toEqual '.command-mode'
+    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"
 
-  describe ".determineSource", ->
-    describe "for a package", ->
-      it "returns '<package-name>'", ->
-        expect(keymap.determineSource('~/.atom/packages/dummy/keymaps/a.cson')).toEqual 'dummy'
-
-    describe "for a linked package", ->
-      it "returns '<package-name>'", ->
-        expect(keymap.determineSource('/Users/john/github/dummy/keymaps/a.cson')).toEqual 'dummy'
-
-    describe "for a user defined keymap", ->
-      it "returns 'User'", ->
-        expect(keymap.determineSource('~/.atom/keymaps/a.cson')).toEqual 'User'
-
-    describe "for a core keymap", ->
-      it "returns 'Core'", ->
-        expect(keymap.determineSource('/Applications/Atom.app/.../node_modules/dummy/keymaps/a.cson')).toEqual 'Core'
-
-    describe "for a linked core keymap", ->
-      it "returns 'Core'", ->
-        expect(keymap.determineSource('/Users/john/github/atom/keymaps/a.cson')).toEqual 'Core'
+    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-replication-spec.coffee

@@ -1,110 +0,0 @@
-path = require 'path'
-temp = require 'temp'
-{Site} = require 'telepath'
-{View} = require 'atom'
-PaneContainer = require '../src/pane-container'
-Pane = require '../src/pane'
-Environment = require './environment'
-
-describe "PaneContainer replication", ->
-  [env1, env2, envConnection, container1, container2, pane1a, pane1b, pane1c] = []
-
-  class TestView extends View
-    @deserialize: ({name}) -> new TestView(name)
-    @content: -> @div tabindex: -1
-    initialize: (@name) -> @text(@name)
-    serialize: -> { deserializer: 'TestView', @name }
-    getState: -> @serialize()
-    getUri: -> path.join(temp.dir, @name)
-    isEqual: (other) -> @name is other.name
-
-  beforeEach ->
-    registerDeserializer(TestView)
-
-    env1 = new Environment(siteId: 1)
-    env2 = env1.clone(siteId: 2)
-    envConnection = env1.connect(env2)
-    doc2 = null
-
-    env1.run ->
-      container1 = new PaneContainer
-      pane1a = new Pane(new TestView('A'))
-      container1.setRoot(pane1a)
-      pane1b = pane1a.splitRight(new TestView('B'))
-      pane1c = pane1b.splitDown(new TestView('C'))
-
-      doc1 = container1.getState()
-      doc2 = doc1.clone(env2.site)
-      envConnection.connect(doc1, doc2)
-
-    env2.run ->
-      container2 = deserialize(doc2)
-
-  afterEach ->
-    env1.destroy()
-    env2.destroy()
-    unregisterDeserializer(TestView)
-
-  it "replicates the inital state of a pane container with splits", ->
-    expect(container1.find('.row > :eq(0):contains(A)')).toExist()
-    expect(container1.find('.row > :eq(1)')).toHaveClass 'column'
-    expect(container1.find('.row > :eq(1) > :eq(0):contains(B)')).toExist()
-    expect(container1.find('.row > :eq(1) > :eq(1):contains(C)')).toExist()
-
-    expect(container2.find('.row > :eq(0):contains(A)')).toExist()
-    expect(container2.find('.row > :eq(1)')).toHaveClass 'column'
-    expect(container2.find('.row > :eq(1) > :eq(0):contains(B)')).toExist()
-    expect(container2.find('.row > :eq(1) > :eq(1):contains(C)')).toExist()
-
-  it "replicates the splitting of panes", ->
-    container1.attachToDom().width(400).height(200)
-    container2.attachToDom().width(400).height(200)
-
-    pane1d = pane1a.splitRight(new TestView('D'))
-
-    expect(container1.find('.row > :eq(1):contains(D)')).toExist()
-    expect(container2.find('.row > :eq(1):contains(D)')).toExist()
-
-    expect(container2.find('.row > :eq(1):contains(D)').outerWidth()).toBe container1.find('.row > :eq(1):contains(D)').outerWidth()
-
-    pane1d.splitDown(new TestView('E'))
-
-    expect(container1.find('.row > :eq(1)')).toHaveClass('column')
-    expect(container1.find('.row > :eq(1) > :eq(0):contains(D)')).toExist()
-    expect(container1.find('.row > :eq(1) > :eq(1):contains(E)')).toExist()
-
-    expect(container2.find('.row > :eq(1)')).toHaveClass('column')
-    expect(container2.find('.row > :eq(1) > :eq(0):contains(D)')).toExist()
-    expect(container2.find('.row > :eq(1) > :eq(1):contains(E)')).toExist()
-
-  it "replicates removal of panes", ->
-    pane1c.remove()
-
-    expect(container1.find('.row > :eq(0):contains(A)')).toExist()
-    expect(container1.find('.row > :eq(1):contains(B)')).toExist()
-    expect(container2.find('.row > :eq(0):contains(A)')).toExist()
-    expect(container2.find('.row > :eq(1):contains(B)')).toExist()
-
-    pane1b.remove()
-
-    expect(container1.find('> :eq(0):contains(A)')).toExist()
-    expect(container2.find('> :eq(0):contains(A)')).toExist()
-
-    pane1a.remove()
-
-    expect(container1.children()).not.toExist()
-    expect(container2.children()).not.toExist()
-
-  # FIXME: We need to get this passing again on master
-  xit "replicates splitting of panes containing edit sessions", ->
-    env1.run ->
-      pane1a.showItem(project.openSync('dir/a'))
-      pane1a.splitDown()
-
-      expect(project.getBuffers().length).toBe 1
-      expect(container1.find('.row > :eq(0) > :eq(0)').view().activeItem.getRelativePath()).toBe 'dir/a'
-      expect(container1.find('.row > :eq(0) > :eq(1)').view().activeItem.getRelativePath()).toBe 'dir/a'
-
-    env2.run ->
-      expect(container2.find('.row > :eq(0) > :eq(0)').view().activeItem.getRelativePath()).toBe 'dir/a'
-      expect(container2.find('.row > :eq(0) > :eq(1)').view().activeItem.getRelativePath()).toBe 'dir/a'

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", ->
@@ -80,11 +80,11 @@ describe "PaneContainer", ->
       expect(panes).toEqual [pane1, pane2, pane3]
 
       panes = []
-      pane4 = pane3.splitRight()
+      pane4 = pane3.splitRight(pane3.copyActiveItem())
       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-replication-spec.coffee

@@ -1,40 +0,0 @@
-PaneContainer = require '../src/pane-container'
-Pane = require '../src/pane'
-{Site} = require 'telepath'
-
-describe "Pane replication", ->
-  [editSession1a, editSession1b, container1, pane1, doc1] = []
-  [editSession2a, editSession2b, container2, pane2, doc2] = []
-
-  beforeEach ->
-    editSession1a = project.openSync('sample.js')
-    editSession1b = project.openSync('sample.txt')
-    container1 = new PaneContainer
-    pane1 = new Pane(editSession1a, editSession1b)
-    container1.setRoot(pane1)
-
-    doc1 = container1.getState()
-    doc2 = doc1.clone(new Site(2))
-    doc1.connect(doc2)
-
-    container2 = deserialize(doc2)
-    pane2 = container2.getRoot()
-
-  it "replicates the initial state of the panes", ->
-    expect(pane2.items).toEqual(pane1.items)
-
-  it "replicates addition and removal of pane items", ->
-    pane1.addItem(project.openSync('css.css'), 1)
-    expect(pane2.items).toEqual(pane1.items)
-    pane1.removeItemAtIndex(2)
-    expect(pane2.items).toEqual(pane1.items)
-
-  it "replicates the movement of pane items", ->
-    pane1.moveItem(editSession1a, 1)
-    expect(pane2.items).toEqual(pane1.items)
-
-  it "replicates which pane item is active", ->
-    pane1.showNextItem()
-    expect(pane2.activeItem).toEqual pane1.activeItem
-    pane1.showNextItem()
-    expect(pane2.activeItem).toEqual pane1.activeItem

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,9 +438,9 @@ describe "Pane", ->
       [paneToLeft, paneToRight] = []
 
       beforeEach ->
-        pane.showItem(editSession1)
-        paneToLeft = pane.splitLeft()
-        paneToRight = pane.splitRight()
+        pane.showItem(editor1)
+        paneToLeft = pane.splitLeft(pane.copyActiveItem())
+        paneToRight = pane.splitRight(pane.copyActiveItem())
         container.attachToDom()
 
       describe "when the removed pane is focused", ->
@@ -475,26 +475,26 @@ 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()
+      pane2 = pane.splitRight(pane.copyActiveItem())
       expect(pane.getNextPane()).toBe pane2
       expect(pane2.getNextPane()).toBe pane
 
@@ -529,7 +529,7 @@ describe "Pane", ->
       expect(pane.isActive()).toBeFalsy()
       pane.focusin()
       expect(pane.isActive()).toBeTruthy()
-      pane.splitRight()
+      pane.splitRight(pane.copyActiveItem())
       expect(pane.isActive()).toBeFalsy()
 
       expect(becameInactiveHandler.callCount).toBe 1
@@ -538,29 +538,41 @@ 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')
 
     describe "splitRight(items...)", ->
       it "builds a row if needed, then appends a new pane after itself", ->
         # creates the new pane with a copy of the active item if none are given
-        pane2 = pane1.splitRight()
+        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]
         expect(container.find('.row .pane').toArray()).toEqual [pane[0], pane2[0], pane3[0]]
 
-    describe "splitRight(items...)", ->
+      it "builds a row if needed, then appends a new pane after itself ", ->
+        # creates the new pane with a copy of the active item if none are given
+        pane2 = pane1.splitRight()
+        expect(container.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0]]
+        expect(pane2.items).toEqual []
+        expect(pane2.activeItem).toBe null
+
+        pane3 = pane2.splitRight()
+        expect(container.find('.row .pane').toArray()).toEqual [pane1[0], pane2[0], pane3[0]]
+        expect(pane3.items).toEqual []
+        expect(pane3.activeItem).toBe null
+
+    describe "splitLeft(items...)", ->
       it "builds a row if needed, then appends a new pane before itself", ->
         # creates the new pane with a copy of the active item if none are given
-        pane2 = pane.splitLeft()
+        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]
@@ -569,10 +581,10 @@ describe "Pane", ->
     describe "splitDown(items...)", ->
       it "builds a column if needed, then appends a new pane after itself", ->
         # creates the new pane with a copy of the active item if none are given
-        pane2 = pane.splitDown()
+        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]
@@ -581,10 +593,10 @@ describe "Pane", ->
     describe "splitUp(items...)", ->
       it "builds a column if needed, then appends a new pane before itself", ->
         # creates the new pane with a copy of the active item if none are given
-        pane2 = pane.splitUp()
+        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]
@@ -661,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')
@@ -681,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 = ->
-        projectState = project.serialize()
         containerState = container.serialize()
         container.remove()
-        project.destroy()
-        window.project = deserialize(projectState)
-        container = deserialize(containerState)
+        container = atom.deserializers.deserialize(containerState)
         pane = container.getRoot()
         container.attachToDom()
 

spec/pasteboard-spec.coffee

@@ -1,10 +1,10 @@
 describe "Pasteboard", ->
   describe "write(text, metadata) and read()", ->
     it "writes and reads text to/from the native pasteboard", ->
-      expect(pasteboard.read()).toEqual ['initial pasteboard content']
-      pasteboard.write('next')
-      expect(pasteboard.read()[0]).toBe 'next'
+      expect(atom.pasteboard.read()).toEqual ['initial pasteboard content']
+      atom.pasteboard.write('next')
+      expect(atom.pasteboard.read()[0]).toBe 'next'
 
     it "returns metadata if the item on the native pasteboard matches the last written item", ->
-      pasteboard.write('next', {meta: 'data'})
-      expect(pasteboard.read()).toEqual ['next', {meta: 'data'}]
+      atom.pasteboard.write('next', {meta: 'data'})
+      expect(atom.pasteboard.read()).toEqual ['next', {meta: 'data'}]

spec/project-replication-spec.coffee

@@ -1,51 +0,0 @@
-path = require 'path'
-{Site} = require 'telepath'
-Project = require '../src/project'
-Git = require '../src/git'
-
-describe "Project replication", ->
-  [doc1, doc2, project1, project2] = []
-
-  beforeEach ->
-    # pretend that home-1/project and home-2/project map to the same git repository url
-    spyOn(Git, 'open').andReturn
-      getOriginUrl: -> 'git://server/project.git'
-      destroy: ->
-
-    projectHome1 = path.join(__dirname, 'fixtures', 'replication', 'home-1')
-    projectHome2 = path.join(__dirname, 'fixtures', 'replication', 'home-2')
-    config.set('core.projectHome', projectHome1)
-    project1 = new Project(path.join(projectHome1, 'project'))
-    project1.bufferForPathSync('file-1.txt')
-    project1.bufferForPathSync('file-1.txt')
-    expect(project1.getBuffers().length).toBe 1
-
-    doc1 = project1.getState()
-    doc2 = doc1.clone(new Site(2))
-    connection = doc1.connect(doc2)
-
-    # pretend we're bootstrapping a joining window
-    config.set('core.projectHome', projectHome2)
-    project2 = deserialize(doc2)
-
-  afterEach ->
-    project1.destroy()
-    project2.destroy()
-
-  it "replicates the initial path and open buffers of the project", ->
-    expect(project2.getPath()).not.toBe project1.getPath()
-    expect(project2.getBuffers().length).toBe 1
-    expect(project2.getBuffers()[0].getRelativePath()).toBe project1.getBuffers()[0].getRelativePath()
-    expect(project2.getBuffers()[0].getPath()).not.toBe project1.getBuffers()[0].getPath()
-
-  it "replicates insertion and removal of open buffers", ->
-    project2.bufferForPathSync('file-2.txt')
-    expect(project1.getBuffers().length).toBe 2
-    expect(project2.getBuffers()[0].getRelativePath()).toBe project1.getBuffers()[0].getRelativePath()
-    expect(project2.getBuffers()[1].getRelativePath()).toBe project1.getBuffers()[1].getRelativePath()
-    expect(project2.getBuffers()[0].getRelativePath()).not.toBe project1.getBuffers()[0].getPath()
-    expect(project2.getBuffers()[1].getRelativePath()).not.toBe project1.getBuffers()[1].getPath()
-
-    project1.removeBuffer(project1.bufferForPathSync('file-2.txt'))
-    expect(project1.getBuffers().length).toBe 1
-    expect(project2.getBuffers()[0].getRelativePath()).toBe project1.getBuffers()[0].getRelativePath()

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,187 +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
-      deserializedProject = deserialize(project.serialize())
+      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 'editor-created' event and stores the edit session", ->
+      handler = jasmine.createSpy('editorCreatedHandler')
+      atom.project.on 'editor-created', handler
+
+      editor1 = atom.project.openSync("a")
+      expect(handler.callCount).toBe 1
+      expect(atom.project.getEditors().length).toBe 1
+      expect(atom.project.getEditors()[0]).toBe editor1
+
+      editor2 = editor1.copy()
+      expect(handler.callCount).toBe 2
+      expect(atom.project.getEditors().length).toBe 2
+      expect(atom.project.getEditors()[0]).toBe editor1
+      expect(atom.project.getEditors()[1]).toBe editor2
 
   describe ".openSync(path)", ->
-    [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 ->
@@ -209,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()
 
@@ -234,63 +263,137 @@ 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 ->
+      atom.project.setPath(atom.project.resolve('../'))
+
+      filePath = atom.project.resolve('sample.js')
+      commentFilePath = atom.project.resolve('sample-with-comments.js')
+      sampleContent = fs.readFileSync(filePath).toString()
+      sampleCommentContent = fs.readFileSync(commentFilePath).toString()
+
+    afterEach ->
+      fs.writeFileSync(filePath, sampleContent)
+      fs.writeFileSync(commentFilePath, sampleCommentContent)
+
+    describe "when called with unopened files", ->
+      it "replaces properly", ->
+        results = []
+        waitsForPromise ->
+          atom.project.replace /items/gi, 'items', [filePath], (result) ->
+            results.push(result)
+
+        runs ->
+          expect(results).toHaveLength 1
+          expect(results[0].filePath).toBe filePath
+          expect(results[0].replacements).toBe 6
+
+    describe "when a buffer is already open", ->
+      it "replaces properly and saves when not modified", ->
+        editor = atom.project.openSync('sample.js')
+        expect(editor.isModified()).toBeFalsy()
+
+        results = []
+        waitsForPromise ->
+          atom.project.replace /items/gi, 'items', [filePath], (result) ->
+            results.push(result)
+
+        runs ->
+          expect(results).toHaveLength 1
+          expect(results[0].filePath).toBe filePath
+          expect(results[0].replacements).toBe 6
+
+          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", ->
+        editor = atom.project.openSync('sample.js')
+        editor.buffer.change([[0,0],[0,0]], 'omg')
+        expect(editor.isModified()).toBeTruthy()
+
+        results = []
+        waitsForPromise ->
+          atom.project.replace /items/gi, 'okthen', [filePath], (result) ->
+            results.push(result)
+
+        runs ->
+          expect(results).toHaveLength 1
+          expect(results[0].filePath).toBe filePath
+          expect(results[0].replacements).toBe 6
+
+          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'
@@ -301,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'
@@ -316,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)
 
@@ -343,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
@@ -365,17 +468,17 @@ describe "Project", ->
           runs ->
             fs.rename(path.join(projectPath, 'git.git'), path.join(projectPath, '.git'))
             ignoredPath = path.join(projectPath, 'ignored.txt')
-            fs.writeSync(ignoredPath, 'this match should not be included')
+            fs.writeFileSync(ignoredPath, 'this match should not be included')
 
         afterEach ->
-          fs.remove(projectPath) if fs.exists(projectPath)
+          fs.removeSync(projectPath) if fs.existsSync(projectPath)
 
         it "excludes ignored files", ->
-          project.setPath(projectPath)
-          config.set('core.excludeVcsIgnoredPaths', true)
+          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 ->
@@ -383,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/'], (result) ->
+          atom.project.scan /aaa/, paths: ["a-dir#{path.sep}"], (result) ->
             paths.push(result.filePath)
             matches = matches.concat(result.matches)
 
@@ -402,12 +505,12 @@ describe "Project", ->
       it "includes files and folders that begin with a '.'", ->
         projectPath = temp.mkdirSync()
         filePath = path.join(projectPath, '.text')
-        fs.writeSync(filePath, 'match this')
-        project.setPath(projectPath)
+        fs.writeFileSync(filePath, 'match this')
+        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)
 
@@ -418,27 +521,56 @@ describe "Project", ->
 
       it "excludes values in core.ignoredNames", ->
         projectPath = path.join(__dirname, 'fixtures', 'git', 'working-dir')
-        ignoredNames = config.get("core.ignoredNames")
+        ignoredNames = atom.config.get("core.ignoredNames")
         ignoredNames.push("a")
-        config.set("core.ignoredNames", ignoredNames)
+        atom.config.set("core.ignoredNames", ignoredNames)
 
         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,480 +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()
-      projectState = project.serialize()
-      rootView.remove()
-      project.destroy()
-      window.project = deserialize(projectState)
-      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)
-
-      window.keymap.bindKeys('*', '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 = config.get('editor.fontSize')
-      rootView.trigger 'window:increase-font-size'
-      expect(config.get('editor.fontSize')).toBe fontSizeBefore + 1
-      rootView.trigger 'window:increase-font-size'
-      expect(config.get('editor.fontSize')).toBe fontSizeBefore + 2
-      rootView.trigger 'window:decrease-font-size'
-      expect(config.get('editor.fontSize')).toBe fontSizeBefore + 1
-      rootView.trigger 'window:decrease-font-size'
-      expect(config.get('editor.fontSize')).toBe fontSizeBefore
-
-    it "does not allow the font size to be less than 1", ->
-      config.set("editor.fontSize", 1)
-      rootView.trigger 'window:decrease-font-size'
-      expect(config.get('editor.fontSize')).toBe 1
-
-  describe ".open(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 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 ".openAsync(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.buildBufferSync('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
@@ -23,21 +23,21 @@ describe "SpacePen extensions", ->
       expect(observeHandler).toHaveBeenCalledWith(undefined)
       observeHandler.reset()
 
-      config.set("foo.bar", "hello")
+      atom.config.set("foo.bar", "hello")
 
       expect(observeHandler).toHaveBeenCalledWith("hello", previous: undefined)
       observeHandler.reset()
 
       view.unobserveConfig()
 
-      config.set("foo.bar", "goodbye")
+      atom.config.set("foo.bar", "goodbye")
 
       expect(observeHandler).not.toHaveBeenCalled()
 
     it "unobserves when the view is removed", ->
       observeHandler.reset()
       parent.remove()
-      config.set("foo.bar", "hello")
+      atom.config.set("foo.bar", "hello")
       expect(observeHandler).not.toHaveBeenCalled()
 
   describe "View.subscribe(eventEmitter, eventName, callback)", ->
@@ -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-platform.coffee

@@ -1,5 +1,5 @@
 path = require 'path'
-fsUtils = require '../src/fs-utils'
+fs = require 'fs-plus'
 
 {_} = require 'atom'
 
@@ -15,8 +15,8 @@ module.exports =
   # Returns nothing.
   generateEvilFiles: ->
     evilFilesPath = path.join(__dirname, 'fixtures', 'evil-files')
-    fsUtils.remove(evilFilesPath) if fsUtils.exists(evilFilesPath)
-    fsUtils.mkdirSync(evilFilesPath)
+    fs.removeSync(evilFilesPath) if fs.existsSync(evilFilesPath)
+    fs.mkdirSync(evilFilesPath)
 
     if (@isWindows())
       filenames = [
@@ -34,5 +34,4 @@ module.exports =
       ]
 
     for filename in filenames
-      fd = fsUtils.writeFileSync(path.join(evilFilesPath, filename), 'evil file!', flag: 'w')
-
+      fd = fs.writeFileSync(path.join(evilFilesPath, filename), 'evil file!', flag: 'w')

spec/spec-helper.coffee

@@ -1,15 +1,15 @@
 require '../src/window'
-window.setUpEnvironment('spec')
-window.restoreDimensions()
+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'
@@ -23,7 +23,7 @@ atom.themes.requireStylesheet '../static/jasmine'
 fixturePackagesPath = path.resolve(__dirname, './fixtures/packages')
 atom.packages.packageDirPaths.unshift(fixturePackagesPath)
 atom.keymap.loadBundledKeymaps()
-[bindingSetsToRestore, bindingSetsByFirstKeystrokeToRestore] = []
+keyBindingsToRestore = atom.keymap.getKeyBindings()
 
 $(window).on 'core:close', -> window.close()
 $(window).on 'unload', ->
@@ -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
@@ -47,40 +49,35 @@ if specDirectory = atom.getLoadSettings().specDirectory
 
 beforeEach ->
   $.fx.off = true
-  if specProjectPath
-    atom.project = new Project(specProjectPath)
-  else
-    atom.project = new Project(path.join(@specDirectory, 'fixtures'))
-  window.project = atom.project
+  projectPath = specProjectPath ? path.join(@specDirectory, 'fixtures')
+  atom.project = atom.getWindowState().set('project', new Project(path: projectPath))
+  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()
 
-  if specPackageName
-    spy = spyOn(atom.packages, 'resolvePackagePath').andCallFake (packageName) ->
-      if packageName is specPackageName
-        resolvePackagePath(specPackagePath)
-      else
-        resolvePackagePath(packageName)
-    resolvePackagePath = _.bind(spy.originalValue, atom.packages)
-
-  # used to reset keymap after each spec
-  bindingSetsToRestore = _.clone(keymap.bindingSets)
-  bindingSetsByFirstKeystrokeToRestore = _.clone(keymap.bindingSetsByFirstKeystroke)
+  spy = spyOn(atom.packages, 'resolvePackagePath').andCallFake (packageName) ->
+    if specPackageName and packageName is specPackageName
+      resolvePackagePath(specPackagePath)
+    else
+      resolvePackagePath(packageName)
+  resolvePackagePath = _.bind(spy.originalValue, atom.packages)
 
   # prevent specs from modifying Atom's menus
   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.packageDirPaths.unshift(fixturePackagesPath)
+  config = new Config({resourcePath, configDirPath: atom.getConfigDirPath()})
   spyOn(config, 'load')
   spyOn(config, 'save')
+  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
@@ -88,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()
@@ -108,26 +104,20 @@ beforeEach ->
   addCustomMatchers(this)
 
 afterEach ->
-  keymap.bindingSets = bindingSetsToRestore
-  keymap.bindingSetsByFirstKeystroke = bindingSetsByFirstKeystrokeToRestore
-  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
   delete atom.windowState
   jasmine.unspy(atom, 'saveWindowState')
   ensureNoPathSubscriptions()
-  syntax.off()
+  atom.syntax.off()
   waits(0) # yield to ui thread to make screen update more frequently
 
 ensureNoPathSubscriptions = ->
@@ -166,7 +156,7 @@ addCustomMatchers = (spec) ->
     toExistOnDisk: (expected) ->
       notText = this.isNot and " not" or ""
       @message = -> return "Expected path '" + @actual + "'" + notText + " to exist."
-      fs.exists(@actual)
+      fs.existsSync(@actual)
 
 window.keyIdentifierForKey = (key) ->
   if key.length > 1 # named key
@@ -181,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}
@@ -243,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)
@@ -266,7 +256,7 @@ $.fn.resultOfTrigger = (type) ->
   event.result
 
 $.fn.enableKeymap = ->
-  @on 'keydown', (e) => window.keymap.handleKeyEvent(e)
+  @on 'keydown', (e) => atom.keymap.handleKeyEvent(e)
 
 $.fn.attachToDom = ->
   @appendTo($('#jasmine-content'))
@@ -280,6 +270,3 @@ $.fn.textInput = (data) ->
     event.initTextEvent('textInput', true, true, window, data)
     event = $.event.fix(event)
     $(this).trigger(event)
-
-unless fs.md5ForPath(require.resolve('./fixtures/sample.js')) == "dd38087d0d7e3e4802a6d3f9b9745f2b"
-  throw new Error("Sample.js is modified")

spec/spec-suite.coffee

@@ -1,54 +1,55 @@
-measure 'spec suite require time', ->
-  {_, fs, Git} = require 'atom'
-  path = require 'path'
-  require './spec-helper'
+{_, fs, Git} = require 'atom'
+path = require 'path'
+require './spec-helper'
 
-  requireSpecs = (specDirectory, specType) ->
-    for specFilePath in fs.listTreeSync(specDirectory) when /-spec\.coffee$/.test specFilePath
-      require specFilePath
+requireSpecs = (specDirectory, specType) ->
+  for specFilePath in fs.listTreeSync(specDirectory) when /-spec\.coffee$/.test specFilePath
+    require specFilePath
 
-      # Set spec directory on spec for setting up the project in spec-helper
-      setSpecDirectory(specDirectory)
+    # Set spec directory on spec for setting up the project in spec-helper
+    setSpecDirectory(specDirectory)
 
-  setSpecField = (name, value) ->
-    specs = jasmine.getEnv().currentRunner().specs()
-    return if specs.length is 0
-    for index in [specs.length-1..0]
-      break if specs[index][name]?
-      specs[index][name] = value
+setSpecField = (name, value) ->
+  specs = jasmine.getEnv().currentRunner().specs()
+  return if specs.length is 0
+  for index in [specs.length-1..0]
+    break if specs[index][name]?
+    specs[index][name] = value
 
-  setSpecType = (specType) ->
-    setSpecField('specType', specType)
+setSpecType = (specType) ->
+  setSpecField('specType', specType)
 
-  setSpecDirectory = (specDirectory) ->
-    setSpecField('specDirectory', specDirectory)
+setSpecDirectory = (specDirectory) ->
+  setSpecField('specDirectory', specDirectory)
 
-  runAllSpecs = ->
-    # Only run core specs when resource path is the Atom repository
-    if Git.exists(window.resourcePath)
-      requireSpecs(path.join(window.resourcePath, 'spec'))
-      setSpecType('core')
+runAllSpecs = ->
+  {resourcePath} = atom.getLoadSettings()
+  # Only run core specs when resource path is the Atom repository
+  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 = _.groupBy packagePaths, (packagePath) ->
-      if packagePath.indexOf("#{fixturesPackagesPath}#{path.sep}") is 0
-        'fixtures'
-      else if packagePath.indexOf("#{window.resourcePath}#{path.sep}") is 0
-        'bundled'
-      else
-        'user'
+  fixturesPackagesPath = path.join(__dirname, 'fixtures', 'packages')
+  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("#{resourcePath}#{path.sep}") is 0
+      'bundled'
+    else
+      'user'
 
-    # Run bundled package specs
-    requireSpecs(path.join(packagePath, 'spec')) for packagePath in packagePaths.bundled ? []
-    setSpecType('bundled')
+  # Run bundled package specs
+  requireSpecs(path.join(packagePath, 'spec')) for packagePath in packagePaths.bundled ? []
+  setSpecType('bundled')
 
-    # Run user package specs
-    requireSpecs(path.join(packagePath, 'spec')) for packagePath in packagePaths.user ? []
-    setSpecType('user')
+  # Run user package specs
+  requireSpecs(path.join(packagePath, 'spec')) for packagePath in packagePaths.user ? []
+  setSpecType('user')
 
-  if specDirectory = atom.getLoadSettings().specDirectory
-    requireSpecs(specDirectory)
-    setSpecType('user')
-  else
-    runAllSpecs()
+if specDirectory = atom.getLoadSettings().specDirectory
+  requireSpecs(specDirectory)
+  setSpecType('user')
+else
+  runAllSpecs()

spec/syntax-spec.coffee

@@ -5,60 +5,60 @@ 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(syntax.selectGrammar(filePath).name).not.toBe 'Ruby'
-      syntax.setGrammarOverrideForPath(filePath, 'source.ruby')
-      syntax2 = deserialize(syntax.serialize())
-      syntax2.addGrammar(grammar) for grammar in syntax.grammars when grammar isnt syntax.nullGrammar
+      expect(atom.syntax.selectGrammar(filePath).name).not.toBe 'Ruby'
+      atom.syntax.setGrammarOverrideForPath(filePath, 'source.ruby')
+      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(syntax.selectGrammar("file.js").name).toBe "JavaScript" # based on extension (.js)
-      expect(syntax.selectGrammar(path.join(temp.dir, '.git', 'config')).name).toBe "Git Config" # based on end of the path (.git/config)
-      expect(syntax.selectGrammar("Rakefile").name).toBe "Ruby" # based on the file's basename (Rakefile)
-      expect(syntax.selectGrammar("curb").name).toBe "Null Grammar"
-      expect(syntax.selectGrammar("/hu.git/config").name).toBe "Null Grammar"
+      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)
+      expect(atom.syntax.selectGrammar("Rakefile").name).toBe "Ruby" # based on the file's basename (Rakefile)
+      expect(atom.syntax.selectGrammar("curb").name).toBe "Null Grammar"
+      expect(atom.syntax.selectGrammar("/hu.git/config").name).toBe "Null Grammar"
 
     it "uses the filePath's shebang line if the grammar cannot be determined by the extension or basename", ->
       filePath = require.resolve("./fixtures/shebang")
-      expect(syntax.selectGrammar(filePath).name).toBe "Ruby"
+      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(syntax.selectGrammar("dummy.coffee", fileContent).name).toBe "CoffeeScript"
+      expect(atom.syntax.selectGrammar("dummy.coffee", fileContent).name).toBe "CoffeeScript"
 
       fileContent = '<?xml version="1.0" encoding="UTF-8"?>'
-      expect(syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Null Grammar"
+      expect(atom.syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Null Grammar"
 
       fileContent += '\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
-      expect(syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Property List (XML)"
+      expect(atom.syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Property List (XML)"
 
     it "doesn't read the file when the file contents are specified", ->
       filePath = require.resolve("./fixtures/shebang")
-      filePathContents = fs.read(filePath)
+      filePathContents = fs.readFileSync(filePath, 'utf8')
       spyOn(fs, 'read').andCallThrough()
-      expect(syntax.selectGrammar(filePath, filePathContents).name).toBe "Ruby"
+      expect(atom.syntax.selectGrammar(filePath, filePathContents).name).toBe "Ruby"
       expect(fs.read).not.toHaveBeenCalled()
 
     it "allows the default grammar to be overridden for a path", ->
       filePath = '/foo/bar/file.js'
-      expect(syntax.selectGrammar(filePath).name).not.toBe 'Ruby'
-      syntax.setGrammarOverrideForPath(filePath, 'source.ruby')
-      expect(syntax.selectGrammar(filePath).name).toBe 'Ruby'
-      syntax.clearGrammarOverrideForPath(filePath)
-      expect(syntax.selectGrammar(filePath).name).not.toBe 'Ruby'
+      expect(atom.syntax.selectGrammar(filePath).name).not.toBe 'Ruby'
+      atom.syntax.setGrammarOverrideForPath(filePath, 'source.ruby')
+      expect(atom.syntax.selectGrammar(filePath).name).toBe 'Ruby'
+      atom.syntax.clearGrammarOverrideForPath(filePath)
+      expect(atom.syntax.selectGrammar(filePath).name).not.toBe 'Ruby'
 
     describe "when multiple grammars have matching fileTypes", ->
       it "selects the grammar with the longest fileType match", ->
@@ -72,46 +72,46 @@ describe "the `syntax` global", ->
           scopeName: 'source2'
           fileTypes: ['test']
 
-        syntax.addGrammar(grammar1)
-        syntax.addGrammar(grammar2)
+        atom.syntax.addGrammar(grammar1)
+        atom.syntax.addGrammar(grammar2)
 
-        expect(syntax.selectGrammar('more.test', '')).toBe grammar1
+        expect(atom.syntax.selectGrammar('more.test', '')).toBe grammar1
 
     describe "when there is no file path", ->
       it "does not throw an exception (regression)", ->
-        expect(-> syntax.selectGrammar(null, '#!/usr/bin/ruby')).not.toThrow()
-        expect(-> syntax.selectGrammar(null, '')).not.toThrow()
-        expect(-> syntax.selectGrammar(null, null)).not.toThrow()
+        expect(-> atom.syntax.selectGrammar(null, '#!/usr/bin/ruby')).not.toThrow()
+        expect(-> atom.syntax.selectGrammar(null, '')).not.toThrow()
+        expect(-> atom.syntax.selectGrammar(null, null)).not.toThrow()
 
   describe ".removeGrammar(grammar)", ->
     it "removes the grammar, so it won't be returned by selectGrammar", ->
-      grammar = syntax.selectGrammar('foo.js')
-      syntax.removeGrammar(grammar)
-      expect(syntax.selectGrammar('foo.js').name).not.toBe grammar.name
+      grammar = atom.syntax.selectGrammar('foo.js')
+      atom.syntax.removeGrammar(grammar)
+      expect(atom.syntax.selectGrammar('foo.js').name).not.toBe grammar.name
 
   describe ".getProperty(scopeDescriptor)", ->
     it "returns the property with the most specific scope selector", ->
-      syntax.addProperties(".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
-      syntax.addProperties(".source .string.quoted.double", foo: bar: baz: 22)
-      syntax.addProperties(".source", foo: bar: baz: 11)
+      atom.syntax.addProperties(".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
+      atom.syntax.addProperties(".source .string.quoted.double", foo: bar: baz: 22)
+      atom.syntax.addProperties(".source", foo: bar: baz: 11)
 
-      expect(syntax.getProperty([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42
-      expect(syntax.getProperty([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBe 22
-      expect(syntax.getProperty([".source.js", ".variable.assignment.js"], "foo.bar.baz")).toBe 11
-      expect(syntax.getProperty([".text"], "foo.bar.baz")).toBeUndefined()
+      expect(atom.syntax.getProperty([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42
+      expect(atom.syntax.getProperty([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBe 22
+      expect(atom.syntax.getProperty([".source.js", ".variable.assignment.js"], "foo.bar.baz")).toBe 11
+      expect(atom.syntax.getProperty([".text"], "foo.bar.baz")).toBeUndefined()
 
     it "favors the most recently added properties in the event of a specificity tie", ->
-      syntax.addProperties(".source.coffee .string.quoted.single", foo: bar: baz: 42)
-      syntax.addProperties(".source.coffee .string.quoted.double", foo: bar: baz: 22)
+      atom.syntax.addProperties(".source.coffee .string.quoted.single", foo: bar: baz: 42)
+      atom.syntax.addProperties(".source.coffee .string.quoted.double", foo: bar: baz: 22)
 
-      expect(syntax.getProperty([".source.coffee", ".string.quoted.single"], "foo.bar.baz")).toBe 42
-      expect(syntax.getProperty([".source.coffee", ".string.quoted.single.double"], "foo.bar.baz")).toBe 22
+      expect(atom.syntax.getProperty([".source.coffee", ".string.quoted.single"], "foo.bar.baz")).toBe 42
+      expect(atom.syntax.getProperty([".source.coffee", ".string.quoted.single.double"], "foo.bar.baz")).toBe 22
 
   describe ".removeProperties(name)", ->
     it "allows properties to be removed by name", ->
-      syntax.addProperties("a", ".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
-      syntax.addProperties("b", ".source .string.quoted.double", foo: bar: baz: 22)
+      atom.syntax.addProperties("a", ".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
+      atom.syntax.addProperties("b", ".source .string.quoted.double", foo: bar: baz: 22)
 
-      syntax.removeProperties("b")
-      expect(syntax.getProperty([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBeUndefined()
-      expect(syntax.getProperty([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42
+      atom.syntax.removeProperties("b")
+      expect(atom.syntax.getProperty([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBeUndefined()
+      expect(atom.syntax.getProperty([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42

spec/text-buffer-replication-spec.coffee

@@ -1,46 +0,0 @@
-{Site} = require 'telepath'
-
-describe "TextBuffer replication", ->
-  [buffer1, buffer2] = []
-
-  beforeEach ->
-    buffer1 = project.buildBufferSync('sample.js')
-    doc1 = buffer1.getState()
-    doc2 = doc1.clone(new Site(2))
-    doc1.connect(doc2)
-    buffer2 = deserialize(doc2, {project})
-
-    waitsFor ->
-      buffer1.loaded and buffer2.loaded
-
-    runs ->
-      buffer1.insert([0, 0], 'changed\n')
-
-  afterEach ->
-    buffer1.destroy()
-    buffer2.destroy()
-
-  it "replicates the initial path and text", ->
-    expect(buffer2.getPath()).toBe buffer1.getPath()
-    expect(buffer2.getText()).toBe buffer1.getText()
-
-  it "replicates changes to the text and emits 'change' events on all replicas", ->
-    buffer1.on 'changed', handler1 = jasmine.createSpy("buffer1 change handler")
-    buffer2.on 'changed', handler2 = jasmine.createSpy("buffer2 change handler")
-
-    buffer1.change([[1, 4], [1, 6]], 'h')
-    expect(buffer1.lineForRow(1)).toBe 'var hicksort = function () {'
-    expect(buffer2.lineForRow(1)).toBe 'var hicksort = function () {'
-
-    expect(buffer1.isModified()).toBeTruthy()
-    expect(buffer2.isModified()).toBeTruthy()
-
-    expectedEvent =
-      oldRange: [[1, 4], [1, 6]]
-      oldText: "qu"
-      newRange: [[1, 4], [1, 5]]
-      newText: "h"
-    expect(handler1).toHaveBeenCalledWith(expectedEvent)
-    expect(handler2).toHaveBeenCalledWith(expectedEvent)
-    expect(handler1.callCount).toBe 1
-    expect(handler2.callCount).toBe 1

spec/text-buffer-spec.coffee

@@ -9,41 +9,41 @@ describe 'TextBuffer', ->
 
   beforeEach ->
     filePath = require.resolve('./fixtures/sample.js')
-    fileContents = fs.read(filePath)
-    buffer = project.bufferForPathSync(filePath)
+    fileContents = fs.readFileSync(filePath, 'utf8')
+    buffer = atom.project.bufferForPathSync(filePath)
 
   afterEach ->
-    buffer?.release()
+    buffer?.destroy()
 
   describe 'constructor', ->
     beforeEach ->
-      buffer.release()
+      buffer.destroy()
       buffer = null
 
     describe "when given a path", ->
       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)
-          expect(buffer.getText()).toBe fs.read(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.read(filePath)
+          expect(buffer.getText()).toBe fs.readFileSync(filePath, 'utf8')
 
       describe "when no file exists for the path", ->
         it "is modified and is initially empty", ->
           filePath = "does-not-exist.txt"
-          expect(fs.exists(filePath)).toBeFalsy()
-          buffer = project.bufferForPathSync(filePath)
+          expect(fs.existsSync(filePath)).toBeFalsy()
+          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", ->
@@ -52,15 +52,15 @@ describe 'TextBuffer', ->
     beforeEach ->
       filePath = path.join(__dirname, "fixtures", "atom-manipulate-me")
       newPath = "#{filePath}-i-moved"
-      fs.writeSync(filePath, "")
-      bufferToChange = project.bufferForPathSync(filePath)
+      fs.writeFileSync(filePath, "")
+      bufferToChange = atom.project.bufferForPathSync(filePath)
       eventHandler = jasmine.createSpy('eventHandler')
       bufferToChange.on 'path-changed', eventHandler
 
     afterEach ->
       bufferToChange.destroy()
-      fs.remove(filePath) if fs.exists(filePath)
-      fs.remove(newPath) if fs.exists(newPath)
+      fs.removeSync(filePath) if fs.existsSync(filePath)
+      fs.removeSync(newPath) if fs.existsSync(newPath)
 
     it "triggers a `path-changed` event when path is changed", ->
       bufferToChange.saveAs(newPath)
@@ -69,8 +69,8 @@ describe 'TextBuffer', ->
     it "triggers a `path-changed` event when the file is moved", ->
       jasmine.unspy(window, "setTimeout")
 
-      fs.remove(newPath) if fs.exists(newPath)
-      fs.move(filePath, newPath)
+      fs.removeSync(newPath) if fs.existsSync(newPath)
+      fs.moveSync(filePath, newPath)
 
       waitsFor "buffer path change", ->
         eventHandler.callCount > 0
@@ -84,8 +84,8 @@ describe 'TextBuffer', ->
     beforeEach ->
       buffer.release()
       filePath = temp.openSync('atom').path
-      fs.writeSync(filePath, "first")
-      buffer = project.bufferForPathSync(filePath).retain()
+      fs.writeFileSync(filePath, "first")
+      buffer = atom.project.bufferForPathSync(filePath).retain()
 
     afterEach ->
       buffer.release()
@@ -105,7 +105,7 @@ describe 'TextBuffer', ->
       it "changes the memory contents of the buffer to match the new disk contents and triggers a 'changed' event", ->
         changeHandler = jasmine.createSpy('changeHandler')
         buffer.on 'changed', changeHandler
-        fs.writeSync(filePath, "second")
+        fs.writeFileSync(filePath, "second")
 
         expect(changeHandler.callCount).toBe 0
         waitsFor "file to trigger change event", ->
@@ -125,7 +125,7 @@ describe 'TextBuffer', ->
         buffer.file.on 'contents-changed', fileChangeHandler
 
         buffer.insert([0, 0], "a change")
-        fs.writeSync(filePath, "second")
+        fs.writeFileSync(filePath, "second")
 
         expect(fileChangeHandler.callCount).toBe 0
         waitsFor "file to trigger 'contents-changed' event", ->
@@ -140,7 +140,7 @@ describe 'TextBuffer', ->
         buffer.insert([0, 0], "a second change")
 
         handler = jasmine.createSpy('fileChange')
-        fs.writeSync(filePath, "a disk change")
+        fs.writeFileSync(filePath, "a disk change")
         buffer.on 'contents-conflicted', handler
 
         expect(handler.callCount).toBe 0
@@ -155,8 +155,8 @@ describe 'TextBuffer', ->
 
     beforeEach ->
       filePath = path.join(temp.dir, 'atom-file-to-delete.txt')
-      fs.writeSync(filePath, 'delete me')
-      bufferToDelete = project.bufferForPathSync(filePath)
+      fs.writeFileSync(filePath, 'delete me')
+      bufferToDelete = atom.project.bufferForPathSync(filePath)
       filePath = bufferToDelete.getPath() # symlinks may have been converted
 
       expect(bufferToDelete.getPath()).toBe filePath
@@ -164,7 +164,7 @@ describe 'TextBuffer', ->
 
       removeHandler = jasmine.createSpy('removeHandler')
       bufferToDelete.file.on 'removed', removeHandler
-      fs.remove(filePath)
+      fs.removeSync(filePath)
       waitsFor "file to be removed", ->
         removeHandler.callCount > 0
 
@@ -177,10 +177,10 @@ describe 'TextBuffer', ->
 
     it "resumes watching of the file when it is re-saved", ->
       bufferToDelete.save()
-      expect(fs.exists(bufferToDelete.getPath())).toBeTruthy()
+      expect(fs.existsSync(bufferToDelete.getPath())).toBeTruthy()
       expect(bufferToDelete.isInConflict()).toBeFalsy()
 
-      fs.writeSync(filePath, 'moo')
+      fs.writeFileSync(filePath, 'moo')
 
       changeHandler = jasmine.createSpy('changeHandler')
       bufferToDelete.on 'changed', changeHandler
@@ -213,21 +213,21 @@ describe 'TextBuffer', ->
     it "reports the modified status changing to true after the underlying file is deleted", ->
       buffer.release()
       filePath = path.join(temp.dir, 'atom-tmp-file')
-      fs.writeSync(filePath, 'delete me')
-      buffer = project.bufferForPathSync(filePath)
+      fs.writeFileSync(filePath, 'delete me')
+      buffer = atom.project.bufferForPathSync(filePath)
       modifiedHandler = jasmine.createSpy("modifiedHandler")
       buffer.on 'modified-status-changed', modifiedHandler
 
-      fs.remove(filePath)
+      fs.removeSync(filePath)
 
       waitsFor "modified status to change", -> modifiedHandler.callCount
       runs -> expect(buffer.isModified()).toBe true
 
     it "reports the modified status changing to false after a modified buffer is saved", ->
       filePath = path.join(temp.dir, 'atom-tmp-file')
-      fs.writeSync(filePath, '')
+      fs.writeFileSync(filePath, '')
       buffer.release()
-      buffer = project.bufferForPathSync(filePath)
+      buffer = atom.project.bufferForPathSync(filePath)
       modifiedHandler = jasmine.createSpy("modifiedHandler")
       buffer.on 'modified-status-changed', modifiedHandler
 
@@ -249,9 +249,9 @@ describe 'TextBuffer', ->
 
     it "reports the modified status changing to false after a modified buffer is reloaded", ->
       filePath = path.join(temp.dir, 'atom-tmp-file')
-      fs.writeSync(filePath, '')
+      fs.writeFileSync(filePath, '')
       buffer.release()
-      buffer = project.bufferForPathSync(filePath)
+      buffer = atom.project.bufferForPathSync(filePath)
       modifiedHandler = jasmine.createSpy("modifiedHandler")
       buffer.on 'modified-status-changed', modifiedHandler
 
@@ -272,10 +272,10 @@ describe 'TextBuffer', ->
 
     it "reports the modified status changing to false after a buffer to a non-existent file is saved", ->
       filePath = path.join(temp.dir, 'atom-tmp-file')
-      fs.remove(filePath) if fs.exists(filePath)
-      expect(fs.exists(filePath)).toBeFalsy()
+      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
 
@@ -285,7 +285,7 @@ describe 'TextBuffer', ->
       modifiedHandler.reset()
 
       buffer.save()
-      expect(fs.exists(filePath)).toBeTruthy()
+      expect(fs.existsSync(filePath)).toBeTruthy()
 
       expect(modifiedHandler).toHaveBeenCalledWith(false)
       expect(buffer.isModified()).toBe false
@@ -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')
@@ -311,8 +311,8 @@ describe 'TextBuffer', ->
 
     it "returns false until the buffer is fully loaded", ->
       buffer.release()
-      filePath = temp.openSync('atom').path
-      buffer = new TextBuffer({project, filePath})
+      buffer = new TextBuffer({filePath: temp.openSync('atom').path})
+      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 () {"
 
@@ -465,16 +465,16 @@ describe 'TextBuffer', ->
 
       beforeEach ->
         filePath = path.join(temp.dir, 'temp.txt')
-        fs.writeSync(filePath, "")
-        saveBuffer = project.bufferForPathSync(filePath)
+        fs.writeFileSync(filePath, "")
+        saveBuffer = atom.project.bufferForPathSync(filePath)
         saveBuffer.setText("blah")
 
       it "saves the contents of the buffer to the path", ->
         saveBuffer.setText 'Buffer contents!'
         saveBuffer.save()
-        expect(fs.read(filePath)).toEqual 'Buffer contents!'
+        expect(fs.readFileSync(filePath, 'utf8')).toEqual 'Buffer contents!'
 
-      it "fires will-be-saved and saved events around the call to fs.writeSync", ->
+      it "fires will-be-saved and saved events around the call to fs.writeFileSync", ->
         events = []
         beforeSave1 = -> events.push('beforeSave1')
         beforeSave2 = -> events.push('beforeSave2')
@@ -483,12 +483,12 @@ describe 'TextBuffer', ->
 
         saveBuffer.on 'will-be-saved', beforeSave1
         saveBuffer.on 'will-be-saved', beforeSave2
-        spyOn(fs, 'writeSync').andCallFake -> events.push 'fs.writeSync'
+        spyOn(fs, 'writeFileSync').andCallFake -> events.push 'fs.writeFileSync'
         saveBuffer.on 'saved', afterSave1
         saveBuffer.on 'saved', afterSave2
 
         saveBuffer.save()
-        expect(events).toEqual ['beforeSave1', 'beforeSave2', 'fs.writeSync', 'afterSave1', 'afterSave2']
+        expect(events).toEqual ['beforeSave1', 'beforeSave2', 'fs.writeFileSync', 'afterSave1', 'afterSave2']
 
       it "fires will-reload and reloaded events when reloaded", ->
         events = []
@@ -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()
 
@@ -522,67 +522,38 @@ describe 'TextBuffer', ->
 
     it "saves the contents of the buffer to the path", ->
       filePath = path.join(temp.dir, 'temp.txt')
-      fs.remove filePath if fs.exists(filePath)
+      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
 
       saveAsBuffer.setText 'Buffer contents!'
       saveAsBuffer.saveAs(filePath)
-      expect(fs.read(filePath)).toEqual 'Buffer contents!'
+      expect(fs.readFileSync(filePath, 'utf8')).toEqual 'Buffer contents!'
 
       expect(eventHandler).toHaveBeenCalledWith(saveAsBuffer)
 
     it "stops listening to events on previous path and begins listening to events on new path", ->
       originalPath = path.join(temp.dir, 'original.txt')
       newPath = path.join(temp.dir, 'new.txt')
-      fs.writeSync(originalPath, "")
+      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)
       expect(changeHandler).not.toHaveBeenCalled()
 
-      fs.writeSync(originalPath, "should not trigger buffer event")
+      fs.writeFileSync(originalPath, "should not trigger buffer event")
       waits 20
       runs ->
         expect(changeHandler).not.toHaveBeenCalled()
-        fs.writeSync(newPath, "should trigger buffer event")
+        fs.writeFileSync(newPath, "should trigger buffer event")
 
       waitsFor ->
         changeHandler.callCount > 0
 
-  describe ".getRelativePath()", ->
-    [filePath, newPath, bufferToChange, eventHandler] = []
-
-    beforeEach ->
-      filePath = path.join(__dirname, "fixtures", "atom-manipulate-me")
-      newPath = "#{filePath}-i-moved"
-      fs.writeSync(filePath, "")
-      bufferToChange = project.bufferForPathSync(filePath)
-      eventHandler = jasmine.createSpy('eventHandler')
-      bufferToChange.on 'path-changed', eventHandler
-
-    afterEach ->
-      bufferToChange.destroy()
-      fs.remove(filePath) if fs.exists(filePath)
-      fs.remove(newPath) if fs.exists(newPath)
-
-    it "updates when the text buffer's file is moved", ->
-      expect(bufferToChange.getRelativePath()).toBe('atom-manipulate-me')
-
-      jasmine.unspy(window, "setTimeout")
-      eventHandler.reset()
-      fs.move(filePath, newPath)
-
-      waitsFor "buffer path change", ->
-        eventHandler.callCount > 0
-
-      runs ->
-        expect(bufferToChange.getRelativePath()).toBe('atom-manipulate-me-i-moved')
-
   describe ".getTextInRange(range)", ->
     describe "when range is empty", ->
       it "returns an empty string", ->
@@ -926,22 +897,28 @@ describe 'TextBuffer', ->
             expect(buffer.getText()).toBe "\ninitialtexthello\n1\n2\n"
 
   describe "serialization", ->
-    buffer2 = null
+    [buffer2, project2] = []
+
+    beforeEach ->
+      buffer.destroy()
+
+      filePath = temp.openSync('atom').path
+      fs.writeFileSync(filePath, "words")
+      buffer = atom.project.bufferForPathSync(filePath)
 
     afterEach ->
       buffer2?.release()
+      project2?.destroy()
 
     describe "when the serialized buffer had no unsaved changes", ->
       it "loads the current contents of the file at the serialized path", ->
         expect(buffer.isModified()).toBeFalsy()
 
-        state = buffer.serialize()
-        state.get('text').insert([0, 0], 'simulate divergence of on-disk contents from serialized contents')
+        project2 = atom.replicate().get('project')
+        buffer2 = project2.getBuffers()[0]
 
-        buffer2 = deserialize(state, {project})
-
-        waitsFor ->
-          buffer2.cachedDiskContents
+        waitsForPromise ->
+          buffer2.load()
 
         runs ->
           expect(buffer2.isModified()).toBeFalsy()
@@ -951,18 +928,11 @@ describe 'TextBuffer', ->
     describe "when the serialized buffer had unsaved changes", ->
       describe "when the disk contents were changed since serialization", ->
         it "loads the disk contents instead of the previous unsaved state", ->
-          buffer.release()
-
-          filePath = temp.openSync('atom').path
-          fs.writeSync(filePath, "words")
-          {buffer} = project.openSync(filePath)
           buffer.setText("BUFFER CHANGE")
+          fs.writeFileSync(filePath, "DISK CHANGE")
 
-          state = buffer.serialize()
-          expect(state.getObject('text')).toBe 'BUFFER CHANGE'
-          fs.writeSync(filePath, "DISK CHANGE")
-
-          buffer2 = deserialize(state, {project})
+          project2 = atom.replicate().get('project')
+          buffer2 = project2.getBuffers()[0]
 
           waitsFor ->
             buffer2.cachedDiskContents
@@ -976,14 +946,14 @@ describe 'TextBuffer', ->
         it "restores the previous unsaved state of the buffer", ->
           previousText = buffer.getText()
           buffer.setText("abc")
+          buffer.retain()
 
-          state = buffer.serialize()
-          expect(state.getObject('text')).toBe 'abc'
+          buffer.getState().serializeForPersistence()
+          project2 = atom.replicate().get('project')
+          buffer2 = project2.getBuffers()[0]
 
-          buffer2 = deserialize(state, {project})
-
-          waitsFor ->
-            buffer2.cachedDiskContents
+          waitsForPromise ->
+            buffer2.load()
 
           runs ->
             expect(buffer2.getPath()).toBe(buffer.getPath())
@@ -996,37 +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.serialize()
+        state = buffer.getState().clone()
         expect(state.get('path')).toBeUndefined()
         expect(state.getObject('text')).toBe 'abc'
 
-        buffer2 = deserialize(state)
+        buffer2 = atom.project.addBuffer(new TextBuffer(state))
         expect(buffer2.getPath()).toBeUndefined()
         expect(buffer2.getText()).toBe("abc")
-
-    describe "when the buffer has remote markers", ->
-      [buffer2, buffer3] = []
-
-      afterEach ->
-        buffer2.destroy()
-        buffer3.destroy()
-
-      it "does not include them in the serialized state", ->
-        doc1 = buffer.getState()
-        doc2 = doc1.clone(new Site(2))
-        doc1.connect(doc2)
-        buffer2 = deserialize(doc2, {project})
-
-        buffer.markPosition [1, 0]
-        buffer2.markPosition [2, 0]
-        expect(buffer.getMarkerCount()).toBe 2
-        expect(buffer.getMarkers()[0].isRemote()).toBe false
-        expect(buffer.getMarkers()[1].isRemote()).toBe true
-
-        buffer3 = deserialize(buffer.serialize(), {project})
-        expect(buffer3.getMarkerCount()).toBe 1
-        expect(buffer3.getMarkers()[0].isRemote()).toBe false
-        expect(buffer3.getMarkers()[0].getRange()).toEqual [[1, 0], [1, 0]]

spec/text-mate-grammar-spec.coffee

@@ -6,14 +6,14 @@ 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)
-    grammar = syntax.selectGrammar("hello.coffee")
+    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)", ->
     it "loads grammars from plists", ->
@@ -49,7 +49,7 @@ describe "TextMateGrammar", ->
 
     describe "when the line doesn't match any patterns", ->
       it "returns the entire line as a single simple token with the grammar's scope", ->
-        textGrammar = syntax.selectGrammar('foo.txt')
+        textGrammar = atom.syntax.selectGrammar('foo.txt')
         {tokens} = textGrammar.tokenizeLine("abc def")
         expect(tokens.length).toBe 1
 
@@ -126,20 +126,20 @@ describe "TextMateGrammar", ->
 
     describe "when the line matches no patterns", ->
       it "does not infinitely loop", ->
-        grammar = syntax.selectGrammar("sample.txt")
+        grammar = atom.syntax.selectGrammar("sample.txt")
         {tokens} = grammar.tokenizeLine('hoo')
         expect(tokens.length).toBe 1
         expect(tokens[0]).toEqual value: 'hoo',  scopes: ["text.plain", "meta.paragraph.text"]
 
     describe "when the line matches a pattern with a 'contentName'", ->
       it "creates tokens using the content of contentName as the token name", ->
-        grammar = syntax.selectGrammar("sample.txt")
+        grammar = atom.syntax.selectGrammar("sample.txt")
         {tokens} = grammar.tokenizeLine('ok, cool')
         expect(tokens[0]).toEqual value: 'ok, cool',  scopes: ["text.plain", "meta.paragraph.text"]
 
     describe "when the line matches a pattern with no `name` or `contentName`", ->
       it "creates tokens without adding a new scope", ->
-        grammar = syntax.selectGrammar('foo.rb')
+        grammar = atom.syntax.selectGrammar('foo.rb')
         {tokens} = grammar.tokenizeLine('%w|oh \\look|')
         expect(tokens.length).toBe 5
         expect(tokens[0]).toEqual value: '%w|',  scopes: ["source.ruby", "string.quoted.other.literal.lower.ruby", "punctuation.definition.string.begin.ruby"]
@@ -184,7 +184,7 @@ describe "TextMateGrammar", ->
 
       describe "when the end pattern contains a back reference", ->
         it "constructs the end rule based on its back-references to captures in the begin rule", ->
-          grammar = syntax.selectGrammar('foo.rb')
+          grammar = atom.syntax.selectGrammar('foo.rb')
           {tokens} = grammar.tokenizeLine('%w|oh|,')
           expect(tokens.length).toBe 4
           expect(tokens[0]).toEqual value: '%w|',  scopes: ["source.ruby", "string.quoted.other.literal.lower.ruby", "punctuation.definition.string.begin.ruby"]
@@ -193,7 +193,7 @@ describe "TextMateGrammar", ->
           expect(tokens[3]).toEqual value: ',',  scopes: ["source.ruby", "punctuation.separator.object.ruby"]
 
         it "allows the rule containing that end pattern to be pushed to the stack multiple times", ->
-          grammar = syntax.selectGrammar('foo.rb')
+          grammar = atom.syntax.selectGrammar('foo.rb')
           {tokens} = grammar.tokenizeLine('%Q+matz had some #{%Q-crazy ideas-} for ruby syntax+ # damn.')
           expect(tokens[0]).toEqual value: '%Q+', scopes: ["source.ruby","string.quoted.other.literal.upper.ruby","punctuation.definition.string.begin.ruby"]
           expect(tokens[1]).toEqual value: 'matz had some ', scopes: ["source.ruby","string.quoted.other.literal.upper.ruby"]
@@ -211,10 +211,10 @@ 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 = syntax.grammarForScopeName('text.html.ruby')
+            grammar = atom.syntax.grammarForScopeName('text.html.ruby')
             {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"]
@@ -242,17 +242,17 @@ 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 = syntax.selectGrammar('foo.html.erb')
+            grammar = atom.syntax.selectGrammar('foo.html.erb')
             grammarUpdatedHandler = jasmine.createSpy("grammarUpdatedHandler")
             grammar.on 'grammar-updated', grammarUpdatedHandler
 
             {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,17 +260,17 @@ 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 = syntax.grammarForScopeName('text.html.ruby')
+            grammar = atom.syntax.grammarForScopeName('text.html.ruby')
             {tokens} = grammar.tokenizeLine("<div class='name'><%= User.find(2).full_name %></div>")
             expect(tokens[0]).toEqual value: "<div class='name'>", scopes: ["text.html.ruby"]
             expect(tokens[1]).toEqual value: '<%=', scopes: ["text.html.ruby","source.ruby.rails.embedded.html","punctuation.section.embedded.ruby"]
             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"]
@@ -308,21 +308,21 @@ describe "TextMateGrammar", ->
       expect(tokens[1].value).toBe " a singleLineComment"
 
     it "does not loop infinitely (regression)", ->
-      grammar = syntax.selectGrammar("hello.js")
+      grammar = atom.syntax.selectGrammar("hello.js")
       {tokens, ruleStack} = grammar.tokenizeLine("// line comment")
       {tokens, ruleStack} = grammar.tokenizeLine(" // second line comment with a single leading space", ruleStack)
 
     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 = syntax.selectGrammar("hello.c")
+        grammar = atom.syntax.selectGrammar("hello.c")
         {tokens, ruleStack} = grammar.tokenizeLine("if(1){m()}")
         expect(tokens[5]).toEqual value: "m", scopes: ["source.c", "meta.block.c", "meta.function-call.c", "support.function.any-method.c"]
 
       it "correctly parses nested blocks. (regression)", ->
-        grammar = syntax.selectGrammar("hello.c")
+        grammar = atom.syntax.selectGrammar("hello.c")
         {tokens, ruleStack} = grammar.tokenizeLine("if(1){if(1){m()}}")
         expect(tokens[5]).toEqual value: "if", scopes: ["source.c", "meta.block.c", "keyword.control.c"]
         expect(tokens[10]).toEqual value: "m", scopes: ["source.c", "meta.block.c", "meta.block.c", "meta.function-call.c", "support.function.any-method.c"]
@@ -330,8 +330,8 @@ 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")
-        grammar = syntax.selectGrammar("something.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"
         expect(tokens[1].value).toBe "bc"
@@ -339,14 +339,14 @@ 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)
-        grammar = syntax.selectGrammar("style.scss")
+        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"]
 
     describe "when a line has more tokens than `maxTokensPerLine`", ->
       it "creates a final token with the remaining text and resets the ruleStack to match the begining of the line", ->
-        grammar = syntax.selectGrammar("hello.js")
+        grammar = atom.syntax.selectGrammar("hello.js")
         spyOn(grammar, 'getMaxTokensPerLine').andCallFake -> 5
         originalRuleStack = [grammar.initialRule, grammar.initialRule, grammar.initialRule]
         {tokens, ruleStack} = grammar.tokenizeLine("one(two(three(four(five(_param_)))))", originalRuleStack)
@@ -356,7 +356,7 @@ describe "TextMateGrammar", ->
 
     describe "when a grammar has a capture with patterns", ->
       it "matches the patterns and includes the scope specified as the pattern's match name", ->
-        grammar = syntax.selectGrammar("hello.php")
+        grammar = atom.syntax.selectGrammar("hello.php")
         {tokens} = grammar.tokenizeLine("<?php public final function meth() {} ?>")
 
         expect(tokens[2].value).toBe "public"
@@ -402,7 +402,7 @@ describe "TextMateGrammar", ->
 
     describe "when the grammar has injections", ->
       it "correctly includes the injected patterns when tokenizing", ->
-        grammar = syntax.selectGrammar("hello.php")
+        grammar = atom.syntax.selectGrammar("hello.php")
         {tokens} = grammar.tokenizeLine("<div><?php function hello() {} ?></div>")
 
         expect(tokens[3].value).toBe "<?php"
@@ -428,15 +428,15 @@ 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)
-        grammar = syntax.grammarForScopeName("text.hyperlink")
+        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)
-        grammar = syntax.selectGrammar("text.js")
+        atom.packages.activatePackage('language-hyperlink', sync: true)
+        grammar = atom.syntax.selectGrammar("text.js")
         {tokens} = grammar.tokenizeLine("var i; // http://github.com")
 
         expect(tokens[0].value).toBe "var"
@@ -447,29 +447,29 @@ 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"]
 
-          syntax.addGrammar(new TextMateGrammar(
+          atom.syntax.addGrammar(new TextMateGrammar(
             name: "test"
             scopeName: "source.test"
             repository: {}
@@ -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,8 +514,8 @@ describe "TextMateGrammar", ->
       lines = null
 
       beforeEach ->
-        atom.activatePackage('language-todo', sync: true)
-        grammar = syntax.selectGrammar('main.rb')
+        atom.packages.activatePackage('language-todo', sync: true)
+        grammar = atom.syntax.selectGrammar('main.rb')
         lines = grammar.tokenizeLines "# TODO be nicer"
 
       it "replaces the number with the capture group and translates the text", ->
@@ -528,8 +528,8 @@ describe "TextMateGrammar", ->
 
     describe "Git commit messages", ->
       beforeEach ->
-        atom.activatePackage('language-git', sync: true)
-        grammar = syntax.selectGrammar('COMMIT_EDITMSG')
+        atom.packages.activatePackage('language-git', sync: true)
+        grammar = atom.syntax.selectGrammar('COMMIT_EDITMSG')
         lines = grammar.tokenizeLines """
           longggggggggggggggggggggggggggggggggggggggggggggggg
           # Please enter the commit message for your changes. Lines starting
@@ -547,8 +547,8 @@ describe "TextMateGrammar", ->
 
     describe "C++", ->
       beforeEach ->
-        atom.activatePackage('language-c', sync: true)
-        grammar = syntax.selectGrammar('includes.cc')
+        atom.packages.activatePackage('language-c', sync: true)
+        grammar = atom.syntax.selectGrammar('includes.cc')
         lines = grammar.tokenizeLines """
           #include "a.h"
           #include "b.h"
@@ -570,7 +570,7 @@ describe "TextMateGrammar", ->
 
     describe "Ruby", ->
       beforeEach ->
-        grammar = syntax.selectGrammar('hello.rb')
+        grammar = atom.syntax.selectGrammar('hello.rb')
         lines = grammar.tokenizeLines """
           a = {
             "b" => "c",
@@ -585,9 +585,9 @@ describe "TextMateGrammar", ->
 
     describe "Objective-C", ->
       beforeEach ->
-        atom.activatePackage('language-c', sync: true)
-        atom.activatePackage('language-objective-c', sync: true)
-        grammar = syntax.selectGrammar('function.mm')
+        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() {
           NSString *a = @"a\\nb";
@@ -612,8 +612,8 @@ describe "TextMateGrammar", ->
 
     describe "Java", ->
       beforeEach ->
-        atom.activatePackage('language-java', sync: true)
-        grammar = syntax.selectGrammar('Function.java')
+        atom.packages.activatePackage('language-java', sync: true)
+        grammar = atom.syntax.selectGrammar('Function.java')
 
       it "correctly parses single line comments", ->
         lines = grammar.tokenizeLines """
@@ -635,11 +635,9 @@ describe "TextMateGrammar", ->
         expect(lastToken.value).toEqual ';'
 
     describe "HTML (Ruby - ERB)", ->
-      beforeEach ->
-        grammar = syntax.selectGrammar('page.erb')
-        lines = grammar.tokenizeLines '<% page_title "My Page" %>'
-
       it "correctly parses strings inside tags", ->
+        grammar = atom.syntax.selectGrammar('page.erb')
+        lines = grammar.tokenizeLines '<% page_title "My Page" %>'
         tokens = lines[0]
 
         expect(tokens[2].value).toEqual '"'
@@ -649,10 +647,20 @@ 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 ->
-          grammar = syntax.selectGrammar('main.js')
+          grammar = atom.syntax.selectGrammar('main.js')
           lines = grammar.tokenizeLines "'\uD835\uDF97'"
 
         it "correctly parses JavaScript strings containing surrogate pair characters", ->
@@ -664,8 +672,8 @@ describe "TextMateGrammar", ->
 
       describe "when the line contains unicode characters", ->
         it "correctly parses tokens starting after them", ->
-          atom.activatePackage('language-json', sync: true)
-          grammar = syntax.selectGrammar('package.json')
+          atom.packages.activatePackage('language-json', sync: true)
+          grammar = atom.syntax.selectGrammar('package.json')
           {tokens} = grammar.tokenizeLine '{"\u2026": 1}'
 
           expect(tokens.length).toBe 8
@@ -674,7 +682,7 @@ describe "TextMateGrammar", ->
 
     describe "python", ->
       it "parses import blocks correctly", ->
-        grammar = syntax.selectGrammar("file.py")
+        grammar = atom.syntax.selectGrammar("file.py")
         lines = grammar.tokenizeLines "import a\nimport b"
 
         line1 = lines[0]

spec/theme-manager-spec.coffee

@@ -1,14 +1,16 @@
 path = require 'path'
-{$, $$, fs, RootView} = require 'atom'
+{$, $$, fs, WorkspaceView} = require 'atom'
 
 ThemeManager = require '../src/theme-manager'
 AtomPackage = require '../src/atom-package'
 
 describe "ThemeManager", ->
   themeManager = null
+  resourcePath = atom.getLoadSettings().resourcePath
+  configDirPath = atom.getConfigDirPath()
 
   beforeEach ->
-    themeManager = new ThemeManager(atom.packages)
+    themeManager = new ThemeManager({packageManager: atom.packages, resourcePath, configDirPath})
 
   afterEach ->
     themeManager.deactivateThemes()
@@ -30,7 +32,7 @@ describe "ThemeManager", ->
 
   describe "getImportPaths()", ->
     it "returns the theme directories before the themes are loaded", ->
-      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()
 
@@ -40,7 +42,7 @@ describe "ThemeManager", ->
       expect(paths[1]).toContain 'atom-light-ui'
 
     it "ignores themes that cannot be resolved to a directory", ->
-      config.set('core.themes', ['definitely-not-a-theme'])
+      atom.config.set('core.themes', ['definitely-not-a-theme'])
       expect(-> themeManager.getImportPaths()).not.toThrow()
 
   describe "when the core.themes config value changes", ->
@@ -49,24 +51,24 @@ describe "ThemeManager", ->
       spyOn(themeManager, 'getUserStylesheetPath').andCallFake -> null
       themeManager.activateThemes()
 
-      config.set('core.themes', [])
+      atom.config.set('core.themes', [])
       expect($('style.theme').length).toBe 0
       expect(reloadHandler).toHaveBeenCalled()
 
-      config.set('core.themes', ['atom-dark-syntax'])
+      atom.config.set('core.themes', ['atom-dark-syntax'])
       expect($('style.theme').length).toBe 1
       expect($('style.theme:eq(0)').attr('id')).toMatch /atom-dark-syntax/
 
-      config.set('core.themes', ['atom-light-syntax', 'atom-dark-syntax'])
+      atom.config.set('core.themes', ['atom-light-syntax', 'atom-dark-syntax'])
       expect($('style.theme').length).toBe 2
       expect($('style.theme:eq(0)').attr('id')).toMatch /atom-dark-syntax/
       expect($('style.theme:eq(1)').attr('id')).toMatch /atom-light-syntax/
 
-      config.set('core.themes', [])
+      atom.config.set('core.themes', [])
       expect($('style.theme').length).toBe 0
 
-      # atom-dark-ui has an directory path, the syntax ones dont.
-      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'
@@ -78,15 +80,15 @@ 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)
       expect($('head style').length).toBe lengthBefore + 1
 
       element = $('head style[id*="css.css"]')
-      expect(element.attr('id')).toBe cssPath
-      expect(element.text()).toBe fs.read(cssPath)
+      expect(element.attr('id')).toBe themeManager.stringToId(cssPath)
+      expect(element.text()).toBe fs.readFileSync(cssPath, 'utf8')
 
       # doesn't append twice
       themeManager.requireStylesheet(cssPath)
@@ -95,13 +97,13 @@ 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
 
       element = $('head style[id*="sample.less"]')
-      expect(element.attr('id')).toBe lessPath
+      expect(element.attr('id')).toBe themeManager.stringToId(lessPath)
       expect(element.text()).toBe """
       #header {
         color: #4d926f;
@@ -119,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 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 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()
@@ -138,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", ->
-      config.set('core.themes', ['theme-with-ui-variables'])
+      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.buildBufferSync '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,19 +387,19 @@ 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(syntax.selectGrammar('test.erb'))
+      tokenizedBuffer.setGrammar(atom.syntax.selectGrammar('test.erb'))
       fullyTokenize(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,49 +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()
-      syntaxState = syntax.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
-      rootView.getActivePane().splitRight()
-      expect(window.rootView.find('.editor').length).toBe 2
+      atom.workspaceView.openSync('sample.js')
+      buffer = atom.workspaceView.getActivePaneItem().buffer
+      pane = atom.workspaceView.getActivePane()
+      pane.splitRight(pane.copyActiveItem())
+      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

@@ -1,6 +1,6 @@
 TextMateGrammar = require './text-mate-grammar'
 Package = require './package'
-fsUtils = require './fs-utils'
+fs = require 'fs-plus'
 path = require 'path'
 _ = require 'underscore-plus'
 {$} = require './space-pen-extensions'
@@ -89,7 +89,7 @@ class AtomPackage extends Package
 
     @requireMainModule()
     if @mainModule?
-      config.setDefaults(@name, @mainModule.configDefaults)
+      atom.config.setDefaults(@name, @mainModule.configDefaults)
       @mainModule.activateConfig?()
     @configActivated = true
 
@@ -105,9 +105,9 @@ class AtomPackage extends Package
     atom.keymap.add(keymapPath, map) for [keymapPath, map] in @keymaps
     atom.contextMenu.add(menuPath, map['context-menu']) for [menuPath, map] in @menus
     atom.menu.add(map.menu) for [menuPath, map] in @menus when map.menu
-    syntax.addGrammar(grammar) for grammar in @grammars
+    atom.syntax.addGrammar(grammar) for grammar in @grammars
     for [scopedPropertiesPath, selector, properties] in @scopedProperties
-      syntax.addProperties(scopedPropertiesPath, selector, properties)
+      atom.syntax.addProperties(scopedPropertiesPath, selector, properties)
 
   loadKeymaps: ->
     @keymaps = @getKeymapPaths().map (keymapPath) -> [keymapPath, CSON.readFileSync(keymapPath)]
@@ -118,16 +118,16 @@ class AtomPackage extends Package
   getKeymapPaths: ->
     keymapsDirPath = path.join(@path, 'keymaps')
     if @metadata.keymaps
-      @metadata.keymaps.map (name) -> fsUtils.resolve(keymapsDirPath, name, ['json', 'cson', ''])
+      @metadata.keymaps.map (name) -> fs.resolve(keymapsDirPath, name, ['json', 'cson', ''])
     else
-      fsUtils.listSync(keymapsDirPath, ['cson', 'json'])
+      fs.listSync(keymapsDirPath, ['cson', 'json'])
 
   getMenuPaths: ->
     menusDirPath = path.join(@path, 'menus')
     if @metadata.menus
-      @metadata.menus.map (name) -> fsUtils.resolve(menusDirPath, name, ['json', 'cson', ''])
+      @metadata.menus.map (name) -> fs.resolve(menusDirPath, name, ['json', 'cson', ''])
     else
-      fsUtils.listSync(menusDirPath, ['cson', 'json'])
+      fs.listSync(menusDirPath, ['cson', 'json'])
 
   loadStylesheets: ->
     @stylesheets = @getStylesheetPaths().map (stylesheetPath) ->
@@ -140,25 +140,25 @@ class AtomPackage extends Package
     stylesheetDirPath = @getStylesheetsPath()
 
     if @metadata.stylesheetMain
-      [fsUtils.resolve(@path, @metadata.stylesheetMain)]
+      [fs.resolve(@path, @metadata.stylesheetMain)]
     else if @metadata.stylesheets
-      @metadata.stylesheets.map (name) -> fsUtils.resolve(stylesheetDirPath, name, ['css', 'less', ''])
-    else if indexStylesheet = fsUtils.resolve(@path, 'index', ['css', 'less'])
+      @metadata.stylesheets.map (name) -> fs.resolve(stylesheetDirPath, name, ['css', 'less', ''])
+    else if indexStylesheet = fs.resolve(@path, 'index', ['css', 'less'])
       [indexStylesheet]
     else
-      fsUtils.listSync(stylesheetDirPath, ['css', 'less'])
+      fs.listSync(stylesheetDirPath, ['css', 'less'])
 
   loadGrammars: ->
     @grammars = []
     grammarsDirPath = path.join(@path, 'grammars')
-    for grammarPath in fsUtils.listSync(grammarsDirPath, ['.json', '.cson'])
+    for grammarPath in fs.listSync(grammarsDirPath, ['.json', '.cson'])
       @grammars.push(TextMateGrammar.loadSync(grammarPath))
 
   loadScopedProperties: ->
     @scopedProperties = []
     scopedPropertiessDirPath = path.join(@path, 'scoped-properties')
-    for scopedPropertiesPath in fsUtils.listSync(scopedPropertiessDirPath, ['.json', '.cson'])
-      for selector, properties of fsUtils.readObjectSync(scopedPropertiesPath)
+    for scopedPropertiesPath in fs.listSync(scopedPropertiessDirPath, ['.json', '.cson'])
+      for selector, properties of fs.readObjectSync(scopedPropertiesPath)
         @scopedProperties.push([scopedPropertiesPath, selector, properties])
 
   serialize: ->
@@ -180,8 +180,8 @@ class AtomPackage extends Package
     @configActivated = false
 
   deactivateResources: ->
-    syntax.removeGrammar(grammar) for grammar in @grammars
-    syntax.removeProperties(scopedPropertiesPath) for [scopedPropertiesPath] in @scopedProperties
+    atom.syntax.removeGrammar(grammar) for grammar in @grammars
+    atom.syntax.removeProperties(scopedPropertiesPath) for [scopedPropertiesPath] in @scopedProperties
     atom.keymap.remove(keymapPath) for [keymapPath] in @keymaps
     atom.themes.removeStylesheet(stylesheetPath) for [stylesheetPath] in @stylesheets
     @stylesheetsActivated = false
@@ -198,7 +198,7 @@ class AtomPackage extends Package
   requireMainModule: ->
     return @mainModule if @mainModule?
     mainModulePath = @getMainModulePath()
-    @mainModule = require(mainModulePath) if fsUtils.isFileSync(mainModulePath)
+    @mainModule = require(mainModulePath) if fs.isFileSync(mainModulePath)
 
   getMainModulePath: ->
     return @mainModulePath if @resolvedMainModulePath
@@ -208,22 +208,22 @@ class AtomPackage extends Package
         path.join(@path, @metadata.main)
       else
         path.join(@path, 'index')
-    @mainModulePath = fsUtils.resolveExtension(mainModulePath, ["", _.keys(require.extensions)...])
+    @mainModulePath = fs.resolveExtension(mainModulePath, ["", _.keys(require.extensions)...])
 
   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,38 +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...)
-
-fsUtils = require './fs-utils'
-{$} = 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()
@@ -47,20 +62,25 @@ class Atom
     MenuManager = require './menu-manager'
 
     @config = new Config({configDirPath, resourcePath})
-    @keymap = new Keymap()
+    @keymap = new Keymap({configDirPath, resourcePath})
     @packages = new PackageManager({devMode, configDirPath, resourcePath})
 
-    #TODO Remove once packages have been updated to not touch atom.packageStates directly
-    @__defineGetter__ 'packageStates', => @packages.packageStates
-    @__defineSetter__ 'packageStates', (packageStates) => @packages.packageStates = packageStates
-
     @subscribe @packages, 'activated', => @watchThemes()
-    @themes = new ThemeManager(@packages)
+    @themes = new ThemeManager({packageManager: @packages, configDirPath, resourcePath})
     @contextMenu = new ContextMenuManager(devMode)
-    @menu = new MenuManager()
+    @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()
 
@@ -95,6 +115,7 @@ class Atom
     else
       browserWindow.center()
 
+  # Private:
   restoreDimensions: ->
     dimensions = @getWindowState().getObject('dimensions')
     unless dimensions?.width and dimensions?.height
@@ -111,54 +132,96 @@ class Atom
     @loadSettings ?= _.deepClone(@getCurrentWindow().loadSettings)
     _.deepClone(@loadSettings)
 
+  # Private:
   deserializeProject: ->
     Project = require './project'
-    state = @getWindowState()
-    @project = deserialize(state.get('project'))
-    unless @project?
-      @project = new Project(@getLoadSettings().initialPath)
-      state.set('project', @project.getState())
+    @project = @getWindowState('project')
+    unless @project instanceof Project
+      @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
@@ -166,84 +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()
 
-  getHomeDirPath: ->
-    process.env[if process.platform is 'win32' then 'USERPROFILE' else 'HOME']
+  # Public: Get the version of the Atom application.
+  getVersion: ->
+    app.getVersion()
 
-  getTempDirPath: ->
-    if process.platform is 'win32' then os.tmpdir() else '/tmp'
+  getGitHubAuthTokenName: ->
+    'Atom GitHub API Token'
+
+  # Public: Set the the github token in the keychain
+  setGitHubAuthToken: (token) ->
+    keytar.replacePassword(@getGitHubAuthTokenName(), 'github', token)
+
+  # Public: Get the github token from the keychain
+  getGitHubAuthToken: ->
+    keytar.getPassword(@getGitHubAuthTokenName(), 'github')
 
   # Public: Get the directory path to Atom's configuration area.
+  #
+  # Returns the absolute path to ~/.atom
   getConfigDirPath: ->
-    @configDirPath ?= fsUtils.absolute('~/.atom')
+    @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'
@@ -255,20 +389,22 @@ class Atom
           filename = "editor-#{sha1}"
 
     if filename
-      path.join(@config.userStoragePath, filename)
+      path.join(@getStorageDirPath(), filename)
     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 fsUtils.exists(windowStatePath)
+      if fs.existsSync(windowStatePath)
         try
-          documentStateJson  = fsUtils.read(windowStatePath)
+          documentStateJson  = fs.readFileSync(windowStatePath, 'utf8')
         catch error
           console.warn "Error reading window state: #{windowStatePath}", error.stack, error
     else
@@ -279,18 +415,28 @@ class Atom
     catch error
       console.warn "Error parsing window state: #{windowStatePath}", error.stack, error
 
-    doc = Document.deserialize(state: documentState) if documentState?
+  # Private:
+  loadWindowState: ->
+    serializedWindowState = @loadSerializedWindowState()
+    doc = Document.deserialize(serializedWindowState) if serializedWindowState?
     doc ?= Document.create()
-    @site = doc.site # TODO: Remove this when everything is using telepath models
+    doc.registerModelClasses(require('./text-buffer'), require('./project'))
+    # TODO: Remove this when everything is using telepath models
+    if @site?
+      @site.setRootDocument(doc)
+    else
+      @site = new SiteShim(doc)
     doc
 
+  # Private:
   saveWindowState: ->
     windowState = @getWindowState()
     if windowStatePath = @getWindowStatePath()
-      windowState.saveSync(path: windowStatePath)
+      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
@@ -298,23 +444,35 @@ class Atom
     else
       @windowState
 
+  # Private: Returns a replicated copy of the current state.
+  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(@config.configDirPath, "user.coffee")
-    try
-      require userInitScriptPath if fsUtils.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/binding-set.coffee

@@ -1,66 +0,0 @@
-{$} = require './space-pen-extensions'
-_ = require 'underscore-plus'
-fsUtils = require './fs-utils'
-
-{specificity} = require 'clear-cut'
-PEG = require 'pegjs'
-
-### Internal ###
-
-module.exports =
-class BindingSet
-
-  @parser: null
-
-  selector: null
-  commandsByKeystrokes: null
-  parser: null
-  name: null
-
-  constructor: (selector, commandsByKeystrokes, @index, @name) ->
-    BindingSet.parser ?= PEG.buildParser(fsUtils.read(require.resolve './keystroke-pattern.pegjs'))
-    @specificity = specificity(selector)
-    @selector = selector.replace(/!important/g, '')
-    @commandsByKeystrokes = @normalizeCommandsByKeystrokes(commandsByKeystrokes)
-
-  # Private:
-  getName: ->
-    @name
-
-  # Private:
-  getSelector: ->
-    @selector
-
-  # Private:
-  getCommandsByKeystrokes: ->
-    @commandsByKeystrokes
-
-  commandForEvent: (event) ->
-    for keystrokes, command of @commandsByKeystrokes
-      return command if event.keystrokes == keystrokes
-    null
-
-  matchesKeystrokePrefix: (event) ->
-    eventKeystrokes = event.keystrokes.split(' ')
-    for keystrokes, command of @commandsByKeystrokes
-      bindingKeystrokes = keystrokes.split(' ')
-      continue unless eventKeystrokes.length < bindingKeystrokes.length
-      return true if _.isEqual(eventKeystrokes, bindingKeystrokes[0...eventKeystrokes.length])
-    false
-
-  normalizeCommandsByKeystrokes: (commandsByKeystrokes) ->
-    normalizedCommandsByKeystrokes = {}
-    for keystrokes, command of commandsByKeystrokes
-      normalizedCommandsByKeystrokes[@normalizeKeystrokes(keystrokes)] = command
-    normalizedCommandsByKeystrokes
-
-  normalizeKeystrokes: (keystrokes) ->
-    normalizedKeystrokes = keystrokes.split(/\s+/).map (keystroke) =>
-      @normalizeKeystroke(keystroke)
-    normalizedKeystrokes.join(' ')
-
-  normalizeKeystroke: (keystroke) ->
-    keys = BindingSet.parser.parse(keystroke)
-    modifiers = keys[0...-1]
-    modifiers.sort()
-    [modifiers..., _.last(keys)].join('-')

src/browser/application-menu.coffee

@@ -22,7 +22,7 @@ class ApplicationMenu
   #   The Object which describes the menu to display.
   # * keystrokesByCommand:
   #   An Object where the keys are commands and the values are Arrays containing
-  #   the keystrokes.
+  #   the keystroke.
   update: (template, keystrokesByCommand) ->
     @translateTemplate(template, keystrokesByCommand)
     @substituteVersion(template)
@@ -97,14 +97,14 @@ class ApplicationMenu
       ]
     ]
 
-  # Private: Combines a menu template with the appropriate keystrokes.
+  # Private: Combines a menu template with the appropriate keystroke.
   #
   # * template:
   #   An Object conforming to atom-shell's menu api but lacking accelerator and
   #   click properties.
   # * keystrokesByCommand:
   #   An Object where the keys are commands and the values are Arrays containing
-  #   the keystrokes.
+  #   the keystroke.
   #
   # Returns a complete menu configuration object for atom-shell's menu API.
   translateTemplate: (template, keystrokesByCommand) ->
@@ -123,21 +123,21 @@ class ApplicationMenu
   #   The name of the command.
   # * keystrokesByCommand:
   #   An Object where the keys are commands and the values are Arrays containing
-  #   the keystrokes.
+  #   the keystroke.
   #
   # Returns a String containing the keystroke in a format that can be interpreted
   #   by atom shell to provide nice icons where available.
   acceleratorForCommand: (command, keystrokesByCommand) ->
-    keystroke = keystrokesByCommand[command]?[0]
-    return null unless keystroke
+    firstKeystroke = keystrokesByCommand[command]?[0]
+    return null unless firstKeystroke
 
-    modifiers = keystroke.split('-')
+    modifiers = firstKeystroke.split('-')
     key = modifiers.pop()
 
     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()
@@ -146,6 +146,9 @@ class AtomApplication
       else
         @openPath(pathToOpen: "atom://config")
 
+    app.on 'window-all-closed', ->
+      app.quit() if process.platform is 'win32'
+
     app.on 'will-quit', =>
       fs.unlinkSync socketPath if fs.existsSync(socketPath) # Clean the socket file when quit normally.
 
@@ -242,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
@@ -288,9 +299,9 @@ class AtomApplication
   openUrl: ({urlToOpen, devMode}) ->
     unless @packages?
       PackageManager = require '../package-manager'
-      fsUtils = require '../fs-utils'
+      fs = require 'fs-plus'
       @packages = new PackageManager
-        configDirPath: fsUtils.absolute('~/.atom')
+        configDirPath: fs.absolute('~/.atom')
         devMode: devMode
         resourcePath: @resourcePath
 
@@ -346,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,6 +10,8 @@ _ = require 'underscore-plus'
 # Private:
 module.exports =
 class AtomWindow
+  @iconPath: path.resolve(__dirname, '..', '..', 'resources', 'atom.png')
+
   browserWindow: null
   loaded: null
   isSpec: null
@@ -19,7 +21,7 @@ class AtomWindow
     global.atomApplication.addWindow(this)
 
     @setupNodePath(@resourcePath)
-    @browserWindow = new BrowserWindow show: false, title: 'Atom'
+    @browserWindow = new BrowserWindow show: false, title: 'Atom', icon: @constructor.iconPath
     @browserWindow.restart = _.wrap _.bind(@browserWindow.restart, @browserWindow), (restart) =>
       @setupNodePath(@resourcePath)
       restart()
@@ -68,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

@@ -62,14 +62,12 @@ delegate.browserMainParts.preMainMessageLoopRun = ->
       AtomApplication = require './atom-application'
 
     AtomApplication.open(args)
-    console.log("App load time: #{Date.now() - startTime}ms")
+    console.log("App load time: #{Date.now() - startTime}ms") unless args.test
 
 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

@@ -1,9 +1,8 @@
 path = require 'path'
-fs = require 'fs'
 _ = require 'underscore-plus'
 async = require 'async'
+fs = require 'fs-plus'
 mkdirp = require 'mkdirp'
-fsUtils = require './fs-utils'
 
 symlinkCommand = (sourcePath, destinationPath, callback) ->
   mkdirp path.dirname(destinationPath), (error) ->
@@ -26,17 +25,17 @@ unlinkCommand = (destinationPath, callback) ->
 module.exports =
   findInstallDirectory: (callback) ->
     directories = ['/opt/boxen', '/opt/github', '/usr/local']
-    async.detect(directories, fsUtils.isDirectory, callback)
+    async.detect(directories, fs.isDirectory, callback)
 
   install: (commandPath, commandName, callback) ->
     if not commandName? or _.isFunction(commandName)
       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?
@@ -45,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

@@ -1,9 +1,9 @@
 module.exports =
   observeConfig: (keyPath, args...) ->
     @configSubscriptions ?= {}
-    @configSubscriptions[keyPath] = config.observe(keyPath, args...)
+    @configSubscriptions[keyPath] = atom.config.observe(keyPath, args...)
 
   unobserveConfig: ->
     if @configSubscriptions?
-      subscription.cancel() for keyPath, subscription of @configSubscriptions
+      subscription.off() for keyPath, subscription of @configSubscriptions
       @configSubscriptions = null

src/config.coffee

@@ -1,8 +1,7 @@
-fsUtils = require './fs-utils'
 _ = require 'underscore-plus'
+fs = require 'fs-plus'
 {Emitter} = require 'emissary'
 CSON = require 'season'
-fs = require 'fs'
 path = require 'path'
 async = require 'async'
 pathWatcher = require 'pathwatcher'
@@ -34,43 +33,27 @@ class Config
 
   # Private: Created during initialization, available as `global.config`
   constructor: ({@configDirPath, @resourcePath}={}) ->
-    @bundledKeymapsDirPath = path.join(@resourcePath, "keymaps")
-    @bundledMenusDirPath = path.join(resourcePath, "menus")
-    @nodeModulesDirPath = path.join(@resourcePath, "node_modules")
-    @bundledPackageDirPaths = [@nodeModulesDirPath]
-    @lessSearchPaths = [
-      path.join(@resourcePath, 'static', 'variables')
-      path.join(@resourcePath, 'static')
-    ]
-    @packageDirPaths = [path.join(@configDirPath, "packages")]
-    if atom.getLoadSettings().devMode
-      @packageDirPaths.unshift(path.join(@configDirPath, "dev", "packages"))
-    @userPackageDirPaths = _.clone(@packageDirPaths)
-    @userStoragePath = path.join(@configDirPath, "storage")
-
-    @defaultSettings =
-      core: _.clone(require('./root-view').configDefaults)
-      editor: _.clone(require('./editor').configDefaults)
+    @defaultSettings = {}
     @settings = {}
-    @configFilePath = fsUtils.resolve(@configDirPath, 'config', ['json', 'cson'])
+    @configFilePath = fs.resolve(@configDirPath, 'config', ['json', 'cson'])
     @configFilePath ?= path.join(@configDirPath, 'config.cson')
 
   # Private:
   initializeConfigDirectory: (done) ->
-    return if fsUtils.exists(@configDirPath)
+    return if fs.existsSync(@configDirPath)
 
-    fsUtils.makeTree(@configDirPath)
+    fs.makeTreeSync(@configDirPath)
 
     queue = async.queue ({sourcePath, destinationPath}, callback) =>
-      fsUtils.copy(sourcePath, destinationPath, callback)
+      fs.copy(sourcePath, destinationPath, callback)
     queue.drain = done
 
-    templateConfigDirPath = fsUtils.resolve(@resourcePath, 'dot-atom')
+    templateConfigDirPath = fs.resolve(@resourcePath, 'dot-atom')
     onConfigDirFile = (sourcePath) =>
       relativePath = sourcePath.substring(templateConfigDirPath.length + 1)
       destinationPath = path.join(@configDirPath, relativePath)
       queue.push({sourcePath, destinationPath})
-    fsUtils.traverseTree(templateConfigDirPath, onConfigDirFile, (path) -> true)
+    fs.traverseTree(templateConfigDirPath, onConfigDirFile, (path) -> true)
 
   # Private:
   load: ->
@@ -80,8 +63,8 @@ class Config
 
   # Private:
   loadUserConfig: ->
-    if !fsUtils.exists(@configFilePath)
-      fsUtils.makeTree(path.dirname(@configFilePath))
+    unless fs.existsSync(@configFilePath)
+      fs.makeTreeSync(path.dirname(@configFilePath))
       CSON.writeFileSync(@configFilePath, {})
 
     try
@@ -142,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.
@@ -164,6 +147,15 @@ class Config
       @update()
     value
 
+  # Public: Toggle the value at the key path.
+  #
+  # The new value will be `true` if the value is currently falsy and will be
+  # `false` if the value is currently truthy.
+  #
+  # Returns the new value.
+  toggle: (keyPath) ->
+    @set(keyPath, !@get(keyPath))
+
   # Public: Push the value to the array at the key path.
   #
   # keyPath - The {String} key path.
@@ -224,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