Add proper line decorations to initial state

Basic line decorations are working, but we still need to handle special
decoration options.

.gitignore

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

README.md

@@ -6,10 +6,25 @@ Visit [atom.io](https://atom.io) to learn more.
 
 ## Installing
 
+### Mac OS X
+
 Download the latest [Atom release](https://github.com/atom/atom/releases/latest).
 
 Atom will automatically update when a new release is available.
 
+### Windows
+
+Install the [Atom chocolatey package](https://chocolatey.org/packages/Atom).
+
+1. Install [chocolatey](https://chocolatey.org).
+2. Close and reopen your command prompt or PowerShell window.
+3. Run `cinst Atom`
+4. In the future run `cup Atom` to upgrade to the latest release.
+
+You can also download a `.zip` file from the [releases page](https://github.com/atom/atom/releases/latest).
+The Windows version does not currently automatically update so you will need to
+manually upgrade to future releases by re-downloading the `.zip` file.
+
 ## Building
 
 * [Linux](docs/build-instructions/linux.md)
@@ -18,4 +33,5 @@ Atom will automatically update when a new release is available.
 * [Windows](docs/build-instructions/windows.md)
 
 ## Developing
+
 Check out the [guides](https://atom.io/docs/latest) and the [API reference](https://atom.io/docs/api).

apm/package.json

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

atom.sh

@@ -69,6 +69,11 @@ elif [ $OS == 'Linux' ]; then
   SCRIPT=$(readlink -f "$0")
   USR_DIRECTORY=$(readlink -f $(dirname $SCRIPT)/..)
   ATOM_PATH="$USR_DIRECTORY/share/atom/atom"
+  DOT_ATOM_DIR="$HOME/.atom"
+
+  if [ ! -d "$DOT_ATOM_DIR" ]; then
+    mkdir -p "$DOT_ATOM_DIR"
+  fi
 
   : ${TMPDIR:=/tmp}
 
@@ -79,9 +84,9 @@ elif [ $OS == 'Linux' ]; then
     exit $?
   else
     (
-    nohup "$ATOM_PATH" --executed-from="$(pwd)" --pid=$$ "$@" > "$TMPDIR/atom-nohup.out" 2>&1
+    nohup "$ATOM_PATH" --executed-from="$(pwd)" --pid=$$ "$@" > "$DOT_ATOM_DIR/nohup.out" 2>&1
     if [ $? -ne 0 ]; then
-      cat "$TMPDIR/atom-nohup.out"
+      cat "$DOT_ATOM_DIR/nohup.out"
       exit $?
     fi
     ) &

build/Gruntfile.coffee

@@ -40,7 +40,10 @@ module.exports = (grunt) ->
   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')
+
+  home = if process.platform is 'win32' then process.env.USERPROFILE else process.env.HOME
+  atomShellDownloadDir = path.join(home, '.atom', 'atom-shell')
+
   symbolsDir = path.join(buildDir, 'Atom.breakpad.syms')
   shellAppDir = path.join(buildDir, appName)
   if process.platform is 'win32'
@@ -93,6 +96,8 @@ module.exports = (grunt) ->
   csonConfig =
     options:
       rootObject: true
+      cachePath: path.join(home, '.atom', 'compile-cache', 'grunt-cson')
+
     glob_to_multiple:
       expand: true
       src: [

build/package.json

@@ -14,10 +14,10 @@
     "grunt": "~0.4.1",
     "grunt-cli": "~0.1.9",
     "grunt-coffeelint": "git+https://github.com/atom/grunt-coffeelint.git",
-    "grunt-contrib-csslint": "~0.1.2",
     "grunt-contrib-coffee": "~0.9.0",
+    "grunt-contrib-csslint": "~0.1.2",
     "grunt-contrib-less": "~0.8.0",
-    "grunt-cson": "0.8.0",
+    "grunt-cson": "0.10.0",
     "grunt-download-atom-shell": "~0.8.0",
     "grunt-lesslint": "0.13.0",
     "grunt-markdown": "~0.4.0",
@@ -27,15 +27,15 @@
     "json-front-matter": "~0.1.3",
     "legal-eagle": "~0.4.0",
     "minidump": "~0.7",
-    "read-package-json": "1.1.8",
     "normalize-package-data": "0.2.12",
+    "npm": "~1.4.5",
     "rcedit": "~0.1.2",
+    "read-package-json": "1.1.8",
     "request": "~2.27.0",
     "rimraf": "~2.2.2",
-    "runas": "0.5.x",
+    "runas": "~1.0.1",
     "underscore-plus": "1.x",
     "unzip": "~0.1.9",
-    "vm-compatibility-layer": "~0.1.0",
-    "npm": "~1.4.5"
+    "vm-compatibility-layer": "~0.1.0"
   }
 }

build/tasks/build-task.coffee

@@ -14,9 +14,9 @@ module.exports = (grunt) ->
     mkdir path.dirname(buildDir)
 
     if process.platform is 'darwin'
-      cp 'atom-shell/Atom.app', shellAppDir
+      cp 'atom-shell/Atom.app', shellAppDir, filter: /default_app/
     else
-      cp 'atom-shell', shellAppDir
+      cp 'atom-shell', shellAppDir, filter: /default_app/
 
     mkdir appDir
 
@@ -45,29 +45,45 @@ module.exports = (grunt) ->
       path.join('git-utils', 'deps')
       path.join('oniguruma', 'deps')
       path.join('less', 'dist')
-      path.join('less', 'test')
       path.join('bootstrap', 'docs')
-      path.join('bootstrap', 'examples')
+      path.join('bootstrap', '_config.yml')
+      path.join('bootstrap', '_includes')
+      path.join('bootstrap', '_layouts')
+      path.join('npm', 'doc')
+      path.join('npm', 'html')
+      path.join('npm', 'man')
+      path.join('npm', 'node_modules', '.bin', 'beep')
+      path.join('npm', 'node_modules', '.bin', 'clear')
+      path.join('npm', 'node_modules', '.bin', 'starwars')
       path.join('pegjs', 'examples')
-      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('jasmine-node', 'spec')
+      path.join('node_modules', 'nan')
+      path.join('build', 'binding.Makefile')
+      path.join('build', 'config.gypi')
+      path.join('build', 'gyp-mac-tool')
+      path.join('build', 'Makefile')
       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')
+
+      # These are only require in dev mode when the grammar isn't precompiled
+      path.join('atom-keymap', 'node_modules', 'loophole')
+      path.join('atom-keymap', 'node_modules', 'pegjs')
+      path.join('atom-keymap', 'node_modules', '.bin', 'pegjs')
+      path.join('snippets', 'node_modules', 'loophole')
+      path.join('snippets', 'node_modules', 'pegjs')
+      path.join('snippets', 'node_modules', '.bin', 'pegjs')
+
+      '.DS_Store'
+      '.jshintrc'
+      '.npmignore'
+      '.pairs'
+      '.travis.yml'
     ]
     ignoredPaths = ignoredPaths.map (ignoredPath) -> _.escapeRegExp(ignoredPath)
 
@@ -75,21 +91,56 @@ module.exports = (grunt) ->
     ignoredPaths.push "#{_.escapeRegExp(path.join('spellchecker', 'vendor', 'hunspell') + path.sep)}.*"
     ignoredPaths.push "#{_.escapeRegExp(path.join('build', 'Release') + path.sep)}.*\\.pdb"
 
+    # Ignore *.cc and *.h files from native modules
+    ignoredPaths.push "#{_.escapeRegExp(path.join('ctags', 'src') + path.sep)}.*\\.(cc|h)*"
+    ignoredPaths.push "#{_.escapeRegExp(path.join('git-utils', 'src') + path.sep)}.*\\.(cc|h)*"
+    ignoredPaths.push "#{_.escapeRegExp(path.join('keytar', 'src') + path.sep)}.*\\.(cc|h)*"
+    ignoredPaths.push "#{_.escapeRegExp(path.join('nslog', 'src') + path.sep)}.*\\.(cc|h)*"
+    ignoredPaths.push "#{_.escapeRegExp(path.join('oniguruma', 'src') + path.sep)}.*\\.(cc|h)*"
+    ignoredPaths.push "#{_.escapeRegExp(path.join('pathwatcher', 'src') + path.sep)}.*\\.(cc|h)*"
+    ignoredPaths.push "#{_.escapeRegExp(path.join('runas', 'src') + path.sep)}.*\\.(cc|h)*"
+    ignoredPaths.push "#{_.escapeRegExp(path.join('scrollbar-style', 'src') + path.sep)}.*\\.(cc|h)*"
+    ignoredPaths.push "#{_.escapeRegExp(path.join('spellchecker', 'src') + path.sep)}.*\\.(cc|h)*"
+
+    # Ignore build files
+    ignoredPaths.push "#{_.escapeRegExp(path.sep)}binding\\.gyp$"
+    ignoredPaths.push "#{_.escapeRegExp(path.sep)}.+\\.target.mk$"
+    ignoredPaths.push "#{_.escapeRegExp(path.sep)}linker\\.lock$"
+    ignoredPaths.push "#{_.escapeRegExp(path.join('build', 'Release') + path.sep)}.+\\.node\\.dSYM"
+
     # Hunspell dictionaries are only not needed on OS X.
     if process.platform is 'darwin'
       ignoredPaths.push path.join('spellchecker', 'vendor', 'hunspell_dictionaries')
     ignoredPaths = ignoredPaths.map (ignoredPath) -> "(#{ignoredPath})"
+
+    testFolderPattern = new RegExp("#{_.escapeRegExp(path.sep)}te?sts?#{_.escapeRegExp(path.sep)}")
+    exampleFolderPattern = new RegExp("#{_.escapeRegExp(path.sep)}examples?#{_.escapeRegExp(path.sep)}")
+    benchmarkFolderPattern = new RegExp("#{_.escapeRegExp(path.sep)}benchmarks?#{_.escapeRegExp(path.sep)}")
+
     nodeModulesFilter = new RegExp(ignoredPaths.join('|'))
+    filterNodeModule = (pathToCopy) ->
+      return true if benchmarkFolderPattern.test(pathToCopy)
+
+      pathToCopy = path.resolve(pathToCopy)
+      nodeModulesFilter.test(pathToCopy) or testFolderPattern.test(pathToCopy) or exampleFolderPattern.test(pathToCopy)
+
     packageFilter = new RegExp("(#{ignoredPaths.join('|')})|(.+\\.(cson|coffee)$)")
+    filterPackage = (pathToCopy) ->
+      return true if benchmarkFolderPattern.test(pathToCopy)
+
+      pathToCopy = path.resolve(pathToCopy)
+      packageFilter.test(pathToCopy) or testFolderPattern.test(pathToCopy) or exampleFolderPattern.test(pathToCopy)
+
     for directory in nonPackageDirectories
-      cp directory, path.join(appDir, directory), filter: nodeModulesFilter
+      cp directory, path.join(appDir, directory), filter: filterNodeModule
+
     for directory in packageDirectories
-      cp directory, path.join(appDir, directory), filter: packageFilter
+      cp directory, path.join(appDir, directory), filter: filterPackage
 
     cp 'spec', path.join(appDir, 'spec')
     cp 'src', path.join(appDir, 'src'), filter: /.+\.(cson|coffee)$/
     cp 'static', path.join(appDir, 'static')
-    cp 'apm', path.join(appDir, 'apm'), filter: nodeModulesFilter
+    cp 'apm', path.join(appDir, 'apm'), filter: filterNodeModule
 
     if process.platform is 'darwin'
       grunt.file.recurse path.join('resources', 'mac'), (sourcePath, rootDirectory, subDirectory='', filename) ->
@@ -97,9 +148,6 @@ module.exports = (grunt) ->
           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'), ''

build/tasks/install-task.coffee

@@ -4,17 +4,13 @@ _ = 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)
 
   grunt.registerTask 'install', 'Install the built application', ->
     installDir = grunt.config.get('atom.installDir')
     shellAppDir = grunt.config.get('atom.shellAppDir')
+
     if process.platform is 'win32'
       runas ?= require 'runas'
       copyFolder = path.resolve 'script', 'copy-folder.cmd'
@@ -32,7 +28,6 @@ module.exports = (grunt) ->
       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')
@@ -42,13 +37,17 @@ module.exports = (grunt) ->
 
       # 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)
+        desktopFile = path.join('resources', 'linux', 'Atom.desktop.in')
+        desktopInstallFile = path.join(installDir, 'share', 'applications', 'Atom.desktop')
+
         {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
+        iconName = path.join(shareDir, 'resources', 'app', 'resources', 'atom.png')
+        installDir = path.join(installDir, '.') # To prevent "Exec=/usr/local//share/atom/atom"
+        template = _.template(String(fs.readFileSync(desktopFile)))
+        filled = template({description, installDir, iconName})
+
+        grunt.file.write(desktopInstallFile, filled)
 
       # Create relative symbol link for apm.
       process.chdir(binDir)

build/tasks/mkdeb-task.coffee

@@ -2,14 +2,17 @@ fs = require 'fs'
 path = require 'path'
 _ = require 'underscore-plus'
 
-fillTemplate = (filePath, data) ->
-  template = _.template(String(fs.readFileSync(filePath + '.in')))
-  filled = template(data)
-  fs.writeFileSync(filePath, filled)
-
 module.exports = (grunt) ->
   {spawn} = require('./task-helpers')(grunt)
 
+  fillTemplate = (filePath, data) ->
+    template = _.template(String(fs.readFileSync("#{filePath}.in")))
+    filled = template(data)
+
+    outputPath = path.join(grunt.config.get('atom.buildDir'), path.basename(filePath))
+    grunt.file.write(outputPath, filled)
+    outputPath
+
   grunt.registerTask 'mkdeb', 'Create debian package', ->
     done = @async()
 
@@ -27,13 +30,11 @@ module.exports = (grunt) ->
     iconName = 'atom'
     data = {name, version, description, section, arch, maintainer, installDir, iconName}
 
-    control = path.join('resources', 'linux', 'debian', 'control')
-    fillTemplate(control, data)
-    desktop = path.join('resources', 'linux', 'Atom.desktop')
-    fillTemplate(desktop, data)
+    controlFilePath = fillTemplate(path.join('resources', 'linux', 'debian', 'control'), data)
+    desktopFilePath = fillTemplate(path.join('resources', 'linux', 'Atom.desktop'), data)
     icon = path.join('resources', 'atom.png')
     buildDir = grunt.config.get('atom.buildDir')
 
     cmd = path.join('script', 'mkdeb')
-    args = [version, arch, control, desktop, icon, buildDir]
+    args = [version, arch, controlFilePath, desktopFilePath, icon, buildDir]
     spawn({cmd, args}, done)

build/tasks/output-build-filetypes.coffee

@@ -0,0 +1,21 @@
+path = require 'path'
+
+module.exports = (grunt) ->
+  grunt.registerTask 'output-build-filetypes', 'Log counts for each filetype in the built application', ->
+    shellAppDir = grunt.config.get('atom.shellAppDir')
+
+    types = {}
+    grunt.file.recurse shellAppDir, (absolutePath, rootPath, relativePath, fileName) ->
+      extension = path.extname(fileName) or fileName
+      types[extension] ?= 0
+      types[extension]++
+
+    extensions = Object.keys(types).sort (extension1, extension2) ->
+      diff = types[extension2] - types[extension1]
+      if diff is 0
+        extension1.toLowerCase().localeCompare(extension2.toLowerCase())
+      else
+        diff
+
+    extensions.forEach (extension) ->
+      grunt.log.error "#{extension}: #{types[extension]}"

build/tasks/prebuild-less-task.coffee

@@ -9,10 +9,12 @@ module.exports = (grunt) ->
       ['atom-dark-ui', 'atom-light-syntax']
       ['atom-dark-ui', 'solarized-dark-syntax']
       ['atom-dark-ui', 'base16-tomorrow-dark-theme']
+      ['atom-dark-ui', 'base16-tomorrow-light-theme']
       ['atom-light-ui', 'atom-light-syntax']
       ['atom-light-ui', 'atom-dark-syntax']
       ['atom-light-ui', 'solarized-dark-syntax']
       ['atom-light-ui', 'base16-tomorrow-dark-theme']
+      ['atom-light-ui', 'base16-tomorrow-light-theme']
     ]
 
     directory = path.join(grunt.config.get('atom.appDir'), 'less-compile-cache')

build/tasks/task-helpers.coffee

@@ -7,7 +7,7 @@ module.exports = (grunt) ->
       grunt.fatal("Cannot copy non-existent #{source.cyan} to #{destination.cyan}")
 
     copyFile = (sourcePath, destinationPath) ->
-      return if filter?.test(sourcePath)
+      return if filter?(sourcePath) or filter?.test?(sourcePath)
 
       stats = fs.lstatSync(sourcePath)
       if stats.isSymbolicLink()

docs/apm-rest-api.md

@@ -1,4 +1,4 @@
-## Atom.io package and update API
+# Atom.io package and update API
 
 This guide describes the web API used by [apm](https://github.com/atom/apm) and
 Atom. The vast majority of use cases are met by the `apm` command-line tool,
@@ -8,6 +8,8 @@ and making sure you have pushed your git tag. In fact, Atom itself shells out to
 uses `apm`, see the [PackageManager class](https://github.com/atom/settings-view/blob/master/lib/package-manager.coffee)
 in the `settings-view` package.
 
+*This API should be considered pre-release and is subject to change (though significant breaking changes are unlikely).*
+
 ### Authorization
 
 For calls to the API that require authentication, provide a valid token from your
@@ -17,12 +19,18 @@ For calls to the API that require authentication, provide a valid token from you
 
 All requests that take parameters require `application/json`.
 
-## Resources
+# API Resources
 
-### Packages
+## Packages
+
+### Listing packages
 
 #### GET /api/packages
 
+Parameters:
+
+- **page** (optional)
+
 Returns a list of all packages in the following format:
 ```json
   [
@@ -40,6 +48,17 @@ Returns a list of all packages in the following format:
   ]
 ```
 
+Results are paginated 30 at a time, and links to the next and last pages are
+provided in the `Link` header:
+
+```
+Link: <https://www.atom.io/api/packages?page=1>; rel="self",
+      <https://www.atom.io/api/packages?page=41>; rel="last",
+      <https://www.atom.io/api/packages?page=2>; rel="next"
+```
+
+### Showing package details
+
 #### GET /api/packages/:package_name
 
 Returns package details and versions for a single package
@@ -68,6 +87,8 @@ Returns:
   }
 ```
 
+### Creating a package
+
 #### POST /api/packages
 
 Create a new package; requires authentication.
@@ -92,6 +113,7 @@ Returns:
   - The package.json at owner/repo isn't valid
 - **409** - A package by that name already exists
 
+### Deleting a package
 
 #### DELETE /api/packages/:package_name
 
@@ -103,6 +125,13 @@ Returns:
 - **400** - Repository is inaccessible
 - **401** - Unauthorized
 
+### Renaming a package
+
+Packages are renamed by publishing a new version with the name changed in `package.json`
+See [Creating a new package version](#creating-a-new-package-version) for details.
+
+Requests made to the previous name will forward to the new name.
+
 ### Package Versions
 
 #### GET /api/packages/:package_name/versions/:version_name
@@ -144,7 +173,9 @@ Returns `package.json` with `dist` key added for e.g. tarball download:
 
 #### POST /api/packages/:package_name/versions
 
-Creates a new package version from a git tag; requires authentication.
+Creates a new package version from a git tag; requires authentication. If `rename`
+is not `true`, the `name` field in `package.json` *must* match the current package
+name.
 
 #### Parameters
 
@@ -152,14 +183,15 @@ Creates a new package version from a git tag; requires authentication.
   that the version name will not be taken from the tag, but from the `version`
   key in the `package.json` file at that ref. The authenticating user *must* have
   access to the package repository.
+- **rename** - Boolean indicating whether this version contains a new name for the package.
 
 #### Returns
 
 - **201** - Successfully created. Returns created version.
-- **400** - Git tag not found / Repository inaccessible
+- **400** - Git tag not found / Repository inaccessible / package.json invalid
 - **409** - Version exists
 
-### Delete a version
+### Deleting a version
 
 #### DELETE /api/packages/:package_name/versions/:version_name
 
@@ -172,7 +204,9 @@ you'll need to increment the version when republishing.
 Returns 204 No Content
 
 
-### Stars
+## Stars
+
+### Listing user stars
 
 #### GET /api/users/:login/stars
 
@@ -186,18 +220,24 @@ List the authenticated user's starred packages; requires authentication.
 
 Return value is similar to **GET /api/packages**
 
+### Starring a package
+
 #### POST /api/packages/:name/star
 
 Star a package; requires authentication.
 
 Returns a package.
 
+### Unstarring a package
+
 #### DELETE /api/packages/:name/star
 
 Unstar a package; requires authentication.
 
 Returns 204 No Content.
 
+### Listing a package's stargazers
+
 #### GET /api/packages/:name/stargazers
 
 List the users that have starred a package.
@@ -211,7 +251,9 @@ Returns a list of user objects:
 ]
 ```
 
-### Atom updates
+## Atom updates
+
+### Listing Atom updates
 
 #### GET /api/updates
 

docs/build-instructions/linux.md

@@ -6,38 +6,52 @@ Ubuntu LTS 12.04 64-bit is the recommended platform.
 
   * 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
-    * [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`
-    * on other distributions refer to the manual on how to install packages
-  * `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`
+  * [Git](http://git-scm.com/)
+  * [Node.js](http://nodejs.org/download/) v0.10.x
+  * [npm](http://www.npmjs.org/) v1.4.x (bundled with Node.js)
+    * `npm -v` to check the version.
+    * `npm config set python /usr/bin/python2 -g` to ensure that gyp uses python2.
+      * You might need to run this command as `sudo`, depending on how you have set up [npm](https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager#ubuntu-mint-elementary-os).
+  * development headers for [GNOME Keyring](https://wiki.gnome.org/Projects/GnomeKeyring)
+
+### Ubuntu / Debian
+* `sudo apt-get install build-essential git libgnome-keyring-dev`
+* Instructions for  [Node.js](https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager#ubuntu-mint-elementary-os).
+
+### Fedora
+* `sudo yum --assumeyes install make gcc gcc-c++ glibc-devel git-core libgnome-keyring-devel`
+* Instructions for [Node.js](https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager#fedora).
+
+### Arch
+* `sudo pacman -S base-devel git nodejs libgnome-keyring`
+* `export PYTHON=/usr/bin/python2` before building Atom.
 
 ## Instructions
 
-  ```sh
-  git clone https://github.com/atom/atom
-  cd atom
-  script/build # Creates application at $TMPDIR/atom-build/Atom
-  sudo script/grunt install # Installs command to /usr/local/bin/atom
-  script/grunt mkdeb # Generates a .deb package at $TMPDIR/atom-build
-  ```
+If you have problems with permissions don't forget to prefix with `sudo`
+
+Create the atom application at `$TMPDIR/atom-build/Atom`:
+
+```sh
+script/build
+```
+
+Install the `atom` and `apm` commands to `/usr/local/bin`:
+
+```sh
+sudo script/grunt install
+```
+
+Generate a `.deb` package at `$TMPDIR/atom-build`: (*optional*)
+
+```sh
+script/grunt mkdeb
+```
+
+Use the newly installed atom by restarting any running atom instances.
 
 ## Troubleshooting
 
-
 ### Exception: "TypeError: Unable to watch path"
 
 If you get following error with a big traceback right after Atom starts:
@@ -64,7 +78,7 @@ 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.
+have Node.js installed, or node isn't identified as Node.js 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.
 

docs/build-instructions/windows.md

@@ -35,10 +35,14 @@
 
 ## Why do I have to use GitHub for Windows?
 
-You don't, You can use your existing Git! GitHub for Windows's Git Shell is just
-easier to set up. You need to have Posix tools in your `%PATH%` (i.e. `grep`,
-`sed`, et al.), which isn't the default configuration when you install Git. To
-fix this, you probably need to fiddle with your system PATH.
+You don't. You can use your existing Git! GitHub for Windows's Git Shell is just
+easier to set up. 
+
+If you _prefer_ using your existing Git installation, make sure git's cmd directory is in your PATH env variable (e.g. `C:\Program Files (x86)\Git\cmd`) before you open your powershell or command window.
+Note that you may have to open your command window as administrator. For powershell that doesn't seem to always be the case, though.
+
+If none of this works, do install Github for Windows and use its Git shell. Makes life easier.
+
 
 ## Troubleshooting
 
@@ -62,5 +66,11 @@ fix this, you probably need to fiddle with your system PATH.
     * https://github.com/TooTallNate/node-gyp/issues/297
     * https://code.google.com/p/gyp/issues/detail?id=393
 
+* Other `node-gyp` errors on first build attempt, even though the right node and python versions are installed.
+  * Do try the build command one more time, as experience shows it often works on second try in many of these cases.
+
+
 ### 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.
+* If all fails, 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, and see if yours has already been reported.
+
+* If it hasn't, please open a new issue with your Windows version 32/64bit and a print/screenshot of your build output, incl. the node and python versions.

docs/creating-a-package.md

@@ -227,15 +227,16 @@ or one of its parents has the `tree-view` class applied to it.
 
 You can also add separators and submenus to your context menus. To add a
 submenu, pass in another object instead of a command. To add a separator, use
-`-` for the name and command of the item.
+`-` for the command of the item.
 
 ```coffeescript
 'context-menu':
   '.workspace':
     'Inspect Element': 'core:inspect'
-    '-': '-'
+    'Separator': '-'
     'Text':
       'Select All': 'core:select-all'
+      'Another Separator': '-'
       'Deleted Selected Text': 'core:delete'
 ```
 

exports/atom.coffee

@@ -15,10 +15,15 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
   module.exports.$ = $
   module.exports.$$ = $$
   module.exports.$$$ = $$$
-  module.exports.EditorView = require '../src/editor-view'
+  if atom.config.get('core.useReactMiniEditors')
+    module.exports.EditorView = require '../src/react-editor-view'
+  else
+    module.exports.EditorView = require '../src/editor-view'
   module.exports.ScrollView = require '../src/scroll-view'
   module.exports.SelectListView = require '../src/select-list-view'
   module.exports.Task = require '../src/task'
   module.exports.View = View
   module.exports.WorkspaceView = require '../src/workspace-view'
   module.exports.Workspace = require '../src/workspace'
+  module.exports.React = require 'react-atom-fork'
+  module.exports.Reactionary = require 'reactionary-atom-fork'

keymaps/linux.cson

@@ -26,6 +26,7 @@
   'ctrl-w': 'core:close'
   'ctrl-z': 'core:undo'
   'ctrl-y': 'core:redo'
+  'ctrl-shift-z': 'core:redo'
   'ctrl-x': 'core:cut'
   'ctrl-c': 'core:copy'
   'ctrl-v': 'core:paste'
@@ -38,7 +39,7 @@
   'shift-pageup': 'core:select-page-up'
   'shift-pagedown': 'core:select-page-down'
   'delete': 'core:delete'
-  'shift-delete': 'core:delete'
+  'shift-delete': 'core:cut'
   'pageup': 'core:page-up'
   'pagedown': 'core:page-down'
   'backspace': 'core:backspace'
@@ -95,6 +96,7 @@
   'ctrl-alt-shift-p': 'editor:log-cursor-scope'
   'ctrl-k ctrl-u': 'editor:upper-case'
   'ctrl-k ctrl-l': 'editor:lower-case'
+  'ctrl-l': 'editor:select-line'
 
 '.workspace .editor:not(.mini)':
   # Atom specific

keymaps/win32.cson

@@ -18,6 +18,7 @@
   'F11': 'window:toggle-full-screen'
 
   # Sublime Parity
+  'ctrl-,': 'application:show-settings'
   'ctrl-N': 'application:new-window'
   'ctrl-W': 'window:close'
   'ctrl-o': 'application:open-file'
@@ -26,7 +27,9 @@
   'ctrl-s': 'core:save'
   'ctrl-S': 'core:save-as'
   'ctrl-w': 'core:close'
+  'ctrl-f4': 'core:close'
   'ctrl-z': 'core:undo'
+  'ctrl-shift-z': 'core:redo'
   'ctrl-y': 'core:redo'
   'ctrl-x': 'core:cut'
   'ctrl-c': 'core:copy'
@@ -40,7 +43,7 @@
   'shift-pageup': 'core:select-page-up'
   'shift-pagedown': 'core:select-page-down'
   'delete': 'core:delete'
-  'shift-delete': 'core:delete'
+  'shift-delete': 'core:cut'
   'pageup': 'core:page-up'
   'pagedown': 'core:page-down'
   'backspace': 'core:backspace'
@@ -82,12 +85,15 @@
   'ctrl-delete': 'editor:delete-to-end-of-word'
   'ctrl-home': 'core:move-to-top'
   'ctrl-end': 'core:move-to-bottom'
+  'ctrl-shift-home': 'core:select-to-top'
+  'ctrl-shift-end': 'core:select-to-bottom'
 
   # Sublime Parity
   'ctrl-a': 'core:select-all'
   'ctrl-alt-shift-p': 'editor:log-cursor-scope'
   'ctrl-k ctrl-u': 'editor:upper-case'
   'ctrl-k ctrl-l': 'editor:lower-case'
+  'ctrl-l': 'editor:select-line'
 
 '.workspace .editor:not(.mini)':
   # Atom specific

menus/darwin.cson

@@ -37,7 +37,7 @@
       { label: 'Save As...', command: 'core:save-as' }
       { label: 'Save All', command: 'window:save-all' }
       { type: 'separator' }
-      { label: 'Close Buffer', command: 'core:close' }
+      { label: 'Close Tab', command: 'core:close' }
       { label: 'Close Pane', command: 'pane:close' }
       { label: 'Close Window', command: 'window:close' }
     ]

menus/linux.cson

@@ -14,8 +14,8 @@
       { label: 'Save &As...', command: 'core:save-as' }
       { label: 'Save A&ll', command: 'window:save-all' }
       { type: 'separator' }
-      { label: '&Close Buffer', command: 'core:close' }
-      { label: 'Close All &Buffers', command: 'pane:close' }
+      { label: '&Close Tab', command: 'core:close' }
+      { label: 'Close &Pane', command: 'pane:close' }
       { label: 'Clos&e Window', command: 'window:close' }
       { type: 'separator' }
       { label: 'Quit', command: 'application:quit' }

menus/win32.cson

@@ -9,13 +9,18 @@
       { label: 'Reopen Last &Item', command: 'pane:reopen-closed-item' }
       { type: 'separator' }
       { label: 'Se&ttings', command: 'application:show-settings' }
+      { label: 'Open Your Config', command: 'application:open-your-config' }
+      { label: 'Open Your Init Script', command: 'application:open-your-init-script' }
+      { label: 'Open Your Keymap', command: 'application:open-your-keymap' }
+      { label: 'Open Your Snippets', command: 'application:open-your-snippets' }
+      { label: 'Open Your Stylesheet', command: 'application:open-your-stylesheet' }
       { type: 'separator' }
       { label: '&Save', command: 'core:save' }
       { label: 'Save &As...', command: 'core:save-as' }
       { label: 'Save A&ll', command: 'window:save-all' }
       { type: 'separator' }
-      { label: '&Close Buffer', command: 'core:close' }
-      { label: 'Close All &Buffers', command: 'pane:close' }
+      { label: '&Close Tab', command: 'core:close' }
+      { label: 'Close &Pane', command: 'pane:close' }
       { label: 'Clos&e Window', command: 'window:close' }
       { type: 'separator' }
       { label: 'E&xit', command: 'application:quit' }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "atom",
   "productName": "Atom",
-  "version": "0.113.0",
+  "version": "0.121.0",
   "description": "A hackable text editor for the 21st Century.",
   "main": "./src/browser/main.js",
   "repository": {
@@ -17,126 +17,128 @@
       "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
     }
   ],
-  "atomShellVersion": "0.13.3",
+  "atomShellVersion": "0.15.2",
   "dependencies": {
     "async": "0.2.6",
-    "atom-keymap": "^0.27.0",
+    "atom-keymap": "^1.0.2",
     "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.1",
-    "fs-plus": "^2.2.3",
+    "emissary": "^1.2.2",
+    "first-mate": "^2.0.1",
+    "fs-plus": "^2.2.6",
     "fstream": "0.1.24",
     "fuzzaldrin": "^1.1",
-    "git-utils": "^1.3",
+    "git-utils": "^2.1.3",
     "grim": "0.11.0",
     "guid": "0.0.10",
+    "immutable": "^2.0.4",
     "jasmine-tagged": "^1.1.2",
-    "less-cache": "0.12.0",
+    "less-cache": "0.13.0",
     "mixto": "^1",
     "mkdirp": "0.3.5",
-    "nslog": "0.5.0",
-    "oniguruma": "^1.0.6",
+    "nslog": "^1.0.1",
+    "oniguruma": "^3.0.3",
     "optimist": "0.4.0",
-    "pathwatcher": "^1.3.2",
+    "pathwatcher": "^2.0.6",
     "property-accessors": "^1",
     "q": "^1.0.1",
     "random-words": "0.0.1",
-    "react-atom-fork": "^0.10.0",
-    "reactionary-atom-fork": "^0.9.0",
-    "runas": "0.5.4",
-    "scandal": "0.16.0",
+    "react-atom-fork": "^0.11.2",
+    "reactionary-atom-fork": "^1.0.0",
+    "runas": "1.0.1",
+    "scandal": "1.0.0",
     "scoped-property-store": "^0.9.0",
-    "scrollbar-style": "^0.4.0",
+    "scrollbar-style": "^1.0.2",
     "season": "^1.0.2",
     "semver": "1.1.4",
     "serializable": "^1",
     "space-pen": "3.2.0",
     "temp": "0.7.0",
-    "text-buffer": "^2.4.2",
+    "text-buffer": "^3.0.0",
     "theorist": "^1",
-    "underscore-plus": "^1.5.0",
+    "underscore-plus": "^1.5.1",
     "vm-compatibility-layer": "0.1.0"
   },
   "packageDependencies": {
     "atom-dark-syntax": "0.19.0",
-    "atom-dark-ui": "0.32.0",
+    "atom-dark-ui": "0.33.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",
+    "atom-light-ui": "0.29.0",
+    "base16-tomorrow-dark-theme": "0.20.0",
+    "base16-tomorrow-light-theme": "0.4.0",
+    "solarized-dark-syntax": "0.22.0",
+    "solarized-light-syntax": "0.12.0",
+    "archive-view": "0.35.0",
+    "autocomplete": "0.29.0",
     "autoflow": "0.17.0",
     "autosave": "0.14.0",
     "background-tips": "0.15.0",
     "bookmarks": "0.27.0",
-    "bracket-matcher": "0.48.0",
+    "bracket-matcher": "0.51.0",
     "command-palette": "0.24.0",
     "deprecation-cop": "0.7.0",
-    "dev-live-reload": "0.31.0",
-    "exception-reporting": "0.18.0",
+    "dev-live-reload": "0.33.0",
+    "exception-reporting": "0.19.0",
     "feedback": "0.33.0",
-    "find-and-replace": "0.125.0",
-    "fuzzy-finder": "0.56.0",
-    "git-diff": "0.35.0",
+    "find-and-replace": "0.127.0",
+    "fuzzy-finder": "0.57.0",
+    "git-diff": "0.37.0",
     "go-to-line": "0.23.0",
     "grammar-selector": "0.27.0",
     "image-view": "0.36.0",
-    "keybinding-resolver": "0.18.0",
-    "link": "0.24.0",
-    "markdown-preview": "0.90.0",
-    "metrics": "0.32.0",
+    "incompatible-packages": "0.5.0",
+    "keybinding-resolver": "0.19.0",
+    "link": "0.25.0",
+    "markdown-preview": "0.95.0",
+    "metrics": "0.33.0",
     "open-on-github": "0.29.0",
     "package-generator": "0.31.0",
-    "release-notes": "0.35.0",
-    "settings-view": "0.132.0",
-    "snippets": "0.47.0",
-    "spell-check": "0.38.0",
-    "status-bar": "0.41.0",
+    "release-notes": "0.36.0",
+    "settings-view": "0.137.0",
+    "snippets": "0.51.0",
+    "spell-check": "0.40.0",
+    "status-bar": "0.42.0",
     "styleguide": "0.29.0",
-    "symbols-view": "0.59.0",
-    "tabs": "0.44.0",
-    "timecop": "0.21.0",
-    "tree-view": "0.108.0",
+    "symbols-view": "0.63.0",
+    "tabs": "0.48.0",
+    "timecop": "0.22.0",
+    "tree-view": "0.112.0",
     "update-package-dependencies": "0.6.0",
     "welcome": "0.17.0",
-    "whitespace": "0.23.0",
+    "whitespace": "0.25.0",
     "wrap-guide": "0.21.0",
-
-    "language-c": "0.21.0",
-    "language-coffee-script": "0.24.0",
+    "language-c": "0.26.0",
+    "language-coffee-script": "0.28.0",
     "language-css": "0.17.0",
-    "language-gfm": "0.42.0",
+    "language-gfm": "0.45.0",
     "language-git": "0.9.0",
-    "language-go": "0.13.0",
+    "language-go": "0.16.0",
     "language-html": "0.22.0",
     "language-hyperlink": "0.10.0",
     "language-java": "0.11.0",
-    "language-javascript": "0.33.0",
+    "language-javascript": "0.39.0",
     "language-json": "0.8.0",
-    "language-less": "0.12.0",
+    "language-less": "0.13.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.32.0",
+    "language-ruby": "0.33.0",
     "language-ruby-on-rails": "0.15.0",
-    "language-sass": "0.13.0",
+    "language-sass": "0.14.0",
     "language-shellscript": "0.8.0",
-    "language-source": "0.7.0",
+    "language-source": "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.15.0",
-    "language-yaml": "0.11.0"
+    "language-xml": "0.17.0",
+    "language-yaml": "0.14.0"
   },
   "private": true,
   "scripts": {

script/bootstrap

@@ -44,23 +44,44 @@ function bootstrap() {
   var apmInstallCommand = npmPath + npmFlags + 'install';
   var apmInstallOptions = {cwd: apmInstallPath};
   var moduleInstallCommand = apmPath + ' install' + apmFlags;
-  var dedupeCommand = apmPath + ' dedupe' + apmFlags;
+  var dedupeApmCommand = apmPath + ' dedupe' + apmFlags;
+  var dedupeNpmCommand = npmPath + npmFlags + 'dedupe';
 
   if (process.argv.indexOf('--no-quiet') === -1) {
     buildInstallCommand  += ' --quiet';
     apmInstallCommand    += ' --quiet';
     moduleInstallCommand += ' --quiet';
-    dedupeCommand        += ' --quiet';
+    dedupeApmCommand     += ' --quiet';
+    dedupeNpmCommand     += ' --quiet';
     buildInstallOptions.ignoreStdout = true;
     apmInstallOptions.ignoreStdout = true;
   }
 
+  // apm ships with 32-bit node so make sure its native modules are compiled
+  // for a 32-bit target architecture
+  if (process.env.JANKY_SHA1 && process.platform === 'win32')
+    apmInstallCommand += ' --arch=ia32';
+
   var commands = [
-    {command: buildInstallCommand, message: 'Installing build modules...', options: buildInstallOptions},
-    {command: apmInstallCommand, message: 'Installing apm...', options: apmInstallOptions},
+    {
+      command: buildInstallCommand,
+      message: 'Installing build modules...',
+      options: buildInstallOptions
+    },
+    {
+      command: apmInstallCommand,
+      message: 'Installing apm...',
+      options: apmInstallOptions
+    },
     apmPath + ' clean' + apmFlags,
     moduleInstallCommand,
-    dedupeCommand + ' ' + packagesToDedupe.join(' '),
+    dedupeApmCommand + ' ' + packagesToDedupe.join(' '),
+    {
+      command: dedupeNpmCommand + ' request semver',
+      options: {
+        cwd: path.resolve(__dirname, '..', 'apm', 'node_modules', 'atom-package-manager')
+      }
+    },
   ];
 
   process.chdir(path.dirname(__dirname));

script/clean

@@ -24,6 +24,7 @@ var commands = [
   [home, '.atom', 'storage'],
   [home, '.atom', '.npm'],
   [home, '.atom', 'compile-cache'],
+  [home, '.atom', 'atom-shell'],
   [tmpdir, 'atom-build'],
   [tmpdir, 'atom-cached-atom-shells'],
 ];

spec/atom-spec.coffee

@@ -531,7 +531,7 @@ describe "the `atom` global", ->
   describe ".isReleasedVersion()", ->
     it "returns false if the version is a SHA and true otherwise", ->
       version = '0.1.0'
-      spyOn(atom.constructor, 'getVersion').andCallFake -> version
+      spyOn(atom, 'getVersion').andCallFake -> version
       expect(atom.isReleasedVersion()).toBe true
       version = '36b5518'
       expect(atom.isReleasedVersion()).toBe false

spec/context-menu-manager-spec.coffee

@@ -30,6 +30,16 @@ describe "ContextMenuManager", ->
       expect(contextMenu.definitions['.selector'][0].command).toEqual 'command'
       expect(contextMenu.definitions['.selector'].length).toBe 1
 
+    it 'allows multiple separators', ->
+      contextMenu.add 'file-path',
+        '.selector':
+          'separator1': '-'
+          'separator2': '-'
+
+      expect(contextMenu.definitions['.selector'].length).toBe 2
+      expect(contextMenu.definitions['.selector'][0].type).toEqual 'separator'
+      expect(contextMenu.definitions['.selector'][1].type).toEqual 'separator'
+
     it 'allows duplicate commands with different labels',  ->
       contextMenu.add 'file-path',
         '.selector':

spec/display-state-manager-spec.coffee

@@ -0,0 +1,345 @@
+Immutable = require 'immutable'
+_ = require 'underscore-plus'
+DisplayStateManager = require '../src/display-state-manager'
+TextBuffer = require 'text-buffer'
+Editor = require '../src/editor'
+
+fdescribe "DisplayStateManager", ->
+  [buffer, editor, stateManager] = []
+
+  beforeEach ->
+    @addMatchers
+      toHaveValues: ToHaveValuesMatcher
+
+    spyOn(DisplayStateManager::, 'getTileSize').andReturn 5
+
+    buffer = new TextBuffer(filePath: atom.project.resolve('sample.js'))
+    buffer.loadSync()
+    buffer.insert([12, 3], '\n' + buffer.getText()) # repeat text so we have more lines
+
+    editor = new Editor({buffer})
+    editor.setLineHeightInPixels(10)
+    editor.setDefaultCharWidth(10)
+    editor.setHeight(100)
+    editor.setWidth(500)
+
+    stateManager = new DisplayStateManager(editor)
+
+  afterEach ->
+    editor.destroy()
+
+  describe "initial state", ->
+    it "breaks the visible lines into tiles", ->
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          startRow: 0
+          left: 0
+          top: 0
+          width: editor.getScrollWidth()
+          height: 50
+          lineHeightInPixels: 10
+          lines: editor.linesForScreenRows(0, 4)
+        5:
+          startRow: 5
+          left: 0
+          top: 50
+          width: editor.getScrollWidth()
+          height: 50
+          lineHeightInPixels: 10
+          lines: editor.linesForScreenRows(5, 9)
+        10:
+          startRow: 10
+          left: 0
+          top: 100
+          width: editor.getScrollWidth()
+          height: 50
+          lineHeightInPixels: 10
+          lines: editor.linesForScreenRows(10, 14)
+
+  describe "when the height is changed", ->
+    it "updates the rendered tiles based on the new height", ->
+      editor.setHeight(150)
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          startRow: 0
+          top: 0
+        5:
+          startRow: 5
+          top: 50
+        10:
+          startRow: 10
+          top: 100
+        15:
+          startRow: 15
+          top: 150
+
+      editor.setHeight(70)
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          startRow: 0
+          top: 0
+        5:
+          startRow: 5
+          top: 50
+
+  describe "when the width is changed", ->
+    it "updates the tiles with the new width", ->
+      editor.setWidth(700)
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          width: 700
+        5:
+          width: 700
+        10:
+          width: 700
+
+  describe "when the lineHeightInPixels is changed", ->
+    it "updates the rendered tiles and assigns a new lineHeightInPixels value to all tiles", ->
+      editor.setScrollTop(10)
+      editor.setLineHeightInPixels(7)
+
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          startRow: 0
+          top: 0 - 10
+          lineHeightInPixels: 7
+        5:
+          startRow: 5
+          top: 7 * 5 - 10
+          lineHeightInPixels: 7
+        10:
+          startRow: 10
+          top: 7 * 10 - 10
+          lineHeightInPixels: 7
+        15:
+          startRow: 15
+          top: 7 * 15 - 10
+          lineHeightInPixels: 7
+
+  describe "when the editor is scrolled vertically", ->
+    it "updates the visible tiles and their top positions", ->
+      editor.setScrollTop(20)
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          left: 0
+          top: -20
+        5:
+          left: 0
+          top: 30
+        10:
+          left: 0
+          top: 80
+
+      editor.setScrollTop(70)
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        5:
+          left: 0
+          top: -20
+        10:
+          left: 0
+          top: 30
+        15:
+          left: 0
+          top: 80
+
+  describe "when the editor is scrolled horizontally", ->
+    it "updates the left position of the visible tiles", ->
+      editor.setScrollLeft(30)
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          left: -30
+        5:
+          left: -30
+        10:
+          left: -30
+
+  describe "when the lines are changed", ->
+    it "updates the lines in the tiles", ->
+      buffer.setTextInRange([[3, 5], [7, 0]], "a\nb\nc\nd")
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          lines: editor.linesForScreenRows(0, 4)
+        5:
+          lines: editor.linesForScreenRows(5, 9)
+        10:
+          lines: editor.linesForScreenRows(10, 14)
+
+  describe "line decorations", ->
+    marker = null
+
+    beforeEach ->
+      marker = editor.markBufferRange([[3, 4], [5, 6]], invalidate: 'touch')
+
+    it "updates the display state when decorations are added, updated, invalidated, or removed", ->
+      decoration = editor.decorateMarker(marker, type: 'line', class: 'test')
+
+      decorationParamsById = {}
+      decorationParamsById[decoration.id] = decoration.getParams()
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          lineDecorations:
+            3: decorationParamsById
+            4: decorationParamsById
+        5:
+          lineDecorations:
+            5: decorationParamsById
+
+      marker.setBufferRange([[8, 4], [10, 6]])
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          lineDecorations:
+            3: null
+            4: null
+        5:
+          lineDecorations:
+            5: null
+            8: decorationParamsById
+            9: decorationParamsById
+        10:
+          lineDecorations:
+            10: decorationParamsById
+
+      buffer.insert([8, 5], 'invalidate marker')
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        5:
+          lineDecorations:
+            8: null
+            9: null
+        10:
+          lineDecorations:
+            10: null
+
+      buffer.undo()
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        5:
+          lineDecorations:
+            8: decorationParamsById
+            9: decorationParamsById
+        10:
+          lineDecorations:
+            10: decorationParamsById
+
+      marker.destroy()
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        5:
+          lineDecorations:
+            8: null
+            9: null
+        10:
+          lineDecorations:
+            10: null
+
+    it "renders line decorations in the initial state", ->
+      decoration = editor.decorateMarker(marker, type: 'line', class: 'test')
+
+      newStateManager = new DisplayStateManager(editor)
+
+      decorationParamsById = {}
+      decorationParamsById[decoration.id] = decoration.getParams()
+      expect(stateManager.getState().get('tiles')).toHaveValues
+        0:
+          lineDecorations:
+            3: decorationParamsById
+            4: decorationParamsById
+        5:
+          lineDecorations:
+            5: decorationParamsById
+
+    describe "when the decoration's 'onlyHead' property is true", ->
+      it "only applies the decoration to lines containing the marker's head", ->
+        decoration = editor.decorateMarker(marker, type: 'line', class: 'only-head', onlyHead: true)
+        decorationParamsById = {}
+        decorationParamsById[decoration.id] = decoration.getParams()
+
+        expect(stateManager.getState().get('tiles')).toHaveValues
+          0:
+            lineDecorations:
+              3: null
+              4: null
+          5:
+            lineDecorations:
+              5: decorationParamsById
+
+    describe "when the decoration's 'onlyEmpty' property is true", ->
+      it "only applies the decoration if the marker is empty", ->
+        decoration = editor.decorateMarker(marker, type: 'line', class: 'only-empty', onlyEmpty: true)
+        decorationParamsById = {}
+        decorationParamsById[decoration.id] = decoration.getParams()
+
+        expect(stateManager.getState().get('tiles')).toHaveValues
+          0:
+            lineDecorations:
+              3: null
+              4: null
+          5:
+            lineDecorations:
+              5: null
+
+        marker.clearTail()
+        expect(stateManager.getState().get('tiles')).toHaveValues
+          0:
+            lineDecorations:
+              3: null
+              4: null
+          5:
+            lineDecorations:
+              5: decorationParamsById
+
+    describe "when the decoration's 'onlyNonEmpty' property is true", ->
+      it "only applies the decoration if the marker is non-empty", ->
+        decoration = editor.decorateMarker(marker, type: 'line', class: 'only-non-empty', onlyNonEmpty: true)
+        decorationParamsById = {}
+        decorationParamsById[decoration.id] = decoration.getParams()
+
+        expect(stateManager.getState().get('tiles')).toHaveValues
+          0:
+            lineDecorations:
+              3: decorationParamsById
+              4: decorationParamsById
+          5:
+            lineDecorations:
+              5: decorationParamsById
+
+        marker.clearTail()
+        expect(stateManager.getState().get('tiles')).toHaveValues
+          0:
+            lineDecorations:
+              3: null
+              4: null
+          5:
+            lineDecorations:
+              5: null
+
+ToHaveValuesMatcher = (expected) ->
+  hasAllValues = true
+  wrongValues = {}
+
+  checkValues = (actual, expected, keyPath=[]) ->
+   for key, expectedValue of expected
+    key = numericKey if numericKey = parseInt(key)
+    currentKeyPath = keyPath.concat([key])
+
+    if expectedValue?
+      if actual.hasOwnProperty(key)
+        actualValue = actual[key]
+        if expectedValue.constructor is Object and _.size(expectedValue) > 0
+          checkValues(actualValue, expectedValue, currentKeyPath)
+        else
+          unless _.isEqual(actualValue, expectedValue)
+            hasAllValues = false
+            _.setValueForKeyPath(wrongValues, currentKeyPath.join('.'), {actualValue, expectedValue})
+      else
+        hasAllValues = false
+        _.setValueForKeyPath(wrongValues, currentKeyPath.join('.'), {expectedValue})
+    else
+      actualValue = actual[key]
+      if actualValue?
+        hasAllValues = false
+        _.setValueForKeyPath(wrongValues, currentKeyPath.join('.'), {actualValue, expectedValue})
+
+
+  notText = if @isNot then " not" else ""
+  this.message = => "Immutable object did not have expected values: #{jasmine.pp(wrongValues)}"
+  checkValues(@actual.toJS(), expected)
+  console.warn "Invalid values:", wrongValues unless hasAllValues
+  hasAllValues

spec/editor-spec.coffee

@@ -1240,6 +1240,8 @@ describe "Editor", ->
         expect(editor.getSelectedBufferRanges()).toEqual [[[0, 0], [0, 0]], [[3, 4], [5, 6]]]
 
       it "autoscrolls to the added selection if needed", ->
+        editor.manageScrollPosition = true
+
         editor.setLineHeightInPixels(10)
         editor.setDefaultCharWidth(10)
         editor.setHeight(50)
@@ -2079,6 +2081,20 @@ describe "Editor", ->
               editor.indent()
               expect(buffer.lineForRow(0)).toMatch(tabRegex)
 
+            it "respects the tab stops when cursor is in the middle of a tab", ->
+              editor.setTabLength(4)
+              buffer.insert([12, 2], "\n ")
+              editor.setCursorBufferPosition [13, 1]
+              editor.indent()
+              expect(buffer.lineForRow(13)).toMatch /^\s+$/
+              expect(buffer.lineForRow(13).length).toBe 4
+              expect(editor.getCursorBufferPosition()).toEqual [13, 4]
+
+              buffer.insert([13, 0], "  ")
+              editor.setCursorBufferPosition [13, 6]
+              editor.indent()
+              expect(buffer.lineForRow(13).length).toBe 8
+
           describe "if 'softTabs' is false", ->
             it "insert a \t into the buffer", ->
               editor.setSoftTabs(false)
@@ -2097,6 +2113,20 @@ describe "Editor", ->
                 expect(buffer.lineForRow(5).length).toBe 6
                 expect(editor.getCursorBufferPosition()).toEqual [5, 6]
 
+              it "respects the tab stops when cursor is in the middle of a tab", ->
+                editor.setTabLength(4)
+                buffer.insert([12, 2], "\n ")
+                editor.setCursorBufferPosition [13, 1]
+                editor.indent(autoIndent: true)
+                expect(buffer.lineForRow(13)).toMatch /^\s+$/
+                expect(buffer.lineForRow(13).length).toBe 4
+                expect(editor.getCursorBufferPosition()).toEqual [13, 4]
+
+                buffer.insert([13, 0], "  ")
+                editor.setCursorBufferPosition [13, 6]
+                editor.indent(autoIndent: true)
+                expect(buffer.lineForRow(13).length).toBe 8
+
             describe "when 'softTabs' is false", ->
               it "moves the cursor to the end of the leading whitespace and inserts enough tabs to bring the line to the suggested level of indentaion", ->
                 convertToHardTabs(buffer)
@@ -2827,7 +2857,7 @@ describe "Editor", ->
 
             atom.config.set("editor.autoIndent", false)
             editor.indent()
-            expect(editor.lineForBufferRow(2)).toBe "   "
+            expect(editor.lineForBufferRow(2)).toBe "  "
 
       describe "when editor.autoIndent is true", ->
         beforeEach ->
@@ -3271,20 +3301,25 @@ describe "Editor", ->
       expect(editor.getText()).toBe '     '
 
   describe ".scrollToCursorPosition()", ->
-    it "scrolls the last cursor into view", ->
+    it "scrolls the last cursor into view, centering around the cursor if possible and the 'center' option isn't false", ->
       editor.setCursorScreenPosition([8, 8])
       editor.setLineHeightInPixels(10)
       editor.setDefaultCharWidth(10)
-      editor.setHeight(50)
+      editor.setHeight(60)
       editor.setWidth(50)
       editor.setHorizontalScrollbarHeight(0)
       expect(editor.getScrollTop()).toBe 0
       expect(editor.getScrollLeft()).toBe 0
 
       editor.scrollToCursorPosition()
-      expect(editor.getScrollBottom()).toBe (9 + editor.getVerticalScrollMargin()) * 10
+      expect(editor.getScrollTop()).toBe (8.5 * 10) - 30
+      expect(editor.getScrollBottom()).toBe (8.5 * 10) + 30
       expect(editor.getScrollRight()).toBe (9 + editor.getHorizontalScrollMargin()) * 10
 
+      editor.setScrollTop(0)
+      editor.scrollToCursorPosition(center: false)
+      expect(editor.getScrollBottom()).toBe (9 + editor.getVerticalScrollMargin()) * 10
+
   describe ".pageUp/Down()", ->
     it "scrolls one screen height up or down and moves the cursor one page length", ->
       editor.manageScrollPosition = true

spec/editor-view-spec.coffee

@@ -2652,7 +2652,6 @@ describe "EditorView", ->
             expect(editor.getCursorBufferPosition()).toEqual [0, 0]
             expect(buffer.lineForRow(0)).toBe 'var quicksort = function () {'
             expect(buffer.lineForRow(13)).toBe 'var a = function() {'
-            editor.logScreenLines()
             expect(editor.isFoldedAtBufferRow(0)).toBe true
             expect(editor.isFoldedAtBufferRow(13)).toBe true
 

spec/fixtures/js

@@ -1 +0,0 @@
-this tests files with no extensions

spec/fixtures/packages/package-with-incompatible-native-module/node_modules/native-module/main.js

@@ -0,0 +1 @@
+throw new Error("this simulates a native module's failure to load")

spec/fixtures/packages/package-with-incompatible-native-module/node_modules/native-module/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "native-module",
+  "main": "./main.js"
+}

spec/fixtures/packages/package-with-incompatible-native-module/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "package-with-incompatible-native-module",
+  "version": "1.0",
+  "main": "./main.js"
+}

spec/fixtures/packages/package-with-infinite-loop-grammar/grammars/grammar.cson

@@ -1,18 +0,0 @@
-'fileTypes': ['package-with-infinite-loop-grammar']
-'name': 'package-with-infinite-loop-grammar'
-'scopeName': 'source.package-with-infinite-loop-grammar'
-
-# This grammar should loop forever if the line contains an `a`
-'patterns': [
-  {
-    'name': 'start'
-    'begin': '^'
-    'end': '$'
-    'patterns': [
-      {
-        name: 'negative-look-ahead'
-        match: "(?!a)"
-      }
-    ]
-  }
-]

spec/fixtures/packages/package-with-snippets/snippets/.hidden-file

@@ -1 +0,0 @@
-This is a hidden file. Don't even try to load it as a snippet

spec/fixtures/packages/package-with-snippets/snippets/junk-file

@@ -1 +0,0 @@
-This file isn't CSON, but shouldn't be a big deal

spec/fixtures/packages/package-with-snippets/snippets/test.cson

@@ -1,4 +0,0 @@
-".test":
-  "Test Snippet":
-    prefix: "test"
-    body: "testing 123"

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

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

spec/fixtures/packages/theme-with-incomplete-ui-variables/stylesheets/editor.less

@@ -0,0 +1,10 @@
+@import "ui-variables";
+
+.editor {
+  padding-top: @component-padding;
+  padding-right: @component-padding;
+  padding-bottom: @component-padding;
+
+  color: @input-background-color;
+  background-color: @background-color-info; // From the fallback variables, not overridden
+}

spec/fixtures/packages/theme-with-incomplete-ui-variables/stylesheets/ui-variables.less

@@ -0,0 +1,3 @@
+// This does not contain all of the ui-variables available.
+@app-background-color: #00f; // Changed
+@input-background-color: #f00; // Changed

spec/fixtures/packages/theme-with-multiple-imported-files/index.less

@@ -1,3 +0,0 @@
-@import "stylesheets/first";
-@import "stylesheets/second";
-@import "stylesheets/last";

spec/fixtures/packages/theme-with-multiple-imported-files/package.json

@@ -1,3 +0,0 @@
-{
-  "theme": "ui"
-}

spec/fixtures/packages/theme-with-multiple-imported-files/stylesheets/first.less

@@ -1,7 +0,0 @@
-.editor {
-  padding-top: 101px;
-  padding-right: 101px;
-  padding-bottom: 101px;
-
-  color: red;
-}

spec/fixtures/packages/theme-with-multiple-imported-files/stylesheets/last.less

@@ -1,5 +0,0 @@
-.editor {
-/*  padding-top: 103px;
-  padding-right: 103px;*/
-  padding-bottom: 103px;
-}

spec/fixtures/packages/theme-with-multiple-imported-files/stylesheets/second.less

@@ -1,9 +0,0 @@
-@import "ui-variables";
-
-@number: 102px;
-
-.editor {
-/*  padding-top: 102px;*/
-  padding-right: @number;
-  padding-bottom: @number;
-}

spec/fixtures/packages/theme-with-multiple-imported-files/stylesheets/ui-variables.less

@@ -1,75 +0,0 @@
-// Variables different from the original are marked 'Changed'
-
-@text-color: #333;
-@text-color-subtle: #777;
-@text-color-highlight: #111;
-@text-color-selected: @text-color-highlight;
-
-@text-color-info: #5293d8;
-@text-color-success: #1fe977;
-@text-color-warning: #f78a46;
-@text-color-error: #c00;
-
-@background-color-info: #0098ff;
-@background-color-success: #17ca65;
-@background-color-warning: #ff4800;
-@background-color-error: #c00;
-@background-color-highlight: rgba(255, 255, 255, 0.10);
-@background-color-selected: @background-color-highlight;
-
-@app-background-color: #00f; // Changed
-
-@base-background-color: #fff;
-@base-border-color: #eee;
-
-@pane-item-background-color: @base-background-color;
-@pane-item-border-color: @base-border-color;
-
-@input-background-color: #f00; // Changed
-@input-border-color: @base-border-color;
-
-@tool-panel-background-color: #f4f4f4;
-@tool-panel-border-color: @base-border-color;
-
-@inset-panel-background-color: #eee;
-@inset-panel-border-color: @base-border-color;
-
-@panel-heading-background-color: #ddd;
-@panel-heading-border-color: transparent;
-
-@overlay-background-color: #f4f4f4;
-@overlay-border-color: @base-border-color;
-
-@button-background-color: #ccc;
-@button-background-color-hover: lighten(@button-background-color, 5%);
-@button-background-color-selected: @button-background-color-hover;
-@button-border-color: #aaa;
-
-@tab-bar-background-color: #fff;
-@tab-bar-border-color: darken(@tab-background-color-active, 10%);
-@tab-background-color: #f4f4f4;
-@tab-background-color-active: #fff;
-@tab-border-color: @base-border-color;
-
-@tree-view-background-color: @tool-panel-background-color;
-@tree-view-border-color: @tool-panel-border-color;
-
-@ui-site-color-1: @background-color-success; // green
-@ui-site-color-2: @background-color-info; // blue
-@ui-site-color-3: @background-color-warning; // orange
-@ui-site-color-4: #db2ff4; // purple
-@ui-site-color-5: #f5e11d; // yellow
-
-@font-size: 12px;
-
-@disclosure-arrow-size: 12px;
-
-@component-padding: 150px;
-@component-icon-padding: 5px;
-@component-icon-size: 16px;
-@component-line-height: 25px;
-@component-border-radius: 2px;
-
-@tab-height: 30px;
-
-@font-family: Arial;

spec/fixtures/replication/home-1/project/file-1.txt

@@ -1 +0,0 @@
-Hello World!

spec/fixtures/replication/home-1/project/file-2.txt

@@ -1 +0,0 @@
-Goodbye World!

spec/fixtures/replication/home-2/project/file-1.txt

@@ -1 +0,0 @@
-Hello World!

spec/fixtures/replication/home-2/project/file-2.txt

@@ -1 +0,0 @@
-Goodbye World!

spec/fixtures/sample-with-error.less

@@ -1 +0,0 @@
-#header {

spec/fixtures/sample.plist

@@ -1,71 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>fileTypes</key>
-	<array>
-		<string>txt</string>
-	</array>
-	<key>keyEquivalent</key>
-	<string>^~P</string>
-	<key>name</key>
-	<string>Plain Text</string>
-	<key>patterns</key>
-	<array>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.item.text</string>
-				</dict>
-			</dict>
-			<key>match</key>
-			<string>^\s*(•).*$\n?</string>
-			<key>name</key>
-			<string>meta.bullet-point.strong.text</string>
-		</dict>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.item.text</string>
-				</dict>
-			</dict>
-			<key>match</key>
-			<string>^\s*(·).*$\n?</string>
-			<key>name</key>
-			<string>meta.bullet-point.light.text</string>
-		</dict>
-		<dict>
-			<key>captures</key>
-			<dict>
-				<key>1</key>
-				<dict>
-					<key>name</key>
-					<string>punctuation.definition.item.text</string>
-				</dict>
-			</dict>
-			<key>match</key>
-			<string>^\s*(\*).*$\n?</string>
-			<key>name</key>
-			<string>meta.bullet-point.star.text</string>
-		</dict>
-		<dict>
-			<key>begin</key>
-			<string>^([ \t]*)(?=\S)</string>
-			<key>contentName</key>
-			<string>meta.paragraph.text</string>
-			<key>end</key>
-			<string>^(?!\1(?=\S))</string>
-		</dict>
-	</array>
-	<key>scopeName</key>
-	<string>text.plain</string>
-	<key>uuid</key>
-	<string>3130E4FA-B10E-11D9-9F75-000D93589AF6</string>
-</dict>
-</plist>

spec/fixtures/symlink-to-dir

@@ -1 +0,0 @@
-dir

spec/fixtures/symlink-to-file

@@ -1 +0,0 @@
-sample.js

spec/fixtures/zed/a

@@ -1 +0,0 @@
-a

spec/jasmine-helper.coffee

@@ -1,7 +1,8 @@
 fs = require 'fs'
 
 module.exports.runSpecSuite = (specSuite, logFile, logErrors=true) ->
-  {$, $$} = require 'atom'
+  {$, $$} = require '../src/space-pen-extensions'
+
   window[key] = value for key, value of require '../vendor/jasmine'
 
   {TerminalReporter} = require 'jasmine-tagged'

spec/package-spec.coffee

@@ -1,8 +1,39 @@
 {$} = require 'atom'
 path = require 'path'
+Package = require '../src/package'
 ThemePackage = require '../src/theme-package'
 
 describe "Package", ->
+  describe "when the package contains incompatible native modules", ->
+    beforeEach ->
+      spyOn(atom, 'inDevMode').andReturn(false)
+
+    it "does not activate it", ->
+      packagePath = atom.project.resolve('packages/package-with-incompatible-native-module')
+      pack = new Package(packagePath)
+      expect(pack.isCompatible()).toBe false
+      expect(pack.incompatibleModules[0].name).toBe 'native-module'
+      expect(pack.incompatibleModules[0].path).toBe path.join(packagePath, 'node_modules', 'native-module')
+
+    it "caches the incompatible native modules in local storage", ->
+      packagePath = atom.project.resolve('packages/package-with-incompatible-native-module')
+      cacheKey = null
+      cacheItem = null
+
+      spyOn(global.localStorage, 'setItem').andCallFake (key, item) ->
+        cacheKey = key
+        cacheItem = item
+      spyOn(global.localStorage, 'getItem').andCallFake (key) ->
+        return cacheItem if cacheKey is key
+
+      expect(new Package(packagePath).isCompatible()).toBe false
+      expect(global.localStorage.getItem.callCount).toBe 1
+      expect(global.localStorage.setItem.callCount).toBe 1
+
+      expect(new Package(packagePath).isCompatible()).toBe false
+      expect(global.localStorage.getItem.callCount).toBe 2
+      expect(global.localStorage.setItem.callCount).toBe 1
+
   describe "theme", ->
     theme = null
 

spec/spec-helper.coffee

@@ -130,6 +130,8 @@ afterEach ->
   atom.project?.destroy()
   atom.project = null
 
+  atom.themes.removeStylesheet('global-editor-styles')
+
   delete atom.state.packageStates
 
   $('#jasmine-content').empty() unless window.debugContent
@@ -318,9 +320,13 @@ window.setEditorWidthInChars = (editorView, widthInChars, charWidth=editorView.c
   editorView.width(charWidth * widthInChars + editorView.gutter.outerWidth())
   $(window).trigger 'resize' # update width of editor view's on-screen lines
 
-window.setEditorHeightInLines = (editorView, heightInChars, charHeight=editorView.lineHeight) ->
-  editorView.height(charHeight * heightInChars + editorView.renderedLines.position().top)
-  $(window).trigger 'resize' # update editor view's on-screen lines
+window.setEditorHeightInLines = (editorView, heightInLines, lineHeight=editorView.lineHeight) ->
+  if editorView.hasClass('react')
+    editorView.height(editorView.getEditor().getLineHeightInPixels() * heightInLines)
+    editorView.component?.measureHeightAndWidth()
+  else
+    editorView.height(lineHeight * heightInLines + editorView.renderedLines.position().top)
+    $(window).trigger 'resize' # update editor view's on-screen lines
 
 $.fn.resultOfTrigger = (type) ->
   event = $.Event(type)

spec/spec-suite.coffee

@@ -1,6 +1,5 @@
 _ = require 'underscore-plus'
 fs = require 'fs-plus'
-{Git} = require 'atom'
 path = require 'path'
 require './spec-helper'
 

spec/theme-manager-spec.coffee

@@ -232,6 +232,21 @@ describe "ThemeManager", ->
         expect($(".editor").css("padding-right")).toBe "150px"
         expect($(".editor").css("padding-bottom")).toBe "150px"
 
+    describe "when there is a theme with incomplete variables", ->
+      it "loads the correct values from the fallback ui-variables", ->
+        themeManager.on 'reloaded', reloadHandler = jasmine.createSpy()
+        atom.config.set('core.themes', ['theme-with-incomplete-ui-variables'])
+
+        waitsFor ->
+          reloadHandler.callCount > 0
+
+        runs ->
+          # an override loaded in the base css
+          expect(atom.workspaceView.css("background-color")).toBe "rgb(0, 0, 255)"
+
+          # from within the theme itself
+          expect($(".editor").css("background-color")).toBe "rgb(0, 152, 255)"
+
   describe "when the user stylesheet changes", ->
     it "reloads it", ->
       [stylesheetRemovedHandler, stylesheetAddedHandler, stylesheetsChangedHandler] = []

spec/workspace-view-spec.coffee

@@ -20,7 +20,6 @@ describe "WorkspaceView", ->
     waitsForPromise ->
       atom.workspace.open(pathToOpen)
 
-
   describe "@deserialize()", ->
     viewState = null
 
@@ -294,3 +293,31 @@ describe "WorkspaceView", ->
       expect(atom.workspaceView).toHaveClass 'scrollbars-visible-always'
       scrollbarStyle.emitValue 'overlay'
       expect(atom.workspaceView).toHaveClass 'scrollbars-visible-when-scrolling'
+
+  describe "editor font styling", ->
+    [editorNode, editor] = []
+
+    beforeEach ->
+      atom.workspaceView.attachToDom()
+      editorNode = atom.workspaceView.find('.editor')[0]
+      editor = atom.workspaceView.find('.editor').view().getEditor()
+
+    it "updates the font-size based on the 'editor.fontSize' config value", ->
+      initialCharWidth = editor.getDefaultCharWidth()
+      expect(getComputedStyle(editorNode).fontSize).toBe atom.config.get('editor.fontSize') + 'px'
+      atom.config.set('editor.fontSize', atom.config.get('editor.fontSize') + 5)
+      expect(getComputedStyle(editorNode).fontSize).toBe atom.config.get('editor.fontSize') + 'px'
+      expect(editor.getDefaultCharWidth()).toBeGreaterThan initialCharWidth
+
+    it "updates the font-family based on the 'editor.fontFamily' config value", ->
+      initialCharWidth = editor.getDefaultCharWidth()
+      expect(getComputedStyle(editorNode).fontFamily).toBe atom.config.get('editor.fontFamily')
+      atom.config.set('editor.fontFamily', 'sans-serif')
+      expect(getComputedStyle(editorNode).fontFamily).toBe atom.config.get('editor.fontFamily')
+      expect(editor.getDefaultCharWidth()).not.toBe initialCharWidth
+
+    it "updates the line-height based on the 'editor.lineHeight' config value", ->
+      initialLineHeight = editor.getLineHeightInPixels()
+      atom.config.set('editor.lineHeight', '30px')
+      expect(getComputedStyle(editorNode).lineHeight).toBe atom.config.get('editor.lineHeight')
+      expect(editor.getLineHeightInPixels()).not.toBe initialLineHeight

src/atom.coffee

@@ -110,14 +110,6 @@ class Atom extends Model
   @getCurrentWindow: ->
     remote.getCurrentWindow()
 
-  # Get the version of the Atom application.
-  @getVersion: ->
-    @appVersion ?= @getLoadSettings().appVersion
-
-  # Determine whether the current version is an official release.
-  @isReleasedVersion: ->
-    not /\w{7}/.test(@getVersion()) # Check if the release is a 7-character SHA prefix
-
   workspaceViewParentSelector: 'body'
 
   # Call .loadOrCreate instead
@@ -158,7 +150,7 @@ class Atom extends Model
     process.env.NODE_PATH = exportsPath
 
     # Make react.js faster
-    process.env.NODE_ENV ?= 'production'
+    process.env.NODE_ENV ?= 'production' unless devMode
 
     @config = new Config({configDirPath, resourcePath})
     @keymaps = new KeymapManager({configDirPath, resourcePath})
@@ -225,9 +217,15 @@ class Atom extends Model
     else
       @center()
 
+  # Returns true if the dimensions are useable, false if they should be ignored.
+  # Work around for https://github.com/atom/atom-shell/issues/473
+  isValidDimensions: ({x, y, width, height}={}) ->
+    width > 0 and height > 0 and x + width > 0 and y + height > 0
+
   storeDefaultWindowDimensions: ->
-    dimensions = JSON.stringify(atom.getWindowDimensions())
-    localStorage.setItem("defaultWindowDimensions", dimensions)
+    dimensions = @getWindowDimensions()
+    if @isValidDimensions(dimensions)
+      localStorage.setItem("defaultWindowDimensions", JSON.stringify(dimensions))
 
   getDefaultWindowDimensions: ->
     {windowDimensions} = @getLoadSettings()
@@ -240,15 +238,21 @@ class Atom extends Model
       console.warn "Error parsing default window dimensions", error
       localStorage.removeItem("defaultWindowDimensions")
 
-    {width, height} = screen.getPrimaryDisplay().workAreaSize
-    dimensions ? {x: 0, y: 0, width: Math.min(1024, width), height: height}
+    if @isValidDimensions(dimensions)
+      dimensions
+    else
+      {width, height} = screen.getPrimaryDisplay().workAreaSize
+      {x: 0, y: 0, width: Math.min(1024, width), height}
 
   restoreWindowDimensions: ->
-    windowDimensions = @state.windowDimensions ? @getDefaultWindowDimensions()
-    @setWindowDimensions(windowDimensions)
+    dimensions = @state.windowDimensions
+    unless @isValidDimensions(dimensions)
+      dimensions = @getDefaultWindowDimensions()
+    @setWindowDimensions(dimensions)
 
   storeWindowDimensions: ->
-    @state.windowDimensions = @getWindowDimensions()
+    dimensions = @getWindowDimensions()
+    @state.windowDimensions = dimensions if @isValidDimensions(dimensions)
 
   # Public: Get the load settings for the current window.
   #
@@ -434,7 +438,7 @@ class Atom extends Model
   # width  - The {Number} of pixels.
   # height - The {Number} of pixels.
   setSize: (width, height) ->
-    ipc.send('call-window-method', 'setSize', width, height)
+    @getCurrentWindow().setSize(width, height)
 
   # Public: Set the position of current window.
   #
@@ -491,11 +495,11 @@ class Atom extends Model
   #
   # Returns the version text {String}.
   getVersion: ->
-    @constructor.getVersion()
+    @appVersion ?= @getLoadSettings().appVersion
 
   # Public: Determine whether the current version is an official release.
   isReleasedVersion: ->
-    @constructor.isReleasedVersion()
+    not /\w{7}/.test(@getVersion()) # Check if the release is a 7-character SHA prefix
 
   # Public: Get the directory path to Atom's configuration area.
   #

src/browser/atom-window.coffee

@@ -105,7 +105,7 @@ class AtomWindow
         type: 'warning'
         buttons: ['Close Window', 'Reload', 'Keep It Open']
         message: 'The editor has crashed'
-        detail: 'Please report this issue to atom@github.com'
+        detail: 'Please report this issue to https://github.com/atom/atom'
       switch chosen
         when 0 then @browserWindow.destroy()
         when 1 then @browserWindow.restart()

src/browser/main.coffee

@@ -27,10 +27,6 @@ start = ->
     event.preventDefault()
     args.urlsToOpen.push(urlToOpen)
 
-  app.on 'open-url', (event, urlToOpen) ->
-    event.preventDefault()
-    args.urlsToOpen.push(urlToOpen)
-
   app.on 'open-file', addPathToOpen
   app.on 'open-url', addUrlToOpen
 

src/buffered-process.coffee

@@ -45,7 +45,16 @@ class BufferedProcess
     # Related to joyent/node#2318
     if process.platform is "win32"
       # Quote all arguments and escapes inner quotes
-      cmdArgs = args.map (arg) -> "\"#{arg.replace(/"/g, '\\"')}\""
+      if args?
+        cmdArgs = args.map (arg) ->
+          if command in ['explorer.exe', 'explorer'] and /^\/[a-zA-Z]+,.*$/.test(arg)
+            # Don't wrap /root,C:\folder style arguments to explorer calls in
+            # quotes since they will not be interpreted correctly if they are
+            arg
+          else
+            "\"#{arg.replace(/"/g, '\\"')}\""
+      else
+        cmdArgs = []
       cmdArgs.unshift("\"#{command}\"")
       cmdArgs = ['/s', '/c', "\"#{cmdArgs.join(' ')}\""]
       cmdOptions = _.clone(options)

src/coffee-cache.coffee

@@ -18,11 +18,16 @@ getCachedJavaScript = (cachePath) ->
     try
       fs.readFileSync(cachePath, 'utf8')
 
+convertFilePath = (filePath) ->
+  if process.platform is 'win32'
+    filePath = "/#{path.resolve(filePath).replace(/\\/g, '/')}"
+  encodeURI(filePath)
+
 compileCoffeeScript = (coffee, filePath, cachePath) ->
   {js, v3SourceMap} = CoffeeScript.compile(coffee, filename: filePath, sourceMap: true)
   # Include source map in the web page environment.
   if btoa? and JSON? and unescape? and encodeURIComponent?
-    js = "#{js}\n//# sourceMappingURL=data:application/json;base64,#{btoa unescape encodeURIComponent v3SourceMap}\n//# sourceURL=#{filePath}"
+    js = "#{js}\n//# sourceMappingURL=data:application/json;base64,#{btoa unescape encodeURIComponent v3SourceMap}\n//# sourceURL=#{convertFilePath(filePath)}"
   try
     fs.writeFileSync(cachePath, js)
   js

src/context-menu-manager.coffee

@@ -44,7 +44,7 @@ class ContextMenuManager
           @addBySelector(selector, menuItem, {devMode})
 
   buildMenuItem: (label, command) ->
-    if label is command is '-'
+    if command is '-'
       {type: 'separator'}
     else
       {label, command}
@@ -60,7 +60,7 @@ class ContextMenuManager
   #              editor is in dev mode.
   addBySelector: (selector, definition, {devMode}={}) ->
     definitions = if devMode then @devModeDefinitions else @definitions
-    unless _.findWhere(definitions[selector], definition)
+    if not _.findWhere(definitions[selector], definition) or _.isEqual(definition, {type: 'separator'})
       (definitions[selector] ?= []).push(definition)
 
   # Returns definitions which match the element and devMode.

src/cursor-component.coffee

@@ -8,22 +8,11 @@ CursorComponent = React.createClass
 
   render: ->
     {pixelRect, defaultCharWidth} = @props
-    {height, width} = pixelRect
+    {top, left, height, width} = pixelRect
     width = defaultCharWidth if width is 0
-    WebkitTransform = @getTransform()
+    WebkitTransform = "translate(#{left}px, #{top}px)"
 
     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')
+    not isEqualForProperties(newProps, @props, 'pixelRect', 'defaultCharWidth')

src/cursor.coffee

@@ -95,8 +95,8 @@ class Cursor extends Model
   getBufferPosition: ->
     @marker.getHeadBufferPosition()
 
-  autoscroll: ->
-    @editor.scrollToScreenRange(@getScreenRange())
+  autoscroll: (options) ->
+    @editor.scrollToScreenRange(@getScreenRange(), options)
 
   # Public: If the marker range is empty, the cursor is marked as being visible.
   updateVisibility: ->

src/cursors-component.coffee

@@ -12,16 +12,16 @@ CursorsComponent = React.createClass
   cursorBlinkIntervalHandle: null
 
   render: ->
-    {cursorPixelRects, scrollTop, scrollLeft, defaultCharWidth, useHardwareAcceleration} = @props
+    {performedInitialMeasurement, cursorPixelRects, defaultCharWidth} = @props
     {blinkOff} = @state
 
     className = 'cursors'
     className += ' blink-off' if blinkOff
 
     div {className},
-      if @isMounted()
+      if performedInitialMeasurement
         for key, pixelRect of cursorPixelRects
-          CursorComponent({key, pixelRect, scrollTop, scrollLeft, defaultCharWidth, useHardwareAcceleration})
+          CursorComponent({key, pixelRect, defaultCharWidth})
 
   getInitialState: ->
     blinkOff: false

src/decoration.coffee

@@ -4,6 +4,39 @@ _ = require 'underscore-plus'
 idCounter = 0
 nextId = -> idCounter++
 
+# Public: Represents a decoration that follows a {Marker}. A decoration is
+# basically a visual representation of a marker. It allows you to add CSS
+# classes to line numbers in the gutter, lines, and add selection-line regions
+# around marked ranges of text.
+#
+# {Decoration} objects are not meant to be created directly, but created with
+# {Editor::decorateMarker}. eg.
+#
+# ```coffee
+# range = editor.getSelectedBufferRange() # any range you like
+# marker = editor.markBufferRange(range)
+# decoration = editor.decorateMarker(marker, {type: 'line', class: 'my-line-class'})
+# ```
+#
+# Best practice for destorying the decoration is by destroying the {Marker}.
+#
+# ```
+# marker.destroy()
+# ```
+#
+# You should only use {Decoration::destroy} when you still need or do not own
+# the marker.
+#
+# ### IDs
+# Each {Decoration} has a unique ID available via `decoration.id`.
+#
+# ### Events
+# A couple of events are emitted:
+#
+# * `destroyed`: When the {Decoration} is destroyed
+# * `updated`: When the {Decoration} is updated via {Decoration::update}.
+#     Event object has properties `oldParams` and `newParams`
+#
 module.exports =
 class Decoration
   Emitter.includeInto(this)
@@ -20,12 +53,21 @@ class Decoration
     @flashQueue = null
     @isDestroyed = false
 
+  # Public: Destroy this marker.
+  #
+  # If you own the marker, you should use {Marker::destroy} which will destroy
+  # this decoration.
   destroy: ->
     return if @isDestroyed
     @isDestroyed = true
     @displayBuffer.removeDecoration(this)
-    @emit 'destoryed'
+    @emit 'destroyed'
 
+  # Public: Update the marker with new params. Allows you to change the decoration's class.
+  #
+  # ```
+  # decoration.update({type: 'gutter', class: 'my-new-class'})
+  # ```
   update: (newParams) ->
     return if @isDestroyed
     oldParams = @params
@@ -34,9 +76,17 @@ class Decoration
     @displayBuffer.decorationUpdated(this)
     @emit 'updated', {oldParams, newParams}
 
-  getParams: ->
-    @params
+  # Public: Returns the marker associated with this {Decoration}
+  getMarker: -> @marker
 
+  # Public: Returns the {Decoration}'s params.
+  getParams: -> @params
+
+  # Public: Check if this decoration is of type `type`
+  #
+  # type - A {String} type like `'gutter'`
+  #
+  # Returns a {Boolean}
   isType: (type) ->
     Decoration.isType(@params, type)
 

src/display-buffer-marker.coffee

@@ -220,8 +220,8 @@ class DisplayBufferMarker
       @oldTailScreenPosition, newTailScreenPosition,
       @oldHeadBufferPosition, newHeadBufferPosition,
       @oldTailBufferPosition, newTailBufferPosition,
-      textChanged,
-      isValid
+      @wasValid, isValid,
+      textChanged
     }
 
     @oldHeadBufferPosition = newHeadBufferPosition

src/display-buffer.coffee

@@ -356,8 +356,10 @@ class DisplayBuffer extends Model
       if editorWidthInChars isnt previousWidthInChars and @softWrap
         @updateWrappedScreenLines()
 
+  # Returns the editor width in characters for soft wrap.
   getEditorWidthInChars: ->
-    width = @getWidth()
+    width = @width ? @getScrollWidth()
+    width -= @getVerticalScrollbarWidth()
     if width? and @defaultCharWidth > 0
       Math.floor(width / @defaultCharWidth)
     else
@@ -970,7 +972,7 @@ class DisplayBuffer extends Model
     for marker in @getMarkers()
       marker.notifyObservers(textChanged: false)
 
-  destroy: ->
+  destroyed: ->
     marker.unsubscribe() for marker in @getMarkers()
     @tokenizedBuffer.destroy()
     @unsubscribe()

src/display-state-manager.coffee

@@ -0,0 +1,246 @@
+{Emitter, Subscriber} = require 'emissary'
+Immutable = require 'immutable'
+if Immutable.Map.update?
+  throw new Error("Remove the Immutable.Map::update shim now that you've upgraded immutable")
+else
+  Immutable.Map::update = (key, fn) -> @set(key, fn(@get(key)))
+
+module.exports =
+class DisplayStateManager
+  Emitter.includeInto(this)
+  Subscriber.includeInto(this)
+
+  constructor: (@editor) ->
+    @buildInitialState()
+    @observeEditor()
+
+  getState: -> @state
+
+  setState: (@state) ->
+    @emit 'did-change-state', @state
+    @state
+
+  getTileSize: -> 5
+
+  getLineWidth: ->
+    Math.max(@editor.getScrollWidth(), @editor.getWidth())
+
+  observeEditor: ->
+    @subscribe @editor.$width.changes, @onWidthChanged
+    @subscribe @editor.$height.changes, @onHeightChanged
+    @subscribe @editor.$lineHeightInPixels.changes, @onLineHeightInPixelsChanged
+    @subscribe @editor.$scrollLeft.changes, @onScrollLeftChanged
+    @subscribe @editor.$scrollTop.changes, @onScrollTopChanged
+    @subscribe @editor, 'screen-lines-changed', @onScreenLinesChanged
+    @subscribe @editor, 'decoration-added', @onDecorationAdded
+    @subscribe @editor, 'decoration-removed', @onDecorationRemoved
+    @subscribe @editor, 'decoration-changed', @onDecorationChanged
+
+  tileStartRowForScreenRow: (screenRow) ->
+    screenRow - (screenRow % @getTileSize())
+
+  getVisibleRowRange: ->
+    heightInLines = Math.floor(@editor.getHeight() / @editor.getLineHeightInPixels())
+    startRow = Math.ceil(@editor.getScrollTop() / @editor.getLineHeightInPixels())
+    endRow = Math.min(@editor.getLineCount(), startRow + heightInLines)
+    [startRow, endRow]
+
+  getTileRowRange: ->
+    [startRow, endRow] = @getVisibleRowRange()
+    [@tileStartRowForScreenRow(startRow), @tileStartRowForScreenRow(endRow)]
+
+  buildInitialState: ->
+    [startRow, endRow] = @getTileRowRange()
+    @state = Immutable.Map
+      tiles: Immutable.Map().withMutations (tiles) =>
+        for tileStartRow in [startRow..endRow] by @getTileSize()
+          tiles.set(tileStartRow, @buildTile(tileStartRow))
+
+  updateTiles: (fn) ->
+    tileSize = @getTileSize()
+    [startRow, endRow] = @getTileRowRange()
+
+    @setState @state.update 'tiles', (tiles) ->
+      tiles.withMutations (tiles) ->
+        # delete any tiles that are outside of the row range
+        tiles.forEach (tile, tileStartRow) ->
+          unless startRow <= tileStartRow <= endRow
+            tiles.delete(tileStartRow)
+
+        # call the callback with the start row and existing state of visible tiles
+        for tileStartRow in [startRow..endRow] by tileSize
+          if newTile = fn(tileStartRow, tiles.get(tileStartRow))
+            tiles.set(tileStartRow, newTile)
+
+  updateTilesIntersectingRowRange: (rangeStartRow, rangeEndRow, fn) ->
+    tileSize = @getTileSize()
+
+    @updateTiles (tileStartRow, tile) ->
+      tileEndRow = tileStartRow + tileSize
+      if rangeEndRow < tileStartRow or tileEndRow <= rangeStartRow
+        tile
+      else
+        fn(tileStartRow, tile)
+
+  buildTile: (tileStartRow) ->
+    lineHeightInPixels = @editor.getLineHeightInPixels()
+    tileSize = @getTileSize()
+    tileEndRow = tileStartRow + tileSize
+
+    tile = Immutable.Map
+      startRow: tileStartRow
+      left: 0 - @editor.getScrollLeft()
+      top: tileStartRow * lineHeightInPixels - @editor.getScrollTop()
+      width: @getLineWidth()
+      height: lineHeightInPixels * tileSize
+      lineHeightInPixels: @editor.getLineHeightInPixels()
+      lines: Immutable.Vector(@editor.linesForScreenRows(tileStartRow, tileEndRow - 1)...)
+      lineDecorations: Immutable.Map()
+
+    @tileWithInitialLineDecorations(tile)
+
+  tileWithInitialLineDecorations: (tile) ->
+    tileStart = tile.get('startRow')
+    tileEnd = tileStart + @getTileSize()
+
+    for markerId, decorations of @editor.decorationsForScreenRowRange(tileStart, tileEnd)
+      marker = @editor.getMarker(markerId)
+      headPosition = marker.getHeadScreenPosition()
+      tailPosition = marker.getTailScreenPosition()
+      valid = marker.isValid()
+      for decoration in decorations
+        continue unless decoration.isType('line')
+
+        id = decoration.id
+        params = decoration.getParams()
+        if rowRange = @rowRangeForLineDecoration(params, headPosition, tailPosition, valid)
+          [start, end] = rowRange
+          unless end < tileStart or tileEnd <= start
+            tile = @tileWithLineDecorations(tile, start, end, id, params)
+
+    tile
+
+  onWidthChanged: (width) =>
+    @updateTiles (tileStartRow, tile) => tile.set('width', width)
+
+  onHeightChanged: =>
+    @updateTiles (tileStartRow, tile) => tile ? @buildTile(tileStartRow)
+
+  onLineHeightInPixelsChanged: (lineHeightInPixels) =>
+    scrollTop = @editor.getScrollTop()
+
+    @updateTiles (tileStartRow, tile) =>
+      if tile?
+        tile.withMutations (tile) ->
+          tile.set('top', tileStartRow * lineHeightInPixels - scrollTop)
+          tile.set('lineHeightInPixels', lineHeightInPixels)
+      else
+        @buildTile(tileStartRow)
+
+  onScrollTopChanged: (scrollTop) =>
+    lineHeightInPixels = @editor.getLineHeightInPixels()
+
+    @updateTiles (tileStartRow, tile) =>
+      if tile?
+        tile.set('top', tileStartRow * lineHeightInPixels - scrollTop)
+      else
+        @buildTile(tileStartRow)
+
+  onScrollLeftChanged: (scrollLeft) =>
+    @updateTiles (tileStartRow, tile) ->
+      tile.set('left', 0 - scrollLeft)
+
+  onScreenLinesChanged: (change) =>
+    @updateTiles (tileStartRow, tile) =>
+      tileEndRow = tileStartRow + @getTileSize()
+      if change.start < tileEndRow
+        tile.set 'lines',
+          Immutable.Vector(@editor.linesForScreenRows(tileStartRow, tileEndRow - 1)...)
+
+  onDecorationAdded: (marker, decoration) =>
+    return unless decoration.isType('line')
+
+    id = decoration.id
+    params = decoration.getParams()
+    headPosition = marker.getHeadScreenPosition()
+    tailPosition = marker.getTailScreenPosition()
+    valid = marker.isValid()
+
+    if rowRange = @rowRangeForLineDecoration(params, headPosition, tailPosition, valid)
+      [start, end] = rowRange
+      @updateTilesIntersectingRowRange start, end, (tileStart, tile) =>
+        @tileWithLineDecorations(tile, start, end, id, params)
+
+  onDecorationRemoved: (marker, decoration) =>
+    return unless decoration.isType('line')
+
+    id = decoration.id
+    params = decoration.getParams()
+    headPosition = marker.getHeadScreenPosition()
+    tailPosition = marker.getTailScreenPosition()
+    valid = true # FIXME: Why is a marker invalidated when destroyed? That seems wrong.
+
+    if rowRange = @rowRangeForLineDecoration(decoration, headPosition, tailPosition, valid)
+      [start, end] = rowRange
+      @updateTilesIntersectingRowRange start, end, (tileStart, tile) =>
+        @tileWithoutLineDecorations(tile, start, end, id)
+
+  onDecorationChanged: (marker, decoration, change) =>
+    return unless decoration.isType('line')
+
+    params = decoration.getParams()
+
+    {oldHeadScreenPosition, oldTailScreenPosition, wasValid} = change
+    if rowRangeToRemove = @rowRangeForLineDecoration(params, oldHeadScreenPosition, oldTailScreenPosition, wasValid)
+      [start, end] = rowRangeToRemove
+      @updateTilesIntersectingRowRange start, end, (tileStart, tile) =>
+        @tileWithoutLineDecorations(tile, start, end, decoration.id)
+
+    {newHeadScreenPosition, newTailScreenPosition, isValid} = change
+    if rowRangeToAdd = @rowRangeForLineDecoration(params, newHeadScreenPosition, newTailScreenPosition, isValid)
+      [start, end] = rowRangeToAdd
+      @updateTilesIntersectingRowRange start, end, (tileStart, tile) =>
+        @tileWithLineDecorations(tile, start, end, decoration.id, params)
+
+  rowRangeForLineDecoration: (params, headPosition, tailPosition, valid) ->
+    return unless valid
+
+    if params.onlyHead
+      return [headPosition.row, headPosition.row]
+
+    if params.onlyEmpty
+      return unless headPosition.isEqual(tailPosition)
+
+    if params.onlyNonEmpty
+      return if headPosition.isEqual(tailPosition)
+
+    start = Math.min(headPosition.row, tailPosition.row)
+    end = Math.max(headPosition.row, tailPosition.row)
+    [start, end]
+
+  tileWithLineDecorations: (tile, start, end, decorationId, decorationParams) ->
+    tileStart = tile.get('startRow')
+    tileEnd = tileStart + @getTileSize()
+    start = Math.max(start, tileStart)
+    end = Math.min(end, tileEnd)
+
+    tile.update 'lineDecorations', (lineDecorations) ->
+      lineDecorations.withMutations (lineDecorations) ->
+        for row in [start..end]
+          lineDecorations.update row, (decorationsById) ->
+            decorationsById ?= Immutable.Map()
+            decorationsById.set(decorationId, decorationParams)
+
+  tileWithoutLineDecorations: (tile, start, end, decorationId) ->
+    tileStart = tile.get('startRow')
+    tileEnd = tileStart + @getTileSize()
+    start = Math.max(start, tileStart)
+    end = Math.min(end, tileEnd)
+
+    tile.update 'lineDecorations', (lineDecorations) ->
+      lineDecorations.withMutations (lineDecorations) ->
+        for row in [start..end]
+          lineDecorations.update row, (decorationsById) ->
+            decorationsById?.delete(decorationId)
+          if lineDecorations.get(row)?.length is 0
+            lineDecorations.delete(row)

src/editor-component.coffee

@@ -6,13 +6,11 @@ scrollbarStyle = require 'scrollbar-style'
 
 GutterComponent = require './gutter-component'
 InputComponent = require './input-component'
-CursorsComponent = require './cursors-component'
 LinesComponent = require './lines-component'
 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'}]}
+DisplayStateManager = require './display-state-manager'
 
 module.exports =
 EditorComponent = React.createClass
@@ -22,6 +20,10 @@ EditorComponent = React.createClass
   statics:
     performSyncUpdates: false
 
+  visible: false
+  autoHeight: false
+  backgroundColor: null
+  gutterBackgroundColor: null
   pendingScrollTop: null
   pendingScrollLeft: null
   selectOnMouseMove: false
@@ -32,30 +34,32 @@ EditorComponent = React.createClass
   selectionChanged: false
   selectionAdded: false
   scrollingVertically: false
-  gutterWidth: 0
   refreshingScrollbars: false
   measuringScrollbars: true
-  pendingVerticalScrollDelta: 0
-  pendingHorizontalScrollDelta: 0
   mouseWheelScreenRow: null
   mouseWheelScreenRowClearDelay: 150
   scrollSensitivity: 0.4
-  scrollViewMeasurementRequested: false
+  heightAndWidthMeasurementRequested: false
   measureLineHeightAndDefaultCharWidthWhenShown: false
-  remeasureCharacterWidthsIfVisibleAfterNextUpdate: false
+  remeasureCharacterWidthsWhenShown: false
   inputEnabled: true
-  scrollViewMeasurementInterval: 100
   scopedCharacterWidthsChangeCount: null
-  scrollViewMeasurementPaused: false
+  domPollingInterval: 100
+  domPollingIntervalId: null
+  domPollingPaused: false
 
   render: ->
-    {focused, fontSize, lineHeight, fontFamily, showIndentGuide, showInvisibles, showLineNumbers, visible} = @state
-    {editor, cursorBlinkPeriod, cursorBlinkResumeDelay} = @props
+    {focused, showIndentGuide, showInvisibles, showLineNumbers, visible} = @state
+    {editor, mini, cursorBlinkPeriod, cursorBlinkResumeDelay} = @props
     maxLineNumberDigits = editor.getLineCount().toString().length
-    invisibles = if showInvisibles then @state.invisibles else {}
+    invisibles = if showInvisibles and not mini then @state.invisibles else {}
     hasSelection = editor.getSelection()? and !editor.getSelection().isEmpty()
+    style = {}
+
+    if @performedInitialMeasurement
+      displayState = @displayStateManager.getState()
+      tilesState = displayState.get('tiles')
 
-    if @isMounted()
       renderedRowRange = @getRenderedRowRange()
       [renderedStartRow, renderedEndRow] = renderedRowRange
       cursorPixelRects = @getCursorPixelRects(renderedRowRange)
@@ -63,6 +67,7 @@ EditorComponent = React.createClass
       decorations = editor.decorationsForScreenRowRange(renderedStartRow, renderedEndRow)
       highlightDecorations = @getHighlightDecorations(decorations)
       lineDecorations = @getLineDecorations(decorations)
+      placeholderText = @props.placeholderText if @props.placeholderText? and editor.isEmpty()
 
       scrollHeight = editor.getScrollHeight()
       scrollWidth = editor.getScrollWidth()
@@ -81,16 +86,19 @@ EditorComponent = React.createClass
       if @mouseWheelScreenRow? and not (renderedStartRow <= @mouseWheelScreenRow < renderedEndRow)
         mouseWheelScreenRow = @mouseWheelScreenRow
 
-    className = 'editor-contents editor-colors'
+      style.height = scrollViewHeight if @autoHeight
+
+    className = 'editor-contents'
     className += ' is-focused' if focused
     className += ' has-selection' if hasSelection
 
-    div className: className, style: {fontSize, lineHeight, fontFamily}, tabIndex: -1,
-      if showLineNumbers
+    div {className, style, tabIndex: -1},
+      if @shouldRenderGutter()
         GutterComponent {
-          ref: 'gutter', onMouseDown: @onGutterMouseDown, onWidthChanged: @onGutterWidthChanged,
-          lineDecorations, defaultCharWidth, editor, renderedRowRange, maxLineNumberDigits, scrollViewHeight,
-          scrollTop, scrollHeight, lineHeightInPixels, @pendingChanges, mouseWheelScreenRow, @useHardwareAcceleration
+          ref: 'gutter', onMouseDown: @onGutterMouseDown, lineDecorations,
+          defaultCharWidth, editor, renderedRowRange, maxLineNumberDigits, scrollViewHeight,
+          scrollTop, scrollHeight, lineHeightInPixels, @pendingChanges, mouseWheelScreenRow,
+          @useHardwareAcceleration, @performedInitialMeasurement, @backgroundColor, @gutterBackgroundColor
         }
 
       div ref: 'scrollView', className: 'scroll-view', onMouseDown: @onMouseDown,
@@ -101,18 +109,28 @@ EditorComponent = React.createClass
           onFocus: @onInputFocused
           onBlur: @onInputBlurred
 
-        CursorsComponent {
-          scrollTop, scrollLeft, cursorPixelRects, cursorBlinkPeriod, cursorBlinkResumeDelay,
-          lineHeightInPixels, defaultCharWidth, @scopedCharacterWidthsChangeCount, @useHardwareAcceleration
-        }
         LinesComponent {
-          ref: 'lines',
+          ref: 'lines', tilesState,
           editor, lineHeightInPixels, defaultCharWidth, lineDecorations, highlightDecorations,
           showIndentGuide, renderedRowRange, @pendingChanges, scrollTop, scrollLeft,
           @scrollingVertically, scrollHeight, scrollWidth, mouseWheelScreenRow, invisibles,
-          visible, scrollViewHeight, @scopedCharacterWidthsChangeCount, lineWidth, @useHardwareAcceleration
+          @visible, scrollViewHeight, @scopedCharacterWidthsChangeCount, lineWidth, @useHardwareAcceleration,
+          placeholderText, @performedInitialMeasurement, @backgroundColor, cursorPixelRects,
+          cursorBlinkPeriod, cursorBlinkResumeDelay
         }
 
+        ScrollbarComponent
+          ref: 'horizontalScrollbar'
+          className: 'horizontal-scrollbar'
+          orientation: 'horizontal'
+          onScroll: @onHorizontalScroll
+          scrollLeft: scrollLeft
+          scrollWidth: scrollWidth
+          visible: horizontallyScrollable and not @refreshingScrollbars and not @measuringScrollbars
+          scrollableInOppositeDirection: verticallyScrollable
+          verticalScrollbarWidth: verticalScrollbarWidth
+          horizontalScrollbarHeight: horizontalScrollbarHeight
+
       ScrollbarComponent
         ref: 'verticalScrollbar'
         className: 'vertical-scrollbar'
@@ -125,18 +143,6 @@ EditorComponent = React.createClass
         verticalScrollbarWidth: verticalScrollbarWidth
         horizontalScrollbarHeight: horizontalScrollbarHeight
 
-      ScrollbarComponent
-        ref: 'horizontalScrollbar'
-        className: 'horizontal-scrollbar'
-        orientation: 'horizontal'
-        onScroll: @onHorizontalScroll
-        scrollLeft: scrollLeft
-        scrollWidth: scrollWidth + @gutterWidth
-        visible: horizontallyScrollable and not @refreshingScrollbars and not @measuringScrollbars
-        scrollableInOppositeDirection: verticallyScrollable
-        verticalScrollbarWidth: verticalScrollbarWidth
-        horizontalScrollbarHeight: horizontalScrollbarHeight
-
       # Also used to measure the height/width of scrollbars after the initial render
       ScrollbarCornerComponent
         ref: 'scrollbarCorner'
@@ -149,13 +155,15 @@ EditorComponent = React.createClass
     {editor} = @props
     Math.max(1, Math.ceil(editor.getHeight() / editor.getLineHeightInPixels()))
 
-  getInitialState: ->
-    visible: true
+  shouldRenderGutter: ->
+    not @props.mini and @state.showLineNumbers
+
+  getInitialState: -> {}
 
   getDefaultProps: ->
     cursorBlinkPeriod: 800
     cursorBlinkResumeDelay: 100
-    lineOverdrawMargin: 8
+    lineOverdrawMargin: 15
 
   componentWillMount: ->
     @pendingChanges = []
@@ -163,28 +171,35 @@ EditorComponent = React.createClass
     @observeConfig()
     @setScrollSensitivity(atom.config.get('editor.scrollSensitivity'))
 
+    @displayStateManager = new DisplayStateManager(@props.editor)
+    @subscribe @displayStateManager, 'did-change-state', @requestUpdate
+
   componentDidMount: ->
     {editor} = @props
 
-    @scrollViewMeasurementIntervalId = setInterval(@measureScrollView, @scrollViewMeasurementInterval)
+    @domPollingIntervalId = setInterval(@pollDOM, @domPollingInterval)
 
     @observeEditor()
     @listenForDOMEvents()
     @listenForCommands()
 
-    @subscribe atom.themes, 'stylesheet-added stylsheet-removed', @onStylesheetsChanged
+    @subscribe atom.themes, 'stylesheet-added stylesheet-removed stylesheet-updated', @onStylesheetsChanged
     @subscribe scrollbarStyle.changes, @refreshScrollbars
 
-    editor.setVisible(true)
-
-    @measureLineHeightAndDefaultCharWidth()
-    @measureScrollView()
-    @measureScrollbars()
+    if @visible = @isVisible()
+      @performInitialMeasurement()
+      @forceUpdate()
 
   componentWillUnmount: ->
+    @props.parentView.trigger 'editor:will-be-removed', [@props.parentView]
     @unsubscribe()
-    clearInterval(@scrollViewMeasurementIntervalId)
-    @scrollViewMeasurementIntervalId = null
+    clearInterval(@domPollingIntervalId)
+    @domPollingIntervalId = null
+
+  componentWillUpdate: ->
+    wasVisible = @visible
+    @visible = @isVisible()
+    @performInitialMeasurement() if @visible and not wasVisible
 
   componentDidUpdate: (prevProps, prevState) ->
     cursorsMoved = @cursorsMoved
@@ -196,15 +211,31 @@ EditorComponent = React.createClass
 
     if @props.editor.isAlive()
       @updateParentViewFocusedClassIfNeeded(prevState)
+      @updateParentViewMiniClassIfNeeded(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)
-    @remeasureCharacterWidthsIfNeeded(prevState)
+    if @performedInitialMeasurement
+      @measureScrollbars() if @measuringScrollbars
+
+  performInitialMeasurement: ->
+    console.log "INITIAL MEASUREMENT"
+    @updatesPaused = true
+    @measureHeightAndWidth()
+    @sampleFontStyling()
+    @sampleBackgroundColors()
+    @measureScrollbars()
+    @measureLineHeightAndDefaultCharWidth() if @measureLineHeightAndDefaultCharWidthWhenShown
+    # @remeasureCharacterWidths() if @remeasureCharacterWidthsWhenShown
+    @props.editor.setVisible(true)
+    @updatesPaused = false
+    @performedInitialMeasurement = true
 
   requestUpdate: ->
+    return unless @isMounted()
+    @pauseDOMPolling()
+
     if @updatesPaused
       @updateRequestedWhilePaused = true
       return
@@ -213,13 +244,13 @@ EditorComponent = React.createClass
       @forceUpdate()
     else unless @updateRequested
       @updateRequested = true
-      setImmediate =>
+      requestAnimationFrame =>
         @updateRequested = false
         @forceUpdate() if @isMounted()
 
   requestAnimationFrame: (fn) ->
     @updatesPaused = true
-    @pauseScrollViewMeasurement()
+    @pauseDOMPolling()
     requestAnimationFrame =>
       fn()
       @updatesPaused = false
@@ -227,6 +258,9 @@ EditorComponent = React.createClass
         @updateRequestedWhilePaused = false
         @forceUpdate()
 
+  getTopmostDOMNode: ->
+    @props.parentView.element
+
   getRenderedRowRange: ->
     {editor, lineOverdrawMargin} = @props
     [visibleStartRow, visibleEndRow] = editor.getVisibleRowRange()
@@ -268,11 +302,15 @@ EditorComponent = React.createClass
       {cursor} = selection
       screenRange = cursor.getScreenRange()
       if renderedStartRow <= screenRange.start.row < renderedEndRow
-        cursorPixelRects[cursor.id] = editor.pixelRectForScreenRange(screenRange)
+        pixelRect = editor.pixelRectForScreenRange(screenRange)
+        pixelRect.startRow = screenRange.start.row
+        cursorPixelRects[cursor.id] = pixelRect
     cursorPixelRects
 
   getLineDecorations: (decorationsByMarkerId) ->
-    {editor} = @props
+    {editor, mini} = @props
+    return {} if mini
+
     decorationsByScreenRow = {}
     for markerId, decorations of decorationsByMarkerId
       marker = editor.getMarker(markerId)
@@ -294,8 +332,8 @@ EditorComponent = React.createClass
               else
                 continue if decorationParams.onlyEmpty
 
-              decorationsByScreenRow[screenRow] ?= []
-              decorationsByScreenRow[screenRow].push decorationParams
+              decorationsByScreenRow[screenRow] ?= {}
+              decorationsByScreenRow[screenRow][decoration.id] = decorationParams
 
     decorationsByScreenRow
 
@@ -316,11 +354,6 @@ EditorComponent = React.createClass
               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: ->
@@ -349,7 +382,7 @@ EditorComponent = React.createClass
 
     scrollViewNode = @refs.scrollView.getDOMNode()
     scrollViewNode.addEventListener 'scroll', @onScrollViewScroll
-    window.addEventListener 'resize', @requestScrollViewMeasurement
+    window.addEventListener 'resize', @requestHeightAndWidthMeasurement
 
     @listenForIMEEvents()
 
@@ -461,7 +494,7 @@ EditorComponent = React.createClass
         'editor:unfold-all': => editor.unfoldAll()
         'editor:fold-current-row': => editor.foldCurrentRow()
         'editor:unfold-current-row': => editor.unfoldCurrentRow()
-        'editor:fold-selection': => neditor.foldSelectedLines()
+        'editor:fold-selection': => editor.foldSelectedLines()
         'editor:fold-at-indent-level-1': => editor.foldAllAtIndentLevel(0)
         'editor:fold-at-indent-level-2': => editor.foldAllAtIndentLevel(1)
         'editor:fold-at-indent-level-3': => editor.foldAllAtIndentLevel(2)
@@ -491,9 +524,6 @@ EditorComponent = React.createClass
       parentView.command command, listener
 
   observeConfig: ->
-    @subscribe atom.config.observe 'editor.fontFamily', @setFontFamily
-    @subscribe atom.config.observe 'editor.fontSize', @setFontSize
-    @subscribe atom.config.observe 'editor.lineHeight', @setLineHeight
     @subscribe atom.config.observe 'editor.showIndentGuide', @setShowIndentGuide
     @subscribe atom.config.observe 'editor.invisibles', @setInvisibles
     @subscribe atom.config.observe 'editor.showInvisibles', @setShowInvisibles
@@ -505,7 +535,14 @@ EditorComponent = React.createClass
     @refs.input.focus()
 
   onTextInput: (event) ->
+    event.stopPropagation()
+
+    # 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 ' '
+
     return unless @isInputEnabled()
+    event.reactSkipEventDispatch = true
 
     {editor} = @props
     inputNode = event.target
@@ -520,9 +557,6 @@ EditorComponent = React.createClass
     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)
@@ -556,28 +590,23 @@ EditorComponent = React.createClass
         @pendingScrollLeft = null
 
   onMouseWheel: (event) ->
-    event.preventDefault()
-    animationFramePending = @pendingHorizontalScrollDelta isnt 0 or @pendingVerticalScrollDelta isnt 0
+    {editor} = @props
 
     # Only scroll in one direction at a time
     {wheelDeltaX, wheelDeltaY} = event
     if Math.abs(wheelDeltaX) > Math.abs(wheelDeltaY)
       # Scrolling horizontally
-      @pendingHorizontalScrollDelta -= Math.round(wheelDeltaX * @scrollSensitivity)
+      previousScrollLeft = editor.getScrollLeft()
+      editor.setScrollLeft(previousScrollLeft - Math.round(wheelDeltaX * @scrollSensitivity))
+      event.preventDefault() unless previousScrollLeft is editor.getScrollLeft()
     else
       # Scrolling vertically
-      @pendingVerticalScrollDelta -= Math.round(wheelDeltaY * @scrollSensitivity)
       @mouseWheelScreenRow = @screenRowForNode(event.target)
       @clearMouseWheelScreenRowAfterDelay ?= debounce(@clearMouseWheelScreenRow, @mouseWheelScreenRowClearDelay)
       @clearMouseWheelScreenRowAfterDelay()
-
-    unless animationFramePending
-      @requestAnimationFrame =>
-        {editor} = @props
-        editor.setScrollTop(editor.getScrollTop() + @pendingVerticalScrollDelta)
-        editor.setScrollLeft(editor.getScrollLeft() + @pendingHorizontalScrollDelta)
-        @pendingVerticalScrollDelta = 0
-        @pendingHorizontalScrollDelta = 0
+      previousScrollTop = editor.getScrollTop()
+      editor.setScrollTop(previousScrollTop - Math.round(wheelDeltaY * @scrollSensitivity))
+      event.preventDefault() unless previousScrollTop is editor.getScrollTop()
 
   onScrollViewScroll: ->
     if @isMounted()
@@ -653,9 +682,12 @@ EditorComponent = React.createClass
         editor.setSelectedScreenRange([tailPosition, [dragRow + 1, 0]])
 
   onStylesheetsChanged: (stylesheet) ->
+    return unless @performedInitialMeasurement
+
     @refreshScrollbars() if @containsScrollbarSelector(stylesheet)
-    @remeasureCharacterWidthsIfVisibleAfterNextUpdate = true
-    @requestUpdate() if @state.visible
+    @sampleFontStyling()
+    @sampleBackgroundColors()
+    @remeasureCharacterWidths()
 
   onScreenLinesChanged: (change) ->
     {editor} = @props
@@ -732,78 +764,114 @@ EditorComponent = React.createClass
     window.addEventListener('mousemove', onMouseMove)
     window.addEventListener('mouseup', onMouseUp)
 
-  pauseScrollViewMeasurement: ->
-    @scrollViewMeasurementPaused = true
-    @resumeScrollViewMeasurementAfterDelay ?= debounce(@resumeScrollViewMeasurement, 100)
-    @resumeScrollViewMeasurementAfterDelay()
+  isVisible: ->
+    node = @getDOMNode()
+    node.offsetHeight > 0 or node.offsetWidth > 0
 
-  resumeScrollViewMeasurement: ->
-    @scrollViewMeasurementPaused = false
+  pauseDOMPolling: ->
+    @domPollingPaused = true
+    @resumeDOMPollingAfterDelay ?= debounce(@resumeDOMPolling, 100)
+    @resumeDOMPollingAfterDelay()
 
-  resumeScrollViewMeasurementAfterDelay: null # created lazily
+  resumeDOMPolling: ->
+    @domPollingPaused = false
 
-  requestScrollViewMeasurement: ->
-    return if @scrollViewMeasurementRequested
+  resumeDOMPollingAfterDelay: null # created lazily
 
-    @scrollViewMeasurementRequested = true
+  pollDOM: ->
+    return if @domPollingPaused or @updateRequested or not @isMounted()
+
+    wasVisible = @visible
+    if @visible = @isVisible()
+      if wasVisible
+        @measureHeightAndWidth()
+        @sampleFontStyling()
+        @sampleBackgroundColors()
+      else
+        @performInitialMeasurement()
+        @forceUpdate()
+
+  requestHeightAndWidthMeasurement: ->
+    return if @heightAndWidthMeasurementRequested
+
+    @heightAndWidthMeasurementRequested = true
     requestAnimationFrame =>
-      @scrollViewMeasurementRequested = false
-      @measureScrollView()
+      @heightAndWidthMeasurementRequested = false
+      @measureHeightAndWidth()
 
   # Measure explicitly-styled height and width and relay them to the model. If
   # these values aren't explicitly styled, we assume the editor is unconstrained
   # and use the scrollHeight / scrollWidth as its height and width in
   # calculations.
-  measureScrollView: ->
-    return if @scrollViewMeasurementPaused
+  measureHeightAndWidth: ->
     return unless @isMounted()
 
-    {editor} = @props
-    editorNode = @getDOMNode()
+    {editor, parentView} = @props
+    parentNode = parentView.element
     scrollViewNode = @refs.scrollView.getDOMNode()
-    {position} = getComputedStyle(editorNode)
-    {width, height} = editorNode.style
+    {position} = getComputedStyle(parentNode)
+    {height} = parentNode.style
 
     if position is 'absolute' or height
+      if @autoHeight
+        @autoHeight = false
+        @forceUpdate()
+
       clientHeight =  scrollViewNode.clientHeight
       editor.setHeight(clientHeight) if clientHeight > 0
+    else
+      editor.setHeight(null)
+      @autoHeight = true
 
-    if position is 'absolute' or width
-      clientWidth = scrollViewNode.clientWidth
-      paddingLeft = parseInt(getComputedStyle(scrollViewNode).paddingLeft)
-      clientWidth -= paddingLeft
-      editor.setWidth(clientWidth) if clientWidth > 0
+    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')
-      if @state.visible
-        @measureLineHeightAndDefaultCharWidth()
-      else
-        @measureLineHeightAndDefaultCharWidthWhenShown = true
-    else if @measureLineHeightAndDefaultCharWidthWhenShown and @state.visible and not prevState.visible
+  sampleFontStyling: ->
+    oldFontSize = @fontSize
+    oldFontFamily = @fontFamily
+    oldLineHeight = @lineHeight
+
+    {@fontSize, @fontFamily, @lineHeight} = getComputedStyle(@getTopmostDOMNode())
+
+    if @fontSize isnt oldFontSize or @fontFamily isnt oldFontFamily or @lineHeight isnt oldLineHeight
       @measureLineHeightAndDefaultCharWidth()
 
-  measureLineHeightAndDefaultCharWidth: ->
-    @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
+    if (@fontSize isnt oldFontSize or @fontFamily isnt oldFontFamily) and @performedInitialMeasurement
       @remeasureCharacterWidths()
 
-  remeasureCharacterWidths: ->
-    @refs.lines.remeasureCharacterWidths()
+  sampleBackgroundColors: (suppressUpdate) ->
+    {parentView} = @props
+    {showLineNumbers} = @state
+    {backgroundColor} = getComputedStyle(parentView.element)
 
-  onGutterWidthChanged: (@gutterWidth) ->
-    @requestUpdate()
+    if backgroundColor isnt @backgroundColor
+      @backgroundColor = backgroundColor
+      @requestUpdate() unless suppressUpdate
+
+    if @shouldRenderGutter()
+      gutterBackgroundColor = getComputedStyle(@refs.gutter.getDOMNode()).backgroundColor
+      if gutterBackgroundColor isnt @gutterBackgroundColor
+        @gutterBackgroundColor = gutterBackgroundColor
+        @requestUpdate() unless suppressUpdate
+
+  measureLineHeightAndDefaultCharWidth: ->
+    if @visible
+      @measureLineHeightAndDefaultCharWidthWhenShown = false
+      @refs.lines.measureLineHeightAndDefaultCharWidth()
+    else
+      @measureLineHeightAndDefaultCharWidthWhenShown = true
+
+  remeasureCharacterWidths: ->
+    if @visible
+      @remeasureCharacterWidthsWhenShown = false
+      @refs.lines.remeasureCharacterWidths()
+    else
+      @remeasureCharacterWidthsWhenShown = true
 
   measureScrollbars: ->
+    return unless @visible
     @measuringScrollbars = false
 
     {editor} = @props
@@ -860,26 +928,23 @@ EditorComponent = React.createClass
       node = node.parentNode
     null
 
-  hide: ->
-    @setState(visible: false)
-
-  show: ->
-    @setState(visible: true)
-
   getFontSize: ->
-    @state.fontSize
+    parseInt(getComputedStyle(@getTopmostDOMNode()).fontSize)
 
   setFontSize: (fontSize) ->
-    @setState({fontSize})
+    @getTopmostDOMNode().style.fontSize = fontSize + 'px'
+    @sampleFontStyling()
 
   getFontFamily: ->
-    @state.fontFamily
+    getComputedStyle(@getTopmostDOMNode()).fontFamily
 
   setFontFamily: (fontFamily) ->
-    @setState({fontFamily})
+    @getTopmostDOMNode().style.fontFamily = fontFamily
+    @sampleFontStyling()
 
   setLineHeight: (lineHeight) ->
-    @setState({lineHeight})
+    @getTopmostDOMNode().style.lineHeight = lineHeight
+    @sampleFontStyling()
 
   setShowIndentGuide: (showIndentGuide) ->
     @setState({showIndentGuide})
@@ -939,6 +1004,10 @@ EditorComponent = React.createClass
     if prevState.focused isnt @state.focused
       @props.parentView.toggleClass('is-focused', @props.focused)
 
+  updateParentViewMiniClassIfNeeded: (prevProps) ->
+    if prevProps.mini isnt @props.mini
+      @props.parentView.toggleClass('mini', @props.mini)
+
   runScrollBenchmark: ->
     unless process.env.NODE_ENV is 'production'
       ReactPerf = require 'react-atom-fork/lib/ReactDefaultPerf'

src/editor-tile-component.coffee

@@ -0,0 +1,302 @@
+{extend, toArray, isEqual} = require 'underscore-plus'
+Decoration = require './decoration'
+
+WrapperDiv = document.createElement('div')
+
+module.exports =
+class EditorTileComponent
+  constructor: (@state) ->
+    @lineNodesByLineId = {}
+    @screenRowsByLineId = {}
+    @lineIdsByScreenRow = {}
+    @renderedDecorationsByLineId = {}
+    @cursorPixelRectsById = {}
+    @cursorNodesById = {}
+
+    @domNode = document.createElement('div')
+    @domNode.style.position = 'absolute'
+    @domNode.style['-webkit-transform'] = @getTransform()
+    @domNode.style.height = @state.get('height') + 'px'
+    @domNode.style.width = @state.get('width') + 'px'
+    @buildLines()
+
+  stateChangedForKeys: ->
+    for key in arguments
+      return true if @prevState?.get(key) isnt @state.get(key)
+    false
+
+  update: (newState) ->
+    @prevState = @state
+    @state = newState
+
+    if @stateChangedForKeys('top', 'left')
+      @domNode.style['-webkit-transform'] = @getTransform()
+
+    if @stateChangedForKeys('width')
+      @domNode.style.width = @state.get('width') + 'px'
+
+    if @stateChangedForKeys('lines', 'lineDecorations')
+      @updateLines()
+
+    # @clearScreenRowCaches() if newProps.lineHeightInPixels isnt @props.lineHeightInPixels
+    # @updateLines()
+    # @updateCursors()
+
+  getTransform: ->
+    "translate3d(#{@state.get('left')}px, #{@state.get('top')}px, 0px)"
+
+  buildLines: ->
+    startRow = @state.get('startRow')
+    lines = @state.get('lines')
+
+    linesHTML = ""
+    lines.forEach (line, i) =>
+      screenRow = startRow + i
+      linesHTML += @buildLineHTML(line, screenRow)
+    @domNode.innerHTML = linesHTML
+
+    lines.forEach (line, i) =>
+      screenRow = startRow + i
+      lineNode = @domNode.children[i]
+      @lineNodesByLineId[line.id] = lineNode
+      @screenRowsByLineId[line.id] = screenRow
+      @lineIdsByScreenRow[screenRow] = line.id
+
+  updateLines: ->
+    lines = @state.get('lines')
+    @removeLineNodes(lines)
+    @appendOrUpdateVisibleLineNodes(lines)
+
+  removeLineNodes: (lines=[]) ->
+    lineIds = new Set
+    lines.forEach (line) -> lineIds.add(line.id.toString())
+
+    for lineId, lineNode of @lineNodesByLineId when not lineIds.has(lineId)
+      screenRow = @screenRowsByLineId[lineId]
+      delete @lineNodesByLineId[lineId]
+      delete @lineIdsByScreenRow[screenRow] if @lineIdsByScreenRow[screenRow] is lineId
+      delete @screenRowsByLineId[lineId]
+      delete @renderedDecorationsByLineId[lineId]
+      @domNode.removeChild(lineNode)
+
+  appendOrUpdateVisibleLineNodes: (visibleLines) ->
+    startRow = @state.get('startRow')
+
+    newLines = null
+    newLinesHTML = null
+
+    visibleLines.forEach (line, index) =>
+      screenRow = startRow + index
+
+      if @hasLineNode(line.id)
+        @updateLineNode(line, screenRow)
+      else
+        newLines ?= []
+        newLinesHTML ?= ""
+        newLines.push(line)
+        newLinesHTML += @buildLineHTML(line, screenRow)
+        @screenRowsByLineId[line.id] = screenRow
+        @lineIdsByScreenRow[screenRow] = line.id
+
+    return unless newLines?
+
+    WrapperDiv.innerHTML = newLinesHTML
+    newLineNodes = toArray(WrapperDiv.children)
+    for line, i in newLines
+      lineNode = newLineNodes[i]
+      @lineNodesByLineId[line.id] = lineNode
+      @domNode.appendChild(lineNode)
+
+  updateLineNode: (line, screenRow) ->
+    startRow = @state.get('startRow')
+    lineWidth = @state.get('width')
+    lineHeightInPixels = @state.get('lineHeightInPixels')
+
+    lineNode = @lineNodesByLineId[line.id]
+
+    unless @screenRowsByLineId[line.id] is screenRow
+      lineNode.style.top =  (screenRow - startRow) * lineHeightInPixels + 'px'
+      lineNode.dataset.screenRow = screenRow
+      @screenRowsByLineId[line.id] = screenRow
+      @lineIdsByScreenRow[screenRow] = line.id
+
+    prevLineDecorations = @prevState?.get('lineDecorations').get(screenRow)
+    lineDecorations = @state.get('lineDecorations').get(screenRow)
+    if lineDecorations isnt prevLineDecorations
+      prevLineDecorations?.forEach (decoration) ->
+        unless lineDecorations?.has(decoration.id)
+          lineNode.classList.remove(decoration.class)
+
+      lineDecorations?.forEach (decoration) ->
+        unless prevLineDecorations?.has(decoration.id)
+          lineNode.classList.add(decoration.class)
+
+  clearScreenRowCaches: ->
+    @screenRowsByLineId = {}
+    @lineIdsByScreenRow = {}
+
+  hasLineNode: (lineId) ->
+    @lineNodesByLineId.hasOwnProperty(lineId)
+
+  lineNodeForScreenRow: (screenRow) ->
+    @lineNodesByLineId[@lineIdsByScreenRow[screenRow]]
+
+  hasDecoration: (decorations, decoration) ->
+    decorations? and decorations[decoration.id] is decoration
+
+  buildLineHTML: (line, screenRow) ->
+    startRow = @state.get('startRow')
+    lineHeightInPixels = @state.get('lineHeightInPixels')
+    width = @state.get('width')
+
+    {text, fold, isSoftWrapped, indentLevel} = line
+
+    classes = @getLineClasses(screenRow)
+    top = (screenRow - startRow) * lineHeightInPixels
+    style = "position: absolute; top: #{top}px; width: 100%;"
+
+    lineHTML = """<div class="#{classes}" style="#{style}">"""
+
+    if text is ""
+      lineHTML += @buildEmptyLineInnerHTML(line)
+    else
+      lineHTML += @buildLineInnerHTML(line)
+
+    lineHTML += '<span class="fold-marker"></span>' if fold?
+    lineHTML += "</div>"
+    lineHTML
+
+  getLineClasses: (screenRow) ->
+    classes = ''
+    if decorationsById = @state.get('lineDecorations').get(screenRow)
+      decorationsById.forEach (decoration) ->
+        classes += decoration.class + ' '
+    classes + 'line'
+
+  buildEmptyLineInnerHTML: (line) ->
+    invisibles = {}
+    showIndentGuide = false
+    # {showIndentGuide, invisibles} = @props
+    {cr, eol} = invisibles
+    {indentLevel, tabLength} = line
+
+    if showIndentGuide and indentLevel > 0
+      invisiblesToRender = []
+      invisiblesToRender.push(cr) if cr? and line.lineEnding is '\r\n'
+      invisiblesToRender.push(eol) if eol?
+
+      lineHTML = ''
+      for i in [0...indentLevel]
+        lineHTML += "<span class='indent-guide'>"
+        for j in [0...tabLength]
+          if invisible = invisiblesToRender.shift()
+            lineHTML += "<span class='invisible-character'>#{invisible}</span>"
+          else
+            lineHTML += ' '
+        lineHTML += "</span>"
+
+      while invisiblesToRender.length
+        lineHTML += "<span class='invisible-character'>#{invisiblesToRender.shift()}</span>"
+
+      lineHTML
+    else
+      # @buildEndOfLineHTML(line, @props.invisibles) or '&nbsp;'
+      @buildEndOfLineHTML(line, {}) or '&nbsp;'
+
+  buildLineInnerHTML: (line) ->
+    # {invisibles, mini, showIndentGuide} = @props
+    invisibles = {}
+    mini = false
+    showIndentGuide = false
+    {tokens, text} = line
+    innerHTML = ""
+
+    scopeStack = []
+    firstTrailingWhitespacePosition = text.search(/\s*$/)
+    lineIsWhitespaceOnly = firstTrailingWhitespacePosition is 0
+    for token in tokens
+      innerHTML += @updateScopeStack(scopeStack, token.scopes)
+      hasIndentGuide = not mini and showIndentGuide and (token.hasLeadingWhitespace or (token.hasTrailingWhitespace and lineIsWhitespaceOnly))
+      innerHTML += token.getValueAsHtml({invisibles, hasIndentGuide})
+
+    innerHTML += @popScope(scopeStack) while scopeStack.length > 0
+    innerHTML += @buildEndOfLineHTML(line, invisibles)
+    innerHTML
+
+  buildEndOfLineHTML: (line, invisibles) ->
+    # return '' if @props.mini or line.isSoftWrapped()
+    return '' if line.isSoftWrapped()
+
+    html = ''
+    # Note the lack of '?' in the character checks. A user can set the chars
+    # to an empty string which we will interpret as not-set
+    if invisibles.cr and line.lineEnding is '\r\n'
+      html += "<span class='invisible-character'>#{invisibles.cr}</span>"
+    if invisibles.eol
+      html += "<span class='invisible-character'>#{invisibles.eol}</span>"
+
+    html
+
+  updateScopeStack: (scopeStack, desiredScopes) ->
+    html = ""
+
+    # Find a common prefix
+    for scope, i in desiredScopes
+      break unless scopeStack[i] is desiredScopes[i]
+
+    # Pop scopes until we're at the common prefx
+    until scopeStack.length is i
+      html += @popScope(scopeStack)
+
+    # Push onto common prefix until scopeStack equals desiredScopes
+    for j in [i...desiredScopes.length]
+      html += @pushScope(scopeStack, desiredScopes[j])
+
+    html
+
+  popScope: (scopeStack) ->
+    scopeStack.pop()
+    "</span>"
+
+  pushScope: (scopeStack, scope) ->
+    scopeStack.push(scope)
+    "<span class=\"#{scope.replace(/\.+/g, ' ')}\">"
+
+  updateCursors: ->
+    return
+    {cursorPixelRects, startRow, lineHeightInPixels} = @props
+
+    for id of @cursorPixelRectsById
+      @removeCursorNode(id) unless cursorPixelRects?.hasOwnProperty(id)
+
+    if cursorPixelRects?
+      for id, newPixelRect of cursorPixelRects
+        newPixelRect.top -= startRow * lineHeightInPixels
+
+        if oldPixelRect = @cursorPixelRectsById[id]
+          unless isEqual(oldPixelRect, newPixelRect)
+            @updateCursorNode(id, newPixelRect)
+        else
+          @buildCursorNode(id, newPixelRect)
+
+  updateCursorNode: (id, pixelRect) ->
+    {top, left, height, width} = pixelRect
+    @cursorNodesById[id].style.top = top + 'px'
+    @cursorNodesById[id].style.left = left + 'px'
+    @cursorNodesById[id].style.height = height + 'px'
+    @cursorNodesById[id].style.width = width + 'px'
+    @cursorPixelRectsById[id] = pixelRect
+
+  buildCursorNode: (id, pixelRect) ->
+    cursorNode = document.createElement('div')
+    cursorNode.className = 'cursor'
+    cursorNode.style.position = 'absolute'
+    @cursorNodesById[id] = cursorNode
+    @cursorPixelRectsById[id] = pixelRect
+    @updateCursorNode(id, pixelRect)
+    @domNode.appendChild(cursorNode)
+
+  removeCursorNode: (id) ->
+    @domNode.removeChild(@cursorNodesById[id])
+    delete @cursorPixelRectsById[id]
+    delete @cursorNodesById[id]

src/editor-view.coffee

@@ -641,9 +641,9 @@ class EditorView extends View
     @scrollBottom(@editor.getScreenLineCount() * @lineHeight)
 
   # Public: Scrolls the editor to the position of the most recently added
-  # cursor.
+  # cursor if it isn't current on screen.
   #
-  # The editor is also centered.
+  # The editor is centered around the cursor's position if possible.
   scrollToCursorPosition: ->
     @scrollToBufferPosition(@editor.getCursorBufferPosition(), center: true)
 

src/editor.coffee

@@ -131,6 +131,10 @@ TextMateScopeSelector = require('first-mate').ScopeSelector
 # - {::markScreenRange}
 # - {::getMarker}
 # - {::findMarkers}
+#
+# ### Decorations
+# - {::decorateMarker}
+# - {::decorationsForScreenRowRange}
 module.exports =
 class Editor extends Model
   Serializable.includeInto(this)
@@ -412,9 +416,10 @@ class Editor extends Model
     @displayBuffer.indentLevelForLine(line)
 
   # Constructs the string used for tabs.
-  buildIndentString: (number) ->
+  buildIndentString: (number, column=0) ->
     if @getSoftTabs()
-      _.multiplyString(" ", Math.floor(number * @getTabLength()))
+      tabStopViolation = column % @getTabLength()
+      _.multiplyString(" ", Math.floor(number * @getTabLength()) - tabStopViolation)
     else
       _.multiplyString("\t", Math.floor(number))
 
@@ -513,6 +518,8 @@ class Editor extends Model
   # {Delegates to: TextBuffer.isModified}
   isModified: -> @buffer.isModified()
 
+  isEmpty: -> @buffer.isEmpty()
+
   # Public: Determine whether the user should be prompted to save before closing
   # this editor.
   shouldPromptToSave: -> @isModified() and not @buffer.hasMultipleEditors()
@@ -1060,9 +1067,11 @@ class Editor extends Model
   # All the changes made inside the given {Function} can be reverted with a
   # single call to {::undo}.
   #
-  # fn - A {Function} that will be called with each {Selection}.
+  # fn - A {Function} that will be called once for each {Selection}. The first
+  #      argument will be a {Selection} and the second argument will be the
+  #      {Number} index of that selection.
   mutateSelectedText: (fn) ->
-    @transact => fn(selection,index) for selection,index in @getSelections()
+    @transact => fn(selection, index) for selection, index in @getSelections()
 
   replaceSelectedText: (options={}, fn) ->
     {selectWordIfEmpty} = options
@@ -1080,8 +1089,10 @@ class Editor extends Model
   # 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 {Object} of decorations in the form
+  #  `{1: [{id: 10, type: 'gutter', class: 'someclass'}], 2: ...}`
+  #   where the keys are {Marker} IDs, and the values are an array of decoration
+  #   params objects attached to the marker.
   # Returns an empty object when no decorations are found
   decorationsForScreenRowRange: (startScreenRow, endScreenRow) ->
     @displayBuffer.decorationsForScreenRowRange(startScreenRow, endScreenRow)
@@ -1090,28 +1101,42 @@ class Editor extends Model
   # is invalidated, or is destroyed, the decoration will be updated to reflect
   # the marker's state.
   #
+  # There are three types of supported decorations:
+  # * `line`: Adds your CSS `class` to the line nodes within the range
+  #     marked by the marker
+  # * `gutter`: Adds your CSS `class` to the line number nodes within the
+  #     range marked by the marker
+  # * `highlight`: Adds a new highlight div to the editor surrounding the
+  #     range marked by the marker. When the user selects text, the selection is
+  #     visualized with a highlight decoration internally. The structure of this
+  #     highlight will be:
+  #     ```html
+  #     <div class="highlight <your-class>">
+  #       <!-- Will be one region for each row in the range. Spans 2 lines? There will be 2 regions. -->
+  #       <div class="region"></div>
+  #     </div>
+  #     ```
+  #
   # 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)
+  # decorationParams - An {Object} representing the decoration eg. `{type: 'gutter', class: 'linter-error'}`
+  #   :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.
+  #   :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.
+  #
+  # Returns a {Decoration} object
+  decorateMarker: (marker, decorationParams) ->
+    @displayBuffer.decorateMarker(marker, decorationParams)
 
   decorationForId: (id) ->
     @displayBuffer.decorationForId(id)
@@ -1264,7 +1289,7 @@ class Editor extends Model
   addSelectionForBufferRange: (bufferRange, options={}) ->
     @markBufferRange(bufferRange, _.defaults(@getSelectionMarkerAttributes(), options))
     selection = @getLastSelection()
-    selection.autoscroll()
+    selection.autoscroll() if @manageScrollPosition
     selection
 
   # Public: Set the selected range in buffer coordinates. If there are multiple
@@ -1472,7 +1497,7 @@ class Editor extends Model
   # text - A {String}
   #
   # Returns the {Range} of the newly-inserted text.
-  setTextInBufferRange: (range, text) -> @getBuffer().setTextInRange(range, text)
+  setTextInBufferRange: (range, text, normalizeLineEndings) -> @getBuffer().setTextInRange(range, text, normalizeLineEndings)
 
   # Public: Get the {Range} of the paragraph surrounding the most recently added
   # cursor.
@@ -1563,8 +1588,14 @@ class Editor extends Model
   moveCursorToBeginningOfPreviousParagraph: ->
     @moveCursors (cursor) -> cursor.moveToBeginningOfPreviousParagraph()
 
-  scrollToCursorPosition: ->
-    @getCursor().autoscroll()
+  # Public: Scroll the editor to reveal the most recently added cursor if it is
+  # off-screen.
+  #
+  # options - An optional hash of options.
+  #   :center - Center the editor around the cursor if possible. Defauls to
+  #             true.
+  scrollToCursorPosition: (options) ->
+    @getCursor().autoscroll(center: options?.center ? true)
 
   pageUp: ->
     newScrollTop = @getScrollTop() - @getHeight()
@@ -1737,7 +1768,7 @@ class Editor extends Model
       {row} = start
       while ++row < end.row
         @addSelectionForBufferRange([[row, 0], [row, Infinity]])
-      @addSelectionForBufferRange([[end.row, 0], [end.row, end.column]])
+      @addSelectionForBufferRange([[end.row, 0], [end.row, end.column]]) unless end.column is 0
 
   # Public: For each selection, transpose the selected text.
   #

src/gutter-component.coffee

@@ -16,14 +16,16 @@ GutterComponent = React.createClass
   measuredWidth: null
 
   render: ->
-    {scrollHeight, scrollViewHeight, onMouseDown} = @props
+    {scrollHeight, scrollViewHeight, onMouseDown, backgroundColor, gutterBackgroundColor} = @props
+
+    if gutterBackgroundColor isnt 'rbga(0, 0, 0, 0)'
+      backgroundColor = gutterBackgroundColor
 
     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:
+      div className: 'line-numbers', ref: 'lineNumbers', style:
         height: Math.max(scrollHeight, scrollViewHeight)
         WebkitTransform: @getTransform()
+        backgroundColor: backgroundColor
 
   getTransform: ->
     {scrollTop, useHardwareAcceleration} = @props
@@ -41,6 +43,7 @@ GutterComponent = React.createClass
 
   componentDidMount: ->
     @appendDummyLineNumber()
+    @updateLineNumbers() if @props.performedInitialMeasurement
 
   # Only update the gutter if the visible row range has changed or if a
   # non-zero-delta change to the screen lines has occurred within the current
@@ -48,23 +51,24 @@ GutterComponent = React.createClass
   shouldComponentUpdate: (newProps) ->
     return true unless isEqualForProperties(newProps, @props,
       'renderedRowRange', 'scrollTop', 'lineHeightInPixels', 'mouseWheelScreenRow', 'lineDecorations',
-      'scrollViewHeight', 'useHardwareAcceleration'
+      'scrollViewHeight', 'useHardwareAcceleration', 'backgroundColor', 'gutterBackgroundColor'
     )
 
     {renderedRowRange, pendingChanges, lineDecorations} = newProps
+    return false unless renderedRowRange?
+
     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) ->
+    return unless @props.performedInitialMeasurement
+
     unless isEqualForProperties(oldProps, @props, 'maxLineNumberDigits')
       @updateDummyLineNumber()
       @removeLineNumberNodes()
 
-    unless isEqualForProperties(oldProps, @props, 'maxLineNumberDigits', 'defaultCharWidth')
-      @measureWidth()
-
     @clearScreenRowCaches() unless oldProps.lineHeightInPixels is @props.lineHeightInPixels
     @updateLineNumbers()
 
@@ -154,7 +158,7 @@ GutterComponent = React.createClass
 
     classes = ''
     if lineDecorations? and decorations = lineDecorations[screenRow]
-      for decoration in decorations
+      for id, decoration of decorations
         if Decoration.isType(decoration, 'gutter')
           classes += decoration.class + ' '
 
@@ -186,12 +190,13 @@ GutterComponent = React.createClass
     previousDecorations = @renderedDecorationsByLineNumberId[lineNumberId]
 
     if previousDecorations?
-      for decoration in previousDecorations
-        node.classList.remove(decoration.class) if Decoration.isType(decoration, 'gutter') and not _.deepContains(decorations, decoration)
+      for id, decoration of previousDecorations
+        if Decoration.isType(decoration, 'gutter') and not @hasDecoration(decorations, decoration)
+          node.classList.remove(decoration.class)
 
     if decorations?
-      for decoration in decorations
-        if Decoration.isType(decoration, 'gutter') and not _.deepContains(previousDecorations, decoration)
+      for id, decoration of decorations
+        if Decoration.isType(decoration, 'gutter') and not @hasDecoration(previousDecorations, decoration)
           node.classList.add(decoration.class)
 
     unless @screenRowsByLineNumberId[lineNumberId] is screenRow
@@ -201,6 +206,9 @@ GutterComponent = React.createClass
       @screenRowsByLineNumberId[lineNumberId] = screenRow
       @lineNumberIdsByScreenRow[screenRow] = lineNumberId
 
+  hasDecoration: (decorations, decoration) ->
+    decorations? and decorations[decoration.id] is decoration
+
   hasLineNumberNode: (lineNumberId) ->
     @lineNumberNodesById.hasOwnProperty(lineNumberId)
 
@@ -218,9 +226,3 @@ GutterComponent = React.createClass
         editor.unfoldBufferRow(bufferRow)
       else
         editor.foldBufferRow(bufferRow)
-
-  measureWidth: ->
-    width = @getDOMNode().offsetWidth
-    unless width is @measuredWidth
-      @measuredWidth = width
-      @props.onWidthChanged?(width)

src/highlights-component.coffee

@@ -9,7 +9,7 @@ HighlightsComponent = React.createClass
 
   render: ->
     div className: 'highlights',
-      @renderHighlights() if @isMounted()
+      @renderHighlights() if @props.performedInitialMeasurement
 
   renderHighlights: ->
     {editor, highlightDecorations, lineHeightInPixels} = @props

src/language-mode.coffee

@@ -43,12 +43,12 @@ class LanguageMode
     commentStartRegex = new OnigRegExp("^(\\s*)(#{commentStartRegexString})")
 
     if commentEndString
-      shouldUncomment = commentStartRegex.test(buffer.lineForRow(start))
+      shouldUncomment = commentStartRegex.testSync(buffer.lineForRow(start))
       if shouldUncomment
         commentEndRegexString = _.escapeRegExp(commentEndString).replace(/^(\s+)/, '(?:$1)?')
         commentEndRegex = new OnigRegExp("(#{commentEndRegexString})(\\s*)$")
-        startMatch =  commentStartRegex.search(buffer.lineForRow(start))
-        endMatch = commentEndRegex.search(buffer.lineForRow(end))
+        startMatch =  commentStartRegex.searchSync(buffer.lineForRow(start))
+        endMatch = commentEndRegex.searchSync(buffer.lineForRow(end))
         if startMatch and endMatch
           buffer.transact ->
             columnStart = startMatch[1].length
@@ -72,13 +72,13 @@ class LanguageMode
         blank = line?.match(/^\s*$/)
 
         allBlank = false unless blank
-        allBlankOrCommented = false unless blank or commentStartRegex.test(line)
+        allBlankOrCommented = false unless blank or commentStartRegex.testSync(line)
 
       shouldUncomment = allBlankOrCommented and not allBlank
 
       if shouldUncomment
         for row in [start..end]
-          if match = commentStartRegex.search(buffer.lineForRow(row))
+          if match = commentStartRegex.searchSync(buffer.lineForRow(row))
             columnStart = match[1].length
             columnEnd = columnStart + match[2].length
             buffer.setTextInRange([[row, columnStart], [row, columnEnd]], "")
@@ -168,7 +168,7 @@ class LanguageMode
       continue if @editor.isBufferRowBlank(row)
       indentation = @editor.indentationForBufferRow(row)
       if indentation <= startIndentLevel
-        includeRowInFold = indentation == startIndentLevel and @foldEndRegexForScopes(scopes)?.search(@editor.lineForBufferRow(row))
+        includeRowInFold = indentation == startIndentLevel and @foldEndRegexForScopes(scopes)?.searchSync(@editor.lineForBufferRow(row))
         foldEndRow = row if includeRowInFold
         break
 
@@ -250,10 +250,10 @@ class LanguageMode
 
     precedingLine = @buffer.lineForRow(precedingRow)
     desiredIndentLevel = @editor.indentationForBufferRow(precedingRow)
-    desiredIndentLevel += 1 if increaseIndentRegex.test(precedingLine) and not @editor.isBufferRowCommented(precedingRow)
+    desiredIndentLevel += 1 if increaseIndentRegex.testSync(precedingLine) and not @editor.isBufferRowCommented(precedingRow)
 
     return desiredIndentLevel unless decreaseIndentRegex = @decreaseIndentRegexForScopes(scopes)
-    desiredIndentLevel -= 1 if decreaseIndentRegex.test(currentLine)
+    desiredIndentLevel -= 1 if decreaseIndentRegex.testSync(currentLine)
 
     Math.max(desiredIndentLevel, 0)
 
@@ -293,7 +293,7 @@ class LanguageMode
     return unless increaseIndentRegex and decreaseIndentRegex
 
     line = @buffer.lineForRow(bufferRow)
-    return unless decreaseIndentRegex.test(line)
+    return unless decreaseIndentRegex.testSync(line)
 
     currentIndentLevel = @editor.indentationForBufferRow(bufferRow)
     return if currentIndentLevel is 0
@@ -302,7 +302,7 @@ class LanguageMode
     precedingLine = @buffer.lineForRow(precedingRow)
 
     desiredIndentLevel = @editor.indentationForBufferRow(precedingRow)
-    desiredIndentLevel -= 1 unless increaseIndentRegex.test(precedingLine)
+    desiredIndentLevel -= 1 unless increaseIndentRegex.testSync(precedingLine)
     if desiredIndentLevel >= 0 and desiredIndentLevel < currentIndentLevel
       @editor.setIndentationForBufferRow(bufferRow, desiredIndentLevel)
 

src/less-compile-cache.coffee

@@ -30,6 +30,10 @@ class LessCompileCache
   setImportPaths: (importPaths=[]) ->
     @cache.setImportPaths(importPaths.concat(@lessSearchPaths))
 
-  read: (stylesheetPath) -> @cache.readFileSync(stylesheetPath)
+  read: (stylesheetPath) ->
+    @cache.readFileSync(stylesheetPath)
+
+  cssForFile: (stylesheetPath, lessContent) ->
+    @cache.cssForFile(stylesheetPath, lessContent)
 
   destroy: -> @unsubscribe()

src/lines-component.coffee

@@ -5,7 +5,9 @@ React = require 'react-atom-fork'
 {$$} = require 'space-pen'
 
 Decoration = require './decoration'
+CursorsComponent = require './cursors-component'
 HighlightsComponent = require './highlights-component'
+EditorTileComponent = require './editor-tile-component'
 
 DummyLineNode = $$(-> @div className: 'line', style: 'position: absolute; visibility: hidden;', => @span 'x')[0]
 AcceptFilter = {acceptNode: -> NodeFilter.FILTER_ACCEPT}
@@ -15,43 +17,28 @@ module.exports =
 LinesComponent = React.createClass
   displayName: 'LinesComponent'
 
+  tileSize: 5
+
   render: ->
-    if @isMounted()
-      {editor, highlightDecorations, scrollHeight, scrollWidth} = @props
-      {lineHeightInPixels, defaultCharWidth, scrollViewHeight, scopedCharacterWidthsChangeCount} = @props
-      style =
-        height: Math.max(scrollHeight, scrollViewHeight)
-        width: scrollWidth
-        WebkitTransform: @getTransform()
-
-    # The lines div must have the 'editor-colors' class so it has an opaque
-    # background to avoid sub-pixel anti-aliasing problems on the GPU
-    div {className: 'lines editor-colors', style},
-      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)"
+    div className: 'lines'
 
   componentWillMount: ->
     @measuredLines = new WeakSet
-    @lineNodesByLineId = {}
-    @screenRowsByLineId = {}
-    @lineIdsByScreenRow = {}
-    @renderedDecorationsByLineId = {}
+    @tileComponentsByStartRow = {}
 
   shouldComponentUpdate: (newProps) ->
+    return newProps.tilesState isnt @props.tilesState
+
     return true unless isEqualForProperties(newProps, @props,
       'renderedRowRange', 'lineDecorations', 'highlightDecorations', 'lineHeightInPixels', 'defaultCharWidth',
       'scrollTop', 'scrollLeft', 'showIndentGuide', 'scrollingVertically', 'invisibles', 'visible',
-      'scrollViewHeight', 'mouseWheelScreenRow', 'scopedCharacterWidthsChangeCount', 'lineWidth', 'useHardwareAcceleration'
+      'scrollViewHeight', 'mouseWheelScreenRow', 'scopedCharacterWidthsChangeCount', 'lineWidth', 'useHardwareAcceleration',
+      'placeholderText', 'performedInitialMeasurement', 'backgroundColor', 'cursorPixelRects'
     )
 
     {renderedRowRange, pendingChanges} = newProps
+    return false unless renderedRowRange?
+
     [renderedStartRow, renderedEndRow] = renderedRowRange
     for change in pendingChanges
       if change.screenDelta is 0
@@ -62,185 +49,19 @@ LinesComponent = React.createClass
     false
 
   componentDidUpdate: (prevProps) ->
-    {visible, scrollingVertically} = @props
+    {performedInitialMeasurement, visible, scrollingVertically} = @props
+    return unless performedInitialMeasurement
 
-    @clearScreenRowCaches() unless prevProps.lineHeightInPixels is @props.lineHeightInPixels
-    @removeLineNodes() unless isEqualForProperties(prevProps, @props, 'showIndentGuide', 'invisibles')
-    @updateLines(@props.lineWidth isnt prevProps.lineWidth)
+    @clearTiles() unless isEqualForProperties(prevProps, @props, 'showIndentGuide', 'invisibles')
+    @updateTiles(prevProps)
     @measureCharactersInNewLines() if visible and not scrollingVertically
 
-  clearScreenRowCaches: ->
-    @screenRowsByLineId = {}
-    @lineIdsByScreenRow = {}
-
-  updateLines: (updateWidth) ->
-    {editor, renderedRowRange, showIndentGuide, selectionChanged, lineDecorations} = @props
-    [startRow, endRow] = renderedRowRange
-
-    visibleLines = editor.linesForScreenRows(startRow, endRow - 1)
-    @removeLineNodes(visibleLines)
-    @appendOrUpdateVisibleLineNodes(visibleLines, startRow, updateWidth)
-
-  removeLineNodes: (visibleLines=[]) ->
-    {mouseWheelScreenRow} = @props
-    visibleLineIds = new Set
-    visibleLineIds.add(line.id.toString()) for line in visibleLines
-    node = @getDOMNode()
-    for lineId, lineNode of @lineNodesByLineId when not visibleLineIds.has(lineId)
-      screenRow = @screenRowsByLineId[lineId]
-      if not screenRow? or screenRow isnt mouseWheelScreenRow
-        delete @lineNodesByLineId[lineId]
-        delete @lineIdsByScreenRow[screenRow] if @lineIdsByScreenRow[screenRow] is lineId
-        delete @screenRowsByLineId[lineId]
-        delete @renderedDecorationsByLineId[lineId]
-        node.removeChild(lineNode)
-
-  appendOrUpdateVisibleLineNodes: (visibleLines, startRow, updateWidth) ->
-    {lineDecorations} = @props
-
-    newLines = null
-    newLinesHTML = null
-
-    for line, index in visibleLines
-      screenRow = startRow + index
-
-      if @hasLineNode(line.id)
-        @updateLineNode(line, screenRow, updateWidth)
-      else
-        newLines ?= []
-        newLinesHTML ?= ""
-        newLines.push(line)
-        newLinesHTML += @buildLineHTML(line, screenRow)
-        @screenRowsByLineId[line.id] = screenRow
-        @lineIdsByScreenRow[screenRow] = line.id
-
-      @renderedDecorationsByLineId[line.id] = lineDecorations[screenRow]
-
-    return unless newLines?
-
-    WrapperDiv.innerHTML = newLinesHTML
-    newLineNodes = toArray(WrapperDiv.children)
-    node = @getDOMNode()
-    for line, i in newLines
-      lineNode = newLineNodes[i]
-      @lineNodesByLineId[line.id] = lineNode
-      node.appendChild(lineNode)
-
-  hasLineNode: (lineId) ->
-    @lineNodesByLineId.hasOwnProperty(lineId)
-
-  buildLineHTML: (line, screenRow) ->
-    {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=\"#{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
-
-  buildEmptyLineInnerHTML: (line) ->
-    {showIndentGuide} = @props
-    {indentLevel, tabLength} = line
-
-    if showIndentGuide and indentLevel > 0
-      indentSpan = "<span class='indent-guide'>#{multiplyString(' ', tabLength)}</span>"
-      multiplyString(indentSpan, indentLevel)
-    else
-      "&nbsp;"
-
-  buildLineInnerHTML: (line) ->
-    {invisibles, mini, showIndentGuide, invisibles} = @props
-    {tokens, text} = line
-    innerHTML = ""
-
-    scopeStack = []
-    firstTrailingWhitespacePosition = text.search(/\s*$/)
-    lineIsWhitespaceOnly = firstTrailingWhitespacePosition is 0
-    for token in tokens
-      innerHTML += @updateScopeStack(scopeStack, token.scopes)
-      hasIndentGuide = not mini and showIndentGuide and token.hasLeadingWhitespace or (token.hasTrailingWhitespace and lineIsWhitespaceOnly)
-      innerHTML += token.getValueAsHtml({invisibles, hasIndentGuide})
-
-    innerHTML += @popScope(scopeStack) while scopeStack.length > 0
-    innerHTML += @buildEndOfLineHTML(line, invisibles)
-    innerHTML
-
-  buildEndOfLineHTML: (line, invisibles) ->
-    return '' if @props.mini or line.isSoftWrapped()
-
-    html = ''
-    if invisibles.cr? and line.lineEnding is '\r\n'
-      html += "<span class='invisible-character'>#{invisibles.cr}</span>"
-    if invisibles.eol?
-      html += "<span class='invisible-character'>#{invisibles.eol}</span>"
-
-    html
-
-  updateScopeStack: (scopeStack, desiredScopes) ->
-    html = ""
-
-    # Find a common prefix
-    for scope, i in desiredScopes
-      break unless scopeStack[i]?.scope is desiredScopes[i]
-
-    # Pop scopes until we're at the common prefx
-    until scopeStack.length is i
-      html += @popScope(scopeStack)
-
-    # Push onto common prefix until scopeStack equals desiredScopes
-    for j in [i...desiredScopes.length]
-      html += @pushScope(scopeStack, desiredScopes[j])
-
-    html
-
-  popScope: (scopeStack) ->
-    scopeStack.pop()
-    "</span>"
-
-  pushScope: (scopeStack, scope) ->
-    scopeStack.push(scope)
-    "<span class=\"#{scope.replace(/\.+/g, ' ')}\">"
-
-  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
-      lineNode.style.top = screenRow * lineHeightInPixels + 'px'
-      lineNode.dataset.screenRow = screenRow
-      @screenRowsByLineId[line.id] = screenRow
-      @lineIdsByScreenRow[screenRow] = line.id
-
   lineNodeForScreenRow: (screenRow) ->
-    @lineNodesByLineId[@lineIdsByScreenRow[screenRow]]
+    tileComponent = @tileComponentsByStartRow[@tileStartRowForScreenRow(screenRow)]
+    tileComponent?.lineNodeForScreenRow(screenRow)
+
+  tileStartRowForScreenRow: (screenRow) ->
+    screenRow - (screenRow % @tileSize)
 
   measureLineHeightAndDefaultCharWidth: ->
     node = @getDOMNode()
@@ -253,19 +74,44 @@ LinesComponent = React.createClass
     editor.setLineHeightInPixels(lineHeightInPixels)
     editor.setDefaultCharWidth(charWidth)
 
+  updateTiles: (prevProps) ->
+    domNode = @getDOMNode()
+
+    prevProps.tilesState?.forEach (tileState, tileStartRow) =>
+      unless @props.tilesState.has(tileStartRow)
+        tileComponent = @tileComponentsByStartRow[tileStartRow]
+        domNode.removeChild(tileComponent.domNode)
+        delete @tileComponentsByStartRow[tileStartRow]
+
+    @props.tilesState.forEach (tileState, tileStartRow) =>
+      if prevProps.tilesState?.has(tileStartRow)
+        tileComponent = @tileComponentsByStartRow[tileStartRow]
+        tileComponent.update(tileState)
+      else
+        tileComponent = new EditorTileComponent(tileState)
+        @tileComponentsByStartRow[tileStartRow] = tileComponent
+        domNode.appendChild(tileComponent.domNode)
+
+  clearTiles: ->
+    for startRow, tileComponent of @tileComponentsByStartRow
+      domNode.removeChild(tileComponent.domNode)
+      delete @tileComponentsByStartRow[startRow]
+
   remeasureCharacterWidths: ->
     @clearScopedCharWidths()
     @measureCharactersInNewLines()
 
   measureCharactersInNewLines: ->
+    return
     {editor} = @props
     [visibleStartRow, visibleEndRow] = @props.renderedRowRange
     node = @getDOMNode()
 
     editor.batchCharacterMeasurement =>
-      for tokenizedLine in editor.linesForScreenRows(visibleStartRow, visibleEndRow - 1)
+      for tokenizedLine, i in editor.linesForScreenRows(visibleStartRow, visibleEndRow - 1)
+        screenRow = visibleStartRow + i
         unless @measuredLines.has(tokenizedLine)
-          lineNode = @lineNodesByLineId[tokenizedLine.id]
+          lineNode = @lineNodeForScreenRow(screenRow)
           @measureCharactersInLine(tokenizedLine, lineNode)
       return
 

src/package.coffee

@@ -158,7 +158,7 @@ class Package
 
   loadStylesheets: ->
     @stylesheets = @getStylesheetPaths().map (stylesheetPath) ->
-      [stylesheetPath, atom.themes.loadStylesheet(stylesheetPath)]
+      [stylesheetPath, atom.themes.loadStylesheet(stylesheetPath, true)]
 
   getStylesheetsPath: ->
     path.join(@path, @constructor.stylesheetsDir)
@@ -269,6 +269,7 @@ class Package
 
   requireMainModule: ->
     return @mainModule if @mainModule?
+    return unless @isCompatible()
     mainModulePath = @getMainModulePath()
     @mainModule = require(mainModulePath) if fs.isFileSync(mainModulePath)
 
@@ -340,3 +341,72 @@ class Package
     for eventHandler in eventHandlers
       eventHandler.handler = eventHandler.disabledHandler
       delete eventHandler.disabledHandler
+
+  # Does the given module path contain native code?
+  isNativeModule: (modulePath) ->
+    try
+      fs.listSync(path.join(modulePath, 'build', 'Release'), ['.node']).length > 0
+    catch error
+      false
+
+  # Get an array of all the native modules that this package depends on.
+  # This will recurse through all dependencies.
+  getNativeModuleDependencyPaths: ->
+    nativeModulePaths = []
+
+    traversePath = (nodeModulesPath) =>
+      try
+        for modulePath in fs.listSync(nodeModulesPath)
+          nativeModulePaths.push(modulePath) if @isNativeModule(modulePath)
+          traversePath(path.join(modulePath, 'node_modules'))
+
+    traversePath(path.join(@path, 'node_modules'))
+    nativeModulePaths
+
+  # Get the incompatible native modules that this package depends on.
+  # This recurses through all dependencies and requires all modules that
+  # contain a `.node` file.
+  #
+  # This information is cached in local storage on a per package/version basis
+  # to minimize the impact on startup time.
+  getIncompatibleNativeModules: ->
+    localStorageKey = "installed-packages:#{@name}:#{@metadata.version}"
+    unless atom.inDevMode()
+      try
+        {incompatibleNativeModules} = JSON.parse(global.localStorage.getItem(localStorageKey)) ? {}
+      return incompatibleNativeModules if incompatibleNativeModules?
+
+    incompatibleNativeModules = []
+    for nativeModulePath in @getNativeModuleDependencyPaths()
+      try
+        require(nativeModulePath)
+      catch error
+        try
+          version = require("#{nativeModulePath}/package.json").version
+        incompatibleNativeModules.push
+          path: nativeModulePath
+          name: path.basename(nativeModulePath)
+          version: version
+          error: error.message
+
+    global.localStorage.setItem(localStorageKey, JSON.stringify({incompatibleNativeModules}))
+    incompatibleNativeModules
+
+  # Public: Is this package compatible with this version of Atom?
+  #
+  # Incompatible packages cannot be activated. This will include packages
+  # installed to ~/.atom/packages that were built against node 0.11.10 but
+  # now need to be upgrade to node 0.11.13.
+  #
+  # Returns a {Boolean}, true if compatible, false if incompatible.
+  isCompatible: ->
+    return @compatible if @compatible?
+
+    if @path.indexOf(path.join(atom.packages.resourcePath, 'node_modules') + path.sep) is 0
+      # Bundled packages are always considered compatible
+      @compatible = true
+    else if packageMain = @getMainModulePath()
+      @incompatibleModules = @getIncompatibleNativeModules()
+      @compatible = @incompatibleModules.length is 0
+    else
+      @compatible = true

src/react-editor-view.coffee

@@ -1,34 +1,36 @@
 {View, $} = require 'space-pen'
 React = require 'react-atom-fork'
-EditorComponent = require './editor-component'
 {defaults} = require 'underscore-plus'
+TextBuffer = require 'text-buffer'
+Editor = require './editor'
+EditorComponent = require './editor-component'
 
 module.exports =
 class ReactEditorView extends View
-  @content: -> @div class: 'editor react'
+  @content: (params) ->
+    attributes = params.attributes ? {}
+    attributes.class = 'editor react editor-colors'
+    @div attributes
 
   focusOnAttach: false
 
-  constructor: (@editor, @props) ->
+  constructor: (editorOrParams, props) ->
     super
 
-  getEditor: -> @editor
+    if editorOrParams instanceof Editor
+      @editor = editorOrParams
+    else
+      {@editor, mini, placeholderText} = editorOrParams
+      props ?= {}
+      props.mini = mini
+      props.placeholderText = placeholderText
+      @editor ?= new Editor
+        buffer: new TextBuffer
+        softWrap: false
+        tabLength: 2
+        softTabs: true
 
-  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)
+    props = defaults({@editor, parentView: this}, props)
     @component = React.renderComponent(EditorComponent(props), @element)
 
     node = @component.getDOMNode()
@@ -38,20 +40,39 @@ class ReactEditorView extends View
     @overlayer = $(node).find('.lines').addClass('overlayer')
     @hiddenInput = $(node).find('.hidden-input')
 
-    @gutter = $(node).find('.gutter')
-    @gutter.removeClassFromAllLines = (klass) =>
-      @gutter.find('.line-number').removeClass(klass)
+    # FIXME: there should be a better way to deal with the gutter element
+    @subscribe atom.config.observe 'editor.showLineNumbers', =>
+      @gutter = $(node).find('.gutter')
 
-    @gutter.getLineNumberElement = (bufferRow) =>
-      @gutter.find("[data-buffer-row='#{bufferRow}']")
+      @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
+      @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
+
+
+  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
+    @component.pollDOM()
     @focus() if @focusOnAttach
-
     @trigger 'editor:attached', [this]
 
   scrollTop: (scrollTop) ->
@@ -94,7 +115,7 @@ class ReactEditorView extends View
     @find('.lines').prepend(view)
 
   beforeRemove: ->
-    React.unmountComponentAtNode(@element)
+    React.unmountComponentAtNode(@element) if @component.isMounted()
     @attached = false
     @trigger 'editor:detached', this
 
@@ -119,7 +140,7 @@ class ReactEditorView extends View
     pane?.splitDown(pane?.copyActiveItem()).activeView
 
   getPane: ->
-    @closest('.pane').view()
+    @parent('.item-views').parents('.pane').view()
 
   focus: ->
     if @component?
@@ -129,11 +150,18 @@ class ReactEditorView extends View
 
   hide: ->
     super
-    @component?.hide()
+    @pollComponentDOM()
 
   show: ->
     super
-    @component?.show()
+    @pollComponentDOM()
+
+  pollComponentDOM: ->
+    return unless @component?
+    valueToRestore = @component.performSyncUpdates
+    @component.performSyncUpdates = true
+    @component.pollDOM()
+    @component.performSyncUpdates = valueToRestore
 
   pageDown: ->
     @editor.pageDown()
@@ -205,3 +233,12 @@ class ReactEditorView extends View
   resetDisplay: -> # No-op shim for package specs
 
   redraw: -> # No-op shim
+
+  setPlaceholderText: (placeholderText) ->
+    if @component?
+      @component.setProps({placeholderText})
+    else
+      @props.placeholderText = placeholderText
+
+  lineElementForScreenRow: (screenRow) ->
+    $(@component.lineNodeForScreenRow(screenRow))

src/scrollbar-component.coffee

@@ -17,8 +17,9 @@ ScrollbarComponent = React.createClass
         style.width = verticalScrollbarWidth
         style.bottom = horizontalScrollbarHeight if scrollableInOppositeDirection
       when 'horizontal'
-        style.height = horizontalScrollbarHeight
+        style.left = 0
         style.right = verticalScrollbarWidth if scrollableInOppositeDirection
+        style.height = horizontalScrollbarHeight
 
     div {className, style, @onScroll},
       switch orientation

src/select-list-view.coffee

@@ -1,5 +1,8 @@
 {$, View} = require './space-pen-extensions'
-EditorView = require './editor-view'
+if atom.config.get('core.useReactMiniEditors')
+  EditorView = require './react-editor-view'
+else
+  EditorView = require './editor-view'
 fuzzyFilter = require('fuzzaldrin').filter
 
 # Public: Provides a view that renders a list of items with an editor that

src/selection.coffee

@@ -392,7 +392,7 @@ class Selection extends Model
       if autoIndent and delta > 0
         @insertText(@editor.buildIndentString(delta))
       else
-        @insertText(@editor.getTabText())
+        @insertText(@editor.buildIndentString(1, @cursor.getBufferColumn()))
     else
       @indentSelectedRows()
 

src/theme-manager.coffee

@@ -128,7 +128,7 @@ class ThemeManager
     @userStylesheetFile = new File(userStylesheetPath)
     @userStylesheetFile.on 'contents-changed moved removed', =>
       @loadUserStylesheet()
-    userStylesheetContents = @loadStylesheet(userStylesheetPath)
+    userStylesheetContents = @loadStylesheet(userStylesheetPath, true)
     @applyStylesheet(userStylesheetPath, userStylesheetContents, 'userTheme')
 
   loadBaseStylesheets: ->
@@ -167,19 +167,27 @@ class ThemeManager
 
     fullPath
 
-  loadStylesheet: (stylesheetPath) ->
+  loadStylesheet: (stylesheetPath, importFallbackVariables) ->
     if path.extname(stylesheetPath) is '.less'
-      @loadLessStylesheet(stylesheetPath)
+      @loadLessStylesheet(stylesheetPath, importFallbackVariables)
     else
       fs.readFileSync(stylesheetPath, 'utf8')
 
-  loadLessStylesheet: (lessStylesheetPath) ->
+  loadLessStylesheet: (lessStylesheetPath, importFallbackVariables=false) ->
     unless @lessCache?
       LessCompileCache = require './less-compile-cache'
       @lessCache = new LessCompileCache({@resourcePath, importPaths: @getImportPaths()})
 
     try
-      @lessCache.read(lessStylesheetPath)
+      if importFallbackVariables
+        baseVarImports = """
+        @import "variables/ui-variables";
+        @import "variables/syntax-variables";
+        """
+        less = fs.readFileSync(lessStylesheetPath, 'utf8')
+        @lessCache.cssForFile(lessStylesheetPath, [baseVarImports, less].join('\n'))
+      else
+        @lessCache.read(lessStylesheetPath)
     catch e
       console.error """
         Error compiling less stylesheet: #{lessStylesheetPath}

src/window-event-handler.coffee

@@ -57,8 +57,7 @@ class WindowEventHandler
 
     @subscribeToCommand $(document), 'core:focus-previous', @focusPrevious
 
-    @subscribe $(document), 'keydown', (event) ->
-      atom.keymaps.handleKeyboardEvent(event.originalEvent)
+    document.addEventListener 'keydown', @onKeydown
 
     @subscribe $(document), 'drop', (e) ->
       e.preventDefault()
@@ -95,6 +94,10 @@ class WindowEventHandler
     bindCommandToAction('core:redo', 'redo:')
     bindCommandToAction('core:select-all', 'selectAll:')
 
+  onKeydown: (event) ->
+    atom.keymaps.handleKeyboardEvent(event)
+    event.stopImmediatePropagation()
+
   openLink: ({target, currentTarget}) ->
     location = target?.getAttribute('href') or currentTarget?.getAttribute('href')
     if location and location[0] isnt '#' and /^https?:\/\//.test(location)

src/workspace-view.coffee

@@ -71,7 +71,7 @@ class WorkspaceView extends View
     projectHome: path.join(fs.getHomeDirectory(), 'github')
     audioBeep: true
     destroyEmptyPanes: true
-    useReactEditor: false
+    useReactEditor: true
 
   @content: ->
     @div class: 'workspace', tabindex: -1, =>
@@ -96,6 +96,11 @@ class WorkspaceView extends View
         when 'overlay'
           @addClass("scrollbars-visible-when-scrolling")
 
+
+    @subscribe atom.config.observe 'editor.fontSize', @setEditorFontSize
+    @subscribe atom.config.observe 'editor.fontFamily', @setEditorFontFamily
+    @subscribe atom.config.observe 'editor.lineHeight', @setEditorLineHeight
+
     @updateTitle()
 
     @on 'focus', (e) => @handleFocus(e)
@@ -340,6 +345,26 @@ class WorkspaceView extends View
   beforeRemove: ->
     @model.destroy()
 
+  setEditorFontSize: (fontSize) =>
+    @setEditorStyle('font-size', fontSize + 'px')
+
+  setEditorFontFamily: (fontFamily) =>
+    @setEditorStyle('font-family', fontFamily)
+
+  setEditorLineHeight: (lineHeight) =>
+    @setEditorStyle('line-height', lineHeight)
+
+  setEditorStyle: (property, value) ->
+    unless styleNode = atom.themes.stylesheetElementForId('global-editor-styles')[0]
+      atom.themes.applyStylesheet('global-editor-styles', '.editor {}')
+      styleNode = atom.themes.stylesheetElementForId('global-editor-styles')[0]
+
+    {sheet} = styleNode
+    editorRule = sheet.cssRules[0]
+    editorRule.style[property] = value
+    atom.themes.emit 'stylesheet-updated', sheet
+    atom.themes.emit 'stylesheets-changed'
+
   # Deprecated
   eachPane: (callback) ->
     deprecate("Use WorkspaceView::eachPaneView instead")

static/atom.less

@@ -1,7 +1,9 @@
 // Import from the syntax theme's variables with a fallback to ./variables/syntax-variables.less
+@import "./variables/syntax-variables";
 @import "syntax-variables";
 
 // Import from the ui theme's variables with a fallback to ./variables/ui-variables.less
+@import "./variables/ui-variables";
 @import "ui-variables";
 
 @import "octicon-utf-codes";

static/editor.less

@@ -3,6 +3,10 @@
 @import "octicon-mixins";
 
 .editor.react {
+  .editor-contents {
+    width: 100%;
+  }
+
   .underlayer {
     position: absolute;
     top: 0;
@@ -81,15 +85,29 @@
   }
 }
 
+.editor.mini {
+  font-size: @input-font-size;
+  line-height: @component-line-height;
+  max-height: @component-line-height + 2; // +2 for borders
+
+  .placeholder-text {
+    position: absolute;
+    color: @text-color-subtle;
+  }
+}
+
+.editor {
+  z-index: 0;
+  font-family: Inconsolata, Monaco, Consolas, 'Courier New', Courier;
+  line-height: 1.3;
+}
+
 .editor, .editor-contents {
   overflow: hidden;
   cursor: text;
   display: -webkit-flex;
   -webkit-user-select: none;
   position: relative;
-  z-index: 0;
-  font-family: Inconsolata, Monaco, Consolas, 'Courier New', Courier;
-  line-height: 1.3;
 }
 
 .editor .gutter .line-number.cursor-line {
@@ -179,6 +197,11 @@
   box-shadow: inset 1px 0;
 }
 
+.editor .vertical-scrollbar,
+.editor .horizontal-scrollbar {
+  cursor: default;
+}
+
 .editor .vertical-scrollbar {
   position: absolute;
   top: 0;
@@ -267,7 +290,7 @@
   z-index: -1;
 }
 
-.editor.mini {
+.editor.mini:not(.react) {
   height: auto;
   line-height: 25px;
 
@@ -284,8 +307,4 @@
   .scroll-view {
     overflow: hidden;
   }
-
-  .placeholder-text {
-    color: @text-color-subtle;
-  }
 }