Use opacity to blink cursor instead of visibility so blink can be styled

Upgrade to incompatible-packages@0.8
Update to deprecation-cop@0.9
2014-08-14 13:20:43 -06:00 · 2014-08-14 12:13:30 -07:00 · 2014-08-14 12:11:13 -07:00 · 2014-08-14 11:39:16 -07:00 · 2014-08-14 09:53:10 -07:00 · 2014-08-14 09:52:20 -07:00
@@ -6,6 +6,6 @@
    "url": "https://github.com/atom/atom.git"
  },
  "dependencies": {
-    "atom-package-manager": "0.83.0"
+    "atom-package-manager": "0.91.0"
  }
 }
@@ -144,12 +144,7 @@ module.exports = (grunt) ->

    coffeelint:
      options:
-        no_empty_param_list:
-          level: 'error'
-        max_line_length:
-          level: 'ignore'
-        indentation:
-          level: 'ignore'
+        configFile: 'coffeelint.json'
      src: [
        'dot-atom/**/*.coffee'
        'exports/**/*.coffee'
@@ -13,7 +13,7 @@
    "github-releases": "~0.2.0",
    "grunt": "~0.4.1",
    "grunt-cli": "~0.1.9",
-    "grunt-coffeelint": "git+https://github.com/atom/grunt-coffeelint.git",
+    "grunt-coffeelint": "git+https://github.com/atom/grunt-coffeelint.git#cfb99aa99811d52687969532bd5a98011ed95bfe",
    "grunt-contrib-coffee": "~0.9.0",
    "grunt-contrib-csslint": "~0.1.2",
    "grunt-contrib-less": "~0.8.0",
@@ -33,7 +33,7 @@
    "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"
@@ -148,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'), ''
@@ -45,8 +45,8 @@ module.exports = (grunt) ->

        strings =
          CompanyName: 'GitHub, Inc.'
-          FileDescription: 'The hackable editor'
-          LegalCopyright: 'Copyright (C) 2013 GitHub, Inc. All rights reserved'
+          FileDescription: 'Atom'
+          LegalCopyright: 'Copyright (C) 2014 GitHub, Inc. All rights reserved'
          ProductName: 'Atom'
          ProductVersion: version

@@ -0,0 +1,14 @@
+{
+  "indentation": {
+    "level": "ignore"
+  },
+  "max_line_length": {
+    "level": "ignore"
+  },
+  "no_empty_param_list": {
+    "level": "error"
+  },
+  "no_unnecessary_fat_arrows": {
+    "level": "ignore"
+  }
+}
@@ -6,23 +6,26 @@ Ubuntu LTS 12.04 64-bit is the recommended platform.

  * OS with 64-bit or 32-bit architecture
  * C++ toolchain
-  * git
-  * [node.js](http://nodejs.org/download/) v0.10.x
-  * [npm](http://www.npmjs.org/) v1.4.x (bundled with node.js)
+  * [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).
-  * libgnome-keyring-dev
+  * 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).
+* 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).
+* 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.

@@ -30,19 +33,43 @@ Ubuntu LTS 12.04 64-bit is the recommended platform.

 If you have problems with permissions don't forget to prefix with `sudo`

-  ```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, e.g. /tmp/atom-build
-  ```
-  
-To run `atom` and `apm` from a terminal open atom's command palette `ctrl+shift+p` and run `Window: Install Shell Commands`
+From the cloned repository directory:
+
+ 1. Build:
+
+    ```sh
+    $ script/build
+    ```
+    This will create the atom application at `$TMPDIR/atom-build/Atom`.
+ 2. Install the `atom` and `apm` commands to `/usr/local/bin` by executing:
+
+    ```sh
+    $ sudo script/grunt install
+    ```
+ 3. *Optionally*, you may generate a `.deb` package at `$TMPDIR/atom-build`:
+
+    ```sh
+    $ script/grunt mkdeb
+    ```
+
+Use the newly installed atom by restarting any running atom instances.
+
+## Advanced Options
+
+### Custom install directory
+
+```sh
+sudo script/grunt install --install-dir /install/atom/here
+```
+
+### Custom build directory
+
+```sh
+script/build --build-dir /build/atom/here
+```

 ## Troubleshooting

-
 ### Exception: "TypeError: Unable to watch path"

 If you get following error with a big traceback right after Atom starts:
@@ -69,7 +96,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.

@@ -66,6 +66,19 @@ If none of this works, do install Github for Windows and use its Git shell. Make
    * https://github.com/TooTallNate/node-gyp/issues/297
    * https://code.google.com/p/gyp/issues/detail?id=393

+* `script/build` stops at installing runas with 'Failed at the runas@0.5.4 install script.'
+  
+  See the next item.
+
+* `error MSB8020: The build tools for Visual Studio 2010 (Platform Toolset = 'v100') cannot be found.`
+   
+  * If you're building atom with Visual Studio 2013 try executing the following
+    command in your Git shell and then re-run `script/build`:
+
+    ```
+    $env:GYP_MSVS_VERSION=2013
+    ```
+
 * 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.

@@ -25,3 +25,5 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
  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'
@@ -12,7 +12,6 @@
  # Sublime Parity
  'tab': 'editor:indent'
  'enter': 'editor:newline'
-  'num-enter': 'editor:newline'
  'shift-tab': 'editor:outdent-selected-rows'
  'ctrl-K': 'editor:delete-line'

@@ -27,7 +26,6 @@
  'tab': 'core:focus-next'
  'shift-tab': 'core:focus-previous'
  'enter': 'native!'
-  'num-enter': 'native!'
  'backspace': 'native!'
  'shift-backspace': 'native!'
  'delete': 'native!'
@@ -21,7 +21,6 @@
  'cmd-O': 'application:open-dev'
  'cmd-alt-ctrl-s': 'application:run-all-specs'
  'enter': 'core:confirm'
-  'num-enter': 'core:confirm'
  'escape': 'core:cancel'
  'up': 'core:move-up'
  'down': 'core:move-down'
@@ -1,7 +1,6 @@
 'body':
  # Atom Specific
  'enter': 'core:confirm'
-  'num-enter': 'core:confirm'
  'escape': 'core:cancel'
  'up': 'core:move-up'
  'down': 'core:move-down'
@@ -5,7 +5,6 @@

  # Atom Specific
  'enter': 'core:confirm'
-  'num-enter': 'core:confirm'
  'escape': 'core:cancel'
  'up': 'core:move-up'
  'down': 'core:move-down'
@@ -1,7 +1,7 @@
 {
  "name": "atom",
  "productName": "Atom",
-  "version": "0.120.0",
+  "version": "0.122.0",
  "description": "A hackable text editor for the 21st Century.",
  "main": "./src/browser/main.js",
  "repository": {
@@ -17,108 +17,109 @@
      "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
    }
  ],
-  "atomShellVersion": "0.13.3",
+  "atomShellVersion": "0.15.6",
  "dependencies": {
    "async": "0.2.6",
-    "atom-keymap": "^0.28.0",
+    "atom-keymap": "^2.0.1",
    "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.4",
+    "emissary": "^1.2.2",
+    "first-mate": "^2.0.1",
+    "fs-plus": "^2.2.6",
    "fstream": "0.1.24",
    "fuzzaldrin": "^1.1",
-    "git-utils": "^1.6",
-    "grim": "0.11.0",
+    "git-utils": "^2.1.4",
+    "grim": "0.12.0",
    "guid": "0.0.10",
    "jasmine-tagged": "^1.1.2",
    "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.5",
+    "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.1",
+    "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.1",
    "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.20.0",
+    "atom-light-ui": "0.29.0",
+    "base16-tomorrow-dark-theme": "0.21.0",
    "base16-tomorrow-light-theme": "0.4.0",
-    "solarized-dark-syntax": "0.21.0",
-    "solarized-light-syntax": "0.11.0",
-    "archive-view": "0.34.0",
-    "autocomplete": "0.28.0",
+    "solarized-dark-syntax": "0.22.0",
+    "solarized-light-syntax": "0.12.0",
+    "archive-view": "0.36.0",
+    "autocomplete": "0.31.0",
    "autoflow": "0.17.0",
-    "autosave": "0.14.0",
+    "autosave": "0.15.0",
    "background-tips": "0.15.0",
    "bookmarks": "0.27.0",
-    "bracket-matcher": "0.50.0",
+    "bracket-matcher": "0.54.0",
    "command-palette": "0.24.0",
-    "deprecation-cop": "0.7.0",
-    "dev-live-reload": "0.32.0",
-    "exception-reporting": "0.19.0",
+    "deprecation-cop": "0.9.0",
+    "dev-live-reload": "0.34.0",
+    "exception-reporting": "0.20.0",
    "feedback": "0.33.0",
-    "find-and-replace": "0.127.0",
+    "find-and-replace": "0.128.0",
    "fuzzy-finder": "0.57.0",
    "git-diff": "0.37.0",
-    "go-to-line": "0.23.0",
+    "go-to-line": "0.24.0",
    "grammar-selector": "0.27.0",
    "image-view": "0.36.0",
-    "keybinding-resolver": "0.18.0",
-    "link": "0.24.0",
-    "markdown-preview": "0.93.0",
+    "incompatible-packages": "0.8.0",
+    "keybinding-resolver": "0.19.0",
+    "link": "0.25.0",
+    "markdown-preview": "0.99.0",
    "metrics": "0.33.0",
    "open-on-github": "0.29.0",
    "package-generator": "0.31.0",
    "release-notes": "0.36.0",
-    "settings-view": "0.136.0",
-    "snippets": "0.49.0",
-    "spell-check": "0.38.0",
-    "status-bar": "0.41.0",
+    "settings-view": "0.139.0",
+    "snippets": "0.51.0",
+    "spell-check": "0.41.0",
+    "status-bar": "0.42.0",
    "styleguide": "0.29.0",
-    "symbols-view": "0.61.0",
-    "tabs": "0.48.0",
+    "symbols-view": "0.63.0",
+    "tabs": "0.49.0",
    "timecop": "0.22.0",
-    "tree-view": "0.111.0",
+    "tree-view": "0.112.0",
    "update-package-dependencies": "0.6.0",
    "welcome": "0.17.0",
    "whitespace": "0.25.0",
    "wrap-guide": "0.21.0",

-    "language-c": "0.26.0",
-    "language-coffee-script": "0.27.0",
+    "language-c": "0.27.0",
+    "language-coffee-script": "0.29.0",
    "language-css": "0.17.0",
-    "language-gfm": "0.43.0",
+    "language-gfm": "0.46.0",
    "language-git": "0.9.0",
    "language-go": "0.16.0",
-    "language-html": "0.22.0",
+    "language-html": "0.24.0",
    "language-hyperlink": "0.10.0",
    "language-java": "0.11.0",
-    "language-javascript": "0.37.0",
+    "language-javascript": "0.39.0",
    "language-json": "0.8.0",
    "language-less": "0.13.0",
    "language-make": "0.10.0",
@@ -127,17 +128,17 @@
    "language-php": "0.15.0",
    "language-property-list": "0.7.0",
    "language-python": "0.18.0",
-    "language-ruby": "0.33.0",
+    "language-ruby": "0.34.0",
    "language-ruby-on-rails": "0.15.0",
-    "language-sass": "0.14.0",
+    "language-sass": "0.16.0",
    "language-shellscript": "0.8.0",
-    "language-source": "0.7.0",
-    "language-sql": "0.9.0",
+    "language-source": "0.8.0",
+    "language-sql": "0.10.0",
    "language-text": "0.6.0",
    "language-todo": "0.10.0",
    "language-toml": "0.12.0",
-    "language-xml": "0.17.0",
-    "language-yaml": "0.13.0"
+    "language-xml": "0.18.0",
+    "language-yaml": "0.15.0"
  },
  "private": true,
  "scripts": {
@@ -23,6 +23,18 @@ describe "Config", ->
      retrievedValue.array[1].b = 2.1
      expect(atom.config.get('value')).toEqual(array: [1, b: 2, 3])

+    it "merges defaults into the returned value if both the assigned value and the default value are objects", ->
+      atom.config.setDefaults("foo", a: 1, b: 2)
+      atom.config.set("foo", a: 3)
+      expect(atom.config.get("foo")).toEqual {a: 3, b: 2}
+
+      atom.config.set("foo", 7)
+      expect(atom.config.get("foo")).toBe 7
+
+      atom.config.set("bar.baz", a: 3)
+      atom.config.setDefaults("bar", baz: 7)
+      expect(atom.config.get("bar.baz")).toEqual {a: 3}
+
  describe ".set(keyPath, value)", ->
    it "allows a key path's value to be written", ->
      expect(atom.config.set("foo.bar.baz", 42)).toBe 42
@@ -499,6 +499,15 @@ describe "Editor", ->
          cursor = editor.getCursor()
          expect(cursor.getBufferPosition()).toEqual [1,0]

+        describe "when invisible characters are enabled", ->
+          it "moves to the first character of the current line without being confused by the invisible characters", ->
+            atom.config.set('editor.showInvisibles', true)
+            editor.setCursorScreenPosition [1,7]
+            editor.moveCursorToFirstCharacterOfLine()
+            expect(editor.getCursorBufferPosition()).toEqual [1,2]
+            editor.moveCursorToFirstCharacterOfLine()
+            expect(editor.getCursorBufferPosition()).toEqual [1,0]
+
    describe ".moveCursorToBeginningOfWord()", ->
      it "moves the cursor to the beginning of the word", ->
        editor.setCursorBufferPosition [0, 8]
@@ -1470,6 +1479,15 @@ describe "Editor", ->

  describe "buffer manipulation", ->
    describe ".insertText(text)", ->
+      describe "when there is a single selection", ->
+        beforeEach ->
+          editor.setSelectedBufferRange([[1, 0], [1, 2]])
+
+        it "will-insert-text and did-insert-text events are emitted when inserting text", ->
+          range = editor.insertText('xxx')
+          expect(range).toEqual [ [[1, 0], [1, 3]] ]
+          expect(buffer.lineForRow(1)).toBe 'xxxvar sort = function(items) {'
+
      describe "when there are multiple empty selections", ->
        describe "when the cursors are on the same line", ->
          it "inserts the given text at the location of each cursor and moves the cursors to the end of each cursor's inserted text", ->
@@ -1547,6 +1565,48 @@ describe "Editor", ->
          editor.insertText('holy cow')
          expect(editor.lineForScreenRow(2).fold).toBeUndefined()

+      describe "when will-insert-text and did-insert-text events are used", ->
+        beforeEach ->
+          editor.setSelectedBufferRange([[1, 0], [1, 2]])
+
+        it "will-insert-text and did-insert-text events are emitted when inserting text", ->
+          willInsertSpy = jasmine.createSpy().andCallFake ->
+            expect(buffer.lineForRow(1)).toBe '  var sort = function(items) {'
+
+          didInsertSpy = jasmine.createSpy().andCallFake ->
+            expect(buffer.lineForRow(1)).toBe 'xxxvar sort = function(items) {'
+
+          editor.on('will-insert-text', willInsertSpy)
+          editor.on('did-insert-text', didInsertSpy)
+
+          expect(editor.insertText('xxx')).toBeTruthy()
+          expect(buffer.lineForRow(1)).toBe 'xxxvar sort = function(items) {'
+
+          expect(willInsertSpy).toHaveBeenCalled()
+          expect(didInsertSpy).toHaveBeenCalled()
+
+          options = willInsertSpy.mostRecentCall.args[0]
+          expect(options.text).toBe 'xxx'
+          expect(options.cancel).toBeDefined()
+
+          options = didInsertSpy.mostRecentCall.args[0]
+          expect(options.text).toBe 'xxx'
+
+        it "text insertion is prevented when cancel is called from a will-insert-text handler", ->
+          willInsertSpy = jasmine.createSpy().andCallFake ({cancel}) ->
+            cancel()
+
+          didInsertSpy = jasmine.createSpy()
+
+          editor.on('will-insert-text', willInsertSpy)
+          editor.on('did-insert-text', didInsertSpy)
+
+          expect(editor.insertText('xxx')).toBe false
+          expect(buffer.lineForRow(1)).toBe '  var sort = function(items) {'
+
+          expect(willInsertSpy).toHaveBeenCalled()
+          expect(didInsertSpy).not.toHaveBeenCalled()
+
    describe ".insertNewline()", ->
      describe "when there is a single cursor", ->
        describe "when the cursor is at the beginning of a line", ->
@@ -3301,20 +3361,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
@@ -2414,37 +2414,6 @@ describe "EditorView", ->
      expect(editor.getCursor().getScreenPosition().row).toBe(0)
      expect(editorView.getFirstVisibleScreenRow()).toBe(0)

-  describe ".checkoutHead()", ->
-    [filePath] = []
-
-    beforeEach ->
-      workingDirPath = temp.mkdirSync('atom-working-dir')
-      fs.copySync(path.join(__dirname, 'fixtures', 'git', 'working-dir'), workingDirPath)
-      fs.renameSync(path.join(workingDirPath, 'git.git'), path.join(workingDirPath, '.git'))
-      atom.project.setPath(workingDirPath)
-      filePath = atom.project.resolve('file.txt')
-
-      waitsForPromise ->
-        atom.workspace.open(filePath).then (o) -> editor = o
-
-      runs ->
-        editorView.edit(editor)
-
-    it "restores the contents of the editor view to the HEAD revision", ->
-      editor.setText('')
-      editor.save()
-
-      fileChangeHandler = jasmine.createSpy('fileChange')
-      editor.getBuffer().file.on 'contents-changed', fileChangeHandler
-
-      editorView.checkoutHead()
-
-      waitsFor "file to trigger contents-changed event", ->
-        fileChangeHandler.callCount > 0
-
-      runs ->
-        expect(editor.getText()).toBe('undefined')
-
  describe ".pixelPositionForBufferPosition(position)", ->
    describe "when the editor view is detached", ->
      it "returns top and left values of 0", ->
@@ -2652,7 +2621,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

@@ -2999,8 +2967,8 @@ describe "EditorView", ->
        expect(editorView.lineElementForScreenRow(rowNumber).text()).toBe buffer.lineForRow(rowNumber)

    it "correctly calculates the position left for non-monospaced invisibles", ->
-      editorView.setShowInvisibles(true)
-      editorView.setInvisibles tab: '♘'
+      atom.config.set('editor.showInvisibles', true)
+      atom.config.set('editor.invisibles', tab: '♘')
      editor.setText('\tx')

      editorView.setFontFamily('serif')
@@ -0,0 +1 @@
+throw new Error("this simulates a native module's failure to load")
@@ -0,0 +1,4 @@
+{
+  "name": "native-module",
+  "main": "./main.js"
+}
@@ -0,0 +1,5 @@
+{
+  "name": "package-with-incompatible-native-module",
+  "version": "1.0",
+  "main": "./main.js"
+}
@@ -119,6 +119,38 @@ describe "Git", ->
      repo.checkoutHead(filePath)
      expect(statusHandler.callCount).toBe 1

+  describe ".checkoutHeadForEditor(editor)", ->
+    [filePath, editor] = []
+
+    beforeEach ->
+      workingDirPath = copyRepository()
+      repo = new Git(workingDirPath)
+      filePath = path.join(workingDirPath, 'a.txt')
+      fs.writeFileSync(filePath, 'ch ch changes')
+
+      waitsForPromise ->
+        atom.workspace.open(filePath)
+
+      runs ->
+        editor = atom.workspace.getActiveEditor()
+
+    it "displays a confirmation dialog by default", ->
+      spyOn(atom, 'confirm').andCallFake ({buttons}) -> buttons.OK()
+      atom.config.set('editor.confirmCheckoutHeadRevision', true)
+
+      repo.checkoutHeadForEditor(editor)
+
+      expect(fs.readFileSync(filePath, 'utf8')).toBe ''
+
+    it "does not display a dialog when confirmation is disabled", ->
+      spyOn(atom, 'confirm')
+      atom.config.set('editor.confirmCheckoutHeadRevision', false)
+
+      repo.checkoutHeadForEditor(editor)
+
+      expect(fs.readFileSync(filePath, 'utf8')).toBe ''
+      expect(atom.confirm).not.toHaveBeenCalled()
+
  describe ".destroy()", ->
    it "throws an exception when any method is called after it is called", ->
      repo = new Git(require.resolve('./fixtures/git/master.git/HEAD'))
@@ -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

@@ -28,7 +28,7 @@ atom.keymaps.loadBundledKeymaps()
 keyBindingsToRestore = atom.keymaps.getKeyBindings()

 $(window).on 'core:close', -> window.close()
-$(window).on 'unload', ->
+$(window).on 'beforeunload', ->
  atom.storeWindowDimensions()
  atom.saveSync()
 $('html,body').css('overflow', 'auto')
@@ -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
@@ -209,6 +211,13 @@ addCustomMatchers = (spec) ->
      element = element.get(0) if element.jquery
      element.webkitMatchesSelector(":focus") or element.querySelector(":focus")

+    toShow: ->
+      notText = if @isNot then " not" else ""
+      element = @actual
+      element = element.get(0) if element.jquery
+      @message = -> return "Expected element '#{element}' or its descendants #{notText} to show."
+      element.style.display in ['block', 'inline-block', 'static', 'fixed']
+
 window.keyIdentifierForKey = (key) ->
  if key.length > 1 # named key
    key
@@ -310,3 +310,59 @@ describe "ThemeManager", ->
      runs ->
        expect(console.warn.callCount).toBe 1
        expect(console.warn.argsForCall[0][0].length).toBeGreaterThan 0
+
+  describe "when in safe mode", ->
+    beforeEach ->
+      themeManager = new ThemeManager({packageManager: atom.packages, resourcePath, configDirPath, safeMode: true})
+
+    describe 'when the enabled UI and syntax themes are bundled with Atom', ->
+      beforeEach ->
+        atom.config.set('core.themes', ['atom-light-ui', 'atom-dark-syntax'])
+
+        waitsForPromise ->
+          themeManager.activateThemes()
+
+      it 'uses the enabled themes', ->
+        activeThemeNames = themeManager.getActiveNames()
+        expect(activeThemeNames.length).toBe(2)
+        expect(activeThemeNames).toContain('atom-light-ui')
+        expect(activeThemeNames).toContain('atom-dark-syntax')
+
+    describe 'when the enabled UI and syntax themes are not bundled with Atom', ->
+      beforeEach ->
+        atom.config.set('core.themes', ['installed-dark-ui', 'installed-dark-syntax'])
+
+        waitsForPromise ->
+          themeManager.activateThemes()
+
+      it 'uses the default dark UI and syntax themes', ->
+        activeThemeNames = themeManager.getActiveNames()
+        expect(activeThemeNames.length).toBe(2)
+        expect(activeThemeNames).toContain('atom-dark-ui')
+        expect(activeThemeNames).toContain('atom-dark-syntax')
+
+    describe 'when the enabled UI theme is not bundled with Atom', ->
+      beforeEach ->
+        atom.config.set('core.themes', ['installed-dark-ui', 'atom-light-syntax'])
+
+        waitsForPromise ->
+          themeManager.activateThemes()
+
+      it 'uses the default dark UI theme', ->
+        activeThemeNames = themeManager.getActiveNames()
+        expect(activeThemeNames.length).toBe(2)
+        expect(activeThemeNames).toContain('atom-dark-ui')
+        expect(activeThemeNames).toContain('atom-light-syntax')
+
+    describe 'when the enabled syntax theme is not bundled with Atom', ->
+      beforeEach ->
+        atom.config.set('core.themes', ['atom-light-ui', 'installed-dark-syntax'])
+
+        waitsForPromise ->
+          themeManager.activateThemes()
+
+      it 'uses the default dark syntax theme', ->
+        activeThemeNames = themeManager.getActiveNames()
+        expect(activeThemeNames.length).toBe(2)
+        expect(activeThemeNames).toContain('atom-light-ui')
+        expect(activeThemeNames).toContain('atom-dark-syntax')
@@ -1,4 +1,5 @@
 TokenizedBuffer = require '../src/tokenized-buffer'
+TextBuffer = require 'text-buffer'
 _ = require 'underscore-plus'

 describe "TokenizedBuffer", ->
@@ -12,6 +13,9 @@ describe "TokenizedBuffer", ->
    waitsForPromise ->
      atom.packages.activatePackage('language-javascript')

+  afterEach ->
+    tokenizedBuffer?.destroy()
+
  startTokenizing = (tokenizedBuffer) ->
    tokenizedBuffer.setVisible(true)

@@ -584,42 +588,95 @@ describe "TokenizedBuffer", ->
      atom.config.set('editor.tabLength', 0)
      expect(tokenizedBuffer.tokenForPosition([0,0]).value).toBe '  '

+  describe "when the invisibles value changes", ->
+    beforeEach ->
+
+    it "updates the tokens with the appropriate invisible characters", ->
+      buffer = new TextBuffer(text: "  \t a line with tabs\tand \tspaces \t ")
+      tokenizedBuffer = new TokenizedBuffer({buffer})
+      fullyTokenize(tokenizedBuffer)
+
+      tokenizedBuffer.setInvisibles(space: 'S', tab: 'T')
+      fullyTokenize(tokenizedBuffer)
+
+      expect(tokenizedBuffer.lineForScreenRow(0).text).toBe "SST Sa line with tabsTand T spacesSTS"
+      # Also needs to work for copies
+      expect(tokenizedBuffer.lineForScreenRow(0).copy().text).toBe "SST Sa line with tabsTand T spacesSTS"
+
+    it "assigns endOfLineInvisibles to tokenized lines", ->
+      buffer = new TextBuffer(text: "a line that ends in a carriage-return-line-feed \r\na line that ends in just a line-feed\na line with no ending")
+      tokenizedBuffer = new TokenizedBuffer({buffer})
+
+      atom.config.set('editor.showInvisibles', true)
+      tokenizedBuffer.setInvisibles(cr: 'R', eol: 'N')
+      fullyTokenize(tokenizedBuffer)
+
+      expect(tokenizedBuffer.lineForScreenRow(0).endOfLineInvisibles).toEqual ['R', 'N']
+      expect(tokenizedBuffer.lineForScreenRow(1).endOfLineInvisibles).toEqual ['N']
+
+      # Lines ending in soft wraps get no invisibles
+      [left, right] = tokenizedBuffer.lineForScreenRow(0).softWrapAt(20)
+      expect(left.endOfLineInvisibles).toBe null
+      expect(right.endOfLineInvisibles).toEqual ['R', 'N']
+
+      tokenizedBuffer.setInvisibles(cr: 'R', eol: false)
+      expect(tokenizedBuffer.lineForScreenRow(0).endOfLineInvisibles).toEqual ['R']
+      expect(tokenizedBuffer.lineForScreenRow(1).endOfLineInvisibles).toEqual []
+
  describe "leading and trailing whitespace", ->
    beforeEach ->
      buffer = atom.project.bufferForPathSync('sample.js')
      tokenizedBuffer = new TokenizedBuffer({buffer})
      fullyTokenize(tokenizedBuffer)

-    it "sets ::hasLeadingWhitespace to true on tokens that have leading whitespace", ->
+    it "sets ::hasLeadingWhitespace to true and assigns ::firstNonWhitespaceIndex on tokens that have leading whitespace", ->
      expect(tokenizedBuffer.lineForScreenRow(0).tokens[0].hasLeadingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(0).tokens[0].firstNonWhitespaceIndex).toBe null
+
      expect(tokenizedBuffer.lineForScreenRow(1).tokens[0].hasLeadingWhitespace).toBe true
+      expect(tokenizedBuffer.lineForScreenRow(1).tokens[0].firstNonWhitespaceIndex).toBe 2
+
      expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].hasLeadingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].firstNonWhitespaceIndex).toBe null
+
      expect(tokenizedBuffer.lineForScreenRow(2).tokens[0].hasLeadingWhitespace).toBe true
+      expect(tokenizedBuffer.lineForScreenRow(2).tokens[0].firstNonWhitespaceIndex).toBe 2
      expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].hasLeadingWhitespace).toBe true
+      expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].firstNonWhitespaceIndex).toBe 2
      expect(tokenizedBuffer.lineForScreenRow(2).tokens[2].hasLeadingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(2).tokens[2].firstNonWhitespaceIndex).toBe null

      # The 4th token *has* leading whitespace, but isn't entirely whitespace
      buffer.insert([5, 0], ' ')
      expect(tokenizedBuffer.lineForScreenRow(5).tokens[3].hasLeadingWhitespace).toBe true
+      expect(tokenizedBuffer.lineForScreenRow(5).tokens[3].firstNonWhitespaceIndex).toBe 1
      expect(tokenizedBuffer.lineForScreenRow(5).tokens[4].hasLeadingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(5).tokens[4].firstNonWhitespaceIndex).toBe null

      # Lines that are *only* whitespace are not considered to have leading whitespace
      buffer.insert([10, 0], '  ')
      expect(tokenizedBuffer.lineForScreenRow(10).tokens[0].hasLeadingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(10).tokens[0].firstNonWhitespaceIndex).toBe null

-    it "sets ::hasTrailingWhitespace to true on tokens that have trailing whitespace", ->
+    it "sets ::hasTrailingWhitespace to true and assigns ::firstTrailingWhitespaceIndex on tokens that have trailing whitespace", ->
      buffer.insert([0, Infinity], '  ')
      expect(tokenizedBuffer.lineForScreenRow(0).tokens[11].hasTrailingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(0).tokens[11].firstTrailingWhitespaceIndex).toBe null
      expect(tokenizedBuffer.lineForScreenRow(0).tokens[12].hasTrailingWhitespace).toBe true
+      expect(tokenizedBuffer.lineForScreenRow(0).tokens[12].firstTrailingWhitespaceIndex).toBe 0

      # The last token *has* trailing whitespace, but isn't entirely whitespace
      buffer.setTextInRange([[2, 39], [2, 40]], '  ')
      expect(tokenizedBuffer.lineForScreenRow(2).tokens[14].hasTrailingWhitespace).toBe false
+      expect(tokenizedBuffer.lineForScreenRow(2).tokens[14].firstTrailingWhitespaceIndex).toBe null
      expect(tokenizedBuffer.lineForScreenRow(2).tokens[15].hasTrailingWhitespace).toBe true
+      console.log tokenizedBuffer.lineForScreenRow(2).tokens[15]
+      expect(tokenizedBuffer.lineForScreenRow(2).tokens[15].firstTrailingWhitespaceIndex).toBe 6

      # Lines that are *only* whitespace are considered to have trailing whitespace
      buffer.insert([10, 0], '  ')
      expect(tokenizedBuffer.lineForScreenRow(10).tokens[0].hasTrailingWhitespace).toBe true
+      expect(tokenizedBuffer.lineForScreenRow(10).tokens[0].firstTrailingWhitespaceIndex).toBe 0

    it "only marks trailing whitespace on the last segment of a soft-wrapped line", ->
      buffer.insert([0, Infinity], '  ')
@@ -627,8 +684,20 @@ describe "TokenizedBuffer", ->
      [segment1, segment2] = tokenizedLine.softWrapAt(16)
      expect(segment1.tokens[5].value).toBe ' '
      expect(segment1.tokens[5].hasTrailingWhitespace).toBe false
+      expect(segment1.tokens[5].firstTrailingWhitespaceIndex).toBe null
      expect(segment2.tokens[6].value).toBe '  '
      expect(segment2.tokens[6].hasTrailingWhitespace).toBe true
+      expect(segment2.tokens[6].firstTrailingWhitespaceIndex).toBe 0
+
+    it "sets leading and trailing whitespace correctly on a line with invisible characters that is copied", ->
+      buffer.setText("  \t a line with tabs\tand \tspaces \t ")
+
+      tokenizedBuffer.setInvisibles(space: 'S', tab: 'T')
+      fullyTokenize(tokenizedBuffer)
+
+      line = tokenizedBuffer.lineForScreenRow(0).copy()
+      expect(line.tokens[0].hasLeadingWhitespace).toBe true
+      expect(line.tokens[line.tokens.length - 1].hasTrailingWhitespace).toBe true

  describe "indent level", ->
    beforeEach ->
@@ -113,6 +113,7 @@ describe "Window", ->
      expect(atom.state.project).toEqual projectState
      expect(atom.saveSync).toHaveBeenCalled()

+  describe ".removeEditorWindow()", ->
    it "unsubscribes from all buffers", ->
      waitsForPromise ->
        atom.workspace.open("sample.js")
@@ -123,7 +124,7 @@ describe "Window", ->
        pane.splitRight(pane.copyActiveItem())
        expect(atom.workspaceView.find('.editor').length).toBe 2

-        atom.unloadEditorWindow()
+        atom.removeEditorWindow()

        expect(buffer.getSubscriptionCount()).toBe 0

@@ -20,7 +20,6 @@ describe "WorkspaceView", ->
    waitsForPromise ->
      atom.workspace.open(pathToOpen)

-
  describe "@deserialize()", ->
    viewState = null

@@ -196,13 +195,12 @@ describe "WorkspaceView", ->
      atom.workspaceView.height(200)
      atom.workspaceView.attachToDom()
      rightEditorView = atom.workspaceView.getActiveView()
-      rightEditorView.getEditor().setText("\t  ")
+      rightEditorView.getEditor().setText("\t  \n")
      leftEditorView = rightEditorView.splitLeft()
      expect(rightEditorView.find(".line:first").text()).toBe "    "
      expect(leftEditorView.find(".line:first").text()).toBe "    "

-      {invisibles} = rightEditorView.component.state
-      {space, tab, eol} = invisibles
+      {space, tab, eol} = atom.config.get('editor.invisibles')
      withInvisiblesShowing = "#{tab} #{space}#{space}#{eol}"

      atom.workspaceView.trigger "window:toggle-invisibles"
@@ -294,3 +292,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
@@ -150,13 +150,13 @@ 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})
    @keymap = @keymaps # Deprecated
    @packages = new PackageManager({devMode, configDirPath, resourcePath, safeMode})
-    @themes = new ThemeManager({packageManager: @packages, configDirPath, resourcePath})
+    @themes = new ThemeManager({packageManager: @packages, configDirPath, resourcePath, safeMode})
    @contextMenu = new ContextMenuManager(devMode)
    @menu = new MenuManager({resourcePath})
    @clipboard = new Clipboard()
@@ -311,11 +311,6 @@ class Atom extends Model
    @requireUserInitScript()
    @menu.update()

-    $(window).on 'unload', =>
-      $(document.body).css('visibility', 'hidden')
-      @unloadEditorWindow()
-      false
-
    @displayWindow()

  unloadEditorWindow: ->
@@ -327,13 +322,18 @@ class Atom extends Model
    @packages.deactivatePackages()
    @state.packageStates = @packages.packageStates
    @saveSync()
-    @workspaceView.remove()
-    @workspaceView = null
-    @project.destroy()
-    @windowEventHandler?.unsubscribe()
-    @keymaps.destroy()
    @windowState = null

+  removeEditorWindow: ->
+    return if not @project and not @workspaceView
+
+    @workspaceView?.remove()
+    @workspaceView = null
+    @project?.destroy()
+    @project = null
+
+    @windowEventHandler?.unsubscribe()
+
  loadThemes: ->
    @themes.load()

@@ -438,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.
  #
@@ -451,6 +451,7 @@ class Atom extends Model
  center: ->
    ipc.send('call-window-method', 'center')

+
  # Schedule the window to be shown and focused on the next tick.
  #
  # This is done in a next tick to prevent a white flicker from occurring
@@ -470,6 +471,12 @@ class Atom extends Model
    app.emit('will-exit')
    remote.process.exit(status)

+  setDocumentEdited: (edited) ->
+    ipc.send('call-window-method', 'setDocumentEdited', edited)
+
+  setRepresentedFilename: (filename) ->
+    ipc.send('call-window-method', 'setRepresentedFilename', filename)
+
  # Public: Is the current window in development mode?
  inDevMode: ->
    @getLoadSettings().devMode
@@ -135,7 +135,7 @@ class AtomApplication

  # Registers basic application commands, non-idempotent.
  handleEvents: ->
-    @on 'application:run-all-specs', -> @runSpecs(exitWhenDone: false, resourcePath: global.devResourcePath)
+    @on 'application:run-all-specs', -> @runSpecs(exitWhenDone: false, resourcePath: global.devResourcePath, safeMode: @focusedWindow()?.safeMode)
    @on 'application:run-benchmarks', -> @runBenchmarks()
    @on 'application:quit', -> app.quit()
    @on 'application:new-window', -> @openPath(windowDimensions: @focusedWindow()?.getDimensions())
@@ -387,11 +387,13 @@ class AtomApplication
  # Opens up a new {AtomWindow} to run specs within.
  #
  # options -
-  #   :exitWhenDone - A Boolean that if true, will close the window upon
+  #   :exitWhenDone - A Boolean that, if true, will close the window upon
  #                   completion.
  #   :resourcePath - The path to include specs from.
  #   :specPath - The directory to load specs from.
-  runSpecs: ({exitWhenDone, resourcePath, specDirectory, logFile}) ->
+  #   :safeMode - A Boolean that, if true, won't run specs from ~/.atom/packages
+  #               and ~/.atom/dev/packages, defaults to false.
+  runSpecs: ({exitWhenDone, resourcePath, specDirectory, logFile, safeMode}) ->
    if resourcePath isnt @resourcePath and not fs.existsSync(resourcePath)
      resourcePath = @resourcePath

@@ -402,7 +404,8 @@ class AtomApplication

    isSpec = true
    devMode = true
-    new AtomWindow({bootstrapScript, resourcePath, exitWhenDone, isSpec, devMode, specDirectory, logFile})
+    safeMode ?= false
+    new AtomWindow({bootstrapScript, resourcePath, exitWhenDone, isSpec, devMode, specDirectory, logFile, safeMode})

  runBenchmarks: ->
    try
@@ -20,7 +20,7 @@ class AtomWindow
  isSpec: null

  constructor: (settings={}) ->
-    {@resourcePath, pathToOpen, initialLine, initialColumn, @isSpec, @exitWhenDone} = settings
+    {@resourcePath, pathToOpen, initialLine, initialColumn, @isSpec, @exitWhenDone, @safeMode} = settings

    # Normalize to make sure drive letter case is consistent on Windows
    @resourcePath = path.normalize(@resourcePath) if @resourcePath
@@ -40,8 +40,6 @@ class BufferedProcess
  #           containing the exit status (optional).
  constructor: ({command, args, options, stdout, stderr, exit}={}) ->
    options ?= {}
-    # Quick hack. Killing @process will only kill cmd.exe, and not the child
-    # process and will just orphan it. Does not escape ^ (cmd's escape symbol).
    # Related to joyent/node#2318
    if process.platform is "win32"
      # Quote all arguments and escapes inner quotes
@@ -55,7 +53,10 @@ class BufferedProcess
            "\"#{arg.replace(/"/g, '\\"')}\""
      else
        cmdArgs = []
-      cmdArgs.unshift("\"#{command}\"")
+      if /\s/.test(command)
+        cmdArgs.unshift("\"#{command}\"")
+      else
+        cmdArgs.unshift(command)
      cmdArgs = ['/s', '/c', "\"#{cmdArgs.join(' ')}\""]
      cmdOptions = _.clone(options)
      cmdOptions.windowsVerbatimArguments = true
@@ -114,8 +115,48 @@ class BufferedProcess
      onLines(buffered) if buffered.length > 0
      onDone()

+  # Kill all child processes of the spawned cmd.exe process on Windows.
+  #
+  # This is required since killing the cmd.exe does not terminate child
+  # processes.
+  killOnWindows: ->
+    parentPid = @process.pid
+    cmd = 'wmic'
+    args = [
+      'process'
+      'where'
+      "(ParentProcessId=#{parentPid})"
+      'get'
+      'processid'
+    ]
+
+    wmicProcess = ChildProcess.spawn(cmd, args)
+    wmicProcess.on 'error', -> # ignore errors
+    output = ''
+    wmicProcess.stdout.on 'data', (data) -> output += data
+    wmicProcess.stdout.on 'close', =>
+      pidsToKill = output.split(/\s+/)
+                    .filter (pid) -> /^\d+$/.test(pid)
+                    .map (pid) -> parseInt(pid)
+                    .filter (pid) -> pid isnt parentPid and 0 < pid < Infinity
+
+      for pid in pidsToKill
+        try
+          process.kill(pid)
+      @killProcess()
+
+  killProcess: ->
+    @process?.kill()
+    @process = null
+
  # Public: Terminate the process.
  kill: ->
+    return if @killed
+
    @killed = true
-    @process.kill()
-    @process = null
+    if process.platform is 'win32'
+      @killOnWindows()
+    else
+      @killProcess()
+
+    undefined
@@ -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
@@ -103,8 +103,19 @@ class Config
  # Returns the value from Atom's default settings, the user's configuration
  # file, or `null` if the key doesn't exist in either.
  get: (keyPath) ->
-    value = _.valueForKeyPath(@settings, keyPath) ? _.valueForKeyPath(@defaultSettings, keyPath)
-    _.deepClone(value)
+    value = _.valueForKeyPath(@settings, keyPath)
+    defaultValue = _.valueForKeyPath(@defaultSettings, keyPath)
+
+    if value?
+      value = _.deepClone(value)
+      valueIsObject = _.isObject(value) and not _.isArray(value)
+      defaultValueIsObject = _.isObject(defaultValue) and not _.isArray(defaultValue)
+      if valueIsObject and defaultValueIsObject
+        _.defaults(value, defaultValue)
+    else
+      value = _.deepClone(defaultValue)
+
+    value

  # Public: Retrieves the setting for the given key as an integer.
  #
@@ -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')
@@ -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: ->
@@ -273,9 +273,10 @@ class Cursor extends Model
  # line.
  moveToFirstCharacterOfLine: ->
    {row, column} = @getScreenPosition()
-    screenline = @editor.lineForScreenRow(row)

-    goalColumn = screenline.text.search(/\S/)
+    bufferRange = @editor.bufferRangeForScreenRange([[row, 0], [row, Infinity]])
+    screenLineText = @editor.getTextInBufferRange(bufferRange)
+    goalColumn = screenLineText.search(/\S/)
    goalColumn = 0 if goalColumn == column or goalColumn == -1
    @setScreenPosition([row, goalColumn])

@@ -12,7 +12,7 @@ CursorsComponent = React.createClass
  cursorBlinkIntervalHandle: null

  render: ->
-    {performedInitialMeasurement, cursorPixelRects, scrollTop, scrollLeft, defaultCharWidth, useHardwareAcceleration} = @props
+    {performedInitialMeasurement, cursorPixelRects, defaultCharWidth} = @props
    {blinkOff} = @state

    className = 'cursors'
@@ -21,7 +21,7 @@ CursorsComponent = React.createClass
    div {className},
      if performedInitialMeasurement
        for key, pixelRect of cursorPixelRects
-          CursorComponent({key, pixelRect, scrollTop, scrollLeft, defaultCharWidth, useHardwareAcceleration})
+          CursorComponent({key, pixelRect, defaultCharWidth})

  getInitialState: ->
    blinkOff: false
@@ -38,10 +38,10 @@ class DisplayBuffer extends Model
  verticalScrollbarWidth: 15
  scopedCharacterWidthsChangeCount: 0

-  constructor: ({tabLength, @editorWidthInChars, @tokenizedBuffer, buffer}={}) ->
+  constructor: ({tabLength, @editorWidthInChars, @tokenizedBuffer, buffer, @invisibles}={}) ->
    super
    @softWrap ?= atom.config.get('editor.softWrap') ? false
-    @tokenizedBuffer ?= new TokenizedBuffer({tabLength, buffer})
+    @tokenizedBuffer ?= new TokenizedBuffer({tabLength, buffer, @invisibles})
    @buffer = @tokenizedBuffer.buffer
    @charWidthsByScope = {}
    @markers = {}
@@ -81,7 +81,7 @@ class DisplayBuffer extends Model
    params

  copy: ->
-    newDisplayBuffer = new DisplayBuffer({@buffer, tabLength: @getTabLength()})
+    newDisplayBuffer = new DisplayBuffer({@buffer, tabLength: @getTabLength(), @invisibles})
    newDisplayBuffer.setScrollTop(@getScrollTop())
    newDisplayBuffer.setScrollLeft(@getScrollLeft())

@@ -340,6 +340,9 @@ class DisplayBuffer extends Model
  setTabLength: (tabLength) ->
    @tokenizedBuffer.setTabLength(tabLength)

+  setInvisibles: (@invisibles) ->
+    @tokenizedBuffer.setInvisibles(@invisibles)
+
  # Deprecated: Use the softWrap property directly
  setSoftWrap: (@softWrap) -> @softWrap

@@ -3,17 +3,15 @@ React = require 'react-atom-fork'
 {debounce, defaults, isEqualForProperties} = require 'underscore-plus'
 scrollbarStyle = require 'scrollbar-style'
 {Range, Point} = require 'text-buffer'
+grim = require 'grim'

 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'}]}
-
 module.exports =
 EditorComponent = React.createClass
  displayName: 'EditorComponent'
@@ -43,7 +41,7 @@ EditorComponent = React.createClass
  scrollSensitivity: 0.4
  heightAndWidthMeasurementRequested: false
  measureLineHeightAndDefaultCharWidthWhenShown: false
-  remeasureCharacterWidthsIfVisibleAfterNextUpdate: false
+  remeasureCharacterWidthsWhenShown: false
  inputEnabled: true
  scopedCharacterWidthsChangeCount: null
  domPollingInterval: 100
@@ -51,13 +49,11 @@ EditorComponent = React.createClass
  domPollingPaused: false

  render: ->
-    {focused, fontSize, lineHeight, fontFamily, showIndentGuide, showInvisibles, showLineNumbers, visible} = @state
+    {focused, showIndentGuide, showLineNumbers, visible} = @state
    {editor, mini, cursorBlinkPeriod, cursorBlinkResumeDelay} = @props
    maxLineNumberDigits = editor.getLineCount().toString().length
-    invisibles = if showInvisibles and not mini then @state.invisibles else {}
    hasSelection = editor.getSelection()? and !editor.getSelection().isEmpty()
-    style = {fontSize, fontFamily}
-    style.lineHeight = lineHeight unless mini
+    style = {}

    if @performedInitialMeasurement
      renderedRowRange = @getRenderedRowRange()
@@ -109,18 +105,14 @@ EditorComponent = React.createClass
          onFocus: @onInputFocused
          onBlur: @onInputBlurred

-        CursorsComponent {
-          scrollTop, scrollLeft, cursorPixelRects, cursorBlinkPeriod, cursorBlinkResumeDelay,
-          lineHeightInPixels, defaultCharWidth, @scopedCharacterWidthsChangeCount, @useHardwareAcceleration,
-          @performedInitialMeasurement
-        }
        LinesComponent {
          ref: 'lines',
          editor, lineHeightInPixels, defaultCharWidth, lineDecorations, highlightDecorations,
          showIndentGuide, renderedRowRange, @pendingChanges, scrollTop, scrollLeft,
-          @scrollingVertically, scrollHeight, scrollWidth, mouseWheelScreenRow, invisibles,
+          @scrollingVertically, scrollHeight, scrollWidth, mouseWheelScreenRow,
          @visible, scrollViewHeight, @scopedCharacterWidthsChangeCount, lineWidth, @useHardwareAcceleration,
-          placeholderText, @performedInitialMeasurement, @backgroundColor
+          placeholderText, @performedInitialMeasurement, @backgroundColor, cursorPixelRects,
+          cursorBlinkPeriod, cursorBlinkResumeDelay, mini
        }

        ScrollbarComponent
@@ -167,7 +159,7 @@ EditorComponent = React.createClass
  getDefaultProps: ->
    cursorBlinkPeriod: 800
    cursorBlinkResumeDelay: 100
-    lineOverdrawMargin: 8
+    lineOverdrawMargin: 15

  componentWillMount: ->
    @pendingChanges = []
@@ -184,7 +176,7 @@ EditorComponent = React.createClass
    @listenForDOMEvents()
    @listenForCommands()

-    @subscribe atom.themes, 'stylesheet-added stylsheet-removed', @onStylesheetsChanged
+    @subscribe atom.themes, 'stylesheet-added stylesheet-removed stylesheet-updated', @onStylesheetsChanged
    @subscribe scrollbarStyle.changes, @refreshScrollbars

    if @visible = @isVisible()
@@ -194,8 +186,13 @@ EditorComponent = React.createClass
  componentWillUnmount: ->
    @props.parentView.trigger 'editor:will-be-removed', [@props.parentView]
    @unsubscribe()
+    window.removeEventListener 'resize', @requestHeightAndWidthMeasurement
    clearInterval(@domPollingIntervalId)
    @domPollingIntervalId = null
+    @props.editor.destroy()
+
+  componentWillReceiveProps: (newProps) ->
+    @props.editor.setMini(newProps.mini)

  componentWillUpdate: ->
    wasVisible = @visible
@@ -219,20 +216,22 @@ EditorComponent = React.createClass

    if @performedInitialMeasurement
      @measureScrollbars() if @measuringScrollbars
-      @measureLineHeightAndDefaultCharWidthIfNeeded(prevState)
-      @remeasureCharacterWidthsIfNeeded(prevState)

  performInitialMeasurement: ->
    @updatesPaused = true
-    @measureLineHeightAndDefaultCharWidth()
    @measureHeightAndWidth()
+    @sampleFontStyling()
    @sampleBackgroundColors()
    @measureScrollbars()
+    @measureLineHeightAndDefaultCharWidth() if @measureLineHeightAndDefaultCharWidthWhenShown
+    @remeasureCharacterWidths() if @remeasureCharacterWidthsWhenShown
    @props.editor.setVisible(true)
    @updatesPaused = false
    @performedInitialMeasurement = true

  requestUpdate: ->
+    return unless @isMounted()
+
    if @updatesPaused
      @updateRequestedWhilePaused = true
      return
@@ -241,7 +240,7 @@ EditorComponent = React.createClass
      @forceUpdate()
    else unless @updateRequested
      @updateRequested = true
-      setImmediate =>
+      requestAnimationFrame =>
        @updateRequested = false
        @forceUpdate() if @isMounted()

@@ -255,6 +254,9 @@ EditorComponent = React.createClass
        @updateRequestedWhilePaused = false
        @forceUpdate()

+  getTopmostDOMNode: ->
+    @props.parentView.element
+
  getRenderedRowRange: ->
    {editor, lineOverdrawMargin} = @props
    [visibleStartRow, visibleEndRow] = editor.getVisibleRowRange()
@@ -346,11 +348,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: ->
@@ -503,7 +500,7 @@ EditorComponent = React.createClass
        'editor:fold-at-indent-level-9': => editor.foldAllAtIndentLevel(8)
        'editor:toggle-line-comments': => editor.toggleLineCommentsInSelection()
        'editor:log-cursor-scope': => editor.logCursorScope()
-        'editor:checkout-head-revision': => editor.checkoutHead()
+        'editor:checkout-head-revision': => atom.project.getRepo()?.checkoutHeadForEditor(editor)
        'editor:copy-path': => editor.copyPathToClipboard()
        'editor:move-line-up': => editor.moveLineUp()
        'editor:move-line-down': => editor.moveLineDown()
@@ -517,24 +514,31 @@ EditorComponent = React.createClass
  addCommandListeners: (listenersByCommandName) ->
    {parentView} = @props

-    for command, listener of listenersByCommandName
-      parentView.command command, listener
+    addListener = (command, listener) ->
+      parentView.command command, (event) ->
+        event.stopPropagation()
+        listener(event)
+
+    addListener(command, listener) for command, listener of listenersByCommandName
+
+    return

  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
    @subscribe atom.config.observe 'editor.showLineNumbers', @setShowLineNumbers
    @subscribe atom.config.observe 'editor.scrollSensitivity', @setScrollSensitivity
    @subscribe atom.config.observe 'editor.useHardwareAcceleration', @setUseHardwareAcceleration

  onFocus: ->
-    @refs.input.focus()
+    @refs.input.focus() if @isMounted()

  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()

    {editor} = @props
@@ -547,12 +551,8 @@ EditorComponent = React.createClass
    selectedLength = inputNode.selectionEnd - inputNode.selectionStart
    editor.selectLeft() if selectedLength is 1

-    editor.insertText(event.data)
-    inputNode.value = event.data
+    inputNode.value = event.data if editor.insertText(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)
@@ -678,10 +678,12 @@ EditorComponent = React.createClass
        editor.setSelectedScreenRange([tailPosition, [dragRow + 1, 0]])

  onStylesheetsChanged: (stylesheet) ->
+    return unless @performedInitialMeasurement
+
    @refreshScrollbars() if @containsScrollbarSelector(stylesheet)
+    @sampleFontStyling()
    @sampleBackgroundColors()
-    @remeasureCharacterWidthsIfVisibleAfterNextUpdate = true
-    @requestUpdate() if @visible
+    @remeasureCharacterWidths()

  onScreenLinesChanged: (change) ->
    {editor} = @props
@@ -773,12 +775,13 @@ EditorComponent = React.createClass
  resumeDOMPollingAfterDelay: null # created lazily

  pollDOM: ->
-    return if @domPollingPaused or not @isMounted()
+    return if @domPollingPaused or @updateRequested or not @isMounted()

    wasVisible = @visible
    if @visible = @isVisible()
      if wasVisible
        @measureHeightAndWidth()
+        @sampleFontStyling()
        @sampleBackgroundColors()
      else
        @performInitialMeasurement()
@@ -821,6 +824,19 @@ EditorComponent = React.createClass
    clientWidth -= paddingLeft
    editor.setWidth(clientWidth) if clientWidth > 0

+  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()
+
+    if (@fontSize isnt oldFontSize or @fontFamily isnt oldFontFamily) and @performedInitialMeasurement
+      @remeasureCharacterWidths()
+
  sampleBackgroundColors: (suppressUpdate) ->
    {parentView} = @props
    {showLineNumbers} = @state
@@ -836,31 +852,19 @@ EditorComponent = React.createClass
        @gutterBackgroundColor = gutterBackgroundColor
        @requestUpdate() unless suppressUpdate

-  measureLineHeightAndDefaultCharWidthIfNeeded: (prevState) ->
-    if not isEqualForProperties(prevState, @state, 'lineHeight', 'fontSize', 'fontFamily')
-      if @visible
-        @measureLineHeightAndDefaultCharWidth()
-      else
-        @measureLineHeightAndDefaultCharWidthWhenShown = true
-    else if @measureLineHeightAndDefaultCharWidthWhenShown and @visible
-      @measureLineHeightAndDefaultCharWidthWhenShown = false
-      @measureLineHeightAndDefaultCharWidth()
-
  measureLineHeightAndDefaultCharWidth: ->
-    @refs.lines.measureLineHeightAndDefaultCharWidth()
-
-  remeasureCharacterWidthsIfNeeded: (prevState) ->
-    if not isEqualForProperties(prevState, @state, 'fontSize', 'fontFamily')
-      if @visible
-        @remeasureCharacterWidths()
-      else
-        @remeasureCharacterWidthsIfVisibleAfterNextUpdate = true
-    else if @remeasureCharacterWidthsIfVisibleAfterNextUpdate and @visible
-      @remeasureCharacterWidthsIfVisibleAfterNextUpdate = false
-      @remeasureCharacterWidths()
+    if @visible
+      @measureLineHeightAndDefaultCharWidthWhenShown = false
+      @refs.lines.measureLineHeightAndDefaultCharWidth()
+    else
+      @measureLineHeightAndDefaultCharWidthWhenShown = true

  remeasureCharacterWidths: ->
-    @refs.lines.remeasureCharacterWidths()
+    if @visible
+      @remeasureCharacterWidthsWhenShown = false
+      @refs.lines.remeasureCharacterWidths()
+    else
+      @remeasureCharacterWidthsWhenShown = true

  measureScrollbars: ->
    return unless @visible
@@ -921,41 +925,34 @@ EditorComponent = React.createClass
    null

  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})

-  # Public: Defines which characters are invisible.
-  #
-  # invisibles - An {Object} defining the invisible characters:
-  #   :eol   - The end of line invisible {String} (default: `\u00ac`).
-  #   :space - The space invisible {String} (default: `\u00b7`).
-  #   :tab   - The tab invisible {String} (default: `\u00bb`).
-  #   :cr    - The carriage return invisible {String} (default: `\u00a4`).
+  # Deprecated
  setInvisibles: (invisibles={}) ->
-    defaults invisibles,
-      eol: '\u00ac'
-      space: '\u00b7'
-      tab: '\u00bb'
-      cr: '\u00a4'
-
-    @setState({invisibles})
+    grim.deprecate "Use config.set('editor.invisibles', invisibles) instead"
+    atom.config.set('editor.invisibles', invisibles)

+  # Deprecated
  setShowInvisibles: (showInvisibles) ->
-    @setState({showInvisibles})
+    atom.config.set('editor.showInvisibles', showInvisibles)

  setShowLineNumbers: (showLineNumbers) ->
    @setState({showLineNumbers})
@@ -58,6 +58,12 @@ class EditorView extends View
    softWrapAtPreferredLineLength: false
    scrollSensitivity: 40
    useHardwareAcceleration: true
+    confirmCheckoutHeadRevision: true
+    invisibles:
+      eol: '\u00ac'
+      space: '\u00b7'
+      tab: '\u00bb'
+      cr: '\u00a4'

  @nextEditorId: 1

@@ -231,7 +237,7 @@ class EditorView extends View
        'editor:fold-at-indent-level-9': => @editor.foldAllAtIndentLevel(8)
        'editor:toggle-line-comments': => @toggleLineCommentsInSelection()
        'editor:log-cursor-scope': => @logCursorScope()
-        'editor:checkout-head-revision': => @checkoutHead()
+        'editor:checkout-head-revision': => atom.project.getRepo()?.checkoutHeadForEditor(@editor)
        'editor:copy-path': => @copyPathToClipboard()
        'editor:move-line-up': => @editor.moveLineUp()
        'editor:move-line-down': => @editor.moveLineDown()
@@ -338,11 +344,6 @@ class EditorView extends View
  getPlaceholderText: ->
    @placeholderText

-  # Checkout the HEAD revision of this editor's file.
-  checkoutHead: ->
-    if path = @editor.getPath()
-      atom.project.getRepo()?.checkoutHead(path)
-
  configure: ->
    @subscribe atom.config.observe 'editor.showLineNumbers', (showLineNumbers) => @gutter.setShowLineNumbers(showLineNumbers)
    @subscribe atom.config.observe 'editor.showInvisibles', (showInvisibles) => @setShowInvisibles(showInvisibles)
@@ -641,9 +642,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)

@@ -159,13 +159,16 @@ class Editor extends Model
  @delegatesProperties '$lineHeightInPixels', '$defaultCharWidth', '$height', '$width',
    '$scrollTop', '$scrollLeft', 'manageScrollPosition', toProperty: 'displayBuffer'

-  constructor: ({@softTabs, initialLine, initialColumn, tabLength, softWrap, @displayBuffer, buffer, registerEditor, suppressCursorCreation}) ->
+  constructor: ({@softTabs, initialLine, initialColumn, tabLength, softWrap, @displayBuffer, buffer, registerEditor, suppressCursorCreation, @mini}) ->
    super

    @cursors = []
    @selections = []

-    @displayBuffer ?= new DisplayBuffer({buffer, tabLength, softWrap})
+    if @shouldShowInvisibles()
+      invisibles = atom.config.get('editor.invisibles')
+
+    @displayBuffer ?= new DisplayBuffer({buffer, tabLength, softWrap, invisibles})
    @buffer = @displayBuffer.buffer
    @softTabs = @usesSoftTabs() ? @softTabs ? atom.config.get('editor.softTabs') ? true

@@ -186,6 +189,9 @@ class Editor extends Model
    @subscribe @$scrollTop, (scrollTop) => @emit 'scroll-top-changed', scrollTop
    @subscribe @$scrollLeft, (scrollLeft) => @emit 'scroll-left-changed', scrollLeft

+    @subscribe atom.config.observe 'editor.showInvisibles', callNow: false, (show) => @updateInvisibles()
+    @subscribe atom.config.observe 'editor.invisibles', callNow: false, => @updateInvisibles()
+
    atom.workspace?.editorAdded(this) if registerEditor

  serializeParams: ->
@@ -281,6 +287,11 @@ class Editor extends Model
  # Controls visibility based on the given {Boolean}.
  setVisible: (visible) -> @displayBuffer.setVisible(visible)

+  setMini: (mini) ->
+    if mini isnt @mini
+      @mini = mini
+      @updateInvisibles()
+
  # Set the number of characters that can be displayed horizontally in the
  # editor.
  #
@@ -435,10 +446,6 @@ class Editor extends Model
  # filePath - A {String} path.
  saveAs: (filePath) -> @buffer.saveAs(filePath)

-  checkoutHead: ->
-    if filePath = @getPath()
-      atom.project.getRepo()?.checkoutHead(filePath)
-
  # Copies the current file path to the native clipboard.
  copyPathToClipboard: ->
    if filePath = @getPath()
@@ -629,12 +636,29 @@ class Editor extends Model

  # Public: For each selection, replace the selected text with the given text.
  #
+  # Emits: `will-insert-text -> ({text, cancel})` before the text has
+  # been inserted. Calling `cancel` will prevent the text from being
+  # inserted.
+  # Emits: `did-insert-text -> ({text})` after the text has been inserted.
+  #
  # text - A {String} representing the text to insert.
  # options - See {Selection::insertText}.
+  #
+  # Returns a {Bool} indicating whether or not the text was inserted.
  insertText: (text, options={}) ->
-    options.autoIndentNewline ?= @shouldAutoIndent()
-    options.autoDecreaseIndent ?= @shouldAutoIndent()
-    @mutateSelectedText (selection) -> selection.insertText(text, options)
+    willInsert = true
+    cancel = -> willInsert = false
+    @emit('will-insert-text', {cancel, text})
+
+    if willInsert
+      options.autoIndentNewline ?= @shouldAutoIndent()
+      options.autoDecreaseIndent ?= @shouldAutoIndent()
+      @mutateSelectedText (selection) =>
+        range = selection.insertText(text, options)
+        @emit('did-insert-text', {text, range})
+        range
+    else
+      false

  # Public: For each selection, replace the selected text with a newline.
  insertNewline: ->
@@ -1588,8 +1612,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()
@@ -1928,6 +1958,15 @@ class Editor extends Model
  shouldAutoIndent: ->
    atom.config.get("editor.autoIndent")

+  shouldShowInvisibles: ->
+    not @mini and atom.config.get('editor.showInvisibles')
+
+  updateInvisibles: ->
+    if @shouldShowInvisibles()
+      @displayBuffer.setInvisibles(atom.config.get('editor.invisibles'))
+    else
+      @displayBuffer.setInvisibles(null)
+
  # Public: Batch multiple operations as a single undo/redo step.
  #
  # Any group of operations that are logically grouped from the perspective of
@@ -2017,7 +2056,7 @@ class Editor extends Model
  setScrollRight: (scrollRight) -> @displayBuffer.setScrollRight(scrollRight)

  getScrollHeight: -> @displayBuffer.getScrollHeight()
-  getScrollWidth: (scrollWidth) -> @displayBuffer.getScrollWidth(scrollWidth)
+  getScrollWidth: -> @displayBuffer.getScrollWidth()

  getVisibleRowRange: -> @displayBuffer.getVisibleRowRange()

@@ -1,4 +1,4 @@
-{join} = require 'path'
+{basename, join} = require 'path'

 _ = require 'underscore-plus'
 {Emitter, Subscriber} = require 'emissary'
@@ -93,6 +93,27 @@ class Git
        @getPathStatus(path)
    @subscribe buffer, 'destroyed', => @unsubscribe(buffer)

+  # Subscribes to editor view event.
+  checkoutHeadForEditor: (editor) ->
+    filePath = editor.getPath()
+    return unless filePath
+
+    fileName = basename(filePath)
+
+    checkoutHead = =>
+      editor.buffer.reload() if editor.buffer.isModified()
+      @checkoutHead(filePath)
+
+    if atom.config.get('editor.confirmCheckoutHeadRevision')
+      atom.confirm
+        message: 'Confirm Checkout HEAD Revision'
+        detailedMessage: "Are you sure you want to discard all changes to \"#{fileName}\" since the last Git commit?"
+        buttons:
+          OK: checkoutHead
+          Cancel: null
+    else
+      checkoutHead()
+
  # Public: Destroy this `Git` object. This destroys any tasks and subscriptions
  # and releases the underlying libgit2 repository handle.
  destroy: ->
@@ -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)

@@ -5,6 +5,7 @@ React = require 'react-atom-fork'
 {$$} = require 'space-pen'

 Decoration = require './decoration'
+CursorsComponent = require './cursors-component'
 HighlightsComponent = require './highlights-component'

 DummyLineNode = $$(-> @div className: 'line', style: 'position: absolute; visibility: hidden;', => @span 'x')[0]
@@ -16,20 +17,30 @@ LinesComponent = React.createClass
  displayName: 'LinesComponent'

  render: ->
-    {performedInitialMeasurement} = @props
+    {performedInitialMeasurement, cursorBlinkPeriod, cursorBlinkResumeDelay} = @props

    if performedInitialMeasurement
      {editor, highlightDecorations, scrollHeight, scrollWidth, placeholderText, backgroundColor} = @props
      {lineHeightInPixels, defaultCharWidth, scrollViewHeight, scopedCharacterWidthsChangeCount} = @props
+      {scrollTop, scrollLeft, cursorPixelRects, mini} = @props
      style =
        height: Math.max(scrollHeight, scrollViewHeight)
        width: scrollWidth
        WebkitTransform: @getTransform()
-        backgroundColor: backgroundColor
+        backgroundColor: if mini then null else backgroundColor

    div {className: 'lines', style},
      div className: 'placeholder-text', placeholderText if placeholderText?
-      HighlightsComponent({editor, highlightDecorations, lineHeightInPixels, defaultCharWidth, scopedCharacterWidthsChangeCount, performedInitialMeasurement})
+
+      CursorsComponent {
+        cursorPixelRects, cursorBlinkPeriod, cursorBlinkResumeDelay, lineHeightInPixels,
+        defaultCharWidth, scopedCharacterWidthsChangeCount, performedInitialMeasurement
+      }
+
+      HighlightsComponent {
+        editor, highlightDecorations, lineHeightInPixels, defaultCharWidth,
+        scopedCharacterWidthsChangeCount, performedInitialMeasurement
+      }

  getTransform: ->
    {scrollTop, scrollLeft, useHardwareAcceleration} = @props
@@ -49,9 +60,9 @@ LinesComponent = React.createClass
  shouldComponentUpdate: (newProps) ->
    return true unless isEqualForProperties(newProps, @props,
      'renderedRowRange', 'lineDecorations', 'highlightDecorations', 'lineHeightInPixels', 'defaultCharWidth',
-      'scrollTop', 'scrollLeft', 'showIndentGuide', 'scrollingVertically', 'invisibles', 'visible',
+      'scrollTop', 'scrollLeft', 'showIndentGuide', 'scrollingVertically', 'visible',
      'scrollViewHeight', 'mouseWheelScreenRow', 'scopedCharacterWidthsChangeCount', 'lineWidth', 'useHardwareAcceleration',
-      'placeholderText', 'performedInitialMeasurement', 'backgroundColor'
+      'placeholderText', 'performedInitialMeasurement', 'backgroundColor', 'cursorPixelRects'
    )

    {renderedRowRange, pendingChanges} = newProps
@@ -71,7 +82,7 @@ LinesComponent = React.createClass
    return unless performedInitialMeasurement

    @clearScreenRowCaches() unless prevProps.lineHeightInPixels is @props.lineHeightInPixels
-    @removeLineNodes() unless isEqualForProperties(prevProps, @props, 'showIndentGuide', 'invisibles')
+    @removeLineNodes() unless isEqualForProperties(prevProps, @props, 'showIndentGuide')
    @updateLines(@props.lineWidth isnt prevProps.lineWidth)
    @measureCharactersInNewLines() if visible and not scrollingVertically

@@ -159,34 +170,30 @@ LinesComponent = React.createClass
    lineHTML

  buildEmptyLineInnerHTML: (line) ->
-    {showIndentGuide, invisibles} = @props
-    {cr, eol} = invisibles
-    {indentLevel, tabLength} = line
+    {showIndentGuide} = @props
+    {indentLevel, tabLength, endOfLineInvisibles} = line

    if showIndentGuide and indentLevel > 0
-      invisiblesToRender = []
-      invisiblesToRender.push(cr) if cr? and line.lineEnding is '\r\n'
-      invisiblesToRender.push(eol) if eol?
-
+      invisibleIndex = 0
      lineHTML = ''
      for i in [0...indentLevel]
        lineHTML += "<span class='indent-guide'>"
        for j in [0...tabLength]
-          if invisible = invisiblesToRender.shift()
+          if invisible = endOfLineInvisibles?[invisibleIndex++]
            lineHTML += "<span class='invisible-character'>#{invisible}</span>"
          else
            lineHTML += ' '
        lineHTML += "</span>"

-      while invisiblesToRender.length
-        lineHTML += "<span class='invisible-character'>#{invisiblesToRender.shift()}</span>"
+      while invisibleIndex < endOfLineInvisibles?.length
+        lineHTML += "<span class='invisible-character'>#{line.endOfLineInvisibles[invisibleIndex++]}</span>"

      lineHTML
    else
-      @buildEndOfLineHTML(line, @props.invisibles) or '&nbsp;'
+      @buildEndOfLineHTML(line) or '&nbsp;'

  buildLineInnerHTML: (line) ->
-    {invisibles, mini, showIndentGuide, invisibles} = @props
+    {mini, showIndentGuide} = @props
    {tokens, text} = line
    innerHTML = ""

@@ -196,23 +203,19 @@ LinesComponent = React.createClass
    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 += token.getValueAsHtml({hasIndentGuide})

    innerHTML += @popScope(scopeStack) while scopeStack.length > 0
-    innerHTML += @buildEndOfLineHTML(line, invisibles)
+    innerHTML += @buildEndOfLineHTML(line)
    innerHTML

-  buildEndOfLineHTML: (line, invisibles) ->
-    return '' if @props.mini or line.isSoftWrapped()
+  buildEndOfLineHTML: (line) ->
+    {endOfLineInvisibles} = line

    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>"
-
+    if endOfLineInvisibles?
+      for invisible in endOfLineInvisibles
+        html += "<span class='invisible-character'>#{invisible}</span>"
    html

  updateScopeStack: (scopeStack, desiredScopes) ->
@@ -15,6 +15,7 @@ class MenuManager
    @pendingUpdateOperation = null
    @template = []
    atom.keymaps.on 'bundled-keymaps-loaded', => @loadPlatformItems()
+    atom.packages.on 'activated', => @sortPackagesMenu()

  # Public: Adds the given item definition to the existing template.
  #
@@ -130,3 +131,14 @@ class MenuManager
  # Get an {Array} of {String} classes for the given element.
  classesForElement: (element) ->
    element?.classList.toString().split(' ') ? []
+
+  sortPackagesMenu: ->
+    packagesMenu = @template.find ({label}) => @normalizeLabel(label) is 'Packages'
+    return unless packagesMenu?.submenu?
+
+    packagesMenu.submenu.sort (item1, item2) =>
+      if item1.label and item2.label
+        @normalizeLabel(item1.label).localeCompare(@normalizeLabel(item2.label))
+      else
+        0
+    @update()
@@ -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
@@ -141,13 +141,17 @@ class PaneView extends View
    @activeItem

  onActiveItemChanged: (item) =>
-    @previousActiveItem?.off? 'title-changed', @activeItemTitleChanged
+    if @previousActiveItem?.off?
+      @previousActiveItem.off 'title-changed', @activeItemTitleChanged
+      @previousActiveItem.off 'modified-status-changed', @activeItemModifiedChanged
    @previousActiveItem = item

    return unless item?

    hasFocus = @hasFocus()
-    item.on? 'title-changed', @activeItemTitleChanged
+    if item.on?
+      item.on 'title-changed', @activeItemTitleChanged
+      item.on 'modified-status-changed', @activeItemModifiedChanged
    view = @viewForItem(item)
    otherView.hide() for otherView in @itemViews.children().not(view).views()
    @itemViews.append(view) unless view.parent().is(@itemViews)
@@ -183,6 +187,9 @@ class PaneView extends View
  activeItemTitleChanged: =>
    @trigger 'pane:active-item-title-changed'

+  activeItemModifiedChanged: =>
+    @trigger 'pane:active-item-modified-status-changed'
+
  viewForItem: (item) ->
    return unless item?
    if item instanceof $
@@ -10,6 +10,7 @@ class ReactEditorView extends View
  @content: (params) ->
    attributes = params.attributes ? {}
    attributes.class = 'editor react editor-colors'
+    attributes.tabIndex = -1
    @div attributes

  focusOnAttach: false
@@ -29,6 +30,7 @@ class ReactEditorView extends View
        softWrap: false
        tabLength: 2
        softTabs: true
+        mini: mini

    props = defaults({@editor, parentView: this}, props)
    @component = React.renderComponent(EditorComponent(props), @element)
@@ -55,6 +57,11 @@ class ReactEditorView extends View
        lines.addClass(klass)
        lines.length > 0

+    @on 'focus', =>
+      if @component?
+        @component.onFocus()
+      else
+        @focusOnAttach = true

  getEditor: -> @editor

@@ -66,6 +73,7 @@ class ReactEditorView extends View
  Object.defineProperty @::, 'lastRenderedScreenRow', get: -> @component.getRenderedRowRange()[1]
  Object.defineProperty @::, 'active', get: -> @is(@getPane()?.activeView)
  Object.defineProperty @::, 'isFocused', get: -> @component?.state.focused
+  Object.defineProperty @::, 'mini', get: -> @component?.props.mini

  afterAttach: (onDom) ->
    return unless onDom
@@ -115,8 +123,9 @@ class ReactEditorView extends View
    @find('.lines').prepend(view)

  beforeRemove: ->
-    React.unmountComponentAtNode(@element)
+    return unless @attached
    @attached = false
+    React.unmountComponentAtNode(@element) if @component.isMounted()
    @trigger 'editor:detached', this

  # Public: Split the editor view left.
@@ -142,12 +151,6 @@ class ReactEditorView extends View
  getPane: ->
    @parent('.item-views').parents('.pane').view()

-  focus: ->
-    if @component?
-      @component.onFocus()
-    else
-      @focusOnAttach = true
-
  hide: ->
    super
    @pollComponentDOM()
@@ -169,9 +172,6 @@ class ReactEditorView extends View
  pageUp: ->
    @editor.pageUp()

-  getModel: ->
-    @component?.getModel()
-
  getFirstVisibleScreenRow: ->
    @editor.getVisibleRowRange()[0]

@@ -16,7 +16,7 @@ module.exports =
 class ThemeManager
  Emitter.includeInto(this)

-  constructor: ({@packageManager, @resourcePath, @configDirPath}) ->
+  constructor: ({@packageManager, @resourcePath, @configDirPath, @safeMode}) ->
    @lessCache = null
    @packageManager.registerPackageActivator(this, ['theme'])

@@ -51,6 +51,28 @@ class ThemeManager
    themeNames = themeNames.filter (themeName) ->
      themeName and typeof themeName is 'string'

+    # Use a built-in syntax and UI theme when in safe mode since themes
+    # installed to ~/.atom/packages will not be loaded.
+    if @safeMode
+      builtInThemeNames = [
+        'atom-dark-syntax'
+        'atom-dark-ui'
+        'atom-light-syntax'
+        'atom-light-ui'
+        'base16-tomorrow-dark-theme'
+        'base16-tomorrow-light-theme'
+        'solarized-dark-syntax'
+        'solarized-light-syntax'
+      ]
+      themeNames = _.intersection(themeNames, builtInThemeNames)
+      if themeNames.length is 0
+        themeNames = ['atom-dark-syntax', 'atom-dark-ui']
+      else if themeNames.length is 1
+        if _.endsWith(themeNames[0], '-ui')
+          themeNames.unshift('atom-dark-syntax')
+        else
+          themeNames.push('atom-dark-ui')
+
    # Reverse so the first (top) theme is loaded after the others. We want
    # the first/top theme to override later themes in the stack.
    themeNames.reverse()
@@ -2,11 +2,7 @@ _ = require 'underscore-plus'
 textUtils = require './text-utils'

 WhitespaceRegexesByTabLength = {}
-LeadingSpaceRegex = /^[ ]+/
-TrailingSpaceRegex = /[ ]+$/
 EscapeRegex = /[&"'<>]/g
-CharacterRegex = /./g
-StartCharacterRegex = /^./
 StartDotRegex = /^\.?/
 WhitespaceRegex = /\S/

@@ -22,6 +18,9 @@ class Token
  isHardTab: null
  hasLeadingWhitespace: false
  hasTrailingWhitespace: false
+  firstNonWhitespaceIndex: null
+  firstTrailingWhitespaceIndex: null
+  hasInvisibleCharacters: false

  constructor: ({@value, @scopes, @isAtomic, @bufferDelta, @isHardTab}) ->
    @screenDelta = @value.length
@@ -136,14 +135,12 @@ class Token
      scopeClasses = scope.split('.')
      _.isSubset(targetClasses, scopeClasses)

-  getValueAsHtml: ({invisibles, hasIndentGuide})->
-    invisibles ?= {}
+  getValueAsHtml: ({hasIndentGuide})->
    if @isHardTab
      classes = 'hard-tab'
      classes += ' indent-guide' if hasIndentGuide
-      classes += ' invisible-character' if invisibles.tab
-      value = if invisibles.tab then @value.replace(StartCharacterRegex, invisibles.tab) else @value
-      html = "<span class='#{classes}'>#{@escapeString(value)}</span>"
+      classes += ' invisible-character' if @hasInvisibleCharacters
+      html = "<span class='#{classes}'>#{@escapeString(@value)}</span>"
    else
      startIndex = 0
      endIndex = @value.length
@@ -151,26 +148,27 @@ class Token
      leadingHtml = ''
      trailingHtml = ''

-      if @hasLeadingWhitespace and match = LeadingSpaceRegex.exec(@value)
+      if @hasLeadingWhitespace
+        leadingWhitespace = @value.substring(0, @firstNonWhitespaceIndex)
+
        classes = 'leading-whitespace'
        classes += ' indent-guide' if hasIndentGuide
-        classes += ' invisible-character' if invisibles.space
+        classes += ' invisible-character' if @hasInvisibleCharacters

-        match[0] = match[0].replace(CharacterRegex, invisibles.space) if invisibles.space
-        leadingHtml = "<span class='#{classes}'>#{match[0]}</span>"
+        leadingHtml = "<span class='#{classes}'>#{leadingWhitespace}</span>"
+        startIndex = @firstNonWhitespaceIndex

-        startIndex = match[0].length
+      if @hasTrailingWhitespace
+        tokenIsOnlyWhitespace = @firstTrailingWhitespaceIndex is 0
+        trailingWhitespace = @value.substring(@firstTrailingWhitespaceIndex)

-      if @hasTrailingWhitespace and match = TrailingSpaceRegex.exec(@value)
-        tokenIsOnlyWhitespace = match[0].length is @value.length
        classes = 'trailing-whitespace'
        classes += ' indent-guide' if hasIndentGuide and not @hasLeadingWhitespace and tokenIsOnlyWhitespace
-        classes += ' invisible-character' if invisibles.space
+        classes += ' invisible-character' if @hasInvisibleCharacters

-        match[0] = match[0].replace(CharacterRegex, invisibles.space) if invisibles.space
-        trailingHtml = "<span class='#{classes}'>#{match[0]}</span>"
+        trailingHtml = "<span class='#{classes}'>#{trailingWhitespace}</span>"

-        endIndex = match.index
+        endIndex = @firstTrailingWhitespaceIndex

      html = leadingHtml
      if @value.length > MaxTokenLength
@@ -19,27 +19,23 @@ class TokenizedBuffer extends Model
  invalidRows: null
  visible: false

-  constructor: ({@buffer, @tabLength}) ->
+  constructor: ({@buffer, @tabLength, @invisibles}) ->
    @tabLength ?= atom.config.getPositiveInt('editor.tabLength', 2)

    @subscribe atom.syntax, 'grammar-added grammar-updated', (grammar) =>
      if grammar.injectionSelector?
-        @resetTokenizedLines() if @hasTokenForSelector(grammar.injectionSelector)
+        @retokenizeLines() if @hasTokenForSelector(grammar.injectionSelector)
      else
        newScore = grammar.getScore(@buffer.getPath(), @buffer.getText())
        @setGrammar(grammar, newScore) if newScore > @currentGrammarScore

-    @on 'grammar-changed grammar-updated', => @resetTokenizedLines()
+    @on 'grammar-changed grammar-updated', => @retokenizeLines()
    @subscribe @buffer, "changed", (e) => @handleBufferChange(e)
    @subscribe @buffer, "path-changed", =>
      @bufferPath = @buffer.getPath()
      @reloadGrammar()

-    @subscribe @$tabLength.changes, (tabLength) =>
-      lastRow = @buffer.getLastRow()
-      @tokenizedLines = @buildPlaceholderTokenizedLinesForRows(0, lastRow)
-      @invalidateRow(0)
-      @emit "changed", { start: 0, end: lastRow, delta: 0 }
+    @subscribe @$tabLength.changes, (tabLength) => @retokenizeLines()

    @subscribe atom.config.observe 'editor.tabLength', callNow: false, =>
      @setTabLength(atom.config.getPositiveInt('editor.tabLength', 2))
@@ -59,7 +55,7 @@ class TokenizedBuffer extends Model
    @unsubscribe(@grammar) if @grammar
    @grammar = grammar
    @currentGrammarScore = score ? grammar.getScore(@buffer.getPath(), @buffer.getText())
-    @subscribe @grammar, 'grammar-updated', => @resetTokenizedLines()
+    @subscribe @grammar, 'grammar-updated', => @retokenizeLines()
    @emit 'grammar-changed', grammar

  reloadGrammar: ->
@@ -74,11 +70,13 @@ class TokenizedBuffer extends Model
        return true if selector.matches(token.scopes)
    false

-  resetTokenizedLines: ->
-    @tokenizedLines = @buildPlaceholderTokenizedLinesForRows(0, @buffer.getLastRow())
+  retokenizeLines: ->
+    lastRow = @buffer.getLastRow()
+    @tokenizedLines = @buildPlaceholderTokenizedLinesForRows(0, lastRow)
    @invalidRows = []
    @invalidateRow(0)
    @fullyTokenized = false
+    @emit "changed", {start: 0, end: lastRow, delta: 0}

  setVisible: (@visible) ->
    @tokenizeInBackground() if @visible
@@ -94,6 +92,11 @@ class TokenizedBuffer extends Model
  # tabLength - A {Number} that defines the new tab length.
  setTabLength: (@tabLength) ->

+  setInvisibles: (invisibles) ->
+    if invisibles isnt @invisibles
+      @invisibles = invisibles
+      @retokenizeLines()
+
  tokenizeInBackground: ->
    return if not @visible or @pendingChunk or not @isAlive()
    @pendingChunk = true
@@ -206,15 +209,16 @@ class TokenizedBuffer extends Model
    tokens = [new Token(value: line, scopes: [@grammar.scopeName])]
    tabLength = @getTabLength()
    indentLevel = @indentLevelForRow(row)
-    new TokenizedLine({tokens, tabLength, indentLevel})
+    lineEnding = @buffer.lineEndingForRow(row)
+    new TokenizedLine({tokens, tabLength, indentLevel, @invisibles, lineEnding})

  buildTokenizedTokenizedLineForRow: (row, ruleStack) ->
    line = @buffer.lineForRow(row)
    lineEnding = @buffer.lineEndingForRow(row)
    tabLength = @getTabLength()
    indentLevel = @indentLevelForRow(row)
-    { tokens, ruleStack } = @grammar.tokenizeLine(line, ruleStack, row is 0)
-    new TokenizedLine({tokens, ruleStack, tabLength, lineEnding, indentLevel})
+    {tokens, ruleStack} = @grammar.tokenizeLine(line, ruleStack, row is 0)
+    new TokenizedLine({tokens, ruleStack, tabLength, lineEnding, indentLevel, @invisibles})

  # FIXME: benogle says: These are actually buffer rows as all buffer rows are
  # accounted for in @tokenizedLines
@@ -1,10 +1,16 @@
 _ = require 'underscore-plus'

+NonWhitespaceRegex = /\S/
+LeadingWhitespaceRegex = /^\s*/
+TrailingWhitespaceRegex = /\s*$/
+RepeatedSpaceRegex = /[ ]/g
 idCounter = 1

 module.exports =
 class TokenizedLine
-  constructor: ({tokens, @lineEnding, @ruleStack, @startBufferColumn, @fold, @tabLength, @indentLevel}) ->
+  endOfLineInvisibles: null
+
+  constructor: ({tokens, @lineEnding, @ruleStack, @startBufferColumn, @fold, @tabLength, @indentLevel, @invisibles}) ->
    @startBufferColumn ?= 0
    @tokens = @breakOutAtomicTokens(tokens)
    @text = @buildText()
@@ -12,6 +18,9 @@ class TokenizedLine

    @id = idCounter++
    @markLeadingAndTrailingWhitespaceTokens()
+    if @invisibles
+      @substituteInvisibleCharacters()
+      @buildEndOfLineInvisibles() if @lineEnding?

  buildText: ->
    text = ""
@@ -90,12 +99,14 @@ class TokenizedLine
      tokens: leftTokens
      startBufferColumn: @startBufferColumn
      ruleStack: @ruleStack
+      invisibles: @invisibles
      lineEnding: null
    )
    rightFragment = new TokenizedLine(
      tokens: rightTokens
      startBufferColumn: @bufferColumnForScreenColumn(column)
      ruleStack: @ruleStack
+      invisibles: @invisibles
      lineEnding: @lineEnding
    )
    [leftFragment, rightFragment]
@@ -133,15 +144,55 @@ class TokenizedLine
    outputTokens

  markLeadingAndTrailingWhitespaceTokens: ->
-    firstNonWhitespacePosition = @text.search(/\S/)
-    firstTrailingWhitespacePosition = @text.search(/\s*$/)
-    lineIsWhitespaceOnly = firstTrailingWhitespacePosition is 0
-    position = 0
-    for token, i in @tokens
-      token.hasLeadingWhitespace =  position < firstNonWhitespacePosition
+    firstNonWhitespaceIndex = @text.search(NonWhitespaceRegex)
+    firstTrailingWhitespaceIndex = @text.search(TrailingWhitespaceRegex)
+    lineIsWhitespaceOnly = firstTrailingWhitespaceIndex is 0
+    index = 0
+    for token in @tokens
+      if index < firstNonWhitespaceIndex
+        token.hasLeadingWhitespace = true
+        token.firstNonWhitespaceIndex = Math.min(index + token.value.length, firstNonWhitespaceIndex - index)
      # Only the *last* segment of a soft-wrapped line can have trailing whitespace
-      token.hasTrailingWhitespace = @lineEnding? and (position + token.value.length > firstTrailingWhitespacePosition)
-      position += token.value.length
+      if @lineEnding? and (index + token.value.length > firstTrailingWhitespaceIndex)
+        token.hasTrailingWhitespace = true
+        token.firstTrailingWhitespaceIndex = Math.max(0, firstTrailingWhitespaceIndex - index)
+      index += token.value.length
+
+  substituteInvisibleCharacters: ->
+    invisibles = @invisibles
+    changedText = false
+
+    for token, i in @tokens
+      if token.isHardTab
+        if invisibles.tab
+          token.value = invisibles.tab + token.value.substring(invisibles.tab.length)
+          token.hasInvisibleCharacters = true
+          changedText = true
+      else
+        if invisibles.space
+          if token.hasLeadingWhitespace
+            token.value = token.value.replace LeadingWhitespaceRegex, (leadingWhitespace) ->
+              leadingWhitespace.replace RepeatedSpaceRegex, invisibles.space
+            token.hasInvisibleCharacters = true
+            changedText = true
+          if token.hasTrailingWhitespace
+            token.value = token.value.replace TrailingWhitespaceRegex, (leadingWhitespace) ->
+              leadingWhitespace.replace RepeatedSpaceRegex, invisibles.space
+            token.hasInvisibleCharacters = true
+            changedText = true
+
+    @text = @buildText() if changedText
+
+  buildEndOfLineInvisibles: ->
+    @endOfLineInvisibles = []
+    {cr, eol} = @invisibles
+
+    switch @lineEnding
+      when '\r\n'
+        @endOfLineInvisibles.push(cr) if cr
+        @endOfLineInvisibles.push(eol) if eol
+      when '\n'
+        @endOfLineInvisibles.push(eol) if eol

  isComment: ->
    for token in @tokens
@@ -23,9 +23,9 @@ class WindowEventHandler
    @subscribe ipc, 'context-command', (command, args...) ->
      $(atom.contextMenu.activeElement).trigger(command, args...)

-    @subscribe $(window), 'focus', -> $("body").removeClass('is-blurred')
+    @subscribe $(window), 'focus', -> document.body.classList.remove('is-blurred')

-    @subscribe $(window), 'blur', -> $("body").addClass('is-blurred')
+    @subscribe $(window), 'blur', -> document.body.classList.add('is-blurred')

    @subscribe $(window), 'window:open-path', (event, {pathToOpen, initialLine, initialColumn}) ->
      unless fs.isDirectorySync(pathToOpen)
@@ -35,13 +35,16 @@ class WindowEventHandler
      confirmed = atom.workspaceView?.confirmClose()
      atom.hide() if confirmed and not @reloadRequested and atom.getCurrentWindow().isWebViewFocused()
      @reloadRequested = false
+
+      atom.storeDefaultWindowDimensions()
+      atom.storeWindowDimensions()
+      atom.unloadEditorWindow() if confirmed
+
      confirmed

-    @subscribe $(window), 'blur unload', ->
-      atom.storeDefaultWindowDimensions()
+    @subscribe $(window), 'blur', -> atom.storeDefaultWindowDimensions()

-    @subscribe $(window), 'unload', ->
-      atom.storeWindowDimensions()
+    @subscribe $(window), 'unload', -> atom.removeEditorWindow()

    @subscribeToCommand $(window), 'window:toggle-full-screen', -> atom.toggleFullScreen()

@@ -57,8 +60,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 +97,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)
@@ -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)
@@ -105,6 +110,7 @@ class WorkspaceView extends View
    atom.project.on 'path-changed', => @updateTitle()
    @on 'pane-container:active-pane-item-changed', => @updateTitle()
    @on 'pane:active-item-title-changed', '.active.pane', => @updateTitle()
+    @on 'pane:active-item-modified-status-changed', '.active.pane', => @updateDocumentEdited()

    @command 'application:about', -> ipc.send('command', 'application:about')
    @command 'application:run-all-specs', -> ipc.send('command', 'application:run-all-specs')
@@ -205,19 +211,28 @@ class WorkspaceView extends View
  confirmClose: ->
    @panes.confirmClose()

-  # Updates the application's title, based on whichever file is open.
+  # Updates the application's title and proxy icon based on whichever file is
+  # open.
  updateTitle: ->
    if projectPath = atom.project.getPath()
      if item = @getModel().getActivePaneItem()
-        @setTitle("#{item.getTitle?() ? 'untitled'} - #{projectPath}")
+        title = "#{item.getTitle?() ? 'untitled'} - #{projectPath}"
+        @setTitle(title, item.getPath?())
      else
-        @setTitle(projectPath)
+        @setTitle(projectPath, projectPath)
    else
      @setTitle('untitled')

-  # Sets the application's title.
-  setTitle: (title) ->
+  # Sets the application's title (and the proxy icon on OS X)
+  setTitle: (title, proxyIconPath='') ->
    document.title = title
+    atom.setRepresentedFilename(proxyIconPath)
+
+  # On OS X, fades the application window's proxy icon when the current file
+  # has been modified.
+  updateDocumentEdited: ->
+    modified = @model.getActivePaneItem()?.isModified?() ? false
+    atom.setDocumentEdited(modified)

  # Get all editor views.
  #
@@ -340,6 +355,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")
@@ -30,7 +30,7 @@
  }

  .cursors.blink-off .cursor {
-    visibility: hidden;
+    opacity: 0;
  }

  .horizontal-scrollbar {
@@ -83,8 +83,15 @@
      }
    }
  }
+}
+
+.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;
  }
 }
@@ -300,8 +307,4 @@
  .scroll-view {
    overflow: hidden;
  }
-
-  .placeholder-text {
-    color: @text-color-subtle;
-  }
 }
@@ -43,6 +43,10 @@ div > .inline-block-tight:last-child {
  margin-right: 0;
 }

+.inline-block .inline-block {
+  vertical-align: top;
+}
+
 // Use left margin when it's in a float: right element.
 // Sets the margin correctly when inline blocks are hidden and shown.
 .pull-right {
@@ -67,6 +67,7 @@
 // Sizes

@font-size: 13px;
+@input-font-size: 14px;

@disclosure-arrow-size: 12px;
				`@@ -0,0 +1 @@`
				`throw new Error("this simulates a native module's failure to load")`