Merge pull request #2865 from atom/ns-react-fix-width-remeasurement

Streamline character width remeasurement to hopefully avoid exceptions

.gitattributes

@@ -6,3 +6,9 @@ spec/fixtures/**/*.less text eol=lf
 spec/fixtures/**/*.css text eol=lf
 spec/fixtures/**/*.txt text eol=lf
 spec/fixtures/dir/**/* text eol=lf
+
+# Git 1.7 does not support **/* patterns
+spec/fixtures/css.css text eol=lf
+spec/fixtures/sample.js text eol=lf
+spec/fixtures/sample.less text eol=lf
+spec/fixtures/sample.txt text eol=lf

.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

CONTRIBUTING.md

@@ -11,6 +11,9 @@ propose changes to this document in a pull request.
 
 ## Submitting Issues
 
+* Check the [debugging guide](https://atom.io/docs/latest/debugging) for tips
+  on debugging. You might be able to find the cause of the problem and fix 
+  things yourself.
 * Include the version of Atom you are using and the OS.
 * Include screenshots and animated GIFs whenever possible; they are immensely
   helpful.

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.71.0"
   }
 }

build/Gruntfile.coffee

@@ -39,21 +39,25 @@ module.exports = (grunt) ->
   tmpDir = os.tmpdir()
   appName = if process.platform is 'darwin' then 'Atom.app' else 'Atom'
   buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
+  installDir = grunt.option('install-dir')
   atomShellDownloadDir = path.join(os.tmpdir(), 'atom-cached-atom-shells')
   symbolsDir = path.join(buildDir, 'Atom.breakpad.syms')
   shellAppDir = path.join(buildDir, appName)
   if process.platform is 'win32'
     contentsDir = shellAppDir
     appDir = path.join(shellAppDir, 'resources', 'app')
-    installDir = path.join(process.env.ProgramFiles, appName)
+    installDir ?= path.join(process.env.ProgramFiles, appName)
+    killCommand = 'taskkill /F /IM atom.exe'
   else if process.platform is 'darwin'
     contentsDir = path.join(shellAppDir, 'Contents')
     appDir = path.join(contentsDir, 'Resources', 'app')
-    installDir = path.join('/Applications', appName)
+    installDir ?= path.join('/Applications', appName)
+    killCommand = 'pkill -9 Atom'
   else
     contentsDir = shellAppDir
     appDir = path.join(shellAppDir, 'resources', 'app')
-    installDir = process.env.INSTALL_PREFIX ? '/usr/local'
+    installDir ?= process.env.INSTALL_PREFIX ? '/usr/local'
+    killCommand ='pkill -9 Atom'
 
   coffeeConfig =
     glob_to_multiple:
@@ -121,6 +125,8 @@ module.exports = (grunt) ->
 
     atom: {appDir, appName, symbolsDir, buildDir, contentsDir, installDir, shellAppDir}
 
+    docsOutputDir: 'docs/output/api'
+
     coffee: coffeeConfig
 
     less: lessConfig
@@ -210,7 +216,7 @@ module.exports = (grunt) ->
 
     shell:
       'kill-atom':
-        command: 'pkill -9 Atom'
+        command: killCommand
         options:
           stdout: false
           stderr: false

build/package.json

@@ -13,7 +13,7 @@
     "github-releases": "~0.2.0",
     "grunt": "~0.4.1",
     "grunt-cli": "~0.1.9",
-    "grunt-coffeelint": "git://github.com/atom/grunt-coffeelint.git",
+    "grunt-coffeelint": "git+https://github.com/atom/grunt-coffeelint.git",
     "grunt-contrib-csslint": "~0.1.2",
     "grunt-contrib-coffee": "~0.9.0",
     "grunt-contrib-less": "~0.8.0",
@@ -26,7 +26,7 @@
     "harmony-collections": "~0.3.8",
     "json-front-matter": "~0.1.3",
     "legal-eagle": "~0.4.0",
-    "minidump": "~0.6",
+    "minidump": "~0.7",
     "read-package-json": "1.1.8",
     "normalize-package-data": "0.2.12",
     "rcedit": "~0.1.2",

build/tasks/build-task.coffee

@@ -1,5 +1,6 @@
 fs = require 'fs'
 path = require 'path'
+_ = require 'underscore-plus'
 
 module.exports = (grunt) ->
   {cp, isAtomPackage, mkdir, rm} = require('./task-helpers')(grunt)
@@ -48,16 +49,32 @@ module.exports = (grunt) ->
       path.join('bootstrap', 'docs')
       path.join('bootstrap', 'examples')
       path.join('pegjs', 'examples')
-      # Add .* to avoid matching hunspell_dictionaries.
-      path.join('spellchecker', 'vendor', 'hunspell', '.*')
+      path.join('plist', 'tests')
       path.join('xmldom', 'test')
+      path.join('combined-stream', 'test')
+      path.join('delayed-stream', 'test')
+      path.join('domhandler', 'test')
+      path.join('fstream-ignore', 'test')
+      path.join('harmony-collections', 'test')
+      path.join('lru-cache', 'test')
+      path.join('minimatch', 'test')
+      path.join('normalize-package-data', 'test')
+      path.join('npm', 'test')
       path.join('jasmine-reporters', 'ext')
+      path.join('jasmine-node', 'node_modules', 'gaze')
       path.join('build', 'Release', 'obj.target')
+      path.join('build', 'Release', 'obj')
       path.join('build', 'Release', '.deps')
       path.join('vendor', 'apm')
       path.join('resources', 'mac')
       path.join('resources', 'win')
     ]
+    ignoredPaths = ignoredPaths.map (ignoredPath) -> _.escapeRegExp(ignoredPath)
+
+    # Add .* to avoid matching hunspell_dictionaries.
+    ignoredPaths.push "#{_.escapeRegExp(path.join('spellchecker', 'vendor', 'hunspell') + path.sep)}.*"
+    ignoredPaths.push "#{_.escapeRegExp(path.join('build', 'Release') + path.sep)}.*\\.pdb"
+
     # Hunspell dictionaries are only not needed on OS X.
     if process.platform is 'darwin'
       ignoredPaths.push path.join('spellchecker', 'vendor', 'hunspell_dictionaries')
@@ -79,6 +96,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/codesign-task.coffee

@@ -1,10 +1,12 @@
+path = require 'path'
+
 module.exports = (grunt) ->
   {spawn} = require('./task-helpers')(grunt)
 
   grunt.registerTask 'codesign', 'Codesign the app', ->
     done = @async()
 
-    if process.env.XCODE_KEYCHAIN
+    if process.platform is 'darwin' and process.env.XCODE_KEYCHAIN
       unlockKeychain (error) ->
         if error?
           done(error)
@@ -20,6 +22,15 @@ module.exports = (grunt) ->
     spawn {cmd, args}, (error) -> callback(error)
 
   signApp = (callback) ->
-    cmd = 'codesign'
-    args = ['-f', '-v', '-s', 'Developer ID Application: GitHub', grunt.config.get('atom.shellAppDir')]
-    spawn {cmd, args}, (error) -> callback(error)
+    switch process.platform
+      when 'darwin'
+        cmd = 'codesign'
+        args = ['-f', '-v', '-s', 'Developer ID Application: GitHub', grunt.config.get('atom.shellAppDir')]
+        spawn {cmd, args}, (error) -> callback(error)
+      when 'win32'
+        spawn {cmd: 'taskkill', args: ['/F', '/IM', 'atom.exe']}, ->
+          cmd = process.env.JANKY_SIGNTOOL ? 'signtool'
+          args = [path.join(grunt.config.get('atom.shellAppDir'), 'atom.exe')]
+          spawn {cmd, args}, (error) -> callback(error)
+      else
+        callback()

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/output-long-paths-task.coffee

@@ -0,0 +1,18 @@
+path = require 'path'
+
+module.exports = (grunt) ->
+  grunt.registerTask 'output-long-paths', 'Log long paths in the built application', ->
+    shellAppDir = grunt.config.get('atom.shellAppDir')
+
+    longPaths = []
+    grunt.file.recurse shellAppDir, (absolutePath, rootPath, relativePath, fileName) ->
+      if relativePath
+        fullPath = path.join(relativePath, fileName)
+      else
+        fullPath = fileName
+      longPaths.push(fullPath) if fullPath.length >= 200
+
+    longPaths.sort (longPath1, longPath2) -> longPath2.length - longPath1.length
+
+    longPaths.forEach (longPath) ->
+      grunt.log.error "#{longPath.length} character path: #{longPath}"

build/tasks/publish-build-task.coffee

@@ -8,11 +8,7 @@ GitHub = require 'github-releases'
 request = require 'request'
 
 grunt = null
-maxReleases = 10
-assets = [
-  {assetName: 'atom-mac.zip', sourceName: 'Atom.app'}
-  {assetName: 'atom-mac-symbols.zip', sourceName: 'Atom.breakpad.syms'}
-]
+
 commitSha = process.env.JANKY_SHA1
 token = process.env.ATOM_ACCESS_TOKEN
 defaultHeaders =
@@ -23,13 +19,20 @@ module.exports = (gruntObject) ->
   grunt = gruntObject
 
   grunt.registerTask 'publish-build', 'Publish the built app', ->
-    return unless process.platform is 'darwin'
     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?
@@ -38,23 +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} #{sourcePath}"
+    else
+      zipCommand = "zip -r --symlinks #{assetName} #{sourcePath}"
     options = {cwd: directory, maxBuffer: Infinity}
-    child_process.exec "zip -r --symlinks #{assetName} #{sourceName}", options, (error, stdout, stderr) ->
-      if error?
-        logError("Zipping #{sourceName} failed", error, stderr)
+    child_process.exec zipCommand, options, (error, stdout, stderr) ->
+      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) ->
@@ -119,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)

build/tasks/spec-task.coffee

@@ -39,7 +39,8 @@ module.exports = (grunt) ->
       grunt.verbose.writeln "Launching #{path.basename(packagePath)} specs."
       spawn options, (error, results, code) ->
         if process.platform is 'win32'
-          process.stderr.write(fs.readFileSync(path.join(packagePath, 'ci.log')))
+          if error
+            process.stderr.write(fs.readFileSync(path.join(packagePath, 'ci.log')))
           fs.unlinkSync(path.join(packagePath, 'ci.log'))
 
         failedPackages.push path.basename(packagePath) if error
@@ -52,9 +53,7 @@ module.exports = (grunt) ->
       continue unless isAtomPackage(packagePath)
       packageSpecQueue.push(packagePath)
 
-    # TODO: Restore concurrency on Windows
-    packageSpecQueue.concurrency = 1 unless process.platform is 'win32'
-
+    packageSpecQueue.concurrency = 1
     packageSpecQueue.drain = -> callback(null, failedPackages)
 
   runCoreSpecs = (callback) ->
@@ -77,7 +76,7 @@ module.exports = (grunt) ->
 
     spawn options, (error, results, code) ->
       if process.platform is 'win32'
-        process.stderr.write(fs.readFileSync('ci.log'))
+        process.stderr.write(fs.readFileSync('ci.log')) if error
         fs.unlinkSync('ci.log')
       else
         # TODO: Restore concurrency on Windows
@@ -105,8 +104,8 @@ module.exports = (grunt) ->
 
       grunt.log.error("[Error]".red + " #{failures.join(', ')} spec(s) failed") if failures.length > 0
 
-      # TODO: Mark the build as green on Windows until specs pass.
-      if process.platform is 'darwin'
+      if process.platform is 'win32' and process.env.JANKY_SHA1
+        # Package specs are still flaky on Windows CI
+        done(!coreSpecFailed)
+      else
         done(!coreSpecFailed and failedPackages.length == 0)
-      else if process.platform is 'win32'
-        done(true)

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

@@ -5,8 +5,15 @@ Ubuntu LTS 12.04 64-bit is the recommended platform.
 ## Requirements
 
   * OS with 64-bit or 32-bit architecture
+  * C++ toolchain
+    * on Ubuntu/Debian: `sudo apt-get install build-essential`
+    * on Fedora: `sudo yum --assumeyes install make gcc gcc-c++ glibc-devel`
   * [node.js](http://nodejs.org/download/) v0.10.x
-  * [npm](http://www.npmjs.org/) v1.4.x  
+    * [Ubuntu/Debian/Mint instructions](https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager#ubuntu-mint-elementary-os)
+    * [Fedora instructions](https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager#fedora)
+  * [npm](http://www.npmjs.org/) v1.4.x
+    * `npm` comes with node.js so no explicit installation is needed here.
+    * You can check `npm` 1.4 or above is installed by running `npm -v`.
   * libgnome-keyring-dev
     * on Ubuntu/Debian: `sudo apt-get install libgnome-keyring-dev`
     * on Fedora: `sudo yum --assumeyes install libgnome-keyring-devel`
@@ -14,7 +21,9 @@ Ubuntu LTS 12.04 64-bit is the recommended platform.
   * `npm config set python /usr/bin/python2 -g` to ensure that gyp uses Python 2
     * This command may require `sudo` depending on how you have
       [configured npm](https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager#ubuntu-mint-elementary-os).
-
+  * Git
+    * on Ubuntu/Debian: `sudo apt-get install git`
+    * on Fedora: `sudo yum install git-core`
 
 ## Instructions
 
@@ -52,5 +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.
+* 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
@@ -51,5 +54,13 @@ fix this, you probably need to fiddle with your system PATH.
   * Try moving the repository to `C:\atom`. Most likely, the path is too long.
     See [issue #2200](https://github.com/atom/atom/issues/2200).
 
+* `error MSB4025: The project file could not be loaded. Invalid character in the given encoding.`
+
+  * These can occur because your home directory (`%USERPROFILE%`) has non-ASCII
+    characters in it. This is a bug in [gyp](https://code.google.com/p/gyp/)
+    which is used to build native node modules and there is no known workaround.
+    * https://github.com/TooTallNate/node-gyp/issues/297
+    * https://code.google.com/p/gyp/issues/detail?id=393
+
 ### Windows build error reports in atom/atom
 * Use [this search](https://github.com/atom/atom/search?q=label%3Abuild-error+label%3Awindows&type=Issues) to get a list of reports about build errors on Windows.

docs/customizing-atom.md

@@ -169,7 +169,7 @@ For example, to change the color of the cursor, you could add the following
 rule to your _~/.atom/styles.less_ file:
 
 ```less
-.editor .cursor {
+.editor.is-focused .cursor {
   border-color: pink;
 }
 ```

docs/debugging.md

@@ -1,6 +1,13 @@
 # Debugging
 
-Atom provides several tools to help you understand unexpected behavior and debug problems. This guide describes some of those tools and a few approaches to help you debug and provide more helpful information when [submitting issues].
+Atom provides several tools to help you understand unexpected behavior and debug problems. This guide describes some of those tools and a few approaches to help you debug and provide more helpful information when [submitting issues]:
+
+* [Update to the latest version](#update-to-the-latest-version)
+* [Check Atom and package settings](#check-atom-and-package-settings) 
+* [Check the keybindings](#check-the-keybindings)
+* [Check if the problem shows up in safe mode](#check-if-the-problem-shows-up-in-safe-mode)
+* [Check your config files](#check-your-config-files)
+* [Check for errors in the developer tools](#check-for-errors-in-the-developer-tools)
 
 ## Update to the latest version
 

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.102.0",
+  "version": "0.112.0",
   "description": "A hackable text editor for the 21st Century.",
   "main": "./src/browser/main.js",
   "repository": {
@@ -17,22 +17,22 @@
       "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
     }
   ],
-  "atomShellVersion": "0.13.0",
+  "atomShellVersion": "0.13.3",
   "dependencies": {
     "async": "0.2.6",
-    "atom-keymap": "^0.26.0",
+    "atom-keymap": "^0.27.0",
     "bootstrap": "git+https://github.com/atom/bootstrap.git#6af81906189f1747fd6c93479e3d998ebe041372",
     "clear-cut": "0.4.0",
     "coffee-script": "1.7.0",
     "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",
     "git-utils": "^1.3",
-    "grim": "0.10.0",
+    "grim": "0.11.0",
     "guid": "0.0.10",
     "jasmine-tagged": "^1.1.2",
     "less-cache": "0.12.0",
@@ -47,95 +47,96 @@
     "random-words": "0.0.1",
     "react-atom-fork": "^0.10.0",
     "reactionary-atom-fork": "^0.9.0",
-    "runas": "^0.5",
-    "scandal": "0.15.2",
+    "runas": "0.5.4",
+    "scandal": "0.16.0",
     "scoped-property-store": "^0.9.0",
     "scrollbar-style": "^0.4.0",
     "season": "^1.0.2",
     "semver": "1.1.4",
     "serializable": "^1",
-    "space-pen": "3.3.0",
-    "temp": "0.5.0",
-    "text-buffer": "^2.2.2",
+    "space-pen": "3.2.0",
+    "temp": "0.7.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.31.0",
+    "atom-dark-syntax": "0.19.0",
+    "atom-dark-ui": "0.32.0",
+    "atom-light-syntax": "0.20.0",
+    "atom-light-ui": "0.28.0",
+    "base16-tomorrow-dark-theme": "0.19.0",
+    "solarized-dark-syntax": "0.20.0",
+    "solarized-light-syntax": "0.11.0",
+    "archive-view": "0.33.0",
     "autocomplete": "0.28.0",
     "autoflow": "0.17.0",
-    "autosave": "0.13.0",
-    "background-tips": "0.14.0",
-    "bookmarks": "0.22.0",
-    "bracket-matcher": "0.43.0",
-    "command-palette": "0.21.0",
-    "deprecation-cop": "0.6.0",
+    "autosave": "0.14.0",
+    "background-tips": "0.15.0",
+    "bookmarks": "0.27.0",
+    "bracket-matcher": "0.48.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.113.0",
-    "fuzzy-finder": "0.54.0",
-    "git-diff": "0.28.0",
-    "go-to-line": "0.22.0",
+    "find-and-replace": "0.125.0",
+    "fuzzy-finder": "0.56.0",
+    "git-diff": "0.35.0",
+    "go-to-line": "0.23.0",
     "grammar-selector": "0.27.0",
-    "image-view": "0.34.0",
+    "image-view": "0.36.0",
     "keybinding-resolver": "0.18.0",
-    "link": "0.22.0",
-    "markdown-preview": "0.74.0",
+    "link": "0.24.0",
+    "markdown-preview": "0.90.0",
     "metrics": "0.32.0",
-    "open-on-github": "0.28.0",
-    "package-generator": "0.30.0",
-    "release-notes": "0.32.0",
-    "settings-view": "0.119.0",
-    "snippets": "0.45.0",
-    "spell-check": "0.36.0",
-    "status-bar": "0.40.0",
+    "open-on-github": "0.29.0",
+    "package-generator": "0.31.0",
+    "release-notes": "0.33.0",
+    "settings-view": "0.132.0",
+    "snippets": "0.47.0",
+    "spell-check": "0.38.0",
+    "status-bar": "0.41.0",
     "styleguide": "0.29.0",
-    "symbols-view": "0.55.0",
-    "tabs": "0.41.0",
-    "timecop": "0.19.0",
-    "tree-view": "0.98.0",
+    "symbols-view": "0.59.0",
+    "tabs": "0.44.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.16.0",
-    "language-coffee-script": "0.22.0",
+    "welcome": "0.17.0",
+    "whitespace": "0.23.0",
+    "wrap-guide": "0.21.0",
+
+    "language-c": "0.21.0",
+    "language-coffee-script": "0.24.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.26.0",
+    "language-java": "0.11.0",
+    "language-javascript": "0.33.0",
     "language-json": "0.8.0",
-    "language-less": "0.9.0",
+    "language-less": "0.12.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.27.0",
-    "language-ruby-on-rails": "0.14.0",
+    "language-ruby": "0.32.0",
+    "language-ruby-on-rails": "0.15.0",
     "language-sass": "0.13.0",
     "language-shellscript": "0.8.0",
     "language-source": "0.7.0",
-    "language-sql": "0.8.0",
+    "language-sql": "0.9.0",
     "language-text": "0.6.0",
     "language-todo": "0.10.0",
     "language-toml": "0.12.0",
-    "language-xml": "0.14.0",
-    "language-yaml": "0.6.0"
+    "language-xml": "0.15.0",
+    "language-yaml": "0.11.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;

script/bootstrap

@@ -10,6 +10,8 @@ function executeCommands(commands, done, index) {
   index = (index == undefined ? 0 : index);
   if (index < commands.length) {
     var command = commands[index];
+    if (command.message)
+      console.log(command.message);
     var options = null;
     if (typeof command !== 'string') {
       options = command.options;
@@ -24,27 +26,41 @@ function executeCommands(commands, done, index) {
 function bootstrap() {
   var apmInstallPath = path.resolve(__dirname, '..', 'apm');
   if (!fs.existsSync(apmInstallPath))
-  fs.mkdirSync(apmInstallPath);
+    fs.mkdirSync(apmInstallPath);
   if (!fs.existsSync(path.join(apmInstallPath, 'node_modules')))
-  fs.mkdirSync(path.join(apmInstallPath, 'node_modules'));
+    fs.mkdirSync(path.join(apmInstallPath, 'node_modules'));
 
   var apmPath = path.resolve(__dirname, '..', 'apm', 'node_modules', 'atom-package-manager', 'bin', 'apm')
-  var apmFlags = process.env.JANKY_SHA1 || process.argv.indexOf('--no-color') !== -1 ? '--no-color' : '';
+  var apmFlags = process.env.JANKY_SHA1 || process.argv.indexOf('--no-color') !== -1 ? ' --no-color' : '';
 
   var npmPath = path.resolve(__dirname, '..', 'build', 'node_modules', '.bin', 'npm');
   var initialNpmCommand = fs.existsSync(npmPath) ? npmPath : 'npm';
   var npmFlags = ' --userconfig=' + path.resolve('.npmrc') + ' ';
 
-  var packagesToDedupe = ['fs-plus', 'humanize-plus', 'oniguruma', 'roaster', 'season'];
-  var echoNewLine = process.platform == 'win32' ? 'echo.' : 'echo';
+  var packagesToDedupe = ['fs-plus', 'humanize-plus', 'oniguruma', 'roaster', 'season', 'grim'];
+
+  var buildInstallCommand = initialNpmCommand + npmFlags + 'install';
+  var buildInstallOptions = {cwd: path.resolve(__dirname, '..', 'build')};
+  var apmInstallCommand = npmPath + npmFlags + 'install';
+  var apmInstallOptions = {cwd: apmInstallPath};
+  var moduleInstallCommand = apmPath + ' install' + apmFlags;
+  var dedupeCommand = apmPath + ' dedupe' + apmFlags;
+
+  if (process.argv.indexOf('--no-quiet') === -1) {
+    buildInstallCommand  += ' --quiet';
+    apmInstallCommand    += ' --quiet';
+    moduleInstallCommand += ' --quiet';
+    dedupeCommand        += ' --quiet';
+    buildInstallOptions.ignoreStdout = true;
+    apmInstallOptions.ignoreStdout = true;
+  }
 
   var commands = [
-  {command: initialNpmCommand + npmFlags + 'install --quiet', options: {cwd: path.resolve(__dirname, '..', 'build'), ignoreStdout: true}},
-  {command: npmPath + npmFlags + 'install --quiet', options: {cwd: apmInstallPath, ignoreStdout: true}},
-  echoNewLine,
-  apmPath + ' clean ' + apmFlags,
-  apmPath + ' install --quiet ' + apmFlags,
-  apmPath + ' dedupe --quiet ' + apmFlags + ' ' + packagesToDedupe.join(' '),
+    {command: buildInstallCommand, message: 'Installing build modules...', options: buildInstallOptions},
+    {command: apmInstallCommand, message: 'Installing apm...', options: apmInstallOptions},
+    apmPath + ' clean' + apmFlags,
+    moduleInstallCommand,
+    dedupeCommand + ' ' + packagesToDedupe.join(' '),
   ];
 
   process.chdir(path.dirname(__dirname));

script/cibuild

@@ -19,12 +19,18 @@ function loadEnvironmentVariables(filePath) {
       var value = parts[1].trim().substr(1, parts[1].length - 2);
       process.env[key] = value;
     }
-  } catch(error) { }
+  } catch(error) {
+    console.error("Failed to load environment variables: " + filePath, error.code);
+  }
 }
 
 function readEnvironmentVariables() {
-  loadEnvironmentVariables('/var/lib/jenkins/config/atomcredentials')
-  loadEnvironmentVariables('/var/lib/jenkins/config/xcodekeychain')
+  if (process.platform === 'win32')
+    loadEnvironmentVariables(path.resolve('/jenkins/config/atomcredentials'));
+  else {
+    loadEnvironmentVariables('/var/lib/jenkins/config/atomcredentials');
+    loadEnvironmentVariables('/var/lib/jenkins/config/xcodekeychain');
+  }
 }
 
 readEnvironmentVariables();

script/install-cli

@@ -1,10 +0,0 @@
-#!/usr/bin/env coffee
-
-path = require 'path'
-CommandInstaller = require '../src/command-installer'
-
-callback = (error) ->
-  console.warn error.message if error?
-
-CommandInstaller.installAtomCommand(path.resolve(__dirname, '..'), callback)
-CommandInstaller.installApmCommand(path.resolve(__dirname, '..'), callback)

script/utils/verify-requirements.js

@@ -11,8 +11,15 @@ module.exports = function(cb) {
       return;
     }
 
-    verifyPython27(function(error, pythonSuccessMessage) {
-      cb(error, (nodeSuccessMessage + "\n" + pythonSuccessMessage).trim());
+    verifyNpm(function(error, npmSuccessMessage) {
+      if (error) {
+        cb(error);
+        return;
+      }
+
+      verifyPython27(function(error, pythonSuccessMessage) {
+        cb(error, (nodeSuccessMessage + "\n" + npmSuccessMessage + "\n" + pythonSuccessMessage).trim());
+      });
     });
   });
 
@@ -32,6 +39,31 @@ function verifyNode(cb) {
   }
 }
 
+function verifyNpm(cb) {
+  var localNpmPath = path.resolve(__dirname, '..', '..', 'build', 'node_modules', '.bin', 'npm');
+  if (process.platform === 'win32')
+    localNpmPath += ".cmd";
+
+  var npmCommand = fs.existsSync(localNpmPath) ? localNpmPath : 'npm';
+  if (npmCommand === 'npm' && process.platform === 'win32')
+    npmCommand += ".cmd";
+
+  childProcess.execFile(npmCommand, ['-v'], { env: process.env }, function(err, stdout) {
+    if (err)
+      return cb("npm 1.4 is required to build Atom. An error (" + err + ") occured when checking the version.");
+
+    var npmVersion = stdout ? stdout.trim() : '';
+    var versionArray = npmVersion.split('.');
+    var npmMajorVersion = +versionArray[0] || 0;
+    var npmMinorVersion = +versionArray[1] || 0;
+    if (npmMajorVersion === 1 && npmMinorVersion < 4)
+      cb("npm v1.4+ is required to build Atom.");
+    else
+      cb(null, "npm: v" + npmVersion);
+  });
+}
+
+
 function verifyPython27(cb) {
   if (process.platform == 'win32') {
     if (!pythonExecutable) {

spec/atom-reporter.coffee

@@ -2,6 +2,7 @@ path = require 'path'
 _ = require 'underscore-plus'
 {convertStackTrace} = require 'coffeestack'
 {View, $, $$} = require '../src/space-pen-extensions'
+grim = require 'grim'
 
 sourceMaps = {}
 formatStackTrace = (spec, message='', stackTrace) ->
@@ -52,6 +53,11 @@ class AtomReporter extends View
         @div outlet: "message", class: 'message'
       @div outlet: "results", class: 'results'
 
+      @div outlet: "deprecations", class: 'status alert alert-warning', style: 'display: none', =>
+        @span outlet: 'deprecationStatus', '0 deprecations'
+        @div class: 'deprecation-toggle'
+      @div outlet: 'deprecationList', class: 'deprecation-list'
+
   startedAt: null
   runningSpecCount: 0
   completeSpecCount: 0
@@ -59,6 +65,7 @@ class AtomReporter extends View
   failedCount: 0
   skippedCount: 0
   totalSpecCount: 0
+  deprecationCount: 0
   @timeoutId: 0
 
   reportRunnerStarting: (runner) ->
@@ -88,6 +95,29 @@ class AtomReporter extends View
   reportSpecStarting: (spec) ->
     @specStarted(spec)
 
+  addDeprecations: (spec) ->
+    deprecations = grim.getDeprecations()
+    @deprecationCount += deprecations.length
+    @deprecations.show() if @deprecationCount > 0
+    if @deprecationCount is 1
+      @deprecationStatus.text("1 deprecation")
+    else
+      @deprecationStatus.text("#{@deprecationCount} deprecations")
+
+    for deprecation in deprecations
+      @deprecationList.append $$ ->
+        @div class: 'padded', =>
+          @div class: 'result-message fail deprecation-message', deprecation.message
+
+          for stack in deprecation.stacks
+            fullStack = stack.map ({functionName, location}) ->
+              if functionName is '<unknown>'
+                "  at #{location}"
+              else
+                "  at #{functionName} (#{location})"
+            @pre class: 'stack-trace padded', formatStackTrace(spec, deprecation.message, fullStack.join('\n'))
+    grim.clearDeprecations()
+
   handleEvents: ->
     $(document).on "click", ".spec-toggle", ({currentTarget}) =>
       element = $(currentTarget)
@@ -96,6 +126,13 @@ class AtomReporter extends View
       element.toggleClass('folded')
       false
 
+    $(document).on "click", ".deprecation-toggle", ({currentTarget}) =>
+      element = $(currentTarget)
+      deprecationList = $(document).find('.deprecation-list')
+      deprecationList.toggle()
+      element.toggleClass('folded')
+      false
+
   updateSpecCounts: ->
     if @skippedCount
       specCount = "#{@completeSpecCount - @skippedCount}/#{@totalSpecCount - @skippedCount} (#{@skippedCount} skipped)"
@@ -175,6 +212,7 @@ class AtomReporter extends View
       specView = new SpecResultView(spec)
       specView.attach()
       @failedCount++
+    @addDeprecations(spec)
 
 class SuiteResultView extends View
   @content: ->

spec/atom-spec.coffee

@@ -535,3 +535,18 @@ describe "the `atom` global", ->
       expect(atom.isReleasedVersion()).toBe true
       version = '36b5518'
       expect(atom.isReleasedVersion()).toBe false
+
+  describe "window:update-available", ->
+    it "is triggered when the auto-updater sends the update-downloaded event", ->
+      updateAvailableHandler = jasmine.createSpy("update-available-handler")
+      atom.workspaceView.on 'window:update-available', updateAvailableHandler
+      autoUpdater = require('remote').require('auto-updater')
+      autoUpdater.emit 'update-downloaded', null, "notes", "version"
+
+      waitsFor ->
+        updateAvailableHandler.callCount > 0
+
+      runs ->
+        [event, version, notes] = updateAvailableHandler.mostRecentCall.args
+        expect(notes).toBe 'notes'
+        expect(version).toBe 'version'

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)
@@ -206,6 +215,19 @@ describe "DisplayBuffer", ->
         displayBuffer.setEditorWidthInChars(-1)
         expect(displayBuffer.editorWidthInChars).not.toBe -1
 
+    it "sets ::scrollLeft to 0 and keeps it there when soft wrapping is enabled", ->
+      displayBuffer.setDefaultCharWidth(10)
+      displayBuffer.setWidth(50)
+      displayBuffer.manageScrollPosition = true
+
+      displayBuffer.setSoftWrap(false)
+      displayBuffer.setScrollLeft(Infinity)
+      expect(displayBuffer.getScrollLeft()).toBeGreaterThan 0
+      displayBuffer.setSoftWrap(true)
+      expect(displayBuffer.getScrollLeft()).toBe 0
+      displayBuffer.setScrollLeft(10)
+      expect(displayBuffer.getScrollLeft()).toBe 0
+
   describe "primitive folding", ->
     beforeEach ->
       displayBuffer.destroy()
@@ -315,6 +337,14 @@ 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)
+
+          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})
@@ -624,6 +654,19 @@ describe "DisplayBuffer", ->
       buffer.delete([[6, 0], [6, 65]])
       expect(displayBuffer.getMaxLineLength()).toBe 62
 
+    it "correctly updates the location of the longest screen line when changes occur", ->
+      expect(displayBuffer.getLongestScreenRow()).toBe 6
+      buffer.delete([[0, 0], [2, 0]])
+      expect(displayBuffer.getLongestScreenRow()).toBe 4
+      buffer.delete([[4, 0], [5, 0]])
+
+      expect(displayBuffer.getLongestScreenRow()).toBe 1
+      expect(displayBuffer.getMaxLineLength()).toBe 62
+
+      buffer.delete([[2, 0], [4, 0]])
+      expect(displayBuffer.getLongestScreenRow()).toBe 1
+      expect(displayBuffer.getMaxLineLength()).toBe 62
+
   describe "::destroy()", ->
     it "unsubscribes all display buffer markers from their underlying buffer marker (regression)", ->
       marker = displayBuffer.markBufferPosition([12, 2])
@@ -912,6 +955,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 +1029,45 @@ 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", ->
+    [marker, decoration, decorationParams] = []
+    beforeEach ->
+      marker = displayBuffer.markBufferRange([[2, 13], [3, 15]])
+      decorationParams = {type: 'gutter', class: 'one'}
+      decoration = displayBuffer.decorateMarker(marker, decorationParams)
+
+    it "can add decorations associated with markers and remove them", ->
+      expect(decoration).toBeDefined()
+      expect(decoration.getParams()).toBe decorationParams
+      expect(displayBuffer.decorationForId(decoration.id)).toBe decoration
+      expect(displayBuffer.decorationsForScreenRowRange(2, 3)[marker.id][0]).toBe decoration
+
+      decoration.destroy()
+      expect(displayBuffer.decorationsForScreenRowRange(2, 3)[marker.id]).not.toBeDefined()
+      expect(displayBuffer.decorationForId(decoration.id)).not.toBeDefined()
+
+    it "will not fail if the decoration is removed twice", ->
+      decoration.destroy()
+      decoration.destroy()
+      expect(displayBuffer.decorationForId(decoration.id)).not.toBeDefined()
+
+    describe "when a decoration is updated via Decoration::update()", ->
+      it "emits an 'updated' event containing the new and old params", ->
+        decoration.on 'updated', updatedSpy = jasmine.createSpy()
+        decoration.update type: 'gutter', class: 'two'
+
+        {oldParams, newParams} = updatedSpy.mostRecentCall.args[0]
+        expect(oldParams).toEqual decorationParams
+        expect(newParams).toEqual type: 'gutter', class: 'two', id: decoration.id
+
   describe "::setScrollTop", ->
     beforeEach ->
       displayBuffer.manageScrollPosition = true
@@ -997,17 +1109,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

@@ -785,6 +785,19 @@ describe "Editor", ->
         editor.moveCursorLeft()
         expect(editor.getScrollLeft()).toBe 58 * 10
 
+      it "scrolls down when inserting lines makes the document longer than the editor's height", ->
+        editor.setCursorScreenPosition([13, Infinity])
+        editor.insertNewline()
+        expect(editor.getScrollBottom()).toBe 14 * 10
+        editor.insertNewline()
+        expect(editor.getScrollBottom()).toBe 15 * 10
+
+      it "autoscrolls to the cursor when it moves due to undo", ->
+        editor.insertText('abc')
+        editor.setScrollTop(Infinity)
+        editor.undo()
+        expect(editor.getScrollTop()).toBe 0
+
   describe "selection", ->
     selection = null
 
@@ -863,6 +876,30 @@ describe "Editor", ->
         expect(selection1.getScreenRange()).toEqual [[3, 0], [4, 5]]
         expect(selection2.getScreenRange()).toEqual [[5, 6], [6, 2]]
 
+    describe ".selectToBeginningOfNextParagraph()", ->
+      it "selects from the cursor to first line of the next paragraph", ->
+        editor.setSelectedBufferRange([[3, 0], [4, 5]])
+        editor.addCursorAtScreenPosition([5, 6])
+        editor.selectToScreenPosition([6, 2])
+
+        editor.selectToBeginningOfNextParagraph()
+
+        selections = editor.getSelections()
+        expect(selections.length).toBe 1
+        expect(selections[0].getScreenRange()).toEqual [[3, 0], [10, 0]]
+
+    describe ".selectToBeginningOfPreviousParagraph()", ->
+      it "selects from the cursor to the first line of the pevious paragraph", ->
+        editor.setSelectedBufferRange([[3, 0], [4, 5]])
+        editor.addCursorAtScreenPosition([5, 6])
+        editor.selectToScreenPosition([6, 2])
+
+        editor.selectToBeginningOfPreviousParagraph()
+
+        selections = editor.getSelections()
+        expect(selections.length).toBe 1
+        expect(selections[0].getScreenRange()).toEqual [[0, 0], [5, 6]]
+
       it "merges selections if they intersect, maintaining the directionality of the last selection", ->
         editor.setCursorScreenPosition([4, 10])
         editor.selectToScreenPosition([5, 27])
@@ -1172,6 +1209,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)
@@ -1196,6 +1234,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", ->
@@ -1443,6 +1496,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", ->
@@ -1622,7 +1686,7 @@ describe "Editor", ->
         editor.setCursorBufferPosition([9,2])
         editor.insertNewline()
         expect(editor.lineForBufferRow(10)).toBe '  };'
-        
+
     describe ".backspace()", ->
       describe "when there is a single cursor", ->
         changeScreenRangeHandler = null
@@ -1807,6 +1871,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", ->
@@ -2234,6 +2324,15 @@ describe "Editor", ->
           editor.outdentSelectedRows()
           expect(buffer.lineForRow(0)).toBe "var quicksort = function () {"
 
+        it "outdents only up to the first non-space non-tab character", ->
+          editor.insertText(' \tfoo\t ')
+          editor.outdentSelectedRows()
+          expect(buffer.lineForRow(0)).toBe "\tfoo\t var quicksort = function () {"
+          editor.outdentSelectedRows()
+          expect(buffer.lineForRow(0)).toBe "foo\t var quicksort = function () {"
+          editor.outdentSelectedRows()
+          expect(buffer.lineForRow(0)).toBe "foo\t var quicksort = function () {"
+
       describe "when one line is selected", ->
         it "outdents line and retains editor", ->
           editor.setSelectedBufferRange([[1,4], [1,14]])
@@ -3187,21 +3286,60 @@ describe "Editor", ->
       expect(editor.getScrollRight()).toBe (9 + editor.getHorizontalScrollMargin()) * 10
 
   describe ".pageUp/Down()", ->
-    it "scrolls one screen height up or down", ->
+    it "scrolls one screen height up or down and moves the cursor one page length", ->
       editor.manageScrollPosition = true
 
       editor.setLineHeightInPixels(10)
       editor.setHeight(50)
       expect(editor.getScrollHeight()).toBe 130
+      expect(editor.getCursorBufferPosition().row).toBe 0
 
       editor.pageDown()
       expect(editor.getScrollTop()).toBe 50
+      expect(editor.getCursorBufferPosition().row).toBe 5
 
       editor.pageDown()
       expect(editor.getScrollTop()).toBe 80
+      expect(editor.getCursorBufferPosition().row).toBe 10
 
       editor.pageUp()
       expect(editor.getScrollTop()).toBe 30
+      expect(editor.getCursorBufferPosition().row).toBe 5
 
       editor.pageUp()
       expect(editor.getScrollTop()).toBe 0
+      expect(editor.getCursorBufferPosition().row).toBe 0
+
+  describe ".selectPageUp/Down()", ->
+    it "selects one screen height of text up or down", ->
+      editor.manageScrollPosition = true
+
+      editor.setLineHeightInPixels(10)
+      editor.setHeight(50)
+      expect(editor.getScrollHeight()).toBe 130
+      expect(editor.getCursorBufferPosition().row).toBe 0
+
+      editor.selectPageDown()
+      expect(editor.getScrollTop()).toBe 30
+      expect(editor.getSelectedBufferRanges()).toEqual [[[0,0], [5,0]]]
+
+      editor.selectPageDown()
+      expect(editor.getScrollTop()).toBe 80
+      expect(editor.getSelectedBufferRanges()).toEqual [[[0,0], [10,0]]]
+
+      editor.selectPageDown()
+      expect(editor.getScrollTop()).toBe 80
+      expect(editor.getSelectedBufferRanges()).toEqual [[[0,0], [12,2]]]
+
+      editor.moveCursorToBottom()
+      editor.selectPageUp()
+      expect(editor.getScrollTop()).toBe 50
+      expect(editor.getSelectedBufferRanges()).toEqual [[[7,0], [12,2]]]
+
+      editor.selectPageUp()
+      expect(editor.getScrollTop()).toBe 0
+      expect(editor.getSelectedBufferRanges()).toEqual [[[2,0], [12,2]]]
+
+      editor.selectPageUp()
+      expect(editor.getScrollTop()).toBe 0
+      expect(editor.getSelectedBufferRanges()).toEqual [[[0,0], [12,2]]]

spec/editor-view-spec.coffee

@@ -10,6 +10,8 @@ describe "EditorView", ->
   [buffer, editorView, editor, cachedEditor, cachedLineHeight, cachedCharWidth, fart] = []
 
   beforeEach ->
+    atom.config.set 'core.useReactEditor', false
+
     waitsForPromise ->
       atom.workspace.open('sample.js').then (o) -> editor = o
 
@@ -1609,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
@@ -1618,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)
@@ -1634,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"
@@ -2080,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/language-mode-spec.coffee

@@ -52,12 +52,17 @@ describe "LanguageMode", ->
         languageMode.toggleLineCommentsForBufferRows(0, 0)
         expect(buffer.lineForRow(0)).toBe "  // "
 
-        buffer.setText ('    a\n  \n    b')
+        buffer.setText('    a\n  \n    b')
         languageMode.toggleLineCommentsForBufferRows(0, 2)
         expect(buffer.lineForRow(0)).toBe "    // a"
         expect(buffer.lineForRow(1)).toBe "    // "
         expect(buffer.lineForRow(2)).toBe "    // b"
 
+        buffer.setText('    \n    // var i;')
+        languageMode.toggleLineCommentsForBufferRows(0, 1)
+        expect(buffer.lineForRow(0)).toBe '    '
+        expect(buffer.lineForRow(1)).toBe '    var i;'
+
     describe ".rowRangeForCodeFoldAtBufferRow(bufferRow)", ->
       it "returns the start/end rows of the foldable region starting at the given row", ->
         expect(languageMode.rowRangeForCodeFoldAtBufferRow(0)).toEqual [0, 12]

spec/pane-container-spec.coffee

@@ -16,6 +16,7 @@ describe "PaneContainer", ->
       containerA = new PaneContainer(root: pane1A)
       pane2A = pane1A.splitRight(items: [new Item])
       pane3A = pane2A.splitDown(items: [new Item])
+      pane3A.focus()
 
     it "preserves the focused pane across serialization", ->
       expect(pane3A.focused).toBe true

spec/pane-spec.coffee

@@ -439,10 +439,11 @@ describe "Pane", ->
           expect(column.orientation).toBe 'vertical'
           expect(column.children).toEqual [pane1, pane3, pane2]
 
-    it "sets up the new pane to be focused", ->
-      expect(pane1.focused).toBe false
+    it "activates the new pane", ->
+      expect(pane1.isActive()).toBe true
       pane2 = pane1.splitRight()
-      expect(pane2.focused).toBe true
+      expect(pane1.isActive()).toBe false
+      expect(pane2.isActive()).toBe true
 
   describe "::destroy()", ->
     [container, pane1, pane2] = []

spec/pane-view-spec.coffee

@@ -199,6 +199,7 @@ describe "PaneView", ->
 
       it "focuses the next pane", ->
         container.attachToDom()
+        pane2.activate()
         expect(pane.hasFocus()).toBe false
         expect(pane2.hasFocus()).toBe true
         pane2Model.destroy()

spec/project-spec.coffee

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

spec/space-pen-extensions-spec.coffee

@@ -24,19 +24,6 @@ describe "SpacePen extensions", ->
       expect(eventHandler).toHaveBeenCalled()
 
   describe "tooltips", ->
-    describe "humanizeKeystrokes", ->
-      humanizeKeystrokes = $.fn.setTooltip.humanizeKeystrokes
-
-      it "replaces single keystroke", ->
-        expect(humanizeKeystrokes('cmd-O')).toEqual '⌘⇧O'
-        expect(humanizeKeystrokes('cmd-shift-up')).toEqual '⌘⇧↑'
-        expect(humanizeKeystrokes('cmd-option-down')).toEqual '⌘⌥↓'
-        expect(humanizeKeystrokes('cmd-option-left')).toEqual '⌘⌥←'
-        expect(humanizeKeystrokes('cmd-option-right')).toEqual '⌘⌥→'
-
-      it "replaces multiple keystroke", ->
-        expect(humanizeKeystrokes('cmd-o ctrl-2')).toEqual '⌘O ⌃2'
-
     describe "when the window is resized", ->
       it "hides the tooltips", ->
         class TooltipView extends View

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 = 60000
+else
+  jasmine.getEnv().defaultTimeoutInterval = 5000
 
 specPackageName = null
 specPackagePath = null
@@ -89,12 +95,14 @@ beforeEach ->
   config.set "editor.autoIndent", false
   config.set "core.disabledPackages", ["package-that-throws-an-exception",
     "package-with-broken-package-json", "package-with-broken-keymap"]
-  config.set "core.useReactEditor", false
+  config.set "core.useReactEditor", true
   config.save.reset()
   atom.config = config
 
   # 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 3
+        expect(tokenizedBuffer.lineForScreenRow(10).indentLevel).toBe 3
+        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: 10, delta: 2)
+
+        expect(tokenizedBuffer.lineForScreenRow(5).indentLevel).toBe 4
+        expect(tokenizedBuffer.lineForScreenRow(6).indentLevel).toBe 4
+        expect(tokenizedBuffer.lineForScreenRow(11).indentLevel).toBe 4
+        expect(tokenizedBuffer.lineForScreenRow(12).indentLevel).toBe 4
+        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: 10, 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,12 +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 "    "
 
-      withInvisiblesShowing = "#{rightEditorView.invisibles.space}#{rightEditorView.invisibles.tab} #{rightEditorView.invisibles.space}#{rightEditorView.invisibles.eol}"
+      {invisibles} = rightEditorView.component.state
+      {space, tab, eol} = invisibles
+      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/browser/atom-window.coffee

@@ -138,6 +138,7 @@ class AtomWindow
           when 'window:reload' then @reload()
           when 'window:toggle-dev-tools' then @toggleDevTools()
           when 'window:close' then @close()
+          when 'window:update-available' then @sendCommandToBrowserWindow(command, args...) # For spec testing
     else if @isWebViewFocused()
       @sendCommandToBrowserWindow(command, args...)
     else

src/browser/auto-update-manager.coffee

@@ -1,3 +1,4 @@
+https = require 'https'
 autoUpdater = require 'auto-updater'
 dialog = require 'dialog'
 _ = require 'underscore-plus'
@@ -16,11 +17,12 @@ class AutoUpdateManager
 
   constructor: (@version) ->
     @state = IDLE_STATE
+    @feedUrl = "https://atom.io/api/updates?version=#{@version}"
 
-    # Only released versions should check for updates.
-    return if /\w{7}/.test(@version)
+    if process.platform is 'win32'
+      autoUpdater.checkForUpdates = => @checkForUpdatesShim()
 
-    autoUpdater.setFeedUrl "https://atom.io/api/updates?version=#{@version}"
+    autoUpdater.setFeedUrl @feedUrl
 
     autoUpdater.on 'checking-for-update', =>
       @setState(CHECKING_STATE)
@@ -39,7 +41,25 @@ class AutoUpdateManager
       @setState(UPDATE_AVAILABLE_STATE)
       @emitUpdateAvailableEvent(@getWindows()...)
 
-    @check(hidePopups: true)
+    # Only released versions should check for updates.
+    unless /\w{7}/.test(@version)
+      @check(hidePopups: true)
+
+  # Windows doesn't have an auto-updater, so use this method to shim the events.
+  checkForUpdatesShim: ->
+    autoUpdater.emit 'checking-for-update'
+    request = https.get @feedUrl, (response) ->
+      if response.statusCode == 200
+        body = ""
+        response.on 'data', (chunk) -> body += chunk
+        response.on 'end', ->
+          {notes, name} = JSON.parse(body)
+          autoUpdater.emit 'update-downloaded', null, notes, name
+      else
+        autoUpdater.emit 'update-not-available'
+
+    request.on 'error', (error) ->
+      autoUpdater.emit 'error', null, error.message
 
   emitUpdateAvailableEvent: (windows...) ->
     return unless @releaseVersion? and @releaseNotes

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,15 +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} = @props
-    {top, left, height, width} = editor.pixelRectForScreenRange(screenRange)
-    top -= scrollTop
-    left -= scrollLeft
-    WebkitTransform = "translate3d(#{left}px, #{top}px, 0px)"
+    {pixelRect, defaultCharWidth} = @props
+    {height, width} = pixelRect
+    width = defaultCharWidth if width is 0
+    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

@@ -28,9 +28,7 @@ class Cursor extends Model
 
       # Supports old editor view
       @needsAutoscroll ?= @isLastCursor() and !textChanged
-
-      # Supports react editor view
-      @autoscroll() if @needsAutoscroll and @editor.manageScrollPosition
+      @autoscroll() if @editor.manageScrollPosition and @isLastCursor() and textChanged
 
       @goalColumn = null
 
@@ -55,8 +53,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())
@@ -114,9 +114,10 @@ class Cursor extends Model
 
   # Public: Get the RegExp used by the cursor to determine what a "word" is.
   #
-  # options: An {Object} with the following keys:
+  # options: An optional {Object} with the following keys:
   #   :includeNonWordCharacters - A {Boolean} indicating whether to include
   #                               non-word characters in the regex.
+  #                               (default: true)
   #
   # Returns a {RegExp}.
   wordRegExp: ({includeNonWordCharacters}={})->

src/cursors-component.coffee

@@ -12,7 +12,7 @@ CursorsComponent = React.createClass
   cursorBlinkIntervalHandle: null
 
   render: ->
-    {editor, cursorScreenRanges, scrollTop, scrollLeft} = @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})
+        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/decoration.coffee

@@ -0,0 +1,57 @@
+_ = require 'underscore-plus'
+{Subscriber, Emitter} = require 'emissary'
+
+idCounter = 0
+nextId = -> idCounter++
+
+module.exports =
+class Decoration
+  Emitter.includeInto(this)
+
+  @isType: (decorationParams, type) ->
+    if _.isArray(decorationParams.type)
+      type in decorationParams.type
+    else
+      type is decorationParams.type
+
+  constructor: (@marker, @displayBuffer, @params) ->
+    @id = nextId()
+    @params.id = @id
+    @flashQueue = null
+    @isDestroyed = false
+
+  destroy: ->
+    return if @isDestroyed
+    @isDestroyed = true
+    @displayBuffer.removeDecoration(this)
+    @emit 'destoryed'
+
+  update: (newParams) ->
+    return if @isDestroyed
+    oldParams = @params
+    @params = newParams
+    @params.id = @id
+    @displayBuffer.decorationUpdated(this)
+    @emit 'updated', {oldParams, newParams}
+
+  getParams: ->
+    @params
+
+  isType: (type) ->
+    Decoration.isType(@params, type)
+
+  matchesPattern: (decorationPattern) ->
+    return false unless decorationPattern?
+    for key, value of decorationPattern
+      return false if @params[key] != value
+    true
+
+  flash: (klass, duration=500) ->
+    flashObject = {class: klass, duration}
+    @flashQueue ?= []
+    @flashQueue.push(flashObject)
+    @emit 'flash'
+
+  consumeNextFlash: ->
+    return @flashQueue.shift() if @flashQueue?.length > 0
+    null

src/display-buffer-marker.coffee

@@ -111,6 +111,34 @@ class DisplayBufferMarker
   setTailBufferPosition: (bufferPosition) ->
     @bufferMarker.setTailPosition(bufferPosition)
 
+  # Retrieves the screen position of the marker's start. This will always be
+  # less than or equal to the result of {DisplayBufferMarker::getEndScreenPosition}.
+  #
+  # Returns a {Point}.
+  getStartScreenPosition: ->
+    @displayBuffer.screenPositionForBufferPosition(@getStartBufferPosition(), wrapAtSoftNewlines: true)
+
+  # Retrieves the buffer position of the marker's start. This will always be
+  # less than or equal to the result of {DisplayBufferMarker::getEndBufferPosition}.
+  #
+  # Returns a {Point}.
+  getStartBufferPosition: ->
+    @bufferMarker.getStartPosition()
+
+  # Retrieves the screen position of the marker's end. This will always be
+  # greater than or equal to the result of {DisplayBufferMarker::getStartScreenPosition}.
+  #
+  # Returns a {Point}.
+  getEndScreenPosition: ->
+    @displayBuffer.screenPositionForBufferPosition(@getEndBufferPosition(), wrapAtSoftNewlines: true)
+
+  # Retrieves the buffer position of the marker's end. This will always be
+  # greater than or equal to the result of {DisplayBufferMarker::getStartBufferPosition}.
+  #
+  # Returns a {Point}.
+  getEndBufferPosition: ->
+    @bufferMarker.getEndPosition()
+
   # Sets the marker's tail to the same position as the marker's head.
   #
   # This only works if there isn't already a tail position.

src/display-buffer.coffee

@@ -8,6 +8,7 @@ TokenizedBuffer = require './tokenized-buffer'
 RowMap = require './row-map'
 Fold = require './fold'
 Token = require './token'
+Decoration = require './decoration'
 DisplayBufferMarker = require './display-buffer-marker'
 
 class BufferToScreenConversionError extends Error
@@ -29,11 +30,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,6 +46,10 @@ class DisplayBuffer extends Model
     @charWidthsByScope = {}
     @markers = {}
     @foldsByMarkerId = {}
+    @decorationsById = {}
+    @decorationsByMarkerId = {}
+    @decorationMarkerChangedSubscriptions = {}
+    @decorationMarkerDestroyedSubscriptions = {}
     @updateAllScreenLines()
     @createFoldForMarker(marker) for marker in @buffer.findMarkers(@getFoldMarkerAttributes())
     @subscribe @tokenizedBuffer, 'grammar-changed', (grammar) => @emit 'grammar-changed', grammar
@@ -177,9 +184,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) ->
@@ -189,10 +199,13 @@ 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)
+
+  getMaxScrollLeft: ->
+    @getScrollWidth() - @getClientWidth()
 
   getScrollRight: -> @scrollLeft + @width
   setScrollRight: (scrollRight) ->
@@ -203,7 +216,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
 
@@ -218,27 +235,35 @@ 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 = {}
 
   getScrollHeight: ->
-    unless @getLineHeightInPixels() > 0
-      throw new Error("You must assign lineHeightInPixels before calling ::getScrollHeight()")
+    return 0 unless @getLineHeightInPixels() > 0
 
     @getLineCount() * @getLineHeightInPixels()
 
   getScrollWidth: ->
-    (@getMaxLineLength() * @getDefaultCharWidth()) + @getCursorWidth()
+    @scrollWidth
 
   getVisibleRowRange: ->
-    unless @getLineHeightInPixels() > 0
-      throw new Error("You must assign a non-zero lineHeightInPixels before calling ::getVisibleRowRange()")
+    return [0, 0] unless @getLineHeightInPixels() > 0
 
     heightInLines = Math.ceil(@getHeight() / @getLineHeightInPixels()) + 1
     startRow = Math.floor(@getScrollTop() / @getLineHeightInPixels())
@@ -254,15 +279,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 +309,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
@@ -289,9 +322,9 @@ class DisplayBuffer extends Model
       height = (screenRange.end.row - screenRange.start.row + 1) * @getLineHeightInPixels()
       width = @getScrollWidth()
     else
-      {top, left} = @pixelPositionForScreenPosition(screenRange.start)
+      {top, left} = @pixelPositionForScreenPosition(screenRange.start, false)
       height = @getLineHeightInPixels()
-      width = @pixelPositionForScreenPosition(screenRange.end).left - left
+      width = @pixelPositionForScreenPosition(screenRange.end, false).left - left
 
     {top, left, width, height}
 
@@ -520,7 +553,7 @@ class DisplayBuffer extends Model
       charWidths = @getScopedCharWidths(token.scopes)
       for char in token.value
         return {top, left} if column is targetColumn
-        left += charWidths[char] ? defaultCharWidth
+        left += charWidths[char] ? defaultCharWidth unless char is '\0'
         column++
     {top, left}
 
@@ -565,6 +598,12 @@ class DisplayBuffer extends Model
   getMaxLineLength: ->
     @maxLineLength
 
+  # Gets the row number of the longest screen line.
+  #
+  # Return a {}
+  getLongestScreenRow: ->
+    @longestScreenRow
+
   # Given a buffer position, this converts it into a screen position.
   #
   # bufferPosition - An object that represents a buffer position. It can be either
@@ -718,6 +757,66 @@ class DisplayBuffer extends Model
   rangeForAllLines: ->
     new Range([0, 0], @clipScreenPosition([Infinity, Infinity]))
 
+  decorationForId: (id) ->
+    @decorationsById[id]
+
+  decorationsForScreenRowRange: (startScreenRow, endScreenRow) ->
+    decorationsByMarkerId = {}
+    for marker in @findMarkers(intersectsScreenRowRange: [startScreenRow, endScreenRow])
+      if decorations = @decorationsByMarkerId[marker.id]
+        decorationsByMarkerId[marker.id] = decorations
+    decorationsByMarkerId
+
+  decorateMarker: (marker, decorationParams) ->
+    marker = @getMarker(marker.id)
+
+    @decorationMarkerDestroyedSubscriptions[marker.id] ?= @subscribe marker, 'destroyed', =>
+      @removeAllDecorationsForMarker(marker)
+
+    @decorationMarkerChangedSubscriptions[marker.id] ?= @subscribe marker, 'changed', (event) =>
+      decorations = @decorationsByMarkerId[marker.id]
+
+      # 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
+
+    decoration = new Decoration(marker, this, decorationParams)
+    @decorationsByMarkerId[marker.id] ?= []
+    @decorationsByMarkerId[marker.id].push(decoration)
+    @decorationsById[decoration.id] = decoration
+    @emit 'decoration-added', marker, decoration
+    decoration
+
+  removeDecoration: (decoration) ->
+    {marker} = decoration
+    return unless decorations = @decorationsByMarkerId[marker.id]
+    index = decorations.indexOf(decoration)
+
+    if index > -1
+      decorations.splice(index, 1)
+      delete @decorationsById[decoration.id]
+      @emit 'decoration-removed', marker, decoration
+      @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]
+
+  decorationUpdated: (decoration) ->
+    @emit 'decoration-updated', decoration
+
   # Retrieves a {DisplayBufferMarker} based on its id.
   #
   # id - A {Number} representing a marker id
@@ -821,13 +920,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) ->
@@ -863,24 +983,26 @@ 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]
     endBufferRow = @rowMap.bufferRowRangeForBufferRow(endBufferRow - 1)[1]
     startScreenRow = @rowMap.screenRowRangeForBufferRow(startBufferRow)[0]
     endScreenRow = @rowMap.screenRowRangeForBufferRow(endBufferRow - 1)[1]
-
     {screenLines, regions} = @buildScreenLines(startBufferRow, endBufferRow + bufferDelta)
+    screenDelta = screenLines.length - (endScreenRow - startScreenRow)
+
     @screenLines[startScreenRow...endScreenRow] = screenLines
     @rowMap.spliceRegions(startBufferRow, endBufferRow - startBufferRow, regions)
-    @findMaxLineLength(startScreenRow, endScreenRow, screenLines)
+    @findMaxLineLength(startScreenRow, endScreenRow, screenLines, screenDelta)
 
     return if options.suppressChangeEvent
 
     changeEvent =
       start: startScreenRow
       end: endScreenRow - 1
-      screenDelta: screenLines.length - (endScreenRow - startScreenRow)
+      screenDelta: screenDelta
       bufferDelta: bufferDelta
 
     if options.delayChangeEvent
@@ -935,22 +1057,33 @@ class DisplayBuffer extends Model
 
     {screenLines, regions}
 
-  findMaxLineLength: (startScreenRow, endScreenRow, newScreenLines) ->
+  findMaxLineLength: (startScreenRow, endScreenRow, newScreenLines, screenDelta) ->
+    oldMaxLineLength = @maxLineLength
+
     if startScreenRow <= @longestScreenRow < endScreenRow
       @longestScreenRow = 0
       @maxLineLength = 0
       maxLengthCandidatesStartRow = 0
       maxLengthCandidates = @screenLines
     else
+      @longestScreenRow += screenDelta if endScreenRow < @longestScreenRow
       maxLengthCandidatesStartRow = startScreenRow
       maxLengthCandidates = newScreenLines
 
-    for screenLine, screenRow in maxLengthCandidates
+    for screenLine, i in maxLengthCandidates
+      screenRow = maxLengthCandidatesStartRow + i
       length = screenLine.text.length
       if length > @maxLineLength
-        @longestScreenRow = maxLengthCandidatesStartRow + screenRow
+        @longestScreenRow = screenRow
         @maxLineLength = length
 
+    @computeScrollWidth() if oldMaxLineLength isnt @maxLineLength
+
+  computeScrollWidth: ->
+    @scrollWidth = @pixelPositionForScreenPosition([@longestScreenRow, @maxLineLength]).left
+    @scrollWidth += 1 unless @getSoftWrap()
+    @setScrollLeft(Math.min(@getScrollLeft(), @getMaxScrollLeft()))
+
   handleBufferMarkersUpdated: =>
     if event = @pendingChangeEvent
       @pendingChangeEvent = null
@@ -961,6 +1094,7 @@ class DisplayBuffer extends Model
     @emit 'marker-created', @getMarker(marker.id)
 
   createFoldForMarker: (marker) ->
+    @decorateMarker(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
@@ -33,22 +39,31 @@ EditorComponent = React.createClass
   pendingHorizontalScrollDelta: 0
   mouseWheelScreenRow: null
   mouseWheelScreenRowClearDelay: 150
+  scrollSensitivity: 0.4
   scrollViewMeasurementRequested: false
-  overflowChangedEventsPaused: false
-  overflowChangedWhilePaused: false
   measureLineHeightAndDefaultCharWidthWhenShown: false
+  remeasureCharacterWidthsIfVisibleAfterNextUpdate: 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.getScreenLineCount().toString().length
+    maxLineNumberDigits = editor.getLineCount().toString().length
     invisibles = if showInvisibles then @state.invisibles else {}
+    hasSelection = editor.getSelection()? and !editor.getSelection().isEmpty()
 
     if @isMounted()
       renderedRowRange = @getRenderedRowRange()
       [renderedStartRow, renderedEndRow] = renderedRowRange
-      cursorScreenRanges = @getCursorScreenRanges(renderedRowRange)
-      selectionScreenRanges = @getSelectionScreenRanges(renderedRowRange)
+      cursorPixelRects = @getCursorPixelRects(renderedRowRange)
+
+      decorations = editor.decorationsForScreenRowRange(renderedStartRow, renderedEndRow)
+      highlightDecorations = @getHighlightDecorations(decorations)
+      lineDecorations = @getLineDecorations(decorations)
+
       scrollHeight = editor.getScrollHeight()
       scrollWidth = editor.getScrollWidth()
       scrollTop = editor.getScrollTop()
@@ -56,42 +71,46 @@ 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
 
     className = 'editor-contents editor-colors'
     className += ' is-focused' if focused
+    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
-      }
+      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
           ref: 'input'
           className: 'hidden-input'
           style: hiddenInputStyle
-          onInput: @onInput
           onFocus: @onInputFocused
           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
@@ -126,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
 
@@ -138,10 +161,13 @@ EditorComponent = React.createClass
     @pendingChanges = []
     @props.editor.manageScrollPosition = true
     @observeConfig()
+    @setScrollSensitivity(atom.config.get('editor.scrollSensitivity'))
 
   componentDidMount: ->
     {editor} = @props
 
+    @scrollViewMeasurementIntervalId = setInterval(@measureScrollView, @scrollViewMeasurementInterval)
+
     @observeEditor()
     @listenForDOMEvents()
     @listenForCommands()
@@ -151,31 +177,55 @@ EditorComponent = React.createClass
 
     editor.setVisible(true)
 
-    editor.batchUpdates =>
-      @measureLineHeightAndDefaultCharWidth()
-      @measureScrollView()
-      @measureScrollbars()
+    @measureLineHeightAndDefaultCharWidth()
+    @measureScrollView()
+    @measureScrollbars()
 
   componentWillUnmount: ->
     @unsubscribe()
-    window.removeEventListener('resize', @onWindowResize)
-
-  componentWillUpdate: ->
-    @props.parentView.trigger 'cursor:moved' if @cursorsMoved
+    clearInterval(@scrollViewMeasurementIntervalId)
+    @scrollViewMeasurementIntervalId = null
 
   componentDidUpdate: (prevProps, prevState) ->
+    cursorsMoved = @cursorsMoved
+    selectionChanged = @selectionChanged
     @pendingChanges.length = 0
+    @cursorsMoved = false
+    @selectionChanged = false
     @refreshingScrollbars = false
+
+    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)
-    @pauseOverflowChangedEvents()
-    @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
@@ -209,30 +259,81 @@ 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
+  getLineDecorations: (decorationsByMarkerId) ->
+    {editor} = @props
+    decorationsByScreenRow = {}
+    for markerId, decorations of decorationsByMarkerId
+      marker = editor.getMarker(markerId)
+      screenRange = null
+      headScreenRow = null
+      if marker.isValid()
+        for decoration in decorations
+          if decoration.isType('gutter') or decoration.isType('line')
+            decorationParams = decoration.getParams()
+            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 decorationParams.onlyHead and screenRow isnt headScreenRow
+              if screenRange.isEmpty()
+                continue if decorationParams.onlyNonEmpty
+              else
+                continue if decorationParams.onlyEmpty
 
-      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))
+              decorationsByScreenRow[screenRow] ?= []
+              decorationsByScreenRow[screenRow].push decorationParams
 
-    selectionScreenRanges
+    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 decoration.isType('highlight')
+            decorationParams = decoration.getParams()
+            filteredDecorations[markerId] ?=
+              id: markerId
+              startPixelPosition: editor.pixelPositionForScreenPosition(screenRange.start)
+              endPixelPosition: editor.pixelPositionForScreenPosition(screenRange.end)
+              decorations: []
+            filteredDecorations[markerId].decorations.push decorationParams
+
+    # 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, 'decoration-updated', @onDecorationChanged
+    @subscribe editor, 'character-widths-changed', @onCharacterWidthsChanged
     @subscribe editor.$scrollTop.changes, @onScrollTopChanged
     @subscribe editor.$scrollLeft.changes, @requestUpdate
     @subscribe editor.$height.changes, @requestUpdate
@@ -244,11 +345,39 @@ EditorComponent = React.createClass
     node = @getDOMNode()
     node.addEventListener 'mousewheel', @onMouseWheel
     node.addEventListener 'focus', @onFocus # For some reason, React's built in focus events seem to bubble
+    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
@@ -271,6 +400,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()
@@ -286,6 +416,8 @@ EditorComponent = React.createClass
       'editor:move-to-beginning-of-next-word': => editor.moveCursorToBeginningOfNextWord()
       'editor:move-to-previous-word-boundary': => editor.moveCursorToPreviousWordBoundary()
       'editor:move-to-next-word-boundary': => editor.moveCursorToNextWordBoundary()
+      'editor:select-to-beginning-of-next-paragraph': => editor.selectToBeginningOfNextParagraph()
+      'editor:select-to-beginning-of-previous-paragraph': => editor.selectToBeginningOfPreviousParagraph()
       'editor:select-to-end-of-line': => editor.selectToEndOfLine()
       'editor:select-to-beginning-of-line': => editor.selectToBeginningOfLine()
       'editor:select-to-end-of-word': => editor.selectToEndOfWord()
@@ -305,10 +437,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()
@@ -346,8 +482,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) ->
@@ -363,10 +497,33 @@ 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()
 
+  onTextInput: (event) ->
+    return unless @isInputEnabled()
+
+    {editor} = @props
+    inputNode = event.target
+
+    # Work around of the accented character suggestion feature in OS X.
+    # Text input fires before a character is inserted, and if the browser is
+    # replacing the previous un-accented character with an accented variant, it
+    # will select backward over it.
+    selectedLength = inputNode.selectionEnd - inputNode.selectionStart
+    editor.selectLeft() if selectedLength is 1
+
+    editor.insertText(event.data)
+    inputNode.value = event.data
+
+    # If we prevent the insertion of a space character, then the browser
+    # interprets the spacebar keypress as a page-down command.
+    event.preventDefault() unless event.data is ' '
+
   onInputFocused: ->
     @setState(focused: true)
 
@@ -376,24 +533,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
 
@@ -405,76 +563,99 @@ EditorComponent = React.createClass
     {wheelDeltaX, wheelDeltaY} = event
     if Math.abs(wheelDeltaX) > Math.abs(wheelDeltaY)
       # Scrolling horizontally
-      @pendingHorizontalScrollDelta -= wheelDeltaX
+      @pendingHorizontalScrollDelta -= Math.round(wheelDeltaX * @scrollSensitivity)
     else
       # Scrolling vertically
-      @pendingVerticalScrollDelta -= wheelDeltaY
+      @pendingVerticalScrollDelta -= Math.round(wheelDeltaY * @scrollSensitivity)
       @mouseWheelScreenRow = @screenRowForNode(event.target)
       @clearMouseWheelScreenRowAfterDelay ?= debounce(@clearMouseWheelScreenRow, @mouseWheelScreenRowClearDelay)
       @clearMouseWheelScreenRowAfterDelay()
 
     unless animationFramePending
-      requestAnimationFrame =>
+      @requestAnimationFrame =>
         {editor} = @props
         editor.setScrollTop(editor.getScrollTop() + @pendingVerticalScrollDelta)
         editor.setScrollLeft(editor.getScrollLeft() + @pendingHorizontalScrollDelta)
         @pendingVerticalScrollDelta = 0
         @pendingHorizontalScrollDelta = 0
 
-  onScrollViewOverflowChanged: ->
-    if @overflowChangedEventsPaused
-      @overflowChangedWhilePaused = true
-    else
-      @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
-
-  onInput: (char, replaceLastCharacter) ->
-    {editor} = @props
-
-    if replaceLastCharacter
-      editor.transact ->
-        editor.selectLeft()
-        editor.insertText(char)
-    else
-      editor.insertText(char)
+    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 shiftKey
-      editor.selectToScreenPosition(screenPosition)
-    else if metaKey
-      editor.addCursorAtScreenPosition(screenPosition)
-    else
-      editor.setCursorScreenPosition(screenPosition)
-      switch detail
-        when 2 then editor.selectWord()
-        when 3 then editor.selectLine()
+    if event.target?.classList.contains('fold-marker')
+      bufferRow = editor.bufferRowForScreenRow(screenPosition.row)
+      editor.unfoldBufferRow(bufferRow)
+      return
 
-    @selectToMousePositionUntilMouseUp(event)
+    switch detail
+      when 1
+        if shiftKey
+          editor.selectToScreenPosition(screenPosition)
+        else if metaKey or (ctrlKey and process.platform isnt 'darwin')
+          editor.addCursorAtScreenPosition(screenPosition)
+        else
+          editor.setCursorScreenPosition(screenPosition)
+      when 2
+        editor.getLastSelection().selectWord()
+      when 3
+        editor.getLastSelection().selectLine()
+
+    @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()
+    @remeasureCharacterWidthsIfVisibleAfterNextUpdate = true
+    @requestUpdate() if @state.visible
 
   onScreenLinesChanged: (change) ->
     {editor} = @props
@@ -497,10 +678,12 @@ EditorComponent = React.createClass
   onScrollTopChanged: ->
     @scrollingVertically = true
     @requestUpdate()
-    @onStoppedScrollingAfterDelay ?= debounce(@onStoppedScrolling, 100)
+    @onStoppedScrollingAfterDelay ?= debounce(@onStoppedScrolling, 200)
     @onStoppedScrollingAfterDelay()
 
   onStoppedScrolling: ->
+    return unless @isMounted()
+
     @scrollingVertically = false
     @mouseWheelScreenRow = null
     @requestUpdate()
@@ -509,16 +692,23 @@ EditorComponent = React.createClass
 
   onCursorsMoved: ->
     @cursorsMoved = true
+    @requestUpdate()
 
-  selectToMousePositionUntilMouseUp: (event) ->
+  onDecorationChanged: ->
+    @requestUpdate()
+
+  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) ->
@@ -542,11 +732,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 =>
@@ -558,6 +755,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
@@ -572,24 +770,16 @@ EditorComponent = React.createClass
 
     if position is 'absolute' or width
       clientWidth = scrollViewNode.clientWidth
+      paddingLeft = parseInt(getComputedStyle(scrollViewNode).paddingLeft)
+      clientWidth -= paddingLeft
       editor.setWidth(clientWidth) if clientWidth > 0
 
   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()
 
@@ -597,13 +787,21 @@ EditorComponent = React.createClass
     @measureLineHeightAndDefaultCharWidthWhenShown = false
     @refs.lines.measureLineHeightAndDefaultCharWidth()
 
+  remeasureCharacterWidthsIfNeeded: (prevState) ->
+    if not isEqualForProperties(prevState, @state, 'fontSize', 'fontFamily')
+      if @state.visible
+        @remeasureCharacterWidths()
+      else
+        @remeasureCharacterWidthsIfVisibleAfterNextUpdate = true
+    else if @remeasureCharacterWidthsIfVisibleAfterNextUpdate and @state.visible
+      @remeasureCharacterWidthsIfVisibleAfterNextUpdate = false
+      @remeasureCharacterWidths()
+
   remeasureCharacterWidths: ->
     @refs.lines.remeasureCharacterWidths()
 
-  measureGutter: ->
-    oldGutterWidth = @gutterWidth
-    @gutterWidth = @refs.gutter.getDOMNode().offsetWidth
-    @requestUpdate() if @gutterWidth isnt oldGutterWidth
+  onGutterWidthChanged: (@gutterWidth) ->
+    @requestUpdate()
 
   measureScrollbars: ->
     @measuringScrollbars = false
@@ -629,29 +827,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()
-
-  pauseOverflowChangedEvents: ->
-    @overflowChangedEventsPaused = true
-    @resumeOverflowChangedEventsAfterDelay ?= debounce(@resumeOverflowChangedEvents, 500)
-    @resumeOverflowChangedEventsAfterDelay()
-
-  resumeOverflowChangedEvents: ->
-    if @overflowChangedWhilePaused
-      @overflowChangedWhilePaused = false
-      @requestScrollViewMeasurement()
-
-  resumeOverflowChangedEventsAfterDelay: null
+    @forceUpdate()
 
   clearMouseWheelScreenRow: ->
     if @mouseWheelScreenRow?
@@ -680,6 +866,79 @@ EditorComponent = React.createClass
   show: ->
     @setState(visible: true)
 
+  getFontSize: ->
+    @state.fontSize
+
+  setFontSize: (fontSize) ->
+    @setState({fontSize})
+
+  getFontFamily: ->
+    @state.fontFamily
+
+  setFontFamily: (fontFamily) ->
+    @setState({fontFamily})
+
+  setLineHeight: (lineHeight) ->
+    @setState({lineHeight})
+
+  setShowIndentGuide: (showIndentGuide) ->
+    @setState({showIndentGuide})
+
+  # Public: Defines which characters are invisible.
+  #
+  # invisibles - An {Object} defining the invisible characters:
+  #   :eol   - The end of line invisible {String} (default: `\u00ac`).
+  #   :space - The space invisible {String} (default: `\u00b7`).
+  #   :tab   - The tab invisible {String} (default: `\u00bb`).
+  #   :cr    - The carriage return invisible {String} (default: `\u00a4`).
+  setInvisibles: (invisibles={}) ->
+    defaults invisibles,
+      eol: '\u00ac'
+      space: '\u00b7'
+      tab: '\u00bb'
+      cr: '\u00a4'
+
+    @setState({invisibles})
+
+  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)
+
+  pixelPositionForMouseEvent: (event) ->
+    {editor} = @props
+    {clientX, clientY} = event
+
+    linesClientRect = @refs.lines.getDOMNode().getBoundingClientRect()
+    top = clientY - linesClientRect.top
+    left = clientX - linesClientRect.left
+    {top, left}
+
+  getModel: ->
+    @props.editor
+
+  isInputEnabled: -> @inputEnabled
+
+  setInputEnabled: (@inputEnabled) -> @inputEnabled
+
+  updateParentViewFocusedClassIfNeeded: (prevState) ->
+    if prevState.focused isnt @state.focused
+      @props.parentView.toggleClass('is-focused', @props.focused)
+
   runScrollBenchmark: ->
     unless process.env.NODE_ENV is 'production'
       ReactPerf = require 'react-atom-fork/lib/ReactDefaultPerf'
@@ -714,47 +973,3 @@ EditorComponent = React.createClass
                   ReactPerf.printExclusive()
                   console.log "Wasted"
                   ReactPerf.printWasted()
-
-  setFontSize: (fontSize) ->
-    @setState({fontSize})
-
-  setLineHeight: (lineHeight) ->
-    @setState({lineHeight})
-
-  setFontFamily: (fontFamily) ->
-    @setState({fontFamily})
-
-  setShowIndentGuide: (showIndentGuide) ->
-    @setState({showIndentGuide})
-
-  # Public: Defines which characters are invisible.
-  #
-  # invisibles - An {Object} defining the invisible characters:
-  #   :eol   - The end of line invisible {String} (default: `\u00ac`).
-  #   :space - The space invisible {String} (default: `\u00b7`).
-  #   :tab   - The tab invisible {String} (default: `\u00bb`).
-  #   :cr    - The carriage return invisible {String} (default: `\u00a4`).
-  setInvisibles: (invisibles={}) ->
-    defaults invisibles,
-      eol: '\u00ac'
-      space: '\u00b7'
-      tab: '\u00bb'
-      cr: '\u00a4'
-
-    @setState({invisibles})
-
-  setShowInvisibles: (showInvisibles) ->
-    @setState({showInvisibles})
-
-  screenPositionForMouseEvent: (event) ->
-    pixelPosition = @pixelPositionForMouseEvent(event)
-    @props.editor.screenPositionForPixelPosition(pixelPosition)
-
-  pixelPositionForMouseEvent: (event) ->
-    {editor} = @props
-    {clientX, clientY} = event
-
-    scrollViewClientRect = @refs.scrollView.getDOMNode().getBoundingClientRect()
-    top = clientY - scrollViewClientRect.top + editor.getScrollTop()
-    left = clientX - scrollViewClientRect.left + editor.getScrollLeft()
-    {top, left}

src/editor-view.coffee

@@ -56,6 +56,8 @@ class EditorView extends View
     softWrap: false
     softTabs: true
     softWrapAtPreferredLineLength: false
+    scrollSensitivity: 40
+    useHardwareAcceleration: true
 
   @nextEditorId: 1
 
@@ -156,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()
@@ -171,6 +174,8 @@ class EditorView extends View
       'editor:move-to-beginning-of-next-word': => @editor.moveCursorToBeginningOfNextWord()
       'editor:move-to-previous-word-boundary': => @editor.moveCursorToPreviousWordBoundary()
       'editor:move-to-next-word-boundary': => @editor.moveCursorToNextWordBoundary()
+      'editor:select-to-beginning-of-next-paragraph': => @editor.selectToBeginningOfNextParagraph()
+      'editor:select-to-beginning-of-previous-paragraph': => @editor.selectToBeginningOfPreviousParagraph()
       'editor:select-to-end-of-line': => @editor.selectToEndOfLine()
       'editor:select-to-beginning-of-line': => @editor.selectToBeginningOfLine()
       'editor:select-to-end-of-word': => @editor.selectToEndOfWord()
@@ -190,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()
@@ -280,7 +287,7 @@ class EditorView extends View
     @editor.moveCursorUp(@getPageRows())
     @scrollTop(newScrollTop,  adjustVerticalScrollbar: true)
 
-  # Public: Gets the number of actual page rows existing in an editor.
+  # Gets the number of actual page rows existing in an editor.
   #
   # Returns a {Number}.
   getPageRows: ->
@@ -365,6 +372,8 @@ class EditorView extends View
       false if @isFocused
 
     @overlayer.on 'mousedown', (e) =>
+      return unless e.which is 1 # only handle the left mouse button
+
       @overlayer.hide()
       clickedElement = document.elementFromPoint(e.pageX, e.pageY)
       @overlayer.show()
@@ -564,7 +573,7 @@ class EditorView extends View
       @scrollTop(scrollTop)
 
     @subscribe @editor, 'scroll-left-changed', (scrollLeft) =>
-      @scrollLeft(scrollLeft)
+      @scrollView.scrollLeft(scrollLeft)
 
     @subscribe @editor, 'soft-wrap-changed', (softWrap) =>
       @setSoftWrap(softWrap)

src/editor.coffee

@@ -112,6 +112,7 @@ TextMateScopeSelector = require('first-mate').ScopeSelector
 # - {::deleteToBeginningOfWord}
 # - {::deleteToBeginningOfLine}
 # - {::delete}
+# - {::deleteToEndOfLine}
 # - {::deleteToEndOfWord}
 # - {::deleteLine}
 # - {::cutSelectedText}
@@ -145,6 +146,7 @@ class Editor extends Model
   selections: null
   suppressSelectionMerging: false
   updateBatchDepth: 0
+  selectionFlashDuration: 500
 
   @delegatesMethods 'suggestedIndentForBufferRow', 'autoIndentBufferRow', 'autoIndentBufferRows',
     'autoDecreaseIndentForBufferRow', 'toggleLineCommentForBufferRow', 'toggleLineCommentsForBufferRows',
@@ -214,6 +216,11 @@ 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-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, "decoration-updated", (args...) => @emit 'decoration-updated', args...
+    @subscribe @displayBuffer, "character-widths-changed", (changeCount) => @emit 'character-widths-changed', changeCount
 
   getViewClass: ->
     if atom.config.get('core.useReactEditor')
@@ -688,6 +695,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.
@@ -842,6 +856,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)
@@ -1057,6 +1075,47 @@ class Editor extends Model
       selection.insertText(fn(text))
       selection.setBufferRange(range)
 
+  # Public: Get all the decorations within a screen row range.
+  #
+  # startScreenRow - the {Number} beginning screen row
+  # endScreenRow - the {Number} end screen row (inclusive)
+  #
+  # 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: 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 - 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.
+  decorateMarker: (marker, decoration) ->
+    @displayBuffer.decorateMarker(marker, decoration)
+
+  decorationForId: (id) ->
+    @displayBuffer.decorationForId(id)
+
   # Public: Get the {DisplayBufferMarker} for the given marker id.
   getMarker: (id) ->
     @displayBuffer.getMarker(id)
@@ -1162,6 +1221,9 @@ class Editor extends Model
   addCursor: (marker) ->
     cursor = new Cursor(editor: this, marker: marker)
     @cursors.push(cursor)
+    @decorateMarker(marker, type: 'gutter', class: 'cursor-line')
+    @decorateMarker(marker, type: 'gutter', class: 'cursor-line-no-selection', onlyHead: true, onlyEmpty: true)
+    @decorateMarker(marker, type: 'line', class: 'cursor-line', onlyEmpty: true)
     @emit 'cursor-added', cursor
     cursor
 
@@ -1201,7 +1263,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.
@@ -1503,18 +1567,31 @@ class Editor extends Model
     @getCursor().autoscroll()
 
   pageUp: ->
-    @setScrollTop(@getScrollTop() - @getHeight())
+    newScrollTop = @getScrollTop() - @getHeight()
+    @moveCursorUp(@getRowsPerPage())
+    @setScrollTop(newScrollTop)
 
   pageDown: ->
-    @setScrollTop(@getScrollTop() + @getHeight())
+    newScrollTop = @getScrollTop() + @getHeight()
+    @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
@@ -1727,6 +1804,20 @@ class Editor extends Model
   selectWord: ->
     @expandSelectionsForward (selection) => selection.selectWord()
 
+  # Public: Expand selections to the beginning of the next paragraph.
+  #
+  # Operates on all selections. Moves the cursor to the beginning of the next
+  # paragraph while preserving the selection's tail position.
+  selectToBeginningOfNextParagraph: ->
+    @expandSelectionsForward (selection) => selection.selectToBeginningOfNextParagraph()
+
+  # Public: Expand selections to the beginning of the next paragraph.
+  #
+  # Operates on all selections. Moves the cursor to the beginning of the next
+  # paragraph while preserving the selection's tail position.
+  selectToBeginningOfPreviousParagraph: ->
+    @expandSelectionsBackward (selection) => selection.selectToBeginningOfPreviousParagraph()
+
   # Public: Select the range of the given marker if it is valid.
   #
   # marker - A {DisplayBufferMarker}
@@ -1820,9 +1911,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.
   #
@@ -1842,14 +1931,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}>"
 
@@ -1878,6 +1959,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)
 
@@ -1925,11 +2008,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

@@ -1,6 +1,8 @@
+_ = require 'underscore-plus'
 React = require 'react-atom-fork'
 {div} = require 'reactionary-atom-fork'
 {isEqual, isEqualForProperties, multiplyString, toArray} = require 'underscore-plus'
+Decoration = require './decoration'
 SubscriberMixin = require './subscriber-mixin'
 
 WrapperDiv = document.createElement('div')
@@ -11,19 +13,31 @@ GutterComponent = React.createClass
   mixins: [SubscriberMixin]
 
   dummyLineNumberNode: null
+  measuredWidth: null
 
   render: ->
-    {scrollHeight, scrollTop} = @props
+    {scrollHeight, scrollViewHeight, onMouseDown} = @props
 
-    div className: 'gutter',
-      div className: 'line-numbers', 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 = {}
+    @renderedDecorationsByLineNumberId = {}
 
   componentDidMount: ->
     @appendDummyLineNumber()
@@ -33,20 +47,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} = 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
 
     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()
 
@@ -58,7 +76,7 @@ GutterComponent = React.createClass
   # since the real line numbers are absolutely positioned for performance reasons.
   appendDummyLineNumber: ->
     {maxLineNumberDigits} = @props
-    WrapperDiv.innerHTML = @buildLineNumberHTML(0, false, maxLineNumberDigits)
+    WrapperDiv.innerHTML = @buildLineNumberHTML(-1, false, maxLineNumberDigits)
     @dummyLineNumberNode = WrapperDiv.children[0]
     @refs.lineNumbers.getDOMNode().appendChild(@dummyLineNumberNode)
 
@@ -70,7 +88,7 @@ GutterComponent = React.createClass
     @removeLineNumberNodes(lineNumberIdsToPreserve)
 
   appendOrUpdateVisibleLineNumberNodes: ->
-    {editor, renderedRowRange, scrollTop, maxLineNumberDigits} = @props
+    {editor, renderedRowRange, scrollTop, maxLineNumberDigits, lineDecorations} = @props
     [startRow, endRow] = renderedRowRange
 
     newLineNumberIds = null
@@ -91,7 +109,7 @@ GutterComponent = React.createClass
       visibleLineNumberIds.add(id)
 
       if @hasLineNumberNode(id)
-        @updateLineNumberNode(id, screenRow)
+        @updateLineNumberNode(id, bufferRow, screenRow, wrapCount > 0)
       else
         newLineNumberIds ?= []
         newLineNumbersHTML ?= ""
@@ -100,6 +118,8 @@ GutterComponent = React.createClass
         @screenRowsByLineNumberId[id] = screenRow
         @lineNumberIdsByScreenRow[screenRow] = id
 
+      @renderedDecorationsByLineNumberId[id] = lineDecorations[screenRow]
+
     if newLineNumberIds?
       WrapperDiv.innerHTML = newLineNumbersHTML
       newLineNumberNodes = toArray(WrapperDiv.children)
@@ -121,17 +141,27 @@ 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) ->
+    {editor, lineHeightInPixels, lineDecorations} = @props
     if screenRow?
-      {lineHeightInPixels} = @props
       style = "position: absolute; top: #{screenRow * lineHeightInPixels}px;"
     else
       style = "visibility: hidden;"
     innerHTML = @buildLineNumberInnerHTML(bufferRow, softWrapped, maxLineNumberDigits)
 
-    "<div class=\"line-number\" style=\"#{style}\" data-buffer-row=\"#{bufferRow}\" data-screen-row=\"#{screenRow}\">#{innerHTML}</div>"
+    classes = ''
+    if lineDecorations? and decorations = lineDecorations[screenRow]
+      for decoration in decorations
+        if Decoration.isType(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>"
 
   buildLineNumberInnerHTML: (bufferRow, softWrapped, maxLineNumberDigits) ->
     if softWrapped
@@ -143,11 +173,31 @@ GutterComponent = React.createClass
     iconHTML = '<div class="icon-right"></div>'
     padding + lineNumber + iconHTML
 
-  updateLineNumberNode: (lineNumberId, screenRow) ->
+  updateLineNumberNode: (lineNumberId, bufferRow, screenRow, softWrapped) ->
+    {editor, lineDecorations} = @props
+    node = @lineNumberNodesById[lineNumberId]
+
+    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 Decoration.isType(decoration, 'gutter') and not _.deepContains(decorations, decoration)
+
+    if decorations?
+      for decoration in decorations
+        if Decoration.isType(decoration, 'gutter') and not _.deepContains(previousDecorations, decoration)
+          node.classList.add(decoration.class)
+
     unless @screenRowsByLineNumberId[lineNumberId] is screenRow
       {lineHeightInPixels} = @props
-      @lineNumberNodesById[lineNumberId].style.top = screenRow * lineHeightInPixels + 'px'
-      @lineNumberNodesById[lineNumberId].dataset.screenRow = screenRow
+      node.style.top = screenRow * lineHeightInPixels + 'px'
+      node.dataset.screenRow = screenRow
       @screenRowsByLineNumberId[lineNumberId] = screenRow
       @lineNumberIdsByScreenRow[screenRow] = lineNumberId
 
@@ -156,3 +206,21 @@ GutterComponent = React.createClass
 
   lineNumberNodeForScreenRow: (screenRow) ->
     @lineNumberNodesById[@lineNumberIdsByScreenRow[screenRow]]
+
+  onClick: (event) ->
+    {editor} = @props
+    {target} = event
+    lineNumber = target.parentNode
+
+    if target.classList.contains('icon-right') and lineNumber.classList.contains('foldable')
+      bufferRow = parseInt(lineNumber.getAttribute('data-buffer-row'))
+      if lineNumber.classList.contains('folded')
+        editor.unfoldBufferRow(bufferRow)
+      else
+        editor.foldBufferRow(bufferRow)
+
+  measureWidth: ->
+    width = @getDOMNode().offsetWidth
+    unless width is @measuredWidth
+      @measuredWidth = width
+      @props.onWidthChanged?(width)

src/highlight-component.coffee

@@ -0,0 +1,90 @@
+React = require 'react-atom-fork'
+{div} = require 'reactionary-atom-fork'
+{isEqualForProperties} = require 'underscore-plus'
+
+module.exports =
+HighlightComponent = React.createClass
+  displayName: 'HighlightComponent'
+
+  render: ->
+    {startPixelPosition, endPixelPosition, decoration} = @props
+
+    className = 'highlight'
+    className += " #{decoration.class}" if decoration.class?
+
+    div {className},
+      if endPixelPosition.top is startPixelPosition.top
+        @renderSingleLineRegions()
+      else
+        @renderMultiLineRegions()
+
+  componentDidMount: ->
+    {editor, decoration} = @props
+    if decoration.id?
+      @decoration = editor.decorationForId(decoration.id)
+      @decoration.on 'flash', @startFlashAnimation
+      @startFlashAnimation()
+
+  componentWillUnmount: ->
+    @decoration?.off 'flash', @startFlashAnimation
+
+  startFlashAnimation: ->
+    return unless flash = @decoration.consumeNextFlash()
+
+    node = @getDOMNode()
+    node.classList.remove(flash.class)
+
+    requestAnimationFrame =>
+      node.classList.add(flash.class)
+      clearTimeout(@flashTimeoutId)
+      removeFlashClass = -> node.classList.remove(flash.class)
+      @flashTimeoutId = setTimeout(removeFlashClass, flash.duration)
+
+  renderSingleLineRegions: ->
+    {startPixelPosition, endPixelPosition, lineHeightInPixels} = @props
+
+    [
+      div className: 'region', key: 0, style:
+        top: startPixelPosition.top
+        height: lineHeightInPixels
+        left: startPixelPosition.left
+        width: endPixelPosition.left - startPixelPosition.left
+    ]
+
+  renderMultiLineRegions: ->
+    {startPixelPosition, endPixelPosition, lineHeightInPixels} = @props
+    regions = []
+    index = 0
+
+    # First row, extending from selection start to the right side of screen
+    regions.push(
+      div className: 'region', key: index++, style:
+        top: startPixelPosition.top
+        left: startPixelPosition.left
+        height: lineHeightInPixels
+        right: 0
+    )
+
+    # Middle rows, extending from left side to right side of screen
+    if endPixelPosition.top - startPixelPosition.top > lineHeightInPixels
+      regions.push(
+        div className: 'region', key: index++, style:
+          top: startPixelPosition.top + lineHeightInPixels
+          height: endPixelPosition.top - startPixelPosition.top - lineHeightInPixels
+          left: 0
+          right: 0
+      )
+
+    # Last row, extending from left side of screen to selection end
+    regions.push(
+      div className: 'region', key: index, style:
+        top: endPixelPosition.top
+        height: lineHeightInPixels
+        left: 0
+        width: endPixelPosition.left
+    )
+
+    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: ->
+    {editor, highlightDecorations, lineHeightInPixels} = @props
+
+    highlightComponents = []
+    for markerId, {startPixelPosition, endPixelPosition, decorations} of highlightDecorations
+      for decoration in decorations
+        highlightComponents.push(HighlightComponent({editor, key: "#{markerId}-#{decoration.class}", startPixelPosition, endPixelPosition, decoration, lineHeightInPixels}))
+
+    highlightComponents
+
+  shouldComponentUpdate: (newProps) ->
+    not isEqualForProperties(newProps, @props, 'highlightDecorations', 'lineHeightInPixels', 'defaultCharWidth', 'scopedCharacterWidthsChangeCount')

src/input-component.coffee

@@ -1,4 +1,3 @@
-punycode = require 'punycode'
 {last, isEqual} = require 'underscore-plus'
 React = require 'react-atom-fork'
 {input} = require 'reactionary-atom-fork'
@@ -17,7 +16,6 @@ InputComponent = React.createClass
 
   componentDidMount: ->
     @getDOMNode().addEventListener 'paste', @onPaste
-    @getDOMNode().addEventListener 'input', @onInput
     @getDOMNode().addEventListener 'compositionupdate', @onCompositionUpdate
 
   # Don't let text accumulate in the input forever, but avoid excessive reflows
@@ -36,15 +34,6 @@ InputComponent = React.createClass
   onPaste: (e) ->
     e.preventDefault()
 
-  onInput: (e) ->
-    e.stopPropagation()
-    valueCharCodes = punycode.ucs2.decode(@getDOMNode().value)
-    valueLength = valueCharCodes.length
-    replaceLastChar = valueLength is @lastValueLength
-    @lastValueLength = valueLength
-    lastChar = String.fromCharCode(last(valueCharCodes))
-    @props.onInput?(lastChar, replaceLastChar)
-
   onFocus: ->
     @props.onFocus?()
 

src/language-mode.coffee

@@ -41,9 +41,9 @@ class LanguageMode
     buffer = @editor.buffer
     commentStartRegexString = _.escapeRegExp(commentStartString).replace(/(\s+)$/, '(?:$1)?')
     commentStartRegex = new OnigRegExp("^(\\s*)(#{commentStartRegexString})")
-    shouldUncomment = commentStartRegex.test(buffer.lineForRow(start))
 
     if commentEndString
+      shouldUncomment = commentStartRegex.test(buffer.lineForRow(start))
       if shouldUncomment
         commentEndRegexString = _.escapeRegExp(commentEndString).replace(/^(\s+)/, '(?:$1)?')
         commentEndRegex = new OnigRegExp("(#{commentEndRegexString})(\\s*)$")
@@ -64,10 +64,18 @@ class LanguageMode
           buffer.insert([start, indentLength], commentStartString)
           buffer.insert([end, buffer.lineLengthForRow(end)], commentEndString)
     else
-      if shouldUncomment and start isnt end
-        shouldUncomment = [start+1..end].every (row) ->
-          line = buffer.lineForRow(row)
-          not line or commentStartRegex.test(line)
+      allBlank = true
+      allBlankOrCommented = true
+
+      for row in [start..end]
+        line = buffer.lineForRow(row)
+        blank = line?.match(/^\s*$/)
+
+        allBlank = false unless blank
+        allBlankOrCommented = false unless blank or commentStartRegex.test(line)
+
+      shouldUncomment = allBlankOrCommented and not allBlank
+
       if shouldUncomment
         for row in [start..end]
           if match = commentStartRegex.search(buffer.lineForRow(row))

src/lines-component.coffee

@@ -1,9 +1,11 @@
+_ = 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'
+Decoration = require './decoration'
+HighlightsComponent = require './highlights-component'
 
 DummyLineNode = $$(-> @div className: 'line', style: 'position: absolute; visibility: hidden;', => @span 'x')[0]
 AcceptFilter = {acceptNode: -> NodeFilter.FILTER_ACCEPT}
@@ -15,32 +17,47 @@ 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()
 
-    div {className: 'lines', style},
-      SelectionsComponent({editor, selectionScreenRanges, lineHeightInPixels, defaultCharWidth}) if @isMounted()
+    # 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},
+      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
     [renderedStartRow, renderedEndRow] = renderedRowRange
     for change in pendingChanges
-      return true unless change.end < renderedStartRow or renderedEndRow <= change.start
+      if change.screenDelta is 0
+        return true unless change.end < renderedStartRow or renderedEndRow <= change.start
+      else
+        return true unless renderedEndRow <= change.start
 
     false
 
@@ -49,20 +66,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 +92,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 +105,7 @@ LinesComponent = React.createClass
       screenRow = startRow + index
 
       if @hasLineNode(line.id)
-        @updateLineNode(line, screenRow)
+        @updateLineNode(line, screenRow, updateWidth)
       else
         newLines ?= []
         newLinesHTML ?= ""
@@ -94,6 +114,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 +130,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 Decoration.isType(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
 
@@ -128,7 +158,7 @@ LinesComponent = React.createClass
 
     if showIndentGuide and indentLevel > 0
       indentSpan = "<span class='indent-guide'>#{multiplyString(' ', tabLength)}</span>"
-      multiplyString(indentSpan, indentLevel + 1)
+      multiplyString(indentSpan, indentLevel)
     else
       "&nbsp;"
 
@@ -185,10 +215,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 Decoration.isType(decoration, 'line') and not _.deepContains(decorations, decoration)
+
+    if decorations?
+      for decoration in decorations
+        if Decoration.isType(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 +250,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
@@ -232,6 +279,8 @@ LinesComponent = React.createClass
       charWidths = editor.getScopedCharWidths(scopes)
 
       for char in value
+        continue if char is '\0'
+
         unless charWidths[char]?
           unless textNode?
             rangeForMeasurement ?= document.createRange()

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/pane-container.coffee

@@ -8,6 +8,8 @@ class PaneContainer extends Model
   atom.deserializers.add(this)
   Serializable.includeInto(this)
 
+  @version: 1
+
   @properties
     root: -> new Pane
     activePane: null
@@ -27,10 +29,12 @@ class PaneContainer extends Model
   deserializeParams: (params) ->
     params.root = atom.deserializers.deserialize(params.root, container: this)
     params.destroyEmptyPanes = atom.config.get('core.destroyEmptyPanes')
+    params.activePane = params.root.getPanes().find (pane) -> pane.id is params.activePaneId
     params
 
   serializeParams: (params) ->
     root: @root?.serialize()
+    activePaneId: @activePane.id
 
   replaceChild: (oldChild, newChild) ->
     throw new Error("Replacing non-existent child") if oldChild isnt @root

src/pane.coffee

@@ -40,14 +40,12 @@ class Pane extends Model
     @subscribe @items.onRemoval (item, index) =>
       @unsubscribe item if typeof item.on is 'function'
 
-    @activate() if params?.active
-
   # Called by the Serializable mixin during serialization.
   serializeParams: ->
+    id: @id
     items: compact(@items.map((item) -> item.serialize?()))
     activeItemUri: @activeItem?.getUri?()
     focused: @focused
-    active: @active
 
   # Called by the Serializable mixin during deserialization.
   deserializeParams: (params) ->
@@ -212,7 +210,10 @@ class Pane extends Model
     @destroyItem(item) for item in @getItems() when item isnt @activeItem
 
   destroy: ->
-    super unless @container?.isAlive() and @container?.getPanes().length is 1
+    if @container?.isAlive() and @container.getPanes().length is 1
+      @destroyItems()
+    else
+      super
 
   # Called by model superclass.
   destroyed: ->
@@ -331,7 +332,7 @@ class Pane extends Model
     if @parent.orientation isnt orientation
       @parent.replaceChild(this, new PaneAxis({@container, orientation, children: [this]}))
 
-    newPane = new @constructor(extend({focused: true}, params))
+    newPane = new @constructor(params)
     switch side
       when 'before' then @parent.insertChildBefore(this, newPane)
       when 'after' then @parent.insertChildAfter(this, newPane)

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
 
@@ -16,10 +14,45 @@ class ReactEditorView extends View
 
   getEditor: -> @editor
 
+  getModel: -> @editor
+
   Object.defineProperty @::, 'lineHeight', get: -> @editor.getLineHeightInPixels()
   Object.defineProperty @::, 'charWidth', get: -> @editor.getDefaultCharWidth()
   Object.defineProperty @::, 'firstRenderedScreenRow', get: -> @component.getRenderedRowRange()[0]
   Object.defineProperty @::, 'lastRenderedScreenRow', get: -> @component.getRenderedRowRange()[1]
+  Object.defineProperty @::, 'active', get: -> @is(@getPane().activeView)
+  Object.defineProperty @::, 'isFocused', get: -> @component?.state.focused
+
+  afterAttach: (onDom) ->
+    return unless onDom
+    return if @attached
+
+    @attached = true
+    props = defaults({@editor, parentView: this}, @props)
+    @component = React.renderComponent(EditorComponent(props), @element)
+
+    node = @component.getDOMNode()
+
+    @scrollView = $(node).find('.scroll-view')
+    @underlayer = $(node).find('.highlights').addClass('underlayer')
+    @overlayer = $(node).find('.lines').addClass('overlayer')
+    @hiddenInput = $(node).find('.hidden-input')
+
+    @gutter = $(node).find('.gutter')
+    @gutter.removeClassFromAllLines = (klass) =>
+      @gutter.find('.line-number').removeClass(klass)
+
+    @gutter.getLineNumberElement = (bufferRow) =>
+      @gutter.find("[data-buffer-row='#{bufferRow}']")
+
+    @gutter.addClassToLine = (bufferRow, klass) =>
+      lines = @gutter.find("[data-buffer-row='#{bufferRow}']")
+      lines.addClass(klass)
+      lines.length > 0
+
+    @focus() if @focusOnAttach
+
+    @trigger 'editor:attached', [this]
 
   scrollTop: (scrollTop) ->
     if scrollTop?
@@ -33,35 +66,22 @@ class ReactEditorView extends View
     else
       @editor.getScrollLeft()
 
-  scrollToScreenPosition: (screenPosition) ->
+  scrollToBottom: ->
+    @editor.setScrollBottom(Infinity)
+
+  scrollToScreenPosition: (screenPosition, options) ->
+    @editor.scrollToScreenPosition(screenPosition, options)
+
+  scrollToBufferPosition: (bufferPosition, options) ->
+    @editor.scrollToBufferPosition(bufferPosition, options)
+
+  scrollToCursorPosition: ->
+    @editor.scrollToCursorPosition()
+
+  scrollToPixelPosition: (pixelPosition) ->
+    screenPosition = screenPositionForPixelPosition(pixelPosition)
     @editor.scrollToScreenPosition(screenPosition)
 
-  scrollToBufferPosition: (bufferPosition) ->
-    @editor.scrollToBufferPosition(bufferPosition)
-
-  afterAttach: (onDom) ->
-    return unless onDom
-    @attached = true
-    props = defaults({@editor, parentView: this}, @props)
-    @component = React.renderComponent(EditorComponent(props), @element)
-
-    node = @component.getDOMNode()
-
-    @underlayer = $(node).find('.selections')
-
-    @gutter = $(node).find('.gutter')
-    @gutter.removeClassFromAllLines = (klass) =>
-      @gutter.find('.line-number').removeClass(klass)
-
-    @gutter.addClassToLine = (bufferRow, klass) =>
-      lines = @gutter.find("[data-buffer-row='#{bufferRow}']")
-      lines.addClass(klass)
-      lines.length > 0
-
-    @focus() if @focusOnAttach
-
-    @trigger 'editor:attached', [this]
-
   pixelPositionForBufferPosition: (bufferPosition) ->
     @editor.pixelPositionForBufferPosition(bufferPosition)
 
@@ -78,6 +98,26 @@ class ReactEditorView extends View
     @attached = false
     @trigger 'editor:detached', this
 
+  # Public: Split the editor view left.
+  splitLeft: ->
+    pane = @getPane()
+    pane?.splitLeft(pane?.copyActiveItem()).activeView
+
+  # Public: Split the editor view right.
+  splitRight: ->
+    pane = @getPane()
+    pane?.splitRight(pane?.copyActiveItem()).activeView
+
+  # Public: Split the editor view up.
+  splitUp: ->
+    pane = @getPane()
+    pane?.splitUp(pane?.copyActiveItem()).activeView
+
+  # Public: Split the editor view down.
+  splitDown: ->
+    pane = @getPane()
+    pane?.splitDown(pane?.copyActiveItem()).activeView
+
   getPane: ->
     @closest('.pane').view()
 
@@ -89,10 +129,79 @@ class ReactEditorView extends View
 
   hide: ->
     super
-    @component.hide()
+    @component?.hide()
 
   show: ->
     super
-    @component.show()
+    @component?.show()
+
+  pageDown: ->
+    @editor.pageDown()
+
+  pageUp: ->
+    @editor.pageUp()
+
+  getModel: ->
+    @component?.getModel()
+
+  getFirstVisibleScreenRow: ->
+    @editor.getVisibleRowRange()[0]
+
+  getLastVisibleScreenRow: ->
+    @editor.getVisibleRowRange()[1]
+
+  getFontFamily: ->
+    @component?.getFontFamily()
+
+  setFontFamily: (fontFamily)->
+    @component?.setFontFamily(fontFamily)
+
+  getFontSize: ->
+    @component?.getFontSize()
+
+  setFontSize: (fontSize)->
+    @component?.setFontSize(fontSize)
+
+  setWidthInChars: (widthInChars) ->
+    @component.getDOMNode().style.width = (@editor.getDefaultCharWidth() * widthInChars) + 'px'
+
+  setLineHeight: (lineHeight) ->
+    @component.setLineHeight(lineHeight)
+
+  setShowIndentGuide: (showIndentGuide) ->
+    @component.setShowIndentGuide(showIndentGuide)
+
+  setSoftWrap: (softWrap) ->
+    @editor.setSoftWrap(softWrap)
+
+  setShowInvisibles: (showInvisibles) ->
+    @component.setShowInvisibles(showInvisibles)
+
+  toggleSoftWrap: ->
+    @editor.toggleSoftWrap()
+
+  toggleSoftTabs: ->
+    @editor.toggleSoftTabs()
+
+  getText: ->
+    @editor.getText()
+
+  setText: (text) ->
+    @editor.setText(text)
+
+  insertText: (text) ->
+    @editor.insertText(text)
+
+  isInputEnabled: ->
+    @component.isInputEnabled()
+
+  setInputEnabled: (inputEnabled) ->
+    @component.setInputEnabled(inputEnabled)
 
   requestDisplayUpdate: -> # No-op shim for find-and-replace
+
+  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-component.coffee

@@ -1,65 +0,0 @@
-React = require 'react-atom-fork'
-{div} = require 'reactionary-atom-fork'
-
-module.exports =
-SelectionComponent = React.createClass
-  displayName: 'SelectionComponent'
-
-  render: ->
-    {editor, screenRange, lineHeightInPixels} = @props
-    {start, end} = screenRange
-    rowCount = end.row - start.row + 1
-    startPixelPosition = editor.pixelPositionForScreenPosition(start)
-    endPixelPosition = editor.pixelPositionForScreenPosition(end)
-
-    div className: 'selection',
-      if rowCount is 1
-        @renderSingleLineRegions(startPixelPosition, endPixelPosition)
-      else
-        @renderMultiLineRegions(startPixelPosition, endPixelPosition, rowCount)
-
-  renderSingleLineRegions: (startPixelPosition, endPixelPosition) ->
-    {lineHeightInPixels} = @props
-
-    [
-      div className: 'region', key: 0, style:
-        top: startPixelPosition.top
-        height: lineHeightInPixels
-        left: startPixelPosition.left
-        width: endPixelPosition.left - startPixelPosition.left
-    ]
-
-  renderMultiLineRegions: (startPixelPosition, endPixelPosition, rowCount) ->
-    {lineHeightInPixels} = @props
-    regions = []
-    index = 0
-
-    # First row, extending from selection start to the right side of screen
-    regions.push(
-      div className: 'region', key: index++, style:
-        top: startPixelPosition.top
-        left: startPixelPosition.left
-        height: lineHeightInPixels
-        right: 0
-    )
-
-    # Middle rows, extending from left side to right side of screen
-    if rowCount > 2
-      regions.push(
-        div className: 'region', key: index++, style:
-          top: startPixelPosition.top + lineHeightInPixels
-          height: (rowCount - 2) * lineHeightInPixels
-          left: 0
-          right: 0
-      )
-
-    # Last row, extending from left side of screen to selection end
-    regions.push(
-      div className: 'region', key: index, style:
-        top: endPixelPosition.top
-        height: lineHeightInPixels
-        left: 0
-        width: endPixelPosition.left
-    )
-
-    regions

src/selection.coffee

@@ -15,6 +15,8 @@ class Selection extends Model
   constructor: ({@cursor, @marker, @editor, id}) ->
     @assignId(id)
     @cursor.selection = this
+    @decoration = @editor.decorateMarker(@marker, type: 'highlight', class: 'selection')
+
     @marker.on 'changed', => @screenRangeChanged()
     @marker.on 'destroyed', =>
       @destroyed = true
@@ -76,9 +78,12 @@ class Selection extends Model
     options.reversed ?= @isReversed()
     @editor.destroyFoldsIntersectingBufferRange(bufferRange) unless options.preserveFolds
     @modifySelection =>
+      needsFlash = options.flash
+      delete options.flash if options.flash?
       @cursor.needsAutoscroll = false if @needsAutoscroll?
       @marker.setBufferRange(bufferRange, options)
       @autoscroll() if @needsAutoscroll and @editor.manageScrollPosition
+      @decoration.flash('flash', @editor.selectionFlashDuration) if needsFlash
 
   # Public: Returns the starting and ending buffer rows the selection is
   # highlighting.
@@ -91,6 +96,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())
 
@@ -236,6 +253,16 @@ class Selection extends Model
   selectToNextWordBoundary: ->
     @modifySelection => @cursor.moveToNextWordBoundary()
 
+  # Public: Selects all the text from the current cursor position to the
+  # beginning of the next paragraph.
+  selectToBeginningOfNextParagraph: ->
+    @modifySelection => @cursor.moveToBeginningOfNextParagraph()
+
+  # Public: Selects all the text from the current cursor position to the
+  # beginning of the previous paragraph.
+  selectToBeginningOfPreviousParagraph: ->
+    @modifySelection => @cursor.moveToBeginningOfPreviousParagraph()
+
   # Public: Moves the selection down one row.
   addSelectionBelow: ->
     range = (@getGoalBufferRange() ? @getBufferRange()).copy()
@@ -256,7 +283,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: ->
@@ -297,6 +325,7 @@ class Selection extends Model
       text = @normalizeIndents(text, options.indentBasis)
 
     newBufferRange = @editor.buffer.setTextInRange(oldBufferRange, text, pick(options, 'undo'))
+
     if options.select
       @setBufferRange(newBufferRange, reversed: wasReversed)
     else
@@ -420,6 +449,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: ->
@@ -485,7 +523,7 @@ class Selection extends Model
   outdentSelectedRows: ->
     [start, end] = @getBufferRowRange()
     buffer = @editor.buffer
-    leadingTabRegex = new RegExp("^ {1,#{@editor.getTabLength()}}|\t")
+    leadingTabRegex = new RegExp("^( {1,#{@editor.getTabLength()}}|\t)")
     for row in [start..end]
       if matchLength = buffer.lineForRow(row).match(leadingTabRegex)?[0].length
         buffer.delete [[row, 0], [row, matchLength]]

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
@@ -218,22 +231,27 @@ class TokenizedBuffer extends Model
 
   indentLevelForRow: (row) ->
     line = @buffer.lineForRow(row)
+    indentLevel = 0
 
     if line is ''
       nextRow = row + 1
       lineCount = @getLineCount()
       while nextRow < lineCount
         nextLine = @buffer.lineForRow(nextRow)
-        return @indentLevelForLine(nextLine) unless nextLine is ''
+        unless nextLine is ''
+          indentLevel = Math.ceil(@indentLevelForLine(nextLine))
+          break
         nextRow++
 
       previousRow = row - 1
       while previousRow >= 0
         previousLine = @buffer.lineForRow(previousRow)
-        return @indentLevelForLine(previousLine) unless previousLine is ''
+        unless previousLine is ''
+          indentLevel = Math.max(Math.ceil(@indentLevelForLine(previousLine)), indentLevel)
+          break
         previousRow--
 
-      0
+      indentLevel
     else
       @indentLevelForLine(line)
 

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/buttons.less

@@ -64,15 +64,15 @@
 }
 
 .btn-toolbar {
-  > .btn-group {
+  > .btn-group + .btn-group, > .btn-group + .btn, > .btn + .btn {
     float: none;
     display: inline-block;
-  }
-  > * {
-    margin-right: 0;
-    margin-left: @component-padding/2;
-  }
-  > *:first-child {
     margin-left: 0;
   }
+  > * {
+    margin-right: @component-padding / 2;
+  }
+  > *:last-child {
+    margin-right: 0;
+  }
 }

static/editor.less

@@ -17,7 +17,7 @@
   }
 
   .cursor {
-    z-index: 2;
+    z-index: 4;
     pointer-events: none;
   }
 
@@ -69,11 +69,13 @@
   .gutter {
     .line-number {
       white-space: nowrap;
-      padding: 0 .5em;
+      padding-left: .5em;
 
       .icon-right {
-        padding: 0;
-        padding-left: .1em;
+        padding: 0 .4em;
+        &:before {
+          text-align: center;
+        }
       }
     }
   }
@@ -121,7 +123,7 @@
   visibility: hidden;
   padding-left: .1em;
   padding-right: .5em;
-  opacity: .7;
+  opacity: .6;
 }
 
 .editor .gutter:hover .line-number.foldable .icon-right {
@@ -149,6 +151,10 @@
   }
 }
 
+.editor .fold-marker {
+  cursor: default;
+}
+
 .editor .fold-marker:after {
   .icon(0.8em, inline);
   content: @ellipsis;
@@ -249,6 +255,12 @@
   width: 1px;
 }
 
+.editor .highlight {
+  background: none;
+  padding: 0;
+}
+
+.editor .highlight .region,
 .editor .selection .region {
   position: absolute;
   pointer-events: none;

static/jasmine.less

@@ -135,6 +135,10 @@ body {
     padding: 5px 0 5px 0;
   }
 
+  .result-message.deprecation-message {
+    color: #f0ad4e;
+  }
+
   .stack-trace {
     font-size: 12px;
     margin: 5px 0 0 0;
@@ -174,4 +178,24 @@ body {
       // overflow: hidden;
     }
   }
+
+  .deprecation-toggle {
+    .octicon(fold);
+    float: right;
+    cursor: pointer;
+    opacity: 0;
+    color: #999;
+
+    &.folded {
+      .octicon(unfold);
+    }
+  }
+
+  .deprecation-toggle:hover {
+    color: #333;
+  }
+
+  &:hover .deprecation-toggle {
+    opacity: 1;
+  }
 }

static/syntax.less

@@ -19,3 +19,17 @@
     }
   }
 }
+
+.define-selection-flash-color-if-not-defined() { @syntax-selection-flash-color: rgba(100, 255, 100, 0.7); }
+.define-selection-flash-color-if-not-defined();
+
+@-webkit-keyframes flash {
+  from { background-color: @syntax-selection-flash-color; }
+  to { background-color: null; }
+}
+
+.editor .flash.selection .region {
+  -webkit-animation-name: flash;
+  -webkit-animation-duration: .5s;
+  -webkit-animation-iteration-count: 1;
+}

static/variables/syntax-variables.less

@@ -5,6 +5,7 @@
 @syntax-text-color: #333;
 @syntax-cursor-color: #333;
 @syntax-selection-color: #69c;
+@syntax-selection-flash-color: #00f; // Color the selection is 'flashed' when you run find next
 @syntax-background-color: #fff;
 
 // Guide colors