Verify selector before registering keybinding

Remove some default packages

.gitignore

@@ -9,5 +9,6 @@ debug.log
 /tags
 /atom-shell/
 docs/output
+docs/includes
 spec/fixtures/evil-files/
 /apm

CONTRIBUTING.md

@@ -30,7 +30,7 @@ in the proper package's repository.
   * Follow the [CoffeeScript](#coffeescript-styleguide),
     [JavaScript](https://github.com/styleguide/javascript),
     and [CSS](https://github.com/styleguide/css) styleguides
-  * Include thoughtfully worded [Jasmine](http://pivotal.github.com/jasmine/)
+  * Include thoughtfully worded [Jasmine](http://pivotal.github.com/jasmine)
     specs
   * Avoid placing files in `vendor`. 3rd-party packages should be added as a
     `package.json` dependency.
@@ -61,3 +61,32 @@ in the proper package's repository.
 
 * Set parameter defaults without spaces around the equal sign
   * `clear = (count=1) ->` instead of `clear = (count = 1) ->`
+
+## Documentation Styleguide
+
+* Use [TomDoc](http://tomdoc.org).
+* Use [Markdown](https://daringfireball.net/projects/markdown).
+* Reference classes with `{ClassName}` style notation.
+* Reference methods with `{ClassName.methodName}` style notation.
+* Delegate to comments elsewhere with `{Delegates to: ClassName.methodName}`
+  style notation.
+
+### Example
+
+```coffee
+# Public: Disable the package with the given name.
+#
+# This method emits multiple events:
+#
+# * `package-will-be-disabled` - before the package is disabled.
+# * `package-disabled`         - after the package is disabled.
+#
+# name     - The {String} name of the package to disable.
+# options  - The {Object} with disable options (default: {}):
+#   :trackTime - `true` to track the amount of time disabling took.
+#   :ignoreErrors - `true` to catch and ignore errors thrown.
+# callback - The {Function} to call after the package has been disabled.
+#
+# Returns `undefined`.
+disablePackage: (name, options, callback) ->
+```

README.md

@@ -1,4 +1,4 @@
-# Atom — The hackable, ~~collaborative~~ editor
+# Atom — The hackable editor
 
 ![Atom](http://i.imgur.com/OrTvUAD.png)
 

build/Gruntfile.coffee

@@ -2,6 +2,10 @@ fs = require 'fs'
 path = require 'path'
 os = require 'os'
 
+# Add support for obselete APIs of vm module so we can make some third-party
+# modules work under node v0.11.x.
+require 'vm-compatibility-layer'
+
 fm = require 'json-front-matter'
 _ = require 'underscore-plus'
 

build/package.json

@@ -6,29 +6,31 @@
     "url": "https://github.com/atom/atom.git"
   },
   "dependencies": {
-    "biscotto": "0.0.17",
-    "first-mate": "~0.10.0",
+    "async": "~0.2.9",
+    "biscotto": "0.6.0",
     "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://github.com/atom/grunt-coffeelint.git",
     "grunt-contrib-csslint": "~0.1.2",
-    "grunt-contrib-coffee": "~0.7.0",
+    "grunt-contrib-coffee": "~0.9.0",
     "grunt-contrib-less": "~0.8.0",
-    "grunt-cson": "0.5.0",
-    "grunt-download-atom-shell": "git+https://atom-bot:362295be4c5258d3f7b967bbabae662a455ca2a7@github.com/atom/grunt-download-atom-shell#v0.5.0",
+    "grunt-cson": "0.6.0",
+    "grunt-download-atom-shell": "git+https://atom-bot:362295be4c5258d3f7b967bbabae662a455ca2a7@github.com/atom/grunt-download-atom-shell#v0.6.0",
     "grunt-lesslint": "0.13.0",
     "grunt-markdown": "~0.4.0",
+    "grunt-peg": "~1.1.0",
     "grunt-shell": "~0.3.1",
     "harmony-collections": "~0.3.8",
-    "js-yaml": "~2.1.0",
     "json-front-matter": "~0.1.3",
     "rcedit": "~0.1.2",
     "request": "~2.27.0",
     "rimraf": "~2.2.2",
+    "runas": "0.5.x",
+    "underscore-plus": "1.x",
     "unzip": "~0.1.9",
-    "walkdir": "0.0.7",
-    "grunt-peg": "~1.1.0"
+    "vm-compatibility-layer": "~0.1.0"
   }
 }

build/tasks/build-task.coffee

@@ -21,7 +21,6 @@ module.exports = (grunt) ->
 
     cp 'atom.sh', path.join(appDir, 'atom.sh')
     cp 'package.json', path.join(appDir, 'package.json')
-    cp 'apm', path.join(appDir, 'apm')
 
     packageDirectories = []
     nonPackageDirectories = [
@@ -39,23 +38,36 @@ module.exports = (grunt) ->
       else
         nonPackageDirectories.push(directory)
 
+    # Put any paths here that shouldn't end up in the built Atom.app
+    # so that it doesn't becomes larger than it needs to be.
     ignoredPaths = [
       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('spellchecker', 'vendor')
+      path.join('xmldom', 'test')
+      path.join('jasmine-reporters', 'ext')
+      path.join('build', 'Release', 'obj.target')
+      path.join('build', 'Release', '.deps')
       path.join('vendor', 'apm')
       path.join('resources', 'mac')
       path.join('resources', 'win')
     ]
     ignoredPaths = ignoredPaths.map (ignoredPath) -> "(#{ignoredPath})"
     nodeModulesFilter = new RegExp(ignoredPaths.join('|'))
+    packageFilter = new RegExp("(#{ignoredPaths.join('|')})|(.+\\.(cson|coffee)$)")
     for directory in nonPackageDirectories
       cp directory, path.join(appDir, directory), filter: nodeModulesFilter
     for directory in packageDirectories
-      cp directory, path.join(appDir, directory), filter: /.+\.(cson|coffee)$/
+      cp directory, path.join(appDir, directory), filter: packageFilter
 
     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
 
     if process.platform is 'darwin'
       grunt.file.recurse path.join('resources', 'mac'), (sourcePath, rootDirectory, subDirectory='', filename) ->

build/tasks/convert-theme.coffee

@@ -1,102 +0,0 @@
-path = require 'path'
-
-_ = require 'underscore-plus'
-fs = require 'fs-plus'
-{ScopeSelector} = require 'first-mate'
-
-module.exports = (grunt) ->
-  grunt.registerTask 'convert-theme', 'Convert a TextMate theme to an Atom theme', ->
-    if textMateThemePath = grunt.option('path')
-      textMateThemePath = path.resolve(textMateThemePath)
-      if grunt.file.isFile(textMateThemePath)
-        textMateTheme = new TextMateTheme(textMateThemePath)
-        themeName = path.basename(textMateThemePath, path.extname(textMateThemePath))
-        atomThemePath = path.join(path.dirname(textMateThemePath), "#{themeName.toLowerCase()}-syntax.css")
-        grunt.file.write(atomThemePath, textMateTheme.getStylesheet())
-        grunt.log.ok("Atom theme written to: #{atomThemePath}")
-      else
-        grunt.log.error("No theme file found at: #{textMateThemePath}")
-        false
-    else
-      grunt.log.error('Must specify --path=<path to TextMate theme>')
-      false
-
-class TextMateTheme
-  constructor: (@path) ->
-    @rulesets = []
-    @buildRulesets()
-
-  buildRulesets: ->
-    {settings} = fs.readPlistSync(@path)
-    @buildGlobalSettingsRulesets(settings[0])
-    @buildScopeSelectorRulesets(settings[1..])
-
-  getStylesheet: ->
-    lines = []
-    for {selector, properties} in @getRulesets()
-      lines.push("#{selector} {")
-      lines.push "  #{name}: #{value};" for name, value of properties
-      lines.push("}\n")
-    lines.join('\n')
-
-  getRulesets: -> @rulesets
-
-  buildGlobalSettingsRulesets: ({settings}) ->
-    { background, foreground, caret, selection, lineHighlight } = settings
-
-    @rulesets.push
-      selector: '.editor, .editor .gutter'
-      properties:
-        'background-color': @translateColor(background)
-        'color': @translateColor(foreground)
-
-    @rulesets.push
-      selector: '.editor.is-focused .cursor'
-      properties:
-        'border-color': @translateColor(caret)
-
-    @rulesets.push
-      selector: '.editor.is-focused .selection .region'
-      properties:
-        'background-color': @translateColor(selection)
-
-    @rulesets.push
-      selector: '.editor.is-focused .line-number.cursor-line-no-selection, .editor.is-focused .line.cursor-line'
-      properties:
-        'background-color': @translateColor(lineHighlight)
-
-  buildScopeSelectorRulesets: (scopeSelectorSettings) ->
-    for { name, scope, settings } in scopeSelectorSettings
-      continue unless scope
-      @rulesets.push
-        comment: name
-        selector: @translateScopeSelector(scope)
-        properties: @translateScopeSelectorSettings(settings)
-
-  translateScopeSelector: (textmateScopeSelector) ->
-    new ScopeSelector(textmateScopeSelector).toCssSelector()
-
-  translateScopeSelectorSettings: ({ foreground, background, fontStyle }) ->
-    properties = {}
-
-    if fontStyle
-      fontStyles = fontStyle.split(/\s+/)
-      properties['font-weight'] = 'bold' if _.contains(fontStyles, 'bold')
-      properties['font-style'] = 'italic' if _.contains(fontStyles, 'italic')
-      properties['text-decoration'] = 'underline' if _.contains(fontStyles, 'underline')
-
-    properties['color'] = @translateColor(foreground) if foreground
-    properties['background-color'] = @translateColor(background) if background
-    properties
-
-  translateColor: (textmateColor) ->
-    if textmateColor.length <= 7
-      textmateColor
-    else
-      r = parseInt(textmateColor[1..2], 16)
-      g = parseInt(textmateColor[3..4], 16)
-      b = parseInt(textmateColor[5..6], 16)
-      a = parseInt(textmateColor[7..8], 16)
-      a = Math.round((a / 255.0) * 100) / 100
-
-      "rgba(#{r}, #{g}, #{b}, #{a})"

build/tasks/docs-task.coffee

@@ -1,26 +1,63 @@
 path = require 'path'
-fs = require 'fs'
+
+async = require 'async'
+fs = require 'fs-plus'
+request = require 'request'
 
 module.exports = (grunt) ->
+  {rm} = require('./task-helpers')(grunt)
+
   cmd = path.join('node_modules', '.bin', 'coffee')
   commonArgs = [path.join('build', 'node_modules', '.bin', 'biscotto'), '--']
   opts =
     stdio: 'inherit'
 
-  grunt.registerTask 'build-docs', 'Builds the API docs in src/app', ->
+  grunt.registerTask 'build-docs', 'Builds the API docs in src', ->
     done = @async()
-    args = [commonArgs..., '--title', 'Atom API Documentation', '-o', 'docs/output/api', 'src/', '../text-buffer/src/range.coffee', '../text-buffer/src/point.coffee', '../text-buffer/src/marker.coffee']
-    grunt.util.spawn({cmd, args, opts}, done)
+
+    downloadIncludes (error, includePaths) ->
+      if error?
+        done(error)
+      else
+        rm('docs/output/api')
+        args = [
+          commonArgs...
+          '--title', 'Atom API Documentation'
+          '-o', 'docs/output/api'
+          '-r', 'docs/README.md'
+          'src/'
+          includePaths...
+        ]
+        grunt.util.spawn({cmd, args, opts}, done)
 
   grunt.registerTask 'lint-docs', 'Generate stats about the doc coverage', ->
     done = @async()
-    args = [commonArgs..., '--noOutput', 'src/']
-    grunt.util.spawn({cmd, args, opts}, done)
+    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()
-    args = [commonArgs..., '--noOutput', '--missing', 'src/']
-    grunt.util.spawn({cmd, args, opts}, done)
+    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()
@@ -94,3 +131,27 @@ module.exports = (grunt) ->
       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: '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)

build/tasks/install-task.coffee

@@ -1,4 +1,5 @@
 path = require 'path'
+runas = null
 
 module.exports = (grunt) ->
   {cp, mkdir, rm} = require('./task-helpers')(grunt)
@@ -6,6 +7,15 @@ module.exports = (grunt) ->
   grunt.registerTask 'install', 'Install the built application', ->
     installDir = grunt.config.get('atom.installDir')
     shellAppDir = grunt.config.get('atom.shellAppDir')
-    rm installDir
-    mkdir path.dirname(installDir)
-    cp shellAppDir, installDir
+    if process.platform is 'win32'
+      runas ?= require 'runas'
+      copyFolder = path.resolve 'script', 'copy-folder.cmd'
+      if runas('cmd', ['/c', copyFolder, shellAppDir, installDir], admin: true) isnt 0
+        grunt.log.error("Failed to copy #{shellAppDir} to #{installDir}")
+
+      createShortcut = path.resolve 'script', 'create-shortcut.cmd'
+      runas('cmd', ['/c', createShortcut, path.join(installDir, 'atom.exe'), 'Atom'])
+    else
+      rm installDir
+      mkdir path.dirname(installDir)
+      cp shellAppDir, installDir

build/tasks/set-version-task.coffee

@@ -41,7 +41,7 @@ module.exports = (grunt) ->
 
         strings =
           CompanyName: 'GitHub, Inc.'
-          FileDescription: 'The hackable, collaborative editor of tomorrow!'
+          FileDescription: 'The hackable editor'
           LegalCopyright: 'Copyright (C) 2013 GitHub, Inc. All rights reserved'
           ProductName: 'Atom'
           ProductVersion: version

build/tasks/task-helpers.coffee

@@ -1,27 +1,41 @@
-fs = require 'fs'
+fs = require 'fs-plus'
 path = require 'path'
-walkdir = require 'walkdir'
 
 module.exports = (grunt) ->
   cp: (source, destination, {filter}={}) ->
     unless grunt.file.exists(source)
       grunt.fatal("Cannot copy non-existent #{source.cyan} to #{destination.cyan}")
 
-    try
-      walkdir.sync source, (sourcePath, stats) ->
-        return if filter?.test(sourcePath)
+    copyFile = (sourcePath, destinationPath) ->
+      return if filter?.test(sourcePath)
 
-        destinationPath = path.join(destination, path.relative(source, sourcePath))
-        if stats.isSymbolicLink()
-          grunt.file.mkdir(path.dirname(destinationPath))
-          fs.symlinkSync(fs.readlinkSync(sourcePath), destinationPath)
-        else if stats.isFile()
-          grunt.file.copy(sourcePath, destinationPath)
+      stats = fs.lstatSync(sourcePath)
+      if stats.isSymbolicLink()
+        grunt.file.mkdir(path.dirname(destinationPath))
+        fs.symlinkSync(fs.readlinkSync(sourcePath), destinationPath)
+      else if stats.isFile()
+        grunt.file.copy(sourcePath, destinationPath)
 
-        if grunt.file.exists(destinationPath)
-          fs.chmodSync(destinationPath, fs.statSync(sourcePath).mode)
-    catch error
-      grunt.fatal(error)
+      if grunt.file.exists(destinationPath)
+        fs.chmodSync(destinationPath, fs.statSync(sourcePath).mode)
+
+    if grunt.file.isFile(source)
+      copyFile(source, destination)
+    else
+      try
+        onFile = (sourcePath) ->
+          destinationPath = path.join(destination, path.relative(source, sourcePath))
+          copyFile(sourcePath, destinationPath)
+        onDirectory = (sourcePath) ->
+          if fs.isSymbolicLinkSync(sourcePath)
+            destinationPath = path.join(destination, path.relative(source, sourcePath))
+            copyFile(sourcePath, destinationPath)
+            false
+          else
+            true
+        fs.traverseTreeSync source, onFile, onDirectory
+      catch error
+        grunt.fatal(error)
 
     grunt.verbose.writeln("Copied #{source.cyan} to #{destination.cyan}.")
 

build/tasks/update-octicons-task.coffee

@@ -0,0 +1,22 @@
+path = require 'path'
+
+module.exports = (grunt) ->
+  grunt.registerTask 'update-octicons', 'Update octicon font and LESS variables', ->
+    pathToOcticons = path.resolve('..', 'octicons')
+    if grunt.file.isDir(pathToOcticons)
+      # Copy font-file
+      fontSrc = path.join(pathToOcticons, 'octicons', 'octicons.woff')
+      fontDest = path.resolve('static', 'octicons.woff')
+      grunt.file.copy(fontSrc, fontDest)
+
+      # Update Octicon UTF codes
+      glyphsSrc = path.join(pathToOcticons, 'data', 'glyphs.yml')
+      output = []
+      for {css, code} in grunt.file.readYAML(glyphsSrc)
+        output.push "@#{css}: \"\\#{code}\";"
+
+      octiconUtfDest = path.resolve('static', 'variables', 'octicon-utf-codes.less')
+      grunt.file.write(octiconUtfDest, "#{output.join('\n')}\n")
+    else
+      grunt.log.error("octicons repo must be cloned to #{pathToOcticons}")
+      false

docs/README.md

@@ -0,0 +1,58 @@
+# Welcome to the Atom API Documentation
+
+![Atom](http://i.imgur.com/OrTvUAD.png)
+
+## FAQ
+
+### Where do I start?
+
+Check out [EditorView][EditorView] and [Editor][Editor] classes for a good
+overview of the main editor API.
+
+### How do I access these classes?
+
+Check out the [Atom][Atom] class docs to see what globals are available and
+what they provide.
+
+You can also require many of these classes in your package via:
+
+```coffee
+{EditorView} = require 'atom'
+```
+
+The classes available from `require 'atom'` are:
+  * [BufferedProcess][BufferedProcess]
+  * [BufferedNodeProcess][BufferedNodeProcess]
+  * [EditorView][EditorView]
+  * [Git][Git]
+  * [Point][Point]
+  * [Range][Range]
+  * [ScrollView][ScrollView]
+  * [SelectListView][SelectListView]
+  * [View][View]
+  * [WorkspaceView][WorkspaceView]
+
+### How do I create a package?
+
+You probably want to read the [creating a package][creating-a-package]
+doc first and come back here when you are done.
+
+### Where are the node docs?
+
+Atom ships with node 0.11.10 and the comprehensive node API docs are available
+[here][node-docs].
+
+[Atom]: ../classes/Atom.html
+[BufferedProcess]: ../classes/BufferedProcess.html
+[BufferedNodeProcess]: ../classes/BufferedNodeProcess.html
+[Editor]: ../classes/Editor.html
+[EditorView]: ../classes/EditorView.html
+[Git]: ../classes/Git.html
+[Point]: ../classes/Point.html
+[Range]: ../classes/Range.html
+[ScrollView]: ../classes/ScrollView.html
+[SelectListView]: ../classes/SelectListView.html
+[View]: ../classes/View.html
+[WorkspaceView]: ../classes/WorkspaceView.html
+[creating-a-package]: https://www.atom.io/docs/latest/creating-a-package
+[node-docs]: http://nodejs.org/docs/v0.11.10/api

docs/advanced/configuration.md

@@ -0,0 +1,76 @@
+## Configuration API
+
+### Reading Config Settings
+
+If you are writing a package that you want to make configurable, you'll need to
+read config settings via the `atom.config` global. You can read the current
+value of a namespaced config key with `atom.config.get`:
+
+```coffeescript
+# read a value with `config.get`
+@showInvisibles() if atom.config.get "editor.showInvisibles"
+```
+
+Or you can use the `::observeConfig` to track changes from any view object.
+
+```coffeescript
+class MyView extends View
+  initialize: ->
+    @observeConfig 'editor.fontSize', () =>
+      @adjustFontSize()
+```
+
+The `::observeConfig` method will call the given callback immediately with the
+current value for the specified key path, and it will also call it in the future
+whenever the value of that key path changes.
+
+Subscriptions made with `observeConfig` are automatically canceled when the
+view is removed. You can cancel config subscriptions manually via the
+`unobserveConfig` method.
+
+```coffeescript
+view1.unobserveConfig() # unobserve all properties
+```
+
+You can add the ability to observe config values to non-view classes by
+extending their prototype with the `ConfigObserver` mixin:
+
+```coffeescript
+{ConfigObserver} = require 'atom'
+
+class MyClass
+  ConfigObserver.includeInto(this)
+  
+  constructor: ->
+    @observeConfig 'editor.showInvisibles', -> # ...
+
+  destroy: ->
+    @unobserveConfig()
+```
+
+### Writing Config Settings
+
+The `atom.config` database is populated on startup from `~/.atom/config.cson`,
+but you can programmatically write to it with `atom.config.set`:
+
+```coffeescript
+# basic key update
+atom.config.set("core.showInvisibles", true)
+```
+
+You should never mutate the value of a config key, because that would circumvent
+the notification of observers. You can however use methods like `pushAtKeyPath`,
+`unshiftAtKeyPath`, and `removeAtKeyPath` to manipulate mutable config values.
+
+```coffeescript
+atom.config.pushAtKeyPath("core.disabledPackages", "wrap-guide")
+atom.config.removeAtKeyPath("core.disabledPackages", "terminal")
+```
+
+You can also use `setDefaults`, which will assign default values for keys that
+are always overridden by values assigned with `set`. Defaults are not written
+out to the the `config.json` file to prevent it from becoming cluttered.
+
+```coffeescript
+atom.config.setDefaults("editor", fontSize: 18, showInvisibles: true)
+```

docs/advanced/globals.md

@@ -0,0 +1,34 @@
+# Globals
+
+Atom exposes several services through singleton objects accessible via the
+`atom` global:
+
+* atom
+  * workspace:
+      Manipulate and query the state of the user interface for the current
+      window. Open editors, manipulate panes.
+  * workspaceView:
+      Similar to workspace, but provides access to the root of all views in the
+      current window.
+  * project:
+      Access the directory associated with the current window. Load editors,
+      perform project-wide searches, register custom openers for special file
+      types.
+  * config:
+      Read, write, and observe user configuration settings.
+  * keymap:
+      Add and query the currently active keybindings.
+  * deserializers:
+      Deserialize instances from their state objects and register deserializers.
+  * packages:
+      Activate, deactivate, and query user packages.
+  * themes:
+      Activate, deactivate, and query user themes.
+  * contextMenu:
+      Register context menus.
+  * menu:
+      Register application menus.
+  * pasteboard:
+      Read from and write to the system pasteboard.
+  * syntax:
+      Assign and query syntactically-scoped properties.

docs/advanced/keymaps.md

@@ -0,0 +1,123 @@
+# Keymaps In-Depth
+
+## Structure of a Keymap File
+
+Keymap files are encoded as JSON or CSON files containing nested hashes. They
+work much like stylesheets, but instead of applying style properties to elements
+matching the selector, they specify the meaning of keystrokes on elements
+matching the selector. Here is an example of some bindings that apply when
+keystrokes pass through elements with the class `.editor`:
+
+```coffee
+'.editor':
+  'cmd-delete': 'editor:backspace-to-beginning-of-line'
+  'alt-backspace': 'editor:backspace-to-beginning-of-word'
+  'ctrl-A': 'editor:select-to-first-character-of-line'
+  'ctrl-shift-e': 'editor:select-to-end-of-line'
+  'cmd-left': 'editor:move-to-first-character-of-line'
+
+'.editor:not(.mini)'
+  'cmd-alt-[': 'editor:fold-current-row'
+  'cmd-alt-]': 'editor:unfold-current-row'
+```
+
+Beneath the first selector are several bindings, mapping specific *keystroke
+patterns* to *commands*. When an element with the `.editor` class is focused and
+`cmd-delete` is pressed, an custom DOM event called
+`editor:backspace-to-beginning-of-line` is emitted on the `.editor` element.
+
+The second selector group also targets editors, but only if they don't have the
+`.mini` class. In this example, the commands for code folding don't really make
+sense on mini-editors, so the selector restricts them to regular editors.
+
+### Keystroke Patterns
+
+Keystroke patterns express one or more keystrokes combined with optional
+modifier keys. For example: `ctrl-w v`, or `cmd-shift-up`. A keystroke is
+composed of the following symbols, separated by a `-`. A multi-keystroke pattern
+can be expressed as keystroke patterns separated by spaces.
+
+
+| Type                | Examples
+| --------------------|----------------------------
+| Character literals  | `a` `4` `$`
+| Modifier keys       | `cmd` `ctrl` `alt` `shift`
+| Special keys        | `enter` `escape` `backspace` `delete` `tab` `home` `end` `pageup` `pagedown` `left` `right` `up` `down`
+
+### Commands
+
+Commands are custom DOM events that are triggered when a keystroke matches a
+binding. This allows user interface code to listen for named commands without
+specifying the specific keybinding that triggers it. For example, the following
+code sets up {EditorView} to listen for commands to move the cursor to the first
+character of the current line:
+
+```coffee
+class EditorView
+  listenForEvents: ->
+    @command 'editor:move-to-first-character-of-line', =>
+      @editor.moveCursorToFirstCharacterOfLine()
+```
+
+The `::command` method is basically an enhanced version of jQuery's `::on`
+method that listens for a custom DOM event and adds some metadata to the DOM,
+which is read by the command palette.
+
+When you are looking to bind new keys, it is often useful to use the command
+palette (`ctrl-shift-p`) to discover what commands are being listened for in a
+given focus context. Commands are "humanized" following a simple algorithm, so a
+command like `editor:fold-current-row` would appear as "Editor: Fold Current
+Row".
+
+### Specificity and Cascade Order
+
+As is the case with CSS applying styles, when multiple bindings match for a
+single element, the conflict is resolved by choosing the most *specific*
+selector. If two matching selectors have the same specificity, the binding
+for the selector appearing later in the cascade takes precedence.
+
+Currently, there's no way to specify selector ordering within a single keymap,
+because JSON objects do not preserve order. We eventually plan to introduce a
+custom CSS-like file format for keymaps that allows for ordering within a single
+file. For now, we've opted to handle cases where selector ordering is critical
+by breaking the keymap into two separate files, such as `snippets-1.cson` and
+`snippets-2.cson`.
+
+## Overloading Key Bindings
+
+Occasionally, it makes sense to layer multiple actions on top of the same key
+binding. An example of this is the snippets package. Snippets are inserted by
+typing a snippet prefix such as `for` and then pressing `tab`. Every time `tab`
+is pressed, we want to execute code attempting to expand a snippet if one exists
+for the text preceding the cursor. If a snippet *doesn't* exist, we want `tab`
+to actually insert whitespace.
+
+To achieve this, the snippets package makes use of the `.abortKeyBinding()`
+method on the event object representing the `snippets:expand` command.
+
+```coffee-script
+# pseudo-code
+editor.command 'snippets:expand', (e) =>
+  if @cursorFollowsValidPrefix()
+    @expandSnippet()
+  else
+    e.abortKeyBinding()
+```
+
+When the event handler observes that the cursor does not follow a valid prefix,
+it calls `e.abortKeyBinding()`, telling the keymap system to continue searching
+for another matching binding.
+
+## Step-by-Step: How Keydown Events are Mapped to Commands
+
+* A keydown event occurs on a *focused* element.
+* Starting at the focused element, the keymap walks upward towards the root of
+  the document, searching for the most specific CSS selector that matches the
+  current DOM element and also contains a keystroke pattern matching the keydown
+  event.
+* When a matching keystroke pattern is found, the search is terminated and the
+  pattern's corresponding command is triggered on the current element.
+* If `.abortKeyBinding()` is called on the triggered event object, the search
+  is resumed, triggering a binding on the next-most-specific CSS selector for
+  the same element or continuing upward to parent elements.
+* If no bindings are found, the event is handled by Chromium normally.

docs/advanced/serialization.md

@@ -71,27 +71,3 @@ will only attempt to call deserialize if the two versions match, and otherwise
 return undefined. We plan on implementing a migration system in the future, but
 this at least protects you from improperly deserializing old state. If you find
 yourself in dire need of the migration system, let us know.
-
-### Deferred Package Deserializers
-
-If your package defers loading on startup with an `activationEvents` property in
-its `package.cson`, your deserializers won't be loaded until your package is
-activated. If you want to deserialize an object from your package on startup,
-this could be a problem.
-
-The solution is to also supply a `deferredDeserializers` array in your
-`package.cson` with the names of all your deserializers. When Atom attempts to
-deserialize some state whose `deserializer` matches one of these names, it will
-load your package first so it can register any necessary deserializers before
-proceeding.
-
-For example, the markdown preview package doesn't fully load until a preview is
-triggered. But if you refresh a window with a preview pane, it loads the
-markdown package early so Atom can deserialize the view correctly.
-
-```coffee-script
-# markdown-preview/package.cson
-'activationEvents': 'markdown-preview:toggle': '.editor'
-'deferredDeserializers': ['MarkdownPreviewView']
-...
-```

docs/contributing.md

@@ -0,0 +1,140 @@
+# Contributing to Atom Packages
+
+The following is a set of guidelines for contributing to Atom packages, which
+are hosted in the [Atom Organization](https://github.com/atom) on GitHub. If
+you're unsure which package is causing your problem or if you're having an issue
+with Atom core, please use the feedback form in the application or email
+[atom@github.com](mailto:atom@github.com).
+
+## Submitting Issues
+
+* Include screenshots and animated GIFs whenever possible; they are immensely
+  helpful.
+* Include the behavior you expected and other places you've seen that behavior
+  such as Emacs, vi, Xcode, etc.
+* Check the dev tools (`alt-cmd-i`) for errors and stack traces to include.
+* Check Console.app for stack traces to include if reporting a crash.
+* Perform a cursory search to see if a similar issue has already been submitted.
+
+## Hacking on Packages
+
+### Cloning
+
+The first step is creating your own clone. You can of course do this manually
+with git, or you can use the `apm develop` command to create a clone based on
+the package's `repository` field in the `package.json`.
+
+For example, if you want to make changes to the `tree-view` package, run the
+following command:
+
+```
+> apm develop tree-view
+Cloning https://github.com/atom/tree-view ✓
+Installing modules ✓
+~/.atom/dev/packages/tree-view -> ~/github/tree-view
+```
+
+This clones the `tree-view` repository to `~/github`. If you prefer a different
+path, specify it via the `ATOM_REPOS_HOME` environment variable.
+
+### Running in Development Mode
+
+Editing a package in Atom is a bit of a circular experience: you're using Atom
+to modify itself. What happens if you temporarily break something? You don't
+want the version of Atom you're using to edit to become useless in the process.
+For this reason, you'll only want to load packages in **development mode** while
+you are working on them. You'll perform your editing in **stable mode**, only
+switching to development mode to test your changes.
+
+To open a development mode window, use the "Application: Open Dev" command,
+which is normally bound to `cmd-shift-o`. You can also run dev mode from the
+command line with `atom --dev`.
+
+To load your package in development mode, create a symlink to it in
+`~/.atom/dev/packages`. This occurs automatically when you clone the package
+with `apm develop`. You can also run `apm link --dev` and `apm unlink --dev`
+from the package directory to create and remove dev-mode symlinks.
+
+### Installing Dependencies
+
+Finally, you need to install the cloned package's dependencies by running
+`apm install` within the package directory. This step is also performed
+automatically the first time you run `apm develop`, but you'll want to keep
+dependencies up to date by running `apm update` after pulling upstream changes.
+
+## Submitting Pull Requests
+
+### Code Guidelines
+
+* Include screenshots and animated GIFs in your pull request whenever possible.
+* Follow the [CoffeeScript](#coffeescript-styleguide),
+  [JavaScript](https://github.com/styleguide/javascript),
+  and [CSS](https://github.com/styleguide/css) styleguides.
+* Include thoughtfully-worded, well-structured
+  [Jasmine](http://pivotal.github.com/jasmine) specs.
+* Document new code based on the
+  [Documentation Styleguide](#documentation-styleguide)
+* End files with a newline.
+* Place requires in the following order:
+  * Built in Node Modules (such as `path`)
+  * Built in Atom and Atom Shell Modules (such as `atom`, `shell`)
+  * Local Modules (using relative paths)
+* Place class properties in the following order:
+  * Class methods and properties (methods starting with a `@`)
+  * Instance methods and properties
+* Avoid platform-dependent code:
+  * Use `require('atom').fs.getHomeDirectory()` to get the home directory.
+  * Use `path.join()` to concatenate filenames.
+  * Use `os.tmpdir()` rather than `/tmp` when you need to reference the
+    temporary directory.
+
+### Commit Message Guidelines
+  * Use the present tense ("Add feature" not "Added feature")
+  * Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
+  * Limit the first line to 72 characters or less
+  * Reference issues and pull requests liberally
+  * Consider starting the commit message with an applicable emoji:
+    * :lipstick: when improving the format/structure of the code
+    * :racehorse: when improving performance
+    * :non-potable_water: when plugging memory leaks
+    * :memo: when writing docs
+    * :bulb: Check out the [Emoji Cheat Sheet](http://www.emoji-cheat-sheet.com)
+      for more ideas.
+
+## CoffeeScript Styleguide
+
+* Use parentheses if it improves code clarity.
+* Prefer alphabetic keywords to symbolic keywords:
+  * `a is b` instead of `a == b`
+* Avoid spaces inside the curly-braces of hash literals:
+  * `{a: 1, b: 2}` instead of `{ a: 1, b: 2 }`
+* Set parameter defaults without spaces around the equal sign:
+  * `clear = (count=1) ->` instead of `clear = (count = 1) ->`
+* Include a single line of whitespace between methods.
+
+## Documentation Styleguide
+
+* Use [TomDoc](http://tomdoc.org).
+* Use [Markdown](https://daringfireball.net/projects/markdown).
+* Reference classes with the custom `{ClassName}` notation.
+* Reference methods with the custom `{ClassName.methodName}` notation.
+
+### Example
+
+```coffee
+# Public: Disable the package with the given name.
+#
+# This method emits multiple events:
+#
+# * `package-will-be-disabled` - before the package is disabled.
+# * `package-disabled`         - after the package is disabled.
+#
+# name     - The {String} name of the package to disable.
+# options  - The {Object} with disable options (default: {}):
+#   :trackTime - `true` to track the amount of time disabling took.
+#   :ignoreErrors - `true` to catch and ignore errors thrown.
+# callback - The {Function} to call after the package has been disabled.
+#
+# Returns `undefined`.
+disablePackage: (name, options, callback) ->
+```

docs/converting-a-text-mate-bundle.md

@@ -0,0 +1,52 @@
+## Converting a TextMate Bundle
+
+This guide will show you how to convert a [TextMate][TextMate] bundle to an
+Atom package.
+
+Converting a TextMate bundle will allow you to use its editor preferences,
+snippets, and colorization inside Atom.
+
+### Install apm
+
+The `apm` command line utility that ships with Atom supports converting
+a TextMate bundle to an Atom package.
+
+Check that you have `apm` installed by running the following command in your
+terminal:
+
+```sh
+apm help init
+```
+
+You should see a message print out with details about the `apm init` command.
+
+If you do not, launch Atom and run the _Atom > Install Shell Commmands_ menu
+to install the `apm` and `atom` commands.
+
+### Convert the Package
+
+Let's convert the TextMate bundle for the [R][R] programming language. You can find other existing TextMate bundles [here][TextMateOrg].
+
+You can convert the R bundle with the following command:
+
+```sh
+apm init --package ~/.atom/packages/language-r --convert https://github.com/textmate/r.tmbundle
+```
+
+You can now browse to `~/.atom/packages/language-r` to see the converted bundle.
+
+:tada: Your new package is now ready to use, launch Atom and open a `.r` file in
+the editor to see it in action!
+
+### Further Reading
+
+* Check out [Publishing a Package](publish-a-package.html) for more information
+  on publishing the package you just created to [atom.io][atomio].
+
+[atomio]: https://atom.io
+[CSS]: http://en.wikipedia.org/wiki/Cascading_Style_Sheets
+[LESS]: http://lesscss.org
+[plist]: http://en.wikipedia.org/wiki/Property_list
+[R]: http://en.wikipedia.org/wiki/R_(programming_language)
+[TextMate]: http://macromates.com
+[TextMateOrg]: https://github.com/textmate/r.tmbundle

docs/converting-a-text-mate-theme.md

@@ -0,0 +1,68 @@
+## Converting a TextMate Theme
+
+This guide will show you how to convert a [TextMate][TextMate] theme to an Atom
+theme.
+
+### Differences
+
+TextMate themes use [plist][plist] files while Atom themes use [CSS][CSS] or
+[LESS][LESS] to style the UI and syntax in the editor.
+
+The utility that converts the theme first parses the theme's plist file and
+then creates comparable CSS rules and properties that will style Atom similarly.
+
+### Install apm
+
+The `apm` command line utility that ships with Atom supports converting
+a TextMate theme to an Atom theme.
+
+Check that you have `apm` installed by running the following command in your
+terminal:
+
+```sh
+apm help init
+```
+
+You should see a message print out with details about the `apm init` command.
+
+If you do not, launch Atom and run the _Atom > Install Shell Commmands_ menu
+to install the `apm` and `atom` commands.
+
+You can now run `apm help init` to see all the options for initializing new
+packages and themes.
+
+### Convert the Theme
+
+Download the theme you wish to convert, you can browse existing TextMate themes
+[here][TextMateThemes].
+
+Now, let's say you've downloaded the theme to `~/Downloads/MyTheme.tmTheme`,
+you can convert the theme with the following command:
+
+```sh
+apm init --theme ~/.atom/packages/my-theme --convert ~/Downloads/MyTheme.tmTheme
+```
+
+You can browse to `~/.atom/packages/my-theme` to see the converted theme.
+
+### Activate the Theme
+
+Now that your theme is installed to `~/.atom/packages` you can enable it
+by launching Atom and selecting the _Atom > Preferences..._ menu.
+
+Select the _Themes_ link on the left side and choose _My Theme_ from the
+__Syntax Theme__ dropdown menu to enable your new theme.
+
+:tada: Your theme is now enabled, open an editor to see it in action!
+
+### Further Reading
+
+* Check out [Publishing a Package](publish-a-package.html) for more information
+  on publishing the theme you just created to [atom.io][atomio].
+
+[atomio]: https://atom.io
+[CSS]: http://en.wikipedia.org/wiki/Cascading_Style_Sheets
+[LESS]: http://lesscss.org
+[plist]: http://en.wikipedia.org/wiki/Property_list
+[TextMate]: http://macromates.com
+[TextMateThemes]: http://wiki.macromates.com/Themes/UserSubmittedThemes

docs/creating-a-package.md

@@ -44,13 +44,13 @@ key mappings your package needs to load. If not specified, mappings in the
 _keymaps_ directory are added alphabetically.
 - `menus`(**Optional**): an Array of Strings identifying the order of
 the menu mappings your package needs to load. If not specified, mappings
-in the _keymap_ directory are added alphabetically.
+in the _menus_ directory are added alphabetically.
 - `snippets` (**Optional**): an Array of Strings identifying the order of the
 snippets your package needs to load. If not specified, snippets in the
 _snippets_ directory are added alphabetically.
 - `activationEvents` (**Optional**): an Array of Strings identifying events that
 trigger your package's activation. You can delay the loading of your package
-until one of these events is trigged.
+until one of these events is triggered.
 
 ## Source Code
 
@@ -154,7 +154,7 @@ loaded in alphabetical order. An optional `keymaps` array in your _package.json_
 can specify which keymaps to load and in what order.
 
 
-Keybindings are executed by determining which element the keypress occured on. In
+Keybindings are executed by determining which element the keypress occurred on. In
 the example above, `changer:magic` command is executed when pressing `ctrl-V` on
 the `.tree-view-scroller` element.
 
@@ -172,7 +172,7 @@ specify which menus to load and in what order.
 It's recommended that you create an application menu item for common actions
 with your package that aren't tied to a specific element:
 
-```coffee-script
+```coffeescript
 'menu': [
   {
     'label': 'Packages'
@@ -202,7 +202,7 @@ by other packages in the order which they were loaded.
 It's recommended to specify a context menu item for commands that are linked to
 specific parts of the interface, like adding a file in the tree-view:
 
-```coffee-script
+```coffeescript
 'context-menu':
   '.tree-view':
     'Add file': 'tree-view:add-file'
@@ -381,7 +381,7 @@ Additional libraries can be found by browsing Atom's *node_modules* folder.
 [apm]: https://github.com/atom/apm
 [git-tag]: http://git-scm.com/book/en/Git-Basics-Tagging
 [wrap-guide]: https://github.com/atom/wrap-guide/
-[keymaps]: internals/keymaps.md
+[keymaps]: advanced/keymaps.md
 [theme-variables]: theme-variables.md
 [tm-tokens]: http://manual.macromates.com/en/language_grammars.html
 [spacepen]: https://github.com/nathansobo/space-pen

docs/customizing-atom.md

@@ -112,30 +112,34 @@ namespaces: `core` and `editor`.
 
 ### Quick Personal Hacks
 
-### user.coffee
+### init.coffee
 
-When Atom finishes loading, it will evaluate _user.coffee_ in your _~/.atom_
+When Atom finishes loading, it will evaluate _init.coffee_ in your _~/.atom_
 directory, giving you a chance to run arbitrary personal CoffeeScript code to
 make customizations. You have full access to Atom's API from code in this file.
 If customizations become extensive, consider [creating a
 package][create-a-package].
 
-### user.less
+This file can also be named _init.js_ and contain JavaScript code.
+
+### styles.css
 
 If you want to apply quick-and-dirty personal styling changes without creating
 an entire theme that you intend to distribute, you can add styles to
-_user.less_ in your _~/.atom_ directory.
+_styles.css_ in your _~/.atom_ directory.
 
 For example, to change the color of the highlighted line number for the line
-that contains the cursor, you could add the following style to _user.less_:
+that contains the cursor, you could add the following style to _styles.css_:
 
-```less
-@highlight-color: pink;
-
-.editor .line-number.cursor-line {
-  color: @highlight-color;
+```css
+.editor .cursor {
+  border-color: pink;
 }
 ```
 
+You can also name the file _styles.less_ if you want to style Atom using
+[LESS][LESS].
+
 [create-a-package]: creating-packages.md
 [create-theme]: creating-a-theme.md
+[LESS]: http://www.lesscss.org

docs/getting-started.md

@@ -19,13 +19,11 @@ bindings][key-bindings] section.
 
 ### Working With Files
 
-Atom windows are scoped to the directory they're opened from. If you launch Atom
-from the command line everything will be relative to the current directory. This
-means that the tree view on the left will only show files contained within that
-directory.
-
-This can be a useful way to organize multiple projects, as each project will be
-contained within its own window.
+Atom windows are scoped to a single directory on disk. If you launch Atom from
+the command line via the `atom` command and don't specify a path, Atom opens a
+window for the current working directory. The current window's directory will be
+visible as the root of the tree view at the left, and also serve as the context
+for all file-related operations.
 
 #### Finding Files
 
@@ -34,20 +32,17 @@ begin typing the name of the file you're looking for. If you are looking for a
 file that is already open press `cmd-b` to bring up a searchable list of open
 files.
 
-You can also use the tree view to navigate to a file. To open or move focus to
-the tree view, press `cmd-\`. You can then navigate to a file using the arrow
-keys and select it with `return`.
+You can also use the tree view to navigate to a file. To open and focus the
+the tree view, press `ctrl-0`. The tree view can be toggled open and closed with
+`cmd-\`.
 
 #### Adding, Moving, Deleting Files
 
-Currently, all file modification is performed via the tree view. To add a file,
-select a directory in the tree view and press `a`. Then type the name of the
-file. Any intermediate directories you type will be created automatically if
-needed.
-
-To move or rename a file or directory, select it in the tree view and press `m`.
-
-To delete a file, select it in the tree view and press `delete`.
+Currently, all file modification is performed via the tree view. Add, move, or
+delete a file by right-clicking in the tree view and selecting the desired
+operation from the context menu. You can also perform these operations from the
+keyboard by selecting a file or directory and using `a` to add, `m` to move, and
+`delete` to delete.
 
 ### Searching
 
@@ -58,35 +53,43 @@ To search within a buffer use `cmd-f`. To search the entire project use
 
 #### Navigating By Symbols
 
-If you want to jump to a method press `cmd-r`. It opens a list of all symbols
-in the current file.
+To jump to a symbol such as a method definition, press `cmd-r`. This opens a
+list of all symbols in the current file, which you can fuzzy filter similarly to
+`cmd-t`.
 
-To search for symbols across your project use `cmd-shift-r`, but you'll need to
-make sure you have a ctags installed and a tags file generated for your project.
-Also, if you're editing CoffeeScript, it's a good idea to update your `~/.ctags`
-file to understand the language. Here is [a good example][ctags].
+To search for symbols across your project, use `cmd-shift-r`. First you'll need
+to make sure you have ctags installed and a tags file generated for your
+project. Also, if you're editing CoffeeScript, it's a good idea to update your
+`~/.ctags` file to understand the language. Here is [a good example][ctags].
 
 ### Split Panes
 
-You can split any editor pane horizontally or vertically by using `cmd-k right` or
-`cmd-k down`. Once you have a split pane, you can move focus between them with
-`cmd-k cmd-right` or `cmd-k cmd-down`. To close a pane, close all tabs inside it.
+You can split any editor pane horizontally or vertically by using `cmd-k right`
+or `cmd-k down`. Once you have a split pane, you can move focus between them
+with `cmd-k cmd-right` or `cmd-k cmd-down`. To close a pane, close all its
+editors with `meta-w`, then press `meta-w` one more time to close the pane. You
+can configure panes to auto-close with empty in the preferences.
 
 ### Folding
 
-You can fold everything with `alt-cmd-{` and unfold everything with
-`alt-cmd-}`. Or, you can fold / unfold by a single level with `alt-cmd-[` and
-`alt-cmd-]`.
+You can fold blocks of code by clicking the arrows that appear when you hover
+your mouse cursor over the gutter. You can also fold and unfold from the
+keyboard with `alt-cmd-[` and `alt-cmd-]`. To fold everything, use
+`alt-cmd-shift-{` and to unfold everything use `alt-cmd-shift-}`. You can also
+fold at a specific indentation level with `cmd-k cmd-N` where N is the
+indentation depth.
 
 ### Soft-Wrap
 
 If you want to toggle soft wrap, trigger the command from the command palette.
 Press `cmd-shift-P` to open the palette, then type "wrap" to find the correct
-command.
+command. By default, lines will wrap based on the size of the editor. If you
+prefer to wrap at a specific line length, toggle "Wrap at preferred line length"
+in preferences.
 
 ## Configuration
 
-Press `cmd-,` to display the a settings pane. This serves as the primary
+Press `cmd-,` to display the preferences pane. This serves as the primary
 interface for adjusting config settings, installing packages and changing
 themes.
 

docs/index.md

@@ -7,7 +7,7 @@
 
 ### Advanced Topics
 
-* [Configuration](internals/configuration.md)
-* [Keymaps](internals/keymaps.md)
-* [Serialization](internals/serialization.md)
-* [View System](internals/view-system.md)
+* [Configuration](advanced/configuration.md)
+* [Keymaps](advanced/keymaps.md)
+* [Serialization](advanced/serialization.md)
+* [View System](advanced/view-system.md)

docs/internals/configuration.md

@@ -1,61 +0,0 @@
-## Configuration API
-
-### Reading Config Settings
-
-If you are writing a package that you want to make configurable, you'll need to
-read config settings. You can read a value from `config` with `config.get`:
-
-```coffeescript
-# read a value with `config.get`
-@showInvisibles() if config.get "edtior.showInvisibles"
-```
-
-Or you can use `observeConfig` to track changes from a view object.
-
-```coffeescript
-class MyView extends View
-  initialize: ->
-    @observeConfig 'editor.fontSize', () =>
-      @adjustFontSize()
-```
-
-The `observeConfig` method will call the given callback immediately with the
-current value for the specified key path, and it will also call it in the future
-whenever the value of that key path changes.
-
-Subscriptions made with `observeConfig` are automatically canceled when the
-view is removed. You can cancel config subscriptions manually via the
-`unobserveConfig` method.
-
-```coffeescript
-view1.unobserveConfig() # unobserve all properties
-```
-
-You can add the ability to observe config values to non-view classes by
-extending their prototype with the `ConfigObserver` mixin:
-
-```coffeescript
-ConfigObserver = require 'config-observer'
-_.extend MyClass.prototype, ConfigObserver
-```
-
-### Writing Config Settings
-
-As discussed above, the config database is automatically populated from
-`config.cson` when Atom is started, but you can programmatically write to it in
-the following way:
-
-```coffeescript
-# basic key update
-config.set("core.showInvisibles", true)
-
-config.pushAtKeyPath("core.disabledPackages", "wrap-guide")
-```
-
-You can also use `setDefaults`, which will assign default values for keys that
-are always overridden by values assigned with `set`. Defaults are not written out
-to the the `config.json` file to prevent it from becoming cluttered.
-
-```coffeescript
-config.setDefaults("editor", fontSize: 18, showInvisibles: true)
-```

docs/internals/keymaps.md

@@ -1,69 +0,0 @@
-## Keymaps In-Depth
-
-### Structure of a Keymap File
-
-Keymap files are encoded as JSON or CSON files containing nested hashes. The
-top-level keys of a keymap are **CSS 3 selectors**, which specify a particular
-context in Atom's interface. Common selectors are `.editor`, which scopes
-bindings to just work when an editor is focused, and `body`, which scopes
-bindings globally.
-
-Beneath the selectors are hashes mapping **keystroke patterns** to
-**semantic events**. A keystroke pattern looks like the following examples.
-Note that the last example describes multiple keystrokes in succession:
-
-- `p`
-- `2`
-- `ctrl-p`
-- `ctrl-alt-cmd-p`
-- `tab`
-- `escape`
-- `enter`
-- `ctrl-w w`
-
-A semantic event is the name of the custom event that will be triggered on the
-target of the keydown event when a key binding matches. You can use the command
-palette (bound to `cmd-shift-P`), to get a list of relevant events and their bindings
-in any focused context in Atom.
-
-### Rules for Mapping A Keydown Event to A Semantic Event
-
-A keymap's job is to translate a physical keystroke event (like `cmd-D`) into a
-semantic event (like `editor:duplicate-line`). Whenever a keydown event occurs
-on a focused element, it bubbles up the DOM as usual. As soon as an element on
-the bubble path matches a key binding for the keystroke, the binding's semantic
-event is triggered on the original target of the keydown event. Just as with
-CSS, if multiple selectors match an element, the most specific selector is
-favored. If two selectors have the same specificity, the selector that occurs
-latest in the cascade is favored.
-
-Currently, there's no way to specify selector ordering within a single keymap,
-because JSON hashes do not preserve order. Rather than making the format more
-awkward in order to preserve order, we've opted to handle cases where order is
-critical by breaking the keymap into two separate files, such as
-`snippets-1.cson` and `snippets-2.cson`.
-
-### Overloading Key Bindings
-
-Occasionally, it makes sense to layer multiple actions on top of the same key
-binding. An example of this is the snippets package. You expand a snippet by
-pressing `tab` immediately following a snippet's prefix. But if the cursor is
-not following a valid snippet prefix, then we want tab to perform its normal
-action (probably inserting a tab character or the appropriate number of spaces).
-
-To achieve this, the snippets package makes use of the `abortKeyBinding` method
-on the event object that's triggered by the binding for `tab`.
-
-```coffee-script
-# pseudo-code
-editor.command 'snippets:expand', (e) =>
-  if @cursorFollowsValidPrefix()
-    @expandSnippet()
-  else
-    e.abortKeyBinding()
-```
-
-When the event handler observes that the cursor does not follow a valid prefix,
-it calls `e.abortKeyBinding()`, which tells the keymap system to continue
-searching up the cascade for another matching binding. In this case, the default
-implementation of `tab` ends up getting triggered.

docs/proposals/atom-docs.md

@@ -1,63 +0,0 @@
-## Atom Documentation Format
-
-This document describes our documentation format, which is markdown with
-a few rules.
-
-### Philosophy
-
-1. Method and argument names **should** clearly communicate its use.
-1. Use documentation to enhance and not correct method/argument names.
-
-#### Basic
-
-In some cases all that's required is a single line. **Do not** feel
-obligated to write more because we have a format.
-
-```markdown
-# Private: Returns the number of pixels from the top of the screen.
-```
-
-* **Each method should declare whether it's public or private by using `Public:`
-or `Private:`** prefix.
-* Following the colon, there should be a short description (that isn't redundant with the
-method name).
-* Documentation should be hard wrapped to 80 columns.
-
-### Public vs Private
-
-If a method is public it can be used by other classes (and possibly by
-the public API). The appropriate steps should be taken to minimize the impact
-when changing public methods. In some cases that might mean adding an
-appropriate release note. In other cases it might mean doing the legwork to
-ensure all affected packages are updated.
-
-#### Complex
-
-For complex methods it's necessary to explain exactly what arguments
-are required and how different inputs effect the operation of the
-function.
-
-The idea is to communicate things that the API user might not know about,
-so repeating information that can be gleaned from the method or argument names
-is not useful.
-
-```markdown
-# Private: Determine the accelerator for a given command.
-#
-# * command:
-#   The name of the command.
-# * keystrokesByCommand:
-#   An {Object} whose keys are commands and the values are Arrays containing
-#   the keystrokes.
-# * options:
-#     + accelerators:
-#       Boolean to determine whether accelerators should be shown.
-#
-# Returns a String containing the keystroke in a format that can be interpreted
-# by atom shell to provide nice icons where available.
-#
-# Raises an Exception if no window is available.
-```
-
-* Use curly brackets `{}` to provide links to other classes.
-* Use `+` for the options list.

docs/proposals/private-beta-tasks.md

@@ -1,70 +0,0 @@
-**Polish the user experience**
-
-First and foremost, Atom is a **product**. Atom needs to feel familiar and
-inviting. This includes a solid introductory experience and parity with the most
-important features of Sublime Text.
-
-  * First launch UI and flow (actions below should be easily discoverable)
-    * Create a new file
-    * Open a project and edit an existing file
-    * Install a package
-    * Change settings (adjust theme, change key bindings, set config options)
-    * How to use command P
-  * Use collaboration internally
-  * How and where to edit keyBinding should be obvious to new users
-  * Finish find and replace in buffer/project
-  * Atom should start < 300ms
-  * Match Sublime's multiple selection functionality (#523)
-  * Fix softwrap bugs
-  * Menus & Context menus
-  * Track usage/engagement of our users (make this opted in?)
-  * Windows support
-  * Reliably and securely auto-update and list what's new
-  * Secure access to the keychain (don't give every package access to the keychain)
-  * Secure access to GitHub (each package can ask to have it's own oauth token)
-  * Don't crash when opening/editing large (> 10Mb) files
-  * Send js and native crash reports to a remote server
-
-**Lay solid groundwork for a package and theme ecosystem**
-
-Extensibility is one of Atom's key value propositions, so a smooth experience
-for creating and maintaining packages is just as important as the user
-experience. The package development, dependency and publishing workflow needs to
-be solid. We also want to have a mechanism for clearly communicating with
-package authors about breaking API changes.
-
-  * Finish APM backend (integrate with GitHub Releases)
-  * Streamline Dev workflow
-    * `apm create` - create package scaffolding
-    * `apm test` - so users can run focused package tests
-    * `apm publish` - should integrate release best practices (ie npm version)
-  * Determine which classes and methods should be included in the public API
-  * Users can find/install/update/fork existing packages and themes
-  
-**Tighten up the view layer**
-Our current approach to the view layer need some improvement. We want to
-actively promote the use of the M-V-VM design pattern, provide some declarative
-event binding mechanisms in the view layer, and improve the performance of the
-typical package specs. We don't want the current approach to be used as an
-example in a bunch of new packages, so it's important to improve it now.
-
-  * Add marker view API
-
-**Get atom.io online with some exciting articles and documentation**
-We'd love to send our private alpha candidates to a nice site with information
-about what Atom is, the philosophies and technologies behind it, and guidance
-for how to get started.
-
-  * Design and create www.atom.io
-    * Guides
-      * Theme & Package creation guide
-    * Full API per release tag
-    * Changelog per release
-    * Explanation of features
-    * Explain Semver and general plans for the future (reassure developers we care about them)
-    * General Values/Goals
-  * Make docs accessible from Atom
-  * Community/contribution guidelines
-    * Is all communication to be done through issues?
-    * When should you publish a plugin?
-    * Do we need to vet plugins from a security perspective?

docs/proposals/private-beta-timeline.md

@@ -1,16 +0,0 @@
-## Proposed Timeline
-
-1. **October 30st** - Internal launch - persuade as many githubbers to switch as
-possible.
-
-1. Triage bugs and identify what needs to be fixed before private alpha. Maybe
-talk to @chrissiebrodigan about doing a UX study.
-
-1. **November 22st** - Private alpha launch
-
-1. Trickle out invites as people ask/we need more testers.
-
-1. If our usage metrics/engagement metrics decrease, stop, identify the issue
-and fix it before continuing.
-
-1. Launch

docs/publishing-a-package.md

@@ -0,0 +1,97 @@
+## Publishing a Package
+
+This guide will show you how to publish a package or theme to the
+[atom.io][atomio] package registry.
+
+Publishing a package allows other people to install it and use it in Atom. It
+is a great way to share what you've made and get feedback and contributions from
+others.
+
+This guide assumes your package's name is `my-package` and but you should pick a
+better name.
+
+### Install apm
+
+The `apm` command line utility that ships with Atom supports publishing packages
+to the atom.io registry.
+
+Check that you have `apm` installed by running the following command in your
+terminal:
+
+```sh
+apm help publish
+```
+
+You should see a message print out with details about the `apm publish` command.
+
+If you do not, launch Atom and run the _Atom > Install Shell Commmands_ menu
+to install the `apm` and `atom` commands.
+
+### Prepare Your Package
+
+If you've followed the steps in the [your first package][your-first-package]
+doc then you should be ready to publish and you can skip to the next step.
+
+If not, there are a few things you should check before publishing:
+
+  * Your *package.json* file has `name`, `description`, and `repository` fields.
+  * Your *package.json* file has a `version` field with a value of  `"0.0.0"`.
+  * Your *package.json* file has an `engines` field that contains an entry
+    for Atom such as: `"engines": {"atom": ">=0.50.0"}`.
+  * Your package has a `README.md` file at the root.
+  * Your package is in a Git repository that has been pushed to
+    [GitHub][github]. Follow [this guide][repo-guide] if your package isn't
+    already on GitHub.
+  
+### Publish Your Package
+
+Before you publish a package it is a good idea to check ahead of time if
+a package with the same name has already been published to atom.io. You can do
+that by visiting `http://atom.io/packages/my-package` to see if the package
+already exists. If it does, update your package's name to something that is
+available before proceeding.
+
+Now let's review what the `apm publish` command does:
+
+  1. Registers the package name on atom.io if it is being published for the
+     first time.
+  2. Updates the `version` field in the *package.json* file and commits it.
+  3. Creates a new [Git tag][git-tag] for the version being published.
+  4. Pushes the tag and current branch up to GitHub.
+  5. Updates atom.io with the new version being published.
+  
+Now run the following commands to publish your package:
+
+```sh
+cd ~/github/my-package
+apm publish minor
+```
+
+If this is the first package you are publishing, the `apm publish` command may
+prompt you for your GitHub username and password. This is required to publish
+and you only need to enter this information the first time you publish. The
+credentials are stored securely in your [keychain][keychain] once you login.
+
+:tada: Your package is now published and available on atom.io. Head on over to
+`http://atom.io/packages/my-package` to see your package's page.
+
+The `minor` option to the publish command tells apm to increment the second
+digit of the version before publishing so the published version will be `0.1.0`
+and the Git tag created will be `v0.1.0`.
+
+In the future you can run `apm publish major` to publish the `1.0.0` version but
+since this was the first version being published it is a good idead to start
+with a minor release.
+
+### Further Reading
+
+* Check out [semantic versioning][semver] to learn more about versioning your
+  package releases.
+
+[atomio]: https://atom.io
+[github]: https://github.com
+[git-tag]: http://git-scm.com/book/en/Git-Basics-Tagging
+[keychain]: http://en.wikipedia.org/wiki/Keychain_(Apple)
+[repo-guide]: http://guides.github.com/overviews/desktop
+[semver]: http://semver.org
+[your-first-package]: your-first-package.html

docs/your-first-package.md

@@ -1,335 +1,155 @@
-# Creating Your First Package
+# Create Your First Package
 
-Let's take a look at creating your first package.
+This tutorial will guide you though creating a simple command that replaces the
+selected text with [ascii art](http://en.wikipedia.org/wiki/ASCII_art). When you
+run our new command with the word "cool" selected, it will be replaced with:
 
-To get started, hit `cmd-shift-P`, and start typing "Generate Package" to generate
-a package. Once you select the "Generate Package" command, it'll ask you for a
-name for your new package. Let's call ours _changer_.
-
-Atom will pop open a new window, showing the _changer_ package with a default set of
-folders and files created for us. Hit `cmd-shift-P` and start typing "Changer." You'll
-see a new `Changer:Toggle` command which, if selected, pops up a greeting. So far,
-so good!
-
-In order to demonstrate the capabilities of Atom and its API, our Changer plugin
-is going to do two things:
-
-1. It'll show only modified files in the file tree
-2. It'll append a new pane to the editor with some information about the modified
-files
-
-Let's get started!
-
-## Changing Keybindings and Commands
-
-Since Changer is primarily concerned with the file tree, let's write a
-key binding that works only when the tree is focused. Instead of using the
-default `toggle`, our keybinding executes a new command called `magic`.
-
-_keymaps/changer.cson_ should change to look like this:
-
-```coffeescript
-'.tree-view':
-  'ctrl-V': 'changer:magic'
+```
+                     ___
+                    /\_ \
+  ___    ___     ___\//\ \
+ /'___\ / __`\  / __`\\ \ \
+/\ \__//\ \L\ \/\ \L\ \\_\ \_
+\ \____\ \____/\ \____//\____\
+ \/____/\/___/  \/___/ \/____/
 ```
 
-Notice that the keybinding is called `ctrl-V` — that's actually `ctrl-shift-v`.
-You can use capital letters to denote using `shift` for your binding.
+The final package can be viewed at
+[https://github.com/atom/ascii-art](https://github.com/atom/ascii-art).
 
-`.tree-view` represents the parent container for the tree view.
-Keybindings only work within the context of where they're entered. In this case,
-hitting `ctrl-V` anywhere other than tree won't do anything. Obviously, you can
-bind to any part of the editor using element, id, or class names. For example,
-you can map to `body` if you want to scope to anywhere in Atom, or just `.editor`
-for the editor portion.
+To begin, press `cmd-shift-P` to bring up the [Command
+Palette](https://github.com/atom/command-palette). Type "generate package" and
+select the "Package Generator: Generate Package" command. Now we need to name
+the package. Let's call it _ascii-art_.
 
-To bind keybindings to a command, we'll need to do a bit of association in our
-CoffeeScript code using the `atom.workspaceView.command` method. This method takes a command
-name and executes a callback function. Open up _lib/changer-view.coffee_, and
-change `atom.workspaceView.command "changer:toggle"` to look like this:
+Atom will open a new window with the contents of our new _ascii-art_ package
+displayed in the Tree View. Because this window is opened **after** the package
+is created, the ASCII Art package will be loaded and available in our new
+window. To verify this, toggle the Command Palette (`cmd-shift-P`) and type
+"ASCII Art". You'll see a new `ASCII Art: Toggle` command. When triggered, this
+command displays a default message.
+
+Now let's edit the package files to make our ASCII Art package do something
+interesting. Since this package doesn't need any UI, we can remove all
+view-related code. Start by opening up _lib/ascii-art.coffee_. Remove all view
+code, so the `module.exports` section looks like this:
 
 ```coffeescript
-atom.workspaceView.command "changer:magic", => @magic()
+module.exports =
+  activate: ->
 ```
 
-It's common practice to namespace your commands with your package name, separated
-with a colon (`:`). Make sure to rename your `toggle` method to `magic` as well.
+## Create a Command
 
-Every time you reload the Atom editor, changes to your package code will be reevaluated,
-just as if you were writing a script for the browser. Reload the editor, click on
-the tree, hit your keybinding, and...nothing happens! What the heck?!
+Now let's add a command. We recommend that you namespace your commands with the
+package name followed by a `:`, so we'll call our command `ascii-art:convert`.
+Register the command in _lib/ascii-art.coffee_:
 
-Open up the _package.json_ file, and find the property called `activationEvents`.
-Basically, this key tells Atom to not load a package until it hears a certain event.
-Change the event to `changer:magic` and reload the editor:
+```coffeescript
+module.exports =
+  activate: ->
+    atom.workspaceView.command "ascii-art:convert", => @convert()
+
+  convert: ->
+    # This assumes the active pane item is an editor
+    editor = atom.workspace.activePaneItem
+    editor.insertText('Hello, World!')
+```
+
+The `atom.workspaceView.command` method takes a command name and a callback. The
+callback executes when the command is triggered. In this case, when the command
+is triggered the callback will call the `convert` method and insert 'Hello,
+World!'.
+
+## Reload the Package
+
+Before we can trigger `ascii-art:convert`, we need to load the latest code for
+our package by reloading the window. Run the command `window:reload` from the
+command palette or by pressing `ctrl-alt-cmd-l`.
+
+## Trigger the Command
+
+Now open the command panel and search for the `ascii-art:convert` command. But
+it's not there! To fix this, open _package.json_ and find the property called
+`activationEvents`. Activation Events speed up load time by allowing Atom to
+delay a package's activation until it's needed. So remove the existing command
+and add `ascii-art:convert` to the `activationEvents` array:
 
 ```json
-"activationEvents": ["changer:magic"]
+"activationEvents": ["ascii-art:convert"],
 ```
 
-Hitting the key binding on the tree now works!
+First, reload the window by running the command `window:reload`. Now when you
+run the `ascii-art:convert` command it will output 'Hello, World!'
 
-## Working with Styles
+## Add a Key Binding
 
-The next step is to hide elements in the tree that aren't modified. To do that,
-we'll first try and get a list of files that have not changed.
-
-All packages are able to use jQuery in their code. In fact, there's [a list of
-the bundled libraries Atom provides by default][bundled-libs].
-
-We bring in jQuery by requiring the `atom` package and binding it to the `$` variable:
+Now let's add a key binding to trigger the `ascii-art:convert` command. Open
+_keymaps/ascii-art.cson_ and add a key binding linking `ctrl-alt-a` to the
+`ascii-art:convert` command. You can delete the pre-existing key binding since
+you don't need it anymore. When finished, the file will look like this:
 
 ```coffeescript
-{$, View} = require 'atom'
+'.editor':
+  'cmd-alt-a': 'ascii-art:convert'
 ```
 
-Now, we can define the `magic` method to query the tree to get us a list of every
-file that _wasn't_ modified:
+Notice `.editor` on the first line. Just like CSS, keymap selectors *scope* key
+bindings so they only apply to specific elements. In this case, our binding is
+only active for elements matching the `.editor` selector. If the Tree View has
+focus, pressing `cmd-alt-a` won't trigger the `ascii-art:convert` command. But
+if the editor has focus, the `ascii-art:convert` method *will* be triggered.
+More information on key bindings can be found in the
+[keymaps](advanced/keymaps.html) documentation.
 
-```coffeescript
-magic: ->
-  $('ol.entries li').each (i, el) ->
-    if !$(el).hasClass("status-modified")
-      console.log el
-```
+Now reload the window and verify that the key binding works! You can also verify
+that it **doesn't** work when the Tree View is focused.
 
-You can access the dev console by hitting `alt-cmd-i`. Here, you'll see all the
-statements from `console` calls. When we execute the `changer:magic` command, the
-browser console lists items that are not being modified (_i.e._, those without the
-`status-modified` class). Let's add a class to each of these elements called `hide-me`:
+## Add the ASCII Art
 
-```coffeescript
-magic: ->
-  $('ol.entries li').each (i, el) ->
-    if !$(el).hasClass("status-modified")
-      $(el).addClass("hide-me")
-```
+Now we need to convert the selected text to ASCII art. To do this we will use
+the [figlet](https://npmjs.org/package/figlet) [node](http://nodejs.org/) module
+from [npm](https://npmjs.org/). Open _package.json_ and add the latest version of
+figlet to the dependencies:
 
-With our newly added class, we can manipulate the visibility of the elements
-with a simple stylesheet. Open up _changer.css_ in the _stylesheets_ directory,
-and add a single entry:
-
-```css
-ol.entries .hide-me {
-  display: none;
+```json
+"dependencies": {
+   "figlet": "1.0.8"
 }
 ```
 
-Refresh Atom, and run the `changer` command. You'll see all the non-changed
-files disappear from the tree. Success!
+After saving the file, run the command 'update-package-dependencies:update' from
+the Command Palette. This will install the package's node module dependencies,
+only figlet in this case. You will need to run
+'update-package-dependencies:update' whenever you update the dependencies field
+in your _package.json_ file.
 
-![Changer_File_View]
-
-There are a number of ways you can get the list back; let's just naively iterate
-over the same elements and remove the class:
+Now require the figlet node module in _lib/ascii-art.coffee_ and instead of
+inserting 'Hello, World!' convert the selected text to ASCII art.
 
 ```coffeescript
-magic: ->
-  $('ol.entries li').each (i, el) ->
-    if !$(el).hasClass("status-modified")
-      if !$(el).hasClass("hide-me")
-        $(el).addClass("hide-me")
-      else
-        $(el).removeClass("hide-me")
+convert: ->
+  # This assumes the active pane item is an editor
+  editor = atom.workspace.activePaneItem
+  selection = editor.getSelection()
+
+  figlet = require 'figlet'
+  figlet selection.getText(), {font: "Larry 3D 2"}, (error, asciiArt) ->
+    if error
+      console.error(error)
+    else
+      selection.insertText("\n#{asciiArt}\n")
 ```
 
-## Creating a New Panel
-
-The next goal of this package is to append a panel to the Atom editor that lists
-some information about the modified files.
-
-To do that, we're going to first open up [the style guide][styleguide]. The Style
-Guide lists every type of UI element that can be created by an Atom package. Aside
-from helping you avoid writing fresh code from scratch, it ensures that packages
-have the same look and feel no matter how they're built.
-
-Every package that extends from the `View` class can provide an optional class
-method called `content`. The `content` method constructs the DOM that your
-package uses as its UI. The principals of `content` are built entirely on
-[SpacePen][space-pen], which we'll touch upon only briefly here.
-
-Our display will simply be an unordered list of the file names, and their
-modified times. We'll append this list to a panel on the bottom of the editor. A
-basic `panel` element inside a `tool-panel` will work well for us. Let's start by carving out a
-`div` to hold the filenames:
-
-```coffeescript
-@content: ->
-  @div class: "changer tool-panel panel-bottom", =>
-    @div class: "panel", =>
-      @div class: "panel-heading", "Modified Files"
-      @div class: "panel-body padded", outlet: 'modifiedFilesContainer', =>
-        @ul class: 'modified-files-list', outlet: 'modifiedFilesList', =>
-          @li 'Modified File Test'
-          @li 'Modified File Test'
-```
-
-You can add any HTML attribute you like. `outlet` names the variable your
-package can use to manipulate the element directly. The fat arrow (`=>`)
-indicates that the next DOM set are nested children.
-
-Once again, you can style `li` elements using your stylesheets. Let's test that
-out by adding these lines to the _changer.css_ file:
-
-```css
-ul.modified-files-list {
-  color: white;
-}
-```
-
-We'll add one more line to the end of the `magic` method to make this pane
-appear:
-
-```coffeescript
-atom.workspaceView.prependToBottom(this)
-```
-
-If you refresh Atom and hit the key command, you'll see a box appear right
-underneath the editor:
-
-![Changer_Panel_Append]
-
-As you might have guessed, `atom.workspaceView.prependToBottom` tells Atom to
-prepend `this` item (_i.e._, whatever is defined by`@content`). If we had called
-`atom.workspaceView.appendToBottom`, the pane would be attached below the status
-bar.
-
-Before we populate this panel for real, let's apply some logic to toggle the
-pane off and on, just like we did with the tree view. Replace the
-`atom.workspaceView.prependToBottom` call with this code:
-
-```coffeescript
-# toggles the pane
-if @hasParent()
-  @remove()
-else
-  atom.workspaceView.prependToBottom(this)
-```
-
-There are about a hundred different ways to toggle a pane on and off, and this
-might not be the most efficient one. If you know your package needs to be
-toggled on and off more freely, it might be better to draw the interface during the
-initialization, then immediately call `hide()` on the element to remove it from
-the view. You can then swap between `show()` and `hide()`, and instead of
-forcing Atom to add and remove the element as we're doing here, it'll just set a
-CSS property to control your package's visibility.
-
-Refresh Atom, hit the key combo, and watch your test list appear and disappear.
-
-## Calling Node.js Code
-
-Since Atom is built on top of [Node.js][node], you can call any of its libraries,
-including other modules that your package requires.
-
-We'll iterate through our resulting tree, and construct the path to our modified
-file based on its depth in the tree. We'll use Node to handle path joining for
-directories.
-
-Add the following Node module to the top of your file:
-
-```coffeescript
-path = require 'path'
-```
-
-Then, add these lines to your `magic` method, _before_ your pane drawing code:
-
-```coffeescript
-modifiedFiles = []
-# for each single entry...
-$('ol.entries li.file.status-modified span.name').each (i, el) ->
-  filePath = []
-  # ...grab its name...
-  filePath.unshift($(el).text())
-
-  # ... then find its parent directories, and grab their names
-  parents = $(el).parents('.directory.status-modified')
-  parents.each (i, el) ->
-    filePath.unshift($(el).find('div.header span.name').eq(0).text())
-
-  modifiedFilePath = path.join(atom.project.rootDirectory.path, filePath.join(path.sep))
-  modifiedFiles.push modifiedFilePath
-```
-
-`modifiedFiles` is an array containing a list of our modified files. We're also
-using the node.js [`path` library][path] to get the proper directory separator
-for our system.
-
-Remove the two `@li` elements we added in `@content`, so that we can
-populate our `modifiedFilesList` with real information. We'll do that by
-iterating over `modifiedFiles`, accessing a file's last modified time, and
-appending it to `modifiedFilesList`:
-
-```coffeescript
-# toggles the pane
-if @hasParent()
-  @remove()
-else
-  for file in modifiedFiles
-    stat = fs.lstatSync(file)
-    mtime = stat.mtime
-    @modifiedFilesList.append("<li>#{file} - Modified at #{mtime}")
-  atom.workspaceView.prependToBottom(this)
-```
-
-When you toggle the modified files list, your pane is now populated with the
-filenames and modified times of files in your project:
-
-![Changer_Panel_Timestamps]
-
-You might notice that subsequent calls to this command reduplicate information.
-We could provide an elegant way of rechecking files already in the list, but for
-this demonstration, we'll just clear the `modifiedFilesList` each time it's closed:
-
-```coffeescript
-# toggles the pane
-if @hasParent()
-  @modifiedFilesList.empty() # added this to clear the list on close
-  @remove()
-else
-  for file in modifiedFiles
-    stat = fs.lstatSync(file)
-    mtime = stat.mtime
-    @modifiedFilesList.append("<li>#{file} - Modified at #{mtime}")
-  atom.workspaceView.prependToBottom(this)
-```
-
-## Coloring UI Elements
-
-For packages that create new UI elements, adhering to the style guide is just one
-part to keeping visual consistency. Packages dealing with color, fonts, padding,
-margins, and other visual cues should rely on [Theme Variables][theme-vars], instead
-of developing individual styles. Theme variables are variables defined by Atom
-for use in packages and themes. They're only available in [`LESS`](http://lesscss.org/)
-stylesheets.
-
-For our package, let's remove the style defined by `ul.modified-files-list` in
-_changer.css_. Create a new file under the _stylesheets_ directory called _text-colors.less_.
-Here, we'll import the _ui-variables.less_ file, and define some Atom-specific
-styles:
-
-```less
-@import "ui-variables";
-
-ul.modified-files-list {
-  color: @text-color;
-  background-color: @background-color-info;
-}
-```
-
-Using theme variables ensures that packages look great alongside any theme.
+Select some text in an editor window and hit `cmd-alt-a`. :tada: You're now an
+ASCII art professional!
 
 ## Further reading
 
-For more information on the mechanics of packages, check out
-[Creating a Package][creating-a-package].
+* [Getting your project on GitHub guide](http://guides.github.com/overviews/desktop)
 
-[bundled-libs]: creating-a-package.html#included-libraries
-[styleguide]: https://github.com/atom/styleguide
-[space-pen]: https://github.com/atom/space-pen
-[node]: http://nodejs.org/
-[path]: http://nodejs.org/docs/latest/api/path.html
-[changer_file_view]: https://f.cloud.github.com/assets/69169/1441187/d7a7cb46-41a7-11e3-8128-d93f70a5d5c1.png
-[changer_panel_append]: https://f.cloud.github.com/assets/69169/1441189/db0c74da-41a7-11e3-8286-b82dd9190c34.png
-[changer_panel_timestamps]: https://f.cloud.github.com/assets/69169/1441190/dcc8eeb6-41a7-11e3-830f-1f1b33072fcd.png
-[theme-vars]: theme-variables.html
-[creating-a-package]: creating-a-package.html
+* [Creating a package guide](creating-a-package.html) for more information
+  on the mechanics of packages
+
+* [Publishing a package guide](publish-a-package.html) for more information
+  on publishing your package to [atom.io](https://atom.io)

dot-atom/init.coffee

@@ -0,0 +1,14 @@
+# Your init script
+#
+# Atom will evaluate this file each time a new window is opened. It is run
+# after packages are loaded/activated and after the previous editor state
+# has been restored.
+#
+# An example hack to make opened Markdown files always be soft wrapped:
+#
+# path = require 'path'
+#
+# atom.workspaceView.eachEditorView (editorView) ->
+#   editor = editorView.getEditor()
+#   if path.extname(editor.getPath()) is '.md'
+#     editor.setSoftWrap(true)

dot-atom/keymap.cson

@@ -1,9 +1,13 @@
-# User keymap
+# Your keymap
 #
 # Atom keymaps work similarly to stylesheets. Just as stylesheets use selectors
 # to apply styles to elements, Atom keymaps use selectors to associate
-# keystrokes with events in specific contexts. Here's a small example, excerpted
-# from Atom's built-in keymaps:
+# keystrokes with events in specific contexts.
+#
+# You can create a new keybinding in this file by typing "key" and then hitting
+# tab.
+#
+# Here's an example taken from Atom's built-in keymap:
 #
 # '.editor':
 #   'enter': 'editor:newline'
@@ -11,3 +15,4 @@
 # 'body':
 #   'ctrl-P': 'core:move-up'
 #   'ctrl-p': 'core:move-down'
+#

dot-atom/snippets.cson

@@ -0,0 +1,15 @@
+# Your snippets
+#
+# Atom snippets allow you to enter a simple prefix in the editor and hit tab to
+# expand the prefix into a larger code block with templated values.
+#
+# You can create a new snippet in this file by typing "snip" and then hitting
+# tab.
+#
+# An example CoffeeScript snippet to expand log to console.log:
+#
+# '.source.coffee':
+#   'Console log':
+#     'prefix': 'log'
+#     'body': 'console.log $1'
+#

dot-atom/snippets/coffee.cson

@@ -1,44 +0,0 @@
-".source.coffee":
-  "Describe block":
-    prefix: "de"
-    body: """
-      describe "${1:description}", ->
-        ${2:body}
-    """
-  "It block":
-    prefix: "i"
-    body: """
-      it "$1", ->
-        $2
-    """
-  "Before each":
-    prefix: "be"
-    body: """
-      beforeEach ->
-        $1
-    """
-  "After each":
-    prefix: "af"
-    body: """
-      afterEach ->
-        $1
-    """
-  "Expectation":
-    prefix: "ex"
-    body: "expect($1).to$2"
-  "Console log":
-    prefix: "log"
-    body: "console.log $1"
-  "Range array":
-    prefix: "ra"
-    body: "[[$1, $2], [$3, $4]]"
-  "Point array":
-    prefix: "pt"
-    body: "[$1, $2]"
-
-  "Key-value pair":
-    prefix: ":"
-    body: '${1:"${2:key}"}: ${3:value}'
-  "Create Jasmine spy":
-    prefix: "spy"
-    body: 'jasmine.createSpy("${1:description}")$2'

dot-atom/styles.css

@@ -0,0 +1,18 @@
+/*
+ * Your Stylesheet
+ *
+ * This stylesheet is loaded when Atom starts up and is reloaded automatically
+ * when it is changed.
+ */
+
+.tree-view {
+
+}
+
+.editor {
+
+}
+
+.editor .cursor {
+
+}

dot-atom/user.coffee

@@ -1 +0,0 @@
-# For more on how to configure atom open `~/github/atom/docs/configuring-and-extending.md`

dot-atom/user.css

@@ -1,8 +0,0 @@
-/* User styles */
-.tree-view {
-
-}
-
-.editor {
-
-}

exports/atom.coffee

@@ -4,8 +4,6 @@ module.exports =
   _: require 'underscore-plus'
   BufferedNodeProcess: require '../src/buffered-node-process'
   BufferedProcess: require '../src/buffered-process'
-  Directory: require '../src/directory'
-  File: require '../src/file'
   fs: require 'fs-plus'
   Git: require '../src/git'
   Point: Point
@@ -20,8 +18,8 @@ unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
   module.exports.$$ = $$
   module.exports.$$$ = $$$
   module.exports.EditorView = require '../src/editor-view'
-  module.exports.WorkspaceView = require '../src/workspace-view'
-  module.exports.SelectList = require '../src/select-list'
   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'

keymaps/base.cson

@@ -24,9 +24,6 @@
   'ctrl-shift-up': 'editor:add-selection-above'
   'ctrl-shift-down': 'editor:add-selection-below'
 
-'.tool-panel':
-  'escape': 'core:close'
-
 '.tool-panel.panel-left, .tool-panel.panel-right':
   'escape': 'tool-panel:unfocus'
 

keymaps/darwin.cson

@@ -1,4 +1,4 @@
-'.platform-darwin':
+'body':
   # Apple specific
   'cmd-q': 'application:quit'
   'cmd-h': 'application:hide'
@@ -68,6 +68,8 @@
   'cmd-=': 'window:increase-font-size'
   'cmd-+': 'window:increase-font-size'
   'cmd--': 'window:decrease-font-size'
+  'cmd-_': 'window:decrease-font-size'
+  'cmd-0': 'window:reset-font-size'
 
   'cmd-k up': 'pane:split-up' # Atom Specific
   'cmd-k down': 'pane:split-down' # Atom Specific
@@ -75,8 +77,12 @@
   'cmd-k right': 'pane:split-right' # Atom Specific
   'cmd-k cmd-w': 'pane:close' # Atom Specific
   'cmd-k alt-cmd-w': 'pane:close-other-items' # Atom Specific
-  'cmd-k cmd-left': 'window:focus-previous-pane'
-  'cmd-k cmd-right': 'window:focus-next-pane'
+  'cmd-k cmd-p': 'window:focus-previous-pane'
+  'cmd-k cmd-n': 'window:focus-next-pane'
+  'cmd-k cmd-up': 'window:focus-pane-above'
+  'cmd-k cmd-down': 'window:focus-pane-below'
+  'cmd-k cmd-left': 'window:focus-pane-on-left'
+  'cmd-k cmd-right': 'window:focus-pane-on-right'
   'cmd-1': 'pane:show-item-1'
   'cmd-2': 'pane:show-item-2'
   'cmd-3': 'pane:show-item-3'
@@ -87,7 +93,7 @@
   'cmd-8': 'pane:show-item-8'
   'cmd-9': 'pane:show-item-9'
 
-'.platform-darwin .editor':
+'.editor':
   # Apple Specific
   'cmd-backspace': 'editor:backspace-to-beginning-of-line'
   'cmd-delete': 'editor:backspace-to-beginning-of-line'
@@ -113,12 +119,11 @@
   'cmd-k cmd-l': 'editor:lower-case'
   'cmd-l': 'editor:select-line'
 
-'body.platform-darwin .editor:not(.mini)':
+'.workspace .editor:not(.mini)':
   # Atom specific
   'alt-cmd-z': 'editor:checkout-head-revision'
   'cmd-<': 'editor:scroll-to-cursor'
   'alt-cmd-ctrl-f': 'editor:fold-selection'
-  'cmd-=': 'editor:auto-indent'
 
   # Sublime Parity
   'cmd-enter': 'editor:newline-below'
@@ -148,7 +153,7 @@
   'cmd-k cmd-9': 'editor:fold-at-indent-level-9'
 
 # allow standard input fields to work correctly
-'body.platform-darwin .native-key-bindings':
+'body .native-key-bindings':
   'cmd-z': 'native!'
   'cmd-Z': 'native!'
   'cmd-x': 'native!'

keymaps/win32.cson

@@ -1,4 +1,4 @@
-'.platform-win32':
+'body':
   # Atom Specific
   'enter': 'core:confirm'
   'escape': 'core:cancel'
@@ -40,6 +40,8 @@
   'ctrl-=': 'window:increase-font-size'
   'ctrl-+': 'window:increase-font-size'
   'ctrl--': 'window:decrease-font-size'
+  'ctrl-_': 'window:decrease-font-size'
+  'ctrl-0': 'window:reset-font-size'
 
   'ctrl-k up': 'pane:split-up' # Atom Specific
   'ctrl-k down': 'pane:split-down' # Atom Specific
@@ -47,10 +49,14 @@
   'ctrl-k right': 'pane:split-right' # Atom Specific
   'ctrl-k ctrl-w': 'pane:close' # Atom Specific
   'ctrl-k alt-ctrl-w': 'pane:close-other-items' # Atom Specific
-  'ctrl-k ctrl-left': 'window:focus-previous-pane'
-  'ctrl-k ctrl-right': 'window:focus-next-pane'
+  'ctrl-k ctrl-p': 'window:focus-previous-pane'
+  'ctrl-k ctrl-n': 'window:focus-next-pane'
+  'ctrl-k ctrl-up':    'window:focus-pane-above'
+  'ctrl-k ctrl-down':  'window:focus-pane-below'
+  'ctrl-k ctrl-left':  'window:focus-pane-on-left'
+  'ctrl-k ctrl-right': 'window:focus-pane-on-right'
 
-'.platform-win32 .editor':
+'.workspace .editor':
   # Windows specific
   'ctrl-delete': 'editor:backspace-to-beginning-of-word'
 
@@ -60,12 +66,11 @@
   'ctrl-k ctrl-u': 'editor:upper-case'
   'ctrl-k ctrl-l': 'editor:lower-case'
 
-'.platform-win32 .editor:not(.mini)':
+'.workspace .editor:not(.mini)':
   # Atom specific
   'alt-ctrl-z': 'editor:checkout-head-revision'
   'ctrl-<': 'editor:scroll-to-cursor'
   'alt-ctrl-f': 'editor:fold-selection'
-  'ctrl-=': 'editor:auto-indent'
 
   # Sublime Parity
   'ctrl-enter': 'editor:newline-below'
@@ -94,7 +99,7 @@
   'ctrl-k ctrl-9': 'editor:fold-at-indent-level-9'
 
 # allow standard input fields to work correctly
-'.platform-win32 input:not(.hidden-input), .platform-win32 .native-key-bindings':
+'body .native-key-bindings':
   'ctrl-z': 'native!'
   'ctrl-Z': 'native!'
   'ctrl-x': 'native!'

menus/darwin.cson

@@ -4,9 +4,17 @@
     submenu: [
       { label: 'About Atom', command: 'application:about' }
       { label: "VERSION", enabled: false }
-      { label: "Install update", command: 'application:install-update', visible: false }
+      { label: "Restart and Install Update", command: 'application:install-update', visible: false}
+      { label: "Check for Update", command: 'application:check-for-update', visible: false}
       { 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' }
+      { label: 'Install Shell Commands', command: 'window:install-shell-commands' }
       { type: 'separator' }
       { label: 'Hide Atom', command: 'application:hide' }
       { label: 'Hide Others', command: 'application:hide-other-applications' }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "atom",
   "productName": "Atom",
-  "version": "0.45.0",
+  "version": "0.51.0",
   "main": "./src/browser/main.js",
   "repository": {
     "type": "git",
@@ -16,126 +16,126 @@
       "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
     }
   ],
-  "atomShellVersion": "0.7.6",
+  "atomShellVersion": "0.9.2",
   "dependencies": {
     "async": "0.2.6",
-    "bootstrap": "git://github.com/benogle/bootstrap.git",
+    "bootstrap": "git://github.com/atom/bootstrap.git#6af81906189f1747fd6c93479e3d998ebe041372",
     "clear-cut": "0.2.0",
-    "coffee-script": "1.6.3",
-    "coffeestack": "0.6.0",
-    "emissary": "0.31.0",
-    "first-mate": "0.17.0",
-    "fs-plus": "0.14.0",
+    "coffee-script": "1.7.0",
+    "coffeestack": "0.7.0",
+    "delegato": "1.x",
+    "emissary": "1.x",
+    "first-mate": ">=1.1.5 <2.0",
+    "fs-plus": "2.x",
     "fstream": "0.1.24",
-    "fuzzaldrin": "0.6.0",
-    "git-utils": "0.29.0",
+    "fuzzaldrin": "1.x",
+    "git-utils": "1.x",
     "guid": "0.0.10",
-    "jasmine-focused": "~0.15.0",
-    "jasmine-node": "git://github.com/kevinsawicki/jasmine-node.git#short-stacks",
-    "jasmine-tagged": "0.2.0",
+    "jasmine-tagged": "1.x",
     "mkdirp": "0.3.5",
-    "keytar": "0.13.0",
-    "less-cache": "0.10.0",
-    "serializable": "0.3.0",
-    "nslog": "0.1.0",
-    "oniguruma": "0.24.0",
+    "keytar": "0.15.1",
+    "less-cache": "0.12.0",
+    "mixto": "1.x",
+    "nslog": "0.5.0",
+    "oniguruma": "1.x",
     "optimist": "0.4.0",
-    "pathwatcher": "0.11.0",
+    "pathwatcher": "0.16.0",
     "pegjs": "0.8.0",
-    "q": "0.9.7",
-    "scandal": "0.11.0",
-    "season": "0.14.0",
+    "property-accessors": "1.x",
+    "q": "1.0.x",
+    "random-words": "0.0.1",
+    "runas": "0.5.x",
+    "scandal": "0.14.0",
+    "season": "1.x",
     "semver": "1.1.4",
-    "space-pen": "3.1.0",
+    "serializable": "1.x",
+    "space-pen": "3.1.1",
     "temp": "0.5.0",
-    "text-buffer": "0.12.0",
-    "underscore-plus": "0.6.1",
-    "theorist": "~0.13.0",
-    "delegato": "~0.4.0",
-    "mixto": "~0.4.0"
+    "text-buffer": ">=1.1.2 <2.0",
+    "theorist": "1.x",
+    "underscore-plus": "1.x",
+    "vm-compatibility-layer": "0.1.0"
   },
   "packageDependencies": {
-    "atom-dark-syntax": "0.10.0",
-    "atom-dark-ui": "0.19.0",
-    "atom-light-syntax": "0.10.0",
-    "atom-light-ui": "0.18.0",
-    "base16-tomorrow-dark-theme": "0.8.0",
-    "solarized-dark-syntax": "0.6.0",
-    "solarized-light-syntax": "0.2.0",
-    "archive-view": "0.19.0",
-    "autocomplete": "0.19.0",
-    "autoflow": "0.11.0",
-    "autosave": "0.10.0",
-    "background-tips": "0.4.0",
-    "bookmarks": "0.15.0",
-    "bracket-matcher": "0.16.0",
-    "command-logger": "0.8.0",
-    "command-palette": "0.14.0",
-    "dev-live-reload": "0.22.0",
-    "editor-stats": "0.12.0",
-    "exception-reporting": "0.11.0",
-    "feedback": "0.22.0",
-    "find-and-replace": "0.74.0",
-    "fuzzy-finder": "0.30.0",
-    "gists": "0.13.0",
-    "git-diff": "0.21.0",
-    "github-sign-in": "0.15.0",
-    "go-to-line": "0.14.0",
-    "grammar-selector": "0.16.0",
-    "image-view": "0.15.0",
-    "keybinding-resolver": "0.8.0",
-    "markdown-preview": "0.24.0",
-    "metrics": "0.21.0",
-    "package-generator": "0.23.0",
-    "release-notes": "0.15.0",
-    "settings-view": "0.55.0",
-    "snippets": "0.18.0",
-    "spell-check": "0.18.0",
-    "status-bar": "0.31.0",
-    "styleguide": "0.19.0",
-    "symbols-view": "0.27.0",
-    "tabs": "0.17.0",
-    "terminal": "0.23.0",
+    "atom-dark-syntax": "0.13.0",
+    "atom-dark-ui": "0.22.0",
+    "atom-light-syntax": "0.13.0",
+    "atom-light-ui": "0.21.0",
+    "base16-tomorrow-dark-theme": "0.11.0",
+    "solarized-dark-syntax": "0.9.0",
+    "solarized-light-syntax": "0.5.0",
+    "archive-view": "0.23.0",
+    "autocomplete": "0.23.0",
+    "autoflow": "0.14.0",
+    "autosave": "0.11.0",
+    "background-tips": "0.7.0",
+    "bookmarks": "0.20.0",
+    "bracket-matcher": "0.20.0",
+    "command-palette": "0.17.0",
+    "dev-live-reload": "0.26.0",
+    "exception-reporting": "0.13.0",
+    "feedback": "0.24.0",
+    "find-and-replace": "0.83.0",
+    "fuzzy-finder": "0.35.0",
+    "gists": "0.17.0",
+    "git-diff": "0.24.0",
+    "github-sign-in": "0.19.0",
+    "go-to-line": "0.16.0",
+    "grammar-selector": "0.20.0",
+    "image-view": "0.24.0",
+    "keybinding-resolver": "0.10.0",
+    "link": "0.17.0",
+    "markdown-preview": "0.32.0",
+    "metrics": "0.26.0",
+    "open-on-github": "0.20.0",
+    "package-generator": "0.26.0",
+    "release-notes": "0.20.0",
+    "settings-view": "0.76.0",
+    "snippets": "0.30.0",
+    "spell-check": "0.25.0",
+    "status-bar": "0.32.0",
+    "styleguide": "0.24.0",
+    "symbols-view": "0.36.0",
+    "tabs": "0.19.0",
     "timecop": "0.13.0",
-    "to-the-hubs": "0.17.0",
-    "tree-view": "0.59.0",
-    "visual-bell": "0.6.0",
+    "tree-view": "0.69.0",
+    "update-package-dependencies": "0.3.0",
     "welcome": "0.4.0",
-    "whitespace": "0.10.0",
-    "wrap-guide": "0.11.0",
-    "language-c": "0.2.0",
-    "language-clojure": "0.1.0",
-    "language-coffee-script": "0.4.0",
-    "language-css": "0.2.0",
-    "language-gfm": "0.11.0",
-    "language-git": "0.3.0",
-    "language-go": "0.2.0",
-    "language-html": "0.2.0",
-    "language-hyperlink": "0.3.0",
-    "language-java": "0.2.0",
-    "language-javascript": "0.4.0",
-    "language-json": "0.2.0",
-    "language-less": "0.1.0",
-    "language-make": "0.1.0",
-    "language-mustache": "0.1.0",
-    "language-objective-c": "0.2.0",
-    "language-pegjs": "0.1.0",
-    "language-perl": "0.2.0",
-    "language-php": "0.2.0",
-    "language-property-list": "0.2.0",
-    "language-puppet": "0.2.0",
-    "language-python": "0.2.0",
-    "language-ruby": "0.6.0",
-    "language-ruby-on-rails": "0.3.0",
-    "language-sass": "0.3.0",
-    "language-shellscript": "0.2.0",
-    "language-source": "0.2.0",
-    "language-sql": "0.2.0",
-    "language-text": "0.2.0",
-    "language-todo": "0.2.0",
-    "language-toml": "0.7.0",
-    "language-xml": "0.2.0",
-    "language-yaml": "0.1.0"
+    "whitespace": "0.14.0",
+    "wrap-guide": "0.14.0",
+    "language-c": "0.8.0",
+    "language-clojure": "0.2.0",
+    "language-coffee-script": "0.9.0",
+    "language-css": "0.7.0",
+    "language-gfm": "0.17.0",
+    "language-git": "0.6.0",
+    "language-go": "0.4.0",
+    "language-html": "0.5.0",
+    "language-hyperlink": "0.5.0",
+    "language-java": "0.5.0",
+    "language-javascript": "0.8.0",
+    "language-json": "0.5.0",
+    "language-less": "0.4.0",
+    "language-make": "0.4.0",
+    "language-mustache": "0.3.0",
+    "language-objective-c": "0.5.0",
+    "language-pegjs": "0.3.0",
+    "language-perl": "0.5.0",
+    "language-php": "0.6.0",
+    "language-property-list": "0.5.0",
+    "language-puppet": "0.5.0",
+    "language-python": "0.5.0",
+    "language-ruby": "0.11.0",
+    "language-ruby-on-rails": "0.6.0",
+    "language-sass": "0.6.0",
+    "language-shellscript": "0.5.0",
+    "language-source": "0.5.0",
+    "language-sql": "0.5.0",
+    "language-text": "0.4.0",
+    "language-todo": "0.4.0",
+    "language-toml": "0.9.0",
+    "language-xml": "0.5.0",
+    "language-yaml": "0.4.0"
   },
   "private": true,
   "scripts": {

script/bootstrap

@@ -31,6 +31,7 @@ if (!fs.existsSync(path.join(apmInstallPath, 'node_modules')))
   fs.mkdirSync(path.join(apmInstallPath, 'node_modules'));
 
 var apmFlags = process.env.JANKY_SHA1 || process.argv.indexOf('--no-color') !== -1 ? '--no-color' : '';
+var packagesToDedupe = ['fs-plus', 'humanize-plus', 'oniguruma', 'roaster', 'season'];
 var echoNewLine = process.platform == 'win32' ? 'echo.' : 'echo';
 var commands = [
   'git submodule --quiet sync',
@@ -43,6 +44,7 @@ var commands = [
   echoNewLine,
   'node apm/node_modules/atom-package-manager/bin/apm clean ' + apmFlags,
   'node apm/node_modules/atom-package-manager/bin/apm install --quiet ' + apmFlags,
+  'node apm/node_modules/atom-package-manager/bin/apm dedupe --quiet ' + apmFlags + ' ' + packagesToDedupe.join(' '),
 ];
 
 process.chdir(path.dirname(__dirname));

script/copy-folder.cmd

@@ -0,0 +1,18 @@
+@echo off
+
+set USAGE=Usage: %0 source destination
+
+if [%1] == [] (
+  echo %USAGE%
+  exit 1
+)
+if [%2] == [] (
+  echo %USAGE%
+  exit 2
+)
+
+:: rm -rf %2
+if exist %2 rmdir %2 /s /q
+
+:: cp -rf %1 %2
+xcopy %1 %2 /e /h /c /i /y /r

script/create-shortcut.cmd

@@ -0,0 +1,23 @@
+@echo off
+
+set USAGE=Usage: %0 source name-on-desktop
+
+if [%1] == [] (
+  echo %USAGE%
+  exit 1
+)
+if [%2] == [] (
+  echo %USAGE%
+  exit 2
+)
+
+set SCRIPT="%TEMP%\%RANDOM%-%RANDOM%-%RANDOM%-%RANDOM%.vbs"
+
+echo Set oWS = WScript.CreateObject("WScript.Shell") >> %SCRIPT%
+echo sLinkFile = "%USERPROFILE%\Desktop\%2.lnk" >> %SCRIPT%
+echo Set oLink = oWS.CreateShortcut(sLinkFile) >> %SCRIPT%
+echo oLink.TargetPath = %1 >> %SCRIPT%
+echo oLink.Save >> %SCRIPT%
+
+cscript /nologo %SCRIPT%
+del %SCRIPT%

script/grunt

@@ -2,8 +2,8 @@
 var cp = require('./utils/child-process-wrapper.js');
 var path = require('path');
 
-// node build/node_modules/grunt-cli/bin/grunt "$@"
-var gruntPath = path.resolve(__dirname, '..', 'build', 'node_modules', 'grunt-cli', 'bin', 'grunt') + (process.platform === 'win32' ? '.cmd' : '');
-var args = [gruntPath, '--gruntfile', path.resolve('build', 'Gruntfile.coffee')];
+// node build/node_modules/.bin/grunt "$@"
+var gruntPath = path.resolve(__dirname, '..', 'build', 'node_modules', '.bin', 'grunt') + (process.platform === 'win32' ? '.cmd' : '');
+var args = ['--gruntfile', path.resolve('build', 'Gruntfile.coffee')];
 args = args.concat(process.argv.slice(2));
-cp.safeSpawn(process.execPath, args, process.exit);
+cp.safeSpawn(gruntPath, args, process.exit);

script/install-cli

@@ -3,9 +3,8 @@
 path = require 'path'
 CommandInstaller = require '../src/command-installer'
 
-callback = (error, sourcePath, destinationPath) ->
-  unless error?
-    console.log "#{sourcePath} intalled to #{destinationPath}"
+callback = (error) ->
+  console.warn error.message if error?
 
 CommandInstaller.installAtomCommand(path.resolve(__dirname, '..'), callback)
 CommandInstaller.installApmCommand(path.resolve(__dirname, '..'), callback)

script/utils/update-octicons

@@ -1,32 +0,0 @@
-#!/usr/bin/env coffee
-
-usage = """
-Usage:
-  update-octicons PATH-TO-OCTICONS
-"""
-
-path = require 'path'
-fs = require 'fs'
-YAML = require 'js-yaml'
-
-scriptPath = process.argv[1]
-pathToOcticons = process.argv[2] ? path.join(process.env.HOME, 'github', 'octicons')
-atomDir = path.resolve(scriptPath, "../../..")
-
-unless fs.existsSync(pathToOcticons)
-  console.error(usage)
-  process.exit(1)
-
-# Copy font-file
-fontSrc = path.join(pathToOcticons, 'octicons', 'octicons.woff')
-fontDest = path.join(atomDir, 'static', 'octicons.woff')
-fs.createReadStream(fontSrc).pipe(fs.createWriteStream(fontDest))
-
-# Update Octicon UTF codes
-glyphsSrc = path.join(pathToOcticons, 'data', 'glyphs.yml')
-octiconUtfDest = path.join atomDir, 'static', 'octicon-utf-codes.less'
-output = []
-for {css, code} in YAML.load(fs.readFileSync(glyphsSrc).toString())
-  output.push "@#{css}: \"\\#{code}\";"
-
-fs.writeFileSync octiconUtfDest, "#{output.join('\n')}\n"

spec/atom-reporter.coffee

@@ -1,35 +1,52 @@
-{View, $, $$} = require '../src/space-pen-extensions'
+path = require 'path'
 _ = require 'underscore-plus'
 {convertStackTrace} = require 'coffeestack'
+{View, $, $$} = require '../src/space-pen-extensions'
 
 sourceMaps = {}
-formatStackTrace = (stackTrace) ->
+formatStackTrace = (spec, message='', stackTrace) ->
   return stackTrace unless stackTrace
 
-  jasminePath = require.resolve('../vendor/jasmine')
-  jasminePattern = new RegExp("\\(#{_.escapeRegExp(jasminePath)}:\\d+:\\d+\\)\\s*$")
+  jasminePattern = /^\s*at\s+.*\(?.*\/jasmine(-[^\/]*)?\.js:\d+:\d+\)?\s*$/
+  firstJasmineLinePattern = /^\s*at \/.*\/jasmine(-[^\/]*)?\.js:\d+:\d+\)?\s*$/
   convertedLines = []
   for line in stackTrace.split('\n')
     convertedLines.push(line) unless jasminePattern.test(line)
+    break if firstJasmineLinePattern.test(line)
 
-  convertStackTrace(convertedLines.join('\n'), sourceMaps)
+  stackTrace = convertStackTrace(convertedLines.join('\n'), sourceMaps)
+  lines = stackTrace.split('\n')
+
+  # Remove first line of stack when it is the same as the error message
+  errorMatch = lines[0]?.match(/^Error: (.*)/)
+  lines.shift() if message.trim() is errorMatch?[1]?.trim()
+
+  for line, index in lines
+    # Remove prefix of lines matching: at [object Object].<anonymous> (path:1:2)
+    prefixMatch = line.match(/at \[object Object\]\.<anonymous> \(([^\)]+)\)/)
+    line = "at #{prefixMatch[1]}" if prefixMatch
+
+    # Relativize locations to spec directory
+    lines[index] = line.replace("at #{spec.specDirectory}#{path.sep}", 'at ')
+
+  lines = lines.map (line) -> line.trim()
+  lines.join('\n').trim()
 
 module.exports =
 class AtomReporter extends View
   @content: ->
-    @div id: 'HTMLReporter', class: 'jasmine_reporter', =>
-      @div outlet: 'specPopup', class: "spec-popup"
+    @div class: 'spec-reporter', =>
       @div outlet: "suites"
-      @div outlet: 'coreArea', =>
-        @div outlet: 'coreHeader', class: 'symbolHeader'
-        @ul outlet: 'coreSummary', class: 'symbolSummary list-unstyled'
-      @div outlet: 'bundledArea', =>
-        @div outlet: 'bundledHeader', class: 'symbolHeader'
-        @ul outlet: 'bundledSummary', class: 'symbolSummary list-unstyled'
-      @div outlet: 'userArea', =>
-        @div outlet: 'userHeader', class: 'symbolHeader'
-        @ul outlet: 'userSummary', class: 'symbolSummary list-unstyled'
-      @div outlet: "status", class: 'status', =>
+      @div outlet: 'coreArea', class: 'symbol-area', =>
+        @div outlet: 'coreHeader', class: 'symbol-header'
+        @ul outlet: 'coreSummary', class: 'symbol-summary list-unstyled'
+      @div outlet: 'bundledArea', class: 'symbol-area', =>
+        @div outlet: 'bundledHeader', class: 'symbol-header'
+        @ul outlet: 'bundledSummary', class: 'symbol-summary list-unstyled'
+      @div outlet: 'userArea', class: 'symbol-area', =>
+        @div outlet: 'userHeader', class: 'symbol-header'
+        @ul outlet: 'userSummary', class: 'symbol-summary list-unstyled'
+      @div outlet: "status", class: 'status alert alert-info', =>
         @div outlet: "time", class: 'time'
         @div outlet: "specCount", class: 'spec-count'
         @div outlet: "message", class: 'message'
@@ -46,7 +63,7 @@ class AtomReporter extends View
 
   reportRunnerStarting: (runner) ->
     @handleEvents()
-    @startedAt = new Date()
+    @startedAt = Date.now()
     specs = runner.specs()
     @totalSpecCount = specs.length
     @addSpecs(specs)
@@ -54,57 +71,29 @@ class AtomReporter extends View
 
   reportRunnerResults: (runner) ->
     @updateSpecCounts()
-    if @failedCount == 0
-      @message.text "Success!"
+    @status.addClass('alert-success').removeClass('alert-info') if @failedCount is 0
+    if @failedCount is 1
+      @message.text "#{@failedCount} failure"
     else
-      @message.text "Game Over"
+      @message.text "#{@failedCount} failures"
 
   reportSuiteResults: (suite) ->
 
   reportSpecResults: (spec) ->
     @completeSpecCount++
-    spec.endedAt = new Date().getTime()
+    spec.endedAt = Date.now()
     @specComplete(spec)
     @updateStatusView(spec)
 
   reportSpecStarting: (spec) ->
     @specStarted(spec)
 
-  specFilter: (spec) ->
-    globalFocusPriority = jasmine.getEnv().focusPriority
-    parent = spec.parentSuite ? spec.suite
-
-    if !globalFocusPriority
-      true
-    else if spec.focusPriority >= globalFocusPriority
-      true
-    else if not parent
-      false
-    else
-      @specFilter(parent)
-
   handleEvents: ->
-    $(document).on "mouseover", ".spec-summary", ({currentTarget}) =>
-      element = $(currentTarget)
-      description = element.data("description")
-      return unless description
-
-      clearTimeout @timeoutId if @timeoutId?
-      @specPopup.show()
-      spec = _.find(window.timedSpecs, ({fullName}) -> description is fullName)
-      description = "#{description} #{spec.time}ms" if spec
-      @specPopup.text description
-      {left, top} = element.offset()
-      left += 20
-      top += 20
-      @specPopup.offset({left, top})
-      @timeoutId = setTimeout((=> @specPopup.hide()), 3000)
-
     $(document).on "click", ".spec-toggle", ({currentTarget}) =>
       element = $(currentTarget)
       specFailures = element.parent().find('.spec-failures')
       specFailures.toggle()
-      if specFailures.is(":visible") then element.text "\uf03d" else element.html "\uf03f"
+      element.toggleClass('folded')
       false
 
   updateSpecCounts: ->
@@ -116,7 +105,7 @@ class AtomReporter extends View
 
   updateStatusView: (spec) ->
     if @failedCount > 0
-      @status.addClass('failed') unless @status.hasClass('failed')
+      @status.addClass('alert-danger').removeClass('alert-info')
 
     @updateSpecCounts()
 
@@ -124,7 +113,7 @@ class AtomReporter extends View
     rootSuite = rootSuite.parentSuite while rootSuite.parentSuite
     @message.text rootSuite.description
 
-    time = "#{Math.round((spec.endedAt - @startedAt.getTime()) / 10)}"
+    time = "#{Math.round((spec.endedAt - @startedAt) / 10)}"
     time = "0#{time}" if time.length < 3
     @time[0].textContent = "#{time[0...-2]}.#{time[-2..]}s"
 
@@ -146,15 +135,22 @@ class AtomReporter extends View
           @userSummary.append symbol
 
     if coreSpecs > 0
-      @coreHeader.text("Core Specs (#{coreSpecs}):")
+      @coreHeader.text("Core Specs (#{coreSpecs})")
     else
       @coreArea.hide()
     if bundledPackageSpecs > 0
-      @bundledHeader.text("Bundled Package Specs (#{bundledPackageSpecs}):")
+      @bundledHeader.text("Bundled Package Specs (#{bundledPackageSpecs})")
     else
       @bundledArea.hide()
     if userPackageSpecs > 0
-      @userHeader.text("User Package Specs (#{userPackageSpecs}):")
+      if coreSpecs is 0 and bundledPackageSpecs is 0
+        # Package specs being run, show a more descriptive label
+        {specDirectory} = specs[0]
+        packageFolderName = path.basename(path.dirname(specDirectory))
+        packageName = _.undasherize(_.uncamelcase(packageFolderName))
+        @userHeader.text("#{packageName} Specs")
+      else
+        @userHeader.text("User Package Specs (#{userPackageSpecs})")
     else
       @userArea.hide()
 
@@ -164,7 +160,7 @@ class AtomReporter extends View
   specComplete: (spec) ->
     specSummaryElement = $("#spec-summary-#{spec.id}")
     specSummaryElement.removeClass('pending')
-    specSummaryElement.data("description", spec.getFullName())
+    specSummaryElement.setTooltip(title: spec.getFullName(), container: '.spec-reporter')
 
     results = spec.results()
     if results.skipped
@@ -185,11 +181,9 @@ class SuiteResultView extends View
     @div class: 'suite', =>
       @div outlet: 'description', class: 'description'
 
-  suite: null
-
   initialize: (@suite) ->
     @attr('id', "suite-view-#{@suite.id}")
-    @description.html @suite.description
+    @description.text(@suite.description)
 
   attach: ->
     (@parentSuiteView() or $('.results')).append this
@@ -206,20 +200,22 @@ class SuiteResultView extends View
 class SpecResultView extends View
   @content: ->
     @div class: 'spec', =>
-      @div "\uf03d", class: 'spec-toggle'
+      @div class: 'spec-toggle'
       @div outlet: 'description', class: 'description'
       @div outlet: 'specFailures', class: 'spec-failures'
-  spec: null
 
   initialize: (@spec) ->
     @addClass("spec-view-#{@spec.id}")
-    @description.html @spec.description
+
+    description = @spec.description
+    description = "it #{description}" if description.indexOf('it ') isnt 0
+    @description.text(description)
 
     for result in @spec.results().getItems() when not result.passed()
-      stackTrace = formatStackTrace(result.trace.stack)
+      stackTrace = formatStackTrace(@spec, result.message, result.trace.stack)
       @specFailures.append $$ ->
-        @div result.message, class: 'resultMessage fail'
-        @div stackTrace, class: 'stackTrace' if stackTrace
+        @div result.message, class: 'result-message fail'
+        @pre stackTrace, class: 'stack-trace padded' if stackTrace
 
   attach: ->
     @parentSuiteView().append this

spec/atom-spec.coffee

@@ -1,6 +1,7 @@
 {$, $$, fs, WorkspaceView}  = require 'atom'
 Exec = require('child_process').exec
 path = require 'path'
+Package = require '../src/package'
 ThemeManager = require '../src/theme-manager'
 
 describe "the `atom` global", ->
@@ -9,35 +10,28 @@ describe "the `atom` global", ->
 
   describe "package lifecycle methods", ->
     describe ".loadPackage(name)", ->
-      describe "when the package has deferred deserializers", ->
-        it "requires the package's main module if one of its deferred deserializers is referenced", ->
-          pack = atom.packages.loadPackage('package-with-activation-events')
-          spyOn(pack, 'activateStylesheets').andCallThrough()
-          expect(pack.mainModule).toBeNull()
-          object = atom.deserializers.deserialize({deserializer: 'Foo', data: 5})
-          expect(pack.mainModule).toBeDefined()
-          expect(object.constructor.name).toBe 'Foo'
-          expect(object.data).toBe 5
-          expect(pack.activateStylesheets).toHaveBeenCalled()
+      it "continues if the package has an invalid package.json", ->
+        spyOn(console, 'warn')
+        atom.config.set("core.disabledPackages", [])
+        expect(-> atom.packages.loadPackage("package-with-broken-package-json")).not.toThrow()
 
-        it "continues if the package has an invalid package.json", ->
-          spyOn(console, 'warn')
-          atom.config.set("core.disabledPackages", [])
-          expect(-> atom.packages.loadPackage("package-with-broken-package-json")).not.toThrow()
-
-        it "continues if the package has an invalid keymap", ->
-          atom.config.set("core.disabledPackages", [])
-          expect(-> atom.packages.loadPackage("package-with-broken-keymap")).not.toThrow()
+      it "continues if the package has an invalid keymap", ->
+        atom.config.set("core.disabledPackages", [])
+        expect(-> atom.packages.loadPackage("package-with-broken-keymap")).not.toThrow()
 
     describe ".unloadPackage(name)", ->
       describe "when the package is active", ->
         it "throws an error", ->
-          pack = atom.packages.activatePackage('package-with-main')
-          expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
-          expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
-          expect( -> atom.packages.unloadPackage(pack.name)).toThrow()
-          expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
-          expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
+          pack = null
+          waitsForPromise ->
+            atom.packages.activatePackage('package-with-main').then (p) -> pack = p
+
+          runs ->
+            expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
+            expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
+            expect( -> atom.packages.unloadPackage(pack.name)).toThrow()
+            expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
+            expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
 
       describe "when the package is not loaded", ->
         it "throws an error", ->
@@ -54,44 +48,69 @@ describe "the `atom` global", ->
 
     describe ".activatePackage(id)", ->
       describe "atom packages", ->
+        describe "when called multiple times", ->
+          it "it only calls activate on the package once", ->
+            spyOn(Package.prototype, 'activateNow').andCallThrough()
+            atom.packages.activatePackage('package-with-index')
+            atom.packages.activatePackage('package-with-index')
+
+            waitsForPromise ->
+              atom.packages.activatePackage('package-with-index')
+
+            runs ->
+              expect(Package.prototype.activateNow.callCount).toBe 1
+
         describe "when the package has a main module", ->
           describe "when the metadata specifies a main module path˜", ->
             it "requires the module at the specified path", ->
               mainModule = require('./fixtures/packages/package-with-main/main-module')
               spyOn(mainModule, 'activate')
-              pack = atom.packages.activatePackage('package-with-main')
-              expect(mainModule.activate).toHaveBeenCalled()
-              expect(pack.mainModule).toBe mainModule
+              pack = null
+              waitsForPromise ->
+                atom.packages.activatePackage('package-with-main').then (p) -> pack = p
+
+              runs ->
+                expect(mainModule.activate).toHaveBeenCalled()
+                expect(pack.mainModule).toBe mainModule
 
           describe "when the metadata does not specify a main module", ->
             it "requires index.coffee", ->
               indexModule = require('./fixtures/packages/package-with-index/index')
               spyOn(indexModule, 'activate')
-              pack = atom.packages.activatePackage('package-with-index')
-              expect(indexModule.activate).toHaveBeenCalled()
-              expect(pack.mainModule).toBe indexModule
+              pack = null
+              waitsForPromise ->
+                atom.packages.activatePackage('package-with-index').then (p) -> pack = p
+
+              runs ->
+                expect(indexModule.activate).toHaveBeenCalled()
+                expect(pack.mainModule).toBe indexModule
 
           it "assigns config defaults from the module", ->
             expect(atom.config.get('package-with-config-defaults.numbers.one')).toBeUndefined()
-            atom.packages.activatePackage('package-with-config-defaults')
-            expect(atom.config.get('package-with-config-defaults.numbers.one')).toBe 1
-            expect(atom.config.get('package-with-config-defaults.numbers.two')).toBe 2
+
+            waitsForPromise ->
+              atom.packages.activatePackage('package-with-config-defaults')
+
+            runs ->
+              expect(atom.config.get('package-with-config-defaults.numbers.one')).toBe 1
+              expect(atom.config.get('package-with-config-defaults.numbers.two')).toBe 2
 
           describe "when the package metadata includes activation events", ->
-            [mainModule, pack] = []
+            [mainModule, promise] = []
 
             beforeEach ->
               mainModule = require './fixtures/packages/package-with-activation-events/index'
               spyOn(mainModule, 'activate').andCallThrough()
-              AtomPackage = require '../src/atom-package'
-              spyOn(AtomPackage.prototype, 'requireMainModule').andCallThrough()
-              pack = atom.packages.activatePackage('package-with-activation-events')
+              spyOn(Package.prototype, 'requireMainModule').andCallThrough()
+
+              promise = atom.packages.activatePackage('package-with-activation-events')
 
             it "defers requiring/activating the main module until an activation event bubbles to the root view", ->
-              expect(pack.requireMainModule).not.toHaveBeenCalled()
-              expect(mainModule.activate).not.toHaveBeenCalled()
+              expect(promise.isFulfilled()).not.toBeTruthy()
               atom.workspaceView.trigger 'activation-event'
-              expect(mainModule.activate).toHaveBeenCalled()
+
+              waitsForPromise ->
+                promise
 
             it "triggers the activation event on all handlers registered during activation", ->
               atom.workspaceView.openSync()
@@ -116,13 +135,17 @@ describe "the `atom` global", ->
             expect(console.warn).not.toHaveBeenCalled()
 
         it "passes the activate method the package's previously serialized state if it exists", ->
-          pack = atom.packages.activatePackage("package-with-serialization")
-          expect(pack.mainModule.someNumber).not.toBe 77
-          pack.mainModule.someNumber = 77
-          atom.packages.deactivatePackage("package-with-serialization")
-          spyOn(pack.mainModule, 'activate').andCallThrough()
-          atom.packages.activatePackage("package-with-serialization")
-          expect(pack.mainModule.activate).toHaveBeenCalledWith({someNumber: 77})
+          pack = null
+          waitsForPromise ->
+            atom.packages.activatePackage("package-with-serialization").then (p) -> pack = p
+
+          runs ->
+            expect(pack.mainModule.someNumber).not.toBe 77
+            pack.mainModule.someNumber = 77
+            atom.packages.deactivatePackage("package-with-serialization")
+            spyOn(pack.mainModule, 'activate').andCallThrough()
+            atom.packages.activatePackage("package-with-serialization")
+            expect(pack.mainModule.activate).toHaveBeenCalledWith({someNumber: 77})
 
         it "logs warning instead of throwing an exception if the package fails to load", ->
           atom.config.set("core.disabledPackages", [])
@@ -239,116 +262,155 @@ describe "the `atom` global", ->
 
         describe "grammar loading", ->
           it "loads the package's grammars", ->
-            atom.packages.activatePackage('package-with-grammars')
-            expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Alot'
-            expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Alittle'
+            waitsForPromise ->
+              atom.packages.activatePackage('package-with-grammars')
+
+            runs ->
+              expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Alot'
+              expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Alittle'
 
         describe "scoped-property loading", ->
           it "loads the scoped properties", ->
-            atom.packages.activatePackage("package-with-scoped-properties")
-            expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
-
-      describe "textmate packages", ->
-        it "loads the package's grammars", ->
-          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-          atom.packages.activatePackage('language-ruby', sync: true)
-          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
-
-        it "translates the package's scoped properties to Atom terms", ->
-          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
-          atom.packages.activatePackage('language-ruby', sync: true)
-          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBe '# '
-
-        describe "when the package has no grammars but does have preferences", ->
-          it "loads the package's preferences as scoped properties", ->
-            jasmine.unspy(window, 'setTimeout')
-            spyOn(atom.syntax, 'addProperties').andCallThrough()
-
-            atom.packages.activatePackage('package-with-preferences-tmbundle')
-
-            waitsFor ->
-              atom.syntax.addProperties.callCount > 0
+            waitsForPromise ->
+              atom.packages.activatePackage("package-with-scoped-properties")
 
             runs ->
-              expect(atom.syntax.getProperty(['.source.pref'], 'editor.increaseIndentPattern')).toBe '^abc$'
+              expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
+
+      describe "converted textmate packages", ->
+        it "loads the package's grammars", ->
+          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+
+          waitsForPromise ->
+            atom.packages.activatePackage('language-ruby')
+
+          runs ->
+            expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
+
+        it "loads the translated scoped properties", ->
+          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
+
+          waitsForPromise ->
+            atom.packages.activatePackage('language-ruby')
+
+          runs ->
+            expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBe '# '
 
     describe ".deactivatePackage(id)", ->
       describe "atom packages", ->
         it "calls `deactivate` on the package's main module if activate was successful", ->
-          pack = atom.packages.activatePackage("package-with-deactivate")
-          expect(atom.packages.isPackageActive("package-with-deactivate")).toBeTruthy()
-          spyOn(pack.mainModule, 'deactivate').andCallThrough()
+          pack = null
+          waitsForPromise ->
+            atom.packages.activatePackage("package-with-deactivate").then (p) -> pack = p
 
-          atom.packages.deactivatePackage("package-with-deactivate")
-          expect(pack.mainModule.deactivate).toHaveBeenCalled()
-          expect(atom.packages.isPackageActive("package-with-module")).toBeFalsy()
+          runs ->
+            expect(atom.packages.isPackageActive("package-with-deactivate")).toBeTruthy()
+            spyOn(pack.mainModule, 'deactivate').andCallThrough()
 
-          spyOn(console, 'warn')
-          badPack = atom.packages.activatePackage("package-that-throws-on-activate")
-          expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeTruthy()
-          spyOn(badPack.mainModule, 'deactivate').andCallThrough()
+            atom.packages.deactivatePackage("package-with-deactivate")
+            expect(pack.mainModule.deactivate).toHaveBeenCalled()
+            expect(atom.packages.isPackageActive("package-with-module")).toBeFalsy()
 
-          atom.packages.deactivatePackage("package-that-throws-on-activate")
-          expect(badPack.mainModule.deactivate).not.toHaveBeenCalled()
-          expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeFalsy()
+            spyOn(console, 'warn')
+
+          badPack = null
+          waitsForPromise ->
+            atom.packages.activatePackage("package-that-throws-on-activate").then (p) -> badPack = p
+
+          runs ->
+            expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeTruthy()
+            spyOn(badPack.mainModule, 'deactivate').andCallThrough()
+
+            atom.packages.deactivatePackage("package-that-throws-on-activate")
+            expect(badPack.mainModule.deactivate).not.toHaveBeenCalled()
+            expect(atom.packages.isPackageActive("package-that-throws-on-activate")).toBeFalsy()
 
         it "does not serialize packages that have not been activated called on their main module", ->
           spyOn(console, 'warn')
-          badPack = atom.packages.activatePackage("package-that-throws-on-activate")
-          spyOn(badPack.mainModule, 'serialize').andCallThrough()
+          badPack = null
+          waitsForPromise ->
+            atom.packages.activatePackage("package-that-throws-on-activate").then (p) -> badPack = p
 
-          atom.packages.deactivatePackage("package-that-throws-on-activate")
-          expect(badPack.mainModule.serialize).not.toHaveBeenCalled()
+          runs ->
+            spyOn(badPack.mainModule, 'serialize').andCallThrough()
+
+            atom.packages.deactivatePackage("package-that-throws-on-activate")
+            expect(badPack.mainModule.serialize).not.toHaveBeenCalled()
 
         it "absorbs exceptions that are thrown by the package module's serialize methods", ->
           spyOn(console, 'error')
-          atom.packages.activatePackage('package-with-serialize-error',  immediate: true)
-          atom.packages.activatePackage('package-with-serialization', immediate: true)
-          atom.packages.deactivatePackages()
-          expect(atom.packages.packageStates['package-with-serialize-error']).toBeUndefined()
-          expect(atom.packages.packageStates['package-with-serialization']).toEqual someNumber: 1
-          expect(console.error).toHaveBeenCalled()
+
+          waitsForPromise ->
+            atom.packages.activatePackage('package-with-serialize-error')
+
+          waitsForPromise ->
+            atom.packages.activatePackage('package-with-serialization')
+
+          runs ->
+            atom.packages.deactivatePackages()
+            expect(atom.packages.packageStates['package-with-serialize-error']).toBeUndefined()
+            expect(atom.packages.packageStates['package-with-serialization']).toEqual someNumber: 1
+            expect(console.error).toHaveBeenCalled()
 
         it "removes the package's grammars", ->
-          atom.packages.activatePackage('package-with-grammars')
-          atom.packages.deactivatePackage('package-with-grammars')
-          expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Null Grammar'
-          expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Null Grammar'
+          waitsForPromise ->
+            atom.packages.activatePackage('package-with-grammars')
+
+          runs ->
+            atom.packages.deactivatePackage('package-with-grammars')
+            expect(atom.syntax.selectGrammar('a.alot').name).toBe 'Null Grammar'
+            expect(atom.syntax.selectGrammar('a.alittle').name).toBe 'Null Grammar'
 
         it "removes the package's keymaps", ->
-          atom.packages.activatePackage('package-with-keymaps')
-          atom.packages.deactivatePackage('package-with-keymaps')
-          expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', $$ -> @div class: 'test-1')).toHaveLength 0
-          expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', $$ -> @div class: 'test-2')).toHaveLength 0
+          waitsForPromise ->
+            atom.packages.activatePackage('package-with-keymaps')
+
+          runs ->
+            atom.packages.deactivatePackage('package-with-keymaps')
+            expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', $$ -> @div class: 'test-1')).toHaveLength 0
+            expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', $$ -> @div class: 'test-2')).toHaveLength 0
 
         it "removes the package's stylesheets", ->
-          atom.packages.activatePackage('package-with-stylesheets')
-          atom.packages.deactivatePackage('package-with-stylesheets')
-          one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css")
-          two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less")
-          three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css")
-          expect(atom.themes.stylesheetElementForId(one)).not.toExist()
-          expect(atom.themes.stylesheetElementForId(two)).not.toExist()
-          expect(atom.themes.stylesheetElementForId(three)).not.toExist()
+          waitsForPromise ->
+            atom.packages.activatePackage('package-with-stylesheets')
+
+          runs ->
+            atom.packages.deactivatePackage('package-with-stylesheets')
+            one = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css")
+            two = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less")
+            three = require.resolve("./fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css")
+            expect(atom.themes.stylesheetElementForId(one)).not.toExist()
+            expect(atom.themes.stylesheetElementForId(two)).not.toExist()
+            expect(atom.themes.stylesheetElementForId(three)).not.toExist()
 
         it "removes the package's scoped-properties", ->
-          atom.packages.activatePackage("package-with-scoped-properties")
-          expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
-          atom.packages.deactivatePackage("package-with-scoped-properties")
-          expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBeUndefined()
+          waitsForPromise ->
+            atom.packages.activatePackage("package-with-scoped-properties")
+
+          runs ->
+            expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
+            atom.packages.deactivatePackage("package-with-scoped-properties")
+            expect(atom.syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBeUndefined()
 
       describe "textmate packages", ->
         it "removes the package's grammars", ->
           expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-          atom.packages.activatePackage('language-ruby', sync: true)
-          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
-          atom.packages.deactivatePackage('language-ruby')
-          expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
+
+          waitsForPromise ->
+            atom.packages.activatePackage('language-ruby')
+
+          runs ->
+            expect(atom.syntax.selectGrammar("file.rb").name).toBe "Ruby"
+            atom.packages.deactivatePackage('language-ruby')
+            expect(atom.syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
 
         it "removes the package's scoped properties", ->
-          atom.packages.activatePackage('language-ruby', sync: true)
-          atom.packages.deactivatePackage('language-ruby')
-          expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
+          waitsForPromise ->
+            atom.packages.activatePackage('language-ruby')
+
+          runs ->
+            atom.packages.deactivatePackage('language-ruby')
+            expect(atom.syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
 
     describe ".activate()", ->
       packageActivator = null
@@ -382,7 +444,7 @@ describe "the `atom` global", ->
         themes = themeActivator.mostRecentCall.args[0]
         expect(['theme']).toContain(theme.getType()) for theme in themes
 
-    describe ".en/disablePackage()", ->
+    describe ".enablePackage() and disablePackage()", ->
       describe "with packages", ->
         it ".enablePackage() enables a disabled package", ->
           packageName = 'package-with-main'
@@ -391,28 +453,36 @@ describe "the `atom` global", ->
           expect(atom.config.get('core.disabledPackages')).toContain packageName
 
           pack = atom.packages.enablePackage(packageName)
-
           loadedPackages = atom.packages.getLoadedPackages()
-          activatedPackages = atom.packages.getActivePackages()
-          expect(loadedPackages).toContain(pack)
-          expect(activatedPackages).toContain(pack)
-          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
+          activatedPackages = null
+          waitsFor ->
+            activatedPackages = atom.packages.getActivePackages()
+            activatedPackages.length > 0
+
+          runs ->
+            expect(loadedPackages).toContain(pack)
+            expect(activatedPackages).toContain(pack)
+            expect(atom.config.get('core.disabledPackages')).not.toContain packageName
 
         it ".disablePackage() disables an enabled package", ->
           packageName = 'package-with-main'
-          atom.packages.activatePackage(packageName)
-          atom.packages.observeDisabledPackages()
-          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
+          waitsForPromise ->
+            atom.packages.activatePackage(packageName)
 
-          pack = atom.packages.disablePackage(packageName)
+          runs ->
+            atom.packages.observeDisabledPackages()
+            expect(atom.config.get('core.disabledPackages')).not.toContain packageName
 
-          activatedPackages = atom.packages.getActivePackages()
-          expect(activatedPackages).not.toContain(pack)
-          expect(atom.config.get('core.disabledPackages')).toContain packageName
+            pack = atom.packages.disablePackage(packageName)
+
+            activatedPackages = atom.packages.getActivePackages()
+            expect(activatedPackages).not.toContain(pack)
+            expect(atom.config.get('core.disabledPackages')).toContain packageName
 
       describe "with themes", ->
         beforeEach ->
-          atom.themes.activateThemes()
+          waitsForPromise ->
+            atom.themes.activateThemes()
 
         afterEach ->
           atom.themes.deactivateThemes()
@@ -426,18 +496,24 @@ describe "the `atom` global", ->
 
           # enabling of theme
           pack = atom.packages.enablePackage(packageName)
-          activatedPackages = atom.packages.getActivePackages()
-          expect(activatedPackages).toContain(pack)
-          expect(atom.config.get('core.themes')).toContain packageName
-          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
 
-          # disabling of theme
-          pack = atom.packages.disablePackage(packageName)
-          activatedPackages = atom.packages.getActivePackages()
-          expect(activatedPackages).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
+          activatedPackages = null
+          waitsFor ->
+            activatedPackages = atom.packages.getActivePackages()
+            activatedPackages.length > 0
+
+          runs ->
+            expect(activatedPackages).toContain(pack)
+            expect(atom.config.get('core.themes')).toContain packageName
+            expect(atom.config.get('core.disabledPackages')).not.toContain packageName
+
+            # disabling of theme
+            pack = atom.packages.disablePackage(packageName)
+            activatedPackages = atom.packages.getActivePackages()
+            expect(activatedPackages).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
 
   describe ".isReleasedVersion()", ->
     it "returns false if the version is a SHA and true otherwise", ->

spec/clipboard-spec.coffee

@@ -0,0 +1,12 @@
+describe "Clipboard", ->
+  describe "write(text, metadata) and read()", ->
+    it "writes and reads text to/from the native clipboard", ->
+      expect(atom.clipboard.read()).toBe 'initial clipboard content'
+      atom.clipboard.write('next')
+      expect(atom.clipboard.read()).toBe 'next'
+
+    it "returns metadata if the item on the native clipboard matches the last written item", ->
+      atom.clipboard.write('next', {meta: 'data'})
+      expect(atom.clipboard.read()).toBe 'next'
+      expect(atom.clipboard.readWithMetadata().text).toBe 'next'
+      expect(atom.clipboard.readWithMetadata().metadata).toEqual {meta: 'data'}

spec/command-installer-spec.coffee

@@ -4,33 +4,31 @@ temp = require 'temp'
 installer = require '../src/command-installer'
 
 describe "install(commandPath, callback)", ->
-  directory = path.join(temp.dir, 'install-atom-command', 'atom')
-  commandPath = path.join(directory, 'source')
-  destinationPath = path.join(directory, 'bin', 'source')
+  commandFilePath = temp.openSync("atom-command").path
+  commandName = path.basename(commandFilePath)
+  installationPath = temp.mkdirSync("atom-bin")
+  installationFilePath = path.join(installationPath, commandName)
 
   beforeEach ->
-    spyOn(installer, 'findInstallDirectory').andCallFake (callback) ->
-      callback(directory)
-
-    fs.removeSync(directory) if fs.existsSync(directory)
+    fs.chmodSync(commandFilePath, '755')
+    spyOn(installer, 'getInstallDirectory').andReturn installationPath
 
   describe "on #darwin", ->
     it "symlinks the command and makes it executable", ->
-      fs.writeFileSync(commandPath, 'test')
-      expect(fs.isFileSync(commandPath)).toBeTruthy()
-      expect(fs.isExecutableSync(commandPath)).toBeFalsy()
-      expect(fs.isFileSync(destinationPath)).toBeFalsy()
+      expect(fs.isFileSync(commandFilePath)).toBeTruthy()
+      expect(fs.isFileSync(installationFilePath)).toBeFalsy()
 
       installDone = false
       installError = null
-      installer.install commandPath, (error) ->
+      installer.install commandFilePath, false, (error) ->
         installDone = true
         installError = error
 
-      waitsFor -> installDone
+      waitsFor ->
+        installDone
 
       runs ->
         expect(installError).toBeNull()
-        expect(fs.isFileSync(destinationPath)).toBeTruthy()
-        expect(fs.realpathSync(destinationPath)).toBe fs.realpathSync(commandPath)
-        expect(fs.isExecutableSync(destinationPath)).toBeTruthy()
+        expect(fs.isFileSync(installationFilePath)).toBeTruthy()
+        expect(fs.realpathSync(installationFilePath)).toBe fs.realpathSync(commandFilePath)
+        expect(fs.isExecutableSync(installationFilePath)).toBeTruthy()

spec/config-spec.coffee

@@ -63,6 +63,19 @@ describe "Config", ->
       atom.config.toggle('foo.a')
       expect(atom.config.get('foo.a')).toBe false
 
+  describe ".restoreDefault(keyPath)", ->
+    it "sets the value of the key path to its default", ->
+      atom.config.setDefaults('a', b: 3)
+      atom.config.set('a.b', 4)
+      expect(atom.config.get('a.b')).toBe 4
+      atom.config.restoreDefault('a.b')
+      expect(atom.config.get('a.b')).toBe 3
+
+      atom.config.set('a.c', 5)
+      expect(atom.config.get('a.c')).toBe 5
+      atom.config.restoreDefault('a.c')
+      expect(atom.config.get('a.c')).toBeUndefined()
+
   describe ".pushAtKeyPath(keyPath, value)", ->
     it "pushes the given value to the array at the key path and updates observers", ->
       atom.config.set("foo.bar.baz", ["a"])
@@ -218,8 +231,10 @@ describe "Config", ->
         runs ->
           expect(fs.existsSync(atom.config.configDirPath)).toBeTruthy()
           expect(fs.existsSync(path.join(atom.config.configDirPath, 'packages'))).toBeTruthy()
-          expect(fs.existsSync(path.join(atom.config.configDirPath, 'snippets'))).toBeTruthy()
+          expect(fs.isFileSync(path.join(atom.config.configDirPath, 'snippets.cson'))).toBeTruthy()
           expect(fs.isFileSync(path.join(atom.config.configDirPath, 'config.cson'))).toBeTruthy()
+          expect(fs.isFileSync(path.join(atom.config.configDirPath, 'init.coffee'))).toBeTruthy()
+          expect(fs.isFileSync(path.join(atom.config.configDirPath, 'styles.css'))).toBeTruthy()
 
   describe ".loadUserConfig()", ->
     beforeEach ->

spec/directory-spec.coffee

@@ -1,138 +0,0 @@
-Directory = require '../src/directory'
-{fs} = require 'atom'
-path = require 'path'
-
-describe "Directory", ->
-  directory = null
-
-  beforeEach ->
-    directory = new Directory(path.join(__dirname, 'fixtures'))
-
-  afterEach ->
-    directory.off()
-
-  describe "when the contents of the directory change on disk", ->
-    temporaryFilePath = null
-
-    beforeEach ->
-      temporaryFilePath = path.join(__dirname, 'fixtures', 'temporary')
-      fs.removeSync(temporaryFilePath) if fs.existsSync(temporaryFilePath)
-
-    afterEach ->
-      fs.removeSync(temporaryFilePath) if fs.existsSync(temporaryFilePath)
-
-    it "triggers 'contents-changed' event handlers", ->
-      changeHandler = null
-
-      runs ->
-        changeHandler = jasmine.createSpy('changeHandler')
-        directory.on 'contents-changed', changeHandler
-        fs.writeFileSync(temporaryFilePath, '')
-
-      waitsFor "first change", -> changeHandler.callCount > 0
-
-      runs ->
-        changeHandler.reset()
-        fs.removeSync(temporaryFilePath)
-
-      waitsFor "second change", -> changeHandler.callCount > 0
-
-  describe "when the directory unsubscribes from events", ->
-    temporaryFilePath = null
-
-    beforeEach ->
-      temporaryFilePath = path.join(directory.path, 'temporary')
-      fs.removeSync(temporaryFilePath) if fs.existsSync(temporaryFilePath)
-
-    afterEach ->
-      fs.removeSync(temporaryFilePath) if fs.existsSync(temporaryFilePath)
-
-    it "no longer triggers events", ->
-      changeHandler = null
-
-      runs ->
-        changeHandler = jasmine.createSpy('changeHandler')
-        directory.on 'contents-changed', changeHandler
-        fs.writeFileSync(temporaryFilePath, '')
-
-      waitsFor "change event", -> changeHandler.callCount > 0
-
-      runs ->
-        changeHandler.reset()
-        directory.off()
-      waits 20
-
-      runs -> fs.removeSync(temporaryFilePath)
-      waits 20
-      runs -> expect(changeHandler.callCount).toBe 0
-
-  describe "on #darwin or #linux", ->
-    it "includes symlink information about entries", ->
-      entries = directory.getEntriesSync()
-      for entry in entries
-        name = entry.getBaseName()
-        if name is 'symlink-to-dir' or name is 'symlink-to-file'
-          expect(entry.symlink).toBeTruthy()
-        else
-          expect(entry.symlink).toBeFalsy()
-
-      callback = jasmine.createSpy('getEntries')
-      directory.getEntries(callback)
-
-      waitsFor -> callback.callCount is 1
-
-      runs ->
-        entries = callback.mostRecentCall.args[1]
-        for entry in entries
-          name = entry.getBaseName()
-          if name is 'symlink-to-dir' or name is 'symlink-to-file'
-            expect(entry.symlink).toBeTruthy()
-          else
-            expect(entry.symlink).toBeFalsy()
-
-  describe ".relativize(path)", ->
-    describe "on #darwin or #linux", ->
-      it "returns a relative path based on the directory's path", ->
-        absolutePath = directory.getPath()
-        expect(directory.relativize(absolutePath)).toBe ''
-        expect(directory.relativize(path.join(absolutePath, "b"))).toBe "b"
-        expect(directory.relativize(path.join(absolutePath, "b/file.coffee"))).toBe "b/file.coffee"
-        expect(directory.relativize(path.join(absolutePath, "file.coffee"))).toBe "file.coffee"
-
-      it "returns a relative path based on the directory's symlinked source path", ->
-        symlinkPath = path.join(__dirname, 'fixtures', 'symlink-to-dir')
-        symlinkDirectory = new Directory(symlinkPath)
-        realFilePath = require.resolve('./fixtures/dir/a')
-        expect(symlinkDirectory.relativize(symlinkPath)).toBe ''
-        expect(symlinkDirectory.relativize(realFilePath)).toBe 'a'
-
-      it "returns the full path if the directory's path is not a prefix of the path", ->
-        expect(directory.relativize('/not/relative')).toBe '/not/relative'
-
-    describe "on #win32", ->
-      it "returns a relative path based on the directory's path", ->
-        absolutePath = directory.getPath()
-        expect(directory.relativize(absolutePath)).toBe ''
-        expect(directory.relativize(path.join(absolutePath, "b"))).toBe "b"
-        expect(directory.relativize(path.join(absolutePath, "b/file.coffee"))).toBe "b\\file.coffee"
-        expect(directory.relativize(path.join(absolutePath, "file.coffee"))).toBe "file.coffee"
-
-      it "returns the full path if the directory's path is not a prefix of the path", ->
-        expect(directory.relativize('/not/relative')).toBe "\\not\\relative"
-
-  describe ".contains(path)", ->
-    it "returns true if the path is a child of the directory's path", ->
-      absolutePath = directory.getPath()
-      expect(directory.contains(path.join(absolutePath, "b"))).toBe true
-      expect(directory.contains(path.join(absolutePath, "b", "file.coffee"))).toBe true
-      expect(directory.contains(path.join(absolutePath, "file.coffee"))).toBe true
-
-    it "returns false if the directory's path is not a prefix of the path", ->
-      expect(directory.contains('/not/relative')).toBe false
-
-    describe "on #darwin or #linux", ->
-      it "returns true if the path is a child of the directory's symlinked source path", ->
-        symlinkPath = path.join(__dirname, 'fixtures', 'symlink-to-dir')
-        symlinkDirectory = new Directory(symlinkPath)
-        realFilePath = require.resolve('./fixtures/dir/a')
-        expect(symlinkDirectory.contains(realFilePath)).toBe true

spec/display-buffer-spec.coffee

@@ -5,12 +5,15 @@ describe "DisplayBuffer", ->
   [displayBuffer, buffer, changeHandler, tabLength] = []
   beforeEach ->
     tabLength = 2
-    atom.packages.activatePackage('language-javascript', sync: true)
+
     buffer = atom.project.bufferForPathSync('sample.js')
     displayBuffer = new DisplayBuffer({buffer, tabLength})
     changeHandler = jasmine.createSpy 'changeHandler'
     displayBuffer.on 'changed', changeHandler
 
+    waitsForPromise ->
+      atom.packages.activatePackage('language-javascript')
+
   afterEach ->
     displayBuffer.destroy()
     buffer.release()

spec/editor-spec.coffee

@@ -16,11 +16,13 @@ describe "Editor", ->
 
   describe "with default options", ->
     beforeEach ->
-      atom.packages.activatePackage('language-javascript', sync: true)
       editor = atom.project.openSync('sample.js', autoIndent: false)
       buffer = editor.buffer
       lineLengths = buffer.getLines().map (line) -> line.length
 
+      waitsForPromise ->
+        atom.packages.activatePackage('language-javascript')
+
     describe "when the editor is deserialized", ->
       it "restores selections and folds based on markers in the buffer", ->
         editor.setSelectedBufferRange([[1, 2], [3, 4]])
@@ -1856,12 +1858,12 @@ describe "Editor", ->
             expect(editor.getCursorBufferPosition()).toEqual [0, 2]
             expect(editor.getCursorScreenPosition()).toEqual [0, editor.getTabLength() * 2]
 
-      describe "pasteboard operations", ->
+      describe "clipboard operations", ->
         beforeEach ->
           editor.setSelectedBufferRanges([[[0, 4], [0, 13]], [[1, 6], [1, 10]]])
 
         describe ".cutSelectedText()", ->
-          it "removes the selected text from the buffer and places it on the pasteboard", ->
+          it "removes the selected text from the buffer and places it on the clipboard", ->
             editor.cutSelectedText()
             expect(buffer.lineForRow(0)).toBe "var  = function () {"
             expect(buffer.lineForRow(1)).toBe "  var  = function(items) {"
@@ -1885,7 +1887,7 @@ describe "Editor", ->
                 editor.cutToEndOfLine()
                 expect(buffer.lineForRow(2)).toBe '    if (items.length'
                 expect(buffer.lineForRow(3)).toBe '    var pivot = item'
-                expect(atom.pasteboard.read()[0]).toBe ' <= 1) return items;\ns.shift(), current, left = [], right = [];'
+                expect(atom.clipboard.read()).toBe ' <= 1) return items;\ns.shift(), current, left = [], right = [];'
 
             describe "when text is selected", ->
               it "only cuts the selected text, not to the end of the line", ->
@@ -1895,7 +1897,7 @@ describe "Editor", ->
 
                 expect(buffer.lineForRow(2)).toBe '    if (items.lengthurn items;'
                 expect(buffer.lineForRow(3)).toBe '    var pivot = item'
-                expect(atom.pasteboard.read()[0]).toBe ' <= 1) ret\ns.shift(), current, left = [], right = [];'
+                expect(atom.clipboard.read()).toBe ' <= 1) ret\ns.shift(), current, left = [], right = [];'
 
         describe ".copySelectedText()", ->
           it "copies selected text onto the clipboard", ->
@@ -1906,7 +1908,7 @@ describe "Editor", ->
 
         describe ".pasteText()", ->
           it "pastes text into the buffer", ->
-            atom.pasteboard.write('first')
+            atom.clipboard.write('first')
             editor.pasteText()
             expect(editor.buffer.lineForRow(0)).toBe "var first = function () {"
             expect(buffer.lineForRow(1)).toBe "  var first = function(items) {"
@@ -2722,21 +2724,37 @@ describe "Editor", ->
         editor.moveCursorLeft()
         expect(editor.getCursorBufferPosition()).toEqual [0, 0]
 
+    describe ".setIndentationForBufferRow", ->
+      describe "when the editor uses soft tabs but the row has hard tabs", ->
+        it "only replaces whitespace charachters", ->
+          editor.setSoftWrap(true)
+          editor.setText("	1\n	2")
+          editor.setCursorBufferPosition([0, 0])
+          editor.setIndentationForBufferRow(0, 2)
+          expect(editor.getText()).toBe("    1\n	2")
+
   describe "when the editor's grammar has an injection selector", ->
     beforeEach ->
-      atom.packages.activatePackage('language-text', sync: true)
-      atom.packages.activatePackage('language-javascript', sync: true)
+
+      waitsForPromise ->
+        atom.packages.activatePackage('language-text')
+
+      waitsForPromise ->
+        atom.packages.activatePackage('language-javascript')
 
     it "includes the grammar's patterns when the selector matches the current scope in other grammars", ->
-      atom.packages.activatePackage('language-hyperlink', sync: true)
-      grammar = atom.syntax.selectGrammar("text.js")
-      {tokens} = grammar.tokenizeLine("var i; // http://github.com")
+      waitsForPromise ->
+        atom.packages.activatePackage('language-hyperlink')
 
-      expect(tokens[0].value).toBe "var"
-      expect(tokens[0].scopes).toEqual ["source.js", "storage.modifier.js"]
+      runs ->
+        grammar = atom.syntax.selectGrammar("text.js")
+        {tokens} = grammar.tokenizeLine("var i; // http://github.com")
 
-      expect(tokens[6].value).toBe "http://github.com"
-      expect(tokens[6].scopes).toEqual ["source.js", "comment.line.double-slash.js", "markup.underline.link.http.hyperlink"]
+        expect(tokens[0].value).toBe "var"
+        expect(tokens[0].scopes).toEqual ["source.js", "storage.modifier.js"]
+
+        expect(tokens[6].value).toBe "http://github.com"
+        expect(tokens[6].scopes).toEqual ["source.js", "comment.line.double-slash.js", "markup.underline.link.http.hyperlink"]
 
     describe "when the grammar is added", ->
       it "retokenizes existing buffers that contain tokens that match the injection selector", ->
@@ -2747,11 +2765,13 @@ describe "Editor", ->
         expect(tokens[1].value).toBe " http://github.com"
         expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
 
-        atom.packages.activatePackage('language-hyperlink', sync: true)
+        waitsForPromise ->
+          atom.packages.activatePackage('language-hyperlink')
 
-        {tokens} = editor.lineForScreenRow(0)
-        expect(tokens[2].value).toBe "http://github.com"
-        expect(tokens[2].scopes).toEqual ["source.js", "comment.line.double-slash.js", "markup.underline.link.http.hyperlink"]
+        runs ->
+          {tokens} = editor.lineForScreenRow(0)
+          expect(tokens[2].value).toBe "http://github.com"
+          expect(tokens[2].scopes).toEqual ["source.js", "comment.line.double-slash.js", "markup.underline.link.http.hyperlink"]
 
     describe "when the grammar is updated", ->
       it "retokenizes existing buffers that contain tokens that match the injection selector", ->
@@ -2762,14 +2782,18 @@ describe "Editor", ->
         expect(tokens[1].value).toBe " SELECT * FROM OCTOCATS"
         expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
 
-        atom.packages.activatePackage('package-with-injection-selector', sync: true)
+        waitsForPromise ->
+          atom.packages.activatePackage('package-with-injection-selector')
 
-        {tokens} = editor.lineForScreenRow(0)
-        expect(tokens[1].value).toBe " SELECT * FROM OCTOCATS"
-        expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
+        runs ->
+          {tokens} = editor.lineForScreenRow(0)
+          expect(tokens[1].value).toBe " SELECT * FROM OCTOCATS"
+          expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
 
-        atom.packages.activatePackage('language-sql', sync: true)
+        waitsForPromise ->
+          atom.packages.activatePackage('language-sql')
 
-        {tokens} = editor.lineForScreenRow(0)
-        expect(tokens[2].value).toBe "SELECT"
-        expect(tokens[2].scopes).toEqual ["source.js", "comment.line.double-slash.js", "keyword.other.DML.sql"]
+        runs ->
+          {tokens} = editor.lineForScreenRow(0)
+          expect(tokens[2].value).toBe "SELECT"
+          expect(tokens[2].scopes).toEqual ["source.js", "comment.line.double-slash.js", "keyword.other.DML.sql"]

spec/file-spec.coffee

@@ -1,132 +0,0 @@
-{File, fs} = require 'atom'
-path = require 'path'
-
-describe 'File', ->
-  [filePath, file] = []
-
-  beforeEach ->
-    filePath = path.join(__dirname, 'fixtures', 'atom-file-test.txt') # Don't put in /tmp because /tmp symlinks to /private/tmp and screws up the rename test
-    fs.removeSync(filePath) if fs.existsSync(filePath)
-    fs.writeFileSync(filePath, "this is old!")
-    file = new File(filePath)
-
-  afterEach ->
-    file.off()
-    fs.removeSync(filePath) if fs.existsSync(filePath)
-
-  describe "when the file has not been read", ->
-    describe "when the contents of the file change", ->
-      it "triggers 'contents-changed' event handlers", ->
-        file.on 'contents-changed', changeHandler = jasmine.createSpy('changeHandler')
-        fs.writeFileSync(file.getPath(), "this is new!")
-
-        waitsFor "change event", ->
-          changeHandler.callCount > 0
-
-  describe "when the file has already been read", ->
-    beforeEach ->
-      file.readSync()
-
-    describe "when the contents of the file change", ->
-      it "triggers 'contents-changed' event handlers", ->
-        changeHandler = null
-        changeHandler = jasmine.createSpy('changeHandler')
-        file.on 'contents-changed', changeHandler
-        fs.writeFileSync(file.getPath(), "this is new!")
-
-        waitsFor "change event", ->
-          changeHandler.callCount > 0
-
-        runs ->
-          changeHandler.reset()
-          fs.writeFileSync(file.getPath(), "this is newer!")
-
-        waitsFor "second change event", ->
-          changeHandler.callCount > 0
-
-    describe "when the file is removed", ->
-      it "triggers 'remove' event handlers", ->
-        removeHandler = null
-        removeHandler = jasmine.createSpy('removeHandler')
-        file.on 'removed', removeHandler
-        fs.removeSync(file.getPath())
-
-        waitsFor "remove event", ->
-          removeHandler.callCount > 0
-
-    describe "when a file is moved (via the filesystem)", ->
-      newPath = null
-
-      beforeEach ->
-        newPath = path.join(path.dirname(filePath), "atom-file-was-moved-test.txt")
-
-      afterEach ->
-        if fs.existsSync(newPath)
-          fs.removeSync(newPath)
-          waitsFor "remove event", (done) -> file.on 'removed', done
-
-      it "it updates its path", ->
-        jasmine.unspy(window, "setTimeout")
-        moveHandler = null
-        moveHandler = jasmine.createSpy('moveHandler')
-        file.on 'moved', moveHandler
-
-        fs.moveSync(filePath, newPath)
-
-        waitsFor "move event", ->
-          moveHandler.callCount > 0
-
-        runs ->
-          expect(file.getPath()).toBe newPath
-
-      it "maintains 'contents-changed' events set on previous path", ->
-        jasmine.unspy(window, "setTimeout")
-        moveHandler = null
-        moveHandler = jasmine.createSpy('moveHandler')
-        file.on 'moved', moveHandler
-        changeHandler = null
-        changeHandler = jasmine.createSpy('changeHandler')
-        file.on 'contents-changed', changeHandler
-
-        fs.moveSync(filePath, newPath)
-
-        waitsFor "move event", ->
-          moveHandler.callCount > 0
-
-        runs ->
-          expect(changeHandler).not.toHaveBeenCalled()
-          fs.writeFileSync(file.getPath(), "this is new!")
-
-        waitsFor "change event", ->
-          changeHandler.callCount > 0
-
-    describe "when a file is deleted and the recreated within a small amount of time (git sometimes does this)", ->
-      it "triggers a contents change event if the contents change", ->
-        jasmine.unspy(File.prototype, 'detectResurrectionAfterDelay')
-        jasmine.unspy(window, "setTimeout")
-
-        changeHandler = jasmine.createSpy("file changed")
-        removeHandler = jasmine.createSpy("file removed")
-        file.on 'contents-changed', changeHandler
-        file.on 'removed', removeHandler
-
-        expect(changeHandler).not.toHaveBeenCalled()
-
-        fs.removeSync(filePath)
-
-        expect(changeHandler).not.toHaveBeenCalled()
-        waits 20
-        runs ->
-          fs.writeFileSync(filePath, "HE HAS RISEN!")
-          expect(changeHandler).not.toHaveBeenCalled()
-
-        waitsFor "resurrection change event", ->
-          changeHandler.callCount == 1
-
-        runs ->
-          expect(removeHandler).not.toHaveBeenCalled()
-          fs.writeFileSync(filePath, "Hallelujah!")
-          changeHandler.reset()
-
-        waitsFor "post-resurrection change event", ->
-          changeHandler.callCount > 0

spec/fixtures/packages/package-with-activation-events/package.cson

@@ -1,2 +1 @@
 'activationEvents': ['activation-event']
-'deferredDeserializers': ['Foo']

spec/fixtures/packages/package-with-broken-snippets.tmbundle/Snippets/.hidden-file

@@ -1 +0,0 @@
-I am hidden so I shouldn't be loaded

spec/fixtures/packages/package-with-broken-snippets.tmbundle/Snippets/invalid.plist

@@ -1 +0,0 @@
-I am not a valid plist but that shouldn't cause a crisis

spec/fixtures/packages/package-with-preferences-tmbundle/preferences/misc.json

@@ -1,7 +0,0 @@
-{
-  "name": "my preferences",
-  "scope": "source.pref",
-  "settings": {
-    "increaseIndentPattern": "^abc$"
-  }
-}

spec/fixtures/packages/package-with-serialize-error/package.cson

@@ -1,5 +1 @@
-# This package loads async, otherwise it would log errors when it
-# is automatically serialized when workspaceView is deactivatated
-
 'main': 'index.coffee'
-'activationEvents': ['activation-event']

spec/fixtures/packages/theme-with-index-css/package.json

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

spec/fixtures/packages/theme-with-index-less/package.json

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

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

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

spec/fixtures/packages/theme-with-package-file/package.json

@@ -1,4 +1,4 @@
 {
-  "theme": true,
+  "theme": "ui",
   "stylesheets": ["first.css", "second.less", "last.css"]
 }

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

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

spec/fixtures/sample-with-comments.js

@@ -15,6 +15,6 @@ var quicksort = function () {
     }
     return sort(left).concat(pivot).concat(sort(right));
   };
-
+  // this is a single-line comment
   return sort(Array.apply(this, arguments));
 };

spec/git-spec.coffee

@@ -187,6 +187,7 @@ describe "Git", ->
       newPath = atom.project.resolve('git/working-dir/untracked.txt')
       cleanPath = atom.project.resolve('git/working-dir/other.txt')
       fs.writeFileSync(newPath, '')
+      newPath = fs.absolute newPath  # specs could be running under symbol path.
 
     afterEach ->
       fs.writeFileSync(modifiedPath, originalModifiedPathText)

spec/jasmine-helper.coffee

@@ -4,8 +4,7 @@ module.exports.runSpecSuite = (specSuite, logFile, logErrors=true) ->
   {$, $$} = require 'atom'
   window[key] = value for key, value of require '../vendor/jasmine'
 
-  require 'jasmine-focused'
-  require 'jasmine-tagged'
+  {TerminalReporter} = require 'jasmine-tagged'
 
   TimeReporter = require './time-reporter'
   timeReporter = new TimeReporter()
@@ -18,15 +17,10 @@ module.exports.runSpecSuite = (specSuite, logFile, logErrors=true) ->
       process.stderr.write(str)
 
   if atom.getLoadSettings().exitWhenDone
-    {jasmineNode} = require 'jasmine-node/lib/jasmine-node/reporter'
-    reporter = new jasmineNode.TerminalReporter
+    reporter = new TerminalReporter
       print: (str) ->
         log(str)
       onComplete: (runner) ->
-        log('\n')
-        timeReporter.logLongestSuites 10, (line) -> log("#{line}\n")
-        log('\n')
-        timeReporter.logLongestSpecs 10, (line) -> log("#{line}\n")
         fs.closeSync(logStream) if logStream?
         atom.exit(runner.results().failedCount > 0 ? 1 : 0)
   else

spec/keymap-spec.coffee

@@ -354,6 +354,27 @@ describe "Keymap", ->
       bindings = keymap.keyBindingsForCommandMatchingElement('cultivate', el)
       expect(bindings).toHaveLength 0
 
+  describe "loading platform specific keybindings", ->
+    customKeymap = null
+
+    beforeEach ->
+      resourcePath = temp.mkdirSync('atom')
+      customKeymap = new Keymap({configDirPath, resourcePath})
+
+    afterEach ->
+      customKeymap.destroy()
+
+    it "doesn't load keybindings from other platforms", ->
+      win32FilePath = path.join(resourcePath, "keymaps", "win32.cson")
+      darwinFilePath = path.join(resourcePath, "keymaps", "darwin.cson")
+      fs.writeFileSync(win32FilePath, '"body": "ctrl-l": "core:win32-move-left"')
+      fs.writeFileSync(darwinFilePath, '"body": "ctrl-l": "core:darwin-move-left"')
+
+      customKeymap.loadBundledKeymaps()
+      keyBindings = customKeymap.keyBindingsForKeystroke('ctrl-l')
+      expect(keyBindings).toHaveLength 1
+      expect(keyBindings[0].command).toBe "core:#{process.platform}-move-left"
+
   describe "when the user keymap file is changed", ->
     it "is reloaded", ->
       keymapFilePath = path.join(configDirPath, "keymap.cson")
@@ -369,3 +390,25 @@ describe "Keymap", ->
       runs ->
         keyBinding = keymap.keyBindingsForKeystroke('ctrl-l')[0]
         expect(keyBinding.command).toBe 'core:move-right'
+        keymap.loadUserKeymap.reset()
+        fs.removeSync(keymapFilePath)
+
+      waitsFor ->
+        keymap.loadUserKeymap.callCount > 0
+
+      runs ->
+        keyBinding = keymap.keyBindingsForKeystroke('ctrl-l')[0]
+        expect(keyBinding).toBeUndefined()
+
+  describe "when adding a binding with an invalid selector", ->
+    it "logs a warning and does not add it", ->
+      spyOn(console, 'warn')
+      keybinding =
+        '##selector':
+          'cmd-a': 'invalid-command'
+      keymap.add('test', keybinding)
+
+      expect(console.warn.callCount).toBe 1
+      expect(console.warn.argsForCall[0][0].length).toBeGreaterThan 0
+      expect(-> keymap.keyBindingsMatchingElement(document.body)).not.toThrow()
+      expect(keymap.keyBindingsForCommand('invalid:command')).toEqual []

spec/language-mode-spec.coffee

@@ -6,10 +6,12 @@ describe "LanguageMode", ->
 
   describe "javascript", ->
     beforeEach ->
-      atom.packages.activatePackage('language-javascript', sync: true)
       editor = atom.project.openSync('sample.js', autoIndent: false)
       {buffer, languageMode} = editor
 
+      waitsForPromise ->
+        atom.packages.activatePackage('language-javascript')
+
     describe ".minIndentLevelForRowRange(startRow, endRow)", ->
       it "returns the minimum indent level for the given row range", ->
         expect(languageMode.minIndentLevelForRowRange(4, 7)).toBe 2
@@ -44,20 +46,12 @@ describe "LanguageMode", ->
         languageMode.toggleLineCommentsForBufferRows(0, 0)
         expect(buffer.lineForRow(0)).toBe " // var i;"
 
-    describe "fold suggestion", ->
-      describe ".doesBufferRowStartFold(bufferRow)", ->
-        it "returns true only when the buffer row starts a foldable region", ->
-          expect(languageMode.doesBufferRowStartFold(0)).toBeTruthy()
-          expect(languageMode.doesBufferRowStartFold(1)).toBeTruthy()
-          expect(languageMode.doesBufferRowStartFold(2)).toBeFalsy()
-          expect(languageMode.doesBufferRowStartFold(3)).toBeFalsy()
-
-      describe ".rowRangeForCodeFoldAtBufferRow(bufferRow)", ->
-        it "returns the start/end rows of the foldable region starting at the given row", ->
-          expect(languageMode.rowRangeForCodeFoldAtBufferRow(0)).toEqual [0, 12]
-          expect(languageMode.rowRangeForCodeFoldAtBufferRow(1)).toEqual [1, 9]
-          expect(languageMode.rowRangeForCodeFoldAtBufferRow(2)).toBeNull()
-          expect(languageMode.rowRangeForCodeFoldAtBufferRow(4)).toEqual [4, 7]
+    describe ".rowRangeForCodeFoldAtBufferRow(bufferRow)", ->
+      it "returns the start/end rows of the foldable region starting at the given row", ->
+        expect(languageMode.rowRangeForCodeFoldAtBufferRow(0)).toEqual [0, 12]
+        expect(languageMode.rowRangeForCodeFoldAtBufferRow(1)).toEqual [1, 9]
+        expect(languageMode.rowRangeForCodeFoldAtBufferRow(2)).toBeNull()
+        expect(languageMode.rowRangeForCodeFoldAtBufferRow(4)).toEqual [4, 7]
 
     describe "suggestedIndentForBufferRow", ->
       it "returns the suggested indentation based on auto-indent/outdent rules", ->
@@ -106,13 +100,14 @@ describe "LanguageMode", ->
           range = languageMode.rowRangeForParagraphAtBufferRow(15)
           expect(range).toEqual [[15,0], [15,26]]
 
-
   describe "coffeescript", ->
     beforeEach ->
-      atom.packages.activatePackage('language-coffee-script', sync: true)
       editor = atom.project.openSync('coffee.coffee', autoIndent: false)
       {buffer, languageMode} = editor
 
+      waitsForPromise ->
+        atom.packages.activatePackage('language-coffee-script')
+
     describe ".toggleLineCommentsForBufferRows(start, end)", ->
       it "comments/uncomments lines in the given range", ->
         languageMode.toggleLineCommentsForBufferRows(4, 6)
@@ -139,13 +134,13 @@ describe "LanguageMode", ->
         expect(buffer.lineForRow(7)).toBe "    # "
 
     describe "fold suggestion", ->
-      describe ".doesBufferRowStartFold(bufferRow)", ->
+      describe ".isFoldableAtBufferRow(bufferRow)", ->
         it "returns true only when the buffer row starts a foldable region", ->
-          expect(languageMode.doesBufferRowStartFold(0)).toBeTruthy()
-          expect(languageMode.doesBufferRowStartFold(1)).toBeTruthy()
-          expect(languageMode.doesBufferRowStartFold(2)).toBeFalsy()
-          expect(languageMode.doesBufferRowStartFold(3)).toBeFalsy()
-          expect(languageMode.doesBufferRowStartFold(19)).toBeTruthy()
+          expect(languageMode.isFoldableAtBufferRow(0)).toBeTruthy()
+          expect(languageMode.isFoldableAtBufferRow(1)).toBeTruthy()
+          expect(languageMode.isFoldableAtBufferRow(2)).toBeFalsy()
+          expect(languageMode.isFoldableAtBufferRow(3)).toBeFalsy()
+          expect(languageMode.isFoldableAtBufferRow(19)).toBeTruthy()
 
       describe ".rowRangeForCodeFoldAtBufferRow(bufferRow)", ->
         it "returns the start/end rows of the foldable region starting at the given row", ->
@@ -156,10 +151,12 @@ describe "LanguageMode", ->
 
   describe "css", ->
     beforeEach ->
-      atom.packages.activatePackage('language-css', sync: true)
       editor = atom.project.openSync('css.css', autoIndent: false)
       {buffer, languageMode} = editor
 
+      waitsForPromise ->
+        atom.packages.activatePackage('language-css')
+
     describe ".toggleLineCommentsForBufferRows(start, end)", ->
       it "comments/uncomments lines in the given range", ->
         languageMode.toggleLineCommentsForBufferRows(0, 1)
@@ -197,11 +194,15 @@ describe "LanguageMode", ->
 
   describe "less", ->
     beforeEach ->
-      atom.packages.activatePackage('language-less', sync: true)
-      atom.packages.activatePackage('language-css', sync: true)
       editor = atom.project.openSync('sample.less', autoIndent: false)
       {buffer, languageMode} = editor
 
+      waitsForPromise ->
+        atom.packages.activatePackage('language-less')
+
+      waitsForPromise ->
+        atom.packages.activatePackage('language-css')
+
     describe "when commenting lines", ->
       it "only uses the `commentEnd` pattern if it comes from the same grammar as the `commentStart`", ->
         languageMode.toggleLineCommentsForBufferRows(0, 0)
@@ -209,10 +210,12 @@ describe "LanguageMode", ->
 
   describe "folding", ->
     beforeEach ->
-      atom.packages.activatePackage('language-javascript', sync: true)
       editor = atom.project.openSync('sample.js', autoIndent: false)
       {buffer, languageMode} = editor
 
+      waitsForPromise ->
+        atom.packages.activatePackage('language-javascript')
+
     it "maintains cursor buffer position when a folding/unfolding", ->
       editor.setCursorBufferPosition([5,5])
       languageMode.foldAll()
@@ -297,12 +300,22 @@ describe "LanguageMode", ->
           languageMode.unfoldBufferRow(1)
           expect(editor.lineForScreenRow(1).fold).toBeUndefined()
 
+    describe ".isFoldableAtBufferRow(bufferRow)", ->
+      it "returns true if the line starts a foldable row range", ->
+        expect(languageMode.isFoldableAtBufferRow(0)).toBe true
+        expect(languageMode.isFoldableAtBufferRow(1)).toBe true
+        expect(languageMode.isFoldableAtBufferRow(2)).toBe false
+        expect(languageMode.isFoldableAtBufferRow(3)).toBe false
+        expect(languageMode.isFoldableAtBufferRow(4)).toBe true
+
   describe "folding with comments", ->
     beforeEach ->
-      atom.packages.activatePackage('language-javascript', sync: true)
       editor = atom.project.openSync('sample-with-comments.js', autoIndent: false)
       {buffer, languageMode} = editor
 
+      waitsForPromise ->
+        atom.packages.activatePackage('language-javascript')
+
     describe ".unfoldAll()", ->
       it "unfolds every folded line", ->
         initialScreenLineCount = editor.getScreenLineCount()
@@ -350,12 +363,25 @@ describe "LanguageMode", ->
         fold2 = editor.lineForScreenRow(5).fold
         expect(fold2).toBeFalsy()
 
+    describe ".isFoldableAtBufferRow(bufferRow)", ->
+      it "returns true if the line starts a multi-line comment", ->
+        expect(languageMode.isFoldableAtBufferRow(1)).toBe true
+        expect(languageMode.isFoldableAtBufferRow(6)).toBe true
+        expect(languageMode.isFoldableAtBufferRow(17)).toBe false
+
+      it "does not return true for a line in the middle of a comment that's followed by an indented line", ->
+        expect(languageMode.isFoldableAtBufferRow(7)).toBe false
+        editor.buffer.insert([8, 0], '  ')
+        expect(languageMode.isFoldableAtBufferRow(7)).toBe false
+
   describe "css", ->
     beforeEach ->
-      atom.packages.activatePackage('language-source', sync: true)
-      atom.packages.activatePackage('language-css', sync: true)
       editor = atom.project.openSync('css.css', autoIndent: true)
 
+      waitsForPromise ->
+        atom.packages.activatePackage('language-source')
+        atom.packages.activatePackage('language-css')
+
     describe "suggestedIndentForBufferRow", ->
       it "does not return negative values (regression)", ->
         editor.setText('.test {\npadding: 0;\n}')

spec/package-spec.coffee

@@ -1,8 +1,8 @@
 {$} = require 'atom'
 path = require 'path'
-Package = require '../src/package'
+ThemePackage = require '../src/theme-package'
 
-describe "AtomPackage", ->
+describe "Package", ->
   describe "theme", ->
     theme = null
 
@@ -16,14 +16,14 @@ describe "AtomPackage", ->
       it "loads and applies css", ->
         expect($(".editor").css("padding-bottom")).not.toBe "1234px"
         themePath = atom.project.resolve('packages/theme-with-index-css')
-        theme = Package.load(themePath)
+        theme = new ThemePackage(themePath)
         theme.activate()
         expect($(".editor").css("padding-top")).toBe "1234px"
 
       it "parses, loads and applies less", ->
         expect($(".editor").css("padding-bottom")).not.toBe "1234px"
         themePath = atom.project.resolve('packages/theme-with-index-less')
-        theme = Package.load(themePath)
+        theme = new ThemePackage(themePath)
         theme.activate()
         expect($(".editor").css("padding-top")).toBe "4321px"
 
@@ -34,7 +34,7 @@ describe "AtomPackage", ->
         expect($(".editor").css("padding-bottom")).not.toBe("103px")
 
         themePath = atom.project.resolve('packages/theme-with-package-file')
-        theme = Package.load(themePath)
+        theme = new ThemePackage(themePath)
         theme.activate()
         expect($(".editor").css("padding-top")).toBe("101px")
         expect($(".editor").css("padding-right")).toBe("102px")
@@ -47,7 +47,7 @@ describe "AtomPackage", ->
         expect($(".editor").css("padding-bottom")).not.toBe "30px"
 
         themePath = atom.project.resolve('packages/theme-without-package-file')
-        theme = Package.load(themePath)
+        theme = new ThemePackage(themePath)
         theme.activate()
         expect($(".editor").css("padding-top")).toBe "10px"
         expect($(".editor").css("padding-right")).toBe "20px"
@@ -56,7 +56,7 @@ describe "AtomPackage", ->
     describe "reloading a theme", ->
       beforeEach ->
         themePath = atom.project.resolve('packages/theme-with-package-file')
-        theme = Package.load(themePath)
+        theme = new ThemePackage(themePath)
         theme.activate()
 
       it "reloads without readding to the stylesheets list", ->
@@ -67,7 +67,7 @@ describe "AtomPackage", ->
     describe "events", ->
       beforeEach ->
         themePath = atom.project.resolve('packages/theme-with-package-file')
-        theme = Package.load(themePath)
+        theme = new ThemePackage(themePath)
         theme.activate()
 
       it "deactivated event fires on .deactivate()", ->

spec/pane-container-spec.coffee

@@ -36,8 +36,8 @@ describe "PaneContainer", ->
     [container, pane1, pane2] = []
 
     beforeEach ->
-      pane1 = new Pane
-      container = new PaneContainer(root: pane1)
+      container = new PaneContainer
+      pane1 = container.root
 
     it "references the first pane if no pane has been made active", ->
       expect(container.activePane).toBe pane1
@@ -60,18 +60,8 @@ describe "PaneContainer", ->
       pane2.destroy()
       expect(container.activePane).toBe pane1
       expect(pane1.active).toBe true
+
+    it "does not allow the root pane to be destroyed", ->
       pane1.destroy()
-      expect(container.activePane).toBe null
-
-  describe "when the last pane is removed", ->
-    [container, pane, surrenderedFocusHandler] = []
-
-    beforeEach ->
-      pane = new Pane
-      container = new PaneContainer(root: pane)
-      container.on 'surrendered-focus', surrenderedFocusHandler = jasmine.createSpy("surrenderedFocusHandler")
-
-    it "assigns null to the root and the activePane", ->
-      pane.destroy()
-      expect(container.root).toBe null
-      expect(container.activePane).toBe null
+      expect(container.root).toBe pane1
+      expect(pane1.isDestroyed()).toBe false

spec/pane-container-view-spec.coffee

@@ -19,40 +19,14 @@ describe "PaneContainerView", ->
       isEqual: (other) -> @name is other?.name
 
     container = new PaneContainerView
-    pane1 = new PaneView(new TestView('1'))
-    container.setRoot(pane1)
+    pane1 = container.getRoot()
+    pane1.activateItem(new TestView('1'))
     pane2 = pane1.splitRight(new TestView('2'))
     pane3 = pane2.splitDown(new TestView('3'))
 
   afterEach ->
     atom.deserializers.remove(TestView)
 
-  describe ".focusNextPane()", ->
-    it "focuses the pane following the focused pane or the first pane if no pane has focus", ->
-      container.attachToDom()
-      container.focusNextPane()
-      expect(pane1.activeItem).toMatchSelector ':focus'
-      container.focusNextPane()
-      expect(pane2.activeItem).toMatchSelector ':focus'
-      container.focusNextPane()
-      expect(pane3.activeItem).toMatchSelector ':focus'
-      container.focusNextPane()
-      expect(pane1.activeItem).toMatchSelector ':focus'
-
-  describe ".focusPreviousPane()", ->
-    it "focuses the pane preceding the focused pane or the last pane if no pane has focus", ->
-      container.attachToDom()
-      $(document.body).focus() # clear focus
-
-      container.focusPreviousPane()
-      expect(pane3.activeItem).toMatchSelector ':focus'
-      container.focusPreviousPane()
-      expect(pane2.activeItem).toMatchSelector ':focus'
-      container.focusPreviousPane()
-      expect(pane1.activeItem).toMatchSelector ':focus'
-      container.focusPreviousPane()
-      expect(pane3.activeItem).toMatchSelector ':focus'
-
   describe ".getActivePane()", ->
     it "returns the most-recently focused pane", ->
       focusStealer = $$ -> @div tabindex: -1, "focus stealer"
@@ -121,7 +95,7 @@ describe "PaneContainerView", ->
 
   describe "serialization", ->
     it "can be serialized and deserialized, and correctly adjusts dimensions of deserialized panes after attach", ->
-      newContainer = atom.deserializers.deserialize(container.serialize())
+      newContainer = new PaneContainerView(container.model.testSerialization())
       expect(newContainer.find('.pane-row > :contains(1)')).toExist()
       expect(newContainer.find('.pane-row > .pane-column > :contains(2)')).toExist()
       expect(newContainer.find('.pane-row > .pane-column > :contains(3)')).toExist()
@@ -130,12 +104,23 @@ describe "PaneContainerView", ->
       expect(newContainer.find('.pane-row > :contains(1)').width()).toBe 150
       expect(newContainer.find('.pane-row > .pane-column > :contains(2)').height()).toBe 100
 
-    it "removes empty panes on deserialization", ->
-      # only deserialize pane 1's view successfully
-      TestView.deserialize = ({name}) -> new TestView(name) if name is '1'
-      newContainer = atom.deserializers.deserialize(container.serialize())
-      expect(newContainer.find('.pane-row, .pane-column')).not.toExist()
-      expect(newContainer.find('> :contains(1)')).toExist()
+    describe "if there are empty panes after deserialization", ->
+      beforeEach ->
+        # only deserialize pane 1's view successfully
+        TestView.deserialize = ({name}) -> new TestView(name) if name is '1'
+
+      describe "if the 'core.destroyEmptyPanes' config option is false (the default)", ->
+        it "leaves the empty panes intact", ->
+          newContainer = new PaneContainerView(container.model.testSerialization())
+          expect(newContainer.find('.pane-row > :contains(1)')).toExist()
+          expect(newContainer.find('.pane-row > .pane-column > .pane').length).toBe 2
+
+      describe "if the 'core.destroyEmptyPanes' config option is true", ->
+        it "removes empty panes on deserialization", ->
+          atom.config.set('core.destroyEmptyPanes', true)
+          newContainer = new PaneContainerView(container.model.testSerialization())
+          expect(newContainer.find('.pane-row, .pane-column')).not.toExist()
+          expect(newContainer.find('> :contains(1)')).toExist()
 
   describe "pane-container:active-pane-item-changed", ->
     [pane1, item1a, item1b, item2a, item2b, item3a, container, activeItemChangedHandler] = []
@@ -147,24 +132,13 @@ describe "PaneContainerView", ->
       item3a = new TestView('3a')
 
       container = new PaneContainerView
+      pane1 = container.getRoot()
+      pane1.activateItem(item1a)
       container.attachToDom()
-      pane1 = new PaneView(item1a)
-      container.setRoot(pane1)
 
       activeItemChangedHandler = jasmine.createSpy("activeItemChangedHandler")
       container.on 'pane-container:active-pane-item-changed', activeItemChangedHandler
 
-    describe "when there are no panes", ->
-      it "is triggered when a new pane containing a pane item is added", ->
-        container.setRoot()
-        expect(container.getPanes().length).toBe 0
-        activeItemChangedHandler.reset()
-
-        pane = new PaneView(item1a)
-        container.setRoot(pane)
-        expect(activeItemChangedHandler.callCount).toBe 1
-        expect(activeItemChangedHandler.argsForCall[0][1]).toEqual item1a
-
     describe "when there is one pane", ->
       it "is triggered when a new pane item is added", ->
         pane1.activateItem(item1b)
@@ -203,11 +177,6 @@ describe "PaneContainerView", ->
         expect(activeItemChangedHandler.callCount).toBe 1
         expect(activeItemChangedHandler.argsForCall[0][1]).toBe undefined
 
-      it "is triggered when the pane is destroyed", ->
-        pane1.remove()
-        expect(activeItemChangedHandler.callCount).toBe 1
-        expect(activeItemChangedHandler.argsForCall[0][1]).toBe undefined
-
     describe "when there are two panes", ->
       [pane2] = []
 
@@ -270,3 +239,115 @@ describe "PaneContainerView", ->
         pane1.remove()
         pane2.remove()
         expect(activeItemChangedHandler).not.toHaveBeenCalled()
+
+  describe ".focusNextPane()", ->
+    it "focuses the pane following the focused pane or the first pane if no pane has focus", ->
+      container.attachToDom()
+      container.focusNextPane()
+      expect(pane1.activeItem).toMatchSelector ':focus'
+      container.focusNextPane()
+      expect(pane2.activeItem).toMatchSelector ':focus'
+      container.focusNextPane()
+      expect(pane3.activeItem).toMatchSelector ':focus'
+      container.focusNextPane()
+      expect(pane1.activeItem).toMatchSelector ':focus'
+
+  describe ".focusPreviousPane()", ->
+    it "focuses the pane preceding the focused pane or the last pane if no pane has focus", ->
+      container.attachToDom()
+      container.getPanes()[0].focus() # activate first pane
+
+      container.focusPreviousPane()
+      expect(pane3.activeItem).toMatchSelector ':focus'
+      container.focusPreviousPane()
+      expect(pane2.activeItem).toMatchSelector ':focus'
+      container.focusPreviousPane()
+      expect(pane1.activeItem).toMatchSelector ':focus'
+      container.focusPreviousPane()
+      expect(pane3.activeItem).toMatchSelector ':focus'
+
+  describe "changing focus directionally between panes", ->
+    [pane1, pane2, pane3, pane4, pane5, pane6, pane7, pane8, pane9] = []
+
+    beforeEach ->
+      # Set up a grid of 9 panes, in the following arrangement, where the
+      # numbers correspond to the variable names below.
+      #
+      # -------
+      # |1|2|3|
+      # -------
+      # |4|5|6|
+      # -------
+      # |7|8|9|
+      # -------
+
+      container = new PaneContainerView
+      pane1 = container.getRoot()
+      pane1.activateItem(new TestView('1'))
+      pane4 = pane1.splitDown(new TestView('4'))
+      pane7 = pane4.splitDown(new TestView('7'))
+
+      pane2 = pane1.splitRight(new TestView('2'))
+      pane3 = pane2.splitRight(new TestView('3'))
+
+      pane5 = pane4.splitRight(new TestView('5'))
+      pane6 = pane5.splitRight(new TestView('6'))
+
+      pane8 = pane7.splitRight(new TestView('8'))
+      pane9 = pane8.splitRight(new TestView('9'))
+
+      container.height(400)
+      container.width(400)
+      container.attachToDom()
+
+    describe ".focusPaneAbove()", ->
+      describe "when there are multiple rows above the focused pane", ->
+        it "focuses up to the adjacent row", ->
+          pane8.focus()
+          container.focusPaneAbove()
+          expect(pane5.activeItem).toMatchSelector ':focus'
+
+      describe "when there are no rows above the focused pane", ->
+        it "keeps the current pane focused", ->
+          pane2.focus()
+          container.focusPaneAbove()
+          expect(pane2.activeItem).toMatchSelector ':focus'
+
+    describe ".focusPaneBelow()", ->
+      describe "when there are multiple rows below the focused pane", ->
+        it "focuses down to the adjacent row", ->
+          pane2.focus()
+          container.focusPaneBelow()
+          expect(pane5.activeItem).toMatchSelector ':focus'
+
+      describe "when there are no rows below the focused pane", ->
+        it "keeps the current pane focused", ->
+          pane8.focus()
+          container.focusPaneBelow()
+          expect(pane8.activeItem).toMatchSelector ':focus'
+
+    describe ".focusPaneOnLeft()", ->
+      describe "when there are multiple columns to the left of the focused pane", ->
+        it "focuses left to the adjacent column", ->
+          pane6.focus()
+          container.focusPaneOnLeft()
+          expect(pane5.activeItem).toMatchSelector ':focus'
+
+      describe "when there are no columns to the left of the focused pane", ->
+        it "keeps the current pane focused", ->
+          pane4.focus()
+          container.focusPaneOnLeft()
+          expect(pane4.activeItem).toMatchSelector ':focus'
+
+    describe ".focusPaneOnRight()", ->
+      describe "when there are multiple columns to the right of the focused pane", ->
+        it "focuses right to the adjacent column", ->
+          pane4.focus()
+          container.focusPaneOnRight()
+          expect(pane5.activeItem).toMatchSelector ':focus'
+
+      describe "when there are no columns to the right of the focused pane", ->
+        it "keeps the current pane focused", ->
+          pane6.focus()
+          container.focusPaneOnRight()
+          expect(pane6.activeItem).toMatchSelector ':focus'

spec/pane-spec.coffee

@@ -4,6 +4,366 @@ PaneAxis = require '../src/pane-axis'
 PaneContainer = require '../src/pane-container'
 
 describe "Pane", ->
+  class Item extends Model
+    @deserialize: ({name, uri}) -> new this(name, uri)
+    constructor: (@name, @uri) ->
+    getUri: -> @uri
+    getPath: -> @path
+    serialize: -> {deserializer: 'Item', @name, @uri}
+    isEqual: (other) -> @name is other?.name
+
+  beforeEach ->
+    atom.deserializers.add(Item)
+
+  afterEach ->
+    atom.deserializers.remove(Item)
+
+  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]
+
+    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]
+
+  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
+      item3 = new Item("C")
+      pane.addItem(item3, 1)
+      expect(pane.items).toEqual [item1, item3, item2]
+
+    it "adds the item after the active item ", ->
+      pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C")])
+      [item1, item2, item3] = pane.items
+      pane.activateItem(item2)
+      item4 = new Item("D")
+      pane.addItem(item4)
+      expect(pane.items).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']
+
+  describe "::activateItem(item)", ->
+    pane = null
+
+    beforeEach ->
+      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]
+
+    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
+
+  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
+
+      expect(pane.activeItem).toBe item1
+      pane.activatePreviousItem()
+      expect(pane.activeItem).toBe item3
+      pane.activatePreviousItem()
+      expect(pane.activeItem).toBe item2
+      pane.activateNextItem()
+      expect(pane.activeItem).toBe item3
+      pane.activateNextItem()
+      expect(pane.activeItem).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
+      pane.activateItemAtIndex(2)
+      expect(pane.activeItem).toBe item3
+      pane.activateItemAtIndex(1)
+      expect(pane.activeItem).toBe item2
+      pane.activateItemAtIndex(0)
+      expect(pane.activeItem).toBe item1
+
+      # Doesn't fail with out-of-bounds indices
+      pane.activateItemAtIndex(100)
+      expect(pane.activeItem).toBe item1
+      pane.activateItemAtIndex(-1)
+      expect(pane.activeItem).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
+
+    it "removes the item from the items list", ->
+      expect(pane.activeItem).toBe item1
+      pane.destroyItem(item2)
+      expect(item2 in pane.items).toBe false
+      expect(pane.activeItem).toBe item1
+
+      pane.destroyItem(item1)
+      expect(item1 in pane.items).toBe false
+
+    describe "when the destroyed item is the active item and is the first item", ->
+      it "activates the next item", ->
+        expect(pane.activeItem).toBe item1
+        pane.destroyItem(item1)
+        expect(pane.activeItem).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
+        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)
+
+    describe "if the item is modified", ->
+      itemUri = null
+
+      beforeEach ->
+        item1.shouldPromptToSave = -> true
+        item1.save = jasmine.createSpy("save")
+        item1.saveAs = jasmine.createSpy("saveAs")
+        item1.getUri = -> itemUri
+
+      describe "if the [Save] option is selected", ->
+        describe "when the item has a uri", ->
+          it "saves the item before destroying it", ->
+            itemUri = "test"
+            spyOn(atom, 'confirm').andReturn(0)
+            pane.destroyItem(item1)
+
+            expect(item1.save).toHaveBeenCalled()
+            expect(item1 in pane.items).toBe false
+            expect(item1.isDestroyed()).toBe true
+
+        describe "when the item has no uri", ->
+          it "presents a save-as dialog, then saves the item with the given uri before removing and destroying it", ->
+            itemUri = null
+
+            spyOn(atom, 'showSaveDialogSync').andReturn("/selected/path")
+            spyOn(atom, 'confirm').andReturn(0)
+            pane.destroyItem(item1)
+
+            expect(atom.showSaveDialogSync).toHaveBeenCalled()
+            expect(item1.saveAs).toHaveBeenCalledWith("/selected/path")
+            expect(item1 in pane.items).toBe false
+            expect(item1.isDestroyed()).toBe true
+
+      describe "if the [Don't Save] option is selected", ->
+        it "removes and destroys the item without saving it", ->
+          spyOn(atom, 'confirm').andReturn(2)
+          pane.destroyItem(item1)
+
+          expect(item1.save).not.toHaveBeenCalled()
+          expect(item1 in pane.items).toBe false
+          expect(item1.isDestroyed()).toBe true
+
+      describe "if the [Cancel] option is selected", ->
+        it "does not save, remove, or destroy the item", ->
+          spyOn(atom, 'confirm').andReturn(1)
+          pane.destroyItem(item1)
+
+          expect(item1.save).not.toHaveBeenCalled()
+          expect(item1 in pane.items).toBe true
+          expect(item1.isDestroyed()).toBe false
+
+    describe "when the last item is destroyed", ->
+      describe "when the 'core.destroyEmptyPanes' config option is false (the default)", ->
+        it "does not destroy the pane, but leaves it in place with empty items", ->
+          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.saveActiveItem()).not.toThrow()
+          expect(-> pane.saveActiveItemAs()).not.toThrow()
+
+      describe "when the 'core.destroyEmptyPanes' config option is true", ->
+        it "destroys the pane", ->
+          atom.config.set('core.destroyEmptyPanes', true)
+          pane.destroyItem(item) for item in pane.getItems()
+          expect(pane.isDestroyed()).toBe true
+
+  describe "::destroyActiveItem()", ->
+    it "destroys the active item", ->
+      pane = new Pane(items: [new Item("A"), new Item("B")])
+      activeItem = pane.activeItem
+      pane.destroyActiveItem()
+      expect(activeItem.isDestroyed()).toBe true
+      expect(activeItem in pane.items).toBe false
+
+    it "does not throw an exception if there are no more items", ->
+      pane = new Pane
+      pane.destroyActiveItem()
+
+  describe "::destroyItems()", ->
+    it "destroys all items", ->
+      pane = new Pane(items: [new Item("A"), new Item("B"), new Item("C")])
+      [item1, item2, item3] = pane.items
+      pane.destroyItems()
+      expect(item1.isDestroyed()).toBe true
+      expect(item2.isDestroyed()).toBe true
+      expect(item3.isDestroyed()).toBe true
+      expect(pane.items).toEqual []
+
+  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]
+
+  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
+      pane.activateItem(item2)
+      pane.destroyInactiveItems()
+      expect(pane.items).toEqual [item2]
+
+  describe "::saveActiveItem()", ->
+    pane = null
+
+    beforeEach ->
+      pane = new Pane(items: [new Item("A")])
+      spyOn(atom, 'showSaveDialogSync').andReturn('/selected/path')
+
+    describe "when the active item has a uri", ->
+      beforeEach ->
+        pane.activeItem.uri = "test"
+
+      describe "when the active item has a save method", ->
+        it "saves the current item", ->
+          pane.activeItem.save = jasmine.createSpy("save")
+          pane.saveActiveItem()
+          expect(pane.activeItem.save).toHaveBeenCalled()
+
+      describe "when the current item has no save method", ->
+        it "does nothing", ->
+          expect(pane.activeItem.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.saveActiveItem()
+          expect(atom.showSaveDialogSync).toHaveBeenCalled()
+          expect(pane.activeItem.saveAs).toHaveBeenCalledWith('/selected/path')
+
+      describe "when the current item has no saveAs method", ->
+        it "does nothing", ->
+          expect(pane.activeItem.saveAs).toBeUndefined()
+          pane.saveActiveItem()
+          expect(atom.showSaveDialogSync).not.toHaveBeenCalled()
+
+  describe "::saveActiveItemAs()", ->
+    pane = null
+
+    beforeEach ->
+      pane = new Pane(items: [new Item("A")])
+      spyOn(atom, 'showSaveDialogSync').andReturn('/selected/path')
+
+    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.saveActiveItemAs()
+        expect(atom.showSaveDialogSync).toHaveBeenCalledWith(__dirname)
+        expect(pane.activeItem.saveAs).toHaveBeenCalledWith('/selected/path')
+
+    describe "when the current item does not have a saveAs method", ->
+      it "does nothing", ->
+        expect(pane.activeItem.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.uri = "a"
+      item2.uri = "b"
+      expect(pane.itemForUri("a")).toBe item1
+      expect(pane.itemForUri("b")).toBe item2
+      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.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)
+
+  describe "::moveItemToPane(item, pane, index)", ->
+    [container, pane1, pane2] = []
+    [item1, item2, item3, item4, item5] = []
+
+    beforeEach ->
+      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
+
+    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]
+
+    describe "when the moved item the last item in the source pane", ->
+      beforeEach ->
+        item5.destroy()
+
+      describe "when the 'core.destroyEmptyPanes' config option is false (the default)", ->
+        it "does not destroy the pane or the item", ->
+          pane2.moveItemToPane(item4, pane1, 0)
+          expect(pane2.isDestroyed()).toBe false
+          expect(item4.isDestroyed()).toBe false
+
+      describe "when the 'core.destroyEmptyPanes' config option is true", ->
+        it "destroys the pane, but not the item", ->
+          atom.config.set('core.destroyEmptyPanes', true)
+          pane2.moveItemToPane(item4, pane1, 0)
+          expect(pane2.isDestroyed()).toBe true
+          expect(item4.isDestroyed()).toBe false
+
   describe "split methods", ->
     [pane1, container] = []
 
@@ -84,27 +444,14 @@ describe "Pane", ->
       pane2 = pane1.splitRight()
       expect(pane2.focused).toBe true
 
-  describe "::destroyItem(item)", ->
-    describe "when the last item is destroyed", ->
-      it "destroys the pane", ->
-        pane = new Pane(items: ["A", "B"])
-        pane.destroyItem("A")
-        pane.destroyItem("B")
-        expect(pane.isDestroyed()).toBe true
-
-  describe "when an item emits a destroyed event", ->
-    it "removes it from the list of items", ->
-      pane = new Pane(items: [new Model, new Model, new Model])
-      [item1, item2, item3] = pane.items
-      pane.items[1].destroy()
-      expect(pane.items).toEqual [item1, item3]
-
   describe "::destroy()", ->
-    [pane1, container] = []
+    [container, pane1, pane2] = []
 
     beforeEach ->
-      pane1 = new Pane(items: [new Model, new Model])
-      container = new PaneContainer(root: pane1)
+      container = new PaneContainer
+      pane1 = container.root
+      pane1.addItems([new Item("A"), new Item("B")])
+      pane2 = pane1.splitRight()
 
     it "destroys the pane's destroyable items", ->
       [item1, item2] = pane1.items
@@ -112,9 +459,14 @@ describe "Pane", ->
       expect(item1.isDestroyed()).toBe true
       expect(item2.isDestroyed()).toBe true
 
+    describe "if the pane is active", ->
+      it "makes the next pane active", ->
+        expect(pane2.isActive()).toBe true
+        pane2.destroy()
+        expect(pane1.isActive()).to
+
     describe "if the pane's parent has more than two children", ->
       it "removes the pane from its parent", ->
-        pane2 = pane1.splitRight()
         pane3 = pane2.splitRight()
 
         expect(container.root.children).toEqual [pane1, pane2, pane3]
@@ -123,7 +475,6 @@ describe "Pane", ->
 
     describe "if the pane's parent has two children", ->
       it "replaces the parent with its last remaining child", ->
-        pane2 = pane1.splitRight()
         pane3 = pane2.splitDown()
 
         expect(container.root.children[0]).toBe pane1
@@ -132,3 +483,32 @@ describe "Pane", ->
         expect(container.root.children).toEqual [pane1, pane2]
         pane2.destroy()
         expect(container.root).toBe pane1
+
+  describe "serialization", ->
+    pane = null
+
+    beforeEach ->
+      pane = new Pane(items: [new Item("A", "a"), new Item("B", "b"), new Item("C", "c")])
+
+    it "can serialize and deserialize the pane and all its items", ->
+      newPane = pane.testSerialization()
+      expect(newPane.items).toEqual pane.items
+
+    it "restores the active item on deserialization", ->
+      pane.activateItemAtIndex(1)
+      newPane = pane.testSerialization()
+      expect(newPane.activeItem).toEqual newPane.items[1]
+
+    it "does not include items that cannot be deserialized", ->
+      spyOn(console, 'warn')
+      unserializable = {}
+      pane.activateItem(unserializable)
+
+      newPane = pane.testSerialization()
+      expect(newPane.activeItem).toEqual pane.items[0]
+      expect(newPane.items.length).toBe pane.items.length - 1
+
+    it "includes the pane's focus state in the serialized state", ->
+      pane.focus()
+      newPane = pane.testSerialization()
+      expect(newPane.focused).toBe true

spec/pane-view-spec.coffee

@@ -5,7 +5,7 @@ path = require 'path'
 temp = require 'temp'
 
 describe "PaneView", ->
-  [container, view1, view2, editor1, editor2, pane] = []
+  [container, view1, view2, editor1, editor2, pane, paneModel] = []
 
   class TestView extends View
     @deserialize: ({id, text}) -> new TestView({id, text})
@@ -22,378 +22,121 @@ describe "PaneView", ->
     view2 = new TestView(id: 'view-2', text: 'View 2')
     editor1 = atom.project.openSync('sample.js')
     editor2 = atom.project.openSync('sample.txt')
-    pane = new PaneView(view1, editor1, view2, editor2)
-    container.setRoot(pane)
+    pane = container.getRoot()
+    paneModel = pane.model
+    paneModel.addItems([view1, editor1, view2, editor2])
 
   afterEach ->
     atom.deserializers.remove(TestView)
 
-  describe "::initialize(items...)", ->
-    it "displays the first item in the pane", ->
-      expect(pane.itemViews.find('#view-1')).toExist()
-
-  describe "::activateItem(item)", ->
-    it "hides all item views except the one being shown and sets the activeItem", ->
+  describe "when the active pane item changes", ->
+    it "hides all item views except the active one", ->
       expect(pane.activeItem).toBe view1
+      expect(view1.css('display')).not.toBe 'none'
+
       pane.activateItem(view2)
       expect(view1.css('display')).toBe 'none'
       expect(view2.css('display')).not.toBe 'none'
-      expect(pane.activeItem).toBe view2
 
-    it "triggers 'pane:active-item-changed' if the item isn't already the activeItem", ->
-      pane.activate()
+    it "triggers 'pane:active-item-changed'", ->
       itemChangedHandler = jasmine.createSpy("itemChangedHandler")
       container.on 'pane:active-item-changed', itemChangedHandler
 
       expect(pane.activeItem).toBe view1
-      pane.activateItem(view2)
-      pane.activateItem(view2)
+      paneModel.activateItem(view2)
+      paneModel.activateItem(view2)
+
       expect(itemChangedHandler.callCount).toBe 1
       expect(itemChangedHandler.argsForCall[0][1]).toBe view2
       itemChangedHandler.reset()
 
-      pane.activateItem(editor1)
+      paneModel.activateItem(editor1)
       expect(itemChangedHandler).toHaveBeenCalled()
       expect(itemChangedHandler.argsForCall[0][1]).toBe editor1
       itemChangedHandler.reset()
 
-    describe "if the pane's active view is focused before calling activateItem", ->
-      it "focuses the new active view", ->
-        container.attachToDom()
-        pane.focus()
-        expect(pane.activeView).not.toBe view2
-        expect(pane.activeView).toMatchSelector ':focus'
-        pane.activateItem(view2)
-        expect(view2).toMatchSelector ':focus'
+    it "transfers focus to the new active view if the previous view was focused", ->
+      container.attachToDom()
+      pane.focus()
+      expect(pane.activeView).not.toBe view2
+      expect(pane.activeView).toMatchSelector ':focus'
+      paneModel.activateItem(view2)
+      expect(view2).toMatchSelector ':focus'
 
-    describe "when the given item isn't yet in the items list on the pane", ->
-      view3 = null
-      beforeEach ->
-        view3 = new TestView(id: 'view-3', text: "View 3")
-        pane.activateItem(editor1)
-        expect(pane.getActiveItemIndex()).toBe 1
+    describe "when the new activeItem is a model", ->
+      it "shows the item's view or creates and shows a new view for the item if none exists", ->
+        initialViewCount = pane.itemViews.find('.test-view').length
 
-      it "adds it to the items list after the active item", ->
-        pane.activateItem(view3)
-        expect(pane.getItems()).toEqual [view1, editor1, view3, view2, editor2]
-        expect(pane.activeItem).toBe view3
-        expect(pane.getActiveItemIndex()).toBe 2
+        model1 =
+          id: 'test-model-1'
+          text: 'Test Model 1'
+          serialize: -> {@id, @text}
+          getViewClass: -> TestView
 
-      it "triggers the 'item-added' event with the item and its index before the 'active-item-changed' event", ->
-        events = []
-        container.on 'pane:item-added', (e, item, index) -> events.push(['pane:item-added', item, index])
-        container.on 'pane:active-item-changed', (e, item) -> events.push(['pane:active-item-changed', item])
-        pane.activateItem(view3)
-        expect(events).toEqual [['pane:item-added', view3, 2], ['pane:active-item-changed', view3]]
+        model2 =
+          id: 'test-model-2'
+          text: 'Test Model 2'
+          serialize: -> {@id, @text}
+          getViewClass: -> TestView
 
-    describe "when showing a model item", ->
-      describe "when no view has yet been appended for that item", ->
-        it "appends and shows a view to display the item based on its `.getViewClass` method", ->
-          pane.activateItem(editor1)
-          editorView = pane.activeView
-          expect(editorView.css('display')).not.toBe 'none'
-          expect(editorView.editor).toBe editor1
+        paneModel.activateItem(model1)
+        paneModel.activateItem(model2)
+        expect(pane.itemViews.find('.test-view').length).toBe initialViewCount + 2
 
-      describe "when a valid view has already been appended for another item", ->
-        it "multiple views are created for multiple items", ->
-          pane.activateItem(editor1)
-          pane.activateItem(editor2)
-          expect(pane.itemViews.find('.editor').length).toBe 2
-          editorView = pane.activeView
-          expect(editorView.css('display')).not.toBe 'none'
-          expect(editorView.editor).toBe editor2
+        paneModel.activatePreviousItem()
+        expect(pane.itemViews.find('.test-view').length).toBe initialViewCount + 2
 
-        it "creates a new view with the item", ->
-          initialViewCount = pane.itemViews.find('.test-view').length
+        paneModel.destroyItem(model2)
+        expect(pane.itemViews.find('.test-view').length).toBe initialViewCount + 1
 
-          model1 =
-            id: 'test-model-1'
-            text: 'Test Model 1'
-            serialize: -> {@id, @text}
-            getViewClass: -> TestView
+        paneModel.destroyItem(model1)
+        expect(pane.itemViews.find('.test-view').length).toBe initialViewCount
 
-          model2 =
-            id: 'test-model-2'
-            text: 'Test Model 2'
-            serialize: -> {@id, @text}
-            getViewClass: -> TestView
-
-          pane.activateItem(model1)
-          pane.activateItem(model2)
-          expect(pane.itemViews.find('.test-view').length).toBe initialViewCount + 2
-
-          pane.activatePreviousItem()
-          expect(pane.itemViews.find('.test-view').length).toBe initialViewCount + 2
-
-          pane.destroyItem(model2)
-          expect(pane.itemViews.find('.test-view').length).toBe initialViewCount + 1
-
-          pane.destroyItem(model1)
-          expect(pane.itemViews.find('.test-view').length).toBe initialViewCount
-
-    describe "when showing a view item", ->
+    describe "when the new activeItem is a view", ->
       it "appends it to the itemViews div if it hasn't already been appended and shows it", ->
         expect(pane.itemViews.find('#view-2')).not.toExist()
-        pane.activateItem(view2)
+        paneModel.activateItem(view2)
         expect(pane.itemViews.find('#view-2')).toExist()
-        expect(pane.activeView).toBe view2
+        paneModel.activateItem(view1)
+        paneModel.activateItem(view2)
+        expect(pane.itemViews.find('#view-2').length).toBe 1
 
-  describe "::destroyItem(item)", ->
-    describe "if the item is not modified", ->
-      it "removes the item and tries to call destroy on it", ->
-        pane.destroyItem(editor2)
-        expect(pane.getItems().indexOf(editor2)).toBe -1
-        expect(editor2.isDestroyed()).toBe true
-
-    describe "if the item is modified", ->
-      beforeEach ->
-        jasmine.unspy(editor2, 'shouldPromptToSave')
-        spyOn(editor2, 'save')
-        spyOn(editor2, 'saveAs')
-
-        editor2.insertText('a')
-        expect(editor2.isModified()).toBeTruthy()
-
-      describe "if the [Save] option is selected", ->
-        describe "when the item has a uri", ->
-          it "saves the item before removing and destroying it", ->
-            spyOn(atom, 'confirm').andReturn(0)
-            pane.destroyItem(editor2)
-
-            expect(editor2.save).toHaveBeenCalled()
-            expect(pane.getItems().indexOf(editor2)).toBe -1
-            expect(editor2.isDestroyed()).toBe true
-
-        describe "when the item has no uri", ->
-          it "presents a save-as dialog, then saves the item with the given uri before removing and destroying it", ->
-            editor2.buffer.setPath(undefined)
-
-            spyOn(atom, 'showSaveDialogSync').andReturn("/selected/path")
-            spyOn(atom, 'confirm').andReturn(0)
-            pane.destroyItem(editor2)
-
-            expect(atom.showSaveDialogSync).toHaveBeenCalled()
-
-            expect(editor2.saveAs).toHaveBeenCalledWith("/selected/path")
-            expect(pane.getItems().indexOf(editor2)).toBe -1
-            expect(editor2.isDestroyed()).toBe true
-
-      describe "if the [Don't Save] option is selected", ->
-        it "removes and destroys the item without saving it", ->
-          spyOn(atom, 'confirm').andReturn(2)
-          pane.destroyItem(editor2)
-
-          expect(editor2.save).not.toHaveBeenCalled()
-          expect(pane.getItems().indexOf(editor2)).toBe -1
-          expect(editor2.isDestroyed()).toBe true
-
-      describe "if the [Cancel] option is selected", ->
-        it "does not save, remove, or destroy the item", ->
-          spyOn(atom, 'confirm').andReturn(1)
-          pane.destroyItem(editor2)
-
-          expect(editor2.save).not.toHaveBeenCalled()
-          expect(pane.getItems().indexOf(editor2)).not.toBe -1
-          expect(editor2.isDestroyed()).toBe false
-
-    it "removes the item's associated view", ->
-      view1.remove = (selector, keepData) -> @wasRemoved = not keepData
-      pane.destroyItem(view1)
-      expect(view1.wasRemoved).toBe true
-
-    it "removes the item from the items list and shows the next item if it was showing", ->
-      pane.destroyItem(view1)
-      expect(pane.getItems()).toEqual [editor1, view2, editor2]
-      expect(pane.activeItem).toBe editor1
-
-      pane.activateItem(editor2)
-      pane.destroyItem(editor2)
-      expect(pane.getItems()).toEqual [editor1, view2]
-      expect(pane.activeItem).toBe editor1
-
-    it "triggers 'pane:item-removed' with the item and its former index", ->
+  describe "when an item is destroyed", ->
+    it "triggers the 'pane:item-removed' event with the item and its former index", ->
       itemRemovedHandler = jasmine.createSpy("itemRemovedHandler")
       pane.on 'pane:item-removed', itemRemovedHandler
-      pane.destroyItem(editor1)
+      paneModel.destroyItem(editor1)
       expect(itemRemovedHandler).toHaveBeenCalled()
       expect(itemRemovedHandler.argsForCall[0][1..2]).toEqual [editor1, 1]
 
-    describe "when removing the last item", ->
-      it "removes the pane", ->
-        pane.destroyItem(item) for item in pane.getItems()
-        expect(pane.hasParent()).toBeFalsy()
-
-      describe "when the pane is focused", ->
-        it "shifts focus to the next pane", ->
-          expect(container.getRoot()).toBe pane
-          container.attachToDom()
-          pane2 = pane.splitRight(new TestView(id: 'view-3', text: 'View 3'))
-          pane.focus()
-          expect(pane).toMatchSelector(':has(:focus)')
-          pane.destroyItem(item) for item in pane.getItems()
-          expect(pane2).toMatchSelector ':has(:focus)'
-
-    describe "when the item is a view", ->
+    describe "when the destroyed item is a view", ->
       it "removes the item from the 'item-views' div", ->
         expect(view1.parent()).toMatchSelector pane.itemViews
-        pane.destroyItem(view1)
+        paneModel.destroyItem(view1)
         expect(view1.parent()).not.toMatchSelector pane.itemViews
 
-    describe "when the item is a model", ->
-      it "removes the associated view only when all items that require it have been removed", ->
-        pane.activateItem(editor1)
-        pane.activateItem(editor2)
-        pane.destroyItem(editor2)
-        expect(pane.itemViews.find('.editor')).toExist()
+    describe "when the destroyed item is a model", ->
+      it "removes the associated view", ->
+        paneModel.activateItem(editor1)
+        expect(pane.itemViews.find('.editor').length).toBe 1
         pane.destroyItem(editor1)
-        expect(pane.itemViews.find('.editor')).not.toExist()
+        expect(pane.itemViews.find('.editor').length).toBe 0
 
-  describe "::moveItem(item, index)", ->
-    it "moves the item to the given index and emits a 'pane:item-moved' event with the item and the new index", ->
-      itemMovedHandler = jasmine.createSpy("itemMovedHandler")
-      pane.on 'pane:item-moved', itemMovedHandler
-
-      pane.moveItem(view1, 2)
-      expect(pane.getItems()).toEqual [editor1, view2, view1, editor2]
+  describe "when an item is moved within the same pane", ->
+    it "emits a 'pane:item-moved' event with the item and the new index", ->
+      pane.on 'pane:item-moved', itemMovedHandler = jasmine.createSpy("itemMovedHandler")
+      paneModel.moveItem(view1, 2)
       expect(itemMovedHandler).toHaveBeenCalled()
       expect(itemMovedHandler.argsForCall[0][1..2]).toEqual [view1, 2]
-      itemMovedHandler.reset()
 
-      pane.moveItem(editor1, 3)
-      expect(pane.getItems()).toEqual [view2, view1, editor2, editor1]
-      expect(itemMovedHandler).toHaveBeenCalled()
-      expect(itemMovedHandler.argsForCall[0][1..2]).toEqual [editor1, 3]
-      itemMovedHandler.reset()
-
-      pane.moveItem(editor1, 1)
-      expect(pane.getItems()).toEqual [view2, editor1, view1, editor2]
-      expect(itemMovedHandler).toHaveBeenCalled()
-      expect(itemMovedHandler.argsForCall[0][1..2]).toEqual [editor1, 1]
-      itemMovedHandler.reset()
-
-  describe "::moveItemToPane(item, pane, index)", ->
-    [pane2, view3] = []
-
-    beforeEach ->
-      view3 = new TestView(id: 'view-3', text: "View 3")
-      pane2 = pane.splitRight(view3)
-
-    it "moves the item to the given pane at the given index", ->
-      pane.moveItemToPane(view1, pane2, 1)
-      expect(pane.getItems()).toEqual [editor1, view2, editor2]
-      expect(pane2.getItems()).toEqual [view3, view1]
-
-    describe "when it is the last item on the source pane", ->
-      it "removes the source pane, but does not destroy the item", ->
-        pane.destroyItem(view1)
-        pane.destroyItem(view2)
-        pane.destroyItem(editor2)
-
-        expect(pane.getItems()).toEqual [editor1]
-        pane.moveItemToPane(editor1, pane2, 1)
-
-        expect(pane.hasParent()).toBeFalsy()
-        expect(pane2.getItems()).toEqual [view3, editor1]
-        expect(editor1.isDestroyed()).toBe false
-
-    describe "when the item is a jQuery object", ->
-      it "preserves data by detaching instead of removing", ->
-        view1.data('preservative', 1234)
-        pane.moveItemToPane(view1, pane2, 1)
-        pane2.activateItemAtIndex(1)
-        expect(pane2.activeView.data('preservative')).toBe 1234
-
-  describe "pane:close", ->
-    it "destroys all items and removes the pane", ->
-      pane.activateItem(editor1)
-      pane.trigger 'pane:close'
-      expect(pane.hasParent()).toBeFalsy()
-      expect(editor2.isDestroyed()).toBe true
-      expect(editor1.isDestroyed()).toBe true
-
-  describe "pane:close-other-items", ->
-    it "destroys all items except the current", ->
-      pane.activateItem(editor1)
-      pane.trigger 'pane:close-other-items'
-      expect(editor2.isDestroyed()).toBe true
-      expect(pane.getItems()).toEqual [editor1]
-
-  describe "::saveActiveItem()", ->
-    describe "when the current item has a uri", ->
-      describe "when the current item has a save method", ->
-        it "saves the current item", ->
-          spyOn(editor2, 'save')
-          pane.activateItem(editor2)
-          pane.saveActiveItem()
-          expect(editor2.save).toHaveBeenCalled()
-
-      describe "when the current item has no save method", ->
-        it "does nothing", ->
-          pane.activeItem.getUri = -> 'you are eye'
-          expect(pane.activeItem.save).toBeUndefined()
-          pane.saveActiveItem()
-
-    describe "when the current item has no uri", ->
-      beforeEach ->
-        spyOn(atom, 'showSaveDialogSync').andReturn('/selected/path')
-
-      describe "when the current item has a saveAs method", ->
-        it "opens a save dialog and saves the current item as the selected path", ->
-          newEditor = atom.project.openSync()
-          spyOn(newEditor, 'saveAs')
-          pane.activateItem(newEditor)
-
-          pane.saveActiveItem()
-
-          expect(atom.showSaveDialogSync).toHaveBeenCalled()
-          expect(newEditor.saveAs).toHaveBeenCalledWith('/selected/path')
-
-      describe "when the current item has no saveAs method", ->
-        it "does nothing", ->
-          expect(pane.activeItem.saveAs).toBeUndefined()
-          pane.saveActiveItem()
-          expect(atom.showSaveDialogSync).not.toHaveBeenCalled()
-
-  describe "::saveActiveItemAs()", ->
-    beforeEach ->
-      spyOn(atom, 'showSaveDialogSync').andReturn('/selected/path')
-
-    describe "when the current item has a saveAs method", ->
-      it "opens the save dialog and calls saveAs on the item with the selected path", ->
-        spyOn(editor2, 'saveAs')
-        pane.activateItem(editor2)
-
-        pane.saveActiveItemAs()
-
-        expect(atom.showSaveDialogSync).toHaveBeenCalledWith(path.dirname(editor2.getPath()))
-        expect(editor2.saveAs).toHaveBeenCalledWith('/selected/path')
-
-    describe "when the current item does not have a saveAs method", ->
-      it "does nothing", ->
-        expect(pane.activeItem.saveAs).toBeUndefined()
-        pane.saveActiveItemAs()
-        expect(atom.showSaveDialogSync).not.toHaveBeenCalled()
-
-  describe "pane:show-next-item and pane:show-previous-item", ->
-    it "advances forward/backward through the pane's items, looping around at either end", ->
-      expect(pane.activeItem).toBe view1
-      pane.trigger 'pane:show-previous-item'
-      expect(pane.activeItem).toBe editor2
-      pane.trigger 'pane:show-previous-item'
-      expect(pane.activeItem).toBe view2
-      pane.trigger 'pane:show-next-item'
-      expect(pane.activeItem).toBe editor2
-      pane.trigger 'pane:show-next-item'
-      expect(pane.activeItem).toBe view1
-
-  describe "pane:show-item-N events", ->
-    it "shows the (n-1)th item if it exists", ->
-      pane.trigger 'pane:show-item-2'
-      expect(pane.activeItem).toBe pane.itemAtIndex(1)
-      pane.trigger 'pane:show-item-1'
-      expect(pane.activeItem).toBe pane.itemAtIndex(0)
-      pane.trigger 'pane:show-item-9' # don't fail on out-of-bounds indices
-      expect(pane.activeItem).toBe pane.itemAtIndex(0)
+  describe "when an item is moved to another pane", ->
+    it "detaches the item's view rather than removing it", ->
+      paneModel2 = paneModel.splitRight()
+      view1.data('preservative', 1234)
+      paneModel.moveItemToPane(view1, paneModel2, 1)
+      expect(view1.data('preservative')).toBe 1234
+      paneModel2.activateItemAtIndex(1)
+      expect(view1.data('preservative')).toBe 1234
 
   describe "when the title of the active item changes", ->
     it "emits pane:active-item-title-changed", ->
@@ -421,67 +164,32 @@ describe "PaneView", ->
       expect(pane.items).toHaveLength(5)
 
       fs.removeSync(filePath)
-      waitsFor ->
+      waitsFor 30000, ->
         pane.items.length == 4
 
-  describe "::remove()", ->
-    it "destroys all the pane's items", ->
-      pane.remove()
-      expect(editor1.isDestroyed()).toBe true
-      expect(editor2.isDestroyed()).toBe true
+  describe "when a pane is destroyed", ->
+    [pane2, pane2Model] = []
+
+    beforeEach ->
+      pane2Model = paneModel.splitRight() # Can't destroy the last pane, so we add another
+      pane2 = pane2Model._view
 
     it "triggers a 'pane:removed' event with the pane", ->
       removedHandler = jasmine.createSpy("removedHandler")
       container.on 'pane:removed', removedHandler
-      pane.remove()
+      paneModel.destroy()
       expect(removedHandler).toHaveBeenCalled()
       expect(removedHandler.argsForCall[0][1]).toBe pane
 
-    describe "when there are other panes", ->
+    describe "if the destroyed pane has focus", ->
       [paneToLeft, paneToRight] = []
 
-      beforeEach ->
-        pane.activateItem(editor1)
-        paneToLeft = pane.splitLeft(pane.copyActiveItem())
-        paneToRight = pane.splitRight(pane.copyActiveItem())
+      it "focuses the next pane", ->
         container.attachToDom()
-
-      describe "when the removed pane is active", ->
-        it "makes the next the next pane active and focuses it", ->
-          pane.activate()
-          pane.remove()
-          expect(paneToLeft.isActive()).toBeFalsy()
-          expect(paneToRight.isActive()).toBeTruthy()
-          expect(paneToRight).toMatchSelector ':has(:focus)'
-
-      describe "when the removed pane is not active", ->
-        it "does not affect the active pane or the focus", ->
-          paneToLeft.focus()
-          expect(paneToLeft.isActive()).toBeTruthy()
-          expect(paneToRight.isActive()).toBeFalsy()
-
-          pane.remove()
-          expect(paneToLeft.isActive()).toBeTruthy()
-          expect(paneToRight.isActive()).toBeFalsy()
-          expect(paneToLeft).toMatchSelector ':has(:focus)'
-
-    describe "when it is the last pane", ->
-      beforeEach ->
-        expect(container.getPanes().length).toBe 1
-        atom.workspaceView = focus: jasmine.createSpy("workspaceView.focus")
-
-      describe "when the removed pane is focused", ->
-        it "calls focus on workspaceView so we don't lose focus", ->
-          container.attachToDom()
-          pane.focus()
-          pane.remove()
-          expect(atom.workspaceView.focus).toHaveBeenCalled()
-
-      describe "when the removed pane is not focused", ->
-        it "does not call focus on root view", ->
-          expect(pane).not.toMatchSelector ':has(:focus)'
-          pane.remove()
-          expect(atom.workspaceView.focus).not.toHaveBeenCalled()
+        expect(pane.hasFocus()).toBe false
+        expect(pane2.hasFocus()).toBe true
+        pane2Model.destroy()
+        expect(pane.hasFocus()).toBe true
 
   describe "::getNextPane()", ->
     it "returns the next pane if one exists, wrapping around from the last pane to the first", ->
@@ -491,148 +199,78 @@ describe "PaneView", ->
       expect(pane.getNextPane()).toBe pane2
       expect(pane2.getNextPane()).toBe pane
 
+  describe "when the pane's active status changes", ->
+    [pane2, pane2Model] = []
+
+    beforeEach ->
+      pane2Model = paneModel.splitRight(items: [pane.copyActiveItem()])
+      pane2 = pane2Model._view
+      expect(pane2Model.isActive()).toBe true
+
+    it "adds or removes the .active class as appropriate", ->
+      expect(pane).not.toHaveClass('active')
+      paneModel.activate()
+      expect(pane).toHaveClass('active')
+      pane2Model.activate()
+      expect(pane).not.toHaveClass('active')
+
+    it "triggers 'pane:became-active' or 'pane:became-inactive' according to the current status", ->
+      pane.on 'pane:became-active', becameActiveHandler = jasmine.createSpy("becameActiveHandler")
+      pane.on 'pane:became-inactive', becameInactiveHandler = jasmine.createSpy("becameInactiveHandler")
+      paneModel.activate()
+
+      expect(becameActiveHandler.callCount).toBe 1
+      expect(becameInactiveHandler.callCount).toBe 0
+
+      pane2Model.activate()
+      expect(becameActiveHandler.callCount).toBe 1
+      expect(becameInactiveHandler.callCount).toBe 1
+
   describe "when the pane is focused", ->
     beforeEach ->
       container.attachToDom()
 
-    it "focuses the active item view", ->
+    it "transfers focus to the active view", ->
       focusHandler = jasmine.createSpy("focusHandler")
       pane.activeItem.on 'focus', focusHandler
       pane.focus()
       expect(focusHandler).toHaveBeenCalled()
 
-    it "triggers 'pane:became-active' if it was not previously active", ->
-      pane2 = pane.splitRight(view2) # Make pane inactive
+    it "makes the pane active", ->
+      paneModel.splitRight(items: [pane.copyActiveItem()])
+      expect(paneModel.isActive()).toBe false
+      pane.focus()
+      expect(paneModel.isActive()).toBe true
 
-      becameActiveHandler = jasmine.createSpy("becameActiveHandler")
-      pane.on 'pane:became-active', becameActiveHandler
-      expect(pane.isActive()).toBeFalsy()
-      pane.focusin()
-      expect(pane.isActive()).toBeTruthy()
-      pane.focusin()
-
-      expect(becameActiveHandler.callCount).toBe 1
-
-    it "triggers 'pane:became-inactive' when it was previously active", ->
-      pane2 = pane.splitRight(view2) # Make pane inactive
-
-      becameInactiveHandler = jasmine.createSpy("becameInactiveHandler")
-      pane.on 'pane:became-inactive', becameInactiveHandler
-
-      expect(pane.isActive()).toBeFalsy()
-      pane.focusin()
-      expect(pane.isActive()).toBeTruthy()
-      pane.splitRight(pane.copyActiveItem())
-      expect(pane.isActive()).toBeFalsy()
-
-      expect(becameInactiveHandler.callCount).toBe 1
-
-  describe "split methods", ->
-    [pane1, view3, view4] = []
-    beforeEach ->
+  describe "when a pane is split", ->
+    it "builds the appropriate pane-row and pane-column views", ->
       pane1 = pane
+      pane1Model = pane.model
       pane.activateItem(editor1)
-      view3 = new TestView(id: 'view-3', text: 'View 3')
-      view4 = new TestView(id: 'view-4', text: 'View 4')
 
-    describe "splitRight(items...)", ->
-      it "builds a row if needed, then appends a new pane after itself", ->
-        # creates the new pane with a copy of the active item if none are given
-        pane2 = pane1.splitRight(pane1.copyActiveItem())
-        expect(container.find('.pane-row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-        expect(pane2.items).toEqual [editor1]
-        expect(pane2.activeItem).not.toBe editor1 # it's a copy
+      pane2Model = pane1Model.splitRight(items: [pane1Model.copyActiveItem()])
+      pane3Model = pane2Model.splitDown(items: [pane2Model.copyActiveItem()])
+      pane2 = pane2Model._view
+      pane3 = pane3Model._view
 
-        pane3 = pane2.splitRight(view3, view4)
-        expect(pane3.getItems()).toEqual [view3, view4]
-        expect(container.find('.pane-row .pane').toArray()).toEqual [pane[0], pane2[0], pane3[0]]
+      expect(container.find('> .pane-row > .pane').toArray()).toEqual [pane1[0]]
+      expect(container.find('> .pane-row > .pane-column > .pane').toArray()).toEqual [pane2[0], pane3[0]]
 
-      it "builds a row if needed, then appends a new pane after itself ", ->
-        # creates the new pane with a copy of the active item if none are given
-        pane2 = pane1.splitRight()
-        expect(container.find('.pane-row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-        expect(pane2.items).toEqual []
-        expect(pane2.activeItem).toBeUndefined()
-
-        pane3 = pane2.splitRight()
-        expect(container.find('.pane-row .pane').toArray()).toEqual [pane1[0], pane2[0], pane3[0]]
-        expect(pane3.items).toEqual []
-        expect(pane3.activeItem).toBeUndefined()
-
-    describe "splitLeft(items...)", ->
-      it "builds a row if needed, then appends a new pane before itself", ->
-        # creates the new pane with a copy of the active item if none are given
-        pane2 = pane.splitLeft(pane1.copyActiveItem())
-        expect(container.find('.pane-row .pane').toArray()).toEqual [pane2[0], pane[0]]
-        expect(pane2.items).toEqual [editor1]
-        expect(pane2.activeItem).not.toBe editor1 # it's a copy
-
-        pane3 = pane2.splitLeft(view3, view4)
-        expect(pane3.getItems()).toEqual [view3, view4]
-        expect(container.find('.pane-row .pane').toArray()).toEqual [pane3[0], pane2[0], pane[0]]
-
-    describe "splitDown(items...)", ->
-      it "builds a column if needed, then appends a new pane after itself", ->
-        # creates the new pane with a copy of the active item if none are given
-        pane2 = pane.splitDown(pane1.copyActiveItem())
-        expect(container.find('.pane-column .pane').toArray()).toEqual [pane[0], pane2[0]]
-        expect(pane2.items).toEqual [editor1]
-        expect(pane2.activeItem).not.toBe editor1 # it's a copy
-
-        pane3 = pane2.splitDown(view3, view4)
-        expect(pane3.getItems()).toEqual [view3, view4]
-        expect(container.find('.pane-column .pane').toArray()).toEqual [pane[0], pane2[0], pane3[0]]
-
-    describe "splitUp(items...)", ->
-      it "builds a column if needed, then appends a new pane before itself", ->
-        # creates the new pane with a copy of the active item if none are given
-        pane2 = pane.splitUp(pane1.copyActiveItem())
-        expect(container.find('.pane-column .pane').toArray()).toEqual [pane2[0], pane[0]]
-        expect(pane2.items).toEqual [editor1]
-        expect(pane2.activeItem).not.toBe editor1 # it's a copy
-
-        pane3 = pane2.splitUp(view3, view4)
-        expect(pane3.getItems()).toEqual [view3, view4]
-        expect(container.find('.pane-column .pane').toArray()).toEqual [pane3[0], pane2[0], pane[0]]
-
-  describe "::itemForUri(uri)", ->
-    it "returns the item for which a call to .getUri() returns the given uri", ->
-      expect(pane.itemForUri(editor1.getUri())).toBe editor1
-      expect(pane.itemForUri(editor2.getUri())).toBe editor2
+      pane1Model.destroy()
+      expect(container.find('> .pane-column > .pane').toArray()).toEqual [pane2[0], pane3[0]]
 
   describe "serialization", ->
-    it "can serialize and deserialize the pane and all its items", ->
-      newPane = pane.testSerialization()
-      expect(newPane.getItems()).toEqual [view1, editor1, view2, editor2]
-
-    it "restores the active item on deserialization", ->
-      pane.activateItem(editor2)
-      newPane = pane.testSerialization()
-      expect(newPane.activeItem).toEqual editor2
-
-    it "does not show items that cannot be deserialized", ->
-      spyOn(console, 'warn')
-
-      class Unserializable
-        getViewClass: -> TestView
-
-      pane.activateItem(new Unserializable)
-
-      newPane = pane.testSerialization()
-      expect(newPane.activeItem).toEqual pane.items[0]
-      expect(newPane.items.length).toBe pane.items.length - 1
-
     it "focuses the pane after attach only if had focus when serialized", ->
       container.attachToDom()
       pane.focus()
 
-      container2 = container.testSerialization()
+      container2 = new PaneContainerView(container.model.testSerialization())
       pane2 = container2.getRoot()
       container2.attachToDom()
       expect(pane2).toMatchSelector(':has(:focus)')
 
       $(document.activeElement).blur()
-      container3 = container.testSerialization()
+      container3 = new PaneContainerView(container.model.testSerialization())
       pane3 = container3.getRoot()
       container3.attachToDom()
       expect(pane3).not.toMatchSelector(':has(:focus)')

spec/pasteboard-spec.coffee

@@ -1,10 +0,0 @@
-describe "Pasteboard", ->
-  describe "write(text, metadata) and read()", ->
-    it "writes and reads text to/from the native pasteboard", ->
-      expect(atom.pasteboard.read()).toEqual ['initial pasteboard content']
-      atom.pasteboard.write('next')
-      expect(atom.pasteboard.read()[0]).toBe 'next'
-
-    it "returns metadata if the item on the native pasteboard matches the last written item", ->
-      atom.pasteboard.write('next', {meta: 'data'})
-      expect(atom.pasteboard.read()).toEqual ['next', {meta: 'data'}]

spec/project-spec.coffee

@@ -72,7 +72,7 @@ describe "Project", ->
       expect(atom.project.getEditors()[1]).toBe editor2
 
   describe ".openSync(path)", ->
-    [fooOpener, barOpener, absolutePath, newBufferHandler, newEditorHandler] = []
+    [absolutePath, newBufferHandler, newEditorHandler] = []
     beforeEach ->
       absolutePath = require.resolve('./fixtures/dir/a')
       newBufferHandler = jasmine.createSpy('newBufferHandler')
@@ -80,129 +80,92 @@ describe "Project", ->
       newEditorHandler = jasmine.createSpy('newEditorHandler')
       atom.project.on 'editor-created', newEditorHandler
 
-      fooOpener = (pathToOpen, options) -> { foo: pathToOpen, options } if pathToOpen?.match(/\.foo/)
-      barOpener = (pathToOpen) -> { bar: pathToOpen } if pathToOpen?.match(/^bar:\/\//)
-      atom.project.registerOpener(fooOpener)
-      atom.project.registerOpener(barOpener)
+    describe "when given an absolute path that hasn't been opened previously", ->
+      it "returns a new edit session for the given path and emits 'buffer-created' and 'editor-created' events", ->
+        editor = atom.project.openSync(absolutePath)
+        expect(editor.buffer.getPath()).toBe absolutePath
+        expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
+        expect(newEditorHandler).toHaveBeenCalledWith editor
 
-    afterEach ->
-      atom.project.unregisterOpener(fooOpener)
-      atom.project.unregisterOpener(barOpener)
+    describe "when given a relative path that hasn't been opened previously", ->
+      it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'editor-created' events", ->
+        editor = atom.project.openSync('a')
+        expect(editor.buffer.getPath()).toBe absolutePath
+        expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
+        expect(newEditorHandler).toHaveBeenCalledWith editor
 
-    describe "when passed a path that doesn't match a custom opener", ->
-      describe "when given an absolute path that hasn't been opened previously", ->
-        it "returns a new edit session for the given path and emits 'buffer-created' and 'editor-created' events", ->
-          editor = atom.project.openSync(absolutePath)
+    describe "when passed the path to a buffer that has already been opened", ->
+      it "returns a new edit session containing previously opened buffer and emits a 'editor-created' event", ->
+        editor = atom.project.openSync(absolutePath)
+        newBufferHandler.reset()
+        expect(atom.project.openSync(absolutePath).buffer).toBe editor.buffer
+        expect(atom.project.openSync('a').buffer).toBe editor.buffer
+        expect(newBufferHandler).not.toHaveBeenCalled()
+        expect(newEditorHandler).toHaveBeenCalledWith editor
+
+    describe "when not passed a path", ->
+      it "returns a new edit session and emits 'buffer-created' and 'editor-created' events", ->
+        editor = atom.project.openSync()
+        expect(editor.buffer.getPath()).toBeUndefined()
+        expect(newBufferHandler).toHaveBeenCalledWith(editor.buffer)
+        expect(newEditorHandler).toHaveBeenCalledWith editor
+
+  describe ".open(path)", ->
+    [absolutePath, newBufferHandler, newEditorHandler] = []
+
+    beforeEach ->
+      absolutePath = require.resolve('./fixtures/dir/a')
+      newBufferHandler = jasmine.createSpy('newBufferHandler')
+      atom.project.on 'buffer-created', newBufferHandler
+      newEditorHandler = jasmine.createSpy('newEditorHandler')
+      atom.project.on 'editor-created', newEditorHandler
+
+    describe "when given an absolute path that isn't currently open", ->
+      it "returns a new edit session for the given path and emits 'buffer-created' and 'editor-created' events", ->
+        editor = null
+        waitsForPromise ->
+          atom.project.open(absolutePath).then (o) -> editor = o
+
+        runs ->
           expect(editor.buffer.getPath()).toBe absolutePath
           expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
           expect(newEditorHandler).toHaveBeenCalledWith editor
 
-      describe "when given a relative path that hasn't been opened previously", ->
-        it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'editor-created' events", ->
-          editor = atom.project.openSync('a')
+    describe "when given a relative path that isn't currently opened", ->
+      it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'editor-created' events", ->
+        editor = null
+        waitsForPromise ->
+          atom.project.open(absolutePath).then (o) -> editor = o
+
+        runs ->
           expect(editor.buffer.getPath()).toBe absolutePath
           expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
           expect(newEditorHandler).toHaveBeenCalledWith editor
 
-      describe "when passed the path to a buffer that has already been opened", ->
-        it "returns a new edit session containing previously opened buffer and emits a 'editor-created' event", ->
-          editor = atom.project.openSync(absolutePath)
+    describe "when passed the path to a buffer that is currently opened", ->
+      it "returns a new edit session containing currently opened buffer and emits a 'editor-created' event", ->
+        editor = null
+        waitsForPromise ->
+          atom.project.open(absolutePath).then (o) -> editor = o
+
+        runs ->
           newBufferHandler.reset()
           expect(atom.project.openSync(absolutePath).buffer).toBe editor.buffer
           expect(atom.project.openSync('a').buffer).toBe editor.buffer
           expect(newBufferHandler).not.toHaveBeenCalled()
           expect(newEditorHandler).toHaveBeenCalledWith editor
 
-      describe "when not passed a path", ->
-        it "returns a new edit session and emits 'buffer-created' and 'editor-created' events", ->
-          editor = atom.project.openSync()
+    describe "when not passed a path", ->
+      it "returns a new edit session and emits 'buffer-created' and 'editor-created' events", ->
+        editor = null
+        waitsForPromise ->
+          atom.project.open().then (o) -> editor = o
+
+        runs ->
           expect(editor.buffer.getPath()).toBeUndefined()
           expect(newBufferHandler).toHaveBeenCalledWith(editor.buffer)
           expect(newEditorHandler).toHaveBeenCalledWith editor
 
-    describe "when passed a path that matches a custom opener", ->
-      it "returns the resource returned by the custom opener", ->
-        pathToOpen = atom.project.resolve('a.foo')
-        expect(atom.project.openSync(pathToOpen, hey: "there")).toEqual { foo: pathToOpen, options: {hey: "there"} }
-        expect(atom.project.openSync("bar://baz")).toEqual { bar: "bar://baz" }
-
-  describe ".open(path)", ->
-    [fooOpener, barOpener, absolutePath, newBufferHandler, newEditorHandler] = []
-
-    beforeEach ->
-      absolutePath = require.resolve('./fixtures/dir/a')
-      newBufferHandler = jasmine.createSpy('newBufferHandler')
-      atom.project.on 'buffer-created', newBufferHandler
-      newEditorHandler = jasmine.createSpy('newEditorHandler')
-      atom.project.on 'editor-created', newEditorHandler
-
-      fooOpener = (pathToOpen, options) -> { foo: pathToOpen, options } if pathToOpen?.match(/\.foo/)
-      barOpener = (pathToOpen) -> { bar: pathToOpen } if pathToOpen?.match(/^bar:\/\//)
-      atom.project.registerOpener(fooOpener)
-      atom.project.registerOpener(barOpener)
-
-    afterEach ->
-      atom.project.unregisterOpener(fooOpener)
-      atom.project.unregisterOpener(barOpener)
-
-    describe "when passed a path that doesn't match a custom opener", ->
-      describe "when given an absolute path that isn't currently open", ->
-        it "returns a new edit session for the given path and emits 'buffer-created' and 'editor-created' events", ->
-          editor = null
-          waitsForPromise ->
-            atom.project.open(absolutePath).then (o) -> editor = o
-
-          runs ->
-            expect(editor.buffer.getPath()).toBe absolutePath
-            expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
-            expect(newEditorHandler).toHaveBeenCalledWith editor
-
-      describe "when given a relative path that isn't currently opened", ->
-        it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'editor-created' events", ->
-          editor = null
-          waitsForPromise ->
-            atom.project.open(absolutePath).then (o) -> editor = o
-
-          runs ->
-            expect(editor.buffer.getPath()).toBe absolutePath
-            expect(newBufferHandler).toHaveBeenCalledWith editor.buffer
-            expect(newEditorHandler).toHaveBeenCalledWith editor
-
-      describe "when passed the path to a buffer that is currently opened", ->
-        it "returns a new edit session containing currently opened buffer and emits a 'editor-created' event", ->
-          editor = null
-          waitsForPromise ->
-            atom.project.open(absolutePath).then (o) -> editor = o
-
-          runs ->
-            newBufferHandler.reset()
-            expect(atom.project.openSync(absolutePath).buffer).toBe editor.buffer
-            expect(atom.project.openSync('a').buffer).toBe editor.buffer
-            expect(newBufferHandler).not.toHaveBeenCalled()
-            expect(newEditorHandler).toHaveBeenCalledWith editor
-
-      describe "when not passed a path", ->
-        it "returns a new edit session and emits 'buffer-created' and 'editor-created' events", ->
-          editor = null
-          waitsForPromise ->
-            atom.project.open().then (o) -> editor = o
-
-          runs ->
-            expect(editor.buffer.getPath()).toBeUndefined()
-            expect(newBufferHandler).toHaveBeenCalledWith(editor.buffer)
-            expect(newEditorHandler).toHaveBeenCalledWith editor
-
-    describe "when passed a path that matches a custom opener", ->
-      it "returns the resource returned by the custom opener", ->
-        waitsForPromise ->
-          pathToOpen = atom.project.resolve('a.foo')
-          atom.project.open(pathToOpen, hey: "there").then (item) ->
-            expect(item).toEqual { foo: pathToOpen, options: {hey: "there"} }
-
-        waitsForPromise ->
-          atom.project.open("bar://baz").then (item) ->
-            expect(item).toEqual { bar: "bar://baz" }
-
     it "returns number of read bytes as progress indicator", ->
       filePath = atom.project.resolve 'a'
       totalBytes = 0

spec/random-editor-spec.coffee

@@ -0,0 +1,112 @@
+{times, random} = require 'underscore-plus'
+randomWords = require 'random-words'
+TextBuffer = require 'text-buffer'
+Editor = require '../src/editor'
+
+describe "Editor", ->
+  [editor, tokenizedBuffer, buffer, steps, previousSteps] = []
+
+  softWrapColumn = 80
+
+  beforeEach ->
+    atom.config.set('editor.softWrapAtPreferredLineLength', true)
+    atom.config.set('editor.preferredLineLength', softWrapColumn)
+
+  it "properly renders soft-wrapped lines when randomly mutated", ->
+    previousSteps = JSON.parse(localStorage.steps ? '[]')
+
+    times 10, (i) ->
+      buffer = new TextBuffer
+      editor = new Editor({buffer})
+      editor.setEditorWidthInChars(80)
+      tokenizedBuffer = editor.displayBuffer.tokenizedBuffer
+      steps = []
+
+      times 30, ->
+        randomlyMutateEditor()
+        verifyLines()
+
+  verifyLines = ->
+    {bufferRows, screenLines} = getReferenceScreenLines()
+    for referenceBufferRow, screenRow in bufferRows
+      referenceScreenLine = screenLines[screenRow]
+      actualBufferRow = editor.bufferRowForScreenRow(screenRow)
+      unless actualBufferRow is referenceBufferRow
+        logLines()
+        throw new Error("Invalid buffer row #{actualBufferRow} for screen row #{screenRow}", )
+
+      actualScreenLine = editor.lineForScreenRow(screenRow)
+      unless actualScreenLine.text is referenceScreenLine.text
+        logLines()
+        throw new Error("Invalid line text at screen row #{screenRow}")
+
+  logLines = ->
+    console.log "==== screen lines ===="
+    editor.logScreenLines()
+    console.log "==== reference lines ===="
+    {bufferRows, screenLines} = getReferenceScreenLines()
+    for bufferRow, screenRow in bufferRows
+      console.log screenRow, bufferRow, screenLines[screenRow].text
+
+  randomlyMutateEditor = ->
+    if Math.random() < .2
+      softWrap = not editor.getSoftWrap()
+      steps.push(['setSoftWrap', softWrap])
+      editor.setSoftWrap(softWrap)
+    else
+      range = getRandomRange()
+      text = getRandomText()
+      steps.push(['setTextInBufferRange', range, text])
+      editor.setTextInBufferRange(range, text)
+
+  getRandomRange = ->
+    startRow = random(0, buffer.getLastRow())
+    startColumn = random(0, buffer.lineForRow(startRow).length)
+    endRow = random(startRow, buffer.getLastRow())
+    endColumn = random(0, buffer.lineForRow(endRow).length)
+    [[startRow, startColumn], [endRow, endColumn]]
+
+  getRandomText = ->
+    text = []
+    max = buffer.getText().split(/\s/).length * 0.75
+
+    times random(5, max), ->
+      if Math.random() < .1
+        text += '\n'
+      else
+        text += " " if /\w$/.test(text)
+        text += randomWords(exactly: 1)
+    text
+
+  getReferenceScreenLines = ->
+    if editor.getSoftWrap()
+      screenLines = []
+      bufferRows = []
+      for bufferRow in [0..tokenizedBuffer.getLastRow()]
+        for screenLine in softWrapLine(tokenizedBuffer.lineForScreenRow(bufferRow))
+          screenLines.push(screenLine)
+          bufferRows.push(bufferRow)
+    else
+      screenLines = tokenizedBuffer.tokenizedLines.slice()
+      bufferRows = [0..tokenizedBuffer.getLastRow()]
+    {screenLines, bufferRows}
+
+  softWrapLine = (tokenizedLine) ->
+    wrappedLines = []
+    while tokenizedLine.text.length > softWrapColumn and wrapScreenColumn = findWrapColumn(tokenizedLine.text)
+      [wrappedLine, tokenizedLine] = tokenizedLine.softWrapAt(wrapScreenColumn)
+      wrappedLines.push(wrappedLine)
+    wrappedLines.push(tokenizedLine)
+    wrappedLines
+
+  findWrapColumn = (line) ->
+    if /\s/.test(line[softWrapColumn])
+      # search forward for the start of a word past the boundary
+      for column in [softWrapColumn..line.length]
+        return column if /\S/.test(line[column])
+      return line.length
+    else
+      # search backward for the start of the word on the boundary
+      for column in [softWrapColumn..0]
+        return column + 1 if /\s/.test(line[column])
+      return softWrapColumn

spec/row-map-spec.coffee

@@ -6,256 +6,99 @@ describe "RowMap", ->
   beforeEach ->
     map = new RowMap
 
-  describe "when no mappings have been recorded", ->
-    it "maps buffer rows to screen rows 1:1", ->
+  describe "::screenRowRangeForBufferRow(bufferRow)", ->
+    it "returns the range of screen rows corresponding to the given buffer row", ->
+      map.spliceRegions(0, 0, [
+        {bufferRows: 5, screenRows: 5}
+        {bufferRows: 1, screenRows: 5}
+        {bufferRows: 5, screenRows: 5}
+        {bufferRows: 5, screenRows: 1}
+      ])
+
       expect(map.screenRowRangeForBufferRow(0)).toEqual [0, 1]
-      expect(map.screenRowRangeForBufferRow(100)).toEqual [100, 101]
+      expect(map.screenRowRangeForBufferRow(5)).toEqual [5, 10]
+      expect(map.screenRowRangeForBufferRow(6)).toEqual [10, 11]
+      expect(map.screenRowRangeForBufferRow(11)).toEqual [15, 16]
+      expect(map.screenRowRangeForBufferRow(12)).toEqual [15, 16]
+      expect(map.screenRowRangeForBufferRow(16)).toEqual [16, 17]
 
-  describe ".mapBufferRowRange(startBufferRow, endBufferRow, screenRows)", ->
-    describe "when mapping to a single screen row (like a visible fold)", ->
-      beforeEach ->
-        map.mapBufferRowRange(5, 10, 1)
-        map.mapBufferRowRange(15, 20, 1)
-        map.mapBufferRowRange(25, 30, 1)
+  describe "::bufferRowRangeForScreenRow(screenRow)", ->
+    it "returns the range of buffer rows corresponding to the given screen row", ->
+      map.spliceRegions(0, 0, [
+        {bufferRows: 5, screenRows: 5}
+        {bufferRows: 1, screenRows: 5}
+        {bufferRows: 5, screenRows: 5}
+        {bufferRows: 5, screenRows: 1}
+      ])
 
-      it "accounts for the mapping when translating buffer rows to screen row ranges", ->
-        expect(map.screenRowRangeForBufferRow(0)).toEqual [0, 1]
+      expect(map.bufferRowRangeForScreenRow(0)).toEqual [0, 1]
+      expect(map.bufferRowRangeForScreenRow(5)).toEqual [5, 6]
+      expect(map.bufferRowRangeForScreenRow(6)).toEqual [5, 6]
+      expect(map.bufferRowRangeForScreenRow(10)).toEqual [6, 7]
+      expect(map.bufferRowRangeForScreenRow(14)).toEqual [10, 11]
+      expect(map.bufferRowRangeForScreenRow(15)).toEqual [11, 16]
+      expect(map.bufferRowRangeForScreenRow(16)).toEqual [16, 17]
 
-        expect(map.screenRowRangeForBufferRow(4)).toEqual [4, 5]
-        expect(map.screenRowRangeForBufferRow(5)).toEqual [5, 6]
-        expect(map.screenRowRangeForBufferRow(9)).toEqual [5, 6]
-        expect(map.screenRowRangeForBufferRow(10)).toEqual [6, 7]
+  describe "::spliceRegions(startBufferRow, bufferRowCount, regions)", ->
+    it "can insert regions when empty", ->
+      regions = [
+        {bufferRows: 5, screenRows: 5}
+        {bufferRows: 1, screenRows: 5}
+        {bufferRows: 5, screenRows: 5}
+        {bufferRows: 5, screenRows: 1}
+      ]
+      map.spliceRegions(0, 0, regions)
+      expect(map.getRegions()).toEqual regions
 
-        expect(map.screenRowRangeForBufferRow(14)).toEqual [10, 11]
-        expect(map.screenRowRangeForBufferRow(15)).toEqual [11, 12]
-        expect(map.screenRowRangeForBufferRow(19)).toEqual [11, 12]
-        expect(map.screenRowRangeForBufferRow(20)).toEqual [12, 13]
+    it "can insert wrapped lines into rectangular regions", ->
+      map.spliceRegions(0, 0, [{bufferRows: 10, screenRows: 10}])
+      map.spliceRegions(5, 0, [{bufferRows: 1, screenRows: 3}])
+      expect(map.getRegions()).toEqual [
+        {bufferRows: 5, screenRows: 5}
+        {bufferRows: 1, screenRows: 3}
+        {bufferRows: 5, screenRows: 5}
+      ]
 
-        expect(map.screenRowRangeForBufferRow(24)).toEqual [16, 17]
-        expect(map.screenRowRangeForBufferRow(25)).toEqual [17, 18]
-        expect(map.screenRowRangeForBufferRow(29)).toEqual [17, 18]
-        expect(map.screenRowRangeForBufferRow(30)).toEqual [18, 19]
+    it "can splice wrapped lines into rectangular regions", ->
+      map.spliceRegions(0, 0, [{bufferRows: 10, screenRows: 10}])
+      map.spliceRegions(5, 1, [{bufferRows: 1, screenRows: 3}])
+      expect(map.getRegions()).toEqual [
+        {bufferRows: 5, screenRows: 5}
+        {bufferRows: 1, screenRows: 3}
+        {bufferRows: 4, screenRows: 4}
+      ]
 
-      it "accounts for the mapping when translating screen rows to buffer row ranges", ->
-        expect(map.bufferRowRangeForScreenRow(0)).toEqual [0, 1]
+    it "can splice folded lines into rectangular regions", ->
+      map.spliceRegions(0, 0, [{bufferRows: 10, screenRows: 10}])
+      map.spliceRegions(5, 3, [{bufferRows: 3, screenRows: 1}])
+      expect(map.getRegions()).toEqual [
+        {bufferRows: 5, screenRows: 5}
+        {bufferRows: 3, screenRows: 1}
+        {bufferRows: 2, screenRows: 2}
+      ]
 
-        expect(map.bufferRowRangeForScreenRow(4)).toEqual [4, 5]
-        expect(map.bufferRowRangeForScreenRow(5)).toEqual [5, 10]
-        expect(map.bufferRowRangeForScreenRow(6)).toEqual [10, 11]
+    it "can replace folded regions with a folded region that surrounds them", ->
+      map.spliceRegions(0, 0, [
+        {bufferRows: 3, screenRows: 3}
+        {bufferRows: 3, screenRows: 1}
+        {bufferRows: 1, screenRows: 1}
+        {bufferRows: 3, screenRows: 1}
+        {bufferRows: 3, screenRows: 3}
+      ])
+      map.spliceRegions(2, 8, [{bufferRows: 8, screenRows: 1}])
+      expect(map.getRegions()).toEqual [
+        {bufferRows: 2, screenRows: 2}
+        {bufferRows: 8, screenRows: 1}
+        {bufferRows: 3, screenRows: 3}
+      ]
 
-        expect(map.bufferRowRangeForScreenRow(10)).toEqual [14, 15]
-        expect(map.bufferRowRangeForScreenRow(11)).toEqual [15, 20]
-        expect(map.bufferRowRangeForScreenRow(12)).toEqual [20, 21]
+    it "merges adjacent rectangular regions", ->
+      map.spliceRegions(0, 0, [
+        {bufferRows: 3, screenRows: 3}
+        {bufferRows: 3, screenRows: 1}
+        {bufferRows: 1, screenRows: 1}
+        {bufferRows: 3, screenRows: 1}
+        {bufferRows: 3, screenRows: 3}
+      ])
 
-        expect(map.bufferRowRangeForScreenRow(16)).toEqual [24, 25]
-        expect(map.bufferRowRangeForScreenRow(17)).toEqual [25, 30]
-        expect(map.bufferRowRangeForScreenRow(18)).toEqual [30, 31]
-
-    describe "when mapping to zero screen rows (like an invisible fold)", ->
-      beforeEach ->
-        map.mapBufferRowRange(5, 10, 0)
-        map.mapBufferRowRange(15, 20, 0)
-        map.mapBufferRowRange(25, 30, 0)
-
-      it "accounts for the mapping when translating buffer rows to screen row ranges", ->
-        expect(map.screenRowRangeForBufferRow(0)).toEqual [0, 1]
-
-        expect(map.screenRowRangeForBufferRow(4)).toEqual [4, 5]
-        expect(map.screenRowRangeForBufferRow(5)).toEqual [5, 5]
-        expect(map.screenRowRangeForBufferRow(9)).toEqual [5, 5]
-        expect(map.screenRowRangeForBufferRow(10)).toEqual [5, 6]
-
-        expect(map.screenRowRangeForBufferRow(14)).toEqual [9, 10]
-        expect(map.screenRowRangeForBufferRow(15)).toEqual [10, 10]
-        expect(map.screenRowRangeForBufferRow(19)).toEqual [10, 10]
-        expect(map.screenRowRangeForBufferRow(20)).toEqual [10, 11]
-
-        expect(map.screenRowRangeForBufferRow(24)).toEqual [14, 15]
-        expect(map.screenRowRangeForBufferRow(25)).toEqual [15, 15]
-        expect(map.screenRowRangeForBufferRow(29)).toEqual [15, 15]
-        expect(map.screenRowRangeForBufferRow(30)).toEqual [15, 16]
-
-      it "accounts for the mapping when translating screen rows to buffer row ranges", ->
-        expect(map.bufferRowRangeForScreenRow(0)).toEqual [0, 1]
-
-        expect(map.bufferRowRangeForScreenRow(4)).toEqual [4, 5]
-        expect(map.bufferRowRangeForScreenRow(5)).toEqual [10, 11]
-
-        expect(map.bufferRowRangeForScreenRow(9)).toEqual [14, 15]
-        expect(map.bufferRowRangeForScreenRow(10)).toEqual [20, 21]
-
-        expect(map.bufferRowRangeForScreenRow(14)).toEqual [24, 25]
-        expect(map.bufferRowRangeForScreenRow(15)).toEqual [30, 31]
-
-    describe "when mapping a single buffer row to multiple screen rows (like a wrapped line)", ->
-      beforeEach ->
-        map.mapBufferRowRange(5, 6, 3)
-        map.mapBufferRowRange(10, 11, 2)
-        map.mapBufferRowRange(20, 21, 5)
-
-      it "accounts for the mapping when translating buffer rows to screen row ranges", ->
-        expect(map.screenRowRangeForBufferRow(0)).toEqual [0, 1]
-
-        expect(map.screenRowRangeForBufferRow(4)).toEqual [4, 5]
-        expect(map.screenRowRangeForBufferRow(5)).toEqual [5, 8]
-        expect(map.screenRowRangeForBufferRow(6)).toEqual [8, 9]
-
-        expect(map.screenRowRangeForBufferRow(9)).toEqual [11, 12]
-        expect(map.screenRowRangeForBufferRow(10)).toEqual [12, 14]
-        expect(map.screenRowRangeForBufferRow(11)).toEqual [14, 15]
-
-        expect(map.screenRowRangeForBufferRow(19)).toEqual [22, 23]
-        expect(map.screenRowRangeForBufferRow(20)).toEqual [23, 28]
-        expect(map.screenRowRangeForBufferRow(21)).toEqual [28, 29]
-
-      it "accounts for the mapping when translating screen rows to buffer row ranges", ->
-        expect(map.bufferRowRangeForScreenRow(0)).toEqual [0, 1]
-
-        expect(map.bufferRowRangeForScreenRow(4)).toEqual [4, 5]
-        expect(map.bufferRowRangeForScreenRow(5)).toEqual [5, 6]
-        expect(map.bufferRowRangeForScreenRow(7)).toEqual [5, 6]
-        expect(map.bufferRowRangeForScreenRow(8)).toEqual [6, 7]
-
-        expect(map.bufferRowRangeForScreenRow(11)).toEqual [9, 10]
-        expect(map.bufferRowRangeForScreenRow(12)).toEqual [10, 11]
-        expect(map.bufferRowRangeForScreenRow(13)).toEqual [10, 11]
-        expect(map.bufferRowRangeForScreenRow(14)).toEqual [11, 12]
-
-        expect(map.bufferRowRangeForScreenRow(22)).toEqual [19, 20]
-        expect(map.bufferRowRangeForScreenRow(23)).toEqual [20, 21]
-        expect(map.bufferRowRangeForScreenRow(27)).toEqual [20, 21]
-        expect(map.bufferRowRangeForScreenRow(28)).toEqual [21, 22]
-
-      describe "after re-mapping a row range to a new number of screen rows", ->
-        beforeEach ->
-          map.applyScreenDelta(12, 2) # simulate adding 2 more soft wraps
-          map.mapBufferRowRange(10, 11, 4)
-
-        it "updates translation accordingly", ->
-          expect(map.screenRowRangeForBufferRow(4)).toEqual [4, 5]
-          expect(map.screenRowRangeForBufferRow(5)).toEqual [5, 8]
-          expect(map.screenRowRangeForBufferRow(6)).toEqual [8, 9]
-
-          expect(map.screenRowRangeForBufferRow(9)).toEqual [11, 12]
-          expect(map.screenRowRangeForBufferRow(10)).toEqual [12, 16]
-          expect(map.screenRowRangeForBufferRow(11)).toEqual [16, 17]
-
-          expect(map.screenRowRangeForBufferRow(19)).toEqual [24, 25]
-          expect(map.screenRowRangeForBufferRow(20)).toEqual [25, 30]
-          expect(map.screenRowRangeForBufferRow(21)).toEqual [30, 31]
-
-    describe "when the row range is inside an existing 1:1 region", ->
-      it "preserves the starting screen row of subsequent 1:N regions", ->
-        map.mapBufferRowRange(5, 10, 1)
-        map.mapBufferRowRange(25, 30, 1)
-
-        expect(map.bufferRowRangeForScreenRow(5)).toEqual [5, 10]
-        expect(map.bufferRowRangeForScreenRow(21)).toEqual [25, 30]
-
-        map.mapBufferRowRange(15, 20, 1)
-
-        expect(map.bufferRowRangeForScreenRow(11)).toEqual [15, 20]
-        expect(map.bufferRowRangeForScreenRow(5)).toEqual [5, 10]
-        expect(map.bufferRowRangeForScreenRow(21)).toEqual [25, 30]
-
-    describe "when the row range surrounds existing regions", ->
-      it "replaces the regions inside the given buffer row range with a single region", ->
-        map.mapBufferRowRange(5, 10, 1)  # inner fold 1
-        map.mapBufferRowRange(11, 13, 1)  # inner fold 2
-        map.mapBufferRowRange(15, 20, 1) # inner fold 3
-        map.mapBufferRowRange(22, 27, 1) # following fold
-
-        map.mapBufferRowRange(5, 20, 1)
-
-        expect(map.bufferRowRangeForScreenRow(5)).toEqual [5, 20]
-        expect(map.bufferRowRangeForScreenRow(6)).toEqual [20, 21]
-        expect(map.bufferRowRangeForScreenRow(7)).toEqual [21, 22]
-        expect(map.bufferRowRangeForScreenRow(8)).toEqual [22, 27]
-
-      it "replaces regions that cover 0 buffer rows at the start or end of the buffer row range", ->
-        map.mapBufferRowRange(0, 0, 1)
-        map.mapBufferRowRange(0, 1, 1)
-        map.mapBufferRowRange(1, 1, 1)
-        map.mapBufferRowRange(0, 1, 3)
-        expect(map.screenRowRangeForBufferRow(0)).toEqual [0, 3]
-
-    describe "when the row range straddles existing regions", ->
-      it "splits the straddled regions and places the new region between them", ->
-                                         # filler region 0
-        map.mapBufferRowRange(4, 7, 1)   # region 1
-                                         # filler region 2
-        map.mapBufferRowRange(13, 15, 1) # region 3
-
-        # create region straddling region 0 and region 2
-        map.mapBufferRowRange(2, 10, 1)
-
-        expect(map.regions[0]).toEqual(bufferRows: 2, screenRows: 2)
-        expect(map.regions[1]).toEqual(bufferRows: 8, screenRows: 1)
-        expect(map.regions[2]).toEqual(bufferRows: 3, screenRows: 8)
-        expect(map.regions[3]).toEqual(bufferRows: 2, screenRows: 1)
-
-    it "merges adjacent isomorphic mappings", ->
-      map.mapBufferRowRange(2, 4, 1)
-      map.mapBufferRowRange(4, 5, 2)
-
-      map.mapBufferRowRange(1, 4, 3)
-      expect(map.regions).toEqual [{bufferRows: 5, screenRows: 5}]
-
-  describe ".applyBufferDelta(startBufferRow, delta)", ->
-    describe "when applying a positive delta", ->
-      it "expands the region containing the given start row by the given delta", ->
-        map.mapBufferRowRange(4, 8, 1)
-
-        map.applyBufferDelta(5, 4)
-
-        expect(map.regions[0]).toEqual(bufferRows: 4, screenRows: 4)
-        expect(map.regions[1]).toEqual(bufferRows: 8, screenRows: 1)
-
-    describe "when applying a negative delta", ->
-      it "shrinks regions starting at the start row until the entire delta is consumed", ->
-        map.mapBufferRowRange(4, 8, 1)
-        map.mapBufferRowRange(10, 14, 1)
-
-        map.applyBufferDelta(3, -6)
-
-        expect(map.regions[0]).toEqual(bufferRows: 3, screenRows: 4)
-        expect(map.regions[1]).toEqual(bufferRows: 0, screenRows: 1)
-        expect(map.regions[2]).toEqual(bufferRows: 1, screenRows: 2)
-        expect(map.regions[3]).toEqual(bufferRows: 4, screenRows: 1)
-
-  describe ".applyScreenDelta(startScreenRow, delta)", ->
-    describe "when applying a positive delta", ->
-      it "can enlarge the screen side of existing regions", ->
-        map.mapBufferRowRange(5, 6, 3) # wrapped line
-        map.applyScreenDelta(5, 2) # wrap it twice more
-        expect(map.screenRowRangeForBufferRow(5)).toEqual [5, 10]
-
-    describe "when applying a negative delta", ->
-      it "can collapse the screen side of multiple regions to 0 until the entire delta has been applied", ->
-        map.mapBufferRowRange(5, 10, 1)  # inner fold 1
-        map.mapBufferRowRange(11, 13, 1)  # inner fold 2
-        map.mapBufferRowRange(15, 20, 1) # inner fold 3
-        map.mapBufferRowRange(22, 27, 1) # following fold
-
-        map.applyScreenDelta(6, -5)
-
-        expect(map.screenRowRangeForBufferRow(5)).toEqual [5, 6]
-        expect(map.screenRowRangeForBufferRow(9)).toEqual [5, 6]
-        expect(map.screenRowRangeForBufferRow(10)).toEqual [6, 6]
-        expect(map.screenRowRangeForBufferRow(19)).toEqual [6, 6]
-        expect(map.screenRowRangeForBufferRow(22)).toEqual [8, 9]
-        expect(map.screenRowRangeForBufferRow(26)).toEqual [8, 9]
-
-      it "starts collapsing the first region at the start row, not before", ->
-        map.mapBufferRowRange(5, 6, 4)
-        map.mapBufferRowRange(11, 13, 1)
-
-        map.applyScreenDelta(7, -5)
-
-        expect(map.regions[0]).toEqual(bufferRows: 5, screenRows: 5)
-        expect(map.regions[1]).toEqual(bufferRows: 1, screenRows: 2)
-        expect(map.regions[2]).toEqual(bufferRows: 5, screenRows: 2)
-
-    it "does not throw an exception when applying a delta beyond the last region", ->
-      map.mapBufferRowRange(5, 10, 1)  # inner fold 1
-      map.applyScreenDelta(15, 10)
+      map.spliceRegions(3, 7, [{bufferRows: 5, screenRows: 5}])

spec/select-list-view-spec.coffee

@@ -1,26 +1,26 @@
-SelectList = require '../src/select-list'
+SelectListView = require '../src/select-list-view'
 {$, $$} = require 'atom'
 
-describe "SelectList", ->
-  [selectList, array, list, miniEditor] = []
+describe "SelectListView", ->
+  [selectList, items, list, filterEditorView] = []
 
   beforeEach ->
-    array = [
+    items = [
       ["A", "Alpha"], ["B", "Bravo"], ["C", "Charlie"],
       ["D", "Delta"], ["E", "Echo"], ["F", "Foxtrot"]
     ]
 
-    selectList = new SelectList
-    selectList.maxItems = 4
-    selectList.filterKey = 1
-    selectList.itemForElement = (element) ->
-      $$ -> @li element[1], class: element[0]
+    selectList = new SelectListView
+    selectList.setMaxItems(4)
+    selectList.getFilterKey = -> 1
+    selectList.viewForItem = (item) ->
+      $$ -> @li item[1], class: item[0]
 
     selectList.confirmed = jasmine.createSpy('confirmed hook')
     selectList.cancelled = jasmine.createSpy('cancelled hook')
 
-    selectList.setArray(array)
-    {list, miniEditor} = selectList
+    selectList.setItems(items)
+    {list, filterEditorView} = selectList
 
   describe "when an array is assigned", ->
     it "populates the list with up to maxItems items, based on the liForElement function", ->
@@ -28,12 +28,27 @@ describe "SelectList", ->
       expect(list.find('li:eq(0)')).toHaveText 'Alpha'
       expect(list.find('li:eq(0)')).toHaveClass 'A'
 
+  describe "viewForItem(item)", ->
+    it "allows raw DOM elements to be returned", ->
+      selectList.viewForItem = (item) ->
+        li = document.createElement('li')
+        li.classList.add(item[0])
+        li.innerText = item[1]
+        li
+
+      selectList.setItems(items)
+
+      expect(list.find('li').length).toBe selectList.maxItems
+      expect(list.find('li:eq(0)')).toHaveText 'Alpha'
+      expect(list.find('li:eq(0)')).toHaveClass 'A'
+      expect(selectList.getSelectedItem()).toBe items[0]
+
   describe "when the text of the mini editor changes", ->
     beforeEach ->
       selectList.attachToDom()
 
     it "filters the elements in the list based on the scoreElement function and selects the first item", ->
-      miniEditor.insertText('la')
+      filterEditorView.getEditor().insertText('la')
       window.advanceClock(selectList.inputThrottle)
 
       expect(list.find('li').length).toBe 2
@@ -43,54 +58,54 @@ describe "SelectList", ->
       expect(selectList.error).not.toBeVisible()
 
     it "displays an error if there are no matches, removes error when there are matches", ->
-      miniEditor.insertText('nothing will match this')
+      filterEditorView.getEditor().insertText('nothing will match this')
       window.advanceClock(selectList.inputThrottle)
 
       expect(list.find('li').length).toBe 0
       expect(selectList.error).not.toBeHidden()
 
-      miniEditor.setText('la')
+      filterEditorView.getEditor().setText('la')
       window.advanceClock(selectList.inputThrottle)
 
       expect(list.find('li').length).toBe 2
       expect(selectList.error).not.toBeVisible()
 
     it "displays no elements until the array has been set on the list", ->
-      selectList.array = null
+      selectList.items = null
       selectList.list.empty()
-      miniEditor.insertText('la')
+      filterEditorView.getEditor().insertText('la')
       window.advanceClock(selectList.inputThrottle)
 
       expect(list.find('li').length).toBe 0
       expect(selectList.error).toBeHidden()
-      selectList.setArray(array)
+      selectList.setItems(items)
       expect(list.find('li').length).toBe 2
 
-  describe "when core:move-up / core:move-down are triggered on the miniEditor", ->
+  describe "when core:move-up / core:move-down are triggered on the filterEditorView", ->
     it "selects the previous / next item in the list, or wraps around to the other side", ->
       expect(list.find('li:first')).toHaveClass 'selected'
 
-      miniEditor.trigger 'core:move-up'
+      filterEditorView.trigger 'core:move-up'
 
       expect(list.find('li:first')).not.toHaveClass 'selected'
       expect(list.find('li:last')).toHaveClass 'selected'
 
-      miniEditor.trigger 'core:move-down'
+      filterEditorView.trigger 'core:move-down'
 
       expect(list.find('li:first')).toHaveClass 'selected'
       expect(list.find('li:last')).not.toHaveClass 'selected'
 
-      miniEditor.trigger 'core:move-down'
+      filterEditorView.trigger 'core:move-down'
 
       expect(list.find('li:eq(0)')).not.toHaveClass 'selected'
       expect(list.find('li:eq(1)')).toHaveClass 'selected'
 
-      miniEditor.trigger 'core:move-down'
+      filterEditorView.trigger 'core:move-down'
 
       expect(list.find('li:eq(1)')).not.toHaveClass 'selected'
       expect(list.find('li:eq(2)')).toHaveClass 'selected'
 
-      miniEditor.trigger 'core:move-up'
+      filterEditorView.trigger 'core:move-up'
 
       expect(list.find('li:eq(2)')).not.toHaveClass 'selected'
       expect(list.find('li:eq(1)')).toHaveClass 'selected'
@@ -100,43 +115,43 @@ describe "SelectList", ->
       itemHeight = list.find('li').outerHeight()
       list.height(itemHeight * 2)
 
-      miniEditor.trigger 'core:move-down'
-      miniEditor.trigger 'core:move-down'
+      filterEditorView.trigger 'core:move-down'
+      filterEditorView.trigger 'core:move-down'
       expect(list.scrollBottom()).toBe itemHeight * 3
 
-      miniEditor.trigger 'core:move-down'
+      filterEditorView.trigger 'core:move-down'
       expect(list.scrollBottom()).toBe itemHeight * 4
 
-      miniEditor.trigger 'core:move-up'
-      miniEditor.trigger 'core:move-up'
+      filterEditorView.trigger 'core:move-up'
+      filterEditorView.trigger 'core:move-up'
       expect(list.scrollTop()).toBe itemHeight
 
   describe "the core:confirm event", ->
     describe "when there is an item selected (because the list in not empty)", ->
       it "triggers the selected hook with the selected array element", ->
-        miniEditor.trigger 'core:move-down'
-        miniEditor.trigger 'core:move-down'
-        miniEditor.trigger 'core:confirm'
-        expect(selectList.confirmed).toHaveBeenCalledWith(array[2])
+        filterEditorView.trigger 'core:move-down'
+        filterEditorView.trigger 'core:move-down'
+        filterEditorView.trigger 'core:confirm'
+        expect(selectList.confirmed).toHaveBeenCalledWith(items[2])
 
     describe "when there is no item selected (because the list is empty)", ->
       beforeEach ->
         selectList.attachToDom()
 
       it "does not trigger the confirmed hook", ->
-        miniEditor.insertText("i will never match anything")
+        filterEditorView.getEditor().insertText("i will never match anything")
         window.advanceClock(selectList.inputThrottle)
 
         expect(list.find('li')).not.toExist()
-        miniEditor.trigger 'core:confirm'
+        filterEditorView.trigger 'core:confirm'
         expect(selectList.confirmed).not.toHaveBeenCalled()
 
       it "does trigger the cancelled hook", ->
-        miniEditor.insertText("i will never match anything")
+        filterEditorView.getEditor().insertText("i will never match anything")
         window.advanceClock(selectList.inputThrottle)
 
         expect(list.find('li')).not.toExist()
-        miniEditor.trigger 'core:confirm'
+        filterEditorView.trigger 'core:confirm'
         expect(selectList.cancelled).toHaveBeenCalled()
 
   describe "when a list item is clicked", ->
@@ -147,12 +162,12 @@ describe "SelectList", ->
       expect(item).toHaveClass 'selected'
       item.mouseup()
 
-      expect(selectList.confirmed).toHaveBeenCalledWith(array[1])
+      expect(selectList.confirmed).toHaveBeenCalledWith(items[1])
 
   describe "the core:cancel event", ->
     it "triggers the cancelled hook and detaches and empties the select list", ->
       spyOn(selectList, 'detach')
-      miniEditor.trigger 'core:cancel'
+      filterEditorView.trigger 'core:cancel'
       expect(selectList.cancelled).toHaveBeenCalled()
       expect(selectList.detach).toHaveBeenCalled()
       expect(selectList.list).toBeEmpty()
@@ -160,7 +175,7 @@ describe "SelectList", ->
   describe "when the mini editor loses focus", ->
     it "triggers the cancelled hook and detaches the select list", ->
       spyOn(selectList, 'detach')
-      miniEditor.hiddenInput.trigger 'focusout'
+      filterEditorView.hiddenInput.trigger 'focusout'
       expect(selectList.cancelled).toHaveBeenCalled()
       expect(selectList.detach).toHaveBeenCalled()
 

spec/space-pen-extensions-spec.coffee

@@ -11,35 +11,6 @@ describe "SpacePen extensions", ->
     parent = $$ -> @div()
     parent.append(view)
 
-  describe "View.observeConfig(keyPath, callback)", ->
-    observeHandler = null
-
-    beforeEach ->
-      observeHandler = jasmine.createSpy("observeHandler")
-      view.observeConfig "foo.bar", observeHandler
-      expect(view.hasParent()).toBeTruthy()
-
-    it "observes the keyPath and cancels the subscription when `.unobserveConfig()` is called", ->
-      expect(observeHandler).toHaveBeenCalledWith(undefined)
-      observeHandler.reset()
-
-      atom.config.set("foo.bar", "hello")
-
-      expect(observeHandler).toHaveBeenCalledWith("hello", previous: undefined)
-      observeHandler.reset()
-
-      view.unobserveConfig()
-
-      atom.config.set("foo.bar", "goodbye")
-
-      expect(observeHandler).not.toHaveBeenCalled()
-
-    it "unobserves when the view is removed", ->
-      observeHandler.reset()
-      parent.remove()
-      atom.config.set("foo.bar", "hello")
-      expect(observeHandler).not.toHaveBeenCalled()
-
   describe "View.subscribe(eventEmitter, eventName, callback)", ->
     [emitter, eventHandler] = []
 
@@ -65,3 +36,19 @@ describe "SpacePen extensions", ->
 
       it "replaces multiple keystroke", ->
         expect(humanizeKeystrokes('cmd-o ctrl-2')).toEqual '⌘O ⌃2'
+
+    describe "when the window is resized", ->
+      it "hides the tooltips", ->
+        class TooltipView extends View
+          @content: ->
+            @div()
+
+        view = new TooltipView()
+        view.attachToDom()
+        view.setTooltip('this is a tip')
+
+        view.tooltip('show')
+        expect($(document.body).find('.tooltip')).toBeVisible()
+
+        $(window).trigger('resize')
+        expect($(document.body).find('.tooltip')).not.toExist()

spec/spec-bootstrap.coffee

@@ -5,7 +5,11 @@ try
   require '../src/window'
   Atom = require '../src/atom'
   window.atom = Atom.loadOrCreate('spec')
-  window.atom.show() unless atom.getLoadSettings().exitWhenDone
+
+  # Show window synchronously so a focusout doesn't fire on input elements
+  # that are focused in the very first spec run.
+  atom.getCurrentWindow().show() unless atom.getLoadSettings().exitWhenDone
+
   {runSpecSuite} = require './jasmine-helper'
 
   document.title = "Spec Suite"

spec/spec-helper.coffee

@@ -4,7 +4,7 @@ atom.restoreWindowDimensions()
 
 require '../vendor/jasmine-jquery'
 path = require 'path'
-{_, $, File, WorkspaceView, fs} = require 'atom'
+{_, $, WorkspaceView, fs} = require 'atom'
 Keymap = require '../src/keymap'
 Config = require '../src/config'
 {Point} = require 'text-buffer'
@@ -41,7 +41,7 @@ specProjectPath = null
 if specDirectory
   specPackagePath = path.resolve(specDirectory, '..')
   try
-    specPackageName = fs.readObjectSync(path.join(specPackagePath, 'package.json'))?.name
+    specPackageName = JSON.parse(fs.readFileSync(path.join(specPackagePath, 'package.json')))?.name
   specProjectPath = path.join(specDirectory, 'fixtures')
 
 beforeEach ->
@@ -88,16 +88,16 @@ beforeEach ->
   spyOn(WorkspaceView.prototype, 'setTitle').andCallFake (@title) ->
   spyOn(window, "setTimeout").andCallFake window.fakeSetTimeout
   spyOn(window, "clearTimeout").andCallFake window.fakeClearTimeout
-  spyOn(File.prototype, "detectResurrectionAfterDelay").andCallFake -> @detectResurrection()
+  spyOn(pathwatcher.File.prototype, "detectResurrectionAfterDelay").andCallFake -> @detectResurrection()
   spyOn(Editor.prototype, "shouldPromptToSave").andReturn false
 
   # make tokenization synchronous
   TokenizedBuffer.prototype.chunkSize = Infinity
   spyOn(TokenizedBuffer.prototype, "tokenizeInBackground").andCallFake -> @tokenizeNextChunk()
 
-  pasteboardContent = 'initial pasteboard content'
-  spyOn(clipboard, 'writeText').andCallFake (text) -> pasteboardContent = text
-  spyOn(clipboard, 'readText').andCallFake -> pasteboardContent
+  clipboardContent = 'initial clipboard content'
+  spyOn(clipboard, 'writeText').andCallFake (text) -> clipboardContent = text
+  spyOn(clipboard, 'readText').andCallFake -> clipboardContent
 
   addCustomMatchers(this)
 
@@ -107,7 +107,7 @@ afterEach ->
 
   atom.workspaceView?.remove?()
   atom.workspaceView = null
-  delete atom.state.workspaceView
+  delete atom.state.workspace
 
   atom.project?.destroy?()
   atom.project = null
@@ -159,6 +159,16 @@ addCustomMatchers = (spec) ->
       @message = -> return "Expected path '" + @actual + "'" + notText + " to exist."
       fs.existsSync(@actual)
 
+    toHaveFocus: ->
+      notText = this.isNot and " not" or ""
+      if not document.hasFocus()
+        console.error "Specs will fail because the Dev Tools have focus. To fix this close the Dev Tools or click the spec runner."
+
+      @message = -> return "Expected element '" + @actual + "' or its descendants" + notText + " to have focus."
+      element = @actual
+      element = element.get(0) if element.jquery
+      element.webkitMatchesSelector(":focus") or element.querySelector(":focus")
+
 window.keyIdentifierForKey = (key) ->
   if key.length > 1 # named key
     key

spec/syntax-spec.coffee

@@ -4,10 +4,18 @@ temp = require 'temp'
 
 describe "the `syntax` global", ->
   beforeEach ->
-    atom.packages.activatePackage('language-text', sync: true)
-    atom.packages.activatePackage('language-javascript', sync: true)
-    atom.packages.activatePackage('language-coffee-script', sync: true)
-    atom.packages.activatePackage('language-ruby', sync: true)
+
+    waitsForPromise ->
+      atom.packages.activatePackage('language-text')
+
+    waitsForPromise ->
+      atom.packages.activatePackage('language-javascript')
+
+    waitsForPromise ->
+      atom.packages.activatePackage('language-coffee-script')
+
+    waitsForPromise ->
+      atom.packages.activatePackage('language-ruby')
 
   describe "serialization", ->
     it "remembers grammar overrides by path", ->
@@ -20,29 +28,33 @@ describe "the `syntax` global", ->
 
   describe ".selectGrammar(filePath)", ->
     it "can use the filePath to load the correct grammar based on the grammar's filetype", ->
-      atom.packages.activatePackage('language-git', sync: true)
+      waitsForPromise ->
+        atom.packages.activatePackage('language-git')
 
-      expect(atom.syntax.selectGrammar("file.js").name).toBe "JavaScript" # based on extension (.js)
-      expect(atom.syntax.selectGrammar(path.join(temp.dir, '.git', 'config')).name).toBe "Git Config" # based on end of the path (.git/config)
-      expect(atom.syntax.selectGrammar("Rakefile").name).toBe "Ruby" # based on the file's basename (Rakefile)
-      expect(atom.syntax.selectGrammar("curb").name).toBe "Null Grammar"
-      expect(atom.syntax.selectGrammar("/hu.git/config").name).toBe "Null Grammar"
+      runs ->
+        expect(atom.syntax.selectGrammar("file.js").name).toBe "JavaScript" # based on extension (.js)
+        expect(atom.syntax.selectGrammar(path.join(temp.dir, '.git', 'config')).name).toBe "Git Config" # based on end of the path (.git/config)
+        expect(atom.syntax.selectGrammar("Rakefile").name).toBe "Ruby" # based on the file's basename (Rakefile)
+        expect(atom.syntax.selectGrammar("curb").name).toBe "Null Grammar"
+        expect(atom.syntax.selectGrammar("/hu.git/config").name).toBe "Null Grammar"
 
     it "uses the filePath's shebang line if the grammar cannot be determined by the extension or basename", ->
       filePath = require.resolve("./fixtures/shebang")
       expect(atom.syntax.selectGrammar(filePath).name).toBe "Ruby"
 
     it "uses the number of newlines in the first line regex to determine the number of lines to test against", ->
-      atom.packages.activatePackage('language-property-list', sync: true)
+      waitsForPromise ->
+        atom.packages.activatePackage('language-property-list')
 
-      fileContent = "first-line\n<html>"
-      expect(atom.syntax.selectGrammar("dummy.coffee", fileContent).name).toBe "CoffeeScript"
+      runs ->
+        fileContent = "first-line\n<html>"
+        expect(atom.syntax.selectGrammar("dummy.coffee", fileContent).name).toBe "CoffeeScript"
 
-      fileContent = '<?xml version="1.0" encoding="UTF-8"?>'
-      expect(atom.syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Null Grammar"
+        fileContent = '<?xml version="1.0" encoding="UTF-8"?>'
+        expect(atom.syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Null Grammar"
 
-      fileContent += '\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
-      expect(atom.syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Property List (XML)"
+        fileContent += '\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
+        expect(atom.syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Property List (XML)"
 
     it "doesn't read the file when the file contents are specified", ->
       filePath = require.resolve("./fixtures/shebang")

spec/theme-manager-spec.coffee

@@ -1,8 +1,10 @@
 path = require 'path'
+
 {$, $$, fs, WorkspaceView} = require 'atom'
+temp = require 'temp'
 
 ThemeManager = require '../src/theme-manager'
-AtomPackage = require '../src/atom-package'
+Package = require '../src/package'
 
 describe "ThemeManager", ->
   themeManager = null
@@ -24,11 +26,14 @@ describe "ThemeManager", ->
       expect(themes.length).toBeGreaterThan(2)
 
     it 'getActiveThemes get all the active themes', ->
-      themeManager.activateThemes()
-      names = atom.config.get('core.themes')
-      expect(names.length).toBeGreaterThan(0)
-      themes = themeManager.getActiveThemes()
-      expect(themes).toHaveLength(names.length)
+      waitsForPromise ->
+        themeManager.activateThemes()
+
+      runs ->
+        names = atom.config.get('core.themes')
+        expect(names.length).toBeGreaterThan(0)
+        themes = themeManager.getActiveThemes()
+        expect(themes).toHaveLength(names.length)
 
   describe "getImportPaths()", ->
     it "returns the theme directories before the themes are loaded", ->
@@ -38,8 +43,8 @@ describe "ThemeManager", ->
 
       # syntax theme is not a dir at this time, so only two.
       expect(paths.length).toBe 2
-      expect(paths[0]).toContain 'atom-dark-ui'
-      expect(paths[1]).toContain 'atom-light-ui'
+      expect(paths[0]).toContain 'atom-light-ui'
+      expect(paths[1]).toContain 'atom-dark-ui'
 
     it "ignores themes that cannot be resolved to a directory", ->
       atom.config.set('core.themes', ['definitely-not-a-theme'])
@@ -49,29 +54,58 @@ describe "ThemeManager", ->
     it "add/removes stylesheets to reflect the new config value", ->
       themeManager.on 'reloaded', reloadHandler = jasmine.createSpy()
       spyOn(themeManager, 'getUserStylesheetPath').andCallFake -> null
-      themeManager.activateThemes()
 
-      atom.config.set('core.themes', [])
-      expect($('style.theme').length).toBe 0
-      expect(reloadHandler).toHaveBeenCalled()
+      waitsForPromise ->
+        themeManager.activateThemes()
 
-      atom.config.set('core.themes', ['atom-dark-syntax'])
-      expect($('style.theme').length).toBe 1
-      expect($('style.theme:eq(0)').attr('id')).toMatch /atom-dark-syntax/
+      runs ->
+        reloadHandler.reset()
+        atom.config.set('core.themes', [])
 
-      atom.config.set('core.themes', ['atom-light-syntax', 'atom-dark-syntax'])
-      expect($('style.theme').length).toBe 2
-      expect($('style.theme:eq(0)').attr('id')).toMatch /atom-dark-syntax/
-      expect($('style.theme:eq(1)').attr('id')).toMatch /atom-light-syntax/
+      waitsFor ->
+        reloadHandler.callCount == 1
 
-      atom.config.set('core.themes', [])
-      expect($('style.theme').length).toBe 0
+      runs ->
+        reloadHandler.reset()
+        expect($('style.theme')).toHaveLength 0
+        atom.config.set('core.themes', ['atom-dark-syntax'])
 
-      # atom-dark-ui has an directory path, the syntax one doesn't
-      atom.config.set('core.themes', ['theme-with-index-less', 'atom-dark-ui'])
-      importPaths = themeManager.getImportPaths()
-      expect(importPaths.length).toBe 1
-      expect(importPaths[0]).toContain 'atom-dark-ui'
+      waitsFor ->
+        reloadHandler.callCount == 1
+
+      runs ->
+        reloadHandler.reset()
+        expect($('style.theme')).toHaveLength 1
+        expect($('style.theme:eq(0)').attr('id')).toMatch /atom-dark-syntax/
+        atom.config.set('core.themes', ['atom-light-syntax', 'atom-dark-syntax'])
+
+      waitsFor ->
+        reloadHandler.callCount == 1
+
+      runs ->
+        reloadHandler.reset()
+        expect($('style.theme')).toHaveLength 2
+        expect($('style.theme:eq(0)').attr('id')).toMatch /atom-dark-syntax/
+        expect($('style.theme:eq(1)').attr('id')).toMatch /atom-light-syntax/
+        atom.config.set('core.themes', [])
+
+      waitsFor ->
+        reloadHandler.callCount == 1
+
+      runs ->
+        reloadHandler.reset()
+        expect($('style.theme')).toHaveLength 0
+        # atom-dark-ui has an directory path, the syntax one doesn't
+        atom.config.set('core.themes', ['theme-with-index-less', 'atom-dark-ui'])
+
+      waitsFor ->
+        reloadHandler.callCount == 1
+
+      runs ->
+        expect($('style.theme')).toHaveLength 2
+        importPaths = themeManager.getImportPaths()
+        expect(importPaths.length).toBe 1
+        expect(importPaths[0]).toContain 'atom-dark-ui'
 
   describe "when a theme fails to load", ->
     it "logs a warning", ->
@@ -143,15 +177,61 @@ describe "ThemeManager", ->
       atom.workspaceView = new WorkspaceView
       atom.workspaceView.append $$ -> @div class: 'editor'
       atom.workspaceView.attachToDom()
-      themeManager.activateThemes()
+
+      waitsForPromise ->
+        themeManager.activateThemes()
 
     it "loads the correct values from the theme's ui-variables file", ->
+      themeManager.on 'reloaded', reloadHandler = jasmine.createSpy()
       atom.config.set('core.themes', ['theme-with-ui-variables'])
 
-      # an override loaded in the base css
-      expect(atom.workspaceView.css("background-color")).toBe "rgb(0, 0, 255)"
+      waitsFor ->
+        reloadHandler.callCount > 0
 
-      # from within the theme itself
-      expect($(".editor").css("padding-top")).toBe "150px"
-      expect($(".editor").css("padding-right")).toBe "150px"
-      expect($(".editor").css("padding-bottom")).toBe "150px"
+      runs ->
+        # an override loaded in the base css
+        expect(atom.workspaceView.css("background-color")).toBe "rgb(0, 0, 255)"
+
+        # from within the theme itself
+        expect($(".editor").css("padding-top")).toBe "150px"
+        expect($(".editor").css("padding-right")).toBe "150px"
+        expect($(".editor").css("padding-bottom")).toBe "150px"
+
+  describe "when the user stylesheet changes", ->
+    it "reloads it", ->
+      userStylesheetPath = path.join(temp.mkdirSync("atom"), 'styles.css')
+      fs.writeFileSync(userStylesheetPath, 'body {border-style: dotted !important;}')
+
+      spyOn(themeManager, 'getUserStylesheetPath').andReturn userStylesheetPath
+
+      waitsForPromise ->
+        themeManager.activateThemes()
+
+      runs ->
+        expect($(document.body).css('border-style')).toBe 'dotted'
+        spyOn(themeManager, 'loadUserStylesheet').andCallThrough()
+        fs.writeFileSync(userStylesheetPath, 'body {border-style: dashed}')
+
+      waitsFor ->
+        themeManager.loadUserStylesheet.callCount is 1
+
+      runs ->
+        expect($(document.body).css('border-style')).toBe 'dashed'
+        fs.removeSync(userStylesheetPath)
+
+      waitsFor ->
+        themeManager.loadUserStylesheet.callCount is 2
+
+      runs ->
+        expect($(document.body).css('border-style')).toBe 'none'
+
+  describe "when a non-existent theme is present in the config", ->
+    it "logs a warning but does not throw an exception (regression)", ->
+      waitsForPromise ->
+        themeManager.activateThemes()
+
+      runs ->
+        spyOn(console, 'warn')
+        expect(-> atom.config.set('core.themes', ['atom-light-ui', 'theme-really-does-not-exist'])).not.toThrow()
+        expect(console.warn.callCount).toBe 1
+        expect(console.warn.argsForCall[0][0].length).toBeGreaterThan 0

spec/tokenized-buffer-spec.coffee

@@ -5,11 +5,13 @@ describe "TokenizedBuffer", ->
   [tokenizedBuffer, buffer, changeHandler] = []
 
   beforeEach ->
-    atom.packages.activatePackage('language-javascript', sync: true)
     # enable async tokenization
     TokenizedBuffer.prototype.chunkSize = 5
     jasmine.unspy(TokenizedBuffer.prototype, 'tokenizeInBackground')
 
+    waitsForPromise ->
+      atom.packages.activatePackage('language-javascript')
+
   startTokenizing = (tokenizedBuffer) ->
     tokenizedBuffer.setVisible(true)
 
@@ -311,10 +313,13 @@ describe "TokenizedBuffer", ->
 
   describe "when the buffer contains hard-tabs", ->
     beforeEach ->
-      atom.packages.activatePackage('language-coffee-script', sync: true)
-      buffer = atom.project.bufferForPathSync('sample-with-tabs.coffee')
-      tokenizedBuffer = new TokenizedBuffer({buffer})
-      startTokenizing(tokenizedBuffer)
+      waitsForPromise ->
+        atom.packages.activatePackage('language-coffee-script')
+
+      runs ->
+        buffer = atom.project.bufferForPathSync('sample-with-tabs.coffee')
+        tokenizedBuffer = new TokenizedBuffer({buffer})
+        startTokenizing(tokenizedBuffer)
 
     afterEach ->
       tokenizedBuffer.destroy()
@@ -341,14 +346,17 @@ describe "TokenizedBuffer", ->
 
   describe "when the buffer contains surrogate pairs", ->
     beforeEach ->
-      atom.packages.activatePackage('language-javascript', sync: true)
-      buffer = atom.project.bufferForPathSync 'sample-with-pairs.js'
-      buffer.setText """
-        'abc\uD835\uDF97def'
-        //\uD835\uDF97xyz
-      """
-      tokenizedBuffer = new TokenizedBuffer({buffer})
-      fullyTokenize(tokenizedBuffer)
+      waitsForPromise ->
+        atom.packages.activatePackage('language-javascript')
+
+      runs ->
+        buffer = atom.project.bufferForPathSync 'sample-with-pairs.js'
+        buffer.setText """
+          'abc\uD835\uDF97def'
+          //\uD835\uDF97xyz
+        """
+        tokenizedBuffer = new TokenizedBuffer({buffer})
+        fullyTokenize(tokenizedBuffer)
 
     afterEach ->
       tokenizedBuffer.destroy()
@@ -379,22 +387,30 @@ describe "TokenizedBuffer", ->
 
   describe "when the grammar is updated because a grammar it includes is activated", ->
     it "retokenizes the buffer", ->
-      atom.packages.activatePackage('language-ruby-on-rails', sync: true)
-      atom.packages.activatePackage('language-ruby', sync: true)
 
-      buffer = atom.project.bufferForPathSync()
-      buffer.setText "<div class='name'><%= User.find(2).full_name %></div>"
-      tokenizedBuffer = new TokenizedBuffer({buffer})
-      tokenizedBuffer.setGrammar(atom.syntax.selectGrammar('test.erb'))
-      fullyTokenize(tokenizedBuffer)
+      waitsForPromise ->
+        atom.packages.activatePackage('language-ruby-on-rails')
 
-      {tokens} = tokenizedBuffer.lineForScreenRow(0)
-      expect(tokens[0]).toEqual value: "<div class='name'>", scopes: ["text.html.ruby"]
+      waitsForPromise ->
+        atom.packages.activatePackage('language-ruby')
 
-      atom.packages.activatePackage('language-html', sync: true)
-      fullyTokenize(tokenizedBuffer)
-      {tokens} = tokenizedBuffer.lineForScreenRow(0)
-      expect(tokens[0]).toEqual value: '<', scopes: ["text.html.ruby","meta.tag.block.any.html","punctuation.definition.tag.begin.html"]
+      runs ->
+        buffer = atom.project.bufferForPathSync()
+        buffer.setText "<div class='name'><%= User.find(2).full_name %></div>"
+        tokenizedBuffer = new TokenizedBuffer({buffer})
+        tokenizedBuffer.setGrammar(atom.syntax.selectGrammar('test.erb'))
+        fullyTokenize(tokenizedBuffer)
+
+        {tokens} = tokenizedBuffer.lineForScreenRow(0)
+        expect(tokens[0]).toEqual value: "<div class='name'>", scopes: ["text.html.ruby"]
+
+      waitsForPromise ->
+        atom.packages.activatePackage('language-html')
+
+      runs ->
+        fullyTokenize(tokenizedBuffer)
+        {tokens} = tokenizedBuffer.lineForScreenRow(0)
+        expect(tokens[0]).toEqual value: '<', scopes: ["text.html.ruby","meta.tag.block.any.html","punctuation.definition.tag.begin.html"]
 
   describe ".tokenForPosition(position)", ->
     afterEach ->

spec/window-spec.coffee

@@ -88,12 +88,12 @@ describe "Window", ->
 
   describe ".unloadEditorWindow()", ->
     it "saves the serialized state of the window so it can be deserialized after reload", ->
-      workspaceViewState = atom.workspaceView.serialize()
+      workspaceState = atom.workspace.serialize()
       syntaxState = atom.syntax.serialize()
 
       atom.unloadEditorWindow()
 
-      expect(atom.state.workspaceView).toEqual workspaceViewState
+      expect(atom.state.workspace).toEqual workspaceState
       expect(atom.state.syntax).toEqual syntaxState
       expect(atom.saveSync).toHaveBeenCalled()
 

spec/workspace-spec.coffee

@@ -0,0 +1,232 @@
+Workspace = require '../src/workspace'
+
+describe "Workspace", ->
+  workspace = null
+
+  beforeEach ->
+    atom.project.setPath(atom.project.resolve('dir'))
+    workspace = new Workspace
+
+  describe "::open(uri, options)", ->
+    beforeEach ->
+      spyOn(workspace.activePane, 'activate').andCallThrough()
+
+    describe "when the 'searchAllPanes' option is false (default)", ->
+      describe "when called without a uri", ->
+        it "adds and activates an empty editor on the active pane", ->
+          editor = null
+          waitsForPromise ->
+            workspace.open().then (o) -> editor = o
+
+          runs ->
+            expect(editor.getPath()).toBeUndefined()
+            expect(workspace.activePane.items).toEqual [editor]
+            expect(workspace.activePaneItem).toBe editor
+            expect(workspace.activePane.activate).toHaveBeenCalled()
+
+      describe "when called with a uri", ->
+        describe "when the active pane already has an editor for the given uri", ->
+          it "activates the existing editor on the active pane", ->
+            editor1 = workspace.openSync('a')
+            editor2 = workspace.openSync('b')
+
+            editor = null
+            waitsForPromise ->
+              workspace.open('a').then (o) -> editor = o
+
+            runs ->
+              expect(editor).toBe editor1
+              expect(workspace.activePaneItem).toBe editor
+              expect(workspace.activePane.activate).toHaveBeenCalled()
+
+        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", ->
+            editor = null
+            waitsForPromise ->
+              workspace.open('a').then (o) -> editor = o
+
+            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()
+
+    describe "when the 'searchAllPanes' option is true", ->
+      describe "when an editor for the given uri is already open on an inactive pane", ->
+        it "activates the existing editor on the inactive pane, then activates that pane", ->
+          editor1 = workspace.openSync('a')
+          pane1 = workspace.activePane
+          pane2 = workspace.activePane.splitRight()
+          editor2 = workspace.openSync('b')
+          expect(workspace.activePaneItem).toBe editor2
+
+          waitsForPromise ->
+            workspace.open('a', searchAllPanes: true)
+
+          runs ->
+            expect(workspace.activePane).toBe pane1
+            expect(workspace.activePaneItem).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", ->
+          editor = null
+          waitsForPromise ->
+            workspace.open('a', searchAllPanes: true).then (o) -> editor = o
+
+          runs ->
+            expect(workspace.activePaneItem).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
+          pane2 = pane1.splitRight()
+          expect(workspace.activePane).toBe pane2
+
+          editor = null
+          waitsForPromise ->
+            workspace.open('a', split: 'left').then (o) -> editor = o
+
+          runs ->
+            expect(workspace.activePane).toBe pane1
+            expect(pane1.items).toEqual [editor]
+            expect(pane2.items).toEqual []
+
+          # Focus right pane and reopen the file on the left
+          waitsForPromise ->
+            pane2.focus()
+            workspace.open('a', split: 'left').then (o) -> editor = o
+
+          runs ->
+            expect(workspace.activePane).toBe pane1
+            expect(pane1.items).toEqual [editor]
+            expect(pane2.items).toEqual []
+
+      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
+          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(pane1.items).toEqual []
+            expect(pane2.items).toEqual [editor]
+
+          # Focus right pane and reopen the file on the right
+          waitsForPromise ->
+            pane1.focus()
+            workspace.open('a', split: 'right').then (o) -> editor = o
+
+          runs ->
+            expect(workspace.activePane).toBe pane2
+            expect(pane1.items).toEqual []
+            expect(pane2.items).toEqual [editor]
+
+    describe "when passed a path that matches a custom opener", ->
+      it "returns the resource returned by the custom opener", ->
+        fooOpener = (pathToOpen, options) -> { foo: pathToOpen, options } if pathToOpen?.match(/\.foo/)
+        barOpener = (pathToOpen) -> { bar: pathToOpen } if pathToOpen?.match(/^bar:\/\//)
+        workspace.registerOpener(fooOpener)
+        workspace.registerOpener(barOpener)
+
+        waitsForPromise ->
+          pathToOpen = atom.project.resolve('a.foo')
+          workspace.open(pathToOpen, hey: "there").then (item) ->
+            expect(item).toEqual { foo: pathToOpen, options: {hey: "there"} }
+
+        waitsForPromise ->
+          workspace.open("bar://baz").then (item) ->
+            expect(item).toEqual { bar: "bar://baz" }
+
+  describe "::openSync(uri, options)", ->
+    [activePane, initialItemCount] = []
+
+    beforeEach ->
+      activePane = workspace.activePane
+      spyOn(activePane, 'activate')
+      initialItemCount = activePane.items.length
+
+    describe "when called without a uri", ->
+      it "adds and activates an empty editor on the active pane", ->
+        editor = workspace.openSync()
+        expect(activePane.items.length).toBe initialItemCount + 1
+        expect(activePane.activeItem).toBe editor
+        expect(editor.getPath()).toBeUndefined()
+        expect(activePane.activate).toHaveBeenCalled()
+
+    describe "when called with a uri", ->
+      describe "when the active pane already has an editor for the given uri", ->
+        it "activates the existing editor on the active pane", ->
+          editor1 = workspace.openSync('a')
+          editor2 = workspace.openSync('b')
+          expect(activePane.activeItem).toBe editor2
+          expect(activePane.items.length).toBe 2
+
+          editor = workspace.openSync(editor1.getPath())
+          expect(editor).toBe editor1
+          expect(activePane.activeItem).toBe editor
+          expect(activePane.activate).toHaveBeenCalled()
+          expect(activePane.items.length).toBe 2
+
+      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", ->
+          editor = workspace.openSync('a')
+          expect(activePane.items.length).toBe 1
+          expect(activePane.activeItem).toBe editor
+          expect(activePane.activate).toHaveBeenCalled()
+
+    describe "when the 'activatePane' option is false", ->
+      it "does not activate the active pane", ->
+        workspace.openSync('b', activatePane: false)
+        expect(activePane.activate).not.toHaveBeenCalled()
+
+  describe "::reopenItemSync()", ->
+    it "opens the uri associated with the last closed pane that isn't currently open", ->
+      pane = workspace.activePane
+      workspace.openSync('a')
+      workspace.openSync('b')
+      workspace.openSync('file1')
+      workspace.openSync()
+
+      # does not reopen items with no uri
+      expect(workspace.activePaneItem.getUri()).toBeUndefined()
+      pane.destroyActiveItem()
+      workspace.reopenItemSync()
+      expect(workspace.activePaneItem.getUri()).not.toBeUndefined()
+
+      # destroy all items
+      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('file1')
+      pane.destroyActiveItem()
+      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('b')
+      pane.destroyActiveItem()
+      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('a')
+      pane.destroyActiveItem()
+
+      # reopens items with uris
+      expect(workspace.activePaneItem).toBeUndefined()
+      workspace.reopenItemSync()
+      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('a')
+
+      # does not reopen items that are already open
+      workspace.openSync('b')
+      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('b')
+      workspace.reopenItemSync()
+      expect(workspace.activePaneItem.getUri()).toBe atom.project.resolve('file1')
+
+  describe "::increase/decreaseFontSize()", ->
+    it "increases/decreases the font size without going below 1", ->
+      atom.config.set('editor.fontSize', 1)
+      workspace.increaseFontSize()
+      expect(atom.config.get('editor.fontSize')).toBe 2
+      workspace.increaseFontSize()
+      expect(atom.config.get('editor.fontSize')).toBe 3
+      workspace.decreaseFontSize()
+      expect(atom.config.get('editor.fontSize')).toBe 2
+      workspace.decreaseFontSize()
+      expect(atom.config.get('editor.fontSize')).toBe 1
+      workspace.decreaseFontSize()
+      expect(atom.config.get('editor.fontSize')).toBe 1

spec/workspace-view-spec.coffee

@@ -3,6 +3,7 @@ Q = require 'q'
 path = require 'path'
 temp = require 'temp'
 PaneView = require '../src/pane-view'
+Workspace = require '../src/workspace'
 
 describe "WorkspaceView", ->
   pathToOpen = null
@@ -10,7 +11,8 @@ describe "WorkspaceView", ->
   beforeEach ->
     atom.project.setPath(atom.project.resolve('dir'))
     pathToOpen = atom.project.resolve('a')
-    atom.workspaceView = new WorkspaceView
+    atom.workspace = new Workspace
+    atom.workspaceView = new WorkspaceView(atom.workspace)
     atom.workspaceView.enableKeymap()
     atom.workspaceView.openSync(pathToOpen)
     atom.workspaceView.focus()
@@ -19,20 +21,21 @@ describe "WorkspaceView", ->
     viewState = null
 
     simulateReload = ->
-      workspaceState = atom.workspaceView.serialize()
+      workspaceState = atom.workspace.serialize()
       projectState = atom.project.serialize()
       atom.workspaceView.remove()
       atom.project = atom.deserializers.deserialize(projectState)
-      atom.workspaceView = WorkspaceView.deserialize(workspaceState)
+      atom.workspace = Workspace.deserialize(workspaceState)
+      atom.workspaceView = new WorkspaceView(atom.workspace)
       atom.workspaceView.attachToDom()
 
     describe "when the serialized WorkspaceView has an unsaved buffer", ->
       it "constructs the view with the same panes", ->
         atom.workspaceView.attachToDom()
         atom.workspaceView.openSync()
-        editor1 = atom.workspaceView.getActiveView()
-        buffer = editor1.getBuffer()
-        editor1.splitRight()
+        editorView1 = atom.workspaceView.getActiveView()
+        buffer = editorView1.getEditor().getBuffer()
+        editorView1.splitRight()
         expect(atom.workspaceView.getActivePane()).toBe atom.workspaceView.getPanes()[1]
 
         simulateReload()
@@ -58,31 +61,31 @@ describe "WorkspaceView", ->
         simulateReload()
 
         expect(atom.workspaceView.getEditorViews().length).toBe 4
-        editor1 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(0)').view()
-        editor3 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(1)').view()
-        editor2 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(0)').view()
-        editor4 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(1)').view()
+        editorView1 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(0)').view()
+        editorView3 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(1)').view()
+        editorView2 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(0)').view()
+        editorView4 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(1)').view()
 
-        expect(editor1.getPath()).toBe atom.project.resolve('a')
-        expect(editor2.getPath()).toBe atom.project.resolve('b')
-        expect(editor3.getPath()).toBe atom.project.resolve('../sample.js')
-        expect(editor3.getCursorScreenPosition()).toEqual [2, 4]
-        expect(editor4.getPath()).toBe atom.project.resolve('../sample.txt')
-        expect(editor4.getCursorScreenPosition()).toEqual [0, 2]
+        expect(editorView1.getEditor().getPath()).toBe atom.project.resolve('a')
+        expect(editorView2.getEditor().getPath()).toBe atom.project.resolve('b')
+        expect(editorView3.getEditor().getPath()).toBe atom.project.resolve('../sample.js')
+        expect(editorView3.getEditor().getCursorScreenPosition()).toEqual [2, 4]
+        expect(editorView4.getEditor().getPath()).toBe atom.project.resolve('../sample.txt')
+        expect(editorView4.getEditor().getCursorScreenPosition()).toEqual [0, 2]
 
         # ensure adjust pane dimensions is called
-        expect(editor1.width()).toBeGreaterThan 0
-        expect(editor2.width()).toBeGreaterThan 0
-        expect(editor3.width()).toBeGreaterThan 0
-        expect(editor4.width()).toBeGreaterThan 0
+        expect(editorView1.width()).toBeGreaterThan 0
+        expect(editorView2.width()).toBeGreaterThan 0
+        expect(editorView3.width()).toBeGreaterThan 0
+        expect(editorView4.width()).toBeGreaterThan 0
 
-        # ensure correct editor is focused again
-        expect(editor2.isFocused).toBeTruthy()
-        expect(editor1.isFocused).toBeFalsy()
-        expect(editor3.isFocused).toBeFalsy()
-        expect(editor4.isFocused).toBeFalsy()
+        # ensure correct editorView is focused again
+        expect(editorView2.isFocused).toBeTruthy()
+        expect(editorView1.isFocused).toBeFalsy()
+        expect(editorView3.isFocused).toBeFalsy()
+        expect(editorView4.isFocused).toBeFalsy()
 
-        expect(atom.workspaceView.title).toBe "#{path.basename(editor2.getPath())} - #{atom.project.getPath()}"
+        expect(atom.workspaceView.title).toBe "#{path.basename(editorView2.getEditor().getPath())} - #{atom.project.getPath()}"
 
     describe "where there are no open editors", ->
       it "constructs the view with no open editors", ->
@@ -95,39 +98,12 @@ describe "WorkspaceView", ->
     beforeEach ->
       atom.workspaceView.attachToDom()
 
-    describe "when there is an active view", ->
-      it "hands off focus to the active view", ->
-        editorView = atom.workspaceView.getActiveView()
-        editorView.isFocused = false
-        atom.workspaceView.focus()
-        expect(editorView.isFocused).toBeTruthy()
-
-    describe "when there is no active view", ->
-      beforeEach ->
-        atom.workspaceView.getActivePane().remove()
-        expect(atom.workspaceView.getActiveView()).toBeUndefined()
-        atom.workspaceView.attachToDom()
-        expect(document.activeElement).toBe document.body
-
-      describe "when are visible focusable elements (with a -1 tabindex)", ->
-        it "passes focus to the first focusable element", ->
-          focusable1 = $$ -> @div "One", id: 'one', tabindex: -1
-          focusable2 = $$ -> @div "Two", id: 'two', tabindex: -1
-          atom.workspaceView.appendToLeft(focusable1, focusable2)
-          expect(document.activeElement).toBe document.body
-
-          atom.workspaceView.focus()
-          expect(document.activeElement).toBe focusable1[0]
-
-      describe "when there are no visible focusable elements", ->
-        it "surrenders focus to the body", ->
-          focusable = $$ -> @div "One", id: 'one', tabindex: -1
-          atom.workspaceView.appendToLeft(focusable)
-          focusable.hide()
-          expect(document.activeElement).toBe document.body
-
-          atom.workspaceView.focus()
-          expect(document.activeElement).toBe document.body
+    it "hands off focus to the active pane", ->
+      activePane = atom.workspaceView.getActivePane()
+      $('body').focus()
+      expect(activePane.hasFocus()).toBe false
+      atom.workspaceView.focus()
+      expect(activePane.hasFocus()).toBe true
 
   describe "keymap wiring", ->
     commandHandler = null
@@ -187,302 +163,36 @@ describe "WorkspaceView", ->
 
     describe "when the root view is deserialized", ->
       it "updates the title to contain the project's path", ->
-        workspaceView2 = atom.deserializers.deserialize(atom.workspaceView.serialize())
+        workspaceView2 = new WorkspaceView(atom.workspace.testSerialization())
         item = atom.workspaceView.getActivePaneItem()
         expect(workspaceView2.title).toBe "#{item.getTitle()} - #{atom.project.getPath()}"
         workspaceView2.remove()
 
-  describe "font size adjustment", ->
-    it "increases/decreases font size when increase/decrease-font-size events are triggered", ->
-      fontSizeBefore = atom.config.get('editor.fontSize')
-      atom.workspaceView.trigger 'window:increase-font-size'
-      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore + 1
-      atom.workspaceView.trigger 'window:increase-font-size'
-      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore + 2
-      atom.workspaceView.trigger 'window:decrease-font-size'
-      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore + 1
-      atom.workspaceView.trigger 'window:decrease-font-size'
-      expect(atom.config.get('editor.fontSize')).toBe fontSizeBefore
-
-    it "does not allow the font size to be less than 1", ->
-      atom.config.set("editor.fontSize", 1)
-      atom.workspaceView.trigger 'window:decrease-font-size'
-      expect(atom.config.get('editor.fontSize')).toBe 1
-
-  describe ".openSync(filePath, options)", ->
-    describe "when there is no active pane", ->
-      beforeEach ->
-        spyOn(PaneView.prototype, 'focus')
-        atom.workspaceView.getActivePane().remove()
-        expect(atom.workspaceView.getActivePane()).toBeUndefined()
-
-      describe "when called with no path", ->
-        it "creates a empty edit session as an item on a new pane, and focuses the pane", ->
-          editor = atom.workspaceView.openSync()
-          expect(atom.workspaceView.getActivePane().activeItem).toBe editor
-          expect(editor.getPath()).toBeUndefined()
-          expect(atom.workspaceView.getActivePane().focus).toHaveBeenCalled()
-
-        it "can create multiple empty edit sessions as an item on a new pane", ->
-          editor = atom.workspaceView.openSync()
-          editor2 = atom.workspaceView.openSync()
-          expect(atom.workspaceView.getActivePane().getItems().length).toBe 2
-          expect(editor).not.toBe editor2
-
-      describe "when called with a path", ->
-        it "creates an edit session for the given path as an item on a new pane, and focuses the pane", ->
-          editor = atom.workspaceView.openSync('b')
-          expect(atom.workspaceView.getActivePane().activeItem).toBe editor
-          expect(editor.getPath()).toBe require.resolve('./fixtures/dir/b')
-          expect(atom.workspaceView.getActivePane().focus).toHaveBeenCalled()
-
-      describe "when the changeFocus option is false", ->
-        it "does not focus the new pane", ->
-          editor = atom.workspaceView.openSync('b', changeFocus: false)
-          expect(atom.workspaceView.getActivePane().focus).not.toHaveBeenCalled()
-
-      describe "when the split option is 'right'", ->
-        it "creates a new pane and opens the file in said pane", ->
-          editor = atom.workspaceView.openSync('b', split: 'right')
-          expect(atom.workspaceView.getActivePane().activeItem).toBe editor
-          expect(editor.getPath()).toBe require.resolve('./fixtures/dir/b')
-
-    describe "when there is an active pane", ->
-      [activePane, initialItemCount] = []
-      beforeEach ->
-        activePane = atom.workspaceView.getActivePane()
-        spyOn(activePane, 'focus')
-        initialItemCount = activePane.getItems().length
-
-      describe "when called with no path", ->
-        it "opens an edit session with an empty buffer as an item in the active pane and focuses it", ->
-          editor = atom.workspaceView.openSync()
-          expect(activePane.getItems().length).toBe initialItemCount + 1
-          expect(activePane.activeItem).toBe editor
-          expect(editor.getPath()).toBeUndefined()
-          expect(activePane.focus).toHaveBeenCalled()
-
-      describe "when called with a path", ->
-        describe "when the active pane already has an edit session item for the path being opened", ->
-          it "shows the existing edit session in the pane", ->
-            previousEditor = activePane.activeItem
-
-            editor = atom.workspaceView.openSync('b')
-            expect(activePane.activeItem).toBe editor
-            expect(editor).not.toBe previousEditor
-
-            editor = atom.workspaceView.openSync(previousEditor.getPath())
-            expect(editor).toBe previousEditor
-            expect(activePane.activeItem).toBe editor
-
-            expect(activePane.focus).toHaveBeenCalled()
-
-        describe "when the active pane does not have an edit session item for the path being opened", ->
-          it "creates a new edit session for the given path in the active editor", ->
-            editor = atom.workspaceView.openSync('b')
-            expect(activePane.items.length).toBe 2
-            expect(activePane.activeItem).toBe editor
-            expect(activePane.focus).toHaveBeenCalled()
-
-      describe "when the changeFocus option is false", ->
-        it "does not focus the active pane", ->
-          editor = atom.workspaceView.openSync('b', changeFocus: false)
-          expect(activePane.focus).not.toHaveBeenCalled()
-
-      describe "when the split option is 'right'", ->
-        it "creates a new pane and opens the file in said pane", ->
-          pane1 = atom.workspaceView.getActivePane()
-
-          editor = atom.workspaceView.openSync('b', split: 'right')
-          pane2 = atom.workspaceView.getActivePane()
-          expect(pane2[0]).not.toBe pane1[0]
-          expect(editor.getPath()).toBe require.resolve('./fixtures/dir/b')
-
-          expect(atom.workspaceView.panes.find('.pane-row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-          editor = atom.workspaceView.openSync('file1', split: 'right')
-          pane3 = atom.workspaceView.getActivePane()
-          expect(pane3[0]).toBe pane2[0]
-          expect(editor.getPath()).toBe require.resolve('./fixtures/dir/file1')
-
-          expect(atom.workspaceView.panes.find('.pane-row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-  describe ".openSingletonSync(filePath, options)", ->
-    describe "when there is an active pane", ->
-      [pane1] = []
-      beforeEach ->
-        pane1 = atom.workspaceView.getActivePane()
-
-      it "creates a new pane and reuses the file when already open", ->
-        atom.workspaceView.openSingletonSync('b', split: 'right')
-        pane2 = atom.workspaceView.getActivePane()
-        expect(pane2[0]).not.toBe pane1[0]
-        expect(pane1.itemForUri('b')).toBeFalsy()
-        expect(pane2.itemForUri('b')).not.toBeFalsy()
-        expect(atom.workspaceView.panes.find('.pane-row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-        pane1.activate()
-        expect(atom.workspaceView.getActivePane()[0]).toBe pane1[0]
-
-        atom.workspaceView.openSingletonSync('b', split: 'right')
-        pane3 = atom.workspaceView.getActivePane()
-        expect(pane3[0]).toBe pane2[0]
-        expect(pane1.itemForUri('b')).toBeFalsy()
-        expect(pane2.itemForUri('b')).not.toBeFalsy()
-        expect(atom.workspaceView.panes.find('.pane-row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-      it "handles split: left by opening to the left pane when necessary", ->
-        atom.workspaceView.openSingletonSync('b', split: 'right')
-        pane2 = atom.workspaceView.getActivePane()
-        expect(pane2[0]).not.toBe pane1[0]
-
-        atom.workspaceView.openSingletonSync('file1', split: 'left')
-
-        activePane = atom.workspaceView.getActivePane()
-        expect(activePane[0]).toBe pane1[0]
-
-        expect(pane1.itemForUri('file1')).toBeTruthy()
-        expect(pane2.itemForUri('file1')).toBeFalsy()
-        expect(atom.workspaceView.panes.find('.pane-row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-        pane2.activate()
-        expect(atom.workspaceView.getActivePane()[0]).toBe pane2[0]
-
-        atom.workspaceView.openSingletonSync('file1', split: 'left')
-        activePane = atom.workspaceView.getActivePane()
-        expect(activePane[0]).toBe pane1[0]
-        expect(atom.workspaceView.panes.find('.pane-row .pane').toArray()).toEqual [pane1[0], pane2[0]]
-
-      it "reuses the file when already open", ->
-        atom.workspaceView.openSync('b')
-        atom.workspaceView.openSingletonSync('b', split: 'right')
-        expect(atom.workspaceView.panes.find('.pane').toArray()).toEqual [pane1[0]]
-
-  describe ".open(filePath)", ->
-    beforeEach ->
-      spyOn(PaneView.prototype, 'focus')
-
-    describe "when there is no active pane", ->
-      beforeEach ->
-        atom.workspaceView.getActivePane().remove()
-        expect(atom.workspaceView.getActivePane()).toBeUndefined()
-
-      describe "when called with no path", ->
-        it "creates a empty edit session as an item on a new pane, and focuses the pane", ->
-          editor = null
-
-          waitsForPromise ->
-            atom.workspaceView.open().then (o) -> editor = o
-
-          runs ->
-            expect(atom.workspaceView.getActivePane().activeItem).toBe editor
-            expect(editor.getPath()).toBeUndefined()
-            expect(atom.workspaceView.getActivePane().focus).toHaveBeenCalled()
-
-        it "can create multiple empty edit sessions as items on a pane", ->
-          editor1 = null
-          editor2 = null
-
-          waitsForPromise ->
-            atom.workspaceView.open()
-              .then (o) ->
-                editor1 = o
-                atom.workspaceView.open()
-              .then (o) ->
-                editor2 = o
-
-          runs ->
-            expect(atom.workspaceView.getActivePane().getItems().length).toBe 2
-            expect(editor1).not.toBe editor2
-
-      describe "when called with a path", ->
-        it "creates an edit session for the given path as an item on a new pane, and focuses the pane", ->
-          editor = null
-          waitsForPromise ->
-            atom.workspaceView.open('b').then (o) -> editor = o
-
-          runs ->
-            expect(atom.workspaceView.getActivePane().activeItem).toBe editor
-            expect(editor.getPath()).toBe require.resolve('./fixtures/dir/b')
-            expect(atom.workspaceView.getActivePane().focus).toHaveBeenCalled()
-
-    describe "when there is an active pane", ->
-      [activePane] = []
-
-      beforeEach ->
-        activePane = atom.workspaceView.getActivePane()
-
-      describe "when called with no path", ->
-        it "opens an edit session with an empty buffer as an item in the active pane and focuses it", ->
-          editor = null
-
-          waitsForPromise ->
-            atom.workspaceView.open().then (o) -> editor = o
-
-          runs ->
-            expect(activePane.getItems().length).toBe 2
-            expect(activePane.activeItem).toBe editor
-            expect(editor.getPath()).toBeUndefined()
-            expect(activePane.focus).toHaveBeenCalled()
-
-      describe "when called with a path", ->
-        describe "when the active pane already has an item for the given path", ->
-          it "shows the existing edit session in the pane", ->
-            previousEditor = activePane.activeItem
-
-            editor = null
-            waitsForPromise ->
-              atom.workspaceView.open('b').then (o) -> editor = o
-
-            runs ->
-              expect(activePane.activeItem).toBe editor
-              expect(editor).not.toBe previousEditor
-
-            waitsForPromise ->
-              atom.workspaceView.open(previousEditor.getPath()).then (o) -> editor = o
-
-            runs ->
-              expect(editor).toBe previousEditor
-              expect(activePane.activeItem).toBe editor
-              expect(activePane.focus).toHaveBeenCalled()
-
-        describe "when the active pane does not have an existing item for the given path", ->
-          it "creates a new edit session for the given path in the active pane", ->
-            editor = null
-
-            waitsForPromise ->
-              atom.workspaceView.open('b').then (o) -> editor = o
-
-            runs ->
-              expect(activePane.activeItem).toBe editor
-              expect(activePane.getItems().length).toBe 2
-              expect(activePane.focus).toHaveBeenCalled()
-
   describe "window:toggle-invisibles event", ->
     it "shows/hides invisibles in all open and future editors", ->
       atom.workspaceView.height(200)
       atom.workspaceView.attachToDom()
-      rightEditor = atom.workspaceView.getActiveView()
-      rightEditor.setText(" \t ")
-      leftEditor = rightEditor.splitLeft()
-      expect(rightEditor.find(".line:first").text()).toBe "    "
-      expect(leftEditor.find(".line:first").text()).toBe "    "
+      rightEditorView = atom.workspaceView.getActiveView()
+      rightEditorView.getEditor().setText(" \t ")
+      leftEditorView = rightEditorView.splitLeft()
+      expect(rightEditorView.find(".line:first").text()).toBe "    "
+      expect(leftEditorView.find(".line:first").text()).toBe "    "
 
-      withInvisiblesShowing = "#{rightEditor.invisibles.space}#{rightEditor.invisibles.tab} #{rightEditor.invisibles.space}#{rightEditor.invisibles.eol}"
+      withInvisiblesShowing = "#{rightEditorView.invisibles.space}#{rightEditorView.invisibles.tab} #{rightEditorView.invisibles.space}#{rightEditorView.invisibles.eol}"
 
       atom.workspaceView.trigger "window:toggle-invisibles"
-      expect(rightEditor.find(".line:first").text()).toBe withInvisiblesShowing
-      expect(leftEditor.find(".line:first").text()).toBe withInvisiblesShowing
+      expect(rightEditorView.find(".line:first").text()).toBe withInvisiblesShowing
+      expect(leftEditorView.find(".line:first").text()).toBe withInvisiblesShowing
 
-      lowerLeftEditor = leftEditor.splitDown()
-      expect(lowerLeftEditor.find(".line:first").text()).toBe withInvisiblesShowing
+      lowerLeftEditorView = leftEditorView.splitDown()
+      expect(lowerLeftEditorView.find(".line:first").text()).toBe withInvisiblesShowing
 
       atom.workspaceView.trigger "window:toggle-invisibles"
-      expect(rightEditor.find(".line:first").text()).toBe "    "
-      expect(leftEditor.find(".line:first").text()).toBe "    "
+      expect(rightEditorView.find(".line:first").text()).toBe "    "
+      expect(leftEditorView.find(".line:first").text()).toBe "    "
 
-      lowerRightEditor = rightEditor.splitDown()
-      expect(lowerRightEditor.find(".line:first").text()).toBe "    "
+      lowerRightEditorView = rightEditorView.splitDown()
+      expect(lowerRightEditorView.find(".line:first").text()).toBe "    "
 
   describe ".eachEditorView(callback)", ->
     beforeEach ->
@@ -524,63 +234,10 @@ describe "WorkspaceView", ->
       atom.workspaceView.getActiveView().splitRight()
       expect(count).toBe 2
 
-  describe ".reopenItemSync()", ->
-    it "opens the uri associated with the last closed pane that isn't currently open", ->
-      workspace = atom.workspaceView
-      pane = workspace.getActivePane()
-      workspace.openSync('b')
-      workspace.openSync('file1')
-      workspace.openSync()
-
-      # does not reopen items with no uri
-      expect(workspace.getActivePaneItem().getUri()).toBeUndefined()
-      pane.destroyActiveItem()
-      workspace.reopenItemSync()
-      expect(workspace.getActivePaneItem().getUri()).not.toBeUndefined()
-
-      # destroy all items
-      expect(workspace.getActivePaneItem().getUri()).toBe 'a'
-      pane.destroyActiveItem()
-      expect(workspace.getActivePaneItem().getUri()).toBe 'b'
-      pane.destroyActiveItem()
-      expect(workspace.getActivePaneItem().getUri()).toBe 'file1'
-      pane.destroyActiveItem()
-
-      # reopens items with uris
-      expect(workspace.getActivePaneItem()).toBeUndefined()
-      workspace.reopenItemSync()
-      expect(workspace.getActivePaneItem().getUri()).toBe 'file1'
-
-      # does not reopen items that are already open
-      workspace.openSync('b')
-      expect(workspace.getActivePaneItem().getUri()).toBe 'b'
-      workspace.reopenItemSync()
-      expect(workspace.getActivePaneItem().getUri()).toBe 'a'
-
   describe "core:close", ->
-    it "closes the active editor until there are none", ->
+    it "closes the active pane item until all that remains is a single empty pane", ->
+      atom.config.set('core.destroyEmptyPanes', true)
       atom.project.openSync('../sample.txt')
       expect(atom.workspaceView.getActivePane().getItems()).toHaveLength 1
       atom.workspaceView.trigger('core:close')
-      expect(atom.workspaceView.getActivePane()).not.toBeDefined()
-      atom.workspaceView.trigger('core:close')
-      expect(atom.workspaceView.getActivePane()).not.toBeDefined()
-
-  describe "core:save", ->
-    it "saves active editor until there are none", ->
-      editor = atom.project.openSync('../sample.txt')
-      spyOn(editor, 'save')
-      atom.workspaceView.getActivePane().activateItem(editor)
-      atom.workspaceView.trigger('core:save')
-      expect(editor.save).toHaveBeenCalled()
-
-  describe "core:save-as", ->
-    beforeEach ->
-      spyOn(atom, 'showSaveDialogSync').andReturn('/selected/path')
-
-    it "saves active editor until there are none", ->
-      editor = atom.project.openSync('../sample.txt')
-      spyOn(editor, 'saveAs')
-      atom.workspaceView.getActivePane().activateItem(editor)
-      atom.workspaceView.trigger('core:save-as')
-      expect(editor.saveAs).toHaveBeenCalled()
+      expect(atom.workspaceView.getActivePane().getItems()).toHaveLength 0