Upgrade to settings-view@0.152

Don't fail create-installer if ATOM_ACCESS_TOKEN isn't set

CONTRIBUTING.md

@@ -12,14 +12,14 @@ 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.
@@ -82,6 +82,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
 

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.102.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/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/install-task.coffee

@@ -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')

coffeelint.json

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

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/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,7 +16,7 @@ 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

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/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':

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.137.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.0",
   "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,12 +29,13 @@
     "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",
     "mixto": "^1",
@@ -50,14 +51,14 @@
     "reactionary-atom-fork": "^1.0.0",
     "runas": "1.0.1",
     "scandal": "1.0.2",
-    "scoped-property-store": "^0.9.0",
+    "scoped-property-store": "^0.13.2",
     "scrollbar-style": "^1.0.2",
     "season": "^1.0.2",
     "semver": "1.1.4",
     "serializable": "^1",
-    "space-pen": "3.4.7",
+    "space-pen": "3.8.0",
     "temp": "0.7.0",
-    "text-buffer": "^3.2.6",
+    "text-buffer": "^3.2.8",
     "theorist": "^1.0.2",
     "underscore-plus": "^1.5.1",
     "vm-compatibility-layer": "0.1.0"
@@ -74,48 +75,48 @@
     "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",
+    "command-palette": "0.27.0",
     "deprecation-cop": "0.10.0",
     "dev-live-reload": "0.34.0",
     "exception-reporting": "0.20.0",
     "feedback": "0.33.0",
-    "find-and-replace": "0.139.0",
+    "find-and-replace": "0.140.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",
+    "grammar-selector": "0.35.0",
+    "image-view": "0.37.0",
+    "incompatible-packages": "0.10.0",
     "keybinding-resolver": "0.20.0",
     "link": "0.25.0",
-    "markdown-preview": "0.103.0",
+    "markdown-preview": "0.104.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",
+    "settings-view": "0.152.0",
+    "snippets": "0.55.0",
     "spell-check": "0.42.0",
-    "status-bar": "0.45.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",
+    "tree-view": "0.131.0",
     "update-package-dependencies": "0.6.0",
-    "welcome": "0.18.0",
+    "welcome": "0.19.0",
     "whitespace": "0.25.0",
-    "wrap-guide": "0.22.0",
+    "wrap-guide": "0.23.0",
     "language-c": "0.28.0",
     "language-coffee-script": "0.35.0",
-    "language-css": "0.17.0",
-    "language-gfm": "0.50.0",
+    "language-css": "0.21.0",
+    "language-gfm": "0.51.0",
     "language-git": "0.9.0",
-    "language-go": "0.17.0",
+    "language-go": "0.18.0",
     "language-html": "0.26.0",
     "language-hyperlink": "0.12.0",
     "language-java": "0.11.0",
@@ -128,18 +129,18 @@
     "language-perl": "0.9.0",
     "language-php": "0.16.0",
     "language-property-list": "0.7.0",
-    "language-python": "0.19.0",
-    "language-ruby": "0.38.0",
+    "language-python": "0.20.0",
+    "language-ruby": "0.39.0",
     "language-ruby-on-rails": "0.18.0",
     "language-sass": "0.22.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-todo": "0.13.0",
     "language-toml": "0.12.0",
-    "language-xml": "0.21.0",
-    "language-yaml": "0.17.0"
+    "language-xml": "0.24.0",
+    "language-yaml": "0.18.0"
   },
   "private": true,
   "scripts": {

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

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,9 +14,12 @@ describe "CommandRegistry", ->
     parent.appendChild(child)
     document.querySelector('#jasmine-content').appendChild(parent)
 
-    registry = new CommandRegistry(parent)
+    registry = new CommandRegistry
 
-  describe "command dispatch", ->
+  afterEach ->
+    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) ->
@@ -48,6 +51,16 @@ 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.add '.grandchild', 'command', -> calls.push('grandchild')
+      registry.add child, 'command', -> calls.push('child-inline')
+      registry.add '.child', 'command', -> calls.push('child')
+      registry.add '.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 = []
@@ -86,8 +99,6 @@ describe "CommandRegistry", ->
       expect(dispatchedEvent.stopImmediatePropagation).toHaveBeenCalled()
 
     it "forwards .preventDefault() calls from the synthetic event to the original", ->
-      calls = []
-
       registry.add '.child', 'command', (event) -> event.preventDefault()
 
       dispatchedEvent = new CustomEvent('command', bubbles: true)
@@ -95,6 +106,14 @@ describe "CommandRegistry", ->
       grandchild.dispatchEvent(dispatchedEvent)
       expect(dispatchedEvent.preventDefault).toHaveBeenCalled()
 
+    it "forwards .abortKeyBinding() calls from the synthetic event to the original", ->
+      registry.add '.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 = []
 

spec/config-spec.coffee

@@ -200,7 +200,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 +214,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 +340,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 +384,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 +475,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 +501,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 +947,106 @@ describe "Config", ->
 
         expect(atom.config.set('foo.bar.arr', ['two', 'three'])).toBe true
         expect(atom.config.get('foo.bar.arr')).toEqual ['two', 'three']
+
+  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 ".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/fixtures/packages/package-with-activation-commands/index.coffee

@@ -6,7 +6,7 @@ module.exports =
   activate: ->
     @activateCallCount++
 
-    atom.commands.add '.workspace', 'activation-command', =>
+    atom.commands.add '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/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", ->
@@ -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.add '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/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'
@@ -29,12 +30,18 @@ atom.keymaps.loadBundledKeymaps()
 keyBindingsToRestore = atom.keymaps.getKeyBindings()
 commandsToRestore = atom.commands.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
@@ -61,11 +68,11 @@ 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)
 
   window.resetTimeouts()
@@ -75,7 +82,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 +112,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 +131,7 @@ beforeEach ->
 afterEach ->
   atom.packages.deactivatePackages()
   atom.menu.template = []
+  atom.contextMenu.clear()
 
   atom.workspaceView?.remove?()
   atom.workspaceView = null
@@ -350,7 +357,7 @@ $.fn.enableKeymap = ->
     not e.originalEvent.defaultPrevented
 
 $.fn.attachToDom = ->
-  @appendTo($('#jasmine-content'))
+  @appendTo($('#jasmine-content')) unless @isOnDom()
 
 $.fn.simulateDomAttachment = ->
   $('<html>').append(this)

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] = []
 
@@ -2214,7 +2208,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 +2261,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 +2431,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
@@ -3521,10 +3650,10 @@ describe "TextEditor", ->
         {tokens} = grammar.tokenizeLine("var i; // http://github.com")
 
         expect(tokens[0].value).toBe "var"
-        expect(tokens[0].scopes).toEqual ["source.js", "storage.modifier.js"]
+        expect(tokens[0].scopeDescriptor).toEqual ["source.js", "storage.modifier.js"]
 
         expect(tokens[6].value).toBe "http://github.com"
-        expect(tokens[6].scopes).toEqual ["source.js", "comment.line.double-slash.js", "markup.underline.link.http.hyperlink"]
+        expect(tokens[6].scopeDescriptor).toEqual ["source.js", "comment.line.double-slash.js", "markup.underline.link.http.hyperlink"]
 
     describe "when the grammar is added", ->
       it "retokenizes existing buffers that contain tokens that match the injection selector", ->
@@ -3536,7 +3665,7 @@ describe "TextEditor", ->
 
           {tokens} = editor.tokenizedLineForScreenRow(0)
           expect(tokens[1].value).toBe " http://github.com"
-          expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
+          expect(tokens[1].scopeDescriptor).toEqual ["source.js", "comment.line.double-slash.js"]
 
         waitsForPromise ->
           atom.packages.activatePackage('language-hyperlink')
@@ -3544,7 +3673,7 @@ describe "TextEditor", ->
         runs ->
           {tokens} = editor.tokenizedLineForScreenRow(0)
           expect(tokens[2].value).toBe "http://github.com"
-          expect(tokens[2].scopes).toEqual ["source.js", "comment.line.double-slash.js", "markup.underline.link.http.hyperlink"]
+          expect(tokens[2].scopeDescriptor).toEqual ["source.js", "comment.line.double-slash.js", "markup.underline.link.http.hyperlink"]
 
       describe "when the grammar is updated", ->
         it "retokenizes existing buffers that contain tokens that match the injection selector", ->
@@ -3556,7 +3685,7 @@ describe "TextEditor", ->
 
             {tokens} = editor.tokenizedLineForScreenRow(0)
             expect(tokens[1].value).toBe " SELECT * FROM OCTOCATS"
-            expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
+            expect(tokens[1].scopeDescriptor).toEqual ["source.js", "comment.line.double-slash.js"]
 
           waitsForPromise ->
             atom.packages.activatePackage('package-with-injection-selector')
@@ -3564,7 +3693,7 @@ describe "TextEditor", ->
           runs ->
             {tokens} = editor.tokenizedLineForScreenRow(0)
             expect(tokens[1].value).toBe " SELECT * FROM OCTOCATS"
-            expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
+            expect(tokens[1].scopeDescriptor).toEqual ["source.js", "comment.line.double-slash.js"]
 
           waitsForPromise ->
             atom.packages.activatePackage('language-sql')
@@ -3572,7 +3701,7 @@ describe "TextEditor", ->
           runs ->
             {tokens} = editor.tokenizedLineForScreenRow(0)
             expect(tokens[2].value).toBe "SELECT"
-            expect(tokens[2].scopes).toEqual ["source.js", "comment.line.double-slash.js", "keyword.other.DML.sql"]
+            expect(tokens[2].scopeDescriptor).toEqual ["source.js", "comment.line.double-slash.js", "keyword.other.DML.sql"]
 
   describe ".normalizeTabsInBufferRange()", ->
     it "normalizes tabs depending on the editor's soft tab/tab length settings", ->

spec/theme-manager-spec.coffee

@@ -209,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 ->
@@ -227,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", ->
@@ -244,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-buffer-spec.coffee

@@ -51,12 +51,12 @@ describe "TokenizedBuffer", ->
       it "initially creates un-tokenized screen lines, then tokenizes lines chunk at a time in the background", ->
         line0 = tokenizedBuffer.tokenizedLineForRow(0)
         expect(line0.tokens.length).toBe 1
-        expect(line0.tokens[0]).toEqual(value: line0.text, scopes: ['source.js'])
+        expect(line0.tokens[0]).toEqual(value: line0.text, scopeDescriptor: ['source.js'])
 
         line11 = tokenizedBuffer.tokenizedLineForRow(11)
         expect(line11.tokens.length).toBe 2
-        expect(line11.tokens[0]).toEqual(value: "  ", scopes: ['source.js'], isAtomic: true)
-        expect(line11.tokens[1]).toEqual(value: "return sort(Array.apply(this, arguments));", scopes: ['source.js'])
+        expect(line11.tokens[0]).toEqual(value: "  ", scopeDescriptor: ['source.js'], isAtomic: true)
+        expect(line11.tokens[1]).toEqual(value: "return sort(Array.apply(this, arguments));", scopeDescriptor: ['source.js'])
 
         # background tokenization has not begun
         expect(tokenizedBuffer.tokenizedLineForRow(0).ruleStack).toBeUndefined()
@@ -149,10 +149,10 @@ describe "TokenizedBuffer", ->
           it "updates tokens to reflect the change", ->
             buffer.setTextInRange([[0, 0], [2, 0]], "foo()\n7\n")
 
-            expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1]).toEqual(value: '(', scopes: ['source.js', 'meta.brace.round.js'])
-            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0]).toEqual(value: '7', scopes: ['source.js', 'constant.numeric.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1]).toEqual(value: '(', scopeDescriptor: ['source.js', 'meta.brace.round.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0]).toEqual(value: '7', scopeDescriptor: ['source.js', 'constant.numeric.js'])
             # line 2 is unchanged
-            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[2]).toEqual(value: 'if', scopes: ['source.js', 'keyword.control.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[2]).toEqual(value: 'if', scopeDescriptor: ['source.js', 'keyword.control.js'])
 
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
@@ -164,7 +164,7 @@ describe "TokenizedBuffer", ->
               buffer.insert([5, 30], '/* */')
               changeHandler.reset()
               buffer.insert([2, 0], '/*')
-              expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopes).toEqual ['source.js']
+              expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopeDescriptor).toEqual ['source.js']
               expect(changeHandler).toHaveBeenCalled()
               [event] = changeHandler.argsForCall[0]
               delete event.bufferChange
@@ -172,9 +172,9 @@ describe "TokenizedBuffer", ->
               changeHandler.reset()
 
               advanceClock()
-              expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-              expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-              expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+              expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
+              expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
+              expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
               expect(changeHandler).toHaveBeenCalled()
               [event] = changeHandler.argsForCall[0]
               delete event.bufferChange
@@ -185,23 +185,23 @@ describe "TokenizedBuffer", ->
             buffer.insert([5, 0], '*/')
 
             buffer.insert([1, 0], 'var ')
-            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
 
         describe "when lines are both updated and removed", ->
           it "updates tokens to reflect the change", ->
             buffer.setTextInRange([[1, 0], [3, 0]], "foo()")
 
             # previous line 0 remains
-            expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[0]).toEqual(value: 'var', scopes: ['source.js', 'storage.modifier.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[0]).toEqual(value: 'var', scopeDescriptor: ['source.js', 'storage.modifier.js'])
 
             # previous line 3 should be combined with input to form line 1
-            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0]).toEqual(value: 'foo', scopes: ['source.js'])
-            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[6]).toEqual(value: '=', scopes: ['source.js', 'keyword.operator.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0]).toEqual(value: 'foo', scopeDescriptor: ['source.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[6]).toEqual(value: '=', scopeDescriptor: ['source.js', 'keyword.operator.js'])
 
             # lines below deleted regions should be shifted upward
-            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[2]).toEqual(value: 'while', scopes: ['source.js', 'keyword.control.js'])
-            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[4]).toEqual(value: '=', scopes: ['source.js', 'keyword.operator.js'])
-            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[4]).toEqual(value: '<', scopes: ['source.js', 'keyword.operator.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[2]).toEqual(value: 'while', scopeDescriptor: ['source.js', 'keyword.control.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[4]).toEqual(value: '=', scopeDescriptor: ['source.js', 'keyword.operator.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[4]).toEqual(value: '<', scopeDescriptor: ['source.js', 'keyword.operator.js'])
 
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
@@ -214,8 +214,8 @@ describe "TokenizedBuffer", ->
             changeHandler.reset()
 
             buffer.setTextInRange([[2, 0], [3, 0]], '/*')
-            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[0].scopes).toEqual ['source.js', 'comment.block.js', 'punctuation.definition.comment.js']
-            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopes).toEqual ['source.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js', 'punctuation.definition.comment.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopeDescriptor).toEqual ['source.js']
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
             delete event.bufferChange
@@ -223,8 +223,8 @@ describe "TokenizedBuffer", ->
             changeHandler.reset()
 
             advanceClock()
-            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
             delete event.bufferChange
@@ -235,19 +235,19 @@ describe "TokenizedBuffer", ->
             buffer.setTextInRange([[1, 0], [2, 0]], "foo()\nbar()\nbaz()\nquux()")
 
             # previous line 0 remains
-            expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[0]).toEqual( value: 'var', scopes: ['source.js', 'storage.modifier.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[0]).toEqual( value: 'var', scopeDescriptor: ['source.js', 'storage.modifier.js'])
 
             # 3 new lines inserted
-            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0]).toEqual(value: 'foo', scopes: ['source.js'])
-            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[0]).toEqual(value: 'bar', scopes: ['source.js'])
-            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0]).toEqual(value: 'baz', scopes: ['source.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0]).toEqual(value: 'foo', scopeDescriptor: ['source.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[0]).toEqual(value: 'bar', scopeDescriptor: ['source.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0]).toEqual(value: 'baz', scopeDescriptor: ['source.js'])
 
             # previous line 2 is joined with quux() on line 4
-            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0]).toEqual(value: 'quux', scopes: ['source.js'])
-            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[4]).toEqual(value: 'if', scopes: ['source.js', 'keyword.control.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0]).toEqual(value: 'quux', scopeDescriptor: ['source.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[4]).toEqual(value: 'if', scopeDescriptor: ['source.js', 'keyword.control.js'])
 
             # previous line 3 is pushed down to become line 5
-            expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[4]).toEqual(value: '=', scopes: ['source.js', 'keyword.operator.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[4]).toEqual(value: '=', scopeDescriptor: ['source.js', 'keyword.operator.js'])
 
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
@@ -264,17 +264,17 @@ describe "TokenizedBuffer", ->
             [event] = changeHandler.argsForCall[0]
             delete event.bufferChange
             expect(event).toEqual(start: 2, end: 2, delta: 2)
-            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[0].scopes).toEqual ['source.js', 'comment.block.js', 'punctuation.definition.comment.js']
-            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].scopes).toEqual ['source.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js', 'punctuation.definition.comment.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].scopeDescriptor).toEqual ['source.js']
             changeHandler.reset()
 
             advanceClock() # tokenize invalidated lines in background
-            expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.tokenizedLineForRow(6).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.tokenizedLineForRow(7).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.tokenizedLineForRow(8).tokens[0].scopes).not.toBe ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(6).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(7).tokens[0].scopeDescriptor).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(8).tokens[0].scopeDescriptor).not.toBe ['source.js', 'comment.block.js']
 
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
@@ -343,7 +343,7 @@ describe "TokenizedBuffer", ->
         expect(tokens[0].value).toBe "#"
         expect(tokens[1].value).toBe " Econ 101"
         expect(tokens[2].value).toBe tabAsSpaces
-        expect(tokens[2].scopes).toEqual tokens[1].scopes
+        expect(tokens[2].scopeDescriptor).toEqual tokens[1].scopeDescriptor
         expect(tokens[2].isAtomic).toBeTruthy()
         expect(tokens[3].value).toBe ""
 
@@ -526,7 +526,7 @@ describe "TokenizedBuffer", ->
         fullyTokenize(tokenizedBuffer)
 
         {tokens} = tokenizedBuffer.tokenizedLineForRow(0)
-        expect(tokens[0]).toEqual value: "<div class='name'>", scopes: ["text.html.ruby"]
+        expect(tokens[0]).toEqual value: "<div class='name'>", scopeDescriptor: ["text.html.ruby"]
 
       waitsForPromise ->
         atom.packages.activatePackage('language-html')
@@ -534,7 +534,7 @@ describe "TokenizedBuffer", ->
       runs ->
         fullyTokenize(tokenizedBuffer)
         {tokens} = tokenizedBuffer.tokenizedLineForRow(0)
-        expect(tokens[0]).toEqual value: '<', scopes: ["text.html.ruby","meta.tag.block.any.html","punctuation.definition.tag.begin.html"]
+        expect(tokens[0]).toEqual value: '<', scopeDescriptor: ["text.html.ruby","meta.tag.block.any.html","punctuation.definition.tag.begin.html"]
 
   describe ".tokenForPosition(position)", ->
     afterEach ->
@@ -545,9 +545,9 @@ describe "TokenizedBuffer", ->
       buffer = atom.project.bufferForPathSync('sample.js')
       tokenizedBuffer = new TokenizedBuffer({buffer})
       fullyTokenize(tokenizedBuffer)
-      expect(tokenizedBuffer.tokenForPosition([1,0]).scopes).toEqual ["source.js"]
-      expect(tokenizedBuffer.tokenForPosition([1,1]).scopes).toEqual ["source.js"]
-      expect(tokenizedBuffer.tokenForPosition([1,2]).scopes).toEqual ["source.js", "storage.modifier.js"]
+      expect(tokenizedBuffer.tokenForPosition([1,0]).scopeDescriptor).toEqual ["source.js"]
+      expect(tokenizedBuffer.tokenForPosition([1,1]).scopeDescriptor).toEqual ["source.js"]
+      expect(tokenizedBuffer.tokenForPosition([1,2]).scopeDescriptor).toEqual ["source.js", "storage.modifier.js"]
 
   describe ".bufferRangeForScopeAtPosition(selector, position)", ->
     beforeEach ->

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.scopeDescriptor
 
       waitsForPromise ->
         atom.project.open('coffee.coffee').then (o) -> editor = o

spec/window-spec.coffee

@@ -8,7 +8,7 @@ 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
@@ -16,7 +16,7 @@ describe "Window", ->
     atom.project.destroy()
     windowEventHandler = new WindowEventHandler()
     atom.deserializeEditorWindow()
-    projectPath = atom.project.getPath()
+    projectPath = atom.project.getPaths()[0]
 
   afterEach ->
     windowEventHandler.unsubscribe()
@@ -47,14 +47,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 +55,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 +66,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", ->
@@ -122,7 +114,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 +255,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,88 @@ 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)

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()

src/atom.coffee

@@ -577,7 +577,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: ->
@@ -619,8 +619,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/atom-application.coffee

@@ -376,10 +376,11 @@ class AtomApplication
   # Kill the process with the given pid.
   killProcess: (pid) ->
     try
-      process.kill(pid)
+      parsedPid = parseInt(pid)
+      process.kill(parsedPid) if isFinite(parsedPid)
     catch error
       if error.code isnt 'ESRCH'
-        console.log("Killing process #{pid} failed: #{error.code}")
+        console.log("Killing process #{pid} failed: #{error.code ? error.message}")
     delete @pidsToOpenWindows[pid]
 
   # Open an atom:// url.

src/browser/atom-window.coffee

@@ -28,6 +28,7 @@ class AtomWindow
       title: 'Atom'
       icon: @constructor.iconPath
       'web-preferences':
+        'direct-write': false
         'subpixel-font-scaling': false
     global.atomApplication.addWindow(this)
 

src/browser/context-menu.coffee

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

src/command-installer.coffee

@@ -30,14 +30,41 @@ module.exports =
   getInstallDirectory: ->
     "/usr/local/bin"
 
-  install: (commandPath, askForPrivilege, callback) ->
+  installShellCommandsInteractively: ->
+    showErrorDialog = (error) ->
+      atom.confirm
+        message: "Failed to install shell commands"
+        detailedMessage: error.message
+
+    resourcePath = atom.getLoadSettings().resourcePath
+    @installAtomCommand resourcePath, true, (error) =>
+      if error?
+        showErrorDialog(error)
+      else
+        @installApmCommand resourcePath, true, (error) ->
+          if error?
+            showErrorDialog(error)
+          else
+            atom.confirm
+              message: "Commands installed."
+              detailedMessage: "The shell commands `atom` and `apm` are installed."
+
+  installAtomCommand: (resourcePath, askForPrivilege, callback) ->
+    commandPath = path.join(resourcePath, 'atom.sh')
+    @createSymlink commandPath, askForPrivilege, callback
+
+  installApmCommand: (resourcePath, askForPrivilege, callback) ->
+    commandPath = path.join(resourcePath, 'apm', 'node_modules', '.bin', 'apm')
+    @createSymlink commandPath, askForPrivilege, callback
+
+  createSymlink: (commandPath, askForPrivilege, callback) ->
     return unless process.platform is 'darwin'
 
     commandName = path.basename(commandPath, path.extname(commandPath))
     destinationPath = path.join(@getInstallDirectory(), commandName)
 
     fs.readlink destinationPath, (error, realpath) ->
-      if realpath == commandPath
+      if realpath is commandPath
         callback()
         return
 
@@ -49,11 +76,3 @@ module.exports =
           catch error
 
         callback?(error)
-
-  installAtomCommand: (resourcePath, askForPrivilege, callback) ->
-    commandPath = path.join(resourcePath, 'atom.sh')
-    @install commandPath, askForPrivilege, callback
-
-  installApmCommand: (resourcePath, askForPrivilege, callback) ->
-    commandPath = path.join(resourcePath, 'apm', 'node_modules', '.bin', 'apm')
-    @install commandPath, askForPrivilege, callback

src/command-registry.coffee

@@ -1,4 +1,4 @@
-{Disposable, CompositeDisposable} = require 'event-kit'
+{Emitter, Disposable, CompositeDisposable} = require 'event-kit'
 {specificity} = require 'clear-cut'
 _ = require 'underscore-plus'
 {$} = require './space-pen-extensions'
@@ -35,7 +35,7 @@ module.exports =
 # Here is a command that inserts the current date in an editor:
 #
 # ```coffee
-# atom.commands.add '.editor',
+# atom.commands.add 'atom-text-editor',
 #   'user:insert-date': (event) ->
 #     editor = $(this).view().getModel()
 #     # soon the above above line will be:
@@ -44,17 +44,14 @@ module.exports =
 # ```
 class CommandRegistry
   constructor: (@rootNode) ->
-    @listenersByCommandName = {}
+    @registeredCommands = {}
+    @selectorBasedListenersByCommandName = {}
+    @inlineListenersByCommandName = {}
+    @emitter = new Emitter
 
-  getRootNode: -> @rootNode
-
-  setRootNode: (newRootNode) ->
-    oldRootNode = @rootNode
-    @rootNode = newRootNode
-
-    for commandName of @listenersByCommandName
-      @removeCommandListener(oldRootNode, commandName)
-      @addCommandListener(newRootNode, commandName)
+  destroy: ->
+    for commandName of @registeredCommands
+      window.removeEventListener(commandName, @handleCommandEvent, true)
 
   # Public: Add one or more command listeners associated with a selector.
   #
@@ -81,27 +78,46 @@ class CommandRegistry
   #
   # Returns a {Disposable} on which `.dispose()` can be called to remove the
   # added command handler(s).
-  add: (selector, commandName, callback) ->
+  add: (target, commandName, callback) ->
     if typeof commandName is 'object'
       commands = commandName
       disposable = new CompositeDisposable
       for commandName, callback of commands
-        disposable.add @add(selector, commandName, callback)
+        disposable.add @add(target, commandName, callback)
       return disposable
 
-    unless @listenersByCommandName[commandName]?
-      @addCommandListener(@rootNode, commandName)
-      @listenersByCommandName[commandName] = []
+    if typeof target is 'string'
+      @addSelectorBasedListener(target, commandName, callback)
+    else
+      @addInlineListener(target, commandName, callback)
 
-    listener = new CommandListener(selector, callback)
-    listenersForCommand = @listenersByCommandName[commandName]
+  addSelectorBasedListener: (selector, commandName, callback) ->
+    @selectorBasedListenersByCommandName[commandName] ?= []
+    listenersForCommand = @selectorBasedListenersByCommandName[commandName]
+    listener = new SelectorBasedListener(selector, callback)
     listenersForCommand.push(listener)
 
+    @commandRegistered(commandName)
+
     new Disposable =>
       listenersForCommand.splice(listenersForCommand.indexOf(listener), 1)
-      if listenersForCommand.length is 0
-        delete @listenersByCommandName[commandName]
-        @removeCommandListener(@rootNode, commandName)
+      delete @selectorBasedListenersByCommandName[commandName] if listenersForCommand.length is 0
+
+  addInlineListener: (element, commandName, callback) ->
+    @inlineListenersByCommandName[commandName] ?= new WeakMap
+
+    listenersForCommand = @inlineListenersByCommandName[commandName]
+    unless listenersForElement = listenersForCommand.get(element)
+      listenersForElement = []
+      listenersForCommand.set(element, listenersForElement)
+    listener = new InlineListener(callback)
+    listenersForElement.push(listener)
+
+    @commandRegistered(commandName)
+
+    new Disposable ->
+      listenersForElement.splice(listenersForElement.indexOf(listener), 1)
+      listenersForCommand.delete(element) if listenersForElement.length is 0
 
   # Public: Find all registered commands matching a query.
   #
@@ -116,12 +132,11 @@ class CommandRegistry
   #    `$::command` method.
   findCommands: ({target}) ->
     commands = []
-    target = @rootNode unless @rootNode.contains(target)
     currentTarget = target
     loop
-      for commandName, listeners of @listenersByCommandName
+      for commandName, listeners of @selectorBasedListenersByCommandName
         for listener in listeners
-          if currentTarget.webkitMatchesSelector(listener.selector)
+          if currentTarget.webkitMatchesSelector?(listener.selector)
             commands.push
               name: commandName
               displayName: _.humanizeEventName(commandName)
@@ -147,37 +162,40 @@ class CommandRegistry
   #
   # * `target` The DOM node at which to start bubbling the command event.
   # * `commandName` {String} indicating the name of the command to dispatch.
-  dispatch: (target, commandName) ->
-    event = new CustomEvent(commandName, bubbles: true)
-    eventWithTarget = Object.create(event, target: value: target)
+  dispatch: (target, commandName, detail) ->
+    event = new CustomEvent(commandName, {bubbles: true, detail})
+    eventWithTarget = Object.create event,
+      target: value: target
+      preventDefault: value: ->
+      stopPropagation: value: ->
+      stopImmediatePropagation: value: ->
     @handleCommandEvent(eventWithTarget)
 
+  onWillDispatch: (callback) ->
+    @emitter.on 'will-dispatch', callback
+
   getSnapshot: ->
     snapshot = {}
-    for commandName, listeners of @listenersByCommandName
+    for commandName, listeners of @selectorBasedListenersByCommandName
       snapshot[commandName] = listeners.slice()
     snapshot
 
   restoreSnapshot: (snapshot) ->
-    rootNode = @getRootNode()
-    @setRootNode(null) # clear listeners for current commands
-    @listenersByCommandName = {}
+    @selectorBasedListenersByCommandName = {}
     for commandName, listeners of snapshot
-      @listenersByCommandName[commandName] = listeners.slice()
-    @setRootNode(rootNode) # restore listeners for commands in snapshot
+      @selectorBasedListenersByCommandName[commandName] = listeners.slice()
 
   handleCommandEvent: (originalEvent) =>
-    originalEvent.__handledByCommandRegistry = true
-
     propagationStopped = false
     immediatePropagationStopped = false
     matched = false
     currentTarget = originalEvent.target
-    invokedListeners = []
 
     syntheticEvent = Object.create originalEvent,
       eventPhase: value: Event.BUBBLING_PHASE
       currentTarget: get: -> currentTarget
+      preventDefault: value: ->
+        originalEvent.preventDefault()
       stopPropagation: value: ->
         originalEvent.stopPropagation()
         propagationStopped = true
@@ -185,44 +203,38 @@ class CommandRegistry
         originalEvent.stopImmediatePropagation()
         propagationStopped = true
         immediatePropagationStopped = true
-      disableInvokedListeners: value: ->
-        listener.enabled = false for listener in invokedListeners
-        -> listener.enabled = true for listener in invokedListeners
+      abortKeyBinding: value: ->
+        originalEvent.abortKeyBinding?()
+
+    @emitter.emit 'will-dispatch', syntheticEvent
 
     loop
-      matchingListeners =
-        (@listenersByCommandName[originalEvent.type] ? [])
-          .filter (listener) -> currentTarget.webkitMatchesSelector(listener.selector)
-          .sort (a, b) -> a.compare(b)
+      listeners = @inlineListenersByCommandName[originalEvent.type]?.get(currentTarget) ? []
+      if currentTarget.webkitMatchesSelector?
+        selectorBasedListeners =
+          (@selectorBasedListenersByCommandName[originalEvent.type] ? [])
+            .filter (listener) -> currentTarget.webkitMatchesSelector(listener.selector)
+            .sort (a, b) -> a.compare(b)
+        listeners = listeners.concat(selectorBasedListeners)
 
-      matched = true if matchingListeners.length > 0
+      matched = true if listeners.length > 0
 
-      for listener in matchingListeners when listener.enabled
+      for listener in listeners
         break if immediatePropagationStopped
-        invokedListeners.push(listener)
         listener.callback.call(currentTarget, syntheticEvent)
 
-      break if currentTarget is @rootNode
+      break if currentTarget is window
       break if propagationStopped
-      currentTarget = currentTarget.parentNode
-      break unless currentTarget?
+      currentTarget = currentTarget.parentNode ? window
 
     matched
 
-  handleJQueryCommandEvent: (event) =>
-    @handleCommandEvent(event) unless event.originalEvent?.__handledByCommandRegistry
-
-  addCommandListener: (node, commandName, listener) ->
-    node?.addEventListener(commandName, @handleCommandEvent, true)
-    $(node).on commandName, @handleJQueryCommandEvent
-
-  removeCommandListener: (node, commandName) ->
-    node?.removeEventListener(commandName, @handleCommandEvent, true)
-    $(node).off commandName, @handleJQueryCommandEvent
-
-class CommandListener
-  enabled: true
+  commandRegistered: (commandName) ->
+    unless @registeredCommands[commandName]
+      window.addEventListener(commandName, @handleCommandEvent, true)
+      @registeredCommands[commandName] = true
 
+class SelectorBasedListener
   constructor: (@selector, @callback) ->
     @specificity = (SpecificityCache[@selector] ?= specificity(@selector))
     @sequenceNumber = SequenceCount++
@@ -230,3 +242,6 @@ class CommandListener
   compare: (other) ->
     other.specificity - @specificity  or
       other.sequenceNumber - @sequenceNumber
+
+class InlineListener
+  constructor: (@callback) ->

src/config-schema.coffee

@@ -1,7 +1,8 @@
 path = require 'path'
 fs = require 'fs-plus'
 
-# This is loaded by atom.coffee
+# This is loaded by atom.coffee. See https://atom.io/docs/api/latest/Config for
+# more information about config schemas.
 module.exports =
   core:
     type: 'object'
@@ -14,6 +15,7 @@ module.exports =
       excludeVcsIgnoredPaths:
         type: 'boolean'
         default: true
+        title: 'Exclude VCS Ignored Paths'
       disabledPackages:
         type: 'array'
         default: []
@@ -37,6 +39,19 @@ module.exports =
   editor:
     type: 'object'
     properties:
+      # These settings are used in scoped fashion only. No defaults.
+      commentStart:
+        type: ['string', 'null']
+      commentEnd:
+        type: ['string', 'null']
+      increaseIndentPattern:
+        type: ['string', 'null']
+      decreaseIndentPattern:
+        type: ['string', 'null']
+      foldEndPattern:
+        type: ['string', 'null']
+
+      # These can be used as globals or scoped, thus defaults.
       fontFamily:
         type: 'string'
         default: ''
@@ -72,7 +87,7 @@ module.exports =
       tabLength:
         type: 'integer'
         default: 2
-        minimum: 1
+        enum: [1, 2, 3, 4, 6, 8]
       softWrap:
         type: 'boolean'
         default: false
@@ -93,9 +108,11 @@ module.exports =
       useHardwareAcceleration:
         type: 'boolean'
         default: true
+        description: 'Disabling will improve editor font rendering but reduce scrolling performance.'
       confirmCheckoutHeadRevision:
         type: 'boolean'
         default: true
+        title: 'Confirm Checkout HEAD Revision'
       invisibles:
         type: 'object'
         properties:

src/config.coffee

@@ -1,21 +1,23 @@
 _ = require 'underscore-plus'
 fs = require 'fs-plus'
 EmitterMixin = require('emissary').Emitter
-{Emitter} = require 'event-kit'
+{CompositeDisposable, Disposable, Emitter} = require 'event-kit'
 CSON = require 'season'
 path = require 'path'
 async = require 'async'
 pathWatcher = require 'pathwatcher'
 {deprecate} = require 'grim'
 
+ScopedPropertyStore = require 'scoped-property-store'
+
 # Essential: Used to access all of Atom's configuration details.
 #
 # An instance of this class is always available as the `atom.config` global.
 #
-# ## Getting and setting config settings. Note that with no value set, {::get}
-# returns the setting's default value.
+# ## Getting and setting config settings.
 #
 # ```coffee
+# # Note that with no value set, ::get returns the setting's default value.
 # atom.config.get('my-package.myKey') # -> 'defaultValue'
 #
 # atom.config.set('my-package.myKey', 'value')
@@ -219,7 +221,7 @@ pathWatcher = require 'pathwatcher'
 #
 # All types support an `enum` key. The enum key lets you specify all values
 # that the config setting can possibly be. `enum` _must_ be an array of values
-# of your specified type.
+# of your specified type. Schema:
 #
 # ```coffee
 # config:
@@ -229,6 +231,8 @@ pathWatcher = require 'pathwatcher'
 #     enum: [2, 4, 6, 8]
 # ```
 #
+# Usage:
+#
 # ```coffee
 # atom.config.set('my-package.someSetting', '2')
 # atom.config.get('my-package.someSetting') # -> 2
@@ -307,6 +311,8 @@ class Config
       properties: {}
     @defaultSettings = {}
     @settings = {}
+    @scopedSettingsStore = new ScopedPropertyStore
+    @usersScopedSettings = new CompositeDisposable
     @configFileHasErrors = false
     @configFilePath = fs.resolve(@configDirPath, 'config', ['json', 'cson'])
     @configFilePath ?= path.join(@configDirPath, 'config.cson')
@@ -319,29 +325,57 @@ class Config
   # than {::onDidChange} in that it will immediately call your callback with the
   # current value of the config entry.
   #
+  # ### Examples
+  #
+  # You might want to be notified when the themes change. We'll watch
+  # `core.themes` for changes
+  #
+  # ```coffee
+  # atom.config.observe 'core.themes', (value) ->
+  #   # do stuff with value
+  # ```
+  #
+  # * `scopeDescriptor` (optional) {Array} of {String}s describing a path from
+  #   the root of the syntax tree to a token. Get one by calling
+  #   {editor.getLastCursor().getScopeDescriptor()}. See {::get} for examples.
   # * `keyPath` {String} name of the key to observe
   # * `callback` {Function} to call when the value of the key changes.
   #   * `value` the new value of the key
   #
   # Returns a {Disposable} with the following keys on which you can call
   # `.dispose()` to unsubscribe.
-  observe: (keyPath, options={}, callback) ->
-    if _.isFunction(options)
-      callback = options
-      options = {}
-    else
+  observe: (scopeDescriptor, keyPath, options, callback) ->
+    args = Array::slice.call(arguments)
+    if args.length is 2
+      # observe(keyPath, callback)
+      [keyPath, callback, scopeDescriptor, options] = args
+    else if args.length is 3 and Array.isArray(scopeDescriptor)
+      # observe(scopeDescriptor, keyPath, callback)
+      [scopeDescriptor, keyPath, callback, options] = args
+    else if args.length is 3 and _.isString(scopeDescriptor) and _.isObject(keyPath)
+      # observe(keyPath, options, callback) # Deprecated!
+      [keyPath, options, callback, scopeDescriptor] = args
+
       message = ""
       message = "`callNow` was set to false. Use ::onDidChange instead. Note that ::onDidChange calls back with different arguments." if options.callNow == false
-      deprecate "Config::observe no longer supports options. #{message}"
+      deprecate "Config::observe no longer supports options; see https://atom.io/docs/api/latest/Config. #{message}"
+    else
+      console.error 'An unsupported form of Config::observe is being used. See https://atom.io/docs/api/latest/Config for details'
+      return
 
-    callback(_.clone(@get(keyPath))) unless options.callNow == false
-    @emitter.on 'did-change', (event) =>
-      callback(event.newValue) if keyPath? and keyPath.indexOf(event?.keyPath) is 0
+    if scopeDescriptor?
+      @observeScopedKeyPath(scopeDescriptor, keyPath, callback)
+    else
+      @observeKeyPath(keyPath, options ? {}, callback)
 
   # Essential: Add a listener for changes to a given key path. If `keyPath` is
   # not specified, your callback will be called on changes to any key.
   #
-  # * `keyPath` (optional) {String} name of the key to observe
+  # * `scopeDescriptor` (optional) {Array} of {String}s describing a path from
+  #   the root of the syntax tree to a token. Get one by calling
+  #   {editor.getLastCursor().getScopeDescriptor()}. See {::get} for examples.
+  # * `keyPath` (optional) {String} name of the key to observe. Must be
+  #   specified if `scopeDescriptor` is specified.
   # * `callback` {Function} to call when the value of the key changes.
   #   * `event` {Object}
   #     * `newValue` the new value of the key
@@ -350,13 +384,17 @@ class Config
   #
   # Returns a {Disposable} with the following keys on which you can call
   # `.dispose()` to unsubscribe.
-  onDidChange: (keyPath, callback) ->
+  onDidChange: (scopeDescriptor, keyPath, callback) ->
+    args = Array::slice.call(arguments)
     if arguments.length is 1
-      callback = keyPath
-      keyPath = undefined
+      [callback, scopeDescriptor, keyPath] = args
+    else if arguments.length is 2
+      [keyPath, callback, scopeDescriptor] = args
 
-    @emitter.on 'did-change', (event) =>
-      callback(event) if not keyPath? or (keyPath? and keyPath.indexOf(event?.keyPath) is 0)
+    if scopeDescriptor?
+      @onDidChangeScopedKeyPath(scopeDescriptor, keyPath, callback)
+    else
+      @onDidChangeKeyPath(keyPath, callback)
 
   ###
   Section: Managing Settings
@@ -364,29 +402,91 @@ class Config
 
   # Essential: Retrieves the setting for the given key.
   #
+  # ### Examples
+  #
+  # You might want to know what themes are enabled, so check `core.themes`
+  #
+  # ```coffee
+  # atom.config.get('core.themes')
+  # ```
+  #
+  # With scope descriptors you can get settings within a specific editor
+  # scope. For example, you might want to know `editor.tabLength` for ruby
+  # files.
+  #
+  # ```coffee
+  # atom.config.get(['source.ruby'], 'editor.tabLength') # => 2
+  # ```
+  #
+  # This setting in ruby files might be different than the global tabLength setting
+  #
+  # ```coffee
+  # atom.config.get('editor.tabLength') # => 4
+  # atom.config.get(['source.ruby'], 'editor.tabLength') # => 2
+  # ```
+  #
+  # You can get the language scope descriptor via
+  # {TextEditor::getRootScopeDescriptor}. This will get the setting specifically
+  # for the editor's language.
+  #
+  # ```coffee
+  # atom.config.get(@editor.getRootScopeDescriptor(), 'editor.tabLength') # => 2
+  # ```
+  #
+  # Additionally, you can get the setting at the specific cursor position.
+  #
+  # ```coffee
+  # scopeDescriptor = @editor.getLastCursor().getScopeDescriptor()
+  # atom.config.get(scopeDescriptor, 'editor.tabLength') # => 2
+  # ```
+  #
+  # * `scopeDescriptor` (optional) {Array} of {String}s describing a path from
+  #   the root of the syntax tree to a token. Get one by calling
+  #   {editor.getLastCursor().getScopeDescriptor()}
   # * `keyPath` The {String} name of the key to retrieve.
   #
   # Returns the value from Atom's default settings, the user's configuration
   # file in the type specified by the configuration schema.
-  get: (keyPath) ->
-    value = _.valueForKeyPath(@settings, keyPath)
-    defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
-
-    if value?
-      value = _.deepClone(value)
-      valueIsObject = _.isObject(value) and not _.isArray(value)
-      defaultValueIsObject = _.isObject(defaultValue) and not _.isArray(defaultValue)
-      if valueIsObject and defaultValueIsObject
-        _.defaults(value, defaultValue)
+  get: (scopeDescriptor, keyPath) ->
+    if arguments.length == 1
+      # cannot assign to keyPath for the sake of v8 optimization
+      globalKeyPath = scopeDescriptor
+      @getRawValue(globalKeyPath)
     else
-      value = _.deepClone(defaultValue)
-
-    value
+      value = @getRawScopedValue(scopeDescriptor, keyPath)
+      value ?= @getRawValue(keyPath)
+      value
 
   # Essential: Sets the value for a configuration setting.
   #
   # This value is stored in Atom's internal configuration file.
   #
+  # ### Examples
+  #
+  # You might want to change the themes programmatically:
+  #
+  # ```coffee
+  # atom.config.set('core.themes', ['atom-light-ui', 'atom-light-syntax'])
+  # ```
+  #
+  # You can also set scoped settings. For example, you might want change the
+  # `editor.tabLength` only for ruby files.
+  #
+  # ```coffee
+  # atom.config.get('editor.tabLength') # => 4
+  # atom.config.get(['source.ruby'], 'editor.tabLength') # => 4
+  # atom.config.get(['source.js'], 'editor.tabLength') # => 4
+  #
+  # # Set ruby to 2
+  # atom.config.set('source.ruby', 'editor.tabLength', 2) # => true
+  #
+  # # Notice it's only set to 2 in the case of ruby
+  # atom.config.get('editor.tabLength') # => 4
+  # atom.config.get(['source.ruby'], 'editor.tabLength') # => 2
+  # atom.config.get(['source.js'], 'editor.tabLength') # => 4
+  # ```
+  #
+  # * `scope` (optional) {String}. eg. '.source.ruby'
   # * `keyPath` The {String} name of the key.
   # * `value` The value of the setting. Passing `undefined` will revert the
   #   setting to the default value.
@@ -394,18 +494,27 @@ class Config
   # Returns a {Boolean}
   # * `true` if the value was set.
   # * `false` if the value was not able to be coerced to the type specified in the setting's schema.
-  set: (keyPath, value) ->
+  set: (scope, keyPath, value) ->
+    if arguments.length < 3
+      value = keyPath
+      keyPath = scope
+      scope = undefined
+
     unless value == undefined
       try
         value = @makeValueConformToSchema(keyPath, value)
       catch e
         return false
 
-    @setRawValue(keyPath, value)
+    if scope?
+      @setRawScopedValue(scope, keyPath, value)
+    else
+      @setRawValue(keyPath, value)
+
     @save() unless @configFileHasErrors
     true
 
-  # Extended: Restore the key path to its default value.
+  # Extended: Restore the global setting at `keyPath` to its default value.
   #
   # * `keyPath` The {String} name of the key.
   #
@@ -414,7 +523,7 @@ class Config
     @set(keyPath, _.valueForKeyPath(@defaultSettings, keyPath))
     @get(keyPath)
 
-  # Extended: Get the default value of the key path. _Please note_ that in most
+  # Extended: Get the global default value of the key path. _Please note_ that in most
   # cases calling this is not necessary! {::get} returns the default value when
   # a custom value is not specified.
   #
@@ -425,7 +534,7 @@ class Config
     defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
     _.deepClone(defaultValue)
 
-  # Extended: Is the key path value its default value?
+  # Extended: Is the value at `keyPath` its default value?
   #
   # * `keyPath` The {String} name of the key.
   #
@@ -434,7 +543,7 @@ class Config
   isDefault: (keyPath) ->
     not _.valueForKeyPath(@settings, keyPath)?
 
-  # Extended: Retrieve the schema for a specific key path. The shema will tell
+  # Extended: Retrieve the schema for a specific key path. The schema will tell
   # you what type the keyPath expects, and other metadata about the config
   # option.
   #
@@ -450,7 +559,8 @@ class Config
       schema = schema.properties[key]
     schema
 
-  # Extended: Returns a new {Object} containing all of settings and defaults.
+  # Extended: Returns a new {Object} containing all of the global settings and
+  # defaults. This does not include scoped settings.
   getSettings: ->
     _.deepExtend(@settings, @defaultSettings)
 
@@ -484,7 +594,7 @@ class Config
     deprecate 'Config::unobserve no longer does anything. Call `.dispose()` on the object returned by Config::observe instead.'
 
   ###
-  Section: Private
+  Section: Internal methods used by core
   ###
 
   pushAtKeyPath: (keyPath, value) ->
@@ -505,103 +615,6 @@ class Config
     @set(keyPath, arrayValue)
     result
 
-  initializeConfigDirectory: (done) ->
-    return if fs.existsSync(@configDirPath)
-
-    fs.makeTreeSync(@configDirPath)
-
-    queue = async.queue ({sourcePath, destinationPath}, callback) ->
-      fs.copy(sourcePath, destinationPath, callback)
-    queue.drain = done
-
-    templateConfigDirPath = fs.resolve(@resourcePath, 'dot-atom')
-    onConfigDirFile = (sourcePath) =>
-      relativePath = sourcePath.substring(templateConfigDirPath.length + 1)
-      destinationPath = path.join(@configDirPath, relativePath)
-      queue.push({sourcePath, destinationPath})
-    fs.traverseTree(templateConfigDirPath, onConfigDirFile, (path) -> true)
-
-  load: ->
-    @initializeConfigDirectory()
-    @loadUserConfig()
-    @observeUserConfig()
-
-  loadUserConfig: ->
-    unless fs.existsSync(@configFilePath)
-      fs.makeTreeSync(path.dirname(@configFilePath))
-      CSON.writeFileSync(@configFilePath, {})
-
-    try
-      userConfig = CSON.readFileSync(@configFilePath)
-      @settings = {} # Reset to the defaults
-      if isPlainObject(userConfig)
-        @setRecursive(null, userConfig)
-      else
-        @emitter.emit 'did-change'
-      @configFileHasErrors = false
-    catch error
-      @configFileHasErrors = true
-      console.error "Failed to load user config '#{@configFilePath}'", error.message
-      console.error error.stack
-
-  observeUserConfig: ->
-    try
-      @watchSubscription ?= pathWatcher.watch @configFilePath, (eventType) =>
-        @loadUserConfig() if eventType is 'change' and @watchSubscription?
-    catch error
-      console.error "Failed to watch user config '#{@configFilePath}'", error.message
-      console.error error.stack
-
-  unobserveUserConfig: ->
-    @watchSubscription?.close()
-    @watchSubscription = null
-
-  save: ->
-    CSON.writeFileSync(@configFilePath, @settings)
-
-  setRawValue: (keyPath, value) ->
-    defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
-    value = undefined if _.isEqual(defaultValue, value)
-
-    oldValue = _.clone(@get(keyPath))
-    _.setValueForKeyPath(@settings, keyPath, value)
-    newValue = @get(keyPath)
-    @emitter.emit 'did-change', {oldValue, newValue, keyPath} if newValue isnt oldValue
-
-  setRawDefault: (keyPath, value) ->
-    oldValue = _.clone(@get(keyPath))
-    _.setValueForKeyPath(@defaultSettings, keyPath, value)
-    newValue = @get(keyPath)
-    @emitter.emit 'did-change', {oldValue, newValue, keyPath} if newValue isnt oldValue
-
-  setRecursive: (keyPath, value) ->
-    if value? and isPlainObject(value)
-      keys = if keyPath? then keyPath.split('.') else []
-      for key, childValue of value
-        continue unless value.hasOwnProperty(key)
-        @setRecursive(keys.concat([key]).join('.'), childValue)
-    else
-      try
-        value = @makeValueConformToSchema(keyPath, value)
-        @setRawValue(keyPath, value)
-      catch e
-        console.warn("'#{keyPath}' could not be set. Attempted value: #{JSON.stringify(value)}; Schema: #{JSON.stringify(@getSchema(keyPath))}")
-
-    return
-
-  setDefaults: (keyPath, defaults) ->
-    if defaults? and isPlainObject(defaults)
-      keys = if keyPath? then keyPath.split('.') else []
-      for key, childValue of defaults
-        continue unless defaults.hasOwnProperty(key)
-        @setDefaults(keys.concat([key]).join('.'), childValue)
-    else
-      try
-        defaults = @makeValueConformToSchema(keyPath, defaults)
-        @setRawDefault(keyPath, defaults)
-      catch e
-        console.warn("'#{keyPath}' could not set the default. Attempted default: #{JSON.stringify(defaults)}; Schema: #{JSON.stringify(@getSchema(keyPath))}")
-
   setSchema: (keyPath, schema) ->
     unless isPlainObject(schema)
       throw new Error("Error loading schema for #{keyPath}: schemas can only be objects!")
@@ -621,6 +634,159 @@ class Config
     _.extend rootSchema, schema
     @setDefaults(keyPath, @extractDefaultsFromSchema(schema))
 
+  load: ->
+    @initializeConfigDirectory()
+    @loadUserConfig()
+    @observeUserConfig()
+
+  ###
+  Section: Private methods managing the user's config file
+  ###
+
+  initializeConfigDirectory: (done) ->
+    return if fs.existsSync(@configDirPath)
+
+    fs.makeTreeSync(@configDirPath)
+
+    queue = async.queue ({sourcePath, destinationPath}, callback) ->
+      fs.copy(sourcePath, destinationPath, callback)
+    queue.drain = done
+
+    templateConfigDirPath = fs.resolve(@resourcePath, 'dot-atom')
+    onConfigDirFile = (sourcePath) =>
+      relativePath = sourcePath.substring(templateConfigDirPath.length + 1)
+      destinationPath = path.join(@configDirPath, relativePath)
+      queue.push({sourcePath, destinationPath})
+    fs.traverseTree(templateConfigDirPath, onConfigDirFile, (path) -> true)
+
+  loadUserConfig: ->
+    unless fs.existsSync(@configFilePath)
+      fs.makeTreeSync(path.dirname(@configFilePath))
+      CSON.writeFileSync(@configFilePath, {})
+
+    try
+      userConfig = CSON.readFileSync(@configFilePath)
+      @resetUserSettings(userConfig)
+      @configFileHasErrors = false
+    catch error
+      @configFileHasErrors = true
+      console.error "Failed to load user config '#{@configFilePath}'", error.message
+      console.error error.stack
+
+  observeUserConfig: ->
+    try
+      @watchSubscription ?= pathWatcher.watch @configFilePath, (eventType) =>
+        @loadUserConfig() if eventType is 'change' and @watchSubscription?
+    catch error
+      console.error "Failed to watch user config '#{@configFilePath}'", error.message
+      console.error error.stack
+
+  unobserveUserConfig: ->
+    @watchSubscription?.close()
+    @watchSubscription = null
+
+  save: ->
+    allSettings = global: @settings
+    allSettings = _.extend allSettings, @scopedSettingsStore.propertiesForSource('user-config')
+    CSON.writeFileSync(@configFilePath, allSettings)
+
+  ###
+  Section: Private methods managing global settings
+  ###
+
+  resetUserSettings: (newSettings) ->
+    unless isPlainObject(newSettings)
+      @settings = {}
+      @emitter.emit 'did-change'
+      return
+
+    if newSettings.global?
+      scopedSettings = newSettings
+      newSettings = newSettings.global
+      delete scopedSettings.global
+      @resetUserScopedSettings(scopedSettings)
+
+    unsetUnspecifiedValues = (keyPath, value) =>
+      if isPlainObject(value)
+        keys = if keyPath? then keyPath.split('.') else []
+        for key, childValue of value
+          continue unless value.hasOwnProperty(key)
+          unsetUnspecifiedValues(keys.concat([key]).join('.'), childValue)
+      else
+        @setRawValue(keyPath, undefined) unless _.valueForKeyPath(newSettings, keyPath)?
+      return
+
+    @setRecursive(null, newSettings)
+    unsetUnspecifiedValues(null, @settings)
+
+  setRecursive: (keyPath, value) ->
+    if isPlainObject(value)
+      keys = if keyPath? then keyPath.split('.') else []
+      for key, childValue of value
+        continue unless value.hasOwnProperty(key)
+        @setRecursive(keys.concat([key]).join('.'), childValue)
+    else
+      try
+        value = @makeValueConformToSchema(keyPath, value)
+        @setRawValue(keyPath, value)
+      catch e
+        console.warn("'#{keyPath}' could not be set. Attempted value: #{JSON.stringify(value)}; Schema: #{JSON.stringify(@getSchema(keyPath))}")
+
+  getRawValue: (keyPath) ->
+    value = _.valueForKeyPath(@settings, keyPath)
+    defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
+
+    if value?
+      value = _.deepClone(value)
+      _.defaults(value, defaultValue) if isPlainObject(value) and isPlainObject(defaultValue)
+    else
+      value = _.deepClone(defaultValue)
+
+    value
+
+  setRawValue: (keyPath, value) ->
+    defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
+    value = undefined if _.isEqual(defaultValue, value)
+
+    oldValue = _.clone(@get(keyPath))
+    _.setValueForKeyPath(@settings, keyPath, value)
+    newValue = @get(keyPath)
+    @emitter.emit 'did-change', {oldValue, newValue, keyPath} unless _.isEqual(newValue, oldValue)
+
+  observeKeyPath: (keyPath, options, callback) ->
+    callback(_.clone(@get(keyPath))) unless options.callNow == false
+    @emitter.on 'did-change', (event) =>
+      callback(event.newValue) if keyPath? and @isSubKeyPath(keyPath, event?.keyPath)
+
+  onDidChangeKeyPath: (keyPath, callback) ->
+    @emitter.on 'did-change', (event) =>
+      callback(event) if not keyPath? or (keyPath? and @isSubKeyPath(keyPath, event?.keyPath))
+
+  isSubKeyPath: (keyPath, subKeyPath) ->
+    return false unless keyPath? and subKeyPath?
+    pathSubTokens = subKeyPath.split('.')
+    pathTokens = keyPath.split('.').slice(0, pathSubTokens.length)
+    _.isEqual(pathTokens, pathSubTokens)
+
+  setRawDefault: (keyPath, value) ->
+    oldValue = _.clone(@get(keyPath))
+    _.setValueForKeyPath(@defaultSettings, keyPath, value)
+    newValue = @get(keyPath)
+    @emitter.emit 'did-change', {oldValue, newValue, keyPath} unless _.isEqual(newValue, oldValue)
+
+  setDefaults: (keyPath, defaults) ->
+    if defaults? and isPlainObject(defaults)
+      keys = if keyPath? then keyPath.split('.') else []
+      for key, childValue of defaults
+        continue unless defaults.hasOwnProperty(key)
+        @setDefaults(keys.concat([key]).join('.'), childValue)
+    else
+      try
+        defaults = @makeValueConformToSchema(keyPath, defaults)
+        @setRawDefault(keyPath, defaults)
+      catch e
+        console.warn("'#{keyPath}' could not set the default. Attempted default: #{JSON.stringify(defaults)}; Schema: #{JSON.stringify(@getSchema(keyPath))}")
+
   extractDefaultsFromSchema: (schema) ->
     if schema.default?
       schema.default
@@ -634,6 +800,76 @@ class Config
     value = @constructor.executeSchemaEnforcers(keyPath, value, schema) if schema = @getSchema(keyPath)
     value
 
+  ###
+  Section: Private Scoped Settings
+  ###
+
+  resetUserScopedSettings: (newScopedSettings) ->
+    @usersScopedSettings?.dispose()
+    @usersScopedSettings = new CompositeDisposable
+    @usersScopedSettings.add @scopedSettingsStore.addProperties('user-config', newScopedSettings)
+    @emitter.emit 'did-change'
+
+  addScopedSettings: (name, selector, value) ->
+    settingsBySelector = {}
+    settingsBySelector[selector] = value
+    disposable = @scopedSettingsStore.addProperties(name, settingsBySelector)
+    @emitter.emit 'did-change'
+    new Disposable =>
+      disposable.dispose()
+      @emitter.emit 'did-change'
+
+  setRawScopedValue: (selector, keyPath, value) ->
+    if keyPath?
+      newValue = {}
+      _.setValueForKeyPath(newValue, keyPath, value)
+      value = newValue
+
+    settingsBySelector = {}
+    settingsBySelector[selector] = value
+    @usersScopedSettings.add @scopedSettingsStore.addProperties('user-config', settingsBySelector)
+    @emitter.emit 'did-change'
+
+  getRawScopedValue: (scopeDescriptor, keyPath) ->
+    scopeChain = scopeDescriptor
+      .map (scope) ->
+        scope = ".#{scope}" unless scope[0] is '.'
+        scope
+      .join(' ')
+    @scopedSettingsStore.getPropertyValue(scopeChain, keyPath)
+
+  observeScopedKeyPath: (scopeDescriptor, keyPath, callback) ->
+    oldValue = @get(scopeDescriptor, keyPath)
+
+    callback(oldValue)
+
+    didChange = =>
+      newValue = @get(scopeDescriptor, keyPath)
+      callback(newValue) unless _.isEqual(oldValue, newValue)
+      oldValue = newValue
+
+    @emitter.on 'did-change', didChange
+
+  onDidChangeScopedKeyPath: (scopeDescriptor, keyPath, callback) ->
+    oldValue = @get(scopeDescriptor, keyPath)
+    didChange = =>
+      newValue = @get(scopeDescriptor, keyPath)
+      callback({oldValue, newValue, keyPath}) unless _.isEqual(oldValue, newValue)
+      oldValue = newValue
+
+    @emitter.on 'did-change', didChange
+
+  # TODO: figure out how to change / remove this. The return value is awkward.
+  # * language mode uses it for one thing.
+  # * autocomplete uses it for editor.completions
+  settingsForScopeDescriptor: (scopeDescriptor, keyPath) ->
+    scopeChain = scopeDescriptor
+      .map (scope) ->
+        scope = ".#{scope}" unless scope[0] is '.'
+        scope
+      .join(' ')
+    @scopedSettingsStore.getProperties(scopeChain, keyPath)
+
 # Base schema enforcers. These will coerce raw input into the specified type,
 # and will throw an error when the value cannot be coerced. Throwing the error
 # will indicate that the value should not be set.
@@ -679,7 +915,7 @@ Config.addSchemaEnforcers
   'null':
     # null sort of isnt supported. It will just unset in this case
     coerce: (keyPath, value, schema) ->
-      throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} must be null") unless value == null
+      throw new Error("Validation failed at #{keyPath}, #{JSON.stringify(value)} must be null") unless value in [undefined, null]
       value
 
   'object':

src/context-menu-manager.coffee

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

src/cursor.coffee

@@ -198,7 +198,7 @@ class Cursor extends Model
     [before, after] = @editor.getTextInBufferRange(range)
     return false if /\s/.test(before) or /\s/.test(after)
 
-    nonWordCharacters = atom.config.get('editor.nonWordCharacters').split('')
+    nonWordCharacters = atom.config.get(@getScopeDescriptor(), 'editor.nonWordCharacters').split('')
     _.contains(nonWordCharacters, before) isnt _.contains(nonWordCharacters, after)
 
   # Public: Returns whether this cursor is between a word's start and end.
@@ -214,11 +214,14 @@ class Cursor extends Model
     else
       @getBufferColumn()
 
-  # Public: Retrieves the grammar's token scopes for the line.
+  # Public: Retrieves the scope descriptor for the cursor's current position.
   #
   # Returns an {Array} of {String}s.
+  getScopeDescriptor: ->
+    @editor.scopeDescriptorForBufferPosition(@getBufferPosition())
   getScopes: ->
-    @editor.scopesForBufferPosition(@getBufferPosition())
+    Grim.deprecate 'Use Cursor::getScopeDescriptor() instead'
+    @getScopeDescriptor()
 
   # Public: Returns true if this cursor has no non-whitespace characters before
   # its current position.
@@ -617,7 +620,7 @@ class Cursor extends Model
   # Returns a {RegExp}.
   wordRegExp: ({includeNonWordCharacters}={}) ->
     includeNonWordCharacters ?= true
-    nonWordCharacters = atom.config.get('editor.nonWordCharacters')
+    nonWordCharacters = atom.config.get(@getScopeDescriptor(), 'editor.nonWordCharacters')
     segments = ["^[\t ]*$"]
     segments.push("[^\\s#{_.escapeRegExp(nonWordCharacters)}]+")
     if includeNonWordCharacters

src/display-buffer.coffee

@@ -3,7 +3,7 @@ EmitterMixin = require('emissary').Emitter
 guid = require 'guid'
 Serializable = require 'serializable'
 {Model} = require 'theorist'
-{Emitter} = require 'event-kit'
+{CompositeDisposable, Emitter} = require 'event-kit'
 {Point, Range} = require 'text-buffer'
 TokenizedBuffer = require './tokenized-buffer'
 RowMap = require './row-map'
@@ -45,7 +45,6 @@ class DisplayBuffer extends Model
 
     @emitter = new Emitter
 
-    @softWrapped ?= atom.config.get('editor.softWrap') ? false
     @tokenizedBuffer ?= new TokenizedBuffer({tabLength, buffer, @invisibles})
     @buffer = @tokenizedBuffer.buffer
     @charWidthsByScope = {}
@@ -53,19 +52,42 @@ class DisplayBuffer extends Model
     @foldsByMarkerId = {}
     @decorationsById = {}
     @decorationsByMarkerId = {}
-    @updateAllScreenLines()
-    @createFoldForMarker(marker) for marker in @buffer.findMarkers(@getFoldMarkerAttributes())
+    @subscribe @tokenizedBuffer.observeGrammar @subscribeToScopedConfigSettings
     @subscribe @tokenizedBuffer.onDidChange @handleTokenizedBufferChange
     @subscribe @buffer.onDidUpdateMarkers @handleBufferMarkersUpdated
     @subscribe @buffer.onDidCreateMarker @handleBufferMarkerCreated
+    @updateAllScreenLines()
+    @createFoldForMarker(marker) for marker in @buffer.findMarkers(@getFoldMarkerAttributes())
 
-    @subscribe atom.config.onDidChange 'editor.preferredLineLength', =>
-      @updateWrappedScreenLines() if @isSoftWrapped() and atom.config.get('editor.softWrapAtPreferredLineLength')
+  subscribeToScopedConfigSettings: =>
+    @scopedConfigSubscriptions?.dispose()
+    @scopedConfigSubscriptions = subscriptions = new CompositeDisposable
 
-    @subscribe atom.config.onDidChange 'editor.softWrapAtPreferredLineLength', =>
+    scopeDescriptor = @getRootScopeDescriptor()
+
+    oldConfigSettings = @configSettings
+    @configSettings =
+      scrollPastEnd: atom.config.get(scopeDescriptor, 'editor.scrollPastEnd')
+      softWrap: atom.config.get(scopeDescriptor, 'editor.softWrap')
+      softWrapAtPreferredLineLength: atom.config.get(scopeDescriptor, 'editor.softWrapAtPreferredLineLength')
+      preferredLineLength: atom.config.get(scopeDescriptor, 'editor.preferredLineLength')
+
+    subscriptions.add atom.config.onDidChange scopeDescriptor, 'editor.softWrap', ({newValue}) =>
+      @configSettings.softWrap = newValue
+      @updateWrappedScreenLines()
+
+    subscriptions.add atom.config.onDidChange scopeDescriptor, 'editor.softWrapAtPreferredLineLength', ({newValue}) =>
+      @configSettings.softWrapAtPreferredLineLength = newValue
       @updateWrappedScreenLines() if @isSoftWrapped()
 
-    @updateAllScreenLines()
+    subscriptions.add atom.config.onDidChange scopeDescriptor, 'editor.preferredLineLength', ({newValue}) =>
+      @configSettings.preferredLineLength = newValue
+      @updateWrappedScreenLines() if @isSoftWrapped() and atom.config.get(scopeDescriptor, 'editor.softWrapAtPreferredLineLength')
+
+    subscriptions.add atom.config.observe scopeDescriptor, 'editor.scrollPastEnd', (value) =>
+      @configSettings.scrollPastEnd = value
+
+    @updateWrappedScreenLines() if oldConfigSettings? and not _.isEqual(oldConfigSettings, @configSettings)
 
   serializeParams: ->
     id: @id
@@ -319,7 +341,7 @@ class DisplayBuffer extends Model
     return 0 unless lineHeight > 0
 
     scrollHeight = @getLineCount() * lineHeight
-    if @height? and atom.config.get('editor.scrollPastEnd')
+    if @height? and @configSettings.scrollPastEnd
       scrollHeight = scrollHeight + @height - (lineHeight * 3)
 
     scrollHeight
@@ -412,11 +434,15 @@ class DisplayBuffer extends Model
     if softWrapped isnt @softWrapped
       @softWrapped = softWrapped
       @updateWrappedScreenLines()
-      @emit 'soft-wrap-changed', @softWrapped
-      @emitter.emit 'did-change-soft-wrapped', @softWrapped
-    @softWrapped
+      softWrapped = @isSoftWrapped()
+      @emit 'soft-wrap-changed', softWrapped
+      @emitter.emit 'did-change-soft-wrapped', softWrapped
+      softWrapped
+    else
+      @isSoftWrapped()
 
-  isSoftWrapped: -> @softWrapped
+  isSoftWrapped: ->
+    @softWrapped ? @configSettings.softWrap ? false
 
   # Set the number of characters that fit horizontally in the editor.
   #
@@ -438,8 +464,8 @@ class DisplayBuffer extends Model
       @editorWidthInChars
 
   getSoftWrapColumn: ->
-    if atom.config.get('editor.softWrapAtPreferredLineLength')
-      Math.min(@getEditorWidthInChars(), atom.config.get('editor.preferredLineLength'))
+    if @configSettings.softWrapAtPreferredLineLength
+      Math.min(@getEditorWidthInChars(), @configSettings.preferredLineLength)
     else
       @getEditorWidthInChars()
 
@@ -624,7 +650,7 @@ class DisplayBuffer extends Model
     left = 0
     column = 0
     for token in @tokenizedLineForScreenRow(targetRow).tokens
-      charWidths = @getScopedCharWidths(token.scopes)
+      charWidths = @getScopedCharWidths(token.scopeDescriptor)
       for char in token.value
         return {top, left} if column is targetColumn
         left += charWidths[char] ? defaultCharWidth unless char is '\0'
@@ -642,7 +668,7 @@ class DisplayBuffer extends Model
     left = 0
     column = 0
     for token in @tokenizedLineForScreenRow(row).tokens
-      charWidths = @getScopedCharWidths(token.scopes)
+      charWidths = @getScopedCharWidths(token.scopeDescriptor)
       for char in token.value
         charWidth = charWidths[char] ? defaultCharWidth
         break if targetLeft <= left + (charWidth / 2)
@@ -726,13 +752,13 @@ class DisplayBuffer extends Model
     [bufferRow] = @rowMap.bufferRowRangeForScreenRow(row)
     new Point(bufferRow, @screenLines[row].bufferColumnForScreenColumn(column))
 
-  # Retrieves the grammar's token scopes for a buffer position.
+  # Retrieves the grammar's token scopeDescriptor for a buffer position.
   #
   # bufferPosition - A {Point} in the {TextBuffer}
   #
   # Returns an {Array} of {String}s.
-  scopesForBufferPosition: (bufferPosition) ->
-    @tokenizedBuffer.scopesForPosition(bufferPosition)
+  scopeDescriptorForBufferPosition: (bufferPosition) ->
+    @tokenizedBuffer.scopeDescriptorForPosition(bufferPosition)
 
   bufferRangeForScopeAtPosition: (selector, position) ->
     @tokenizedBuffer.bufferRangeForScopeAtPosition(selector, position)
@@ -1034,6 +1060,9 @@ class DisplayBuffer extends Model
       line = @tokenizedLineForScreenRow(row).text
       console.log row, @bufferRowForScreenRow(row), line, line.length
 
+  getRootScopeDescriptor: ->
+    @tokenizedBuffer.rootScopeDescriptor
+
   handleTokenizedBufferChange: (tokenizedBufferChange) =>
     {start, end, delta, bufferChange} = tokenizedBufferChange
     @updateScreenLines(start, end + 1, delta, delayChangeEvent: bufferChange?)

src/language-mode.coffee

@@ -29,12 +29,12 @@ class LanguageMode
   #
   # Returns an {Array} of the commented {Ranges}.
   toggleLineCommentsForBufferRows: (start, end) ->
-    scopes = @editor.scopesForBufferPosition([start, 0])
-    properties = atom.syntax.propertiesForScope(scopes, "editor.commentStart")[0]
+    scopeDescriptor = @editor.scopeDescriptorForBufferPosition([start, 0])
+    properties = atom.config.settingsForScopeDescriptor(scopeDescriptor, 'editor.commentStart')[0]
     return unless properties
 
-    commentStartString = _.valueForKeyPath(properties, "editor.commentStart")
-    commentEndString = _.valueForKeyPath(properties, "editor.commentEnd")
+    commentStartString = _.valueForKeyPath(properties, 'editor.commentStart')
+    commentEndString = _.valueForKeyPath(properties, 'editor.commentEnd')
 
     return unless commentStartString
 
@@ -168,12 +168,12 @@ class LanguageMode
     return null unless @isFoldableAtBufferRow(bufferRow)
 
     startIndentLevel = @editor.indentationForBufferRow(bufferRow)
-    scopes = @editor.scopesForBufferPosition([bufferRow, 0])
+    scopeDescriptor = @editor.scopeDescriptorForBufferPosition([bufferRow, 0])
     for row in [(bufferRow + 1)..@editor.getLastBufferRow()]
       continue if @editor.isBufferRowBlank(row)
       indentation = @editor.indentationForBufferRow(row)
       if indentation <= startIndentLevel
-        includeRowInFold = indentation == startIndentLevel and @foldEndRegexForScopes(scopes)?.searchSync(@editor.lineTextForBufferRow(row))
+        includeRowInFold = indentation == startIndentLevel and @foldEndRegexForScopeDescriptor(scopeDescriptor)?.searchSync(@editor.lineTextForBufferRow(row))
         foldEndRow = row if includeRowInFold
         break
 
@@ -246,8 +246,8 @@ class LanguageMode
   # Returns a {Number}.
   suggestedIndentForBufferRow: (bufferRow) ->
     currentIndentLevel = @editor.indentationForBufferRow(bufferRow)
-    scopes = @editor.scopesForBufferPosition([bufferRow, 0])
-    return currentIndentLevel unless increaseIndentRegex = @increaseIndentRegexForScopes(scopes)
+    scopeDescriptor = @editor.scopeDescriptorForBufferPosition([bufferRow, 0])
+    return currentIndentLevel unless increaseIndentRegex = @increaseIndentRegexForScopeDescriptor(scopeDescriptor)
 
     currentLine = @buffer.lineForRow(bufferRow)
     precedingRow = if bufferRow > 0 then bufferRow - 1 else null
@@ -257,7 +257,7 @@ class LanguageMode
     desiredIndentLevel = @editor.indentationForBufferRow(precedingRow)
     desiredIndentLevel += 1 if increaseIndentRegex.testSync(precedingLine) and not @editor.isBufferRowCommented(precedingRow)
 
-    return desiredIndentLevel unless decreaseIndentRegex = @decreaseIndentRegexForScopes(scopes)
+    return desiredIndentLevel unless decreaseIndentRegex = @decreaseIndentRegexForScopeDescriptor(scopeDescriptor)
     desiredIndentLevel -= 1 if decreaseIndentRegex.testSync(currentLine)
 
     Math.max(desiredIndentLevel, 0)
@@ -292,9 +292,9 @@ class LanguageMode
   #
   # bufferRow - The row {Number}
   autoDecreaseIndentForBufferRow: (bufferRow) ->
-    scopes = @editor.scopesForBufferPosition([bufferRow, 0])
-    increaseIndentRegex = @increaseIndentRegexForScopes(scopes)
-    decreaseIndentRegex = @decreaseIndentRegexForScopes(scopes)
+    scopeDescriptor = @editor.scopeDescriptorForBufferPosition([bufferRow, 0])
+    increaseIndentRegex = @increaseIndentRegexForScopeDescriptor(scopeDescriptor)
+    decreaseIndentRegex = @decreaseIndentRegexForScopeDescriptor(scopeDescriptor)
     return unless increaseIndentRegex and decreaseIndentRegex
 
     line = @buffer.lineForRow(bufferRow)
@@ -311,15 +311,15 @@ class LanguageMode
     if desiredIndentLevel >= 0 and desiredIndentLevel < currentIndentLevel
       @editor.setIndentationForBufferRow(bufferRow, desiredIndentLevel)
 
-  getRegexForProperty: (scopes, property) ->
-    if pattern = atom.syntax.getProperty(scopes, property)
+  getRegexForProperty: (scopeDescriptor, property) ->
+    if pattern = atom.config.get(scopeDescriptor, property)
       new OnigRegExp(pattern)
 
-  increaseIndentRegexForScopes: (scopes) ->
-    @getRegexForProperty(scopes, 'editor.increaseIndentPattern')
+  increaseIndentRegexForScopeDescriptor: (scopeDescriptor) ->
+    @getRegexForProperty(scopeDescriptor, 'editor.increaseIndentPattern')
 
-  decreaseIndentRegexForScopes: (scopes) ->
-    @getRegexForProperty(scopes, 'editor.decreaseIndentPattern')
+  decreaseIndentRegexForScopeDescriptor: (scopeDescriptor) ->
+    @getRegexForProperty(scopeDescriptor, 'editor.decreaseIndentPattern')
 
-  foldEndRegexForScopes: (scopes) ->
-    @getRegexForProperty(scopes, 'editor.foldEndPattern')
+  foldEndRegexForScopeDescriptor: (scopeDescriptor) ->
+    @getRegexForProperty(scopeDescriptor, 'editor.foldEndPattern')

src/lines-component.coffee

@@ -200,7 +200,7 @@ LinesComponent = React.createClass
     firstTrailingWhitespacePosition = text.search(/\s*$/)
     lineIsWhitespaceOnly = firstTrailingWhitespacePosition is 0
     for token in tokens
-      innerHTML += @updateScopeStack(scopeStack, token.scopes)
+      innerHTML += @updateScopeStack(scopeStack, token.scopeDescriptor)
       hasIndentGuide = not mini and showIndentGuide and (token.hasLeadingWhitespace() or (token.hasTrailingWhitespace() and lineIsWhitespaceOnly))
       innerHTML += token.getValueAsHtml({hasIndentGuide})
 
@@ -217,20 +217,20 @@ LinesComponent = React.createClass
         html += "<span class='invisible-character'>#{invisible}</span>"
     html
 
-  updateScopeStack: (scopeStack, desiredScopes) ->
+  updateScopeStack: (scopeStack, desiredScopeDescriptor) ->
     html = ""
 
     # Find a common prefix
-    for scope, i in desiredScopes
-      break unless scopeStack[i] is desiredScopes[i]
+    for scope, i in desiredScopeDescriptor
+      break unless scopeStack[i] is desiredScopeDescriptor[i]
 
-    # Pop scopes until we're at the common prefx
+    # Pop scopeDescriptor until we're at the common prefx
     until scopeStack.length is i
       html += @popScope(scopeStack)
 
-    # Push onto common prefix until scopeStack equals desiredScopes
-    for j in [i...desiredScopes.length]
-      html += @pushScope(scopeStack, desiredScopes[j])
+    # Push onto common prefix until scopeStack equals desiredScopeDescriptor
+    for j in [i...desiredScopeDescriptor.length]
+      html += @pushScope(scopeStack, desiredScopeDescriptor[j])
 
     html
 
@@ -308,8 +308,8 @@ LinesComponent = React.createClass
     iterator = null
     charIndex = 0
 
-    for {value, scopes}, tokenIndex in tokenizedLine.tokens
-      charWidths = editor.getScopedCharWidths(scopes)
+    for {value, scopeDescriptor}, tokenIndex in tokenizedLine.tokens
+      charWidths = editor.getScopedCharWidths(scopeDescriptor)
 
       for char in value
         continue if char is '\0'
@@ -331,7 +331,7 @@ LinesComponent = React.createClass
           rangeForMeasurement.setStart(textNode, i)
           rangeForMeasurement.setEnd(textNode, i + 1)
           charWidth = rangeForMeasurement.getBoundingClientRect().width
-          editor.setScopedCharWidth(scopes, char, charWidth)
+          editor.setScopedCharWidth(scopeDescriptor, char, charWidth)
 
         charIndex++
 

src/marker.coffee

@@ -160,7 +160,7 @@ class Marker
   getProperties: ->
     @bufferMarker.getProperties()
   getAttributes: ->
-    deprecate 'Use Marker::getProperties instead'
+    Grim.deprecate 'Use Marker::getProperties instead'
     @getProperties()
 
   # Essential: Merges an {Object} containing new properties into the marker's
@@ -170,14 +170,14 @@ class Marker
   setProperties: (properties) ->
     @bufferMarker.setProperties(properties)
   setAttributes: (properties) ->
-    deprecate 'Use Marker::getProperties instead'
+    Grim.deprecate 'Use Marker::getProperties instead'
     @setProperties(properties)
 
   matchesProperties: (attributes) ->
     attributes = @displayBuffer.translateToBufferMarkerParams(attributes)
     @bufferMarker.matchesParams(attributes)
   matchesAttributes: (attributes) ->
-    deprecate 'Use Marker::matchesProperties instead'
+    Grim.deprecate 'Use Marker::matchesProperties instead'
     @matchesProperties(attributes)
 
   ###

src/menu-helpers.coffee

@@ -0,0 +1,52 @@
+_ = require 'underscore-plus'
+
+ItemSpecificities = new WeakMap
+
+merge = (menu, item, itemSpecificity=Infinity) ->
+  item = cloneMenuItem(item)
+  ItemSpecificities.set(item, itemSpecificity) if itemSpecificity
+  matchingItemIndex = findMatchingItemIndex(menu, item)
+  matchingItem = menu[matchingItemIndex] unless matchingItemIndex is - 1
+
+  if matchingItem?
+    if item.submenu?
+      merge(matchingItem.submenu, submenuItem, itemSpecificity) for submenuItem in item.submenu
+    else if itemSpecificity
+      unless itemSpecificity < ItemSpecificities.get(matchingItem)
+        menu[matchingItemIndex] = item
+  else unless item.type is 'separator' and _.last(menu)?.type is 'separator'
+    menu.push(item)
+
+unmerge = (menu, item) ->
+  matchingItemIndex = findMatchingItemIndex(menu, item)
+  matchingItem = menu[matchingItemIndex] unless matchingItemIndex is - 1
+
+  if matchingItem?
+    if item.submenu?
+      unmerge(matchingItem.submenu, submenuItem) for submenuItem in item.submenu
+
+    unless matchingItem.submenu?.length > 0
+      menu.splice(matchingItemIndex, 1)
+
+findMatchingItemIndex = (menu, {type, label, submenu}) ->
+  return -1 if type is 'separator'
+  for item, index in menu
+    if normalizeLabel(item.label) is normalizeLabel(label) and item.submenu? is submenu?
+      return index
+  -1
+
+normalizeLabel = (label) ->
+  return undefined unless label?
+
+  if process.platform is 'darwin'
+    label
+  else
+    label.replace(/\&/g, '')
+
+cloneMenuItem = (item) ->
+  item = _.pick(item, 'type', 'label', 'command', 'submenu', 'commandDetail')
+  if item.submenu?
+    item.submenu = item.submenu.map (submenuItem) -> cloneMenuItem(submenuItem)
+  item
+
+module.exports = {merge, unmerge, normalizeLabel, cloneMenuItem}

src/menu-manager.coffee

@@ -6,6 +6,8 @@ CSON = require 'season'
 fs = require 'fs-plus'
 {Disposable} = require 'event-kit'
 
+MenuHelpers = require './menu-helpers'
+
 # Extended: Provides a registry for menu items that you'd like to appear in the
 # application menu.
 #
@@ -39,6 +41,7 @@ class MenuManager
   # Returns a {Disposable} on which `.dispose()` can be called to remove the
   # added menu items.
   add: (items) ->
+    items = _.deepClone(items)
     @merge(@template, item) for item in items
     @update()
     new Disposable => @remove(items)
@@ -60,14 +63,14 @@ class MenuManager
       # Selector isn't valid
       return false
 
-    # Simulate an .editor element attached to a .workspace element attached to
-    # a body element that has the same classes as the current body element.
+    # Simulate an atom-text-editor element attached to a atom-workspace element attached
+    # to a body element that has the same classes as the current body element.
     unless @testEditor?
       testBody = document.createElement('body')
       testBody.classList.add(@classesForElement(document.body)...)
 
       testWorkspace = document.createElement('div')
-      workspaceClasses = @classesForElement(document.body.querySelector('.workspace'))
+      workspaceClasses = @classesForElement(document.body.querySelector('atom-workspace'))
       workspaceClasses = ['workspace'] if workspaceClasses.length is 0
       testWorkspace.classList.add(workspaceClasses...)
 
@@ -103,30 +106,10 @@ class MenuManager
   # Merges an item in a submenu aware way such that new items are always
   # appended to the bottom of existing menus where possible.
   merge: (menu, item) ->
-    item = _.deepClone(item)
-    matchingItem = @findMatchingItem(menu, item)
-
-    if matchingItem?
-      if item.submenu?
-        @merge(matchingItem.submenu, submenuItem) for submenuItem in item.submenu
-    else
-      menu.push(item)
+    MenuHelpers.merge(menu, item)
 
   unmerge: (menu, item) ->
-    if matchingItem = @findMatchingItem(menu, item)
-      if item.submenu?
-        @unmerge(matchingItem.submenu, submenuItem) for submenuItem in item.submenu
-
-      unless matchingItem.submenu?.length > 0
-        menu.splice(menu.indexOf(matchingItem), 1)
-
-  # find an existing menu item matching the given item
-  findMatchingItem: (menu, {label, submenu}) ->
-    debugger unless menu?
-    for item in menu
-      if @normalizeLabel(item.label) is @normalizeLabel(label) and item.submenu? is submenu?
-        return item
-    null
+    MenuHelpers.unmerge(menu, item)
 
   # OSX can't handle displaying accelerators for multiple keystrokes.
   # If they are sent across, it will stop processing accelerators for the rest
@@ -145,25 +128,17 @@ class MenuManager
     keystrokesByCommand = @filterMultipleKeystroke(keystrokesByCommand)
     ipc.send 'update-application-menu', template, keystrokesByCommand
 
-  normalizeLabel: (label) ->
-    return undefined unless label?
-
-    if process.platform is 'darwin'
-      label
-    else
-      label.replace(/\&/g, '')
-
   # Get an {Array} of {String} classes for the given element.
   classesForElement: (element) ->
     element?.classList.toString().split(' ') ? []
 
   sortPackagesMenu: ->
-    packagesMenu = @template.find ({label}) => @normalizeLabel(label) is 'Packages'
+    packagesMenu = @template.find ({label}) -> MenuHelpers.normalizeLabel(label) is 'Packages'
     return unless packagesMenu?.submenu?
 
-    packagesMenu.submenu.sort (item1, item2) =>
+    packagesMenu.submenu.sort (item1, item2) ->
       if item1.label and item2.label
-        @normalizeLabel(item1.label).localeCompare(@normalizeLabel(item2.label))
+        MenuHelpers.normalizeLabel(item1.label).localeCompare(MenuHelpers.normalizeLabel(item2.label))
       else
         0
     @update()

src/package-manager.coffee

@@ -256,7 +256,7 @@ class PackageManager
     metadata?.engines?.atom?
 
   unobserveDisabledPackages: ->
-    @disabledPackagesSubscription?.off()
+    @disabledPackagesSubscription?.dispose()
     @disabledPackagesSubscription = null
 
   observeDisabledPackages: ->

src/package.coffee

@@ -162,9 +162,10 @@ class Package
     @stylesheetsActivated = true
 
   activateResources: ->
-    atom.keymaps.add(keymapPath, map) for [keymapPath, map] in @keymaps
-    atom.contextMenu.add(menuPath, map['context-menu']) for [menuPath, map] in @menus
-    atom.menu.add(map.menu) for [menuPath, map] in @menus when map.menu
+    @activationDisposables = new CompositeDisposable
+    @activationDisposables.add(atom.keymaps.add(keymapPath, map)) for [keymapPath, map] in @keymaps
+    @activationDisposables.add(atom.contextMenu.add(map['context-menu'])) for [menuPath, map] in @menus
+    @activationDisposables.add(atom.menu.add(map.menu)) for [menuPath, map] in @menus when map.menu
 
     unless @grammarsActivated
       grammar.activate() for grammar in @grammars
@@ -294,8 +295,8 @@ class Package
   deactivateResources: ->
     grammar.deactivate() for grammar in @grammars
     scopedProperties.deactivate() for scopedProperties in @scopedProperties
-    atom.keymaps.remove(keymapPath) for [keymapPath] in @keymaps
     atom.themes.removeStylesheet(stylesheetPath) for [stylesheetPath] in @stylesheets
+    @activationDisposables?.dispose()
     @stylesheetsActivated = false
     @grammarsActivated = false
     @scopedPropertiesActivated = false
@@ -334,9 +335,18 @@ class Package
     @activationCommandSubscriptions = new CompositeDisposable
     for selector, commands of @getActivationCommands()
       for command in commands
-        @activationCommandSubscriptions.add(
-          atom.commands.add(selector, command, @handleActivationCommand)
-        )
+        do (selector, command) =>
+          atom.commands.commandRegistered(command)
+          @activationCommandSubscriptions.add(atom.commands.onWillDispatch (event) =>
+            return unless event.type is command
+            currentTarget = event.target
+            while currentTarget
+              if currentTarget.webkitMatchesSelector(selector)
+                @activationCommandSubscriptions.dispose()
+                @activateNow()
+                break
+              currentTarget = currentTarget.parentElement
+          )
 
   getActivationCommands: ->
     return @activationCommands if @activationCommands?
@@ -354,28 +364,20 @@ class Package
     if @metadata.activationEvents?
       if _.isArray(@metadata.activationEvents)
         for eventName in @metadata.activationEvents
-          @activationCommands['.workspace'] ?= []
-          @activationCommands['.workspace'].push(eventName)
+          @activationCommands['atom-workspace'] ?= []
+          @activationCommands['atom-workspace'].push(eventName)
       else if _.isString(@metadata.activationEvents)
         eventName = @metadata.activationEvents
-        @activationCommands['.workspace'] ?= []
-        @activationCommands['.workspace'].push(eventName)
+        @activationCommands['atom-workspace'] ?= []
+        @activationCommands['atom-workspace'].push(eventName)
       else
         for eventName, selector of @metadata.activationEvents
-          selector ?= '.workspace'
+          selector ?= 'atom-workspace'
           @activationCommands[selector] ?= []
           @activationCommands[selector].push(eventName)
 
     @activationCommands
 
-  handleActivationCommand: (event) =>
-    event.stopImmediatePropagation()
-    @activationCommandSubscriptions.dispose()
-    reenableInvokedListeners = event.disableInvokedListeners()
-    @activateNow()
-    event.target.dispatchEvent(new CustomEvent(event.type, bubbles: true))
-    reenableInvokedListeners()
-
   # Does the given module path contain native code?
   isNativeModule: (modulePath) ->
     try

src/pane-axis-element.coffee

@@ -0,0 +1,42 @@
+{CompositeDisposable} = require 'event-kit'
+{callAttachHooks} = require './space-pen-extensions'
+
+class PaneAxisElement extends HTMLElement
+  createdCallback: ->
+    @subscriptions = new CompositeDisposable
+
+  detachedCallback: ->
+    @subscriptions.dispose()
+
+  setModel: (@model) ->
+    @subscriptions.add @model.onDidAddChild(@childAdded.bind(this))
+    @subscriptions.add @model.onDidRemoveChild(@childRemoved.bind(this))
+    @subscriptions.add @model.onDidReplaceChild(@childReplaced.bind(this))
+
+    @childAdded({child, index}) for child, index in @model.getChildren()
+
+    switch @model.getOrientation()
+      when 'horizontal'
+        @classList.add('horizontal', 'pane-row')
+      when 'vertical'
+        @classList.add('vertical', 'pane-column')
+
+  childAdded: ({child, index}) ->
+    view = @model.getView(child)
+    @insertBefore(view, @children[index])
+    callAttachHooks(view) # for backward compatibility with SpacePen views
+
+  childRemoved: ({child}) ->
+    view = @model.getView(child)
+    view.remove()
+
+  childReplaced:  ({index, oldChild, newChild}) ->
+    focusedElement = document.activeElement if @hasFocus()
+    @childRemoved({child: oldChild, index})
+    @childAdded({child: newChild, index})
+    focusedElement?.focus() if document.activeElement is document.body
+
+  hasFocus: ->
+    this is document.activeElement or @contains(document.activeElement)
+
+module.exports = PaneAxisElement = document.registerElement 'atom-pane-axis', prototype: PaneAxisElement.prototype

src/pane-axis-view.coffee

@@ -1,37 +0,0 @@
-{CompositeDisposable} = require 'event-kit'
-{View} = require './space-pen-extensions'
-PaneView = null
-
-module.exports =
-class PaneAxisView extends View
-  initialize: (@model) ->
-    @subscriptions = new CompositeDisposable
-
-    @onChildAdded({child, index}) for child, index in @model.getChildren()
-
-    @subscriptions.add @model.onDidAddChild(@onChildAdded)
-    @subscriptions.add @model.onDidRemoveChild(@onChildRemoved)
-    @subscriptions.add @model.onDidReplaceChild(@onChildReplaced)
-
-  afterAttach: ->
-    @container = @closest('.panes').view()
-
-  onChildReplaced:  ({index, oldChild, newChild}) =>
-    focusedElement = document.activeElement if @hasFocus()
-    @onChildRemoved({child: oldChild, index})
-    @onChildAdded({child: newChild, index})
-    focusedElement?.focus() if document.activeElement is document.body
-
-  onChildAdded: ({child, index}) =>
-    view = @model.getView(child).__spacePenView
-    @insertAt(index, view)
-
-  onChildRemoved: ({child}) =>
-    view = @model.getView(child).__spacePenView
-    view.detach()
-    PaneView ?= require './pane-view'
-    if view instanceof PaneView and view.model.isDestroyed()
-      @container?.trigger 'pane:removed', [view]
-
-  beforeRemove: ->
-    @subscriptions.dispose()

src/pane-axis.coffee

@@ -3,9 +3,6 @@
 {flatten} = require 'underscore-plus'
 Serializable = require 'serializable'
 
-PaneRowView = null
-PaneColumnView = null
-
 module.exports =
 class PaneAxis extends Model
   atom.deserializers.add(this)
@@ -40,11 +37,7 @@ class PaneAxis extends Model
 
   setContainer: (@container) -> @container
 
-  getViewClass: ->
-    if @orientation is 'vertical'
-      PaneColumnView ?= require './pane-column-view'
-    else
-      PaneRowView ?= require './pane-row-view'
+  getOrientation: -> @orientation
 
   getView: (object) ->
     @container.getView(object)

src/pane-column-view.coffee

@@ -1,12 +0,0 @@
-{$} = require './space-pen-extensions'
-_ = require 'underscore-plus'
-PaneAxisView = require './pane-axis-view'
-
-module.exports =
-class PaneColumnView extends PaneAxisView
-
-  @content: ->
-    @div class: 'pane-column'
-
-  className: ->
-    "PaneColumn"

src/pane-container-element.coffee

@@ -0,0 +1,78 @@
+{CompositeDisposable} = require 'event-kit'
+{callAttachHooks} = require './space-pen-extensions'
+PaneContainerView = null
+_ = require 'underscore-plus'
+
+module.exports =
+class PaneContainerElement extends HTMLElement
+  createdCallback: ->
+    @subscriptions = new CompositeDisposable
+    @classList.add 'panes'
+    PaneContainerView ?= require './pane-container-view'
+    @__spacePenView = new PaneContainerView(this)
+
+  setModel: (@model) ->
+    @subscriptions.add @model.observeRoot(@rootChanged.bind(this))
+    @__spacePenView.setModel(@model)
+
+  rootChanged: (root) ->
+    focusedElement = document.activeElement if @hasFocus()
+    @firstChild?.remove()
+    if root?
+      view = @model.getView(root)
+      @appendChild(view)
+      callAttachHooks(view)
+      focusedElement?.focus()
+
+  hasFocus: ->
+    this is document.activeElement or @contains(document.activeElement)
+
+  focusPaneViewAbove: ->
+    @nearestPaneInDirection('above')?.focus()
+
+  focusPaneViewBelow: ->
+    @nearestPaneInDirection('below')?.focus()
+
+  focusPaneViewOnLeft: ->
+    @nearestPaneInDirection('left')?.focus()
+
+  focusPaneViewOnRight: ->
+    @nearestPaneInDirection('right')?.focus()
+
+  nearestPaneInDirection: (direction) ->
+    distance = (pointA, pointB) ->
+      x = pointB.x - pointA.x
+      y = pointB.y - pointA.y
+      Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2))
+
+    paneView = @model.getView(@model.getActivePane())
+    box = @boundingBoxForPaneView(paneView)
+
+    paneViews = _.toArray(@querySelectorAll('atom-pane'))
+      .filter (otherPaneView) =>
+        otherBox = @boundingBoxForPaneView(otherPaneView)
+        switch direction
+          when 'left' then otherBox.right.x <= box.left.x
+          when 'right' then otherBox.left.x >= box.right.x
+          when 'above' then otherBox.bottom.y <= box.top.y
+          when 'below' then otherBox.top.y >= box.bottom.y
+      .sort (paneViewA, paneViewB) =>
+        boxA = @boundingBoxForPaneView(paneViewA)
+        boxB = @boundingBoxForPaneView(paneViewB)
+        switch direction
+          when 'left' then distance(box.left, boxA.right) - distance(box.left, boxB.right)
+          when 'right' then distance(box.right, boxA.left) - distance(box.right, boxB.left)
+          when 'above' then distance(box.top, boxA.bottom) - distance(box.top, boxB.bottom)
+          when 'below' then distance(box.bottom, boxA.top) - distance(box.bottom, boxB.top)
+
+    paneViews[0]
+
+  boundingBoxForPaneView: (paneView) ->
+    boundingBox = paneView.getBoundingClientRect()
+
+    left: {x: boundingBox.left, y: boundingBox.top}
+    right: {x: boundingBox.right, y: boundingBox.top}
+    top: {x: boundingBox.left, y: boundingBox.top}
+    bottom: {x: boundingBox.left, y: boundingBox.bottom}
+
+module.exports = PaneContainerElement = document.registerElement 'atom-pane-container', prototype: PaneContainerElement.prototype

src/pane-container-view.coffee

@@ -1,7 +1,7 @@
 {deprecate} = require 'grim'
 Delegator = require 'delegato'
 {CompositeDisposable} = require 'event-kit'
-{$, View} = require './space-pen-extensions'
+{$, View, callAttachHooks} = require './space-pen-extensions'
 PaneView = require './pane-view'
 PaneContainer = require './pane-container'
 
@@ -15,53 +15,25 @@ class PaneContainerView extends View
   @content: ->
     @div class: 'panes'
 
-  initialize: (params) ->
+  constructor: (@element) ->
+    super
     @subscriptions = new CompositeDisposable
 
-    if params instanceof PaneContainer
-      @model = params
-    else
-      @model = new PaneContainer({root: params?.root?.model})
-
-    @subscriptions.add @model.observeRoot(@onRootChanged)
+  setModel: (@model) ->
     @subscriptions.add @model.onDidChangeActivePaneItem(@onActivePaneItemChanged)
 
   getRoot: ->
-    @children().first().view()
-
-  onRootChanged: (root) =>
-    focusedElement = document.activeElement if @hasFocus()
-
-    oldRoot = @getRoot()
-    if oldRoot instanceof PaneView and oldRoot.model.isDestroyed()
-      @trigger 'pane:removed', [oldRoot]
-    oldRoot?.detach()
-    if root?
-      view = @model.getView(root).__spacePenView
-      @append(view)
-      focusedElement?.focus()
-    else
-      atom.workspaceView?.focus() if focusedElement?
+    view = @model.getView(@model.getRoot())
+    view.__spacePenView ? view
 
   onActivePaneItemChanged: (activeItem) =>
     @trigger 'pane-container:active-pane-item-changed', [activeItem]
 
-  removeChild: (child) ->
-    throw new Error("Removing non-existant child") unless @getRoot() is child
-    @setRoot(null)
-    @trigger 'pane:removed', [child] if child instanceof PaneView
-
   confirmClose: ->
-    saved = true
-    for paneView in @getPaneViews()
-      for item in paneView.getItems()
-        if not paneView.promptToSaveItem(item)
-          saved = false
-          break
-    saved
+    @model.confirmClose()
 
   getPaneViews: ->
-    @find('.pane').views()
+    @find('atom-pane').views()
 
   indexOfPane: (paneView) ->
     @getPaneViews().indexOf(paneView.view())
@@ -76,7 +48,7 @@ class PaneContainerView extends View
     off: => @off 'pane:attached', paneViewAttached
 
   getFocusedPane: ->
-    @find('.pane:has(:focus)').view()
+    @find('atom-pane:has(:focus)').view()
 
   getActivePane: ->
     deprecate("Use PaneContainerView::getActivePaneView instead.")
@@ -101,56 +73,17 @@ class PaneContainerView extends View
     @model.activatePreviousPane()
 
   focusPaneViewAbove: ->
-    @nearestPaneInDirection('above')?.focus()
+    @element.focusPaneViewAbove()
 
   focusPaneViewBelow: ->
-    @nearestPaneInDirection('below')?.focus()
+    @element.focusPaneViewBelow()
 
   focusPaneViewOnLeft: ->
-    @nearestPaneInDirection('left')?.focus()
+    @element.focusPaneViewOnLeft()
 
   focusPaneViewOnRight: ->
-    @nearestPaneInDirection('right')?.focus()
+    @element.focusPaneViewOnRight()
 
-  nearestPaneInDirection: (direction) ->
-    distance = (pointA, pointB) ->
-      x = pointB.x - pointA.x
-      y = pointB.y - pointA.y
-      Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2))
-
-    paneView = @getActivePaneView()
-    box = @boundingBoxForPaneView(paneView)
-    paneViews = @getPaneViews()
-      .filter (otherPaneView) =>
-        otherBox = @boundingBoxForPaneView(otherPaneView)
-        switch direction
-          when 'left' then otherBox.right.x <= box.left.x
-          when 'right' then otherBox.left.x >= box.right.x
-          when 'above' then otherBox.bottom.y <= box.top.y
-          when 'below' then otherBox.top.y >= box.bottom.y
-      .sort (paneViewA, paneViewB) =>
-        boxA = @boundingBoxForPaneView(paneViewA)
-        boxB = @boundingBoxForPaneView(paneViewB)
-        switch direction
-          when 'left' then distance(box.left, boxA.right) - distance(box.left, boxB.right)
-          when 'right' then distance(box.right, boxA.left) - distance(box.right, boxB.left)
-          when 'above' then distance(box.top, boxA.bottom) - distance(box.top, boxB.bottom)
-          when 'below' then distance(box.bottom, boxA.top) - distance(box.bottom, boxB.top)
-
-    paneViews[0]
-
-  boundingBoxForPaneView: (paneView) ->
-    boundingBox = paneView[0].getBoundingClientRect()
-
-    left: {x: boundingBox.left, y: boundingBox.top}
-    right: {x: boundingBox.right, y: boundingBox.top}
-    top: {x: boundingBox.left, y: boundingBox.top}
-    bottom: {x: boundingBox.left, y: boundingBox.bottom}
-
-  # Deprecated
   getPanes: ->
     deprecate("Use PaneContainerView::getPaneViews() instead")
     @getPaneViews()
-
-  beforeRemove: ->
-    @subscriptions.dispose()

src/pane-container.coffee

@@ -3,9 +3,14 @@
 {Emitter, CompositeDisposable} = require 'event-kit'
 Serializable = require 'serializable'
 Pane = require './pane'
+PaneElement = require './pane-element'
+PaneContainerElement = require './pane-container-element'
+PaneAxisElement = require './pane-axis-element'
+PaneAxis = require './pane-axis'
+TextEditor = require './text-editor'
+TextEditorElement = require './text-editor-element'
 ViewRegistry = require './view-registry'
 ItemRegistry = require './item-registry'
-PaneContainerView = null
 
 module.exports =
 class PaneContainer extends Model
@@ -30,8 +35,10 @@ class PaneContainer extends Model
     @emitter = new Emitter
     @subscriptions = new CompositeDisposable
 
-    @viewRegistry = params?.viewRegistry ? new ViewRegistry
     @itemRegistry = new ItemRegistry
+    @viewRegistry = params?.viewRegistry ? new ViewRegistry
+    @registerViewProviders()
+
     @setRoot(params?.root ? new Pane)
     @destroyEmptyPanes() if params?.destroyEmptyPanes
 
@@ -48,8 +55,22 @@ class PaneContainer extends Model
     root: @root?.serialize()
     activePaneId: @activePane.id
 
-  getViewClass: ->
-    PaneContainerView ?= require './pane-container-view'
+  registerViewProviders: ->
+    @viewRegistry.addViewProvider
+      modelConstructor: PaneContainer
+      viewConstructor: PaneContainerElement
+
+    @viewRegistry.addViewProvider
+      modelConstructor: PaneAxis
+      viewConstructor: PaneAxisElement
+
+    @viewRegistry.addViewProvider
+      modelConstructor: Pane
+      viewConstructor: PaneElement
+
+    @viewRegistry.addViewProvider
+      modelConstructor: TextEditor
+      viewConstructor: TextEditorElement
 
   getView: (object) ->
     @viewRegistry.getView(object)
@@ -129,6 +150,17 @@ class PaneContainer extends Model
   saveAll: ->
     pane.saveItems() for pane in @getPanes()
 
+  confirmClose: ->
+    allSaved = true
+
+    for pane in @getPanes()
+      for item in pane.getItems()
+        unless pane.promptToSaveItem(item)
+          allSaved = false
+          break
+
+    allSaved
+
   activateNextPane: ->
     panes = @getPanes()
     if panes.length > 1

src/pane-element.coffee

@@ -0,0 +1,126 @@
+{CompositeDisposable} = require 'event-kit'
+{$, callAttachHooks, callRemoveHooks} = require './space-pen-extensions'
+PaneView = require './pane-view'
+
+class PaneElement extends HTMLElement
+  attached: false
+
+  createdCallback: ->
+    @attached = false
+    @subscriptions = new CompositeDisposable
+    @inlineDisplayStyles = new WeakMap
+
+    @initializeContent()
+    @subscribeToDOMEvents()
+    @createSpacePenShim()
+
+  attachedCallback: ->
+    @attached = true
+    @focus() if @model.isFocused()
+
+  detachedCallback: ->
+    @attached = false
+
+  initializeContent: ->
+    @setAttribute 'class', 'pane'
+    @setAttribute 'tabindex', -1
+    @appendChild @itemViews = document.createElement('div')
+    @itemViews.setAttribute 'class', 'item-views'
+
+  subscribeToDOMEvents: ->
+    @addEventListener 'focusin', => @model.focus()
+    @addEventListener 'focusout', => @model.blur()
+    @addEventListener 'focus', => @getActiveView()?.focus()
+
+  createSpacePenShim: ->
+    @__spacePenView = new PaneView(this)
+
+    addCommands = (handlersByName) =>
+      for name, handler of handlersByName
+        do (handler) =>
+          @__spacePenView.command name, => handler.apply(this, arguments)
+
+    addCommands(
+      'pane:save-items': -> @getModel().saveItems()
+      'pane:show-next-item': -> @getModel().activateNextItem()
+      'pane:show-previous-item': -> @getModel().activatePreviousItem()
+      'pane:show-item-1': -> @getModel().activateItemAtIndex(0)
+      'pane:show-item-2': -> @getModel().activateItemAtIndex(1)
+      'pane:show-item-3': -> @getModel().activateItemAtIndex(2)
+      'pane:show-item-4': -> @getModel().activateItemAtIndex(3)
+      'pane:show-item-5': -> @getModel().activateItemAtIndex(4)
+      'pane:show-item-6': -> @getModel().activateItemAtIndex(5)
+      'pane:show-item-7': -> @getModel().activateItemAtIndex(6)
+      'pane:show-item-8': -> @getModel().activateItemAtIndex(7)
+      'pane:show-item-9': -> @getModel().activateItemAtIndex(8)
+      'pane:split-left': -> @getModel().splitLeft(copyActiveItem: true)
+      'pane:split-right': -> @getModel().splitRight(copyActiveItem: true)
+      'pane:split-up': -> @getModel().splitUp(copyActiveItem: true)
+      'pane:split-down': -> @getModel().splitDown(copyActiveItem: true)
+      'pane:close': -> @getModel().destroy()
+      'pane:close-other-items': -> @getModel().destroyInactiveItems()
+    )
+
+  getModel: -> @model
+
+  setModel: (@model) ->
+    @subscriptions.add @model.onDidActivate(@activated.bind(this))
+    @subscriptions.add @model.observeActive(@activeStatusChanged.bind(this))
+    @subscriptions.add @model.observeActiveItem(@activeItemChanged.bind(this))
+    @subscriptions.add @model.onDidRemoveItem(@itemRemoved.bind(this))
+    @subscriptions.add @model.onDidDestroy(@paneDestroyed.bind(this))
+    @__spacePenView.setModel(@model)
+
+  activated: ->
+    @focus() unless @hasFocus()
+
+  activeStatusChanged: (active) ->
+    if active
+      @classList.add('active')
+    else
+      @classList.remove('active')
+
+  activeItemChanged: (item) ->
+    return unless item?
+
+    hasFocus = @hasFocus()
+    itemView = @model.getView(item)
+
+    for child in @itemViews.children
+      if child is itemView
+        @showItemView(child) if @attached
+      else
+        @hideItemView(child)
+
+    unless @itemViews.contains(itemView)
+      @itemViews.appendChild(itemView)
+      callAttachHooks(itemView)
+
+    itemView.focus() if hasFocus
+
+  showItemView: (itemView) ->
+    inlineDisplayStyle = @inlineDisplayStyles.get(itemView)
+    if inlineDisplayStyle?
+      itemView.style.display = inlineDisplayStyle
+    else
+      itemView.style.display = ''
+
+  hideItemView: (itemView) ->
+    inlineDisplayStyle = itemView.style.display
+    @inlineDisplayStyles.set(itemView, inlineDisplayStyle) if inlineDisplayStyle?
+    itemView.style.display = 'none'
+
+  itemRemoved: ({item, index, destroyed}) ->
+    if viewToRemove = @model.getView(item)
+      callRemoveHooks(viewToRemove)
+      viewToRemove.remove()
+
+  paneDestroyed: ->
+    @subscriptions.dispose()
+
+  getActiveView: -> @model.getView(@model.getActiveItem())
+
+  hasFocus: ->
+    this is document.activeElement or @contains(document.activeElement)
+
+module.exports = PaneElement = document.registerElement 'atom-pane', prototype: PaneElement.prototype

src/pane-row-view.coffee

@@ -1,11 +0,0 @@
-{$} = require './space-pen-extensions'
-_ = require 'underscore-plus'
-PaneAxisView = require './pane-axis-view'
-
-module.exports =
-class PaneRowView extends PaneAxisView
-  @content: ->
-    @div class: 'pane-row'
-
-  className: ->
-    "PaneRow"

src/pane-view.coffee

@@ -17,12 +17,6 @@ class PaneView extends View
   Delegator.includeInto(this)
   PropertyAccessors.includeInto(this)
 
-  @version: 1
-
-  @content: (wrappedView) ->
-    @div class: 'pane', tabindex: -1, =>
-      @div class: 'item-views', outlet: 'itemViews'
-
   @delegatesProperties 'items', 'activeItem', toProperty: 'model'
   @delegatesMethods 'getItems', 'activateNextItem', 'activatePreviousItem', 'getActiveItemIndex',
     'activateItemAtIndex', 'activateItem', 'addItem', 'itemAtIndex', 'moveItem', 'moveItemToPane',
@@ -32,49 +26,33 @@ class PaneView extends View
     'activate', 'getActiveItem', toProperty: 'model'
 
   previousActiveItem: null
+  attached: false
 
-  initialize: (@model) ->
+  constructor: (@element) ->
+    @itemViews = $(element.itemViews)
+    super
+
+  setModel: (@model) ->
     @subscriptions = new CompositeDisposable
-    @onItemAdded(item) for item in @items
-    @handleEvents()
-
-  handleEvents: ->
     @subscriptions.add @model.observeActiveItem(@onActiveItemChanged)
     @subscriptions.add @model.onDidAddItem(@onItemAdded)
     @subscriptions.add @model.onDidRemoveItem(@onItemRemoved)
     @subscriptions.add @model.onDidMoveItem(@onItemMoved)
     @subscriptions.add @model.onWillDestroyItem(@onBeforeItemDestroyed)
-    @subscriptions.add @model.onDidActivate(@onActivated)
     @subscriptions.add @model.observeActive(@onActiveStatusChanged)
+    @subscriptions.add @model.onDidDestroy(@onPaneDestroyed)
 
-    @subscribe this, 'focusin', => @model.focus()
-    @subscribe this, 'focusout', => @model.blur()
-    @subscribe this, 'focus', =>
-      @activeView?.focus()
-      false
+  afterAttach: ->
+    @container ?= @closest('atom-pane-container').view()
+    @trigger('pane:attached', [this]) unless @attached
+    @attached = true
 
-    @command 'pane:save-items', => @saveItems()
-    @command 'pane:show-next-item', => @activateNextItem()
-    @command 'pane:show-previous-item', => @activatePreviousItem()
+  onPaneDestroyed: =>
+    @container?.trigger 'pane:removed', [this]
+    @subscriptions.dispose()
 
-    @command 'pane:show-item-1', => @activateItemAtIndex(0)
-    @command 'pane:show-item-2', => @activateItemAtIndex(1)
-    @command 'pane:show-item-3', => @activateItemAtIndex(2)
-    @command 'pane:show-item-4', => @activateItemAtIndex(3)
-    @command 'pane:show-item-5', => @activateItemAtIndex(4)
-    @command 'pane:show-item-6', => @activateItemAtIndex(5)
-    @command 'pane:show-item-7', => @activateItemAtIndex(6)
-    @command 'pane:show-item-8', => @activateItemAtIndex(7)
-    @command 'pane:show-item-9', => @activateItemAtIndex(8)
-
-    @command 'pane:split-left', => @model.splitLeft(copyActiveItem: true)
-    @command 'pane:split-right', => @model.splitRight(copyActiveItem: true)
-    @command 'pane:split-up', => @model.splitUp(copyActiveItem: true)
-    @command 'pane:split-down', => @model.splitDown(copyActiveItem: true)
-    @command 'pane:close', =>
-      @model.destroyItems()
-      @model.destroy()
-    @command 'pane:close-other-items', => @destroyInactiveItems()
+  remove: ->
+    @model.destroy() unless @model.isDestroyed()
 
   # Essential: Returns the {Pane} model underlying this pane view
   getModel: -> @model
@@ -109,23 +87,10 @@ class PaneView extends View
     deprecate("Use PaneView::activatePreviousItem instead")
     @activatePreviousItem()
 
-  afterAttach: (onDom) ->
-    @focus() if @model.focused and onDom
-
-    return if @attached
-    @container = @closest('.panes').view()
-    @attached = true
-    @trigger 'pane:attached', [this]
-
-  onActivated: =>
-    @focus() unless @hasFocus()
-
   onActiveStatusChanged: (active) =>
     if active
-      @addClass('active')
       @trigger 'pane:became-active'
     else
-      @removeClass('active')
       @trigger 'pane:became-inactive'
 
   # Public: Returns the next pane, ordered by creation.
@@ -179,23 +144,12 @@ class PaneView extends View
     @trigger 'pane:item-added', [item, index]
 
   onItemRemoved: ({item, index, destroyed}) =>
-    if item instanceof $
-      viewToRemove = item
-    else
-      viewToRemove = @model.getView(item).__spacePenView
-
-    if viewToRemove?
-      if destroyed
-        viewToRemove.remove()
-      else
-        viewToRemove.detach()
-
     @trigger 'pane:item-removed', [item, index]
 
   onItemMoved: ({item, newIndex}) =>
     @trigger 'pane:item-moved', [item, newIndex]
 
-  onBeforeItemDestroyed: (item) =>
+  onBeforeItemDestroyed: ({item}) =>
     @unsubscribe(item) if typeof item.off is 'function'
     @trigger 'pane:before-item-destroyed', [item]
 
@@ -215,17 +169,7 @@ class PaneView extends View
 
   splitDown: (items...) -> @model.getView(@model.splitDown({items})).__spacePenView
 
-  # Public: Get the container view housing this pane.
-  #
-  # Returns a {View}.
-  getContainer: ->
-    @closest('.panes').view()
+  getContainer: -> @closest('atom-pane-container').view()
 
-  beforeRemove: ->
-    @subscriptions.dispose()
-    @model.destroy() unless @model.isDestroyed()
-
-  remove: (selector, keepData) ->
-    return super if keepData
-    @unsubscribe()
-    super
+  focus: ->
+    @element.focus()

src/pane.coffee

@@ -53,9 +53,6 @@ class Pane extends Model
     params.activeItem = find params.items, (item) -> item.getUri?() is activeItemUri
     params
 
-  # Called by the view layer to construct a view for this model.
-  getViewClass: -> PaneView ?= require './pane-view'
-
   getView: (object) ->
     @container.getView(object)
 
@@ -238,6 +235,8 @@ class Pane extends Model
     @focused = false
     true # if this is called from an event handler, don't cancel it
 
+  isFocused: -> @focused
+
   getPanes: -> [this]
 
   ###
@@ -414,9 +413,8 @@ class Pane extends Model
     @destroyItem(item) for item in @getItems() when item isnt @activeItem
 
   promptToSaveItem: (item) ->
-    return true unless item.shouldPromptToSave?()
+    return true unless typeof item.getUri is 'function' and item.shouldPromptToSave?()
 
-    uri = item.getUri()
     chosen = atom.confirm
       message: "'#{item.getTitle?() ? item.getUri()}' has changes, do you want to save them?"
       detailedMessage: "Your changes will be lost if you close this item without saving."

src/project.coffee

@@ -6,10 +6,12 @@ fs = require 'fs-plus'
 Q = require 'q'
 {deprecate} = require 'grim'
 {Model} = require 'theorist'
-{Emitter, Subscriber} = require 'emissary'
+{Subscriber} = require 'emissary'
+{Emitter} = require 'event-kit'
 Serializable = require 'serializable'
 TextBuffer = require 'text-buffer'
 {Directory} = require 'pathwatcher'
+Grim = require 'grim'
 
 TextEditor = require './text-editor'
 Task = require './task'
@@ -33,14 +35,17 @@ class Project extends Model
   Section: Construction and Destruction
   ###
 
-  constructor: ({path, @buffers}={}) ->
+  constructor: ({path, paths, @buffers}={}) ->
+    @emitter = new Emitter
     @buffers ?= []
 
     for buffer in @buffers
       do (buffer) =>
         buffer.onDidDestroy => @removeBuffer(buffer)
 
-    @setPath(path)
+    Grim.deprecate("Pass 'paths' array instead of 'path' to project constructor") if path?
+    paths ?= _.compact([path])
+    @setPaths(paths)
 
   destroyed: ->
     buffer.destroy() for buffer in @getBuffers()
@@ -66,25 +71,47 @@ class Project extends Model
     params.buffers = params.buffers.map (bufferState) -> atom.deserializers.deserialize(bufferState)
     params
 
+
+  ###
+  Section: Event Subscription
+  ###
+
+  onDidChangePaths: (callback) ->
+    @emitter.on 'did-change-paths', callback
+
+  on: (eventName) ->
+    if eventName is 'path-changed'
+      Grim.deprecate("Use Project::onDidChangePaths instead")
+    super
+
   ###
   Section: Accessing the git repository
   ###
 
-  # Public: Returns the {GitRepository} if available.
-  getRepo: -> @repo
+  # Public: Get an {Array} of {GitRepository}s associated with the project's
+  # directories.
+  getRepositories: -> _.compact([@repo])
+  getRepo: ->
+    Grim.deprecate("Use ::getRepositories instead")
+    @repo
 
   ###
   Section: Managing Paths
   ###
 
-  # Public: Returns the project's {String} fullpath.
+
+  # Public: Get an {Array} of {String}s containing the paths of the project's
+  # directories.
+  getPaths: -> _.compact([@rootDirectory?.path])
   getPath: ->
+    Grim.deprecate("Use ::getPaths instead")
     @rootDirectory?.path
 
-  # Public: Sets the project's fullpath.
+  # Public: Set the paths of the project's directories.
   #
-  # * `projectPath` {String} path
-  setPath: (projectPath) ->
+  # * `projectPaths` {Array} of {String} paths.
+  setPaths: (projectPaths) ->
+    [projectPath] = projectPaths
     projectPath = path.normalize(projectPath) if projectPath
     @path = projectPath
     @rootDirectory?.off()
@@ -100,9 +127,16 @@ class Project extends Model
       @rootDirectory = null
 
     @emit "path-changed"
+    @emitter.emit 'did-change-paths', projectPaths
+  setPath: (path) ->
+    Grim.deprecate("Use ::setPaths instead")
+    @setPaths([path])
 
-  # Public: Returns the root {Directory} object for this project.
+  # Public: Get an {Array} of {Directory}s associated with this project.
+  getDirectories: ->
+    [@rootDirectory]
   getRootDirectory: ->
+    Grim.deprecate("Use ::getDirectories instead")
     @rootDirectory
 
   # Public: Given a uri, this resolves it relative to the project directory. If
@@ -120,7 +154,7 @@ class Project extends Model
     else
       if fs.isAbsolute(uri)
         path.normalize(fs.absolute(uri))
-      else if projectPath = @getPath()
+      else if projectPath = @getPaths()[0]
         path.normalize(fs.absolute(path.join(projectPath, uri)))
       else
         undefined
@@ -345,12 +379,12 @@ class Project extends Model
 
   # Deprecated: delegate
   registerOpener: (opener) ->
-    deprecate("Use Workspace::registerOpener instead")
+    deprecate("Use Workspace::addOpener instead")
     atom.workspace.registerOpener(opener)
 
   # Deprecated: delegate
   unregisterOpener: (opener) ->
-    deprecate("Use Workspace::unregisterOpener instead")
+    deprecate("Call .dispose() on the Disposable returned from ::addOpener instead")
     atom.workspace.unregisterOpener(opener)
 
   # Deprecated: delegate