Always return real package paths

⬆️ bump tree view for new sort option

CONTRIBUTING.md

@@ -74,7 +74,7 @@ For more information on how to work with Atom's official packages, see
 * Limit the first line to 72 characters or less
 * Reference issues and pull requests liberally
 * Consider starting the commit message with an applicable emoji:
-    * :lipstick: `:lipstick:` when improving the format/structure of the code
+    * :art: `:art:` when improving the format/structure of the code
     * :racehorse: `:racehorse:` when improving performance
     * :non-potable_water: `:non-potable_water:` when plugging memory leaks
     * :memo: `:memo:` when writing docs
@@ -87,6 +87,8 @@ For more information on how to work with Atom's official packages, see
     * :white_check_mark: `:white_check_mark:` when adding tests
     * :lock: `:lock:` when dealing with security
     * :arrow_up: `:arrow_up:` when upgrading dependencies
+    * :arrow_down: `:arrow_down:` when downgrading dependencies
+    * :shirt: `:shirt:` when removing linter warnings
 
 ## CoffeeScript Styleguide
 
@@ -98,6 +100,10 @@ For more information on how to work with Atom's official packages, see
 * Avoid spaces inside the curly-braces of hash literals:
     * `{a: 1, b: 2}` instead of `{ a: 1, b: 2 }`
 * Include a single line of whitespace between methods.
+* Capitalize initialisms and acronyms in names, except for the first word, which
+  should be lower-case:
+  * `getURI` instead of `getUri`
+  * `uriToOpen` instead of `URIToOpen`
 
 ## Documentation Styleguide
 

apm/package.json

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

build/Gruntfile.coffee

@@ -198,6 +198,7 @@ module.exports = (grunt) ->
       outputDir: 'atom-shell'
       downloadDir: atomShellDownloadDir
       rebuild: true  # rebuild native modules after atom-shell is updated
+      token: process.env.ATOM_ACCESS_TOKEN
 
     'create-windows-installer':
       appDirectory: shellAppDir
@@ -205,6 +206,7 @@ module.exports = (grunt) ->
       authors: 'GitHub Inc.'
       loadingGif: path.resolve(__dirname, '..', 'resources', 'win', 'loading.gif')
       iconUrl: 'https://raw.githubusercontent.com/atom/atom/master/resources/win/atom.ico'
+      setupIcon: path.resolve(__dirname, '..', 'resources', 'win', 'atom.ico')
 
     shell:
       'kill-atom':

build/package.json

@@ -12,19 +12,19 @@
     "fs-plus": "2.x",
     "github-releases": "~0.2.0",
     "grunt": "~0.4.1",
-    "grunt-atom-shell-installer": "^0.13.0",
+    "grunt-atom-shell-installer": "^0.20.0",
     "grunt-cli": "~0.1.9",
     "grunt-coffeelint": "git+https://github.com/atom/grunt-coffeelint.git#cfb99aa99811d52687969532bd5a98011ed95bfe",
-    "grunt-contrib-coffee": "~0.9.0",
+    "grunt-contrib-coffee": "~0.12.0",
     "grunt-contrib-csslint": "~0.1.2",
     "grunt-contrib-less": "~0.8.0",
-    "grunt-cson": "0.10.0",
-    "grunt-download-atom-shell": "~0.10.0",
+    "grunt-cson": "0.14.0",
+    "grunt-download-atom-shell": "~0.11.0",
     "grunt-lesslint": "0.13.0",
     "grunt-peg": "~1.1.0",
     "grunt-shell": "~0.3.1",
     "harmony-collections": "~0.3.8",
-    "legal-eagle": "~0.6.0",
+    "legal-eagle": "~0.9.0",
     "minidump": "~0.8",
     "npm": "~1.4.5",
     "rcedit": "~0.3.0",

build/tasks/build-task.coffee

@@ -71,6 +71,7 @@ module.exports = (grunt) ->
       path.join('build', 'Release', 'obj')
       path.join('build', 'Release', '.deps')
       path.join('vendor', 'apm')
+      path.join('resources', 'linux')
       path.join('resources', 'mac')
       path.join('resources', 'win')
 
@@ -143,7 +144,10 @@ module.exports = (grunt) ->
     cp 'spec', path.join(appDir, 'spec')
     cp 'src', path.join(appDir, 'src'), filter: /.+\.(cson|coffee)$/
     cp 'static', path.join(appDir, 'static')
-    cp 'apm', path.join(appDir, 'apm'), filter: filterNodeModule
+
+    cp path.join('apm', 'node_modules', 'atom-package-manager'), path.join(appDir, 'apm'), filter: filterNodeModule
+    if process.platform isnt 'win32'
+      fs.symlinkSync(path.join('..', '..', 'bin', 'apm'), path.join(appDir, 'apm', 'node_modules', '.bin', 'apm'))
 
     if process.platform is 'darwin'
       grunt.file.recurse path.join('resources', 'mac'), (sourcePath, rootDirectory, subDirectory='', filename) ->

build/tasks/install-task.coffee

@@ -1,4 +1,3 @@
-fs = require 'fs'
 path = require 'path'
 _ = require 'underscore-plus'
 fs = require 'fs-plus'

build/tasks/license-overrides.coffee

@@ -35,6 +35,10 @@ module.exports =
 
       MIT/X11
     """
+  'cheerio@0.15.0':
+    repository: "https://github.com/cheeriojs/cheerio"
+    license: 'MIT'
+    source: 'https://github.com/cheeriojs/cheerio/blob/master/package.json'
   'specificity@0.1.3':
     repository: 'https://github.com/keeganstreet/specificity'
     license: 'MIT'

build/tasks/prebuild-less-task.coffee

@@ -1,4 +1,5 @@
 path = require 'path'
+fs = require 'fs'
 
 LessCache = require 'less-cache'
 
@@ -7,14 +8,35 @@ module.exports = (grunt) ->
     prebuiltConfigurations = [
       ['atom-dark-ui', 'atom-dark-syntax']
       ['atom-dark-ui', 'atom-light-syntax']
+      ['atom-dark-ui', 'one-dark-syntax']
+      ['atom-dark-ui', 'one-light-syntax']
       ['atom-dark-ui', 'solarized-dark-syntax']
       ['atom-dark-ui', 'base16-tomorrow-dark-theme']
       ['atom-dark-ui', 'base16-tomorrow-light-theme']
+
       ['atom-light-ui', 'atom-light-syntax']
       ['atom-light-ui', 'atom-dark-syntax']
+      ['atom-light-ui', 'one-dark-syntax']
+      ['atom-light-ui', 'one-light-syntax']
       ['atom-light-ui', 'solarized-dark-syntax']
       ['atom-light-ui', 'base16-tomorrow-dark-theme']
       ['atom-light-ui', 'base16-tomorrow-light-theme']
+
+      ['one-dark-ui', 'one-dark-syntax']
+      ['one-dark-ui', 'one-light-syntax']
+      ['one-dark-ui', 'atom-dark-syntax']
+      ['one-dark-ui', 'atom-light-syntax']
+      ['one-dark-ui', 'solarized-dark-syntax']
+      ['one-dark-ui', 'base16-tomorrow-dark-theme']
+      ['one-dark-ui', 'base16-tomorrow-light-theme']
+
+      ['one-light-ui', 'one-light-syntax']
+      ['one-light-ui', 'one-dark-syntax']
+      ['one-light-ui', 'atom-light-syntax']
+      ['one-light-ui', 'atom-dark-syntax']
+      ['one-light-ui', 'solarized-dark-syntax']
+      ['one-light-ui', 'base16-tomorrow-dark-theme']
+      ['one-light-ui', 'base16-tomorrow-light-theme']
     ]
 
     directory = path.join(grunt.config.get('atom.appDir'), 'less-compile-cache')
@@ -25,7 +47,10 @@ module.exports = (grunt) ->
       for theme in configuration
         # TODO Use AtomPackage class once it runs outside of an Atom context
         themePath = path.resolve('node_modules', theme)
-        stylesheetsDir = path.join(themePath, 'stylesheets')
+        if fs.existsSync(path.join(themePath, 'stylesheets'))
+          stylesheetsDir = path.join(themePath, 'stylesheets')
+        else
+          stylesheetsDir = path.join(themePath, 'styles')
         {main} = grunt.file.readJSON(path.join(themePath, 'package.json'))
         main ?= 'index.less'
         mainPath = path.join(themePath, main)
@@ -38,10 +63,18 @@ module.exports = (grunt) ->
         resourcePath: path.resolve('.')
         importPaths: importPaths
 
+      cssForFile = (file) ->
+        baseVarImports = """
+        @import "variables/ui-variables";
+        @import "variables/syntax-variables";
+        """
+        less = fs.readFileSync(file, 'utf8')
+        lessCache.cssForFile(file, [baseVarImports, less].join('\n'))
+
       for file in @filesSrc
         grunt.verbose.writeln("File #{file.cyan} created in cache.")
-        lessCache.readFileSync(file)
+        cssForFile(file)
 
       for file in themeMains
         grunt.verbose.writeln("File #{file.cyan} created in cache.")
-        lessCache.readFileSync(file)
+        cssForFile(file)

build/tasks/publish-build-task.coffee

@@ -101,7 +101,7 @@ getAssets = ->
 logError = (message, error, details) ->
   grunt.log.error(message)
   grunt.log.error(error.message ? error) if error?
-  grunt.log.error(details) if details
+  grunt.log.error(require('util').inspect(details)) if details
 
 zipAssets = (buildDir, assets, callback) ->
   zip = (directory, sourcePath, assetName, callback) ->
@@ -142,7 +142,30 @@ getAtomDraftRelease = (callback) ->
             firstDraft.assets = assets
             callback(null, firstDraft)
       else
-        callback(new Error('No draft release in atom/atom repo'))
+        createAtomDraftRelease(callback)
+
+createAtomDraftRelease = (callback) ->
+  {version} = require('../../package.json')
+  options =
+    uri: 'https://api.github.com/repos/atom/atom/releases'
+    method: 'POST'
+    headers: defaultHeaders
+    json:
+      tag_name: "v#{version}"
+      name: version
+      draft: true
+      body: """
+        ### Notable Changes
+
+        * Something new
+      """
+
+  request options, (error, response, body='') ->
+    if error? or response.statusCode isnt 201
+      logError("Creating atom/atom draft release failed", error, body)
+      callback(error ? new Error(response.statusCode))
+    else
+      callback(null, body)
 
 deleteRelease = (release) ->
   options =

build/tasks/spec-task.coffee

@@ -12,11 +12,18 @@ module.exports = (grunt) ->
   packageSpecQueue = null
 
   logDeprecations = (label, {stderr}={}) ->
-    if process.env.JANKY_SHA1 and stderr?.indexOf('Calls to deprecated functions') isnt -1
-      grunt.log.error(label)
-      stderr = stderr.replace(/^\[.*\] "/g, '')
-      stderr = stderr.replace(/source: .*$/g, '')
-      grunt.log.error(stderr)
+    return unless process.env.JANKY_SHA1
+    stderr ?= ''
+    deprecatedStart = stderr.indexOf('Calls to deprecated functions')
+    return if deprecatedStart is -1
+
+    grunt.log.error(label)
+    stderr = stderr.substring(deprecatedStart)
+    stderr = stderr.replace(/^\s*\[[^\]]+\]\s+/gm, '')
+    stderr = stderr.replace(/source: .*$/gm, '')
+    stderr = stderr.replace(/^"/gm, '')
+    stderr = stderr.replace(/",\s*$/gm, '')
+    grunt.log.error(stderr)
 
   getAppPath = ->
     contentsDir = grunt.config.get('atom.contentsDir')

build/tasks/update-octicons-task.coffee

@@ -1,22 +0,0 @@
-path = require 'path'
-
-module.exports = (grunt) ->
-  grunt.registerTask 'update-octicons', 'Update octicon font and LESS variables', ->
-    pathToOcticons = path.resolve('..', 'octicons')
-    if grunt.file.isDir(pathToOcticons)
-      # Copy font-file
-      fontSrc = path.join(pathToOcticons, 'octicons', 'octicons.woff')
-      fontDest = path.resolve('static', 'octicons.woff')
-      grunt.file.copy(fontSrc, fontDest)
-
-      # Update Octicon UTF codes
-      glyphsSrc = path.join(pathToOcticons, 'data', 'glyphs.yml')
-      output = []
-      for {css, code} in grunt.file.readYAML(glyphsSrc)
-        output.push "@#{css}: \"\\#{code}\";"
-
-      octiconUtfDest = path.resolve('static', 'variables', 'octicon-utf-codes.less')
-      grunt.file.write(octiconUtfDest, "#{output.join('\n')}\n")
-    else
-      grunt.log.error("octicons repo must be cloned to #{pathToOcticons}")
-      false

docs/advanced/keymaps.md

@@ -3,7 +3,7 @@
 ## Structure of a Keymap File
 
 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
+work much like style sheets, 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 `atom-text-editor` elements:

docs/apm-rest-api.md

@@ -30,8 +30,8 @@ All requests that take parameters require `application/json`.
 Parameters:
 
 - **page** (optional)
-- **sort** (optional, values: `created_at`, `updated_at`, `downloads`)
-- **direction** (optional, values: `asc`, `desc`)
+- **sort** (optional) - One of `downloads`, `created_at`, `updated_at`, `stars`. Defaults to `downloads`
+- **direction** (optional) - `asc` or `desc`. Defaults to `desc`. `stars` can only be ordered `desc`
 
 Returns a list of all packages in the following format:
 ```json
@@ -61,17 +61,18 @@ Link: <https://www.atom.io/api/packages?page=1>; rel="self",
 
 By default, results are sorted by download count, descending.
 
+### Searching packages
+
 #### GET /api/packages/search
 
 Parameters:
 
-- **q** String query to search
-- **sort** (optional, values: `created_at`, `updated_at`, `downloads`)
-- **direction** (optional, values: `asc`, `desc`)
+- **q** (required) - Search query
+- **page** (optional)
+- **sort** (optional) - One of `downloads`, `created_at`, `updated_at`, `stars`. Defaults to the relevance of the search query.
+- **direction** (optional) - `asc` or `desc`. Defaults to `desc`.
 
-Returns a list of all packages in the same format as `/api/packages`.
-
-By default, results sorted by relevance to search query.
+Returns results in the same format as [listing packages](#listing-packages).
 
 ### Showing package details
 

docs/build-instructions/linux.md

@@ -26,13 +26,17 @@ Ubuntu LTS 12.04 64-bit is the recommended platform.
 
 ### Arch
 
-* `sudo pacman -S base-devel git nodejs libgnome-keyring python2`
+* `sudo pacman -S gconf base-devel git nodejs libgnome-keyring python2`
 * `export PYTHON=/usr/bin/python2` before building Atom.
 
 ### Slackware
 
 * `sbopkg -k -i node -i atom`
 
+### openSUSE
+
+* `sudo zypper install nodejs make gcc gcc-c++ glibc-devel git-core libgnome-keyring-devel rpmdevtools`
+
 ## Instructions
 
 If you have problems with permissions don't forget to prefix with `sudo`

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

@@ -45,7 +45,7 @@ the editor to see it in action!
 
 [atomio]: https://atom.io
 [CSS]: http://en.wikipedia.org/wiki/Cascading_Style_Sheets
-[LESS]: http://lesscss.org
+[Less]: http://lesscss.org
 [plist]: http://en.wikipedia.org/wiki/Property_list
 [R]: http://en.wikipedia.org/wiki/R_(programming_language)
 [TextMate]: http://macromates.com

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

@@ -6,7 +6,7 @@ theme.
 ### Differences
 
 TextMate themes use [plist][plist] files while Atom themes use [CSS][CSS] or
-[LESS][LESS] to style the UI and syntax in the editor.
+[Less][Less] to style the UI and syntax in the editor.
 
 The utility that converts the theme first parses the theme's plist file and
 then creates comparable CSS rules and properties that will style Atom similarly.
@@ -62,7 +62,7 @@ __Syntax Theme__ dropdown menu to enable your new theme.
 
 [atomio]: https://atom.io
 [CSS]: http://en.wikipedia.org/wiki/Cascading_Style_Sheets
-[LESS]: http://lesscss.org
+[Less]: http://lesscss.org
 [plist]: http://en.wikipedia.org/wiki/Property_list
 [TextMate]: http://macromates.com
 [TextMateThemes]: http://wiki.macromates.com/Themes/UserSubmittedThemes

docs/creating-a-package.md

@@ -15,7 +15,7 @@ my-package/
   menus/
   spec/
   snippets/
-  stylesheets/
+  styles/
   index.coffee
   package.json
 ```
@@ -38,10 +38,10 @@ In addition to the regular [npm package.json keys][npm-keys] available, Atom
 package.json files have their own additions.
 
 - `main` (**Required**): the path to the CoffeeScript file that's the entry point
-to your package
-- `stylesheets` (**Optional**): an Array of Strings identifying the order of the
+to your package.
+- `styles` (**Optional**): an Array of Strings identifying the order of the
 style sheets your package needs to load. If not specified, style sheets in the
-_stylesheets_ directory are added alphabetically.
+_styles_ directory are added alphabetically.
 - `keymaps`(**Optional**): an Array of Strings identifying the order of the
 key mappings your package needs to load. If not specified, mappings in the
 _keymaps_ directory are added alphabetically.
@@ -121,10 +121,10 @@ like you.
 
 ## Style Sheets
 
-Style sheets for your package should be placed in the _stylesheets_ directory.
+Style sheets for your package should be placed in the _styles_ directory.
 Any style sheets in this directory will be loaded and attached to the DOM when
-your package is activated. Style sheets can be written as CSS or [LESS] (but
-LESS is recommended).
+your package is activated. Style sheets can be written as CSS or [Less], but
+Less is recommended.
 
 Ideally, you won't need much in the way of styling. We've provided a standard
 set of components which define both the colors and UI elements for any package
@@ -138,7 +138,7 @@ taken from the active theme's [ui-variables.less][ui-variables]. For more
 information, see the [theme variables docs][theme-variables]. If you follow this
 guideline, your package will look good out of the box with any theme!
 
-An optional `stylesheets` array in your _package.json_ can list the style sheets
+An optional `styleSheets` array in your _package.json_ can list the style sheets
 by name to specify a loading order; otherwise, style sheets are loaded
 alphabetically.
 
@@ -418,8 +418,8 @@ all the other available commands.
 [underscore]: http://underscorejs.org/
 [jasmine]: http://jasmine.github.io
 [cson]: https://github.com/atom/season
-[less]: http://lesscss.org
-[ui-variables]: https://github.com/atom/atom-dark-ui/blob/master/stylesheets/ui-variables.less
+[Less]: http://lesscss.org
+[ui-variables]: https://github.com/atom/atom-dark-ui/blob/master/styles/ui-variables.less
 [first-package]: your-first-package.html
 [convert-bundle]: converting-a-text-mate-bundle.html
 [convert-theme]: converting-a-text-mate-theme.html

docs/creating-a-theme.md

@@ -1,8 +1,8 @@
 # Creating a Theme
 
-Atom's interface is rendered using HTML, and it's styled via [LESS] (a superset
-of CSS). Don't worry if you haven't heard of LESS before; it's just like CSS,
-but with a few handy extensions.
+Atom's interface is rendered using HTML, and it's styled via [Less] which is a
+superset of CSS. Don't worry if you haven't heard of Less before; it's just like
+CSS, but with a few handy extensions.
 
 Atom supports two types of themes: _UI_ and _syntax_.  UI themes style
 elements such as the tree view, the tabs, drop-down lists, and the status bar.
@@ -17,7 +17,7 @@ section on the left hand side.
 Themes are pretty straightforward but it's still helpful to be familiar with
 a few things before starting:
 
-* LESS is a superset of CSS, but it has some really handy features like
+* Less is a superset of CSS, but it has some really handy features like
   variables. If you aren't familiar with its syntax, take a few minutes
   to [familiarize yourself][less-tutorial].
 * You may also want to review the concept of a _[package.json]_, too. This file
@@ -42,10 +42,10 @@ _Motif_ theme listed in the _Syntax Theme_ drop-down. Select it from the menu to
 activate it, now when you open an editor you should see that your new
 _motif-syntax_ theme in action.
 
-Open up _stylesheets/colors.less_ to change the various colors variables which
+Open up _styles/colors.less_ to change the various colors variables which
 have been already been defined. For example, turn `@red` into `#f4c2c1`.
 
-Then open _stylesheets/base.less_ and modify the various selectors that have
+Then open _styles/base.less_ and modify the various selectors that have
 been already been defined. These selectors style different parts of code in the
 editor such as comments, strings and the line numbers in the gutter.
 
@@ -131,7 +131,7 @@ _styleguide_, or use the shortcut `cmd-ctrl-shift-g`.
 ![styleguide-img]
 
 [atomio]: http://atom.io/packages
-[less]: http://lesscss.org/
+[Less]: http://lesscss.org/
 [git]: http://git-scm.com/
 [atom]: https://atom.io/
 [package.json]: ./creating-a-package.html#package-json

docs/customizing-atom.md

@@ -54,7 +54,7 @@ You can also use `apm` to find new packages to install:
 
 ## Customizing Key Bindings
 
-Atom keymaps work similarly to stylesheets. Just as stylesheets use selectors
+Atom keymaps work similarly to style sheets. Just as style sheets use selectors
 to apply styles to elements, Atom keymaps use selectors to associate keystrokes
 with events in specific contexts. Here's a small example, excerpted from Atom's
 built-in keymaps:
@@ -174,12 +174,12 @@ atom-text-editor.is-focused .cursor {
 }
 ```
 
-Unfamiliar with LESS? Read more about it [here][LESS].
+Unfamiliar with Less? Read more about it [here][Less].
 
 This file can also be named _styles.css_ and contain CSS.
 
 [creating-a-package]: creating-a-package.md
 [create-theme]: creating-a-theme.md
-[LESS]: http://www.lesscss.org
+[Less]: http://www.lesscss.org
 [CSON]: https://github.com/atom/season
 [CoffeeScript]: http://coffeescript.org/

docs/debugging.md

@@ -3,7 +3,8 @@
 Atom provides several tools to help you understand unexpected behavior and debug problems. This guide describes some of those tools and a few approaches to help you debug and provide more helpful information when [submitting issues]:
 
 * [Update to the latest version](#update-to-the-latest-version)
-* [Check Atom and package settings](#check-atom-and-package-settings) 
+* [Check for linked packages](#check-for-linked-packages)
+* [Check Atom and package settings](#check-atom-and-package-settings)
 * [Check the keybindings](#check-the-keybindings)
 * [Check if the problem shows up in safe mode](#check-if-the-problem-shows-up-in-safe-mode)
 * [Check your config files](#check-your-config-files)
@@ -24,6 +25,16 @@ $ atom --version
 
 Head on over to the [list of releases][atom releases] and see if there's a more recent release. You can update to the most recent release by downloading Atom from the releases page, or with the in-app auto-updater. The in-app auto-updater checks for and downloads a new version after you restart Atom, or if you use the Atom > Check for Update menu option.
 
+## Check for linked packages
+
+If you develop or contribute to Atom packages, there may be left-over packages linked to your `~/.atom/packages` or `~/.atom/dev/packages` directories. You can use:
+
+```shell
+$ apm links
+```
+
+to list all linked development packages. You can remove the links using the `apm unlink` command. See `apm unlink --help` for details.
+
 ## Check Atom and package settings
 
 In some cases, unexpected behavior might be caused by misconfigured or unconfigured settings in Atom or in one of the packages.
@@ -89,6 +100,21 @@ When an error is thrown in Atom, the developer tools are automatically shown wit
 
 If you can reproduce the error, use this approach to get the full stack trace. The stack trace might point to a problem in your [Init script][init script or stylesheet] or a specific package you installed, which you can then disable and report an issue on its GitHub repository.
 
+## Check that you have a build toolchain installed
+
+If you are having issues installing a package using `apm install`, this could be
+because the package has dependencies on libraries that contain native code
+and so you will need to have a C++ compiler and Python installed to be able to
+install it.
+
+You can run `apm install --check` to see if [apm][apm] can build native code on
+your machine.
+
+Check out the pre-requisites in the [build instructions][build-instructions] for
+your platform for more details.
+
+[apm]: https://github.com/atom/apm
+[build-instructions]: https://github.com/atom/atom/tree/master/docs/build-instructions
 [submitting issues]: https://github.com/atom/atom/blob/master/CONTRIBUTING.md#submitting-issues
 [building atom]: https://github.com/atom/atom#building
 [atom releases]: https://github.com/atom/atom/releases

docs/getting-started.md

@@ -34,7 +34,7 @@ files. If you are using Git you can use `cmd-shift-b` to search the list of
 files modified and untracked in your project's repository.
 
 You can also use the tree view to navigate to a file. To open and focus the
-the tree view, press `ctrl-0`. The tree view can be toggled open and closed with
+tree view, press `ctrl-0`. The tree view can be toggled open and closed with
 `cmd-\`.
 
 #### Adding, Moving, Deleting Files

docs/upgrading/upgrading-your-package.md

@@ -0,0 +1,625 @@
+# Upgrading your package to 1.0 APIs
+
+Atom is rapidly approaching 1.0. Much of the effort leading up to the 1.0 has been cleaning up APIs in an attempt to future proof, and make a more pleasant experience developing packages.
+
+This document will guide you through the large bits of upgrading your package to work with 1.0 APIs.
+
+## TL;DR
+
+We've set deprecation messages and errors in strategic places to help make sure you don't miss anything. You should be able to get 95% of the way to an updated package just by fixing errors and deprecations. There are a couple of things you can do to get the full effect of all the errors and deprecations.
+
+### Use atom-space-pen-views
+
+If you use any class from `require 'atom'` with a `$` or `View` in the name, add the `atom-space-pen-views` module to your package's `package.json` file's dependencies:
+
+```js
+{
+  "dependencies": {
+    "atom-space-pen-views": "^2.0.3"
+  }
+}
+```
+
+Then run `apm install` in your package directory.
+
+### Require views from atom-space-pen-views
+
+Anywhere you are requiring one of the following from `atom` you need to require them from `atom-space-pen-views` instead.
+
+```coffee
+# require these from 'atom-space-pen-views' rather than 'atom'
+$
+$$
+$$$
+View
+TextEditorView
+ScrollView
+SelectListView
+```
+
+So this:
+
+```coffee
+# Old way
+{$, TextEditorView, View, GitRepository} = require 'atom'
+```
+
+Would be replaced by this:
+
+```coffee
+# New way
+{GitRepository} = require 'atom'
+{$, TextEditorView, View} = require 'atom-space-pen-views'
+```
+
+### Run specs and test your package
+
+You wrote specs, right!? Here's where they shine. Run them with `cmd-shift-P`, and search for `run package specs`. It will show all the deprecation messages and errors.
+
+### Update the engines field in package.json
+
+When you are deprecation free and all done converting, upgrade the `engines` field in your package.json:
+
+```json
+{
+  "engines": {
+    "atom": ">=0.174.0, <2.0.0"
+  }
+}
+```
+
+### Examples
+
+We have upgraded all the core packages. Please see [this issue](https://github.com/atom/atom/issues/4011) for a link to all the upgrade PRs.
+
+## Deprecations
+
+All of the methods in Atom core that have changes will emit deprecation messages when called. These messages are shown in two places: your **package specs**, and in **Deprecation Cop**.
+
+### Specs
+
+Just run your specs, and all the deprecations will be displayed in yellow.
+
+![spec-deps](https://cloud.githubusercontent.com/assets/69169/5637943/b85114ba-95b5-11e4-8681-b81ea8f556d7.png)
+
+### Deprecation Cop
+
+Run an atom window in dev mode (`atom -d`) with your package loaded, and open Deprecation Cop (search for `deprecation` in the command palette). Deprecated methods will be appear in Deprecation Cop only after they have been called.
+
+![dep-cop](https://cloud.githubusercontent.com/assets/69169/5637914/6e702fa2-95b5-11e4-92cc-a236ddacee21.png)
+
+When deprecation cop is open, and deprecated methods are called, a `Refresh` button will appear in the top right of the Deprecation Cop interface. So exercise your package, then come back to Deprecation Cop and click the `Refresh` button.
+
+## Upgrading your Views
+
+Previous to 1.0, views were baked into Atom core. These views were based on jQuery and `space-pen`. They looked something like this:
+
+```coffee
+# The old way: getting views from atom
+{$, TextEditorView, View} = require 'atom'
+
+module.exports =
+class SomeView extends View
+  @content: ->
+    @div class: 'find-and-replace', =>
+      @div class: 'block', =>
+        @subview 'myEditor', new TextEditorView(mini: true)
+  #...
+```
+
+### The New
+
+`require 'atom'` no longer provides view helpers or jQuery. Atom core is now 'view agnostic'. The preexisting view system is available from a new npm package: `atom-space-pen-views`.
+
+`atom-space-pen-views` now provides jQuery, `space-pen` views, and Atom specific views:
+
+
+```coffee
+# These are now provided by atom-space-pen-views
+$
+$$
+$$$
+View
+TextEditorView
+ScrollView
+SelectListView
+```
+
+### Adding the module dependencies
+
+To use the new views, you need to specify the `atom-space-pen-views` module in your package's `package.json` file's dependencies:
+
+```js
+{
+  "dependencies": {
+    "atom-space-pen-views": "^2.0.3"
+  }
+}
+```
+
+`space-pen` bundles jQuery. If you do not need `space-pen` or any of the views, you can require jQuery directly.
+
+```js
+{
+  "dependencies": {
+    "jquery": "^2"
+  }
+}
+```
+
+### Converting your views
+
+Sometimes it is as simple as converting the requires at the top of each view page. I assume you read the 'TL;DR' section and have updated all of your requires.
+
+### Upgrading classes extending any space-pen View
+
+#### `afterAttach` and `beforeRemove` updated
+
+The `afterAttach` and `beforeRemove` hooks have been replaced with
+`attached` and `detached` and the semantics have changed.
+
+`afterAttach` was called whenever the node was attached to another DOM node, even if that parent node wasn't present in the DOM. `afterAttach` also was called with a boolean indicating whether or not the element and its parents were on the DOM. Now the `attached` hook is _only_ called when the node and all of its parents are actually on the DOM, and is not called with a boolean.
+
+`beforeRemove` was only called when `$.fn.remove` was called, which was typically used when the node was completely removed from the DOM. The new `detached` hook is called whenever the DOM node is _detached_, which could happen if the node is being detached for reattachment later. In short, if `beforeRemove` is called the node is never coming back. With `detached` it might be attached again later.
+
+```coffee
+# Old way
+{View} = require 'atom'
+class MyView extends View
+  afterAttach: (onDom) ->
+    #...
+
+  beforeRemove: ->
+    #...
+```
+
+```coffee
+# New way
+{View} = require 'atom-space-pen-views'
+class MyView extends View
+  attached: ->
+    # Always called with the equivalent of @afterAttach(true)!
+    #...
+
+  detached: ->
+    #...
+```
+
+#### `subscribe` and `subscribeToCommand` methods removed
+
+The `subscribe` and `subscribeToCommand` methods have been removed. See the Eventing and Disposables section for more info.
+
+### Upgrading to the new TextEditorView
+
+All of the atom-specific methods available on the `TextEditorView` have been moved to the `TextEditor`, available via `TextEditorView::getModel`. See the [`TextEditorView` docs][TextEditorView] and [`TextEditor` docs][TextEditor] for more info.
+
+### Upgrading classes extending ScrollView
+
+The `ScrollView` has very minor changes.
+
+You can no longer use `@off` to remove default behavior for `core:move-up`, `core:move-down`, etc.
+
+```coffee
+# Old way to turn off default behavior
+class ResultsView extends ScrollView
+  initialize: (@model) ->
+    super()
+    # turn off default scrolling behavior from ScrollView
+    @off 'core:move-up'
+    @off 'core:move-down'
+    @off 'core:move-left'
+    @off 'core:move-right'
+```
+
+```coffee
+# New way to turn off default behavior
+class ResultsView extends ScrollView
+  initialize: (@model) ->
+    disposable = super()
+    # turn off default scrolling behavior from ScrollView
+    disposable.dispose()
+```
+
+* Check out [an example](https://github.com/atom/find-and-replace/pull/311/files#diff-9) from find-and-replace.
+* See the [docs][ScrollView] for all the options.
+
+### Upgrading classes extending SelectListView
+
+Your SelectListView might look something like this:
+
+```coffee
+# Old!
+class CommandPaletteView extends SelectListView
+  initialize: ->
+    super()
+    @addClass('command-palette overlay from-top')
+    atom.workspaceView.command 'command-palette:toggle', => @toggle()
+
+  confirmed: ({name, jQuery}) ->
+    @cancel()
+    # do something with the result
+
+  toggle: ->
+    if @hasParent()
+      @cancel()
+    else
+      @attach()
+
+  attach: ->
+    @storeFocusedElement()
+
+    items = [] # TODO: build items
+    @setItems(items)
+
+    atom.workspaceView.append(this)
+    @focusFilterEditor()
+
+  confirmed: ({name, jQuery}) ->
+    @cancel()
+```
+
+This attaches and detaches itself from the dom when toggled, canceling magically detaches it from the DOM, and it uses the classes `overlay` and `from-top`.
+
+The new SelectListView no longer automatically detaches itself from the DOM when cancelled. It's up to you to implement whatever cancel beahavior you want. Using the new APIs to mimic the sematics of the old class, it should look like this:
+
+```coffee
+# New!
+class CommandPaletteView extends SelectListView
+  initialize: ->
+    super()
+    # no more need for the `overlay` and `from-top` classes
+    @addClass('command-palette')
+    atom.commands.add 'atom-workspace', 'command-palette:toggle', => @toggle()
+
+  # You need to implement the `cancelled` method and hide.
+  cancelled: ->
+    @hide()
+
+  confirmed: ({name, jQuery}) ->
+    @cancel()
+    # do something with the result
+
+  toggle: ->
+    # Toggling now checks panel visibility,
+    # and hides / shows rather than attaching to / detaching from the DOM.
+    if @panel?.isVisible()
+      @cancel()
+    else
+      @show()
+
+  show: ->
+    # Now you will add your select list as a modal panel to the workspace
+    @panel ?= atom.workspace.addModalPanel(item: this)
+    @panel.show()
+
+    @storeFocusedElement()
+
+    items = [] # TODO: build items
+    @setItems(items)
+
+    @focusFilterEditor()
+
+  hide: ->
+    @panel?.hide()
+```
+
+* And check out the [conversion of CommandPaletteView][selectlistview-example] as a real-world example.
+* See the [SelectListView docs][SelectListView] for all options.
+
+## Using the model layer rather than the view layer
+
+The API no longer exposes any specialized view objects or view classes. `atom.workspaceView`, and all the view classes: `WorkspaceView`, `EditorView`, `PaneView`, etc. have been globally deprecated.
+
+Nearly all of the atom-specific actions performed by the old view objects can now be managed via the model layer. For example, here's adding a panel to the interface using the `atom.workspace` model instead of the `workspaceView`:
+
+```coffee
+# Old!
+div = document.createElement('div')
+atom.workspaceView.appendToTop(div)
+```
+
+```coffee
+# New!
+div = document.createElement('div')
+atom.workspace.addTopPanel(item: div)
+```
+
+For actions that still require the view, such as dispatching commands or munging css classes, you'll access the view via the `atom.views.getView()` method. This will return a subclass of `HTMLElement` rather than a jQuery object or an instance of a deprecated view class (e.g. `WorkspaceView`).
+
+```coffee
+# Old!
+workspaceView = atom.workspaceView
+editorView = workspaceView.getActiveEditorView()
+paneView = editorView.getPaneView()
+```
+
+```coffee
+# New!
+# Generally, just use the models
+workspace = atom.workspace
+editor = workspace.getActiveTextEditor()
+pane = editor.getPane()
+
+# If you need views, get them with `getView`
+workspaceElement = atom.views.getView(atom.workspace)
+editorElement = atom.views.getView(editor)
+paneElement = atom.views.getView(pane)
+```
+
+## Updating Specs
+
+`atom.workspaceView`, the `WorkspaceView` class and the `EditorView` class have been deprecated. These two objects are used heavily throughout specs, mostly to dispatch events and commands. This section will explain how to remove them while still retaining the ability to dispatch events and commands.
+
+### Removing WorkspaceView references
+
+`WorkspaceView` has been deprecated. Everything you could do on the view, you can now do on the `Workspace` model.
+
+Requiring `WorkspaceView` from `atom` and accessing any methods on it will throw a deprecation warning. Many specs lean heavily on `WorkspaceView` to trigger commands and fetch `EditorView` objects.
+
+Your specs might contain something like this:
+
+```coffee
+# Old!
+{WorkspaceView} = require 'atom'
+describe 'FindView', ->
+  beforeEach ->
+    atom.workspaceView = new WorkspaceView()
+```
+
+Instead, we will use the `atom.views.getView()` method. This will return a plain `HTMLElement`, not a `WorkspaceView` or jQuery object.
+
+```coffee
+# New!
+describe 'FindView', ->
+  workspaceElement = null
+  beforeEach ->
+    workspaceElement = atom.views.getView(atom.workspace)
+```
+
+### Attaching the workspace to the DOM
+
+The workspace needs to be attached to the DOM in some cases. For example, view hooks only work (`attached()` on `View`, `attachedCallback()` on custom elements) when there is a descendant attached to the DOM.
+
+You might see this in your specs:
+
+```coffee
+# Old!
+atom.workspaceView.attachToDom()
+```
+
+Change it to:
+
+```coffee
+# New!
+jasmine.attachToDOM(workspaceElement)
+```
+
+### Removing EditorView references
+
+Like `WorkspaceView`, `EditorView` has been deprecated. Everything you needed to do on the view you are now able to do on the `TextEditor` model.
+
+In many cases, you will not even need to get the editor's view anymore. Any of those instances should be updated to use the `TextEditor` instance instead. You should really only need the editor's view when you plan on triggering a command on the view in a spec.
+
+Your specs might contain something like this:
+
+```coffee
+# Old!
+describe 'Something', ->
+  [editorView] = []
+  beforeEach ->
+    editorView = atom.workspaceView.getActiveView()
+```
+
+We're going to use `atom.views.getView()` again to get the editor element. As in the case of the `workspaceElement`, `getView` will return a subclass of `HTMLElement` rather than an `EditorView` or jQuery object.
+
+```coffee
+# New!
+describe 'Something', ->
+  [editor, editorElement] = []
+  beforeEach ->
+    editor = atom.workspace.getActiveTextEditor()
+    editorElement = atom.views.getView(editor)
+```
+
+### Dispatching commands
+
+Since the `editorElement` objects are no longer `jQuery` objects, they no longer support `trigger()`. Additionally, Atom has a new command dispatcher, `atom.commands`, that we use rather than commandeering jQuery's `trigger` method.
+
+From this:
+
+```coffee
+# Old!
+workspaceView.trigger 'a-package:toggle'
+editorView.trigger 'find-and-replace:show'
+```
+
+To this:
+
+```coffee
+# New!
+atom.commands.dispatch workspaceElement, 'a-package:toggle'
+atom.commands.dispatch editorElement, 'find-and-replace:show'
+```
+
+## Eventing and Disposables
+
+A couple large things changed with respect to events:
+
+1. All model events are now exposed as event subscription methods that return [`Disposable`][disposable] objects
+1. The `subscribe()` method is no longer available on `space-pen` `View` objects
+1. An Emitter is now provided from `require 'atom'`
+
+### Consuming Events
+
+All events from the Atom API are now methods that return a [`Disposable`][disposable] object, on which you can call `dispose()` to unsubscribe.
+
+```coffee
+# Old!
+editor.on 'changed', ->
+```
+
+```coffee
+# New!
+disposable = editor.onDidChange ->
+
+# You can unsubscribe at some point in the future via `dispose()`
+disposable.dispose()
+```
+
+Deprecation warnings will guide you toward the correct methods.
+
+#### Using a CompositeDisposable
+
+You can group multiple disposables into a single disposable with a `CompositeDisposable`.
+
+```coffee
+{CompositeDisposable} = require 'atom'
+
+class Something
+  constructor: ->
+    editor = atom.workspace.getActiveTextEditor()
+    @disposables = new CompositeDisposable
+    @disposables.add editor.onDidChange ->
+    @disposables.add editor.onDidChangePath ->
+
+  destroy: ->
+    @disposables.dispose()
+```
+
+### Removing View::subscribe and Subscriber::subscribe calls
+
+There were a couple permutations of `subscribe()`. In these examples, a `CompositeDisposable` is used as it will commonly be useful where conversion is necessary.
+
+#### subscribe(unsubscribable)
+
+This one is very straight forward.
+
+```coffee
+# Old!
+@subscribe editor.on 'changed', ->
+```
+
+```coffee
+# New!
+disposables = new CompositeDisposable
+disposables.add editor.onDidChange ->
+```
+
+#### subscribe(modelObject, event, method)
+
+When the modelObject is an Atom model object, the change is very simple. Just use the correct event method, and add it to your CompositeDisposable.
+
+```coffee
+# Old!
+@subscribe editor, 'changed', ->
+```
+
+```coffee
+# New!
+disposables = new CompositeDisposable
+disposables.add editor.onDidChange ->
+```
+
+#### subscribe(jQueryObject, selector(optional), event, method)
+
+Things are a little more complicated when subscribing to a DOM or jQuery element. Atom no longer provides helpers for subscribing to elements. You can use jQuery or the native DOM APIs, whichever you prefer.
+
+```coffee
+# Old!
+@subscribe $(window), 'focus', ->
+```
+
+```coffee
+# New!
+{Disposable, CompositeDisposable} = require 'atom'
+disposables = new CompositeDisposable
+
+# New with jQuery
+focusCallback = ->
+$(window).on 'focus', focusCallback
+disposables.add new Disposable ->
+  $(window).off 'focus', focusCallback
+
+# New with native APIs
+focusCallback = ->
+window.addEventListener 'focus', focusCallback
+disposables.add new Disposable ->
+  window.removeEventListener 'focus', focusCallback
+```
+
+### Providing Events: Using the Emitter
+
+You no longer need to require `emissary` to get an emitter. We now provide an `Emitter` class from `require 'atom'`. We have a specific pattern for use of the `Emitter`. Rather than mixing it in, we instantiate a member variable, and create explicit subscription methods. For more information see the [`Emitter` docs][emitter].
+
+```coffee
+# New!
+{Emitter} = require 'atom'
+
+class Something
+  constructor: ->
+    @emitter = new Emitter
+
+  destroy: ->
+    @emitter.dispose()
+
+  onDidChange: (callback) ->
+    @emitter.on 'did-change', callback
+
+  methodThatFiresAChange: ->
+    @emitter.emit 'did-change', {data: 2}
+
+# Using the evented class
+something = new Something
+something.onDidChange (eventObject) ->
+  console.log eventObject.data # => 2
+something.methodThatFiresAChange()
+```
+
+## Subscribing To Commands
+
+`$.fn.command` and `View::subscribeToCommand` are no longer available. Now we use `atom.commands.add`, and collect the results in a `CompositeDisposable`. See [the docs][commands-add] for more info.
+
+```coffee
+# Old!
+atom.workspaceView.command 'core:close core:cancel', ->
+
+# When inside a View class, you might see this
+@subscribeToCommand 'core:close core:cancel', ->
+```
+
+```coffee
+# New!
+@disposables.add atom.commands.add 'atom-workspace',
+  'core:close': ->
+  'core:cancel': ->
+
+# You can register commands directly on individual DOM elements in addition to
+# using selectors. When in a View class, you should have a `@element` object
+# available. `@element` is a plain HTMLElement object
+@disposables.add atom.commands.add @element,
+  'core:close': ->
+  'core:cancel': ->
+```
+
+## Upgrading your stylesheet's selectors
+
+Many selectors have changed, and we have introduced the [Shadow DOM][shadowdom] to the editor. See [Upgrading Your Package Selectors guide][upgrading-selectors] for more information in upgrading your package stylesheets.
+
+## Help us improve this guide!
+
+Did you hit something painful that wasn't in here? Want to reword some bit of it? Find something incorrect? Please edit [this file][guide], and send a pull request. Contributions are greatly appreciated.
+
+
+
+
+[texteditorview]:https://github.com/atom/atom-space-pen-views#texteditorview
+[scrollview]:https://github.com/atom/atom-space-pen-views#scrollview
+[selectlistview]:https://github.com/atom/atom-space-pen-views#selectlistview
+[selectlistview-example]:https://github.com/atom/command-palette/pull/19/files
+[emitter]:https://atom.io/docs/api/latest/Emitter
+[texteditor]:https://atom.io/docs/api/latest/TextEditor
+[disposable]:https://atom.io/docs/api/latest/Disposable
+[commands-add]:https://atom.io/docs/api/latest/CommandRegistry#instance-add
+[upgrading-selectors]:upgrading-your-ui-theme
+[shadowdom]:http://blog.atom.io/2014/11/18/avoiding-style-pollution-with-the-shadow-dom.html
+[guide]:https://github.com/atom/atom/blob/master/docs/upgrading/upgrading-your-package.md

docs/upgrading/upgrading-your-syntax-theme.md

@@ -6,19 +6,16 @@ Syntax themes are specifically intended to style only text editor content, so th
 
 When theme style sheets are loaded into the text editor's shadow DOM, selectors intended to target the editor from the *outside* no longer make sense. Styles targeting the `.editor` and `.editor-colors` classes instead need to target the `:host` pseudo-element, which matches against the containing `atom-text-editor` node. Check out the [Shadow DOM 201][host-pseudo-element] article for more information about the `:host` pseudo-element.
 
-Here's an example from Atom's light syntax theme. Note that the previous selectors intended to target the editor from the outside have been retained to allow the theme to keep working during the transition phase when it is possible to disable the shadow DOM.
+Here's an example from Atom's light syntax theme. Note that the `atom-text-editor` selector intended to target the editor from the outside has been retained to allow the theme to keep working during the transition phase when it is possible to disable the shadow DOM.
 
 ```css
-.editor-colors, :host { /* :host added */
+atom-text-editor, :host { /* :host added */
   background-color: @syntax-background-color;
   color: @syntax-text-color;
-}
 
-.editor, :host { /* :host added */
   .invisible-character {
     color: @syntax-invisible-character-color;
   }
-
   /* more nested selectors... */
 }
 ```

docs/upgrading/upgrading-your-ui-theme.md

@@ -1,6 +1,6 @@
 # Upgrading Your UI Theme Or Package Selectors
 
-In addition to changes in Atom's scripting API, we'll also be making some breaking changes to Atom's DOM structure, requiring stylesheets and keymaps in both packages and themes to be updated.
+In addition to changes in Atom's scripting API, we'll also be making some breaking changes to Atom's DOM structure, requiring style sheets and keymaps in both packages and themes to be updated.
 
 ## Deprecation Cop
 
@@ -121,12 +121,12 @@ The selector features discussed above allow you to target shadow DOM content wit
 
 ```
 my-ui-theme/
-  stylesheets/
+  styles/
     index.less                   # loaded globally
     index.atom-text-editor.less  # loaded in the text editor shadow DOM
 ```
 
-Check out this [style sheet](https://github.com/atom/decoration-example/blob/master/stylesheets/decoration-example.atom-text-editor.less) from the decoration-example package for an example of context-targeting.
+Check out this [style sheet](https://github.com/atom/decoration-example/blob/master/styles/decoration-example.atom-text-editor.less) from the decoration-example package for an example of context-targeting.
 
 Inside a context-targeted style sheet, there's no need to use the `::shadow` or `/deep/` expressions. If you want to refer to the element containing the shadow root, you can use the `::host` pseudo-element.
 
@@ -134,4 +134,4 @@ During the transition phase, style sheets targeting the `atom-text-editor` conte
 
 [shadow-dom-101]: http://www.html5rocks.com/en/tutorials/webcomponents/shadowdom
 [shadow-dom-201]: http://www.html5rocks.com/en/tutorials/webcomponents/shadowdom-201#toc-style-cat-hat
-[find-and-replace]: https://github.com/atom/find-and-replace/blob/95351f261bc384960a69b66bf12eae8002da63f9/stylesheets/find-and-replace.less#L10
+[find-and-replace]: https://github.com/atom/find-and-replace/blob/95351f261bc384960a69b66bf12eae8002da63f9/styles/find-and-replace.less#L10

docs/writing-specs.md

@@ -127,3 +127,10 @@ describe "when a test is written", ->
     expect("apples").toEqual("apples")
     expect("oranges").not.toEqual("apples")
 ```
+
+### Running on CI
+
+It is now easy to run the specs in a CI environment like Travis and AppVeyor. See the
+[Travis CI For Your Packages](http://blog.atom.io/2014/04/25/ci-for-your-packages.html)
+and [AppVeyor CI For Your Packages](http://blog.atom.io/2014/07/28/windows-ci-for-your-packages.html)
+posts for more details.

docs/your-first-package.md

@@ -88,17 +88,17 @@ run the `ascii-art:convert` command it will output 'Hello, World!'
 Now let's add a key binding to trigger the `ascii-art:convert` command. Open
 _keymaps/ascii-art.cson_ and add a key binding linking `ctrl-alt-a` to the
 `ascii-art:convert` command. You can delete the pre-existing key binding since
-you don't need it anymore. When finished, the file will look like this:
+you don't need it anymore. When finished, the file will have this:
 
 ```coffeescript
 'atom-text-editor':
-  'cmd-alt-a': 'ascii-art:convert'
+  'ctrl-alt-a': 'ascii-art:convert'
 ```
 
 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 `atom-text-editor` selector. If
-the Tree View has focus, pressing `cmd-alt-a` won't trigger the
+the Tree View has focus, pressing `ctrl-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 [keymaps](advanced/keymaps.html) documentation.
@@ -142,7 +142,7 @@ convert: ->
       selection.insertText("\n#{asciiArt}\n")
 ```
 
-Select some text in an editor window and hit `cmd-alt-a`. :tada: You're now an
+Select some text in an editor window and hit `ctrl-alt-a`. :tada: You're now an
 ASCII art professional!
 
 ## Further reading

dot-atom/keymap.cson

@@ -1,7 +1,7 @@
 # Your keymap
 #
-# Atom keymaps work similarly to stylesheets. Just as stylesheets use selectors
-# to apply styles to elements, Atom keymaps use selectors to associate
+# Atom keymaps work similarly to style sheets. Just as style sheets use
+# selectors to apply styles to elements, Atom keymaps use selectors to associate
 # keystrokes with events in specific contexts.
 #
 # You can create a new keybinding in this file by typing "key" and then hitting

dot-atom/styles.less

@@ -12,10 +12,14 @@
 
 }
 
+// style the background and foreground colors on the atom-text-editor-element
+// itself
 atom-text-editor {
 
 }
 
-atom-text-editor .cursor {
+// To style other content in the text editor's shadow DOM, use the ::shadow
+// expression
+atom-text-editor::shadow .cursor {
 
 }

exports/atom.coffee

@@ -40,11 +40,11 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
   Object.defineProperty module.exports, '$', get: ->
     deprecate """
       Requiring `$` from `atom` is no longer supported.
-      If you are using `space-pen`, please require `$` from `space-pen`. Otherwise require `jquery` instead:
-        `{$} = require 'space-pen'`
+      If you are using `space-pen`, please require `$` from `atom-space-pen-views`. Otherwise require `jquery` instead:
+        `{$} = require 'atom-space-pen-views'`
         or
         `$ = require 'jquery'`
-      Add `"space-pen": "^4"` to your package dependencies.
+      Add `"atom-space-pen-views": "^2.0.3"` to your package dependencies.
       Or add `"jquery": "^2"` to your package dependencies.
     """
     $
@@ -52,27 +52,27 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
   Object.defineProperty module.exports, '$$', get: ->
     deprecate """
       Requiring `$$` from `atom` is no longer supported.
-      Please require `space-pen` instead:
-        `{$$} = require 'space-pen'`
-      Add `"space-pen": "^4"` to your package dependencies.
+      Please require `atom-space-pen-views` instead:
+        `{$$} = require 'atom-space-pen-views'`
+      Add `"atom-space-pen-views": "^2.0.3"` to your package dependencies.
     """
     $$
 
   Object.defineProperty module.exports, '$$$', get: ->
     deprecate """
       Requiring `$$$` from `atom` is no longer supported.
-      Please require `space-pen` instead:
-        `{$$$} = require 'space-pen'`
-      Add `"space-pen": "^4"` to your package dependencies.
+      Please require `atom-space-pen-views` instead:
+        `{$$$} = require 'atom-space-pen-views'`
+      Add `"atom-space-pen-views": "^2.0.3"` to your package dependencies.
     """
     $$$
 
   Object.defineProperty module.exports, 'View', get: ->
     deprecate """
       Requiring `View` from `atom` is no longer supported.
-      Please require `space-pen` instead:
-        `{View} = require 'space-pen'`
-      Add `"space-pen": "^4"` to your package dependencies.
+      Please require `atom-space-pen-views` instead:
+        `{View} = require 'atom-space-pen-views'`
+      Add `"atom-space-pen-views": "^2.0.3"` to your package dependencies.
     """
     View
 
@@ -81,7 +81,7 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
       Requiring `EditorView` from `atom` is no longer supported.
       Please require `TextEditorView` from `atom-space-pen-view` instead:
         `{TextEditorView} = require 'atom-space-pen-views'`
-      Add `"atom-space-pen-views": "^0"` to your package dependencies.
+      Add `"atom-space-pen-views": "^2.0.3"` to your package dependencies.
     """
     require '../src/text-editor-view'
 
@@ -90,7 +90,7 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
       Requiring `TextEditorView` from `atom` is no longer supported.
       Please require `TextEditorView` from `atom-space-pen-view` instead:
         `{TextEditorView} = require 'atom-space-pen-views'`
-      Add `"atom-space-pen-views": "^0"` to your package dependencies.
+      Add `"atom-space-pen-views": "^2.0.3"` to your package dependencies.
     """
     require '../src/text-editor-view'
 
@@ -100,7 +100,7 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
       Please require `ScrollView` from `atom-space-pen-view` instead:
         `{ScrollView} = require 'atom-space-pen-views'`
       Note that the API has changed slightly! Please read the docs at https://github.com/atom/atom-space-pen-views
-      Add `"atom-space-pen-views": "^0"` to your package dependencies.
+      Add `"atom-space-pen-views": "^2.0.3"` to your package dependencies.
     """
     require '../src/scroll-view'
 
@@ -110,7 +110,7 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
       Please require `SelectListView` from `atom-space-pen-view` instead:
         `{SelectListView} = require 'atom-space-pen-views'`
       Note that the API has changed slightly! Please read the docs at https://github.com/atom/atom-space-pen-views
-      Add `"atom-space-pen-views": "^0"` to your package dependencies.
+      Add `"atom-space-pen-views": "^2.0.3"` to your package dependencies.
     """
     require '../src/select-list-view'
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "atom",
   "productName": "Atom",
-  "version": "0.165.0",
+  "version": "0.177.0",
   "description": "A hackable text editor for the 21st Century.",
   "main": "./src/browser/main.js",
   "repository": {
@@ -17,135 +17,141 @@
       "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
     }
   ],
-  "atomShellVersion": "0.19.4",
+  "atomShellVersion": "0.20.7",
   "dependencies": {
     "async": "0.2.6",
-    "atom-keymap": "^2.3.0",
+    "atom-keymap": "^2.5.2",
     "bootstrap": "git+https://github.com/atom/bootstrap.git#6af81906189f1747fd6c93479e3d998ebe041372",
     "clear-cut": "0.4.0",
-    "coffee-script": "1.7.0",
-    "coffeestack": "0.7.0",
+    "coffee-script": "1.8.0",
+    "coffeestack": "0.8.0",
+    "color": "^0.7.3",
     "delegato": "^1",
     "emissary": "^1.3.1",
-    "event-kit": "0.8.1",
-    "first-mate": "^2.2.0",
+    "event-kit": "^1.0.1",
+    "first-mate": "^2.2.5",
     "fs-plus": "^2.3.2",
     "fstream": "0.1.24",
     "fuzzaldrin": "^2.1",
     "git-utils": "^2.2",
-    "grim": "0.12.0",
+    "grim": "1.1.0",
     "guid": "0.0.10",
     "jasmine-json": "~0.0",
     "jasmine-tagged": "^1.1.2",
     "jquery": "^2.1.1",
-    "less-cache": "0.19.0",
+    "less-cache": "git+https://github.com/atom/less-cache.git#018b1739ae03ee35aae9827d7d7b16d0799c5d42",
     "marked": "^0.3",
     "mixto": "^1",
     "mkdirp": "0.3.5",
     "nslog": "^1.0.1",
-    "oniguruma": "^3.0.4",
+    "oniguruma": "^3.0.6",
     "optimist": "0.4.0",
-    "pathwatcher": "^2.3.5",
+    "pathwatcher": "^2.6.1",
     "property-accessors": "^1",
     "q": "^1.0.1",
     "random-words": "0.0.1",
-    "react-atom-fork": "^0.11.1",
+    "react-atom-fork": "^0.11.4",
     "reactionary-atom-fork": "^1.0.0",
     "runas": "1.0.1",
     "scandal": "1.0.3",
-    "scoped-property-store": "^0.15.4",
+    "scoped-property-store": "^0.16.2",
     "scrollbar-style": "^1.0.2",
-    "season": "^1.0.2",
+    "season": "^5.1.1",
     "semver": "2.2.1",
     "serializable": "^1",
-    "service-hub": "^0.1.0",
+    "service-hub": "^0.2.0",
     "space-pen": "3.8.2",
+    "stacktrace-parser": "0.1.1",
     "temp": "0.7.0",
-    "text-buffer": "^3.8.2",
+    "text-buffer": "^3.10.1",
     "theorist": "^1.0.2",
     "underscore-plus": "^1.6.6",
     "vm-compatibility-layer": "0.1.0"
   },
   "packageDependencies": {
-    "atom-dark-syntax": "0.23.0",
-    "atom-dark-ui": "0.42.0",
-    "atom-light-syntax": "0.22.0",
-    "atom-light-ui": "0.36.0",
-    "base16-tomorrow-dark-theme": "0.22.0",
-    "base16-tomorrow-light-theme": "0.5.0",
-    "solarized-dark-syntax": "0.29.0",
-    "solarized-light-syntax": "0.13.0",
-    "archive-view": "0.40.0",
-    "autocomplete": "0.34.0",
-    "autoflow": "0.20.0",
-    "autosave": "0.19.0",
-    "background-tips": "0.18.0",
-    "bookmarks": "0.31.0",
-    "bracket-matcher": "0.64.0",
-    "command-palette": "0.30.0",
-    "deprecation-cop": "0.20.0",
-    "dev-live-reload": "0.36.0",
-    "encoding-selector": "0.12.0",
+    "atom-dark-syntax": "0.26.0",
+    "atom-dark-ui": "0.46.0",
+    "atom-light-syntax": "0.26.0",
+    "atom-light-ui": "0.40.0",
+    "base16-tomorrow-dark-theme": "0.25.0",
+    "base16-tomorrow-light-theme": "0.8.0",
+    "one-dark-ui": "0.2.0",
+    "one-dark-syntax": "0.2.0",
+    "one-light-syntax": "0.2.0",
+    "one-light-ui": "0.1.0",
+    "solarized-dark-syntax": "0.32.0",
+    "solarized-light-syntax": "0.19.0",
+    "archive-view": "0.44.0",
+    "autocomplete": "0.43.0",
+    "autoflow": "0.21.0",
+    "autosave": "0.20.0",
+    "background-tips": "0.21.0",
+    "bookmarks": "0.35.0",
+    "bracket-matcher": "0.69.0",
+    "command-palette": "0.34.0",
+    "deprecation-cop": "0.33.0",
+    "dev-live-reload": "0.39.0",
+    "encoding-selector": "0.17.0",
     "exception-reporting": "0.21.0",
-    "find-and-replace": "0.152.0",
-    "fuzzy-finder": "0.62.0",
-    "git-diff": "0.45.0",
-    "go-to-line": "0.27.0",
-    "grammar-selector": "0.40.0",
-    "image-view": "0.44.0",
-    "incompatible-packages": "0.16.0",
-    "keybinding-resolver": "0.24.0",
-    "link": "0.28.0",
-    "markdown-preview": "0.112.0",
-    "metrics": "0.40.0",
-    "notifications": "0.21.0",
-    "open-on-github": "0.31.0",
-    "package-generator": "0.34.0",
-    "release-notes": "0.43.0",
-    "settings-view": "0.161.0",
-    "snippets": "0.60.0",
-    "spell-check": "0.45.0",
-    "status-bar": "0.54.0",
-    "styleguide": "0.36.0",
-    "symbols-view": "0.70.0",
-    "tabs": "0.58.0",
-    "timecop": "0.24.0",
-    "tree-view": "0.139.0",
+    "find-and-replace": "0.156.0",
+    "fuzzy-finder": "0.65.0",
+    "git-diff": "0.50.0",
+    "go-to-line": "0.30.0",
+    "grammar-selector": "0.44.0",
+    "image-view": "0.47.0",
+    "incompatible-packages": "0.21.0",
+    "keybinding-resolver": "0.27.0",
+    "link": "0.29.0",
+    "markdown-preview": "0.126.0",
+    "metrics": "0.41.0",
+    "notifications": "0.26.0",
+    "open-on-github": "0.32.0",
+    "package-generator": "0.37.0",
+    "release-notes": "0.47.0",
+    "settings-view": "0.174.0",
+    "snippets": "0.70.0",
+    "spell-check": "0.51.0",
+    "status-bar": "0.58.0",
+    "styleguide": "0.42.0",
+    "symbols-view": "0.79.0",
+    "tabs": "0.64.0",
+    "timecop": "0.28.0",
+    "tree-view": "0.149.0",
     "update-package-dependencies": "0.7.0",
     "welcome": "0.21.0",
-    "whitespace": "0.27.0",
-    "wrap-guide": "0.27.0",
-    "language-c": "0.33.0",
-    "language-clojure": "0.9.0",
-    "language-coffee-script": "0.38.1",
-    "language-css": "0.24.0",
-    "language-gfm": "0.55.0",
-    "language-git": "0.9.0",
-    "language-go": "0.19.1",
-    "language-html": "0.27.0",
+    "whitespace": "0.28.0",
+    "wrap-guide": "0.31.0",
+    "language-c": "0.37.0",
+    "language-clojure": "0.10.0",
+    "language-coffee-script": "0.39.0",
+    "language-css": "0.26.0",
+    "language-gfm": "0.63.0",
+    "language-git": "0.10.0",
+    "language-go": "0.21.0",
+    "language-html": "0.28.0",
     "language-hyperlink": "0.12.2",
-    "language-java": "0.13.0",
-    "language-javascript": "0.51.0",
-    "language-json": "0.10.0",
-    "language-less": "0.21.0",
-    "language-make": "0.12.0",
+    "language-java": "0.14.0",
+    "language-javascript": "0.55.0",
+    "language-json": "0.11.0",
+    "language-less": "0.24.0",
+    "language-make": "0.13.0",
     "language-mustache": "0.11.0",
-    "language-objective-c": "0.12.0",
-    "language-perl": "0.9.0",
-    "language-php": "0.18.0",
-    "language-property-list": "0.7.0",
-    "language-python": "0.26.0",
-    "language-ruby": "0.45.0",
+    "language-objective-c": "0.15.0",
+    "language-perl": "0.10.0",
+    "language-php": "0.20.0",
+    "language-property-list": "0.8.0",
+    "language-python": "0.30.0",
+    "language-ruby": "0.47.0",
     "language-ruby-on-rails": "0.18.0",
-    "language-sass": "0.29.0",
-    "language-shellscript": "0.10.1",
-    "language-source": "0.8.0",
-    "language-sql": "0.11.0",
+    "language-sass": "0.31.0",
+    "language-shellscript": "0.12.0",
+    "language-source": "0.9.0",
+    "language-sql": "0.14.0",
     "language-text": "0.6.0",
     "language-todo": "0.15.0",
-    "language-toml": "0.14.1",
-    "language-xml": "0.25.0",
-    "language-yaml": "0.21.0"
+    "language-toml": "0.15.0",
+    "language-xml": "0.27.0",
+    "language-yaml": "0.22.0"
   },
   "private": true,
   "scripts": {

resources/win/apm.sh

@@ -1,3 +1,3 @@
 #!/bin/sh
 
-"$0/../../app/apm/node_modules/atom-package-manager/bin/node.exe" "$0/../../app/apm/node_modules/atom-package-manager/lib/cli.js" "$@"
+"$0/../../app/apm/bin/node.exe" "$0/../../app/apm/lib/cli.js" "$@"

resources/win/atom.cmd

@@ -18,5 +18,5 @@ FOR %%a IN (%*) DO (
 IF "%EXPECT_OUTPUT%"=="YES" (
   "%~dp0\..\..\atom.exe" %*
 ) ELSE (
-  "%~dp0\..\app\apm\node_modules\atom-package-manager\bin\node.exe" "%~dp0\atom.js" %*
+  "%~dp0\..\app\apm\bin\node.exe" "%~dp0\atom.js" %*
 )

resources/win/atom.sh

@@ -18,5 +18,5 @@ done
 if [ $EXPECT_OUTPUT ]; then
   "$0/../../../atom.exe" "$@"
 else
-  "$0/../../app/apm/node_modules/atom-package-manager/bin/node.exe" "$0/../atom.js" "$@"
+  "$0/../../app/apm/bin/node.exe" "$0/../atom.js" "$@"
 fi

script/bootstrap

@@ -48,9 +48,9 @@ function bootstrap() {
   var dedupeNpmCommand = npmPath + npmFlags + 'dedupe';
 
   if (process.argv.indexOf('--no-quiet') === -1) {
-    buildInstallCommand  += ' --quiet';
-    apmInstallCommand    += ' --quiet';
-    moduleInstallCommand += ' --quiet';
+    buildInstallCommand  += ' --loglevel error';
+    apmInstallCommand    += ' --loglevel error';
+    moduleInstallCommand += ' --loglevel error';
     dedupeApmCommand     += ' --quiet';
     dedupeNpmCommand     += ' --quiet';
     buildInstallOptions.ignoreStdout = true;

spec/atom-reporter.coffee

@@ -117,7 +117,7 @@ class AtomReporter extends View
           @div class: 'result-message fail deprecation-message', =>
             @raw marked(deprecation.message)
 
-          for stack in deprecation.stacks
+          for stack in deprecation.getStacks()
             fullStack = stack.map ({functionName, location}) ->
               if functionName is '<unknown>'
                 "  at #{location}"

spec/display-buffer-spec.coffee

@@ -351,11 +351,16 @@ describe "DisplayBuffer", ->
           expect(displayBuffer.tokenizedLineForScreenRow(1).text).toMatch /^10/
 
       describe "when there is another display buffer pointing to the same buffer", ->
-        it "does not create folds in the other display buffer", ->
+        it "does not consider folds to be nested inside of folds from the other display buffer", ->
           otherDisplayBuffer = new DisplayBuffer({buffer, tabLength})
+          otherDisplayBuffer.createFold(1, 5)
+
           displayBuffer.createFold(2, 4)
           expect(otherDisplayBuffer.foldsStartingAtBufferRow(2).length).toBe 0
 
+          expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe '2'
+          expect(displayBuffer.tokenizedLineForScreenRow(3).text).toBe '5'
+
     describe "when the buffer changes", ->
       [fold1, fold2] = []
       beforeEach ->
@@ -1058,7 +1063,7 @@ describe "DisplayBuffer", ->
     [marker, decoration, decorationProperties] = []
     beforeEach ->
       marker = displayBuffer.markBufferRange([[2, 13], [3, 15]])
-      decorationProperties = {type: 'gutter', class: 'one'}
+      decorationProperties = {type: 'line-number', class: 'one'}
       decoration = displayBuffer.decorateMarker(marker, decorationProperties)
 
     it "can add decorations associated with markers and remove them", ->
@@ -1079,11 +1084,11 @@ describe "DisplayBuffer", ->
     describe "when a decoration is updated via Decoration::update()", ->
       it "emits an 'updated' event containing the new and old params", ->
         decoration.onDidChangeProperties updatedSpy = jasmine.createSpy()
-        decoration.setProperties type: 'gutter', class: 'two'
+        decoration.setProperties type: 'line-number', class: 'two'
 
         {oldProperties, newProperties} = updatedSpy.mostRecentCall.args[0]
         expect(oldProperties).toEqual decorationProperties
-        expect(newProperties).toEqual type: 'gutter', class: 'two', id: decoration.id
+        expect(newProperties).toEqual type: 'line-number', class: 'two', id: decoration.id
 
     describe "::getDecorations(properties)", ->
       it "returns decorations matching the given optional properties", ->

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

@@ -9,5 +9,3 @@ module.exports =
         two:
           type: 'integer'
           default: 2
-
-  activate: -> # no-op

spec/fixtures/packages/package-with-deprecated-pane-item-method/index.coffee

@@ -0,0 +1,5 @@
+class TestItem
+  getUri: -> "test"
+
+exports.activate = ->
+  atom.workspace.addOpener -> new TestItem

spec/fixtures/packages/package-with-empty-keymap/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "package-with-empty-keymap",
+  "version": "1.0.0"
+}

spec/fixtures/packages/package-with-empty-menu/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "package-with-empty-menu",
+  "version": "1.0.0"
+}

spec/fixtures/packages/package-with-style-sheets-manifest/package.cson

@@ -0,0 +1 @@
+styleSheets: ['2', '1']

spec/fixtures/packages/package-with-stylesheets-manifest/package.cson

@@ -1 +1 @@
-stylesheets: ['2', '1']
+styleSheets: ['2', '1']

spec/fixtures/packages/theme-with-incomplete-ui-variables/package.json

@@ -1,4 +1,4 @@
 {
   "theme": "ui",
-  "stylesheets": ["editor.less"]
+  "styleSheets": ["editor.less"]
 }

spec/fixtures/packages/theme-with-package-file/package.json

@@ -1,4 +1,4 @@
 {
   "theme": "ui",
-  "stylesheets": ["first.css", "second.less", "last.css"]
+  "styleSheets": ["first.css", "second.less", "last.css"]
 }

spec/fixtures/packages/theme-with-syntax-variables/package.json

@@ -1,4 +1,4 @@
 {
   "theme": "syntax",
-  "stylesheets": ["editor.less"]
+  "styleSheets": ["editor.less"]
 }

spec/fixtures/packages/theme-with-ui-variables/package.json

@@ -1,4 +1,4 @@
 {
   "theme": "ui",
-  "stylesheets": ["editor.less"]
+  "styleSheets": ["editor.less"]
 }

spec/fixtures/task-spec-handler.coffee

@@ -1,2 +1,3 @@
 module.exports = ->
+  emit("some-event", 1, 2, 3)
   'hello'

spec/language-mode-spec.coffee

@@ -381,6 +381,23 @@ describe "LanguageMode", ->
         expect(languageMode.isFoldableAtBufferRow(3)).toBe false
         expect(languageMode.isFoldableAtBufferRow(4)).toBe true
 
+    describe ".foldAllAtIndentLevel(indentLevel)", ->
+      it "folds blocks of text at the given indentation level", ->
+        languageMode.foldAllAtIndentLevel(0)
+        expect(editor.lineTextForScreenRow(0)).toBe "var quicksort = function () {"
+        expect(editor.getLastScreenRow()).toBe 0
+
+        languageMode.foldAllAtIndentLevel(1)
+        expect(editor.lineTextForScreenRow(0)).toBe "var quicksort = function () {"
+        expect(editor.lineTextForScreenRow(1)).toBe "  var sort = function(items) {"
+        expect(editor.getLastScreenRow()).toBe 4
+
+        languageMode.foldAllAtIndentLevel(2)
+        expect(editor.lineTextForScreenRow(0)).toBe "var quicksort = function () {"
+        expect(editor.lineTextForScreenRow(1)).toBe "  var sort = function(items) {"
+        expect(editor.lineTextForScreenRow(2)).toBe "    if (items.length <= 1) return items;"
+        expect(editor.getLastScreenRow()).toBe 9
+
   describe "folding with comments", ->
     beforeEach ->
       waitsForPromise ->

spec/package-spec.coffee

@@ -9,14 +9,14 @@ describe "Package", ->
       spyOn(atom, 'inDevMode').andReturn(false)
 
     it "does not activate it", ->
-      packagePath = atom.project.resolve('packages/package-with-incompatible-native-module')
+      packagePath = atom.project.getDirectories()[0]?.resolve('packages/package-with-incompatible-native-module')
       pack = new Package(packagePath)
       expect(pack.isCompatible()).toBe false
       expect(pack.incompatibleModules[0].name).toBe 'native-module'
       expect(pack.incompatibleModules[0].path).toBe path.join(packagePath, 'node_modules', 'native-module')
 
     it "caches the incompatible native modules in local storage", ->
-      packagePath = atom.project.resolve('packages/package-with-incompatible-native-module')
+      packagePath = atom.project.getDirectories()[0]?.resolve('packages/package-with-incompatible-native-module')
       cacheKey = null
       cacheItem = null
 
@@ -46,14 +46,14 @@ describe "Package", ->
     describe "when the theme contains a single style file", ->
       it "loads and applies css", ->
         expect($("atom-text-editor").css("padding-bottom")).not.toBe "1234px"
-        themePath = atom.project.resolve('packages/theme-with-index-css')
+        themePath = atom.project.getDirectories()[0]?.resolve('packages/theme-with-index-css')
         theme = new ThemePackage(themePath)
         theme.activate()
         expect($("atom-text-editor").css("padding-top")).toBe "1234px"
 
       it "parses, loads and applies less", ->
         expect($("atom-text-editor").css("padding-bottom")).not.toBe "1234px"
-        themePath = atom.project.resolve('packages/theme-with-index-less')
+        themePath = atom.project.getDirectories()[0]?.resolve('packages/theme-with-index-less')
         theme = new ThemePackage(themePath)
         theme.activate()
         expect($("atom-text-editor").css("padding-top")).toBe "4321px"
@@ -64,7 +64,7 @@ describe "Package", ->
         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')
+        themePath = atom.project.getDirectories()[0]?.resolve('packages/theme-with-package-file')
         theme = new ThemePackage(themePath)
         theme.activate()
         expect($("atom-text-editor").css("padding-top")).toBe("101px")
@@ -77,7 +77,7 @@ describe "Package", ->
         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')
+        themePath = atom.project.getDirectories()[0]?.resolve('packages/theme-without-package-file')
         theme = new ThemePackage(themePath)
         theme.activate()
         expect($("atom-text-editor").css("padding-top")).toBe "10px"
@@ -86,7 +86,7 @@ describe "Package", ->
 
     describe "reloading a theme", ->
       beforeEach ->
-        themePath = atom.project.resolve('packages/theme-with-package-file')
+        themePath = atom.project.getDirectories()[0]?.resolve('packages/theme-with-package-file')
         theme = new ThemePackage(themePath)
         theme.activate()
 
@@ -97,7 +97,7 @@ describe "Package", ->
 
     describe "events", ->
       beforeEach ->
-        themePath = atom.project.resolve('packages/theme-with-package-file')
+        themePath = atom.project.getDirectories()[0]?.resolve('packages/theme-with-package-file')
         theme = new ThemePackage(themePath)
         theme.activate()
 

spec/pane-container-spec.coffee

@@ -129,7 +129,7 @@ describe "PaneContainer", ->
     beforeEach ->
       class TestItem
         shouldPromptToSave: -> true
-        getUri: -> 'test'
+        getURI: -> 'test'
 
       container = new PaneContainer
       container.getRoot().splitRight()

spec/pane-container-view-spec.coffee

@@ -16,7 +16,7 @@ describe "PaneContainerView", ->
       @content: -> @div tabindex: -1
       initialize: (@name) -> @text(@name)
       serialize: -> { deserializer: 'TestView', @name }
-      getUri: -> path.join(temp.dir, @name)
+      getURI: -> path.join(temp.dir, @name)
       save: -> @saved = true
       isEqual: (other) -> @name is other?.name
       onDidChangeTitle: -> new Disposable(->)

spec/pane-spec.coffee

@@ -9,7 +9,7 @@ describe "Pane", ->
   class Item extends Model
     @deserialize: ({name, uri}) -> new this(name, uri)
     constructor: (@name, @uri) ->
-    getUri: -> @uri
+    getURI: -> @uri
     getPath: -> @path
     serialize: -> {deserializer: 'Item', @name, @uri}
     isEqual: (other) -> @name is other?.name
@@ -231,18 +231,18 @@ describe "Pane", ->
         expect(pane.getActiveItem()).toBe item1
 
     describe "if the item is modified", ->
-      itemUri = null
+      itemURI = null
 
       beforeEach ->
         item1.shouldPromptToSave = -> true
         item1.save = jasmine.createSpy("save")
         item1.saveAs = jasmine.createSpy("saveAs")
-        item1.getUri = -> itemUri
+        item1.getURI = -> itemURI
 
       describe "if the [Save] option is selected", ->
         describe "when the item has a uri", ->
           it "saves the item before destroying it", ->
-            itemUri = "test"
+            itemURI = "test"
             spyOn(atom, 'confirm').andReturn(0)
             pane.destroyItem(item1)
 
@@ -252,7 +252,7 @@ describe "Pane", ->
 
         describe "when the item has no uri", ->
           it "presents a save-as dialog, then saves the item with the given uri before removing and destroying it", ->
-            itemUri = null
+            itemURI = null
 
             spyOn(atom, 'showSaveDialogSync').andReturn("/selected/path")
             spyOn(atom, 'confirm').andReturn(0)
@@ -404,15 +404,15 @@ describe "Pane", ->
         pane.saveActiveItemAs()
         expect(atom.showSaveDialogSync).not.toHaveBeenCalled()
 
-  describe "::itemForUri(uri)", ->
-    it "returns the item for which a call to .getUri() returns the given uri", ->
+  describe "::itemForURI(uri)", ->
+    it "returns the item for which a call to .getURI() returns the given uri", ->
       pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C"), new Item("D")])
       [item1, item2, item3] = pane.getItems()
       item1.uri = "a"
       item2.uri = "b"
-      expect(pane.itemForUri("a")).toBe item1
-      expect(pane.itemForUri("b")).toBe item2
-      expect(pane.itemForUri("bogus")).toBeUndefined()
+      expect(pane.itemForURI("a")).toBe item1
+      expect(pane.itemForURI("b")).toBe item2
+      expect(pane.itemForURI("bogus")).toBeUndefined()
 
   describe "::moveItem(item, index)", ->
     [pane, item1, item2, item3, item4] = []
@@ -589,7 +589,7 @@ describe "Pane", ->
       [item1, item2] = pane.getItems()
 
       item1.shouldPromptToSave = -> true
-      item1.getUri = -> "/test/path"
+      item1.getURI = -> "/test/path"
       item1.save = jasmine.createSpy("save")
 
       spyOn(atom, 'confirm').andReturn(0)
@@ -604,7 +604,7 @@ describe "Pane", ->
       [item1, item2] = pane.getItems()
 
       item1.shouldPromptToSave = -> true
-      item1.getUri = -> "/test/path"
+      item1.getURI = -> "/test/path"
       item1.save = jasmine.createSpy("save")
 
       spyOn(atom, 'confirm').andReturn(1)

spec/pane-view-spec.coffee

@@ -15,7 +15,7 @@ describe "PaneView", ->
     initialize: ({@id, @text}) ->
       @emitter = new Emitter
     serialize: -> { deserializer: 'TestView', @id, @text }
-    getUri: -> @id
+    getURI: -> @id
     isEqual: (other) -> other? and @id == other.id and @text == other.text
     changeTitle: ->
       @emitter.emit 'did-change-title', 'title'

spec/project-spec.coffee

@@ -4,12 +4,11 @@ Project = require '../src/project'
 _ = require 'underscore-plus'
 fs = require 'fs-plus'
 path = require 'path'
-platform = require './spec-helper-platform'
 BufferedProcess = require '../src/buffered-process'
 
 describe "Project", ->
   beforeEach ->
-    atom.project.setPaths([atom.project.resolve('dir')])
+    atom.project.setPaths([atom.project.getDirectories()[0]?.resolve('dir')])
 
   describe "serialization", ->
     deserializedProject = null
@@ -38,6 +37,32 @@ describe "Project", ->
         deserializedProject.getBuffers()[0].destroy()
         expect(deserializedProject.getBuffers().length).toBe 0
 
+
+    it "does not deserialize buffers when their path is a directory that exists", ->
+      pathToOpen = path.join(temp.mkdirSync(), 'file.txt')
+
+      waitsForPromise ->
+        atom.project.open(pathToOpen)
+
+      runs ->
+        expect(atom.project.getBuffers().length).toBe 1
+        fs.mkdirSync(pathToOpen)
+        deserializedProject = atom.project.testSerialization()
+        expect(deserializedProject.getBuffers().length).toBe 0
+
+    it "does not deserialize buffers when their path is inaccessible", ->
+      pathToOpen = path.join(temp.mkdirSync(), 'file.txt')
+      fs.writeFileSync(pathToOpen, '')
+
+      waitsForPromise ->
+        atom.project.open(pathToOpen)
+
+      runs ->
+        expect(atom.project.getBuffers().length).toBe 1
+        fs.chmodSync(pathToOpen, '000')
+        deserializedProject = atom.project.testSerialization()
+        expect(deserializedProject.getBuffers().length).toBe 0
+
   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
@@ -52,6 +77,29 @@ describe "Project", ->
         editor.saveAs(tempFile)
         expect(atom.project.getPaths()[0]).toBe path.dirname(tempFile)
 
+  describe "when a watch error is thrown from the TextBuffer", ->
+    editor = null
+    beforeEach ->
+      waitsForPromise ->
+        atom.project.open(require.resolve('./fixtures/dir/a')).then (o) -> editor = o
+
+    it "creates a warning notification", ->
+      atom.notifications.onDidAddNotification noteSpy = jasmine.createSpy()
+
+      error = new Error('SomeError')
+      error.eventType = 'resurrect'
+      editor.buffer.emitter.emit 'will-throw-watch-error',
+        handle: jasmine.createSpy()
+        error: error
+
+      expect(noteSpy).toHaveBeenCalled()
+
+      notification = noteSpy.mostRecentCall.args[0]
+      expect(notification.getType()).toBe 'warning'
+      expect(notification.getDetail()).toBe 'SomeError'
+      expect(notification.getMessage()).toContain '`resurrect`'
+      expect(notification.getMessage()).toContain 'fixtures/dir/a'
+
   describe ".open(path)", ->
     [absolutePath, newBufferHandler] = []
 
@@ -110,7 +158,7 @@ describe "Project", ->
           expect(newBufferHandler).toHaveBeenCalledWith(editor.buffer)
 
     it "returns number of read bytes as progress indicator", ->
-      filePath = atom.project.resolve 'a'
+      filePath = atom.project.getDirectories()[0]?.resolve 'a'
       totalBytes = 0
       promise = atom.project.open(filePath)
       promise.progress (bytesRead) -> totalBytes = bytesRead
@@ -149,27 +197,6 @@ describe "Project", ->
           atom.project.bufferForPath("b").then (anotherBuffer) ->
             expect(anotherBuffer).not.toBe buffer
 
-  describe ".resolve(uri)", ->
-    describe "when passed an absolute or relative path", ->
-      it "returns an absolute path based on the atom.project's root", ->
-        absolutePath = require.resolve('./fixtures/dir/a')
-        expect(atom.project.resolve('a')).toBe absolutePath
-        expect(atom.project.resolve(absolutePath + '/../a')).toBe absolutePath
-        expect(atom.project.resolve('a/../a')).toBe absolutePath
-        expect(atom.project.resolve()).toBeUndefined()
-
-    describe "when passed a uri with a scheme", ->
-      it "does not modify uris that begin with a scheme", ->
-        expect(atom.project.resolve('http://zombo.com')).toBe 'http://zombo.com'
-
-    describe "when the project has no path", ->
-      it "returns undefined for relative URIs", ->
-        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)
-        expect(atom.project.resolve(absolutePath)).toBe absolutePath
-
   describe ".setPaths(path)", ->
     describe "when path is a file", ->
       it "sets its path to the files parent directory and updates the root directory", ->
@@ -195,290 +222,6 @@ describe "Project", ->
       expect(atom.project.getPaths()[0]).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
       expect(atom.project.getDirectories()[0].path).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
 
-  describe ".replace()", ->
-    [filePath, commentFilePath, sampleContent, sampleCommentContent] = []
-
-    beforeEach ->
-      atom.project.setPaths([atom.project.resolve('../')])
-
-      filePath = atom.project.resolve('sample.js')
-      commentFilePath = atom.project.resolve('sample-with-comments.js')
-      sampleContent = fs.readFileSync(filePath).toString()
-      sampleCommentContent = fs.readFileSync(commentFilePath).toString()
-
-    afterEach ->
-      fs.writeFileSync(filePath, sampleContent)
-      fs.writeFileSync(commentFilePath, sampleCommentContent)
-
-    describe "when a file doesn't exist", ->
-      it "calls back with an error", ->
-        errors = []
-        missingPath = path.resolve('/not-a-file.js')
-        expect(fs.existsSync(missingPath)).toBeFalsy()
-
-        waitsForPromise ->
-          atom.project.replace /items/gi, 'items', [missingPath], (result, error) ->
-            errors.push(error)
-
-        runs ->
-          expect(errors).toHaveLength 1
-          expect(errors[0].path).toBe missingPath
-
-    describe "when called with unopened files", ->
-      it "replaces properly", ->
-        results = []
-        waitsForPromise ->
-          atom.project.replace /items/gi, 'items', [filePath], (result) ->
-            results.push(result)
-
-        runs ->
-          expect(results).toHaveLength 1
-          expect(results[0].filePath).toBe filePath
-          expect(results[0].replacements).toBe 6
-
-    describe "when a buffer is already open", ->
-      it "replaces properly and saves when not modified", ->
-        editor = null
-        results = []
-
-        waitsForPromise ->
-          atom.project.open('sample.js').then (o) -> editor = o
-
-        runs ->
-          expect(editor.isModified()).toBeFalsy()
-
-        waitsForPromise ->
-          atom.project.replace /items/gi, 'items', [filePath], (result) ->
-            results.push(result)
-
-        runs ->
-          expect(results).toHaveLength 1
-          expect(results[0].filePath).toBe filePath
-          expect(results[0].replacements).toBe 6
-
-          expect(editor.isModified()).toBeFalsy()
-
-      it "does not replace when the path is not specified", ->
-        editor = null
-        results = []
-
-        waitsForPromise ->
-          atom.project.open('sample-with-comments.js').then (o) -> editor = o
-
-        waitsForPromise ->
-          atom.project.replace /items/gi, 'items', [commentFilePath], (result) ->
-            results.push(result)
-
-        runs ->
-          expect(results).toHaveLength 1
-          expect(results[0].filePath).toBe commentFilePath
-
-      it "does NOT save when modified", ->
-        editor = null
-        results = []
-
-        waitsForPromise ->
-          atom.project.open('sample.js').then (o) -> editor = o
-
-        runs ->
-          editor.buffer.setTextInRange([[0,0],[0,0]], 'omg')
-          expect(editor.isModified()).toBeTruthy()
-
-        waitsForPromise ->
-          atom.project.replace /items/gi, 'okthen', [filePath], (result) ->
-            results.push(result)
-
-        runs ->
-          expect(results).toHaveLength 1
-          expect(results[0].filePath).toBe filePath
-          expect(results[0].replacements).toBe 6
-
-          expect(editor.isModified()).toBeTruthy()
-
-  describe ".scan(options, callback)", ->
-    describe "when called with a regex", ->
-      it "calls the callback with all regex results in all files in the project", ->
-        results = []
-        waitsForPromise ->
-          atom.project.scan /(a)+/, (result) ->
-            results.push(result)
-
-        runs ->
-          expect(results).toHaveLength(3)
-          expect(results[0].filePath).toBe atom.project.resolve('a')
-          expect(results[0].matches).toHaveLength(3)
-          expect(results[0].matches[0]).toEqual
-            matchText: 'aaa'
-            lineText: 'aaa bbb'
-            lineTextOffset: 0
-            range: [[0, 0], [0, 3]]
-
-      it "works with with escaped literals (like $ and ^)", ->
-        results = []
-        waitsForPromise ->
-          atom.project.scan /\$\w+/, (result) -> results.push(result)
-
-        runs ->
-          expect(results.length).toBe 1
-
-          {filePath, matches} = results[0]
-          expect(filePath).toBe atom.project.resolve('a')
-          expect(matches).toHaveLength 1
-          expect(matches[0]).toEqual
-            matchText: '$bill'
-            lineText: 'dollar$bill'
-            lineTextOffset: 0
-            range: [[2, 6], [2, 11]]
-
-      it "works on evil filenames", ->
-        platform.generateEvilFiles()
-        atom.project.setPaths([path.join(__dirname, 'fixtures', 'evil-files')])
-        paths = []
-        matches = []
-        waitsForPromise ->
-          atom.project.scan /evil/, (result) ->
-            paths.push(result.filePath)
-            matches = matches.concat(result.matches)
-
-        runs ->
-          _.each(matches, (m) -> expect(m.matchText).toEqual 'evil')
-
-          if platform.isWindows()
-            expect(paths.length).toBe 3
-            expect(paths[0]).toMatch /a_file_with_utf8.txt$/
-            expect(paths[1]).toMatch /file with spaces.txt$/
-            expect(path.basename(paths[2])).toBe "utfa\u0306.md"
-          else
-            expect(paths.length).toBe 5
-            expect(paths[0]).toMatch /a_file_with_utf8.txt$/
-            expect(paths[1]).toMatch /file with spaces.txt$/
-            expect(paths[2]).toMatch /goddam\nnewlines$/m
-            expect(paths[3]).toMatch /quote".txt$/m
-            expect(path.basename(paths[4])).toBe "utfa\u0306.md"
-
-      it "ignores case if the regex includes the `i` flag", ->
-        results = []
-        waitsForPromise ->
-          atom.project.scan /DOLLAR/i, (result) -> results.push(result)
-
-        runs ->
-          expect(results).toHaveLength 1
-
-      describe "when the core.excludeVcsIgnoredPaths config is truthy", ->
-        [projectPath, ignoredPath] = []
-
-        beforeEach ->
-          sourceProjectPath = path.join(__dirname, 'fixtures', 'git', 'working-dir')
-          projectPath = path.join(temp.mkdirSync("atom"))
-
-          writerStream = fstream.Writer(projectPath)
-          fstream.Reader(sourceProjectPath).pipe(writerStream)
-
-          waitsFor (done) ->
-            writerStream.on 'close', done
-            writerStream.on 'error', done
-
-          runs ->
-            fs.rename(path.join(projectPath, 'git.git'), path.join(projectPath, '.git'))
-            ignoredPath = path.join(projectPath, 'ignored.txt')
-            fs.writeFileSync(ignoredPath, 'this match should not be included')
-
-        afterEach ->
-          fs.removeSync(projectPath) if fs.existsSync(projectPath)
-
-        it "excludes ignored files", ->
-          atom.project.setPaths([projectPath])
-          atom.config.set('core.excludeVcsIgnoredPaths', true)
-          resultHandler = jasmine.createSpy("result found")
-          waitsForPromise ->
-            atom.project.scan /match/, (results) ->
-              resultHandler()
-
-          runs ->
-            expect(resultHandler).not.toHaveBeenCalled()
-
-      it "includes only files when a directory filter is specified", ->
-        projectPath = path.join(path.join(__dirname, 'fixtures', 'dir'))
-        atom.project.setPaths([projectPath])
-
-        filePath = path.join(projectPath, 'a-dir', 'oh-git')
-
-        paths = []
-        matches = []
-        waitsForPromise ->
-          atom.project.scan /aaa/, paths: ["a-dir#{path.sep}"], (result) ->
-            paths.push(result.filePath)
-            matches = matches.concat(result.matches)
-
-        runs ->
-          expect(paths.length).toBe 1
-          expect(paths[0]).toBe filePath
-          expect(matches.length).toBe 1
-
-      it "includes files and folders that begin with a '.'", ->
-        projectPath = temp.mkdirSync()
-        filePath = path.join(projectPath, '.text')
-        fs.writeFileSync(filePath, 'match this')
-        atom.project.setPaths([projectPath])
-        paths = []
-        matches = []
-        waitsForPromise ->
-          atom.project.scan /match this/, (result) ->
-            paths.push(result.filePath)
-            matches = matches.concat(result.matches)
-
-        runs ->
-          expect(paths.length).toBe 1
-          expect(paths[0]).toBe filePath
-          expect(matches.length).toBe 1
-
-      it "excludes values in core.ignoredNames", ->
-        projectPath = path.join(__dirname, 'fixtures', 'git', 'working-dir')
-        ignoredNames = atom.config.get("core.ignoredNames")
-        ignoredNames.push("a")
-        atom.config.set("core.ignoredNames", ignoredNames)
-
-        resultHandler = jasmine.createSpy("result found")
-        waitsForPromise ->
-          atom.project.scan /dollar/, (results) ->
-            resultHandler()
-
-        runs ->
-          expect(resultHandler).not.toHaveBeenCalled()
-
-      it "scans buffer contents if the buffer is modified", ->
-        editor = null
-        results = []
-
-        waitsForPromise ->
-          atom.project.open('a').then (o) ->
-            editor = o
-            editor.setText("Elephant")
-
-        waitsForPromise ->
-          atom.project.scan /a|Elephant/, (result) -> results.push result
-
-        runs ->
-          expect(results).toHaveLength 3
-          resultForA = _.find results, ({filePath}) -> path.basename(filePath) == 'a'
-          expect(resultForA.matches).toHaveLength 1
-          expect(resultForA.matches[0].matchText).toBe 'Elephant'
-
-      it "ignores buffers outside the project", ->
-        editor = null
-        results = []
-
-        waitsForPromise ->
-          atom.project.open(temp.openSync().path).then (o) ->
-            editor = o
-            editor.setText("Elephant")
-
-        waitsForPromise ->
-          atom.project.scan /Elephant/, (result) -> results.push result
-
-        runs ->
-          expect(results).toHaveLength 0
-
   describe ".eachBuffer(callback)", ->
     beforeEach ->
       atom.project.bufferForPathSync('a')

spec/spec-helper.coffee

@@ -84,6 +84,10 @@ beforeEach ->
   atom.workspaceViewParentSelector = '#jasmine-content'
 
   window.resetTimeouts()
+  spyOn(_._, "now").andCallFake -> window.now
+  spyOn(window, "setTimeout").andCallFake window.fakeSetTimeout
+  spyOn(window, "clearTimeout").andCallFake window.fakeClearTimeout
+
   atom.packages.packageStates = {}
 
   serializedWindowState = null
@@ -102,9 +106,9 @@ beforeEach ->
   spyOn(atom.menu, 'sendToBrowserProcess')
 
   # reset config before each spec; don't load or save from/to `config.json`
+  spyOn(Config::, 'load')
+  spyOn(Config::, 'save')
   config = new Config({resourcePath, configDirPath: atom.getConfigDirPath()})
-  spyOn(config, 'load')
-  spyOn(config, 'save')
   atom.config = config
   atom.loadConfig()
   config.set "core.destroyEmptyPanes", false
@@ -114,6 +118,8 @@ beforeEach ->
   config.set "core.disabledPackages", ["package-that-throws-an-exception",
     "package-with-broken-package-json", "package-with-broken-keymap"]
   config.set "editor.useShadowDOM", true
+  advanceClock(1000)
+  window.setTimeout.reset()
   config.load.reset()
   config.save.reset()
 
@@ -121,8 +127,6 @@ beforeEach ->
   TextEditorElement::setUpdatedSynchronously(true)
 
   spyOn(atom, "setRepresentedFilename")
-  spyOn(window, "setTimeout").andCallFake window.fakeSetTimeout
-  spyOn(window, "clearTimeout").andCallFake window.fakeClearTimeout
   spyOn(pathwatcher.File.prototype, "detectResurrectionAfterDelay").andCallFake -> @detectResurrection()
   spyOn(TextEditor.prototype, "shouldPromptToSave").andReturn false
 
@@ -204,10 +208,15 @@ jasmine.attachToDOM = (element) ->
 
 deprecationsSnapshot = null
 jasmine.snapshotDeprecations = ->
-  deprecationsSnapshot = Grim.getDeprecations() # suppress deprecations!!
+  deprecationsSnapshot = _.clone(Grim.deprecations)
 
 jasmine.restoreDeprecationsSnapshot = ->
-  Grim.grimDeprecations = deprecationsSnapshot
+  Grim.deprecations = deprecationsSnapshot
+
+jasmine.useRealClock = ->
+  jasmine.unspy(window, 'setTimeout')
+  jasmine.unspy(window, 'clearTimeout')
+  jasmine.unspy(_._, 'now')
 
 addCustomMatchers = (spec) ->
   spec.addMatchers
@@ -294,13 +303,13 @@ window.waitsForPromise = (args...) ->
   window.waitsFor timeout, (moveOn) ->
     promise = fn()
     if shouldReject
-      promise.fail(moveOn)
-      promise.done ->
+      promise.catch(moveOn)
+      promise.then ->
         jasmine.getEnv().currentSpec.fail("Expected promise to be rejected, but it was resolved")
         moveOn()
     else
-      promise.done(moveOn)
-      promise.fail (error) ->
+      promise.then(moveOn)
+      promise.catch (error) ->
         jasmine.getEnv().currentSpec.fail("Expected promise to be resolved, but it was rejected with #{jasmine.pp(error)}")
         moveOn()
 

spec/squirrel-update-spec.coffee

@@ -25,6 +25,16 @@ describe "Windows squirrel updates", ->
       else
         originalSpawn('ls')
 
+  it "ignores errors spawning Squirrel", ->
+    jasmine.unspy(ChildProcess, 'spawn')
+    spyOn(ChildProcess, 'spawn').andCallFake -> throw new Error("EBUSY")
+
+    app = quit: jasmine.createSpy('quit')
+    expect(SquirrelUpdate.handleStartupEvent(app, '--squirrel-install')).toBe true
+
+    waitsFor ->
+      app.quit.callCount is 1
+
   it "quits the app on all squirrel events", ->
     app = quit: jasmine.createSpy('quit')
 

spec/style-manager-spec.coffee

@@ -53,14 +53,16 @@ describe "StyleManager", ->
         expect(addEvents[0].getAttribute('source-path')).toBe '/foo/bar'
         expect(addEvents[0].textContent).toBe "a {color: yellow;}"
 
-    describe "when a group parameter is specified", ->
-      it "inserts the stylesheet at the end of any existing stylesheets for the same group", ->
-        manager.addStyleSheet("a {color: red}", group: 'a')
-        manager.addStyleSheet("a {color: blue}", group: 'b')
-        manager.addStyleSheet("a {color: green}", group: 'a')
+    describe "when a priority parameter is specified", ->
+      it "inserts the style sheet based on the priority", ->
+        manager.addStyleSheet("a {color: red}", priority: 1)
+        manager.addStyleSheet("a {color: blue}", priority: 0)
+        manager.addStyleSheet("a {color: green}", priority: 2)
+        manager.addStyleSheet("a {color: yellow}", priority: 1)
 
         expect(manager.getStyleElements().map (elt) -> elt.textContent).toEqual [
-          "a {color: red}"
-          "a {color: green}"
           "a {color: blue}"
+          "a {color: red}"
+          "a {color: yellow}"
+          "a {color: green}"
         ]

spec/styles-element-spec.coffee

@@ -32,16 +32,18 @@ describe "StylesElement", ->
     expect(element.children[initialChildCount].textContent).toBe "a {color: blue;}"
     expect(removedStyleElements).toEqual [addedStyleElements[0]]
 
-  it "orders style elements by group", ->
+  it "orders style elements by priority", ->
     initialChildCount = element.children.length
 
-    atom.styles.addStyleSheet("a {color: red}", group: 'a')
-    atom.styles.addStyleSheet("a {color: blue}", group: 'b')
-    atom.styles.addStyleSheet("a {color: green}", group: 'a')
+    atom.styles.addStyleSheet("a {color: red}", priority: 1)
+    atom.styles.addStyleSheet("a {color: blue}", priority: 0)
+    atom.styles.addStyleSheet("a {color: green}", priority: 2)
+    atom.styles.addStyleSheet("a {color: yellow}", priority: 1)
 
-    expect(element.children[initialChildCount].textContent).toBe "a {color: red}"
-    expect(element.children[initialChildCount + 1].textContent).toBe "a {color: green}"
-    expect(element.children[initialChildCount + 2].textContent).toBe "a {color: blue}"
+    expect(element.children[initialChildCount].textContent).toBe "a {color: blue}"
+    expect(element.children[initialChildCount + 1].textContent).toBe "a {color: red}"
+    expect(element.children[initialChildCount + 2].textContent).toBe "a {color: yellow}"
+    expect(element.children[initialChildCount + 3].textContent).toBe "a {color: green}"
 
   it "updates existing style nodes when style elements are updated", ->
     initialChildCount = element.children.length

spec/task-spec.coffee

@@ -20,3 +20,26 @@ describe "Task", ->
         expect(handlerResult).toBe 'hello'
         expect(childProcess.kill).toHaveBeenCalled()
         expect(processErrored).toBe false
+
+  it "calls listeners registered with ::on when events are emitted in the task", ->
+    task = new Task(require.resolve('./fixtures/task-spec-handler'))
+
+    eventSpy = jasmine.createSpy('eventSpy')
+    task.on("some-event", eventSpy)
+
+    waitsFor (done) -> task.start(done)
+
+    runs ->
+      expect(eventSpy).toHaveBeenCalledWith(1, 2, 3)
+
+  it "unregisters listeners when the Disposable returned by ::on is disposed", ->
+    task = new Task(require.resolve('./fixtures/task-spec-handler'))
+
+    eventSpy = jasmine.createSpy('eventSpy')
+    disposable = task.on("some-event", eventSpy)
+    disposable.dispose()
+
+    waitsFor (done) -> task.start(done)
+
+    runs ->
+      expect(eventSpy).not.toHaveBeenCalled()

spec/text-editor-component-spec.coffee

@@ -429,7 +429,7 @@ describe "TextEditorComponent", ->
       it "excludes the null byte from character measurement", ->
         editor.setText("a\0b")
         nextAnimationFrame()
-        expect(editor.pixelPositionForScreenPosition([0, Infinity]).left).toEqual 2 * charWidth
+        expect(wrapperNode.pixelPositionForScreenPosition([0, Infinity]).left).toEqual 2 * charWidth
 
     describe "when there is a fold", ->
       it "renders a fold marker on the folded line", ->
@@ -552,14 +552,29 @@ describe "TextEditorComponent", ->
       nextAnimationFrame()
       expect(lineNumbersNode.style.backgroundColor).toBe 'rgb(255, 0, 0)'
 
-    describe "when the editor.showLineNumbers config is false", ->
-      it "doesn't render any line numbers", ->
-        expect(component.refs.gutter).toBeDefined()
-        atom.config.set("editor.showLineNumbers", false)
-        expect(component.refs.gutter).not.toBeDefined()
-        atom.config.set("editor.showLineNumbers", true)
-        expect(component.refs.gutter).toBeDefined()
-        expect(component.lineNumberNodeForScreenRow(3)).toBeDefined()
+    it "hides or shows the gutter based on the '::isGutterVisible' property on the model and the global 'editor.showLineNumbers' config setting", ->
+      expect(component.refs.gutter?).toBe true
+
+      editor.setGutterVisible(false)
+      nextAnimationFrame()
+
+      expect(component.refs.gutter?).toBe false
+
+      atom.config.set("editor.showLineNumbers", false)
+      expect(nextAnimationFrame).toBe noAnimationFrame
+
+      expect(component.refs.gutter?).toBe false
+
+      editor.setGutterVisible(true)
+      expect(nextAnimationFrame).toBe noAnimationFrame
+
+      expect(component.refs.gutter?).toBe false
+
+      atom.config.set("editor.showLineNumbers", true)
+      nextAnimationFrame()
+
+      expect(component.refs.gutter?).toBe true
+      expect(component.lineNumberNodeForScreenRow(3)?).toBe true
 
     describe "fold decorations", ->
       describe "rendering fold decorations", ->
@@ -755,7 +770,6 @@ describe "TextEditorComponent", ->
       expect(cursorNode.offsetWidth).toBe charWidth
 
     it "blinks cursors when they aren't moving", ->
-      spyOn(_._, 'now').andCallFake -> window.now # Ensure _.debounce is based on our fake spec timeline
       cursorsNode = componentNode.querySelector('.cursors')
 
       expect(cursorsNode.classList.contains('blink-off')).toBe false
@@ -802,7 +816,7 @@ describe "TextEditorComponent", ->
       nextAnimationFrame()
       cursorNode = componentNode.querySelector('.cursor')
 
-      {left} = editor.pixelPositionForScreenPosition([1, 10])
+      {left} = wrapperNode.pixelPositionForScreenPosition([1, 10])
       expect(cursorNode.style['-webkit-transform']).toBe "translate(#{left}px, #{editor.getLineHeightInPixels()}px)"
 
   describe "selection rendering", ->
@@ -896,7 +910,7 @@ describe "TextEditorComponent", ->
       nextAnimationFrame()
       selectionNode = componentNode.querySelector('.region')
       expect(selectionNode.offsetTop).toBe editor.getLineHeightInPixels()
-      expect(selectionNode.offsetLeft).toBe editor.pixelPositionForScreenPosition([1, 6]).left
+      expect(selectionNode.offsetLeft).toBe wrapperNode.pixelPositionForScreenPosition([1, 6]).left
 
     it "will flash the selection when flash:true is passed to editor::setSelectedBufferRange", ->
       editor.setSelectedBufferRange([[1, 6], [1, 10]], flash: true)
@@ -917,7 +931,7 @@ describe "TextEditorComponent", ->
 
     beforeEach ->
       marker = editor.displayBuffer.markBufferRange([[2, 13], [3, 15]], invalidate: 'inside')
-      decorationParams = {type: ['gutter', 'line'], class: 'a'}
+      decorationParams = {type: ['line-number', 'line'], class: 'a'}
       decoration = editor.decorateMarker(marker, decorationParams)
       nextAnimationFrame()
 
@@ -932,7 +946,7 @@ describe "TextEditorComponent", ->
 
       # Add decorations that are out of range
       marker2 = editor.displayBuffer.markBufferRange([[9, 0], [9, 0]])
-      editor.decorateMarker(marker2, type: ['gutter', 'line'], class: 'b')
+      editor.decorateMarker(marker2, type: ['line-number', 'line'], class: 'b')
       nextAnimationFrame()
 
       # Scroll decorations into view
@@ -956,7 +970,7 @@ describe "TextEditorComponent", ->
 
       marker.destroy()
       marker = editor.markBufferRange([[0, 0], [0, 2]])
-      editor.decorateMarker(marker, type: ['gutter', 'line'], class: 'b')
+      editor.decorateMarker(marker, type: ['line-number', 'line'], class: 'b')
       nextAnimationFrame()
       expect(lineNumberHasClass(0, 'b')).toBe true
       expect(lineNumberHasClass(1, 'b')).toBe false
@@ -1025,7 +1039,7 @@ describe "TextEditorComponent", ->
 
     describe "when the decoration's 'onlyHead' property is true", ->
       it "only applies the decoration's class to lines containing the marker's head", ->
-        editor.decorateMarker(marker, type: ['gutter', 'line'], class: 'only-head', onlyHead: true)
+        editor.decorateMarker(marker, type: ['line-number', 'line'], class: 'only-head', onlyHead: true)
         nextAnimationFrame()
         expect(lineAndLineNumberHaveClass(1, 'only-head')).toBe false
         expect(lineAndLineNumberHaveClass(2, 'only-head')).toBe false
@@ -1034,7 +1048,7 @@ describe "TextEditorComponent", ->
 
     describe "when the decoration's 'onlyEmpty' property is true", ->
       it "only applies the decoration when its marker is empty", ->
-        editor.decorateMarker(marker, type: ['gutter', 'line'], class: 'only-empty', onlyEmpty: true)
+        editor.decorateMarker(marker, type: ['line-number', 'line'], class: 'only-empty', onlyEmpty: true)
         nextAnimationFrame()
         expect(lineAndLineNumberHaveClass(2, 'only-empty')).toBe false
         expect(lineAndLineNumberHaveClass(3, 'only-empty')).toBe false
@@ -1046,7 +1060,7 @@ describe "TextEditorComponent", ->
 
     describe "when the decoration's 'onlyNonEmpty' property is true", ->
       it "only applies the decoration when its marker is non-empty", ->
-        editor.decorateMarker(marker, type: ['gutter', 'line'], class: 'only-non-empty', onlyNonEmpty: true)
+        editor.decorateMarker(marker, type: ['line-number', 'line'], class: 'only-non-empty', onlyNonEmpty: true)
         nextAnimationFrame()
         expect(lineAndLineNumberHaveClass(2, 'only-non-empty')).toBe true
         expect(lineAndLineNumberHaveClass(3, 'only-non-empty')).toBe true
@@ -1231,7 +1245,7 @@ describe "TextEditorComponent", ->
         decoration = editor.decorateMarker(marker, {type: 'overlay', item})
         nextAnimationFrame()
 
-        position = editor.pixelPositionForBufferPosition([2, 5])
+        position = wrapperNode.pixelPositionForBufferPosition([2, 5])
 
         overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
         expect(overlay.style.left).toBe position.left + 'px'
@@ -1241,7 +1255,7 @@ describe "TextEditorComponent", ->
         editor.moveRight()
         nextAnimationFrame()
 
-        position = editor.pixelPositionForBufferPosition([2, 7])
+        position = wrapperNode.pixelPositionForBufferPosition([2, 7])
 
         expect(overlay.style.left).toBe position.left + 'px'
         expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
@@ -1252,7 +1266,7 @@ describe "TextEditorComponent", ->
         decoration = editor.decorateMarker(marker, {type: 'overlay', item})
         nextAnimationFrame()
 
-        position = editor.pixelPositionForBufferPosition([2, 10])
+        position = wrapperNode.pixelPositionForBufferPosition([2, 10])
 
         overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
         expect(overlay.style.left).toBe position.left + 'px'
@@ -1263,7 +1277,7 @@ describe "TextEditorComponent", ->
         decoration = editor.decorateMarker(marker, {type: 'overlay', item})
         nextAnimationFrame()
 
-        position = editor.pixelPositionForBufferPosition([2, 5])
+        position = wrapperNode.pixelPositionForBufferPosition([2, 5])
 
         overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
         expect(overlay.style.left).toBe position.left + 'px'
@@ -1274,7 +1288,7 @@ describe "TextEditorComponent", ->
         decoration = editor.decorateMarker(marker, {type: 'overlay', position: 'tail', item})
         nextAnimationFrame()
 
-        position = editor.pixelPositionForBufferPosition([2, 5])
+        position = wrapperNode.pixelPositionForBufferPosition([2, 5])
 
         overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
         expect(overlay.style.left).toBe position.left + 'px'
@@ -1304,7 +1318,7 @@ describe "TextEditorComponent", ->
         decoration = editor.decorateMarker(marker, {type: 'overlay', item})
         nextAnimationFrame()
 
-        position = editor.pixelPositionForBufferPosition([0, 26])
+        position = wrapperNode.pixelPositionForBufferPosition([0, 26])
 
         overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
         expect(overlay.style.left).toBe position.left + 'px'
@@ -1313,7 +1327,7 @@ describe "TextEditorComponent", ->
         editor.insertText('a')
         nextAnimationFrame()
 
-        position = editor.pixelPositionForBufferPosition([0, 27])
+        position = wrapperNode.pixelPositionForBufferPosition([0, 27])
 
         expect(overlay.style.left).toBe position.left - itemWidth + 'px'
         expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
@@ -1323,7 +1337,7 @@ describe "TextEditorComponent", ->
         decoration = editor.decorateMarker(marker, {type: 'overlay', item})
         nextAnimationFrame()
 
-        position = editor.pixelPositionForBufferPosition([4, 0])
+        position = wrapperNode.pixelPositionForBufferPosition([4, 0])
 
         overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
         expect(overlay.style.left).toBe position.left + 'px'
@@ -1332,7 +1346,7 @@ describe "TextEditorComponent", ->
         editor.insertNewline()
         nextAnimationFrame()
 
-        position = editor.pixelPositionForBufferPosition([5, 0])
+        position = wrapperNode.pixelPositionForBufferPosition([5, 0])
 
         expect(overlay.style.left).toBe position.left + 'px'
         expect(overlay.style.top).toBe position.top - itemHeight + 'px'
@@ -1354,7 +1368,7 @@ describe "TextEditorComponent", ->
           decoration = editor.decorateMarker(marker, {type: 'overlay', item})
           nextAnimationFrame()
 
-          position = editor.pixelPositionForBufferPosition([0, 2])
+          position = wrapperNode.pixelPositionForBufferPosition([0, 2])
 
           overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
           expect(overlay.style.left).toBe position.left + 'px'
@@ -1363,7 +1377,7 @@ describe "TextEditorComponent", ->
           editor.insertText('a')
           nextAnimationFrame()
 
-          position = editor.pixelPositionForBufferPosition([0, 3])
+          position = wrapperNode.pixelPositionForBufferPosition([0, 3])
 
           expect(overlay.style.left).toBe position.left + 'px'
           expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
@@ -1373,7 +1387,7 @@ describe "TextEditorComponent", ->
           decoration = editor.decorateMarker(marker, {type: 'overlay', item})
           nextAnimationFrame()
 
-          position = editor.pixelPositionForBufferPosition([1, 0])
+          position = wrapperNode.pixelPositionForBufferPosition([1, 0])
 
           overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
           expect(overlay.style.left).toBe position.left + 'px'
@@ -1382,7 +1396,7 @@ describe "TextEditorComponent", ->
           editor.insertNewline()
           nextAnimationFrame()
 
-          position = editor.pixelPositionForBufferPosition([2, 0])
+          position = wrapperNode.pixelPositionForBufferPosition([2, 0])
 
           expect(overlay.style.left).toBe position.left + 'px'
           expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
@@ -1395,7 +1409,7 @@ describe "TextEditorComponent", ->
           decoration = editor.decorateMarker(marker, {type: 'overlay', item})
           nextAnimationFrame()
 
-          position = editor.pixelPositionForBufferPosition([0, 28])
+          position = wrapperNode.pixelPositionForBufferPosition([0, 28])
 
           overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
           expect(overlay.style.left).toBe position.left + 'px'
@@ -1404,7 +1418,7 @@ describe "TextEditorComponent", ->
           editor.insertText('a')
           nextAnimationFrame()
 
-          position = editor.pixelPositionForBufferPosition([0, 29])
+          position = wrapperNode.pixelPositionForBufferPosition([0, 29])
 
           expect(overlay.style.left).toBe position.left - itemWidth + 'px'
           expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
@@ -1415,7 +1429,7 @@ describe "TextEditorComponent", ->
           decoration = editor.decorateMarker(marker, {type: 'overlay', item})
           nextAnimationFrame()
 
-          position = editor.pixelPositionForBufferPosition([6, 0])
+          position = wrapperNode.pixelPositionForBufferPosition([6, 0])
 
           overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
           expect(overlay.style.left).toBe position.left + 'px'
@@ -1424,7 +1438,7 @@ describe "TextEditorComponent", ->
           editor.insertNewline()
           nextAnimationFrame()
 
-          position = editor.pixelPositionForBufferPosition([7, 0])
+          position = wrapperNode.pixelPositionForBufferPosition([7, 0])
 
           expect(overlay.style.left).toBe position.left + 'px'
           expect(overlay.style.top).toBe position.top - itemHeight + 'px'
@@ -2048,8 +2062,6 @@ describe "TextEditorComponent", ->
         expect(component.mouseWheelScreenRow).toBe null
 
       it "clears the mouseWheelScreenRow after a delay even if the event does not cause scrolling", ->
-        spyOn(_._, 'now').andCallFake -> window.now # Ensure _.debounce is based on our fake spec timeline
-
         expect(editor.getScrollTop()).toBe 0
 
         lineNode = componentNode.querySelector('.line')
@@ -2505,7 +2517,8 @@ describe "TextEditorComponent", ->
 
   describe "when the 'mini' property is true", ->
     beforeEach ->
-      component.setProps(mini: true)
+      editor.setMini(true)
+      nextAnimationFrame()
 
     it "does not render the gutter", ->
       expect(componentNode.querySelector('.gutter')).toBeNull()
@@ -2593,9 +2606,9 @@ describe "TextEditorComponent", ->
 
     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
+        atom.config.set 'editor.softWrap', true, scopeSelector: '.source.coffee'
+        atom.config.set 'editor.preferredLineLength', 17, scopeSelector: '.source.coffee'
+        atom.config.set 'editor.softWrapAtPreferredLineLength', true, scopeSelector: '.source.coffee'
 
         editor.setEditorWidthInChars(20)
         coffeeEditor.setEditorWidthInChars(20)
@@ -2605,18 +2618,18 @@ describe "TextEditorComponent", ->
         expect(coffeeEditor.lineTextForScreenRow(3)).toEqual '    return items '
 
       it 'updates the wrapped lines when editor.preferredLineLength changes', ->
-        atom.config.set '.source.coffee', 'editor.preferredLineLength', 20
+        atom.config.set 'editor.preferredLineLength', 20, scopeSelector: '.source.coffee'
         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
+        atom.config.set 'editor.softWrapAtPreferredLineLength', false, scopeSelector: '.source.coffee'
         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
+        atom.config.set 'editor.softWrap', false, scopeSelector: '.source.coffee'
         expect(coffeeEditor.lineTextForScreenRow(2)).toEqual '    return items if items.length <= 1'
 
-        atom.config.set '.source.coffee', 'editor.softWrap', true
+        atom.config.set 'editor.softWrap', true, scopeSelector: '.source.coffee'
         expect(coffeeEditor.lineTextForScreenRow(3)).toEqual '    return items '
 
       it 'updates the wrapped lines when the grammar changes', ->
@@ -2644,11 +2657,11 @@ describe "TextEditorComponent", ->
           tab: 'F'
           cr: 'E'
 
-        atom.config.set '.source.js', 'editor.showInvisibles', true
-        atom.config.set '.source.js', 'editor.invisibles', jsInvisibles
+        atom.config.set 'editor.showInvisibles', true, scopeSelector: '.source.js'
+        atom.config.set 'editor.invisibles', jsInvisibles, scopeSelector: '.source.js'
 
-        atom.config.set '.source.coffee', 'editor.showInvisibles', false
-        atom.config.set '.source.coffee', 'editor.invisibles', coffeeInvisibles
+        atom.config.set 'editor.showInvisibles', false, scopeSelector: '.source.coffee'
+        atom.config.set 'editor.invisibles', coffeeInvisibles, scopeSelector: '.source.coffee'
 
         editor.setText " a line with tabs\tand spaces \n"
         nextAnimationFrame()
@@ -2664,7 +2677,7 @@ describe "TextEditorComponent", ->
       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
+        atom.config.set 'editor.showInvisibles', true, scopeSelector: '.source.coffee'
         nextAnimationFrame()
         expect(component.lineNodeForScreenRow(0).textContent).toBe "#{coffeeInvisibles.space}a line with tabs#{coffeeInvisibles.tab}and spaces#{coffeeInvisibles.space}#{coffeeInvisibles.eol}"
 
@@ -2673,7 +2686,7 @@ describe "TextEditorComponent", ->
           space: 'E'
           tab: 'W'
           cr: 'I'
-        atom.config.set '.source.coffee', 'editor.invisibles', newInvisibles
+        atom.config.set 'editor.invisibles', newInvisibles, scopeSelector: '.source.coffee'
         nextAnimationFrame()
         expect(component.lineNodeForScreenRow(0).textContent).toBe "#{newInvisibles.space}a line with tabs#{newInvisibles.tab}and spaces#{newInvisibles.space}#{newInvisibles.eol}"
 
@@ -2683,8 +2696,8 @@ describe "TextEditorComponent", ->
 
     describe 'editor.showIndentGuide', ->
       beforeEach ->
-        atom.config.set '.source.js', 'editor.showIndentGuide', true
-        atom.config.set '.source.coffee', 'editor.showIndentGuide', false
+        atom.config.set 'editor.showIndentGuide', true, scopeSelector: '.source.js'
+        atom.config.set 'editor.showIndentGuide', false, scopeSelector: '.source.coffee'
 
       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))
@@ -2705,7 +2718,7 @@ describe "TextEditorComponent", ->
         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
+        atom.config.set 'editor.showIndentGuide', false, scopeSelector: '.source.js'
 
         line1LeafNodes = getLeafNodes(component.lineNodeForScreenRow(1))
         expect(line1LeafNodes[0].textContent).toBe '  '
@@ -2754,14 +2767,14 @@ describe "TextEditorComponent", ->
     event
 
   clientCoordinatesForScreenPosition = (screenPosition) ->
-    positionOffset = editor.pixelPositionForScreenPosition(screenPosition)
+    positionOffset = wrapperNode.pixelPositionForScreenPosition(screenPosition)
     scrollViewClientRect = componentNode.querySelector('.scroll-view').getBoundingClientRect()
     clientX = scrollViewClientRect.left + positionOffset.left - editor.getScrollLeft()
     clientY = scrollViewClientRect.top + positionOffset.top - editor.getScrollTop()
     {clientX, clientY}
 
   clientCoordinatesForScreenRowInGutter = (screenRow) ->
-    positionOffset = editor.pixelPositionForScreenPosition([screenRow, 1])
+    positionOffset = wrapperNode.pixelPositionForScreenPosition([screenRow, 1])
     gutterClientRect = componentNode.querySelector('.gutter').getBoundingClientRect()
     clientX = gutterClientRect.left + positionOffset.left - editor.getScrollLeft()
     clientY = gutterClientRect.top + positionOffset.top - editor.getScrollTop()

spec/text-editor-element-spec.coffee

@@ -10,16 +10,21 @@ describe "TextEditorElement", ->
     jasmineContent = document.body.querySelector('#jasmine-content')
 
   describe "instantiation", ->
-    it "honors the mini attribute", ->
+    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", ->
+    it "honors the 'placeholder-text' attribute", ->
       jasmineContent.innerHTML = "<atom-text-editor placeholder-text='testing'>"
       element = jasmineContent.firstChild
       expect(element.getModel().getPlaceholderText()).toBe 'testing'
 
+    it "honors the 'gutter-hidden' attribute", ->
+      jasmineContent.innerHTML = "<atom-text-editor gutter-hidden>"
+      element = jasmineContent.firstChild
+      expect(element.getModel().isGutterVisible()).toBe false
+
     it "honors the text content", ->
       jasmineContent.innerHTML = "<atom-text-editor>testing</atom-text-editor>"
       element = jasmineContent.firstChild
@@ -42,9 +47,12 @@ describe "TextEditorElement", ->
 
         component = element.component
         expect(component.isMounted()).toBe true
-        element.getModel().destroy()
+        element.remove()
         expect(component.isMounted()).toBe false
 
+        jasmine.attachToDOM(element)
+        expect(element.component.isMounted()).toBe true
+
     describe "when the editor.useShadowDOM config option is false", ->
       it "mounts the react component and unmounts when removed from the dom", ->
         atom.config.set('editor.useShadowDOM', false)
@@ -95,6 +103,22 @@ describe "TextEditorElement", ->
         document.body.focus()
         expect(blurCalled).toBe true
 
+    describe "when focused while a parent node is being attached to the DOM", ->
+      class ElementThatFocusesChild extends HTMLDivElement
+        attachedCallback: ->
+          @firstChild.focus()
+
+      document.registerElement("element-that-focuses-child",
+        prototype: ElementThatFocusesChild.prototype
+      )
+
+      it "proxies the focus event to the hidden input", ->
+        element = new TextEditorElement
+        parentElement = document.createElement("element-that-focuses-child")
+        parentElement.appendChild(element)
+        jasmineContent.appendChild(parentElement)
+        expect(element.shadowRoot.activeElement).toBe element.shadowRoot.querySelector('input')
+
   describe "when the themes finish loading", ->
     [themeReloadCallback, initialThemeLoadComplete, element] = []
 
@@ -104,7 +128,7 @@ describe "TextEditorElement", ->
 
       spyOn(atom.themes, 'isInitialLoadComplete').andCallFake ->
         initialThemeLoadComplete
-      spyOn(atom.themes, 'onDidReloadAll').andCallFake (fn) ->
+      spyOn(atom.themes, 'onDidChangeActiveThemes').andCallFake (fn) ->
         themeReloadCallback = fn
 
       atom.config.set("editor.useShadowDOM", false)

spec/text-editor-spec.coffee

@@ -62,7 +62,6 @@ describe "TextEditor", ->
         atom.workspace.open('sample.less', initialLine: 5).then (o) -> editor = o
 
       runs ->
-        buffer = editor.buffer
         expect(editor.getLastCursor().getBufferPosition().row).toEqual 5
         expect(editor.getLastCursor().getBufferPosition().column).toEqual 0
 
@@ -74,10 +73,37 @@ describe "TextEditor", ->
         atom.workspace.open('sample.less', initialColumn: 8).then (o) -> editor = o
 
       runs ->
-        buffer = editor.buffer
         expect(editor.getLastCursor().getBufferPosition().row).toEqual 0
         expect(editor.getLastCursor().getBufferPosition().column).toEqual 8
 
+  describe "when the editor is reopened with an initialLine option", ->
+    it "positions the cursor on the specified line", ->
+      editor = null
+
+      waitsForPromise ->
+        atom.workspace.open('sample.less', initialLine: 5).then (o) -> editor = o
+
+      waitsForPromise ->
+        atom.workspace.open('sample.less', initialLine: 4).then (o) -> editor = o
+
+      runs ->
+        expect(editor.getLastCursor().getBufferPosition().row).toEqual 4
+        expect(editor.getLastCursor().getBufferPosition().column).toEqual 0
+
+  describe "when the editor is reopened with an initialColumn option", ->
+    it "positions the cursor on the specified column", ->
+      editor = null
+
+      waitsForPromise ->
+        atom.workspace.open('sample.less', initialColumn: 8).then (o) -> editor = o
+
+      waitsForPromise ->
+        atom.workspace.open('sample.less', initialColumn: 7).then (o) -> editor = o
+
+      runs ->
+        expect(editor.getLastCursor().getBufferPosition().row).toEqual 0
+        expect(editor.getLastCursor().getBufferPosition().column).toEqual 7
+
   describe ".copy()", ->
     it "returns a different edit session with the same initial state", ->
       editor.setSelectedBufferRange([[1, 2], [3, 4]])
@@ -129,6 +155,25 @@ describe "TextEditor", ->
         expect(editor2.getSoftTabs()).toBe true
         expect(editor2.getEncoding()).toBe 'macroman'
 
+    it "uses scoped `core.fileEncoding` values", ->
+      editor1 = null
+      editor2 = null
+
+      atom.config.set('core.fileEncoding', 'utf16le')
+      atom.config.set('core.fileEncoding', 'macroman', scopeSelector: '.js')
+
+      waitsForPromise ->
+        atom.workspace.open('a').then (o) -> editor1 = o
+
+      runs ->
+        expect(editor1.getEncoding()).toBe 'utf16le'
+
+      waitsForPromise ->
+        atom.workspace.open('test.js').then (o) -> editor2 = o
+
+      runs ->
+        expect(editor2.getEncoding()).toBe 'macroman'
+
   describe "title", ->
     describe ".getTitle()", ->
       it "uses the basename of the buffer's path as its title, or 'untitled' if the path is undefined", ->
@@ -918,6 +963,15 @@ describe "TextEditor", ->
         editor.undo()
         expect(editor.getScrollTop()).toBe 0
 
+    describe '.logCursorScope()', ->
+      beforeEach ->
+        spyOn(atom.notifications, 'addInfo')
+
+      it 'opens a notification', ->
+        editor.logCursorScope()
+
+        expect(atom.notifications.addInfo).toHaveBeenCalled()
+
   describe "selection", ->
     selection = null
 
@@ -1327,7 +1381,7 @@ describe "TextEditor", ->
           coffeeEditor.selectWordsContainingCursors()
           expect(coffeeEditor.getSelectedBufferRange()).toEqual [[0, 6], [0, 15]]
 
-          atom.config.set '.source.coffee', 'editor.nonWordCharacters', 'qusort'
+          atom.config.set 'editor.nonWordCharacters', 'qusort', scopeSelector: '.source.coffee'
 
           coffeeEditor.setCursorBufferPosition [0, 9]
           coffeeEditor.selectWordsContainingCursors()
@@ -2595,12 +2649,20 @@ describe "TextEditor", ->
             atom.config.set("editor.autoIndentOnPaste", true)
 
           describe "when only whitespace precedes the cursor", ->
-            it "auto-indents the lines spanned by the pasted text", ->
-              atom.clipboard.write("console.log(x);\nconsole.log(y);\n")
-              editor.setCursorBufferPosition([5, 2])
+            it "auto-indents the lines spanned by the pasted text, based on the first pasted line", ->
+              expect(editor.indentationForBufferRow(5)).toBe(3)
+
+              atom.clipboard.write("a(x);\n  b(x);\n    c(x);\n", indentBasis: 0)
+              editor.setCursorBufferPosition([5, 0])
               editor.pasteText()
-              expect(editor.lineTextForBufferRow(5)).toBe("      console.log(x);")
-              expect(editor.lineTextForBufferRow(6)).toBe("      console.log(y);")
+
+              # Adjust the indentation of the pasted block
+              expect(editor.indentationForBufferRow(5)).toBe(3)
+              expect(editor.indentationForBufferRow(6)).toBe(4)
+              expect(editor.indentationForBufferRow(7)).toBe(5)
+
+              # Preserve the indentation of the next row
+              expect(editor.indentationForBufferRow(8)).toBe(3)
 
           describe "when non-whitespace characters precede the cursor", ->
             it "does not auto-indent the first line being pasted", ->
@@ -2697,9 +2759,9 @@ describe "TextEditor", ->
               editor.setSelectedBufferRange([[1, 2], [1, Infinity]])
               editor.pasteText()
               expect(editor.lineTextForBufferRow(1)).toBe("  if (items.length <= 1) return items;")
-              expect(editor.lineTextForBufferRow(2)).toBe("  ")
+              expect(editor.lineTextForBufferRow(2)).toBe("")
               expect(editor.lineTextForBufferRow(3)).toBe("    if (items.length <= 1) return items;")
-              expect(editor.getCursorBufferPosition()).toEqual([2, 2])
+              expect(editor.getCursorBufferPosition()).toEqual([2, 0])
 
           describe "when there is no selection", ->
             it "pastes the line above the cursor and retains the cursor's column", ->
@@ -3276,7 +3338,7 @@ describe "TextEditor", ->
         atom.packages.unloadPackages()
 
       it 'returns correct values based on the scope of the set grammars', ->
-        atom.config.set '.source.coffee', 'editor.tabLength', 6
+        atom.config.set 'editor.tabLength', 6, scopeSelector: '.source.coffee'
 
         expect(editor.getTabLength()).toBe 2
         expect(coffeeEditor.getTabLength()).toBe 6
@@ -3298,12 +3360,12 @@ describe "TextEditor", ->
         expect(editor.getTabLength()).toBe 2
         expect(editor.tokenizedLineForScreenRow(5).tokens[0].firstNonWhitespaceIndex).toBe 2
 
-        atom.config.set '.source.js', 'editor.tabLength', 6
+        atom.config.set 'editor.tabLength', 6, scopeSelector: '.source.js'
         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
+        atom.config.set 'editor.tabLength', 6, scopeSelector: '.source.coffee'
 
         expect(editor.getTabLength()).toBe 2
         expect(editor.tokenizedLineForScreenRow(5).tokens[0].firstNonWhitespaceIndex).toBe 2
@@ -3473,8 +3535,8 @@ describe "TextEditor", ->
           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)
+          atom.config.set('editor.autoIndent', true, scopeSelector: '.source.js')
+          atom.config.set('editor.autoIndent', false, scopeSelector: '.source.coffee')
 
       afterEach: ->
         atom.packages.deactivatePackages()
@@ -3766,8 +3828,12 @@ describe "TextEditor", ->
     it "updates the grammar based on grammar overrides", ->
       expect(editor.getGrammar().name).toBe 'JavaScript'
       atom.grammars.setGrammarOverrideForPath(editor.getPath(), 'source.coffee')
+      callback = jasmine.createSpy('callback')
+      editor.onDidChangeGrammar(callback)
       editor.reloadGrammar()
       expect(editor.getGrammar().name).toBe 'CoffeeScript'
+      expect(callback.callCount).toBe 1
+      expect(callback.argsForCall[0][0]).toBe atom.grammars.grammarForScopeName('source.coffee')
 
   describe "when the editor's grammar has an injection selector", ->
     beforeEach ->

spec/theme-manager-spec.coffee

@@ -73,65 +73,90 @@ describe "ThemeManager", ->
 
   describe "when the core.themes config value changes", ->
     it "add/removes stylesheets to reflect the new config value", ->
-      themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
+      themeManager.onDidChangeActiveThemes didChangeActiveThemesHandler = jasmine.createSpy()
       spyOn(atom.styles, 'getUserStyleSheetPath').andCallFake -> null
 
       waitsForPromise ->
         themeManager.activateThemes()
 
       runs ->
-        reloadHandler.reset()
+        didChangeActiveThemesHandler.reset()
         atom.config.set('core.themes', [])
 
       waitsFor ->
-        reloadHandler.callCount == 1
+        didChangeActiveThemesHandler.callCount == 1
 
       runs ->
-        reloadHandler.reset()
+        didChangeActiveThemesHandler.reset()
         expect($('style.theme')).toHaveLength 0
         atom.config.set('core.themes', ['atom-dark-ui'])
 
       waitsFor ->
-        reloadHandler.callCount == 1
+        didChangeActiveThemesHandler.callCount == 1
 
       runs ->
-        reloadHandler.reset()
-        expect($('style[group=theme]')).toHaveLength 2
-        expect($('style[group=theme]:eq(0)').attr('source-path')).toMatch /atom-dark-ui/
+        didChangeActiveThemesHandler.reset()
+        expect($('style[priority=1]')).toHaveLength 2
+        expect($('style[priority=1]:eq(0)').attr('source-path')).toMatch /atom-dark-ui/
         atom.config.set('core.themes', ['atom-light-ui', 'atom-dark-ui'])
 
       waitsFor ->
-        reloadHandler.callCount == 1
+        didChangeActiveThemesHandler.callCount == 1
 
       runs ->
-        reloadHandler.reset()
-        expect($('style[group=theme]')).toHaveLength 2
-        expect($('style[group=theme]:eq(0)').attr('source-path')).toMatch /atom-dark-ui/
-        expect($('style[group=theme]:eq(1)').attr('source-path')).toMatch /atom-light-ui/
+        didChangeActiveThemesHandler.reset()
+        expect($('style[priority=1]')).toHaveLength 2
+        expect($('style[priority=1]:eq(0)').attr('source-path')).toMatch /atom-dark-ui/
+        expect($('style[priority=1]:eq(1)').attr('source-path')).toMatch /atom-light-ui/
         atom.config.set('core.themes', [])
 
       waitsFor ->
-        reloadHandler.callCount == 1
+        didChangeActiveThemesHandler.callCount == 1
 
       runs ->
-        reloadHandler.reset()
-        expect($('style[group=theme]')).toHaveLength 2
+        didChangeActiveThemesHandler.reset()
+        expect($('style[priority=1]')).toHaveLength 2
         # atom-dark-ui has an directory path, the syntax one doesn't
         atom.config.set('core.themes', ['theme-with-index-less', 'atom-dark-ui'])
 
       waitsFor ->
-        reloadHandler.callCount == 1
+        didChangeActiveThemesHandler.callCount == 1
 
       runs ->
-        expect($('style[group=theme]')).toHaveLength 2
+        expect($('style[priority=1]')).toHaveLength 2
         importPaths = themeManager.getImportPaths()
         expect(importPaths.length).toBe 1
         expect(importPaths[0]).toContain 'atom-dark-ui'
 
+    it 'adds theme-* classes to the workspace for each active theme', ->
+      workspaceElement = atom.views.getView(atom.workspace)
+      themeManager.onDidChangeActiveThemes didChangeActiveThemesHandler = jasmine.createSpy()
+
+      waitsForPromise ->
+        themeManager.activateThemes()
+
+      runs ->
+        expect(workspaceElement).toHaveClass 'theme-atom-dark-ui'
+
+        themeManager.onDidChangeActiveThemes didChangeActiveThemesHandler = jasmine.createSpy()
+        atom.config.set('core.themes', ['theme-with-ui-variables', 'theme-with-syntax-variables'])
+
+      waitsFor ->
+        didChangeActiveThemesHandler.callCount > 0
+
+      runs ->
+        # `theme-` twice as it prefixes the name with `theme-`
+        expect(workspaceElement).toHaveClass 'theme-theme-with-ui-variables'
+        expect(workspaceElement).toHaveClass 'theme-theme-with-syntax-variables'
+        expect(workspaceElement).not.toHaveClass 'theme-atom-dark-ui'
+        expect(workspaceElement).not.toHaveClass 'theme-atom-dark-syntax'
+
   describe "when a theme fails to load", ->
     it "logs a warning", ->
       spyOn(console, 'warn')
-      expect(-> atom.packages.activatePackage('a-theme-that-will-not-be-found')).toThrow()
+      atom.packages.activatePackage('a-theme-that-will-not-be-found')
+      expect(console.warn.callCount).toBe 1
+      expect(console.warn.argsForCall[0][0]).toContain "Could not resolve 'a-theme-that-will-not-be-found'"
 
   describe "::requireStylesheet(path)", ->
     beforeEach ->
@@ -145,7 +170,7 @@ describe "ThemeManager", ->
       themeManager.onDidChangeStylesheets stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
       themeManager.onDidAddStylesheet stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
 
-      cssPath = atom.project.resolve('css.css')
+      cssPath = atom.project.getDirectories()[0]?.resolve('css.css')
       lengthBefore = $('head style').length
 
       themeManager.requireStylesheet(cssPath)
@@ -169,7 +194,7 @@ describe "ThemeManager", ->
       $('head style[id*="css.css"]').remove()
 
     it "synchronously loads and parses less files at the given path and installs a style tag for it in the head", ->
-      lessPath = atom.project.resolve('sample.less')
+      lessPath = atom.project.getDirectories()[0]?.resolve('sample.less')
       lengthBefore = $('head style').length
       themeManager.requireStylesheet(lessPath)
       expect($('head style').length).toBe lengthBefore + 1
@@ -193,9 +218,9 @@ describe "ThemeManager", ->
 
     it "supports requiring css and less stylesheets without an explicit extension", ->
       themeManager.requireStylesheet path.join(__dirname, 'fixtures', 'css')
-      expect($('head style[source-path*="css.css"]').attr('source-path')).toBe themeManager.stringToId(atom.project.resolve('css.css'))
+      expect($('head style[source-path*="css.css"]').attr('source-path')).toBe themeManager.stringToId(atom.project.getDirectories()[0]?.resolve('css.css'))
       themeManager.requireStylesheet path.join(__dirname, 'fixtures', 'sample')
-      expect($('head style[source-path*="sample.less"]').attr('source-path')).toBe themeManager.stringToId(atom.project.resolve('sample.less'))
+      expect($('head style[source-path*="sample.less"]').attr('source-path')).toBe themeManager.stringToId(atom.project.getDirectories()[0]?.resolve('sample.less'))
 
       $('head style[id*="css.css"]').remove()
       $('head style[id*="sample.less"]').remove()
@@ -223,11 +248,9 @@ describe "ThemeManager", ->
 
       expect(stylesheetsChangedHandler).toHaveBeenCalled()
 
-  describe "base stylesheet loading", ->
+  describe "base style sheet loading", ->
     workspaceElement = null
     beforeEach ->
-      jasmine.snapshotDeprecations()
-
       workspaceElement = atom.views.getView(atom.workspace)
       jasmine.attachToDOM(workspaceElement)
       workspaceElement.appendChild document.createElement('atom-text-editor')
@@ -235,15 +258,12 @@ describe "ThemeManager", ->
       waitsForPromise ->
         themeManager.activateThemes()
 
-    beforeEach ->
-      jasmine.restoreDeprecationsSnapshot()
-
     it "loads the correct values from the theme's ui-variables file", ->
-      themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
+      themeManager.onDidChangeActiveThemes didChangeActiveThemesHandler = jasmine.createSpy()
       atom.config.set('core.themes', ['theme-with-ui-variables', 'theme-with-syntax-variables'])
 
       waitsFor ->
-        reloadHandler.callCount > 0
+        didChangeActiveThemesHandler.callCount > 0
 
       runs ->
         # an override loaded in the base css
@@ -256,11 +276,11 @@ describe "ThemeManager", ->
 
     describe "when there is a theme with incomplete variables", ->
       it "loads the correct values from the fallback ui-variables", ->
-        themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
+        themeManager.onDidChangeActiveThemes didChangeActiveThemesHandler = jasmine.createSpy()
         atom.config.set('core.themes', ['theme-with-incomplete-ui-variables', 'theme-with-syntax-variables'])
 
         waitsFor ->
-          reloadHandler.callCount > 0
+          didChangeActiveThemesHandler.callCount > 0
 
         runs ->
           # an override loaded in the base css
@@ -269,85 +289,104 @@ describe "ThemeManager", ->
           # from within the theme itself
           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', ->
-        expect(workspaceElement).toHaveClass 'theme-atom-dark-ui'
-
-        themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
-        atom.config.set('core.themes', ['theme-with-ui-variables', 'theme-with-syntax-variables'])
-
-        waitsFor ->
-          reloadHandler.callCount > 0
-
-        runs ->
-          # `theme-` twice as it prefixes the name with `theme-`
-          expect(workspaceElement).toHaveClass 'theme-theme-with-ui-variables'
-          expect(workspaceElement).toHaveClass 'theme-theme-with-syntax-variables'
-          expect(workspaceElement).not.toHaveClass 'theme-atom-dark-ui'
-          expect(workspaceElement).not.toHaveClass 'theme-atom-dark-syntax'
-
-  describe "when the user stylesheet changes", ->
+  describe "user stylesheet", ->
+    userStylesheetPath = null
     beforeEach ->
-      jasmine.snapshotDeprecations()
-
-    afterEach ->
-      jasmine.restoreDeprecationsSnapshot()
-
-    it "reloads it", ->
-      [styleElementAddedHandler, styleElementRemovedHandler] = []
-      [stylesheetRemovedHandler, stylesheetAddedHandler, stylesheetsChangedHandler] = []
       userStylesheetPath = path.join(temp.mkdirSync("atom"), 'styles.less')
       fs.writeFileSync(userStylesheetPath, 'body {border-style: dotted !important;}')
       spyOn(atom.styles, 'getUserStyleSheetPath').andReturn userStylesheetPath
 
-      waitsForPromise ->
-        themeManager.activateThemes()
+    describe "when the user stylesheet changes", ->
+      beforeEach ->
+        jasmine.snapshotDeprecations()
 
-      runs ->
-        atom.styles.onDidRemoveStyleElement styleElementRemovedHandler = jasmine.createSpy("styleElementRemovedHandler")
-        atom.styles.onDidAddStyleElement styleElementAddedHandler = jasmine.createSpy("styleElementAddedHandler")
+      afterEach ->
+        jasmine.restoreDeprecationsSnapshot()
 
-        themeManager.onDidChangeStylesheets stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
-        themeManager.onDidRemoveStylesheet stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
-        themeManager.onDidAddStylesheet stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
-        spyOn(themeManager, 'loadUserStylesheet').andCallThrough()
+      it "reloads it", ->
+        [styleElementAddedHandler, styleElementRemovedHandler] = []
+        [stylesheetRemovedHandler, stylesheetAddedHandler, stylesheetsChangedHandler] = []
 
-        expect($(document.body).css('border-style')).toBe 'dotted'
-        fs.writeFileSync(userStylesheetPath, 'body {border-style: dashed}')
+        waitsForPromise ->
+          themeManager.activateThemes()
 
-      waitsFor ->
-        themeManager.loadUserStylesheet.callCount is 1
+        runs ->
+          atom.styles.onDidRemoveStyleElement styleElementRemovedHandler = jasmine.createSpy("styleElementRemovedHandler")
+          atom.styles.onDidAddStyleElement styleElementAddedHandler = jasmine.createSpy("styleElementAddedHandler")
 
-      runs ->
-        expect($(document.body).css('border-style')).toBe 'dashed'
+          themeManager.onDidChangeStylesheets stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
+          themeManager.onDidRemoveStylesheet stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
+          themeManager.onDidAddStylesheet stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
+          spyOn(themeManager, 'loadUserStylesheet').andCallThrough()
 
-        expect(styleElementRemovedHandler).toHaveBeenCalled()
-        expect(styleElementRemovedHandler.argsForCall[0][0].textContent).toContain 'dotted'
-        expect(stylesheetRemovedHandler).toHaveBeenCalled()
-        expect(stylesheetRemovedHandler.argsForCall[0][0].cssRules[0].style.border).toBe 'dotted'
+          expect($(document.body).css('border-style')).toBe 'dotted'
+          fs.writeFileSync(userStylesheetPath, 'body {border-style: dashed}')
 
-        expect(styleElementAddedHandler).toHaveBeenCalled()
-        expect(styleElementAddedHandler.argsForCall[0][0].textContent).toContain 'dashed'
-        expect(stylesheetAddedHandler).toHaveBeenCalled()
-        expect(stylesheetAddedHandler.argsForCall[0][0].cssRules[0].style.border).toBe 'dashed'
+        waitsFor ->
+          themeManager.loadUserStylesheet.callCount is 1
 
-        expect(stylesheetsChangedHandler).toHaveBeenCalled()
+        runs ->
+          expect($(document.body).css('border-style')).toBe 'dashed'
 
-        styleElementRemovedHandler.reset()
-        stylesheetRemovedHandler.reset()
-        stylesheetsChangedHandler.reset()
-        fs.removeSync(userStylesheetPath)
+          expect(styleElementRemovedHandler).toHaveBeenCalled()
+          expect(styleElementRemovedHandler.argsForCall[0][0].textContent).toContain 'dotted'
+          expect(stylesheetRemovedHandler).toHaveBeenCalled()
+          expect(stylesheetRemovedHandler.argsForCall[0][0].cssRules[0].style.border).toBe 'dotted'
 
-      waitsFor ->
-        themeManager.loadUserStylesheet.callCount is 2
+          expect(styleElementAddedHandler).toHaveBeenCalled()
+          expect(styleElementAddedHandler.argsForCall[0][0].textContent).toContain 'dashed'
+          expect(stylesheetAddedHandler).toHaveBeenCalled()
+          expect(stylesheetAddedHandler.argsForCall[0][0].cssRules[0].style.border).toBe 'dashed'
 
-      runs ->
-        expect(styleElementRemovedHandler).toHaveBeenCalled()
-        expect(styleElementRemovedHandler.argsForCall[0][0].textContent).toContain 'dashed'
-        expect(stylesheetRemovedHandler).toHaveBeenCalled()
-        expect(stylesheetRemovedHandler.argsForCall[0][0].cssRules[0].style.border).toBe 'dashed'
-        expect($(document.body).css('border-style')).toBe 'none'
-        expect(stylesheetsChangedHandler).toHaveBeenCalled()
+          expect(stylesheetsChangedHandler).toHaveBeenCalled()
+
+          styleElementRemovedHandler.reset()
+          stylesheetRemovedHandler.reset()
+          stylesheetsChangedHandler.reset()
+          fs.removeSync(userStylesheetPath)
+
+        waitsFor ->
+          themeManager.loadUserStylesheet.callCount is 2
+
+        runs ->
+          expect(styleElementRemovedHandler).toHaveBeenCalled()
+          expect(styleElementRemovedHandler.argsForCall[0][0].textContent).toContain 'dashed'
+          expect(stylesheetRemovedHandler).toHaveBeenCalled()
+          expect(stylesheetRemovedHandler.argsForCall[0][0].cssRules[0].style.border).toBe 'dashed'
+          expect($(document.body).css('border-style')).toBe 'none'
+          expect(stylesheetsChangedHandler).toHaveBeenCalled()
+
+    describe "when there is an error reading the stylesheet", ->
+      addErrorHandler = null
+      beforeEach ->
+        themeManager.loadUserStylesheet()
+        spyOn(themeManager.lessCache, 'cssForFile').andCallFake ->
+          throw new Error('EACCES permission denied "styles.less"')
+        atom.notifications.onDidAddNotification addErrorHandler = jasmine.createSpy()
+
+      it "creates an error notification", ->
+        themeManager.loadUserStylesheet()
+        expect(addErrorHandler).toHaveBeenCalled()
+        note = addErrorHandler.mostRecentCall.args[0]
+        expect(note.getType()).toBe 'error'
+        expect(note.getMessage()).toContain 'Error loading'
+
+    describe "when there is an error watching the user stylesheet", ->
+      addErrorHandler = null
+      beforeEach ->
+        {File} = require 'pathwatcher'
+        spyOn(File::, 'on').andCallFake (event) ->
+          if event.indexOf('contents-changed') > -1
+            throw new Error('Unable to watch path')
+        spyOn(themeManager, 'loadStylesheet').andReturn ''
+        atom.notifications.onDidAddNotification addErrorHandler = jasmine.createSpy()
+
+      it "creates an error notification", ->
+        themeManager.loadUserStylesheet()
+        expect(addErrorHandler).toHaveBeenCalled()
+        note = addErrorHandler.mostRecentCall.args[0]
+        expect(note.getType()).toBe 'error'
+        expect(note.getMessage()).toContain 'Unable to watch path'
 
   describe "when a non-existent theme is present in the config", ->
     beforeEach ->
@@ -358,7 +397,7 @@ describe "ThemeManager", ->
         themeManager.activateThemes()
 
     it 'uses the default dark UI and syntax themes and logs a warning', ->
-      activeThemeNames = themeManager.getActiveNames()
+      activeThemeNames = themeManager.getActiveThemeNames()
       expect(console.warn.callCount).toBe 2
       expect(activeThemeNames.length).toBe(2)
       expect(activeThemeNames).toContain('atom-dark-ui')
@@ -376,7 +415,7 @@ describe "ThemeManager", ->
           themeManager.activateThemes()
 
       it 'uses the enabled themes', ->
-        activeThemeNames = themeManager.getActiveNames()
+        activeThemeNames = themeManager.getActiveThemeNames()
         expect(activeThemeNames.length).toBe(2)
         expect(activeThemeNames).toContain('atom-light-ui')
         expect(activeThemeNames).toContain('atom-dark-syntax')
@@ -389,7 +428,7 @@ describe "ThemeManager", ->
           themeManager.activateThemes()
 
       it 'uses the default dark UI and syntax themes', ->
-        activeThemeNames = themeManager.getActiveNames()
+        activeThemeNames = themeManager.getActiveThemeNames()
         expect(activeThemeNames.length).toBe(2)
         expect(activeThemeNames).toContain('atom-dark-ui')
         expect(activeThemeNames).toContain('atom-dark-syntax')
@@ -402,7 +441,7 @@ describe "ThemeManager", ->
           themeManager.activateThemes()
 
       it 'uses the default dark UI theme', ->
-        activeThemeNames = themeManager.getActiveNames()
+        activeThemeNames = themeManager.getActiveThemeNames()
         expect(activeThemeNames.length).toBe(2)
         expect(activeThemeNames).toContain('atom-dark-ui')
         expect(activeThemeNames).toContain('atom-light-syntax')
@@ -415,7 +454,7 @@ describe "ThemeManager", ->
           themeManager.activateThemes()
 
       it 'uses the default dark syntax theme', ->
-        activeThemeNames = themeManager.getActiveNames()
+        activeThemeNames = themeManager.getActiveThemeNames()
         expect(activeThemeNames.length).toBe(2)
         expect(activeThemeNames).toContain('atom-light-ui')
         expect(activeThemeNames).toContain('atom-dark-syntax')

spec/view-registry-spec.coffee

@@ -14,14 +14,14 @@ describe "ViewRegistry", ->
         expect(registry.getView(node)).toBe node
 
     describe "when passed a SpacePen view", ->
-      it "returns the root node of the view with a __spacePenView property pointing at the SpacePen view", ->
+      it "returns the root node of the view with a .spacePenView property pointing at the SpacePen view", ->
         class TestView extends View
           @content: -> @div "Hello"
 
         view = new TestView
         node = registry.getView(view)
         expect(node.textContent).toBe "Hello"
-        expect(node.__spacePenView).toBe view
+        expect(node.spacePenView).toBe view
 
     describe "when passed a model object", ->
       describe "when a view provider is registered matching the object's constructor", ->
@@ -62,7 +62,7 @@ describe "ViewRegistry", ->
             node = registry.getView(model)
 
             expect(node.textContent).toBe "hello"
-            view = node.__spacePenView
+            view = node.spacePenView
             expect(view instanceof TestView).toBe true
             expect(view.model).toBe model
 

spec/window-spec.coffee

@@ -169,6 +169,14 @@ describe "Window", ->
       $("<a href='#scroll-me'>link</a>").appendTo(document.body).click().remove()
       expect(shell.openExternal).not.toHaveBeenCalled()
 
+  describe "when a form is submitted", ->
+    it "prevents the default so that the window's URL isn't changed", ->
+      submitSpy = jasmine.createSpy('submit')
+      $(document).on('submit', 'form', submitSpy)
+      $("<form>foo</form>").appendTo(document.body).submit().remove()
+      expect(submitSpy.callCount).toBe 1
+      expect(submitSpy.argsForCall[0][0].isDefaultPrevented()).toBe true
+
   describe "core:focus-next and core:focus-previous", ->
     describe "when there is no currently focused element", ->
       it "focuses the element with the lowest/highest tabindex", ->

spec/workspace-spec.coffee

@@ -1,13 +1,19 @@
 path = require 'path'
 temp = require 'temp'
 Workspace = require '../src/workspace'
+Pane = require '../src/pane'
 {View} = require '../src/space-pen-extensions'
+platform = require './spec-helper-platform'
+_ = require 'underscore-plus'
+fstream = require 'fstream'
+fs = require 'fs-plus'
+Grim = require 'grim'
 
 describe "Workspace", ->
   workspace = null
 
   beforeEach ->
-    atom.project.setPaths([atom.project.resolve('dir')])
+    atom.project.setPaths([atom.project.getDirectories()[0]?.resolve('dir')])
     atom.workspace = workspace = new Workspace
 
   describe "::open(uri, options)", ->
@@ -66,19 +72,19 @@ describe "Workspace", ->
 
               expect(openEvents).toEqual [
                 {
-                  uri: atom.project.resolve('a')
+                  uri: atom.project.getDirectories()[0]?.resolve('a')
                   item: editor1
                   pane: atom.workspace.getActivePane()
                   index: 0
                 }
                 {
-                  uri: atom.project.resolve('b')
+                  uri: atom.project.getDirectories()[0]?.resolve('b')
                   item: editor2
                   pane: atom.workspace.getActivePane()
                   index: 1
                 }
                 {
-                  uri: atom.project.resolve('a')
+                  uri: atom.project.getDirectories()[0]?.resolve('a')
                   item: editor1
                   pane: atom.workspace.getActivePane()
                   index: 0
@@ -92,7 +98,7 @@ describe "Workspace", ->
               workspace.open('a').then (o) -> editor = o
 
             runs ->
-              expect(editor.getUri()).toBe atom.project.resolve('a')
+              expect(editor.getURI()).toBe atom.project.getDirectories()[0]?.resolve('a')
               expect(workspace.getActivePaneItem()).toBe editor
               expect(workspace.getActivePane().items).toEqual [editor]
               expect(workspace.getActivePane().activate).toHaveBeenCalled()
@@ -226,7 +232,7 @@ describe "Workspace", ->
         workspace.addOpener(barOpener)
 
         waitsForPromise ->
-          pathToOpen = atom.project.resolve('a.foo')
+          pathToOpen = atom.project.getDirectories()[0]?.resolve('a.foo')
           workspace.open(pathToOpen, hey: "there").then (item) ->
             expect(item).toEqual { foo: pathToOpen, options: {hey: "there"} }
 
@@ -246,6 +252,116 @@ describe "Workspace", ->
       runs ->
         expect(newEditorHandler.argsForCall[0][0].textEditor).toBe editor
 
+    it "records a deprecation warning on the appropriate package if the item has a ::getUri method instead of ::getURI", ->
+      jasmine.snapshotDeprecations()
+
+      waitsForPromise -> atom.packages.activatePackage('package-with-deprecated-pane-item-method')
+
+      waitsForPromise ->
+        atom.workspace.open("test")
+
+      runs ->
+        deprecations = Grim.getDeprecations()
+        expect(deprecations.length).toBe 1
+        expect(deprecations[0].message).toBe "Pane item with class `TestItem` should implement `::getURI` instead of `::getUri`."
+        expect(deprecations[0].getStacks()[0].metadata.packageName).toBe "package-with-deprecated-pane-item-method"
+        jasmine.restoreDeprecationsSnapshot()
+
+    describe "when there is an error opening the file", ->
+      notificationSpy = null
+      beforeEach ->
+        atom.notifications.onDidAddNotification notificationSpy = jasmine.createSpy()
+
+      describe "when a large file is opened", ->
+        beforeEach ->
+          spyOn(fs, 'getSizeSync').andReturn 2 * 1048577 # 2MB
+
+        it "creates a notification", ->
+          waitsForPromise ->
+            workspace.open('file1')
+
+          runs ->
+            expect(notificationSpy).toHaveBeenCalled()
+            notification = notificationSpy.mostRecentCall.args[0]
+            expect(notification.getType()).toBe 'warning'
+            expect(notification.getMessage()).toContain '< 2MB'
+
+      describe "when a file does not exist", ->
+        it "creates an empty buffer for the specified path", ->
+          waitsForPromise ->
+            workspace.open('not-a-file.md')
+
+          runs ->
+            editor = workspace.getActiveTextEditor()
+            expect(notificationSpy).not.toHaveBeenCalled()
+            expect(editor.getPath()).toContain 'not-a-file.md'
+
+      describe "when the user does not have access to the file", ->
+        beforeEach ->
+          spyOn(fs, 'openSync').andCallFake (path) ->
+            error = new Error("EACCES, permission denied '#{path}'")
+            error.path = path
+            error.code = 'EACCES'
+            throw error
+
+        it "creates a notification", ->
+          waitsForPromise ->
+            workspace.open('file1')
+
+          runs ->
+            expect(notificationSpy).toHaveBeenCalled()
+            notification = notificationSpy.mostRecentCall.args[0]
+            expect(notification.getType()).toBe 'warning'
+            expect(notification.getMessage()).toContain 'Permission denied'
+            expect(notification.getMessage()).toContain 'file1'
+
+      describe "when the the operation is not permitted", ->
+        beforeEach ->
+          spyOn(fs, 'openSync').andCallFake (path) ->
+            error = new Error("EPERM, operation not permitted '#{path}'")
+            error.path = path
+            error.code = 'EPERM'
+            throw error
+
+        it "creates a notification", ->
+          waitsForPromise ->
+            workspace.open('file1')
+
+          runs ->
+            expect(notificationSpy).toHaveBeenCalled()
+            notification = notificationSpy.mostRecentCall.args[0]
+            expect(notification.getType()).toBe 'warning'
+            expect(notification.getMessage()).toContain 'Unable to open'
+            expect(notification.getMessage()).toContain 'file1'
+
+      describe "when the the file is already open in windows", ->
+        beforeEach ->
+          spyOn(fs, 'openSync').andCallFake (path) ->
+            error = new Error("EBUSY, resource busy or locked '#{path}'")
+            error.path = path
+            error.code = 'EBUSY'
+            throw error
+
+        it "creates a notification", ->
+          waitsForPromise ->
+            workspace.open('file1')
+
+          runs ->
+            expect(notificationSpy).toHaveBeenCalled()
+            notification = notificationSpy.mostRecentCall.args[0]
+            expect(notification.getType()).toBe 'warning'
+            expect(notification.getMessage()).toContain 'Unable to open'
+            expect(notification.getMessage()).toContain 'file1'
+
+      describe "when there is an unhandled error", ->
+        beforeEach ->
+          spyOn(fs, 'openSync').andCallFake (path) ->
+            throw new Error("I dont even know what is happening right now!!")
+
+        it "creates a notification", ->
+          open = -> workspace.open('file1', workspace.getActivePane())
+          expect(open).toThrow()
+
   describe "::reopenItem()", ->
     it "opens the uri associated with the last closed pane that isn't currently open", ->
       pane = workspace.getActivePane()
@@ -257,21 +373,21 @@ describe "Workspace", ->
 
       runs ->
         # does not reopen items with no uri
-        expect(workspace.getActivePaneItem().getUri()).toBeUndefined()
+        expect(workspace.getActivePaneItem().getURI()).toBeUndefined()
         pane.destroyActiveItem()
 
       waitsForPromise ->
         workspace.reopenItem()
 
       runs ->
-        expect(workspace.getActivePaneItem().getUri()).not.toBeUndefined()
+        expect(workspace.getActivePaneItem().getURI()).not.toBeUndefined()
 
         # destroy all items
-        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('file1')
+        expect(workspace.getActivePaneItem().getURI()).toBe atom.project.getDirectories()[0]?.resolve('file1')
         pane.destroyActiveItem()
-        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('b')
+        expect(workspace.getActivePaneItem().getURI()).toBe atom.project.getDirectories()[0]?.resolve('b')
         pane.destroyActiveItem()
-        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('a')
+        expect(workspace.getActivePaneItem().getURI()).toBe atom.project.getDirectories()[0]?.resolve('a')
         pane.destroyActiveItem()
 
         # reopens items with uris
@@ -281,20 +397,20 @@ describe "Workspace", ->
         workspace.reopenItem()
 
       runs ->
-        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('a')
+        expect(workspace.getActivePaneItem().getURI()).toBe atom.project.getDirectories()[0]?.resolve('a')
 
       # does not reopen items that are already open
       waitsForPromise ->
         workspace.open('b')
 
       runs ->
-        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('b')
+        expect(workspace.getActivePaneItem().getURI()).toBe atom.project.getDirectories()[0]?.resolve('b')
 
       waitsForPromise ->
         workspace.reopenItem()
 
       runs ->
-        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('file1')
+        expect(workspace.getActivePaneItem().getURI()).toBe atom.project.getDirectories()[0]?.resolve('file1')
 
   describe "::increase/decreaseFontSize()", ->
     it "increases/decreases the font size without going below 1", ->
@@ -553,3 +669,363 @@ describe "Workspace", ->
 
         expect(atom.workspace.panelForItem(item)).toBe panel
         expect(atom.workspace.panelForItem(itemWithNoPanel)).toBe null
+
+  describe "::scan(regex, options, callback)", ->
+    describe "when called with a regex", ->
+      it "calls the callback with all regex results in all files in the project", ->
+        results = []
+        waitsForPromise ->
+          atom.workspace.scan /(a)+/, (result) ->
+            results.push(result)
+
+        runs ->
+          expect(results).toHaveLength(3)
+          expect(results[0].filePath).toBe atom.project.getDirectories()[0]?.resolve('a')
+          expect(results[0].matches).toHaveLength(3)
+          expect(results[0].matches[0]).toEqual
+            matchText: 'aaa'
+            lineText: 'aaa bbb'
+            lineTextOffset: 0
+            range: [[0, 0], [0, 3]]
+
+      it "works with with escaped literals (like $ and ^)", ->
+        results = []
+        waitsForPromise ->
+          atom.workspace.scan /\$\w+/, (result) -> results.push(result)
+
+        runs ->
+          expect(results.length).toBe 1
+
+          {filePath, matches} = results[0]
+          expect(filePath).toBe atom.project.getDirectories()[0]?.resolve('a')
+          expect(matches).toHaveLength 1
+          expect(matches[0]).toEqual
+            matchText: '$bill'
+            lineText: 'dollar$bill'
+            lineTextOffset: 0
+            range: [[2, 6], [2, 11]]
+
+      it "works on evil filenames", ->
+        platform.generateEvilFiles()
+        atom.project.setPaths([path.join(__dirname, 'fixtures', 'evil-files')])
+        paths = []
+        matches = []
+        waitsForPromise ->
+          atom.workspace.scan /evil/, (result) ->
+            paths.push(result.filePath)
+            matches = matches.concat(result.matches)
+
+        runs ->
+          _.each(matches, (m) -> expect(m.matchText).toEqual 'evil')
+
+          if platform.isWindows()
+            expect(paths.length).toBe 3
+            expect(paths[0]).toMatch /a_file_with_utf8.txt$/
+            expect(paths[1]).toMatch /file with spaces.txt$/
+            expect(path.basename(paths[2])).toBe "utfa\u0306.md"
+          else
+            expect(paths.length).toBe 5
+            expect(paths[0]).toMatch /a_file_with_utf8.txt$/
+            expect(paths[1]).toMatch /file with spaces.txt$/
+            expect(paths[2]).toMatch /goddam\nnewlines$/m
+            expect(paths[3]).toMatch /quote".txt$/m
+            expect(path.basename(paths[4])).toBe "utfa\u0306.md"
+
+      it "ignores case if the regex includes the `i` flag", ->
+        results = []
+        waitsForPromise ->
+          atom.workspace.scan /DOLLAR/i, (result) -> results.push(result)
+
+        runs ->
+          expect(results).toHaveLength 1
+
+      describe "when the core.excludeVcsIgnoredPaths config is truthy", ->
+        [projectPath, ignoredPath] = []
+
+        beforeEach ->
+          sourceProjectPath = path.join(__dirname, 'fixtures', 'git', 'working-dir')
+          projectPath = path.join(temp.mkdirSync("atom"))
+
+          writerStream = fstream.Writer(projectPath)
+          fstream.Reader(sourceProjectPath).pipe(writerStream)
+
+          waitsFor (done) ->
+            writerStream.on 'close', done
+            writerStream.on 'error', done
+
+          runs ->
+            fs.rename(path.join(projectPath, 'git.git'), path.join(projectPath, '.git'))
+            ignoredPath = path.join(projectPath, 'ignored.txt')
+            fs.writeFileSync(ignoredPath, 'this match should not be included')
+
+        afterEach ->
+          fs.removeSync(projectPath) if fs.existsSync(projectPath)
+
+        it "excludes ignored files", ->
+          atom.project.setPaths([projectPath])
+          atom.config.set('core.excludeVcsIgnoredPaths', true)
+          resultHandler = jasmine.createSpy("result found")
+          waitsForPromise ->
+            atom.workspace.scan /match/, (results) ->
+              resultHandler()
+
+          runs ->
+            expect(resultHandler).not.toHaveBeenCalled()
+
+      it "includes only files when a directory filter is specified", ->
+        projectPath = path.join(path.join(__dirname, 'fixtures', 'dir'))
+        atom.project.setPaths([projectPath])
+
+        filePath = path.join(projectPath, 'a-dir', 'oh-git')
+
+        paths = []
+        matches = []
+        waitsForPromise ->
+          atom.workspace.scan /aaa/, paths: ["a-dir#{path.sep}"], (result) ->
+            paths.push(result.filePath)
+            matches = matches.concat(result.matches)
+
+        runs ->
+          expect(paths.length).toBe 1
+          expect(paths[0]).toBe filePath
+          expect(matches.length).toBe 1
+
+      it "includes files and folders that begin with a '.'", ->
+        projectPath = temp.mkdirSync()
+        filePath = path.join(projectPath, '.text')
+        fs.writeFileSync(filePath, 'match this')
+        atom.project.setPaths([projectPath])
+        paths = []
+        matches = []
+        waitsForPromise ->
+          atom.workspace.scan /match this/, (result) ->
+            paths.push(result.filePath)
+            matches = matches.concat(result.matches)
+
+        runs ->
+          expect(paths.length).toBe 1
+          expect(paths[0]).toBe filePath
+          expect(matches.length).toBe 1
+
+      it "excludes values in core.ignoredNames", ->
+        projectPath = path.join(__dirname, 'fixtures', 'git', 'working-dir')
+        ignoredNames = atom.config.get("core.ignoredNames")
+        ignoredNames.push("a")
+        atom.config.set("core.ignoredNames", ignoredNames)
+
+        resultHandler = jasmine.createSpy("result found")
+        waitsForPromise ->
+          atom.workspace.scan /dollar/, (results) ->
+            resultHandler()
+
+        runs ->
+          expect(resultHandler).not.toHaveBeenCalled()
+
+      it "scans buffer contents if the buffer is modified", ->
+        editor = null
+        results = []
+
+        waitsForPromise ->
+          atom.project.open('a').then (o) ->
+            editor = o
+            editor.setText("Elephant")
+
+        waitsForPromise ->
+          atom.workspace.scan /a|Elephant/, (result) -> results.push result
+
+        runs ->
+          expect(results).toHaveLength 3
+          resultForA = _.find results, ({filePath}) -> path.basename(filePath) == 'a'
+          expect(resultForA.matches).toHaveLength 1
+          expect(resultForA.matches[0].matchText).toBe 'Elephant'
+
+      it "ignores buffers outside the project", ->
+        editor = null
+        results = []
+
+        waitsForPromise ->
+          atom.project.open(temp.openSync().path).then (o) ->
+            editor = o
+            editor.setText("Elephant")
+
+        waitsForPromise ->
+          atom.workspace.scan /Elephant/, (result) -> results.push result
+
+        runs ->
+          expect(results).toHaveLength 0
+
+  describe "::replace(regex, replacementText, paths, iterator)", ->
+    [filePath, commentFilePath, sampleContent, sampleCommentContent] = []
+
+    beforeEach ->
+      atom.project.setPaths([atom.project.getDirectories()[0]?.resolve('../')])
+
+      filePath = atom.project.getDirectories()[0]?.resolve('sample.js')
+      commentFilePath = atom.project.getDirectories()[0]?.resolve('sample-with-comments.js')
+      sampleContent = fs.readFileSync(filePath).toString()
+      sampleCommentContent = fs.readFileSync(commentFilePath).toString()
+
+    afterEach ->
+      fs.writeFileSync(filePath, sampleContent)
+      fs.writeFileSync(commentFilePath, sampleCommentContent)
+
+    describe "when a file doesn't exist", ->
+      it "calls back with an error", ->
+        errors = []
+        missingPath = path.resolve('/not-a-file.js')
+        expect(fs.existsSync(missingPath)).toBeFalsy()
+
+        waitsForPromise ->
+          atom.workspace.replace /items/gi, 'items', [missingPath], (result, error) ->
+            errors.push(error)
+
+        runs ->
+          expect(errors).toHaveLength 1
+          expect(errors[0].path).toBe missingPath
+
+    describe "when called with unopened files", ->
+      it "replaces properly", ->
+        results = []
+        waitsForPromise ->
+          atom.workspace.replace /items/gi, 'items', [filePath], (result) ->
+            results.push(result)
+
+        runs ->
+          expect(results).toHaveLength 1
+          expect(results[0].filePath).toBe filePath
+          expect(results[0].replacements).toBe 6
+
+    describe "when a buffer is already open", ->
+      it "replaces properly and saves when not modified", ->
+        editor = null
+        results = []
+
+        waitsForPromise ->
+          atom.project.open('sample.js').then (o) -> editor = o
+
+        runs ->
+          expect(editor.isModified()).toBeFalsy()
+
+        waitsForPromise ->
+          atom.workspace.replace /items/gi, 'items', [filePath], (result) ->
+            results.push(result)
+
+        runs ->
+          expect(results).toHaveLength 1
+          expect(results[0].filePath).toBe filePath
+          expect(results[0].replacements).toBe 6
+
+          expect(editor.isModified()).toBeFalsy()
+
+      it "does not replace when the path is not specified", ->
+        editor = null
+        results = []
+
+        waitsForPromise ->
+          atom.project.open('sample-with-comments.js').then (o) -> editor = o
+
+        waitsForPromise ->
+          atom.workspace.replace /items/gi, 'items', [commentFilePath], (result) ->
+            results.push(result)
+
+        runs ->
+          expect(results).toHaveLength 1
+          expect(results[0].filePath).toBe commentFilePath
+
+      it "does NOT save when modified", ->
+        editor = null
+        results = []
+
+        waitsForPromise ->
+          atom.project.open('sample.js').then (o) -> editor = o
+
+        runs ->
+          editor.buffer.setTextInRange([[0,0],[0,0]], 'omg')
+          expect(editor.isModified()).toBeTruthy()
+
+        waitsForPromise ->
+          atom.workspace.replace /items/gi, 'okthen', [filePath], (result) ->
+            results.push(result)
+
+        runs ->
+          expect(results).toHaveLength 1
+          expect(results[0].filePath).toBe filePath
+          expect(results[0].replacements).toBe 6
+
+          expect(editor.isModified()).toBeTruthy()
+
+  describe "::saveActivePaneItem()", ->
+    describe "when there is an error", ->
+      it "emits a warning notification when the file cannot be saved", ->
+        spyOn(Pane::, 'saveActiveItem').andCallFake ->
+          throw new Error("'/some/file' is a directory")
+
+        atom.notifications.onDidAddNotification addedSpy = jasmine.createSpy()
+        atom.workspace.saveActivePaneItem()
+        expect(addedSpy).toHaveBeenCalled()
+        expect(addedSpy.mostRecentCall.args[0].getType()).toBe 'warning'
+
+      it "emits a warning notification when the directory cannot be written to", ->
+        spyOn(Pane::, 'saveActiveItem').andCallFake ->
+          throw new Error("ENOTDIR, not a directory '/Some/dir/and-a-file.js'")
+
+        atom.notifications.onDidAddNotification addedSpy = jasmine.createSpy()
+        atom.workspace.saveActivePaneItem()
+        expect(addedSpy).toHaveBeenCalled()
+        expect(addedSpy.mostRecentCall.args[0].getType()).toBe 'warning'
+
+      it "emits a warning notification when the user does not have permission", ->
+        spyOn(Pane::, 'saveActiveItem').andCallFake ->
+          error = new Error("EACCES, permission denied '/Some/dir/and-a-file.js'")
+          error.code = 'EACCES'
+          error.path = '/Some/dir/and-a-file.js'
+          throw error
+
+        atom.notifications.onDidAddNotification addedSpy = jasmine.createSpy()
+        atom.workspace.saveActivePaneItem()
+        expect(addedSpy).toHaveBeenCalled()
+        expect(addedSpy.mostRecentCall.args[0].getType()).toBe 'warning'
+
+      it "emits a warning notification when the operation is not permitted", ->
+        spyOn(Pane::, 'saveActiveItem').andCallFake ->
+          error = new Error("EPERM, operation not permitted '/Some/dir/and-a-file.js'")
+          error.code = 'EPERM'
+          error.path = '/Some/dir/and-a-file.js'
+          throw error
+
+      it "emits a warning notification when the file is already open by another app", ->
+        spyOn(Pane::, 'saveActiveItem').andCallFake ->
+          error = new Error("EBUSY, resource busy or locked '/Some/dir/and-a-file.js'")
+          error.code = 'EBUSY'
+          error.path = '/Some/dir/and-a-file.js'
+          throw error
+
+        atom.notifications.onDidAddNotification addedSpy = jasmine.createSpy()
+        atom.workspace.saveActivePaneItem()
+        expect(addedSpy).toHaveBeenCalled()
+
+        notificaiton = addedSpy.mostRecentCall.args[0]
+        expect(notificaiton.getType()).toBe 'warning'
+        expect(notificaiton.getMessage()).toContain 'Unable to save'
+
+      it "emits a warning notification when the file system is read-only", ->
+        spyOn(Pane::, 'saveActiveItem').andCallFake ->
+          error = new Error("EROFS, read-only file system '/Some/dir/and-a-file.js'")
+          error.code = 'EROFS'
+          error.path = '/Some/dir/and-a-file.js'
+          throw error
+
+        atom.notifications.onDidAddNotification addedSpy = jasmine.createSpy()
+        atom.workspace.saveActivePaneItem()
+        expect(addedSpy).toHaveBeenCalled()
+
+        notification = addedSpy.mostRecentCall.args[0]
+        expect(notification.getType()).toBe 'warning'
+        expect(notification.getMessage()).toContain 'Unable to save'
+
+      it "emits a warning notification when the file cannot be saved", ->
+        spyOn(Pane::, 'saveActiveItem').andCallFake ->
+          throw new Error("no one knows")
+
+        save = -> atom.workspace.saveActivePaneItem()
+        expect(save).toThrow()

spec/workspace-view-spec.coffee

@@ -3,7 +3,6 @@ Q = require 'q'
 path = require 'path'
 temp = require 'temp'
 TextEditorView = require '../src/text-editor-view'
-Pane = require '../src/pane'
 PaneView = require '../src/pane-view'
 Workspace = require '../src/workspace'
 
@@ -13,8 +12,8 @@ describe "WorkspaceView", ->
   beforeEach ->
     jasmine.snapshotDeprecations()
 
-    atom.project.setPaths([atom.project.resolve('dir')])
-    pathToOpen = atom.project.resolve('a')
+    atom.project.setPaths([atom.project.getDirectories()[0]?.resolve('dir')])
+    pathToOpen = atom.project.getDirectories()[0]?.resolve('a')
     atom.workspace = new Workspace
     atom.workspaceView = atom.views.getView(atom.workspace).__spacePenView
     atom.workspaceView.enableKeymap()
@@ -93,11 +92,11 @@ describe "WorkspaceView", ->
           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')
-          expect(editorView3.getEditor().getPath()).toBe atom.project.resolve('../sample.js')
+          expect(editorView1.getEditor().getPath()).toBe atom.project.getDirectories()[0]?.resolve('a')
+          expect(editorView2.getEditor().getPath()).toBe atom.project.getDirectories()[0]?.resolve('b')
+          expect(editorView3.getEditor().getPath()).toBe atom.project.getDirectories()[0]?.resolve('../sample.js')
           expect(editorView3.getEditor().getCursorScreenPosition()).toEqual [2, 4]
-          expect(editorView4.getEditor().getPath()).toBe atom.project.resolve('../sample.txt')
+          expect(editorView4.getEditor().getPath()).toBe atom.project.getDirectories()[0]?.resolve('../sample.txt')
           expect(editorView4.getEditor().getCursorScreenPosition()).toEqual [0, 2]
 
           # ensure adjust pane dimensions is called
@@ -295,39 +294,3 @@ describe "WorkspaceView", ->
 
       modalContainer = workspaceElement.querySelector('atom-panel-container.modal')
       expect(modalContainer.parentNode).toBe workspaceElement
-
-  describe "::saveActivePaneItem()", ->
-    describe "when there is an error", ->
-      it "emits a warning notification when the file cannot be saved", ->
-        spyOn(Pane::, 'saveActiveItem').andCallFake ->
-          throw new Error("'/some/file' is a directory")
-
-        atom.notifications.onDidAddNotification addedSpy = jasmine.createSpy()
-        atom.workspace.saveActivePaneItem()
-        expect(addedSpy).toHaveBeenCalled()
-        expect(addedSpy.mostRecentCall.args[0].getType()).toBe 'warning'
-
-      it "emits a warning notification when the directory cannot be written to", ->
-        spyOn(Pane::, 'saveActiveItem').andCallFake ->
-          throw new Error("ENOTDIR, not a directory '/Some/dir/and-a-file.js'")
-
-        atom.notifications.onDidAddNotification addedSpy = jasmine.createSpy()
-        atom.workspace.saveActivePaneItem()
-        expect(addedSpy).toHaveBeenCalled()
-        expect(addedSpy.mostRecentCall.args[0].getType()).toBe 'warning'
-
-      it "emits a warning notification when the user does not have permission", ->
-        spyOn(Pane::, 'saveActiveItem').andCallFake ->
-          throw new Error("EACCES, permission denied '/Some/dir/and-a-file.js'")
-
-        atom.notifications.onDidAddNotification addedSpy = jasmine.createSpy()
-        atom.workspace.saveActivePaneItem()
-        expect(addedSpy).toHaveBeenCalled()
-        expect(addedSpy.mostRecentCall.args[0].getType()).toBe 'warning'
-
-      it "emits a warning notification when the file cannot be saved", ->
-        spyOn(Pane::, 'saveActiveItem').andCallFake ->
-          throw new Error("no one knows")
-
-        save = -> atom.workspace.saveActivePaneItem()
-        expect(save).toThrow()

src/atom.coffee

@@ -3,7 +3,6 @@ ipc = require 'ipc'
 os = require 'os'
 path = require 'path'
 remote = require 'remote'
-screen = require 'screen'
 shell = require 'shell'
 
 _ = require 'underscore-plus'
@@ -280,8 +279,6 @@ class Atom extends Model
       deprecate "The atom.syntax global is deprecated. Use atom.grammars instead."
       @grammars
 
-    @subscribe @packages.onDidActivateAll => @watchThemes()
-
     Project = require './project'
     TextBuffer = require 'text-buffer'
     @deserializers.add(TextBuffer)
@@ -547,6 +544,7 @@ class Atom extends Model
     if @isValidDimensions(dimensions)
       dimensions
     else
+      screen = remote.require 'screen'
       {width, height} = screen.getPrimaryDisplay().workAreaSize
       {x: 0, y: 0, width: Math.min(1024, width), height}
 
@@ -580,7 +578,10 @@ class Atom extends Model
 
     @watchProjectPath()
 
-    @packages.activate()
+    @packages.activate().then =>
+      maximize = dimensions?.maximized and process.platform isnt 'darwin'
+      @displayWindow({maximize})
+
     @keymaps.loadUserKeymap()
     @requireUserInitScript() unless safeMode
 
@@ -589,9 +590,6 @@ class Atom extends Model
       @setAutoHideMenuBar(newValue)
     @setAutoHideMenuBar(true) if @config.get('core.autoHideMenuBar')
 
-    maximize = dimensions?.maximized and process.platform isnt 'darwin'
-    @displayWindow({maximize})
-
   unloadEditorWindow: ->
     return if not @project
 
@@ -720,13 +718,6 @@ class Atom extends Model
   loadThemes: ->
     @themes.load()
 
-  watchThemes: ->
-    @themes.onDidReloadAll =>
-      # Only reload stylesheets from non-theme packages
-      for pack in @packages.getActivePackages() when pack.getType() isnt 'theme'
-        pack.reloadStylesheets?()
-      null
-
   # Notify the browser project of the window's current project path
   watchProjectPath: ->
     onProjectPathChanged = =>
@@ -776,7 +767,9 @@ class Atom extends Model
       try
         require(userInitScriptPath) if fs.isFileSync(userInitScriptPath)
       catch error
-        console.error "Failed to load `#{userInitScriptPath}`", error.stack, error
+        atom.notifications.addError "Failed to load `#{userInitScriptPath}`",
+          detail: error.message
+          dismissable: true
 
   # Require the module with the given globals.
   #

src/browser/atom-application.coffee

@@ -359,7 +359,7 @@ class AtomApplication
 
     if existingWindow?
       openedWindow = existingWindow
-      openedWindow.openPath(pathToOpen, initialLine)
+      openedWindow.openPath(pathToOpen, initialLine, initialColumn)
       if openedWindow.isMinimized()
         openedWindow.restore()
       else

src/browser/atom-window.coffee

@@ -10,7 +10,6 @@ module.exports =
 class AtomWindow
   _.extend @prototype, EventEmitter.prototype
 
-  @iconPath: path.resolve(__dirname, '..', '..', 'resources', 'atom.png')
   @includeShellLoadTime: true
 
   browserWindow: null
@@ -26,7 +25,6 @@ class AtomWindow
     @browserWindow = new BrowserWindow
       show: false
       title: 'Atom'
-      icon: @constructor.iconPath
       'web-preferences':
         'direct-write': false
         'subpixel-font-scaling': false

src/browser/auto-update-manager.coffee

@@ -1,6 +1,7 @@
 autoUpdater = null
 _ = require 'underscore-plus'
 {EventEmitter} = require 'events'
+path = require 'path'
 
 IdleState = 'idle'
 CheckingState = 'checking'
@@ -51,8 +52,7 @@ class AutoUpdateManager
       @emitUpdateAvailableEvent(@getWindows()...)
 
     # Only released versions should check for updates.
-    unless /\w{7}/.test(@version)
-      @check(hidePopups: true)
+    @check(hidePopups: true) unless /\w{7}/.test(@version)
 
     switch process.platform
       when 'win32'
@@ -86,12 +86,24 @@ class AutoUpdateManager
   onUpdateNotAvailable: =>
     autoUpdater.removeListener 'error', @onUpdateError
     dialog = require 'dialog'
-    dialog.showMessageBox type: 'info', buttons: ['OK'], message: 'No update available.', detail: "Version #{@version} is the latest version."
+    dialog.showMessageBox
+      type: 'info'
+      buttons: ['OK']
+      icon: path.resolve(__dirname, '..', '..', 'resources', 'atom.png')
+      message: 'No update available.'
+      title: 'No Update Available'
+      detail: "Version #{@version} is the latest version."
 
   onUpdateError: (event, message) =>
     autoUpdater.removeListener 'update-not-available', @onUpdateNotAvailable
     dialog = require 'dialog'
-    dialog.showMessageBox type: 'warning', buttons: ['OK'], message: 'There was an error checking for updates.', detail: message
+    dialog.showMessageBox
+      type: 'warning'
+      buttons: ['OK']
+      icon: path.resolve(__dirname, '..', '..', 'resources', 'atom.png')
+      message: 'There was an error checking for updates.'
+      title: 'Update Error'
+      detail: message
 
   getWindows: ->
     global.atomApplication.windows

src/browser/main.coffee

@@ -13,16 +13,6 @@ process.on 'uncaughtException', (error={}) ->
   nslog(error.message) if error.message?
   nslog(error.stack) if error.stack?
 
-# Patch fs.statSyncNoException/fs.lstatSyncNoException to fail for non-strings
-# https://github.com/atom/atom-shell/issues/843
-{lstatSyncNoException, statSyncNoException} = fs
-fs.statSyncNoException = (pathToStat) ->
-  return false unless pathToStat and typeof pathToStat is 'string'
-  statSyncNoException(pathToStat)
-fs.lstatSyncNoException = (pathToStat) ->
-  return false unless pathToStat and typeof pathToStat is 'string'
-  lstatSyncNoException(pathToStat)
-
 start = ->
   if process.platform is 'win32'
     SquirrelUpdate = require './squirrel-update'
@@ -50,8 +40,12 @@ start = ->
     app.removeListener 'open-file', addPathToOpen
     app.removeListener 'open-url', addUrlToOpen
 
+    cwd = args.executedFrom?.toString() or process.cwd()
     args.pathsToOpen = args.pathsToOpen.map (pathToOpen) ->
-      path.resolve(args.executedFrom ? process.cwd(), pathToOpen.toString())
+      if cwd
+        path.resolve(cwd, pathToOpen.toString())
+      else
+        path.resolve(pathToOpen.toString())
 
     setupCoffeeScript()
     if args.devMode