Upgrade notifications for issue searching and dupe handling

when there is a parse error

build/Gruntfile.coffee

@@ -6,7 +6,6 @@ os = require 'os'
 # modules work under node v0.11.x.
 require 'vm-compatibility-layer'
 
-fm = require 'json-front-matter'
 _ = require 'underscore-plus'
 
 packageJson = require '../package.json'
@@ -22,9 +21,9 @@ module.exports = (grunt) ->
   grunt.loadNpmTasks('grunt-contrib-csslint')
   grunt.loadNpmTasks('grunt-contrib-coffee')
   grunt.loadNpmTasks('grunt-contrib-less')
-  grunt.loadNpmTasks('grunt-markdown')
   grunt.loadNpmTasks('grunt-shell')
   grunt.loadNpmTasks('grunt-download-atom-shell')
+  grunt.loadNpmTasks('grunt-atom-shell-installer')
   grunt.loadNpmTasks('grunt-peg')
   grunt.loadTasks('tasks')
 
@@ -194,32 +193,19 @@ module.exports = (grunt) ->
         'static/**/*.less'
       ]
 
-    markdown:
-      guides:
-        files: [
-          expand: true
-          cwd: 'docs'
-          src: '**/*.md'
-          dest: 'docs/output/'
-          ext: '.html'
-        ]
-        options:
-          template: 'docs/template.jst'
-          templateContext:
-            tag: "v#{major}.#{minor}"
-          markdownOptions:
-            gfm: true
-          preCompile: (src, context) ->
-            parsed = fm.parse(src)
-            _.extend(context, parsed.attributes)
-            parsed.body
-
     'download-atom-shell':
       version: packageJson.atomShellVersion
       outputDir: 'atom-shell'
       downloadDir: atomShellDownloadDir
       rebuild: true  # rebuild native modules after atom-shell is updated
 
+    'create-windows-installer':
+      appDirectory: shellAppDir
+      outputDirectory: path.join(buildDir, 'installer')
+      authors: 'GitHub Inc.'
+      loadingGif: path.resolve(__dirname, '..', 'resources', 'win', 'loading.gif')
+      iconUrl: 'https://raw.githubusercontent.com/atom/atom/master/resources/win/atom.ico'
+
     shell:
       'kill-atom':
         command: killCommand
@@ -237,6 +223,7 @@ module.exports = (grunt) ->
   ciTasks.push('dump-symbols') if process.platform isnt 'win32'
   ciTasks.push('set-version', 'check-licenses', 'lint')
   ciTasks.push('mkdeb') if process.platform is 'linux'
+  ciTasks.push('create-windows-installer') if process.platform is 'win32'
   ciTasks.push('test') if process.platform is 'darwin'
   ciTasks.push('codesign')
   ciTasks.push('publish-build')

build/package.json

@@ -7,11 +7,12 @@
   },
   "dependencies": {
     "async": "~0.2.9",
-    "donna": "1.0.6",
+    "donna": "1.0.7",
     "formidable": "~1.0.14",
     "fs-plus": "2.x",
     "github-releases": "~0.2.0",
     "grunt": "~0.4.1",
+    "grunt-atom-shell-installer": "^0.10.0",
     "grunt-cli": "~0.1.9",
     "grunt-coffeelint": "git+https://github.com/atom/grunt-coffeelint.git#cfb99aa99811d52687969532bd5a98011ed95bfe",
     "grunt-contrib-coffee": "~0.9.0",
@@ -20,17 +21,13 @@
     "grunt-cson": "0.10.0",
     "grunt-download-atom-shell": "~0.10.0",
     "grunt-lesslint": "0.13.0",
-    "grunt-markdown": "~0.4.0",
     "grunt-peg": "~1.1.0",
     "grunt-shell": "~0.3.1",
     "harmony-collections": "~0.3.8",
-    "json-front-matter": "~0.1.3",
-    "legal-eagle": "~0.4.0",
+    "legal-eagle": "~0.6.0",
     "minidump": "~0.8",
-    "normalize-package-data": "0.2.12",
     "npm": "~1.4.5",
-    "rcedit": "~0.1.2",
-    "read-package-json": "1.1.8",
+    "rcedit": "~0.3.0",
     "request": "~2.27.0",
     "rimraf": "~2.2.2",
     "runas": "~1.0.1",

build/tasks/build-task.coffee

@@ -11,6 +11,7 @@ module.exports = (grunt) ->
     appDir = grunt.config.get('atom.appDir')
 
     rm shellAppDir
+    rm path.join(buildDir, 'installer')
     mkdir path.dirname(buildDir)
 
     if process.platform is 'darwin'

build/tasks/check-licenses-task.coffee

@@ -1,4 +1,3 @@
-
 module.exports = (grunt) ->
   grunt.registerTask 'check-licenses', 'Report the licenses of all dependencies', ->
     legalEagle = require 'legal-eagle'
@@ -13,7 +12,7 @@ module.exports = (grunt) ->
     legalEagle options, (err, summary) ->
       if err?
         console.error(err)
-        exit 1
+        process.exit 1
 
       for key of summary
         delete summary[key] if key.match /^atom@/

build/tasks/codesign-task.coffee

@@ -36,7 +36,7 @@ module.exports = (grunt) ->
           spawn {cmd, args}, (error) ->
             return callback(error) if error?
 
-            setupExePath = path.join(grunt.config.get('atom.shellAppDir'), '..', 'Releases', 'setup.exe')
+            setupExePath = path.resolve(grunt.config.get('atom.buildDir'), 'installer', 'AtomSetup.exe')
             if fs.isFileSync(setupExePath)
               args = [setupExePath]
               spawn {cmd, args}, (error) -> callback(error)

build/tasks/create-installer.coffee

@@ -1,46 +0,0 @@
-fs = require 'fs'
-path = require 'path'
-_ = require 'underscore-plus'
-
-module.exports = (grunt) ->
-  {spawn, rm} = require('./task-helpers')(grunt)
-
-  grunt.registerTask 'create-installer', 'Create the Windows installer', ->
-    return unless process.platform is 'win32'
-
-    done = @async()
-
-    buildDir = grunt.config.get('atom.buildDir')
-    atomDir = path.join(buildDir, 'Atom')
-    releasesDir = path.join(buildDir, 'Releases')
-    atomGitHubToken = process.env.ATOM_ACCESS_TOKEN
-
-    packageInfo = grunt.file.readJSON(path.join(atomDir, 'resources', 'app', 'package.json'))
-    inputTemplate = grunt.file.read(path.join('build', 'windows', 'atom.nuspec.erb'))
-
-    # NB: Build server has some sort of stamp on the version number
-    packageInfo.version = packageInfo.version.replace(/-.*$/, '')
-
-    targetNuspecPath = path.join(buildDir, 'atom.nuspec')
-    grunt.file.write(targetNuspecPath, _.template(inputTemplate, packageInfo))
-
-    # We use the previous releases to build deltas for the current release,
-    # sync down the existing releases directory by rolling through GitHub releases
-    cmd = 'build/windows/SyncGitHubReleases.exe'
-    args = ['-r', releasesDir, '-u', 'https://github.com/atom/atom', '-t', atomGitHubToken]
-
-    spawn {cmd, args}, (error, result, code) ->
-      if error?
-        grunt.log.error "ATOM_ACCESS_TOKEN environment variable not set or invalid, can't download old releases; continuing anyways"
-
-      cmd = 'build/windows/nuget.exe'
-      args = ['pack', targetNuspecPath, '-BasePath', atomDir, '-OutputDirectory', buildDir]
-
-      spawn {cmd, args}, (error, result, code) ->
-        return done(error) if error?
-
-        pkgs = pkg for pkg in fs.readdirSync(buildDir) when path.extname(pkg) is '.nupkg'
-
-        cmd = 'build/windows/update.com'
-        args = ['--releasify', path.join(buildDir, pkgs), '-r', releasesDir, '-g', 'build/windows/install-spinner.gif']
-        spawn {cmd, args}, (error, result, code) -> done(error)

build/tasks/docs-task.coffee

@@ -6,12 +6,17 @@ _ = require 'underscore-plus'
 donna = require 'donna'
 tello = require 'tello'
 
+moduleBlacklist = [
+  'space-pen'
+]
+
 module.exports = (grunt) ->
   getClassesToInclude = ->
     modulesPath = path.resolve(__dirname, '..', '..', 'node_modules')
     classes = {}
     fs.traverseTreeSync modulesPath, (modulePath) ->
       return false if modulePath.match(/node_modules/g).length > 1 # dont need the dependencies of the dependencies
+      return false if path.basename(modulePath) in moduleBlacklist
       return true unless path.basename(modulePath) is 'package.json'
       return true unless fs.isFileSync(modulePath)
 

build/tasks/publish-build-task.coffee

@@ -54,6 +54,11 @@ module.exports = (gruntObject) ->
           uploadAssets(release, buildDir, assets, done)
 
 getAssets = ->
+  {cp} = require('./task-helpers')(grunt)
+
+  {version} = grunt.file.readJSON('package.json')
+  buildDir = grunt.config.get('atom.buildDir')
+
   switch process.platform
     when 'darwin'
       [
@@ -62,16 +67,16 @@ getAssets = ->
         {assetName: 'atom-api.json', sourcePath: 'atom-api.json'}
       ]
     when 'win32'
-      [
-        {assetName: 'atom-windows.zip', sourcePath: 'Atom'}
-      ]
+      assets = [{assetName: 'atom-windows.zip', sourcePath: 'Atom'}]
+      for squirrelAsset in ['AtomSetup.exe', 'RELEASES', "atom-#{version}-full.nupkg"]
+        cp path.join(buildDir, 'installer', squirrelAsset), path.join(buildDir, squirrelAsset)
+        assets.push({assetName: squirrelAsset, sourcePath: assetName})
+      assets
     when 'linux'
-      buildDir = grunt.config.get('atom.buildDir')
       if process.arch is 'ia32'
         arch = 'i386'
       else
         arch = 'amd64'
-      {version} = grunt.file.readJSON('package.json')
 
       # Check for a Debian build
       sourcePath = "#{buildDir}/atom-#{version}-#{arch}.deb"
@@ -87,7 +92,6 @@ getAssets = ->
           arch = 'x86_64'
         assetName = "atom.#{arch}.rpm"
 
-      {cp} = require('./task-helpers')(grunt)
       cp sourcePath, path.join(buildDir, assetName)
 
       [

build/windows/atom.nuspec.erb

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

docs/README.md

@@ -1,60 +1,5 @@
-# Welcome to the Atom API Documentation
+# Welcome to the Atom Docs
 
 ![Atom](https://cloud.githubusercontent.com/assets/72919/2874231/3af1db48-d3dd-11e3-98dc-6066f8bc766f.png)
 
-## FAQ
-
-### Where do I start?
-
-Check out [EditorView][EditorView] and [Editor][Editor] classes for a good
-overview of the main editor API.
-
-### How do I access these classes?
-
-Check out the [Atom][Atom] class docs to see what globals are available and
-what they provide.
-
-You can also require many of these classes in your package via:
-
-```coffee
-{EditorView} = require 'atom'
-```
-
-The classes available from `require 'atom'` are:
-  * [BufferedProcess][BufferedProcess]
-  * [BufferedNodeProcess][BufferedNodeProcess]
-  * [EditorView][EditorView]
-  * [Git][Git]
-  * [Point][Point]
-  * [Range][Range]
-  * [ScrollView][ScrollView]
-  * [SelectListView][SelectListView]
-  * [View][View]
-  * [WorkspaceView][WorkspaceView]
-  * [Workspace][Workspace]
-
-### How do I create a package?
-
-You probably want to read the [creating a package][creating-a-package]
-doc first and come back here when you are done.
-
-### Where are the node docs?
-
-Atom ships with node 0.11.10 and the comprehensive node API docs are available
-[here][node-docs].
-
-[Atom]: ../classes/Atom.html
-[BufferedProcess]: ../classes/BufferedProcess.html
-[BufferedNodeProcess]: ../classes/BufferedNodeProcess.html
-[Editor]: ../classes/Editor.html
-[EditorView]: ../classes/EditorView.html
-[Git]: ../classes/Git.html
-[Point]: ../classes/Point.html
-[Range]: ../classes/Range.html
-[ScrollView]: ../classes/ScrollView.html
-[SelectListView]: ../classes/SelectListView.html
-[View]: ../classes/View.html
-[WorkspaceView]: ../classes/WorkspaceView.html
-[Workspace]: ../classes/Workspace.html
-[creating-a-package]: https://atom.io/docs/latest/creating-a-package
-[node-docs]: http://nodejs.org/docs/v0.11.10/api
+TODO: Write when docs move to a dedicated repo.

docs/advanced/configuration.md

@@ -11,32 +11,34 @@ value of a namespaced config key with `atom.config.get`:
 @showInvisibles() if atom.config.get "editor.showInvisibles"
 ```
 
-Or you can use the `::subscribe` with `atom.config.observe` to track changes
-from any view object.
+Or you can subscribe via `atom.config.observe` to track changes from any view
+object.
 
 ```coffeescript
+{View} = require 'space-pen'
+
 class MyView extends View
-  initialize: ->
-    @subscribe atom.config.observe 'editor.fontSize', (newValue, {previous}) =>
-      @adjustFontSize()
+  attached: ->
+    @fontSizeObserveSubscription =
+      atom.config.observe 'editor.fontSize', (newValue, {previous}) =>
+        @adjustFontSize()
+
+  detached: ->
+    @fontSizeObserveSubscription.dispose()
 ```
 
 The `atom.config.observe` method will call the given callback immediately with
 the current value for the specified key path, and it will also call it in the
-future whenever the value of that key path changes.
+future whenever the value of that key path changes. If you only want to invoke
+the callback when the next time the value changes, use `atom.config.onDidChange`
+instead.
 
-Subscriptions made with `::subscribe` are automatically canceled when the
-view is removed. You can cancel config subscriptions manually via the
-`off` method on the subscription object that `atom.config.observe` returns.
-
-```coffeescript
-fontSizeSubscription = atom.config.observe 'editor.fontSize', (newValue, {previous}) =>
-  @adjustFontSize()
-
-# ... later on
-
-fontSizeSubscription.off() # Stop observing
-```
+Subscription methods return *disposable* subscription objects. Note in the
+example above how we save the subscription to the `@fontSizeObserveSubscription`
+instance variable and dispose of it when the view is detached. To group multiple
+subscriptions together, you can add them all to a
+[`CompositeDisposable`][composite-disposable] that you dispose when the view is
+detached.
 
 ### Writing Config Settings
 
@@ -48,10 +50,9 @@ but you can programmatically write to it with `atom.config.set`:
 atom.config.set("core.showInvisibles", true)
 ```
 
-You can also use `setDefaults`, which will assign default values for keys that
-are always overridden by values assigned with `set`. Defaults are not written
-out to the the `config.json` file to prevent it from becoming cluttered.
+If you're exposing package configuration via specific key paths, you'll want to
+associate them with a schema in your package's main module. Read more about
+schemas in the [config API docs][config-api].
 
-```coffeescript
-atom.config.setDefaults("editor", fontSize: 18, showInvisibles: true)
-```
+[composite-disposable]: https://atom.io/docs/api/latest/CompositeDisposable
+[config-api]: https://atom.io/docs/api/latest/Config

docs/advanced/globals.md

@@ -1,34 +0,0 @@
-# Globals
-
-Atom exposes several services through singleton objects accessible via the
-`atom` global:
-
-* atom
-  * workspace:
-      Manipulate and query the state of the user interface for the current
-      window. Open editors, manipulate panes.
-  * workspaceView:
-      Similar to workspace, but provides access to the root of all views in the
-      current window.
-  * project:
-      Access the directory associated with the current window. Load editors,
-      perform project-wide searches, register custom openers for special file
-      types.
-  * config:
-      Read, write, and observe user configuration settings.
-  * keymap:
-      Add and query the currently active keybindings.
-  * deserializers:
-      Deserialize instances from their state objects and register deserializers.
-  * packages:
-      Activate, deactivate, and query user packages.
-  * themes:
-      Activate, deactivate, and query user themes.
-  * contextMenu:
-      Register context menus.
-  * menu:
-      Register application menus.
-  * pasteboard:
-      Read from and write to the system pasteboard.
-  * syntax:
-      Assign and query syntactically-scoped properties.

docs/advanced/keymaps.md

@@ -16,7 +16,7 @@ keystrokes pass through `atom-text-editor` elements:
   'ctrl-shift-e': 'editor:select-to-end-of-line'
   'cmd-left': 'editor:move-to-first-character-of-line'
 
-'atom-text-editor:not(.mini)'
+'atom-text-editor:not([mini])'
   'cmd-alt-[': 'editor:fold-current-row'
   'cmd-alt-]': 'editor:unfold-current-row'
 ```
@@ -27,8 +27,8 @@ patterns* to *commands*. When an element with the `atom-text-editor` class is fo
 `editor:delete-to-beginning-of-line` is emitted on the `atom-text-editor` element.
 
 The second selector group also targets editors, but only if they don't have the
-`.mini` class. In this example, the commands for code folding don't really make
-sense on mini-editors, so the selector restricts them to regular editors.
+`mini` attribute. In this example, the commands for code folding don't really
+make sense on mini-editors, so the selector restricts them to regular editors.
 
 ### Keystroke Patterns
 

docs/advanced/view-system.md

@@ -1,58 +0,0 @@
-## Atom's View System
-
-### SpacePen Basics
-
-Atom's view system is built around the [SpacePen] view framework. SpacePen
-view objects inherit from the jQuery prototype, and wrap DOM nodes
-
-View objects are actually jQuery wrappers around DOM fragments, supporting all
-the typical jQuery traversal and manipulation methods. In addition, view objects
-have methods that are view-specific. For example, you could call both general
-and view-specific on the global `atom.workspaceView` instance:
-
-```coffeescript
-atom.workspaceView.find('atom-text-editor.active') # standard jQuery method
-atom.workspaceView.getActiveEditor()      # view-specific method
-```
-
-If you retrieve a jQuery wrapper for an element associated with a view, use the
-`.view()` method to retrieve the element's view object:
-
-```coffeescript
-# this is a plain jQuery object; you can't call view-specific methods
-editorElement = atom.workspaceView.find('atom-text-editor.active')
-
-# get the view object by calling `.view()` to call view-specific methods
-editorView = editorElement.view()
-editorView.setCursorBufferPosition([1, 2])
-```
-
-Refer to the [SpacePen] documentation for more details.
-
-### WorkspaceView
-
-The root of Atom's view hierarchy is a global called `atom.workspaceView`, which is a
-singleton instance of the `WorkspaceView` view class. The root view fills the entire
-window, and contains every other view. If you open Atom's inspector with
-`alt-cmd-i`, you can see the internal structure of `WorkspaceView`:
-
-![WorkspaceView in the inspector][workspaceview-inspector]
-
-#### Panes
-
-The `WorkspaceView` contains `prependToBottom/Top/Left/Right` and
-`appendToBottom/Top/Left/Right` methods, which are used to add Tool Panels. Tool
-panels are elements that take up screen real estate not devoted to text editing.
-In the example above, the `TreeView` is appended to the left, and the
-`CommandPanel` is appended to the top.
-
-```coffeescript
-# place a view to the left of the panes
-atom.workspaceView.appendToLeft(new MyView)
-
-# place a view below the panes
-atom.workspaceView.appendToBottom(new MyOtherView)
-```
-
-[spacepen]: http://github.com/nathansobo/space-pen
-[workspaceView-inspector]: https://f.cloud.github.com/assets/1424/1091631/1932c2d6-166b-11e3-8adf-9690fe82d3b8.png

docs/apm-rest-api.md

@@ -30,6 +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`)
 
 Returns a list of all packages in the following format:
 ```json
@@ -57,6 +59,20 @@ Link: <https://www.atom.io/api/packages?page=1>; rel="self",
       <https://www.atom.io/api/packages?page=2>; rel="next"
 ```
 
+By default, results are sorted by download count, descending.
+
+#### GET /api/packages/search
+
+Parameters:
+
+- **q** String query to search
+- **sort** (optional, values: `created_at`, `updated_at`, `downloads`)
+- **direction** (optional, values: `asc`, `desc`)
+
+Returns a list of all packages in the same format as `/api/packages`.
+
+By default, results sorted by relevance to search query.
+
 ### Showing package details
 
 #### GET /api/packages/:package_name

docs/build-instructions/linux.md

@@ -43,7 +43,7 @@ If you have problems with permissions don't forget to prefix with `sudo`
 2. Checkout the latest Atom release:
 
   ```sh
-  git fetch
+  git fetch -p
   git checkout $(git describe --tags `git rev-list --tags --max-count=1`)
   ```
 

docs/creating-a-package.md

@@ -40,7 +40,7 @@ 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
-stylesheets your package needs to load. If not specified, stylesheets in the
+style sheets your package needs to load. If not specified, style sheets in the
 _stylesheets_ 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
@@ -119,27 +119,27 @@ Also, please collaborate with us if you need an API that doesn't exist. Our goal
 is to build out Atom's API organically based on the needs of package authors
 like you.
 
-## Stylesheets
+## Style Sheets
 
-Stylesheets for your package should be placed in the _stylesheets_ directory.
-Any stylesheets in this directory will be loaded and attached to the DOM when
-your package is activated. Stylesheets can be written as CSS or [LESS] (but LESS
-is recommended).
+Style sheets for your package should be placed in the _stylesheets_ 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).
 
 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
-that fits into Atom seamlessly. You can view all of Atom's UI components by opening
-the styleguide: open the command palette (`cmd-shift-P`) and search for _styleguide_,
-or just type `cmd-ctrl-shift-G`.
+that fits into Atom seamlessly. You can view all of Atom's UI components by
+opening the styleguide: open the command palette (`cmd-shift-P`) and search for
+_styleguide_, or just type `cmd-ctrl-shift-G`.
 
-If you _do_ need special styling, try to keep only structural styles in the package
-stylesheets. If you _must_ specify colors and sizing, these should be 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!
+If you _do_ need special styling, try to keep only structural styles in the
+package style sheets. If you _must_ specify colors and sizing, these should be
+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 stylesheets
-by name to specify a loading order; otherwise, stylesheets are loaded
+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.
 
 ## Keymaps
@@ -157,9 +157,9 @@ loaded in alphabetical order. An optional `keymaps` array in your _package.json_
 can specify which keymaps to load and in what order.
 
 
-Keybindings are executed by determining which element the keypress occurred on. In
-the example above, `changer:magic` command is executed when pressing `ctrl-V` on
-the `.tree-view-scroller` element.
+Keybindings are executed by determining which element the keypress occurred on.
+In the example above, `changer:magic` command is executed when pressing `ctrl-V`
+on the `.tree-view-scroller` element.
 
 See the [main keymaps documentation][keymaps] for more detailed information on
 how keymaps work.
@@ -195,7 +195,8 @@ with your package that aren't tied to a specific element:
 ```
 
 To add your own item to the application menu, simply create a top level `menu`
-key in any menu configuration file in _menus_. This can be a JSON or [CSON] file.
+key in any menu configuration file in _menus_. This can be a JSON or [CSON]
+file.
 
 The menu templates you specify are merged with all other templates provided
 by other packages in the order which they were loaded.

docs/customizing-atom.md

@@ -63,7 +63,7 @@ built-in keymaps:
 'atom-text-editor':
   'enter': 'editor:newline'
 
-'atom-text-editor.mini input':
+'atom-text-editor[mini] input':
   'enter': 'core:confirm'
 ```
 
@@ -118,7 +118,6 @@ You can open this file in an editor from the _Atom > Open Your Config_ menu.
       - `cr`: Carriage return (for Microsoft-style line endings)
       - `eol`: `\n` characters
       - `space`: Leading and trailing space characters
-  - `normalizeIndentOnPaste`: Enable/disable conversion of pasted tabs to spaces
   - `preferredLineLength`: Identifies the length of a line (defaults to `80`)
   - `showInvisibles`: Whether to render placeholders for invisible characters (defaults to `false`)
   - `showIndentGuide`: Show/hide indent indicators within the editor

docs/index.md

@@ -18,5 +18,9 @@
 * [Developing Node Modules](advanced/node-modules.md)
 * [Keymaps](advanced/keymaps.md)
 * [Serialization](advanced/serialization.md)
-* [View System](advanced/view-system.md)
 * [Scopes and Scope Descriptors](advanced/scopes-and-scope-descriptors.md)
+
+### Upgrading to 1.0 APIs
+
+* [Upgrading Your UI Theme Or Package Selectors](upgrading/upgrading-your-ui-theme.md)
+* [Upgrading Your Syntax Theme](upgrading/upgrading-your-syntax-theme.md)

docs/template.jst

@@ -1,150 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-
-    <link href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css" rel="stylesheet">
-    <link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap-theme.min.css">
-    <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
-    <!--[if lt IE 9]>
-      <script src="../../assets/js/html5shiv.js"></script>
-      <script src="../../assets/js/respond.min.js"></script>
-    <![endif]-->
-
-    <title>Atom - <%= title %></title>
-    <style>
-      /*github.com style (c) Vasily Polovnyov <vast@whiteants.net>*/
-      pre code {
-        display: block; padding: 0.5em;
-        color: #333;
-        background: #f8f8ff
-      }
-      pre .comment,
-      pre .template_comment,
-      pre .diff .header,
-      pre .javadoc {
-        color: #998;
-        font-style: italic
-      }
-      pre .keyword,
-      pre .css .rule .keyword,
-      pre .winutils,
-      pre .javascript .title,
-      pre .nginx .title,
-      pre .subst,
-      pre .request,
-      pre .status {
-        color: #333;
-        font-weight: bold
-      }
-      pre .number,
-      pre .hexcolor,
-      pre .ruby .constant {
-        color: #099;
-      }
-      pre .string,
-      pre .tag .value,
-      pre .phpdoc,
-      pre .tex .formula {
-        color: #d14
-      }
-      pre .title,
-      pre .id {
-        color: #900;
-        font-weight: bold
-      }
-      pre .javascript .title,
-      pre .lisp .title,
-      pre .clojure .title,
-      pre .subst {
-        font-weight: normal
-      }
-      pre .class .title,
-      pre .haskell .type,
-      pre .vhdl .literal,
-      pre .tex .command {
-        color: #458;
-        font-weight: bold
-      }
-      pre .tag,
-      pre .tag .title,
-      pre .rules .property,
-      pre .django .tag .keyword {
-        color: #000080;
-        font-weight: normal
-      }
-      pre .attribute,
-      pre .variable,
-      pre .lisp .body {
-        color: #008080
-      }
-      pre .regexp {
-        color: #009926
-      }
-      pre .class {
-        color: #458;
-        font-weight: bold
-      }
-      pre .symbol,
-      pre .ruby .symbol .string,
-      pre .lisp .keyword,
-      pre .tex .special,
-      pre .prompt {
-        color: #990073
-      }
-      pre .built_in,
-      pre .lisp .title,
-      pre .clojure .built_in {
-        color: #0086b3
-      }
-      pre .preprocessor,
-      pre .pi,
-      pre .doctype,
-      pre .shebang,
-      pre .cdata {
-        color: #999;
-        font-weight: bold
-      }
-      pre .deletion {
-        background: #fdd
-      }
-      pre .addition {
-        background: #dfd
-      }
-      pre .diff .change {
-        background: #0086b3
-      }
-      pre .chunk {
-        color: #aaa
-      }
-
-      body {
-        padding-top: 50px;
-      }
-    </style>
-  </head>
-  <body>
-   <div class="navbar navbar-inverse navbar-fixed-top">
-      <div class="container">
-        <div class="navbar-header">
-          <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
-            <span class="icon-bar"></span>
-            <span class="icon-bar"></span>
-            <span class="icon-bar"></span>
-          </button>
-          <a class="navbar-brand" href="/<%= tag %>/index.html">Atom Documentation</a>
-        </div>
-        <div class="collapse navbar-collapse">
-          <ul class="nav navbar-nav">
-            <li><a href="/docs/api/<%= tag %>/api/index.html">API</a></li>
-          </ul>
-        </div><!--/.nav-collapse -->
-      </div>
-    </div>
-
-    <div class="container">
-      <%= content %>
-    </div>
-  </body>
-</html>

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

@@ -0,0 +1,27 @@
+# Upgrading Your Syntax Theme
+
+Text editor content is now rendered in the shadow DOM, which shields it from being styled by global style sheets to protect against accidental style pollution. For more background on the shadow DOM, check out the [Shadow DOM 101][shadow-dom-101] on HTML 5 Rocks.
+
+Syntax themes are specifically intended to style only text editor content, so they are automatically loaded directly into the text editor's shadow DOM when it is enabled. This happens automatically when the the theme's `package.json` contains a `theme: "syntax"` declaration, so you don't need to change anything to target the appropriate context.
+
+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.
+
+```css
+.editor-colors, :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... */
+}
+```
+
+[shadow-dom-101]: http://www.html5rocks.com/en/tutorials/webcomponents/shadowdom
+[host-pseudo-element]: http://www.html5rocks.com/en/tutorials/webcomponents/shadowdom-201#toc-style-host

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

@@ -0,0 +1,137 @@
+# 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.
+
+## Deprecation Cop
+
+Deprecation cop will list usages of deprecated selector patterns to guide you. You can access it via the command palette (`cmd-shift-p`, then search for `Deprecation`). It breaks the deprecations down by package:
+
+![dep-cop](https://cloud.githubusercontent.com/assets/69169/5078860/d38a5df4-6e64-11e4-95b6-eb585ee9bbfc.png)
+
+## Custom Tags
+
+Rather than adding classes to standard HTML elements to indicate their role, Atom now uses custom element names. For example, `<div class="workspace">` has now been replaced with `<atom-workspace>`. Selectors should be updated accordingly. Note that tag names have lower specificity than classes in CSS, so you'll need to take care in converting things.
+
+Old Selector        | New Selector
+--------------------|--------------------------------
+`.editor`           | `atom-text-editor`
+`.editor.mini`      | `atom-text-editor[mini]`
+`.workspace`        | `atom-workspace`
+`.horizontal`       | `atom-workspace-axis.horizontal`
+`.vertical`         | `atom-workspace-axis.vertical`
+`.pane-container`   | `atom-pane-conatiner`
+`.pane`             | `atom-pane`
+`.tool-panel`       | `atom-panel`
+`.panel-top`        | `atom-panel.top`
+`.panel-bottom`     | `atom-panel.bottom`
+`.panel-left`       | `atom-panel.left`
+`.panel-right`      | `atom-panel.right`
+`.overlay`          | `atom-panel.modal`
+
+## Supporting the Shadow DOM
+
+Text editor content is now rendered in the shadow DOM, which shields it from being styled by global style sheets to protect against accidental style pollution. For more background on the shadow DOM, check out the [Shadow DOM 101][shadow-dom-101] on HTML 5 Rocks. If you need to style text editor content in a UI theme, you'll need to circumvent this protection for any rules that target the text editor's content. Some examples of the kinds of UI theme styles needing to be updated:
+
+* Highlight decorations
+* Gutter decorations
+* Line decorations
+* Scrollbar styling
+* Anything targeting a child selector of `.editor`
+
+During a transition phase, it will be possible to enable or disable the text editor's shadow DOM in the settings, so themes will need to be compatible with both approaches.
+
+### Shadow DOM Selectors
+
+Chromium provides two tools for bypassing shadow boundaries, the `::shadow` pseudo-element and the `/deep/` combinator. For an in-depth explanation of styling the shadow DOM, see the [Shadow DOM 201][shadow-dom-201] article on HTML 5 Rocks.
+
+#### ::shadow
+
+The `::shadow` pseudo-element allows you to bypass a single shadow root. For example, say you want to update a highlight decoration for a linter package. Initially, the style looks as follows:
+
+```css
+// Without shadow DOM support
+atom-text-editor .highlight.my-linter {
+  background: hotpink;
+}
+```
+
+In order for this style to apply with the shadow DOM enabled, you will need to add a second selector with the `::shadow` pseudo-element. You should leave the original selector in place so your theme continues to work with the shadow DOM disabled during the transition period.
+
+```css
+// With shadow DOM support
+atom-text-editor .highlight.my-linter,
+atom-text-editor::shadow .highlight.my-linter {
+  background: hotpink;
+}
+```
+
+Check out the [find-and-replace][find-and-replace] package for another example of using `::shadow` to pierce the shadow DOM.
+
+#### /deep/
+
+The `/deep/` combinator overrides *all* shadow boundaries, making it useful for rules you want to apply globally such as scrollbar styling. Here's a snippet containing scrollbar styling for the Atom Dark UI theme before shadow DOM support:
+
+```css
+// Without shadow DOM support
+.scrollbars-visible-always {
+  ::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+  }
+
+  ::-webkit-scrollbar-track,
+  ::-webkit-scrollbar-corner {
+    background: @scrollbar-background-color;
+  }
+
+  ::-webkit-scrollbar-thumb {
+    background: @scrollbar-color;
+    border-radius: 5px;
+    box-shadow: 0 0 1px black inset;
+  }
+}
+```
+
+To style scrollbars even inside of the shadow DOM, each rule needs to be prefixed with `/deep/`. We use `/deep/` instead of `::shadow` because we don't care about the selector of the host element in this case. We just want our styling to apply everywhere.
+
+```css
+// With shadow DOM support using /deep/
+.scrollbars-visible-always {
+  /deep/ ::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+  }
+
+  /deep/ ::-webkit-scrollbar-track,
+  /deep/ ::-webkit-scrollbar-corner {
+    background: @scrollbar-background-color;
+  }
+
+  /deep/ ::-webkit-scrollbar-thumb {
+    background: @scrollbar-color;
+    border-radius: 5px;
+    box-shadow: 0 0 1px black inset;
+  }
+}
+```
+
+### Context-Targeted Style Sheets
+
+The selector features discussed above allow you to target shadow DOM content with specific selectors, but Atom also allows you to target a specific shadow DOM context with an entire style sheet. The context into which a style sheet is loaded is based on the file name. If you want to load a style sheet into the editor, name it with the `.atom-text-editor.less` or `.atom-text-editor.css` extensions.
+
+```
+my-ui-theme/
+  stylesheets/
+    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.
+
+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.
+
+During the transition phase, style sheets targeting the `atom-text-editor` context will *also* be loaded globally. Make sure you update your selectors in a way that maintains compatibility with the shadow DOM being disabled. That means if you use a `::host` pseudo element, you should also include the same style rule matches against `atom-text-editor`.
+
+[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

docs/your-first-package.md

@@ -49,7 +49,7 @@ Register the command in _lib/ascii-art.coffee_:
 ```coffeescript
 module.exports =
   activate: ->
-    atom.workspaceView.command "ascii-art:convert", => @convert()
+    atom.commands.add 'atom-workspace', "ascii-art:convert", => @convert()
 
   convert: ->
     # This assumes the active pane item is an editor
@@ -57,10 +57,10 @@ module.exports =
     editor.insertText('Hello, World!')
 ```
 
-The `atom.workspaceView.command` method takes a command name and a callback. The
-callback executes when the command is triggered. In this case, when the command
-is triggered the callback will call the `convert` method and insert 'Hello,
-World!'.
+The `atom.commands.add` method takes a selector, command name, and a callback.
+The callback executes when the command is triggered on an element matching the
+selector. In this case, when the command is triggered the callback will call the
+`convert` method and insert 'Hello, World!'.
 
 ## Reload the Package
 
@@ -95,13 +95,13 @@ you don't need it anymore. When finished, the file will look like this:
   'cmd-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 `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.
+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
+`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.
 
 Now reload the window and verify that the key binding works! You can also verify
 that it **doesn't** work when the Tree View is focused.

exports/atom.coffee

@@ -1,35 +1,127 @@
 {Point, Range} = require 'text-buffer'
+{Emitter, Disposable, CompositeDisposable} = require 'event-kit'
 {deprecate} = require 'grim'
 
 module.exports =
   BufferedNodeProcess: require '../src/buffered-node-process'
   BufferedProcess: require '../src/buffered-process'
   GitRepository: require '../src/git-repository'
+  Notification: require '../src/notification'
   Point: Point
   Range: Range
+  Emitter: Emitter
+  Disposable: Disposable
+  CompositeDisposable: CompositeDisposable
 
 # The following classes can't be used from a Task handler and should therefore
 # only be exported when not running as a child node process
 unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
+  module.exports.Task = require '../src/task'
+  module.exports.TextEditor = require '../src/text-editor'
+
   {$, $$, $$$, View} = require '../src/space-pen-extensions'
 
-  module.exports.$ = $
-  module.exports.$$ = $$
-  module.exports.$$$ = $$$
-  module.exports.TextEditorView = require '../src/text-editor-view'
-  module.exports.ScrollView = require '../src/scroll-view'
-  module.exports.SelectListView = require '../src/select-list-view'
-  module.exports.Task = require '../src/task'
-  module.exports.View = View
-  module.exports.WorkspaceView = require '../src/workspace-view'
-  module.exports.Workspace = require '../src/workspace'
-  module.exports.React = require 'react-atom-fork'
-  module.exports.Reactionary = require 'reactionary-atom-fork'
+  Object.defineProperty module.exports, 'Workspace', get: ->
+    deprecate """
+      Requiring `Workspace` from `atom` is no longer supported.
+      If you need this, please open an issue on
+      https://github.com/atom/atom/issues/new
+      And let us know what you are using it for.
+    """
+    require '../src/workspace'
+
+  Object.defineProperty module.exports, 'WorkspaceView', get: ->
+    deprecate """
+      Requiring `WorkspaceView` from `atom` is no longer supported.
+      Use `atom.views.getView(atom.workspace)` instead.
+    """
+    require '../src/workspace-view'
+
+  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'`
+        or
+        `$ = require 'jquery'`
+      Add `"space-pen": "^4"` to your package dependencies.
+      Or add `"jquery": "^2"` 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.
+    """
+    $$
+
+  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.
+    """
+    $$$
+
+  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.
+    """
+    View
+
+  Object.defineProperty module.exports, 'EditorView', get: ->
+    deprecate """
+      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.
+    """
+    require '../src/text-editor-view'
+
+  Object.defineProperty module.exports, 'TextEditorView', get: ->
+    deprecate """
+      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.
+    """
+    require '../src/text-editor-view'
+
+  Object.defineProperty module.exports, 'ScrollView', get: ->
+    deprecate """
+      Requiring `ScrollView` from `atom` is no longer supported.
+      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.
+    """
+    require '../src/scroll-view'
+
+  Object.defineProperty module.exports, 'SelectListView', get: ->
+    deprecate """
+      Requiring `SelectListView` from `atom` is no longer supported.
+      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.
+    """
+    require '../src/select-list-view'
+
+  Object.defineProperty module.exports, 'React', get: ->
+    deprecate "Please require `react-atom-fork` instead: `React = require 'react-atom-fork'`. Add `\"react-atom-fork\": \"^0.11\"` to your package dependencies."
+    require 'react-atom-fork'
+
+  Object.defineProperty module.exports, 'Reactionary', get: ->
+    deprecate "Please require `reactionary-atom-fork` instead: `Reactionary = require 'reactionary-atom-fork'`. Add `\"reactionary-atom-fork\": \"^0.9\"` to your package dependencies."
+    require 'reactionary-atom-fork'
 
 Object.defineProperty module.exports, 'Git', get: ->
   deprecate "Please require `GitRepository` instead of `Git`: `{GitRepository} = require 'atom'`"
   module.exports.GitRepository
-
-Object.defineProperty module.exports, 'EditorView', get: ->
-  deprecate "Please require `TextEditorView` instead of `EditorView`: `{TextEditorView} = require 'atom'`"
-  module.exports.TextEditorView

keymaps/base.cson

@@ -5,7 +5,7 @@
   'shift-home': 'editor:select-to-first-character-of-line'
   'shift-end': 'editor:select-to-end-of-line'
 
-'atom-text-editor:not(.mini)':
+'atom-text-editor:not([mini])':
   # Atom Specific
   'ctrl-C': 'editor:copy-path'
 
@@ -15,13 +15,13 @@
   'shift-tab': 'editor:outdent-selected-rows'
   'ctrl-K': 'editor:delete-line'
 
-'.select-list atom-text-editor.mini':
+'.select-list atom-text-editor[mini]':
   'enter': 'core:confirm'
 
 '.tool-panel.panel-left, .tool-panel.panel-right':
   'escape': 'tool-panel:unfocus'
 
-'atom-text-editor !important, atom-text-editor.mini !important':
+'atom-text-editor !important, atom-text-editor[mini] !important':
   'escape': 'editor:consolidate-selections'
 
 # allow standard input fields to work correctly

keymaps/darwin.cson

@@ -112,7 +112,7 @@
   # Apple Specific
   'cmd-backspace': 'editor:delete-to-beginning-of-line'
   'cmd-shift-backspace': 'editor:delete-to-beginning-of-line'
-  'cmd-delete': 'editor:delete-to-beginning-of-line'
+  'cmd-delete': 'editor:delete-to-end-of-line'
   'ctrl-A': 'editor:select-to-first-character-of-line'
   'ctrl-E': 'editor:select-to-end-of-line'
   'cmd-left': 'editor:move-to-first-character-of-line'
@@ -136,7 +136,7 @@
   'cmd-l': 'editor:select-line'
   'ctrl-t': 'editor:transpose'
 
-'atom-workspace atom-text-editor:not(.mini)':
+'atom-workspace atom-text-editor:not([mini])':
   # Atom specific
   'alt-cmd-z': 'editor:checkout-head-revision'
   'cmd-<': 'editor:scroll-to-cursor'

keymaps/linux.cson

@@ -101,7 +101,7 @@
   'ctrl-k ctrl-l': 'editor:lower-case'
   'ctrl-l': 'editor:select-line'
 
-'atom-workspace atom-text-editor:not(.mini)':
+'atom-workspace atom-text-editor:not([mini])':
   # Atom specific
   'alt-ctrl-z': 'editor:checkout-head-revision'
   'ctrl-<': 'editor:scroll-to-cursor'

keymaps/win32.cson

@@ -98,7 +98,7 @@
   'ctrl-k ctrl-l': 'editor:lower-case'
   'ctrl-l': 'editor:select-line'
 
-'atom-workspace atom-text-editor:not(.mini)':
+'atom-workspace atom-text-editor:not([mini])':
   # Atom specific
   'alt-ctrl-z': 'editor:checkout-head-revision'
   'ctrl-<': 'editor:scroll-to-cursor'

menus/linux.cson

@@ -94,6 +94,7 @@
     submenu: [
       { label: '&Reload', command: 'window:reload' }
       { label: 'Toggle &Full Screen', command: 'window:toggle-full-screen' }
+      { label: 'Toggle Menu Bar', command: 'window:toggle-menu-bar' }
       {
         label: 'Developer'
         submenu: [

menus/win32.cson

@@ -93,6 +93,7 @@
     submenu: [
       { label: '&Reload', command: 'window:reload' }
       { label: 'Toggle &Full Screen', command: 'window:toggle-full-screen' }
+      { label: 'Toggle Menu Bar', command: 'window:toggle-menu-bar' }
       {
         label: 'Panes'
         submenu: [
@@ -162,7 +163,7 @@
     submenu: [
       { label: 'View &Terms of Use', command: 'application:open-terms-of-use' }
       { label: 'View &License', command: 'application:open-license' }
-      { label: "VERSION", enabled: false }
+      { label: 'VERSION', enabled: false }
       { type: 'separator' }
       { label: '&Documentation', command: 'application:open-documentation' }
       { label: 'Roadmap', command: 'application:open-roadmap' }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "atom",
   "productName": "Atom",
-  "version": "0.145.0",
+  "version": "0.153.0",
   "description": "A hackable text editor for the 21st Century.",
   "main": "./src/browser/main.js",
   "repository": {
@@ -17,10 +17,10 @@
       "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
     }
   ],
-  "atomShellVersion": "0.19.1",
+  "atomShellVersion": "0.19.4",
   "dependencies": {
     "async": "0.2.6",
-    "atom-keymap": "^2.2.2",
+    "atom-keymap": "^2.3.0",
     "bootstrap": "git+https://github.com/atom/bootstrap.git#6af81906189f1747fd6c93479e3d998ebe041372",
     "clear-cut": "0.4.0",
     "coffee-script": "1.7.0",
@@ -29,7 +29,7 @@
     "emissary": "^1.3.1",
     "event-kit": "0.7.2",
     "first-mate": "^2.2.0",
-    "fs-plus": "^2.3.1",
+    "fs-plus": "^2.3.2",
     "fstream": "0.1.24",
     "fuzzaldrin": "^2.1",
     "git-utils": "^2.1.5",
@@ -37,13 +37,15 @@
     "guid": "0.0.10",
     "jasmine-json": "~0.0",
     "jasmine-tagged": "^1.1.2",
-    "less-cache": "0.17.0",
+    "jquery": "^2.1.1",
+    "less-cache": "0.19.0",
+    "marked": "^0.3",
     "mixto": "^1",
     "mkdirp": "0.3.5",
     "nslog": "^1.0.1",
     "oniguruma": "^3.0.4",
     "optimist": "0.4.0",
-    "pathwatcher": "^2.3.2",
+    "pathwatcher": "2.3.2",
     "property-accessors": "^1",
     "q": "^1.0.1",
     "random-words": "0.0.1",
@@ -56,71 +58,72 @@
     "season": "^1.0.2",
     "semver": "2.2.1",
     "serializable": "^1",
-    "space-pen": "3.8.1",
+    "space-pen": "3.8.2",
     "temp": "0.7.0",
-    "text-buffer": "^3.6.0",
+    "text-buffer": "^3.7.2",
     "theorist": "^1.0.2",
     "underscore-plus": "^1.6.1",
     "vm-compatibility-layer": "0.1.0"
   },
   "packageDependencies": {
-    "atom-dark-syntax": "0.21.0",
-    "atom-dark-ui": "0.35.0",
-    "atom-light-syntax": "0.21.0",
-    "atom-light-ui": "0.30.0",
-    "base16-tomorrow-dark-theme": "0.21.0",
-    "base16-tomorrow-light-theme": "0.4.0",
-    "solarized-dark-syntax": "0.22.0",
-    "solarized-light-syntax": "0.12.0",
+    "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.23.0",
+    "solarized-light-syntax": "0.13.0",
     "archive-view": "0.37.0",
-    "autocomplete": "0.33.0",
+    "autocomplete": "0.33.1",
     "autoflow": "0.18.0",
     "autosave": "0.18.0",
     "background-tips": "0.17.0",
     "bookmarks": "0.30.0",
     "bracket-matcher": "0.62.0",
-    "command-palette": "0.27.0",
-    "deprecation-cop": "0.11.0",
+    "command-palette": "0.28.0",
+    "deprecation-cop": "0.18.0",
     "dev-live-reload": "0.35.0",
-    "encoding-selector": "0.7.0",
+    "encoding-selector": "0.8.0",
     "exception-reporting": "0.20.0",
-    "find-and-replace": "0.146.0",
+    "find-and-replace": "0.147.0",
     "fuzzy-finder": "0.60.0",
     "git-diff": "0.43.0",
     "go-to-line": "0.26.0",
     "grammar-selector": "0.37.0",
-    "image-view": "0.40.0",
+    "image-view": "0.42.0",
     "incompatible-packages": "0.10.0",
     "keybinding-resolver": "0.20.0",
     "link": "0.26.0",
     "markdown-preview": "0.110.0",
-    "metrics": "0.38.0",
+    "metrics": "0.39.0",
+    "notifications": "0.4.0",
     "open-on-github": "0.30.0",
     "package-generator": "0.32.0",
     "release-notes": "0.36.0",
-    "settings-view": "0.158.0",
-    "snippets": "0.56.0",
-    "spell-check": "0.43.0",
-    "status-bar": "0.46.0",
+    "settings-view": "0.161.0",
+    "snippets": "0.57.0",
+    "spell-check": "0.44.0",
+    "status-bar": "0.48.0",
     "styleguide": "0.30.0",
     "symbols-view": "0.68.0",
-    "tabs": "0.55.0",
+    "tabs": "0.56.0",
     "timecop": "0.23.0",
-    "tree-view": "0.132.0",
+    "tree-view": "0.134.0",
     "update-package-dependencies": "0.6.0",
     "welcome": "0.19.0",
     "whitespace": "0.26.0",
-    "wrap-guide": "0.23.0",
-    "language-c": "0.30.0",
-    "language-coffee-script": "0.37.0",
+    "wrap-guide": "0.24.0",
+    "language-c": "0.31.0",
+    "language-coffee-script": "0.38.0",
     "language-css": "0.23.0",
-    "language-gfm": "0.53.0",
+    "language-gfm": "0.54.0",
     "language-git": "0.9.0",
     "language-go": "0.19.0",
     "language-html": "0.26.0",
     "language-hyperlink": "0.12.0",
     "language-java": "0.11.0",
-    "language-javascript": "0.43.0",
+    "language-javascript": "0.45.0",
     "language-json": "0.8.0",
     "language-less": "0.18.0",
     "language-make": "0.12.0",
@@ -129,18 +132,18 @@
     "language-perl": "0.9.0",
     "language-php": "0.18.0",
     "language-property-list": "0.7.0",
-    "language-python": "0.23.0",
+    "language-python": "0.24.0",
     "language-ruby": "0.41.0",
     "language-ruby-on-rails": "0.18.0",
-    "language-sass": "0.25.0",
+    "language-sass": "0.26.0",
     "language-shellscript": "0.10.0",
     "language-source": "0.8.0",
     "language-sql": "0.11.0",
     "language-text": "0.6.0",
     "language-todo": "0.13.0",
     "language-toml": "0.14.0",
-    "language-xml": "0.24.0",
-    "language-yaml": "0.19.0"
+    "language-xml": "0.25.0",
+    "language-yaml": "0.20.0"
   },
   "private": true,
   "scripts": {

script/utils/child-process-wrapper.js

@@ -34,6 +34,9 @@ exports.safeSpawn = function(command, args, options, callback) {
   var child = childProcess.spawn(command, args, options);
   child.stderr.pipe(process.stderr);
   child.stdout.pipe(process.stdout);
+  child.on('error', function(error) {
+    console.error('Command \'' + command + '\' failed: ' + error.message);
+  });
   child.on('exit', function(code) {
     if (code != 0)
       process.exit(code);

spec/atom-reporter.coffee

@@ -3,6 +3,7 @@ _ = require 'underscore-plus'
 {convertStackTrace} = require 'coffeestack'
 {View, $, $$} = require '../src/space-pen-extensions'
 grim = require 'grim'
+marked = require 'marked'
 
 sourceMaps = {}
 formatStackTrace = (spec, message='', stackTrace) ->
@@ -110,7 +111,8 @@ class AtomReporter extends View
     for deprecation in deprecations
       @deprecationList.append $$ ->
         @div class: 'padded', =>
-          @div class: 'result-message fail deprecation-message', deprecation.message
+          @div class: 'result-message fail deprecation-message', =>
+            @raw marked(deprecation.message)
 
           for stack in deprecation.stacks
             fullStack = stack.map ({functionName, location}) ->

spec/atom-spec.coffee

@@ -5,9 +5,6 @@ Package = require '../src/package'
 ThemeManager = require '../src/theme-manager'
 
 describe "the `atom` global", ->
-  beforeEach ->
-    atom.workspaceView = atom.views.getView(atom.workspace).__spacePenView
-
   describe 'window sizing methods', ->
     describe '::getPosition and ::setPosition', ->
       it 'sets the position of the window, and can retrieve the position just set', ->
@@ -35,6 +32,9 @@ describe "the `atom` global", ->
 
   describe "window:update-available", ->
     it "is triggered when the auto-updater sends the update-downloaded event", ->
+      # FIXME: We need to figure out a way minus workspaceView to handle update-available events.
+      atom.workspaceView = atom.views.getView(atom.workspace).__spacePenView
+
       updateAvailableHandler = jasmine.createSpy("update-available-handler")
       atom.workspaceView.on 'window:update-available', updateAvailableHandler
       autoUpdater = require('remote').require('auto-updater')
@@ -52,3 +52,72 @@ describe "the `atom` global", ->
     it 'loads the default core config', ->
       expect(atom.config.get('core.excludeVcsIgnoredPaths')).toBe true
       expect(atom.config.get('editor.showInvisibles')).toBe false
+
+  describe "window onerror handler", ->
+    beforeEach ->
+      spyOn atom, 'openDevTools'
+      spyOn atom, 'executeJavaScriptInDevTools'
+
+    it "will open the dev tools when an error is triggered", ->
+      try
+        a + 1
+      catch e
+        window.onerror.call(window, e.toString(), 'abc', 2, 3, e)
+
+      expect(atom.openDevTools).toHaveBeenCalled()
+      expect(atom.executeJavaScriptInDevTools).toHaveBeenCalled()
+
+    describe "::onWillThrowError", ->
+      willThrowSpy = null
+      beforeEach ->
+        willThrowSpy = jasmine.createSpy()
+
+      it "is called when there is an error", ->
+        error = null
+        atom.onWillThrowError(willThrowSpy)
+        try
+          a + 1
+        catch e
+          error = e
+          window.onerror.call(window, e.toString(), 'abc', 2, 3, e)
+
+        delete willThrowSpy.mostRecentCall.args[0].preventDefault
+        expect(willThrowSpy).toHaveBeenCalledWith
+          message: error.toString()
+          url: 'abc'
+          line: 2
+          column: 3
+          originalError: error
+
+      it "will not show the devtools when preventDefault() is called", ->
+        willThrowSpy.andCallFake (errorObject) -> errorObject.preventDefault()
+        atom.onWillThrowError(willThrowSpy)
+
+        try
+          a + 1
+        catch e
+          window.onerror.call(window, e.toString(), 'abc', 2, 3, e)
+
+        expect(willThrowSpy).toHaveBeenCalled()
+        expect(atom.openDevTools).not.toHaveBeenCalled()
+        expect(atom.executeJavaScriptInDevTools).not.toHaveBeenCalled()
+
+    describe "::onDidThrowError", ->
+      didThrowSpy = null
+      beforeEach ->
+        didThrowSpy = jasmine.createSpy()
+
+      it "is called when there is an error", ->
+        error = null
+        atom.onDidThrowError(didThrowSpy)
+        try
+          a + 1
+        catch e
+          error = e
+          window.onerror.call(window, e.toString(), 'abc', 2, 3, e)
+        expect(didThrowSpy).toHaveBeenCalledWith
+          message: error.toString()
+          url: 'abc'
+          line: 2
+          column: 3
+          originalError: error

spec/config-spec.coffee

@@ -195,6 +195,52 @@ describe "Config", ->
         atom.config.restoreDefault('.source.coffee', 'foo.bar.baz')
         expect(atom.config.save.callCount).toBe 1
 
+      it "does not call ::save or add a scoped property when no value has been set", ->
+        # see https://github.com/atom/atom/issues/4175
+        atom.config.setDefaults("foo", bar: baz: 10)
+        atom.config.restoreDefault('.source.coffee', 'foo.bar.baz')
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.baz')).toBe 10
+
+        expect(atom.config.save).not.toHaveBeenCalled()
+
+        scopedProperties = atom.config.scopedSettingsStore.propertiesForSource('user-config')
+        expect(scopedProperties['.coffee.source']).toBeUndefined()
+
+      it "removes the scoped value when it was the only set value on the object", ->
+        spyOn(CSON, 'writeFileSync')
+        jasmine.unspy atom.config, 'save'
+
+        atom.config.setDefaults("foo", bar: baz: 10)
+        atom.config.set('.source.coffee', 'foo.bar.baz', 55)
+        atom.config.set('.source.coffee', 'foo.bar.zfoo', 20)
+        CSON.writeFileSync.reset()
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.baz')).toBe 55
+
+        atom.config.restoreDefault('.source.coffee', 'foo.bar.baz')
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.baz')).toBe 10
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.zfoo')).toBe 20
+        expect(CSON.writeFileSync).toHaveBeenCalled()
+        properties = CSON.writeFileSync.mostRecentCall.args[1]
+        expect(properties['.coffee.source']).toEqual
+          foo:
+            bar:
+              zfoo: 20
+
+        CSON.writeFileSync.reset()
+        atom.config.restoreDefault('.source.coffee', 'foo.bar.zfoo')
+        expect(CSON.writeFileSync).toHaveBeenCalled()
+        properties = CSON.writeFileSync.mostRecentCall.args[1]
+        expect(properties['.coffee.source']).toBeUndefined()
+
+      it "does not call ::save when the value is already at the default", ->
+        atom.config.setDefaults("foo", bar: baz: 10)
+        atom.config.set('.source.coffee', 'foo.bar.baz', 55)
+        atom.config.save.reset()
+
+        atom.config.restoreDefault('.source.coffee', 'foo.bar.ok')
+        expect(atom.config.save).not.toHaveBeenCalled()
+        expect(atom.config.get(['.source.coffee'], 'foo.bar.baz')).toBe 55
+
   describe ".getSettings()", ->
     it "returns all settings including defaults", ->
       atom.config.setDefaults("foo", bar: baz: 10)
@@ -508,11 +554,13 @@ describe "Config", ->
     describe "when the config file contains invalid cson", ->
       beforeEach ->
         spyOn(console, 'error')
+        spyOn(atom.notifications, 'addError')
         fs.writeFileSync(atom.config.configFilePath, "{{{{{")
 
       it "logs an error to the console and does not overwrite the config file on a subsequent save", ->
         atom.config.loadUserConfig()
         expect(console.error).toHaveBeenCalled()
+        expect(atom.notifications.addError.callCount).toBe 1
         atom.config.set("hair", "blonde") # trigger a save
         expect(atom.config.save).not.toHaveBeenCalled()
 
@@ -646,7 +694,6 @@ describe "Config", ->
             expect(atom.config.get(['.source.ruby'], 'foo.bar')).toBe 'baz'
             expect(atom.config.get(['.source.ruby'], 'foo.scoped')).toBe true
 
-
     describe "when the config file changes to omit a setting with a default", ->
       it "resets the setting back to the default", ->
         fs.writeFileSync(atom.config.configFilePath, "foo: { baz: 'new'}")

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

@@ -9,5 +9,6 @@ module.exports =
     atom.commands.add 'atom-workspace', 'activation-command', =>
       @activationCommandCallCount++
 
-    atom.workspaceView.getActiveView()?.command 'activation-command', =>
+    editorView = atom.views.getView(atom.workspace.getActiveEditor())?.__spacePenView
+    editorView?.command 'activation-command', =>
       @legacyActivationCommandCallCount++

spec/language-mode-spec.coffee

@@ -96,12 +96,13 @@ describe "LanguageMode", ->
         buffer.setText("//this is a single line comment")
         expect(languageMode.rowRangeForCommentAtBufferRow(0)).toBeUndefined()
 
-    describe "suggestedIndentForBufferRow", ->
-      it "returns the suggested indentation based on auto-indent/outdent rules", ->
+    describe ".suggestedIndentForBufferRow", ->
+      it "bases indentation off of the previous non-blank line", ->
         expect(languageMode.suggestedIndentForBufferRow(0)).toBe 0
         expect(languageMode.suggestedIndentForBufferRow(1)).toBe 1
         expect(languageMode.suggestedIndentForBufferRow(2)).toBe 2
         expect(languageMode.suggestedIndentForBufferRow(9)).toBe 1
+        expect(languageMode.suggestedIndentForBufferRow(11)).toBe 1
 
     describe "rowRangeForParagraphAtBufferRow", ->
       describe "with code and comments", ->

spec/notification-manager-spec.coffee

@@ -0,0 +1,57 @@
+NotificationManager = require '../src/notification-manager'
+
+describe "NotificationManager", ->
+  [manager] = []
+
+  beforeEach ->
+    manager = new NotificationManager
+
+  describe "the atom global", ->
+    it "has a notifications instance", ->
+      expect(atom.notifications instanceof NotificationManager).toBe true
+
+  describe "adding events", ->
+    addSpy = null
+
+    beforeEach ->
+      addSpy = jasmine.createSpy()
+      manager.onDidAddNotification(addSpy)
+
+    it "emits an event when a notification has been added", ->
+      manager.add('error', 'Some error!', icon: 'someIcon')
+      expect(addSpy).toHaveBeenCalled()
+
+      notification = addSpy.mostRecentCall.args[0]
+      expect(notification.getType()).toBe 'error'
+      expect(notification.getMessage()).toBe 'Some error!'
+      expect(notification.getIcon()).toBe 'someIcon'
+
+    it "emits a fatal error ::addFatalError has been called", ->
+      manager.addFatalError('Some error!', icon: 'someIcon')
+      expect(addSpy).toHaveBeenCalled()
+      notification = addSpy.mostRecentCall.args[0]
+      expect(notification.getType()).toBe 'fatal'
+
+    it "emits an error ::addError has been called", ->
+      manager.addError('Some error!', icon: 'someIcon')
+      expect(addSpy).toHaveBeenCalled()
+      notification = addSpy.mostRecentCall.args[0]
+      expect(notification.getType()).toBe 'error'
+
+    it "emits a warning notification ::addWarning has been called", ->
+      manager.addWarning('Something!', icon: 'someIcon')
+      expect(addSpy).toHaveBeenCalled()
+      notification = addSpy.mostRecentCall.args[0]
+      expect(notification.getType()).toBe 'warning'
+
+    it "emits an info notification ::addInfo has been called", ->
+      manager.addInfo('Something!', icon: 'someIcon')
+      expect(addSpy).toHaveBeenCalled()
+      notification = addSpy.mostRecentCall.args[0]
+      expect(notification.getType()).toBe 'info'
+
+    it "emits a success notification ::addSuccess has been called", ->
+      manager.addSuccess('Something!', icon: 'someIcon')
+      expect(addSpy).toHaveBeenCalled()
+      notification = addSpy.mostRecentCall.args[0]
+      expect(notification.getType()).toBe 'success'

spec/notification-spec.coffee

@@ -0,0 +1,18 @@
+Notification = require '../src/notification'
+
+describe "Notification", ->
+  [notification] = []
+
+  describe "::getTimestamp()", ->
+    it "returns a Date object", ->
+      notification = new Notification('error', 'message!')
+      expect(notification.getTimestamp() instanceof Date).toBe true
+
+  describe "::getIcon()", ->
+    it "returns a default when no icon specified", ->
+      notification = new Notification('error', 'message!')
+      expect(notification.getIcon()).toBe 'flame'
+
+    it "returns the icon specified", ->
+      notification = new Notification('error', 'message!', icon: 'my-icon')
+      expect(notification.getIcon()).toBe 'my-icon'

spec/package-manager-spec.coffee

@@ -2,8 +2,9 @@
 Package = require '../src/package'
 
 describe "PackageManager", ->
+  workspaceElement = null
   beforeEach ->
-    atom.workspaceView = atom.views.getView(atom.workspace).__spacePenView
+    workspaceElement = atom.views.getView(atom.workspace)
 
   describe "::loadPackage(name)", ->
     it "continues if the package has an invalid package.json", ->
@@ -111,7 +112,7 @@ describe "PackageManager", ->
           [mainModule, promise, workspaceCommandListener] = []
 
           beforeEach ->
-            atom.workspaceView.attachToDom()
+            jasmine.attachToDOM(workspaceElement)
             mainModule = require './fixtures/packages/package-with-activation-commands/index'
             mainModule.legacyActivationCommandCallCount = 0
             mainModule.activationCommandCallCount = 0
@@ -125,29 +126,29 @@ describe "PackageManager", ->
 
           it "defers requiring/activating the main module until an activation event bubbles to the root view", ->
             expect(promise.isFulfilled()).not.toBeTruthy()
-            atom.workspaceView[0].dispatchEvent(new CustomEvent('activation-command', bubbles: true))
+            workspaceElement.dispatchEvent(new CustomEvent('activation-command', bubbles: true))
 
             waitsForPromise ->
               promise
 
           it "triggers the activation event on all handlers registered during activation", ->
             waitsForPromise ->
-              atom.workspaceView.open()
+              atom.workspace.open()
 
             runs ->
-              editorView = atom.workspaceView.getActiveView()
+              editorView = atom.views.getView(atom.workspace.getActiveEditor()).__spacePenView
               legacyCommandListener = jasmine.createSpy("legacyCommandListener")
               editorView.command 'activation-command', legacyCommandListener
               editorCommandListener = jasmine.createSpy("editorCommandListener")
               atom.commands.add 'atom-text-editor', 'activation-command', editorCommandListener
-              editorView[0].dispatchEvent(new CustomEvent('activation-command', bubbles: true))
+              atom.commands.dispatch(editorView[0], 'activation-command')
               expect(mainModule.activate.callCount).toBe 1
               expect(mainModule.legacyActivationCommandCallCount).toBe 1
               expect(mainModule.activationCommandCallCount).toBe 1
               expect(legacyCommandListener.callCount).toBe 1
               expect(editorCommandListener.callCount).toBe 1
               expect(workspaceCommandListener.callCount).toBe 1
-              editorView[0].dispatchEvent(new CustomEvent('activation-command', bubbles: true))
+              atom.commands.dispatch(editorView[0], 'activation-command')
               expect(mainModule.legacyActivationCommandCallCount).toBe 2
               expect(mainModule.activationCommandCallCount).toBe 2
               expect(legacyCommandListener.callCount).toBe 2
@@ -349,8 +350,8 @@ describe "PackageManager", ->
             atom.packages.activatePackage('package-with-grammars')
 
           runs ->
-            expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Alot'
-            expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Alittle'
+            expect(atom.grammars.selectGrammar('a.alot').name).toBe 'Alot'
+            expect(atom.grammars.selectGrammar('a.alittle').name).toBe 'Alittle'
 
       describe "scoped-property loading", ->
         it "loads the scoped properties", ->
@@ -362,13 +363,13 @@ describe "PackageManager", ->
 
     describe "converted textmate packages", ->
       it "loads the package's grammars", ->
-        expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+        expect(atom.grammars.selectGrammar("file.rb").name).toBe "Null Grammar"
 
         waitsForPromise ->
           atom.packages.activatePackage('language-ruby')
 
         runs ->
-          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
+          expect(atom.grammars.selectGrammar("file.rb").name).toBe "Ruby"
 
       it "loads the translated scoped properties", ->
         expect(atom.config.get(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
@@ -454,8 +455,8 @@ describe "PackageManager", ->
 
         runs ->
           atom.packages.deactivatePackage('package-with-grammars')
-          expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Null Grammar'
-          expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Null Grammar'
+          expect(atom.grammars.selectGrammar('a.alot').name).toBe 'Null Grammar'
+          expect(atom.grammars.selectGrammar('a.alittle').name).toBe 'Null Grammar'
 
       it "removes the package's keymaps", ->
         waitsForPromise ->
@@ -490,15 +491,15 @@ describe "PackageManager", ->
 
     describe "textmate packages", ->
       it "removes the package's grammars", ->
-        expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+        expect(atom.grammars.selectGrammar("file.rb").name).toBe "Null Grammar"
 
         waitsForPromise ->
           atom.packages.activatePackage('language-ruby')
 
         runs ->
-          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
+          expect(atom.grammars.selectGrammar("file.rb").name).toBe "Ruby"
           atom.packages.deactivatePackage('language-ruby')
-          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+          expect(atom.grammars.selectGrammar("file.rb").name).toBe "Null Grammar"
 
       it "removes the package's scoped properties", ->
         waitsForPromise ->
@@ -526,8 +527,8 @@ describe "PackageManager", ->
       atom.packages.deactivatePackages()
       atom.packages.unloadPackages()
 
-      Syntax = require '../src/syntax'
-      atom.syntax = window.syntax = new Syntax()
+      GrammarRegistry = require '../src/grammar-registry'
+      atom.grammars = window.syntax = new GrammarRegistry()
 
     it "activates all the packages, and none of the themes", ->
       atom.packages.activate()

spec/panel-container-element-spec.coffee

@@ -34,8 +34,8 @@ describe "PanelContainerElement", ->
     element = container.getView()
     jasmineContent.appendChild(element)
 
-  it 'has a location attribute with value from the model', ->
-    expect(element.getAttribute('location')).toBe 'left'
+  it 'has a location class with value from the model', ->
+    expect(element).toHaveClass 'left'
 
   it 'removes the element when the container is destroyed', ->
     expect(element.parentNode).toBe jasmineContent
@@ -43,6 +43,19 @@ describe "PanelContainerElement", ->
     expect(element.parentNode).not.toBe jasmineContent
 
   describe "adding and removing panels", ->
+    it "allows panels to be inserted at any position", ->
+      panel1 = new Panel({viewRegistry, item: new TestPanelContainerItem(), priority: 10})
+      panel2 = new Panel({viewRegistry, item: new TestPanelContainerItem(), priority: 5})
+      panel3 = new Panel({viewRegistry, item: new TestPanelContainerItem(), priority: 8})
+
+      container.addPanel(panel1)
+      container.addPanel(panel2)
+      container.addPanel(panel3)
+
+      expect(element.childNodes[2].getModel()).toBe(panel1)
+      expect(element.childNodes[1].getModel()).toBe(panel3)
+      expect(element.childNodes[0].getModel()).toBe(panel2)
+
     describe "when the container is at the left location", ->
       it "adds atom-panel elements when a new panel is added to the container; removes them when the panels are destroyed", ->
         expect(element.childNodes.length).toBe 0
@@ -50,7 +63,9 @@ describe "PanelContainerElement", ->
         panel1 = new Panel({viewRegistry, item: new TestPanelContainerItem()})
         container.addPanel(panel1)
         expect(element.childNodes.length).toBe 1
-        expect(element.childNodes[0].getAttribute('location')).toBe 'left'
+        expect(element.childNodes[0]).toHaveClass 'left'
+        expect(element.childNodes[0]).toHaveClass 'tool-panel' # legacy selector support
+        expect(element.childNodes[0]).toHaveClass 'panel-left' # legacy selector support
 
         expect(element.childNodes[0].tagName).toBe 'ATOM-PANEL'
 
@@ -79,7 +94,9 @@ describe "PanelContainerElement", ->
         panel1 = new Panel({viewRegistry, item: new TestPanelContainerItem(), className: 'one'})
         container.addPanel(panel1)
         expect(element.childNodes.length).toBe 1
-        expect(element.childNodes[0].getAttribute('location')).toBe 'bottom'
+        expect(element.childNodes[0]).toHaveClass 'bottom'
+        expect(element.childNodes[0]).toHaveClass 'tool-panel' # legacy selector support
+        expect(element.childNodes[0]).toHaveClass 'panel-bottom' # legacy selector support
         expect(element.childNodes[0].tagName).toBe 'ATOM-PANEL'
         expect(panel1.getView()).toHaveClass 'one'
 
@@ -116,3 +133,14 @@ describe "PanelContainerElement", ->
 
       expect(panel1.getView().style.display).not.toBe 'none'
       expect(panel2.getView().style.display).toBe 'none'
+
+    it "adds the 'modal' class to panels", ->
+      panel1 = new Panel({viewRegistry, item: new TestPanelContainerItem()})
+      container.addPanel(panel1)
+
+      expect(panel1.getView()).toHaveClass 'modal'
+
+      # legacy selector support
+      expect(panel1.getView()).not.toHaveClass 'tool-panel'
+      expect(panel1.getView()).toHaveClass 'overlay'
+      expect(panel1.getView()).toHaveClass 'from-top'

spec/spec-helper.coffee

@@ -9,7 +9,8 @@ _ = require 'underscore-plus'
 fs = require 'fs-plus'
 Grim = require 'grim'
 KeymapManager = require '../src/keymap-extensions'
-{$, WorkspaceView, Workspace} = require 'atom'
+Workspace = require '../src/workspace'
+{$} = require '../src/space-pen-extensions'
 Config = require '../src/config'
 {Point} = require 'text-buffer'
 Project = require '../src/project'
@@ -82,7 +83,7 @@ beforeEach ->
   serializedWindowState = null
 
   spyOn(atom, 'saveSync')
-  atom.syntax.clearGrammarOverrides()
+  atom.grammars.clearGrammarOverrides()
 
   spy = spyOn(atom.packages, 'resolvePackagePath').andCallFake (packageName) ->
     if specPackageName and packageName is specPackageName
@@ -135,8 +136,9 @@ afterEach ->
   atom.menu.template = []
   atom.contextMenu.clear()
 
-  atom.workspaceView?.remove?()
-  atom.workspaceView = null
+  atom.workspace?.destroy()
+  atom.workspace = null
+  atom.__workspaceView = null
   delete atom.state.workspace
 
   atom.project?.destroy()
@@ -150,7 +152,7 @@ afterEach ->
 
   jasmine.unspy(atom, 'saveSync')
   ensureNoPathSubscriptions()
-  atom.syntax.clearObservers()
+  atom.grammars.clearObservers()
   waits(0) # yield to ui thread to make screen update more frequently
 
 ensureNoPathSubscriptions = ->
@@ -191,6 +193,10 @@ jasmine.unspy = (object, methodName) ->
   throw new Error("Not a spy") unless object[methodName].hasOwnProperty('originalValue')
   object[methodName] = object[methodName].originalValue
 
+jasmine.attachToDOM = (element) ->
+  jasmineContent = document.querySelector('#jasmine-content')
+  jasmineContent.appendChild(element) unless jasmineContent.contains(element)
+
 addCustomMatchers = (spec) ->
   spec.addMatchers
     toBeInstanceOf: (expected) ->

spec/styles-element-spec.coffee

@@ -74,3 +74,34 @@ describe "StylesElement", ->
     expect(element.children.length).toBe 2
     expect(element.children[0].textContent).toBe "a {color: red;}"
     expect(element.children[1].textContent).toBe "a {color: blue;}"
+
+  describe "atom-text-editor shadow DOM selector upgrades", ->
+    beforeEach ->
+      element.setAttribute('context', 'atom-text-editor')
+      spyOn(console, 'warn')
+
+    it "upgrades selectors containing .editor-colors", ->
+      atom.styles.addStyleSheet(".editor-colors {background: black;}", context: 'atom-text-editor')
+      expect(element.firstChild.sheet.cssRules[0].selectorText).toBe ':host'
+
+    it "upgrades selectors containing .editor", ->
+      atom.styles.addStyleSheet """
+        .editor {background: black;}
+        .editor.mini {background: black;}
+        .editor:focus {background: black;}
+      """, context: 'atom-text-editor'
+
+      expect(element.firstChild.sheet.cssRules[0].selectorText).toBe ':host'
+      expect(element.firstChild.sheet.cssRules[1].selectorText).toBe ':host(.mini)'
+      expect(element.firstChild.sheet.cssRules[2].selectorText).toBe ':host(:focus)'
+
+    it "defers selector upgrade until the element is attached", ->
+      element = new StylesElement
+      element.setAttribute('context', 'atom-text-editor')
+      element.initialize()
+
+      atom.styles.addStyleSheet ".editor {background: black;}", context: 'atom-text-editor'
+      expect(element.firstChild.sheet).toBeNull()
+
+      document.querySelector('#jasmine-content').appendChild(element)
+      expect(element.firstChild.sheet.cssRules[0].selectorText).toBe ':host'

spec/syntax-spec.coffee

@@ -23,10 +23,10 @@ describe "the `syntax` global", ->
   describe "serialization", ->
     it "remembers grammar overrides by path", ->
       filePath = '/foo/bar/file.js'
-      expect(atom.syntax.selectGrammar(filePath).name).not.toBe 'Ruby'
-      atom.syntax.setGrammarOverrideForPath(filePath, 'source.ruby')
-      syntax2 = atom.deserializers.deserialize(atom.syntax.serialize())
-      syntax2.addGrammar(grammar) for grammar in atom.syntax.grammars when grammar isnt atom.syntax.nullGrammar
+      expect(atom.grammars.selectGrammar(filePath).name).not.toBe 'Ruby'
+      atom.grammars.setGrammarOverrideForPath(filePath, 'source.ruby')
+      syntax2 = atom.deserializers.deserialize(atom.grammars.serialize())
+      syntax2.addGrammar(grammar) for grammar in atom.grammars.grammars when grammar isnt atom.grammars.nullGrammar
       expect(syntax2.selectGrammar(filePath).name).toBe 'Ruby'
 
   describe ".selectGrammar(filePath)", ->
@@ -35,15 +35,15 @@ describe "the `syntax` global", ->
         atom.packages.activatePackage('language-git')
 
       runs ->
-        expect(atom.syntax.selectGrammar("file.js").name).toBe "JavaScript" # based on extension (.js)
-        expect(atom.syntax.selectGrammar(path.join(temp.dir, '.git', 'config')).name).toBe "Git Config" # based on end of the path (.git/config)
-        expect(atom.syntax.selectGrammar("Rakefile").name).toBe "Ruby" # based on the file's basename (Rakefile)
-        expect(atom.syntax.selectGrammar("curb").name).toBe "Null Grammar"
-        expect(atom.syntax.selectGrammar("/hu.git/config").name).toBe "Null Grammar"
+        expect(atom.grammars.selectGrammar("file.js").name).toBe "JavaScript" # based on extension (.js)
+        expect(atom.grammars.selectGrammar(path.join(temp.dir, '.git', 'config')).name).toBe "Git Config" # based on end of the path (.git/config)
+        expect(atom.grammars.selectGrammar("Rakefile").name).toBe "Ruby" # based on the file's basename (Rakefile)
+        expect(atom.grammars.selectGrammar("curb").name).toBe "Null Grammar"
+        expect(atom.grammars.selectGrammar("/hu.git/config").name).toBe "Null Grammar"
 
     it "uses the filePath's shebang line if the grammar cannot be determined by the extension or basename", ->
       filePath = require.resolve("./fixtures/shebang")
-      expect(atom.syntax.selectGrammar(filePath).name).toBe "Ruby"
+      expect(atom.grammars.selectGrammar(filePath).name).toBe "Ruby"
 
     it "uses the number of newlines in the first line regex to determine the number of lines to test against", ->
       waitsForPromise ->
@@ -51,28 +51,28 @@ describe "the `syntax` global", ->
 
       runs ->
         fileContent = "first-line\n<html>"
-        expect(atom.syntax.selectGrammar("dummy.coffee", fileContent).name).toBe "CoffeeScript"
+        expect(atom.grammars.selectGrammar("dummy.coffee", fileContent).name).toBe "CoffeeScript"
 
         fileContent = '<?xml version="1.0" encoding="UTF-8"?>'
-        expect(atom.syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Null Grammar"
+        expect(atom.grammars.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Null Grammar"
 
         fileContent += '\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
-        expect(atom.syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Property List (XML)"
+        expect(atom.grammars.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Property List (XML)"
 
     it "doesn't read the file when the file contents are specified", ->
       filePath = require.resolve("./fixtures/shebang")
       filePathContents = fs.readFileSync(filePath, 'utf8')
       spyOn(fs, 'read').andCallThrough()
-      expect(atom.syntax.selectGrammar(filePath, filePathContents).name).toBe "Ruby"
+      expect(atom.grammars.selectGrammar(filePath, filePathContents).name).toBe "Ruby"
       expect(fs.read).not.toHaveBeenCalled()
 
     it "allows the default grammar to be overridden for a path", ->
       filePath = '/foo/bar/file.js'
-      expect(atom.syntax.selectGrammar(filePath).name).not.toBe 'Ruby'
-      atom.syntax.setGrammarOverrideForPath(filePath, 'source.ruby')
-      expect(atom.syntax.selectGrammar(filePath).name).toBe 'Ruby'
-      atom.syntax.clearGrammarOverrideForPath(filePath)
-      expect(atom.syntax.selectGrammar(filePath).name).not.toBe 'Ruby'
+      expect(atom.grammars.selectGrammar(filePath).name).not.toBe 'Ruby'
+      atom.grammars.setGrammarOverrideForPath(filePath, 'source.ruby')
+      expect(atom.grammars.selectGrammar(filePath).name).toBe 'Ruby'
+      atom.grammars.clearGrammarOverrideForPath(filePath)
+      expect(atom.grammars.selectGrammar(filePath).name).not.toBe 'Ruby'
 
     describe "when multiple grammars have matching fileTypes", ->
       it "selects the grammar with the longest fileType match", ->
@@ -82,8 +82,8 @@ describe "the `syntax` global", ->
           scopeName: 'source1'
           fileTypes: ['test']
         )
-        grammar1 = atom.syntax.loadGrammarSync(grammarPath1)
-        expect(atom.syntax.selectGrammar('more.test', '')).toBe grammar1
+        grammar1 = atom.grammars.loadGrammarSync(grammarPath1)
+        expect(atom.grammars.selectGrammar('more.test', '')).toBe grammar1
 
         grammarPath2 = temp.path(suffix: '.json')
         fs.writeFileSync grammarPath2, JSON.stringify(
@@ -91,44 +91,44 @@ describe "the `syntax` global", ->
           scopeName: 'source2'
           fileTypes: ['test', 'more.test']
         )
-        grammar2 = atom.syntax.loadGrammarSync(grammarPath2)
-        expect(atom.syntax.selectGrammar('more.test', '')).toBe grammar2
+        grammar2 = atom.grammars.loadGrammarSync(grammarPath2)
+        expect(atom.grammars.selectGrammar('more.test', '')).toBe grammar2
 
     describe "when there is no file path", ->
       it "does not throw an exception (regression)", ->
-        expect(-> atom.syntax.selectGrammar(null, '#!/usr/bin/ruby')).not.toThrow()
-        expect(-> atom.syntax.selectGrammar(null, '')).not.toThrow()
-        expect(-> atom.syntax.selectGrammar(null, null)).not.toThrow()
+        expect(-> atom.grammars.selectGrammar(null, '#!/usr/bin/ruby')).not.toThrow()
+        expect(-> atom.grammars.selectGrammar(null, '')).not.toThrow()
+        expect(-> atom.grammars.selectGrammar(null, null)).not.toThrow()
 
   describe ".removeGrammar(grammar)", ->
     it "removes the grammar, so it won't be returned by selectGrammar", ->
-      grammar = atom.syntax.selectGrammar('foo.js')
-      atom.syntax.removeGrammar(grammar)
-      expect(atom.syntax.selectGrammar('foo.js').name).not.toBe grammar.name
+      grammar = atom.grammars.selectGrammar('foo.js')
+      atom.grammars.removeGrammar(grammar)
+      expect(atom.grammars.selectGrammar('foo.js').name).not.toBe grammar.name
 
   describe ".getProperty(scopeDescriptor)", ->
     it "returns the property with the most specific scope selector", ->
-      atom.syntax.addProperties(".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
-      atom.syntax.addProperties(".source .string.quoted.double", foo: bar: baz: 22)
-      atom.syntax.addProperties(".source", foo: bar: baz: 11)
+      atom.grammars.addProperties(".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
+      atom.grammars.addProperties(".source .string.quoted.double", foo: bar: baz: 22)
+      atom.grammars.addProperties(".source", foo: bar: baz: 11)
 
-      expect(atom.syntax.getProperty([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42
-      expect(atom.syntax.getProperty([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBe 22
-      expect(atom.syntax.getProperty([".source.js", ".variable.assignment.js"], "foo.bar.baz")).toBe 11
-      expect(atom.syntax.getProperty([".text"], "foo.bar.baz")).toBeUndefined()
+      expect(atom.grammars.getProperty([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42
+      expect(atom.grammars.getProperty([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBe 22
+      expect(atom.grammars.getProperty([".source.js", ".variable.assignment.js"], "foo.bar.baz")).toBe 11
+      expect(atom.grammars.getProperty([".text"], "foo.bar.baz")).toBeUndefined()
 
     it "favors the most recently added properties in the event of a specificity tie", ->
-      atom.syntax.addProperties(".source.coffee .string.quoted.single", foo: bar: baz: 42)
-      atom.syntax.addProperties(".source.coffee .string.quoted.double", foo: bar: baz: 22)
+      atom.grammars.addProperties(".source.coffee .string.quoted.single", foo: bar: baz: 42)
+      atom.grammars.addProperties(".source.coffee .string.quoted.double", foo: bar: baz: 22)
 
-      expect(atom.syntax.getProperty([".source.coffee", ".string.quoted.single"], "foo.bar.baz")).toBe 42
-      expect(atom.syntax.getProperty([".source.coffee", ".string.quoted.single.double"], "foo.bar.baz")).toBe 22
+      expect(atom.grammars.getProperty([".source.coffee", ".string.quoted.single"], "foo.bar.baz")).toBe 42
+      expect(atom.grammars.getProperty([".source.coffee", ".string.quoted.single.double"], "foo.bar.baz")).toBe 22
 
   describe ".removeProperties(name)", ->
     it "allows properties to be removed by name", ->
-      atom.syntax.addProperties("a", ".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
-      atom.syntax.addProperties("b", ".source .string.quoted.double", foo: bar: baz: 22)
+      atom.grammars.addProperties("a", ".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
+      atom.grammars.addProperties("b", ".source .string.quoted.double", foo: bar: baz: 22)
 
-      atom.syntax.removeProperties("b")
-      expect(atom.syntax.getProperty([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBeUndefined()
-      expect(atom.syntax.getProperty([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42
+      atom.grammars.removeProperties("b")
+      expect(atom.grammars.getProperty([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBeUndefined()
+      expect(atom.grammars.getProperty([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42

spec/text-editor-component-spec.coffee

@@ -1131,6 +1131,13 @@ describe "TextEditorComponent", ->
       regions = componentNode.querySelectorAll('.test-highlight .region')
       expect(regions.length).toBe 2
 
+    it "renders classes on the regions directly if 'deprecatedRegionClass' option is defined", ->
+      decoration = editor.decorateMarker(marker, type: 'highlight', class: 'test-highlight', deprecatedRegionClass: 'test-highlight-region')
+      nextAnimationFrame()
+
+      regions = componentNode.querySelectorAll('.test-highlight .region.test-highlight-region')
+      expect(regions.length).toBe 2
+
     describe "when flashing a decoration via Decoration::flash()", ->
       highlightNode = null
       beforeEach ->
@@ -1196,6 +1203,221 @@ describe "TextEditorComponent", ->
         expect(componentNode.querySelector('.test-highlight')).toBeFalsy()
         expect(componentNode.querySelector('.new-test-highlight')).toBeTruthy()
 
+  describe "overlay decoration rendering", ->
+    [item] = []
+    beforeEach ->
+      item = document.createElement('div')
+      item.classList.add 'overlay-test'
+
+    describe "when the marker is empty", ->
+      it "renders an overlay decoration when added and removes the overlay when the decoration is destroyed", ->
+        marker = editor.displayBuffer.markBufferRange([[2, 13], [2, 13]], invalidate: 'never')
+        decoration = editor.decorateMarker(marker, {type: 'overlay', item})
+        nextAnimationFrame()
+
+        overlay = component.getTopmostDOMNode().querySelector('atom-overlay .overlay-test')
+        expect(overlay).toBe item
+
+        decoration.destroy()
+        nextAnimationFrame()
+
+        overlay = component.getTopmostDOMNode().querySelector('atom-overlay .overlay-test')
+        expect(overlay).toBe null
+
+      it "renders in the correct position on initial display and when the marker moves", ->
+        editor.setCursorBufferPosition([2, 5])
+
+        marker = editor.getLastCursor().getMarker()
+        decoration = editor.decorateMarker(marker, {type: 'overlay', item})
+        nextAnimationFrame()
+
+        position = editor.pixelPositionForBufferPosition([2, 5])
+
+        overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
+        expect(overlay.style.left).toBe position.left + 'px'
+        expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+        editor.moveRight()
+        editor.moveRight()
+        nextAnimationFrame()
+
+        position = editor.pixelPositionForBufferPosition([2, 7])
+
+        expect(overlay.style.left).toBe position.left + 'px'
+        expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+    describe "when the marker is not empty", ->
+      it "renders at the head of the marker", ->
+        marker = editor.displayBuffer.markBufferRange([[2, 5], [2, 10]], invalidate: 'never')
+        decoration = editor.decorateMarker(marker, {type: 'overlay', item})
+        nextAnimationFrame()
+
+        position = editor.pixelPositionForBufferPosition([2, 10])
+
+        overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
+        expect(overlay.style.left).toBe position.left + 'px'
+        expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+      it "renders at the head of the marker when the marker is reversed", ->
+        marker = editor.displayBuffer.markBufferRange([[2, 5], [2, 10]], invalidate: 'never', reversed: true)
+        decoration = editor.decorateMarker(marker, {type: 'overlay', item})
+        nextAnimationFrame()
+
+        position = editor.pixelPositionForBufferPosition([2, 5])
+
+        overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
+        expect(overlay.style.left).toBe position.left + 'px'
+        expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+    describe "positioning the overlay when near the edge of the editor", ->
+      [itemWidth, itemHeight] = []
+      beforeEach ->
+        itemWidth = 4 * editor.getDefaultCharWidth()
+        itemHeight = 4 * editor.getLineHeightInPixels()
+
+        gutterWidth = componentNode.querySelector('.gutter').offsetWidth
+        windowWidth = gutterWidth + 30 * editor.getDefaultCharWidth()
+        windowHeight = 9 * editor.getLineHeightInPixels()
+
+        item.style.width = itemWidth + 'px'
+        item.style.height = itemHeight + 'px'
+
+        wrapperNode.style.width = windowWidth + 'px'
+        wrapperNode.style.height = windowHeight + 'px'
+
+        component.measureHeightAndWidth()
+        nextAnimationFrame()
+
+      it "flips horizontally when near the right edge", ->
+        marker = editor.displayBuffer.markBufferRange([[0, 26], [0, 26]], invalidate: 'never')
+        decoration = editor.decorateMarker(marker, {type: 'overlay', item})
+        nextAnimationFrame()
+
+        position = editor.pixelPositionForBufferPosition([0, 26])
+
+        overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
+        expect(overlay.style.left).toBe position.left + 'px'
+        expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+        editor.insertText('a')
+        nextAnimationFrame()
+
+        position = editor.pixelPositionForBufferPosition([0, 27])
+
+        expect(overlay.style.left).toBe position.left - itemWidth + 'px'
+        expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+      it "flips vertically when near the bottom edge", ->
+        marker = editor.displayBuffer.markBufferRange([[4, 0], [4, 0]], invalidate: 'never')
+        decoration = editor.decorateMarker(marker, {type: 'overlay', item})
+        nextAnimationFrame()
+
+        position = editor.pixelPositionForBufferPosition([4, 0])
+
+        overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
+        expect(overlay.style.left).toBe position.left + 'px'
+        expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+        editor.insertNewline()
+        nextAnimationFrame()
+
+        position = editor.pixelPositionForBufferPosition([5, 0])
+
+        expect(overlay.style.left).toBe position.left + 'px'
+        expect(overlay.style.top).toBe position.top - itemHeight + 'px'
+
+      describe "when the editor is very small", ->
+        beforeEach ->
+          gutterWidth = componentNode.querySelector('.gutter').offsetWidth
+          windowWidth = gutterWidth + 6 * editor.getDefaultCharWidth()
+          windowHeight = 6 * editor.getLineHeightInPixels()
+
+          wrapperNode.style.width = windowWidth + 'px'
+          wrapperNode.style.height = windowHeight + 'px'
+
+          component.measureHeightAndWidth()
+          nextAnimationFrame()
+
+        it "does not flip horizontally and force the overlay to have a negative left", ->
+          marker = editor.displayBuffer.markBufferRange([[0, 2], [0, 2]], invalidate: 'never')
+          decoration = editor.decorateMarker(marker, {type: 'overlay', item})
+          nextAnimationFrame()
+
+          position = editor.pixelPositionForBufferPosition([0, 2])
+
+          overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
+          expect(overlay.style.left).toBe position.left + 'px'
+          expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+          editor.insertText('a')
+          nextAnimationFrame()
+
+          position = editor.pixelPositionForBufferPosition([0, 3])
+
+          expect(overlay.style.left).toBe position.left + 'px'
+          expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+        it "does not flip vertically and force the overlay to have a negative top", ->
+          marker = editor.displayBuffer.markBufferRange([[1, 0], [1, 0]], invalidate: 'never')
+          decoration = editor.decorateMarker(marker, {type: 'overlay', item})
+          nextAnimationFrame()
+
+          position = editor.pixelPositionForBufferPosition([1, 0])
+
+          overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
+          expect(overlay.style.left).toBe position.left + 'px'
+          expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+          editor.insertNewline()
+          nextAnimationFrame()
+
+          position = editor.pixelPositionForBufferPosition([2, 0])
+
+          expect(overlay.style.left).toBe position.left + 'px'
+          expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+
+      describe "when editor scroll position is not 0", ->
+        it "flips horizontally when near the right edge", ->
+          editor.setScrollLeft(2 * editor.getDefaultCharWidth())
+          marker = editor.displayBuffer.markBufferRange([[0, 28], [0, 28]], invalidate: 'never')
+          decoration = editor.decorateMarker(marker, {type: 'overlay', item})
+          nextAnimationFrame()
+
+          position = editor.pixelPositionForBufferPosition([0, 28])
+
+          overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
+          expect(overlay.style.left).toBe position.left + 'px'
+          expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+          editor.insertText('a')
+          nextAnimationFrame()
+
+          position = editor.pixelPositionForBufferPosition([0, 29])
+
+          expect(overlay.style.left).toBe position.left - itemWidth + 'px'
+          expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+        it "flips vertically when near the bottom edge", ->
+          editor.setScrollTop(2 * editor.getLineHeightInPixels())
+          marker = editor.displayBuffer.markBufferRange([[6, 0], [6, 0]], invalidate: 'never')
+          decoration = editor.decorateMarker(marker, {type: 'overlay', item})
+          nextAnimationFrame()
+
+          position = editor.pixelPositionForBufferPosition([6, 0])
+
+          overlay = component.getTopmostDOMNode().querySelector('atom-overlay')
+          expect(overlay.style.left).toBe position.left + 'px'
+          expect(overlay.style.top).toBe position.top + editor.getLineHeightInPixels() + 'px'
+
+          editor.insertNewline()
+          nextAnimationFrame()
+
+          position = editor.pixelPositionForBufferPosition([7, 0])
+
+          expect(overlay.style.left).toBe position.left + 'px'
+          expect(overlay.style.top).toBe position.top - itemHeight + 'px'
+
   describe "hidden input field", ->
     it "renders the hidden input field at the position of the last cursor if the cursor is on screen and the editor is focused", ->
       editor.setVerticalScrollMargin(0)
@@ -2310,7 +2532,7 @@ describe "TextEditorComponent", ->
   describe "grammar data attributes", ->
     it "adds and updates the grammar data attribute based on the current grammar", ->
       expect(wrapperNode.dataset.grammar).toBe 'source js'
-      editor.setGrammar(atom.syntax.nullGrammar)
+      editor.setGrammar(atom.grammars.nullGrammar)
       expect(wrapperNode.dataset.grammar).toBe 'text plain null-grammar'
 
   describe "encoding data attributes", ->
@@ -2462,6 +2684,28 @@ describe "TextEditorComponent", ->
         expect(line1LeafNodes[0].classList.contains('indent-guide')).toBe false
         expect(line1LeafNodes[1].classList.contains('indent-guide')).toBe false
 
+  describe "middle mouse paste on Linux", ->
+    it "pastes the previously selected text", ->
+      spyOn(require('ipc'), 'send').andCallFake (eventName, selectedText) ->
+        if eventName is 'write-text-to-selection-clipboard'
+          require('clipboard').writeText(selectedText, 'selection')
+
+      atom.clipboard.write('')
+      component.listenForMiddleMousePaste()
+
+      editor.setCursorBufferPosition([10, 0])
+      componentNode.querySelector('.scroll-view').dispatchEvent(buildMouseEvent('mouseup', which: 2))
+
+      expect(atom.clipboard.read()).toBe ''
+      expect(editor.lineTextForBufferRow(10)).toBe ''
+
+      editor.setSelectedBufferRange([[1, 6], [1, 10]])
+      editor.setCursorBufferPosition([10, 0])
+      componentNode.querySelector('.scroll-view').dispatchEvent(buildMouseEvent('mouseup', which: 2))
+
+      expect(atom.clipboard.read()).toBe 'sort'
+      expect(editor.lineTextForBufferRow(10)).toBe 'sort'
+
   buildMouseEvent = (type, properties...) ->
     properties = extend({bubbles: true, cancelable: true}, properties...)
     properties.detail ?= 1

spec/text-editor-element-spec.coffee

@@ -1,4 +1,5 @@
 TextEditorElement = require '../src/text-editor-element'
+TextEditor = require '../src/text-editor'
 
 # The rest of text-editor-component-spec will be moved to this file when React
 # is eliminated. This covers only concerns related to the wrapper element for now
@@ -19,6 +20,13 @@ describe "TextEditorElement", ->
       element = jasmineContent.firstChild
       expect(element.getModel().getPlaceholderText()).toBe 'testing'
 
+  describe "when the model is assigned", ->
+    it "adds the 'mini' attribute if .isMini() returns true on the model", ->
+      element = new TextEditorElement
+      model = new TextEditor(mini: true)
+      element.setModel(model)
+      expect(element.hasAttribute('mini')).toBe true
+
   describe "focus and blur handling", ->
     describe "when the editor.useShadowDOM config option is true", ->
       it "proxies focus/blur events to/from the hidden input inside the shadow root", ->

spec/text-editor-spec.coffee

@@ -98,12 +98,13 @@ describe "TextEditor", ->
       expect(editor2.isFoldedAtBufferRow(4)).not.toBe editor.isFoldedAtBufferRow(4)
 
   describe "config defaults", ->
-    it "uses the `editor.tabLength`, `editor.softWrap`, and `editor.softTabs` config values", ->
+    it "uses the `editor.tabLength`, `editor.softWrap`, and `editor.softTabs`, and `core.fileEncoding` config values", ->
       editor1 = null
       editor2 = null
       atom.config.set('editor.tabLength', 4)
       atom.config.set('editor.softWrap', true)
       atom.config.set('editor.softTabs', false)
+      atom.config.set('core.fileEncoding', 'utf16le')
 
       waitsForPromise ->
         atom.workspace.open('a').then (o) -> editor1 = o
@@ -112,10 +113,12 @@ describe "TextEditor", ->
         expect(editor1.getTabLength()).toBe 4
         expect(editor1.isSoftWrapped()).toBe true
         expect(editor1.getSoftTabs()).toBe false
+        expect(editor1.getEncoding()).toBe 'utf16le'
 
         atom.config.set('editor.tabLength', 8)
         atom.config.set('editor.softWrap', false)
         atom.config.set('editor.softTabs', true)
+        atom.config.set('core.fileEncoding', 'macroman')
 
       waitsForPromise ->
         atom.workspace.open('b').then (o) -> editor2 = o
@@ -124,6 +127,7 @@ describe "TextEditor", ->
         expect(editor2.getTabLength()).toBe 8
         expect(editor2.isSoftWrapped()).toBe false
         expect(editor2.getSoftTabs()).toBe true
+        expect(editor2.getEncoding()).toBe 'macroman'
 
   describe "title", ->
     describe ".getTitle()", ->
@@ -2473,17 +2477,33 @@ describe "TextEditor", ->
           expect(editor.getCursorScreenPosition()).toEqual [0, editor.getTabLength() * 2]
 
     describe "clipboard operations", ->
-      beforeEach ->
-        editor.setSelectedBufferRanges([[[0, 4], [0, 13]], [[1, 6], [1, 10]]])
-
       describe ".cutSelectedText()", ->
         it "removes the selected text from the buffer and places it on the clipboard", ->
+          editor.setSelectedBufferRanges([[[0, 4], [0, 13]], [[1, 6], [1, 10]]])
           editor.cutSelectedText()
           expect(buffer.lineForRow(0)).toBe "var  = function () {"
           expect(buffer.lineForRow(1)).toBe "  var  = function(items) {"
-
           expect(clipboard.readText()).toBe 'quicksort\nsort'
 
+        describe "when no text is selected", ->
+          beforeEach ->
+            editor.setSelectedBufferRanges([
+              [[0, 0], [0, 0]],
+              [[5, 0], [5, 0]],
+            ])
+
+          it "cuts the lines on which there are cursors", ->
+            editor.cutSelectedText()
+            expect(buffer.getLineCount()).toBe(11)
+            expect(buffer.lineForRow(1)).toBe("    if (items.length <= 1) return items;")
+            expect(buffer.lineForRow(4)).toBe("      current < pivot ? left.push(current) : right.push(current);")
+            expect(atom.clipboard.read()).toEqual """
+              var quicksort = function () {
+
+                    current = items.shift();
+
+            """
+
       describe ".cutToEndOfLine()", ->
         describe "when soft wrap is on", ->
           it "cuts up to the end of the line", ->
@@ -2522,37 +2542,165 @@ describe "TextEditor", ->
           expect(buffer.lineForRow(1)).toBe "  var sort = function(items) {"
           expect(buffer.lineForRow(2)).toBe "    if (items.length <= 1) return items;"
           expect(clipboard.readText()).toBe 'quicksort\nsort\nitems'
-          expect(atom.clipboard.readWithMetadata().metadata.selections).toEqual([
-            'quicksort'
-            'sort'
-            'items'
-          ])
+          expect(atom.clipboard.read()).toEqual """
+            quicksort
+            sort
+            items
+          """
+
+        describe "when no text is selected", ->
+          beforeEach ->
+            editor.setSelectedBufferRanges([
+              [[1, 5], [1, 5]],
+              [[5, 8], [5, 8]]
+            ])
+
+          it "copies the lines on which there are cursors", ->
+            editor.copySelectedText()
+            expect(atom.clipboard.read()).toEqual([
+              "  var sort = function(items) {\n"
+              "      current = items.shift();\n"
+            ].join("\n"))
+            expect(editor.getSelectedBufferRanges()).toEqual([
+              [[1, 5], [1, 5]],
+              [[5, 8], [5, 8]]
+            ])
 
       describe ".pasteText()", ->
+        copyText = (text, {startColumn, textEditor}={}) ->
+          startColumn ?= 0
+          textEditor ?= editor
+          textEditor.setCursorBufferPosition([0, 0])
+          textEditor.insertText(text)
+          numberOfNewlines = text.match(/\n/g)?.length
+          endColumn = text.match(/[^\n]*$/)[0]?.length
+          textEditor.getLastSelection().setBufferRange([[0,startColumn], [numberOfNewlines,endColumn]])
+          textEditor.cutSelectedText()
+
         it "pastes text into the buffer", ->
+          editor.setSelectedBufferRanges([[[0, 4], [0, 13]], [[1, 6], [1, 10]]])
           atom.clipboard.write('first')
           editor.pasteText()
           expect(editor.lineTextForBufferRow(0)).toBe "var first = function () {"
           expect(editor.lineTextForBufferRow(1)).toBe "  var first = function(items) {"
 
+        describe "when `autoIndentOnPaste` is true", ->
+          beforeEach ->
+            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])
+              editor.pasteText()
+              expect(editor.lineTextForBufferRow(5)).toBe("      console.log(x);")
+              expect(editor.lineTextForBufferRow(6)).toBe("      console.log(y);")
+
+          describe "when non-whitespace characters precede the cursor", ->
+            it "does not auto-indent the first line being pasted", ->
+              editor.setText """
+              if (x) {
+                  y();
+              }
+              """
+
+              atom.clipboard.write(" z();")
+              editor.setCursorBufferPosition([1, Infinity])
+              editor.pasteText()
+              expect(editor.lineTextForBufferRow(1)).toBe("    y(); z();")
+
+        describe "when `autoIndentOnPaste` is false", ->
+          beforeEach ->
+            atom.config.set('editor.autoIndentOnPaste', false)
+
+          describe "when the cursor is indented further than the original copied text", ->
+            it "increases the indentation of the copied lines to match", ->
+              editor.setSelectedBufferRange([[1, 2], [3, 0]])
+              editor.copySelectedText()
+
+              editor.setCursorBufferPosition([5, 6])
+              editor.pasteText()
+
+              expect(editor.lineTextForBufferRow(5)).toBe "      var sort = function(items) {"
+              expect(editor.lineTextForBufferRow(6)).toBe "        if (items.length <= 1) return items;"
+
+          describe "when the cursor is indented less far than the original copied text", ->
+            it "decreases the indentation of the copied lines to match", ->
+              editor.setSelectedBufferRange([[6, 6], [8, 0]])
+              editor.copySelectedText()
+
+              editor.setCursorBufferPosition([1, 2])
+              editor.pasteText()
+
+              expect(editor.lineTextForBufferRow(1)).toBe "  current < pivot ? left.push(current) : right.push(current);"
+              expect(editor.lineTextForBufferRow(2)).toBe "}"
+
+          describe "when the first copied line has leading whitespace", ->
+            it "preserves the line's leading whitespace", ->
+              editor.setSelectedBufferRange([[4, 0], [6, 0]])
+              editor.copySelectedText()
+
+              editor.setCursorBufferPosition([0, 0])
+              editor.pasteText()
+
+              expect(editor.lineTextForBufferRow(0)).toBe "    while(items.length > 0) {"
+              expect(editor.lineTextForBufferRow(1)).toBe "      current = items.shift();"
+
         describe 'when the clipboard has many selections', ->
+          beforeEach ->
+            atom.config.set("editor.autoIndentOnPaste", false)
+            editor.setSelectedBufferRanges([[[0, 4], [0, 13]], [[1, 6], [1, 10]]])
+            editor.copySelectedText()
+
           it "pastes each selection separately into the buffer", ->
-            atom.clipboard.write('first\nsecond', {selections: ['first', 'second'] })
+            editor.copySelectedText()
+            editor.moveRight()
+            editor.insertText("_")
             editor.pasteText()
-            expect(editor.lineTextForBufferRow(0)).toBe "var first = function () {"
-            expect(editor.lineTextForBufferRow(1)).toBe "  var second = function(items) {"
+            expect(editor.lineTextForBufferRow(0)).toBe "var quicksort_quicksort = function () {"
+            expect(editor.lineTextForBufferRow(1)).toBe "  var sort_sort = function(items) {"
 
           describe 'and the selections count does not match', ->
-            it "pastes the whole text into the buffer", ->
-              atom.clipboard.write('first\nsecond\nthird', {selections: ['first', 'second', 'third'] })
-              editor.pasteText()
-              expect(editor.lineTextForBufferRow(0)).toBe "var first"
-              expect(editor.lineTextForBufferRow(1)).toBe "second"
-              expect(editor.lineTextForBufferRow(2)).toBe "third = function () {"
+            beforeEach ->
+              editor.setSelectedBufferRanges([[[0, 4], [0, 13]]])
 
-              expect(editor.lineTextForBufferRow(3)).toBe "  var first"
-              expect(editor.lineTextForBufferRow(4)).toBe "second"
-              expect(editor.lineTextForBufferRow(5)).toBe "third = function(items) {"
+            it "pastes the whole text into the buffer", ->
+              editor.pasteText()
+              expect(editor.lineTextForBufferRow(0)).toBe "var quicksort"
+              expect(editor.lineTextForBufferRow(1)).toBe "sort = function () {"
+
+        describe "when a full line was cut", ->
+          beforeEach ->
+            editor.setCursorBufferPosition([2, 13])
+            editor.cutSelectedText()
+            editor.setCursorBufferPosition([2, 13])
+
+          it "pastes the line above the cursor and retains the cursor's column", ->
+            editor.pasteText()
+            expect(editor.lineTextForBufferRow(2)).toBe("    if (items.length <= 1) return items;")
+            expect(editor.lineTextForBufferRow(3)).toBe("    var pivot = items.shift(), current, left = [], right = [];")
+            expect(editor.getCursorBufferPosition()).toEqual([3, 13])
+
+        describe "when a full line was copied", ->
+          beforeEach ->
+            editor.setCursorBufferPosition([2, 13])
+            editor.copySelectedText()
+
+          describe "when there is a selection", ->
+            it "overwrites the selection as with any copied text", ->
+              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(3)).toBe("    if (items.length <= 1) return items;")
+              expect(editor.getCursorBufferPosition()).toEqual([2, 2])
+
+          describe "when there is no selection", ->
+            it "pastes the line above the cursor and retains the cursor's column", ->
+              editor.pasteText()
+              expect(editor.lineTextForBufferRow(2)).toBe("    if (items.length <= 1) return items;")
+              expect(editor.lineTextForBufferRow(3)).toBe("    if (items.length <= 1) return items;")
+              expect(editor.getCursorBufferPosition()).toEqual([3, 13])
 
     describe ".indentSelectedRows()", ->
       describe "when nothing is selected", ->
@@ -2683,6 +2831,18 @@ describe "TextEditor", ->
 
           expect(editor.getSelectedBufferRange()).toEqual [[0, 1], [3, 0]]
 
+    describe ".autoIndentSelectedRows", ->
+      it "auto-indents the selection", ->
+        editor.setCursorBufferPosition([2, 0])
+        editor.insertText("function() {\ninside=true\n}\n  i=1\n")
+        editor.getLastSelection().setBufferRange([[2,0], [6,0]])
+        editor.autoIndentSelectedRows()
+
+        expect(editor.lineTextForBufferRow(2)).toBe "    function() {"
+        expect(editor.lineTextForBufferRow(3)).toBe "      inside=true"
+        expect(editor.lineTextForBufferRow(4)).toBe "    }"
+        expect(editor.lineTextForBufferRow(5)).toBe "    i=1"
+
     describe ".toggleLineCommentsInSelection()", ->
       it "toggles comments on the selected lines", ->
         editor.setSelectedBufferRange([[4, 5], [7, 5]])
@@ -3172,251 +3332,159 @@ describe "TextEditor", ->
     it "switches to the better-matched grammar and re-tokenizes the buffer", ->
       editor.destroy()
 
-      jsGrammar = atom.syntax.selectGrammar('a.js')
-      atom.syntax.removeGrammar(jsGrammar)
+      jsGrammar = atom.grammars.selectGrammar('a.js')
+      atom.grammars.removeGrammar(jsGrammar)
 
       waitsForPromise ->
         atom.workspace.open('sample.js', autoIndent: false).then (o) -> editor = o
 
       runs ->
-        expect(editor.getGrammar()).toBe atom.syntax.nullGrammar
+        expect(editor.getGrammar()).toBe atom.grammars.nullGrammar
         expect(editor.tokenizedLineForScreenRow(0).tokens.length).toBe 1
 
-        atom.syntax.addGrammar(jsGrammar)
+        atom.grammars.addGrammar(jsGrammar)
         expect(editor.getGrammar()).toBe jsGrammar
         expect(editor.tokenizedLineForScreenRow(0).tokens.length).toBeGreaterThan 1
 
-  describe "auto-indent", ->
-    copyText = (text, {startColumn, textEditor}={}) ->
-      startColumn ?= 0
-      textEditor ?= editor
-      textEditor.setCursorBufferPosition([0, 0])
-      textEditor.insertText(text)
-      numberOfNewlines = text.match(/\n/g)?.length
-      endColumn = text.match(/[^\n]*$/)[0]?.length
-      textEditor.getLastSelection().setBufferRange([[0,startColumn], [numberOfNewlines,endColumn]])
-      textEditor.cutSelectedText()
-
-    describe "editor.autoIndent", ->
-      describe "when editor.autoIndent is false (default)", ->
-        describe "when `indent` is triggered", ->
-          it "does not auto-indent the line", ->
-            editor.setCursorBufferPosition([1, 30])
-            editor.insertText("\n ")
-            expect(editor.lineTextForBufferRow(2)).toBe " "
-
-            atom.config.set("editor.autoIndent", false)
-            editor.indent()
-            expect(editor.lineTextForBufferRow(2)).toBe "  "
-
-      describe "when editor.autoIndent is true", ->
-        beforeEach ->
-          atom.config.set("editor.autoIndent", true)
-
-        describe "when `indent` is triggered", ->
-          it "auto-indents the line", ->
-            editor.setCursorBufferPosition([1, 30])
-            editor.insertText("\n ")
-            expect(editor.lineTextForBufferRow(2)).toBe " "
-
-            atom.config.set("editor.autoIndent", true)
-            editor.indent()
-            expect(editor.lineTextForBufferRow(2)).toBe "    "
-
-        describe "when a newline is added", ->
-          describe "when the line preceding the newline adds a new level of indentation", ->
-            it "indents the newline to one additional level of indentation beyond the preceding line", ->
-              editor.setCursorBufferPosition([1, Infinity])
-              editor.insertText('\n')
-              expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1) + 1
-
-          describe "when the line preceding the newline does't add a level of indentation", ->
-            it "indents the new line to the same level a as the preceding line", ->
-              editor.setCursorBufferPosition([5, 14])
-              editor.insertText('\n')
-              expect(editor.indentationForBufferRow(6)).toBe editor.indentationForBufferRow(5)
-
-          describe "when the line preceding the newline is a comment", ->
-            it "maintains the indent of the commented line", ->
-              editor.setCursorBufferPosition([0, 0])
-              editor.insertText('    //')
-              editor.setCursorBufferPosition([0, Infinity])
-              editor.insertText('\n')
-              expect(editor.indentationForBufferRow(1)).toBe 2
-
-          it "does not indent the line preceding the newline", ->
-            editor.setCursorBufferPosition([2, 0])
-            editor.insertText('  var this-line-should-be-indented-more\n')
-            expect(editor.indentationForBufferRow(1)).toBe 1
-
-            atom.config.set("editor.autoIndent", true)
-            editor.setCursorBufferPosition([2, Infinity])
-            editor.insertText('\n')
-            expect(editor.indentationForBufferRow(1)).toBe 1
-            expect(editor.indentationForBufferRow(2)).toBe 1
-
-          describe "when the cursor is before whitespace", ->
-            it "retains the whitespace following the cursor on the new line", ->
-              editor.setText("  var sort = function() {}")
-              editor.setCursorScreenPosition([0, 23])
-              editor.insertNewline()
-
-              expect(buffer.lineForRow(0)).toBe '  var sort = function()'
-              expect(buffer.lineForRow(1)).toBe '   {}'
-              expect(editor.getCursorScreenPosition()).toEqual [1, 2]
-
-        describe "when inserted text matches a decrease indent pattern", ->
-          describe "when the preceding line matches an increase indent pattern", ->
-            it "decreases the indentation to match that of the preceding line", ->
-              editor.setCursorBufferPosition([1, Infinity])
-              editor.insertText('\n')
-              expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1) + 1
-              editor.insertText('}')
-              expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1)
-
-          describe "when the preceding line doesn't match an increase indent pattern", ->
-            it "decreases the indentation to be one level below that of the preceding line", ->
-              editor.setCursorBufferPosition([3, Infinity])
-              editor.insertText('\n    ')
-              expect(editor.indentationForBufferRow(4)).toBe editor.indentationForBufferRow(3)
-              editor.insertText('}')
-              expect(editor.indentationForBufferRow(4)).toBe editor.indentationForBufferRow(3) - 1
-
-            it "doesn't break when decreasing the indentation on a row that has no indentation", ->
-              editor.setCursorBufferPosition([12, Infinity])
-              editor.insertText("\n}; # too many closing brackets!")
-              expect(editor.lineTextForBufferRow(13)).toBe "}; # too many closing brackets!"
-
-        describe "when inserted text does not match a decrease indent pattern", ->
-          it "does not decrease the indentation", ->
-            editor.setCursorBufferPosition([12, 0])
-            editor.insertText('  ')
-            expect(editor.lineTextForBufferRow(12)).toBe '  };'
-            editor.insertText('\t\t')
-            expect(editor.lineTextForBufferRow(12)).toBe '  \t\t};'
-
-        describe "when the current line does not match a decrease indent pattern", ->
-          it "leaves the line unchanged", ->
-            editor.setCursorBufferPosition([2, 4])
-            expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1) + 1
-            editor.insertText('foo')
-            expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1) + 1
-
-      describe 'when scoped settings are used', ->
-        coffeeEditor = null
-        beforeEach ->
-          waitsForPromise ->
-            atom.packages.activatePackage('language-coffee-script')
-          waitsForPromise ->
-            atom.project.open('coffee.coffee', autoIndent: false).then (o) -> coffeeEditor = o
-
-          runs ->
-            atom.config.set('.source.js', 'editor.autoIndent', true)
-            atom.config.set('.source.coffee', 'editor.autoIndent', false)
-
-        afterEach: ->
-          atom.packages.deactivatePackages()
-          atom.packages.unloadPackages()
-
-        it "does not auto-indent the line for javascript files", ->
+  describe "editor.autoIndent", ->
+    describe "when editor.autoIndent is false (default)", ->
+      describe "when `indent` is triggered", ->
+        it "does not auto-indent the line", ->
           editor.setCursorBufferPosition([1, 30])
-          editor.insertText("\n")
+          editor.insertText("\n ")
+          expect(editor.lineTextForBufferRow(2)).toBe " "
+
+          atom.config.set("editor.autoIndent", false)
+          editor.indent()
+          expect(editor.lineTextForBufferRow(2)).toBe "  "
+
+    describe "when editor.autoIndent is true", ->
+      beforeEach ->
+        atom.config.set("editor.autoIndent", true)
+
+      describe "when `indent` is triggered", ->
+        it "auto-indents the line", ->
+          editor.setCursorBufferPosition([1, 30])
+          editor.insertText("\n ")
+          expect(editor.lineTextForBufferRow(2)).toBe " "
+
+          atom.config.set("editor.autoIndent", true)
+          editor.indent()
           expect(editor.lineTextForBufferRow(2)).toBe "    "
 
-          coffeeEditor.setCursorBufferPosition([1, 18])
-          coffeeEditor.insertText("\n")
-          expect(coffeeEditor.lineTextForBufferRow(2)).toBe ""
-
-    describe "editor.normalizeIndentOnPaste", ->
-      beforeEach ->
-        atom.config.set('editor.normalizeIndentOnPaste', true)
-
-      it "does not normalize the indentation level of the text when editor.normalizeIndentOnPaste is false", ->
-        copyText("   function() {\nvar cool = 1;\n  }\n")
-        atom.config.set('editor.normalizeIndentOnPaste', false)
-        editor.setCursorBufferPosition([5, 2])
-        editor.pasteText()
-        expect(editor.lineTextForBufferRow(5)).toBe "     function() {"
-        expect(editor.lineTextForBufferRow(6)).toBe "var cool = 1;"
-        expect(editor.lineTextForBufferRow(7)).toBe "  }"
-
-      describe "when the inserted text contains no newlines", ->
-        it "does not adjust the indentation level of the text", ->
-          editor.setCursorBufferPosition([5, 2])
-          editor.insertText("foo", indentBasis: 5)
-          expect(editor.lineTextForBufferRow(5)).toBe "  foo    current = items.shift();"
-
-        it "does not adjust the whitespace if there are preceding characters", ->
-          copyText(" foo")
-          editor.setCursorBufferPosition([5, 30])
-          editor.pasteText()
-
-          expect(editor.lineTextForBufferRow(5)).toBe "      current = items.shift(); foo"
-
-      describe "when the inserted text contains newlines", ->
-        describe "when the cursor is preceded only by whitespace characters", ->
-          it "normalizes indented lines to the cursor's current indentation level", ->
-            copyText("    while (true) {\n      foo();\n    }\n", {startColumn: 2})
-            editor.setCursorBufferPosition([3, 4])
-            editor.pasteText()
-
-            expect(editor.lineTextForBufferRow(3)).toBe "    while (true) {"
-            expect(editor.lineTextForBufferRow(4)).toBe "      foo();"
-            expect(editor.lineTextForBufferRow(5)).toBe "    }"
-            expect(editor.lineTextForBufferRow(6)).toBe "var pivot = items.shift(), current, left = [], right = [];"
-
-        describe "when the cursor is preceded by non-whitespace characters", ->
-          it "normalizes the indentation level of all lines based on the level of the existing first line", ->
-            copyText("    while (true) {\n      foo();\n    }\n", {startColumn: 0})
+      describe "when a newline is added", ->
+        describe "when the line preceding the newline adds a new level of indentation", ->
+          it "indents the newline to one additional level of indentation beyond the preceding line", ->
             editor.setCursorBufferPosition([1, Infinity])
-            editor.pasteText()
+            editor.insertText('\n')
+            expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1) + 1
 
-            expect(editor.lineTextForBufferRow(1)).toBe "  var sort = function(items) {while (true) {"
-            expect(editor.lineTextForBufferRow(2)).toBe "    foo();"
-            expect(editor.lineTextForBufferRow(3)).toBe "  }"
-            expect(editor.lineTextForBufferRow(4)).toBe ""
+        describe "when the line preceding the newline does't add a level of indentation", ->
+          it "indents the new line to the same level a as the preceding line", ->
+            editor.setCursorBufferPosition([5, 14])
+            editor.insertText('\n')
+            expect(editor.indentationForBufferRow(6)).toBe editor.indentationForBufferRow(5)
 
-      describe 'when scoped settings are used', ->
-        coffeeEditor = null
-        beforeEach ->
-          waitsForPromise ->
-            atom.packages.activatePackage('language-coffee-script')
-          waitsForPromise ->
-            atom.project.open('coffee.coffee', autoIndent: false).then (o) -> coffeeEditor = o
+        describe "when the line preceding the newline is a comment", ->
+          it "maintains the indent of the commented line", ->
+            editor.setCursorBufferPosition([0, 0])
+            editor.insertText('    //')
+            editor.setCursorBufferPosition([0, Infinity])
+            editor.insertText('\n')
+            expect(editor.indentationForBufferRow(1)).toBe 2
 
-          runs ->
-            atom.config.set('.source.js', 'editor.normalizeIndentOnPaste', true)
-            atom.config.set('.source.coffee', 'editor.normalizeIndentOnPaste', false)
+        describe "when the line preceding the newline contains only whitespace", ->
+          it "bases the new line's indentation on only the preceding line", ->
+            editor.setCursorBufferPosition([6, Infinity])
+            editor.insertText("\n  ")
+            expect(editor.getCursorBufferPosition()).toEqual([7, 2])
 
-        afterEach: ->
-          atom.packages.deactivatePackages()
-          atom.packages.unloadPackages()
+            editor.insertNewline()
+            editor.logScreenLines()
+            expect(editor.lineTextForBufferRow(8)).toBe("  ")
 
-        it "normalizes the indentation level based on scoped settings", ->
-          copyText("    while (true) {\n      foo();\n    }\n", {startColumn: 2, textEditor: coffeeEditor})
-          coffeeEditor.setCursorBufferPosition([4, 4])
-          coffeeEditor.pasteText()
-          expect(coffeeEditor.lineTextForBufferRow(4)).toBe "      while (true) {"
-          expect(coffeeEditor.lineTextForBufferRow(5)).toBe "      foo();"
-          expect(coffeeEditor.lineTextForBufferRow(6)).toBe "    }"
+        it "does not indent the line preceding the newline", ->
+          editor.setCursorBufferPosition([2, 0])
+          editor.insertText('  var this-line-should-be-indented-more\n')
+          expect(editor.indentationForBufferRow(1)).toBe 1
 
-          copyText("    while (true) {\n      foo();\n    }\n", {startColumn: 2})
-          editor.setCursorBufferPosition([3, 4])
-          editor.pasteText()
-          expect(editor.lineTextForBufferRow(3)).toBe "    while (true) {"
-          expect(editor.lineTextForBufferRow(4)).toBe "      foo();"
-          expect(editor.lineTextForBufferRow(5)).toBe "    }"
+          atom.config.set("editor.autoIndent", true)
+          editor.setCursorBufferPosition([2, Infinity])
+          editor.insertText('\n')
+          expect(editor.indentationForBufferRow(1)).toBe 1
+          expect(editor.indentationForBufferRow(2)).toBe 1
 
-    it "autoIndentSelectedRows auto-indents the selection", ->
-      editor.setCursorBufferPosition([2, 0])
-      editor.insertText("function() {\ninside=true\n}\n  i=1\n")
-      editor.getLastSelection().setBufferRange([[2,0], [6,0]])
-      editor.autoIndentSelectedRows()
+        describe "when the cursor is before whitespace", ->
+          it "retains the whitespace following the cursor on the new line", ->
+            editor.setText("  var sort = function() {}")
+            editor.setCursorScreenPosition([0, 23])
+            editor.insertNewline()
 
-      expect(editor.lineTextForBufferRow(2)).toBe "    function() {"
-      expect(editor.lineTextForBufferRow(3)).toBe "      inside=true"
-      expect(editor.lineTextForBufferRow(4)).toBe "    }"
-      expect(editor.lineTextForBufferRow(5)).toBe "    i=1"
+            expect(buffer.lineForRow(0)).toBe '  var sort = function()'
+            expect(buffer.lineForRow(1)).toBe '   {}'
+            expect(editor.getCursorScreenPosition()).toEqual [1, 2]
+
+      describe "when inserted text matches a decrease indent pattern", ->
+        describe "when the preceding line matches an increase indent pattern", ->
+          it "decreases the indentation to match that of the preceding line", ->
+            editor.setCursorBufferPosition([1, Infinity])
+            editor.insertText('\n')
+            expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1) + 1
+            editor.insertText('}')
+            expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1)
+
+        describe "when the preceding line doesn't match an increase indent pattern", ->
+          it "decreases the indentation to be one level below that of the preceding line", ->
+            editor.setCursorBufferPosition([3, Infinity])
+            editor.insertText('\n    ')
+            expect(editor.indentationForBufferRow(4)).toBe editor.indentationForBufferRow(3)
+            editor.insertText('}')
+            expect(editor.indentationForBufferRow(4)).toBe editor.indentationForBufferRow(3) - 1
+
+          it "doesn't break when decreasing the indentation on a row that has no indentation", ->
+            editor.setCursorBufferPosition([12, Infinity])
+            editor.insertText("\n}; # too many closing brackets!")
+            expect(editor.lineTextForBufferRow(13)).toBe "}; # too many closing brackets!"
+
+      describe "when inserted text does not match a decrease indent pattern", ->
+        it "does not decrease the indentation", ->
+          editor.setCursorBufferPosition([12, 0])
+          editor.insertText('  ')
+          expect(editor.lineTextForBufferRow(12)).toBe '  };'
+          editor.insertText('\t\t')
+          expect(editor.lineTextForBufferRow(12)).toBe '  \t\t};'
+
+      describe "when the current line does not match a decrease indent pattern", ->
+        it "leaves the line unchanged", ->
+          editor.setCursorBufferPosition([2, 4])
+          expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1) + 1
+          editor.insertText('foo')
+          expect(editor.indentationForBufferRow(2)).toBe editor.indentationForBufferRow(1) + 1
+
+    describe 'when scoped settings are used', ->
+      coffeeEditor = null
+      beforeEach ->
+        waitsForPromise ->
+          atom.packages.activatePackage('language-coffee-script')
+        waitsForPromise ->
+          atom.project.open('coffee.coffee', autoIndent: false).then (o) -> coffeeEditor = o
+
+        runs ->
+          atom.config.set('.source.js', 'editor.autoIndent', true)
+          atom.config.set('.source.coffee', 'editor.autoIndent', false)
+
+      afterEach: ->
+        atom.packages.deactivatePackages()
+        atom.packages.unloadPackages()
+
+      it "does not auto-indent the line for javascript files", ->
+        editor.setCursorBufferPosition([1, 30])
+        editor.insertText("\n")
+        expect(editor.lineTextForBufferRow(2)).toBe "    "
+
+        coffeeEditor.setCursorBufferPosition([1, 18])
+        coffeeEditor.insertText("\n")
+        expect(coffeeEditor.lineTextForBufferRow(2)).toBe ""
 
   describe "soft and hard tabs", ->
     afterEach ->
@@ -3438,6 +3506,19 @@ describe "TextEditor", ->
       runs ->
         expect(editor.softTabs).toBe false
 
+    it "uses hard tabs in Makefile files", ->
+      # FIXME remove once this is handled by a scoped setting in the
+      # language-make package
+
+      waitsForPromise ->
+        atom.packages.activatePackage('language-make')
+
+      waitsForPromise ->
+        atom.project.open('Makefile').then (o) -> editor = o
+
+      runs ->
+        expect(editor.softTabs).toBe false
+
   describe ".destroy()", ->
     it "destroys all markers associated with the edit session", ->
       expect(buffer.getMarkerCount()).toBeGreaterThan 0
@@ -3681,7 +3762,7 @@ describe "TextEditor", ->
 
     it "updates the grammar based on grammar overrides", ->
       expect(editor.getGrammar().name).toBe 'JavaScript'
-      atom.syntax.setGrammarOverrideForPath(editor.getPath(), 'source.coffee')
+      atom.grammars.setGrammarOverrideForPath(editor.getPath(), 'source.coffee')
       editor.reloadGrammar()
       expect(editor.getGrammar().name).toBe 'CoffeeScript'
 
@@ -3699,7 +3780,7 @@ describe "TextEditor", ->
         atom.packages.activatePackage('language-hyperlink')
 
       runs ->
-        grammar = atom.syntax.selectGrammar("text.js")
+        grammar = atom.grammars.selectGrammar("text.js")
         {tokens} = grammar.tokenizeLine("var i; // http://github.com")
 
         expect(tokens[0].value).toBe "var"

spec/theme-manager-spec.coffee

@@ -70,7 +70,7 @@ 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()
-      spyOn(themeManager, 'getUserStylesheetPath').andCallFake -> null
+      spyOn(atom.styles, 'getUserStyleSheetPath').andCallFake -> null
 
       waitsForPromise ->
         themeManager.activateThemes()
@@ -207,10 +207,11 @@ describe "ThemeManager", ->
       expect(stylesheetsChangedHandler).toHaveBeenCalled()
 
   describe "base stylesheet loading", ->
+    workspaceElement = null
     beforeEach ->
-      atom.workspaceView = atom.views.getView(atom.workspace).__spacePenView
-      atom.workspaceView.append $('<atom-text-editor>')
-      atom.workspaceView.attachToDom()
+      workspaceElement = atom.views.getView(atom.workspace)
+      jasmine.attachToDOM(workspaceElement)
+      workspaceElement.appendChild document.createElement('atom-text-editor')
 
       waitsForPromise ->
         themeManager.activateThemes()
@@ -224,7 +225,7 @@ describe "ThemeManager", ->
 
       runs ->
         # an override loaded in the base css
-        expect(atom.workspaceView.css("background-color")).toBe "rgb(0, 0, 255)"
+        expect(getComputedStyle(workspaceElement)["background-color"]).toBe "rgb(0, 0, 255)"
 
         # from within the theme itself
         expect($("atom-text-editor").css("padding-top")).toBe "150px"
@@ -241,14 +242,14 @@ describe "ThemeManager", ->
 
         runs ->
           # an override loaded in the base css
-          expect(atom.workspaceView.css("background-color")).toBe "rgb(0, 0, 255)"
+          expect(getComputedStyle(workspaceElement)["background-color"]).toBe "rgb(0, 0, 255)"
 
           # 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(atom.workspaceView).toHaveClass 'theme-atom-dark-ui'
+        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'])
@@ -258,17 +259,17 @@ describe "ThemeManager", ->
 
         runs ->
           # `theme-` twice as it prefixes the name with `theme-`
-          expect(atom.workspaceView).toHaveClass 'theme-theme-with-ui-variables'
-          expect(atom.workspaceView).toHaveClass 'theme-theme-with-syntax-variables'
-          expect(atom.workspaceView).not.toHaveClass 'theme-atom-dark-ui'
-          expect(atom.workspaceView).not.toHaveClass 'theme-atom-dark-syntax'
+          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", ->
     it "reloads it", ->
       [stylesheetRemovedHandler, stylesheetAddedHandler, stylesheetsChangedHandler] = []
       userStylesheetPath = path.join(temp.mkdirSync("atom"), 'styles.less')
       fs.writeFileSync(userStylesheetPath, 'body {border-style: dotted !important;}')
-      spyOn(themeManager, 'getUserStylesheetPath').andReturn userStylesheetPath
+      spyOn(atom.styles, 'getUserStyleSheetPath').andReturn userStylesheetPath
 
       waitsForPromise ->
         themeManager.activateThemes()

spec/tokenized-buffer-spec.coffee

@@ -522,7 +522,7 @@ describe "TokenizedBuffer", ->
         buffer = atom.project.bufferForPathSync()
         buffer.setText "<div class='name'><%= User.find(2).full_name %></div>"
         tokenizedBuffer = new TokenizedBuffer({buffer})
-        tokenizedBuffer.setGrammar(atom.syntax.selectGrammar('test.erb'))
+        tokenizedBuffer.setGrammar(atom.grammars.selectGrammar('test.erb'))
         fullyTokenize(tokenizedBuffer)
 
         {tokens} = tokenizedBuffer.tokenizedLineForRow(0)

spec/tooltip-manager-spec.coffee

@@ -0,0 +1,72 @@
+TooltipManager = require '../src/tooltip-manager'
+{$} = require '../src/space-pen-extensions'
+
+describe "TooltipManager", ->
+  [manager, element] = []
+
+  beforeEach ->
+    manager = new TooltipManager
+    element = document.createElement('div')
+    element.classList.add('foo')
+    jasmine.attachToDOM(element)
+
+  hover = (element, fn) ->
+    $(element).trigger 'mouseenter'
+    advanceClock(manager.defaults.delay.show)
+    fn()
+    $(element).trigger 'mouseleave'
+    advanceClock(manager.defaults.delay.hide)
+
+  describe "::add(target, options)", ->
+    describe "when the target is an element", ->
+      it "creates a tooltip based on the given options when hovering over the target element", ->
+        manager.add element, title: "Title"
+        hover element, ->
+          expect(document.body.querySelector(".tooltip")).toHaveText("Title")
+
+    describe "when a keyBindingCommand is specified", ->
+      describe "when a title is specified", ->
+        it "appends the key binding corresponding to the command to the title", ->
+          atom.keymaps.add 'test',
+            '.foo': 'ctrl-x ctrl-y': 'test-command'
+            '.bar': 'ctrl-x ctrl-z': 'test-command'
+
+          manager.add element, title: "Title", keyBindingCommand: 'test-command'
+
+          hover element, ->
+            tooltipElement = document.body.querySelector(".tooltip")
+            expect(tooltipElement).toHaveText "Title ⌃X ⌃Y"
+
+      describe "when no title is specified", ->
+        it "shows the key binding corresponding to the command alone", ->
+          atom.keymaps.add 'test', '.foo': 'ctrl-x ctrl-y': 'test-command'
+
+          manager.add element, keyBindingCommand: 'test-command'
+
+          hover element, ->
+            tooltipElement = document.body.querySelector(".tooltip")
+            expect(tooltipElement).toHaveText "⌃X ⌃Y"
+
+      describe "when a keyBindingTarget is specified", ->
+        it "looks up the key binding relative to the target", ->
+          atom.keymaps.add 'test',
+            '.bar': 'ctrl-x ctrl-z': 'test-command'
+            '.foo': 'ctrl-x ctrl-y': 'test-command'
+
+          manager.add element, keyBindingCommand: 'test-command', keyBindingTarget: element
+
+          hover element, ->
+            tooltipElement = document.body.querySelector(".tooltip")
+            expect(tooltipElement).toHaveText "⌃X ⌃Y"
+
+    describe "when .dispose() is called on the returned disposable", ->
+      it "no longer displays the tooltip on hover", ->
+        disposable = manager.add element, title: "Title"
+
+        hover element, ->
+          expect(document.body.querySelector(".tooltip")).toHaveText("Title")
+
+        disposable.dispose()
+
+        hover element, ->
+          expect(document.body.querySelector(".tooltip")).toBeNull()

spec/window-spec.coffee

@@ -95,13 +95,13 @@ describe "Window", ->
   describe ".unloadEditorWindow()", ->
     it "saves the serialized state of the window so it can be deserialized after reload", ->
       workspaceState = atom.workspace.serialize()
-      syntaxState = atom.syntax.serialize()
+      syntaxState = atom.grammars.serialize()
       projectState = atom.project.serialize()
 
       atom.unloadEditorWindow()
 
       expect(atom.state.workspace).toEqual workspaceState
-      expect(atom.state.syntax).toEqual syntaxState
+      expect(atom.state.grammars).toEqual syntaxState
       expect(atom.state.project).toEqual projectState
       expect(atom.saveSync).toHaveBeenCalled()
 
@@ -112,9 +112,9 @@ describe "Window", ->
 
       runs ->
         buffer = atom.workspace.getActivePaneItem().buffer
-        pane = atom.workspaceView.getActivePaneView()
-        pane.splitRight(pane.copyActiveItem())
-        expect(atom.workspaceView.find('atom-text-editor').length).toBe 2
+        pane = atom.workspace.getActivePane()
+        pane.splitRight(copyActiveItem: true)
+        expect(atom.workspace.getTextEditors().length).toBe 2
 
         atom.removeEditorWindow()
 

spec/workspace-spec.coffee

@@ -500,4 +500,3 @@ describe "Workspace", ->
 
         expect(panel).toBeDefined()
         expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0})
-        expect(panel.getClassName()).toBe 'overlay from-top' # the default

spec/workspace-view-spec.coffee

@@ -277,15 +277,15 @@ describe "WorkspaceView", ->
       workspaceElement = atom.views.getView(atom.workspace)
 
     it 'inserts panel container elements in the correct places in the DOM', ->
-      leftContainer = workspaceElement.querySelector('atom-panel-container[location="left"]')
-      rightContainer = workspaceElement.querySelector('atom-panel-container[location="right"]')
+      leftContainer = workspaceElement.querySelector('atom-panel-container.left')
+      rightContainer = workspaceElement.querySelector('atom-panel-container.right')
       expect(leftContainer.nextSibling).toBe workspaceElement.verticalAxis
       expect(rightContainer.previousSibling).toBe workspaceElement.verticalAxis
 
-      topContainer = workspaceElement.querySelector('atom-panel-container[location="top"]')
-      bottomContainer = workspaceElement.querySelector('atom-panel-container[location="bottom"]')
+      topContainer = workspaceElement.querySelector('atom-panel-container.top')
+      bottomContainer = workspaceElement.querySelector('atom-panel-container.bottom')
       expect(topContainer.nextSibling).toBe workspaceElement.paneContainer
       expect(bottomContainer.previousSibling).toBe workspaceElement.paneContainer
 
-      modalContainer = workspaceElement.querySelector('atom-panel-container[location="modal"]')
+      modalContainer = workspaceElement.querySelector('atom-panel-container.modal')
       expect(modalContainer.parentNode).toBe workspaceElement

src/atom.coffee

@@ -5,6 +5,7 @@ path = require 'path'
 remote = require 'remote'
 screen = require 'screen'
 shell = require 'shell'
+{deprecate} = require 'grim'
 
 _ = require 'underscore-plus'
 {deprecate} = require 'grim'
@@ -33,6 +34,23 @@ class Atom extends Model
     startTime = Date.now()
     atom = @deserialize(@loadState(mode)) ? new this({mode, @version})
     atom.deserializeTimings.atom = Date.now() -  startTime
+
+    workspaceViewDeprecationMessage = """
+      atom.workspaceView is no longer available.
+      In most cases you will not need the view. See the Workspace docs for
+      alternatives: https://atom.io/docs/api/latest/Workspace.
+      If you do need the view, please use `atom.views.getView(atom.workspace)`,
+      which returns an HTMLElement.
+    """
+
+    Object.defineProperty atom, 'workspaceView',
+      get: ->
+        deprecate(workspaceViewDeprecationMessage)
+        atom.__workspaceView
+      set: (newValue) ->
+        deprecate(workspaceViewDeprecationMessage)
+        atom.__workspaceView = newValue
+
     atom
 
   # Deserializes the Atom environment from a state object
@@ -125,11 +143,17 @@ class Atom extends Model
   # Public: A {KeymapManager} instance
   keymaps: null
 
+  # Public: A {TooltipManager} instance
+  tooltips: null
+
+  # Experimental: A {NotificationManager} instance
+  notifications: null
+
   # Public: A {Project} instance
   project: null
 
-  # Public: A {Syntax} instance
-  syntax: null
+  # Public: A {GrammarRegistry} instance
+  grammars: null
 
   # Public: A {PackageManager} instance
   packages: null
@@ -137,6 +161,9 @@ class Atom extends Model
   # Public: A {ThemeManager} instance
   themes: null
 
+  # Public: A {StyleManager} instance
+  styles: null
+
   # Public: A {DeserializerManager} instance
   deserializers: null
 
@@ -146,9 +173,6 @@ class Atom extends Model
   # Public: A {Workspace} instance
   workspace: null
 
-  # Public: A {WorkspaceView} instance
-  workspaceView: null
-
   ###
   Section: Construction and Destruction
   ###
@@ -173,11 +197,21 @@ class Atom extends Model
       require('grim').deprecate = ->
 
     window.onerror = =>
-      @openDevTools()
-      @executeJavaScriptInDevTools('InspectorFrontendAPI.showConsole()')
       @lastUncaughtError = Array::slice.call(arguments)
+      [message, url, line, column, originalError] = @lastUncaughtError
+      eventObject = {message, url, line, column, originalError}
+
+      openDevTools = true
+      eventObject.preventDefault = -> openDevTools = false
+
+      @emitter.emit 'will-throw-error', eventObject
+
+      if openDevTools
+        @openDevTools()
+        @executeJavaScriptInDevTools('InspectorFrontendAPI.showConsole()')
+
       @emit 'uncaught-error', arguments...
-      @emitter.emit 'did-throw-error', arguments...
+      @emitter.emit 'did-throw-error', {message, url, line, column, originalError}
 
     @unsubscribe()
     @setBodyPlatformClass()
@@ -188,9 +222,11 @@ class Atom extends Model
     KeymapManager = require './keymap-extensions'
     ViewRegistry = require './view-registry'
     CommandRegistry = require './command-registry'
+    TooltipManager = require './tooltip-manager'
+    NotificationManager = require './notification-manager'
     PackageManager = require './package-manager'
     Clipboard = require './clipboard'
-    Syntax = require './syntax'
+    GrammarRegistry = require './grammar-registry'
     ThemeManager = require './theme-manager'
     StyleManager = require './style-manager'
     ContextMenuManager = require './context-menu-manager'
@@ -213,6 +249,9 @@ class Atom extends Model
     @config = new Config({configDirPath, resourcePath})
     @keymaps = new KeymapManager({configDirPath, resourcePath})
     @keymap = @keymaps # Deprecated
+    @keymaps.subscribeToFileReadFailure()
+    @tooltips = new TooltipManager
+    @notifications = new NotificationManager
     @commands = new CommandRegistry
     @views = new ViewRegistry
     @packages = new PackageManager({devMode, configDirPath, resourcePath, safeMode})
@@ -223,7 +262,11 @@ class Atom extends Model
     @menu = new MenuManager({resourcePath})
     @clipboard = new Clipboard()
 
-    @syntax = @deserializers.deserialize(@state.syntax) ? new Syntax()
+    @grammars = @deserializers.deserialize(@state.grammars ? @state.syntax) ? new GrammarRegistry()
+
+    Object.defineProperty this, 'syntax', get: ->
+      deprecate "The atom.syntax global is deprecated. Use atom.grammars instead."
+      @grammars
 
     @subscribe @packages.onDidActivateAll => @watchThemes()
 
@@ -248,10 +291,31 @@ class Atom extends Model
   onDidBeep: (callback) ->
     @emitter.on 'did-beep', callback
 
+  # Extended: Invoke the given callback when there is an unhandled error, but
+  # before the devtools pop open
+  #
+  # * `callback` {Function} to be called whenever there is an unhandled error
+  #   * `event` {Object}
+  #     * `originalError` {Object} the original error object
+  #     * `message` {String} the original error object
+  #     * `url` {String} Url to the file where the error originated.
+  #     * `line` {Number}
+  #     * `column` {Number}
+  #     * `preventDefault` {Function} call this to avoid popping up the dev tools.
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
+  onWillThrowError: (callback) ->
+    @emitter.on 'will-throw-error', callback
+
   # Extended: Invoke the given callback whenever there is an unhandled error.
   #
   # * `callback` {Function} to be called whenever there is an unhandled error
-  #   * `errorMessage` {String}
+  #   * `event` {Object}
+  #     * `originalError` {Object} the original error object
+  #     * `message` {String} the original error object
+  #     * `url` {String} Url to the file where the error originated.
+  #     * `line` {Number}
+  #     * `column` {Number}
   #
   # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
   onDidThrowError: (callback) ->
@@ -503,15 +567,19 @@ class Atom extends Model
     @packages.activate()
     @keymaps.loadUserKeymap()
     @requireUserInitScript() unless safeMode
+
     @menu.update()
+    @subscribe @config.onDidChange 'core.autoHideMenuBar', ({newValue}) =>
+      @setAutoHideMenuBar(newValue)
+    @setAutoHideMenuBar(true) if @config.get('core.autoHideMenuBar')
 
     maximize = dimensions?.maximized and process.platform isnt 'darwin'
     @displayWindow({maximize})
 
   unloadEditorWindow: ->
-    return if not @project and not @workspaceView
+    return if not @project
 
-    @state.syntax = @syntax.serialize()
+    @state.grammars = @grammars.serialize()
     @state.project = @project.serialize()
     @state.workspace = @workspace.serialize()
     @packages.deactivatePackages()
@@ -520,10 +588,10 @@ class Atom extends Model
     @windowState = null
 
   removeEditorWindow: ->
-    return if not @project and not @workspaceView
+    return if not @project
 
-    @workspaceView?.remove()
-    @workspaceView = null
+    @workspace?.destroy()
+    @workspace = null
     @project?.destroy()
     @project = null
 
@@ -536,7 +604,7 @@ class Atom extends Model
   # Essential: Visually and audibly trigger a beep.
   beep: ->
     shell.beep() if @config.get('core.audioBeep')
-    @workspaceView.trigger 'beep'
+    @__workspaceView.trigger 'beep'
     @emitter.emit 'did-beep'
 
   # Essential: A flexible way to open a dialog akin to an alert dialog.
@@ -612,11 +680,13 @@ class Atom extends Model
 
     startTime = Date.now()
     @workspace = Workspace.deserialize(@state.workspace) ? new Workspace
-    @workspaceView = @views.getView(@workspace).__spacePenView
+
+    workspaceElement = @views.getView(@workspace)
+    @__workspaceView = workspaceElement.__spacePenView
     @deserializeTimings.workspace = Date.now() - startTime
 
-    @keymaps.defaultTarget = @workspaceView[0]
-    $(@workspaceViewParentSelector).append(@workspaceView)
+    @keymaps.defaultTarget = workspaceElement
+    document.querySelector(@workspaceViewParentSelector).appendChild(workspaceElement)
 
   deserializePackageStates: ->
     @packages.packageStates = @state.packageStates ? {}
@@ -723,3 +793,7 @@ class Atom extends Model
 
   setBodyPlatformClass: ->
     document.body.classList.add("platform-#{process.platform}")
+
+  setAutoHideMenuBar: (autoHide) ->
+    ipc.send('call-window-method', 'setAutoHideMenuBar', autoHide)
+    ipc.send('call-window-method', 'setMenuBarVisibility', !autoHide)

src/browser/atom-application.coffee

@@ -238,6 +238,11 @@ class AtomApplication
       win = BrowserWindow.fromWebContents(event.sender)
       win[method](args...)
 
+    clipboard = null
+    ipc.on 'write-text-to-selection-clipboard', (event, selectedText) ->
+      clipboard ?= require 'clipboard'
+      clipboard.writeText(selectedText, 'selection')
+
   # Public: Executes the given command.
   #
   # If it isn't handled globally, delegate to the currently focused window.

src/browser/auto-update-manager.coffee

@@ -15,15 +15,20 @@ class AutoUpdateManager
 
   constructor: (@version) ->
     @state = IdleState
-    @feedUrl = "https://atom.io/api/updates?version=#{@version}"
+    if process.platform is 'win32'
+      # Squirrel for Windows can't handle query params
+      # https://github.com/Squirrel/Squirrel.Windows/issues/132
+      @feedUrl = 'https://atom.io/api/updates'
+    else
+      @feedUrl = "https://atom.io/api/updates?version=#{@version}"
 
     process.nextTick => @setupAutoUpdater()
 
   setupAutoUpdater: ->
-    autoUpdater = require 'auto-updater'
-
     if process.platform is 'win32'
-      autoUpdater.checkForUpdates = => @checkForUpdatesShim()
+      autoUpdater = require './auto-updater-win32'
+    else
+      autoUpdater = require 'auto-updater'
 
     autoUpdater.setFeedUrl @feedUrl
 
@@ -48,24 +53,6 @@ class AutoUpdateManager
     unless /\w{7}/.test(@version)
       @check(hidePopups: true)
 
-  # Windows doesn't have an auto-updater, so use this method to shim the events.
-  checkForUpdatesShim: ->
-    autoUpdater.emit 'checking-for-update'
-
-    https = require 'https'
-    request = https.get @feedUrl, (response) ->
-      if response.statusCode == 200
-        body = ""
-        response.on 'data', (chunk) -> body += chunk
-        response.on 'end', ->
-          {notes, name} = JSON.parse(body)
-          autoUpdater.emit 'update-downloaded', null, notes, name
-      else
-        autoUpdater.emit 'update-not-available'
-
-    request.on 'error', (error) ->
-      autoUpdater.emit 'error', null, error.message
-
   emitUpdateAvailableEvent: (windows...) ->
     return unless @releaseVersion? and @releaseNotes
     for atomWindow in windows

src/browser/auto-updater-win32.coffee

@@ -0,0 +1,69 @@
+{EventEmitter} = require 'events'
+_ = require 'underscore-plus'
+shellAutoUpdater = require 'auto-updater'
+SquirrelUpdate = require './squirrel-update'
+
+class AutoUpdater
+  _.extend @prototype, EventEmitter.prototype
+
+  setFeedUrl: (@updateUrl) ->
+
+  quitAndInstall: ->
+    unless SquirrelUpdate.existsSync()
+      shellAutoUpdater.quitAndInstall()
+      return
+
+    @installUpdate (error) ->
+      return if error?
+
+      SquirrelUpdate.spawn ['--processStart', 'atom.exe'], ->
+        shellAutoUpdater.quitAndInstall()
+
+  downloadUpdate: (callback) ->
+    SquirrelUpdate.spawn ['--download', @updateUrl], (error, stdout) ->
+      return callback(error) if error?
+
+      try
+        # Last line of output is the JSON details about the releases
+        json = stdout.trim().split('\n').pop()
+        update = JSON.parse(json)?.releasesToApply?.pop?()
+      catch error
+        error.stdout = stdout
+        return callback(error)
+
+      callback(null, update)
+
+  installUpdate: (callback) ->
+    SquirrelUpdate.spawn(['--update', @updateUrl], callback)
+
+  checkForUpdates: ->
+    throw new Error('Update URL is not set') unless @updateUrl
+
+    @emit 'checking-for-update'
+
+    unless SquirrelUpdate.existsSync()
+      @emit 'update-not-available'
+      return
+
+    @downloadUpdate (error, update) =>
+      if error?
+        console.log "Failed to download: #{error.message} - #{error.code} - #{error.stdout}"
+        @emit 'update-not-available'
+        return
+
+      unless update?
+        @emit 'update-not-available'
+        return
+
+      @installUpdate (error) =>
+        if error?
+          console.log "Failed to update: #{error.message} - #{error.code} - #{error.stdout}"
+          @emit 'update-not-available'
+          return
+
+        console.log "Updated to #{update.version}"
+
+        @emit 'update-available'
+        @emit 'update-downloaded', {}, update.releaseNotes, update.version, new Date(), 'https://atom.io', => @quitAndInstall()
+
+module.exports = new AutoUpdater()

src/browser/main.coffee

@@ -13,7 +13,21 @@ 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'
+    return if SquirrelUpdate.handleStartupEvent()
+
   args = parseCommandLine()
 
   addPathToOpen = (event, pathToOpen) ->

src/browser/squirrel-update.coffee

@@ -0,0 +1,198 @@
+app = require 'app'
+ChildProcess = require 'child_process'
+fs = require 'fs-plus'
+path = require 'path'
+
+rootAtomFolder = path.resolve(process.execPath, '..', '..')
+binFolder = path.join(rootAtomFolder, 'bin')
+updateDotExe = path.join(rootAtomFolder, 'Update.exe')
+exeName = path.basename(process.execPath)
+
+if process.env.SystemRoot
+  system32Path = path.join(process.env.SystemRoot, 'System32')
+  regPath = path.join(system32Path, 'reg.exe')
+  setxPath = path.join(system32Path, 'setx.exe')
+else
+  regPath = 'reg.exe'
+  setxPath = 'setx.exe'
+
+# Registry keys used for context menu
+fileKeyPath = 'HKCU\\Software\\Classes\\*\\shell\\Atom'
+directoryKeyPath = 'HKCU\\Software\\Classes\\directory\\shell\\Atom'
+backgroundKeyPath = 'HKCU\\Software\\Classes\\directory\\background\\shell\\Atom'
+environmentKeyPath = 'HKCU\\Environment'
+
+# Spawn a command and invoke the callback when it completes with an error
+# and the output from standard out.
+spawn = (command, args, callback) ->
+  spawnedProcess = ChildProcess.spawn(command, args)
+
+  stdout = ''
+  spawnedProcess.stdout.on 'data', (data) -> stdout += data
+
+  error = null
+  spawnedProcess.on 'error', (processError) -> error ?= processError
+  spawnedProcess.on 'close', (code, signal) ->
+    error ?= new Error("Command failed: #{signal ? code}") if code isnt 0
+    error?.code ?= code
+    error?.stdout ?= stdout
+    callback(error, stdout)
+
+# Spawn reg.exe and callback when it completes
+spawnReg = (args, callback) ->
+  spawn(regPath, args, callback)
+
+# Spawn setx.exe and callback when it completes
+spawnSetx = (args, callback) ->
+  spawn(setxPath, args, callback)
+
+# Spawn the Update.exe with the given arguments and invoke the callback when
+# the command completes.
+spawnUpdate = (args, callback) ->
+  spawn(updateDotExe, args, callback)
+
+# Install the Open with Atom explorer context menu items via the registry.
+installContextMenu = (callback) ->
+  addToRegistry = (args, callback) ->
+    args.unshift('add')
+    args.push('/f')
+    spawnReg(args, callback)
+
+  installMenu = (keyPath, arg, callback) ->
+    args = [keyPath, '/ve', '/d', 'Open with Atom']
+    addToRegistry args, ->
+      args = [keyPath, '/v', 'Icon', '/d', process.execPath]
+      addToRegistry args, ->
+        args = ["#{keyPath}\\command", '/ve', '/d', "#{process.execPath} \"#{arg}\""]
+        addToRegistry(args, callback)
+
+  installMenu fileKeyPath, '%1', ->
+    installMenu directoryKeyPath, '%1', ->
+      installMenu(backgroundKeyPath, '%V', callback)
+
+# Get the user's PATH environment variable registry value.
+getPath = (callback) ->
+  spawnReg ['query', environmentKeyPath, '/v', 'Path'], (error, stdout) ->
+    if error?
+      if error.code is 1
+        # The query failed so the Path does not exist yet in the registry
+        return callback(null, '')
+      else
+        return callback(error)
+
+    # Registry query output is in the form:
+    #
+    # HKEY_CURRENT_USER\Environment
+    #     Path    REG_SZ    C:\a\folder\on\the\path;C\another\folder
+    #
+
+    lines = stdout.split(/[\r\n]+/).filter (line) -> line
+    segments = lines[lines.length - 1]?.split('    ')
+    if segments[1] is 'Path' and segments.length >= 3
+      pathEnv = segments?[3..].join('    ')
+      callback(null, pathEnv)
+    else
+      callback(new Error('Registry query for PATH failed'))
+
+# Uninstall the Open with Atom explorer context menu items via the registry.
+uninstallContextMenu = (callback) ->
+  deleteFromRegistry = (keyPath, callback) ->
+    spawnReg(['delete', keyPath, '/f'], callback)
+
+  deleteFromRegistry fileKeyPath, ->
+    deleteFromRegistry directoryKeyPath, ->
+      deleteFromRegistry(backgroundKeyPath, callback)
+
+# Add atom and apm to the PATH
+#
+# This is done by adding .cmd shims to the root bin folder in the Atom
+# install directory that point to the newly installed versions inside
+# the versioned app directories.
+addCommandsToPath = (callback) ->
+  installCommands = (callback) ->
+    atomCommandPath = path.join(binFolder, 'atom.cmd')
+    relativeExePath = path.relative(binFolder, process.execPath)
+    atomCommand = """
+      @echo off
+      "%~dp0\\#{relativeExePath}" %*
+    """
+
+    apmCommandPath = path.join(binFolder, 'apm.cmd')
+    relativeApmPath = path.relative(binFolder, path.join(process.resourcesPath, 'app', 'apm', 'node_modules', 'atom-package-manager', 'bin', 'apm.cmd'))
+    apmCommand = """
+      @echo off
+      "%~dp0\\#{relativeApmPath}" %*
+    """
+
+    fs.writeFile atomCommandPath, atomCommand, ->
+      fs.writeFile apmCommandPath, apmCommand, ->
+        callback()
+
+  addBinToPath = (pathSegments, callback) ->
+    pathSegments.push(binFolder)
+    newPathEnv = pathSegments.join(';')
+    spawnSetx(['Path', newPathEnv], callback)
+
+  installCommands (error) ->
+    return callback(error) if error?
+
+    getPath (error, pathEnv) ->
+      return callback(error) if error?
+
+      pathSegments = pathEnv.split(/;+/).filter (pathSegment) -> pathSegment
+      if pathSegments.indexOf(binFolder) is -1
+        addBinToPath(pathSegments, callback)
+      else
+        callback()
+
+# Remove atom and apm from the PATH
+removeCommandsFromPath = (callback) ->
+  getPath (error, pathEnv) ->
+    return callback(error) if error?
+
+    pathSegments = pathEnv.split(/;+/).filter (pathSegment) ->
+      pathSegment and pathSegment isnt binFolder
+    newPathEnv = pathSegments.join(';')
+
+    if pathEnv isnt newPathEnv
+      spawnSetx(['Path', newPathEnv], callback)
+    else
+      callback()
+
+
+# Create a desktop and start menu shortcut by using the command line API
+# provided by Squirrel's Update.exe
+createShortcut = (callback) ->
+  spawnUpdate(['--createShortcut', exeName], callback)
+
+# Remove the desktop and start menu shortcuts by using the command line API
+# provided by Squirrel's Update.exe
+removeShortcut = (callback) ->
+  spawnUpdate(['--removeShortcut', exeName], callback)
+
+exports.spawn = spawnUpdate
+
+# Is the Update.exe installed with Atom?
+exports.existsSync = ->
+  fs.existsSync(updateDotExe)
+
+# Handle squirrel events denoted by --squirrel-* command line arguments.
+exports.handleStartupEvent = ->
+  switch process.argv[1]
+    when '--squirrel-install', '--squirrel-updated'
+      createShortcut ->
+        installContextMenu ->
+          addCommandsToPath ->
+            app.quit()
+      true
+    when '--squirrel-uninstall'
+      removeShortcut ->
+        uninstallContextMenu ->
+          removeCommandsFromPath ->
+            app.quit()
+      true
+    when '--squirrel-obsolete'
+      app.quit()
+      true
+    else
+      false

src/config-schema.coffee

@@ -35,6 +35,47 @@ module.exports =
       destroyEmptyPanes:
         type: 'boolean'
         default: true
+      fileEncoding:
+        description: 'Default character set encoding to use when reading and writing files.'
+        type: 'string'
+        default: 'utf8'
+        enum: [
+          'cp437',
+          'eucjp',
+          'euckr',
+          'gbk',
+          'iso88591',
+          'iso885910',
+          'iso885913',
+          'iso885914',
+          'iso885915',
+          'iso885916',
+          'iso88592',
+          'iso88593',
+          'iso88594',
+          'iso88595',
+          'iso88596',
+          'iso88597',
+          'iso88597',
+          'iso88598',
+          'koi8r',
+          'koi8u',
+          'macroman',
+          'shiftjis',
+          'utf16be',
+          'utf16le',
+          'utf8',
+          'windows1250',
+          'windows1251',
+          'windows1252',
+          'windows1253',
+          'windows1254',
+          'windows1255',
+          'windows1256',
+          'windows1257',
+          'windows1258',
+          'windows866'
+        ]
 
   editor:
     type: 'object'
@@ -74,7 +115,8 @@ module.exports =
       autoIndent:
         type: 'boolean'
         default: true
-      normalizeIndentOnPaste:
+        description: 'Automatically indent the cursor when inserting a newline'
+      autoIndentOnPaste:
         type: 'boolean'
         default: true
       nonWordCharacters:
@@ -142,3 +184,9 @@ module.exports =
         type: 'boolean'
         default: process.platform isnt 'darwin'
         description: 'Increase/decrease the editor font size when pressing the Ctrl key and scrolling the mouse up/down.'
+
+if process.platform in ['win32', 'linux']
+  module.exports.core.properties.autoHideMenuBar =
+    type: 'boolean'
+    default: false
+    description: 'Automatically hide the menu bar and toggle it by pressing Alt. This is only supported on Windows & Linux.'

src/config.coffee

@@ -526,6 +526,9 @@ class Config
 
   # Extended: Restore the global setting at `keyPath` to its default value.
   #
+  # * `scopeSelector` (optional) {String}. eg. '.source.ruby'
+  #   See [the scopes docs](https://atom.io/docs/latest/advanced/scopes-and-scope-descriptors)
+  #   for more information.
   # * `keyPath` The {String} name of the key.
   #
   # Returns the new value.
@@ -536,11 +539,13 @@ class Config
 
     if scopeSelector?
       settings = @scopedSettingsStore.propertiesForSourceAndSelector('user-config', scopeSelector)
-      @scopedSettingsStore.removePropertiesForSourceAndSelector('user-config', scopeSelector)
-      _.setValueForKeyPath(settings, keyPath, undefined)
-      @addScopedSettings('user-config', scopeSelector, settings, @usersScopedSettingPriority)
-      @save() unless @configFileHasErrors
-      @getDefault(scopeSelector, keyPath)
+      if _.valueForKeyPath(settings, keyPath)?
+        @scopedSettingsStore.removePropertiesForSourceAndSelector('user-config', scopeSelector)
+        _.setValueForKeyPath(settings, keyPath, undefined)
+        settings = withoutEmptyObjects(settings)
+        @addScopedSettings('user-config', scopeSelector, settings, @usersScopedSettingPriority) if settings?
+        @save() unless @configFileHasErrors
+        @getDefault(scopeSelector, keyPath)
     else
       @set(keyPath, _.valueForKeyPath(@defaultSettings, keyPath))
       @get(keyPath)
@@ -719,21 +724,26 @@ class Config
       @configFileHasErrors = false
     catch error
       @configFileHasErrors = true
-      console.error "Failed to load user config '#{@configFilePath}'", error.message
-      console.error error.stack
+      @notifyFailure('Failed to load config.cson', error)
 
   observeUserConfig: ->
     try
       @watchSubscription ?= pathWatcher.watch @configFilePath, (eventType) =>
         @loadUserConfig() if eventType is 'change' and @watchSubscription?
     catch error
-      console.error "Failed to watch user config '#{@configFilePath}'", error.message
-      console.error error.stack
+      @notifyFailure('Failed to watch user config', error)
 
   unobserveUserConfig: ->
     @watchSubscription?.close()
     @watchSubscription = null
 
+  notifyFailure: (errorMessage, error) ->
+    message = "#{errorMessage}"
+    detail = error.stack
+    atom.notifications.addError(message, {detail, closable: true})
+    console.error message
+    console.error detail
+
   save: ->
     allSettings = global: @settings
     allSettings = _.extend allSettings, @scopedSettingsStore.propertiesForSource('user-config')
@@ -1046,3 +1056,15 @@ splitKeyPath = (keyPath) ->
       startIndex = i + 1
   keyPathArray.push keyPath.substr(startIndex, keyPath.length)
   keyPathArray
+
+withoutEmptyObjects = (object) ->
+  resultObject = undefined
+  if isPlainObject(object)
+    for key, value of object
+      newValue = withoutEmptyObjects(value)
+      if newValue?
+        resultObject ?= {}
+        resultObject[key] = newValue
+  else
+    resultObject = object
+  resultObject

src/context-menu-manager.coffee

@@ -76,8 +76,8 @@ class ContextMenuManager
   #     * `event` The click event that deployed the context menu.
   add: (itemsBySelector) ->
     # Detect deprecated file path as first argument
-    unless typeof itemsBySelector is 'object'
-      Grim.deprecate("ContextMenuManage::add has changed to take a single object as its argument. Please consult the documentation.")
+    if itemsBySelector? and typeof itemsBySelector isnt 'object'
+      Grim.deprecate("ContextMenuManager::add has changed to take a single object as its argument. Please consult the documentation.")
       itemsBySelector = arguments[1]
       devMode = arguments[2]?.devMode
 

src/cursor.coffee

@@ -17,7 +17,7 @@ class Cursor extends Model
   visible: true
   needsAutoscroll: null
 
-  # Instantiated by an {TextEditor}
+  # Instantiated by a {TextEditor}
   constructor: ({@editor, @marker, id}) ->
     @emitter = new Emitter
 
@@ -171,6 +171,10 @@ class Cursor extends Model
   Section: Cursor Position Details
   ###
 
+  # Public: Returns the underlying {Marker} for the cursor.
+  # Useful with overlay {Decoration}s.
+  getMarker: -> @marker
+
   # Public: Identifies if the cursor is surrounded by whitespace.
   #
   # "Surrounded" here means that the character directly before and after the
@@ -420,7 +424,7 @@ class Cursor extends Model
   Section: Local Positions and Ranges
   ###
 
-  # Public: Retrieves buffer position of previous word boundary. It might be on
+  # Public: Returns buffer position of previous word boundary. It might be on
   # the current word, or the previous word.
   #
   # * `options` (optional) {Object} with the following keys:
@@ -446,7 +450,7 @@ class Cursor extends Model
 
     beginningOfWordPosition or currentBufferPosition
 
-  # Public: Retrieves buffer position of the next word boundary. It might be on
+  # Public: Returns buffer position of the next word boundary. It might be on
   # the current word, or the previous word.
   #
   # * `options` (optional) {Object} with the following keys:
@@ -471,6 +475,10 @@ class Cursor extends Model
 
     endOfWordPosition or currentBufferPosition
 
+  getMoveNextWordBoundaryBufferPosition: (options) ->
+    deprecate 'Use `::getNextWordBoundaryBufferPosition(options)` instead'
+    @getNextWordBoundaryBufferPosition(options)
+
   # Public: Retrieves the buffer position of where the current word starts.
   #
   # * `options` (optional) An {Object} with the following keys:

src/git-repository.coffee

@@ -1,9 +1,8 @@
 {basename, join} = require 'path'
 
 _ = require 'underscore-plus'
-{Subscriber} = require 'emissary'
 EmitterMixin = require('emissary').Emitter
-{Emitter} = require 'event-kit'
+{Emitter, Disposable, CompositeDisposable} = require 'event-kit'
 fs = require 'fs-plus'
 GitUtils = require 'git-utils'
 {deprecate} = require 'grim'
@@ -45,7 +44,6 @@ Task = require './task'
 module.exports =
 class GitRepository
   EmitterMixin.includeInto(this)
-  Subscriber.includeInto(this)
 
   @exists: (path) ->
     if git = @open(path)
@@ -75,6 +73,8 @@ class GitRepository
 
   constructor: (path, options={}) ->
     @emitter = new Emitter
+    @subscriptions = new CompositeDisposable
+
     @repo = GitUtils.open(path)
     unless @repo?
       throw new Error("No Git repository found searching path: #{path}")
@@ -88,13 +88,15 @@ class GitRepository
 
     refreshOnWindowFocus ?= true
     if refreshOnWindowFocus
-      {$} = require './space-pen-extensions'
-      @subscribe $(window), 'focus', =>
+      onWindowFocus = =>
         @refreshIndex()
         @refreshStatus()
 
+      window.addEventListener 'focus', onWindowFocus
+      @subscriptions.add new Disposable(-> window.removeEventListener 'focus', onWindowFocus)
+
     if @project?
-      @subscribe @project.eachBuffer (buffer) => @subscribeToBuffer(buffer)
+      @subscriptions.add @project.eachBuffer (buffer) => @subscribeToBuffer(buffer)
 
   # Public: Destroy this {GitRepository} object.
   #
@@ -109,7 +111,7 @@ class GitRepository
       @repo.release()
       @repo = null
 
-    @unsubscribe()
+    @subscriptions.dispose()
 
   ###
   Section: Event Subscription
@@ -403,10 +405,13 @@ class GitRepository
       if path = buffer.getPath()
         @getPathStatus(path)
 
-    @subscribe buffer.onDidSave(getBufferPathStatus)
-    @subscribe buffer.onDidReload(getBufferPathStatus)
-    @subscribe buffer.onDidChangePath(getBufferPathStatus)
-    @subscribe buffer.onDidDestroy => @unsubscribe(buffer)
+    bufferSubscriptions = new CompositeDisposable
+    bufferSubscriptions.add buffer.onDidSave(getBufferPathStatus)
+    bufferSubscriptions.add buffer.onDidReload(getBufferPathStatus)
+    bufferSubscriptions.add buffer.onDidChangePath(getBufferPathStatus)
+    bufferSubscriptions.add buffer.onDidDestroy =>
+      bufferSubscriptions.dispose()
+      @subscriptions.remove(bufferSubscriptions)
 
   # Subscribes to editor view event.
   checkoutHeadForEditor: (editor) ->

src/grammar-registry.coffee

@@ -2,7 +2,8 @@ _ = require 'underscore-plus'
 {deprecate} = require 'grim'
 {specificity} = require 'clear-cut'
 {Subscriber} = require 'emissary'
-{GrammarRegistry, ScopeSelector} = require 'first-mate'
+FirstMate = require 'first-mate'
+{ScopeSelector} = FirstMate
 ScopedPropertyStore = require 'scoped-property-store'
 PropertyAccessors = require 'property-accessors'
 
@@ -11,20 +12,22 @@ Token = require './token'
 
 # Extended: Syntax class holding the grammars used for tokenizing.
 #
-# An instance of this class is always available as the `atom.syntax` global.
+# An instance of this class is always available as the `atom.grammars` global.
 #
 # The Syntax class also contains properties for things such as the
 # language-specific comment regexes. See {::getProperty} for more details.
 module.exports =
-class Syntax extends GrammarRegistry
+class GrammarRegistry extends FirstMate.GrammarRegistry
   PropertyAccessors.includeInto(this)
   Subscriber.includeInto(this)
-  atom.deserializers.add(this)
 
   @deserialize: ({grammarOverridesByPath}) ->
-    syntax = new Syntax()
-    syntax.grammarOverridesByPath = grammarOverridesByPath
-    syntax
+    grammarRegistry = new GrammarRegistry()
+    grammarRegistry.grammarOverridesByPath = grammarOverridesByPath
+    grammarRegistry
+
+  atom.deserializers.add(this)
+  atom.deserializers.add(name: 'Syntax', deserialize: @deserialize) # Support old serialization
 
   constructor: ->
     super(maxTokensPerLine: 100)
@@ -34,6 +37,17 @@ class Syntax extends GrammarRegistry
 
   createToken: (value, scopes) -> new Token({value, scopes})
 
+  # Extended: Select a grammar for the given file path and file contents.
+  #
+  # This picks the best match by checking the file path and contents against
+  # each grammar.
+  #
+  # * `filePath` A {String} file path.
+  # * `fileContents` A {String} of text for the file path.
+  #
+  # Returns a {Grammar}, never null.
+  selectGrammar: (filePath, fileContents) -> super
+
   # Deprecated: Used by settings-view to display snippets for packages
   @::accessor 'propertyStore', ->
     deprecate("Do not use this. Use a public method on Config")

src/highlight-component.coffee

@@ -14,9 +14,9 @@ HighlightComponent = React.createClass
 
     div {className},
       if endPixelPosition.top is startPixelPosition.top
-        @renderSingleLineRegions()
+        @renderSingleLineRegions(decoration.deprecatedRegionClass)
       else
-        @renderMultiLineRegions()
+        @renderMultiLineRegions(decoration.deprecatedRegionClass)
 
   componentDidMount: ->
     {editor, decoration} = @props
@@ -41,25 +41,32 @@ HighlightComponent = React.createClass
       removeFlashClass = -> node.classList.remove(flash.class)
       @flashTimeoutId = setTimeout(removeFlashClass, flash.duration)
 
-  renderSingleLineRegions: ->
+  renderSingleLineRegions: (regionClass) ->
     {startPixelPosition, endPixelPosition, lineHeightInPixels} = @props
 
+    className = 'region'
+    className += " #{regionClass}" if regionClass?
+
     [
-      div className: 'region', key: 0, style:
+      div className: className, key: 0, style:
         top: startPixelPosition.top
         height: lineHeightInPixels
         left: startPixelPosition.left
         width: endPixelPosition.left - startPixelPosition.left
     ]
 
-  renderMultiLineRegions: ->
+  renderMultiLineRegions: (regionClass) ->
     {startPixelPosition, endPixelPosition, lineHeightInPixels} = @props
+
+    className = 'region'
+    className += " #{regionClass}" if regionClass?
+
     regions = []
     index = 0
 
     # First row, extending from selection start to the right side of screen
     regions.push(
-      div className: 'region', key: index++, style:
+      div className: className, key: index++, style:
         top: startPixelPosition.top
         left: startPixelPosition.left
         height: lineHeightInPixels
@@ -69,7 +76,7 @@ HighlightComponent = React.createClass
     # Middle rows, extending from left side to right side of screen
     if endPixelPosition.top - startPixelPosition.top > lineHeightInPixels
       regions.push(
-        div className: 'region', key: index++, style:
+        div className: className, key: index++, style:
           top: startPixelPosition.top + lineHeightInPixels
           height: endPixelPosition.top - startPixelPosition.top - lineHeightInPixels
           left: 0
@@ -78,7 +85,7 @@ HighlightComponent = React.createClass
 
     # Last row, extending from left side of screen to selection end
     regions.push(
-      div className: 'region', key: index, style:
+      div className: className, key: index, style:
         top: endPixelPosition.top
         height: lineHeightInPixels
         left: 0
@@ -88,4 +95,4 @@ HighlightComponent = React.createClass
     regions
 
   shouldComponentUpdate: (newProps) ->
-    not isEqualForProperties(newProps, @props, 'startPixelPosition', 'endPixelPosition', 'lineHeightInPixels')
+    not isEqualForProperties(newProps, @props, 'startPixelPosition', 'endPixelPosition', 'lineHeightInPixels', 'decoration')

src/highlights-component.coffee

@@ -17,7 +17,7 @@ HighlightsComponent = React.createClass
     highlightComponents = []
     for markerId, {startPixelPosition, endPixelPosition, decorations} of highlightDecorations
       for decoration in decorations
-        highlightComponents.push(HighlightComponent({editor, key: "#{markerId}-#{decoration.class}", startPixelPosition, endPixelPosition, decoration, lineHeightInPixels}))
+        highlightComponents.push(HighlightComponent({editor, key: "#{markerId}-#{decoration.id}", startPixelPosition, endPixelPosition, decoration, lineHeightInPixels}))
 
     highlightComponents
 

src/keymap-extensions.coffee

@@ -23,6 +23,10 @@ KeymapManager::loadUserKeymap = ->
   if fs.isFileSync(userKeymapPath)
     @loadKeymap(userKeymapPath, watch: true, suppressErrors: true)
 
+KeymapManager::subscribeToFileReadFailure = ->
+  this.onDidFailToReadFile (error) ->
+    atom.notifications.addError('Failed to load keymap.cson', {detail: error.stack, closable: true})
+
 # This enables command handlers registered via jQuery to call
 # `.abortKeyBinding()` on the `jQuery.Event` object passed to the handler.
 jQuery.Event::abortKeyBinding = ->

src/language-mode.coffee

@@ -244,14 +244,18 @@ class LanguageMode
   # bufferRow - A {Number} indicating the buffer row
   #
   # Returns a {Number}.
-  suggestedIndentForBufferRow: (bufferRow) ->
+  suggestedIndentForBufferRow: (bufferRow, options) ->
     currentIndentLevel = @editor.indentationForBufferRow(bufferRow)
     scopeDescriptor = @editor.scopeDescriptorForBufferPosition([bufferRow, 0])
     return currentIndentLevel unless increaseIndentRegex = @increaseIndentRegexForScopeDescriptor(scopeDescriptor)
 
     currentLine = @buffer.lineForRow(bufferRow)
-    precedingRow = if bufferRow > 0 then bufferRow - 1 else null
-    return currentIndentLevel unless precedingRow?
+    if options?.skipBlankLines ? true
+      precedingRow = @buffer.previousNonBlankRow(bufferRow)
+      return 0 unless precedingRow?
+    else
+      precedingRow = bufferRow - 1
+      return currentIndentLevel if precedingRow < 0
 
     precedingLine = @buffer.lineForRow(precedingRow)
     desiredIndentLevel = @editor.indentationForBufferRow(precedingRow)
@@ -285,7 +289,7 @@ class LanguageMode
   # bufferRow - The row {Number}.
   # options - An options {Object} to pass through to {TextEditor::setIndentationForBufferRow}.
   autoIndentBufferRow: (bufferRow, options) ->
-    indentLevel = @suggestedIndentForBufferRow(bufferRow)
+    indentLevel = @suggestedIndentForBufferRow(bufferRow, options)
     @editor.setIndentationForBufferRow(bufferRow, indentLevel, options)
 
   # Given a buffer row, this decreases the indentation.

src/lines-component.coffee

@@ -7,6 +7,7 @@ React = require 'react-atom-fork'
 Decoration = require './decoration'
 CursorsComponent = require './cursors-component'
 HighlightsComponent = require './highlights-component'
+OverlayManager = require './overlay-manager'
 
 DummyLineNode = $$(-> @div className: 'line', style: 'position: absolute; visibility: hidden;', => @span 'x')[0]
 AcceptFilter = {acceptNode: -> NodeFilter.FILTER_ACCEPT}
@@ -20,7 +21,7 @@ LinesComponent = React.createClass
     {performedInitialMeasurement, cursorBlinkPeriod, cursorBlinkResumeDelay} = @props
 
     if performedInitialMeasurement
-      {editor, highlightDecorations, scrollHeight, scrollWidth, placeholderText, backgroundColor} = @props
+      {editor, overlayDecorations, highlightDecorations, scrollHeight, scrollWidth, placeholderText, backgroundColor} = @props
       {lineHeightInPixels, defaultCharWidth, scrollViewHeight, scopedCharacterWidthsChangeCount} = @props
       {scrollTop, scrollLeft, cursorPixelRects, mini} = @props
       style =
@@ -58,15 +59,22 @@ LinesComponent = React.createClass
     @renderedDecorationsByLineId = {}
 
   componentDidMount: ->
-    if atom.config.get('editor.useShadowDOM')
+    if @props.useShadowDOM
       insertionPoint = document.createElement('content')
       insertionPoint.setAttribute('select', '.overlayer')
       @getDOMNode().appendChild(insertionPoint)
 
+      insertionPoint = document.createElement('content')
+      insertionPoint.setAttribute('select', 'atom-overlay')
+      @overlayManager = new OverlayManager(@props.hostElement)
+      @getDOMNode().appendChild(insertionPoint)
+    else
+      @overlayManager = new OverlayManager(@getDOMNode())
+
   shouldComponentUpdate: (newProps) ->
     return true unless isEqualForProperties(newProps, @props,
       'renderedRowRange', 'lineDecorations', 'highlightDecorations', 'lineHeightInPixels', 'defaultCharWidth',
-      'scrollTop', 'scrollLeft', 'showIndentGuide', 'scrollingVertically', 'visible',
+      'overlayDecorations', 'scrollTop', 'scrollLeft', 'showIndentGuide', 'scrollingVertically', 'visible',
       'scrollViewHeight', 'mouseWheelScreenRow', 'scopedCharacterWidthsChangeCount', 'lineWidth', 'useHardwareAcceleration',
       'placeholderText', 'performedInitialMeasurement', 'backgroundColor', 'cursorPixelRects'
     )
@@ -92,6 +100,8 @@ LinesComponent = React.createClass
     @updateLines(@props.lineWidth isnt prevProps.lineWidth)
     @measureCharactersInNewLines() if visible and not scrollingVertically
 
+    @overlayManager?.render(@props)
+
   clearScreenRowCaches: ->
     @screenRowsByLineId = {}
     @lineIdsByScreenRow = {}

src/menu-helpers.coffee

@@ -44,7 +44,7 @@ normalizeLabel = (label) ->
     label.replace(/\&/g, '')
 
 cloneMenuItem = (item) ->
-  item = _.pick(item, 'type', 'label', 'enabled', 'command', 'submenu', 'commandDetail')
+  item = _.pick(item, 'type', 'label', 'enabled', 'visible', 'command', 'submenu', 'commandDetail')
   if item.submenu?
     item.submenu = item.submenu.map (submenuItem) -> cloneMenuItem(submenuItem)
   item

src/notification-manager.coffee

@@ -0,0 +1,44 @@
+{Emitter, Disposable} = require 'event-kit'
+Notification = require '../src/notification'
+
+# Experimental: Allows messaging the user. This will likely change, dont use
+# quite yet!
+module.exports =
+class NotificationManager
+  constructor: ->
+    @notifications = []
+    @emitter = new Emitter
+
+  ###
+  Section: Events
+  ###
+
+  onDidAddNotification: (callback) ->
+    @emitter.on 'did-add-notification', callback
+
+  ###
+  Section: Adding Notifications
+  ###
+
+  addSuccess: (message, options) ->
+    @addNotification(new Notification('success', message, options))
+
+  addInfo: (message, options) ->
+    @addNotification(new Notification('info', message, options))
+
+  addWarning: (message, options) ->
+    @addNotification(new Notification('warning', message, options))
+
+  addError: (message, options) ->
+    @addNotification(new Notification('error', message, options))
+
+  addFatalError: (message, options) ->
+    @addNotification(new Notification('fatal', message, options))
+
+  add: (type, message, options) ->
+    @addNotification(new Notification(type, message, options))
+
+  addNotification: (notification) ->
+    @notifications.push(notification)
+    @emitter.emit('did-add-notification', notification)
+    notification

src/notification.coffee

@@ -0,0 +1,33 @@
+
+# Experimental: This will likely change, do not use.
+module.exports =
+class Notification
+  constructor: (@type, @message, @options={}) ->
+    @timestamp = new Date()
+
+  getOptions: -> @options
+
+  getType: -> @type
+
+  getMessage: -> @message
+
+  getTimestamp: -> @timestamp
+
+  getDetail: -> @options.detail
+
+  isEqual: (other) ->
+    @getMessage() == other.getMessage() \
+      and @getType() == other.getType() \
+      and @getDetail() == other.getDetail()
+
+  isClosable: ->
+    !!@options.closable
+
+  getIcon: ->
+    return @options.icon if @options.icon?
+    switch @type
+      when 'fatal' then 'bug'
+      when 'error' then 'flame'
+      when 'warning' then 'alert'
+      when 'info' then 'info'
+      when 'success' then 'check'

src/overlay-manager.coffee

@@ -0,0 +1,43 @@
+module.exports =
+class OverlayManager
+  constructor: (@container) ->
+    @overlays = {}
+
+  render: (props) ->
+    {editor, overlayDecorations, lineHeightInPixels} = props
+
+    existingDecorations = null
+    for markerId, {isMarkerReversed, headPixelPosition, decorations} of overlayDecorations
+      for decoration in decorations
+        @renderOverlay(editor, decoration, headPixelPosition, lineHeightInPixels)
+
+        existingDecorations ?= {}
+        existingDecorations[decoration.id] = true
+
+    for id, overlay of @overlays
+      unless existingDecorations? and id of existingDecorations
+        @container.removeChild(overlay)
+        delete @overlays[id]
+
+    return
+
+  renderOverlay: (editor, decoration, pixelPosition, lineHeightInPixels) ->
+    item = atom.views.getView(decoration.item)
+    unless overlay = @overlays[decoration.id]
+      overlay = @overlays[decoration.id] = document.createElement('atom-overlay')
+      overlay.appendChild(item)
+      @container.appendChild(overlay)
+
+    itemWidth = item.offsetWidth
+    itemHeight = item.offsetHeight
+
+    left = pixelPosition.left
+    if left + itemWidth - editor.getScrollLeft() > editor.getWidth() and left - itemWidth >= editor.getScrollLeft()
+      left -= itemWidth
+
+    top = pixelPosition.top + lineHeightInPixels
+    if top + itemHeight - editor.getScrollTop() > editor.getHeight() and top - itemHeight - lineHeightInPixels >= editor.getScrollTop()
+      top -= itemHeight + lineHeightInPixels
+
+    overlay.style.top = top + 'px'
+    overlay.style.left = left + 'px'

src/package.coffee

@@ -192,8 +192,8 @@ class Package
   activateResources: ->
     @activationDisposables = new CompositeDisposable
     @activationDisposables.add(atom.keymaps.add(keymapPath, map)) for [keymapPath, map] in @keymaps
-    @activationDisposables.add(atom.contextMenu.add(map['context-menu'])) for [menuPath, map] in @menus
-    @activationDisposables.add(atom.menu.add(map.menu)) for [menuPath, map] in @menus when map.menu
+    @activationDisposables.add(atom.contextMenu.add(map['context-menu'])) for [menuPath, map] in @menus when map['context-menu']?
+    @activationDisposables.add(atom.menu.add(map['menu'])) for [menuPath, map] in @menus when map['menu']?
 
     unless @grammarsActivated
       grammar.activate() for grammar in @grammars
@@ -254,7 +254,7 @@ class Package
     grammarPaths = fs.listSync(grammarsDirPath, ['json', 'cson'])
     for grammarPath in grammarPaths
       try
-        grammar = atom.syntax.readGrammarSync(grammarPath)
+        grammar = atom.grammars.readGrammarSync(grammarPath)
         grammar.packageName = @name
         @grammars.push(grammar)
         grammar.activate()
@@ -268,7 +268,7 @@ class Package
     return Q() if @grammarsLoaded
 
     loadGrammar = (grammarPath, callback) =>
-      atom.syntax.readGrammar grammarPath, (error, grammar) =>
+      atom.grammars.readGrammar grammarPath, (error, grammar) =>
         if error?
           console.warn("Failed to load grammar: #{grammarPath}", error.stack ? error)
         else

src/pane-element.coffee

@@ -95,7 +95,7 @@ class PaneElement extends HTMLElement
 
   itemRemoved: ({item, index, destroyed}) ->
     if viewToRemove = @model.getView(item)
-      callRemoveHooks(viewToRemove)
+      callRemoveHooks(viewToRemove) if destroyed
       viewToRemove.remove()
 
   paneDestroyed: ->

src/panel-container-element.coffee

@@ -10,16 +10,20 @@ class PanelContainerElement extends HTMLElement
     @subscriptions.add @model.onDidAddPanel(@panelAdded.bind(this))
     @subscriptions.add @model.onDidRemovePanel(@panelRemoved.bind(this))
     @subscriptions.add @model.onDidDestroy(@destroyed.bind(this))
-
-    @setAttribute('location', @model.getLocation())
+    @classList.add(@model.getLocation())
 
   panelAdded: ({panel, index}) ->
     panelElement = panel.getView()
-    panelElement.setAttribute('location', @model.getLocation())
+    panelElement.classList.add(@model.getLocation())
+    if @model.isModal()
+      panelElement.classList.add("overlay", "from-top")
+    else
+      panelElement.classList.add("tool-panel", "panel-#{@model.getLocation()}")
+
     if index >= @childNodes.length
       @appendChild(panelElement)
     else
-      referenceItem = @childNodes[index + 1]
+      referenceItem = @childNodes[index]
       @insertBefore(panelElement, referenceItem)
 
     if @model.isModal()

src/project.coffee

@@ -323,6 +323,7 @@ class Project extends Model
   # Still needed when deserializing a tokenized buffer
   buildBufferSync: (absoluteFilePath) ->
     buffer = new TextBuffer({filePath: absoluteFilePath})
+    buffer.setEncoding(atom.config.get('core.fileEncoding'))
     @addBuffer(buffer)
     buffer.loadSync()
     buffer
@@ -338,6 +339,7 @@ class Project extends Model
       throw new Error("Atom can only handle files < 2MB for now.")
 
     buffer = new TextBuffer({filePath: absoluteFilePath})
+    buffer.setEncoding(atom.config.get('core.fileEncoding'))
     @addBuffer(buffer)
     buffer.load()
       .then((buffer) -> buffer)

src/scroll-view.coffee

@@ -1,6 +1,6 @@
 {View} = require './space-pen-extensions'
 
-# Extended: Represents a view that scrolls.
+# Deprecated: Represents a view that scrolls.
 #
 # Handles several core events to update scroll position:
 #

src/select-list-view.coffee

@@ -2,7 +2,7 @@
 TextEditorView = require './text-editor-view'
 fuzzyFilter = require('fuzzaldrin').filter
 
-# Essential: Provides a view that renders a list of items with an editor that
+# Deprecated: Provides a view that renders a list of items with an editor that
 # filters the items. Used by many packages such as the fuzzy-finder,
 # command-palette, symbols-view and autocomplete.
 #

src/selection.coffee

@@ -4,6 +4,8 @@
 {Emitter} = require 'event-kit'
 Grim = require 'grim'
 
+NonWhitespaceRegExp = /\S/
+
 # Extended: Represents a selection in the {TextEditor}.
 module.exports =
 class Selection extends Model
@@ -357,8 +359,11 @@ class Selection extends Model
     @clear()
     @cursor.needsAutoscroll = @cursor.isLastCursor()
 
+    precedingText = @editor.getTextInRange([[oldBufferRange.start.row, 0], oldBufferRange.start])
+    startLevel = @editor.indentLevelForLine(precedingText)
+
     if options.indentBasis? and not options.autoIndent
-      text = @normalizeIndents(text, options.indentBasis)
+      text = @adjustIndent(text, startLevel - options.indentBasis)
 
     newBufferRange = @editor.buffer.setTextInRange(oldBufferRange, text, pick(options, 'undo', 'normalizeLineEndings'))
 
@@ -368,13 +373,16 @@ class Selection extends Model
       @cursor.setBufferPosition(newBufferRange.end, skipAtomicTokens: true) if wasReversed
 
     if options.autoIndent
-      @editor.autoIndentBufferRow(row) for row in newBufferRange.getRows()
+      precedingText = @editor.getTextInBufferRange([[newBufferRange.start.row, 0], newBufferRange.start])
+      unless NonWhitespaceRegExp.test(precedingText)
+        @editor.autoIndentBufferRow(newBufferRange.getRows()[0])
+      @editor.autoIndentBufferRow(row) for row, i in newBufferRange.getRows() when i > 0
     else if options.autoIndentNewline and text == '\n'
       currentIndentation = @editor.indentationForBufferRow(newBufferRange.start.row)
-      @editor.autoIndentBufferRow(newBufferRange.end.row, preserveLeadingWhitespace: true)
+      @editor.autoIndentBufferRow(newBufferRange.end.row, preserveLeadingWhitespace: true, skipBlankLines: false)
       if @editor.indentationForBufferRow(newBufferRange.end.row) < currentIndentation
         @editor.setIndentationForBufferRow(newBufferRange.end.row, currentIndentation)
-    else if options.autoDecreaseIndent and /\S/.test text
+    else if options.autoDecreaseIndent and NonWhitespaceRegExp.test(text)
       @editor.autoDecreaseIndentForBufferRow(newBufferRange.start.row)
 
     newBufferRange
@@ -541,8 +549,9 @@ class Selection extends Model
   # Public: Copies the selection to the clipboard and then deletes it.
   #
   # * `maintainClipboard` {Boolean} (default: false) See {::copy}
-  cut: (maintainClipboard=false) ->
-    @copy(maintainClipboard)
+  # * `fullLine` {Boolean} (default: false) See {::copy}
+  cut: (maintainClipboard=false, fullLine=false) ->
+    @copy(maintainClipboard, fullLine)
     @delete()
 
   # Public: Copies the current selection to the clipboard.
@@ -551,22 +560,36 @@ class Selection extends Model
   #   is created to store each content copied to the clipboard. The clipboard
   #   `text` still contains the concatenation of the clipboard with the
   #   current selection. (default: false)
-  copy: (maintainClipboard=false) ->
+  # * `fullLine` {Boolean} if `true`, the copied text will always be pasted
+  #   at the beginning of the line containing the cursor, regardless of the
+  #   cursor's horizontal position. (default: false)
+  copy: (maintainClipboard=false, fullLine=false) ->
     return if @isEmpty()
-    text = @editor.buffer.getTextInRange(@getBufferRange())
+    {start, end} = @getBufferRange()
+    selectionText = @editor.getTextInRange([start, end])
+    precedingText = @editor.getTextInRange([[start.row, 0], start])
+    startLevel = @editor.indentLevelForLine(precedingText)
+
     if maintainClipboard
       {text: clipboardText, metadata} = atom.clipboard.readWithMetadata()
-
-      if metadata?.selections?
-        metadata.selections.push(text)
-      else
-        metadata = { selections: [clipboardText, text] }
-
-      text = "" + (clipboardText) + "\n" + text
+      metadata ?= {}
+      unless metadata.selections?
+        metadata.selections = [{
+          text: clipboardText,
+          indentBasis: metadata.indentBasis,
+          fullLine: metadata.fullLine,
+        }]
+      metadata.selections.push({
+        text: selectionText,
+        indentBasis: startLevel,
+        fullLine: fullLine
+      })
+      atom.clipboard.write([clipboardText, selectionText].join("\n"), metadata)
     else
-      metadata = { indentBasis: @editor.indentationForBufferRow(@getBufferRange().start.row) }
-
-    atom.clipboard.write(text, metadata)
+      atom.clipboard.write(selectionText, {
+        indentBasis: startLevel,
+        fullLine: fullLine
+      })
 
   # Public: Creates a fold containing the current selection.
   fold: ->
@@ -574,34 +597,22 @@ class Selection extends Model
     @editor.createFold(range.start.row, range.end.row)
     @cursor.setBufferPosition([range.end.row + 1, 0])
 
-  # Public: Indents the given text to the suggested level based on the grammar.
+  # Public: Increases the indentation level of
   #
-  # * `text` The {String} to indent within the selection.
-  # * `indentBasis` The beginning indent level.
-  normalizeIndents: (text, indentBasis) ->
-    textPrecedingCursor = @cursor.getCurrentBufferLine()[0...@cursor.getBufferColumn()]
-    isCursorInsideExistingLine = /\S/.test(textPrecedingCursor)
 
+  # * `indentIncrease` The beginning indent level.
+  adjustIndent: (text, indentIncrease) ->
     lines = text.split('\n')
-    firstLineIndentLevel = @editor.indentLevelForLine(lines[0])
-    if isCursorInsideExistingLine
-      minimumIndentLevel = @editor.indentationForBufferRow(@cursor.getBufferRow())
-    else
-      minimumIndentLevel = @cursor.getIndentLevel()
-
-    normalizedLines = []
-    for line, i in lines
-      if i == 0
-        indentLevel = 0
-      else if line == '' # remove all indentation from empty lines
-        indentLevel = 0
+    for line, i in lines when i > 0
+      if indentIncrease == 0
+        continue
+      else if indentIncrease > 0
+        lines[i] = @editor.buildIndentString(indentIncrease) + line
       else
-        lineIndentLevel = @editor.indentLevelForLine(lines[i])
-        indentLevel = minimumIndentLevel + (lineIndentLevel - indentBasis)
-
-      normalizedLines.push(@setIndentationForLine(line, indentLevel))
-
-    normalizedLines.join('\n')
+        currentIndentLevel = @editor.indentLevelForLine(lines[i])
+        indentLevel = Math.max(0, currentIndentLevel + indentIncrease)
+        lines[i] = line.replace(/^[\t ]+/, @editor.buildIndentString(indentLevel))
+    lines.join('\n')
 
   # Indent the current line(s).
   #
@@ -634,11 +645,6 @@ class Selection extends Model
     for row in [start..end]
       @editor.buffer.insert([row, 0], @editor.getTabText()) unless @editor.buffer.lineLengthForRow(row) == 0
 
-  setIndentationForLine: (line, indentLevel) ->
-    desiredIndentLevel = Math.max(0, indentLevel)
-    desiredIndentString = @editor.buildIndentString(desiredIndentLevel)
-    line.replace(/^[\t ]*/, desiredIndentString)
-
   ###
   Section: Managing multiple selections
   ###

src/space-pen-extensions.coffee

@@ -12,7 +12,7 @@ jQuery.cleanData = (elements) ->
 
 SpacePenCallRemoveHooks = SpacePen.callRemoveHooks
 SpacePen.callRemoveHooks = (element) ->
-  view.unsubscribe() for view in SpacePen.viewsForElement(element)
+  view.unsubscribe?() for view in SpacePen.viewsForElement(element)
   SpacePenCallRemoveHooks(element)
 
 NativeEventNames = new Set

src/style-manager.coffee

@@ -1,5 +1,12 @@
+fs = require 'fs-plus'
+path = require 'path'
 {Emitter, Disposable} = require 'event-kit'
 
+# Extended: A singleton instance of this class available via `atom.styles`,
+# which you can use to globally query and observe the set of active style
+# sheets. The `StyleManager` doesn't add any style elements to the DOM on its
+# own, but is instead subscribed to by individual `<atom-styles>` elements,
+# which clone and attach style elements in different contexts.
 module.exports =
 class StyleManager
   constructor: ->
@@ -7,19 +14,78 @@ class StyleManager
     @styleElements = []
     @styleElementsBySourcePath = {}
 
+  ###
+  Section: Event Subscription
+  ###
+
+  # Extended: Invoke `callback` for all current and future style elements.
+  #
+  # * `callback` {Function} that is called with style elements.
+  #   * `styleElement` An `HTMLStyleElement` instance. The `.sheet` property
+  #     will be null because this element isn't attached to the DOM. If you want
+  #     to attach this element to the DOM, be sure to clone it first by calling
+  #     `.cloneNode(true)` on it. The style element will also have the following
+  #     non-standard properties:
+  #     * `sourcePath` A {String} containing the path from which the style
+  #       element was loaded.
+  #     * `context` A {String} indicating the target context of the style
+  #       element.
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to cancel the
+  # subscription.
   observeStyleElements: (callback) ->
     callback(styleElement) for styleElement in @getStyleElements()
     @onDidAddStyleElement(callback)
 
+  # Extended: Invoke `callback` when a style element is added.
+  #
+  # * `callback` {Function} that is called with style elements.
+  #   * `styleElement` An `HTMLStyleElement` instance. The `.sheet` property
+  #     will be null because this element isn't attached to the DOM. If you want
+  #     to attach this element to the DOM, be sure to clone it first by calling
+  #     `.cloneNode(true)` on it. The style element will also have the following
+  #     non-standard properties:
+  #     * `sourcePath` A {String} containing the path from which the style
+  #       element was loaded.
+  #     * `context` A {String} indicating the target context of the style
+  #       element.
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to cancel the
+  # subscription.
   onDidAddStyleElement: (callback) ->
     @emitter.on 'did-add-style-element', callback
 
+  # Extended: Invoke `callback` when a style element is removed.
+  #
+  # * `callback` {Function} that is called with style elements.
+  #   * `styleElement` An `HTMLStyleElement` instance.
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to cancel the
+  # subscription.
   onDidRemoveStyleElement: (callback) ->
     @emitter.on 'did-remove-style-element', callback
 
+  # Extended: Invoke `callback` when an existing style element is updated.
+  #
+  # * `callback` {Function} that is called with style elements.
+  #   * `styleElement` An `HTMLStyleElement` instance. The `.sheet` property
+  #      will be null because this element isn't attached to the DOM. The style
+  #      element will also have the following non-standard properties:
+  #     * `sourcePath` A {String} containing the path from which the style
+  #       element was loaded.
+  #     * `context` A {String} indicating the target context of the style
+  #       element.
+  #
+  # Returns a {Disposable} on which `.dispose()` can be called to cancel the
+  # subscription.
   onDidUpdateStyleElement: (callback) ->
     @emitter.on 'did-update-style-element', callback
 
+  ###
+  Section: Reading Style Elements
+  ###
+
+  # Extended: Get all loaded style elements.
   getStyleElements: ->
     @styleElements.slice()
 
@@ -85,3 +151,17 @@ class StyleManager
     existingStyleElements = @getStyleElements()
     for styleElement in styleElementsToRestore
       @addStyleElement(styleElement) unless styleElement in existingStyleElements
+
+  ###
+  Section: Paths
+  ###
+
+  # Extended: Get the path of the user style sheet in `~/.atom`.
+  #
+  # Returns a {String}.
+  getUserStyleSheetPath: ->
+    stylesheetPath = fs.resolve(path.join(atom.getConfigDirPath(), 'styles'), ['css', 'less'])
+    if fs.isFileSync(stylesheetPath)
+      stylesheetPath
+    else
+      path.join(atom.getConfigDirPath(), 'styles.less')

src/styles-element.coffee

@@ -18,6 +18,9 @@ class StylesElement extends HTMLElement
     @styleElementClonesByOriginalElement = new WeakMap
 
   attachedCallback: ->
+    if @context is 'atom-text-editor'
+      for styleElement in @children
+        @upgradeDeprecatedSelectors(styleElement)
     @initialize()
 
   detachedCallback: ->
@@ -48,6 +51,7 @@ class StylesElement extends HTMLElement
     return unless @styleElementMatchesContext(styleElement)
 
     styleElementClone = styleElement.cloneNode(true)
+    styleElementClone.sourcePath = styleElement.sourcePath
     styleElementClone.context = styleElement.context
     @styleElementClonesByOriginalElement.set(styleElement, styleElementClone)
 
@@ -59,6 +63,10 @@ class StylesElement extends HTMLElement
           break
 
     @insertBefore(styleElementClone, insertBefore)
+
+    if @context is 'atom-text-editor'
+      @upgradeDeprecatedSelectors(styleElementClone)
+
     @emitter.emit 'did-add-style-element', styleElementClone
 
   styleElementRemoved: (styleElement) ->
@@ -78,4 +86,30 @@ class StylesElement extends HTMLElement
   styleElementMatchesContext: (styleElement) ->
     not @context? or styleElement.context is @context
 
+  upgradeDeprecatedSelectors: (styleElement) ->
+    return unless styleElement.sheet?
+
+    upgradedSelectors = []
+
+    for rule in styleElement.sheet.cssRules
+      continue if /\:host/.test(rule.selectorText)
+
+      inputSelector = rule.selectorText
+      outputSelector = rule.selectorText
+        .replace(/\.editor-colors($|[ >])/g, ':host$1')
+        .replace(/\.editor([:.][^ ,>]+)/g, ':host($1)')
+        .replace(/\.editor($|[ ,>])/g, ':host$1')
+
+      unless inputSelector is outputSelector
+        rule.selectorText = outputSelector
+        upgradedSelectors.push({inputSelector, outputSelector})
+
+    if upgradedSelectors.length > 0
+      warning = "Upgraded the following syntax theme selectors in `#{styleElement.sourcePath}` for shadow DOM compatibility:\n\n"
+      for {inputSelector, outputSelector} in upgradedSelectors
+        warning += "`#{inputSelector}` => `#{outputSelector}`\n"
+
+      warning += "\nSee the upgrade guide for information on removing this warning."
+      console.warn(warning)
+
 module.exports = StylesElement = document.registerElement 'atom-styles', prototype: StylesElement.prototype

src/text-editor-component.coffee

@@ -6,6 +6,7 @@ scrollbarStyle = require 'scrollbar-style'
 {Range, Point} = require 'text-buffer'
 grim = require 'grim'
 {CompositeDisposable} = require 'event-kit'
+ipc = require 'ipc'
 
 GutterComponent = require './gutter-component'
 InputComponent = require './input-component'
@@ -50,7 +51,7 @@ TextEditorComponent = React.createClass
 
   render: ->
     {focused, showIndentGuide, showLineNumbers, visible} = @state
-    {editor, mini, cursorBlinkPeriod, cursorBlinkResumeDelay} = @props
+    {editor, mini, cursorBlinkPeriod, cursorBlinkResumeDelay, hostElement, useShadowDOM} = @props
     maxLineNumberDigits = editor.getLineCount().toString().length
     hasSelection = editor.getLastSelection()? and !editor.getLastSelection().isEmpty()
     style = {}
@@ -66,6 +67,7 @@ TextEditorComponent = React.createClass
 
       decorations = editor.decorationsForScreenRowRange(renderedStartRow, renderedEndRow)
       highlightDecorations = @getHighlightDecorations(decorations)
+      overlayDecorations = @getOverlayDecorations(decorations)
       lineDecorations = @getLineDecorations(decorations)
       placeholderText = editor.getPlaceholderText() if editor.isEmpty()
       visible = @isVisible()
@@ -89,7 +91,10 @@ TextEditorComponent = React.createClass
 
       style.height = scrollViewHeight if @autoHeight
 
-    className = 'editor-contents'
+    if useShadowDOM
+      className = 'editor-contents--private'
+    else
+      className = 'editor-contents'
     className += ' is-focused' if focused
     className += ' has-selection' if hasSelection
 
@@ -110,12 +115,13 @@ TextEditorComponent = React.createClass
 
         LinesComponent {
           ref: 'lines',
-          editor, lineHeightInPixels, defaultCharWidth, tokenizedLines, lineDecorations, highlightDecorations,
+          editor, lineHeightInPixels, defaultCharWidth, tokenizedLines,
+          lineDecorations, highlightDecorations, overlayDecorations, hostElement,
           showIndentGuide, renderedRowRange, @pendingChanges, scrollTop, scrollLeft,
           @scrollingVertically, scrollHeight, scrollWidth, mouseWheelScreenRow,
           visible, scrollViewHeight, @scopedCharacterWidthsChangeCount, lineWidth, @useHardwareAcceleration,
           placeholderText, @performedInitialMeasurement, @backgroundColor, cursorPixelRects,
-          cursorBlinkPeriod, cursorBlinkResumeDelay, mini
+          cursorBlinkPeriod, cursorBlinkResumeDelay, mini, useShadowDOM
         }
 
         ScrollbarComponent
@@ -193,7 +199,6 @@ TextEditorComponent = React.createClass
   componentWillUnmount: ->
     {editor, hostElement} = @props
 
-    hostElement.__spacePenView.trigger 'editor:will-be-removed', [hostElement.__spacePenView]
     @unsubscribe()
     @scopedConfigSubscriptions.dispose()
     window.removeEventListener 'resize', @requestHeightAndWidthMeasurement
@@ -351,7 +356,23 @@ TextEditorComponent = React.createClass
               endPixelPosition: editor.pixelPositionForScreenPosition(screenRange.end)
               decorations: []
             filteredDecorations[markerId].decorations.push decorationParams
+    filteredDecorations
 
+  getOverlayDecorations: (decorationsByMarkerId) ->
+    {editor} = @props
+    filteredDecorations = {}
+    for markerId, decorations of decorationsByMarkerId
+      marker = editor.getMarker(markerId)
+      headBufferPosition = marker.getHeadBufferPosition()
+      if marker.isValid()
+        for decoration in decorations
+          if decoration.isType('overlay')
+            decorationParams = decoration.getProperties()
+            filteredDecorations[markerId] ?=
+              id: markerId
+              headPixelPosition: editor.pixelPositionForScreenPosition(headBufferPosition)
+              decorations: []
+            filteredDecorations[markerId].decorations.push decorationParams
     filteredDecorations
 
   observeEditor: ->
@@ -384,6 +405,7 @@ TextEditorComponent = React.createClass
     window.addEventListener 'resize', @requestHeightAndWidthMeasurement
 
     @listenForIMEEvents()
+    @listenForMiddleMousePaste() if process.platform is 'linux'
 
   listenForIMEEvents: ->
     node = @getDOMNode()
@@ -411,6 +433,22 @@ TextEditorComponent = React.createClass
       editor.insertText(selectedText, select: true, undo: 'skip')
       event.target.value = ''
 
+  listenForMiddleMousePaste: ->
+    clipboard = require 'clipboard'
+
+    @refs.scrollView.getDOMNode().addEventListener 'mouseup', ({which}) =>
+      return unless which is 2
+
+      if selection = clipboard.readText('selection')
+        @props.editor.insertText(selection)
+
+    @subscribe @props.editor.onDidChangeSelectionRange =>
+      if selectedText = @props.editor.getSelectedText()
+        # This uses ipc.send instead of clipboard.writeText because
+        # clipboard.writeText is a sync ipc call on Linux and that
+        # will slow down selections.
+        ipc.send('write-text-to-selection-clipboard', selectedText)
+
   observeConfig: ->
     @subscribe atom.config.observe 'editor.useHardwareAcceleration', @setUseHardwareAcceleration
     @subscribe atom.config.onDidChange 'editor.fontSize', @sampleFontStyling

src/text-editor-element.coffee

@@ -1,11 +1,14 @@
 {View, $, callRemoveHooks} = require 'space-pen'
 React = require 'react-atom-fork'
+Path = require 'path'
 {defaults} = require 'underscore-plus'
 TextBuffer = require 'text-buffer'
 TextEditor = require './text-editor'
 TextEditorComponent = require './text-editor-component'
 TextEditorView = null
 
+ShadowStyleSheet = null
+
 class TextEditorElement extends HTMLElement
   model: null
   componentDescriptor: null
@@ -25,24 +28,31 @@ class TextEditorElement extends HTMLElement
     @setAttribute('tabindex', -1)
 
     if atom.config.get('editor.useShadowDOM')
+      @useShadowDOM = true
+
+      unless ShadowStyleSheet?
+        ShadowStyleSheet = document.createElement('style')
+        ShadowStyleSheet.textContent = atom.themes.loadLessStylesheet(require.resolve('../static/text-editor-shadow.less'))
+
       @createShadowRoot()
 
+      @shadowRoot.appendChild(ShadowStyleSheet.cloneNode(true))
       @stylesElement = document.createElement('atom-styles')
       @stylesElement.setAttribute('context', 'atom-text-editor')
       @stylesElement.initialize()
 
       @rootElement = document.createElement('div')
-      @rootElement.classList.add('shadow')
+      @rootElement.classList.add('editor--private')
 
       @shadowRoot.appendChild(@stylesElement)
       @shadowRoot.appendChild(@rootElement)
     else
+      @useShadowDOM = false
+
+      @classList.add('editor', 'editor-colors')
       @stylesElement = document.head.querySelector('atom-styles')
       @rootElement = this
 
-    @rootElement.classList.add('editor', 'editor-colors')
-
-
   createSpacePenShim: ->
     TextEditorView ?= require './text-editor-view'
     @__spacePenView = new TextEditorView(this)
@@ -60,6 +70,7 @@ class TextEditorElement extends HTMLElement
     @model = model
     @mountComponent()
     @addGrammarScopeAttribute()
+    @addMiniAttributeIfNeeded()
     @model.onDidChangeGrammar => @addGrammarScopeAttribute()
     @addEncodingAttribute()
     @model.onDidChangeEncoding => @addEncodingAttribute()
@@ -88,10 +99,13 @@ class TextEditorElement extends HTMLElement
       editor: @model
       mini: @model.mini
       lineOverdrawMargin: @lineOverdrawMargin
+      useShadowDOM: @useShadowDOM
     )
     @component = React.renderComponent(@componentDescriptor, @rootElement)
 
-    unless atom.config.get('editor.useShadowDOM')
+    if @useShadowDOM
+      @shadowRoot.addEventListener('blur', @shadowRootBlurred.bind(this), true)
+    else
       inputNode = @component.refs.input.getDOMNode()
       inputNode.addEventListener 'focus', @focused.bind(this)
       inputNode.addEventListener 'blur', => @dispatchEvent(new FocusEvent('blur', bubbles: false))
@@ -109,17 +123,30 @@ class TextEditorElement extends HTMLElement
       @focusOnAttach = true
 
   blurred: (event) ->
-    unless atom.config.get('editor.useShadowDOM')
+    unless @useShadowDOM
       if event.relatedTarget is @component?.refs.input?.getDOMNode()
         event.stopImmediatePropagation()
         return
 
     @component?.blurred()
 
+  # Work around what seems to be a bug in Chromium. Focus can be stolen from the
+  # hidden input when clicking on the gutter and transferred to the
+  # already-focused host element. The host element never gets a 'focus' event
+  # however, which leaves us in a limbo state where the text editor element is
+  # focused but the hidden input isn't focused. This always refocuses the hidden
+  # input if a blur event occurs in the shadow DOM that is transferring focus
+  # back to the host element.
+  shadowRootBlurred: (event) ->
+    @component.focused() if event.relatedTarget is this
+
   addGrammarScopeAttribute: ->
     grammarScope = @model.getGrammar()?.scopeName?.replace(/\./g, ' ')
     @dataset.grammar = grammarScope
 
+  addMiniAttributeIfNeeded: ->
+    @setAttributeNode(document.createAttribute("mini")) if @model.isMini()
+
   addEncodingAttribute: ->
     @dataset.encoding = @model.getEncoding()
 
@@ -199,7 +226,7 @@ atom.commands.add 'atom-text-editor', stopEventPropagationAndGroupUndo(
   'editor:lower-case': -> @lowerCase()
 )
 
-atom.commands.add 'atom-text-editor:not(.mini)', stopEventPropagationAndGroupUndo(
+atom.commands.add 'atom-text-editor:not([mini])', stopEventPropagationAndGroupUndo(
   'core:move-up': -> @moveUp()
   'core:move-down': -> @moveDown()
   'core:move-to-top': -> @moveToTop()

src/text-editor-view.coffee

@@ -7,7 +7,7 @@ TextEditorElement = require './text-editor-element'
 TextEditorComponent = require './text-editor-component'
 {deprecate} = require 'grim'
 
-# Public: Represents the entire visual pane in Atom.
+# Deprecated: Represents the entire visual pane in Atom.
 #
 # The TextEditorView manages the {TextEditor}, which manages the file buffers.
 # `TextEditorView` is intentionally sparse. Most of the things you'll want
@@ -77,7 +77,6 @@ class TextEditorView extends View
 
     @scrollView = @root.find('.scroll-view')
 
-
     if atom.config.get('editor.useShadowDOM')
       @underlayer = $("<div class='underlayer'></div>").appendTo(this)
       @overlayer = $("<div class='overlayer'></div>").appendTo(this)
@@ -139,6 +138,7 @@ class TextEditorView extends View
 
   beforeRemove: ->
     @trigger 'editor:detached', [this]
+    @trigger 'editor:will-be-removed', [this]
     @attached = false
 
   remove: (selector, keepData) ->

src/text-editor.coffee

@@ -6,7 +6,7 @@ Delegator = require 'delegato'
 {Model} = require 'theorist'
 EmitterMixin = require('emissary').Emitter
 {CompositeDisposable, Emitter} = require 'event-kit'
-{Point, Range} = require 'text-buffer'
+{Point, Range} = TextBuffer = require 'text-buffer'
 LanguageMode = require './language-mode'
 DisplayBuffer = require './display-buffer'
 Cursor = require './cursor'
@@ -84,6 +84,7 @@ class TextEditor extends Model
     @cursors = []
     @selections = []
 
+    buffer ?= new TextBuffer
     @displayBuffer ?= new DisplayBuffer({buffer, tabLength, softWrapped})
     @buffer = @displayBuffer.buffer
     @softTabs = @usesSoftTabs() ? @softTabs ? atom.config.get('editor.softTabs') ? true
@@ -1097,34 +1098,49 @@ class TextEditor extends Model
   # abort the transaction, call {::abortTransaction} to terminate the function's
   # execution and revert any changes performed up to the abortion.
   #
-  # * `groupingInterval` (optional) This is the sames as the `groupingInterval`
-  #    parameter in {::beginTransaction}
-  # * `fn` A {Function} to call inside the transaction.
-  transact: (groupingInterval, fn) -> @buffer.transact(groupingInterval, fn)
-
-  # Extended: Start an open-ended transaction.
-  #
-  # Call {::commitTransaction} or {::abortTransaction} to terminate the
-  # transaction. If you nest calls to transactions, only the outermost
-  # transaction is considered. You must match every begin with a matching
-  # commit, but a single call to abort will cancel all nested transactions.
-  #
   # * `groupingInterval` (optional) The {Number} of milliseconds for which this
   #   transaction should be considered 'groupable' after it begins. If a transaction
   #   with a positive `groupingInterval` is committed while the previous transaction is
   #   still 'groupable', the two transactions are merged with respect to undo and redo.
+  # * `fn` A {Function} to call inside the transaction.
+  transact: (groupingInterval, fn) -> @buffer.transact(groupingInterval, fn)
+
+  # Deprecated: Start an open-ended transaction.
   beginTransaction: (groupingInterval) -> @buffer.beginTransaction(groupingInterval)
 
-  # Extended: Commit an open-ended transaction started with {::beginTransaction}
-  # and push it to the undo stack.
-  #
-  # If transactions are nested, only the outermost commit takes effect.
+  # Deprecated: Commit an open-ended transaction started with {::beginTransaction}.
   commitTransaction: -> @buffer.commitTransaction()
 
   # Extended: Abort an open transaction, undoing any operations performed so far
   # within the transaction.
   abortTransaction: -> @buffer.abortTransaction()
 
+  # Extended: Create a pointer to the current state of the buffer for use
+  # with {::revertToCheckpoint} and {::groupChangesSinceCheckpoint}.
+  #
+  # Returns a checkpoint value.
+  createCheckpoint: -> @buffer.createCheckpoint()
+
+  # Extended: Revert the buffer to the state it was in when the given
+  # checkpoint was created.
+  #
+  # The redo stack will be empty following this operation, so changes since the
+  # checkpoint will be lost. If the given checkpoint is no longer present in the
+  # undo history, no changes will be made to the buffer and this method will
+  # return `false`.
+  #
+  # Returns a {Boolean} indicating whether the operation succeeded.
+  revertToCheckpoint: (checkpoint) -> @buffer.revertToCheckpoint(checkpoint)
+
+  # Extended: Group all changes since the given checkpoint into a single
+  # transaction for purposes of undo/redo.
+  #
+  # If the given checkpoint is no longer present in the undo history, no
+  # grouping will be performed and this method will return `false`.
+  #
+  # Returns a {Boolean} indicating whether the operation succeeded.
+  groupChangesSinceCheckpoint: (checkpoint) -> @buffer.groupChangesSinceCheckpoint(checkpoint)
+
   ###
   Section: TextEditor Coordinates
   ###
@@ -2243,6 +2259,10 @@ class TextEditor extends Model
   # Returns a {Boolean} or undefined if no non-comment lines had leading
   # whitespace.
   usesSoftTabs: ->
+    # FIXME Remove once this can be specified as a scoped setting in the
+    # language-make package
+    return false if @getGrammar().scopeName is 'source.makefile'
+
     for bufferRow in [0..@buffer.getLastRow()]
       continue if @displayBuffer.tokenizedBuffer.tokenizedLineForRow(bufferRow).isComment()
 
@@ -2443,7 +2463,8 @@ class TextEditor extends Model
       @commentScopeSelector.matches(scopeDescriptor)
 
   logCursorScope: ->
-    console.log @getLastCursor().getScopeDescriptor()
+    scopeDescriptor = @getLastCursor().getScopeDescriptor()
+    console.log scopeDescriptor.scopes, scopeDescriptor
 
   # {Delegates to: DisplayBuffer.tokenForBufferPosition}
   tokenForBufferPosition: (bufferPosition) -> @displayBuffer.tokenForBufferPosition(bufferPosition)
@@ -2463,14 +2484,24 @@ class TextEditor extends Model
   copySelectedText: ->
     maintainClipboard = false
     for selection in @getSelections()
-      selection.copy(maintainClipboard)
+      if selection.isEmpty()
+        previousRange = selection.getBufferRange()
+        selection.selectLine()
+        selection.copy(maintainClipboard, true)
+        selection.setBufferRange(previousRange)
+      else
+        selection.copy(maintainClipboard, false)
       maintainClipboard = true
 
   # Essential: For each selection, cut the selected text.
   cutSelectedText: ->
     maintainClipboard = false
     @mutateSelectedText (selection) ->
-      selection.cut(maintainClipboard)
+      if selection.isEmpty()
+        selection.selectLine()
+        selection.cut(maintainClipboard, true)
+      else
+        selection.cut(maintainClipboard, false)
       maintainClipboard = true
 
   # Essential: For each selection, replace the selected text with the contents of
@@ -2482,22 +2513,32 @@ class TextEditor extends Model
   #
   # * `options` (optional) See {Selection::insertText}.
   pasteText: (options={}) ->
-    {text, metadata} = atom.clipboard.readWithMetadata()
+    {text: clipboardText, metadata} = atom.clipboard.readWithMetadata()
+    metadata ?= {}
+    options.autoIndent = @shouldAutoIndentOnPaste()
 
-    containsNewlines = text.indexOf('\n') isnt -1
+    @mutateSelectedText (selection, index) =>
+      if metadata.selections?.length is @getSelections().length
+        {text, indentBasis, fullLine} = metadata.selections[index]
+      else
+        {indentBasis, fullLine} = metadata
+        text = clipboardText
 
-    if metadata?.selections? and metadata.selections.length is @getSelections().length
-      @mutateSelectedText (selection, index) ->
-        text = metadata.selections[index]
+      delete options.indentBasis
+      {cursor} = selection
+      if indentBasis?
+        containsNewlines = text.indexOf('\n') isnt -1
+        if containsNewlines or !cursor.hasPrecedingCharactersOnLine()
+          options.indentBasis ?= indentBasis
+
+      if fullLine and selection.isEmpty()
+        oldPosition = selection.getBufferRange().start
+        selection.setBufferRange([[oldPosition.row, 0], [oldPosition.row, 0]])
+        selection.insertText(text, options)
+        newPosition = oldPosition.translate([1, 0])
+        selection.setBufferRange([newPosition, newPosition])
+      else
         selection.insertText(text, options)
-
-      return
-
-    else if atom.config.get(@getLastCursor().getScopeDescriptor(), "editor.normalizeIndentOnPaste") and metadata?.indentBasis?
-      if !@getLastCursor().hasPrecedingCharactersOnLine() or containsNewlines
-        options.indentBasis ?= metadata.indentBasis
-
-    @insertText(text, options)
 
   # Public: For each selection, if the selection is empty, cut all characters
   # of the containing line following the cursor. Otherwise cut the selected
@@ -2713,6 +2754,9 @@ class TextEditor extends Model
   shouldAutoIndent: ->
     atom.config.get(@getRootScopeDescriptor(), "editor.autoIndent")
 
+  shouldAutoIndentOnPaste: ->
+    atom.config.get(@getRootScopeDescriptor(), "editor.autoIndentOnPaste")
+
   shouldShowInvisibles: ->
     not @mini and atom.config.get(@getRootScopeDescriptor(), 'editor.showInvisibles')
 

src/theme-manager.coffee

@@ -6,7 +6,7 @@ EmitterMixin = require('emissary').Emitter
 {File} = require 'pathwatcher'
 fs = require 'fs-plus'
 Q = require 'q'
-{deprecate} = require 'grim'
+Grim = require 'grim'
 
 Package = require './package'
 
@@ -57,61 +57,66 @@ class ThemeManager
   Section: Event Subscription
   ###
 
-  # Essential: Invoke `callback` when all styles have been reloaded.
+  # Essential: Invoke `callback` when style sheet changes associated with
+  # updating the list of active themes have completed.
   #
   # * `callback` {Function}
   onDidReloadAll: (callback) ->
     @emitter.on 'did-reload-all', callback
 
-  # Essential: Invoke `callback` when a stylesheet has been added to the dom.
+  # Deprecated: Invoke `callback` when a stylesheet has been added to the dom.
   #
   # * `callback` {Function}
   #   * `stylesheet` {StyleSheet} the style node
   #
   # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
   onDidAddStylesheet: (callback) ->
+    Grim.deprecate("Use atom.styles.onDidAddStyleElement instead")
     @emitter.on 'did-add-stylesheet', callback
 
-  # Essential: Invoke `callback` when a stylesheet has been removed from the dom.
+  # Deprecated: Invoke `callback` when a stylesheet has been removed from the dom.
   #
   # * `callback` {Function}
   #   * `stylesheet` {StyleSheet} the style node
   #
   # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
   onDidRemoveStylesheet: (callback) ->
+    Grim.deprecate("Use atom.styles.onDidRemoveStyleElement instead")
     @emitter.on 'did-remove-stylesheet', callback
 
-  # Essential: Invoke `callback` when a stylesheet has been updated.
+  # Deprecated: Invoke `callback` when a stylesheet has been updated.
   #
   # * `callback` {Function}
   #   * `stylesheet` {StyleSheet} the style node
   #
   # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
   onDidUpdateStylesheet: (callback) ->
+    Grim.deprecate("Use atom.styles.onDidUpdateStyleElement instead")
     @emitter.on 'did-update-stylesheet', callback
 
-  # Essential: Invoke `callback` when any stylesheet has been updated, added, or removed.
+  # Deprecated: Invoke `callback` when any stylesheet has been updated, added, or removed.
   #
   # * `callback` {Function}
   #
   # Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
   onDidChangeStylesheets: (callback) ->
+    Grim.deprecate("Use atom.styles.onDidAdd/RemoveStyleElement instead")
     @emitter.on 'did-change-stylesheets', callback
 
   on: (eventName) ->
     switch eventName
       when 'reloaded'
-        deprecate 'Use ThemeManager::onDidReloadAll instead'
+        Grim.deprecate 'Use ThemeManager::onDidReloadAll instead'
       when 'stylesheet-added'
-        deprecate 'Use ThemeManager::onDidAddStylesheet instead'
+        Grim.deprecate 'Use ThemeManager::onDidAddStylesheet instead'
       when 'stylesheet-removed'
-        deprecate 'Use ThemeManager::onDidRemoveStylesheet instead'
+        Grim.deprecate 'Use ThemeManager::onDidRemoveStylesheet instead'
       when 'stylesheet-updated'
-        deprecate 'Use ThemeManager::onDidUpdateStylesheet instead'
+        Grim.deprecate 'Use ThemeManager::onDidUpdateStylesheet instead'
       when 'stylesheets-changed'
-        deprecate 'Use ThemeManager::onDidChangeStylesheets instead'
+        Grim.deprecate 'Use ThemeManager::onDidChangeStylesheets instead'
       else
-        deprecate 'ThemeManager::on is deprecated. Use event subscription methods instead.'
+        Grim.deprecate 'ThemeManager::on is deprecated. Use event subscription methods instead.'
     EmitterMixin::on.apply(this, arguments)
 
   ###
@@ -197,18 +202,15 @@ class ThemeManager
     atom.config.set('core.themes', enabledThemeNames)
 
   ###
-  Section: Managing Stylesheets
+  Section: Private
   ###
 
-  # Public: Returns the {String} path to the user's stylesheet under ~/.atom
+  # Returns the {String} path to the user's stylesheet under ~/.atom
   getUserStylesheetPath: ->
-    stylesheetPath = fs.resolve(path.join(@configDirPath, 'styles'), ['css', 'less'])
-    if fs.isFileSync(stylesheetPath)
-      stylesheetPath
-    else
-      path.join(@configDirPath, 'styles.less')
+    Grim.deprecate("Call atom.styles.getUserStyleSheetPath() instead")
+    atom.styles.getUserStyleSheetPath()
 
-  # Public: Resolve and apply the stylesheet specified by the path.
+  # Resolve and apply the stylesheet specified by the path.
   #
   # This supports both CSS and Less stylsheets.
   #
@@ -231,7 +233,7 @@ class ThemeManager
 
   loadUserStylesheet: ->
     @unwatchUserStylesheet()
-    userStylesheetPath = @getUserStylesheetPath()
+    userStylesheetPath = atom.styles.getUserStyleSheetPath()
     return unless fs.isFileSync(userStylesheetPath)
 
     @userStylesheetPath = userStylesheetPath
@@ -249,9 +251,6 @@ class ThemeManager
     if nativeStylesheetPath = fs.resolveOnLoadPath(process.platform, ['css', 'less'])
       @requireStylesheet(nativeStylesheetPath)
 
-    textEditorStylesPath = path.join(@resourcePath, 'static', 'text-editor-shadow.less')
-    atom.styles.addStyleSheet(@loadLessStylesheet(textEditorStylesPath), sourcePath: textEditorStylesPath, context: 'atom-text-editor')
-
   stylesheetElementForId: (id) ->
     document.head.querySelector("atom-styles style[source-path=\"#{id}\"]")
 
@@ -295,10 +294,6 @@ class ThemeManager
   applyStylesheet: (path, text, type='bundled') ->
     @styleSheetDisposablesBySourcePath[path] = atom.styles.addStyleSheet(text, sourcePath: path, group: type)
 
-  ###
-  Section: Private
-  ###
-
   stringToId: (string) ->
     string.replace(/\\/g, '/')
 
@@ -339,13 +334,15 @@ class ThemeManager
   isInitialLoadComplete: -> @initialLoadComplete
 
   addActiveThemeClasses: ->
+    workspaceElement = atom.views.getView(atom.workspace)
     for pack in @getActiveThemes()
-      atom.workspaceView?[0]?.classList.add("theme-#{pack.name}")
+      workspaceElement.classList.add("theme-#{pack.name}")
     return
 
   removeActiveThemeClasses: ->
+    workspaceElement = atom.views.getView(atom.workspace)
     for pack in @getActiveThemes()
-      atom.workspaceView?[0]?.classList.remove("theme-#{pack.name}")
+      workspaceElement.classList.remove("theme-#{pack.name}")
     return
 
   refreshLessCache: ->

src/tokenized-buffer.coffee

@@ -26,8 +26,8 @@ class TokenizedBuffer extends Model
   constructor: ({@buffer, @tabLength, @invisibles}) ->
     @emitter = new Emitter
 
-    @subscribe atom.syntax.onDidAddGrammar(@grammarAddedOrUpdated)
-    @subscribe atom.syntax.onDidUpdateGrammar(@grammarAddedOrUpdated)
+    @subscribe atom.grammars.onDidAddGrammar(@grammarAddedOrUpdated)
+    @subscribe atom.grammars.onDidUpdateGrammar(@grammarAddedOrUpdated)
 
     @subscribe @buffer.preemptDidChange (e) => @handleBufferChange(e)
     @subscribe @buffer.onDidChangePath (@bufferPath) => @reloadGrammar()
@@ -98,7 +98,7 @@ class TokenizedBuffer extends Model
     @emitter.emit 'did-change-grammar', grammar
 
   reloadGrammar: ->
-    if grammar = atom.syntax.selectGrammar(@buffer.getPath(), @buffer.getText())
+    if grammar = atom.grammars.selectGrammar(@buffer.getPath(), @buffer.getText())
       @setGrammar(grammar)
     else
       throw new Error("No grammar found for path: #{path}")