Invoke handlers on detached DOM nodes

This ensures that all listeners slot into the correct location in a
single dispatch, regardless of whether they are added with
Node::addEventListener or via CommandRegistry::listen/capture. This
allows selector-based listeners to integrate into the rest of events
in a global way.

CONTRIBUTING.md

@@ -12,19 +12,21 @@ propose changes to this document in a pull request.
 ## Submitting Issues
 
 * Check the [debugging guide](https://atom.io/docs/latest/debugging) for tips
-  on debugging. You might be able to find the cause of the problem and fix 
+  on debugging. You might be able to find the cause of the problem and fix
   things yourself.
 * Include the version of Atom you are using and the OS.
 * Include screenshots and animated GIFs whenever possible; they are immensely
   helpful.
 * Include the behavior you expected and other places you've seen that behavior
   such as Emacs, vi, Xcode, etc.
-* Check the dev tools (`alt-cmd-i`) for errors to include. If the dev tools 
+* Check the dev tools (`alt-cmd-i`) for errors to include. If the dev tools
   are open _before_ the error is triggered, a full stack trace for the error
   will be logged. If you can reproduce the error, use this approach to get the
   full stack trace and include it in the issue.
 * On Mac, check Console.app for stack traces to include if reporting a crash.
 * Perform a cursory search to see if a similar issue has already been submitted.
+* Please setup a [profile picture](https://help.github.com/articles/how-do-i-set-up-my-profile-picture)
+  to make yourself recognizable and so we can all get to know each other better.
 
 ### Package Repositories
 
@@ -62,6 +64,8 @@ For more information on how to work with Atom's official packages, see
     * Use `path.join()` to concatenate filenames.
     * Use `os.tmpdir()` rather than `/tmp` when you need to reference the
       temporary directory.
+* Using a plain `return` when returning explicitly at the end of a function.
+    * Not `return null`, `return undefined`, `null`, or `undefined`
 
 ## Git Commit Messages
 
@@ -82,6 +86,7 @@ For more information on how to work with Atom's official packages, see
     * :green_heart: `:green_heart:` when fixing the CI build
     * :white_check_mark: `:white_check_mark:` when adding tests
     * :lock: `:lock:` when dealing with security
+    * :arrow_up: `:arrow_up:` when upgrading dependencies
 
 ## CoffeeScript Styleguide
 

Dockerfile

@@ -0,0 +1,22 @@
+# VERSION:        0.1
+# DESCRIPTION:    Image to build Atom and create a .rpm file
+
+# Base docker image
+FROM fedora:20
+
+# Install dependencies
+RUN yum install -y \
+    make \
+    gcc \
+    gcc-c++ \
+    glibc-devel \
+    git-core \
+    libgnome-keyring-devel \
+    rpmdevtools
+
+# Install node
+RUN curl -sL https://rpm.nodesource.com/setup | bash -
+RUN yum install -y nodejs
+
+ADD . /atom
+WORKDIR /atom

README.md

@@ -4,6 +4,9 @@ Atom is a hackable text editor for the 21st century, built on [atom-shell](http:
 
 Visit [atom.io](https://atom.io) to learn more.
 
+Visit [issue #3684](https://github.com/atom/atom/issues/3684) to learn more
+about the Atom 1.0 roadmap.
+
 ## Installing
 
 ### Mac OS X
@@ -36,6 +39,17 @@ Currently only a 64-bit version is available.
 The Linux version does not currently automatically update so you will need to
 repeat these steps to upgrade to future releases.
 
+### Red Hat Linux (Fedora, CentOS, Red Hat)
+
+Currently only a 64-bit version is available.
+
+1. Download `atom.x86_64.rpm` from the [Atom releases page](https://github.com/atom/atom/releases/latest).
+2. Run `sudo yum localinstall atom.x86_64.rpm` 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

@@ -6,6 +6,6 @@
     "url": "https://github.com/atom/atom.git"
   },
   "dependencies": {
-    "atom-package-manager": "0.97.0"
+    "atom-package-manager": "0.109.0"
   }
 }

atom.sh

@@ -71,9 +71,7 @@ elif [ $OS == 'Linux' ]; then
   ATOM_PATH="$USR_DIRECTORY/share/atom/atom"
   DOT_ATOM_DIR="$HOME/.atom"
 
-  if [ ! -d "$DOT_ATOM_DIR" ]; then
-    mkdir -p "$DOT_ATOM_DIR"
-  fi
+  mkdir -p "$DOT_ATOM_DIR"
 
   : ${TMPDIR:=/tmp}
 

build/Gruntfile.coffee

@@ -120,7 +120,10 @@ module.exports = (grunt) ->
 
   for child in fs.readdirSync('node_modules') when child isnt '.bin'
     directory = path.join('node_modules', child)
-    {engines, theme} = grunt.file.readJSON(path.join(directory, 'package.json'))
+    metadataPath = path.join(directory, 'package.json')
+    continue unless grunt.file.isFile(metadataPath)
+
+    {engines, theme} = grunt.file.readJSON(metadataPath)
     if engines?.atom?
       coffeeConfig.glob_to_multiple.src.push("#{directory}/**/*.coffee")
       lessConfig.glob_to_multiple.src.push("#{directory}/**/*.less")

build/debian/Dockerfile

@@ -0,0 +1,50 @@
+# VERSION:        0.1
+# DESCRIPTION:    Create the atom editor in a container 
+# AUTHOR:         Jessica Frazelle <jessie@docker.com>
+# COMMENTS:
+#   This file describes how to build the atom editor 
+#   in a container with all dependencies installed.
+#   Tested on Debian Jessie.
+# USAGE:
+#   # Download atom Dockerfile
+#   wget http://raw.githubusercontent.com/atom/atom/master/Dockerfile
+#
+#   # Build atom image
+#   docker build -t atom .
+#
+#   docker run -v /tmp/.X11-unix:/tmp/.X11-unix \
+#     -e DISPLAY=unix$DISPLAY atom
+#
+
+DOCKER-VERSION 1.3
+
+# Base docker image
+FROM debian:jessie
+MAINTAINER Jessica Frazelle <jessie@docker.com>
+
+# Install dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    ca-certificates \
+    curl \
+    git \
+    libasound2 \
+    libgconf-2-4 \
+    libgnome-keyring-dev \
+    libgtk2.0-0 \
+    libnss3 \
+    libxtst6 \
+    --no-install-recommends
+
+# install node
+RUN curl -sL https://deb.nodesource.com/setup | bash -
+RUN apt-get install -y nodejs
+
+# clone atom
+RUN git clone https://github.com/atom/atom /src
+WORKDIR /src
+RUN git fetch && git checkout $(git describe --tags `git rev-list --tags --max-count=1`)
+RUN script/build && script/grunt install
+
+# Autorun atom
+CMD /usr/local/bin/atom --foreground --log-file /var/log/atom.log && tail -f /var/log/atom.log

build/package.json

@@ -7,7 +7,7 @@
   },
   "dependencies": {
     "async": "~0.2.9",
-    "donna": "1.0.1",
+    "donna": "1.0.6",
     "formidable": "~1.0.14",
     "fs-plus": "2.x",
     "github-releases": "~0.2.0",
@@ -18,7 +18,7 @@
     "grunt-contrib-csslint": "~0.1.2",
     "grunt-contrib-less": "~0.8.0",
     "grunt-cson": "0.10.0",
-    "grunt-download-atom-shell": "~0.8.0",
+    "grunt-download-atom-shell": "~0.10.0",
     "grunt-lesslint": "0.13.0",
     "grunt-markdown": "~0.4.0",
     "grunt-peg": "~1.1.0",

build/tasks/build-task.coffee

@@ -153,7 +153,7 @@ module.exports = (grunt) ->
       fs.writeFileSync path.join(appDir, 'node_modules', 'symbols-view', 'vendor', 'ctags-win32.exe.ignore'), ''
       fs.writeFileSync path.join(shellAppDir, 'atom.exe.gui'), ''
 
-    dependencies = ['compile', "generate-license:save"]
+    dependencies = ['compile', 'generate-license:save', 'generate-module-cache', 'compile-packages-slug']
     dependencies.push('copy-info-plist') if process.platform is 'darwin'
     dependencies.push('set-exe-icon') if process.platform is 'win32'
     grunt.task.run(dependencies...)

build/tasks/compile-packages-slug-task.coffee

@@ -0,0 +1,54 @@
+path = require 'path'
+CSON = require 'season'
+fs = require 'fs-plus'
+_ = require 'underscore-plus'
+
+module.exports = (grunt) ->
+  {spawn, rm} = require('./task-helpers')(grunt)
+
+  grunt.registerTask 'compile-packages-slug', 'Add bundled package metadata information to the main package.json file', ->
+    appDir = fs.realpathSync(grunt.config.get('atom.appDir'))
+
+    modulesDirectory = path.join(appDir, 'node_modules')
+    packages = {}
+
+    for moduleDirectory in fs.listSync(modulesDirectory)
+      continue if path.basename(moduleDirectory) is '.bin'
+
+      metadataPath = path.join(moduleDirectory, 'package.json')
+      metadata = grunt.file.readJSON(metadataPath)
+      continue unless metadata?.engines?.atom?
+
+      moduleCache = metadata._atomModuleCache ? {}
+
+      rm metadataPath
+      _.remove(moduleCache.extensions?['.json'] ? [], 'package.json')
+
+      for property in ['_from', '_id', 'dist', 'readme', 'readmeFilename']
+        delete metadata[property]
+
+      pack = {metadata, keymaps: {}, menus: {}}
+
+      if metadata.main
+        mainPath = require.resolve(path.resolve(moduleDirectory, metadata.main))
+        pack.main = path.relative(appDir, mainPath)
+
+      for keymapPath in fs.listSync(path.join(moduleDirectory, 'keymaps'), ['.cson', '.json'])
+        relativePath = path.relative(appDir, keymapPath)
+        pack.keymaps[relativePath] = CSON.readFileSync(keymapPath)
+        rm keymapPath
+
+      for menuPath in fs.listSync(path.join(moduleDirectory, 'menus'), ['.cson', '.json'])
+        relativePath = path.relative(appDir, menuPath)
+        pack.menus[relativePath] = CSON.readFileSync(menuPath)
+        rm menuPath
+
+      packages[metadata.name] = pack
+
+      for extension, paths of moduleCache.extensions
+        delete moduleCache.extensions[extension] if paths.length is 0
+
+    metadata = grunt.file.readJSON(path.join(appDir, 'package.json'))
+    metadata._atomPackages = packages
+
+    grunt.file.write(path.join(appDir, 'package.json'), JSON.stringify(metadata))

build/tasks/create-installer.coffee

@@ -12,6 +12,8 @@ module.exports = (grunt) ->
 
     buildDir = grunt.config.get('atom.buildDir')
     atomDir = path.join(buildDir, 'Atom')
+    releasesDir = path.join(buildDir, 'Releases')
+    atomGitHubToken = process.env.ATOM_ACCESS_TOKEN
 
     packageInfo = grunt.file.readJSON(path.join(atomDir, 'resources', 'app', 'package.json'))
     inputTemplate = grunt.file.read(path.join('build', 'windows', 'atom.nuspec.erb'))
@@ -22,20 +24,23 @@ module.exports = (grunt) ->
     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]
+    # We use the previous releases to build deltas for the current release,
+    # sync down the existing releases directory by rolling through GitHub releases
+    cmd = 'build/windows/SyncGitHubReleases.exe'
+    args = ['-r', releasesDir, '-u', 'https://github.com/atom/atom', '-t', atomGitHubToken]
 
     spawn {cmd, args}, (error, result, code) ->
-      return done(error) if error?
+      if error?
+        grunt.log.error "ATOM_ACCESS_TOKEN environment variable not set or invalid, can't download old releases; continuing anyways"
 
-      pkgs = pkg for pkg in fs.readdirSync(buildDir) when path.extname(pkg) is '.nupkg'
+      cmd = 'build/windows/nuget.exe'
+      args = ['pack', targetNuspecPath, '-BasePath', atomDir, '-OutputDirectory', buildDir]
 
-      releasesDir = path.join(buildDir, 'Releases')
+      spawn {cmd, args}, (error, result, code) ->
+        return done(error) if error?
 
-      # NB: Gonna clear Releases for now, in the future we need to pull down
-      # the existing version
-      rm(releasesDir)
+        pkgs = pkg for pkg in fs.readdirSync(buildDir) when path.extname(pkg) is '.nupkg'
 
-      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)
+        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/generate-module-cache-task.coffee

@@ -0,0 +1,39 @@
+path = require 'path'
+fs = require 'fs-plus'
+ModuleCache = require '../../src/module-cache'
+
+module.exports = (grunt) ->
+  grunt.registerTask 'generate-module-cache', 'Generate a module cache for all core modules and packages', ->
+    appDir = grunt.config.get('atom.appDir')
+
+    {packageDependencies} = grunt.file.readJSON('package.json')
+
+    for packageName, version of packageDependencies
+      ModuleCache.create(path.join(appDir, 'node_modules', packageName))
+
+    ModuleCache.create(appDir)
+
+    metadata = grunt.file.readJSON(path.join(appDir, 'package.json'))
+
+    metadata._atomModuleCache.folders.forEach (folder) ->
+      if '' in folder.paths
+        folder.paths = [
+          ''
+          'exports'
+          'spec'
+          'src'
+          'src/browser'
+          'static'
+          'vendor'
+        ]
+
+    # Reactionary does not have an explicit react dependency
+    metadata._atomModuleCache.folders.push
+      paths: [
+        'node_modules/reactionary-atom-fork/lib'
+      ]
+      dependencies: {
+        'react-atom-fork': metadata.dependencies['react-atom-fork']
+      }
+
+    grunt.file.write(path.join(appDir, 'package.json'), JSON.stringify(metadata))

build/tasks/install-task.coffee

@@ -32,7 +32,7 @@ module.exports = (grunt) ->
       binDir = path.join(installDir, 'bin')
       shareDir = path.join(installDir, 'share', 'atom')
 
-      iconName = path.join(shareDir,'resources','app','resources','atom.png')
+      iconName = path.join(shareDir,'resources', 'app', 'resources', 'atom.png')
 
       mkdir binDir
       cp 'atom.sh', path.join(binDir, 'atom')
@@ -40,11 +40,11 @@ module.exports = (grunt) ->
       mkdir path.dirname(shareDir)
       cp shellAppDir, shareDir
 
-      # Create Atom.desktop if installation not in temporary folder
+      # Create atom.desktop if installation not in temporary folder
       tmpDir = if process.env.TMPDIR? then process.env.TMPDIR else '/tmp'
       if installDir.indexOf(tmpDir) isnt 0
-        desktopFile = path.join('resources', 'linux', 'Atom.desktop.in')
-        desktopInstallFile = path.join(installDir, 'share', 'applications', 'Atom.desktop')
+        desktopFile = path.join('resources', 'linux', 'atom.desktop.in')
+        desktopInstallFile = path.join(installDir, 'share', 'applications', 'atom.desktop')
 
         {description} = grunt.file.readJSON('package.json')
         iconName = path.join(shareDir, 'resources', 'app', 'resources', 'atom.png')

build/tasks/mkdeb-task.coffee

@@ -39,7 +39,7 @@ module.exports = (grunt) ->
     getInstalledSize buildDir, (error, installedSize) ->
       data = {name, version, description, section, arch, maintainer, installDir, iconName, installedSize}
       controlFilePath = fillTemplate(path.join('resources', 'linux', 'debian', 'control'), data)
-      desktopFilePath = fillTemplate(path.join('resources', 'linux', 'Atom.desktop'), data)
+      desktopFilePath = fillTemplate(path.join('resources', 'linux', 'atom.desktop'), data)
       icon = path.join('resources', 'atom.png')
 
       cmd = path.join('script', 'mkdeb')

build/tasks/mkrpm-task.coffee

@@ -0,0 +1,48 @@
+fs = require 'fs'
+path = require 'path'
+_ = require 'underscore-plus'
+
+module.exports = (grunt) ->
+  {spawn, rm, mkdir} = require('./task-helpers')(grunt)
+
+  fillTemplate = (filePath, data) ->
+    template = _.template(String(fs.readFileSync("#{filePath}.in")))
+    filled = template(data)
+
+    outputPath = path.join(grunt.config.get('atom.buildDir'), path.basename(filePath))
+    grunt.file.write(outputPath, filled)
+    outputPath
+
+  grunt.registerTask 'mkrpm', 'Create rpm package', ->
+    done = @async()
+
+    if process.arch is 'ia32'
+      arch = 'i386'
+    else if process.arch is 'x64'
+      arch = 'amd64'
+    else
+      return done("Unsupported arch #{process.arch}")
+
+    {name, version, description} = grunt.file.readJSON('package.json')
+    buildDir = grunt.config.get('atom.buildDir')
+
+    rpmDir = path.join(buildDir, 'rpm')
+    rm rpmDir
+    mkdir rpmDir
+
+    installDir = grunt.config.get('atom.installDir')
+    shareDir = path.join(installDir, 'share', 'atom')
+    iconName = path.join(shareDir, 'resources', 'app', 'resources', 'atom.png')
+
+    data = {name, version, description, installDir, iconName}
+    specFilePath = fillTemplate(path.join('resources', 'linux', 'redhat', 'atom.spec'), data)
+    desktopFilePath = fillTemplate(path.join('resources', 'linux', 'atom.desktop'), data)
+
+    cmd = path.join('script', 'mkrpm')
+    args = [specFilePath, desktopFilePath, buildDir]
+    spawn {cmd, args}, (error) ->
+      if error?
+        done(error)
+      else
+        grunt.log.ok "Created rpm package in #{rpmDir}"
+        done()

build/tasks/publish-build-task.coffee

@@ -20,9 +20,9 @@ module.exports = (gruntObject) ->
   {cp} = require('./task-helpers')(grunt)
 
   grunt.registerTask 'publish-build', 'Publish the built app', ->
-    return if process.env.JANKY_SHA1 and process.env.JANKY_BRANCH isnt 'master'
-    tasks = ['upload-assets']
-    tasks.unshift('build-docs', 'prepare-docs') if process.platform is 'darwin'
+    tasks = []
+    tasks.push('build-docs', 'prepare-docs') if process.platform is 'darwin'
+    tasks.push('upload-assets') if process.env.JANKY_SHA1 and process.env.JANKY_BRANCH is 'master'
     grunt.task.run(tasks)
 
   grunt.registerTask 'prepare-docs', 'Move api.json to atom-api.json', ->
@@ -31,7 +31,16 @@ module.exports = (gruntObject) ->
     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()
+    doneCallback = @async()
+    startTime = Date.now()
+    done = (args...) ->
+      elapsedTime = Math.round((Date.now() - startTime) / 100) / 10
+      grunt.log.ok("Upload time: #{elapsedTime}s")
+      doneCallback(args...)
+
+    unless token
+      return done(new Error('ATOM_ACCESS_TOKEN environment variable not set'))
+
     buildDir = grunt.config.get('atom.buildDir')
     assets = getAssets()
 
@@ -63,9 +72,21 @@ getAssets = ->
       else
         arch = 'amd64'
       {version} = grunt.file.readJSON('package.json')
+
+      # Check for a Debian build
       sourcePath = "#{buildDir}/atom-#{version}-#{arch}.deb"
       assetName = "atom-#{arch}.deb"
 
+      # Check for a Fedora build
+      unless fs.isFileSync(sourcePath)
+        rpmName = fs.readdirSync("#{buildDir}/rpm")[0]
+        sourcePath = "#{buildDir}/rpm/#{rpmName}"
+        if process.arch is 'ia32'
+          arch = 'i386'
+        else
+          arch = 'x86_64'
+        assetName = "atom.#{arch}.rpm"
+
       {cp} = require('./task-helpers')(grunt)
       cp sourcePath, path.join(buildDir, assetName)
 

build/tasks/set-version-task.coffee

@@ -32,7 +32,7 @@ module.exports = (grunt) ->
       packageJsonPath = path.join(appDir, 'package.json')
       packageJson = require(packageJsonPath)
       packageJson.version = version
-      packageJsonString = JSON.stringify(packageJson, null, 2)
+      packageJsonString = JSON.stringify(packageJson)
       fs.writeFileSync(packageJsonPath, packageJsonString)
 
       if process.platform is 'darwin'

build/tasks/spec-task.coffee

@@ -4,6 +4,8 @@ path = require 'path'
 _ = require 'underscore-plus'
 async = require 'async'
 
+concurrency = 2
+
 module.exports = (grunt) ->
   {isAtomPackage, spawn} = require('./task-helpers')(grunt)
 
@@ -61,7 +63,7 @@ module.exports = (grunt) ->
       continue unless isAtomPackage(packagePath)
       packageSpecQueue.push(packagePath)
 
-    packageSpecQueue.concurrency = 1
+    packageSpecQueue.concurrency = concurrency - 1
     packageSpecQueue.drain = -> callback(null, failedPackages)
 
   runCoreSpecs = (callback) ->
@@ -84,7 +86,7 @@ module.exports = (grunt) ->
         fs.unlinkSync('ci.log')
       else
         # TODO: Restore concurrency on Windows
-        packageSpecQueue.concurrency = 2
+        packageSpecQueue.concurrency = concurrency
 
       callback(null, error)
 
@@ -102,7 +104,7 @@ module.exports = (grunt) ->
     method [runCoreSpecs, runPackageSpecs], (error, results) ->
       [coreSpecFailed, failedPackages] = results
       elapsedTime = Math.round((Date.now() - startTime) / 100) / 10
-      grunt.verbose.writeln("Total spec time: #{elapsedTime}s")
+      grunt.log.ok("Total spec time: #{elapsedTime}s using #{concurrency} cores")
       failures = failedPackages
       failures.push "atom core" if coreSpecFailed
 

docs/advanced/keymaps.md

@@ -6,25 +6,25 @@ Keymap files are encoded as JSON or CSON files containing nested hashes. They
 work much like stylesheets, but instead of applying style properties to elements
 matching the selector, they specify the meaning of keystrokes on elements
 matching the selector. Here is an example of some bindings that apply when
-keystrokes pass through elements with the class `.editor`:
+keystrokes pass through `atom-text-editor` elements:
 
 ```coffee
-'.editor':
+'atom-text-editor':
   'cmd-delete': 'editor:delete-to-beginning-of-line'
   'alt-backspace': 'editor:delete-to-beginning-of-word'
   'ctrl-A': 'editor:select-to-first-character-of-line'
   'ctrl-shift-e': 'editor:select-to-end-of-line'
   'cmd-left': 'editor:move-to-first-character-of-line'
 
-'.editor:not(.mini)'
+'atom-text-editor:not(.mini)'
   'cmd-alt-[': 'editor:fold-current-row'
   'cmd-alt-]': 'editor:unfold-current-row'
 ```
 
 Beneath the first selector are several bindings, mapping specific *keystroke
-patterns* to *commands*. When an element with the `.editor` class is focused and
+patterns* to *commands*. When an element with the `atom-text-editor` class is focused and
 `cmd-delete` is pressed, an custom DOM event called
-`editor:delete-to-beginning-of-line` is emitted on the `.editor` element.
+`editor:delete-to-beginning-of-line` is emitted on the `atom-text-editor` element.
 
 The second selector group also targets editors, but only if they don't have the
 `.mini` class. In this example, the commands for code folding don't really make
@@ -91,7 +91,7 @@ the current keystroke sequence and continue searching from its parent. If you
 want to remove a binding from a keymap you don't control, such as keymaps in
 Atom core or in packages, use the `unset!` directive.
 
-For example, the following code removes the keybinding for `a` in the Tree View, 
+For example, the following code removes the keybinding for `a` in the Tree View,
 which is normally used to trigger the `tree-view:add-file` command:
 
 ```coffee

docs/advanced/scopes-and-scope-descriptors.md

@@ -0,0 +1,87 @@
+# Scoped Settings, Scopes and Scope Descriptors
+
+Atom supports language-specific settings. You can soft wrap only Markdown files, or set the tab length to 4 in Python files.
+
+Language-specific settings are a subset of something more general we call "scoped settings". Scoped settings allow targeting down to a specific syntax token type. For example, you could conceivably set a setting to target only Ruby comments, only code inside Markdown files, or even only JavaScript function names.
+
+## Scope names in syntax tokens
+
+Each token in the editor has a collection of scope names. For example, the aformentioned JavaScript function name might have the scope names `function` and `name`. An open paren might have the scope names `punctuation`, `parameters`, `begin`.
+
+Scope names work just like CSS classes. In fact, in the editor, scope names are attached to a token's DOM node as CSS classes.
+
+Take this piece of JavaScript:
+
+```js
+function functionName() {
+  console.log('Log it out');
+}
+```
+
+In the dev tools, the first line's markup looks like this.
+
+![screen shot 2014-10-14 at 11 21 35 am](https://cloud.githubusercontent.com/assets/69169/4634321/2b1b923c-53cf-11e4-9268-6e57bcb14ec8.png)
+
+All the class names on the spans are scope names. Any scope name can be used to target a setting's value.
+
+## Scope Selectors
+
+Scope selectors allow you to target specific tokens just like a CSS selector targets specific nodes in the DOM. Some examples:
+
+```coffee
+'.source.js' # selects all javascript tokens
+'.source.js .function.name' # selects all javascript function names
+'.function.name' # selects all function names in any language
+```
+
+[Config::set][config-set] accepts a `scopeSelector`. If you'd like to set a setting for JavaScript function names, you can give it the js function name `scopeSelector`:
+
+```coffee
+atom.config.set('.source.js .function.name', 'my-package.my-setting', 'special value')
+```
+
+## Scope Descriptors
+
+A scope descriptor is an [Object][scope-descriptor] that wraps an `Array` of
+`String`s. The Array describes a path from the root of the syntax tree to a
+token including _all_ scope names for the entire path.
+
+In our JavaScript example above, a scope descriptor for the function name token would be:
+
+```coffee
+['source.js', 'meta.function.js', 'entity.name.function.js']
+```
+
+[Config::get][config-get] accepts a `scopeDescriptor`. You can get the value for your setting scoped to JavaScript function names via:
+
+```coffee
+scopeDescriptor = ['source.js', 'meta.function.js', 'entity.name.function.js']
+value = atom.config.get(scopeDescriptor, 'my-package.my-setting')
+```
+
+But, you do not need to generate scope descriptors by hand. There are a couple methods available to get the scope descriptor from the editor:
+
+* [Editor::getRootScopeDescriptor][editor-getRootScopeDescriptor] to get the language's descriptor. eg. `[".source.js"]`
+* [Editor::scopeDescriptorForBufferPosition][editor-scopeDescriptorForBufferPosition] to get the descriptor at a specific position in the buffer.
+* [Cursor::getScopeDescriptor][cursor-getScopeDescriptor] to get a cursor's descriptor based on position. eg. if the cursor were in the name of the method in our example it would return `["source.js", "meta.function.js", "entity.name.function.js"]`
+
+Let's revisit our example using these methods:
+
+```coffee
+editor = atom.workspace.getActiveTextEditor()
+cursor = editor.getLastCursor()
+valueAtCursor = atom.config.get(cursor.getScopeDescriptor(), 'my-package.my-setting')
+valueForLanguage = atom.config.get(editor.getRootScopeDescriptor(), 'my-package.my-setting')
+```
+
+
+[config]:https://atom.io/docs/api/latest/Config
+[config-get]:https://atom.io/docs/api/latest/Config#instance-get
+[config-set]:https://atom.io/docs/api/latest/Config#instance-set
+[config-observe]:https://atom.io/docs/api/latest/Config#instance-observe
+
+[editor-getRootScopeDescriptor]:https://atom.io/docs/api/latest/TextEditor#instance-getRootScopeDescriptor
+[editor-scopeDescriptorForBufferPosition]:https://atom.io/docs/api/latest/TextEditor#instance-scopeDescriptorForBufferPosition
+
+[cursor-getScopeDescriptor]:https://atom.io/docs/api/latest/Cursor#instance-getScopeDescriptor
+[scope-descriptor]:https://atom.io/docs/api/latest/ScopeDescriptor

docs/advanced/view-system.md

@@ -11,7 +11,7 @@ have methods that are view-specific. For example, you could call both general
 and view-specific on the global `atom.workspaceView` instance:
 
 ```coffeescript
-atom.workspaceView.find('.editor.active') # standard jQuery method
+atom.workspaceView.find('atom-text-editor.active') # standard jQuery method
 atom.workspaceView.getActiveEditor()      # view-specific method
 ```
 
@@ -20,7 +20,7 @@ If you retrieve a jQuery wrapper for an element associated with a view, use the
 
 ```coffeescript
 # this is a plain jQuery object; you can't call view-specific methods
-editorElement = atom.workspaceView.find('.editor.active')
+editorElement = atom.workspaceView.find('atom-text-editor.active')
 
 # get the view object by calling `.view()` to call view-specific methods
 editorView = editorElement.view()

docs/build-instructions/linux.md

@@ -16,17 +16,17 @@ Ubuntu LTS 12.04 64-bit is the recommended platform.
 
 ### Ubuntu / Debian
 
-* `sudo apt-get install build-essential git libgnome-keyring-dev`
+* `sudo apt-get install build-essential git libgnome-keyring-dev fakeroot`
 * Instructions for  [Node.js](https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager#ubuntu-mint-elementary-os).
 
-### Fedora
+### Fedora / CentOS / RHEL
 
-* `sudo yum --assumeyes install make gcc gcc-c++ glibc-devel git-core libgnome-keyring-devel`
+* `sudo yum --assumeyes install make gcc gcc-c++ glibc-devel git-core libgnome-keyring-devel rpmdevtools`
 * Instructions for [Node.js](https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager#fedora).
 
 ### Arch
 
-* `sudo pacman -S base-devel git nodejs libgnome-keyring`
+* `sudo pacman -S base-devel git nodejs libgnome-keyring python2`
 * `export PYTHON=/usr/bin/python2` before building Atom.
 
 ## Instructions
@@ -61,13 +61,19 @@ If you have problems with permissions don't forget to prefix with `sudo`
   sudo script/grunt install
   ```
 
-5. *Optionally*, you may generate a `.deb` package at `$TMPDIR/atom-build`:
+  To use the newly installed Atom, quit and restart all running Atom instances.
+
+5. *Optionally*, you may generate distributable packages of Atom at `$TMPDIR/atom-build`. Currenty, `.deb` and `.rpm` package types are supported. To create a `.deb` package run:
 
   ```sh
   script/grunt mkdeb
   ```
 
-Use the newly installed Atom by fully quitting Atom and then reopening.
+  To create an `.rpm` package run
+
+  ```sh
+  script/grunt mkrpm
+  ```
 
 ## Advanced Options
 
@@ -85,7 +91,7 @@ script/build --build-dir /build/atom/here
 
 ## Troubleshooting
 
-### Exception: "TypeError: Unable to watch path"
+### TypeError: Unable to watch path
 
 If you get following error with a big traceback right after Atom starts:
 
@@ -115,6 +121,22 @@ 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.
 
+### AttributeError: 'module' object has no attribute 'script_main'
+
+If you get following error with a big traceback while building Atom:
+
+  ```
+  sys.exit(gyp.script_main()) AttributeError: 'module' object has no attribute 'script_main' gyp ERR!
+  ```
+
+you need to uninstall the system version of gyp.
+
+On Fedora you would do the following:
+
+  ```sh
+  sudo yum remove gyp
+  ```
+
 #### You can also use Alternatives
 
 On some variants (mostly Debian based distros) it's preferable for you to use

docs/build-instructions/windows.md

@@ -36,7 +36,7 @@
 ## Why do I have to use GitHub for Windows?
 
 You don't. You can use your existing Git! GitHub for Windows's Git Shell is just
-easier to set up. 
+easier to set up.
 
 If you _prefer_ using your existing Git installation, make sure git's cmd directory is in your PATH env variable (e.g. `C:\Program Files (x86)\Git\cmd`) before you open your powershell or command window.
 Note that you may have to open your command window as administrator. For powershell that doesn't seem to always be the case, though.
@@ -67,11 +67,11 @@ If none of this works, do install Github for Windows and use its Git shell. Make
     * https://code.google.com/p/gyp/issues/detail?id=393
 
 * `script/build` stops at installing runas with 'Failed at the runas@0.5.4 install script.'
-  
+
   See the next item.
 
 * `error MSB8020: The build tools for Visual Studio 2010 (Platform Toolset = 'v100') cannot be found.`
-   
+
   * If you're building atom with Visual Studio 2013 try executing the following
     command in your Git shell and then re-run `script/build`:
 

docs/contributing-to-packages.md

@@ -9,22 +9,27 @@ in the proper package's repository.
 
 ### Cloning
 
-The first step is creating your own clone. You can of course do this manually
-with git, or you can use the `apm develop` command to create a clone based on
-the package's `repository` field in the `package.json`.
+The first step is creating your own clone.
 
-For example, if you want to make changes to the `tree-view` package, run the
-following command:
+For example, if you want to make changes to the `tree-view` package, fork the repo on your github account, then clone it:
 
 ```
-> apm develop tree-view
-Cloning https://github.com/atom/tree-view ✓
+> git clone git@github.com:your-username/tree-view.git
+```
+
+Next install all the dependencies:
+
+```
+> cd tree-view
+> apm install
 Installing modules ✓
-~/.atom/dev/packages/tree-view -> ~/github/tree-view
 ```
 
-This clones the `tree-view` repository to `~/github`. If you prefer a different
-path, specify it via the `ATOM_REPOS_HOME` environment variable.
+Now you can link it to development mode so when you run an Atom window with `atom --dev`, you will use your fork instead of the built in package:
+
+```
+> apm link -d
+```
 
 ### Running in Development Mode
 
@@ -46,7 +51,4 @@ from the package directory to create and remove dev-mode symlinks.
 
 ### Installing Dependencies
 
-Finally, you need to install the cloned package's dependencies by running
-`apm install` within the package directory. This step is also performed
-automatically the first time you run `apm develop`, but you'll want to keep
-dependencies up to date by running `apm update` after pulling upstream changes.
+You'll want to keep dependencies up to date by running `apm update` after pulling any upstream changes.

docs/creating-a-package.md

@@ -207,37 +207,44 @@ specific parts of the interface, like adding a file in the tree-view:
 
 ```coffeescript
 'context-menu':
-  '.tree-view':
-    'Add file': 'tree-view:add-file'
-  '.workspace':
-    'Inspect Element': 'core:inspect'
+  '.tree-view': [
+    {label: 'Add file', command: 'tree-view:add-file'}
+  ]
+  'atom-workspace': [
+    {label: 'Inspect Element', command: 'core:inspect'}
+  ]
 ```
 
 To add your own item to the application menu simply create a top level
 `context-menu` key in any menu configuration file in _menus_. This can be a
 JSON or [CSON] file.
 
-Context menus are created by determining which element was selected and
-then adding all of the menu items whose selectors match that element (in
-the order which they were loaded). The process is then repeated for the
-elements until reaching the top of the DOM tree.
+Context menus are created by determining which element was selected and then
+adding all of the menu items whose selectors match that element (in the order
+which they were loaded). The process is then repeated for the elements until
+reaching the top of the DOM tree.
 
 In the example above, the `Add file` item will only appear when the focused item
 or one of its parents has the `tree-view` class applied to it.
 
 You can also add separators and submenus to your context menus. To add a
-submenu, pass in another object instead of a command. To add a separator, use
-`-` for the command of the item.
+submenu, provide a `submenu` key instead of a command. To add a separator, add
+an item with a single `type: 'separator'` key/value pair.
 
 ```coffeescript
 'context-menu':
-  '.workspace':
-    'Inspect Element': 'core:inspect'
-    'Separator': '-'
-    'Text':
-      'Select All': 'core:select-all'
-      'Another Separator': '-'
-      'Deleted Selected Text': 'core:delete'
+  'atom-workspace': [
+    {
+      label: 'Text'
+      submenu: [
+        {label: 'Inspect Element', command: 'core:inspect'}
+        {type: 'separator'}
+        {label: 'Selector All', command: 'core:select-all'}
+        {type: 'separator'}
+        {label: 'Deleted Selected Text', command: 'core:delete'}
+      ]
+    }
+  ]
 ```
 
 ## Snippets

docs/customizing-atom.md

@@ -60,10 +60,10 @@ with events in specific contexts. Here's a small example, excerpted from Atom's
 built-in keymaps:
 
 ```coffee
-'.editor':
+'atom-text-editor':
   'enter': 'editor:newline'
 
-'.mini.editor input':
+'atom-text-editor.mini input':
   'enter': 'core:confirm'
 ```
 
@@ -169,7 +169,7 @@ For example, to change the color of the cursor, you could add the following
 rule to your _~/.atom/styles.less_ file:
 
 ```less
-.editor.is-focused .cursor {
+atom-text-editor.is-focused .cursor {
   border-color: pink;
 }
 ```

docs/index.md

@@ -9,6 +9,7 @@
 * [Converting a TextMate Bundle](converting-a-text-mate-bundle.md)
 * [Converting a TextMate Theme](converting-a-text-mate-theme.md)
 * [Contributing](contributing.md)
+* [Contributing to Core Packages](contributing-to-packages.md)
 * [Debugging](debugging.md)
 
 ### Advanced Topics
@@ -18,3 +19,4 @@
 * [Keymaps](advanced/keymaps.md)
 * [Serialization](advanced/serialization.md)
 * [View System](advanced/view-system.md)
+* [Scopes and Scope Descriptors](advanced/scopes-and-scope-descriptors.md)

docs/your-first-package.md

@@ -91,13 +91,13 @@ _keymaps/ascii-art.cson_ and add a key binding linking `ctrl-alt-a` to the
 you don't need it anymore. When finished, the file will look like this:
 
 ```coffeescript
-'.editor':
+'atom-text-editor':
   'cmd-alt-a': 'ascii-art:convert'
 ```
 
-Notice `.editor` on the first line. Just like CSS, keymap selectors *scope* key
+Notice `atom-text-editor` on the first line. Just like CSS, keymap selectors *scope* key
 bindings so they only apply to specific elements. In this case, our binding is
-only active for elements matching the `.editor` selector. If the Tree View has
+only active for elements matching the `atom-text-editor` selector. If the Tree View has
 focus, pressing `cmd-alt-a` won't trigger the `ascii-art:convert` command. But
 if the editor has focus, the `ascii-art:convert` method *will* be triggered.
 More information on key bindings can be found in the

dot-atom/keymap.cson

@@ -9,7 +9,7 @@
 #
 # Here's an example taken from Atom's built-in keymap:
 #
-# '.editor':
+# 'atom-text-editor':
 #   'enter': 'editor:newline'
 #
 # '.workspace':
@@ -19,3 +19,7 @@
 # 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
+#
+# This file uses CoffeeScript Object Notation (CSON).
+# If you are unfamiliar with CSON, you can read more about it here:
+# https://github.com/bevry/cson#what-is-cson

dot-atom/snippets.cson

@@ -13,3 +13,6 @@
 #     'prefix': 'log'
 #     'body': 'console.log $1'
 #
+# This file uses CoffeeScript Object Notation (CSON).
+# If you are unfamiliar with CSON, you can read more about it here:
+# https://github.com/bevry/cson#what-is-cson

dot-atom/styles.less

@@ -12,10 +12,10 @@
 
 }
 
-.editor {
+atom-text-editor {
 
 }
 
-.editor .cursor {
+atom-text-editor .cursor {
 
 }

keymaps/base.cson

@@ -1,11 +1,11 @@
-'.editor':
+'atom-text-editor':
   # Platform Bindings
   'home': 'editor:move-to-first-character-of-line'
   'end': 'editor:move-to-end-of-screen-line'
   'shift-home': 'editor:select-to-first-character-of-line'
   'shift-end': 'editor:select-to-end-of-line'
 
-'.editor:not(.mini)':
+'atom-text-editor:not(.mini)':
   # Atom Specific
   'ctrl-C': 'editor:copy-path'
 
@@ -18,7 +18,7 @@
 '.tool-panel.panel-left, .tool-panel.panel-right':
   'escape': 'tool-panel:unfocus'
 
-'.editor !important, .editor.mini !important':
+'atom-text-editor !important, atom-text-editor.mini !important':
   'escape': 'editor:consolidate-selections'
 
 # allow standard input fields to work correctly

keymaps/darwin.cson

@@ -100,7 +100,7 @@
   'cmd-8': 'pane:show-item-8'
   'cmd-9': 'pane:show-item-9'
 
-'.editor':
+'atom-text-editor':
   # Platform Bindings
   'alt-left': 'editor:move-to-beginning-of-word'
   'alt-right': 'editor:move-to-end-of-word'
@@ -134,7 +134,7 @@
   'cmd-l': 'editor:select-line'
   'ctrl-t': 'editor:transpose'
 
-'.workspace .editor:not(.mini)':
+'atom-workspace atom-text-editor:not(.mini)':
   # Atom specific
   'alt-cmd-z': 'editor:checkout-head-revision'
   'cmd-<': 'editor:scroll-to-cursor'

keymaps/emacs.cson

@@ -1,4 +1,4 @@
-'.editor':
+'atom-text-editor':
   'alt-f': 'editor:move-to-end-of-word'
   'alt-F': 'editor:select-to-end-of-word'
   'alt-b': 'editor:move-to-beginning-of-word'

keymaps/linux.cson

@@ -79,7 +79,7 @@
   'alt-8': 'pane:show-item-8'
   'alt-9': 'pane:show-item-9'
 
-'.workspace .editor':
+'atom-workspace atom-text-editor':
   # Platform Bindings
   'ctrl-left': 'editor:move-to-beginning-of-word'
   'ctrl-right': 'editor:move-to-end-of-word'
@@ -99,7 +99,7 @@
   'ctrl-k ctrl-l': 'editor:lower-case'
   'ctrl-l': 'editor:select-line'
 
-'.workspace .editor:not(.mini)':
+'atom-workspace atom-text-editor:not(.mini)':
   # Atom specific
   'alt-ctrl-z': 'editor:checkout-head-revision'
   'ctrl-<': 'editor:scroll-to-cursor'

keymaps/win32.cson

@@ -74,7 +74,7 @@
   'ctrl-k ctrl-left':  'window:focus-pane-on-left'
   'ctrl-k ctrl-right': 'window:focus-pane-on-right'
 
-'.workspace .editor':
+'atom-workspace atom-text-editor':
   # Platform Bindings
   'ctrl-left': 'editor:move-to-beginning-of-word'
   'ctrl-right': 'editor:move-to-end-of-word'
@@ -94,7 +94,7 @@
   'ctrl-k ctrl-l': 'editor:lower-case'
   'ctrl-l': 'editor:select-line'
 
-'.workspace .editor:not(.mini)':
+'atom-workspace atom-text-editor:not(.mini)':
   # Atom specific
   'alt-ctrl-z': 'editor:checkout-head-revision'
   'ctrl-<': 'editor:scroll-to-cursor'

menus/darwin.cson

@@ -196,18 +196,27 @@
 ]
 
 'context-menu':
-  '.overlayer':
-    'Undo': 'core:undo'
-    'Redo': 'core:redo'
-    'separator1': '-'
-    'Cut': 'core:cut'
-    'Copy': 'core:copy'
-    'Paste': 'core:paste'
-    'Delete': 'core:delete'
-    'Select All': 'core:select-all'
-    'separator2': '-'
-    'Split Up': 'pane:split-up'
-    'Split Down': 'pane:split-down'
-    'Split Left': 'pane:split-left'
-    'Split Right': 'pane:split-right'
-    'separator3': '-'
+  '.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'}
+  ]
+  'atom-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

@@ -153,18 +153,27 @@
 ]
 
 'context-menu':
-  '.overlayer':
-    'Undo': 'core:undo'
-    'Redo': 'core:redo'
-    'separator1': '-'
-    'Cut': 'core:cut'
-    'Copy': 'core:copy'
-    'Paste': 'core:paste'
-    'Delete': 'core:delete'
-    'Select All': 'core:select-all'
-    'separator2': '-'
-    'Split Up': 'pane:split-up'
-    'Split Down': 'pane:split-down'
-    'Split Left': 'pane:split-left'
-    'Split Right': 'pane:split-right'
-    'separator3': '-'
+  '.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'}
+  ]
+  'atom-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

@@ -171,18 +171,27 @@
 ]
 
 'context-menu':
-  '.overlayer':
-    'Undo': 'core:undo'
-    'Redo': 'core:redo'
-    'separator1': '-'
-    'Cut': 'core:cut'
-    'Copy': 'core:copy'
-    'Paste': 'core:paste'
-    'Delete': 'core:delete'
-    'Select All': 'core:select-all'
-    'separator2': '-'
-    'Split Up': 'pane:split-up'
-    'Split Down': 'pane:split-down'
-    'Split Left': 'pane:split-left'
-    'Split Right': 'pane:split-right'
-    'separator3': '-'
+  '.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'}
+  ]
+  'atom-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.133.0",
+  "version": "0.141.0",
   "description": "A hackable text editor for the 21st Century.",
   "main": "./src/browser/main.js",
   "repository": {
@@ -17,10 +17,10 @@
       "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
     }
   ],
-  "atomShellVersion": "0.16.2",
+  "atomShellVersion": "0.18.2",
   "dependencies": {
     "async": "0.2.6",
-    "atom-keymap": "^2.2.0",
+    "atom-keymap": "^2.2.1",
     "bootstrap": "git+https://github.com/atom/bootstrap.git#6af81906189f1747fd6c93479e3d998ebe041372",
     "clear-cut": "0.4.0",
     "coffee-script": "1.7.0",
@@ -29,14 +29,15 @@
     "emissary": "^1.3.1",
     "event-kit": "0.7.2",
     "first-mate": "^2.2.0",
-    "fs-plus": "^2.2.6",
+    "fs-plus": "^2.3.1",
     "fstream": "0.1.24",
     "fuzzaldrin": "^2.1",
-    "git-utils": "^2.1.4",
+    "git-utils": "^2.1.5",
     "grim": "0.12.0",
     "guid": "0.0.10",
+    "jasmine-json": "~0.0",
     "jasmine-tagged": "^1.1.2",
-    "less-cache": "0.15.0",
+    "less-cache": "0.17.0",
     "mixto": "^1",
     "mkdirp": "0.3.5",
     "nslog": "^1.0.1",
@@ -49,23 +50,23 @@
     "react-atom-fork": "^0.11.1",
     "reactionary-atom-fork": "^1.0.0",
     "runas": "1.0.1",
-    "scandal": "1.0.2",
-    "scoped-property-store": "^0.9.0",
+    "scandal": "1.0.3",
+    "scoped-property-store": "^0.15.0",
     "scrollbar-style": "^1.0.2",
     "season": "^1.0.2",
-    "semver": "1.1.4",
+    "semver": "2.2.1",
     "serializable": "^1",
-    "space-pen": "3.4.7",
+    "space-pen": "3.8.0",
     "temp": "0.7.0",
-    "text-buffer": "^3.2.6",
+    "text-buffer": "^3.3.0",
     "theorist": "^1.0.2",
-    "underscore-plus": "^1.5.1",
+    "underscore-plus": "^1.6.1",
     "vm-compatibility-layer": "0.1.0"
   },
   "packageDependencies": {
-    "atom-dark-syntax": "0.19.0",
+    "atom-dark-syntax": "0.20.0",
     "atom-dark-ui": "0.35.0",
-    "atom-light-syntax": "0.20.0",
+    "atom-light-syntax": "0.21.0",
     "atom-light-ui": "0.30.0",
     "base16-tomorrow-dark-theme": "0.21.0",
     "base16-tomorrow-light-theme": "0.4.0",
@@ -74,72 +75,72 @@
     "archive-view": "0.37.0",
     "autocomplete": "0.32.0",
     "autoflow": "0.18.0",
-    "autosave": "0.17.0",
+    "autosave": "0.18.0",
     "background-tips": "0.17.0",
     "bookmarks": "0.28.0",
-    "bracket-matcher": "0.61.0",
-    "command-palette": "0.26.0",
-    "deprecation-cop": "0.10.0",
+    "bracket-matcher": "0.62.0",
+    "command-palette": "0.27.0",
+    "deprecation-cop": "0.11.0",
     "dev-live-reload": "0.34.0",
     "exception-reporting": "0.20.0",
     "feedback": "0.33.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.34.0",
-    "image-view": "0.36.0",
-    "incompatible-packages": "0.9.0",
+    "find-and-replace": "0.141.0",
+    "fuzzy-finder": "0.60.0",
+    "git-diff": "0.42.0",
+    "go-to-line": "0.26.0",
+    "grammar-selector": "0.35.0",
+    "image-view": "0.38.0",
+    "incompatible-packages": "0.10.0",
     "keybinding-resolver": "0.20.0",
-    "link": "0.25.0",
-    "markdown-preview": "0.103.0",
+    "link": "0.26.0",
+    "markdown-preview": "0.107.0",
     "metrics": "0.36.0",
     "open-on-github": "0.30.0",
     "package-generator": "0.31.0",
     "release-notes": "0.36.0",
-    "settings-view": "0.148.0",
-    "snippets": "0.53.0",
-    "spell-check": "0.42.0",
-    "status-bar": "0.45.0",
+    "settings-view": "0.153.0",
+    "snippets": "0.56.0",
+    "spell-check": "0.43.0",
+    "status-bar": "0.46.0",
     "styleguide": "0.30.0",
     "symbols-view": "0.66.0",
-    "tabs": "0.54.0",
-    "timecop": "0.22.0",
-    "tree-view": "0.127.0",
+    "tabs": "0.55.0",
+    "timecop": "0.23.0",
+    "tree-view": "0.131.0",
     "update-package-dependencies": "0.6.0",
-    "welcome": "0.18.0",
-    "whitespace": "0.25.0",
-    "wrap-guide": "0.22.0",
-    "language-c": "0.28.0",
-    "language-coffee-script": "0.35.0",
-    "language-css": "0.17.0",
-    "language-gfm": "0.50.0",
+    "welcome": "0.19.0",
+    "whitespace": "0.26.0",
+    "wrap-guide": "0.23.0",
+    "language-c": "0.29.0",
+    "language-coffee-script": "0.37.0",
+    "language-css": "0.21.0",
+    "language-gfm": "0.53.0",
     "language-git": "0.9.0",
-    "language-go": "0.17.0",
+    "language-go": "0.19.0",
     "language-html": "0.26.0",
     "language-hyperlink": "0.12.0",
     "language-java": "0.11.0",
-    "language-javascript": "0.40.0",
+    "language-javascript": "0.42.0",
     "language-json": "0.8.0",
-    "language-less": "0.15.0",
+    "language-less": "0.18.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.16.0",
+    "language-php": "0.17.0",
     "language-property-list": "0.7.0",
-    "language-python": "0.19.0",
-    "language-ruby": "0.38.0",
+    "language-python": "0.21.0",
+    "language-ruby": "0.41.0",
     "language-ruby-on-rails": "0.18.0",
-    "language-sass": "0.22.0",
+    "language-sass": "0.24.0",
     "language-shellscript": "0.8.0",
     "language-source": "0.8.0",
     "language-sql": "0.11.0",
     "language-text": "0.6.0",
-    "language-todo": "0.12.0",
-    "language-toml": "0.12.0",
-    "language-xml": "0.21.0",
-    "language-yaml": "0.17.0"
+    "language-todo": "0.13.0",
+    "language-toml": "0.14.0",
+    "language-xml": "0.24.0",
+    "language-yaml": "0.19.0"
   },
   "private": true,
   "scripts": {

resources/linux/atom.desktop.in

@@ -1,6 +1,7 @@
 [Desktop Entry]
 Name=Atom
 Comment=<%= description %>
+GenericName=Text Editor
 Exec=<%= installDir %>/share/atom/atom %U
 Icon=<%= iconName %>
 Type=Application

resources/linux/redhat/atom.spec.in

@@ -0,0 +1,29 @@
+Name:           <%= name %>
+Version:        <%= version %>
+Release:        0.1%{?dist}
+Summary:        Atom is a hackable text editor for the 21st century
+License:        MIT
+URL:            https://atom.io/
+BuildConflicts: gyp
+BuildRequires:  make, gcc, gcc-c++, glibc-devel, git-core, libgnome-keyring-devel
+Requires:       libgnome-keyring
+AutoReqProv:    no # Avoid libchromiumcontent.so missing dependency
+
+%description
+<%= description %>
+
+%install
+mkdir -p %{buildroot}/usr/local/share/atom
+cp -r /tmp/atom-build/Atom/* %{buildroot}/usr/local/share/atom
+mkdir -p %{buildroot}/usr/local/bin/
+ln -sf /usr/local/share/atom/resources/app/apm/node_modules/.bin/apm %{buildroot}/usr/local/bin/apm
+cp atom.sh %{buildroot}/usr/local/bin/atom
+chmod 755 atom.sh
+mkdir -p %{buildroot}/usr/local/share/applications/
+mv atom.desktop %{buildroot}/usr/local/share/applications/
+
+%files
+/usr/local/bin/atom
+/usr/local/bin/apm
+/usr/local/share/atom/
+/usr/local/share/applications/atom.desktop

script/cibuild-atom-rpm

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -e
+
+docker build -t atom-rpm .
+docker run \
+ --env JANKY_SHA1="$JANKY_SHA1" \
+ --env JANKY_BRANCH="$JANKY_BRANCH" \
+ --env ATOM_ACCESS_TOKEN="$BUILD_ATOM_RPM_ACCESS_TOKEN" \
+ atom-rpm /atom/script/rpmbuild

script/copy-folder.cmd

@@ -15,4 +15,4 @@ if [%2] == [] (
 if exist %2 rmdir %2 /s /q
 
 :: cp -rf %1 %2
-xcopy %1 %2 /e /h /c /i /y /r
+(robocopy %1 %2 /e) ^& IF %ERRORLEVEL% LEQ 1 exit 0

script/mkrpm

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -e
+
+SPEC_FILE="$1"
+DESKTOP_FILE="$2"
+BUILD_DIRECTORY="$3"
+
+RPM_BUILD_ROOT=~/rpmbuild
+ARCH=`uname -m`
+
+rpmdev-setuptree
+
+cp -r $BUILD_DIRECTORY/Atom/* $RPM_BUILD_ROOT/BUILD
+cp $SPEC_FILE $RPM_BUILD_ROOT/SPECS
+cp ./atom.sh $RPM_BUILD_ROOT/BUILD
+cp $DESKTOP_FILE $RPM_BUILD_ROOT/BUILD
+
+rpmbuild -ba $SPEC_FILE
+cp $RPM_BUILD_ROOT/RPMS/$ARCH/atom-*.rpm $BUILD_DIRECTORY/rpm
+
+rm -rf $RPM_BUILD_ROOT

script/rpmbuild

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+set -e
+
+script/build
+script/grunt mkrpm publish-build --stack

spec/command-installer-spec.coffee

@@ -20,7 +20,7 @@ describe "install(commandPath, callback)", ->
 
       installDone = false
       installError = null
-      installer.install commandFilePath, false, (error) ->
+      installer.createSymlink commandFilePath, false, (error) ->
         installDone = true
         installError = error
 

spec/command-registry-spec.coffee

@@ -14,12 +14,19 @@ describe "CommandRegistry", ->
     parent.appendChild(child)
     document.querySelector('#jasmine-content').appendChild(parent)
 
-    registry = new CommandRegistry(parent)
+    registry = new CommandRegistry
+    atom.commands.restoreDOMEventMethods()
+    registry.patchDOMEventMethods()
 
-  describe "command dispatch", ->
+  afterEach ->
+    registry.restoreDOMEventMethods()
+    atom.commands.patchDOMEventMethods()
+    registry.destroy()
+
+  describe "when a command event is dispatched on an element", ->
     it "invokes callbacks with selectors matching the target", ->
       called = false
-      registry.add '.grandchild', 'command', (event) ->
+      registry.listen '.grandchild', 'command', (event) ->
         expect(this).toBe grandchild
         expect(event.type).toBe 'command'
         expect(event.eventPhase).toBe Event.BUBBLING_PHASE
@@ -33,13 +40,13 @@ describe "CommandRegistry", ->
     it "invokes callbacks with selectors matching ancestors of the target", ->
       calls = []
 
-      registry.add '.child', 'command', (event) ->
+      registry.listen '.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) ->
+      registry.listen '.parent', 'command', (event) ->
         expect(this).toBe parent
         expect(event.target).toBe grandchild
         expect(event.currentTarget).toBe parent
@@ -48,58 +55,110 @@ describe "CommandRegistry", ->
       grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
       expect(calls).toEqual ['child', 'parent']
 
+    it "invokes inline listeners prior to listeners applied via selectors", ->
+      calls = []
+      registry.listen '.grandchild', 'command', -> calls.push('grandchild')
+      registry.listen child, 'command', -> calls.push('child-inline')
+      registry.listen '.child', 'command', -> calls.push('child')
+      registry.listen '.parent', 'command', -> calls.push('parent')
+
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual ['grandchild', 'child-inline', '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
+      registry.listen '.foo.bar', 'command', -> calls.push('.foo.bar')
+      registry.listen '.foo', 'command', -> calls.push('.foo')
+      registry.listen '.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 "does not bubble the event if the ::bubbles property is false on the dispatched event", ->
+      calls = []
+
+      registry.listen '.grandchild', 'command', -> calls.push('grandchild')
+      registry.listen '.child', 'command', -> calls.push('child')
+      registry.listen '.parent', 'command', -> calls.push('parent')
+
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: false))
+      expect(calls).toEqual ['grandchild']
+
+    it "invokes capture-phase listeners before bubble-phase listeners", ->
+      calls = []
+
+      # Spot-check event details for both capture and bubbling phase
+      registry.capture '.grandchild', 'command', (event) ->
+        expect(this).toBe grandchild
+        expect(event.type).toBe 'command'
+        expect(event.eventPhase).toBe Event.CAPTURING_PHASE
+        expect(event.target).toBe grandchild
+        expect(event.currentTarget).toBe grandchild
+        calls.push('grandchild-capture')
+
+      registry.listen '.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
+        calls.push('grandchild-bubble')
+
+      registry.capture child, 'command', -> calls.push('child-inline-capture')
+      registry.listen child, 'command', -> calls.push('child-inline-bubble')
+      registry.capture '.child', 'command', -> calls.push('child-capture')
+      registry.capture '.parent', 'command', -> calls.push('parent-capture')
+
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual ['parent-capture', 'child-inline-capture', 'child-capture', 'grandchild-capture', 'grandchild-bubble', 'child-inline-bubble']
+
     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()
+      registry.listen '.parent', 'command', -> calls.push('parent')
+      registry.listen '.child', 'command', -> calls.push('child-2')
+      registry.listen '.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()
+      registry.listen '.parent', 'command', -> calls.push('parent')
+      registry.listen '.child', 'command', -> calls.push('child-2')
+      registry.listen '.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()
+      registry.listen '.child', 'command', (event) -> event.preventDefault()
 
       dispatchedEvent = new CustomEvent('command', bubbles: true)
       spyOn(dispatchedEvent, 'preventDefault')
       grandchild.dispatchEvent(dispatchedEvent)
       expect(dispatchedEvent.preventDefault).toHaveBeenCalled()
 
+    it "forwards .abortKeyBinding() calls from the synthetic event to the original", ->
+      registry.listen '.child', 'command', (event) -> event.abortKeyBinding()
+
+      dispatchedEvent = new CustomEvent('command', bubbles: true)
+      dispatchedEvent.abortKeyBinding = jasmine.createSpy('abortKeyBinding')
+      grandchild.dispatchEvent(dispatchedEvent)
+      expect(dispatchedEvent.abortKeyBinding).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 = registry.listen '.parent', 'command', -> calls.push('parent')
+      disposable2 = registry.listen '.child', 'command', -> calls.push('child')
 
       disposable1.dispose()
       grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
@@ -113,7 +172,7 @@ describe "CommandRegistry", ->
     it "allows multiple commands to be registered under one selector when called with an object", ->
       calls = []
 
-      disposable = registry.add '.child',
+      disposable = registry.listen '.child',
         'command-1': -> calls.push('command-1')
         'command-2': -> calls.push('command-2')
 
@@ -130,10 +189,10 @@ describe "CommandRegistry", ->
 
   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', ->
+      registry.listen '.parent', 'namespace:command-1', ->
+      registry.listen '.child', 'namespace:command-2', ->
+      registry.listen '.grandchild', 'namespace:command-3', ->
+      registry.listen '.grandchild.no-match', 'namespace:command-4', ->
 
       expect(registry.findCommands(target: grandchild)[0..2]).toEqual [
         {name: 'namespace:command-3', displayName: 'Namespace: Command 3'}
@@ -144,7 +203,7 @@ describe "CommandRegistry", ->
   describe "::dispatch(target, commandName)", ->
     it "simulates invocation of the given command ", ->
       called = false
-      registry.add '.grandchild', 'command', (event) ->
+      registry.listen '.grandchild', 'command', (event) ->
         expect(this).toBe grandchild
         expect(event.type).toBe 'command'
         expect(event.eventPhase).toBe Event.BUBBLING_PHASE
@@ -156,18 +215,42 @@ describe "CommandRegistry", ->
       expect(called).toBe true
 
     it "returns a boolean indicating whether any listeners matched the command", ->
-      registry.add '.grandchild', 'command', ->
+      registry.listen '.grandchild', 'command', ->
 
       expect(registry.dispatch(grandchild, 'command')).toBe true
       expect(registry.dispatch(grandchild, 'bogus')).toBe false
       expect(registry.dispatch(parent, 'command')).toBe false
 
+    it "does not perform bubbling for native event names that should not bubble", ->
+      calls = []
+
+      registry.listen '.grandchild', 'focus', -> calls.push('grandchild')
+      registry.listen '.child', 'focus', -> calls.push('child')
+      registry.listen '.parent', 'focus', -> calls.push('parent')
+
+      registry.dispatch(grandchild, 'focus')
+      expect(calls).toEqual ['grandchild']
+
+    it "allows an event object to be passed instead of an event name", ->
+      called = false
+      registry.listen '.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
+        expect(event.detail).toEqual {a: 1}
+        called = true
+
+      registry.dispatch(grandchild, new CustomEvent('command', bubbles: true), {a: 1})
+      expect(called).toBe true
+
   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', ->
+      registry.listen '.parent', 'namespace:command-1', ->
+      registry.listen '.child', 'namespace:command-2', ->
       snapshot = registry.getSnapshot()
-      registry.add '.grandchild', 'namespace:command-3', ->
+      registry.listen '.grandchild', 'namespace:command-3', ->
 
       expect(registry.findCommands(target: grandchild)[0..2]).toEqual [
         {name: 'namespace:command-3', displayName: 'Namespace: Command 3'}
@@ -182,10 +265,39 @@ describe "CommandRegistry", ->
         {name: 'namespace:command-1', displayName: 'Namespace: Command 1'}
       ]
 
-      registry.add '.grandchild', 'namespace:command-3', ->
+      registry.listen '.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'}
       ]
+
+  describe "::addEventListener and ::removeEventListener overrides", ->
+    it "mixes listeners registered via ::addEventListener with selector-based listeners", ->
+      calls = []
+      registry.listen '.grandchild', 'command', -> calls.push('grandchild')
+      registry.listen '.child', 'command', -> calls.push('child')
+      registry.listen '.parent', 'command', -> calls.push('parent')
+
+      bubbleListener = -> calls.push('child-inline-bubble')
+      captureListener = -> calls.push('child-inline-capture')
+      child.addEventListener('command', bubbleListener)
+      child.addEventListener('command', captureListener, true)
+
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual ['child-inline-capture', 'grandchild', 'child-inline-bubble', 'child', 'parent']
+
+      child.removeEventListener('command', bubbleListener)
+      child.removeEventListener('command', captureListener, true)
+
+      calls = []
+      grandchild.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(calls).toEqual ['grandchild', 'child', 'parent']
+
+    it "invokes handlers on detached DOM nodes", ->
+      detachedNode = document.createElement('div')
+      called = false
+      detachedNode.addEventListener 'command', -> called = true
+      detachedNode.dispatchEvent(new CustomEvent('command', bubbles: true))
+      expect(called).toBe true

spec/config-spec.coffee

@@ -88,6 +88,19 @@ describe "Config", ->
       expect(atom.config.getDefault('foo.bar')).toEqual initialDefaultValue
       expect(atom.config.getDefault('foo.bar')).not.toBe initialDefaultValue
 
+    describe "when scoped settings are used", ->
+      it "returns the global default when no scoped default set", ->
+        atom.config.setDefaults("foo", bar: baz: 10)
+        expect(atom.config.getDefault('.source.coffee', 'foo.bar.baz')).toBe 10
+
+      it "returns the scoped default when a scoped default is set", ->
+        atom.config.setDefaults("foo", bar: baz: 10)
+        atom.config.addScopedSettings("default", ".source.coffee", foo: bar: baz: 42)
+        expect(atom.config.getDefault('.source.coffee', 'foo.bar.baz')).toBe 42
+
+        atom.config.set('.source.coffee', 'foo.bar.baz', 55)
+        expect(atom.config.getDefault('.source.coffee', 'foo.bar.baz')).toBe 42
+
   describe ".isDefault(keyPath)", ->
     it "returns true when the value of the key path is its default value", ->
       atom.config.setDefaults("foo", same: 1, changes: 1)
@@ -99,6 +112,21 @@ describe "Config", ->
       expect(atom.config.isDefault('foo.same')).toBe false
       expect(atom.config.isDefault('foo.changes')).toBe false
 
+    describe "when scoped settings are used", ->
+      it "returns false when a scoped setting was set by the user", ->
+        expect(atom.config.isDefault('.source.coffee', 'foo.bar.baz')).toBe true
+
+        atom.config.addScopedSettings("default", ".source.coffee", foo: bar: baz: 42)
+        expect(atom.config.isDefault('.source.coffee', 'foo.bar.baz')).toBe true
+
+        atom.config.set('.source.coffee', 'foo.bar.baz', 55)
+        expect(atom.config.isDefault('.source.coffee', 'foo.bar.baz')).toBe false
+
+  describe ".setDefaults(keyPath)", ->
+    it "sets a default when the setting's key contains an escaped dot", ->
+      atom.config.setDefaults("foo", 'a\\.b': 1, b: 2)
+      expect(atom.config.get("foo")).toEqual 'a\\.b': 1, b: 2
+
   describe ".toggle(keyPath)", ->
     it "negates the boolean value of the current key path value", ->
       atom.config.set('foo.a', 1)
@@ -130,6 +158,66 @@ describe "Config", ->
       atom.config.restoreDefault('a.c')
       expect(atom.config.get('a.c')).toBeUndefined()
 
+    it "calls ::save()", ->
+      atom.config.setDefaults('a', b: 3)
+      atom.config.set('a.b', 4)
+      atom.config.save.reset()
+
+      atom.config.restoreDefault('a.c')
+      expect(atom.config.save.callCount).toBe 1
+
+    describe "when scoped settings are used", ->
+      it "restores the global default when no scoped default set", ->
+        atom.config.setDefaults("foo", bar: baz: 10)
+        atom.config.set('.source.coffee', 'foo.bar.baz', 55)
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.baz')).toBe 55
+
+        atom.config.restoreDefault('.source.coffee', 'foo.bar.baz')
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.baz')).toBe 10
+
+      it "restores the scoped default when a scoped default is set", ->
+        atom.config.setDefaults("foo", bar: baz: 10)
+        atom.config.addScopedSettings("default", ".source.coffee", foo: bar: baz: 42)
+        atom.config.set('.source.coffee', 'foo.bar.baz', 55)
+        atom.config.set('.source.coffee', 'foo.bar.ok', 100)
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.baz')).toBe 55
+
+        atom.config.restoreDefault('.source.coffee', 'foo.bar.baz')
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.baz')).toBe 42
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.ok')).toBe 100
+
+      it "calls ::save()", ->
+        atom.config.setDefaults("foo", bar: baz: 10)
+        atom.config.addScopedSettings("default", ".source.coffee", foo: bar: baz: 42)
+        atom.config.set('.source.coffee', 'foo.bar.baz', 55)
+        atom.config.save.reset()
+
+        atom.config.restoreDefault('.source.coffee', 'foo.bar.baz')
+        expect(atom.config.save.callCount).toBe 1
+
+  describe ".getSettings()", ->
+    it "returns all settings including defaults", ->
+      atom.config.setDefaults("foo", bar: baz: 10)
+      atom.config.set("foo.ok", 12)
+
+      expect(atom.config.getSettings().foo).toEqual
+        ok: 12
+        bar:
+          baz: 10
+
+    describe "when scoped settings are used", ->
+      it "returns all the scoped settings including all the defaults", ->
+        atom.config.setDefaults("foo", bar: baz: 10)
+        atom.config.set("foo.ok", 12)
+        atom.config.addScopedSettings("default", ".source.coffee", foo: bar: baz: 42)
+        atom.config.addScopedSettings("default", ".source.coffee", foo: bar: omg: 'omg')
+
+        expect(atom.config.getSettings(".source.coffee").foo).toEqual
+          ok: 12
+          bar:
+            baz: 42
+            omg: 'omg'
+
   describe ".pushAtKeyPath(keyPath, value)", ->
     it "pushes the given value to the array at the key path and updates observers", ->
       atom.config.set("foo.bar.baz", ["a"])
@@ -200,7 +288,7 @@ describe "Config", ->
 
         expect(CSON.writeFileSync.argsForCall[0][0]).toBe(path.join(atom.config.configDirPath, "atom.config.json"))
         writtenConfig = CSON.writeFileSync.argsForCall[0][1]
-        expect(writtenConfig).toBe atom.config.settings
+        expect(writtenConfig).toEqual global: atom.config.settings
 
     describe "when ~/.atom/config.json doesn't exist", ->
       it "writes any non-default properties to ~/.atom/config.cson", ->
@@ -214,9 +302,29 @@ describe "Config", ->
         atom.config.save()
 
         expect(CSON.writeFileSync.argsForCall[0][0]).toBe(path.join(atom.config.configDirPath, "atom.config.cson"))
-        CoffeeScript = require 'coffee-script'
         writtenConfig = CSON.writeFileSync.argsForCall[0][1]
-        expect(writtenConfig).toEqual atom.config.settings
+        expect(writtenConfig).toEqual global: atom.config.settings
+
+    describe "when scoped settings are defined", ->
+      it 'writes out explicitly set config settings', ->
+        atom.config.set('.source.ruby', 'foo.bar', 'ruby')
+        atom.config.set('.source.ruby', 'foo.omg', 'wow')
+        atom.config.set('.source.coffee', 'foo.bar', 'coffee')
+
+        CSON.writeFileSync.reset()
+        atom.config.save()
+
+        writtenConfig = CSON.writeFileSync.argsForCall[0][1]
+        expect(writtenConfig).toEqualJson
+          global:
+            atom.config.settings
+          '.ruby.source':
+            foo:
+              bar: 'ruby'
+              omg: 'wow'
+          '.coffee.source':
+            foo:
+              bar: 'coffee'
 
   describe ".setDefaults(keyPath, defaults)", ->
     it "assigns any previously-unassigned keys to the object at the key path", ->
@@ -320,6 +428,14 @@ describe "Config", ->
       atom.config.set('foo.bar.baz', "value 2")
       expect(observeHandler).not.toHaveBeenCalled()
 
+    it 'does not fire the callback for a similarly named keyPath', ->
+      bazCatHandler = jasmine.createSpy("bazCatHandler")
+      observeSubscription = atom.config.observe "foo.bar.bazCat", bazCatHandler
+
+      bazCatHandler.reset()
+      atom.config.set('foo.bar.baz', "value 10")
+      expect(bazCatHandler).not.toHaveBeenCalled()
+
   describe ".initializeConfigDirectory()", ->
     beforeEach ->
       if fs.existsSync(dotAtomPath)
@@ -356,6 +472,23 @@ describe "Config", ->
     afterEach ->
       fs.removeSync(dotAtomPath)
 
+    describe "when the config file contains scoped settings", ->
+      beforeEach ->
+        fs.writeFileSync atom.config.configFilePath, """
+          global:
+            foo:
+              bar: 'baz'
+
+          '.source.ruby':
+            foo:
+              bar: 'more-specific'
+        """
+        atom.config.loadUserConfig()
+
+      it "updates the config data based on the file contents", ->
+        expect(atom.config.get("foo.bar")).toBe 'baz'
+        expect(atom.config.get(['.source.ruby'], "foo.bar")).toBe 'more-specific'
+
     describe "when the config file contains valid cson", ->
       beforeEach ->
         fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'baz'")
@@ -430,7 +563,15 @@ describe "Config", ->
       atom.config.configDirPath = dotAtomPath
       atom.config.configFilePath = path.join(atom.config.configDirPath, "atom.config.cson")
       expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
-      fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'baz'")
+      fs.writeFileSync atom.config.configFilePath, """
+        global:
+          foo:
+            bar: 'baz'
+            scoped: false
+        '.source.ruby':
+          foo:
+            scoped: true
+      """
       atom.config.loadUserConfig()
       atom.config.observeUserConfig()
       updatedHandler = jasmine.createSpy("updatedHandler")
@@ -448,6 +589,64 @@ 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 scoped settings are used', ->
+        it "fires a change event for scoped settings that are removed", ->
+          atom.config.onDidChange ['.source.ruby'], 'foo.scoped', scopedSpy = jasmine.createSpy()
+
+          fs.writeFileSync atom.config.configFilePath, """
+            global:
+              foo:
+                scoped: false
+          """
+          waitsFor 'update event', -> updatedHandler.callCount > 0
+          runs ->
+            expect(scopedSpy).toHaveBeenCalled()
+            expect(atom.config.get(['.source.ruby'], 'foo.scoped')).toBe false
+
+        it "does not fire a change event for paths that did not change", ->
+          atom.config.onDidChange ['.source.ruby'], 'foo.scoped', noChangeSpy = jasmine.createSpy()
+
+          fs.writeFileSync atom.config.configFilePath, """
+            global:
+              foo:
+                bar: 'baz'
+            '.source.ruby':
+              foo:
+                scoped: true
+          """
+          waitsFor 'update event', -> updatedHandler.callCount > 0
+          runs ->
+            expect(noChangeSpy).not.toHaveBeenCalled()
+            expect(atom.config.get(['.source.ruby'], 'foo.bar')).toBe 'baz'
+            expect(atom.config.get(['.source.ruby'], 'foo.scoped')).toBe true
+
+
     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'}")
@@ -836,3 +1035,128 @@ describe "Config", ->
 
         expect(atom.config.set('foo.bar.arr', ['two', 'three'])).toBe true
         expect(atom.config.get('foo.bar.arr')).toEqual ['two', 'three']
+
+    describe "when scoped settings are used", ->
+      beforeEach ->
+        schema =
+          type: 'string'
+          default: 'ok'
+          scopes:
+            '.source.js':
+              default: 'omg'
+        atom.config.setSchema('foo.bar.str', schema)
+
+      it 'it respects the scoped defaults', ->
+        expect(atom.config.get('foo.bar.str')).toBe 'ok'
+        expect(atom.config.get(['.source.js'], 'foo.bar.str')).toBe 'omg'
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.str')).toBe 'ok'
+
+  describe "scoped settings", ->
+    describe ".get(scopeDescriptor, keyPath)", ->
+      it "returns the property with the most specific scope selector", ->
+        atom.config.addScopedSettings("config", ".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
+        atom.config.addScopedSettings("config", ".source .string.quoted.double", foo: bar: baz: 22)
+        atom.config.addScopedSettings("config", ".source", foo: bar: baz: 11)
+
+        expect(atom.config.get([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42
+        expect(atom.config.get([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBe 22
+        expect(atom.config.get([".source.js", ".variable.assignment.js"], "foo.bar.baz")).toBe 11
+        expect(atom.config.get([".text"], "foo.bar.baz")).toBeUndefined()
+
+      it "favors the most recently added properties in the event of a specificity tie", ->
+        atom.config.addScopedSettings("config", ".source.coffee .string.quoted.single", foo: bar: baz: 42)
+        atom.config.addScopedSettings("config", ".source.coffee .string.quoted.double", foo: bar: baz: 22)
+
+        expect(atom.config.get([".source.coffee", ".string.quoted.single"], "foo.bar.baz")).toBe 42
+        expect(atom.config.get([".source.coffee", ".string.quoted.single.double"], "foo.bar.baz")).toBe 22
+
+      describe 'when there are global defaults', ->
+        it 'falls back to the global when there is no scoped property specified', ->
+          atom.config.setDefaults("foo", hasDefault: 'ok')
+          expect(atom.config.get([".source.coffee", ".string.quoted.single"], "foo.hasDefault")).toBe 'ok'
+
+      describe 'setting priority', ->
+        describe 'when package settings are added after user settings', ->
+          it "returns the user's setting because the user's setting has higher priority", ->
+            atom.config.set(".source.coffee", "foo.bar.baz", 100)
+            atom.config.addScopedSettings("some-package", ".source.coffee", foo: bar: baz: 1)
+            expect(atom.config.get([".source.coffee"], "foo.bar.baz")).toBe 100
+
+    describe ".set(scope, keyPath, value)", ->
+      it "sets the value and overrides the others", ->
+        atom.config.addScopedSettings("config", ".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
+        atom.config.addScopedSettings("config", ".source .string.quoted.double", foo: bar: baz: 22)
+        atom.config.addScopedSettings("config", ".source", foo: bar: baz: 11)
+
+        expect(atom.config.get([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42
+
+        expect(atom.config.set(".source.coffee .string.quoted.double.coffee", "foo.bar.baz", 100)).toBe true
+        expect(atom.config.get([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 100
+
+    describe ".removeScopedSettingsForName(name)", ->
+      it "allows properties to be removed by name", ->
+        disposable1 = atom.config.addScopedSettings("a", ".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
+        disposable2 = atom.config.addScopedSettings("b", ".source .string.quoted.double", foo: bar: baz: 22)
+
+        disposable2.dispose()
+        expect(atom.config.get([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBeUndefined()
+        expect(atom.config.get([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42
+
+    describe ".observe(scopeDescriptor, keyPath)", ->
+      it 'calls the supplied callback when the value at the descriptor/keypath changes', ->
+        atom.config.observe [".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz", changeSpy = jasmine.createSpy()
+        expect(changeSpy).toHaveBeenCalledWith(undefined)
+        changeSpy.reset()
+
+        atom.config.set("foo.bar.baz", 12)
+        expect(changeSpy).toHaveBeenCalledWith(12)
+        changeSpy.reset()
+
+        disposable1 = atom.config.addScopedSettings("a", ".source .string.quoted.double", foo: bar: baz: 22)
+        expect(changeSpy).toHaveBeenCalledWith(22)
+        changeSpy.reset()
+
+        disposable2 = atom.config.addScopedSettings("b", ".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
+        expect(changeSpy).toHaveBeenCalledWith(42)
+        changeSpy.reset()
+
+        disposable2.dispose()
+        expect(changeSpy).toHaveBeenCalledWith(22)
+        changeSpy.reset()
+
+        disposable1.dispose()
+        expect(changeSpy).toHaveBeenCalledWith(12)
+        changeSpy.reset()
+
+        atom.config.set("foo.bar.baz", undefined)
+        expect(changeSpy).toHaveBeenCalledWith(undefined)
+        changeSpy.reset()
+
+    describe ".onDidChange(scopeDescriptor, keyPath)", ->
+      it 'calls the supplied callback when the value at the descriptor/keypath changes', ->
+        keyPath = "foo.bar.baz"
+        atom.config.onDidChange [".source.coffee", ".string.quoted.double.coffee"], keyPath, changeSpy = jasmine.createSpy()
+
+        atom.config.set("foo.bar.baz", 12)
+        expect(changeSpy).toHaveBeenCalledWith({oldValue: undefined, newValue: 12, keyPath})
+        changeSpy.reset()
+
+        disposable1 = atom.config.addScopedSettings("a", ".source .string.quoted.double", foo: bar: baz: 22)
+        expect(changeSpy).toHaveBeenCalledWith({oldValue: 12, newValue: 22, keyPath})
+        changeSpy.reset()
+
+        disposable2 = atom.config.addScopedSettings("b", ".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
+        expect(changeSpy).toHaveBeenCalledWith({oldValue: 22, newValue: 42, keyPath})
+        changeSpy.reset()
+
+        disposable2.dispose()
+        expect(changeSpy).toHaveBeenCalledWith({oldValue: 42, newValue: 22, keyPath})
+        changeSpy.reset()
+
+        disposable1.dispose()
+        expect(changeSpy).toHaveBeenCalledWith({oldValue: 22, newValue: 12, keyPath})
+        changeSpy.reset()
+
+        atom.config.set("foo.bar.baz", undefined)
+        expect(changeSpy).toHaveBeenCalledWith({oldValue: 12, newValue: undefined, keyPath})
+        changeSpy.reset()

spec/context-menu-manager-spec.coffee

@@ -3,173 +3,172 @@
 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
+      shouldDisplay = false
+      expect(contextMenu.templateForEvent(dispatchedEvent)).toEqual []
 
-        it "creates a menu with development items", ->
-          menu = contextMenu.combinedMenuTemplateForElement(element)
+    it "allows items to be specified in the legacy format for now", ->
+      contextMenu.add '.parent':
+        'A': 'a'
+        'Separator 1': '-'
+        'B':
+          'C': 'c'
+          'Separator 2': '-'
+          'D': 'd'
 
-          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: ->
+      expect(contextMenu.templateForElement(parent)).toEqual [
+        {label: 'A', command: 'a'}
+        {type: 'separator'}
+        {
+          label: 'B'
+          submenu: [
+            {label: 'C', command: 'c'}
+            {type: 'separator'}
+            {label: 'D', command: 'd'}
+          ]
+        }
       ]
-    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

spec/display-buffer-spec.coffee

@@ -56,6 +56,11 @@ describe "DisplayBuffer", ->
       buffer.delete([[8, 0], [10, 0]])
       expect(displayBuffer.getScrollTop()).toBe 60
 
+    it "updates the display buffer prior to invoking change handlers registered on the buffer", ->
+      buffer.onDidChange -> expect(displayBuffer2.tokenizedLineForScreenRow(0).text).toBe "testing"
+      displayBuffer2 = new DisplayBuffer({buffer, tabLength})
+      buffer.setText("testing")
+
   describe "soft wrapping", ->
     beforeEach ->
       displayBuffer.setSoftWrapped(true)

spec/fixtures/module-cache/file.json

@@ -0,0 +1,3 @@
+{
+  "foo": "bar"
+}

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

@@ -6,7 +6,7 @@ module.exports =
   activate: ->
     @activateCallCount++
 
-    atom.commands.add '.workspace', 'activation-command', =>
+    atom.commands.listen 'atom-workspace', 'activation-command', =>
       @activationCommandCallCount++
 
     atom.workspaceView.getActiveView()?.command 'activation-command', =>

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

@@ -1,5 +1,5 @@
 {
   "name": "no events",
   "version": "0.1.0",
-  "activationCommands": {".workspace": []}
+  "activationCommands": {"atom-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/fixtures/packages/theme-with-incomplete-ui-variables/stylesheets/editor.less

@@ -1,6 +1,6 @@
 @import "ui-variables";
 
-.editor {
+atom-text-editor {
   padding-top: @component-padding;
   padding-right: @component-padding;
   padding-bottom: @component-padding;

spec/fixtures/packages/theme-with-index-css/index.css

@@ -1,3 +1,3 @@
-.editor {
+atom-text-editor {
   padding-top: 1234px;
 }

spec/fixtures/packages/theme-with-index-less/index.less

@@ -1,5 +1,5 @@
 @padding: 4321px;
 
-.editor {
+atom-text-editor {
   padding-top: @padding;
 }

spec/fixtures/packages/theme-with-package-file/stylesheets/first.css

@@ -1,4 +1,4 @@
-.editor {
+atom-text-editor {
   padding-top: 101px;
   padding-right: 101px;
   padding-bottom: 101px;

spec/fixtures/packages/theme-with-package-file/stylesheets/last.css

@@ -1,4 +1,4 @@
-.editor {
+atom-text-editor {
 /*  padding-top: 103px;
   padding-right: 103px;*/
   padding-bottom: 103px;

spec/fixtures/packages/theme-with-package-file/stylesheets/second.less

@@ -1,6 +1,6 @@
 @number: 102px;
 
-.editor {
+atom-text-editor {
 /*  padding-top: 102px;*/
   padding-right: @number;
   padding-bottom: @number;

spec/fixtures/packages/theme-with-ui-variables/stylesheets/editor.less

@@ -1,6 +1,6 @@
 @import "ui-variables";
 
-.editor {
+atom-text-editor {
   padding-top: @component-padding;
   padding-right: @component-padding;
   padding-bottom: @component-padding;

spec/fixtures/packages/theme-without-package-file/stylesheets/a.css

@@ -1,4 +1,4 @@
-.editor {
+atom-text-editor {
   padding-top: 10px;
   padding-right: 10px;
   padding-bottom: 10px;

spec/fixtures/packages/theme-without-package-file/stylesheets/b.css

@@ -1,4 +1,4 @@
-.editor {
+atom-text-editor {
   padding-right: 20px;
   padding-bottom: 20px;
 }

spec/fixtures/packages/theme-without-package-file/stylesheets/c.less

@@ -1,5 +1,5 @@
 @number: 30px;
 
-.editor {
+atom-text-editor {
   padding-bottom: @number;
 }

spec/fixtures/packages/theme-without-package-file/stylesheets/d.csv

@@ -1,4 +1,4 @@
-.editor {
+atom-text-editor {
   padding-top: 100px;
   padding-right: 100px;
   padding-bottom: 100px;

spec/git-spec.coffee

@@ -223,7 +223,7 @@ describe "GitRepository", ->
     [editor] = []
 
     beforeEach ->
-      atom.project.setPath(copyRepository())
+      atom.project.setPaths([copyRepository()])
 
       waitsForPromise ->
         atom.workspace.open('other.txt').then (o) -> editor = o
@@ -232,7 +232,7 @@ describe "GitRepository", ->
       editor.insertNewline()
 
       statusHandler = jasmine.createSpy('statusHandler')
-      atom.project.getRepo().onDidChangeStatus statusHandler
+      atom.project.getRepositories()[0].onDidChangeStatus statusHandler
       editor.save()
       expect(statusHandler.callCount).toBe 1
       expect(statusHandler).toHaveBeenCalledWith {path: editor.getPath(), pathStatus: 256}
@@ -241,7 +241,7 @@ describe "GitRepository", ->
       fs.writeFileSync(editor.getPath(), 'changed')
 
       statusHandler = jasmine.createSpy('statusHandler')
-      atom.project.getRepo().onDidChangeStatus statusHandler
+      atom.project.getRepositories()[0].onDidChangeStatus statusHandler
       editor.getBuffer().reload()
       expect(statusHandler.callCount).toBe 1
       expect(statusHandler).toHaveBeenCalledWith {path: editor.getPath(), pathStatus: 256}
@@ -252,7 +252,7 @@ describe "GitRepository", ->
       fs.writeFileSync(editor.getPath(), 'changed')
 
       statusHandler = jasmine.createSpy('statusHandler')
-      atom.project.getRepo().onDidChangeStatus statusHandler
+      atom.project.getRepositories()[0].onDidChangeStatus statusHandler
       editor.getBuffer().emitter.emit 'did-change-path'
       expect(statusHandler.callCount).toBe 1
       expect(statusHandler).toHaveBeenCalledWith {path: editor.getPath(), pathStatus: 256}
@@ -266,7 +266,7 @@ describe "GitRepository", ->
       project2?.destroy()
 
     it "subscribes to all the serialized buffers in the project", ->
-      atom.project.setPath(copyRepository())
+      atom.project.setPaths([copyRepository()])
 
       waitsForPromise ->
         atom.workspace.open('file.txt')
@@ -283,7 +283,7 @@ describe "GitRepository", ->
         buffer.append('changes')
 
         statusHandler = jasmine.createSpy('statusHandler')
-        project2.getRepo().onDidChangeStatus statusHandler
+        project2.getRepositories()[0].onDidChangeStatus statusHandler
         buffer.save()
         expect(statusHandler.callCount).toBe 1
         expect(statusHandler).toHaveBeenCalledWith {path: buffer.getPath(), pathStatus: 256}

spec/module-cache-spec.coffee

@@ -0,0 +1,92 @@
+path = require 'path'
+Module = require 'module'
+fs = require 'fs-plus'
+temp = require 'temp'
+ModuleCache = require '../src/module-cache'
+
+describe 'ModuleCache', ->
+  beforeEach ->
+    spyOn(Module, '_findPath').andCallThrough()
+
+  it 'resolves atom shell module paths without hitting the filesystem', ->
+    builtins = ModuleCache.cache.builtins
+    expect(Object.keys(builtins).length).toBeGreaterThan 0
+
+    for builtinName, builtinPath of builtins
+      expect(require.resolve(builtinName)).toBe builtinPath
+      expect(fs.isFileSync(require.resolve(builtinName)))
+
+    expect(Module._findPath.callCount).toBe 0
+
+  it 'resolves relative core paths without hitting the filesystem', ->
+    ModuleCache.add atom.getLoadSettings().resourcePath, {
+      _atomModuleCache:
+        extensions:
+          '.json': [
+            path.join('spec', 'fixtures', 'module-cache', 'file.json')
+          ]
+    }
+    expect(require('./fixtures/module-cache/file.json').foo).toBe 'bar'
+    expect(Module._findPath.callCount).toBe 0
+
+  it 'resolves module paths when a compatible version is provided by core', ->
+    packagePath = fs.realpathSync(temp.mkdirSync('atom-package'))
+    ModuleCache.add packagePath, {
+      _atomModuleCache:
+        folders: [{
+          paths: [
+            ''
+          ]
+          dependencies:
+            'underscore-plus': '*'
+        }]
+    }
+    ModuleCache.add atom.getLoadSettings().resourcePath, {
+      _atomModuleCache:
+        dependencies: [{
+          name: 'underscore-plus'
+          version: require('underscore-plus/package.json').version
+          path: path.join('node_modules', 'underscore-plus', 'lib', 'underscore-plus.js')
+        }]
+    }
+
+    indexPath = path.join(packagePath, 'index.js')
+    fs.writeFileSync indexPath, """
+      exports.load = function() { require('underscore-plus'); };
+    """
+
+    packageMain = require(indexPath)
+    Module._findPath.reset()
+    packageMain.load()
+    expect(Module._findPath.callCount).toBe 0
+
+  it 'does not resolve module paths when no compatible version is provided by core', ->
+    packagePath = fs.realpathSync(temp.mkdirSync('atom-package'))
+    ModuleCache.add packagePath, {
+      _atomModuleCache:
+        folders: [{
+          paths: [
+            ''
+          ]
+          dependencies:
+            'underscore-plus': '0.0.1'
+        }]
+    }
+    ModuleCache.add atom.getLoadSettings().resourcePath, {
+      _atomModuleCache:
+        dependencies: [{
+          name: 'underscore-plus'
+          version: require('underscore-plus/package.json').version
+          path: path.join('node_modules', 'underscore-plus', 'lib', 'underscore-plus.js')
+        }]
+    }
+
+    indexPath = path.join(packagePath, 'index.js')
+    fs.writeFileSync indexPath, """
+      exports.load = function() { require('underscore-plus'); };
+    """
+
+    packageMain = require(indexPath)
+    Module._findPath.reset()
+    expect(-> packageMain.load()).toThrow()
+    expect(Module._findPath.callCount).toBe 1

spec/package-manager-spec.coffee

@@ -3,7 +3,7 @@ Package = require '../src/package'
 
 describe "PackageManager", ->
   beforeEach ->
-    atom.workspaceView = new WorkspaceView
+    atom.workspaceView = atom.workspace.getView(atom.workspace).__spacePenView
 
   describe "::loadPackage(name)", ->
     it "continues if the package has an invalid package.json", ->
@@ -118,7 +118,7 @@ describe "PackageManager", ->
             spyOn(Package.prototype, 'requireMainModule').andCallThrough()
 
             workspaceCommandListener = jasmine.createSpy('workspaceCommandListener')
-            atom.commands.add '.workspace', 'activation-command', workspaceCommandListener
+            atom.commands.listen '.workspace', 'activation-command', workspaceCommandListener
 
             promise = atom.packages.activatePackage('package-with-activation-commands')
 
@@ -138,7 +138,7 @@ describe "PackageManager", ->
               legacyCommandListener = jasmine.createSpy("legacyCommandListener")
               editorView.command 'activation-command', legacyCommandListener
               editorCommandListener = jasmine.createSpy("editorCommandListener")
-              atom.commands.add '.editor', 'activation-command', editorCommandListener
+              atom.commands.listen 'atom-text-editor', 'activation-command', editorCommandListener
               editorView[0].dispatchEvent(new CustomEvent('activation-command', bubbles: true))
               expect(mainModule.activate.callCount).toBe 1
               expect(mainModule.legacyActivationCommandCallCount).toBe 1
@@ -230,30 +230,30 @@ describe "PackageManager", ->
           it "loads all the .cson/.json files in the menus directory", ->
             element = ($$ -> @div class: 'test-1')[0]
 
-            expect(atom.contextMenu.definitionsForElement(element)).toEqual []
+            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.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"
+            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.definitionsForElement(element)).toEqual []
+            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.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()
+            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", ->
@@ -313,7 +313,7 @@ describe "PackageManager", ->
             atom.packages.activatePackage("package-with-scoped-properties")
 
           runs ->
-            expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
+            expect(atom.config.get ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
 
     describe "converted textmate packages", ->
       it "loads the package's grammars", ->
@@ -326,15 +326,18 @@ describe "PackageManager", ->
           expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
 
       it "loads the translated scoped properties", ->
-        expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
+        expect(atom.config.get(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
 
         waitsForPromise ->
           atom.packages.activatePackage('language-ruby')
 
         runs ->
-          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBe '# '
+          expect(atom.config.get(['.source.ruby'], 'editor.commentStart')).toBe '# '
 
   describe "::deactivatePackage(id)", ->
+    afterEach ->
+      atom.packages.unloadPackages()
+
     describe "atom packages", ->
       it "calls `deactivate` on the package's main module if activate was successful", ->
         pack = null
@@ -436,9 +439,9 @@ describe "PackageManager", ->
           atom.packages.activatePackage("package-with-scoped-properties")
 
         runs ->
-          expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
+          expect(atom.config.get ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
           atom.packages.deactivatePackage("package-with-scoped-properties")
-          expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBeUndefined()
+          expect(atom.config.get ['.source.omg'], 'editor.increaseIndentPattern').toBeUndefined()
 
     describe "textmate packages", ->
       it "removes the package's grammars", ->
@@ -458,7 +461,7 @@ describe "PackageManager", ->
 
         runs ->
           atom.packages.deactivatePackage('language-ruby')
-          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
+          expect(atom.config.get(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
 
   describe "::activate()", ->
     packageActivator = null

spec/package-spec.coffee

@@ -38,51 +38,51 @@ describe "Package", ->
     theme = null
 
     beforeEach ->
-      $("#jasmine-content").append $("<div class='editor'></div>")
+      $("#jasmine-content").append $("<atom-text-editor></atom-text-editor>")
 
     afterEach ->
       theme.deactivate() if theme?
 
     describe "when the theme contains a single style file", ->
       it "loads and applies css", ->
-        expect($(".editor").css("padding-bottom")).not.toBe "1234px"
+        expect($("atom-text-editor").css("padding-bottom")).not.toBe "1234px"
         themePath = atom.project.resolve('packages/theme-with-index-css')
         theme = new ThemePackage(themePath)
         theme.activate()
-        expect($(".editor").css("padding-top")).toBe "1234px"
+        expect($("atom-text-editor").css("padding-top")).toBe "1234px"
 
       it "parses, loads and applies less", ->
-        expect($(".editor").css("padding-bottom")).not.toBe "1234px"
+        expect($("atom-text-editor").css("padding-bottom")).not.toBe "1234px"
         themePath = atom.project.resolve('packages/theme-with-index-less')
         theme = new ThemePackage(themePath)
         theme.activate()
-        expect($(".editor").css("padding-top")).toBe "4321px"
+        expect($("atom-text-editor").css("padding-top")).toBe "4321px"
 
     describe "when the theme contains a package.json file", ->
       it "loads and applies stylesheets from package.json in the correct order", ->
-        expect($(".editor").css("padding-top")).not.toBe("101px")
-        expect($(".editor").css("padding-right")).not.toBe("102px")
-        expect($(".editor").css("padding-bottom")).not.toBe("103px")
+        expect($("atom-text-editor").css("padding-top")).not.toBe("101px")
+        expect($("atom-text-editor").css("padding-right")).not.toBe("102px")
+        expect($("atom-text-editor").css("padding-bottom")).not.toBe("103px")
 
         themePath = atom.project.resolve('packages/theme-with-package-file')
         theme = new ThemePackage(themePath)
         theme.activate()
-        expect($(".editor").css("padding-top")).toBe("101px")
-        expect($(".editor").css("padding-right")).toBe("102px")
-        expect($(".editor").css("padding-bottom")).toBe("103px")
+        expect($("atom-text-editor").css("padding-top")).toBe("101px")
+        expect($("atom-text-editor").css("padding-right")).toBe("102px")
+        expect($("atom-text-editor").css("padding-bottom")).toBe("103px")
 
     describe "when the theme does not contain a package.json file and is a directory", ->
       it "loads all stylesheet files in the directory", ->
-        expect($(".editor").css("padding-top")).not.toBe "10px"
-        expect($(".editor").css("padding-right")).not.toBe "20px"
-        expect($(".editor").css("padding-bottom")).not.toBe "30px"
+        expect($("atom-text-editor").css("padding-top")).not.toBe "10px"
+        expect($("atom-text-editor").css("padding-right")).not.toBe "20px"
+        expect($("atom-text-editor").css("padding-bottom")).not.toBe "30px"
 
         themePath = atom.project.resolve('packages/theme-without-package-file')
         theme = new ThemePackage(themePath)
         theme.activate()
-        expect($(".editor").css("padding-top")).toBe "10px"
-        expect($(".editor").css("padding-right")).toBe "20px"
-        expect($(".editor").css("padding-bottom")).toBe "30px"
+        expect($("atom-text-editor").css("padding-top")).toBe "10px"
+        expect($("atom-text-editor").css("padding-right")).toBe "20px"
+        expect($("atom-text-editor").css("padding-bottom")).toBe "30px"
 
     describe "reloading a theme", ->
       beforeEach ->

spec/pane-container-spec.coffee

@@ -115,3 +115,29 @@ describe "PaneContainer", ->
       pane3.addItems([new Object, new Object])
 
       expect(observed).toEqual container.getPaneItems()
+
+  describe "::confirmClose()", ->
+    [container, pane1, pane2] = []
+
+    beforeEach ->
+      class TestItem
+        shouldPromptToSave: -> true
+        getUri: -> 'test'
+
+      container = new PaneContainer
+      container.getRoot().splitRight()
+      [pane1, pane2] = container.getPanes()
+      pane1.addItem(new TestItem)
+      pane2.addItem(new TestItem)
+
+    it "returns true if the user saves all modified files when prompted", ->
+      spyOn(atom, "confirm").andReturn(0)
+      saved = container.confirmClose()
+      expect(saved).toBeTruthy()
+      expect(atom.confirm).toHaveBeenCalled()
+
+    it "returns false if the user cancels saving any modified file", ->
+      spyOn(atom, "confirm").andReturn(1)
+      saved = container.confirmClose()
+      expect(saved).toBeFalsy()
+      expect(atom.confirm).toHaveBeenCalled()

spec/pane-container-view-spec.coffee

@@ -1,5 +1,6 @@
 path = require 'path'
 temp = require 'temp'
+PaneContainer = require '../src/pane-container'
 PaneContainerView = require '../src/pane-container-view'
 PaneView = require '../src/pane-view'
 {$, View, $$} = require 'atom'
@@ -18,7 +19,7 @@ describe "PaneContainerView", ->
       save: -> @saved = true
       isEqual: (other) -> @name is other?.name
 
-    container = new PaneContainerView
+    container = atom.workspace.getView(atom.workspace.paneContainer).__spacePenView
     pane1 = container.getRoot()
     pane1.activateItem(new TestView('1'))
     pane2 = pane1.splitRight(new TestView('2'))
@@ -70,39 +71,16 @@ describe "PaneContainerView", ->
         for item in pane.getItems()
           expect(item.saved).toBeTruthy()
 
-  describe ".confirmClose()", ->
-    it "returns true after modified files are saved", ->
-      pane1.itemAtIndex(0).shouldPromptToSave = -> true
-      pane2.itemAtIndex(0).shouldPromptToSave = -> true
-      spyOn(atom, "confirm").andReturn(0)
-
-      saved = container.confirmClose()
-
-      runs ->
-        expect(saved).toBeTruthy()
-        expect(atom.confirm).toHaveBeenCalled()
-
-    it "returns false if the user cancels saving", ->
-      pane1.itemAtIndex(0).shouldPromptToSave = -> true
-      pane2.itemAtIndex(0).shouldPromptToSave = -> true
-      spyOn(atom, "confirm").andReturn(1)
-
-      saved = container.confirmClose()
-
-      runs ->
-        expect(saved).toBeFalsy()
-        expect(atom.confirm).toHaveBeenCalled()
-
   describe "serialization", ->
     it "can be serialized and deserialized, and correctly adjusts dimensions of deserialized panes after attach", ->
-      newContainer = new PaneContainerView(container.model.testSerialization())
-      expect(newContainer.find('.pane-row > :contains(1)')).toExist()
-      expect(newContainer.find('.pane-row > .pane-column > :contains(2)')).toExist()
-      expect(newContainer.find('.pane-row > .pane-column > :contains(3)')).toExist()
+      newContainer = atom.workspace.getView(container.model.testSerialization()).__spacePenView
+      expect(newContainer.find('atom-pane-axis.horizontal > :contains(1)')).toExist()
+      expect(newContainer.find('atom-pane-axis.horizontal > atom-pane-axis.vertical > :contains(2)')).toExist()
+      expect(newContainer.find('atom-pane-axis.horizontal > atom-pane-axis.vertical > :contains(3)')).toExist()
 
       newContainer.height(200).width(300).attachToDom()
-      expect(newContainer.find('.pane-row > :contains(1)').width()).toBe 150
-      expect(newContainer.find('.pane-row > .pane-column > :contains(2)').height()).toBe 100
+      expect(newContainer.find('atom-pane-axis.horizontal > :contains(1)').width()).toBe 150
+      expect(newContainer.find('atom-pane-axis.horizontal > atom-pane-axis.vertical > :contains(2)').height()).toBe 100
 
     describe "if there are empty panes after deserialization", ->
       beforeEach ->
@@ -111,15 +89,15 @@ describe "PaneContainerView", ->
 
       describe "if the 'core.destroyEmptyPanes' config option is false (the default)", ->
         it "leaves the empty panes intact", ->
-          newContainer = new PaneContainerView(container.model.testSerialization())
-          expect(newContainer.find('.pane-row > :contains(1)')).toExist()
-          expect(newContainer.find('.pane-row > .pane-column > .pane').length).toBe 2
+          newContainer = atom.workspace.getView(container.model.testSerialization()).__spacePenView
+          expect(newContainer.find('atom-pane-axis.horizontal > :contains(1)')).toExist()
+          expect(newContainer.find('atom-pane-axis.horizontal > atom-pane-axis.vertical > atom-pane').length).toBe 2
 
       describe "if the 'core.destroyEmptyPanes' config option is true", ->
         it "removes empty panes on deserialization", ->
           atom.config.set('core.destroyEmptyPanes', true)
-          newContainer = new PaneContainerView(container.model.testSerialization())
-          expect(newContainer.find('.pane-row, .pane-column')).not.toExist()
+          newContainer = atom.workspace.getView(container.model.testSerialization()).__spacePenView
+          expect(newContainer.find('atom-pane-axis.horizontal, atom-pane-axis.vertical')).not.toExist()
           expect(newContainer.find('> :contains(1)')).toExist()
 
   describe "pane-container:active-pane-item-changed", ->
@@ -131,7 +109,7 @@ describe "PaneContainerView", ->
       item2b = new TestView('2b')
       item3a = new TestView('3a')
 
-      container = new PaneContainerView
+      container = atom.workspace.getView(new PaneContainer).__spacePenView
       pane1 = container.getRoot()
       pane1.activateItem(item1a)
       container.attachToDom()
@@ -281,7 +259,7 @@ describe "PaneContainerView", ->
       # |7|8|9|
       # -------
 
-      container = new PaneContainerView
+      container = atom.workspace.getView(new PaneContainer).__spacePenView
       pane1 = container.getRoot()
       pane1.activateItem(new TestView('1'))
       pane4 = pane1.splitDown(new TestView('4'))

spec/pane-view-spec.coffee

@@ -1,4 +1,4 @@
-PaneContainerView = require '../src/pane-container-view'
+PaneContainer = require '../src/pane-container'
 PaneView = require '../src/pane-view'
 fs = require 'fs-plus'
 {Emitter} = require 'event-kit'
@@ -24,7 +24,7 @@ describe "PaneView", ->
 
   beforeEach ->
     deserializerDisposable = atom.deserializers.add(TestView)
-    container = new PaneContainerView
+    container = atom.workspace.getView(new PaneContainer).__spacePenView
     containerModel = container.model
     view1 = new TestView(id: 'view-1', text: 'View 1')
     view2 = new TestView(id: 'view-2', text: 'View 2')
@@ -131,9 +131,9 @@ describe "PaneView", ->
     describe "when the destroyed item is a model", ->
       it "removes the associated view", ->
         paneModel.activateItem(editor1)
-        expect(pane.itemViews.find('.editor').length).toBe 1
+        expect(pane.itemViews.find('atom-text-editor').length).toBe 1
         pane.destroyItem(editor1)
-        expect(pane.itemViews.find('.editor').length).toBe 0
+        expect(pane.itemViews.find('atom-text-editor').length).toBe 0
 
   describe "when an item is moved within the same pane", ->
     it "emits a 'pane:item-moved' event with the item and the new index", ->
@@ -289,7 +289,7 @@ describe "PaneView", ->
       expect(paneModel.isActive()).toBe true
 
   describe "when a pane is split", ->
-    it "builds the appropriate pane-row and pane-column views", ->
+    it "builds the appropriateatom-pane-axis.horizontal and pane-column views", ->
       pane1 = pane
       pane1Model = pane.getModel()
       pane.activateItem(editor1)
@@ -300,24 +300,24 @@ describe "PaneView", ->
       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]]
+      expect(container.find('> atom-pane-axis.horizontal > atom-pane').toArray()).toEqual [pane1[0]]
+      expect(container.find('> atom-pane-axis.horizontal > atom-pane-axis.vertical > atom-pane').toArray()).toEqual [pane2[0], pane3[0]]
 
       pane1Model.destroy()
-      expect(container.find('> .pane-column > .pane').toArray()).toEqual [pane2[0], pane3[0]]
+      expect(container.find('> atom-pane-axis.vertical > atom-pane').toArray()).toEqual [pane2[0], pane3[0]]
 
   describe "serialization", ->
     it "focuses the pane after attach only if had focus when serialized", ->
       container.attachToDom()
       pane.focus()
 
-      container2 = new PaneContainerView(container.model.testSerialization())
+      container2 = atom.workspace.getView(container.model.testSerialization()).__spacePenView
       pane2 = container2.getRoot()
       container2.attachToDom()
       expect(pane2).toMatchSelector(':has(:focus)')
 
       $(document.activeElement).blur()
-      container3 = new PaneContainerView(container.model.testSerialization())
+      container3 = atom.workspace.getView(container.model.testSerialization()).__spacePenView
       pane3 = container3.getRoot()
       container3.attachToDom()
       expect(pane3).not.toMatchSelector(':has(:focus)')

spec/panel-container-element-spec.coffee

@@ -0,0 +1,63 @@
+ViewRegistry = require '../src/view-registry'
+Panel = require '../src/panel'
+PanelElement = require '../src/panel-element'
+PanelContainer = require '../src/panel-container'
+PanelContainerElement = require '../src/panel-container-element'
+
+describe "PanelContainerElement", ->
+  [jasmineContent, element, container, viewRegistry] = []
+
+  class TestPanelContainerItem
+    constructior: ->
+
+  class TestPanelContainerItemElement extends HTMLElement
+    createdCallback: ->
+      @classList.add('test-root')
+    setModel: (@model) ->
+  TestPanelContainerItemElement = document.registerElement 'atom-test-container-item-element', prototype: TestPanelContainerItemElement.prototype
+
+  beforeEach ->
+    jasmineContent = document.body.querySelector('#jasmine-content')
+
+    viewRegistry = new ViewRegistry
+    viewRegistry.addViewProvider
+      modelConstructor: Panel
+      viewConstructor: PanelElement
+    viewRegistry.addViewProvider
+      modelConstructor: PanelContainer
+      viewConstructor: PanelContainerElement
+    viewRegistry.addViewProvider
+      modelConstructor: TestPanelContainerItem
+      viewConstructor: TestPanelContainerItemElement
+
+    container = new PanelContainer({viewRegistry, location: 'left'})
+    element = container.getView()
+    jasmineContent.appendChild(element)
+
+  it 'has a location attribute with value from the model', ->
+    expect(element.getAttribute('location')).toBe 'left'
+
+  it 'removes the element when the container is destroyed', ->
+    expect(element.parentNode).toBe jasmineContent
+    container.destroy()
+    expect(element.parentNode).not.toBe jasmineContent
+
+  describe "adding and removing panels", ->
+    it "adds atom-panel elements when a new panel is added to the container; removes them when the panels are destroyed", ->
+      expect(element.childNodes.length).toBe 0
+
+      panel1 = new Panel({viewRegistry, item: new TestPanelContainerItem(), location: 'left'})
+      container.addPanel(panel1)
+      expect(element.childNodes.length).toBe 1
+
+      expect(element.childNodes[0].tagName).toBe 'ATOM-PANEL'
+
+      panel2 = new Panel({viewRegistry, item: new TestPanelContainerItem(), location: 'left'})
+      container.addPanel(panel2)
+      expect(element.childNodes.length).toBe 2
+
+      panel1.destroy()
+      expect(element.childNodes.length).toBe 1
+
+      panel2.destroy()
+      expect(element.childNodes.length).toBe 0

spec/panel-container-spec.coffee

@@ -0,0 +1,98 @@
+ViewRegistry = require '../src/view-registry'
+Panel = require '../src/panel'
+PanelContainer = require '../src/panel-container'
+
+describe "PanelContainer", ->
+  [container, viewRegistry] = []
+
+  class TestPanelItem
+    constructior: ->
+
+  beforeEach ->
+    viewRegistry = new ViewRegistry
+    container = new PanelContainer({viewRegistry})
+
+  describe "::addPanel(panel)", ->
+    it 'emits an onDidAddPanel event with the index the panel was inserted at', ->
+      container.onDidAddPanel addPanelSpy = jasmine.createSpy()
+
+      panel1 = new Panel(item: new TestPanelItem())
+      container.addPanel(panel1)
+      expect(addPanelSpy).toHaveBeenCalledWith({panel: panel1, index: 0})
+
+      panel2 = new Panel(item: new TestPanelItem())
+      container.addPanel(panel2)
+      expect(addPanelSpy).toHaveBeenCalledWith({panel: panel2, index: 1})
+
+  describe "when a panel is destroyed", ->
+    it 'emits an onDidRemovePanel event with the index of the removed item', ->
+      container.onDidRemovePanel removePanelSpy = jasmine.createSpy()
+
+      panel1 = new Panel(item: new TestPanelItem())
+      container.addPanel(panel1)
+      panel2 = new Panel(item: new TestPanelItem())
+      container.addPanel(panel2)
+
+      expect(removePanelSpy).not.toHaveBeenCalled()
+
+      panel2.destroy()
+      expect(removePanelSpy).toHaveBeenCalledWith({panel: panel2, index: 1})
+
+      panel1.destroy()
+      expect(removePanelSpy).toHaveBeenCalledWith({panel: panel1, index: 0})
+
+  describe "panel priority", ->
+    describe 'left / top panel container', ->
+      [initialPanel] = []
+      beforeEach ->
+        # 'left' logic is the same as 'top'
+        container = new PanelContainer({viewRegistry, location: 'left'})
+        initialPanel = new Panel(item: new TestPanelItem())
+        container.addPanel(initialPanel)
+
+      describe 'when a panel with low priority is added', ->
+        it 'is inserted at the beginning of the list', ->
+          container.onDidAddPanel addPanelSpy = jasmine.createSpy()
+          panel = new Panel(item: new TestPanelItem(), priority: 0)
+          container.addPanel(panel)
+
+          expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0})
+          expect(container.getPanels()[0]).toBe panel
+
+      describe 'when a panel with priority between two other panels is added', ->
+        it 'is inserted at the between the two panels', ->
+          panel = new Panel(item: new TestPanelItem(), priority: 1000)
+          container.addPanel(panel)
+
+          container.onDidAddPanel addPanelSpy = jasmine.createSpy()
+          panel = new Panel(item: new TestPanelItem(), priority: 101)
+          container.addPanel(panel)
+
+          expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 1})
+          expect(container.getPanels()[1]).toBe panel
+
+    describe 'right / bottom panel container', ->
+      [initialPanel] = []
+      beforeEach ->
+        # 'bottom' logic is the same as 'right'
+        container = new PanelContainer({viewRegistry, location: 'right'})
+        initialPanel = new Panel(item: new TestPanelItem())
+        container.addPanel(initialPanel)
+
+      describe 'when a panel with high priority is added', ->
+        it 'is inserted at the beginning of the list', ->
+          container.onDidAddPanel addPanelSpy = jasmine.createSpy()
+          panel = new Panel(item: new TestPanelItem(), priority: 1000)
+          container.addPanel(panel)
+
+          expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0})
+          expect(container.getPanels()[0]).toBe panel
+
+      describe 'when a panel with low priority is added', ->
+        it 'is inserted at the end of the list', ->
+          container.onDidAddPanel addPanelSpy = jasmine.createSpy()
+          panel = new Panel(item: new TestPanelItem(), priority: 0)
+          container.addPanel(panel)
+
+          expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 1})
+          expect(container.getPanels()[1]).toBe panel

spec/panel-element-spec.coffee

@@ -0,0 +1,56 @@
+ViewRegistry = require '../src/view-registry'
+Panel = require '../src/panel'
+PanelElement = require '../src/panel-element'
+
+describe "PanelElement", ->
+  [jasmineContent, element, panel, viewRegistry] = []
+
+  class TestPanelItem
+    constructior: ->
+
+  class TestPanelItemElement extends HTMLElement
+    createdCallback: ->
+      @classList.add('test-root')
+    setModel: (@model) ->
+  TestPanelItemElement = document.registerElement 'atom-test-item-element', prototype: TestPanelItemElement.prototype
+
+  beforeEach ->
+    jasmineContent = document.body.querySelector('#jasmine-content')
+
+    viewRegistry = new ViewRegistry
+    viewRegistry.addViewProvider
+      modelConstructor: Panel
+      viewConstructor: PanelElement
+    viewRegistry.addViewProvider
+      modelConstructor: TestPanelItem
+      viewConstructor: TestPanelItemElement
+
+  it 'removes the element when the panel is destroyed', ->
+    panel = new Panel({viewRegistry, item: new TestPanelItem})
+    element = panel.getView()
+    jasmineContent.appendChild(element)
+
+    expect(element.parentNode).toBe jasmineContent
+    panel.destroy()
+    expect(element.parentNode).not.toBe jasmineContent
+
+  describe "changing panel visibility", ->
+    it 'initially renders panel created with visibile: false', ->
+      panel = new Panel({viewRegistry, visible: false, item: new TestPanelItem})
+      element = panel.getView()
+      jasmineContent.appendChild(element)
+
+      expect(element.style.display).toBe 'none'
+
+    it 'hides and shows the panel element when Panel::hide() and Panel::show() are called', ->
+      panel = new Panel({viewRegistry, item: new TestPanelItem})
+      element = panel.getView()
+      jasmineContent.appendChild(element)
+
+      expect(element.style.display).not.toBe 'none'
+
+      panel.hide()
+      expect(element.style.display).toBe 'none'
+
+      panel.show()
+      expect(element.style.display).not.toBe 'none'

spec/panel-spec.coffee

@@ -0,0 +1,23 @@
+Panel = require '../src/panel'
+
+describe "Panel", ->
+  [panel] = []
+
+  class TestPanelItem
+    constructior: ->
+
+  beforeEach ->
+    panel = new Panel(item: new TestPanelItem())
+
+  describe "changing panel visibility", ->
+    it 'emits an event when visibility changes', ->
+      panel.onDidChangeVisible spy = jasmine.createSpy()
+
+      panel.hide()
+      expect(panel.isVisible()).toBe false
+      expect(spy).toHaveBeenCalledWith(false)
+      spy.reset()
+
+      panel.show()
+      expect(panel.isVisible()).toBe true
+      expect(spy).toHaveBeenCalledWith(true)

spec/project-spec.coffee

@@ -9,7 +9,7 @@ BufferedProcess = require '../src/buffered-process'
 
 describe "Project", ->
   beforeEach ->
-    atom.project.setPath(atom.project.resolve('dir'))
+    atom.project.setPaths([atom.project.resolve('dir')])
 
   describe "serialization", ->
     deserializedProject = null
@@ -41,8 +41,8 @@ describe "Project", ->
   describe "when an editor is saved and the project has no path", ->
     it "sets the project's path to the saved file's parent directory", ->
       tempFile = temp.openSync().path
-      atom.project.setPath(undefined)
-      expect(atom.project.getPath()).toBeUndefined()
+      atom.project.setPaths([])
+      expect(atom.project.getPaths()[0]).toBeUndefined()
       editor = null
 
       waitsForPromise ->
@@ -50,7 +50,7 @@ describe "Project", ->
 
       runs ->
         editor.saveAs(tempFile)
-        expect(atom.project.getPath()).toBe path.dirname(tempFile)
+        expect(atom.project.getPaths()[0]).toBe path.dirname(tempFile)
 
   describe ".open(path)", ->
     [absolutePath, newBufferHandler] = []
@@ -164,7 +164,7 @@ describe "Project", ->
 
     describe "when the project has no path", ->
       it "returns undefined for relative URIs", ->
-        atom.project.setPath()
+        atom.project.setPaths([])
         expect(atom.project.resolve('test.txt')).toBeUndefined()
         expect(atom.project.resolve('http://github.com')).toBe 'http://github.com'
         absolutePath = fs.absolute(__dirname)
@@ -173,33 +173,33 @@ describe "Project", ->
   describe ".setPath(path)", ->
     describe "when path is a file", ->
       it "sets its path to the files parent directory and updates the root directory", ->
-        atom.project.setPath(require.resolve('./fixtures/dir/a'))
-        expect(atom.project.getPath()).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
+        atom.project.setPaths([require.resolve('./fixtures/dir/a')])
+        expect(atom.project.getPaths()[0]).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
         expect(atom.project.getRootDirectory().path).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
 
     describe "when path is a directory", ->
       it "sets its path to the directory and updates the root directory", ->
         directory = fs.absolute(path.join(__dirname, 'fixtures', 'dir', 'a-dir'))
-        atom.project.setPath(directory)
-        expect(atom.project.getPath()).toEqual directory
+        atom.project.setPaths([directory])
+        expect(atom.project.getPaths()[0]).toEqual directory
         expect(atom.project.getRootDirectory().path).toEqual directory
 
     describe "when path is null", ->
       it "sets its path and root directory to null", ->
-        atom.project.setPath(null)
-        expect(atom.project.getPath()?).toBeFalsy()
+        atom.project.setPaths([])
+        expect(atom.project.getPaths()[0]?).toBeFalsy()
         expect(atom.project.getRootDirectory()?).toBeFalsy()
 
     it "normalizes the path to remove consecutive slashes, ., and .. segments", ->
-      atom.project.setPath("#{require.resolve('./fixtures/dir/a')}#{path.sep}b#{path.sep}#{path.sep}..")
-      expect(atom.project.getPath()).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
+      atom.project.setPaths(["#{require.resolve('./fixtures/dir/a')}#{path.sep}b#{path.sep}#{path.sep}.."])
+      expect(atom.project.getPaths()[0]).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
       expect(atom.project.getRootDirectory().path).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
 
   describe ".replace()", ->
     [filePath, commentFilePath, sampleContent, sampleCommentContent] = []
 
     beforeEach ->
-      atom.project.setPath(atom.project.resolve('../'))
+      atom.project.setPaths([atom.project.resolve('../')])
 
       filePath = atom.project.resolve('sample.js')
       commentFilePath = atom.project.resolve('sample-with-comments.js')
@@ -332,7 +332,7 @@ describe "Project", ->
 
       it "works on evil filenames", ->
         platform.generateEvilFiles()
-        atom.project.setPath(path.join(__dirname, 'fixtures', 'evil-files'))
+        atom.project.setPaths([path.join(__dirname, 'fixtures', 'evil-files')])
         paths = []
         matches = []
         waitsForPromise ->
@@ -387,7 +387,7 @@ describe "Project", ->
           fs.removeSync(projectPath) if fs.existsSync(projectPath)
 
         it "excludes ignored files", ->
-          atom.project.setPath(projectPath)
+          atom.project.setPaths([projectPath])
           atom.config.set('core.excludeVcsIgnoredPaths', true)
           resultHandler = jasmine.createSpy("result found")
           waitsForPromise ->
@@ -399,7 +399,7 @@ describe "Project", ->
 
       it "includes only files when a directory filter is specified", ->
         projectPath = path.join(path.join(__dirname, 'fixtures', 'dir'))
-        atom.project.setPath(projectPath)
+        atom.project.setPaths([projectPath])
 
         filePath = path.join(projectPath, 'a-dir', 'oh-git')
 
@@ -419,7 +419,7 @@ describe "Project", ->
         projectPath = temp.mkdirSync()
         filePath = path.join(projectPath, '.text')
         fs.writeFileSync(filePath, 'match this')
-        atom.project.setPath(projectPath)
+        atom.project.setPaths([projectPath])
         paths = []
         matches = []
         waitsForPromise ->

spec/spec-helper.coffee

@@ -2,6 +2,7 @@ require '../src/window'
 atom.initialize()
 atom.restoreWindowDimensions()
 
+require 'jasmine-json'
 require '../vendor/jasmine-jquery'
 path = require 'path'
 _ = require 'underscore-plus'
@@ -28,17 +29,23 @@ atom.packages.packageDirPaths.unshift(fixturePackagesPath)
 atom.keymaps.loadBundledKeymaps()
 keyBindingsToRestore = atom.keymaps.getKeyBindings()
 commandsToRestore = atom.commands.getSnapshot()
+styleElementsToRestore = atom.styles.getSnapshot()
 
-$(window).on 'core:close', -> window.close()
-$(window).on 'beforeunload', ->
+window.addEventListener 'core:close', -> window.close()
+window.addEventListener 'beforeunload', ->
   atom.storeWindowDimensions()
   atom.saveSync()
 $('html,body').css('overflow', 'auto')
 
+# Allow document.title to be assigned in specs without screwing up spec window title
+documentTitle = null
+Object.defineProperty document, 'title',
+  get: -> documentTitle
+  set: (title) -> documentTitle = title
+
 jasmine.getEnv().addEqualityTester(_.isEqual) # Use underscore's definition of equality for toEqual assertions
 
-if process.platform is 'win32' and process.env.JANKY_SHA1
-  # Use longer timeout on Windows CI
+if process.env.JANKY_SHA1 and process.platform is 'win32'
   jasmine.getEnv().defaultTimeoutInterval = 60000
 else
   jasmine.getEnv().defaultTimeoutInterval = 5000
@@ -61,12 +68,13 @@ isCoreSpec = specDirectory == fs.realpathSync(__dirname)
 beforeEach ->
   Grim.clearDeprecations() if isCoreSpec
   $.fx.off = true
+  documentTitle = null
   projectPath = specProjectPath ? path.join(@specDirectory, 'fixtures')
-  atom.project = new Project(path: projectPath)
+  atom.project = new Project(paths: [projectPath])
   atom.workspace = new Workspace()
   atom.keymaps.keyBindings = _.clone(keyBindingsToRestore)
-  atom.commands.setRootNode(document.body)
   atom.commands.restoreSnapshot(commandsToRestore)
+  atom.styles.restoreSnapshot(styleElementsToRestore)
 
   window.resetTimeouts()
   atom.packages.packageStates = {}
@@ -75,7 +83,6 @@ beforeEach ->
 
   spyOn(atom, 'saveSync')
   atom.syntax.clearGrammarOverrides()
-  atom.syntax.clearProperties()
 
   spy = spyOn(atom.packages, 'resolvePackagePath').andCallFake (packageName) ->
     if specPackageName and packageName is specPackageName
@@ -106,7 +113,7 @@ beforeEach ->
   spyOn(TextEditorView.prototype, 'requestDisplayUpdate').andCallFake -> @updateDisplay()
   TextEditorComponent.performSyncUpdates = true
 
-  spyOn(WorkspaceView.prototype, 'setTitle').andCallFake (@title) ->
+  spyOn(atom, "setRepresentedFilename")
   spyOn(window, "setTimeout").andCallFake window.fakeSetTimeout
   spyOn(window, "clearTimeout").andCallFake window.fakeClearTimeout
   spyOn(pathwatcher.File.prototype, "detectResurrectionAfterDelay").andCallFake -> @detectResurrection()
@@ -125,6 +132,7 @@ beforeEach ->
 afterEach ->
   atom.packages.deactivatePackages()
   atom.menu.template = []
+  atom.contextMenu.clear()
 
   atom.workspaceView?.remove?()
   atom.workspaceView = null
@@ -217,7 +225,7 @@ addCustomMatchers = (spec) ->
       notText = if @isNot then " not" else ""
       element = @actual
       element = element.get(0) if element.jquery
-      @message = -> return "Expected element '#{element}' or its descendants #{notText} to show."
+      @message = -> return "Expected element '#{element}' or its descendants#{notText} to show."
       element.style.display in ['block', 'inline-block', 'static', 'fixed']
 
 window.keyIdentifierForKey = (key) ->
@@ -343,14 +351,10 @@ $.fn.resultOfTrigger = (type) ->
   event.result
 
 $.fn.enableKeymap = ->
-  @on 'keydown', (e) ->
-    originalEvent = e.originalEvent ? e
-    Object.defineProperty(originalEvent, 'target', get: -> e.target) unless originalEvent.target?
-    atom.keymaps.handleKeyboardEvent(originalEvent)
-    not e.originalEvent.defaultPrevented
+  @element.addEventListener 'keydown', (event) -> atom.keymaps.handleKeyboardEvent(event)
 
 $.fn.attachToDom = ->
-  @appendTo($('#jasmine-content'))
+  @appendTo($('#jasmine-content')) unless @isOnDom()
 
 $.fn.simulateDomAttachment = ->
   $('<html>').append(this)

spec/style-manager-spec.coffee

@@ -0,0 +1,66 @@
+StyleManager = require '../src/style-manager'
+
+describe "StyleManager", ->
+  [manager, addEvents, removeEvents, updateEvents] = []
+
+  beforeEach ->
+    manager = new StyleManager
+    addEvents = []
+    removeEvents = []
+    updateEvents = []
+
+    manager.onDidAddStyleElement (event) -> addEvents.push(event)
+    manager.onDidRemoveStyleElement (event) -> removeEvents.push(event)
+    manager.onDidUpdateStyleElement (event) -> updateEvents.push(event)
+
+  describe "::addStyleSheet(source, params)", ->
+    it "adds a stylesheet based on the given source and returns a disposable allowing it to be removed", ->
+      disposable = manager.addStyleSheet("a {color: red;}")
+
+      expect(addEvents.length).toBe 1
+      expect(addEvents[0].textContent).toBe "a {color: red;}"
+
+      styleElements = manager.getStyleElements()
+      expect(styleElements.length).toBe 1
+      expect(styleElements[0].textContent).toBe "a {color: red;}"
+
+      disposable.dispose()
+
+      expect(removeEvents.length).toBe 1
+      expect(removeEvents[0].textContent).toBe "a {color: red;}"
+      expect(manager.getStyleElements().length).toBe 0
+
+    describe "when a sourcePath parameter is specified", ->
+      it "ensures a maximum of one style element for the given source path, updating a previous if it exists", ->
+        disposable1 = manager.addStyleSheet("a {color: red;}", sourcePath: '/foo/bar')
+
+        expect(addEvents.length).toBe 1
+        expect(addEvents[0].getAttribute('source-path')).toBe '/foo/bar'
+
+        disposable2 = manager.addStyleSheet("a {color: blue;}", sourcePath: '/foo/bar')
+
+        expect(addEvents.length).toBe 1
+        expect(updateEvents.length).toBe 1
+        expect(updateEvents[0].getAttribute('source-path')).toBe '/foo/bar'
+        expect(updateEvents[0].textContent).toBe "a {color: blue;}"
+
+        disposable2.dispose()
+        addEvents = []
+
+        manager.addStyleSheet("a {color: yellow;}", sourcePath: '/foo/bar')
+
+        expect(addEvents.length).toBe 1
+        expect(addEvents[0].getAttribute('source-path')).toBe '/foo/bar'
+        expect(addEvents[0].textContent).toBe "a {color: yellow;}"
+
+    describe "when a group parameter is specified", ->
+      it "inserts the stylesheet at the end of any existing stylesheets for the same group", ->
+        manager.addStyleSheet("a {color: red}", group: 'a')
+        manager.addStyleSheet("a {color: blue}", group: 'b')
+        manager.addStyleSheet("a {color: green}", group: 'a')
+
+        expect(manager.getStyleElements().map (elt) -> elt.textContent).toEqual [
+          "a {color: red}"
+          "a {color: green}"
+          "a {color: blue}"
+        ]

spec/styles-element-spec.coffee

@@ -0,0 +1,54 @@
+StylesElement = require '../src/styles-element'
+StyleManager = require '../src/style-manager'
+
+describe "StylesElement", ->
+  [element, addedStyleElements, removedStyleElements, updatedStyleElements] = []
+
+  beforeEach ->
+    element = new StylesElement
+    document.querySelector('#jasmine-content').appendChild(element)
+    addedStyleElements = []
+    removedStyleElements = []
+    updatedStyleElements = []
+    element.onDidAddStyleElement (element) -> addedStyleElements.push(element)
+    element.onDidRemoveStyleElement (element) -> removedStyleElements.push(element)
+    element.onDidUpdateStyleElement (element) -> updatedStyleElements.push(element)
+
+  it "renders a style tag for all currently active stylesheets in the style manager", ->
+    initialChildCount = element.children.length
+
+    disposable1 = atom.styles.addStyleSheet("a {color: red;}")
+    expect(element.children.length).toBe initialChildCount + 1
+    expect(element.children[initialChildCount].textContent).toBe "a {color: red;}"
+    expect(addedStyleElements).toEqual [element.children[initialChildCount]]
+
+    disposable2 = atom.styles.addStyleSheet("a {color: blue;}")
+    expect(element.children.length).toBe initialChildCount + 2
+    expect(element.children[initialChildCount + 1].textContent).toBe "a {color: blue;}"
+    expect(addedStyleElements).toEqual [element.children[initialChildCount], element.children[initialChildCount + 1]]
+
+    disposable1.dispose()
+    expect(element.children.length).toBe initialChildCount + 1
+    expect(element.children[initialChildCount].textContent).toBe "a {color: blue;}"
+    expect(removedStyleElements).toEqual [addedStyleElements[0]]
+
+  it "orders style elements by group", ->
+    initialChildCount = element.children.length
+
+    atom.styles.addStyleSheet("a {color: red}", group: 'a')
+    atom.styles.addStyleSheet("a {color: blue}", group: 'b')
+    atom.styles.addStyleSheet("a {color: green}", group: 'a')
+
+    expect(element.children[initialChildCount].textContent).toBe "a {color: red}"
+    expect(element.children[initialChildCount + 1].textContent).toBe "a {color: green}"
+    expect(element.children[initialChildCount + 2].textContent).toBe "a {color: blue}"
+
+  it "updates existing style nodes when style elements are updated", ->
+    initialChildCount = element.children.length
+
+    atom.styles.addStyleSheet("a {color: red;}", sourcePath: '/foo/bar')
+    atom.styles.addStyleSheet("a {color: blue;}", sourcePath: '/foo/bar')
+
+    expect(element.children.length).toBe initialChildCount + 1
+    expect(element.children[initialChildCount].textContent).toBe "a {color: blue;}"
+    expect(updatedStyleElements).toEqual [element.children[initialChildCount]]

spec/text-editor-component-spec.coffee

@@ -277,7 +277,7 @@ describe "TextEditorComponent", ->
         expect(leafNodes[0].classList.contains('invisible-character')).toBe true
         expect(leafNodes[leafNodes.length - 1].classList.contains('invisible-character')).toBe true
 
-      it "displays newlines as their own token outside of the other tokens' scopes", ->
+      it "displays newlines as their own token outside of the other tokens' scopeDescriptor", ->
         editor.setText "var\n"
         nextAnimationFrame()
         expect(component.lineNodeForScreenRow(0).innerHTML).toBe "<span class=\"source js\"><span class=\"storage modifier js\">var</span></span><span class=\"invisible-character\">#{invisibles.eol}</span>"
@@ -446,12 +446,6 @@ describe "TextEditorComponent", ->
         foldedLineNode = component.lineNodeForScreenRow(4)
         expect(foldedLineNode.querySelector('.fold-marker')).toBeFalsy()
 
-    getLeafNodes = (node) ->
-      if node.children.length > 0
-        flatten(toArray(node.children).map(getLeafNodes))
-      else
-        [node]
-
   describe "gutter rendering", ->
     [gutter] = []
 
@@ -704,6 +698,24 @@ describe "TextEditorComponent", ->
       expect(cursorRect.left).toBe rangeRect.left
       expect(cursorRect.width).toBe rangeRect.width
 
+    it "accounts for the width of paired characters when positioning cursors", ->
+      atom.config.set('editor.fontFamily', 'sans-serif')
+      editor.setText('he\u0301y') # e with an accent mark
+      editor.setCursorBufferPosition([0, 3])
+      nextAnimationFrame()
+
+      cursor = componentNode.querySelector('.cursor')
+      cursorRect = cursor.getBoundingClientRect()
+
+      cursorLocationTextNode = component.lineNodeForScreenRow(0).querySelector('.source.js').firstChild
+      range = document.createRange()
+      range.setStart(cursorLocationTextNode, 3)
+      range.setEnd(cursorLocationTextNode, 4)
+      rangeRect = range.getBoundingClientRect()
+
+      expect(cursorRect.left).toBe rangeRect.left
+      expect(cursorRect.width).toBe rangeRect.width
+
     it "positions cursors correctly after character widths are changed via a stylesheet change", ->
       atom.config.set('editor.fontFamily', 'sans-serif')
       editor.setCursorScreenPosition([0, 16])
@@ -1236,6 +1248,22 @@ describe "TextEditorComponent", ->
     beforeEach ->
       linesNode = componentNode.querySelector('.lines')
 
+    describe "when the mouse is single-clicked below the last line", ->
+      it "moves the cursor to the end of file buffer position", ->
+        editor.setText('foo')
+        editor.setCursorBufferPosition([0, 0])
+        height = 4.5 * lineHeightInPixels
+        wrapperNode.style.height = height + 'px'
+        wrapperNode.style.width = 10 * charWidth + 'px'
+        component.measureHeightAndWidth()
+        nextAnimationFrame()
+
+        coordinates = clientCoordinatesForScreenPosition([0, 2])
+        coordinates.clientY = height * 2
+        linesNode.dispatchEvent(buildMouseEvent('mousedown', coordinates))
+        nextAnimationFrame()
+        expect(editor.getCursorScreenPosition()).toEqual [0, 3]
+
     describe "when a non-folded line is single-clicked", ->
       describe "when no modifier keys are held down", ->
         it "moves the cursor to the nearest screen position", ->
@@ -2214,7 +2242,6 @@ describe "TextEditorComponent", ->
     it "does not render invisible characters", ->
       atom.config.set('editor.invisibles', eol: 'E')
       atom.config.set('editor.showInvisibles', true)
-      nextAnimationFrame()
       expect(component.lineNodeForScreenRow(0).textContent).toBe 'var quicksort = function () {'
 
     it "does not assign an explicit line-height on the editor contents", ->
@@ -2268,6 +2295,140 @@ describe "TextEditorComponent", ->
 
       expect(editor.getCursorBufferPosition()).toEqual [0, 1]
 
+  describe 'scoped config settings', ->
+    [coffeeEditor, coffeeComponent] = []
+
+    beforeEach ->
+      waitsForPromise ->
+        atom.packages.activatePackage('language-coffee-script')
+      waitsForPromise ->
+        atom.project.open('coffee.coffee', autoIndent: false).then (o) -> coffeeEditor = o
+
+    afterEach: ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
+    describe 'soft wrap settings', ->
+      beforeEach ->
+        atom.config.set '.source.coffee', 'editor.softWrap', true
+        atom.config.set '.source.coffee', 'editor.preferredLineLength', 17
+        atom.config.set '.source.coffee', 'editor.softWrapAtPreferredLineLength', true
+
+        editor.setEditorWidthInChars(20)
+        coffeeEditor.setEditorWidthInChars(20)
+
+      it "wraps lines when editor.softWrap is true for a matching scope", ->
+        expect(editor.lineTextForScreenRow(2)).toEqual '    if (items.length <= 1) return items;'
+        expect(coffeeEditor.lineTextForScreenRow(3)).toEqual '    return items '
+
+      it 'updates the wrapped lines when editor.preferredLineLength changes', ->
+        atom.config.set '.source.coffee', 'editor.preferredLineLength', 20
+        expect(coffeeEditor.lineTextForScreenRow(2)).toEqual '    return items if '
+
+      it 'updates the wrapped lines when editor.softWrapAtPreferredLineLength changes', ->
+        atom.config.set '.source.coffee', 'editor.softWrapAtPreferredLineLength', false
+        expect(coffeeEditor.lineTextForScreenRow(2)).toEqual '    return items if '
+
+      it 'updates the wrapped lines when editor.softWrap changes', ->
+        atom.config.set '.source.coffee', 'editor.softWrap', false
+        expect(coffeeEditor.lineTextForScreenRow(2)).toEqual '    return items if items.length <= 1'
+
+        atom.config.set '.source.coffee', 'editor.softWrap', true
+        expect(coffeeEditor.lineTextForScreenRow(3)).toEqual '    return items '
+
+      it 'updates the wrapped lines when the grammar changes', ->
+        editor.setGrammar(coffeeEditor.getGrammar())
+        expect(editor.isSoftWrapped()).toBe true
+        expect(editor.lineTextForScreenRow(0)).toEqual 'var quicksort = '
+
+      describe '::isSoftWrapped()', ->
+        it 'returns the correct value based on the scoped settings', ->
+          expect(editor.isSoftWrapped()).toBe false
+          expect(coffeeEditor.isSoftWrapped()).toBe true
+
+    describe 'invisibles settings', ->
+      [jsInvisibles, coffeeInvisibles] = []
+      beforeEach ->
+        jsInvisibles =
+          eol: 'J'
+          space: 'A'
+          tab: 'V'
+          cr: 'A'
+
+        coffeeInvisibles =
+          eol: 'C'
+          space: 'O'
+          tab: 'F'
+          cr: 'E'
+
+        atom.config.set '.source.js', 'editor.showInvisibles', true
+        atom.config.set '.source.js', 'editor.invisibles', jsInvisibles
+
+        atom.config.set '.source.coffee', 'editor.showInvisibles', false
+        atom.config.set '.source.coffee', 'editor.invisibles', coffeeInvisibles
+
+        editor.setText " a line with tabs\tand spaces \n"
+        nextAnimationFrame()
+
+      it "renders the invisibles when editor.showInvisibles is true for a given grammar", ->
+        expect(component.lineNodeForScreenRow(0).textContent).toBe "#{jsInvisibles.space}a line with tabs#{jsInvisibles.tab}and spaces#{jsInvisibles.space}#{jsInvisibles.eol}"
+
+      it "does not render the invisibles when editor.showInvisibles is false for a given grammar", ->
+        editor.setGrammar(coffeeEditor.getGrammar())
+        nextAnimationFrame()
+        expect(component.lineNodeForScreenRow(0).textContent).toBe " a line with tabs and spaces "
+
+      it "re-renders the invisibles when the invisible settings change", ->
+        jsGrammar = editor.getGrammar()
+        editor.setGrammar(coffeeEditor.getGrammar())
+        atom.config.set '.source.coffee', 'editor.showInvisibles', true
+        nextAnimationFrame()
+        expect(component.lineNodeForScreenRow(0).textContent).toBe "#{coffeeInvisibles.space}a line with tabs#{coffeeInvisibles.tab}and spaces#{coffeeInvisibles.space}#{coffeeInvisibles.eol}"
+
+        newInvisibles =
+          eol: 'N'
+          space: 'E'
+          tab: 'W'
+          cr: 'I'
+        atom.config.set '.source.coffee', 'editor.invisibles', newInvisibles
+        nextAnimationFrame()
+        expect(component.lineNodeForScreenRow(0).textContent).toBe "#{newInvisibles.space}a line with tabs#{newInvisibles.tab}and spaces#{newInvisibles.space}#{newInvisibles.eol}"
+
+        editor.setGrammar(jsGrammar)
+        nextAnimationFrame()
+        expect(component.lineNodeForScreenRow(0).textContent).toBe "#{jsInvisibles.space}a line with tabs#{jsInvisibles.tab}and spaces#{jsInvisibles.space}#{jsInvisibles.eol}"
+
+    describe 'editor.showIndentGuide', ->
+      beforeEach ->
+        atom.config.set '.source.js', 'editor.showIndentGuide', true
+        atom.config.set '.source.coffee', 'editor.showIndentGuide', false
+
+      it "has an 'indent-guide' class when scoped editor.showIndentGuide is true, but not when scoped editor.showIndentGuide is false", ->
+        line1LeafNodes = getLeafNodes(component.lineNodeForScreenRow(1))
+        expect(line1LeafNodes[0].textContent).toBe '  '
+        expect(line1LeafNodes[0].classList.contains('indent-guide')).toBe true
+        expect(line1LeafNodes[1].classList.contains('indent-guide')).toBe false
+
+        editor.setGrammar(coffeeEditor.getGrammar())
+
+        line1LeafNodes = getLeafNodes(component.lineNodeForScreenRow(1))
+        expect(line1LeafNodes[0].textContent).toBe '  '
+        expect(line1LeafNodes[0].classList.contains('indent-guide')).toBe false
+        expect(line1LeafNodes[1].classList.contains('indent-guide')).toBe false
+
+      it "removes the 'indent-guide' class when editor.showIndentGuide to false", ->
+        line1LeafNodes = getLeafNodes(component.lineNodeForScreenRow(1))
+        expect(line1LeafNodes[0].textContent).toBe '  '
+        expect(line1LeafNodes[0].classList.contains('indent-guide')).toBe true
+        expect(line1LeafNodes[1].classList.contains('indent-guide')).toBe false
+
+        atom.config.set '.source.js', 'editor.showIndentGuide', false
+
+        line1LeafNodes = getLeafNodes(component.lineNodeForScreenRow(1))
+        expect(line1LeafNodes[0].textContent).toBe '  '
+        expect(line1LeafNodes[0].classList.contains('indent-guide')).toBe false
+        expect(line1LeafNodes[1].classList.contains('indent-guide')).toBe false
+
   buildMouseEvent = (type, properties...) ->
     properties = extend({bubbles: true, cancelable: true}, properties...)
     properties.detail ?= 1
@@ -2304,3 +2465,9 @@ describe "TextEditorComponent", ->
 
   lineHasClass = (screenRow, klass) ->
     component.lineNodeForScreenRow(screenRow).classList.contains(klass)
+
+  getLeafNodes = (node) ->
+    if node.children.length > 0
+      flatten(toArray(node.children).map(getLeafNodes))
+    else
+      [node]

spec/text-editor-element-spec.coffee

@@ -0,0 +1,36 @@
+TextEditorElement = require '../src/text-editor-element'
+
+# The rest of text-editor-component-spec will be moved to this file when React
+# is eliminated. This covers only concerns related to the wrapper element for now
+describe "TextEditorElement", ->
+  jasmineContent = null
+
+  beforeEach ->
+    jasmineContent = document.body.querySelector('#jasmine-content')
+
+  describe "instantiation", ->
+    it "honors the mini attribute", ->
+      jasmineContent.innerHTML = "<atom-text-editor mini>"
+      element = jasmineContent.firstChild
+      expect(element.getModel().isMini()).toBe true
+
+    it "honors the placeholder-text attribute", ->
+      jasmineContent.innerHTML = "<atom-text-editor placeholder-text='testing'>"
+      element = jasmineContent.firstChild
+      expect(element.getModel().getPlaceholderText()).toBe 'testing'
+
+  describe "::focus()", ->
+    it "transfers focus to the hidden text area and does not emit 'focusout' or 'blur' events", ->
+      element = new TextEditorElement
+      jasmineContent.appendChild(element)
+
+      focusoutCalled = false
+      element.addEventListener 'focusout', -> focusoutCalled = true
+      blurCalled = false
+      element.addEventListener 'blur', -> blurCalled = true
+
+      element.focus()
+      expect(focusoutCalled).toBe false
+      expect(blurCalled).toBe false
+      expect(element.hasFocus()).toBe true
+      expect(element.querySelector('input')).toBe document.activeElement

spec/text-editor-spec.coffee

@@ -113,7 +113,7 @@ describe "TextEditor", ->
         expect(editor1.isSoftWrapped()).toBe true
         expect(editor1.getSoftTabs()).toBe false
 
-        atom.config.set('editor.tabLength', 100)
+        atom.config.set('editor.tabLength', 8)
         atom.config.set('editor.softWrap', false)
         atom.config.set('editor.softTabs', true)
 
@@ -121,7 +121,7 @@ describe "TextEditor", ->
         atom.workspace.open('b').then (o) -> editor2 = o
 
       runs ->
-        expect(editor2.getTabLength()).toBe 100
+        expect(editor2.getTabLength()).toBe 8
         expect(editor2.isSoftWrapped()).toBe false
         expect(editor2.getSoftTabs()).toBe true
 
@@ -1259,7 +1259,6 @@ describe "TextEditor", ->
           editor.selectWordsContainingCursors()
           expect(editor.getSelectedText()).toBe 'var'
 
-
       describe "when the cursor is inside a region of whitespace", ->
         it "selects the whitespace region", ->
           editor.setCursorScreenPosition([5, 2])
@@ -1277,6 +1276,29 @@ describe "TextEditor", ->
           editor.selectWordsContainingCursors()
           expect(editor.getSelectedBufferRange()).toEqual [[12, 2], [12, 6]]
 
+      describe 'when editor.nonWordCharacters is set scoped to a grammar', ->
+        coffeeEditor = null
+        beforeEach ->
+          waitsForPromise ->
+            atom.packages.activatePackage('language-coffee-script')
+          waitsForPromise ->
+            atom.project.open('coffee.coffee', autoIndent: false).then (o) -> coffeeEditor = o
+
+        it 'selects the correct surrounding word for the given scoped setting', ->
+          coffeeEditor.setCursorBufferPosition [0, 9] # in the middle of quicksort
+          coffeeEditor.selectWordsContainingCursors()
+          expect(coffeeEditor.getSelectedBufferRange()).toEqual [[0, 6], [0, 15]]
+
+          atom.config.set '.source.coffee', 'editor.nonWordCharacters', 'qusort'
+
+          coffeeEditor.setCursorBufferPosition [0, 9]
+          coffeeEditor.selectWordsContainingCursors()
+          expect(coffeeEditor.getSelectedBufferRange()).toEqual [[0, 8], [0, 11]]
+
+          editor.setCursorBufferPosition [0, 7]
+          editor.selectWordsContainingCursors()
+          expect(editor.getSelectedBufferRange()).toEqual [[0, 4], [0, 13]]
+
     describe ".selectToFirstCharacterOfLine()", ->
       it "moves to the first character of the current line or the beginning of the line if it's already on the first character", ->
         editor.setCursorScreenPosition [0,5]
@@ -3038,6 +3060,51 @@ describe "TextEditor", ->
         atom.workspace.open(null, softTabs: false).then (editor) ->
           expect(editor.getSoftTabs()).toBeFalsy()
 
+  describe '.getTabLength()', ->
+    describe 'when scoped settings are used', ->
+      coffeeEditor = null
+      beforeEach ->
+        waitsForPromise ->
+          atom.packages.activatePackage('language-coffee-script')
+        waitsForPromise ->
+          atom.project.open('coffee.coffee', autoIndent: false).then (o) -> coffeeEditor = o
+
+      afterEach: ->
+        atom.packages.deactivatePackages()
+        atom.packages.unloadPackages()
+
+      it 'returns correct values based on the scope of the set grammars', ->
+        atom.config.set '.source.coffee', 'editor.tabLength', 6
+
+        expect(editor.getTabLength()).toBe 2
+        expect(coffeeEditor.getTabLength()).toBe 6
+
+      it 'retokenizes when the tab length is updated via .setTabLength()', ->
+        expect(editor.getTabLength()).toBe 2
+        expect(editor.tokenizedLineForScreenRow(5).tokens[0].firstNonWhitespaceIndex).toBe 2
+
+        editor.setTabLength(6)
+        expect(editor.getTabLength()).toBe 6
+        expect(editor.tokenizedLineForScreenRow(5).tokens[0].firstNonWhitespaceIndex).toBe 6
+
+      it 'retokenizes when the editor.tabLength setting is updated', ->
+        expect(editor.getTabLength()).toBe 2
+        expect(editor.tokenizedLineForScreenRow(5).tokens[0].firstNonWhitespaceIndex).toBe 2
+
+        atom.config.set '.source.js', 'editor.tabLength', 6
+        expect(editor.getTabLength()).toBe 6
+        expect(editor.tokenizedLineForScreenRow(5).tokens[0].firstNonWhitespaceIndex).toBe 6
+
+      it 'updates the tab length when the grammar changes', ->
+        atom.config.set '.source.coffee', 'editor.tabLength', 6
+
+        expect(editor.getTabLength()).toBe 2
+        expect(editor.tokenizedLineForScreenRow(5).tokens[0].firstNonWhitespaceIndex).toBe 2
+
+        editor.setGrammar(coffeeEditor.getGrammar())
+        expect(editor.getTabLength()).toBe 6
+        expect(editor.tokenizedLineForScreenRow(5).tokens[0].firstNonWhitespaceIndex).toBe 6
+
   describe ".indentLevelForLine(line)", ->
     it "returns the indent level when the line has only leading whitespace", ->
       expect(editor.indentLevelForLine("    hello")).toBe(2)
@@ -3077,14 +3144,15 @@ describe "TextEditor", ->
         expect(editor.tokenizedLineForScreenRow(0).tokens.length).toBeGreaterThan 1
 
   describe "auto-indent", ->
-    copyText = (text, {startColumn}={}) ->
+    copyText = (text, {startColumn, textEditor}={}) ->
       startColumn ?= 0
-      editor.setCursorBufferPosition([0, 0])
-      editor.insertText(text)
+      textEditor ?= editor
+      textEditor.setCursorBufferPosition([0, 0])
+      textEditor.insertText(text)
       numberOfNewlines = text.match(/\n/g)?.length
       endColumn = text.match(/[^\n]*$/)[0]?.length
-      editor.getLastSelection().setBufferRange([[0,startColumn], [numberOfNewlines,endColumn]])
-      editor.cutSelectedText()
+      textEditor.getLastSelection().setBufferRange([[0,startColumn], [numberOfNewlines,endColumn]])
+      textEditor.cutSelectedText()
 
     describe "editor.autoIndent", ->
       describe "when editor.autoIndent is false (default)", ->
@@ -3191,6 +3259,31 @@ describe "TextEditor", ->
             editor.insertText('foo')
             expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1) + 1
 
+      describe 'when scoped settings are used', ->
+        coffeeEditor = null
+        beforeEach ->
+          waitsForPromise ->
+            atom.packages.activatePackage('language-coffee-script')
+          waitsForPromise ->
+            atom.project.open('coffee.coffee', autoIndent: false).then (o) -> coffeeEditor = o
+
+          runs ->
+            atom.config.set('.source.js', 'editor.autoIndent', true)
+            atom.config.set('.source.coffee', 'editor.autoIndent', false)
+
+        afterEach: ->
+          atom.packages.deactivatePackages()
+          atom.packages.unloadPackages()
+
+        it "does not auto-indent the line for javascript files", ->
+          editor.setCursorBufferPosition([1, 30])
+          editor.insertText("\n")
+          expect(editor.lineTextForBufferRow(2)).toBe "    "
+
+          coffeeEditor.setCursorBufferPosition([1, 18])
+          coffeeEditor.insertText("\n")
+          expect(coffeeEditor.lineTextForBufferRow(2)).toBe ""
+
     describe "editor.normalizeIndentOnPaste", ->
       beforeEach ->
         atom.config.set('editor.normalizeIndentOnPaste', true)
@@ -3240,6 +3333,37 @@ describe "TextEditor", ->
             expect(editor.lineTextForBufferRow(3)).toBe "  }"
             expect(editor.lineTextForBufferRow(4)).toBe ""
 
+      describe 'when scoped settings are used', ->
+        coffeeEditor = null
+        beforeEach ->
+          waitsForPromise ->
+            atom.packages.activatePackage('language-coffee-script')
+          waitsForPromise ->
+            atom.project.open('coffee.coffee', autoIndent: false).then (o) -> coffeeEditor = o
+
+          runs ->
+            atom.config.set('.source.js', 'editor.normalizeIndentOnPaste', true)
+            atom.config.set('.source.coffee', 'editor.normalizeIndentOnPaste', false)
+
+        afterEach: ->
+          atom.packages.deactivatePackages()
+          atom.packages.unloadPackages()
+
+        it "normalizes the indentation level based on scoped settings", ->
+          copyText("    while (true) {\n      foo();\n    }\n", {startColumn: 2, textEditor: coffeeEditor})
+          coffeeEditor.setCursorBufferPosition([4, 4])
+          coffeeEditor.pasteText()
+          expect(coffeeEditor.lineTextForBufferRow(4)).toBe "      while (true) {"
+          expect(coffeeEditor.lineTextForBufferRow(5)).toBe "      foo();"
+          expect(coffeeEditor.lineTextForBufferRow(6)).toBe "    }"
+
+          copyText("    while (true) {\n      foo();\n    }\n", {startColumn: 2})
+          editor.setCursorBufferPosition([3, 4])
+          editor.pasteText()
+          expect(editor.lineTextForBufferRow(3)).toBe "    while (true) {"
+          expect(editor.lineTextForBufferRow(4)).toBe "      foo();"
+          expect(editor.lineTextForBufferRow(5)).toBe "    }"
+
     it "autoIndentSelectedRows auto-indents the selection", ->
       editor.setCursorBufferPosition([2, 0])
       editor.insertText("function() {\ninside=true\n}\n  i=1\n")
@@ -3252,10 +3376,18 @@ describe "TextEditor", ->
       expect(editor.lineTextForBufferRow(5)).toBe "    i=1"
 
   describe "soft and hard tabs", ->
+    afterEach ->
+      atom.packages.deactivatePackages()
+      atom.packages.unloadPackages()
+
     it "resets the tab style when tokenization is complete", ->
       editor.destroy()
-      atom.project.open('sample-with-tabs-and-leading-comment.coffee').then (o) -> editor = o
-      expect(editor.softTabs).toBe true
+
+      waitsForPromise ->
+        atom.project.open('sample-with-tabs-and-leading-comment.coffee').then (o) -> editor = o
+
+      runs ->
+        expect(editor.softTabs).toBe true
 
       waitsForPromise ->
         atom.packages.activatePackage('language-coffee-script')
@@ -3263,9 +3395,6 @@ describe "TextEditor", ->
       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
@@ -3283,9 +3412,12 @@ describe "TextEditor", ->
     describe "when no text is selected", ->
       describe "when the line below isn't empty", ->
         it "joins the line below with the current line separated by a space and moves the cursor to the start of line that was moved up", ->
+          editor.setCursorBufferPosition([0, Infinity])
+          editor.insertText('  ')
+          editor.setCursorBufferPosition([0])
           editor.joinLines()
           expect(editor.lineTextForBufferRow(0)).toBe 'var quicksort = function () { var sort = function(items) {'
-          expect(editor.getCursorBufferPosition()).toEqual [0, 30]
+          expect(editor.getCursorBufferPosition()).toEqual [0, 29]
 
       describe "when the line below is empty", ->
         it "deletes the line below and moves the cursor to the end of the line", ->
@@ -3301,6 +3433,13 @@ describe "TextEditor", ->
           editor.joinLines()
           expect(editor.lineTextForBufferRow(12)).toBe '};'
 
+      describe "when the line is empty", ->
+        it "joins the line below with the current line with no added space", ->
+          editor.setCursorBufferPosition([10])
+          editor.joinLines()
+          expect(editor.lineTextForBufferRow(10)).toBe 'return sort(Array.apply(this, arguments));'
+          expect(editor.getCursorBufferPosition()).toEqual [10, 0]
+
     describe "when text is selected", ->
       describe "when the selection does not span multiple lines", ->
         it "joins the line below with the current line separated by a space and retains the selected text", ->

spec/text-utils-spec.coffee

@@ -2,18 +2,23 @@ textUtils = require '../src/text-utils'
 
 describe 'text utilities', ->
   describe '.hasPairedCharacter(string)', ->
-    it 'returns true when the string contains a surrogate pair or variation sequence', ->
+    it 'returns true when the string contains a surrogate pair, variation sequence, or combined character', ->
       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('e\u0301')).toBe true
+
       expect(textUtils.hasPairedCharacter('\uD835')).toBe false
       expect(textUtils.hasPairedCharacter('\uDF97')).toBe false
       expect(textUtils.hasPairedCharacter('\uFE0E')).toBe false
+      expect(textUtils.hasPairedCharacter('\u0301')).toBe false
+
       expect(textUtils.hasPairedCharacter('\uFE0E\uFE0E')).toBe false
+      expect(textUtils.hasPairedCharacter('\u0301\u0301')).toBe false
 
   describe '.isPairedCharacter(string, index)', ->
-    it 'returns true when the index is the start of a high/low surrogate pair or variation sequence', ->
+    it 'returns true when the index is the start of a high/low surrogate pair, variation sequence, or combined character', ->
       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
@@ -21,12 +26,21 @@ describe 'text utilities', ->
       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
+
+      expect(textUtils.isPairedCharacter('ae\u0301c', 0)).toBe false
+      expect(textUtils.isPairedCharacter('ae\u0301c', 1)).toBe true
+      expect(textUtils.isPairedCharacter('ae\u0301c', 2)).toBe false
+      expect(textUtils.isPairedCharacter('ae\u0301c', 3)).toBe false
+      expect(textUtils.isPairedCharacter('ae\u0301c', 4)).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'])
 
@@ -92,8 +92,8 @@ describe "ThemeManager", ->
 
       runs ->
         reloadHandler.reset()
-        expect($('style.theme')).toHaveLength 1
-        expect($('style.theme:eq(0)').attr('id')).toMatch /atom-dark-syntax/
+        expect($('style[group=theme]')).toHaveLength 1
+        expect($('style[group=theme]:eq(0)').attr('source-path')).toMatch /atom-dark-syntax/
         atom.config.set('core.themes', ['atom-light-syntax', 'atom-dark-syntax'])
 
       waitsFor ->
@@ -101,9 +101,9 @@ describe "ThemeManager", ->
 
       runs ->
         reloadHandler.reset()
-        expect($('style.theme')).toHaveLength 2
-        expect($('style.theme:eq(0)').attr('id')).toMatch /atom-dark-syntax/
-        expect($('style.theme:eq(1)').attr('id')).toMatch /atom-light-syntax/
+        expect($('style[group=theme]')).toHaveLength 2
+        expect($('style[group=theme]:eq(0)').attr('source-path')).toMatch /atom-dark-syntax/
+        expect($('style[group=theme]:eq(1)').attr('source-path')).toMatch /atom-light-syntax/
         atom.config.set('core.themes', [])
 
       waitsFor ->
@@ -111,7 +111,7 @@ describe "ThemeManager", ->
 
       runs ->
         reloadHandler.reset()
-        expect($('style.theme')).toHaveLength 0
+        expect($('style[group=theme]')).toHaveLength 0
         # atom-dark-ui has an directory path, the syntax one doesn't
         atom.config.set('core.themes', ['theme-with-index-less', 'atom-dark-ui'])
 
@@ -119,7 +119,7 @@ describe "ThemeManager", ->
         reloadHandler.callCount == 1
 
       runs ->
-        expect($('style.theme')).toHaveLength 2
+        expect($('style[group=theme]')).toHaveLength 2
         importPaths = themeManager.getImportPaths()
         expect(importPaths.length).toBe 1
         expect(importPaths[0]).toContain 'atom-dark-ui'
@@ -129,7 +129,7 @@ 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.onDidChangeStylesheets stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
       themeManager.onDidAddStylesheet stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
@@ -142,8 +142,8 @@ describe "ThemeManager", ->
       expect(stylesheetAddedHandler).toHaveBeenCalled()
       expect(stylesheetsChangedHandler).toHaveBeenCalled()
 
-      element = $('head style[id*="css.css"]')
-      expect(element.attr('id')).toBe themeManager.stringToId(cssPath)
+      element = $('head style[source-path*="css.css"]')
+      expect(element.attr('source-path')).toBe themeManager.stringToId(cssPath)
       expect(element.text()).toBe fs.readFileSync(cssPath, 'utf8')
       expect(element[0].sheet).toBe stylesheetAddedHandler.argsForCall[0][0]
 
@@ -159,8 +159,8 @@ describe "ThemeManager", ->
       themeManager.requireStylesheet(lessPath)
       expect($('head style').length).toBe lengthBefore + 1
 
-      element = $('head style[id*="sample.less"]')
-      expect(element.attr('id')).toBe themeManager.stringToId(lessPath)
+      element = $('head style[source-path*="sample.less"]')
+      expect(element.attr('source-path')).toBe themeManager.stringToId(lessPath)
       expect(element.text()).toBe """
       #header {
         color: #4d926f;
@@ -178,25 +178,24 @@ describe "ThemeManager", ->
 
     it "supports requiring css and less stylesheets without an explicit extension", ->
       themeManager.requireStylesheet path.join(__dirname, 'fixtures', 'css')
-      expect($('head style[id*="css.css"]').attr('id')).toBe themeManager.stringToId(atom.project.resolve('css.css'))
+      expect($('head style[source-path*="css.css"]').attr('source-path')).toBe themeManager.stringToId(atom.project.resolve('css.css'))
       themeManager.requireStylesheet path.join(__dirname, 'fixtures', 'sample')
-      expect($('head style[id*="sample.less"]').attr('id')).toBe themeManager.stringToId(atom.project.resolve('sample.less'))
+      expect($('head style[source-path*="sample.less"]').attr('source-path')).toBe themeManager.stringToId(atom.project.resolve('sample.less'))
 
       $('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.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")
 
@@ -210,7 +209,7 @@ describe "ThemeManager", ->
   describe "base stylesheet loading", ->
     beforeEach ->
       atom.workspaceView = atom.workspace.getView(atom.workspace).__spacePenView
-      atom.workspaceView.append $$ -> @div class: 'editor'
+      atom.workspaceView.append $('<atom-text-editor>')
       atom.workspaceView.attachToDom()
 
       waitsForPromise ->
@@ -228,9 +227,9 @@ describe "ThemeManager", ->
         expect(atom.workspaceView.css("background-color")).toBe "rgb(0, 0, 255)"
 
         # from within the theme itself
-        expect($(".editor").css("padding-top")).toBe "150px"
-        expect($(".editor").css("padding-right")).toBe "150px"
-        expect($(".editor").css("padding-bottom")).toBe "150px"
+        expect($("atom-text-editor").css("padding-top")).toBe "150px"
+        expect($("atom-text-editor").css("padding-right")).toBe "150px"
+        expect($("atom-text-editor").css("padding-bottom")).toBe "150px"
 
     describe "when there is a theme with incomplete variables", ->
       it "loads the correct values from the fallback ui-variables", ->
@@ -245,7 +244,7 @@ describe "ThemeManager", ->
           expect(atom.workspaceView.css("background-color")).toBe "rgb(0, 0, 255)"
 
           # from within the theme itself
-          expect($(".editor").css("background-color")).toBe "rgb(0, 152, 255)"
+          expect($("atom-text-editor").css("background-color")).toBe "rgb(0, 152, 255)"
 
     describe "theme classes on the workspace", ->
       it 'adds theme-* classes to the workspace for each active theme', ->

spec/tokenized-line-spec.coffee

@@ -19,16 +19,16 @@ describe "TokenizedLine", ->
       expect(editor.tokenizedLineForScreenRow(2).isOnlyWhitespace()).toBe false
 
   describe "::getScopeTree()", ->
-    it "returns a tree whose inner nodes are scopes and whose leaf nodes are tokens in those scopes", ->
+    it "returns a tree whose inner nodes are scopeDescriptor and whose leaf nodes are tokens in those scopeDescriptor", ->
       [tokens, tokenIndex] = []
 
-      ensureValidScopeTree = (scopeTree, scopes=[]) ->
+      ensureValidScopeTree = (scopeTree, scopeDescriptor=[]) ->
         if scopeTree.children?
           for child in scopeTree.children
-            ensureValidScopeTree(child, scopes.concat([scopeTree.scope]))
+            ensureValidScopeTree(child, scopeDescriptor.concat([scopeTree.scope]))
         else
           expect(scopeTree).toBe tokens[tokenIndex++]
-          expect(scopes).toEqual scopeTree.scopes
+          expect(scopeDescriptor).toEqual scopeTree.scopes
 
       waitsForPromise ->
         atom.project.open('coffee.coffee').then (o) -> editor = o

spec/window-spec.coffee

@@ -8,19 +8,14 @@ describe "Window", ->
 
   beforeEach ->
     spyOn(atom, 'hide')
-    initialPath = atom.project.getPath()
+    initialPath = atom.project.getPaths()[0]
     spyOn(atom, 'getLoadSettings').andCallFake ->
       loadSettings = atom.getLoadSettings.originalValue.call(atom)
       loadSettings.initialPath = initialPath
       loadSettings
     atom.project.destroy()
-    windowEventHandler = new WindowEventHandler()
     atom.deserializeEditorWindow()
-    projectPath = atom.project.getPath()
-
-  afterEach ->
-    windowEventHandler.unsubscribe()
-    $(window).off 'beforeunload'
+    projectPath = atom.project.getPaths()[0]
 
   describe "when the window is loaded", ->
     it "doesn't have .is-blurred on the body tag", ->
@@ -47,14 +42,6 @@ describe "Window", ->
       $(window).trigger 'window:close'
       expect(atom.close).toHaveBeenCalled()
 
-    it "emits the beforeunload event", ->
-      $(window).off 'beforeunload'
-      beforeunload = jasmine.createSpy('beforeunload').andReturn(false)
-      $(window).on 'beforeunload', beforeunload
-
-      $(window).trigger 'window:close'
-      expect(beforeunload).toHaveBeenCalled()
-
   describe "beforeunload event", ->
     [beforeUnloadEvent] = []
 
@@ -63,9 +50,9 @@ describe "Window", ->
       beforeUnloadEvent = $.Event(new Event('beforeunload'))
 
     describe "when pane items are are modified", ->
-      it "prompts user to save and and calls workspaceView.confirmClose", ->
+      it "prompts user to save and calls atom.workspace.confirmClose", ->
         editor = null
-        spyOn(atom.workspaceView, 'confirmClose').andCallThrough()
+        spyOn(atom.workspace, 'confirmClose').andCallThrough()
         spyOn(atom, "confirm").andReturn(2)
 
         waitsForPromise ->
@@ -74,7 +61,7 @@ describe "Window", ->
         runs ->
           editor.insertText("I look different, I feel different.")
           $(window).trigger(beforeUnloadEvent)
-          expect(atom.workspaceView.confirmClose).toHaveBeenCalled()
+          expect(atom.workspace.confirmClose).toHaveBeenCalled()
           expect(atom.confirm).toHaveBeenCalled()
 
       it "prompts user to save and handler returns true if don't save", ->
@@ -115,6 +102,8 @@ describe "Window", ->
 
   describe ".removeEditorWindow()", ->
     it "unsubscribes from all buffers", ->
+      spyOn(atom.windowEventHandler, 'unsubscribe') # don't unsubscribe from window events
+
       waitsForPromise ->
         atom.workspace.open("sample.js")
 
@@ -122,7 +111,7 @@ describe "Window", ->
         buffer = atom.workspace.getActivePaneItem().buffer
         pane = atom.workspaceView.getActivePaneView()
         pane.splitRight(pane.copyActiveItem())
-        expect(atom.workspaceView.find('.editor').length).toBe 2
+        expect(atom.workspaceView.find('atom-text-editor').length).toBe 2
 
         atom.removeEditorWindow()
 
@@ -263,19 +252,19 @@ describe "Window", ->
 
     describe "when the project does not have a path", ->
       beforeEach ->
-        atom.project.setPath()
+        atom.project.setPaths([])
 
       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
+          expect(atom.project.getPaths()[0]).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
+          expect(atom.project.getPaths()[0]).toBe __dirname
 
     describe "when the opened path is a file", ->
       it "opens it in the workspace", ->

spec/workspace-spec.coffee

@@ -1,3 +1,5 @@
+path = require 'path'
+temp = require 'temp'
 Workspace = require '../src/workspace'
 {View} = require '../src/space-pen-extensions'
 
@@ -5,7 +7,7 @@ describe "Workspace", ->
   workspace = null
 
   beforeEach ->
-    atom.project.setPath(atom.project.resolve('dir'))
+    atom.project.setPaths([atom.project.resolve('dir')])
     atom.workspace = workspace = new Workspace
 
   describe "::open(uri, options)", ->
@@ -220,8 +222,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')
@@ -369,3 +371,124 @@ describe "Workspace", ->
       workspace2 = Workspace.deserialize(state)
       expect(jsPackage.loadGrammarsSync.callCount).toBe 1
       expect(coffeePackage.loadGrammarsSync.callCount).toBe 1
+
+  describe "document.title", ->
+    describe "when the project has no path", ->
+      it "sets the title to 'untitled'", ->
+        atom.project.setPath(undefined)
+        expect(document.title).toBe 'untitled - Atom'
+
+    describe "when the project has a path", ->
+      beforeEach ->
+        waitsForPromise ->
+          atom.workspace.open('b')
+
+      describe "when there is an active pane item", ->
+        it "sets the title to the pane item's title plus the project path", ->
+          item = atom.workspace.getActivePaneItem()
+          expect(document.title).toBe "#{item.getTitle()} - #{atom.project.getPaths()[0]} - Atom"
+
+      describe "when the title of the active pane item changes", ->
+        it "updates the window title based on the item's new title", ->
+          editor = atom.workspace.getActivePaneItem()
+          editor.buffer.setPath(path.join(temp.dir, 'hi'))
+          expect(document.title).toBe "#{editor.getTitle()} - #{atom.project.getPaths()[0]} - Atom"
+
+      describe "when the active pane's item changes", ->
+        it "updates the title to the new item's title plus the project path", ->
+          atom.workspace.getActivePane().activateNextItem()
+          item = atom.workspace.getActivePaneItem()
+          expect(document.title).toBe "#{item.getTitle()} - #{atom.project.getPaths()[0]} - Atom"
+
+      describe "when the last pane item is removed", ->
+        it "updates the title to contain the project's path", ->
+          atom.workspace.getActivePane().destroy()
+          expect(atom.workspace.getActivePaneItem()).toBeUndefined()
+          expect(document.title).toBe "#{atom.project.getPaths()[0]} - Atom"
+
+      describe "when an inactive pane's item changes", ->
+        it "does not update the title", ->
+          pane = atom.workspace.getActivePane()
+          pane.splitRight()
+          initialTitle = document.title
+          pane.activateNextItem()
+          expect(document.title).toBe initialTitle
+
+    describe "when the workspace is deserialized", ->
+      beforeEach ->
+        waitsForPromise -> atom.workspace.open('a')
+
+      it "updates the title to contain the project's path", ->
+        document.title = null
+        workspace2 = atom.workspace.testSerialization()
+        item = atom.workspace.getActivePaneItem()
+        expect(document.title).toBe "#{item.getTitle()} - #{atom.project.getPaths()[0]} - Atom"
+        workspace2.destroy()
+
+  describe "document edited status", ->
+    [item1, item2] = []
+
+    beforeEach ->
+      waitsForPromise -> atom.workspace.open('a')
+      waitsForPromise -> atom.workspace.open('b')
+      runs ->
+        [item1, item2] = atom.workspace.getPaneItems()
+        spyOn(atom, 'setDocumentEdited')
+
+    it "calls atom.setDocumentEdited when the active item changes", ->
+      expect(atom.workspace.getActivePaneItem()).toBe item2
+      item1.insertText('a')
+      expect(item1.isModified()).toBe true
+      atom.workspace.getActivePane().activateNextItem()
+
+      expect(atom.setDocumentEdited).toHaveBeenCalledWith(true)
+
+    it "calls atom.setDocumentEdited when the active item's modified status changes", ->
+      expect(atom.workspace.getActivePaneItem()).toBe item2
+      item2.insertText('a')
+      advanceClock(item2.getBuffer().getStoppedChangingDelay())
+
+      expect(item2.isModified()).toBe true
+      expect(atom.setDocumentEdited).toHaveBeenCalledWith(true)
+
+      item2.undo()
+      advanceClock(item2.getBuffer().getStoppedChangingDelay())
+
+      expect(item2.isModified()).toBe false
+      expect(atom.setDocumentEdited).toHaveBeenCalledWith(false)
+
+  describe "adding panels", ->
+    class TestPanel
+      constructior: ->
+
+    describe '::addLeftPanel(model)', ->
+      it 'adds a panel to the correct panel container', ->
+        atom.workspace.panelContainers.left.onDidAddPanel addPanelSpy = jasmine.createSpy()
+        panel = atom.workspace.addLeftPanel(item: new TestPanel())
+
+        expect(panel).toBeDefined()
+        expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0})
+
+    describe '::addRightPanel(model)', ->
+      it 'adds a panel to the correct panel container', ->
+        atom.workspace.panelContainers.right.onDidAddPanel addPanelSpy = jasmine.createSpy()
+        panel = atom.workspace.addRightPanel(item: new TestPanel())
+
+        expect(panel).toBeDefined()
+        expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0})
+
+    describe '::addTopPanel(model)', ->
+      it 'adds a panel to the correct panel container', ->
+        atom.workspace.panelContainers.top.onDidAddPanel addPanelSpy = jasmine.createSpy()
+        panel = atom.workspace.addTopPanel(item: new TestPanel())
+
+        expect(panel).toBeDefined()
+        expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0})
+
+    describe '::addBottomPanel(model)', ->
+      it 'adds a panel to the correct panel container', ->
+        atom.workspace.panelContainers.bottom.onDidAddPanel addPanelSpy = jasmine.createSpy()
+        panel = atom.workspace.addBottomPanel(item: new TestPanel())
+
+        expect(panel).toBeDefined()
+        expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0})

spec/workspace-view-spec.coffee

@@ -10,7 +10,7 @@ describe "WorkspaceView", ->
   pathToOpen = null
 
   beforeEach ->
-    atom.project.setPath(atom.project.resolve('dir'))
+    atom.project.setPaths([atom.project.resolve('dir')])
     pathToOpen = atom.project.resolve('a')
     atom.workspace = new Workspace
     atom.workspaceView = atom.workspace.getView(atom.workspace).__spacePenView
@@ -49,7 +49,7 @@ describe "WorkspaceView", ->
 
           expect(atom.workspaceView.getEditorViews().length).toBe 2
           expect(atom.workspaceView.getActivePaneView()).toBe atom.workspaceView.getPaneViews()[1]
-          expect(atom.workspaceView.title).toBe "untitled - #{atom.project.getPath()}"
+          expect(document.title).toBe "untitled - #{atom.project.getPaths()[0]} - Atom"
 
     describe "when there are open editors", ->
       it "constructs the view with the same panes", ->
@@ -82,10 +82,10 @@ describe "WorkspaceView", ->
           simulateReload()
 
           expect(atom.workspaceView.getEditorViews().length).toBe 4
-          editorView1 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(0)').view()
-          editorView3 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(1)').view()
-          editorView2 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(0)').view()
-          editorView4 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(1)').view()
+          editorView1 = atom.workspaceView.panes.find('atom-pane-axis.horizontal > atom-pane atom-text-editor:eq(0)').view()
+          editorView3 = atom.workspaceView.panes.find('atom-pane-axis.horizontal > atom-pane atom-text-editor:eq(1)').view()
+          editorView2 = atom.workspaceView.panes.find('atom-pane-axis.horizontal > atom-pane-axis.vertical > atom-pane atom-text-editor:eq(0)').view()
+          editorView4 = atom.workspaceView.panes.find('atom-pane-axis.horizontal > atom-pane-axis.vertical > atom-pane atom-text-editor:eq(1)').view()
 
           expect(editorView1.getEditor().getPath()).toBe atom.project.resolve('a')
           expect(editorView2.getEditor().getPath()).toBe atom.project.resolve('b')
@@ -106,7 +106,7 @@ describe "WorkspaceView", ->
           expect(editorView3).not.toHaveFocus()
           expect(editorView4).not.toHaveFocus()
 
-          expect(atom.workspaceView.title).toBe "#{path.basename(editorView2.getEditor().getPath())} - #{atom.project.getPath()}"
+          expect(document.title).toBe "#{path.basename(editorView2.getEditor().getPath())} - #{atom.project.getPaths()[0]} - Atom"
 
     describe "where there are no open editors", ->
       it "constructs the view with no open editors", ->
@@ -127,70 +127,16 @@ describe "WorkspaceView", ->
       expect(activePane).toHaveFocus()
 
   describe "keymap wiring", ->
-    commandHandler = null
-    beforeEach ->
-      commandHandler = jasmine.createSpy('commandHandler')
-      atom.workspaceView.on('foo-command', commandHandler)
-
-      atom.keymaps.add('name', '*': {'x': 'foo-command'})
-
     describe "when a keydown event is triggered in the WorkspaceView", ->
       it "triggers matching keybindings for that event", ->
+        commandHandler = jasmine.createSpy('commandHandler')
+        atom.workspaceView.on('foo-command', commandHandler)
+        atom.keymaps.add('name', '*': {'x': 'foo-command'})
         event = keydownEvent 'x', target: atom.workspaceView[0]
 
         atom.workspaceView.trigger(event)
         expect(commandHandler).toHaveBeenCalled()
 
-  describe "window title", ->
-    describe "when the project has no path", ->
-      it "sets the title to 'untitled'", ->
-        atom.project.setPath(undefined)
-        expect(atom.workspaceView.title).toBe 'untitled'
-
-    describe "when the project has a path", ->
-      beforeEach ->
-        waitsForPromise ->
-          atom.workspace.open('b')
-
-      describe "when there is an active pane item", ->
-        it "sets the title to the pane item's title plus the project path", ->
-          item = atom.workspace.getActivePaneItem()
-          expect(atom.workspaceView.title).toBe "#{item.getTitle()} - #{atom.project.getPath()}"
-
-      describe "when the title of the active pane item changes", ->
-        it "updates the window title based on the item's new title", ->
-          editor = atom.workspace.getActivePaneItem()
-          editor.buffer.setPath(path.join(temp.dir, 'hi'))
-          expect(atom.workspaceView.title).toBe "#{editor.getTitle()} - #{atom.project.getPath()}"
-
-      describe "when the active pane's item changes", ->
-        it "updates the title to the new item's title plus the project path", ->
-          atom.workspaceView.getActivePaneView().activateNextItem()
-          item = atom.workspace.getActivePaneItem()
-          expect(atom.workspaceView.title).toBe "#{item.getTitle()} - #{atom.project.getPath()}"
-
-      describe "when the last pane item is removed", ->
-        it "updates the title to contain the project's path", ->
-          atom.workspaceView.getActivePaneView().remove()
-          expect(atom.workspace.getActivePaneItem()).toBeUndefined()
-          expect(atom.workspaceView.title).toBe atom.project.getPath()
-
-      describe "when an inactive pane's item changes", ->
-        it "does not update the title", ->
-          pane = atom.workspaceView.getActivePaneView()
-          pane.splitRight()
-          initialTitle = atom.workspaceView.title
-          pane.activateNextItem()
-          expect(atom.workspaceView.title).toBe initialTitle
-
-    describe "when the root view is deserialized", ->
-      it "updates the title to contain the project's path", ->
-        workspace2 = atom.workspace.testSerialization()
-        workspaceView2 = workspace2.getView(workspace2).__spacePenView
-        item = atom.workspace.getActivePaneItem()
-        expect(workspaceView2.title).toBe "#{item.getTitle()} - #{atom.project.getPath()}"
-        workspaceView2.remove()
-
   describe "window:toggle-invisibles event", ->
     it "shows/hides invisibles in all open and future editors", ->
       atom.workspaceView.height(200)
@@ -302,8 +248,8 @@ describe "WorkspaceView", ->
 
     beforeEach ->
       atom.workspaceView.attachToDom()
-      editorNode = atom.workspaceView.find('.editor')[0]
-      editor = atom.workspaceView.find('.editor').view().getEditor()
+      editorNode = atom.workspaceView.find('atom-text-editor')[0]
+      editor = atom.workspaceView.find('atom-text-editor').view().getEditor()
 
     it "updates the font-size based on the 'editor.fontSize' config value", ->
       initialCharWidth = editor.getDefaultCharWidth()
@@ -324,3 +270,19 @@ describe "WorkspaceView", ->
       atom.config.set('editor.lineHeight', '30px')
       expect(getComputedStyle(editorNode).lineHeight).toBe atom.config.get('editor.lineHeight')
       expect(editor.getLineHeightInPixels()).not.toBe initialLineHeight
+
+  describe 'panel containers', ->
+    workspaceElement = null
+    beforeEach ->
+      workspaceElement = atom.workspace.getView(atom.workspace)
+
+    it 'inserts panel container elements in the correct places in the DOM', ->
+      leftContainer = workspaceElement.querySelector('atom-panel-container[location="left"]')
+      rightContainer = workspaceElement.querySelector('atom-panel-container[location="right"]')
+      expect(leftContainer.nextSibling).toBe workspaceElement.verticalAxis
+      expect(rightContainer.previousSibling).toBe workspaceElement.verticalAxis
+
+      topContainer = workspaceElement.querySelector('atom-panel-container[location="top"]')
+      bottomContainer = workspaceElement.querySelector('atom-panel-container[location="bottom"]')
+      expect(topContainer.nextSibling).toBe workspaceElement.paneContainer
+      expect(bottomContainer.previousSibling).toBe workspaceElement.paneContainer

src/atom.coffee

@@ -14,6 +14,7 @@ fs = require 'fs-plus'
 
 {$} = require './space-pen-extensions'
 WindowEventHandler = require './window-event-handler'
+StylesElement = require './styles-element'
 
 # Essential: Atom global for dealing with packages, themes, menus, and the window.
 #
@@ -29,7 +30,10 @@ class Atom extends Model
   #
   # Returns an Atom instance, fully initialized
   @loadOrCreate: (mode) ->
-    @deserialize(@loadState(mode)) ? new this({mode, @version})
+    startTime = Date.now()
+    atom = @deserialize(@loadState(mode)) ? new this({mode, @version})
+    atom.deserializeTimings.atom = Date.now() -  startTime
+    atom
 
   # Deserializes the Atom environment from a state object
   @deserialize: (state) ->
@@ -103,7 +107,7 @@ class Atom extends Model
   Section: Properties
   ###
 
-  # Experimental: A {CommandRegistry} instance
+  # Public: A {CommandRegistry} instance
   commands: null
 
   # Public: A {Config} instance
@@ -152,6 +156,7 @@ class Atom extends Model
     {@mode} = @state
     DeserializerManager = require './deserializer-manager'
     @deserializers = new DeserializerManager()
+    @deserializeTimings = {}
 
   # Sets up the basic services that should be available in all modes
   # (both spec and application).
@@ -182,6 +187,7 @@ class Atom extends Model
     Clipboard = require './clipboard'
     Syntax = require './syntax'
     ThemeManager = require './theme-manager'
+    StyleManager = require './style-manager'
     ContextMenuManager = require './context-menu-manager'
     MenuManager = require './menu-manager'
     {devMode, safeMode, resourcePath} = @getLoadSettings()
@@ -196,11 +202,17 @@ class Atom extends Model
     # Make react.js faster
     process.env.NODE_ENV ?= 'production' unless devMode
 
+    # Set Atom's home so packages don't have to guess it
+    process.env.ATOM_HOME = configDirPath
+
     @config = new Config({configDirPath, resourcePath})
     @keymaps = new KeymapManager({configDirPath, resourcePath})
     @keymap = @keymaps # Deprecated
     @commands = new CommandRegistry
+    @commands.patchDOMEventMethods()
     @packages = new PackageManager({devMode, configDirPath, resourcePath, safeMode})
+    @styles = new StyleManager
+    document.head.appendChild(new StylesElement)
     @themes = new ThemeManager({packageManager: @packages, configDirPath, resourcePath, safeMode})
     @contextMenu = new ContextMenuManager({resourcePath, devMode})
     @menu = new MenuManager({resourcePath})
@@ -577,7 +589,7 @@ class Atom extends Model
     Project = require './project'
 
     startTime = Date.now()
-    @project ?= @deserializers.deserialize(@state.project) ? new Project(path: @getLoadSettings().initialPath)
+    @project ?= @deserializers.deserialize(@state.project) ? new Project(paths: [@getLoadSettings().initialPath])
     @deserializeTimings.project = Date.now() - startTime
 
   deserializeWorkspaceView: ->
@@ -597,7 +609,6 @@ class Atom extends Model
     delete @state.packageStates
 
   deserializeEditorWindow: ->
-    @deserializeTimings = {}
     @deserializePackageStates()
     @deserializeProject()
     @deserializeWorkspaceView()
@@ -619,8 +630,8 @@ class Atom extends Model
   # 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
+      ipc.send('window-command', 'project-path-changed', @project.getPaths()[0])
+    @subscribe @project.onDidChangePaths(onProjectPathChanged)
     onProjectPathChanged()
 
   exit: (status) ->

src/browser/application-menu.coffee

@@ -10,24 +10,50 @@ _ = require 'underscore-plus'
 module.exports =
 class ApplicationMenu
   constructor: (@version) ->
-    @menu = Menu.buildFromTemplate @getDefaultTemplate()
-    Menu.setApplicationMenu @menu
+    @windowTemplates = new WeakMap()
+    @setActiveTemplate(@getDefaultTemplate())
     global.atomApplication.autoUpdateManager.on 'state-changed', (state) =>
       @showUpdateMenuItem(state)
 
   # Public: Updates the entire menu with the given keybindings.
   #
+  # window - The BrowserWindow this menu template is associated with.
   # template - The Object which describes the menu to display.
   # keystrokesByCommand - An Object where the keys are commands and the values
   #                       are Arrays containing the keystroke.
-  update: (template, keystrokesByCommand) ->
+  update: (window, template, keystrokesByCommand) ->
+    return unless window is @lastFocusedWindow
+
     @translateTemplate(template, keystrokesByCommand)
     @substituteVersion(template)
-    @menu = Menu.buildFromTemplate(template)
-    Menu.setApplicationMenu(@menu)
+    @windowTemplates.set(window, template)
+    @setActiveTemplate(template)
 
     @showUpdateMenuItem(global.atomApplication.autoUpdateManager.getState())
 
+  setActiveTemplate: (template) ->
+    unless _.isEqual(template, @activeTemplate)
+      @activeTemplate = template
+      @menu = Menu.buildFromTemplate(_.deepClone(template))
+      Menu.setApplicationMenu(@menu)
+
+  # Register a BrowserWindow with this application menu.
+  addWindow: (window) ->
+    @lastFocusedWindow ?= window
+
+    focusHandler = =>
+      @lastFocusedWindow = window
+      if template = @windowTemplates.get(window)
+        @setActiveTemplate(template)
+
+    window.on 'focus', focusHandler
+    window.once 'closed', =>
+      @lastFocusedWindow = null if window is @lastFocusedWindow
+      @windowTemplates.delete(window)
+      window.removeListener 'focus', focusHandler
+
+    @enableWindowSpecificItems(true)
+
   # Flattens the given menu and submenu items into an single Array.
   #
   # menu - A complete menu configuration object for atom-shell's menu API.