Merge pull request #1581 from atom/atom-shell-v0.10.1

Upgrade to atom-shell@0.10.1

.gitignore

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

CONTRIBUTING.md

@@ -15,7 +15,7 @@ to propose changes to this document in a pull request.
 
 This is the repository for the core Atom editor only. Atom comes bundled with
 many packages and themes that are stored in other repos under the
-[atom org](https://github.com/atom) such as [tabs](https://github.com/atom/tabs),
+[atom organization](https://github.com/atom) such as [tabs](https://github.com/atom/tabs),
 [find-and-replace](https://github.com/atom/find-and-replace),
 [language-javascript](https://github.com/atom/language-javascript),
 and [atom-light-ui](http://github.com/atom/atom-light-ui).
@@ -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,33 @@ 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}`.
+* Reference instance methods with `{ClassName::methodName}`.
+* Reference class methods with `{ClassName.methodName}`.
+* 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) ->
+```

LICENSE

@@ -0,0 +1 @@
+Copyright 2014 GitHub, Inc.

LICENSE.md

@@ -1,13 +0,0 @@
-Copyright 2013 GitHub Inc.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

README.md

@@ -1,8 +1,8 @@
-# Atom — The hackable, ~~collaborative~~ editor
+# Atom — The hackable editor
 
 ![Atom](http://i.imgur.com/OrTvUAD.png)
 
-Check out our [guides and API documentation](https://www.atom.io/docs/latest/).
+Check out our [guides and API documentation](https://atom.io/docs/latest).
 
 ## Installing
 

atom.gyp

@@ -1,14 +0,0 @@
-{
-  'targets': [
-    {
-      'target_name': 'Atom',
-      'type': 'none',
-      'postbuilds': [
-        {
-          'postbuild_name': 'Create Atom, basically do everything',
-          'action': ['script/constructicon/build'],
-        },
-      ],
-    },
-  ],
-}

build/Gruntfile.coffee

@@ -2,16 +2,39 @@ 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'
 
-packageJson = require './package.json'
+packageJson = require '../package.json'
 
 # OAuth token for atom-bot
 # TODO Remove once all repositories are public
 process.env.ATOM_ACCESS_TOKEN ?= '362295be4c5258d3f7b967bbabae662a455ca2a7'
 
+# Shim harmony collections in case grunt was invoked without harmony
+# collections enabled
+_.extend(global, require('harmony-collections')) unless global.WeakMap?
+
 module.exports = (grunt) ->
+  grunt.loadNpmTasks('grunt-coffeelint')
+  grunt.loadNpmTasks('grunt-lesslint')
+  grunt.loadNpmTasks('grunt-cson')
+  grunt.loadNpmTasks('grunt-contrib-csslint')
+  grunt.loadNpmTasks('grunt-contrib-coffee')
+  grunt.loadNpmTasks('grunt-contrib-less')
+  grunt.loadNpmTasks('grunt-markdown')
+  grunt.loadNpmTasks('grunt-shell')
+  grunt.loadNpmTasks('grunt-download-atom-shell')
+  grunt.loadNpmTasks('grunt-peg')
+  grunt.loadTasks('tasks')
+
+  # This allows all subsequent paths to the relative to the root of the repo
+  grunt.file.setBase(path.resolve('..'))
+
   if not grunt.option('verbose')
     grunt.log.writeln = (args...) -> grunt.log
     grunt.log.write = (args...) -> grunt.log
@@ -23,6 +46,7 @@ module.exports = (grunt) ->
     installRoot = process.env.ProgramFiles
     buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
     shellAppDir = path.join(buildDir, appName)
+    contentsDir = shellAppDir
     appDir = path.join(shellAppDir, 'resources', 'app')
     atomShellDownloadDir = path.join(os.tmpdir(), 'atom-cached-atom-shells')
   else
@@ -83,6 +107,13 @@ module.exports = (grunt) ->
       dest: appDir
       ext: '.json'
 
+  pegConfig =
+    glob_to_multiple:
+      expand: true
+      src: ['src/**/*.pegjs']
+      dest: appDir
+      ext: '.js'
+
   for child in fs.readdirSync('node_modules') when child isnt '.bin'
     directory = path.join('node_modules', child)
     {engines, theme} = grunt.file.readJSON(path.join(directory, 'package.json'))
@@ -91,6 +122,7 @@ module.exports = (grunt) ->
       lessConfig.glob_to_multiple.src.push("#{directory}/**/*.less")
       prebuildLessConfig.src.push("#{directory}/**/*.less") unless theme
       csonConfig.glob_to_multiple.src.push("#{directory}/**/*.cson")
+      pegConfig.glob_to_multiple.src.push("#{directory}/**/*.pegjs")
 
   grunt.initConfig
     pkg: grunt.file.readJSON('package.json')
@@ -105,6 +137,8 @@ module.exports = (grunt) ->
 
     cson: csonConfig
 
+    peg: pegConfig
+
     coffeelint:
       options:
         no_empty_param_list:
@@ -117,8 +151,10 @@ module.exports = (grunt) ->
         'dot-atom/**/*.coffee'
         'exports/**/*.coffee'
         'src/**/*.coffee'
-        'tasks/**/*.coffee'
-        'Gruntfile.coffee'
+      ]
+      build: [
+        'build/tasks/**/*.coffee'
+        'build/Gruntfile.coffee'
       ]
       test: [
         'spec/*.coffee'
@@ -188,21 +224,9 @@ module.exports = (grunt) ->
           stderr: false
           failOnError: false
 
-  grunt.loadNpmTasks('grunt-coffeelint')
-  grunt.loadNpmTasks('grunt-lesslint')
-  grunt.loadNpmTasks('grunt-cson')
-  grunt.loadNpmTasks('grunt-contrib-csslint')
-  grunt.loadNpmTasks('grunt-contrib-coffee')
-  grunt.loadNpmTasks('grunt-contrib-less')
-  grunt.loadNpmTasks('grunt-markdown')
-  grunt.loadNpmTasks('grunt-download-atom-shell')
-  grunt.loadNpmTasks('grunt-shell')
-  grunt.loadTasks('tasks')
-
-  grunt.registerTask('compile', ['coffee', 'prebuild-less', 'cson'])
+  grunt.registerTask('compile', ['coffee', 'prebuild-less', 'cson', 'peg'])
   grunt.registerTask('lint', ['coffeelint', 'csslint', 'lesslint'])
   grunt.registerTask('test', ['shell:kill-atom', 'run-specs'])
-  grunt.registerTask('ci', ['download-atom-shell', 'build', 'set-development-version', 'lint', 'test'])
-  grunt.registerTask('deploy', ['partial-clean', 'download-atom-shell', 'build', 'codesign'])
+  grunt.registerTask('ci', ['output-disk-space', 'download-atom-shell', 'build', 'set-version', 'check-licenses', 'lint', 'test', 'codesign', 'publish-build'])
   grunt.registerTask('docs', ['markdown:guides', 'build-docs'])
-  grunt.registerTask('default', ['download-atom-shell', 'build', 'set-development-version', 'install'])
+  grunt.registerTask('default', ['download-atom-shell', 'build', 'set-version', 'install'])

build/README.md

@@ -0,0 +1,10 @@
+# Atom Build
+
+This folder contains the grunt configuration and tasks to build Atom.
+
+It was moved from the root of the repository so that any native modules used
+would be compiled against node's v8 headers since anything stored in
+`node_modules` at the root of the repo is compiled against atom's v8 headers.
+
+New build dependencies should be added to the `package.json` file located in
+this folder.

build/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "atom-build",
+  "description": "Atom build",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/atom/atom.git"
+  },
+  "dependencies": {
+    "async": "~0.2.9",
+    "biscotto": "2.x",
+    "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.9.0",
+    "grunt-contrib-less": "~0.8.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",
+    "json-front-matter": "~0.1.3",
+    "legal-eagle": "~0.3.0",
+    "rcedit": "~0.1.2",
+    "request": "~2.27.0",
+    "rimraf": "~2.2.2",
+    "runas": "0.5.x",
+    "underscore-plus": "1.x",
+    "unzip": "~0.1.9",
+    "vm-compatibility-layer": "~0.1.0"
+  }
+}

build/tasks/build-task.coffee

@@ -38,30 +38,43 @@ 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) ->
         unless /.+\.plist/.test(sourcePath)
           grunt.file.copy(sourcePath, path.resolve(appDir, '..', subDirectory, filename))
 
-    dependencies = ['compile']
+    dependencies = ['compile', "generate-license:save"]
     dependencies.push('copy-info-plist') if process.platform is 'darwin'
     dependencies.push('set-exe-icon') if process.platform is 'win32'
     grunt.task.run(dependencies...)

build/tasks/check-licenses-task.coffee

@@ -0,0 +1,25 @@
+
+module.exports = (grunt) ->
+  grunt.registerTask 'check-licenses', 'Report the licenses of all dependencies', ->
+    legalEagle = require 'legal-eagle'
+    {size, keys} = require 'underscore-plus'
+    done = @async()
+
+    options =
+      path: process.cwd()
+      omitPermissive: true
+      overrides: require './license-overrides'
+
+    legalEagle options, (err, summary) ->
+      if err?
+        console.error(err)
+        exit 1
+
+      if size(summary)
+        console.error "Found dependencies without permissive licenses:"
+        for name in keys(summary).sort()
+          console.error "#{name}"
+          console.error "  License: #{summary[name].license}"
+          console.error "  Repository: #{summary[name].repository}"
+        process.exit 1
+      done()

build/tasks/codesign-task.coffee

@@ -0,0 +1,25 @@
+module.exports = (grunt) ->
+  {spawn} = require('./task-helpers')(grunt)
+
+  grunt.registerTask 'codesign', 'Codesign the app', ->
+    done = @async()
+
+    if process.env.XCODE_KEYCHAIN
+      unlockKeychain (error) ->
+        if error?
+          done(error)
+        else
+          signApp(done)
+    else
+      signApp(done)
+
+  unlockKeychain = (callback) ->
+    cmd = 'security'
+    {XCODE_KEYCHAIN_PASSWORD, XCODE_KEYCHAIN} = process.env
+    args = ['unlock-keychain', '-p', XCODE_KEYCHAIN_PASSWORD, XCODE_KEYCHAIN]
+    spawn {cmd, args}, (error) -> callback(error)
+
+  signApp = (callback) ->
+    cmd = 'codesign'
+    args = ['-f', '-v', '-s', 'Developer ID Application: GitHub', grunt.config.get('atom.shellAppDir')]
+    spawn {cmd, args}, (error) -> callback(error)

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('node_modules', '.bin', 'biscotto'), '--']
+  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/', '../telepath/src/range.coffee', '../telepath/src/point.coffee', '../telepath/src/string-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/generate-license-task.coffee

@@ -0,0 +1,46 @@
+fs = require 'fs'
+path = require 'path'
+
+module.exports = (grunt) ->
+  grunt.registerTask 'generate-license', 'Generate the license, including the licenses of all dependencies', (mode) ->
+    legalEagle = require 'legal-eagle'
+    done = @async()
+
+    options =
+      path: process.cwd()
+      overrides: require './license-overrides'
+
+    legalEagle options, (err, dependencyLicenses) ->
+      if err?
+        console.error(err)
+        exit 1
+
+      licenseText = getLicenseText(dependencyLicenses)
+      if mode is 'save'
+        targetPath = path.join(grunt.config.get('atom.appDir'), 'LICENSE')
+        fs.writeFileSync(targetPath, licenseText)
+      else
+        console.log licenseText
+      done()
+
+getLicenseText = (dependencyLicenses) ->
+  {keys} = require 'underscore-plus'
+  text = """
+    Copyright 2014 GitHub, Inc.
+
+    This application bundles the following third-party packages in accordance
+    with the following licenses:\n\n
+  """
+  names = keys(dependencyLicenses).sort()
+  for name in names
+    {license, source, sourceText} = dependencyLicenses[name]
+
+    text += "-------------------------------------------------------------------------\n\n"
+    text += "Package: #{name}\n"
+    text += "License: #{license}\n"
+    text += "License Source: #{source}\n" if source?
+    if sourceText?
+      text += "Source Text:\n\n"
+      text += sourceText
+    text += '\n'
+  text

build/tasks/install-task.coffee

@@ -0,0 +1,21 @@
+path = require 'path'
+runas = null
+
+module.exports = (grunt) ->
+  {cp, mkdir, rm} = require('./task-helpers')(grunt)
+
+  grunt.registerTask 'install', 'Install the built application', ->
+    installDir = grunt.config.get('atom.installDir')
+    shellAppDir = grunt.config.get('atom.shellAppDir')
+    if process.platform is 'win32'
+      runas ?= require 'runas'
+      copyFolder = path.resolve 'script', 'copy-folder.cmd'
+      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/license-overrides.coffee

@@ -0,0 +1,62 @@
+module.exports =
+  'aws-sign@0.3.0':
+    repository: 'https://github.com/mikeal/aws-sign'
+    license: 'MIT'
+    source: 'index.js'
+    sourceText: """
+      /*!
+       * knox - auth
+       * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+       * MIT Licensed
+       */
+      <content omitted>
+    """
+  'bufferjs@2.0.0':
+    repository: 'https://github.com/coolaj86/node-bufferjs'
+    license: 'MIT'
+    source: 'LICENSE.MIT'
+    sourceText: """
+      Copyright (c) 2010 AJ ONeal (and Contributors)
+
+      Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+      The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+    """
+  'buffers@0.1.1':
+    repository: "http://github.com/substack/node-buffers"
+    license: 'MIT'
+    source: 'README.markdown'
+    sourceText: """
+      <content omitted>
+      license
+      =======
+
+      MIT/X11
+    """
+  'specificity@0.1.3':
+    repository: 'https://github.com/keeganstreet/specificity'
+    license: 'MIT'
+    source: 'package.json in repository'
+
+  'promzard@0.2.0':
+    license: 'ISC'
+    source: 'LICENSE in the repository'
+    sourceText: """
+        The ISC License
+
+        Copyright (c) Isaac Z. Schlueter
+
+        Permission to use, copy, modify, and/or distribute this software for any
+        purpose with or without fee is hereby granted, provided that the above
+        copyright notice and this permission notice appear in all copies.
+
+        THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+        WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+        MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+        ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+        WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+        ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+        IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+      """

build/tasks/output-disk-space.coffee

@@ -0,0 +1,25 @@
+module.exports = (grunt) ->
+  {spawn} = require('./task-helpers')(grunt)
+
+  grunt.registerTask 'output-disk-space', 'Print diskspace available', ->
+    return unless process.platform is 'darwin'
+
+    done = @async()
+
+    cmd = 'df'
+    args = ['-Hl']
+    spawn {cmd, args}, (error, result, code) ->
+      return done(error) if error?
+
+      lines = result.stdout.split("\n")
+
+      for line in lines[1..]
+        [filesystem, size, used, avail, capacity, extra] = line.split(/\s+/)
+        capacity = parseInt(capacity)
+
+        if capacity > 90
+          grunt.log.error("#{filesystem} is at #{capacity}% capacity!")
+        else if capacity > 80
+          grunt.log.ok("#{filesystem} is at #{capacity}% capacity.")
+
+      done()

build/tasks/publish-build-task.coffee

@@ -1,7 +1,3 @@
-#!/usr/bin/env coffee
-
-return if process.env.JANKY_SHA1 and process.env.JANKY_BRANCH isnt 'master'
-
 child_process = require 'child_process'
 path = require 'path'
 
@@ -10,6 +6,7 @@ fs = require 'fs-plus'
 GitHub = require 'github-releases'
 request = require 'request'
 
+grunt = null
 maxReleases = 10
 assetName = 'atom-mac.zip'
 assetPath = "/tmp/atom-build/#{assetName}"
@@ -19,16 +16,41 @@ defaultHeaders =
   Authorization: "token #{token}"
   'User-Agent': 'Atom'
 
+module.exports = (gruntObject) ->
+  grunt = gruntObject
+  grunt.registerTask 'publish-build', 'Publish the built app', ->
+    return unless process.platform is 'darwin'
+    return if process.env.JANKY_SHA1 and process.env.JANKY_BRANCH isnt 'master'
+
+    done = @async()
+
+    createBuildRelease (error, release) ->
+      return done(error) if error?
+      zipApp (error) ->
+        return done(error) if error?
+        uploadAsset release, (error) ->
+          return done(error) if error?
+          publishRelease release, (error) ->
+            return done(error) if error?
+            getAtomDraftRelease (error, release) ->
+              return done(error) if error?
+              deleteExistingAsset release, (error) ->
+                return done(error) if error?
+                uploadAsset(release, done)
+
+logError = (message, error, details) ->
+  grunt.log.error(message)
+  grunt.log.error(error.message ? error) if error?
+  grunt.log.error(details) if details
+
 zipApp = (callback) ->
   fs.removeSync(assetPath)
 
   options = {cwd: path.dirname(assetPath), maxBuffer: Infinity}
   child_process.exec "zip -r --symlinks #{assetName} Atom.app", options, (error, stdout, stderr) ->
     if error?
-      console.error('Zipping Atom.app failed', error, stderr)
-      process.exit(1)
-    else
-      callback()
+      logError('Zipping Atom.app failed', error, stderr)
+    callback(error)
 
 getRelease = (callback) ->
   options =
@@ -38,17 +60,29 @@ getRelease = (callback) ->
     json: true
   request options, (error, response, releases=[]) ->
     if error? or response.statusCode isnt 200
-      console.error('Fetching releases failed', error, releases)
-      process.exit(1)
+      logError('Fetching releases failed', error, releases)
+      callback(error ? new Error(response.statusCode))
     else
       if releases.length > maxReleases
         deleteRelease(release) for release in releases[maxReleases..]
 
       for release in releases when release.name is commitSha
-        callback(release)
+        callback(null, release)
         return
       callback()
 
+getAtomDraftRelease = (callback) ->
+  atomRepo = new GitHub({repo: 'atom/atom', token})
+  atomRepo.getReleases (error, releases=[]) ->
+    if error?
+      logError('Fetching atom/atom releases failed', error, releases)
+      callback(error)
+    else
+      for release in releases when release.draft
+        callback(null, release)
+        return
+      callback(new Error('No draft release in atom/atom repo'))
+
 deleteRelease = (release) ->
   options =
     uri: release.url
@@ -57,7 +91,7 @@ deleteRelease = (release) ->
     json: true
   request options, (error, response, body='') ->
     if error? or response.statusCode isnt 204
-      console.error('Deleting release failed', error, body)
+      logError('Deleting release failed', error, body)
 
 deleteExistingAsset = (release, callback) ->
   for asset in release.assets when asset.name is assetName
@@ -67,8 +101,8 @@ deleteExistingAsset = (release, callback) ->
       headers: defaultHeaders
     request options, (error, response, body='') ->
       if error? or response.statusCode isnt 204
-        console.error('Deleting existing release asset failed', error, body)
-        process.exit(1)
+        logError('Deleting existing release asset failed', error, body)
+        callback(error ? new Error(response.statusCode))
       else
         callback()
 
@@ -76,11 +110,15 @@ deleteExistingAsset = (release, callback) ->
 
   callback()
 
-createRelease = (callback) ->
-  getRelease (release) ->
+createBuildRelease = (callback) ->
+  getRelease (error, release) ->
+    if error?
+      callback(error)
+      return
+
     if release?
-      deleteExistingAsset release, ->
-        callback(release)
+      deleteExistingAsset release, (error) ->
+        callback(error, release)
       return
 
     options =
@@ -91,19 +129,19 @@ createRelease = (callback) ->
         tag_name: "v#{commitSha}"
         target_commitish: 'master'
         name: commitSha
-        body: "Build of [atom@#{commitSha.substring(0, 7)}](https://github.com/atom/atom/commit/#{commitSha})"
+        body: "Build of [atom@#{commitSha.substring(0, 7)}](https://github.com/atom/atom/commits/#{commitSha})"
         draft: true
         prerelease: true
     request options, (error, response, release={}) ->
       if error? or response.statusCode isnt 201
-        console.error('Creating release failed', error, release)
-        process.exit(1)
+        logError('Creating release failed', error, release)
+        callback(error ? new Error(response.statusCode))
       else
-        callback(release)
+        callback(null, release)
 
 uploadAsset = (release, callback) ->
   options =
-    uri: "https://uploads.github.com/repos/atom/atom-master-builds/releases/#{release.id}/assets?name=#{assetName}"
+    uri: release.upload_url.replace(/\{.*$/, "?name=#{assetName}")
     method: 'POST'
     headers: _.extend({
       'Content-Type': 'application/zip'
@@ -112,14 +150,14 @@ uploadAsset = (release, callback) ->
 
   assetRequest = request options, (error, response, body='') ->
     if error? or response.statusCode >= 400
-      console.error('Upload release asset failed', error, body)
-      process.exit(1)
+      logError('Upload release asset failed', error, body)
+      callback(error ? new Error(response.statusCode))
     else
-      callback(release)
+      callback(null, release)
 
   fs.createReadStream(assetPath).pipe(assetRequest)
 
-publishRelease = (release) ->
+publishRelease = (release, callback) ->
   options =
     uri: release.url
     method: 'POST'
@@ -128,10 +166,7 @@ publishRelease = (release) ->
       draft: false
   request options, (error, response, body={}) ->
     if error? or response.statusCode isnt 200
-      console.error('Creating release failed', error, body)
-      process.exit(1)
-
-createRelease (release) ->
-  zipApp ->
-    uploadAsset release, ->
-      publishRelease release
+      logError('Creating release failed', error, body)
+      callback(error ? new Error(response.statusCode))
+    else
+      callback()

build/tasks/publish-packages.coffee

@@ -8,7 +8,7 @@ request = require 'request'
 module.exports = (grunt) ->
   {spawn} = require('./task-helpers')(grunt)
 
-  baseUrl = "https://www.atom.io/api/packages"
+  baseUrl = "https://atom.io/api/packages"
 
   packageExists = (packageName, token, callback) ->
     requestSettings =

build/tasks/set-exe-icon-task.coffee

@@ -6,7 +6,7 @@ module.exports = (grunt) ->
 
     shellAppDir = grunt.config.get('atom.shellAppDir')
     shellExePath = path.join(shellAppDir, 'atom.exe')
-    iconPath = path.resolve(__dirname, '..', 'resources', 'win', 'atom.ico')
+    iconPath = path.resolve('resources', 'win', 'atom.ico')
 
     rcedit = require('rcedit')
     rcedit(shellExePath, {'icon': iconPath}, done)

build/tasks/set-version-task.coffee

@@ -4,15 +4,24 @@ path = require 'path'
 module.exports = (grunt) ->
   {spawn} = require('./task-helpers')(grunt)
 
-  grunt.registerTask 'set-development-version', 'Sets version to current SHA-1', ->
+  getVersion = (callback) ->
+    if process.env.JANKY_SHA1 and process.env.JANKY_BRANCH is 'master'
+      {version} = require(path.join(grunt.config.get('atom.appDir'), 'package.json'))
+      callback(null, version)
+    else
+      cmd = 'git'
+      args = ['rev-parse', '--short', 'HEAD']
+      spawn {cmd, args}, (error, {stdout}={}, code) ->
+        callback(error, stdout?.trim?())
+
+  grunt.registerTask 'set-version', 'Set the version in the plist and package.json', ->
     done = @async()
 
-    cmd = 'git'
-    args = ['rev-parse', '--short', 'HEAD']
-    spawn {cmd, args}, (error, result, code) ->
-      return done(error) if error?
+    getVersion (error, version) ->
+      if error?
+        done(error)
+        return
 
-      version = result.stdout.trim()
       appDir = grunt.config.get('atom.appDir')
 
       # Replace version field of package.json.
@@ -32,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/spec-task.coffee

@@ -0,0 +1,112 @@
+fs = require 'fs'
+path = require 'path'
+
+_ = require 'underscore-plus'
+
+async = require 'async'
+
+module.exports = (grunt) ->
+  {isAtomPackage, spawn} = require('./task-helpers')(grunt)
+
+  packageSpecQueue = null
+
+  runPackageSpecs = (callback) ->
+    failedPackages = []
+    rootDir = grunt.config.get('atom.shellAppDir')
+    contentsDir = grunt.config.get('atom.contentsDir')
+    resourcePath = process.cwd()
+    if process.platform is 'darwin'
+      appPath = path.join(contentsDir, 'MacOS', 'Atom')
+    else if process.platform is 'win32'
+      appPath = path.join(contentsDir, 'atom.exe')
+
+    packageSpecQueue = async.queue (packagePath, callback) ->
+      if process.platform is 'darwin'
+        options =
+          cmd: appPath
+          args: ['--test', "--resource-path=#{resourcePath}", "--spec-directory=#{path.join(packagePath, 'spec')}"]
+          opts:
+            cwd: packagePath
+            env: _.extend({}, process.env, ATOM_PATH: rootDir)
+      else if process.platform is 'win32'
+        options =
+          cmd: process.env.comspec
+          args: ['/c', appPath, '--test', "--resource-path=#{resourcePath}", "--spec-directory=#{path.join(packagePath, 'spec')}", "--log-file=ci.log"]
+          opts:
+            cwd: packagePath
+            env: _.extend({}, process.env, ATOM_PATH: rootDir)
+
+      grunt.verbose.writeln "Launching #{path.basename(packagePath)} specs."
+      spawn options, (error, results, code) ->
+        if process.platform is 'win32'
+          process.stderr.write(fs.readFileSync(path.join(packagePath, 'ci.log')))
+          fs.unlinkSync(path.join(packagePath, 'ci.log'))
+
+        failedPackages.push path.basename(packagePath) if error
+        callback()
+
+    modulesDirectory = path.resolve('node_modules')
+    for packageDirectory in fs.readdirSync(modulesDirectory)
+      packagePath = path.join(modulesDirectory, packageDirectory)
+      continue unless grunt.file.isDir(path.join(packagePath, 'spec'))
+      continue unless isAtomPackage(packagePath)
+      packageSpecQueue.push(packagePath)
+
+    # TODO: Restore concurrency on Windows
+    packageSpecQueue.concurrency = 1 unless process.platform is 'win32'
+
+    packageSpecQueue.drain = -> callback(null, failedPackages)
+
+  runCoreSpecs = (callback) ->
+    contentsDir = grunt.config.get('atom.contentsDir')
+    if process.platform is 'darwin'
+      appPath = path.join(contentsDir, 'MacOS', 'Atom')
+    else if process.platform is 'win32'
+      appPath = path.join(contentsDir, 'atom.exe')
+    resourcePath = process.cwd()
+    coreSpecsPath = path.resolve('spec')
+
+    if process.platform is 'darwin'
+      options =
+        cmd: appPath
+        args: ['--test', "--resource-path=#{resourcePath}", "--spec-directory=#{coreSpecsPath}"]
+    else if process.platform is 'win32'
+      options =
+        cmd: process.env.comspec
+        args: ['/c', appPath, '--test', "--resource-path=#{resourcePath}", "--spec-directory=#{coreSpecsPath}", "--log-file=ci.log"]
+
+    spawn options, (error, results, code) ->
+      if process.platform is 'win32'
+        process.stderr.write(fs.readFileSync('ci.log'))
+        fs.unlinkSync('ci.log')
+      else
+        # TODO: Restore concurrency on Windows
+        packageSpecQueue.concurrency = 2
+
+      callback(null, error)
+
+  grunt.registerTask 'run-specs', 'Run the specs', ->
+    done = @async()
+    startTime = Date.now()
+
+    # TODO: This should really be parallel on both platforms, however our
+    # fixtures step on each others toes currently.
+    if process.platform is 'darwin'
+      method = async.parallel
+    else if process.platform is 'win32'
+      method = async.series
+
+    method [runCoreSpecs, runPackageSpecs], (error, results) ->
+      [coreSpecFailed, failedPackages] = results
+      elapsedTime = Math.round((Date.now() - startTime) / 100) / 10
+      grunt.verbose.writeln("Total spec time: #{elapsedTime}s")
+      failures = failedPackages
+      failures.push "atom core" if coreSpecFailed
+
+      grunt.log.error("[Error]".red + " #{failures.join(', ')} spec(s) failed") if failures.length > 0
+
+      # TODO: Mark the build as green on Windows until specs pass.
+      if process.platform is 'darwin'
+        done(!coreSpecFailed and failedPackages.length == 0)
+      else if process.platform is 'win32'
+        done(true)

build/tasks/task-helpers.coffee

@@ -0,0 +1,67 @@
+fs = require 'fs-plus'
+path = require 'path'
+
+module.exports = (grunt) ->
+  cp: (source, destination, {filter}={}) ->
+    unless grunt.file.exists(source)
+      grunt.fatal("Cannot copy non-existent #{source.cyan} to #{destination.cyan}")
+
+    copyFile = (sourcePath, destinationPath) ->
+      return if filter?.test(sourcePath)
+
+      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)
+
+    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}.")
+
+  mkdir: (args...) ->
+    grunt.file.mkdir(args...)
+
+  rm: (args...) ->
+    grunt.file.delete(args..., force: true) if grunt.file.exists(args...)
+
+  spawn: (options, callback) ->
+    childProcess = require 'child_process'
+    stdout = []
+    stderr = []
+    error = null
+    proc = childProcess.spawn(options.cmd, options.args, options.opts)
+    proc.stdout.on 'data', (data) -> stdout.push(data.toString())
+    proc.stderr.on 'data', (data) -> stderr.push(data.toString())
+    proc.on 'close', (exitCode, signal) ->
+      error = new Error(signal) if exitCode != 0
+      results = {stderr: stderr.join(''), stdout: stdout.join(''), code: exitCode}
+      grunt.log.error results.stderr if exitCode != 0
+      callback(error, results, exitCode)
+
+  isAtomPackage: (packagePath) ->
+    try
+      {engines} = grunt.file.readJSON(path.join(packagePath, 'package.json'))
+      engines?.atom?
+    catch error
+      false

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://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/advanced/view-system.md

@@ -40,25 +40,18 @@ window, and contains every other view. If you open Atom's inspector with
 
 #### Panes
 
-The `WorkspaceView` contains a `#horizontal` and a `#vertical` axis surrounding
-`#panes`. Elements in the horizontal axis will tile across the window
-horizontally, appearing to have a vertical orientation. Items in the vertical
-axis will tile across the window vertically, appearing to have a horizontal
-orientation. You would typically attach tool panels to the root view's primary
-axes. Tool panels are elements which take up some screen real estate that isn't
-devoted to direct editing. In the example above, the `TreeView` is present in
-the `#horizontal` axis to the left of the `#panes`, and the `CommandPanel` is
-present in the `#vertical` axis below the `#panes`.
-
-You can attach a tool panel to an axis using the `horizontal` or `vertical`
-outlets as follows:
+The `WorkspaceView` contains `prependToBottom/Top/Left/Right` and
+`appendToBottom/Top/Left/Right` methods, which are used to add Tool Panels. Tool
+panels are elements that take up screen real estate not devoted to text editing.
+In the example above, the `TreeView` is appended to the left, and the
+`CommandPanel` is appended to the top.
 
 ```coffeescript
-# place a view to the left of the panes (or use .append() to place it to the right)
-atom.workspaceView.horizontal.prepend(new MyView)
+# place a view to the left of the panes
+atom.workspaceView.appendToLeft(new MyView)
 
-# place a view below the panes (or use .prepend() to place it above)
-atom.workspaceView.vertical.append(new MyOtherView)
+# place a view below the panes
+atom.workspaceView.appendToBottom(new MyOtherView)
 ```
 
 [spacepen]: http://github.com/nathansobo/space-pen

docs/contributing.md

@@ -0,0 +1,142 @@
+# 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 methods and classes in markdown with the custom `{}` notation:
+  * Reference classes with `{ClassName}`
+  * Reference instance methods with `{ClassName::methodName}`
+  * Reference class methods with `{ClassName.methodName}`
+
+### 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/creating-a-theme.md

@@ -1,124 +1,127 @@
 # Creating a Theme
 
 Atom's interface is rendered using HTML, and it's styled via [LESS] (a superset
-of CSS). Don't worry if you haven't heard of LESS before; it's just like CSS, but
-with a few handy extensions.
+of CSS). Don't worry if you haven't heard of LESS before; it's just like CSS,
+but with a few handy extensions.
 
-Since CSS is the basis of the theming system, we can load multiple themes within
-Atom, and the themes behave just as they would on a website. Themes loaded first
-are overridden by themes which are loaded later. The order of theme loading is
-controlled within the Settings/Themes pane.
+Atom supports two types of themes: _UI_ and _syntax_.  UI themes style
+elements such as the tree view, the tabs, drop-down lists, and the status bar.
+Syntax themes style the code inside the editor.
 
-This flexibility is helpful for users that prefer a light interface with a dark
-syntax theme. Atom currently has only interface and syntax themes, but it is
-possible to create a theme to style something specific — say, changing
-the colors in the tree view or creating a language specific syntax theme.
+Themes can be installed and changed from the settings view which you can open
+by selecting the _Atom > Preferences..._ menu and navigating to the _Themes_
+section on the left hand side.
 
 ## Getting Started
 
-Themes are pretty straight forward but it's still helpful to be familiar with
+Themes are pretty straightforward but it's still helpful to be familiar with
 a few things before starting:
 
 * LESS is a superset of CSS, but it has some really handy features like
-  variables. If you aren't familiar with its syntax take a few minutes
+  variables. If you aren't familiar with its syntax, take a few minutes
   to [familiarize yourself][less-tutorial].
 * You may also want to review the concept of a _[package.json]_, too. This file
-is used to help distribute your theme to Atom users.
-
-There are two types of themes you can create: syntax themes and interface themes.
-The differences between them are simply a matter of what they target and what
-they provide. Syntax themes focus on the entire editor pane, while interface themes
-target elements which are outside of the editor.
+  is used to help distribute your theme to Atom users.
+* Your theme's _package.json_ must contain a `"theme"` key with a value
+  of `"ui"` or `"syntax"` for Atom to recognize and load it as a theme.
+* You can find existing themes to install or fork on [atom.io](atomio).
 
 ## Creating a Syntax Theme
 
 Let's create your first theme.
 
-To get started, hit `cmd-shift-P`, and start typing "Generate Theme" to generate
-a package. Select "Generate Theme," and you'll be asked for a theme name. Let's
-call ours _motif_.
+To get started, hit `cmd-shift-P`, and start typing "Generate Syntax Theme" to
+generate a new theme package. Select "Generate Syntax Theme," and you'll be
+asked for the path where your theme will be created. Let's call ours _motif_.
 
-Atom will pop open a new window, showing the _motif_ theme, with a default set of
-folders and files created for us. If you hit `cmd-,` and navigate to the Themes
-menu option, you'll see the `motif` theme already available. Drag it over from
-"Enabled Themes" to "Available Themes."
+Atom will pop open a new window, showing the _motif_ theme, with a default set
+of folders and files created for us. If you open the settings view (`cmd-,`)
+and navigate to the _Themes_ section on the left, you'll see the _Motif_ theme
+listed in the _Syntax Theme_ drop-down. Select it from the menu to activate it,
+now when you open an editor you should see that your new _motif_ theme in
+action.
 
 Open up _stylesheets/colors.less_ to change the various colors variables which
 have been already been defined. For example, turn `@red` into `#f4c2c1`.
 
-Then, open _stylesheets/base.less_, and modify the various syntax CSS selectors
-that have been already been defined. Each of these selectors represents a different
-part of the Atom window. Themes that don't need to modify a particular region
-can simply remove the selectors they don't need.
+Then open _stylesheets/base.less_ and modify the various selectors that have
+been already been defined. These selectors style different parts of code in the
+editor such as comments, strings and the line numbers in the gutter.
 
 As an example, let's make the `.gutter` `background-color` into `@red`.
 
-Reload Atom by hitting `cmd-r` to see the changes you made reflected in your Atom
-window. Pretty neat!
+Reload Atom by pressing `cmd-alt-option-L` to see the changes you made reflected
+in your Atom window. Pretty neat!
 
 ## Creating an Interface Theme
 
-Interface themes  **must** provide a `ui-variables.less` file which contains all
+Interface themes **must** provide a `ui-variables.less` file which contains all
 of the variables provided by the [core themes][ui-variables].
 
 To create an interface UI theme, do the following:
 
-1. Fork one of the following repos
-  1. [atom-dark-ui]
-  1. [atom-light-ui]
-1. Open a terminal in the forked theme's directory
-1. Open your new theme in a Dev Mode Atom window (run `atom -d .` in the terminal or use the __View > Developer > Open in Dev Mode__ menu)
-1. Change the name of the theme in the theme's `package.json` file
-1. Run `apm link` to tell Atom about your new theme
-1. Reload Atom (`cmd-r`)
-1. Enable the theme via the themes panel in settings
-1. Make changes! Since you opened the theme in a Dev Mode window, changes will
+1. Fork one of the following repositories:
+  * [atom-dark-ui]
+  * [atom-light-ui]
+2. Clone the forked repository to the local filesystem
+3. Open a terminal in the forked theme's directory
+4. Open your new theme in a Dev Mode Atom window run `atom --dev .` in the
+   terminal or use the _View > Developer > Open in Dev Mode_ menu)
+5. Change the name of the theme in the theme's `package.json` file
+6. Run `apm link` to symlink your repository to `~/.atom/packages`
+7. Reload Atom using `cmd-alt-ctrl-L`
+8. Enable the theme via _UI Theme_ drop-down in the _Themes_ section of the
+   settings view
+9. Make changes! Since you opened the theme in a Dev Mode window, changes will
    be instantly reflected in the editor without having to reload.
 
 ## Development workflow
 
-There are a few of tools to help make theme development faster.
+There are a few of tools to help make theme development faster and easier.
 
 ### Live Reload
 
-Reloading by hitting `cmd-r` after you make changes to your theme is less than ideal.
-Atom supports [live updating][livereload] of styles on Dev Mode Atom windows.
+Reloading by hitting `cmd-alt-ctrl-L` after you make changes to your theme is
+less than ideal. Atom supports [live updating][livereload] of styles on Dev Mode
+Atom windows.
 
 To enable a Dev Mode window:
 
 1. Open your theme directory in a dev window by either going to the
-__View > Developer > Open in Dev Mode__ menu or by hitting the `cmd-shift-o`
-shortcut
-1. Make a change to your theme file and save it. Your change should be
-immediately applied!
+   __View > Developer > Open in Dev Mode__ menu or by hitting the `cmd-shift-o`
+  shortcut
+2. Make a change to your theme file and save it. Your change should be
+   immediately applied!
 
 If you'd like to reload all the styles at any time, you can use the shortcut
-`cmd-ctrl-R`.
+`cmd-ctrl-shift-r`.
 
 ### Developer Tools
 
 Atom is based on the Chrome browser, and supports Chrome's Developer Tools. You
-can open them by selecting the __View > Toggle Developer Tools__ menu, or by using
-the `cmd-option-i` shortcut.
+can open them by selecting the _View > Toggle Developer Tools_ menu, or by
+using the `cmd-alt-i` shortcut.
 
 The dev tools allow you to inspect elements and take a look at their CSS
 properties.
 
 ![devtools-img]
 
-Check out Google's [extensive tutorial][devtools-tutorial] for a short introduction.
+Check out Google's [extensive tutorial][devtools-tutorial] for a short
+introduction.
 
 ### Atom Styleguide
 
 If you are creating an interface theme, you'll want a way to see how your theme
-changes affect all the components in the system. The [styleguide] is a page with
-every component Atom supports rendered.
+changes affect all the components in the system. The [styleguide] is a page that
+renders every component Atom supports.
 
 To open the styleguide, open the command palette (`cmd-shift-P`) and search for
 _styleguide_, or use the shortcut `cmd-ctrl-shift-g`.
 
 ![styleguide-img]
 
+[atomio]: http://atom.io/packages
 [less]: http://lesscss.org/
 [git]: http://git-scm.com/
 [atom]: https://atom.io/

docs/customizing-atom.md

@@ -1,34 +1,57 @@
 # Customizing Atom
 
 To change a setting, configure a theme, or install a package just open the
-Settings pane in the current window by pressing `cmd+,`.
+Settings view in the current window by pressing `cmd+,`.
 
 ## Changing The Theme
 
-Because Atom themes are based on CSS, it's possible (and encouraged) to have
-multiple themes active at the same time. Atom comes with both light and dark
-interface themes as well as several syntax themes (you can also [create your
-own][create-theme]).
+Atom comes with both light and dark UI themes as well as several syntax themes.
+You are also encouraged to [create or fork][create-theme] your own theme.
 
-To change the active themes just open the Settings pane (`cmd-,`) and select the
-`Themes` tab. You can install non-bundled themes by going to the `Available
-Themes` section on the `Packages` tab within the Settings panel.
+To change the active theme just open the Settings view (`cmd-,`) and select the
+`Themes` section from the left hand side. You will see a drop-down menu to
+change the active _Syntax_ and _UI_ themes.
+
+You can also install more themes from here by browsing the featured themes or
+searching for a specific theme.
 
 ## Installing Packages
 
-You can install non-bundled packages by going to the `Available Packages`
-section on the `Packages` tab within the Settings panel (`cmd-,`).
+You can install non-bundled packages by going to the `Packages` section on left
+hand side of the Settings view (`cmd-,`). You will see several featured packages
+and you can also search for packages from here. The packages listed here have
+been published to [atom.io](http://atom.io/packages) which is the official
+registry for Atom packages.
 
-You can also install packages from the command line using the
-[apm](https://github.com/atom/apm) command:
+You can also install packages from the command line using `apm`.
 
-`apm install <package_name>` to install the latest version.
+Check that you have `apm` installed by running the following command in your
+terminal:
 
-`apm install <package_name>@<package_version>` to install a specific version.
+```sh
+apm help install
+```
+
+You should see a message print out with details about the `apm install` command.
+
+If you do not, launch Atom and run the _Atom > Install Shell Commmands_ menu
+to install the `apm` and `atom` commands.
+
+You can also install packages by using the `apm install` command:
+
+* `apm install <package_name>` to install the latest version.
+
+* `apm install <package_name>@<package_version>` to install a specific version.
 
 For example `apm install emmet@0.1.5` installs the `0.1.5` release of the
 [Emmet](https://github.com/atom/emmet) package into `~/.atom/packages`.
 
+You can also use `apm` to find new packages to install:
+
+* `apm search coffee` to search for CoffeeScript packages.
+
+* `apm view emmet` to see more information about a specific package.
+
 ## Customizing Key Bindings
 
 Atom keymaps work similarly to stylesheets. Just as stylesheets use selectors
@@ -36,13 +59,13 @@ 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:
 
-```coffee-script
+```coffee
 '.editor':
   'enter': 'editor:newline'
 
 'body':
-  'ctrl-P': 'core:move-up'
-  'ctrl-p': 'core:move-down'
+  'ctrl-b': 'core:move-left'
+  'ctrl-f': 'core:move-right'
 ```
 
 This keymap defines the meaning of `enter` in two different contexts. In a
@@ -55,6 +78,8 @@ By default, `~/.atom/keymap.cson` is loaded when Atom is started. It will always
 be loaded last, giving you the chance to override bindings that are defined by
 Atom's core keymaps or third-party packages.
 
+You can open this file in an editor from the _Atom > Open Your Keymap_ menu.
+
 You'll want to know all the commands available to you. Open the Settings panel
 (`cmd-,`) and select the _Keybindings_ tab. It will show you all the keybindings
 currently in use.
@@ -64,16 +89,18 @@ currently in use.
 Atom loads configuration settings from the `config.cson` file in your _~/.atom_
 directory, which contains CoffeeScript-style JSON:
 
-```coffeescript
-core:
-  excludeVcsIgnoredPaths: true
-editor:
-  fontSize: 18
+```coffee
+'core':
+  'excludeVcsIgnoredPaths': true
+'editor':
+  'fontSize': 18
 ```
 
 The configuration itself is grouped by the package name or one of the two core
 namespaces: `core` and `editor`.
 
+You can open this file in an editor from the _Atom > Open Your Config_ menu.
+
 ### Configuration Key Reference
 
 - `core`
@@ -108,34 +135,43 @@ namespaces: `core` and `editor`.
   - `removeTrailingWhitespace`: Enable/disable striping of whitespace at the end of lines (defaults to `true`)
 - `wrap-guide`
   - `columns`: Array of hashes with a `pattern` and `column` key to match the
-             the path of the current editor to a column position.
+     the path of the current editor to a column position.
 
 ### 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].
+If customizations become extensive, consider [creating a package][create-a-package].
 
-### user.less
+You can open this file in an editor from the _Atom > Open Your Init Script_
+menu.
+
+This file can also be named _init.js_ and contain JavaScript code.
+
+### styles.less
 
 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.
+an entire theme that you intend to publish, you can add styles to the
+_styles.less_ file 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_:
+You can open this file in an editor from the _Atom > Open Your Stylesheet_ menu.
+
+For example, to change the color of the cursor, you could add the following
+rule to your _~/.atom/styles.less_ file:
 
 ```less
-@highlight-color: pink;
-
-.editor .line-number.cursor-line {
-  color: @highlight-color;
+.editor .cursor {
+  border-color: pink;
 }
 ```
 
+Unfamiliar with LESS? Read more about it [here][LESS].
+
+This file can also be named _styles.css_ and contain CSS.
+
 [create-a-package]: creating-packages.md
 [create-theme]: creating-a-theme.md
+[LESS]: http://www.lesscss.org

docs/getting-started.md

@@ -19,35 +19,30 @@ 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 on the left, and also serve as the context
+for all file-related operations.
 
 #### Finding Files
 
 The fastest way to find a file is to use the fuzzy finder. Press `cmd-t` and
 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.
+files. If you are using Git you can use `cmd-shift-b` to search the list of
+files modified and untracked in your project's repository.
 
-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`.
+You can add, move, and delete files and folders by right-clicking them 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 folder
+and using `a` to add, `m` to move, and `delete` to delete.
 
 ### Searching
 
@@ -58,37 +53,50 @@ 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 `tags` (or `TAGS`) file generated for your project.
+This can be done by installing [ctags](http://ctags.sourceforge.net/) and
+running a command such as `ctags -R src/` from the command line in your
+project's root directory. Using [Homebrew](http://brew.sh/)? Just run
+`brew install ctags`.
+
+You can customize how tags are generated by creating your own `.ctags` file
+in your home directory (`~/.ctags`). Here is [a good example][ctags] to start
+from.
 
 ### 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
-interface for adjusting config settings, installing packages and changing
-themes.
+Press `cmd-,` to open the Settings view. This is the place to change settings
+install packages, and change the theme.
 
 For more advanced configuration see the [customization guide][customization].
 
@@ -98,4 +106,4 @@ For more advanced configuration see the [customization guide][customization].
 [customization]: customizing-atom.md
 [key-bindings]: customizing-atom.md#customizing-key-bindings
 [command palette]: https://f.cloud.github.com/assets/1424/1091618/ee7c3554-166a-11e3-9955-aaa61bb5509c.png
-[ctags]: https://github.com/kevinsawicki/dotfiles/blob/master/.ctags
+[ctags]: https://github.com/atom/symbols-view/blob/master/lib/.ctags

docs/index.md

@@ -4,10 +4,12 @@
 * [Customizing Atom](customizing-atom.md)
 * [Creating a Package](creating-a-package.md)
 * [Creating a Theme](creating-a-theme.md)
+* [Publishing a Package](publishing-a-package.md)
+* [Contributing](contributing.md)
 
 ### 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,334 +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.vertical.append(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.vertical.append` tells Atom to append `this`
-item (_i.e._, whatever is defined by`@content`) _vertically_ to the editor. If
-we had called `atom.workspaceView.horizontal.append`, the pane would be attached to the
-right-hand side of the editor.
-
-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.vertical.append`
-call with this code:
-
-```coffeescript
-# toggles the pane
-if @hasParent()
-  atom.workspaceView.vertical.children().last().remove()
-else
-  atom.workspaceView.vertical.append(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()
-  atom.workspaceView.vertical.children().last().remove()
-else
-  for file in modifiedFiles
-    stat = fs.lstatSync(file)
-    mtime = stat.mtime
-    @modifiedFilesList.append("<li>#{file} - Modified at #{mtime}")
-  atom.workspaceView.vertical.append(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
-  atom.workspaceView.vertical.children().last().remove()
-else
-  for file in modifiedFiles
-    stat = fs.lstatSync(file)
-    mtime = stat.mtime
-    @modifiedFilesList.append("<li>#{file} - Modified at #{mtime}")
-  atom.workspaceView.vertical.append(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.less

@@ -0,0 +1,21 @@
+/*
+ * Your Stylesheet
+ *
+ * This stylesheet is loaded when Atom starts up and is reloaded automatically
+ * when it is changed.
+ *
+ * If you are unfamiliar with LESS, you can read more about it here:
+ * http://www.lesscss.org
+ */
+
+.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

@@ -1,15 +1,9 @@
-{Document, Model, Point, Range} = require 'telepath'
+{Point, Range} = require 'text-buffer'
 
 module.exports =
-  _: require 'underscore-plus'
   BufferedNodeProcess: require '../src/buffered-node-process'
   BufferedProcess: require '../src/buffered-process'
-  Directory: require '../src/directory'
-  Document: Document
-  File: require '../src/file'
-  fs: require 'fs-plus'
   Git: require '../src/git'
-  Model: Model
   Point: Point
   Range: Range
 
@@ -22,8 +16,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

@@ -5,7 +5,7 @@
   'alt-shift-left': 'editor:select-to-beginning-of-word'
   'alt-shift-right': 'editor:select-to-end-of-word'
   'home': 'editor:move-to-first-character-of-line'
-  'end': 'editor:move-to-end-of-line'
+  'end': 'editor:move-to-end-of-screen-line'
   'shift-home': 'editor:select-to-first-character-of-line'
   'shift-end': 'editor:select-to-end-of-line'
 
@@ -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,8 +1,8 @@
-'.platform-darwin':
+'body':
   # Apple specific
   'cmd-q': 'application:quit'
   'cmd-h': 'application:hide'
-  'cmd-H': 'application:hide-other-applications'
+  'cmd-alt-h': 'application:hide-other-applications'
   'cmd-m': 'application:minimize'
   'alt-cmd-ctrl-m': 'application:zoom'
 
@@ -26,7 +26,7 @@
   'down': 'core:move-down'
   'left': 'core:move-left'
   'right': 'core:move-right'
-  'ctrl-alt-cmd-r': 'window:reload'
+  'ctrl-alt-cmd-l': 'window:reload'
   'alt-cmd-i': 'window:toggle-dev-tools'
   'cmd-alt-ctrl-p': 'window:run-package-specs'
 
@@ -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,19 +93,19 @@
   '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'
   'ctrl-A': 'editor:select-to-first-character-of-line'
   'ctrl-E': 'editor:select-to-end-of-line'
   'cmd-left': 'editor:move-to-first-character-of-line'
-  'cmd-right': 'editor:move-to-end-of-line'
+  'cmd-right': 'editor:move-to-end-of-screen-line'
   'cmd-shift-left': 'editor:select-to-first-character-of-line'
   'cmd-shift-right': 'editor:select-to-end-of-line'
   'alt-backspace': 'editor:backspace-to-beginning-of-word'
   'alt-delete': 'editor:delete-to-end-of-word'
-  'ctrl-a': 'editor:move-to-first-character-of-line'
+  'ctrl-a': 'editor:move-to-beginning-of-line'
   'ctrl-e': 'editor:move-to-end-of-line'
   'ctrl-k': 'editor:cut-to-end-of-line'
 
@@ -111,13 +117,13 @@
   'cmd-alt-p': 'editor:log-cursor-scope'
   'cmd-k cmd-u': 'editor:upper-case'
   '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'
@@ -129,6 +135,7 @@
   'cmd-/': 'editor:toggle-line-comments'
   'cmd-j': 'editor:join-line'
   'cmd-D': 'editor:duplicate-line'
+  'cmd-L': 'editor:split-selections-into-lines'
 
   'cmd-alt-[': 'editor:fold-current-row'
   'cmd-alt-]': 'editor:unfold-current-row'
@@ -146,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

@@ -3,10 +3,19 @@
     label: 'Atom'
     submenu: [
       { label: 'About Atom', command: 'application:about' }
+      { label: 'View License', command: 'application:open-license' }
       { 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' }
@@ -99,6 +108,7 @@
     submenu: [
       { label: 'Add Selection Above', command: 'editor:add-selection-above' }
       { label: 'Add Selection Below', command: 'editor:add-selection-below' }
+      { label: 'Split into Lines', command: 'editor:split-selections-into-lines'}
       { type: 'separator' }
       { label: 'Select to Top', command: 'core:select-to-top' }
       { label: 'Select to Bottom', command: 'core:select-to-bottom' }
@@ -156,7 +166,6 @@
     label: 'Help'
     submenu: [
       { label: 'Documentation', command: 'application:open-documentation' }
-      { label: 'Report an Issue', command: 'application:report-issue' }
       { type: 'separator' }
     ]
   }

menus/win32.cson

@@ -106,6 +106,7 @@
     submenu: [
       { label: 'Add Selection &Above', command: 'editor:add-selection-above' }
       { label: 'Add Selection &Below', command: 'editor:add-selection-below' }
+      { label: 'S&plit into Lines', command: 'editor:split-selections-into-lines'}
       { type: 'separator' }
       { label: 'Select to &Top', command: 'core:select-to-top' }
       { label: 'Select to Botto&m', command: 'core:select-to-bottom' }
@@ -144,6 +145,7 @@
     label: '&Help'
     submenu: [
       { label: '&About Atom...', command: 'application:about' }
+      { label: 'View &License', command: 'application:open-license' }
       { label: "VERSION", enabled: false }
       { label: "Install &update", command: 'application:install-update', visible: false }
       { type: 'separator' }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "atom",
   "productName": "Atom",
-  "version": "0.44.0",
+  "version": "0.52.0",
   "main": "./src/browser/main.js",
   "repository": {
     "type": "git",
@@ -16,146 +16,121 @@
       "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
     }
   ],
-  "atomShellVersion": "0.7.6",
+  "atomShellVersion": "0.10.1",
   "dependencies": {
     "async": "0.2.6",
-    "bootstrap": "git://github.com/benogle/bootstrap.git",
-    "clear-cut": "0.2.0",
-    "coffee-script": "1.6.3",
-    "coffeestack": "0.6.0",
-    "diff": "git://github.com/benogle/jsdiff.git",
-    "emissary": "0.19.0",
-    "first-mate": "0.5.0",
-    "fs-plus": "0.11.0",
-    "fuzzaldrin": "0.1.0",
-    "git-utils": "0.29.0",
-    "guid": "0.0.10",
-    "jasmine-focused": "~0.15.0",
-    "mkdirp": "0.3.5",
-    "keytar": "0.13.0",
-    "less-cache": "0.10.0",
-    "nslog": "0.1.0",
-    "oniguruma": "0.24.0",
-    "optimist": "0.4.0",
-    "pathwatcher": "0.11.0",
-    "pegjs": "0.7.0",
-    "q": "0.9.7",
-    "scandal": "0.8.0",
-    "season": "0.14.0",
-    "semver": "1.1.4",
-    "space-pen": "2.0.2",
-    "telepath": "0.70.0",
-    "temp": "0.5.0",
-    "underscore-plus": "0.5.0"
-  },
-  "devDependencies": {
-    "biscotto": "0.0.17",
-    "formidable": "~1.0.14",
+    "bootstrap": "git://github.com/atom/bootstrap.git#6af81906189f1747fd6c93479e3d998ebe041372",
+    "clear-cut": "0.4.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",
-    "grunt": "~0.4.1",
-    "grunt-cli": "~0.1.9",
-    "grunt-coffeelint": "git://github.com/atom/grunt-coffeelint.git",
-    "grunt-lesslint": "0.13.0",
-    "grunt-cson": "0.5.0",
-    "grunt-contrib-csslint": "~0.1.2",
-    "grunt-contrib-coffee": "~0.7.0",
-    "grunt-contrib-less": "~0.8.0",
-    "walkdir": "0.0.7",
-    "js-yaml": "~2.1.0",
-    "grunt-markdown": "~0.4.0",
-    "json-front-matter": "~0.1.3",
-    "grunt-shell": "~0.3.1",
-    "jasmine-node": "git://github.com/kevinsawicki/jasmine-node.git#short-stacks",
-    "jasmine-tagged": "0.2.0",
-    "request": "~2.27.0",
-    "unzip": "~0.1.9",
-    "rcedit": "~0.1.2",
-    "rimraf": "~2.2.2",
-    "github-releases": "~0.2.0"
+    "fuzzaldrin": "1.x",
+    "git-utils": "1.x",
+    "guid": "0.0.10",
+    "jasmine-tagged": ">=1.1.1 <2.0",
+    "mkdirp": "0.3.5",
+    "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.16.0",
+    "pegjs": "0.8.0",
+    "property-accessors": "1.x",
+    "q": "1.0.x",
+    "random-words": "0.0.1",
+    "runas": "0.5.x",
+    "scandal": "0.15.0",
+    "season": ">=1.0.2 <2.0",
+    "semver": "1.1.4",
+    "serializable": "1.x",
+    "space-pen": "3.1.1",
+    "temp": "0.5.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.17.0",
-    "atom-light-syntax": "0.10.0",
-    "atom-light-ui": "0.16.0",
-    "base16-tomorrow-dark-theme": "0.8.0",
-    "solarized-dark-syntax": "0.6.0",
-    "solarized-light-syntax": "0.2.0",
-    "archive-view": "0.16.0",
-    "autocomplete": "0.18.0",
-    "autoflow": "0.11.0",
-    "autosave": "0.10.0",
-    "bookmarks": "0.15.0",
-    "bracket-matcher": "0.15.0",
-    "command-logger": "0.8.0",
-    "command-palette": "0.13.0",
-    "dev-live-reload": "0.20.0",
-    "editor-stats": "0.9.0",
-    "exception-reporting": "0.9.0",
-    "feedback": "0.18.0",
-    "find-and-replace": "0.62.0",
-    "fuzzy-finder": "0.28.0",
-    "gists": "0.13.0",
-    "git-diff": "0.21.0",
-    "github-sign-in": "0.15.0",
-    "go-to-line": "0.12.0",
-    "grammar-selector": "0.13.0",
-    "image-view": "0.10.0",
-    "keybinding-resolver": "0.6.0",
-    "link": "0.11.0",
-    "markdown-preview": "0.22.0",
-    "metrics": "0.20.0",
-    "package-generator": "0.23.0",
-    "release-notes": "0.15.0",
-    "settings-view": "0.51.0",
-    "snippets": "0.17.0",
-    "spell-check": "0.17.0",
-    "status-bar": "0.27.0",
-    "styleguide": "0.18.0",
-    "symbols-view": "0.27.0",
-    "tabs": "0.16.0",
-    "terminal": "0.23.0",
-    "timecop": "0.11.0",
-    "to-the-hubs": "0.16.0",
-    "tree-view": "0.50.0",
-    "visual-bell": "0.6.0",
-    "welcome": "0.4.0",
-    "whitespace": "0.10.0",
-    "wrap-guide": "0.10.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.10.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",
-    "grunt-download-atom-shell": "0.4.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.24.0",
+    "autocomplete": "0.24.0",
+    "autoflow": "0.15.0",
+    "autosave": "0.12.0",
+    "background-tips": "0.8.0",
+    "bookmarks": "0.21.0",
+    "bracket-matcher": "0.22.0",
+    "command-palette": "0.18.0",
+    "dev-live-reload": "0.28.0",
+    "exception-reporting": "0.15.0",
+    "feedback": "0.26.0",
+    "find-and-replace": "0.85.0",
+    "fuzzy-finder": "0.37.0",
+    "git-diff": "0.25.0",
+    "github-sign-in": "0.20.0",
+    "go-to-line": "0.17.0",
+    "grammar-selector": "0.21.0",
+    "image-view": "0.25.0",
+    "keybinding-resolver": "0.11.0",
+    "link": "0.18.0",
+    "markdown-preview": "0.35.0",
+    "metrics": "0.28.0",
+    "open-on-github": "0.21.0",
+    "package-generator": "0.28.0",
+    "release-notes": "0.23.0",
+    "settings-view": "0.82.0",
+    "snippets": "0.32.0",
+    "spell-check": "0.26.0",
+    "status-bar": "0.33.0",
+    "styleguide": "0.25.0",
+    "symbols-view": "0.38.0",
+    "tabs": "0.24.0",
+    "timecop": "0.15.0",
+    "tree-view": "0.71.0",
+    "update-package-dependencies": "0.4.0",
+    "welcome": "0.5.0",
+    "whitespace": "0.15.0",
+    "wrap-guide": "0.15.0",
+    "language-c": "0.12.0",
+    "language-coffee-script": "0.12.0",
+    "language-css": "0.10.0",
+    "language-gfm": "0.18.0",
+    "language-git": "0.9.0",
+    "language-go": "0.6.0",
+    "language-html": "0.8.0",
+    "language-hyperlink": "0.8.0",
+    "language-java": "0.8.0",
+    "language-javascript": "0.11.0",
+    "language-json": "0.8.0",
+    "language-less": "0.5.0",
+    "language-make": "0.8.0",
+    "language-objective-c": "0.9.0",
+    "language-perl": "0.8.0",
+    "language-php": "0.8.0",
+    "language-property-list": "0.7.0",
+    "language-python": "0.8.0",
+    "language-ruby": "0.13.0",
+    "language-ruby-on-rails": "0.7.0",
+    "language-sass": "0.8.0",
+    "language-shellscript": "0.7.0",
+    "language-source": "0.7.0",
+    "language-sql": "0.7.0",
+    "language-text": "0.6.0",
+    "language-todo": "0.6.0",
+    "language-toml": "0.11.0",
+    "language-xml": "0.7.0",
+    "language-yaml": "0.6.0"
   },
   "private": true,
   "scripts": {

script/bootstrap

@@ -1,5 +1,6 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --harmony_collections
 var safeExec = require('./utils/child-process-wrapper.js').safeExec;
+var fs = require('fs');
 var path = require('path');
 
 // OAuth token for atom-bot
@@ -22,16 +23,28 @@ function executeCommands(commands, done, index) {
     done(null);
 }
 
+var apmVendorPath = path.resolve(__dirname, '..', 'vendor', 'apm');
+var apmInstallPath = path.resolve(__dirname, '..', 'apm');
+if (!fs.existsSync(apmInstallPath))
+  fs.mkdirSync(apmInstallPath);
+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',
   'git submodule --quiet update --recursive --init',
-  {command: 'npm install --quiet .', options: {cwd: path.resolve(__dirname, '..', 'vendor', 'apm'), ignoreStdout: true}},
-  {command: 'npm install --quiet vendor/apm', options: {ignoreStdout: true}},
+  {command: 'npm install --quiet', options: {cwd: path.resolve(__dirname, '..', 'build'), ignoreStdout: true}},
+  {command: 'npm install --quiet', options: {cwd: apmVendorPath, ignoreStdout: true}},
+  {command: 'npm install --quiet ' + apmVendorPath, options: {cwd: apmInstallPath, ignoreStdout: true}},
+  {command: 'npm install --quiet ' + apmVendorPath, options: {ignoreStdout: true}},
+  {command: 'node ../../apm/node_modules/atom-package-manager/bin/apm rebuild', options: {cwd: path.resolve('node_modules', 'atom-package-manager'), ignoreStdout: true}},
   echoNewLine,
-  'node node_modules/atom-package-manager/bin/apm clean ' + apmFlags,
-  'node node_modules/atom-package-manager/bin/apm install --quiet ' + apmFlags,
+  '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/build

@@ -1,11 +1,13 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --harmony_collections
 var cp = require('./utils/child-process-wrapper.js');
 var path = require('path');
 
 process.chdir(path.dirname(__dirname));
 
 cp.safeExec('node script/bootstrap', function() {
-  // node_modules/.bin/grunt "$@"
-  var gruntPath = path.join('node_modules', '.bin', 'grunt') + (process.platform === 'win32' ? '.cmd' : '');
-  cp.safeSpawn(gruntPath, process.argv.slice(2), process.exit);
+  // build/node_modules/.bin/grunt "$@"
+  var gruntPath = path.join('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(gruntPath, args, process.exit);
 });

script/cibuild

@@ -1,20 +1,18 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --harmony_collections
 var cp = require('./utils/child-process-wrapper.js');
 var fs = require('fs');
 var path = require('path');
 
 process.chdir(path.dirname(__dirname));
 
-if (process.platform != 'darwin')
-  throw new Error('cibuild can not run on ' + process.platform + ' yet!');
+if (process.platform == 'linux')
+  throw new Error('cibuild can not run on linux yet!');
 
 var homeDir = process.platform == 'win32' ? process.env.USERPROFILE : process.env.HOME;
 
-function readEnvironmentVariables() {
-  var credentialsPath = '/var/lib/jenkins/config/atomcredentials';
+function loadEnvironmentVariables(filePath) {
   try {
-    var credentials = fs.readFileSync(credentialsPath, 'utf8');
-    var lines = credentials.trim().split('\n');
+    var lines = fs.readFileSync(filePath, 'utf8').trim().split('\n');
     for (i in lines) {
       var parts = lines[i].split('=');
       var key = parts[0].trim();
@@ -24,18 +22,23 @@ function readEnvironmentVariables() {
   } catch(error) { }
 }
 
+function readEnvironmentVariables() {
+  loadEnvironmentVariables('/var/lib/jenkins/config/atomcredentials')
+  loadEnvironmentVariables('/var/lib/jenkins/config/xcodekeychain')
+}
+
 readEnvironmentVariables();
 cp.safeExec.bind(global, 'node script/bootstrap', function(error) {
   if (error)
     process.exit(1);
+  require('fs-plus').removeSync.bind(global, path.join(homeDir, '.atom'))
   var async = require('async');
-  var gruntPath = path.join('node_modules', '.bin', 'grunt') + (process.platform === 'win32' ? '.cmd' : '');
-  async.series([
-    require('rimraf').bind(global, path.join(homeDir, '.atom')),
+  var gruntPath = path.join('build', 'node_modules', '.bin', 'grunt') + (process.platform === 'win32' ? '.cmd' : '');
+  var tasks = [
     cp.safeExec.bind(global, 'git clean -dff'),
-    cp.safeExec.bind(global, gruntPath + ' ci --stack --no-color'),
-    cp.safeExec.bind(global, 'node_modules/.bin/coffee script/upload-release')
-  ], function(error) {
+    cp.safeExec.bind(global, gruntPath + ' ci --gruntfile build/Gruntfile.coffee --stack --no-color'),
+  ]
+  async.series(tasks, function(error) {
     process.exit(error ? 1 : 0);
   });
 })();

script/clean

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --harmony_collections
 var cp = require('./utils/child-process-wrapper.js');
 var path = require('path');
 var os = require('os');
@@ -16,6 +16,9 @@ var killatom = process.platform === 'win32' ? 'START taskkill /F /IM ' + product
 var commands = [
   killatom,
   [__dirname, '..', 'node_modules'],
+  [__dirname, '..', 'build', 'node_modules'],
+  [__dirname, '..', 'apm', 'node_modules'],
+  [__dirname, '..', 'vendor', 'apm', 'node_modules'],
   [__dirname, '..', 'atom-shell'],
   [home, '.atom', '.node-gyp'],
   [home, '.atom', 'storage'],

script/constructicon/build

@@ -1,16 +0,0 @@
-#!/bin/sh
-
-set -ex
-
-# This entire file is a hack so that constructicon can build Atom via
-# xcode
-
-cd "$(dirname "$0")/../.."
-rm -fr node_modules
-rm -fr vendor/apm/node_modules
-./script/bootstrap --no-color
-./node_modules/.bin/grunt --no-color --build-dir="$BUILT_PRODUCTS_DIR" deploy
-
-echo "TARGET_BUILD_DIR=$BUILT_PRODUCTS_DIR"
-echo "FULL_PRODUCT_NAME=Atom.app"
-echo "PRODUCT_NAME=Atom"

script/constructicon/prebuild

@@ -1,8 +0,0 @@
-#!/bin/sh
-
-set -ex
-cd "$(dirname "$0")/../.."
-export PATH="atom-shell/Atom.app/Contents/Resources/:${PATH}"
-
-rm -rf atom.xcodeproj
-gyp --depth=. atom.gyp

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

@@ -0,0 +1,9 @@
+#!/usr/bin/env node --harmony_collections
+var cp = require('./utils/child-process-wrapper.js');
+var path = require('path');
+
+// 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(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/test

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --harmony_collections
 var safeExec = require('./utils/child-process-wrapper.js').safeExec;
 var path = require('path');
 

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'
+{$, $$, 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,23 +496,29 @@ 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", ->
       version = '0.1.0'
-      spyOn(atom, 'getVersion').andCallFake -> version
+      spyOn(atom.constructor, 'getVersion').andCallFake -> version
       expect(atom.isReleasedVersion()).toBe true
       version = '36b5518'
       expect(atom.isReleasedVersion()).toBe false

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

@@ -1,36 +1,34 @@
-{fs} = require 'atom'
 path = require 'path'
+fs = require 'fs-plus'
 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

@@ -1,7 +1,7 @@
-{fs} = require 'atom'
 path = require 'path'
 temp = require 'temp'
 CSON = require 'season'
+fs = require 'fs-plus'
 
 describe "Config", ->
   dotAtomPath = path.join(temp.dir, 'dot-atom-dir')
@@ -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"])
@@ -204,7 +217,7 @@ describe "Config", ->
       expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
 
     afterEach ->
-      fs.removeSync(dotAtomPath) if fs.existsSync(dotAtomPath)
+      fs.removeSync(dotAtomPath)
 
     describe "when the configDirPath doesn't exist", ->
       it "copies the contents of dot-atom to ~/.atom", ->
@@ -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.less'))).toBeTruthy()
 
   describe ".loadUserConfig()", ->
     beforeEach ->
@@ -228,7 +243,7 @@ describe "Config", ->
       expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
 
     afterEach ->
-      fs.removeSync(dotAtomPath) if fs.existsSync(dotAtomPath)
+      fs.removeSync(dotAtomPath)
 
     describe "when the config file contains valid cson", ->
       beforeEach ->
@@ -271,7 +286,7 @@ describe "Config", ->
 
     afterEach ->
       atom.config.unobserveUserConfig()
-      fs.removeSync(dotAtomPath) if fs.existsSync(dotAtomPath)
+      fs.removeSync(dotAtomPath)
 
     describe "when the config file changes to contain valid cson", ->
       it "updates the config data", ->

spec/directory-spec.coffee

@@ -1,124 +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.getEntries()
-      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

@@ -1,16 +1,19 @@
 DisplayBuffer = require '../src/display-buffer'
-{_} = require 'atom'
+_ = require 'underscore-plus'
 
 describe "DisplayBuffer", ->
   [displayBuffer, buffer, changeHandler, tabLength] = []
   beforeEach ->
     tabLength = 2
-    atom.packages.activatePackage('language-javascript', sync: true)
+
     buffer = atom.project.bufferForPathSync('sample.js')
-    displayBuffer = atom.create(new DisplayBuffer({buffer, tabLength}))
+    displayBuffer = new DisplayBuffer({buffer, tabLength})
     changeHandler = jasmine.createSpy 'changeHandler'
     displayBuffer.on 'changed', changeHandler
 
+    waitsForPromise ->
+      atom.packages.activatePackage('language-javascript')
+
   afterEach ->
     displayBuffer.destroy()
     buffer.release()
@@ -150,7 +153,7 @@ describe "DisplayBuffer", ->
       describe "when a newline is inserted, deleted, and re-inserted at the end of a wrapped line (regression)", ->
         it "correctly renders the original wrapped line", ->
           buffer = atom.project.buildBufferSync(null, '')
-          displayBuffer = atom.create(new DisplayBuffer({buffer, tabLength, editorWidthInChars: 30, softWrap: true}))
+          displayBuffer = new DisplayBuffer({buffer, tabLength, editorWidthInChars: 30, softWrap: true})
 
           buffer.insert([0, 0], "the quick brown fox jumps over the lazy dog.")
           buffer.insert([0, Infinity], '\n')
@@ -202,7 +205,7 @@ describe "DisplayBuffer", ->
       displayBuffer.destroy()
       buffer.release()
       buffer = atom.project.bufferForPathSync('two-hundred.txt')
-      displayBuffer = atom.create(new DisplayBuffer({buffer, tabLength}))
+      displayBuffer = new DisplayBuffer({buffer, tabLength})
       displayBuffer.on 'changed', changeHandler
 
     describe "when folds are created and destroyed", ->
@@ -308,7 +311,7 @@ describe "DisplayBuffer", ->
 
       describe "when there is another display buffer pointing to the same buffer", ->
         it "does not create folds in the other display buffer", ->
-          otherDisplayBuffer = atom.create(new DisplayBuffer({buffer, tabLength}))
+          otherDisplayBuffer = new DisplayBuffer({buffer, tabLength})
           displayBuffer.createFold(2, 4)
           expect(otherDisplayBuffer.foldsStartingAtBufferRow(2).length).toBe 0
 

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]])
@@ -28,10 +30,7 @@ describe "Editor", ->
         editor.foldBufferRow(4)
         expect(editor.isFoldedAtBufferRow(4)).toBeTruthy()
 
-        # Simulate serialization with replicate
-        editor2 = editor.replicate()
-        # FIXME: The created hook is called manually on deserialization because globals aren't ready otherwise
-        editor2.created()
+        editor2 = editor.testSerialization()
 
         expect(editor2.id).toBe editor.id
         expect(editor2.getBuffer().getPath()).toBe editor.getBuffer().getPath()
@@ -361,13 +360,13 @@ describe "Editor", ->
           expect(editor.getCursors().length).toBe 1
           expect(editor.getCursorBufferPosition()).toEqual [12,2]
 
-      describe ".moveCursorToBeginningOfLine()", ->
+      describe ".moveCursorToBeginningOfScreenLine()", ->
         describe "when soft wrap is on", ->
           it "moves cursor to the beginning of the screen line", ->
             editor.setSoftWrap(true)
             editor.setEditorWidthInChars(10)
             editor.setCursorScreenPosition([1, 2])
-            editor.moveCursorToBeginningOfLine()
+            editor.moveCursorToBeginningOfScreenLine()
             cursor = editor.getCursor()
             expect(cursor.getScreenPosition()).toEqual [1, 0]
 
@@ -375,19 +374,19 @@ describe "Editor", ->
           it "moves cursor to the beginning of then line", ->
             editor.setCursorScreenPosition [0,5]
             editor.addCursorAtScreenPosition [1,7]
-            editor.moveCursorToBeginningOfLine()
+            editor.moveCursorToBeginningOfScreenLine()
             expect(editor.getCursors().length).toBe 2
             [cursor1, cursor2] = editor.getCursors()
             expect(cursor1.getBufferPosition()).toEqual [0,0]
             expect(cursor2.getBufferPosition()).toEqual [1,0]
 
-      describe ".moveCursorToEndOfLine()", ->
+      describe ".moveCursorToEndOfScreenLine()", ->
         describe "when soft wrap is on", ->
           it "moves cursor to the beginning of the screen line", ->
             editor.setSoftWrap(true)
             editor.setEditorWidthInChars(10)
             editor.setCursorScreenPosition([1, 2])
-            editor.moveCursorToEndOfLine()
+            editor.moveCursorToEndOfScreenLine()
             cursor = editor.getCursor()
             expect(cursor.getScreenPosition()).toEqual [1, 9]
 
@@ -395,12 +394,30 @@ describe "Editor", ->
           it "moves cursor to the end of line", ->
             editor.setCursorScreenPosition [0,0]
             editor.addCursorAtScreenPosition [1,0]
-            editor.moveCursorToEndOfLine()
+            editor.moveCursorToEndOfScreenLine()
             expect(editor.getCursors().length).toBe 2
             [cursor1, cursor2] = editor.getCursors()
             expect(cursor1.getBufferPosition()).toEqual [0,29]
             expect(cursor2.getBufferPosition()).toEqual [1,30]
 
+      describe ".moveCursorToBeginningOfLine()", ->
+        it "moves cursor to the beginning of the buffer line", ->
+          editor.setSoftWrap(true)
+          editor.setEditorWidthInChars(10)
+          editor.setCursorScreenPosition([1, 2])
+          editor.moveCursorToBeginningOfLine()
+          cursor = editor.getCursor()
+          expect(cursor.getScreenPosition()).toEqual [0, 0]
+
+      describe ".moveCursorToEndOfLine()", ->
+        it "moves cursor to the end of the buffer line", ->
+          editor.setSoftWrap(true)
+          editor.setEditorWidthInChars(10)
+          editor.setCursorScreenPosition([0, 2])
+          editor.moveCursorToEndOfLine()
+          cursor = editor.getCursor()
+          expect(cursor.getScreenPosition()).toEqual [3, 4]
+
       describe ".moveCursorToFirstCharacterOfLine()", ->
         describe "when soft wrap is on", ->
           it "moves to the first character of the current screen line or the beginning of the screen line if it's already on the first character", ->
@@ -432,6 +449,13 @@ describe "Editor", ->
             expect(cursor1.getBufferPosition()).toEqual [0,0]
             expect(cursor2.getBufferPosition()).toEqual [1,0]
 
+          it "moves to the beginning of the line if it only contains whitespace ", ->
+            editor.setText("first\n    \nthird")
+            editor.setCursorScreenPosition [1,2]
+            editor.moveCursorToFirstCharacterOfLine()
+            cursor = editor.getCursor()
+            expect(cursor.getBufferPosition()).toEqual [1,0]
+
       describe ".moveCursorToBeginningOfWord()", ->
         it "moves the cursor to the beginning of the word", ->
           editor.setCursorBufferPosition [0, 8]
@@ -797,6 +821,11 @@ describe "Editor", ->
           editor.selectLine()
           expect(editor.getSelectedBufferRange()).toEqual [[12,0], [12,2]]
 
+          editor.setCursorBufferPosition([0, 2])
+          editor.selectLine()
+          editor.selectLine()
+          expect(editor.getSelectedBufferRange()).toEqual [[0,0], [2,0]]
+
       describe ".selectToBeginningOfWord()", ->
         it "selects text from cusor position to beginning of word", ->
           editor.setCursorScreenPosition [0,13]
@@ -1159,6 +1188,27 @@ describe "Editor", ->
               [[10, 0], [10, 0]]
             ]
 
+      describe ".splitSelectionsIntoLines()", ->
+        it "splits all multi-line selections into one selection per line", ->
+          editor.setSelectedBufferRange([[0, 3], [2, 4]])
+          editor.splitSelectionsIntoLines()
+          expect(editor.getSelectedBufferRanges()).toEqual [
+            [[0, 3], [0, 29]]
+            [[1, 0], [1, 30]]
+            [[2, 0], [2, 4]]
+          ]
+
+          editor.setSelectedBufferRange([[0, 3], [1, 10]])
+          editor.splitSelectionsIntoLines()
+          expect(editor.getSelectedBufferRanges()).toEqual [
+            [[0, 3], [0, 29]]
+            [[1, 0], [1, 10]]
+          ]
+
+          editor.setSelectedBufferRange([[0, 0], [0, 3]])
+          editor.splitSelectionsIntoLines()
+          expect(editor.getSelectedBufferRanges()).toEqual [[[0, 0], [0, 3]]]
+
       describe ".consolidateSelections()", ->
         it "destroys all selections but the most recent, returning true if any selections were destroyed", ->
           editor.setSelectedBufferRange([[3, 16], [3, 21]])
@@ -1808,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) {"
@@ -1837,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", ->
@@ -1847,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", ->
@@ -1858,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) {"
@@ -2673,3 +2723,77 @@ describe "Editor", ->
         expect(editor.getCursorBufferPosition()).toEqual [0, 2]
         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 ->
+
+      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", ->
+      waitsForPromise ->
+        atom.packages.activatePackage('language-hyperlink')
+
+      runs ->
+        grammar = atom.syntax.selectGrammar("text.js")
+        {tokens} = grammar.tokenizeLine("var i; // http://github.com")
+
+        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", ->
+        editor = atom.project.openSync('sample.js')
+        editor.setText("// http://github.com")
+
+        {tokens} = editor.lineForScreenRow(0)
+        expect(tokens[1].value).toBe " http://github.com"
+        expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
+
+        waitsForPromise ->
+          atom.packages.activatePackage('language-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", ->
+        editor = atom.project.openSync('sample.js')
+        editor.setText("// SELECT * FROM OCTOCATS")
+
+        {tokens} = editor.lineForScreenRow(0)
+        expect(tokens[1].value).toBe " SELECT * FROM OCTOCATS"
+        expect(tokens[1].scopes).toEqual ["source.js", "comment.line.double-slash.js"]
+
+        waitsForPromise ->
+          atom.packages.activatePackage('package-with-injection-selector')
+
+        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"]
+
+        waitsForPromise ->
+          atom.packages.activatePackage('language-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-injection-selector/grammars/grammar.cson

@@ -0,0 +1,4 @@
+'name': 'test'
+'scopeName': 'source.test'
+'injectionSelector': 'comment'
+'patterns': [{'include': 'source.sql'}]

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"]
 }