Merge pull request #3514 from atom/bo-remove-method-deprecations

Remove event deprecations from core

apm/package.json

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

atom.sh

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

benchmark/benchmark-bootstrap.coffee

@@ -1,6 +1,6 @@
 require '../src/window'
 Atom = require '../src/atom'
-atom = new Atom()
+window.atom = Atom.loadOrCreate('spec')
 atom.show() unless atom.getLoadSettings().exitWhenDone
 window.atom = atom
 
@@ -9,5 +9,4 @@ window.atom = atom
 atom.openDevTools()
 
 document.title = "Benchmark Suite"
-benchmarkSuite = require.resolve('./benchmark-suite')
-runSpecSuite(benchmarkSuite, true)
+runSpecSuite('../benchmark/benchmark-suite', atom.getLoadSettings().logFile)

benchmark/benchmark-helper.coffee

@@ -1,7 +1,9 @@
 require '../spec/spec-helper'
 
 path = require 'path'
-{$, _, Point, fs} = require 'atom'
+{$, Point} = require 'atom'
+_ = require 'underscore-plus'
+fs = require 'fs-plus'
 Project = require '../src/project'
 TokenizedBuffer = require '../src/tokenized-buffer'
 
@@ -101,7 +103,7 @@ $.fn.resultOfTrigger = (type) ->
   event.result
 
 $.fn.enableKeymap = ->
-  @on 'keydown', (e) => window.keymap.handleKeyEvent(e)
+  @on 'keydown', (e) -> window.keymap.handleKeyEvent(e)
 
 $.fn.attachToDom = ->
   $('#jasmine-content').append(this)

benchmark/benchmark-suite.coffee

@@ -53,7 +53,7 @@ describe "editorView.", ->
 
     describe "at-end.", ->
       beforeEach ->
-        editorView.moveCursorToBottom()
+        editorView.moveToBottom()
 
       benchmark "insert-delete", ->
         editorView.insertText('"')
@@ -62,8 +62,8 @@ describe "editorView.", ->
     describe "empty-vs-set-innerHTML.", ->
       [firstRow, lastRow] = []
       beforeEach ->
-        firstRow = editorView.getFirstVisibleScreenRow()
-        lastRow = editorView.getLastVisibleScreenRow()
+        firstRow = editorView.getModel().getFirstVisibleScreenRow()
+        lastRow = editorView.getModel().getLastVisibleScreenRow()
 
       benchmark "build-gutter-html.", 1000, ->
         editorView.gutter.renderLineNumbers(null, firstRow, lastRow)
@@ -97,13 +97,13 @@ describe "editorView.", ->
       describe "multiple-lines.", ->
         [firstRow, lastRow] = []
         beforeEach ->
-          firstRow = editorView.getFirstVisibleScreenRow()
-          lastRow = editorView.getLastVisibleScreenRow()
+          firstRow = editorView.getModel().getFirstVisibleScreenRow()
+          lastRow = editorView.getModel().getLastVisibleScreenRow()
 
         benchmark "cache-entire-visible-area", 100, ->
           for i in [firstRow..lastRow]
             line = editorView.lineElementForScreenRow(i)[0]
-            editorView.positionLeftForLineAndColumn(line, i, Math.max(0, editorView.lineLengthForBufferRow(i)))
+            editorView.positionLeftForLineAndColumn(line, i, Math.max(0, editorView.getModel().lineTextForBufferRow(i).length))
 
     describe "text-rendering.", ->
       beforeEach ->
@@ -178,7 +178,7 @@ describe "editorView.", ->
         atom.workspaceView.openSync('huge.js')
 
       benchmark "moving-to-eof.", 1, ->
-        editorView.moveCursorToBottom()
+        editorView.moveToBottom()
 
       describe "on-first-line.", ->
         benchmark "inserting-newline", 5, ->
@@ -195,11 +195,11 @@ describe "editorView.", ->
         endPosition = null
 
         beforeEach ->
-          editorView.moveCursorToBottom()
+          editorView.moveToBottom()
           endPosition = editorView.getCursorScreenPosition()
 
         benchmark "move-to-beginning-of-word", ->
-          editorView.moveCursorToBeginningOfWord()
+          editorView.moveToBeginningOfWord()
           editorView.setCursorScreenPosition(endPosition)
 
         benchmark "insert", ->

benchmark/browser-process-startup.coffee

@@ -0,0 +1,56 @@
+#!/usr/bin/env coffee
+
+{spawn, exec} = require 'child_process'
+fs = require 'fs'
+os = require 'os'
+path = require 'path'
+_ = require 'underscore-plus'
+temp = require 'temp'
+
+directoryToOpen = temp.mkdirSync('browser-process-startup-')
+socketPath = path.join(os.tmpdir(), 'atom.sock')
+numberOfRuns = 10
+
+deleteSocketFile = ->
+  try
+    fs.unlinkSync(socketPath) if fs.existsSync(socketPath)
+  catch error
+    console.error(error)
+
+launchAtom = (callback) ->
+  deleteSocketFile()
+
+  cmd = 'atom'
+  args = ['--safe', '--new-window', '--foreground', directoryToOpen]
+  atomProcess = spawn(cmd, args)
+
+  output = ''
+  startupTimes = []
+  dataListener = (data) ->
+    output += data
+    if match = /App load time: (\d+)/.exec(output)
+      startupTime = parseInt(match[1])
+      atomProcess.stderr.removeListener 'data', dataListener
+      atomProcess.kill()
+      exec 'pkill -9 Atom', (error) ->
+        console.error(error) if error?
+        callback(startupTime)
+
+  atomProcess.stderr.on 'data', dataListener
+
+startupTimes = []
+collector = (startupTime) ->
+  startupTimes.push(startupTime)
+  if startupTimes.length < numberOfRuns
+    launchAtom(collector)
+  else
+    maxTime = _.max(startupTimes)
+    minTime = _.min(startupTimes)
+    totalTime = startupTimes.reduce (previousValue=0, currentValue) -> previousValue + currentValue
+    console.log "Startup Runs: #{startupTimes.length}"
+    console.log "First run time: #{startupTimes[0]}ms"
+    console.log "Max time: #{maxTime}ms"
+    console.log "Min time: #{minTime}ms"
+    console.log "Average time: #{Math.round(totalTime/startupTimes.length)}ms"
+
+launchAtom(collector)

build/Gruntfile.coffee

@@ -40,7 +40,10 @@ module.exports = (grunt) ->
   appName = if process.platform is 'darwin' then 'Atom.app' else 'Atom'
   buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
   installDir = grunt.option('install-dir')
-  atomShellDownloadDir = path.join(tmpDir, 'atom-cached-atom-shells')
+
+  home = if process.platform is 'win32' then process.env.USERPROFILE else process.env.HOME
+  atomShellDownloadDir = path.join(home, '.atom', 'atom-shell')
+
   symbolsDir = path.join(buildDir, 'Atom.breakpad.syms')
   shellAppDir = path.join(buildDir, appName)
   if process.platform is 'win32'
@@ -57,7 +60,7 @@ module.exports = (grunt) ->
     contentsDir = shellAppDir
     appDir = path.join(shellAppDir, 'resources', 'app')
     installDir ?= process.env.INSTALL_PREFIX ? '/usr/local'
-    killCommand ='pkill -9 Atom'
+    killCommand ='pkill -9 atom'
 
   coffeeConfig =
     glob_to_multiple:
@@ -93,6 +96,8 @@ module.exports = (grunt) ->
   csonConfig =
     options:
       rootObject: true
+      cachePath: path.join(home, '.atom', 'compile-cache', 'grunt-cson')
+
     glob_to_multiple:
       expand: true
       src: [
@@ -125,7 +130,7 @@ module.exports = (grunt) ->
 
     atom: {appDir, appName, symbolsDir, buildDir, contentsDir, installDir, shellAppDir}
 
-    docsOutputDir: 'docs/output/api'
+    docsOutputDir: 'docs/output'
 
     coffee: coffeeConfig
 
@@ -139,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'
@@ -225,9 +225,14 @@ module.exports = (grunt) ->
   grunt.registerTask('compile', ['coffee', 'prebuild-less', 'cson', 'peg'])
   grunt.registerTask('lint', ['coffeelint', 'csslint', 'lesslint'])
   grunt.registerTask('test', ['shell:kill-atom', 'run-specs'])
-  grunt.registerTask('ci', ['output-disk-space', 'download-atom-shell', 'build', 'dump-symbols', 'set-version', 'check-licenses', 'lint', 'test', 'codesign', 'publish-build'])
   grunt.registerTask('docs', ['markdown:guides', 'build-docs'])
 
+
+  ciTasks = ['output-disk-space', 'download-atom-shell', 'build']
+  ciTasks.push('dump-symbols') unless process.platform is 'win32'
+  ciTasks.push('set-version', 'check-licenses', 'lint', 'test', 'codesign', 'publish-build')
+  grunt.registerTask('ci', ciTasks)
+
   defaultTasks = ['download-atom-shell', 'build', 'set-version']
   defaultTasks.push 'install' unless process.platform is 'linux'
   grunt.registerTask('default', defaultTasks)

build/package.json

@@ -7,17 +7,18 @@
   },
   "dependencies": {
     "async": "~0.2.9",
-    "biscotto": ">=2.1.1 <3.0",
+    "donna": "1.0.1",
+    "tello": "1.0.2",
     "formidable": "~1.0.14",
     "fs-plus": "2.x",
     "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",
-    "grunt-cson": "0.8.0",
+    "grunt-cson": "0.10.0",
     "grunt-download-atom-shell": "~0.8.0",
     "grunt-lesslint": "0.13.0",
     "grunt-markdown": "~0.4.0",
@@ -26,14 +27,14 @@
     "harmony-collections": "~0.3.8",
     "json-front-matter": "~0.1.3",
     "legal-eagle": "~0.4.0",
-    "minidump": "~0.7",
+    "minidump": "~0.8",
     "normalize-package-data": "0.2.12",
     "npm": "~1.4.5",
     "rcedit": "~0.1.2",
     "read-package-json": "1.1.8",
     "request": "~2.27.0",
     "rimraf": "~2.2.2",
-    "runas": "0.5.x",
+    "runas": "~1.0.1",
     "underscore-plus": "1.x",
     "unzip": "~0.1.9",
     "vm-compatibility-layer": "~0.1.0"

build/tasks/build-task.coffee

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

build/tasks/docs-task.coffee

@@ -1,162 +1,39 @@
 path = require 'path'
 
-async = require 'async'
 fs = require 'fs-plus'
-request = require 'request'
+_ = require 'underscore-plus'
+
+donna = require 'donna'
+tello = require 'tello'
 
 module.exports = (grunt) ->
-  {rm} = require('./task-helpers')(grunt)
+  getClassesToInclude = ->
+    modulesPath = path.resolve(__dirname, '..', '..', 'node_modules')
+    classes = {}
+    fs.traverseTreeSync modulesPath, (modulePath) ->
+      return true unless path.basename(modulePath) is 'package.json'
+      return true unless fs.isFileSync(modulePath)
 
-  cmd = path.join('node_modules', '.bin', 'coffee')
-  commonArgs = [path.join('build', 'node_modules', '.bin', 'biscotto'), '--']
-  opts =
-    stdio: 'inherit'
+      apiPath = path.join(path.dirname(modulePath), 'api.json')
+      if fs.isFileSync(apiPath)
+        _.extend(classes, grunt.file.readJSON(apiPath).classes)
+      true
+    classes
+
+  sortClasses = (classes) ->
+    sortedClasses = {}
+    for className in Object.keys(classes).sort()
+      sortedClasses[className] = classes[className]
+    sortedClasses
 
   grunt.registerTask 'build-docs', 'Builds the API docs in src', ->
-    done = @async()
-
     docsOutputDir = grunt.config.get('docsOutputDir')
 
-    downloadIncludes (error, includePaths) ->
-      if error?
-        done(error)
-      else
-        rm(docsOutputDir)
-        args = [
-          commonArgs...
-          '--title', 'Atom API Documentation'
-          '-o', docsOutputDir
-          '-r', 'docs/README.md'
-          '--stability', '1'
-          'src/'
-          includePaths...
-        ]
-        grunt.util.spawn({cmd, args, opts}, done)
+    metadata = donna.generateMetadata(['.'])
+    api = tello.digest(metadata)
+    _.extend(api.classes, getClassesToInclude())
+    api.classes = sortClasses(api.classes)
 
-  grunt.registerTask 'lint-docs', 'Generate stats about the doc coverage', ->
-    done = @async()
-    downloadIncludes (error, includePaths) ->
-      if error?
-        done(error)
-      else
-        args = [
-          commonArgs...
-          '--noOutput'
-          'src/'
-          includePaths...
-        ]
-        grunt.util.spawn({cmd, args, opts}, done)
-
-  grunt.registerTask 'missing-docs', 'Generate stats about the doc coverage', ->
-    done = @async()
-    downloadIncludes (error, includePaths) ->
-      if error?
-        done(error)
-      else
-        args = [
-          commonArgs...
-          '--noOutput'
-          '--missing'
-          'src/'
-          includePaths...
-        ]
-        grunt.util.spawn({cmd, args, opts}, done)
-
-  grunt.registerTask 'copy-docs', 'Copies over latest API docs to atom-docs', ->
-    done = @async()
-
-    fetchTag = (args..., callback) ->
-      cmd = 'git'
-      args = ['describe', '--abbrev=0', '--tags']
-      grunt.util.spawn {cmd, args}, (error, result) ->
-        if error?
-          callback(error)
-        else
-          callback(null, String(result).trim())
-
-    copyDocs = (tag, callback) ->
-      cmd = 'cp'
-      args = ['-r', 'docs/output/', "../atom.io/public/docs/api/#{tag}/"]
-
-      fs.exists "../atom.io/public/docs/api/", (exists) ->
-        if exists
-          grunt.util.spawn {cmd, args}, (error, result) ->
-            if error?
-              callback(error)
-            else
-              callback(null, tag)
-        else
-          grunt.log.error "../atom.io/public/docs/api/ doesn't exist"
-          return false
-
-    grunt.util.async.waterfall [fetchTag, copyDocs], done
-
-  grunt.registerTask 'deploy-docs', 'Publishes latest API docs to atom-docs.githubapp.com', ->
-    done = @async()
-    docsRepoArgs = ['--work-tree=../atom-docs/', '--git-dir=../atom-docs/.git/']
-
-    fetchTag = (args..., callback) ->
-      cmd = 'git'
-      args = ['describe', '--abbrev=0', '--tags']
-      grunt.util.spawn {cmd, args}, (error, result) ->
-        if error?
-          callback(error)
-        else
-          callback(null, String(result).trim().split('.')[0..1].join('.'))
-
-    stageDocs = (tag, callback) ->
-      cmd = 'git'
-      args = [docsRepoArgs..., 'add', "public/#{tag}"]
-      grunt.util.spawn({cmd, args, opts}, callback)
-
-    fetchSha = (args..., callback) ->
-      cmd = 'git'
-      args = ['rev-parse', 'HEAD']
-      grunt.util.spawn {cmd, args}, (error, result) ->
-        if error?
-          callback(error)
-        else
-          callback(null, String(result).trim())
-
-    commitChanges = (sha, callback) ->
-      cmd = 'git'
-      args = [docsRepoArgs..., 'commit', "-m Update API docs to #{sha}"]
-      grunt.util.spawn({cmd, args, opts}, callback)
-
-    pushOrigin = (args..., callback) ->
-      cmd = 'git'
-      args = [docsRepoArgs..., 'push', 'origin', 'master']
-      grunt.util.spawn({cmd, args, opts}, callback)
-
-    pushHeroku = (args..., callback) ->
-      cmd = 'git'
-      args = [docsRepoArgs..., 'push', 'heroku', 'master']
-      grunt.util.spawn({cmd, args, opts}, callback)
-
-    grunt.util.async.waterfall [fetchTag, stageDocs, fetchSha, commitChanges, pushOrigin, pushHeroku], done
-
-downloadFileFromRepo = ({repo, file}, callback) ->
-  uri = "https://raw.github.com/atom/#{repo}/master/#{file}"
-  request uri, (error, response, contents) ->
-    return callback(error) if error?
-    downloadPath = path.join('docs', 'includes', repo, file)
-    fs.writeFile downloadPath, contents, (error) ->
-      callback(error, downloadPath)
-
-downloadIncludes = (callback) ->
-  includes = [
-    {repo: 'atom-keymap', file: 'src/keymap-manager.coffee'}
-    {repo: 'atom-keymap', file: 'src/key-binding.coffee'}
-    {repo: 'first-mate',  file: 'src/grammar.coffee'}
-    {repo: 'first-mate',  file: 'src/grammar-registry.coffee'}
-    {repo: 'node-pathwatcher', file: 'src/directory.coffee'}
-    {repo: 'node-pathwatcher', file: 'src/file.coffee'}
-    {repo: 'space-pen',   file: 'src/space-pen.coffee'}
-    {repo: 'text-buffer', file: 'src/marker.coffee'}
-    {repo: 'text-buffer', file: 'src/point.coffee'}
-    {repo: 'text-buffer', file: 'src/range.coffee'}
-    {repo: 'text-buffer', file: 'src/text-buffer.coffee'}
-    {repo: 'theorist',    file: 'src/model.coffee'}
-  ]
-
-  async.map(includes, downloadFileFromRepo, callback)
+    apiJson = JSON.stringify(api, null, 2)
+    apiJsonPath = path.join(docsOutputDir, 'api.json')
+    grunt.file.write(apiJsonPath, apiJson)

build/tasks/mkdeb-task.coffee

@@ -13,8 +13,16 @@ module.exports = (grunt) ->
     grunt.file.write(outputPath, filled)
     outputPath
 
+  getInstalledSize = (buildDir, callback) ->
+    cmd = 'du'
+    args = ['-sk', path.join(buildDir, 'Atom')]
+    spawn {cmd, args}, (error, {stdout}) ->
+      installedSize = stdout.split(/\s+/)?[0] or '200000' # default to 200MB
+      callback(null, installedSize)
+
   grunt.registerTask 'mkdeb', 'Create debian package', ->
     done = @async()
+    buildDir = grunt.config.get('atom.buildDir')
 
     if process.arch is 'ia32'
       arch = 'i386'
@@ -28,13 +36,17 @@ module.exports = (grunt) ->
     maintainer = 'GitHub <atom@github.com>'
     installDir = '/usr'
     iconName = 'atom'
-    data = {name, version, description, section, arch, maintainer, installDir, iconName}
+    getInstalledSize buildDir, (error, installedSize) ->
+      data = {name, version, description, section, arch, maintainer, installDir, iconName, installedSize}
+      controlFilePath = fillTemplate(path.join('resources', 'linux', 'debian', 'control'), data)
+      desktopFilePath = fillTemplate(path.join('resources', 'linux', 'Atom.desktop'), data)
+      icon = path.join('resources', 'atom.png')
 
-    controlFilePath = fillTemplate(path.join('resources', 'linux', 'debian', 'control'), data)
-    desktopFilePath = fillTemplate(path.join('resources', 'linux', 'Atom.desktop'), data)
-    icon = path.join('resources', 'atom.png')
-    buildDir = grunt.config.get('atom.buildDir')
-
-    cmd = path.join('script', 'mkdeb')
-    args = [version, arch, controlFilePath, desktopFilePath, icon, buildDir]
-    spawn({cmd, args}, done)
+      cmd = path.join('script', 'mkdeb')
+      args = [version, arch, controlFilePath, desktopFilePath, icon, buildDir]
+      spawn {cmd, args}, (error) ->
+        if error?
+          done(error)
+        else
+          grunt.log.ok "Created #{buildDir}/atom-#{version}-#{arch}.deb"
+          done()

build/tasks/output-build-filetypes.coffee

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

build/tasks/publish-build-task.coffee

@@ -17,6 +17,7 @@ defaultHeaders =
 
 module.exports = (gruntObject) ->
   grunt = gruntObject
+  {cp} = require('./task-helpers')(grunt)
 
   grunt.registerTask 'publish-build', 'Publish the built app', ->
     return if process.env.JANKY_SHA1 and process.env.JANKY_BRANCH isnt 'master'
@@ -24,8 +25,10 @@ module.exports = (gruntObject) ->
     tasks.unshift('build-docs', 'prepare-docs') if process.platform is 'darwin'
     grunt.task.run(tasks)
 
-  grunt.registerTask 'prepare-docs', 'Move the build docs to the build dir', ->
-    fs.copySync(grunt.config.get('docsOutputDir'), path.join(grunt.config.get('atom.buildDir'), 'atom-docs'))
+  grunt.registerTask 'prepare-docs', 'Move api.json to atom-api.json', ->
+    docsOutputDir = grunt.config.get('docsOutputDir')
+    buildDir = grunt.config.get('atom.buildDir')
+    cp  path.join(docsOutputDir, 'api.json'), path.join(buildDir, 'atom-api.json')
 
   grunt.registerTask 'upload-assets', 'Upload the assets to a GitHub release', ->
     done = @async()
@@ -46,7 +49,7 @@ getAssets = ->
     [
       {assetName: 'atom-mac.zip', sourcePath: 'Atom.app'}
       {assetName: 'atom-mac-symbols.zip', sourcePath: 'Atom.breakpad.syms'}
-      {assetName: 'atom-docs.zip', sourcePath: 'atom-docs'}
+      {assetName: 'atom-api.json', sourcePath: 'atom-api.json'}
     ]
   else
     [
@@ -70,7 +73,7 @@ zipAssets = (buildDir, assets, callback) ->
       callback(error)
 
   tasks = []
-  for {assetName, sourcePath} in assets
+  for {assetName, sourcePath} in assets when path.extname(assetName) is '.zip'
     fs.removeSync(path.join(buildDir, assetName))
     tasks.push(zip.bind(this, buildDir, sourcePath, assetName))
   async.parallel(tasks, callback)

build/tasks/set-version-task.coffee

@@ -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
 

build/tasks/spec-task.coffee

@@ -2,7 +2,6 @@ fs = require 'fs'
 path = require 'path'
 
 _ = require 'underscore-plus'
-
 async = require 'async'
 
 module.exports = (grunt) ->
@@ -10,18 +9,27 @@ module.exports = (grunt) ->
 
   packageSpecQueue = null
 
+  getAppPath = ->
+    contentsDir = grunt.config.get('atom.contentsDir')
+    switch process.platform
+      when 'darwin'
+        path.join(contentsDir, 'MacOS', 'Atom')
+      when 'linux'
+        path.join(contentsDir, 'atom')
+      when 'win32'
+        path.join(contentsDir, 'atom.exe')
+
   runPackageSpecs = (callback) ->
     failedPackages = []
     rootDir = grunt.config.get('atom.shellAppDir')
-    contentsDir = grunt.config.get('atom.contentsDir')
     resourcePath = process.cwd()
-    if process.platform is 'darwin'
-      appPath = path.join(contentsDir, 'MacOS', 'Atom')
-    else if process.platform is 'win32'
-      appPath = path.join(contentsDir, 'atom.exe')
+    appPath = getAppPath()
+
+    # Ensure application is executable on Linux
+    fs.chmodSync(appPath, '755') if process.platform is 'linux'
 
     packageSpecQueue = async.queue (packagePath, callback) ->
-      if process.platform is 'darwin'
+      if process.platform in ['darwin', 'linux']
         options =
           cmd: appPath
           args: ['--test', "--resource-path=#{resourcePath}", "--spec-directory=#{path.join(packagePath, 'spec')}"]
@@ -57,15 +65,11 @@ module.exports = (grunt) ->
     packageSpecQueue.drain = -> callback(null, failedPackages)
 
   runCoreSpecs = (callback) ->
-    contentsDir = grunt.config.get('atom.contentsDir')
-    if process.platform is 'darwin'
-      appPath = path.join(contentsDir, 'MacOS', 'Atom')
-    else if process.platform is 'win32'
-      appPath = path.join(contentsDir, 'atom.exe')
+    appPath = getAppPath()
     resourcePath = process.cwd()
     coreSpecsPath = path.resolve('spec')
 
-    if process.platform is 'darwin'
+    if process.platform in ['darwin', 'linux']
       options =
         cmd: appPath
         args: ['--test', "--resource-path=#{resourcePath}", "--spec-directory=#{coreSpecsPath}"]
@@ -90,7 +94,7 @@ module.exports = (grunt) ->
 
     # TODO: This should really be parallel on both platforms, however our
     # fixtures step on each others toes currently.
-    if process.platform is 'darwin'
+    if process.platform in ['darwin', 'linux']
       method = async.parallel
     else if process.platform is 'win32'
       method = async.series

build/tasks/task-helpers.coffee

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

coffeelint.json

@@ -0,0 +1,14 @@
+{
+  "max_line_length": {
+    "level": "ignore"
+  },
+  "no_empty_param_list": {
+    "level": "error"
+  },
+  "arrow_spacing": {
+    "level": "error"
+  },
+  "no_interpolation_in_single_quotes": {
+    "level": "error"
+  }
+}

docs/advanced/keymaps.md

@@ -56,7 +56,7 @@ character of the current line:
 class EditorView
   listenForEvents: ->
     @command 'editor:move-to-first-character-of-line', =>
-      @editor.moveCursorToFirstCharacterOfLine()
+      @editor.moveToFirstCharacterOfLine()
 ```
 
 The `::command` method is basically an enhanced version of jQuery's `::on`

docs/build-instructions/linux.md

@@ -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:
@@ -61,7 +88,7 @@ this is the reason for this error you can issue
 and restart Atom.  If Atom now works fine, you can make this setting permanent:
 
   ```sh
-  echo 32768 > /proc/sys/fs/inotify/max_user_watches
+  echo 32768 | sudo tee -a /proc/sys/fs/inotify/max_user_watches
   ```
 
 See also https://github.com/atom/atom/issues/2082.
@@ -69,10 +96,19 @@ 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.
 
+#### You can also use Alternatives
+
+On some variants (mostly Debian based distros) it's preferable for you to use
+Alternatives so that changes to the binary paths can be fixed or altered easily:
+
+```sh
+sudo update-alternatives --install /usr/bin/node node /usr/bin/nodejs 1 --slave /usr/bin/js js /usr/bin/nodejs
+```
+
 ### Linux build error reports in atom/atom
 * Use [this search](https://github.com/atom/atom/search?q=label%3Abuild-error+label%3Alinux&type=Issues)
   to get a list of reports about build errors on Linux.

docs/build-instructions/windows.md

@@ -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.
 

docs/customizing-atom.md

@@ -123,7 +123,7 @@ You can open this file in an editor from the _Atom > Open Your Config_ menu.
   - `showInvisibles`: Whether to render placeholders for invisible characters (defaults to `false`)
   - `showIndentGuide`: Show/hide indent indicators within the editor
   - `showLineNumbers`: Show/hide line numbers within the gutter
-  - `softWrap`: Enable/disable soft wrapping of text within the editor
+  - `softWrapped`: Enable/disable soft wrapping of text within the editor
   - `softWrapAtPreferredLineLength`: Enable/disable soft line wrapping at `preferredLineLength`
   - `tabLength`: Number of spaces within a tab (defaults to `2`)
 - `fuzzyFinder`

docs/your-first-package.md

@@ -53,7 +53,7 @@ module.exports =
 
   convert: ->
     # This assumes the active pane item is an editor
-    editor = atom.workspace.activePaneItem
+    editor = atom.workspace.getActivePaneItem()
     editor.insertText('Hello, World!')
 ```
 
@@ -131,8 +131,8 @@ inserting 'Hello, World!' convert the selected text to ASCII art.
 ```coffeescript
 convert: ->
   # This assumes the active pane item is an editor
-  editor = atom.workspace.activePaneItem
-  selection = editor.getSelection()
+  editor = atom.workspace.getActivePaneItem()
+  selection = editor.getLastSelection()
 
   figlet = require 'figlet'
   figlet selection.getText(), {font: "Larry 3D 2"}, (error, asciiArt) ->

dot-atom/init.coffee

@@ -11,4 +11,4 @@
 # atom.workspaceView.eachEditorView (editorView) ->
 #   editor = editorView.getEditor()
 #   if path.extname(editor.getPath()) is '.md'
-#     editor.setSoftWrap(true)
+#     editor.setSoftWrapped(true)

dot-atom/keymap.cson

@@ -13,6 +13,9 @@
 #   'enter': 'editor:newline'
 #
 # '.workspace':
-#   'ctrl-P': 'core:move-up'
+#   'ctrl-shift-p': 'core:move-up'
 #   'ctrl-p': 'core:move-down'
 #
+# You can find more information about keymaps in these guides:
+# * https://atom.io/docs/latest/customizing-atom#customizing-key-bindings
+# * https://atom.io/docs/latest/advanced/keymaps

exports/atom.coffee

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

keymaps/base.cson

@@ -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!'

keymaps/darwin.cson

@@ -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'

keymaps/linux.cson

@@ -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'
@@ -11,10 +10,12 @@
   'ctrl-shift-i': 'window:toggle-dev-tools'
   'ctrl-alt-p': 'window:run-package-specs'
   'ctrl-alt-s': 'application:run-all-specs'
-  'ctrl-shift-o': 'application:open-dev'
+  'ctrl-alt-o': 'application:open-dev'
+  'ctrl-shift-o': 'application:open-folder'
   'F11': 'window:toggle-full-screen'
 
   # Sublime Parity
+  'ctrl-,': 'application:show-settings'
   'ctrl-N': 'application:new-window'
   'ctrl-W': 'window:close'
   'ctrl-o': 'application:open-file'
@@ -26,6 +27,7 @@
   'ctrl-w': 'core:close'
   'ctrl-z': 'core:undo'
   'ctrl-y': 'core:redo'
+  'ctrl-shift-z': 'core:redo'
   'ctrl-x': 'core:cut'
   'ctrl-c': 'core:copy'
   'ctrl-v': 'core:paste'
@@ -95,6 +97,7 @@
   'ctrl-alt-shift-p': 'editor:log-cursor-scope'
   'ctrl-k ctrl-u': 'editor:upper-case'
   'ctrl-k ctrl-l': 'editor:lower-case'
+  'ctrl-l': 'editor:select-line'
 
 '.workspace .editor:not(.mini)':
   # Atom specific

keymaps/win32.cson

@@ -5,7 +5,6 @@
 
   # Atom Specific
   'enter': 'core:confirm'
-  'num-enter': 'core:confirm'
   'escape': 'core:cancel'
   'up': 'core:move-up'
   'down': 'core:move-down'
@@ -26,8 +25,8 @@
   'ctrl-n': 'application:new-file'
   'ctrl-s': 'core:save'
   'ctrl-S': 'core:save-as'
-  'ctrl-w': 'core:close'
   'ctrl-f4': 'core:close'
+  'ctrl-w': 'core:close'
   'ctrl-z': 'core:undo'
   'ctrl-shift-z': 'core:redo'
   'ctrl-y': 'core:redo'
@@ -93,6 +92,7 @@
   'ctrl-alt-shift-p': 'editor:log-cursor-scope'
   'ctrl-k ctrl-u': 'editor:upper-case'
   'ctrl-k ctrl-l': 'editor:lower-case'
+  'ctrl-l': 'editor:select-line'
 
 '.workspace .editor:not(.mini)':
   # Atom specific

menus/darwin.cson

@@ -18,6 +18,8 @@
       { type: 'separator' }
       { label: 'Install Shell Commands', command: 'window:install-shell-commands' }
       { type: 'separator' }
+      { label: 'Services', submenu: [] }
+      { type: 'separator' }
       { label: 'Hide Atom', command: 'application:hide' }
       { label: 'Hide Others', command: 'application:hide-other-applications' }
       { label: 'Show All', command: 'application:unhide-all-applications' }
@@ -37,7 +39,7 @@
       { label: 'Save As...', command: 'core:save-as' }
       { label: 'Save All', command: 'window:save-all' }
       { type: 'separator' }
-      { label: 'Close Buffer', command: 'core:close' }
+      { label: 'Close Tab', command: 'core:close' }
       { label: 'Close Pane', command: 'pane:close' }
       { label: 'Close Window', command: 'window:close' }
     ]
@@ -164,7 +166,7 @@
         ]
       }
       { type: 'separator' }
-      { label: 'Toggle Soft Wrap', command: 'editor:toggle-soft-wrap' }
+      { label: 'Toggle Soft Wrap', command: 'editor:toggle-soft-wrapped' }
     ]
   }
 
@@ -192,3 +194,13 @@
     ]
   }
 ]
+
+'context-menu':
+  '.overlayer':
+    'Undo': 'core:undo'
+    'Redo': 'core:redo'
+    'Cut': 'core:cut'
+    'Copy': 'core:copy'
+    'Paste': 'core:paste'
+    'Delete': 'core:delete'
+    'Select All': 'core:select-all'

menus/linux.cson

@@ -8,14 +8,12 @@
       { label: 'Open Folder...', command: 'application:open-folder' }
       { label: 'Reopen Last &Item', command: 'pane:reopen-closed-item' }
       { type: 'separator' }
-      { label: '&Preferences...', command: 'application:show-settings' }
-      { type: 'separator' }
       { label: '&Save', command: 'core:save' }
       { label: 'Save &As...', command: 'core:save-as' }
       { label: 'Save A&ll', command: 'window:save-all' }
       { type: 'separator' }
-      { label: '&Close Buffer', command: 'core:close' }
-      { label: 'Close All &Buffers', command: 'pane:close' }
+      { label: '&Close Tab', command: 'core:close' }
+      { label: 'Close &Pane', command: 'pane:close' }
       { label: 'Clos&e Window', command: 'window:close' }
       { type: 'separator' }
       { label: 'Quit', command: 'application:quit' }
@@ -80,6 +78,14 @@
           { label: 'Fold Level 9', command: 'editor:fold-at-indent-level-9' }
         ]
       }
+      { type: 'separator' }
+      { label: '&Preferences', command: 'application:show-settings' }
+      { label: 'Open Your Config', command: 'application:open-your-config' }
+      { label: 'Open Your Init Script', command: 'application:open-your-init-script' }
+      { label: 'Open Your Keymap', command: 'application:open-your-keymap' }
+      { label: 'Open Your Snippets', command: 'application:open-your-snippets' }
+      { label: 'Open Your Stylesheet', command: 'application:open-your-stylesheet' }
+      { type: 'separator' }
     ]
   }
 
@@ -98,7 +104,7 @@
         ]
       }
       { type: 'separator' }
-      { label: 'Toggle Soft &Wrap', command: 'editor:toggle-soft-wrap' }
+      { label: 'Toggle Soft &Wrap', command: 'editor:toggle-soft-wrapped' }
     ]
   }
 
@@ -133,16 +139,6 @@
     submenu: []
   }
 
-  {
-    label: '&Window'
-    submenu: [
-      { label: 'Mi&nimize', command: 'application:minimize' }
-      { label: 'Ma&ximize', command: 'application:zoom' }
-      { type: 'separator' }
-      { label: 'Bring &All to Front', command: 'application:bring-all-windows-to-front' }
-    ]
-  }
-
   {
     label: '&Help'
     submenu: [
@@ -155,3 +151,13 @@
     ]
   }
 ]
+
+'context-menu':
+  '.overlayer':
+    'Undo': 'core:undo'
+    'Redo': 'core:redo'
+    'Cut': 'core:cut'
+    'Copy': 'core:copy'
+    'Paste': 'core:paste'
+    'Delete': 'core:delete'
+    'Select All': 'core:select-all'

menus/win32.cson

@@ -9,13 +9,18 @@
       { label: 'Reopen Last &Item', command: 'pane:reopen-closed-item' }
       { type: 'separator' }
       { label: 'Se&ttings', command: 'application:show-settings' }
+      { label: 'Open Your Config', command: 'application:open-your-config' }
+      { label: 'Open Your Init Script', command: 'application:open-your-init-script' }
+      { label: 'Open Your Keymap', command: 'application:open-your-keymap' }
+      { label: 'Open Your Snippets', command: 'application:open-your-snippets' }
+      { label: 'Open Your Stylesheet', command: 'application:open-your-stylesheet' }
       { type: 'separator' }
       { label: '&Save', command: 'core:save' }
       { label: 'Save &As...', command: 'core:save-as' }
       { label: 'Save A&ll', command: 'window:save-all' }
       { type: 'separator' }
-      { label: '&Close Buffer', command: 'core:close' }
-      { label: 'Close All &Buffers', command: 'pane:close' }
+      { label: '&Close Tab', command: 'core:close' }
+      { label: 'Close &Pane', command: 'pane:close' }
       { label: 'Clos&e Window', command: 'window:close' }
       { type: 'separator' }
       { label: 'E&xit', command: 'application:quit' }
@@ -117,7 +122,7 @@
         ]
       }
       { type: 'separator' }
-      { label: 'Toggle Soft &Wrap', command: 'editor:toggle-soft-wrap' }
+      { label: 'Toggle Soft &Wrap', command: 'editor:toggle-soft-wrapped' }
     ]
   }
 
@@ -152,16 +157,6 @@
     submenu: []
   }
 
-  {
-    label: '&Window'
-    submenu: [
-      { label: 'Mi&nimize', command: 'application:minimize' }
-      { label: 'Ma&ximize', command: 'application:zoom' }
-      { type: 'separator' }
-      { label: 'Bring &All to Front', command: 'application:bring-all-windows-to-front' }
-    ]
-  }
-
   {
     label: '&Help'
     submenu: [
@@ -174,3 +169,13 @@
     ]
   }
 ]
+
+'context-menu':
+  '.overlayer':
+    'Undo': 'core:undo'
+    'Redo': 'core:redo'
+    'Cut': 'core:cut'
+    'Copy': 'core:copy'
+    'Paste': 'core:paste'
+    'Delete': 'core:delete'
+    'Select All': 'core:select-all'

package.json

@@ -1,7 +1,7 @@
 {
   "name": "atom",
   "productName": "Atom",
-  "version": "0.117.0",
+  "version": "0.127.0",
   "description": "A hackable text editor for the 21st Century.",
   "main": "./src/browser/main.js",
   "repository": {
@@ -17,127 +17,129 @@
       "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
     }
   ],
-  "atomShellVersion": "0.13.3",
+  "atomShellVersion": "0.16.2",
   "dependencies": {
     "async": "0.2.6",
-    "atom-keymap": "^0.28.0",
+    "atom-keymap": "^2.1.0",
     "bootstrap": "git+https://github.com/atom/bootstrap.git#6af81906189f1747fd6c93479e3d998ebe041372",
     "clear-cut": "0.4.0",
     "coffee-script": "1.7.0",
     "coffeestack": "0.7.0",
     "delegato": "^1",
-    "emissary": "^1.2.1",
-    "first-mate": "^1.7.1",
-    "fs-plus": "^2.2.4",
+    "emissary": "^1.3.1",
+    "event-kit": "0.7.1",
+    "first-mate": "^2.1.0",
+    "fs-plus": "^2.2.6",
     "fstream": "0.1.24",
-    "fuzzaldrin": "^1.1",
-    "git-utils": "^1.6",
-    "grim": "0.11.0",
+    "fuzzaldrin": "^2.1",
+    "git-utils": "^2.1.4",
+    "grim": "0.12.0",
     "guid": "0.0.10",
     "jasmine-tagged": "^1.1.2",
-    "less-cache": "0.13.0",
+    "less-cache": "0.14.0",
     "mixto": "^1",
     "mkdirp": "0.3.5",
-    "nslog": "0.5.0",
-    "oniguruma": "^1.0.6",
+    "nslog": "^1.0.1",
+    "oniguruma": "^3.0.4",
     "optimist": "0.4.0",
-    "pathwatcher": "^1.5",
+    "pathwatcher": "^2.1.1",
     "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",
+    "space-pen": "3.4.7",
     "temp": "0.7.0",
-    "text-buffer": "^2.4.2",
-    "theorist": "^1",
-    "underscore-plus": "^1.5.0",
+    "text-buffer": "^3.2.4",
+    "theorist": "^1.0.2",
+    "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.34.0",
     "atom-light-syntax": "0.20.0",
-    "atom-light-ui": "0.28.0",
-    "base16-tomorrow-dark-theme": "0.20.0",
-    "base16-tomorrow-light-theme": "0.3.0",
-    "solarized-dark-syntax": "0.21.0",
-    "solarized-light-syntax": "0.11.0",
-    "archive-view": "0.34.0",
-    "autocomplete": "0.28.0",
-    "autoflow": "0.17.0",
-    "autosave": "0.14.0",
-    "background-tips": "0.15.0",
-    "bookmarks": "0.27.0",
-    "bracket-matcher": "0.48.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.22.0",
+    "solarized-light-syntax": "0.12.0",
+    "archive-view": "0.36.0",
+    "autocomplete": "0.32.0",
+    "autoflow": "0.18.0",
+    "autosave": "0.17.0",
+    "background-tips": "0.16.0",
+    "bookmarks": "0.28.0",
+    "bracket-matcher": "0.55.0",
     "command-palette": "0.24.0",
-    "deprecation-cop": "0.7.0",
-    "dev-live-reload": "0.31.0",
-    "exception-reporting": "0.18.0",
+    "deprecation-cop": "0.10.0",
+    "dev-live-reload": "0.34.0",
+    "exception-reporting": "0.20.0",
     "feedback": "0.33.0",
-    "find-and-replace": "0.127.0",
-    "fuzzy-finder": "0.57.0",
-    "git-diff": "0.37.0",
-    "go-to-line": "0.23.0",
-    "grammar-selector": "0.27.0",
+    "find-and-replace": "0.134.0",
+    "fuzzy-finder": "0.58.0",
+    "git-diff": "0.39.0",
+    "go-to-line": "0.25.0",
+    "grammar-selector": "0.29.0",
     "image-view": "0.36.0",
-    "keybinding-resolver": "0.18.0",
-    "link": "0.24.0",
-    "markdown-preview": "0.93.0",
-    "metrics": "0.33.0",
-    "open-on-github": "0.29.0",
+    "incompatible-packages": "0.9.0",
+    "keybinding-resolver": "0.19.0",
+    "link": "0.25.0",
+    "markdown-preview": "0.101.0",
+    "metrics": "0.34.0",
+    "open-on-github": "0.30.0",
     "package-generator": "0.31.0",
-    "release-notes": "0.35.0",
-    "settings-view": "0.134.0",
-    "snippets": "0.48.0",
-    "spell-check": "0.38.0",
-    "status-bar": "0.41.0",
-    "styleguide": "0.29.0",
-    "symbols-view": "0.60.0",
-    "tabs": "0.45.0",
-    "timecop": "0.21.0",
-    "tree-view": "0.111.0",
+    "release-notes": "0.36.0",
+    "settings-view": "0.142.0",
+    "snippets": "0.52.0",
+    "spell-check": "0.42.0",
+    "status-bar": "0.44.0",
+    "styleguide": "0.30.0",
+    "symbols-view": "0.63.0",
+    "tabs": "0.50.0",
+    "timecop": "0.22.0",
+    "tree-view": "0.115.0",
     "update-package-dependencies": "0.6.0",
-    "welcome": "0.17.0",
+    "welcome": "0.18.0",
     "whitespace": "0.25.0",
     "wrap-guide": "0.21.0",
-
-    "language-c": "0.22.0",
-    "language-coffee-script": "0.27.0",
+    "language-c": "0.28.0",
+    "language-coffee-script": "0.30.0",
     "language-css": "0.17.0",
-    "language-gfm": "0.43.0",
+    "language-gfm": "0.48.0",
     "language-git": "0.9.0",
-    "language-go": "0.14.0",
-    "language-html": "0.22.0",
-    "language-hyperlink": "0.10.0",
+    "language-go": "0.17.0",
+    "language-html": "0.26.0",
+    "language-hyperlink": "0.12.0",
     "language-java": "0.11.0",
-    "language-javascript": "0.36.0",
+    "language-javascript": "0.39.0",
     "language-json": "0.8.0",
-    "language-less": "0.13.0",
-    "language-make": "0.10.0",
+    "language-less": "0.15.0",
+    "language-make": "0.12.0",
+    "language-mustache": "0.10.0",
     "language-objective-c": "0.11.0",
     "language-perl": "0.9.0",
     "language-php": "0.15.0",
     "language-property-list": "0.7.0",
-    "language-python": "0.18.0",
-    "language-ruby": "0.33.0",
-    "language-ruby-on-rails": "0.15.0",
-    "language-sass": "0.14.0",
+    "language-python": "0.19.0",
+    "language-ruby": "0.36.0",
+    "language-ruby-on-rails": "0.18.0",
+    "language-sass": "0.21.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-todo": "0.11.0",
     "language-toml": "0.12.0",
-    "language-xml": "0.15.0",
-    "language-yaml": "0.13.0"
+    "language-xml": "0.20.0",
+    "language-yaml": "0.17.0"
   },
   "private": true,
   "scripts": {

resources/linux/Atom.desktop.in

@@ -5,4 +5,5 @@ Exec=<%= installDir %>/share/atom/atom %U
 Icon=<%= iconName %>
 Type=Application
 StartupNotify=true
-Categories=GNOME;GTK;Utility;TextEditor;
+Categories=GNOME;GTK;Utility;TextEditor;Development;
+MimeType=text/plain;

resources/linux/debian/control.in

@@ -3,6 +3,6 @@ Version: <%= version %>
 Section: <%= section %>
 Priority: optional
 Architecture: <%= arch %>
-Installed-Size: `du -ks usr|cut -f 1`
+Installed-Size: <%= installedSize %>
 Maintainer: <%= maintainer %>
 Description: <%= description %>

script/bootstrap

@@ -77,7 +77,7 @@ function bootstrap() {
     moduleInstallCommand,
     dedupeApmCommand + ' ' + packagesToDedupe.join(' '),
     {
-      command: dedupeNpmCommand + ' request',
+      command: dedupeNpmCommand + ' request semver',
       options: {
         cwd: path.resolve(__dirname, '..', 'apm', 'node_modules', 'atom-package-manager')
       }

script/clean

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

script/mkdeb

@@ -13,21 +13,22 @@ CONTROL_FILE="$3"
 DESKTOP_FILE="$4"
 ICON_FILE="$5"
 DEB_PATH="$6"
+FILE_MODE=755
 
 TARGET_ROOT="`mktemp -d`"
 chmod 755 "$TARGET_ROOT"
 TARGET="$TARGET_ROOT/atom-$VERSION-$ARCH"
 
-mkdir -p "$TARGET/usr"
+mkdir -m $FILE_MODE -p "$TARGET/usr"
 env INSTALL_PREFIX="$TARGET/usr" script/grunt install
 
-mkdir -p "$TARGET/DEBIAN"
+mkdir -m $FILE_MODE -p "$TARGET/DEBIAN"
 cp "$CONTROL_FILE" "$TARGET/DEBIAN/control"
 
-mkdir -p "$TARGET/usr/share/applications"
+mkdir -m $FILE_MODE -p "$TARGET/usr/share/applications"
 cp "$DESKTOP_FILE" "$TARGET/usr/share/applications"
 
-mkdir -p "$TARGET/usr/share/pixmaps"
+mkdir -m $FILE_MODE -p "$TARGET/usr/share/pixmaps"
 cp "$ICON_FILE" "$TARGET/usr/share/pixmaps"
 
 dpkg-deb -b "$TARGET"

spec/atom-reporter.coffee

@@ -119,14 +119,14 @@ class AtomReporter extends View
     grim.clearDeprecations()
 
   handleEvents: ->
-    $(document).on "click", ".spec-toggle", ({currentTarget}) =>
+    $(document).on "click", ".spec-toggle", ({currentTarget}) ->
       element = $(currentTarget)
       specFailures = element.parent().find('.spec-failures')
       specFailures.toggle()
       element.toggleClass('folded')
       false
 
-    $(document).on "click", ".deprecation-toggle", ({currentTarget}) =>
+    $(document).on "click", ".deprecation-toggle", ({currentTarget}) ->
       element = $(currentTarget)
       deprecationList = $(document).find('.deprecation-list')
       deprecationList.toggle()

spec/atom-spec.coffee

@@ -241,15 +241,15 @@ describe "the `atom` global", ->
               two = atom.themes.stringToId(two)
               three = atom.themes.stringToId(three)
 
-              expect(atom.themes.stylesheetElementForId(one)).not.toExist()
-              expect(atom.themes.stylesheetElementForId(two)).not.toExist()
-              expect(atom.themes.stylesheetElementForId(three)).not.toExist()
+              expect(atom.themes.stylesheetElementForId(one)).toBeNull()
+              expect(atom.themes.stylesheetElementForId(two)).toBeNull()
+              expect(atom.themes.stylesheetElementForId(three)).toBeNull()
 
               atom.packages.activatePackage("package-with-stylesheets-manifest")
 
-              expect(atom.themes.stylesheetElementForId(one)).toExist()
-              expect(atom.themes.stylesheetElementForId(two)).toExist()
-              expect(atom.themes.stylesheetElementForId(three)).not.toExist()
+              expect(atom.themes.stylesheetElementForId(one)).not.toBeNull()
+              expect(atom.themes.stylesheetElementForId(two)).not.toBeNull()
+              expect(atom.themes.stylesheetElementForId(three)).toBeNull()
               expect($('#jasmine-content').css('font-size')).toBe '1px'
 
           describe "when the metadata does not contain a 'stylesheets' manifest", ->
@@ -263,14 +263,14 @@ describe "the `atom` global", ->
               two = atom.themes.stringToId(two)
               three = atom.themes.stringToId(three)
 
-              expect(atom.themes.stylesheetElementForId(one)).not.toExist()
-              expect(atom.themes.stylesheetElementForId(two)).not.toExist()
-              expect(atom.themes.stylesheetElementForId(three)).not.toExist()
+              expect(atom.themes.stylesheetElementForId(one)).toBeNull()
+              expect(atom.themes.stylesheetElementForId(two)).toBeNull()
+              expect(atom.themes.stylesheetElementForId(three)).toBeNull()
 
               atom.packages.activatePackage("package-with-stylesheets")
-              expect(atom.themes.stylesheetElementForId(one)).toExist()
-              expect(atom.themes.stylesheetElementForId(two)).toExist()
-              expect(atom.themes.stylesheetElementForId(three)).toExist()
+              expect(atom.themes.stylesheetElementForId(one)).not.toBeNull()
+              expect(atom.themes.stylesheetElementForId(two)).not.toBeNull()
+              expect(atom.themes.stylesheetElementForId(three)).not.toBeNull()
               expect($('#jasmine-content').css('font-size')).toBe '3px'
 
         describe "grammar loading", ->
@@ -493,13 +493,14 @@ describe "the `atom` global", ->
             expect(atom.config.get('core.disabledPackages')).toContain packageName
 
       describe "with themes", ->
+        reloadedHandler = null
+
         beforeEach ->
           waitsForPromise ->
             atom.themes.activateThemes()
 
         afterEach ->
           atom.themes.deactivateThemes()
-          atom.config.unobserve('core.themes')
 
         it ".enablePackage() and .disablePackage() enables and disables a theme", ->
           packageName = 'theme-with-package-file'
@@ -517,13 +518,17 @@ describe "the `atom` global", ->
             expect(atom.config.get('core.themes')).toContain packageName
             expect(atom.config.get('core.disabledPackages')).not.toContain packageName
 
-            # disabling of theme
+            reloadedHandler = jasmine.createSpy('reloadedHandler')
+            reloadedHandler.reset()
+            atom.themes.onDidReloadAll reloadedHandler
+
             pack = atom.packages.disablePackage(packageName)
 
           waitsFor ->
-            not (pack in atom.packages.getActivePackages())
+            reloadedHandler.callCount is 1
 
           runs ->
+            expect(atom.packages.getActivePackages()).not.toContain pack
             expect(atom.config.get('core.themes')).not.toContain packageName
             expect(atom.config.get('core.themes')).not.toContain packageName
             expect(atom.config.get('core.disabledPackages')).not.toContain packageName
@@ -531,7 +536,7 @@ describe "the `atom` global", ->
   describe ".isReleasedVersion()", ->
     it "returns false if the version is a SHA and true otherwise", ->
       version = '0.1.0'
-      spyOn(atom.constructor, 'getVersion').andCallFake -> version
+      spyOn(atom, 'getVersion').andCallFake -> version
       expect(atom.isReleasedVersion()).toBe true
       version = '36b5518'
       expect(atom.isReleasedVersion()).toBe false

spec/config-spec.coffee

@@ -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

spec/context-menu-manager-spec.coffee

@@ -6,7 +6,8 @@ describe "ContextMenuManager", ->
   [contextMenu] = []
 
   beforeEach ->
-    contextMenu = new ContextMenuManager
+    {resourcePath} = atom.getLoadSettings()
+    contextMenu = new ContextMenuManager({resourcePath})
 
   describe "adding definitions", ->
     it 'loads',  ->

spec/display-buffer-spec.coffee

@@ -9,7 +9,7 @@ describe "DisplayBuffer", ->
     buffer = atom.project.bufferForPathSync('sample.js')
     displayBuffer = new DisplayBuffer({buffer, tabLength})
     changeHandler = jasmine.createSpy 'changeHandler'
-    displayBuffer.on 'changed', changeHandler
+    displayBuffer.onDidChange changeHandler
 
     waitsForPromise ->
       atom.packages.activatePackage('language-javascript')
@@ -58,7 +58,7 @@ describe "DisplayBuffer", ->
 
   describe "soft wrapping", ->
     beforeEach ->
-      displayBuffer.setSoftWrap(true)
+      displayBuffer.setSoftWrapped(true)
       displayBuffer.setEditorWidthInChars(50)
       changeHandler.reset()
 
@@ -67,48 +67,48 @@ describe "DisplayBuffer", ->
         it "uses the preferred line length as the soft wrap column when it is less than the configured soft wrap column", ->
           atom.config.set('editor.preferredLineLength', 100)
           atom.config.set('editor.softWrapAtPreferredLineLength', true)
-          expect(displayBuffer.lineForRow(10).text).toBe '    return '
+          expect(displayBuffer.tokenizedLineForScreenRow(10).text).toBe '    return '
 
           atom.config.set('editor.preferredLineLength', 5)
-          expect(displayBuffer.lineForRow(10).text).toBe 'funct'
+          expect(displayBuffer.tokenizedLineForScreenRow(10).text).toBe 'funct'
 
           atom.config.set('editor.softWrapAtPreferredLineLength', false)
-          expect(displayBuffer.lineForRow(10).text).toBe '    return '
+          expect(displayBuffer.tokenizedLineForScreenRow(10).text).toBe '    return '
 
       describe "when the line is shorter than the max line length", ->
         it "renders the line unchanged", ->
-          expect(displayBuffer.lineForRow(0).text).toBe buffer.lineForRow(0)
+          expect(displayBuffer.tokenizedLineForScreenRow(0).text).toBe buffer.lineForRow(0)
 
       describe "when the line is empty", ->
         it "renders the empty line", ->
-          expect(displayBuffer.lineForRow(13).text).toBe ''
+          expect(displayBuffer.tokenizedLineForScreenRow(13).text).toBe ''
 
       describe "when there is a non-whitespace character at the max length boundary", ->
         describe "when there is whitespace before the boundary", ->
           it "wraps the line at the end of the first whitespace preceding the boundary", ->
-            expect(displayBuffer.lineForRow(10).text).toBe '    return '
-            expect(displayBuffer.lineForRow(11).text).toBe 'sort(left).concat(pivot).concat(sort(right));'
+            expect(displayBuffer.tokenizedLineForScreenRow(10).text).toBe '    return '
+            expect(displayBuffer.tokenizedLineForScreenRow(11).text).toBe 'sort(left).concat(pivot).concat(sort(right));'
 
         describe "when there is no whitespace before the boundary", ->
           it "wraps the line exactly at the boundary since there's no more graceful place to wrap it", ->
             buffer.setTextInRange([[0, 0], [1, 0]], 'abcdefghijklmnopqrstuvwxyz\n')
             displayBuffer.setEditorWidthInChars(10)
-            expect(displayBuffer.lineForRow(0).text).toBe 'abcdefghij'
-            expect(displayBuffer.lineForRow(1).text).toBe 'klmnopqrst'
-            expect(displayBuffer.lineForRow(2).text).toBe 'uvwxyz'
+            expect(displayBuffer.tokenizedLineForScreenRow(0).text).toBe 'abcdefghij'
+            expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe 'klmnopqrst'
+            expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe 'uvwxyz'
 
       describe "when there is a whitespace character at the max length boundary", ->
         it "wraps the line at the first non-whitespace character following the boundary", ->
-          expect(displayBuffer.lineForRow(3).text).toBe '    var pivot = items.shift(), current, left = [], '
-          expect(displayBuffer.lineForRow(4).text).toBe 'right = [];'
+          expect(displayBuffer.tokenizedLineForScreenRow(3).text).toBe '    var pivot = items.shift(), current, left = [], '
+          expect(displayBuffer.tokenizedLineForScreenRow(4).text).toBe 'right = [];'
 
       describe "when there are hard tabs", ->
         beforeEach ->
           buffer.setText(buffer.getText().replace(new RegExp('  ', 'g'), '\t'))
 
         it "correctly tokenizes the hard tabs", ->
-          expect(displayBuffer.lineForRow(3).tokens[0].isHardTab).toBeTruthy()
-          expect(displayBuffer.lineForRow(3).tokens[1].isHardTab).toBeTruthy()
+          expect(displayBuffer.tokenizedLineForScreenRow(3).tokens[0].isHardTab).toBeTruthy()
+          expect(displayBuffer.tokenizedLineForScreenRow(3).tokens[1].isHardTab).toBeTruthy()
 
     describe "when the buffer changes", ->
       describe "when buffer lines are updated", ->
@@ -121,57 +121,57 @@ describe "DisplayBuffer", ->
         describe "when the update makes a soft-wrapped line shorter than the max line length", ->
           it "rewraps the line and emits a change event", ->
             buffer.delete([[6, 24], [6, 42]])
-            expect(displayBuffer.lineForRow(7).text).toBe '      current < pivot ?  : right.push(current);'
-            expect(displayBuffer.lineForRow(8).text).toBe '    }'
+            expect(displayBuffer.tokenizedLineForScreenRow(7).text).toBe '      current < pivot ?  : right.push(current);'
+            expect(displayBuffer.tokenizedLineForScreenRow(8).text).toBe '    }'
 
             expect(changeHandler).toHaveBeenCalled()
             [[event]]= changeHandler.argsForCall
 
             expect(event).toEqual(start: 7, end: 8, screenDelta: -1, bufferDelta: 0)
 
-        describe "when the update causes a line to softwrap an additional time", ->
+        describe "when the update causes a line to soft wrap an additional time", ->
           it "rewraps the line and emits a change event", ->
             buffer.insert([6, 28], '1234567890')
-            expect(displayBuffer.lineForRow(7).text).toBe '      current < pivot ? '
-            expect(displayBuffer.lineForRow(8).text).toBe 'left1234567890.push(current) : '
-            expect(displayBuffer.lineForRow(9).text).toBe 'right.push(current);'
-            expect(displayBuffer.lineForRow(10).text).toBe '    }'
+            expect(displayBuffer.tokenizedLineForScreenRow(7).text).toBe '      current < pivot ? '
+            expect(displayBuffer.tokenizedLineForScreenRow(8).text).toBe 'left1234567890.push(current) : '
+            expect(displayBuffer.tokenizedLineForScreenRow(9).text).toBe 'right.push(current);'
+            expect(displayBuffer.tokenizedLineForScreenRow(10).text).toBe '    }'
 
             expect(changeHandler).toHaveBeenCalledWith(start: 7, end: 8, screenDelta: 1, bufferDelta: 0)
 
       describe "when buffer lines are inserted", ->
         it "inserts / updates wrapped lines and emits a change event", ->
           buffer.insert([6, 21], '1234567890 abcdefghij 1234567890\nabcdefghij')
-          expect(displayBuffer.lineForRow(7).text).toBe '      current < pivot1234567890 abcdefghij '
-          expect(displayBuffer.lineForRow(8).text).toBe '1234567890'
-          expect(displayBuffer.lineForRow(9).text).toBe 'abcdefghij ? left.push(current) : '
-          expect(displayBuffer.lineForRow(10).text).toBe 'right.push(current);'
+          expect(displayBuffer.tokenizedLineForScreenRow(7).text).toBe '      current < pivot1234567890 abcdefghij '
+          expect(displayBuffer.tokenizedLineForScreenRow(8).text).toBe '1234567890'
+          expect(displayBuffer.tokenizedLineForScreenRow(9).text).toBe 'abcdefghij ? left.push(current) : '
+          expect(displayBuffer.tokenizedLineForScreenRow(10).text).toBe 'right.push(current);'
 
           expect(changeHandler).toHaveBeenCalledWith(start: 7, end: 8, screenDelta: 2, bufferDelta: 1)
 
       describe "when buffer lines are removed", ->
         it "removes lines and emits a change event", ->
           buffer.setTextInRange([[3, 21], [7, 5]], ';')
-          expect(displayBuffer.lineForRow(3).text).toBe '    var pivot = items;'
-          expect(displayBuffer.lineForRow(4).text).toBe '    return '
-          expect(displayBuffer.lineForRow(5).text).toBe 'sort(left).concat(pivot).concat(sort(right));'
-          expect(displayBuffer.lineForRow(6).text).toBe '  };'
+          expect(displayBuffer.tokenizedLineForScreenRow(3).text).toBe '    var pivot = items;'
+          expect(displayBuffer.tokenizedLineForScreenRow(4).text).toBe '    return '
+          expect(displayBuffer.tokenizedLineForScreenRow(5).text).toBe 'sort(left).concat(pivot).concat(sort(right));'
+          expect(displayBuffer.tokenizedLineForScreenRow(6).text).toBe '  };'
 
           expect(changeHandler).toHaveBeenCalledWith(start: 3, end: 9, screenDelta: -6, bufferDelta: -4)
 
       describe "when a newline is inserted, deleted, and re-inserted at the end of a wrapped line (regression)", ->
         it "correctly renders the original wrapped line", ->
           buffer = atom.project.buildBufferSync(null, '')
-          displayBuffer = new DisplayBuffer({buffer, tabLength, editorWidthInChars: 30, softWrap: true})
+          displayBuffer = new DisplayBuffer({buffer, tabLength, editorWidthInChars: 30, softWrapped: true})
 
           buffer.insert([0, 0], "the quick brown fox jumps over the lazy dog.")
           buffer.insert([0, Infinity], '\n')
           buffer.delete([[0, Infinity], [1, 0]])
           buffer.insert([0, Infinity], '\n')
 
-          expect(displayBuffer.lineForRow(0).text).toBe "the quick brown fox jumps over "
-          expect(displayBuffer.lineForRow(1).text).toBe "the lazy dog."
-          expect(displayBuffer.lineForRow(2).text).toBe ""
+          expect(displayBuffer.tokenizedLineForScreenRow(0).text).toBe "the quick brown fox jumps over "
+          expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe "the lazy dog."
+          expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe ""
 
     describe "position translation", ->
       it "translates positions accounting for wrapped lines", ->
@@ -204,9 +204,9 @@ describe "DisplayBuffer", ->
     describe ".setEditorWidthInChars(length)", ->
       it "changes the length at which lines are wrapped and emits a change event for all screen lines", ->
         displayBuffer.setEditorWidthInChars(40)
-        expect(tokensText displayBuffer.lineForRow(4).tokens).toBe 'left = [], right = [];'
-        expect(tokensText displayBuffer.lineForRow(5).tokens).toBe '    while(items.length > 0) {'
-        expect(tokensText displayBuffer.lineForRow(12).tokens).toBe 'sort(left).concat(pivot).concat(sort(rig'
+        expect(tokensText displayBuffer.tokenizedLineForScreenRow(4).tokens).toBe 'left = [], right = [];'
+        expect(tokensText displayBuffer.tokenizedLineForScreenRow(5).tokens).toBe '    while(items.length > 0) {'
+        expect(tokensText displayBuffer.tokenizedLineForScreenRow(12).tokens).toBe 'sort(left).concat(pivot).concat(sort(rig'
         expect(changeHandler).toHaveBeenCalledWith(start: 0, end: 15, screenDelta: 3, bufferDelta: 0)
 
       it "only allows positive widths to be assigned", ->
@@ -220,10 +220,10 @@ describe "DisplayBuffer", ->
       displayBuffer.setWidth(50)
       displayBuffer.manageScrollPosition = true
 
-      displayBuffer.setSoftWrap(false)
+      displayBuffer.setSoftWrapped(false)
       displayBuffer.setScrollLeft(Infinity)
       expect(displayBuffer.getScrollLeft()).toBeGreaterThan 0
-      displayBuffer.setSoftWrap(true)
+      displayBuffer.setSoftWrapped(true)
       expect(displayBuffer.getScrollLeft()).toBe 0
       displayBuffer.setScrollLeft(10)
       expect(displayBuffer.getScrollLeft()).toBe 0
@@ -234,7 +234,7 @@ describe "DisplayBuffer", ->
       buffer.release()
       buffer = atom.project.bufferForPathSync('two-hundred.txt')
       displayBuffer = new DisplayBuffer({buffer, tabLength})
-      displayBuffer.on 'changed', changeHandler
+      displayBuffer.onDidChange changeHandler
 
     describe "when folds are created and destroyed", ->
       describe "when a fold spans multiple lines", ->
@@ -242,7 +242,7 @@ describe "DisplayBuffer", ->
           fold = displayBuffer.createFold(4, 7)
           expect(fold).toBeDefined()
 
-          [line4, line5] = displayBuffer.linesForRows(4, 5)
+          [line4, line5] = displayBuffer.tokenizedLinesForScreenRows(4, 5)
           expect(line4.fold).toBe fold
           expect(line4.text).toMatch /^4-+/
           expect(line5.text).toBe '8'
@@ -251,7 +251,7 @@ describe "DisplayBuffer", ->
           changeHandler.reset()
 
           fold.destroy()
-          [line4, line5] = displayBuffer.linesForRows(4, 5)
+          [line4, line5] = displayBuffer.tokenizedLinesForScreenRows(4, 5)
           expect(line4.fold).toBeUndefined()
           expect(line4.text).toMatch /^4-+/
           expect(line5.text).toBe '5'
@@ -262,7 +262,7 @@ describe "DisplayBuffer", ->
         it "renders a fold placeholder for the folded line but does not skip any lines", ->
           fold = displayBuffer.createFold(4, 4)
 
-          [line4, line5] = displayBuffer.linesForRows(4, 5)
+          [line4, line5] = displayBuffer.tokenizedLinesForScreenRows(4, 5)
           expect(line4.fold).toBe fold
           expect(line4.text).toMatch /^4-+/
           expect(line5.text).toBe '5'
@@ -275,7 +275,7 @@ describe "DisplayBuffer", ->
 
           fold.destroy()
 
-          [line4, line5] = displayBuffer.linesForRows(4, 5)
+          [line4, line5] = displayBuffer.tokenizedLinesForScreenRows(4, 5)
           expect(line4.fold).toBeUndefined()
           expect(line4.text).toMatch /^4-+/
           expect(line5.text).toBe '5'
@@ -287,13 +287,13 @@ describe "DisplayBuffer", ->
           innerFold = displayBuffer.createFold(6, 7)
           outerFold = displayBuffer.createFold(4, 8)
 
-          [line4, line5] = displayBuffer.linesForRows(4, 5)
+          [line4, line5] = displayBuffer.tokenizedLinesForScreenRows(4, 5)
           expect(line4.fold).toBe outerFold
           expect(line4.text).toMatch /4-+/
           expect(line5.text).toMatch /9-+/
 
           outerFold.destroy()
-          [line4, line5, line6, line7] = displayBuffer.linesForRows(4, 7)
+          [line4, line5, line6, line7] = displayBuffer.tokenizedLinesForScreenRows(4, 7)
           expect(line4.fold).toBeUndefined()
           expect(line4.text).toMatch /^4-+/
           expect(line5.text).toBe '5'
@@ -305,7 +305,7 @@ describe "DisplayBuffer", ->
           innerFold = displayBuffer.createFold(4, 6)
           outerFold = displayBuffer.createFold(4, 8)
 
-          [line4, line5] = displayBuffer.linesForRows(4, 5)
+          [line4, line5] = displayBuffer.tokenizedLinesForScreenRows(4, 5)
           expect(line4.fold).toBe outerFold
           expect(line4.text).toMatch /4-+/
           expect(line5.text).toMatch /9-+/
@@ -326,14 +326,14 @@ describe "DisplayBuffer", ->
 
           innerFold = displayBuffer.createFold(2, 5)
           expect(changeHandler).not.toHaveBeenCalled()
-          [line0, line1] = displayBuffer.linesForRows(0, 1)
+          [line0, line1] = displayBuffer.tokenizedLinesForScreenRows(0, 1)
           expect(line0.fold).toBe outerFold
           expect(line1.fold).toBeUndefined()
 
           changeHandler.reset()
           innerFold.destroy()
           expect(changeHandler).not.toHaveBeenCalled()
-          [line0, line1] = displayBuffer.linesForRows(0, 1)
+          [line0, line1] = displayBuffer.tokenizedLinesForScreenRows(0, 1)
           expect(line0.fold).toBe outerFold
           expect(line1.fold).toBeUndefined()
 
@@ -342,8 +342,8 @@ describe "DisplayBuffer", ->
           fold2 = displayBuffer.createFold(4, 9)
           fold1 = displayBuffer.createFold(0, 4)
 
-          expect(displayBuffer.lineForRow(0).text).toMatch /^0/
-          expect(displayBuffer.lineForRow(1).text).toMatch /^10/
+          expect(displayBuffer.tokenizedLineForScreenRow(0).text).toMatch /^0/
+          expect(displayBuffer.tokenizedLineForScreenRow(1).text).toMatch /^10/
 
       describe "when there is another display buffer pointing to the same buffer", ->
         it "does not create folds in the other display buffer", ->
@@ -363,19 +363,19 @@ describe "DisplayBuffer", ->
           buffer.setTextInRange([[1, 0], [5, 1]], 'party!')
 
         it "removes the fold and replaces the selection with the new text", ->
-          expect(displayBuffer.lineForRow(0).text).toBe "0"
-          expect(displayBuffer.lineForRow(1).text).toBe "party!"
-          expect(displayBuffer.lineForRow(2).fold).toBe fold2
-          expect(displayBuffer.lineForRow(3).text).toMatch /^9-+/
+          expect(displayBuffer.tokenizedLineForScreenRow(0).text).toBe "0"
+          expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe "party!"
+          expect(displayBuffer.tokenizedLineForScreenRow(2).fold).toBe fold2
+          expect(displayBuffer.tokenizedLineForScreenRow(3).text).toMatch /^9-+/
 
           expect(changeHandler).toHaveBeenCalledWith(start: 1, end: 3, screenDelta: -2, bufferDelta: -4)
 
         describe "when the changes is subsequently undone", ->
           xit "restores destroyed folds", ->
             buffer.undo()
-            expect(displayBuffer.lineForRow(2).text).toBe '2'
-            expect(displayBuffer.lineForRow(2).fold).toBe fold1
-            expect(displayBuffer.lineForRow(3).text).toBe '5'
+            expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe '2'
+            expect(displayBuffer.tokenizedLineForScreenRow(2).fold).toBe fold1
+            expect(displayBuffer.tokenizedLineForScreenRow(3).text).toBe '5'
 
       describe "when the old range surrounds two nested folds", ->
         it "removes both folds and replaces the selection with the new text", ->
@@ -384,9 +384,9 @@ describe "DisplayBuffer", ->
 
           buffer.setTextInRange([[1, 0], [10, 0]], 'goodbye')
 
-          expect(displayBuffer.lineForRow(0).text).toBe "0"
-          expect(displayBuffer.lineForRow(1).text).toBe "goodbye10"
-          expect(displayBuffer.lineForRow(2).text).toBe "11"
+          expect(displayBuffer.tokenizedLineForScreenRow(0).text).toBe "0"
+          expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe "goodbye10"
+          expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe "11"
 
           expect(changeHandler).toHaveBeenCalledWith(start: 1, end: 3, screenDelta: -2, bufferDelta: -9)
 
@@ -403,42 +403,42 @@ describe "DisplayBuffer", ->
           it "updates the buffer and re-positions subsequent folds", ->
             buffer.setTextInRange([[0, 0], [1, 1]], 'abc')
 
-            expect(displayBuffer.lineForRow(0).text).toBe "abc"
-            expect(displayBuffer.lineForRow(1).fold).toBe fold1
-            expect(displayBuffer.lineForRow(2).text).toBe "5"
-            expect(displayBuffer.lineForRow(3).fold).toBe fold2
-            expect(displayBuffer.lineForRow(4).text).toMatch /^9-+/
+            expect(displayBuffer.tokenizedLineForScreenRow(0).text).toBe "abc"
+            expect(displayBuffer.tokenizedLineForScreenRow(1).fold).toBe fold1
+            expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe "5"
+            expect(displayBuffer.tokenizedLineForScreenRow(3).fold).toBe fold2
+            expect(displayBuffer.tokenizedLineForScreenRow(4).text).toMatch /^9-+/
 
             expect(changeHandler).toHaveBeenCalledWith(start: 0, end: 1, screenDelta: -1, bufferDelta: -1)
             changeHandler.reset()
 
             fold1.destroy()
-            expect(displayBuffer.lineForRow(0).text).toBe "abc"
-            expect(displayBuffer.lineForRow(1).text).toBe "2"
-            expect(displayBuffer.lineForRow(3).text).toMatch /^4-+/
-            expect(displayBuffer.lineForRow(4).text).toBe "5"
-            expect(displayBuffer.lineForRow(5).fold).toBe fold2
-            expect(displayBuffer.lineForRow(6).text).toMatch /^9-+/
+            expect(displayBuffer.tokenizedLineForScreenRow(0).text).toBe "abc"
+            expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe "2"
+            expect(displayBuffer.tokenizedLineForScreenRow(3).text).toMatch /^4-+/
+            expect(displayBuffer.tokenizedLineForScreenRow(4).text).toBe "5"
+            expect(displayBuffer.tokenizedLineForScreenRow(5).fold).toBe fold2
+            expect(displayBuffer.tokenizedLineForScreenRow(6).text).toMatch /^9-+/
 
             expect(changeHandler).toHaveBeenCalledWith(start: 1, end: 1, screenDelta: 2, bufferDelta: 0)
 
       describe "when the old range straddles the beginning of a fold", ->
         it "destroys the fold", ->
           buffer.setTextInRange([[1, 1], [3, 0]], "a\nb\nc\nd\n")
-          expect(displayBuffer.lineForRow(1).text).toBe '1a'
-          expect(displayBuffer.lineForRow(2).text).toBe 'b'
-          expect(displayBuffer.lineForRow(2).fold).toBeUndefined()
-          expect(displayBuffer.lineForRow(3).text).toBe 'c'
+          expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe '1a'
+          expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe 'b'
+          expect(displayBuffer.tokenizedLineForScreenRow(2).fold).toBeUndefined()
+          expect(displayBuffer.tokenizedLineForScreenRow(3).text).toBe 'c'
 
       describe "when the old range follows a fold", ->
         it "re-positions the screen ranges for the change event based on the preceding fold", ->
           buffer.setTextInRange([[10, 0], [11, 0]], 'abc')
 
-          expect(displayBuffer.lineForRow(1).text).toBe "1"
-          expect(displayBuffer.lineForRow(2).fold).toBe fold1
-          expect(displayBuffer.lineForRow(3).text).toBe "5"
-          expect(displayBuffer.lineForRow(4).fold).toBe fold2
-          expect(displayBuffer.lineForRow(5).text).toMatch /^9-+/
+          expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe "1"
+          expect(displayBuffer.tokenizedLineForScreenRow(2).fold).toBe fold1
+          expect(displayBuffer.tokenizedLineForScreenRow(3).text).toBe "5"
+          expect(displayBuffer.tokenizedLineForScreenRow(4).fold).toBe fold2
+          expect(displayBuffer.tokenizedLineForScreenRow(5).text).toMatch /^9-+/
 
           expect(changeHandler).toHaveBeenCalledWith(start: 6, end: 7, screenDelta: -1, bufferDelta: -1)
 
@@ -449,12 +449,12 @@ describe "DisplayBuffer", ->
             expect(fold1.getStartRow()).toBe 2
             expect(fold1.getEndRow()).toBe 5
 
-            expect(displayBuffer.lineForRow(1).text).toBe "1"
-            expect(displayBuffer.lineForRow(2).text).toBe "2"
-            expect(displayBuffer.lineForRow(2).fold).toBe fold1
-            expect(displayBuffer.lineForRow(3).text).toMatch "5"
-            expect(displayBuffer.lineForRow(4).fold).toBe fold2
-            expect(displayBuffer.lineForRow(5).text).toMatch /^9-+/
+            expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe "1"
+            expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe "2"
+            expect(displayBuffer.tokenizedLineForScreenRow(2).fold).toBe fold1
+            expect(displayBuffer.tokenizedLineForScreenRow(3).text).toMatch "5"
+            expect(displayBuffer.tokenizedLineForScreenRow(4).fold).toBe fold2
+            expect(displayBuffer.tokenizedLineForScreenRow(5).text).toMatch /^9-+/
 
             expect(changeHandler).toHaveBeenCalledWith(start: 2, end: 2, screenDelta: 0, bufferDelta: 1)
 
@@ -464,12 +464,12 @@ describe "DisplayBuffer", ->
             expect(fold1.getStartRow()).toBe 2
             expect(fold1.getEndRow()).toBe 7
 
-            expect(displayBuffer.lineForRow(1).text).toBe "1"
-            expect(displayBuffer.lineForRow(2).text).toBe "2"
-            expect(displayBuffer.lineForRow(2).fold).toBe fold1
-            expect(displayBuffer.lineForRow(3).text).toMatch "5"
-            expect(displayBuffer.lineForRow(4).fold).toBe fold2
-            expect(displayBuffer.lineForRow(5).text).toMatch /^9-+/
+            expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe "1"
+            expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe "2"
+            expect(displayBuffer.tokenizedLineForScreenRow(2).fold).toBe fold1
+            expect(displayBuffer.tokenizedLineForScreenRow(3).text).toMatch "5"
+            expect(displayBuffer.tokenizedLineForScreenRow(4).fold).toBe fold2
+            expect(displayBuffer.tokenizedLineForScreenRow(5).text).toMatch /^9-+/
 
             expect(changeHandler).toHaveBeenCalledWith(start: 2, end: 2, screenDelta: 0, bufferDelta: 3)
 
@@ -478,21 +478,21 @@ describe "DisplayBuffer", ->
           it "destroys the fold", ->
             fold2.destroy()
             buffer.setTextInRange([[3, 0], [6, 0]], 'a\n')
-            expect(displayBuffer.lineForRow(2).text).toBe '2'
-            expect(displayBuffer.lineForRow(2).fold).toBeUndefined()
-            expect(displayBuffer.lineForRow(3).text).toBe 'a'
-            expect(displayBuffer.lineForRow(4).text).toBe '6'
+            expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe '2'
+            expect(displayBuffer.tokenizedLineForScreenRow(2).fold).toBeUndefined()
+            expect(displayBuffer.tokenizedLineForScreenRow(3).text).toBe 'a'
+            expect(displayBuffer.tokenizedLineForScreenRow(4).text).toBe '6'
 
       describe "when the old range is contained to a single line in-between two folds", ->
         it "re-renders the line with the placeholder and re-positions the second fold", ->
           buffer.insert([5, 0], 'abc\n')
 
-          expect(displayBuffer.lineForRow(1).text).toBe "1"
-          expect(displayBuffer.lineForRow(2).fold).toBe fold1
-          expect(displayBuffer.lineForRow(3).text).toMatch "abc"
-          expect(displayBuffer.lineForRow(4).text).toBe "5"
-          expect(displayBuffer.lineForRow(5).fold).toBe fold2
-          expect(displayBuffer.lineForRow(6).text).toMatch /^9-+/
+          expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe "1"
+          expect(displayBuffer.tokenizedLineForScreenRow(2).fold).toBe fold1
+          expect(displayBuffer.tokenizedLineForScreenRow(3).text).toMatch "abc"
+          expect(displayBuffer.tokenizedLineForScreenRow(4).text).toBe "5"
+          expect(displayBuffer.tokenizedLineForScreenRow(5).fold).toBe fold2
+          expect(displayBuffer.tokenizedLineForScreenRow(6).text).toMatch /^9-+/
 
           expect(changeHandler).toHaveBeenCalledWith(start: 3, end: 3, screenDelta: 1, bufferDelta: 1)
 
@@ -545,15 +545,15 @@ describe "DisplayBuffer", ->
         displayBuffer.createFold(1, 9)
         displayBuffer.createFold(11, 12)
 
-        expect(displayBuffer.lineForRow(1).text).toBe '1'
-        expect(displayBuffer.lineForRow(2).text).toBe '10'
+        expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe '1'
+        expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe '10'
 
         displayBuffer.unfoldBufferRow(2)
-        expect(displayBuffer.lineForRow(1).text).toBe '1'
-        expect(displayBuffer.lineForRow(2).text).toBe '2'
-        expect(displayBuffer.lineForRow(7).fold).toBeDefined()
-        expect(displayBuffer.lineForRow(8).text).toMatch /^9-+/
-        expect(displayBuffer.lineForRow(10).fold).toBeDefined()
+        expect(displayBuffer.tokenizedLineForScreenRow(1).text).toBe '1'
+        expect(displayBuffer.tokenizedLineForScreenRow(2).text).toBe '2'
+        expect(displayBuffer.tokenizedLineForScreenRow(7).fold).toBeDefined()
+        expect(displayBuffer.tokenizedLineForScreenRow(8).text).toMatch /^9-+/
+        expect(displayBuffer.tokenizedLineForScreenRow(10).fold).toBeDefined()
 
     describe ".outermostFoldsInBufferRowRange(startRow, endRow)", ->
       it "returns the outermost folds entirely contained in the given row range, exclusive of end row", ->
@@ -568,7 +568,7 @@ describe "DisplayBuffer", ->
 
   describe "::clipScreenPosition(screenPosition, wrapBeyondNewlines: false, wrapAtSoftNewlines: false, skipAtomicTokens: false)", ->
     beforeEach ->
-      displayBuffer.setSoftWrap(true)
+      displayBuffer.setSoftWrapped(true)
       displayBuffer.setEditorWidthInChars(50)
 
     it "allows valid positions", ->
@@ -643,7 +643,7 @@ describe "DisplayBuffer", ->
 
     it "correctly translates positions on soft wrapped lines containing tabs", ->
       buffer.setText('\t\taa  bb  cc  dd  ee  ff  gg')
-      displayBuffer.setSoftWrap(true)
+      displayBuffer.setSoftWrapped(true)
       displayBuffer.setEditorWidthInChars(10)
       expect(displayBuffer.screenPositionForBufferPosition([0, 10], wrapAtSoftNewlines: true)).toEqual [1, 0]
       expect(displayBuffer.bufferPositionForScreenPosition([1, 0])).toEqual [0, 10]
@@ -686,7 +686,7 @@ describe "DisplayBuffer", ->
         expect(marker2.getScreenRange()).toEqual [[5, 4], [5, 10]]
 
       it "emits a 'marker-created' event on the DisplayBuffer whenever a marker is created", ->
-        displayBuffer.on 'marker-created', markerCreatedHandler = jasmine.createSpy("markerCreatedHandler")
+        displayBuffer.onDidCreateMarker markerCreatedHandler = jasmine.createSpy("markerCreatedHandler")
 
         marker1 = displayBuffer.markScreenRange([[5, 4], [5, 10]])
         expect(markerCreatedHandler).toHaveBeenCalledWith(marker1)
@@ -722,7 +722,7 @@ describe "DisplayBuffer", ->
 
       beforeEach ->
         marker = displayBuffer.markScreenRange([[5, 4], [5, 10]])
-        marker.on 'changed', markerChangedHandler = jasmine.createSpy("markerChangedHandler")
+        marker.onDidChange markerChangedHandler = jasmine.createSpy("markerChangedHandler")
 
       it "triggers the 'changed' event whenever the markers head's screen position changes in the buffer or on screen", ->
         marker.setHeadScreenPosition([8, 20])
@@ -859,8 +859,8 @@ describe "DisplayBuffer", ->
 
       it "updates markers before emitting buffer change events, but does not notify their observers until the change event", ->
         marker2 = displayBuffer.markBufferRange([[8, 1], [8, 1]])
-        marker2.on 'changed', marker2ChangedHandler = jasmine.createSpy("marker2ChangedHandler")
-        displayBuffer.on 'changed', changeHandler = jasmine.createSpy("changeHandler").andCallFake -> onDisplayBufferChange()
+        marker2.onDidChange marker2ChangedHandler = jasmine.createSpy("marker2ChangedHandler")
+        displayBuffer.onDidChange changeHandler = jasmine.createSpy("changeHandler").andCallFake -> onDisplayBufferChange()
 
         # New change ----
 
@@ -886,7 +886,7 @@ describe "DisplayBuffer", ->
         marker2ChangedHandler.reset()
 
         marker3 = displayBuffer.markBufferRange([[8, 1], [8, 2]])
-        marker3.on 'changed', marker3ChangedHandler = jasmine.createSpy("marker3ChangedHandler")
+        marker3.onDidChange marker3ChangedHandler = jasmine.createSpy("marker3ChangedHandler")
 
         onDisplayBufferChange = ->
           # calls change handler first
@@ -932,7 +932,7 @@ describe "DisplayBuffer", ->
         expect(marker3ChangedHandler).toHaveBeenCalled()
 
       it "updates the position of markers before emitting change events that aren't caused by a buffer change", ->
-        displayBuffer.on 'changed', changeHandler = jasmine.createSpy("changeHandler").andCallFake ->
+        displayBuffer.onDidChange changeHandler = jasmine.createSpy("changeHandler").andCallFake ->
           # calls change handler first
           expect(markerChangedHandler).not.toHaveBeenCalled()
           # but still updates the markers
@@ -998,16 +998,16 @@ describe "DisplayBuffer", ->
         expect(marker.isValid()).toBeFalsy()
         expect(displayBuffer.getMarker(marker.id)).toBeUndefined()
 
-      it "emits 'destroyed' events when markers are destroyed", ->
+      it "notifies ::onDidDestroy observers when markers are destroyed", ->
         destroyedHandler = jasmine.createSpy("destroyedHandler")
         marker = displayBuffer.markScreenRange([[5, 4], [5, 10]])
-        marker.on 'destroyed', destroyedHandler
+        marker.onDidDestroy destroyedHandler
         marker.destroy()
         expect(destroyedHandler).toHaveBeenCalled()
         destroyedHandler.reset()
 
         marker2 = displayBuffer.markScreenRange([[5, 4], [5, 10]])
-        marker2.on 'destroyed', destroyedHandler
+        marker2.onDidDestroy destroyedHandler
         buffer.getMarker(marker2.id).destroy()
         expect(destroyedHandler).toHaveBeenCalled()
 
@@ -1037,16 +1037,28 @@ describe "DisplayBuffer", ->
         expect(start.top).toBe 5 * 20
         expect(start.left).toBe (4 * 10) + (6 * 11)
 
+    describe 'when there are multiple DisplayBuffers for a buffer', ->
+      describe 'when a marker is created', ->
+        it 'the second display buffer will not emit a marker-created event when the marker has been deleted in the first marker-created event', ->
+          displayBuffer2 = new DisplayBuffer({buffer, tabLength})
+          displayBuffer.onDidCreateMarker markerCreated1 = jasmine.createSpy().andCallFake (marker) -> marker.destroy()
+          displayBuffer2.onDidCreateMarker markerCreated2 = jasmine.createSpy()
+
+          displayBuffer.markBufferRange([[0, 0], [1, 5]], {})
+
+          expect(markerCreated1).toHaveBeenCalled()
+          expect(markerCreated2).not.toHaveBeenCalled()
+
   describe "decorations", ->
-    [marker, decoration, decorationParams] = []
+    [marker, decoration, decorationProperties] = []
     beforeEach ->
       marker = displayBuffer.markBufferRange([[2, 13], [3, 15]])
-      decorationParams = {type: 'gutter', class: 'one'}
-      decoration = displayBuffer.decorateMarker(marker, decorationParams)
+      decorationProperties = {type: 'gutter', class: 'one'}
+      decoration = displayBuffer.decorateMarker(marker, decorationProperties)
 
     it "can add decorations associated with markers and remove them", ->
       expect(decoration).toBeDefined()
-      expect(decoration.getParams()).toBe decorationParams
+      expect(decoration.getProperties()).toBe decorationProperties
       expect(displayBuffer.decorationForId(decoration.id)).toBe decoration
       expect(displayBuffer.decorationsForScreenRowRange(2, 3)[marker.id][0]).toBe decoration
 
@@ -1061,12 +1073,12 @@ describe "DisplayBuffer", ->
 
     describe "when a decoration is updated via Decoration::update()", ->
       it "emits an 'updated' event containing the new and old params", ->
-        decoration.on 'updated', updatedSpy = jasmine.createSpy()
-        decoration.update type: 'gutter', class: 'two'
+        decoration.onDidChangeProperties updatedSpy = jasmine.createSpy()
+        decoration.setProperties type: 'gutter', class: 'two'
 
-        {oldParams, newParams} = updatedSpy.mostRecentCall.args[0]
-        expect(oldParams).toEqual decorationParams
-        expect(newParams).toEqual type: 'gutter', class: 'two', id: decoration.id
+        {oldProperties, newProperties} = updatedSpy.mostRecentCall.args[0]
+        expect(oldProperties).toEqual decorationProperties
+        expect(newProperties).toEqual type: 'gutter', class: 'two', id: decoration.id
 
   describe "::setScrollTop", ->
     beforeEach ->
@@ -1159,7 +1171,7 @@ describe "DisplayBuffer", ->
     it "recomputes the scroll width when the scoped character widths change in a batch", ->
       operatorWidth = 20
 
-      displayBuffer.on 'character-widths-changed', changedSpy = jasmine.createSpy()
+      displayBuffer.onDidChangeCharacterWidths changedSpy = jasmine.createSpy()
 
       displayBuffer.batchCharacterMeasurement ->
         displayBuffer.setScopedCharWidth(['source.js', 'keyword.operator.js'], '<', operatorWidth)

spec/fixtures/js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

spec/fixtures/sample-with-error.less

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

spec/fixtures/sample.plist

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

spec/fixtures/symlink-to-dir

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

spec/fixtures/symlink-to-file

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

spec/fixtures/zed/a

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

spec/git-spec.coffee

@@ -111,14 +111,46 @@ describe "Git", ->
       fs.writeFileSync(filePath, 'ch ch changes')
       repo.getPathStatus(filePath)
       statusHandler = jasmine.createSpy('statusHandler')
-      repo.on 'status-changed', statusHandler
+      repo.onDidChangeStatus statusHandler
       repo.checkoutHead(filePath)
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler.argsForCall[0][0..1]).toEqual [filePath, 0]
+      expect(statusHandler.argsForCall[0][0]).toEqual {path: filePath, pathStatus: 0}
 
       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'))
@@ -135,11 +167,11 @@ describe "Git", ->
 
     it "trigger a status-changed event when the new status differs from the last cached one", ->
       statusHandler = jasmine.createSpy("statusHandler")
-      repo.on 'status-changed', statusHandler
+      repo.onDidChangeStatus statusHandler
       fs.writeFileSync(filePath, '')
       status = repo.getPathStatus(filePath)
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler.argsForCall[0][0..1]).toEqual [filePath, status]
+      expect(statusHandler.argsForCall[0][0]).toEqual {path: filePath, pathStatus: status}
 
       fs.writeFileSync(filePath, 'abc')
       status = repo.getPathStatus(filePath)
@@ -176,7 +208,7 @@ describe "Git", ->
     it "returns status information for all new and modified files", ->
       fs.writeFileSync(modifiedPath, 'making this path modified')
       statusHandler = jasmine.createSpy('statusHandler')
-      repo.on 'statuses-changed', statusHandler
+      repo.onDidChangeStatuses statusHandler
       repo.refreshStatus()
 
       waitsFor ->
@@ -200,19 +232,19 @@ describe "Git", ->
       editor.insertNewline()
 
       statusHandler = jasmine.createSpy('statusHandler')
-      atom.project.getRepo().on 'status-changed', statusHandler
+      atom.project.getRepo().onDidChangeStatus statusHandler
       editor.save()
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler).toHaveBeenCalledWith editor.getPath(), 256
+      expect(statusHandler).toHaveBeenCalledWith {path: editor.getPath(), pathStatus: 256}
 
     it "emits a status-changed event when a buffer is reloaded", ->
       fs.writeFileSync(editor.getPath(), 'changed')
 
       statusHandler = jasmine.createSpy('statusHandler')
-      atom.project.getRepo().on 'status-changed', statusHandler
+      atom.project.getRepo().onDidChangeStatus statusHandler
       editor.getBuffer().reload()
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler).toHaveBeenCalledWith editor.getPath(), 256
+      expect(statusHandler).toHaveBeenCalledWith {path: editor.getPath(), pathStatus: 256}
       editor.getBuffer().reload()
       expect(statusHandler.callCount).toBe 1
 
@@ -220,11 +252,11 @@ describe "Git", ->
       fs.writeFileSync(editor.getPath(), 'changed')
 
       statusHandler = jasmine.createSpy('statusHandler')
-      atom.project.getRepo().on 'status-changed', statusHandler
-      editor.getBuffer().emit 'path-changed'
+      atom.project.getRepo().onDidChangeStatus statusHandler
+      editor.getBuffer().emitter.emit 'did-change-path'
       expect(statusHandler.callCount).toBe 1
-      expect(statusHandler).toHaveBeenCalledWith editor.getPath(), 256
-      editor.getBuffer().emit 'path-changed'
+      expect(statusHandler).toHaveBeenCalledWith {path: editor.getPath(), pathStatus: 256}
+      editor.getBuffer().emitter.emit 'did-change-path'
       expect(statusHandler.callCount).toBe 1
 
   describe "when a project is deserialized", ->
@@ -251,7 +283,7 @@ describe "Git", ->
         buffer.append('changes')
 
         statusHandler = jasmine.createSpy('statusHandler')
-        project2.getRepo().on 'status-changed', statusHandler
+        project2.getRepo().onDidChangeStatus statusHandler
         buffer.save()
         expect(statusHandler.callCount).toBe 1
-        expect(statusHandler).toHaveBeenCalledWith buffer.getPath(), 256
+        expect(statusHandler).toHaveBeenCalledWith {path: buffer.getPath(), pathStatus: 256}

spec/language-mode-spec.coffee

@@ -275,46 +275,46 @@ describe "LanguageMode", ->
       it "folds every foldable line", ->
         languageMode.foldAll()
 
-        fold1 = editor.lineForScreenRow(0).fold
+        fold1 = editor.tokenizedLineForScreenRow(0).fold
         expect([fold1.getStartRow(), fold1.getEndRow()]).toEqual [0, 12]
         fold1.destroy()
 
-        fold2 = editor.lineForScreenRow(1).fold
+        fold2 = editor.tokenizedLineForScreenRow(1).fold
         expect([fold2.getStartRow(), fold2.getEndRow()]).toEqual [1, 9]
         fold2.destroy()
 
-        fold3 = editor.lineForScreenRow(4).fold
+        fold3 = editor.tokenizedLineForScreenRow(4).fold
         expect([fold3.getStartRow(), fold3.getEndRow()]).toEqual [4, 7]
 
     describe ".foldBufferRow(bufferRow)", ->
       describe "when bufferRow can be folded", ->
         it "creates a fold based on the syntactic region starting at the given row", ->
           languageMode.foldBufferRow(1)
-          fold = editor.lineForScreenRow(1).fold
+          fold = editor.tokenizedLineForScreenRow(1).fold
           expect(fold.getStartRow()).toBe 1
           expect(fold.getEndRow()).toBe 9
 
       describe "when bufferRow can't be folded", ->
         it "searches upward for the first row that begins a syntatic region containing the given buffer row (and folds it)", ->
           languageMode.foldBufferRow(8)
-          fold = editor.lineForScreenRow(1).fold
+          fold = editor.tokenizedLineForScreenRow(1).fold
           expect(fold.getStartRow()).toBe 1
           expect(fold.getEndRow()).toBe 9
 
       describe "when the bufferRow is already folded", ->
         it "searches upward for the first row that begins a syntatic region containing the folded row (and folds it)", ->
           languageMode.foldBufferRow(2)
-          expect(editor.lineForScreenRow(1).fold).toBeDefined()
-          expect(editor.lineForScreenRow(0).fold).not.toBeDefined()
+          expect(editor.tokenizedLineForScreenRow(1).fold).toBeDefined()
+          expect(editor.tokenizedLineForScreenRow(0).fold).not.toBeDefined()
 
           languageMode.foldBufferRow(1)
-          expect(editor.lineForScreenRow(0).fold).toBeDefined()
+          expect(editor.tokenizedLineForScreenRow(0).fold).toBeDefined()
 
       describe "when the bufferRow is in a multi-line comment", ->
         it "searches upward and downward for surrounding comment lines and folds them as a single fold", ->
           buffer.insert([1,0], "  //this is a comment\n  // and\n  //more docs\n\n//second comment")
           languageMode.foldBufferRow(1)
-          fold = editor.lineForScreenRow(1).fold
+          fold = editor.tokenizedLineForScreenRow(1).fold
           expect(fold.getStartRow()).toBe 1
           expect(fold.getEndRow()).toBe 3
 
@@ -322,7 +322,7 @@ describe "LanguageMode", ->
         it "searches upward for the first row that begins a syntatic region containing the folded row (and folds it)", ->
           buffer.insert([1,0], "  //this is a single line comment\n")
           languageMode.foldBufferRow(1)
-          fold = editor.lineForScreenRow(0).fold
+          fold = editor.tokenizedLineForScreenRow(0).fold
           expect(fold.getStartRow()).toBe 0
           expect(fold.getEndRow()).toBe 13
 
@@ -357,38 +357,38 @@ describe "LanguageMode", ->
       it "folds every foldable line", ->
         languageMode.foldAll()
 
-        fold1 = editor.lineForScreenRow(0).fold
+        fold1 = editor.tokenizedLineForScreenRow(0).fold
         expect([fold1.getStartRow(), fold1.getEndRow()]).toEqual [0, 19]
         fold1.destroy()
 
-        fold2 = editor.lineForScreenRow(1).fold
+        fold2 = editor.tokenizedLineForScreenRow(1).fold
         expect([fold2.getStartRow(), fold2.getEndRow()]).toEqual [1, 4]
 
-        fold3 = editor.lineForScreenRow(2).fold.destroy()
+        fold3 = editor.tokenizedLineForScreenRow(2).fold.destroy()
 
-        fold4 = editor.lineForScreenRow(3).fold
+        fold4 = editor.tokenizedLineForScreenRow(3).fold
         expect([fold4.getStartRow(), fold4.getEndRow()]).toEqual [6, 8]
 
     describe ".foldAllAtIndentLevel()", ->
       it "folds every foldable range at a given indentLevel", ->
         languageMode.foldAllAtIndentLevel(2)
 
-        fold1 = editor.lineForScreenRow(6).fold
+        fold1 = editor.tokenizedLineForScreenRow(6).fold
         expect([fold1.getStartRow(), fold1.getEndRow()]).toEqual [6, 8]
         fold1.destroy()
 
-        fold2 = editor.lineForScreenRow(11).fold
+        fold2 = editor.tokenizedLineForScreenRow(11).fold
         expect([fold2.getStartRow(), fold2.getEndRow()]).toEqual [11, 14]
         fold2.destroy()
 
       it "does not fold anything but the indentLevel", ->
         languageMode.foldAllAtIndentLevel(0)
 
-        fold1 = editor.lineForScreenRow(0).fold
+        fold1 = editor.tokenizedLineForScreenRow(0).fold
         expect([fold1.getStartRow(), fold1.getEndRow()]).toEqual [0, 19]
         fold1.destroy()
 
-        fold2 = editor.lineForScreenRow(5).fold
+        fold2 = editor.tokenizedLineForScreenRow(5).fold
         expect(fold2).toBeFalsy()
 
     describe ".isFoldableAtBufferRow(bufferRow)", ->

spec/package-spec.coffee

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

spec/pane-container-spec.coffee

@@ -27,42 +27,91 @@ describe "PaneContainer", ->
 
     it "preserves the active pane across serialization, independent of focus", ->
       pane3A.activate()
-      expect(containerA.activePane).toBe pane3A
+      expect(containerA.getActivePane()).toBe pane3A
 
       containerB = containerA.testSerialization()
       [pane1B, pane2B, pane3B] = containerB.getPanes()
-      expect(containerB.activePane).toBe pane3B
+      expect(containerB.getActivePane()).toBe pane3B
 
-  describe "::activePane", ->
+  it "does not allow the root pane to be destroyed", ->
+    container = new PaneContainer
+    container.getRoot().destroy()
+    expect(container.getRoot()).toBeDefined()
+    expect(container.getRoot().isDestroyed()).toBe false
+
+  describe "::getActivePane()", ->
     [container, pane1, pane2] = []
 
     beforeEach ->
       container = new PaneContainer
-      pane1 = container.root
+      pane1 = container.getRoot()
 
-    it "references the first pane if no pane has been made active", ->
-      expect(container.activePane).toBe pane1
-      expect(pane1.active).toBe true
+    it "returns the first pane if no pane has been made active", ->
+      expect(container.getActivePane()).toBe pane1
+      expect(pane1.isActive()).toBe true
 
-    it "references the most pane on which ::activate was most recently called", ->
+    it "returns the most pane on which ::activate() was most recently called", ->
       pane2 = pane1.splitRight()
       pane2.activate()
-      expect(container.activePane).toBe pane2
-      expect(pane1.active).toBe false
-      expect(pane2.active).toBe true
+      expect(container.getActivePane()).toBe pane2
+      expect(pane1.isActive()).toBe false
+      expect(pane2.isActive()).toBe true
       pane1.activate()
-      expect(container.activePane).toBe pane1
-      expect(pane1.active).toBe true
-      expect(pane2.active).toBe false
+      expect(container.getActivePane()).toBe pane1
+      expect(pane1.isActive()).toBe true
+      expect(pane2.isActive()).toBe false
 
-    it "is reassigned to the next pane if the current active pane is destroyed", ->
+    it "returns the next pane if the current active pane is destroyed", ->
       pane2 = pane1.splitRight()
       pane2.activate()
       pane2.destroy()
-      expect(container.activePane).toBe pane1
-      expect(pane1.active).toBe true
+      expect(container.getActivePane()).toBe pane1
+      expect(pane1.isActive()).toBe true
 
-    it "does not allow the root pane to be destroyed", ->
-      pane1.destroy()
-      expect(container.root).toBe pane1
-      expect(pane1.isDestroyed()).toBe false
+  describe "::onDidChangeActivePaneItem()", ->
+    [container, pane1, pane2, observed] = []
+
+    beforeEach ->
+      container = new PaneContainer(root: new Pane(items: [new Object, new Object]))
+      container.getRoot().splitRight(items: [new Object, new Object])
+      [pane1, pane2] = container.getPanes()
+
+      observed = []
+      container.onDidChangeActivePaneItem (item) -> observed.push(item)
+
+    it "invokes observers when the active item of the active pane changes", ->
+      pane2.activateNextItem()
+      pane2.activateNextItem()
+      expect(observed).toEqual [pane2.itemAtIndex(1), pane2.itemAtIndex(0)]
+
+    it "invokes observers when the active pane changes", ->
+      pane1.activate()
+      pane2.activate()
+      expect(observed).toEqual [pane1.itemAtIndex(0), pane2.itemAtIndex(0)]
+
+  describe "::observePanes()", ->
+    it "invokes observers with all current and future panes", ->
+      container = new PaneContainer
+      container.getRoot().splitRight()
+      [pane1, pane2] = container.getPanes()
+
+      observed = []
+      container.observePanes (pane) -> observed.push(pane)
+
+      pane3 = pane2.splitDown()
+      pane4 = pane2.splitRight()
+
+      expect(observed).toEqual [pane1, pane2, pane3, pane4]
+
+  describe "::observePaneItems()", ->
+    it "invokes observers with all current and future pane items", ->
+      container = new PaneContainer(root: new Pane(items: [new Object, new Object]))
+      container.getRoot().splitRight(items: [new Object])
+      [pane1, pane2] = container.getPanes()
+      observed = []
+      container.observePaneItems (pane) -> observed.push(pane)
+
+      pane3 = pane2.splitDown(items: [new Object])
+      pane3.addItems([new Object, new Object])
+
+      expect(observed).toEqual container.getPaneItems()

spec/pane-spec.coffee

@@ -21,39 +21,83 @@ describe "Pane", ->
   describe "construction", ->
     it "sets the active item to the first item", ->
       pane = new Pane(items: [new Item("A"), new Item("B")])
-      expect(pane.activeItem).toBe pane.items[0]
+      expect(pane.getActiveItem()).toBe pane.itemAtIndex(0)
 
     it "compacts the items array", ->
       pane = new Pane(items: [undefined, new Item("A"), null, new Item("B")])
-      expect(pane.items.length).toBe 2
-      expect(pane.activeItem).toBe pane.items[0]
+      expect(pane.getItems().length).toBe 2
+      expect(pane.getActiveItem()).toBe pane.itemAtIndex(0)
+
+  describe "::activate()", ->
+    [container, pane1, pane2] = []
+
+    beforeEach ->
+      container = new PaneContainer(root: new Pane)
+      container.getRoot().splitRight()
+      [pane1, pane2] = container.getPanes()
+
+    it "changes the active pane on the container", ->
+      expect(container.getActivePane()).toBe pane2
+      pane1.activate()
+      expect(container.getActivePane()).toBe pane1
+      pane2.activate()
+      expect(container.getActivePane()).toBe pane2
+
+    it "invokes ::onDidChangeActivePane observers on the container", ->
+      observed = []
+      container.onDidChangeActivePane (activePane) -> observed.push(activePane)
+
+      pane1.activate()
+      pane1.activate()
+      pane2.activate()
+      pane1.activate()
+      expect(observed).toEqual [pane1, pane2, pane1]
+
+    it "invokes ::onDidChangeActive observers on the relevant panes", ->
+      observed = []
+      pane1.onDidChangeActive (active) -> observed.push(active)
+      pane1.activate()
+      pane2.activate()
+      expect(observed).toEqual [true, false]
+
+    it "invokes ::onDidActivate() observers", ->
+      eventCount = 0
+      pane1.onDidActivate -> eventCount++
+      pane1.activate()
+      pane1.activate()
+      pane2.activate()
+      expect(eventCount).toBe 2
 
   describe "::addItem(item, index)", ->
     it "adds the item at the given index", ->
       pane = new Pane(items: [new Item("A"), new Item("B")])
-      [item1, item2] = pane.items
+      [item1, item2] = pane.getItems()
       item3 = new Item("C")
       pane.addItem(item3, 1)
-      expect(pane.items).toEqual [item1, item3, item2]
+      expect(pane.getItems()).toEqual [item1, item3, item2]
 
-    it "adds the item after the active item ", ->
+    it "adds the item after the active item if no index is provided", ->
       pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C")])
-      [item1, item2, item3] = pane.items
+      [item1, item2, item3] = pane.getItems()
       pane.activateItem(item2)
       item4 = new Item("D")
       pane.addItem(item4)
-      expect(pane.items).toEqual [item1, item2, item4, item3]
+      expect(pane.getItems()).toEqual [item1, item2, item4, item3]
 
     it "sets the active item after adding the first item", ->
       pane = new Pane
       item = new Item("A")
-      events = []
-      pane.on 'item-added', -> events.push('item-added')
-      pane.$activeItem.changes.onValue -> events.push('active-item-changed')
-
       pane.addItem(item)
-      expect(pane.activeItem).toBe item
-      expect(events).toEqual ['item-added', 'active-item-changed']
+      expect(pane.getActiveItem()).toBe item
+
+    it "invokes ::onDidAddItem() observers", ->
+      pane = new Pane(items: [new Item("A"), new Item("B")])
+      events = []
+      pane.onDidAddItem (event) -> events.push(event)
+
+      item = new Item("C")
+      pane.addItem(item, 1)
+      expect(events).toEqual [{item, index: 1}]
 
   describe "::activateItem(item)", ->
     pane = null
@@ -62,83 +106,102 @@ describe "Pane", ->
       pane = new Pane(items: [new Item("A"), new Item("B")])
 
     it "changes the active item to the current item", ->
-      expect(pane.activeItem).toBe pane.items[0]
-      pane.activateItem(pane.items[1])
-      expect(pane.activeItem).toBe pane.items[1]
+      expect(pane.getActiveItem()).toBe pane.itemAtIndex(0)
+      pane.activateItem(pane.itemAtIndex(1))
+      expect(pane.getActiveItem()).toBe pane.itemAtIndex(1)
 
     it "adds the given item if it isn't present in ::items", ->
       item = new Item("C")
       pane.activateItem(item)
-      expect(item in pane.items).toBe true
-      expect(pane.activeItem).toBe item
+      expect(item in pane.getItems()).toBe true
+      expect(pane.getActiveItem()).toBe item
+
+    it "invokes ::onDidChangeActiveItem() observers", ->
+      observed = []
+      pane.onDidChangeActiveItem (item) -> observed.push(item)
+      pane.activateItem(pane.itemAtIndex(1))
+      expect(observed).toEqual [pane.itemAtIndex(1)]
 
   describe "::activateNextItem() and ::activatePreviousItem()", ->
     it "sets the active item to the next/previous item, looping around at either end", ->
       pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C")])
-      [item1, item2, item3] = pane.items
+      [item1, item2, item3] = pane.getItems()
 
-      expect(pane.activeItem).toBe item1
+      expect(pane.getActiveItem()).toBe item1
       pane.activatePreviousItem()
-      expect(pane.activeItem).toBe item3
+      expect(pane.getActiveItem()).toBe item3
       pane.activatePreviousItem()
-      expect(pane.activeItem).toBe item2
+      expect(pane.getActiveItem()).toBe item2
       pane.activateNextItem()
-      expect(pane.activeItem).toBe item3
+      expect(pane.getActiveItem()).toBe item3
       pane.activateNextItem()
-      expect(pane.activeItem).toBe item1
+      expect(pane.getActiveItem()).toBe item1
 
   describe "::activateItemAtIndex(index)", ->
     it "activates the item at the given index", ->
       pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C")])
-      [item1, item2, item3] = pane.items
+      [item1, item2, item3] = pane.getItems()
       pane.activateItemAtIndex(2)
-      expect(pane.activeItem).toBe item3
+      expect(pane.getActiveItem()).toBe item3
       pane.activateItemAtIndex(1)
-      expect(pane.activeItem).toBe item2
+      expect(pane.getActiveItem()).toBe item2
       pane.activateItemAtIndex(0)
-      expect(pane.activeItem).toBe item1
+      expect(pane.getActiveItem()).toBe item1
 
       # Doesn't fail with out-of-bounds indices
       pane.activateItemAtIndex(100)
-      expect(pane.activeItem).toBe item1
+      expect(pane.getActiveItem()).toBe item1
       pane.activateItemAtIndex(-1)
-      expect(pane.activeItem).toBe item1
+      expect(pane.getActiveItem()).toBe item1
 
   describe "::destroyItem(item)", ->
     [pane, item1, item2, item3] = []
 
     beforeEach ->
       pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C")])
-      [item1, item2, item3] = pane.items
+      [item1, item2, item3] = pane.getItems()
 
-    it "removes the item from the items list", ->
-      expect(pane.activeItem).toBe item1
+    it "removes the item from the items list and destroyes it", ->
+      expect(pane.getActiveItem()).toBe item1
       pane.destroyItem(item2)
-      expect(item2 in pane.items).toBe false
-      expect(pane.activeItem).toBe item1
+      expect(item2 in pane.getItems()).toBe false
+      expect(item2.isDestroyed()).toBe true
+      expect(pane.getActiveItem()).toBe item1
 
       pane.destroyItem(item1)
-      expect(item1 in pane.items).toBe false
+      expect(item1 in pane.getItems()).toBe false
+      expect(item1.isDestroyed()).toBe true
+
+    it "invokes ::onWillDestroyItem() observers before destroying the item", ->
+      events = []
+      pane.onWillDestroyItem (event) ->
+        expect(item2.isDestroyed()).toBe false
+        events.push(event)
+
+      pane.destroyItem(item2)
+      expect(item2.isDestroyed()).toBe true
+      expect(events).toEqual [{item: item2, index: 1}]
+
+    it "invokes ::onDidRemoveItem() observers", ->
+      events = []
+      pane.onDidRemoveItem (event) -> events.push(event)
+      pane.destroyItem(item2)
+      expect(events).toEqual [{item: item2, index: 1, destroyed: true}]
 
     describe "when the destroyed item is the active item and is the first item", ->
       it "activates the next item", ->
-        expect(pane.activeItem).toBe item1
+        expect(pane.getActiveItem()).toBe item1
         pane.destroyItem(item1)
-        expect(pane.activeItem).toBe item2
+        expect(pane.getActiveItem()).toBe item2
 
     describe "when the destroyed item is the active item and is not the first item", ->
       beforeEach ->
         pane.activateItem(item2)
 
       it "activates the previous item", ->
-        expect(pane.activeItem).toBe item2
+        expect(pane.getActiveItem()).toBe item2
         pane.destroyItem(item2)
-        expect(pane.activeItem).toBe item1
-
-    it "emits 'item-removed' with the item, its index, and true indicating the item is being destroyed", ->
-      pane.on 'item-removed', itemRemovedHandler = jasmine.createSpy("itemRemovedHandler")
-      pane.destroyItem(item2)
-      expect(itemRemovedHandler).toHaveBeenCalledWith(item2, 1, true)
+        expect(pane.getActiveItem()).toBe item1
 
     describe "if the item is modified", ->
       itemUri = null
@@ -157,7 +220,7 @@ describe "Pane", ->
             pane.destroyItem(item1)
 
             expect(item1.save).toHaveBeenCalled()
-            expect(item1 in pane.items).toBe false
+            expect(item1 in pane.getItems()).toBe false
             expect(item1.isDestroyed()).toBe true
 
         describe "when the item has no uri", ->
@@ -170,7 +233,7 @@ describe "Pane", ->
 
             expect(atom.showSaveDialogSync).toHaveBeenCalled()
             expect(item1.saveAs).toHaveBeenCalledWith("/selected/path")
-            expect(item1 in pane.items).toBe false
+            expect(item1 in pane.getItems()).toBe false
             expect(item1.isDestroyed()).toBe true
 
       describe "if the [Don't Save] option is selected", ->
@@ -179,7 +242,7 @@ describe "Pane", ->
           pane.destroyItem(item1)
 
           expect(item1.save).not.toHaveBeenCalled()
-          expect(item1 in pane.items).toBe false
+          expect(item1 in pane.getItems()).toBe false
           expect(item1.isDestroyed()).toBe true
 
       describe "if the [Cancel] option is selected", ->
@@ -188,7 +251,7 @@ describe "Pane", ->
           pane.destroyItem(item1)
 
           expect(item1.save).not.toHaveBeenCalled()
-          expect(item1 in pane.items).toBe true
+          expect(item1 in pane.getItems()).toBe true
           expect(item1.isDestroyed()).toBe false
 
     describe "when the last item is destroyed", ->
@@ -197,7 +260,7 @@ describe "Pane", ->
           expect(atom.config.get('core.destroyEmptyPanes')).toBe false
           pane.destroyItem(item) for item in pane.getItems()
           expect(pane.isDestroyed()).toBe false
-          expect(pane.activeItem).toBeUndefined()
+          expect(pane.getActiveItem()).toBeUndefined()
           expect(-> pane.saveActiveItem()).not.toThrow()
           expect(-> pane.saveActiveItemAs()).not.toThrow()
 
@@ -210,10 +273,10 @@ describe "Pane", ->
   describe "::destroyActiveItem()", ->
     it "destroys the active item", ->
       pane = new Pane(items: [new Item("A"), new Item("B")])
-      activeItem = pane.activeItem
+      activeItem = pane.getActiveItem()
       pane.destroyActiveItem()
       expect(activeItem.isDestroyed()).toBe true
-      expect(activeItem in pane.items).toBe false
+      expect(activeItem in pane.getItems()).toBe false
 
     it "does not throw an exception if there are no more items", ->
       pane = new Pane
@@ -222,27 +285,40 @@ describe "Pane", ->
   describe "::destroyItems()", ->
     it "destroys all items", ->
       pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C")])
-      [item1, item2, item3] = pane.items
+      [item1, item2, item3] = pane.getItems()
       pane.destroyItems()
       expect(item1.isDestroyed()).toBe true
       expect(item2.isDestroyed()).toBe true
       expect(item3.isDestroyed()).toBe true
-      expect(pane.items).toEqual []
+      expect(pane.getItems()).toEqual []
+
+  describe "::observeItems()", ->
+    it "invokes the observer with all current and future items", ->
+      pane = new Pane(items: [new Item, new Item])
+      [item1, item2] = pane.getItems()
+
+      observed = []
+      pane.observeItems (item) -> observed.push(item)
+
+      item3 = new Item
+      pane.addItem(item3)
+
+      expect(observed).toEqual [item1, item2, item3]
 
   describe "when an item emits a destroyed event", ->
     it "removes it from the list of items", ->
       pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C")])
-      [item1, item2, item3] = pane.items
-      pane.items[1].destroy()
-      expect(pane.items).toEqual [item1, item3]
+      [item1, item2, item3] = pane.getItems()
+      pane.itemAtIndex(1).destroy()
+      expect(pane.getItems()).toEqual [item1, item3]
 
   describe "::destroyInactiveItems()", ->
     it "destroys all items but the active item", ->
       pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C")])
-      [item1, item2, item3] = pane.items
+      [item1, item2, item3] = pane.getItems()
       pane.activateItem(item2)
       pane.destroyInactiveItems()
-      expect(pane.items).toEqual [item2]
+      expect(pane.getItems()).toEqual [item2]
 
   describe "::saveActiveItem()", ->
     pane = null
@@ -253,30 +329,30 @@ describe "Pane", ->
 
     describe "when the active item has a uri", ->
       beforeEach ->
-        pane.activeItem.uri = "test"
+        pane.getActiveItem().uri = "test"
 
       describe "when the active item has a save method", ->
         it "saves the current item", ->
-          pane.activeItem.save = jasmine.createSpy("save")
+          pane.getActiveItem().save = jasmine.createSpy("save")
           pane.saveActiveItem()
-          expect(pane.activeItem.save).toHaveBeenCalled()
+          expect(pane.getActiveItem().save).toHaveBeenCalled()
 
       describe "when the current item has no save method", ->
         it "does nothing", ->
-          expect(pane.activeItem.save).toBeUndefined()
+          expect(pane.getActiveItem().save).toBeUndefined()
           pane.saveActiveItem()
 
     describe "when the current item has no uri", ->
       describe "when the current item has a saveAs method", ->
         it "opens a save dialog and saves the current item as the selected path", ->
-          pane.activeItem.saveAs = jasmine.createSpy("saveAs")
+          pane.getActiveItem().saveAs = jasmine.createSpy("saveAs")
           pane.saveActiveItem()
           expect(atom.showSaveDialogSync).toHaveBeenCalled()
-          expect(pane.activeItem.saveAs).toHaveBeenCalledWith('/selected/path')
+          expect(pane.getActiveItem().saveAs).toHaveBeenCalledWith('/selected/path')
 
       describe "when the current item has no saveAs method", ->
         it "does nothing", ->
-          expect(pane.activeItem.saveAs).toBeUndefined()
+          expect(pane.getActiveItem().saveAs).toBeUndefined()
           pane.saveActiveItem()
           expect(atom.showSaveDialogSync).not.toHaveBeenCalled()
 
@@ -289,22 +365,22 @@ describe "Pane", ->
 
     describe "when the current item has a saveAs method", ->
       it "opens the save dialog and calls saveAs on the item with the selected path", ->
-        pane.activeItem.path = __filename
-        pane.activeItem.saveAs = jasmine.createSpy("saveAs")
+        pane.getActiveItem().path = __filename
+        pane.getActiveItem().saveAs = jasmine.createSpy("saveAs")
         pane.saveActiveItemAs()
         expect(atom.showSaveDialogSync).toHaveBeenCalledWith(__filename)
-        expect(pane.activeItem.saveAs).toHaveBeenCalledWith('/selected/path')
+        expect(pane.getActiveItem().saveAs).toHaveBeenCalledWith('/selected/path')
 
     describe "when the current item does not have a saveAs method", ->
       it "does nothing", ->
-        expect(pane.activeItem.saveAs).toBeUndefined()
+        expect(pane.getActiveItem().saveAs).toBeUndefined()
         pane.saveActiveItemAs()
         expect(atom.showSaveDialogSync).not.toHaveBeenCalled()
 
   describe "::itemForUri(uri)", ->
     it "returns the item for which a call to .getUri() returns the given uri", ->
       pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C"), new Item("D")])
-      [item1, item2, item3] = pane.items
+      [item1, item2, item3] = pane.getItems()
       item1.uri = "a"
       item2.uri = "b"
       expect(pane.itemForUri("a")).toBe item1
@@ -312,24 +388,32 @@ describe "Pane", ->
       expect(pane.itemForUri("bogus")).toBeUndefined()
 
   describe "::moveItem(item, index)", ->
-    it "moves the item to the given index and emits an 'item-moved' event with the item and its new index", ->
-      pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C"), new Item("D")])
-      [item1, item2, item3, item4] = pane.items
-      pane.on 'item-moved', itemMovedHandler = jasmine.createSpy("itemMovedHandler")
+    [pane, item1, item2, item3, item4] = []
 
+    beforeEach ->
+      pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C"), new Item("D")])
+      [item1, item2, item3, item4] = pane.getItems()
+
+    it "moves the item to the given index and invokes ::onDidMoveItem observers", ->
       pane.moveItem(item1, 2)
       expect(pane.getItems()).toEqual [item2, item3, item1, item4]
-      expect(itemMovedHandler).toHaveBeenCalledWith(item1, 2)
-      itemMovedHandler.reset()
 
       pane.moveItem(item2, 3)
       expect(pane.getItems()).toEqual [item3, item1, item4, item2]
-      expect(itemMovedHandler).toHaveBeenCalledWith(item2, 3)
-      itemMovedHandler.reset()
 
       pane.moveItem(item2, 1)
       expect(pane.getItems()).toEqual [item3, item2, item1, item4]
-      expect(itemMovedHandler).toHaveBeenCalledWith(item2, 1)
+
+    it "invokes ::onDidMoveItem() observers", ->
+      events = []
+      pane.onDidMoveItem (event) -> events.push(event)
+
+      pane.moveItem(item1, 2)
+      pane.moveItem(item2, 3)
+      expect(events).toEqual [
+        {item: item1, oldIndex: 0, newIndex: 2}
+        {item: item2, oldIndex: 0, newIndex: 3}
+      ]
 
   describe "::moveItemToPane(item, pane, index)", ->
     [container, pane1, pane2] = []
@@ -339,13 +423,20 @@ describe "Pane", ->
       pane1 = new Pane(items: [new Item("A"), new Item("B"), new Item("C")])
       container = new PaneContainer(root: pane1)
       pane2 = pane1.splitRight(items: [new Item("D"), new Item("E")])
-      [item1, item2, item3] = pane1.items
-      [item4, item5] = pane2.items
+      [item1, item2, item3] = pane1.getItems()
+      [item4, item5] = pane2.getItems()
 
     it "moves the item to the given pane at the given index", ->
       pane1.moveItemToPane(item2, pane2, 1)
-      expect(pane1.items).toEqual [item1, item3]
-      expect(pane2.items).toEqual [item4, item2, item5]
+      expect(pane1.getItems()).toEqual [item1, item3]
+      expect(pane2.getItems()).toEqual [item4, item2, item5]
+
+    it "invokes ::onDidRemoveItem() observers", ->
+      events = []
+      pane1.onDidRemoveItem (event) -> events.push(event)
+      pane1.moveItemToPane(item2, pane2, 1)
+
+      expect(events).toEqual [{item: item2, index: 1, destroyed: false}]
 
     describe "when the moved item the last item in the source pane", ->
       beforeEach ->
@@ -368,22 +459,27 @@ describe "Pane", ->
     [pane1, container] = []
 
     beforeEach ->
-      pane1 = new Pane(items: ["A"])
+      pane1 = new Pane(items: [new Item("A")])
       container = new PaneContainer(root: pane1)
 
     describe "::splitLeft(params)", ->
       describe "when the parent is the container root", ->
         it "replaces itself with a row and inserts a new pane to the left of itself", ->
-          pane2 = pane1.splitLeft(items: ["B"])
-          pane3 = pane1.splitLeft(items: ["C"])
+          pane2 = pane1.splitLeft(items: [new Item("B")])
+          pane3 = pane1.splitLeft(items: [new Item("C")])
           expect(container.root.orientation).toBe 'horizontal'
           expect(container.root.children).toEqual [pane2, pane3, pane1]
 
+      describe "when `copyActiveItem: true` is passed in the params", ->
+        it "duplicates the active item", ->
+          pane2 = pane1.splitLeft(copyActiveItem: true)
+          expect(pane2.getActiveItem()).toEqual pane1.getActiveItem()
+
       describe "when the parent is a column", ->
         it "replaces itself with a row and inserts a new pane to the left of itself", ->
           pane1.splitDown()
-          pane2 = pane1.splitLeft(items: ["B"])
-          pane3 = pane1.splitLeft(items: ["C"])
+          pane2 = pane1.splitLeft(items: [new Item("B")])
+          pane3 = pane1.splitLeft(items: [new Item("C")])
           row = container.root.children[0]
           expect(row.orientation).toBe 'horizontal'
           expect(row.children).toEqual [pane2, pane3, pane1]
@@ -391,16 +487,21 @@ describe "Pane", ->
     describe "::splitRight(params)", ->
       describe "when the parent is the container root", ->
         it "replaces itself with a row and inserts a new pane to the right of itself", ->
-          pane2 = pane1.splitRight(items: ["B"])
-          pane3 = pane1.splitRight(items: ["C"])
+          pane2 = pane1.splitRight(items: [new Item("B")])
+          pane3 = pane1.splitRight(items: [new Item("C")])
           expect(container.root.orientation).toBe 'horizontal'
           expect(container.root.children).toEqual [pane1, pane3, pane2]
 
+      describe "when `copyActiveItem: true` is passed in the params", ->
+        it "duplicates the active item", ->
+          pane2 = pane1.splitRight(copyActiveItem: true)
+          expect(pane2.getActiveItem()).toEqual pane1.getActiveItem()
+
       describe "when the parent is a column", ->
         it "replaces itself with a row and inserts a new pane to the right of itself", ->
           pane1.splitDown()
-          pane2 = pane1.splitRight(items: ["B"])
-          pane3 = pane1.splitRight(items: ["C"])
+          pane2 = pane1.splitRight(items: [new Item("B")])
+          pane3 = pane1.splitRight(items: [new Item("C")])
           row = container.root.children[0]
           expect(row.orientation).toBe 'horizontal'
           expect(row.children).toEqual [pane1, pane3, pane2]
@@ -408,16 +509,21 @@ describe "Pane", ->
     describe "::splitUp(params)", ->
       describe "when the parent is the container root", ->
         it "replaces itself with a column and inserts a new pane above itself", ->
-          pane2 = pane1.splitUp(items: ["B"])
-          pane3 = pane1.splitUp(items: ["C"])
+          pane2 = pane1.splitUp(items: [new Item("B")])
+          pane3 = pane1.splitUp(items: [new Item("C")])
           expect(container.root.orientation).toBe 'vertical'
           expect(container.root.children).toEqual [pane2, pane3, pane1]
 
+      describe "when `copyActiveItem: true` is passed in the params", ->
+        it "duplicates the active item", ->
+          pane2 = pane1.splitUp(copyActiveItem: true)
+          expect(pane2.getActiveItem()).toEqual pane1.getActiveItem()
+
       describe "when the parent is a row", ->
         it "replaces itself with a column and inserts a new pane above itself", ->
           pane1.splitRight()
-          pane2 = pane1.splitUp(items: ["B"])
-          pane3 = pane1.splitUp(items: ["C"])
+          pane2 = pane1.splitUp(items: [new Item("B")])
+          pane3 = pane1.splitUp(items: [new Item("C")])
           column = container.root.children[0]
           expect(column.orientation).toBe 'vertical'
           expect(column.children).toEqual [pane2, pane3, pane1]
@@ -425,16 +531,21 @@ describe "Pane", ->
     describe "::splitDown(params)", ->
       describe "when the parent is the container root", ->
         it "replaces itself with a column and inserts a new pane below itself", ->
-          pane2 = pane1.splitDown(items: ["B"])
-          pane3 = pane1.splitDown(items: ["C"])
+          pane2 = pane1.splitDown(items: [new Item("B")])
+          pane3 = pane1.splitDown(items: [new Item("C")])
           expect(container.root.orientation).toBe 'vertical'
           expect(container.root.children).toEqual [pane1, pane3, pane2]
 
+      describe "when `copyActiveItem: true` is passed in the params", ->
+        it "duplicates the active item", ->
+          pane2 = pane1.splitDown(copyActiveItem: true)
+          expect(pane2.getActiveItem()).toEqual pane1.getActiveItem()
+
       describe "when the parent is a row", ->
         it "replaces itself with a column and inserts a new pane below itself", ->
           pane1.splitRight()
-          pane2 = pane1.splitDown(items: ["B"])
-          pane3 = pane1.splitDown(items: ["C"])
+          pane2 = pane1.splitDown(items: [new Item("B")])
+          pane3 = pane1.splitDown(items: [new Item("C")])
           column = container.root.children[0]
           expect(column.orientation).toBe 'vertical'
           expect(column.children).toEqual [pane1, pane3, pane2]
@@ -455,7 +566,7 @@ describe "Pane", ->
       pane2 = pane1.splitRight()
 
     it "destroys the pane's destroyable items", ->
-      [item1, item2] = pane1.items
+      [item1, item2] = pane1.getItems()
       pane1.destroy()
       expect(item1.isDestroyed()).toBe true
       expect(item2.isDestroyed()).toBe true
@@ -493,12 +604,12 @@ describe "Pane", ->
 
     it "can serialize and deserialize the pane and all its items", ->
       newPane = pane.testSerialization()
-      expect(newPane.items).toEqual pane.items
+      expect(newPane.getItems()).toEqual pane.getItems()
 
     it "restores the active item on deserialization", ->
       pane.activateItemAtIndex(1)
       newPane = pane.testSerialization()
-      expect(newPane.activeItem).toEqual newPane.items[1]
+      expect(newPane.getActiveItem()).toEqual newPane.itemAtIndex(1)
 
     it "does not include items that cannot be deserialized", ->
       spyOn(console, 'warn')
@@ -506,8 +617,8 @@ describe "Pane", ->
       pane.activateItem(unserializable)
 
       newPane = pane.testSerialization()
-      expect(newPane.activeItem).toEqual pane.items[0]
-      expect(newPane.items.length).toBe pane.items.length - 1
+      expect(newPane.getActiveItem()).toEqual pane.itemAtIndex(0)
+      expect(newPane.getItems().length).toBe pane.getItems().length - 1
 
     it "includes the pane's focus state in the serialized state", ->
       pane.focus()

spec/pane-view-spec.coffee

@@ -1,6 +1,7 @@
 PaneContainerView = require '../src/pane-container-view'
 PaneView = require '../src/pane-view'
 fs = require 'fs-plus'
+{Emitter} = require 'event-kit'
 {$, View} = require 'atom'
 path = require 'path'
 temp = require 'temp'
@@ -12,9 +13,14 @@ describe "PaneView", ->
     @deserialize: ({id, text}) -> new TestView({id, text})
     @content: ({id, text}) -> @div class: 'test-view', id: id, tabindex: -1, text
     initialize: ({@id, @text}) ->
+      @emitter = new Emitter
     serialize: -> { deserializer: 'TestView', @id, @text }
     getUri: -> @id
     isEqual: (other) -> other? and @id == other.id and @text == other.text
+    changeTitle: ->
+      @emitter.emit 'did-change-title', 'title'
+    onDidChangeTitle: (callback) ->
+      @emitter.on 'did-change-title', callback
 
   beforeEach ->
     atom.deserializers.add(TestView)
@@ -29,7 +35,7 @@ describe "PaneView", ->
 
     runs ->
       pane = container.getRoot()
-      paneModel = pane.model
+      paneModel = pane.getModel()
       paneModel.addItems([view1, editor1, view2, editor2])
 
   afterEach ->
@@ -37,7 +43,7 @@ describe "PaneView", ->
 
   describe "when the active pane item changes", ->
     it "hides all item views except the active one", ->
-      expect(pane.activeItem).toBe view1
+      expect(pane.getActiveItem()).toBe view1
       expect(view1.css('display')).not.toBe 'none'
 
       pane.activateItem(view2)
@@ -48,7 +54,7 @@ describe "PaneView", ->
       itemChangedHandler = jasmine.createSpy("itemChangedHandler")
       container.on 'pane:active-item-changed', itemChangedHandler
 
-      expect(pane.activeItem).toBe view1
+      expect(pane.getActiveItem()).toBe view1
       paneModel.activateItem(view2)
       paneModel.activateItem(view2)
 
@@ -145,22 +151,47 @@ describe "PaneView", ->
       expect(view1.data('preservative')).toBe 1234
 
   describe "when the title of the active item changes", ->
-    it "emits pane:active-item-title-changed", ->
-      activeItemTitleChangedHandler = jasmine.createSpy("activeItemTitleChangedHandler")
-      pane.on 'pane:active-item-title-changed', activeItemTitleChangedHandler
+    describe 'when there is no onDidChangeTitle method', ->
+      beforeEach ->
+        view1.onDidChangeTitle = null
+        view2.onDidChangeTitle = null
 
-      expect(pane.activeItem).toBe view1
+        pane.activateItem(view2)
+        pane.activateItem(view1)
 
-      view2.trigger 'title-changed'
-      expect(activeItemTitleChangedHandler).not.toHaveBeenCalled()
+      it "emits pane:active-item-title-changed", ->
+        activeItemTitleChangedHandler = jasmine.createSpy("activeItemTitleChangedHandler")
+        pane.on 'pane:active-item-title-changed', activeItemTitleChangedHandler
 
-      view1.trigger 'title-changed'
-      expect(activeItemTitleChangedHandler).toHaveBeenCalled()
-      activeItemTitleChangedHandler.reset()
+        expect(pane.getActiveItem()).toBe view1
 
-      pane.activateItem(view2)
-      view2.trigger 'title-changed'
-      expect(activeItemTitleChangedHandler).toHaveBeenCalled()
+        view2.trigger 'title-changed'
+        expect(activeItemTitleChangedHandler).not.toHaveBeenCalled()
+
+        view1.trigger 'title-changed'
+        expect(activeItemTitleChangedHandler).toHaveBeenCalled()
+        activeItemTitleChangedHandler.reset()
+
+        pane.activateItem(view2)
+        view2.trigger 'title-changed'
+        expect(activeItemTitleChangedHandler).toHaveBeenCalled()
+
+    describe 'when there is a onDidChangeTitle method', ->
+      it "emits pane:active-item-title-changed", ->
+        activeItemTitleChangedHandler = jasmine.createSpy("activeItemTitleChangedHandler")
+        pane.on 'pane:active-item-title-changed', activeItemTitleChangedHandler
+
+        expect(pane.getActiveItem()).toBe view1
+        view2.changeTitle()
+        expect(activeItemTitleChangedHandler).not.toHaveBeenCalled()
+
+        view1.changeTitle()
+        expect(activeItemTitleChangedHandler).toHaveBeenCalled()
+        activeItemTitleChangedHandler.reset()
+
+        pane.activateItem(view2)
+        view2.changeTitle()
+        expect(activeItemTitleChangedHandler).toHaveBeenCalled()
 
   describe "when an unmodifed buffer's path is deleted", ->
     it "removes the pane item", ->
@@ -246,7 +277,7 @@ describe "PaneView", ->
 
     it "transfers focus to the active view", ->
       focusHandler = jasmine.createSpy("focusHandler")
-      pane.activeItem.on 'focus', focusHandler
+      pane.getActiveItem().on 'focus', focusHandler
       pane.focus()
       expect(focusHandler).toHaveBeenCalled()
 
@@ -259,7 +290,7 @@ describe "PaneView", ->
   describe "when a pane is split", ->
     it "builds the appropriate pane-row and pane-column views", ->
       pane1 = pane
-      pane1Model = pane.model
+      pane1Model = pane.getModel()
       pane.activateItem(editor1)
 
       pane2Model = pane1Model.splitRight(items: [pane1Model.copyActiveItem()])

spec/project-spec.coffee

@@ -190,6 +190,11 @@ describe "Project", ->
         expect(atom.project.getPath()?).toBeFalsy()
         expect(atom.project.getRootDirectory()?).toBeFalsy()
 
+    it "normalizes the path to remove consecutive slashes, ., and .. segments", ->
+      atom.project.setPath("#{require.resolve('./fixtures/dir/a')}#{path.sep}b#{path.sep}#{path.sep}..")
+      expect(atom.project.getPath()).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
+      expect(atom.project.getRootDirectory().path).toEqual path.dirname(require.resolve('./fixtures/dir/a'))
+
   describe ".replace()", ->
     [filePath, commentFilePath, sampleContent, sampleCommentContent] = []
 

spec/random-editor-spec.coffee

@@ -35,7 +35,7 @@ describe "Editor", ->
         logLines()
         throw new Error("Invalid buffer row #{actualBufferRow} for screen row #{screenRow}", )
 
-      actualScreenLine = editor.lineForScreenRow(screenRow)
+      actualScreenLine = editor.tokenizedLineForScreenRow(screenRow)
       unless actualScreenLine.text is referenceScreenLine.text
         logLines()
         throw new Error("Invalid line text at screen row #{screenRow}")
@@ -50,9 +50,9 @@ describe "Editor", ->
 
   randomlyMutateEditor = ->
     if Math.random() < .2
-      softWrap = not editor.getSoftWrap()
-      steps.push(['setSoftWrap', softWrap])
-      editor.setSoftWrap(softWrap)
+      softWrapped = not editor.isSoftWrapped()
+      steps.push(['setSoftWrapped', softWrapped])
+      editor.setSoftWrapped(softWrapped)
     else
       range = getRandomRange()
       text = getRandomText()
@@ -79,11 +79,11 @@ describe "Editor", ->
     text
 
   getReferenceScreenLines = ->
-    if editor.getSoftWrap()
+    if editor.isSoftWrapped()
       screenLines = []
       bufferRows = []
       for bufferRow in [0..tokenizedBuffer.getLastRow()]
-        for screenLine in softWrapLine(tokenizedBuffer.lineForScreenRow(bufferRow))
+        for screenLine in softWrapLine(tokenizedBuffer.tokenizedLineForRow(bufferRow))
           screenLines.push(screenLine)
           bufferRows.push(bufferRow)
     else

spec/selection-spec.coffee

@@ -6,7 +6,7 @@ describe "Selection", ->
   beforeEach ->
     buffer = atom.project.bufferForPathSync('sample.js')
     editor = new Editor(buffer: buffer, tabLength: 2)
-    selection = editor.getSelection()
+    selection = editor.getLastSelection()
 
   afterEach ->
     buffer.destroy()
@@ -57,10 +57,10 @@ describe "Selection", ->
       expect(selection.isReversed()).toBeFalsy()
 
   describe "when only the selection's tail is moved (regression)", ->
-    it "emits the 'screen-range-changed' event", ->
+    it "notifies ::onDidChangeRange observers", ->
       selection.setBufferRange([[2, 0], [2, 10]], reversed: true)
       changeScreenRangeHandler = jasmine.createSpy('changeScreenRangeHandler')
-      selection.on 'screen-range-changed', changeScreenRangeHandler
+      selection.onDidChangeRange changeScreenRangeHandler
 
       buffer.insert([2, 5], 'abc')
       expect(changeScreenRangeHandler).toHaveBeenCalled()

spec/spec-helper.coffee

@@ -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')
@@ -95,7 +95,6 @@ beforeEach ->
   config.set "editor.autoIndent", false
   config.set "core.disabledPackages", ["package-that-throws-an-exception",
     "package-with-broken-package-json", "package-with-broken-keymap"]
-  config.set "core.useReactEditor", true
   config.save.reset()
   atom.config = config
 
@@ -130,14 +129,15 @@ afterEach ->
   atom.project?.destroy()
   atom.project = null
 
+  atom.themes.removeStylesheet('global-editor-styles')
+
   delete atom.state.packageStates
 
   $('#jasmine-content').empty() unless window.debugContent
 
   jasmine.unspy(atom, 'saveSync')
   ensureNoPathSubscriptions()
-  atom.syntax.off()
-  ensureNoDeprecatedFunctionsCalled() if isCoreSpec
+  atom.syntax.clearObservers()
   waits(0) # yield to ui thread to make screen update more frequently
 
 ensureNoPathSubscriptions = ->
@@ -209,6 +209,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

spec/theme-manager-spec.coffee

@@ -69,7 +69,7 @@ describe "ThemeManager", ->
 
   describe "when the core.themes config value changes", ->
     it "add/removes stylesheets to reflect the new config value", ->
-      themeManager.on 'reloaded', reloadHandler = jasmine.createSpy()
+      themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
       spyOn(themeManager, 'getUserStylesheetPath').andCallFake -> null
 
       waitsForPromise ->
@@ -131,8 +131,8 @@ describe "ThemeManager", ->
 
   describe "requireStylesheet(path)", ->
     it "synchronously loads css at the given path and installs a style tag for it in the head", ->
-      themeManager.on 'stylesheets-changed', stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
-      themeManager.on 'stylesheet-added', stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
+      themeManager.onDidChangeStylesheets stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
+      themeManager.onDidAddStylesheet stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
       cssPath = atom.project.resolve('css.css')
       lengthBefore = $('head style').length
 
@@ -193,8 +193,8 @@ describe "ThemeManager", ->
       themeManager.requireStylesheet(cssPath)
       expect($(document.body).css('font-weight')).toBe("bold")
 
-      themeManager.on 'stylesheet-removed', stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
-      themeManager.on 'stylesheets-changed', stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
+      themeManager.onDidRemoveStylesheet stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
+      themeManager.onDidChangeStylesheets stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
 
       themeManager.removeStylesheet(cssPath)
 
@@ -217,7 +217,7 @@ describe "ThemeManager", ->
         themeManager.activateThemes()
 
     it "loads the correct values from the theme's ui-variables file", ->
-      themeManager.on 'reloaded', reloadHandler = jasmine.createSpy()
+      themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
       atom.config.set('core.themes', ['theme-with-ui-variables'])
 
       waitsFor ->
@@ -234,7 +234,7 @@ describe "ThemeManager", ->
 
     describe "when there is a theme with incomplete variables", ->
       it "loads the correct values from the fallback ui-variables", ->
-        themeManager.on 'reloaded', reloadHandler = jasmine.createSpy()
+        themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
         atom.config.set('core.themes', ['theme-with-incomplete-ui-variables'])
 
         waitsFor ->
@@ -247,6 +247,21 @@ describe "ThemeManager", ->
           # from within the theme itself
           expect($(".editor").css("background-color")).toBe "rgb(0, 152, 255)"
 
+    describe "theme classes on the workspace", ->
+      it 'adds theme-* classes to the workspace for each active theme', ->
+        expect(atom.workspaceView).toHaveClass 'theme-atom-dark-ui'
+
+        themeManager.onDidReloadAll reloadHandler = jasmine.createSpy()
+        atom.config.set('core.themes', ['theme-with-ui-variables'])
+
+        waitsFor ->
+          reloadHandler.callCount > 0
+
+        runs ->
+          # `theme-` twice as it prefixes the name with `theme-`
+          expect(atom.workspaceView).toHaveClass 'theme-theme-with-ui-variables'
+          expect(atom.workspaceView).not.toHaveClass 'theme-atom-dark-ui'
+
   describe "when the user stylesheet changes", ->
     it "reloads it", ->
       [stylesheetRemovedHandler, stylesheetAddedHandler, stylesheetsChangedHandler] = []
@@ -258,9 +273,9 @@ describe "ThemeManager", ->
         themeManager.activateThemes()
 
       runs ->
-        themeManager.on 'stylesheets-changed', stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
-        themeManager.on 'stylesheet-removed', stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
-        themeManager.on 'stylesheet-added', stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
+        themeManager.onDidChangeStylesheets stylesheetsChangedHandler = jasmine.createSpy("stylesheetsChangedHandler")
+        themeManager.onDidRemoveStylesheet stylesheetRemovedHandler = jasmine.createSpy("stylesheetRemovedHandler")
+        themeManager.onDidAddStylesheet stylesheetAddedHandler = jasmine.createSpy("stylesheetAddedHandler")
         spyOn(themeManager, 'loadUserStylesheet').andCallThrough()
 
         expect($(document.body).css('border-style')).toBe 'dotted'
@@ -301,7 +316,9 @@ describe "ThemeManager", ->
         themeManager.activateThemes()
 
       runs ->
-        themeManager.once 'reloaded', -> reloaded = true
+        disposable = themeManager.onDidReloadAll ->
+          disposable.dispose()
+          reloaded = true
         spyOn(console, 'warn')
         expect(-> atom.config.set('core.themes', ['atom-light-ui', 'theme-really-does-not-exist'])).not.toThrow()
 
@@ -310,3 +327,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')

spec/time-reporter.coffee

@@ -18,7 +18,7 @@ class TimeReporter extends jasmine.Reporter
     log ?= (line) -> console.log(line)
     log "Longest running suites:"
     suites = _.map(window.timedSuites, (key, value) -> [value, key])
-    for suite in _.sortBy(suites, (suite) => -suite[1])[0...number]
+    for suite in _.sortBy(suites, (suite) -> -suite[1])[0...number]
       time = Math.round(suite[1] / 100) / 10
       log "  #{suite[0]} (#{time}s)"
     undefined

spec/tokenized-buffer-spec.coffee

@@ -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)
 
@@ -37,7 +41,7 @@ describe "TokenizedBuffer", ->
       buffer = atom.project.bufferForPathSync('sample.js')
       tokenizedBuffer = new TokenizedBuffer({buffer})
       startTokenizing(tokenizedBuffer)
-      tokenizedBuffer.on "changed", changeHandler = jasmine.createSpy('changeHandler')
+      tokenizedBuffer.onDidChange changeHandler = jasmine.createSpy('changeHandler')
 
     afterEach ->
       tokenizedBuffer.destroy()
@@ -45,38 +49,38 @@ describe "TokenizedBuffer", ->
 
     describe "on construction", ->
       it "initially creates un-tokenized screen lines, then tokenizes lines chunk at a time in the background", ->
-        line0 = tokenizedBuffer.lineForScreenRow(0)
+        line0 = tokenizedBuffer.tokenizedLineForRow(0)
         expect(line0.tokens.length).toBe 1
         expect(line0.tokens[0]).toEqual(value: line0.text, scopes: ['source.js'])
 
-        line11 = tokenizedBuffer.lineForScreenRow(11)
+        line11 = tokenizedBuffer.tokenizedLineForRow(11)
         expect(line11.tokens.length).toBe 2
         expect(line11.tokens[0]).toEqual(value: "  ", scopes: ['source.js'], isAtomic: true)
         expect(line11.tokens[1]).toEqual(value: "return sort(Array.apply(this, arguments));", scopes: ['source.js'])
 
         # background tokenization has not begun
-        expect(tokenizedBuffer.lineForScreenRow(0).ruleStack).toBeUndefined()
+        expect(tokenizedBuffer.tokenizedLineForRow(0).ruleStack).toBeUndefined()
 
         # tokenize chunk 1
         advanceClock()
-        expect(tokenizedBuffer.lineForScreenRow(0).ruleStack?).toBeTruthy()
-        expect(tokenizedBuffer.lineForScreenRow(4).ruleStack?).toBeTruthy()
-        expect(tokenizedBuffer.lineForScreenRow(5).ruleStack?).toBeFalsy()
+        expect(tokenizedBuffer.tokenizedLineForRow(0).ruleStack?).toBeTruthy()
+        expect(tokenizedBuffer.tokenizedLineForRow(4).ruleStack?).toBeTruthy()
+        expect(tokenizedBuffer.tokenizedLineForRow(5).ruleStack?).toBeFalsy()
         expect(changeHandler).toHaveBeenCalledWith(start: 0, end: 4, delta: 0)
         changeHandler.reset()
 
         # tokenize chunk 2
         advanceClock()
-        expect(tokenizedBuffer.lineForScreenRow(5).ruleStack?).toBeTruthy()
-        expect(tokenizedBuffer.lineForScreenRow(9).ruleStack?).toBeTruthy()
-        expect(tokenizedBuffer.lineForScreenRow(10).ruleStack?).toBeFalsy()
+        expect(tokenizedBuffer.tokenizedLineForRow(5).ruleStack?).toBeTruthy()
+        expect(tokenizedBuffer.tokenizedLineForRow(9).ruleStack?).toBeTruthy()
+        expect(tokenizedBuffer.tokenizedLineForRow(10).ruleStack?).toBeFalsy()
         expect(changeHandler).toHaveBeenCalledWith(start: 5, end: 9, delta: 0)
         changeHandler.reset()
 
         # tokenize last chunk
         advanceClock()
-        expect(tokenizedBuffer.lineForScreenRow(10).ruleStack?).toBeTruthy()
-        expect(tokenizedBuffer.lineForScreenRow(12).ruleStack?).toBeTruthy()
+        expect(tokenizedBuffer.tokenizedLineForRow(10).ruleStack?).toBeTruthy()
+        expect(tokenizedBuffer.tokenizedLineForRow(12).ruleStack?).toBeTruthy()
         expect(changeHandler).toHaveBeenCalledWith(start: 10, end: 12, delta: 0)
 
     describe "when the buffer is partially tokenized", ->
@@ -130,8 +134,8 @@ describe "TokenizedBuffer", ->
           expect(tokenizedBuffer.firstInvalidRow()).toBe 5
           buffer.setTextInRange([[6, 0], [7, 0]], "\n\n\n")
 
-          expect(tokenizedBuffer.lineForScreenRow(6).ruleStack?).toBeFalsy()
-          expect(tokenizedBuffer.lineForScreenRow(7).ruleStack?).toBeFalsy()
+          expect(tokenizedBuffer.tokenizedLineForRow(6).ruleStack?).toBeFalsy()
+          expect(tokenizedBuffer.tokenizedLineForRow(7).ruleStack?).toBeFalsy()
 
           changeHandler.reset()
           expect(tokenizedBuffer.firstInvalidRow()).toBe 5
@@ -145,10 +149,10 @@ describe "TokenizedBuffer", ->
           it "updates tokens to reflect the change", ->
             buffer.setTextInRange([[0, 0], [2, 0]], "foo()\n7\n")
 
-            expect(tokenizedBuffer.lineForScreenRow(0).tokens[1]).toEqual(value: '(', scopes: ['source.js', 'meta.brace.round.js'])
-            expect(tokenizedBuffer.lineForScreenRow(1).tokens[0]).toEqual(value: '7', scopes: ['source.js', 'constant.numeric.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1]).toEqual(value: '(', scopes: ['source.js', 'meta.brace.round.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0]).toEqual(value: '7', scopes: ['source.js', 'constant.numeric.js'])
             # line 2 is unchanged
-            expect(tokenizedBuffer.lineForScreenRow(2).tokens[2]).toEqual(value: 'if', scopes: ['source.js', 'keyword.control.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[2]).toEqual(value: 'if', scopes: ['source.js', 'keyword.control.js'])
 
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
@@ -160,7 +164,7 @@ describe "TokenizedBuffer", ->
               buffer.insert([5, 30], '/* */')
               changeHandler.reset()
               buffer.insert([2, 0], '/*')
-              expect(tokenizedBuffer.lineForScreenRow(3).tokens[0].scopes).toEqual ['source.js']
+              expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopes).toEqual ['source.js']
               expect(changeHandler).toHaveBeenCalled()
               [event] = changeHandler.argsForCall[0]
               delete event.bufferChange
@@ -168,9 +172,9 @@ describe "TokenizedBuffer", ->
               changeHandler.reset()
 
               advanceClock()
-              expect(tokenizedBuffer.lineForScreenRow(3).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-              expect(tokenizedBuffer.lineForScreenRow(4).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-              expect(tokenizedBuffer.lineForScreenRow(5).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+              expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+              expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+              expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
               expect(changeHandler).toHaveBeenCalled()
               [event] = changeHandler.argsForCall[0]
               delete event.bufferChange
@@ -181,23 +185,23 @@ describe "TokenizedBuffer", ->
             buffer.insert([5, 0], '*/')
 
             buffer.insert([1, 0], 'var ')
-            expect(tokenizedBuffer.lineForScreenRow(1).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
 
         describe "when lines are both updated and removed", ->
           it "updates tokens to reflect the change", ->
             buffer.setTextInRange([[1, 0], [3, 0]], "foo()")
 
             # previous line 0 remains
-            expect(tokenizedBuffer.lineForScreenRow(0).tokens[0]).toEqual(value: 'var', scopes: ['source.js', 'storage.modifier.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[0]).toEqual(value: 'var', scopes: ['source.js', 'storage.modifier.js'])
 
             # previous line 3 should be combined with input to form line 1
-            expect(tokenizedBuffer.lineForScreenRow(1).tokens[0]).toEqual(value: 'foo', scopes: ['source.js'])
-            expect(tokenizedBuffer.lineForScreenRow(1).tokens[6]).toEqual(value: '=', scopes: ['source.js', 'keyword.operator.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0]).toEqual(value: 'foo', scopes: ['source.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[6]).toEqual(value: '=', scopes: ['source.js', 'keyword.operator.js'])
 
             # lines below deleted regions should be shifted upward
-            expect(tokenizedBuffer.lineForScreenRow(2).tokens[2]).toEqual(value: 'while', scopes: ['source.js', 'keyword.control.js'])
-            expect(tokenizedBuffer.lineForScreenRow(3).tokens[4]).toEqual(value: '=', scopes: ['source.js', 'keyword.operator.js'])
-            expect(tokenizedBuffer.lineForScreenRow(4).tokens[4]).toEqual(value: '<', scopes: ['source.js', 'keyword.operator.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[2]).toEqual(value: 'while', scopes: ['source.js', 'keyword.control.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[4]).toEqual(value: '=', scopes: ['source.js', 'keyword.operator.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[4]).toEqual(value: '<', scopes: ['source.js', 'keyword.operator.js'])
 
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
@@ -210,8 +214,8 @@ describe "TokenizedBuffer", ->
             changeHandler.reset()
 
             buffer.setTextInRange([[2, 0], [3, 0]], '/*')
-            expect(tokenizedBuffer.lineForScreenRow(2).tokens[0].scopes).toEqual ['source.js', 'comment.block.js', 'punctuation.definition.comment.js']
-            expect(tokenizedBuffer.lineForScreenRow(3).tokens[0].scopes).toEqual ['source.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[0].scopes).toEqual ['source.js', 'comment.block.js', 'punctuation.definition.comment.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopes).toEqual ['source.js']
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
             delete event.bufferChange
@@ -219,8 +223,8 @@ describe "TokenizedBuffer", ->
             changeHandler.reset()
 
             advanceClock()
-            expect(tokenizedBuffer.lineForScreenRow(3).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.lineForScreenRow(4).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
             delete event.bufferChange
@@ -231,19 +235,19 @@ describe "TokenizedBuffer", ->
             buffer.setTextInRange([[1, 0], [2, 0]], "foo()\nbar()\nbaz()\nquux()")
 
             # previous line 0 remains
-            expect(tokenizedBuffer.lineForScreenRow(0).tokens[0]).toEqual( value: 'var', scopes: ['source.js', 'storage.modifier.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[0]).toEqual( value: 'var', scopes: ['source.js', 'storage.modifier.js'])
 
             # 3 new lines inserted
-            expect(tokenizedBuffer.lineForScreenRow(1).tokens[0]).toEqual(value: 'foo', scopes: ['source.js'])
-            expect(tokenizedBuffer.lineForScreenRow(2).tokens[0]).toEqual(value: 'bar', scopes: ['source.js'])
-            expect(tokenizedBuffer.lineForScreenRow(3).tokens[0]).toEqual(value: 'baz', scopes: ['source.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0]).toEqual(value: 'foo', scopes: ['source.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[0]).toEqual(value: 'bar', scopes: ['source.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0]).toEqual(value: 'baz', scopes: ['source.js'])
 
             # previous line 2 is joined with quux() on line 4
-            expect(tokenizedBuffer.lineForScreenRow(4).tokens[0]).toEqual(value: 'quux', scopes: ['source.js'])
-            expect(tokenizedBuffer.lineForScreenRow(4).tokens[4]).toEqual(value: 'if', scopes: ['source.js', 'keyword.control.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0]).toEqual(value: 'quux', scopes: ['source.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[4]).toEqual(value: 'if', scopes: ['source.js', 'keyword.control.js'])
 
             # previous line 3 is pushed down to become line 5
-            expect(tokenizedBuffer.lineForScreenRow(5).tokens[4]).toEqual(value: '=', scopes: ['source.js', 'keyword.operator.js'])
+            expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[4]).toEqual(value: '=', scopes: ['source.js', 'keyword.operator.js'])
 
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
@@ -260,17 +264,17 @@ describe "TokenizedBuffer", ->
             [event] = changeHandler.argsForCall[0]
             delete event.bufferChange
             expect(event).toEqual(start: 2, end: 2, delta: 2)
-            expect(tokenizedBuffer.lineForScreenRow(2).tokens[0].scopes).toEqual ['source.js', 'comment.block.js', 'punctuation.definition.comment.js']
-            expect(tokenizedBuffer.lineForScreenRow(3).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.lineForScreenRow(4).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.lineForScreenRow(5).tokens[0].scopes).toEqual ['source.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[0].scopes).toEqual ['source.js', 'comment.block.js', 'punctuation.definition.comment.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(3).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(4).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].scopes).toEqual ['source.js']
             changeHandler.reset()
 
             advanceClock() # tokenize invalidated lines in background
-            expect(tokenizedBuffer.lineForScreenRow(5).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.lineForScreenRow(6).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.lineForScreenRow(7).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
-            expect(tokenizedBuffer.lineForScreenRow(8).tokens[0].scopes).not.toBe ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(6).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(7).tokens[0].scopes).toEqual ['source.js', 'comment.block.js']
+            expect(tokenizedBuffer.tokenizedLineForRow(8).tokens[0].scopes).not.toBe ['source.js', 'comment.block.js']
 
             expect(changeHandler).toHaveBeenCalled()
             [event] = changeHandler.argsForCall[0]
@@ -281,13 +285,13 @@ describe "TokenizedBuffer", ->
         it "tokenizes the initial chunk synchronously, then tokenizes the remaining lines in the background", ->
           commentBlock = _.multiplyString("// a comment\n", tokenizedBuffer.chunkSize + 2)
           buffer.insert([0,0], commentBlock)
-          expect(tokenizedBuffer.lineForScreenRow(0).ruleStack?).toBeTruthy()
-          expect(tokenizedBuffer.lineForScreenRow(4).ruleStack?).toBeTruthy()
-          expect(tokenizedBuffer.lineForScreenRow(5).ruleStack?).toBeFalsy()
+          expect(tokenizedBuffer.tokenizedLineForRow(0).ruleStack?).toBeTruthy()
+          expect(tokenizedBuffer.tokenizedLineForRow(4).ruleStack?).toBeTruthy()
+          expect(tokenizedBuffer.tokenizedLineForRow(5).ruleStack?).toBeFalsy()
 
           advanceClock()
-          expect(tokenizedBuffer.lineForScreenRow(5).ruleStack?).toBeTruthy()
-          expect(tokenizedBuffer.lineForScreenRow(6).ruleStack?).toBeTruthy()
+          expect(tokenizedBuffer.tokenizedLineForRow(5).ruleStack?).toBeTruthy()
+          expect(tokenizedBuffer.tokenizedLineForRow(6).ruleStack?).toBeTruthy()
 
       describe ".findOpeningBracket(closingBufferPosition)", ->
         it "returns the position of the matching bracket, skipping any nested brackets", ->
@@ -298,18 +302,18 @@ describe "TokenizedBuffer", ->
           expect(tokenizedBuffer.findClosingBracket([1, 29])).toEqual [9, 2]
 
       it "tokenizes leading whitespace based on the new tab length", ->
-        expect(tokenizedBuffer.lineForScreenRow(5).tokens[0].isAtomic).toBeTruthy()
-        expect(tokenizedBuffer.lineForScreenRow(5).tokens[0].value).toBe "  "
-        expect(tokenizedBuffer.lineForScreenRow(5).tokens[1].isAtomic).toBeTruthy()
-        expect(tokenizedBuffer.lineForScreenRow(5).tokens[1].value).toBe "  "
+        expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].isAtomic).toBeTruthy()
+        expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].value).toBe "  "
+        expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[1].isAtomic).toBeTruthy()
+        expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[1].value).toBe "  "
 
         tokenizedBuffer.setTabLength(4)
         fullyTokenize(tokenizedBuffer)
 
-        expect(tokenizedBuffer.lineForScreenRow(5).tokens[0].isAtomic).toBeTruthy()
-        expect(tokenizedBuffer.lineForScreenRow(5).tokens[0].value).toBe "    "
-        expect(tokenizedBuffer.lineForScreenRow(5).tokens[1].isAtomic).toBeFalsy()
-        expect(tokenizedBuffer.lineForScreenRow(5).tokens[1].value).toBe "  current "
+        expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].isAtomic).toBeTruthy()
+        expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[0].value).toBe "    "
+        expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[1].isAtomic).toBeFalsy()
+        expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[1].value).toBe "  current "
 
   describe "when the buffer contains hard-tabs", ->
     beforeEach ->
@@ -331,7 +335,7 @@ describe "TokenizedBuffer", ->
 
       it "renders each tab as its own atomic token with a value of size tabLength", ->
         tabAsSpaces = _.multiplyString(' ', tokenizedBuffer.getTabLength())
-        screenLine0 = tokenizedBuffer.lineForScreenRow(0)
+        screenLine0 = tokenizedBuffer.tokenizedLineForRow(0)
         expect(screenLine0.text).toBe "# Econ 101#{tabAsSpaces}"
         { tokens } = screenLine0
 
@@ -343,7 +347,7 @@ describe "TokenizedBuffer", ->
         expect(tokens[2].isAtomic).toBeTruthy()
         expect(tokens[3].value).toBe ""
 
-        expect(tokenizedBuffer.lineForScreenRow(2).text).toBe "#{tabAsSpaces} buy()#{tabAsSpaces}while supply > demand"
+        expect(tokenizedBuffer.tokenizedLineForRow(2).text).toBe "#{tabAsSpaces} buy()#{tabAsSpaces}while supply > demand"
 
       it "aligns the hard tabs to the correct tab stop column", ->
         buffer.setText """
@@ -355,62 +359,62 @@ describe "TokenizedBuffer", ->
         tokenizedBuffer.setTabLength(4)
         fullyTokenize(tokenizedBuffer)
 
-        expect(tokenizedBuffer.lineForScreenRow(0).text).toBe "1   2   3   4"
-        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].screenDelta).toBe 3
+        expect(tokenizedBuffer.tokenizedLineForRow(0).text).toBe "1   2   3   4"
+        expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1].screenDelta).toBe 3
 
-        expect(tokenizedBuffer.lineForScreenRow(1).text).toBe "12  3   4   5"
-        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].screenDelta).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(1).text).toBe "12  3   4   5"
+        expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[1].screenDelta).toBe 2
 
-        expect(tokenizedBuffer.lineForScreenRow(2).text).toBe "123 4       5   6"
-        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].screenDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(2).text).toBe "123 4       5   6"
+        expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[1].screenDelta).toBe 1
 
         tokenizedBuffer.setTabLength(3)
         fullyTokenize(tokenizedBuffer)
 
-        expect(tokenizedBuffer.lineForScreenRow(0).text).toBe "1  2  3  4"
-        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].screenDelta).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(0).text).toBe "1  2  3  4"
+        expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1].screenDelta).toBe 2
 
-        expect(tokenizedBuffer.lineForScreenRow(1).text).toBe "12 3     4  5"
-        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].screenDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(1).text).toBe "12 3     4  5"
+        expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[1].screenDelta).toBe 1
 
-        expect(tokenizedBuffer.lineForScreenRow(2).text).toBe "123   4     5  6"
-        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].screenDelta).toBe 3
+        expect(tokenizedBuffer.tokenizedLineForRow(2).text).toBe "123   4     5  6"
+        expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[1].screenDelta).toBe 3
 
         tokenizedBuffer.setTabLength(2)
         fullyTokenize(tokenizedBuffer)
 
-        expect(tokenizedBuffer.lineForScreenRow(0).text).toBe "1 2   3 4"
-        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].screenDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(0).text).toBe "1 2   3 4"
+        expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1].screenDelta).toBe 1
 
-        expect(tokenizedBuffer.lineForScreenRow(1).text).toBe "12  3   4 5"
-        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].screenDelta).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(1).text).toBe "12  3   4 5"
+        expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[1].screenDelta).toBe 2
 
-        expect(tokenizedBuffer.lineForScreenRow(2).text).toBe "123 4     5 6"
-        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].screenDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(2).text).toBe "123 4     5 6"
+        expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[1].screenDelta).toBe 1
 
         tokenizedBuffer.setTabLength(1)
         fullyTokenize(tokenizedBuffer)
 
-        expect(tokenizedBuffer.lineForScreenRow(0).text).toBe "1 2  3 4"
-        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(0).tokens[1].screenDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(0).text).toBe "1 2  3 4"
+        expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[1].screenDelta).toBe 1
 
-        expect(tokenizedBuffer.lineForScreenRow(1).text).toBe "12 3   4 5"
-        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].screenDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(1).text).toBe "12 3   4 5"
+        expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[1].screenDelta).toBe 1
 
-        expect(tokenizedBuffer.lineForScreenRow(2).text).toBe "123 4    5 6"
-        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].bufferDelta).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].screenDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(2).text).toBe "123 4    5 6"
+        expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[1].bufferDelta).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[1].screenDelta).toBe 1
 
   describe "when the buffer contains UTF-8 surrogate pairs", ->
     beforeEach ->
@@ -431,7 +435,7 @@ describe "TokenizedBuffer", ->
       buffer.release()
 
     it "renders each UTF-8 surrogate pair as its own atomic token", ->
-      screenLine0 = tokenizedBuffer.lineForScreenRow(0)
+      screenLine0 = tokenizedBuffer.tokenizedLineForRow(0)
       expect(screenLine0.text).toBe "'abc\uD835\uDF97def'"
       { tokens } = screenLine0
 
@@ -443,7 +447,7 @@ describe "TokenizedBuffer", ->
       expect(tokens[3].value).toBe "def"
       expect(tokens[4].value).toBe "'"
 
-      screenLine1 = tokenizedBuffer.lineForScreenRow(1)
+      screenLine1 = tokenizedBuffer.tokenizedLineForRow(1)
       expect(screenLine1.text).toBe "//\uD835\uDF97xyz"
       { tokens } = screenLine1
 
@@ -464,7 +468,7 @@ describe "TokenizedBuffer", ->
 
       runs ->
         tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
-        tokenizedBuffer.on 'tokenized', tokenizedHandler
+        tokenizedBuffer.onDidTokenize tokenizedHandler
         fullyTokenize(tokenizedBuffer)
         expect(tokenizedHandler.callCount).toBe(1)
 
@@ -479,7 +483,7 @@ describe "TokenizedBuffer", ->
         tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
         fullyTokenize(tokenizedBuffer)
 
-        tokenizedBuffer.on 'tokenized', tokenizedHandler
+        tokenizedBuffer.onDidTokenize tokenizedHandler
         editor.getBuffer().insert([0, 0], "'")
         fullyTokenize(tokenizedBuffer)
         expect(tokenizedHandler).not.toHaveBeenCalled()
@@ -495,7 +499,7 @@ describe "TokenizedBuffer", ->
 
       runs ->
         tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
-        tokenizedBuffer.on 'tokenized', tokenizedHandler
+        tokenizedBuffer.onDidTokenize tokenizedHandler
         fullyTokenize(tokenizedBuffer)
         tokenizedHandler.reset()
 
@@ -521,7 +525,7 @@ describe "TokenizedBuffer", ->
         tokenizedBuffer.setGrammar(atom.syntax.selectGrammar('test.erb'))
         fullyTokenize(tokenizedBuffer)
 
-        {tokens} = tokenizedBuffer.lineForScreenRow(0)
+        {tokens} = tokenizedBuffer.tokenizedLineForRow(0)
         expect(tokens[0]).toEqual value: "<div class='name'>", scopes: ["text.html.ruby"]
 
       waitsForPromise ->
@@ -529,7 +533,7 @@ describe "TokenizedBuffer", ->
 
       runs ->
         fullyTokenize(tokenizedBuffer)
-        {tokens} = tokenizedBuffer.lineForScreenRow(0)
+        {tokens} = tokenizedBuffer.tokenizedLineForRow(0)
         expect(tokens[0]).toEqual value: '<', scopes: ["text.html.ruby","meta.tag.block.any.html","punctuation.definition.tag.begin.html"]
 
   describe ".tokenForPosition(position)", ->
@@ -584,51 +588,112 @@ 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.tokenizedLineForRow(0).text).toBe "SST Sa line with tabsTand T spacesSTS"
+      # Also needs to work for copies
+      expect(tokenizedBuffer.tokenizedLineForRow(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.tokenizedLineForRow(0).endOfLineInvisibles).toEqual ['R', 'N']
+      expect(tokenizedBuffer.tokenizedLineForRow(1).endOfLineInvisibles).toEqual ['N']
+
+      # Lines ending in soft wraps get no invisibles
+      [left, right] = tokenizedBuffer.tokenizedLineForRow(0).softWrapAt(20)
+      expect(left.endOfLineInvisibles).toBe null
+      expect(right.endOfLineInvisibles).toEqual ['R', 'N']
+
+      tokenizedBuffer.setInvisibles(cr: 'R', eol: false)
+      expect(tokenizedBuffer.tokenizedLineForRow(0).endOfLineInvisibles).toEqual ['R']
+      expect(tokenizedBuffer.tokenizedLineForRow(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", ->
-      expect(tokenizedBuffer.lineForScreenRow(0).tokens[0].hasLeadingWhitespace).toBe false
-      expect(tokenizedBuffer.lineForScreenRow(1).tokens[0].hasLeadingWhitespace).toBe true
-      expect(tokenizedBuffer.lineForScreenRow(1).tokens[1].hasLeadingWhitespace).toBe false
-      expect(tokenizedBuffer.lineForScreenRow(2).tokens[0].hasLeadingWhitespace).toBe true
-      expect(tokenizedBuffer.lineForScreenRow(2).tokens[1].hasLeadingWhitespace).toBe true
-      expect(tokenizedBuffer.lineForScreenRow(2).tokens[2].hasLeadingWhitespace).toBe false
+    it "assigns ::firstNonWhitespaceIndex on tokens that have leading whitespace", ->
+      expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[0].firstNonWhitespaceIndex).toBe null
+      expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[0].firstNonWhitespaceIndex).toBe 2
+      expect(tokenizedBuffer.tokenizedLineForRow(1).tokens[1].firstNonWhitespaceIndex).toBe null
+
+      expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[0].firstNonWhitespaceIndex).toBe 2
+      expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[1].firstNonWhitespaceIndex).toBe 2
+      expect(tokenizedBuffer.tokenizedLineForRow(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[4].hasLeadingWhitespace).toBe false
+      expect(tokenizedBuffer.tokenizedLineForRow(5).tokens[3].firstNonWhitespaceIndex).toBe 1
+      expect(tokenizedBuffer.tokenizedLineForRow(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.tokenizedLineForRow(10).tokens[0].firstNonWhitespaceIndex).toBe null
 
-    it "sets ::hasTrailingWhitespace to true on tokens that have trailing whitespace", ->
+    it "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[12].hasTrailingWhitespace).toBe true
+      expect(tokenizedBuffer.tokenizedLineForRow(0).tokens[11].firstTrailingWhitespaceIndex).toBe null
+      expect(tokenizedBuffer.tokenizedLineForRow(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[15].hasTrailingWhitespace).toBe true
+      expect(tokenizedBuffer.tokenizedLineForRow(2).tokens[14].firstTrailingWhitespaceIndex).toBe null
+      expect(tokenizedBuffer.tokenizedLineForRow(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.tokenizedLineForRow(10).tokens[0].firstTrailingWhitespaceIndex).toBe 0
 
     it "only marks trailing whitespace on the last segment of a soft-wrapped line", ->
       buffer.insert([0, Infinity], '  ')
-      tokenizedLine = tokenizedBuffer.lineForScreenRow(0)
+      tokenizedLine = tokenizedBuffer.tokenizedLineForRow(0)
       [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.tokenizedLineForRow(0).copy()
+      expect(line.tokens[0].firstNonWhitespaceIndex).toBe 2
+      expect(line.tokens[line.tokens.length - 1].firstTrailingWhitespaceIndex).toBe 0
+
+    it "sets the ::firstNonWhitespaceIndex and ::firstTrailingWhitespaceIndex correctly when tokens are split for soft-wrapping", ->
+      tokenizedBuffer.setInvisibles(space: 'S')
+      buffer.setText(" token ")
+      fullyTokenize(tokenizedBuffer)
+      token = tokenizedBuffer.tokenizedLines[0].tokens[0]
+
+      [leftToken, rightToken] = token.splitAt(1)
+      expect(leftToken.hasInvisibleCharacters).toBe true
+      expect(leftToken.firstNonWhitespaceIndex).toBe 1
+      expect(leftToken.firstTrailingWhitespaceIndex).toBe null
+
+      expect(leftToken.hasInvisibleCharacters).toBe true
+      expect(rightToken.firstNonWhitespaceIndex).toBe null
+      expect(rightToken.firstTrailingWhitespaceIndex).toBe 5
 
   describe "indent level", ->
     beforeEach ->
@@ -638,84 +703,84 @@ describe "TokenizedBuffer", ->
 
     describe "when the line is non-empty", ->
       it "has an indent level based on the leading whitespace on the line", ->
-        expect(tokenizedBuffer.lineForScreenRow(0).indentLevel).toBe 0
-        expect(tokenizedBuffer.lineForScreenRow(1).indentLevel).toBe 1
-        expect(tokenizedBuffer.lineForScreenRow(2).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(0).indentLevel).toBe 0
+        expect(tokenizedBuffer.tokenizedLineForRow(1).indentLevel).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(2).indentLevel).toBe 2
         buffer.insert([2, 0], ' ')
-        expect(tokenizedBuffer.lineForScreenRow(2).indentLevel).toBe 2.5
+        expect(tokenizedBuffer.tokenizedLineForRow(2).indentLevel).toBe 2.5
 
     describe "when the line is empty", ->
       it "assumes the indentation level of the first non-empty line below or above if one exists", ->
         buffer.insert([12, 0], '    ')
         buffer.insert([12, Infinity], '\n\n')
-        expect(tokenizedBuffer.lineForScreenRow(13).indentLevel).toBe 2
-        expect(tokenizedBuffer.lineForScreenRow(14).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(13).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(14).indentLevel).toBe 2
 
         buffer.insert([1, Infinity], '\n\n')
-        expect(tokenizedBuffer.lineForScreenRow(2).indentLevel).toBe 2
-        expect(tokenizedBuffer.lineForScreenRow(3).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(2).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(3).indentLevel).toBe 2
 
         buffer.setText('\n\n\n')
-        expect(tokenizedBuffer.lineForScreenRow(1).indentLevel).toBe 0
+        expect(tokenizedBuffer.tokenizedLineForRow(1).indentLevel).toBe 0
 
     describe "when the changed lines are surrounded by whitespace-only lines", ->
       it "updates the indentLevel of empty lines that precede the change", ->
-        expect(tokenizedBuffer.lineForScreenRow(12).indentLevel).toBe 0
+        expect(tokenizedBuffer.tokenizedLineForRow(12).indentLevel).toBe 0
 
         buffer.insert([12, 0], '\n')
         buffer.insert([13, 0], '  ')
-        expect(tokenizedBuffer.lineForScreenRow(12).indentLevel).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(12).indentLevel).toBe 1
 
       it "updates empty line indent guides when the empty line is the last line", ->
         buffer.insert([12, 2], '\n')
 
         # The newline and he tab need to be in two different operations to surface the bug
         buffer.insert([12, 0], '  ')
-        expect(tokenizedBuffer.lineForScreenRow(13).indentLevel).toBe 1
+        expect(tokenizedBuffer.tokenizedLineForRow(13).indentLevel).toBe 1
 
         buffer.insert([12, 0], '  ')
-        expect(tokenizedBuffer.lineForScreenRow(13).indentLevel).toBe 2
-        expect(tokenizedBuffer.lineForScreenRow(14)).not.toBeDefined()
+        expect(tokenizedBuffer.tokenizedLineForRow(13).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(14)).not.toBeDefined()
 
       it "updates the indentLevel of empty lines surrounding a change that inserts lines", ->
         # create some new lines
         buffer.insert([7, 0], '\n\n')
         buffer.insert([5, 0], '\n\n')
 
-        expect(tokenizedBuffer.lineForScreenRow(5).indentLevel).toBe 3
-        expect(tokenizedBuffer.lineForScreenRow(6).indentLevel).toBe 3
-        expect(tokenizedBuffer.lineForScreenRow(9).indentLevel).toBe 3
-        expect(tokenizedBuffer.lineForScreenRow(10).indentLevel).toBe 3
-        expect(tokenizedBuffer.lineForScreenRow(11).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(5).indentLevel).toBe 3
+        expect(tokenizedBuffer.tokenizedLineForRow(6).indentLevel).toBe 3
+        expect(tokenizedBuffer.tokenizedLineForRow(9).indentLevel).toBe 3
+        expect(tokenizedBuffer.tokenizedLineForRow(10).indentLevel).toBe 3
+        expect(tokenizedBuffer.tokenizedLineForRow(11).indentLevel).toBe 2
 
-        tokenizedBuffer.on "changed", changeHandler = jasmine.createSpy('changeHandler')
+        tokenizedBuffer.onDidChange changeHandler = jasmine.createSpy('changeHandler')
 
         buffer.setTextInRange([[7, 0], [8, 65]], '        one\n        two\n        three\n        four')
 
         delete changeHandler.argsForCall[0][0].bufferChange
         expect(changeHandler).toHaveBeenCalledWith(start: 5, end: 10, delta: 2)
 
-        expect(tokenizedBuffer.lineForScreenRow(5).indentLevel).toBe 4
-        expect(tokenizedBuffer.lineForScreenRow(6).indentLevel).toBe 4
-        expect(tokenizedBuffer.lineForScreenRow(11).indentLevel).toBe 4
-        expect(tokenizedBuffer.lineForScreenRow(12).indentLevel).toBe 4
-        expect(tokenizedBuffer.lineForScreenRow(13).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(5).indentLevel).toBe 4
+        expect(tokenizedBuffer.tokenizedLineForRow(6).indentLevel).toBe 4
+        expect(tokenizedBuffer.tokenizedLineForRow(11).indentLevel).toBe 4
+        expect(tokenizedBuffer.tokenizedLineForRow(12).indentLevel).toBe 4
+        expect(tokenizedBuffer.tokenizedLineForRow(13).indentLevel).toBe 2
 
       it "updates the indentLevel of empty lines surrounding a change that removes lines", ->
         # create some new lines
         buffer.insert([7, 0], '\n\n')
         buffer.insert([5, 0], '\n\n')
 
-        tokenizedBuffer.on "changed", changeHandler = jasmine.createSpy('changeHandler')
+        tokenizedBuffer.onDidChange changeHandler = jasmine.createSpy('changeHandler')
 
         buffer.setTextInRange([[7, 0], [8, 65]], '    ok')
 
         delete changeHandler.argsForCall[0][0].bufferChange
         expect(changeHandler).toHaveBeenCalledWith(start: 5, end: 10, delta: -1)
 
-        expect(tokenizedBuffer.lineForScreenRow(5).indentLevel).toBe 2
-        expect(tokenizedBuffer.lineForScreenRow(6).indentLevel).toBe 2
-        expect(tokenizedBuffer.lineForScreenRow(7).indentLevel).toBe 2 # new text
-        expect(tokenizedBuffer.lineForScreenRow(8).indentLevel).toBe 2
-        expect(tokenizedBuffer.lineForScreenRow(9).indentLevel).toBe 2
-        expect(tokenizedBuffer.lineForScreenRow(10).indentLevel).toBe 2 # }
+        expect(tokenizedBuffer.tokenizedLineForRow(5).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(6).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(7).indentLevel).toBe 2 # new text
+        expect(tokenizedBuffer.tokenizedLineForRow(8).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(9).indentLevel).toBe 2
+        expect(tokenizedBuffer.tokenizedLineForRow(10).indentLevel).toBe 2 # }

spec/tokenized-line-spec.coffee

@@ -10,13 +10,13 @@ describe "TokenizedLine", ->
         atom.project.open('coffee.coffee').then (o) -> editor = o
 
     it "returns true when the line is only whitespace", ->
-      expect(editor.lineForScreenRow(3).isOnlyWhitespace()).toBe true
-      expect(editor.lineForScreenRow(7).isOnlyWhitespace()).toBe true
-      expect(editor.lineForScreenRow(23).isOnlyWhitespace()).toBe true
+      expect(editor.tokenizedLineForScreenRow(3).isOnlyWhitespace()).toBe true
+      expect(editor.tokenizedLineForScreenRow(7).isOnlyWhitespace()).toBe true
+      expect(editor.tokenizedLineForScreenRow(23).isOnlyWhitespace()).toBe true
 
     it "returns false when the line is not only whitespace", ->
-      expect(editor.lineForScreenRow(0).isOnlyWhitespace()).toBe false
-      expect(editor.lineForScreenRow(2).isOnlyWhitespace()).toBe false
+      expect(editor.tokenizedLineForScreenRow(0).isOnlyWhitespace()).toBe false
+      expect(editor.tokenizedLineForScreenRow(2).isOnlyWhitespace()).toBe false
 
   describe "::getScopeTree()", ->
     it "returns a tree whose inner nodes are scopes and whose leaf nodes are tokens in those scopes", ->
@@ -35,6 +35,6 @@ describe "TokenizedLine", ->
 
       runs ->
         tokenIndex = 0
-        tokens = editor.lineForScreenRow(1).tokens
-        scopeTree = editor.lineForScreenRow(1).getScopeTree()
+        tokens = editor.tokenizedLineForScreenRow(1).tokens
+        scopeTree = editor.tokenizedLineForScreenRow(1).getScopeTree()
         ensureValidScopeTree(scopeTree)

spec/window-spec.coffee

@@ -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
 
@@ -255,3 +256,35 @@ describe "Window", ->
 
         elements.trigger "core:focus-previous"
         expect(elements.find("[tabindex=1]:focus")).toExist()
+
+  describe "the window:open-path event", ->
+    beforeEach ->
+      spyOn(atom.workspace, 'open')
+
+    describe "when the project does not have a path", ->
+      beforeEach ->
+        atom.project.setPath()
+
+      describe "when the opened path exists", ->
+        it "sets the project path to the opened path", ->
+          $(window).trigger('window:open-path', [{pathToOpen: __filename}])
+
+          expect(atom.project.getPath()).toBe __dirname
+
+      describe "when the opened path does not exist but its parent directory does", ->
+        it "sets the project path to the opened path's parent directory", ->
+          $(window).trigger('window:open-path', [{pathToOpen: path.join(__dirname, 'this-path-does-not-exist.txt')}])
+
+          expect(atom.project.getPath()).toBe __dirname
+
+    describe "when the opened path is a file", ->
+      it "opens it in the workspace", ->
+        $(window).trigger('window:open-path', [{pathToOpen: __filename}])
+
+        expect(atom.workspace.open.mostRecentCall.args[0]).toBe __filename
+
+    describe "when the opened path is a directory", ->
+      it "does not open it in the workspace", ->
+        $(window).trigger('window:open-path', [{pathToOpen: __dirname}])
+
+        expect(atom.workspace.open.callCount).toBe 0

spec/workspace-spec.coffee

@@ -8,8 +8,12 @@ describe "Workspace", ->
     atom.workspace = workspace = new Workspace
 
   describe "::open(uri, options)", ->
+    openEvents = null
+
     beforeEach ->
-      spyOn(workspace.activePane, 'activate').andCallThrough()
+      openEvents = []
+      workspace.onDidOpen (event) -> openEvents.push(event)
+      spyOn(workspace.getActivePane(), 'activate').andCallThrough()
 
     describe "when the 'searchAllPanes' option is false (default)", ->
       describe "when called without a uri", ->
@@ -21,18 +25,21 @@ describe "Workspace", ->
 
           runs ->
             expect(editor1.getPath()).toBeUndefined()
-            expect(workspace.activePane.items).toEqual [editor1]
-            expect(workspace.activePaneItem).toBe editor1
-            expect(workspace.activePane.activate).toHaveBeenCalled()
+            expect(workspace.getActivePane().items).toEqual [editor1]
+            expect(workspace.getActivePaneItem()).toBe editor1
+            expect(workspace.getActivePane().activate).toHaveBeenCalled()
+            expect(openEvents).toEqual [{uri: undefined, pane: workspace.getActivePane(), item: editor1, index: 0}]
+            openEvents = []
 
           waitsForPromise ->
             workspace.open().then (editor) -> editor2 = editor
 
           runs ->
             expect(editor2.getPath()).toBeUndefined()
-            expect(workspace.activePane.items).toEqual [editor1, editor2]
-            expect(workspace.activePaneItem).toBe editor2
-            expect(workspace.activePane.activate).toHaveBeenCalled()
+            expect(workspace.getActivePane().items).toEqual [editor1, editor2]
+            expect(workspace.getActivePaneItem()).toBe editor2
+            expect(workspace.getActivePane().activate).toHaveBeenCalled()
+            expect(openEvents).toEqual [{uri: undefined, pane: workspace.getActivePane(), item: editor2, index: 1}]
 
       describe "when called with a uri", ->
         describe "when the active pane already has an editor for the given uri", ->
@@ -51,8 +58,29 @@ describe "Workspace", ->
 
             runs ->
               expect(editor).toBe editor1
-              expect(workspace.activePaneItem).toBe editor
-              expect(workspace.activePane.activate).toHaveBeenCalled()
+              expect(workspace.getActivePaneItem()).toBe editor
+              expect(workspace.getActivePane().activate).toHaveBeenCalled()
+
+              expect(openEvents).toEqual [
+                {
+                  uri: atom.project.resolve('a')
+                  item: editor1
+                  pane: atom.workspace.getActivePane()
+                  index: 0
+                }
+                {
+                  uri: atom.project.resolve('b')
+                  item: editor2
+                  pane: atom.workspace.getActivePane()
+                  index: 1
+                }
+                {
+                  uri: atom.project.resolve('a')
+                  item: editor1
+                  pane: atom.workspace.getActivePane()
+                  index: 0
+                }
+              ]
 
         describe "when the active pane does not have an editor for the given uri", ->
           it "adds and activates a new editor for the given path on the active pane", ->
@@ -62,9 +90,9 @@ describe "Workspace", ->
 
             runs ->
               expect(editor.getUri()).toBe atom.project.resolve('a')
-              expect(workspace.activePaneItem).toBe editor
-              expect(workspace.activePane.items).toEqual [editor]
-              expect(workspace.activePane.activate).toHaveBeenCalled()
+              expect(workspace.getActivePaneItem()).toBe editor
+              expect(workspace.getActivePane().items).toEqual [editor]
+              expect(workspace.getActivePane().activate).toHaveBeenCalled()
 
     describe "when the 'searchAllPanes' option is true", ->
       describe "when an editor for the given uri is already open on an inactive pane", ->
@@ -83,14 +111,14 @@ describe "Workspace", ->
             workspace.open('b').then (o) -> editor2 = o
 
           runs ->
-            expect(workspace.activePaneItem).toBe editor2
+            expect(workspace.getActivePaneItem()).toBe editor2
 
           waitsForPromise ->
             workspace.open('a', searchAllPanes: true)
 
           runs ->
-            expect(workspace.activePane).toBe pane1
-            expect(workspace.activePaneItem).toBe editor1
+            expect(workspace.getActivePane()).toBe pane1
+            expect(workspace.getActivePaneItem()).toBe editor1
 
       describe "when no editor for the given uri is open in any pane", ->
         it "opens an editor for the given uri in the active pane", ->
@@ -99,21 +127,21 @@ describe "Workspace", ->
             workspace.open('a', searchAllPanes: true).then (o) -> editor = o
 
           runs ->
-            expect(workspace.activePaneItem).toBe editor
+            expect(workspace.getActivePaneItem()).toBe editor
 
     describe "when the 'split' option is set", ->
       describe "when the 'split' option is 'left'", ->
         it "opens the editor in the leftmost pane of the current pane axis", ->
-          pane1 = workspace.activePane
+          pane1 = workspace.getActivePane()
           pane2 = pane1.splitRight()
-          expect(workspace.activePane).toBe pane2
+          expect(workspace.getActivePane()).toBe pane2
 
           editor = null
           waitsForPromise ->
             workspace.open('a', split: 'left').then (o) -> editor = o
 
           runs ->
-            expect(workspace.activePane).toBe pane1
+            expect(workspace.getActivePane()).toBe pane1
             expect(pane1.items).toEqual [editor]
             expect(pane2.items).toEqual []
 
@@ -123,37 +151,37 @@ describe "Workspace", ->
             workspace.open('a', split: 'left').then (o) -> editor = o
 
           runs ->
-            expect(workspace.activePane).toBe pane1
+            expect(workspace.getActivePane()).toBe pane1
             expect(pane1.items).toEqual [editor]
             expect(pane2.items).toEqual []
 
       describe "when a pane axis is the leftmost sibling of the current pane", ->
         it "opens the new item in the current pane", ->
           editor = null
-          pane1 = workspace.activePane
+          pane1 = workspace.getActivePane()
           pane2 = pane1.splitLeft()
           pane3 = pane2.splitDown()
           pane1.activate()
-          expect(workspace.activePane).toBe pane1
+          expect(workspace.getActivePane()).toBe pane1
 
           waitsForPromise ->
             workspace.open('a', split: 'left').then (o) -> editor = o
 
           runs ->
-            expect(workspace.activePane).toBe pane1
+            expect(workspace.getActivePane()).toBe pane1
             expect(pane1.items).toEqual [editor]
 
       describe "when the 'split' option is 'right'", ->
         it "opens the editor in the rightmost pane of the current pane axis", ->
           editor = null
-          pane1 = workspace.activePane
+          pane1 = workspace.getActivePane()
           pane2 = null
           waitsForPromise ->
             workspace.open('a', split: 'right').then (o) -> editor = o
 
           runs ->
             pane2 = workspace.getPanes().filter((p) -> p != pane1)[0]
-            expect(workspace.activePane).toBe pane2
+            expect(workspace.getActivePane()).toBe pane2
             expect(pane1.items).toEqual []
             expect(pane2.items).toEqual [editor]
 
@@ -163,18 +191,18 @@ describe "Workspace", ->
             workspace.open('a', split: 'right').then (o) -> editor = o
 
           runs ->
-            expect(workspace.activePane).toBe pane2
+            expect(workspace.getActivePane()).toBe pane2
             expect(pane1.items).toEqual []
             expect(pane2.items).toEqual [editor]
 
         describe "when a pane axis is the rightmost sibling of the current pane", ->
           it "opens the new item in a new pane split to the right of the current pane", ->
             editor = null
-            pane1 = workspace.activePane
+            pane1 = workspace.getActivePane()
             pane2 = pane1.splitRight()
             pane3 = pane2.splitDown()
             pane1.activate()
-            expect(workspace.activePane).toBe pane1
+            expect(workspace.getActivePane()).toBe pane1
             pane4 = null
 
             waitsForPromise ->
@@ -182,7 +210,7 @@ describe "Workspace", ->
 
             runs ->
               pane4 = workspace.getPanes().filter((p) -> p != pane1)[0]
-              expect(workspace.activePane).toBe pane4
+              expect(workspace.getActivePane()).toBe pane4
               expect(pane4.items).toEqual [editor]
               expect(workspace.paneContainer.root.children[0]).toBe pane1
               expect(workspace.paneContainer.root.children[1]).toBe pane4
@@ -203,21 +231,21 @@ describe "Workspace", ->
           workspace.open("bar://baz").then (item) ->
             expect(item).toEqual { bar: "bar://baz" }
 
-    it "emits an 'editor-created' event", ->
+    it "notifies ::onDidAddTextEditor observers", ->
       absolutePath = require.resolve('./fixtures/dir/a')
       newEditorHandler = jasmine.createSpy('newEditorHandler')
-      workspace.on 'editor-created', newEditorHandler
+      workspace.onDidAddTextEditor newEditorHandler
 
       editor = null
       waitsForPromise ->
         workspace.open(absolutePath).then (e) -> editor = e
 
       runs ->
-        expect(newEditorHandler).toHaveBeenCalledWith editor
+        expect(newEditorHandler.argsForCall[0][0].textEditor).toBe editor
 
   describe "::reopenItem()", ->
     it "opens the uri associated with the last closed pane that isn't currently open", ->
-      pane = workspace.activePane
+      pane = workspace.getActivePane()
       waitsForPromise ->
         workspace.open('a').then ->
           workspace.open('b').then ->
@@ -226,44 +254,44 @@ describe "Workspace", ->
 
       runs ->
         # does not reopen items with no uri
-        expect(workspace.activePaneItem.getUri()).toBeUndefined()
+        expect(workspace.getActivePaneItem().getUri()).toBeUndefined()
         pane.destroyActiveItem()
 
       waitsForPromise ->
         workspace.reopenItem()
 
       runs ->
-        expect(workspace.activePaneItem.getUri()).not.toBeUndefined()
+        expect(workspace.getActivePaneItem().getUri()).not.toBeUndefined()
 
         # destroy all items
-        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('file1')
+        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('file1')
         pane.destroyActiveItem()
-        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('b')
+        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('b')
         pane.destroyActiveItem()
-        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('a')
+        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('a')
         pane.destroyActiveItem()
 
         # reopens items with uris
-        expect(workspace.activePaneItem).toBeUndefined()
+        expect(workspace.getActivePaneItem()).toBeUndefined()
 
       waitsForPromise ->
         workspace.reopenItem()
 
       runs ->
-        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('a')
+        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('a')
 
       # does not reopen items that are already open
       waitsForPromise ->
         workspace.open('b')
 
       runs ->
-        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('b')
+        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('b')
 
       waitsForPromise ->
         workspace.reopenItem()
 
       runs ->
-        expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('file1')
+        expect(workspace.getActivePaneItem().getUri()).toBe atom.project.resolve('file1')
 
   describe "::increase/decreaseFontSize()", ->
     it "increases/decreases the font size without going below 1", ->
@@ -282,7 +310,22 @@ describe "Workspace", ->
   describe "::openLicense()", ->
     it "opens the license as plain-text in a buffer", ->
       waitsForPromise -> workspace.openLicense()
-      runs -> expect(workspace.activePaneItem.getText()).toMatch /Copyright/
+      runs -> expect(workspace.getActivePaneItem().getText()).toMatch /Copyright/
+
+  describe "::observeTextEditors()", ->
+    it "invokes the observer with current and future text editors", ->
+      observed = []
+
+      waitsForPromise -> workspace.open()
+      waitsForPromise -> workspace.open()
+      waitsForPromise -> workspace.openLicense()
+
+      runs ->
+        workspace.observeTextEditors (editor) -> observed.push(editor)
+
+      waitsForPromise -> workspace.open()
+
+      expect(observed).toEqual workspace.getTextEditors()
 
   describe "when an editor is destroyed", ->
     it "removes the editor", ->
@@ -292,23 +335,9 @@ describe "Workspace", ->
         workspace.open("a").then (e) -> editor = e
 
       runs ->
-        expect(workspace.getEditors()).toHaveLength 1
+        expect(workspace.getTextEditors()).toHaveLength 1
         editor.destroy()
-        expect(workspace.getEditors()).toHaveLength 0
-
-  describe "when an editor is copied", ->
-    it "emits an 'editor-created' event", ->
-      editor = null
-      handler = jasmine.createSpy('editorCreatedHandler')
-      workspace.on 'editor-created', handler
-
-      waitsForPromise ->
-        workspace.open("a").then (o) -> editor = o
-
-      runs ->
-        expect(handler.callCount).toBe 1
-        editorCopy = editor.copy()
-        expect(handler.callCount).toBe 2
+        expect(workspace.getTextEditors()).toHaveLength 0
 
   it "stores the active grammars used by all the open editors", ->
     waitsForPromise ->
@@ -317,14 +346,19 @@ describe "Workspace", ->
     waitsForPromise ->
       atom.packages.activatePackage('language-coffee-script')
 
+    waitsForPromise ->
+      atom.packages.activatePackage('language-todo')
+
     waitsForPromise ->
       atom.workspace.open('sample.coffee')
 
     runs ->
-      atom.workspace.getActiveEditor().setText('i = /test/;')
+      atom.workspace.getActiveEditor().setText """
+        i = /test/; #FIXME
+      """
 
       state = atom.workspace.serialize()
-      expect(state.packagesWithActiveGrammars).toEqual ['language-coffee-script', 'language-javascript']
+      expect(state.packagesWithActiveGrammars).toEqual ['language-coffee-script', 'language-javascript', 'language-todo']
 
       jsPackage = atom.packages.getLoadedPackage('language-javascript')
       coffeePackage = atom.packages.getLoadedPackage('language-coffee-script')

spec/workspace-view-spec.coffee

@@ -20,7 +20,6 @@ describe "WorkspaceView", ->
     waitsForPromise ->
       atom.workspace.open(pathToOpen)
 
-
   describe "@deserialize()", ->
     viewState = null
 
@@ -43,7 +42,7 @@ describe "WorkspaceView", ->
         runs ->
           editorView1 = atom.workspaceView.getActiveView()
           buffer = editorView1.getEditor().getBuffer()
-          editorView1.splitRight()
+          editorView1.getPaneView().getModel().splitRight(copyActiveItem: true)
           expect(atom.workspaceView.getActivePaneView()).toBe atom.workspaceView.getPaneViews()[1]
 
           simulateReload()
@@ -196,27 +195,29 @@ describe "WorkspaceView", ->
       atom.workspaceView.height(200)
       atom.workspaceView.attachToDom()
       rightEditorView = atom.workspaceView.getActiveView()
-      rightEditorView.getEditor().setText("\t  ")
-      leftEditorView = rightEditorView.splitLeft()
+      rightEditorView.getEditor().setText("\t  \n")
+      rightEditorView.getPaneView().getModel().splitLeft(copyActiveItem: true)
+      leftEditorView = atom.workspaceView.getActiveView()
       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"
       expect(rightEditorView.find(".line:first").text()).toBe withInvisiblesShowing
       expect(leftEditorView.find(".line:first").text()).toBe withInvisiblesShowing
 
-      lowerLeftEditorView = leftEditorView.splitDown()
+      leftEditorView.getPaneView().getModel().splitDown(copyActiveItem: true)
+      lowerLeftEditorView = atom.workspaceView.getActiveView()
       expect(lowerLeftEditorView.find(".line:first").text()).toBe withInvisiblesShowing
 
       atom.workspaceView.trigger "window:toggle-invisibles"
       expect(rightEditorView.find(".line:first").text()).toBe "    "
       expect(leftEditorView.find(".line:first").text()).toBe "    "
 
-      lowerRightEditorView = rightEditorView.splitDown()
+      rightEditorView.getPaneView().getModel().splitDown(copyActiveItem: true)
+      lowerRightEditorView = atom.workspaceView.getActiveView()
       expect(lowerRightEditorView.find(".line:first").text()).toBe "    "
 
   describe ".eachEditorView(callback)", ->
@@ -243,7 +244,7 @@ describe "WorkspaceView", ->
       atom.workspaceView.eachEditorView(callback)
       count = 0
       callbackEditor = null
-      atom.workspaceView.getActiveView().splitRight()
+      atom.workspaceView.getActiveView().getPaneView().getModel().splitRight(copyActiveItem: true)
       expect(count).toBe 1
       expect(callbackEditor).toBe atom.workspaceView.getActiveView()
 
@@ -261,10 +262,10 @@ describe "WorkspaceView", ->
 
       subscription = atom.workspaceView.eachEditorView(callback)
       expect(count).toBe 1
-      atom.workspaceView.getActiveView().splitRight()
+      atom.workspaceView.getActiveView().getPaneView().getModel().splitRight(copyActiveItem: true)
       expect(count).toBe 2
       subscription.off()
-      atom.workspaceView.getActiveView().splitRight()
+      atom.workspaceView.getActiveView().getPaneView().getModel().splitRight(copyActiveItem: true)
       expect(count).toBe 2
 
   describe "core:close", ->
@@ -273,7 +274,7 @@ describe "WorkspaceView", ->
 
       paneView1 = atom.workspaceView.getActivePaneView()
       editorView = atom.workspaceView.getActiveView()
-      editorView.splitRight()
+      editorView.getPaneView().getModel().splitRight(copyActiveItem: true)
       paneView2 = atom.workspaceView.getActivePaneView()
 
       expect(paneView1).not.toBe paneView2
@@ -294,3 +295,31 @@ describe "WorkspaceView", ->
       expect(atom.workspaceView).toHaveClass 'scrollbars-visible-always'
       scrollbarStyle.emitValue 'overlay'
       expect(atom.workspaceView).toHaveClass 'scrollbars-visible-when-scrolling'
+
+  describe "editor font styling", ->
+    [editorNode, editor] = []
+
+    beforeEach ->
+      atom.workspaceView.attachToDom()
+      editorNode = atom.workspaceView.find('.editor')[0]
+      editor = atom.workspaceView.find('.editor').view().getEditor()
+
+    it "updates the font-size based on the 'editor.fontSize' config value", ->
+      initialCharWidth = editor.getDefaultCharWidth()
+      expect(getComputedStyle(editorNode).fontSize).toBe atom.config.get('editor.fontSize') + 'px'
+      atom.config.set('editor.fontSize', atom.config.get('editor.fontSize') + 5)
+      expect(getComputedStyle(editorNode).fontSize).toBe atom.config.get('editor.fontSize') + 'px'
+      expect(editor.getDefaultCharWidth()).toBeGreaterThan initialCharWidth
+
+    it "updates the font-family based on the 'editor.fontFamily' config value", ->
+      initialCharWidth = editor.getDefaultCharWidth()
+      expect(getComputedStyle(editorNode).fontFamily).toBe atom.config.get('editor.fontFamily')
+      atom.config.set('editor.fontFamily', 'sans-serif')
+      expect(getComputedStyle(editorNode).fontFamily).toBe atom.config.get('editor.fontFamily')
+      expect(editor.getDefaultCharWidth()).not.toBe initialCharWidth
+
+    it "updates the line-height based on the 'editor.lineHeight' config value", ->
+      initialLineHeight = editor.getLineHeightInPixels()
+      atom.config.set('editor.lineHeight', '30px')
+      expect(getComputedStyle(editorNode).lineHeight).toBe atom.config.get('editor.lineHeight')
+      expect(editor.getLineHeightInPixels()).not.toBe initialLineHeight

src/atom.coffee

@@ -17,29 +17,14 @@ WindowEventHandler = require './window-event-handler'
 # Public: Atom global for dealing with packages, themes, menus, and the window.
 #
 # An instance of this class is always available as the `atom` global.
-#
-# ## Useful properties available:
-#
-#  * `atom.clipboard`     - A {Clipboard} instance
-#  * `atom.config`        - A {Config} instance
-#  * `atom.contextMenu`   - A {ContextMenuManager} instance
-#  * `atom.deserializers` - A {DeserializerManager} instance
-#  * `atom.keymaps`        - A {KeymapManager} instance
-#  * `atom.menu`          - A {MenuManager} instance
-#  * `atom.packages`      - A {PackageManager} instance
-#  * `atom.project`       - A {Project} instance
-#  * `atom.syntax`        - A {Syntax} instance
-#  * `atom.themes`        - A {ThemeManager} instance
-#  * `atom.workspace`     - A {Workspace} instance
-#  * `atom.workspaceView` - A {WorkspaceView} instance
 module.exports =
 class Atom extends Model
   @version: 1  # Increment this when the serialization format changes
 
   # Public: Load or create the Atom environment in the given mode.
   #
-  # mode - Pass 'editor' or 'spec' depending on the kind of environment you
-  #        want to build.
+  # * `mode` A {String} mode that is either 'editor' or 'spec' depending on the
+  #   kind of environment you want to build.
   #
   # Returns an Atom instance, fully initialized
   @loadOrCreate: (mode) ->
@@ -110,15 +95,44 @@ class Atom extends Model
   @getCurrentWindow: ->
     remote.getCurrentWindow()
 
-  # Get the version of the Atom application.
-  @getVersion: ->
-    @appVersion ?= @getLoadSettings().appVersion
-
-  # Determine whether the current version is an official release.
-  @isReleasedVersion: ->
-    not /\w{7}/.test(@getVersion()) # Check if the release is a 7-character SHA prefix
-
   workspaceViewParentSelector: 'body'
+  lastUncaughtError: null
+
+  # Public: A {Clipboard} instance
+  clipboard: null
+
+  # Public: A {Config} instance
+  config: null
+
+  # Public: A {ContextMenuManager} instance
+  contextMenu: null
+
+  # Public: A {DeserializerManager} instance
+  deserializers: null
+
+  # Public: A {KeymapManager} instance
+  keymaps: null
+
+  # Public: A {MenuManager} instance
+  menu: null
+
+  # Public: A {PackageManager} instance
+  packages: null
+
+  # Public: A {Project} instance
+  project: null
+
+  # Public: A {Syntax} instance
+  syntax: null
+
+  # Public: A {ThemeManager} instance
+  themes: null
+
+  # Public: A {Workspace} instance
+  workspace: null
+
+  # Public: A {WorkspaceView} instance
+  workspaceView: null
 
   # Call .loadOrCreate instead
   constructor: (@state) ->
@@ -127,12 +141,14 @@ class Atom extends Model
     @deserializers = new DeserializerManager()
 
   # Public: Sets up the basic services that should be available in all modes
-  # (both spec and application). Call after this instance has been assigned to
-  # the `atom` global.
+  # (both spec and application).
+  #
+  # Call after this instance has been assigned to the `atom` global.
   initialize: ->
     window.onerror = =>
       @openDevTools()
       @executeJavaScriptInDevTools('InspectorFrontendAPI.showConsole()')
+      @lastUncaughtError = Array::slice.call(arguments)
       @emit 'uncaught-error', arguments...
 
     @unsubscribe()
@@ -158,20 +174,20 @@ 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})
-    @contextMenu = new ContextMenuManager(devMode)
+    @themes = new ThemeManager({packageManager: @packages, configDirPath, resourcePath, safeMode})
+    @contextMenu = new ContextMenuManager({resourcePath, devMode})
     @menu = new MenuManager({resourcePath})
     @clipboard = new Clipboard()
 
     @syntax = @deserializers.deserialize(@state.syntax) ? new Syntax()
 
-    @subscribe @packages, 'activated', => @watchThemes()
+    @subscribe @packages.onDidActivateAll => @watchThemes()
 
     Project = require './project'
     TextBuffer = require 'text-buffer'
@@ -199,12 +215,17 @@ class Atom extends Model
 
   # Public: Get the dimensions of this window.
   #
-  # Returns an object with x, y, width, and height keys.
+  # Returns an {Object} with the following keys:
+  #   * `x`      The window's x-position {Number}.
+  #   * `y`      The window's y-position {Number}.
+  #   * `width`  The window's width {Number}.
+  #   * `height` The window's height {Number}.
   getWindowDimensions: ->
     browserWindow = @getCurrentWindow()
     [x, y] = browserWindow.getPosition()
     [width, height] = browserWindow.getSize()
-    {x, y, width, height}
+    maximized = browserWindow.isMaximized()
+    {x, y, width, height, maximized}
 
   # Public: Set the dimensions of the window.
   #
@@ -212,11 +233,11 @@ class Atom extends Model
   # in the dimensions parameter. If x or y are omitted the window will be
   # centered. If height or width are omitted only the position will be changed.
   #
-  # dimensions - An {Object} with the following keys:
-  #   :x - The new x coordinate.
-  #   :y - The new y coordinate.
-  #   :width - The new width.
-  #   :height - The new height.
+  # * `dimensions` An {Object} with the following keys:
+  #   * `x` The new x coordinate.
+  #   * `y` The new y coordinate.
+  #   * `width` The new width.
+  #   * `height` The new height.
   setWindowDimensions: ({x, y, width, height}) ->
     if width? and height?
       @setSize(width, height)
@@ -257,6 +278,7 @@ class Atom extends Model
     unless @isValidDimensions(dimensions)
       dimensions = @getDefaultWindowDimensions()
     @setWindowDimensions(dimensions)
+    dimensions
 
   storeWindowDimensions: ->
     dimensions = @getWindowDimensions()
@@ -264,7 +286,7 @@ class Atom extends Model
 
   # Public: Get the load settings for the current window.
   #
-  # Returns an object containing all the load setting key/value pairs.
+  # Returns an {Object} containing all the load setting key/value pairs.
   getLoadSettings: ->
     @constructor.getLoadSettings()
 
@@ -299,14 +321,15 @@ class Atom extends Model
 
   # Call this method when establishing a real application window.
   startEditorWindow: ->
+    {resourcePath, safeMode} = @getLoadSettings()
+
     CommandInstaller = require './command-installer'
-    resourcePath = atom.getLoadSettings().resourcePath
     CommandInstaller.installAtomCommand resourcePath, false, (error) ->
       console.warn error.message if error?
     CommandInstaller.installApmCommand resourcePath, false, (error) ->
       console.warn error.message if error?
 
-    @restoreWindowDimensions()
+    dimensions = @restoreWindowDimensions()
     @config.load()
     @config.setDefaults('core', require('./workspace-view').configDefaults)
     @config.setDefaults('editor', require('./editor-view').configDefaults)
@@ -314,17 +337,16 @@ class Atom extends Model
     @themes.loadBaseStylesheets()
     @packages.loadPackages()
     @deserializeEditorWindow()
+
+    @watchProjectPath()
+
     @packages.activate()
     @keymaps.loadUserKeymap()
-    @requireUserInitScript()
+    @requireUserInitScript() unless safeMode
     @menu.update()
 
-    $(window).on 'unload', =>
-      $(document.body).css('visibility', 'hidden')
-      @unloadEditorWindow()
-      false
-
-    @displayWindow()
+    maximize = dimensions?.maximized and process.platform isnt 'darwin'
+    @displayWindow({maximize})
 
   unloadEditorWindow: ->
     return if not @project and not @workspaceView
@@ -335,52 +357,70 @@ 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()
 
   watchThemes: ->
-    @themes.on 'reloaded', =>
+    @themes.onDidReloadAll =>
       # Only reload stylesheets from non-theme packages
       for pack in @packages.getActivePackages() when pack.getType() isnt 'theme'
         pack.reloadStylesheets?()
       null
 
+  # Notify the browser project of the window's current project path
+  watchProjectPath: ->
+    onProjectPathChanged = =>
+      ipc.send('window-command', 'project-path-changed', @project.getPath())
+    @subscribe @project, 'path-changed', onProjectPathChanged
+    onProjectPathChanged()
+
   # Public: Open a new Atom window using the given options.
   #
   # Calling this method without an options parameter will open a prompt to pick
   # a file/folder to open in the new window.
   #
-  # options - An {Object} with the following keys:
-  #   :pathsToOpen -  An {Array} of {String} paths to open.
+  # * `options` An {Object} with the following keys:
+  #   * `pathsToOpen`  An {Array} of {String} paths to open.
+  #   * `newWindow` A {Boolean}, true to always open a new window instead of
+  #     reusing existing windows depending on the paths to open.
+  #   * `devMode` A {Boolean}, true to open the window in development mode.
+  #     Development mode loads the Atom source from the locally cloned
+  #     repository and also loads all the packages in ~/.atom/dev/packages
+  #   * `safeMode` A {Boolean}, true to open the window in safe mode. Safe
+  #     mode prevents all packages installed to ~/.atom/packages from loading.
   open: (options) ->
     ipc.send('open', options)
 
   # Public: Open a confirm dialog.
   #
-  # ## Example
+  # ## Examples
   #
   # ```coffee
-  #   atom.confirm
-  #     message: 'How you feeling?'
-  #     detailedMessage: 'Be honest.'
-  #     buttons:
-  #       Good: -> window.alert('good to hear')
-  #       Bad:  -> window.alert('bummer')
+  # atom.confirm
+  #   message: 'How you feeling?'
+  #   detailedMessage: 'Be honest.'
+  #   buttons:
+  #     Good: -> window.alert('good to hear')
+  #     Bad:  -> window.alert('bummer')
   # ```
   #
-  # options - An {Object} with the following keys:
-  #   :message - The {String} message to display.
-  #   :detailedMessage - The {String} detailed message to display.
-  #   :buttons - Either an array of strings or an object where keys are
-  #              button names and the values are callbacks to invoke when
-  #              clicked.
+  # * `options` An {Object} with the following keys:
+  #   * `message` The {String} message to display.
+  #   * `detailedMessage` The {String} detailed message to display.
+  #   * `buttons` Either an array of strings or an object where keys are
+  #     button names and the values are callbacks to invoke when clicked.
   #
   # Returns the chosen button index {Number} if the buttons option was an array.
   confirm: ({message, detailedMessage, buttons}={}) ->
@@ -443,15 +483,15 @@ class Atom extends Model
 
   # Public: Set the size of current window.
   #
-  # width  - The {Number} of pixels.
-  # height - The {Number} of pixels.
+  # * `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.
   #
-  # x - The {Number} of pixels.
-  # y - The {Number} of pixels.
+  # * `x` The {Number} of pixels.
+  # * `y` The {Number} of pixels.
   setPosition: (x, y) ->
     ipc.send('call-window-method', 'setPosition', x, y)
 
@@ -459,15 +499,17 @@ 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
   # if called synchronously.
-  displayWindow: ->
+  displayWindow: ({maximize}={}) ->
     setImmediate =>
       @show()
       @focus()
-      @setFullScreen(true) if @workspaceView.fullScreen
+      @setFullScreen(true) if @workspace.fullScreen
+      @maximize() if maximize
 
   # Public: Close the current window.
   close: ->
@@ -478,6 +520,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
@@ -499,15 +547,18 @@ class Atom extends Model
   isFullScreen: ->
     @getCurrentWindow().isFullScreen()
 
+  maximize: ->
+    ipc.send('call-window-method', 'maximize')
+
   # Public: Get the version of the Atom application.
   #
   # Returns the version text {String}.
   getVersion: ->
-    @constructor.getVersion()
+    @appVersion ?= @getLoadSettings().appVersion
 
   # Public: Determine whether the current version is an official release.
   isReleasedVersion: ->
-    @constructor.isReleasedVersion()
+    not /\w{7}/.test(@getVersion()) # Check if the release is a 7-character SHA prefix
 
   # Public: Get the directory path to Atom's configuration area.
   #
@@ -527,7 +578,7 @@ class Atom extends Model
   # This time include things like loading and activating packages, creating
   # DOM elements for the editor, and reading the config.
   #
-  # Returns the number of milliseconds taken to load the window or null
+  # Returns the {Number} of milliseconds taken to load the window or null
   # if the window hasn't finished loading yet.
   getWindowLoadTime: ->
     @loadTime
@@ -559,8 +610,8 @@ class Atom extends Model
   # The globals will be set on the `window` object and removed after the
   # require completes.
   #
-  # id - The {String} module name or path.
-  # globals - An {Object} to set as globals during require (default: {})
+  # * `id` The {String} module name or path.
+  # * `globals` An optinal {Object} to set as globals during require.
   requireWithGlobals: (id, globals={}) ->
     existingGlobals = {}
     for key, value of globals

src/browser/application-menu.coffee

@@ -116,7 +116,7 @@ class ApplicationMenu
       item.metadata ?= {}
       if item.command
         item.accelerator = @acceleratorForCommand(item.command, keystrokesByCommand)
-        item.click = => global.atomApplication.sendCommand(item.command)
+        item.click = -> global.atomApplication.sendCommand(item.command)
         item.metadata['windowSpecific'] = true unless /^application:/.test(item.command)
       @translateTemplate(item.submenu, keystrokesByCommand) if item.submenu
     template

src/browser/atom-application.coffee

@@ -5,13 +5,11 @@ AutoUpdateManager = require './auto-update-manager'
 BrowserWindow = require 'browser-window'
 Menu = require 'menu'
 app = require 'app'
-dialog = require 'dialog'
 fs = require 'fs'
 ipc = require 'ipc'
 path = require 'path'
 os = require 'os'
 net = require 'net'
-shell = require 'shell'
 url = require 'url'
 {EventEmitter} = require 'events'
 _ = require 'underscore-plus'
@@ -103,6 +101,13 @@ class AtomApplication
     window.once 'window:loaded', =>
       @autoUpdateManager.emitUpdateAvailableEvent(window)
 
+    unless window.isSpec
+      focusHandler = => @lastFocusedWindow = window
+      window.browserWindow.on 'focus', focusHandler
+      window.browserWindow.once 'closed', =>
+        @lastFocusedWindow = null if window is @lastFocusedWindow
+        window.browserWindow.removeListener 'focus', focusHandler
+
   # Creates server to listen for additional atom application launches.
   #
   # You can run the atom command multiple times, but after the first launch
@@ -135,7 +140,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())
@@ -149,8 +154,8 @@ class AtomApplication
       atomWindow ?= @focusedWindow()
       atomWindow?.browserWindow.inspectElement(x, y)
 
-    @on 'application:open-documentation', -> shell.openExternal('https://atom.io/docs/latest/?app')
-    @on 'application:open-terms-of-use', -> shell.openExternal('https://atom.io/terms')
+    @on 'application:open-documentation', -> require('shell').openExternal('https://atom.io/docs/latest/?app')
+    @on 'application:open-terms-of-use', -> require('shell').openExternal('https://atom.io/terms')
     @on 'application:install-update', -> @autoUpdateManager.install()
     @on 'application:check-for-update', => @autoUpdateManager.check()
 
@@ -199,13 +204,15 @@ class AtomApplication
 
     # A request from the associated render process to open a new render process.
     ipc.on 'open', (event, options) =>
+      window = @windowForEvent(event)
       if options?
         if options.pathsToOpen?.length > 0
+          options.window = window
           @openPaths(options)
         else
           new AtomWindow(options)
       else
-        @promptForPath()
+        @promptForPath({window})
 
     ipc.on 'update-application-menu', (event, template, keystrokesByCommand) =>
       @applicationMenu.update(template, keystrokesByCommand)
@@ -281,8 +288,12 @@ class AtomApplication
 
   # Returns the {AtomWindow} for the given path.
   windowForPath: (pathToOpen) ->
-    for atomWindow in @windows
-      return atomWindow if atomWindow.containsPath(pathToOpen)
+    _.find @windows, (atomWindow) -> atomWindow.containsPath(pathToOpen)
+
+  # Returns the {AtomWindow} for the given ipc event.
+  windowForEvent: ({sender}) ->
+    window = BrowserWindow.fromWebContents(sender)
+    _.find @windows, ({browserWindow}) -> window is browserWindow
 
   # Public: Returns the currently focused {AtomWindow} or undefined if none.
   focusedWindow: ->
@@ -296,9 +307,10 @@ class AtomApplication
   #   :newWindow - Boolean of whether this should be opened in a new window.
   #   :devMode - Boolean to control the opened window's dev mode.
   #   :safeMode - Boolean to control the opened window's safe mode.
-  openPaths: ({pathsToOpen, pidToKillWhenClosed, newWindow, devMode, safeMode}) ->
+  #   :window - {AtomWindow} to open file paths in.
+  openPaths: ({pathsToOpen, pidToKillWhenClosed, newWindow, devMode, safeMode, window}) ->
     for pathToOpen in pathsToOpen ? []
-      @openPath({pathToOpen, pidToKillWhenClosed, newWindow, devMode, safeMode})
+      @openPath({pathToOpen, pidToKillWhenClosed, newWindow, devMode, safeMode, window})
 
   # Public: Opens a single path, in an existing window if possible.
   #
@@ -309,15 +321,33 @@ class AtomApplication
   #   :devMode - Boolean to control the opened window's dev mode.
   #   :safeMode - Boolean to control the opened window's safe mode.
   #   :windowDimensions - Object with height and width keys.
-  openPath: ({pathToOpen, pidToKillWhenClosed, newWindow, devMode, safeMode, windowDimensions}={}) ->
+  #   :window - {AtomWindow} to open file paths in.
+  openPath: ({pathToOpen, pidToKillWhenClosed, newWindow, devMode, safeMode, windowDimensions, window}={}) ->
     {pathToOpen, initialLine, initialColumn} = @locationForPathToOpen(pathToOpen)
 
-    unless devMode
-      existingWindow = @windowForPath(pathToOpen) unless pidToKillWhenClosed or newWindow
-    if existingWindow
+    unless pidToKillWhenClosed or newWindow
+      pathToOpenStat = fs.statSyncNoException(pathToOpen)
+
+      # Default to using the specified window or the last focused window
+      currentWindow = window ? @lastFocusedWindow
+
+      if pathToOpenStat.isFile?()
+        # Open the file in the current window
+        existingWindow = currentWindow
+      else if pathToOpenStat.isDirectory?()
+        # Open the folder in the current window if it doesn't have a path
+        existingWindow = currentWindow unless currentWindow?.hasProjectPath()
+
+      # Don't reuse windows in dev mode
+      existingWindow ?= @windowForPath(pathToOpen) unless devMode
+
+    if existingWindow?
       openedWindow = existingWindow
       openedWindow.openPath(pathToOpen, initialLine)
-      openedWindow.restore()
+      if openedWindow.isMinimized()
+        openedWindow.restore()
+      else
+        openedWindow.focus()
     else
       if devMode
         try
@@ -331,7 +361,7 @@ class AtomApplication
     if pidToKillWhenClosed?
       @pidsToOpenWindows[pidToKillWhenClosed] = openedWindow
 
-    openedWindow.browserWindow.on 'closed', =>
+    openedWindow.browserWindow.once 'closed', =>
       @killProcessForWindow(openedWindow)
 
   # Kill all processes associated with opened windows.
@@ -387,11 +417,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,16 +434,20 @@ 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: ->
+  runBenchmarks: ({exitWhenDone, specDirectory}={}) ->
     try
       bootstrapScript = require.resolve(path.resolve(global.devResourcePath, 'benchmark', 'benchmark-bootstrap'))
     catch error
       bootstrapScript = require.resolve(path.resolve(__dirname, '..', '..', 'benchmark', 'benchmark-bootstrap'))
 
+    specDirectory ?= path.dirname(bootstrapScript)
+
     isSpec = true
-    new AtomWindow({bootstrapScript, @resourcePath, isSpec})
+    devMode = true
+    new AtomWindow({bootstrapScript, @resourcePath, exitWhenDone, isSpec, specDirectory, devMode})
 
   locationForPathToOpen: (pathToOpen) ->
     return {pathToOpen} unless pathToOpen
@@ -438,7 +474,8 @@ class AtomApplication
   #              should be in dev mode or not.
   #   :safeMode - A Boolean which controls whether any newly opened windows
   #               should be in safe mode or not.
-  promptForPath: ({type, devMode, safeMode}={}) ->
+  #   :window - An {AtomWindow} to use for opening a selected file path.
+  promptForPath: ({type, devMode, safeMode, window}={}) ->
     type ?= 'all'
     properties =
       switch type
@@ -446,5 +483,7 @@ class AtomApplication
         when 'folder' then ['openDirectory']
         when 'all' then ['openFile', 'openDirectory']
         else throw new Error("#{type} is an invalid type for promptForPath")
+
+    dialog = require 'dialog'
     dialog.showOpenDialog title: 'Open', properties: properties.concat(['multiSelections', 'createDirectory']), (pathsToOpen) =>
-      @openPaths({pathsToOpen, devMode, safeMode})
+      @openPaths({pathsToOpen, devMode, safeMode, window})

src/browser/atom-protocol-handler.coffee

@@ -1,5 +1,5 @@
 app = require 'app'
-fs = require 'fs-plus'
+fs = require 'fs'
 path = require 'path'
 protocol = require 'protocol'
 
@@ -24,5 +24,5 @@ class AtomProtocolHandler
       relativePath = path.normalize(request.url.substr(7))
       for loadPath in @loadPaths
         filePath = path.join(loadPath, relativePath)
-        break if fs.isFileSync(filePath)
+        break if fs.statSyncNoException(filePath).isFile?()
       return new protocol.RequestFileJob(filePath)

src/browser/atom-window.coffee

@@ -1,7 +1,5 @@
 BrowserWindow = require 'browser-window'
-ContextMenu = require './context-menu'
 app = require 'app'
-dialog = require 'dialog'
 path = require 'path'
 fs = require 'fs'
 url = require 'url'
@@ -20,14 +18,19 @@ 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
 
+    @browserWindow = new BrowserWindow
+      show: false
+      title: 'Atom'
+      icon: @constructor.iconPath
+      'web-preferences':
+        'subpixel-font-scaling': false
     global.atomApplication.addWindow(this)
 
-    @browserWindow = new BrowserWindow show: false, title: 'Atom', icon: @constructor.iconPath
     @handleEvents()
 
     loadSettings = _.extend({}, settings)
@@ -49,6 +52,8 @@ class AtomWindow
       @emit 'window:loaded'
       @loaded = true
 
+    @browserWindow.on 'project-path-changed', (@projectPath) =>
+
     @browserWindow.loadUrl @getUrl(loadSettings)
     @browserWindow.focusOnWebView() if @isSpec
 
@@ -66,9 +71,18 @@ class AtomWindow
       slashes: true
       query: {loadSettings: JSON.stringify(loadSettings)}
 
+  hasProjectPath: -> @projectPath?.length > 0
+
   getInitialPath: ->
     @browserWindow.loadSettings.initialPath
 
+  setupContextMenu: ->
+    ContextMenu = null
+
+    @browserWindow.on 'context-menu', (menuTemplate) =>
+      ContextMenu ?= require './context-menu'
+      new ContextMenu(menuTemplate, this)
+
   containsPath: (pathToCheck) ->
     initialPath = @getInitialPath()
     if not initialPath
@@ -91,6 +105,7 @@ class AtomWindow
     @browserWindow.on 'unresponsive', =>
       return if @isSpec
 
+      dialog = require 'dialog'
       chosen = dialog.showMessageBox @browserWindow,
         type: 'warning'
         buttons: ['Close', 'Keep Waiting']
@@ -101,6 +116,7 @@ class AtomWindow
     @browserWindow.webContents.on 'crashed', =>
       global.atomApplication.exit(100) if @exitWhenDone
 
+      dialog = require 'dialog'
       chosen = dialog.showMessageBox @browserWindow,
         type: 'warning'
         buttons: ['Close Window', 'Reload', 'Keep It Open']
@@ -110,8 +126,7 @@ class AtomWindow
         when 0 then @browserWindow.destroy()
         when 1 then @browserWindow.restart()
 
-    @browserWindow.on 'context-menu', (menuTemplate) =>
-      new ContextMenu(menuTemplate, this)
+    @setupContextMenu()
 
     if @isSpec
       # Workaround for https://github.com/atom/atom-shell/issues/380
@@ -169,6 +184,8 @@ class AtomWindow
 
   isFocused: -> @browserWindow.isFocused()
 
+  isMinimized: -> @browserWindow.isMinimized()
+
   isWebViewFocused: -> @browserWindow.isWebViewFocused()
 
   isSpecWindow: -> @isSpec

src/browser/auto-update-manager.coffee

@@ -1,44 +1,47 @@
-https = require 'https'
-autoUpdater = require 'auto-updater'
-dialog = require 'dialog'
+autoUpdater = null
 _ = require 'underscore-plus'
 {EventEmitter} = require 'events'
 
-IDLE_STATE='idle'
-CHECKING_STATE='checking'
-DOWNLOADING_STATE='downloading'
-UPDATE_AVAILABLE_STATE='update-available'
-NO_UPDATE_AVAILABLE_STATE='no-update-available'
-ERROR_STATE='error'
+IdleState = 'idle'
+CheckingState = 'checking'
+DownladingState = 'downloading'
+UpdateAvailableState = 'update-available'
+NoUpdateAvailableState = 'no-update-available'
+ErrorState = 'error'
 
 module.exports =
 class AutoUpdateManager
   _.extend @prototype, EventEmitter.prototype
 
   constructor: (@version) ->
-    @state = IDLE_STATE
+    @state = IdleState
     @feedUrl = "https://atom.io/api/updates?version=#{@version}"
 
+    process.nextTick => @setupAutoUpdater()
+
+  setupAutoUpdater: ->
+    autoUpdater = require 'auto-updater'
+
     if process.platform is 'win32'
       autoUpdater.checkForUpdates = => @checkForUpdatesShim()
 
     autoUpdater.setFeedUrl @feedUrl
 
     autoUpdater.on 'checking-for-update', =>
-      @setState(CHECKING_STATE)
+      @setState(CheckingState)
 
     autoUpdater.on 'update-not-available', =>
-      @setState(NO_UPDATE_AVAILABLE_STATE)
+      @setState(NoUpdateAvailableState)
 
     autoUpdater.on 'update-available', =>
-      @setState(DOWNLOADING_STATE)
+      @setState(DownladingState)
 
     autoUpdater.on 'error', (event, message) =>
-      @setState(ERROR_STATE)
+      @setState(ErrorState)
       console.error "Error Downloading Update: #{message}"
 
     autoUpdater.on 'update-downloaded', (event, @releaseNotes, @releaseVersion) =>
-      @setState(UPDATE_AVAILABLE_STATE)
+      @setState(UpdateAvailableState)
       @emitUpdateAvailableEvent(@getWindows()...)
 
     # Only released versions should check for updates.
@@ -48,6 +51,8 @@ class AutoUpdateManager
   # Windows doesn't have an auto-updater, so use this method to shim the events.
   checkForUpdatesShim: ->
     autoUpdater.emit 'checking-for-update'
+
+    https = require 'https'
     request = https.get @feedUrl, (response) ->
       if response.statusCode == 200
         body = ""
@@ -67,14 +72,14 @@ class AutoUpdateManager
       atomWindow.sendCommand('window:update-available', [@releaseVersion, @releaseNotes])
 
   setState: (state) ->
-    return unless @state != state
+    return if @state is state
     @state = state
     @emit 'state-changed', @state
 
   getState: ->
     @state
 
-  check: ({hidePopups}={})->
+  check: ({hidePopups}={}) ->
     unless hidePopups
       autoUpdater.once 'update-not-available', @onUpdateNotAvailable
       autoUpdater.once 'error', @onUpdateError
@@ -86,10 +91,12 @@ class AutoUpdateManager
 
   onUpdateNotAvailable: =>
     autoUpdater.removeListener 'error', @onUpdateError
+    dialog = require 'dialog'
     dialog.showMessageBox type: 'info', buttons: ['OK'], message: 'No update available.', detail: "Version #{@version} is the latest version."
 
   onUpdateError: (event, message) =>
     autoUpdater.removeListener 'update-not-available', @onUpdateNotAvailable
+    dialog = require 'dialog'
     dialog.showMessageBox type: 'warning', buttons: ['OK'], message: 'There was an error checking for updates.', detail: message
 
   getWindows: ->

src/browser/main.coffee

@@ -3,11 +3,9 @@ global.shellStartTime = Date.now()
 crashReporter = require 'crash-reporter'
 app = require 'app'
 fs = require 'fs'
-module = require 'module'
 path = require 'path'
 optimist = require 'optimist'
 nslog = require 'nslog'
-dialog = require 'dialog'
 
 console.log = nslog
 
@@ -27,24 +25,20 @@ start = ->
     event.preventDefault()
     args.urlsToOpen.push(urlToOpen)
 
-  app.on 'open-url', (event, urlToOpen) ->
-    event.preventDefault()
-    args.urlsToOpen.push(urlToOpen)
-
   app.on 'open-file', addPathToOpen
   app.on 'open-url', addUrlToOpen
 
   app.on 'will-finish-launching', ->
     setupCrashReporter()
 
-  app.on 'finish-launching', ->
+  app.on 'ready', ->
     app.removeListener 'open-file', addPathToOpen
     app.removeListener 'open-url', addUrlToOpen
 
     args.pathsToOpen = args.pathsToOpen.map (pathToOpen) ->
       path.resolve(args.executedFrom ? process.cwd(), pathToOpen.toString())
 
-    require('coffee-script').register()
+    setupCoffeeScript()
     if args.devMode
       require(path.join(args.resourcePath, 'src', 'coffee-cache')).register()
       AtomApplication = require path.join(args.resourcePath, 'src', 'browser', 'atom-application')
@@ -61,13 +55,29 @@ global.devResourcePath = path.normalize(global.devResourcePath) if global.devRes
 setupCrashReporter = ->
   crashReporter.start(productName: 'Atom', companyName: 'GitHub')
 
+setupCoffeeScript = ->
+  CoffeeScript = null
+
+  require.extensions['.coffee'] = (module, filePath) ->
+    CoffeeScript ?= require('coffee-script')
+    coffee = fs.readFileSync(filePath, 'utf8')
+    js = CoffeeScript.compile(coffee, filename: filePath)
+    module._compile(js, filePath)
+
 parseCommandLine = ->
   version = app.getVersion()
   options = optimist(process.argv[1..])
   options.usage """
     Atom Editor v#{version}
 
-    Usage: atom [options] [file ...]
+    Usage: atom [options] [path ...]
+
+    One or more paths to files or folders to open may be specified.
+
+    File paths will open in the current window.
+
+    Folder paths will open in an existing window if that folder has already been
+    opened or a new window if it hasn't.
   """
   options.alias('d', 'dev').boolean('d').describe('d', 'Run in development mode.')
   options.alias('f', 'foreground').boolean('f').describe('f', 'Keep the browser process in the foreground.')
@@ -106,9 +116,7 @@ parseCommandLine = ->
   else if devMode
     resourcePath = global.devResourcePath
 
-  try
-    fs.statSync resourcePath
-  catch
+  unless fs.statSyncNoException(resourcePath)
     resourcePath = path.dirname(path.dirname(__dirname))
 
   {resourcePath, pathsToOpen, executedFrom, test, version, pidToKillWhenClosed, devMode, safeMode, newWindow, specDirectory, logFile}

src/buffered-node-process.coffee

@@ -6,34 +6,35 @@ path = require 'path'
 #
 # This is necessary on Windows since it doesn't support shebang `#!` lines.
 #
-# ## Requiring in packages
+# ## Examples
 #
 # ```coffee
-# {BufferedNodeProcess} = require 'atom'
+#   {BufferedNodeProcess} = require 'atom'
 # ```
 module.exports =
 class BufferedNodeProcess extends BufferedProcess
+
   # Public: Runs the given Node script by spawning a new child process.
   #
-  # options - An {Object} with the following keys:
-  #   :command - The {String} path to the JavaScript script to execute.
-  #   :args - The {Array} of arguments to pass to the script (optional).
-  #   :options - The options {Object} to pass to Node's `ChildProcess.spawn`
-  #              method (optional).
-  #   :stdout - The callback {Function} that receives a single argument which
-  #             contains the standard output from the command. The callback is
-  #             called as data is received but it's buffered to ensure only
-  #             complete lines are passed until the source stream closes. After
-  #             the source stream has closed all remaining data is sent in a
-  #             final call (optional).
-  #   :stderr - The callback {Function} that receives a single argument which
-  #             contains the standard error output from the command. The
-  #             callback is called as data is received but it's buffered to
-  #             ensure only complete lines are passed until the source stream
-  #             closes. After the source stream has closed all remaining data
-  #             is sent in a final call (optional).
-  #   :exit - The callback {Function} which receives a single argument
-  #           containing the exit status (optional).
+  # * `options` An {Object} with the following keys:
+  #   * `command` The {String} path to the JavaScript script to execute.
+  #   * `args` The {Array} of arguments to pass to the script (optional).
+  #   * `options` The options {Object} to pass to Node's `ChildProcess.spawn`
+  #               method (optional).
+  #   * `stdout` The callback {Function} that receives a single argument which
+  #              contains the standard output from the command. The callback is
+  #              called as data is received but it's buffered to ensure only
+  #              complete lines are passed until the source stream closes. After
+  #              the source stream has closed all remaining data is sent in a
+  #              final call (optional).
+  #   * `stderr` The callback {Function} that receives a single argument which
+  #              contains the standard error output from the command. The
+  #              callback is called as data is received but it's buffered to
+  #              ensure only complete lines are passed until the source stream
+  #              closes. After the source stream has closed all remaining data
+  #              is sent in a final call (optional).
+  #   * `exit` The callback {Function} which receives a single argument
+  #            containing the exit status (optional).
   constructor: ({command, args, options, stdout, stderr, exit}) ->
     node =
       if process.platform is 'darwin'

src/buffered-process.coffee

@@ -4,7 +4,7 @@ ChildProcess = require 'child_process'
 # Public: A wrapper which provides standard error/output line buffering for
 # Node's ChildProcess.
 #
-# ## Requiring in packages
+# ## Examples
 #
 # ```coffee
 # {BufferedProcess} = require 'atom'
@@ -19,29 +19,27 @@ module.exports =
 class BufferedProcess
   # Public: Runs the given command by spawning a new child process.
   #
-  # options - An {Object} with the following keys:
-  #   :command - The {String} command to execute.
-  #   :args - The {Array} of arguments to pass to the command (optional).
-  #   :options - The options {Object} to pass to Node's `ChildProcess.spawn`
-  #              method (optional).
-  #   :stdout - The callback {Function} that receives a single argument which
-  #             contains the standard output from the command. The callback is
-  #             called as data is received but it's buffered to ensure only
-  #             complete lines are passed until the source stream closes. After
-  #             the source stream has closed all remaining data is sent in a
-  #             final call (optional).
-  #   :stderr - The callback {Function} that receives a single argument which
-  #             contains the standard error output from the command. The
-  #             callback is called as data is received but it's buffered to
-  #             ensure only complete lines are passed until the source stream
-  #             closes. After the source stream has closed all remaining data
-  #             is sent in a final call (optional).
-  #   :exit - The callback {Function} which receives a single argument
-  #           containing the exit status (optional).
+  # * `options` An {Object} with the following keys:
+  #   * `command` The {String} command to execute.
+  #   * `args` The {Array} of arguments to pass to the command (optional).
+  #   * `options` The options {Object} to pass to Node's `ChildProcess.spawn`
+  #               method (optional).
+  #   * `stdout` The callback {Function} that receives a single argument which
+  #              contains the standard output from the command. The callback is
+  #              called as data is received but it's buffered to ensure only
+  #              complete lines are passed until the source stream closes. After
+  #              the source stream has closed all remaining data is sent in a
+  #              final call (optional).
+  #   * `stderr` The callback {Function} that receives a single argument which
+  #              contains the standard error output from the command. The
+  #              callback is called as data is received but it's buffered to
+  #              ensure only complete lines are passed until the source stream
+  #              closes. After the source stream has closed all remaining data
+  #              is sent in a final call (optional).
+  #   * `exit` The callback {Function} which receives a single argument
+  #            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
@@ -94,9 +95,9 @@ class BufferedProcess
 
   # Helper method to pass data line by line.
   #
-  # stream - The Stream to read from.
-  # onLines - The callback to call with each line of data.
-  # onDone - The callback to call when the stream has closed.
+  # * `stream` The Stream to read from.
+  # * `onLines` The callback to call with each line of data.
+  # * `onDone` The callback to call when the stream has closed.
   bufferStream: (stream, onLines, onDone) ->
     stream.setEncoding('utf8')
     buffered = ''
@@ -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