Merge pull request #2431 from atom/cj-add-tokenized-event

Use tokenized event to determine tab style

.gitignore

@@ -1,5 +1,7 @@
 *.swp
+*~
 .DS_Store
+Thumbs.db
 .project
 .svn
 .nvm-version
@@ -11,4 +13,3 @@ debug.log
 docs/output
 docs/includes
 spec/fixtures/evil-files/
-/apm

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "vendor/apm"]
-	path = vendor/apm
-	url = https://github.com/atom/apm.git

.npmrc

@@ -1,2 +1 @@
-ca =
 cache = ~/.atom/.npm

CONTRIBUTING.md

@@ -1,76 +1,102 @@
-# :tada: Contributing to Atom :tada:
+# Contributing to Atom
 
-These are just guidelines, not rules, use your best judgement and feel free
-to propose changes to this document in a pull request.
+:+1::tada: First off, thanks for taking the time to contribute! :tada::+1:
 
-## Issues
-  * Include screenshots and animated GIFs whenever possible, they are immensely
-    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.
+The following is a set of guidelines for contributing to Atom and its packages,
+which are hosted in the [Atom Organization](https://github.com/atom) on GitHub.
+If you're unsure which package is causing your problem or if you're having an
+issue with Atom core, please open an issue on the [main atom repository](https://github.com/atom/atom/issues).
+These are just guidelines, not rules, use your best judgement and feel free to
+propose changes to this document in a pull request.
+
+## Submitting Issues
+
+* Include screenshots and animated GIFs whenever possible; they are immensely
+  helpful.
+* Include the behavior you expected and other places you've seen that behavior
+  such as Emacs, vi, Xcode, etc.
+* Check the dev tools (`alt-cmd-i`) for errors and stack traces to include.
+* On Mac, check Console.app for stack traces to include if reporting a crash.
+* Perform a cursory search to see if a similar issue has already been submitted.
 
 ### Package Repositories
 
 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 organization](https://github.com/atom) such as [tabs](https://github.com/atom/tabs),
+[Atom organization](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).
+[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.
+For more information on how to work with Atom's official packages, see
+[Contributing to Atom Packages](https://atom.io/docs/latest/contributing-to-packages.html)
 
 ## Pull Requests
-  * Include screenshots and animated GIFs whenever possible.
-  * Follow the [CoffeeScript](#coffeescript-styleguide),
-    [JavaScript](https://github.com/styleguide/javascript),
-    and [CSS](https://github.com/styleguide/css) styleguides
-  * Include thoughtfully worded [Jasmine](http://pivotal.github.com/jasmine)
-    specs
-  * 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:
+
+* Include screenshots and animated GIFs in your pull request whenever possible.
+* Follow the [CoffeeScript](#coffeescript-styleguide),
+  [JavaScript](https://github.com/styleguide/javascript),
+  and [CSS](https://github.com/styleguide/css) styleguides.
+* Include thoughtfully-worded, well-structured
+  [Jasmine](http://jasmine.github.io/) specs.
+* Document new code based on the
+  [Documentation Styleguide](#documentation-styleguide)
+* End files with a newline.
+* Place requires 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 methods (methods starting with a `@`)
-    * Instance methods
-  * Beware of platform differences
+* Place class properties in the following order:
+    * Class methods and properties (methods starting with a `@`)
+    * Instance methods and properties
+* Avoid platform-dependent code:
     * 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
+    * Use `os.tmpdir()` rather than `/tmp` when you need to reference the
+      temporary directory.
 
 ## 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
+
+* Use the present tense ("Add feature" not "Added feature")
+* Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
+* Limit the first line to 72 characters or less
+* Reference issues and pull requests liberally
+* Consider starting the commit message with an applicable emoji:
+    * :lipstick: `:lipstick:` when improving the format/structure of the code
+    * :racehorse: `:racehorse:` when improving performance
+    * :non-potable_water: `:non-potable_water:` when plugging memory leaks
+    * :memo: `:memo:` when writing docs
+    * :penguin: `:penguin:` when fixing something on Linux
+    * :apple: `:apple:` when fixing something on Mac OS
+    * :checkered_flag: `:checkered_flag:` when fixing something on Windows
+    * :bug: `:bug:` when fixing a bug
+    * :fire: `:fire:` when removing code or files
+    * :green_heart: `:green_heart:` when fixing the CI build
+    * :white_check_mark: `:white_check_mark:` when adding tests
+    * :lock: `:lock:` when dealing with security
 
 ## CoffeeScript Styleguide
 
 * Set parameter defaults without spaces around the equal sign
-  * `clear = (count=1) ->` instead of `clear = (count = 1) ->`
+    * `clear = (count=1) ->` instead of `clear = (count = 1) ->`
+* Use parentheses if it improves code clarity.
+* Prefer alphabetic keywords to symbolic keywords:
+    * `a is b` instead of `a == b`
+* Avoid spaces inside the curly-braces of hash literals:
+    * `{a: 1, b: 2}` instead of `{ a: 1, b: 2 }`
+* Include a single line of whitespace between methods.
 
 ## Documentation Styleguide
 
 * Use [TomDoc](http://tomdoc.org).
 * Use [Markdown](https://daringfireball.net/projects/markdown).
-* Reference classes with `{ClassName}`.
-* Reference instance methods with `{ClassName::methodName}`.
-* Reference class methods with `{ClassName.methodName}`.
-* Delegate to comments elsewhere with `{Delegates to: ClassName.methodName}`
-  style notation.
+* Reference methods and classes in markdown with the custom `{}` notation:
+    * Reference classes with `{ClassName}`
+    * Reference instance methods with `{ClassName::methodName}`
+    * Reference class methods with `{ClassName.methodName}`
+    * Delegate to comments elsewhere with `{Delegates to: ClassName.methodName}`
+      style notation.
 
 ### Example
 

LICENSE

@@ -1 +0,0 @@
-Copyright 2014 GitHub, Inc.

LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2014 GitHub Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,8 +1,8 @@
-# Atom — The hackable editor
+![Atom](https://cloud.githubusercontent.com/assets/72919/2874231/3af1db48-d3dd-11e3-98dc-6066f8bc766f.png)
 
-![Atom](http://i.imgur.com/OrTvUAD.png)
+Atom is a hackable text editor for the 21st century, built on [atom-shell](http://github.com/atom/atom-shell), and based on everything we love about our favorite editors. We designed it to be deeply customizable, but still approachable using the default configuration.
 
-Check out our [guides and API documentation](https://atom.io/docs/latest).
+Visit [atom.io](https://atom.io) to learn more.
 
 ## Installing
 
@@ -12,6 +12,10 @@ Atom will automatically update when a new release is available.
 
 ## Building
 
-Follow the instructions in the [build docs][building].
+* [Linux](docs/build-instructions/linux.md)
+* [OS X](docs/build-instructions/os-x.md)
+* [FreeBSD](docs/build-instructions/freebsd.md)
+* [Windows](docs/build-instructions/windows.md)
 
-[building]: https://github.com/atom/atom/blob/master/docs/building-atom.md
+## Developing
+Check out the [guides](https://atom.io/docs/latest) and the [API reference](https://atom.io/docs/api).

apm/README.md

@@ -0,0 +1,2 @@
+This folder is where [apm](https://github.com/atom/apm) is installed to so that
+it is bundled with Atom.

apm/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "atom-bundled-apm",
+  "description": "Atom's bundled APM",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/atom/atom.git"
+  },
+  "dependencies": {
+    "atom-package-manager": "0.59.0"
+  }
+}

atom.sh

@@ -1,17 +1,17 @@
 #!/bin/bash
 
-if [ "`uname`" == 'Darwin' ]; then
+if [ "$(uname)" == 'Darwin' ]; then
   OS='Mac'
-elif [ "`expr substr $(uname -s) 1 5`" == 'Linux' ]; then
+elif [ "$(expr substr $(uname -s) 1 5)" == 'Linux' ]; then
   OS='Linux'
-elif [ "`expr substr $(uname -s) 1 10`" == 'MINGW32_NT' ]; then
+elif [ "$(expr substr $(uname -s) 1 10)" == 'MINGW32_NT' ]; then
   OS='Cygwin'
 else
-  echo "Your platform (`uname -a`) is not supported."
+  echo "Your platform ($(uname -a)) is not supported."
   exit 1
 fi
 
-while getopts ":wtfvhs-:" opt; do
+while getopts ":wtfvh-:" opt; do
   case "$opt" in
     -)
       case "${OPTARG}" in
@@ -66,17 +66,25 @@ if [ $OS == 'Mac' ]; then
     open -a "$ATOM_PATH/$ATOM_APP_NAME" -n --args --executed-from="$(pwd)" --pid=$$ "$@"
   fi
 elif [ $OS == 'Linux' ]; then
-  SCRIPT=`readlink -f "$0"`
-  USR_DIRECTORY=`readlink -f $(dirname $SCRIPT)/..`
+  SCRIPT=$(readlink -f "$0")
+  USR_DIRECTORY=$(readlink -f $(dirname $SCRIPT)/..)
   ATOM_PATH="$USR_DIRECTORY/share/atom/atom"
 
-  [ -x "$ATOM_PATH" ] || ATOM_PATH='/tmp/atom-build/Atom/atom'
+  : ${TMPDIR:=/tmp}
+
+  [ -x "$ATOM_PATH" ] || ATOM_PATH="$TMPDIR/atom-build/Atom/atom"
 
   if [ $EXPECT_OUTPUT ]; then
     "$ATOM_PATH" --executed-from="$(pwd)" --pid=$$ "$@"
     exit $?
   else
-    nohup "$ATOM_PATH" --executed-from="$(pwd)" --pid=$$ "$@" > /dev/null 2>&1 &
+    (
+    nohup "$ATOM_PATH" --executed-from="$(pwd)" --pid=$$ "$@" > "$TMPDIR/atom-nohup.out" 2>&1
+    if [ $? -ne 0 ]; then
+      cat "$TMPDIR/atom-nohup.out"
+      exit $?
+    fi
+    ) &
   fi
 fi
 

build/Gruntfile.coffee

@@ -36,40 +36,26 @@ module.exports = (grunt) ->
     grunt.log.write = (args...) -> grunt.log
 
   [major, minor, patch] = packageJson.version.split('.')
+  tmpDir = os.tmpdir()
+  appName = if process.platform is 'darwin' then 'Atom.app' else 'Atom'
+  buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
+  atomShellDownloadDir = path.join(os.tmpdir(), 'atom-cached-atom-shells')
+  symbolsDir = path.join(buildDir, 'Atom.breakpad.syms')
+  shellAppDir = path.join(buildDir, appName)
   if process.platform is 'win32'
-    appName = 'Atom'
-    tmpDir = os.tmpdir()
-    buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
-    symbolsDir = path.join(buildDir, 'Atom.breakpad.syms')
-    shellAppDir = path.join(buildDir, appName)
     contentsDir = shellAppDir
     appDir = path.join(shellAppDir, 'resources', 'app')
-    atomShellDownloadDir = path.join(os.tmpdir(), 'atom-cached-atom-shells')
     installDir = path.join(process.env.ProgramFiles, appName)
   else if process.platform is 'darwin'
-    appName = 'Atom.app'
-    tmpDir = '/tmp'
-    buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
-    symbolsDir = path.join(buildDir, 'Atom.breakpad.syms')
-    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('/Applications', appName)
   else
-    appName = 'Atom'
-    tmpDir = '/tmp'
-    buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
-    symbolsDir = path.join(buildDir, 'Atom.breakpad.syms')
-    shellAppDir = path.join(buildDir, appName)
     contentsDir = shellAppDir
     appDir = path.join(shellAppDir, 'resources', 'app')
-    atomShellDownloadDir = '/tmp/atom-cached-atom-shells'
     installDir = process.env.INSTALL_PREFIX ? '/usr/local'
 
   coffeeConfig =
-    options:
-      sourceMap: true
     glob_to_multiple:
       expand: true
       src: [

build/package.json

@@ -18,15 +18,17 @@
     "grunt-contrib-coffee": "~0.9.0",
     "grunt-contrib-less": "~0.8.0",
     "grunt-cson": "0.8.0",
-    "grunt-download-atom-shell": "git+https://atom-bot:467bac80a0017b96fb5be5cfc686f5e0cc607b10@github.com/atom/grunt-download-atom-shell#v0.6.1",
+    "grunt-download-atom-shell": "~0.7.2",
     "grunt-lesslint": "0.13.0",
     "grunt-markdown": "~0.4.0",
     "grunt-peg": "~1.1.0",
     "grunt-shell": "~0.3.1",
     "harmony-collections": "~0.3.8",
     "json-front-matter": "~0.1.3",
-    "legal-eagle": "~0.3.0",
-    "minidump": "0.5.x",
+    "legal-eagle": "~0.4.0",
+    "minidump": "~0.6",
+    "read-package-json": "1.1.8",
+    "normalize-package-data": "0.2.12",
     "rcedit": "~0.1.2",
     "request": "~2.27.0",
     "rimraf": "~2.2.2",

build/tasks/build-task.coffee

@@ -47,7 +47,9 @@ module.exports = (grunt) ->
       path.join('less', 'test')
       path.join('bootstrap', 'docs')
       path.join('bootstrap', 'examples')
-      path.join('spellchecker', 'vendor')
+      path.join('pegjs', 'examples')
+      # Add .* to avoid matching hunspell_dictionaries.
+      path.join('spellchecker', 'vendor', 'hunspell', '.*')
       path.join('xmldom', 'test')
       path.join('jasmine-reporters', 'ext')
       path.join('build', 'Release', 'obj.target')
@@ -56,6 +58,9 @@ module.exports = (grunt) ->
       path.join('resources', 'mac')
       path.join('resources', 'win')
     ]
+    # Hunspell dictionaries are only not needed on OS X.
+    if process.platform is 'darwin'
+      ignoredPaths.push path.join('spellchecker', 'vendor', 'hunspell_dictionaries')
     ignoredPaths = ignoredPaths.map (ignoredPath) -> "(#{ignoredPath})"
     nodeModulesFilter = new RegExp(ignoredPaths.join('|'))
     packageFilter = new RegExp("(#{ignoredPaths.join('|')})|(.+\\.(cson|coffee)$)")

build/tasks/clean-task.coffee

@@ -5,7 +5,7 @@ module.exports = (grunt) ->
   {rm} = require('./task-helpers')(grunt)
 
   grunt.registerTask 'partial-clean', 'Delete some of the build files', ->
-    tmpdir = if process.platform is 'win32' then os.tmpdir() else '/tmp'
+    tmpdir = os.tmpdir()
 
     rm grunt.config.get('atom.buildDir')
     rm require('../src/coffee-cache').cacheDir

build/tasks/docs-task.coffee

@@ -143,7 +143,7 @@ downloadFileFromRepo = ({repo, file}, callback) ->
 
 downloadIncludes = (callback) ->
   includes = [
-    {repo: 'atom-keymap', file: 'src/keymap.coffee'}
+    {repo: 'atom-keymap', file: 'src/keymap-manager.coffee'}
     {repo: 'atom-keymap', file: 'src/key-binding.coffee'}
     {repo: 'first-mate',  file: 'src/grammar.coffee'}
     {repo: 'first-mate',  file: 'src/grammar-registry.coffee'}

build/tasks/generate-license-task.coffee

@@ -17,7 +17,7 @@ module.exports = (grunt) ->
 
       licenseText = getLicenseText(dependencyLicenses)
       if mode is 'save'
-        targetPath = path.join(grunt.config.get('atom.appDir'), 'LICENSE')
+        targetPath = path.join(grunt.config.get('atom.appDir'), 'LICENSE.md')
         fs.writeFileSync(targetPath, licenseText)
       else
         console.log licenseText
@@ -26,7 +26,7 @@ module.exports = (grunt) ->
 getLicenseText = (dependencyLicenses) ->
   {keys} = require 'underscore-plus'
   text = """
-    Copyright 2014 GitHub, Inc.
+    #{fs.readFileSync('LICENSE.md', 'utf8')}
 
     This application bundles the following third-party packages in accordance
     with the following licenses:\n\n

build/tasks/install-task.coffee

@@ -1,4 +1,6 @@
+fs = require 'fs'
 path = require 'path'
+fs = require 'fs-plus'
 runas = null
 
 module.exports = (grunt) ->
@@ -28,3 +30,10 @@ module.exports = (grunt) ->
       rm shareDir
       mkdir path.dirname(shareDir)
       cp shellAppDir, shareDir
+
+      # Create relative symbol link for apm.
+      process.chdir(binDir)
+      rm('apm')
+      fs.symlinkSync(path.join('..', 'share', 'atom', 'resources', 'app', 'apm', 'node_modules', '.bin', 'apm'), 'apm')
+
+      fs.chmodSync(path.join(shareDir, 'atom'), "755")

build/tasks/mkdeb-task.coffee

@@ -16,7 +16,7 @@ module.exports = (grunt) ->
     {name, version, description} = grunt.file.readJSON('package.json')
     section = 'devel'
     arch = 'amd64'
-    maintainer = 'GitHub <support@github.com>'
+    maintainer = 'GitHub <atom@github.com>'
     data = {name, version, description, section, arch, maintainer}
 
     control = path.join('resources', 'linux', 'debian', 'control')

build/tasks/publish-build-task.coffee

@@ -29,21 +29,14 @@ module.exports = (gruntObject) ->
     done = @async()
     buildDir = grunt.config.get('atom.buildDir')
 
-    createBuildRelease (error, release) ->
+    zipApps buildDir, assets, (error) ->
       return done(error) if error?
-
-      zipApps buildDir, assets, (error) ->
+      getAtomDraftRelease (error, release) ->
         return done(error) if error?
-        uploadAssets release, buildDir, assets, (error) ->
+        assetNames = (asset.assetName for asset in assets)
+        deleteExistingAssets release, assetNames, (error) ->
           return done(error) if error?
-          publishRelease release, (error) ->
-            return done(error) if error?
-            getAtomDraftRelease (error, release) ->
-              return done(error) if error?
-              assetNames = (asset.assetName for asset in assets)
-              deleteExistingAssets release, assetNames, (error) ->
-                return done(error) if error?
-                uploadAssets(release, buildDir, assets, done)
+          uploadAssets(release, buildDir, assets, done)
 
 logError = (message, error, details) ->
   grunt.log.error(message)
@@ -64,25 +57,6 @@ zipApps = (buildDir, assets, callback) ->
     tasks.push(zip.bind(this, buildDir, sourceName, assetName))
   async.parallel(tasks, callback)
 
-getRelease = (callback) ->
-  options =
-    uri: 'https://api.github.com/repos/atom/atom-master-builds/releases'
-    method: 'GET'
-    headers: defaultHeaders
-    json: true
-  request options, (error, response, releases=[]) ->
-    if error? or response.statusCode isnt 200
-      logError('Fetching releases failed', error, releases)
-      callback(error ? new Error(response.statusCode))
-    else
-      if releases.length > maxReleases
-        deleteRelease(release) for release in releases[maxReleases..]
-
-      for release in releases when release.name is commitSha
-        callback(null, release)
-        return
-      callback()
-
 getAtomDraftRelease = (callback) ->
   atomRepo = new GitHub({repo: 'atom/atom', token})
   atomRepo.getReleases (error, releases=[]) ->
@@ -125,35 +99,6 @@ deleteExistingAssets = (release, assetNames, callback) ->
     tasks.push(deleteAsset.bind(this, asset.url))
   async.parallel(tasks, callback)
 
-createBuildRelease = (callback) ->
-  getRelease (error, release) ->
-    if error?
-      callback(error)
-      return
-
-    if release?
-      deleteExistingAssets release, (error) ->
-        callback(error, release)
-      return
-
-    options =
-      uri: 'https://api.github.com/repos/atom/atom-master-builds/releases'
-      method: 'POST'
-      headers: defaultHeaders
-      json:
-        tag_name: "v#{commitSha}"
-        target_commitish: 'master'
-        name: commitSha
-        body: "Build of [atom@#{commitSha.substring(0, 7)}](https://github.com/atom/atom/commits/#{commitSha})"
-        draft: true
-        prerelease: true
-    request options, (error, response, release={}) ->
-      if error? or response.statusCode isnt 201
-        logError('Creating release failed', error, release)
-        callback(error ? new Error(response.statusCode))
-      else
-        callback(null, release)
-
 uploadAssets = (release, buildDir, assets, callback) ->
   upload = (release, assetName, assetPath, callback) ->
     options =
@@ -178,17 +123,3 @@ uploadAssets = (release, buildDir, assets, callback) ->
     assetPath = path.join(buildDir, assetName)
     tasks.push(upload.bind(this, release, assetName, assetPath))
   async.parallel(tasks, callback)
-
-publishRelease = (release, callback) ->
-  options =
-    uri: release.url
-    method: 'POST'
-    headers: defaultHeaders
-    json:
-      draft: false
-  request options, (error, response, body={}) ->
-    if error? or response.statusCode isnt 200
-      logError('Creating release failed', error, body)
-      callback(error ? new Error(response.statusCode))
-    else
-      callback()

build/tasks/publish-packages.coffee

@@ -1,108 +0,0 @@
-async = require 'async'
-request = require 'request'
-
-# Configure and publish all packages in package.json to atom.io
-#
-# This task should be run whenever you want to be sure that atom.io contains
-# all the packages and versions referenced in Atom's package.json file.
-module.exports = (grunt) ->
-  {spawn} = require('./task-helpers')(grunt)
-
-  baseUrl = "https://atom.io/api/packages"
-
-  packageExists = (packageName, token, callback) ->
-    requestSettings =
-      url: "#{baseUrl}/#{packageName}"
-      json: true
-      headers:
-        authorization: token
-    request.get requestSettings, (error, response, body={}) ->
-      if error?
-        callback(error)
-      else
-        callback(null, response.statusCode is 404)
-
-  createPackage = (packageName, token, callback) ->
-    requestSettings =
-      url: baseUrl
-      json: true
-      headers:
-        authorization: token
-      method: 'POST'
-      body:
-        repository: "atom/#{packageName}"
-
-    request.get requestSettings, (error, response, body={}) ->
-      if error?
-        callback(error)
-      else if response.statusCode isnt 201
-        message = body.message ? body.error ? body
-        callback(new Error("Creating package failed: #{message}"))
-      else
-        callback()
-
-  createPackageVersion = (packageName, tag, token, callback) ->
-    requestSettings =
-      url: "#{baseUrl}/#{packageName}/versions"
-      json: true
-      method: 'POST'
-      headers:
-        authorization: token
-      body:
-        tag: tag
-
-    request.get requestSettings, (error, response, body={}) ->
-      if error?
-        callback(error)
-      else if response.statusCode isnt 201
-        message = body.message ? body.error ? body
-        if message is 'Version exists'
-          callback()
-        else
-          callback(new Error("Creating new version failed: #{message}"))
-      else
-        callback()
-
-  getToken = (callback) ->
-    if token = process.env.ATOM_ACCESS_TOKEN
-      callback(null, token)
-    else
-      spawn {cmd: 'security', args: ['-q', 'find-generic-password', '-ws', 'GitHub API Token']}, (error, result, code) ->
-        token = result.toString() unless error?
-        callback(error, token)
-
-  grunt.registerTask 'publish-packages', 'Publish all bundled packages', ->
-    done = @async()
-
-    getToken (error, token) ->
-      unless token
-        grunt.log.error('Token not found in keychain or ATOM_ACCESS_TOKEN environment variable')
-        done(false)
-
-      {packageDependencies} = grunt.file.readJSON('package.json') ? {}
-      tasks = []
-      for name, version of packageDependencies
-        do (name, version) ->
-          tasks.push (callback) ->
-            grunt.verbose.writeln("Publishing #{name}@#{version}")
-            tag = "v#{version}"
-            packageExists name, token, (error, exists) ->
-              if error?
-                callback(error)
-                return
-
-              if exists
-                createPackage name, token, (error) ->
-                  if error?
-                    callback(error)
-                  else
-                    createPackageVersion(name, tag, token, callback)
-              else
-                createPackageVersion(name, tag, token, callback)
-
-      async.waterfall tasks, (error) ->
-        if error?
-          grunt.log.error(error.message)
-          done(false)
-        else
-          done()

build/tasks/set-version-task.coffee

@@ -5,14 +5,18 @@ module.exports = (grunt) ->
   {spawn} = require('./task-helpers')(grunt)
 
   getVersion = (callback) ->
-    if process.env.JANKY_SHA1 and process.env.JANKY_BRANCH is 'master'
-      {version} = require(path.join(grunt.config.get('atom.appDir'), 'package.json'))
+    onBuildMachine = process.env.JANKY_SHA1 and process.env.JANKY_BRANCH is 'master'
+    inRepository = fs.existsSync(path.resolve(__dirname, '..', '..', '.git'))
+    {version} = require(path.join(grunt.config.get('atom.appDir'), 'package.json'))
+    if onBuildMachine or not inRepository
       callback(null, version)
     else
       cmd = 'git'
       args = ['rev-parse', '--short', 'HEAD']
       spawn {cmd, args}, (error, {stdout}={}, code) ->
-        callback(error, stdout?.trim?())
+        commitHash = stdout?.trim?()
+        combinedVersion = "#{version}-#{commitHash}"
+        callback(error, combinedVersion)
 
   grunt.registerTask 'set-version', 'Set the version in the plist and package.json', ->
     done = @async()

docs/README.md

@@ -1,6 +1,6 @@
 # Welcome to the Atom API Documentation
 
-![Atom](http://i.imgur.com/OrTvUAD.png)
+![Atom](https://cloud.githubusercontent.com/assets/72919/2874231/3af1db48-d3dd-11e3-98dc-6066f8bc766f.png)
 
 ## FAQ
 

docs/advanced/keymaps.md

@@ -10,8 +10,8 @@ keystrokes pass through elements with the class `.editor`:
 
 ```coffee
 '.editor':
-  'cmd-delete': 'editor:backspace-to-beginning-of-line'
-  'alt-backspace': 'editor:backspace-to-beginning-of-word'
+  'cmd-delete': 'editor:delete-to-beginning-of-line'
+  'alt-backspace': 'editor:delete-to-beginning-of-word'
   'ctrl-A': 'editor:select-to-first-character-of-line'
   'ctrl-shift-e': 'editor:select-to-end-of-line'
   'cmd-left': 'editor:move-to-first-character-of-line'
@@ -24,7 +24,7 @@ keystrokes pass through elements with the class `.editor`:
 Beneath the first selector are several bindings, mapping specific *keystroke
 patterns* to *commands*. When an element with the `.editor` class is focused and
 `cmd-delete` is pressed, an custom DOM event called
-`editor:backspace-to-beginning-of-line` is emitted on the `.editor` element.
+`editor:delete-to-beginning-of-line` is emitted on the `.editor` element.
 
 The second selector group also targets editors, but only if they don't have the
 `.mini` class. In this example, the commands for code folding don't really make
@@ -83,6 +83,22 @@ file. For now, we've opted to handle cases where selector ordering is critical
 by breaking the keymap into two separate files, such as `snippets-1.cson` and
 `snippets-2.cson`.
 
+## Removing Bindings
+
+When the keymap system encounters a binding with the `unset!` directive as its
+command, it will treat the current element as if it had no key bindings matching
+the current keystroke sequence and continue searching from its parent. If you
+want to remove a binding from a keymap you don't control, such as keymaps in
+Atom core or in packages, use the `unset!` directive.
+
+## Forcing Chromium's Native Keystroke Handling
+
+If you want to force the native browser behavior for a given keystroke, use the
+`native!` directive as the command of a binding. This can be useful to enable
+the correct behavior in native input elements, for example. If you apply the
+`.native-key-bindings` class to an element, all the keystrokes typically handled
+by the browser will be assigned the `native!` directive.
+
 ## Overloading Key Bindings
 
 Occasionally, it makes sense to layer multiple actions on top of the same key

docs/advanced/node-modules.md

@@ -0,0 +1,24 @@
+## Developing Node Modules
+
+Atom contains a number of packages that are Node modules instead of Atom packages. If you want to
+make changes to the Node modules, for instance `atom-keymap`, you have to link them into the
+development environment differently than you would a normal Atom package.
+
+### Linking a Node Module Into Your Atom Dev Environment
+
+Here are the steps to run a local version of a node module *not an apm* within Atom. We're using
+`atom-keymap` as an example:
+
+```bash
+$ git clone https://github.com/atom/atom-keymap.git
+$ cd atom-keymap
+$ npm install
+$ npm link
+$ apm rebuild # This is the special step, it makes the npm work with Atom's version of Node
+$ cd WHERE-YOU-CLONED-ATOM
+$ npm link atom-keymap
+$ atom # Should work!
+```
+
+After this, you'll have to `npm install` and `apm rebuild` when you make a change to the node
+module's code.

docs/apm-rest-api.md

@@ -0,0 +1,189 @@
+## Atom.io package and update API
+
+This guide describes the web API used by [apm](https://github.com/atom/apm) and
+Atom. The vast majority of use cases are met by the `apm` command-line tool,
+which does other useful things like incrementing your version in `package.json`
+and making sure you have pushed your git tag. In fact, Atom itself shells out to
+`apm` rather than hitting the API directly. If you're curious about how Atom
+uses `apm`, see the [PackageManager class](https://github.com/atom/settings-view/blob/master/lib/package-manager.coffee)
+in the `settings-view` package.
+
+### Authorization
+
+For calls to the API that require authentication, provide a valid token from your
+[Atom.io account page](https://atom.io/account) in the `Authorization` header.
+
+### Media type
+
+All requests that take parameters require `application/json`.
+
+## Resources
+
+### Packages
+
+#### GET /api/packages
+
+Returns a list of all packages in the following format:
+```json
+  [
+    {
+      "releases": {
+        "latest": "0.6.0"
+      },
+      "name": "thedaniel-test-package",
+      "repository": {
+        "type": "git",
+        "url": "https://github.com/thedaniel/test-package"
+      }
+    },
+    ...
+  ]
+```
+
+#### GET /api/packages/:package_name
+
+Returns package details and versions for a single package
+
+Parameters:
+
+- **engine** (optional) - Only show packages with versions compatible with this
+  Atom version. Must be valid [SemVer](http://semver.org).
+
+Returns:
+
+```json
+  {
+    "releases": {
+      "latest": "0.6.0"
+    },
+    "name": "thedaniel-test-package",
+    "repository": {
+      "type": "git",
+      "url": "https://github.com/thedaniel/test-package"
+    },
+    "versions": [
+      (see single version output below)
+      ...,
+    ]
+  }
+```
+
+#### POST /api/packages
+
+Create a new package; requires authentication.
+
+The name and version will be fetched from the `package.json`
+file in the specified repository. The authenticating user *must* have access
+to the indicated repository.
+
+When a package is created, a release hook is registered with GitHub for package
+version creation.
+
+Parameters:
+
+- **repository** - String. The repository containing the plugin, in the form "owner/repo"
+
+Returns:
+
+- **201** - Successfully created, returns created package.
+- **400** - Repository is inaccessible, nonexistent, not an atom package. Possible
+  error messages include:
+  - That repo does not exist, isn't an atom package, or atombot does not have access
+  - The package.json at owner/repo isn't valid
+- **409** - A package by that name already exists
+
+
+#### DELETE /api/packages/:package_name
+
+Delete a package; requires authentication.
+
+Returns:
+
+- **204** - Success
+- **400** - Repository is inaccessible
+- **401** - Unauthorized
+
+### Package Versions
+
+#### GET /api/packages/:package_name/versions/:version_name
+
+Returns `package.json` with `dist` key added for e.g. tarball download:
+
+```json
+  {
+    "bugs": {
+      "url": "https://github.com/thedaniel/test-package/issues"
+    },
+    "dependencies": {
+      "async": "~0.2.6",
+      "pegjs": "~0.7.0",
+      "season": "~0.13.0"
+    },
+    "description": "Expand snippets matching the current prefix with `tab`.",
+    "dist": {
+      "tarball": "https://codeload.github.com/..."
+    },
+    "engines": {
+      "atom": "*"
+    },
+    "main": "./lib/snippets",
+    "name": "thedaniel-test-package",
+    "publishConfig": {
+      "registry": "https://...",
+    },
+    "repository": {
+      "type": "git",
+      "url": "https://github.com/thedaniel/test-package.git"
+    },
+    "version": "0.6.0"
+  }
+```
+
+
+### Creating a new package version
+
+#### POST /api/packages/:package_name/versions
+
+Creates a new package version from a git tag; requires authentication.
+
+#### Parameters
+
+- **tag** - A git tag for the version you'd like to create. It's important to note
+  that the version name will not be taken from the tag, but from the `version`
+  key in the `package.json` file at that ref. The authenticating user *must* have
+  access to the package repository.
+
+#### Returns
+
+- **201** - Successfully created. Returns created version.
+- **400** - Git tag not found / Repository inaccessible
+- **409** - Version exists
+
+### Delete a version
+
+#### DELETE /api/packages/:package_name/versions/:version_name
+
+Deletes a package version; requires authentication.
+
+Note that a version cannot be republished with a different tag if it is deleted.
+If you need to delete the latest version of a package for e.g. security reasons,
+you'll need to increment the version when republishing.
+
+Returns 204 No Content
+
+### Atom updates
+
+#### GET /api/updates
+
+Atom update feed, following the format expected by [Squirrel](https://github.com/Squirrel/).
+
+Returns:
+
+```
+{
+    "name": "0.96.0",
+    "notes": "[HTML release notes]"
+    "pub_date": "2014-05-19T15:52:06.000Z",
+    "url": "https://www.atom.io/api/updates/download"
+}
+```

docs/build-instructions/freebsd.md

@@ -0,0 +1,22 @@
+# FreeBSD
+
+FreeBSD -RELEASE 64-bit is the recommended platform.
+
+## Requirements
+
+  * FreeBSD
+  * `pkg install node`
+  * `pkg install npm`
+  * `pkg install libgnome-keyring`
+  * `npm config set python /usr/local/bin/python2 -g` to ensure that gyp uses Python 2
+
+## Instructions
+
+  ```sh
+  git clone https://github.com/atom/atom
+  cd atom
+  script/build # Creates application at $TMPDIR/atom-build/Atom
+  sudo script/grunt install # Installs command to /usr/local/bin/atom
+  ```
+
+## Troubleshooting

docs/build-instructions/linux.md

@@ -0,0 +1,49 @@
+# Linux
+
+Ubuntu LTS 12.04 64-bit is the recommended platform.
+
+## Requirements
+
+  * OS with 64-bit architecture
+  * [node.js](http://nodejs.org/download/) v0.10.x
+  * [npm](http://www.npmjs.org/) v1.4.x  
+  * libgnome-keyring-dev `sudo apt-get install libgnome-keyring-dev` (refer to your distribution's manual on how to install packages if you are not on Debian or Ubuntu-based systems)
+  * `npm config set python /usr/bin/python2 -g` to ensure that gyp uses Python 2
+
+
+## Instructions
+
+  ```sh
+  git clone https://github.com/atom/atom
+  cd atom
+  script/build # Creates application at $TMPDIR/atom-build/Atom
+  sudo script/grunt install # Installs command to /usr/local/bin/atom
+  script/grunt mkdeb # Generates a .deb package at $TMPDIR/atom-build
+  ```
+
+
+## Troubleshooting
+
+
+### Exception: "TypeError: Unable to watch path"
+
+If you get following error with a big traceback right after Atom starts:
+
+  ```
+  TypeError: Unable to watch path
+  ```
+
+you have to increase number of watched files by inotify.  For testing if
+this is the reason for this error you can issue
+
+  ```sh
+  sudo sysctl fs.inotify.max_user_watches=32768
+  ```
+
+and restart Atom.  If Atom now works fine, you can make this setting permanent:
+
+  ```sh
+  echo 32768 > /proc/sys/fs/inotify/max_user_watches
+  ```
+
+See also https://github.com/atom/atom/issues/2082.

docs/build-instructions/os-x.md

@@ -0,0 +1,17 @@
+# OS X
+
+## Requirements
+
+  * OS X 10.8 or later
+  * [node.js](http://nodejs.org/download/) v0.10.x
+  * Command Line Tools for [Xcode](https://developer.apple.com/xcode/downloads/) (run `xcode-select --install` to install)
+
+## Instructions
+
+  ```sh
+  git clone https://github.com/atom/atom
+  cd atom
+  script/build # Creates application at /Applications/Atom.app
+  ```
+
+## Troubleshooting

docs/build-instructions/windows.md

@@ -0,0 +1,46 @@
+# Windows
+
+## Requirements
+
+### On Windows 7
+  * [Visual C++ 2010 Express](http://www.visualstudio.com/en-us/downloads/download-visual-studio-vs#DownloadFamilies_4)
+  * [Visual Studio 2010 Service Pack 1](http://www.microsoft.com/en-us/download/details.aspx?id=23691)
+  * [node.js](http://nodejs.org/download/) v0.10.x
+    * For 64-bit builds of node and native modules you **must** have the
+    [Windows 7 64-bit SDK](http://www.microsoft.com/en-us/download/details.aspx?id=8279).
+    You may also need the [compiler update for the Windows SDK 7.1](http://www.microsoft.com/en-us/download/details.aspx?id=4422)
+
+  * [Python](http://www.python.org/download/) v2.7.x
+  * [GitHub for Windows](http://windows.github.com/)
+
+### On Windows 8
+  * [Visual Studio Express 2013 for Windows Desktop](http://www.visualstudio.com/en-us/downloads/download-visual-studio-vs#DownloadFamilies_2)
+  * [node.js](http://nodejs.org/download/) v0.10.x
+  * [Python](http://www.python.org/download/) v2.7.x (required by [node-gyp](https://github.com/TooTallNate/node-gyp))
+  * [GitHub for Windows](http://windows.github.com/)
+
+## Instructions
+
+  ```bat
+  # Use the `Git Shell` app which was installed by GitHub for Windows. Also Make
+  # sure you have logged into the GitHub for Windows GUI App.
+  cd C:\
+  git clone https://github.com/atom/atom/
+  cd atom
+  script/build # Creates application in the `Program Files` directory
+  ```
+
+## Why do I have to use GitHub for Windows?
+
+You don't, You can use your existing Git! GitHub for Windows's Git Shell is just
+easier to set up. You need to have Posix tools in your `%PATH%` (i.e. `grep`,
+`sed`, et al.), which isn't the default configuration when you install Git. To
+fix this, you probably need to fiddle with your system PATH.
+
+## Troubleshooting
+
+### Common Errors
+* `node is not recognized`
+
+  * If you just installed node you need to restart your computer before node is
+  available on your Path.

docs/contributing-to-packages.md

@@ -0,0 +1,52 @@
+# Contributing to Official Atom Packages
+
+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.
+
+## Hacking on Packages
+
+### Cloning
+
+The first step is creating your own clone. You can of course do this manually
+with git, or you can use the `apm develop` command to create a clone based on
+the package's `repository` field in the `package.json`.
+
+For example, if you want to make changes to the `tree-view` package, run the
+following command:
+
+```
+> apm develop tree-view
+Cloning https://github.com/atom/tree-view ✓
+Installing modules ✓
+~/.atom/dev/packages/tree-view -> ~/github/tree-view
+```
+
+This clones the `tree-view` repository to `~/github`. If you prefer a different
+path, specify it via the `ATOM_REPOS_HOME` environment variable.
+
+### Running in Development Mode
+
+Editing a package in Atom is a bit of a circular experience: you're using Atom
+to modify itself. What happens if you temporarily break something? You don't
+want the version of Atom you're using to edit to become useless in the process.
+For this reason, you'll only want to load packages in **development mode** while
+you are working on them. You'll perform your editing in **stable mode**, only
+switching to development mode to test your changes.
+
+To open a development mode window, use the "Application: Open Dev" command,
+which is normally bound to `cmd-shift-o`. You can also run dev mode from the
+command line with `atom --dev`.
+
+To load your package in development mode, create a symlink to it in
+`~/.atom/dev/packages`. This occurs automatically when you clone the package
+with `apm develop`. You can also run `apm link --dev` and `apm unlink --dev`
+from the package directory to create and remove dev-mode symlinks.
+
+### Installing Dependencies
+
+Finally, you need to install the cloned package's dependencies by running
+`apm install` within the package directory. This step is also performed
+automatically the first time you run `apm develop`, but you'll want to keep
+dependencies up to date by running `apm update` after pulling upstream changes.

docs/contributing.md

@@ -1,142 +0,0 @@
-# Contributing to Atom Packages
-
-The following is a set of guidelines for contributing to Atom packages, which
-are hosted in the [Atom Organization](https://github.com/atom) on GitHub. If
-you're unsure which package is causing your problem or if you're having an issue
-with Atom core, please use the feedback form in the application or email
-[atom@github.com](mailto:atom@github.com).
-
-## Submitting Issues
-
-* Include screenshots and animated GIFs whenever possible; they are immensely
-  helpful.
-* Include the behavior you expected and other places you've seen that behavior
-  such as Emacs, vi, Xcode, etc.
-* Check the dev tools (`alt-cmd-i`) for errors and stack traces to include.
-* Check Console.app for stack traces to include if reporting a crash.
-* Perform a cursory search to see if a similar issue has already been submitted.
-
-## Hacking on Packages
-
-### Cloning
-
-The first step is creating your own clone. You can of course do this manually
-with git, or you can use the `apm develop` command to create a clone based on
-the package's `repository` field in the `package.json`.
-
-For example, if you want to make changes to the `tree-view` package, run the
-following command:
-
-```
-> apm develop tree-view
-Cloning https://github.com/atom/tree-view ✓
-Installing modules ✓
-~/.atom/dev/packages/tree-view -> ~/github/tree-view
-```
-
-This clones the `tree-view` repository to `~/github`. If you prefer a different
-path, specify it via the `ATOM_REPOS_HOME` environment variable.
-
-### Running in Development Mode
-
-Editing a package in Atom is a bit of a circular experience: you're using Atom
-to modify itself. What happens if you temporarily break something? You don't
-want the version of Atom you're using to edit to become useless in the process.
-For this reason, you'll only want to load packages in **development mode** while
-you are working on them. You'll perform your editing in **stable mode**, only
-switching to development mode to test your changes.
-
-To open a development mode window, use the "Application: Open Dev" command,
-which is normally bound to `cmd-shift-o`. You can also run dev mode from the
-command line with `atom --dev`.
-
-To load your package in development mode, create a symlink to it in
-`~/.atom/dev/packages`. This occurs automatically when you clone the package
-with `apm develop`. You can also run `apm link --dev` and `apm unlink --dev`
-from the package directory to create and remove dev-mode symlinks.
-
-### Installing Dependencies
-
-Finally, you need to install the cloned package's dependencies by running
-`apm install` within the package directory. This step is also performed
-automatically the first time you run `apm develop`, but you'll want to keep
-dependencies up to date by running `apm update` after pulling upstream changes.
-
-## Submitting Pull Requests
-
-### Code Guidelines
-
-* Include screenshots and animated GIFs in your pull request whenever possible.
-* Follow the [CoffeeScript](#coffeescript-styleguide),
-  [JavaScript](https://github.com/styleguide/javascript),
-  and [CSS](https://github.com/styleguide/css) styleguides.
-* Include thoughtfully-worded, well-structured
-  [Jasmine](http://pivotal.github.com/jasmine) specs.
-* Document new code based on the
-  [Documentation Styleguide](#documentation-styleguide)
-* End files with a newline.
-* Place requires 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)
-* Place class properties in the following order:
-  * Class methods and properties (methods starting with a `@`)
-  * Instance methods and properties
-* Avoid platform-dependent code:
-  * Use `require('atom').fs.getHomeDirectory()` to get the home directory.
-  * Use `path.join()` to concatenate filenames.
-  * Use `os.tmpdir()` rather than `/tmp` when you need to reference the
-    temporary directory.
-
-### Commit Message Guidelines
-  * Use the present tense ("Add feature" not "Added feature")
-  * Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
-  * Limit the first line to 72 characters or less
-  * 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
-    * :bulb: Check out the [Emoji Cheat Sheet](http://www.emoji-cheat-sheet.com)
-      for more ideas.
-
-## CoffeeScript Styleguide
-
-* Use parentheses if it improves code clarity.
-* Prefer alphabetic keywords to symbolic keywords:
-  * `a is b` instead of `a == b`
-* Avoid spaces inside the curly-braces of hash literals:
-  * `{a: 1, b: 2}` instead of `{ a: 1, b: 2 }`
-* Set parameter defaults without spaces around the equal sign:
-  * `clear = (count=1) ->` instead of `clear = (count = 1) ->`
-* Include a single line of whitespace between methods.
-
-## Documentation Styleguide
-
-* Use [TomDoc](http://tomdoc.org).
-* Use [Markdown](https://daringfireball.net/projects/markdown).
-* Reference methods and classes in markdown with the custom `{}` notation:
-  * Reference classes with `{ClassName}`
-  * Reference instance methods with `{ClassName::methodName}`
-  * Reference class methods with `{ClassName.methodName}`
-
-### Example
-
-```coffee
-# Public: Disable the package with the given name.
-#
-# This method emits multiple events:
-#
-# * `package-will-be-disabled` - before the package is disabled.
-# * `package-disabled`         - after the package is disabled.
-#
-# name     - The {String} name of the package to disable.
-# options  - The {Object} with disable options (default: {}):
-#   :trackTime - `true` to track the amount of time disabling took.
-#   :ignoreErrors - `true` to catch and ignore errors thrown.
-# callback - The {Function} to call after the package has been disabled.
-#
-# Returns `undefined`.
-disablePackage: (name, options, callback) ->
-```

docs/contributing.md

@@ -0,0 +1 @@
+../CONTRIBUTING.md

docs/converting-a-text-mate-bundle.md

@@ -20,7 +20,7 @@ apm help init
 
 You should see a message print out with details about the `apm init` command.
 
-If you do not, launch Atom and run the _Atom > Install Shell Commmands_ menu
+If you do not, launch Atom and run the _Atom > Install Shell Commands_ menu
 to install the `apm` and `atom` commands.
 
 ### Convert the Package
@@ -49,4 +49,4 @@ the editor to see it in action!
 [plist]: http://en.wikipedia.org/wiki/Property_list
 [R]: http://en.wikipedia.org/wiki/R_(programming_language)
 [TextMate]: http://macromates.com
-[TextMateOrg]: https://github.com/textmate/r.tmbundle
+[TextMateOrg]: https://github.com/textmate

docs/converting-a-text-mate-theme.md

@@ -25,7 +25,7 @@ apm help init
 
 You should see a message print out with details about the `apm init` command.
 
-If you do not, launch Atom and run the _Atom > Install Shell Commmands_ menu
+If you do not, launch Atom and run the _Atom > Install Shell Commands_ menu
 to install the `apm` and `atom` commands.
 
 You can now run `apm help init` to see all the options for initializing new

docs/customizing-atom.md

@@ -34,7 +34,7 @@ apm help install
 
 You should see a message print out with details about the `apm install` command.
 
-If you do not, launch Atom and run the _Atom > Install Shell Commmands_ menu
+If you do not, launch Atom and run the _Atom > Install Shell Commands_ menu
 to install the `apm` and `atom` commands.
 
 You can also install packages by using the `apm install` command:

docs/getting-started.md

@@ -73,7 +73,7 @@ from.
 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 its
-editors with `meta-w`, then press `meta-w` one more time to close the pane. You
+editors with `cmd-w`, then press `cmd-w` one more time to close the pane. You
 can configure panes to auto-close when empty in the Settings view.
 
 ### Folding

docs/index.md

@@ -5,6 +5,7 @@
 * [Creating a Package](creating-a-package.md)
 * [Creating a Theme](creating-a-theme.md)
 * [Publishing a Package](publishing-a-package.md)
+* [Writing Specs](writing-specs.md)
 * [Converting a TextMate Bundle](converting-a-text-mate-bundle.md)
 * [Converting a TextMate Theme](converting-a-text-mate-theme.md)
 * [Contributing](contributing.md)
@@ -12,6 +13,7 @@
 ### Advanced Topics
 
 * [Configuration](advanced/configuration.md)
+* [Developing Node Modules](advanced/node-modules.md)
 * [Keymaps](advanced/keymaps.md)
 * [Serialization](advanced/serialization.md)
 * [View System](advanced/view-system.md)

docs/publishing-a-package.md

@@ -7,7 +7,7 @@ Publishing a package allows other people to install it and use it in Atom. It
 is a great way to share what you've made and get feedback and contributions from
 others.
 
-This guide assumes your package's name is `my-package` and but you should pick a
+This guide assumes your package's name is `my-package` but you should pick a
 better name.
 
 ### Install apm
@@ -24,7 +24,7 @@ apm help publish
 
 You should see a message print out with details about the `apm publish` command.
 
-If you do not, launch Atom and run the _Atom > Install Shell Commmands_ menu
+If you do not, launch Atom and run the _Atom > Install Shell Commands_ menu
 to install the `apm` and `atom` commands.
 
 ### Prepare Your Package
@@ -42,7 +42,7 @@ If not, there are a few things you should check before publishing:
   * Your package is in a Git repository that has been pushed to
     [GitHub][github]. Follow [this guide][repo-guide] if your package isn't
     already on GitHub.
-  
+
 ### Publish Your Package
 
 Before you publish a package it is a good idea to check ahead of time if
@@ -59,7 +59,7 @@ Now let's review what the `apm publish` command does:
   3. Creates a new [Git tag][git-tag] for the version being published.
   4. Pushes the tag and current branch up to GitHub.
   5. Updates atom.io with the new version being published.
-  
+
 Now run the following commands to publish your package:
 
 ```sh
@@ -75,18 +75,34 @@ credentials are stored securely in your [keychain][keychain] once you login.
 :tada: Your package is now published and available on atom.io. Head on over to
 `http://atom.io/packages/my-package` to see your package's page.
 
+With `apm publish`, you can bump the version and publish by using
+```sh
+apm publish <version-type>
+```
+where `<version-type>` can be `major`, `minor` and `patch`.
+
+The `major` option to the publish command tells apm to increment the first
+digit of the version before publishing so the published version will be `1.0.0`
+and the Git tag created will be `v1.0.0`.
+
 The `minor` option to the publish command tells apm to increment the second
 digit of the version before publishing so the published version will be `0.1.0`
 and the Git tag created will be `v0.1.0`.
 
-In the future you can run `apm publish major` to publish the `1.0.0` version but
-since this was the first version being published it is a good idead to start
-with a minor release.
+The `patch` option to the publish command tells apm to increment the third
+digit of the version before publishing so the published version will be `0.0.1`
+and the Git tag created will be `v0.0.1`.
+
+Use `major` when you make a huge change, like a rewrite, or a large change to the functionality or interface.
+Use `minor` when adding or removing a feature.
+Use `patch` when you make a small change like a bug fix that does not add or remove features.
 
 ### Further Reading
 
 * Check out [semantic versioning][semver] to learn more about versioning your
   package releases.
+* Consult the [Atom.io package API docs][apm-rest-api] to learn more about how
+  `apm` works.
 
 [atomio]: https://atom.io
 [github]: https://github.com
@@ -95,3 +111,4 @@ with a minor release.
 [repo-guide]: http://guides.github.com/overviews/desktop
 [semver]: http://semver.org
 [your-first-package]: your-first-package.html
+[apm-rest-api]: apm-rest-api.md

docs/writing-specs.md

@@ -0,0 +1,61 @@
+# Writing specs
+
+Atom uses [Jasmine](http://jasmine.github.io/2.0/introduction.html) as its spec framework. Any new functionality should have specs to guard against regressions.
+
+## Create a new spec
+
+[Atom specs](https://github.com/atom/atom/tree/master/spec) and [package specs](https://github.com/atom/markdown-preview/tree/master/spec) are added to their respective `spec` directory. The example below creates a spec for Atom core.
+
+0. Create a spec file
+
+  Spec files **must** end with `-spec` so add `sample-spec.coffee` to `atom/spec`.
+
+0. Add one or more `describe` methods
+
+  The `describe` method takes two arguments, a description and a function. If the description explains a behavior it typically begins with `when` if it is more like a unit test it begins with the method name.
+
+  ```coffee
+  describe "when a test is written", ->
+    # contents
+  ```
+
+  or
+
+  ```coffee
+  describe "Editor::moveUp", ->
+    # contents
+  ```
+
+0. Add one or more `it` method
+
+  The `it` method also takes two arguments, a description and a function. Try and make the description flow with the `it` method. For example, a description of `this should work` doesn't read well as `it this should work`. But a description of `should work` sounds great as `it should work`.
+
+  ```coffee
+  describe "when a test is written", ->
+    it "has some expectations that should pass", ->
+      # Expectations
+  ```
+
+0. Add one or more expectations
+
+  The best way to learn about expectations is to read the [jasmine documentation](http://jasmine.github.io/2.0/introduction.html#section-Expectations) about them. Below is a simple example.
+
+  ```coffee
+  describe "when a test is written", ->
+    it "has some expectations that should pass", ->
+      expect("apples").toEqual("apples")
+      expect("oranges").not.toEqual("apples")
+  ```
+
+## Running specs
+
+Most of the time you'll want to run specs by triggering the `window:run-package-specs` command. This command is not only to run package specs, it is also for Atom core specs. This will run all the specs in the current project's spec directory. If you want to run the Atom core specs and **all** the default package specs trigger the `window:run-all-specs` command.
+
+To run a limited subset of specs use the `fdescribe` or `fit` methods. You can use those to focus a single spec or several specs. In the example above, focusing an individual spec looks like this:
+
+```coffee
+describe "when a test is written", ->
+  fit "has some expectations that should pass", ->
+    expect("apples").toEqual("apples")
+    expect("oranges").not.toEqual("apples")
+```

docs/your-first-package.md

@@ -21,7 +21,7 @@ To begin, press `cmd-shift-P` to bring up the [Command
 Palette](https://github.com/atom/command-palette). Type "generate package" and
 select the "Package Generator: Generate Package" command. Now we need to name
 the package. Try to avoid naming your package with the *atom-* prefix, for
-example we are going to call this package _ascii-art_. 
+example we are going to call this package _ascii-art_.
 
 Atom will open a new window with the contents of our new _ascii-art_ package
 displayed in the Tree View. Because this window is opened **after** the package
@@ -149,8 +149,10 @@ ASCII art professional!
 
 * [Getting your project on GitHub guide](http://guides.github.com/overviews/desktop)
 
+* [Writing specs](writing-specs.md) for your package
+
 * [Creating a package guide](creating-a-package.html) for more information
   on the mechanics of packages
 
-* [Publishing a package guide](publish-a-package.html) for more information
+* [Publishing a package guide](publishing-a-package.html) for more information
   on publishing your package to [atom.io](https://atom.io)

dot-atom/.gitignore

@@ -0,0 +1,5 @@
+storage
+compile-cache
+dev
+.npm
+.node-gyp

keymaps/base.cson

@@ -1,17 +1,10 @@
 '.editor':
   # Platform Bindings
-  'alt-left': 'editor:move-to-beginning-of-word'
-  'alt-right': 'editor:move-to-end-of-word'
-  'alt-shift-left': 'editor:select-to-beginning-of-word'
-  'alt-shift-right': 'editor:select-to-end-of-word'
   'home': 'editor:move-to-first-character-of-line'
   'end': 'editor:move-to-end-of-screen-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'
@@ -19,10 +12,9 @@
   # Sublime Parity
   'tab': 'editor:indent'
   'enter': 'editor:newline'
+  'num-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.panel-left, .tool-panel.panel-right':
   'escape': 'tool-panel:unfocus'
@@ -35,6 +27,7 @@
   'tab': 'core:focus-next'
   'shift-tab': 'core:focus-previous'
   'enter': 'native!'
+  'num-enter': 'native!'
   'backspace': 'native!'
   'shift-backspace': 'native!'
   'delete': 'native!'

keymaps/darwin.cson

@@ -21,6 +21,7 @@
   'cmd-O': 'application:open-dev'
   'cmd-alt-ctrl-s': 'application:run-all-specs'
   'enter': 'core:confirm'
+  'num-enter': 'core:confirm'
   'escape': 'core:cancel'
   'up': 'core:move-up'
   'down': 'core:move-down'
@@ -65,6 +66,8 @@
   'cmd-}': 'pane:show-next-item'
   'cmd-alt-left': 'pane:show-previous-item'
   'cmd-alt-right': 'pane:show-next-item'
+  'ctrl-tab': 'pane:show-next-item'
+  'ctrl-shift-tab': 'pane:show-previous-item'
   'cmd-=': 'window:increase-font-size'
   'cmd-+': 'window:increase-font-size'
   'cmd--': 'window:decrease-font-size'
@@ -94,17 +97,23 @@
   'cmd-9': 'pane:show-item-9'
 
 '.editor':
+  # Platform Bindings
+  'alt-left': 'editor:move-to-beginning-of-word'
+  'alt-right': 'editor:move-to-end-of-word'
+  'alt-shift-left': 'editor:select-to-beginning-of-word'
+  'alt-shift-right': 'editor:select-to-end-of-word'
+
   # Apple Specific
-  'cmd-backspace': 'editor:backspace-to-beginning-of-line'
-  'cmd-shift-backspace': 'editor:backspace-to-beginning-of-line'
-  'cmd-delete': 'editor:backspace-to-beginning-of-line'
+  'cmd-backspace': 'editor:delete-to-beginning-of-line'
+  'cmd-shift-backspace': 'editor:delete-to-beginning-of-line'
+  'cmd-delete': 'editor:delete-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-screen-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-backspace': 'editor:delete-to-beginning-of-word'
   'alt-delete': 'editor:delete-to-end-of-word'
   'ctrl-a': 'editor:move-to-beginning-of-line'
   'ctrl-e': 'editor:move-to-end-of-line'
@@ -119,6 +128,7 @@
   'cmd-k cmd-u': 'editor:upper-case'
   'cmd-k cmd-l': 'editor:lower-case'
   'cmd-l': 'editor:select-line'
+  'ctrl-t': 'editor:transpose'
 
 '.workspace .editor:not(.mini)':
   # Atom specific
@@ -137,6 +147,8 @@
   'cmd-j': 'editor:join-lines'
   'cmd-D': 'editor:duplicate-lines'
   'cmd-L': 'editor:split-selections-into-lines'
+  'ctrl-shift-up': 'editor:add-selection-above'
+  'ctrl-shift-down': 'editor:add-selection-below'
 
   'cmd-alt-[': 'editor:fold-current-row'
   'cmd-alt-]': 'editor:unfold-current-row'

keymaps/emacs.cson

@@ -3,5 +3,5 @@
   'alt-F': 'editor:select-to-end-of-word'
   'alt-b': 'editor:move-to-beginning-of-word'
   'alt-B': 'editor:select-to-beginning-of-word'
-  'alt-h': 'editor:backspace-to-beginning-of-word'
+  'alt-h': 'editor:delete-to-beginning-of-word'
   'alt-d': 'editor:delete-to-end-of-word'

keymaps/linux.cson

@@ -1,6 +1,7 @@
 'body':
   # Atom Specific
   'enter': 'core:confirm'
+  'num-enter': 'core:confirm'
   'escape': 'core:cancel'
   'up': 'core:move-up'
   'down': 'core:move-down'
@@ -10,11 +11,14 @@
   'ctrl-alt-i': 'window:toggle-dev-tools'
   'ctrl-alt-p': 'window:run-package-specs'
   'ctrl-alt-s': 'application:run-all-specs'
+  'ctrl-shift-o': 'application:open-dev'
+  'F11': 'window:toggle-full-screen'
 
   # Sublime Parity
   'ctrl-N': 'application:new-window'
   'ctrl-W': 'window:close'
-  'ctrl-o': 'application:open'
+  'ctrl-o': 'application:open-file'
+  'ctrl-q': 'application:quit'
   'ctrl-T': 'pane:reopen-closed-item'
   'ctrl-n': 'application:new-file'
   'ctrl-s': 'core:save'
@@ -57,8 +61,17 @@
   'ctrl-k ctrl-right': 'window:focus-pane-on-right'
 
 '.workspace .editor':
-  # Windows specific
-  'ctrl-delete': 'editor:backspace-to-beginning-of-word'
+  # Platform Bindings
+  'ctrl-left': 'editor:move-to-beginning-of-word'
+  'ctrl-right': 'editor:move-to-end-of-word'
+  'ctrl-shift-left': 'editor:select-to-beginning-of-word'
+  'ctrl-shift-right': 'editor:select-to-end-of-word'
+  'ctrl-backspace': 'editor:delete-to-beginning-of-word'
+  'ctrl-delete': 'editor:delete-to-end-of-word'
+  'ctrl-home': 'core:move-to-top'
+  'ctrl-end': 'core:move-to-bottom'
+  'ctrl-shift-home': 'core:select-to-top'
+  'ctrl-shift-end': 'core:select-to-bottom'
 
   # Sublime Parity
   'ctrl-a': 'core:select-all'
@@ -82,6 +95,8 @@
   'ctrl-/': 'editor:toggle-line-comments'
   'ctrl-j': 'editor:join-lines'
   'ctrl-D': 'editor:duplicate-lines'
+  'alt-shift-up': 'editor:add-selection-above'
+  'alt-shift-down': 'editor:add-selection-below'
 
   'ctrl-alt-[': 'editor:fold-current-row'
   'ctrl-alt-]': 'editor:unfold-current-row'

keymaps/win32.cson

@@ -1,6 +1,11 @@
 'body':
+  # Platform Bindings
+  'ctrl-pageup': 'pane:show-previous-item'
+  'ctrl-pagedown': 'pane:show-next-item'
+
   # Atom Specific
   'enter': 'core:confirm'
+  'num-enter': 'core:confirm'
   'escape': 'core:cancel'
   'up': 'core:move-up'
   'down': 'core:move-down'
@@ -10,11 +15,12 @@
   'ctrl-alt-i': 'window:toggle-dev-tools'
   'ctrl-alt-p': 'window:run-package-specs'
   'ctrl-alt-s': 'application:run-all-specs'
+  'F11': 'window:toggle-full-screen'
 
   # Sublime Parity
   'ctrl-N': 'application:new-window'
   'ctrl-W': 'window:close'
-  'ctrl-o': 'application:open'
+  'ctrl-o': 'application:open-file'
   'ctrl-T': 'pane:reopen-closed-item'
   'ctrl-n': 'application:new-file'
   'ctrl-s': 'core:save'
@@ -33,6 +39,7 @@
   'pageup': 'core:page-up'
   'pagedown': 'core:page-down'
   'backspace': 'core:backspace'
+  'shift-backspace': 'core:backspace'
   'ctrl-tab': 'pane:show-next-item'
   'ctrl-shift-tab': 'pane:show-previous-item'
   'ctrl-shift-up': 'core:move-up'
@@ -57,8 +64,15 @@
   'ctrl-k ctrl-right': 'window:focus-pane-on-right'
 
 '.workspace .editor':
-  # Windows specific
-  'ctrl-delete': 'editor:backspace-to-beginning-of-word'
+  # Platform Bindings
+  'ctrl-left': 'editor:move-to-beginning-of-word'
+  'ctrl-right': 'editor:move-to-end-of-word'
+  'ctrl-shift-left': 'editor:select-to-beginning-of-word'
+  'ctrl-shift-right': 'editor:select-to-end-of-word'
+  'ctrl-backspace': 'editor:delete-to-beginning-of-word'
+  'ctrl-delete': 'editor:delete-to-end-of-word'
+  'ctrl-home': 'core:move-to-top'
+  'ctrl-end': 'core:move-to-bottom'
 
   # Sublime Parity
   'ctrl-a': 'core:select-all'

menus/darwin.cson

@@ -4,10 +4,10 @@
     submenu: [
       { label: 'About Atom', command: 'application:about' }
       { label: 'View License', command: 'application:open-license' }
-      { label: "VERSION", enabled: false }
-      { label: "Restart and Install Update", command: 'application:install-update', visible: false}
-      { label: "Check for Update", command: 'application:check-for-update', visible: false}
-      { label: "Downloading Update", command: 'application:check-for-update', enabled: false, visible: false}
+      { label: 'VERSION', enabled: false }
+      { label: 'Restart and Install Update', command: 'application:install-update', visible: false}
+      { label: 'Check for Update', command: 'application:check-for-update', visible: false}
+      { label: 'Downloading Update', enabled: false, visible: false}
       { type: 'separator' }
       { label: 'Preferences...', command: 'application:show-settings' }
       { label: 'Open Your Config', command: 'application:open-your-config' }
@@ -134,6 +134,25 @@
     submenu: [
       { label: 'Reload', command: 'window:reload' }
       { label: 'Toggle Full Screen', command: 'window:toggle-full-screen' }
+      {
+        label: 'Panes'
+        submenu: [
+          { label: 'Split Up', command: 'pane:split-up' }
+          { label: 'Split Down', command: 'pane:split-down' }
+          { label: 'Split Left', command: 'pane:split-left' }
+          { label: 'Split Right', command: 'pane:split-right' }
+          { type: 'separator' }
+          { label: 'Focus Next Pane', command: 'window:focus-next-pane' }
+          { label: 'Focus Previous Pane', command: 'window:focus-previous-pane' }
+          { type: 'separator' }
+          { label: 'Focus Pane Above', command: 'window:focus-pane-above' }
+          { label: 'Focus Pane Below', command: 'window:focus-pane-below' }
+          { label: 'Focus Pane On Left', command: 'window:focus-pane-on-left' }
+          { label: 'Focus Pane On Right', command: 'window:focus-pane-on-right' }
+          { type: 'separator' }
+          { label: 'Close Pane', command: 'pane:close' }
+        ]
+      }
       {
         label: 'Developer'
         submenu: [
@@ -166,6 +185,7 @@
   {
     label: 'Help'
     submenu: [
+      { label: 'Terms of Use', command: 'application:open-terms-of-use' }
       { label: 'Documentation', command: 'application:open-documentation' }
       { type: 'separator' }
     ]

menus/linux.cson

@@ -4,7 +4,8 @@
     submenu: [
       { label: 'New &Window', command: 'application:new-window' }
       { label: '&New File', command: 'application:new-file' }
-      { label: '&Open...', command: 'application:open' }
+      { label: '&Open File...', command: 'application:open-file' }
+      { label: 'Open Folder...', command: 'application:open-folder' }
       { label: 'Reopen Last &Item', command: 'pane:reopen-closed-item' }
       { type: 'separator' }
       { label: '&Preferences...', command: 'application:show-settings' }
@@ -17,7 +18,7 @@
       { label: 'Close All &Buffers', command: 'pane:close' }
       { label: 'Clos&e Window', command: 'window:close' }
       { type: 'separator' }
-      { label: 'E&xit', command: 'application:quit' }
+      { label: 'Quit', command: 'application:quit' }
     ]
   }
 
@@ -144,10 +145,9 @@
   {
     label: '&Help'
     submenu: [
-      { label: '&About Atom...', command: 'application:about' }
+      { label: 'View &Terms of Use', command: 'application:open-terms-of-use' }
       { label: 'View &License', command: 'application:open-license' }
       { label: "VERSION", enabled: false }
-      { label: "Install &update", command: 'application:install-update', visible: false }
       { type: 'separator' }
       { label: '&Documentation', command: 'application:open-documentation' }
       { type: 'separator' }

menus/win32.cson

@@ -4,7 +4,8 @@
     submenu: [
       { label: 'New &Window', command: 'application:new-window' }
       { label: '&New File', command: 'application:new-file' }
-      { label: '&Open...', command: 'application:open' }
+      { label: '&Open File...', command: 'application:open-file' }
+      { label: 'Open Folder...', command: 'application:open-folder' }
       { label: 'Reopen Last &Item', command: 'pane:reopen-closed-item' }
       { type: 'separator' }
       { label: '&Preferences...', command: 'application:show-settings' }
@@ -87,6 +88,25 @@
     submenu: [
       { label: '&Reload', command: 'window:reload' }
       { label: 'Toggle &Full Screen', command: 'window:toggle-full-screen' }
+      {
+        label: 'Panes'
+        submenu: [
+          { label: 'Split Up', command: 'pane:split-up' }
+          { label: 'Split Down', command: 'pane:split-down' }
+          { label: 'Split Left', command: 'pane:split-left' }
+          { label: 'Split Right', command: 'pane:split-right' }
+          { type: 'separator' }
+          { label: 'Focus Next Pane', command: 'window:focus-next-pane' }
+          { label: 'Focus Previous Pane', command: 'window:focus-previous-pane' }
+          { type: 'separator' }
+          { label: 'Focus Pane Above', command: 'window:focus-pane-above' }
+          { label: 'Focus Pane Below', command: 'window:focus-pane-below' }
+          { label: 'Focus Pane On Left', command: 'window:focus-pane-on-left' }
+          { label: 'Focus Pane On Right', command: 'window:focus-pane-on-right' }
+          { type: 'separator' }
+          { label: 'Close pane', command: 'pane:close' }
+        ]
+      }
       {
         label: 'Developer'
         submenu: [
@@ -145,6 +165,7 @@
     label: '&Help'
     submenu: [
       { label: '&About Atom...', command: 'application:about' }
+      { label: 'View &Terms of Use', command: 'application:open-terms-of-use' }
       { label: 'View &License', command: 'application:open-license' }
       { label: "VERSION", enabled: false }
       { label: "Install &update", command: 'application:install-update', visible: false }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "atom",
   "productName": "Atom",
-  "version": "0.78.0",
+  "version": "0.100.0",
   "description": "A hackable text editor for the 21st Century.",
   "main": "./src/browser/main.js",
   "repository": {
@@ -11,121 +11,130 @@
   "bugs": {
     "url": "https://github.com/atom/atom/issues"
   },
-  "license": "All Rights Reserved",
-  "atomShellVersion": "0.11.3",
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
+    }
+  ],
+  "atomShellVersion": "0.12.7",
   "dependencies": {
     "async": "0.2.6",
-    "atom-keymap": "^0.11.0",
-    "bootstrap": "git://github.com/atom/bootstrap.git#6af81906189f1747fd6c93479e3d998ebe041372",
+    "atom-keymap": "^0.26.0",
+    "bootstrap": "git+https://github.com/atom/bootstrap.git#6af81906189f1747fd6c93479e3d998ebe041372",
     "clear-cut": "0.4.0",
     "coffee-script": "1.7.0",
     "coffeestack": "0.7.0",
-    "delegato": "1.x",
-    "emissary": "^1.2",
-    "first-mate": ">=1.4.2 <2.0",
-    "fs-plus": ">=2.0.4 < 3.0",
+    "delegato": "^1",
+    "emissary": "^1.2.1",
+    "first-mate": "^1.6",
+    "fs-plus": "^2.2.3",
     "fstream": "0.1.24",
-    "fuzzaldrin": "~1.1",
-    "git-utils": "^1.1.1",
+    "fuzzaldrin": "^1.1",
+    "git-utils": "^1.3",
+    "grim": "0.10.0",
     "guid": "0.0.10",
-    "jasmine-tagged": ">=1.1.1 <2.0",
-    "mkdirp": "0.3.5",
-    "keytar": "1.x",
+    "jasmine-tagged": "^1.1.1",
     "less-cache": "0.12.0",
-    "mixto": "1.x",
+    "mixto": "^1",
+    "mkdirp": "0.3.5",
     "nslog": "0.5.0",
-    "oniguruma": "^1.0.4",
+    "oniguruma": "^1.0.6",
     "optimist": "0.4.0",
-    "pathwatcher": "^1.1",
-    "property-accessors": "1.x",
+    "pathwatcher": "^1.3.1",
+    "property-accessors": "^1",
     "q": "^1.0.1",
     "random-words": "0.0.1",
-    "runas": "0.5.x",
-    "scandal": "0.15.0",
-    "scrollbar-style": "^0.1.0",
-    "season": ">=1.0.2 <2.0",
+    "react-atom-fork": "^0.10.0",
+    "reactionary-atom-fork": "^0.9.0",
+    "runas": "^0.5",
+    "scandal": "0.15.2",
+    "scoped-property-store": "^0.9.0",
+    "scrollbar-style": "^0.4.0",
+    "season": "^1.0.2",
     "semver": "1.1.4",
-    "serializable": "1.x",
-    "space-pen": "3.1.1",
+    "serializable": "^1",
+    "space-pen": "3.2.0",
     "temp": "0.5.0",
-    "text-buffer": "^1.4.5",
-    "theorist": "1.x",
-    "underscore-plus": ">=1.0.5 <2.0",
+    "text-buffer": "^2.2.2",
+    "theorist": "^1",
+    "underscore-plus": "^1.3.0",
     "vm-compatibility-layer": "0.1.0"
   },
   "packageDependencies": {
     "atom-dark-syntax": "0.15.0",
-    "atom-dark-ui": "0.26.0",
-    "atom-light-syntax": "0.16.0",
-    "atom-light-ui": "0.23.0",
-    "base16-tomorrow-dark-theme": "0.13.0",
+    "atom-dark-ui": "0.28.0",
+    "atom-light-syntax": "0.17.0",
+    "atom-light-ui": "0.25.0",
+    "base16-tomorrow-dark-theme": "0.15.0",
     "solarized-dark-syntax": "0.14.0",
     "solarized-light-syntax": "0.7.0",
-    "archive-view": "0.30.0",
-    "autocomplete": "0.27.0",
-    "autoflow": "0.15.0",
+    "archive-view": "0.31.0",
+    "autocomplete": "0.28.0",
+    "autoflow": "0.17.0",
     "autosave": "0.13.0",
-    "background-tips": "0.9.0",
+    "background-tips": "0.14.0",
     "bookmarks": "0.22.0",
-    "bracket-matcher": "0.26.0",
-    "command-palette": "0.19.0",
+    "bracket-matcher": "0.41.0",
+    "command-palette": "0.21.0",
+    "deprecation-cop": "0.6.0",
     "dev-live-reload": "0.30.0",
     "exception-reporting": "0.17.0",
-    "feedback": "0.28.0",
-    "find-and-replace": "0.92.0",
-    "fuzzy-finder": "0.42.0",
-    "git-diff": "0.25.0",
-    "go-to-line": "0.18.0",
-    "grammar-selector": "0.23.0",
-    "image-view": "0.32.0",
-    "keybinding-resolver": "0.12.0",
-    "link": "0.20.0",
-    "markdown-preview": "0.51.0",
+    "feedback": "0.33.0",
+    "find-and-replace": "0.110.0",
+    "fuzzy-finder": "0.53.0",
+    "git-diff": "0.28.0",
+    "go-to-line": "0.21.0",
+    "grammar-selector": "0.27.0",
+    "image-view": "0.33.0",
+    "keybinding-resolver": "0.18.0",
+    "link": "0.22.0",
+    "markdown-preview": "0.72.0",
     "metrics": "0.32.0",
-    "open-on-github": "0.23.0",
+    "open-on-github": "0.28.0",
     "package-generator": "0.30.0",
-    "release-notes": "0.26.0",
-    "settings-view": "0.97.0",
-    "snippets": "0.40.0",
-    "spell-check": "0.28.0",
-    "status-bar": "0.37.0",
-    "styleguide": "0.26.0",
-    "symbols-view": "0.46.0",
-    "tabs": "0.31.0",
-    "timecop": "0.17.0",
-    "tree-view": "0.83.0",
+    "release-notes": "0.31.0",
+    "settings-view": "0.117.0",
+    "snippets": "0.44.0",
+    "spell-check": "0.35.0",
+    "status-bar": "0.40.0",
+    "styleguide": "0.29.0",
+    "symbols-view": "0.54.0",
+    "tabs": "0.41.0",
+    "timecop": "0.19.0",
+    "tree-view": "0.95.0",
     "update-package-dependencies": "0.6.0",
-    "welcome": "0.11.0",
-    "whitespace": "0.21.0",
+    "welcome": "0.14.0",
+    "whitespace": "0.22.0",
     "wrap-guide": "0.18.0",
-    "language-c": "0.13.0",
-    "language-coffee-script": "0.16.0",
-    "language-css": "0.13.0",
-    "language-gfm": "0.25.0",
+    "language-c": "0.15.0",
+    "language-coffee-script": "0.22.0",
+    "language-css": "0.16.0",
+    "language-gfm": "0.38.0",
     "language-git": "0.9.0",
-    "language-go": "0.7.0",
-    "language-html": "0.15.0",
+    "language-go": "0.12.0",
+    "language-html": "0.22.0",
     "language-hyperlink": "0.9.0",
-    "language-java": "0.9.0",
-    "language-javascript": "0.21.0",
+    "language-java": "0.10.0",
+    "language-javascript": "0.26.0",
     "language-json": "0.8.0",
-    "language-less": "0.6.0",
-    "language-make": "0.9.0",
+    "language-less": "0.9.0",
+    "language-make": "0.10.0",
     "language-objective-c": "0.11.0",
-    "language-perl": "0.8.0",
-    "language-php": "0.13.0",
+    "language-perl": "0.9.0",
+    "language-php": "0.14.0",
     "language-property-list": "0.7.0",
-    "language-python": "0.12.0",
-    "language-ruby": "0.17.0",
-    "language-ruby-on-rails": "0.12.0",
-    "language-sass": "0.8.0",
+    "language-python": "0.17.0",
+    "language-ruby": "0.26.0",
+    "language-ruby-on-rails": "0.14.0",
+    "language-sass": "0.11.0",
     "language-shellscript": "0.8.0",
     "language-source": "0.7.0",
-    "language-sql": "0.7.0",
+    "language-sql": "0.8.0",
     "language-text": "0.6.0",
-    "language-todo": "0.9.0",
+    "language-todo": "0.10.0",
     "language-toml": "0.12.0",
-    "language-xml": "0.9.0",
+    "language-xml": "0.14.0",
     "language-yaml": "0.6.0"
   },
   "private": true,

script/bootstrap

@@ -1,8 +1,18 @@
 #!/usr/bin/env node
 
-var nodeMinorVersion = process.versions.node.split('.')[1]
-if (nodeMinorVersion !== '10') {
-  console.warn("You must run script/bootstrap and script/build with node v0.10.x");
+var fs = require('fs');
+
+var nodeVersion = process.versions.node.split('.')
+var nodeMajorVersion = +nodeVersion[0]
+var nodeMinorVersion = +nodeVersion[1]
+if (nodeMajorVersion === 0 && nodeMinorVersion < 10) {
+  console.warn("You must run script/bootstrap and script/build with node v0.10 or above");
+  process.exit(1);
+}
+
+// Make sure python2.7 is installed
+if (process.platform == 'win32' && !fs.existsSync('C:\\Python27\\')) {
+  console.warn("You must have Python 2.7 installed at 'C:\\Python27\\'");
   process.exit(1);
 }
 
@@ -25,28 +35,25 @@ function executeCommands(commands, done, index) {
     done(null);
 }
 
-var apmVendorPath = path.resolve(__dirname, '..', 'vendor', 'apm');
 var apmInstallPath = path.resolve(__dirname, '..', 'apm');
 if (!fs.existsSync(apmInstallPath))
   fs.mkdirSync(apmInstallPath);
 if (!fs.existsSync(path.join(apmInstallPath, 'node_modules')))
   fs.mkdirSync(path.join(apmInstallPath, 'node_modules'));
 
-var apmPath = 'apm/node_modules/atom-package-manager/bin/apm'
+var apmPath = path.resolve(__dirname, '..', 'apm', 'node_modules', 'atom-package-manager', 'bin', 'apm')
 var apmFlags = process.env.JANKY_SHA1 || process.argv.indexOf('--no-color') !== -1 ? '--no-color' : '';
 
 var npmPath = path.resolve(__dirname, '..', 'build', 'node_modules', '.bin', 'npm');
+var initialNpmCommand = fs.existsSync(npmPath) ? npmPath : 'npm';
 var npmFlags = ' --userconfig=' + path.resolve('.npmrc') + ' ';
 
 var packagesToDedupe = ['fs-plus', 'humanize-plus', 'oniguruma', 'roaster', 'season'];
 var echoNewLine = process.platform == 'win32' ? 'echo.' : 'echo';
 
 var commands = [
-  'git submodule --quiet sync',
-  'git submodule --quiet update --recursive --init',
-  {command: 'npm' + npmFlags + 'install --quiet', options: {cwd: path.resolve(__dirname, '..', 'build'), ignoreStdout: true}},
-  {command: npmPath + npmFlags + 'install --quiet', options: {cwd: apmVendorPath, ignoreStdout: true}},
-  {command: npmPath + npmFlags + 'install --quiet ' + apmVendorPath, options: {cwd: apmInstallPath, ignoreStdout: true}},
+  {command: initialNpmCommand + npmFlags + 'install --quiet', options: {cwd: path.resolve(__dirname, '..', 'build'), ignoreStdout: true}},
+  {command: npmPath + npmFlags + 'install --quiet', options: {cwd: apmInstallPath, ignoreStdout: true}},
   echoNewLine,
   apmPath + ' clean ' + apmFlags,
   apmPath + ' install --quiet ' + apmFlags,

script/cibuild

@@ -28,17 +28,19 @@ function readEnvironmentVariables() {
 }
 
 readEnvironmentVariables();
-cp.safeExec.bind(global, 'node script/bootstrap', function(error) {
-  if (error)
-    process.exit(1);
-  require('fs-plus').removeSync.bind(global, path.join(homeDir, '.atom'))
-  var async = require('async');
-  var gruntPath = path.join('build', 'node_modules', '.bin', 'grunt') + (process.platform === 'win32' ? '.cmd' : '');
-  var tasks = [
-    cp.safeExec.bind(global, 'git clean -dff'),
-    cp.safeExec.bind(global, gruntPath + ' ci --gruntfile build/Gruntfile.coffee --stack --no-color'),
-  ]
-  async.series(tasks, function(error) {
-    process.exit(error ? 1 : 0);
-  });
+cp.safeExec.bind(global, 'npm install npm', {cwd: path.resolve(__dirname, '..', 'build')}, function() {
+  cp.safeExec.bind(global, 'node script/bootstrap', function(error) {
+    if (error)
+      process.exit(1);
+    require('fs-plus').removeSync.bind(global, path.join(homeDir, '.atom'))
+    var async = require('async');
+    var gruntPath = path.join('build', 'node_modules', '.bin', 'grunt') + (process.platform === 'win32' ? '.cmd' : '');
+    var tasks = [
+      cp.safeExec.bind(global, 'git clean -dff'),
+      cp.safeExec.bind(global, gruntPath + ' ci --gruntfile build/Gruntfile.coffee --stack --no-color'),
+    ]
+    async.series(tasks, function(error) {
+      process.exit(error ? 1 : 0);
+    });
+  })();
 })();

script/clean

@@ -8,7 +8,7 @@ var productName = require('../package.json').productName;
 
 process.chdir(path.dirname(__dirname));
 var home = process.env[(process.platform === 'win32') ? 'USERPROFILE' : 'HOME'];
-var tmpdir = process.platform === 'win32' ? os.tmpdir() : '/tmp';
+var tmpdir = os.tmpdir();
 
 // Windows: Use START as a way to ignore error if Atom.exe isnt running
 var killatom = process.platform === 'win32' ? 'START taskkill /F /IM ' + productName + '.exe' : 'pkill -9 ' + productName + ' || true';
@@ -18,14 +18,13 @@ var commands = [
   [__dirname, '..', 'node_modules'],
   [__dirname, '..', 'build', 'node_modules'],
   [__dirname, '..', 'apm', 'node_modules'],
-  [__dirname, '..', 'vendor', 'apm', 'node_modules'],
   [__dirname, '..', 'atom-shell'],
   [home, '.atom', '.node-gyp'],
   [home, '.atom', 'storage'],
   [home, '.atom', '.npm'],
+  [home, '.atom', 'compile-cache'],
   [tmpdir, 'atom-build'],
   [tmpdir, 'atom-cached-atom-shells'],
-  [tmpdir, 'atom-compile-cache'],
 ];
 var run = function() {
   var next = commands.shift();

script/grunt.cmd

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

script/mkdeb

@@ -1,6 +1,8 @@
 #!/bin/bash
 # mkdeb version control-file-path deb-file-path
 
+set -e
+
 SCRIPT=`readlink -f "$0"`
 ROOT=`readlink -f $(dirname $SCRIPT)/..`
 cd $ROOT
@@ -12,7 +14,8 @@ ICON_FILE="$4"
 DEB_PATH="$5"
 
 TARGET_ROOT="`mktemp -d`"
-TARGET="$TARGET_ROOT/atom-$VERSION"
+chmod 755 "$TARGET_ROOT"
+TARGET="$TARGET_ROOT/atom-$VERSION-amd64"
 
 mkdir -p "$TARGET/usr"
 env INSTALL_PREFIX="$TARGET/usr" script/grunt install
@@ -27,5 +30,5 @@ mkdir -p "$TARGET/usr/share/pixmaps"
 cp "$ICON_FILE" "$TARGET/usr/share/pixmaps"
 
 dpkg-deb -b "$TARGET"
-mv "$TARGET_ROOT/atom-$VERSION.deb" "$DEB_PATH"
+mv "$TARGET_ROOT/atom-$VERSION-amd64.deb" "$DEB_PATH"
 rm -rf $TARGET_ROOT

spec/atom-spec.coffee

@@ -113,18 +113,21 @@ describe "the `atom` global", ->
                 promise
 
             it "triggers the activation event on all handlers registered during activation", ->
-              atom.workspaceView.openSync()
-              editorView = atom.workspaceView.getActiveView()
-              eventHandler = jasmine.createSpy("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
-              editorView.trigger 'activation-event'
-              expect(mainModule.activationEventCallCount).toBe 2
-              expect(eventHandler.callCount).toBe 2
-              expect(mainModule.activate.callCount).toBe 1
+              waitsForPromise ->
+                atom.workspaceView.open()
+
+              runs ->
+                editorView = atom.workspaceView.getActiveView()
+                eventHandler = jasmine.createSpy("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
+                editorView.trigger 'activation-event'
+                expect(mainModule.activationEventCallCount).toBe 2
+                expect(eventHandler.callCount).toBe 2
+                expect(mainModule.activate.callCount).toBe 1
 
             it "activates the package immediately when the events are empty", ->
               mainModule = require './fixtures/packages/package-with-empty-activation-events/index'
@@ -170,28 +173,28 @@ describe "the `atom` global", ->
               element2 = $$ -> @div class: 'test-2'
               element3 = $$ -> @div class: 'test-3'
 
-              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
+              expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])).toHaveLength 0
+              expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element2[0])).toHaveLength 0
+              expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element3[0])).toHaveLength 0
 
               atom.packages.activatePackage("package-with-keymaps")
 
-              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe "test-1"
-              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element2)[0].command).toBe "test-2"
-              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element3)).toHaveLength 0
+              expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])[0].command).toBe "test-1"
+              expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element2[0])[0].command).toBe "test-2"
+              expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element3[0])).toHaveLength 0
 
           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(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)).toHaveLength 0
+              expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])).toHaveLength 0
 
               atom.packages.activatePackage("package-with-keymaps-manifest")
 
-              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe 'keymap-1'
-              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-n', element1)[0].command).toBe 'keymap-2'
-              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-y', element3)).toHaveLength 0
+              expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])[0].command).toBe 'keymap-1'
+              expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-n', target:element1[0])[0].command).toBe 'keymap-2'
+              expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-y', target:element3[0])).toHaveLength 0
 
         describe "menu loading", ->
           beforeEach ->
@@ -377,8 +380,8 @@ describe "the `atom` global", ->
 
           runs ->
             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
+            expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:$$ -> @div class: 'test-1'[0])).toHaveLength 0
+            expect(atom.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:$$ -> @div class: 'test-2'[0])).toHaveLength 0
 
         it "removes the package's stylesheets", ->
           waitsForPromise ->
@@ -507,20 +510,20 @@ describe "the `atom` global", ->
           # enabling of theme
           pack = atom.packages.enablePackage(packageName)
 
-          activatedPackages = null
           waitsFor ->
-            activatedPackages = atom.packages.getActivePackages()
-            activatedPackages.length > 0
+            pack in atom.packages.getActivePackages()
 
           runs ->
-            expect(activatedPackages).toContain(pack)
             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)
+
+          waitsFor ->
+            not (pack in atom.packages.getActivePackages())
+
+          runs ->
             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/config-spec.coffee

@@ -5,6 +5,10 @@ fs = require 'fs-plus'
 
 describe "Config", ->
   dotAtomPath = path.join(temp.dir, 'dot-atom-dir')
+  dotAtomPath = null
+
+  beforeEach ->
+    dotAtomPath = temp.path('dot-atom-dir')
 
   describe ".get(keyPath)", ->
     it "allows a key path's value to be read", ->
@@ -36,15 +40,53 @@ describe "Config", ->
 
     describe "when the value equals the default value", ->
       it "does not store the value", ->
-        atom.config.setDefaults("foo", same: 1, changes: 1)
+        atom.config.setDefaults "foo",
+          same: 1
+          changes: 1
+          sameArray: [1, 2, 3]
+          sameObject: {a: 1, b: 2}
+          null: null
+          undefined: undefined
         expect(atom.config.settings.foo).toBeUndefined()
+
         atom.config.set('foo.same', 1)
         atom.config.set('foo.changes', 2)
+        atom.config.set('foo.sameArray', [1, 2, 3])
+        atom.config.set('foo.null', undefined)
+        atom.config.set('foo.undefined', null)
+        atom.config.set('foo.sameObject', {b: 2, a: 1})
         expect(atom.config.settings.foo).toEqual {changes: 2}
 
         atom.config.set('foo.changes', 1)
         expect(atom.config.settings.foo).toEqual {}
 
+  describe ".getDefault(keyPath)", ->
+    it "returns a clone of the default value", ->
+      atom.config.setDefaults("foo", same: 1, changes: 1)
+      expect(atom.config.getDefault('foo.same')).toBe 1
+      expect(atom.config.getDefault('foo.changes')).toBe 1
+
+      atom.config.set('foo.same', 2)
+      atom.config.set('foo.changes', 3)
+      expect(atom.config.getDefault('foo.same')).toBe 1
+      expect(atom.config.getDefault('foo.changes')).toBe 1
+
+      initialDefaultValue = [1, 2, 3]
+      atom.config.setDefaults("foo", bar: initialDefaultValue)
+      expect(atom.config.getDefault('foo.bar')).toEqual initialDefaultValue
+      expect(atom.config.getDefault('foo.bar')).not.toBe initialDefaultValue
+
+  describe ".isDefault(keyPath)", ->
+    it "returns true when the value of the key path is its default value", ->
+      atom.config.setDefaults("foo", same: 1, changes: 1)
+      expect(atom.config.isDefault('foo.same')).toBe true
+      expect(atom.config.isDefault('foo.changes')).toBe true
+
+      atom.config.set('foo.same', 2)
+      atom.config.set('foo.changes', 3)
+      expect(atom.config.isDefault('foo.same')).toBe false
+      expect(atom.config.isDefault('foo.changes')).toBe false
+
   describe ".toggle(keyPath)", ->
     it "negates the boolean value of the current key path value", ->
       atom.config.set('foo.a', 1)
@@ -170,6 +212,13 @@ describe "Config", ->
       expect(atom.config.get("foo.quux.x")).toBe 0
       expect(atom.config.get("foo.quux.y")).toBe 1
 
+    it "emits an updated event", ->
+      updatedCallback = jasmine.createSpy('updated')
+      atom.config.observe('foo.bar.baz.a', callNow: false, updatedCallback)
+      expect(updatedCallback.callCount).toBe 0
+      atom.config.setDefaults("foo.bar.baz", a: 2)
+      expect(updatedCallback.callCount).toBe 1
+
   describe ".observe(keyPath)", ->
     [observeHandler, observeSubscription] = []
 
@@ -213,8 +262,10 @@ describe "Config", ->
 
   describe ".initializeConfigDirectory()", ->
     beforeEach ->
+      if fs.existsSync(dotAtomPath)
+        fs.removeSync(dotAtomPath)
+
       atom.config.configDirPath = dotAtomPath
-      expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
 
     afterEach ->
       fs.removeSync(dotAtomPath)

spec/display-buffer-spec.coffee

@@ -18,10 +18,10 @@ describe "DisplayBuffer", ->
     displayBuffer.destroy()
     buffer.release()
 
-  describe ".copy()", ->
+  describe "::copy()", ->
     it "creates a new DisplayBuffer with the same initial state", ->
       marker1 = displayBuffer.markBufferRange([[1, 2], [3, 4]], id: 1)
-      marker2 = displayBuffer.markBufferRange([[2, 3], [4, 5]], isReversed: true, id: 2)
+      marker2 = displayBuffer.markBufferRange([[2, 3], [4, 5]], reversed: true, id: 2)
       marker3 = displayBuffer.markBufferPosition([5, 6], id: 3)
       displayBuffer.createFold(3, 5)
 
@@ -82,7 +82,7 @@ describe "DisplayBuffer", ->
 
         describe "when there is no whitespace before the boundary", ->
           it "wraps the line exactly at the boundary since there's no more graceful place to wrap it", ->
-            buffer.change([[0, 0], [1, 0]], 'abcdefghijklmnopqrstuvwxyz\n')
+            buffer.setTextInRange([[0, 0], [1, 0]], 'abcdefghijklmnopqrstuvwxyz\n')
             displayBuffer.setEditorWidthInChars(10)
             expect(displayBuffer.lineForRow(0).text).toBe 'abcdefghij'
             expect(displayBuffer.lineForRow(1).text).toBe 'klmnopqrst'
@@ -142,7 +142,7 @@ describe "DisplayBuffer", ->
 
       describe "when buffer lines are removed", ->
         it "removes lines and emits a change event", ->
-          buffer.change([[3, 21], [7, 5]], ';')
+          buffer.setTextInRange([[3, 21], [7, 5]], ';')
           expect(displayBuffer.lineForRow(3).text).toBe '    var pivot = items;'
           expect(displayBuffer.lineForRow(4).text).toBe '    return '
           expect(displayBuffer.lineForRow(5).text).toBe 'sort(left).concat(pivot).concat(sort(right));'
@@ -330,7 +330,7 @@ describe "DisplayBuffer", ->
 
       describe "when the old range surrounds a fold", ->
         beforeEach ->
-          buffer.change([[1, 0], [5, 1]], 'party!')
+          buffer.setTextInRange([[1, 0], [5, 1]], 'party!')
 
         it "removes the fold and replaces the selection with the new text", ->
           expect(displayBuffer.lineForRow(0).text).toBe "0"
@@ -352,7 +352,7 @@ describe "DisplayBuffer", ->
           displayBuffer.createFold(2, 9)
           changeHandler.reset()
 
-          buffer.change([[1, 0], [10, 0]], 'goodbye')
+          buffer.setTextInRange([[1, 0], [10, 0]], 'goodbye')
 
           expect(displayBuffer.lineForRow(0).text).toBe "0"
           expect(displayBuffer.lineForRow(1).text).toBe "goodbye10"
@@ -371,7 +371,7 @@ describe "DisplayBuffer", ->
       describe "when the old range precedes lines with a fold", ->
         describe "when the new range precedes lines with a fold", ->
           it "updates the buffer and re-positions subsequent folds", ->
-            buffer.change([[0, 0], [1, 1]], 'abc')
+            buffer.setTextInRange([[0, 0], [1, 1]], 'abc')
 
             expect(displayBuffer.lineForRow(0).text).toBe "abc"
             expect(displayBuffer.lineForRow(1).fold).toBe fold1
@@ -394,7 +394,7 @@ describe "DisplayBuffer", ->
 
       describe "when the old range straddles the beginning of a fold", ->
         it "destroys the fold", ->
-          buffer.change([[1, 1], [3, 0]], "a\nb\nc\nd\n")
+          buffer.setTextInRange([[1, 1], [3, 0]], "a\nb\nc\nd\n")
           expect(displayBuffer.lineForRow(1).text).toBe '1a'
           expect(displayBuffer.lineForRow(2).text).toBe 'b'
           expect(displayBuffer.lineForRow(2).fold).toBeUndefined()
@@ -402,7 +402,7 @@ describe "DisplayBuffer", ->
 
       describe "when the old range follows a fold", ->
         it "re-positions the screen ranges for the change event based on the preceding fold", ->
-          buffer.change([[10, 0], [11, 0]], 'abc')
+          buffer.setTextInRange([[10, 0], [11, 0]], 'abc')
 
           expect(displayBuffer.lineForRow(1).text).toBe "1"
           expect(displayBuffer.lineForRow(2).fold).toBe fold1
@@ -430,7 +430,7 @@ describe "DisplayBuffer", ->
 
         describe "when the end of the new range exceeds the end of the fold", ->
           it "expands the fold to contain all the inserted lines", ->
-            buffer.change([[3, 0], [4, 0]], 'a\nb\nc\nd\n')
+            buffer.setTextInRange([[3, 0], [4, 0]], 'a\nb\nc\nd\n')
             expect(fold1.getStartRow()).toBe 2
             expect(fold1.getEndRow()).toBe 7
 
@@ -447,7 +447,7 @@ describe "DisplayBuffer", ->
         describe "when the end of the new range precedes the end of the fold", ->
           it "destroys the fold", ->
             fold2.destroy()
-            buffer.change([[3, 0], [6, 0]], 'a\n')
+            buffer.setTextInRange([[3, 0], [6, 0]], 'a\n')
             expect(displayBuffer.lineForRow(2).text).toBe '2'
             expect(displayBuffer.lineForRow(2).fold).toBeUndefined()
             expect(displayBuffer.lineForRow(3).text).toBe 'a'
@@ -536,7 +536,7 @@ describe "DisplayBuffer", ->
         expect(displayBuffer.outermostFoldsInBufferRowRange(3, 18)).toEqual [fold1, fold3, fold5]
         expect(displayBuffer.outermostFoldsInBufferRowRange(5, 16)).toEqual [fold3]
 
-  describe ".clipScreenPosition(screenPosition, wrapBeyondNewlines: false, wrapAtSoftNewlines: false, skipAtomicTokens: false)", ->
+  describe "::clipScreenPosition(screenPosition, wrapBeyondNewlines: false, wrapAtSoftNewlines: false, skipAtomicTokens: false)", ->
     beforeEach ->
       displayBuffer.setSoftWrap(true)
       displayBuffer.setEditorWidthInChars(50)
@@ -598,7 +598,7 @@ describe "DisplayBuffer", ->
         expect(displayBuffer.clipScreenPosition([0, 1], skipAtomicTokens: true)).toEqual [0, tabLength]
         expect(displayBuffer.clipScreenPosition([0, tabLength], skipAtomicTokens: true)).toEqual [0, tabLength]
 
-  describe ".screenPositionForBufferPosition(bufferPosition, options)", ->
+  describe "::screenPositionForBufferPosition(bufferPosition, options)", ->
     it "clips the specified buffer position", ->
       expect(displayBuffer.screenPositionForBufferPosition([0, 2])).toEqual [0, 2]
       expect(displayBuffer.screenPositionForBufferPosition([0, 100000])).toEqual [0, 29]
@@ -618,13 +618,13 @@ describe "DisplayBuffer", ->
       expect(displayBuffer.screenPositionForBufferPosition([0, 10], wrapAtSoftNewlines: true)).toEqual [1, 0]
       expect(displayBuffer.bufferPositionForScreenPosition([1, 0])).toEqual [0, 10]
 
-  describe ".getMaxLineLength()", ->
+  describe "::getMaxLineLength()", ->
     it "returns the length of the longest screen line", ->
       expect(displayBuffer.getMaxLineLength()).toBe 65
       buffer.delete([[6, 0], [6, 65]])
       expect(displayBuffer.getMaxLineLength()).toBe 62
 
-  describe ".destroy()", ->
+  describe "::destroy()", ->
     it "unsubscribes all display buffer markers from their underlying buffer marker (regression)", ->
       marker = displayBuffer.markBufferPosition([12, 2])
       displayBuffer.destroy()
@@ -777,17 +777,17 @@ describe "DisplayBuffer", ->
           isValid: true
         }
 
-      xit "triggers the 'changed' event whenever the marker is invalidated or revalidated", ->
+      it "triggers the 'changed' event whenever the marker is invalidated or revalidated", ->
         buffer.deleteRow(8)
         expect(markerChangedHandler).toHaveBeenCalled()
         expect(markerChangedHandler.argsForCall[0][0]).toEqual {
           oldHeadScreenPosition: [5, 10]
           oldHeadBufferPosition: [8, 10]
-          newHeadScreenPosition: [5, 10]
+          newHeadScreenPosition: [5, 0]
           newHeadBufferPosition: [8, 0]
           oldTailScreenPosition: [5, 4]
           oldTailBufferPosition: [8, 4]
-          newTailScreenPosition: [5, 4]
+          newTailScreenPosition: [5, 0]
           newTailBufferPosition: [8, 0]
           textChanged: true
           isValid: false
@@ -798,12 +798,12 @@ describe "DisplayBuffer", ->
 
         expect(markerChangedHandler).toHaveBeenCalled()
         expect(markerChangedHandler.argsForCall[0][0]).toEqual {
-          oldHeadScreenPosition: [5, 10]
-          oldHeadBufferPosition: [8, 10]
+          oldHeadScreenPosition: [5, 0]
+          oldHeadBufferPosition: [8, 0]
           newHeadScreenPosition: [5, 10]
           newHeadBufferPosition: [8, 10]
-          oldTailScreenPosition: [5, 4]
-          oldTailBufferPosition: [8, 4]
+          oldTailScreenPosition: [5, 0]
+          oldTailBufferPosition: [8, 0]
           newTailScreenPosition: [5, 4]
           newTailBufferPosition: [8, 4]
           textChanged: true
@@ -814,7 +814,7 @@ describe "DisplayBuffer", ->
         displayBuffer.createFold(10, 11)
         expect(markerChangedHandler).not.toHaveBeenCalled()
 
-      xit "updates markers before emitting buffer change events, but does not notify their observers until the change event", ->
+      it "updates markers before emitting buffer change events, but does not notify their observers until the change event", ->
         marker2 = displayBuffer.markBufferRange([[8, 1], [8, 1]])
         marker2.on 'changed', marker2ChangedHandler = jasmine.createSpy("marker2ChangedHandler")
         displayBuffer.on 'changed', changeHandler = jasmine.createSpy("changeHandler").andCallFake -> onDisplayBufferChange()
@@ -831,7 +831,7 @@ describe "DisplayBuffer", ->
           expect(marker.getTailScreenPosition()).toEqual [5, 7]
           expect(marker2.isValid()).toBeFalsy()
 
-        buffer.change([[8, 0], [8, 2]], ".....")
+        buffer.setTextInRange([[8, 0], [8, 2]], ".....")
         expect(changeHandler).toHaveBeenCalled()
         expect(markerChangedHandler).toHaveBeenCalled()
         expect(marker2ChangedHandler).toHaveBeenCalled()
@@ -902,7 +902,7 @@ describe "DisplayBuffer", ->
         expect(changeHandler).toHaveBeenCalled()
         expect(markerChangedHandler).toHaveBeenCalled()
 
-    describe ".findMarkers(attributes)", ->
+    describe "::findMarkers(attributes)", ->
       it "allows the startBufferRow and endBufferRow to be specified", ->
         marker1 = displayBuffer.markBufferRange([[0, 0], [3, 0]], class: 'a')
         marker2 = displayBuffer.markBufferRange([[0, 0], [5, 0]], class: 'a')
@@ -932,7 +932,7 @@ describe "DisplayBuffer", ->
         buffer.getMarker(marker2.id).destroy()
         expect(destroyedHandler).toHaveBeenCalled()
 
-    describe "DisplayBufferMarker.copy(attributes)", ->
+    describe "DisplayBufferMarker::copy(attributes)", ->
       it "creates a copy of the marker with the given attributes merged in", ->
         initialMarkerCount = displayBuffer.getMarkerCount()
         marker1 = displayBuffer.markScreenRange([[5, 4], [5, 10]], a: 1, b: 2)
@@ -943,3 +943,71 @@ describe "DisplayBuffer", ->
         expect(displayBuffer.getMarkerCount()).toBe initialMarkerCount + 2
         expect(marker1.getAttributes()).toEqual a: 1, b: 2
         expect(marker2.getAttributes()).toEqual a: 1, b: 3
+
+    describe "DisplayBufferMarker::getPixelRange()", ->
+      it "returns the start and end positions of the marker based on the line height and character widths assigned to the DisplayBuffer", ->
+        marker = displayBuffer.markScreenRange([[5, 10], [6, 4]])
+
+        displayBuffer.setLineHeightInPixels(20)
+        displayBuffer.setDefaultCharWidth(10)
+        displayBuffer.setScopedCharWidths(["source.js", "keyword.control.js"], r: 11, e: 11, t: 11, u: 11, n: 11)
+
+        {start, end} = marker.getPixelRange()
+        expect(start.top).toBe 5 * 20
+        expect(start.left).toBe (4 * 10) + (6 * 11)
+
+  describe "::setScrollTop", ->
+    beforeEach ->
+      displayBuffer.manageScrollPosition = true
+      displayBuffer.setLineHeightInPixels(10)
+
+    it "disallows negative values", ->
+      displayBuffer.setHeight(displayBuffer.getScrollHeight() + 100)
+      expect(displayBuffer.setScrollTop(-10)).toBe 0
+      expect(displayBuffer.getScrollTop()).toBe 0
+
+    it "disallows values that would make ::getScrollBottom() exceed ::getScrollHeight()", ->
+      displayBuffer.setHeight(50)
+      maxScrollTop = displayBuffer.getScrollHeight() - displayBuffer.getHeight()
+
+      expect(displayBuffer.setScrollTop(maxScrollTop)).toBe maxScrollTop
+      expect(displayBuffer.getScrollTop()).toBe maxScrollTop
+
+      expect(displayBuffer.setScrollTop(maxScrollTop + 50)).toBe maxScrollTop
+      expect(displayBuffer.getScrollTop()).toBe maxScrollTop
+
+  describe "::setScrollLeft", ->
+    beforeEach ->
+      displayBuffer.manageScrollPosition = true
+      displayBuffer.setLineHeightInPixels(10)
+      displayBuffer.setDefaultCharWidth(10)
+
+    it "disallows negative values", ->
+      displayBuffer.setWidth(displayBuffer.getScrollWidth() + 100)
+      expect(displayBuffer.setScrollLeft(-10)).toBe 0
+      expect(displayBuffer.getScrollLeft()).toBe 0
+
+    it "disallows values that would make ::getScrollRight() exceed ::getScrollWidth()", ->
+      displayBuffer.setWidth(50)
+      maxScrollLeft = displayBuffer.getScrollWidth() - displayBuffer.getWidth()
+
+      expect(displayBuffer.setScrollLeft(maxScrollLeft)).toBe maxScrollLeft
+      expect(displayBuffer.getScrollLeft()).toBe maxScrollLeft
+
+      expect(displayBuffer.setScrollLeft(maxScrollLeft + 50)).toBe maxScrollLeft
+      expect(displayBuffer.getScrollLeft()).toBe maxScrollLeft
+
+  describe "::scrollToScreenPosition(position)", ->
+    it "sets the scroll top and scroll left so the given screen position is in view", ->
+      displayBuffer.manageScrollPosition = true
+      displayBuffer.setLineHeightInPixels(10)
+      displayBuffer.setDefaultCharWidth(10)
+      displayBuffer.setHorizontalScrollbarHeight(0)
+
+      displayBuffer.setHeight(50)
+      displayBuffer.setWidth(50)
+      maxScrollTop = displayBuffer.getScrollHeight() - displayBuffer.getHeight()
+
+      displayBuffer.scrollToScreenPosition([8, 20])
+      expect(displayBuffer.getScrollBottom()).toBe (9 + displayBuffer.getVerticalScrollMargin()) * 10
+      expect(displayBuffer.getScrollRight()).toBe (20 + displayBuffer.getHorizontalScrollMargin()) * 10

spec/editor-component-spec.coffee

@@ -0,0 +1,856 @@
+_ = require 'underscore-plus'
+{extend, flatten, toArray, last} = _
+
+ReactEditorView = require '../src/react-editor-view'
+nbsp = String.fromCharCode(160)
+
+describe "EditorComponent", ->
+  [contentNode, editor, wrapperView, component, node, verticalScrollbarNode, horizontalScrollbarNode] = []
+  [lineHeightInPixels, charWidth, delayAnimationFrames, nextAnimationFrame, lineOverdrawMargin] = []
+
+  beforeEach ->
+    lineOverdrawMargin = 2
+
+    waitsForPromise ->
+      atom.packages.activatePackage('language-javascript')
+
+    runs ->
+      spyOn(window, "setInterval").andCallFake window.fakeSetInterval
+      spyOn(window, "clearInterval").andCallFake window.fakeClearInterval
+
+      delayAnimationFrames = false
+      nextAnimationFrame = null
+      spyOn(window, 'requestAnimationFrame').andCallFake (fn) ->
+        if delayAnimationFrames
+          nextAnimationFrame = fn
+        else
+          fn()
+
+    waitsForPromise ->
+      atom.project.open('sample.js').then (o) -> editor = o
+
+    runs ->
+      contentNode = document.querySelector('#jasmine-content')
+      contentNode.style.width = '1000px'
+
+      wrapperView = new ReactEditorView(editor, {lineOverdrawMargin})
+      wrapperView.attachToDom()
+      {component} = wrapperView
+      component.setLineHeight(1.3)
+      component.setFontSize(20)
+
+      lineHeightInPixels = editor.getLineHeightInPixels()
+      charWidth = editor.getDefaultCharWidth()
+      node = component.getDOMNode()
+      verticalScrollbarNode = node.querySelector('.vertical-scrollbar')
+      horizontalScrollbarNode = node.querySelector('.horizontal-scrollbar')
+
+      node.style.height = editor.getLineCount() * lineHeightInPixels + 'px'
+      node.style.width = '1000px'
+      component.measureHeightAndWidth()
+
+  afterEach ->
+    contentNode.style.width = ''
+
+  describe "line rendering", ->
+    it "renders the currently-visible lines plus the overdraw margin", ->
+      node.style.height = 4.5 * lineHeightInPixels + 'px'
+      component.measureHeightAndWidth()
+
+      linesNode = node.querySelector('.lines')
+      expect(linesNode.style['-webkit-transform']).toBe "translate3d(0px, 0px, 0px)"
+      expect(node.querySelectorAll('.line').length).toBe 6 + 2 # no margin above
+      expect(component.lineNodeForScreenRow(0).textContent).toBe editor.lineForScreenRow(0).text
+      expect(component.lineNodeForScreenRow(0).offsetTop).toBe 0
+      expect(component.lineNodeForScreenRow(5).textContent).toBe editor.lineForScreenRow(5).text
+      expect(component.lineNodeForScreenRow(5).offsetTop).toBe 5 * lineHeightInPixels
+
+      verticalScrollbarNode.scrollTop = 4.5 * lineHeightInPixels
+      verticalScrollbarNode.dispatchEvent(new UIEvent('scroll'))
+
+      expect(linesNode.style['-webkit-transform']).toBe "translate3d(0px, #{-4.5 * lineHeightInPixels}px, 0px)"
+      expect(node.querySelectorAll('.line').length).toBe 6 + 4 # margin above and below
+      expect(component.lineNodeForScreenRow(2).offsetTop).toBe 2 * lineHeightInPixels
+      expect(component.lineNodeForScreenRow(2).textContent).toBe editor.lineForScreenRow(2).text
+      expect(component.lineNodeForScreenRow(9).offsetTop).toBe 9 * lineHeightInPixels
+      expect(component.lineNodeForScreenRow(9).textContent).toBe editor.lineForScreenRow(9).text
+
+    it "updates the top position of subsequent lines when lines are inserted or removed", ->
+      editor.getBuffer().deleteRows(0, 1)
+      lineNodes = node.querySelectorAll('.line')
+      expect(component.lineNodeForScreenRow(0).offsetTop).toBe 0
+      expect(component.lineNodeForScreenRow(1).offsetTop).toBe 1 * lineHeightInPixels
+      expect(component.lineNodeForScreenRow(2).offsetTop).toBe 2 * lineHeightInPixels
+
+      editor.getBuffer().insert([0, 0], '\n\n')
+      lineNodes = node.querySelectorAll('.line')
+      expect(component.lineNodeForScreenRow(0).offsetTop).toBe 0 * lineHeightInPixels
+      expect(component.lineNodeForScreenRow(1).offsetTop).toBe 1 * lineHeightInPixels
+      expect(component.lineNodeForScreenRow(2).offsetTop).toBe 2 * lineHeightInPixels
+      expect(component.lineNodeForScreenRow(3).offsetTop).toBe 3 * lineHeightInPixels
+      expect(component.lineNodeForScreenRow(4).offsetTop).toBe 4 * lineHeightInPixels
+
+    it "updates the top position of lines when the line height changes", ->
+      initialLineHeightInPixels = editor.getLineHeightInPixels()
+      component.setLineHeight(2)
+
+      newLineHeightInPixels = editor.getLineHeightInPixels()
+      expect(newLineHeightInPixels).not.toBe initialLineHeightInPixels
+      expect(component.lineNodeForScreenRow(1).offsetTop).toBe 1 * newLineHeightInPixels
+
+    it "updates the top position of lines when the font size changes", ->
+      initialLineHeightInPixels = editor.getLineHeightInPixels()
+      component.setFontSize(10)
+
+      newLineHeightInPixels = editor.getLineHeightInPixels()
+      expect(newLineHeightInPixels).not.toBe initialLineHeightInPixels
+      expect(component.lineNodeForScreenRow(1).offsetTop).toBe 1 * newLineHeightInPixels
+
+    it "updates the top position of lines when the font family changes", ->
+      # Can't find a font that changes the line height, but we think one might exist
+      linesComponent = component.refs.scrollView.refs.lines
+      spyOn(linesComponent, 'measureLineHeightInPixelsAndCharWidth').andCallFake -> editor.setLineHeightInPixels(10)
+
+      initialLineHeightInPixels = editor.getLineHeightInPixels()
+      component.setFontFamily('sans-serif')
+
+      expect(linesComponent.measureLineHeightInPixelsAndCharWidth).toHaveBeenCalled()
+      newLineHeightInPixels = editor.getLineHeightInPixels()
+      expect(newLineHeightInPixels).not.toBe initialLineHeightInPixels
+      expect(component.lineNodeForScreenRow(1).offsetTop).toBe 1 * newLineHeightInPixels
+
+    it "renders the .lines div at the full height of the editor if there aren't enough lines to scroll vertically", ->
+      editor.setText('')
+      node.style.height = '300px'
+      component.measureHeightAndWidth()
+
+      linesNode = node.querySelector('.lines')
+      expect(linesNode.offsetHeight).toBe 300
+
+    describe "when showInvisibles is enabled", ->
+      invisibles = null
+
+      beforeEach ->
+        invisibles =
+          eol: 'E'
+          space: 'S'
+          tab: 'T'
+          cr: 'C'
+
+        atom.config.set("editor.showInvisibles", true)
+        atom.config.set("editor.invisibles", invisibles)
+
+      it "re-renders the lines when the showInvisibles config option changes", ->
+        editor.setText " a line with tabs\tand spaces "
+
+        expect(component.lineNodeForScreenRow(0).textContent).toBe "#{invisibles.space}a line with tabs#{invisibles.tab} and spaces#{invisibles.space}#{invisibles.eol}"
+        atom.config.set("editor.showInvisibles", false)
+        expect(component.lineNodeForScreenRow(0).textContent).toBe " a line with tabs  and spaces "
+        atom.config.set("editor.showInvisibles", true)
+        expect(component.lineNodeForScreenRow(0).textContent).toBe "#{invisibles.space}a line with tabs#{invisibles.tab} and spaces#{invisibles.space}#{invisibles.eol}"
+
+      it "displays spaces, tabs, and newlines as visible characters", ->
+        editor.setText " a line with tabs\tand spaces "
+        expect(component.lineNodeForScreenRow(0).textContent).toBe "#{invisibles.space}a line with tabs#{invisibles.tab} and spaces#{invisibles.space}#{invisibles.eol}"
+
+      it "displays newlines as their own token outside of the other tokens' scopes", ->
+        editor.setText "var"
+        expect(component.lineNodeForScreenRow(0).innerHTML).toBe "<span class=\"source js\"><span class=\"storage modifier js\">var</span></span><span class=\"invisible-character\">#{invisibles.eol}</span>"
+
+      it "displays trailing carriage returns using a visible, non-empty value", ->
+        editor.setText "a line that ends with a carriage return\r\n"
+        expect(component.lineNodeForScreenRow(0).textContent).toBe "a line that ends with a carriage return#{invisibles.cr}#{invisibles.eol}"
+
+      describe "when soft wrapping is enabled", ->
+        beforeEach ->
+          editor.setText "a line that wraps "
+          editor.setSoftWrap(true)
+          node.style.width = 15 * charWidth + 'px'
+          component.measureHeightAndWidth()
+
+        it "doesn't show end of line invisibles at the end of wrapped lines", ->
+          expect(component.lineNodeForScreenRow(0).textContent).toBe "a line that "
+          expect(component.lineNodeForScreenRow(1).textContent).toBe "wraps#{invisibles.space}#{invisibles.eol}"
+
+    describe "when indent guides are enabled", ->
+      beforeEach ->
+        component.setShowIndentGuide(true)
+
+      it "adds an 'indent-guide' class to spans comprising the leading whitespace", ->
+        line1LeafNodes = getLeafNodes(component.lineNodeForScreenRow(1))
+        expect(line1LeafNodes[0].textContent).toBe '  '
+        expect(line1LeafNodes[0].classList.contains('indent-guide')).toBe true
+        expect(line1LeafNodes[1].classList.contains('indent-guide')).toBe false
+
+        line2LeafNodes = getLeafNodes(component.lineNodeForScreenRow(2))
+        expect(line2LeafNodes[0].textContent).toBe '  '
+        expect(line2LeafNodes[0].classList.contains('indent-guide')).toBe true
+        expect(line2LeafNodes[1].textContent).toBe '  '
+        expect(line2LeafNodes[1].classList.contains('indent-guide')).toBe true
+        expect(line2LeafNodes[2].classList.contains('indent-guide')).toBe false
+
+      it "renders leading whitespace spans with the 'indent-guide' class for empty lines", ->
+        editor.getBuffer().insert([1, Infinity], '\n')
+
+        line2LeafNodes = getLeafNodes(component.lineNodeForScreenRow(2))
+
+        expect(line2LeafNodes.length).toBe 3
+        expect(line2LeafNodes[0].textContent).toBe '  '
+        expect(line2LeafNodes[0].classList.contains('indent-guide')).toBe true
+        expect(line2LeafNodes[1].textContent).toBe '  '
+        expect(line2LeafNodes[1].classList.contains('indent-guide')).toBe true
+        expect(line2LeafNodes[2].textContent).toBe '  '
+        expect(line2LeafNodes[2].classList.contains('indent-guide')).toBe true
+
+      it "renders indent guides correctly on lines containing only whitespace", ->
+        editor.getBuffer().insert([1, Infinity], '\n      ')
+        line2LeafNodes = getLeafNodes(component.lineNodeForScreenRow(2))
+        expect(line2LeafNodes.length).toBe 3
+        expect(line2LeafNodes[0].textContent).toBe '  '
+        expect(line2LeafNodes[0].classList.contains('indent-guide')).toBe true
+        expect(line2LeafNodes[1].textContent).toBe '  '
+        expect(line2LeafNodes[1].classList.contains('indent-guide')).toBe true
+        expect(line2LeafNodes[2].textContent).toBe '  '
+        expect(line2LeafNodes[2].classList.contains('indent-guide')).toBe true
+
+      it "does not render indent guides in trailing whitespace for lines containing non whitespace characters", ->
+        editor.getBuffer().setText "  hi  "
+        line0LeafNodes = getLeafNodes(component.lineNodeForScreenRow(0))
+        expect(line0LeafNodes[0].textContent).toBe '  '
+        expect(line0LeafNodes[0].classList.contains('indent-guide')).toBe true
+        expect(line0LeafNodes[1].textContent).toBe '  '
+        expect(line0LeafNodes[1].classList.contains('indent-guide')).toBe false
+
+      getLeafNodes = (node) ->
+        if node.children.length > 0
+          flatten(toArray(node.children).map(getLeafNodes))
+        else
+          [node]
+
+  describe "gutter rendering", ->
+    it "renders the currently-visible line numbers", ->
+      node.style.height = 4.5 * lineHeightInPixels + 'px'
+      component.measureHeightAndWidth()
+
+      expect(node.querySelectorAll('.line-number').length).toBe 6 + 2 + 1 # line overdraw margin below + dummy line number
+      expect(component.lineNumberNodeForScreenRow(0).textContent).toBe "#{nbsp}1"
+      expect(component.lineNumberNodeForScreenRow(5).textContent).toBe "#{nbsp}6"
+
+      verticalScrollbarNode.scrollTop = 2.5 * lineHeightInPixels
+      verticalScrollbarNode.dispatchEvent(new UIEvent('scroll'))
+
+      expect(node.querySelectorAll('.line-number').length).toBe 6 + 4 + 1 # line overdraw margin above/below + dummy line number
+
+      expect(component.lineNumberNodeForScreenRow(2).textContent).toBe "#{nbsp}3"
+      expect(component.lineNumberNodeForScreenRow(2).offsetTop).toBe 2 * lineHeightInPixels
+      return
+      expect(component.lineNumberNodeForScreenRow(7).textContent).toBe "#{nbsp}8"
+      expect(component.lineNumberNodeForScreenRow(7).offsetTop).toBe 7 * lineHeightInPixels
+
+    it "updates the translation of subsequent line numbers when lines are inserted or removed", ->
+      editor.getBuffer().insert([0, 0], '\n\n')
+
+      lineNumberNodes = node.querySelectorAll('.line-number')
+      expect(component.lineNumberNodeForScreenRow(0).offsetTop).toBe 0
+      expect(component.lineNumberNodeForScreenRow(1).offsetTop).toBe 1 * lineHeightInPixels
+      expect(component.lineNumberNodeForScreenRow(2).offsetTop).toBe 2 * lineHeightInPixels
+      expect(component.lineNumberNodeForScreenRow(3).offsetTop).toBe 3 * lineHeightInPixels
+      expect(component.lineNumberNodeForScreenRow(4).offsetTop).toBe 4 * lineHeightInPixels
+
+      editor.getBuffer().insert([0, 0], '\n\n')
+      expect(component.lineNumberNodeForScreenRow(0).offsetTop).toBe 0
+      expect(component.lineNumberNodeForScreenRow(1).offsetTop).toBe 1 * lineHeightInPixels
+      expect(component.lineNumberNodeForScreenRow(2).offsetTop).toBe 2 * lineHeightInPixels
+      expect(component.lineNumberNodeForScreenRow(3).offsetTop).toBe 3 * lineHeightInPixels
+      expect(component.lineNumberNodeForScreenRow(4).offsetTop).toBe 4 * lineHeightInPixels
+      expect(component.lineNumberNodeForScreenRow(5).offsetTop).toBe 5 * lineHeightInPixels
+      expect(component.lineNumberNodeForScreenRow(6).offsetTop).toBe 6 * lineHeightInPixels
+
+    it "renders • characters for soft-wrapped lines", ->
+      editor.setSoftWrap(true)
+      node.style.height = 4.5 * lineHeightInPixels + 'px'
+      node.style.width = 30 * charWidth + 'px'
+      component.measureHeightAndWidth()
+
+      expect(node.querySelectorAll('.line-number').length).toBe 6 + lineOverdrawMargin + 1 # 1 dummy line node
+      expect(component.lineNumberNodeForScreenRow(0).textContent).toBe "#{nbsp}1"
+      expect(component.lineNumberNodeForScreenRow(1).textContent).toBe "#{nbsp}•"
+      expect(component.lineNumberNodeForScreenRow(2).textContent).toBe "#{nbsp}2"
+      expect(component.lineNumberNodeForScreenRow(3).textContent).toBe "#{nbsp}•"
+      expect(component.lineNumberNodeForScreenRow(4).textContent).toBe "#{nbsp}3"
+      expect(component.lineNumberNodeForScreenRow(5).textContent).toBe "#{nbsp}•"
+
+    it "pads line numbers to be right-justified based on the maximum number of line number digits", ->
+      editor.getBuffer().setText([1..10].join('\n'))
+      for screenRow in [0..8]
+        expect(component.lineNumberNodeForScreenRow(screenRow).textContent).toBe "#{nbsp}#{screenRow + 1}"
+      expect(component.lineNumberNodeForScreenRow(9).textContent).toBe "10"
+
+      gutterNode = node.querySelector('.gutter')
+      initialGutterWidth = gutterNode.offsetWidth
+
+      # Removes padding when the max number of digits goes down
+      editor.getBuffer().delete([[1, 0], [2, 0]])
+      for screenRow in [0..8]
+        expect(component.lineNumberNodeForScreenRow(screenRow).textContent).toBe "#{screenRow + 1}"
+      expect(gutterNode.offsetWidth).toBeLessThan initialGutterWidth
+
+      # Increases padding when the max number of digits goes up
+      editor.getBuffer().insert([0, 0], '\n\n')
+      for screenRow in [0..8]
+        expect(component.lineNumberNodeForScreenRow(screenRow).textContent).toBe "#{nbsp}#{screenRow + 1}"
+      expect(component.lineNumberNodeForScreenRow(9).textContent).toBe "10"
+      expect(gutterNode.offsetWidth).toBe initialGutterWidth
+
+  describe "cursor rendering", ->
+    it "renders the currently visible cursors, translated relative to the scroll position", ->
+      cursor1 = editor.getCursor()
+      cursor1.setScreenPosition([0, 5])
+
+      node.style.height = 4.5 * lineHeightInPixels + 'px'
+      node.style.width = 20 * lineHeightInPixels + 'px'
+      component.measureHeightAndWidth()
+
+      cursorNodes = node.querySelectorAll('.cursor')
+      expect(cursorNodes.length).toBe 1
+      expect(cursorNodes[0].offsetHeight).toBe lineHeightInPixels
+      expect(cursorNodes[0].offsetWidth).toBe charWidth
+      expect(cursorNodes[0].style['-webkit-transform']).toBe "translate3d(#{5 * charWidth}px, #{0 * lineHeightInPixels}px, 0px)"
+
+      cursor2 = editor.addCursorAtScreenPosition([6, 11])
+      cursor3 = editor.addCursorAtScreenPosition([4, 10])
+
+      cursorNodes = node.querySelectorAll('.cursor')
+      expect(cursorNodes.length).toBe 2
+      expect(cursorNodes[0].offsetTop).toBe 0
+      expect(cursorNodes[0].style['-webkit-transform']).toBe "translate3d(#{5 * charWidth}px, #{0 * lineHeightInPixels}px, 0px)"
+      expect(cursorNodes[1].style['-webkit-transform']).toBe "translate3d(#{10 * charWidth}px, #{4 * lineHeightInPixels}px, 0px)"
+
+      verticalScrollbarNode.scrollTop = 2.5 * lineHeightInPixels
+      verticalScrollbarNode.dispatchEvent(new UIEvent('scroll'))
+      horizontalScrollbarNode.scrollLeft = 3.5 * charWidth
+      horizontalScrollbarNode.dispatchEvent(new UIEvent('scroll'))
+
+      cursorNodes = node.querySelectorAll('.cursor')
+      expect(cursorNodes.length).toBe 2
+      expect(cursorNodes[0].style['-webkit-transform']).toBe "translate3d(#{(11 - 3.5) * charWidth}px, #{(6 - 2.5) * lineHeightInPixels}px, 0px)"
+      expect(cursorNodes[1].style['-webkit-transform']).toBe "translate3d(#{(10 - 3.5) * charWidth}px, #{(4 - 2.5) * lineHeightInPixels}px, 0px)"
+
+      cursor3.destroy()
+      cursorNodes = node.querySelectorAll('.cursor')
+      expect(cursorNodes.length).toBe 1
+      expect(cursorNodes[0].style['-webkit-transform']).toBe "translate3d(#{(11 - 3.5) * charWidth}px, #{(6 - 2.5) * lineHeightInPixels}px, 0px)"
+
+    it "accounts for character widths when positioning cursors", ->
+      atom.config.set('editor.fontFamily', 'sans-serif')
+      editor.setCursorScreenPosition([0, 16])
+
+      cursor = node.querySelector('.cursor')
+      cursorRect = cursor.getBoundingClientRect()
+
+      cursorLocationTextNode = component.lineNodeForScreenRow(0).querySelector('.storage.type.function.js').firstChild
+      range = document.createRange()
+      range.setStart(cursorLocationTextNode, 0)
+      range.setEnd(cursorLocationTextNode, 1)
+      rangeRect = range.getBoundingClientRect()
+
+      expect(cursorRect.left).toBe rangeRect.left
+      expect(cursorRect.width).toBe rangeRect.width
+
+    it "blinks cursors when they aren't moving", ->
+      spyOn(_._, 'now').andCallFake -> window.now # Ensure _.debounce is based on our fake spec timeline
+      cursorsNode = node.querySelector('.cursors')
+
+      expect(cursorsNode.classList.contains('blink-off')).toBe false
+      advanceClock(component.props.cursorBlinkPeriod / 2)
+      expect(cursorsNode.classList.contains('blink-off')).toBe true
+      advanceClock(component.props.cursorBlinkPeriod / 2)
+      expect(cursorsNode.classList.contains('blink-off')).toBe false
+
+      # Stop blinking after moving the cursor
+      editor.moveCursorRight()
+      expect(cursorsNode.classList.contains('blink-off')).toBe false
+
+      advanceClock(component.props.cursorBlinkResumeDelay)
+      advanceClock(component.props.cursorBlinkPeriod / 2)
+      expect(cursorsNode.classList.contains('blink-off')).toBe true
+
+    it "does not render cursors that are associated with non-empty selections", ->
+      editor.setSelectedScreenRange([[0, 4], [4, 6]])
+      editor.addCursorAtScreenPosition([6, 8])
+
+      cursorNodes = node.querySelectorAll('.cursor')
+      expect(cursorNodes.length).toBe 1
+      expect(cursorNodes[0].style['-webkit-transform']).toBe "translate3d(#{8 * charWidth}px, #{6 * lineHeightInPixels}px, 0px)"
+
+  describe "selection rendering", ->
+    [scrollViewNode, scrollViewClientLeft] = []
+
+    beforeEach ->
+      scrollViewNode = node.querySelector('.scroll-view')
+      scrollViewClientLeft = node.querySelector('.scroll-view').getBoundingClientRect().left
+
+    it "renders 1 region for 1-line selections", ->
+      # 1-line selection
+      editor.setSelectedScreenRange([[1, 6], [1, 10]])
+      regions = node.querySelectorAll('.selection .region')
+
+      expect(regions.length).toBe 1
+      regionRect = regions[0].getBoundingClientRect()
+      expect(regionRect.top).toBe 1 * lineHeightInPixels
+      expect(regionRect.height).toBe 1 * lineHeightInPixels
+      expect(regionRect.left).toBe scrollViewClientLeft + 6 * charWidth
+      expect(regionRect.width).toBe 4 * charWidth
+
+    it "renders 2 regions for 2-line selections", ->
+      editor.setSelectedScreenRange([[1, 6], [2, 10]])
+      regions = node.querySelectorAll('.selection .region')
+      expect(regions.length).toBe 2
+
+      region1Rect = regions[0].getBoundingClientRect()
+      expect(region1Rect.top).toBe 1 * lineHeightInPixels
+      expect(region1Rect.height).toBe 1 * lineHeightInPixels
+      expect(region1Rect.left).toBe scrollViewClientLeft + 6 * charWidth
+      expect(region1Rect.right).toBe scrollViewNode.getBoundingClientRect().right
+
+      region2Rect = regions[1].getBoundingClientRect()
+      expect(region2Rect.top).toBe 2 * lineHeightInPixels
+      expect(region2Rect.height).toBe 1 * lineHeightInPixels
+      expect(region2Rect.left).toBe scrollViewClientLeft + 0
+      expect(region2Rect.width).toBe 10 * charWidth
+
+    it "renders 3 regions for selections with more than 2 lines", ->
+      editor.setSelectedScreenRange([[1, 6], [5, 10]])
+      regions = node.querySelectorAll('.selection .region')
+      expect(regions.length).toBe 3
+
+      region1Rect = regions[0].getBoundingClientRect()
+      expect(region1Rect.top).toBe 1 * lineHeightInPixels
+      expect(region1Rect.height).toBe 1 * lineHeightInPixels
+      expect(region1Rect.left).toBe scrollViewClientLeft + 6 * charWidth
+      expect(region1Rect.right).toBe scrollViewNode.getBoundingClientRect().right
+
+      region2Rect = regions[1].getBoundingClientRect()
+      expect(region2Rect.top).toBe 2 * lineHeightInPixels
+      expect(region2Rect.height).toBe 3 * lineHeightInPixels
+      expect(region2Rect.left).toBe scrollViewClientLeft + 0
+      expect(region2Rect.right).toBe scrollViewNode.getBoundingClientRect().right
+
+      region3Rect = regions[2].getBoundingClientRect()
+      expect(region3Rect.top).toBe 5 * lineHeightInPixels
+      expect(region3Rect.height).toBe 1 * lineHeightInPixels
+      expect(region3Rect.left).toBe scrollViewClientLeft + 0
+      expect(region3Rect.width).toBe 10 * charWidth
+
+    it "does not render empty selections unless they are the first selection (to prevent a Chromium rendering artifact caused by removing it)", ->
+      editor.addSelectionForBufferRange([[2, 2], [2, 2]])
+      expect(editor.getSelection(0).isEmpty()).toBe true
+      expect(editor.getSelection(1).isEmpty()).toBe true
+
+      expect(node.querySelectorAll('.selection').length).toBe 1
+
+  describe "hidden input field", ->
+    it "renders the hidden input field at the position of the last cursor if the cursor is on screen and the editor is focused", ->
+      editor.setVerticalScrollMargin(0)
+      editor.setHorizontalScrollMargin(0)
+
+      inputNode = node.querySelector('.hidden-input')
+      node.style.height = 5 * lineHeightInPixels + 'px'
+      node.style.width = 10 * charWidth + 'px'
+      component.measureHeightAndWidth()
+
+      expect(editor.getCursorScreenPosition()).toEqual [0, 0]
+      editor.setScrollTop(3 * lineHeightInPixels)
+      editor.setScrollLeft(3 * charWidth)
+
+      expect(inputNode.offsetTop).toBe 0
+      expect(inputNode.offsetLeft).toBe 0
+
+      # In bounds, not focused
+      editor.setCursorBufferPosition([5, 4])
+      expect(inputNode.offsetTop).toBe 0
+      expect(inputNode.offsetLeft).toBe 0
+
+      # In bounds and focused
+      inputNode.focus()
+      expect(inputNode.offsetTop).toBe (5 * lineHeightInPixels) - editor.getScrollTop()
+      expect(inputNode.offsetLeft).toBe (4 * charWidth) - editor.getScrollLeft()
+
+      # In bounds, not focused
+      inputNode.blur()
+      expect(inputNode.offsetTop).toBe 0
+      expect(inputNode.offsetLeft).toBe 0
+
+      # Out of bounds, not focused
+      editor.setCursorBufferPosition([1, 2])
+      expect(inputNode.offsetTop).toBe 0
+      expect(inputNode.offsetLeft).toBe 0
+
+      # Out of bounds, focused
+      inputNode.focus()
+      expect(inputNode.offsetTop).toBe 0
+      expect(inputNode.offsetLeft).toBe 0
+
+  describe "mouse interactions", ->
+    linesNode = null
+
+    beforeEach ->
+      delayAnimationFrames = true
+      linesNode = node.querySelector('.lines')
+
+    describe "when a non-folded line is single-clicked", ->
+      describe "when no modifier keys are held down", ->
+        it "moves the cursor to the nearest screen position", ->
+          node.style.height = 4.5 * lineHeightInPixels + 'px'
+          node.style.width = 10 * charWidth + 'px'
+          component.measureHeightAndWidth()
+          editor.setScrollTop(3.5 * lineHeightInPixels)
+          editor.setScrollLeft(2 * charWidth)
+
+          linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([4, 8])))
+          expect(editor.getCursorScreenPosition()).toEqual [4, 8]
+
+      describe "when the shift key is held down", ->
+        it "selects to the nearest screen position", ->
+          editor.setCursorScreenPosition([3, 4])
+          linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([5, 6]), shiftKey: true))
+          expect(editor.getSelectedScreenRange()).toEqual [[3, 4], [5, 6]]
+
+      describe "when the command key is held down", ->
+        it "adds a cursor at the nearest screen position", ->
+          editor.setCursorScreenPosition([3, 4])
+          linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([5, 6]), metaKey: true))
+          expect(editor.getSelectedScreenRanges()).toEqual [[[3, 4], [3, 4]], [[5, 6], [5, 6]]]
+
+    describe "when a non-folded line is double-clicked", ->
+      it "selects the word containing the nearest screen position", ->
+        linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([5, 10]), detail: 2))
+        linesNode.dispatchEvent(buildMouseEvent('mouseup'))
+        expect(editor.getSelectedScreenRange()).toEqual [[5, 6], [5, 13]]
+
+        linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([6, 6]), detail: 1))
+        linesNode.dispatchEvent(buildMouseEvent('mouseup'))
+        expect(editor.getSelectedScreenRange()).toEqual [[6, 6], [6, 6]]
+
+        linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([8, 8]), detail: 1, shiftKey: true))
+        linesNode.dispatchEvent(buildMouseEvent('mouseup'))
+        expect(editor.getSelectedScreenRange()).toEqual [[6, 6], [8, 8]]
+
+    describe "when a non-folded line is triple-clicked", ->
+      it "selects the line containing the nearest screen position", ->
+        linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([5, 10]), detail: 3))
+        linesNode.dispatchEvent(buildMouseEvent('mouseup'))
+        expect(editor.getSelectedScreenRange()).toEqual [[5, 0], [6, 0]]
+
+        linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([6, 6]), detail: 1, shiftKey: true))
+        linesNode.dispatchEvent(buildMouseEvent('mouseup'))
+        expect(editor.getSelectedScreenRange()).toEqual [[5, 0], [7, 0]]
+
+        linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([7, 5]), detail: 1))
+        linesNode.dispatchEvent(buildMouseEvent('mouseup'))
+        linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([8, 8]), detail: 1, shiftKey: true))
+        linesNode.dispatchEvent(buildMouseEvent('mouseup'))
+        expect(editor.getSelectedScreenRange()).toEqual [[7, 5], [8, 8]]
+
+    describe "when the mouse is clicked and dragged", ->
+      it "selects to the nearest screen position until the mouse button is released", ->
+        linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([2, 4]), which: 1))
+        linesNode.dispatchEvent(buildMouseEvent('mousemove', clientCoordinatesForScreenPosition([6, 8]), which: 1))
+        nextAnimationFrame()
+        expect(editor.getSelectedScreenRange()).toEqual [[2, 4], [6, 8]]
+
+        linesNode.dispatchEvent(buildMouseEvent('mousemove', clientCoordinatesForScreenPosition([10, 0]), which: 1))
+        nextAnimationFrame()
+        expect(editor.getSelectedScreenRange()).toEqual [[2, 4], [10, 0]]
+
+        linesNode.dispatchEvent(buildMouseEvent('mouseup'))
+        linesNode.dispatchEvent(buildMouseEvent('mousemove', clientCoordinatesForScreenPosition([12, 0]), which: 1))
+        nextAnimationFrame()
+        expect(editor.getSelectedScreenRange()).toEqual [[2, 4], [10, 0]]
+
+      it "stops selecting if the mouse is dragged into the dev tools", ->
+        linesNode.dispatchEvent(buildMouseEvent('mousedown', clientCoordinatesForScreenPosition([2, 4]), which: 1))
+        linesNode.dispatchEvent(buildMouseEvent('mousemove', clientCoordinatesForScreenPosition([6, 8]), which: 1))
+        nextAnimationFrame()
+        expect(editor.getSelectedScreenRange()).toEqual [[2, 4], [6, 8]]
+
+        linesNode.dispatchEvent(buildMouseEvent('mousemove', clientCoordinatesForScreenPosition([10, 0]), which: 0))
+        nextAnimationFrame()
+        expect(editor.getSelectedScreenRange()).toEqual [[2, 4], [6, 8]]
+
+        linesNode.dispatchEvent(buildMouseEvent('mousemove', clientCoordinatesForScreenPosition([8, 0]), which: 1))
+        nextAnimationFrame()
+        expect(editor.getSelectedScreenRange()).toEqual [[2, 4], [6, 8]]
+
+    clientCoordinatesForScreenPosition = (screenPosition) ->
+      positionOffset = editor.pixelPositionForScreenPosition(screenPosition)
+      scrollViewClientRect = node.querySelector('.scroll-view').getBoundingClientRect()
+      clientX = scrollViewClientRect.left + positionOffset.left - editor.getScrollLeft()
+      clientY = scrollViewClientRect.top + positionOffset.top - editor.getScrollTop()
+      {clientX, clientY}
+
+    buildMouseEvent = (type, properties...) ->
+      properties = extend({bubbles: true, cancelable: true}, properties...)
+      event = new MouseEvent(type, properties)
+      Object.defineProperty(event, 'which', get: -> properties.which) if properties.which?
+      event
+
+  describe "focus handling", ->
+    inputNode = null
+
+    beforeEach ->
+      inputNode = node.querySelector('.hidden-input')
+
+    it "transfers focus to the hidden input", ->
+      expect(document.activeElement).toBe document.body
+      node.focus()
+      expect(document.activeElement).toBe inputNode
+
+    it "adds the 'is-focused' class to the editor when the hidden input is focused", ->
+      expect(document.activeElement).toBe document.body
+      inputNode.focus()
+      expect(node.classList.contains('is-focused')).toBe true
+      inputNode.blur()
+      expect(node.classList.contains('is-focused')).toBe false
+
+  describe "scrolling", ->
+    it "updates the vertical scrollbar when the scrollTop is changed in the model", ->
+      node.style.height = 4.5 * lineHeightInPixels + 'px'
+      component.measureHeightAndWidth()
+
+      expect(verticalScrollbarNode.scrollTop).toBe 0
+
+      editor.setScrollTop(10)
+      expect(verticalScrollbarNode.scrollTop).toBe 10
+
+    it "updates the horizontal scrollbar and the x transform of the lines based on the scrollLeft of the model", ->
+      node.style.width = 30 * charWidth + 'px'
+      component.measureHeightAndWidth()
+
+      linesNode = node.querySelector('.lines')
+      expect(linesNode.style['-webkit-transform']).toBe "translate3d(0px, 0px, 0px)"
+      expect(horizontalScrollbarNode.scrollLeft).toBe 0
+
+      editor.setScrollLeft(100)
+      expect(linesNode.style['-webkit-transform']).toBe "translate3d(-100px, 0px, 0px)"
+      expect(horizontalScrollbarNode.scrollLeft).toBe 100
+
+    it "updates the scrollLeft of the model when the scrollLeft of the horizontal scrollbar changes", ->
+      node.style.width = 30 * charWidth + 'px'
+      component.measureHeightAndWidth()
+
+      expect(editor.getScrollLeft()).toBe 0
+      horizontalScrollbarNode.scrollLeft = 100
+      horizontalScrollbarNode.dispatchEvent(new UIEvent('scroll'))
+
+      expect(editor.getScrollLeft()).toBe 100
+
+    it "does not obscure the last line with the horizontal scrollbar", ->
+      node.style.height = 4.5 * lineHeightInPixels + 'px'
+      node.style.width = 10 * charWidth + 'px'
+      component.measureHeightAndWidth()
+      editor.setScrollBottom(editor.getScrollHeight())
+      lastLineNode = component.lineNodeForScreenRow(editor.getLastScreenRow())
+      bottomOfLastLine = lastLineNode.getBoundingClientRect().bottom
+      topOfHorizontalScrollbar = horizontalScrollbarNode.getBoundingClientRect().top
+      expect(bottomOfLastLine).toBe topOfHorizontalScrollbar
+
+      # Scroll so there's no space below the last line when the horizontal scrollbar disappears
+      node.style.width = 100 * charWidth + 'px'
+      component.measureHeightAndWidth()
+      bottomOfLastLine = lastLineNode.getBoundingClientRect().bottom
+      bottomOfEditor = node.getBoundingClientRect().bottom
+      expect(bottomOfLastLine).toBe bottomOfEditor
+
+    it "does not obscure the last character of the longest line with the vertical scrollbar", ->
+      node.style.height = 7 * lineHeightInPixels + 'px'
+      node.style.width = 10 * charWidth + 'px'
+      component.measureHeightAndWidth()
+
+      editor.setScrollLeft(Infinity)
+
+      rightOfLongestLine = component.lineNodeForScreenRow(6).getBoundingClientRect().right
+      leftOfVerticalScrollbar = verticalScrollbarNode.getBoundingClientRect().left
+      expect(Math.round(rightOfLongestLine)).toBe leftOfVerticalScrollbar - 1 # Leave 1 px so the cursor is visible on the end of the line
+
+    it "only displays dummy scrollbars when scrollable in that direction", ->
+      expect(verticalScrollbarNode.style.display).toBe 'none'
+      expect(horizontalScrollbarNode.style.display).toBe 'none'
+
+      node.style.height = 4.5 * lineHeightInPixels + 'px'
+      node.style.width = '1000px'
+      component.measureHeightAndWidth()
+
+      expect(verticalScrollbarNode.style.display).toBe ''
+      expect(horizontalScrollbarNode.style.display).toBe 'none'
+
+      node.style.width = 10 * charWidth + 'px'
+      component.measureHeightAndWidth()
+
+      expect(verticalScrollbarNode.style.display).toBe ''
+      expect(horizontalScrollbarNode.style.display).toBe ''
+
+      node.style.height = 20 * lineHeightInPixels + 'px'
+      component.measureHeightAndWidth()
+
+      expect(verticalScrollbarNode.style.display).toBe 'none'
+      expect(horizontalScrollbarNode.style.display).toBe ''
+
+    it "makes the dummy scrollbar divs only as tall/wide as the actual scrollbars", ->
+      node.style.height = 4 * lineHeightInPixels + 'px'
+      node.style.width = 10 * charWidth + 'px'
+      component.measureHeightAndWidth()
+
+      atom.themes.applyStylesheet "test", """
+        ::-webkit-scrollbar {
+          width: 8px;
+          height: 8px;
+        }
+      """
+
+      scrollbarCornerNode = node.querySelector('.scrollbar-corner')
+      expect(verticalScrollbarNode.offsetWidth).toBe 8
+      expect(horizontalScrollbarNode.offsetHeight).toBe 8
+      expect(scrollbarCornerNode.offsetWidth).toBe 8
+      expect(scrollbarCornerNode.offsetHeight).toBe 8
+
+    it "assigns the bottom/right of the scrollbars to the width of the opposite scrollbar if it is visible", ->
+      scrollbarCornerNode = node.querySelector('.scrollbar-corner')
+
+      expect(verticalScrollbarNode.style.bottom).toBe ''
+      expect(horizontalScrollbarNode.style.right).toBe ''
+
+      node.style.height = 4.5 * lineHeightInPixels + 'px'
+      node.style.width = '1000px'
+      component.measureHeightAndWidth()
+      expect(verticalScrollbarNode.style.bottom).toBe ''
+      expect(horizontalScrollbarNode.style.right).toBe verticalScrollbarNode.offsetWidth + 'px'
+      expect(scrollbarCornerNode.style.display).toBe 'none'
+
+      node.style.width = 10 * charWidth + 'px'
+      component.measureHeightAndWidth()
+      expect(verticalScrollbarNode.style.bottom).toBe horizontalScrollbarNode.offsetHeight + 'px'
+      expect(horizontalScrollbarNode.style.right).toBe verticalScrollbarNode.offsetWidth + 'px'
+      expect(scrollbarCornerNode.style.display).toBe ''
+
+      node.style.height = 20 * lineHeightInPixels + 'px'
+      component.measureHeightAndWidth()
+      expect(verticalScrollbarNode.style.bottom).toBe horizontalScrollbarNode.offsetHeight + 'px'
+      expect(horizontalScrollbarNode.style.right).toBe ''
+      expect(scrollbarCornerNode.style.display).toBe 'none'
+
+    it "accounts for the width of the gutter in the scrollWidth of the horizontal scrollbar", ->
+      gutterNode = node.querySelector('.gutter')
+      node.style.width = 10 * charWidth + 'px'
+      component.measureHeightAndWidth()
+
+      expect(horizontalScrollbarNode.scrollWidth).toBe gutterNode.offsetWidth + editor.getScrollWidth()
+
+    describe "when a mousewheel event occurs on the editor", ->
+      it "updates the horizontal or vertical scrollbar depending on which delta is greater (x or y)", ->
+        node.style.height = 4.5 * lineHeightInPixels + 'px'
+        node.style.width = 20 * charWidth + 'px'
+        component.measureHeightAndWidth()
+
+        expect(verticalScrollbarNode.scrollTop).toBe 0
+        expect(horizontalScrollbarNode.scrollLeft).toBe 0
+
+        node.dispatchEvent(new WheelEvent('mousewheel', wheelDeltaX: -5, wheelDeltaY: -10))
+        expect(verticalScrollbarNode.scrollTop).toBe 10
+        expect(horizontalScrollbarNode.scrollLeft).toBe 0
+
+        node.dispatchEvent(new WheelEvent('mousewheel', wheelDeltaX: -15, wheelDeltaY: -5))
+        expect(verticalScrollbarNode.scrollTop).toBe 10
+        expect(horizontalScrollbarNode.scrollLeft).toBe 15
+
+      describe "when the mousewheel event's target is a line", ->
+        it "keeps the line on the DOM if it is scrolled off-screen", ->
+          node.style.height = 4.5 * lineHeightInPixels + 'px'
+          node.style.width = 20 * charWidth + 'px'
+          component.measureHeightAndWidth()
+
+          lineNode = node.querySelector('.line')
+          wheelEvent = new WheelEvent('mousewheel', wheelDeltaX: 0, wheelDeltaY: -500)
+          Object.defineProperty(wheelEvent, 'target', get: -> lineNode)
+          node.dispatchEvent(wheelEvent)
+
+          expect(node.contains(lineNode)).toBe true
+
+      describe "when the mousewheel event's target is a line number", ->
+        it "keeps the line number on the DOM if it is scrolled off-screen", ->
+          node.style.height = 4.5 * lineHeightInPixels + 'px'
+          node.style.width = 20 * charWidth + 'px'
+          component.measureHeightAndWidth()
+
+          lineNumberNode = node.querySelectorAll('.line-number')[1]
+          wheelEvent = new WheelEvent('mousewheel', wheelDeltaX: 0, wheelDeltaY: -500)
+          Object.defineProperty(wheelEvent, 'target', get: -> lineNumberNode)
+          node.dispatchEvent(wheelEvent)
+
+          expect(node.contains(lineNumberNode)).toBe true
+
+  describe "input events", ->
+    inputNode = null
+
+    beforeEach ->
+      inputNode = node.querySelector('.hidden-input')
+
+    it "inserts the newest character in the input's value into the buffer", ->
+      inputNode.value = 'x'
+      inputNode.dispatchEvent(new Event('input'))
+      expect(editor.lineForBufferRow(0)).toBe 'xvar quicksort = function () {'
+
+      inputNode.value = 'xy'
+      inputNode.dispatchEvent(new Event('input'))
+      expect(editor.lineForBufferRow(0)).toBe 'xyvar quicksort = function () {'
+
+    it "replaces the last character if the length of the input's value doesn't increase, as occurs with the accented character menu", ->
+      inputNode.value = 'u'
+      inputNode.dispatchEvent(new Event('input'))
+      expect(editor.lineForBufferRow(0)).toBe 'uvar quicksort = function () {'
+
+      inputNode.value = 'ü'
+      inputNode.dispatchEvent(new Event('input'))
+      expect(editor.lineForBufferRow(0)).toBe 'üvar quicksort = function () {'
+
+  describe "commands", ->
+    describe "editor:consolidate-selections", ->
+      it "consolidates selections on the editor model, aborting the key binding if there is only one selection", ->
+        spyOn(editor, 'consolidateSelections').andCallThrough()
+
+        event = new CustomEvent('editor:consolidate-selections', bubbles: true, cancelable: true)
+        event.abortKeyBinding = jasmine.createSpy("event.abortKeyBinding")
+        node.dispatchEvent(event)
+
+        expect(editor.consolidateSelections).toHaveBeenCalled()
+        expect(event.abortKeyBinding).toHaveBeenCalled()
+
+  describe "hiding and showing the editor", ->
+    describe "when fontSize, fontFamily, or lineHeight changes while the editor is hidden", ->
+      it "does not attempt to measure the lineHeight and defaultCharWidth until the editor becomes visible again", ->
+        wrapperView.hide()
+        initialLineHeightInPixels = editor.getLineHeightInPixels()
+        initialCharWidth = editor.getDefaultCharWidth()
+
+        component.setLineHeight(2)
+        expect(editor.getLineHeightInPixels()).toBe initialLineHeightInPixels
+        expect(editor.getDefaultCharWidth()).toBe initialCharWidth
+        component.setFontSize(22)
+        expect(editor.getLineHeightInPixels()).toBe initialLineHeightInPixels
+        expect(editor.getDefaultCharWidth()).toBe initialCharWidth
+        component.setFontFamily('monospace')
+        expect(editor.getLineHeightInPixels()).toBe initialLineHeightInPixels
+        expect(editor.getDefaultCharWidth()).toBe initialCharWidth
+
+        wrapperView.show()
+        expect(editor.getLineHeightInPixels()).not.toBe initialLineHeightInPixels
+        expect(editor.getDefaultCharWidth()).not.toBe initialCharWidth
+
+    describe "when lines are changed while the editor is hidden", ->
+      it "does not measure new characters until the editor is shown again", ->
+        editor.setText('')
+        wrapperView.hide()
+        editor.setText('var z = 1')
+        editor.setCursorBufferPosition([0, Infinity])
+        wrapperView.show()
+        expect(node.querySelector('.cursor').style['-webkit-transform']).toBe "translate3d(#{9 * charWidth}px, 0px, 0px)"

spec/editor-spec.coffee

@@ -7,9 +7,12 @@ describe "Editor", ->
     buffer.setText(buffer.getText().replace(/[ ]{2}/g, "\t"))
 
   beforeEach ->
-    editor = atom.project.openSync('sample.js', autoIndent: false)
-    buffer = editor.buffer
-    lineLengths = buffer.getLines().map (line) -> line.length
+    waitsForPromise ->
+      atom.project.open('sample.js', autoIndent: false).then (o) -> editor = o
+
+    runs ->
+      buffer = editor.buffer
+      lineLengths = buffer.getLines().map (line) -> line.length
 
     waitsForPromise ->
       atom.packages.activatePackage('language-javascript')
@@ -17,7 +20,7 @@ describe "Editor", ->
   describe "when the editor is deserialized", ->
     it "restores selections and folds based on markers in the buffer", ->
       editor.setSelectedBufferRange([[1, 2], [3, 4]])
-      editor.addSelectionForBufferRange([[5, 6], [7, 5]], isReversed: true)
+      editor.addSelectionForBufferRange([[5, 6], [7, 5]], reversed: true)
       editor.foldBufferRow(4)
       expect(editor.isFoldedAtBufferRow(4)).toBeTruthy()
 
@@ -31,15 +34,33 @@ describe "Editor", ->
       editor2.destroy()
 
   describe "when the editor is constructed with an initialLine option", ->
-    it "and positions the cursor on the specified line", ->
-      editor = atom.project.openSync('sample.js', initialLine: 2)
-      buffer = editor.buffer
-      expect(editor.getCursor().getBufferPosition().row).toEqual 2
+    it "positions the cursor on the specified line", ->
+      editor = null
+
+      waitsForPromise ->
+        atom.workspace.open('sample.less', initialLine: 5).then (o) -> editor = o
+
+      runs ->
+        buffer = editor.buffer
+        expect(editor.getCursor().getBufferPosition().row).toEqual 5
+        expect(editor.getCursor().getBufferPosition().column).toEqual 0
+
+  describe "when the editor is constructed with an initialColumn option", ->
+    it "positions the cursor on the specified column", ->
+      editor = null
+
+      waitsForPromise ->
+        atom.workspace.open('sample.less', initialColumn: 8).then (o) -> editor = o
+
+      runs ->
+        buffer = editor.buffer
+        expect(editor.getCursor().getBufferPosition().row).toEqual 0
+        expect(editor.getCursor().getBufferPosition().column).toEqual 8
 
   describe ".copy()", ->
     it "returns a different edit session with the same initial state", ->
       editor.setSelectedBufferRange([[1, 2], [3, 4]])
-      editor.addSelectionForBufferRange([[5, 6], [7, 8]], isReversed: true)
+      editor.addSelectionForBufferRange([[5, 6], [7, 8]], reversed: true)
       editor.foldBufferRow(4)
       expect(editor.isFoldedAtBufferRow(4)).toBeTruthy()
 
@@ -57,21 +78,31 @@ describe "Editor", ->
 
   describe "config defaults", ->
     it "uses the `editor.tabLength`, `editor.softWrap`, and `editor.softTabs` config values", ->
+      editor1 = null
+      editor2 = null
       atom.config.set('editor.tabLength', 4)
       atom.config.set('editor.softWrap', true)
       atom.config.set('editor.softTabs', false)
-      editor1 = atom.project.openSync('a')
-      expect(editor1.getTabLength()).toBe 4
-      expect(editor1.getSoftWrap()).toBe true
-      expect(editor1.getSoftTabs()).toBe false
 
-      atom.config.set('editor.tabLength', 100)
-      atom.config.set('editor.softWrap', false)
-      atom.config.set('editor.softTabs', true)
-      editor2 = atom.project.openSync('b')
-      expect(editor2.getTabLength()).toBe 100
-      expect(editor2.getSoftWrap()).toBe false
-      expect(editor2.getSoftTabs()).toBe true
+      waitsForPromise ->
+        atom.workspace.open('a').then (o) -> editor1 = o
+
+      runs ->
+        expect(editor1.getTabLength()).toBe 4
+        expect(editor1.getSoftWrap()).toBe true
+        expect(editor1.getSoftTabs()).toBe false
+
+        atom.config.set('editor.tabLength', 100)
+        atom.config.set('editor.softWrap', false)
+        atom.config.set('editor.softTabs', true)
+
+      waitsForPromise ->
+        atom.workspace.open('b').then (o) -> editor2 = o
+
+      runs ->
+        expect(editor2.getTabLength()).toBe 100
+        expect(editor2.getSoftWrap()).toBe false
+        expect(editor2.getSoftTabs()).toBe true
 
   describe "title", ->
     describe ".getTitle()", ->
@@ -111,6 +142,21 @@ describe "Editor", ->
         editor.moveCursorDown()
         expect(editor.getCursorBufferPosition()).toEqual [1, 1]
 
+      it "emits a single 'cursors-moved' event for all moved cursors", ->
+        editor.on 'cursors-moved', cursorsMovedHandler = jasmine.createSpy("cursorsMovedHandler")
+
+        editor.moveCursorDown()
+        expect(cursorsMovedHandler.callCount).toBe 1
+
+        cursorsMovedHandler.reset()
+        editor.addCursorAtScreenPosition([3, 0])
+        editor.moveCursorDown()
+        expect(cursorsMovedHandler.callCount).toBe 1
+
+        cursorsMovedHandler.reset()
+        editor.getCursor().moveDown()
+        expect(cursorsMovedHandler.callCount).toBe 1
+
     describe ".setCursorScreenPosition(screenPosition)", ->
       it "clears a goal column established by vertical movement", ->
         # set a goal column by moving down
@@ -576,6 +622,38 @@ describe "Editor", ->
         editor.moveCursorToBeginningOfNextWord()
         expect(editor.getCursorBufferPosition()).toEqual [11, 9]
 
+    describe ".moveCursorToBeginningOfNextParagraph()", ->
+      it "moves the cursor before the first line of the next paragraph", ->
+        editor.setCursorBufferPosition [0,6]
+        cursor = editor.getCursor()
+
+        editor.moveCursorToBeginningOfNextParagraph()
+
+        expect(cursor.getBufferPosition()).toEqual  { row : 10, column : 0 }
+
+        editor.setText("")
+        editor.setCursorBufferPosition [0,0]
+        cursor = editor.getCursor()
+        editor.moveCursorToBeginningOfNextParagraph()
+
+        expect(cursor.getBufferPosition()).toEqual [0, 0]
+
+    describe ".moveCursorToBeginningOfPreviousParagraph()", ->
+      it "moves the cursor before the first line of the pevious paragraph", ->
+        editor.setCursorBufferPosition [10,0]
+        cursor = editor.getCursor()
+
+        editor.moveCursorToBeginningOfPreviousParagraph()
+
+        expect(cursor.getBufferPosition()).toEqual  { row : 0, column : 0 }
+
+        editor.setText("")
+        editor.setCursorBufferPosition [0,0]
+        cursor = editor.getCursor()
+        editor.moveCursorToBeginningOfPreviousParagraph()
+
+        expect(cursor.getBufferPosition()).toEqual [0, 0]
+
     describe ".getCurrentParagraphBufferRange()", ->
       it "returns the buffer range of the current paragraph, delimited by blank lines or the beginning / end of the file", ->
         buffer.setText """
@@ -645,6 +723,68 @@ describe "Editor", ->
           cursor2 = editor.addCursorAtBufferPosition([1,4])
           expect(cursor2.marker).toBe cursor1.marker
 
+    describe "autoscroll", ->
+      beforeEach ->
+        editor.manageScrollPosition = true
+        editor.setVerticalScrollMargin(2)
+        editor.setHorizontalScrollMargin(2)
+        editor.setLineHeightInPixels(10)
+        editor.setDefaultCharWidth(10)
+        editor.setHorizontalScrollbarHeight(0)
+        editor.setHeight(5.5 * 10)
+        editor.setWidth(5.5 * 10)
+
+      it "scrolls down when the last cursor gets closer than ::verticalScrollMargin to the bottom of the editor", ->
+        expect(editor.getScrollTop()).toBe 0
+        expect(editor.getScrollBottom()).toBe 5.5 * 10
+
+        editor.setCursorScreenPosition([2, 0])
+        expect(editor.getScrollBottom()).toBe 5.5 * 10
+
+        editor.moveCursorDown()
+        expect(editor.getScrollBottom()).toBe 6 * 10
+
+        editor.moveCursorDown()
+        expect(editor.getScrollBottom()).toBe 7 * 10
+
+      it "scrolls up when the last cursor gets closer than ::verticalScrollMargin to the top of the editor", ->
+        editor.setCursorScreenPosition([11, 0])
+        editor.setScrollBottom(editor.getScrollHeight())
+
+        editor.moveCursorUp()
+        expect(editor.getScrollBottom()).toBe editor.getScrollHeight()
+
+        editor.moveCursorUp()
+        expect(editor.getScrollTop()).toBe 7 * 10
+
+        editor.moveCursorUp()
+        expect(editor.getScrollTop()).toBe 6 * 10
+
+      it "scrolls right when the last cursor gets closer than ::horizontalScrollMargin to the right of the editor", ->
+        expect(editor.getScrollLeft()).toBe 0
+        expect(editor.getScrollRight()).toBe 5.5 * 10
+
+        editor.setCursorScreenPosition([0, 2])
+        expect(editor.getScrollRight()).toBe 5.5 * 10
+
+        editor.moveCursorRight()
+        expect(editor.getScrollRight()).toBe 6 * 10
+
+        editor.moveCursorRight()
+        expect(editor.getScrollRight()).toBe 7 * 10
+
+      it "scrolls left when the last cursor gets closer than ::horizontalScrollMargin to the left of the editor", ->
+        editor.setScrollRight(editor.getScrollWidth())
+        editor.setCursorScreenPosition([6, 62])
+
+        expect(editor.getScrollRight()).toBe editor.getScrollWidth()
+
+        editor.moveCursorLeft()
+        expect(editor.getScrollLeft()).toBe 59 * 10
+
+        editor.moveCursorLeft()
+        expect(editor.getScrollLeft()).toBe 58 * 10
+
   describe "selection", ->
     selection = null
 
@@ -683,7 +823,7 @@ describe "Editor", ->
         expect(selection1.isReversed()).toBeFalsy()
 
       it "merges selections when they intersect when moving up", ->
-        editor.setSelectedBufferRanges([[[0,9], [0,13]], [[1,10], [1,20]]], isReversed: true)
+        editor.setSelectedBufferRanges([[[0,9], [0,13]], [[1,10], [1,20]]], reversed: true)
         [selection1, selection2] = editor.getSelections()
 
         editor.selectUp()
@@ -694,7 +834,7 @@ describe "Editor", ->
         expect(selection1.isReversed()).toBeTruthy()
 
       it "merges selections when they intersect when moving left", ->
-        editor.setSelectedBufferRanges([[[0,9], [0,13]], [[0,14], [1,20]]], isReversed: true)
+        editor.setSelectedBufferRanges([[[0,9], [0,13]], [[0,14], [1,20]]], reversed: true)
         [selection1, selection2] = editor.getSelections()
 
         editor.selectLeft()
@@ -1000,7 +1140,7 @@ describe "Editor", ->
         expect(selection1).toBe selection
         expect(selection1.getBufferRange()).toEqual [[2, 2], [3, 3]]
 
-      describe "when the preserveFolds option is false (the default)", ->
+      describe "when the 'preserveFolds' option is false (the default)", ->
         it "removes folds that contain the selections", ->
           editor.setSelectedBufferRange([[0,0], [0,0]])
           editor.createFold(1, 4)
@@ -1014,7 +1154,7 @@ describe "Editor", ->
           expect(editor.lineForScreenRow(6).fold).toBeUndefined()
           expect(editor.lineForScreenRow(10).fold).toBeDefined()
 
-      describe "when the preserve folds option is true", ->
+      describe "when the 'preserveFolds' option is true", ->
         it "does not remove folds that contain the selections", ->
           editor.setSelectedBufferRange([[0,0], [0,0]])
           editor.createFold(1, 4)
@@ -1023,6 +1163,25 @@ describe "Editor", ->
           expect(editor.isFoldedAtBufferRow(1)).toBeTruthy()
           expect(editor.isFoldedAtBufferRow(6)).toBeTruthy()
 
+    describe ".setSelectedBufferRange(range)", ->
+      describe "when the 'autoscroll' option is true", ->
+        it "autoscrolls to the selection", ->
+          editor.manageScrollPosition = true
+          editor.setLineHeightInPixels(10)
+          editor.setDefaultCharWidth(10)
+          editor.setHeight(50)
+          editor.setWidth(50)
+          editor.setHorizontalScrollbarHeight(0)
+          expect(editor.getScrollTop()).toBe 0
+
+          editor.setSelectedBufferRange([[5, 6], [6, 8]], autoscroll: true)
+          expect(editor.getScrollBottom()).toBe (7 + editor.getVerticalScrollMargin()) * 10
+          expect(editor.getScrollRight()).toBe 50
+
+          editor.setSelectedBufferRange([[6, 6], [6, 8]], autoscroll: true)
+          expect(editor.getScrollBottom()).toBe (7 + editor.getVerticalScrollMargin()) * 10
+          expect(editor.getScrollRight()).toBe (8 + editor.getHorizontalScrollMargin()) * 10
+
     describe ".selectMarker(marker)", ->
       describe "if the marker is valid", ->
         it "selects the marker's range and returns the selected range", ->
@@ -1245,10 +1404,14 @@ describe "Editor", ->
         expect(selection.isEmpty()).toBeTruthy()
 
     it "does not share selections between different edit sessions for the same buffer", ->
-      editor2 = atom.project.openSync('sample.js')
-      editor.setSelectedBufferRanges([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
-      editor2.setSelectedBufferRanges([[[8, 7], [6, 5]], [[4, 3], [2, 1]]])
-      expect(editor2.getSelectedBufferRanges()).not.toEqual editor.getSelectedBufferRanges()
+      editor2 = null
+      waitsForPromise ->
+        atom.project.open('sample.js').then (o) -> editor2 = o
+
+      runs ->
+        editor.setSelectedBufferRanges([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
+        editor2.setSelectedBufferRanges([[[8, 7], [6, 5]], [[4, 3], [2, 1]]])
+        expect(editor2.getSelectedBufferRanges()).not.toEqual editor.getSelectedBufferRanges()
 
   describe "buffer manipulation", ->
     describe ".insertText(text)", ->
@@ -1424,6 +1587,35 @@ describe "Editor", ->
           editor.undo()
           expect(editor.getCursorBufferPosition()).toEqual [3,4]
 
+      it "indents the new line to the correct level when editor.autoIndent is true", ->
+        atom.config.set('editor.autoIndent', true)
+
+        editor.setText('  var test')
+        editor.setCursorBufferPosition([0,2])
+        editor.insertNewlineAbove()
+
+        expect(editor.getCursorBufferPosition()).toEqual [0,2]
+        expect(editor.lineForBufferRow(0)).toBe '  '
+        expect(editor.lineForBufferRow(1)).toBe '  var test'
+
+        editor.setText('\n  var test')
+        editor.setCursorBufferPosition([1,2])
+        editor.insertNewlineAbove()
+
+        expect(editor.getCursorBufferPosition()).toEqual [1,2]
+        expect(editor.lineForBufferRow(0)).toBe ''
+        expect(editor.lineForBufferRow(1)).toBe '  '
+        expect(editor.lineForBufferRow(2)).toBe '  var test'
+
+        editor.setText('function() {\n}')
+        editor.setCursorBufferPosition([1,1])
+        editor.insertNewlineAbove()
+
+        expect(editor.getCursorBufferPosition()).toEqual [1,2]
+        expect(editor.lineForBufferRow(0)).toBe 'function() {'
+        expect(editor.lineForBufferRow(1)).toBe '  '
+        expect(editor.lineForBufferRow(2)).toBe '}'
+
     describe ".backspace()", ->
       describe "when there is a single cursor", ->
         changeScreenRangeHandler = null
@@ -1571,46 +1763,51 @@ describe "Editor", ->
           editor.backspace()
           expect(editor.lineForBufferRow(0)).toBe 'var  =  () {'
 
-    describe ".backspaceToBeginningOfWord()", ->
+    describe ".deleteToBeginningOfWord()", ->
       describe "when no text is selected", ->
         it "deletes all text between the cursor and the beginning of the word", ->
           editor.setCursorBufferPosition([1, 24])
           editor.addCursorAtBufferPosition([3, 5])
           [cursor1, cursor2] = editor.getCursors()
 
-          editor.backspaceToBeginningOfWord()
+          editor.deleteToBeginningOfWord()
           expect(buffer.lineForRow(1)).toBe '  var sort = function(ems) {'
           expect(buffer.lineForRow(3)).toBe '    ar pivot = items.shift(), current, left = [], right = [];'
           expect(cursor1.getBufferPosition()).toEqual [1, 22]
           expect(cursor2.getBufferPosition()).toEqual [3, 4]
 
-          editor.backspaceToBeginningOfWord()
+          editor.deleteToBeginningOfWord()
           expect(buffer.lineForRow(1)).toBe '  var sort = functionems) {'
           expect(buffer.lineForRow(2)).toBe '    if (items.length <= 1) return itemsar pivot = items.shift(), current, left = [], right = [];'
           expect(cursor1.getBufferPosition()).toEqual [1, 21]
           expect(cursor2.getBufferPosition()).toEqual [2, 39]
 
-          editor.backspaceToBeginningOfWord()
+          editor.deleteToBeginningOfWord()
           expect(buffer.lineForRow(1)).toBe '  var sort = ems) {'
           expect(buffer.lineForRow(2)).toBe '    if (items.length <= 1) return ar pivot = items.shift(), current, left = [], right = [];'
           expect(cursor1.getBufferPosition()).toEqual [1, 13]
           expect(cursor2.getBufferPosition()).toEqual [2, 34]
 
+          editor.setText('  var sort')
+          editor.setCursorBufferPosition([0, 2])
+          editor.deleteToBeginningOfWord()
+          expect(buffer.lineForRow(0)).toBe 'var sort'
+
       describe "when text is selected", ->
         it "deletes only selected text", ->
           editor.setSelectedBufferRanges([[[1, 24], [1, 27]], [[2, 0], [2, 4]]])
-          editor.backspaceToBeginningOfWord()
+          editor.deleteToBeginningOfWord()
           expect(buffer.lineForRow(1)).toBe '  var sort = function(it) {'
           expect(buffer.lineForRow(2)).toBe 'if (items.length <= 1) return items;'
 
-    describe ".backspaceToBeginningOfLine()", ->
+    describe ".deleteToBeginningOfLine()", ->
       describe "when no text is selected", ->
         it "deletes all text between the cursor and the beginning of the line", ->
           editor.setCursorBufferPosition([1, 24])
           editor.addCursorAtBufferPosition([2, 5])
           [cursor1, cursor2] = editor.getCursors()
 
-          editor.backspaceToBeginningOfLine()
+          editor.deleteToBeginningOfLine()
           expect(buffer.lineForRow(1)).toBe 'ems) {'
           expect(buffer.lineForRow(2)).toBe 'f (items.length <= 1) return items;'
           expect(cursor1.getBufferPosition()).toEqual [1, 0]
@@ -1619,13 +1816,13 @@ describe "Editor", ->
         describe "when at the beginning of the line", ->
           it "deletes the newline", ->
             editor.setCursorBufferPosition([2])
-            editor.backspaceToBeginningOfLine()
+            editor.deleteToBeginningOfLine()
             expect(buffer.lineForRow(1)).toBe '  var sort = function(items) {    if (items.length <= 1) return items;'
 
       describe "when text is selected", ->
         it "still deletes all text to begginning of the line", ->
           editor.setSelectedBufferRanges([[[1, 24], [1, 27]], [[2, 0], [2, 4]]])
-          editor.backspaceToBeginningOfLine()
+          editor.deleteToBeginningOfLine()
           expect(buffer.lineForRow(1)).toBe 'ems) {'
           expect(buffer.lineForRow(2)).toBe '    if (items.length <= 1) return items;'
 
@@ -1898,17 +2095,44 @@ describe "Editor", ->
 
       describe ".copySelectedText()", ->
         it "copies selected text onto the clipboard", ->
+          editor.setSelectedBufferRanges([[[0,4], [0,13]], [[1,6], [1, 10]], [[2,8], [2, 13]]])
+
           editor.copySelectedText()
           expect(buffer.lineForRow(0)).toBe "var quicksort = function () {"
           expect(buffer.lineForRow(1)).toBe "  var sort = function(items) {"
-          expect(clipboard.readText()).toBe 'quicksort\nsort'
+          expect(buffer.lineForRow(2)).toBe "    if (items.length <= 1) return items;"
+          expect(clipboard.readText()).toBe 'quicksort\nsort\nitems'
+          expect(atom.clipboard.readWithMetadata().metadata.selections).toEqual([
+            'quicksort'
+            'sort'
+            'items'
+          ])
 
       describe ".pasteText()", ->
         it "pastes text into the buffer", ->
           atom.clipboard.write('first')
           editor.pasteText()
-          expect(editor.buffer.lineForRow(0)).toBe "var first = function () {"
-          expect(buffer.lineForRow(1)).toBe "  var first = function(items) {"
+          expect(editor.lineForBufferRow(0)).toBe "var first = function () {"
+          expect(editor.lineForBufferRow(1)).toBe "  var first = function(items) {"
+
+        describe 'when the clipboard has many selections', ->
+          it "pastes each selection separately into the buffer", ->
+            atom.clipboard.write('first\nsecond', {selections: ['first', 'second'] })
+            editor.pasteText()
+            expect(editor.lineForBufferRow(0)).toBe "var first = function () {"
+            expect(editor.lineForBufferRow(1)).toBe "  var second = function(items) {"
+
+          describe 'and the selections count does not match', ->
+            it "pastes the whole text into the buffer", ->
+              atom.clipboard.write('first\nsecond\nthird', {selections: ['first', 'second', 'third'] })
+              editor.pasteText()
+              expect(editor.lineForBufferRow(0)).toBe "var first"
+              expect(editor.lineForBufferRow(1)).toBe "second"
+              expect(editor.lineForBufferRow(2)).toBe "third = function () {"
+
+              expect(editor.lineForBufferRow(3)).toBe "  var first"
+              expect(editor.lineForBufferRow(4)).toBe "second"
+              expect(editor.lineForBufferRow(5)).toBe "third = function(items) {"
 
     describe ".indentSelectedRows()", ->
       describe "when nothing is selected", ->
@@ -2097,10 +2321,14 @@ describe "Editor", ->
 
       it "does not explode if the current language mode has no comment regex", ->
         editor.destroy()
-        editor = atom.project.openSync(null, autoIndent: false)
-        editor.setSelectedBufferRange([[4, 5], [4, 5]])
-        editor.toggleLineCommentsInSelection()
-        expect(buffer.lineForRow(4)).toBe "    while(items.length > 0) {"
+
+        waitsForPromise ->
+          atom.workspace.open(null, autoIndent: false).then (o) -> editor = o
+
+        runs ->
+          editor.setSelectedBufferRange([[4, 5], [4, 5]])
+          editor.toggleLineCommentsInSelection()
+          expect(buffer.lineForRow(4)).toBe "    while(items.length > 0) {"
 
       it "uncomments when the line lacks the trailing whitespace in the comment regex", ->
         editor.setCursorBufferPosition([10, 0])
@@ -2419,14 +2647,21 @@ describe "Editor", ->
 
   describe "soft-tabs detection", ->
     it "assigns soft / hard tabs based on the contents of the buffer, or uses the default if unknown", ->
-      editor = atom.project.openSync('sample.js', softTabs: false)
-      expect(editor.getSoftTabs()).toBeTruthy()
+      waitsForPromise ->
+        atom.workspace.open('sample.js', softTabs: false).then (editor) ->
+          expect(editor.getSoftTabs()).toBeTruthy()
 
-      editor = atom.project.openSync('sample-with-tabs.coffee', softTabs: true)
-      expect(editor.getSoftTabs()).toBeFalsy()
+      waitsForPromise ->
+        atom.workspace.open('sample-with-tabs.coffee', softTabs: true).then (editor) ->
+          expect(editor.getSoftTabs()).toBeFalsy()
 
-      editor = atom.project.openSync(null, softTabs: false)
-      expect(editor.getSoftTabs()).toBeFalsy()
+      waitsForPromise ->
+        atom.workspace.open('sample-with-tabs-and-initial-comment.js', softTabs: true).then (editor) ->
+          expect(editor.getSoftTabs()).toBeFalsy()
+
+      waitsForPromise ->
+        atom.workspace.open(null, softTabs: false).then (editor) ->
+          expect(editor.getSoftTabs()).toBeFalsy()
 
   describe ".indentLevelForLine(line)", ->
     it "returns the indent level when the line has only leading whitespace", ->
@@ -2450,16 +2685,21 @@ describe "Editor", ->
 
   describe "when a better-matched grammar is added to syntax", ->
     it "switches to the better-matched grammar and re-tokenizes the buffer", ->
+      editor.destroy()
+
       jsGrammar = atom.syntax.selectGrammar('a.js')
       atom.syntax.removeGrammar(jsGrammar)
 
-      editor2 = atom.project.openSync('sample.js', autoIndent: false)
-      expect(editor2.getGrammar()).toBe atom.syntax.nullGrammar
-      expect(editor2.lineForScreenRow(0).tokens.length).toBe 1
+      waitsForPromise ->
+        atom.workspace.open('sample.js', autoIndent: false).then (o) -> editor = o
 
-      atom.syntax.addGrammar(jsGrammar)
-      expect(editor2.getGrammar()).toBe jsGrammar
-      expect(editor2.lineForScreenRow(0).tokens.length).toBeGreaterThan 1
+      runs ->
+        expect(editor.getGrammar()).toBe atom.syntax.nullGrammar
+        expect(editor.lineForScreenRow(0).tokens.length).toBe 1
+
+        atom.syntax.addGrammar(jsGrammar)
+        expect(editor.getGrammar()).toBe jsGrammar
+        expect(editor.lineForScreenRow(0).tokens.length).toBeGreaterThan 1
 
   describe "auto-indent", ->
     copyText = (text, {startColumn}={}) ->
@@ -2636,6 +2876,18 @@ describe "Editor", ->
       expect(editor.lineForBufferRow(4)).toBe "    }"
       expect(editor.lineForBufferRow(5)).toBe "    i=1"
 
+  describe "soft and hard tabs", ->
+    it "resets the tab style when tokenization is complete", ->
+      editor.destroy()
+      atom.project.open('sample-with-tabs-and-leading-comment.coffee').then (o) -> editor = o
+      expect(editor.softTabs).toBe true
+
+      waitsForPromise ->
+        atom.packages.activatePackage('language-coffee-script')
+
+      runs ->
+        expect(editor.softTabs).toBe false
+
   describe ".destroy()", ->
     it "destroys all markers associated with the edit session", ->
       expect(buffer.getMarkerCount()).toBeGreaterThan 0
@@ -2746,10 +2998,15 @@ describe "Editor", ->
       expect(editor.shouldPromptToSave()).toBeFalsy()
       buffer.setText('changed')
       expect(editor.shouldPromptToSave()).toBeTruthy()
-      editor2 = atom.project.openSync('sample.js', autoIndent: false)
-      expect(editor.shouldPromptToSave()).toBeFalsy()
-      editor2.destroy()
-      expect(editor.shouldPromptToSave()).toBeTruthy()
+
+      editor2 = null
+      waitsForPromise ->
+        atom.project.open('sample.js', autoIndent: false).then (o) -> editor2 = o
+
+      runs ->
+        expect(editor.shouldPromptToSave()).toBeFalsy()
+        editor2.destroy()
+        expect(editor.shouldPromptToSave()).toBeTruthy()
 
   describe "when the edit session contains surrogate pair characters", ->
     it "correctly backspaces over them", ->
@@ -2845,12 +3102,15 @@ describe "Editor", ->
 
     describe "when the grammar is added", ->
       it "retokenizes existing buffers that contain tokens that match the injection selector", ->
-        editor = atom.project.openSync('sample.js')
-        editor.setText("// http://github.com")
+        waitsForPromise ->
+          atom.workspace.open('sample.js').then (o) -> editor = o
 
-        {tokens} = editor.lineForScreenRow(0)
-        expect(tokens[1].value).toBe " http://github.com"
-        expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
+        runs ->
+          editor.setText("// http://github.com")
+
+          {tokens} = editor.lineForScreenRow(0)
+          expect(tokens[1].value).toBe " http://github.com"
+          expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
 
         waitsForPromise ->
           atom.packages.activatePackage('language-hyperlink')
@@ -2862,12 +3122,15 @@ describe "Editor", ->
 
       describe "when the grammar is updated", ->
         it "retokenizes existing buffers that contain tokens that match the injection selector", ->
-          editor = atom.project.openSync('sample.js')
-          editor.setText("// SELECT * FROM OCTOCATS")
+          waitsForPromise ->
+            atom.workspace.open('sample.js').then (o) -> editor = o
 
-          {tokens} = editor.lineForScreenRow(0)
-          expect(tokens[1].value).toBe " SELECT * FROM OCTOCATS"
-          expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
+          runs ->
+            editor.setText("// SELECT * FROM OCTOCATS")
+
+            {tokens} = editor.lineForScreenRow(0)
+            expect(tokens[1].value).toBe " SELECT * FROM OCTOCATS"
+            expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
 
           waitsForPromise ->
             atom.packages.activatePackage('package-with-injection-selector')
@@ -2900,3 +3163,38 @@ describe "Editor", ->
       editor.setSoftTabs(false)
       editor.normalizeTabsInBufferRange([[0, 0], [Infinity, Infinity]])
       expect(editor.getText()).toBe '     '
+
+  describe ".scrollToCursorPosition()", ->
+    it "scrolls the last cursor into view", ->
+      editor.setCursorScreenPosition([8, 8])
+      editor.setLineHeightInPixels(10)
+      editor.setDefaultCharWidth(10)
+      editor.setHeight(50)
+      editor.setWidth(50)
+      editor.setHorizontalScrollbarHeight(0)
+      expect(editor.getScrollTop()).toBe 0
+      expect(editor.getScrollLeft()).toBe 0
+
+      editor.scrollToCursorPosition()
+      expect(editor.getScrollBottom()).toBe (9 + editor.getVerticalScrollMargin()) * 10
+      expect(editor.getScrollRight()).toBe (9 + editor.getHorizontalScrollMargin()) * 10
+
+  describe ".pageUp/Down()", ->
+    it "scrolls one screen height up or down", ->
+      editor.manageScrollPosition = true
+
+      editor.setLineHeightInPixels(10)
+      editor.setHeight(50)
+      expect(editor.getScrollHeight()).toBe 130
+
+      editor.pageDown()
+      expect(editor.getScrollTop()).toBe 50
+
+      editor.pageDown()
+      expect(editor.getScrollTop()).toBe 80
+
+      editor.pageUp()
+      expect(editor.getScrollTop()).toBe 30
+
+      editor.pageUp()
+      expect(editor.getScrollTop()).toBe 0

spec/editor-view-spec.coffee

@@ -7,28 +7,36 @@ path = require 'path'
 temp = require 'temp'
 
 describe "EditorView", ->
-  [buffer, editorView, editor, cachedLineHeight, cachedCharWidth] = []
+  [buffer, editorView, editor, cachedEditor, cachedLineHeight, cachedCharWidth, fart] = []
 
   beforeEach ->
-    editor = atom.project.openSync('sample.js')
-    buffer = editor.buffer
-    editorView = new EditorView(editor)
-    editorView.lineOverdraw = 2
-    editorView.isFocused = true
-    editorView.enableKeymap()
-    editorView.calculateHeightInLines = ->
-      Math.ceil(@height() / @lineHeight)
-    editorView.attachToDom = ({ heightInLines, widthInChars } = {}) ->
-      heightInLines ?= @getEditor().getBuffer().getLineCount()
-      @height(getLineHeight() * heightInLines)
-      @width(getCharWidth() * widthInChars) if widthInChars
-      $('#jasmine-content').append(this)
+    waitsForPromise ->
+      atom.workspace.open('sample.js').then (o) -> editor = o
 
     waitsForPromise ->
-      atom.packages.activatePackage('language-text', sync: true)
+      atom.workspace.open('sample.less').then (o) -> cachedEditor = o
+
+    runs ->
+      buffer = editor.buffer
+      editorView = new EditorView(editor)
+      editorView.lineOverdraw = 2
+      editorView.isFocused = true
+      editorView.enableKeymap()
+
+      editorView.calculateHeightInLines = ->
+        Math.ceil(@height() / @lineHeight)
+
+      editorView.attachToDom = ({ heightInLines, widthInChars } = {}) ->
+        heightInLines ?= @getEditor().getBuffer().getLineCount()
+        @height(getLineHeight() * heightInLines)
+        @width(getCharWidth() * widthInChars) if widthInChars
+        $('#jasmine-content').append(this)
 
     waitsForPromise ->
-      atom.packages.activatePackage('language-javascript', sync: true)
+      atom.packages.activatePackage('language-text')
+
+    waitsForPromise ->
+      atom.packages.activatePackage('language-javascript')
 
   getLineHeight = ->
     return cachedLineHeight if cachedLineHeight?
@@ -41,7 +49,7 @@ describe "EditorView", ->
     cachedCharWidth
 
   calcDimensions = ->
-    editorForMeasurement = new EditorView(editor: atom.project.openSync('sample.js'))
+    editorForMeasurement = new EditorView({editor: cachedEditor})
     editorForMeasurement.attachToDom()
     cachedLineHeight = editorForMeasurement.lineHeight
     cachedCharWidth = editorForMeasurement.charWidth
@@ -105,18 +113,23 @@ describe "EditorView", ->
 
   describe "when the editor's file is modified on disk", ->
     it "triggers an alert", ->
+      fileChangeHandler = null
       filePath = path.join(temp.dir, 'atom-changed-file.txt')
       fs.writeFileSync(filePath, "")
-      editor = atom.project.openSync(filePath)
-      editorView.edit(editor)
-      editor.insertText("now the buffer is modified")
 
-      fileChangeHandler = jasmine.createSpy('fileChange')
-      editor.buffer.file.on 'contents-changed', fileChangeHandler
+      waitsForPromise ->
+        atom.workspace.open(filePath).then (o) -> editor = o
 
-      spyOn(atom, "confirm")
+      runs ->
+        editorView.edit(editor)
+        editor.insertText("now the buffer is modified")
 
-      fs.writeFileSync(filePath, "a file change")
+        fileChangeHandler = jasmine.createSpy('fileChange')
+        editor.buffer.file.on 'contents-changed', fileChangeHandler
+
+        spyOn(atom, "confirm")
+
+        fs.writeFileSync(filePath, "a file change")
 
       waitsFor "file to trigger contents-changed event", ->
         fileChangeHandler.callCount > 0
@@ -133,8 +146,11 @@ describe "EditorView", ->
     [newEditor, newBuffer] = []
 
     beforeEach ->
-      newEditor = atom.project.openSync('two-hundred.txt')
-      newBuffer = newEditor.buffer
+      waitsForPromise ->
+        atom.workspace.open('two-hundred.txt').then (o) -> newEditor = o
+
+      runs ->
+        newBuffer = newEditor.buffer
 
     it "updates the rendered lines, cursors, selections, scroll position, and event subscriptions to match the given edit session", ->
       editorView.attachToDom(heightInLines: 5, widthInChars: 30)
@@ -170,17 +186,24 @@ describe "EditorView", ->
       expect(editorView.lineElementForScreenRow(6).text()).toMatch /^      currentgoodbye/
 
     it "triggers alert if edit session's buffer goes into conflict with changes on disk", ->
+      contentsConflictedHandler = null
       filePath = path.join(temp.dir, 'atom-changed-file.txt')
       fs.writeFileSync(filePath, "")
-      tempEditor = atom.project.openSync(filePath)
-      editorView.edit(tempEditor)
-      tempEditor.insertText("a buffer change")
+      tempEditor = null
 
-      spyOn(atom, "confirm")
+      waitsForPromise ->
+        atom.workspace.open(filePath).then (o) -> tempEditor = o
+
+      runs ->
+        editorView.edit(tempEditor)
+        tempEditor.insertText("a buffer change")
+
+        spyOn(atom, "confirm")
+
+        contentsConflictedHandler = jasmine.createSpy("contentsConflictedHandler")
+        tempEditor.on 'contents-conflicted', contentsConflictedHandler
+        fs.writeFileSync(filePath, "a file change")
 
-      contentsConflictedHandler = jasmine.createSpy("contentsConflictedHandler")
-      tempEditor.on 'contents-conflicted', contentsConflictedHandler
-      fs.writeFileSync(filePath, "a file change")
       waitsFor ->
         contentsConflictedHandler.callCount > 0
 
@@ -281,26 +304,34 @@ describe "EditorView", ->
     it "emits event when editor view view receives a new buffer", ->
       eventHandler = jasmine.createSpy('eventHandler')
       editorView.on 'editor:path-changed', eventHandler
-      editorView.edit(atom.project.openSync(filePath))
-      expect(eventHandler).toHaveBeenCalled()
+      waitsForPromise ->
+        atom.workspace.open(filePath).then (editor) ->
+          editorView.edit(editor)
+
+      runs ->
+        expect(eventHandler).toHaveBeenCalled()
 
     it "stops listening to events on previously set buffers", ->
       eventHandler = jasmine.createSpy('eventHandler')
       oldBuffer = editor.getBuffer()
-      newEditor = atom.project.openSync(filePath)
-      editorView.on 'editor:path-changed', eventHandler
+      newEditor = null
 
+      waitsForPromise ->
+        atom.workspace.open(filePath).then (o) -> newEditor = o
 
-      editorView.edit(newEditor)
-      expect(eventHandler).toHaveBeenCalled()
+      runs ->
+        editorView.on 'editor:path-changed', eventHandler
 
-      eventHandler.reset()
-      oldBuffer.saveAs(path.join(temp.dir, 'atom-bad.txt'))
-      expect(eventHandler).not.toHaveBeenCalled()
+        editorView.edit(newEditor)
+        expect(eventHandler).toHaveBeenCalled()
 
-      eventHandler.reset()
-      newEditor.getBuffer().saveAs(path.join(temp.dir, 'atom-new.txt'))
-      expect(eventHandler).toHaveBeenCalled()
+        eventHandler.reset()
+        oldBuffer.saveAs(path.join(temp.dir, 'atom-bad.txt'))
+        expect(eventHandler).not.toHaveBeenCalled()
+
+        eventHandler.reset()
+        newEditor.getBuffer().saveAs(path.join(temp.dir, 'atom-new.txt'))
+        expect(eventHandler).toHaveBeenCalled()
 
     it "loads the grammar for the new path", ->
       expect(editor.getGrammar().name).toBe 'JavaScript'
@@ -432,9 +463,9 @@ describe "EditorView", ->
           editorView.setFontFamily('sans-serif')
 
       it "positions the cursor to the clicked row and column", ->
-          {top, left} = editorView.pixelOffsetForScreenPosition([3, 30])
-          editorView.renderedLines.trigger mousedownEvent(pageX: left, pageY: top)
-          expect(editor.getCursorScreenPosition()).toEqual [3, 30]
+        {top, left} = editorView.pixelOffsetForScreenPosition([3, 30])
+        editorView.renderedLines.trigger mousedownEvent(pageX: left, pageY: top)
+        expect(editor.getCursorScreenPosition()).toEqual [3, 30]
 
     describe "double-click", ->
       it "selects the word under the cursor, and expands the selection wordwise in either direction on a subsequent shift-click", ->
@@ -464,7 +495,21 @@ describe "EditorView", ->
         editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [3, 12], originalEvent: {detail: 1}, shiftKey: true)
         expect(editor.getSelectedBufferRange()).toEqual [[3, 10], [3, 12]]
 
-      describe "when clicking between a word and a non-word", ->
+      it "stops selecting by word when another selection is made", ->
+        expect(editor.getCursorScreenPosition()).toEqual(row: 0, column: 0)
+        editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [0, 8], originalEvent: {detail: 1})
+        editorView.renderedLines.trigger 'mouseup'
+        editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [0, 8], originalEvent: {detail: 2})
+        editorView.renderedLines.trigger 'mouseup'
+        expect(editor.getSelectedText()).toBe "quicksort"
+
+        editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [3, 10])
+        editorView.renderedLines.trigger mousemoveEvent(editorView: editorView, point: [3, 12], which: 1)
+        editorView.renderedLines.trigger 'mouseup'
+
+        expect(editor.getSelectedBufferRange()).toEqual [[3, 10], [3, 12]]
+
+      describe "when double-clicking between a word and a non-word", ->
         it "selects the word", ->
           expect(editor.getCursorScreenPosition()).toEqual(row: 0, column: 0)
           editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [1, 21], originalEvent: {detail: 1})
@@ -487,6 +532,30 @@ describe "EditorView", ->
           editorView.renderedLines.trigger 'mouseup'
           expect(editor.getSelectedText()).toBe "{"
 
+      describe "when double-clicking on whitespace", ->
+        it "selects all adjacent whitespace", ->
+          editor.setText("   some  text    ")
+          editor.setCursorBufferPosition([0, 2])
+          editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [0, 2], originalEvent: {detail: 1})
+          editorView.renderedLines.trigger 'mouseup'
+          editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [0, 2], originalEvent: {detail: 2})
+          editorView.renderedLines.trigger 'mouseup'
+          expect(editor.getSelectedBufferRange()).toEqual [[0, 0], [0, 3]]
+
+          editor.setCursorBufferPosition([0, 8])
+          editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [0, 8], originalEvent: {detail: 1})
+          editorView.renderedLines.trigger 'mouseup'
+          editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [0, 8], originalEvent: {detail: 2})
+          editorView.renderedLines.trigger 'mouseup'
+          expect(editor.getSelectedBufferRange()).toEqual [[0, 7], [0, 9]]
+
+          editor.setCursorBufferPosition([0, 14])
+          editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [0, 14], originalEvent: {detail: 1})
+          editorView.renderedLines.trigger 'mouseup'
+          editorView.renderedLines.trigger mousedownEvent(editorView: editorView, point: [0, 14], originalEvent: {detail: 2})
+          editorView.renderedLines.trigger 'mouseup'
+          expect(editor.getSelectedBufferRange()).toEqual [[0, 13], [0, 17]]
+
     describe "triple/quardruple/etc-click", ->
       it "selects the line under the cursor", ->
         expect(editor.getCursorScreenPosition()).toEqual(row: 0, column: 0)
@@ -1371,7 +1440,7 @@ describe "EditorView", ->
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(6)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(12)
 
-          buffer.change([[1,0], [3,0]], "1\n2\n3\n")
+          buffer.setTextInRange([[1,0], [3,0]], "1\n2\n3\n")
           expect(editorView.renderedLines.find(".line").length).toBe 7
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(6)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(12)
@@ -1384,21 +1453,21 @@ describe "EditorView", ->
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(6)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(12)
 
-          buffer.change([[2,0], [7,0]], "2\n3\n4\n5\n6\n7\n8\n9\n")
+          buffer.setTextInRange([[2,0], [7,0]], "2\n3\n4\n5\n6\n7\n8\n9\n")
           expect(editorView.renderedLines.find(".line").length).toBe 7
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(6)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(12)
 
       describe "when the change straddles the last rendered row", ->
         it "doesn't render rows that were not previously rendered", ->
-          buffer.change([[2,0], [7,0]], "2\n3\n4\n5\n6\n7\n8\n")
+          buffer.setTextInRange([[2,0], [7,0]], "2\n3\n4\n5\n6\n7\n8\n")
           expect(editorView.renderedLines.find(".line").length).toBe 7
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(0)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(6)
 
       describe "when the change the follows the last rendered row", ->
         it "does not change the rendered lines", ->
-          buffer.change([[12,0], [12,0]], "12\n13\n14\n")
+          buffer.setTextInRange([[12,0], [12,0]], "12\n13\n14\n")
           expect(editorView.renderedLines.find(".line").length).toBe 7
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(0)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(6)
@@ -1408,7 +1477,7 @@ describe "EditorView", ->
         setEditorWidthInChars(editorView, maxLineLength)
         widthBefore = editorView.renderedLines.width()
         expect(widthBefore).toBe editorView.scrollView.width() + 20
-        buffer.change([[12,0], [12,0]], [1..maxLineLength*2].join(''))
+        buffer.setTextInRange([[12,0], [12,0]], [1..maxLineLength*2].join(''))
         expect(editorView.renderedLines.width()).toBeGreaterThan widthBefore
 
     describe "when lines are removed", ->
@@ -1418,7 +1487,7 @@ describe "EditorView", ->
       it "sets the rendered screen line's width to either the max line length or the scollView's width (whichever is greater)", ->
         maxLineLength = editor.getMaxScreenLineLength()
         setEditorWidthInChars(editorView, maxLineLength)
-        buffer.change([[12,0], [12,0]], [1..maxLineLength*2].join(''))
+        buffer.setTextInRange([[12,0], [12,0]], [1..maxLineLength*2].join(''))
         expect(editorView.renderedLines.width()).toBeGreaterThan editorView.scrollView.width()
         widthBefore = editorView.renderedLines.width()
         buffer.delete([[12, 0], [12, Infinity]])
@@ -1431,7 +1500,7 @@ describe "EditorView", ->
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(6)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(12)
 
-          buffer.change([[1,0], [2,0]], "")
+          buffer.setTextInRange([[1,0], [2,0]], "")
           expect(editorView.renderedLines.find(".line").length).toBe 6
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(6)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(11)
@@ -1443,21 +1512,21 @@ describe "EditorView", ->
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(6)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(12)
 
-          buffer.change([[7,0], [11,0]], "1\n2\n")
+          buffer.setTextInRange([[7,0], [11,0]], "1\n2\n")
           expect(editorView.renderedLines.find(".line").length).toBe 5
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(6)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(10)
 
       describe "when the change straddles the last rendered row", ->
         it "renders the correct rows", ->
-          buffer.change([[2,0], [7,0]], "")
+          buffer.setTextInRange([[2,0], [7,0]], "")
           expect(editorView.renderedLines.find(".line").length).toBe 7
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(0)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(6)
 
       describe "when the change the follows the last rendered row", ->
         it "does not change the rendered lines", ->
-          buffer.change([[10,0], [12,0]], "")
+          buffer.setTextInRange([[10,0], [12,0]], "")
           expect(editorView.renderedLines.find(".line").length).toBe 7
           expect(editorView.renderedLines.find(".line:first").text()).toBe buffer.lineForRow(0)
           expect(editorView.renderedLines.find(".line:last").text()).toBe buffer.lineForRow(6)
@@ -1515,14 +1584,18 @@ describe "EditorView", ->
 
     describe "when autoscrolling at the end of the document", ->
       it "renders lines properly", ->
-        editorView.edit(atom.project.openSync('two-hundred.txt'))
-        editorView.attachToDom(heightInLines: 5.5)
+        waitsForPromise ->
+          atom.workspace.open('two-hundred.txt').then (editor) ->
+            editorView.edit(editor)
 
-        expect(editorView.renderedLines.find('.line').length).toBe 8
+        runs ->
+          editorView.attachToDom(heightInLines: 5.5)
 
-        editor.moveCursorToBottom()
+          expect(editorView.renderedLines.find('.line').length).toBe 8
 
-        expect(editorView.renderedLines.find('.line').length).toBe 8
+          editor.moveCursorToBottom()
+
+          expect(editorView.renderedLines.find('.line').length).toBe 8
 
     describe "when line has a character that could push it to be too tall (regression)", ->
       it "does renders the line at a consistent height", ->
@@ -1582,7 +1655,7 @@ describe "EditorView", ->
           editor.setSoftWrap(true)
 
         it "doesn't show the end of line invisible at the end of lines broken due to wrapping", ->
-          editor.setText "a line that wraps"
+          editor.setText "a line that wraps "
           editorView.attachToDom()
           editorView.setWidthInChars(6)
           atom.config.set "editor.showInvisibles", true
@@ -1590,11 +1663,11 @@ describe "EditorView", ->
           expect(space).toBeTruthy()
           eol = editorView.invisibles?.eol
           expect(eol).toBeTruthy()
-          expect(editorView.renderedLines.find('.line:first').text()).toBe "a line#{space}"
-          expect(editorView.renderedLines.find('.line:last').text()).toBe "wraps#{eol}"
+          expect(editorView.renderedLines.find('.line:first').text()).toBe "a line "
+          expect(editorView.renderedLines.find('.line:last').text()).toBe "wraps#{space}#{eol}"
 
         it "displays trailing carriage return using a visible non-empty value", ->
-          editor.setText "a line that\r\n"
+          editor.setText "a line that \r\n"
           editorView.attachToDom()
           editorView.setWidthInChars(6)
           atom.config.set "editor.showInvisibles", true
@@ -1604,8 +1677,8 @@ describe "EditorView", ->
           expect(cr).toBeTruthy()
           eol = editorView.invisibles?.eol
           expect(eol).toBeTruthy()
-          expect(editorView.renderedLines.find('.line:first').text()).toBe "a line#{space}"
-          expect(editorView.renderedLines.find('.line:eq(1)').text()).toBe "that#{cr}#{eol}"
+          expect(editorView.renderedLines.find('.line:first').text()).toBe "a line "
+          expect(editorView.renderedLines.find('.line:eq(1)').text()).toBe "that#{space}#{cr}#{eol}"
           expect(editorView.renderedLines.find('.line:last').text()).toBe "#{eol}"
 
     describe "when editor.showIndentGuide is set to true", ->
@@ -1730,6 +1803,13 @@ describe "EditorView", ->
           expect(editorView.renderedLines.find('.line:eq(10) .indent-guide').text()).toBe "#{eol}   "
           expect(editorView.renderedLines.find('.line:eq(10) .invisible-character').text()).toBe eol
 
+    describe "when editor.showIndentGuide is set to false", ->
+      it "does not render the indent guide on whitespace only lines (regression)", ->
+        editorView.attachToDom()
+        editor.setText('    ')
+        atom.config.set('editor.showIndentGuide', false)
+        expect(editorView.renderedLines.find('.line:eq(0) .indent-guide').length).toBe 0
+
   describe "when soft-wrap is enabled", ->
     beforeEach ->
       jasmine.unspy(window, 'setTimeout')
@@ -1770,10 +1850,14 @@ describe "EditorView", ->
       expect(editor.bufferPositionForScreenPosition(editor.getCursorScreenPosition())).toEqual [3, 60]
 
     it "does not wrap the lines of any newly assigned buffers", ->
-      otherEditor = atom.project.openSync()
-      otherEditor.buffer.setText([1..100].join(''))
-      editorView.edit(otherEditor)
-      expect(editorView.renderedLines.find('.line').length).toBe(1)
+      otherEditor = null
+      waitsForPromise ->
+        atom.workspace.open().then (o) -> otherEditor = o
+
+      runs ->
+        otherEditor.buffer.setText([1..100].join(''))
+        editorView.edit(otherEditor)
+        expect(editorView.renderedLines.find('.line').length).toBe(1)
 
     it "unwraps lines when softwrap is disabled", ->
       editorView.toggleSoftWrap()
@@ -1802,15 +1886,15 @@ describe "EditorView", ->
       expect(editor.getCursorScreenPosition()).toEqual [11, 0]
 
     it "calls .setWidthInChars() when the editor view is attached because now its dimensions are available to calculate it", ->
-      otherEditor = new EditorView(editor: atom.project.openSync('sample.js'))
-      spyOn(otherEditor, 'setWidthInChars')
+      otherEditorView = new EditorView(editor)
+      spyOn(otherEditorView, 'setWidthInChars')
 
-      otherEditor.editor.setSoftWrap(true)
-      expect(otherEditor.setWidthInChars).not.toHaveBeenCalled()
+      otherEditorView.editor.setSoftWrap(true)
+      expect(otherEditorView.setWidthInChars).not.toHaveBeenCalled()
 
-      otherEditor.simulateDomAttachment()
-      expect(otherEditor.setWidthInChars).toHaveBeenCalled()
-      otherEditor.remove()
+      otherEditorView.simulateDomAttachment()
+      expect(otherEditorView.setWidthInChars).toHaveBeenCalled()
+      otherEditorView.remove()
 
     describe "when the editor view's width changes", ->
       it "updates the width in characters on the edit session", ->
@@ -1961,15 +2045,19 @@ describe "EditorView", ->
 
     describe "when the switching from an edit session for a long buffer to an edit session for a short buffer", ->
       it "updates the line numbers to reflect the shorter buffer", ->
-        emptyEditor = atom.project.openSync(null)
-        editorView.edit(emptyEditor)
-        expect(editorView.gutter.lineNumbers.find('.line-number').length).toBe 1
+        emptyEditor = null
+        waitsForPromise ->
+          atom.workspace.open().then (o) -> emptyEditor = o
 
-        editorView.edit(editor)
-        expect(editorView.gutter.lineNumbers.find('.line-number').length).toBeGreaterThan 1
+        runs ->
+          editorView.edit(emptyEditor)
+          expect(editorView.gutter.lineNumbers.find('.line-number').length).toBe 1
 
-        editorView.edit(emptyEditor)
-        expect(editorView.gutter.lineNumbers.find('.line-number').length).toBe 1
+          editorView.edit(editor)
+          expect(editorView.gutter.lineNumbers.find('.line-number').length).toBeGreaterThan 1
+
+          editorView.edit(emptyEditor)
+          expect(editorView.gutter.lineNumbers.find('.line-number').length).toBe 1
 
     describe "when the editor view is mini", ->
       it "hides the gutter", ->
@@ -2189,10 +2277,13 @@ describe "EditorView", ->
 
   describe "folding", ->
     beforeEach ->
-      editor = atom.project.openSync('two-hundred.txt')
-      buffer = editor.buffer
-      editorView.edit(editor)
-      editorView.attachToDom()
+      waitsForPromise ->
+        atom.workspace.open('two-hundred.txt').then (o) -> editor = o
+
+      runs ->
+        buffer = editor.buffer
+        editorView.edit(editor)
+        editorView.attachToDom()
 
     describe "when a fold-selection event is triggered", ->
       it "folds the lines covered by the selection into a single line with a fold class and marker", ->
@@ -2246,7 +2337,7 @@ describe "EditorView", ->
       it "adds/removes the 'fold-selected' class to the fold's line element and hides the cursor if it is on the fold line", ->
         editor.createFold(2, 4)
 
-        editor.setSelectedBufferRange([[1, 0], [2, 0]], preserveFolds: true, isReversed: true)
+        editor.setSelectedBufferRange([[1, 0], [2, 0]], preserveFolds: true, reversed: true)
         expect(editorView.lineElementForScreenRow(2)).toMatchSelector('.fold.fold-selected')
 
         editor.setSelectedBufferRange([[1, 0], [1, 1]], preserveFolds: true)
@@ -2327,8 +2418,11 @@ describe "EditorView", ->
     beforeEach ->
       filePath = atom.project.resolve('git/working-dir/file.txt')
       originalPathText = fs.readFileSync(filePath, 'utf8')
-      editor = atom.project.openSync(filePath)
-      editorView.edit(editor)
+      waitsForPromise ->
+        atom.workspace.open(filePath).then (o) -> editor = o
+
+      runs ->
+        editorView.edit(editor)
 
     afterEach ->
       fs.writeFileSync(filePath, originalPathText)
@@ -2802,7 +2896,7 @@ describe "EditorView", ->
 
   describe "when the escape key is pressed on the editor view", ->
     it "clears multiple selections if there are any, and otherwise allows other bindings to be handled", ->
-      atom.keymap.bindKeys 'name', '.editor', {'escape': 'test-event'}
+      atom.keymaps.add 'name', '.editor': {'escape': 'test-event'}
       testEventHandler = jasmine.createSpy("testEventHandler")
 
       editorView.on 'test-event', testEventHandler
@@ -2819,22 +2913,26 @@ describe "EditorView", ->
   describe "when the editor view is attached but invisible", ->
     describe "when the editor view's text is changed", ->
       it "redraws the editor view when it is next shown", ->
+        displayUpdatedHandler = null
         atom.workspaceView = new WorkspaceView
-        atom.workspaceView.openSync('sample.js')
-        atom.workspaceView.attachToDom()
-        editorView = atom.workspaceView.getActiveView()
+        waitsForPromise ->
+          atom.workspaceView.open('sample.txt').then (o) -> editor = o
 
-        view = $$ -> @div id: 'view', tabindex: -1, 'View'
-        editorView.getPane().activateItem(view)
-        expect(editorView.isVisible()).toBeFalsy()
+        runs ->
+          atom.workspaceView.attachToDom()
+          editorView = atom.workspaceView.getActiveView()
 
-        editor.setText('hidden changes')
-        editor.setCursorBufferPosition([0,4])
+          view = $$ -> @div id: 'view', tabindex: -1, 'View'
+          editorView.getPane().activateItem(view)
+          expect(editorView.isVisible()).toBeFalsy()
 
-        displayUpdatedHandler = jasmine.createSpy("displayUpdatedHandler")
-        editorView.on 'editor:display-updated', displayUpdatedHandler
-        editorView.getPane().activateItem(editorView.getModel())
-        expect(editorView.isVisible()).toBeTruthy()
+          editor.setText('hidden changes')
+          editor.setCursorBufferPosition([0,4])
+
+          displayUpdatedHandler = jasmine.createSpy("displayUpdatedHandler")
+          editorView.on 'editor:display-updated', displayUpdatedHandler
+          editorView.getPane().activateItem(editorView.getModel())
+          expect(editorView.isVisible()).toBeTruthy()
 
         waitsFor ->
           displayUpdatedHandler.callCount is 1
@@ -2874,14 +2972,17 @@ describe "EditorView", ->
   describe "when the editor view is removed", ->
     it "fires a editor:will-be-removed event", ->
       atom.workspaceView = new WorkspaceView
-      atom.workspaceView.openSync('sample.js')
-      atom.workspaceView.attachToDom()
-      editorView = atom.workspaceView.getActiveView()
+      waitsForPromise ->
+        atom.workspace.open('sample.js')
 
-      willBeRemovedHandler = jasmine.createSpy('willBeRemovedHandler')
-      editorView.on 'editor:will-be-removed', willBeRemovedHandler
-      editorView.getPane().destroyActiveItem()
-      expect(willBeRemovedHandler).toHaveBeenCalled()
+      runs ->
+        atom.workspaceView.attachToDom()
+        editorView = atom.workspaceView.getActiveView()
+
+        willBeRemovedHandler = jasmine.createSpy('willBeRemovedHandler')
+        editorView.on 'editor:will-be-removed', willBeRemovedHandler
+        editorView.getPane().destroyActiveItem()
+        expect(willBeRemovedHandler).toHaveBeenCalled()
 
   describe "when setInvisibles is toggled (regression)", ->
     it "renders inserted newlines properly", ->
@@ -2894,6 +2995,20 @@ describe "EditorView", ->
       for rowNumber in [1..5]
         expect(editorView.lineElementForScreenRow(rowNumber).text()).toBe buffer.lineForRow(rowNumber)
 
+    it "correctly calculates the position left for non-monospaced invisibles", ->
+      editorView.setShowInvisibles(true)
+      editorView.setInvisibles tab: '♘'
+      editor.setText('\tx')
+
+      editorView.setFontFamily('serif')
+      editorView.setFontSize(10)
+      editorView.attachToDom()
+      editorView.setWidthInChars(5)
+
+      expect(editorView.pixelPositionForScreenPosition([0, 0]).left).toEqual 0
+      expect(editorView.pixelPositionForScreenPosition([0, 1]).left).toEqual 10
+      expect(editorView.pixelPositionForScreenPosition([0, 2]).left).toEqual 13
+
   describe "when the window is resized", ->
     it "updates the active edit session with the current soft wrap column", ->
       editorView.attachToDom()

spec/fixtures/sample-with-tabs-and-initial-comment.js

@@ -0,0 +1,8 @@
+/**
+ * Look, this is a comment. Don't go making assumtions that I want soft tabs
+ * because this block comment has leading spaces, Geez.
+ */
+
+if (beNice) {
+	console.log('Thank you for being nice.');
+}

spec/fixtures/sample-with-tabs-and-leading-comment.coffee

@@ -0,0 +1,4 @@
+  # This is a comment
+if this.studyingEconomics
+	buy()	while supply > demand
+		sell() until supply > demand

spec/git-spec.coffee

@@ -177,6 +177,24 @@ describe "Git", ->
       status = repo.getPathStatus(filePath)
       expect(statusHandler.callCount).toBe 1
 
+  describe ".getDirectoryStatus(path)", ->
+    [directoryPath, filePath, originalPathText] = []
+
+    beforeEach ->
+      repo = new Git(path.join(__dirname, 'fixtures', 'git', 'working-dir'))
+      directoryPath = path.join(__dirname, 'fixtures', 'git', 'working-dir', 'dir')
+      filePath = require.resolve('./fixtures/git/working-dir/dir/b.txt')
+      originalPathText = fs.readFileSync(filePath, 'utf8')
+
+    afterEach ->
+      fs.writeFileSync(filePath, originalPathText)
+
+    it "gets the status based on the files inside the directory", ->
+      expect(repo.isStatusModified(repo.getDirectoryStatus(directoryPath))).toBe false
+      fs.writeFileSync(filePath, 'abc')
+      repo.getPathStatus(filePath)
+      expect(repo.isStatusModified(repo.getDirectoryStatus(directoryPath))).toBe true
+
   describe ".refreshStatus()", ->
     [newPath, modifiedPath, cleanPath, originalModifiedPathText] = []
 
@@ -203,17 +221,19 @@ describe "Git", ->
         statusHandler.callCount > 0
 
       runs ->
-        statuses = repo.statuses
-        expect(statuses[cleanPath]).toBeUndefined()
-        expect(repo.isStatusNew(statuses[newPath])).toBeTruthy()
-        expect(repo.isStatusModified(statuses[modifiedPath])).toBeTruthy()
+        expect(repo.getCachedPathStatus(cleanPath)).toBeUndefined()
+        expect(repo.isStatusNew(repo.getCachedPathStatus(newPath))).toBeTruthy()
+        expect(repo.isStatusModified(repo.getCachedPathStatus(modifiedPath))).toBeTruthy()
 
   describe "buffer events", ->
     [originalContent, editor] = []
 
     beforeEach ->
-      editor = atom.project.openSync('sample.js')
-      originalContent = editor.getText()
+      waitsForPromise ->
+        atom.workspace.open('sample.js').then (o) -> editor = o
+
+      runs ->
+        originalContent = editor.getText()
 
     afterEach ->
       fs.writeFileSync(editor.getPath(), originalContent)
@@ -257,9 +277,12 @@ describe "Git", ->
       project2?.destroy()
 
     it "subscribes to all the serialized buffers in the project", ->
-      atom.project.openSync('sample.js')
-      project2 = atom.project.testSerialization()
-      buffer = project2.getBuffers()[0]
+      waitsForPromise ->
+        atom.workspace.open('sample.js')
+
+      runs ->
+        project2 = atom.project.testSerialization()
+        buffer = project2.getBuffers()[0]
 
       waitsFor ->
         buffer.loaded

spec/language-mode-spec.coffee

@@ -6,8 +6,10 @@ describe "LanguageMode", ->
 
   describe "javascript", ->
     beforeEach ->
-      editor = atom.project.openSync('sample.js', autoIndent: false)
-      {buffer, languageMode} = editor
+      waitsForPromise ->
+        atom.workspace.open('sample.js', autoIndent: false).then (o) ->
+          editor = o
+          {buffer, languageMode} = editor
 
       waitsForPromise ->
         atom.packages.activatePackage('language-javascript')
@@ -46,6 +48,16 @@ describe "LanguageMode", ->
         languageMode.toggleLineCommentsForBufferRows(0, 0)
         expect(buffer.lineForRow(0)).toBe " // var i;"
 
+        buffer.setText('  ')
+        languageMode.toggleLineCommentsForBufferRows(0, 0)
+        expect(buffer.lineForRow(0)).toBe "  // "
+
+        buffer.setText ('    a\n  \n    b')
+        languageMode.toggleLineCommentsForBufferRows(0, 2)
+        expect(buffer.lineForRow(0)).toBe "    // a"
+        expect(buffer.lineForRow(1)).toBe "    // "
+        expect(buffer.lineForRow(2)).toBe "    // b"
+
     describe ".rowRangeForCodeFoldAtBufferRow(bufferRow)", ->
       it "returns the start/end rows of the foldable region starting at the given row", ->
         expect(languageMode.rowRangeForCodeFoldAtBufferRow(0)).toEqual [0, 12]
@@ -102,8 +114,10 @@ describe "LanguageMode", ->
 
   describe "coffeescript", ->
     beforeEach ->
-      editor = atom.project.openSync('coffee.coffee', autoIndent: false)
-      {buffer, languageMode} = editor
+      waitsForPromise ->
+        atom.workspace.open('coffee.coffee', autoIndent: false).then (o) ->
+          editor = o
+          {buffer, languageMode} = editor
 
       waitsForPromise ->
         atom.packages.activatePackage('language-coffee-script')
@@ -151,8 +165,10 @@ describe "LanguageMode", ->
 
   describe "css", ->
     beforeEach ->
-      editor = atom.project.openSync('css.css', autoIndent: false)
-      {buffer, languageMode} = editor
+      waitsForPromise ->
+        atom.workspace.open('css.css', autoIndent: false).then (o) ->
+          editor = o
+          {buffer, languageMode} = editor
 
       waitsForPromise ->
         atom.packages.activatePackage('language-css')
@@ -168,34 +184,36 @@ describe "LanguageMode", ->
         languageMode.toggleLineCommentsForBufferRows(2, 2)
         expect(buffer.lineForRow(0)).toBe "/*body {"
         expect(buffer.lineForRow(1)).toBe "  font-size: 1234px;*/"
-        expect(buffer.lineForRow(2)).toBe "/*  width: 110%;*/"
+        expect(buffer.lineForRow(2)).toBe "  /*width: 110%;*/"
         expect(buffer.lineForRow(3)).toBe "  font-weight: bold !important;"
 
         languageMode.toggleLineCommentsForBufferRows(0, 1)
         expect(buffer.lineForRow(0)).toBe "body {"
         expect(buffer.lineForRow(1)).toBe "  font-size: 1234px;"
-        expect(buffer.lineForRow(2)).toBe "/*  width: 110%;*/"
+        expect(buffer.lineForRow(2)).toBe "  /*width: 110%;*/"
         expect(buffer.lineForRow(3)).toBe "  font-weight: bold !important;"
 
       it "uncomments lines with leading whitespace", ->
-        buffer.change([[2, 0], [2, Infinity]], "  /*width: 110%;*/")
+        buffer.setTextInRange([[2, 0], [2, Infinity]], "  /*width: 110%;*/")
         languageMode.toggleLineCommentsForBufferRows(2, 2)
         expect(buffer.lineForRow(2)).toBe "  width: 110%;"
 
       it "uncomments lines with trailing whitespace", ->
-        buffer.change([[2, 0], [2, Infinity]], "/*width: 110%;*/  ")
+        buffer.setTextInRange([[2, 0], [2, Infinity]], "/*width: 110%;*/  ")
         languageMode.toggleLineCommentsForBufferRows(2, 2)
         expect(buffer.lineForRow(2)).toBe "width: 110%;  "
 
       it "uncomments lines with leading and trailing whitespace", ->
-        buffer.change([[2, 0], [2, Infinity]], "   /*width: 110%;*/ ")
+        buffer.setTextInRange([[2, 0], [2, Infinity]], "   /*width: 110%;*/ ")
         languageMode.toggleLineCommentsForBufferRows(2, 2)
         expect(buffer.lineForRow(2)).toBe "   width: 110%; "
 
   describe "less", ->
     beforeEach ->
-      editor = atom.project.openSync('sample.less', autoIndent: false)
-      {buffer, languageMode} = editor
+      waitsForPromise ->
+        atom.workspace.open('sample.less', autoIndent: false).then (o) ->
+          editor = o
+          {buffer, languageMode} = editor
 
       waitsForPromise ->
         atom.packages.activatePackage('language-less')
@@ -210,9 +228,11 @@ describe "LanguageMode", ->
 
   describe "xml", ->
     beforeEach ->
-      editor = atom.project.openSync('sample.xml', autoIndent: false)
-      editor.setText("<!-- test -->")
-      {buffer, languageMode} = editor
+      waitsForPromise ->
+        atom.workspace.open('sample.xml', autoIndent: false).then (o) ->
+          editor = o
+          editor.setText("<!-- test -->")
+          {buffer, languageMode} = editor
 
       waitsForPromise ->
         atom.packages.activatePackage('language-xml')
@@ -224,8 +244,10 @@ describe "LanguageMode", ->
 
   describe "folding", ->
     beforeEach ->
-      editor = atom.project.openSync('sample.js', autoIndent: false)
-      {buffer, languageMode} = editor
+      waitsForPromise ->
+        atom.workspace.open('sample.js', autoIndent: false).then (o) ->
+          editor = o
+          {buffer, languageMode} = editor
 
       waitsForPromise ->
         atom.packages.activatePackage('language-javascript')
@@ -309,8 +331,10 @@ describe "LanguageMode", ->
 
   describe "folding with comments", ->
     beforeEach ->
-      editor = atom.project.openSync('sample-with-comments.js', autoIndent: false)
-      {buffer, languageMode} = editor
+      waitsForPromise ->
+        atom.workspace.open('sample-with-comments.js', autoIndent: false).then (o) ->
+          editor = o
+          {buffer, languageMode} = editor
 
       waitsForPromise ->
         atom.packages.activatePackage('language-javascript')
@@ -375,7 +399,10 @@ describe "LanguageMode", ->
 
   describe "css", ->
     beforeEach ->
-      editor = atom.project.openSync('css.css', autoIndent: true)
+      waitsForPromise ->
+        atom.workspace.open('css.css', autoIndent: true).then (o) ->
+          editor = o
+          {buffer, languageMode} = editor
 
       waitsForPromise ->
         atom.packages.activatePackage('language-source')

spec/pane-container-view-spec.coffee

@@ -27,7 +27,7 @@ describe "PaneContainerView", ->
   afterEach ->
     atom.deserializers.remove(TestView)
 
-  describe ".getActivePane()", ->
+  describe ".getActivePaneView()", ->
     it "returns the most-recently focused pane", ->
       focusStealer = $$ -> @div tabindex: -1, "focus stealer"
       focusStealer.attachToDom()
@@ -35,15 +35,15 @@ describe "PaneContainerView", ->
 
       pane2.focus()
       expect(container.getFocusedPane()).toBe pane2
-      expect(container.getActivePane()).toBe pane2
+      expect(container.getActivePaneView()).toBe pane2
 
       focusStealer.focus()
       expect(container.getFocusedPane()).toBeUndefined()
-      expect(container.getActivePane()).toBe pane2
+      expect(container.getActivePaneView()).toBe pane2
 
       pane3.focus()
       expect(container.getFocusedPane()).toBe pane3
-      expect(container.getActivePane()).toBe pane3
+      expect(container.getActivePaneView()).toBe pane3
 
   describe ".eachPaneView(callback)", ->
     it "runs the callback with all current and future panes until the subscription is cancelled", ->

spec/pane-view-spec.coffee

@@ -21,11 +21,16 @@ describe "PaneView", ->
     container = new PaneContainerView
     view1 = new TestView(id: 'view-1', text: 'View 1')
     view2 = new TestView(id: 'view-2', text: 'View 2')
-    editor1 = atom.project.openSync('sample.js')
-    editor2 = atom.project.openSync('sample.txt')
-    pane = container.getRoot()
-    paneModel = pane.model
-    paneModel.addItems([view1, editor1, view2, editor2])
+    waitsForPromise ->
+      atom.workspace.open('sample.js').then (o) -> editor1 = o
+
+    waitsForPromise ->
+      atom.workspace.open('sample.txt').then (o) -> editor2 = o
+
+    runs ->
+      pane = container.getRoot()
+      paneModel = pane.model
+      paneModel.addItems([view1, editor1, view2, editor2])
 
   afterEach ->
     atom.deserializers.remove(TestView)
@@ -159,14 +164,20 @@ describe "PaneView", ->
 
   describe "when an unmodifed buffer's path is deleted", ->
     it "removes the pane item", ->
+      editor = null
       jasmine.unspy(window, 'setTimeout')
       filePath = temp.openSync('atom').path
-      editor = atom.project.openSync(filePath)
-      pane.activateItem(editor)
-      expect(pane.items).toHaveLength(5)
 
-      fs.removeSync(filePath)
-      waitsFor -> pane.items.length == 4
+      waitsForPromise ->
+        atom.workspace.open(filePath).then (o) -> editor = o
+
+      runs ->
+        pane.activateItem(editor)
+        expect(pane.items).toHaveLength(5)
+        fs.removeSync(filePath)
+
+      waitsFor ->
+        pane.items.length == 4
 
   describe "when a pane is destroyed", ->
     [pane2, pane2Model] = []

spec/project-spec.coffee

@@ -18,111 +18,50 @@ describe "Project", ->
       deserializedProject?.destroy()
 
     it "does not include unretained buffers in the serialized state", ->
-      atom.project.bufferForPathSync('a')
-      expect(atom.project.getBuffers().length).toBe 1
+      waitsForPromise ->
+        atom.project.bufferForPath('a')
 
-      deserializedProject = atom.project.testSerialization()
-      expect(deserializedProject.getBuffers().length).toBe 0
+      runs ->
+        expect(atom.project.getBuffers().length).toBe 1
+        deserializedProject = atom.project.testSerialization()
+        expect(deserializedProject.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
-      deserializedProject = atom.project.testSerialization()
+      waitsForPromise ->
+        atom.project.open('a')
 
-      expect(deserializedProject.getBuffers().length).toBe 1
-      deserializedProject.getBuffers()[0].destroy()
-      expect(deserializedProject.getBuffers().length).toBe 0
+      runs ->
+        expect(atom.project.getBuffers().length).toBe 1
+        deserializedProject = atom.project.testSerialization()
 
-  describe "when an edit session is destroyed", ->
-    it "removes edit session and calls destroy on buffer (if buffer is not referenced by other edit sessions)", ->
-      editor = atom.project.openSync("a")
-      anotherEditor = atom.project.openSync("a")
+        expect(deserializedProject.getBuffers().length).toBe 1
+        deserializedProject.getBuffers()[0].destroy()
+        expect(deserializedProject.getBuffers().length).toBe 0
 
-      expect(atom.project.editors.length).toBe 2
-      expect(editor.buffer).toBe anotherEditor.buffer
-
-      editor.destroy()
-      expect(atom.project.editors.length).toBe 1
-
-      anotherEditor.destroy()
-      expect(atom.project.editors.length).toBe 0
-
-  describe "when an edit session is saved and the project has no path", ->
+  describe "when an editor is saved and the project has no path", ->
     it "sets the project's path to the saved file's parent directory", ->
       tempFile = temp.openSync().path
       atom.project.setPath(undefined)
       expect(atom.project.getPath()).toBeUndefined()
-      editor = atom.project.openSync()
-      editor.saveAs(tempFile)
-      expect(atom.project.getPath()).toBe path.dirname(tempFile)
+      editor = null
 
-  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
+      waitsForPromise ->
+        atom.project.open().then (o) -> editor = o
 
-      editor1 = atom.project.openSync("a")
-      expect(handler.callCount).toBe 1
-      expect(atom.project.getEditors().length).toBe 1
-      expect(atom.project.getEditors()[0]).toBe editor1
-
-      editor2 = editor1.copy()
-      expect(handler.callCount).toBe 2
-      expect(atom.project.getEditors().length).toBe 2
-      expect(atom.project.getEditors()[0]).toBe editor1
-      expect(atom.project.getEditors()[1]).toBe editor2
-
-  describe ".openSync(path)", ->
-    [absolutePath, newBufferHandler, newEditorHandler] = []
-    beforeEach ->
-      absolutePath = require.resolve('./fixtures/dir/a')
-      newBufferHandler = jasmine.createSpy('newBufferHandler')
-      atom.project.on 'buffer-created', newBufferHandler
-      newEditorHandler = jasmine.createSpy('newEditorHandler')
-      atom.project.on 'editor-created', newEditorHandler
-
-    describe "when given an absolute path that hasn't been opened previously", ->
-      it "returns a new edit session for the given path and emits 'buffer-created' and 'editor-created' events", ->
-        editor = atom.project.openSync(absolutePath)
-        expect(editor.buffer.getPath()).toBe absolutePath
-        expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
-        expect(newEditorHandler).toHaveBeenCalledWith editor
-
-    describe "when given a relative path that hasn't been opened previously", ->
-      it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'editor-created' events", ->
-        editor = atom.project.openSync('a')
-        expect(editor.buffer.getPath()).toBe absolutePath
-        expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
-        expect(newEditorHandler).toHaveBeenCalledWith editor
-
-    describe "when passed the path to a buffer that has already been opened", ->
-      it "returns a new edit session containing previously opened buffer and emits a 'editor-created' event", ->
-        editor = atom.project.openSync(absolutePath)
-        newBufferHandler.reset()
-        expect(atom.project.openSync(absolutePath).buffer).toBe editor.buffer
-        expect(atom.project.openSync('a').buffer).toBe editor.buffer
-        expect(newBufferHandler).not.toHaveBeenCalled()
-        expect(newEditorHandler).toHaveBeenCalledWith editor
-
-    describe "when not passed a path", ->
-      it "returns a new edit session and emits 'buffer-created' and 'editor-created' events", ->
-        editor = atom.project.openSync()
-        expect(editor.buffer.getPath()).toBeUndefined()
-        expect(newBufferHandler).toHaveBeenCalledWith(editor.buffer)
-        expect(newEditorHandler).toHaveBeenCalledWith editor
+      runs ->
+        editor.saveAs(tempFile)
+        expect(atom.project.getPath()).toBe path.dirname(tempFile)
 
   describe ".open(path)", ->
-    [absolutePath, newBufferHandler, newEditorHandler] = []
+    [absolutePath, newBufferHandler] = []
 
     beforeEach ->
       absolutePath = require.resolve('./fixtures/dir/a')
       newBufferHandler = jasmine.createSpy('newBufferHandler')
       atom.project.on 'buffer-created', newBufferHandler
-      newEditorHandler = jasmine.createSpy('newEditorHandler')
-      atom.project.on 'editor-created', newEditorHandler
 
     describe "when given an absolute path that isn't currently open", ->
-      it "returns a new edit session for the given path and emits 'buffer-created' and 'editor-created' events", ->
+      it "returns a new edit session for the given path and emits 'buffer-created'", ->
         editor = null
         waitsForPromise ->
           atom.project.open(absolutePath).then (o) -> editor = o
@@ -130,10 +69,9 @@ describe "Project", ->
         runs ->
           expect(editor.buffer.getPath()).toBe absolutePath
           expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
-          expect(newEditorHandler).toHaveBeenCalledWith editor
 
     describe "when given a relative path that isn't currently opened", ->
-      it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'editor-created' events", ->
+      it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created'", ->
         editor = null
         waitsForPromise ->
           atom.project.open(absolutePath).then (o) -> editor = o
@@ -141,23 +79,28 @@ describe "Project", ->
         runs ->
           expect(editor.buffer.getPath()).toBe absolutePath
           expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
-          expect(newEditorHandler).toHaveBeenCalledWith editor
 
     describe "when passed the path to a buffer that is currently opened", ->
-      it "returns a new edit session containing currently opened buffer and emits a 'editor-created' event", ->
+      it "returns a new edit session containing currently opened buffer", ->
         editor = null
+
         waitsForPromise ->
           atom.project.open(absolutePath).then (o) -> editor = o
 
         runs ->
           newBufferHandler.reset()
-          expect(atom.project.openSync(absolutePath).buffer).toBe editor.buffer
-          expect(atom.project.openSync('a').buffer).toBe editor.buffer
-          expect(newBufferHandler).not.toHaveBeenCalled()
-          expect(newEditorHandler).toHaveBeenCalledWith editor
+
+        waitsForPromise ->
+          atom.project.open(absolutePath).then ({buffer}) ->
+            expect(buffer).toBe editor.buffer
+
+        waitsForPromise ->
+          atom.project.open('a').then ({buffer}) ->
+            expect(buffer).toBe editor.buffer
+            expect(newBufferHandler).not.toHaveBeenCalled()
 
     describe "when not passed a path", ->
-      it "returns a new edit session and emits 'buffer-created' and 'editor-created' events", ->
+      it "returns a new edit session and emits 'buffer-created'", ->
         editor = null
         waitsForPromise ->
           atom.project.open().then (o) -> editor = o
@@ -165,7 +108,6 @@ describe "Project", ->
         runs ->
           expect(editor.buffer.getPath()).toBeUndefined()
           expect(newBufferHandler).toHaveBeenCalledWith(editor.buffer)
-          expect(newEditorHandler).toHaveBeenCalledWith editor
 
     it "returns number of read bytes as progress indicator", ->
       filePath = atom.project.resolve 'a'
@@ -179,20 +121,6 @@ describe "Project", ->
       runs ->
         expect(totalBytes).toBe fs.statSync(filePath).size
 
-  describe ".bufferForPathSync(path)", ->
-    describe "when opening a previously opened path", ->
-      it "does not create a new buffer", ->
-        buffer = atom.project.bufferForPathSync("a").retain()
-        expect(atom.project.bufferForPathSync("a")).toBe buffer
-
-        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 = atom.project.bufferForPathSync("a").retain().release()
-        expect(atom.project.bufferForPathSync("a").retain().release()).not.toBe buffer
-
   describe ".bufferForPath(path)", ->
     [buffer] = []
     beforeEach ->
@@ -282,10 +210,15 @@ describe "Project", ->
 
     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()
-
+        editor = null
         results = []
+
+        waitsForPromise ->
+          atom.project.open('sample.js').then (o) -> editor = o
+
+        runs ->
+          expect(editor.isModified()).toBeFalsy()
+
         waitsForPromise ->
           atom.project.replace /items/gi, 'items', [filePath], (result) ->
             results.push(result)
@@ -298,10 +231,12 @@ describe "Project", ->
           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')
-
+        editor = null
         results = []
+
+        waitsForPromise ->
+          atom.project.open('sample-with-comments.js').then (o) -> editor = o
+
         waitsForPromise ->
           atom.project.replace /items/gi, 'items', [commentFilePath], (result) ->
             results.push(result)
@@ -311,11 +246,16 @@ describe "Project", ->
           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()
-
+        editor = null
         results = []
+
+        waitsForPromise ->
+          atom.project.open('sample.js').then (o) -> editor = o
+
+        runs ->
+          editor.buffer.setTextInRange([[0,0],[0,0]], 'omg')
+          expect(editor.isModified()).toBeTruthy()
+
         waitsForPromise ->
           atom.project.replace /items/gi, 'okthen', [filePath], (result) ->
             results.push(result)
@@ -479,9 +419,14 @@ describe "Project", ->
           expect(resultHandler).not.toHaveBeenCalled()
 
       it "scans buffer contents if the buffer is modified", ->
-        editor = atom.project.openSync("a")
-        editor.setText("Elephant")
+        editor = null
         results = []
+
+        waitsForPromise ->
+          atom.project.open('a').then (o) ->
+            editor = o
+            editor.setText("Elephant")
+
         waitsForPromise ->
           atom.project.scan /a|Elephant/, (result) -> results.push result
 
@@ -492,9 +437,14 @@ describe "Project", ->
           expect(resultForA.matches[0].matchText).toBe 'Elephant'
 
       it "ignores buffers outside the project", ->
-        editor = atom.project.openSync(temp.openSync().path)
-        editor.setText("Elephant")
+        editor = null
         results = []
+
+        waitsForPromise ->
+          atom.project.open(temp.openSync().path).then (o) ->
+            editor = o
+            editor.setText("Elephant")
+
         waitsForPromise ->
           atom.project.scan /Elephant/, (result) -> results.push result
 

spec/selection-spec.coffee

@@ -58,7 +58,7 @@ describe "Selection", ->
 
   describe "when only the selection's tail is moved (regression)", ->
     it "emits the 'screen-range-changed' event", ->
-      selection.setBufferRange([[2, 0], [2, 10]], isReversed: true)
+      selection.setBufferRange([[2, 0], [2, 10]], reversed: true)
       changeScreenRangeHandler = jasmine.createSpy('changeScreenRangeHandler')
       selection.on 'screen-range-changed', changeScreenRangeHandler
 

spec/spec-helper.coffee

@@ -6,8 +6,9 @@ require '../vendor/jasmine-jquery'
 path = require 'path'
 _ = require 'underscore-plus'
 fs = require 'fs-plus'
-Keymap = require '../src/keymap-extensions'
-{$, WorkspaceView} = require 'atom'
+Grim = require 'grim'
+KeymapManager = require '../src/keymap-extensions'
+{$, WorkspaceView, Workspace} = require 'atom'
 Config = require '../src/config'
 {Point} = require 'text-buffer'
 Project = require '../src/project'
@@ -22,8 +23,8 @@ atom.themes.requireStylesheet '../static/jasmine'
 
 fixturePackagesPath = path.resolve(__dirname, './fixtures/packages')
 atom.packages.packageDirPaths.unshift(fixturePackagesPath)
-atom.keymap.loadBundledKeymaps()
-keyBindingsToRestore = atom.keymap.getKeyBindings()
+atom.keymaps.loadBundledKeymaps()
+keyBindingsToRestore = atom.keymaps.getKeyBindings()
 
 $(window).on 'core:close', -> window.close()
 $(window).on 'unload', ->
@@ -37,6 +38,7 @@ jasmine.getEnv().defaultTimeoutInterval = 5000
 specPackageName = null
 specPackagePath = null
 specProjectPath = null
+isCoreSpec = false
 
 {specDirectory, resourcePath} = atom.getLoadSettings()
 
@@ -46,11 +48,15 @@ if specDirectory
     specPackageName = JSON.parse(fs.readFileSync(path.join(specPackagePath, 'package.json')))?.name
   specProjectPath = path.join(specDirectory, 'fixtures')
 
+isCoreSpec = specDirectory == fs.realpathSync(__dirname)
+
 beforeEach ->
+  Grim.clearDeprecations() if isCoreSpec
   $.fx.off = true
   projectPath = specProjectPath ? path.join(@specDirectory, 'fixtures')
   atom.project = new Project(path: projectPath)
-  atom.keymap.keyBindings = _.clone(keyBindingsToRestore)
+  atom.workspace = new Workspace()
+  atom.keymaps.keyBindings = _.clone(keyBindingsToRestore)
 
   window.resetTimeouts()
   atom.packages.packageStates = {}
@@ -83,6 +89,7 @@ beforeEach ->
   config.set "editor.autoIndent", false
   config.set "core.disabledPackages", ["package-that-throws-an-exception",
     "package-with-broken-package-json", "package-with-broken-keymap"]
+  config.set "core.useReactEditor", false
   config.save.reset()
   atom.config = config
 
@@ -112,7 +119,7 @@ afterEach ->
   atom.workspaceView = null
   delete atom.state.workspace
 
-  atom.project?.destroy?()
+  atom.project?.destroy()
   atom.project = null
 
   delete atom.state.packageStates
@@ -122,6 +129,7 @@ afterEach ->
   jasmine.unspy(atom, 'saveSync')
   ensureNoPathSubscriptions()
   atom.syntax.off()
+  ensureNoDeprecatedFunctionsCalled() if isCoreSpec
   waits(0) # yield to ui thread to make screen update more frequently
 
 ensureNoPathSubscriptions = ->
@@ -130,6 +138,27 @@ ensureNoPathSubscriptions = ->
   if watchedPaths.length > 0
     throw new Error("Leaking subscriptions for paths: " + watchedPaths.join(", "))
 
+ensureNoDeprecatedFunctionsCalled = ->
+  deprecations = Grim.getDeprecations()
+  if deprecations.length > 0
+    originalPrepareStackTrace = Error.prepareStackTrace
+    Error.prepareStackTrace = (error, stack) ->
+      output = []
+      for deprecation in deprecations
+        output.push "#{deprecation.originName} is deprecated. #{deprecation.message}"
+        output.push _.multiplyString("-", output[output.length - 1].length)
+        for stack in deprecation.getStacks()
+          for {functionName, location} in stack
+            output.push "#{functionName} -- #{location}"
+        output.push ""
+      output.join("\n")
+
+    error = new Error("Deprecated function(s) #{deprecations.map(({originName}) -> originName).join ', '}) were called.")
+    error.stack
+    Error.prepareStackTrace = originalPrepareStackTrace
+
+    throw error
+
 emitObject = jasmine.StringPrettyPrinter.prototype.emitObject
 jasmine.StringPrettyPrinter.prototype.emitObject = (obj) ->
   if obj.inspect
@@ -187,7 +216,7 @@ window.keydownEvent = (key, properties={}) ->
   originalEventProperties.cmd = properties.metaKey
   originalEventProperties.target = properties.target?[0] ? properties.target
   originalEventProperties.which = properties.which
-  originalEvent = Keymap.keydownEvent(key, originalEventProperties)
+  originalEvent = KeymapManager.keydownEvent(key, originalEventProperties)
   properties = $.extend({originalEvent}, properties)
   $.Event("keydown", properties)
 
@@ -232,7 +261,9 @@ window.waitsForPromise = (args...) ->
 window.resetTimeouts = ->
   window.now = 0
   window.timeoutCount = 0
+  window.intervalCount = 0
   window.timeouts = []
+  window.intervalTimeouts = {}
 
 window.fakeSetTimeout = (callback, ms) ->
   id = ++window.timeoutCount
@@ -242,6 +273,17 @@ window.fakeSetTimeout = (callback, ms) ->
 window.fakeClearTimeout = (idToClear) ->
   window.timeouts = window.timeouts.filter ([id]) -> id != idToClear
 
+window.fakeSetInterval = (callback, ms) ->
+  id = ++window.intervalCount
+  action = ->
+    callback()
+    window.intervalTimeouts[id] = window.fakeSetTimeout(action, ms)
+  window.intervalTimeouts[id] = window.fakeSetTimeout(action, ms)
+  id
+
+window.fakeClearInterval = (idToClear) ->
+  window.fakeClearTimeout(@intervalTimeouts[idToClear])
+
 window.advanceClock = (delta=1) ->
   window.now += delta
   callbacks = []
@@ -278,7 +320,11 @@ $.fn.resultOfTrigger = (type) ->
   event.result
 
 $.fn.enableKeymap = ->
-  @on 'keydown', (e) => atom.keymap.handleKeyEvent(e)
+  @on 'keydown', (e) ->
+    originalEvent = e.originalEvent ? e
+    Object.defineProperty(originalEvent, 'target', get: -> e.target) unless originalEvent.target?
+    atom.keymaps.handleKeyboardEvent(originalEvent)
+    not e.originalEvent.defaultPrevented
 
 $.fn.attachToDom = ->
   @appendTo($('#jasmine-content'))

spec/theme-manager-spec.coffee

@@ -20,7 +20,7 @@ describe "ThemeManager", ->
 
   describe "theme getters and setters", ->
     beforeEach ->
-      atom.packages.loadPackages(sync: true)
+      atom.packages.loadPackages()
 
     it 'getLoadedThemes get all the loaded themes', ->
       themes = themeManager.getLoadedThemes()
@@ -36,6 +36,22 @@ describe "ThemeManager", ->
         themes = themeManager.getActiveThemes()
         expect(themes).toHaveLength(names.length)
 
+  describe "when the core.themes config value contains invalid entry", ->
+    it "ignores theme", ->
+      atom.config.set 'core.themes', [
+        'atom-light-ui'
+        null
+        undefined
+        ''
+        false
+        4
+        {}
+        []
+        'atom-dark-ui'
+      ]
+
+      expect(themeManager.getEnabledThemeNames()).toEqual ['atom-dark-ui', 'atom-light-ui']
+
   describe "getImportPaths()", ->
     it "returns the theme directories before the themes are loaded", ->
       atom.config.set('core.themes', ['theme-with-index-less', 'atom-dark-ui', 'atom-light-ui'])
@@ -115,15 +131,21 @@ describe "ThemeManager", ->
 
   describe "requireStylesheet(path)", ->
     it "synchronously loads css at the given path and installs a style tag for it in the head", ->
+      themeManager.on 'stylesheets-changed', stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
+      themeManager.on 'stylesheet-added', stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
       cssPath = atom.project.resolve('css.css')
       lengthBefore = $('head style').length
 
       themeManager.requireStylesheet(cssPath)
       expect($('head style').length).toBe lengthBefore + 1
 
+      expect(stylesheetAddedHandler).toHaveBeenCalled()
+      expect(stylesheetsChangedHandler).toHaveBeenCalled()
+
       element = $('head style[id*="css.css"]')
       expect(element.attr('id')).toBe themeManager.stringToId(cssPath)
       expect(element.text()).toBe fs.readFileSync(cssPath, 'utf8')
+      expect(element[0].sheet).toBe stylesheetAddedHandler.argsForCall[0][0]
 
       # doesn't append twice
       themeManager.requireStylesheet(cssPath)
@@ -171,9 +193,18 @@ describe "ThemeManager", ->
       themeManager.requireStylesheet(cssPath)
       expect($(document.body).css('font-weight')).toBe("bold")
 
+      themeManager.on 'stylesheet-removed', stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
       themeManager.on 'stylesheets-changed', stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
+
       themeManager.removeStylesheet(cssPath)
+
       expect($(document.body).css('font-weight')).not.toBe("bold")
+
+      expect(stylesheetRemovedHandler).toHaveBeenCalled()
+      stylesheet = stylesheetRemovedHandler.argsForCall[0][0]
+      expect(stylesheet instanceof CSSStyleSheet).toBe true
+      expect(stylesheet.cssRules[0].selectorText).toBe 'body'
+
       expect(stylesheetsChangedHandler).toHaveBeenCalled()
 
   describe "base stylesheet loading", ->
@@ -203,20 +234,21 @@ describe "ThemeManager", ->
 
   describe "when the user stylesheet changes", ->
     it "reloads it", ->
+      [stylesheetRemovedHandler, stylesheetAddedHandler, stylesheetsChangedHandler] = []
       userStylesheetPath = path.join(temp.mkdirSync("atom"), 'styles.less')
       fs.writeFileSync(userStylesheetPath, 'body {border-style: dotted !important;}')
-
       spyOn(themeManager, 'getUserStylesheetPath').andReturn userStylesheetPath
-      themeManager.on 'stylesheets-changed', stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
 
       waitsForPromise ->
         themeManager.activateThemes()
 
       runs ->
-        expect($(document.body).css('border-style')).toBe 'dotted'
-        expect(stylesheetsChangedHandler).toHaveBeenCalled()
-        stylesheetsChangedHandler.reset()
+        themeManager.on 'stylesheets-changed', stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
+        themeManager.on 'stylesheet-removed', stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
+        themeManager.on 'stylesheet-added', stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
         spyOn(themeManager, 'loadUserStylesheet').andCallThrough()
+
+        expect($(document.body).css('border-style')).toBe 'dotted'
         fs.writeFileSync(userStylesheetPath, 'body {border-style: dashed}')
 
       waitsFor ->
@@ -224,7 +256,16 @@ describe "ThemeManager", ->
 
       runs ->
         expect($(document.body).css('border-style')).toBe 'dashed'
+
+        expect(stylesheetRemovedHandler).toHaveBeenCalled()
+        expect(stylesheetRemovedHandler.argsForCall[0][0].cssRules[0].style.border).toBe 'dotted'
+
+        expect(stylesheetAddedHandler).toHaveBeenCalled()
+        expect(stylesheetAddedHandler.argsForCall[0][0].cssRules[0].style.border).toBe 'dashed'
+
         expect(stylesheetsChangedHandler).toHaveBeenCalled()
+
+        stylesheetRemovedHandler.reset()
         stylesheetsChangedHandler.reset()
         fs.removeSync(userStylesheetPath)
 
@@ -232,16 +273,25 @@ describe "ThemeManager", ->
         themeManager.loadUserStylesheet.callCount is 2
 
       runs ->
+        expect(stylesheetRemovedHandler).toHaveBeenCalled()
+        expect(stylesheetRemovedHandler.argsForCall[0][0].cssRules[0].style.border).toBe 'dashed'
         expect($(document.body).css('border-style')).toBe 'none'
         expect(stylesheetsChangedHandler).toHaveBeenCalled()
 
   describe "when a non-existent theme is present in the config", ->
     it "logs a warning but does not throw an exception (regression)", ->
+      reloaded = false
+
       waitsForPromise ->
         themeManager.activateThemes()
 
       runs ->
+        themeManager.once 'reloaded', -> reloaded = true
         spyOn(console, 'warn')
         expect(-> atom.config.set('core.themes', ['atom-light-ui', 'theme-really-does-not-exist'])).not.toThrow()
+
+      waitsFor -> reloaded
+
+      runs ->
         expect(console.warn.callCount).toBe 1
         expect(console.warn.argsForCall[0][0].length).toBeGreaterThan 0

spec/tokenized-buffer-spec.coffee

@@ -119,7 +119,7 @@ describe "TokenizedBuffer", ->
 
       describe "when there is a buffer change surrounding an invalid row", ->
         it "pushes the invalid row to the end of the change", ->
-          buffer.change([[4, 0], [6, 0]], "\n\n\n")
+          buffer.setTextInRange([[4, 0], [6, 0]], "\n\n\n")
           changeHandler.reset()
 
           expect(tokenizedBuffer.firstInvalidRow()).toBe 8
@@ -128,7 +128,7 @@ describe "TokenizedBuffer", ->
       describe "when there is a buffer change inside an invalid region", ->
         it "does not attempt to tokenize the lines in the change, and preserves the existing invalid row", ->
           expect(tokenizedBuffer.firstInvalidRow()).toBe 5
-          buffer.change([[6, 0], [7, 0]], "\n\n\n")
+          buffer.setTextInRange([[6, 0], [7, 0]], "\n\n\n")
 
           expect(tokenizedBuffer.lineForScreenRow(6).ruleStack?).toBeFalsy()
           expect(tokenizedBuffer.lineForScreenRow(7).ruleStack?).toBeFalsy()
@@ -143,7 +143,7 @@ describe "TokenizedBuffer", ->
       describe "when there is a buffer change that is smaller than the chunk size", ->
         describe "when lines are updated, but none are added or removed", ->
           it "updates tokens to reflect the change", ->
-            buffer.change([[0, 0], [2, 0]], "foo()\n7\n")
+            buffer.setTextInRange([[0, 0], [2, 0]], "foo()\n7\n")
 
             expect(tokenizedBuffer.lineForScreenRow(0).tokens[1]).toEqual(value: '(', scopes: ['source.js', 'meta.brace.round.js'])
             expect(tokenizedBuffer.lineForScreenRow(1).tokens[0]).toEqual(value: '7', scopes: ['source.js', 'constant.numeric.js'])
@@ -185,7 +185,7 @@ describe "TokenizedBuffer", ->
 
         describe "when lines are both updated and removed", ->
           it "updates tokens to reflect the change", ->
-            buffer.change([[1, 0], [3, 0]], "foo()")
+            buffer.setTextInRange([[1, 0], [3, 0]], "foo()")
 
             # previous line 0 remains
             expect(tokenizedBuffer.lineForScreenRow(0).tokens[0]).toEqual(value: 'var', scopes: ['source.js', 'storage.modifier.js'])
@@ -209,7 +209,7 @@ describe "TokenizedBuffer", ->
             buffer.insert([5, 30], '/* */')
             changeHandler.reset()
 
-            buffer.change([[2, 0], [3, 0]], '/*')
+            buffer.setTextInRange([[2, 0], [3, 0]], '/*')
             expect(tokenizedBuffer.lineForScreenRow(2).tokens[0].scopes).toEqual ['source.js', 'comment.block.js', 'punctuation.definition.comment.js']
             expect(tokenizedBuffer.lineForScreenRow(3).tokens[0].scopes).toEqual ['source.js']
             expect(changeHandler).toHaveBeenCalled()
@@ -228,7 +228,7 @@ describe "TokenizedBuffer", ->
 
         describe "when lines are both updated and inserted", ->
           it "updates tokens to reflect the change", ->
-            buffer.change([[1, 0], [2, 0]], "foo()\nbar()\nbaz()\nquux()")
+            buffer.setTextInRange([[1, 0], [2, 0]], "foo()\nbar()\nbaz()\nquux()")
 
             # previous line 0 remains
             expect(tokenizedBuffer.lineForScreenRow(0).tokens[0]).toEqual( value: 'var', scopes: ['source.js', 'storage.modifier.js'])
@@ -385,7 +385,58 @@ describe "TokenizedBuffer", ->
       expect(tokens[1].value).toBeTruthy()
       expect(tokens[2].value).toBe 'xyz'
 
+  describe "when the grammar is tokenized", ->
+    it "emits the `tokenized` event", ->
+      editor = null
+      tokenizedHandler = jasmine.createSpy("tokenized handler")
+
+      waitsForPromise ->
+        atom.project.open('sample.js').then (o) -> editor = o
+
+      runs ->
+        tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
+        tokenizedBuffer.on 'tokenized', tokenizedHandler
+        fullyTokenize(tokenizedBuffer)
+        expect(tokenizedHandler.callCount).toBe(1)
+
+    it "doesn't re-emit the `tokenized` event when it is re-tokenized", ->
+      editor = null
+      tokenizedHandler = jasmine.createSpy("tokenized handler")
+
+      waitsForPromise ->
+        atom.project.open('sample.js').then (o) -> editor = o
+
+      runs ->
+        tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
+        fullyTokenize(tokenizedBuffer)
+
+        tokenizedBuffer.on 'tokenized', tokenizedHandler
+        editor.getBuffer().insert([0, 0], "'")
+        fullyTokenize(tokenizedBuffer)
+        expect(tokenizedHandler).not.toHaveBeenCalled()
+
   describe "when the grammar is updated because a grammar it includes is activated", ->
+    it "re-emits the `tokenized` event", ->
+      editor = null
+      tokenizedBuffer = null
+      tokenizedHandler = jasmine.createSpy("tokenized handler")
+
+      waitsForPromise ->
+        atom.project.open('coffee.coffee').then (o) -> editor = o
+
+      runs ->
+        tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
+        tokenizedBuffer.on 'tokenized', tokenizedHandler
+        fullyTokenize(tokenizedBuffer)
+        tokenizedHandler.reset()
+
+      waitsForPromise ->
+        atom.packages.activatePackage('language-coffee-script')
+
+      runs ->
+        fullyTokenize(tokenizedBuffer)
+        expect(tokenizedHandler.callCount).toBe(1)
+
     it "retokenizes the buffer", ->
 
       waitsForPromise ->
@@ -463,3 +514,77 @@ describe "TokenizedBuffer", ->
       expect(tokenizedBuffer.tokenForPosition([0,0]).value).toBe ' '
       atom.config.set('editor.tabLength', 0)
       expect(tokenizedBuffer.tokenForPosition([0,0]).value).toBe '  '
+
+  describe "leading and trailing whitespace", ->
+    beforeEach ->
+      buffer = atom.project.bufferForPathSync('sample.js')
+      tokenizedBuffer = new TokenizedBuffer({buffer})
+      fullyTokenize(tokenizedBuffer)
+
+    it "sets ::hasLeadingWhitespace to true on tokens that have leading whitespace", ->
+      expect(tokenizedBuffer.lineForScreenRow(0).tokens[0].hasLeadingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(1).tokens[0].hasLeadingWhitespace).toBe true
+      expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].hasLeadingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(2).tokens[0].hasLeadingWhitespace).toBe true
+      expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].hasLeadingWhitespace).toBe true
+      expect(tokenizedBuffer.lineForScreenRow(2).tokens[2].hasLeadingWhitespace).toBe false
+
+      # The 4th token *has* leading whitespace, but isn't entirely whitespace
+      buffer.insert([5, 0], ' ')
+      expect(tokenizedBuffer.lineForScreenRow(5).tokens[3].hasLeadingWhitespace).toBe true
+      expect(tokenizedBuffer.lineForScreenRow(5).tokens[4].hasLeadingWhitespace).toBe false
+
+      # Lines that are *only* whitespace are not considered to have leading whitespace
+      buffer.insert([10, 0], '  ')
+      expect(tokenizedBuffer.lineForScreenRow(10).tokens[0].hasLeadingWhitespace).toBe false
+
+    it "sets ::hasTrailingWhitespace to true on tokens that have trailing whitespace", ->
+      buffer.insert([0, Infinity], '  ')
+      expect(tokenizedBuffer.lineForScreenRow(0).tokens[11].hasTrailingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(0).tokens[12].hasTrailingWhitespace).toBe true
+
+      # The last token *has* trailing whitespace, but isn't entirely whitespace
+      buffer.setTextInRange([[2, 39], [2, 40]], '  ')
+      expect(tokenizedBuffer.lineForScreenRow(2).tokens[14].hasTrailingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(2).tokens[15].hasTrailingWhitespace).toBe true
+
+      # Lines that are *only* whitespace are considered to have trailing whitespace
+      buffer.insert([10, 0], '  ')
+      expect(tokenizedBuffer.lineForScreenRow(10).tokens[0].hasTrailingWhitespace).toBe true
+
+    it "only marks trailing whitespace on the last segment of a soft-wrapped line", ->
+      buffer.insert([0, Infinity], '  ')
+      tokenizedLine = tokenizedBuffer.lineForScreenRow(0)
+      [segment1, segment2] = tokenizedLine.softWrapAt(16)
+      expect(segment1.tokens[5].value).toBe ' '
+      expect(segment1.tokens[5].hasTrailingWhitespace).toBe false
+      expect(segment2.tokens[6].value).toBe '  '
+      expect(segment2.tokens[6].hasTrailingWhitespace).toBe true
+
+  describe "indent level", ->
+    beforeEach ->
+      buffer = atom.project.bufferForPathSync('sample.js')
+      tokenizedBuffer = new TokenizedBuffer({buffer})
+      fullyTokenize(tokenizedBuffer)
+
+    describe "when the line is non-empty", ->
+      it "has an indent level based on the leading whitespace on the line", ->
+        expect(tokenizedBuffer.lineForScreenRow(0).indentLevel).toBe 0
+        expect(tokenizedBuffer.lineForScreenRow(1).indentLevel).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(2).indentLevel).toBe 2
+        buffer.insert([2, 0], ' ')
+        expect(tokenizedBuffer.lineForScreenRow(2).indentLevel).toBe 2.5
+
+    describe "when the line is empty", ->
+      it "assumes the indentation level of the first non-empty line below or above if one exists", ->
+        buffer.insert([12, 0], '    ')
+        buffer.insert([12, Infinity], '\n\n')
+        expect(tokenizedBuffer.lineForScreenRow(13).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(14).indentLevel).toBe 2
+
+        buffer.insert([1, Infinity], '\n\n')
+        expect(tokenizedBuffer.lineForScreenRow(2).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(3).indentLevel).toBe 2
+
+        buffer.setText('\n\n\n')
+        expect(tokenizedBuffer.lineForScreenRow(1).indentLevel).toBe 0

spec/tokenized-line-spec.coffee

@@ -0,0 +1,26 @@
+describe "TokenizedLine", ->
+  editor = null
+
+  beforeEach ->
+    waitsForPromise -> atom.packages.activatePackage('language-coffee-script')
+
+  describe "::getScopeTree()", ->
+    it "returns a tree whose inner nodes are scopes and whose leaf nodes are tokens in those scopes", ->
+      [tokens, tokenIndex] = []
+
+      ensureValidScopeTree = (scopeTree, scopes=[]) ->
+        if scopeTree.children?
+          for child in scopeTree.children
+            ensureValidScopeTree(child, scopes.concat([scopeTree.scope]))
+        else
+          expect(scopeTree).toBe tokens[tokenIndex++]
+          expect(scopes).toEqual scopeTree.scopes
+
+      waitsForPromise ->
+        atom.project.open('coffee.coffee').then (o) -> editor = o
+
+      runs ->
+        tokenIndex = 0
+        tokens = editor.lineForScreenRow(1).tokens
+        scopeTree = editor.lineForScreenRow(1).getScopeTree()
+        ensureValidScopeTree(scopeTree)

spec/window-spec.coffee

@@ -64,27 +64,41 @@ describe "Window", ->
 
     describe "when pane items are are modified", ->
       it "prompts user to save and and calls workspaceView.confirmClose", ->
+        editor = null
         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(atom.workspaceView.confirmClose).toHaveBeenCalled()
-        expect(atom.confirm).toHaveBeenCalled()
+
+        waitsForPromise ->
+          atom.workspace.open("sample.js").then (o) -> editor = o
+
+        runs ->
+          editor.insertText("I look different, I feel different.")
+          $(window).trigger(beforeUnloadEvent)
+          expect(atom.workspaceView.confirmClose).toHaveBeenCalled()
+          expect(atom.confirm).toHaveBeenCalled()
 
       it "prompts user to save and handler returns true if don't save", ->
+        editor = null
         spyOn(atom, "confirm").andReturn(2)
-        editor = atom.workspaceView.openSync("sample.js")
-        editor.insertText("I look different, I feel different.")
-        $(window).trigger(beforeUnloadEvent)
-        expect(atom.confirm).toHaveBeenCalled()
+
+        waitsForPromise ->
+          atom.workspace.open("sample.js").then (o) -> editor = o
+
+        runs ->
+          editor.insertText("I look different, I feel different.")
+          $(window).trigger(beforeUnloadEvent)
+          expect(atom.confirm).toHaveBeenCalled()
 
       it "prompts user to save and handler returns false if dialog is canceled", ->
+        editor = null
         spyOn(atom, "confirm").andReturn(1)
-        editor = atom.workspaceView.openSync("sample.js")
-        editor.insertText("I look different, I feel different.")
-        $(window).trigger(beforeUnloadEvent)
-        expect(atom.confirm).toHaveBeenCalled()
+        waitsForPromise ->
+          atom.workspace.open("sample.js").then (o) -> editor = o
+
+        runs ->
+          editor.insertText("I look different, I feel different.")
+          $(window).trigger(beforeUnloadEvent)
+          expect(atom.confirm).toHaveBeenCalled()
 
   describe ".unloadEditorWindow()", ->
     it "saves the serialized state of the window so it can be deserialized after reload", ->
@@ -100,15 +114,18 @@ describe "Window", ->
       expect(atom.saveSync).toHaveBeenCalled()
 
     it "unsubscribes from all buffers", ->
-      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
+      waitsForPromise ->
+        atom.workspace.open("sample.js")
 
-      atom.unloadEditorWindow()
+      runs ->
+        buffer = atom.workspace.getActivePaneItem().buffer
+        pane = atom.workspaceView.getActivePaneView()
+        pane.splitRight(pane.copyActiveItem())
+        expect(atom.workspaceView.find('.editor').length).toBe 2
 
-      expect(buffer.getSubscriptionCount()).toBe 0
+        atom.unloadEditorWindow()
+
+        expect(buffer.getSubscriptionCount()).toBe 0
 
   describe "drag and drop", ->
     buildDragEvent = (type, files) ->

spec/workspace-spec.coffee

@@ -5,7 +5,7 @@ describe "Workspace", ->
 
   beforeEach ->
     atom.project.setPath(atom.project.resolve('dir'))
-    workspace = new Workspace
+    atom.workspace = workspace = new Workspace
 
   describe "::open(uri, options)", ->
     beforeEach ->
@@ -37,12 +37,17 @@ describe "Workspace", ->
       describe "when called with a uri", ->
         describe "when the active pane already has an editor for the given uri", ->
           it "activates the existing editor on the active pane", ->
-            editor1 = workspace.openSync('a')
-            editor2 = workspace.openSync('b')
-
             editor = null
+            editor1 = null
+            editor2 = null
+
             waitsForPromise ->
-              workspace.open('a').then (o) -> editor = o
+              workspace.open('a').then (o) ->
+                editor1 = o
+                workspace.open('b').then (o) ->
+                  editor2 = o
+                  workspace.open('a').then (o) ->
+                    editor = o
 
             runs ->
               expect(editor).toBe editor1
@@ -64,11 +69,21 @@ describe "Workspace", ->
     describe "when the 'searchAllPanes' option is true", ->
       describe "when an editor for the given uri is already open on an inactive pane", ->
         it "activates the existing editor on the inactive pane, then activates that pane", ->
-          editor1 = workspace.openSync('a')
-          pane1 = workspace.activePane
-          pane2 = workspace.activePane.splitRight()
-          editor2 = workspace.openSync('b')
-          expect(workspace.activePaneItem).toBe editor2
+          editor1 = null
+          editor2 = null
+          pane1 = workspace.getActivePane()
+          pane2 = workspace.getActivePane().splitRight()
+
+          waitsForPromise ->
+            pane1.activate()
+            workspace.open('a').then (o) -> editor1 = o
+
+          waitsForPromise ->
+            pane2.activate()
+            workspace.open('b').then (o) -> editor2 = o
+
+          runs ->
+            expect(workspace.activePaneItem).toBe editor2
 
           waitsForPromise ->
             workspace.open('a', searchAllPanes: true)
@@ -112,6 +127,22 @@ describe "Workspace", ->
             expect(pane1.items).toEqual [editor]
             expect(pane2.items).toEqual []
 
+      describe "when a pane axis is the leftmost sibling of the current pane", ->
+        it "opens the new item in the current pane", ->
+          editor = null
+          pane1 = workspace.activePane
+          pane2 = pane1.splitLeft()
+          pane3 = pane2.splitDown()
+          pane1.activate()
+          expect(workspace.activePane).toBe pane1
+
+          waitsForPromise ->
+            workspace.open('a', split: 'left').then (o) -> editor = o
+
+          runs ->
+            expect(workspace.activePane).toBe pane1
+            expect(pane1.items).toEqual [editor]
+
       describe "when the 'split' option is 'right'", ->
         it "opens the editor in the rightmost pane of the current pane axis", ->
           editor = null
@@ -136,6 +167,26 @@ describe "Workspace", ->
             expect(pane1.items).toEqual []
             expect(pane2.items).toEqual [editor]
 
+        describe "when a pane axis is the rightmost sibling of the current pane", ->
+          it "opens the new item in a new pane split to the right of the current pane", ->
+            editor = null
+            pane1 = workspace.activePane
+            pane2 = pane1.splitRight()
+            pane3 = pane2.splitDown()
+            pane1.activate()
+            expect(workspace.activePane).toBe pane1
+            pane4 = null
+
+            waitsForPromise ->
+              workspace.open('a', split: 'right').then (o) -> editor = o
+
+            runs ->
+              pane4 = workspace.getPanes().filter((p) -> p != pane1)[0]
+              expect(workspace.activePane).toBe pane4
+              expect(pane4.items).toEqual [editor]
+              expect(workspace.paneContainer.root.children[0]).toBe pane1
+              expect(workspace.paneContainer.root.children[1]).toBe pane4
+
     describe "when passed a path that matches a custom opener", ->
       it "returns the resource returned by the custom opener", ->
         fooOpener = (pathToOpen, options) -> { foo: pathToOpen, options } if pathToOpen?.match(/\.foo/)
@@ -152,80 +203,67 @@ describe "Workspace", ->
           workspace.open("bar://baz").then (item) ->
             expect(item).toEqual { bar: "bar://baz" }
 
-  describe "::openSync(uri, options)", ->
-    [activePane, initialItemCount] = []
+    it "emits an 'editor-created' event", ->
+      absolutePath = require.resolve('./fixtures/dir/a')
+      newEditorHandler = jasmine.createSpy('newEditorHandler')
+      workspace.on 'editor-created', newEditorHandler
 
-    beforeEach ->
-      activePane = workspace.activePane
-      spyOn(activePane, 'activate')
-      initialItemCount = activePane.items.length
+      editor = null
+      waitsForPromise ->
+        workspace.open(absolutePath).then (e) -> editor = e
 
-    describe "when called without a uri", ->
-      it "adds and activates an empty editor on the active pane", ->
-        editor = workspace.openSync()
-        expect(activePane.items.length).toBe initialItemCount + 1
-        expect(activePane.activeItem).toBe editor
-        expect(editor.getPath()).toBeUndefined()
-        expect(activePane.activate).toHaveBeenCalled()
+      runs ->
+        expect(newEditorHandler).toHaveBeenCalledWith editor
 
-    describe "when called with a uri", ->
-      describe "when the active pane already has an editor for the given uri", ->
-        it "activates the existing editor on the active pane", ->
-          editor1 = workspace.openSync('a')
-          editor2 = workspace.openSync('b')
-          expect(activePane.activeItem).toBe editor2
-          expect(activePane.items.length).toBe 2
-
-          editor = workspace.openSync(editor1.getPath())
-          expect(editor).toBe editor1
-          expect(activePane.activeItem).toBe editor
-          expect(activePane.activate).toHaveBeenCalled()
-          expect(activePane.items.length).toBe 2
-
-      describe "when the active pane does not have an editor for the given uri", ->
-        it "adds and activates a new editor for the given path on the active pane", ->
-          editor = workspace.openSync('a')
-          expect(activePane.items.length).toBe 1
-          expect(activePane.activeItem).toBe editor
-          expect(activePane.activate).toHaveBeenCalled()
-
-    describe "when the 'activatePane' option is false", ->
-      it "does not activate the active pane", ->
-        workspace.openSync('b', activatePane: false)
-        expect(activePane.activate).not.toHaveBeenCalled()
-
-  describe "::reopenItemSync()", ->
+  describe "::reopenItem()", ->
     it "opens the uri associated with the last closed pane that isn't currently open", ->
       pane = workspace.activePane
-      workspace.openSync('a')
-      workspace.openSync('b')
-      workspace.openSync('file1')
-      workspace.openSync()
+      waitsForPromise ->
+        workspace.open('a').then ->
+          workspace.open('b').then ->
+            workspace.open('file1').then ->
+              workspace.open()
 
-      # does not reopen items with no uri
-      expect(workspace.activePaneItem.getUri()).toBeUndefined()
-      pane.destroyActiveItem()
-      workspace.reopenItemSync()
-      expect(workspace.activePaneItem.getUri()).not.toBeUndefined()
+      runs ->
+        # does not reopen items with no uri
+        expect(workspace.activePaneItem.getUri()).toBeUndefined()
+        pane.destroyActiveItem()
 
-      # destroy all items
-      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('file1')
-      pane.destroyActiveItem()
-      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('b')
-      pane.destroyActiveItem()
-      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('a')
-      pane.destroyActiveItem()
+      waitsForPromise ->
+        workspace.reopenItem()
 
-      # reopens items with uris
-      expect(workspace.activePaneItem).toBeUndefined()
-      workspace.reopenItemSync()
-      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('a')
+      runs ->
+        expect(workspace.activePaneItem.getUri()).not.toBeUndefined()
+
+        # destroy all items
+        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('file1')
+        pane.destroyActiveItem()
+        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('b')
+        pane.destroyActiveItem()
+        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('a')
+        pane.destroyActiveItem()
+
+        # reopens items with uris
+        expect(workspace.activePaneItem).toBeUndefined()
+
+      waitsForPromise ->
+        workspace.reopenItem()
+
+      runs ->
+        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('a')
 
       # does not reopen items that are already open
-      workspace.openSync('b')
-      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('b')
-      workspace.reopenItemSync()
-      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('file1')
+      waitsForPromise ->
+        workspace.open('b')
+
+      runs ->
+        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('b')
+
+      waitsForPromise ->
+        workspace.reopenItem()
+
+      runs ->
+        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('file1')
 
   describe "::increase/decreaseFontSize()", ->
     it "increases/decreases the font size without going below 1", ->
@@ -245,3 +283,29 @@ describe "Workspace", ->
     it "opens the license as plain-text in a buffer", ->
       waitsForPromise -> workspace.openLicense()
       runs -> expect(workspace.activePaneItem.getText()).toMatch /Copyright/
+
+  describe "when an editor is destroyed", ->
+    it "removes the editor", ->
+      editor = null
+
+      waitsForPromise ->
+        workspace.open("a").then (e) -> editor = e
+
+      runs ->
+        expect(workspace.getEditors()).toHaveLength 1
+        editor.destroy()
+        expect(workspace.getEditors()).toHaveLength 0
+
+  describe "when an editor is copied", ->
+    it "emits an 'editor-created' event", ->
+      editor = null
+      handler = jasmine.createSpy('editorCreatedHandler')
+      workspace.on 'editor-created', handler
+
+      waitsForPromise ->
+        workspace.open("a").then (o) -> editor = o
+
+      runs ->
+        expect(handler.callCount).toBe 1
+        editorCopy = editor.copy()
+        expect(handler.callCount).toBe 2

spec/workspace-view-spec.coffee

@@ -2,6 +2,7 @@
 Q = require 'q'
 path = require 'path'
 temp = require 'temp'
+EditorView = require '../src/editor-view'
 PaneView = require '../src/pane-view'
 Workspace = require '../src/workspace'
 
@@ -14,9 +15,12 @@ describe "WorkspaceView", ->
     atom.workspace = new Workspace
     atom.workspaceView = new WorkspaceView(atom.workspace)
     atom.workspaceView.enableKeymap()
-    atom.workspaceView.openSync(pathToOpen)
     atom.workspaceView.focus()
 
+    waitsForPromise ->
+      atom.workspace.open(pathToOpen)
+
+
   describe "@deserialize()", ->
     viewState = null
 
@@ -32,64 +36,82 @@ describe "WorkspaceView", ->
     describe "when the serialized WorkspaceView has an unsaved buffer", ->
       it "constructs the view with the same panes", ->
         atom.workspaceView.attachToDom()
-        atom.workspaceView.openSync()
-        editorView1 = atom.workspaceView.getActiveView()
-        buffer = editorView1.getEditor().getBuffer()
-        editorView1.splitRight()
-        expect(atom.workspaceView.getActivePane()).toBe atom.workspaceView.getPaneViews()[1]
 
-        simulateReload()
+        waitsForPromise ->
+          atom.workspace.open()
 
-        expect(atom.workspaceView.getEditorViews().length).toBe 2
-        expect(atom.workspaceView.getActivePane()).toBe atom.workspaceView.getPaneViews()[1]
-        expect(atom.workspaceView.title).toBe "untitled - #{atom.project.getPath()}"
+        runs ->
+          editorView1 = atom.workspaceView.getActiveView()
+          buffer = editorView1.getEditor().getBuffer()
+          editorView1.splitRight()
+          expect(atom.workspaceView.getActivePaneView()).toBe atom.workspaceView.getPaneViews()[1]
+
+          simulateReload()
+
+          expect(atom.workspaceView.getEditorViews().length).toBe 2
+          expect(atom.workspaceView.getActivePaneView()).toBe atom.workspaceView.getPaneViews()[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()
+        pane1 = atom.workspaceView.getActivePaneView()
         pane2 = pane1.splitRight()
         pane3 = pane2.splitRight()
-        pane4 = pane2.splitDown()
-        pane2.activateItem(atom.project.openSync('b'))
-        pane3.activateItem(atom.project.openSync('../sample.js'))
-        pane3.activeItem.setCursorScreenPosition([2, 4])
-        pane4.activateItem(atom.project.openSync('../sample.txt'))
-        pane4.activeItem.setCursorScreenPosition([0, 2])
-        pane2.focus()
+        pane4 = null
 
-        simulateReload()
+        waitsForPromise ->
+          atom.workspace.open('b').then (editor) ->
+            pane2.activateItem(editor)
 
-        expect(atom.workspaceView.getEditorViews().length).toBe 4
-        editorView1 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(0)').view()
-        editorView3 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(1)').view()
-        editorView2 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(0)').view()
-        editorView4 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(1)').view()
+        waitsForPromise ->
+          atom.workspace.open('../sample.js').then (editor) ->
+            pane3.activateItem(editor)
 
-        expect(editorView1.getEditor().getPath()).toBe atom.project.resolve('a')
-        expect(editorView2.getEditor().getPath()).toBe atom.project.resolve('b')
-        expect(editorView3.getEditor().getPath()).toBe atom.project.resolve('../sample.js')
-        expect(editorView3.getEditor().getCursorScreenPosition()).toEqual [2, 4]
-        expect(editorView4.getEditor().getPath()).toBe atom.project.resolve('../sample.txt')
-        expect(editorView4.getEditor().getCursorScreenPosition()).toEqual [0, 2]
+        runs ->
+          pane3.activeItem.setCursorScreenPosition([2, 4])
+          pane4 = pane2.splitDown()
 
-        # ensure adjust pane dimensions is called
-        expect(editorView1.width()).toBeGreaterThan 0
-        expect(editorView2.width()).toBeGreaterThan 0
-        expect(editorView3.width()).toBeGreaterThan 0
-        expect(editorView4.width()).toBeGreaterThan 0
+        waitsForPromise ->
+          atom.workspace.open('../sample.txt').then (editor) ->
+            pane4.activateItem(editor)
 
-        # ensure correct editorView is focused again
-        expect(editorView2.isFocused).toBeTruthy()
-        expect(editorView1.isFocused).toBeFalsy()
-        expect(editorView3.isFocused).toBeFalsy()
-        expect(editorView4.isFocused).toBeFalsy()
+        runs ->
+          pane4.activeItem.setCursorScreenPosition([0, 2])
+          pane2.focus()
 
-        expect(atom.workspaceView.title).toBe "#{path.basename(editorView2.getEditor().getPath())} - #{atom.project.getPath()}"
+          simulateReload()
+
+          expect(atom.workspaceView.getEditorViews().length).toBe 4
+          editorView1 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(0)').view()
+          editorView3 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(1)').view()
+          editorView2 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(0)').view()
+          editorView4 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(1)').view()
+
+          expect(editorView1.getEditor().getPath()).toBe atom.project.resolve('a')
+          expect(editorView2.getEditor().getPath()).toBe atom.project.resolve('b')
+          expect(editorView3.getEditor().getPath()).toBe atom.project.resolve('../sample.js')
+          expect(editorView3.getEditor().getCursorScreenPosition()).toEqual [2, 4]
+          expect(editorView4.getEditor().getPath()).toBe atom.project.resolve('../sample.txt')
+          expect(editorView4.getEditor().getCursorScreenPosition()).toEqual [0, 2]
+
+          # ensure adjust pane dimensions is called
+          expect(editorView1.width()).toBeGreaterThan 0
+          expect(editorView2.width()).toBeGreaterThan 0
+          expect(editorView3.width()).toBeGreaterThan 0
+          expect(editorView4.width()).toBeGreaterThan 0
+
+          # ensure correct editorView is focused again
+          expect(editorView2).toHaveFocus()
+          expect(editorView1).not.toHaveFocus()
+          expect(editorView3).not.toHaveFocus()
+          expect(editorView4).not.toHaveFocus()
+
+          expect(atom.workspaceView.title).toBe "#{path.basename(editorView2.getEditor().getPath())} - #{atom.project.getPath()}"
 
     describe "where there are no open editors", ->
       it "constructs the view with no open editors", ->
-        atom.workspaceView.getActivePane().remove()
+        atom.workspaceView.getActivePaneView().remove()
         expect(atom.workspaceView.getEditorViews().length).toBe 0
         simulateReload()
         expect(atom.workspaceView.getEditorViews().length).toBe 0
@@ -99,11 +121,11 @@ describe "WorkspaceView", ->
       atom.workspaceView.attachToDom()
 
     it "hands off focus to the active pane", ->
-      activePane = atom.workspaceView.getActivePane()
+      activePane = atom.workspaceView.getActivePaneView()
       $('body').focus()
-      expect(activePane.hasFocus()).toBe false
+      expect(activePane).not.toHaveFocus()
       atom.workspaceView.focus()
-      expect(activePane.hasFocus()).toBe true
+      expect(activePane).toHaveFocus()
 
   describe "keymap wiring", ->
     commandHandler = null
@@ -111,7 +133,7 @@ describe "WorkspaceView", ->
       commandHandler = jasmine.createSpy('commandHandler')
       atom.workspaceView.on('foo-command', commandHandler)
 
-      atom.keymap.bindKeys('name', '*', 'x': 'foo-command')
+      atom.keymaps.add('name', '*': {'x': 'foo-command'})
 
     describe "when a keydown event is triggered in the WorkspaceView", ->
       it "triggers matching keybindings for that event", ->
@@ -128,43 +150,44 @@ describe "WorkspaceView", ->
 
     describe "when the project has a path", ->
       beforeEach ->
-        atom.workspaceView.openSync('b')
+        waitsForPromise ->
+          atom.workspace.open('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()
+          item = atom.workspace.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 = atom.workspace.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()
+          atom.workspaceView.getActivePaneView().activateNextItem()
+          item = atom.workspace.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()
+          atom.workspaceView.getActivePaneView().remove()
+          expect(atom.workspace.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 = atom.workspaceView.getActivePaneView()
           pane.splitRight()
           initialTitle = atom.workspaceView.title
-          pane.showNextItem()
+          pane.activateNextItem()
           expect(atom.workspaceView.title).toBe initialTitle
 
     describe "when the root view is deserialized", ->
       it "updates the title to contain the project's path", ->
         workspaceView2 = new WorkspaceView(atom.workspace.testSerialization())
-        item = atom.workspaceView.getActivePaneItem()
+        item = atom.workspace.getActivePaneItem()
         expect(workspaceView2.title).toBe "#{item.getTitle()} - #{atom.project.getPath()}"
         workspaceView2.remove()
 
@@ -222,6 +245,14 @@ describe "WorkspaceView", ->
       expect(count).toBe 1
       expect(callbackEditor).toBe atom.workspaceView.getActiveView()
 
+    it "does not invoke the callback for mini editors", ->
+      editorViewCreatedHandler = jasmine.createSpy('editorViewCreatedHandler')
+      atom.workspaceView.eachEditorView(editorViewCreatedHandler)
+      editorViewCreatedHandler.reset()
+      miniEditor = new EditorView(mini: true)
+      atom.workspaceView.append(miniEditor)
+      expect(editorViewCreatedHandler).not.toHaveBeenCalled()
+
     it "returns a subscription that can be disabled", ->
       count = 0
       callback = (editor) -> count++
@@ -237,10 +268,22 @@ describe "WorkspaceView", ->
   describe "core:close", ->
     it "closes the active pane item until all that remains is a single empty pane", ->
       atom.config.set('core.destroyEmptyPanes', true)
-      atom.project.openSync('../sample.txt')
-      expect(atom.workspaceView.getActivePane().getItems()).toHaveLength 1
+
+      paneView1 = atom.workspaceView.getActivePaneView()
+      editorView = atom.workspaceView.getActiveView()
+      editorView.splitRight()
+      paneView2 = atom.workspaceView.getActivePaneView()
+
+      expect(paneView1).not.toBe paneView2
+      expect(atom.workspaceView.getPaneViews()).toHaveLength 2
       atom.workspaceView.trigger('core:close')
-      expect(atom.workspaceView.getActivePane().getItems()).toHaveLength 0
+
+      expect(atom.workspaceView.getActivePaneView().getItems()).toHaveLength 1
+      expect(atom.workspaceView.getPaneViews()).toHaveLength 1
+      atom.workspaceView.trigger('core:close')
+
+      expect(atom.workspaceView.getActivePaneView().getItems()).toHaveLength 0
+      expect(atom.workspaceView.getPaneViews()).toHaveLength 1
 
   describe "the scrollbar visibility class", ->
     it "has a class based on the style of the scrollbar", ->

src/atom.coffee

@@ -1,6 +1,5 @@
 crypto = require 'crypto'
 ipc = require 'ipc'
-keytar = require 'keytar'
 os = require 'os'
 path = require 'path'
 remote = require 'remote'
@@ -8,6 +7,7 @@ screen = require 'screen'
 shell = require 'shell'
 
 _ = require 'underscore-plus'
+{deprecated} = require 'grim'
 {Model} = require 'theorist'
 fs = require 'fs-plus'
 
@@ -24,7 +24,7 @@ WindowEventHandler = require './window-event-handler'
 #  * `atom.config`        - A {Config} instance
 #  * `atom.contextMenu`   - A {ContextMenuManager} instance
 #  * `atom.deserializers` - A {DeserializerManager} instance
-#  * `atom.keymap`        - A {Keymap} instance
+#  * `atom.keymaps`        - A {KeymapManager} instance
 #  * `atom.menu`          - A {MenuManager} instance
 #  * `atom.packages`      - A {PackageManager} instance
 #  * `atom.project`       - A {Project} instance
@@ -38,8 +38,8 @@ class Atom extends Model
 
   # Public: Load or create the Atom environment in the given mode.
   #
-  # - mode: Pass 'editor' or 'spec' depending on the kind of environment you
-  #         want to build.
+  # mode - Pass 'editor' or 'spec' depending on the kind of environment you
+  #        want to build.
   #
   # Returns an Atom instance, fully initialized
   @loadOrCreate: (mode) ->
@@ -132,6 +132,7 @@ class Atom extends Model
   initialize: ->
     window.onerror = =>
       @openDevTools()
+      @executeJavaScriptInDevTools('InspectorFrontendAPI.showConsole()')
       @emit 'uncaught-error', arguments...
 
     @unsubscribe()
@@ -140,14 +141,14 @@ class Atom extends Model
     @loadTime = null
 
     Config = require './config'
-    Keymap = require './keymap-extensions'
+    KeymapManager = require './keymap-extensions'
     PackageManager = require './package-manager'
     Clipboard = require './clipboard'
     Syntax = require './syntax'
     ThemeManager = require './theme-manager'
     ContextMenuManager = require './context-menu-manager'
     MenuManager = require './menu-manager'
-    {devMode, resourcePath} = @getLoadSettings()
+    {devMode, safeMode, resourcePath} = @getLoadSettings()
     configDirPath = @getConfigDirPath()
 
     # Add 'src/exports' to module search path.
@@ -156,9 +157,13 @@ class Atom extends Model
     # Still set NODE_PATH since tasks may need it.
     process.env.NODE_PATH = exportsPath
 
+    # Make react.js faster
+    process.env.NODE_ENV ?= 'production'
+
     @config = new Config({configDirPath, resourcePath})
-    @keymap = new Keymap({configDirPath, resourcePath})
-    @packages = new PackageManager({devMode, configDirPath, resourcePath})
+    @keymaps = new KeymapManager({configDirPath, resourcePath})
+    @keymap = @keymaps # Deprecated
+    @packages = new PackageManager({devMode, configDirPath, resourcePath, safeMode})
     @themes = new ThemeManager({packageManager: @packages, configDirPath, resourcePath})
     @contextMenu = new ContextMenuManager(devMode)
     @menu = new MenuManager({resourcePath})
@@ -179,9 +184,11 @@ class Atom extends Model
 
   # Deprecated: Callers should be converted to use atom.deserializers
   registerRepresentationClass: ->
+    deprecated("Callers should be converted to use atom.deserializers")
 
   # Deprecated: Callers should be converted to use atom.deserializers
   registerRepresentationClasses: ->
+    deprecated("Callers should be converted to use atom.deserializers")
 
   setBodyPlatformClass: ->
     document.body.classList.add("platform-#{process.platform}")
@@ -205,11 +212,11 @@ class Atom extends Model
   # in the dimensions parameter. If x or y are omitted the window will be
   # centered. If height or width are omitted only the position will be changed.
   #
-  # * dimensions:
-  #    + x: The new x coordinate.
-  #    + y: The new y coordinate.
-  #    + width: The new width.
-  #    + height: The new height.
+  # dimensions - An {Object} with the following keys:
+  #   :x - The new x coordinate.
+  #   :y - The new y coordinate.
+  #   :width - The new width.
+  #   :height - The new height.
   setWindowDimensions: ({x, y, width, height}) ->
     if width? and height?
       @setSize(width, height)
@@ -218,12 +225,26 @@ class Atom extends Model
     else
       @center()
 
+  storeDefaultWindowDimensions: ->
+    dimensions = JSON.stringify(atom.getWindowDimensions())
+    localStorage.setItem("defaultWindowDimensions", dimensions)
+
+  getDefaultWindowDimensions: ->
+    {windowDimensions} = @getLoadSettings()
+    return windowDimensions if windowDimensions?
+
+    dimensions = null
+    try
+      dimensions = JSON.parse(localStorage.getItem("defaultWindowDimensions"))
+    catch error
+      console.warn "Error parsing default window dimensions", error
+      localStorage.removeItem("defaultWindowDimensions")
+
+    {width, height} = screen.getPrimaryDisplay().workAreaSize
+    dimensions ? {x: 0, y: 0, width: Math.min(1024, width), height: height}
+
   restoreWindowDimensions: ->
-    workAreaSize = screen.getPrimaryDisplay().workAreaSize
-    windowDimensions = @state.windowDimensions ? {}
-    {initialSize} = @getLoadSettings()
-    windowDimensions.height ?= initialSize?.height ? workAreaSize.height
-    windowDimensions.width ?= initialSize?.width ? Math.min(workAreaSize.width, 1024)
+    windowDimensions = @state.windowDimensions ? @getDefaultWindowDimensions()
     @setWindowDimensions(windowDimensions)
 
   storeWindowDimensions: ->
@@ -244,7 +265,7 @@ class Atom extends Model
     WorkspaceView = require './workspace-view'
     @workspace = Workspace.deserialize(@state.workspace) ? new Workspace
     @workspaceView = new WorkspaceView(@workspace)
-    @keymap.defaultTarget = @workspaceView[0]
+    @keymaps.defaultTarget = @workspaceView[0]
     $(@workspaceViewParentSelector).append(@workspaceView)
 
   deserializePackageStates: ->
@@ -269,12 +290,12 @@ class Atom extends Model
     @config.load()
     @config.setDefaults('core', require('./workspace-view').configDefaults)
     @config.setDefaults('editor', require('./editor-view').configDefaults)
-    @keymap.loadBundledKeymaps()
+    @keymaps.loadBundledKeymaps()
     @themes.loadBaseStylesheets()
     @packages.loadPackages()
     @deserializeEditorWindow()
     @packages.activate()
-    @keymap.loadUserKeymap()
+    @keymaps.loadUserKeymap()
     @requireUserInitScript()
     @menu.update()
 
@@ -298,7 +319,7 @@ class Atom extends Model
     @workspaceView = null
     @project.destroy()
     @windowEventHandler?.unsubscribe()
-    @keymap.destroy()
+    @keymaps.destroy()
     @windowState = null
 
   loadThemes: ->
@@ -319,7 +340,7 @@ class Atom extends Model
   # options - An {Object} with the following keys:
   #   :pathsToOpen -  An {Array} of {String} paths to open.
   open: (options) ->
-    ipc.sendChannel('open', options)
+    ipc.send('open', options)
 
   # Public: Open a confirm dialog.
   #
@@ -373,46 +394,50 @@ class Atom extends Model
 
   # Public: Open the dev tools for the current window.
   openDevTools: ->
-    ipc.sendChannel('call-window-method', 'openDevTools')
+    ipc.send('call-window-method', 'openDevTools')
 
   # Public: Toggle the visibility of the dev tools for the current window.
   toggleDevTools: ->
-    ipc.sendChannel('call-window-method', 'toggleDevTools')
+    ipc.send('call-window-method', 'toggleDevTools')
+
+  # Public: Execute code in dev tools.
+  executeJavaScriptInDevTools: (code) ->
+    ipc.send('call-window-method', 'executeJavaScriptInDevTools', code)
 
   # Public: Reload the current window.
   reload: ->
-    ipc.sendChannel('call-window-method', 'restart')
+    ipc.send('call-window-method', 'restart')
 
   # Public: Focus the current window.
   focus: ->
-    ipc.sendChannel('call-window-method', 'focus')
+    ipc.send('call-window-method', 'focus')
     $(window).focus()
 
   # Public: Show the current window.
   show: ->
-    ipc.sendChannel('call-window-method', 'show')
+    ipc.send('call-window-method', 'show')
 
   # Public: Hide the current window.
   hide: ->
-    ipc.sendChannel('call-window-method', 'hide')
+    ipc.send('call-window-method', 'hide')
 
   # Public: Set the size of current window.
   #
   # width  - The {Number} of pixels.
   # height - The {Number} of pixels.
   setSize: (width, height) ->
-    ipc.sendChannel('call-window-method', 'setSize', width, height)
+    ipc.send('call-window-method', 'setSize', width, height)
 
   # Public: Set the position of current window.
   #
   # x - The {Number} of pixels.
   # y - The {Number} of pixels.
   setPosition: (x, y) ->
-    ipc.sendChannel('call-window-method', 'setPosition', x, y)
+    ipc.send('call-window-method', 'setPosition', x, y)
 
   # Public: Move current window to the center of the screen.
   center: ->
-    ipc.sendChannel('call-window-method', 'center')
+    ipc.send('call-window-method', 'center')
 
   # Schedule the window to be shown and focused on the next tick.
   #
@@ -431,7 +456,7 @@ class Atom extends Model
   exit: (status) ->
     app = remote.require('app')
     app.emit('will-exit')
-    app.exit(status)
+    remote.process.exit(status)
 
   # Public: Is the current window in development mode?
   inDevMode: ->
@@ -447,13 +472,16 @@ class Atom extends Model
 
   # Public: Set the full screen state of the current window.
   setFullScreen: (fullScreen=false) ->
-    ipc.sendChannel('call-window-method', 'setFullScreen', fullScreen)
+    ipc.send('call-window-method', 'setFullScreen', fullScreen)
+    if fullScreen then document.body.classList.add("fullscreen") else document.body.classList.remove("fullscreen")
 
   # Public: Is the current window in full screen mode?
   isFullScreen: ->
     @getCurrentWindow().isFullScreen()
 
   # Public: Get the version of the Atom application.
+  #
+  # Returns the version text {String}.
   getVersion: ->
     @constructor.getVersion()
 
@@ -461,20 +489,9 @@ class Atom extends Model
   isReleasedVersion: ->
     @constructor.isReleasedVersion()
 
-  getGitHubAuthTokenName: ->
-    'Atom GitHub API Token'
-
-  # Public: Set the the github token in the keychain
-  setGitHubAuthToken: (token) ->
-    keytar.replacePassword(@getGitHubAuthTokenName(), 'github', token)
-
-  # Public: Get the github token from the keychain
-  getGitHubAuthToken: ->
-    keytar.getPassword(@getGitHubAuthTokenName(), 'github')
-
   # Public: Get the directory path to Atom's configuration area.
   #
-  # Returns the absolute path to ~/.atom
+  # Returns the absolute path to `~/.atom`.
   getConfigDirPath: ->
     @constructor.getConfigDirPath()
 

src/browser/application-menu.coffee

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

src/browser/atom-application.coffee

@@ -1,9 +1,9 @@
 AtomWindow = require './atom-window'
 ApplicationMenu = require './application-menu'
 AtomProtocolHandler = require './atom-protocol-handler'
+AutoUpdateManager = require './auto-update-manager'
 BrowserWindow = require 'browser-window'
 Menu = require 'menu'
-autoUpdater = require 'auto-updater'
 app = require 'app'
 dialog = require 'dialog'
 fs = require 'fs'
@@ -59,33 +59,33 @@ class AtomApplication
   exit: (status) -> app.exit(status)
 
   constructor: (options) ->
-    {@resourcePath, @version, @devMode} = options
+    {@resourcePath, @version, @devMode, @safeMode} = options
     global.atomApplication = this
 
     @pidsToOpenWindows = {}
     @pathsToOpen ?= []
     @windows = []
 
+    @autoUpdateManager = new AutoUpdateManager(@version)
     @applicationMenu = new ApplicationMenu(@version)
     @atomProtocolHandler = new AtomProtocolHandler(@resourcePath)
 
     @listenForArgumentsFromNewProcess()
     @setupJavaScriptArguments()
     @handleEvents()
-    @setupAutoUpdater()
 
     @openWithOptions(options)
 
   # Opens a new window based on the options provided.
-  openWithOptions: ({pathsToOpen, urlsToOpen, test, pidToKillWhenClosed, devMode, newWindow, specDirectory, logFile}) ->
+  openWithOptions: ({pathsToOpen, urlsToOpen, test, pidToKillWhenClosed, devMode, safeMode, newWindow, specDirectory, logFile}) ->
     if test
       @runSpecs({exitWhenDone: true, @resourcePath, specDirectory, logFile})
     else if pathsToOpen.length > 0
-      @openPaths({pathsToOpen, pidToKillWhenClosed, newWindow, devMode})
+      @openPaths({pathsToOpen, pidToKillWhenClosed, newWindow, devMode, safeMode})
     else if urlsToOpen.length > 0
-      @openUrl({urlToOpen, devMode}) for urlToOpen in urlsToOpen
+      @openUrl({urlToOpen, devMode, safeMode}) for urlToOpen in urlsToOpen
     else
-      @openPath({pidToKillWhenClosed, newWindow, devMode}) # Always open a editor window if this is the first instance of Atom.
+      @openPath({pidToKillWhenClosed, newWindow, devMode, safeMode}) # Always open a editor window if this is the first instance of Atom.
 
   # Public: Removes the {AtomWindow} from the global window list.
   removeWindow: (window) ->
@@ -96,6 +96,8 @@ class AtomApplication
   addWindow: (window) ->
     @windows.push window
     @applicationMenu?.enableWindowSpecificItems(true)
+    window.once 'window:loaded', =>
+      @autoUpdateManager.emitUpdateAvailableEvent(window)
 
   # Creates server to listen for additional atom application launches.
   #
@@ -125,68 +127,40 @@ class AtomApplication
 
   # Configures required javascript environment flags.
   setupJavaScriptArguments: ->
-    app.commandLine.appendSwitch 'js-flags', '--harmony_collections --harmony-proxies'
-
-  # Enable updates unless running from a local build of Atom.
-  setupAutoUpdater: ->
-    return if /\w{7}/.test(@version) # Only released versions should check for updates.
-
-    autoUpdater.setFeedUrl "https://atom.io/api/updates?version=#{@version}"
-
-    autoUpdater.on 'checking-for-update', =>
-      @applicationMenu.showDownloadingUpdateItem(false)
-      @applicationMenu.showInstallUpdateItem(false)
-      @applicationMenu.showCheckForUpdateItem(false)
-
-    autoUpdater.on 'update-not-available', =>
-      @applicationMenu.showCheckForUpdateItem(true)
-
-    autoUpdater.on 'update-available', =>
-      @applicationMenu.showDownloadingUpdateItem(true)
-
-    autoUpdater.on 'update-downloaded', (event, releaseNotes, releaseVersion, releaseDate, releaseURL) =>
-      atomWindow.sendCommand('window:update-available', [releaseVersion, releaseNotes]) for atomWindow in @windows
-      @applicationMenu.showInstallUpdateItem(true)
-
-    autoUpdater.on 'error', (event, message) =>
-      @applicationMenu.showCheckForUpdateItem(true)
-
-    # Check for update after Atom has fully started and the menus are created
-    setTimeout((-> autoUpdater.checkForUpdates()), 5000)
-
-  checkForUpdate: ->
-    @onUpdateNotAvailable ?= =>
-      autoUpdater.removeListener 'error', @onUpdateError
-      dialog.showMessageBox type: 'info', buttons: ['OK'], message: 'No update available.', detail: "Version #{@version} is the latest version."
-
-    @onUpdateError ?= (event, message) =>
-      autoUpdater.removeListener 'update-not-available', @onUpdateNotAvailable
-      dialog.showMessageBox type: 'warning', buttons: ['OK'], message: 'There was an error checking for updates.', detail: message
-
-    autoUpdater.once 'update-not-available', @onUpdateNotAvailable
-    autoUpdater.once 'error', @onUpdateError
-    autoUpdater.checkForUpdates()
+    app.commandLine.appendSwitch 'js-flags', '--harmony'
 
   # Registers basic application commands, non-idempotent.
   handleEvents: ->
-    @on 'application:about', -> Menu.sendActionToFirstResponder('orderFrontStandardAboutPanel:')
     @on 'application:run-all-specs', -> @runSpecs(exitWhenDone: false, resourcePath: global.devResourcePath)
     @on 'application:run-benchmarks', -> @runBenchmarks()
     @on 'application:quit', -> app.quit()
-    @on 'application:hide', -> Menu.sendActionToFirstResponder('hide:')
-    @on 'application:hide-other-applications', -> Menu.sendActionToFirstResponder('hideOtherApplications:')
-    @on 'application:unhide-all-applications', -> Menu.sendActionToFirstResponder('unhideAllApplications:')
-    @on 'application:new-window', -> @openPath(initialSize: @getFocusedWindowSize())
+    @on 'application:new-window', -> @openPath(windowDimensions: @focusedWindow()?.getDimensions())
     @on 'application:new-file', -> (@focusedWindow() ? this).openPath()
-    @on 'application:open', -> @promptForPath()
+    @on 'application:open', -> @promptForPath(type: 'all')
+    @on 'application:open-file', -> @promptForPath(type: 'file')
+    @on 'application:open-folder', -> @promptForPath(type: 'folder')
     @on 'application:open-dev', -> @promptForPath(devMode: true)
-    @on 'application:minimize', -> Menu.sendActionToFirstResponder('performMiniaturize:')
-    @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-safe', -> @promptForPath(safeMode: true)
+    @on 'application:inspect', ({x,y, atomWindow}) ->
+      atomWindow ?= @focusedWindow()
+      atomWindow?.browserWindow.inspectElement(x, y)
+
     @on 'application:open-documentation', -> shell.openExternal('https://atom.io/docs/latest/?app')
-    @on 'application:install-update', -> autoUpdater.quitAndInstall()
-    @on 'application:check-for-update', => @checkForUpdate()
+    @on 'application:open-terms-of-use', -> shell.openExternal('https://atom.io/terms')
+    @on 'application:install-update', -> @autoUpdateManager.install()
+    @on 'application:check-for-update', => @autoUpdateManager.check()
+
+    if process.platform is 'darwin'
+      @on 'application:about', -> Menu.sendActionToFirstResponder('orderFrontStandardAboutPanel:')
+      @on 'application:bring-all-windows-to-front', -> Menu.sendActionToFirstResponder('arrangeInFront:')
+      @on 'application:hide', -> Menu.sendActionToFirstResponder('hide:')
+      @on 'application:hide-other-applications', -> Menu.sendActionToFirstResponder('hideOtherApplications:')
+      @on 'application:minimize', -> Menu.sendActionToFirstResponder('performMiniaturize:')
+      @on 'application:unhide-all-applications', -> Menu.sendActionToFirstResponder('unhideAllApplications:')
+      @on 'application:zoom', -> Menu.sendActionToFirstResponder('zoom:')
+    else
+      @on 'application:minimize', -> @focusedWindow()?.minimize()
+      @on 'application:zoom', -> @focusedWindow()?.maximize()
 
     @openPathOnEvent('application:show-settings', 'atom://config')
     @openPathOnEvent('application:open-your-config', 'atom://.atom/config')
@@ -194,6 +168,7 @@ class AtomApplication
     @openPathOnEvent('application:open-your-keymap', 'atom://.atom/keymap')
     @openPathOnEvent('application:open-your-snippets', 'atom://.atom/snippets')
     @openPathOnEvent('application:open-your-stylesheet', 'atom://.atom/stylesheet')
+    @openPathOnEvent('application:open-license', path.join(@resourcePath, 'LICENSE.md'))
 
     app.on 'window-all-closed', ->
       app.quit() if process.platform in ['win32', 'linux']
@@ -212,10 +187,14 @@ class AtomApplication
 
     app.on 'open-url', (event, urlToOpen) =>
       event.preventDefault()
-      @openUrl({urlToOpen, @devMode})
+      @openUrl({urlToOpen, @devMode, @safeMode})
+
+    app.on 'activate-with-no-open-windows', (event) =>
+      event.preventDefault()
+      @emit('application:new-window')
 
     # A request from the associated render process to open a new render process.
-    ipc.on 'open', (processId, routingId, options) =>
+    ipc.on 'open', (event, options) =>
       if options?
         if options.pathsToOpen?.length > 0
           @openPaths(options)
@@ -224,31 +203,29 @@ class AtomApplication
       else
         @promptForPath()
 
-    ipc.on 'update-application-menu', (processId, routingId, template, keystrokesByCommand) =>
+    ipc.on 'update-application-menu', (event, template, keystrokesByCommand) =>
       @applicationMenu.update(template, keystrokesByCommand)
 
-    ipc.on 'run-package-specs', (processId, routingId, specDirectory) =>
+    ipc.on 'run-package-specs', (event, specDirectory) =>
       @runSpecs({resourcePath: global.devResourcePath, specDirectory: specDirectory, exitWhenDone: false})
 
-    ipc.on 'command', (processId, routingId, command) =>
+    ipc.on 'command', (event, command) =>
       @emit(command)
 
-    ipc.on 'window-command', (processId, routingId, command, args...) ->
-      win = BrowserWindow.fromProcessIdAndRoutingId(processId, routingId)
+    ipc.on 'window-command', (event, command, args...) ->
+      win = BrowserWindow.fromWebContents(event.sender)
       win.emit(command, args...)
 
-    ipc.on 'call-window-method', (processId, routingId, method, args...) ->
-      win = BrowserWindow.fromProcessIdAndRoutingId(processId, routingId)
+    ipc.on 'call-window-method', (event, method, args...) ->
+      win = BrowserWindow.fromWebContents(event.sender)
       win[method](args...)
 
   # Public: Executes the given command.
   #
   # If it isn't handled globally, delegate to the currently focused window.
   #
-  # * command:
-  #   The string representing the command.
-  # * args:
-  #   The optional arguments to pass along.
+  # command - The string representing the command.
+  # args - The optional arguments to pass along.
   sendCommand: (command, args...) ->
     unless @emit(command, args...)
       focusedWindow = @focusedWindow()
@@ -257,6 +234,18 @@ class AtomApplication
       else
         @sendCommandToFirstResponder(command)
 
+  # Public: Executes the given command on the given window.
+  #
+  # command - The string representing the command.
+  # atomWindow - The {AtomWindow} to send the command to.
+  # args - The optional arguments to pass along.
+  sendCommandToWindow: (command, atomWindow, args...) ->
+    unless @emit(command, args...)
+      if atomWindow?
+        atomWindow.sendCommand(command, args...)
+      else
+        @sendCommandToFirstResponder(command)
+
   # Translates the command into OS X action and sends it to application's first
   # responder.
   sendCommandToFirstResponder: (command) ->
@@ -277,8 +266,8 @@ class AtomApplication
   #
   # A new window will be created if there is no currently focused window.
   #
-  # * eventName: The event to listen for.
-  # * pathToOpen: The path to open when the event is triggered.
+  # eventName - The event to listen for.
+  # pathToOpen - The path to open when the event is triggered.
   openPathOnEvent: (eventName, pathToOpen) ->
     @on eventName, ->
       if window = @focusedWindow()
@@ -295,56 +284,36 @@ class AtomApplication
   focusedWindow: ->
     _.find @windows, (atomWindow) -> atomWindow.isFocused()
 
-  # Public: Get the height and width of the focused window.
-  #
-  # Returns an object with height and width keys or null if there is no
-  # focused window.
-  getFocusedWindowSize: ->
-    if focusedWindow = @focusedWindow()
-      [width, height] = focusedWindow.getSize()
-      {width, height}
-    else
-      null
-
   # Public: Opens multiple paths, in existing windows if possible.
   #
-  # * options
-  #    + pathsToOpen:
-  #      The array of file paths to open
-  #    + pidToKillWhenClosed:
-  #      The integer of the pid to kill
-  #    + newWindow:
-  #      Boolean of whether this should be opened in a new window.
-  #    + devMode:
-  #      Boolean to control the opened window's dev mode.
-  openPaths: ({pathsToOpen, pidToKillWhenClosed, newWindow, devMode}) ->
-    @openPath({pathToOpen, pidToKillWhenClosed, newWindow, devMode}) for pathToOpen in pathsToOpen ? []
+  # options -
+  #   :pathsToOpen - The array of file paths to open
+  #   :pidToKillWhenClosed - The integer of the pid to kill
+  #   :newWindow - Boolean of whether this should be opened in a new window.
+  #   :devMode - Boolean to control the opened window's dev mode.
+  #   :safeMode - Boolean to control the opened window's safe mode.
+  openPaths: ({pathsToOpen, pidToKillWhenClosed, newWindow, devMode, safeMode}) ->
+    for pathToOpen in pathsToOpen ? []
+      @openPath({pathToOpen, pidToKillWhenClosed, newWindow, devMode, safeMode})
 
   # Public: Opens a single path, in an existing window if possible.
   #
-  # * options
-  #    + pathToOpen:
-  #      The file path to open
-  #    + pidToKillWhenClosed:
-  #      The integer of the pid to kill
-  #    + newWindow:
-  #      Boolean of whether this should be opened in a new window.
-  #    + devMode:
-  #      Boolean to control the opened window's dev mode.
-  #    + initialSize:
-  #      Object with height and width keys.
-  openPath: ({pathToOpen, pidToKillWhenClosed, newWindow, devMode, initialSize}={}) ->
-    if pathToOpen
-      [basename, initialLine] = path.basename(pathToOpen).split(':')
-      if initialLine
-        pathToOpen = "#{path.dirname(pathToOpen)}/#{basename}"
-        initialLine -= 1 # Convert line numbers to a base of 0
+  # options -
+  #   :pathToOpen - The file path to open
+  #   :pidToKillWhenClosed - The integer of the pid to kill
+  #   :newWindow - Boolean of whether this should be opened in a new window.
+  #   :devMode - Boolean to control the opened window's dev mode.
+  #   :safeMode - Boolean to control the opened window's safe mode.
+  #   :windowDimensions - Object with height and width keys.
+  openPath: ({pathToOpen, pidToKillWhenClosed, newWindow, devMode, safeMode, windowDimensions}={}) ->
+    {pathToOpen, initialLine, initialColumn} = @locationForPathToOpen(pathToOpen)
 
     unless devMode
       existingWindow = @windowForPath(pathToOpen) unless pidToKillWhenClosed or newWindow
     if existingWindow
       openedWindow = existingWindow
       openedWindow.openPath(pathToOpen, initialLine)
+      openedWindow.restore()
     else
       if devMode
         try
@@ -353,12 +322,12 @@ class AtomApplication
 
       bootstrapScript ?= require.resolve('../window-bootstrap')
       resourcePath ?= @resourcePath
-      openedWindow = new AtomWindow({pathToOpen, initialLine, bootstrapScript, resourcePath, devMode, initialSize})
+      openedWindow = new AtomWindow({pathToOpen, initialLine, initialColumn, bootstrapScript, resourcePath, devMode, safeMode, windowDimensions})
 
     if pidToKillWhenClosed?
       @pidsToOpenWindows[pidToKillWhenClosed] = openedWindow
 
-    openedWindow.browserWindow.on 'destroyed', =>
+    openedWindow.browserWindow.on 'closed', =>
       @killProcessForWindow(openedWindow)
 
   # Kill all processes associated with opened windows.
@@ -385,12 +354,11 @@ class AtomApplication
   # responsible for opening the URL.  A new window will be created with
   # that package's `urlMain` as the bootstrap script.
   #
-  # * options
-  #    + urlToOpen:
-  #      The atom:// url to open.
-  #    + devMode:
-  #      Boolean to control the opened window's dev mode.
-  openUrl: ({urlToOpen, devMode}) ->
+  # options -
+  #   :urlToOpen - The atom:// url to open.
+  #   :devMode - Boolean to control the opened window's dev mode.
+  #   :safeMode - Boolean to control the opened window's safe mode.
+  openUrl: ({urlToOpen, devMode, safeMode}) ->
     unless @packages?
       PackageManager = require '../package-manager'
       fs = require 'fs-plus'
@@ -405,7 +373,8 @@ class AtomApplication
       if pack.urlMain
         packagePath = @packages.resolvePackagePath(packageName)
         bootstrapScript = path.resolve(packagePath, pack.urlMain)
-        new AtomWindow({bootstrapScript, @resourcePath, devMode, urlToOpen, initialSize: @getFocusedWindowSize()})
+        windowDimensions = @focusedWindow()?.getDimensions()
+        new AtomWindow({bootstrapScript, @resourcePath, devMode, safeMode, urlToOpen, windowDimensions})
       else
         console.log "Package '#{pack.name}' does not have a url main: #{urlToOpen}"
     else
@@ -413,13 +382,11 @@ class AtomApplication
 
   # Opens up a new {AtomWindow} to run specs within.
   #
-  # * options
-  #    + exitWhenDone:
-  #      A Boolean that if true, will close the window upon completion.
-  #    + resourcePath:
-  #      The path to include specs from.
-  #    + specPath:
-  #      The directory to load specs from.
+  # options -
+  #   :exitWhenDone - A Boolean that if true, will close the window upon
+  #                   completion.
+  #   :resourcePath - The path to include specs from.
+  #   :specPath - The directory to load specs from.
   runSpecs: ({exitWhenDone, resourcePath, specDirectory, logFile}) ->
     if resourcePath isnt @resourcePath and not fs.existsSync(resourcePath)
       resourcePath = @resourcePath
@@ -442,14 +409,38 @@ class AtomApplication
     isSpec = true
     new AtomWindow({bootstrapScript, @resourcePath, isSpec})
 
+  locationForPathToOpen: (pathToOpen) ->
+    return {pathToOpen} unless pathToOpen
+    return {pathToOpen} if fs.existsSync(pathToOpen)
+
+    [fileToOpen, initialLine, initialColumn] = path.basename(pathToOpen).split(':')
+    return {pathToOpen} unless initialLine
+    return {pathToOpen} unless parseInt(initialLine) > 0
+
+    # Convert line numbers to a base of 0
+    initialLine -= 1 if initialLine
+    initialColumn -= 1 if initialColumn
+    pathToOpen = path.join(path.dirname(pathToOpen), fileToOpen)
+    {pathToOpen, initialLine, initialColumn}
+
   # Opens a native dialog to prompt the user for a path.
   #
   # Once paths are selected, they're opened in a new or existing {AtomWindow}s.
   #
-  # * options
-  #    + devMode:
-  #      A Boolean which controls whether any newly opened windows should  be in
-  #      dev mode or not.
-  promptForPath: ({devMode}={}) ->
-    dialog.showOpenDialog title: 'Open', properties: ['openFile', 'openDirectory', 'multiSelections', 'createDirectory'], (pathsToOpen) =>
-      @openPaths({pathsToOpen, devMode})
+  # options -
+  #   :type - A String which specifies the type of the dialog, could be 'file',
+  #           'folder' or 'all'. The 'all' is only available on OS X.
+  #   :devMode - A Boolean which controls whether any newly opened windows
+  #              should be in dev mode or not.
+  #   :safeMode - A Boolean which controls whether any newly opened windows
+  #               should be in safe mode or not.
+  promptForPath: ({type, devMode, safeMode}={}) ->
+    type ?= 'all'
+    properties =
+      switch type
+        when 'file' then ['openFile']
+        when 'folder' then ['openDirectory']
+        when 'all' then ['openFile', 'openDirectory']
+        else throw new Error("#{type} is an invalid type for promptForPath")
+    dialog.showOpenDialog title: 'Open', properties: properties.concat(['multiSelections', 'createDirectory']), (pathsToOpen) =>
+      @openPaths({pathsToOpen, devMode, safeMode})

src/browser/atom-window.coffee

@@ -2,14 +2,16 @@ BrowserWindow = require 'browser-window'
 ContextMenu = require './context-menu'
 app = require 'app'
 dialog = require 'dialog'
-ipc = require 'ipc'
 path = require 'path'
 fs = require 'fs'
 url = require 'url'
 _ = require 'underscore-plus'
+{EventEmitter} = require 'events'
 
 module.exports =
 class AtomWindow
+  _.extend @prototype, EventEmitter.prototype
+
   @iconPath: path.resolve(__dirname, '..', '..', 'resources', 'atom.png')
   @includeShellLoadTime: true
 
@@ -18,7 +20,7 @@ class AtomWindow
   isSpec: null
 
   constructor: (settings={}) ->
-    {@resourcePath, pathToOpen, initialLine, @isSpec, @exitWhenDone} = settings
+    {@resourcePath, pathToOpen, initialLine, initialColumn, @isSpec, @exitWhenDone} = settings
     global.atomApplication.addWindow(this)
 
     @browserWindow = new BrowserWindow show: false, title: 'Atom', icon: @constructor.iconPath
@@ -38,11 +40,14 @@ class AtomWindow
       loadSettings.initialPath = path.dirname(pathToOpen)
 
     @browserWindow.loadSettings = loadSettings
-    @browserWindow.once 'window:loaded', => @loaded = true
+    @browserWindow.once 'window:loaded', =>
+      @emit 'window:loaded'
+      @loaded = true
+
     @browserWindow.loadUrl @getUrl(loadSettings)
     @browserWindow.focusOnWebView() if @isSpec
 
-    @openPath(pathToOpen, initialLine)
+    @openPath(pathToOpen, initialLine, initialColumn)
 
   getUrl: (loadSettingsObj) ->
     # Ignore the windowState when passing loadSettings via URL, since it could
@@ -75,7 +80,7 @@ class AtomWindow
       false
 
   handleEvents: ->
-    @browserWindow.on 'destroyed', =>
+    @browserWindow.on 'closed', =>
       global.atomApplication.removeWindow(this)
 
     @browserWindow.on 'unresponsive', =>
@@ -88,7 +93,7 @@ class AtomWindow
         detail: 'The editor is not responding. Would you like to force close it or just keep waiting?'
       @browserWindow.destroy() if chosen is 0
 
-    @browserWindow.on 'crashed', =>
+    @browserWindow.webContents.on 'crashed', =>
       global.atomApplication.exit(100) if @exitWhenDone
 
       chosen = dialog.showMessageBox @browserWindow,
@@ -101,19 +106,19 @@ class AtomWindow
         when 1 then @browserWindow.restart()
 
     @browserWindow.on 'context-menu', (menuTemplate) =>
-      new ContextMenu(menuTemplate, @browserWindow)
+      new ContextMenu(menuTemplate, this)
 
     if @isSpec
       # Spec window's web view should always have focus
       @browserWindow.on 'blur', =>
         @browserWindow.focusOnWebView()
 
-  openPath: (pathToOpen, initialLine) ->
+  openPath: (pathToOpen, initialLine, initialColumn) ->
     if @loaded
       @focus()
-      @sendCommand('window:open-path', {pathToOpen, initialLine})
+      @sendCommand('window:open-path', {pathToOpen, initialLine, initialColumn})
     else
-      @browserWindow.once 'window:loaded', => @openPath(pathToOpen, initialLine)
+      @browserWindow.once 'window:loaded', => @openPath(pathToOpen, initialLine, initialColumn)
 
   sendCommand: (command, args...) ->
     if @isSpecWindow()
@@ -130,13 +135,22 @@ class AtomWindow
 
   sendCommandToBrowserWindow: (command, args...) ->
     action = if args[0]?.contextCommand then 'context-command' else 'command'
-    ipc.sendChannel @browserWindow.getProcessId(), @browserWindow.getRoutingId(), action, command, args...
+    @browserWindow.webContents.send action, command, args...
+
+  getDimensions: ->
+    [x, y] = @browserWindow.getPosition()
+    [width, height] = @browserWindow.getSize()
+    {x, y, width, height}
 
   close: -> @browserWindow.close()
 
   focus: -> @browserWindow.focus()
 
-  getSize: -> @browserWindow.getSize()
+  minimize: -> @browserWindow.minimize()
+
+  maximize: -> @browserWindow.maximize()
+
+  restore: -> @browserWindow.restore()
 
   handlesAtomCommands: ->
     not @isSpecWindow() and @isWebViewFocused()

src/browser/auto-update-manager.coffee

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

src/browser/context-menu.coffee

@@ -2,10 +2,10 @@ Menu = require 'menu'
 
 module.exports =
 class ContextMenu
-  constructor: (template, browserWindow) ->
+  constructor: (template, @atomWindow) ->
     template = @createClickHandlers(template)
     menu = Menu.buildFromTemplate(template)
-    menu.popup(browserWindow)
+    menu.popup(@atomWindow.browserWindow)
 
   # It's necessary to build the event handlers in this process, otherwise
   # closures are drug across processes and failed to be garbage collected
@@ -13,7 +13,10 @@ class ContextMenu
   createClickHandlers: (template) ->
     for item in template
       if item.command
-        (item.commandOptions ?= {}).contextCommand = true
-        item.click = do (item) ->
-          => global.atomApplication.sendCommand(item.command, item.commandOptions)
+        item.commandOptions ?= {}
+        item.commandOptions.contextCommand = true
+        item.commandOptions.atomWindow = @atomWindow
+        do (item) =>
+          item.click = =>
+            global.atomApplication.sendCommandToWindow(item.command, @atomWindow, item.commandOptions)
       item

src/browser/main.coffee

@@ -42,7 +42,7 @@ start = ->
     app.removeListener 'open-url', addUrlToOpen
 
     args.pathsToOpen = args.pathsToOpen.map (pathToOpen) ->
-      path.resolve(args.executedFrom ? process.cwd(), pathToOpen)
+      path.resolve(args.executedFrom ? process.cwd(), pathToOpen.toString())
 
     require('coffee-script').register()
     if args.devMode
@@ -73,6 +73,7 @@ parseCommandLine = ->
   options.alias('l', 'log-file').string('l').describe('l', 'Log all output to file.')
   options.alias('n', 'new-window').boolean('n').describe('n', 'Open a new window.')
   options.alias('s', 'spec-directory').string('s').describe('s', 'Set the spec directory (default: Atom\'s spec directory).')
+  options.boolean('safe').describe('safe', 'Do not load packages from ~/.atom/packages or ~/.atom/dev/packages.')
   options.alias('t', 'test').boolean('t').describe('t', 'Run the specified specs and exit with error code on failures.')
   options.alias('v', 'version').boolean('v').describe('v', 'Print the version.')
   options.alias('w', 'wait').boolean('w').describe('w', 'Wait for window to be closed before returning.')
@@ -88,6 +89,7 @@ parseCommandLine = ->
 
   executedFrom = args['executed-from']
   devMode = args['dev']
+  safeMode = args['safe']
   pathsToOpen = args._
   pathsToOpen = [executedFrom] if executedFrom and pathsToOpen.length is 0
   test = args['test']
@@ -107,6 +109,6 @@ parseCommandLine = ->
   catch
     resourcePath = path.dirname(path.dirname(__dirname))
 
-  {resourcePath, pathsToOpen, executedFrom, test, version, pidToKillWhenClosed, devMode, newWindow, specDirectory, logFile}
+  {resourcePath, pathsToOpen, executedFrom, test, version, pidToKillWhenClosed, devMode, safeMode, newWindow, specDirectory, logFile}
 
 start()

src/buffered-process.coffee

@@ -12,7 +12,7 @@ ChildProcess = require 'child_process'
 # args = ['-ef']
 # stdout = (output) -> console.log(output)
 # exit = (code) -> console.log("ps -ef exited with #{code}")
-# process = new BufferredProcess({command, args, stdout, exit})
+# process = new BufferedProcess({command, args, stdout, exit})
 # ```
 module.exports =
 class BufferedProcess
@@ -39,7 +39,14 @@ class BufferedProcess
   #           containing the exit status (optional).
   constructor: ({command, args, options, stdout, stderr, exit}={}) ->
     options ?= {}
-    @process = ChildProcess.spawn(command, args, options)
+    # Quick hack. Killing @process will only kill cmd.exe, and not the child
+    # process and will just orphan it. Does not escape ^ (cmd's escape symbol).
+    # Related to joyent/node#2318
+    if process.platform is "win32"
+      @process = ChildProcess.spawn(process.env.comspec || "cmd.exe",
+        [ "/c", command ].concat(args), options)
+    else
+      @process = ChildProcess.spawn(command, args, options)
     @killed = false
 
     stdoutClosed = true

src/coffee-cache.coffee

@@ -1,33 +1,29 @@
 crypto = require 'crypto'
-fs = require 'fs'
 path = require 'path'
-os = require 'os'
 
 CoffeeScript = require 'coffee-script'
 CSON = require 'season'
-mkdir = require('mkdirp').sync
+fs = require 'fs-plus'
 
-tmpDir = if process.platform is 'win32' then os.tmpdir() else '/tmp'
-cacheDir = path.join(tmpDir, 'atom-compile-cache')
+cacheDir = path.join(fs.absolute('~/.atom'), 'compile-cache')
 coffeeCacheDir = path.join(cacheDir, 'coffee')
 CSON.setCacheDir(path.join(cacheDir, 'cson'))
 
 getCachePath = (coffee) ->
   digest = crypto.createHash('sha1').update(coffee, 'utf8').digest('hex')
-  path.join(coffeeCacheDir, "#{digest}.coffee")
+  path.join(coffeeCacheDir, "#{digest}.js")
 
 getCachedJavaScript = (cachePath) ->
-  if stat = fs.statSyncNoException(cachePath)
+  if fs.isFileSync(cachePath)
     try
-      fs.readFileSync(cachePath, 'utf8') if stat.isFile()
+      fs.readFileSync(cachePath, 'utf8')
 
 compileCoffeeScript = (coffee, filePath, cachePath) ->
-  {js,v3SourceMap} = CoffeeScript.compile(coffee, filename: filePath, sourceMap: true)
+  {js, v3SourceMap} = CoffeeScript.compile(coffee, filename: filePath, sourceMap: true)
   # Include source map in the web page environment.
   if btoa? and JSON? and unescape? and encodeURIComponent?
     js = "#{js}\n//# sourceMappingURL=data:application/json;base64,#{btoa unescape encodeURIComponent v3SourceMap}\n//# sourceURL=#{filePath}"
   try
-    mkdir(path.dirname(cachePath))
     fs.writeFileSync(cachePath, js)
   js
 

src/config.coffee

@@ -18,9 +18,9 @@ pathWatcher = require 'pathwatcher'
 # ## Example
 #
 # ```coffeescript
-# atom.config.set('myplugin.key', 'value')
-# atom.config.observe 'myplugin.key', ->
-#   console.log 'My configuration changed:', atom.config.get('myplugin.key')
+# atom.config.set('my-package.key', 'value')
+# atom.config.observe 'my-package.key', ->
+#   console.log 'My configuration changed:', atom.config.get('my-package.key')
 # ```
 module.exports =
 class Config
@@ -86,9 +86,9 @@ class Config
       hash = hash[key]
 
     _.extend hash, defaults
-    @update()
+    @emit 'updated'
 
-  # Public: Get the path to the config file being used.
+  # Public: Get the {String} path to the config file being used.
   getUserConfigPath: ->
     @configFilePath
 
@@ -98,10 +98,10 @@ class Config
 
   # Public: Retrieves the setting for the given key.
   #
-  # keyPath - The {String} name of the key to retrieve
+  # keyPath - The {String} name of the key to retrieve.
   #
-  # Returns the value from Atom's default settings, the user's configuration file,
-  # or `null` if the key doesn't exist in either.
+  # Returns the value from Atom's default settings, the user's configuration
+  # file, or `null` if the key doesn't exist in either.
   get: (keyPath) ->
     value = _.valueForKeyPath(@settings, keyPath) ? _.valueForKeyPath(@defaultSettings, keyPath)
     _.deepClone(value)
@@ -110,8 +110,8 @@ class Config
   #
   # keyPath - The {String} name of the key to retrieve
   #
-  # Returns the value from Atom's default settings, the user's configuration file,
-  # or `NaN` if the key doesn't exist in either.
+  # Returns the value from Atom's default settings, the user's configuration
+  # file, or `NaN` if the key doesn't exist in either.
   getInt: (keyPath) ->
     parseInt(@get(keyPath))
 
@@ -121,8 +121,8 @@ class Config
   # defaultValue - The integer {Number} to fall back to if the value isn't
   #                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.
+  # 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=0) ->
     Math.max(@getInt(keyPath), 0) or defaultValue
 
@@ -130,13 +130,14 @@ class Config
   #
   # This value is stored in Atom's internal configuration file.
   #
-  # keyPath - The {String} name of the key
-  # value - The value of the setting
+  # keyPath - The {String} name of the key.
+  # value - The value of the setting.
   #
   # Returns the `value`.
   set: (keyPath, value) ->
-    if @get(keyPath) != value
-      value = undefined if _.valueForKeyPath(@defaultSettings, keyPath) == value
+    if @get(keyPath) isnt value
+      defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
+      value = undefined if _.isEqual(defaultValue, value)
       _.setValueForKeyPath(@settings, keyPath, value)
       @update()
     value
@@ -146,6 +147,8 @@ class Config
   # The new value will be `true` if the value is currently falsy and will be
   # `false` if the value is currently truthy.
   #
+  # keyPath - The {String} name of the key.
+  #
   # Returns the new value.
   toggle: (keyPath) ->
     @set(keyPath, !@get(keyPath))
@@ -158,12 +161,30 @@ class Config
   restoreDefault: (keyPath) ->
     @set(keyPath, _.valueForKeyPath(@defaultSettings, keyPath))
 
+  # Public: Get the default value of the key path.
+  #
+  # keyPath - The {String} name of the key.
+  #
+  # Returns the default value.
+  getDefault: (keyPath) ->
+    defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
+    _.deepClone(defaultValue)
+
+  # Public: Is the key path value its default value?
+  #
+  # keyPath - The {String} name of the key.
+  #
+  # Returns a {Boolean}, `true` if the current value is the default, `false`
+  # otherwise.
+  isDefault: (keyPath) ->
+    not _.valueForKeyPath(@settings, keyPath)?
+
   # Public: Push the value to the array at the key path.
   #
   # keyPath - The {String} key path.
   # value - The value to push to the array.
   #
-  # Returns the new array length of the setting.
+  # Returns the new array length {Number} of the setting.
   pushAtKeyPath: (keyPath, value) ->
     arrayValue = @get(keyPath) ? []
     result = arrayValue.push(value)
@@ -175,7 +196,7 @@ class Config
   # keyPath - The {String} key path.
   # value - The value to shift onto the array.
   #
-  # Returns the new array length of the setting.
+  # Returns the new array length {Number} of the setting.
   unshiftAtKeyPath: (keyPath, value) ->
     arrayValue = @get(keyPath) ? []
     result = arrayValue.unshift(value)
@@ -201,11 +222,13 @@ class Config
   #
   # keyPath - The {String} name of the key to observe
   # options - An optional {Object} containing the `callNow` key.
-  # callback - The {Function} that fires when the. It is given a single argument, `value`,
-  #            which is the new value of `keyPath`.
+  # callback - The {Function} to call when the value of the key changes.
+  #            The first argument will be the new value of the key and the
+  #            second argument will be an {Object} with a `previous` property
+  #            that is the prior value of the key.
   #
   # Returns an {Object} with the following keys:
-  #  :off - A {Function} that unobserves the `keyPath` with called.
+  #  :off - A {Function} that unobserves the `keyPath` when called.
   observe: (keyPath, options={}, callback) ->
     if _.isFunction(options)
       callback = options
@@ -225,9 +248,9 @@ class Config
     callback(value) if options.callNow ? true
     subscription
 
-  # Public: Unobserve all callbacks on a given key
+  # Public: Unobserve all callbacks on a given key.
   #
-  # keyPath - The {String} name of the key to unobserve
+  # keyPath - The {String} name of the key to unobserve.
   unobserve: (keyPath) ->
     @off("updated.#{keyPath.replace(/\./, '-')}")
 

src/context-menu-manager.coffee

@@ -18,7 +18,7 @@ class ContextMenuManager
       label: 'Inspect Element'
       command: 'application:inspect'
       executeAtBuild: (e) ->
-        @.commandOptions = x: e.pageX, y: e.pageY
+        @commandOptions = x: e.pageX, y: e.pageY
     ]
 
   # Public: Creates menu definitions from the object specified by the menu
@@ -98,5 +98,6 @@ class ContextMenuManager
   showForEvent: (event) ->
     @activeElement = event.target
     menuTemplate = @combinedMenuTemplateForElement(event.target)
+    return unless menuTemplate?.length > 0
     @executeBuildHandlers(event, menuTemplate)
     remote.getCurrentWindow().emit('context-menu', menuTemplate)

src/cursor-component.coffee

@@ -0,0 +1,15 @@
+React = require 'react-atom-fork'
+{div} = require 'reactionary-atom-fork'
+
+module.exports =
+CursorComponent = React.createClass
+  displayName: 'CursorComponent'
+
+  render: ->
+    {cursor, scrollTop, scrollLeft} = @props
+    {top, left, height, width} = cursor.getPixelRect()
+    top -= scrollTop
+    left -= scrollLeft
+    WebkitTransform = "translate3d(#{left}px, #{top}px, 0px)"
+
+    div className: 'cursor', style: {height, width, WebkitTransform}

src/cursor-view.coffee

@@ -78,7 +78,11 @@ class CursorView extends View
   setVisible: (visible) ->
     unless @visible is visible
       @visible = visible
-      @toggle(@visible)
+      hiddenCursor = 'hidden-cursor'
+      if visible
+        @removeClass hiddenCursor
+      else
+        @addClass hiddenCursor
 
   stopBlinking: ->
     @constructor.stopBlinking(this) if @blinking

src/cursor.coffee

@@ -1,5 +1,5 @@
 {Point, Range} = require 'text-buffer'
-{Emitter} = require 'emissary'
+{Model} = require 'theorist'
 _ = require 'underscore-plus'
 
 # Public: The `Cursor` class represents the little blinking line identifying
@@ -8,9 +8,7 @@ _ = require 'underscore-plus'
 # Cursors belong to {Editor}s and have some metadata attached in the form
 # of a {Marker}.
 module.exports =
-class Cursor
-  Emitter.includeInto(this)
-
+class Cursor extends Model
   screenPosition: null
   bufferPosition: null
   goalColumn: null
@@ -18,7 +16,8 @@ class Cursor
   needsAutoscroll: null
 
   # Instantiated by an {Editor}
-  constructor: ({@editor, @marker}) ->
+  constructor: ({@editor, @marker, id}) ->
+    @assignId(id)
     @updateVisibility()
     @marker.on 'changed', (e) =>
       @updateVisibility()
@@ -27,7 +26,12 @@ class Cursor
       {textChanged} = e
       return if oldHeadScreenPosition.isEqual(newHeadScreenPosition)
 
+      # Supports old editor view
       @needsAutoscroll ?= @isLastCursor() and !textChanged
+
+      # Supports react editor view
+      @autoscroll() if @needsAutoscroll and @editor.manageScrollPosition
+
       @goalColumn = null
 
       movedEvent =
@@ -38,7 +42,7 @@ class Cursor
         textChanged: textChanged
 
       @emit 'moved', movedEvent
-      @editor.emit 'cursor-moved', movedEvent
+      @editor.cursorMoved(movedEvent)
     @marker.on 'destroyed', =>
       @destroyed = true
       @editor.removeCursor(this)
@@ -54,6 +58,9 @@ class Cursor
     unless fn()
       @emit 'autoscrolled' if @needsAutoscroll
 
+  getPixelRect: ->
+    @editor.pixelRectForScreenRange(@getScreenRange())
+
   # Public: Moves a cursor to a given screen position.
   #
   # screenPosition - An {Array} of two numbers: the screen row, and the screen
@@ -69,6 +76,10 @@ class Cursor
   getScreenPosition: ->
     @marker.getHeadScreenPosition()
 
+  getScreenRange: ->
+    {row, column} = @getScreenPosition()
+    new Range(new Point(row, column), new Point(row, column + 1))
+
   # Public: Moves a cursor to a given buffer position.
   #
   # bufferPosition - An {Array} of two numbers: the buffer row, and the buffer
@@ -84,6 +95,9 @@ class Cursor
   getBufferPosition: ->
     @marker.getHeadBufferPosition()
 
+  autoscroll: ->
+    @editor.scrollToScreenRange(@getScreenRange())
+
   # Public: If the marker range is empty, the cursor is marked as being visible.
   updateVisibility: ->
     @setVisible(@marker.getBufferRange().isEmpty())
@@ -124,13 +138,13 @@ class Cursor
 
   # Public: Identifies if the cursor is surrounded by whitespace.
   #
-  # "Surrounded" here means that all characters before and after the cursor is
-  # whitespace.
+  # "Surrounded" here means that the character directly before and after the
+  # cursor are both whitespace.
   #
   # Returns a {Boolean}.
   isSurroundedByWhitespace: ->
     {row, column} = @getBufferPosition()
-    range = [[row, Math.min(0, column - 1)], [row, Math.max(0, column + 1)]]
+    range = [[row, column - 1], [row, column + 1]]
     /^\s+$/.test @editor.getTextInBufferRange(range)
 
   # Public: Returns whether the cursor is currently between a word and non-word
@@ -315,12 +329,14 @@ class Cursor
   #   :includeNonWordCharacters - A {Boolean} indicating whether to include
   #                               non-word characters in the default word regex.
   #                               Has no effect if wordRegex is set.
+  #   :allowPrevious - A {Boolean} indicating whether the beginning of the
+  #                    previous word can be returned.
   #
   # Returns a {Range}.
   getBeginningOfCurrentWordBufferPosition: (options = {}) ->
     allowPrevious = options.allowPrevious ? true
     currentBufferPosition = @getBufferPosition()
-    previousNonBlankRow = @editor.buffer.previousNonBlankRow(currentBufferPosition.row)
+    previousNonBlankRow = @editor.buffer.previousNonBlankRow(currentBufferPosition.row) ? 0
     scanRange = [[previousNonBlankRow, 0], currentBufferPosition]
 
     beginningOfWordPosition = null
@@ -330,7 +346,12 @@ class Cursor
       if not beginningOfWordPosition?.isEqual(currentBufferPosition)
         stop()
 
-    beginningOfWordPosition or currentBufferPosition
+    if beginningOfWordPosition?
+      beginningOfWordPosition
+    else if allowPrevious
+      new Point(0, 0)
+    else
+      currentBufferPosition
 
   # Public: Retrieves buffer position of previous word boundary. It might be on
   # the current word, or the previous word.
@@ -436,6 +457,43 @@ class Cursor
   getCurrentLineBufferRange: (options) ->
     @editor.bufferRangeForBufferRow(@getBufferRow(), options)
 
+  # Public: Moves the cursor to the beginning of the next paragraph
+  moveToBeginningOfNextParagraph: ->
+    if position = @getBeginningOfNextParagraphBufferPosition()
+      @setBufferPosition(position)
+
+  # Public: Moves the cursor to the beginning of the previous paragraph
+  moveToBeginningOfPreviousParagraph: ->
+    if position = @getBeginningOfPreviousParagraphBufferPosition()
+      @setBufferPosition(position)
+
+  getBeginningOfNextParagraphBufferPosition: (editor) ->
+    start = @getBufferPosition()
+    eof = @editor.getEofBufferPosition()
+    scanRange = [start, eof]
+
+    {row, column} = eof
+    position = new Point(row, column - 1)
+
+    @editor.scanInBufferRange /^\n*$/g, scanRange, ({range, stop}) =>
+      if !range.start.isEqual(start)
+        position = range.start
+        stop()
+    @editor.screenPositionForBufferPosition(position)
+
+  getBeginningOfPreviousParagraphBufferPosition: (editor) ->
+    start = @editor.getCursorBufferPosition()
+
+    {row, column} = start
+    scanRange = [[row-1, column], [0,0]]
+    position = new Point(0, 0)
+    zero = new Point(0,0)
+    @editor.backwardsScanInBufferRange /^\n*$/g, scanRange, ({range, stop}) =>
+      if !range.start.isEqual(zero)
+        position = range.start
+        stop()
+    @editor.screenPositionForBufferPosition(position)
+
   # Public: Retrieves the range for the current paragraph.
   #
   # A paragraph is defined as a block of text surrounded by empty lines.
@@ -444,7 +502,7 @@ class Cursor
   getCurrentParagraphBufferRange: ->
     @editor.languageMode.rowRangeForParagraphAtBufferRow(@getBufferRow())
 
-  # Public: Returns the characters preceeding the cursor in the current word.
+  # Public: Returns the characters preceding the cursor in the current word.
   getCurrentWordPrefix: ->
     @editor.getTextInBufferRange([@getBeginningOfCurrentWordBufferPosition(), @getBufferPosition()])
 

src/cursors-component.coffee

@@ -0,0 +1,55 @@
+React = require 'react-atom-fork'
+{div} = require 'reactionary-atom-fork'
+{debounce, toArray} = require 'underscore-plus'
+SubscriberMixin = require './subscriber-mixin'
+CursorComponent = require './cursor-component'
+
+module.exports =
+CursorsComponent = React.createClass
+  displayName: 'CursorsComponent'
+  mixins: [SubscriberMixin]
+
+  cursorBlinkIntervalHandle: null
+
+  render: ->
+    {editor, scrollTop, scrollLeft} = @props
+    {blinkOff} = @state
+
+    className = 'cursors'
+    className += ' blink-off' if blinkOff
+
+    div {className},
+      if @isMounted()
+        for selection in editor.getSelections()
+          if selection.isEmpty() and editor.selectionIntersectsVisibleRowRange(selection)
+            {cursor} = selection
+            CursorComponent({key: cursor.id, cursor, scrollTop, scrollLeft})
+
+  getInitialState: ->
+    blinkOff: false
+
+  componentDidMount: ->
+    @startBlinkingCursors()
+
+  componentWillUnmount: ->
+    @stopBlinkingCursors()
+
+  componentWillUpdate: ({cursorsMoved}) ->
+    @pauseCursorBlinking() if cursorsMoved
+
+  startBlinkingCursors: ->
+    @toggleCursorBlinkHandle = setInterval(@toggleCursorBlink, @props.cursorBlinkPeriod / 2) if @isMounted()
+
+  startBlinkingCursorsAfterDelay: null # Created lazily
+
+  stopBlinkingCursors: ->
+    clearInterval(@toggleCursorBlinkHandle)
+
+  toggleCursorBlink: ->
+    @setState(blinkOff: not @state.blinkOff)
+
+  pauseCursorBlinking: ->
+    @state.blinkOff = false
+    @stopBlinkingCursors()
+    @startBlinkingCursorsAfterDelay ?= debounce(@startBlinkingCursors, @props.cursorBlinkResumeDelay)
+    @startBlinkingCursorsAfterDelay()

src/custom-event-mixin.coffee

@@ -0,0 +1,15 @@
+module.exports =
+CustomEventMixin =
+  componentWillMount: ->
+    @customEventListeners = {}
+
+  componentWillUnmount: ->
+    for name, listeners in @customEventListeners
+      for listener in listeners
+        @getDOMNode().removeEventListener(name, listener)
+
+  addCustomEventListeners: (customEventListeners) ->
+    for name, listener of customEventListeners
+      @customEventListeners[name] ?= []
+      @customEventListeners[name].push(listener)
+      @getDOMNode().addEventListener(name, listener)

src/display-buffer-marker.coffee

@@ -54,6 +54,9 @@ class DisplayBufferMarker
   setBufferRange: (bufferRange, options) ->
     @bufferMarker.setRange(bufferRange, options)
 
+  getPixelRange: ->
+    @displayBuffer.pixelRangeForScreenRange(@getScreenRange(), false)
+
   # Retrieves the screen position of the marker's head.
   #
   # Returns a {Point}.
@@ -140,10 +143,10 @@ class DisplayBufferMarker
     @bufferMarker.isDestroyed()
 
   getAttributes: ->
-    @bufferMarker.getAttributes()
+    @bufferMarker.getProperties()
 
   setAttributes: (attributes) ->
-    @bufferMarker.setAttributes(attributes)
+    @bufferMarker.setProperties(attributes)
 
   matchesAttributes: (attributes) ->
     attributes = @displayBuffer.translateToBufferMarkerParams(attributes)

src/display-buffer.coffee

@@ -20,19 +20,33 @@ class DisplayBuffer extends Model
   Serializable.includeInto(this)
 
   @properties
+    manageScrollPosition: false
     softWrap: null
     editorWidthInChars: null
+    lineHeightInPixels: null
+    defaultCharWidth: null
+    height: null
+    width: null
+    scrollTop: 0
+    scrollLeft: 0
+
+  verticalScrollMargin: 2
+  horizontalScrollMargin: 6
+  horizontalScrollbarHeight: 15
+  verticalScrollbarWidth: 15
 
   constructor: ({tabLength, @editorWidthInChars, @tokenizedBuffer, buffer}={}) ->
     super
     @softWrap ?= atom.config.get('editor.softWrap') ? false
     @tokenizedBuffer ?= new TokenizedBuffer({tabLength, buffer})
     @buffer = @tokenizedBuffer.buffer
+    @charWidthsByScope = {}
     @markers = {}
     @foldsByMarkerId = {}
     @updateAllScreenLines()
     @createFoldForMarker(marker) for marker in @buffer.findMarkers(@getFoldMarkerAttributes())
     @subscribe @tokenizedBuffer, 'grammar-changed', (grammar) => @emit 'grammar-changed', grammar
+    @subscribe @tokenizedBuffer, 'tokenized', => @emit 'tokenized'
     @subscribe @tokenizedBuffer, 'changed', @handleTokenizedBufferChange
     @subscribe @buffer, 'markers-updated', @handleBufferMarkersUpdated
     @subscribe @buffer, 'marker-created', @handleBufferMarkerCreated
@@ -51,6 +65,8 @@ class DisplayBuffer extends Model
     id: @id
     softWrap: @softWrap
     editorWidthInChars: @editorWidthInChars
+    scrollTop: @scrollTop
+    scrollLeft: @scrollLeft
     tokenizedBuffer: @tokenizedBuffer.serialize()
 
   deserializeParams: (params) ->
@@ -59,6 +75,9 @@ class DisplayBuffer extends Model
 
   copy: ->
     newDisplayBuffer = new DisplayBuffer({@buffer, tabLength: @getTabLength()})
+    newDisplayBuffer.setScrollTop(@getScrollTop())
+    newDisplayBuffer.setScrollLeft(@getScrollLeft())
+
     for marker in @findMarkers(displayBufferId: @id)
       marker.copy(displayBufferId: newDisplayBuffer.id)
     newDisplayBuffer
@@ -89,6 +108,205 @@ class DisplayBuffer extends Model
   # visible - A {Boolean} indicating of the tokenized buffer is shown
   setVisible: (visible) -> @tokenizedBuffer.setVisible(visible)
 
+  getVerticalScrollMargin: -> @verticalScrollMargin
+  setVerticalScrollMargin: (@verticalScrollMargin) -> @verticalScrollMargin
+
+  getHorizontalScrollMargin: -> @horizontalScrollMargin
+  setHorizontalScrollMargin: (@horizontalScrollMargin) -> @horizontalScrollMargin
+
+  getHorizontalScrollbarHeight: -> @horizontalScrollbarHeight
+  setHorizontalScrollbarHeight: (@horizontalScrollbarHeight) -> @horizontalScrollbarHeight
+
+  getVerticalScrollbarWidth: -> @verticalScrollbarWidth
+  setVerticalScrollbarWidth: (@verticalScrollbarWidth) -> @verticalScrollbarWidth
+
+  getHeight: ->
+    if @height?
+      @height
+    else
+      if @horizontallyScrollable()
+        @getScrollHeight() + @getHorizontalScrollbarHeight()
+      else
+        @getScrollHeight()
+
+  setHeight: (@height) -> @height
+
+  getClientHeight: (reentrant) ->
+    if @horizontallyScrollable(reentrant)
+      @getHeight() - @getHorizontalScrollbarHeight()
+    else
+      @getHeight()
+
+  getClientWidth: (reentrant) ->
+    if @verticallyScrollable(reentrant)
+      @getWidth() - @getVerticalScrollbarWidth()
+    else
+      @getWidth()
+
+  horizontallyScrollable: (reentrant) ->
+    return false unless @width?
+    return false if @getSoftWrap()
+    if reentrant
+      @getScrollWidth() > @getWidth()
+    else
+      @getScrollWidth() > @getClientWidth(true)
+
+  verticallyScrollable: (reentrant) ->
+    return false unless @height?
+    if reentrant
+      @getScrollHeight() > @getHeight()
+    else
+      @getScrollHeight() > @getClientHeight(true)
+
+  getWidth: ->
+    if @width?
+      @width
+    else
+      if @verticallyScrollable()
+        @getScrollWidth() + @getVerticalScrollbarWidth()
+      else
+        @getScrollWidth()
+
+  setWidth: (newWidth) ->
+    oldWidth = @width
+    @width = newWidth
+    @updateWrappedScreenLines() if newWidth isnt oldWidth and @softWrap
+    @setScrollTop(@getScrollTop()) # Ensure scrollTop is still valid in case horizontal scrollbar disappeared
+    @width
+
+  getScrollTop: -> @scrollTop
+  setScrollTop: (scrollTop) ->
+    if @manageScrollPosition
+      @scrollTop = Math.max(0, Math.min(@getScrollHeight() - @getClientHeight(), scrollTop))
+    else
+      @scrollTop = scrollTop
+
+  getScrollBottom: -> @scrollTop + @height
+  setScrollBottom: (scrollBottom) ->
+    @setScrollTop(scrollBottom - @getClientHeight())
+    @getScrollBottom()
+
+  getScrollLeft: -> @scrollLeft
+  setScrollLeft: (scrollLeft) ->
+    if @manageScrollPosition
+      @scrollLeft = Math.max(0, Math.min(@getScrollWidth() - @getClientWidth(), scrollLeft))
+      @scrollLeft
+    else
+      @scrollLeft = scrollLeft
+
+  getScrollRight: -> @scrollLeft + @width
+  setScrollRight: (scrollRight) ->
+    @setScrollLeft(scrollRight - @width)
+    @getScrollRight()
+
+  getLineHeightInPixels: -> @lineHeightInPixels
+  setLineHeightInPixels: (@lineHeightInPixels) -> @lineHeightInPixels
+
+  getDefaultCharWidth: -> @defaultCharWidth
+  setDefaultCharWidth: (@defaultCharWidth) -> @defaultCharWidth
+
+  getCursorWidth: -> 1
+
+  getScopedCharWidth: (scopeNames, char) ->
+    @getScopedCharWidths(scopeNames)[char]
+
+  getScopedCharWidths: (scopeNames) ->
+    scope = @charWidthsByScope
+    for scopeName in scopeNames
+      scope[scopeName] ?= {}
+      scope = scope[scopeName]
+    scope.charWidths ?= {}
+    scope.charWidths
+
+  setScopedCharWidth: (scopeNames, char, width) ->
+    @getScopedCharWidths(scopeNames)[char] = width
+
+  setScopedCharWidths: (scopeNames, charWidths) ->
+    _.extend(@getScopedCharWidths(scopeNames), charWidths)
+
+  clearScopedCharWidths: ->
+    @charWidthsByScope = {}
+
+  getScrollHeight: ->
+    unless @getLineHeightInPixels() > 0
+      throw new Error("You must assign lineHeightInPixels before calling ::getScrollHeight()")
+
+    @getLineCount() * @getLineHeightInPixels()
+
+  getScrollWidth: ->
+    (@getMaxLineLength() * @getDefaultCharWidth()) + @getCursorWidth()
+
+  getVisibleRowRange: ->
+    unless @getLineHeightInPixels() > 0
+      throw new Error("You must assign a non-zero lineHeightInPixels before calling ::getVisibleRowRange()")
+
+    heightInLines = Math.ceil(@getHeight() / @getLineHeightInPixels()) + 1
+    startRow = Math.floor(@getScrollTop() / @getLineHeightInPixels())
+    endRow = Math.min(@getLineCount(), startRow + heightInLines)
+
+    [startRow, endRow]
+
+  intersectsVisibleRowRange: (startRow, endRow) ->
+    [visibleStart, visibleEnd] = @getVisibleRowRange()
+    not (endRow <= visibleStart or visibleEnd <= startRow)
+
+  selectionIntersectsVisibleRowRange: (selection) ->
+    {start, end} = selection.getScreenRange()
+    @intersectsVisibleRowRange(start.row, end.row + 1)
+
+  scrollToScreenRange: (screenRange) ->
+    verticalScrollMarginInPixels = @getVerticalScrollMargin() * @getLineHeightInPixels()
+    horizontalScrollMarginInPixels = @getHorizontalScrollMargin() * @getDefaultCharWidth()
+
+    {top, left, height, width} = @pixelRectForScreenRange(screenRange)
+    bottom = top + height
+    right = left + width
+    desiredScrollTop = top - verticalScrollMarginInPixels
+    desiredScrollBottom = bottom + verticalScrollMarginInPixels
+    desiredScrollLeft = left - horizontalScrollMarginInPixels
+    desiredScrollRight = right + horizontalScrollMarginInPixels
+
+    if desiredScrollTop < @getScrollTop()
+      @setScrollTop(desiredScrollTop)
+    else if desiredScrollBottom > @getScrollBottom()
+      @setScrollBottom(desiredScrollBottom)
+
+    if desiredScrollLeft < @getScrollLeft()
+      @setScrollLeft(desiredScrollLeft)
+    else if desiredScrollRight > @getScrollRight()
+      @setScrollRight(desiredScrollRight)
+
+  scrollToScreenPosition: (screenPosition) ->
+    @scrollToScreenRange(new Range(screenPosition, screenPosition))
+
+  scrollToBufferPosition: (bufferPosition) ->
+    @scrollToScreenPosition(@screenPositionForBufferPosition(bufferPosition))
+
+  pixelRectForScreenRange: (screenRange) ->
+    if screenRange.end.row > screenRange.start.row
+      top = @pixelPositionForScreenPosition(screenRange.start).top
+      left = 0
+      height = (screenRange.end.row - screenRange.start.row + 1) * @getLineHeightInPixels()
+      width = @getScrollWidth()
+    else
+      {top, left} = @pixelPositionForScreenPosition(screenRange.start)
+      height = @getLineHeightInPixels()
+      width = @pixelPositionForScreenPosition(screenRange.end).left - left
+
+    {top, left, width, height}
+
+  # Retrieves the current tab length.
+  #
+  # Returns a {Number}.
+  getTabLength: ->
+    @tokenizedBuffer.getTabLength()
+
+  # Specifies the tab length.
+  #
+  # tabLength - A {Number} that defines the new tab length.
+  setTabLength: (tabLength) ->
+    @tokenizedBuffer.setTabLength(tabLength)
+
   # Deprecated: Use the softWrap property directly
   setSoftWrap: (@softWrap) -> @softWrap
 
@@ -105,12 +323,19 @@ class DisplayBuffer extends Model
       if editorWidthInChars isnt previousWidthInChars and @softWrap
         @updateWrappedScreenLines()
 
-  getSoftWrapColumn: ->
-    if atom.config.get('editor.softWrapAtPreferredLineLength')
-      Math.min(@editorWidthInChars, atom.config.getPositiveInt('editor.preferredLineLength', @editorWidthInChars))
+  getEditorWidthInChars: ->
+    width = @getWidth()
+    if width? and @defaultCharWidth > 0
+      Math.floor(width / @defaultCharWidth)
     else
       @editorWidthInChars
 
+  getSoftWrapColumn: ->
+    if atom.config.get('editor.softWrapAtPreferredLineLength')
+      Math.min(@getEditorWidthInChars(), atom.config.getPositiveInt('editor.preferredLineLength', @getEditorWidthInChars()))
+    else
+      @getEditorWidthInChars()
+
   # Gets the screen line for the given screen row.
   #
   # screenRow - A {Number} indicating the screen row.
@@ -134,6 +359,9 @@ class DisplayBuffer extends Model
   getLines: ->
     new Array(@screenLines...)
 
+  indentLevelForLine: (line) ->
+    @tokenizedBuffer.indentLevelForLine(line)
+
   # Given starting and ending screen rows, this returns an array of the
   # buffer rows corresponding to every screen row in the range
   #
@@ -273,6 +501,52 @@ class DisplayBuffer extends Model
     end = @bufferPositionForScreenPosition(screenRange.end)
     new Range(start, end)
 
+  pixelRangeForScreenRange: (screenRange, clip=true) ->
+    {start, end} = Range.fromObject(screenRange)
+    {start: @pixelPositionForScreenPosition(start, clip), end: @pixelPositionForScreenPosition(end, clip)}
+
+  pixelPositionForScreenPosition: (screenPosition, clip=true) ->
+    screenPosition = Point.fromObject(screenPosition)
+    screenPosition = @clipScreenPosition(screenPosition) if clip
+
+    targetRow = screenPosition.row
+    targetColumn = screenPosition.column
+    defaultCharWidth = @defaultCharWidth
+
+    top = targetRow * @lineHeightInPixels
+    left = 0
+    column = 0
+    for token in @lineForRow(targetRow).tokens
+      charWidths = @getScopedCharWidths(token.scopes)
+      for char in token.value
+        return {top, left} if column is targetColumn
+        left += charWidths[char] ? defaultCharWidth
+        column++
+    {top, left}
+
+  screenPositionForPixelPosition: (pixelPosition) ->
+    targetTop = pixelPosition.top
+    targetLeft = pixelPosition.left
+    defaultCharWidth = @defaultCharWidth
+    row = Math.floor(targetTop / @getLineHeightInPixels())
+    row = Math.min(row, @getLastRow())
+    row = Math.max(0, row)
+
+    left = 0
+    column = 0
+    for token in @lineForRow(row).tokens
+      charWidths = @getScopedCharWidths(token.scopes)
+      for char in token.value
+        charWidth = charWidths[char] ? defaultCharWidth
+        break if targetLeft <= left + (charWidth / 2)
+        left += charWidth
+        column++
+
+    new Point(row, column)
+
+  pixelPositionForBufferPosition: (bufferPosition) ->
+    @pixelPositionForScreenPosition(@screenPositionForBufferPosition(bufferPosition))
+
   # Gets the number of screen lines.
   #
   # Returns a {Number}.
@@ -358,18 +632,6 @@ class DisplayBuffer extends Model
   tokenForBufferPosition: (bufferPosition) ->
     @tokenizedBuffer.tokenForPosition(bufferPosition)
 
-  # Retrieves the current tab length.
-  #
-  # Returns a {Number}.
-  getTabLength: ->
-    @tokenizedBuffer.getTabLength()
-
-  # Specifies the tab length.
-  #
-  # tabLength - A {Number} that defines the new tab length.
-  setTabLength: (tabLength) ->
-    @tokenizedBuffer.setTabLength(tabLength)
-
   # Get the grammar for this buffer.
   #
   # Returns the current {Grammar} or the {NullGrammar}.
@@ -493,8 +755,8 @@ class DisplayBuffer extends Model
   # options - Options to pass to the {Marker} constructor
   #
   # Returns a {Number} representing the new marker's ID.
-  markBufferRange: (args...) ->
-    @getMarker(@buffer.markRange(args...).id)
+  markBufferRange: (range, options) ->
+    @getMarker(@buffer.markRange(range, options).id)
 
   # Public: Constructs a new marker at the given screen position.
   #

src/editor-component.coffee

@@ -0,0 +1,516 @@
+React = require 'react-atom-fork'
+{div, span} = require 'reactionary-atom-fork'
+{debounce, defaults} = require 'underscore-plus'
+scrollbarStyle = require 'scrollbar-style'
+
+GutterComponent = require './gutter-component'
+EditorScrollViewComponent = require './editor-scroll-view-component'
+ScrollbarComponent = require './scrollbar-component'
+ScrollbarCornerComponent = require './scrollbar-corner-component'
+SubscriberMixin = require './subscriber-mixin'
+
+module.exports =
+EditorComponent = React.createClass
+  displayName: 'EditorComponent'
+  mixins: [SubscriberMixin]
+
+  pendingScrollTop: null
+  pendingScrollLeft: null
+  selectOnMouseMove: false
+  batchingUpdates: false
+  updateRequested: false
+  cursorsMoved: false
+  selectionChanged: false
+  selectionAdded: false
+  scrollingVertically: false
+  gutterWidth: 0
+  refreshingScrollbars: false
+  measuringScrollbars: true
+  pendingVerticalScrollDelta: 0
+  pendingHorizontalScrollDelta: 0
+  mouseWheelScreenRow: null
+
+  render: ->
+    {focused, fontSize, lineHeight, fontFamily, showIndentGuide, showInvisibles, visible} = @state
+    {editor, cursorBlinkPeriod, cursorBlinkResumeDelay} = @props
+    maxLineNumberDigits = editor.getScreenLineCount().toString().length
+    invisibles = if showInvisibles then @state.invisibles else {}
+
+    if @isMounted()
+      renderedRowRange = @getRenderedRowRange()
+      scrollHeight = editor.getScrollHeight()
+      scrollWidth = editor.getScrollWidth()
+      scrollTop = editor.getScrollTop()
+      scrollLeft = editor.getScrollLeft()
+      lineHeightInPixels = editor.getLineHeightInPixels()
+      scrollViewHeight = editor.getHeight()
+      horizontalScrollbarHeight = editor.getHorizontalScrollbarHeight()
+      verticalScrollbarWidth = editor.getVerticalScrollbarWidth()
+      verticallyScrollable = editor.verticallyScrollable()
+      horizontallyScrollable = editor.horizontallyScrollable()
+
+    className = 'editor editor-colors react'
+    className += ' is-focused' if focused
+
+    div className: className, style: {fontSize, lineHeight, fontFamily}, tabIndex: -1,
+      GutterComponent {
+        ref: 'gutter', editor, renderedRowRange, maxLineNumberDigits,
+        scrollTop, scrollHeight, lineHeight, lineHeightInPixels, fontSize, fontFamily,
+        @pendingChanges, onWidthChanged: @onGutterWidthChanged, @mouseWheelScreenRow
+      }
+
+      EditorScrollViewComponent {
+        ref: 'scrollView', editor, fontSize, fontFamily, showIndentGuide,
+        lineHeight, lineHeightInPixels, renderedRowRange, @pendingChanges,
+        scrollTop, scrollLeft, scrollHeight, scrollWidth, @scrollingVertically,
+        @cursorsMoved, @selectionChanged, @selectionAdded, cursorBlinkPeriod,
+        cursorBlinkResumeDelay, @onInputFocused, @onInputBlurred, @mouseWheelScreenRow,
+        invisibles, visible, scrollViewHeight, focused
+      }
+
+      ScrollbarComponent
+        ref: 'verticalScrollbar'
+        className: 'vertical-scrollbar'
+        orientation: 'vertical'
+        onScroll: @onVerticalScroll
+        scrollTop: scrollTop
+        scrollHeight: scrollHeight
+        visible: verticallyScrollable and not @refreshingScrollbars and not @measuringScrollbars
+        scrollableInOppositeDirection: horizontallyScrollable
+        verticalScrollbarWidth: verticalScrollbarWidth
+        horizontalScrollbarHeight: horizontalScrollbarHeight
+
+      ScrollbarComponent
+        ref: 'horizontalScrollbar'
+        className: 'horizontal-scrollbar'
+        orientation: 'horizontal'
+        onScroll: @onHorizontalScroll
+        scrollLeft: scrollLeft
+        scrollWidth: scrollWidth + @gutterWidth
+        visible: horizontallyScrollable and not @refreshingScrollbars and not @measuringScrollbars
+        scrollableInOppositeDirection: verticallyScrollable
+        verticalScrollbarWidth: verticalScrollbarWidth
+        horizontalScrollbarHeight: horizontalScrollbarHeight
+
+      # Also used to measure the height/width of scrollbars after the initial render
+      ScrollbarCornerComponent
+        ref: 'scrollbarCorner'
+        visible: not @refreshingScrollbars and (@measuringScrollbars or horizontallyScrollable and verticallyScrollable)
+        measuringScrollbars: @measuringScrollbars
+        height: horizontalScrollbarHeight
+        width: verticalScrollbarWidth
+
+  getRenderedRowRange: ->
+    {editor, lineOverdrawMargin} = @props
+    [visibleStartRow, visibleEndRow] = editor.getVisibleRowRange()
+    renderedStartRow = Math.max(0, visibleStartRow - lineOverdrawMargin)
+    renderedEndRow = Math.min(editor.getScreenLineCount(), visibleEndRow + lineOverdrawMargin)
+    [renderedStartRow, renderedEndRow]
+
+  getInitialState: ->
+    visible: true
+
+  getDefaultProps: ->
+    cursorBlinkPeriod: 800
+    cursorBlinkResumeDelay: 100
+    lineOverdrawMargin: 8
+
+  componentWillMount: ->
+    @pendingChanges = []
+    @props.editor.manageScrollPosition = true
+    @observeConfig()
+
+  componentDidMount: ->
+    @observeEditor()
+    @listenForDOMEvents()
+    @listenForCommands()
+    @measureScrollbars()
+    @subscribe atom.themes, 'stylesheet-added stylsheet-removed', @onStylesheetsChanged
+    @subscribe scrollbarStyle.changes, @refreshScrollbars
+    @props.editor.setVisible(true)
+    @requestUpdate()
+
+  componentWillUnmount: ->
+    @unsubscribe()
+    @getDOMNode().removeEventListener 'mousewheel', @onMouseWheel
+
+  componentWillUpdate: ->
+    @props.parentView.trigger 'cursor:moved' if @cursorsMoved
+
+  componentDidUpdate: ->
+    @pendingChanges.length = 0
+    @cursorsMoved = false
+    @selectionChanged = false
+    @selectionAdded = false
+    @refreshingScrollbars = false
+    @measureScrollbars() if @measuringScrollbars
+    @props.parentView.trigger 'editor:display-updated'
+
+  observeEditor: ->
+    {editor} = @props
+    @subscribe editor, 'batched-updates-started', @onBatchedUpdatesStarted
+    @subscribe editor, 'batched-updates-ended', @onBatchedUpdatesEnded
+    @subscribe editor, 'screen-lines-changed', @onScreenLinesChanged
+    @subscribe editor, 'cursors-moved', @onCursorsMoved
+    @subscribe editor, 'selection-removed selection-screen-range-changed', @onSelectionChanged
+    @subscribe editor, 'selection-added', @onSelectionAdded
+    @subscribe editor.$scrollTop.changes, @onScrollTopChanged
+    @subscribe editor.$scrollLeft.changes, @requestUpdate
+    @subscribe editor.$height.changes, @requestUpdate
+    @subscribe editor.$width.changes, @requestUpdate
+    @subscribe editor.$defaultCharWidth.changes, @requestUpdate
+    @subscribe editor.$lineHeightInPixels.changes, @requestUpdate
+
+  listenForDOMEvents: ->
+    node = @getDOMNode()
+    node.addEventListener 'mousewheel', @onMouseWheel
+    node.addEventListener 'focus', @onFocus # For some reason, React's built in focus events seem to bubble
+
+  listenForCommands: ->
+    {parentView, editor, mini} = @props
+
+    @addCommandListeners
+      'core:move-left': => editor.moveCursorLeft()
+      'core:move-right': => editor.moveCursorRight()
+      'core:select-left': => editor.selectLeft()
+      'core:select-right': => editor.selectRight()
+      'core:select-all': => editor.selectAll()
+      'core:backspace': => editor.backspace()
+      'core:delete': => editor.delete()
+      'core:undo': => editor.undo()
+      'core:redo': => editor.redo()
+      'core:cut': => editor.cutSelectedText()
+      'core:copy': => editor.copySelectedText()
+      'core:paste': => editor.pasteText()
+      'editor:move-to-previous-word': => editor.moveCursorToPreviousWord()
+      'editor:select-word': => editor.selectWord()
+      'editor:consolidate-selections': @consolidateSelections
+      'editor:delete-to-beginning-of-word': => editor.deleteToBeginningOfWord()
+      'editor:delete-to-beginning-of-line': => editor.deleteToBeginningOfLine()
+      'editor:delete-to-end-of-word': => editor.deleteToEndOfWord()
+      'editor:delete-line': => editor.deleteLine()
+      'editor:cut-to-end-of-line': => editor.cutToEndOfLine()
+      'editor:move-to-beginning-of-next-paragraph': => editor.moveCursorToBeginningOfNextParagraph()
+      'editor:move-to-beginning-of-previous-paragraph': => editor.moveCursorToBeginningOfPreviousParagraph()
+      'editor:move-to-beginning-of-screen-line': => editor.moveCursorToBeginningOfScreenLine()
+      'editor:move-to-beginning-of-line': => editor.moveCursorToBeginningOfLine()
+      'editor:move-to-end-of-screen-line': => editor.moveCursorToEndOfScreenLine()
+      'editor:move-to-end-of-line': => editor.moveCursorToEndOfLine()
+      'editor:move-to-first-character-of-line': => editor.moveCursorToFirstCharacterOfLine()
+      'editor:move-to-beginning-of-word': => editor.moveCursorToBeginningOfWord()
+      'editor:move-to-end-of-word': => editor.moveCursorToEndOfWord()
+      'editor:move-to-beginning-of-next-word': => editor.moveCursorToBeginningOfNextWord()
+      'editor:move-to-previous-word-boundary': => editor.moveCursorToPreviousWordBoundary()
+      'editor:move-to-next-word-boundary': => editor.moveCursorToNextWordBoundary()
+      'editor:select-to-end-of-line': => editor.selectToEndOfLine()
+      'editor:select-to-beginning-of-line': => editor.selectToBeginningOfLine()
+      'editor:select-to-end-of-word': => editor.selectToEndOfWord()
+      'editor:select-to-beginning-of-word': => editor.selectToBeginningOfWord()
+      'editor:select-to-beginning-of-next-word': => editor.selectToBeginningOfNextWord()
+      'editor:select-to-next-word-boundary': => editor.selectToNextWordBoundary()
+      'editor:select-to-previous-word-boundary': => editor.selectToPreviousWordBoundary()
+      'editor:select-to-first-character-of-line': => editor.selectToFirstCharacterOfLine()
+      'editor:select-line': => editor.selectLine()
+      'editor:transpose': => editor.transpose()
+      'editor:upper-case': => editor.upperCase()
+      'editor:lower-case': => editor.lowerCase()
+
+    unless mini
+      @addCommandListeners
+        'core:move-up': => editor.moveCursorUp()
+        'core:move-down': => editor.moveCursorDown()
+        'core:move-to-top': => editor.moveCursorToTop()
+        'core:move-to-bottom': => editor.moveCursorToBottom()
+        'core:select-up': => editor.selectUp()
+        'core:select-down': => editor.selectDown()
+        'core:select-to-top': => editor.selectToTop()
+        'core:select-to-bottom': => editor.selectToBottom()
+        'editor:indent': => editor.indent()
+        'editor:auto-indent': => editor.autoIndentSelectedRows()
+        'editor:indent-selected-rows': => editor.indentSelectedRows()
+        'editor:outdent-selected-rows': => editor.outdentSelectedRows()
+        'editor:newline': => editor.insertNewline()
+        'editor:newline-below': => editor.insertNewlineBelow()
+        'editor:newline-above': => editor.insertNewlineAbove()
+        'editor:add-selection-below': => editor.addSelectionBelow()
+        'editor:add-selection-above': => editor.addSelectionAbove()
+        'editor:split-selections-into-lines': => editor.splitSelectionsIntoLines()
+        'editor:toggle-soft-tabs': => editor.toggleSoftTabs()
+        'editor:toggle-soft-wrap': => editor.toggleSoftWrap()
+        'editor:fold-all': => editor.foldAll()
+        'editor:unfold-all': => editor.unfoldAll()
+        'editor:fold-current-row': => editor.foldCurrentRow()
+        'editor:unfold-current-row': => editor.unfoldCurrentRow()
+        'editor:fold-selection': => neditor.foldSelectedLines()
+        'editor:fold-at-indent-level-1': => editor.foldAllAtIndentLevel(0)
+        'editor:fold-at-indent-level-2': => editor.foldAllAtIndentLevel(1)
+        'editor:fold-at-indent-level-3': => editor.foldAllAtIndentLevel(2)
+        'editor:fold-at-indent-level-4': => editor.foldAllAtIndentLevel(3)
+        'editor:fold-at-indent-level-5': => editor.foldAllAtIndentLevel(4)
+        'editor:fold-at-indent-level-6': => editor.foldAllAtIndentLevel(5)
+        'editor:fold-at-indent-level-7': => editor.foldAllAtIndentLevel(6)
+        'editor:fold-at-indent-level-8': => editor.foldAllAtIndentLevel(7)
+        'editor:fold-at-indent-level-9': => editor.foldAllAtIndentLevel(8)
+        'editor:toggle-line-comments': => editor.toggleLineCommentsInSelection()
+        'editor:log-cursor-scope': => editor.logCursorScope()
+        'editor:checkout-head-revision': => editor.checkoutHead()
+        'editor:copy-path': => editor.copyPathToClipboard()
+        'editor:move-line-up': => editor.moveLineUp()
+        'editor:move-line-down': => editor.moveLineDown()
+        'editor:duplicate-lines': => editor.duplicateLines()
+        'editor:join-lines': => editor.joinLines()
+        'editor:toggle-indent-guide': => atom.config.toggle('editor.showIndentGuide')
+        'editor:toggle-line-numbers': =>  atom.config.toggle('editor.showLineNumbers')
+        'editor:scroll-to-cursor': => editor.scrollToCursorPosition()
+        'core:page-up': => editor.pageUp()
+        'core:page-down': => editor.pageDown()
+        'benchmark:scroll': @runScrollBenchmark
+
+  addCommandListeners: (listenersByCommandName) ->
+    {parentView} = @props
+
+    for command, listener of listenersByCommandName
+      parentView.command command, listener
+
+  observeConfig: ->
+    @subscribe atom.config.observe 'editor.fontFamily', @setFontFamily
+    @subscribe atom.config.observe 'editor.fontSize', @setFontSize
+    @subscribe atom.config.observe 'editor.lineHeight', @setLineHeight
+    @subscribe atom.config.observe 'editor.showIndentGuide', @setShowIndentGuide
+    @subscribe atom.config.observe 'editor.invisibles', @setInvisibles
+    @subscribe atom.config.observe 'editor.showInvisibles', @setShowInvisibles
+
+  measureScrollbars: ->
+    @measuringScrollbars = false
+
+    {editor} = @props
+    scrollbarCornerNode = @refs.scrollbarCorner.getDOMNode()
+    width = (scrollbarCornerNode.offsetWidth - scrollbarCornerNode.clientWidth) or 15
+    height = (scrollbarCornerNode.offsetHeight - scrollbarCornerNode.clientHeight) or 15
+    editor.setVerticalScrollbarWidth(width)
+    editor.setHorizontalScrollbarHeight(height)
+
+  setFontSize: (fontSize) ->
+    @setState({fontSize})
+
+  setLineHeight: (lineHeight) ->
+    @setState({lineHeight})
+
+  setFontFamily: (fontFamily) ->
+    @setState({fontFamily})
+
+  setShowIndentGuide: (showIndentGuide) ->
+    @setState({showIndentGuide})
+
+  # Public: Defines which characters are invisible.
+  #
+  # invisibles - An {Object} defining the invisible characters:
+  #   :eol   - The end of line invisible {String} (default: `\u00ac`).
+  #   :space - The space invisible {String} (default: `\u00b7`).
+  #   :tab   - The tab invisible {String} (default: `\u00bb`).
+  #   :cr    - The carriage return invisible {String} (default: `\u00a4`).
+  setInvisibles: (invisibles={}) ->
+    defaults invisibles,
+      eol: '\u00ac'
+      space: '\u00b7'
+      tab: '\u00bb'
+      cr: '\u00a4'
+
+    @setState({invisibles})
+
+  setShowInvisibles: (showInvisibles) ->
+    @setState({showInvisibles})
+
+  onFocus: ->
+    @refs.scrollView.focus()
+
+  onInputFocused: ->
+    @setState(focused: true)
+
+  onInputBlurred: ->
+    @setState(focused: false)
+
+  onVerticalScroll: (scrollTop) ->
+    {editor} = @props
+
+    return if scrollTop is editor.getScrollTop()
+
+    animationFramePending = @pendingScrollTop?
+    @pendingScrollTop = scrollTop
+    unless animationFramePending
+      requestAnimationFrame =>
+        @props.editor.setScrollTop(@pendingScrollTop)
+        @pendingScrollTop = null
+
+  onHorizontalScroll: (scrollLeft) ->
+    {editor} = @props
+
+    return if scrollLeft is editor.getScrollLeft()
+
+    animationFramePending = @pendingScrollLeft?
+    @pendingScrollLeft = scrollLeft
+    unless animationFramePending
+      requestAnimationFrame =>
+        @props.editor.setScrollLeft(@pendingScrollLeft)
+        @pendingScrollLeft = null
+
+  onMouseWheel: (event) ->
+    event.preventDefault()
+    screenRow = @screenRowForNode(event.target)
+    @mouseWheelScreenRow = screenRow if screenRow?
+    animationFramePending = @pendingHorizontalScrollDelta isnt 0 or @pendingVerticalScrollDelta isnt 0
+
+    # Only scroll in one direction at a time
+    {wheelDeltaX, wheelDeltaY} = event
+    if Math.abs(wheelDeltaX) > Math.abs(wheelDeltaY)
+      @pendingHorizontalScrollDelta -= wheelDeltaX
+    else
+      @pendingVerticalScrollDelta -= wheelDeltaY
+
+    unless animationFramePending
+      requestAnimationFrame =>
+        {editor} = @props
+        editor.setScrollTop(editor.getScrollTop() + @pendingVerticalScrollDelta)
+        editor.setScrollLeft(editor.getScrollLeft() + @pendingHorizontalScrollDelta)
+        @pendingVerticalScrollDelta = 0
+        @pendingHorizontalScrollDelta = 0
+
+  screenRowForNode: (node) ->
+    while node isnt document
+      if screenRow = node.dataset.screenRow
+        return parseInt(screenRow)
+      node = node.parentNode
+    null
+
+  onStylesheetsChanged: (stylesheet) ->
+    @refreshScrollbars() if @containsScrollbarSelector(stylesheet)
+
+  containsScrollbarSelector: (stylesheet) ->
+    for rule in stylesheet.cssRules
+      if rule.selectorText?.indexOf('scrollbar') > -1
+        return true
+    false
+
+  refreshScrollbars: ->
+    # Believe it or not, proper handling of changes to scrollbar styles requires
+    # three DOM updates.
+
+    # Scrollbar style changes won't apply to scrollbars that are already
+    # visible, so first we need to hide scrollbars so we can redisplay them and
+    # force Chromium to apply updates.
+    @refreshingScrollbars = true
+    @requestUpdate()
+
+    # Next, we display only the scrollbar corner so we can measure the new
+    # scrollbar dimensions. The ::measuringScrollbars property will be set back
+    # to false after the scrollbars are measured.
+    @measuringScrollbars = true
+    @requestUpdate()
+
+    # Finally, we restore the scrollbars based on the newly-measured dimensions
+    # if the editor's content and dimensions require them to be visible.
+    @requestUpdate()
+
+  onBatchedUpdatesStarted: ->
+    @batchingUpdates = true
+
+  onBatchedUpdatesEnded: ->
+    updateRequested = @updateRequested
+    @updateRequested = false
+    @batchingUpdates = false
+    if updateRequested
+      @requestUpdate()
+
+  onScreenLinesChanged: (change) ->
+    {editor} = @props
+    @pendingChanges.push(change)
+    @requestUpdate() if editor.intersectsVisibleRowRange(change.start, change.end + 1) # TODO: Use closed-open intervals for change events
+
+  onSelectionChanged: (selection) ->
+    {editor} = @props
+    if editor.selectionIntersectsVisibleRowRange(selection)
+      @selectionChanged = true
+      @requestUpdate()
+
+  onSelectionAdded: (selection) ->
+    {editor} = @props
+    if editor.selectionIntersectsVisibleRowRange(selection)
+      @selectionChanged = true
+      @selectionAdded = true
+      @requestUpdate()
+
+  onScrollTopChanged: ->
+    @scrollingVertically = true
+    @requestUpdate()
+    @stopScrollingAfterDelay ?= debounce(@onStoppedScrolling, 100)
+    @stopScrollingAfterDelay()
+
+  onStoppedScrolling: ->
+    @scrollingVertically = false
+    @mouseWheelScreenRow = null
+    @requestUpdate()
+
+  stopScrollingAfterDelay: null # created lazily
+
+  onCursorsMoved: ->
+    @cursorsMoved = true
+
+  onGutterWidthChanged: (@gutterWidth) ->
+    @requestUpdate()
+
+  requestUpdate: ->
+    if @batchingUpdates
+      @updateRequested = true
+    else
+      @forceUpdate()
+
+  measureHeightAndWidth: ->
+    @refs.scrollView.measureHeightAndWidth()
+
+  consolidateSelections: (e) ->
+    e.abortKeyBinding() unless @props.editor.consolidateSelections()
+
+  lineNodeForScreenRow: (screenRow) -> @refs.scrollView.lineNodeForScreenRow(screenRow)
+
+  lineNumberNodeForScreenRow: (screenRow) -> @refs.gutter.lineNumberNodeForScreenRow(screenRow)
+
+  hide: ->
+    @setState(visible: false)
+
+  show: ->
+    @setState(visible: true)
+
+  runScrollBenchmark: ->
+    unless process.env.NODE_ENV is 'production'
+      ReactPerf = require 'react-atom-fork/lib/ReactDefaultPerf'
+      ReactPerf.start()
+
+    node = @getDOMNode()
+
+    scroll = (delta, done) ->
+      dispatchMouseWheelEvent = ->
+        node.dispatchEvent(new WheelEvent('mousewheel', wheelDeltaX: -0, wheelDeltaY: -delta))
+
+      stopScrolling = ->
+        clearInterval(interval)
+        done?()
+
+      interval = setInterval(dispatchMouseWheelEvent, 10)
+      setTimeout(stopScrolling, 500)
+
+    console.timeline('scroll')
+    scroll 50, ->
+      scroll 100, ->
+        scroll 200, ->
+          scroll 400, ->
+            scroll 800, ->
+              scroll 1600, ->
+                console.timelineEnd('scroll')
+                unless process.env.NODE_ENV is 'production'
+                  ReactPerf.stop()
+                  console.log "Inclusive"
+                  ReactPerf.printInclusive()
+                  console.log "Exclusive"
+                  ReactPerf.printExclusive()
+                  console.log "Wasted"
+                  ReactPerf.printWasted()