Upgrade to gists@0.11.0 for spec fixes

I added some things to tooltips that we need. Namely, fitting them within the viewport.

.gitattributes

@@ -0,0 +1,8 @@
+# Specs depend on character counts, if we don't specify the line endings the
+# fixtures will vary depending on platform
+spec/fixtures/**/*.js text eol=lf
+spec/fixtures/**/*.coffee text eol=lf
+spec/fixtures/**/*.less text eol=lf
+spec/fixtures/**/*.css text eol=lf
+spec/fixtures/**/*.txt text eol=lf
+spec/fixtures/dir/**/* text eol=lf

.github

@@ -1,2 +0,0 @@
-[docs]
-title = The Guide to Atom

.gitignore

@@ -5,6 +5,8 @@
 .nvm-version
 node_modules
 npm-debug.log
+debug.log
 /tags
 /atom-shell/
-docs/api
+docs/output
+spec/fixtures/evil-files/

.gitmodules

@@ -1,9 +1,3 @@
-[submodule "vendor/bootstrap"]
-	path = vendor/bootstrap
-	url = https://github.com/twitter/bootstrap
 [submodule "vendor/apm"]
 	path = vendor/apm
-	url = https://github.com/github/apm.git
-[submodule "vendor/telepath"]
-	path = vendor/telepath
-	url = https://github.com/github/telepath.git
+	url = https://github.com/atom/apm.git

.nakignore

@@ -1,4 +0,0 @@
-tags
-node_modules
-docs/api
-.git

.pairs

@@ -8,6 +8,9 @@ pairs:
   jp: Justin Palmer; justin
   gt: Garen Torikian; garen
   mc: Matt Colyer; mcolyer
+  bo: Ben Ogle; benogle
+  jr: Jason Rudolph; jasonrudolph
+  jl: Jessica Lord; jlord
 email:
   domain: github.com
 #global: true

CHANGELOG.md

@@ -1,62 +0,0 @@
-* Improved: cmd-n now opens a new tab and cmd-shift-n now opens a new window.
-* Added: Inspect Element context menu
-* Fixed: Save As dialog now defaults to directory path of current editor
-* Fixed: Using toggle comment shortcut respects indentation level
-
-* Fixed: Search never completing in the command panel
-
-* Fixed: cmd-n now works when no windows are open
-
-* Fixed: Error selecting a grammar for an untitled editor
-
-* Added: j/k now can be used to navigate the tree view and archive editor
-
-* Fixed: Atom can now be launched when ~/.atom/config.cson doesn't exist
-* Added: Initial collaboration sessions
-* Fixed: Empty lines being deleted via uppercase/downcase command
-* Fixed: Keybindings not working when using non-English keyboard language
-* Fixed: cmd-shift-p and cmd-alt-w not doing anything when pressed
-
-* Improved: Use grunt (instead of rake) for build system
-* Fixed: Java files not syntax highlighting correctly.
-* Fixed: LESS/CSS now indents properly after hitting enter.
-* Added: Support for browsing .tar.gz and .zip files in the editor
-* Added: TODO/FIXME/CHANGED are now highlighted in comments.
-* Fixed: Full screen state of windows is now persisted across restarts.
-* Added: Makefile syntax highlighting now included.
-* Added: Open fuzzy finder to specific line using colon suffix (i.e ':25')
-* Fixed: Issues deleting and moving over certain UTF-8 characters
-* Fixed: Tree view not properly highlighting or revealing for open images.
-* Added: Packages can now be installed from the configuration UI.
-* Fixed: .git folder now ignored by default when searching
-
-* Fixed: Not being able to disable packages from configuration UI.
-* Fixed: Fuzzy finder showing poor results for entered text
-* Improved: App icon
-
-* Fixed: Fuzzy finder being empty sometimes
-
-* Improved: App icon
-* Fixed: End of line invisibles rendering incorrectly with the indent guide
-* Fixed: Updates not installing automatically on restart
-* Fixed: Wrap guide not displaying
-* Fixed: Error when saving with the markdown preview focused
-
-* Fixed: Atom always running in dev mode
-* Fixed: Crash when running in dev mode without a path to the Atom source
-
-* Fixed: Freeze when editing a RoR class
-* Added: meta-N to open a new untitled editor in the current window
-
-* Fixed: Styling in command logger
-* Added: XML and Ruby syntax highlighting in Markdown files
-* Fixed: Error when editing files in a HEAD-less Git repository
-
-* Fixed: Invisible characters not being visible when enabled
-* Added: Editor gutter now displays Git status for lines
-
-* Improved: Startup time
-* Added: SQL bundle now included
-* Added: PEG.js bundle now included
-* Added: Hyperlinks can now be opened with ctrl-O
-* Fixed: PHP syntax highlighting

CONTRIBUTING.md

@@ -1,5 +1,6 @@
 # :rotating_light: Contributing to Atom :rotating_light:
 
+
 ## Issues
   * Include screenshots and animated GIFs whenever possible, they are immensely
     helpful
@@ -9,20 +10,58 @@
   * Check the Dev tools (`alt-cmd-i`) for errors and stack traces to include
 
 ## Code
-  * Follow the [JavaScript](https://github.com/styleguide/javascript),
-    [CSS](https://github.com/styleguide/css),
-    and [Objective-C](https://github.com/github/objective-c-conventions)
-    styleguides
+  * Follow the [JavaScript](https://github.com/styleguide/javascript) and
+    [CSS](https://github.com/styleguide/css) styleguides
   * Include thoughtfully worded [Jasmine](http://pivotal.github.com/jasmine/)
     specs
-  * Style new elements in both the light and dark default themes when
-    appropriate
-  * New packages go in `src/packages/`
   * Add 3rd-party packages as a `package.json` dependency
   * Commit messages are in the present tense
+  * Commit messages that improve the format of the code start with :lipstick:
+  * Commit messages that improve the performance start with :racehorse:
+  * Commit messages that remove memory leaks start with :non-potable_water:
+  * Commit messages that improve documentation start with :memo:
   * Files end with a newline
   * Class variables and methods should be in the following order:
     * Class variables (variables starting with a `@`)
     * Class methods (methods starting with a `@`)
     * Instance variables
     * Instance methods
+  * Beware of platform differences
+    * The home directory is `process.env.USERPROFILE` on Windows, while on OS X
+      and Linux it's `process.env.HOME`
+    * Path separator is `\` on Windows, and is `/` on OS X and Linux, so use
+      `path.join` to concatenate filenames
+    * Temporary directory is not `/tmp` on Windows, use `os.tmpdir()` when
+      possible
+
+## Philosophy
+
+### Write Beautiful Code
+Once you get something working, take the time to consider whether you can achieve it in a more elegant way. We're planning on open-sourcing Atom, so let's put our best foot forward.
+
+### When in doubt, pair-up
+Pairing can be an effective and fun way to pass on culture, knowledge, and taste. If you can find the time, we encourage you to work synchronously with other community members of all experience levels to help the knowledge-mulching process. It doesn't have to be all the time; a little pairing goes a long way.
+
+### Write tests, and write them first
+The test suite keeps protects our codebase from the ravages of entropy, but it only works when we have thorough coverage. Before you write implementation code, write a  failing test proving that it's needed.
+
+### Leave the test suite better than you found it
+Consider how the specs you are adding fit into the spec-file as a whole. Is this the right place for your spec? Does the spec need to be reorganized now that you're adding this extra dimension? Specs are only as useful as the next person's ability to understand them.
+
+### Solve today's problem
+Avoid adding flexibility that isn't needed *today*. Nothing is ever set in stone, and we can always go back and add flexibility later. Adding it early just means we have to pay for complexity that we might not end up using.
+
+### Favor clarity over brevity or cleverness.
+Three lines that someone else can read are better than one line that's tricky.
+
+### Don't be defensive
+Only catch exceptions that are truly exceptional. Assume that components we control will honor their contracts. If they don't, the solution is to find and fix the problem in code rather than cluttering the code with attempts to foresee all potential issues at runtime.
+
+### Don't be afraid to add classes and methods
+Code rarely suffers from too many methods and classes, and  often suffers from too few. Err on the side of numerous short, well-named methods. Pull out classes with well-defined roles.
+
+### Rip shit out
+Don't be afraid to delete code. Don't be afraid to rewrite something that needs to be refreshed. If it's in version control, we can always resurrect it.
+
+### Maintain a consistent level of abstraction
+Every line in a method should read at the same basic level of abstraction. If there's a section of a method that goes into a lot more detail than the rest of the method, consider extracting a new method and giving it a clear name.

Gruntfile.coffee

@@ -1,58 +1,103 @@
+fs = require 'fs'
 path = require 'path'
+os = require 'os'
+
+fm = require 'json-front-matter'
+_ = require 'underscore-plus'
+
+packageJson = require './package.json'
 
 module.exports = (grunt) ->
-  appName = 'Atom.app'
-  buildDir = grunt.option('build-dir') ? '/tmp/atom-build'
-  shellAppDir = path.join(buildDir, appName)
-  contentsDir = path.join(shellAppDir, 'Contents')
-  appDir = path.join(contentsDir, 'Resources', 'app')
-  installDir = path.join('/Applications', appName)
+  if not grunt.option('verbose')
+    grunt.log.writeln = (args...) -> grunt.log
+    grunt.log.write = (args...) -> grunt.log
+
+  [major, minor, patch] = packageJson.version.split('.')
+  if process.platform is 'win32'
+    appName = 'Atom'
+    tmpDir = os.tmpdir()
+    installRoot = process.env.ProgramFiles
+    buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
+    shellAppDir = path.join(buildDir, appName)
+    appDir = path.join(shellAppDir, 'resources', 'app')
+  else
+    appName = 'Atom.app'
+    tmpDir = '/tmp'
+    installRoot = '/Applications'
+    buildDir = grunt.option('build-dir') ? path.join(tmpDir, 'atom-build')
+    shellAppDir = path.join(buildDir, appName)
+    contentsDir = path.join(shellAppDir, 'Contents')
+    appDir = path.join(contentsDir, 'Resources', 'app')
+
+  installDir = path.join(installRoot, appName)
+
+  coffeeConfig =
+    options:
+      sourceMap: true
+    glob_to_multiple:
+      expand: true
+      src: [
+        'src/**/*.coffee'
+        'exports/**/*.coffee'
+        'static/**/*.coffee'
+      ]
+      dest: appDir
+      ext: '.js'
+
+  lessConfig =
+    options:
+      paths: [
+        'static/variables'
+        'static'
+      ]
+    glob_to_multiple:
+      expand: true
+      src: [
+        'static/**/*.less'
+      ]
+      dest: appDir
+      ext: '.css'
+
+  prebuildLessConfig =
+    src: [
+      'static/**/*.less'
+      'node_modules/bootstrap/less/bootstrap.less'
+    ]
+
+  csonConfig =
+    options:
+      rootObject: true
+    glob_to_multiple:
+      expand: true
+      src: [
+        'menus/*.cson'
+        'keymaps/*.cson'
+        'static/**/*.cson'
+      ]
+      dest: appDir
+      ext: '.json'
+
+  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'))
+    if engines?.atom?
+      coffeeConfig.glob_to_multiple.src.push("#{directory}/**/*.coffee")
+      lessConfig.glob_to_multiple.src.push("#{directory}/**/*.less")
+      prebuildLessConfig.src.push("#{directory}/**/*.less") unless theme
+      csonConfig.glob_to_multiple.src.push("#{directory}/**/*.cson")
 
   grunt.initConfig
     pkg: grunt.file.readJSON('package.json')
 
     atom: {appDir, appName, buildDir, contentsDir, installDir, shellAppDir}
 
-    coffee:
-      options:
-        sourceMap: true
-      glob_to_multiple:
-        expand: true
-        src: [
-          'src/**/*.coffee'
-          'static/**/*.coffee'
-        ]
-        dest: appDir
-        ext: '.js'
+    coffee: coffeeConfig
 
-    less:
-      options:
-        paths: [
-          'static'
-          'vendor'
-        ]
-      glob_to_multiple:
-        expand: true
-        src: [
-          'src/**/*.less'
-          'static/**/*.less'
-          'themes/**/*.less'
-        ]
-        dest: appDir
-        ext: '.css'
+    less: lessConfig
 
-    cson:
-      options:
-        rootObject: true
-      glob_to_multiple:
-        expand: true
-        src: [
-          'src/**/*.cson'
-          'static/**/*.cson'
-          'themes/**/*.cson'
-        ]
-        dest: appDir
-        ext: '.json'
+    'prebuild-less': prebuildLessConfig
+
+    cson: csonConfig
 
     coffeelint:
       options:
@@ -60,23 +105,28 @@ module.exports = (grunt) ->
           level: 'error'
         max_line_length:
           level: 'ignore'
+        indentation:
+          level: 'ignore'
       src: [
         'dot-atom/**/*.coffee'
+        'exports/**/*.coffee'
         'src/**/*.coffee'
+        'tasks/**/*.coffee'
+        'Gruntfile.coffee'
       ]
       test: [
         'spec/*.coffee'
-        'spec/app/**/*.coffee'
-        'spec/stdlib/**/*.coffee'
       ]
 
     csslint:
       options:
         'adjoining-classes': false
+        'duplicate-background-images': false
         'box-model': false
         'box-sizing': false
         'bulletproof-font-face': false
         'compatible-vendor-prefixes': false
+        'display-property-grouping': false
         'fallback-colors': false
         'font-sizes': false
         'gradients': false
@@ -90,28 +140,56 @@ module.exports = (grunt) ->
         'universal-selector': false
         'vendor-prefix': false
       src: [
-        'src/**/*.css',
         'static/**/*.css'
-        'themes/**/*.css'
       ]
 
     lesslint:
       src: [
-        'src/**/*.less',
         'static/**/*.less'
-        'themes/**/*.less'
       ]
 
+    markdown:
+      guides:
+        files: [
+          expand: true
+          cwd: 'docs'
+          src: '**/*.md'
+          dest: 'docs/output/'
+          ext: '.html'
+        ]
+        options:
+          template: 'docs/template.jst'
+          templateContext:
+            tag: "v#{major}.#{minor}"
+          markdownOptions:
+            gfm: true
+          preCompile: (src, context) ->
+            parsed = fm.parse(src)
+            _.extend(context, parsed.attributes)
+            parsed.body
+
+    shell:
+      'kill-atom':
+        command: 'pkill -9 Atom'
+        options:
+          stdout: false
+          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-shell')
   grunt.loadTasks('tasks')
 
-  grunt.registerTask('compile', ['coffee', 'less', 'cson'])
+  grunt.registerTask('compile', ['coffee', 'prebuild-less', 'cson'])
   grunt.registerTask('lint', ['coffeelint', 'csslint', 'lesslint'])
-  grunt.registerTask('ci', ['lint', 'partial-clean', 'update-atom-shell', 'build', 'test'])
+  grunt.registerTask('test', ['shell:kill-atom', 'run-specs'])
+  grunt.registerTask('ci', ['update-atom-shell', 'build', 'set-development-version', 'lint', 'test'])
   grunt.registerTask('deploy', ['partial-clean', 'update-atom-shell', 'build', 'codesign'])
+  grunt.registerTask('docs', ['markdown:guides', 'build-docs'])
   grunt.registerTask('default', ['update-atom-shell', 'build', 'set-development-version', 'install'])

README.md

@@ -2,7 +2,7 @@
 
 ![atom](https://s3.amazonaws.com/speakeasy/apps/icons/27/medium/7db16e44-ba57-11e2-8c6f-981faf658e00.png)
 
-Check out our [documentation on the docs tab](https://github.com/github/atom/docs).
+Check out our [guides](https://www.atom.io/docs/latest/) and [API documentation](https://www.atom.io/docs/api/v34.0.0/api/)
 
 ## Installing
 
@@ -15,6 +15,7 @@ It will automatically update when a new release is available.
 ### Requirements
 
   * Mountain Lion
+    * Looking for Windows support? Read [here][building].
   * Boxen (Obviously Atom won't release with this requirement)
 
 ### Installation
@@ -24,3 +25,6 @@ It will automatically update when a new release is available.
   2. `cd ~/github/atom`
 
   3. `script/build`
+
+
+[building]: https://github.com/atom/atom/blob/master/docs/building-atom.md

Rakefile

@@ -1,11 +0,0 @@
-rule "" do |t|
-  puts <<-HELP
-    Atom now uses grunt instead of Rake.
-    See https://github.com/github/atom/pull/596 for more info.
-
-    tl;dr
-    -----
-    Run ./script/build instead of rake install.
-
-  HELP
-end

aa

@@ -1,2 +0,0 @@
-coffee -c -o /Applications/Atom.app/Contents/Resources/app/src/ src/main.coffee src/atom-application.coffee src/atom-window.coffee &&
-/Applications/Atom.app/Contents/MacOS/Atom --resource-path=$(pwd) --executed-from=$(pwd) $@

atom.sh

@@ -1,5 +1,6 @@
 #!/bin/sh
-ATOM_PATH=/Applications/Atom.app
+ATOM_PATH=${ATOM_PATH-/Applications/Atom.app}
+ATOM_BINARY=$ATOM_PATH/Contents/MacOS/Atom
 
 if [ ! -d $ATOM_PATH ]; then sleep 5; fi # Wait for Atom to reappear, Sparkle may be replacing it.
 
@@ -8,7 +9,33 @@ if [ ! -d $ATOM_PATH ]; then
   exit 1
 fi
 
-open -a $ATOM_PATH -n --args --executed-from="$(pwd)" --pid=$$ $@
+while getopts ":wtfvhs-:" opt; do
+  case "$opt" in
+    -)
+      case "${OPTARG}" in
+        wait)
+          WAIT=1
+          ;;
+        help|version|foreground|test)
+          EXPECT_OUTPUT=1
+          ;;
+      esac
+      ;;
+    w)
+      WAIT=1
+      ;;
+    h|v|f|t)
+      EXPECT_OUTPUT=1
+      ;;
+  esac
+done
+
+if [ $EXPECT_OUTPUT ]; then
+  $ATOM_BINARY --executed-from="$(pwd)" --pid=$$ $@
+  exit $?
+else
+  open -a $ATOM_PATH -n --args --executed-from="$(pwd)" --pid=$$ $@
+fi
 
 # Used to exit process when atom is used as $EDITOR
 on_die() {
@@ -16,16 +43,6 @@ on_die() {
 }
 trap 'on_die' SIGQUIT SIGTERM
 
-# Don't exit process if we were told to wait.
-while [ "$#" -gt "0" ]; do
-  case $1 in
-    -W|--wait)
-      WAIT=1
-      ;;
-  esac
-  shift
-done
-
 if [ $WAIT ]; then
   while true; do
     sleep 1

benchmark/benchmark-bootstrap.coffee

@@ -1,5 +1,13 @@
-require 'atom'
-{runSpecSuite} = require 'jasmine-helper'
+require '../src/window'
+Atom = require '../src/atom'
+atom = new Atom()
+atom.show() unless atom.getLoadSettings().exitWhenDone
+window.atom = atom
+
+{runSpecSuite} = require '../spec/jasmine-helper'
+
+atom.openDevTools()
 
 document.title = "Benchmark Suite"
-runSpecSuite("benchmark-suite", true)
+benchmarkSuite = require.resolve('./benchmark-suite')
+runSpecSuite(benchmarkSuite, true)

benchmark/benchmark-helper.coffee

@@ -1,30 +1,9 @@
-nakedLoad 'jasmine-jquery'
-$ = require 'jquery'
-_ = require 'underscore'
-Keymap = require 'keymap'
-Point = require 'point'
-Config = require 'config'
-Project = require 'project'
+require '../spec/spec-helper'
 
-require 'window'
-requireStylesheet "jasmine.less"
-
-# Load TextMate bundles, which specs rely on (but not other packages)
-atom.loadTextMatePackages()
-
-beforeEach ->
-  # reset config after each benchmark; don't load or save from/to `config.json`
-  window.config = new Config()
-  spyOn(config, 'load')
-  spyOn(config, 'save')
-
-keymap = new Keymap
-keymap.bindDefaultKeys()
-$(window).on 'keydown', (e) -> keymap.handleKeyEvent(e)
-keymap.bindKeys '*',
-  'meta-w': 'close'
-  'alt-meta-i': 'show-console'
-$(document).on 'close', -> window.close()
+path = require 'path'
+{$, _, Point, fs} = require 'atom'
+Project = require '../src/project'
+TokenizedBuffer = require '../src/tokenized-buffer'
 
 defaultCount = 100
 window.pbenchmark = (args...) -> window.benchmark(args..., profile: true)
@@ -32,7 +11,13 @@ window.fbenchmark = (args...) -> window.benchmark(args..., focused: true)
 window.fpbenchmark = (args...) -> window.benchmark(args..., profile: true, focused: true)
 window.pfbenchmark = window.fpbenchmark
 
-window.benchmarkFixturesProject = new Project(require.resolve 'benchmark/fixtures')
+window.benchmarkFixturesProject = new Project(path.join(__dirname, 'fixtures'))
+
+beforeEach ->
+  window.project = window.benchmarkFixturesProject
+  jasmine.unspy(window, 'setTimeout')
+  jasmine.unspy(window, 'clearTimeout')
+  jasmine.unspy(TokenizedBuffer::, 'tokenizeInBackground')
 
 window.benchmark = (args...) ->
   description = args.shift()
@@ -43,7 +28,6 @@ window.benchmark = (args...) ->
   [fn, options] = args
   { profile, focused } = (options ? {})
 
-  atom.showDevTools() if profile
   method = if focused then fit else it
   method description, ->
     total = measure ->
@@ -89,8 +73,8 @@ window.clickEvent = (properties={}) ->
 
 window.mouseEvent = (type, properties) ->
   if properties.point
-    {point, editor} = properties
-    {top, left} = @pagePixelPositionForPoint(editor, point)
+    {point, editorView} = properties
+    {top, left} = @pagePixelPositionForPoint(editorView, point)
     properties.pageX = left + 1
     properties.pageY = top + 1
   properties.originalEvent ?= {detail: 1}
@@ -102,14 +86,14 @@ window.mousedownEvent = (properties={}) ->
 window.mousemoveEvent = (properties={}) ->
   window.mouseEvent('mousemove', properties)
 
-window.pagePixelPositionForPoint = (editor, point) ->
+window.pagePixelPositionForPoint = (editorView, point) ->
   point = Point.fromObject point
-  top = editor.lines.offset().top + point.row * editor.lineHeight
-  left = editor.lines.offset().left + point.column * editor.charWidth - editor.lines.scrollLeft()
+  top = editorView.lines.offset().top + point.row * editorView.lineHeight
+  left = editorView.lines.offset().left + point.column * editorView.charWidth - editorView.lines.scrollLeft()
   { top, left }
 
-window.setEditorWidthInChars = (editor, widthInChars, charWidth=editor.charWidth) ->
-  editor.width(charWidth * widthInChars + editor.lines.position().left)
+window.seteditorViewWidthInChars = (editorView, widthInChars, charWidth=editorView.charWidth) ->
+  editorView.width(charWidth * widthInChars + editorView.lines.position().left)
 
 $.fn.resultOfTrigger = (type) ->
   event = $.Event(type)

benchmark/benchmark-suite.coffee

@@ -1,113 +1,217 @@
-require 'benchmark-helper'
-$ = require 'jquery'
-_ = require 'underscore'
-TokenizedBuffer = require 'tokenized-buffer'
+require './benchmark-helper'
+{$, _, RootView} = require 'atom'
+TokenizedBuffer = require '../src/tokenized-buffer'
 
-describe "editor.", ->
-  editor = null
+describe "editorView.", ->
+  editorView = null
 
   beforeEach ->
     window.rootViewParentSelector = '#jasmine-content'
-    window.attachRootView(require.resolve('benchmark/fixtures'))
+    window.rootView = new RootView
+    window.rootView.attachToDom()
 
     rootView.width(1024)
     rootView.height(768)
-    rootView.open() # open blank editor
-    editor = rootView.getActiveEditor()
+    rootView.openSync()
+    editorView = rootView.getActiveView()
 
   afterEach ->
-    if editor.pendingDisplayUpdate
+    if editorView.pendingDisplayUpdate
       waitsFor "editor to finish rendering", (done) ->
-        editor.on 'editor:display-updated', done
-
-    runs ->
-      projectPath = project.getPath()
-      $(window).off 'beforeunload'
-      window.shutdown()
-      atom.setRootViewStateForPath(projectPath, null)
+        editorView.on 'editor:display-updated', done
 
   describe "keymap.", ->
     event = null
 
     beforeEach ->
-      event = keydownEvent('x', target: editor.hiddenInput[0])
+      event = keydownEvent('x', target: editorView.hiddenInput[0])
 
     benchmark "keydown-event-with-no-binding", 10, ->
       keymap.handleKeyEvent(event)
 
   describe "opening-buffers.", ->
     benchmark "300-line-file.", ->
-      buffer = project.bufferForPath('medium.coffee')
+      buffer = project.bufferForPathSync('medium.coffee')
 
   describe "empty-file.", ->
     benchmark "insert-delete", ->
-      editor.insertText('x')
-      editor.backspace()
+      editorView.insertText('x')
+      editorView.backspace()
 
   describe "300-line-file.", ->
     beforeEach ->
-      rootView.open('medium.coffee')
+      rootView.openSync('medium.coffee')
 
     describe "at-begining.", ->
       benchmark "insert-delete", ->
-        editor.insertText('x')
-        editor.backspace()
+        editorView.insertText('x')
+        editorView.backspace()
 
       benchmark "insert-delete-rehighlight", ->
-        editor.insertText('"')
-        editor.backspace()
+        editorView.insertText('"')
+        editorView.backspace()
 
     describe "at-end.", ->
       beforeEach ->
-        editor.moveCursorToBottom()
+        editorView.moveCursorToBottom()
 
       benchmark "insert-delete", ->
-        editor.insertText('"')
-        editor.backspace()
+        editorView.insertText('"')
+        editorView.backspace()
+
+    describe "empty-vs-set-innerHTML.", ->
+      [firstRow, lastRow] = []
+      beforeEach ->
+        firstRow = editorView.getFirstVisibleScreenRow()
+        lastRow = editorView.getLastVisibleScreenRow()
+
+      benchmark "build-gutter-html.", 1000, ->
+        editorView.gutter.renderLineNumbers(null, firstRow, lastRow)
+
+      benchmark "set-innerHTML.", 1000, ->
+        editorView.gutter.renderLineNumbers(null, firstRow, lastRow)
+        editorView.gutter.lineNumbers[0].innerHtml = ''
+
+      benchmark "empty.", 1000, ->
+        editorView.gutter.renderLineNumbers(null, firstRow, lastRow)
+        editorView.gutter.lineNumbers.empty()
+
+    describe "positionLeftForLineAndColumn.", ->
+      line = null
+      beforeEach ->
+        editorView.scrollTop(2000)
+        editorView.resetDisplay()
+        line = editorView.lineElementForScreenRow(106)[0]
+
+      describe "one-line.", ->
+        beforeEach ->
+          editorView.clearCharacterWidthCache()
+
+        benchmark "uncached", 5000, ->
+          editorView.positionLeftForLineAndColumn(line, 106, 82)
+          editorView.clearCharacterWidthCache()
+
+        benchmark "cached", 5000, ->
+          editorView.positionLeftForLineAndColumn(line, 106, 82)
+
+      describe "multiple-lines.", ->
+        [firstRow, lastRow] = []
+        beforeEach ->
+          firstRow = editorView.getFirstVisibleScreenRow()
+          lastRow = editorView.getLastVisibleScreenRow()
+
+        benchmark "cache-entire-visible-area", 100, ->
+          for i in [firstRow..lastRow]
+            line = editorView.lineElementForScreenRow(i)[0]
+            editorView.positionLeftForLineAndColumn(line, i, Math.max(0, editorView.lineLengthForBufferRow(i)))
+
+    describe "text-rendering.", ->
+      beforeEach ->
+        editorView.scrollTop(2000)
+
+      benchmark "resetDisplay", 50, ->
+        editorView.resetDisplay()
+
+      benchmark "htmlForScreenRows", 1000, ->
+        lastRow = editorView.getLastScreenRow()
+        editorView.htmlForScreenRows(0, lastRow)
+
+      benchmark "htmlForScreenRows.htmlParsing", 50, ->
+        lastRow = editorView.getLastScreenRow()
+        html = editorView.htmlForScreenRows(0, lastRow)
+
+        div = document.createElement('div')
+        div.innerHTML = html
+
+    describe "gutter-api.", ->
+      describe "getLineNumberElementsForClass.", ->
+        beforeEach ->
+          editorView.gutter.addClassToLine(20, 'omgwow')
+          editorView.gutter.addClassToLine(40, 'omgwow')
+
+        benchmark "DOM", 20000, ->
+          editorView.gutter.getLineNumberElementsForClass('omgwow')
+
+      benchmark "getLineNumberElement.DOM", 20000, ->
+        editorView.gutter.getLineNumberElement(12)
+
+      benchmark "toggle-class", 2000, ->
+        editorView.gutter.addClassToLine(40, 'omgwow')
+        editorView.gutter.removeClassFromLine(40, 'omgwow')
+
+      describe "find-then-unset.", ->
+        classes = ['one', 'two', 'three', 'four']
+
+        benchmark "single-class", 200, ->
+          editorView.gutter.addClassToLine(30, 'omgwow')
+          editorView.gutter.addClassToLine(40, 'omgwow')
+          editorView.gutter.removeClassFromAllLines('omgwow')
+
+        benchmark "multiple-class", 200, ->
+          editorView.gutter.addClassToLine(30, 'one')
+          editorView.gutter.addClassToLine(30, 'two')
+
+          editorView.gutter.addClassToLine(40, 'two')
+          editorView.gutter.addClassToLine(40, 'three')
+          editorView.gutter.addClassToLine(40, 'four')
+
+          for klass in classes
+            editorView.gutter.removeClassFromAllLines(klass)
+
+    describe "line-htmlification.", ->
+      div = null
+      html = null
+      beforeEach ->
+        lastRow = editorView.getLastScreenRow()
+        html = editorView.htmlForScreenRows(0, lastRow)
+        div = document.createElement('div')
+
+      benchmark "setInnerHTML", 1, ->
+        div.innerHTML = html
 
   describe "9000-line-file.", ->
     benchmark "opening.", 5, ->
-      rootView.open('huge.js')
+      rootView.openSync('huge.js')
 
     describe "after-opening.", ->
       beforeEach ->
-        rootView.open('huge.js')
+        rootView.openSync('huge.js')
 
       benchmark "moving-to-eof.", 1, ->
-        editor.moveCursorToBottom()
+        editorView.moveCursorToBottom()
 
       describe "on-first-line.", ->
         benchmark "inserting-newline", 5, ->
-          editor.insertNewline()
+          editorView.insertNewline()
 
       describe "on-last-visible-line.", ->
         beforeEach ->
-          editor.setCursorScreenPosition([editor.getLastVisibleScreenRow(), 0])
+          editorView.setCursorScreenPosition([editorView.getLastVisibleScreenRow(), 0])
 
         benchmark "move-down-and-scroll", 300, ->
-          editor.trigger 'move-down'
+          editorView.trigger 'move-down'
 
       describe "at-eof.", ->
         endPosition = null
 
         beforeEach ->
-          editor.moveCursorToBottom()
-          endPosition = editor.getCursorScreenPosition()
+          editorView.moveCursorToBottom()
+          endPosition = editorView.getCursorScreenPosition()
 
         benchmark "move-to-beginning-of-word", ->
-          editor.moveCursorToBeginningOfWord()
-          editor.setCursorScreenPosition(endPosition)
+          editorView.moveCursorToBeginningOfWord()
+          editorView.setCursorScreenPosition(endPosition)
 
         benchmark "insert", ->
-          editor.insertText('x')
+          editorView.insertText('x')
 
 describe "TokenizedBuffer.", ->
   describe "coffee-script-grammar.", ->
     [languageMode, buffer] = []
 
     beforeEach ->
-      editSession = benchmarkFixturesProject.open('medium.coffee')
-      { languageMode, buffer } = editSession
+      editor = benchmarkFixturesProject.openSync('medium.coffee')
+      { languageMode, buffer } = editor
 
     benchmark "construction", 20, ->
       new TokenizedBuffer(buffer, { languageMode, tabLength: 2})

docs/building-atom.md

@@ -0,0 +1,34 @@
+## Building Atom
+
+These guide is meant only for users who wish to help develop atom core,
+if you're just interested in using atom you should just [download
+atom][download].
+
+## OSX
+
+* Use Mountain Lion
+* Install the latest node 0.10.x release (32bit preferable)
+* Clone [atom][atom-git] to `~/github/atom`
+* Run `~/github/atom/script/bootstrap`
+
+## Windows
+
+* Install [Visual C++ 2010 Express][win-vs2010]
+* Install the [latest 32bit Node 0.10.x][win-node]
+* Install the [latest Python 2.7.x][win-python]
+* Install [GitHub for Windows][win-github]
+* Clone [atom/atom][atom-git] to `C:\Users\<user>\github\atom\`
+* Add `C:\Python27;C:\Program Files\nodejs;C:\Users\<user>\github\atom\node_modules\`
+  to your PATH
+* Set ATOM_ACCESS_TOKEN to your oauth2 credentials (run `security -q
+  find-generic-password -ws 'GitHub API Token'` on OSX to get your
+  credentials).
+* Use the Windows GitHub shell and cd into `C:\Users\<user>\github\atom`
+* Run `script\bootstrap`
+
+[download]: http://www.atom.io
+[win-node]: http://nodejs.org/download/
+[win-python]: http://www.python.org/download/
+[win-github]: http://windows.github.com/
+[win-vs2010]: http://www.microsoft.com/visualstudio/eng/products/visual-studio-2010-express
+[atom-git]: https://github.com/atom/atom/

docs/built-in-packages/command-panel.md

@@ -1,29 +0,0 @@
-## Command Panel
-
-The command panel contains a  partial implementation of the [Sam command language](http://man.cat-v.org/plan_9/1/sam).
-In addition, packages are free to design and define any scoped command.
-
-Pop open the command line by hitting .
-You can get a list of commands available to Atom (including any keybindings) by hitting `meta-p`.
-
-## Examples
-
-`,` selects the entire file
-
-`1,4` selects lines 1-4 in the current file
-
-`/pattern` selects the first match after the cursor/selection
-
-`s/pattern/replacement` replaces the first text matching pattern in current selection
-
-`s/pattern/replacement/g` replaces all text matching pattern in current selection
-
-`,s/pattern/replacement/g` replaces all text matching pattern in file
-
-`1,4s/pattern/replacement` replaces all text matching pattern in lines 1-4
-
-`x/pattern` selects all matches in the current selections
-
-`,x/pattern` selects all matches in the file
-
-`,x/pattern1/ x/pattern2` "structural regex" - selects all matches of pattern2 inside matches of pattern1

docs/built-in-packages/intro.md

@@ -1,3 +0,0 @@
-# Built-In Packages
-
-Atom ships with several optional built-in packages.

docs/built-in-packages/markdown-preview.md

@@ -1,7 +0,0 @@
-## Markdown Preview
-
-The `markdown-preview` extension displays the rendered HTML for the markdown
-in the current editor.
-
-It can be activated from the editor using the `ctrl-m` key-binding and is
-currently enabled for `.markdown`, `.md`, `.mkd`, `.mkdown`, and `.ron` files.

docs/built-in-packages/wrap-guide.md

@@ -1,33 +0,0 @@
-## Wrap Guide
-
-The `wrap-guide` extension places a vertical line in each editor at a certain
-column to guide your formatting, so lines do not exceed a certain width.
-
-By default, the wrap-guide is placed at the 80th column.
-
-### Configuration
-
-You can customize where the column is placed using the `wrapGuide.columns`
-config option:
-
-```coffeescript
-"wrap-guide":
-  columns: [
-    { pattern: "\.mm$", column: 200 },
-    { pattern: "\.cc$", column: 120 }
-  ]
-```
-
-The above config example would place the guide at the 200th column for paths
-that end with `.mm` and place the guide at the 120th column for paths that end
-with `.cc`.
-
-You can configure the color and/or width of the line by adding the following
-CSS to a custom stylesheet:
-
-```css
-.wrap-guide {
-  width: 10px;
-  background-color: red;
-}
-```

docs/creating-a-package.md

@@ -0,0 +1,395 @@
+# Creating Packages
+
+Packages are at the core of Atom. Nearly everything outside of the main editor
+is handled by a package. That includes "core" pieces like the [file tree][file-tree],
+[status bar][status-bar], [syntax highlighting][cs-syntax], and more.
+
+A package can contain a variety of different resource types to change Atom's
+behavior. The basic package layout is as follows:
+
+```text
+my-package/
+  grammars/
+  keymaps/
+  lib/
+  menus/
+  spec/
+  snippets/
+  stylesheets/
+  index.coffee
+  package.json
+```
+
+Not every package will have (or need) all of these directories.
+
+We have [a tutorial on creating your first package][first-package].
+
+## package.json
+
+Similar to [npm packages][npm], Atom packages contain a _package.json_ file
+in their top-level directory. This file contains metadata about the package,
+such as the path to its "main" module, library dependencies, and manifests
+specifying the order in which its resources should be loaded.
+
+In addition to the regular [npm package.json keys][npm-keys] available, Atom
+package.json files have their own additions.
+
+- `main` (**Required**): the path to the CoffeeScript file that's the entry point
+to your package
+- `stylesheets` (**Optional**): an Array of Strings identifying the order of the
+stylesheets your package needs to load. If not specified, stylesheets in the
+_stylesheets_ directory are added alphabetically.
+- `keymaps`(**Optional**): an Array of Strings identifying the order of the
+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.
+- `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.
+
+## Source Code
+
+If you want to extend Atom's behavior, your package should contain a single
+top-level module, which you export from _index.coffee_ (or whichever file is
+indicated by the `main` key in your _package.json_ file). The remainder of your
+code should be placed in the `lib` directory, and required from your top-level
+file.
+
+Your package's top-level module is a singleton object that manages the lifecycle
+of your extensions to Atom. Even if your package creates ten different views and
+appends them to different parts of the DOM, it's all managed from your top-level
+object.
+
+Your package's top-level module should implement the following methods:
+
+- `activate(rootView, state)`: This **required** method is called when your
+package is loaded. It is always passed the window's global `rootView`, and is
+sometimes passed state data if the window has been reloaded and your module
+implements the `serialize` method. Use this to do initialization work when your
+package is started (like setting up DOM elements or binding events).
+
+- `serialize()`: This **optional** method is called when the window is shutting
+down, allowing you to return JSON to represent the state of your component. When
+the window is later restored, the data you returned is passed to your
+module's `activate` method so you can restore your view to where the user left
+off.
+
+- `deactivate()`: This **optional** method is called when the window is shutting
+down. If your package is watching any files or holding external resources in any
+other way, release them here. If you're just subscribing to things on window,
+you don't need to worry because that's getting torn down anyway.
+
+### Simple Package Code
+
+Your directory would look like this:
+
+```text
+my-package/
+  package.json
+  index.coffee
+  lib/
+    my-package.coffee
+```
+
+`index.coffee` might be:
+```coffeescript
+module.exports = require "./lib/my-package"
+```
+
+`my-package/my-package.coffee` might start:
+```coffeescript
+module.exports =
+  activate: (rootView, state) -> # ...
+  deactivate: -> # ...
+  serialize: -> # ...
+```
+
+Beyond this simple contract, your package has access to Atom's API. Be aware
+that since we are early in development, APIs are subject to change and we have
+not yet established clear boundaries between what is public and what is private.
+Also, please collaborate with us if you need an API that doesn't exist. Our goal
+is to build out Atom's API organically based on the needs of package authors
+like you.
+
+## Stylesheets
+
+Stylesheets for your package should be placed in the _stylesheets_ directory.
+Any stylesheets in this directory will be loaded and attached to the DOM when
+your package is activated. Stylesheets can be written as CSS or [LESS] (but LESS
+is recommended).
+
+Ideally, you won't need much in the way of styling. We've provided a standard
+set of components which define both the colors and UI elements for any package
+that fits into Atom seamlessly. You can view all of Atom's UI components by opening
+the styleguide: open the command palette (`cmd-p`) and search for _styleguide_,
+or just type `cmd-ctrl-G`.
+
+If you _do_ need special styling, try to keep only structural styles in the package
+stylesheets. If you _must_ specify colors and sizing, these should be taken from
+the active theme's [ui-variables.less][ui-variables]. For more information, see the
+[theme variables docs][theme-variables]. If you follow this guideline, your package
+will look good out of the box with any theme!
+
+An optional `stylesheets` array in your _package.json_ can list the stylesheets
+by name to specify a loading order; otherwise, stylesheets are loaded
+alphabetically.
+
+## Keymaps
+
+It's recommended that you provide key bindings for commonly used actions for
+your extension, especially if you're also adding a new command:
+
+```coffeescript
+'.tree-view-scroller':
+  'ctrl-V': 'changer:magic'
+```
+
+Keymaps are placed in the _keymaps_ subdirectory. By default, all keymaps are
+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
+the example above, `changer:magic` command is executed when pressing `ctrl-V` on
+the `.tree-view-scroller` element.
+
+See the [main keymaps documentation][keymaps] for more detailed information on
+how keymaps work.
+
+## Menus
+
+Menus are placed in the _menus_ subdirectory. By default, all menus are loaded
+in alphabetical order. An optional `menus` array in your _package.json_ can
+specify which menus to load and in what order.
+
+### Application Menu
+
+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
+'menu': [
+  {
+    'label': 'Packages'
+    'submenu': [
+      {
+        'label': 'My Package'
+        'submenu': [
+          {
+            'label': 'Toggle'
+            'command': 'my-package:toggle'
+          }
+        ]
+      }
+    ]
+  }
+]
+```
+
+To add your own item to the application menu, simply create a top level `menu`
+key in any menu configuration file in _menus_. This can be a JSON or [CSON] file.
+
+The menu templates you specify are merged with all other templates provided
+by other packages in the order which they were loaded.
+
+### Context Menu
+
+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
+'context-menu':
+  '.tree-view':
+    'Add file': 'tree-view:add-file'
+  '#root-view':
+    'Inspect Element': 'core:inspect'
+```
+
+To add your own item to the application menu simply create a top level
+`context-menu` key in any menu configuration file in _menus_. This can be a
+JSON or [CSON] file.
+
+Context menus are created by determining which element was selected and
+then adding all of the menu items whose selectors match that element (in
+the order which they were loaded). The process is then repeated for the
+elements until reaching the top of the DOM tree.
+
+In the example above, the `Add file` item will only appear when the focused item
+or one of its parents has the `tree-view` class applied to it.
+
+## Snippets
+
+An extension can supply language snippets in the _snippets_ directory which
+allows the user to enter repetitive text quickly:
+
+```coffeescript
+".source.coffee .specs":
+  "Expect":
+    prefix: "ex"
+    body: "expect($1).to$2"
+  "Describe":
+    prefix: "de"
+    body: """
+      describe "${1:description}", ->
+        ${2:body}
+    """
+```
+
+A snippets file contains scope selectors at its top level (`.source.coffee
+.spec`). Each scope selector contains a hash of snippets keyed by their name
+(`Expect`, `Describe`). Each snippet also specifies a `prefix` and a `body` key.
+The `prefix` represents the first few letters to type before hitting the `tab`
+key to autocomplete. The `body` defines the autofilled text. You can use
+placeholders like `$1`, `$2`, to indicate regions in the body the user can
+navigate to every time they hit `tab`.
+
+All files in the directory are automatically loaded, unless the _package.json_
+supplies a `snippets` key. As with all scoped items, snippets loaded later take
+precedence over earlier snippets when two snippets match a scope with the same
+specificity.
+
+## Language Grammars
+
+If you're developing a new language grammar, you'll want to place your file in
+the _grammars_ directory. Each grammar is a pairing of two keys, `match` and
+`captures`. `match` is a regular expression identifying the pattern to
+highlight, while `captures` is an object representing what to do with each
+matching group.
+
+For example:
+
+
+```coffeescript
+{
+  'match': '(?:^|\\s)(__[^_]+__)'
+  'captures':
+    '1': 'name': 'markup.bold.gfm'
+}
+```
+
+This indicates that the first matching capture (`(__[^_]+__)`) should have the
+`markup.bold.gfm` token applied to it.
+
+To capture a single group, simply use the `name` key instead:
+
+```coffeescript
+{
+  'match': '^#{1,6}\\s+.+$'
+  'name': 'markup.heading.gfm'
+}
+```
+
+This indicates that Markdown header lines (`#`, `##`, `###`) should be applied
+with the `markup.heading.gfm` token.
+
+More information about the significance of these tokens can be found in
+[section 12.4 of the TextMate Manual][tm-tokens].
+
+Your grammar should also include a `filetypes` array, which is a list of file
+extensions your grammar supports:
+
+```coffeescript
+'fileTypes': [
+  'markdown'
+  'md'
+  'mkd'
+  'mkdown'
+  'ron'
+]
+```
+
+## Bundle External Resources
+
+It's common to ship external resources like images and fonts in the package, to
+make it easy to reference the resources in HTML or CSS, you can use the `atom`
+protocol URLs to load resources in the package.
+
+The URLs should be in the format of
+`atom://package-name/relative-path-to-package-of-resource`, for example, the
+`atom://image-view/images/transparent-background.gif` would be equivablent to
+`~/.atom/packages/image-view/images/transparent-background.gif`.
+
+You can also use the `atom` protocol URLs in themes.
+
+## Writing Tests
+
+Your package **should** have tests, and if they're placed in the _spec_
+directory, they can be run by Atom.
+
+Under the hood, [Jasmine] executes your tests, so you can assume that any DSL
+available there is available to your package as well.
+
+**FIXME: Explain the following**
+
+* jasmine
+* jasmine-focused
+* `spec/fixtures` and global.project
+* setTimeout
+* whatever else is different in spec-helper
+
+## Running Tests
+
+TODO: Probably use the menu option now.
+
+Once you've got your test suite written, the recommended way to run it is `apm
+test`. `apm test` prints its output to the console and returns the proper status
+code depending on whether tests passed or failed.
+
+## Publishing
+
+Atom bundles a command line utility called [apm] which can be used to publish
+Atom packages to the public registry.
+
+Once your package is written and ready for distribution you can run the
+following to publish your package:
+
+```sh
+cd my-package
+apm publish minor
+```
+
+This will update your `package.json` to have a new minor `version`, commit the
+change, create a new [Git tag][git-tag], and then upload the package to the
+registry.
+
+Run `apm help publish` to see all the available options and `apm help` to see
+all the other available commands.
+
+## Included Libraries
+
+FIXME: Describe `require 'atom'
+
+In addition to core node.js modules, all packages can `require` the following
+popular libraries into their packages:
+
+* [SpacePen] (as `require 'space-pen'`)
+* [jQuery] (as `require 'jquery'`)
+* [Underscore] (as `require 'underscore'`)
+
+Additional libraries can be found by browsing Atom's *node_modules* folder.
+
+[file-tree]: https://github.com/atom/tree-view
+[status-bar]: https://github.com/atom/status-bar
+[cs-syntax]: https://github.com/atom/language-coffee-script
+[npm]: http://en.wikipedia.org/wiki/Npm_(software)
+[npm-keys]: https://npmjs.org/doc/json.html
+[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
+[theme-variables]: theme-variables.md
+[tm-tokens]: http://manual.macromates.com/en/language_grammars.html
+[spacepen]: https://github.com/nathansobo/space-pen
+[path]: http://nodejs.org/docs/latest/api/path.html
+[jquery]: http://jquery.com/
+[underscore]: http://underscorejs.org/
+[jasmine]: https://github.com/pivotal/jasmine
+[cson]: https://github.com/atom/season
+[less]: http://lesscss.org
+[ui-variables]: https://github.com/atom/atom-dark-ui/blob/master/stylesheets/ui-variables.less
+[first-package]: your-first-package.html

docs/creating-a-theme.md

@@ -0,0 +1,135 @@
+# 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.
+
+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.
+
+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.
+
+## Getting Started
+
+Themes are pretty straight forward 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
+  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.
+
+## Creating a Syntax Theme
+
+Let's create your first theme.
+
+To get started, hit `cmd-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_.
+
+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."
+
+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.
+
+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!
+
+## Creating an Interface Theme
+
+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
+   be instantly reflected in the editor without having to reload.
+
+## Development workflow
+
+There are a few of tools to help make theme development faster.
+
+### 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.
+
+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!
+
+If you'd like to reload all the styles at any time, you can use the shortcut
+`cmd-ctrl-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.
+
+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.
+
+### 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.
+
+To open the styleguide, open the command palette (`cmd-p`) and search for
+_styleguide_, or use the shortcut `cmd-ctrl-shift-g`.
+
+![styleguide-img]
+
+[less]: http://lesscss.org/
+[git]: http://git-scm.com/
+[atom]: https://atom.io/
+[package.json]: ./creating-a-package.html#package-json
+[less-tutorial]: https://speakerdeck.com/danmatthews/less-css
+[devtools-tutorial]: https://developers.google.com/chrome-developer-tools/docs/elements
+[ui-variables]: ./theme-variables.html
+[livereload]: https://github.com/atom/dev-live-reload
+[styleguide]: https://github.com/atom/styleguide
+[atom-dark-ui]: https://github.com/atom/atom-dark-ui
+[atom-light-ui]: https://github.com/atom/atom-light-ui
+[styleguide-img]: https://f.cloud.github.com/assets/69169/1347390/2d431d98-36af-11e3-8f8e-3f4ce1e67adb.png
+[devtools-img]: https://f.cloud.github.com/assets/69169/1347391/2d51f91c-36af-11e3-806f-f7b334af43e9.png
+[themesettings-img]: https://f.cloud.github.com/assets/69169/1347569/3150bd0c-36b2-11e3-9d69-423503acfe3f.png

docs/customizing-atom.md

@@ -1,54 +1,23 @@
-# Configuration Settings
+# Customizing Atom
 
-## Your .atom Directory
+To change a setting, configure a theme, or install a package just open the
+Settings pane in the current window by pressing `cmd+,`.
 
-When you install Atom, an _.atom_ directory is created in your home directory.
-If you press `meta-,`, that directory is opened in a new window. For the
-time being, this serves as the primary interface for adjusting configuration
-settings, adding and changing key bindings, tweaking styles, etc.
+## Changing The Theme
 
-Atom loads configuration settings from the `config.cson` file in your _~/.atom_
-directory, which contains CoffeeScript-style JSON:
+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]).
 
-```coffeescript
-core:
-  hideGitIgnoredFiles: true
-editor:
-  fontSize: 18
-```
+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.
 
-Configuration is broken into namespaces, which are defined by the config hash's
-top-level keys. In addition to Atom's core components, each package may define
-its own namespace.
+## Installing Packages
 
-## Glossary of Config Keys
-
-- `core`
-  - `disablePackages`: An array of package names to disable
-  - `hideGitIgnoredFiles`: Whether files in the _.gitignore_ should be hidden
-  - `ignoredNames`: File names to ignore across all of Atom (not fully implemented)
-  - `themes`: An array of theme names to load, in cascading order
-  - `autosave`: Save a buffer when its view loses focus
-- `editor`
-  - `autoIndent`: Enable/disable basic auto-indent (defaults to `true`)
-  - `autoIndentOnPaste`: Enable/disable auto-indented pasted text (defaults to `false`)
-  - `nonWordCharacters`: A string of non-word characters to define word boundaries
-  - `fontSize`: The editor font size
-  - `fontFamily`: The editor font family
-  - `invisibles`: Specify characters that Atom renders for invisibles in this hash
-      - `tab`: Hard tab characters
-      - `cr`: Carriage return (for Microsoft-style line endings)
-      - `eol`: `\n` characters
-      - `space`: Leading and trailing space characters
-  - `preferredLineLength`: Identifies the length of a line (defaults to `80`)
-  - `showInvisibles`: Whether to render placeholders for invisible characters (defaults to `false`)
-- `fuzzyFinder`
-  - `ignoredNames`: Files to ignore *only* in the fuzzy-finder
-- `whitespace`
-  - `ensureSingleTrailingNewline`: Whether to reduce multiple newlines to one at the end of files
-- `wrapGuide`
-  - `columns`: Array of hashes with a `pattern` and `column` key to match the
-             the path of the current editor to a column position.
+You can install non-bundled packages by going to the `Available Packages`
+section on the `Packages` tab within the Settings panel (`cmd-,`).
 
 ## Customizing Key Bindings
 
@@ -61,8 +30,9 @@ built-in keymaps:
 '.editor':
   'enter': 'editor:newline'
 
-".select-list .editor.mini":
-  'enter': 'core:confirm',
+'body':
+  'ctrl-P': 'core:move-up'
+  'ctrl-p': 'core:move-down'
 ```
 
 This keymap defines the meaning of `enter` in two different contexts. In a
@@ -71,68 +41,92 @@ the editor to insert a newline. But if the same keystroke occurs inside of a
 select list's mini-editor, it instead emits the `core:confirm` event based on
 the binding in the more-specific selector.
 
-By default, any keymap files in your `~/.atom/keymaps` directory are loaded
-in alphabetical order when Atom is started. They will always be loaded last,
-giving you the chance to override bindings that are defined by Atom's core
-keymaps or third-party packages.
+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.
 
-## Changing The Theme
+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.
 
-Atom comes bundled with two themes `atom-dark-*` and `atom-light-*`.
+## Advanced Configuration
 
-Because Atom themes are based on CSS, it's possible to have multiple themes
-active at the same time. For example, you'll usually select a theme for the UI
-and another theme for syntax highlighting.  You can select themes by specifying
-them in the `core.themes` array in your `config.cson`:
-
-```coffee-script
-core:
-  themes: ["atom-light-ui", "atom-light-syntax"]
-  # or, if the sun is going down:
-  # themes: ["atom-dark-ui", "atom-dark-syntax"]
-```
-
-You install new themes by placing them in the _~/.atom/themes_ directory. A
-theme can be a CSS file, a directory containing multiple CSS files, or a
-TextMate theme (either _.tmTheme_ or _.plist_).
-
-
-## Installing Packages (Partially Implemented)
-
-To install a package, clone it into the _~/.atom/packages_ directory. Atom will
-also load grammars and snippets from TextMate bundles. If you want to disable a
-package without removing it from the packages directory, insert its name into
-_config.core.disabledPackages_:
+Atom loads configuration settings from the `config.cson` file in your _~/.atom_
+directory, which contains CoffeeScript-style JSON:
 
 ```coffeescript
 core:
-  disabledPackages: [
-    "fuzzy-finder",
-    "tree-view"
-  ]
+  hideGitIgnoredFiles: true
+editor:
+  fontSize: 18
 ```
 
-## Quick Personal Hacks
+The configuration itself is grouped by the package name or one of the two core
+namespaces: `core` and `editor`.
+
+### Configuration Key Reference
+
+- `core`
+  - `disabledPackages`: An array of package names to disable
+  - `excludeVcsIgnoredPaths`: Don't search within files specified by _.gitignore_
+  - `hideGitIgnoredFiles`: Whether files in the _.gitignore_ should be hidden
+  - `ignoredNames`: File names to ignore across all of Atom
+  - `projectHome`: The directory where projects are assumed to be located
+  - `themes`: An array of theme names to load, in cascading order
+- `editor`
+  - `autoIndent`: Enable/disable basic auto-indent (defaults to `true`)
+  - `autoIndentOnPaste`: Enable/disable auto-indented pasted text (defaults to `false`)
+  - `nonWordCharacters`: A string of non-word characters to define word boundaries
+  - `fontSize`: The editor font size
+  - `fontFamily`: The editor font family
+  - `invisibles`: Specify characters that Atom renders for invisibles in this hash
+      - `tab`: Hard tab characters
+      - `cr`: Carriage return (for Microsoft-style line endings)
+      - `eol`: `\n` characters
+      - `space`: Leading and trailing space characters
+  - `normalizeIndentOnPaste`: Enable/disable conversion of pasted tabs to spaces
+  - `preferredLineLength`: Identifies the length of a line (defaults to `80`)
+  - `showInvisibles`: Whether to render placeholders for invisible characters (defaults to `false`)
+  - `showIndentGuide`: Show/hide indent indicators within the editor
+  - `showLineNumbers`: Show/hide line numbers within the gutter
+  - `softWrap`: Enable/disable soft wrapping of text within the editor
+  - `softWrapAtPreferredLineLength`: Enable/disable soft line wrapping at `preferredLineLength`
+  - `tabLength`: Number of spaces within a tab (defaults to `2`)
+- `fuzzyFinder`
+  - `ignoredNames`: Files to ignore *only* in the fuzzy-finder
+- `whitespace`
+  - `ensureSingleTrailingNewline`: Whether to reduce multiple newlines to one at the end of files
+  - `removeTrailingWhitespace`: Enable/disable striping of whitespace at the end of lines (defaults to `true`)
+- `wrapGuide`
+  - `columns`: Array of hashes with a `pattern` and `column` key to match the
+             the path of the current editor to a column position.
+
+### Quick Personal Hacks
 
 ### user.coffee
 
 When Atom finishes loading, it will evaluate _user.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.
-Please refer to the [Atom Internals Guide](./internals/intro,md) for more information. If your
-customizations become extensive, consider [creating a package](./packages/creating_packages.md).
+If customizations become extensive, consider [creating a
+package][create-a-package].
 
-### user.css
+### user.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.css_ in your _~/.atom_ directory.
+_user.less_ 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.css_:
+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_:
+
+```less
+@highlight-color: pink;
 
-```css
 .editor .line-number.cursor-line {
-  color: pink;
+  color: @highlight-color;
 }
 ```
+
+[create-a-package]: creating-packages.md
+[create-theme]: creating-a-theme.md

docs/getting-started.md

@@ -1,63 +1,42 @@
 # Getting Started
 
-Welcome to Atom. This documentation provides a basic introduction to being
-productive with this editor. We'll then delve into more details about configuring,
-theming, and extending Atom.
+Welcome to Atom! This guide provides a quick introduction so you can be
+productive as quickly as possible. There are also guides which cover
+[configuring], [theming], and [extending] Atom.
 
 ## The Command Palette
 
-If there's one key-command you must remember in Atom, it should be `meta-p` (`meta` is
-synonymous with the ⌘ key). You can always hit `meta-p` to bring up a list of
-commands that are relevant to the currently focused UI element. If there is a
-key binding for a given command, it is also displayed. This is a great way to
-explore the system and get to know the key commands interactively. If you'd like
-to learn about adding or changing a binding for a command, refer to the [key
-bindings](#customizing-key-bindings) section.
+If there's one key-command you must remember in Atom, it should be `cmd-p`. You
+can always hit `cmd-p` to bring up a list of commands that are relevant to the
+currently focused interface element. If there is a key binding for a given
+command, it is also displayed. This is a great way to explore the system and get
+to know the key commands interactively. If you'd like to learn about adding or
+changing a binding for a command, refer to the [key bindings][key-bindings]
+section below.
 
-![Command Palette](http://f.cl.ly/items/32041o3w471F3C0F0V2O/Screen%20Shot%202013-02-13%20at%207.27.41%20PM.png)
+![Command Palette]
 
-## Basic Key Bindings
-
-You can always use `meta-p` to explore available commands and their
-bindings, but here's a list of a few useful commands.
-
-- `meta-o` : open a file or directory
-- `meta-n` : open new window
-- `meta-r` : reload the current window
-- `meta-alt-ctrl-s` : run test specs
-- `meta-t` : open file finder to navigate files in your project
-- `meta-;` : open command prompt
-- `meta-f` : open command prompt with `/` for a local file search
-- `meta-g` : repeat the last local search
-- `meta-shift-f` : open command prompt with `Xx/` for a project-wide search
-- `meta-\` : focus/open tree view, or close it when it is focused
-- `meta-|` : open tree view with the current file selected
-- `ctrl-w v`, `ctrl-|` : split screen vertically
-- `ctrl-w s`, `ctrl--` : split screen horizontally
-- `meta-l` : go to line
-
-## Usage Basics
-
-### If You See A Rendering Bug
-
-Things are pretty stable, but we think we have a couple rendering bugs lurking
-that are hard to reproduce. If you see one, please hit `meta-p` and type
-"save debug snapshot". Run that command to save a snapshot of the misbehaving
-editor and send it to us, along with a screenshot and your best description of
-how you produced the bug. Refreshing with `meta-r` should usually resolve the
-issue so you can keep working.
+## The Basics
 
 ### Working With Files
 
+Atom windows are scoped to the directory in which they're opened from. So 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 it's own window and it's state will be unique to that window.
+
 #### Finding Files
 
 The fastest way to find a file in your project is to use the fuzzy finder. Just
-hit `meta-t` and start typing the name of the file you're looking for. If you
-already have the file open as a tab and want to jump to it, hit `meta-b` to bring
+hit `cmd-t` and start typing the name of the file you're looking for. If you
+already have the file open as a tab and want to jump to it, hit `cmd-b` to bring
 up a searchable list of open buffers.
 
 You can also use the tree view to navigate to a file. To open or move focus to
-the tree view, hit `meta-\`. You can then navigate to a file and select it with
+the tree view, hit `cmd-\`. You can then navigate to a file and select it with
 `return`.
 
 #### Adding, Moving, Deleting Files
@@ -70,53 +49,27 @@ needed.
 To move or rename a file or directory, select it in the tree view and hit `m`.
 To delete a file, select it in the tree view and hit `delete`.
 
-### Searching For Stuff
+### Searching
 
-#### Using the Command Line
+#### Find and Replace
 
-Atom has a command line similar to old-school editors such as emacs and vim. Nearly
-every command has a key binding which you can discover with `meta-p`.
-
-The command line is also (currently) the only place you can perform a search. Hitting
-`meta-f` opens the command line and prepopulates it with the `/` command. This finds
-text in the current buffer, starting at the location of the cursor. Pressing `meta-g`
-repeats the search. Hitting `meta-shift-f` opens the command line and prepopulates
-it with `Xx/`, which is a composite command that performs a global search. The results
-of the search appear in the operation preview list, which you can focus
-with `meta-:`.
-
-Atom's command language is still under construction, and is loosely based on
-the [Sam editor](http://doc.cat-v.org/bell_labs/sam_lang_tutorial/) from the
-Plan 9 operating system. It's similar to Ex mode in vim, but is selection-based
-rather than line-based. It allows you to compose commands together in
-interesting ways.
+To search within a buffer use `cmd-f`. To search the entire project use
+`cmd-shift-f`. To find and replace within the current buffer use `cmd-alt-f`.
 
 #### Navigating By Symbols
 
-If you want to jump to a method, you can use the ctags-based symbols package.
-The `meta-j` binding opens a list of all symbols in the current file. The
-`meta-shift-j` binding opens a list of all symbols for the current project
-based on a tags file. `meta-.` jumps to the tag for the word currently
-under the cursor.
+If you want to jump to a method, the `cmd-j` binding opens a list of all symbols
+in the current file. `cmd-.` jumps to the tag for the word currently under the
+cursor.
 
-Make sure you have a tags file generated for the project for
-the latter of these two bindings to work. 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](https://github.com/kevinsawicki/dotfiles/blob/master/.ctags).
-
-### Replacing Stuff
-
-To perform a replacement, open up the command line with `meta-;` and use the `s`
-command, as follows: `s/foo/bar/g`. Note that if you have a selection, the
-replacement will only occur inside the selected text. An empty selection will
-cause the replacement to occur across the whole buffer. If you want to run the
-command on the whole buffer even if you have a selection, precede your
-substitution with the `,` address; this indicates that the following command should
-run on the whole buffer.
+To search for symbols across your project use `cmd-shift-j`, but you'll need to
+make sure you have a tags file generated for the project Also, if you're editing
+CoffeeScript, it's a good idea to update your `~/.ctags` file to understand the
+language. Here is [a good example][ctags].
 
 ### Split Panes
 
-You can split any editor pane horizontally or vertically by using `ctrl-\` or
+You can split any editor pane horizontally or vertically by using `ctrl-w s` or
 `ctrl-w v`. Once you have a split pane, you can move focus between them with
 `ctrl-tab` or `ctrl-w w`. To close a pane, close all tabs inside it.
 
@@ -124,151 +77,26 @@ You can split any editor pane horizontally or vertically by using `ctrl-\` or
 
 You can fold everything with `ctrl-{` and unfold everything with
 `ctrl-}`. Or, you can fold / unfold by a single level with `ctrl-[` and
-`ctrl-]`. The user interaction around folds is still a bit rough, but we're
-planning to improve it soon.
+`ctrl-]`.
 
 ### Soft-Wrap
 
 If you want to toggle soft wrap, trigger the command from the command palette.
-Hit `meta-p` to open the palette, then type "wrap" to find the correct
+Hit `cmd-p` to open the palette, then type "wrap" to find the correct
 command.
 
-## Your .atom Directory
+## Configuration
 
-When you install Atom, an `.atom` directory is created in your home directory.
-If you press `meta-,`, that directory will be opened in a new window. For the
-time being, this will serve as the primary interface for adjusting configuration
-settings, adding and changing key bindings, tweaking styles, etc.
+If you press `cmd-,`, a configuration panel will appear in the currently focused
+pane. This serves as the primary interface for adjusting settings, installing
+packages and changing themes.
 
-## Configuration Settings
+For more advanced configuration see the [customization guide][customization].
 
-Atom loads configuration settings from the `config.cson` file in your `~/.atom`
-directory, which contains CoffeeScript-style JSON:
-
-```coffeescript
-core:
-  hideGitIgnoredFiles: true
-editor:
-  fontSize: 18
-```
-
-Configuration is broken into namespaces, which are defined by the config hash's
-top-level keys. In addition to Atom's core components, each package may define
-its own namespace.
-
-### Glossary of Config Keys
-
-- core
-  - disabledPackages: An array of package names to disable
-  - hideGitIgnoredFiles: Whether files in the .gitignore should be hidden
-  - ignoredNames: File names to ignore across all of atom (not fully implemented)
-  - themes: An array of theme names to load, in cascading order
-  - autosave: Save a resource when its view loses focus
-- editor
-  - autoIndent: Enable/disable basic auto-indent (defaults to true)
-  - autoIndentOnPaste: Enable/disable auto-indented pasted text (defaults to false)
-  - nonWordCharacters: A string of non-word characters to define word boundaries
-  - fontSize
-  - fontFamily
-  - invisibles: Specify characters that Atom renders for invisibles in this hash
-      - tab: Hard tab characters
-      - cr: Carriage return (For Microsoft-style line endings)
-      - eol: `\n` characters
-      - space: Leading and trailing space characters
-  - preferredLineLength: Packages such as autoflow use this (defaults to 80)
-  - showInvisibles: Whether to render placeholders for invisible characters (defaults to false)
-- fuzzyFinder
-  - ignoredNames: Files to ignore *only* in the fuzzy-finder
-- whitespace
-  - ensureSingleTrailingNewline: Whether to reduce multiple newlines to one at the end of files
-- wrapGuide
-  - columns: Array of hashes with a `pattern` and `column` key to match the
-             the path of the current editor to a column position.
-
-## Customizing Key Bindings
-
-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:
-
-```coffee-script
-'.editor':
-  'enter': 'editor:newline'
-
-".select-list .editor.mini":
-  'enter': 'core:confirm',
-```
-
-This keymap defines the meaning of `enter` in two different contexts. In a
-normal editor, pressing `enter` emits the `editor:newline` event, which causes
-the editor to insert a newline. But if the same keystroke occurs inside of a
-select list's mini-editor, it instead emits the `core:confirm` event based on
-the binding in the more-specific selector.
-
-By default, any keymap files in your `~/.atom/keymaps` directory will be loaded
-in alphabetical order when Atom is started. They will always be loaded last,
-giving you the chance to override bindings that are defined by Atom's core
-keymaps or third-party packages.
-
-## Changing The Theme
-
-Atom comes bundles with two themes `atom-dark-*` and `atom-light-*`.
-
-Because Atom themes are based on CSS, it's possible to have multiple themes
-active at the same time. For example, you'll usually select a theme for the UI
-and another theme for syntax highlighting.  You can select themes by specifying
-them in the `core.themes` array in your `config.cson`:
-
-```coffee-script
-core:
-  themes: ["atom-light-ui", "atom-light-syntax"]
-  # or, if the sun is going down:
-  # themes: ["atom-dark-ui", "atom-dark-syntax"]
-```
-
-You install new themes by placing them in the `~/.atom/themes` directory. A
-theme can be a CSS file, a directory containing multiple CSS files, or a
-TextMate theme (either `.tmTheme` or `.plist`).
-
-
-## Installing Packages (Partially Implemented)
-
-To install a package, clone it into the `~/.atom/packages` directory. Atom will
-also load grammars and snippets from TextMate bundles. If you want to disable a
-package without removing it from the packages directory, insert its name into
-`config.core.disabledPackages`:
-
-config.cson:
-```coffeescript
-core:
-  disabledPackages: [
-    "fuzzy-finder",
-    "tree-view"
-  ]
-```
-
-## Quick Personal Hacks
-
-### user.coffee
-
-When Atom finishes loading, it will evaluate `user.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.
-Please refer to the Atom Internals Guide for more information. If your
-customizations become extensive, consider creating a package.
-
-### user.css
-
-If you want to apply quick-and-dirty personal styling changes without creating
-an entire theme that you intend to distribute, you can add styles to
-`user.css` in your `~/.atom` directory.
-
-For example to change the color of the highlighted line number for the line that
-contains the cursor, you could add the following style to `user.css`:
-
-```css
-.editor .line-number.cursor-line {
-  color: pink;
-}
-```
+[configuring]: customizing-atom.md
+[theming]: creating-a-theme.md
+[extending]: creating-a-package.md
+[customization]: customizing-atom.md
+[key-bindings]: #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

docs/index.md

@@ -0,0 +1,13 @@
+## Guides
+
+* [Getting Started](getting-started.md)
+* [Customizing Atom](customizing-atom.md)
+* [Creating a Package](creating-a-package.md)
+* [Creating a Theme](creating-a-theme.md)
+
+### Advanced Topics
+
+* [Configuration](internals/configuration.md)
+* [Keymaps](internals/keymaps.md)
+* [Serialization](internals/serialization.md)
+* [View System](internals/view-system.md)

docs/internals/configuration.md

@@ -7,7 +7,7 @@ read config settings. You can read a value from `config` with `config.get`:
 
 ```coffeescript
 # read a value with `config.get`
-@autosave() if config.get "core.autosave"
+@showInvisibles() if config.get "edtior.showInvisibles"
 ```
 
 Or you can use `observeConfig` to track changes from a view object.
@@ -47,7 +47,7 @@ the following way:
 
 ```coffeescript
 # basic key update
-config.set("core.autosave", true)
+config.set("core.showInvisibles", true)
 
 config.pushAtKeyPath("core.disabledPackages", "wrap-guide")
 ```

docs/internals/intro.md

@@ -1,6 +0,0 @@
-# Atom Internals
-
-To extend Atom effectively, you'll need to understand how it works internally.
-This system is evolving fast and it's unlikely that these docs will cover all
-of it any time soon, so view this as a jumping-off point. To really understand
-how things work, use the web inspector or dive into the code.

docs/internals/keymaps.md

@@ -15,7 +15,7 @@ Note that the last example describes multiple keystrokes in succession:
 - `p`
 - `2`
 - `ctrl-p`
-- `ctrl-alt-meta-p`
+- `ctrl-alt-cmd-p`
 - `tab`
 - `escape`
 - `enter`
@@ -23,12 +23,12 @@ Note that the last example describes multiple keystrokes in succession:
 
 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 `meta-p`), to get a list of relevant events and their bindings
+palette (bound to `cmd-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 `meta-D`) into a
+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

docs/internals/view-system.md

@@ -2,9 +2,8 @@
 
 ### SpacePen Basics
 
-Atom's view system is built around the [SpacePen](http://github.com/nathansobo/space-pen)
-view framework. SpacePen view objects inherit from the jQuery prototype, and
-wrap DOM nodes
+Atom's view system is built around the [SpacePen] view framework. SpacePen
+view objects inherit from the jQuery prototype, and wrap DOM nodes
 
 View objects are actually jQuery wrappers around DOM fragments, supporting all
 the typical jQuery traversal and manipulation methods. In addition, view objects
@@ -28,17 +27,16 @@ editorView = editorElement.view()
 editorView.setCursorBufferPosition([1, 2])
 ```
 
-Refer to the [SpacePen](http://github.com/nathansobo/space-pen) documentation
-for more details.
+Refer to the [SpacePen] documentation for more details.
 
 ### RootView
 
-The root of Atom's view hiererchy is a global called `rootView`, which is a
+The root of Atom's view hierarchy is a global called `rootView`, which is a
 singleton instance of the `RootView` view class. The root view fills the entire
 window, and contains every other view. If you open Atom's inspector with
-`alt-meta-i`, you can see the internal structure of `RootView`:
+`alt-cmd-i`, you can see the internal structure of `RootView`:
 
-![RootView in the inspector](http://f.cl.ly/items/2n0s3m0I2d223p3s3W01/root-view-inspector.png)
+![RootView in the inspector][rootview-inspector]
 
 #### Panes
 
@@ -62,3 +60,6 @@ rootView.horizontal.prepend(new MyView)
 # place a view below the panes (or use .prepend() to place it above)
 rootView.vertical.append(new MyOtherView)
 ```
+
+[spacepen]: http://github.com/nathansobo/space-pen
+[rootview-inspector]: https://f.cloud.github.com/assets/1424/1091631/1932c2d6-166b-11e3-8adf-9690fe82d3b8.png

docs/manifest.txt

@@ -1,15 +0,0 @@
-getting-started.md
-configuring-atom.md
-built-in-packages/intro.md
-built-in-packages/command-panel.md
-built-in-packages/markdown-preview.md
-built-in-packages/wrap-guide.md
-packages/authoring-packages.md
-packages/creating_a_package.md
-packages/included_libraries.md
-packages/package_json.md
-themes/authoring-themes.md
-internals/intro.md
-internals/configuration.md
-internals/keymaps.md
-internals/view-system.md

docs/packages/authoring-packages.md

@@ -1,211 +0,0 @@
-# Authoring Packages
-
-Packages are at the core of Atom. Nearly everything outside of the main editor manipulation
-is handled by a package. That includes "core" pieces like the command panel, status bar,
-file tree, and more.
-
-A package can contain a variety of different resource types to change Atom's
-behavior. The basic package layout is as follows (though not every package will
-have all of these directories):
-
-```text
-my-package/
-  lib/
-  stylesheets/
-  keymaps/
-  snippets/
-  grammars/
-  spec/
-  package.json
-  index.coffee
-```
-
-**NOTE:** NPM behavior is partially implemented until we get a working Node.js
-API built into Atom. The goal is to make Atom packages be a superset of NPM
-packages.
-
-Below, we'll break down each directory. There's also [a tutorial](./creating_a_package.md)
-on creating your first package.
-
-## package.json
-
-Similar to [npm packages](http://en.wikipedia.org/wiki/Npm_(software\)), Atom packages
-can contain a _package.json_ file in their top-level directory. This file contains metadata
-about the package, such as the path to its "main" module, library dependencies,
-and manifests specifying the order in which its resources should be loaded.
-
-In addition to the regular [npm package.json keys](https://npmjs.org/doc/json.html)
-available, Atom package.json files [have their own additions](./package_json.md).
-
-## Source Code
-
-If you want to extend Atom's behavior, your package should contain a single
-top-level module, which you export from _index.coffee_ (or whichever file is
-indicated by the `main` key in your _package.json_ file). The remainder of your
-code should be placed in the `lib` directory, and required from your top-level
-file.
-
-Your package's top-level module is a singleton object that manages the lifecycle
-of your extensions to Atom. Even if your package creates ten different views and
-appends them to different parts of the DOM, it's all managed from your top-level
-object.
-
-Your package's top-level module should implement the following methods:
-
-- `activate(rootView, state)`: This **required** method is called when your
-package is loaded. It is always passed the window's global `rootView`, and is
-sometimes passed state data if the window has been reloaded and your module
-implements the `serialize` method. Use this to do initialization work when your
-package is started (like setting up DOM elements or binding events).
-
-- `serialize()`: This **optional** method is called when the window is shutting
-down, allowing you to return JSON to represent the state of your component. When
-the window is later restored, the data you returned is passed to your
-module's `activate` method so you can restore your view to where the user left
-off.
-
-- `deactivate()`: This **optional** method is called when the window is shutting
-down. If your package is watching any files or holding external resources in any
-other way, release them here. If you're just subscribing to things on window,
-you don't need to worry because that's getting torn down anyway.
-
-### Simple Package Code
-
-```text
-my-package/
-  package.json # optional
-  index.coffee
-  lib/
-    my-package.coffee
-```
-
-`index.coffee`:
-```coffeescript
-module.exports = require "./lib/my-package"
-```
-
-`my-package/my-package.coffee`:
-```coffeescript
-module.exports =
-  activate: (rootView, state) -> # ...
-  deactivate: -> # ...
-  serialize: -> # ...
-```
-
-Beyond this simple contract, your package has full access to Atom's internal
-API. Anything we call internally, you can call as well. Be aware that since we
-are early in development, APIs are subject to change and we have not yet
-established clear boundaries between what is public and what is private. Also,
-please collaborate with us if you need an API that doesn't exist. Our goal is
-to build out Atom's API organically based on the needs of package authors like
-you.
-
-See [Atom's built-in packages](https://github.com/github/atom/tree/master/src/packages)
-for examples of Atom's API in action.
-
-## Stylesheets
-
-Stylesheets for your package should be placed in the _stylesheets_ directory.
-Any stylesheets in this directory will be loaded and attached to the DOM when
-your package is activated. Stylesheets can be written as CSS or LESS.
-
-An optional `stylesheets` array in your _package.json_ can list the stylesheets by
-name to specify a loading order; otherwise, stylesheets are loaded alphabetically.
-
-## Keymaps
-
-Keymaps are placed in the _keymaps_ subdirectory. It's a good idea to provide
-default keymaps for your extension, especially if you're also adding a new command.
-
-By default, all keymaps are loaded in alphabetical order. An optional `keymaps`
-array in your _package.json_ can specify which keymaps to load and in what order.
-
-See the [main keymaps documentation](../internals/keymaps.md) for more information on
-how keymaps work.
-
-## Snippets
-
-An extension can supply language snippets in the _snippets_ directory. These can
-be `.cson` or `.json` files. Here's an example:
-
-```coffeescript
-".source.coffee .specs":
-  "Expect":
-    prefix: "ex"
-    body: "expect($1).to$2"
-  "Describe":
-    prefix: "de"
-    body: """
-      describe "${1:description}", ->
-        ${2:body}
-    """
-```
-
-A snippets file contains scope selectors at its top level (`.source.coffee .spec`).
-Each scope selector contains a hash of snippets keyed by their name (`Expect`, `Describe`).
-Each snippet also specifies a `prefix` and a `body` key. The `prefix` represents
-the first few letters to type before hitting the `tab` key to autocomplete. The
-`body` defines the autofilled text. You can use placeholders like `$1`, `$2`, to indicate
-regions in the body the user can navigate to every time they hit `tab`.
-
-All files in the directory are automatically loaded, unless the
-_package.json_ supplies a `snippets` key. As with all scoped
-items, snippets loaded later take precedence over earlier snippets when two
-snippets match a scope with the same specificity.
-
-## Language Grammars
-
-If you're developing a new language grammar, you'll want to place your file in
-the _grammars_ directory. Each grammar is a pairing of two keys, `match` and
-`captures`. `match` is a regular expression identifying the pattern to highlight,
-while `captures` is a JSON representing what to do with each matching group.
-For example:
-
-
-```json
-{
-  'match': '(?:^|\\s)(__[^_]+__)'
-  'captures':
-    '1': 'name': 'markup.bold.gfm'
-}
-```
-
-This indicates that the first matching capture (`(__[^_]+__)`) should have the
-`markup.bold.gfm` token applied to it.
-
-To capture a single group, simply use the `name` key instead:
-
-```json
-{
-  'match': '^#{1,6}\\s+.+$'
-  'name': 'markup.heading.gfm'
-}
-```
-
-This indicates that Markdown header lines (`#`, `##`, `###`) should be applied with
-the `markup.heading.gfm` token.
-
-More information about the significance of these tokens can be found in
-[section 12.4 of the TextMate Manual](http://manual.macromates.com/en/language_grammars.html).
-
-Your grammar should also include a `filetypes` array, which is a list of file extensions
-your grammar supports:
-
-```
-'fileTypes': [
-  'markdown'
-  'md'
-  'mkd'
-  'mkdown'
-  'ron'
-]
-```
-
-## Writing Tests
-
-Your package **should** have tests, and if they're placed in the _spec_ directory,
-they can be run by Atom.
-
-Under the hood, [Jasmine](https://github.com/pivotal/jasmine) is being used to run
-to execute the tests, so you can assume that any DSL available there is available
-to your package as well.

docs/packages/creating_a_package.md

@@ -1,254 +0,0 @@
-# Creating Packages
-
-Let's take a look at creating our first package.
-
-Atom has a command you can enter that'll create a package for you:
-`package-generator:generate`. Otherwise, you can hit `meta-p`, and start typing
-"Package Generator." Once you activate this package, it'll ask you for a name for
-your new package. Let's call ours _changer_.
-
-Now, _changer_ is going to have a default set of folders and files created for us.
-Hit `meta-R` to reload Atom, then hit `meta-p` and start typing "Changer." You'll
-see a new `Changer:Toggle` command which, if selected, pops up a new message. 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 keybinding
-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_ can easily become this:
-
-```cson
-'.tree-view-scroller':
-  'ctrl-V': 'changer:magic'
-```
-
-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.
-
-`.tree-view-scroller` represents the parent container for the tree view. Keybindings
-only work within the context of where they're entered. For example, hitting `ctrl-V`
-anywhere other than tree won't do anything. You can map to `body` if you want
-to scope to anywhere in Atom, or just `.editor` for the editor portion.
-
-To bind keybindings to a command, we'll use the `rootView.command` method. This
-takes a command name and executes a function in the code. For example:
-
-```coffeescript
-rootView.command "changer:magic", => @magic()
-```
-
-It's common practice to namespace your commands with your package name, and separate
-it with a colon (`:`). Rename the existing `toggle` method to `magic` to get the
-binding to work.
-
-Reload the editor, click on the tree, hit your keybinding, and...nothing happens! What the heck?!
-
-Open up the _package.json_ file, and notice the key that says `activationEvents`.
-Basically, this tells Atom to not load a package until it hears a certain event.
-Let's change the event to `changer:magic` and reload the editor.
-
-Hitting the key binding on the tree now works!
-
-## Working with styles
-
-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, we have [a list of
-some of the bundled libraries Atom provides by default](./included_libraries.md).
-
-Let's bring in jQuery:
-
-```coffeescript
-$ = require 'jquery'
-```
-
-Now, we can query the tree to get us a list of every file that _wasn't_ modified:
-
-```coffeescript
-magic: ->
-  $('ol.entries li').each (i, el) ->
-    if !$(el).hasClass("modified")
-      console.log el
-```
-
-You can access the dev console by hitting `alt-meta-i`. When we execute the
-`changer:magic` command, the browser console lists the items that are not being
-modified. Let's add a class to each of these elements called `hide-me`:
-
-```coffeescript
-magic: ->
-  $('ol.entries li').each (i, el) ->
-    if !$(el).hasClass("modified")
-      $(el).addClass("hide-me")
-```
-
-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;
-}
-```
-
-Refresh atom, and run the `changer` command. You'll see all the non-changed files
-disappear from the tree. 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:
-
-```coffeescript
-magic: ->
-  $('ol.entries li').each (i, el) ->
-    if !$(el).hasClass("modified")
-      if !$(el).hasClass("hide-me")
-        $(el).addClass("hide-me")
-      else
-        $(el).removeClass("hide-me")
-```
-
-## Creating a New Pane
-
-The next goal of this package is to append a pane to the Atom editor that lists
-some information about the modified files.
-
-To do that, we're going to first create a new class method called `content`. 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](https://github.com/nathansobo/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. Let's start by carving out a `div` to hold the filenames:
-
-```coffeescript
-@content: ->
-  @div class: 'modified-files-container', =>
-    @ul class: 'modified-files-list', outlet: 'modifiedFilesList', =>
-      @li 'Test'
-      @li 'Test2'
-```
-
-You can add any HTML5 attribute you like. `outlet` names the variable
-your package can uses to manipulate the element directly. The fat pipe (`=>`) indicates
-that the next set are nested children.
-
-We'll add one more line to `magic` to make this pane appear:
-
-```coffeescript
-rootView.vertical.append(this)
-```
-
-If you hit the key command, you'll see a box appear right underneath the editor.
-Success!
-
-Before we populate this, let's apply some logic to toggle the pane off and on, just
-like we did with the tree view:
-
-```coffeescript
-# toggles the pane
-if @hasParent()
-  rootView.vertical.children().last().remove()
-else
-  rootView.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 UI 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.
-
-You might have noticed that our two `li` elements aren't showing up. Let's set
-a color on them so that they pop. Open up `changer.css` and add this CSS:
-
-```css
-ul.modified-files-list {
-  color: white;
-}
-```
-
-Refresh Atom, hit the key combo, and see your brilliantly white test list.
-
-## Calling Node.js Code
-
-Since Atom is built on top of Node.js, 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:
-
-```coffeescript
-path = require 'path'
-
-# ...
-
-modifiedFiles = []
-# for each single entry...
-$('ol.entries li.file.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.modified')
-  parents.each (i, el) ->
-    filePath.unshift($(el).find('div.header span.name').eq(0).text())
-
-  modifiedFilePath = path.join(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](http://nodejs.org/docs/latest/api/path.html) to get
-the proper directory separator for our system.
-
-Let's 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()
-  rootView.vertical.children().last().remove()
-else
-  for file in modifiedFiles
-    stat = fs.lstatSync(file)
-    mtime = stat.mtime
-    @modifiedFilesList.append("<li>#{file} - Modified at #{mtime}")
-  rootView.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. 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()
-  rootView.vertical.children().last().remove()
-else
-  for file in modifiedFiles
-    stat = fs.lstatSync(file)
-    mtime = stat.mtime
-    @modifiedFilesList.append("<li>#{file} - Modified at #{mtime}")
-  rootView.vertical.append(this)
-```

docs/packages/included_libraries.md

@@ -1,10 +0,0 @@
-# Included Libraries
-
-In addition to core node.js modules, all packages can `require` the following popular
-libraries into their packages:
-
-* [SpacePen](https://github.com/nathansobo/space-pen) (as `require 'space-pen'`)
-* [jQuery](http://jquery.com/) (as `require 'jquery'`)
-* [Underscore](http://underscorejs.org/) (as `require 'underscore'`)
-
-Additional libraries can be found by browsing Atom's _node_modules_ folder.

docs/packages/package_json.md

@@ -1,18 +0,0 @@
-# package.json format
-
-The following keys are available to your package's _package.json_ manifest file:
-
-- `main` (**Required**): the path to the CoffeeScript file that's the entry point
-to your package
-- `stylesheets` (**Optional**): an Array of Strings identifying the order of the
-stylesheets your package needs to load. If not specified, stylesheets in the _stylesheets_
-directory are added alphabetically.
-- `keymaps`(**Optional**): an Array of Strings identifying the order of the
-key mappings your package needs to load. If not specified, mappings in the _keymaps_
-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.

docs/proposals/atom-docs.md

@@ -0,0 +1,63 @@
+## 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

@@ -0,0 +1,70 @@
+**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

@@ -0,0 +1,16 @@
+## 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/template.jst

@@ -0,0 +1,150 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
+    <link href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css" rel="stylesheet">
+    <link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap-theme.min.css">
+    <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
+    <!--[if lt IE 9]>
+      <script src="../../assets/js/html5shiv.js"></script>
+      <script src="../../assets/js/respond.min.js"></script>
+    <![endif]-->
+
+    <title>Atom - <%= title %></title>
+    <style>
+      /*github.com style (c) Vasily Polovnyov <vast@whiteants.net>*/
+      pre code {
+        display: block; padding: 0.5em;
+        color: #333;
+        background: #f8f8ff
+      }
+      pre .comment,
+      pre .template_comment,
+      pre .diff .header,
+      pre .javadoc {
+        color: #998;
+        font-style: italic
+      }
+      pre .keyword,
+      pre .css .rule .keyword,
+      pre .winutils,
+      pre .javascript .title,
+      pre .nginx .title,
+      pre .subst,
+      pre .request,
+      pre .status {
+        color: #333;
+        font-weight: bold
+      }
+      pre .number,
+      pre .hexcolor,
+      pre .ruby .constant {
+        color: #099;
+      }
+      pre .string,
+      pre .tag .value,
+      pre .phpdoc,
+      pre .tex .formula {
+        color: #d14
+      }
+      pre .title,
+      pre .id {
+        color: #900;
+        font-weight: bold
+      }
+      pre .javascript .title,
+      pre .lisp .title,
+      pre .clojure .title,
+      pre .subst {
+        font-weight: normal
+      }
+      pre .class .title,
+      pre .haskell .type,
+      pre .vhdl .literal,
+      pre .tex .command {
+        color: #458;
+        font-weight: bold
+      }
+      pre .tag,
+      pre .tag .title,
+      pre .rules .property,
+      pre .django .tag .keyword {
+        color: #000080;
+        font-weight: normal
+      }
+      pre .attribute,
+      pre .variable,
+      pre .lisp .body {
+        color: #008080
+      }
+      pre .regexp {
+        color: #009926
+      }
+      pre .class {
+        color: #458;
+        font-weight: bold
+      }
+      pre .symbol,
+      pre .ruby .symbol .string,
+      pre .lisp .keyword,
+      pre .tex .special,
+      pre .prompt {
+        color: #990073
+      }
+      pre .built_in,
+      pre .lisp .title,
+      pre .clojure .built_in {
+        color: #0086b3
+      }
+      pre .preprocessor,
+      pre .pi,
+      pre .doctype,
+      pre .shebang,
+      pre .cdata {
+        color: #999;
+        font-weight: bold
+      }
+      pre .deletion {
+        background: #fdd
+      }
+      pre .addition {
+        background: #dfd
+      }
+      pre .diff .change {
+        background: #0086b3
+      }
+      pre .chunk {
+        color: #aaa
+      }
+
+      body {
+        padding-top: 50px;
+      }
+    </style>
+  </head>
+  <body>
+   <div class="navbar navbar-inverse navbar-fixed-top">
+      <div class="container">
+        <div class="navbar-header">
+          <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+          </button>
+          <a class="navbar-brand" href="/<%= tag %>/index.html">Atom Documentation</a>
+        </div>
+        <div class="collapse navbar-collapse">
+          <ul class="nav navbar-nav">
+            <li><a href="/docs/api/<%= tag %>/api/index.html">API</a></li>
+          </ul>
+        </div><!--/.nav-collapse -->
+      </div>
+    </div>
+
+    <div class="container">
+      <%= content %>
+    </div>
+  </body>
+</html>

docs/theme-variables.md

@@ -0,0 +1,116 @@
+# Style variables
+
+Atom's UI provides a set of variables you can use in your own themes and packages.
+
+## Use in Themes
+
+Each custom theme must specify a `ui-variables.less` file with all of the
+following variables defined. The top-most theme specified in the theme settings
+will be loaded and available for import.
+
+## Use in Packages
+
+In any of your package's `.less` files, you can access the theme variables
+by importing the `ui-variables` file from Atom.
+
+Your package should generally only specify structural styling, and these should
+come from [the style guide][styleguide]. Your package shouldn't specify colors,
+padding sizes, or anything in absolute pixels. You should instead use the theme
+variables. If you follow this guideline, your package will look good out of the
+box with any theme!
+
+Here's an example `.less` file that a package can define using theme variables:
+
+```css
+@import "ui-variables";
+
+.my-selector{
+  background-color: @base-background-color;
+  padding: @component-padding;
+}
+```
+
+## Variables
+
+### Text colors
+
+* `@text-color`
+* `@text-color-subtle`
+* `@text-color-highlight`
+* `@text-color-selected`
+* `@text-color-info` - A blue
+* `@text-color-success`- A green
+* `@text-color-warning`- An orange or yellow
+* `@text-color-error` - A red
+
+### Background colors
+
+* `@background-color-info` - A blue
+* `@background-color-success` - A green
+* `@background-color-warning` - An orange or yellow
+* `@background-color-error` - A red
+* `@background-color-highlight`
+* `@background-color-selected`
+* `@app-background-color` - The app's background under all the editor components
+
+### Component colors
+
+* `@base-background-color` -
+* `@base-border-color` -
+
+* `@pane-item-background-color` -
+* `@pane-item-border-color` -
+
+* `@input-background-color` -
+* `@input-border-color` -
+
+* `@tool-panel-background-color` -
+* `@tool-panel-border-color` -
+
+* `@inset-panel-background-color` -
+* `@inset-panel-border-color` -
+
+* `@panel-heading-background-color` -
+* `@panel-heading-border-color` -
+
+* `@overlay-background-color` -
+* `@overlay-border-color` -
+
+* `@button-background-color` -
+* `@button-background-color-hover` -
+* `@button-background-color-selected` -
+* `@button-border-color` -
+
+* `@tab-bar-background-color` -
+* `@tab-bar-border-color` -
+* `@tab-background-color` -
+* `@tab-background-color-active` -
+* `@tab-border-color` -
+
+* `@tree-view-background-color` -
+* `@tree-view-border-color` -
+
+* `@ui-site-color-1` -
+* `@ui-site-color-2` -
+* `@ui-site-color-3` -
+* `@ui-site-color-4` -
+* `@ui-site-color-5` -
+
+### Component sizes
+
+* `@disclosure-arrow-size` -
+
+* `@component-padding` -
+* `@component-icon-padding` -
+* `@component-icon-size` -
+* `@component-line-height` -
+* `@component-border-radius` -
+
+* `@tab-height` -
+
+### Fonts
+
+* `@font-size` -
+* `@font-family` -
+
+[styleguide]: https://github.com/atom/styleguide

docs/themes/authoring-themes.md

@@ -1,55 +0,0 @@
-# Authoring Themes
-
-If you understand CSS, you can write an Atom theme easily. Your theme can style
-Atom's user interface, specify the appearance of syntax-highlighted code, or
-both. For making a syntax highlighting theme, refer to
-[section 12.4 of the TextMate Manual](http://manual.macromates.com/en/language_grammars.html)
-for a list of the common scopes used by TextMate grammars. You'll just need to
-translate scope names to CSS classes. To theme Atom's user interface, take a
-look at the existing light and dark themes for an example. Pressing `alt-meta-i`
-and inspecting the Atom's markup directly can also be helpful.
-
-The most basic theme is just a _.css_ file. More complex themes occupy their own
-folder, which can contain multiple stylesheets along with an optional
-_package.cson_ file containing a manifest to control their load-order:
-
-```text
-~/.atom/themes/
-  rockstar.css
-  rainbow/
-    package.json
-    core.css
-    editor.css
-    tree-view.css
-```
-
-package.cson:
-```coffee-script
-stylesheets: ["core.css", "editor.less", "tree-view.css"]
-```
-
-The `package.cson` file specifies which stylesheets to load and in what order
-with the `stylesheets` key. If no manifest is specified, all stylesheets are
-loaded in alphabetical order when the user selects the theme.
-
-
-## Theme Extensions (Not Yet Implemented)
-
-A theme may need to be extended to cover DOM elements that are introduced by a
-third-party Atom package. When a package is loaded, stylesheets with the same
-name as the package will automatically be loaded from the `packages` directory
-of active themes:
-
-```text
-~/.atom/themes/
-  midnight/midnight.less
-  midnight/packages/terminal.less
-  midnight/packages/tree-view.less
-```
-
-In the example above, if the `midnight` theme is active, its `terminal` and
-`tree-view` stylesheets will be loaded automatically if and when those packages
-are activated. If you author an extension to a theme consider sending its author
-a pull request to have it included in the theme by default. Package-specific
-theme stylesheets need not be listed in the theme's `package.json` because they
-will be loaded automatically when the package is loaded.

docs/your-first-package.md

@@ -0,0 +1,334 @@
+# Creating Your First Package
+
+Let's take a look at creating your first package.
+
+To get started, hit `cmd-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-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'
+```
+
+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.
+
+`.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 bind keybindings to a command, we'll need to do a bit of association in our
+CoffeeScript code using the `rootView.command` method. This method takes a command
+name and executes a callback function. Open up _lib/changer-view.coffee_, and
+change `rootView.command "changer:toggle"` to look like this:
+
+```coffeescript
+rootView.command "changer:magic", => @magic()
+```
+
+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.
+
+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?!
+
+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:
+
+```json
+"activationEvents": ["changer:magic"]
+```
+
+Hitting the key binding on the tree now works!
+
+## Working with Styles
+
+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:
+
+```coffeescript
+{$, View} = require 'atom'
+```
+
+Now, we can define the `magic` method to query the tree to get us a list of every
+file that _wasn't_ modified:
+
+```coffeescript
+magic: ->
+  $('ol.entries li').each (i, el) ->
+    if !$(el).hasClass("status-modified")
+      console.log el
+```
+
+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`:
+
+```coffeescript
+magic: ->
+  $('ol.entries li').each (i, el) ->
+    if !$(el).hasClass("status-modified")
+      $(el).addClass("hide-me")
+```
+
+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;
+}
+```
+
+Refresh Atom, and run the `changer` command. You'll see all the non-changed
+files disappear from the tree. Success!
+
+![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:
+
+```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")
+```
+
+## 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
+rootView.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, `rootView.vertical.append` tells Atom to append `this`
+item (_i.e._, whatever is defined by`@content`) _vertically_ to the editor. If
+we had called `rootView.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 `rootView.vertical.append`
+call with this code:
+
+```coffeescript
+# toggles the pane
+if @hasParent()
+  rootView.vertical.children().last().remove()
+else
+  rootView.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()
+  rootView.vertical.children().last().remove()
+else
+  for file in modifiedFiles
+    stat = fs.lstatSync(file)
+    mtime = stat.mtime
+    @modifiedFilesList.append("<li>#{file} - Modified at #{mtime}")
+  rootView.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
+  rootView.vertical.children().last().remove()
+else
+  for file in modifiedFiles
+    stat = fs.lstatSync(file)
+    mtime = stat.mtime
+    @modifiedFilesList.append("<li>#{file} - Modified at #{mtime}")
+  rootView.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.
+
+## Further reading
+
+For more information on the mechanics of packages, check out
+[Creating a Package][creating-a-package].
+
+[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

dot-atom/keymap.cson

@@ -0,0 +1,13 @@
+# User 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:
+#
+# '.editor':
+#   'enter': 'editor:newline'
+#
+# 'body':
+#   'ctrl-P': 'core:move-up'
+#   'ctrl-p': 'core:move-down'

dot-atom/themes/README.md

@@ -1 +0,0 @@
-All themes in this directory will be automatically loaded

exports/atom.coffee

@@ -0,0 +1,28 @@
+{Document, Point, Range} = require 'telepath'
+
+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'
+  Point: Point
+  Range: Range
+
+# The following classes can't be used from a Task handler and should therefore
+# only be exported when not running as a child node process
+unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
+  {$, $$, $$$, View} = require '../src/space-pen-extensions'
+
+  module.exports.$ = $
+  module.exports.$$ = $$
+  module.exports.$$$ = $$$
+  module.exports.Editor = require '../src/editor-view'
+  module.exports.RootView = require '../src/root-view'
+  module.exports.SelectList = require '../src/select-list'
+  module.exports.ScrollView = require '../src/scroll-view'
+  module.exports.Task = require '../src/task'
+  module.exports.View = View

keymaps/base.cson

@@ -0,0 +1,52 @@
+'.editor':
+  # Platform Bindings
+  'alt-left': 'editor:move-to-previous-word-boundary'
+  'alt-right': 'editor:move-to-next-word-boundary'
+  'alt-shift-left': 'editor:select-to-previous-word-boundary'
+  'alt-shift-right': 'editor:select-to-next-word-boundary'
+  'home': 'editor:move-to-first-character-of-line'
+  'end': 'editor:move-to-end-of-line'
+  'shift-home': 'editor:select-to-first-character-of-line'
+  'shift-end': 'editor:select-to-end-of-line'
+
+  # Sublime Parity
+  'ctrl-t': 'editor:transpose'
+
+'.editor:not(.mini)':
+  # Atom Specific
+  'ctrl-C': 'editor:copy-path'
+
+  # Sublime Parity
+  'tab': 'editor:indent'
+  'enter': 'editor:newline'
+  'shift-tab': 'editor:outdent-selected-rows'
+  'ctrl-K': 'editor:delete-line'
+  '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'
+
+'.editor !important, .editor.mini !important':
+  'escape': 'editor:consolidate-selections'
+
+# allow standard input fields to work correctly
+'input:not(.hidden-input), .native-key-bindings':
+  'tab': 'core:focus-next'
+  'shift-tab': 'core:focus-previous'
+  'left': 'native!'
+  'right': 'native!'
+  'shift-left': 'native!'
+  'shift-right': 'native!'
+  'backspace': 'native!'
+  'shift-backspace': 'native!'
+  'delete': 'native!'
+  'ctrl-b': 'native!'
+  'ctrl-f': 'native!'
+  'ctrl-F': 'native!'
+  'ctrl-B': 'native!'
+  'ctrl-h': 'native!'
+  'ctrl-d': 'native!'

keymaps/darwin.cson

@@ -0,0 +1,154 @@
+'.platform-darwin':
+  # Apple specific
+  'cmd-q': 'application:quit'
+  'cmd-h': 'application:hide'
+  'cmd-H': 'application:hide-other-applications'
+  'cmd-m': 'application:minimize'
+  'alt-cmd-ctrl-m': 'application:zoom'
+
+  'ctrl-p': 'core:move-up'
+  'ctrl-n': 'core:move-down'
+  'ctrl-b': 'core:move-left'
+  'ctrl-f': 'core:move-right'
+  'ctrl-P': 'core:select-up'
+  'ctrl-N': 'core:select-down'
+  'ctrl-F': 'core:select-right'
+  'ctrl-B': 'core:select-left'
+  'ctrl-h': 'core:backspace'
+  'ctrl-d': 'core:delete'
+
+  # Atom Specific
+  'cmd-O': 'application:open-dev'
+  'cmd-alt-ctrl-s': 'application:run-all-specs'
+  'enter': 'core:confirm'
+  'escape': 'core:cancel'
+  'up': 'core:move-up'
+  'down': 'core:move-down'
+  'left': 'core:move-left'
+  'right': 'core:move-right'
+  'ctrl-alt-cmd-r': 'window:reload'
+  'alt-cmd-i': 'window:toggle-dev-tools'
+  'cmd-alt-ctrl-p': 'window:run-package-specs'
+
+  # Sublime Parity
+  'cmd-,': 'application:show-settings'
+  'cmd-N': 'application:new-window'
+  'cmd-W': 'window:close'
+  'cmd-o': 'application:open'
+  'cmd-T': 'pane:reopen-closed-item'
+  'cmd-n': 'application:new-file'
+  'cmd-s': 'core:save'
+  'cmd-S': 'core:save-as'
+  'cmd-alt-s': 'window:save-all'
+  'cmd-w': 'core:close'
+  'cmd-ctrl-f': 'window:toggle-full-screen'
+  'cmd-z': 'core:undo'
+  'cmd-Z': 'core:redo'
+  'cmd-y': 'core:redo'
+  'cmd-x': 'core:cut'
+  'cmd-c': 'core:copy'
+  'cmd-v': 'core:paste'
+  'shift-up': 'core:select-up'
+  'shift-down': 'core:select-down'
+  'shift-left': 'core:select-left'
+  'shift-right': 'core:select-right'
+  'delete': 'core:delete'
+  'pageup': 'core:page-up'
+  'pagedown': 'core:page-down'
+  'backspace': 'core:backspace'
+  'shift-backspace': 'core:backspace'
+  'cmd-up': 'core:move-to-top'
+  'cmd-down': 'core:move-to-bottom'
+  'cmd-shift-up': 'core:select-to-top'
+  'cmd-shift-down': 'core:select-to-bottom'
+  'cmd-{': 'pane:show-previous-item'
+  'cmd-}': 'pane:show-next-item'
+  'cmd-alt-left': 'pane:show-previous-item'
+  'cmd-alt-right': 'pane:show-next-item'
+  'cmd-=': 'window:increase-font-size'
+  'cmd-+': 'window:increase-font-size'
+  'cmd--': 'window:decrease-font-size'
+
+  'cmd-k up': 'pane:split-up' # Atom Specific
+  'cmd-k down': 'pane:split-down' # Atom Specific
+  'cmd-k left': 'pane:split-left' # Atom Specific
+  '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-1': 'pane:show-item-1'
+  'cmd-2': 'pane:show-item-2'
+  'cmd-3': 'pane:show-item-3'
+  'cmd-4': 'pane:show-item-4'
+  'cmd-5': 'pane:show-item-5'
+  'cmd-6': 'pane:show-item-6'
+  'cmd-7': 'pane:show-item-7'
+  'cmd-8': 'pane:show-item-8'
+  'cmd-9': 'pane:show-item-9'
+
+'.platform-darwin .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-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-e': 'editor:move-to-end-of-line'
+  'ctrl-k': 'editor:cut-to-end-of-line'
+
+  # Atom Specific
+  'ctrl-W': 'editor:select-word'
+
+  # Sublime Parity
+  'cmd-a': 'core:select-all'
+  'cmd-alt-p': 'editor:log-cursor-scope'
+  'cmd-k cmd-u': 'editor:upper-case'
+  'cmd-k cmd-l': 'editor:lower-case'
+
+'body.platform-darwin .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'
+  'cmd-shift-enter': 'editor:newline-above'
+  'cmd-]': 'editor:indent-selected-rows'
+  'cmd-[': 'editor:outdent-selected-rows'
+  'ctrl-cmd-up': 'editor:move-line-up'
+  'ctrl-cmd-down': 'editor:move-line-down'
+  'cmd-/': 'editor:toggle-line-comments'
+  'cmd-j': 'editor:join-line'
+  'cmd-D': 'editor:duplicate-line'
+
+  'cmd-alt-[': 'editor:fold-current-row'
+  'cmd-alt-]': 'editor:unfold-current-row'
+  'cmd-alt-{': 'editor:fold-all' # Atom Specific
+  'cmd-alt-}': 'editor:unfold-all' # Atom Specific
+  'cmd-k cmd-0': 'editor:unfold-all'
+  'cmd-k cmd-1': 'editor:fold-at-indent-level-1'
+  'cmd-k cmd-2': 'editor:fold-at-indent-level-2'
+  'cmd-k cmd-3': 'editor:fold-at-indent-level-3'
+  'cmd-k cmd-4': 'editor:fold-at-indent-level-4'
+  'cmd-k cmd-5': 'editor:fold-at-indent-level-5'
+  'cmd-k cmd-6': 'editor:fold-at-indent-level-6'
+  'cmd-k cmd-7': 'editor:fold-at-indent-level-7'
+  'cmd-k cmd-8': 'editor:fold-at-indent-level-8'
+  'cmd-k cmd-9': 'editor:fold-at-indent-level-9'
+
+# allow standard input fields to work correctly
+'body.platform-darwin input:not(.hidden-input), body.platform-darwin .native-key-bindings':
+  'cmd-z': 'native!'
+  'cmd-Z': 'native!'
+  'cmd-x': 'native!'
+  'cmd-c': 'native!'
+  'cmd-v': 'native!'

keymaps/emacs.cson

@@ -0,0 +1,7 @@
+'.editor':
+  'alt-f': 'editor:move-to-end-of-word'
+  'alt-F': 'editor:select-to-end-of-word'
+  'alt-b': 'editor:move-to-beginning-of-word'
+  'alt-B': 'editor:select-to-beginning-of-word'
+  'alt-h': 'editor:backspace-to-beginning-of-word'
+  'alt-d': 'editor:delete-to-end-of-word'

keymaps/win32.cson

@@ -0,0 +1,102 @@
+'.platform-win32':
+  # Atom Specific
+  'enter': 'core:confirm'
+  'escape': 'core:cancel'
+  'up': 'core:move-up'
+  'down': 'core:move-down'
+  'left': 'core:move-left'
+  'right': 'core:move-right'
+  'ctrl-alt-r': 'window:reload'
+  'ctrl-alt-i': 'window:toggle-dev-tools'
+  'ctrl-alt-p': 'window:run-package-specs'
+  'ctrl-alt-s': 'application:run-all-specs'
+
+  # Sublime Parity
+  'ctrl-N': 'application:new-window'
+  'ctrl-W': 'window:close'
+  'ctrl-o': 'application:open'
+  'ctrl-T': 'pane:reopen-closed-item'
+  'ctrl-n': 'application:new-file'
+  'ctrl-s': 'core:save'
+  'ctrl-S': 'core:save-as'
+  'ctrl-w': 'core:close'
+  'ctrl-z': 'core:undo'
+  'ctrl-y': 'core:redo'
+  'ctrl-x': 'core:cut'
+  'ctrl-c': 'core:copy'
+  'ctrl-v': 'core:paste'
+  'shift-up': 'core:select-up'
+  'shift-down': 'core:select-down'
+  'shift-left': 'core:select-left'
+  'shift-right': 'core:select-right'
+  'delete': 'core:delete'
+  'pageup': 'core:page-up'
+  'pagedown': 'core:page-down'
+  'backspace': 'core:backspace'
+  'ctrl-tab': 'pane:show-next-item'
+  'ctrl-shift-tab': 'pane:show-previous-item'
+  'ctrl-shift-up': 'core:move-up'
+  'ctrl-shift-down': 'core:move-down'
+  'ctrl-=': 'window:increase-font-size'
+  'ctrl-+': 'window:increase-font-size'
+  'ctrl--': 'window:decrease-font-size'
+
+  'ctrl-k up': 'pane:split-up' # Atom Specific
+  'ctrl-k down': 'pane:split-down' # Atom Specific
+  'ctrl-k left': 'pane:split-left' # Atom Specific
+  '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'
+
+'.platform-win32 .editor':
+  # Windows specific
+  'ctrl-delete': 'editor:backspace-to-beginning-of-word'
+
+  # Sublime Parity
+  'ctrl-a': 'core:select-all'
+  'ctrl-alt-p': 'editor:log-cursor-scope'
+  'ctrl-k ctrl-u': 'editor:upper-case'
+  'ctrl-k ctrl-l': 'editor:lower-case'
+
+'.platform-win32 .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'
+  'ctrl-shift-enter': 'editor:newline-above'
+  'ctrl-]': 'editor:indent-selected-rows'
+  'ctrl-[': 'editor:outdent-selected-rows'
+  'ctrl-up': 'editor:move-line-up'
+  'ctrl-down': 'editor:move-line-down'
+  'ctrl-/': 'editor:toggle-line-comments'
+  'ctrl-j': 'editor:join-line'
+  'ctrl-D': 'editor:duplicate-line'
+
+  'ctrl-alt-[': 'editor:fold-current-row'
+  'ctrl-alt-]': 'editor:unfold-current-row'
+  'ctrl-alt-{': 'editor:fold-all' # Atom Specific
+  'ctrl-alt-}': 'editor:unfold-all' # Atom Specific
+  'ctrl-k ctrl-0': 'editor:unfold-all'
+  'ctrl-k ctrl-1': 'editor:fold-at-indent-level-1'
+  'ctrl-k ctrl-2': 'editor:fold-at-indent-level-2'
+  'ctrl-k ctrl-3': 'editor:fold-at-indent-level-3'
+  'ctrl-k ctrl-4': 'editor:fold-at-indent-level-4'
+  'ctrl-k ctrl-5': 'editor:fold-at-indent-level-5'
+  'ctrl-k ctrl-6': 'editor:fold-at-indent-level-6'
+  'ctrl-k ctrl-7': 'editor:fold-at-indent-level-7'
+  'ctrl-k ctrl-8': 'editor:fold-at-indent-level-8'
+  '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':
+  'ctrl-z': 'native!'
+  'ctrl-Z': 'native!'
+  'ctrl-x': 'native!'
+  'ctrl-c': 'native!'
+  'ctrl-v': 'native!'

menus/darwin.cson

@@ -0,0 +1,180 @@
+'menu': [
+  {
+    label: 'Atom'
+    submenu: [
+      { label: 'About Atom', command: 'application:about' }
+      { label: "VERSION", enabled: false }
+      { label: "Install update", command: 'application:install-update', visible: false }
+      { type: 'separator' }
+      { label: 'Preferences...', command: 'application:show-settings' }
+      { type: 'separator' }
+      { label: 'Hide Atom', command: 'application:hide' }
+      { label: 'Hide Others', command: 'application:hide-other-applications' }
+      { label: 'Show All', command: 'application:unhide-all-applications' }
+      { type: 'separator' }
+      { label: 'Quit', command: 'application:quit' }
+    ]
+  }
+  {
+    label: 'File'
+    submenu: [
+      { label: 'New Window', command: 'application:new-window' }
+      { label: 'New File', command: 'application:new-file' }
+      { label: 'Open...', command: 'application:open' }
+      { label: 'Reopen Last Item', command: 'pane:reopen-closed-item' }
+      { type: 'separator' }
+      { label: 'Save', command: 'core:save' }
+      { label: 'Save As...', command: 'core:save-as' }
+      { label: 'Save All', command: 'window:save-all' }
+      { type: 'separator' }
+      { label: 'Close Buffer', command: 'core:close' }
+      { label: 'Close All Buffers', command: 'pane:close' }
+      { label: 'Close Window', command: 'window:close' }
+    ]
+  }
+
+  {
+    label: 'Edit'
+    submenu: [
+      { label: 'Undo', command: 'core:undo' }
+      { label: 'Redo', command: 'core:redo' }
+      { type: 'separator' }
+      { label: 'Cut', command: 'core:cut' }
+      { label: 'Copy', command: 'core:copy' }
+      { label: 'Copy Path', command: 'editor:copy-path' }
+      { label: 'Paste', command: 'core:paste' }
+      { label: 'Select All', command: 'core:select-all' }
+      { type: 'separator' }
+      { label: 'Toggle Comments', command: 'editor:toggle-line-comments' }
+      {
+        label: 'Lines',
+        submenu: [
+          { label: 'Indent', command: 'editor:indent-selected-rows' }
+          { label: 'Outdent', command: 'editor:outdent-selected-rows' }
+          { label: 'Auto Indent', command: 'editor:auto-indent' }
+          { type: 'separator' }
+          { label: 'Move Line Up', command: 'editor:move-line-up' }
+          { label: 'Move Line Down', command: 'editor:move-line-down' }
+          { label: 'Duplicate Line', command: 'editor:duplicate-line' }
+          { label: 'Delete Line', command: 'editor:delete-line' }
+          { label: 'Join Lines', command: 'editor:join-line' }
+        ]
+      }
+      {
+        label: 'Text',
+        submenu: [
+          { label: 'Upper Case', command: 'editor:upper-case' }
+          { label: 'Lower Case', command: 'editor:lower-case' }
+          { type: 'separator' }
+          { label: 'Delete to End of Word', command: 'editor:delete-to-end-of-word' }
+          { label: 'Delete Line', command: 'editor:delete-line' }
+          { type: 'separator' }
+          { label: 'Transpose', command: 'editor:transpose' }
+        ]
+      }
+      {
+        label: 'Folding',
+        submenu: [
+          { label: 'Fold', command: 'editor:fold-current-row' }
+          { label: 'Unfold', command: 'editor:unfold-current-row' }
+          { label: 'Unfold All', command: 'editor:unfold-all' }
+          { type: 'separator' }
+          { label: 'Fold All', command: 'editor:fold-all' }
+          { label: 'Fold Level 1', command: 'editor:fold-at-indent-level-1' }
+          { label: 'Fold Level 2', command: 'editor:fold-at-indent-level-2' }
+          { label: 'Fold Level 3', command: 'editor:fold-at-indent-level-3' }
+          { label: 'Fold Level 4', command: 'editor:fold-at-indent-level-4' }
+          { label: 'Fold Level 5', command: 'editor:fold-at-indent-level-5' }
+          { label: 'Fold Level 6', command: 'editor:fold-at-indent-level-6' }
+          { label: 'Fold Level 7', command: 'editor:fold-at-indent-level-7' }
+          { label: 'Fold Level 8', command: 'editor:fold-at-indent-level-8' }
+          { label: 'Fold Level 9', command: 'editor:fold-at-indent-level-9' }
+        ]
+      }
+    ]
+  }
+
+  {
+    label: 'Selection'
+    submenu: [
+      { label: 'Add Selection Above', command: 'editor:add-selection-above' }
+      { label: 'Add Selection Below', command: 'editor:add-selection-below' }
+      { type: 'separator' }
+      { label: 'Select to Top', command: 'core:select-to-top' }
+      { label: 'Select to Bottom', command: 'core:select-to-bottom' }
+      { type: 'separator' }
+      { label: 'Select Line', command: 'editor:select-line' }
+      { label: 'Select Word', command: 'editor:select-word' }
+      { label: 'Select to Beginning of Word', command: 'editor:select-to-beginning-of-word' }
+      { label: 'Select to Beginning of Line', command: 'editor:select-to-beginning-of-line' }
+      { label: 'Select to First Character of Line', command: 'editor:select-to-first-character-of-line' }
+      { label: 'Select to End of Word', command: 'editor:select-to-end-of-word' }
+      { label: 'Select to End of Line', command: 'editor:select-to-end-of-line' }
+    ]
+  }
+
+  {
+    label: 'Movement'
+    submenu: [
+      { label: 'Move to Top', command: 'core:move-to-top' }
+      { label: 'Move to Bottom', command: 'core:move-to-bottom' }
+      { type: 'separator' }
+      { label: 'Move to Beginning of Line', command: 'editor:move-to-beginning-of-line' }
+      { label: 'Move to First Character of Line', command: 'editor:move-to-first-character-of-line' }
+      { label: 'Move to End of Line', command: 'editor:move-to-end-of-line' }
+      { type: 'separator' }
+      { label: 'Move to Beginning of Word', command: 'editor:move-to-beginning-of-word' }
+      { label: 'Move to End of Word', command: 'editor:move-to-end-of-word' }
+      { label: 'Move to Next Word', command: 'editor:move-to-next-word-boundary' }
+      { label: 'Move to Previous Word', command: 'editor:move-to-previous-word-boundary' }
+    ]
+  }
+
+  {
+    label: 'Find'
+    submenu: []
+  }
+
+  {
+    label: 'View'
+    submenu: [
+      { label: 'Reload', command: 'window:reload' }
+      { label: 'Toggle Full Screen', command: 'window:toggle-full-screen' }
+      {
+        label: 'Developer'
+        submenu: [
+          { label: 'Open In Dev Mode...', command: 'application:open-dev' }
+          { label: 'Run Atom Specs', command: 'application:run-all-specs' }
+          { label: 'Run Package Specs', command: 'window:run-package-specs' }
+          { label: 'Toggle Developer Tools', command: 'window:toggle-dev-tools' }
+        ]
+      }
+      { type: 'separator' }
+      { label: 'Toggle Soft Wrap', command: 'editor:toggle-soft-wrap' }
+    ]
+  }
+
+  {
+    label: 'Packages'
+    submenu: []
+  }
+
+  {
+    label: 'Window'
+    submenu: [
+      { label: 'Minimize', command: 'application:minimize' }
+      { label: 'Zoom', command: 'application:zoom' }
+      { type: 'separator' }
+      { label: 'Bring All to Front', command: 'application:bring-all-windows-to-front' }
+    ]
+  }
+
+  {
+    label: 'Help'
+    submenu: [
+      { label: 'Documentation', command: 'application:open-documentation' }
+      { label: 'Report an Issue', command: 'application:report-issue' }
+      { type: 'separator' }
+    ]
+  }
+]

menus/win32.cson

@@ -0,0 +1,172 @@
+'menu': [
+  {
+    label: '&File'
+    submenu: [
+      { label: 'New &Window', command: 'application:new-window' }
+      { label: '&New File', command: 'application:new-file' }
+      { label: '&Open...', command: 'application:open' }
+      { label: 'Reopen Last &Item', command: 'pane:reopen-closed-item' }
+      { type: 'separator' }
+      { label: '&Preferences...', command: 'application:show-settings' }
+      { type: 'separator' }
+      { label: '&Save', command: 'core:save' }
+      { label: 'Save &As...', command: 'core:save-as' }
+      { label: 'Save A&ll', command: 'window:save-all' }
+      { type: 'separator' }
+      { label: '&Close Buffer', command: 'core:close' }
+      { label: 'Close All &Buffers', command: 'pane:close' }
+      { label: 'Clos&e Window', command: 'window:close' }
+      { type: 'separator' }
+      { label: 'E&xit', command: 'application:quit' }
+    ]
+  }
+
+  {
+    label: '&Edit'
+    submenu: [
+      { label: '&Undo', command: 'core:undo' }
+      { label: '&Redo', command: 'core:redo' }
+      { type: 'separator' }
+      { label: '&Cut', command: 'core:cut' }
+      { label: 'C&opy', command: 'core:copy' }
+      { label: 'Copy Pat&h', command: 'editor:copy-path' }
+      { label: '&Paste', command: 'core:paste' }
+      { label: 'Select &All', command: 'core:select-all' }
+      { type: 'separator' }
+      { label: '&Toggle Comments', command: 'editor:toggle-line-comments' }
+      {
+        label: 'Lines',
+        submenu: [
+          { label: '&Indent', command: 'editor:indent-selected-rows' }
+          { label: '&Outdent', command: 'editor:outdent-selected-rows' }
+          { label: '&Auto Indent', command: 'editor:auto-indent' }
+          { type: 'separator' }
+          { label: 'Move Line &Up', command: 'editor:move-line-up' }
+          { label: 'Move Line &Down', command: 'editor:move-line-down' }
+          { label: 'Du&plicate Line', command: 'editor:duplicate-line' }
+          { label: 'D&elete Line', command: 'editor:delete-line' }
+          { label: '&Join Lines', command: 'editor:join-line' }
+        ]
+      }
+      {
+        label: 'Text',
+        submenu: [
+          { label: '&Upper Case', command: 'editor:upper-case' }
+          { label: '&Lower Case', command: 'editor:lower-case' }
+          { type: 'separator' }
+          { label: 'Delete to End of &Word', command: 'editor:delete-to-end-of-word' }
+          { label: '&Delete Line', command: 'editor:delete-line' }
+          { type: 'separator' }
+          { label: '&Transpose', command: 'editor:transpose' }
+        ]
+      }
+      {
+        label: 'Folding',
+        submenu: [
+          { label: '&Fold', command: 'editor:fold-current-row' }
+          { label: '&Unfold', command: 'editor:unfold-current-row' }
+          { label: 'Unfold &All', command: 'editor:unfold-all' }
+          { type: 'separator' }
+          { label: 'Fol&d All', command: 'editor:fold-all' }
+          { label: 'Fold Level 1', command: 'editor:fold-at-indent-level-1' }
+          { label: 'Fold Level 2', command: 'editor:fold-at-indent-level-2' }
+          { label: 'Fold Level 3', command: 'editor:fold-at-indent-level-3' }
+          { label: 'Fold Level 4', command: 'editor:fold-at-indent-level-4' }
+          { label: 'Fold Level 5', command: 'editor:fold-at-indent-level-5' }
+          { label: 'Fold Level 6', command: 'editor:fold-at-indent-level-6' }
+          { label: 'Fold Level 7', command: 'editor:fold-at-indent-level-7' }
+          { label: 'Fold Level 8', command: 'editor:fold-at-indent-level-8' }
+          { label: 'Fold Level 9', command: 'editor:fold-at-indent-level-9' }
+        ]
+      }
+    ]
+  }
+
+  {
+    label: '&View'
+    submenu: [
+      { label: '&Reload', command: 'window:reload' }
+      { label: 'Toggle &Full Screen', command: 'window:toggle-full-screen' }
+      {
+        label: 'Developer'
+        submenu: [
+          { label: 'Open In &Dev Mode...', command: 'application:open-dev' }
+          { label: 'Run &Atom Specs', command: 'application:run-all-specs' }
+          { label: 'Run Package &Specs', command: 'window:run-package-specs' }
+          { label: 'Toggle Developer &Tools', command: 'window:toggle-dev-tools' }
+        ]
+      }
+      { type: 'separator' }
+      { label: 'Toggle Soft &Wrap', command: 'editor:toggle-soft-wrap' }
+    ]
+  }
+
+  {
+    label: '&Selection'
+    submenu: [
+      { label: 'Add Selection &Above', command: 'editor:add-selection-above' }
+      { label: 'Add Selection &Below', command: 'editor:add-selection-below' }
+      { type: 'separator' }
+      { label: 'Select to &Top', command: 'core:select-to-top' }
+      { label: 'Select to Botto&m', command: 'core:select-to-bottom' }
+      { type: 'separator' }
+      { label: 'Select &Line', command: 'editor:select-line' }
+      { label: 'Select &Word', command: 'editor:select-word' }
+      { label: 'Select to Beginning of W&ord', command: 'editor:select-to-beginning-of-word' }
+      { label: 'Select to Beginning of L&ine', command: 'editor:select-to-beginning-of-line' }
+      { label: 'Select to First &Character of Line', command: 'editor:select-to-first-character-of-line' }
+      { label: 'Select to End of Wor&d', command: 'editor:select-to-end-of-word' }
+      { label: 'Select to End of Lin&e', command: 'editor:select-to-end-of-line' }
+    ]
+  }
+
+  {
+    label: '&Movement'
+    submenu: [
+      { label: 'Move to &Top', command: 'core:move-to-top' }
+      { label: 'Move to &Bottom', command: 'core:move-to-bottom' }
+      { type: 'separator' }
+      { label: 'Move to Beginning of &Line', command: 'editor:move-to-beginning-of-line' }
+      { label: 'Move to &First Character of Line', command: 'editor:move-to-first-character-of-line' }
+      { label: 'Move to &End of Line', command: 'editor:move-to-end-of-line' }
+      { type: 'separator' }
+      { label: 'Move to Beginning of &Word', command: 'editor:move-to-beginning-of-word' }
+      { label: 'Move to End of Wor&d', command: 'editor:move-to-end-of-word' }
+      { label: 'Move to &Next Word', command: 'editor:move-to-next-word-boundary' }
+      { label: 'Move to &Previous Word', command: 'editor:move-to-previous-word-boundary' }
+    ]
+  }
+
+  {
+    label: 'F&ind'
+    submenu: []
+  }
+
+  {
+    label: '&Packages'
+    submenu: []
+  }
+
+  {
+    label: '&Window'
+    submenu: [
+      { label: 'Mi&nimize', command: 'application:minimize' }
+      { label: 'Ma&ximize', command: 'application:zoom' }
+      { type: 'separator' }
+      { label: 'Bring &All to Front', command: 'application:bring-all-windows-to-front' }
+    ]
+  }
+
+  {
+    label: '&Help'
+    submenu: [
+      { label: '&About Atom...', command: 'application:about' }
+      { label: "VERSION", enabled: false }
+      { label: "Install &update", command: 'application:install-update', visible: false }
+      { type: 'separator' }
+      { label: '&Documentation', command: 'application:open-documentation' }
+      { label: 'Report an &Issue', command: 'application:report-issue' }
+      { type: 'separator' }
+    ]
+  }
+]

package.json

@@ -1,89 +1,151 @@
 {
   "name": "atom",
-  "version": "0.0.0",
-  "main": "./src/main.js",
+  "version": "39.0.0",
+  "main": "./src/browser/main.js",
   "repository": {
     "type": "git",
-    "url": "https://github.com/github/atom.git"
+    "url": "https://github.com/atom/atom.git"
   },
+  "bugs": {
+    "url": "https://github.com/atom/atom/issues"
+  },
+  "atomShellVersion": "0.6.11",
   "dependencies": {
-    "coffee-script": "1.6.2",
-    "ctags": "0.5.0",
-    "oniguruma": "0.16.0",
-    "mkdirp": "0.3.5",
-    "git-utils": "0.19.0",
-    "underscore": "1.4.4",
-    "d3": "3.0.8",
-    "coffee-cache": "0.1.0",
-    "pegjs": "0.7.0",
     "async": "0.2.6",
-    "nak": "0.2.16",
-    "spellchecker": "0.6.0",
-    "pathwatcher": "0.5.0",
-    "keytar": "0.9.0",
-    "ls-archive": "0.9.0",
-    "temp": "0.5.0",
-    "rimraf": "2.1.4",
-    "plist": "git://github.com/nathansobo/node-plist.git",
-    "space-pen": "1.0.0",
-    "less": "git://github.com/nathansobo/less.js.git",
-    "roaster": "0.0.5",
-    "jqueryui-browser": "1.10.2-1",
-    "optimist": "0.4.0",
-    "season": "0.10.0",
-    "humanize-plus": "1.1.0",
-    "semver": "1.1.4",
+    "bootstrap": "git://github.com/benogle/bootstrap.git",
+    "clear-cut": "0.2.0",
+    "coffee-script": "1.6.3",
+    "coffeestack": "0.6.0",
+    "emissary": "0.19.0",
+    "first-mate": "0.5.0",
+    "fs-plus": "0.9.0",
+    "fuzzaldrin": "0.1.0",
+    "git-utils": "0.29.0",
     "guid": "0.0.10",
-    "tantamount": "0.3.0",
-    "coffeestack": "0.4.0",
-    "c-tmbundle": "1.0.0",
-    "coffee-script-tmbundle": "2.0.0",
-    "css-tmbundle": "1.0.0",
-    "git-tmbundle": "1.0.0",
-    "go-tmbundle": "1.0.0",
-    "html-tmbundle": "1.0.0",
-    "hyperlink-helper-tmbundle": "1.0.0",
-    "java-tmbundle": "1.0.0",
-    "javascript-tmbundle": "1.0.0",
-    "json-tmbundle": "1.0.0",
-    "less-tmbundle": "1.0.0",
-    "make-tmbundle": "1.0.0",
-    "mustache-tmbundle": "1.0.0",
-    "objective-c-tmbundle": "1.0.0",
-    "pegjs-tmbundle": "1.0.0",
-    "perl-tmbundle": "1.0.0",
-    "php-tmbundle": "1.0.0",
-    "property-list-tmbundle": "1.0.0",
-    "puppet-textmate-tmbundle": "1.0.0",
-    "python-tmbundle": "1.0.0",
-    "ruby-on-rails-tmbundle": "1.0.0",
-    "ruby-tmbundle": "1.0.0",
-    "sass-tmbundle": "1.0.0",
-    "shellscript-tmbundle": "1.0.0",
-    "source-tmbundle": "1.0.0",
-    "sql-tmbundle": "1.0.0",
-    "text-tmbundle": "1.0.0",
-    "textmate-clojure": "1.0.0",
-    "todo-tmbundle": "1.0.0",
-    "xml-tmbundle": "1.0.0",
-    "yaml-tmbundle": "1.0.0",
-    "nslog": "0.1.0"
+    "jasmine-focused": "~0.15.0",
+    "mkdirp": "0.3.5",
+    "less-cache": "0.10.0",
+    "nslog": "0.1.0",
+    "oniguruma": "0.24.0",
+    "optimist": "0.4.0",
+    "pathwatcher": "0.10.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.0",
+    "telepath": "0.45.0",
+    "temp": "0.5.0",
+    "underscore-plus": "0.3.0"
   },
   "devDependencies": {
-    "biscotto": "0.0.12",
+    "biscotto": "0.0.17",
+    "formidable": "~1.0.14",
+    "fstream": "0.1.24",
     "grunt": "~0.4.1",
     "grunt-cli": "~0.1.9",
-    "grunt-coffeelint": "0.0.6",
-    "grunt-lesslint": "0.8.0",
+    "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.5.2",
-    "jasmine-focused": "~0.7.0",
-    "walkdir": "0.0.7"
+    "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"
+  },
+  "packageDependencies": {
+    "atom-light-ui": "0.8.0",
+    "atom-light-syntax": "0.6.0",
+    "atom-dark-ui": "0.8.0",
+    "atom-dark-syntax": "0.6.0",
+    "base16-tomorrow-dark-theme": "0.6.0",
+    "solarized-dark-syntax": "0.4.0",
+    "archive-view": "0.14.0",
+    "autocomplete": "0.15.0",
+    "autoflow": "0.9.0",
+    "autosave": "0.7.0",
+    "bookmarks": "0.13.0",
+    "bracket-matcher": "0.12.0",
+    "command-logger": "0.7.0",
+    "command-palette": "0.10.0",
+    "dev-live-reload": "0.17.0",
+    "editor-stats": "0.7.0",
+    "exception-reporting": "0.8.0",
+    "find-and-replace": "0.49.0",
+    "fuzzy-finder": "0.25.0",
+    "gists": "0.11.0",
+    "git-diff": "0.16.0",
+    "github-sign-in": "0.11.0",
+    "go-to-line": "0.10.0",
+    "grammar-selector": "0.11.0",
+    "image-view": "0.9.0",
+    "keybinding-resolver": "0.5.0",
+    "link": "0.9.0",
+    "markdown-preview": "0.19.0",
+    "metrics": "0.12.0",
+    "package-generator": "0.21.0",
+    "release-notes": "0.12.0",
+    "settings-view": "0.47.0",
+    "snippets": "0.15.0",
+    "spell-check": "0.15.0",
+    "status-bar": "0.22.0",
+    "styleguide": "0.15.0",
+    "symbols-view": "0.24.0",
+    "tabs": "0.12.0",
+    "terminal": "0.22.0",
+    "timecop": "0.10.0",
+    "to-the-hubs": "0.13.0",
+    "tree-view": "0.39.0",
+    "visual-bell": "0.4.0",
+    "whitespace": "0.9.0",
+    "wrap-guide": "0.6.0",
+    "language-c": "0.2.0",
+    "language-clojure": "0.1.0",
+    "language-coffee-script": "0.3.0",
+    "language-css": "0.2.0",
+    "language-gfm": "0.9.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.3.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.4.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"
   },
   "private": true,
   "scripts": {
-    "preinstall": "true"
+    "preinstall": "node -e 'process.exit(0)'",
+    "test": "node script/test"
   }
 }

script/bootstrap

@@ -1,21 +1,38 @@
-#!/bin/sh
+#!/usr/bin/env node
+var safeExec = require('./utils/child-process-wrapper.js').safeExec;
+var path = require('path');
 
-# exit on subprocess errors
-set -o errexit
-
-exit_unless_npm_exists() {
-  if ! hash npm 2> /dev/null; then
-    echo "ERROR: Atom requires npm"
-    exit 1
-  fi
+// Executes an array of commands one by one.
+function executeCommands(commands, done, index) {
+  index = (index == undefined ? 0 : index);
+  if (index < commands.length) {
+    var command = commands[index];
+    var options = null;
+    if (typeof command !== 'string') {
+      options = command.options;
+      command = command.command;
+    }
+    safeExec(command, options, executeCommands.bind(this, commands, done, index + 1));
+  } else
+    done(null);
 }
 
-exit_unless_npm_exists
+// Join multiple commands into one line.
+function joinCommands() {
+  var commandSeparator = process.platform == 'win32' ? '&' : ';';
+  return Array.prototype.slice.call(arguments, 0).join(commandSeparator);
+}
 
-git submodule --quiet sync
-git submodule --quiet update --recursive --init
+var echoNewLine = process.platform == 'win32' ? 'echo.' : 'echo';
+var commands = [
+  'git submodule --quiet sync',
+  'git submodule --quiet update --recursive --init',
+  {command: joinCommands('cd vendor/apm', 'npm install --silent .'), options: {ignoreStdout: true}},
+  {command: 'npm install --silent vendor/apm', options: {ignoreStdout: true}},
+  echoNewLine,
+  'node node_modules/atom-package-manager/bin/apm clean',
+  'node node_modules/atom-package-manager/bin/apm install --silent',
+];
 
-(cd vendor/apm && npm install .)
-
-npm install --silent vendor/apm
-./node_modules/.bin/apm install --silent
+process.chdir(path.dirname(__dirname));
+executeCommands(commands, process.exit);

script/bootstrap.cmd

@@ -0,0 +1,6 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\bootstrap" %*
+) ELSE (
+  node  "%~dp0\bootstrap" %*
+)
+

script/build

@@ -1,8 +1,12 @@
-#!/bin/sh
+#!/usr/bin/env node
+var cp = require('./utils/child-process-wrapper.js');
+var path = require('path');
 
-set -e
+process.chdir(path.dirname(__dirname));
 
-cd "$(dirname "$0")/.."
-
-./script/bootstrap
-./node_modules/.bin/grunt "$@"
+cp.safeExec('node script/bootstrap', function() {
+  // node node_modules/grunt-cli/bin/grunt "$@"
+  var gruntPath = path.join('node_modules', 'grunt-cli', 'bin', 'grunt');
+  var args = [gruntPath].concat(process.argv.slice(2));
+  cp.safeSpawn(process.execPath, args, process.exit);
+});

script/build.cmd

@@ -0,0 +1,5 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\build" %*
+) ELSE (
+  node  "%~dp0\build" %*
+)

script/cibuild

@@ -1,11 +1,39 @@
-#!/bin/sh
+#!/usr/bin/env node
+var cp = require('./utils/child-process-wrapper.js');
+var fs = require('fs');
+var path = require('path');
 
-set -e
+process.chdir(path.dirname(__dirname));
 
-cd "$(dirname "$0")/.."
+if (process.platform != 'darwin')
+  throw new Error('cibuild can not run on ' + process.platform + ' yet!');
 
-rm -rf ~/.atom
-git clean -dff
+var homeDir = process.platform == 'win32' ? process.env.USERPROFILE : process.env.HOME;
 
-rm -fr node_modules
-./script/test
+function readEnvironmentVariables() {
+  var credentialsPath = '/var/lib/jenkins/config/atomcredentials';
+  try {
+    var credentials = fs.readFileSync(credentialsPath, 'utf8');
+    var lines = credentials.trim().split('\n');
+    for (i in lines) {
+      var parts = lines[i].split('=');
+      var key = parts[0].trim();
+      var value = parts[1].trim().substr(1, parts[1].length - 2);
+      process.env[key] = value;
+    }
+  } catch(error) { }
+}
+
+readEnvironmentVariables();
+cp.safeExec.bind(global, 'node script/bootstrap', function(error) {
+  if (error)
+    process.exit(1);
+  var async = require('async');
+  async.series([
+    require('rimraf').bind(global, path.join(homeDir, '.atom')),
+    cp.safeExec.bind(global, 'git clean -dff'),
+    cp.safeExec.bind(global, 'node node_modules/grunt-cli/bin/grunt ci --stack --no-color'),
+  ], function(error) {
+    process.exit(error ? 1 : 0);
+  });
+})();

script/constructicon/build

@@ -8,7 +8,7 @@ set -ex
 cd "$(dirname "$0")/../.."
 rm -fr node_modules
 ./script/bootstrap
-./node_modules/.bin/grunt --build-dir="$BUILT_PRODUCTS_DIR" deploy
+./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"

script/test

@@ -1,8 +1,9 @@
-#!/bin/sh
+#!/usr/bin/env node
+var safeExec = require('./utils/child-process-wrapper.js').safeExec;
+var path = require('path');
 
-set -e
+process.chdir(path.dirname(__dirname));
 
-cd "$(dirname "$0")/.."
-
-./script/bootstrap
-./node_modules/.bin/grunt ci --stack --no-color
+safeExec('node script/bootstrap', function() {
+  safeExec('node node_modules/grunt-cli/bin/grunt ci --stack --no-color', process.exit);
+});

script/update-atom-shell

@@ -1,30 +0,0 @@
-#!/bin/bash
-
-cd "$(dirname "${BASH_SOURCE[0]}" )/.."
-
-TARGET=${1:-atom-shell}
-DISTURL="https://gh-contractor-zcbenz.s3.amazonaws.com/atom-shell"
-CURRENT_VERSION=$(cat "${TARGET}/version" 2>&1)
-LATEST_VERSION=$(curl -fsSkL $DISTURL/version)
-
-if [ -z "${LATEST_VERSION}" ] ; then
-  echo "Could determine lastest version of atom-shell" >&2
-  exit 1
-fi
-
-TEMP_DIR=/tmp/atom-cached-atom-shells/${LATEST_VERSION}
-
-if [[ ${LATEST_VERSION} != ${CURRENT_VERSION} ]]; then
-  if [ -d $TEMP_DIR ]; then
-    echo "Using cached version of atom-shell ${LATEST_VERSION} from ${TEMP_DIR}"
-  else
-    echo "Downloading/extracting atom-shell ${LATEST_VERSION}..."
-    mkdir -p $TEMP_DIR
-    curl "${DISTURL}/${LATEST_VERSION}/atom-shell.zip" > "${TEMP_DIR}/atom-shell.zip"
-    unzip -q "${TEMP_DIR}/atom-shell.zip" -d "${TEMP_DIR}"
-    rm "${TEMP_DIR}/atom-shell.zip"
-  fi
-  [ -e "${TARGET}" ] && rm -rf "${TARGET}"
-  cp -R "${TEMP_DIR}" "${TARGET}"
-  echo ${LATEST_VERSION} > "${TARGET}/version"
-fi

script/utils/child-process-wrapper.js

@@ -0,0 +1,43 @@
+var childProcess = require('child_process');
+
+// Exit the process if the command failed and only call the callback if the
+// command succeed, output of the command would also be piped.
+exports.safeExec = function(command, options, callback) {
+  if (!callback) {
+    callback = options;
+    options = {};
+  }
+  if (!options)
+    options = {};
+
+  // This needed to be increased for `apm test` runs that generate many failures
+  // The default is 200KB.
+  options.maxBuffer = 1024 * 1024;
+
+  var child = childProcess.exec(command, options, function(error, stdout, stderr) {
+    if (error)
+      process.exit(error.code || 1);
+    else
+      callback(null);
+  });
+  child.stderr.pipe(process.stderr);
+  if (!options.ignoreStdout)
+    child.stdout.pipe(process.stdout);
+}
+
+// Same with safeExec but call child_process.spawn instead.
+exports.safeSpawn = function(command, args, options, callback) {
+  if (!callback) {
+    callback = options;
+    options = {};
+  }
+  var child = childProcess.spawn(command, args, options);
+  child.stderr.pipe(process.stderr);
+  child.stdout.pipe(process.stdout);
+  child.on('exit', function(code) {
+    if (code != 0)
+      process.exit(code);
+    else
+      callback(null);
+  });
+}

script/utils/compile-main-to-app

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+coffee -c -o /Applications/Atom.app/Contents/Resources/app/src/ src/main.coffee

script/utils/update-octicons

@@ -0,0 +1,32 @@
+#!/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/app/atom-spec.coffee

@@ -1,295 +0,0 @@
-$ = require 'jquery'
-RootView = require 'root-view'
-{$$} = require 'space-pen'
-fsUtils = require 'fs-utils'
-Exec = require('child_process').exec
-path = require 'path'
-
-describe "the `atom` global", ->
-  beforeEach ->
-    window.rootView = new RootView
-
-  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.loadPackage('package-with-activation-events')
-          expect(pack.mainModule).toBeNull()
-          object = deserialize({deserializer: 'Foo', data: 5})
-          expect(pack.mainModule).toBeDefined()
-          expect(object.constructor.name).toBe 'Foo'
-          expect(object.data).toBe 5
-
-    describe ".unloadPackage(name)", ->
-      describe "when the package is active", ->
-        it "throws an error", ->
-          pack = atom.activatePackage('package-with-main')
-          expect(atom.isPackageLoaded(pack.name)).toBeTruthy()
-          expect(atom.isPackageActive(pack.name)).toBeTruthy()
-          expect( -> atom.unloadPackage(pack.name)).toThrow()
-          expect(atom.isPackageLoaded(pack.name)).toBeTruthy()
-          expect(atom.isPackageActive(pack.name)).toBeTruthy()
-
-      describe "when the package is not loaded", ->
-        it "throws an error", ->
-          expect(atom.isPackageLoaded('unloaded')).toBeFalsy()
-          expect( -> atom.unloadPackage('unloaded')).toThrow()
-          expect(atom.isPackageLoaded('unloaded')).toBeFalsy()
-
-      describe "when the package is loaded", ->
-        it "no longers reports it as being loaded", ->
-          pack = atom.loadPackage('package-with-main')
-          expect(atom.isPackageLoaded(pack.name)).toBeTruthy()
-          atom.unloadPackage(pack.name)
-          expect(atom.isPackageLoaded(pack.name)).toBeFalsy()
-
-    describe ".activatePackage(id)", ->
-      describe "atom packages", ->
-        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.activatePackage('package-with-main')
-              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.activatePackage('package-with-index')
-              expect(indexModule.activate).toHaveBeenCalled()
-              expect(pack.mainModule).toBe indexModule
-
-          it "assigns config defaults from the module", ->
-            expect(config.get('package-with-config-defaults.numbers.one')).toBeUndefined()
-            atom.activatePackage('package-with-config-defaults')
-            expect(config.get('package-with-config-defaults.numbers.one')).toBe 1
-            expect(config.get('package-with-config-defaults.numbers.two')).toBe 2
-
-          describe "when the package metadata includes activation events", ->
-            [mainModule, pack] = []
-
-            beforeEach ->
-              mainModule = require 'fixtures/packages/package-with-activation-events/index'
-              spyOn(mainModule, 'activate').andCallThrough()
-              AtomPackage = require 'atom-package'
-              spyOn(AtomPackage.prototype, 'requireMainModule').andCallThrough()
-              pack = atom.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()
-              rootView.trigger 'activation-event'
-              expect(mainModule.activate).toHaveBeenCalled()
-
-            it "triggers the activation event on all handlers registered during activation", ->
-              rootView.open()
-              editor = rootView.getActiveView()
-              eventHandler = jasmine.createSpy("activation-event")
-              editor.command 'activation-event', eventHandler
-              editor.trigger 'activation-event'
-              expect(mainModule.activate.callCount).toBe 1
-              expect(mainModule.activationEventCallCount).toBe 1
-              expect(eventHandler.callCount).toBe 1
-              editor.trigger 'activation-event'
-              expect(mainModule.activationEventCallCount).toBe 2
-              expect(eventHandler.callCount).toBe 2
-              expect(mainModule.activate.callCount).toBe 1
-
-        describe "when the package has no main module", ->
-          it "does not throw an exception", ->
-            spyOn(console, "error")
-            spyOn(console, "warn").andCallThrough()
-            expect(-> atom.activatePackage('package-without-module')).not.toThrow()
-            expect(console.error).not.toHaveBeenCalled()
-            expect(console.warn).not.toHaveBeenCalled()
-
-        it "passes the activate method the package's previously serialized state if it exists", ->
-          pack = atom.activatePackage("package-with-serialization")
-          expect(pack.mainModule.someNumber).not.toBe 77
-          pack.mainModule.someNumber = 77
-          atom.deactivatePackage("package-with-serialization")
-          spyOn(pack.mainModule, 'activate').andCallThrough()
-          atom.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", ->
-          config.set("core.disabledPackages", [])
-          spyOn(console, "warn")
-          expect(-> atom.activatePackage("package-that-throws-an-exception")).not.toThrow()
-          expect(console.warn).toHaveBeenCalled()
-
-        describe "keymap loading", ->
-          describe "when the metadata does not contain a 'keymaps' manifest", ->
-            it "loads all the .cson/.json files in the keymaps directory", ->
-              element1 = $$ -> @div class: 'test-1'
-              element2 = $$ -> @div class: 'test-2'
-              element3 = $$ -> @div class: 'test-3'
-
-              expect(keymap.bindingsForElement(element1)['ctrl-z']).toBeUndefined()
-              expect(keymap.bindingsForElement(element2)['ctrl-z']).toBeUndefined()
-              expect(keymap.bindingsForElement(element3)['ctrl-z']).toBeUndefined()
-
-              atom.activatePackage("package-with-keymaps")
-
-              expect(keymap.bindingsForElement(element1)['ctrl-z']).toBe "test-1"
-              expect(keymap.bindingsForElement(element2)['ctrl-z']).toBe "test-2"
-              expect(keymap.bindingsForElement(element3)['ctrl-z']).toBeUndefined()
-
-          describe "when the metadata contains a 'keymaps' manifest", ->
-            it "loads only the keymaps specified by the manifest, in the specified order", ->
-              element1 = $$ -> @div class: 'test-1'
-              element3 = $$ -> @div class: 'test-3'
-
-              expect(keymap.bindingsForElement(element1)['ctrl-z']).toBeUndefined()
-
-              atom.activatePackage("package-with-keymaps-manifest")
-
-              expect(keymap.bindingsForElement(element1)['ctrl-z']).toBe 'keymap-1'
-              expect(keymap.bindingsForElement(element1)['ctrl-n']).toBe 'keymap-2'
-              expect(keymap.bindingsForElement(element3)['ctrl-y']).toBeUndefined()
-
-        describe "stylesheet loading", ->
-          describe "when the metadata contains a 'stylesheets' manifest", ->
-            it "loads stylesheets from the stylesheets directory as specified by the manifest", ->
-              one = fsUtils.resolveOnLoadPath("fixtures/packages/package-with-stylesheets-manifest/stylesheets/1.css")
-              two = fsUtils.resolveOnLoadPath("fixtures/packages/package-with-stylesheets-manifest/stylesheets/2.less")
-              three = fsUtils.resolveOnLoadPath("fixtures/packages/package-with-stylesheets-manifest/stylesheets/3.css")
-              expect(stylesheetElementForId(one)).not.toExist()
-              expect(stylesheetElementForId(two)).not.toExist()
-              expect(stylesheetElementForId(three)).not.toExist()
-
-              atom.activatePackage("package-with-stylesheets-manifest")
-
-              expect(stylesheetElementForId(one)).toExist()
-              expect(stylesheetElementForId(two)).toExist()
-              expect(stylesheetElementForId(three)).not.toExist()
-              expect($('#jasmine-content').css('font-size')).toBe '1px'
-
-          describe "when the metadata does not contain a 'stylesheets' manifest", ->
-            it "loads all stylesheets from the stylesheets directory", ->
-              one = fsUtils.resolveOnLoadPath("fixtures/packages/package-with-stylesheets/stylesheets/1.css")
-              two = fsUtils.resolveOnLoadPath("fixtures/packages/package-with-stylesheets/stylesheets/2.less")
-              three = fsUtils.resolveOnLoadPath("fixtures/packages/package-with-stylesheets/stylesheets/3.css")
-              expect(stylesheetElementForId(one)).not.toExist()
-              expect(stylesheetElementForId(two)).not.toExist()
-              expect(stylesheetElementForId(three)).not.toExist()
-
-              atom.activatePackage("package-with-stylesheets")
-              expect(stylesheetElementForId(one)).toExist()
-              expect(stylesheetElementForId(two)).toExist()
-              expect(stylesheetElementForId(three)).toExist()
-              expect($('#jasmine-content').css('font-size')).toBe '3px'
-
-        describe "grammar loading", ->
-          it "loads the package's grammars", ->
-            atom.activatePackage('package-with-grammars')
-            expect(syntax.selectGrammar('a.alot').name).toBe 'Alot'
-            expect(syntax.selectGrammar('a.alittle').name).toBe 'Alittle'
-
-        describe "scoped-property loading", ->
-          it "loads the scoped properties", ->
-            atom.activatePackage("package-with-scoped-properties")
-            expect(syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
-
-      describe "textmate packages", ->
-        it "loads the package's grammars", ->
-          expect(syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-          atom.activatePackage('ruby-tmbundle', sync: true)
-          expect(syntax.selectGrammar("file.rb").name).toBe "Ruby"
-
-        it "translates the package's scoped properties to Atom terms", ->
-          expect(syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
-          atom.activatePackage('ruby-tmbundle', sync: true)
-          expect(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(syntax, 'addProperties').andCallThrough()
-
-            atom.activatePackage('package-with-preferences-tmbundle')
-
-            waitsFor ->
-              syntax.addProperties.callCount > 0
-            runs ->
-              expect(syntax.getProperty(['.source.pref'], 'editor.increaseIndentPattern')).toBe '^abc$'
-
-    describe ".activatePackageConfig(id)", ->
-      it "calls the optional .activateConfigMenu method on the package's main module", ->
-        pack = atom.activatePackageConfig('package-with-activate-config')
-        expect(pack.mainModule.activateCalled).toBeFalsy()
-        expect(pack.mainModule.activateConfigCalled).toBeTruthy()
-
-      it "loads the package's config defaults", ->
-        expect(config.get('package-with-config-defaults.numbers.one')).toBeUndefined()
-        atom.activatePackageConfig('package-with-config-defaults')
-        expect(config.get('package-with-config-defaults.numbers.one')).toBe 1
-        expect(config.get('package-with-config-defaults.numbers.two')).toBe 2
-
-    describe ".deactivatePackage(id)", ->
-      describe "atom packages", ->
-        it "calls `deactivate` on the package's main module", ->
-          pack = atom.activatePackage("package-with-deactivate")
-          expect(atom.isPackageActive("package-with-deactivate")).toBeTruthy()
-          spyOn(pack.mainModule, 'deactivate').andCallThrough()
-
-          atom.deactivatePackage("package-with-deactivate")
-          expect(pack.mainModule.deactivate).toHaveBeenCalled()
-          expect(atom.isPackageActive("package-with-module")).toBeFalsy()
-
-        it "absorbs exceptions that are thrown by the package module's serialize methods", ->
-          spyOn(console, 'error')
-          atom.activatePackage('package-with-serialize-error',  immediate: true)
-          atom.activatePackage('package-with-serialization', immediate: true)
-          atom.deactivatePackages()
-          expect(atom.packageStates['package-with-serialize-error']).toBeUndefined()
-          expect(atom.packageStates['package-with-serialization']).toEqual someNumber: 1
-          expect(console.error).toHaveBeenCalled()
-
-        it "removes the package's grammars", ->
-          atom.activatePackage('package-with-grammars')
-          atom.deactivatePackage('package-with-grammars')
-          expect(syntax.selectGrammar('a.alot').name).toBe 'Null Grammar'
-          expect(syntax.selectGrammar('a.alittle').name).toBe 'Null Grammar'
-
-        it "removes the package's keymaps", ->
-          atom.activatePackage('package-with-keymaps')
-          atom.deactivatePackage('package-with-keymaps')
-          expect(keymap.bindingsForElement($$ -> @div class: 'test-1')['ctrl-z']).toBeUndefined()
-          expect(keymap.bindingsForElement($$ -> @div class: 'test-2')['ctrl-z']).toBeUndefined()
-
-        it "removes the package's stylesheets", ->
-          atom.activatePackage('package-with-stylesheets')
-          atom.deactivatePackage('package-with-stylesheets')
-          one = fsUtils.resolveOnLoadPath("package-with-stylesheets/stylesheets/1.css")
-          two = fsUtils.resolveOnLoadPath("package-with-stylesheets/stylesheets/2.less")
-          three = fsUtils.resolveOnLoadPath("package-with-stylesheets/stylesheets/3.css")
-          expect(stylesheetElementForId(one)).not.toExist()
-          expect(stylesheetElementForId(two)).not.toExist()
-          expect(stylesheetElementForId(three)).not.toExist()
-
-        it "removes the package's scoped-properties", ->
-          atom.activatePackage("package-with-scoped-properties")
-          expect(syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBe '^a'
-          atom.deactivatePackage("package-with-scoped-properties")
-          expect(syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBeUndefined()
-
-      describe "texmate packages", ->
-        it "removes the package's grammars", ->
-          expect(syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-          atom.activatePackage('ruby-tmbundle', sync: true)
-          expect(syntax.selectGrammar("file.rb").name).toBe "Ruby"
-          atom.deactivatePackage('ruby-tmbundle')
-          expect(syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-
-        it "removes the package's scoped properties", ->
-          atom.activatePackage('ruby-tmbundle', sync: true)
-          atom.deactivatePackage('ruby-tmbundle')
-          expect(syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
-
-  describe ".getVersion", ->
-    it "returns the current version number", ->
-      expect(typeof atom.getVersion()).toBe 'string'

spec/app/config-panel-spec.coffee

@@ -1,138 +0,0 @@
-ConfigPanel = require 'config-panel'
-Editor = require 'editor'
-
-describe "ConfigPanel", ->
-  it "automatically binds named input fields to their corresponding config keys", ->
-    class TestPanel extends ConfigPanel
-      @content: ->
-        @div =>
-          @input outlet: 'intInput', id: 'foo.int', type: 'int'
-          @input outlet: 'floatInput', id: 'foo.float', type: 'float'
-          @input outlet: 'stringInput', id: 'foo.string', type: 'string'
-          @input outlet: 'booleanInput', id: 'foo.boolean', type: 'checkbox'
-
-    config.set('foo.int', 22)
-    config.set('foo.boolean', true)
-
-    panel = new TestPanel
-    expect(panel.intInput.val()).toBe '22'
-    expect(panel.floatInput.val()).toBe ''
-    expect(panel.stringInput.val()).toBe ''
-    expect(panel.booleanInput.attr('checked')).toBeTruthy()
-
-    config.set('foo.int', 10)
-    expect(panel.intInput.val()).toBe '10'
-    expect(panel.floatInput.val()).toBe ''
-    expect(panel.stringInput.val()).toBe ''
-
-    config.set('foo.string', 'hey')
-    expect(panel.intInput.val()).toBe '10'
-    expect(panel.floatInput.val()).toBe ''
-    expect(panel.stringInput.val()).toBe 'hey'
-
-    config.set('foo.boolean', false)
-    expect(panel.booleanInput.attr('checked')).toBeFalsy()
-
-    panel.intInput.val('90.2').change()
-    expect(config.get('foo.int')).toBe 90
-
-    panel.floatInput.val('90.2').change()
-    expect(config.get('foo.float')).toBe 90.2
-
-    panel.intInput.val('0').change()
-    expect(config.get('foo.int')).toBe 0
-
-    panel.floatInput.val('0').change()
-    expect(config.get('foo.float')).toBe 0
-
-    panel.stringInput.val('moo').change()
-    expect(config.get('foo.string')).toBe 'moo'
-
-    panel.intInput.val('abcd').change()
-    expect(config.get('foo.int')).toBe 'abcd'
-
-    panel.floatInput.val('defg').change()
-    expect(config.get('foo.float')).toBe 'defg'
-
-    panel.intInput.val('').change()
-    expect(config.get('foo.int')).toBe undefined
-    panel.floatInput.val('').change()
-    expect(config.get('foo.float')).toBe undefined
-    panel.stringInput.val('').change()
-    expect(config.get('foo.string')).toBe undefined
-
-  it "automatically binds named editors to their corresponding config keys", ->
-    class TestPanel extends ConfigPanel
-      @content: ->
-        @div =>
-          @subview 'intEditor', new Editor(mini: true, attributes: { id: 'foo.int', type: 'int' })
-          @subview 'floatEditor', new Editor(mini: true, attributes: { id: 'foo.float', type: 'float' })
-          @subview 'stringEditor', new Editor(mini: true, attributes: { id: 'foo.string', type: 'string' })
-
-    config.set('foo.int', 1)
-    config.set('foo.float', 1.1)
-    config.set('foo.string', 'I think therefore I am.')
-    panel = new TestPanel
-    window.advanceClock(10000) # wait for contents-modified to be triggered
-    expect(panel.intEditor.getText()).toBe '1'
-    expect(panel.floatEditor.getText()).toBe '1.1'
-    expect(panel.stringEditor.getText()).toBe 'I think therefore I am.'
-
-    config.set('foo.int', 2)
-    config.set('foo.float', 2.2)
-    config.set('foo.string', 'We are what we think.')
-    expect(panel.intEditor.getText()).toBe '2'
-    expect(panel.floatEditor.getText()).toBe '2.2'
-    expect(panel.stringEditor.getText()).toBe 'We are what we think.'
-
-    panel.intEditor.setText('3')
-    panel.floatEditor.setText('3.3')
-    panel.stringEditor.setText('All limitations are self imposed.')
-    window.advanceClock(10000) # wait for contents-modified to be triggered
-    expect(config.get('foo.int')).toBe 3
-    expect(config.get('foo.float')).toBe 3.3
-    expect(config.get('foo.string')).toBe 'All limitations are self imposed.'
-
-
-    panel.intEditor.setText('not an int')
-    panel.floatEditor.setText('not a float')
-    window.advanceClock(10000) # wait for contents-modified to be triggered
-    expect(config.get('foo.int')).toBe 'not an int'
-    expect(config.get('foo.float')).toBe 'not a float'
-
-    panel.intEditor.setText('')
-    panel.floatEditor.setText('')
-    panel.stringEditor.setText('')
-    window.advanceClock(10000) # wait for contents-modified to be triggered
-    expect(config.get('foo.int')).toBe undefined
-    expect(config.get('foo.float')).toBe undefined
-    expect(config.get('foo.string')).toBe undefined
-
-    panel.intEditor.setText('0')
-    panel.floatEditor.setText('0')
-    window.advanceClock(10000) # wait for contents-modified to be triggered
-    expect(config.get('foo.int')).toBe 0
-    expect(config.get('foo.float')).toBe 0
-
-  it "does not save the config value until it has been changed to a new value", ->
-    class TestPanel extends ConfigPanel
-      @content: ->
-        @div =>
-          @subview "fooInt", new Editor(mini: true, attributes: {id: 'foo.int', type: 'int'})
-
-    config.set('foo.int', 1)
-    observeHandler = jasmine.createSpy("observeHandler")
-    config.observe "foo.int", observeHandler
-    observeHandler.reset()
-
-    testPanel = new TestPanel
-    window.advanceClock(10000) # wait for contents-modified to be triggered
-    expect(observeHandler).not.toHaveBeenCalled()
-
-    testPanel.fooInt.setText("1")
-    window.advanceClock(10000) # wait for contents-modified to be triggered
-    expect(observeHandler).not.toHaveBeenCalled()
-
-    testPanel.fooInt.setText("2")
-    window.advanceClock(10000) # wait for contents-modified to be triggered
-    expect(observeHandler).toHaveBeenCalled()

spec/app/config-spec.coffee

@@ -1,265 +0,0 @@
-fs = require 'fs'
-fsUtils = require 'fs-utils'
-path = require 'path'
-CSON = require 'season'
-
-describe "Config", ->
-  describe ".get(keyPath)", ->
-    it "allows a key path's value to be read", ->
-      expect(config.set("foo.bar.baz", 42)).toBe 42
-      expect(config.get("foo.bar.baz")).toBe 42
-      expect(config.get("bogus.key.path")).toBeUndefined()
-
-    it "returns a deep clone of the key path's value", ->
-      config.set('value', array: [1, b: 2, 3])
-      retrievedValue = config.get('value')
-      retrievedValue.array[0] = 4
-      retrievedValue.array[1].b = 2.1
-      expect(config.get('value')).toEqual(array: [1, b: 2, 3])
-
-  describe ".set(keyPath, value)", ->
-    it "allows a key path's value to be written", ->
-      expect(config.set("foo.bar.baz", 42)).toBe 42
-      expect(config.get("foo.bar.baz")).toBe 42
-
-    it "updates observers and saves when a key path is set", ->
-      observeHandler = jasmine.createSpy "observeHandler"
-      config.observe "foo.bar.baz", observeHandler
-      observeHandler.reset()
-
-      config.set("foo.bar.baz", 42)
-
-      expect(config.save).toHaveBeenCalled()
-      expect(observeHandler).toHaveBeenCalledWith 42
-
-    describe "when the value equals the default value", ->
-      it "does not store the value", ->
-        config.setDefaults("foo", same: 1, changes: 1)
-        expect(config.settings.foo).toBeUndefined()
-        config.set('foo.same', 1)
-        config.set('foo.changes', 2)
-        expect(config.settings.foo).toEqual {changes: 2}
-
-        config.set('foo.changes', 1)
-        expect(config.settings.foo).toEqual {}
-
-  describe ".pushAtKeyPath(keyPath, value)", ->
-    it "pushes the given value to the array at the key path and updates observers", ->
-      config.set("foo.bar.baz", ["a"])
-      observeHandler = jasmine.createSpy "observeHandler"
-      config.observe "foo.bar.baz", observeHandler
-      observeHandler.reset()
-
-      expect(config.pushAtKeyPath("foo.bar.baz", "b")).toBe 2
-      expect(config.get("foo.bar.baz")).toEqual ["a", "b"]
-      expect(observeHandler).toHaveBeenCalledWith config.get("foo.bar.baz")
-
-  describe ".removeAtKeyPath(keyPath, value)", ->
-    it "removes the given value from the array at the key path and updates observers", ->
-      config.set("foo.bar.baz", ["a", "b", "c"])
-      observeHandler = jasmine.createSpy "observeHandler"
-      config.observe "foo.bar.baz", observeHandler
-      observeHandler.reset()
-
-      expect(config.removeAtKeyPath("foo.bar.baz", "b")).toEqual ["a", "c"]
-      expect(config.get("foo.bar.baz")).toEqual ["a", "c"]
-      expect(observeHandler).toHaveBeenCalledWith config.get("foo.bar.baz")
-
-  describe ".getPositiveInt(keyPath, defaultValue)", ->
-    it "returns the proper current or default value", ->
-      config.set('editor.preferredLineLength', 0)
-      expect(config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
-      config.set('editor.preferredLineLength', -1234)
-      expect(config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
-      config.set('editor.preferredLineLength', 'abcd')
-      expect(config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
-      config.set('editor.preferredLineLength', null)
-      expect(config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
-
-  describe ".save()", ->
-    beforeEach ->
-      spyOn(fs, 'writeFileSync')
-      jasmine.unspy config, 'save'
-
-    describe "when ~/.atom/config.json exists", ->
-      it "writes any non-default properties to ~/.atom/config.json", ->
-        config.configFilePath = path.join(config.configDirPath, "config.json")
-        config.set("a.b.c", 1)
-        config.set("a.b.d", 2)
-        config.set("x.y.z", 3)
-        config.setDefaults("a.b", e: 4, f: 5)
-
-        fs.writeFileSync.reset()
-        config.save()
-
-        expect(fs.writeFileSync.argsForCall[0][0]).toBe(path.join(config.configDirPath, "config.json"))
-        writtenConfig = JSON.parse(fs.writeFileSync.argsForCall[0][1])
-        expect(writtenConfig).toEqual config.settings
-
-    describe "when ~/.atom/config.json doesn't exist", ->
-      it "writes any non-default properties to ~/.atom/config.cson", ->
-        config.configFilePath = path.join(config.configDirPath, "config.cson")
-        config.set("a.b.c", 1)
-        config.set("a.b.d", 2)
-        config.set("x.y.z", 3)
-        config.setDefaults("a.b", e: 4, f: 5)
-
-        fs.writeFileSync.reset()
-        config.save()
-
-        expect(fs.writeFileSync.argsForCall[0][0]).toBe(path.join(config.configDirPath, "config.cson"))
-        CoffeeScript = require 'coffee-script'
-        writtenConfig = CoffeeScript.eval(fs.writeFileSync.argsForCall[0][1], bare: true)
-        expect(writtenConfig).toEqual config.settings
-
-  describe ".setDefaults(keyPath, defaults)", ->
-    it "assigns any previously-unassigned keys to the object at the key path", ->
-      config.set("foo.bar.baz", a: 1)
-      config.setDefaults("foo.bar.baz", a: 2, b: 3, c: 4)
-      expect(config.get("foo.bar.baz.a")).toBe 1
-      expect(config.get("foo.bar.baz.b")).toBe 3
-      expect(config.get("foo.bar.baz.c")).toBe 4
-
-      config.setDefaults("foo.quux", x: 0, y: 1)
-      expect(config.get("foo.quux.x")).toBe 0
-      expect(config.get("foo.quux.y")).toBe 1
-
-  describe ".observe(keyPath)", ->
-    observeHandler = null
-
-    beforeEach ->
-      observeHandler = jasmine.createSpy("observeHandler")
-      config.set("foo.bar.baz", "value 1")
-      config.observe "foo.bar.baz", observeHandler
-
-    it "fires the given callback with the current value at the keypath", ->
-      expect(observeHandler).toHaveBeenCalledWith("value 1")
-
-    it "fires the callback every time the observed value changes", ->
-      observeHandler.reset() # clear the initial call
-      config.set('foo.bar.baz', "value 2")
-      expect(observeHandler).toHaveBeenCalledWith("value 2")
-      observeHandler.reset()
-
-      config.set('foo.bar.baz', "value 1")
-      expect(observeHandler).toHaveBeenCalledWith("value 1")
-
-    it "fires the callback when the observed value is deleted", ->
-      observeHandler.reset() # clear the initial call
-      config.set('foo.bar.baz', undefined)
-      expect(observeHandler).toHaveBeenCalledWith(undefined)
-
-    it "fires the callback when the full key path goes into and out of existence", ->
-      observeHandler.reset() # clear the initial call
-      config.set("foo.bar", undefined)
-
-      expect(observeHandler).toHaveBeenCalledWith(undefined)
-      observeHandler.reset()
-
-      config.set("foo.bar.baz", "i'm back")
-      expect(observeHandler).toHaveBeenCalledWith("i'm back")
-
-  describe ".initializeConfigDirectory()", ->
-    beforeEach ->
-      config.configDirPath = '/tmp/dot-atom-dir'
-      expect(fsUtils.exists(config.configDirPath)).toBeFalsy()
-
-    afterEach ->
-      fsUtils.remove('/tmp/dot-atom-dir') if fsUtils.exists('/tmp/dot-atom-dir')
-
-    describe "when the configDirPath doesn't exist", ->
-      it "copies the contents of dot-atom to ~/.atom", ->
-        initializationDone = false
-        jasmine.unspy(window, "setTimeout")
-        config.initializeConfigDirectory ->
-          initializationDone = true
-
-        waitsFor -> initializationDone
-
-        runs ->
-          expect(fsUtils.exists(config.configDirPath)).toBeTruthy()
-          expect(fsUtils.exists(path.join(config.configDirPath, 'packages'))).toBeTruthy()
-          expect(fsUtils.exists(path.join(config.configDirPath, 'snippets'))).toBeTruthy()
-          expect(fsUtils.exists(path.join(config.configDirPath, 'themes'))).toBeTruthy()
-          expect(fsUtils.isFileSync(path.join(config.configDirPath, 'config.cson'))).toBeTruthy()
-
-  describe ".loadUserConfig()", ->
-    beforeEach ->
-      config.configDirPath = '/tmp/dot-atom-dir'
-      config.configFilePath = path.join(config.configDirPath, "config.cson")
-      expect(fsUtils.exists(config.configDirPath)).toBeFalsy()
-
-    afterEach ->
-      fsUtils.remove('/tmp/dot-atom-dir') if fsUtils.exists('/tmp/dot-atom-dir')
-
-    describe "when the config file contains valid cson", ->
-      beforeEach ->
-        fsUtils.writeSync(config.configFilePath, "foo: bar: 'baz'")
-        config.loadUserConfig()
-
-      it "updates the config data based on the file contents", ->
-        expect(config.get("foo.bar")).toBe 'baz'
-
-    describe "when the config file contains invalid cson", ->
-      beforeEach ->
-        spyOn(console, 'error')
-        fsUtils.writeSync(config.configFilePath, "{{{{{")
-
-      it "logs an error to the console and does not overwrite the config file on a subsequent save", ->
-        config.loadUserConfig()
-        expect(console.error).toHaveBeenCalled()
-        config.set("hair", "blonde") # trigger a save
-        expect(config.save).not.toHaveBeenCalled()
-
-    describe "when the config file does not exist", ->
-      it "creates it with an empty object", ->
-        fsUtils.makeTree(config.configDirPath)
-        config.loadUserConfig()
-        expect(fsUtils.exists(config.configFilePath)).toBe true
-        expect(CSON.readFileSync(config.configFilePath)).toEqual {}
-
-  describe ".observeUserConfig()", ->
-    updatedHandler = null
-
-    beforeEach ->
-      config.configDirPath = '/tmp/dot-atom-dir'
-      config.configFilePath = path.join(config.configDirPath, "config.cson")
-      expect(fsUtils.exists(config.configDirPath)).toBeFalsy()
-      fsUtils.writeSync(config.configFilePath, "foo: bar: 'baz'")
-      config.loadUserConfig()
-      config.observeUserConfig()
-      updatedHandler = jasmine.createSpy("updatedHandler")
-      config.on 'updated', updatedHandler
-
-    afterEach ->
-      config.unobserveUserConfig()
-      fsUtils.remove('/tmp/dot-atom-dir') if fsUtils.exists('/tmp/dot-atom-dir')
-
-    describe "when the config file changes to contain valid cson", ->
-      it "updates the config data", ->
-        fsUtils.writeSync(config.configFilePath, "foo: { bar: 'quux', baz: 'bar'}")
-        waitsFor 'update event', -> updatedHandler.callCount > 0
-        runs ->
-          expect(config.get('foo.bar')).toBe 'quux'
-          expect(config.get('foo.baz')).toBe 'bar'
-
-    describe "when the config file changes to contain invalid cson", ->
-      beforeEach ->
-        spyOn(console, 'error')
-        fsUtils.writeSync(config.configFilePath, "}}}")
-        waitsFor "error to be logged", -> console.error.callCount > 0
-
-      it "logs a warning and does not update config data", ->
-        expect(updatedHandler.callCount).toBe 0
-        expect(config.get('foo.bar')).toBe 'baz'
-        config.set("hair", "blonde") # trigger a save
-        expect(config.save).not.toHaveBeenCalled()
-
-      describe "when the config file subsequently changes again to contain valid cson", ->
-        beforeEach ->
-          fsUtils.writeSync(config.configFilePath, "foo: bar: 'baz'")
-          waitsFor 'update event', -> updatedHandler.callCount > 0
-
-        it "updates the config data and resumes saving", ->
-          config.set("hair", "blonde")
-          expect(config.save).toHaveBeenCalled()

spec/app/config-view-spec.coffee

@@ -1,46 +0,0 @@
-ConfigView = require 'config-view'
-{$$} = require 'space-pen'
-
-describe "ConfigView", ->
-  configView = null
-
-  beforeEach ->
-    configView = new ConfigView
-
-  describe "serialization", ->
-    it "remembers which panel was visible", ->
-      configView.showPanel('Editor')
-      newConfigView = deserialize(configView.serialize())
-      configView.remove()
-      newConfigView.attachToDom()
-      expect(newConfigView.activePanelName).toBe 'Editor'
-
-    it "shows the previously active panel if it is added after deserialization", ->
-      configView.addPanel('Panel 1', $$ -> @div id: 'panel-1')
-      configView.showPanel('Panel 1')
-      newConfigView = deserialize(configView.serialize())
-      configView.remove()
-      newConfigView.attachToDom()
-      newConfigView.addPanel('Panel 1', $$ -> @div id: 'panel-1')
-      expect(newConfigView.activePanelName).toBe 'Panel 1'
-
-  describe ".addPanel(name, view)", ->
-    it "adds a menu entry to the left and a panel that can be activated by clicking it", ->
-      configView.addPanel('Panel 1', $$ -> @div id: 'panel-1')
-      configView.addPanel('Panel 2', $$ -> @div id: 'panel-2')
-
-      expect(configView.panelMenu.find('li a:contains(Panel 1)')).toExist()
-      expect(configView.panelMenu.find('li a:contains(Panel 2)')).toExist()
-      expect(configView.panelMenu.children(':first')).toHaveClass 'active'
-
-      configView.attachToDom()
-      configView.panelMenu.find('li a:contains(Panel 1)').click()
-      expect(configView.panelMenu.children('.active').length).toBe 1
-      expect(configView.panelMenu.find('li:contains(Panel 1)')).toHaveClass('active')
-      expect(configView.panels.find('#panel-1')).toBeVisible()
-      expect(configView.panels.find('#panel-2')).toBeHidden()
-      configView.panelMenu.find('li a:contains(Panel 2)').click()
-      expect(configView.panelMenu.children('.active').length).toBe 1
-      expect(configView.panelMenu.find('li:contains(Panel 2)')).toHaveClass('active')
-      expect(configView.panels.find('#panel-1')).toBeHidden()
-      expect(configView.panels.find('#panel-2')).toBeVisible()

spec/app/directory-spec.coffee

@@ -1,110 +0,0 @@
-Directory = require 'directory'
-fsUtils = require 'fs-utils'
-path = require 'path'
-
-describe "Directory", ->
-  directory = null
-
-  beforeEach ->
-    directory = new Directory(fsUtils.resolveOnLoadPath('fixtures'))
-
-  afterEach ->
-    directory.off()
-
-  describe "when the contents of the directory change on disk", ->
-    temporaryFilePath = null
-
-    beforeEach ->
-      temporaryFilePath = path.join(fsUtils.resolveOnLoadPath('fixtures'), 'temporary')
-      fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
-
-    afterEach ->
-      fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
-
-    it "triggers 'contents-changed' event handlers", ->
-      changeHandler = null
-
-      runs ->
-        changeHandler = jasmine.createSpy('changeHandler')
-        directory.on 'contents-changed', changeHandler
-        fsUtils.writeSync(temporaryFilePath, '')
-
-      waitsFor "first change", -> changeHandler.callCount > 0
-
-      runs ->
-        changeHandler.reset()
-        fsUtils.remove(temporaryFilePath)
-
-      waitsFor "second change", -> changeHandler.callCount > 0
-
-  describe "when the directory unsubscribes from events", ->
-    temporaryFilePath = null
-
-    beforeEach ->
-      temporaryFilePath = path.join(directory.path, 'temporary')
-      fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
-
-    afterEach ->
-      fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
-
-    it "no longer triggers events", ->
-      changeHandler = null
-
-      runs ->
-        changeHandler = jasmine.createSpy('changeHandler')
-        directory.on 'contents-changed', changeHandler
-        fsUtils.writeSync(temporaryFilePath, '')
-
-      waitsFor "change event", -> changeHandler.callCount > 0
-
-      runs ->
-        changeHandler.reset()
-        directory.off()
-      waits 20
-
-      runs -> fsUtils.remove(temporaryFilePath)
-      waits 20
-      runs -> expect(changeHandler.callCount).toBe 0
-
-  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)", ->
-    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(fsUtils.resolveOnLoadPath('fixtures'), 'symlink-to-dir')
-      symlinkDirectory = new Directory(symlinkPath)
-      realFilePath = fsUtils.resolveOnLoadPath('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 ".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 true if the path is a child of the directory's symlinked source path", ->
-      symlinkPath = path.join(fsUtils.resolveOnLoadPath('fixtures'), 'symlink-to-dir')
-      symlinkDirectory = new Directory(symlinkPath)
-      realFilePath = fsUtils.resolveOnLoadPath('fixtures/dir/a')
-      expect(symlinkDirectory.contains(realFilePath)).toBe true
-
-    it "returns false if the directory's path is not a prefix of the path", ->
-      expect(directory.contains('/not/relative')).toBe false

spec/app/edit-session-replication-spec.coffee

@@ -1,26 +0,0 @@
-{createSite} = require 'telepath'
-Editor = require 'editor'
-
-describe "EditSession replication", ->
-  [editSession1, editSession2] = []
-  beforeEach ->
-    editSession1 = project.open('sample.js')
-    doc1 = editSession1.getState()
-    doc2 = doc1.clone(createSite(2))
-    doc1.connect(doc2)
-    editSession2 = deserialize(doc2)
-
-  it "replicates the scroll position", ->
-    editor1 = new Editor(editSession1)
-    editor2 = new Editor(editSession2)
-
-    editor1.attachToDom().width(50).height(50)
-    editor2.attachToDom().width(50).height(50)
-
-    editor1.scrollTop(10)
-    expect(editor1.scrollTop()).toBe 10
-    expect(editor2.scrollTop()).toBe 10
-
-    editor2.scrollLeft(20)
-    expect(editor2.scrollLeft()).toBe 20
-    expect(editor1.scrollLeft()).toBe 20

spec/app/event-emitter-spec.coffee

@@ -1,208 +0,0 @@
-_ = require 'underscore'
-EventEmitter = require 'event-emitter'
-
-describe "EventEmitter mixin", ->
-  [object, fooHandler1, fooHandler2, barHandler] = []
-
-  beforeEach ->
-    object = {}
-    _.extend(object, EventEmitter)
-
-    fooHandler1 = jasmine.createSpy('fooHandler1')
-    fooHandler2 = jasmine.createSpy('fooHandler2')
-    barHandler = jasmine.createSpy('barHandler')
-
-    object.on 'foo', fooHandler1
-    object.on 'foo', fooHandler2
-    object.on 'bar', barHandler
-
-  describe ".on", ->
-    describe "when called with multiple space-separated event names", ->
-      it "subscribes to each event names", ->
-        object.on '    a.b  c.d\te ', fooHandler1
-
-        object.trigger 'a'
-        expect(fooHandler1).toHaveBeenCalled()
-
-        fooHandler1.reset()
-        object.trigger 'c'
-        expect(fooHandler1).toHaveBeenCalled()
-
-        fooHandler1.reset()
-        object.trigger 'e'
-        expect(fooHandler1).toHaveBeenCalled()
-
-        fooHandler1.reset()
-        object.trigger ''
-        expect(fooHandler1).not.toHaveBeenCalled()
-
-  describe ".trigger", ->
-    describe "when called with a non-namespaced event name", ->
-      it "triggers all handlers registered for the given event name", ->
-        object.trigger 'foo', 'data'
-        expect(fooHandler1).toHaveBeenCalledWith('data')
-        expect(fooHandler2).toHaveBeenCalledWith('data')
-        expect(barHandler).not.toHaveBeenCalled()
-
-        fooHandler1.reset()
-        fooHandler2.reset()
-
-        object.trigger 'bar', 'stuff'
-        expect(barHandler).toHaveBeenCalledWith('stuff')
-
-    describe "when there are namespaced handlers", ->
-      it "triggers only handlers registered with the given namespace / event combination", ->
-        barHandler2 = jasmine.createSpy('barHandler2')
-        object.on('bar.ns1', barHandler2)
-
-        object.trigger('bar')
-
-        expect(barHandler).toHaveBeenCalled()
-        expect(barHandler2).toHaveBeenCalled()
-        barHandler.reset()
-        barHandler2.reset()
-
-        object.trigger('bar.ns1')
-
-        expect(barHandler).not.toHaveBeenCalled()
-        expect(barHandler2).toHaveBeenCalled()
-
-    it "does not raise exceptions when called with non-existent events / namespaces", ->
-      object.trigger('junk')
-      object.trigger('junk.garbage')
-
-  describe ".off", ->
-    describe "when called with no arguments", ->
-      it "removes all subscriptions", ->
-        object.off()
-        object.trigger 'foo'
-        expect(fooHandler1).not.toHaveBeenCalled()
-        expect(fooHandler2).not.toHaveBeenCalled()
-
-    describe "when called with multiple space-separated event names", ->
-      it "unsubscribes from each event name", ->
-        object.on 'a.b c.d e', fooHandler1
-        object.off ' a.b\te   '
-
-        object.trigger 'a'
-        expect(fooHandler1).not.toHaveBeenCalled()
-
-        fooHandler1.reset()
-        object.trigger 'e'
-        expect(fooHandler1).not.toHaveBeenCalled()
-
-        fooHandler1.reset()
-        object.trigger 'c.d'
-        expect(fooHandler1).toHaveBeenCalled()
-
-    describe "when called with a non-namespaced event name", ->
-      it "removes all handlers for that event name", ->
-        object.off 'foo'
-        object.trigger 'foo'
-        expect(fooHandler1).not.toHaveBeenCalled()
-        expect(fooHandler2).not.toHaveBeenCalled()
-
-    describe "when called with a non-namespaced event name and a handler function", ->
-      it "removes the specific handler", ->
-        object.off 'foo', fooHandler1
-        object.trigger 'foo'
-        expect(fooHandler1).not.toHaveBeenCalled()
-        expect(fooHandler2).toHaveBeenCalled()
-
-      it "does not throw an exception if there was not matching `on` call", ->
-        expect(-> object.off 'marco', -> "nothing").not.toThrow()
-
-    describe "when there are namespaced event handlers", ->
-      [barHandler2, bazHandler1, bazHandler2, bazHandler3] = []
-
-      beforeEach ->
-        barHandler2 = jasmine.createSpy('barHandler2')
-        bazHandler1 = jasmine.createSpy('bazHandler1')
-        bazHandler2 = jasmine.createSpy('bazHandler2')
-        bazHandler3 = jasmine.createSpy('bazHandler3')
-
-        object.on 'bar.ns1', barHandler2
-        object.on 'baz.ns1', bazHandler1
-        object.on 'baz.ns1', bazHandler2
-        object.on 'baz.ns2', bazHandler3
-
-      describe "when called with a namespaced event name", ->
-        it "removes all handlers in that namespace", ->
-          object.trigger 'baz'
-
-          expect(bazHandler1).toHaveBeenCalled()
-          expect(bazHandler2).toHaveBeenCalled()
-          expect(bazHandler3).toHaveBeenCalled()
-
-          bazHandler1.reset()
-          bazHandler2.reset()
-          bazHandler3.reset()
-
-          object.off 'baz.ns1'
-          object.trigger 'baz'
-          object.trigger 'baz.ns1'
-
-          expect(bazHandler1).not.toHaveBeenCalled()
-          expect(bazHandler2).not.toHaveBeenCalled()
-          expect(bazHandler3).toHaveBeenCalled()
-
-      describe "when called with just a namespace", ->
-        it "removes all handlers for all events on that namespace", ->
-          object.trigger 'bar'
-          expect(barHandler).toHaveBeenCalled()
-          expect(barHandler2).toHaveBeenCalled()
-
-          barHandler.reset()
-          barHandler2.reset()
-
-          object.trigger 'baz'
-          expect(bazHandler1).toHaveBeenCalled()
-          expect(bazHandler2).toHaveBeenCalled()
-          expect(bazHandler3).toHaveBeenCalled()
-
-          bazHandler1.reset()
-          bazHandler2.reset()
-          bazHandler3.reset()
-
-          object.off '.ns1'
-
-          object.trigger 'bar'
-          object.trigger 'bar.ns1'
-          expect(barHandler).toHaveBeenCalled()
-          expect(barHandler2).not.toHaveBeenCalled()
-
-          object.trigger 'baz'
-          object.trigger 'baz.ns1'
-
-          expect(bazHandler1).not.toHaveBeenCalled()
-          expect(bazHandler2).not.toHaveBeenCalled()
-          expect(bazHandler3).toHaveBeenCalled()
-
-        describe "when called with event names and namespaces that don't exist", ->
-          it "does not raise an exception", ->
-            object.off 'junk'
-            object.off '.garbage'
-            object.off 'junk.garbage'
-
-
-  describe ".one(event, callback)", ->
-    it "triggers the given callback once, then removes the subscription", ->
-      oneHandler = jasmine.createSpy('oneHandler')
-      object.one 'event', oneHandler
-
-      object.trigger('event')
-      expect(oneHandler).toHaveBeenCalled()
-      oneHandler.reset()
-
-      object.trigger('event')
-      expect(oneHandler).not.toHaveBeenCalled()
-
-  describe ".subscriptionCount()", ->
-    it "returns the total number of subscriptions on the object", ->
-      expect(object.subscriptionCount()).toBe 3
-
-      object.on 'baz', ->
-      expect(object.subscriptionCount()).toBe 4
-
-      object.off 'foo'
-      expect(object.subscriptionCount()).toBe 2

spec/app/file-spec.coffee

@@ -1,121 +0,0 @@
-File = require 'file'
-fsUtils = require 'fs-utils'
-path = require 'path'
-
-describe 'File', ->
-  [filePath, file] = []
-
-  beforeEach ->
-    filePath = path.join(fsUtils.resolveOnLoadPath('fixtures'), "atom-file-test.txt") # Don't put in /tmp because /tmp symlinks to /private/tmp and screws up the rename test
-    fsUtils.remove(filePath) if fsUtils.exists(filePath)
-    fsUtils.writeSync(filePath, "this is old!")
-    file = new File(filePath)
-    file.read()
-
-  afterEach ->
-    file.off()
-    fsUtils.remove(filePath) if fsUtils.exists(filePath)
-
-  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
-      fsUtils.writeSync(file.getPath(), "this is new!")
-
-      waitsFor "change event", ->
-        changeHandler.callCount > 0
-
-      runs ->
-        changeHandler.reset()
-        fsUtils.writeSync(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
-      fsUtils.remove(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 fsUtils.exists(newPath)
-        fsUtils.remove(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
-
-      fsUtils.move(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
-
-      fsUtils.move(filePath, newPath)
-
-      waitsFor "move event", ->
-        moveHandler.callCount > 0
-
-      runs ->
-        expect(changeHandler).not.toHaveBeenCalled()
-        fsUtils.writeSync(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()
-
-      fsUtils.remove(filePath)
-
-      expect(changeHandler).not.toHaveBeenCalled()
-      waits 20
-      runs ->
-        fsUtils.writeSync(filePath, "HE HAS RISEN!")
-        expect(changeHandler).not.toHaveBeenCalled()
-
-      waitsFor "resurrection change event", ->
-        changeHandler.callCount == 1
-
-      runs ->
-        expect(removeHandler).not.toHaveBeenCalled()
-        fsUtils.writeSync(filePath, "Hallelujah!")
-        changeHandler.reset()
-
-      waitsFor "post-resurrection change event", ->
-        changeHandler.callCount > 0

spec/app/git-spec.coffee

@@ -1,206 +0,0 @@
-Git = require 'git'
-fsUtils = require 'fs-utils'
-path = require 'path'
-Task = require 'task'
-
-describe "Git", ->
-  repo = null
-
-  beforeEach ->
-    fsUtils.remove('/tmp/.git') if fsUtils.isDirectorySync('/tmp/.git')
-
-  afterEach ->
-    repo.destroy() if repo?.repo?
-
-  describe "@open(path)", ->
-    it "returns null when no repository is found", ->
-      expect(Git.open('/tmp/nogit.txt')).toBeNull()
-
-  describe "new Git(path)", ->
-    it "throws an exception when no repository is found", ->
-      expect(-> new Git('/tmp/nogit.txt')).toThrow()
-
-  describe ".getPath()", ->
-    it "returns the repository path for a .git directory path", ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/master.git/HEAD'))
-      expect(repo.getPath()).toBe fsUtils.resolveOnLoadPath('fixtures/git/master.git')
-
-    it "returns the repository path for a repository path", ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/master.git'))
-      expect(repo.getPath()).toBe fsUtils.resolveOnLoadPath('fixtures/git/master.git')
-
-  describe ".isPathIgnored(path)", ->
-    it "returns true for an ignored path", ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/ignore.git'))
-      expect(repo.isPathIgnored('a.txt')).toBeTruthy()
-
-    it "returns false for a non-ignored path", ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/ignore.git'))
-      expect(repo.isPathIgnored('b.txt')).toBeFalsy()
-
-  describe ".isPathModified(path)", ->
-    [repo, filePath, newPath, originalPathText] = []
-
-    beforeEach ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
-      filePath = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
-      newPath = path.join(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'), 'new-path.txt')
-      originalPathText = fsUtils.read(filePath)
-
-    afterEach ->
-      fsUtils.writeSync(filePath, originalPathText)
-      fsUtils.remove(newPath) if fsUtils.exists(newPath)
-
-    describe "when the path is unstaged", ->
-      it "returns false if the path has not been modified", ->
-        expect(repo.isPathModified(filePath)).toBeFalsy()
-
-      it "returns true if the path is modified", ->
-        fsUtils.writeSync(filePath, "change")
-        expect(repo.isPathModified(filePath)).toBeTruthy()
-
-      it "returns true if the path is deleted", ->
-        fsUtils.remove(filePath)
-        expect(repo.isPathModified(filePath)).toBeTruthy()
-
-      it "returns false if the path is new", ->
-        expect(repo.isPathModified(newPath)).toBeFalsy()
-
-  describe ".isPathNew(path)", ->
-    [filePath, newPath] = []
-
-    beforeEach ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
-      filePath = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
-      newPath = path.join(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'), 'new-path.txt')
-      fsUtils.writeSync(newPath, "i'm new here")
-
-    afterEach ->
-      fsUtils.remove(newPath) if fsUtils.exists(newPath)
-
-    describe "when the path is unstaged", ->
-      it "returns true if the path is new", ->
-        expect(repo.isPathNew(newPath)).toBeTruthy()
-
-      it "returns false if the path isn't new", ->
-        expect(repo.isPathNew(filePath)).toBeFalsy()
-
-  describe ".checkoutHead(path)", ->
-    [path1, path2, originalPath1Text, originalPath2Text] = []
-
-    beforeEach ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
-      path1 = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
-      originalPath1Text = fsUtils.read(path1)
-      path2 = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/other.txt')
-      originalPath2Text = fsUtils.read(path2)
-
-    afterEach ->
-      fsUtils.writeSync(path1, originalPath1Text)
-      fsUtils.writeSync(path2, originalPath2Text)
-
-    it "no longer reports a path as modified after checkout", ->
-      expect(repo.isPathModified(path1)).toBeFalsy()
-      fsUtils.writeSync(path1, '')
-      expect(repo.isPathModified(path1)).toBeTruthy()
-      expect(repo.checkoutHead(path1)).toBeTruthy()
-      expect(repo.isPathModified(path1)).toBeFalsy()
-
-    it "restores the contents of the path to the original text", ->
-      fsUtils.writeSync(path1, '')
-      expect(repo.checkoutHead(path1)).toBeTruthy()
-      expect(fsUtils.read(path1)).toBe(originalPath1Text)
-
-    it "only restores the path specified", ->
-      fsUtils.writeSync(path2, 'path 2 is edited')
-      expect(repo.isPathModified(path2)).toBeTruthy()
-      expect(repo.checkoutHead(path1)).toBeTruthy()
-      expect(fsUtils.read(path2)).toBe('path 2 is edited')
-      expect(repo.isPathModified(path2)).toBeTruthy()
-
-    it "fires a status-changed event if the checkout completes successfully", ->
-      fsUtils.writeSync(path1, '')
-      repo.getPathStatus(path1)
-      statusHandler = jasmine.createSpy('statusHandler')
-      repo.on 'status-changed', statusHandler
-      repo.checkoutHead(path1)
-      expect(statusHandler.callCount).toBe 1
-      expect(statusHandler.argsForCall[0][0..1]).toEqual [path1, 0]
-
-      repo.checkoutHead(path1)
-      expect(statusHandler.callCount).toBe 1
-
-  describe ".destroy()", ->
-    it "throws an exception when any method is called after it is called", ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/master.git/HEAD'))
-      repo.destroy()
-      expect(-> repo.getShortHead()).toThrow()
-
-  describe ".getDiffStats(path)", ->
-    [filePath, originalPathText] = []
-
-    beforeEach ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
-      filePath = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
-      originalPathText = fsUtils.read(filePath)
-
-    afterEach ->
-      fsUtils.writeSync(filePath, originalPathText)
-
-    it "returns the number of lines added and deleted", ->
-      expect(repo.getDiffStats(filePath)).toEqual {added: 0, deleted: 0}
-      fsUtils.writeSync(filePath, "#{originalPathText} edited line")
-      expect(repo.getDiffStats(filePath)).toEqual {added: 1, deleted: 1}
-
-  describe ".getPathStatus(path)", ->
-    [filePath, originalPathText] = []
-
-    beforeEach ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
-      filePath = fsUtils.resolveOnLoadPath('fixtures/git/working-dir/file.txt')
-      originalPathText = fsUtils.read(filePath)
-
-    afterEach ->
-      fsUtils.writeSync(filePath, originalPathText)
-
-    it "trigger a status-changed event when the new status differs from the last cached one", ->
-      statusHandler = jasmine.createSpy("statusHandler")
-      repo.on 'status-changed', statusHandler
-      fsUtils.writeSync(filePath, '')
-      status = repo.getPathStatus(filePath)
-      expect(statusHandler.callCount).toBe 1
-      expect(statusHandler.argsForCall[0][0..1]).toEqual [filePath, status]
-
-      fsUtils.writeSync(filePath, 'abc')
-      status = repo.getPathStatus(filePath)
-      expect(statusHandler.callCount).toBe 1
-
-  describe ".refreshStatus()", ->
-    [newPath, modifiedPath, cleanPath, originalModifiedPathText] = []
-
-    beforeEach ->
-      repo = new Git(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
-      modifiedPath = project.resolve('git/working-dir/file.txt')
-      originalModifiedPathText = fsUtils.read(modifiedPath)
-      newPath = project.resolve('git/working-dir/untracked.txt')
-      cleanPath = project.resolve('git/working-dir/other.txt')
-      fsUtils.writeSync(newPath, '')
-
-    afterEach ->
-      fsUtils.writeSync(modifiedPath, originalModifiedPathText)
-      fsUtils.remove(newPath) if fsUtils.exists(newPath)
-
-    it "returns status information for all new and modified files", ->
-      fsUtils.writeSync(modifiedPath, 'making this path modified')
-      statusHandler = jasmine.createSpy('statusHandler')
-      repo.on 'statuses-changed', statusHandler
-      repo.refreshStatus()
-
-      waitsFor ->
-        statusHandler.callCount > 0
-
-      runs ->
-        statuses = repo.statuses
-        expect(statuses[cleanPath]).toBeUndefined()
-        expect(repo.isStatusNew(statuses[newPath])).toBeTruthy()
-        expect(repo.isStatusModified(statuses[modifiedPath])).toBeTruthy()

spec/app/language-mode-spec.coffee

@@ -1,160 +0,0 @@
-Project = require 'project'
-Buffer = require 'text-buffer'
-EditSession = require 'edit-session'
-
-describe "LanguageMode", ->
-  [editSession, buffer, languageMode] = []
-
-  afterEach ->
-    editSession.destroy()
-
-  describe "javascript", ->
-    beforeEach ->
-      atom.activatePackage('javascript-tmbundle', sync: true)
-      editSession = project.open('sample.js', autoIndent: false)
-      {buffer, languageMode} = editSession
-
-    describe ".minIndentLevelForRowRange(startRow, endRow)", ->
-      it "returns the minimum indent level for the given row range", ->
-        expect(languageMode.minIndentLevelForRowRange(4, 7)).toBe 2
-        expect(languageMode.minIndentLevelForRowRange(5, 7)).toBe 2
-        expect(languageMode.minIndentLevelForRowRange(5, 6)).toBe 3
-        expect(languageMode.minIndentLevelForRowRange(9, 11)).toBe 1
-        expect(languageMode.minIndentLevelForRowRange(10, 10)).toBe 0
-
-    describe ".toggleLineCommentsForBufferRows(start, end)", ->
-      it "comments/uncomments lines in the given range", ->
-        languageMode.toggleLineCommentsForBufferRows(4, 7)
-        expect(buffer.lineForRow(4)).toBe "    // while(items.length > 0) {"
-        expect(buffer.lineForRow(5)).toBe "    //   current = items.shift();"
-        expect(buffer.lineForRow(6)).toBe "    //   current < pivot ? left.push(current) : right.push(current);"
-        expect(buffer.lineForRow(7)).toBe "    // }"
-
-        languageMode.toggleLineCommentsForBufferRows(4, 5)
-        expect(buffer.lineForRow(4)).toBe "    while(items.length > 0) {"
-        expect(buffer.lineForRow(5)).toBe "      current = items.shift();"
-        expect(buffer.lineForRow(6)).toBe "    //   current < pivot ? left.push(current) : right.push(current);"
-        expect(buffer.lineForRow(7)).toBe "    // }"
-
-    describe "fold suggestion", ->
-      describe ".doesBufferRowStartFold(bufferRow)", ->
-        it "returns true only when the buffer row starts a foldable region", ->
-          expect(languageMode.doesBufferRowStartFold(0)).toBeTruthy()
-          expect(languageMode.doesBufferRowStartFold(1)).toBeTruthy()
-          expect(languageMode.doesBufferRowStartFold(2)).toBeFalsy()
-          expect(languageMode.doesBufferRowStartFold(3)).toBeFalsy()
-
-      describe ".rowRangeForFoldAtBufferRow(bufferRow)", ->
-        it "returns the start/end rows of the foldable region starting at the given row", ->
-          expect(languageMode.rowRangeForFoldAtBufferRow(0)).toEqual [0, 12]
-          expect(languageMode.rowRangeForFoldAtBufferRow(1)).toEqual [1, 9]
-          expect(languageMode.rowRangeForFoldAtBufferRow(2)).toBeNull()
-          expect(languageMode.rowRangeForFoldAtBufferRow(4)).toEqual [4, 7]
-
-    describe "suggestedIndentForBufferRow", ->
-      it "returns the suggested indentation based on auto-indent/outdent rules", ->
-        expect(languageMode.suggestedIndentForBufferRow(0)).toBe 0
-        expect(languageMode.suggestedIndentForBufferRow(1)).toBe 1
-        expect(languageMode.suggestedIndentForBufferRow(2)).toBe 2
-        expect(languageMode.suggestedIndentForBufferRow(9)).toBe 1
-
-  describe "coffeescript", ->
-    beforeEach ->
-      atom.activatePackage('coffee-script-tmbundle', sync: true)
-      editSession = project.open('coffee.coffee', autoIndent: false)
-      {buffer, languageMode} = editSession
-
-    describe ".toggleLineCommentsForBufferRows(start, end)", ->
-      it "comments/uncomments lines in the given range", ->
-        languageMode.toggleLineCommentsForBufferRows(4, 6)
-        expect(buffer.lineForRow(4)).toBe "    # pivot = items.shift()"
-        expect(buffer.lineForRow(5)).toBe "    # left = []"
-        expect(buffer.lineForRow(6)).toBe "    # right = []"
-
-        languageMode.toggleLineCommentsForBufferRows(4, 5)
-        expect(buffer.lineForRow(4)).toBe "    pivot = items.shift()"
-        expect(buffer.lineForRow(5)).toBe "    left = []"
-        expect(buffer.lineForRow(6)).toBe "    # right = []"
-
-      it "comments/uncomments lines when empty line", ->
-        languageMode.toggleLineCommentsForBufferRows(4, 7)
-        expect(buffer.lineForRow(4)).toBe "    # pivot = items.shift()"
-        expect(buffer.lineForRow(5)).toBe "    # left = []"
-        expect(buffer.lineForRow(6)).toBe "    # right = []"
-        expect(buffer.lineForRow(7)).toBe "    # "
-
-        languageMode.toggleLineCommentsForBufferRows(4, 5)
-        expect(buffer.lineForRow(4)).toBe "    pivot = items.shift()"
-        expect(buffer.lineForRow(5)).toBe "    left = []"
-        expect(buffer.lineForRow(6)).toBe "    # right = []"
-        expect(buffer.lineForRow(7)).toBe "    # "
-
-    describe "fold suggestion", ->
-      describe ".doesBufferRowStartFold(bufferRow)", ->
-        it "returns true only when the buffer row starts a foldable region", ->
-          expect(languageMode.doesBufferRowStartFold(0)).toBeTruthy()
-          expect(languageMode.doesBufferRowStartFold(1)).toBeTruthy()
-          expect(languageMode.doesBufferRowStartFold(2)).toBeFalsy()
-          expect(languageMode.doesBufferRowStartFold(3)).toBeFalsy()
-          expect(languageMode.doesBufferRowStartFold(19)).toBeTruthy()
-
-      describe ".rowRangeForFoldAtBufferRow(bufferRow)", ->
-        it "returns the start/end rows of the foldable region starting at the given row", ->
-          expect(languageMode.rowRangeForFoldAtBufferRow(0)).toEqual [0, 20]
-          expect(languageMode.rowRangeForFoldAtBufferRow(1)).toEqual [1, 17]
-          expect(languageMode.rowRangeForFoldAtBufferRow(2)).toBeNull()
-          expect(languageMode.rowRangeForFoldAtBufferRow(19)).toEqual [19, 20]
-
-  describe "css", ->
-    beforeEach ->
-      atom.activatePackage('css-tmbundle', sync: true)
-      editSession = project.open('css.css', autoIndent: false)
-      {buffer, languageMode} = editSession
-
-    describe ".toggleLineCommentsForBufferRows(start, end)", ->
-      it "comments/uncomments lines in the given range", ->
-        languageMode.toggleLineCommentsForBufferRows(0, 1)
-        expect(buffer.lineForRow(0)).toBe "/*body {"
-        expect(buffer.lineForRow(1)).toBe "  font-size: 1234px;*/"
-        expect(buffer.lineForRow(2)).toBe "  width: 110%;"
-        expect(buffer.lineForRow(3)).toBe "  font-weight: bold !important;"
-
-        languageMode.toggleLineCommentsForBufferRows(2, 2)
-        expect(buffer.lineForRow(0)).toBe "/*body {"
-        expect(buffer.lineForRow(1)).toBe "  font-size: 1234px;*/"
-        expect(buffer.lineForRow(2)).toBe "/*  width: 110%;*/"
-        expect(buffer.lineForRow(3)).toBe "  font-weight: bold !important;"
-
-        languageMode.toggleLineCommentsForBufferRows(0, 1)
-        expect(buffer.lineForRow(0)).toBe "body {"
-        expect(buffer.lineForRow(1)).toBe "  font-size: 1234px;"
-        expect(buffer.lineForRow(2)).toBe "/*  width: 110%;*/"
-        expect(buffer.lineForRow(3)).toBe "  font-weight: bold !important;"
-
-      it "uncomments lines with leading whitespace", ->
-        buffer.change([[2, 0], [2, Infinity]], "  /*width: 110%;*/")
-        languageMode.toggleLineCommentsForBufferRows(2, 2)
-        expect(buffer.lineForRow(2)).toBe "  width: 110%;"
-
-      it "uncomments lines with trailing whitespace", ->
-        buffer.change([[2, 0], [2, Infinity]], "/*width: 110%;*/  ")
-        languageMode.toggleLineCommentsForBufferRows(2, 2)
-        expect(buffer.lineForRow(2)).toBe "width: 110%;  "
-
-      it "uncomments lines with leading and trailing whitespace", ->
-        buffer.change([[2, 0], [2, Infinity]], "   /*width: 110%;*/ ")
-        languageMode.toggleLineCommentsForBufferRows(2, 2)
-        expect(buffer.lineForRow(2)).toBe "   width: 110%; "
-
-  describe "less", ->
-    beforeEach ->
-      atom.activatePackage('less-tmbundle', sync: true)
-      atom.activatePackage('css-tmbundle', sync: true)
-      editSession = project.open('sample.less', autoIndent: false)
-      {buffer, languageMode} = editSession
-
-    describe "when commenting lines", ->
-      it "only uses the `commentEnd` pattern if it comes from the same grammar as the `commentStart`", ->
-        languageMode.toggleLineCommentsForBufferRows(0, 0)
-        expect(buffer.lineForRow(0)).toBe "// @color: #4D926F;"
-

spec/app/package-config-panel-spec.coffee

@@ -1,154 +0,0 @@
-PackageConfigPanel = require 'package-config-panel'
-packageManager = require 'package-manager'
-_ = require 'underscore'
-
-describe "PackageConfigPanel", ->
-  [panel, configObserver] = []
-
-  beforeEach ->
-    installedPackages = [
-      {
-        name: 'p1'
-        version: '3.2.1'
-      }
-      {
-        name: 'p2'
-        version: '1.2.3'
-      }
-      {
-        name: 'p3'
-        version: '5.8.5'
-      }
-    ]
-
-    availablePackages = [
-      {
-        name: 'p4'
-        version: '3.2.1'
-        homepage: 'http://p4.io'
-      }
-      {
-        name: 'p5'
-        version: '1.2.3'
-        repository: url: 'http://github.com/atom/p5.git'
-        bugs: url: 'http://github.com/atom/p5/issues'
-      }
-      {
-        name: 'p6'
-        version: '5.8.5'
-      }
-    ]
-
-    spyOn(packageManager, 'getAvailable').andCallFake (callback) ->
-      callback(null, availablePackages)
-    spyOn(packageManager, 'uninstall').andCallFake (pack, callback) ->
-      _.remove(installedPackages, pack)
-      callback()
-    spyOn(packageManager, 'install').andCallFake (pack, callback) ->
-      installedPackages.push(pack)
-      callback()
-
-    spyOn(atom, 'getAvailablePackageMetadata').andReturn(installedPackages)
-    spyOn(atom, 'resolvePackagePath').andCallFake (name) ->
-      if _.contains(_.pluck(installedPackages, 'name'), name)
-        "/tmp/atom-packages/#{name}"
-
-    configObserver = jasmine.createSpy("configObserver")
-    observeSubscription = config.observe('core.disabledPackages', configObserver)
-    config.set('core.disabledPackages', ['p1', 'p3'])
-    configObserver.reset()
-    jasmine.unspy(window, "setTimeout")
-    panel = new PackageConfigPanel
-
-    installedCallback = jasmine.createSpy("installed packages callback")
-    panel.packageEventEmitter.on("installed-packages-loaded", installedCallback)
-    waitsFor -> installedCallback.callCount > 0
-
-  describe 'Installed tab', ->
-    it "lists all installed packages with a link to enable or disable the package", ->
-      p1View = panel.installed.find("[name='p1']").view()
-      expect(p1View).toExist()
-      expect(p1View.enableToggle.find('a').text()).toBe 'Enable'
-
-      p2View = panel.installed.find("[name='p2']").view()
-      expect(p2View).toExist()
-      expect(p2View.enableToggle.find('a').text()).toBe 'Disable'
-
-      p3View = panel.installed.find("[name='p3']").view()
-      expect(p3View).toExist()
-      expect(p3View.enableToggle.find('a').text()).toBe 'Enable'
-
-    describe "when the core.disabledPackages array changes", ->
-      it "updates the checkboxes for newly disabled / enabled packages", ->
-        config.set('core.disabledPackages', ['p2'])
-        p1View = panel.installed.find("[name='p1']").view()
-        expect(p1View.enableToggle.find('a').text()).toBe 'Disable'
-
-        p2View = panel.installed.find("[name='p2']").view()
-        expect(p2View.enableToggle.find('a').text()).toBe 'Enable'
-
-        p3View = panel.installed.find("[name='p3']").view()
-        expect(p3View.enableToggle.find('a').text()).toBe 'Disable'
-
-    describe "when the disable link is clicked", ->
-      it "adds the package name to the disabled packages array", ->
-        p2View = panel.installed.find("[name='p2']").view()
-        p2View.enableToggle.find('a').click()
-        expect(configObserver).toHaveBeenCalledWith(['p1', 'p3', 'p2'])
-
-    describe "when the enable link is clicked", ->
-      it "removes the package name from the disabled packages array", ->
-        p3View = panel.installed.find("[name='p3']").view()
-        p3View.enableToggle.find('a').click()
-        expect(configObserver).toHaveBeenCalledWith(['p1'])
-
-    describe "when Uninstall is clicked", ->
-      it "removes the package from the tab", ->
-        expect(panel.installed.find("[name='p1']")).toExist()
-        p1View = panel.installed.find("[name='p1']").view()
-        expect(p1View.defaultAction.text()).toBe 'Uninstall'
-        p1View.defaultAction.click()
-        expect(panel.installed.find("[name='p1']")).not.toExist()
-
-  describe 'Available tab', ->
-    it 'lists all available packages', ->
-      panel.availableLink.click()
-      panel.attachToDom()
-
-      expect(panel.available.packagesArea.children('.panel').length).toBe 3
-      p4View = panel.available.packagesArea.children('.panel:eq(0)').view()
-      p5View = panel.available.packagesArea.children('.panel:eq(1)').view()
-      p6View = panel.available.packagesArea.children('.panel:eq(2)').view()
-
-      expect(p4View.name.text()).toBe 'p4'
-      expect(p5View.name.text()).toBe 'p5'
-      expect(p6View.name.text()).toBe 'p6'
-
-      expect(p4View.version.text()).toBe '3.2.1'
-      expect(p5View.version.text()).toBe '1.2.3'
-      expect(p6View.version.text()).toBe '5.8.5'
-
-      p4View.dropdownButton.click()
-      expect(p4View.homepage).toBeVisible()
-      expect(p4View.homepage.find('a').attr('href')).toBe 'http://p4.io'
-      expect(p4View.issues).toBeHidden()
-
-      p5View.dropdownButton.click()
-      expect(p5View.homepage).toBeVisible()
-      expect(p5View.homepage.find('a').attr('href')).toBe 'http://github.com/atom/p5'
-      expect(p5View.issues).toBeVisible()
-      expect(p5View.issues.find('a').attr('href')).toBe 'http://github.com/atom/p5/issues'
-
-      p6View.dropdownButton.click()
-      expect(p6View.homepage).toBeHidden()
-      expect(p6View.issues).toBeHidden()
-
-    describe "when Install is clicked", ->
-      it "adds the package to the Installed tab", ->
-        expect(panel.installed.find("[name='p4']")).not.toExist()
-        expect(panel.available.find("[name='p4']")).toExist()
-        p4View = panel.available.find("[name='p4']").view()
-        expect(p4View.defaultAction.text()).toBe 'Install'
-        p4View.defaultAction.click()
-        expect(panel.installed.find("[name='p4']")).toExist()
-        expect(p4View.defaultAction.text()).toBe 'Uninstall'

spec/app/pane-container-replication-spec.coffee

@@ -1,82 +0,0 @@
-{createSite} = require 'telepath'
-{View} = require 'space-pen'
-PaneContainer = require 'pane-container'
-Pane = require 'pane'
-
-describe "PaneContainer replication", ->
-  [container1, container2, pane1a, pane1b, pane1c] = []
-
-  class TestView extends View
-    @deserialize: ({name}) -> new TestView(name)
-    @content: -> @div tabindex: -1
-    initialize: (@name) -> @text(@name)
-    serialize: -> { deserializer: 'TestView', @name }
-    getState: -> @serialize()
-    getUri: -> "/tmp/#{@name}"
-    isEqual: (other) -> @name is other.name
-
-  beforeEach ->
-    registerDeserializer(TestView)
-    container1 = new PaneContainer
-    pane1a = new Pane(new TestView('A'))
-    container1.setRoot(pane1a)
-    pane1b = pane1a.splitRight(new TestView('B'))
-    pane1c = pane1b.splitDown(new TestView('C'))
-
-    doc1 = container1.getState()
-    doc2 = doc1.clone(createSite(2))
-    doc1.connect(doc2)
-    container2 = deserialize(doc2)
-
-  afterEach ->
-    unregisterDeserializer(TestView)
-
-  it "replicates the inital state of a pane container with splits", ->
-    expect(container1.find('.row > :eq(0):contains(A)')).toExist()
-    expect(container1.find('.row > :eq(1)')).toHaveClass 'column'
-    expect(container1.find('.row > :eq(1) > :eq(0):contains(B)')).toExist()
-    expect(container1.find('.row > :eq(1) > :eq(1):contains(C)')).toExist()
-
-    expect(container2.find('.row > :eq(0):contains(A)')).toExist()
-    expect(container2.find('.row > :eq(1)')).toHaveClass 'column'
-    expect(container2.find('.row > :eq(1) > :eq(0):contains(B)')).toExist()
-    expect(container2.find('.row > :eq(1) > :eq(1):contains(C)')).toExist()
-
-  it "replicates the splitting of panes", ->
-    container1.attachToDom().width(400).height(200)
-    container2.attachToDom().width(400).height(200)
-
-    pane1d = pane1a.splitRight(new TestView('D'))
-
-    expect(container1.find('.row > :eq(1):contains(D)')).toExist()
-    expect(container2.find('.row > :eq(1):contains(D)')).toExist()
-
-    expect(container2.find('.row > :eq(1):contains(D)').outerWidth()).toBe container1.find('.row > :eq(1):contains(D)').outerWidth()
-
-    pane1d.splitDown(new TestView('E'))
-
-    expect(container1.find('.row > :eq(1)')).toHaveClass('column')
-    expect(container1.find('.row > :eq(1) > :eq(0):contains(D)')).toExist()
-    expect(container1.find('.row > :eq(1) > :eq(1):contains(E)')).toExist()
-
-    expect(container2.find('.row > :eq(1)')).toHaveClass('column')
-    expect(container2.find('.row > :eq(1) > :eq(0):contains(D)')).toExist()
-    expect(container2.find('.row > :eq(1) > :eq(1):contains(E)')).toExist()
-
-  it "replicates removal of panes", ->
-    pane1c.remove()
-
-    expect(container1.find('.row > :eq(0):contains(A)')).toExist()
-    expect(container1.find('.row > :eq(1):contains(B)')).toExist()
-    expect(container2.find('.row > :eq(0):contains(A)')).toExist()
-    expect(container2.find('.row > :eq(1):contains(B)')).toExist()
-
-    pane1b.remove()
-
-    expect(container1.find('> :eq(0):contains(A)')).toExist()
-    expect(container2.find('> :eq(0):contains(A)')).toExist()
-
-    pane1a.remove()
-
-    expect(container1.children()).not.toExist()
-    expect(container2.children()).not.toExist()

spec/app/pane-container-spec.coffee

@@ -1,192 +0,0 @@
-PaneContainer = require 'pane-container'
-Pane = require 'pane'
-{View, $$} = require 'space-pen'
-_ = require 'underscore'
-$ = require 'jquery'
-
-describe "PaneContainer", ->
-  [TestView, container, pane1, pane2, pane3] = []
-
-  beforeEach ->
-    class TestView extends View
-      registerDeserializer(this)
-      @deserialize: ({name}) -> new TestView(name)
-      @content: -> @div tabindex: -1
-      initialize: (@name) -> @text(@name)
-      serialize: -> { deserializer: 'TestView', @name }
-      getUri: -> "/tmp/#{@name}"
-      save: -> @saved = true
-      isEqual: (other) -> @name is other.name
-
-    container = new PaneContainer
-    pane1 = new Pane(new TestView('1'))
-    container.setRoot(pane1)
-    pane2 = pane1.splitRight(new TestView('2'))
-    pane3 = pane2.splitDown(new TestView('3'))
-
-  afterEach ->
-    unregisterDeserializer(TestView)
-
-  describe ".focusNextPane()", ->
-    it "focuses the pane following the focused pane or the first pane if no pane has focus", ->
-      container.attachToDom()
-      container.focusNextPane()
-      expect(pane1.activeItem).toMatchSelector ':focus'
-      container.focusNextPane()
-      expect(pane2.activeItem).toMatchSelector ':focus'
-      container.focusNextPane()
-      expect(pane3.activeItem).toMatchSelector ':focus'
-      container.focusNextPane()
-      expect(pane1.activeItem).toMatchSelector ':focus'
-
-  describe ".focusPreviousPane()", ->
-    it "focuses the pane preceding the focused pane or the last pane if no pane has focus", ->
-      container.attachToDom()
-      container.focusPreviousPane()
-      expect(pane3.activeItem).toMatchSelector ':focus'
-      container.focusPreviousPane()
-      expect(pane2.activeItem).toMatchSelector ':focus'
-      container.focusPreviousPane()
-      expect(pane1.activeItem).toMatchSelector ':focus'
-      container.focusPreviousPane()
-      expect(pane3.activeItem).toMatchSelector ':focus'
-
-  describe ".getActivePane()", ->
-    it "returns the most-recently focused pane", ->
-      focusStealer = $$ -> @div tabindex: -1, "focus stealer"
-      focusStealer.attachToDom()
-      container.attachToDom()
-
-      pane2.focus()
-      expect(container.getFocusedPane()).toBe pane2
-      expect(container.getActivePane()).toBe pane2
-
-      focusStealer.focus()
-      expect(container.getFocusedPane()).toBeUndefined()
-      expect(container.getActivePane()).toBe pane2
-
-      pane3.focus()
-      expect(container.getFocusedPane()).toBe pane3
-      expect(container.getActivePane()).toBe pane3
-
-      # returns the first pane if none have been set to active
-      container.find('.pane.active').removeClass('active')
-      expect(container.getActivePane()).toBe pane1
-
-  describe ".eachPane(callback)", ->
-    it "runs the callback with all current and future panes until the subscription is cancelled", ->
-      panes = []
-      subscription = container.eachPane (pane) -> panes.push(pane)
-      expect(panes).toEqual [pane1, pane2, pane3]
-
-      panes = []
-      pane4 = pane3.splitRight()
-      expect(panes).toEqual [pane4]
-
-      panes = []
-      subscription.cancel()
-      pane4.splitDown()
-      expect(panes).toEqual []
-
-  describe ".reopenItem()", ->
-    describe "when there is an active pane", ->
-      it "reconstructs and shows the last-closed pane item", ->
-        expect(container.getActivePane()).toBe pane3
-        item3 = pane3.activeItem
-        item4 = new TestView('4')
-        pane3.showItem(item4)
-
-        pane3.destroyItem(item3)
-        pane3.destroyItem(item4)
-        expect(container.getActivePane()).toBe pane1
-
-        expect(container.reopenItem()).toBeTruthy()
-        expect(pane1.activeItem).toEqual item4
-
-        expect(container.reopenItem()).toBeTruthy()
-        expect(pane1.activeItem).toEqual item3
-
-        expect(container.reopenItem()).toBeFalsy()
-        expect(pane1.activeItem).toEqual item3
-
-    describe "when there is no active pane", ->
-      it "attaches a new pane with the reconstructed last pane item and focuses it", ->
-        container.attachToDom()
-        pane1.remove()
-        pane2.remove()
-        item3 = pane3.activeItem
-        pane3.destroyItem(item3)
-        expect(container.getActivePane()).toBeUndefined()
-
-        container.reopenItem()
-
-        expect(container.getActivePane().activeItem).toEqual item3
-        expect(container.getActivePane().activeView).toMatchSelector ':focus'
-
-    it "does not reopen an item that is already open", ->
-      item3 = pane3.activeItem
-      item4 = new TestView('4')
-      pane3.showItem(item4)
-      pane3.destroyItem(item3)
-      pane3.destroyItem(item4)
-
-      expect(container.getActivePane()).toBe pane1
-      pane1.showItem(new TestView('4'))
-
-      expect(container.reopenItem()).toBeTruthy()
-      expect(_.pluck(pane1.getItems(), 'name')).toEqual ['1', '4', '3']
-      expect(pane1.activeItem).toEqual item3
-
-      expect(container.reopenItem()).toBeFalsy()
-      expect(pane1.activeItem).toEqual item3
-
-  describe ".saveAll()", ->
-    it "saves all open pane items", ->
-      pane1.showItem(new TestView('4'))
-
-      container.saveAll()
-
-      for pane in container.getPanes()
-        for item in pane.getItems()
-          expect(item.saved).toBeTruthy()
-
-  describe ".confirmClose()", ->
-    it "returns true after modified files are saved", ->
-      pane1.itemAtIndex(0).isModified = -> true
-      pane2.itemAtIndex(0).isModified = -> true
-      spyOn(atom, "confirmSync").andReturn(0)
-
-      saved = container.confirmClose()
-
-      runs ->
-        expect(saved).toBeTruthy()
-        expect(atom.confirmSync).toHaveBeenCalled()
-
-    it "returns false if the user cancels saving", ->
-      pane1.itemAtIndex(0).isModified = -> true
-      pane2.itemAtIndex(0).isModified = -> true
-      spyOn(atom, "confirmSync").andReturn(1)
-
-      saved = container.confirmClose()
-
-      runs ->
-        expect(saved).toBeFalsy()
-        expect(atom.confirmSync).toHaveBeenCalled()
-
-  describe "serialization", ->
-    it "can be serialized and deserialized, and correctly adjusts dimensions of deserialized panes after attach", ->
-      newContainer = deserialize(container.serialize())
-      expect(newContainer.find('.row > :contains(1)')).toExist()
-      expect(newContainer.find('.row > .column > :contains(2)')).toExist()
-      expect(newContainer.find('.row > .column > :contains(3)')).toExist()
-
-      newContainer.height(200).width(300).attachToDom()
-      expect(newContainer.find('.row > :contains(1)').width()).toBe 150
-      expect(newContainer.find('.row > .column > :contains(2)').height()).toBe 100
-
-    xit "removes empty panes on deserialization", ->
-      # only deserialize pane 1's view successfully
-      TestView.deserialize = ({name}) -> new TestView(name) if name is '1'
-      newContainer = deserialize(container.serialize())
-      expect(newContainer.find('.row, .column')).not.toExist()
-      expect(newContainer.find('> :contains(1)')).toExist()

spec/app/pane-replication-spec.coffee

@@ -1,40 +0,0 @@
-PaneContainer = require 'pane-container'
-Pane = require 'pane'
-{createSite} = require 'telepath'
-
-describe "Pane replication", ->
-  [editSession1a, editSession1b, container1, pane1, doc1] = []
-  [editSession2a, editSession2b, container2, pane2, doc2] = []
-
-  beforeEach ->
-    editSession1a = project.open('sample.js')
-    editSession1b = project.open('sample.txt')
-    container1 = new PaneContainer
-    pane1 = new Pane(editSession1a, editSession1b)
-    container1.setRoot(pane1)
-
-    doc1 = container1.getState()
-    doc2 = doc1.clone(createSite(2))
-    doc1.connect(doc2)
-
-    container2 = deserialize(doc2)
-    pane2 = container2.getRoot()
-
-  it "replicates the initial state of the panes", ->
-    expect(pane2.items).toEqual(pane1.items)
-
-  it "replicates addition and removal of pane items", ->
-    pane1.addItem(project.open('css.css'), 1)
-    expect(pane2.items).toEqual(pane1.items)
-    pane1.removeItemAtIndex(2)
-    expect(pane2.items).toEqual(pane1.items)
-
-  it "replicates the movement of pane items", ->
-    pane1.moveItem(editSession1a, 1)
-    expect(pane2.items).toEqual(pane1.items)
-
-  it "replicates which pane item is active", ->
-    pane1.showNextItem()
-    expect(pane2.activeItem).toEqual pane1.activeItem
-    pane1.showNextItem()
-    expect(pane2.activeItem).toEqual pane1.activeItem

spec/app/pasteboard-spec.coffee

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

spec/app/point-spec.coffee

@@ -1,33 +0,0 @@
-Point = require 'point'
-
-describe "Point", ->
-  describe ".isEqual(value)", ->
-    describe "when given value is a Point", ->
-      it "returns true when the rows and columns match", ->
-        expect(new Point(1,2)).toEqual new Point(1,2)
-        expect(new Point(2,1)).not.toEqual new Point(1,2)
-
-    describe "when given value is an Array", ->
-      it "returns true only when index zero matches row and index one matches column", ->
-        expect(new Point(1,2)).toEqual [1,2]
-        expect(new Point(2,1)).not.toEqual [1,2]
-
-    describe "when one of the points has a row or column that is NaN", ->
-      it "returns false", ->
-        expect(new Point(1, 3)).not.toEqual new Point(NaN, 3)
-        expect(new Point(1, 3)).not.toEqual new Point(1, NaN)
-
-  describe "compare", ->
-    it "returns 1, 0, or -1 based on whether the given point precedes, equals, or follows the receivers location in the buffer", ->
-      expect(new Point(5, 0).compare(new Point(5, 0))).toBe 0
-      expect(new Point(5, 0).compare(new Point(6, 0))).toBe -1
-      expect(new Point(5, 0).compare(new Point(5, 1))).toBe -1
-      expect(new Point(5, 0).compare(new Point(6, 1))).toBe -1
-      expect(new Point(5, 5).compare(new Point(4, 1))).toBe 1
-      expect(new Point(5, 5).compare(new Point(5, 3))).toBe 1
-
-  describe ".translate(other)", ->
-    it "returns a translated point", ->
-      expect(new Point(1,2).translate([2,4])).toEqual [3,6]
-      expect(new Point(1,2).translate([-1])).toEqual [0,2]
-      expect(new Point(1,2).translate([0,-2])).toEqual [1,0]

spec/app/project-spec.coffee

@@ -1,328 +0,0 @@
-Project = require 'project'
-fsUtils = require 'fs-utils'
-path = require 'path'
-_ = require 'underscore'
-BufferedProcess = require 'buffered-process'
-
-describe "Project", ->
-  beforeEach ->
-    project.setPath(project.resolve('dir'))
-
-  describe "when an edit session is destroyed", ->
-    it "removes edit session and calls destroy on buffer (if buffer is not referenced by other edit sessions)", ->
-      editSession = project.open("a")
-      anotherEditSession = project.open("a")
-
-      expect(project.editSessions.length).toBe 2
-      expect(editSession.buffer).toBe anotherEditSession.buffer
-
-      editSession.destroy()
-      expect(project.editSessions.length).toBe 1
-
-      anotherEditSession.destroy()
-      expect(project.editSessions.length).toBe 0
-
-  describe "when an edit session is saved and the project has no path", ->
-    it "sets the project's path to the saved file's parent directory", ->
-      project.setPath(undefined)
-      expect(project.getPath()).toBeUndefined()
-      editSession = project.open()
-      editSession.saveAs('/tmp/atom-test-save-sets-project-path')
-      expect(project.getPath()).toBe '/tmp'
-      fsUtils.remove('/tmp/atom-test-save-sets-project-path')
-
-  describe ".open(path)", ->
-    [fooOpener, barOpener, absolutePath, newBufferHandler, newEditSessionHandler] = []
-    beforeEach ->
-      absolutePath = fsUtils.resolveOnLoadPath('fixtures/dir/a')
-      newBufferHandler = jasmine.createSpy('newBufferHandler')
-      project.on 'buffer-created', newBufferHandler
-      newEditSessionHandler = jasmine.createSpy('newEditSessionHandler')
-      project.on 'edit-session-created', newEditSessionHandler
-
-      fooOpener = (pathToOpen, options) -> { foo: pathToOpen, options } if pathToOpen?.match(/\.foo/)
-      barOpener = (pathToOpen) -> { bar: pathToOpen } if pathToOpen?.match(/^bar:\/\//)
-      Project.registerOpener(fooOpener)
-      Project.registerOpener(barOpener)
-
-    afterEach ->
-      Project.unregisterOpener(fooOpener)
-      Project.unregisterOpener(barOpener)
-
-    describe "when passed a path that doesn't match a custom opener", ->
-      describe "when given an absolute path that hasn't been opened previously", ->
-        it "returns a new edit session for the given path and emits 'buffer-created' and 'edit-session-created' events", ->
-          editSession = project.open(absolutePath)
-          expect(editSession.buffer.getPath()).toBe absolutePath
-          expect(newBufferHandler).toHaveBeenCalledWith editSession.buffer
-          expect(newEditSessionHandler).toHaveBeenCalledWith editSession
-
-      describe "when given a relative path that hasn't been opened previously", ->
-        it "returns a new edit session for the given path (relative to the project root) and emits 'buffer-created' and 'edit-session-created' events", ->
-          editSession = project.open('a')
-          expect(editSession.buffer.getPath()).toBe absolutePath
-          expect(newBufferHandler).toHaveBeenCalledWith editSession.buffer
-          expect(newEditSessionHandler).toHaveBeenCalledWith editSession
-
-      describe "when passed the path to a buffer that has already been opened", ->
-        it "returns a new edit session containing previously opened buffer and emits a 'edit-session-created' event", ->
-          editSession = project.open(absolutePath)
-          newBufferHandler.reset()
-          expect(project.open(absolutePath).buffer).toBe editSession.buffer
-          expect(project.open('a').buffer).toBe editSession.buffer
-          expect(newBufferHandler).not.toHaveBeenCalled()
-          expect(newEditSessionHandler).toHaveBeenCalledWith editSession
-
-      describe "when not passed a path", ->
-        it "returns a new edit session and emits 'buffer-created' and 'edit-session-created' events", ->
-          editSession = project.open()
-          expect(editSession.buffer.getPath()).toBeUndefined()
-          expect(newBufferHandler).toHaveBeenCalledWith(editSession.buffer)
-          expect(newEditSessionHandler).toHaveBeenCalledWith editSession
-
-    describe "when passed a path that matches a custom opener", ->
-      it "returns the resource returned by the custom opener", ->
-        expect(project.open("a.foo", hey: "there")).toEqual { foo: "a.foo", options: {hey: "there"} }
-        expect(project.open("bar://baz")).toEqual { bar: "bar://baz" }
-
-  describe ".bufferForPath(path)", ->
-    describe "when opening a previously opened path", ->
-      it "does not create a new buffer", ->
-        buffer = project.bufferForPath("a").retain()
-        expect(project.bufferForPath("a")).toBe buffer
-
-        alternativeBuffer = project.bufferForPath("b").retain().release()
-        expect(alternativeBuffer).not.toBe buffer
-        buffer.release()
-
-      it "creates a new buffer if the previous buffer was destroyed", ->
-        buffer = project.bufferForPath("a").retain().release()
-        expect(project.bufferForPath("a").retain().release()).not.toBe buffer
-
-  describe ".resolve(uri)", ->
-    describe "when passed an absolute or relative path", ->
-      it "returns an absolute path based on the project's root", ->
-        absolutePath = fsUtils.resolveOnLoadPath('fixtures/dir/a')
-        expect(project.resolve('a')).toBe absolutePath
-        expect(project.resolve(absolutePath + '/../a')).toBe absolutePath
-        expect(project.resolve('a/../a')).toBe absolutePath
-
-    describe "when passed a uri with a scheme", ->
-      it "does not modify uris that begin with a scheme", ->
-        expect(project.resolve('http://zombo.com')).toBe 'http://zombo.com'
-
-  describe ".setPath(path)", ->
-    describe "when path is a file", ->
-      it "sets its path to the files parent directory and updates the root directory", ->
-        project.setPath(fsUtils.resolveOnLoadPath('fixtures/dir/a'))
-        expect(project.getPath()).toEqual fsUtils.resolveOnLoadPath('fixtures/dir')
-        expect(project.getRootDirectory().path).toEqual fsUtils.resolveOnLoadPath('fixtures/dir')
-
-    describe "when path is a directory", ->
-      it "sets its path to the directory and updates the root directory", ->
-        project.setPath(fsUtils.resolveOnLoadPath('fixtures/dir/a-dir'))
-        expect(project.getPath()).toEqual fsUtils.resolveOnLoadPath('fixtures/dir/a-dir')
-        expect(project.getRootDirectory().path).toEqual fsUtils.resolveOnLoadPath('fixtures/dir/a-dir')
-
-    describe "when path is null", ->
-      it "sets its path and root directory to null", ->
-        project.setPath(null)
-        expect(project.getPath()?).toBeFalsy()
-        expect(project.getRootDirectory()?).toBeFalsy()
-
-  describe ".getFilePaths()", ->
-    it "returns file paths using a promise", ->
-      paths = null
-      waitsForPromise ->
-        project.getFilePaths().done (foundPaths) -> paths = foundPaths
-
-      runs ->
-        expect(paths.length).toBeGreaterThan 0
-
-    it "ignores files that return true from atom.ignorePath(path)", ->
-      spyOn(project, 'isPathIgnored').andCallFake (filePath) -> path.basename(filePath).match /a$/
-
-      paths = null
-      waitsForPromise ->
-        project.getFilePaths().done (foundPaths) -> paths = foundPaths
-
-      runs ->
-        expect(paths).not.toContain(project.resolve('a'))
-        expect(paths).toContain(project.resolve('b'))
-
-    describe "when config.core.hideGitIgnoredFiles is true", ->
-      it "ignores files that are present in .gitignore if the project is a git repo", ->
-        config.set "core.hideGitIgnoredFiles", true
-        project.setPath(fsUtils.resolveOnLoadPath('fixtures/git/working-dir'))
-        paths = null
-        waitsForPromise ->
-          project.getFilePaths().done (foundPaths) -> paths = foundPaths
-
-        runs ->
-          expect(paths).not.toContain('ignored.txt')
-
-    describe "ignored file name", ->
-      ignoredFile = null
-
-      beforeEach ->
-        ignoredFile = path.join(fsUtils.resolveOnLoadPath('fixtures/dir'), 'ignored.txt')
-        fsUtils.writeSync(ignoredFile, "")
-
-      afterEach ->
-        fsUtils.remove(ignoredFile)
-
-      it "ignores ignored.txt file", ->
-        paths = null
-        config.pushAtKeyPath("core.ignoredNames", "ignored.txt")
-        waitsForPromise ->
-          project.getFilePaths().done (foundPaths) -> paths = foundPaths
-
-        runs ->
-          expect(paths).not.toContain('ignored.txt')
-
-    describe "ignored folder name", ->
-      ignoredFile = null
-
-      beforeEach ->
-        ignoredFile = path.join(fsUtils.resolveOnLoadPath('fixtures/dir'), 'ignored/ignored.txt')
-        fsUtils.writeSync(ignoredFile, "")
-
-      afterEach ->
-        fsUtils.remove(ignoredFile)
-
-      it "ignores ignored folder", ->
-        paths = null
-        config.get("core.ignoredNames").push("ignored.txt")
-        config.set("core.ignoredNames", config.get("core.ignoredNames"))
-        waitsForPromise ->
-          project.getFilePaths().done (foundPaths) -> paths = foundPaths
-
-        runs ->
-          expect(paths).not.toContain('ignored/ignored.txt')
-
-  describe ".scan(options, callback)", ->
-    describe "when called with a regex", ->
-      it "calls the callback with all regex matches in all files in the project", ->
-        matches = []
-        waitsForPromise ->
-          project.scan /(a)+/, (match) -> matches.push(match)
-
-        runs ->
-          expect(matches[0]).toEqual
-            path: project.resolve('a')
-            match: 'aaa'
-            range: [[0, 0], [0, 3]]
-
-          expect(matches[1]).toEqual
-            path: project.resolve('a')
-            match: 'aa'
-            range: [[1, 3], [1, 5]]
-
-      it "works with with escaped literals (like $ and ^)", ->
-        matches = []
-        waitsForPromise ->
-          project.scan /\$\w+/, (match) -> matches.push(match)
-
-        runs ->
-          expect(matches.length).toBe 1
-
-          expect(matches[0]).toEqual
-            path: project.resolve('a')
-            match: '$bill'
-            range: [[2, 6], [2, 11]]
-
-      it "works on evil filenames", ->
-        project.setPath(fsUtils.resolveOnLoadPath('fixtures/evil-files'))
-        paths = []
-        matches = []
-        waitsForPromise ->
-          project.scan /evil/, (result) ->
-            paths.push(result.path)
-            matches.push(result.match)
-
-        runs ->
-          expect(paths.length).toBe 5
-          matches.forEach (match) -> expect(match).toEqual 'evil'
-          expect(paths[0]).toMatch /a_file_with_utf8.txt$/
-          expect(paths[1]).toMatch /file with spaces.txt$/
-          expect(paths[2]).toMatch /goddam\nnewlines$/m
-          expect(paths[3]).toMatch /quote".txt$/m
-          expect(path.basename(paths[4])).toBe "utfa\u0306.md"
-
-      it "handles breaks in the search subprocess's output following the filename", ->
-        spyOn(BufferedProcess.prototype, 'bufferStream')
-
-        iterator = jasmine.createSpy('iterator')
-        project.scan /a+/, iterator
-
-        stdout = BufferedProcess.prototype.bufferStream.argsForCall[0][1]
-        stdout ":#{fsUtils.resolveOnLoadPath('fixtures/dir/a')}\n"
-        stdout "1;0 3:aaa bbb\n2;3 2:cc aa cc\n"
-
-        expect(iterator.argsForCall[0][0]).toEqual
-          path: project.resolve('a')
-          match: 'aaa'
-          range: [[0, 0], [0, 3]]
-
-        expect(iterator.argsForCall[1][0]).toEqual
-          path: project.resolve('a')
-          match: 'aa'
-          range: [[1, 3], [1, 5]]
-
-      describe "when the core.excludeVcsIgnoredPaths config is truthy", ->
-        [projectPath, ignoredPath] = []
-
-        beforeEach ->
-          projectPath = fsUtils.resolveOnLoadPath('fixtures/git/working-dir')
-          ignoredPath = path.join(projectPath, 'ignored.txt')
-          fsUtils.writeSync(ignoredPath, 'this match should not be included')
-
-        afterEach ->
-          fsUtils.remove(ignoredPath) if fsUtils.exists(ignoredPath)
-
-        it "excludes ignored files", ->
-          project.setPath(projectPath)
-          config.set('core.excludeVcsIgnoredPaths', true)
-          paths = []
-          matches = []
-          waitsForPromise ->
-            project.scan /match/, (result) ->
-              paths.push(result.path)
-              matches.push(result.match)
-
-          runs ->
-            expect(paths.length).toBe 0
-            expect(matches.length).toBe 0
-
-      it "includes files and folders that begin with a '.'", ->
-        projectPath = '/tmp/atom-tests/folder-with-dot-file'
-        filePath = path.join(projectPath, '.text')
-        fsUtils.writeSync(filePath, 'match this')
-        project.setPath(projectPath)
-        paths = []
-        matches = []
-        waitsForPromise ->
-          project.scan /match this/, (result) ->
-            paths.push(result.path)
-            matches.push(result.match)
-
-        runs ->
-          expect(paths.length).toBe 1
-          expect(paths[0]).toBe filePath
-          expect(matches.length).toBe 1
-
-      it "excludes values in core.ignoredNames", ->
-        projectPath = '/tmp/atom-tests/folder-with-dot-git/.git'
-        filePath = path.join(projectPath, 'test.txt')
-        fsUtils.writeSync(filePath, 'match this')
-        project.setPath(projectPath)
-        paths = []
-        matches = []
-        waitsForPromise ->
-          project.scan /match/, (result) ->
-            paths.push(result.path)
-            matches.push(result.match)
-
-        runs ->
-          expect(paths.length).toBe 0
-          expect(matches.length).toBe 0

spec/app/range-spec.coffee

@@ -1,47 +0,0 @@
-Range = require 'range'
-Point = require 'point'
-
-describe "Range", ->
-  describe "constructor", ->
-    it "ensures that @start <= @end", ->
-      range1 = new Range(new Point(0, 1), new Point(0, 4))
-      expect(range1.start).toEqual(row: 0, column: 1)
-
-      range2 = new Range(new Point(1, 4), new Point(0, 1))
-      expect(range2.start).toEqual(row: 0, column: 1)
-
-  describe ".isEmpty()", ->
-    it "returns true if @start equals @end", ->
-      expect(new Range(new Point(1, 1), new Point(1, 1)).isEmpty()).toBeTruthy()
-      expect(new Range(new Point(1, 1), new Point(1, 2)).isEmpty()).toBeFalsy()
-
-  describe ".intersectsWith(otherRange)", ->
-    it "returns true if the ranges intersect or share an endpoint", ->
-      expect(new Range([1, 1], [2, 10]).intersectsWith(new Range([2, 1], [3, 10]))).toBeTruthy()
-      expect(new Range([2, 1], [3, 10]).intersectsWith(new Range([1, 1], [2, 10]))).toBeTruthy()
-      expect(new Range([2, 1], [3, 10]).intersectsWith(new Range([2, 5], [3, 1]))).toBeTruthy()
-      expect(new Range([2, 5], [3, 1]).intersectsWith(new Range([2, 1], [3, 10]))).toBeTruthy()
-      expect(new Range([2, 5], [3, 1]).intersectsWith(new Range([3, 1], [3, 10]))).toBeTruthy()
-      expect(new Range([3, 1], [3, 10]).intersectsWith(new Range([2, 5], [3, 1]))).toBeTruthy()
-      expect(new Range([2, 5], [3, 1]).intersectsWith(new Range([3, 2], [3, 10]))).toBeFalsy()
-      expect(new Range([3, 2], [3, 10]).intersectsWith(new Range([2, 5], [3, 1]))).toBeFalsy()
-
-  describe ".union(otherRange)", ->
-    it "returns the union of the two ranges", ->
-      expect(new Range([1, 1], [2, 10]).union(new Range([2, 1], [3, 10]))).toEqual [[1, 1], [3, 10]]
-      expect(new Range([2, 1], [3, 10]).union(new Range([1, 1], [2, 10]))).toEqual [[1, 1], [3, 10]]
-      expect(new Range([2, 1], [3, 10]).union(new Range([2, 5], [3, 1]))).toEqual [[2, 1], [3, 10]]
-      expect(new Range([2, 5], [3, 1]).union(new Range([2, 1], [3, 10]))).toEqual [[2, 1], [3, 10]]
-
-  describe ".compare(otherRange)", ->
-    it "sorts earlier ranges first, and larger ranges first if both ranges start at the same place", ->
-      expect(new Range([1, 1], [2, 10]).compare(new Range([2, 1], [3, 10]))).toBe -1
-      expect(new Range([2, 1], [3, 10]).compare(new Range([1, 1], [2, 10]))).toBe 1
-      expect(new Range([1, 1], [3, 10]).compare(new Range([1, 1], [2, 10]))).toBe -1
-      expect(new Range([1, 1], [2, 10]).compare(new Range([1, 1], [3, 10]))).toBe 1
-      expect(new Range([1, 1], [3, 10]).compare(new Range([1, 1], [3, 10]))).toBe 0
-
-  describe ".translate(startPoint, endPoint)", ->
-    it "returns a range translates by the specified start and end points", ->
-      expect(new Range([1, 1], [2, 10]).translate([1])).toEqual [[2, 1], [3, 10]]
-      expect(new Range([1, 1], [2, 10]).translate([1,2], [3,4])).toEqual [[2, 3], [5, 14]]

spec/app/root-view-spec.coffee

@@ -1,376 +0,0 @@
-$ = require 'jquery'
-fsUtils = require 'fs-utils'
-path = require 'path'
-Project = require 'project'
-RootView = require 'root-view'
-Buffer = require 'text-buffer'
-Editor = require 'editor'
-Pane = require 'pane'
-{View, $$} = require 'space-pen'
-
-describe "RootView", ->
-  pathToOpen = null
-
-  beforeEach ->
-    project.setPath(project.resolve('dir'))
-    pathToOpen = project.resolve('a')
-    window.rootView = new RootView
-    rootView.enableKeymap()
-    rootView.open(pathToOpen)
-    rootView.focus()
-
-  describe "@deserialize()", ->
-    viewState = null
-
-    describe "when the serialized RootView has an unsaved buffer", ->
-      it "constructs the view with the same panes", ->
-        rootView.attachToDom()
-        rootView.open()
-        editor1 = rootView.getActiveView()
-        buffer = editor1.getBuffer()
-        editor1.splitRight()
-        viewState = rootView.serialize()
-        rootView.remove()
-
-        window.rootView = deserialize(viewState)
-        rootView.attachToDom()
-
-        expect(rootView.getEditors().length).toBe 2
-        expect(rootView.getActiveView().getText()).toBe buffer.getText()
-        expect(rootView.title).toBe "untitled - #{project.getPath()}"
-
-    describe "when there are open editors", ->
-      it "constructs the view with the same panes", ->
-        rootView.attachToDom()
-        pane1 = rootView.getActivePane()
-        pane2 = pane1.splitRight()
-        pane3 = pane2.splitRight()
-        pane4 = pane2.splitDown()
-        pane2.showItem(project.open('b'))
-        pane3.showItem(project.open('../sample.js'))
-        pane3.activeItem.setCursorScreenPosition([2, 4])
-        pane4.showItem(project.open('../sample.txt'))
-        pane4.activeItem.setCursorScreenPosition([0, 2])
-        pane2.focus()
-
-        viewState = rootView.serialize()
-        rootView.remove()
-        window.rootView = deserialize(viewState)
-        rootView.attachToDom()
-
-        expect(rootView.getEditors().length).toBe 4
-        editor1 = rootView.panes.find('.row > .pane .editor:eq(0)').view()
-        editor3 = rootView.panes.find('.row > .pane .editor:eq(1)').view()
-        editor2 = rootView.panes.find('.row > .column > .pane .editor:eq(0)').view()
-        editor4 = rootView.panes.find('.row > .column > .pane .editor:eq(1)').view()
-
-        expect(editor1.getPath()).toBe project.resolve('a')
-        expect(editor2.getPath()).toBe project.resolve('b')
-        expect(editor3.getPath()).toBe project.resolve('../sample.js')
-        expect(editor3.getCursorScreenPosition()).toEqual [2, 4]
-        expect(editor4.getPath()).toBe project.resolve('../sample.txt')
-        expect(editor4.getCursorScreenPosition()).toEqual [0, 2]
-
-        # ensure adjust pane dimensions is called
-        expect(editor1.width()).toBeGreaterThan 0
-        expect(editor2.width()).toBeGreaterThan 0
-        expect(editor3.width()).toBeGreaterThan 0
-        expect(editor4.width()).toBeGreaterThan 0
-
-        # ensure correct editor is focused again
-        expect(editor2.isFocused).toBeTruthy()
-        expect(editor1.isFocused).toBeFalsy()
-        expect(editor3.isFocused).toBeFalsy()
-        expect(editor4.isFocused).toBeFalsy()
-
-        expect(rootView.title).toBe "#{path.basename(editor2.getPath())} - #{project.getPath()}"
-
-    describe "where there are no open editors", ->
-      it "constructs the view with no open editors", ->
-        rootView.getActivePane().remove()
-        expect(rootView.getEditors().length).toBe 0
-
-        viewState = rootView.serialize()
-        rootView.remove()
-        window.rootView = deserialize(viewState)
-
-        rootView.attachToDom()
-        expect(rootView.getEditors().length).toBe 0
-
-  describe "focus", ->
-    describe "when there is an active view", ->
-      it "hands off focus to the active view", ->
-        editor = rootView.getActiveView()
-        editor.isFocused = false
-        rootView.focus()
-        expect(editor.isFocused).toBeTruthy()
-
-    describe "when there is no active view", ->
-      beforeEach ->
-        rootView.getActivePane().remove()
-        expect(rootView.getActiveView()).toBeUndefined()
-        rootView.attachToDom()
-        expect(document.activeElement).toBe document.body
-
-      describe "when are visible focusable elements (with a -1 tabindex)", ->
-        it "passes focus to the first focusable element", ->
-          focusable1 = $$ -> @div "One", id: 'one', tabindex: -1
-          focusable2 = $$ -> @div "Two", id: 'two', tabindex: -1
-          rootView.horizontal.append(focusable1, focusable2)
-          expect(document.activeElement).toBe document.body
-
-          rootView.focus()
-          expect(document.activeElement).toBe focusable1[0]
-
-      describe "when there are no visible focusable elements", ->
-        it "surrenders focus to the body", ->
-          focusable = $$ -> @div "One", id: 'one', tabindex: -1
-          rootView.horizontal.append(focusable)
-          focusable.hide()
-          expect(document.activeElement).toBe document.body
-
-          rootView.focus()
-          expect(document.activeElement).toBe document.body
-
-  describe "keymap wiring", ->
-    commandHandler = null
-    beforeEach ->
-      commandHandler = jasmine.createSpy('commandHandler')
-      rootView.on('foo-command', commandHandler)
-
-      window.keymap.bindKeys('*', 'x': 'foo-command')
-
-    describe "when a keydown event is triggered on the RootView", ->
-      it "triggers matching keybindings for that event", ->
-        event = keydownEvent 'x', target: rootView[0]
-
-        rootView.trigger(event)
-        expect(commandHandler).toHaveBeenCalled()
-
-  describe "window title", ->
-    describe "when the project has no path", ->
-      it "sets the title to 'untitled'", ->
-        project.setPath(undefined)
-        expect(rootView.title).toBe 'untitled'
-
-    describe "when the project has a path", ->
-      beforeEach ->
-        rootView.open('b')
-
-      describe "when there is an active pane item", ->
-        it "sets the title to the pane item's title plus the project path", ->
-          item = rootView.getActivePaneItem()
-          expect(rootView.title).toBe "#{item.getTitle()} - #{project.getPath()}"
-
-      describe "when the title of the active pane item changes", ->
-        it "updates the window title based on the item's new title", ->
-          editSession = rootView.getActivePaneItem()
-          editSession.buffer.setPath('/tmp/hi')
-          expect(rootView.title).toBe "#{editSession.getTitle()} - #{project.getPath()}"
-
-      describe "when the active pane's item changes", ->
-        it "updates the title to the new item's title plus the project path", ->
-          rootView.getActivePane().showNextItem()
-          item = rootView.getActivePaneItem()
-          expect(rootView.title).toBe "#{item.getTitle()} - #{project.getPath()}"
-
-      describe "when the last pane item is removed", ->
-        it "update the title to contain the project's path", ->
-          rootView.getActivePane().remove()
-          expect(rootView.getActivePaneItem()).toBeUndefined()
-          expect(rootView.title).toBe "atom - #{project.getPath()}"
-
-      describe "when an inactive pane's item changes", ->
-        it "does not update the title", ->
-          pane = rootView.getActivePane()
-          pane.splitRight()
-          initialTitle = rootView.title
-          pane.showNextItem()
-          expect(rootView.title).toBe initialTitle
-
-  describe "font size adjustment", ->
-    it "increases/decreases font size when increase/decrease-font-size events are triggered", ->
-      fontSizeBefore = config.get('editor.fontSize')
-      rootView.trigger 'window:increase-font-size'
-      expect(config.get('editor.fontSize')).toBe fontSizeBefore + 1
-      rootView.trigger 'window:increase-font-size'
-      expect(config.get('editor.fontSize')).toBe fontSizeBefore + 2
-      rootView.trigger 'window:decrease-font-size'
-      expect(config.get('editor.fontSize')).toBe fontSizeBefore + 1
-      rootView.trigger 'window:decrease-font-size'
-      expect(config.get('editor.fontSize')).toBe fontSizeBefore
-
-    it "does not allow the font size to be less than 1", ->
-      config.set("editor.fontSize", 1)
-      rootView.trigger 'window:decrease-font-size'
-      expect(config.get('editor.fontSize')).toBe 1
-
-  describe ".open(path, options)", ->
-    describe "when there is no active pane", ->
-      beforeEach ->
-        spyOn(Pane.prototype, 'focus')
-        rootView.getActivePane().remove()
-        expect(rootView.getActivePane()).toBeUndefined()
-
-      describe "when called with no path", ->
-        it "creates a empty edit session as an item on a new pane, and focuses the pane", ->
-          editSession = rootView.open()
-          expect(rootView.getActivePane().activeItem).toBe editSession
-          expect(editSession.getPath()).toBeUndefined()
-          expect(rootView.getActivePane().focus).toHaveBeenCalled()
-
-      describe "when called with a path", ->
-        it "creates an edit session for the given path as an item on a new pane, and focuses the pane", ->
-          editSession = rootView.open('b')
-          expect(rootView.getActivePane().activeItem).toBe editSession
-          expect(editSession.getPath()).toBe fsUtils.resolveOnLoadPath('fixtures/dir/b')
-          expect(rootView.getActivePane().focus).toHaveBeenCalled()
-
-      describe "when the changeFocus option is false", ->
-        it "does not focus the new pane", ->
-          editSession = rootView.open('b', changeFocus: false)
-          expect(rootView.getActivePane().focus).not.toHaveBeenCalled()
-
-    describe "when there is an active pane", ->
-      [activePane, initialItemCount] = []
-      beforeEach ->
-        activePane = rootView.getActivePane()
-        spyOn(activePane, 'focus')
-        initialItemCount = activePane.getItems().length
-
-      describe "when called with no path", ->
-        it "opens an edit session with an empty buffer as an item on the active pane and focuses it", ->
-          editSession = rootView.open()
-          expect(activePane.getItems().length).toBe initialItemCount + 1
-          expect(activePane.activeItem).toBe editSession
-          expect(editSession.getPath()).toBeUndefined()
-          expect(activePane.focus).toHaveBeenCalled()
-
-      describe "when called with a path", ->
-        describe "when the active pane already has an edit session item for the path being opened", ->
-          it "shows the existing edit session on the pane", ->
-            previousEditSession = activePane.activeItem
-
-            editSession = rootView.open('b')
-            expect(activePane.activeItem).toBe editSession
-            expect(editSession).not.toBe previousEditSession
-
-            editSession = rootView.open(previousEditSession.getPath())
-            expect(editSession).toBe previousEditSession
-            expect(activePane.activeItem).toBe editSession
-
-            expect(activePane.focus).toHaveBeenCalled()
-
-        describe "when the active pane does not have an edit session item for the path being opened", ->
-          it "creates a new edit session for the given path in the active editor", ->
-            editSession = rootView.open('b')
-            expect(activePane.items.length).toBe 2
-            expect(activePane.activeItem).toBe editSession
-            expect(activePane.focus).toHaveBeenCalled()
-
-      describe "when the changeFocus option is false", ->
-        it "does not focus the active pane", ->
-          editSession = rootView.open('b', changeFocus: false)
-          expect(activePane.focus).not.toHaveBeenCalled()
-
-  describe "window:toggle-invisibles event", ->
-    it "shows/hides invisibles in all open and future editors", ->
-      rootView.height(200)
-      rootView.attachToDom()
-      rightEditor = rootView.getActiveView()
-      rightEditor.setText(" \t ")
-      leftEditor = rightEditor.splitLeft()
-      expect(rightEditor.find(".line:first").text()).toBe "    "
-      expect(leftEditor.find(".line:first").text()).toBe "    "
-
-      withInvisiblesShowing = "#{rightEditor.invisibles.space}#{rightEditor.invisibles.tab} #{rightEditor.invisibles.space}#{rightEditor.invisibles.eol}"
-
-      rootView.trigger "window:toggle-invisibles"
-      expect(rightEditor.find(".line:first").text()).toBe withInvisiblesShowing
-      expect(leftEditor.find(".line:first").text()).toBe withInvisiblesShowing
-
-      lowerLeftEditor = leftEditor.splitDown()
-      expect(lowerLeftEditor.find(".line:first").text()).toBe withInvisiblesShowing
-
-      rootView.trigger "window:toggle-invisibles"
-      expect(rightEditor.find(".line:first").text()).toBe "    "
-      expect(leftEditor.find(".line:first").text()).toBe "    "
-
-      lowerRightEditor = rightEditor.splitDown()
-      expect(lowerRightEditor.find(".line:first").text()).toBe "    "
-
-  describe ".eachEditor(callback)", ->
-    beforeEach ->
-      rootView.attachToDom()
-
-    it "invokes the callback for existing editor", ->
-      count = 0
-      callbackEditor = null
-      callback = (editor) ->
-        callbackEditor = editor
-        count++
-      rootView.eachEditor(callback)
-      expect(count).toBe 1
-      expect(callbackEditor).toBe rootView.getActiveView()
-
-    it "invokes the callback for new editor", ->
-      count = 0
-      callbackEditor = null
-      callback = (editor) ->
-        callbackEditor = editor
-        count++
-
-      rootView.eachEditor(callback)
-      count = 0
-      callbackEditor = null
-      rootView.getActiveView().splitRight()
-      expect(count).toBe 1
-      expect(callbackEditor).toBe rootView.getActiveView()
-
-    it "returns a subscription that can be disabled", ->
-      count = 0
-      callback = (editor) -> count++
-
-      subscription = rootView.eachEditor(callback)
-      expect(count).toBe 1
-      rootView.getActiveView().splitRight()
-      expect(count).toBe 2
-      subscription.off()
-      rootView.getActiveView().splitRight()
-      expect(count).toBe 2
-
-  describe ".eachBuffer(callback)", ->
-    beforeEach ->
-      rootView.attachToDom()
-
-    it "invokes the callback for existing buffer", ->
-      count = 0
-      callbackBuffer = null
-      callback = (buffer) ->
-        callbackBuffer = buffer
-        count++
-      rootView.eachBuffer(callback)
-      expect(count).toBe 1
-      expect(callbackBuffer).toBe rootView.getActiveView().getBuffer()
-
-    it "invokes the callback for new buffer", ->
-      count = 0
-      callbackBuffer = null
-      callback = (buffer) ->
-        callbackBuffer = buffer
-        count++
-
-      rootView.eachBuffer(callback)
-      count = 0
-      callbackBuffer = null
-      rootView.open(require.resolve('fixtures/sample.txt'))
-      expect(count).toBe 1
-      expect(callbackBuffer).toBe rootView.getActiveView().getBuffer()
-
-  describe "when a 'new-editor' event is triggered", ->
-    it "opens a new untitled editor", ->
-      itemCount = rootView.getActivePane().getItems().length
-      rootView.trigger 'new-editor'
-      expect(rootView.getActivePaneItem().getPath()).toBeUndefined()
-      expect(rootView.getActivePaneItem().getBuffer().fileExists()).toBeFalsy()
-      expect(rootView.getActivePane().getItems().length).toBe itemCount + 1

spec/app/syntax-spec.coffee

@@ -1,115 +0,0 @@
-fsUtils = require 'fs-utils'
-TextMateGrammar = require 'text-mate-grammar'
-
-describe "the `syntax` global", ->
-  beforeEach ->
-    atom.activatePackage('text-tmbundle', sync: true)
-    atom.activatePackage('javascript-tmbundle', sync: true)
-    atom.activatePackage('coffee-script-tmbundle', sync: true)
-    atom.activatePackage('ruby-tmbundle', sync: true)
-
-  describe "serialization", ->
-    it "remembers grammar overrides by path", ->
-      path = '/foo/bar/file.js'
-      expect(syntax.selectGrammar(path).name).not.toBe 'Ruby'
-      syntax.setGrammarOverrideForPath(path, 'source.ruby')
-      syntax2 = deserialize(syntax.serialize())
-      syntax2.addGrammar(grammar) for grammar in syntax.grammars when grammar isnt syntax.nullGrammar
-      expect(syntax2.selectGrammar(path).name).toBe 'Ruby'
-
-  describe ".selectGrammar(filePath)", ->
-    it "can use the filePath to load the correct grammar based on the grammar's filetype", ->
-      atom.activatePackage('git-tmbundle', sync: true)
-
-      expect(syntax.selectGrammar("file.js").name).toBe "JavaScript" # based on extension (.js)
-      expect(syntax.selectGrammar("/tmp/.git/config").name).toBe "Git Config" # based on end of the path (.git/config)
-      expect(syntax.selectGrammar("Rakefile").name).toBe "Ruby" # based on the file's basename (Rakefile)
-      expect(syntax.selectGrammar("curb").name).toBe "Null Grammar"
-      expect(syntax.selectGrammar("/hu.git/config").name).toBe "Null Grammar"
-
-    it "uses the filePath's shebang line if the grammar cannot be determined by the extension or basename", ->
-      filePath = require.resolve("fixtures/shebang")
-      expect(syntax.selectGrammar(filePath).name).toBe "Ruby"
-
-    it "uses the number of newlines in the first line regex to determine the number of lines to test against", ->
-      atom.activatePackage('property-list-tmbundle', sync: true)
-
-      fileContent = "first-line\n<html>"
-      expect(syntax.selectGrammar("dummy.coffee", fileContent).name).toBe "CoffeeScript"
-
-      fileContent = '<?xml version="1.0" encoding="UTF-8"?>'
-      expect(syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Null Grammar"
-
-      fileContent += '\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
-      expect(syntax.selectGrammar("grammar.tmLanguage", fileContent).name).toBe "Property List (XML)"
-
-    it "doesn't read the file when the file contents are specified", ->
-      filePath = require.resolve("fixtures/shebang")
-      filePathContents = fsUtils.read(filePath)
-      spyOn(fsUtils, 'read').andCallThrough()
-      expect(syntax.selectGrammar(filePath, filePathContents).name).toBe "Ruby"
-      expect(fsUtils.read).not.toHaveBeenCalled()
-
-    it "allows the default grammar to be overridden for a path", ->
-      path = '/foo/bar/file.js'
-      expect(syntax.selectGrammar(path).name).not.toBe 'Ruby'
-      syntax.setGrammarOverrideForPath(path, 'source.ruby')
-      expect(syntax.selectGrammar(path).name).toBe 'Ruby'
-      syntax.clearGrammarOverrideForPath(path)
-      expect(syntax.selectGrammar(path).name).not.toBe 'Ruby'
-
-    describe "when multiple grammars have matching fileTypes", ->
-      it "selects the grammar with the longest fileType match", ->
-        grammar1 = new TextMateGrammar
-          name: 'test1'
-          scopeName: 'source1'
-          fileTypes: ['test', 'more.test']
-
-        grammar2 = new TextMateGrammar
-          name: 'test2'
-          scopeName: 'source2'
-          fileTypes: ['test']
-
-        syntax.addGrammar(grammar1)
-        syntax.addGrammar(grammar2)
-
-        expect(syntax.selectGrammar('more.test', '')).toBe grammar1
-
-    describe "when there is no file path", ->
-      it "does not throw an exception (regression)", ->
-        expect(-> syntax.selectGrammar(null, '#!/usr/bin/ruby')).not.toThrow()
-        expect(-> syntax.selectGrammar(null, '')).not.toThrow()
-        expect(-> syntax.selectGrammar(null, null)).not.toThrow()
-
-  describe ".removeGrammar(grammar)", ->
-    it "removes the grammar, so it won't be returned by selectGrammar", ->
-      grammar = syntax.selectGrammar('foo.js')
-      syntax.removeGrammar(grammar)
-      expect(syntax.selectGrammar('foo.js').name).not.toBe grammar.name
-
-  describe ".getProperty(scopeDescriptor)", ->
-    it "returns the property with the most specific scope selector", ->
-      syntax.addProperties(".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
-      syntax.addProperties(".source .string.quoted.double", foo: bar: baz: 22)
-      syntax.addProperties(".source", foo: bar: baz: 11)
-
-      expect(syntax.getProperty([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42
-      expect(syntax.getProperty([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBe 22
-      expect(syntax.getProperty([".source.js", ".variable.assignment.js"], "foo.bar.baz")).toBe 11
-      expect(syntax.getProperty([".text"], "foo.bar.baz")).toBeUndefined()
-
-    it "favors the most recently added properties in the event of a specificity tie", ->
-      syntax.addProperties(".source.coffee .string.quoted.single", foo: bar: baz: 42)
-      syntax.addProperties(".source.coffee .string.quoted.double", foo: bar: baz: 22)
-
-      expect(syntax.getProperty([".source.coffee", ".string.quoted.single"], "foo.bar.baz")).toBe 42
-      expect(syntax.getProperty([".source.coffee", ".string.quoted.single.double"], "foo.bar.baz")).toBe 22
-
-  describe ".removeProperties(name)", ->
-    it "allows properties to be removed by name", ->
-      syntax.addProperties("a", ".source.coffee .string.quoted.double.coffee", foo: bar: baz: 42)
-      syntax.addProperties("b", ".source .string.quoted.double", foo: bar: baz: 22)
-
-      syntax.removeProperties("b")
-      expect(syntax.getProperty([".source.js", ".string.quoted.double.js"], "foo.bar.baz")).toBeUndefined()
-      expect(syntax.getProperty([".source.coffee", ".string.quoted.double.coffee"], "foo.bar.baz")).toBe 42

spec/app/text-mate-scope-selector-spec.coffee

@@ -1,46 +0,0 @@
-TextMateScopeSelector = require 'text-mate-scope-selector'
-
-describe "TextMateScopeSelector", ->
-  it "matches the asterix", ->
-    expect(new TextMateScopeSelector('*').matches(['a'])).toBeTruthy()
-    expect(new TextMateScopeSelector('*').matches(['b', 'c'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a.*.c').matches(['a.b.c'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a.*.c').matches(['a.b.c.d'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a.*.c').matches(['a.b.d.c'])).toBeFalsy()
-
-  it "matches prefixes", ->
-    expect(new TextMateScopeSelector('a').matches(['a'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a').matches(['a.b'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a').matches(['abc'])).toBeFalsy()
-
-  it "matches disjunction", ->
-    expect(new TextMateScopeSelector('a | b').matches(['b'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a|b|c').matches(['c'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a|b|c').matches(['d'])).toBeFalsy()
-
-  it "matches negation", ->
-    expect(new TextMateScopeSelector('a - c').matches(['a', 'b'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a-b').matches(['a', 'b'])).toBeFalsy()
-
-  it "matches conjunction", ->
-    expect(new TextMateScopeSelector('a & b').matches(['b', 'a'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a&b&c').matches(['c'])).toBeFalsy()
-    expect(new TextMateScopeSelector('a&b&c').matches(['a', 'b', 'd'])).toBeFalsy()
-
-  it "matches composites", ->
-    expect(new TextMateScopeSelector('a,b,c').matches(['b', 'c'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a, b, c').matches(['d', 'e'])).toBeFalsy()
-    expect(new TextMateScopeSelector('a, b, c').matches(['d', 'c.e'])).toBeTruthy()
-
-  it "matches groups", ->
-    expect(new TextMateScopeSelector('(a,b) | (c, d)').matches(['a'])).toBeTruthy()
-    expect(new TextMateScopeSelector('(a,b) | (c, d)').matches(['b'])).toBeTruthy()
-    expect(new TextMateScopeSelector('(a,b) | (c, d)').matches(['c'])).toBeTruthy()
-    expect(new TextMateScopeSelector('(a,b) | (c, d)').matches(['d'])).toBeTruthy()
-    expect(new TextMateScopeSelector('(a,b) | (c, d)').matches(['e'])).toBeFalsy()
-
-  it "matches paths", ->
-    expect(new TextMateScopeSelector('a b').matches(['a', 'b'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a b').matches(['b', 'a'])).toBeFalsy()
-    expect(new TextMateScopeSelector('a c').matches(['a', 'b', 'c', 'd', 'e'])).toBeTruthy()
-    expect(new TextMateScopeSelector('a b e').matches(['a', 'b', 'c', 'd', 'e'])).toBeTruthy()

spec/app/text-mate-theme-spec.coffee

@@ -1,54 +0,0 @@
-fsUtils = require 'fs-utils'
-path = require 'path'
-plist = require 'plist'
-TextMateTheme = require 'text-mate-theme'
-Theme = require 'theme'
-
-describe "TextMateTheme", ->
-  [theme, themePath] = []
-
-  beforeEach ->
-    themePath = fsUtils.resolveOnLoadPath(path.join('fixtures', 'test.tmTheme'))
-    theme = Theme.load(themePath)
-
-  afterEach ->
-    theme.deactivate()
-
-  describe ".getRulesets()", ->
-    rulesets = null
-
-    beforeEach ->
-      rulesets = theme.getRulesets()
-
-    it "returns rulesets representing the theme's global style settings", ->
-      expect(rulesets[0]).toEqual
-        selector: '.editor, .editor .gutter'
-        properties:
-          'background-color': '#141414'
-          'color': '#F8F8F8'
-
-      expect(rulesets[1]).toEqual
-        selector: '.editor.is-focused .cursor'
-        properties:
-          'border-color': '#A7A7A7'
-
-      expect(rulesets[2]).toEqual
-        selector: '.editor.is-focused .selection .region'
-        properties:
-          'background-color': "rgba(221, 240, 255, 0.2)"
-
-    it "returns an array of objects representing the theme's scope selectors", ->
-      expect(rulesets[12]).toEqual
-        comment: "Invalid – Deprecated"
-        selector: ".invalid.deprecated"
-        properties:
-          'color': "#D2A8A1"
-          'font-style': 'italic'
-          'text-decoration': 'underline'
-
-      expect(rulesets[13]).toEqual
-        comment: "Invalid – Illegal"
-        selector: ".invalid.illegal"
-        properties:
-          'color': "#F8F8F8"
-          'background-color': 'rgba(86, 45, 86, 0.75)'

spec/app/theme-config-panel-spec.coffee

@@ -1,49 +0,0 @@
-$ = require 'jquery'
-ThemeConfigPanel = require 'theme-config-panel'
-
-describe "ThemeConfigPanel", ->
-  panel = null
-
-  beforeEach ->
-    config.set('core.themes', ['atom-dark-ui', 'atom-dark-syntax'])
-    panel = new ThemeConfigPanel
-
-  describe "when an enabled theme is reloced in the themes list", ->
-    it "updates the 'core.themes' config key to reflect the new order", ->
-      li = panel.enabledThemes.children(':first').detach()
-      panel.enabledThemes.append(li)
-      panel.enabledThemes.sortable('option', 'update')()
-      expect(config.get('core.themes')).toEqual ['atom-dark-syntax', 'atom-dark-ui']
-
-  describe "when a theme is dragged into the enabled themes list", ->
-    it "updates the 'core.themes' config key to reflect the themes in the enabled list", ->
-      dragHelper = panel.availableThemes.find("li[name='atom-light-ui']").clone()
-      panel.enabledThemes.prepend(dragHelper)
-      panel.enabledThemes.sortable('option', 'receive')(null, helper: dragHelper[0])
-      panel.enabledThemes.sortable('option', 'update')()
-      expect(config.get('core.themes')).toEqual ['atom-light-ui', 'atom-dark-ui', 'atom-dark-syntax']
-
-    describe "when the theme is already present in the enabled list", ->
-      it "removes the previous instance of the theme, updating the order based on the location of drag", ->
-        dragHelper = panel.availableThemes.find("li[name='atom-dark-ui']").clone()
-        panel.enabledThemes.append(dragHelper)
-        panel.enabledThemes.sortable('option', 'receive')(null, helper: dragHelper[0])
-        panel.enabledThemes.sortable('option', 'update')()
-        expect(config.get('core.themes')).toEqual ['atom-dark-syntax', 'atom-dark-ui']
-
-        dragHelper = panel.availableThemes.find("li[name='atom-dark-ui']").clone()
-        panel.enabledThemes.prepend(dragHelper)
-        panel.enabledThemes.sortable('option', 'receive')(null, helper: dragHelper[0])
-        panel.enabledThemes.sortable('option', 'update')()
-        expect(config.get('core.themes')).toEqual ['atom-dark-ui', 'atom-dark-syntax']
-
-  describe "when the disable icon is clicked on a theme li", ->
-    it "removes the theme from the list and the 'core.themes' array", ->
-      panel.enabledThemes.find('li:first .disable-theme').click()
-      expect(panel.getEnabledThemeNames()).toEqual ['atom-dark-syntax']
-      expect(config.get('core.themes')).toEqual ['atom-dark-syntax']
-
-  describe "when the 'core.config' key is updated", ->
-    it "refreshes the enabled themes list", ->
-      config.set('core.themes', ['atom-light-ui', 'atom-light-syntax'])
-      expect(panel.getEnabledThemeNames()).toEqual ['atom-light-ui', 'atom-light-syntax']

spec/app/theme-spec.coffee

@@ -1,59 +0,0 @@
-$ = require 'jquery'
-fsUtils = require 'fs-utils'
-path = require 'path'
-Theme = require 'theme'
-
-describe "@load(name)", ->
-  theme = null
-
-  beforeEach ->
-    $("#jasmine-content").append $("<div class='editor'></div>")
-
-  afterEach ->
-    theme.deactivate()
-
-  describe "TextMateTheme", ->
-    it "applies the theme's stylesheet to the current window", ->
-      expect($(".editor").css("background-color")).not.toBe("rgb(20, 20, 20)")
-
-      themePath = fsUtils.resolveOnLoadPath(path.join('fixtures', 'test.tmTheme'))
-      theme = Theme.load(themePath)
-      expect($(".editor").css("background-color")).toBe("rgb(20, 20, 20)")
-
-  describe "AtomTheme", ->
-    describe "when the theme is a file", ->
-      it "loads and applies css", ->
-        expect($(".editor").css("padding-bottom")).not.toBe "1234px"
-        themePath = project.resolve('themes/theme-stylesheet.css')
-        theme = Theme.load(themePath)
-        expect($(".editor").css("padding-top")).toBe "1234px"
-
-      it "parses, loads and applies less", ->
-        expect($(".editor").css("padding-bottom")).not.toBe "1234px"
-        themePath = project.resolve('themes/theme-stylesheet.less')
-        theme = Theme.load(themePath)
-        expect($(".editor").css("padding-top")).toBe "4321px"
-
-    describe "when the theme contains a package.json file", ->
-      it "loads and applies stylesheets from package.json in the correct order", ->
-        expect($(".editor").css("padding-top")).not.toBe("101px")
-        expect($(".editor").css("padding-right")).not.toBe("102px")
-        expect($(".editor").css("padding-bottom")).not.toBe("103px")
-
-        themePath = project.resolve('themes/theme-with-package-file')
-        theme = Theme.load(themePath)
-        expect($(".editor").css("padding-top")).toBe("101px")
-        expect($(".editor").css("padding-right")).toBe("102px")
-        expect($(".editor").css("padding-bottom")).toBe("103px")
-
-    describe "when the theme does not contain a package.json file and is a directory", ->
-      it "loads all stylesheet files in the directory", ->
-        expect($(".editor").css("padding-top")).not.toBe "10px"
-        expect($(".editor").css("padding-right")).not.toBe "20px"
-        expect($(".editor").css("padding-bottom")).not.toBe "30px"
-
-        themePath = project.resolve('themes/theme-without-package-file')
-        theme = Theme.load(themePath)
-        expect($(".editor").css("padding-top")).toBe "10px"
-        expect($(".editor").css("padding-right")).toBe "20px"
-        expect($(".editor").css("padding-bottom")).toBe "30px"

spec/app/undo-manager-spec.coffee

@@ -1,163 +0,0 @@
-UndoManager = require 'undo-manager'
-Buffer = require 'text-buffer'
-Range = require 'range'
-
-describe "UndoManager", ->
-  [buffer, undoManager] = []
-
-  beforeEach ->
-    buffer = new Buffer(require.resolve('fixtures/sample.js'))
-    undoManager = buffer.undoManager
-
-  afterEach ->
-    buffer.destroy()
-
-  describe ".undo()", ->
-    it "undoes the last change", ->
-      buffer.change(new Range([0, 5], [0, 9]), '')
-      buffer.insert([0, 6], 'h')
-      buffer.insert([0, 10], 'y')
-      expect(buffer.lineForRow(0)).toContain 'qshorty'
-
-      undoManager.undo()
-      expect(buffer.lineForRow(0)).toContain 'qshort'
-      expect(buffer.lineForRow(0)).not.toContain 'qshorty'
-
-      undoManager.undo()
-      expect(buffer.lineForRow(0)).toContain 'qsort'
-
-      undoManager.undo()
-      expect(buffer.lineForRow(0)).toContain 'quicksort'
-
-    it "does not throw an exception when there is nothing to undo", ->
-      undoManager.undo()
-
-  describe ".redo()", ->
-    beforeEach ->
-      buffer.change(new Range([0, 5], [0, 9]), '')
-      buffer.insert([0, 6], 'h')
-      buffer.insert([0, 10], 'y')
-      undoManager.undo()
-      undoManager.undo()
-      expect(buffer.lineForRow(0)).toContain 'qsort'
-
-    it "redoes the last undone change", ->
-      undoManager.redo()
-      expect(buffer.lineForRow(0)).toContain 'qshort'
-
-      undoManager.redo()
-      expect(buffer.lineForRow(0)).toContain 'qshorty'
-
-      undoManager.undo()
-      expect(buffer.lineForRow(0)).toContain 'qshort'
-
-    it "does not throw an exception when there is nothing to redo", ->
-      undoManager.redo()
-      undoManager.redo()
-      undoManager.redo()
-
-    it "discards the redo history when there is a new change following an undo", ->
-      buffer.insert([0, 6], 'p')
-      expect(buffer.getText()).toContain 'qsport'
-
-      undoManager.redo()
-      expect(buffer.getText()).toContain 'qsport'
-
-  describe "transaction methods", ->
-    describe "transact()", ->
-      beforeEach ->
-        buffer.setText('')
-
-      it "starts a transaction that can be committed later", ->
-        buffer.append('1')
-        undoManager.transact()
-        buffer.append('2')
-        buffer.append('3')
-        undoManager.commit()
-        buffer.append('4')
-
-        expect(buffer.getText()).toBe '1234'
-        undoManager.undo()
-        expect(buffer.getText()).toBe '123'
-        undoManager.undo()
-        expect(buffer.getText()).toBe '1'
-        undoManager.redo()
-        expect(buffer.getText()).toBe '123'
-
-      it "starts a transaction that can be aborted later", ->
-        buffer.append('1')
-        buffer.append('2')
-
-        undoManager.transact()
-
-        buffer.append('3')
-        buffer.append('4')
-        expect(buffer.getText()).toBe '1234'
-
-        undoManager.abort()
-        expect(buffer.getText()).toBe '12'
-
-        undoManager.undo()
-        expect(buffer.getText()).toBe '1'
-
-        undoManager.redo()
-        expect(buffer.getText()).toBe '12'
-
-        undoManager.redo()
-        expect(buffer.getText()).toBe '12'
-
-    describe "commit", ->
-      it "throws an exception if there is no current transaction", ->
-        expect(-> buffer.commit()).toThrow()
-
-      it "does not record empty transactions", ->
-        buffer.insert([0,0], "foo")
-        undoManager.transact()
-        undoManager.commit()
-        undoManager.undo()
-        expect(buffer.lineForRow(0)).not.toContain("foo")
-
-    describe "abort", ->
-      it "does not affect the undo stack when the current transaction is empty", ->
-        buffer.setText('')
-        buffer.append('1')
-        buffer.transact()
-        buffer.abort()
-        expect(buffer.getText()).toBe '1'
-        buffer.undo()
-        expect(buffer.getText()).toBe ''
-
-      it "throws an exception if there is no current transaction", ->
-        expect(-> buffer.abort()).toThrow()
-
-  describe "exception handling", ->
-    describe "when a `do` operation throws an exception", ->
-      it "clears the stack", ->
-        spyOn(console, 'error')
-        buffer.setText("word")
-        buffer.insert([0,0], "1")
-        expect(->
-          undoManager.pushOperation(do: -> throw new Error("I'm a bad do operation"))
-        ).toThrow("I'm a bad do operation")
-
-        undoManager.undo()
-        expect(buffer.lineForRow(0)).toBe "1word"
-
-    describe "when an `undo` operation throws an exception", ->
-      it "clears the stack", ->
-        spyOn(console, 'error')
-        buffer.setText("word")
-        buffer.insert([0,0], "1")
-        undoManager.pushOperation(undo: -> throw new Error("I'm a bad undo operation"))
-        expect(-> undoManager.undo()).toThrow("I'm a bad undo operation")
-        expect(buffer.lineForRow(0)).toBe "1word"
-
-    describe "when an `redo` operation throws an exception", ->
-      it "clears the stack", ->
-        spyOn(console, 'error')
-        buffer.setText("word")
-        buffer.insert([0,0], "1")
-        undoManager.pushOperation(redo: -> throw new Error("I'm a bad redo operation"))
-        undoManager.undo()
-        expect(-> undoManager.redo()).toThrow("I'm a bad redo operation")
-        expect(buffer.lineForRow(0)).toBe "1word"

spec/atom-package-spec.coffee

@@ -0,0 +1,76 @@
+{$} = require 'atom'
+path = require 'path'
+Package = require '../src/package'
+
+describe "AtomPackage", ->
+  describe "theme", ->
+    theme = null
+
+    beforeEach ->
+      $("#jasmine-content").append $("<div class='editor'></div>")
+
+    afterEach ->
+      theme.deactivate() if theme?
+
+    describe "when the theme contains a single style file", ->
+      it "loads and applies css", ->
+        expect($(".editor").css("padding-bottom")).not.toBe "1234px"
+        themePath = atom.project.resolve('packages/theme-with-index-css')
+        theme = Package.load(themePath)
+        theme.activate()
+        expect($(".editor").css("padding-top")).toBe "1234px"
+
+      it "parses, loads and applies less", ->
+        expect($(".editor").css("padding-bottom")).not.toBe "1234px"
+        themePath = atom.project.resolve('packages/theme-with-index-less')
+        theme = Package.load(themePath)
+        theme.activate()
+        expect($(".editor").css("padding-top")).toBe "4321px"
+
+    describe "when the theme contains a package.json file", ->
+      it "loads and applies stylesheets from package.json in the correct order", ->
+        expect($(".editor").css("padding-top")).not.toBe("101px")
+        expect($(".editor").css("padding-right")).not.toBe("102px")
+        expect($(".editor").css("padding-bottom")).not.toBe("103px")
+
+        themePath = atom.project.resolve('packages/theme-with-package-file')
+        theme = Package.load(themePath)
+        theme.activate()
+        expect($(".editor").css("padding-top")).toBe("101px")
+        expect($(".editor").css("padding-right")).toBe("102px")
+        expect($(".editor").css("padding-bottom")).toBe("103px")
+
+    describe "when the theme does not contain a package.json file and is a directory", ->
+      it "loads all stylesheet files in the directory", ->
+        expect($(".editor").css("padding-top")).not.toBe "10px"
+        expect($(".editor").css("padding-right")).not.toBe "20px"
+        expect($(".editor").css("padding-bottom")).not.toBe "30px"
+
+        themePath = atom.project.resolve('packages/theme-without-package-file')
+        theme = Package.load(themePath)
+        theme.activate()
+        expect($(".editor").css("padding-top")).toBe "10px"
+        expect($(".editor").css("padding-right")).toBe "20px"
+        expect($(".editor").css("padding-bottom")).toBe "30px"
+
+    describe "reloading a theme", ->
+      beforeEach ->
+        themePath = atom.project.resolve('packages/theme-with-package-file')
+        theme = Package.load(themePath)
+        theme.activate()
+
+      it "reloads without readding to the stylesheets list", ->
+        expect(theme.getStylesheetPaths().length).toBe 3
+        theme.reloadStylesheet(theme.getStylesheetPaths()[0])
+        expect(theme.getStylesheetPaths().length).toBe 3
+
+    describe "events", ->
+      beforeEach ->
+        themePath = atom.project.resolve('packages/theme-with-package-file')
+        theme = Package.load(themePath)
+        theme.activate()
+
+      it "deactivated event fires on .deactivate()", ->
+        theme.on 'deactivated', spy = jasmine.createSpy()
+        theme.deactivate()
+        expect(spy).toHaveBeenCalled()

spec/atom-protocol-handler-spec.coffee

@@ -0,0 +1,15 @@
+{$} = require 'atom'
+
+describe '"atom" protocol URL', ->
+  it 'sends the file relative in the package as response', ->
+    called = false
+    callback = -> called = true
+    $.ajax
+      url: 'atom://async/package.json'
+      success: callback
+      # In old versions of jQuery, ajax calls to custom protocol would always
+      # be treated as error eventhough the browser thinks it's a success
+      # request.
+      error: callback
+
+    waitsFor 'request to be done', -> called is true

spec/atom-reporter.coffee

@@ -1,13 +1,12 @@
-$ = require 'jquery'
-{View, $$} = require 'space-pen'
-_ = require 'underscore'
+{View, $, $$} = require '../src/space-pen-extensions'
+_ = require 'underscore-plus'
 {convertStackTrace} = require 'coffeestack'
 
 sourceMaps = {}
 formatStackTrace = (stackTrace) ->
   return stackTrace unless stackTrace
 
-  jasminePath = require.resolve('jasmine')
+  jasminePath = require.resolve('../vendor/jasmine')
   jasminePattern = new RegExp("\\(#{_.escapeRegExp(jasminePath)}:\\d+:\\d+\\)\\s*$")
   convertedLines = []
   for line in stackTrace.split('\n')
@@ -21,7 +20,15 @@ class AtomReporter extends View
     @div id: 'HTMLReporter', class: 'jasmine_reporter', =>
       @div outlet: 'specPopup', class: "spec-popup"
       @div outlet: "suites"
-      @ul outlet: "symbolSummary", class: 'symbolSummary list-unstyled'
+      @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: "time", class: 'time'
         @div outlet: "specCount", class: 'spec-count'
@@ -46,6 +53,7 @@ class AtomReporter extends View
     $(document.body).append this
 
   reportRunnerResults: (runner) ->
+    @updateSpecCounts()
     if @failedCount == 0
       @message.text "Success!"
     else
@@ -83,7 +91,7 @@ class AtomReporter extends View
 
       clearTimeout @timeoutId if @timeoutId?
       @specPopup.show()
-      spec = _.find(window.timedSpecs, (spec) -> description is spec.name)
+      spec = _.find(window.timedSpecs, ({fullName}) -> description is fullName)
       description = "#{description} #{spec.time}ms" if spec
       @specPopup.text description
       {left, top} = element.offset()
@@ -99,15 +107,18 @@ class AtomReporter extends View
       if specFailures.is(":visible") then element.text "\uf03d" else element.html "\uf03f"
       false
 
-  updateStatusView: (spec) ->
-    if @failedCount > 0
-      @status.addClass('failed') unless @status.hasClass('failed')
-
+  updateSpecCounts: ->
     if @skippedCount
       specCount = "#{@completeSpecCount - @skippedCount}/#{@totalSpecCount - @skippedCount} (#{@skippedCount} skipped)"
     else
       specCount = "#{@completeSpecCount}/#{@totalSpecCount}"
-    @specCount.text specCount
+    @specCount[0].textContent = specCount
+
+  updateStatusView: (spec) ->
+    if @failedCount > 0
+      @status.addClass('failed') unless @status.hasClass('failed')
+
+    @updateSpecCounts()
 
     rootSuite = spec.suite
     rootSuite = rootSuite.parentSuite while rootSuite.parentSuite
@@ -115,18 +126,43 @@ class AtomReporter extends View
 
     time = "#{Math.round((spec.endedAt - @startedAt.getTime()) / 10)}"
     time = "0#{time}" if time.length < 3
-    @time.text "#{time[0...-2]}.#{time[-2..]}s"
+    @time[0].textContent = "#{time[0...-2]}.#{time[-2..]}s"
 
   addSpecs: (specs) ->
+    coreSpecs = 0
+    bundledPackageSpecs = 0
+    userPackageSpecs = 0
     for spec in specs
-      symbol = $$ -> @li class: "spec-summary pending spec-summary-#{spec.id}"
-      @symbolSummary.append symbol
+      symbol = $$ -> @li id: "spec-summary-#{spec.id}", class: "spec-summary pending"
+      switch spec.specType
+        when 'core'
+          coreSpecs++
+          @coreSummary.append symbol
+        when 'bundled'
+          bundledPackageSpecs++
+          @bundledSummary.append symbol
+        when 'user'
+          userPackageSpecs++
+          @userSummary.append symbol
+
+    if coreSpecs > 0
+      @coreHeader.text("Core Specs (#{coreSpecs}):")
+    else
+      @coreArea.hide()
+    if bundledPackageSpecs > 0
+      @bundledHeader.text("Bundled Package Specs (#{bundledPackageSpecs}):")
+    else
+      @bundledArea.hide()
+    if userPackageSpecs > 0
+      @userHeader.text("User Package Specs (#{userPackageSpecs}):")
+    else
+      @userArea.hide()
 
   specStarted: (spec) ->
     @runningSpecCount++
 
   specComplete: (spec) ->
-    specSummaryElement = $(".spec-summary-#{spec.id}")
+    specSummaryElement = $("#spec-summary-#{spec.id}")
     specSummaryElement.removeClass('pending')
     specSummaryElement.data("description", spec.getFullName())
 
@@ -152,7 +188,7 @@ class SuiteResultView extends View
   suite: null
 
   initialize: (@suite) ->
-    @addClass("suite-view-#{@suite.id}")
+    @attr('id', "suite-view-#{@suite.id}")
     @description.html @suite.description
 
   attach: ->
@@ -161,7 +197,7 @@ class SuiteResultView extends View
   parentSuiteView: ->
     return unless @suite.parentSuite
 
-    if not suiteView = $(".suite-view-#{@suite.parentSuite.id}").view()
+    if not suiteView = $("#suite-view-#{@suite.parentSuite.id}").view()
       suiteView = new SuiteResultView(@suite.parentSuite)
       suiteView.attach()
 
@@ -189,7 +225,7 @@ class SpecResultView extends View
     @parentSuiteView().append this
 
   parentSuiteView: ->
-    if not suiteView = $(".suite-view-#{@spec.suite.id}").view()
+    if not suiteView = $("#suite-view-#{@spec.suite.id}").view()
       suiteView = new SuiteResultView(@spec.suite)
       suiteView.attach()
 

spec/atom-spec.coffee

@@ -0,0 +1,440 @@
+{$, $$, fs, RootView}  = require 'atom'
+Exec = require('child_process').exec
+path = require 'path'
+ThemeManager = require '../src/theme-manager'
+
+describe "the `atom` global", ->
+  beforeEach ->
+    atom.rootView = new RootView
+
+  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 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()
+
+      describe "when the package is not loaded", ->
+        it "throws an error", ->
+          expect(atom.packages.isPackageLoaded('unloaded')).toBeFalsy()
+          expect( -> atom.packages.unloadPackage('unloaded')).toThrow()
+          expect(atom.packages.isPackageLoaded('unloaded')).toBeFalsy()
+
+      describe "when the package is loaded", ->
+        it "no longers reports it as being loaded", ->
+          pack = atom.packages.loadPackage('package-with-main')
+          expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
+          atom.packages.unloadPackage(pack.name)
+          expect(atom.packages.isPackageLoaded(pack.name)).toBeFalsy()
+
+    describe ".activatePackage(id)", ->
+      describe "atom packages", ->
+        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
+
+          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
+
+          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
+
+          describe "when the package metadata includes activation events", ->
+            [mainModule, pack] = []
+
+            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')
+
+            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()
+              atom.rootView.trigger 'activation-event'
+              expect(mainModule.activate).toHaveBeenCalled()
+
+            it "triggers the activation event on all handlers registered during activation", ->
+              atom.rootView.openSync()
+              editorView = atom.rootView.getActiveView()
+              eventHandler = jasmine.createSpy("activation-event")
+              editorView.command 'activation-event', eventHandler
+              editorView.trigger 'activation-event'
+              expect(mainModule.activate.callCount).toBe 1
+              expect(mainModule.activationEventCallCount).toBe 1
+              expect(eventHandler.callCount).toBe 1
+              editorView.trigger 'activation-event'
+              expect(mainModule.activationEventCallCount).toBe 2
+              expect(eventHandler.callCount).toBe 2
+              expect(mainModule.activate.callCount).toBe 1
+
+        describe "when the package has no main module", ->
+          it "does not throw an exception", ->
+            spyOn(console, "error")
+            spyOn(console, "warn").andCallThrough()
+            expect(-> atom.packages.activatePackage('package-without-module')).not.toThrow()
+            expect(console.error).not.toHaveBeenCalled()
+            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})
+
+        it "logs warning instead of throwing an exception if the package fails to load", ->
+          atom.config.set("core.disabledPackages", [])
+          spyOn(console, "warn")
+          expect(-> atom.packages.activatePackage("package-that-throws-an-exception")).not.toThrow()
+          expect(console.warn).toHaveBeenCalled()
+
+        describe "keymap loading", ->
+          describe "when the metadata does not contain a 'keymaps' manifest", ->
+            it "loads all the .cson/.json files in the keymaps directory", ->
+              element1 = $$ -> @div class: 'test-1'
+              element2 = $$ -> @div class: 'test-2'
+              element3 = $$ -> @div class: 'test-3'
+
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)).toHaveLength 0
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element2)).toHaveLength 0
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element3)).toHaveLength 0
+
+              atom.packages.activatePackage("package-with-keymaps")
+
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe "test-1"
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element2)[0].command).toBe "test-2"
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element3)).toHaveLength 0
+
+          describe "when the metadata contains a 'keymaps' manifest", ->
+            it "loads only the keymaps specified by the manifest, in the specified order", ->
+              element1 = $$ -> @div class: 'test-1'
+              element3 = $$ -> @div class: 'test-3'
+
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)).toHaveLength 0
+
+              atom.packages.activatePackage("package-with-keymaps-manifest")
+
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-z', element1)[0].command).toBe 'keymap-1'
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-n', element1)[0].command).toBe 'keymap-2'
+              expect(atom.keymap.keyBindingsForKeystrokeMatchingElement('ctrl-y', element3)).toHaveLength 0
+
+        describe "menu loading", ->
+          beforeEach ->
+            atom.contextMenu.definitions = []
+            atom.menu.template = []
+
+          describe "when the metadata does not contain a 'menus' manifest", ->
+            it "loads all the .cson/.json files in the menus directory", ->
+              element = ($$ -> @div class: 'test-1')[0]
+
+              expect(atom.contextMenu.definitionsForElement(element)).toEqual []
+
+              atom.packages.activatePackage("package-with-menus")
+
+              expect(atom.menu.template.length).toBe 2
+              expect(atom.menu.template[0].label).toBe "Second to Last"
+              expect(atom.menu.template[1].label).toBe "Last"
+              expect(atom.contextMenu.definitionsForElement(element)[0].label).toBe "Menu item 1"
+              expect(atom.contextMenu.definitionsForElement(element)[1].label).toBe "Menu item 2"
+              expect(atom.contextMenu.definitionsForElement(element)[2].label).toBe "Menu item 3"
+
+          describe "when the metadata contains a 'menus' manifest", ->
+            it "loads only the menus specified by the manifest, in the specified order", ->
+              element = ($$ -> @div class: 'test-1')[0]
+
+              expect(atom.contextMenu.definitionsForElement(element)).toEqual []
+
+              atom.packages.activatePackage("package-with-menus-manifest")
+
+              expect(atom.menu.template[0].label).toBe "Second to Last"
+              expect(atom.menu.template[1].label).toBe "Last"
+              expect(atom.contextMenu.definitionsForElement(element)[0].label).toBe "Menu item 2"
+              expect(atom.contextMenu.definitionsForElement(element)[1].label).toBe "Menu item 1"
+              expect(atom.contextMenu.definitionsForElement(element)[2]).toBeUndefined()
+
+        describe "stylesheet loading", ->
+          describe "when the metadata contains a 'stylesheets' manifest", ->
+            it "loads stylesheets from the stylesheets directory as specified by the manifest", ->
+              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")
+
+              one = atom.themes.stringToId(one)
+              two = atom.themes.stringToId(two)
+              three = atom.themes.stringToId(three)
+
+              expect(atom.themes.stylesheetElementForId(one)).not.toExist()
+              expect(atom.themes.stylesheetElementForId(two)).not.toExist()
+              expect(atom.themes.stylesheetElementForId(three)).not.toExist()
+
+              atom.packages.activatePackage("package-with-stylesheets-manifest")
+
+              expect(atom.themes.stylesheetElementForId(one)).toExist()
+              expect(atom.themes.stylesheetElementForId(two)).toExist()
+              expect(atom.themes.stylesheetElementForId(three)).not.toExist()
+              expect($('#jasmine-content').css('font-size')).toBe '1px'
+
+          describe "when the metadata does not contain a 'stylesheets' manifest", ->
+            it "loads all stylesheets from the stylesheets directory", ->
+              one = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/1.css")
+              two = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/2.less")
+              three = require.resolve("./fixtures/packages/package-with-stylesheets/stylesheets/3.css")
+
+
+              one = atom.themes.stringToId(one)
+              two = atom.themes.stringToId(two)
+              three = atom.themes.stringToId(three)
+
+              expect(atom.themes.stylesheetElementForId(one)).not.toExist()
+              expect(atom.themes.stylesheetElementForId(two)).not.toExist()
+              expect(atom.themes.stylesheetElementForId(three)).not.toExist()
+
+              atom.packages.activatePackage("package-with-stylesheets")
+              expect(atom.themes.stylesheetElementForId(one)).toExist()
+              expect(atom.themes.stylesheetElementForId(two)).toExist()
+              expect(atom.themes.stylesheetElementForId(three)).toExist()
+              expect($('#jasmine-content').css('font-size')).toBe '3px'
+
+        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'
+
+        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
+
+            runs ->
+              expect(atom.syntax.getProperty(['.source.pref'], 'editor.increaseIndentPattern')).toBe '^abc$'
+
+    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()
+
+          atom.packages.deactivatePackage("package-with-deactivate")
+          expect(pack.mainModule.deactivate).toHaveBeenCalled()
+          expect(atom.packages.isPackageActive("package-with-module")).toBeFalsy()
+
+          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-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()
+
+          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()
+
+        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'
+
+        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
+
+        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()
+
+        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()
+
+      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"
+
+        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()
+
+    describe ".activate()", ->
+      packageActivator = null
+      themeActivator = null
+
+      beforeEach ->
+        spyOn(console, 'warn')
+        atom.packages.loadPackages()
+
+        loadedPackages = atom.packages.getLoadedPackages()
+        expect(loadedPackages.length).toBeGreaterThan 0
+
+        packageActivator = spyOn(atom.packages, 'activatePackages')
+        themeActivator = spyOn(atom.themes, 'activatePackages')
+
+      afterEach ->
+        atom.packages.unloadPackages()
+
+        Syntax = require '../src/syntax'
+        atom.syntax = window.syntax = new Syntax()
+
+      it "activates all the packages, and none of the themes", ->
+        atom.packages.activate()
+
+        expect(packageActivator).toHaveBeenCalled()
+        expect(themeActivator).toHaveBeenCalled()
+
+        packages = packageActivator.mostRecentCall.args[0]
+        expect(['atom', 'textmate']).toContain(pack.getType()) for pack in packages
+
+        themes = themeActivator.mostRecentCall.args[0]
+        expect(['theme']).toContain(theme.getType()) for theme in themes
+
+    describe ".en/disablePackage()", ->
+      describe "with packages", ->
+        it ".enablePackage() enables a disabled package", ->
+          packageName = 'package-with-main'
+          atom.config.pushAtKeyPath('core.disabledPackages', packageName)
+          atom.packages.observeDisabledPackages()
+          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
+
+        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
+
+          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()
+
+        afterEach ->
+          atom.themes.deactivateThemes()
+          atom.config.unobserve('core.themes')
+
+        it ".enablePackage() and .disablePackage() enables and disables a theme", ->
+          packageName = 'theme-with-package-file'
+
+          expect(atom.config.get('core.themes')).not.toContain packageName
+          expect(atom.config.get('core.disabledPackages')).not.toContain packageName
+
+          # 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

spec/command-installer-spec.coffee

@@ -0,0 +1,36 @@
+{fs} = require 'atom'
+path = require 'path'
+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')
+
+  beforeEach ->
+    spyOn(installer, 'findInstallDirectory').andCallFake (callback) ->
+      callback(directory)
+
+    fs.removeSync(directory) if fs.existsSync(directory)
+
+  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()
+
+      installDone = false
+      installError = null
+      installer.install commandPath, (error) ->
+        installDone = true
+        installError = error
+
+      waitsFor -> installDone
+
+      runs ->
+        expect(installError).toBeNull()
+        expect(fs.isFileSync(destinationPath)).toBeTruthy()
+        expect(fs.realpathSync(destinationPath)).toBe fs.realpathSync(commandPath)
+        expect(fs.isExecutableSync(destinationPath)).toBeTruthy()

spec/config-spec.coffee

@@ -0,0 +1,303 @@
+{fs} = require 'atom'
+path = require 'path'
+temp = require 'temp'
+CSON = require 'season'
+
+describe "Config", ->
+  dotAtomPath = path.join(temp.dir, 'dot-atom-dir')
+
+  describe ".get(keyPath)", ->
+    it "allows a key path's value to be read", ->
+      expect(atom.config.set("foo.bar.baz", 42)).toBe 42
+      expect(atom.config.get("foo.bar.baz")).toBe 42
+      expect(atom.config.get("bogus.key.path")).toBeUndefined()
+
+    it "returns a deep clone of the key path's value", ->
+      atom.config.set('value', array: [1, b: 2, 3])
+      retrievedValue = atom.config.get('value')
+      retrievedValue.array[0] = 4
+      retrievedValue.array[1].b = 2.1
+      expect(atom.config.get('value')).toEqual(array: [1, b: 2, 3])
+
+  describe ".set(keyPath, value)", ->
+    it "allows a key path's value to be written", ->
+      expect(atom.config.set("foo.bar.baz", 42)).toBe 42
+      expect(atom.config.get("foo.bar.baz")).toBe 42
+
+    it "updates observers and saves when a key path is set", ->
+      observeHandler = jasmine.createSpy "observeHandler"
+      atom.config.observe "foo.bar.baz", observeHandler
+      observeHandler.reset()
+
+      atom.config.set("foo.bar.baz", 42)
+
+      expect(atom.config.save).toHaveBeenCalled()
+      expect(observeHandler).toHaveBeenCalledWith 42, {previous: undefined}
+
+    describe "when the value equals the default value", ->
+      it "does not store the value", ->
+        atom.config.setDefaults("foo", same: 1, changes: 1)
+        expect(atom.config.settings.foo).toBeUndefined()
+        atom.config.set('foo.same', 1)
+        atom.config.set('foo.changes', 2)
+        expect(atom.config.settings.foo).toEqual {changes: 2}
+
+        atom.config.set('foo.changes', 1)
+        expect(atom.config.settings.foo).toEqual {}
+
+  describe ".toggle(keyPath)", ->
+    it "negates the boolean value of the current key path value", ->
+      atom.config.set('foo.a', 1)
+      atom.config.toggle('foo.a')
+      expect(atom.config.get('foo.a')).toBe false
+
+      atom.config.set('foo.a', '')
+      atom.config.toggle('foo.a')
+      expect(atom.config.get('foo.a')).toBe true
+
+      atom.config.set('foo.a', null)
+      atom.config.toggle('foo.a')
+      expect(atom.config.get('foo.a')).toBe true
+
+      atom.config.set('foo.a', true)
+      atom.config.toggle('foo.a')
+      expect(atom.config.get('foo.a')).toBe false
+
+  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"])
+      observeHandler = jasmine.createSpy "observeHandler"
+      atom.config.observe "foo.bar.baz", observeHandler
+      observeHandler.reset()
+
+      expect(atom.config.pushAtKeyPath("foo.bar.baz", "b")).toBe 2
+      expect(atom.config.get("foo.bar.baz")).toEqual ["a", "b"]
+      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz"), {previous: ['a']}
+
+  describe ".unshiftAtKeyPath(keyPath, value)", ->
+    it "unshifts the given value to the array at the key path and updates observers", ->
+      atom.config.set("foo.bar.baz", ["b"])
+      observeHandler = jasmine.createSpy "observeHandler"
+      atom.config.observe "foo.bar.baz", observeHandler
+      observeHandler.reset()
+
+      expect(atom.config.unshiftAtKeyPath("foo.bar.baz", "a")).toBe 2
+      expect(atom.config.get("foo.bar.baz")).toEqual ["a", "b"]
+      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz"), {previous: ['b']}
+
+  describe ".removeAtKeyPath(keyPath, value)", ->
+    it "removes the given value from the array at the key path and updates observers", ->
+      atom.config.set("foo.bar.baz", ["a", "b", "c"])
+      observeHandler = jasmine.createSpy "observeHandler"
+      atom.config.observe "foo.bar.baz", observeHandler
+      observeHandler.reset()
+
+      expect(atom.config.removeAtKeyPath("foo.bar.baz", "b")).toEqual ["a", "c"]
+      expect(atom.config.get("foo.bar.baz")).toEqual ["a", "c"]
+      expect(observeHandler).toHaveBeenCalledWith atom.config.get("foo.bar.baz"), {previous: ['a', 'b', 'c']}
+
+  describe ".getPositiveInt(keyPath, defaultValue)", ->
+    it "returns the proper current or default value", ->
+      atom.config.set('editor.preferredLineLength', 0)
+      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+      atom.config.set('editor.preferredLineLength', -1234)
+      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+      atom.config.set('editor.preferredLineLength', 'abcd')
+      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+      atom.config.set('editor.preferredLineLength', null)
+      expect(atom.config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
+
+  describe ".save()", ->
+    nodeFs = require 'fs'
+
+    beforeEach ->
+      spyOn(nodeFs, 'writeFileSync')
+      jasmine.unspy atom.config, 'save'
+
+    describe "when ~/.atom/config.json exists", ->
+      it "writes any non-default properties to ~/.atom/config.json", ->
+        atom.config.configFilePath = path.join(atom.config.configDirPath, "atom.config.json")
+        atom.config.set("a.b.c", 1)
+        atom.config.set("a.b.d", 2)
+        atom.config.set("x.y.z", 3)
+        atom.config.setDefaults("a.b", e: 4, f: 5)
+
+        nodeFs.writeFileSync.reset()
+        atom.config.save()
+
+        expect(nodeFs.writeFileSync.argsForCall[0][0]).toBe(path.join(atom.config.configDirPath, "atom.config.json"))
+        writtenConfig = JSON.parse(nodeFs.writeFileSync.argsForCall[0][1])
+        expect(writtenConfig).toEqual atom.config.settings
+
+    describe "when ~/.atom/config.json doesn't exist", ->
+      it "writes any non-default properties to ~/.atom/config.cson", ->
+        atom.config.configFilePath = path.join(atom.config.configDirPath, "atom.config.cson")
+        atom.config.set("a.b.c", 1)
+        atom.config.set("a.b.d", 2)
+        atom.config.set("x.y.z", 3)
+        atom.config.setDefaults("a.b", e: 4, f: 5)
+
+        nodeFs.writeFileSync.reset()
+        atom.config.save()
+
+        expect(nodeFs.writeFileSync.argsForCall[0][0]).toBe(path.join(atom.config.configDirPath, "atom.config.cson"))
+        CoffeeScript = require 'coffee-script'
+        writtenConfig = CoffeeScript.eval(nodeFs.writeFileSync.argsForCall[0][1], bare: true)
+        expect(writtenConfig).toEqual atom.config.settings
+
+  describe ".setDefaults(keyPath, defaults)", ->
+    it "assigns any previously-unassigned keys to the object at the key path", ->
+      atom.config.set("foo.bar.baz", a: 1)
+      atom.config.setDefaults("foo.bar.baz", a: 2, b: 3, c: 4)
+      expect(atom.config.get("foo.bar.baz.a")).toBe 1
+      expect(atom.config.get("foo.bar.baz.b")).toBe 3
+      expect(atom.config.get("foo.bar.baz.c")).toBe 4
+
+      atom.config.setDefaults("foo.quux", x: 0, y: 1)
+      expect(atom.config.get("foo.quux.x")).toBe 0
+      expect(atom.config.get("foo.quux.y")).toBe 1
+
+  describe ".observe(keyPath)", ->
+    [observeHandler, observeSubscription] = []
+
+    beforeEach ->
+      observeHandler = jasmine.createSpy("observeHandler")
+      atom.config.set("foo.bar.baz", "value 1")
+      observeSubscription = atom.config.observe "foo.bar.baz", observeHandler
+
+    it "fires the given callback with the current value at the keypath", ->
+      expect(observeHandler).toHaveBeenCalledWith("value 1")
+
+    it "fires the callback every time the observed value changes", ->
+      observeHandler.reset() # clear the initial call
+      atom.config.set('foo.bar.baz', "value 2")
+      expect(observeHandler).toHaveBeenCalledWith("value 2", {previous: 'value 1'})
+      observeHandler.reset()
+
+      atom.config.set('foo.bar.baz', "value 1")
+      expect(observeHandler).toHaveBeenCalledWith("value 1", {previous: 'value 2'})
+
+    it "fires the callback when the observed value is deleted", ->
+      observeHandler.reset() # clear the initial call
+      atom.config.set('foo.bar.baz', undefined)
+      expect(observeHandler).toHaveBeenCalledWith(undefined, {previous: 'value 1'})
+
+    it "fires the callback when the full key path goes into and out of existence", ->
+      observeHandler.reset() # clear the initial call
+      atom.config.set("foo.bar", undefined)
+
+      expect(observeHandler).toHaveBeenCalledWith(undefined, {previous: 'value 1'})
+      observeHandler.reset()
+
+      atom.config.set("foo.bar.baz", "i'm back")
+      expect(observeHandler).toHaveBeenCalledWith("i'm back", {previous: undefined})
+
+    it "does not fire the callback once the observe subscription is off'ed", ->
+      observeHandler.reset() # clear the initial call
+      observeSubscription.off()
+      atom.config.set('foo.bar.baz', "value 2")
+      expect(observeHandler).not.toHaveBeenCalled()
+
+  describe ".initializeConfigDirectory()", ->
+    beforeEach ->
+      atom.config.configDirPath = dotAtomPath
+      expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
+
+    afterEach ->
+      fs.removeSync(dotAtomPath) if fs.existsSync(dotAtomPath)
+
+    describe "when the configDirPath doesn't exist", ->
+      it "copies the contents of dot-atom to ~/.atom", ->
+        initializationDone = false
+        jasmine.unspy(window, "setTimeout")
+        atom.config.initializeConfigDirectory ->
+          initializationDone = true
+
+        waitsFor -> initializationDone
+
+        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, 'config.cson'))).toBeTruthy()
+
+  describe ".loadUserConfig()", ->
+    beforeEach ->
+      atom.config.configDirPath = dotAtomPath
+      atom.config.configFilePath = path.join(atom.config.configDirPath, "atom.config.cson")
+      expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
+
+    afterEach ->
+      fs.removeSync(dotAtomPath) if fs.existsSync(dotAtomPath)
+
+    describe "when the config file contains valid cson", ->
+      beforeEach ->
+        fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'baz'")
+        atom.config.loadUserConfig()
+
+      it "updates the config data based on the file contents", ->
+        expect(atom.config.get("foo.bar")).toBe 'baz'
+
+    describe "when the config file contains invalid cson", ->
+      beforeEach ->
+        spyOn(console, 'error')
+        fs.writeFileSync(atom.config.configFilePath, "{{{{{")
+
+      it "logs an error to the console and does not overwrite the config file on a subsequent save", ->
+        atom.config.loadUserConfig()
+        expect(console.error).toHaveBeenCalled()
+        atom.config.set("hair", "blonde") # trigger a save
+        expect(atom.config.save).not.toHaveBeenCalled()
+
+    describe "when the config file does not exist", ->
+      it "creates it with an empty object", ->
+        fs.makeTreeSync(atom.config.configDirPath)
+        atom.config.loadUserConfig()
+        expect(fs.existsSync(atom.config.configFilePath)).toBe true
+        expect(CSON.readFileSync(atom.config.configFilePath)).toEqual {}
+
+  describe ".observeUserConfig()", ->
+    updatedHandler = null
+
+    beforeEach ->
+      atom.config.configDirPath = dotAtomPath
+      atom.config.configFilePath = path.join(atom.config.configDirPath, "atom.config.cson")
+      expect(fs.existsSync(atom.config.configDirPath)).toBeFalsy()
+      fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'baz'")
+      atom.config.loadUserConfig()
+      atom.config.observeUserConfig()
+      updatedHandler = jasmine.createSpy("updatedHandler")
+      atom.config.on 'updated', updatedHandler
+
+    afterEach ->
+      atom.config.unobserveUserConfig()
+      fs.removeSync(dotAtomPath) if fs.existsSync(dotAtomPath)
+
+    describe "when the config file changes to contain valid cson", ->
+      it "updates the config data", ->
+        fs.writeFileSync(atom.config.configFilePath, "foo: { bar: 'quux', baz: 'bar'}")
+        waitsFor 'update event', -> updatedHandler.callCount > 0
+        runs ->
+          expect(atom.config.get('foo.bar')).toBe 'quux'
+          expect(atom.config.get('foo.baz')).toBe 'bar'
+
+    describe "when the config file changes to contain invalid cson", ->
+      beforeEach ->
+        spyOn(console, 'error')
+        fs.writeFileSync(atom.config.configFilePath, "}}}")
+        waitsFor "error to be logged", -> console.error.callCount > 0
+
+      it "logs a warning and does not update config data", ->
+        expect(updatedHandler.callCount).toBe 0
+        expect(atom.config.get('foo.bar')).toBe 'baz'
+        atom.config.set("hair", "blonde") # trigger a save
+        expect(atom.config.save).not.toHaveBeenCalled()
+
+      describe "when the config file subsequently changes again to contain valid cson", ->
+        beforeEach ->
+          fs.writeFileSync(atom.config.configFilePath, "foo: bar: 'baz'")
+          waitsFor 'update event', -> updatedHandler.callCount > 0
+
+        it "updates the config data and resumes saving", ->
+          atom.config.set("hair", "blonde")
+          expect(atom.config.save).toHaveBeenCalled()

spec/context-menu-manager-spec.coffee

@@ -0,0 +1,122 @@
+{$$} = require 'atom'
+
+ContextMenuManager = require '../src/context-menu-manager'
+
+describe "ContextMenuManager", ->
+  [contextMenu] = []
+
+  beforeEach ->
+    contextMenu = new ContextMenuManager
+
+  describe "adding definitions", ->
+    it 'loads',  ->
+      contextMenu.add 'file-path',
+        '.selector':
+          'label': 'command'
+
+      expect(contextMenu.definitions['.selector'][0].label).toEqual 'label'
+      expect(contextMenu.definitions['.selector'][0].command).toEqual 'command'
+
+    describe 'dev mode', ->
+      it 'loads',  ->
+        contextMenu.add 'file-path',
+          '.selector':
+            'label': 'command'
+        , devMode: true
+
+        expect(contextMenu.devModeDefinitions['.selector'][0].label).toEqual 'label'
+        expect(contextMenu.devModeDefinitions['.selector'][0].command).toEqual 'command'
+
+  describe "building a menu template", ->
+    beforeEach ->
+      contextMenu.definitions = {
+        '.parent':[
+          label: 'parent'
+          command: 'command-p'
+         ]
+        '.child': [
+          label: 'child'
+          command: 'command-c'
+        ]
+      }
+
+      contextMenu.devModeDefinitions =
+        '.parent': [
+          label: 'dev-label'
+          command: 'dev-command'
+        ]
+
+    describe "on a single element", ->
+      [element] = []
+
+      beforeEach ->
+        element = ($$ -> @div class: 'parent')[0]
+
+      it "creates a menu with a single item", ->
+        menu = contextMenu.combinedMenuTemplateForElement(element)
+
+        expect(menu[0].label).toEqual 'parent'
+        expect(menu[0].command).toEqual 'command-p'
+        expect(menu[1]).toBeUndefined()
+
+      describe "in devMode", ->
+        beforeEach -> contextMenu.devMode = true
+
+        it "creates a menu with development items", ->
+          menu = contextMenu.combinedMenuTemplateForElement(element)
+
+          expect(menu[0].label).toEqual 'parent'
+          expect(menu[0].command).toEqual 'command-p'
+          expect(menu[1].type).toEqual 'separator'
+          expect(menu[2].label).toEqual 'dev-label'
+          expect(menu[2].command).toEqual 'dev-command'
+
+
+    describe "on multiple elements", ->
+      [element] = []
+
+      beforeEach ->
+        element = $$ ->
+          @div class: 'parent', =>
+            @div class: 'child'
+
+        element = element.find('.child')[0]
+
+      it "creates a menu with a two items", ->
+        menu = contextMenu.combinedMenuTemplateForElement(element)
+
+        expect(menu[0].label).toEqual 'child'
+        expect(menu[0].command).toEqual 'command-c'
+        expect(menu[1].label).toEqual 'parent'
+        expect(menu[1].command).toEqual 'command-p'
+        expect(menu[2]).toBeUndefined()
+
+      describe "in devMode", ->
+        beforeEach -> contextMenu.devMode = true
+
+        xit "creates a menu with development items", ->
+          menu = contextMenu.combinedMenuTemplateForElement(element)
+
+          expect(menu[0].label).toEqual 'child'
+          expect(menu[0].command).toEqual 'command-c'
+          expect(menu[1].label).toEqual 'parent'
+          expect(menu[1].command).toEqual 'command-p'
+          expect(menu[2].label).toEqual 'dev-label'
+          expect(menu[2].command).toEqual 'dev-command'
+          expect(menu[3]).toBeUndefined()
+
+  describe "#executeBuildHandlers", ->
+    menuTemplate = [
+        label: 'label'
+        executeAtBuild: ->
+      ]
+    event =
+      target: null
+
+    it 'should invoke the executeAtBuild fn', ->
+      buildFn = spyOn(menuTemplate[0], 'executeAtBuild')
+      contextMenu.executeBuildHandlers(event, menuTemplate)
+
+      expect(buildFn).toHaveBeenCalled()
+      expect(buildFn.mostRecentCall.args[0]).toBe event
+

spec/deserializer-manager-spec.coffee

@@ -0,0 +1,33 @@
+DeserializerManager = require '../src/deserializer-manager'
+
+describe ".deserialize(state)", ->
+  deserializer = null
+
+  class Foo
+    @deserialize: ({name}) -> new Foo(name)
+    constructor: (@name) ->
+
+  beforeEach ->
+    deserializer = new DeserializerManager()
+    deserializer.add(Foo)
+
+  it "calls deserialize on the deserializer for the given state object, or returns undefined if one can't be found", ->
+    spyOn(console, 'warn')
+    object = deserializer.deserialize({ deserializer: 'Foo', name: 'Bar' })
+    expect(object.name).toBe 'Bar'
+    expect(deserializer.deserialize({ deserializer: 'Bogus' })).toBeUndefined()
+
+  describe "when the deserializer has a version", ->
+    beforeEach ->
+      Foo.version = 2
+
+    describe "when the deserialized state has a matching version", ->
+      it "attempts to deserialize the state", ->
+        object = deserializer.deserialize({ deserializer: 'Foo', version: 2, name: 'Bar' })
+        expect(object.name).toBe 'Bar'
+
+    describe "when the deserialized state has a non-matching version", ->
+      it "returns undefined", ->
+        expect(deserializer.deserialize({ deserializer: 'Foo', version: 3, name: 'Bar' })).toBeUndefined()
+        expect(deserializer.deserialize({ deserializer: 'Foo', version: 1, name: 'Bar' })).toBeUndefined()
+        expect(deserializer.deserialize({ deserializer: 'Foo', name: 'Bar' })).toBeUndefined()