Upgrade to background-tips@0.15

Fix jitter in React editor

.gitignore

@@ -13,3 +13,5 @@ debug.log
 docs/output
 docs/includes
 spec/fixtures/evil-files/
+resources/linux/Atom.desktop
+resources/linux/debian/control

.pairs

@@ -11,6 +11,7 @@ pairs:
   bo: Ben Ogle; benogle
   jr: Jason Rudolph; jasonrudolph
   jl: Jessica Lord; jlord
+  dh: Daniel Hengeveld; danielh
 email:
   domain: github.com
 #global: true

apm/package.json

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

build/Gruntfile.coffee

@@ -121,6 +121,8 @@ module.exports = (grunt) ->
 
     atom: {appDir, appName, symbolsDir, buildDir, contentsDir, installDir, shellAppDir}
 
+    docsOutputDir: 'docs/output/api'
+
     coffee: coffeeConfig
 
     less: lessConfig

build/tasks/build-task.coffee

@@ -86,6 +86,15 @@ module.exports = (grunt) ->
         unless /.+\.plist/.test(sourcePath)
           grunt.file.copy(sourcePath, path.resolve(appDir, '..', subDirectory, filename))
 
+    if process.platform is 'win32'
+      cp path.join('resources', 'win', 'msvcp100.dll'), path.join(shellAppDir, 'msvcp100.dll')
+      cp path.join('resources', 'win', 'msvcr100.dll'), path.join(shellAppDir, 'msvcr100.dll')
+
+      # Set up chocolatey ignore and gui files
+      fs.writeFileSync path.join(appDir, 'apm', 'node_modules', 'atom-package-manager', 'bin', 'node.exe.ignore'), ''
+      fs.writeFileSync path.join(appDir, 'node_modules', 'symbols-view', 'vendor', 'ctags-win32.exe.ignore'), ''
+      fs.writeFileSync path.join(shellAppDir, 'atom.exe.gui'), ''
+
     dependencies = ['compile', "generate-license:save"]
     dependencies.push('copy-info-plist') if process.platform is 'darwin'
     dependencies.push('set-exe-icon') if process.platform is 'win32'

build/tasks/docs-task.coffee

@@ -15,15 +15,17 @@ module.exports = (grunt) ->
   grunt.registerTask 'build-docs', 'Builds the API docs in src', ->
     done = @async()
 
+    docsOutputDir = grunt.config.get('docsOutputDir')
+
     downloadIncludes (error, includePaths) ->
       if error?
         done(error)
       else
-        rm('docs/output/api')
+        rm(docsOutputDir)
         args = [
           commonArgs...
           '--title', 'Atom API Documentation'
-          '-o', 'docs/output/api'
+          '-o', docsOutputDir
           '-r', 'docs/README.md'
           '--stability', '1'
           'src/'

build/tasks/install-task.coffee

@@ -1,8 +1,14 @@
 fs = require 'fs'
 path = require 'path'
+_ = require 'underscore-plus'
 fs = require 'fs-plus'
 runas = null
 
+fillTemplate = (filePath, data) ->
+  template = _.template(String(fs.readFileSync(filePath + '.in')))
+  filled = template(data)
+  fs.writeFileSync(filePath, filled)
+
 module.exports = (grunt) ->
   {cp, mkdir, rm} = require('./task-helpers')(grunt)
 
@@ -25,12 +31,25 @@ module.exports = (grunt) ->
       binDir = path.join(installDir, 'bin')
       shareDir = path.join(installDir, 'share', 'atom')
 
+      iconName = path.join(shareDir,'resources','app','resources','atom.png')
+      desktopFile = path.join('resources', 'linux', 'Atom.desktop')
+
       mkdir binDir
       cp 'atom.sh', path.join(binDir, 'atom')
       rm shareDir
       mkdir path.dirname(shareDir)
       cp shellAppDir, shareDir
 
+      # Create Atom.desktop if installation not in temporary folder
+      tmpDir = if process.env.TMPDIR? then process.env.TMPDIR else '/tmp'
+      desktopInstallFile = path.join(installDir,'share','applications','Atom.desktop')
+      if installDir.indexOf(tmpDir) isnt 0
+        mkdir path.dirname(desktopInstallFile)
+        {description} = grunt.file.readJSON('package.json')
+        installDir = path.join(installDir,'.') # To prevent "Exec=/usr/local//share/atom/atom"
+        fillTemplate(desktopFile, {description, installDir, iconName})
+        cp desktopFile, desktopInstallFile
+
       # Create relative symbol link for apm.
       process.chdir(binDir)
       rm('apm')

build/tasks/mkdeb-task.coffee

@@ -23,7 +23,9 @@ module.exports = (grunt) ->
     {name, version, description} = grunt.file.readJSON('package.json')
     section = 'devel'
     maintainer = 'GitHub <atom@github.com>'
-    data = {name, version, description, section, arch, maintainer}
+    installDir = '/usr'
+    iconName = 'atom'
+    data = {name, version, description, section, arch, maintainer, installDir, iconName}
 
     control = path.join('resources', 'linux', 'debian', 'control')
     fillTemplate(control, data)

build/tasks/publish-build-task.coffee

@@ -9,16 +9,6 @@ request = require 'request'
 
 grunt = null
 
-if process.platform is 'darwin'
-  assets = [
-    {assetName: 'atom-mac.zip', sourceName: 'Atom.app'}
-    {assetName: 'atom-mac-symbols.zip', sourceName: 'Atom.breakpad.syms'}
-  ]
-else
-  assets = [
-    {assetName: 'atom-windows.zip', sourceName: 'Atom'}
-  ]
-
 commitSha = process.env.JANKY_SHA1
 token = process.env.ATOM_ACCESS_TOKEN
 defaultHeaders =
@@ -30,11 +20,19 @@ module.exports = (gruntObject) ->
 
   grunt.registerTask 'publish-build', 'Publish the built app', ->
     return if process.env.JANKY_SHA1 and process.env.JANKY_BRANCH isnt 'master'
+    tasks = ['upload-assets']
+    tasks.unshift('build-docs', 'prepare-docs') if process.platform is 'darwin'
+    grunt.task.run(tasks)
 
+  grunt.registerTask 'prepare-docs', 'Move the build docs to the build dir', ->
+    fs.copySync(grunt.config.get('docsOutputDir'), path.join(grunt.config.get('atom.buildDir'), 'atom-docs'))
+
+  grunt.registerTask 'upload-assets', 'Upload the assets to a GitHub release', ->
     done = @async()
     buildDir = grunt.config.get('atom.buildDir')
+    assets = getAssets()
 
-    zipApps buildDir, assets, (error) ->
+    zipAssets buildDir, assets, (error) ->
       return done(error) if error?
       getAtomDraftRelease (error, release) ->
         return done(error) if error?
@@ -43,26 +41,38 @@ module.exports = (gruntObject) ->
           return done(error) if error?
           uploadAssets(release, buildDir, assets, done)
 
+getAssets = ->
+  if process.platform is 'darwin'
+    [
+      {assetName: 'atom-mac.zip', sourcePath: 'Atom.app'}
+      {assetName: 'atom-mac-symbols.zip', sourcePath: 'Atom.breakpad.syms'}
+      {assetName: 'atom-docs.zip', sourcePath: 'atom-docs'}
+    ]
+  else
+    [
+      {assetName: 'atom-windows.zip', sourcePath: 'Atom'}
+    ]
+
 logError = (message, error, details) ->
   grunt.log.error(message)
   grunt.log.error(error.message ? error) if error?
   grunt.log.error(details) if details
 
-zipApps = (buildDir, assets, callback) ->
-  zip = (directory, sourceName, assetName, callback) ->
+zipAssets = (buildDir, assets, callback) ->
+  zip = (directory, sourcePath, assetName, callback) ->
     if process.platform is 'win32'
-      zipCommand = "C:/psmodules/7z.exe a -r #{assetName} #{sourceName}"
+      zipCommand = "C:/psmodules/7z.exe a -r #{assetName} #{sourcePath}"
     else
-      zipCommand = "zip -r --symlinks #{assetName} #{sourceName}"
+      zipCommand = "zip -r --symlinks #{assetName} #{sourcePath}"
     options = {cwd: directory, maxBuffer: Infinity}
     child_process.exec zipCommand, options, (error, stdout, stderr) ->
-      logError("Zipping #{sourceName} failed", error, stderr) if error?
+      logError("Zipping #{sourcePath} failed", error, stderr) if error?
       callback(error)
 
   tasks = []
-  for {assetName, sourceName} in assets
+  for {assetName, sourcePath} in assets
     fs.removeSync(path.join(buildDir, assetName))
-    tasks.push(zip.bind(this, buildDir, sourceName, assetName))
+    tasks.push(zip.bind(this, buildDir, sourcePath, assetName))
   async.parallel(tasks, callback)
 
 getAtomDraftRelease = (callback) ->
@@ -127,7 +137,7 @@ uploadAssets = (release, buildDir, assets, callback) ->
     fs.createReadStream(assetPath).pipe(assetRequest)
 
   tasks = []
-  for {assetName, sourceName} in assets
+  for {assetName} in assets
     assetPath = path.join(buildDir, assetName)
     tasks.push(upload.bind(this, release, assetName, assetPath))
   async.parallel(tasks, callback)

docs/advanced/configuration.md

@@ -11,41 +11,31 @@ value of a namespaced config key with `atom.config.get`:
 @showInvisibles() if atom.config.get "editor.showInvisibles"
 ```
 
-Or you can use the `::observeConfig` to track changes from any view object.
+Or you can use the `::subscribe` with `atom.config.observe` to track changes
+from any view object.
 
 ```coffeescript
 class MyView extends View
   initialize: ->
-    @observeConfig 'editor.fontSize', () =>
+    @subscribe atom.config.observe 'editor.fontSize', (newValue, {previous}) =>
       @adjustFontSize()
 ```
 
-The `::observeConfig` 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.
+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.
 
-Subscriptions made with `observeConfig` are automatically canceled when the
+Subscriptions made with `::subscribe` are automatically canceled when the
 view is removed. You can cancel config subscriptions manually via the
-`unobserveConfig` method.
+`off` method on the subscription object that `atom.config.observe` returns.
 
 ```coffeescript
-view1.unobserveConfig() # unobserve all properties
-```
+fontSizeSubscription = atom.config.observe 'editor.fontSize', (newValue, {previous}) =>
+  @adjustFontSize()
 
-You can add the ability to observe config values to non-view classes by
-extending their prototype with the `ConfigObserver` mixin:
+# ... later on
 
-```coffeescript
-{ConfigObserver} = require 'atom'
-
-class MyClass
-  ConfigObserver.includeInto(this)
-  
-  constructor: ->
-    @observeConfig 'editor.showInvisibles', -> # ...
-
-  destroy: ->
-    @unobserveConfig()
+fontSizeSubscription.off() # Stop observing
 ```
 
 ### Writing Config Settings

docs/apm-rest-api.md

@@ -198,6 +198,19 @@ Unstar a package; requires authentication.
 
 Returns 204 No Content.
 
+#### GET /api/packages/:name/stargazers
+
+List the users that have starred a package.
+
+Returns a list of user objects:
+
+```json
+[
+  {"login":"aperson"},
+  {"login":"anotherperson"},
+]
+```
+
 ### Atom updates
 
 #### GET /api/updates
@@ -206,10 +219,10 @@ Atom update feed, following the format expected by [Squirrel](https://github.com
 
 Returns:
 
-```
+```json
 {
     "name": "0.96.0",
-    "notes": "[HTML release notes]"
+    "notes": "[HTML release notes]",
     "pub_date": "2014-05-19T15:52:06.000Z",
     "url": "https://www.atom.io/api/updates/download"
 }

docs/build-instructions/linux.md

@@ -61,6 +61,13 @@ and restart Atom.  If Atom now works fine, you can make this setting permanent:
 
 See also https://github.com/atom/atom/issues/2082.
 
+### /usr/bin/env: node: No such file or directory
+
+If you get this notice when attempting to `script/build`, you either do not
+have nodejs installed, or node isn't identified as nodejs on your machine.
+If it's the latter, entering `sudo ln -s /usr/bin/nodejs /usr/bin/node` into
+your terminal may fix the issue.
+
 ### Linux build error reports in atom/atom
 * Use [this search](https://github.com/atom/atom/search?q=label%3Abuild-error+label%3Alinux&type=Issues)
   to get a list of reports about build errors on Linux.

docs/build-instructions/windows.md

@@ -9,8 +9,11 @@
     * For 64-bit builds of node and native modules you **must** have the
     [Windows 7 64-bit SDK](http://www.microsoft.com/en-us/download/details.aspx?id=8279).
     You may also need the [compiler update for the Windows SDK 7.1](http://www.microsoft.com/en-us/download/details.aspx?id=4422)
-
-  * [Python](http://www.python.org/download/) v2.7.x
+  * [Python](http://www.python.org/download/) v2.7.
+    * The python.exe must be available at `%SystemDrive%\Python27\python.exe`.
+      If it is installed elsewhere, you can create a symbolic link to the
+      directory containing the python.exe using:
+      `mklink /d %SystemDrive%\Python27 D:\elsewhere\Python27`
   * [GitHub for Windows](http://windows.github.com/)
 
 ### On Windows 8

docs/writing-specs.md

@@ -38,7 +38,7 @@ Atom uses [Jasmine](http://jasmine.github.io/2.0/introduction.html) as its spec
 
 0. Add one or more expectations
 
-  The best way to learn about expectations is to read the [jasmine documentation](http://jasmine.github.io/2.0/introduction.html#section-Expectations) about them. Below is a simple example.
+  The best way to learn about expectations is to read the [jasmine documentation](http://jasmine.github.io/1.3/introduction.html#section-Expectations) about them. Below is a simple example.
 
   ```coffee
   describe "when a test is written", ->
@@ -47,6 +47,74 @@ Atom uses [Jasmine](http://jasmine.github.io/2.0/introduction.html) as its spec
       expect("oranges").not.toEqual("apples")
   ```
 
+## Asynchronous specs
+
+Writing Asynchronous specs can be tricky at first. Some examples.
+
+0. Promises
+
+  Working with promises is rather easy in Atom. You can use our `waitsForPromise` function.
+
+  ```coffee
+    describe "when we open a file", ->
+      it "should be opened in an editor", ->
+        waitsForPromise ->
+          atom.workspace.open('c.coffee').then (editor) ->
+            expect(editor.getPath()).toContain 'c.coffee'
+  ```
+
+  This method can be used in the `describe`, `it`, `beforeEach` and `afterEach` functions.
+
+  ```coffee
+  describe "when we open a file", ->
+    beforeEach ->
+      waitsForPromise ->
+        atom.workspace.open 'c.coffee'
+
+    it "should be opened in an editor", ->
+      expect(atom.workspace.getActiveEditor().getPath()).toContain 'c.coffee'
+
+  ```
+
+  If you need to wait for multiple promises use a new `waitsForPromise` function for each promise. (Caution: Without `beforeEach` this example will fail!)
+
+  ```coffee
+  describe "waiting for the packages to load", ->
+
+    beforeEach ->
+      waitsForPromise ->
+        atom.workspace.open('sample.js')
+      waitsForPromise ->
+        atom.packages.activatePackage('tabs')
+      waitsForPromise ->
+        atom.packages.activatePackage('tree-view')
+
+    it 'should have waited long enough', ->
+      expect(atom.packages.isPackageActive('tabs')).toBe true
+      expect(atom.packages.isPackageActive('tree-view')).toBe true
+  ```
+
+0. Asynchronous functions with callbacks
+
+  Specs for asynchronous functions can be done using the `waitsFor` and `runs` functions. A simple example.
+
+  ```coffee
+  describe "fs.readdir(path, cb)", ->
+    it "is async", ->
+      spy = jasmine.createSpy('fs.readdirSpy')
+
+      fs.readdir('/tmp/example', spy)
+      waitsFor ->
+        spy.callCount > 0
+      runs ->
+        exp = [null, ['example.coffee']]
+        expect(spy.mostRecentCall.args).toEqual exp
+        expect(spy).toHaveBeenCalledWith(null, ['example.coffee'])
+  ```
+
+For a more detailed documentation on asynchronous tests please visit the [jasmine documentation](http://jasmine.github.io/1.3/introduction.html#section-Asynchronous_Support).
+
+
 ## Running specs
 
 Most of the time you'll want to run specs by triggering the `window:run-package-specs` command. This command is not only to run package specs, it is also for Atom core specs. This will run all the specs in the current project's spec directory. If you want to run the Atom core specs and **all** the default package specs trigger the `window:run-all-specs` command.

keymaps/darwin.cson

@@ -53,6 +53,8 @@
   'shift-down': 'core:select-down'
   'shift-left': 'core:select-left'
   'shift-right': 'core:select-right'
+  'shift-pageup': 'core:select-page-up'
+  'shift-pagedown': 'core:select-page-down'
   'delete': 'core:delete'
   'shift-delete': 'core:delete'
   'pageup': 'core:page-up'
@@ -67,6 +69,8 @@
   'cmd-}': 'pane:show-next-item'
   'cmd-alt-left': 'pane:show-previous-item'
   'cmd-alt-right': 'pane:show-next-item'
+  'ctrl-pageup': 'pane:show-previous-item'
+  'ctrl-pagedown': 'pane:show-next-item'
   'ctrl-tab': 'pane:show-next-item'
   'ctrl-shift-tab': 'pane:show-previous-item'
   'cmd-=': 'window:increase-font-size'

keymaps/linux.cson

@@ -35,6 +35,8 @@
   'shift-down': 'core:select-down'
   'shift-left': 'core:select-left'
   'shift-right': 'core:select-right'
+  'shift-pageup': 'core:select-page-up'
+  'shift-pagedown': 'core:select-page-down'
   'delete': 'core:delete'
   'shift-delete': 'core:delete'
   'pageup': 'core:page-up'
@@ -43,6 +45,8 @@
   'shift-backspace': 'core:backspace'
   'ctrl-tab': 'pane:show-next-item'
   'ctrl-shift-tab': 'pane:show-previous-item'
+  'ctrl-pageup': 'pane:show-previous-item'
+  'ctrl-pagedown': 'pane:show-next-item'
   'ctrl-shift-up': 'core:move-up'
   'ctrl-shift-down': 'core:move-down'
   'ctrl-=': 'window:increase-font-size'

keymaps/win32.cson

@@ -37,6 +37,8 @@
   'shift-down': 'core:select-down'
   'shift-left': 'core:select-left'
   'shift-right': 'core:select-right'
+  'shift-pageup': 'core:select-page-up'
+  'shift-pagedown': 'core:select-page-down'
   'delete': 'core:delete'
   'shift-delete': 'core:delete'
   'pageup': 'core:page-up'
@@ -45,6 +47,8 @@
   'shift-backspace': 'core:backspace'
   'ctrl-tab': 'pane:show-next-item'
   'ctrl-shift-tab': 'pane:show-previous-item'
+  'ctrl-pageup': 'pane:show-previous-item'
+  'ctrl-pagedown': 'pane:show-next-item'
   'ctrl-shift-up': 'core:move-up'
   'ctrl-shift-down': 'core:move-down'
   'ctrl-alt-up': 'editor:add-selection-above'

menus/darwin.cson

@@ -109,6 +109,7 @@
     submenu: [
       { label: 'Add Selection Above', command: 'editor:add-selection-above' }
       { label: 'Add Selection Below', command: 'editor:add-selection-below' }
+      { label: 'Single Selection', command: 'editor:consolidate-selections'}
       { label: 'Split into Lines', command: 'editor:split-selections-into-lines'}
       { type: 'separator' }
       { label: 'Select to Top', command: 'core:select-to-top' }

menus/linux.cson

@@ -108,6 +108,7 @@
       { label: 'Add Selection &Above', command: 'editor:add-selection-above' }
       { label: 'Add Selection &Below', command: 'editor:add-selection-below' }
       { label: 'S&plit into Lines', command: 'editor:split-selections-into-lines'}
+      { label: 'Single Selection', command: 'editor:consolidate-selections'}
       { type: 'separator' }
       { label: 'Select to &Top', command: 'core:select-to-top' }
       { label: 'Select to Botto&m', command: 'core:select-to-bottom' }

menus/win32.cson

@@ -127,6 +127,7 @@
       { label: 'Add Selection &Above', command: 'editor:add-selection-above' }
       { label: 'Add Selection &Below', command: 'editor:add-selection-below' }
       { label: 'S&plit into Lines', command: 'editor:split-selections-into-lines'}
+      { label: 'Single Selection', command: 'editor:consolidate-selections'}
       { type: 'separator' }
       { label: 'Select to &Top', command: 'core:select-to-top' }
       { label: 'Select to Botto&m', command: 'core:select-to-bottom' }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "atom",
   "productName": "Atom",
-  "version": "0.104.0",
+  "version": "0.107.0",
   "description": "A hackable text editor for the 21st Century.",
   "main": "./src/browser/main.js",
   "repository": {
@@ -17,7 +17,7 @@
       "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
     }
   ],
-  "atomShellVersion": "0.13.1",
+  "atomShellVersion": "0.13.3",
   "dependencies": {
     "async": "0.2.6",
     "atom-keymap": "^0.27.0",
@@ -27,7 +27,7 @@
     "coffeestack": "0.7.0",
     "delegato": "^1",
     "emissary": "^1.2.1",
-    "first-mate": "^1.7",
+    "first-mate": "^1.7.1",
     "fs-plus": "^2.2.3",
     "fstream": "0.1.24",
     "fuzzaldrin": "^1.1",
@@ -47,8 +47,8 @@
     "random-words": "0.0.1",
     "react-atom-fork": "^0.10.0",
     "reactionary-atom-fork": "^0.9.0",
-    "runas": "^0.5",
-    "scandal": "0.15.3",
+    "runas": "0.5.4",
+    "scandal": "0.16.0",
     "scoped-property-store": "^0.9.0",
     "scrollbar-style": "^0.4.0",
     "season": "^1.0.2",
@@ -56,77 +56,78 @@
     "serializable": "^1",
     "space-pen": "3.2.0",
     "temp": "0.7.0",
-    "text-buffer": "^2.3.0",
+    "text-buffer": "^2.4.2",
     "theorist": "^1",
-    "underscore-plus": "^1.4.1",
+    "underscore-plus": "^1.5.0",
     "vm-compatibility-layer": "0.1.0"
   },
   "packageDependencies": {
-    "atom-dark-syntax": "0.16.0",
-    "atom-dark-ui": "0.29.0",
-    "atom-light-syntax": "0.17.0",
-    "atom-light-ui": "0.25.0",
-    "base16-tomorrow-dark-theme": "0.16.0",
-    "solarized-dark-syntax": "0.17.0",
-    "solarized-light-syntax": "0.8.0",
-    "archive-view": "0.32.0",
+    "atom-dark-syntax": "0.17.0",
+    "atom-dark-ui": "0.30.0",
+    "atom-light-syntax": "0.18.0",
+    "atom-light-ui": "0.26.0",
+    "base16-tomorrow-dark-theme": "0.17.0",
+    "solarized-dark-syntax": "0.18.0",
+    "solarized-light-syntax": "0.9.0",
+    "archive-view": "0.33.0",
     "autocomplete": "0.28.0",
     "autoflow": "0.17.0",
     "autosave": "0.14.0",
-    "background-tips": "0.14.0",
-    "bookmarks": "0.24.0",
-    "bracket-matcher": "0.46.0",
-    "command-palette": "0.22.0",
+    "background-tips": "0.15.0",
+    "bookmarks": "0.25.0",
+    "bracket-matcher": "0.47.0",
+    "command-palette": "0.24.0",
     "deprecation-cop": "0.7.0",
     "dev-live-reload": "0.31.0",
     "exception-reporting": "0.18.0",
     "feedback": "0.33.0",
-    "find-and-replace": "0.117.0",
-    "fuzzy-finder": "0.54.0",
-    "git-diff": "0.31.0",
-    "go-to-line": "0.22.0",
+    "find-and-replace": "0.122.0",
+    "fuzzy-finder": "0.56.0",
+    "git-diff": "0.34.0",
+    "go-to-line": "0.23.0",
     "grammar-selector": "0.27.0",
-    "image-view": "0.35.0",
+    "image-view": "0.36.0",
     "keybinding-resolver": "0.18.0",
-    "link": "0.22.0",
-    "markdown-preview": "0.80.0",
+    "link": "0.24.0",
+    "markdown-preview": "0.86.0",
     "metrics": "0.32.0",
-    "open-on-github": "0.28.0",
+    "open-on-github": "0.29.0",
     "package-generator": "0.31.0",
     "release-notes": "0.32.0",
-    "settings-view": "0.127.0",
-    "snippets": "0.45.0",
-    "spell-check": "0.37.0",
-    "status-bar": "0.40.0",
+    "settings-view": "0.129.0",
+    "snippets": "0.47.0",
+    "spell-check": "0.38.0",
+    "status-bar": "0.41.0",
     "styleguide": "0.29.0",
-    "symbols-view": "0.56.0",
-    "tabs": "0.41.0",
-    "timecop": "0.19.0",
-    "tree-view": "0.103.0",
+    "symbols-view": "0.59.0",
+    "tabs": "0.42.0",
+    "timecop": "0.21.0",
+    "tree-view": "0.108.0",
     "update-package-dependencies": "0.6.0",
-    "welcome": "0.16.0",
-    "whitespace": "0.22.0",
-    "wrap-guide": "0.18.0",
-    "language-c": "0.18.0",
+    "welcome": "0.17.0",
+    "whitespace": "0.23.0",
+    "wrap-guide": "0.19.0",
+
+    "language-c": "0.21.0",
     "language-coffee-script": "0.22.0",
     "language-css": "0.17.0",
-    "language-gfm": "0.39.0",
+    "language-gfm": "0.42.0",
     "language-git": "0.9.0",
-    "language-go": "0.12.0",
+    "language-go": "0.13.0",
     "language-html": "0.22.0",
     "language-hyperlink": "0.10.0",
-    "language-java": "0.10.0",
-    "language-javascript": "0.27.0",
+    "language-java": "0.11.0",
+    "language-javascript": "0.30.0",
     "language-json": "0.8.0",
-    "language-less": "0.9.0",
+    "language-less": "0.11.0",
     "language-make": "0.10.0",
     "language-objective-c": "0.11.0",
     "language-perl": "0.9.0",
     "language-php": "0.15.0",
     "language-property-list": "0.7.0",
     "language-python": "0.18.0",
-    "language-ruby": "0.29.0",
-    "language-ruby-on-rails": "0.14.0",
+    "language-ruby": "0.30.0",
+    "language-ruby-on-rails": "0.15.0",
     "language-sass": "0.13.0",
     "language-shellscript": "0.8.0",
     "language-source": "0.7.0",
@@ -134,8 +135,8 @@
     "language-text": "0.6.0",
     "language-todo": "0.10.0",
     "language-toml": "0.12.0",
-    "language-xml": "0.14.0",
-    "language-yaml": "0.7.0"
+    "language-xml": "0.15.0",
+    "language-yaml": "0.10.0"
   },
   "private": true,
   "scripts": {

resources/linux/Atom.desktop.in

@@ -1,8 +1,8 @@
 [Desktop Entry]
 Name=Atom
 Comment=<%= description %>
-Exec=/usr/share/atom/atom %U
-Icon=atom
+Exec=<%= installDir %>/share/atom/atom %U
+Icon=<%= iconName %>
 Type=Application
 StartupNotify=true
 Categories=GNOME;GTK;Utility;TextEditor;

spec/context-menu-manager-spec.coffee

@@ -17,6 +17,33 @@ describe "ContextMenuManager", ->
       expect(contextMenu.definitions['.selector'][0].label).toEqual 'label'
       expect(contextMenu.definitions['.selector'][0].command).toEqual 'command'
 
+    it 'does not add duplicate menu items',  ->
+      contextMenu.add 'file-path',
+        '.selector':
+          'label': 'command'
+
+      contextMenu.add 'file-path',
+        '.selector':
+          'label': 'command'
+
+      expect(contextMenu.definitions['.selector'][0].label).toEqual 'label'
+      expect(contextMenu.definitions['.selector'][0].command).toEqual 'command'
+      expect(contextMenu.definitions['.selector'].length).toBe 1
+
+    it 'allows duplicate commands with different labels',  ->
+      contextMenu.add 'file-path',
+        '.selector':
+          'label': 'command'
+
+      contextMenu.add 'file-path',
+        '.selector':
+          'another label': 'command'
+
+      expect(contextMenu.definitions['.selector'][0].label).toEqual 'label'
+      expect(contextMenu.definitions['.selector'][0].command).toEqual 'command'
+      expect(contextMenu.definitions['.selector'][1].label).toEqual 'another label'
+      expect(contextMenu.definitions['.selector'][1].command).toEqual 'command'
+
     it "loads submenus", ->
       contextMenu.add 'file-path',
         '.selector':

spec/display-buffer-spec.coffee

@@ -47,6 +47,15 @@ describe "DisplayBuffer", ->
       buffer.insert([0,0], oneHundredLines)
       expect(displayBuffer.getLineCount()).toBe 100 + originalLineCount
 
+    it "reassigns the scrollTop if it exceeds the max possible value after lines are removed", ->
+      displayBuffer.manageScrollPosition = true
+      displayBuffer.setHeight(50)
+      displayBuffer.setLineHeightInPixels(10)
+      displayBuffer.setScrollTop(80)
+
+      buffer.delete([[8, 0], [10, 0]])
+      expect(displayBuffer.getScrollTop()).toBe 60
+
   describe "soft wrapping", ->
     beforeEach ->
       displayBuffer.setSoftWrap(true)
@@ -315,6 +324,16 @@ describe "DisplayBuffer", ->
           expect(line0.fold).toBe outerFold
           expect(line1.fold).toBeUndefined()
 
+      describe "when a fold ends where another fold begins", ->
+        it "continues to hide the lines inside the second fold", ->
+          fold2 = displayBuffer.createFold(4, 9)
+          fold1 = displayBuffer.createFold(0, 4)
+
+          displayBuffer.logLines(0, 20)
+
+          expect(displayBuffer.lineForRow(0).text).toMatch /^0/
+          expect(displayBuffer.lineForRow(1).text).toMatch /^10/
+
       describe "when there is another display buffer pointing to the same buffer", ->
         it "does not create folds in the other display buffer", ->
           otherDisplayBuffer = new DisplayBuffer({buffer, tabLength})
@@ -912,6 +931,42 @@ describe "DisplayBuffer", ->
         expect(displayBuffer.findMarkers(class: 'a', startBufferRow: 0, endBufferRow: 3)).toEqual [marker1]
         expect(displayBuffer.findMarkers(endBufferRow: 10)).toEqual [marker3]
 
+      it "allows the startScreenRow and endScreenRow to be specified", ->
+        marker1 = displayBuffer.markBufferRange([[6, 0], [7, 0]], class: 'a')
+        marker2 = displayBuffer.markBufferRange([[9, 0], [10, 0]], class: 'a')
+        displayBuffer.createFold(4, 7)
+        expect(displayBuffer.findMarkers(class: 'a', startScreenRow: 6, endScreenRow: 7)).toEqual [marker2]
+
+      it "allows intersectsBufferRowRange to be specified", ->
+        marker1 = displayBuffer.markBufferRange([[5, 0], [5, 0]], class: 'a')
+        marker2 = displayBuffer.markBufferRange([[8, 0], [8, 0]], class: 'a')
+        displayBuffer.createFold(4, 7)
+        expect(displayBuffer.findMarkers(class: 'a', intersectsBufferRowRange: [5, 6])).toEqual [marker1]
+
+      it "allows intersectsScreenRowRange to be specified", ->
+        marker1 = displayBuffer.markBufferRange([[5, 0], [5, 0]], class: 'a')
+        marker2 = displayBuffer.markBufferRange([[8, 0], [8, 0]], class: 'a')
+        displayBuffer.createFold(4, 7)
+        expect(displayBuffer.findMarkers(class: 'a', intersectsScreenRowRange: [5, 10])).toEqual [marker2]
+
+      it "allows containedInScreenRange to be specified", ->
+        marker1 = displayBuffer.markBufferRange([[5, 0], [5, 0]], class: 'a')
+        marker2 = displayBuffer.markBufferRange([[8, 0], [8, 0]], class: 'a')
+        displayBuffer.createFold(4, 7)
+        expect(displayBuffer.findMarkers(class: 'a', containedInScreenRange: [[5, 0], [7, 0]])).toEqual [marker2]
+
+      it "allows intersectsBufferRange to be specified", ->
+        marker1 = displayBuffer.markBufferRange([[5, 0], [5, 0]], class: 'a')
+        marker2 = displayBuffer.markBufferRange([[8, 0], [8, 0]], class: 'a')
+        displayBuffer.createFold(4, 7)
+        expect(displayBuffer.findMarkers(class: 'a', intersectsBufferRange: [[5, 0], [6, 0]])).toEqual [marker1]
+
+      it "allows intersectsScreenRange to be specified", ->
+        marker1 = displayBuffer.markBufferRange([[5, 0], [5, 0]], class: 'a')
+        marker2 = displayBuffer.markBufferRange([[8, 0], [8, 0]], class: 'a')
+        displayBuffer.createFold(4, 7)
+        expect(displayBuffer.findMarkers(class: 'a', intersectsScreenRange: [[5, 0], [10, 0]])).toEqual [marker2]
+
     describe "marker destruction", ->
       it "allows markers to be destroyed", ->
         marker = displayBuffer.markScreenRange([[5, 4], [5, 10]])
@@ -950,12 +1005,25 @@ describe "DisplayBuffer", ->
 
         displayBuffer.setLineHeightInPixels(20)
         displayBuffer.setDefaultCharWidth(10)
-        displayBuffer.setScopedCharWidths(["source.js", "keyword.control.js"], r: 11, e: 11, t: 11, u: 11, n: 11)
+
+        for char in ['r', 'e', 't', 'u', 'r', 'n']
+          displayBuffer.setScopedCharWidth(["source.js", "keyword.control.js"], char, 11)
 
         {start, end} = marker.getPixelRange()
         expect(start.top).toBe 5 * 20
         expect(start.left).toBe (4 * 10) + (6 * 11)
 
+  describe "decorations", ->
+    it "can add decorations associated with markers and remove them", ->
+      decoration = {type: 'gutter', class: 'one'}
+      marker = displayBuffer.markBufferRange([[2, 13], [3, 15]])
+
+      displayBuffer.addDecorationForMarker(marker, decoration)
+      expect(displayBuffer.decorationsForScreenRowRange(2, 3)[marker.id][0]).toBe decoration
+
+      displayBuffer.removeDecorationForMarker(marker, decoration)
+      expect(displayBuffer.decorationsForScreenRowRange(2, 3)[marker.id]).not.toBeDefined()
+
   describe "::setScrollTop", ->
     beforeEach ->
       displayBuffer.manageScrollPosition = true
@@ -997,17 +1065,61 @@ describe "DisplayBuffer", ->
       expect(displayBuffer.setScrollLeft(maxScrollLeft + 50)).toBe maxScrollLeft
       expect(displayBuffer.getScrollLeft()).toBe maxScrollLeft
 
-  describe "::scrollToScreenPosition(position)", ->
-    it "sets the scroll top and scroll left so the given screen position is in view", ->
+  describe "::scrollToScreenPosition(position, [options])", ->
+    beforeEach ->
       displayBuffer.manageScrollPosition = true
       displayBuffer.setLineHeightInPixels(10)
       displayBuffer.setDefaultCharWidth(10)
       displayBuffer.setHorizontalScrollbarHeight(0)
-
       displayBuffer.setHeight(50)
       displayBuffer.setWidth(50)
-      maxScrollTop = displayBuffer.getScrollHeight() - displayBuffer.getHeight()
 
+    it "sets the scroll top and scroll left so the given screen position is in view", ->
       displayBuffer.scrollToScreenPosition([8, 20])
       expect(displayBuffer.getScrollBottom()).toBe (9 + displayBuffer.getVerticalScrollMargin()) * 10
       expect(displayBuffer.getScrollRight()).toBe (20 + displayBuffer.getHorizontalScrollMargin()) * 10
+
+    describe "when the 'center' option is true", ->
+      it "vertically scrolls to center the given position vertically", ->
+        displayBuffer.scrollToScreenPosition([8, 20], center: true)
+        expect(displayBuffer.getScrollTop()).toBe (8 * 10) + 5 - (50 / 2)
+        expect(displayBuffer.getScrollRight()).toBe (20 + displayBuffer.getHorizontalScrollMargin()) * 10
+
+      it "does not scroll vertically if the position is already in view", ->
+        displayBuffer.scrollToScreenPosition([4, 20], center: true)
+        expect(displayBuffer.getScrollTop()).toBe 0
+
+  describe "scroll width", ->
+    cursorWidth = 1
+    beforeEach ->
+      displayBuffer.setDefaultCharWidth(10)
+
+    it "recomputes the scroll width when the default character width changes", ->
+      expect(displayBuffer.getScrollWidth()).toBe 10 * 65 + cursorWidth
+
+      displayBuffer.setDefaultCharWidth(12)
+      expect(displayBuffer.getScrollWidth()).toBe 12 * 65 + cursorWidth
+
+    it "recomputes the scroll width when the max line length changes", ->
+      buffer.insert([6, 12], ' ')
+      expect(displayBuffer.getScrollWidth()).toBe 10 * 66 + cursorWidth
+
+      buffer.delete([[6, 10], [6, 12]], ' ')
+      expect(displayBuffer.getScrollWidth()).toBe 10 * 64 + cursorWidth
+
+    it "recomputes the scroll width when the scoped character widths change", ->
+      operatorWidth = 20
+      displayBuffer.setScopedCharWidth(['source.js', 'keyword.operator.js'], '<', operatorWidth)
+      expect(displayBuffer.getScrollWidth()).toBe 10 * 64 + operatorWidth + cursorWidth
+
+    it "recomputes the scroll width when the scoped character widths change in a batch", ->
+      operatorWidth = 20
+
+      displayBuffer.on 'character-widths-changed', changedSpy = jasmine.createSpy()
+
+      displayBuffer.batchCharacterMeasurement ->
+        displayBuffer.setScopedCharWidth(['source.js', 'keyword.operator.js'], '<', operatorWidth)
+        displayBuffer.setScopedCharWidth(['source.js', 'keyword.operator.js'], '?', operatorWidth)
+
+      expect(displayBuffer.getScrollWidth()).toBe 10 * 63 + operatorWidth * 2 + cursorWidth
+      expect(changedSpy.callCount).toBe 1

spec/editor-spec.coffee

@@ -1196,6 +1196,7 @@ describe "Editor", ->
           editor.setHeight(50)
           editor.setWidth(50)
           editor.setHorizontalScrollbarHeight(0)
+
           expect(editor.getScrollTop()).toBe 0
 
           editor.setSelectedBufferRange([[5, 6], [6, 8]], autoscroll: true)
@@ -1220,6 +1221,21 @@ describe "Editor", ->
           expect(editor.selectMarker(marker)).toBeFalsy()
           expect(editor.getSelectedBufferRange()).toEqual [[0, 0], [0, 0]]
 
+    describe ".addSelectionForBufferRange(bufferRange)", ->
+      it "adds a selection for the specified buffer range", ->
+        editor.addSelectionForBufferRange([[3, 4], [5, 6]])
+        expect(editor.getSelectedBufferRanges()).toEqual [[[0, 0], [0, 0]], [[3, 4], [5, 6]]]
+
+      it "autoscrolls to the added selection if needed", ->
+        editor.setLineHeightInPixels(10)
+        editor.setDefaultCharWidth(10)
+        editor.setHeight(50)
+        editor.setWidth(50)
+
+        editor.addSelectionForBufferRange([[8, 10], [8, 15]])
+        expect(editor.getScrollTop()).toBe 75
+        expect(editor.getScrollLeft()).toBe 160
+
     describe ".addSelectionBelow()", ->
       describe "when the selection is non-empty", ->
         it "selects the same region of the line below current selections if possible", ->
@@ -1467,6 +1483,17 @@ describe "Editor", ->
             expect(cursor1.getBufferPosition()).toEqual [1, 5]
             expect(cursor2.getBufferPosition()).toEqual [2, 7]
 
+          it "autoscrolls to the last cursor", ->
+            editor.manageScrollPosition = true
+            editor.setCursorScreenPosition([1, 2])
+            editor.addCursorAtScreenPosition([10, 4])
+            editor.setLineHeightInPixels(10)
+            editor.setHeight(50)
+
+            expect(editor.getScrollTop()).toBe 0
+            editor.insertText('a')
+            expect(editor.getScrollTop()).toBe 80
+
       describe "when there are multiple non-empty selections", ->
         describe "when the selections are on the same line", ->
           it "replaces each selection range with the inserted characters", ->
@@ -1831,6 +1858,32 @@ describe "Editor", ->
           expect(buffer.lineForRow(1)).toBe '  var sort = function(it) {'
           expect(buffer.lineForRow(2)).toBe 'if (items.length <= 1) return items;'
 
+    describe '.deleteToEndOfLine()', ->
+      describe 'when no text is selected', ->
+        it 'deletes all text between the cursor and the end of the line', ->
+          editor.setCursorBufferPosition([1, 24])
+          editor.addCursorAtBufferPosition([2, 5])
+          [cursor1, cursor2] = editor.getCursors()
+
+          editor.deleteToEndOfLine()
+          expect(buffer.lineForRow(1)).toBe '  var sort = function(it'
+          expect(buffer.lineForRow(2)).toBe '    i'
+          expect(cursor1.getBufferPosition()).toEqual [1, 24]
+          expect(cursor2.getBufferPosition()).toEqual [2, 5]
+
+        describe 'when at the end of the line', ->
+          it 'deletes the next newline', ->
+            editor.setCursorBufferPosition([1, 30])
+            editor.deleteToEndOfLine()
+            expect(buffer.lineForRow(1)).toBe '  var sort = function(items) {    if (items.length <= 1) return items;'
+
+      describe 'when text is selected', ->
+        it 'deletes only the text in the selection', ->
+          editor.setSelectedBufferRanges([[[1, 24], [1, 27]], [[2, 0], [2, 4]]])
+          editor.deleteToEndOfLine()
+          expect(buffer.lineForRow(1)).toBe '  var sort = function(it) {'
+          expect(buffer.lineForRow(2)).toBe 'if (items.length <= 1) return items;'
+
     describe ".deleteToBeginningOfLine()", ->
       describe "when no text is selected", ->
         it "deletes all text between the cursor and the beginning of the line", ->
@@ -3244,113 +3297,36 @@ describe "Editor", ->
       expect(editor.getScrollTop()).toBe 0
       expect(editor.getCursorBufferPosition().row).toBe 0
 
-  describe "decorations", ->
-    decoration = null
-    beforeEach ->
-      decoration = {type: 'gutter', class: 'one'}
+  describe ".selectPageUp/Down()", ->
+    it "selects one screen height of text up or down", ->
+      editor.manageScrollPosition = true
 
-    it "can add decorations to buffer rows and remove them", ->
-      editor.addDecorationToBufferRow(2, decoration)
-      editor.addDecorationToBufferRow(2, decoration)
+      editor.setLineHeightInPixels(10)
+      editor.setHeight(50)
+      expect(editor.getScrollHeight()).toBe 130
+      expect(editor.getCursorBufferPosition().row).toBe 0
 
-      decorations = editor.decorationsForBufferRow(2)
-      expect(decorations).toHaveLength 1
-      expect(decorations).toContain decoration
+      editor.selectPageDown()
+      expect(editor.getScrollTop()).toBe 30
+      expect(editor.getSelectedBufferRanges()).toEqual [[[0,0], [5,0]]]
 
-      editor.removeDecorationFromBufferRow(2, decoration)
-      decorations = editor.decorationsForBufferRow(2)
-      expect(decorations).toHaveLength 0
+      editor.selectPageDown()
+      expect(editor.getScrollTop()).toBe 80
+      expect(editor.getSelectedBufferRanges()).toEqual [[[0,0], [10,0]]]
 
-    it "can add decorations to buffer row ranges and remove them", ->
-      editor.addDecorationToBufferRowRange(2, 4, decoration)
-      expect(editor.decorationsForBufferRow 2).toContain decoration
-      expect(editor.decorationsForBufferRow 3).toContain decoration
-      expect(editor.decorationsForBufferRow 4).toContain decoration
+      editor.selectPageDown()
+      expect(editor.getScrollTop()).toBe 80
+      expect(editor.getSelectedBufferRanges()).toEqual [[[0,0], [12,2]]]
 
-      editor.removeDecorationFromBufferRowRange(3, 5, decoration)
-      expect(editor.decorationsForBufferRow 2).toContain decoration
-      expect(editor.decorationsForBufferRow 3).not.toContain decoration
-      expect(editor.decorationsForBufferRow 4).not.toContain decoration
+      editor.moveCursorToBottom()
+      editor.selectPageUp()
+      expect(editor.getScrollTop()).toBe 50
+      expect(editor.getSelectedBufferRanges()).toEqual [[[7,0], [12,2]]]
 
-    it "can add decorations associated with markers and remove them", ->
-      marker = editor.displayBuffer.markBufferRange([[2, 13], [3, 15]], class: 'my-marker', invalidate: 'inside')
+      editor.selectPageUp()
+      expect(editor.getScrollTop()).toBe 0
+      expect(editor.getSelectedBufferRanges()).toEqual [[[2,0], [12,2]]]
 
-      editor.addDecorationForMarker(marker, decoration)
-      expect(editor.decorationsForBufferRow 1).not.toContain decoration
-      expect(editor.decorationsForBufferRow 2).toContain decoration
-      expect(editor.decorationsForBufferRow 3).toContain decoration
-      expect(editor.decorationsForBufferRow 4).not.toContain decoration
-
-      editor.getBuffer().insert([0, 0], '\n')
-      expect(editor.decorationsForBufferRow 2).not.toContain decoration
-      expect(editor.decorationsForBufferRow 3).toContain decoration
-      expect(editor.decorationsForBufferRow 4).toContain decoration
-      expect(editor.decorationsForBufferRow 5).not.toContain decoration
-
-      editor.getBuffer().insert([4, 2], 'n')
-      expect(editor.decorationsForBufferRow 2).not.toContain decoration
-      expect(editor.decorationsForBufferRow 3).not.toContain decoration
-      expect(editor.decorationsForBufferRow 4).not.toContain decoration
-      expect(editor.decorationsForBufferRow 5).not.toContain decoration
-
-      editor.getBuffer().undo()
-      expect(editor.decorationsForBufferRow 2).not.toContain decoration
-      expect(editor.decorationsForBufferRow 3).toContain decoration
-      expect(editor.decorationsForBufferRow 4).toContain decoration
-      expect(editor.decorationsForBufferRow 5).not.toContain decoration
-
-      editor.removeDecorationForMarker(marker, decoration)
-      expect(editor.decorationsForBufferRow 2).not.toContain decoration
-      expect(editor.decorationsForBufferRow 3).not.toContain decoration
-      expect(editor.decorationsForBufferRow 4).not.toContain decoration
-      expect(editor.decorationsForBufferRow 5).not.toContain decoration
-
-    describe "decorationsForBufferRow", ->
-      one = {type: 'one', class: 'one'}
-      two = {type: 'two', class: 'two'}
-      typeless = {class: 'typeless'}
-
-      beforeEach ->
-        editor.addDecorationToBufferRow(2, one)
-        editor.addDecorationToBufferRow(2, two)
-        editor.addDecorationToBufferRow(2, typeless)
-
-      it "returns all decorations with no decorationType specified", ->
-        decorations = editor.decorationsForBufferRow(2)
-        expect(decorations).toContain one
-        expect(decorations).toContain two
-        expect(decorations).toContain typeless
-
-      it "returns typeless decorations with all decorationTypes", ->
-        decorations = editor.decorationsForBufferRow(2, 'one')
-        expect(decorations).toContain one
-        expect(decorations).not.toContain two
-        expect(decorations).toContain typeless
-
-    describe "decorationsForBufferRowRange", ->
-      one = {type: 'one', class: 'one'}
-      two = {type: 'two', class: 'two'}
-      typeless = {class: 'typeless'}
-
-      it "returns an object of decorations based on the decorationType", ->
-        editor.addDecorationToBufferRow(2, one)
-        editor.addDecorationToBufferRow(3, one)
-        editor.addDecorationToBufferRow(5, one)
-
-        editor.addDecorationToBufferRow(3, two)
-        editor.addDecorationToBufferRow(4, two)
-
-        editor.addDecorationToBufferRow(3, typeless)
-        editor.addDecorationToBufferRow(5, typeless)
-
-        decorations = editor.decorationsForBufferRowRange(2, 5, 'one')
-        expect(decorations[2]).toContain one
-
-        expect(decorations[3]).toContain one
-        expect(decorations[3]).not.toContain two
-        expect(decorations[3]).toContain typeless
-
-        expect(decorations[4]).toHaveLength 0
-
-        expect(decorations[5]).toContain one
-        expect(decorations[5]).toContain typeless
+      editor.selectPageUp()
+      expect(editor.getScrollTop()).toBe 0
+      expect(editor.getSelectedBufferRanges()).toEqual [[[0,0], [12,2]]]

spec/editor-view-spec.coffee

@@ -1611,7 +1611,7 @@ describe "EditorView", ->
         editorView.attachToDom()
 
         expect(atom.config.get("editor.showInvisibles")).toBeFalsy()
-        expect(editorView.renderedLines.find('.line').text()).toBe " a line with tabs  and spaces "
+        expect(editorView.renderedLines.find('.line').text()).toBe " a line with tabs and spaces "
 
         atom.config.set("editor.showInvisibles", true)
         space = editorView.invisibles?.space
@@ -1620,10 +1620,10 @@ describe "EditorView", ->
         expect(tab).toBeTruthy()
         eol = editorView.invisibles?.eol
         expect(eol).toBeTruthy()
-        expect(editorView.renderedLines.find('.line').text()).toBe "#{space}a line with tabs#{tab} and spaces#{space}#{eol}"
+        expect(editorView.renderedLines.find('.line').text()).toBe "#{space}a line with tabs#{tab}and spaces#{space}#{eol}"
 
         atom.config.set("editor.showInvisibles", false)
-        expect(editorView.renderedLines.find('.line').text()).toBe " a line with tabs  and spaces "
+        expect(editorView.renderedLines.find('.line').text()).toBe " a line with tabs and spaces "
 
       it "displays newlines as their own token outside of the other tokens scope", ->
         editorView.setShowInvisibles(true)
@@ -1636,7 +1636,7 @@ describe "EditorView", ->
         editorView.attachToDom()
         atom.config.set("editor.showInvisibles", true)
         atom.config.set("editor.invisibles", eol: ";", space: "_", tab: "tab")
-        expect(editorView.find(".line:first").text()).toBe "_tab _;"
+        expect(editorView.find(".line:first").text()).toBe "_tab_;"
 
       it "displays trailing carriage return using a visible non-empty value", ->
         editor.setText "a line that ends with a carriage return\r\n"
@@ -2082,7 +2082,7 @@ describe "EditorView", ->
         tab = miniEditor.invisibles?.tab
         expect(tab).toBeTruthy()
         miniEditor.getEditor().setText(" a line with tabs\tand spaces ")
-        expect(miniEditor.renderedLines.find('.line').text()).toBe "#{space}a line with tabs#{tab} and spaces#{space}"
+        expect(miniEditor.renderedLines.find('.line').text()).toBe "#{space}a line with tabs#{tab}and spaces#{space}"
 
       it "doesn't show the indent guide", ->
         atom.config.set "editor.showIndentGuide", true

spec/project-spec.coffee

@@ -205,6 +205,17 @@ describe "Project", ->
       fs.writeFileSync(filePath, sampleContent)
       fs.writeFileSync(commentFilePath, sampleCommentContent)
 
+    describe "when a file doesn't exist", ->
+      it "calls back with an error", ->
+        errors = []
+        waitsForPromise ->
+          atom.project.replace /items/gi, 'items', ['/not-a-file.js'], (result, error) ->
+            errors.push(error)
+
+        runs ->
+          expect(errors).toHaveLength 1
+          expect(errors[0].path).toBe '/not-a-file.js'
+
     describe "when called with unopened files", ->
       it "replaces properly", ->
         results = []

spec/spec-helper.coffee

@@ -15,6 +15,7 @@ Project = require '../src/project'
 Editor = require '../src/editor'
 EditorView = require '../src/editor-view'
 TokenizedBuffer = require '../src/tokenized-buffer'
+EditorComponent = require '../src/editor-component'
 pathwatcher = require 'pathwatcher'
 clipboard = require 'clipboard'
 
@@ -33,7 +34,12 @@ $(window).on 'unload', ->
 $('html,body').css('overflow', 'auto')
 
 jasmine.getEnv().addEqualityTester(_.isEqual) # Use underscore's definition of equality for toEqual assertions
-jasmine.getEnv().defaultTimeoutInterval = 5000
+
+if process.platform is 'win32' and process.env.JANKY_SHA1
+  # Use longer timeout on Windows CI
+  jasmine.getEnv().defaultTimeoutInterval = 30000
+else
+  jasmine.getEnv().defaultTimeoutInterval = 5000
 
 specPackageName = null
 specPackagePath = null
@@ -95,6 +101,8 @@ beforeEach ->
 
   # make editor display updates synchronous
   spyOn(EditorView.prototype, 'requestDisplayUpdate').andCallFake -> @updateDisplay()
+  EditorComponent.performSyncUpdates = true
+
   spyOn(WorkspaceView.prototype, 'setTitle').andCallFake (@title) ->
   spyOn(window, "setTimeout").andCallFake window.fakeSetTimeout
   spyOn(window, "clearTimeout").andCallFake window.fakeClearTimeout

spec/tokenized-buffer-spec.coffee

@@ -335,16 +335,84 @@ describe "TokenizedBuffer", ->
         expect(screenLine0.text).toBe "# Econ 101#{tabAsSpaces}"
         { tokens } = screenLine0
 
-        expect(tokens.length).toBe 3
+        expect(tokens.length).toBe 4
         expect(tokens[0].value).toBe "#"
         expect(tokens[1].value).toBe " Econ 101"
         expect(tokens[2].value).toBe tabAsSpaces
         expect(tokens[2].scopes).toEqual tokens[1].scopes
         expect(tokens[2].isAtomic).toBeTruthy()
+        expect(tokens[3].value).toBe ""
 
         expect(tokenizedBuffer.lineForScreenRow(2).text).toBe "#{tabAsSpaces} buy()#{tabAsSpaces}while supply > demand"
 
-  describe "when the buffer contains surrogate pairs", ->
+      it "aligns the hard tabs to the correct tab stop column", ->
+        buffer.setText """
+          1\t2 \t3\t4
+          12\t3  \t4\t5
+          123\t4   \t5\t6
+        """
+
+        tokenizedBuffer.setTabLength(4)
+        fullyTokenize(tokenizedBuffer)
+
+        expect(tokenizedBuffer.lineForScreenRow(0).text).toBe "1   2   3   4"
+        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].screenDelta).toBe 3
+
+        expect(tokenizedBuffer.lineForScreenRow(1).text).toBe "12  3   4   5"
+        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].screenDelta).toBe 2
+
+        expect(tokenizedBuffer.lineForScreenRow(2).text).toBe "123 4       5   6"
+        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].screenDelta).toBe 1
+
+        tokenizedBuffer.setTabLength(3)
+        fullyTokenize(tokenizedBuffer)
+
+        expect(tokenizedBuffer.lineForScreenRow(0).text).toBe "1  2  3  4"
+        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].screenDelta).toBe 2
+
+        expect(tokenizedBuffer.lineForScreenRow(1).text).toBe "12 3     4  5"
+        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].screenDelta).toBe 1
+
+        expect(tokenizedBuffer.lineForScreenRow(2).text).toBe "123   4     5  6"
+        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].screenDelta).toBe 3
+
+        tokenizedBuffer.setTabLength(2)
+        fullyTokenize(tokenizedBuffer)
+
+        expect(tokenizedBuffer.lineForScreenRow(0).text).toBe "1 2   3 4"
+        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].screenDelta).toBe 1
+
+        expect(tokenizedBuffer.lineForScreenRow(1).text).toBe "12  3   4 5"
+        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].screenDelta).toBe 2
+
+        expect(tokenizedBuffer.lineForScreenRow(2).text).toBe "123 4     5 6"
+        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].screenDelta).toBe 1
+
+        tokenizedBuffer.setTabLength(1)
+        fullyTokenize(tokenizedBuffer)
+
+        expect(tokenizedBuffer.lineForScreenRow(0).text).toBe "1 2  3 4"
+        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].screenDelta).toBe 1
+
+        expect(tokenizedBuffer.lineForScreenRow(1).text).toBe "12 3   4 5"
+        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].screenDelta).toBe 1
+
+        expect(tokenizedBuffer.lineForScreenRow(2).text).toBe "123 4    5 6"
+        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].screenDelta).toBe 1
+
+  describe "when the buffer contains UTF-8 surrogate pairs", ->
     beforeEach ->
       waitsForPromise ->
         atom.packages.activatePackage('language-javascript')
@@ -362,7 +430,7 @@ describe "TokenizedBuffer", ->
       tokenizedBuffer.destroy()
       buffer.release()
 
-    it "renders each surrogate pair as its own atomic token", ->
+    it "renders each UTF-8 surrogate pair as its own atomic token", ->
       screenLine0 = tokenizedBuffer.lineForScreenRow(0)
       expect(screenLine0.text).toBe "'abc\uD835\uDF97def'"
       { tokens } = screenLine0
@@ -379,11 +447,12 @@ describe "TokenizedBuffer", ->
       expect(screenLine1.text).toBe "//\uD835\uDF97xyz"
       { tokens } = screenLine1
 
-      expect(tokens.length).toBe 3
+      expect(tokens.length).toBe 4
       expect(tokens[0].value).toBe '//'
       expect(tokens[1].value).toBe '\uD835\uDF97'
       expect(tokens[1].value).toBeTruthy()
       expect(tokens[2].value).toBe 'xyz'
+      expect(tokens[3].value).toBe ''
 
   describe "when the grammar is tokenized", ->
     it "emits the `tokenized` event", ->
@@ -588,3 +657,65 @@ describe "TokenizedBuffer", ->
 
         buffer.setText('\n\n\n')
         expect(tokenizedBuffer.lineForScreenRow(1).indentLevel).toBe 0
+
+    describe "when the changed lines are surrounded by whitespace-only lines", ->
+      it "updates the indentLevel of empty lines that precede the change", ->
+        expect(tokenizedBuffer.lineForScreenRow(12).indentLevel).toBe 0
+
+        buffer.insert([12, 0], '\n')
+        buffer.insert([13, 0], '  ')
+        expect(tokenizedBuffer.lineForScreenRow(12).indentLevel).toBe 1
+
+      it "updates empty line indent guides when the empty line is the last line", ->
+        buffer.insert([12, 2], '\n')
+
+        # The newline and he tab need to be in two different operations to surface the bug
+        buffer.insert([12, 0], '  ')
+        expect(tokenizedBuffer.lineForScreenRow(13).indentLevel).toBe 1
+
+        buffer.insert([12, 0], '  ')
+        expect(tokenizedBuffer.lineForScreenRow(13).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(14)).not.toBeDefined()
+
+      it "updates the indentLevel of empty lines surrounding a change that inserts lines", ->
+        # create some new lines
+        buffer.insert([7, 0], '\n\n')
+        buffer.insert([5, 0], '\n\n')
+
+        expect(tokenizedBuffer.lineForScreenRow(5).indentLevel).toBe 3
+        expect(tokenizedBuffer.lineForScreenRow(6).indentLevel).toBe 3
+        expect(tokenizedBuffer.lineForScreenRow(9).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(10).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(11).indentLevel).toBe 2
+
+        tokenizedBuffer.on "changed", changeHandler = jasmine.createSpy('changeHandler')
+
+        buffer.setTextInRange([[7, 0], [8, 65]], '        one\n        two\n        three\n        four')
+
+        delete changeHandler.argsForCall[0][0].bufferChange
+        expect(changeHandler).toHaveBeenCalledWith(start: 5, end: 8, delta: 2)
+
+        expect(tokenizedBuffer.lineForScreenRow(5).indentLevel).toBe 4
+        expect(tokenizedBuffer.lineForScreenRow(6).indentLevel).toBe 4
+        expect(tokenizedBuffer.lineForScreenRow(11).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(12).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(13).indentLevel).toBe 2
+
+      it "updates the indentLevel of empty lines surrounding a change that removes lines", ->
+        # create some new lines
+        buffer.insert([7, 0], '\n\n')
+        buffer.insert([5, 0], '\n\n')
+
+        tokenizedBuffer.on "changed", changeHandler = jasmine.createSpy('changeHandler')
+
+        buffer.setTextInRange([[7, 0], [8, 65]], '    ok')
+
+        delete changeHandler.argsForCall[0][0].bufferChange
+        expect(changeHandler).toHaveBeenCalledWith(start: 5, end: 8, delta: -1)
+
+        expect(tokenizedBuffer.lineForScreenRow(5).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(6).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(7).indentLevel).toBe 2 # new text
+        expect(tokenizedBuffer.lineForScreenRow(8).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(9).indentLevel).toBe 2
+        expect(tokenizedBuffer.lineForScreenRow(10).indentLevel).toBe 2 # }

spec/tokenized-line-spec.coffee

@@ -4,6 +4,20 @@ describe "TokenizedLine", ->
   beforeEach ->
     waitsForPromise -> atom.packages.activatePackage('language-coffee-script')
 
+  describe "::isOnlyWhitespace()", ->
+    beforeEach ->
+      waitsForPromise ->
+        atom.project.open('coffee.coffee').then (o) -> editor = o
+
+    it "returns true when the line is only whitespace", ->
+      expect(editor.lineForScreenRow(3).isOnlyWhitespace()).toBe true
+      expect(editor.lineForScreenRow(7).isOnlyWhitespace()).toBe true
+      expect(editor.lineForScreenRow(23).isOnlyWhitespace()).toBe true
+
+    it "returns false when the line is not only whitespace", ->
+      expect(editor.lineForScreenRow(0).isOnlyWhitespace()).toBe false
+      expect(editor.lineForScreenRow(2).isOnlyWhitespace()).toBe false
+
   describe "::getScopeTree()", ->
     it "returns a tree whose inner nodes are scopes and whose leaf nodes are tokens in those scopes", ->
       [tokens, tokenIndex] = []

spec/workspace-spec.coffee

@@ -309,3 +309,28 @@ describe "Workspace", ->
         expect(handler.callCount).toBe 1
         editorCopy = editor.copy()
         expect(handler.callCount).toBe 2
+
+  it "stores the active grammars used by all the open editors", ->
+    waitsForPromise ->
+      atom.packages.activatePackage('language-javascript')
+
+    waitsForPromise ->
+      atom.packages.activatePackage('language-coffee-script')
+
+    waitsForPromise ->
+      atom.workspace.open('sample.coffee')
+
+    runs ->
+      atom.workspace.getActiveEditor().setText('i = /test/;')
+
+      state = atom.workspace.serialize()
+      expect(state.packagesWithActiveGrammars).toEqual ['language-coffee-script', 'language-javascript']
+
+      jsPackage = atom.packages.getLoadedPackage('language-javascript')
+      coffeePackage = atom.packages.getLoadedPackage('language-coffee-script')
+      spyOn(jsPackage, 'loadGrammarsSync')
+      spyOn(coffeePackage, 'loadGrammarsSync')
+
+      workspace2 = Workspace.deserialize(state)
+      expect(jsPackage.loadGrammarsSync.callCount).toBe 1
+      expect(coffeePackage.loadGrammarsSync.callCount).toBe 1

spec/workspace-view-spec.coffee

@@ -196,14 +196,14 @@ describe "WorkspaceView", ->
       atom.workspaceView.height(200)
       atom.workspaceView.attachToDom()
       rightEditorView = atom.workspaceView.getActiveView()
-      rightEditorView.getEditor().setText(" \t ")
+      rightEditorView.getEditor().setText("\t  ")
       leftEditorView = rightEditorView.splitLeft()
       expect(rightEditorView.find(".line:first").text()).toBe "    "
       expect(leftEditorView.find(".line:first").text()).toBe "    "
 
       {invisibles} = rightEditorView.component.state
       {space, tab, eol} = invisibles
-      withInvisiblesShowing = "#{space}#{tab} #{space}#{eol}"
+      withInvisiblesShowing = "#{tab} #{space}#{space}#{eol}"
 
       atom.workspaceView.trigger "window:toggle-invisibles"
       expect(rightEditorView.find(".line:first").text()).toBe withInvisiblesShowing

src/atom.coffee

@@ -258,13 +258,20 @@ class Atom extends Model
 
   deserializeProject: ->
     Project = require './project'
+
+    startTime = Date.now()
     @project ?= @deserializers.deserialize(@state.project) ? new Project(path: @getLoadSettings().initialPath)
+    @deserializeTimings.project = Date.now() - startTime
 
   deserializeWorkspaceView: ->
     Workspace = require './workspace'
     WorkspaceView = require './workspace-view'
+
+    startTime = Date.now()
     @workspace = Workspace.deserialize(@state.workspace) ? new Workspace
     @workspaceView = new WorkspaceView(@workspace)
+    @deserializeTimings.workspace = Date.now() - startTime
+
     @keymaps.defaultTarget = @workspaceView[0]
     $(@workspaceViewParentSelector).append(@workspaceView)
 
@@ -273,6 +280,7 @@ class Atom extends Model
     delete @state.packageStates
 
   deserializeEditorWindow: ->
+    @deserializeTimings = {}
     @deserializePackageStates()
     @deserializeProject()
     @deserializeWorkspaceView()

src/context-menu-manager.coffee

@@ -60,7 +60,8 @@ class ContextMenuManager
   #              editor is in dev mode.
   addBySelector: (selector, definition, {devMode}={}) ->
     definitions = if devMode then @devModeDefinitions else @definitions
-    (definitions[selector] ?= []).push(definition)
+    unless _.findWhere(definitions[selector], definition)
+      (definitions[selector] ?= []).push(definition)
 
   # Returns definitions which match the element and devMode.
   definitionsForElement: (element, {devMode}={}) ->

src/cursor-component.coffee

@@ -1,16 +1,29 @@
 React = require 'react-atom-fork'
 {div} = require 'reactionary-atom-fork'
+{isEqualForProperties} = require 'underscore-plus'
 
 module.exports =
 CursorComponent = React.createClass
   displayName: 'CursorComponent'
 
   render: ->
-    {editor, screenRange, scrollTop, scrollLeft, defaultCharWidth} = @props
-    {top, left, height, width} = editor.pixelRectForScreenRange(screenRange)
-    top -= scrollTop
-    left -= scrollLeft
+    {pixelRect, defaultCharWidth} = @props
+    {height, width} = pixelRect
     width = defaultCharWidth if width is 0
-    WebkitTransform = "translate3d(#{left}px, #{top}px, 0px)"
+    WebkitTransform = @getTransform()
 
     div className: 'cursor', style: {height, width, WebkitTransform}
+
+  getTransform: ->
+    {pixelRect, scrollTop, scrollLeft, useHardwareAcceleration} = @props
+    {top, left} = pixelRect
+    top -= scrollTop
+    left -= scrollLeft
+
+    if useHardwareAcceleration
+      "translate3d(#{left}px, #{top}px, 0px)"
+    else
+      "translate(#{left}px, #{top}px)"
+
+  shouldComponentUpdate: (newProps) ->
+    not isEqualForProperties(newProps, @props, 'pixelRect', 'scrollTop', 'scrollLeft', 'defaultCharWidth')

src/cursor.coffee

@@ -29,9 +29,6 @@ class Cursor extends Model
       # Supports old editor view
       @needsAutoscroll ?= @isLastCursor() and !textChanged
 
-      # Supports react editor view
-      @autoscroll() if @needsAutoscroll and @editor.manageScrollPosition
-
       @goalColumn = null
 
       movedEvent =
@@ -55,8 +52,10 @@ class Cursor extends Model
   changePosition: (options, fn) ->
     @clearSelection()
     @needsAutoscroll = options.autoscroll ? @isLastCursor()
-    unless fn()
-      @emit 'autoscrolled' if @needsAutoscroll
+    fn()
+    if @needsAutoscroll
+      @emit 'autoscrolled' # Support legacy editor
+      @autoscroll() if @needsAutoscroll and @editor.manageScrollPosition # Support react editor view
 
   getPixelRect: ->
     @editor.pixelRectForScreenRange(@getScreenRange())

src/cursors-component.coffee

@@ -12,7 +12,7 @@ CursorsComponent = React.createClass
   cursorBlinkIntervalHandle: null
 
   render: ->
-    {editor, cursorScreenRanges, scrollTop, scrollLeft, defaultCharWidth} = @props
+    {cursorPixelRects, scrollTop, scrollLeft, defaultCharWidth, useHardwareAcceleration} = @props
     {blinkOff} = @state
 
     className = 'cursors'
@@ -20,8 +20,8 @@ CursorsComponent = React.createClass
 
     div {className},
       if @isMounted()
-        for key, screenRange of cursorScreenRanges
-          CursorComponent({key, editor, screenRange, scrollTop, scrollLeft, defaultCharWidth})
+        for key, pixelRect of cursorPixelRects
+          CursorComponent({key, pixelRect, scrollTop, scrollLeft, defaultCharWidth, useHardwareAcceleration})
 
   getInitialState: ->
     blinkOff: false
@@ -34,10 +34,14 @@ CursorsComponent = React.createClass
 
   shouldComponentUpdate: (newProps, newState) ->
     not newState.blinkOff is @state.blinkOff or
-      not isEqualForProperties(newProps, @props, 'cursorScreenRanges', 'scrollTop', 'scrollLeft', 'lineHeightInPixels', 'defaultCharWidth')
+      not isEqualForProperties(newProps, @props, 'cursorPixelRects', 'scrollTop', 'scrollLeft', 'defaultCharWidth', 'useHardwareAcceleration')
 
   componentWillUpdate: (newProps) ->
-    @pauseCursorBlinking() if @props.cursorScreenRanges and not isEqual(newProps.cursorScreenRanges, @props.cursorScreenRanges)
+    cursorsMoved = @props.cursorPixelRects? and
+      isEqualForProperties(newProps, @props, 'defaultCharWidth', 'scopedCharacterWidthsChangeCount') and
+      not isEqual(newProps.cursorPixelRects, @props.cursorPixelRects)
+
+    @pauseCursorBlinking() if cursorsMoved
 
   startBlinkingCursors: ->
     @toggleCursorBlinkHandle = setInterval(@toggleCursorBlink, @props.cursorBlinkPeriod / 2) if @isMounted()

src/display-buffer.coffee

@@ -29,11 +29,13 @@ class DisplayBuffer extends Model
     width: null
     scrollTop: 0
     scrollLeft: 0
+    scrollWidth: 0
 
   verticalScrollMargin: 2
   horizontalScrollMargin: 6
   horizontalScrollbarHeight: 15
   verticalScrollbarWidth: 15
+  scopedCharacterWidthsChangeCount: 0
 
   constructor: ({tabLength, @editorWidthInChars, @tokenizedBuffer, buffer}={}) ->
     super
@@ -43,8 +45,9 @@ class DisplayBuffer extends Model
     @charWidthsByScope = {}
     @markers = {}
     @foldsByMarkerId = {}
-    @decorations = {}
-    @decorationMarkerSubscriptions = {}
+    @decorationsByMarkerId = {}
+    @decorationMarkerChangedSubscriptions = {}
+    @decorationMarkerDestroyedSubscriptions = {}
     @updateAllScreenLines()
     @createFoldForMarker(marker) for marker in @buffer.findMarkers(@getFoldMarkerAttributes())
     @subscribe @tokenizedBuffer, 'grammar-changed', (grammar) => @emit 'grammar-changed', grammar
@@ -179,9 +182,12 @@ class DisplayBuffer extends Model
   getScrollTop: -> @scrollTop
   setScrollTop: (scrollTop) ->
     if @manageScrollPosition
-      @scrollTop = Math.max(0, Math.min(@getScrollHeight() - @getClientHeight(), scrollTop))
+      @scrollTop = Math.round(Math.max(0, Math.min(@getMaxScrollTop(), scrollTop)))
     else
-      @scrollTop = scrollTop
+      @scrollTop = Math.round(scrollTop)
+
+  getMaxScrollTop: ->
+    @getScrollHeight() - @getClientHeight()
 
   getScrollBottom: -> @scrollTop + @height
   setScrollBottom: (scrollBottom) ->
@@ -191,10 +197,10 @@ class DisplayBuffer extends Model
   getScrollLeft: -> @scrollLeft
   setScrollLeft: (scrollLeft) ->
     if @manageScrollPosition
-      @scrollLeft = Math.max(0, Math.min(@getScrollWidth() - @getClientWidth(), scrollLeft))
+      @scrollLeft = Math.round(Math.max(0, Math.min(@getScrollWidth() - @getClientWidth(), scrollLeft)))
       @scrollLeft
     else
-      @scrollLeft = scrollLeft
+      @scrollLeft = Math.round(scrollLeft)
 
   getScrollRight: -> @scrollLeft + @width
   setScrollRight: (scrollRight) ->
@@ -205,7 +211,11 @@ class DisplayBuffer extends Model
   setLineHeightInPixels: (@lineHeightInPixels) -> @lineHeightInPixels
 
   getDefaultCharWidth: -> @defaultCharWidth
-  setDefaultCharWidth: (@defaultCharWidth) -> @defaultCharWidth
+  setDefaultCharWidth: (defaultCharWidth) ->
+    if defaultCharWidth isnt @defaultCharWidth
+      @defaultCharWidth = defaultCharWidth
+      @computeScrollWidth()
+    defaultCharWidth
 
   getCursorWidth: -> 1
 
@@ -220,11 +230,21 @@ class DisplayBuffer extends Model
     scope.charWidths ?= {}
     scope.charWidths
 
+  batchCharacterMeasurement: (fn) ->
+    oldChangeCount = @scopedCharacterWidthsChangeCount
+    @batchingCharacterMeasurement = true
+    fn()
+    @batchingCharacterMeasurement = false
+    @characterWidthsChanged() if oldChangeCount isnt @scopedCharacterWidthsChangeCount
+
   setScopedCharWidth: (scopeNames, char, width) ->
     @getScopedCharWidths(scopeNames)[char] = width
+    @scopedCharacterWidthsChangeCount++
+    @characterWidthsChanged() unless @batchingCharacterMeasurement
 
-  setScopedCharWidths: (scopeNames, charWidths) ->
-    _.extend(@getScopedCharWidths(scopeNames), charWidths)
+  characterWidthsChanged: ->
+    @computeScrollWidth()
+    @emit 'character-widths-changed', @scopedCharacterWidthsChangeCount
 
   clearScopedCharWidths: ->
     @charWidthsByScope = {}
@@ -235,7 +255,7 @@ class DisplayBuffer extends Model
     @getLineCount() * @getLineHeightInPixels()
 
   getScrollWidth: ->
-    (@getMaxLineLength() * @getDefaultCharWidth()) + @getCursorWidth()
+    @scrollWidth
 
   getVisibleRowRange: ->
     return [0, 0] unless @getLineHeightInPixels() > 0
@@ -254,15 +274,23 @@ class DisplayBuffer extends Model
     {start, end} = selection.getScreenRange()
     @intersectsVisibleRowRange(start.row, end.row + 1)
 
-  scrollToScreenRange: (screenRange) ->
+  scrollToScreenRange: (screenRange, options) ->
     verticalScrollMarginInPixels = @getVerticalScrollMargin() * @getLineHeightInPixels()
     horizontalScrollMarginInPixels = @getHorizontalScrollMargin() * @getDefaultCharWidth()
 
     {top, left, height, width} = @pixelRectForScreenRange(screenRange)
     bottom = top + height
     right = left + width
-    desiredScrollTop = top - verticalScrollMarginInPixels
-    desiredScrollBottom = bottom + verticalScrollMarginInPixels
+
+    if options?.center
+      desiredScrollCenter = top + height / 2
+      unless @getScrollTop() < desiredScrollCenter < @getScrollBottom()
+        desiredScrollTop =  desiredScrollCenter - @getHeight() / 2
+        desiredScrollBottom =  desiredScrollCenter + @getHeight() / 2
+    else
+      desiredScrollTop = top - verticalScrollMarginInPixels
+      desiredScrollBottom = bottom + verticalScrollMarginInPixels
+
     desiredScrollLeft = left - horizontalScrollMarginInPixels
     desiredScrollRight = right + horizontalScrollMarginInPixels
 
@@ -276,11 +304,11 @@ class DisplayBuffer extends Model
     else if desiredScrollRight > @getScrollRight()
       @setScrollRight(desiredScrollRight)
 
-  scrollToScreenPosition: (screenPosition) ->
-    @scrollToScreenRange(new Range(screenPosition, screenPosition))
+  scrollToScreenPosition: (screenPosition, options) ->
+    @scrollToScreenRange(new Range(screenPosition, screenPosition), options)
 
-  scrollToBufferPosition: (bufferPosition) ->
-    @scrollToScreenPosition(@screenPositionForBufferPosition(bufferPosition))
+  scrollToBufferPosition: (bufferPosition, options) ->
+    @scrollToScreenPosition(@screenPositionForBufferPosition(bufferPosition), options)
 
   pixelRectForScreenRange: (screenRange) ->
     if screenRange.end.row > screenRange.start.row
@@ -718,51 +746,19 @@ class DisplayBuffer extends Model
   rangeForAllLines: ->
     new Range([0, 0], @clipScreenPosition([Infinity, Infinity]))
 
-  decorationsForBufferRow: (bufferRow, decorationType) ->
-    decorations = @decorations[bufferRow] ? []
-    decorations = (dec for dec in decorations when not dec.type? or dec.type is decorationType) if decorationType?
-    decorations
+  decorationsForScreenRowRange: (startScreenRow, endScreenRow) ->
+    decorationsByMarkerId = {}
 
-  decorationsForBufferRowRange: (startBufferRow, endBufferRow, decorationType) ->
-    decorations = {}
-    for bufferRow in [startBufferRow..endBufferRow]
-      decorations[bufferRow] = @decorationsForBufferRow(bufferRow, decorationType)
-    decorations
+    for marker in @findMarkers(intersectsScreenRowRange: [startScreenRow, endScreenRow])
+      if decorations = @decorationsByMarkerId[marker.id]
+        decorationsByMarkerId[marker.id] = decorations
+    decorationsByMarkerId
 
-  addDecorationToBufferRow: (bufferRow, decoration) ->
-    @decorations[bufferRow] ?= []
-    for current in @decorations[bufferRow]
-      return if _.isEqual(current, decoration)
-    @decorations[bufferRow].push(decoration)
-    @emit 'decoration-changed', {bufferRow, decoration, action: 'add'}
-
-  removeDecorationFromBufferRow: (bufferRow, decorationPattern) ->
-    return unless decorations = @decorations[bufferRow]
-
-    removed = []
-    i = decorations.length - 1
-    while i >= 0
-      if @decorationMatchesPattern(decorations[i], decorationPattern)
-        removed.push decorations[i]
-        decorations.splice(i, 1)
-      i--
-
-    delete @decorations[bufferRow] unless @decorations[bufferRow]?
-
-    for decoration in removed
-      @emit 'decoration-changed', {bufferRow, decoration, action: 'remove'}
-
-    removed
-
-  addDecorationToBufferRowRange: (startBufferRow, endBufferRow, decoration) ->
-    for bufferRow in [startBufferRow..endBufferRow]
-      @addDecorationToBufferRow(bufferRow, decoration)
-    return
-
-  removeDecorationFromBufferRowRange: (startBufferRow, endBufferRow, decoration) ->
-    for bufferRow in [startBufferRow..endBufferRow]
-      @removeDecorationFromBufferRow(bufferRow, decoration)
-    return
+  decorationMatchesType: (decoration, type) ->
+    if _.isArray(decoration.type)
+      type in decoration.type
+    else
+      type is decoration.type
 
   decorationMatchesPattern: (decoration, decorationPattern) ->
     return false unless decoration? and decorationPattern?
@@ -771,43 +767,56 @@ class DisplayBuffer extends Model
     true
 
   addDecorationForMarker: (marker, decoration) ->
-    startRow = marker.getStartBufferPosition().row
-    endRow = marker.getEndBufferPosition().row
-    @addDecorationToBufferRowRange(startRow, endRow, decoration)
+    unless marker?
+      console.warn 'A null marker cannot be decorated'
+      return
 
-    changedSubscription = @subscribe marker, 'changed', (e) =>
-      oldStartRow = e.oldHeadBufferPosition.row
-      oldEndRow = e.oldTailBufferPosition.row
-      newStartRow = e.newHeadBufferPosition.row
-      newEndRow = e.newTailBufferPosition.row
+    marker = @getMarker(marker.id)
 
-      # swap so head is always <= than tail
-      [oldEndRow, oldStartRow] = [oldStartRow, oldEndRow] if oldStartRow > oldEndRow
-      [newEndRow, newStartRow] = [newStartRow, newEndRow] if newStartRow > newEndRow
+    @decorationMarkerDestroyedSubscriptions[marker.id] ?= @subscribe marker, 'destroyed', =>
+      @removeAllDecorationsForMarker(marker)
 
-      @removeDecorationFromBufferRowRange(oldStartRow, oldEndRow, decoration)
-      @addDecorationToBufferRowRange(newStartRow, newEndRow, decoration) if e.isValid
+    @decorationMarkerChangedSubscriptions[marker.id] ?= @subscribe marker, 'changed', (event) =>
+      decorations = @decorationsByMarkerId[marker.id]
 
-    destroyedSubscription = @subscribe marker, 'destroyed', (e) =>
-      @removeDecorationForMarker(marker, decoration)
+      # Why check existence? Markers may get destroyed or decorations removed
+      # in the change handler. Bookmarks does this.
+      if decorations?
+        for decoration in decorations
+          @emit 'decoration-changed', marker, decoration, event
 
-    @decorationMarkerSubscriptions[marker.id] ?= []
-    @decorationMarkerSubscriptions[marker.id].push {decoration, changedSubscription, destroyedSubscription}
+    @decorationsByMarkerId[marker.id] ?= []
+    @decorationsByMarkerId[marker.id].push(decoration)
+    @emit 'decoration-added', marker, decoration
 
   removeDecorationForMarker: (marker, decorationPattern) ->
-    return unless @decorationMarkerSubscriptions[marker.id]?
+    unless marker?
+      console.warn 'A decoration cannot be removed from a null marker'
+      return
 
-    startRow = marker.getStartBufferPosition().row
-    endRow = marker.getEndBufferPosition().row
-    @removeDecorationFromBufferRowRange(startRow, endRow, decorationPattern)
+    return unless decorations = @decorationsByMarkerId[marker.id]
 
-    for subscription in _.clone(@decorationMarkerSubscriptions[marker.id])
-      if @decorationMatchesPattern(subscription.decoration, decorationPattern)
-        subscription.changedSubscription.off()
-        subscription.destroyedSubscription.off()
-        @decorationMarkerSubscriptions[marker.id] = _.without(@decorationMarkerSubscriptions[marker.id], subscription)
+    for i in [decorations.length - 1..0]
+      decoration = decorations[i]
+      if @decorationMatchesPattern(decoration, decorationPattern)
+        decorations.splice(i, 1)
+        @emit 'decoration-removed', marker, decoration
 
-    return
+    @removedAllMarkerDecorations(marker) if decorations.length is 0
+
+  removeAllDecorationsForMarker: (marker) ->
+    decorations = @decorationsByMarkerId[marker.id].slice()
+    for decoration in decorations
+      @emit 'decoration-removed', marker, decoration
+    @removedAllMarkerDecorations(marker)
+
+  removedAllMarkerDecorations: (marker) ->
+    @decorationMarkerChangedSubscriptions[marker.id].off()
+    @decorationMarkerDestroyedSubscriptions[marker.id].off()
+
+    delete @decorationsByMarkerId[marker.id]
+    delete @decorationMarkerChangedSubscriptions[marker.id]
+    delete @decorationMarkerDestroyedSubscriptions[marker.id]
 
   # Retrieves a {DisplayBufferMarker} based on its id.
   #
@@ -912,13 +921,34 @@ class DisplayBuffer extends Model
           key = 'startRow'
         when 'endBufferRow'
           key = 'endRow'
+        when 'startScreenRow'
+          key = 'startRow'
+          value = @bufferRowForScreenRow(value)
+        when 'endScreenRow'
+          key = 'endRow'
+          value = @bufferRowForScreenRow(value)
+        when 'intersectsBufferRowRange'
+          key = 'intersectsRowRange'
+        when 'intersectsScreenRowRange'
+          key = 'intersectsRowRange'
+          [startRow, endRow] = value
+          value = [@bufferRowForScreenRow(startRow), @bufferRowForScreenRow(endRow)]
         when 'containsBufferRange'
           key = 'containsRange'
         when 'containsBufferPosition'
           key = 'containsPosition'
         when 'containedInBufferRange'
           key = 'containedInRange'
+        when 'containedInScreenRange'
+          key = 'containedInRange'
+          value = @bufferRangeForScreenRange(value)
+        when 'intersectsBufferRange'
+          key = 'intersectsRange'
+        when 'intersectsScreenRange'
+          key = 'intersectsRange'
+          value = @bufferRangeForScreenRange(value)
       bufferMarkerParams[key] = value
+
     bufferMarkerParams
 
   findFoldMarker: (attributes) ->
@@ -954,6 +984,7 @@ class DisplayBuffer extends Model
   handleTokenizedBufferChange: (tokenizedBufferChange) =>
     {start, end, delta, bufferChange} = tokenizedBufferChange
     @updateScreenLines(start, end + 1, delta, delayChangeEvent: bufferChange?)
+    @setScrollTop(Math.min(@getScrollTop(), @getMaxScrollTop())) if @manageScrollPosition and delta < 0
 
   updateScreenLines: (startBufferRow, endBufferRow, bufferDelta=0, options={}) ->
     startBufferRow = @rowMap.bufferRowRangeForBufferRow(startBufferRow)[0]
@@ -1027,6 +1058,8 @@ class DisplayBuffer extends Model
     {screenLines, regions}
 
   findMaxLineLength: (startScreenRow, endScreenRow, newScreenLines) ->
+    oldMaxLineLength = @maxLineLength
+
     if startScreenRow <= @longestScreenRow < endScreenRow
       @longestScreenRow = 0
       @maxLineLength = 0
@@ -1042,6 +1075,11 @@ class DisplayBuffer extends Model
         @longestScreenRow = maxLengthCandidatesStartRow + screenRow
         @maxLineLength = length
 
+    @computeScrollWidth() if oldMaxLineLength isnt @maxLineLength
+
+  computeScrollWidth: ->
+    @scrollWidth = @pixelPositionForScreenPosition([@longestScreenRow, @maxLineLength]).left + 1
+
   handleBufferMarkersUpdated: =>
     if event = @pendingChangeEvent
       @pendingChangeEvent = null
@@ -1052,8 +1090,7 @@ class DisplayBuffer extends Model
     @emit 'marker-created', @getMarker(marker.id)
 
   createFoldForMarker: (marker) ->
-    bufferMarker = new DisplayBufferMarker({bufferMarker: marker, displayBuffer: this})
-    @addDecorationForMarker(bufferMarker, type: 'gutter', class: 'folded')
+    @addDecorationForMarker(marker, type: 'gutter', class: 'folded')
     new Fold(this, marker)
 
   foldForMarker: (marker) ->

src/editor-component.coffee

@@ -12,16 +12,22 @@ ScrollbarComponent = require './scrollbar-component'
 ScrollbarCornerComponent = require './scrollbar-corner-component'
 SubscriberMixin = require './subscriber-mixin'
 
+DummyHighlightDecoration = {id: 'dummy', startPixelPosition: {top: 0, left: 0}, endPixelPosition: {top: 0, left: 0}, decorations: [{class: 'dummy'}]}
+
 module.exports =
 EditorComponent = React.createClass
   displayName: 'EditorComponent'
   mixins: [SubscriberMixin]
 
+  statics:
+    performSyncUpdates: false
+
   pendingScrollTop: null
   pendingScrollLeft: null
   selectOnMouseMove: false
-  batchingUpdates: false
   updateRequested: false
+  updatesPaused: false
+  updateRequestedWhilePaused: false
   cursorsMoved: false
   selectionChanged: false
   selectionAdded: false
@@ -36,10 +42,14 @@ EditorComponent = React.createClass
   scrollSensitivity: 0.4
   scrollViewMeasurementRequested: false
   measureLineHeightAndDefaultCharWidthWhenShown: false
+  remeasureCharacterWidthsWhenShown: false
   inputEnabled: true
+  scrollViewMeasurementInterval: 100
+  scopedCharacterWidthsChangeCount: null
+  scrollViewMeasurementPaused: false
 
   render: ->
-    {focused, fontSize, lineHeight, fontFamily, showIndentGuide, showInvisibles, visible} = @state
+    {focused, fontSize, lineHeight, fontFamily, showIndentGuide, showInvisibles, showLineNumbers, visible} = @state
     {editor, cursorBlinkPeriod, cursorBlinkResumeDelay} = @props
     maxLineNumberDigits = editor.getLineCount().toString().length
     invisibles = if showInvisibles then @state.invisibles else {}
@@ -48,9 +58,12 @@ EditorComponent = React.createClass
     if @isMounted()
       renderedRowRange = @getRenderedRowRange()
       [renderedStartRow, renderedEndRow] = renderedRowRange
-      cursorScreenRanges = @getCursorScreenRanges(renderedRowRange)
-      selectionScreenRanges = @getSelectionScreenRanges(renderedRowRange)
-      decorations = @getGutterDecorations(renderedRowRange)
+      cursorPixelRects = @getCursorPixelRects(renderedRowRange)
+
+      decorations = editor.decorationsForScreenRowRange(renderedStartRow, renderedEndRow)
+      highlightDecorations = @getHighlightDecorations(decorations)
+      lineDecorations = @getLineDecorations(decorations)
+
       scrollHeight = editor.getScrollHeight()
       scrollWidth = editor.getScrollWidth()
       scrollTop = editor.getScrollTop()
@@ -58,12 +71,13 @@ EditorComponent = React.createClass
       lineHeightInPixels = editor.getLineHeightInPixels()
       defaultCharWidth = editor.getDefaultCharWidth()
       scrollViewHeight = editor.getHeight()
+      lineWidth = Math.max(scrollWidth, editor.getWidth())
       horizontalScrollbarHeight = editor.getHorizontalScrollbarHeight()
       verticalScrollbarWidth = editor.getVerticalScrollbarWidth()
       verticallyScrollable = editor.verticallyScrollable()
       horizontallyScrollable = editor.horizontallyScrollable()
       hiddenInputStyle = @getHiddenInputPosition()
-      hiddenInputStyle.WebkitTransform = 'translateZ(0)'
+      hiddenInputStyle.WebkitTransform = 'translateZ(0)' if @useHardwareAcceleration
       if @mouseWheelScreenRow? and not (renderedStartRow <= @mouseWheelScreenRow < renderedEndRow)
         mouseWheelScreenRow = @mouseWheelScreenRow
 
@@ -72,11 +86,12 @@ EditorComponent = React.createClass
     className += ' has-selection' if hasSelection
 
     div className: className, style: {fontSize, lineHeight, fontFamily}, tabIndex: -1,
-      GutterComponent {
-        ref: 'gutter', editor, renderedRowRange, maxLineNumberDigits, scrollTop,
-        scrollHeight, lineHeightInPixels, @pendingChanges, mouseWheelScreenRow,
-        decorations
-      }
+      if showLineNumbers
+        GutterComponent {
+          ref: 'gutter', onMouseDown: @onGutterMouseDown, onWidthChanged: @onGutterWidthChanged,
+          lineDecorations, defaultCharWidth, editor, renderedRowRange, maxLineNumberDigits, scrollViewHeight,
+          scrollTop, scrollHeight, lineHeightInPixels, @pendingChanges, mouseWheelScreenRow, @useHardwareAcceleration
+        }
 
       div ref: 'scrollView', className: 'scroll-view', onMouseDown: @onMouseDown,
         InputComponent
@@ -87,14 +102,15 @@ EditorComponent = React.createClass
           onBlur: @onInputBlurred
 
         CursorsComponent {
-          editor, scrollTop, scrollLeft, cursorScreenRanges, cursorBlinkPeriod, cursorBlinkResumeDelay,
-          lineHeightInPixels, defaultCharWidth
+          scrollTop, scrollLeft, cursorPixelRects, cursorBlinkPeriod, cursorBlinkResumeDelay,
+          lineHeightInPixels, defaultCharWidth, @scopedCharacterWidthsChangeCount, @useHardwareAcceleration
         }
         LinesComponent {
-          ref: 'lines', editor, lineHeightInPixels, defaultCharWidth,
-          showIndentGuide, renderedRowRange, @pendingChanges, scrollTop, scrollLeft, @scrollingVertically,
-          selectionScreenRanges, scrollHeight, scrollWidth, mouseWheelScreenRow, invisibles,
-          visible, scrollViewHeight
+          ref: 'lines',
+          editor, lineHeightInPixels, defaultCharWidth, lineDecorations, highlightDecorations,
+          showIndentGuide, renderedRowRange, @pendingChanges, scrollTop, scrollLeft,
+          @scrollingVertically, scrollHeight, scrollWidth, mouseWheelScreenRow, invisibles,
+          visible, scrollViewHeight, @scopedCharacterWidthsChangeCount, lineWidth, @useHardwareAcceleration
         }
 
       ScrollbarComponent
@@ -129,6 +145,10 @@ EditorComponent = React.createClass
         height: horizontalScrollbarHeight
         width: verticalScrollbarWidth
 
+  getPageRows: ->
+    {editor} = @props
+    Math.max(1, Math.ceil(editor.getHeight() / editor.getLineHeightInPixels()))
+
   getInitialState: ->
     visible: true
 
@@ -146,6 +166,8 @@ EditorComponent = React.createClass
   componentDidMount: ->
     {editor} = @props
 
+    @scrollViewMeasurementIntervalId = setInterval(@measureScrollView, @scrollViewMeasurementInterval)
+
     @observeEditor()
     @listenForDOMEvents()
     @listenForCommands()
@@ -155,33 +177,55 @@ EditorComponent = React.createClass
 
     editor.setVisible(true)
 
-    editor.batchUpdates =>
-      @measureLineHeightAndDefaultCharWidth()
-      @measureScrollView()
-      @measureScrollbars()
+    @measureLineHeightAndDefaultCharWidth()
+    @measureScrollView()
+    @measureScrollbars()
 
   componentWillUnmount: ->
     @unsubscribe()
-    window.removeEventListener('resize', @onWindowResize)
-
-  componentWillUpdate: ->
-    if @props.editor.isAlive()
-      @props.parentView.trigger 'cursor:moved' if @cursorsMoved
-      @props.parentView.trigger 'selection:changed' if @selectionChanged
+    clearInterval(@scrollViewMeasurementIntervalId)
+    @scrollViewMeasurementIntervalId = null
 
   componentDidUpdate: (prevProps, prevState) ->
+    cursorsMoved = @cursorsMoved
+    selectionChanged = @selectionChanged
     @pendingChanges.length = 0
+    @cursorsMoved = false
+    @selectionChanged = false
     @refreshingScrollbars = false
-    @updateParentViewFocusedClassIfNeeded(prevState)
+
+    if @props.editor.isAlive()
+      @updateParentViewFocusedClassIfNeeded(prevState)
+      @props.parentView.trigger 'cursor:moved' if cursorsMoved
+      @props.parentView.trigger 'selection:changed' if selectionChanged
+      @props.parentView.trigger 'editor:display-updated'
+
     @measureScrollbars() if @measuringScrollbars
     @measureLineHeightAndCharWidthsIfNeeded(prevState)
-    @props.parentView.trigger 'editor:display-updated'
+    @remeasureCharacterWidthsIfNeeded(prevState)
 
   requestUpdate: ->
-    if @batchingUpdates
-      @updateRequested = true
-    else
+    if @updatesPaused
+      @updateRequestedWhilePaused = true
+      return
+
+    if @performSyncUpdates ? EditorComponent.performSyncUpdates
       @forceUpdate()
+    else unless @updateRequested
+      @updateRequested = true
+      setImmediate =>
+        @updateRequested = false
+        @forceUpdate() if @isMounted()
+
+  requestAnimationFrame: (fn) ->
+    @updatesPaused = true
+    @pauseScrollViewMeasurement()
+    requestAnimationFrame =>
+      fn()
+      @updatesPaused = false
+      if @updateRequestedWhilePaused and @isMounted()
+        @updateRequestedWhilePaused = false
+        @forceUpdate()
 
   getRenderedRowRange: ->
     {editor, lineOverdrawMargin} = @props
@@ -215,43 +259,78 @@ EditorComponent = React.createClass
         cursorScreenRanges[cursor.id] = screenRange
     cursorScreenRanges
 
-  getSelectionScreenRanges: (renderedRowRange) ->
+  getCursorPixelRects: (renderedRowRange) ->
     {editor} = @props
     [renderedStartRow, renderedEndRow] = renderedRowRange
 
-    selectionScreenRanges = {}
-    for selection, index in editor.getSelections()
-      screenRange = selection.getScreenRange()
+    cursorPixelRects = {}
+    for selection in editor.getSelections() when selection.isEmpty()
+      {cursor} = selection
+      screenRange = cursor.getScreenRange()
+      if renderedStartRow <= screenRange.start.row < renderedEndRow
+        cursorPixelRects[cursor.id] = editor.pixelRectForScreenRange(screenRange)
+    cursorPixelRects
 
-      if not screenRange.isEmpty() and screenRange.intersectsRowRange(renderedStartRow, renderedEndRow)
-        selectionScreenRanges[selection.id] = screenRange
-
-      else if index is 0 # Rendering artifacts occur on the lines GPU layer if we remove the last selection
-        selectionScreenRanges[selection.id] = new Range(new Point(renderedStartRow, 0), new Point(renderedStartRow, 0))
-
-    selectionScreenRanges
-
-  getGutterDecorations:  (renderedRowRange) ->
+  getLineDecorations: (decorationsByMarkerId) ->
     {editor} = @props
-    [renderedStartRow, renderedEndRow] = renderedRowRange
+    decorationsByScreenRow = {}
+    for markerId, decorations of decorationsByMarkerId
+      marker = editor.getMarker(markerId)
+      screenRange = null
+      headScreenRow = null
+      if marker.isValid()
+        for decoration in decorations
+          if editor.decorationMatchesType(decoration, 'gutter') or editor.decorationMatchesType(decoration, 'line')
+            screenRange ?= marker.getScreenRange()
+            headScreenRow ?= marker.getHeadScreenPosition().row
+            startRow = screenRange.start.row
+            endRow = screenRange.end.row
+            endRow-- if not screenRange.isEmpty() and screenRange.end.column == 0
+            for screenRow in [startRow..endRow]
+              continue if decoration.onlyHead and screenRow isnt headScreenRow
+              if screenRange.isEmpty()
+                continue if decoration.onlyNonEmpty
+              else
+                continue if decoration.onlyEmpty
 
-    bufferRows = editor.bufferRowsForScreenRows(renderedStartRow, renderedEndRow - 1)
+              decorationsByScreenRow[screenRow] ?= []
+              decorationsByScreenRow[screenRow].push decoration
 
-    decorations = {}
-    for bufferRow in bufferRows
-      decorations[bufferRow] = editor.decorationsForBufferRow(bufferRow, 'gutter')
-      decorations[bufferRow].push {class: 'foldable'} if editor.isFoldableAtBufferRow(bufferRow)
-    decorations
+    decorationsByScreenRow
+
+  getHighlightDecorations: (decorationsByMarkerId) ->
+    {editor} = @props
+    filteredDecorations = {}
+    for markerId, decorations of decorationsByMarkerId
+      marker = editor.getMarker(markerId)
+      screenRange = marker.getScreenRange()
+      if marker.isValid() and not screenRange.isEmpty()
+        for decoration in decorations
+          if editor.decorationMatchesType(decoration, 'highlight')
+            filteredDecorations[markerId] ?=
+              id: markerId
+              startPixelPosition: editor.pixelPositionForScreenPosition(screenRange.start)
+              endPixelPosition: editor.pixelPositionForScreenPosition(screenRange.end)
+              decorations: []
+            filteredDecorations[markerId].decorations.push decoration
+
+    # At least in Chromium 31, removing the last highlight causes a rendering
+    # artifact where chunks of the lines disappear, so we always leave this
+    # dummy highlight in place to prevent that.
+    filteredDecorations['dummy'] = DummyHighlightDecoration
+
+    filteredDecorations
 
   observeEditor: ->
     {editor} = @props
-    @subscribe editor, 'batched-updates-started', @onBatchedUpdatesStarted
-    @subscribe editor, 'batched-updates-ended', @onBatchedUpdatesEnded
     @subscribe editor, 'screen-lines-changed', @onScreenLinesChanged
     @subscribe editor, 'cursors-moved', @onCursorsMoved
     @subscribe editor, 'selection-removed selection-screen-range-changed', @onSelectionChanged
     @subscribe editor, 'selection-added', @onSelectionAdded
+    @subscribe editor, 'decoration-added', @onDecorationChanged
+    @subscribe editor, 'decoration-removed', @onDecorationChanged
     @subscribe editor, 'decoration-changed', @onDecorationChanged
+    @subscribe editor, 'character-widths-changed', @onCharacterWidthsChanged
     @subscribe editor.$scrollTop.changes, @onScrollTopChanged
     @subscribe editor.$scrollLeft.changes, @requestUpdate
     @subscribe editor.$height.changes, @requestUpdate
@@ -266,9 +345,36 @@ EditorComponent = React.createClass
     node.addEventListener 'textInput', @onTextInput
 
     scrollViewNode = @refs.scrollView.getDOMNode()
-    scrollViewNode.addEventListener 'overflowchanged', @onScrollViewOverflowChanged
     scrollViewNode.addEventListener 'scroll', @onScrollViewScroll
-    window.addEventListener('resize', @onWindowResize)
+    window.addEventListener 'resize', @requestScrollViewMeasurement
+
+    @listenForIMEEvents()
+
+  listenForIMEEvents: ->
+    node = @getDOMNode()
+    {editor} = @props
+
+    # The IME composition events work like this:
+    #
+    # User types 's', chromium pops up the completion helper
+    #   1. compositionstart fired
+    #   2. compositionupdate fired; event.data == 's'
+    # User hits arrow keys to move around in completion helper
+    #   3. compositionupdate fired; event.data == 's' for each arry key press
+    # User escape to cancel
+    #   4. compositionend fired
+    # OR User chooses a completion
+    #   4. compositionend fired
+    #   5. textInput fired; event.data == the completion string
+
+    selectedText = null
+    node.addEventListener 'compositionstart', ->
+      selectedText = editor.getSelectedText()
+    node.addEventListener 'compositionupdate', (event) ->
+      editor.insertText(event.data, select: true, undo: 'skip')
+    node.addEventListener 'compositionend', (event) ->
+      editor.insertText(selectedText, select: true, undo: 'skip')
+      event.target.value = ''
 
   listenForCommands: ->
     {parentView, editor, mini} = @props
@@ -291,6 +397,7 @@ EditorComponent = React.createClass
       'editor:consolidate-selections': @consolidateSelections
       'editor:delete-to-beginning-of-word': => editor.deleteToBeginningOfWord()
       'editor:delete-to-beginning-of-line': => editor.deleteToBeginningOfLine()
+      'editor:delete-to-end-of-line': => editor.deleteToEndOfLine()
       'editor:delete-to-end-of-word': => editor.deleteToEndOfWord()
       'editor:delete-line': => editor.deleteLine()
       'editor:cut-to-end-of-line': => editor.cutToEndOfLine()
@@ -327,10 +434,14 @@ EditorComponent = React.createClass
         'core:move-down': => editor.moveCursorDown()
         'core:move-to-top': => editor.moveCursorToTop()
         'core:move-to-bottom': => editor.moveCursorToBottom()
+        'core:page-up': => editor.pageUp()
+        'core:page-down': => editor.pageDown()
         'core:select-up': => editor.selectUp()
         'core:select-down': => editor.selectDown()
         'core:select-to-top': => editor.selectToTop()
         'core:select-to-bottom': => editor.selectToBottom()
+        'core:select-page-up': => editor.selectPageUp()
+        'core:select-page-down': => editor.selectPageDown()
         'editor:indent': => editor.indent()
         'editor:auto-indent': => editor.autoIndentSelectedRows()
         'editor:indent-selected-rows': => editor.indentSelectedRows()
@@ -368,8 +479,6 @@ EditorComponent = React.createClass
         'editor:toggle-indent-guide': => atom.config.toggle('editor.showIndentGuide')
         'editor:toggle-line-numbers': =>  atom.config.toggle('editor.showLineNumbers')
         'editor:scroll-to-cursor': => editor.scrollToCursorPosition()
-        'core:page-up': => editor.pageUp()
-        'core:page-down': => editor.pageDown()
         'benchmark:scroll': @runScrollBenchmark
 
   addCommandListeners: (listenersByCommandName) ->
@@ -385,7 +494,9 @@ EditorComponent = React.createClass
     @subscribe atom.config.observe 'editor.showIndentGuide', @setShowIndentGuide
     @subscribe atom.config.observe 'editor.invisibles', @setInvisibles
     @subscribe atom.config.observe 'editor.showInvisibles', @setShowInvisibles
+    @subscribe atom.config.observe 'editor.showLineNumbers', @setShowLineNumbers
     @subscribe atom.config.observe 'editor.scrollSensitivity', @setScrollSensitivity
+    @subscribe atom.config.observe 'editor.useHardwareAcceleration', @setUseHardwareAcceleration
 
   onFocus: ->
     @refs.input.focus()
@@ -419,24 +530,25 @@ EditorComponent = React.createClass
   onVerticalScroll: (scrollTop) ->
     {editor} = @props
 
-    return if scrollTop is editor.getScrollTop()
+    return if @updateRequested or scrollTop is editor.getScrollTop()
 
     animationFramePending = @pendingScrollTop?
     @pendingScrollTop = scrollTop
     unless animationFramePending
-      requestAnimationFrame =>
-        @props.editor.setScrollTop(@pendingScrollTop)
+      @requestAnimationFrame =>
+        pendingScrollTop = @pendingScrollTop
         @pendingScrollTop = null
+        @props.editor.setScrollTop(pendingScrollTop)
 
   onHorizontalScroll: (scrollLeft) ->
     {editor} = @props
 
-    return if scrollLeft is editor.getScrollLeft()
+    return if @updateRequested or scrollLeft is editor.getScrollLeft()
 
     animationFramePending = @pendingScrollLeft?
     @pendingScrollLeft = scrollLeft
     unless animationFramePending
-      requestAnimationFrame =>
+      @requestAnimationFrame =>
         @props.editor.setScrollLeft(@pendingScrollLeft)
         @pendingScrollLeft = null
 
@@ -457,35 +569,35 @@ EditorComponent = React.createClass
       @clearMouseWheelScreenRowAfterDelay()
 
     unless animationFramePending
-      requestAnimationFrame =>
+      @requestAnimationFrame =>
         {editor} = @props
         editor.setScrollTop(editor.getScrollTop() + @pendingVerticalScrollDelta)
         editor.setScrollLeft(editor.getScrollLeft() + @pendingHorizontalScrollDelta)
         @pendingVerticalScrollDelta = 0
         @pendingHorizontalScrollDelta = 0
 
-  onScrollViewOverflowChanged: ->
-    @requestScrollViewMeasurement()
-
-  onWindowResize: ->
-    @requestScrollViewMeasurement()
-
   onScrollViewScroll: ->
-    console.warn "EditorScrollView scroll position changed, and it shouldn't have. If you can reproduce this, please report it."
-    scrollViewNode = @refs.scrollView.getDOMNode()
-    scrollViewNode.scrollTop = 0
-    scrollViewNode.scrollLeft = 0
+    if @isMounted()
+      console.warn "EditorScrollView scrolled when it shouldn't have."
+      scrollViewNode = @refs.scrollView.getDOMNode()
+      scrollViewNode.scrollTop = 0
+      scrollViewNode.scrollLeft = 0
 
   onMouseDown: (event) ->
     return unless event.button is 0 # only handle the left mouse button
 
     {editor} = @props
-    {detail, shiftKey, metaKey} = event
+    {detail, shiftKey, metaKey, ctrlKey} = event
     screenPosition = @screenPositionForMouseEvent(event)
 
+    if event.target?.classList.contains('fold-marker')
+      bufferRow = editor.bufferRowForScreenRow(screenPosition.row)
+      editor.unfoldBufferRow(bufferRow)
+      return
+
     if shiftKey
       editor.selectToScreenPosition(screenPosition)
-    else if metaKey
+    else if metaKey or (ctrlKey and process.platform isnt 'darwin')
       editor.addCursorAtScreenPosition(screenPosition)
     else
       editor.setCursorScreenPosition(screenPosition)
@@ -493,21 +605,50 @@ EditorComponent = React.createClass
         when 2 then editor.selectWord()
         when 3 then editor.selectLine()
 
-    @selectToMousePositionUntilMouseUp(event)
+    @handleDragUntilMouseUp event, (screenPosition) ->
+      editor.selectToScreenPosition(screenPosition)
+
+  onGutterMouseDown: (event) ->
+    return unless event.button is 0 # only handle the left mouse button
+
+    if event.shiftKey
+      @onGutterShiftClick(event)
+    else
+      @onGutterClick(event)
+
+  onGutterClick: (event) ->
+    {editor} = @props
+    clickedRow = @screenPositionForMouseEvent(event).row
+
+    editor.setCursorScreenPosition([clickedRow, 0])
+
+    @handleDragUntilMouseUp event, (screenPosition) ->
+      dragRow = screenPosition.row
+      if dragRow < clickedRow # dragging up
+        editor.setSelectedScreenRange([[dragRow, 0], [clickedRow + 1, 0]])
+      else
+        editor.setSelectedScreenRange([[clickedRow, 0], [dragRow + 1, 0]])
+
+  onGutterShiftClick: (event) ->
+    {editor} = @props
+    clickedRow = @screenPositionForMouseEvent(event).row
+    tailPosition = editor.getSelection().getTailScreenPosition()
+
+    if clickedRow < tailPosition.row
+      editor.selectToScreenPosition([clickedRow, 0])
+    else
+      editor.selectToScreenPosition([clickedRow + 1, 0])
+
+    @handleDragUntilMouseUp event, (screenPosition) ->
+      dragRow = screenPosition.row
+      if dragRow < tailPosition.row # dragging up
+        editor.setSelectedScreenRange([[dragRow, 0], tailPosition])
+      else
+        editor.setSelectedScreenRange([tailPosition, [dragRow + 1, 0]])
 
   onStylesheetsChanged: (stylesheet) ->
     @refreshScrollbars() if @containsScrollbarSelector(stylesheet)
 
-  onBatchedUpdatesStarted: ->
-    @batchingUpdates = true
-
-  onBatchedUpdatesEnded: ->
-    updateRequested = @updateRequested
-    @updateRequested = false
-    @batchingUpdates = false
-    if updateRequested
-      @requestUpdate()
-
   onScreenLinesChanged: (change) ->
     {editor} = @props
     @pendingChanges.push(change)
@@ -529,7 +670,7 @@ EditorComponent = React.createClass
   onScrollTopChanged: ->
     @scrollingVertically = true
     @requestUpdate()
-    @onStoppedScrollingAfterDelay ?= debounce(@onStoppedScrolling, 100)
+    @onStoppedScrollingAfterDelay ?= debounce(@onStoppedScrolling, 200)
     @onStoppedScrollingAfterDelay()
 
   onStoppedScrolling: ->
@@ -546,19 +687,20 @@ EditorComponent = React.createClass
     @requestUpdate()
 
   onDecorationChanged: ->
-    @decorationChangedImmediate ?= setImmediate =>
-      @requestUpdate() if @isMounted()
-      @decorationChangedImmediate = null
+    @requestUpdate()
 
-  selectToMousePositionUntilMouseUp: (event) ->
+  onCharacterWidthsChanged: (@scopedCharacterWidthsChangeCount) ->
+    @requestUpdate()
+
+  handleDragUntilMouseUp: (event, dragHandler) ->
     {editor} = @props
     dragging = false
     lastMousePosition = {}
-
     animationLoop = =>
-      requestAnimationFrame =>
+      @requestAnimationFrame =>
         if dragging
-          @selectToMousePosition(lastMousePosition)
+          screenPosition = @screenPositionForMouseEvent(lastMousePosition)
+          dragHandler(screenPosition)
           animationLoop()
 
     onMouseMove = (event) ->
@@ -582,11 +724,18 @@ EditorComponent = React.createClass
     window.addEventListener('mousemove', onMouseMove)
     window.addEventListener('mouseup', onMouseUp)
 
-  selectToMousePosition: (event) ->
-    @props.editor.selectToScreenPosition(@screenPositionForMouseEvent(event))
+  pauseScrollViewMeasurement: ->
+    @scrollViewMeasurementPaused = true
+    @resumeScrollViewMeasurementAfterDelay ?= debounce(@resumeScrollViewMeasurement, 100)
+    @resumeScrollViewMeasurementAfterDelay()
+
+  resumeScrollViewMeasurement: ->
+    @scrollViewMeasurementPaused = false
+
+  resumeScrollViewMeasurementAfterDelay: null # created lazily
 
   requestScrollViewMeasurement: ->
-    return if @measurementPending
+    return if @scrollViewMeasurementRequested
 
     @scrollViewMeasurementRequested = true
     requestAnimationFrame =>
@@ -598,6 +747,7 @@ EditorComponent = React.createClass
   # and use the scrollHeight / scrollWidth as its height and width in
   # calculations.
   measureScrollView: ->
+    return if @scrollViewMeasurementPaused
     return unless @isMounted()
 
     {editor} = @props
@@ -616,20 +766,10 @@ EditorComponent = React.createClass
 
   measureLineHeightAndCharWidthsIfNeeded: (prevState) ->
     if not isEqualForProperties(prevState, @state, 'lineHeight', 'fontSize', 'fontFamily')
-      {editor} = @props
-
-      editor.batchUpdates =>
-        oldDefaultCharWidth = editor.getDefaultCharWidth()
-
-        if @state.visible
-          @measureLineHeightAndDefaultCharWidth()
-        else
-          @measureLineHeightAndDefaultCharWidthWhenShown = true
-
-        unless oldDefaultCharWidth is editor.getDefaultCharWidth()
-          @remeasureCharacterWidths()
-          @measureGutter()
-
+      if @state.visible
+        @measureLineHeightAndDefaultCharWidth()
+      else
+        @measureLineHeightAndDefaultCharWidthWhenShown = true
     else if @measureLineHeightAndDefaultCharWidthWhenShown and @state.visible and not prevState.visible
       @measureLineHeightAndDefaultCharWidth()
 
@@ -637,13 +777,21 @@ EditorComponent = React.createClass
     @measureLineHeightAndDefaultCharWidthWhenShown = false
     @refs.lines.measureLineHeightAndDefaultCharWidth()
 
+  remeasureCharacterWidthsIfNeeded: (prevState) ->
+    if not isEqualForProperties(prevState, @state, 'fontSize', 'fontFamily')
+      if @state.visible
+        @remeasureCharacterWidths()
+      else
+        @remeasureCharacterWidthsWhenShown = true
+    else if @remeasureCharacterWidthsWhenShown and @state.visible and not prevState.visible
+      @remeasureCharacterWidths()
+
   remeasureCharacterWidths: ->
+    @remeasureCharacterWidthsWhenShown = false
     @refs.lines.remeasureCharacterWidths()
 
-  measureGutter: ->
-    oldGutterWidth = @gutterWidth
-    @gutterWidth = @refs.gutter.getDOMNode().offsetWidth
-    @requestUpdate() if @gutterWidth isnt oldGutterWidth
+  onGutterWidthChanged: (@gutterWidth) ->
+    @requestUpdate()
 
   measureScrollbars: ->
     @measuringScrollbars = false
@@ -669,17 +817,17 @@ EditorComponent = React.createClass
     # visible, so first we need to hide scrollbars so we can redisplay them and
     # force Chromium to apply updates.
     @refreshingScrollbars = true
-    @requestUpdate()
+    @forceUpdate()
 
     # Next, we display only the scrollbar corner so we can measure the new
     # scrollbar dimensions. The ::measuringScrollbars property will be set back
     # to false after the scrollbars are measured.
     @measuringScrollbars = true
-    @requestUpdate()
+    @forceUpdate()
 
     # Finally, we restore the scrollbars based on the newly-measured dimensions
     # if the editor's content and dimensions require them to be visible.
-    @requestUpdate()
+    @forceUpdate()
 
   clearMouseWheelScreenRow: ->
     if @mouseWheelScreenRow?
@@ -745,10 +893,18 @@ EditorComponent = React.createClass
   setShowInvisibles: (showInvisibles) ->
     @setState({showInvisibles})
 
+  setShowLineNumbers: (showLineNumbers) ->
+    @setState({showLineNumbers})
+
   setScrollSensitivity: (scrollSensitivity) ->
     if scrollSensitivity = parseInt(scrollSensitivity)
       @scrollSensitivity = Math.abs(scrollSensitivity) / 100
 
+  setUseHardwareAcceleration: (useHardwareAcceleration=true) ->
+    unless @useHardwareAcceleration is useHardwareAcceleration
+      @useHardwareAcceleration = useHardwareAcceleration
+      @requestUpdate()
+
   screenPositionForMouseEvent: (event) ->
     pixelPosition = @pixelPositionForMouseEvent(event)
     @props.editor.screenPositionForPixelPosition(pixelPosition)
@@ -757,9 +913,9 @@ EditorComponent = React.createClass
     {editor} = @props
     {clientX, clientY} = event
 
-    scrollViewClientRect = @refs.scrollView.getDOMNode().getBoundingClientRect()
-    top = clientY - scrollViewClientRect.top + editor.getScrollTop()
-    left = clientX - scrollViewClientRect.left + editor.getScrollLeft()
+    linesClientRect = @refs.lines.getDOMNode().getBoundingClientRect()
+    top = clientY - linesClientRect.top
+    left = clientX - linesClientRect.left
     {top, left}
 
   getModel: ->

src/editor-view.coffee

@@ -57,6 +57,7 @@ class EditorView extends View
     softTabs: true
     softWrapAtPreferredLineLength: false
     scrollSensitivity: 40
+    useHardwareAcceleration: true
 
   @nextEditorId: 1
 
@@ -157,6 +158,7 @@ class EditorView extends View
       'editor:consolidate-selections': (event) => @consolidateSelections(event)
       'editor:delete-to-beginning-of-word': => @editor.deleteToBeginningOfWord()
       'editor:delete-to-beginning-of-line': => @editor.deleteToBeginningOfLine()
+      'editor:delete-to-end-of-line': => @editor.deleteToEndOfLine()
       'editor:delete-to-end-of-word': => @editor.deleteToEndOfWord()
       'editor:delete-line': => @editor.deleteLine()
       'editor:cut-to-end-of-line': => @editor.cutToEndOfLine()
@@ -193,12 +195,14 @@ class EditorView extends View
         'core:move-down': => @editor.moveCursorDown()
         'core:move-to-top': => @editor.moveCursorToTop()
         'core:move-to-bottom': => @editor.moveCursorToBottom()
-        'core:page-down': => @pageDown()
         'core:page-up': => @pageUp()
+        'core:page-down': => @pageDown()
         'core:select-up': => @editor.selectUp()
         'core:select-down': => @editor.selectDown()
         'core:select-to-top': => @editor.selectToTop()
         'core:select-to-bottom': => @editor.selectToBottom()
+        'core:select-page-up': => @editor.selectUp(@getPageRows())
+        'core:select-page-down': => @editor.selectDown(@getPageRows())
         'editor:indent': => @editor.indent()
         'editor:auto-indent': => @editor.autoIndentSelectedRows()
         'editor:indent-selected-rows': => @editor.indentSelectedRows()

src/editor.coffee

@@ -112,6 +112,7 @@ TextMateScopeSelector = require('first-mate').ScopeSelector
 # - {::deleteToBeginningOfWord}
 # - {::deleteToBeginningOfLine}
 # - {::delete}
+# - {::deleteToEndOfLine}
 # - {::deleteToEndOfWord}
 # - {::deleteLine}
 # - {::cutSelectedText}
@@ -214,7 +215,10 @@ class Editor extends Model
     @subscribe @displayBuffer, 'grammar-changed', => @handleGrammarChange()
     @subscribe @displayBuffer, 'tokenized', => @handleTokenization()
     @subscribe @displayBuffer, 'soft-wrap-changed', (args...) => @emit 'soft-wrap-changed', args...
-    @subscribe @displayBuffer, "decoration-changed", (e) => @emit 'decoration-changed', e
+    @subscribe @displayBuffer, "decoration-added", (args...) => @emit 'decoration-added', args...
+    @subscribe @displayBuffer, "decoration-removed", (args...) => @emit 'decoration-removed', args...
+    @subscribe @displayBuffer, "decoration-changed", (args...) => @emit 'decoration-changed', args...
+    @subscribe @displayBuffer, "character-widths-changed", (changeCount) => @emit 'character-widths-changed', changeCount
 
   getViewClass: ->
     if atom.config.get('core.useReactEditor')
@@ -689,6 +693,13 @@ class Editor extends Model
   delete: ->
     @mutateSelectedText (selection) -> selection.delete()
 
+  # Public: For each selection, if the selection is not empty, deletes the
+  # selection; otherwise, deletes all characters of the containing line
+  # following the cursor. If the cursor is already at the end of the line,
+  # deletes the following newline.
+  deleteToEndOfLine: ->
+    @mutateSelectedText (selection) -> selection.deleteToEndOfLine()
+
   # Public: For each selection, if the selection is empty, delete all characters
   # of the containing word following the cursor. Otherwise delete the selected
   # text.
@@ -843,6 +854,10 @@ class Editor extends Model
   isFoldableAtBufferRow: (bufferRow) ->
     @languageMode.isFoldableAtBufferRow(bufferRow)
 
+  isFoldableAtScreenRow: (screenRow) ->
+    bufferRow = @displayBuffer.bufferRowForScreenRow(screenRow)
+    @isFoldableAtBufferRow(bufferRow)
+
   # TODO: Rename to foldRowRange?
   createFold: (startRow, endRow) ->
     @displayBuffer.createFold(startRow, endRow)
@@ -1058,41 +1073,50 @@ class Editor extends Model
       selection.insertText(fn(text))
       selection.setBufferRange(range)
 
-  # Public: Get all the decorations for a buffer row.
+  # Public: Get all the decorations within a screen row range.
   #
-  # bufferRow - the {int} buffer row
-  # decorationType - the {String} decoration type to filter by eg. 'gutter'
+  # startScreenRow - the {Number} beginning screen row
+  # endScreenRow - the {Number} end screen row (inclusive)
   #
-  # Returns an {Array} of decorations in the form `[{type: 'gutter', class: 'someclass'}, ...]`
-  # Returns an empty array when no decorations are found
-  decorationsForBufferRow: (bufferRow, decorationType) ->
-    @displayBuffer.decorationsForBufferRow(bufferRow, decorationType)
+  # Returns an {Object} of decorations in the form `{1: [{type: 'gutter', class: 'someclass'}], 2: ...}`
+  #   where the keys are markerIds, and the values are an array of decoration objects attached to the marker.
+  # Returns an empty object when no decorations are found
+  decorationsForScreenRowRange: (startScreenRow, endScreenRow) ->
+    @displayBuffer.decorationsForScreenRowRange(startScreenRow, endScreenRow)
 
-  # Public: Get all the decorations for a range of buffer rows (inclusive)
+  # Public: Adds a decoration that tracks a {Marker}. When the marker moves,
+  # is invalidated, or is destroyed, the decoration will be updated to reflect
+  # the marker's state.
   #
-  # startBufferRow - the {int} start of the buffer row range
-  # endBufferRow - the {int} end of the buffer row range (inclusive)
-  # decorationType - the {String} decoration type to filter by eg. 'gutter'
-  #
-  # Returns an {Object} of decorations in the form `{23: [{type: 'gutter', class: 'someclass'}, ...], 24: [...]}`
-  # Returns an {Object} with keyed with all buffer rows in the range containing empty {Array}s when no decorations are found
-  decorationsForBufferRowRange: (startBufferRow, endBufferRow, decorationType) ->
-    @displayBuffer.decorationsForBufferRowRange(startBufferRow, endBufferRow, decorationType)
+  # marker - A {Marker} you want this decoration to follow.
+  # decoration - An {Object} representing the decoration eg. `{type: 'gutter', class: 'linter-error'}`
+  #   The decoration can contain the following keys:
+  #     * type: There are a few supported decoration types:
+  #       * `gutter`: Applies the decoration to the line numbers spanned by the
+  #            marker.
+  #       * `line`: Applies the decoration to the lines spanned by the marker.
+  #       * `highlight`: Applies the decoration to a "highlight" behind the
+  #            marked range. When the user selects text, the selection is
+  #            visualized with a highlight decoration internally.
+  #     * class: This CSS class will be applied to the decorated line number,
+  #         line, or highlight.
+  #     * onlyHead: If `true`, the decoration will only be applied to the head
+  #         of the marker. Only applicable to the `line` and `gutter` types.
+  #     * onlyEmpty: If `true`, the decoration will only be applied if the
+  #         associated marker is empty. Only applicable to the `line` and
+  #         `gutter` types.
+  #     * onlyNonEmpty: If `true`, the decoration will only be applied if the
+  #         associated marker is non-empty.  Only applicable to the `line` and
+  #         gutter types.
+  addDecorationForMarker: (marker, decoration) ->
+    @displayBuffer.addDecorationForMarker(marker, decoration)
 
-  # Public: Adds a decoration to a buffer row. For example, use to mark a gutter
-  # line number with a class by using the form `{type: 'gutter', class: 'linter-error'}`
-  #
-  # bufferRow - the {int} buffer row
-  # decoration - the {Object} decoration type to filter by eg. `{type: 'gutter', class: 'linter-error'}`
-  #
-  # Returns nothing
-  addDecorationToBufferRow: (bufferRow, decoration) ->
-    @displayBuffer.addDecorationToBufferRow(bufferRow, decoration)
-
-  # Public: Removes a decoration from a buffer row.
+  # Public: Removes all decorations associated with a {Marker} that match a
+  # `decorationPattern` and stop tracking the {Marker}.
   #
   # ```coffee
-  # editor.removeDecorationFromBufferRow(2, {type: 'gutter', class: 'linter-error'})
+  # marker = editor.markBufferRange([[4, 13], [5, 17]])
+  # editor.removeDecorationForMarker(marker, {type: 'gutter', class: 'linter-error'})
   # ```
   #
   # All decorations matching a pattern will be removed. For example, you might
@@ -1108,49 +1132,9 @@ class Editor extends Model
   # You can remove both with:
   #
   # ```coffee
-  # editor.removeDecorationFromBufferRow(2, {namespace: 'myns'})
+  # editor.removeDecorationForMarker(marker, {namespace: 'myns'})
   # ```
   #
-  # bufferRow - the {int} buffer row
-  # decorationPattern - the {Object} decoration type to filter by eg. `{type: 'gutter', class: 'linter-error'}`
-  #
-  # Returns an {Array} of the removed decorations
-  removeDecorationFromBufferRow: (bufferRow, decorationPattern) ->
-    @displayBuffer.removeDecorationFromBufferRow(bufferRow, decorationPattern)
-
-  # Public: Adds a decoration to line numbers in a buffer row range
-  #
-  # startBufferRow - the {int} start of the buffer row range
-  # endBufferRow - the {int} end of the buffer row range (inclusive)
-  # decoration - the {Object} decoration type to filter by eg. `{type: 'gutter', class: 'linter-error'}`
-  #
-  # Returns nothing
-  addDecorationToBufferRowRange: (startBufferRow, endBufferRow, decoration) ->
-    @displayBuffer.addDecorationToBufferRowRange(startBufferRow, endBufferRow, decoration)
-
-  # Public: Removes a decoration from line numbers in a buffer row range
-  #
-  # startBufferRow - the {int} start of the buffer row range
-  # endBufferRow - the {int} end of the buffer row range (inclusive)
-  # decoration - the {Object} decoration type to filter by eg. `{type: 'gutter', class: 'linter-error'}`
-  #
-  # Returns nothing
-  removeDecorationFromBufferRowRange: (startBufferRow, endBufferRow, decoration) ->
-    @displayBuffer.removeDecorationFromBufferRowRange(startBufferRow, endBufferRow, decoration)
-
-  # Public: Adds a decoration that tracks a {Marker}. When the marker moves,
-  # is invalidated, or is destroyed, the decoration will be updated to reflect the marker's state.
-  #
-  # marker - the {Marker} you want this decoration to follow
-  # decoration - the {Object} decoration type to filter by eg. `{type: 'gutter', class: 'linter-error'}`
-  #
-  # Returns nothing
-  addDecorationForMarker: (marker, decoration) ->
-    @displayBuffer.addDecorationForMarker(marker, decoration)
-
-  # Public: Removes all decorations associated with a {Marker} that match a
-  # `decorationPattern` and stop tracking the {Marker}.
-  #
   # marker - the {Marker} to detach from
   # decorationPattern - the {Object} decoration type to filter by eg. `{type: 'gutter', class: 'linter-error'}`
   #
@@ -1158,6 +1142,9 @@ class Editor extends Model
   removeDecorationForMarker: (marker, decorationPattern) ->
     @displayBuffer.removeDecorationForMarker(marker, decorationPattern)
 
+  decorationMatchesType: (decoration, type) ->
+    @displayBuffer.decorationMatchesType(decoration, type)
+
   # Public: Get the {DisplayBufferMarker} for the given marker id.
   getMarker: (id) ->
     @displayBuffer.getMarker(id)
@@ -1263,7 +1250,9 @@ class Editor extends Model
   addCursor: (marker) ->
     cursor = new Cursor(editor: this, marker: marker)
     @cursors.push(cursor)
-    @addDecorationForMarker(marker, {class: 'cursor-line'})
+    @addDecorationForMarker(marker, type: 'gutter', class: 'cursor-line')
+    @addDecorationForMarker(marker, type: 'gutter', class: 'cursor-line-no-selection', onlyHead: true, onlyEmpty: true)
+    @addDecorationForMarker(marker, type: 'line', class: 'cursor-line', onlyEmpty: true)
     @emit 'cursor-added', cursor
     cursor
 
@@ -1290,6 +1279,7 @@ class Editor extends Model
         if selection.intersectsBufferRange(selectionBufferRange)
           return selection
     else
+      @addDecorationForMarker(marker, type: 'highlight', class: 'selection')
       @emit 'selection-added', selection
       selection
 
@@ -1303,7 +1293,9 @@ class Editor extends Model
   # Returns the added {Selection}.
   addSelectionForBufferRange: (bufferRange, options={}) ->
     @markBufferRange(bufferRange, _.defaults(@getSelectionMarkerAttributes(), options))
-    @getLastSelection()
+    selection = @getLastSelection()
+    selection.autoscroll()
+    selection
 
   # Public: Set the selected range in buffer coordinates. If there are multiple
   # selections, they are reduced to a single selection with the given range.
@@ -1614,17 +1606,22 @@ class Editor extends Model
     @moveCursorDown(@getRowsPerPage())
     @setScrollTop(newScrollTop)
 
+  selectPageUp: ->
+    @selectUp(@getRowsPerPage())
+
+  selectPageDown: ->
+    @selectDown(@getRowsPerPage())
+
   # Returns the number of rows per page
   getRowsPerPage: ->
     Math.max(1, Math.ceil(@getHeight() / @getLineHeightInPixels()))
 
   moveCursors: (fn) ->
     @movingCursors = true
-    @batchUpdates =>
-      fn(cursor) for cursor in @getCursors()
-      @mergeCursors()
-      @movingCursors = false
-      @emit 'cursors-moved'
+    fn(cursor) for cursor in @getCursors()
+    @mergeCursors()
+    @movingCursors = false
+    @emit 'cursors-moved'
 
   cursorMoved: (event) ->
     @emit 'cursor-moved', event
@@ -1944,9 +1941,7 @@ class Editor extends Model
   # execution and revert any changes performed up to the abortion.
   #
   # fn - A {Function} to call inside the transaction.
-  transact: (fn) ->
-    @batchUpdates =>
-      @buffer.transact(fn)
+  transact: (fn) -> @buffer.transact(fn)
 
   # Public: Start an open-ended transaction.
   #
@@ -1966,14 +1961,6 @@ class Editor extends Model
   # within the transaction.
   abortTransaction: -> @buffer.abortTransaction()
 
-  batchUpdates: (fn) ->
-    @emit 'batched-updates-started' if @updateBatchDepth is 0
-    @updateBatchDepth++
-    result = fn()
-    @updateBatchDepth--
-    @emit 'batched-updates-ended' if @updateBatchDepth is 0
-    result
-
   inspect: ->
     "<Editor #{@id}>"
 
@@ -2002,6 +1989,8 @@ class Editor extends Model
   getLineHeightInPixels: -> @displayBuffer.getLineHeightInPixels()
   setLineHeightInPixels: (lineHeightInPixels) -> @displayBuffer.setLineHeightInPixels(lineHeightInPixels)
 
+  batchCharacterMeasurement: (fn) -> @displayBuffer.batchCharacterMeasurement(fn)
+
   getScopedCharWidth: (scopeNames, char) -> @displayBuffer.getScopedCharWidth(scopeNames, char)
   setScopedCharWidth: (scopeNames, char, width) -> @displayBuffer.setScopedCharWidth(scopeNames, char, width)
 
@@ -2049,11 +2038,11 @@ class Editor extends Model
 
   pixelRectForScreenRange: (screenRange) -> @displayBuffer.pixelRectForScreenRange(screenRange)
 
-  scrollToScreenRange: (screenRange) -> @displayBuffer.scrollToScreenRange(screenRange)
+  scrollToScreenRange: (screenRange, options) -> @displayBuffer.scrollToScreenRange(screenRange, options)
 
-  scrollToScreenPosition: (screenPosition) -> @displayBuffer.scrollToScreenPosition(screenPosition)
+  scrollToScreenPosition: (screenPosition, options) -> @displayBuffer.scrollToScreenPosition(screenPosition, options)
 
-  scrollToBufferPosition: (bufferPosition) -> @displayBuffer.scrollToBufferPosition(bufferPosition)
+  scrollToBufferPosition: (bufferPosition, options) -> @displayBuffer.scrollToBufferPosition(bufferPosition, options)
 
   horizontallyScrollable: -> @displayBuffer.horizontallyScrollable()
 

src/fold.coffee

@@ -35,6 +35,11 @@ class Fold
   # Returns a {Range}.
   getBufferRange: ({includeNewline}={}) ->
     range = @marker.getRange()
+
+    if range.end.row > range.start.row and nextFold = @displayBuffer.largestFoldStartingAtBufferRow(range.end.row)
+      nextRange = nextFold.getBufferRange()
+      range = new Range(range.start, nextRange.end)
+
     if includeNewline
       range = range.copy()
       range.end.row++

src/gutter-component.coffee

@@ -12,20 +12,31 @@ GutterComponent = React.createClass
   mixins: [SubscriberMixin]
 
   dummyLineNumberNode: null
+  measuredWidth: null
 
   render: ->
-    {scrollHeight, scrollTop} = @props
+    {scrollHeight, scrollViewHeight, onMouseDown} = @props
 
-    div className: 'gutter', onClick: @onClick,
-      div className: 'line-numbers editor-colors', ref: 'lineNumbers', style:
-        height: scrollHeight
-        WebkitTransform: "translate3d(0px, #{-scrollTop}px, 0px)"
+    div className: 'gutter', onClick: @onClick, onMouseDown: onMouseDown,
+      # The line-numbers div must have the 'editor-colors' class so it has an
+      # opaque background to avoid sub-pixel anti-aliasing problems on the GPU
+      div className: 'gutter line-numbers editor-colors', ref: 'lineNumbers', style:
+        height: Math.max(scrollHeight, scrollViewHeight)
+        WebkitTransform: @getTransform()
+
+  getTransform: ->
+    {scrollTop, useHardwareAcceleration} = @props
+
+    if useHardwareAcceleration
+      "translate3d(0px, #{-scrollTop}px, 0px)"
+    else
+      "translate(0px, #{-scrollTop}px)"
 
   componentWillMount: ->
     @lineNumberNodesById = {}
     @lineNumberIdsByScreenRow = {}
     @screenRowsByLineNumberId = {}
-    @previousDecorations = {}
+    @renderedDecorationsByLineNumberId = {}
 
   componentDidMount: ->
     @appendDummyLineNumber()
@@ -35,22 +46,24 @@ GutterComponent = React.createClass
   # visible row range.
   shouldComponentUpdate: (newProps) ->
     return true unless isEqualForProperties(newProps, @props,
-      'renderedRowRange', 'scrollTop', 'lineHeightInPixels', 'mouseWheelScreenRow'
+      'renderedRowRange', 'scrollTop', 'lineHeightInPixels', 'mouseWheelScreenRow', 'lineDecorations',
+      'scrollViewHeight', 'useHardwareAcceleration'
     )
 
-    {renderedRowRange, pendingChanges, decorations} = newProps
+    {renderedRowRange, pendingChanges, lineDecorations} = newProps
     for change in pendingChanges when Math.abs(change.screenDelta) > 0 or Math.abs(change.bufferDelta) > 0
       return true unless change.end <= renderedRowRange.start or renderedRowRange.end <= change.start
 
-    return true unless _.isEqual(@previousDecorations, decorations)
-
     false
 
   componentDidUpdate: (oldProps) ->
-    unless oldProps.maxLineNumberDigits is @props.maxLineNumberDigits
+    unless isEqualForProperties(oldProps, @props, 'maxLineNumberDigits')
       @updateDummyLineNumber()
       @removeLineNumberNodes()
 
+    unless isEqualForProperties(oldProps, @props, 'maxLineNumberDigits', 'defaultCharWidth')
+      @measureWidth()
+
     @clearScreenRowCaches() unless oldProps.lineHeightInPixels is @props.lineHeightInPixels
     @updateLineNumbers()
 
@@ -74,7 +87,7 @@ GutterComponent = React.createClass
     @removeLineNumberNodes(lineNumberIdsToPreserve)
 
   appendOrUpdateVisibleLineNumberNodes: ->
-    {editor, renderedRowRange, scrollTop, maxLineNumberDigits, decorations} = @props
+    {editor, renderedRowRange, scrollTop, maxLineNumberDigits, lineDecorations} = @props
     [startRow, endRow] = renderedRowRange
 
     newLineNumberIds = null
@@ -95,15 +108,17 @@ GutterComponent = React.createClass
       visibleLineNumberIds.add(id)
 
       if @hasLineNumberNode(id)
-        @updateLineNumberNode(id, bufferRow, screenRow, wrapCount > 0, decorations[bufferRow])
+        @updateLineNumberNode(id, bufferRow, screenRow, wrapCount > 0)
       else
         newLineNumberIds ?= []
         newLineNumbersHTML ?= ""
         newLineNumberIds.push(id)
-        newLineNumbersHTML += @buildLineNumberHTML(bufferRow, wrapCount > 0, maxLineNumberDigits, screenRow, decorations[bufferRow])
+        newLineNumbersHTML += @buildLineNumberHTML(bufferRow, wrapCount > 0, maxLineNumberDigits, screenRow)
         @screenRowsByLineNumberId[id] = screenRow
         @lineNumberIdsByScreenRow[screenRow] = id
 
+      @renderedDecorationsByLineNumberId[id] = lineDecorations[screenRow]
+
     if newLineNumberIds?
       WrapperDiv.innerHTML = newLineNumbersHTML
       newLineNumberNodes = toArray(WrapperDiv.children)
@@ -114,7 +129,6 @@ GutterComponent = React.createClass
         @lineNumberNodesById[lineNumberId] = lineNumberNode
         node.appendChild(lineNumberNode)
 
-    @previousDecorations = decorations
     visibleLineNumberIds
 
   removeLineNumberNodes: (lineNumberIdsToPreserve) ->
@@ -126,20 +140,24 @@ GutterComponent = React.createClass
         delete @lineNumberNodesById[lineNumberId]
         delete @lineNumberIdsByScreenRow[screenRow] if @lineNumberIdsByScreenRow[screenRow] is lineNumberId
         delete @screenRowsByLineNumberId[lineNumberId]
+        delete @renderedDecorationsByLineNumberId[lineNumberId]
         node.removeChild(lineNumberNode)
 
-  buildLineNumberHTML: (bufferRow, softWrapped, maxLineNumberDigits, screenRow, decorations) ->
+  buildLineNumberHTML: (bufferRow, softWrapped, maxLineNumberDigits, screenRow) ->
+    {editor, lineHeightInPixels, lineDecorations} = @props
     if screenRow?
-      {lineHeightInPixels} = @props
       style = "position: absolute; top: #{screenRow * lineHeightInPixels}px;"
     else
       style = "visibility: hidden;"
     innerHTML = @buildLineNumberInnerHTML(bufferRow, softWrapped, maxLineNumberDigits)
 
     classes = ''
-    if decorations?
+    if lineDecorations? and decorations = lineDecorations[screenRow]
       for decoration in decorations
-        classes += decoration.class + ' ' if not softWrapped or softWrapped and decoration.softWrap
+        if editor.decorationMatchesType(decoration, 'gutter')
+          classes += decoration.class + ' '
+
+    classes += "foldable " if bufferRow >= 0 and editor.isFoldableAtBufferRow(bufferRow)
     classes += "line-number line-number-#{bufferRow}"
 
     "<div class=\"#{classes}\" style=\"#{style}\" data-buffer-row=\"#{bufferRow}\" data-screen-row=\"#{screenRow}\">#{innerHTML}</div>"
@@ -154,17 +172,25 @@ GutterComponent = React.createClass
     iconHTML = '<div class="icon-right"></div>'
     padding + lineNumber + iconHTML
 
-  updateLineNumberNode: (lineNumberId, bufferRow, screenRow, softWrapped, decorations) ->
+  updateLineNumberNode: (lineNumberId, bufferRow, screenRow, softWrapped) ->
+    {editor, lineDecorations} = @props
     node = @lineNumberNodesById[lineNumberId]
-    previousDecorations = @previousDecorations[bufferRow]
+
+    if editor.isFoldableAtBufferRow(bufferRow)
+      node.classList.add('foldable')
+    else
+      node.classList.remove('foldable')
+
+    decorations = lineDecorations[screenRow]
+    previousDecorations = @renderedDecorationsByLineNumberId[lineNumberId]
 
     if previousDecorations?
       for decoration in previousDecorations
-        node.classList.remove(decoration.class) if not contains(decorations, decoration)
+        node.classList.remove(decoration.class) if editor.decorationMatchesType(decoration, 'gutter') and not _.deepContains(decorations, decoration)
 
     if decorations?
       for decoration in decorations
-        if not contains(previousDecorations, decoration) and (not softWrapped or softWrapped and decoration.softWrap)
+        if editor.decorationMatchesType(decoration, 'gutter') and not _.deepContains(previousDecorations, decoration)
           node.classList.add(decoration.class)
 
     unless @screenRowsByLineNumberId[lineNumberId] is screenRow
@@ -192,9 +218,8 @@ GutterComponent = React.createClass
       else
         editor.foldBufferRow(bufferRow)
 
-# Created because underscore uses === not _.isEqual, which we need
-contains = (array, target) ->
-  return false unless array?
-  for object in array
-    return true if _.isEqual(object, target)
-  false
+  measureWidth: ->
+    width = @getDOMNode().offsetWidth
+    unless width is @measuredWidth
+      @measuredWidth = width
+      @props.onWidthChanged?(width)

src/highlight-component.coffee

@@ -1,25 +1,24 @@
 React = require 'react-atom-fork'
 {div} = require 'reactionary-atom-fork'
+{isEqualForProperties} = require 'underscore-plus'
 
 module.exports =
-SelectionComponent = React.createClass
-  displayName: 'SelectionComponent'
+HighlightComponent = React.createClass
+  displayName: 'HighlightComponent'
 
   render: ->
-    {editor, screenRange, lineHeightInPixels} = @props
-    {start, end} = screenRange
-    rowCount = end.row - start.row + 1
-    startPixelPosition = editor.pixelPositionForScreenPosition(start)
-    endPixelPosition = editor.pixelPositionForScreenPosition(end)
+    {startPixelPosition, endPixelPosition, decoration} = @props
 
-    div className: 'selection',
-      if rowCount is 1
-        @renderSingleLineRegions(startPixelPosition, endPixelPosition)
+    className = 'highlight'
+    className += " #{decoration.class}" if decoration.class?
+    div {className},
+      if endPixelPosition.top is startPixelPosition.top
+        @renderSingleLineRegions()
       else
-        @renderMultiLineRegions(startPixelPosition, endPixelPosition, rowCount)
+        @renderMultiLineRegions()
 
-  renderSingleLineRegions: (startPixelPosition, endPixelPosition) ->
-    {lineHeightInPixels} = @props
+  renderSingleLineRegions: ->
+    {startPixelPosition, endPixelPosition, lineHeightInPixels} = @props
 
     [
       div className: 'region', key: 0, style:
@@ -29,8 +28,8 @@ SelectionComponent = React.createClass
         width: endPixelPosition.left - startPixelPosition.left
     ]
 
-  renderMultiLineRegions: (startPixelPosition, endPixelPosition, rowCount) ->
-    {lineHeightInPixels} = @props
+  renderMultiLineRegions: ->
+    {startPixelPosition, endPixelPosition, lineHeightInPixels} = @props
     regions = []
     index = 0
 
@@ -44,11 +43,11 @@ SelectionComponent = React.createClass
     )
 
     # Middle rows, extending from left side to right side of screen
-    if rowCount > 2
+    if endPixelPosition.top - startPixelPosition.top > lineHeightInPixels
       regions.push(
         div className: 'region', key: index++, style:
           top: startPixelPosition.top + lineHeightInPixels
-          height: (rowCount - 2) * lineHeightInPixels
+          height: endPixelPosition.top - startPixelPosition.top - lineHeightInPixels
           left: 0
           right: 0
       )
@@ -63,3 +62,6 @@ SelectionComponent = React.createClass
     )
 
     regions
+
+  shouldComponentUpdate: (newProps) ->
+    not isEqualForProperties(newProps, @props, 'startPixelPosition', 'endPixelPosition', 'lineHeightInPixels')

src/highlights-component.coffee

@@ -0,0 +1,25 @@
+React = require 'react-atom-fork'
+{div} = require 'reactionary-atom-fork'
+{isEqualForProperties} = require 'underscore-plus'
+HighlightComponent = require './highlight-component'
+
+module.exports =
+HighlightsComponent = React.createClass
+  displayName: 'HighlightsComponent'
+
+  render: ->
+    div className: 'highlights',
+      @renderHighlights() if @isMounted()
+
+  renderHighlights: ->
+    {highlightDecorations, lineHeightInPixels} = @props
+
+    highlightComponents = []
+    for markerId, {startPixelPosition, endPixelPosition, decorations} of highlightDecorations
+      for decoration in decorations
+        highlightComponents.push(HighlightComponent({key: "#{markerId}-#{decoration.class}", startPixelPosition, endPixelPosition, decoration, lineHeightInPixels}))
+
+    highlightComponents
+
+  shouldComponentUpdate: (newProps) ->
+    not isEqualForProperties(newProps, @props, 'highlightDecorations', 'lineHeightInPixels', 'defaultCharWidth', 'scopedCharacterWidthsChangeCount')

src/lines-component.coffee

@@ -1,9 +1,10 @@
+_ = require 'underscore-plus'
 React = require 'react-atom-fork'
 {div, span} = require 'reactionary-atom-fork'
 {debounce, isEqual, isEqualForProperties, multiplyString, toArray} = require 'underscore-plus'
 {$$} = require 'space-pen'
 
-SelectionsComponent = require './selections-component'
+HighlightsComponent = require './highlights-component'
 
 DummyLineNode = $$(-> @div className: 'line', style: 'position: absolute; visibility: hidden;', => @span 'x')[0]
 AcceptFilter = {acceptNode: -> NodeFilter.FILTER_ACCEPT}
@@ -15,26 +16,38 @@ LinesComponent = React.createClass
 
   render: ->
     if @isMounted()
-      {editor, selectionScreenRanges, scrollTop, scrollLeft, scrollHeight, scrollWidth, lineHeightInPixels, defaultCharWidth, scrollViewHeight} = @props
+      {editor, highlightDecorations, scrollHeight, scrollWidth} = @props
+      {lineHeightInPixels, defaultCharWidth, scrollViewHeight, scopedCharacterWidthsChangeCount} = @props
       style =
         height: Math.max(scrollHeight, scrollViewHeight)
         width: scrollWidth
-        WebkitTransform: "translate3d(#{-scrollLeft}px, #{-scrollTop}px, 0px)"
+        WebkitTransform: @getTransform()
 
+    # The lines div must have the 'editor-colors' class so it has an opaque
+    # background to avoid sub-pixel anti-aliasing problems on the GPU
     div {className: 'lines editor-colors', style},
-      SelectionsComponent({editor, selectionScreenRanges, lineHeightInPixels, defaultCharWidth}) if @isMounted()
+      HighlightsComponent({editor, highlightDecorations, lineHeightInPixels, defaultCharWidth, scopedCharacterWidthsChangeCount})
+
+  getTransform: ->
+    {scrollTop, scrollLeft, useHardwareAcceleration} = @props
+
+    if useHardwareAcceleration
+      "translate3d(#{-scrollLeft}px, #{-scrollTop}px, 0px)"
+    else
+      "translate(#{-scrollLeft}px, #{-scrollTop}px)"
 
   componentWillMount: ->
     @measuredLines = new WeakSet
     @lineNodesByLineId = {}
     @screenRowsByLineId = {}
     @lineIdsByScreenRow = {}
+    @renderedDecorationsByLineId = {}
 
   shouldComponentUpdate: (newProps) ->
     return true unless isEqualForProperties(newProps, @props,
-      'renderedRowRange', 'selectionScreenRanges', 'lineHeightInPixels', 'defaultCharWidth',
+      'renderedRowRange', 'lineDecorations', 'highlightDecorations', 'lineHeightInPixels', 'defaultCharWidth',
       'scrollTop', 'scrollLeft', 'showIndentGuide', 'scrollingVertically', 'invisibles', 'visible',
-      'scrollViewHeight', 'mouseWheelScreenRow'
+      'scrollViewHeight', 'mouseWheelScreenRow', 'scopedCharacterWidthsChangeCount', 'lineWidth', 'useHardwareAcceleration'
     )
 
     {renderedRowRange, pendingChanges} = newProps
@@ -49,20 +62,20 @@ LinesComponent = React.createClass
 
     @clearScreenRowCaches() unless prevProps.lineHeightInPixels is @props.lineHeightInPixels
     @removeLineNodes() unless isEqualForProperties(prevProps, @props, 'showIndentGuide', 'invisibles')
-    @updateLines()
+    @updateLines(@props.lineWidth isnt prevProps.lineWidth)
     @measureCharactersInNewLines() if visible and not scrollingVertically
 
   clearScreenRowCaches: ->
     @screenRowsByLineId = {}
     @lineIdsByScreenRow = {}
 
-  updateLines: ->
-    {editor, renderedRowRange, showIndentGuide, selectionChanged} = @props
+  updateLines: (updateWidth) ->
+    {editor, renderedRowRange, showIndentGuide, selectionChanged, lineDecorations} = @props
     [startRow, endRow] = renderedRowRange
 
     visibleLines = editor.linesForScreenRows(startRow, endRow - 1)
     @removeLineNodes(visibleLines)
-    @appendOrUpdateVisibleLineNodes(visibleLines, startRow)
+    @appendOrUpdateVisibleLineNodes(visibleLines, startRow, updateWidth)
 
   removeLineNodes: (visibleLines=[]) ->
     {mouseWheelScreenRow} = @props
@@ -75,9 +88,12 @@ LinesComponent = React.createClass
         delete @lineNodesByLineId[lineId]
         delete @lineIdsByScreenRow[screenRow] if @lineIdsByScreenRow[screenRow] is lineId
         delete @screenRowsByLineId[lineId]
+        delete @renderedDecorationsByLineId[lineId]
         node.removeChild(lineNode)
 
-  appendOrUpdateVisibleLineNodes: (visibleLines, startRow) ->
+  appendOrUpdateVisibleLineNodes: (visibleLines, startRow, updateWidth) ->
+    {lineDecorations} = @props
+
     newLines = null
     newLinesHTML = null
 
@@ -85,7 +101,7 @@ LinesComponent = React.createClass
       screenRow = startRow + index
 
       if @hasLineNode(line.id)
-        @updateLineNode(line, screenRow)
+        @updateLineNode(line, screenRow, updateWidth)
       else
         newLines ?= []
         newLinesHTML ?= ""
@@ -94,6 +110,8 @@ LinesComponent = React.createClass
         @screenRowsByLineId[line.id] = screenRow
         @lineIdsByScreenRow[screenRow] = line.id
 
+      @renderedDecorationsByLineId[line.id] = lineDecorations[screenRow]
+
     return unless newLines?
 
     WrapperDiv.innerHTML = newLinesHTML
@@ -108,17 +126,25 @@ LinesComponent = React.createClass
     @lineNodesByLineId.hasOwnProperty(lineId)
 
   buildLineHTML: (line, screenRow) ->
-    {editor, mini, showIndentGuide, lineHeightInPixels} = @props
+    {editor, mini, showIndentGuide, lineHeightInPixels, lineDecorations, lineWidth} = @props
     {tokens, text, lineEnding, fold, isSoftWrapped, indentLevel} = line
 
+    classes = ''
+    if decorations = lineDecorations[screenRow]
+      for decoration in decorations
+        if editor.decorationMatchesType(decoration, 'line')
+          classes += decoration.class + ' '
+    classes += 'line'
+
     top = screenRow * lineHeightInPixels
-    lineHTML = "<div class=\"line\" style=\"position: absolute; top: #{top}px;\" data-screen-row=\"#{screenRow}\">"
+    lineHTML = "<div class=\"#{classes}\" style=\"position: absolute; top: #{top}px; width: #{lineWidth}px;\" data-screen-row=\"#{screenRow}\">"
 
     if text is ""
       lineHTML += @buildEmptyLineInnerHTML(line)
     else
       lineHTML += @buildLineInnerHTML(line)
 
+    lineHTML += '<span class="fold-marker"></span>' if fold
     lineHTML += "</div>"
     lineHTML
 
@@ -185,10 +211,25 @@ LinesComponent = React.createClass
     scopeStack.push(scope)
     "<span class=\"#{scope.replace(/\.+/g, ' ')}\">"
 
-  updateLineNode: (line, screenRow) ->
+  updateLineNode: (line, screenRow, updateWidth) ->
+    {editor, lineHeightInPixels, lineDecorations, lineWidth} = @props
+    lineNode = @lineNodesByLineId[line.id]
+
+    decorations = lineDecorations[screenRow]
+    previousDecorations = @renderedDecorationsByLineId[line.id]
+
+    if previousDecorations?
+      for decoration in previousDecorations
+        lineNode.classList.remove(decoration.class) if editor.decorationMatchesType(decoration, 'line') and not _.deepContains(decorations, decoration)
+
+    if decorations?
+      for decoration in decorations
+        if editor.decorationMatchesType(decoration, 'line') and not _.deepContains(previousDecorations, decoration)
+          lineNode.classList.add(decoration.class)
+
+    lineNode.style.width = lineWidth + 'px' if updateWidth
+
     unless @screenRowsByLineId[line.id] is screenRow
-      {lineHeightInPixels} = @props
-      lineNode = @lineNodesByLineId[line.id]
       lineNode.style.top = screenRow * lineHeightInPixels + 'px'
       lineNode.dataset.screenRow = screenRow
       @screenRowsByLineId[line.id] = screenRow
@@ -205,22 +246,24 @@ LinesComponent = React.createClass
     node.removeChild(DummyLineNode)
 
     {editor} = @props
-    editor.batchUpdates ->
-      editor.setLineHeightInPixels(lineHeightInPixels)
-      editor.setDefaultCharWidth(charWidth)
+    editor.setLineHeightInPixels(lineHeightInPixels)
+    editor.setDefaultCharWidth(charWidth)
 
   remeasureCharacterWidths: ->
     @clearScopedCharWidths()
     @measureCharactersInNewLines()
 
   measureCharactersInNewLines: ->
+    {editor} = @props
     [visibleStartRow, visibleEndRow] = @props.renderedRowRange
     node = @getDOMNode()
 
-    for tokenizedLine in @props.editor.linesForScreenRows(visibleStartRow, visibleEndRow - 1)
-      unless @measuredLines.has(tokenizedLine)
-        lineNode = @lineNodesByLineId[tokenizedLine.id]
-        @measureCharactersInLine(tokenizedLine, lineNode)
+    editor.batchCharacterMeasurement =>
+      for tokenizedLine in editor.linesForScreenRows(visibleStartRow, visibleEndRow - 1)
+        unless @measuredLines.has(tokenizedLine)
+          lineNode = @lineNodesByLineId[tokenizedLine.id]
+          @measureCharactersInLine(tokenizedLine, lineNode)
+      return
 
   measureCharactersInLine: (tokenizedLine, lineNode) ->
     {editor} = @props

src/package.coffee

@@ -67,7 +67,6 @@ class Package
         @loadKeymaps()
         @loadMenus()
         @loadStylesheets()
-        @grammarsPromise = @loadGrammars()
         @scopedPropertiesPromise = @loadScopedProperties()
         @requireMainModule() unless @hasActivationEvents()
 
@@ -83,6 +82,8 @@ class Package
     @scopedProperties = []
 
   activate: ->
+    @grammarsPromise ?= @loadGrammars()
+
     unless @activationDeferred?
       @activationDeferred = Q.defer()
       @measure 'activateTime', =>
@@ -128,8 +129,9 @@ class Package
     atom.contextMenu.add(menuPath, map['context-menu']) for [menuPath, map] in @menus
     atom.menu.add(map.menu) for [menuPath, map] in @menus when map.menu
 
-    grammar.activate() for grammar in @grammars
-    @grammarsActivated = true
+    unless @grammarsActivated
+      grammar.activate() for grammar in @grammars
+      @grammarsActivated = true
 
     scopedProperties.activate() for scopedProperties in @scopedProperties
     @scopedPropertiesActivated = true
@@ -173,14 +175,32 @@ class Package
     else
       fs.listSync(stylesheetDirPath, ['css', 'less'])
 
+  loadGrammarsSync: ->
+    return if @grammarsLoaded
+
+    grammarsDirPath = path.join(@path, 'grammars')
+    grammarPaths = fs.listSync(grammarsDirPath, ['json', 'cson'])
+    for grammarPath in grammarPaths
+      try
+        grammar = atom.syntax.readGrammarSync(grammarPath)
+        grammar.packageName = @name
+        @grammars.push(grammar)
+        grammar.activate()
+      catch error
+        console.warn("Failed to load grammar: #{grammarPath}", error.stack ? error)
+
+    @grammarsLoaded = true
+    @grammarsActivated = true
+
   loadGrammars: ->
-    @grammars = []
+    return Q() if @grammarsLoaded
 
     loadGrammar = (grammarPath, callback) =>
       atom.syntax.readGrammar grammarPath, (error, grammar) =>
         if error?
           console.warn("Failed to load grammar: #{grammarPath}", error.stack ? error)
         else
+          grammar.packageName = @name
           @grammars.push(grammar)
           grammar.activate() if @grammarsActivated
         callback()

src/project.coffee

@@ -239,6 +239,9 @@ class Project extends Model
     task.on 'scan:result-found', (result) =>
       iterator(result) unless @isPathModified(result.filePath)
 
+    task.on 'scan:file-error', (error) ->
+      iterator(null, error)
+
     if _.isFunction(options.onPathsSearched)
       task.on 'scan:paths-searched', (numberOfPathsSearched) ->
         options.onPathsSearched(numberOfPathsSearched)
@@ -283,6 +286,7 @@ class Project extends Model
         checkFinished()
 
       task.on 'replace:path-replaced', iterator
+      task.on 'replace:file-error', (error) -> iterator(null, error)
 
     for buffer in @getBuffers()
       continue unless buffer.getPath() in filePaths

src/react-editor-view.coffee

@@ -5,9 +5,7 @@ EditorComponent = require './editor-component'
 
 module.exports =
 class ReactEditorView extends View
-  # The `overlayer` class is included for backwards compatibility with
-  # context menus. It should be removed in v1.0.0
-  @content: -> @div class: 'editor react overlayer'
+  @content: -> @div class: 'editor react'
 
   focusOnAttach: false
 
@@ -36,7 +34,7 @@ class ReactEditorView extends View
     node = @component.getDOMNode()
 
     @scrollView = $(node).find('.scroll-view')
-    @underlayer = $(node).find('.selections').addClass('underlayer')
+    @underlayer = $(node).find('.highlights').addClass('underlayer')
     @overlayer = $(node).find('.lines').addClass('overlayer')
     @hiddenInput = $(node).find('.hidden-input')
 
@@ -71,11 +69,11 @@ class ReactEditorView extends View
   scrollToBottom: ->
     @editor.setScrollBottom(Infinity)
 
-  scrollToScreenPosition: (screenPosition) ->
-    @editor.scrollToScreenPosition(screenPosition)
+  scrollToScreenPosition: (screenPosition, options) ->
+    @editor.scrollToScreenPosition(screenPosition, options)
 
-  scrollToBufferPosition: (bufferPosition) ->
-    @editor.scrollToBufferPosition(bufferPosition)
+  scrollToBufferPosition: (bufferPosition, options) ->
+    @editor.scrollToBufferPosition(bufferPosition, options)
 
   scrollToCursorPosition: ->
     @editor.scrollToCursorPosition()
@@ -204,4 +202,6 @@ class ReactEditorView extends View
 
   updateDisplay: -> # No-op shim for package specs
 
+  resetDisplay: -> # No-op shim for package specs
+
   redraw: -> # No-op shim

src/replace-handler.coffee

@@ -6,8 +6,10 @@ module.exports = (filePaths, regexSource, regexFlags, replacementText) ->
   replacer = new PathReplacer()
   regex = new RegExp(regexSource, regexFlags)
 
+  replacer.on 'file-error', ({code, path, message}) ->
+    emit('replace:file-error', {code, path, message})
+
   replacer.on 'path-replaced', (result) ->
     emit('replace:path-replaced', result)
 
-  replacer.replacePaths regex, replacementText, filePaths, ->
-    callback()
+  replacer.replacePaths(regex, replacementText, filePaths, -> callback())

src/scan-handler.coffee

@@ -9,6 +9,9 @@ module.exports = (rootPath, regexSource, options) ->
   searcher = new PathSearcher()
   scanner = new PathScanner(rootPath, options)
 
+  searcher.on 'file-error', ({code, path, message}) ->
+    emit('scan:file-error', {code, path, message})
+
   searcher.on 'results-found', (result) ->
     emit('scan:result-found', result)
 

src/selection.coffee

@@ -91,6 +91,18 @@ class Selection extends Model
     end = Math.max(start, end - 1) if range.end.column == 0
     [start, end]
 
+  getTailScreenPosition: ->
+    @marker.getTailScreenPosition()
+
+  getTailBufferPosition: ->
+    @marker.getTailBufferPosition()
+
+  getHeadScreenPosition: ->
+    @marker.getHeadScreenPosition()
+
+  getHeadBufferPosition: ->
+    @marker.getHeadBufferPosition()
+
   autoscroll: ->
     @editor.scrollToScreenRange(@getScreenRange())
 
@@ -266,7 +278,8 @@ class Selection extends Model
 
   # FIXME: I have no idea what this does.
   getGoalBufferRange: ->
-    @marker.getAttributes().goalBufferRange
+    if goalBufferRange = @marker.getAttributes().goalBufferRange
+      Range.fromObject(goalBufferRange)
 
   # Public: Moves the selection up one row.
   addSelectionAbove: ->
@@ -302,6 +315,7 @@ class Selection extends Model
     wasReversed = @isReversed()
     @clear()
     @cursor.needsAutoscroll = @cursor.isLastCursor()
+    @cursor.autoscroll() if @editor.manageScrollPosition and @cursor.isLastCursor()
 
     if options.indentBasis? and not options.autoIndent
       text = @normalizeIndents(text, options.indentBasis)
@@ -430,6 +444,15 @@ class Selection extends Model
         @selectRight()
     @deleteSelectedText()
 
+  # Public: If the selection is empty, removes all text from the cursor to the
+  # end of the line. If the cursor is already at the end of the line, it
+  # removes the following newline. If the selection isn't empty, only deletes
+  # the contents of the selection.
+  deleteToEndOfLine: ->
+    return @delete() if @isEmpty() and @cursor.isAtEndOfLine()
+    @selectToEndOfLine() if @isEmpty()
+    @deleteSelectedText()
+
   # Public: Removes the selection or all characters from the start of the
   # selection to the end of the current word if nothing is selected.
   deleteToEndOfWord: ->

src/selections-component.coffee

@@ -1,25 +0,0 @@
-React = require 'react-atom-fork'
-{div} = require 'reactionary-atom-fork'
-{isEqualForProperties} = require 'underscore-plus'
-SelectionComponent = require './selection-component'
-
-module.exports =
-SelectionsComponent = React.createClass
-  displayName: 'SelectionsComponent'
-
-  render: ->
-    div className: 'selections', @renderSelections()
-
-  renderSelections: ->
-    {editor, selectionScreenRanges, lineHeightInPixels} = @props
-
-    selectionComponents = []
-    for selectionId, screenRange of selectionScreenRanges
-      selectionComponents.push(SelectionComponent({key: selectionId, screenRange, editor, lineHeightInPixels}))
-    selectionComponents
-
-  componentWillMount: ->
-    @selectionRanges = {}
-
-  shouldComponentUpdate: (newProps) ->
-    not isEqualForProperties(newProps, @props, 'selectionScreenRanges', 'lineHeightInPixels', 'defaultCharWidth')

src/token.coffee

@@ -2,8 +2,8 @@ _ = require 'underscore-plus'
 textUtils = require './text-utils'
 
 WhitespaceRegexesByTabLength = {}
-LeadingWhitespaceRegex = /^[ ]+/
-TrailingWhitespaceRegex = /[ ]+$/
+LeadingSpaceRegex = /^[ ]+/
+TrailingSpaceRegex = /[ ]+$/
 EscapeRegex = /[&"'<>]/g
 CharacterRegex = /./g
 StartCharacterRegex = /^./
@@ -42,16 +42,18 @@ class Token
   whitespaceRegexForTabLength: (tabLength) ->
     WhitespaceRegexesByTabLength[tabLength] ?= new RegExp("([ ]{#{tabLength}})|(\t)|([^\t]+)", "g")
 
-  breakOutAtomicTokens: (tabLength, breakOutLeadingSoftTabs) ->
+  breakOutAtomicTokens: (tabLength, breakOutLeadingSoftTabs, startColumn) ->
     if @hasSurrogatePair
       outputTokens = []
+      column = startColumn
 
       for token in @breakOutSurrogatePairs()
         if token.isAtomic
           outputTokens.push(token)
         else
-          outputTokens.push(token.breakOutAtomicTokens(tabLength, breakOutLeadingSoftTabs)...)
+          outputTokens.push(token.breakOutAtomicTokens(tabLength, breakOutLeadingSoftTabs, column)...)
         breakOutLeadingSoftTabs = token.isOnlyWhitespace() if breakOutLeadingSoftTabs
+        column += token.value.length
 
       outputTokens
     else
@@ -64,17 +66,21 @@ class Token
 
       outputTokens = []
       regex = @whitespaceRegexForTabLength(tabLength)
+      column = startColumn
       while match = regex.exec(@value)
         [fullMatch, softTab, hardTab] = match
+        token = null
         if softTab and breakOutLeadingSoftTabs
-          outputTokens.push(@buildSoftTabToken(tabLength))
+          token = @buildSoftTabToken(tabLength)
         else if hardTab
           breakOutLeadingSoftTabs = false
-          outputTokens.push(@buildHardTabToken(tabLength))
+          token = @buildHardTabToken(tabLength, column)
         else
           breakOutLeadingSoftTabs = false
           value = match[0]
-          outputTokens.push(new Token({value, @scopes}))
+          token = new Token({value, @scopes})
+        column += token.value.length
+        outputTokens.push(token)
 
       outputTokens
 
@@ -105,17 +111,18 @@ class Token
       isAtomic: true
     )
 
-  buildHardTabToken: (tabLength) ->
-    @buildTabToken(tabLength, true)
+  buildHardTabToken: (tabLength, column) ->
+    @buildTabToken(tabLength, true, column)
 
   buildSoftTabToken: (tabLength) ->
-    @buildTabToken(tabLength, false)
+    @buildTabToken(tabLength, false, 0)
 
-  buildTabToken: (tabLength, isHardTab) ->
+  buildTabToken: (tabLength, isHardTab, column=0) ->
+    tabStop = tabLength - (column % tabLength)
     new Token(
-      value: _.multiplyString(" ", tabLength)
+      value: _.multiplyString(" ", tabStop)
       scopes: @scopes
-      bufferDelta: if isHardTab then 1 else tabLength
+      bufferDelta: if isHardTab then 1 else tabStop
       isAtomic: true
       isHardTab: isHardTab
     )
@@ -144,7 +151,7 @@ class Token
       leadingHtml = ''
       trailingHtml = ''
 
-      if @hasLeadingWhitespace and match = LeadingWhitespaceRegex.exec(@value)
+      if @hasLeadingWhitespace and match = LeadingSpaceRegex.exec(@value)
         classes = 'leading-whitespace'
         classes += ' indent-guide' if hasIndentGuide
         classes += ' invisible-character' if invisibles.space
@@ -154,7 +161,7 @@ class Token
 
         startIndex = match[0].length
 
-      if @hasTrailingWhitespace and match = TrailingWhitespaceRegex.exec(@value)
+      if @hasTrailingWhitespace and match = TrailingSpaceRegex.exec(@value)
         tokenIsOnlyWhitespace = match[0].length is @value.length
         classes = 'trailing-whitespace'
         classes += ' indent-guide' if hasIndentGuide and not @hasLeadingWhitespace and tokenIsOnlyWhitespace

src/tokenized-buffer.coffee

@@ -161,13 +161,26 @@ class TokenizedBuffer extends Model
     previousEndStack = @stackForRow(end) # used in spill detection below
     newTokenizedLines = @buildTokenizedLinesForRows(start, end + delta, @stackForRow(start - 1))
     _.spliceWithArray(@tokenizedLines, start, end - start + 1, newTokenizedLines)
-    newEndStack = @stackForRow(end + delta)
 
+    start = @retokenizeWhitespaceRowsIfIndentLevelChanged(start - 1, -1)
+    end = @retokenizeWhitespaceRowsIfIndentLevelChanged(newRange.end.row + 1, 1) - delta
+
+    newEndStack = @stackForRow(end + delta)
     if newEndStack and not _.isEqual(newEndStack, previousEndStack)
       @invalidateRow(end + delta + 1)
 
     @emit "changed", { start, end, delta, bufferChange: e }
 
+  retokenizeWhitespaceRowsIfIndentLevelChanged: (row, increment) ->
+    line = @tokenizedLines[row]
+    if line?.isOnlyWhitespace() and @indentLevelForRow(row) isnt line.indentLevel
+      while line?.isOnlyWhitespace()
+        @tokenizedLines[row] = @buildTokenizedTokenizedLineForRow(row, @stackForRow(row - 1))
+        row += increment
+        line = @tokenizedLines[row]
+
+    row - increment
+
   buildTokenizedLinesForRows: (startRow, endRow, startingStack) ->
     ruleStack = startingStack
     stopTokenizingAt = startRow + @chunkSize

src/tokenized-line.coffee

@@ -5,8 +5,8 @@ idCounter = 1
 module.exports =
 class TokenizedLine
   constructor: ({tokens, @lineEnding, @ruleStack, @startBufferColumn, @fold, @tabLength, @indentLevel}) ->
-    @tokens = @breakOutAtomicTokens(tokens)
     @startBufferColumn ?= 0
+    @tokens = @breakOutAtomicTokens(tokens)
     @text = @buildText()
     @bufferDelta = @buildBufferDelta()
 
@@ -124,8 +124,11 @@ class TokenizedLine
   breakOutAtomicTokens: (inputTokens) ->
     outputTokens = []
     breakOutLeadingSoftTabs = true
+    column = @startBufferColumn
     for token in inputTokens
-      outputTokens.push(token.breakOutAtomicTokens(@tabLength, breakOutLeadingSoftTabs)...)
+      newTokens = token.breakOutAtomicTokens(@tabLength, breakOutLeadingSoftTabs, column)
+      column += newToken.value.length for newToken in newTokens
+      outputTokens.push(newTokens...)
       breakOutLeadingSoftTabs = token.isOnlyWhitespace() if breakOutLeadingSoftTabs
     outputTokens
 
@@ -149,6 +152,14 @@ class TokenizedLine
       break
     false
 
+  isOnlyWhitespace: ->
+    if @text == ''
+      true
+    else
+      for token in @tokens
+        return false unless token.isOnlyWhitespace()
+      true
+
   tokenAtIndex: (index) ->
     @tokens[index]
 

src/workspace.coffee

@@ -46,6 +46,9 @@ class Workspace extends Model
 
   # Called by the Serializable mixin during deserialization
   deserializeParams: (params) ->
+    for packageName in params.packagesWithActiveGrammars ? []
+      atom.packages.getLoadedPackage(packageName)?.loadGrammarsSync()
+
     params.paneContainer = PaneContainer.deserialize(params.paneContainer)
     params
 
@@ -53,6 +56,21 @@ class Workspace extends Model
   serializeParams: ->
     paneContainer: @paneContainer.serialize()
     fullScreen: atom.isFullScreen()
+    packagesWithActiveGrammars: @getPackageNamesWithActiveGrammars()
+
+  getPackageNamesWithActiveGrammars: ->
+    packageNames = []
+    addGrammar = ({includedGrammarScopes, packageName}={}) ->
+      return unless packageName
+      # Prevent cycles
+      return if packageNames.indexOf(packageName) isnt -1
+
+      packageNames.push(packageName)
+      for scopeName in includedGrammarScopes ? []
+        addGrammar(atom.syntax.grammarForScopeName(scopeName))
+
+    addGrammar(editor.getGrammar()) for editor in @getEditors()
+    _.uniq(packageNames)
 
   editorAdded: (editor) ->
     @emit 'editor-created', editor

static/editor.less

@@ -151,6 +151,10 @@
   }
 }
 
+.editor .fold-marker {
+  cursor: default;
+}
+
 .editor .fold-marker:after {
   .icon(0.8em, inline);
   content: @ellipsis;
@@ -251,6 +255,12 @@
   width: 1px;
 }
 
+.editor .highlight {
+  background: none;
+  padding: 0;
+}
+
+.editor .highlight .region,
 .editor .selection .region {
   position: absolute;
   pointer-events: none;