Merge pull request #3690 from atom/bo-fix-config-issue

Fix config resetting all values when one changes.

.node-version

@@ -0,0 +1 @@
+v0.10.21

README.md

@@ -25,6 +25,17 @@ You can also download a `.zip` file from the [releases page](https://github.com/
 The Windows version does not currently automatically update so you will need to
 manually upgrade to future releases by re-downloading the `.zip` file.
 
+### Debian Linux (Ubuntu)
+
+Currently only a 64-bit version is available.
+
+1. Download `atom-amd64.deb` from the [Atom releases page](https://github.com/atom/atom/releases/latest).
+2. Run `sudo dpkg --install atom-amd64.deb` on the downloaded package.
+3. Launch Atom using the installed `atom` command.
+
+The Linux version does not currently automatically update so you will need to
+repeat these steps to upgrade to future releases.
+
 ## Building
 
 * [Linux](docs/build-instructions/linux.md)

apm/package.json

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

atom.sh

@@ -50,7 +50,7 @@ if [ $OS == 'Mac' ]; then
 
   # If ATOM_PATH isn't a executable file, use spotlight to search for Atom
   if [ ! -x "$ATOM_PATH/$ATOM_APP_NAME" ]; then
-    ATOM_PATH=$(mdfind "kMDItemCFBundleIdentifier == 'com.github.atom'" | head -1 | xargs dirname)
+    ATOM_PATH=$(mdfind "kMDItemCFBundleIdentifier == 'com.github.atom'" | grep -v ShipIt | head -1 | xargs dirname)
   fi
 
   # Exit if Atom can't be found

benchmark/benchmark-suite.coffee

@@ -7,7 +7,7 @@ describe "editorView.", ->
 
   beforeEach ->
     atom.workspaceViewParentSelector = '#jasmine-content'
-    atom.workspaceView = new WorkspaceView
+    atom.workspaceView = atom.workspace.getView(atom.workspace).__spacePenView
     atom.workspaceView.attachToDom()
 
     atom.workspaceView.width(1024)

benchmark/browser-process-startup.coffee

@@ -0,0 +1,56 @@
+#!/usr/bin/env coffee
+
+{spawn, exec} = require 'child_process'
+fs = require 'fs'
+os = require 'os'
+path = require 'path'
+_ = require 'underscore-plus'
+temp = require 'temp'
+
+directoryToOpen = temp.mkdirSync('browser-process-startup-')
+socketPath = path.join(os.tmpdir(), 'atom.sock')
+numberOfRuns = 10
+
+deleteSocketFile = ->
+  try
+    fs.unlinkSync(socketPath) if fs.existsSync(socketPath)
+  catch error
+    console.error(error)
+
+launchAtom = (callback) ->
+  deleteSocketFile()
+
+  cmd = 'atom'
+  args = ['--safe', '--new-window', '--foreground', directoryToOpen]
+  atomProcess = spawn(cmd, args)
+
+  output = ''
+  startupTimes = []
+  dataListener = (data) ->
+    output += data
+    if match = /App load time: (\d+)/.exec(output)
+      startupTime = parseInt(match[1])
+      atomProcess.stderr.removeListener 'data', dataListener
+      atomProcess.kill()
+      exec 'pkill -9 Atom', (error) ->
+        console.error(error) if error?
+        callback(startupTime)
+
+  atomProcess.stderr.on 'data', dataListener
+
+startupTimes = []
+collector = (startupTime) ->
+  startupTimes.push(startupTime)
+  if startupTimes.length < numberOfRuns
+    launchAtom(collector)
+  else
+    maxTime = _.max(startupTimes)
+    minTime = _.min(startupTimes)
+    totalTime = startupTimes.reduce (previousValue=0, currentValue) -> previousValue + currentValue
+    console.log "Startup Runs: #{startupTimes.length}"
+    console.log "First run time: #{startupTimes[0]}ms"
+    console.log "Max time: #{maxTime}ms"
+    console.log "Min time: #{minTime}ms"
+    console.log "Average time: #{Math.round(totalTime/startupTimes.length)}ms"
+
+launchAtom(collector)

build/Gruntfile.coffee

@@ -39,6 +39,7 @@ module.exports = (grunt) ->
   tmpDir = os.tmpdir()
   appName = if process.platform is 'darwin' then 'Atom.app' else 'Atom'
   buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
+  buildDir = path.resolve(buildDir)
   installDir = grunt.option('install-dir')
 
   home = if process.platform is 'win32' then process.env.USERPROFILE else process.env.HOME
@@ -62,6 +63,8 @@ module.exports = (grunt) ->
     installDir ?= process.env.INSTALL_PREFIX ? '/usr/local'
     killCommand ='pkill -9 atom'
 
+  installDir = path.resolve(installDir)
+
   coffeeConfig =
     glob_to_multiple:
       expand: true
@@ -225,9 +228,17 @@ module.exports = (grunt) ->
   grunt.registerTask('compile', ['coffee', 'prebuild-less', 'cson', 'peg'])
   grunt.registerTask('lint', ['coffeelint', 'csslint', 'lesslint'])
   grunt.registerTask('test', ['shell:kill-atom', 'run-specs'])
-  grunt.registerTask('ci', ['output-disk-space', 'download-atom-shell', 'build', 'dump-symbols', 'set-version', 'check-licenses', 'lint', 'test', 'codesign', 'publish-build'])
   grunt.registerTask('docs', ['markdown:guides', 'build-docs'])
 
+  ciTasks = ['output-disk-space', 'download-atom-shell', 'build']
+  ciTasks.push('dump-symbols') if process.platform isnt 'win32'
+  ciTasks.push('set-version', 'check-licenses', 'lint')
+  ciTasks.push('mkdeb') if process.platform is 'linux'
+  ciTasks.push('test') if process.platform is 'darwin'
+  ciTasks.push('codesign')
+  ciTasks.push('publish-build')
+  grunt.registerTask('ci', ciTasks)
+
   defaultTasks = ['download-atom-shell', 'build', 'set-version']
   defaultTasks.push 'install' unless process.platform is 'linux'
   grunt.registerTask('default', defaultTasks)

build/package.json

@@ -7,8 +7,7 @@
   },
   "dependencies": {
     "async": "~0.2.9",
-    "donna": "~1.0",
-    "tello": "~0.2",
+    "donna": "1.0.1",
     "formidable": "~1.0.14",
     "fs-plus": "2.x",
     "github-releases": "~0.2.0",
@@ -27,7 +26,7 @@
     "harmony-collections": "~0.3.8",
     "json-front-matter": "~0.1.3",
     "legal-eagle": "~0.4.0",
-    "minidump": "~0.7",
+    "minidump": "~0.8",
     "normalize-package-data": "0.2.12",
     "npm": "~1.4.5",
     "rcedit": "~0.1.2",
@@ -35,6 +34,8 @@
     "request": "~2.27.0",
     "rimraf": "~2.2.2",
     "runas": "~1.0.1",
+    "tello": "1.0.3",
+    "temp": "~0.8.1",
     "underscore-plus": "1.x",
     "unzip": "~0.1.9",
     "vm-compatibility-layer": "~0.1.0"

build/tasks/codesign-task.coffee

@@ -1,4 +1,5 @@
 path = require 'path'
+fs = require 'fs-plus'
 
 module.exports = (grunt) ->
   {spawn} = require('./task-helpers')(grunt)
@@ -25,12 +26,21 @@ module.exports = (grunt) ->
     switch process.platform
       when 'darwin'
         cmd = 'codesign'
-        args = ['-f', '-v', '-s', 'Developer ID Application: GitHub', grunt.config.get('atom.shellAppDir')]
+        args = ['--deep', '--force', '--verbose', '--sign', 'Developer ID Application: GitHub', grunt.config.get('atom.shellAppDir')]
         spawn {cmd, args}, (error) -> callback(error)
       when 'win32'
         spawn {cmd: 'taskkill', args: ['/F', '/IM', 'atom.exe']}, ->
           cmd = process.env.JANKY_SIGNTOOL ? 'signtool'
           args = [path.join(grunt.config.get('atom.shellAppDir'), 'atom.exe')]
-          spawn {cmd, args}, (error) -> callback(error)
+
+          spawn {cmd, args}, (error) ->
+            return callback(error) if error?
+
+            setupExePath = path.join(grunt.config.get('atom.shellAppDir'), '..', 'Releases', 'setup.exe')
+            if fs.isFileSync(setupExePath)
+              args = [setupExePath]
+              spawn {cmd, args}, (error) -> callback(error)
+            else
+              callback()
       else
         callback()

build/tasks/create-installer.coffee

@@ -0,0 +1,41 @@
+fs = require 'fs'
+path = require 'path'
+_ = require 'underscore-plus'
+
+module.exports = (grunt) ->
+  {spawn, rm} = require('./task-helpers')(grunt)
+
+  grunt.registerTask 'create-installer', 'Create the Windows installer', ->
+    return unless process.platform is 'win32'
+
+    done = @async()
+
+    buildDir = grunt.config.get('atom.buildDir')
+    atomDir = path.join(buildDir, 'Atom')
+
+    packageInfo = grunt.file.readJSON(path.join(atomDir, 'resources', 'app', 'package.json'))
+    inputTemplate = grunt.file.read(path.join('build', 'windows', 'atom.nuspec.erb'))
+
+    # NB: Build server has some sort of stamp on the version number
+    packageInfo.version = packageInfo.version.replace(/-.*$/, '')
+
+    targetNuspecPath = path.join(buildDir, 'atom.nuspec')
+    grunt.file.write(targetNuspecPath, _.template(inputTemplate, packageInfo))
+
+    cmd = 'build/windows/nuget.exe'
+    args = ['pack', targetNuspecPath, '-BasePath', atomDir, '-OutputDirectory', buildDir]
+
+    spawn {cmd, args}, (error, result, code) ->
+      return done(error) if error?
+
+      pkgs = pkg for pkg in fs.readdirSync(buildDir) when path.extname(pkg) is '.nupkg'
+
+      releasesDir = path.join(buildDir, 'Releases')
+
+      # NB: Gonna clear Releases for now, in the future we need to pull down
+      # the existing version
+      rm(releasesDir)
+
+      cmd = 'build/windows/update.com'
+      args = ['--releasify', path.join(buildDir, pkgs), '-r', releasesDir, '-g', 'build/windows/install-spinner.gif']
+      spawn {cmd, args}, (error, result, code) -> done(error)

build/tasks/docs-task.coffee

@@ -11,6 +11,7 @@ module.exports = (grunt) ->
     modulesPath = path.resolve(__dirname, '..', '..', 'node_modules')
     classes = {}
     fs.traverseTreeSync modulesPath, (modulePath) ->
+      return false if modulePath.match(/node_modules/g).length > 1 # dont need the dependencies of the dependencies
       return true unless path.basename(modulePath) is 'package.json'
       return true unless fs.isFileSync(modulePath)
 

build/tasks/install-task.coffee

@@ -3,6 +3,7 @@ path = require 'path'
 _ = require 'underscore-plus'
 fs = require 'fs-plus'
 runas = null
+temp = require 'temp'
 
 module.exports = (grunt) ->
   {cp, mkdir, rm} = require('./task-helpers')(grunt)
@@ -22,7 +23,11 @@ module.exports = (grunt) ->
     else if process.platform is 'darwin'
       rm installDir
       mkdir path.dirname(installDir)
-      cp shellAppDir, installDir
+
+      tempFolder = temp.path()
+      mkdir tempFolder
+      cp shellAppDir, tempFolder
+      fs.renameSync(tempFolder, installDir)
     else
       binDir = path.join(installDir, 'bin')
       shareDir = path.join(installDir, 'share', 'atom')

build/tasks/publish-build-task.coffee

@@ -28,7 +28,7 @@ module.exports = (gruntObject) ->
   grunt.registerTask 'prepare-docs', 'Move api.json to atom-api.json', ->
     docsOutputDir = grunt.config.get('docsOutputDir')
     buildDir = grunt.config.get('atom.buildDir')
-    cp  path.join(docsOutputDir, 'api.json'), path.join(buildDir, 'atom-api.json')
+    cp path.join(docsOutputDir, 'api.json'), path.join(buildDir, 'atom-api.json')
 
   grunt.registerTask 'upload-assets', 'Upload the assets to a GitHub release', ->
     done = @async()
@@ -45,16 +45,33 @@ module.exports = (gruntObject) ->
           uploadAssets(release, buildDir, assets, done)
 
 getAssets = ->
-  if process.platform is 'darwin'
-    [
-      {assetName: 'atom-mac.zip', sourcePath: 'Atom.app'}
-      {assetName: 'atom-mac-symbols.zip', sourcePath: 'Atom.breakpad.syms'}
-      {assetName: 'atom-api.json', sourcePath: 'atom-api.json'}
-    ]
-  else
-    [
-      {assetName: 'atom-windows.zip', sourcePath: 'Atom'}
-    ]
+  switch process.platform
+    when 'darwin'
+      [
+        {assetName: 'atom-mac.zip', sourcePath: 'Atom.app'}
+        {assetName: 'atom-mac-symbols.zip', sourcePath: 'Atom.breakpad.syms'}
+        {assetName: 'atom-api.json', sourcePath: 'atom-api.json'}
+      ]
+    when 'win32'
+      [
+        {assetName: 'atom-windows.zip', sourcePath: 'Atom'}
+      ]
+    when 'linux'
+      buildDir = grunt.config.get('atom.buildDir')
+      if process.arch is 'ia32'
+        arch = 'i386'
+      else
+        arch = 'amd64'
+      {version} = grunt.file.readJSON('package.json')
+      sourcePath = "#{buildDir}/atom-#{version}-#{arch}.deb"
+      assetName = "atom-#{arch}.deb"
+
+      {cp} = require('./task-helpers')(grunt)
+      cp sourcePath, path.join(buildDir, assetName)
+
+      [
+        {assetName, sourcePath}
+      ]
 
 logError = (message, error, details) ->
   grunt.log.error(message)

build/tasks/spec-task.coffee

@@ -109,7 +109,6 @@ module.exports = (grunt) ->
       grunt.log.error("[Error]".red + " #{failures.join(', ')} spec(s) failed") if failures.length > 0
 
       if process.platform is 'win32' and process.env.JANKY_SHA1
-        # Package specs are still flaky on Windows CI
-        done(!coreSpecFailed)
+        done()
       else
         done(!coreSpecFailed and failedPackages.length == 0)

build/tasks/task-helpers.coffee

@@ -53,8 +53,9 @@ module.exports = (grunt) ->
     proc = childProcess.spawn(options.cmd, options.args, options.opts)
     proc.stdout.on 'data', (data) -> stdout.push(data.toString())
     proc.stderr.on 'data', (data) -> stderr.push(data.toString())
+    proc.on 'error', (processError) -> error ?= processError
     proc.on 'close', (exitCode, signal) ->
-      error = new Error(signal) if exitCode != 0
+      error ?= new Error(signal) if exitCode != 0
       results = {stderr: stderr.join(''), stdout: stdout.join(''), code: exitCode}
       grunt.log.error results.stderr if exitCode != 0
       callback(error, results, exitCode)

build/windows/atom.nuspec.erb

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+    <metadata>
+        <id><%= name %></id>
+        <version><%= version %></version>
+        <authors>The Atom Community</authors>
+        <owners>The Atom Community</owners>
+        <iconUrl>https://raw.githubusercontent.com/atom/atom/master/resources/win/atom.ico</iconUrl>
+        <requireLicenseAcceptance>false</requireLicenseAcceptance>
+        <description><%= description %></description>
+    </metadata>
+    <files>
+        <file src="locales\**" target="lib\net45\locales" />
+        <file src="resources\**" target="lib\net45\resources" />
+        <file src="*.pak" target="lib\net45" />
+
+        <file src="atom.exe" target="lib\net45\atom.exe" />
+        <file src="atom.exe.gui" target="lib\net45\atom.exe.gui" />
+        <file src="chromiumcontent.dll" target="lib\net45\chromiumcontent.dll" />
+        <file src="d3dcompiler_43.dll" target="lib\net45\d3dcompiler_43.dll" />
+        <file src="ffmpegsumo.dll" target="lib\net45\ffmpegsumo.dll" />
+        <file src="icudtl.dat" target="lib\net45\icudtl.dat" />
+        <file src="libEGL.dll" target="lib\net45\libEGL.dll" />
+        <file src="libGLESv2.dll" target="lib\net45\libGLESv2.dll" />
+        <file src="LICENSE" target="lib\net45\LICENSE" />
+        <file src="msvcp120.dll" target="lib\net45\msvcp120.dll" />
+        <file src="msvcr120.dll" target="lib\net45\msvcr120.dll" />
+        <file src="vccorlib120.dll" target="lib\net45\vccorlib120.dll" />
+        <file src="version" target="lib\net45\version" />
+        <file src="xinput1_3.dll" target="lib\net45\xinput1_3.dll" />
+    </files>
+</package>

coffeelint.json

@@ -10,5 +10,8 @@
   },
   "no_interpolation_in_single_quotes": {
     "level": "error"
+  },
+  "no_debugger": {
+    "level": "error"
   }
 }

docs/advanced/configuration.md

@@ -48,15 +48,6 @@ but you can programmatically write to it with `atom.config.set`:
 atom.config.set("core.showInvisibles", true)
 ```
 
-You should never mutate the value of a config key, because that would circumvent
-the notification of observers. You can however use methods like `pushAtKeyPath`,
-`unshiftAtKeyPath`, and `removeAtKeyPath` to manipulate mutable config values.
-
-```coffeescript
-atom.config.pushAtKeyPath("core.disabledPackages", "wrap-guide")
-atom.config.removeAtKeyPath("core.disabledPackages", "terminal")
-```
-
 You can also use `setDefaults`, which will assign default values for keys that
 are always overridden by values assigned with `set`. Defaults are not written
 out to the the `config.json` file to prevent it from becoming cluttered.

docs/build-instructions/linux.md

@@ -33,26 +33,41 @@ Ubuntu LTS 12.04 64-bit is the recommended platform.
 
 If you have problems with permissions don't forget to prefix with `sudo`
 
-From the cloned repository directory:
+1. Clone the Atom repository:
 
- 1. Build:
+  ```sh
+  git clone https://github.com/atom/atom
+  cd atom
+  ```
 
-    ```sh
-    $ script/build
-    ```
-    This will create the atom application at `$TMPDIR/atom-build/Atom`.
- 2. Install the `atom` and `apm` commands to `/usr/local/bin` by executing:
+2. Checkout the latest Atom release:
 
-    ```sh
-    $ sudo script/grunt install
-    ```
- 3. *Optionally*, you may generate a `.deb` package at `$TMPDIR/atom-build`:
+  ```sh
+  git fetch
+  git checkout $(git describe --tags `git rev-list --tags --max-count=1`)
+  ```
 
-    ```sh
-    $ script/grunt mkdeb
-    ```
+3. Build Atom:
 
-Use the newly installed atom by restarting any running atom instances.
+  ```sh
+  script/build
+  ```
+
+  This will create the atom application at `$TMPDIR/atom-build/Atom`.
+
+4. Install the `atom` and `apm` commands to `/usr/local/bin` by executing:
+
+  ```sh
+  sudo script/grunt install
+  ```
+
+5. *Optionally*, you may generate a `.deb` package at `$TMPDIR/atom-build`:
+
+  ```sh
+  script/grunt mkdeb
+  ```
+
+Use the newly installed Atom by fully quitting Atom and then reopening.
 
 ## Advanced Options
 
@@ -88,7 +103,7 @@ this is the reason for this error you can issue
 and restart Atom.  If Atom now works fine, you can make this setting permanent:
 
   ```sh
-  echo 32768 > /proc/sys/fs/inotify/max_user_watches
+  echo 32768 | sudo tee -a /proc/sys/fs/inotify/max_user_watches
   ```
 
 See also https://github.com/atom/atom/issues/2082.
@@ -100,6 +115,15 @@ have Node.js installed, or node isn't identified as Node.js on your machine.
 If it's the latter, entering `sudo ln -s /usr/bin/nodejs /usr/bin/node` into
 your terminal may fix the issue.
 
+#### You can also use Alternatives
+
+On some variants (mostly Debian based distros) it's preferable for you to use
+Alternatives so that changes to the binary paths can be fixed or altered easily:
+
+```sh
+sudo update-alternatives --install /usr/bin/node node /usr/bin/nodejs 1 --slave /usr/bin/js js /usr/bin/nodejs
+```
+
 ### Linux build error reports in atom/atom
 * Use [this search](https://github.com/atom/atom/search?q=label%3Abuild-error+label%3Alinux&type=Issues)
   to get a list of reports about build errors on Linux.

docs/creating-a-package.md

@@ -321,6 +321,29 @@ extensions your grammar supports:
 ]
 ```
 
+## Adding Configuration Settings
+
+You can support config settings in your package that are editable in the
+settings view. Specify a `config` key in your package main:
+
+```coffeescript
+module.exports =
+  # Your config schema!
+  config:
+    someInt:
+      type: 'integer'
+      default: 23
+      minimum: 1
+  activate: (state) -> # ...
+  # ...
+```
+
+To define the configuration, we use [json schema][json-schema] which allows you
+to indicate the type your value should be, its default, etc.
+
+See the [Config API Docs](https://atom.io/docs/api/latest/Config) for more
+details specifying your configuration.
+
 ## Bundle External Resources
 
 It's common to ship external resources like images and fonts in the package, to
@@ -392,3 +415,4 @@ all the other available commands.
 [first-package]: your-first-package.html
 [convert-bundle]: converting-a-text-mate-bundle.html
 [convert-theme]: converting-a-text-mate-theme.html
+[json-schema]: http://json-schema.org/

dot-atom/init.coffee

@@ -11,4 +11,4 @@
 # atom.workspaceView.eachEditorView (editorView) ->
 #   editor = editorView.getEditor()
 #   if path.extname(editor.getPath()) is '.md'
-#     editor.setSoftWrap(true)
+#     editor.setSoftWrapped(true)

dot-atom/keymap.cson

@@ -13,6 +13,9 @@
 #   'enter': 'editor:newline'
 #
 # '.workspace':
-#   'ctrl-P': 'core:move-up'
+#   'ctrl-shift-p': 'core:move-up'
 #   'ctrl-p': 'core:move-down'
 #
+# You can find more information about keymaps in these guides:
+# * https://atom.io/docs/latest/customizing-atom#customizing-key-bindings
+# * https://atom.io/docs/latest/advanced/keymaps

exports/atom.coffee

@@ -1,9 +1,10 @@
 {Point, Range} = require 'text-buffer'
+{deprecate} = require 'grim'
 
 module.exports =
   BufferedNodeProcess: require '../src/buffered-node-process'
   BufferedProcess: require '../src/buffered-process'
-  Git: require '../src/git'
+  GitRepository: require '../src/git-repository'
   Point: Point
   Range: Range
 
@@ -15,7 +16,7 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
   module.exports.$ = $
   module.exports.$$ = $$
   module.exports.$$$ = $$$
-  module.exports.EditorView = require '../src/editor-view'
+  module.exports.TextEditorView = require '../src/text-editor-view'
   module.exports.ScrollView = require '../src/scroll-view'
   module.exports.SelectListView = require '../src/select-list-view'
   module.exports.Task = require '../src/task'
@@ -24,3 +25,11 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
   module.exports.Workspace = require '../src/workspace'
   module.exports.React = require 'react-atom-fork'
   module.exports.Reactionary = require 'reactionary-atom-fork'
+
+Object.defineProperty module.exports, 'Git', get: ->
+  deprecate "Please require `GitRepository` instead of `Git`: `{GitRepository} = require 'atom'`"
+  module.exports.GitRepository
+
+Object.defineProperty module.exports, 'EditorView', get: ->
+  deprecate "Please require `TextEditorView` instead of `EditorView`: `{TextEditorView} = require 'atom'`"
+  module.exports.TextEditorView

keymaps/darwin.cson

@@ -119,7 +119,7 @@
   'cmd-shift-right': 'editor:select-to-end-of-line'
   '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-a': 'editor:move-to-first-character-of-line'
   'ctrl-e': 'editor:move-to-end-of-line'
   'ctrl-k': 'editor:cut-to-end-of-line'
 
@@ -143,6 +143,8 @@
   # Sublime Parity
   'cmd-enter': 'editor:newline-below'
   'cmd-shift-enter': 'editor:newline-above'
+  'alt-enter': 'editor:newline'
+  'shift-enter': 'editor:newline'
   'cmd-]': 'editor:indent-selected-rows'
   'cmd-[': 'editor:outdent-selected-rows'
   'ctrl-cmd-up': 'editor:move-line-up'

menus/darwin.cson

@@ -18,6 +18,8 @@
       { type: 'separator' }
       { label: 'Install Shell Commands', command: 'window:install-shell-commands' }
       { type: 'separator' }
+      { label: 'Services', submenu: [] }
+      { type: 'separator' }
       { label: 'Hide Atom', command: 'application:hide' }
       { label: 'Hide Others', command: 'application:hide-other-applications' }
       { label: 'Show All', command: 'application:unhide-all-applications' }
@@ -194,11 +196,27 @@
 ]
 
 'context-menu':
-  '.overlayer':
-    'Undo': 'core:undo'
-    'Redo': 'core:redo'
-    'Cut': 'core:cut'
-    'Copy': 'core:copy'
-    'Paste': 'core:paste'
-    'Delete': 'core:delete'
-    'Select All': 'core:select-all'
+  '.overlayer': [
+    {label: 'Undo', command: 'core:undo'}
+    {label: 'Redo', command: 'core:redo'}
+    {type: 'separator'}
+    {label: 'Cut', command: 'core:cut'}
+    {label: 'Copy', command: 'core:copy'}
+    {label: 'Paste', command: 'core:paste'}
+    {label: 'Delete', command: 'core:delete'}
+    {label: 'Select All', command: 'core:select-all'}
+    {type: 'separator'}
+    {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'}
+  ]
+  '.pane': [
+    {type: 'separator'}
+    {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'}
+  ]

menus/linux.cson

@@ -85,6 +85,7 @@
       { label: 'Open Your Keymap', command: 'application:open-your-keymap' }
       { label: 'Open Your Snippets', command: 'application:open-your-snippets' }
       { label: 'Open Your Stylesheet', command: 'application:open-your-stylesheet' }
+      { type: 'separator' }
     ]
   }
 
@@ -152,11 +153,27 @@
 ]
 
 'context-menu':
-  '.overlayer':
-    'Undo': 'core:undo'
-    'Redo': 'core:redo'
-    'Cut': 'core:cut'
-    'Copy': 'core:copy'
-    'Paste': 'core:paste'
-    'Delete': 'core:delete'
-    'Select All': 'core:select-all'
+  '.overlayer': [
+    {label: 'Undo', command: 'core:undo'}
+    {label: 'Redo', command: 'core:redo'}
+    {type: 'separator'}
+    {label: 'Cut', command: 'core:cut'}
+    {label: 'Copy', command: 'core:copy'}
+    {label: 'Paste', command: 'core:paste'}
+    {label: 'Delete', command: 'core:delete'}
+    {label: 'Select All', command: 'core:select-all'}
+    {type: 'separator'}
+    {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'}
+  ]
+  '.pane': [
+    {type: 'separator'}
+    {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'}
+  ]

menus/win32.cson

@@ -33,8 +33,8 @@
       { label: '&Undo', command: 'core:undo' }
       { label: '&Redo', command: 'core:redo' }
       { type: 'separator' }
-      { label: '&Cut', command: 'core:cut' }
-      { label: 'C&opy', command: 'core:copy' }
+      { label: 'Cu&t', command: 'core:cut' }
+      { label: '&Copy', command: 'core:copy' }
       { label: 'Copy Pat&h', command: 'editor:copy-path' }
       { label: '&Paste', command: 'core:paste' }
       { label: 'Select &All', command: 'core:select-all' }
@@ -171,11 +171,27 @@
 ]
 
 'context-menu':
-  '.overlayer':
-    'Undo': 'core:undo'
-    'Redo': 'core:redo'
-    'Cut': 'core:cut'
-    'Copy': 'core:copy'
-    'Paste': 'core:paste'
-    'Delete': 'core:delete'
-    'Select All': 'core:select-all'
+  '.overlayer': [
+    {label: 'Undo', command: 'core:undo'}
+    {label: 'Redo', command: 'core:redo'}
+    {type: 'separator'}
+    {label: 'Cut', command: 'core:cut'}
+    {label: 'Copy', command: 'core:copy'}
+    {label: 'Paste', command: 'core:paste'}
+    {label: 'Delete', command: 'core:delete'}
+    {label: 'Select All', command: 'core:select-all'}
+    {type: 'separator'}
+    {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'}
+  ]
+  '.pane': [
+    {type: 'separator'}
+    {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'}
+  ]

package.json

@@ -1,7 +1,7 @@
 {
   "name": "atom",
   "productName": "Atom",
-  "version": "0.125.0",
+  "version": "0.134.0",
   "description": "A hackable text editor for the 21st Century.",
   "main": "./src/browser/main.js",
   "repository": {
@@ -17,128 +17,128 @@
       "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
     }
   ],
-  "atomShellVersion": "0.15.9",
+  "atomShellVersion": "0.17.1",
   "dependencies": {
     "async": "0.2.6",
-    "atom-keymap": "^2.0.5",
+    "atom-keymap": "^2.2.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",
     "emissary": "^1.3.1",
-    "event-kit": "0.5.0",
-    "first-mate": "^2.0.5",
-    "fs-plus": "^2.2.6",
+    "event-kit": "0.7.2",
+    "first-mate": "^2.2.0",
+    "fs-plus": "^2.3.1",
     "fstream": "0.1.24",
     "fuzzaldrin": "^2.1",
     "git-utils": "^2.1.4",
     "grim": "0.12.0",
     "guid": "0.0.10",
     "jasmine-tagged": "^1.1.2",
-    "less-cache": "0.14.0",
+    "less-cache": "0.15.0",
     "mixto": "^1",
     "mkdirp": "0.3.5",
     "nslog": "^1.0.1",
     "oniguruma": "^3.0.4",
     "optimist": "0.4.0",
-    "pathwatcher": "^2.0.10",
+    "pathwatcher": "^2.1.3",
     "property-accessors": "^1",
     "q": "^1.0.1",
     "random-words": "0.0.1",
     "react-atom-fork": "^0.11.1",
     "reactionary-atom-fork": "^1.0.0",
     "runas": "1.0.1",
-    "scandal": "1.0.0",
+    "scandal": "1.0.2",
     "scoped-property-store": "^0.9.0",
     "scrollbar-style": "^1.0.2",
     "season": "^1.0.2",
     "semver": "1.1.4",
     "serializable": "^1",
-    "space-pen": "3.4.6",
+    "space-pen": "3.4.7",
     "temp": "0.7.0",
-    "text-buffer": "^3.2.0",
+    "text-buffer": "^3.2.6",
     "theorist": "^1.0.2",
     "underscore-plus": "^1.5.1",
     "vm-compatibility-layer": "0.1.0"
   },
   "packageDependencies": {
     "atom-dark-syntax": "0.19.0",
-    "atom-dark-ui": "0.34.0",
+    "atom-dark-ui": "0.35.0",
     "atom-light-syntax": "0.20.0",
-    "atom-light-ui": "0.29.0",
+    "atom-light-ui": "0.30.0",
     "base16-tomorrow-dark-theme": "0.21.0",
     "base16-tomorrow-light-theme": "0.4.0",
     "solarized-dark-syntax": "0.22.0",
     "solarized-light-syntax": "0.12.0",
-    "archive-view": "0.36.0",
-    "autocomplete": "0.31.0",
+    "archive-view": "0.37.0",
+    "autocomplete": "0.32.0",
     "autoflow": "0.18.0",
-    "autosave": "0.15.0",
-    "background-tips": "0.16.0",
+    "autosave": "0.17.0",
+    "background-tips": "0.17.0",
     "bookmarks": "0.28.0",
-    "bracket-matcher": "0.54.0",
-    "command-palette": "0.24.0",
+    "bracket-matcher": "0.61.0",
+    "command-palette": "0.26.0",
     "deprecation-cop": "0.10.0",
     "dev-live-reload": "0.34.0",
     "exception-reporting": "0.20.0",
     "feedback": "0.33.0",
-    "find-and-replace": "0.134.0",
+    "find-and-replace": "0.139.0",
     "fuzzy-finder": "0.58.0",
     "git-diff": "0.39.0",
     "go-to-line": "0.25.0",
-    "grammar-selector": "0.29.0",
-    "image-view": "0.36.0",
+    "grammar-selector": "0.34.0",
+    "image-view": "0.37.0",
     "incompatible-packages": "0.9.0",
-    "keybinding-resolver": "0.19.0",
+    "keybinding-resolver": "0.20.0",
     "link": "0.25.0",
-    "markdown-preview": "0.101.0",
-    "metrics": "0.33.0",
+    "markdown-preview": "0.103.0",
+    "metrics": "0.36.0",
     "open-on-github": "0.30.0",
     "package-generator": "0.31.0",
     "release-notes": "0.36.0",
-    "settings-view": "0.142.0",
-    "snippets": "0.51.0",
+    "settings-view": "0.149.0",
+    "snippets": "0.53.0",
     "spell-check": "0.42.0",
-    "status-bar": "0.44.0",
+    "status-bar": "0.45.0",
     "styleguide": "0.30.0",
-    "symbols-view": "0.63.0",
-    "tabs": "0.50.0",
+    "symbols-view": "0.66.0",
+    "tabs": "0.54.0",
     "timecop": "0.22.0",
-    "tree-view": "0.114.0",
+    "tree-view": "0.127.0",
     "update-package-dependencies": "0.6.0",
     "welcome": "0.18.0",
     "whitespace": "0.25.0",
-    "wrap-guide": "0.21.0",
+    "wrap-guide": "0.22.0",
     "language-c": "0.28.0",
-    "language-coffee-script": "0.30.0",
+    "language-coffee-script": "0.35.0",
     "language-css": "0.17.0",
-    "language-gfm": "0.48.0",
+    "language-gfm": "0.50.0",
     "language-git": "0.9.0",
     "language-go": "0.17.0",
-    "language-html": "0.25.0",
+    "language-html": "0.26.0",
     "language-hyperlink": "0.12.0",
     "language-java": "0.11.0",
-    "language-javascript": "0.39.0",
+    "language-javascript": "0.40.0",
     "language-json": "0.8.0",
     "language-less": "0.15.0",
     "language-make": "0.12.0",
     "language-mustache": "0.10.0",
     "language-objective-c": "0.11.0",
     "language-perl": "0.9.0",
-    "language-php": "0.15.0",
+    "language-php": "0.16.0",
     "language-property-list": "0.7.0",
     "language-python": "0.19.0",
-    "language-ruby": "0.35.0",
+    "language-ruby": "0.38.0",
     "language-ruby-on-rails": "0.18.0",
-    "language-sass": "0.21.0",
+    "language-sass": "0.22.0",
     "language-shellscript": "0.8.0",
     "language-source": "0.8.0",
-    "language-sql": "0.10.0",
+    "language-sql": "0.11.0",
     "language-text": "0.6.0",
-    "language-todo": "0.11.0",
+    "language-todo": "0.12.0",
     "language-toml": "0.12.0",
-    "language-xml": "0.19.0",
+    "language-xml": "0.22.0",
     "language-yaml": "0.17.0"
   },
   "private": true,

resources/linux/Atom.desktop.in

@@ -5,4 +5,5 @@ Exec=<%= installDir %>/share/atom/atom %U
 Icon=<%= iconName %>
 Type=Application
 StartupNotify=true
-Categories=GNOME;GTK;Utility;TextEditor;
+Categories=GNOME;GTK;Utility;TextEditor;Development;
+MimeType=text/plain;

resources/linux/debian/control.in

@@ -1,8 +1,10 @@
 Package: <%= name %>
 Version: <%= version %>
+Depends: python (>= 2.6), libc6
 Section: <%= section %>
 Priority: optional
 Architecture: <%= arch %>
 Installed-Size: <%= installedSize %>
 Maintainer: <%= maintainer %>
 Description: <%= description %>
+ Atom is a free and open source text editor that is modern, approachable, and hackable to the core.

resources/linux/debian/lintian-overrides

@@ -0,0 +1,7 @@
+atom: arch-dependent-file-in-usr-share
+atom: changelog-file-missing-in-native-package
+atom: copyright-file-contains-full-apache-2-license
+atom: copyright-should-refer-to-common-license-file-for-apache-2
+atom: embedded-library
+atom: package-installs-python-bytecode
+atom: unstripped-binary-or-object

script/cibuild

@@ -5,9 +5,6 @@ var path = require('path');
 
 process.chdir(path.dirname(__dirname));
 
-if (process.platform == 'linux')
-  throw new Error('cibuild can not run on linux yet!');
-
 var homeDir = process.platform == 'win32' ? process.env.USERPROFILE : process.env.HOME;
 
 function loadEnvironmentVariables(filePath) {
@@ -27,7 +24,7 @@ function loadEnvironmentVariables(filePath) {
 function readEnvironmentVariables() {
   if (process.platform === 'win32')
     loadEnvironmentVariables(path.resolve('/jenkins/config/atomcredentials'));
-  else {
+  else if (process.platform === 'darwin') {
     loadEnvironmentVariables('/var/lib/jenkins/config/atomcredentials');
     loadEnvironmentVariables('/var/lib/jenkins/config/xcodekeychain');
   }

script/cibuild-atom-linux

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -e
+
+export ATOM_ACCESS_TOKEN=$BUILD_ATOM_LINUX_ACCESS_TOKEN
+
+if [ -d /usr/local/share/nodenv ]; then
+  export NODENV_ROOT=/usr/local/share/nodenv
+  export PATH=/usr/local/share/nodenv/bin:/usr/local/share/nodenv/shims:$PATH
+  export NODENV_VERSION="v0.10.21"
+fi
+
+script/cibuild

script/mkdeb

@@ -16,7 +16,7 @@ DEB_PATH="$6"
 FILE_MODE=755
 
 TARGET_ROOT="`mktemp -d`"
-chmod 755 "$TARGET_ROOT"
+chmod $FILE_MODE "$TARGET_ROOT"
 TARGET="$TARGET_ROOT/atom-$VERSION-$ARCH"
 
 mkdir -m $FILE_MODE -p "$TARGET/usr"
@@ -31,6 +31,17 @@ cp "$DESKTOP_FILE" "$TARGET/usr/share/applications"
 mkdir -m $FILE_MODE -p "$TARGET/usr/share/pixmaps"
 cp "$ICON_FILE" "$TARGET/usr/share/pixmaps"
 
-dpkg-deb -b "$TARGET"
+# Copy generated LICENSE.md to /usr/share/doc/atom/copyright
+mkdir -m $FILE_MODE -p "$TARGET/usr/share/doc/atom"
+cp "$TARGET/usr/share/atom/resources/app/LICENSE.md" "$TARGET/usr/share/doc/atom/copyright"
+
+# Add lintian overrides
+mkdir -m $FILE_MODE -p "$TARGET/usr/share/lintian/overrides"
+cp "$ROOT/resources/linux/debian/lintian-overrides" "$TARGET/usr/share/lintian/overrides/atom"
+
+# Remove executable bit from .node files
+find "$TARGET" -type f -name "*.node" -exec chmod a-x {} \;
+
+fakeroot dpkg-deb -b "$TARGET"
 mv "$TARGET_ROOT/atom-$VERSION-$ARCH.deb" "$DEB_PATH"
-rm -rf $TARGET_ROOT
+rm -rf "$TARGET_ROOT"

script/utils/verify-requirements.js

@@ -31,7 +31,7 @@ function verifyNode(cb) {
   var nodeMajorVersion = +versionArray[0];
   var nodeMinorVersion = +versionArray[1];
   if (nodeMajorVersion === 0 && nodeMinorVersion < 10) {
-    error = "node v0.10 is required to build Atom.";
+    error = "node v0.10 is required to build Atom, node " + nodeVersion + " is installed.";
     cb(error);
   }
   else {

spec/atom-reporter.coffee

@@ -76,6 +76,9 @@ class AtomReporter extends View
     @addSpecs(specs)
     $(document.body).append this
 
+    @on 'click', '.stack-trace', ->
+      $(this).toggleClass('expanded')
+
   reportRunnerResults: (runner) ->
     @updateSpecCounts()
     @status.addClass('alert-success').removeClass('alert-info') if @failedCount is 0

spec/atom-spec.coffee

@@ -6,532 +6,24 @@ ThemeManager = require '../src/theme-manager'
 
 describe "the `atom` global", ->
   beforeEach ->
-    atom.workspaceView = new WorkspaceView
+    atom.workspaceView = atom.workspace.getView(atom.workspace).__spacePenView
 
-  describe "package lifecycle methods", ->
-    describe ".loadPackage(name)", ->
-      it "continues if the package has an invalid package.json", ->
-        spyOn(console, 'warn')
-        atom.config.set("core.disabledPackages", [])
-        expect(-> atom.packages.loadPackage("package-with-broken-package-json")).not.toThrow()
-
-      it "continues if the package has an invalid keymap", ->
-        atom.config.set("core.disabledPackages", [])
-        expect(-> atom.packages.loadPackage("package-with-broken-keymap")).not.toThrow()
-
-    describe ".unloadPackage(name)", ->
-      describe "when the package is active", ->
-        it "throws an error", ->
-          pack = null
-          waitsForPromise ->
-            atom.packages.activatePackage('package-with-main').then (p) -> pack = p
-
-          runs ->
-            expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
-            expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
-            expect( -> atom.packages.unloadPackage(pack.name)).toThrow()
-            expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
-            expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
-
-      describe "when the package is not loaded", ->
-        it "throws an error", ->
-          expect(atom.packages.isPackageLoaded('unloaded')).toBeFalsy()
-          expect( -> atom.packages.unloadPackage('unloaded')).toThrow()
-          expect(atom.packages.isPackageLoaded('unloaded')).toBeFalsy()
-
-      describe "when the package is loaded", ->
-        it "no longers reports it as being loaded", ->
-          pack = atom.packages.loadPackage('package-with-main')
-          expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
-          atom.packages.unloadPackage(pack.name)
-          expect(atom.packages.isPackageLoaded(pack.name)).toBeFalsy()
-
-    describe ".activatePackage(id)", ->
-      describe "atom packages", ->
-        describe "when called multiple times", ->
-          it "it only calls activate on the package once", ->
-            spyOn(Package.prototype, 'activateNow').andCallThrough()
-            atom.packages.activatePackage('package-with-index')
-            atom.packages.activatePackage('package-with-index')
-
-            waitsForPromise ->
-              atom.packages.activatePackage('package-with-index')
-
-            runs ->
-              expect(Package.prototype.activateNow.callCount).toBe 1
-
-        describe "when the package has a main module", ->
-          describe "when the metadata specifies a main module path˜", ->
-            it "requires the module at the specified path", ->
-              mainModule = require('./fixtures/packages/package-with-main/main-module')
-              spyOn(mainModule, 'activate')
-              pack = null
-              waitsForPromise ->
-                atom.packages.activatePackage('package-with-main').then (p) -> pack = p
-
-              runs ->
-                expect(mainModule.activate).toHaveBeenCalled()
-                expect(pack.mainModule).toBe mainModule
-
-          describe "when the metadata does not specify a main module", ->
-            it "requires index.coffee", ->
-              indexModule = require('./fixtures/packages/package-with-index/index')
-              spyOn(indexModule, 'activate')
-              pack = null
-              waitsForPromise ->
-                atom.packages.activatePackage('package-with-index').then (p) -> pack = p
-
-              runs ->
-                expect(indexModule.activate).toHaveBeenCalled()
-                expect(pack.mainModule).toBe indexModule
-
-          it "assigns config defaults from the module", ->
-            expect(atom.config.get('package-with-config-defaults.numbers.one')).toBeUndefined()
-
-            waitsForPromise ->
-              atom.packages.activatePackage('package-with-config-defaults')
-
-            runs ->
-              expect(atom.config.get('package-with-config-defaults.numbers.one')).toBe 1
-              expect(atom.config.get('package-with-config-defaults.numbers.two')).toBe 2
-
-          describe "when the package metadata includes activation events", ->
-            [mainModule, promise] = []
-
-            beforeEach ->
-              mainModule = require './fixtures/packages/package-with-activation-events/index'
-              spyOn(mainModule, 'activate').andCallThrough()
-              spyOn(Package.prototype, 'requireMainModule').andCallThrough()
-
-              promise = atom.packages.activatePackage('package-with-activation-events')
-
-            it "defers requiring/activating the main module until an activation event bubbles to the root view", ->
-              expect(promise.isFulfilled()).not.toBeTruthy()
-              atom.workspaceView.trigger 'activation-event'
-
-              waitsForPromise ->
-                promise
-
-            it "triggers the activation event on all handlers registered during activation", ->
-              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'
-              spyOn(mainModule, 'activate').andCallThrough()
-
-              waitsForPromise ->
-                atom.packages.activatePackage('package-with-empty-activation-events')
-
-              runs ->
-                expect(mainModule.activate.callCount).toBe 1
-
-        describe "when the package has no main module", ->
-          it "does not throw an exception", ->
-            spyOn(console, "error")
-            spyOn(console, "warn").andCallThrough()
-            expect(-> atom.packages.activatePackage('package-without-module')).not.toThrow()
-            expect(console.error).not.toHaveBeenCalled()
-            expect(console.warn).not.toHaveBeenCalled()
-
-        it "passes the activate method the package's previously serialized state if it exists", ->
-          pack = null
-          waitsForPromise ->
-            atom.packages.activatePackage("package-with-serialization").then (p) -> pack = p
-
-          runs ->
-            expect(pack.mainModule.someNumber).not.toBe 77
-            pack.mainModule.someNumber = 77
-            atom.packages.deactivatePackage("package-with-serialization")
-            spyOn(pack.mainModule, 'activate').andCallThrough()
-            atom.packages.activatePackage("package-with-serialization")
-            expect(pack.mainModule.activate).toHaveBeenCalledWith({someNumber: 77})
-
-        it "logs warning instead of throwing an exception if the package fails to load", ->
-          atom.config.set("core.disabledPackages", [])
-          spyOn(console, "warn")
-          expect(-> atom.packages.activatePackage("package-that-throws-an-exception")).not.toThrow()
-          expect(console.warn).toHaveBeenCalled()
-
-        describe "keymap loading", ->
-          describe "when the metadata does not contain a 'keymaps' manifest", ->
-            it "loads all the .cson/.json files in the keymaps directory", ->
-              element1 = $$ -> @div class: 'test-1'
-              element2 = $$ -> @div class: 'test-2'
-              element3 = $$ -> @div class: 'test-3'
-
-              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.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.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])).toHaveLength 0
-
-              atom.packages.activatePackage("package-with-keymaps-manifest")
-
-              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 ->
-            atom.contextMenu.definitions = []
-            atom.menu.template = []
-
-          describe "when the metadata does not contain a 'menus' manifest", ->
-            it "loads all the .cson/.json files in the menus directory", ->
-              element = ($$ -> @div class: 'test-1')[0]
-
-              expect(atom.contextMenu.definitionsForElement(element)).toEqual []
-
-              atom.packages.activatePackage("package-with-menus")
-
-              expect(atom.menu.template.length).toBe 2
-              expect(atom.menu.template[0].label).toBe "Second to Last"
-              expect(atom.menu.template[1].label).toBe "Last"
-              expect(atom.contextMenu.definitionsForElement(element)[0].label).toBe "Menu item 1"
-              expect(atom.contextMenu.definitionsForElement(element)[1].label).toBe "Menu item 2"
-              expect(atom.contextMenu.definitionsForElement(element)[2].label).toBe "Menu item 3"
-
-          describe "when the metadata contains a 'menus' manifest", ->
-            it "loads only the menus specified by the manifest, in the specified order", ->
-              element = ($$ -> @div class: 'test-1')[0]
-
-              expect(atom.contextMenu.definitionsForElement(element)).toEqual []
-
-              atom.packages.activatePackage("package-with-menus-manifest")
-
-              expect(atom.menu.template[0].label).toBe "Second to Last"
-              expect(atom.menu.template[1].label).toBe "Last"
-              expect(atom.contextMenu.definitionsForElement(element)[0].label).toBe "Menu item 2"
-              expect(atom.contextMenu.definitionsForElement(element)[1].label).toBe "Menu item 1"
-              expect(atom.contextMenu.definitionsForElement(element)[2]).toBeUndefined()
-
-        describe "stylesheet loading", ->
-          describe "when the metadata contains a 'stylesheets' manifest", ->
-            it "loads stylesheets from the stylesheets directory as specified by the manifest", ->
-              one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css")
-              two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less")
-              three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css")
-
-              one = atom.themes.stringToId(one)
-              two = atom.themes.stringToId(two)
-              three = atom.themes.stringToId(three)
-
-              expect(atom.themes.stylesheetElementForId(one)).not.toExist()
-              expect(atom.themes.stylesheetElementForId(two)).not.toExist()
-              expect(atom.themes.stylesheetElementForId(three)).not.toExist()
-
-              atom.packages.activatePackage("package-with-stylesheets-manifest")
-
-              expect(atom.themes.stylesheetElementForId(one)).toExist()
-              expect(atom.themes.stylesheetElementForId(two)).toExist()
-              expect(atom.themes.stylesheetElementForId(three)).not.toExist()
-              expect($('#jasmine-content').css('font-size')).toBe '1px'
-
-          describe "when the metadata does not contain a 'stylesheets' manifest", ->
-            it "loads all stylesheets from the stylesheets directory", ->
-              one = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/1.css")
-              two = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/2.less")
-              three = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/3.css")
-
-
-              one = atom.themes.stringToId(one)
-              two = atom.themes.stringToId(two)
-              three = atom.themes.stringToId(three)
-
-              expect(atom.themes.stylesheetElementForId(one)).not.toExist()
-              expect(atom.themes.stylesheetElementForId(two)).not.toExist()
-              expect(atom.themes.stylesheetElementForId(three)).not.toExist()
-
-              atom.packages.activatePackage("package-with-stylesheets")
-              expect(atom.themes.stylesheetElementForId(one)).toExist()
-              expect(atom.themes.stylesheetElementForId(two)).toExist()
-              expect(atom.themes.stylesheetElementForId(three)).toExist()
-              expect($('#jasmine-content').css('font-size')).toBe '3px'
-
-        describe "grammar loading", ->
-          it "loads the package's grammars", ->
-            waitsForPromise ->
-              atom.packages.activatePackage('package-with-grammars')
-
-            runs ->
-              expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Alot'
-              expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Alittle'
-
-        describe "scoped-property loading", ->
-          it "loads the scoped properties", ->
-            waitsForPromise ->
-              atom.packages.activatePackage("package-with-scoped-properties")
-
-            runs ->
-              expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
-
-      describe "converted textmate packages", ->
-        it "loads the package's grammars", ->
-          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-
-          waitsForPromise ->
-            atom.packages.activatePackage('language-ruby')
-
-          runs ->
-            expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
-
-        it "loads the translated scoped properties", ->
-          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
-
-          waitsForPromise ->
-            atom.packages.activatePackage('language-ruby')
-
-          runs ->
-            expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBe '# '
-
-    describe ".deactivatePackage(id)", ->
-      describe "atom packages", ->
-        it "calls `deactivate` on the package's main module if activate was successful", ->
-          pack = null
-          waitsForPromise ->
-            atom.packages.activatePackage("package-with-deactivate").then (p) -> pack = p
-
-          runs ->
-            expect(atom.packages.isPackageActive("package-with-deactivate")).toBeTruthy()
-            spyOn(pack.mainModule, 'deactivate').andCallThrough()
-
-            atom.packages.deactivatePackage("package-with-deactivate")
-            expect(pack.mainModule.deactivate).toHaveBeenCalled()
-            expect(atom.packages.isPackageActive("package-with-module")).toBeFalsy()
-
-            spyOn(console, 'warn')
-
-          badPack = null
-          waitsForPromise ->
-            atom.packages.activatePackage("package-that-throws-on-activate").then (p) -> badPack = p
-
-          runs ->
-            expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeTruthy()
-            spyOn(badPack.mainModule, 'deactivate').andCallThrough()
-
-            atom.packages.deactivatePackage("package-that-throws-on-activate")
-            expect(badPack.mainModule.deactivate).not.toHaveBeenCalled()
-            expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeFalsy()
-
-        it "does not serialize packages that have not been activated called on their main module", ->
-          spyOn(console, 'warn')
-          badPack = null
-          waitsForPromise ->
-            atom.packages.activatePackage("package-that-throws-on-activate").then (p) -> badPack = p
-
-          runs ->
-            spyOn(badPack.mainModule, 'serialize').andCallThrough()
-
-            atom.packages.deactivatePackage("package-that-throws-on-activate")
-            expect(badPack.mainModule.serialize).not.toHaveBeenCalled()
-
-        it "absorbs exceptions that are thrown by the package module's serialize methods", ->
-          spyOn(console, 'error')
-
-          waitsForPromise ->
-            atom.packages.activatePackage('package-with-serialize-error')
-
-          waitsForPromise ->
-            atom.packages.activatePackage('package-with-serialization')
-
-          runs ->
-            atom.packages.deactivatePackages()
-            expect(atom.packages.packageStates['package-with-serialize-error']).toBeUndefined()
-            expect(atom.packages.packageStates['package-with-serialization']).toEqual someNumber: 1
-            expect(console.error).toHaveBeenCalled()
-
-        it "removes the package's grammars", ->
-          waitsForPromise ->
-            atom.packages.activatePackage('package-with-grammars')
-
-          runs ->
-            atom.packages.deactivatePackage('package-with-grammars')
-            expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Null Grammar'
-            expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Null Grammar'
-
-        it "removes the package's keymaps", ->
-          waitsForPromise ->
-            atom.packages.activatePackage('package-with-keymaps')
-
-          runs ->
-            atom.packages.deactivatePackage('package-with-keymaps')
-            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 ->
-            atom.packages.activatePackage('package-with-stylesheets')
-
-          runs ->
-            atom.packages.deactivatePackage('package-with-stylesheets')
-            one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css")
-            two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less")
-            three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css")
-            expect(atom.themes.stylesheetElementForId(one)).not.toExist()
-            expect(atom.themes.stylesheetElementForId(two)).not.toExist()
-            expect(atom.themes.stylesheetElementForId(three)).not.toExist()
-
-        it "removes the package's scoped-properties", ->
-          waitsForPromise ->
-            atom.packages.activatePackage("package-with-scoped-properties")
-
-          runs ->
-            expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
-            atom.packages.deactivatePackage("package-with-scoped-properties")
-            expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBeUndefined()
-
-      describe "textmate packages", ->
-        it "removes the package's grammars", ->
-          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-
-          waitsForPromise ->
-            atom.packages.activatePackage('language-ruby')
-
-          runs ->
-            expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
-            atom.packages.deactivatePackage('language-ruby')
-            expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-
-        it "removes the package's scoped properties", ->
-          waitsForPromise ->
-            atom.packages.activatePackage('language-ruby')
-
-          runs ->
-            atom.packages.deactivatePackage('language-ruby')
-            expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
-
-    describe ".activate()", ->
-      packageActivator = null
-      themeActivator = null
+  describe 'window sizing methods', ->
+    describe '::getPosition and ::setPosition', ->
+      it 'sets the position of the window, and can retrieve the position just set', ->
+        atom.setPosition(22, 45)
+        expect(atom.getPosition()).toEqual x: 22, y: 45
 
+    describe '::getSize and ::setSize', ->
+      originalSize = null
       beforeEach ->
-        spyOn(console, 'warn')
-        atom.packages.loadPackages()
-
-        loadedPackages = atom.packages.getLoadedPackages()
-        expect(loadedPackages.length).toBeGreaterThan 0
-
-        packageActivator = spyOn(atom.packages, 'activatePackages')
-        themeActivator = spyOn(atom.themes, 'activatePackages')
-
+        originalSize = atom.getSize()
       afterEach ->
-        atom.packages.unloadPackages()
+        atom.setSize(originalSize.width, originalSize.height)
 
-        Syntax = require '../src/syntax'
-        atom.syntax = window.syntax = new Syntax()
-
-      it "activates all the packages, and none of the themes", ->
-        atom.packages.activate()
-
-        expect(packageActivator).toHaveBeenCalled()
-        expect(themeActivator).toHaveBeenCalled()
-
-        packages = packageActivator.mostRecentCall.args[0]
-        expect(['atom', 'textmate']).toContain(pack.getType()) for pack in packages
-
-        themes = themeActivator.mostRecentCall.args[0]
-        expect(['theme']).toContain(theme.getType()) for theme in themes
-
-    describe ".enablePackage() and disablePackage()", ->
-      describe "with packages", ->
-        it ".enablePackage() enables a disabled package", ->
-          packageName = 'package-with-main'
-          atom.config.pushAtKeyPath('core.disabledPackages', packageName)
-          atom.packages.observeDisabledPackages()
-          expect(atom.config.get('core.disabledPackages')).toContain packageName
-
-          pack = atom.packages.enablePackage(packageName)
-          loadedPackages = atom.packages.getLoadedPackages()
-          activatedPackages = null
-          waitsFor ->
-            activatedPackages = atom.packages.getActivePackages()
-            activatedPackages.length > 0
-
-          runs ->
-            expect(loadedPackages).toContain(pack)
-            expect(activatedPackages).toContain(pack)
-            expect(atom.config.get('core.disabledPackages')).not.toContain packageName
-
-        it ".disablePackage() disables an enabled package", ->
-          packageName = 'package-with-main'
-          waitsForPromise ->
-            atom.packages.activatePackage(packageName)
-
-          runs ->
-            atom.packages.observeDisabledPackages()
-            expect(atom.config.get('core.disabledPackages')).not.toContain packageName
-
-            pack = atom.packages.disablePackage(packageName)
-
-            activatedPackages = atom.packages.getActivePackages()
-            expect(activatedPackages).not.toContain(pack)
-            expect(atom.config.get('core.disabledPackages')).toContain packageName
-
-      describe "with themes", ->
-        reloadedHandler = null
-
-        beforeEach ->
-          waitsForPromise ->
-            atom.themes.activateThemes()
-
-        afterEach ->
-          atom.themes.deactivateThemes()
-
-        it ".enablePackage() and .disablePackage() enables and disables a theme", ->
-          packageName = 'theme-with-package-file'
-
-          expect(atom.config.get('core.themes')).not.toContain packageName
-          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
-
-          # enabling of theme
-          pack = atom.packages.enablePackage(packageName)
-
-          waitsFor ->
-            pack in atom.packages.getActivePackages()
-
-          runs ->
-            expect(atom.config.get('core.themes')).toContain packageName
-            expect(atom.config.get('core.disabledPackages')).not.toContain packageName
-
-            reloadedHandler = jasmine.createSpy('reloadedHandler')
-            reloadedHandler.reset()
-            atom.themes.on('reloaded', reloadedHandler)
-
-            pack = atom.packages.disablePackage(packageName)
-
-          waitsFor ->
-            reloadedHandler.callCount is 1
-
-          runs ->
-            expect(atom.packages.getActivePackages()).not.toContain pack
-            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
+      it 'sets the size of the window, and can retrieve the size just set', ->
+        atom.setSize(100, 400)
+        expect(atom.getSize()).toEqual width: 100, height: 400
 
   describe ".isReleasedVersion()", ->
     it "returns false if the version is a SHA and true otherwise", ->
@@ -555,3 +47,8 @@ describe "the `atom` global", ->
         [event, version, notes] = updateAvailableHandler.mostRecentCall.args
         expect(notes).toBe 'notes'
         expect(version).toBe 'version'
+
+  describe "loading default config", ->
+    it 'loads the default core config', ->
+      expect(atom.config.get('core.excludeVcsIgnoredPaths')).toBe true
+      expect(atom.config.get('editor.showInvisibles')).toBe false

spec/command-registry-spec.coffee

@@ -0,0 +1,191 @@
+CommandRegistry = require '../src/command-registry'
+
+describe "CommandRegistry", ->
+  [registry, parent, child, grandchild] = []
+
+  beforeEach ->
+    parent = document.createElement("div")
+    child = document.createElement("div")
+    grandchild = document.createElement("div")
+    parent.classList.add('parent')
+    child.classList.add('child')
+    grandchild.classList.add('grandchild')
+    child.appendChild(grandchild)
+    parent.appendChild(child)
+    document.querySelector('#jasmine-content').appendChild(parent)
+
+    registry = new CommandRegistry(parent)
+
+  describe "command dispatch", ->
+    it "invokes callbacks with selectors matching the target", ->
+      called = false
+      registry.add '.grandchild', 'command', (event) ->
+        expect(this).toBe grandchild
+        expect(event.type).toBe 'command'
+        expect(event.eventPhase).toBe Event.BUBBLING_PHASE
+        expect(event.target).toBe grandchild
+        expect(event.currentTarget).toBe grandchild
+        called = true
+
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(called).toBe true
+
+    it "invokes callbacks with selectors matching ancestors of the target", ->
+      calls = []
+
+      registry.add '.child', 'command', (event) ->
+        expect(this).toBe child
+        expect(event.target).toBe grandchild
+        expect(event.currentTarget).toBe child
+        calls.push('child')
+
+      registry.add '.parent', 'command', (event) ->
+        expect(this).toBe parent
+        expect(event.target).toBe grandchild
+        expect(event.currentTarget).toBe parent
+        calls.push('parent')
+
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual ['child', 'parent']
+
+    it "orders multiple matching listeners for an element by selector specificity", ->
+      child.classList.add('foo', 'bar')
+      calls = []
+
+      registry.add '.foo.bar', 'command', -> calls.push('.foo.bar')
+      registry.add '.foo', 'command', -> calls.push('.foo')
+      registry.add '.bar', 'command', -> calls.push('.bar') # specificity ties favor commands added later, like CSS
+
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual ['.foo.bar', '.bar', '.foo']
+
+    it "stops bubbling through ancestors when .stopPropagation() is called on the event", ->
+      calls = []
+
+      registry.add '.parent', 'command', -> calls.push('parent')
+      registry.add '.child', 'command', -> calls.push('child-2')
+      registry.add '.child', 'command', (event) -> calls.push('child-1'); event.stopPropagation()
+
+      dispatchedEvent = new CustomEvent('command', bubbles: true)
+      spyOn(dispatchedEvent, 'stopPropagation')
+      grandchild.dispatchEvent(dispatchedEvent)
+      expect(calls).toEqual ['child-1', 'child-2']
+      expect(dispatchedEvent.stopPropagation).toHaveBeenCalled()
+
+    it "stops invoking callbacks when .stopImmediatePropagation() is called on the event", ->
+      calls = []
+
+      registry.add '.parent', 'command', -> calls.push('parent')
+      registry.add '.child', 'command', -> calls.push('child-2')
+      registry.add '.child', 'command', (event) -> calls.push('child-1'); event.stopImmediatePropagation()
+
+      dispatchedEvent = new CustomEvent('command', bubbles: true)
+      spyOn(dispatchedEvent, 'stopImmediatePropagation')
+      grandchild.dispatchEvent(dispatchedEvent)
+      expect(calls).toEqual ['child-1']
+      expect(dispatchedEvent.stopImmediatePropagation).toHaveBeenCalled()
+
+    it "forwards .preventDefault() calls from the synthetic event to the original", ->
+      calls = []
+
+      registry.add '.child', 'command', (event) -> event.preventDefault()
+
+      dispatchedEvent = new CustomEvent('command', bubbles: true)
+      spyOn(dispatchedEvent, 'preventDefault')
+      grandchild.dispatchEvent(dispatchedEvent)
+      expect(dispatchedEvent.preventDefault).toHaveBeenCalled()
+
+    it "allows listeners to be removed via a disposable returned by ::add", ->
+      calls = []
+
+      disposable1 = registry.add '.parent', 'command', -> calls.push('parent')
+      disposable2 = registry.add '.child', 'command', -> calls.push('child')
+
+      disposable1.dispose()
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual ['child']
+
+      calls = []
+      disposable2.dispose()
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual []
+
+    it "allows multiple commands to be registered under one selector when called with an object", ->
+      calls = []
+
+      disposable = registry.add '.child',
+        'command-1': -> calls.push('command-1')
+        'command-2': -> calls.push('command-2')
+
+      grandchild.dispatchEvent(new CustomEvent('command-1', bubbles: true))
+      grandchild.dispatchEvent(new CustomEvent('command-2', bubbles: true))
+
+      expect(calls).toEqual ['command-1', 'command-2']
+
+      calls = []
+      disposable.dispose()
+      grandchild.dispatchEvent(new CustomEvent('command-1', bubbles: true))
+      grandchild.dispatchEvent(new CustomEvent('command-2', bubbles: true))
+      expect(calls).toEqual []
+
+  describe "::findCommands({target})", ->
+    it "returns commands that can be invoked on the target or its ancestors", ->
+      registry.add '.parent', 'namespace:command-1', ->
+      registry.add '.child', 'namespace:command-2', ->
+      registry.add '.grandchild', 'namespace:command-3', ->
+      registry.add '.grandchild.no-match', 'namespace:command-4', ->
+
+      expect(registry.findCommands(target: grandchild)[0..2]).toEqual [
+        {name: 'namespace:command-3', displayName: 'Namespace: Command 3'}
+        {name: 'namespace:command-2', displayName: 'Namespace: Command 2'}
+        {name: 'namespace:command-1', displayName: 'Namespace: Command 1'}
+      ]
+
+  describe "::dispatch(target, commandName)", ->
+    it "simulates invocation of the given command ", ->
+      called = false
+      registry.add '.grandchild', 'command', (event) ->
+        expect(this).toBe grandchild
+        expect(event.type).toBe 'command'
+        expect(event.eventPhase).toBe Event.BUBBLING_PHASE
+        expect(event.target).toBe grandchild
+        expect(event.currentTarget).toBe grandchild
+        called = true
+
+      registry.dispatch(grandchild, 'command')
+      expect(called).toBe true
+
+    it "returns a boolean indicating whether any listeners matched the command", ->
+      registry.add '.grandchild', 'command', ->
+
+      expect(registry.dispatch(grandchild, 'command')).toBe true
+      expect(registry.dispatch(grandchild, 'bogus')).toBe false
+      expect(registry.dispatch(parent, 'command')).toBe false
+
+  describe "::getSnapshot and ::restoreSnapshot", ->
+    it "removes all command handlers except for those in the snapshot", ->
+      registry.add '.parent', 'namespace:command-1', ->
+      registry.add '.child', 'namespace:command-2', ->
+      snapshot = registry.getSnapshot()
+      registry.add '.grandchild', 'namespace:command-3', ->
+
+      expect(registry.findCommands(target: grandchild)[0..2]).toEqual [
+        {name: 'namespace:command-3', displayName: 'Namespace: Command 3'}
+        {name: 'namespace:command-2', displayName: 'Namespace: Command 2'}
+        {name: 'namespace:command-1', displayName: 'Namespace: Command 1'}
+      ]
+
+      registry.restoreSnapshot(snapshot)
+
+      expect(registry.findCommands(target: grandchild)[0..1]).toEqual [
+        {name: 'namespace:command-2', displayName: 'Namespace: Command 2'}
+        {name: 'namespace:command-1', displayName: 'Namespace: Command 1'}
+      ]
+
+      registry.add '.grandchild', 'namespace:command-3', ->
+      registry.restoreSnapshot(snapshot)
+
+      expect(registry.findCommands(target: grandchild)[0..1]).toEqual [
+        {name: 'namespace:command-2', displayName: 'Namespace: Command 2'}
+        {name: 'namespace:command-1', displayName: 'Namespace: Command 1'}
+      ]

spec/config-spec.coffee

@@ -12,7 +12,7 @@ describe "Config", ->
 
   describe ".get(keyPath)", ->
     it "allows a key path's value to be read", ->
-      expect(atom.config.set("foo.bar.baz", 42)).toBe 42
+      expect(atom.config.set("foo.bar.baz", 42)).toBe true
       expect(atom.config.get("foo.bar.baz")).toBe 42
       expect(atom.config.get("bogus.key.path")).toBeUndefined()
 
@@ -37,7 +37,7 @@ describe "Config", ->
 
   describe ".set(keyPath, value)", ->
     it "allows a key path's value to be written", ->
-      expect(atom.config.set("foo.bar.baz", 42)).toBe 42
+      expect(atom.config.set("foo.bar.baz", 42)).toBe true
       expect(atom.config.get("foo.bar.baz")).toBe 42
 
     it "updates observers and saves when a key path is set", ->
@@ -48,7 +48,7 @@ describe "Config", ->
       atom.config.set("foo.bar.baz", 42)
 
       expect(atom.config.save).toHaveBeenCalled()
-      expect(observeHandler).toHaveBeenCalledWith 42, {previous: undefined}
+      expect(observeHandler).toHaveBeenCalledWith 42
 
     describe "when the value equals the default value", ->
       it "does not store the value", ->
@@ -139,7 +139,7 @@ describe "Config", ->
 
       expect(atom.config.pushAtKeyPath("foo.bar.baz", "b")).toBe 2
       expect(atom.config.get("foo.bar.baz")).toEqual ["a", "b"]
-      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz"), {previous: ['a']}
+      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz")
 
   describe ".unshiftAtKeyPath(keyPath, value)", ->
     it "unshifts the given value to the array at the key path and updates observers", ->
@@ -150,7 +150,7 @@ describe "Config", ->
 
       expect(atom.config.unshiftAtKeyPath("foo.bar.baz", "a")).toBe 2
       expect(atom.config.get("foo.bar.baz")).toEqual ["a", "b"]
-      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz"), {previous: ['b']}
+      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz")
 
   describe ".removeAtKeyPath(keyPath, value)", ->
     it "removes the given value from the array at the key path and updates observers", ->
@@ -161,16 +161,22 @@ describe "Config", ->
 
       expect(atom.config.removeAtKeyPath("foo.bar.baz", "b")).toEqual ["a", "c"]
       expect(atom.config.get("foo.bar.baz")).toEqual ["a", "c"]
-      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz"), {previous: ['a', 'b', 'c']}
+      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz")
 
   describe ".getPositiveInt(keyPath, defaultValue)", ->
-    it "returns the proper current or default value", ->
+    it "returns the proper coerced value", ->
       atom.config.set('editor.preferredLineLength', 0)
-      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 1
+
+    it "returns the proper coerced value", ->
       atom.config.set('editor.preferredLineLength', -1234)
-      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 1
+
+    it "returns the default value when a string is passed in", ->
       atom.config.set('editor.preferredLineLength', 'abcd')
       expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+
+    it "returns the default value when null is passed in", ->
       atom.config.set('editor.preferredLineLength', null)
       expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
 
@@ -226,11 +232,54 @@ describe "Config", ->
 
     it "emits an updated event", ->
       updatedCallback = jasmine.createSpy('updated')
-      atom.config.observe('foo.bar.baz.a', callNow: false, updatedCallback)
+      atom.config.onDidChange('foo.bar.baz.a', updatedCallback)
       expect(updatedCallback.callCount).toBe 0
       atom.config.setDefaults("foo.bar.baz", a: 2)
       expect(updatedCallback.callCount).toBe 1
 
+  describe ".onDidChange(keyPath)", ->
+    [observeHandler, observeSubscription] = []
+
+    describe 'when a keyPath is specified', ->
+      beforeEach ->
+        observeHandler = jasmine.createSpy("observeHandler")
+        atom.config.set("foo.bar.baz", "value 1")
+        observeSubscription = atom.config.onDidChange "foo.bar.baz", observeHandler
+
+      it "does not fire the given callback with the current value at the keypath", ->
+        expect(observeHandler).not.toHaveBeenCalled()
+
+      it "fires the callback every time the observed value changes", ->
+        observeHandler.reset() # clear the initial call
+        atom.config.set('foo.bar.baz', "value 2")
+        expect(observeHandler).toHaveBeenCalledWith({newValue: 'value 2', oldValue: 'value 1', keyPath: 'foo.bar.baz'})
+        observeHandler.reset()
+
+        atom.config.set('foo.bar.baz', "value 1")
+        expect(observeHandler).toHaveBeenCalledWith({newValue: 'value 1', oldValue: 'value 2', keyPath: 'foo.bar.baz'})
+
+    describe 'when a keyPath is not specified', ->
+      beforeEach ->
+        observeHandler = jasmine.createSpy("observeHandler")
+        atom.config.set("foo.bar.baz", "value 1")
+        observeSubscription = atom.config.onDidChange observeHandler
+
+      it "does not fire the given callback initially", ->
+        expect(observeHandler).not.toHaveBeenCalled()
+
+      it "fires the callback every time any value changes", ->
+        observeHandler.reset() # clear the initial call
+        atom.config.set('foo.bar.baz', "value 2")
+        expect(observeHandler).toHaveBeenCalledWith({newValue: 'value 2', oldValue: 'value 1', keyPath: 'foo.bar.baz'})
+
+        observeHandler.reset()
+        atom.config.set('foo.bar.baz', "value 1")
+        expect(observeHandler).toHaveBeenCalledWith({newValue: 'value 1', oldValue: 'value 2', keyPath: 'foo.bar.baz'})
+
+        observeHandler.reset()
+        atom.config.set('foo.bar.int', 1)
+        expect(observeHandler).toHaveBeenCalledWith({newValue: 1, oldValue: undefined, keyPath: 'foo.bar.int'})
+
   describe ".observe(keyPath)", ->
     [observeHandler, observeSubscription] = []
 
@@ -245,26 +294,25 @@ describe "Config", ->
     it "fires the callback every time the observed value changes", ->
       observeHandler.reset() # clear the initial call
       atom.config.set('foo.bar.baz', "value 2")
-      expect(observeHandler).toHaveBeenCalledWith("value 2", {previous: 'value 1'})
+      expect(observeHandler).toHaveBeenCalledWith("value 2")
       observeHandler.reset()
 
       atom.config.set('foo.bar.baz', "value 1")
-      expect(observeHandler).toHaveBeenCalledWith("value 1", {previous: 'value 2'})
+      expect(observeHandler).toHaveBeenCalledWith("value 1")
 
     it "fires the callback when the observed value is deleted", ->
       observeHandler.reset() # clear the initial call
       atom.config.set('foo.bar.baz', undefined)
-      expect(observeHandler).toHaveBeenCalledWith(undefined, {previous: 'value 1'})
+      expect(observeHandler).toHaveBeenCalledWith(undefined)
 
     it "fires the callback when the full key path goes into and out of existence", ->
       observeHandler.reset() # clear the initial call
       atom.config.set("foo.bar", undefined)
+      expect(observeHandler).toHaveBeenCalledWith(undefined)
 
-      expect(observeHandler).toHaveBeenCalledWith(undefined, {previous: 'value 1'})
       observeHandler.reset()
-
       atom.config.set("foo.bar.baz", "i'm back")
-      expect(observeHandler).toHaveBeenCalledWith("i'm back", {previous: undefined})
+      expect(observeHandler).toHaveBeenCalledWith("i'm back")
 
     it "does not fire the callback once the observe subscription is off'ed", ->
       observeHandler.reset() # clear the initial call
@@ -311,11 +359,19 @@ describe "Config", ->
     describe "when the config file contains valid cson", ->
       beforeEach ->
         fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'baz'")
-        atom.config.loadUserConfig()
 
       it "updates the config data based on the file contents", ->
+        atom.config.loadUserConfig()
         expect(atom.config.get("foo.bar")).toBe 'baz'
 
+      it "notifies observers for updated keypaths on load", ->
+        observeHandler = jasmine.createSpy("observeHandler")
+        observeSubscription = atom.config.observe "foo.bar", observeHandler
+
+        atom.config.loadUserConfig()
+
+        expect(observeHandler).toHaveBeenCalledWith 'baz'
+
     describe "when the config file contains invalid cson", ->
       beforeEach ->
         spyOn(console, 'error')
@@ -334,10 +390,43 @@ describe "Config", ->
         expect(fs.existsSync(atom.config.configFilePath)).toBe true
         expect(CSON.readFileSync(atom.config.configFilePath)).toEqual {}
 
+    describe "when a schema is specified", ->
+      beforeEach ->
+        schema =
+          type: 'object'
+          properties:
+            bar:
+              type: 'string'
+              default: 'def'
+            int:
+              type: 'integer'
+              default: 12
+
+        atom.config.setSchema('foo', schema)
+
+      describe "when the config file contains values that do not adhere to the schema", ->
+        warnSpy = null
+        beforeEach ->
+          warnSpy = spyOn console, 'warn'
+          fs.writeFileSync atom.config.configFilePath, """
+            foo:
+              bar: 'baz'
+              int: 'bad value'
+          """
+          atom.config.loadUserConfig()
+
+        it "updates the only the settings that have values matching the schema", ->
+          expect(atom.config.get("foo.bar")).toBe 'baz'
+          expect(atom.config.get("foo.int")).toBe 12
+
+          expect(warnSpy).toHaveBeenCalled()
+          expect(warnSpy.mostRecentCall.args[0]).toContain "'foo.int' could not be set"
+
   describe ".observeUserConfig()", ->
     updatedHandler = null
 
     beforeEach ->
+      atom.config.setDefaults('foo', bar: 'def')
       atom.config.configDirPath = dotAtomPath
       atom.config.configFilePath = path.join(atom.config.configDirPath, "atom.config.cson")
       expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
@@ -345,7 +434,7 @@ describe "Config", ->
       atom.config.loadUserConfig()
       atom.config.observeUserConfig()
       updatedHandler = jasmine.createSpy("updatedHandler")
-      atom.config.on 'updated', updatedHandler
+      atom.config.onDidChange updatedHandler
 
     afterEach ->
       atom.config.unobserveUserConfig()
@@ -359,6 +448,60 @@ describe "Config", ->
           expect(atom.config.get('foo.bar')).toBe 'quux'
           expect(atom.config.get('foo.baz')).toBe 'bar'
 
+      it "does not fire a change event for paths that did not change", ->
+        atom.config.onDidChange 'foo.bar', noChangeSpy = jasmine.createSpy()
+
+        fs.writeFileSync(atom.config.configFilePath, "foo: { bar: 'baz', omg: 'ok'}")
+        waitsFor 'update event', -> updatedHandler.callCount > 0
+        runs ->
+          expect(noChangeSpy).not.toHaveBeenCalled()
+          expect(atom.config.get('foo.bar')).toBe 'baz'
+          expect(atom.config.get('foo.omg')).toBe 'ok'
+
+      describe 'when the default value is a complex value', ->
+        beforeEach ->
+          fs.writeFileSync(atom.config.configFilePath, "foo: { bar: ['baz', 'ok']}")
+          waitsFor 'update event', -> updatedHandler.callCount > 0
+          runs -> updatedHandler.reset()
+
+        it "does not fire a change event for paths that did not change", ->
+          atom.config.onDidChange 'foo.bar', noChangeSpy = jasmine.createSpy()
+
+          fs.writeFileSync(atom.config.configFilePath, "foo: { bar: ['baz', 'ok'], omg: 'another'}")
+          waitsFor 'update event', -> updatedHandler.callCount > 0
+          runs ->
+            expect(noChangeSpy).not.toHaveBeenCalled()
+            expect(atom.config.get('foo.bar')).toEqual ['baz', 'ok']
+            expect(atom.config.get('foo.omg')).toBe 'another'
+
+    describe "when the config file changes to omit a setting with a default", ->
+      it "resets the setting back to the default", ->
+        fs.writeFileSync(atom.config.configFilePath, "foo: { baz: 'new'}")
+        waitsFor 'update event', -> updatedHandler.callCount > 0
+        runs ->
+          expect(atom.config.get('foo.bar')).toBe 'def'
+          expect(atom.config.get('foo.baz')).toBe 'new'
+
+    describe "when the config file changes to be empty", ->
+      beforeEach ->
+        fs.writeFileSync(atom.config.configFilePath, "")
+        waitsFor 'update event', -> updatedHandler.callCount > 0
+
+      it "resets all settings back to the defaults", ->
+        expect(updatedHandler.callCount).toBe 1
+        expect(atom.config.get('foo.bar')).toBe 'def'
+        atom.config.set("hair", "blonde") # trigger a save
+        expect(atom.config.save).toHaveBeenCalled()
+
+      describe "when the config file subsequently changes again to contain configuration", ->
+        beforeEach ->
+          updatedHandler.reset()
+          fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'newVal'")
+          waitsFor 'update event', -> updatedHandler.callCount > 0
+
+        it "sets the setting to the value specified in the config file", ->
+          expect(atom.config.get('foo.bar')).toBe 'newVal'
+
     describe "when the config file changes to contain invalid cson", ->
       beforeEach ->
         spyOn(console, 'error')
@@ -373,9 +516,349 @@ describe "Config", ->
 
       describe "when the config file subsequently changes again to contain valid cson", ->
         beforeEach ->
-          fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'baz'")
+          fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'newVal'")
           waitsFor 'update event', -> updatedHandler.callCount > 0
 
         it "updates the config data and resumes saving", ->
           atom.config.set("hair", "blonde")
           expect(atom.config.save).toHaveBeenCalled()
+
+  describe "when a schema is specified", ->
+    schema = null
+
+    describe '.setSchema(keyPath, schema)', ->
+      it 'creates a properly nested schema', ->
+        schema =
+          type: 'object'
+          properties:
+            anInt:
+              type: 'integer'
+              default: 12
+
+        atom.config.setSchema('foo.bar', schema)
+
+        expect(atom.config.getSchema('foo')).toEqual
+          type: 'object'
+          properties:
+            bar:
+              type: 'object'
+              properties:
+                anInt:
+                  type: 'integer'
+                  default: 12
+
+      it 'sets defaults specified by the schema', ->
+        schema =
+          type: 'object'
+          properties:
+            anInt:
+              type: 'integer'
+              default: 12
+            anObject:
+              type: 'object'
+              properties:
+                nestedInt:
+                  type: 'integer'
+                  default: 24
+                nestedObject:
+                  type: 'object'
+                  properties:
+                    superNestedInt:
+                      type: 'integer'
+                      default: 36
+
+        atom.config.setSchema('foo.bar', schema)
+        expect(atom.config.get("foo.bar.anInt")).toBe 12
+        expect(atom.config.get("foo.bar.anObject")).toEqual
+          nestedInt: 24
+          nestedObject:
+            superNestedInt: 36
+
+      it 'can set a non-object schema', ->
+        schema =
+          type: 'integer'
+          default: 12
+
+        atom.config.setSchema('foo.bar.anInt', schema)
+        expect(atom.config.get("foo.bar.anInt")).toBe 12
+        expect(atom.config.getSchema('foo.bar.anInt')).toEqual
+          type: 'integer'
+          default: 12
+
+    describe '.getSchema(keyPath)', ->
+      schema =
+        type: 'object'
+        properties:
+          anInt:
+            type: 'integer'
+            default: 12
+
+      atom.config.setSchema('foo.bar', schema)
+
+      expect(atom.config.getSchema('foo.bar')).toEqual
+        type: 'object'
+        properties:
+          anInt:
+            type: 'integer'
+            default: 12
+
+      expect(atom.config.getSchema('foo.bar.anInt')).toEqual
+        type: 'integer'
+        default: 12
+
+    describe 'when the value has an "integer" type', ->
+      beforeEach ->
+        schema =
+          type: 'integer'
+          default: 12
+        atom.config.setSchema('foo.bar.anInt', schema)
+
+      it 'coerces a string to an int', ->
+        atom.config.set('foo.bar.anInt', '123')
+        expect(atom.config.get('foo.bar.anInt')).toBe 123
+
+      it 'does not allow infinity', ->
+        atom.config.set('foo.bar.anInt', Infinity)
+        expect(atom.config.get('foo.bar.anInt')).toBe 12
+
+      it 'coerces a float to an int', ->
+        atom.config.set('foo.bar.anInt', 12.3)
+        expect(atom.config.get('foo.bar.anInt')).toBe 12
+
+      it 'will not set non-integers', ->
+        atom.config.set('foo.bar.anInt', null)
+        expect(atom.config.get('foo.bar.anInt')).toBe 12
+
+        atom.config.set('foo.bar.anInt', 'nope')
+        expect(atom.config.get('foo.bar.anInt')).toBe 12
+
+      describe 'when the minimum and maximum keys are used', ->
+        beforeEach ->
+          schema =
+            type: 'integer'
+            minimum: 10
+            maximum: 20
+            default: 12
+          atom.config.setSchema('foo.bar.anInt', schema)
+
+        it 'keeps the specified value within the specified range', ->
+          atom.config.set('foo.bar.anInt', '123')
+          expect(atom.config.get('foo.bar.anInt')).toBe 20
+
+          atom.config.set('foo.bar.anInt', '1')
+          expect(atom.config.get('foo.bar.anInt')).toBe 10
+
+    describe 'when the value has an "integer" and "string" type', ->
+      beforeEach ->
+        schema =
+          type: ['integer', 'string']
+          default: 12
+        atom.config.setSchema('foo.bar.anInt', schema)
+
+      it 'can coerce an int, and fallback to a string', ->
+        atom.config.set('foo.bar.anInt', '123')
+        expect(atom.config.get('foo.bar.anInt')).toBe 123
+
+        atom.config.set('foo.bar.anInt', 'cats')
+        expect(atom.config.get('foo.bar.anInt')).toBe 'cats'
+
+    describe 'when the value has an "string" and "boolean" type', ->
+      beforeEach ->
+        schema =
+          type: ['string', 'boolean']
+          default: 'def'
+        atom.config.setSchema('foo.bar', schema)
+
+      it 'can set a string, a boolean, and revert back to the default', ->
+        atom.config.set('foo.bar', 'ok')
+        expect(atom.config.get('foo.bar')).toBe 'ok'
+
+        atom.config.set('foo.bar', false)
+        expect(atom.config.get('foo.bar')).toBe false
+
+        atom.config.set('foo.bar', undefined)
+        expect(atom.config.get('foo.bar')).toBe 'def'
+
+    describe 'when the value has a "number" type', ->
+      beforeEach ->
+        schema =
+          type: 'number'
+          default: 12.1
+        atom.config.setSchema('foo.bar.aFloat', schema)
+
+      it 'coerces a string to a float', ->
+        atom.config.set('foo.bar.aFloat', '12.23')
+        expect(atom.config.get('foo.bar.aFloat')).toBe 12.23
+
+      it 'will not set non-numbers', ->
+        atom.config.set('foo.bar.aFloat', null)
+        expect(atom.config.get('foo.bar.aFloat')).toBe 12.1
+
+        atom.config.set('foo.bar.aFloat', 'nope')
+        expect(atom.config.get('foo.bar.aFloat')).toBe 12.1
+
+      describe 'when the minimum and maximum keys are used', ->
+        beforeEach ->
+          schema =
+            type: 'number'
+            minimum: 11.2
+            maximum: 25.4
+            default: 12.1
+          atom.config.setSchema('foo.bar.aFloat', schema)
+
+        it 'keeps the specified value within the specified range', ->
+          atom.config.set('foo.bar.aFloat', '123.2')
+          expect(atom.config.get('foo.bar.aFloat')).toBe 25.4
+
+          atom.config.set('foo.bar.aFloat', '1.0')
+          expect(atom.config.get('foo.bar.aFloat')).toBe 11.2
+
+    describe 'when the value has a "boolean" type', ->
+      beforeEach ->
+        schema =
+          type: 'boolean'
+          default: true
+        atom.config.setSchema('foo.bar.aBool', schema)
+
+      it 'coerces various types to a boolean', ->
+        atom.config.set('foo.bar.aBool', 'true')
+        expect(atom.config.get('foo.bar.aBool')).toBe true
+        atom.config.set('foo.bar.aBool', 'false')
+        expect(atom.config.get('foo.bar.aBool')).toBe false
+        atom.config.set('foo.bar.aBool', 'TRUE')
+        expect(atom.config.get('foo.bar.aBool')).toBe true
+        atom.config.set('foo.bar.aBool', 'FALSE')
+        expect(atom.config.get('foo.bar.aBool')).toBe false
+        atom.config.set('foo.bar.aBool', 1)
+        expect(atom.config.get('foo.bar.aBool')).toBe false
+        atom.config.set('foo.bar.aBool', 0)
+        expect(atom.config.get('foo.bar.aBool')).toBe false
+        atom.config.set('foo.bar.aBool', {})
+        expect(atom.config.get('foo.bar.aBool')).toBe false
+        atom.config.set('foo.bar.aBool', null)
+        expect(atom.config.get('foo.bar.aBool')).toBe false
+
+      it 'reverts back to the default value when undefined is passed to set', ->
+        atom.config.set('foo.bar.aBool', 'false')
+        expect(atom.config.get('foo.bar.aBool')).toBe false
+
+        atom.config.set('foo.bar.aBool', undefined)
+        expect(atom.config.get('foo.bar.aBool')).toBe true
+
+    describe 'when the value has an "string" type', ->
+      beforeEach ->
+        schema =
+          type: 'string'
+          default: 'ok'
+        atom.config.setSchema('foo.bar.aString', schema)
+
+      it 'allows strings', ->
+        atom.config.set('foo.bar.aString', 'yep')
+        expect(atom.config.get('foo.bar.aString')).toBe 'yep'
+
+      it 'will only set strings', ->
+        expect(atom.config.set('foo.bar.aString', 123)).toBe false
+        expect(atom.config.get('foo.bar.aString')).toBe 'ok'
+
+        expect(atom.config.set('foo.bar.aString', true)).toBe false
+        expect(atom.config.get('foo.bar.aString')).toBe 'ok'
+
+        expect(atom.config.set('foo.bar.aString', null)).toBe false
+        expect(atom.config.get('foo.bar.aString')).toBe 'ok'
+
+        expect(atom.config.set('foo.bar.aString', [])).toBe false
+        expect(atom.config.get('foo.bar.aString')).toBe 'ok'
+
+        expect(atom.config.set('foo.bar.aString', nope: 'nope')).toBe false
+        expect(atom.config.get('foo.bar.aString')).toBe 'ok'
+
+    describe 'when the value has an "object" type', ->
+      beforeEach ->
+        schema =
+          type: 'object'
+          properties:
+            anInt:
+              type: 'integer'
+              default: 12
+            nestedObject:
+              type: 'object'
+              properties:
+                nestedBool:
+                  type: 'boolean'
+                  default: false
+        atom.config.setSchema('foo.bar', schema)
+
+      it 'converts and validates all the children', ->
+        atom.config.set 'foo.bar',
+          anInt: '23'
+          nestedObject:
+            nestedBool: 'true'
+        expect(atom.config.get('foo.bar')).toEqual
+          anInt: 23
+          nestedObject:
+            nestedBool: true
+
+      it 'will set only the values that adhere to the schema', ->
+        expect(atom.config.set 'foo.bar',
+          anInt: 'nope'
+          nestedObject:
+            nestedBool: true
+        ).toBe true
+        expect(atom.config.get('foo.bar.anInt')).toEqual 12
+        expect(atom.config.get('foo.bar.nestedObject.nestedBool')).toEqual true
+
+    describe 'when the value has an "array" type', ->
+      beforeEach ->
+        schema =
+          type: 'array'
+          default: [1, 2, 3]
+          items:
+            type: 'integer'
+        atom.config.setSchema('foo.bar', schema)
+
+      it 'converts an array of strings to an array of ints', ->
+        atom.config.set 'foo.bar', ['2', '3', '4']
+        expect(atom.config.get('foo.bar')).toEqual  [2, 3, 4]
+
+    describe 'when the `enum` key is used', ->
+      beforeEach ->
+        schema =
+          type: 'object'
+          properties:
+            str:
+              type: 'string'
+              default: 'ok'
+              enum: ['ok', 'one', 'two']
+            int:
+              type: 'integer'
+              default: 2
+              enum: [2, 3, 5]
+            arr:
+              type: 'array'
+              default: ['one', 'two']
+              items:
+                type: 'string'
+                enum: ['one', 'two', 'three']
+
+        atom.config.setSchema('foo.bar', schema)
+
+      it 'will only set a string when the string is in the enum values', ->
+        expect(atom.config.set('foo.bar.str', 'nope')).toBe false
+        expect(atom.config.get('foo.bar.str')).toBe 'ok'
+
+        expect(atom.config.set('foo.bar.str', 'one')).toBe true
+        expect(atom.config.get('foo.bar.str')).toBe 'one'
+
+      it 'will only set an integer when the integer is in the enum values', ->
+        expect(atom.config.set('foo.bar.int', '400')).toBe false
+        expect(atom.config.get('foo.bar.int')).toBe 2
+
+        expect(atom.config.set('foo.bar.int', '3')).toBe true
+        expect(atom.config.get('foo.bar.int')).toBe 3
+
+      it 'will only set an array when the array values are in the enum values', ->
+        expect(atom.config.set('foo.bar.arr', ['one', 'five'])).toBe true
+        expect(atom.config.get('foo.bar.arr')).toEqual ['one']
+
+        expect(atom.config.set('foo.bar.arr', ['two', 'three'])).toBe true
+        expect(atom.config.get('foo.bar.arr')).toEqual ['two', 'three']

spec/context-menu-manager-spec.coffee

@@ -3,173 +3,150 @@
 ContextMenuManager = require '../src/context-menu-manager'
 
 describe "ContextMenuManager", ->
-  [contextMenu] = []
+  [contextMenu, parent, child, grandchild] = []
 
   beforeEach ->
     {resourcePath} = atom.getLoadSettings()
     contextMenu = new ContextMenuManager({resourcePath})
 
-  describe "adding definitions", ->
-    it 'loads',  ->
-      contextMenu.add 'file-path',
-        '.selector':
-          'label': 'command'
+    parent = document.createElement("div")
+    child = document.createElement("div")
+    grandchild = document.createElement("div")
+    parent.classList.add('parent')
+    child.classList.add('child')
+    grandchild.classList.add('grandchild')
+    child.appendChild(grandchild)
+    parent.appendChild(child)
 
-      expect(contextMenu.definitions['.selector'][0].label).toEqual 'label'
-      expect(contextMenu.definitions['.selector'][0].command).toEqual 'command'
+  describe "::add(itemsBySelector)", ->
+    it "can add top-level menu items that can be removed with the returned disposable", ->
+      disposable = contextMenu.add
+        '.parent': [{label: 'A', command: 'a'}]
+        '.child': [{label: 'B', command: 'b'}]
+        '.grandchild': [{label: 'C', command: 'c'}]
 
-    it 'does not add duplicate menu items',  ->
-      contextMenu.add 'file-path',
-        '.selector':
-          'label': 'command'
+      expect(contextMenu.templateForElement(grandchild)).toEqual [
+        {label: 'C', command: 'c'}
+        {label: 'B', command: 'b'}
+        {label: 'A', command: 'a'}
+      ]
 
-      contextMenu.add 'file-path',
-        '.selector':
-          'label': 'command'
+      disposable.dispose()
+      expect(contextMenu.templateForElement(grandchild)).toEqual []
 
-      expect(contextMenu.definitions['.selector'][0].label).toEqual 'label'
-      expect(contextMenu.definitions['.selector'][0].command).toEqual 'command'
-      expect(contextMenu.definitions['.selector'].length).toBe 1
+    it "can add submenu items to existing menus that can be removed with the returned disposable", ->
+      disposable1 = contextMenu.add
+        '.grandchild': [{label: 'A', submenu: [{label: 'B', command: 'b'}]}]
+      disposable2 = contextMenu.add
+        '.grandchild': [{label: 'A', submenu: [{label: 'C', command: 'c'}]}]
 
-    it 'allows multiple separators', ->
-      contextMenu.add 'file-path',
-        '.selector':
-          'separator1': '-'
-          'separator2': '-'
-
-      expect(contextMenu.definitions['.selector'].length).toBe 2
-      expect(contextMenu.definitions['.selector'][0].type).toEqual 'separator'
-      expect(contextMenu.definitions['.selector'][1].type).toEqual 'separator'
-
-    it 'allows duplicate commands with different labels',  ->
-      contextMenu.add 'file-path',
-        '.selector':
-          'label': 'command'
-
-      contextMenu.add 'file-path',
-        '.selector':
-          'another label': 'command'
-
-      expect(contextMenu.definitions['.selector'][0].label).toEqual 'label'
-      expect(contextMenu.definitions['.selector'][0].command).toEqual 'command'
-      expect(contextMenu.definitions['.selector'][1].label).toEqual 'another label'
-      expect(contextMenu.definitions['.selector'][1].command).toEqual 'command'
-
-    it "loads submenus", ->
-      contextMenu.add 'file-path',
-        '.selector':
-          'parent':
-            'child-1': 'child-1:trigger'
-            'child-2': 'child-2:trigger'
-          'parent-2': 'parent-2:trigger'
-
-      expect(contextMenu.definitions['.selector'].length).toBe 2
-      expect(contextMenu.definitions['.selector'][0].label).toEqual 'parent'
-      expect(contextMenu.definitions['.selector'][0].submenu.length).toBe 2
-      expect(contextMenu.definitions['.selector'][0].submenu[0].label).toBe 'child-1'
-      expect(contextMenu.definitions['.selector'][0].submenu[0].command).toBe 'child-1:trigger'
-      expect(contextMenu.definitions['.selector'][0].submenu[1].label).toBe 'child-2'
-      expect(contextMenu.definitions['.selector'][0].submenu[1].command).toBe 'child-2:trigger'
-
-    describe 'dev mode', ->
-      it 'loads',  ->
-        contextMenu.add 'file-path',
-          '.selector':
-            'label': 'command'
-        , devMode: true
-
-        expect(contextMenu.devModeDefinitions['.selector'][0].label).toEqual 'label'
-        expect(contextMenu.devModeDefinitions['.selector'][0].command).toEqual 'command'
-
-  describe "building a menu template", ->
-    beforeEach ->
-      contextMenu.definitions = {
-        '.parent':[
-          label: 'parent'
-          command: 'command-p'
-         ]
-        '.child': [
-          label: 'child'
-          command: 'command-c'
+      expect(contextMenu.templateForElement(grandchild)).toEqual [{
+        label: 'A',
+        submenu: [
+          {label: 'B', command: 'b'}
+          {label: 'C', command: 'c'}
         ]
+      }]
+
+      disposable2.dispose()
+      expect(contextMenu.templateForElement(grandchild)).toEqual [{
+        label: 'A',
+        submenu: [
+          {label: 'B', command: 'b'}
+        ]
+      }]
+
+      disposable1.dispose()
+      expect(contextMenu.templateForElement(grandchild)).toEqual []
+
+    it "favors the most specific / recently added item in the case of a duplicate label", ->
+      grandchild.classList.add('foo')
+
+      disposable1 = contextMenu.add
+        '.grandchild': [{label: 'A', command: 'a'}]
+      disposable2 = contextMenu.add
+        '.grandchild.foo': [{label: 'A', command: 'b'}]
+      disposable3 = contextMenu.add
+        '.grandchild': [{label: 'A', command: 'c'}]
+      disposable4 = contextMenu.add
+        '.child': [{label: 'A', command: 'd'}]
+
+      expect(contextMenu.templateForElement(grandchild)).toEqual [{label: 'A', command: 'b'}]
+
+      disposable2.dispose()
+      expect(contextMenu.templateForElement(grandchild)).toEqual [{label: 'A', command: 'c'}]
+
+      disposable3.dispose()
+      expect(contextMenu.templateForElement(grandchild)).toEqual [{label: 'A', command: 'a'}]
+
+      disposable1.dispose()
+      expect(contextMenu.templateForElement(grandchild)).toEqual [{label: 'A', command: 'd'}]
+
+    it "allows multiple separators, but not adjacent to each other", ->
+      contextMenu.add
+        '.grandchild': [
+          {label: 'A', command: 'a'},
+          {type: 'separator'},
+          {type: 'separator'},
+          {label: 'B', command: 'b'},
+          {type: 'separator'},
+          {type: 'separator'},
+          {label: 'C', command: 'c'}
+        ]
+
+      expect(contextMenu.templateForElement(grandchild)).toEqual [
+        {label: 'A', command: 'a'},
+        {type: 'separator'},
+        {label: 'B', command: 'b'},
+        {type: 'separator'},
+        {label: 'C', command: 'c'}
+      ]
+
+    it "excludes items marked for display in devMode unless in dev mode", ->
+      disposable1 = contextMenu.add
+        '.grandchild': [{label: 'A', command: 'a', devMode: true}, {label: 'B', command: 'b', devMode: false}]
+
+      expect(contextMenu.templateForElement(grandchild)).toEqual [{label: 'B', command: 'b'}]
+
+      contextMenu.devMode = true
+      expect(contextMenu.templateForElement(grandchild)).toEqual [{label: 'A', command: 'a'}, {label: 'B', command: 'b'}]
+
+    it "allows items to be associated with `created` hooks which are invoked on template construction with the item and event", ->
+      createdEvent = null
+
+      item = {
+        label: 'A',
+        command: 'a',
+        created: (event) ->
+          @command = 'b'
+          createdEvent = event
       }
 
-      contextMenu.devModeDefinitions =
-        '.parent': [
-          label: 'dev-label'
-          command: 'dev-command'
-        ]
+      contextMenu.add('.grandchild': [item])
 
-    describe "on a single element", ->
-      [element] = []
+      dispatchedEvent = {target: grandchild}
+      expect(contextMenu.templateForEvent(dispatchedEvent)).toEqual [{label: 'A', command: 'b'}]
+      expect(item.command).toBe 'a' # doesn't modify original item template
+      expect(createdEvent).toBe dispatchedEvent
 
-      beforeEach ->
-        element = ($$ -> @div class: 'parent')[0]
+    it "allows items to be associated with `shouldDisplay` hooks which are invoked on construction to determine whether the item should be included", ->
+      shouldDisplayEvent = null
+      shouldDisplay = true
 
-      it "creates a menu with a single item", ->
-        menu = contextMenu.combinedMenuTemplateForElement(element)
+      item = {
+        label: 'A',
+        command: 'a',
+        shouldDisplay: (event) ->
+          @foo = 'bar'
+          shouldDisplayEvent = event
+          shouldDisplay
+      }
+      contextMenu.add('.grandchild': [item])
 
-        expect(menu[0].label).toEqual 'parent'
-        expect(menu[0].command).toEqual 'command-p'
-        expect(menu[1]).toBeUndefined()
+      dispatchedEvent = {target: grandchild}
+      expect(contextMenu.templateForEvent(dispatchedEvent)).toEqual [{label: 'A', command: 'a'}]
+      expect(item.foo).toBeUndefined() # doesn't modify original item template
+      expect(shouldDisplayEvent).toBe dispatchedEvent
 
-      describe "in devMode", ->
-        beforeEach -> contextMenu.devMode = true
-
-        it "creates a menu with development items", ->
-          menu = contextMenu.combinedMenuTemplateForElement(element)
-
-          expect(menu[0].label).toEqual 'parent'
-          expect(menu[0].command).toEqual 'command-p'
-          expect(menu[1].type).toEqual 'separator'
-          expect(menu[2].label).toEqual 'dev-label'
-          expect(menu[2].command).toEqual 'dev-command'
-
-
-    describe "on multiple elements", ->
-      [element] = []
-
-      beforeEach ->
-        element = $$ ->
-          @div class: 'parent', =>
-            @div class: 'child'
-
-        element = element.find('.child')[0]
-
-      it "creates a menu with a two items", ->
-        menu = contextMenu.combinedMenuTemplateForElement(element)
-
-        expect(menu[0].label).toEqual 'child'
-        expect(menu[0].command).toEqual 'command-c'
-        expect(menu[1].label).toEqual 'parent'
-        expect(menu[1].command).toEqual 'command-p'
-        expect(menu[2]).toBeUndefined()
-
-      describe "in devMode", ->
-        beforeEach -> contextMenu.devMode = true
-
-        xit "creates a menu with development items", ->
-          menu = contextMenu.combinedMenuTemplateForElement(element)
-
-          expect(menu[0].label).toEqual 'child'
-          expect(menu[0].command).toEqual 'command-c'
-          expect(menu[1].label).toEqual 'parent'
-          expect(menu[1].command).toEqual 'command-p'
-          expect(menu[2].label).toEqual 'dev-label'
-          expect(menu[2].command).toEqual 'dev-command'
-          expect(menu[3]).toBeUndefined()
-
-  describe "executeBuildHandlers", ->
-    menuTemplate = [
-        label: 'label'
-        executeAtBuild: ->
-      ]
-    event =
-      target: null
-
-    it 'should invoke the executeAtBuild fn', ->
-      buildFn = spyOn(menuTemplate[0], 'executeAtBuild')
-      contextMenu.executeBuildHandlers(event, menuTemplate)
-
-      expect(buildFn).toHaveBeenCalled()
-      expect(buildFn.mostRecentCall.args[0]).toBe event
+      shouldDisplay = false
+      expect(contextMenu.templateForEvent(dispatchedEvent)).toEqual []

spec/deserializer-manager-spec.coffee

@@ -1,33 +1,44 @@
 DeserializerManager = require '../src/deserializer-manager'
 
-describe ".deserialize(state)", ->
-  deserializer = null
+describe "DeserializerManager", ->
+  manager = null
 
   class Foo
     @deserialize: ({name}) -> new Foo(name)
     constructor: (@name) ->
 
   beforeEach ->
-    deserializer = new DeserializerManager()
-    deserializer.add(Foo)
+    manager = new DeserializerManager
 
-  it "calls deserialize on the deserializer for the given state object, or returns undefined if one can't be found", ->
-    spyOn(console, 'warn')
-    object = deserializer.deserialize({ deserializer: 'Foo', name: 'Bar' })
-    expect(object.name).toBe 'Bar'
-    expect(deserializer.deserialize({ deserializer: 'Bogus' })).toBeUndefined()
+  describe "::add(deserializer)", ->
+    it "returns a disposable that can be used to remove the manager", ->
+      disposable = manager.add(Foo)
+      expect(manager.deserialize({deserializer: 'Foo', name: 'Bar'})).toBeDefined()
+      disposable.dispose()
+      spyOn(console, 'warn')
+      expect(manager.deserialize({deserializer: 'Foo', name: 'Bar'})).toBeUndefined()
 
-  describe "when the deserializer has a version", ->
+  describe "::deserialize(state)", ->
     beforeEach ->
-      Foo.version = 2
+      manager.add(Foo)
 
-    describe "when the deserialized state has a matching version", ->
-      it "attempts to deserialize the state", ->
-        object = deserializer.deserialize({ deserializer: 'Foo', version: 2, name: 'Bar' })
-        expect(object.name).toBe 'Bar'
+    it "calls deserialize on the manager for the given state object, or returns undefined if one can't be found", ->
+      spyOn(console, 'warn')
+      object = manager.deserialize({deserializer: 'Foo', name: 'Bar'})
+      expect(object.name).toBe 'Bar'
+      expect(manager.deserialize({deserializer: 'Bogus'})).toBeUndefined()
 
-    describe "when the deserialized state has a non-matching version", ->
-      it "returns undefined", ->
-        expect(deserializer.deserialize({ deserializer: 'Foo', version: 3, name: 'Bar' })).toBeUndefined()
-        expect(deserializer.deserialize({ deserializer: 'Foo', version: 1, name: 'Bar' })).toBeUndefined()
-        expect(deserializer.deserialize({ deserializer: 'Foo', name: 'Bar' })).toBeUndefined()
+    describe "when the manager has a version", ->
+      beforeEach ->
+        Foo.version = 2
+
+      describe "when the deserialized state has a matching version", ->
+        it "attempts to deserialize the state", ->
+          object = manager.deserialize({deserializer: 'Foo', version: 2, name: 'Bar'})
+          expect(object.name).toBe 'Bar'
+
+      describe "when the deserialized state has a non-matching version", ->
+        it "returns undefined", ->
+          expect(manager.deserialize({deserializer: 'Foo', version: 3, name: 'Bar'})).toBeUndefined()
+          expect(manager.deserialize({deserializer: 'Foo', version: 1, name: 'Bar'})).toBeUndefined()
+          expect(manager.deserialize({deserializer: 'Foo', name: 'Bar'})).toBeUndefined()

spec/display-buffer-spec.coffee

@@ -9,7 +9,7 @@ describe "DisplayBuffer", ->
     buffer = atom.project.bufferForPathSync('sample.js')
     displayBuffer = new DisplayBuffer({buffer, tabLength})
     changeHandler = jasmine.createSpy 'changeHandler'
-    displayBuffer.on 'changed', changeHandler
+    displayBuffer.onDidChange changeHandler
 
     waitsForPromise ->
       atom.packages.activatePackage('language-javascript')
@@ -58,7 +58,7 @@ describe "DisplayBuffer", ->
 
   describe "soft wrapping", ->
     beforeEach ->
-      displayBuffer.setSoftWrap(true)
+      displayBuffer.setSoftWrapped(true)
       displayBuffer.setEditorWidthInChars(50)
       changeHandler.reset()
 
@@ -129,7 +129,7 @@ describe "DisplayBuffer", ->
 
             expect(event).toEqual(start: 7, end: 8, screenDelta: -1, bufferDelta: 0)
 
-        describe "when the update causes a line to softwrap an additional time", ->
+        describe "when the update causes a line to soft wrap an additional time", ->
           it "rewraps the line and emits a change event", ->
             buffer.insert([6, 28], '1234567890')
             expect(displayBuffer.tokenizedLineForScreenRow(7).text).toBe '      current < pivot ? '
@@ -162,7 +162,7 @@ describe "DisplayBuffer", ->
       describe "when a newline is inserted, deleted, and re-inserted at the end of a wrapped line (regression)", ->
         it "correctly renders the original wrapped line", ->
           buffer = atom.project.buildBufferSync(null, '')
-          displayBuffer = new DisplayBuffer({buffer, tabLength, editorWidthInChars: 30, softWrap: true})
+          displayBuffer = new DisplayBuffer({buffer, tabLength, editorWidthInChars: 30, softWrapped: true})
 
           buffer.insert([0, 0], "the quick brown fox jumps over the lazy dog.")
           buffer.insert([0, Infinity], '\n')
@@ -220,10 +220,10 @@ describe "DisplayBuffer", ->
       displayBuffer.setWidth(50)
       displayBuffer.manageScrollPosition = true
 
-      displayBuffer.setSoftWrap(false)
+      displayBuffer.setSoftWrapped(false)
       displayBuffer.setScrollLeft(Infinity)
       expect(displayBuffer.getScrollLeft()).toBeGreaterThan 0
-      displayBuffer.setSoftWrap(true)
+      displayBuffer.setSoftWrapped(true)
       expect(displayBuffer.getScrollLeft()).toBe 0
       displayBuffer.setScrollLeft(10)
       expect(displayBuffer.getScrollLeft()).toBe 0
@@ -234,7 +234,7 @@ describe "DisplayBuffer", ->
       buffer.release()
       buffer = atom.project.bufferForPathSync('two-hundred.txt')
       displayBuffer = new DisplayBuffer({buffer, tabLength})
-      displayBuffer.on 'changed', changeHandler
+      displayBuffer.onDidChange changeHandler
 
     describe "when folds are created and destroyed", ->
       describe "when a fold spans multiple lines", ->
@@ -568,7 +568,7 @@ describe "DisplayBuffer", ->
 
   describe "::clipScreenPosition(screenPosition, wrapBeyondNewlines: false, wrapAtSoftNewlines: false, skipAtomicTokens: false)", ->
     beforeEach ->
-      displayBuffer.setSoftWrap(true)
+      displayBuffer.setSoftWrapped(true)
       displayBuffer.setEditorWidthInChars(50)
 
     it "allows valid positions", ->
@@ -643,7 +643,7 @@ describe "DisplayBuffer", ->
 
     it "correctly translates positions on soft wrapped lines containing tabs", ->
       buffer.setText('\t\taa  bb  cc  dd  ee  ff  gg')
-      displayBuffer.setSoftWrap(true)
+      displayBuffer.setSoftWrapped(true)
       displayBuffer.setEditorWidthInChars(10)
       expect(displayBuffer.screenPositionForBufferPosition([0, 10], wrapAtSoftNewlines: true)).toEqual [1, 0]
       expect(displayBuffer.bufferPositionForScreenPosition([1, 0])).toEqual [0, 10]
@@ -686,7 +686,7 @@ describe "DisplayBuffer", ->
         expect(marker2.getScreenRange()).toEqual [[5, 4], [5, 10]]
 
       it "emits a 'marker-created' event on the DisplayBuffer whenever a marker is created", ->
-        displayBuffer.on 'marker-created', markerCreatedHandler = jasmine.createSpy("markerCreatedHandler")
+        displayBuffer.onDidCreateMarker markerCreatedHandler = jasmine.createSpy("markerCreatedHandler")
 
         marker1 = displayBuffer.markScreenRange([[5, 4], [5, 10]])
         expect(markerCreatedHandler).toHaveBeenCalledWith(marker1)
@@ -722,7 +722,7 @@ describe "DisplayBuffer", ->
 
       beforeEach ->
         marker = displayBuffer.markScreenRange([[5, 4], [5, 10]])
-        marker.on 'changed', markerChangedHandler = jasmine.createSpy("markerChangedHandler")
+        marker.onDidChange markerChangedHandler = jasmine.createSpy("markerChangedHandler")
 
       it "triggers the 'changed' event whenever the markers head's screen position changes in the buffer or on screen", ->
         marker.setHeadScreenPosition([8, 20])
@@ -859,8 +859,8 @@ describe "DisplayBuffer", ->
 
       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()
+        marker2.onDidChange marker2ChangedHandler = jasmine.createSpy("marker2ChangedHandler")
+        displayBuffer.onDidChange changeHandler = jasmine.createSpy("changeHandler").andCallFake -> onDisplayBufferChange()
 
         # New change ----
 
@@ -886,7 +886,7 @@ describe "DisplayBuffer", ->
         marker2ChangedHandler.reset()
 
         marker3 = displayBuffer.markBufferRange([[8, 1], [8, 2]])
-        marker3.on 'changed', marker3ChangedHandler = jasmine.createSpy("marker3ChangedHandler")
+        marker3.onDidChange marker3ChangedHandler = jasmine.createSpy("marker3ChangedHandler")
 
         onDisplayBufferChange = ->
           # calls change handler first
@@ -932,7 +932,7 @@ describe "DisplayBuffer", ->
         expect(marker3ChangedHandler).toHaveBeenCalled()
 
       it "updates the position of markers before emitting change events that aren't caused by a buffer change", ->
-        displayBuffer.on 'changed', changeHandler = jasmine.createSpy("changeHandler").andCallFake ->
+        displayBuffer.onDidChange changeHandler = jasmine.createSpy("changeHandler").andCallFake ->
           # calls change handler first
           expect(markerChangedHandler).not.toHaveBeenCalled()
           # but still updates the markers
@@ -998,20 +998,20 @@ describe "DisplayBuffer", ->
         expect(marker.isValid()).toBeFalsy()
         expect(displayBuffer.getMarker(marker.id)).toBeUndefined()
 
-      it "emits 'destroyed' events when markers are destroyed", ->
+      it "notifies ::onDidDestroy observers when markers are destroyed", ->
         destroyedHandler = jasmine.createSpy("destroyedHandler")
         marker = displayBuffer.markScreenRange([[5, 4], [5, 10]])
-        marker.on 'destroyed', destroyedHandler
+        marker.onDidDestroy destroyedHandler
         marker.destroy()
         expect(destroyedHandler).toHaveBeenCalled()
         destroyedHandler.reset()
 
         marker2 = displayBuffer.markScreenRange([[5, 4], [5, 10]])
-        marker2.on 'destroyed', destroyedHandler
+        marker2.onDidDestroy destroyedHandler
         buffer.getMarker(marker2.id).destroy()
         expect(destroyedHandler).toHaveBeenCalled()
 
-    describe "DisplayBufferMarker::copy(attributes)", ->
+    describe "Marker::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)
@@ -1020,10 +1020,10 @@ describe "DisplayBuffer", ->
         marker2 = marker1.copy(b: 3)
         expect(marker2.getBufferRange()).toEqual marker1.getBufferRange()
         expect(displayBuffer.getMarkerCount()).toBe initialMarkerCount + 2
-        expect(marker1.getAttributes()).toEqual a: 1, b: 2
-        expect(marker2.getAttributes()).toEqual a: 1, b: 3
+        expect(marker1.getProperties()).toEqual a: 1, b: 2
+        expect(marker2.getProperties()).toEqual a: 1, b: 3
 
-    describe "DisplayBufferMarker::getPixelRange()", ->
+    describe "Marker::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]])
 
@@ -1041,9 +1041,8 @@ describe "DisplayBuffer", ->
       describe 'when a marker is created', ->
         it 'the second display buffer will not emit a marker-created event when the marker has been deleted in the first marker-created event', ->
           displayBuffer2 = new DisplayBuffer({buffer, tabLength})
-          displayBuffer.on 'marker-created', markerCreated1 = jasmine.createSpy().andCallFake (marker) ->
-            marker.destroy()
-          displayBuffer2.on 'marker-created', markerCreated2 = jasmine.createSpy()
+          displayBuffer.onDidCreateMarker markerCreated1 = jasmine.createSpy().andCallFake (marker) -> marker.destroy()
+          displayBuffer2.onDidCreateMarker markerCreated2 = jasmine.createSpy()
 
           displayBuffer.markBufferRange([[0, 0], [1, 5]], {})
 
@@ -1051,15 +1050,15 @@ describe "DisplayBuffer", ->
           expect(markerCreated2).not.toHaveBeenCalled()
 
   describe "decorations", ->
-    [marker, decoration, decorationParams] = []
+    [marker, decoration, decorationProperties] = []
     beforeEach ->
       marker = displayBuffer.markBufferRange([[2, 13], [3, 15]])
-      decorationParams = {type: 'gutter', class: 'one'}
-      decoration = displayBuffer.decorateMarker(marker, decorationParams)
+      decorationProperties = {type: 'gutter', class: 'one'}
+      decoration = displayBuffer.decorateMarker(marker, decorationProperties)
 
     it "can add decorations associated with markers and remove them", ->
       expect(decoration).toBeDefined()
-      expect(decoration.getParams()).toBe decorationParams
+      expect(decoration.getProperties()).toBe decorationProperties
       expect(displayBuffer.decorationForId(decoration.id)).toBe decoration
       expect(displayBuffer.decorationsForScreenRowRange(2, 3)[marker.id][0]).toBe decoration
 
@@ -1074,12 +1073,12 @@ describe "DisplayBuffer", ->
 
     describe "when a decoration is updated via Decoration::update()", ->
       it "emits an 'updated' event containing the new and old params", ->
-        decoration.on 'updated', updatedSpy = jasmine.createSpy()
-        decoration.update type: 'gutter', class: 'two'
+        decoration.onDidChangeProperties updatedSpy = jasmine.createSpy()
+        decoration.setProperties type: 'gutter', class: 'two'
 
-        {oldParams, newParams} = updatedSpy.mostRecentCall.args[0]
-        expect(oldParams).toEqual decorationParams
-        expect(newParams).toEqual type: 'gutter', class: 'two', id: decoration.id
+        {oldProperties, newProperties} = updatedSpy.mostRecentCall.args[0]
+        expect(oldProperties).toEqual decorationProperties
+        expect(newProperties).toEqual type: 'gutter', class: 'two', id: decoration.id
 
   describe "::setScrollTop", ->
     beforeEach ->
@@ -1101,6 +1100,33 @@ describe "DisplayBuffer", ->
       expect(displayBuffer.setScrollTop(maxScrollTop + 50)).toBe maxScrollTop
       expect(displayBuffer.getScrollTop()).toBe maxScrollTop
 
+  describe "editor.scrollPastEnd", ->
+    describe "when editor.scrollPastEnd is false", ->
+      beforeEach ->
+        atom.config.set("editor.scrollPastEnd", false)
+        displayBuffer.manageScrollPosition = true
+        displayBuffer.setLineHeightInPixels(10)
+
+      it "does not add the height of the view to the scroll height", ->
+        lineHeight = displayBuffer.getLineHeightInPixels()
+        originalScrollHeight = displayBuffer.getScrollHeight()
+        displayBuffer.setHeight(50)
+
+        expect(displayBuffer.getScrollHeight()).toBe originalScrollHeight
+
+    describe "when editor.scrollPastEnd is true", ->
+      beforeEach ->
+        atom.config.set("editor.scrollPastEnd", true)
+        displayBuffer.manageScrollPosition = true
+        displayBuffer.setLineHeightInPixels(10)
+
+      it "adds the height of the view to the scroll height", ->
+        lineHeight = displayBuffer.getLineHeightInPixels()
+        originalScrollHeight = displayBuffer.getScrollHeight()
+        displayBuffer.setHeight(50)
+
+        expect(displayBuffer.getScrollHeight()).toEqual(originalScrollHeight + displayBuffer.height - (lineHeight * 3))
+
   describe "::setScrollLeft", ->
     beforeEach ->
       displayBuffer.manageScrollPosition = true
@@ -1172,7 +1198,7 @@ describe "DisplayBuffer", ->
     it "recomputes the scroll width when the scoped character widths change in a batch", ->
       operatorWidth = 20
 
-      displayBuffer.on 'character-widths-changed', changedSpy = jasmine.createSpy()
+      displayBuffer.onDidChangeCharacterWidths changedSpy = jasmine.createSpy()
 
       displayBuffer.batchCharacterMeasurement ->
         displayBuffer.setScopedCharWidth(['source.js', 'keyword.operator.js'], '<', operatorWidth)

spec/fixtures/packages/package-that-throws-on-deactivate/index.coffee

@@ -0,0 +1,4 @@
+module.exports =
+  activate: ->
+  deactivate: -> throw new Error('Top that')
+  serialize: ->

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

@@ -0,0 +1,13 @@
+module.exports =
+  activateCallCount: 0
+  activationCommandCallCount: 0
+  legacyActivationCommandCallCount: 0
+
+  activate: ->
+    @activateCallCount++
+
+    atom.commands.add '.workspace', 'activation-command', =>
+      @activationCommandCallCount++
+
+    atom.workspaceView.getActiveView()?.command 'activation-command', =>
+      @legacyActivationCommandCallCount++

spec/fixtures/packages/package-with-activation-commands/package.cson

@@ -0,0 +1,2 @@
+'activationCommands':
+  '.workspace': 'activation-command'

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

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

spec/fixtures/packages/package-with-activation-events/package.cson

@@ -1 +0,0 @@
-'activationEvents': ['activation-event']

spec/fixtures/packages/package-with-config-schema/index.coffee

@@ -0,0 +1,13 @@
+module.exports =
+  config:
+    numbers:
+      type: 'object'
+      properties:
+        one:
+          type: 'integer'
+          default: 1
+        two:
+          type: 'integer'
+          default: 2
+
+  activate: -> # no-op

spec/fixtures/packages/package-with-empty-activation-commands/package.json

@@ -1,5 +1,5 @@
 {
   "name": "no events",
   "version": "0.1.0",
-  "activationEvents": []
+  "activationCommands": {".workspace": []}
 }

spec/fixtures/packages/package-with-menus/menus/menu-1.cson

@@ -1,7 +1,8 @@
 'menu': [
-  { 'label': 'Second to Last' }
+  {'label': 'Second to Last'}
 ]
 
 'context-menu':
-  '.test-1':
-    'Menu item 1': 'command-1'
+  '.test-1': [
+    {label: 'Menu item 1', command: 'command-1'}
+  ]

spec/fixtures/packages/package-with-menus/menus/menu-2.cson

@@ -3,5 +3,6 @@
 ]
 
 'context-menu':
-  '.test-1':
-    'Menu item 2': 'command-2'
+  '.test-1': [
+    {label: 'Menu item 2', command: 'command-2'}
+  ]

spec/fixtures/packages/package-with-menus/menus/menu-3.cson

@@ -3,5 +3,6 @@
 ]
 
 'context-menu':
-  '.test-1':
-    'Menu item 3': 'command-3'
+  '.test-1': [
+    {label: 'Menu item 3', command: 'command-3'}
+  ]

spec/git-spec.coffee

@@ -1,5 +1,5 @@
 temp = require 'temp'
-Git = require '../src/git'
+GitRepository = require '../src/git-repository'
 fs = require 'fs-plus'
 path = require 'path'
 Task = require '../src/task'
@@ -10,7 +10,7 @@ copyRepository = ->
   fs.renameSync(path.join(workingDirPath, 'git.git'), path.join(workingDirPath, '.git'))
   workingDirPath
 
-describe "Git", ->
+describe "GitRepository", ->
   repo = null
 
   beforeEach ->
@@ -22,28 +22,28 @@ describe "Git", ->
 
   describe "@open(path)", ->
     it "returns null when no repository is found", ->
-      expect(Git.open(path.join(temp.dir, 'nogit.txt'))).toBeNull()
+      expect(GitRepository.open(path.join(temp.dir, 'nogit.txt'))).toBeNull()
 
-  describe "new Git(path)", ->
+  describe "new GitRepository(path)", ->
     it "throws an exception when no repository is found", ->
-      expect(-> new Git(path.join(temp.dir, 'nogit.txt'))).toThrow()
+      expect(-> new GitRepository(path.join(temp.dir, 'nogit.txt'))).toThrow()
 
   describe ".getPath()", ->
     it "returns the repository path for a .git directory path", ->
-      repo = new Git(path.join(__dirname, 'fixtures', 'git', 'master.git', 'HEAD'))
+      repo = new GitRepository(path.join(__dirname, 'fixtures', 'git', 'master.git', 'HEAD'))
       expect(repo.getPath()).toBe path.join(__dirname, 'fixtures', 'git', 'master.git')
 
     it "returns the repository path for a repository path", ->
-      repo = new Git(path.join(__dirname, 'fixtures', 'git', 'master.git'))
+      repo = new GitRepository(path.join(__dirname, 'fixtures', 'git', 'master.git'))
       expect(repo.getPath()).toBe path.join(__dirname, 'fixtures', 'git', 'master.git')
 
   describe ".isPathIgnored(path)", ->
     it "returns true for an ignored path", ->
-      repo = new Git(path.join(__dirname, 'fixtures', 'git', 'ignore.git'))
+      repo = new GitRepository(path.join(__dirname, 'fixtures', 'git', 'ignore.git'))
       expect(repo.isPathIgnored('a.txt')).toBeTruthy()
 
     it "returns false for a non-ignored path", ->
-      repo = new Git(path.join(__dirname, 'fixtures', 'git', 'ignore.git'))
+      repo = new GitRepository(path.join(__dirname, 'fixtures', 'git', 'ignore.git'))
       expect(repo.isPathIgnored('b.txt')).toBeFalsy()
 
   describe ".isPathModified(path)", ->
@@ -51,7 +51,7 @@ describe "Git", ->
 
     beforeEach ->
       workingDirPath = copyRepository()
-      repo = new Git(workingDirPath)
+      repo = new GitRepository(workingDirPath)
       filePath = path.join(workingDirPath, 'a.txt')
       newPath = path.join(workingDirPath, 'new-path.txt')
 
@@ -75,7 +75,7 @@ describe "Git", ->
 
     beforeEach ->
       workingDirPath = copyRepository()
-      repo = new Git(workingDirPath)
+      repo = new GitRepository(workingDirPath)
       filePath = path.join(workingDirPath, 'a.txt')
       newPath = path.join(workingDirPath, 'new-path.txt')
       fs.writeFileSync(newPath, "i'm new here")
@@ -92,7 +92,7 @@ describe "Git", ->
 
     beforeEach ->
       workingDirPath = copyRepository()
-      repo = new Git(workingDirPath)
+      repo = new GitRepository(workingDirPath)
       filePath = path.join(workingDirPath, 'a.txt')
 
     it "no longer reports a path as modified after checkout", ->
@@ -111,10 +111,10 @@ describe "Git", ->
       fs.writeFileSync(filePath, 'ch ch changes')
       repo.getPathStatus(filePath)
       statusHandler = jasmine.createSpy('statusHandler')
-      repo.on 'status-changed', statusHandler
+      repo.onDidChangeStatus statusHandler
       repo.checkoutHead(filePath)
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler.argsForCall[0][0..1]).toEqual [filePath, 0]
+      expect(statusHandler.argsForCall[0][0]).toEqual {path: filePath, pathStatus: 0}
 
       repo.checkoutHead(filePath)
       expect(statusHandler.callCount).toBe 1
@@ -124,7 +124,7 @@ describe "Git", ->
 
     beforeEach ->
       workingDirPath = copyRepository()
-      repo = new Git(workingDirPath)
+      repo = new GitRepository(workingDirPath)
       filePath = path.join(workingDirPath, 'a.txt')
       fs.writeFileSync(filePath, 'ch ch changes')
 
@@ -153,7 +153,7 @@ describe "Git", ->
 
   describe ".destroy()", ->
     it "throws an exception when any method is called after it is called", ->
-      repo = new Git(require.resolve('./fixtures/git/master.git/HEAD'))
+      repo = new GitRepository(require.resolve('./fixtures/git/master.git/HEAD'))
       repo.destroy()
       expect(-> repo.getShortHead()).toThrow()
 
@@ -162,16 +162,16 @@ describe "Git", ->
 
     beforeEach ->
       workingDirectory = copyRepository()
-      repo = new Git(workingDirectory)
+      repo = new GitRepository(workingDirectory)
       filePath = path.join(workingDirectory, 'file.txt')
 
     it "trigger a status-changed event when the new status differs from the last cached one", ->
       statusHandler = jasmine.createSpy("statusHandler")
-      repo.on 'status-changed', statusHandler
+      repo.onDidChangeStatus statusHandler
       fs.writeFileSync(filePath, '')
       status = repo.getPathStatus(filePath)
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler.argsForCall[0][0..1]).toEqual [filePath, status]
+      expect(statusHandler.argsForCall[0][0]).toEqual {path: filePath, pathStatus: status}
 
       fs.writeFileSync(filePath, 'abc')
       status = repo.getPathStatus(filePath)
@@ -182,7 +182,7 @@ describe "Git", ->
 
     beforeEach ->
       workingDirectory = copyRepository()
-      repo = new Git(workingDirectory)
+      repo = new GitRepository(workingDirectory)
       directoryPath = path.join(workingDirectory, 'dir')
       filePath = path.join(directoryPath, 'b.txt')
 
@@ -197,7 +197,7 @@ describe "Git", ->
 
     beforeEach ->
       workingDirectory = copyRepository()
-      repo = new Git(workingDirectory)
+      repo = new GitRepository(workingDirectory)
       modifiedPath = path.join(workingDirectory, 'file.txt')
       newPath = path.join(workingDirectory, 'untracked.txt')
       cleanPath = path.join(workingDirectory, 'other.txt')
@@ -208,7 +208,7 @@ describe "Git", ->
     it "returns status information for all new and modified files", ->
       fs.writeFileSync(modifiedPath, 'making this path modified')
       statusHandler = jasmine.createSpy('statusHandler')
-      repo.on 'statuses-changed', statusHandler
+      repo.onDidChangeStatuses statusHandler
       repo.refreshStatus()
 
       waitsFor ->
@@ -232,19 +232,19 @@ describe "Git", ->
       editor.insertNewline()
 
       statusHandler = jasmine.createSpy('statusHandler')
-      atom.project.getRepo().on 'status-changed', statusHandler
+      atom.project.getRepo().onDidChangeStatus statusHandler
       editor.save()
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler).toHaveBeenCalledWith editor.getPath(), 256
+      expect(statusHandler).toHaveBeenCalledWith {path: editor.getPath(), pathStatus: 256}
 
     it "emits a status-changed event when a buffer is reloaded", ->
       fs.writeFileSync(editor.getPath(), 'changed')
 
       statusHandler = jasmine.createSpy('statusHandler')
-      atom.project.getRepo().on 'status-changed', statusHandler
+      atom.project.getRepo().onDidChangeStatus statusHandler
       editor.getBuffer().reload()
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler).toHaveBeenCalledWith editor.getPath(), 256
+      expect(statusHandler).toHaveBeenCalledWith {path: editor.getPath(), pathStatus: 256}
       editor.getBuffer().reload()
       expect(statusHandler.callCount).toBe 1
 
@@ -252,10 +252,10 @@ describe "Git", ->
       fs.writeFileSync(editor.getPath(), 'changed')
 
       statusHandler = jasmine.createSpy('statusHandler')
-      atom.project.getRepo().on 'status-changed', statusHandler
+      atom.project.getRepo().onDidChangeStatus statusHandler
       editor.getBuffer().emitter.emit 'did-change-path'
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler).toHaveBeenCalledWith editor.getPath(), 256
+      expect(statusHandler).toHaveBeenCalledWith {path: editor.getPath(), pathStatus: 256}
       editor.getBuffer().emitter.emit 'did-change-path'
       expect(statusHandler.callCount).toBe 1
 
@@ -283,7 +283,7 @@ describe "Git", ->
         buffer.append('changes')
 
         statusHandler = jasmine.createSpy('statusHandler')
-        project2.getRepo().on 'status-changed', statusHandler
+        project2.getRepo().onDidChangeStatus statusHandler
         buffer.save()
         expect(statusHandler.callCount).toBe 1
-        expect(statusHandler).toHaveBeenCalledWith buffer.getPath(), 256
+        expect(statusHandler).toHaveBeenCalledWith {path: buffer.getPath(), pathStatus: 256}

spec/jasmine-helper.coffee

@@ -7,6 +7,8 @@ module.exports.runSpecSuite = (specSuite, logFile, logErrors=true) ->
 
   {TerminalReporter} = require 'jasmine-tagged'
 
+  disableFocusMethods() if process.env.JANKY_SHA1
+
   TimeReporter = require './time-reporter'
   timeReporter = new TimeReporter()
 
@@ -38,3 +40,10 @@ module.exports.runSpecSuite = (specSuite, logFile, logErrors=true) ->
   $('body').append $$ -> @div id: 'jasmine-content'
 
   jasmineEnv.execute()
+
+disableFocusMethods = ->
+  ['fdescribe', 'ffdescribe', 'fffdescribe', 'fit', 'ffit', 'fffit'].forEach (methodName) ->
+    focusMethod = window[methodName]
+    window[methodName] = (description) ->
+      error = new Error('Focused spec is running on CI')
+      focusMethod description, -> throw error

spec/language-mode-spec.coffee

@@ -14,6 +14,10 @@ describe "LanguageMode", ->
       waitsForPromise ->
         atom.packages.activatePackage('language-javascript')
 
+    afterEach ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
     describe ".minIndentLevelForRowRange(startRow, endRow)", ->
       it "returns the minimum indent level for the given row range", ->
         expect(languageMode.minIndentLevelForRowRange(4, 7)).toBe 2
@@ -70,6 +74,28 @@ describe "LanguageMode", ->
         expect(languageMode.rowRangeForCodeFoldAtBufferRow(2)).toBeNull()
         expect(languageMode.rowRangeForCodeFoldAtBufferRow(4)).toEqual [4, 7]
 
+    describe ".rowRangeForCommentAtBufferRow(bufferRow)", ->
+      it "returns the start/end rows of the foldable comment starting at the given row", ->
+        buffer.setText("//this is a multi line comment\n//another line")
+        expect(languageMode.rowRangeForCommentAtBufferRow(0)).toEqual [0, 1]
+        expect(languageMode.rowRangeForCommentAtBufferRow(1)).toEqual [0, 1]
+
+        buffer.setText("//this is a multi line comment\n//another line\n//and one more")
+        expect(languageMode.rowRangeForCommentAtBufferRow(0)).toEqual [0, 2]
+        expect(languageMode.rowRangeForCommentAtBufferRow(1)).toEqual [0, 2]
+
+        buffer.setText("//this is a multi line comment\n\n//with an empty line")
+        expect(languageMode.rowRangeForCommentAtBufferRow(0)).toBeUndefined()
+        expect(languageMode.rowRangeForCommentAtBufferRow(1)).toBeUndefined()
+        expect(languageMode.rowRangeForCommentAtBufferRow(2)).toBeUndefined()
+
+        buffer.setText("//this is a single line comment\n")
+        expect(languageMode.rowRangeForCommentAtBufferRow(0)).toBeUndefined()
+        expect(languageMode.rowRangeForCommentAtBufferRow(1)).toBeUndefined()
+
+        buffer.setText("//this is a single line comment")
+        expect(languageMode.rowRangeForCommentAtBufferRow(0)).toBeUndefined()
+
     describe "suggestedIndentForBufferRow", ->
       it "returns the suggested indentation based on auto-indent/outdent rules", ->
         expect(languageMode.suggestedIndentForBufferRow(0)).toBe 0
@@ -127,6 +153,10 @@ describe "LanguageMode", ->
       waitsForPromise ->
         atom.packages.activatePackage('language-coffee-script')
 
+    afterEach ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
     describe ".toggleLineCommentsForBufferRows(start, end)", ->
       it "comments/uncomments lines in the given range", ->
         languageMode.toggleLineCommentsForBufferRows(4, 6)
@@ -178,6 +208,10 @@ describe "LanguageMode", ->
       waitsForPromise ->
         atom.packages.activatePackage('language-css')
 
+    afterEach ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
     describe ".toggleLineCommentsForBufferRows(start, end)", ->
       it "comments/uncomments lines in the given range", ->
         languageMode.toggleLineCommentsForBufferRows(0, 1)
@@ -226,6 +260,10 @@ describe "LanguageMode", ->
       waitsForPromise ->
         atom.packages.activatePackage('language-css')
 
+    afterEach ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
     describe "when commenting lines", ->
       it "only uses the `commentEnd` pattern if it comes from the same grammar as the `commentStart`", ->
         languageMode.toggleLineCommentsForBufferRows(0, 0)
@@ -242,6 +280,10 @@ describe "LanguageMode", ->
       waitsForPromise ->
         atom.packages.activatePackage('language-xml')
 
+    afterEach ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
     describe "when uncommenting lines", ->
       it "removes the leading whitespace from the comment end pattern match", ->
         languageMode.toggleLineCommentsForBufferRows(0, 0)
@@ -257,6 +299,10 @@ describe "LanguageMode", ->
       waitsForPromise ->
         atom.packages.activatePackage('language-javascript')
 
+    afterEach ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
     it "maintains cursor buffer position when a folding/unfolding", ->
       editor.setCursorBufferPosition([5,5])
       languageMode.foldAll()
@@ -344,6 +390,10 @@ describe "LanguageMode", ->
       waitsForPromise ->
         atom.packages.activatePackage('language-javascript')
 
+    afterEach ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
     describe ".unfoldAll()", ->
       it "unfolds every folded line", ->
         initialScreenLineCount = editor.getScreenLineCount()
@@ -413,6 +463,10 @@ describe "LanguageMode", ->
         atom.packages.activatePackage('language-source')
         atom.packages.activatePackage('language-css')
 
+    afterEach ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
     describe "suggestedIndentForBufferRow", ->
       it "does not return negative values (regression)", ->
         editor.setText('.test {\npadding: 0;\n}')

spec/menu-manager-spec.coffee

@@ -0,0 +1,48 @@
+MenuManager = require '../src/menu-manager'
+
+describe "MenuManager", ->
+  menu = null
+
+  beforeEach ->
+    menu = new MenuManager(resourcePath: atom.getLoadSettings().resourcePath)
+
+  describe "::add(items)", ->
+    it "can add new menus that can be removed with the returned disposable", ->
+      disposable = menu.add [{label: "A", submenu: [{label: "B", command: "b"}]}]
+      expect(menu.template).toEqual [{label: "A", submenu: [{label: "B", command: "b"}]}]
+      disposable.dispose()
+      expect(menu.template).toEqual []
+
+    it "can add submenu items to existing menus that can be removed with the returned disposable", ->
+      disposable1 = menu.add [{label: "A", submenu: [{label: "B", command: "b"}]}]
+      disposable2 = menu.add [{label: "A", submenu: [{label: "C", submenu: [{label: "D", command: 'd'}]}]}]
+      disposable3 = menu.add [{label: "A", submenu: [{label: "C", submenu: [{label: "E", command: 'e'}]}]}]
+
+      expect(menu.template).toEqual [{
+        label: "A",
+        submenu: [
+          {label: "B", command: "b"},
+          {label: "C", submenu: [{label: 'D', command: 'd'}, {label: 'E', command: 'e'}]}
+        ]
+      }]
+
+      disposable3.dispose()
+      expect(menu.template).toEqual [{
+        label: "A",
+        submenu: [
+          {label: "B", command: "b"},
+          {label: "C", submenu: [{label: 'D', command: 'd'}]}
+        ]
+      }]
+
+      disposable2.dispose()
+      expect(menu.template).toEqual [{label: "A", submenu: [{label: "B", command: "b"}]}]
+
+      disposable1.dispose()
+      expect(menu.template).toEqual []
+
+    it "does not add duplicate labels to the same menu", ->
+      originalItemCount = menu.template.length
+      menu.add [{label: "A", submenu: [{label: "B", command: "b"}]}]
+      menu.add [{label: "A", submenu: [{label: "B", command: "b"}]}]
+      expect(menu.template[originalItemCount]).toEqual {label: "A", submenu: [{label: "B", command: "b"}]}

spec/package-manager-spec.coffee

@@ -0,0 +1,570 @@
+{$, $$, WorkspaceView}  = require 'atom'
+Package = require '../src/package'
+
+describe "PackageManager", ->
+  beforeEach ->
+    atom.workspaceView = new WorkspaceView
+
+  describe "::loadPackage(name)", ->
+    it "continues if the package has an invalid package.json", ->
+      spyOn(console, 'warn')
+      atom.config.set("core.disabledPackages", [])
+      expect(-> atom.packages.loadPackage("package-with-broken-package-json")).not.toThrow()
+
+    it "continues if the package has an invalid keymap", ->
+      spyOn(console, 'warn')
+      atom.config.set("core.disabledPackages", [])
+      expect(-> atom.packages.loadPackage("package-with-broken-keymap")).not.toThrow()
+
+  describe "::unloadPackage(name)", ->
+    describe "when the package is active", ->
+      it "throws an error", ->
+        pack = null
+        waitsForPromise ->
+          atom.packages.activatePackage('package-with-main').then (p) -> pack = p
+
+        runs ->
+          expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
+          expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
+          expect( -> atom.packages.unloadPackage(pack.name)).toThrow()
+          expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
+          expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
+
+    describe "when the package is not loaded", ->
+      it "throws an error", ->
+        expect(atom.packages.isPackageLoaded('unloaded')).toBeFalsy()
+        expect( -> atom.packages.unloadPackage('unloaded')).toThrow()
+        expect(atom.packages.isPackageLoaded('unloaded')).toBeFalsy()
+
+    describe "when the package is loaded", ->
+      it "no longers reports it as being loaded", ->
+        pack = atom.packages.loadPackage('package-with-main')
+        expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
+        atom.packages.unloadPackage(pack.name)
+        expect(atom.packages.isPackageLoaded(pack.name)).toBeFalsy()
+
+  describe "::activatePackage(id)", ->
+    describe "atom packages", ->
+      describe "when called multiple times", ->
+        it "it only calls activate on the package once", ->
+          spyOn(Package.prototype, 'activateNow').andCallThrough()
+          atom.packages.activatePackage('package-with-index')
+          atom.packages.activatePackage('package-with-index')
+
+          waitsForPromise ->
+            atom.packages.activatePackage('package-with-index')
+
+          runs ->
+            expect(Package.prototype.activateNow.callCount).toBe 1
+
+      describe "when the package has a main module", ->
+        describe "when the metadata specifies a main module path˜", ->
+          it "requires the module at the specified path", ->
+            mainModule = require('./fixtures/packages/package-with-main/main-module')
+            spyOn(mainModule, 'activate')
+            pack = null
+            waitsForPromise ->
+              atom.packages.activatePackage('package-with-main').then (p) -> pack = p
+
+            runs ->
+              expect(mainModule.activate).toHaveBeenCalled()
+              expect(pack.mainModule).toBe mainModule
+
+        describe "when the metadata does not specify a main module", ->
+          it "requires index.coffee", ->
+            indexModule = require('./fixtures/packages/package-with-index/index')
+            spyOn(indexModule, 'activate')
+            pack = null
+            waitsForPromise ->
+              atom.packages.activatePackage('package-with-index').then (p) -> pack = p
+
+            runs ->
+              expect(indexModule.activate).toHaveBeenCalled()
+              expect(pack.mainModule).toBe indexModule
+
+        it "assigns config schema, including defaults when package contains a schema", ->
+          expect(atom.config.get('package-with-config-schema.numbers.one')).toBeUndefined()
+
+          waitsForPromise ->
+            atom.packages.activatePackage('package-with-config-schema')
+
+          runs ->
+            expect(atom.config.get('package-with-config-schema.numbers.one')).toBe 1
+            expect(atom.config.get('package-with-config-schema.numbers.two')).toBe 2
+
+            expect(atom.config.set('package-with-config-schema.numbers.one', 'nope')).toBe false
+            expect(atom.config.set('package-with-config-schema.numbers.one', '10')).toBe true
+            expect(atom.config.get('package-with-config-schema.numbers.one')).toBe 10
+
+        it "still assigns configDefaults from the module though deprecated", ->
+          expect(atom.config.get('package-with-config-defaults.numbers.one')).toBeUndefined()
+
+          waitsForPromise ->
+            atom.packages.activatePackage('package-with-config-defaults')
+
+          runs ->
+            expect(atom.config.get('package-with-config-defaults.numbers.one')).toBe 1
+            expect(atom.config.get('package-with-config-defaults.numbers.two')).toBe 2
+
+        describe "when the package metadata includes `activationCommands`", ->
+          [mainModule, promise, workspaceCommandListener] = []
+
+          beforeEach ->
+            atom.workspaceView.attachToDom()
+            mainModule = require './fixtures/packages/package-with-activation-commands/index'
+            mainModule.legacyActivationCommandCallCount = 0
+            mainModule.activationCommandCallCount = 0
+            spyOn(mainModule, 'activate').andCallThrough()
+            spyOn(Package.prototype, 'requireMainModule').andCallThrough()
+
+            workspaceCommandListener = jasmine.createSpy('workspaceCommandListener')
+            atom.commands.add '.workspace', 'activation-command', workspaceCommandListener
+
+            promise = atom.packages.activatePackage('package-with-activation-commands')
+
+          it "defers requiring/activating the main module until an activation event bubbles to the root view", ->
+            expect(promise.isFulfilled()).not.toBeTruthy()
+            atom.workspaceView[0].dispatchEvent(new CustomEvent('activation-command', bubbles: true))
+
+            waitsForPromise ->
+              promise
+
+          it "triggers the activation event on all handlers registered during activation", ->
+            waitsForPromise ->
+              atom.workspaceView.open()
+
+            runs ->
+              editorView = atom.workspaceView.getActiveView()
+              legacyCommandListener = jasmine.createSpy("legacyCommandListener")
+              editorView.command 'activation-command', legacyCommandListener
+              editorCommandListener = jasmine.createSpy("editorCommandListener")
+              atom.commands.add '.editor', 'activation-command', editorCommandListener
+              editorView[0].dispatchEvent(new CustomEvent('activation-command', bubbles: true))
+              expect(mainModule.activate.callCount).toBe 1
+              expect(mainModule.legacyActivationCommandCallCount).toBe 1
+              expect(mainModule.activationCommandCallCount).toBe 1
+              expect(legacyCommandListener.callCount).toBe 1
+              expect(editorCommandListener.callCount).toBe 1
+              expect(workspaceCommandListener.callCount).toBe 1
+              editorView[0].dispatchEvent(new CustomEvent('activation-command', bubbles: true))
+              expect(mainModule.legacyActivationCommandCallCount).toBe 2
+              expect(mainModule.activationCommandCallCount).toBe 2
+              expect(legacyCommandListener.callCount).toBe 2
+              expect(editorCommandListener.callCount).toBe 2
+              expect(workspaceCommandListener.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-commands/index'
+            spyOn(mainModule, 'activate').andCallThrough()
+
+            waitsForPromise ->
+              atom.packages.activatePackage('package-with-empty-activation-commands')
+
+            runs ->
+              expect(mainModule.activate.callCount).toBe 1
+
+      describe "when the package has no main module", ->
+        it "does not throw an exception", ->
+          spyOn(console, "error")
+          spyOn(console, "warn").andCallThrough()
+          expect(-> atom.packages.activatePackage('package-without-module')).not.toThrow()
+          expect(console.error).not.toHaveBeenCalled()
+          expect(console.warn).not.toHaveBeenCalled()
+
+      it "passes the activate method the package's previously serialized state if it exists", ->
+        pack = null
+        waitsForPromise ->
+          atom.packages.activatePackage("package-with-serialization").then (p) -> pack = p
+
+        runs ->
+          expect(pack.mainModule.someNumber).not.toBe 77
+          pack.mainModule.someNumber = 77
+          atom.packages.deactivatePackage("package-with-serialization")
+          spyOn(pack.mainModule, 'activate').andCallThrough()
+          atom.packages.activatePackage("package-with-serialization")
+          expect(pack.mainModule.activate).toHaveBeenCalledWith({someNumber: 77})
+
+      it "logs warning instead of throwing an exception if the package fails to load", ->
+        atom.config.set("core.disabledPackages", [])
+        spyOn(console, "warn")
+        expect(-> atom.packages.activatePackage("package-that-throws-an-exception")).not.toThrow()
+        expect(console.warn).toHaveBeenCalled()
+
+      describe "keymap loading", ->
+        describe "when the metadata does not contain a 'keymaps' manifest", ->
+          it "loads all the .cson/.json files in the keymaps directory", ->
+            element1 = $$ -> @div class: 'test-1'
+            element2 = $$ -> @div class: 'test-2'
+            element3 = $$ -> @div class: 'test-3'
+
+            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.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.keymaps.findKeyBindings(keystrokes:'ctrl-z', target:element1[0])).toHaveLength 0
+
+            atom.packages.activatePackage("package-with-keymaps-manifest")
+
+            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 ->
+          atom.contextMenu.definitions = []
+          atom.menu.template = []
+
+        describe "when the metadata does not contain a 'menus' manifest", ->
+          it "loads all the .cson/.json files in the menus directory", ->
+            element = ($$ -> @div class: 'test-1')[0]
+
+            expect(atom.contextMenu.templateForElement(element)).toEqual []
+
+            atom.packages.activatePackage("package-with-menus")
+
+            expect(atom.menu.template.length).toBe 2
+            expect(atom.menu.template[0].label).toBe "Second to Last"
+            expect(atom.menu.template[1].label).toBe "Last"
+            expect(atom.contextMenu.templateForElement(element)[0].label).toBe "Menu item 1"
+            expect(atom.contextMenu.templateForElement(element)[1].label).toBe "Menu item 2"
+            expect(atom.contextMenu.templateForElement(element)[2].label).toBe "Menu item 3"
+
+        describe "when the metadata contains a 'menus' manifest", ->
+          it "loads only the menus specified by the manifest, in the specified order", ->
+            element = ($$ -> @div class: 'test-1')[0]
+
+            expect(atom.contextMenu.templateForElement(element)).toEqual []
+
+            atom.packages.activatePackage("package-with-menus-manifest")
+
+            expect(atom.menu.template[0].label).toBe "Second to Last"
+            expect(atom.menu.template[1].label).toBe "Last"
+            expect(atom.contextMenu.templateForElement(element)[0].label).toBe "Menu item 2"
+            expect(atom.contextMenu.templateForElement(element)[1].label).toBe "Menu item 1"
+            expect(atom.contextMenu.templateForElement(element)[2]).toBeUndefined()
+
+      describe "stylesheet loading", ->
+        describe "when the metadata contains a 'stylesheets' manifest", ->
+          it "loads stylesheets from the stylesheets directory as specified by the manifest", ->
+            one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css")
+            two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less")
+            three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css")
+
+            one = atom.themes.stringToId(one)
+            two = atom.themes.stringToId(two)
+            three = atom.themes.stringToId(three)
+
+            expect(atom.themes.stylesheetElementForId(one)).toBeNull()
+            expect(atom.themes.stylesheetElementForId(two)).toBeNull()
+            expect(atom.themes.stylesheetElementForId(three)).toBeNull()
+
+            atom.packages.activatePackage("package-with-stylesheets-manifest")
+
+            expect(atom.themes.stylesheetElementForId(one)).not.toBeNull()
+            expect(atom.themes.stylesheetElementForId(two)).not.toBeNull()
+            expect(atom.themes.stylesheetElementForId(three)).toBeNull()
+            expect($('#jasmine-content').css('font-size')).toBe '1px'
+
+        describe "when the metadata does not contain a 'stylesheets' manifest", ->
+          it "loads all stylesheets from the stylesheets directory", ->
+            one = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/1.css")
+            two = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/2.less")
+            three = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/3.css")
+
+
+            one = atom.themes.stringToId(one)
+            two = atom.themes.stringToId(two)
+            three = atom.themes.stringToId(three)
+
+            expect(atom.themes.stylesheetElementForId(one)).toBeNull()
+            expect(atom.themes.stylesheetElementForId(two)).toBeNull()
+            expect(atom.themes.stylesheetElementForId(three)).toBeNull()
+
+            atom.packages.activatePackage("package-with-stylesheets")
+            expect(atom.themes.stylesheetElementForId(one)).not.toBeNull()
+            expect(atom.themes.stylesheetElementForId(two)).not.toBeNull()
+            expect(atom.themes.stylesheetElementForId(three)).not.toBeNull()
+            expect($('#jasmine-content').css('font-size')).toBe '3px'
+
+      describe "grammar loading", ->
+        it "loads the package's grammars", ->
+          waitsForPromise ->
+            atom.packages.activatePackage('package-with-grammars')
+
+          runs ->
+            expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Alot'
+            expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Alittle'
+
+      describe "scoped-property loading", ->
+        it "loads the scoped properties", ->
+          waitsForPromise ->
+            atom.packages.activatePackage("package-with-scoped-properties")
+
+          runs ->
+            expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
+
+    describe "converted textmate packages", ->
+      it "loads the package's grammars", ->
+        expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+
+        waitsForPromise ->
+          atom.packages.activatePackage('language-ruby')
+
+        runs ->
+          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
+
+      it "loads the translated scoped properties", ->
+        expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
+
+        waitsForPromise ->
+          atom.packages.activatePackage('language-ruby')
+
+        runs ->
+          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBe '# '
+
+  describe "::deactivatePackage(id)", ->
+    describe "atom packages", ->
+      it "calls `deactivate` on the package's main module if activate was successful", ->
+        pack = null
+        waitsForPromise ->
+          atom.packages.activatePackage("package-with-deactivate").then (p) -> pack = p
+
+        runs ->
+          expect(atom.packages.isPackageActive("package-with-deactivate")).toBeTruthy()
+          spyOn(pack.mainModule, 'deactivate').andCallThrough()
+
+          atom.packages.deactivatePackage("package-with-deactivate")
+          expect(pack.mainModule.deactivate).toHaveBeenCalled()
+          expect(atom.packages.isPackageActive("package-with-module")).toBeFalsy()
+
+          spyOn(console, 'warn')
+
+        badPack = null
+        waitsForPromise ->
+          atom.packages.activatePackage("package-that-throws-on-activate").then (p) -> badPack = p
+
+        runs ->
+          expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeTruthy()
+          spyOn(badPack.mainModule, 'deactivate').andCallThrough()
+
+          atom.packages.deactivatePackage("package-that-throws-on-activate")
+          expect(badPack.mainModule.deactivate).not.toHaveBeenCalled()
+          expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeFalsy()
+
+      it "does not serialize packages that have not been activated called on their main module", ->
+        spyOn(console, 'warn')
+        badPack = null
+        waitsForPromise ->
+          atom.packages.activatePackage("package-that-throws-on-activate").then (p) -> badPack = p
+
+        runs ->
+          spyOn(badPack.mainModule, 'serialize').andCallThrough()
+
+          atom.packages.deactivatePackage("package-that-throws-on-activate")
+          expect(badPack.mainModule.serialize).not.toHaveBeenCalled()
+
+      it "absorbs exceptions that are thrown by the package module's serialize method", ->
+        spyOn(console, 'error')
+
+        waitsForPromise ->
+          atom.packages.activatePackage('package-with-serialize-error')
+
+        waitsForPromise ->
+          atom.packages.activatePackage('package-with-serialization')
+
+        runs ->
+          atom.packages.deactivatePackages()
+          expect(atom.packages.packageStates['package-with-serialize-error']).toBeUndefined()
+          expect(atom.packages.packageStates['package-with-serialization']).toEqual someNumber: 1
+          expect(console.error).toHaveBeenCalled()
+
+      it "absorbs exceptions that are thrown by the package module's deactivate method", ->
+        spyOn(console, 'error')
+
+        waitsForPromise ->
+          atom.packages.activatePackage("package-that-throws-on-deactivate")
+
+        runs ->
+          expect(-> atom.packages.deactivatePackage("package-that-throws-on-deactivate")).not.toThrow()
+          expect(console.error).toHaveBeenCalled()
+
+      it "removes the package's grammars", ->
+        waitsForPromise ->
+          atom.packages.activatePackage('package-with-grammars')
+
+        runs ->
+          atom.packages.deactivatePackage('package-with-grammars')
+          expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Null Grammar'
+          expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Null Grammar'
+
+      it "removes the package's keymaps", ->
+        waitsForPromise ->
+          atom.packages.activatePackage('package-with-keymaps')
+
+        runs ->
+          atom.packages.deactivatePackage('package-with-keymaps')
+          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 ->
+          atom.packages.activatePackage('package-with-stylesheets')
+
+        runs ->
+          atom.packages.deactivatePackage('package-with-stylesheets')
+          one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css")
+          two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less")
+          three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css")
+          expect(atom.themes.stylesheetElementForId(one)).not.toExist()
+          expect(atom.themes.stylesheetElementForId(two)).not.toExist()
+          expect(atom.themes.stylesheetElementForId(three)).not.toExist()
+
+      it "removes the package's scoped-properties", ->
+        waitsForPromise ->
+          atom.packages.activatePackage("package-with-scoped-properties")
+
+        runs ->
+          expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
+          atom.packages.deactivatePackage("package-with-scoped-properties")
+          expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBeUndefined()
+
+    describe "textmate packages", ->
+      it "removes the package's grammars", ->
+        expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+
+        waitsForPromise ->
+          atom.packages.activatePackage('language-ruby')
+
+        runs ->
+          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
+          atom.packages.deactivatePackage('language-ruby')
+          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+
+      it "removes the package's scoped properties", ->
+        waitsForPromise ->
+          atom.packages.activatePackage('language-ruby')
+
+        runs ->
+          atom.packages.deactivatePackage('language-ruby')
+          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
+
+  describe "::activate()", ->
+    packageActivator = null
+    themeActivator = null
+
+    beforeEach ->
+      spyOn(console, 'warn')
+      atom.packages.loadPackages()
+
+      loadedPackages = atom.packages.getLoadedPackages()
+      expect(loadedPackages.length).toBeGreaterThan 0
+
+      packageActivator = spyOn(atom.packages, 'activatePackages')
+      themeActivator = spyOn(atom.themes, 'activatePackages')
+
+    afterEach ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
+      Syntax = require '../src/syntax'
+      atom.syntax = window.syntax = new Syntax()
+
+    it "activates all the packages, and none of the themes", ->
+      atom.packages.activate()
+
+      expect(packageActivator).toHaveBeenCalled()
+      expect(themeActivator).toHaveBeenCalled()
+
+      packages = packageActivator.mostRecentCall.args[0]
+      expect(['atom', 'textmate']).toContain(pack.getType()) for pack in packages
+
+      themes = themeActivator.mostRecentCall.args[0]
+      expect(['theme']).toContain(theme.getType()) for theme in themes
+
+  describe "::enablePackage() and ::disablePackage()", ->
+    describe "with packages", ->
+      it ".enablePackage() enables a disabled package", ->
+        packageName = 'package-with-main'
+        atom.config.pushAtKeyPath('core.disabledPackages', packageName)
+        atom.packages.observeDisabledPackages()
+        expect(atom.config.get('core.disabledPackages')).toContain packageName
+
+        pack = atom.packages.enablePackage(packageName)
+        loadedPackages = atom.packages.getLoadedPackages()
+        activatedPackages = null
+        waitsFor ->
+          activatedPackages = atom.packages.getActivePackages()
+          activatedPackages.length > 0
+
+        runs ->
+          expect(loadedPackages).toContain(pack)
+          expect(activatedPackages).toContain(pack)
+          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
+
+      it ".disablePackage() disables an enabled package", ->
+        packageName = 'package-with-main'
+        waitsForPromise ->
+          atom.packages.activatePackage(packageName)
+
+        runs ->
+          atom.packages.observeDisabledPackages()
+          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
+
+          pack = atom.packages.disablePackage(packageName)
+
+          activatedPackages = atom.packages.getActivePackages()
+          expect(activatedPackages).not.toContain(pack)
+          expect(atom.config.get('core.disabledPackages')).toContain packageName
+
+    describe "with themes", ->
+      reloadedHandler = null
+
+      beforeEach ->
+        waitsForPromise ->
+          atom.themes.activateThemes()
+
+      afterEach ->
+        atom.themes.deactivateThemes()
+
+      it ".enablePackage() and .disablePackage() enables and disables a theme", ->
+        packageName = 'theme-with-package-file'
+
+        expect(atom.config.get('core.themes')).not.toContain packageName
+        expect(atom.config.get('core.disabledPackages')).not.toContain packageName
+
+        # enabling of theme
+        pack = atom.packages.enablePackage(packageName)
+
+        waitsFor ->
+          pack in atom.packages.getActivePackages()
+
+        runs ->
+          expect(atom.config.get('core.themes')).toContain packageName
+          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
+
+          reloadedHandler = jasmine.createSpy('reloadedHandler')
+          reloadedHandler.reset()
+          atom.themes.onDidReloadAll reloadedHandler
+
+          pack = atom.packages.disablePackage(packageName)
+
+        waitsFor ->
+          reloadedHandler.callCount is 1
+
+        runs ->
+          expect(atom.packages.getActivePackages()).not.toContain pack
+          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/package-spec.coffee

@@ -102,6 +102,6 @@ describe "Package", ->
         theme.activate()
 
       it "deactivated event fires on .deactivate()", ->
-        theme.on 'deactivated', spy = jasmine.createSpy()
+        theme.onDidDeactivate spy = jasmine.createSpy()
         theme.deactivate()
         expect(spy).toHaveBeenCalled()

spec/pane-container-view-spec.coffee

@@ -5,11 +5,11 @@ PaneView = require '../src/pane-view'
 {$, View, $$} = require 'atom'
 
 describe "PaneContainerView", ->
-  [TestView, container, pane1, pane2, pane3] = []
+  [TestView, container, pane1, pane2, pane3, deserializerDisposable] = []
 
   beforeEach ->
     class TestView extends View
-      atom.deserializers.add(this)
+      deserializerDisposable = atom.deserializers.add(this)
       @deserialize: ({name}) -> new TestView(name)
       @content: -> @div tabindex: -1
       initialize: (@name) -> @text(@name)
@@ -25,7 +25,7 @@ describe "PaneContainerView", ->
     pane3 = pane2.splitDown(new TestView('3'))
 
   afterEach ->
-    atom.deserializers.remove(TestView)
+    deserializerDisposable.dispose()
 
   describe ".getActivePaneView()", ->
     it "returns the most-recently focused pane", ->

spec/pane-spec.coffee

@@ -4,6 +4,8 @@ PaneAxis = require '../src/pane-axis'
 PaneContainer = require '../src/pane-container'
 
 describe "Pane", ->
+  deserializerDisposable = null
+
   class Item extends Model
     @deserialize: ({name, uri}) -> new this(name, uri)
     constructor: (@name, @uri) ->
@@ -13,10 +15,10 @@ describe "Pane", ->
     isEqual: (other) -> @name is other?.name
 
   beforeEach ->
-    atom.deserializers.add(Item)
+    deserializerDisposable = atom.deserializers.add(Item)
 
   afterEach ->
-    atom.deserializers.remove(Item)
+    deserializerDisposable.dispose()
 
   describe "construction", ->
     it "sets the active item to the first item", ->
@@ -99,6 +101,13 @@ describe "Pane", ->
       pane.addItem(item, 1)
       expect(events).toEqual [{item, index: 1}]
 
+    it "throws an exception if the item is already present on a pane", ->
+      item = new Item("A")
+      pane1 = new Pane(items: [item])
+      container = new PaneContainer(root: pane1)
+      pane2 = pane1.splitRight()
+      expect(-> pane2.addItem(item)).toThrow()
+
   describe "::activateItem(item)", ->
     pane = null
 

spec/pane-view-spec.coffee

@@ -1,24 +1,31 @@
 PaneContainerView = require '../src/pane-container-view'
 PaneView = require '../src/pane-view'
 fs = require 'fs-plus'
+{Emitter} = require 'event-kit'
 {$, View} = require 'atom'
 path = require 'path'
 temp = require 'temp'
 
 describe "PaneView", ->
-  [container, view1, view2, editor1, editor2, pane, paneModel] = []
+  [container, containerModel, view1, view2, editor1, editor2, pane, paneModel, deserializerDisposable] = []
 
   class TestView extends View
     @deserialize: ({id, text}) -> new TestView({id, text})
     @content: ({id, text}) -> @div class: 'test-view', id: id, tabindex: -1, text
     initialize: ({@id, @text}) ->
+      @emitter = new Emitter
     serialize: -> { deserializer: 'TestView', @id, @text }
     getUri: -> @id
     isEqual: (other) -> other? and @id == other.id and @text == other.text
+    changeTitle: ->
+      @emitter.emit 'did-change-title', 'title'
+    onDidChangeTitle: (callback) ->
+      @emitter.on 'did-change-title', callback
 
   beforeEach ->
-    atom.deserializers.add(TestView)
+    deserializerDisposable = atom.deserializers.add(TestView)
     container = new PaneContainerView
+    containerModel = container.model
     view1 = new TestView(id: 'view-1', text: 'View 1')
     view2 = new TestView(id: 'view-2', text: 'View 2')
     waitsForPromise ->
@@ -33,7 +40,7 @@ describe "PaneView", ->
       paneModel.addItems([view1, editor1, view2, editor2])
 
   afterEach ->
-    atom.deserializers.remove(TestView)
+    deserializerDisposable.dispose()
 
   describe "when the active pane item changes", ->
     it "hides all item views except the active one", ->
@@ -145,22 +152,47 @@ describe "PaneView", ->
       expect(view1.data('preservative')).toBe 1234
 
   describe "when the title of the active item changes", ->
-    it "emits pane:active-item-title-changed", ->
-      activeItemTitleChangedHandler = jasmine.createSpy("activeItemTitleChangedHandler")
-      pane.on 'pane:active-item-title-changed', activeItemTitleChangedHandler
+    describe 'when there is no onDidChangeTitle method', ->
+      beforeEach ->
+        view1.onDidChangeTitle = null
+        view2.onDidChangeTitle = null
 
-      expect(pane.getActiveItem()).toBe view1
+        pane.activateItem(view2)
+        pane.activateItem(view1)
 
-      view2.trigger 'title-changed'
-      expect(activeItemTitleChangedHandler).not.toHaveBeenCalled()
+      it "emits pane:active-item-title-changed", ->
+        activeItemTitleChangedHandler = jasmine.createSpy("activeItemTitleChangedHandler")
+        pane.on 'pane:active-item-title-changed', activeItemTitleChangedHandler
 
-      view1.trigger 'title-changed'
-      expect(activeItemTitleChangedHandler).toHaveBeenCalled()
-      activeItemTitleChangedHandler.reset()
+        expect(pane.getActiveItem()).toBe view1
 
-      pane.activateItem(view2)
-      view2.trigger 'title-changed'
-      expect(activeItemTitleChangedHandler).toHaveBeenCalled()
+        view2.trigger 'title-changed'
+        expect(activeItemTitleChangedHandler).not.toHaveBeenCalled()
+
+        view1.trigger 'title-changed'
+        expect(activeItemTitleChangedHandler).toHaveBeenCalled()
+        activeItemTitleChangedHandler.reset()
+
+        pane.activateItem(view2)
+        view2.trigger 'title-changed'
+        expect(activeItemTitleChangedHandler).toHaveBeenCalled()
+
+    describe 'when there is a onDidChangeTitle method', ->
+      it "emits pane:active-item-title-changed", ->
+        activeItemTitleChangedHandler = jasmine.createSpy("activeItemTitleChangedHandler")
+        pane.on 'pane:active-item-title-changed', activeItemTitleChangedHandler
+
+        expect(pane.getActiveItem()).toBe view1
+        view2.changeTitle()
+        expect(activeItemTitleChangedHandler).not.toHaveBeenCalled()
+
+        view1.changeTitle()
+        expect(activeItemTitleChangedHandler).toHaveBeenCalled()
+        activeItemTitleChangedHandler.reset()
+
+        pane.activateItem(view2)
+        view2.changeTitle()
+        expect(activeItemTitleChangedHandler).toHaveBeenCalled()
 
   describe "when an unmodifed buffer's path is deleted", ->
     it "removes the pane item", ->
@@ -185,7 +217,7 @@ describe "PaneView", ->
 
     beforeEach ->
       pane2Model = paneModel.splitRight() # Can't destroy the last pane, so we add another
-      pane2 = pane2Model._view
+      pane2 = containerModel.getView(pane2Model).__spacePenView
 
     it "triggers a 'pane:removed' event with the pane", ->
       removedHandler = jasmine.createSpy("removedHandler")
@@ -218,7 +250,7 @@ describe "PaneView", ->
 
     beforeEach ->
       pane2Model = paneModel.splitRight(items: [pane.copyActiveItem()])
-      pane2 = pane2Model._view
+      pane2 = containerModel.getView(pane2Model).__spacePenView
       expect(pane2Model.isActive()).toBe true
 
     it "adds or removes the .active class as appropriate", ->
@@ -265,7 +297,8 @@ describe "PaneView", ->
       pane2Model = pane1Model.splitRight(items: [pane1Model.copyActiveItem()])
       pane3Model = pane2Model.splitDown(items: [pane2Model.copyActiveItem()])
       pane2 = pane2Model._view
-      pane3 = pane3Model._view
+      pane2 = containerModel.getView(pane2Model).__spacePenView
+      pane3 = containerModel.getView(pane3Model).__spacePenView
 
       expect(container.find('> .pane-row > .pane').toArray()).toEqual [pane1[0]]
       expect(container.find('> .pane-row > .pane-column > .pane').toArray()).toEqual [pane2[0], pane3[0]]

spec/random-editor-spec.coffee

@@ -1,9 +1,9 @@
 {times, random} = require 'underscore-plus'
 randomWords = require 'random-words'
 TextBuffer = require 'text-buffer'
-Editor = require '../src/editor'
+TextEditor = require '../src/text-editor'
 
-describe "Editor", ->
+describe "TextEditor", ->
   [editor, tokenizedBuffer, buffer, steps, previousSteps] = []
 
   softWrapColumn = 80
@@ -17,7 +17,7 @@ describe "Editor", ->
 
     times 10, (i) ->
       buffer = new TextBuffer
-      editor = new Editor({buffer})
+      editor = new TextEditor({buffer})
       editor.setEditorWidthInChars(80)
       tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
       steps = []
@@ -50,9 +50,9 @@ describe "Editor", ->
 
   randomlyMutateEditor = ->
     if Math.random() < .2
-      softWrap = not editor.getSoftWrap()
-      steps.push(['setSoftWrap', softWrap])
-      editor.setSoftWrap(softWrap)
+      softWrapped = not editor.isSoftWrapped()
+      steps.push(['setSoftWrapped', softWrapped])
+      editor.setSoftWrapped(softWrapped)
     else
       range = getRandomRange()
       text = getRandomText()
@@ -79,7 +79,7 @@ describe "Editor", ->
     text
 
   getReferenceScreenLines = ->
-    if editor.getSoftWrap()
+    if editor.isSoftWrapped()
       screenLines = []
       bufferRows = []
       for bufferRow in [0..tokenizedBuffer.getLastRow()]

spec/selection-spec.coffee

@@ -1,11 +1,11 @@
-Editor = require '../src/editor'
+TextEditor = require '../src/text-editor'
 
 describe "Selection", ->
   [buffer, editor, selection] = []
 
   beforeEach ->
     buffer = atom.project.bufferForPathSync('sample.js')
-    editor = new Editor(buffer: buffer, tabLength: 2)
+    editor = new TextEditor(buffer: buffer, tabLength: 2)
     selection = editor.getLastSelection()
 
   afterEach ->
@@ -57,10 +57,10 @@ describe "Selection", ->
       expect(selection.isReversed()).toBeFalsy()
 
   describe "when only the selection's tail is moved (regression)", ->
-    it "emits the 'screen-range-changed' event", ->
+    it "notifies ::onDidChangeRange observers", ->
       selection.setBufferRange([[2, 0], [2, 10]], reversed: true)
       changeScreenRangeHandler = jasmine.createSpy('changeScreenRangeHandler')
-      selection.on 'screen-range-changed', changeScreenRangeHandler
+      selection.onDidChangeRange changeScreenRangeHandler
 
       buffer.insert([2, 5], 'abc')
       expect(changeScreenRangeHandler).toHaveBeenCalled()

spec/spec-helper.coffee

@@ -12,20 +12,22 @@ KeymapManager = require '../src/keymap-extensions'
 Config = require '../src/config'
 {Point} = require 'text-buffer'
 Project = require '../src/project'
-Editor = require '../src/editor'
-EditorView = require '../src/editor-view'
+TextEditor = require '../src/text-editor'
+TextEditorView = require '../src/text-editor-view'
 TokenizedBuffer = require '../src/tokenized-buffer'
-EditorComponent = require '../src/editor-component'
+TextEditorComponent = require '../src/text-editor-component'
 pathwatcher = require 'pathwatcher'
 clipboard = require 'clipboard'
 
 atom.themes.loadBaseStylesheets()
 atom.themes.requireStylesheet '../static/jasmine'
+atom.themes.initialLoadComplete = true
 
 fixturePackagesPath = path.resolve(__dirname, './fixtures/packages')
 atom.packages.packageDirPaths.unshift(fixturePackagesPath)
 atom.keymaps.loadBundledKeymaps()
 keyBindingsToRestore = atom.keymaps.getKeyBindings()
+commandsToRestore = atom.commands.getSnapshot()
 
 $(window).on 'core:close', -> window.close()
 $(window).on 'beforeunload', ->
@@ -63,6 +65,8 @@ beforeEach ->
   atom.project = new Project(path: projectPath)
   atom.workspace = new Workspace()
   atom.keymaps.keyBindings = _.clone(keyBindingsToRestore)
+  atom.commands.setRootNode(document.body)
+  atom.commands.restoreSnapshot(commandsToRestore)
 
   window.resetTimeouts()
   atom.packages.packageStates = {}
@@ -87,26 +91,26 @@ beforeEach ->
   config = new Config({resourcePath, configDirPath: atom.getConfigDirPath()})
   spyOn(config, 'load')
   spyOn(config, 'save')
-  config.setDefaults('core', WorkspaceView.configDefaults)
-  config.setDefaults('editor', EditorView.configDefaults)
+  atom.config = config
+  atom.loadConfig()
   config.set "core.destroyEmptyPanes", false
   config.set "editor.fontFamily", "Courier"
   config.set "editor.fontSize", 16
   config.set "editor.autoIndent", false
   config.set "core.disabledPackages", ["package-that-throws-an-exception",
     "package-with-broken-package-json", "package-with-broken-keymap"]
+  config.load.reset()
   config.save.reset()
-  atom.config = config
 
   # make editor display updates synchronous
-  spyOn(EditorView.prototype, 'requestDisplayUpdate').andCallFake -> @updateDisplay()
-  EditorComponent.performSyncUpdates = true
+  spyOn(TextEditorView.prototype, 'requestDisplayUpdate').andCallFake -> @updateDisplay()
+  TextEditorComponent.performSyncUpdates = true
 
   spyOn(WorkspaceView.prototype, 'setTitle').andCallFake (@title) ->
   spyOn(window, "setTimeout").andCallFake window.fakeSetTimeout
   spyOn(window, "clearTimeout").andCallFake window.fakeClearTimeout
   spyOn(pathwatcher.File.prototype, "detectResurrectionAfterDelay").andCallFake -> @detectResurrection()
-  spyOn(Editor.prototype, "shouldPromptToSave").andReturn false
+  spyOn(TextEditor.prototype, "shouldPromptToSave").andReturn false
 
   # make tokenization synchronous
   TokenizedBuffer.prototype.chunkSize = Infinity
@@ -121,6 +125,7 @@ beforeEach ->
 afterEach ->
   atom.packages.deactivatePackages()
   atom.menu.template = []
+  atom.contextMenu.clear()
 
   atom.workspaceView?.remove?()
   atom.workspaceView = null
@@ -137,7 +142,7 @@ afterEach ->
 
   jasmine.unspy(atom, 'saveSync')
   ensureNoPathSubscriptions()
-  atom.syntax.off()
+  atom.syntax.clearObservers()
   waits(0) # yield to ui thread to make screen update more frequently
 
 ensureNoPathSubscriptions = ->

spec/syntax-spec.coffee

@@ -4,7 +4,6 @@ temp = require 'temp'
 
 describe "the `syntax` global", ->
   beforeEach ->
-
     waitsForPromise ->
       atom.packages.activatePackage('language-text')
 
@@ -17,6 +16,10 @@ describe "the `syntax` global", ->
     waitsForPromise ->
       atom.packages.activatePackage('language-ruby')
 
+  afterEach ->
+    atom.packages.deactivatePackages()
+    atom.packages.unloadPackages()
+
   describe "serialization", ->
     it "remembers grammar overrides by path", ->
       filePath = '/foo/bar/file.js'

spec/text-editor-component-spec.coffee

@@ -1,11 +1,11 @@
 _ = require 'underscore-plus'
 {extend, flatten, toArray, last} = _
 
-EditorView = require '../src/editor-view'
-EditorComponent = require '../src/editor-component'
+TextEditorView = require '../src/text-editor-view'
+TextEditorComponent = require '../src/text-editor-component'
 nbsp = String.fromCharCode(160)
 
-describe "EditorComponent", ->
+describe "TextEditorComponent", ->
   [contentNode, editor, wrapperView, wrapperNode, component, componentNode, verticalScrollbarNode, horizontalScrollbarNode] = []
   [lineHeightInPixels, charWidth, nextAnimationFrame, noAnimationFrame, lineOverdrawMargin] = []
 
@@ -34,7 +34,7 @@ describe "EditorComponent", ->
       contentNode = document.querySelector('#jasmine-content')
       contentNode.style.width = '1000px'
 
-      wrapperView = new EditorView(editor, {lineOverdrawMargin})
+      wrapperView = new TextEditorView(editor, {lineOverdrawMargin})
       wrapperView.attachToDom()
       wrapperNode = wrapperView.element
 
@@ -197,6 +197,50 @@ describe "EditorComponent", ->
       nextAnimationFrame()
       expect(linesNode.style.backgroundColor).toBe 'rgb(255, 0, 0)'
 
+    it "applies .leading-whitespace for lines with leading spaces and/or tabs", ->
+      editor.setText(' a')
+      nextAnimationFrame()
+
+      leafNodes = getLeafNodes(component.lineNodeForScreenRow(0))
+      expect(leafNodes[0].classList.contains('leading-whitespace')).toBe true
+      expect(leafNodes[0].classList.contains('trailing-whitespace')).toBe false
+
+      editor.setText('\ta')
+      nextAnimationFrame()
+
+      leafNodes = getLeafNodes(component.lineNodeForScreenRow(0))
+      expect(leafNodes[0].classList.contains('leading-whitespace')).toBe true
+      expect(leafNodes[0].classList.contains('trailing-whitespace')).toBe false
+
+    it "applies .trailing-whitespace for lines with trailing spaces and/or tabs", ->
+      editor.setText(' ')
+      nextAnimationFrame()
+
+      leafNodes = getLeafNodes(component.lineNodeForScreenRow(0))
+      expect(leafNodes[0].classList.contains('trailing-whitespace')).toBe true
+      expect(leafNodes[0].classList.contains('leading-whitespace')).toBe false
+
+      editor.setText('\t')
+      nextAnimationFrame()
+
+      leafNodes = getLeafNodes(component.lineNodeForScreenRow(0))
+      expect(leafNodes[0].classList.contains('trailing-whitespace')).toBe true
+      expect(leafNodes[0].classList.contains('leading-whitespace')).toBe false
+
+      editor.setText('a ')
+      nextAnimationFrame()
+
+      leafNodes = getLeafNodes(component.lineNodeForScreenRow(0))
+      expect(leafNodes[0].classList.contains('trailing-whitespace')).toBe true
+      expect(leafNodes[0].classList.contains('leading-whitespace')).toBe false
+
+      editor.setText('a\t')
+      nextAnimationFrame()
+
+      leafNodes = getLeafNodes(component.lineNodeForScreenRow(0))
+      expect(leafNodes[0].classList.contains('trailing-whitespace')).toBe true
+      expect(leafNodes[0].classList.contains('leading-whitespace')).toBe false
+
     describe "when showInvisibles is enabled", ->
       invisibles = null
 
@@ -278,7 +322,7 @@ describe "EditorComponent", ->
       describe "when soft wrapping is enabled", ->
         beforeEach ->
           editor.setText "a line that wraps \n"
-          editor.setSoftWrap(true)
+          editor.setSoftWrapped(true)
           nextAnimationFrame()
           componentNode.style.width = 16 * charWidth + editor.getVerticalScrollbarWidth() + 'px'
           component.measureHeightAndWidth()
@@ -457,7 +501,7 @@ describe "EditorComponent", ->
       expect(component.lineNumberNodeForScreenRow(6).offsetTop).toBe 6 * lineHeightInPixels
 
     it "renders • characters for soft-wrapped lines", ->
-      editor.setSoftWrap(true)
+      editor.setSoftWrapped(true)
       wrapperNode.style.height = 4.5 * lineHeightInPixels + 'px'
       wrapperNode.style.width = 30 * charWidth + 'px'
       component.measureHeightAndWidth()
@@ -893,7 +937,7 @@ describe "EditorComponent", ->
 
     it "only applies decorations to screen rows that are spanned by their marker when lines are soft-wrapped", ->
       editor.setText("a line that wraps, ok")
-      editor.setSoftWrap(true)
+      editor.setSoftWrapped(true)
       componentNode.style.width = 16 * charWidth + 'px'
       component.measureHeightAndWidth()
       nextAnimationFrame()
@@ -1134,7 +1178,7 @@ describe "EditorComponent", ->
       it "renders the decoration's new params", ->
         expect(componentNode.querySelector('.test-highlight')).toBeTruthy()
 
-        decoration.update(type: 'highlight', class: 'new-test-highlight')
+        decoration.setProperties(type: 'highlight', class: 'new-test-highlight')
         nextAnimationFrame()
 
         expect(componentNode.querySelector('.test-highlight')).toBeFalsy()
@@ -1690,11 +1734,11 @@ describe "EditorComponent", ->
         nextAnimationFrame()
         expect(verticalScrollbarNode.scrollTop).toBe 10
 
-      it "parses negative scrollSensitivity values as positive", ->
+      it "parses negative scrollSensitivity values at the minimum", ->
         atom.config.set('editor.scrollSensitivity', -50)
         componentNode.dispatchEvent(new WheelEvent('mousewheel', wheelDeltaX: 0, wheelDeltaY: -10))
         nextAnimationFrame()
-        expect(verticalScrollbarNode.scrollTop).toBe 5
+        expect(verticalScrollbarNode.scrollTop).toBe 1
 
     describe "when the mousewheel event's target is a line", ->
       it "keeps the line on the DOM if it is scrolled off-screen", ->
@@ -1955,7 +1999,7 @@ describe "EditorComponent", ->
         hiddenParent.style.display = 'none'
         contentNode.appendChild(hiddenParent)
 
-        wrapperView = new EditorView(editor, {lineOverdrawMargin})
+        wrapperView = new TextEditorView(editor, {lineOverdrawMargin})
         wrapperNode = wrapperView.element
         wrapperView.appendTo(hiddenParent)
 
@@ -2066,7 +2110,7 @@ describe "EditorComponent", ->
 
   describe "soft wrapping", ->
     beforeEach ->
-      editor.setSoftWrap(true)
+      editor.setSoftWrapped(true)
       nextAnimationFrame()
 
     it "updates the wrap location when the editor is resized", ->
@@ -2181,7 +2225,7 @@ describe "EditorComponent", ->
 
   describe "when placholderText is specified", ->
     it "renders the placeholder text when the buffer is empty", ->
-      component.setProps(placeholderText: 'Hello World')
+      editor.setPlaceholderText('Hello World')
       expect(componentNode.querySelector('.placeholder-text')).toBeNull()
       editor.setText('')
       nextAnimationFrame()
@@ -2192,10 +2236,10 @@ describe "EditorComponent", ->
 
   describe "legacy editor compatibility", ->
     it "triggers the screen-lines-changed event before the editor:display-update event", ->
-      editor.setSoftWrap(true)
+      editor.setSoftWrapped(true)
 
       callingOrder = []
-      editor.on 'screen-lines-changed', -> callingOrder.push 'screen-lines-changed'
+      editor.onDidChange -> callingOrder.push 'screen-lines-changed'
       wrapperView.on 'editor:display-updated', -> callingOrder.push 'editor:display-updated'
       editor.insertText("HELLO! HELLO!\n HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! HELLO! ")
       nextAnimationFrame()
@@ -2215,6 +2259,15 @@ describe "EditorComponent", ->
       editor.setGrammar(atom.syntax.nullGrammar)
       expect(wrapperNode.dataset.grammar).toBe 'text plain null-grammar'
 
+  describe "detaching and reattaching the editor (regression)", ->
+    it "does not throw an exception", ->
+      wrapperView.detach()
+      wrapperView.attachToDom()
+
+      wrapperView.trigger('core:move-right')
+
+      expect(editor.getCursorBufferPosition()).toEqual [0, 1]
+
   buildMouseEvent = (type, properties...) ->
     properties = extend({bubbles: true, cancelable: true}, properties...)
     properties.detail ?= 1

spec/text-editor-spec.coffee

@@ -1,7 +1,7 @@
 clipboard = require 'clipboard'
-Editor = require '../src/editor'
+TextEditor = require '../src/text-editor'
 
-describe "Editor", ->
+describe "TextEditor", ->
   [buffer, editor, lineLengths] = []
 
   convertToHardTabs = (buffer) ->
@@ -49,7 +49,7 @@ describe "Editor", ->
 
       state = editor.serialize()
       atom.config.set('editor.invisibles', eol: '?')
-      editor2 = Editor.deserialize(state)
+      editor2 = TextEditor.deserialize(state)
 
       expect(editor2.displayBuffer.invisibles.eol).toBe '?'
       expect(editor2.displayBuffer.tokenizedBuffer.invisibles.eol).toBe '?'
@@ -110,7 +110,7 @@ describe "Editor", ->
 
       runs ->
         expect(editor1.getTabLength()).toBe 4
-        expect(editor1.getSoftWrap()).toBe true
+        expect(editor1.isSoftWrapped()).toBe true
         expect(editor1.getSoftTabs()).toBe false
 
         atom.config.set('editor.tabLength', 100)
@@ -122,7 +122,7 @@ describe "Editor", ->
 
       runs ->
         expect(editor2.getTabLength()).toBe 100
-        expect(editor2.getSoftWrap()).toBe false
+        expect(editor2.isSoftWrapped()).toBe false
         expect(editor2.getSoftTabs()).toBe true
 
   describe "title", ->
@@ -138,13 +138,24 @@ describe "Editor", ->
         buffer.setPath(undefined)
         expect(editor.getLongTitle()).toBe 'untitled'
 
-    it "emits 'title-changed' events when the underlying buffer path", ->
-      titleChangedHandler = jasmine.createSpy("titleChangedHandler")
-      editor.on 'title-changed', titleChangedHandler
+    it "notifies ::onDidChangeTitle observers when the underlying buffer path changes", ->
+      observed = []
+      editor.onDidChangeTitle (title) -> observed.push(title)
 
       buffer.setPath('/foo/bar/baz.txt')
       buffer.setPath(undefined)
-      expect(titleChangedHandler.callCount).toBe 2
+
+      expect(observed).toEqual ['baz.txt', 'untitled']
+
+  describe "path", ->
+    it "notifies ::onDidChangePath observers when the underlying buffer path changes", ->
+      observed = []
+      editor.onDidChangePath (filePath) -> observed.push(filePath)
+
+      buffer.setPath(__filename)
+      buffer.setPath(undefined)
+
+      expect(observed).toEqual [__filename, undefined]
 
   describe "cursor", ->
     describe ".getLastCursor()", ->
@@ -163,20 +174,19 @@ describe "Editor", ->
         editor.moveDown()
         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")
+      it "emits an event with the old position, new position, and the cursor that moved", ->
+        editor.onDidChangeCursorPosition positionChangedHandler = jasmine.createSpy()
 
-        editor.moveDown()
-        expect(cursorsMovedHandler.callCount).toBe 1
+        editor.setCursorBufferPosition([2, 4])
 
-        cursorsMovedHandler.reset()
-        editor.addCursorAtScreenPosition([3, 0])
-        editor.moveDown()
-        expect(cursorsMovedHandler.callCount).toBe 1
+        expect(positionChangedHandler).toHaveBeenCalled()
+        eventObject = positionChangedHandler.mostRecentCall.args[0]
 
-        cursorsMovedHandler.reset()
-        editor.getLastCursor().moveDown()
-        expect(cursorsMovedHandler.callCount).toBe 1
+        expect(eventObject.oldBufferPosition).toEqual [0, 0]
+        expect(eventObject.oldScreenPosition).toEqual [0, 0]
+        expect(eventObject.newBufferPosition).toEqual [2, 4]
+        expect(eventObject.newScreenPosition).toEqual [2, 4]
+        expect(eventObject.cursor).toBe editor.getLastCursor()
 
     describe ".setCursorScreenPosition(screenPosition)", ->
       it "clears a goal column established by vertical movement", ->
@@ -203,7 +213,7 @@ describe "Editor", ->
 
       describe "when soft-wrap is enabled and code is folded", ->
         beforeEach ->
-          editor.setSoftWrap(true)
+          editor.setSoftWrapped(true)
           editor.setEditorWidthInChars(50)
           editor.createFold(2, 3)
 
@@ -484,7 +494,7 @@ describe "Editor", ->
     describe ".moveToBeginningOfScreenLine()", ->
       describe "when soft wrap is on", ->
         it "moves cursor to the beginning of the screen line", ->
-          editor.setSoftWrap(true)
+          editor.setSoftWrapped(true)
           editor.setEditorWidthInChars(10)
           editor.setCursorScreenPosition([1, 2])
           editor.moveToBeginningOfScreenLine()
@@ -504,7 +514,7 @@ describe "Editor", ->
     describe ".moveToEndOfScreenLine()", ->
       describe "when soft wrap is on", ->
         it "moves cursor to the beginning of the screen line", ->
-          editor.setSoftWrap(true)
+          editor.setSoftWrapped(true)
           editor.setEditorWidthInChars(10)
           editor.setCursorScreenPosition([1, 2])
           editor.moveToEndOfScreenLine()
@@ -523,7 +533,7 @@ describe "Editor", ->
 
     describe ".moveToBeginningOfLine()", ->
       it "moves cursor to the beginning of the buffer line", ->
-        editor.setSoftWrap(true)
+        editor.setSoftWrapped(true)
         editor.setEditorWidthInChars(10)
         editor.setCursorScreenPosition([1, 2])
         editor.moveToBeginningOfLine()
@@ -532,7 +542,7 @@ describe "Editor", ->
 
     describe ".moveToEndOfLine()", ->
       it "moves cursor to the end of the buffer line", ->
-        editor.setSoftWrap(true)
+        editor.setSoftWrapped(true)
         editor.setEditorWidthInChars(10)
         editor.setCursorScreenPosition([0, 2])
         editor.moveToEndOfLine()
@@ -542,7 +552,7 @@ describe "Editor", ->
     describe ".moveToFirstCharacterOfLine()", ->
       describe "when soft wrap is on", ->
         it "moves to the first character of the current screen line or the beginning of the screen line if it's already on the first character", ->
-          editor.setSoftWrap(true)
+          editor.setSoftWrapped(true)
           editor.setEditorWidthInChars(10)
           editor.setCursorScreenPosition [2,5]
           editor.addCursorAtScreenPosition [8,7]
@@ -782,37 +792,6 @@ describe "Editor", ->
         editor.setCursorBufferPosition([3, 1])
         expect(editor.getCurrentParagraphBufferRange()).toBeUndefined()
 
-    describe "cursor-moved events", ->
-      cursorMovedHandler = null
-
-      beforeEach ->
-        editor.foldBufferRow(4)
-        editor.setSelectedBufferRange([[8, 1], [9, 0]])
-        cursorMovedHandler = jasmine.createSpy("cursorMovedHandler")
-        editor.on 'cursor-moved', cursorMovedHandler
-
-      describe "when the position of the cursor changes", ->
-        it "emits a cursor-moved event", ->
-          buffer.insert([9, 0], '...')
-          expect(cursorMovedHandler).toHaveBeenCalledWith(
-            oldBufferPosition: [9, 0]
-            oldScreenPosition: [6, 0]
-            newBufferPosition: [9, 3]
-            newScreenPosition: [6, 3]
-            textChanged: true
-          )
-
-      describe "when the position of the associated selection's tail changes, but not the cursor's position", ->
-        it "does not emit a cursor-moved event", ->
-          buffer.insert([8, 0], '...')
-          expect(cursorMovedHandler).not.toHaveBeenCalled()
-
-    describe "::getCursorBufferPositions()", ->
-      it "returns the cursor positions in the order they were added", ->
-        cursor1 = editor.addCursorAtBufferPosition([8, 5])
-        cursor2 = editor.addCursorAtBufferPosition([4, 5])
-        expect(editor.getCursorBufferPositions()).toEqual [[0, 0], [8, 5], [4, 5]]
-
     describe "::getCursorScreenPositions()", ->
       it "returns the cursor positions in the order they were added", ->
         editor.foldBufferRow(4)
@@ -922,6 +901,22 @@ describe "Editor", ->
     beforeEach ->
       selection = editor.getLastSelection()
 
+    describe "when the selection range changes", ->
+      it "emits an event with the old range, new range, and the selection that moved", ->
+        editor.setSelectedBufferRange([[3, 0], [4, 5]])
+
+        editor.onDidChangeSelectionRange rangeChangedHandler = jasmine.createSpy()
+        editor.selectToBufferPosition([6, 2])
+
+        expect(rangeChangedHandler).toHaveBeenCalled()
+        eventObject = rangeChangedHandler.mostRecentCall.args[0]
+
+        expect(eventObject.oldBufferRange).toEqual [[3, 0], [4, 5]]
+        expect(eventObject.oldScreenRange).toEqual [[3, 0], [4, 5]]
+        expect(eventObject.newBufferRange).toEqual [[3, 0], [6, 2]]
+        expect(eventObject.newScreenRange).toEqual [[3, 0], [6, 2]]
+        expect(eventObject.selection).toBe selection
+
     describe ".selectUp/Down/Left/Right()", ->
       it "expands each selection to its cursor's new location", ->
         editor.setSelectedBufferRanges([[[0,9], [0,13]], [[3,16], [3,21]]])
@@ -1651,7 +1646,7 @@ describe "Editor", ->
         beforeEach ->
           editor.setSelectedBufferRange([[1, 0], [1, 2]])
 
-        it "will-insert-text and did-insert-text events are emitted when inserting text", ->
+        it "replaces the selection with the given text", ->
           range = editor.insertText('xxx')
           expect(range).toEqual [ [[1, 0], [1, 3]] ]
           expect(buffer.lineForRow(1)).toBe 'xxxvar sort = function(items) {'
@@ -1733,19 +1728,19 @@ describe "Editor", ->
           editor.insertText('holy cow')
           expect(editor.tokenizedLineForScreenRow(2).fold).toBeUndefined()
 
-      describe "when will-insert-text and did-insert-text events are used", ->
+      describe "when there are ::onWillInsertText and ::onDidInsertText observers", ->
         beforeEach ->
           editor.setSelectedBufferRange([[1, 0], [1, 2]])
 
-        it "will-insert-text and did-insert-text events are emitted when inserting text", ->
+        it "notifies the observers when inserting text", ->
           willInsertSpy = jasmine.createSpy().andCallFake ->
             expect(buffer.lineForRow(1)).toBe '  var sort = function(items) {'
 
           didInsertSpy = jasmine.createSpy().andCallFake ->
             expect(buffer.lineForRow(1)).toBe 'xxxvar sort = function(items) {'
 
-          editor.on('will-insert-text', willInsertSpy)
-          editor.on('did-insert-text', didInsertSpy)
+          editor.onWillInsertText(willInsertSpy)
+          editor.onDidInsertText(didInsertSpy)
 
           expect(editor.insertText('xxx')).toBeTruthy()
           expect(buffer.lineForRow(1)).toBe 'xxxvar sort = function(items) {'
@@ -1760,14 +1755,14 @@ describe "Editor", ->
           options = didInsertSpy.mostRecentCall.args[0]
           expect(options.text).toBe 'xxx'
 
-        it "text insertion is prevented when cancel is called from a will-insert-text handler", ->
+        it "cancels text insertion when an ::onWillInsertText observer calls cancel on an event", ->
           willInsertSpy = jasmine.createSpy().andCallFake ({cancel}) ->
             cancel()
 
           didInsertSpy = jasmine.createSpy()
 
-          editor.on('will-insert-text', willInsertSpy)
-          editor.on('did-insert-text', didInsertSpy)
+          editor.onWillInsertText(willInsertSpy)
+          editor.onDidInsertText(didInsertSpy)
 
           expect(editor.insertText('xxx')).toBe false
           expect(buffer.lineForRow(1)).toBe '  var sort = function(items) {'
@@ -1924,7 +1919,7 @@ describe "Editor", ->
         beforeEach ->
           selection = editor.getLastSelection()
           changeScreenRangeHandler = jasmine.createSpy('changeScreenRangeHandler')
-          selection.on 'screen-range-changed', changeScreenRangeHandler
+          selection.onDidChangeRange changeScreenRangeHandler
 
         describe "when the cursor is on the middle of the line", ->
           it "removes the character before the cursor", ->
@@ -2365,6 +2360,16 @@ describe "Editor", ->
                 expect(buffer.lineForRow(5)).toMatch /^\t\t\t$/
                 expect(editor.getCursorBufferPosition()).toEqual [5, 3]
 
+              describe "when the difference between the suggested level of indentation and the current level of indentation is greater than 0 but less than 1", ->
+                it "inserts one tab", ->
+                  editor.setSoftTabs(false)
+                  buffer.setText(" \ntest")
+                  editor.setCursorBufferPosition [1, 0]
+
+                  editor.indent(autoIndent: true)
+                  expect(buffer.lineForRow(1)).toBe '\ttest'
+                  expect(editor.getCursorBufferPosition()).toEqual [1, 1]
+
           describe "when the line's indent level is greater than the suggested level of indentation", ->
             describe "when 'softTabs' is true (the default)", ->
               it "moves the cursor to the end of the leading whitespace and inserts 'tabLength' spaces into the buffer", ->
@@ -2422,7 +2427,7 @@ describe "Editor", ->
       describe ".cutToEndOfLine()", ->
         describe "when soft wrap is on", ->
           it "cuts up to the end of the line", ->
-            editor.setSoftWrap(true)
+            editor.setSoftWrapped(true)
             editor.setEditorWidthInChars(10)
             editor.setCursorScreenPosition([2, 2])
             editor.cutToEndOfLine()
@@ -2924,7 +2929,7 @@ describe "Editor", ->
 
     describe "when soft wrap is enabled", ->
       it "deletes the entire line that the cursor is on", ->
-        editor.setSoftWrap(true)
+        editor.setSoftWrapped(true)
         editor.setEditorWidthInChars(10)
         editor.setCursorBufferPosition([6])
 
@@ -3258,12 +3263,22 @@ describe "Editor", ->
       runs ->
         expect(editor.softTabs).toBe false
 
+        atom.packages.deactivatePackage('language-coffee-script')
+        atom.packages.unloadPackage('language-coffee-script')
+
   describe ".destroy()", ->
     it "destroys all markers associated with the edit session", ->
       expect(buffer.getMarkerCount()).toBeGreaterThan 0
       editor.destroy()
       expect(buffer.getMarkerCount()).toBe 0
 
+    it "notifies ::onDidDestroy observers when the editor is destroyed", ->
+      destroyObserverCalled = false
+      editor.onDidDestroy -> destroyObserverCalled = true
+
+      editor.destroy()
+      expect(destroyObserverCalled).toBe true
+
   describe ".joinLines()", ->
     describe "when no text is selected", ->
       describe "when the line below isn't empty", ->
@@ -3378,7 +3393,7 @@ describe "Editor", ->
         editor2.destroy()
         expect(editor.shouldPromptToSave()).toBeTruthy()
 
-  describe "when the edit session contains surrogate pair characters", ->
+  describe "when the editor contains surrogate pair characters", ->
     it "correctly backspaces over them", ->
       editor.setText('\uD835\uDF97\uD835\uDF97\uD835\uDF97')
       editor.moveToBottom()
@@ -3419,10 +3434,51 @@ describe "Editor", ->
       editor.moveLeft()
       expect(editor.getCursorBufferPosition()).toEqual [0, 0]
 
+  describe "when the editor contains variation sequence character pairs", ->
+    it "correctly backspaces over them", ->
+      editor.setText('\u2714\uFE0E\u2714\uFE0E\u2714\uFE0E')
+      editor.moveToBottom()
+      editor.backspace()
+      expect(editor.getText()).toBe '\u2714\uFE0E\u2714\uFE0E'
+      editor.backspace()
+      expect(editor.getText()).toBe '\u2714\uFE0E'
+      editor.backspace()
+      expect(editor.getText()).toBe ''
+
+    it "correctly deletes over them", ->
+      editor.setText('\u2714\uFE0E\u2714\uFE0E\u2714\uFE0E')
+      editor.moveToTop()
+      editor.delete()
+      expect(editor.getText()).toBe '\u2714\uFE0E\u2714\uFE0E'
+      editor.delete()
+      expect(editor.getText()).toBe '\u2714\uFE0E'
+      editor.delete()
+      expect(editor.getText()).toBe ''
+
+    it "correctly moves over them", ->
+      editor.setText('\u2714\uFE0E\u2714\uFE0E\u2714\uFE0E\n')
+      editor.moveToTop()
+      editor.moveRight()
+      expect(editor.getCursorBufferPosition()).toEqual [0, 2]
+      editor.moveRight()
+      expect(editor.getCursorBufferPosition()).toEqual [0, 4]
+      editor.moveRight()
+      expect(editor.getCursorBufferPosition()).toEqual [0, 6]
+      editor.moveRight()
+      expect(editor.getCursorBufferPosition()).toEqual [1, 0]
+      editor.moveLeft()
+      expect(editor.getCursorBufferPosition()).toEqual [0, 6]
+      editor.moveLeft()
+      expect(editor.getCursorBufferPosition()).toEqual [0, 4]
+      editor.moveLeft()
+      expect(editor.getCursorBufferPosition()).toEqual [0, 2]
+      editor.moveLeft()
+      expect(editor.getCursorBufferPosition()).toEqual [0, 0]
+
   describe ".setIndentationForBufferRow", ->
     describe "when the editor uses soft tabs but the row has hard tabs", ->
       it "only replaces whitespace characters", ->
-        editor.setSoftWrap(true)
+        editor.setSoftWrapped(true)
         editor.setText("\t1\n\t2")
         editor.setCursorBufferPosition([0, 0])
         editor.setIndentationForBufferRow(0, 2)
@@ -3430,7 +3486,7 @@ describe "Editor", ->
 
     describe "when the indentation level is a non-integer", ->
       it "does not throw an exception", ->
-        editor.setSoftWrap(true)
+        editor.setSoftWrapped(true)
         editor.setText("\t1\n\t2")
         editor.setCursorBufferPosition([0, 0])
         editor.setIndentationForBufferRow(0, 2.1)
@@ -3612,3 +3668,21 @@ describe "Editor", ->
       editor.selectPageUp()
       expect(editor.getScrollTop()).toBe 0
       expect(editor.getSelectedBufferRanges()).toEqual [[[0,0], [12,2]]]
+
+  describe '.get/setPlaceholderText()', ->
+    it 'can be created with placeholderText', ->
+      TextBuffer = require 'text-buffer'
+      newEditor = new TextEditor
+        buffer: new TextBuffer
+        mini: true
+        placeholderText: 'yep'
+      expect(newEditor.getPlaceholderText()).toBe 'yep'
+
+    it 'models placeholderText and emits an event when changed', ->
+      editor.onDidChangePlaceholderText handler = jasmine.createSpy()
+
+      expect(editor.getPlaceholderText()).toBeUndefined()
+
+      editor.setPlaceholderText('OK')
+      expect(handler).toHaveBeenCalledWith 'OK'
+      expect(editor.getPlaceholderText()).toBe 'OK'

spec/text-utils-spec.coffee

@@ -1,30 +1,32 @@
 textUtils = require '../src/text-utils'
 
 describe 'text utilities', ->
-  describe '.getCharacterCount(string)', ->
-    it 'returns the number of full characters in the string', ->
-      expect(textUtils.getCharacterCount('abc')).toBe 3
-      expect(textUtils.getCharacterCount('a\uD835\uDF97b\uD835\uDF97c')).toBe 5
-      expect(textUtils.getCharacterCount('\uD835\uDF97')).toBe 1
-      expect(textUtils.getCharacterCount('\uD835')).toBe 1
-      expect(textUtils.getCharacterCount('\uDF97')).toBe 1
+  describe '.hasPairedCharacter(string)', ->
+    it 'returns true when the string contains a surrogate pair or variation sequence', ->
+      expect(textUtils.hasPairedCharacter('abc')).toBe false
+      expect(textUtils.hasPairedCharacter('a\uD835\uDF97b\uD835\uDF97c')).toBe true
+      expect(textUtils.hasPairedCharacter('\uD835\uDF97')).toBe true
+      expect(textUtils.hasPairedCharacter('\u2714\uFE0E')).toBe true
+      expect(textUtils.hasPairedCharacter('\uD835')).toBe false
+      expect(textUtils.hasPairedCharacter('\uDF97')).toBe false
+      expect(textUtils.hasPairedCharacter('\uFE0E')).toBe false
+      expect(textUtils.hasPairedCharacter('\uFE0E\uFE0E')).toBe false
 
-  describe '.hasSurrogatePair(string)', ->
-    it 'returns true when the string contains a surrogate pair', ->
-      expect(textUtils.hasSurrogatePair('abc')).toBe false
-      expect(textUtils.hasSurrogatePair('a\uD835\uDF97b\uD835\uDF97c')).toBe true
-      expect(textUtils.hasSurrogatePair('\uD835\uDF97')).toBe true
-      expect(textUtils.hasSurrogatePair('\uD835')).toBe false
-      expect(textUtils.hasSurrogatePair('\uDF97')).toBe false
-
-  describe '.isSurrogatePair(string, index)', ->
-    it 'returns true when the index is the start of a high/low surrogate pair', ->
-      expect(textUtils.isSurrogatePair('a\uD835\uDF97b\uD835\uDF97c', 0)).toBe false
-      expect(textUtils.isSurrogatePair('a\uD835\uDF97b\uD835\uDF97c', 1)).toBe true
-      expect(textUtils.isSurrogatePair('a\uD835\uDF97b\uD835\uDF97c', 2)).toBe false
-      expect(textUtils.isSurrogatePair('a\uD835\uDF97b\uD835\uDF97c', 3)).toBe false
-      expect(textUtils.isSurrogatePair('a\uD835\uDF97b\uD835\uDF97c', 4)).toBe true
-      expect(textUtils.isSurrogatePair('a\uD835\uDF97b\uD835\uDF97c', 5)).toBe false
-      expect(textUtils.isSurrogatePair('a\uD835\uDF97b\uD835\uDF97c', 6)).toBe false
-      expect(textUtils.isSurrogatePair('\uD835')).toBe false
-      expect(textUtils.isSurrogatePair('\uDF97')).toBe false
+  describe '.isPairedCharacter(string, index)', ->
+    it 'returns true when the index is the start of a high/low surrogate pair or variation sequence', ->
+      expect(textUtils.isPairedCharacter('a\uD835\uDF97b\uD835\uDF97c', 0)).toBe false
+      expect(textUtils.isPairedCharacter('a\uD835\uDF97b\uD835\uDF97c', 1)).toBe true
+      expect(textUtils.isPairedCharacter('a\uD835\uDF97b\uD835\uDF97c', 2)).toBe false
+      expect(textUtils.isPairedCharacter('a\uD835\uDF97b\uD835\uDF97c', 3)).toBe false
+      expect(textUtils.isPairedCharacter('a\uD835\uDF97b\uD835\uDF97c', 4)).toBe true
+      expect(textUtils.isPairedCharacter('a\uD835\uDF97b\uD835\uDF97c', 5)).toBe false
+      expect(textUtils.isPairedCharacter('a\uD835\uDF97b\uD835\uDF97c', 6)).toBe false
+      expect(textUtils.isPairedCharacter('a\u2714\uFE0E', 0)).toBe false
+      expect(textUtils.isPairedCharacter('a\u2714\uFE0E', 1)).toBe true
+      expect(textUtils.isPairedCharacter('a\u2714\uFE0E', 2)).toBe false
+      expect(textUtils.isPairedCharacter('a\u2714\uFE0E', 3)).toBe false
+      expect(textUtils.isPairedCharacter('\uD835')).toBe false
+      expect(textUtils.isPairedCharacter('\uDF97')).toBe false
+      expect(textUtils.isPairedCharacter('\uFE0E')).toBe false
+      expect(textUtils.isPairedCharacter('\uFE0E')).toBe false
+      expect(textUtils.isPairedCharacter('\uFE0E\uFE0E')).toBe false

spec/theme-manager-spec.coffee

@@ -52,7 +52,7 @@ describe "ThemeManager", ->
 
       expect(themeManager.getEnabledThemeNames()).toEqual ['atom-dark-ui', 'atom-light-ui']
 
-  describe "getImportPaths()", ->
+  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'])
 
@@ -69,7 +69,7 @@ describe "ThemeManager", ->
 
   describe "when the core.themes config value changes", ->
     it "add/removes stylesheets to reflect the new config value", ->
-      themeManager.on 'reloaded', reloadHandler = jasmine.createSpy()
+      themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
       spyOn(themeManager, 'getUserStylesheetPath').andCallFake -> null
 
       waitsForPromise ->
@@ -129,10 +129,10 @@ describe "ThemeManager", ->
       spyOn(console, 'warn')
       expect(-> atom.packages.activatePackage('a-theme-that-will-not-be-found')).toThrow()
 
-  describe "requireStylesheet(path)", ->
+  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")
+      themeManager.onDidChangeStylesheets stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
+      themeManager.onDidAddStylesheet stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
       cssPath = atom.project.resolve('css.css')
       lengthBefore = $('head style').length
 
@@ -185,18 +185,17 @@ describe "ThemeManager", ->
       $('head style[id*="css.css"]').remove()
       $('head style[id*="sample.less"]').remove()
 
-  describe ".removeStylesheet(path)", ->
-    it "removes styling applied by given stylesheet path", ->
+    it "returns a disposable allowing styles applied by the given path to be removed", ->
       cssPath = require.resolve('./fixtures/css.css')
 
       expect($(document.body).css('font-weight')).not.toBe("bold")
-      themeManager.requireStylesheet(cssPath)
+      disposable = 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.onDidRemoveStylesheet stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
+      themeManager.onDidChangeStylesheets stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
 
-      themeManager.removeStylesheet(cssPath)
+      disposable.dispose()
 
       expect($(document.body).css('font-weight')).not.toBe("bold")
 
@@ -209,7 +208,7 @@ describe "ThemeManager", ->
 
   describe "base stylesheet loading", ->
     beforeEach ->
-      atom.workspaceView = new WorkspaceView
+      atom.workspaceView = atom.workspace.getView(atom.workspace).__spacePenView
       atom.workspaceView.append $$ -> @div class: 'editor'
       atom.workspaceView.attachToDom()
 
@@ -217,7 +216,7 @@ describe "ThemeManager", ->
         themeManager.activateThemes()
 
     it "loads the correct values from the theme's ui-variables file", ->
-      themeManager.on 'reloaded', reloadHandler = jasmine.createSpy()
+      themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
       atom.config.set('core.themes', ['theme-with-ui-variables'])
 
       waitsFor ->
@@ -234,7 +233,7 @@ describe "ThemeManager", ->
 
     describe "when there is a theme with incomplete variables", ->
       it "loads the correct values from the fallback ui-variables", ->
-        themeManager.on 'reloaded', reloadHandler = jasmine.createSpy()
+        themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
         atom.config.set('core.themes', ['theme-with-incomplete-ui-variables'])
 
         waitsFor ->
@@ -251,7 +250,7 @@ describe "ThemeManager", ->
       it 'adds theme-* classes to the workspace for each active theme', ->
         expect(atom.workspaceView).toHaveClass 'theme-atom-dark-ui'
 
-        themeManager.on 'reloaded', reloadHandler = jasmine.createSpy()
+        themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
         atom.config.set('core.themes', ['theme-with-ui-variables'])
 
         waitsFor ->
@@ -273,9 +272,9 @@ describe "ThemeManager", ->
         themeManager.activateThemes()
 
       runs ->
-        themeManager.on 'stylesheets-changed', stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
-        themeManager.on 'stylesheet-removed', stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
-        themeManager.on 'stylesheet-added', stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
+        themeManager.onDidChangeStylesheets stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
+        themeManager.onDidRemoveStylesheet stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
+        themeManager.onDidAddStylesheet stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
         spyOn(themeManager, 'loadUserStylesheet').andCallThrough()
 
         expect($(document.body).css('border-style')).toBe 'dotted'
@@ -316,7 +315,9 @@ describe "ThemeManager", ->
         themeManager.activateThemes()
 
       runs ->
-        themeManager.once 'reloaded', -> reloaded = true
+        disposable = themeManager.onDidReloadAll ->
+          disposable.dispose()
+          reloaded = true
         spyOn(console, 'warn')
         expect(-> atom.config.set('core.themes', ['atom-light-ui', 'theme-really-does-not-exist'])).not.toThrow()
 

spec/tokenized-buffer-spec.coffee

@@ -41,7 +41,7 @@ describe "TokenizedBuffer", ->
       buffer = atom.project.bufferForPathSync('sample.js')
       tokenizedBuffer = new TokenizedBuffer({buffer})
       startTokenizing(tokenizedBuffer)
-      tokenizedBuffer.on "changed", changeHandler = jasmine.createSpy('changeHandler')
+      tokenizedBuffer.onDidChange changeHandler = jasmine.createSpy('changeHandler')
 
     afterEach ->
       tokenizedBuffer.destroy()
@@ -468,7 +468,7 @@ describe "TokenizedBuffer", ->
 
       runs ->
         tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
-        tokenizedBuffer.on 'tokenized', tokenizedHandler
+        tokenizedBuffer.onDidTokenize tokenizedHandler
         fullyTokenize(tokenizedBuffer)
         expect(tokenizedHandler.callCount).toBe(1)
 
@@ -483,7 +483,7 @@ describe "TokenizedBuffer", ->
         tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
         fullyTokenize(tokenizedBuffer)
 
-        tokenizedBuffer.on 'tokenized', tokenizedHandler
+        tokenizedBuffer.onDidTokenize tokenizedHandler
         editor.getBuffer().insert([0, 0], "'")
         fullyTokenize(tokenizedBuffer)
         expect(tokenizedHandler).not.toHaveBeenCalled()
@@ -499,7 +499,7 @@ describe "TokenizedBuffer", ->
 
       runs ->
         tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
-        tokenizedBuffer.on 'tokenized', tokenizedHandler
+        tokenizedBuffer.onDidTokenize tokenizedHandler
         fullyTokenize(tokenizedBuffer)
         tokenizedHandler.reset()
 
@@ -586,7 +586,7 @@ describe "TokenizedBuffer", ->
       atom.config.set('editor.tabLength', 1)
       expect(tokenizedBuffer.tokenForPosition([0,0]).value).toBe ' '
       atom.config.set('editor.tabLength', 0)
-      expect(tokenizedBuffer.tokenForPosition([0,0]).value).toBe '  '
+      expect(tokenizedBuffer.tokenForPosition([0,0]).value).toBe ' '
 
   describe "when the invisibles value changes", ->
     beforeEach ->
@@ -753,7 +753,7 @@ describe "TokenizedBuffer", ->
         expect(tokenizedBuffer.tokenizedLineForRow(10).indentLevel).toBe 3
         expect(tokenizedBuffer.tokenizedLineForRow(11).indentLevel).toBe 2
 
-        tokenizedBuffer.on "changed", changeHandler = jasmine.createSpy('changeHandler')
+        tokenizedBuffer.onDidChange changeHandler = jasmine.createSpy('changeHandler')
 
         buffer.setTextInRange([[7, 0], [8, 65]], '        one\n        two\n        three\n        four')
 
@@ -771,7 +771,7 @@ describe "TokenizedBuffer", ->
         buffer.insert([7, 0], '\n\n')
         buffer.insert([5, 0], '\n\n')
 
-        tokenizedBuffer.on "changed", changeHandler = jasmine.createSpy('changeHandler')
+        tokenizedBuffer.onDidChange changeHandler = jasmine.createSpy('changeHandler')
 
         buffer.setTextInRange([[7, 0], [8, 65]], '    ok')
 

spec/view-registry-spec.coffee

@@ -0,0 +1,107 @@
+ViewRegistry = require '../src/view-registry'
+{View} = require '../src/space-pen-extensions'
+
+describe "ViewRegistry", ->
+  registry = null
+
+  beforeEach ->
+    registry = new ViewRegistry
+
+  describe "::getView(object)", ->
+    describe "when passed a DOM node", ->
+      it "returns the given DOM node", ->
+        node = document.createElement('div')
+        expect(registry.getView(node)).toBe node
+
+    describe "when passed a SpacePen view", ->
+      it "returns the root node of the view with a __spacePenView property pointing at the SpacePen view", ->
+        class TestView extends View
+          @content: -> @div "Hello"
+
+        view = new TestView
+        node = registry.getView(view)
+        expect(node.textContent).toBe "Hello"
+        expect(node.__spacePenView).toBe view
+
+    describe "when passed a model object", ->
+      describe "when a view provider is registered matching the object's constructor", ->
+        describe "when the provider has a viewConstructor property", ->
+          it "constructs a view element and assigns the model on it", ->
+            class TestModel
+
+            class TestModelSubclass extends TestModel
+
+            class TestView
+              setModel: (@model) ->
+
+            model = new TestModel
+
+            registry.addViewProvider
+              modelConstructor: TestModel
+              viewConstructor: TestView
+
+            view = registry.getView(model)
+            expect(view instanceof TestView).toBe true
+            expect(view.model).toBe model
+
+            subclassModel = new TestModelSubclass
+            view2 = registry.getView(subclassModel)
+            expect(view2 instanceof TestView).toBe true
+            expect(view2.model).toBe subclassModel
+
+        describe "when the provider has a createView method", ->
+          it "constructs a view element by calling the createView method with the model", ->
+            class TestModel
+            class TestView
+              setModel: (@model) ->
+
+            registry.addViewProvider
+              modelConstructor: TestModel
+              createView: (model) ->
+                view = new TestView
+                view.setModel(model)
+                view
+
+            model = new TestModel
+            view = registry.getView(model)
+            expect(view instanceof TestView).toBe true
+            expect(view.model).toBe model
+
+      describe "when no view provider is registered for the object's constructor", ->
+        describe "when the object has a .getViewClass() method", ->
+          it "builds an instance of the view class with the model, then returns its root node with a __spacePenView property pointing at the view", ->
+            class TestView extends View
+              @content: (model) -> @div model.name
+              initialize: (@model) ->
+
+            class TestModel
+              constructor: (@name) ->
+              getViewClass: -> TestView
+
+            model = new TestModel("hello")
+            node = registry.getView(model)
+
+            expect(node.textContent).toBe "hello"
+            view = node.__spacePenView
+            expect(view instanceof TestView).toBe true
+            expect(view.model).toBe model
+
+            # returns the same DOM node for repeated calls
+            expect(registry.getView(model)).toBe node
+
+        describe "when the object has no .getViewClass() method", ->
+          it "throws an exception", ->
+            expect(-> registry.getView(new Object)).toThrow()
+
+  describe "::addViewProvider(providerSpec)", ->
+    it "returns a disposable that can be used to remove the provider", ->
+      class TestModel
+      class TestView
+        setModel: (@model) ->
+      disposable = registry.addViewProvider
+        modelConstructor: TestModel
+        viewConstructor: TestView
+
+      expect(registry.getView(new TestModel) instanceof TestView).toBe true
+      disposable.dispose()
+      expect(-> registry.getView(new TestModel)).toThrow()

spec/window-spec.coffee

@@ -1,6 +1,6 @@
 {$, $$} = require 'atom'
 path = require 'path'
-Editor = require '../src/editor'
+TextEditor = require '../src/text-editor'
 WindowEventHandler = require '../src/window-event-handler'
 
 describe "Window", ->
@@ -59,7 +59,7 @@ describe "Window", ->
     [beforeUnloadEvent] = []
 
     beforeEach ->
-      jasmine.unspy(Editor.prototype, "shouldPromptToSave")
+      jasmine.unspy(TextEditor.prototype, "shouldPromptToSave")
       beforeUnloadEvent = $.Event(new Event('beforeunload'))
 
     describe "when pane items are are modified", ->
@@ -256,3 +256,35 @@ describe "Window", ->
 
         elements.trigger "core:focus-previous"
         expect(elements.find("[tabindex=1]:focus")).toExist()
+
+  describe "the window:open-path event", ->
+    beforeEach ->
+      spyOn(atom.workspace, 'open')
+
+    describe "when the project does not have a path", ->
+      beforeEach ->
+        atom.project.setPath()
+
+      describe "when the opened path exists", ->
+        it "sets the project path to the opened path", ->
+          $(window).trigger('window:open-path', [{pathToOpen: __filename}])
+
+          expect(atom.project.getPath()).toBe __dirname
+
+      describe "when the opened path does not exist but its parent directory does", ->
+        it "sets the project path to the opened path's parent directory", ->
+          $(window).trigger('window:open-path', [{pathToOpen: path.join(__dirname, 'this-path-does-not-exist.txt')}])
+
+          expect(atom.project.getPath()).toBe __dirname
+
+    describe "when the opened path is a file", ->
+      it "opens it in the workspace", ->
+        $(window).trigger('window:open-path', [{pathToOpen: __filename}])
+
+        expect(atom.workspace.open.mostRecentCall.args[0]).toBe __filename
+
+    describe "when the opened path is a directory", ->
+      it "does not open it in the workspace", ->
+        $(window).trigger('window:open-path', [{pathToOpen: __dirname}])
+
+        expect(atom.workspace.open.callCount).toBe 0

spec/workspace-spec.coffee

@@ -1,4 +1,5 @@
 Workspace = require '../src/workspace'
+{View} = require '../src/space-pen-extensions'
 
 describe "Workspace", ->
   workspace = null
@@ -219,8 +220,8 @@ describe "Workspace", ->
       it "returns the resource returned by the custom opener", ->
         fooOpener = (pathToOpen, options) -> { foo: pathToOpen, options } if pathToOpen?.match(/\.foo/)
         barOpener = (pathToOpen) -> { bar: pathToOpen } if pathToOpen?.match(/^bar:\/\//)
-        workspace.registerOpener(fooOpener)
-        workspace.registerOpener(barOpener)
+        workspace.addOpener(fooOpener)
+        workspace.addOpener(barOpener)
 
         waitsForPromise ->
           pathToOpen = atom.project.resolve('a.foo')

spec/workspace-view-spec.coffee

@@ -2,7 +2,7 @@
 Q = require 'q'
 path = require 'path'
 temp = require 'temp'
-EditorView = require '../src/editor-view'
+TextEditorView = require '../src/text-editor-view'
 PaneView = require '../src/pane-view'
 Workspace = require '../src/workspace'
 
@@ -13,7 +13,7 @@ describe "WorkspaceView", ->
     atom.project.setPath(atom.project.resolve('dir'))
     pathToOpen = atom.project.resolve('a')
     atom.workspace = new Workspace
-    atom.workspaceView = new WorkspaceView(atom.workspace)
+    atom.workspaceView = atom.workspace.getView(atom.workspace).__spacePenView
     atom.workspaceView.enableKeymap()
     atom.workspaceView.focus()
 
@@ -29,7 +29,7 @@ describe "WorkspaceView", ->
       atom.workspaceView.remove()
       atom.project = atom.deserializers.deserialize(projectState)
       atom.workspace = Workspace.deserialize(workspaceState)
-      atom.workspaceView = new WorkspaceView(atom.workspace)
+      atom.workspaceView = atom.workspace.getView(atom.workspace).__spacePenView
       atom.workspaceView.attachToDom()
 
     describe "when the serialized WorkspaceView has an unsaved buffer", ->
@@ -42,7 +42,7 @@ describe "WorkspaceView", ->
         runs ->
           editorView1 = atom.workspaceView.getActiveView()
           buffer = editorView1.getEditor().getBuffer()
-          editorView1.splitRight()
+          editorView1.getPaneView().getModel().splitRight(copyActiveItem: true)
           expect(atom.workspaceView.getActivePaneView()).toBe atom.workspaceView.getPaneViews()[1]
 
           simulateReload()
@@ -61,7 +61,7 @@ describe "WorkspaceView", ->
 
         waitsForPromise ->
           atom.workspace.open('b').then (editor) ->
-            pane2.activateItem(editor)
+            pane2.activateItem(editor.copy())
 
         waitsForPromise ->
           atom.workspace.open('../sample.js').then (editor) ->
@@ -185,7 +185,8 @@ describe "WorkspaceView", ->
 
     describe "when the root view is deserialized", ->
       it "updates the title to contain the project's path", ->
-        workspaceView2 = new WorkspaceView(atom.workspace.testSerialization())
+        workspace2 = atom.workspace.testSerialization()
+        workspaceView2 = workspace2.getView(workspace2).__spacePenView
         item = atom.workspace.getActivePaneItem()
         expect(workspaceView2.title).toBe "#{item.getTitle()} - #{atom.project.getPath()}"
         workspaceView2.remove()
@@ -196,7 +197,8 @@ describe "WorkspaceView", ->
       atom.workspaceView.attachToDom()
       rightEditorView = atom.workspaceView.getActiveView()
       rightEditorView.getEditor().setText("\t  \n")
-      leftEditorView = rightEditorView.splitLeft()
+      rightEditorView.getPaneView().getModel().splitLeft(copyActiveItem: true)
+      leftEditorView = atom.workspaceView.getActiveView()
       expect(rightEditorView.find(".line:first").text()).toBe "    "
       expect(leftEditorView.find(".line:first").text()).toBe "    "
 
@@ -207,14 +209,16 @@ describe "WorkspaceView", ->
       expect(rightEditorView.find(".line:first").text()).toBe withInvisiblesShowing
       expect(leftEditorView.find(".line:first").text()).toBe withInvisiblesShowing
 
-      lowerLeftEditorView = leftEditorView.splitDown()
+      leftEditorView.getPaneView().getModel().splitDown(copyActiveItem: true)
+      lowerLeftEditorView = atom.workspaceView.getActiveView()
       expect(lowerLeftEditorView.find(".line:first").text()).toBe withInvisiblesShowing
 
       atom.workspaceView.trigger "window:toggle-invisibles"
       expect(rightEditorView.find(".line:first").text()).toBe "    "
       expect(leftEditorView.find(".line:first").text()).toBe "    "
 
-      lowerRightEditorView = rightEditorView.splitDown()
+      rightEditorView.getPaneView().getModel().splitDown(copyActiveItem: true)
+      lowerRightEditorView = atom.workspaceView.getActiveView()
       expect(lowerRightEditorView.find(".line:first").text()).toBe "    "
 
   describe ".eachEditorView(callback)", ->
@@ -241,7 +245,7 @@ describe "WorkspaceView", ->
       atom.workspaceView.eachEditorView(callback)
       count = 0
       callbackEditor = null
-      atom.workspaceView.getActiveView().splitRight()
+      atom.workspaceView.getActiveView().getPaneView().getModel().splitRight(copyActiveItem: true)
       expect(count).toBe 1
       expect(callbackEditor).toBe atom.workspaceView.getActiveView()
 
@@ -249,7 +253,7 @@ describe "WorkspaceView", ->
       editorViewCreatedHandler = jasmine.createSpy('editorViewCreatedHandler')
       atom.workspaceView.eachEditorView(editorViewCreatedHandler)
       editorViewCreatedHandler.reset()
-      miniEditor = new EditorView(mini: true)
+      miniEditor = new TextEditorView(mini: true)
       atom.workspaceView.append(miniEditor)
       expect(editorViewCreatedHandler).not.toHaveBeenCalled()
 
@@ -259,10 +263,10 @@ describe "WorkspaceView", ->
 
       subscription = atom.workspaceView.eachEditorView(callback)
       expect(count).toBe 1
-      atom.workspaceView.getActiveView().splitRight()
+      atom.workspaceView.getActiveView().getPaneView().getModel().splitRight(copyActiveItem: true)
       expect(count).toBe 2
       subscription.off()
-      atom.workspaceView.getActiveView().splitRight()
+      atom.workspaceView.getActiveView().getPaneView().getModel().splitRight(copyActiveItem: true)
       expect(count).toBe 2
 
   describe "core:close", ->
@@ -271,7 +275,7 @@ describe "WorkspaceView", ->
 
       paneView1 = atom.workspaceView.getActivePaneView()
       editorView = atom.workspaceView.getActiveView()
-      editorView.splitRight()
+      editorView.getPaneView().getModel().splitRight(copyActiveItem: true)
       paneView2 = atom.workspaceView.getActivePaneView()
 
       expect(paneView1).not.toBe paneView2

src/atom.coffee

@@ -7,21 +7,22 @@ screen = require 'screen'
 shell = require 'shell'
 
 _ = require 'underscore-plus'
-{deprecated} = require 'grim'
+{deprecate} = require 'grim'
+{Emitter} = require 'event-kit'
 {Model} = require 'theorist'
 fs = require 'fs-plus'
 
 {$} = require './space-pen-extensions'
 WindowEventHandler = require './window-event-handler'
 
-# Public: Atom global for dealing with packages, themes, menus, and the window.
+# Essential: Atom global for dealing with packages, themes, menus, and the window.
 #
 # An instance of this class is always available as the `atom` global.
 module.exports =
 class Atom extends Model
   @version: 1  # Increment this when the serialization format changes
 
-  # Public: Load or create the Atom environment in the given mode.
+  # Load or create the Atom environment in the given mode.
   #
   # * `mode` A {String} mode that is either 'editor' or 'spec' depending on the
   #   kind of environment you want to build.
@@ -98,26 +99,27 @@ class Atom extends Model
   workspaceViewParentSelector: 'body'
   lastUncaughtError: null
 
-  # Public: A {Clipboard} instance
-  clipboard: null
+  ###
+  Section: Properties
+  ###
+
+  # Experimental: A {CommandRegistry} instance
+  commands: null
 
   # Public: A {Config} instance
   config: null
 
+  # Public: A {Clipboard} instance
+  clipboard: null
+
   # Public: A {ContextMenuManager} instance
   contextMenu: null
 
-  # Public: A {DeserializerManager} instance
-  deserializers: null
-
-  # Public: A {KeymapManager} instance
-  keymaps: null
-
   # Public: A {MenuManager} instance
   menu: null
 
-  # Public: A {PackageManager} instance
-  packages: null
+  # Public: A {KeymapManager} instance
+  keymaps: null
 
   # Public: A {Project} instance
   project: null
@@ -125,26 +127,43 @@ class Atom extends Model
   # Public: A {Syntax} instance
   syntax: null
 
+  # Public: A {PackageManager} instance
+  packages: null
+
   # Public: A {ThemeManager} instance
   themes: null
 
+  # Public: A {DeserializerManager} instance
+  deserializers: null
+
   # Public: A {Workspace} instance
   workspace: null
 
   # Public: A {WorkspaceView} instance
   workspaceView: null
 
+  ###
+  Section: Construction and Destruction
+  ###
+
   # Call .loadOrCreate instead
   constructor: (@state) ->
+    @emitter = new Emitter
     {@mode} = @state
     DeserializerManager = require './deserializer-manager'
     @deserializers = new DeserializerManager()
 
-  # Public: Sets up the basic services that should be available in all modes
+  # Sets up the basic services that should be available in all modes
   # (both spec and application).
   #
   # Call after this instance has been assigned to the `atom` global.
   initialize: ->
+    # Disable deprecations unless in dev mode or spec mode so that regular
+    # editor performance isn't impacted by generating stack traces for
+    # deprecated calls.
+    unless @inDevMode() or @inSpecMode()
+      require('grim').deprecate = ->
+
     window.onerror = =>
       @openDevTools()
       @executeJavaScriptInDevTools('InspectorFrontendAPI.showConsole()')
@@ -158,6 +177,7 @@ class Atom extends Model
 
     Config = require './config'
     KeymapManager = require './keymap-extensions'
+    CommandRegistry = require './command-registry'
     PackageManager = require './package-manager'
     Clipboard = require './clipboard'
     Syntax = require './syntax'
@@ -179,6 +199,7 @@ class Atom extends Model
     @config = new Config({configDirPath, resourcePath})
     @keymaps = new KeymapManager({configDirPath, resourcePath})
     @keymap = @keymaps # Deprecated
+    @commands = new CommandRegistry
     @packages = new PackageManager({devMode, configDirPath, resourcePath, safeMode})
     @themes = new ThemeManager({packageManager: @packages, configDirPath, resourcePath, safeMode})
     @contextMenu = new ContextMenuManager({resourcePath, devMode})
@@ -187,33 +208,183 @@ class Atom extends Model
 
     @syntax = @deserializers.deserialize(@state.syntax) ? new Syntax()
 
-    @subscribe @packages, 'activated', => @watchThemes()
+    @subscribe @packages.onDidActivateAll => @watchThemes()
 
     Project = require './project'
     TextBuffer = require 'text-buffer'
     @deserializers.add(TextBuffer)
     TokenizedBuffer = require './tokenized-buffer'
     DisplayBuffer = require './display-buffer'
-    Editor = require './editor'
+    TextEditor = require './text-editor'
 
     @windowEventHandler = new WindowEventHandler
 
-  # Deprecated: Callers should be converted to use atom.deserializers
-  registerRepresentationClass: ->
-    deprecated("Callers should be converted to use atom.deserializers")
+  ###
+  Section: Event Subscription
+  ###
 
-  # Deprecated: Callers should be converted to use atom.deserializers
-  registerRepresentationClasses: ->
-    deprecated("Callers should be converted to use atom.deserializers")
+  # Extended: Invoke the given callback whenever {::beep} is called.
+  #
+  # * `callback` {Function} to be called whenever {::beep} is called.
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+  onDidBeep: (callback) ->
+    @emitter.on 'did-beep', callback
 
-  setBodyPlatformClass: ->
-    document.body.classList.add("platform-#{process.platform}")
+  ###
+  Section: Atom Details
+  ###
 
-  # Public: Get the current window
+  # Public: Is the current window in development mode?
+  inDevMode: ->
+    @getLoadSettings().devMode
+
+  # Public: Is the current window running specs?
+  inSpecMode: ->
+    @getLoadSettings().isSpec
+
+  # Public: Get the version of the Atom application.
+  #
+  # Returns the version text {String}.
+  getVersion: ->
+    @appVersion ?= @getLoadSettings().appVersion
+
+  # Public: Determine whether the current version is an official release.
+  isReleasedVersion: ->
+    not /\w{7}/.test(@getVersion()) # Check if the release is a 7-character SHA prefix
+
+  # Public: Get the directory path to Atom's configuration area.
+  #
+  # Returns the absolute path to `~/.atom`.
+  getConfigDirPath: ->
+    @constructor.getConfigDirPath()
+
+  # Public: Get the time taken to completely load the current window.
+  #
+  # This time include things like loading and activating packages, creating
+  # DOM elements for the editor, and reading the config.
+  #
+  # Returns the {Number} of milliseconds taken to load the window or null
+  # if the window hasn't finished loading yet.
+  getWindowLoadTime: ->
+    @loadTime
+
+  # Public: Get the load settings for the current window.
+  #
+  # Returns an {Object} containing all the load setting key/value pairs.
+  getLoadSettings: ->
+    @constructor.getLoadSettings()
+
+  ###
+  Section: Managing The Atom Window
+  ###
+
+  # Essential: Open a new Atom window using the given options.
+  #
+  # Calling this method without an options parameter will open a prompt to pick
+  # a file/folder to open in the new window.
+  #
+  # * `options` An {Object} with the following keys:
+  #   * `pathsToOpen`  An {Array} of {String} paths to open.
+  #   * `newWindow` A {Boolean}, true to always open a new window instead of
+  #     reusing existing windows depending on the paths to open.
+  #   * `devMode` A {Boolean}, true to open the window in development mode.
+  #     Development mode loads the Atom source from the locally cloned
+  #     repository and also loads all the packages in ~/.atom/dev/packages
+  #   * `safeMode` A {Boolean}, true to open the window in safe mode. Safe
+  #     mode prevents all packages installed to ~/.atom/packages from loading.
+  open: (options) ->
+    ipc.send('open', options)
+
+  # Essential: Close the current window.
+  close: ->
+    @getCurrentWindow().close()
+
+  # Essential: Get the size of current window.
+  #
+  # Returns an {Object} in the format `{width: 1000, height: 700}`
+  getSize: ->
+    [width, height] = @getCurrentWindow().getSize()
+    {width, height}
+
+  # Essential: Set the size of current window.
+  #
+  # * `width` The {Number} of pixels.
+  # * `height` The {Number} of pixels.
+  setSize: (width, height) ->
+    @getCurrentWindow().setSize(width, height)
+
+  # Essential: Get the position of current window.
+  #
+  # Returns an {Object} in the format `{x: 10, y: 20}`
+  getPosition: ->
+    [x, y] = @getCurrentWindow().getPosition()
+    {x, y}
+
+  # Essential: Set the position of current window.
+  #
+  # * `x` The {Number} of pixels.
+  # * `y` The {Number} of pixels.
+  setPosition: (x, y) ->
+    ipc.send('call-window-method', 'setPosition', x, y)
+
+  # Extended: Get the current window
   getCurrentWindow: ->
     @constructor.getCurrentWindow()
 
-  # Public: Get the dimensions of this window.
+  # Extended: Move current window to the center of the screen.
+  center: ->
+    ipc.send('call-window-method', 'center')
+
+  # Extended: Focus the current window.
+  focus: ->
+    ipc.send('call-window-method', 'focus')
+    $(window).focus()
+
+  # Extended: Show the current window.
+  show: ->
+    ipc.send('call-window-method', 'show')
+
+  # Extended: Hide the current window.
+  hide: ->
+    ipc.send('call-window-method', 'hide')
+
+  # Extended: Reload the current window.
+  reload: ->
+    ipc.send('call-window-method', 'restart')
+
+  # Extended: Returns a {Boolean} true when the current window is maximized.
+  isMaximixed: ->
+    @getCurrentWindow().isMaximized()
+
+  maximize: ->
+    ipc.send('call-window-method', 'maximize')
+
+  # Extended: Is the current window in full screen mode?
+  isFullScreen: ->
+    @getCurrentWindow().isFullScreen()
+
+  # Extended: Set the full screen state of the current window.
+  setFullScreen: (fullScreen=false) ->
+    ipc.send('call-window-method', 'setFullScreen', fullScreen)
+    if fullScreen then document.body.classList.add("fullscreen") else document.body.classList.remove("fullscreen")
+
+  # Extended: Toggle the full screen state of the current window.
+  toggleFullScreen: ->
+    @setFullScreen(!@isFullScreen())
+
+  # Schedule the window to be shown and focused on the next tick.
+  #
+  # This is done in a next tick to prevent a white flicker from occurring
+  # if called synchronously.
+  displayWindow: ({maximize}={}) ->
+    setImmediate =>
+      @show()
+      @focus()
+      @setFullScreen(true) if @workspace.fullScreen
+      @maximize() if maximize
+
+  # Get the dimensions of this window.
   #
   # Returns an {Object} with the following keys:
   #   * `x`      The window's x-position {Number}.
@@ -227,7 +398,7 @@ class Atom extends Model
     maximized = browserWindow.isMaximized()
     {x, y, width, height, maximized}
 
-  # Public: Set the dimensions of the window.
+  # Set the dimensions of the window.
   #
   # The window will be centered if either the x or y coordinate is not set
   # in the dimensions parameter. If x or y are omitted the window will be
@@ -284,41 +455,6 @@ class Atom extends Model
     dimensions = @getWindowDimensions()
     @state.windowDimensions = dimensions if @isValidDimensions(dimensions)
 
-  # Public: Get the load settings for the current window.
-  #
-  # Returns an {Object} containing all the load setting key/value pairs.
-  getLoadSettings: ->
-    @constructor.getLoadSettings()
-
-  deserializeProject: ->
-    Project = require './project'
-
-    startTime = Date.now()
-    @project ?= @deserializers.deserialize(@state.project) ? new Project(path: @getLoadSettings().initialPath)
-    @deserializeTimings.project = Date.now() - startTime
-
-  deserializeWorkspaceView: ->
-    Workspace = require './workspace'
-    WorkspaceView = require './workspace-view'
-
-    startTime = Date.now()
-    @workspace = Workspace.deserialize(@state.workspace) ? new Workspace
-    @workspaceView = new WorkspaceView(@workspace)
-    @deserializeTimings.workspace = Date.now() - startTime
-
-    @keymaps.defaultTarget = @workspaceView[0]
-    $(@workspaceViewParentSelector).append(@workspaceView)
-
-  deserializePackageStates: ->
-    @packages.packageStates = @state.packageStates ? {}
-    delete @state.packageStates
-
-  deserializeEditorWindow: ->
-    @deserializeTimings = {}
-    @deserializePackageStates()
-    @deserializeProject()
-    @deserializeWorkspaceView()
-
   # Call this method when establishing a real application window.
   startEditorWindow: ->
     {resourcePath, safeMode} = @getLoadSettings()
@@ -330,9 +466,7 @@ class Atom extends Model
       console.warn error.message if error?
 
     dimensions = @restoreWindowDimensions()
-    @config.load()
-    @config.setDefaults('core', require('./workspace-view').configDefaults)
-    @config.setDefaults('editor', require('./editor-view').configDefaults)
+    @loadConfig()
     @keymaps.loadBundledKeymaps()
     @themes.loadBaseStylesheets()
     @packages.loadPackages()
@@ -369,59 +503,34 @@ class Atom extends Model
 
     @windowEventHandler?.unsubscribe()
 
-  loadThemes: ->
-    @themes.load()
+  ###
+  Section: Messaging the User
+  ###
 
-  watchThemes: ->
-    @themes.on 'reloaded', =>
-      # Only reload stylesheets from non-theme packages
-      for pack in @packages.getActivePackages() when pack.getType() isnt 'theme'
-        pack.reloadStylesheets?()
-      null
+  # Essential: Visually and audibly trigger a beep.
+  beep: ->
+    shell.beep() if @config.get('core.audioBeep')
+    @workspaceView.trigger 'beep'
+    @emitter.emit 'did-beep'
 
-  # Notify the browser project of the window's current project path
-  watchProjectPath: ->
-    onProjectPathChanged = =>
-      ipc.send('window-command', 'project-path-changed', @project.getPath())
-    @subscribe @project, 'path-changed', onProjectPathChanged
-    onProjectPathChanged()
-
-  # Public: Open a new Atom window using the given options.
-  #
-  # Calling this method without an options parameter will open a prompt to pick
-  # a file/folder to open in the new window.
-  #
-  # * `options` An {Object} with the following keys:
-  #   * `pathsToOpen`  An {Array} of {String} paths to open.
-  #   * `newWindow` A {Boolean}, true to always open a new window instead of
-  #     reusing existing windows depending on the paths to open.
-  #   * `devMode` A {Boolean}, true to open the window in development mode.
-  #     Development mode loads the Atom source from the locally cloned
-  #     repository and also loads all the packages in ~/.atom/dev/packages
-  #   * `safeMode` A {Boolean}, true to open the window in safe mode. Safe
-  #     mode prevents all packages installed to ~/.atom/packages from loading.
-  open: (options) ->
-    ipc.send('open', options)
-
-  # Public: Open a confirm dialog.
+  # Essential: A flexible way to open a dialog akin to an alert dialog.
   #
   # ## Examples
   #
   # ```coffee
-  #   atom.confirm
-  #     message: 'How you feeling?'
-  #     detailedMessage: 'Be honest.'
-  #     buttons:
-  #       Good: -> window.alert('good to hear')
-  #       Bad:  -> window.alert('bummer')
+  # atom.confirm
+  #   message: 'How you feeling?'
+  #   detailedMessage: 'Be honest.'
+  #   buttons:
+  #     Good: -> window.alert('good to hear')
+  #     Bad: -> window.alert('bummer')
   # ```
   #
   # * `options` An {Object} with the following keys:
   #   * `message` The {String} message to display.
-  #   * `detailedMessage` The {String} detailed message to display.
-  #   * `buttons` Either an array of strings or an object where keys are
-  #               button names and the values are callbacks to invoke when
-  #               clicked.
+  #   * `detailedMessage` (optional) The {String} detailed message to display.
+  #   * `buttons` (optional) Either an array of strings or an object where keys are
+  #     button names and the values are callbacks to invoke when clicked.
   #
   # Returns the chosen button index {Number} if the buttons option was an array.
   confirm: ({message, detailedMessage, buttons}={}) ->
@@ -444,77 +553,75 @@ class Atom extends Model
       callback = buttons[buttonLabels[chosen]]
       callback?()
 
-  showSaveDialog: (callback) ->
-    callback(showSaveDialogSync())
+  ###
+  Section: Managing the Dev Tools
+  ###
 
-  showSaveDialogSync: (defaultPath) ->
-    defaultPath ?= @project?.getPath()
-    currentWindow = @getCurrentWindow()
-    dialog = remote.require('dialog')
-    dialog.showSaveDialog currentWindow, {title: 'Save File', defaultPath}
-
-  # Public: Open the dev tools for the current window.
+  # Extended: Open the dev tools for the current window.
   openDevTools: ->
     ipc.send('call-window-method', 'openDevTools')
 
-  # Public: Toggle the visibility of the dev tools for the current window.
+  # Extended: Toggle the visibility of the dev tools for the current window.
   toggleDevTools: ->
     ipc.send('call-window-method', 'toggleDevTools')
 
-  # Public: Execute code in dev tools.
+  # Extended: Execute code in dev tools.
   executeJavaScriptInDevTools: (code) ->
     ipc.send('call-window-method', 'executeJavaScriptInDevTools', code)
 
-  # Public: Reload the current window.
-  reload: ->
-    ipc.send('call-window-method', 'restart')
+  ###
+  Section: Private
+  ###
 
-  # Public: Focus the current window.
-  focus: ->
-    ipc.send('call-window-method', 'focus')
-    $(window).focus()
+  deserializeProject: ->
+    Project = require './project'
 
-  # Public: Show the current window.
-  show: ->
-    ipc.send('call-window-method', 'show')
+    startTime = Date.now()
+    @project ?= @deserializers.deserialize(@state.project) ? new Project(path: @getLoadSettings().initialPath)
+    @deserializeTimings.project = Date.now() - startTime
 
-  # Public: Hide the current window.
-  hide: ->
-    ipc.send('call-window-method', 'hide')
+  deserializeWorkspaceView: ->
+    Workspace = require './workspace'
+    WorkspaceView = require './workspace-view'
 
-  # Public: Set the size of current window.
-  #
-  # * `width` The {Number} of pixels.
-  # * `height` The {Number} of pixels.
-  setSize: (width, height) ->
-    @getCurrentWindow().setSize(width, height)
+    startTime = Date.now()
+    @workspace = Workspace.deserialize(@state.workspace) ? new Workspace
+    @workspaceView = @workspace.getView(@workspace).__spacePenView
+    @deserializeTimings.workspace = Date.now() - startTime
 
-  # Public: Set the position of current window.
-  #
-  # * `x` The {Number} of pixels.
-  # * `y` The {Number} of pixels.
-  setPosition: (x, y) ->
-    ipc.send('call-window-method', 'setPosition', x, y)
+    @keymaps.defaultTarget = @workspaceView[0]
+    $(@workspaceViewParentSelector).append(@workspaceView)
 
-  # Public: Move current window to the center of the screen.
-  center: ->
-    ipc.send('call-window-method', 'center')
+  deserializePackageStates: ->
+    @packages.packageStates = @state.packageStates ? {}
+    delete @state.packageStates
 
+  deserializeEditorWindow: ->
+    @deserializeTimings = {}
+    @deserializePackageStates()
+    @deserializeProject()
+    @deserializeWorkspaceView()
 
-  # Schedule the window to be shown and focused on the next tick.
-  #
-  # This is done in a next tick to prevent a white flicker from occurring
-  # if called synchronously.
-  displayWindow: ({maximize}={}) ->
-    setImmediate =>
-      @show()
-      @focus()
-      @setFullScreen(true) if @workspace.fullScreen
-      @maximize() if maximize
+  loadConfig: ->
+    @config.setSchema null, {type: 'object', properties: _.clone(require('./config-schema'))}
+    @config.load()
 
-  # Public: Close the current window.
-  close: ->
-    @getCurrentWindow().close()
+  loadThemes: ->
+    @themes.load()
+
+  watchThemes: ->
+    @themes.onDidReloadAll =>
+      # Only reload stylesheets from non-theme packages
+      for pack in @packages.getActivePackages() when pack.getType() isnt 'theme'
+        pack.reloadStylesheets?()
+      null
+
+  # Notify the browser project of the window's current project path
+  watchProjectPath: ->
+    onProjectPathChanged = =>
+      ipc.send('window-command', 'project-path-changed', @project.getPath())
+    @subscribe @project, 'path-changed', onProjectPathChanged
+    onProjectPathChanged()
 
   exit: (status) ->
     app = remote.require('app')
@@ -527,45 +634,14 @@ class Atom extends Model
   setRepresentedFilename: (filename) ->
     ipc.send('call-window-method', 'setRepresentedFilename', filename)
 
-  # Public: Is the current window in development mode?
-  inDevMode: ->
-    @getLoadSettings().devMode
+  showSaveDialog: (callback) ->
+    callback(showSaveDialogSync())
 
-  # Public: Is the current window running specs?
-  inSpecMode: ->
-    @getLoadSettings().isSpec
-
-  # Public: Toggle the full screen state of the current window.
-  toggleFullScreen: ->
-    @setFullScreen(!@isFullScreen())
-
-  # Public: Set the full screen state of the current window.
-  setFullScreen: (fullScreen=false) ->
-    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()
-
-  maximize: ->
-    ipc.send('call-window-method', 'maximize')
-
-  # Public: Get the version of the Atom application.
-  #
-  # Returns the version text {String}.
-  getVersion: ->
-    @appVersion ?= @getLoadSettings().appVersion
-
-  # Public: Determine whether the current version is an official release.
-  isReleasedVersion: ->
-    not /\w{7}/.test(@getVersion()) # Check if the release is a 7-character SHA prefix
-
-  # Public: Get the directory path to Atom's configuration area.
-  #
-  # Returns the absolute path to `~/.atom`.
-  getConfigDirPath: ->
-    @constructor.getConfigDirPath()
+  showSaveDialogSync: (defaultPath) ->
+    defaultPath ?= @project?.getPath()
+    currentWindow = @getCurrentWindow()
+    dialog = remote.require('dialog')
+    dialog.showSaveDialog currentWindow, {title: 'Save File', defaultPath}
 
   saveSync: ->
     stateString = JSON.stringify(@state)
@@ -574,27 +650,12 @@ class Atom extends Model
     else
       @getCurrentWindow().loadSettings.windowState = stateString
 
-  # Public: Get the time taken to completely load the current window.
-  #
-  # This time include things like loading and activating packages, creating
-  # DOM elements for the editor, and reading the config.
-  #
-  # Returns the {Number} of milliseconds taken to load the window or null
-  # if the window hasn't finished loading yet.
-  getWindowLoadTime: ->
-    @loadTime
-
   crashMainProcess: ->
     remote.process.crash()
 
   crashRenderProcess: ->
     process.crash()
 
-  # Public: Visually and audibly trigger a beep.
-  beep: ->
-    shell.beep() if @config.get('core.audioBeep')
-    @workspaceView.trigger 'beep'
-
   getUserInitScriptPath: ->
     initScriptPath = fs.resolve(@getConfigDirPath(), 'init', ['js', 'coffee'])
     initScriptPath ? path.join(@getConfigDirPath(), 'init.coffee')
@@ -606,7 +667,7 @@ class Atom extends Model
       catch error
         console.error "Failed to load `#{userInitScriptPath}`", error.stack, error
 
-  # Public: Require the module with the given globals.
+  # Require the module with the given globals.
   #
   # The globals will be set on the `window` object and removed after the
   # require completes.
@@ -626,3 +687,14 @@ class Atom extends Model
         delete window[key]
       else
         window[key] = value
+
+  # Deprecated: Callers should be converted to use atom.deserializers
+  registerRepresentationClass: ->
+    deprecate("Callers should be converted to use atom.deserializers")
+
+  # Deprecated: Callers should be converted to use atom.deserializers
+  registerRepresentationClasses: ->
+    deprecate("Callers should be converted to use atom.deserializers")
+
+  setBodyPlatformClass: ->
+    document.body.classList.add("platform-#{process.platform}")

src/browser/atom-application.coffee

@@ -5,13 +5,11 @@ AutoUpdateManager = require './auto-update-manager'
 BrowserWindow = require 'browser-window'
 Menu = require 'menu'
 app = require 'app'
-dialog = require 'dialog'
 fs = require 'fs'
 ipc = require 'ipc'
 path = require 'path'
 os = require 'os'
 net = require 'net'
-shell = require 'shell'
 url = require 'url'
 {EventEmitter} = require 'events'
 _ = require 'underscore-plus'
@@ -103,11 +101,12 @@ class AtomApplication
     window.once 'window:loaded', =>
       @autoUpdateManager.emitUpdateAvailableEvent(window)
 
-    focusHandler = => @lastFocusedWindow = window
-    window.browserWindow.on 'focus', focusHandler
-    window.browserWindow.once 'closed', =>
-      @lastFocusedWindow = null if window is @lastFocusedWindow
-      window.browserWindow.removeListener 'focus', focusHandler
+    unless window.isSpec
+      focusHandler = => @lastFocusedWindow = window
+      window.browserWindow.on 'focus', focusHandler
+      window.browserWindow.once 'closed', =>
+        @lastFocusedWindow = null if window is @lastFocusedWindow
+        window.browserWindow.removeListener 'focus', focusHandler
 
   # Creates server to listen for additional atom application launches.
   #
@@ -155,8 +154,8 @@ class AtomApplication
       atomWindow ?= @focusedWindow()
       atomWindow?.browserWindow.inspectElement(x, y)
 
-    @on 'application:open-documentation', -> shell.openExternal('https://atom.io/docs/latest/?app')
-    @on 'application:open-terms-of-use', -> shell.openExternal('https://atom.io/terms')
+    @on 'application:open-documentation', -> require('shell').openExternal('https://atom.io/docs/latest/?app')
+    @on 'application:open-terms-of-use', -> require('shell').openExternal('https://atom.io/terms')
     @on 'application:install-update', -> @autoUpdateManager.install()
     @on 'application:check-for-update', => @autoUpdateManager.check()
 
@@ -484,5 +483,23 @@ class AtomApplication
         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) =>
+
+    # Show the open dialog as child window on Windows and Linux, and as
+    # independent dialog on OS X. This matches most native apps.
+    parentWindow =
+      if process.platform is 'darwin'
+        null
+      else
+        BrowserWindow.getFocusedWindow()
+
+    openOptions =
+      properties: properties.concat(['multiSelections', 'createDirectory'])
+      title: 'Open'
+
+    if process.platform is 'linux'
+      if projectPath = @lastFocusedWindow?.projectPath
+        openOptions.defaultPath = projectPath
+
+    dialog = require 'dialog'
+    dialog.showOpenDialog parentWindow, openOptions, (pathsToOpen) =>
       @openPaths({pathsToOpen, devMode, safeMode, window})

src/browser/atom-protocol-handler.coffee

@@ -1,5 +1,5 @@
 app = require 'app'
-fs = require 'fs-plus'
+fs = require 'fs'
 path = require 'path'
 protocol = require 'protocol'
 
@@ -24,5 +24,5 @@ class AtomProtocolHandler
       relativePath = path.normalize(request.url.substr(7))
       for loadPath in @loadPaths
         filePath = path.join(loadPath, relativePath)
-        break if fs.isFileSync(filePath)
+        break if fs.statSyncNoException(filePath).isFile?()
       return new protocol.RequestFileJob(filePath)

src/browser/atom-window.coffee

@@ -1,7 +1,5 @@
 BrowserWindow = require 'browser-window'
-ContextMenu = require './context-menu'
 app = require 'app'
-dialog = require 'dialog'
 path = require 'path'
 fs = require 'fs'
 url = require 'url'
@@ -25,7 +23,13 @@ class AtomWindow
     # Normalize to make sure drive letter case is consistent on Windows
     @resourcePath = path.normalize(@resourcePath) if @resourcePath
 
-    @browserWindow = new BrowserWindow show: false, title: 'Atom', icon: @constructor.iconPath
+    @browserWindow = new BrowserWindow
+      show: false
+      title: 'Atom'
+      icon: @constructor.iconPath
+      'web-preferences':
+        'direct-write': false
+        'subpixel-font-scaling': false
     global.atomApplication.addWindow(this)
 
     @handleEvents()
@@ -73,6 +77,13 @@ class AtomWindow
   getInitialPath: ->
     @browserWindow.loadSettings.initialPath
 
+  setupContextMenu: ->
+    ContextMenu = null
+
+    @browserWindow.on 'context-menu', (menuTemplate) =>
+      ContextMenu ?= require './context-menu'
+      new ContextMenu(menuTemplate, this)
+
   containsPath: (pathToCheck) ->
     initialPath = @getInitialPath()
     if not initialPath
@@ -95,6 +106,7 @@ class AtomWindow
     @browserWindow.on 'unresponsive', =>
       return if @isSpec
 
+      dialog = require 'dialog'
       chosen = dialog.showMessageBox @browserWindow,
         type: 'warning'
         buttons: ['Close', 'Keep Waiting']
@@ -105,6 +117,7 @@ class AtomWindow
     @browserWindow.webContents.on 'crashed', =>
       global.atomApplication.exit(100) if @exitWhenDone
 
+      dialog = require 'dialog'
       chosen = dialog.showMessageBox @browserWindow,
         type: 'warning'
         buttons: ['Close Window', 'Reload', 'Keep It Open']
@@ -114,8 +127,7 @@ class AtomWindow
         when 0 then @browserWindow.destroy()
         when 1 then @browserWindow.restart()
 
-    @browserWindow.on 'context-menu', (menuTemplate) =>
-      new ContextMenu(menuTemplate, this)
+    @setupContextMenu()
 
     if @isSpec
       # Workaround for https://github.com/atom/atom-shell/issues/380

src/browser/auto-update-manager.coffee

@@ -1,44 +1,47 @@
-https = require 'https'
-autoUpdater = require 'auto-updater'
-dialog = require 'dialog'
+autoUpdater = null
 _ = 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'
+IdleState = 'idle'
+CheckingState = 'checking'
+DownladingState = 'downloading'
+UpdateAvailableState = 'update-available'
+NoUpdateAvailableState = 'no-update-available'
+ErrorState = 'error'
 
 module.exports =
 class AutoUpdateManager
   _.extend @prototype, EventEmitter.prototype
 
   constructor: (@version) ->
-    @state = IDLE_STATE
+    @state = IdleState
     @feedUrl = "https://atom.io/api/updates?version=#{@version}"
 
+    process.nextTick => @setupAutoUpdater()
+
+  setupAutoUpdater: ->
+    autoUpdater = require 'auto-updater'
+
     if process.platform is 'win32'
       autoUpdater.checkForUpdates = => @checkForUpdatesShim()
 
     autoUpdater.setFeedUrl @feedUrl
 
     autoUpdater.on 'checking-for-update', =>
-      @setState(CHECKING_STATE)
+      @setState(CheckingState)
 
     autoUpdater.on 'update-not-available', =>
-      @setState(NO_UPDATE_AVAILABLE_STATE)
+      @setState(NoUpdateAvailableState)
 
     autoUpdater.on 'update-available', =>
-      @setState(DOWNLOADING_STATE)
+      @setState(DownladingState)
 
     autoUpdater.on 'error', (event, message) =>
-      @setState(ERROR_STATE)
+      @setState(ErrorState)
       console.error "Error Downloading Update: #{message}"
 
     autoUpdater.on 'update-downloaded', (event, @releaseNotes, @releaseVersion) =>
-      @setState(UPDATE_AVAILABLE_STATE)
+      @setState(UpdateAvailableState)
       @emitUpdateAvailableEvent(@getWindows()...)
 
     # Only released versions should check for updates.
@@ -48,6 +51,8 @@ class AutoUpdateManager
   # Windows doesn't have an auto-updater, so use this method to shim the events.
   checkForUpdatesShim: ->
     autoUpdater.emit 'checking-for-update'
+
+    https = require 'https'
     request = https.get @feedUrl, (response) ->
       if response.statusCode == 200
         body = ""
@@ -67,7 +72,7 @@ class AutoUpdateManager
       atomWindow.sendCommand('window:update-available', [@releaseVersion, @releaseNotes])
 
   setState: (state) ->
-    return unless @state != state
+    return if @state is state
     @state = state
     @emit 'state-changed', @state
 
@@ -86,10 +91,12 @@ class AutoUpdateManager
 
   onUpdateNotAvailable: =>
     autoUpdater.removeListener 'error', @onUpdateError
+    dialog = require 'dialog'
     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 = require 'dialog'
     dialog.showMessageBox type: 'warning', buttons: ['OK'], message: 'There was an error checking for updates.', detail: message
 
   getWindows: ->

src/browser/context-menu.coffee

@@ -13,12 +13,12 @@ class ContextMenu
   createClickHandlers: (template) ->
     for item in template
       if item.command
-        item.commandOptions ?= {}
-        item.commandOptions.contextCommand = true
-        item.commandOptions.atomWindow = @atomWindow
+        item.commandDetail ?= {}
+        item.commandDetail.contextCommand = true
+        item.commandDetail.atomWindow = @atomWindow
         do (item) =>
           item.click = =>
-            global.atomApplication.sendCommandToWindow(item.command, @atomWindow, item.commandOptions)
+            global.atomApplication.sendCommandToWindow(item.command, @atomWindow, item.commandDetail)
       else if item.submenu
         @createClickHandlers(item.submenu)
       item

src/browser/main.coffee

@@ -3,11 +3,9 @@ global.shellStartTime = Date.now()
 crashReporter = require 'crash-reporter'
 app = require 'app'
 fs = require 'fs'
-module = require 'module'
 path = require 'path'
 optimist = require 'optimist'
 nslog = require 'nslog'
-dialog = require 'dialog'
 
 console.log = nslog
 
@@ -33,14 +31,14 @@ start = ->
   app.on 'will-finish-launching', ->
     setupCrashReporter()
 
-  app.on 'finish-launching', ->
+  app.on 'ready', ->
     app.removeListener 'open-file', addPathToOpen
     app.removeListener 'open-url', addUrlToOpen
 
     args.pathsToOpen = args.pathsToOpen.map (pathToOpen) ->
       path.resolve(args.executedFrom ? process.cwd(), pathToOpen.toString())
 
-    require('coffee-script').register()
+    setupCoffeeScript()
     if args.devMode
       require(path.join(args.resourcePath, 'src', 'coffee-cache')).register()
       AtomApplication = require path.join(args.resourcePath, 'src', 'browser', 'atom-application')
@@ -57,6 +55,15 @@ global.devResourcePath = path.normalize(global.devResourcePath) if global.devRes
 setupCrashReporter = ->
   crashReporter.start(productName: 'Atom', companyName: 'GitHub')
 
+setupCoffeeScript = ->
+  CoffeeScript = null
+
+  require.extensions['.coffee'] = (module, filePath) ->
+    CoffeeScript ?= require('coffee-script')
+    coffee = fs.readFileSync(filePath, 'utf8')
+    js = CoffeeScript.compile(coffee, filename: filePath)
+    module._compile(js, filePath)
+
 parseCommandLine = ->
   version = app.getVersion()
   options = optimist(process.argv[1..])
@@ -109,9 +116,7 @@ parseCommandLine = ->
   else if devMode
     resourcePath = global.devResourcePath
 
-  try
-    fs.statSync resourcePath
-  catch
+  unless fs.statSyncNoException(resourcePath)
     resourcePath = path.dirname(path.dirname(__dirname))
 
   {resourcePath, pathsToOpen, executedFrom, test, version, pidToKillWhenClosed, devMode, safeMode, newWindow, specDirectory, logFile}

src/buffered-node-process.coffee

@@ -1,7 +1,7 @@
 BufferedProcess = require './buffered-process'
 path = require 'path'
 
-# Public: Like {BufferedProcess}, but accepts a Node script as the command
+# Extended: Like {BufferedProcess}, but accepts a Node script as the command
 # to run.
 #
 # This is necessary on Windows since it doesn't support shebang `#!` lines.

src/buffered-process.coffee

@@ -1,7 +1,7 @@
 _ = require 'underscore-plus'
 ChildProcess = require 'child_process'
 
-# Public: A wrapper which provides standard error/output line buffering for
+# Extended: A wrapper which provides standard error/output line buffering for
 # Node's ChildProcess.
 #
 # ## Examples
@@ -44,13 +44,14 @@ class BufferedProcess
     if process.platform is "win32"
       # Quote all arguments and escapes inner quotes
       if args?
-        cmdArgs = args.map (arg) ->
+        cmdArgs = args.filter (arg) -> arg?
+        cmdArgs = cmdArgs.map (arg) ->
           if command in ['explorer.exe', 'explorer'] and /^\/[a-zA-Z]+,.*$/.test(arg)
             # Don't wrap /root,C:\folder style arguments to explorer calls in
             # quotes since they will not be interpreted correctly if they are
             arg
           else
-            "\"#{arg.replace(/"/g, '\\"')}\""
+            "\"#{arg.toString().replace(/"/g, '\\"')}\""
       else
         cmdArgs = []
       if /\s/.test(command)

src/clipboard.coffee

@@ -1,7 +1,7 @@
 clipboard = require 'clipboard'
 crypto = require 'crypto'
 
-# Public: Represents the clipboard used for copying and pasting in Atom.
+# Extended: Represents the clipboard used for copying and pasting in Atom.
 #
 # An instance of this class is always available as the `atom.clipboard` global.
 #

src/command-registry.coffee

@@ -0,0 +1,232 @@
+{Disposable, CompositeDisposable} = require 'event-kit'
+{specificity} = require 'clear-cut'
+_ = require 'underscore-plus'
+{$} = require './space-pen-extensions'
+
+SequenceCount = 0
+SpecificityCache = {}
+
+module.exports =
+
+# Experimental: Associates listener functions with commands in a
+# context-sensitive way using CSS selectors. You can access a global instance of
+# this class via `atom.commands`, and commands registered there will be
+# presented in the command palette.
+#
+# The global command registry facilitates a style of event handling known as
+# *event delegation* that was popularized by jQuery. Atom commands are expressed
+# as custom DOM events that can be invoked on the currently focused element via
+# a key binding or manually via the command palette. Rather than binding
+# listeners for command events directly to DOM nodes, you instead register
+# command event listeners globally on `atom.commands` and constrain them to
+# specific kinds of elements with CSS selectors.
+#
+# As the event bubbles upward through the DOM, all registered event listeners
+# with matching selectors are invoked in order of specificity. In the event of a
+# specificity tie, the most recently registered listener is invoked first. This
+# mirrors the "cascade" semantics of CSS. Event listeners are invoked in the
+# context of the current DOM node, meaning `this` always points at
+# `event.currentTarget`. As is normally the case with DOM events,
+# `stopPropagation` and `stopImmediatePropagation` can be used to terminate the
+# bubbling process and prevent invocation of additional listeners.
+#
+# ## Example
+#
+# Here is a command that inserts the current date in an editor:
+#
+# ```coffee
+# atom.commands.add '.editor',
+#   'user:insert-date': (event) ->
+#     editor = $(this).view().getModel()
+#     # soon the above above line will be:
+#     # editor = @getModel()
+#     editor.insertText(new Date().toLocaleString())
+# ```
+class CommandRegistry
+  constructor: (@rootNode) ->
+    @listenersByCommandName = {}
+
+  getRootNode: -> @rootNode
+
+  setRootNode: (newRootNode) ->
+    oldRootNode = @rootNode
+    @rootNode = newRootNode
+
+    for commandName of @listenersByCommandName
+      @removeCommandListener(oldRootNode, commandName)
+      @addCommandListener(newRootNode, commandName)
+
+  # Public: Add one or more command listeners associated with a selector.
+  #
+  # ## Arguments: Registering One Command
+  #
+  # * `selector` A {String} containing a CSS selector matching elements on which
+  #   you want to handle the commands. The `,` combinator is not currently
+  #   supported.
+  # * `commandName` A {String} containing the name of a command you want to
+  #   handle such as `user:insert-date`.
+  # * `callback` A {Function} to call when the given command is invoked on an
+  #   element matching the selector. It will be called with `this` referencing
+  #   the matching DOM node.
+  #   * `event` A standard DOM event instance. Call `stopPropagation` or
+  #     `stopImmediatePropagation` to terminate bubbling early.
+  #
+  # ## Arguments: Registering Multiple Commands
+  #
+  # * `selector` A {String} containing a CSS selector matching elements on which
+  #   you want to handle the commands. The `,` combinator is not currently
+  #   supported.
+  # * `commands` An {Object} mapping command names like `user:insert-date` to
+  #   listener {Function}s.
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to remove the
+  # added command handler(s).
+  add: (selector, commandName, callback) ->
+    if typeof commandName is 'object'
+      commands = commandName
+      disposable = new CompositeDisposable
+      for commandName, callback of commands
+        disposable.add @add(selector, commandName, callback)
+      return disposable
+
+    unless @listenersByCommandName[commandName]?
+      @addCommandListener(@rootNode, commandName)
+      @listenersByCommandName[commandName] = []
+
+    listener = new CommandListener(selector, callback)
+    listenersForCommand = @listenersByCommandName[commandName]
+    listenersForCommand.push(listener)
+
+    new Disposable =>
+      listenersForCommand.splice(listenersForCommand.indexOf(listener), 1)
+      if listenersForCommand.length is 0
+        delete @listenersByCommandName[commandName]
+        @removeCommandListener(@rootNode, commandName)
+
+  # Public: Find all registered commands matching a query.
+  #
+  # * `params` An {Object} containing one or more of the following keys:
+  #   * `target` A DOM node that is the hypothetical target of a given command.
+  #
+  # Returns an {Array} of {Object}s containing the following keys:
+  #  * `name` The name of the command. For example, `user:insert-date`.
+  #  * `displayName` The display name of the command. For example,
+  #    `User: Insert Date`.
+  #  * `jQuery` Present if the command was registered with the legacy
+  #    `$::command` method.
+  findCommands: ({target}) ->
+    commands = []
+    target = @rootNode unless @rootNode.contains(target)
+    currentTarget = target
+    loop
+      for commandName, listeners of @listenersByCommandName
+        for listener in listeners
+          if currentTarget.webkitMatchesSelector(listener.selector)
+            commands.push
+              name: commandName
+              displayName: _.humanizeEventName(commandName)
+
+      break if currentTarget is @rootNode
+      currentTarget = currentTarget.parentNode
+      break unless currentTarget?
+
+    for name, displayName of $(target).events() when displayName
+      commands.push({name, displayName, jQuery: true})
+
+    for name, displayName of $(window).events() when displayName
+      commands.push({name, displayName, jQuery: true})
+
+    commands
+
+  # Public: Simulate the dispatch of a command on a DOM node.
+  #
+  # This can be useful for testing when you want to simulate the invocation of a
+  # command on a detached DOM node. Otherwise, the DOM node in question needs to
+  # be attached to the document so the event bubbles up to the root node to be
+  # processed.
+  #
+  # * `target` The DOM node at which to start bubbling the command event.
+  # * `commandName` {String} indicating the name of the command to dispatch.
+  dispatch: (target, commandName) ->
+    event = new CustomEvent(commandName, bubbles: true)
+    eventWithTarget = Object.create(event, target: value: target)
+    @handleCommandEvent(eventWithTarget)
+
+  getSnapshot: ->
+    snapshot = {}
+    for commandName, listeners of @listenersByCommandName
+      snapshot[commandName] = listeners.slice()
+    snapshot
+
+  restoreSnapshot: (snapshot) ->
+    rootNode = @getRootNode()
+    @setRootNode(null) # clear listeners for current commands
+    @listenersByCommandName = {}
+    for commandName, listeners of snapshot
+      @listenersByCommandName[commandName] = listeners.slice()
+    @setRootNode(rootNode) # restore listeners for commands in snapshot
+
+  handleCommandEvent: (originalEvent) =>
+    originalEvent.__handledByCommandRegistry = true
+
+    propagationStopped = false
+    immediatePropagationStopped = false
+    matched = false
+    currentTarget = originalEvent.target
+    invokedListeners = []
+
+    syntheticEvent = Object.create originalEvent,
+      eventPhase: value: Event.BUBBLING_PHASE
+      currentTarget: get: -> currentTarget
+      stopPropagation: value: ->
+        originalEvent.stopPropagation()
+        propagationStopped = true
+      stopImmediatePropagation: value: ->
+        originalEvent.stopImmediatePropagation()
+        propagationStopped = true
+        immediatePropagationStopped = true
+      disableInvokedListeners: value: ->
+        listener.enabled = false for listener in invokedListeners
+        -> listener.enabled = true for listener in invokedListeners
+
+    loop
+      matchingListeners =
+        (@listenersByCommandName[originalEvent.type] ? [])
+          .filter (listener) -> currentTarget.webkitMatchesSelector(listener.selector)
+          .sort (a, b) -> a.compare(b)
+
+      matched = true if matchingListeners.length > 0
+
+      for listener in matchingListeners when listener.enabled
+        break if immediatePropagationStopped
+        invokedListeners.push(listener)
+        listener.callback.call(currentTarget, syntheticEvent)
+
+      break if currentTarget is @rootNode
+      break if propagationStopped
+      currentTarget = currentTarget.parentNode
+      break unless currentTarget?
+
+    matched
+
+  handleJQueryCommandEvent: (event) =>
+    @handleCommandEvent(event) unless event.originalEvent?.__handledByCommandRegistry
+
+  addCommandListener: (node, commandName, listener) ->
+    node?.addEventListener(commandName, @handleCommandEvent, true)
+    $(node).on commandName, @handleJQueryCommandEvent
+
+  removeCommandListener: (node, commandName) ->
+    node?.removeEventListener(commandName, @handleCommandEvent, true)
+    $(node).off commandName, @handleJQueryCommandEvent
+
+class CommandListener
+  enabled: true
+
+  constructor: (@selector, @callback) ->
+    @specificity = (SpecificityCache[@selector] ?= specificity(@selector))
+    @sequenceNumber = SequenceCount++
+
+  compare: (other) ->
+    other.specificity - @specificity  or
+      other.sequenceNumber - @sequenceNumber

src/config-schema.coffee

@@ -0,0 +1,115 @@
+path = require 'path'
+fs = require 'fs-plus'
+
+# This is loaded by atom.coffee
+module.exports =
+  core:
+    type: 'object'
+    properties:
+      ignoredNames:
+        type: 'array'
+        default: [".git", ".hg", ".svn", ".DS_Store", "Thumbs.db"]
+        items:
+          type: 'string'
+      excludeVcsIgnoredPaths:
+        type: 'boolean'
+        default: true
+        title: 'Exclude VCS Ignored Paths'
+      disabledPackages:
+        type: 'array'
+        default: []
+        items:
+          type: 'string'
+      themes:
+        type: 'array'
+        default: ['atom-dark-ui', 'atom-dark-syntax']
+        items:
+          type: 'string'
+      projectHome:
+        type: 'string'
+        default: path.join(fs.getHomeDirectory(), 'github')
+      audioBeep:
+        type: 'boolean'
+        default: true
+      destroyEmptyPanes:
+        type: 'boolean'
+        default: true
+
+  editor:
+    type: 'object'
+    properties:
+      fontFamily:
+        type: 'string'
+        default: ''
+      fontSize:
+        type: 'integer'
+        default: 16
+        minimum: 1
+      lineHeight:
+        type: ['string', 'number']
+        default: 1.3
+      showInvisibles:
+        type: 'boolean'
+        default: false
+      showIndentGuide:
+        type: 'boolean'
+        default: false
+      showLineNumbers:
+        type: 'boolean'
+        default: true
+      autoIndent:
+        type: 'boolean'
+        default: true
+      normalizeIndentOnPaste:
+        type: 'boolean'
+        default: true
+      nonWordCharacters:
+        type: 'string'
+        default: "/\\()\"':,.;<>~!@#$%^&*|+=[]{}`?-"
+      preferredLineLength:
+        type: 'integer'
+        default: 80
+        minimum: 1
+      tabLength:
+        type: 'integer'
+        default: 2
+        minimum: 1
+      softWrap:
+        type: 'boolean'
+        default: false
+      softTabs:
+        type: 'boolean'
+        default: true
+      softWrapAtPreferredLineLength:
+        type: 'boolean'
+        default: false
+      scrollSensitivity:
+        type: 'integer'
+        default: 40
+        minimum: 10
+        maximum: 200
+      scrollPastEnd:
+        type: 'boolean'
+        default: false
+      useHardwareAcceleration:
+        type: 'boolean'
+        default: true
+      confirmCheckoutHeadRevision:
+        type: 'boolean'
+        default: true
+        title: 'Confirm Checkout HEAD Revision'
+      invisibles:
+        type: 'object'
+        properties:
+          eol:
+            type: ['boolean', 'string']
+            default: '\u00ac'
+          space:
+            type: ['boolean', 'string']
+            default: '\u00b7'
+          tab:
+            type: ['boolean', 'string']
+            default: '\u00bb'
+          cr:
+            type: ['boolean', 'string']
+            default: '\u00a4'

src/config.coffee

@@ -1,39 +1,510 @@
 _ = require 'underscore-plus'
 fs = require 'fs-plus'
-{Emitter} = require 'emissary'
+EmitterMixin = require('emissary').Emitter
+{Emitter} = require 'event-kit'
 CSON = require 'season'
 path = require 'path'
 async = require 'async'
 pathWatcher = require 'pathwatcher'
+{deprecate} = require 'grim'
 
-# Public: Used to access all of Atom's configuration details.
+# Essential: Used to access all of Atom's configuration details.
 #
 # An instance of this class is always available as the `atom.config` global.
 #
-# ## Best practices
-#
-# * Create your own root keypath using your package's name.
-# * Don't depend on (or write to) configuration keys outside of your keypath.
-#
-# ## Examples
+# ## Getting and setting config settings. Note that with no value set, {::get}
+# returns the setting's default value.
 #
 # ```coffee
-# atom.config.set('my-package.key', 'value')
-# atom.config.observe 'my-package.key', ->
-#   console.log 'My configuration changed:', atom.config.get('my-package.key')
+# atom.config.get('my-package.myKey') # -> 'defaultValue'
+#
+# atom.config.set('my-package.myKey', 'value')
+# atom.config.get('my-package.myKey') # -> 'value'
 # ```
+#
+# You may want to watch for changes. Use {::observe} to catch changes to the setting.
+#
+# ```coffee
+# atom.config.set('my-package.myKey', 'value')
+# atom.config.observe 'my-package.myKey', (newValue) ->
+#   # `observe` calls immediately and every time the value is changed
+#   console.log 'My configuration changed:', newValue
+# ```
+#
+# If you want a notification only when the value changes, use {::onDidChange}.
+#
+# ```coffee
+# atom.config.onDidChange 'my-package.myKey', ({newValue, oldValue}) ->
+#   console.log 'My configuration changed:', newValue, oldValue
+# ```
+#
+# ### Value Coercion
+#
+# Config settings each have a type specified by way of a
+# [schema](json-schema.org). For example we might an integer setting that only
+# allows integers greater than `0`:
+#
+# ```coffee
+# # When no value has been set, `::get` returns the setting's default value
+# atom.config.get('my-package.anInt') # -> 12
+#
+# # The string will be coerced to the integer 123
+# atom.config.set('my-package.anInt', '123')
+# atom.config.get('my-package.anInt') # -> 123
+#
+# # The string will be coerced to an integer, but it must be greater than 0, so is set to 1
+# atom.config.set('my-package.anInt', '-20')
+# atom.config.get('my-package.anInt') # -> 1
+# ```
+#
+# ## Defining settings for your package
+#
+# Define a schema under a `config` key in your package main.
+#
+# ```coffee
+# module.exports =
+#   # Your config schema
+#   config:
+#     someInt:
+#       type: 'integer'
+#       default: 23
+#       minimum: 1
+#
+#   activate: (state) -> # ...
+#   # ...
+# ```
+#
+# See [Creating a Package](https://atom.io/docs/latest/creating-a-package) for
+# more info.
+#
+# ## Config Schemas
+#
+# We use [json schema](json-schema.org) which allows you to define your value's
+# default, the type it should be, etc. A simple example:
+#
+# ```coffee
+# # We want to provide an `enableThing`, and a `thingVolume`
+# config:
+#   enableThing:
+#     type: 'boolean'
+#     default: false
+#   thingVolume:
+#     type: 'integer'
+#     default: 5
+#     minimum: 1
+#     maximum: 11
+# ```
+#
+# The type keyword allows for type coercion and validation. If a `thingVolume` is
+# set to a string `'10'`, it will be coerced into an integer.
+#
+# ```coffee
+# atom.config.set('my-package.thingVolume', '10')
+# atom.config.get('my-package.thingVolume') # -> 10
+#
+# # It respects the min / max
+# atom.config.set('my-package.thingVolume', '400')
+# atom.config.get('my-package.thingVolume') # -> 11
+#
+# # If it cannot be coerced, the value will not be set
+# atom.config.set('my-package.thingVolume', 'cats')
+# atom.config.get('my-package.thingVolume') # -> 11
+# ```
+#
+# ### Supported Types
+#
+# The `type` keyword can be a string with any one of the following. You can also
+# chain them by specifying multiple in an an array. For example
+#
+# ```coffee
+# config:
+#   someSetting:
+#     type: ['boolean', 'integer']
+#     default: 5
+#
+# # Then
+# atom.config.set('my-package.someSetting', 'true')
+# atom.config.get('my-package.someSetting') # -> true
+#
+# atom.config.set('my-package.someSetting', '12')
+# atom.config.get('my-package.someSetting') # -> 12
+# ```
+#
+# #### string
+#
+# Values must be a string.
+#
+# ```coffee
+# config:
+#   someSetting:
+#     type: 'string'
+#     default: 'hello'
+# ```
+#
+# #### integer
+#
+# Values will be coerced into integer. Supports the (optional) `minimum` and
+# `maximum` keys.
+#
+#   ```coffee
+#   config:
+#     someSetting:
+#       type: 'integer'
+#       default: 5
+#       minimum: 1
+#       maximum: 11
+#   ```
+#
+# #### number
+#
+# Values will be coerced into a number, including real numbers. Supports the
+# (optional) `minimum` and `maximum` keys.
+#
+# ```coffee
+# config:
+#   someSetting:
+#     type: 'number'
+#     default: 5.3
+#     minimum: 1.5
+#     maximum: 11.5
+# ```
+#
+# #### boolean
+#
+# Values will be coerced into a Boolean. `'true'` and `'false'` will be coerced into
+# a boolean. Numbers, arrays, objects, and anything else will not be coerced.
+#
+# ```coffee
+# config:
+#   someSetting:
+#     type: 'boolean'
+#     default: false
+# ```
+#
+# #### array
+#
+# Value must be an Array. The types of the values can be specified by a
+# subschema in the `items` key.
+#
+# ```coffee
+# config:
+#   someSetting:
+#     type: 'array'
+#     default: [1, 2, 3]
+#     items:
+#       type: 'integer'
+#       minimum: 1.5
+#       maximum: 11.5
+# ```
+#
+# #### object
+#
+# Value must be an object. This allows you to nest config options. Sub options
+# must be under a `properties key`
+#
+# ```coffee
+# config:
+#   someSetting:
+#     type: 'object'
+#     properties:
+#       myChildIntOption:
+#         type: 'integer'
+#         minimum: 1.5
+#         maximum: 11.5
+# ```
+#
+# ### Other Supported Keys
+#
+# #### enum
+#
+# All types support an `enum` key. The enum key lets you specify all values
+# that the config setting can possibly be. `enum` _must_ be an array of values
+# of your specified type.
+#
+# ```coffee
+# config:
+#   someSetting:
+#     type: 'integer'
+#     default: 4
+#     enum: [2, 4, 6, 8]
+# ```
+#
+# ```coffee
+# atom.config.set('my-package.someSetting', '2')
+# atom.config.get('my-package.someSetting') # -> 2
+#
+# # will not set values outside of the enum values
+# atom.config.set('my-package.someSetting', '3')
+# atom.config.get('my-package.someSetting') # -> 2
+#
+# # If it cannot be coerced, the value will not be set
+# atom.config.set('my-package.someSetting', '4')
+# atom.config.get('my-package.someSetting') # -> 4
+# ```
+#
+# #### title and description
+#
+# The settings view will use the `title` and `description` keys to display your
+# config setting in a readable way. By default the settings view humanizes your
+# config key, so `someSetting` becomes `Some Setting`. In some cases, this is
+# confusing for users, and a more descriptive title is useful.
+#
+# Descriptions will be displayed below the title in the settings view.
+#
+# ```coffee
+# config:
+#   someSetting:
+#     title: 'Setting Magnitude'
+#     description: 'This will affect the blah and the other blah'
+#     type: 'integer'
+#     default: 4
+# ```
+#
+# __Note__: You should strive to be so clear in your naming of the setting that
+# you do not need to specify a title or description!
+#
+# ## Best practices
+#
+# * Don't depend on (or write to) configuration keys outside of your keypath.
+#
 module.exports =
 class Config
-  Emitter.includeInto(this)
+  EmitterMixin.includeInto(this)
+  @schemaEnforcers = {}
+
+  @addSchemaEnforcer: (typeName, enforcerFunction) ->
+    @schemaEnforcers[typeName] ?= []
+    @schemaEnforcers[typeName].push(enforcerFunction)
+
+  @addSchemaEnforcers: (filters) ->
+    for typeName, functions of filters
+      for name, enforcerFunction of functions
+        @addSchemaEnforcer(typeName, enforcerFunction)
+
+  @executeSchemaEnforcers: (keyPath, value, schema) ->
+    error = null
+    types = schema.type
+    types = [types] unless Array.isArray(types)
+    for type in types
+      try
+        enforcerFunctions = @schemaEnforcers[type].concat(@schemaEnforcers['*'])
+        for enforcer in enforcerFunctions
+          # At some point in one's life, one must call upon an enforcer.
+          value = enforcer.call(this, keyPath, value, schema)
+        error = null
+        break
+      catch e
+        error = e
+
+    throw error if error?
+    value
 
   # Created during initialization, available as `atom.config`
   constructor: ({@configDirPath, @resourcePath}={}) ->
+    @emitter = new Emitter
+    @schema =
+      type: 'object'
+      properties: {}
     @defaultSettings = {}
     @settings = {}
     @configFileHasErrors = false
     @configFilePath = fs.resolve(@configDirPath, 'config', ['json', 'cson'])
     @configFilePath ?= path.join(@configDirPath, 'config.cson')
 
+  ###
+  Section: Config Subscription
+  ###
+
+  # Essential: Add a listener for changes to a given key path. This is different
+  # than {::onDidChange} in that it will immediately call your callback with the
+  # current value of the config entry.
+  #
+  # * `keyPath` {String} name of the key to observe
+  # * `callback` {Function} to call when the value of the key changes.
+  #   * `value` the new value of the key
+  #
+  # Returns a {Disposable} with the following keys on which you can call
+  # `.dispose()` to unsubscribe.
+  observe: (keyPath, options={}, callback) ->
+    if _.isFunction(options)
+      callback = options
+      options = {}
+    else
+      message = ""
+      message = "`callNow` was set to false. Use ::onDidChange instead. Note that ::onDidChange calls back with different arguments." if options.callNow == false
+      deprecate "Config::observe no longer supports options. #{message}"
+
+    callback(_.clone(@get(keyPath))) unless options.callNow == false
+    @emitter.on 'did-change', (event) ->
+      callback(event.newValue) if keyPath? and keyPath.indexOf(event?.keyPath) is 0
+
+  # Essential: Add a listener for changes to a given key path. If `keyPath` is
+  # not specified, your callback will be called on changes to any key.
+  #
+  # * `keyPath` (optional) {String} name of the key to observe
+  # * `callback` {Function} to call when the value of the key changes.
+  #   * `event` {Object}
+  #     * `newValue` the new value of the key
+  #     * `oldValue` the prior value of the key.
+  #     * `keyPath` the keyPath of the changed key
+  #
+  # Returns a {Disposable} with the following keys on which you can call
+  # `.dispose()` to unsubscribe.
+  onDidChange: (keyPath, callback) ->
+    if arguments.length is 1
+      callback = keyPath
+      keyPath = undefined
+
+    @emitter.on 'did-change', (event) ->
+      callback(event) if not keyPath? or (keyPath? and keyPath.indexOf(event?.keyPath) is 0)
+
+  ###
+  Section: Managing Settings
+  ###
+
+  # Essential: Retrieves the setting for the given key.
+  #
+  # * `keyPath` The {String} name of the key to retrieve.
+  #
+  # Returns the value from Atom's default settings, the user's configuration
+  # file in the type specified by the configuration schema.
+  get: (keyPath) ->
+    value = _.valueForKeyPath(@settings, keyPath)
+    defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
+
+    if value?
+      value = _.deepClone(value)
+      valueIsObject = _.isObject(value) and not _.isArray(value)
+      defaultValueIsObject = _.isObject(defaultValue) and not _.isArray(defaultValue)
+      if valueIsObject and defaultValueIsObject
+        _.defaults(value, defaultValue)
+    else
+      value = _.deepClone(defaultValue)
+
+    value
+
+  # Essential: Sets the value for a configuration setting.
+  #
+  # This value is stored in Atom's internal configuration file.
+  #
+  # * `keyPath` The {String} name of the key.
+  # * `value` The value of the setting. Passing `undefined` will revert the
+  #   setting to the default value.
+  #
+  # Returns a {Boolean}
+  # * `true` if the value was set.
+  # * `false` if the value was not able to be coerced to the type specified in the setting's schema.
+  set: (keyPath, value) ->
+    unless value == undefined
+      try
+        value = @makeValueConformToSchema(keyPath, value)
+      catch e
+        return false
+
+    @setRawValue(keyPath, value)
+    @save() unless @configFileHasErrors
+    true
+
+  # Extended: Restore the key path to its default value.
+  #
+  # * `keyPath` The {String} name of the key.
+  #
+  # Returns the new value.
+  restoreDefault: (keyPath) ->
+    @set(keyPath, _.valueForKeyPath(@defaultSettings, keyPath))
+    @get(keyPath)
+
+  # Extended: Get the default value of the key path. _Please note_ that in most
+  # cases calling this is not necessary! {::get} returns the default value when
+  # a custom value is not specified.
+  #
+  # * `keyPath` The {String} name of the key.
+  #
+  # Returns the default value.
+  getDefault: (keyPath) ->
+    defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
+    _.deepClone(defaultValue)
+
+  # Extended: 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)?
+
+  # Extended: Retrieve the schema for a specific key path. The shema will tell
+  # you what type the keyPath expects, and other metadata about the config
+  # option.
+  #
+  # * `keyPath` The {String} name of the key.
+  #
+  # Returns an {Object} eg. `{type: 'integer', default: 23, minimum: 1}`.
+  # Returns `null` when the keyPath has no schema specified.
+  getSchema: (keyPath) ->
+    keys = keyPath.split('.')
+    schema = @schema
+    for key in keys
+      break unless schema?
+      schema = schema.properties[key]
+    schema
+
+  # Extended: Returns a new {Object} containing all of settings and defaults.
+  getSettings: ->
+    _.deepExtend(@settings, @defaultSettings)
+
+  # Extended: Get the {String} path to the config file being used.
+  getUserConfigPath: ->
+    @configFilePath
+
+  ###
+  Section: Deprecated
+  ###
+
+  getInt: (keyPath) ->
+    deprecate '''Config::getInt is no longer necessary. Use ::get instead.
+    Make sure the config option you are accessing has specified an `integer`
+    schema. See the schema section of
+    https://atom.io/docs/api/latest/Config for more info.'''
+    parseInt(@get(keyPath))
+
+  getPositiveInt: (keyPath, defaultValue=0) ->
+    deprecate '''Config::getPositiveInt is no longer necessary. Use ::get instead.
+    Make sure the config option you are accessing has specified an `integer`
+    schema with `minimum: 1`. See the schema section of
+    https://atom.io/docs/api/latest/Config for more info.'''
+    Math.max(@getInt(keyPath), 0) or defaultValue
+
+  toggle: (keyPath) ->
+    deprecate 'Config::toggle is no longer supported. Please remove from your code.'
+    @set(keyPath, !@get(keyPath))
+
+  unobserve: (keyPath) ->
+    deprecate 'Config::unobserve no longer does anything. Call `.dispose()` on the object returned by Config::observe instead.'
+
+  ###
+  Section: Private
+  ###
+
+  pushAtKeyPath: (keyPath, value) ->
+    arrayValue = @get(keyPath) ? []
+    result = arrayValue.push(value)
+    @set(keyPath, arrayValue)
+    result
+
+  unshiftAtKeyPath: (keyPath, value) ->
+    arrayValue = @get(keyPath) ? []
+    result = arrayValue.unshift(value)
+    @set(keyPath, arrayValue)
+    result
+
+  removeAtKeyPath: (keyPath, value) ->
+    arrayValue = @get(keyPath) ? []
+    result = _.remove(arrayValue, value)
+    @set(keyPath, arrayValue)
+    result
+
   initializeConfigDirectory: (done) ->
     return if fs.existsSync(@configDirPath)
 
@@ -62,210 +533,215 @@ class Config
 
     try
       userConfig = CSON.readFileSync(@configFilePath)
-      _.extend(@settings, userConfig)
+      @setAll(userConfig)
       @configFileHasErrors = false
-      @emit 'updated'
-    catch e
+    catch error
       @configFileHasErrors = true
-      console.error "Failed to load user config '#{@configFilePath}'", e.message
-      console.error e.stack
+      console.error "Failed to load user config '#{@configFilePath}'", error.message
+      console.error error.stack
 
   observeUserConfig: ->
-    @watchSubscription ?= pathWatcher.watch @configFilePath, (eventType) =>
-      @loadUserConfig() if eventType is 'change' and @watchSubscription?
+    try
+      @watchSubscription ?= pathWatcher.watch @configFilePath, (eventType) =>
+        @loadUserConfig() if eventType is 'change' and @watchSubscription?
+    catch error
+      console.error "Failed to watch user config '#{@configFilePath}'", error.message
+      console.error error.stack
 
   unobserveUserConfig: ->
     @watchSubscription?.close()
     @watchSubscription = null
 
-  setDefaults: (keyPath, defaults) ->
-    keys = keyPath.split('.')
-    hash = @defaultSettings
-    for key in keys
-      hash[key] ?= {}
-      hash = hash[key]
-
-    _.extend hash, defaults
-    @emit 'updated'
-
-  # Extended: Get the {String} path to the config file being used.
-  getUserConfigPath: ->
-    @configFilePath
-
-  # Extended: Returns a new {Object} containing all of settings and defaults.
-  getSettings: ->
-    _.deepExtend(@settings, @defaultSettings)
-
-  # Essential: Retrieves the setting for the given key.
-  #
-  # * `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.
-  get: (keyPath) ->
-    value = _.valueForKeyPath(@settings, keyPath)
-    defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
-
-    if value?
-      value = _.deepClone(value)
-      valueIsObject = _.isObject(value) and not _.isArray(value)
-      defaultValueIsObject = _.isObject(defaultValue) and not _.isArray(defaultValue)
-      if valueIsObject and defaultValueIsObject
-        _.defaults(value, defaultValue)
-    else
-      value = _.deepClone(defaultValue)
-
-    value
-
-  # Extended: Retrieves the setting for the given key as an integer.
-  #
-  # * `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.
-  getInt: (keyPath) ->
-    parseInt(@get(keyPath))
-
-  # Extended: Retrieves the setting for the given key as a positive integer.
-  #
-  # * `keyPath` The {String} name of the key to retrieve
-  # * `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.
-  getPositiveInt: (keyPath, defaultValue=0) ->
-    Math.max(@getInt(keyPath), 0) or defaultValue
-
-  # Essential: Sets the value for a configuration setting.
-  #
-  # This value is stored in Atom's internal configuration file.
-  #
-  # * `keyPath` The {String} name of the key.
-  # * `value` The value of the setting.
-  #
-  # Returns the `value`.
-  set: (keyPath, value) ->
-    if @get(keyPath) isnt value
-      defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
-      value = undefined if _.isEqual(defaultValue, value)
-      _.setValueForKeyPath(@settings, keyPath, value)
-      @update()
-    value
-
-  # Extended: Toggle the value at the key path.
-  #
-  # The new value will be `true` if the value is currently falsy and will be
-  # `false` if the value is currently truthy.
-  #
-  # * `keyPath` The {String} name of the key.
-  #
-  # Returns the new value.
-  toggle: (keyPath) ->
-    @set(keyPath, !@get(keyPath))
-
-  # Extended: Restore the key path to its default value.
-  #
-  # * `keyPath` The {String} name of the key.
-  #
-  # Returns the new value.
-  restoreDefault: (keyPath) ->
-    @set(keyPath, _.valueForKeyPath(@defaultSettings, keyPath))
-
-  # Extended: 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)
-
-  # Extended: 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)?
-
-  # Extended: 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 {Number} of the setting.
-  pushAtKeyPath: (keyPath, value) ->
-    arrayValue = @get(keyPath) ? []
-    result = arrayValue.push(value)
-    @set(keyPath, arrayValue)
-    result
-
-  # Extended: Add the value to the beginning of the array at the key path.
-  #
-  # * `keyPath` The {String} key path.
-  # * `value` The value to shift onto the array.
-  #
-  # Returns the new array length {Number} of the setting.
-  unshiftAtKeyPath: (keyPath, value) ->
-    arrayValue = @get(keyPath) ? []
-    result = arrayValue.unshift(value)
-    @set(keyPath, arrayValue)
-    result
-
-  # Public: Remove the value from the array at the key path.
-  #
-  # * `keyPath` The {String} key path.
-  # * `value` The value to remove from the array.
-  #
-  # Returns the new array value of the setting.
-  removeAtKeyPath: (keyPath, value) ->
-    arrayValue = @get(keyPath) ? []
-    result = _.remove(arrayValue, value)
-    @set(keyPath, arrayValue)
-    result
-
-  # Essential: Add a listener for changes to a given key path.
-  #
-  # * `keyPath` The {String} name of the key to observe
-  # * `options` An optional {Object} containing the `callNow` key.
-  # * `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` when called.
-  observe: (keyPath, options={}, callback) ->
-    if _.isFunction(options)
-      callback = options
-      options = {}
-
-    value = @get(keyPath)
-    previousValue = _.clone(value)
-    updateCallback = =>
-      value = @get(keyPath)
-      unless _.isEqual(value, previousValue)
-        previous = previousValue
-        previousValue = _.clone(value)
-        callback(value, {previous})
-
-    eventName = "updated.#{keyPath.replace(/\./, '-')}"
-    subscription = @on eventName, updateCallback
-    callback(value) if options.callNow ? true
-    subscription
-
-  # Unobserve all callbacks on a given key.
-  #
-  # * `keyPath` The {String} name of the key to unobserve.
-  unobserve: (keyPath) ->
-    @off("updated.#{keyPath.replace(/\./, '-')}")
-
-  update: ->
-    return if @configFileHasErrors
-    @save()
-    @emit 'updated'
-
   save: ->
     CSON.writeFileSync(@configFilePath, @settings)
+
+  setRawValue: (keyPath, value) ->
+    defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
+    value = undefined if _.isEqual(defaultValue, value)
+
+    oldValue = _.clone(@get(keyPath))
+    _.setValueForKeyPath(@settings, keyPath, value)
+    newValue = @get(keyPath)
+    @emitter.emit 'did-change', {oldValue, newValue, keyPath} unless _.isEqual(newValue, oldValue)
+
+  setRawDefault: (keyPath, value) ->
+    oldValue = _.clone(@get(keyPath))
+    _.setValueForKeyPath(@defaultSettings, keyPath, value)
+    newValue = @get(keyPath)
+    @emitter.emit 'did-change', {oldValue, newValue, keyPath} unless _.isEqual(newValue, oldValue)
+
+  setRecursive: (keyPath, value) ->
+    if isPlainObject(value)
+      keys = if keyPath? then keyPath.split('.') else []
+      for key, childValue of value
+        continue unless value.hasOwnProperty(key)
+        @setRecursive(keys.concat([key]).join('.'), childValue)
+    else
+      try
+        value = @makeValueConformToSchema(keyPath, value)
+        @setRawValue(keyPath, value)
+      catch e
+        console.warn("'#{keyPath}' could not be set. Attempted value: #{JSON.stringify(value)}; Schema: #{JSON.stringify(@getSchema(keyPath))}")
+
+  setAll: (newSettings) ->
+    unless isPlainObject(newSettings)
+      @settings = {}
+      @emitter.emit 'did-change'
+      return
+
+    unsetUnspecifiedValues = (keyPath, value) =>
+      if isPlainObject(value)
+        keys = if keyPath? then keyPath.split('.') else []
+        for key, childValue of value
+          continue unless value.hasOwnProperty(key)
+          unsetUnspecifiedValues(keys.concat([key]).join('.'), childValue)
+      else
+        @setRawValue(keyPath, undefined) unless _.valueForKeyPath(newSettings, keyPath)?
+      return
+
+    @setRecursive(null, newSettings)
+    unsetUnspecifiedValues(null, @settings)
+
+  setDefaults: (keyPath, defaults) ->
+    if defaults? and isPlainObject(defaults)
+      keys = if keyPath? then keyPath.split('.') else []
+      for key, childValue of defaults
+        continue unless defaults.hasOwnProperty(key)
+        @setDefaults(keys.concat([key]).join('.'), childValue)
+    else
+      try
+        defaults = @makeValueConformToSchema(keyPath, defaults)
+        @setRawDefault(keyPath, defaults)
+      catch e
+        console.warn("'#{keyPath}' could not set the default. Attempted default: #{JSON.stringify(defaults)}; Schema: #{JSON.stringify(@getSchema(keyPath))}")
+
+  setSchema: (keyPath, schema) ->
+    unless isPlainObject(schema)
+      throw new Error("Error loading schema for #{keyPath}: schemas can only be objects!")
+
+    unless typeof schema.type?
+      throw new Error("Error loading schema for #{keyPath}: schema objects must have a type attribute")
+
+    rootSchema = @schema
+    if keyPath
+      for key in keyPath.split('.')
+        rootSchema.type = 'object'
+        rootSchema.properties ?= {}
+        properties = rootSchema.properties
+        properties[key] ?= {}
+        rootSchema = properties[key]
+
+    _.extend rootSchema, schema
+    @setDefaults(keyPath, @extractDefaultsFromSchema(schema))
+
+  extractDefaultsFromSchema: (schema) ->
+    if schema.default?
+      schema.default
+    else if schema.type is 'object' and schema.properties? and isPlainObject(schema.properties)
+      defaults = {}
+      properties = schema.properties or {}
+      defaults[key] = @extractDefaultsFromSchema(value) for key, value of properties
+      defaults
+
+  makeValueConformToSchema: (keyPath, value) ->
+    value = @constructor.executeSchemaEnforcers(keyPath, value, schema) if schema = @getSchema(keyPath)
+    value
+
+# Base schema enforcers. These will coerce raw input into the specified type,
+# and will throw an error when the value cannot be coerced. Throwing the error
+# will indicate that the value should not be set.
+#
+# Enforcers are run from most specific to least. For a schema with type
+# `integer`, all the enforcers for the `integer` type will be run first, in
+# order of specification. Then the `*` enforcers will be run, in order of
+# specification.
+Config.addSchemaEnforcers
+  'integer':
+    coerce: (keyPath, value, schema) ->
+      value = parseInt(value)
+      throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} cannot be coerced into an int") if isNaN(value) or not isFinite(value)
+      value
+
+  'number':
+    coerce: (keyPath, value, schema) ->
+      value = parseFloat(value)
+      throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} cannot be coerced into a number") if isNaN(value) or not isFinite(value)
+      value
+
+  'boolean':
+    coerce: (keyPath, value, schema) ->
+      switch typeof value
+        when 'string'
+          if value.toLowerCase() is 'true'
+            true
+          else if value.toLowerCase() is 'false'
+            false
+          else
+            throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} must be a boolean or the string 'true' or 'false'")
+        when 'boolean'
+          value
+        else
+          throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} must be a boolean or the string 'true' or 'false'")
+
+  'string':
+    validate: (keyPath, value, schema) ->
+      unless typeof value is 'string'
+        throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} must be a string")
+      value
+
+  'null':
+    # null sort of isnt supported. It will just unset in this case
+    coerce: (keyPath, value, schema) ->
+      throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} must be null") unless value == null
+      value
+
+  'object':
+    coerce: (keyPath, value, schema) ->
+      throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} must be an object") unless isPlainObject(value)
+      return value unless schema.properties?
+
+      newValue = {}
+      for prop, childSchema of schema.properties
+        continue unless value.hasOwnProperty(prop)
+        try
+          newValue[prop] = @executeSchemaEnforcers("#{keyPath}.#{prop}", value[prop], childSchema)
+        catch error
+          console.warn "Error setting item in object: #{error.message}"
+      newValue
+
+  'array':
+    coerce: (keyPath, value, schema) ->
+      throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} must be an array") unless Array.isArray(value)
+      itemSchema = schema.items
+      if itemSchema?
+        newValue = []
+        for item in value
+          try
+            newValue.push @executeSchemaEnforcers(keyPath, item, itemSchema)
+          catch error
+            console.warn "Error setting item in array: #{error.message}"
+        newValue
+      else
+        value
+
+  '*':
+    coerceMinimumAndMaximum: (keyPath, value, schema) ->
+      return value unless typeof value is 'number'
+      if schema.minimum? and typeof schema.minimum is 'number'
+        value = Math.max(value, schema.minimum)
+      if schema.maximum? and typeof schema.maximum is 'number'
+        value = Math.min(value, schema.maximum)
+      value
+
+    validateEnum: (keyPath, value, schema) ->
+      possibleValues = schema.enum
+      return value unless possibleValues? and Array.isArray(possibleValues) and possibleValues.length
+
+      for possibleValue in possibleValues
+        # Using `isEqual` for possibility of placing enums on array and object schemas
+        return value if _.isEqual(possibleValue, value)
+
+      throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} is not one of #{JSON.stringify(possibleValues)}")
+
+isPlainObject = (value) ->
+  _.isObject(value) and not _.isArray(value) and not _.isFunction(value) and not _.isString(value)

src/context-menu-manager.coffee

@@ -4,8 +4,14 @@ remote = require 'remote'
 path = require 'path'
 CSON = require 'season'
 fs = require 'fs-plus'
+{specificity} = require 'clear-cut'
+{Disposable} = require 'event-kit'
+Grim = require 'grim'
+MenuHelpers = require './menu-helpers'
 
-# Public: Provides a registry for commands that you'd like to appear in the
+SpecificityCache = {}
+
+# Extended: Provides a registry for commands that you'd like to appear in the
 # context menu.
 #
 # An instance of this class is always available as the `atom.contextMenu`
@@ -13,119 +19,152 @@ fs = require 'fs-plus'
 module.exports =
 class ContextMenuManager
   constructor: ({@resourcePath, @devMode}) ->
-    @definitions = {}
-    @devModeDefinitions = {}
-    @activeElement = null
+    @definitions = {'.overlayer': []} # TODO: Remove once color picker package stops touching private data
+    @clear()
 
-    @devModeDefinitions['.workspace'] = [
-      label: 'Inspect Element'
-      command: 'application:inspect'
-      executeAtBuild: (e) ->
-        @commandOptions = x: e.pageX, y: e.pageY
-    ]
-
-    atom.keymaps.on 'bundled-keymaps-loaded', => @loadPlatformItems()
+    atom.keymaps.onDidLoadBundledKeymaps => @loadPlatformItems()
 
   loadPlatformItems: ->
     menusDirPath = path.join(@resourcePath, 'menus')
     platformMenuPath = fs.resolve(menusDirPath, process.platform, ['cson', 'json'])
     map = CSON.readFileSync(platformMenuPath)
-    atom.contextMenu.add(platformMenuPath, map['context-menu'])
+    atom.contextMenu.add(map['context-menu'])
 
-  # Public: Creates menu definitions from the object specified by the menu
-  # JSON API.
+  # Public: Add context menu items scoped by CSS selectors.
   #
-  # * `name` The path of the file that contains the menu definitions.
-  # * `object` The 'context-menu' object specified in the menu JSON API.
-  # * `options` An optional {Object} with the following keys:
-  #   * `devMode` Determines whether the entries should only be shown when
-  #     the window is in dev mode.
-  add: (name, object, {devMode}={}) ->
-    for selector, items of object
-      for label, commandOrSubmenu of items
+  # ## Examples
+  #
+  # To add a context menu, pass a selector matching the elements to which you
+  # want the menu to apply as the top level key, followed by a menu descriptor.
+  # The invocation below adds a global 'Help' context menu item and a 'History'
+  # submenu on the editor supporting undo/redo. This is just for example
+  # purposes and not the way the menu is actually configured in Atom by default.
+  #
+  # ```coffee
+  # atom.contextMenu.add {
+  #   '.workspace': [{label: 'Help', command: 'application:open-documentation'}]
+  #   '.editor':    [{
+  #     label: 'History',
+  #     submenu: [
+  #       {label: 'Undo': command:'core:undo'}
+  #       {label: 'Redo': command:'core:redo'}
+  #     ]
+  #   }]
+  # }
+  # ```
+  #
+  # ## Arguments
+  #
+  # * `itemsBySelector` An {Object} whose keys are CSS selectors and whose
+  #   values are {Array}s of item {Object}s containing the following keys:
+  #   * `label` (Optional) A {String} containing the menu item's label.
+  #   * `command` (Optional) A {String} containing the command to invoke on the
+  #     target of the right click that invoked the context menu.
+  #   * `submenu` (Optional) An {Array} of additional items.
+  #   * `type` (Optional) If you want to create a separator, provide an item
+  #      with `type: 'separator'` and no other keys.
+  #   * `created` (Optional) A {Function} that is called on the item each time a
+  #     context menu is created via a right click. You can assign properties to
+  #    `this` to dynamically compute the command, label, etc. This method is
+  #    actually called on a clone of the original item template to prevent state
+  #    from leaking across context menu deployments. Called with the following
+  #    argument:
+  #     * `event` The click event that deployed the context menu.
+  #   * `shouldDisplay` (Optional) A {Function} that is called to determine
+  #     whether to display this item on a given context menu deployment. Called
+  #     with the following argument:
+  #     * `event` The click event that deployed the context menu.
+  add: (itemsBySelector) ->
+    # Detect deprecated file path as first argument
+    unless typeof itemsBySelector is 'object'
+      Grim.deprecate("ContextMenuManage::add has changed to take a single object as its argument. Please consult the documentation.")
+      itemsBySelector = arguments[1]
+      devMode = arguments[2]?.devMode
+
+    # Detect deprecated format for items object
+    for key, value of itemsBySelector
+      unless _.isArray(value)
+        Grim.deprecate("The format for declaring context menu items has changed. Please consult the documentation.")
+        itemsBySelector = @convertLegacyItems(itemsBySelector, devMode)
+
+    addedItemSets = []
+
+    for selector, items of itemsBySelector
+      itemSet = new ContextMenuItemSet(selector, items)
+      addedItemSets.push(itemSet)
+      @itemSets.push(itemSet)
+
+    new Disposable =>
+      for itemSet in addedItemSets
+        @itemSets.splice(@itemSets.indexOf(itemSet), 1)
+
+  templateForElement: (target) ->
+    @templateForEvent({target})
+
+  templateForEvent: (event) ->
+    template = []
+    currentTarget = event.target
+
+    while currentTarget?
+      currentTargetItems = []
+      matchingItemSets =
+        @itemSets.filter (itemSet) -> currentTarget.webkitMatchesSelector(itemSet.selector)
+
+      for itemSet in matchingItemSets
+        for item in itemSet.items
+          continue if item.devMode and not @devMode
+          item = Object.create(item)
+          if typeof item.shouldDisplay is 'function'
+            continue unless item.shouldDisplay(event)
+          item.created?(event)
+          MenuHelpers.merge(currentTargetItems, MenuHelpers.cloneMenuItem(item), itemSet.specificity)
+
+      for item in currentTargetItems
+        MenuHelpers.merge(template, item, false)
+
+      currentTarget = currentTarget.parentElement
+
+    template
+
+  convertLegacyItems: (legacyItems, devMode) ->
+    itemsBySelector = {}
+
+    for selector, commandsByLabel of legacyItems
+      itemsBySelector[selector] = items = []
+
+      for label, commandOrSubmenu of commandsByLabel
         if typeof commandOrSubmenu is 'object'
-          submenu = []
-          for submenuLabel, command of commandOrSubmenu
-            submenu.push(@buildMenuItem(submenuLabel, command))
-          @addBySelector(selector, {label: label, submenu: submenu}, {devMode})
+          items.push({label, submenu: @convertLegacyItems(commandOrSubmenu, devMode), devMode})
+        else if commandOrSubmenu is '-'
+          items.push({type: 'separator'})
         else
-          menuItem = @buildMenuItem(label, commandOrSubmenu)
-          @addBySelector(selector, menuItem, {devMode})
+          items.push({label, command: commandOrSubmenu, devMode})
 
-    undefined
-
-  buildMenuItem: (label, command) ->
-    if command is '-'
-      {type: 'separator'}
-    else
-      {label, command}
-
-  # Registers a command to be displayed when the relevant item is right
-  # clicked.
-  #
-  # * `selector` The css selector for the active element which should include
-  #   the given command in its context menu.
-  # * `definition` The object containing keys which match the menu template API.
-  # * `options` An optional {Object} with the following keys:
-  #   * `devMode` Indicates whether this command should only appear while the
-  #     editor is in dev mode.
-  addBySelector: (selector, definition, {devMode}={}) ->
-    definitions = if devMode then @devModeDefinitions else @definitions
-    if not _.findWhere(definitions[selector], definition) or _.isEqual(definition, {type: 'separator'})
-      (definitions[selector] ?= []).push(definition)
-
-  # Returns definitions which match the element and devMode.
-  definitionsForElement: (element, {devMode}={}) ->
-    definitions = if devMode then @devModeDefinitions else @definitions
-    matchedDefinitions = []
-    for selector, items of definitions when element.webkitMatchesSelector(selector)
-      matchedDefinitions.push(_.clone(item)) for item in items
-
-    matchedDefinitions
-
-  # Used to generate the context menu for a specific element and it's
-  # parents.
-  #
-  # The menu items are sorted such that menu items that match closest to the
-  # active element are listed first. The further down the list you go, the higher
-  # up the ancestor hierarchy they match.
-  #
-  # * `element` The DOM element to generate the menu template for.
-  menuTemplateForMostSpecificElement: (element, {devMode}={}) ->
-    menuTemplate = @definitionsForElement(element, {devMode})
-    if element.parentElement
-      menuTemplate.concat(@menuTemplateForMostSpecificElement(element.parentElement, {devMode}))
-    else
-      menuTemplate
-
-  # Returns a menu template for both normal entries as well as
-  # development mode entries.
-  combinedMenuTemplateForElement: (element) ->
-    normalItems = @menuTemplateForMostSpecificElement(element)
-    devItems = if @devMode then @menuTemplateForMostSpecificElement(element, devMode: true) else []
-
-    menuTemplate = normalItems
-    menuTemplate.push({ type: 'separator' }) if normalItems.length > 0 and devItems.length > 0
-    menuTemplate.concat(devItems)
-
-  # Executes `executeAtBuild` if defined for each menu item with
-  # the provided event and then removes the `executeAtBuild` property from
-  # the menu item.
-  #
-  # This is useful for commands that need to provide data about the event
-  # to the command.
-  executeBuildHandlers: (event, menuTemplate) ->
-    for template in menuTemplate
-      template?.executeAtBuild?.call(template, event)
-      delete template.executeAtBuild
+    itemsBySelector
 
   # Public: Request a context menu to be displayed.
   #
   # * `event` A DOM event.
   showForEvent: (event) ->
     @activeElement = event.target
-    menuTemplate = @combinedMenuTemplateForElement(event.target)
+    menuTemplate = @templateForEvent(event)
+
     return unless menuTemplate?.length > 0
-    @executeBuildHandlers(event, menuTemplate)
     remote.getCurrentWindow().emit('context-menu', menuTemplate)
-    undefined
+    return
+
+  clear: ->
+    @activeElement = null
+    @itemSets = []
+    @add '.workspace': [{
+      label: 'Inspect Element'
+      command: 'application:inspect'
+      devMode: true
+      created: (event) ->
+        {pageX, pageY} = event
+        @commandDetail = {x: pageX, y: pageY}
+    }]
+
+class ContextMenuItemSet
+  constructor: (@selector, @items) ->
+    @specificity = (SpecificityCache[@selector] ?= specificity(@selector))

src/cursor.coffee

@@ -1,37 +1,14 @@
 {Point, Range} = require 'text-buffer'
 {Model} = require 'theorist'
+{Emitter} = require 'event-kit'
 _ = require 'underscore-plus'
+Grim = require 'grim'
 
 # Extended: The `Cursor` class represents the little blinking line identifying
 # where text can be inserted.
 #
-# Cursors belong to {Editor}s and have some metadata attached in the form
+# Cursors belong to {TextEditor}s and have some metadata attached in the form
 # of a {Marker}.
-#
-# ## Events
-#
-# ### moved
-#
-# Extended: Emit when a cursor has been moved. If there are multiple cursors,
-# it will be emit for each cursor.
-#
-# * `event` {Object}
-#   * `oldBufferPosition` {Point}
-#   * `oldScreenPosition` {Point}
-#   * `newBufferPosition` {Point}
-#   * `newScreenPosition` {Point}
-#   * `textChanged` {Boolean}
-#
-# ### destroyed
-#
-# Extended: Emit when the cursor is destroyed
-#
-# ### visibility-changed
-#
-# Extended: Emit when the Cursor is hidden or shown
-#
-# * `visible` {Boolean} true when cursor is visible
-#
 module.exports =
 class Cursor extends Model
   screenPosition: null
@@ -40,11 +17,13 @@ class Cursor extends Model
   visible: true
   needsAutoscroll: null
 
-  # Instantiated by an {Editor}
+  # Instantiated by an {TextEditor}
   constructor: ({@editor, @marker, id}) ->
+    @emitter = new Emitter
+
     @assignId(id)
     @updateVisibility()
-    @marker.on 'changed', (e) =>
+    @marker.onDidChange (e) =>
       @updateVisibility()
       {oldHeadScreenPosition, newHeadScreenPosition} = e
       {oldHeadBufferPosition, newHeadBufferPosition} = e
@@ -63,34 +42,79 @@ class Cursor extends Model
         newBufferPosition: newHeadBufferPosition
         newScreenPosition: newHeadScreenPosition
         textChanged: textChanged
+        cursor: this
 
       @emit 'moved', movedEvent
+      @emitter.emit 'did-change-position'
       @editor.cursorMoved(movedEvent)
-    @marker.on 'destroyed', =>
+    @marker.onDidDestroy =>
       @destroyed = true
       @editor.removeCursor(this)
       @emit 'destroyed'
+      @emitter.emit 'did-destroy'
+      @emitter.dispose()
     @needsAutoscroll = true
 
   destroy: ->
     @marker.destroy()
 
-  changePosition: (options, fn) ->
-    @clearSelection()
-    @needsAutoscroll = options.autoscroll ? @isLastCursor()
-    fn()
-    if @needsAutoscroll
-      @emit 'autoscrolled' # Support legacy editor
-      @autoscroll() if @needsAutoscroll and @editor.manageScrollPosition # Support react editor view
+  ###
+  Section: Event Subscription
+  ###
 
-  getPixelRect: ->
-    @editor.pixelRectForScreenRange(@getScreenRange())
+  # Public: Calls your `callback` when the cursor has been moved.
+  #
+  # * `callback` {Function}
+  #   * `event` {Object}
+  #     * `oldBufferPosition` {Point}
+  #     * `oldScreenPosition` {Point}
+  #     * `newBufferPosition` {Point}
+  #     * `newScreenPosition` {Point}
+  #     * `textChanged` {Boolean}
+  #     * `Cursor` {Cursor} that triggered the event
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+  onDidChangePosition: (callback) ->
+    @emitter.on 'did-change-position', callback
+
+  # Public: Calls your `callback` when the cursor is destroyed
+  #
+  # * `callback` {Function}
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+  onDidDestroy: (callback) ->
+    @emitter.on 'did-destroy', callback
+
+  # Public: Calls your `callback` when the cursor's visibility has changed
+  #
+  # * `callback` {Function}
+  #   * `visibility` {Boolean}
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+  onDidChangeVisibility: (callback) ->
+    @emitter.on 'did-change-visibility', callback
+
+  on: (eventName) ->
+    switch eventName
+      when 'moved'
+        Grim.deprecate("Use Cursor::onDidChangePosition instead")
+      when 'destroyed'
+        Grim.deprecate("Use Cursor::onDidDestroy instead")
+      when 'destroyed'
+        Grim.deprecate("Use Cursor::onDidDestroy instead")
+      else
+        Grim.deprecate("::on is no longer supported. Use the event subscription methods instead")
+    super
+
+  ###
+  Section: Managing Cursor Position
+  ###
 
   # Public: Moves a cursor to a given screen position.
   #
   # * `screenPosition` {Array} of two numbers: the screen row, and the screen column.
   # * `options` (optional) {Object} with the following keys:
-  #   * `autoscroll` A Boolean which, if `true`, scrolls the {Editor} to wherever
+  #   * `autoscroll` A Boolean which, if `true`, scrolls the {TextEditor} to wherever
   #     the cursor moves to.
   setScreenPosition: (screenPosition, options={}) ->
     @changePosition options, =>
@@ -100,15 +124,11 @@ class Cursor extends Model
   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` {Array} of two numbers: the buffer row, and the buffer column.
   # * `options` (optional) {Object} with the following keys:
-  #   * `autoscroll` A Boolean which, if `true`, scrolls the {Editor} to wherever
+  #   * `autoscroll` A Boolean which, if `true`, scrolls the {TextEditor} to wherever
   #     the cursor moves to.
   setBufferPosition: (bufferPosition, options={}) ->
     @changePosition options, =>
@@ -118,46 +138,38 @@ class Cursor extends Model
   getBufferPosition: ->
     @marker.getHeadBufferPosition()
 
-  autoscroll: (options) ->
-    @editor.scrollToScreenRange(@getScreenRange(), options)
+  # Public: Returns the cursor's current screen row.
+  getScreenRow: ->
+    @getScreenPosition().row
 
-  # Public: If the marker range is empty, the cursor is marked as being visible.
-  updateVisibility: ->
-    @setVisible(@marker.getBufferRange().isEmpty())
+  # Public: Returns the cursor's current screen column.
+  getScreenColumn: ->
+    @getScreenPosition().column
 
-  # Public: Sets whether the cursor is visible.
-  setVisible: (visible) ->
-    if @visible != visible
-      @visible = visible
-      @needsAutoscroll ?= true if @visible and @isLastCursor()
-      @emit 'visibility-changed', @visible
+  # Public: Retrieves the cursor's current buffer row.
+  getBufferRow: ->
+    @getBufferPosition().row
 
-  # Public: Returns the visibility of the cursor.
-  isVisible: -> @visible
+  # Public: Returns the cursor's current buffer column.
+  getBufferColumn: ->
+    @getBufferPosition().column
 
-  # Public: Get the RegExp used by the cursor to determine what a "word" is.
-  #
-  # * `options` (optional) {Object} with the following keys:
-  #   * `includeNonWordCharacters` A {Boolean} indicating whether to include
-  #     non-word characters in the regex. (default: true)
-  #
-  # Returns a {RegExp}.
-  wordRegExp: ({includeNonWordCharacters}={}) ->
-    includeNonWordCharacters ?= true
-    nonWordCharacters = atom.config.get('editor.nonWordCharacters')
-    segments = ["^[\t ]*$"]
-    segments.push("[^\\s#{_.escapeRegExp(nonWordCharacters)}]+")
-    if includeNonWordCharacters
-      segments.push("[#{_.escapeRegExp(nonWordCharacters)}]+")
-    new RegExp(segments.join("|"), "g")
+  # Public: Returns the cursor's current buffer row of text excluding its line
+  # ending.
+  getCurrentBufferLine: ->
+    @editor.lineTextForBufferRow(@getBufferRow())
 
-  # Public: Identifies if this cursor is the last in the {Editor}.
-  #
-  # "Last" is defined as the most recently added cursor.
-  #
-  # Returns a {Boolean}.
-  isLastCursor: ->
-    this == @editor.getLastCursor()
+  # Public: Returns whether the cursor is at the start of a line.
+  isAtBeginningOfLine: ->
+    @getBufferPosition().column == 0
+
+  # Public: Returns whether the cursor is on the line return character.
+  isAtEndOfLine: ->
+    @getBufferPosition().isEqual(@getCurrentLineBufferRange().end)
+
+  ###
+  Section: Cursor Position Details
+  ###
 
   # Public: Identifies if the cursor is surrounded by whitespace.
   #
@@ -195,34 +207,42 @@ class Cursor extends Model
     range = [[row, column], [row, Infinity]]
     @editor.getTextInBufferRange(range).search(@wordRegExp()) == 0
 
-  # Public: Prevents this cursor from causing scrolling.
-  clearAutoscroll: ->
-    @needsAutoscroll = null
+  # Public: Returns the indentation level of the current line.
+  getIndentLevel: ->
+    if @editor.getSoftTabs()
+      @getBufferColumn() / @editor.getTabLength()
+    else
+      @getBufferColumn()
 
-  # Public: Deselects the current selection.
-  clearSelection: ->
-    @selection?.clear()
+  # Public: Retrieves the grammar's token scopes for the line.
+  #
+  # Returns an {Array} of {String}s.
+  getScopes: ->
+    @editor.scopesForBufferPosition(@getBufferPosition())
 
-  # Public: Returns the cursor's current screen row.
-  getScreenRow: ->
-    @getScreenPosition().row
+  # Public: Returns true if this cursor has no non-whitespace characters before
+  # its current position.
+  hasPrecedingCharactersOnLine: ->
+    bufferPosition = @getBufferPosition()
+    line = @editor.lineTextForBufferRow(bufferPosition.row)
+    firstCharacterColumn = line.search(/\S/)
 
-  # Public: Returns the cursor's current screen column.
-  getScreenColumn: ->
-    @getScreenPosition().column
+    if firstCharacterColumn is -1
+      false
+    else
+      bufferPosition.column > firstCharacterColumn
 
-  # Public: Retrieves the cursor's current buffer row.
-  getBufferRow: ->
-    @getBufferPosition().row
+  # Public: Identifies if this cursor is the last in the {TextEditor}.
+  #
+  # "Last" is defined as the most recently added cursor.
+  #
+  # Returns a {Boolean}.
+  isLastCursor: ->
+    this == @editor.getLastCursor()
 
-  # Public: Returns the cursor's current buffer column.
-  getBufferColumn: ->
-    @getBufferPosition().column
-
-  # Public: Returns the cursor's current buffer row of text excluding its line
-  # ending.
-  getCurrentBufferLine: ->
-    @editor.lineTextForBufferRow(@getBufferRow())
+  ###
+  Section: Moving the Cursor
+  ###
 
   # Public: Moves the cursor up one screen row.
   #
@@ -383,6 +403,20 @@ class Cursor extends Model
 
     @setBufferPosition(endOfLeadingWhitespace) if endOfLeadingWhitespace.isGreaterThan(position)
 
+  # 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)
+
+  ###
+  Section: Local Positions and Ranges
+  ###
+
   # Public: Retrieves the buffer position of where the current word starts.
   #
   # * `options` (optional) An {Object} with the following keys:
@@ -519,15 +553,98 @@ class Cursor extends Model
   getCurrentLineBufferRange: (options) ->
     @editor.bufferRangeForBufferRow(@getBufferRow(), options)
 
-  # Public: Moves the cursor to the beginning of the next paragraph
-  moveToBeginningOfNextParagraph: ->
-    if position = @getBeginningOfNextParagraphBufferPosition()
-      @setBufferPosition(position)
+  # Public: Retrieves the range for the current paragraph.
+  #
+  # A paragraph is defined as a block of text surrounded by empty lines.
+  #
+  # Returns a {Range}.
+  getCurrentParagraphBufferRange: ->
+    @editor.languageMode.rowRangeForParagraphAtBufferRow(@getBufferRow())
 
-  # Public: Moves the cursor to the beginning of the previous paragraph
-  moveToBeginningOfPreviousParagraph: ->
-    if position = @getBeginningOfPreviousParagraphBufferPosition()
-      @setBufferPosition(position)
+  # Public: Returns the characters preceding the cursor in the current word.
+  getCurrentWordPrefix: ->
+    @editor.getTextInBufferRange([@getBeginningOfCurrentWordBufferPosition(), @getBufferPosition()])
+
+  ###
+  Section: Visibility
+  ###
+
+  # Public: If the marker range is empty, the cursor is marked as being visible.
+  updateVisibility: ->
+    @setVisible(@marker.getBufferRange().isEmpty())
+
+  # Public: Sets whether the cursor is visible.
+  setVisible: (visible) ->
+    if @visible != visible
+      @visible = visible
+      @needsAutoscroll ?= true if @visible and @isLastCursor()
+      @emit 'visibility-changed', @visible
+      @emitter.emit 'did-change-visibility', @visible
+
+  # Public: Returns the visibility of the cursor.
+  isVisible: -> @visible
+
+  ###
+  Section: Comparing to another cursor
+  ###
+
+  # Public: Compare this cursor's buffer position to another cursor's buffer position.
+  #
+  # See {Point::compare} for more details.
+  #
+  # * `otherCursor`{Cursor} to compare against
+  compare: (otherCursor) ->
+    @getBufferPosition().compare(otherCursor.getBufferPosition())
+
+  ###
+  Section: Utilities
+  ###
+
+  # Public: Prevents this cursor from causing scrolling.
+  clearAutoscroll: ->
+    @needsAutoscroll = null
+
+  # Public: Deselects the current selection.
+  clearSelection: ->
+    @selection?.clear()
+
+  # Public: Get the RegExp used by the cursor to determine what a "word" is.
+  #
+  # * `options` (optional) {Object} with the following keys:
+  #   * `includeNonWordCharacters` A {Boolean} indicating whether to include
+  #     non-word characters in the regex. (default: true)
+  #
+  # Returns a {RegExp}.
+  wordRegExp: ({includeNonWordCharacters}={}) ->
+    includeNonWordCharacters ?= true
+    nonWordCharacters = atom.config.get('editor.nonWordCharacters')
+    segments = ["^[\t ]*$"]
+    segments.push("[^\\s#{_.escapeRegExp(nonWordCharacters)}]+")
+    if includeNonWordCharacters
+      segments.push("[#{_.escapeRegExp(nonWordCharacters)}]+")
+    new RegExp(segments.join("|"), "g")
+
+  ###
+  Section: Private
+  ###
+
+  changePosition: (options, fn) ->
+    @clearSelection()
+    @needsAutoscroll = options.autoscroll ? @isLastCursor()
+    fn()
+    if @needsAutoscroll
+      @emit 'autoscrolled' # Support legacy editor
+      @autoscroll() if @needsAutoscroll and @editor.manageScrollPosition # Support react editor view
+
+  getPixelRect: ->
+    @editor.pixelRectForScreenRange(@getScreenRange())
+
+  getScreenRange: ->
+    {row, column} = @getScreenPosition()
+    new Range(new Point(row, column), new Point(row, column + 1))
+
+  autoscroll: (options) ->
+    @editor.scrollToScreenRange(@getScreenRange(), options)
 
   getBeginningOfNextParagraphBufferPosition: (editor) ->
     start = @getBufferPosition()
@@ -555,56 +672,3 @@ class Cursor extends Model
         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.
-  #
-  # Returns a {Range}.
-  getCurrentParagraphBufferRange: ->
-    @editor.languageMode.rowRangeForParagraphAtBufferRow(@getBufferRow())
-
-  # Public: Returns the characters preceding the cursor in the current word.
-  getCurrentWordPrefix: ->
-    @editor.getTextInBufferRange([@getBeginningOfCurrentWordBufferPosition(), @getBufferPosition()])
-
-  # Public: Returns whether the cursor is at the start of a line.
-  isAtBeginningOfLine: ->
-    @getBufferPosition().column == 0
-
-  # Public: Returns the indentation level of the current line.
-  getIndentLevel: ->
-    if @editor.getSoftTabs()
-      @getBufferColumn() / @editor.getTabLength()
-    else
-      @getBufferColumn()
-
-  # Public: Returns whether the cursor is on the line return character.
-  isAtEndOfLine: ->
-    @getBufferPosition().isEqual(@getCurrentLineBufferRange().end)
-
-  # Public: Retrieves the grammar's token scopes for the line.
-  #
-  # Returns an {Array} of {String}s.
-  getScopes: ->
-    @editor.scopesForBufferPosition(@getBufferPosition())
-
-  # Public: Returns true if this cursor has no non-whitespace characters before
-  # its current position.
-  hasPrecedingCharactersOnLine: ->
-    bufferPosition = @getBufferPosition()
-    line = @editor.lineTextForBufferRow(bufferPosition.row)
-    firstCharacterColumn = line.search(/\S/)
-
-    if firstCharacterColumn is -1
-      false
-    else
-      bufferPosition.column > firstCharacterColumn
-
-  # Public: Compare this cursor's buffer position to another cursor's buffer position.
-  #
-  # See {Point::compare} for more details.
-  #
-  # * `otherCursor`{Cursor} to compare against
-  compare: (otherCursor) ->
-    @getBufferPosition().compare(otherCursor.getBufferPosition())

src/decoration.coffee

@@ -1,5 +1,7 @@
 _ = require 'underscore-plus'
-{Subscriber, Emitter} = require 'emissary'
+EmitterMixin = require('emissary').Emitter
+{Emitter} = require 'event-kit'
+Grim = require 'grim'
 
 idCounter = 0
 nextId = -> idCounter++
@@ -10,7 +12,7 @@ nextId = -> idCounter++
 # around marked ranges of text.
 #
 # {Decoration} objects are not meant to be created directly, but created with
-# {Editor::decorateMarker}. eg.
+# {TextEditor::decorateMarker}. eg.
 #
 # ```coffee
 # range = editor.getSelectedBufferRange() # any range you like
@@ -26,44 +28,76 @@ nextId = -> idCounter++
 #
 # You should only use {Decoration::destroy} when you still need or do not own
 # the marker.
-#
-# ## Events
-#
-# ### updated
-#
-# Extended: When the {Decoration} is updated via {Decoration::update}.
-#
-# * `event` {Object}
-#   * `oldParams` {Object} the old parameters the decoration used to have
-#   * `newParams` {Object} the new parameters the decoration now has
-#
-# ### destroyed
-#
-# Extended: When the {Decoration} is destroyed
-#
 module.exports =
 class Decoration
-  Emitter.includeInto(this)
+  EmitterMixin.includeInto(this)
 
-  # Extended: Check if the `decorationParams.type` matches `type`
+  # Private: Check if the `decorationProperties.type` matches `type`
   #
-  # * `decorationParams` {Object} eg. `{type: 'gutter', class: 'my-new-class'}`
+  # * `decorationProperties` {Object} eg. `{type: 'gutter', class: 'my-new-class'}`
   # * `type` {String} type like `'gutter'`, `'line'`, etc. `type` can also
   #   be an {Array} of {String}s, where it will return true if the decoration's
   #   type matches any in the array.
   #
   # Returns {Boolean}
-  @isType: (decorationParams, type) ->
-    if _.isArray(decorationParams.type)
-      type in decorationParams.type
+  @isType: (decorationProperties, type) ->
+    if _.isArray(decorationProperties.type)
+      type in decorationProperties.type
     else
-      type is decorationParams.type
+      type is decorationProperties.type
 
-  constructor: (@marker, @displayBuffer, @params) ->
+  ###
+  Section: Construction and Destruction
+  ###
+
+  constructor: (@marker, @displayBuffer, @properties) ->
+    @emitter = new Emitter
     @id = nextId()
-    @params.id = @id
+    @properties.id = @id
     @flashQueue = null
-    @isDestroyed = false
+    @destroyed = false
+
+    @markerDestroyDisposable = @marker.onDidDestroy => @destroy()
+
+  # Essential: Destroy this marker.
+  #
+  # If you own the marker, you should use {Marker::destroy} which will destroy
+  # this decoration.
+  destroy: ->
+    return if @destroyed
+    @markerDestroyDisposable.dispose()
+    @markerDestroyDisposable = null
+    @destroyed = true
+    @emit 'destroyed'
+    @emitter.emit 'did-destroy'
+    @emitter.dispose()
+
+  ###
+  Section: Event Subscription
+  ###
+
+  # Essential: When the {Decoration} is updated via {Decoration::update}.
+  #
+  # * `callback` {Function}
+  #   * `event` {Object}
+  #     * `oldProperties` {Object} the old parameters the decoration used to have
+  #     * `newProperties` {Object} the new parameters the decoration now has
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+  onDidChangeProperties: (callback) ->
+    @emitter.on 'did-change-properties', callback
+
+  # Essential: Invoke the given callback when the {Decoration} is destroyed
+  #
+  # * `callback` {Function}
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+  onDidDestroy: (callback) ->
+    @emitter.on 'did-destroy', callback
+
+  ###
+  Section: Decoration Details
+  ###
 
   # Essential: An id unique across all {Decoration} objects
   getId: -> @id
@@ -71,9 +105,6 @@ class Decoration
   # Essential: Returns the marker associated with this {Decoration}
   getMarker: -> @marker
 
-  # Essential: Returns the {Decoration}'s params.
-  getParams: -> @params
-
   # Public: Check if this decoration is of type `type`
   #
   # * `type` {String} type like `'gutter'`, `'line'`, etc. `type` can also
@@ -82,9 +113,20 @@ class Decoration
   #
   # Returns {Boolean}
   isType: (type) ->
-    Decoration.isType(@params, type)
+    Decoration.isType(@properties, type)
 
-  # Essential: Update the marker with new params. Allows you to change the decoration's class.
+  ###
+  Section: Properties
+  ###
+
+  # Essential: Returns the {Decoration}'s properties.
+  getProperties: ->
+    @properties
+  getParams: ->
+    Grim.deprecate 'Use Decoration::getProperties instead'
+    @getProperties()
+
+  # Essential: Update the marker with new Properties. Allows you to change the decoration's class.
   #
   # ## Examples
   #
@@ -92,37 +134,51 @@ class Decoration
   # decoration.update({type: 'gutter', class: 'my-new-class'})
   # ```
   #
-  # * `newParams` {Object} eg. `{type: 'gutter', class: 'my-new-class'}`
-  update: (newParams) ->
-    return if @isDestroyed
-    oldParams = @params
-    @params = newParams
-    @params.id = @id
-    @displayBuffer.decorationUpdated(this)
-    @emit 'updated', {oldParams, newParams}
+  # * `newProperties` {Object} eg. `{type: 'gutter', class: 'my-new-class'}`
+  setProperties: (newProperties) ->
+    return if @destroyed
+    oldProperties = @properties
+    @properties = newProperties
+    @properties.id = @id
+    @emit 'updated', {oldParams: oldProperties, newParams: newProperties}
+    @emitter.emit 'did-change-properties', {oldProperties, newProperties}
+  update: (newProperties) ->
+    Grim.deprecate 'Use Decoration::setProperties instead'
+    @setProperties(newProperties)
 
-  # Essential: Destroy this marker.
-  #
-  # If you own the marker, you should use {Marker::destroy} which will destroy
-  # this decoration.
-  destroy: ->
-    return if @isDestroyed
-    @isDestroyed = true
-    @displayBuffer.removeDecoration(this)
-    @emit 'destroyed'
+  ###
+  Section: Private methods
+  ###
 
   matchesPattern: (decorationPattern) ->
     return false unless decorationPattern?
     for key, value of decorationPattern
-      return false if @params[key] != value
+      return false if @properties[key] != value
     true
 
+  onDidFlash: (callback) ->
+    @emitter.on 'did-flash', callback
+
   flash: (klass, duration=500) ->
     flashObject = {class: klass, duration}
     @flashQueue ?= []
     @flashQueue.push(flashObject)
     @emit 'flash'
+    @emitter.emit 'did-flash'
 
   consumeNextFlash: ->
     return @flashQueue.shift() if @flashQueue?.length > 0
     null
+
+  on: (eventName) ->
+    switch eventName
+      when 'updated'
+        Grim.deprecate 'Use Decoration::onDidChangeProperties instead'
+      when 'destroyed'
+        Grim.deprecate 'Use Decoration::onDidDestroy instead'
+      when 'flash'
+        Grim.deprecate 'Use Decoration::onDidFlash instead'
+      else
+        Grim.deprecate 'Decoration::on is deprecated. Use event subscription methods instead.'
+
+    EmitterMixin::on.apply(this, arguments)

src/deserializer-manager.coffee

@@ -1,4 +1,7 @@
-# Public: Manages the deserializers used for serialized state
+{Disposable} = require 'event-kit'
+Grim = require 'grim'
+
+# Extended: Manages the deserializers used for serialized state
 #
 # An instance of this class is always available as the `atom.deserializers`
 # global.
@@ -24,14 +27,17 @@ class DeserializerManager
 
   # Public: Register the given class(es) as deserializers.
   #
-  # * `classes` One or more classes to register.
-  add: (classes...) ->
-    @deserializers[klass.name] = klass for klass in classes
+  # * `deserializers` One or more deserializers to register. A deserializer can
+  #   be any object with a `.name` property and a `.deserialize()` method. A
+  #   common approach is to register a *constructor* as the deserializer for its
+  #   instances by adding a `.deserialize()` class method.
+  add: (deserializers...) ->
+    @deserializers[deserializer.name] = deserializer for deserializer in deserializers
+    new Disposable =>
+      delete @deserializers[deserializer.name] for deserializer in deserializers
 
-  # Public: Remove the given class(es) as deserializers.
-  #
-  # * `classes` One or more classes to remove.
   remove: (classes...) ->
+    Grim.deprecate("Call .dispose() on the Disposable return from ::add instead")
     delete @deserializers[name] for {name} in classes
 
   # Public: Deserialize the state and params.

src/display-buffer-marker.coffee

@@ -1,231 +0,0 @@
-{Range} = require 'text-buffer'
-_ = require 'underscore-plus'
-{Emitter, Subscriber} = require 'emissary'
-
-module.exports =
-class DisplayBufferMarker
-  Emitter.includeInto(this)
-  Subscriber.includeInto(this)
-
-  bufferMarkerSubscription: null
-  oldHeadBufferPosition: null
-  oldHeadScreenPosition: null
-  oldTailBufferPosition: null
-  oldTailScreenPosition: null
-  wasValid: true
-
-  constructor: ({@bufferMarker, @displayBuffer}) ->
-    @id = @bufferMarker.id
-    @oldHeadBufferPosition = @getHeadBufferPosition()
-    @oldHeadScreenPosition = @getHeadScreenPosition()
-    @oldTailBufferPosition = @getTailBufferPosition()
-    @oldTailScreenPosition = @getTailScreenPosition()
-    @wasValid = @isValid()
-
-    @subscribe @bufferMarker.onDidDestroy => @destroyed()
-    @subscribe @bufferMarker.onDidChange (event) => @notifyObservers(event)
-
-  copy: (attributes) ->
-    @displayBuffer.getMarker(@bufferMarker.copy(attributes).id)
-
-  # Gets the screen range of the display marker.
-  #
-  # Returns a {Range}.
-  getScreenRange: ->
-    @displayBuffer.screenRangeForBufferRange(@getBufferRange(), wrapAtSoftNewlines: true)
-
-  # Modifies the screen range of the display marker.
-  #
-  # screenRange - The new {Range} to use
-  # options - A hash of options matching those found in {Marker::setRange}
-  setScreenRange: (screenRange, options) ->
-    @setBufferRange(@displayBuffer.bufferRangeForScreenRange(screenRange), options)
-
-  # Gets the buffer range of the display marker.
-  #
-  # Returns a {Range}.
-  getBufferRange: ->
-    @bufferMarker.getRange()
-
-  # Modifies the buffer range of the display marker.
-  #
-  # screenRange - The new {Range} to use
-  # options - A hash of options matching those found in {Marker::setRange}
-  setBufferRange: (bufferRange, options) ->
-    @bufferMarker.setRange(bufferRange, options)
-
-  getPixelRange: ->
-    @displayBuffer.pixelRangeForScreenRange(@getScreenRange(), false)
-
-  # Retrieves the screen position of the marker's head.
-  #
-  # Returns a {Point}.
-  getHeadScreenPosition: ->
-    @displayBuffer.screenPositionForBufferPosition(@getHeadBufferPosition(), wrapAtSoftNewlines: true)
-
-  # Sets the screen position of the marker's head.
-  #
-  # screenRange - The new {Point} to use
-  # options - A hash of options matching those found in {DisplayBuffer::bufferPositionForScreenPosition}
-  setHeadScreenPosition: (screenPosition, options) ->
-    screenPosition = @displayBuffer.clipScreenPosition(screenPosition, options)
-    @setHeadBufferPosition(@displayBuffer.bufferPositionForScreenPosition(screenPosition, options))
-
-  # Retrieves the buffer position of the marker's head.
-  #
-  # Returns a {Point}.
-  getHeadBufferPosition: ->
-    @bufferMarker.getHeadPosition()
-
-  # Sets the buffer position of the marker's head.
-  #
-  # screenRange - The new {Point} to use
-  # options - A hash of options matching those found in {DisplayBuffer::bufferPositionForScreenPosition}
-  setHeadBufferPosition: (bufferPosition) ->
-    @bufferMarker.setHeadPosition(bufferPosition)
-
-  # Retrieves the screen position of the marker's tail.
-  #
-  # Returns a {Point}.
-  getTailScreenPosition: ->
-    @displayBuffer.screenPositionForBufferPosition(@getTailBufferPosition(), wrapAtSoftNewlines: true)
-
-  # Sets the screen position of the marker's tail.
-  #
-  # screenRange - The new {Point} to use
-  # options - A hash of options matching those found in {DisplayBuffer::bufferPositionForScreenPosition}
-  setTailScreenPosition: (screenPosition, options) ->
-    screenPosition = @displayBuffer.clipScreenPosition(screenPosition, options)
-    @setTailBufferPosition(@displayBuffer.bufferPositionForScreenPosition(screenPosition, options))
-
-  # Retrieves the buffer position of the marker's tail.
-  #
-  # Returns a {Point}.
-  getTailBufferPosition: ->
-    @bufferMarker.getTailPosition()
-
-  # Sets the buffer position of the marker's tail.
-  #
-  # screenRange - The new {Point} to use
-  # options - A hash of options matching those found in {DisplayBuffer::bufferPositionForScreenPosition}
-  setTailBufferPosition: (bufferPosition) ->
-    @bufferMarker.setTailPosition(bufferPosition)
-
-  # Retrieves the screen position of the marker's start. This will always be
-  # less than or equal to the result of {DisplayBufferMarker::getEndScreenPosition}.
-  #
-  # Returns a {Point}.
-  getStartScreenPosition: ->
-    @displayBuffer.screenPositionForBufferPosition(@getStartBufferPosition(), wrapAtSoftNewlines: true)
-
-  # Retrieves the buffer position of the marker's start. This will always be
-  # less than or equal to the result of {DisplayBufferMarker::getEndBufferPosition}.
-  #
-  # Returns a {Point}.
-  getStartBufferPosition: ->
-    @bufferMarker.getStartPosition()
-
-  # Retrieves the screen position of the marker's end. This will always be
-  # greater than or equal to the result of {DisplayBufferMarker::getStartScreenPosition}.
-  #
-  # Returns a {Point}.
-  getEndScreenPosition: ->
-    @displayBuffer.screenPositionForBufferPosition(@getEndBufferPosition(), wrapAtSoftNewlines: true)
-
-  # Retrieves the buffer position of the marker's end. This will always be
-  # greater than or equal to the result of {DisplayBufferMarker::getStartBufferPosition}.
-  #
-  # Returns a {Point}.
-  getEndBufferPosition: ->
-    @bufferMarker.getEndPosition()
-
-  # Sets the marker's tail to the same position as the marker's head.
-  #
-  # This only works if there isn't already a tail position.
-  #
-  # Returns a {Point} representing the new tail position.
-  plantTail: ->
-    @bufferMarker.plantTail()
-
-  # Removes the tail from the marker.
-  clearTail: ->
-    @bufferMarker.clearTail()
-
-  hasTail: ->
-    @bufferMarker.hasTail()
-
-  # Returns whether the head precedes the tail in the buffer
-  isReversed: ->
-    @bufferMarker.isReversed()
-
-  # Returns a {Boolean} indicating whether the marker is valid. Markers can be
-  # invalidated when a region surrounding them in the buffer is changed.
-  isValid: ->
-    @bufferMarker.isValid()
-
-  # Returns a {Boolean} indicating whether the marker has been destroyed. A marker
-  # can be invalid without being destroyed, in which case undoing the invalidating
-  # operation would restore the marker. Once a marker is destroyed by calling
-  # {Marker::destroy}, no undo/redo operation can ever bring it back.
-  isDestroyed: ->
-    @bufferMarker.isDestroyed()
-
-  getAttributes: ->
-    @bufferMarker.getProperties()
-
-  setAttributes: (attributes) ->
-    @bufferMarker.setProperties(attributes)
-
-  matchesAttributes: (attributes) ->
-    attributes = @displayBuffer.translateToBufferMarkerParams(attributes)
-    @bufferMarker.matchesAttributes(attributes)
-
-  # Destroys the marker
-  destroy: ->
-    @bufferMarker.destroy()
-    @unsubscribe()
-
-  isEqual: (other) ->
-    return false unless other instanceof @constructor
-    @bufferMarker.isEqual(other.bufferMarker)
-
-  compare: (other) ->
-    @bufferMarker.compare(other.bufferMarker)
-
-  # Returns a {String} representation of the marker
-  inspect: ->
-    "DisplayBufferMarker(id: #{@id}, bufferRange: #{@getBufferRange()})"
-
-  destroyed: ->
-    delete @displayBuffer.markers[@id]
-    @emit 'destroyed'
-
-  notifyObservers: ({textChanged}) ->
-    textChanged ?= false
-
-    newHeadBufferPosition = @getHeadBufferPosition()
-    newHeadScreenPosition = @getHeadScreenPosition()
-    newTailBufferPosition = @getTailBufferPosition()
-    newTailScreenPosition = @getTailScreenPosition()
-    isValid = @isValid()
-
-    return if _.isEqual(isValid, @wasValid) and
-      _.isEqual(newHeadBufferPosition, @oldHeadBufferPosition) and
-      _.isEqual(newHeadScreenPosition, @oldHeadScreenPosition) and
-      _.isEqual(newTailBufferPosition, @oldTailBufferPosition) and
-      _.isEqual(newTailScreenPosition, @oldTailScreenPosition)
-
-    @emit 'changed', {
-      @oldHeadScreenPosition, newHeadScreenPosition,
-      @oldTailScreenPosition, newTailScreenPosition,
-      @oldHeadBufferPosition, newHeadBufferPosition,
-      @oldTailBufferPosition, newTailBufferPosition,
-      textChanged,
-      isValid
-    }
-
-    @oldHeadBufferPosition = newHeadBufferPosition
-    @oldHeadScreenPosition = newHeadScreenPosition
-    @oldTailBufferPosition = newTailBufferPosition
-    @oldTailScreenPosition = newTailScreenPosition
-    @wasValid = isValid