Add empty changelog to get this deploy out

Speed up start time

.github

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

.gitignore

@@ -7,4 +7,5 @@ node_modules
 npm-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/twbs/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,7 @@ 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:

CHANGELOG.md

@@ -1,79 +0,0 @@
-* Added: Terminal package now bundled by default, open with ctrl-`
-* Fixed: Fuzzy finder not showing results for files at a certain depth
-* Fixed: Atom > Preferences... menu not opening settings in focused window
-
-* Fixed: Atom failing to launch if the theme being used was not found
-
-* Improved: Theme changes now immediately take effect
-* Fixed: Wrap in quotes/parens now works in split panes
-* Improved: Autocomplete now includes CSS property names and values
-* Improved: Settings GUI is now a pane item
-* Added: Support package filtering in Settings GUI
-* Added: Dynamically load all config options in the Settings GUI
-* Added: Ability to bookmark lines and navigate bookmarks
-* Fixed: Error when inserting newlines in CSS
-* Fixed: Folding all will fold comments as well
-* Added: Ability to fold all code at a given indentation level
-
-* 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

@@ -16,17 +16,25 @@
     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
+  * Be ware 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
 

Gruntfile.coffee

@@ -1,58 +1,99 @@
+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)
+  [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,19 +101,23 @@ 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
@@ -91,28 +136,60 @@ 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', 'set-development-version', '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('default', ['update-atom-shell', 'build', 'set-development-version', 'install'])
+  grunt.registerTask('docs', ['markdown:guides', 'build-docs'])
+
+  defaultTasks = ['update-atom-shell', 'build']
+  defaultTasks.push('set-development-version') if process.platform is 'darwin'
+  defaultTasks.push('install')
+  grunt.registerTask('default', defaultTasks)

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://atom-docs.githubapp.com/v26.0/index.html) and [API documentation](https://atom-docs.githubapp.com/v26.0/api/index.html).
 
 ## Installing
 

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,5 @@
 #!/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.
@@ -9,14 +9,14 @@ if [ ! -d $ATOM_PATH ]; then
   exit 1
 fi
 
-while getopts ":whv-:" opt; do
+while getopts ":wtfvhs-:" opt; do
   case "$opt" in
     -)
       case "${OPTARG}" in
         wait)
           WAIT=1
           ;;
-        help|version)
+        help|version|foreground|test)
           EXPECT_OUTPUT=1
           ;;
       esac
@@ -24,7 +24,7 @@ while getopts ":whv-:" opt; do
     w)
       WAIT=1
       ;;
-    h|v)
+    h|v|f|t)
       EXPECT_OUTPUT=1
       ;;
   esac
@@ -32,6 +32,7 @@ done
 
 if [ $EXPECT_OUTPUT ]; then
   $ATOM_BINARY --executed-from="$(pwd)" --pid=$$ $@
+  exit $?
 else
   open -a $ATOM_PATH -n --args --executed-from="$(pwd)" --pid=$$ $@
 fi

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,10 @@
-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'
+fsUtils = require '../src/fs-utils'
+TokenizedBuffer = require '../src/tokenized-buffer'
 
 defaultCount = 100
 window.pbenchmark = (args...) -> window.benchmark(args..., profile: true)
@@ -32,7 +12,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 +29,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 ->

benchmark/benchmark-suite.coffee

@@ -1,31 +1,25 @@
-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
 
   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() # open blank editor
+    editor = rootView.getActiveView()
 
   afterEach ->
     if editor.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)
-
   describe "keymap.", ->
     event = null
 
@@ -37,7 +31,7 @@ describe "editor.", ->
 
   describe "opening-buffers.", ->
     benchmark "300-line-file.", ->
-      buffer = project.bufferForPath('medium.coffee')
+      buffer = project.bufferForPathSync('medium.coffee')
 
   describe "empty-file.", ->
     benchmark "insert-delete", ->
@@ -46,7 +40,7 @@ describe "editor.", ->
 
   describe "300-line-file.", ->
     beforeEach ->
-      rootView.open('medium.coffee')
+      rootView.openSync('medium.coffee')
 
     describe "at-begining.", ->
       benchmark "insert-delete", ->
@@ -65,13 +59,123 @@ describe "editor.", ->
         editor.insertText('"')
         editor.backspace()
 
+    describe "empty-vs-set-innerHTML.", ->
+      [firstRow, lastRow] = []
+      beforeEach ->
+        firstRow = editor.getFirstVisibleScreenRow()
+        lastRow = editor.getLastVisibleScreenRow()
+
+      benchmark "build-gutter-html.", 1000, ->
+        editor.gutter.renderLineNumbers(null, firstRow, lastRow)
+
+      benchmark "set-innerHTML.", 1000, ->
+        editor.gutter.renderLineNumbers(null, firstRow, lastRow)
+        editor.gutter.lineNumbers[0].innerHtml = ''
+
+      benchmark "empty.", 1000, ->
+        editor.gutter.renderLineNumbers(null, firstRow, lastRow)
+        editor.gutter.lineNumbers.empty()
+
+    describe "positionLeftForLineAndColumn.", ->
+      line = null
+      beforeEach ->
+        editor.scrollTop(2000)
+        editor.resetDisplay()
+        line = editor.lineElementForScreenRow(106)[0]
+
+      describe "one-line.", ->
+        beforeEach ->
+          editor.clearCharacterWidthCache()
+
+        benchmark "uncached", 5000, ->
+          editor.positionLeftForLineAndColumn(line, 106, 82)
+          editor.clearCharacterWidthCache()
+
+        benchmark "cached", 5000, ->
+          editor.positionLeftForLineAndColumn(line, 106, 82)
+
+      describe "multiple-lines.", ->
+        [firstRow, lastRow] = []
+        beforeEach ->
+          firstRow = editor.getFirstVisibleScreenRow()
+          lastRow = editor.getLastVisibleScreenRow()
+
+        benchmark "cache-entire-visible-area", 100, ->
+          for i in [firstRow..lastRow]
+            line = editor.lineElementForScreenRow(i)[0]
+            editor.positionLeftForLineAndColumn(line, i, Math.max(0, editor.lineLengthForBufferRow(i)))
+
+    describe "text-rendering.", ->
+      beforeEach ->
+        editor.scrollTop(2000)
+
+      benchmark "resetDisplay", 50, ->
+        editor.resetDisplay()
+
+      benchmark "htmlForScreenRows", 1000, ->
+        lastRow = editor.getLastScreenRow()
+        editor.htmlForScreenRows(0, lastRow)
+
+      benchmark "htmlForScreenRows.htmlParsing", 50, ->
+        lastRow = editor.getLastScreenRow()
+        html = editor.htmlForScreenRows(0, lastRow)
+
+        div = document.createElement('div')
+        div.innerHTML = html
+
+    describe "gutter-api.", ->
+      describe "getLineNumberElementsForClass.", ->
+        beforeEach ->
+          editor.gutter.addClassToLine(20, 'omgwow')
+          editor.gutter.addClassToLine(40, 'omgwow')
+
+        benchmark "DOM", 20000, ->
+          editor.gutter.getLineNumberElementsForClass('omgwow')
+
+      benchmark "getLineNumberElement.DOM", 20000, ->
+        editor.gutter.getLineNumberElement(12)
+
+      benchmark "toggle-class", 2000, ->
+        editor.gutter.addClassToLine(40, 'omgwow')
+        editor.gutter.removeClassFromLine(40, 'omgwow')
+
+      describe "find-then-unset.", ->
+        classes = ['one', 'two', 'three', 'four']
+
+        benchmark "single-class", 200, ->
+          editor.gutter.addClassToLine(30, 'omgwow')
+          editor.gutter.addClassToLine(40, 'omgwow')
+          editor.gutter.removeClassFromAllLines('omgwow')
+
+        benchmark "multiple-class", 200, ->
+          editor.gutter.addClassToLine(30, 'one')
+          editor.gutter.addClassToLine(30, 'two')
+
+          editor.gutter.addClassToLine(40, 'two')
+          editor.gutter.addClassToLine(40, 'three')
+          editor.gutter.addClassToLine(40, 'four')
+
+          for klass in classes
+            editor.gutter.removeClassFromAllLines(klass)
+
+    describe "line-htmlification.", ->
+      div = null
+      html = null
+      beforeEach ->
+        lastRow = editor.getLastScreenRow()
+        html = editor.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()
@@ -106,7 +210,7 @@ describe "TokenizedBuffer.", ->
     [languageMode, buffer] = []
 
     beforeEach ->
-      editSession = benchmarkFixturesProject.open('medium.coffee')
+      editSession = benchmarkFixturesProject.openSync('medium.coffee')
       { languageMode, buffer } = editSession
 
     benchmark "construction", 20, ->

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,629 @@
+# Authoring 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, status
+bar 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/
+  grammars/
+  keymaps/
+  lib/
+  menus/
+  spec/
+  snippets/
+  stylesheets/
+  index.coffee
+  package.json
+```
+
+## package.json
+
+Similar to [npm packages][npm], 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][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
+
+```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 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.
+
+Check out [wrap-guide] for a simple example of Atom's package 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] (but LESS
+is recommended).
+
+Ideally you will not need much in the way of styling. We've provided a standard
+set of components. You can view all components by opening the styleguide: open
+the command palette (`cmd-p`) and search for _styleguide_ or just
+`cmd-ctrl-shift-g`.
+
+If you do need styling, we try to keep only structural styles in the package
+stylesheets. Colors and sizing should be taken from the active theme's
+[ui-variables.less][ui-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
+
+```coffeescript
+'.tree-view-scroller':
+  'ctrl-V': 'changer:magic'
+```
+
+It's recommended that you provide key bindings for commonly used actions for
+your extension, especially if you're also adding a new command.
+
+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.
+
+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
+
+```coffee-script
+'menu': [
+  {
+    'label': 'Packages'
+    'submenu': [
+      {
+        'label': 'My Package'
+        'submenu': [
+          {
+            'label': 'Toggle'
+            'command': 'my-package:toggle'
+          }
+        ]
+      }
+    ]
+  }
+]
+```
+
+It's recommended that you create an application menu item for common actions
+with your package that aren't tied to a specific element.
+
+To add your own item to the application menu simply create a top level `menu`
+key in any menu configuration file in _menus_ (since the above is [CSON] it
+should end with `.cson`)
+
+The menu templates you specify are merged with all other templates provided
+by other packages in the order which they were loaded.
+
+### Context Menu
+
+```coffee-script
+'context-menu':
+  '.tree-view':
+    'Add file': 'tree-view:add-file'
+  '#root-view':
+    'Inspect Element': 'core:inspect'
+```
+
+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.
+
+To add your own item to the application menu simply create a top level
+`context-menu` key in any menu configuration file in _menus_ (since the above is
+[CSON] it should end with `.cson`)
+
+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] is being used to execute the 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
+
+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.
+
+
+# Full Example
+
+Let's take a look at creating our first package.
+
+To get started hit `cmd-p`, and start typing "Package Generator." to generate
+the package. Once you select the package generator command, 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 `cmd-r` to reload Atom, then hit `cmd-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
+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_ can easily become 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. 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).
+
+Let's bring in jQuery:
+
+```coffeescript
+{$} = require 'atom'
+```
+
+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-cmd-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 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 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], 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 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 see your 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][path] 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)
+```
+
+# 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.
+
+[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
+[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

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 they behaves just as they would on a website. Themes loaded first are overridden by
+themes which are loaded later (the order is controlled from within the Settings
+pane).
+
+This flexibility is helpful for users which 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 a changing
+the colors in the tree view or creating a language specific syntax theme.
+
+## Getting Started
+
+To create your own theme you'll need a few things:
+
+* A working install of [Atom], so you can work on your new theme.
+* A working install of [git] to track changes.
+* And a [GitHub] account, so you can distribute your themes.
+
+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].
+* Atom uses Chrome at its core, so you can use Chrome devtools to
+  inspect the current state of the interface. Checkout Google's
+  [extensive tutorial][devtools-tutorial] for a short introduction.
+
+## Creating a Minimal Syntax Theme
+
+1. Open the Command Palette (`cmd-p`)
+1. Search for `Package Generator: Generate Syntax Theme` and select it.
+1. Choose a name for your theme. A folder will be created with this name.
+1. Press enter to create your theme. After creation, your theme will be
+   installed and enabled.
+1. An Atom window will open with your newly created theme.
+  1. Open `package.json` and update the relevant parts.
+  1. Open `stylesheets/colors.less` to change the various colors variables which
+     have been already been defined.
+  1. Open `stylesheets/base.less` and modify the various syntax CSS selectors
+     that have been already been defined.
+  1. When you're ready, update the `README.md` and include an example screenshot
+     of your new theme in action.
+1. Reload atom (`cmd-r`) to see changes you made reflected in your Atom window.
+1. Look in the theme settings, your new theme should be show in the enabled themes section
+    ![themesettings-img]
+1. Open a terminal to your new theme directory; it should be in `~/.atom/packages/<my-name>`.  
+  1. To publish, initialize a git repository, push to GitHub, and run
+     `apm publish`.
+
+Want to make edits and have them immediately show up without reloading? Open a
+development window (__View > Developer > Open in Dev Mode__ menu) to the
+directory of your choice &mdash; even the new theme itself. Then just edit away!
+Changes will be instantly reflected in the editor without having to reload.
+
+## Interface Themes
+
+There are only two differences between interface and syntax themes - what
+they target and what they provide. Interface themes only target elements which
+are outside of the editor and **must** provide a `ui-variables.less` file which
+contains all of the variables provided by the [core themes][ui-variables].
+
+To create a 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 fast.
+
+### Live Reload
+
+Reloading via `cmd-r` after you make changes to your theme less than ideal. Atom
+supports [live updating][livereload] of styles on Dev Mode Atom windows.
+
+1. Open your theme directory in a dev window by either using the
+__View > Developer > Open in Dev Mode__ menu or the `cmd-shift-o` shortcut
+1. Make a change to your theme file and save &mdash; your change should be
+immediately applied!
+
+If you'd like to reload all styles at any time, you can use the shortcut
+`cmd-ctrl-shift-r`.
+
+### Developer Tools
+
+Atom is based on the Chrome browser, and supports Chrome's Developer Tools. You
+can open them by selecting the __View > Toggle Developer Tools__ menu or by using the
+`cmd-option-i` shortcut.
+
+The dev tools allow you to inspect elements and take a look at their CSS
+properties.
+
+![devtools-img]
+
+### 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/
+[github]: https://github.com/
+[less-tutorial]: https://speakerdeck.com/danmatthews/less-css
+[devtools-tutorial]: https://developers.google.com/chrome-developer-tools/docs/elements
+[ui-variables]: https://github.com/atom/atom-dark-ui/blob/master/stylesheets/ui-variables.less
+[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,88 @@ 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
+## Advanced Configuration
 
-Atom comes bundled 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_:
+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-shift-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,154 +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
-'editor':
-  'fontSize': 16
-'core':
-  'themes': [
-    'atom-dark-ui'
-    'atom-dark-syntax'
-  ]
-```
-
-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:
-
-```coffeescript
-'.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`:
-
-```coffeescript
-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,12 @@
+## 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/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.

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,31 @@
+{Document, Point, Range, Site} = require 'telepath'
+_ = require 'underscore-plus'
+
+module.exports =
+  _: _
+  BufferedNodeProcess: require '../src/buffered-node-process'
+  BufferedProcess: require '../src/buffered-process'
+  Directory: require '../src/directory'
+  Document: Document
+  File: require '../src/file'
+  fs: require '../src/fs-utils'
+  Git: require '../src/git'
+  Point: Point
+  Range: Range
+  Site: Site
+
+# 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'
+  module.exports.pathForRepositoryUrl = require('../src/project').pathForRepositoryUrl
+  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/apple.cson

@@ -0,0 +1,29 @@
+'body':
+  'meta-up': 'core:move-to-top'
+  'meta-down': 'core:move-to-bottom'
+  'meta-shift-up': 'core:select-to-top'
+  'meta-shift-down': 'core:select-to-bottom'
+
+'.editor':
+  'meta-left': 'editor:move-to-first-character-of-line'
+  'meta-right': 'editor:move-to-end-of-line'
+  'meta-shift-left': 'editor:select-to-first-character-of-line'
+  'meta-shift-right': 'editor:select-to-end-of-line'
+
+  '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'
+
+  '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'
+
+  'alt-backspace': 'editor:backspace-to-beginning-of-word'
+  'meta-backspace': 'editor:backspace-to-beginning-of-line'
+
+  'alt-delete': 'editor:delete-to-end-of-word'
+  'ctrl-t': 'editor:transpose'
+  'ctrl-A': 'editor:select-to-first-character-of-line'
+  'ctrl-E': 'editor:select-to-end-of-line'

keymaps/atom.cson

@@ -1,4 +1,16 @@
 'body':
+  'meta-q': 'application:quit'
+  'meta-h': 'application:hide'
+  'meta-H': 'application:hide-other-applications'
+  'meta-n': 'application:new-file'
+  'meta-N': 'application:new-window'
+  'meta-o': 'application:open'
+  'meta-O': 'application:open-dev'
+  'meta-m': 'application:minimize'
+  'meta-,': 'application:show-settings'
+  'alt-meta-ctrl-m': 'application:zoom'
+  'meta-alt-ctrl-s': 'application:run-all-specs'
+
   'meta-s': 'core:save'
   'meta-S': 'core:save-as'
   'enter': 'core:confirm'
@@ -18,6 +30,7 @@
   'delete': 'core:delete'
   'meta-z': 'core:undo'
   'meta-Z': 'core:redo'
+  'meta-y': 'core:redo'
   'meta-x': 'core:cut'
   'meta-c': 'core:copy'
   'meta-v': 'core:paste'
@@ -26,12 +39,14 @@
 
   'meta-alt-s': 'window:save-all'
   'meta-W': 'window:close'
-  'meta-r': 'window:reload'
   'meta-+': 'window:increase-font-size'
   'meta--': 'window:decrease-font-size'
   'ctrl-w w': 'window:focus-next-pane'
   'ctrl-tab': 'window:focus-next-pane'
   'ctrl-meta-f': 'window:toggle-full-screen'
+  'ctrl-alt-meta-r': 'window:reload'
+  'alt-meta-i': 'window:toggle-dev-tools'
+  'meta-alt-ctrl-p': 'window:run-package-specs'
 
   'ctrl-|': 'pane:split-right'
   'ctrl-w v': 'pane:split-right'
@@ -55,14 +70,6 @@
   'alt-meta-w': 'pane:close-other-items'
   'meta-P': 'pane:close'
 
-  'meta-n': 'new-editor'
-  'meta-N': 'new-window'
-  'meta-,': 'open-user-configuration'
-  'meta-o': 'open'
-  'meta-O': 'open-dev'
-  'meta-w': 'core:close'
-  'alt-meta-i': 'toggle-dev-tools'
-
 '.tool-panel':
   'meta-escape': 'tool-panel:unfocus'
   'escape': 'core:close'

keymaps/editor.cson

@@ -1,10 +1,16 @@
 '.editor':
+  'ctrl-K': 'editor:delete-line'
+  'ctrl-W': 'editor:select-word'
+  'meta-alt-p': 'editor:log-cursor-scope'
+  'meta-u': 'editor:upper-case'
+  'meta-U': 'editor:lower-case'
+
+'.editor:not(.mini)':
   'enter': 'editor:newline'
   'meta-enter': 'editor:newline-below'
   'meta-shift-enter': 'editor:newline-above'
   'tab': 'editor:indent'
   'meta-=': 'editor:auto-indent'
-  'meta-d': 'editor:delete-line'
 
   'ctrl-[': 'editor:fold-current-row'
   'ctrl-]': 'editor:unfold-current-row'
@@ -26,16 +32,13 @@
   'shift-tab': 'editor:outdent-selected-rows'
   'meta-[': 'editor:outdent-selected-rows'
   'meta-]': 'editor:indent-selected-rows'
+
   'meta-/': 'editor:toggle-line-comments'
-  'ctrl-W': 'editor:select-word'
-  'meta-alt-p': 'editor:log-cursor-scope'
-  'meta-u': 'editor:upper-case'
-  'meta-U': 'editor:lower-case'
   'ctrl-C': 'editor:copy-path'
   'ctrl-meta-up': 'editor:move-line-up'
   'ctrl-meta-down': 'editor:move-line-down'
   'meta-D': 'editor:duplicate-line'
-  'ctrl-J': 'editor:join-line'
+  'meta-j': 'editor:join-line'
   'meta-<': 'editor:scroll-to-cursor'
 
 '.editor.mini':

keymaps/select-list.cson

@@ -0,0 +1,4 @@
+'.select-list .mini.editor':
+  'enter': 'core:confirm'
+  'escape': 'core:cancel'
+  'meta-w': 'core:cancel'

menus/base.cson

@@ -0,0 +1,185 @@
+'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: 'Collaboration'
+    submenu: []
+  }
+
+  {
+    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' }
+    ]
+  }
+]

package.json

@@ -1,92 +1,151 @@
 {
   "name": "atom",
-  "version": "0.0.0",
-  "main": "./src/main.js",
+  "version": "33.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.6",
   "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.2.0",
-    "less": "git://github.com/nathansobo/less.js.git",
-    "roaster": "0.0.7",
-    "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/twbs/bootstrap.git#v3.0.0",
+    "clear-cut": "0.1.0",
+    "coffee-script": "1.6.3",
+    "coffeestack": "0.6.0",
+    "emissary": "0.9.0",
+    "first-mate": "0.5.0",
+    "fuzzaldrin": "0.1.0",
+    "git-utils": "0.28.0",
     "guid": "0.0.10",
-    "tantamount": "0.3.0",
+    "jasmine-focused": "~0.15.0",
+    "mkdirp": "0.3.5",
+    "less-cache": "0.9.0",
     "nslog": "0.1.0",
-    "coffeestack": "0.4.0",
-    "first-mate": "0.1.0",
-    "c-tmbundle": "1.0.0",
-    "coffee-script-tmbundle": "4.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",
-    "terminal": "0.3.0"
+    "oniguruma": "0.22.0",
+    "optimist": "0.4.0",
+    "pathwatcher": "0.8.0",
+    "pegjs": "0.7.0",
+    "plist": "git://github.com/nathansobo/node-plist.git",
+    "q": "0.9.7",
+    "rimraf": "2.1.4",
+    "scandal": "0.6.0",
+    "season": "0.14.0",
+    "semver": "1.1.4",
+    "space-pen": "2.0.0",
+    "telepath": "0.8.1",
+    "temp": "0.5.0",
+    "underscore-plus": "0.2.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-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.6.4",
-    "jasmine-focused": "~0.7.0",
+    "grunt-contrib-less": "~0.8.0",
     "walkdir": "0.0.7",
-    "js-yaml": "~2.1.0"
+    "ws": "0.4.27",
+    "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",
+    "request": "~2.27.0"
+  },
+  "packageDependencies" : {
+    "atom-light-ui": "0.5.0",
+    "atom-light-syntax": "0.5.0",
+    "atom-dark-ui": "0.5.0",
+    "atom-dark-syntax": "0.5.0",
+    "base16-tomorrow-dark-theme": "0.2.0",
+    "solarized-dark-syntax": "0.3.0",
+
+    "archive-view": "0.11.0",
+    "autocomplete": "0.11.0",
+    "autoflow": "0.5.0",
+    "autosave": "0.3.0",
+    "bookmarks": "0.8.0",
+    "bracket-matcher": "0.7.0",
+    "collaboration": "0.34.0",
+    "command-logger": "0.6.0",
+    "command-palette": "0.6.0",
+    "dev-live-reload": "0.12.0",
+    "editor-stats": "0.5.0",
+    "exception-reporting": "0.5.0",
+    "find-and-replace": "0.32.0",
+    "fuzzy-finder": "0.15.0",
+    "gfm": "0.5.0",
+    "gists": "0.6.0",
+    "git-diff": "0.12.0",
+    "github-sign-in": "0.9.0",
+    "go-to-line": "0.8.0",
+    "grammar-selector": "0.8.0",
+    "image-view": "0.7.0",
+    "link": "0.7.0",
+    "markdown-preview": "0.12.0",
+    "metrics": "0.8.0",
+    "package-generator": "0.14.0",
+    "release-notes": "0.11.0",
+    "settings-view": "0.34.0",
+    "snippets": "0.11.0",
+    "spell-check": "0.9.0",
+    "status-bar": "0.15.0",
+    "styleguide": "0.9.0",
+    "symbols-view": "0.15.0",
+    "tabs": "0.7.0",
+    "terminal": "0.14.0",
+    "timecop": "0.9.0",
+    "to-the-hubs": "0.8.0",
+    "toml": "0.3.0",
+    "tree-view": "0.22.0",
+    "visual-bell": "0.3.0",
+    "whitespace": "0.7.0",
+    "wrap-guide": "0.4.0",
+
+    "language-c": "0.2.0",
+    "language-clojure": "0.1.0",
+    "language-coffee-script": "0.1.0",
+    "language-css": "0.2.0",
+    "language-git": "0.2.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-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,31 @@
-#!/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)
+    safeExec(commands[index], 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',
+  joinCommands('cd vendor/apm', 'npm install --silent .'),
+  'npm install --silent vendor/apm',
+  echoNewLine,
+  'node node_modules/.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_modules/.bin/grunt "$@"
+  var gruntPath = path.join('node_modules', '.bin', 'grunt');
+  var args = [gruntPath].concat(process.argv.slice(2));
+  cp.safeSpawn(process.execPath, args, process.exit);
+});

script/cibuild

@@ -1,11 +1,40 @@
-#!/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/.bin/apm clean'),
+    cp.safeExec.bind(global, 'node node_modules/.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/.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=ea1f81aa5260fe2d4a844f18e0251278fbadc093 # v0.2.1
-
-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,35 @@
+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 = {};
+  }
+  var child = childProcess.exec(command, options, function(error, stdout, stderr) {
+    if (error)
+      process.exit(error.code);
+    else
+      callback(null);
+  });
+  child.stderr.pipe(process.stderr);
+  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

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/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,344 +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 "when an edit session is deserialized", ->
-    it "emits an 'edit-session-created' event and stores the edit session", ->
-      handler = jasmine.createSpy('editSessionCreatedHandler')
-      project.on 'edit-session-created', handler
-
-      editSession1 = project.open("a")
-      expect(handler.callCount).toBe 1
-      expect(project.getEditSessions().length).toBe 1
-      expect(project.getEditSessions()[0]).toBe editSession1
-
-      editSession2 = deserialize(editSession1.serialize())
-      expect(handler.callCount).toBe 2
-      expect(project.getEditSessions().length).toBe 2
-      expect(project.getEditSessions()[0]).toBe editSession1
-      expect(project.getEditSessions()[1]).toBe editSession2
-
-  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/text-mate-scope-selector-spec.coffee

@@ -1,79 +0,0 @@
-TextMateScopeSelector = require 'text-mate-scope-selector'
-
-describe "TextMateScopeSelector", ->
-  describe ".matches(scopes)", ->
-    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.b').matches(['a.b.c'])).toBeTruthy()
-      expect(new TextMateScopeSelector('a').matches(['abc'])).toBeFalsy()
-      expect(new TextMateScopeSelector('a.b-c').matches(['a.b-c.d'])).toBeTruthy()
-      expect(new TextMateScopeSelector('a.b').matches(['a.b-d'])).toBeFalsy()
-      expect(new TextMateScopeSelector('c++').matches(['c++'])).toBeTruthy()
-      expect(new TextMateScopeSelector('c++').matches(['c'])).toBeFalsy()
-      expect(new TextMateScopeSelector('a_b_c').matches(['a_b_c'])).toBeTruthy()
-      expect(new TextMateScopeSelector('a_b_c').matches(['a_b'])).toBeFalsy()
-
-    it "matches filters", ->
-      expect(new TextMateScopeSelector('R:g').matches(['g'])).toBeTruthy()
-
-    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 - c').matches(['a'])).toBeTruthy()
-      expect(new TextMateScopeSelector('-c').matches(['b'])).toBeTruthy()
-      expect(new TextMateScopeSelector('-c').matches(['c', 'b'])).toBeFalsy()
-      expect(new TextMateScopeSelector('a-b').matches(['a', 'b'])).toBeFalsy()
-      expect(new TextMateScopeSelector('a -b').matches(['a', 'b'])).toBeFalsy()
-      expect(new TextMateScopeSelector('a -c').matches(['a', 'b'])).toBeTruthy()
-      expect(new TextMateScopeSelector('a-c').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()
-      expect(new TextMateScopeSelector('a & -b').matches(['a', 'b', 'd'])).toBeFalsy()
-      expect(new TextMateScopeSelector('a & -b').matches(['a', 'd'])).toBeTruthy()
-
-    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()
-      expect(new TextMateScopeSelector('a,').matches(['a', 'c'])).toBeTruthy()
-      expect(new TextMateScopeSelector('a,').matches(['b', 'c'])).toBeFalsy()
-
-    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()
-
-  describe ".toCssSelector()", ->
-    it "converts the TextMate scope selector to a CSS selector", ->
-      expect(new TextMateScopeSelector('a b c').toCssSelector()).toBe '.a .b .c'
-      expect(new TextMateScopeSelector('a.b.c').toCssSelector()).toBe '.a.b.c'
-      expect(new TextMateScopeSelector('*').toCssSelector()).toBe '*'
-      expect(new TextMateScopeSelector('a - b').toCssSelector()).toBe '.a:not(.b)'
-      expect(new TextMateScopeSelector('a & b').toCssSelector()).toBe '.a .b'
-      expect(new TextMateScopeSelector('a & -b').toCssSelector()).toBe '.a:not(.b)'
-      expect(new TextMateScopeSelector('a | b').toCssSelector()).toBe '.a, .b'
-      expect(new TextMateScopeSelector('a - (b.c d)').toCssSelector()).toBe '.a:not(.b.c .d)'
-      expect(new TextMateScopeSelector('a, b').toCssSelector()).toBe '.a, .b'

spec/app/theme-manager-spec.coffee

@@ -1,32 +0,0 @@
-$ = require 'jquery'
-
-Theme = require 'theme'
-ThemeManager = require 'theme-manager'
-
-describe "ThemeManager", ->
-  describe "when the core.themes config value changes", ->
-    it "add/removes stylesheets to reflect the new config value", ->
-      themeManager = new ThemeManager()
-      spyOn(themeManager, 'getUserStylesheetPath').andCallFake -> null
-      themeManager.load()
-      config.set('core.themes', [])
-      expect($('style.userTheme').length).toBe 0
-
-      config.set('core.themes', ['atom-dark-syntax'])
-      expect($('style.userTheme').length).toBe 1
-      expect($('style.userTheme:eq(0)').attr('id')).toMatch /atom-dark-syntax.less$/
-
-      config.set('core.themes', ['atom-light-syntax', 'atom-dark-syntax'])
-      expect($('style.userTheme').length).toBe 2
-      expect($('style.userTheme:eq(0)').attr('id')).toMatch /atom-light-syntax.less$/
-      expect($('style.userTheme:eq(1)').attr('id')).toMatch /atom-dark-syntax.less$/
-
-      config.set('core.themes', [])
-      expect($('style.userTheme').length).toBe 0
-
-  describe "when a theme fails to load", ->
-    it "logs a warning", ->
-      themeManager = new ThemeManager()
-      spyOn(console, 'warn')
-      themeManager.loadTheme('a-theme-that-will-not-be-found')
-      expect(console.warn).toHaveBeenCalled()

spec/app/theme-spec.coffee

@@ -1,50 +0,0 @@
-$ = require 'jquery'
-fsUtils = require 'fs-utils'
-path = require 'path'
-Theme = require 'theme'
-
-describe "Theme", ->
-  theme = null
-
-  beforeEach ->
-    $("#jasmine-content").append $("<div class='editor'></div>")
-
-  afterEach ->
-    theme.deactivate()
-
-  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 = new Theme(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 = new Theme(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 = new Theme(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 = new Theme(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 = 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 = 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 = 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 = 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 = 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 = 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')
@@ -24,9 +23,6 @@ class AtomReporter extends View
       @div outlet: 'coreArea', =>
         @div outlet: 'coreHeader', class: 'symbolHeader'
         @ul outlet: 'coreSummary', class: 'symbolSummary list-unstyled'
-      @div outlet: 'internalArea', =>
-        @div outlet: 'internalHeader', class: 'symbolHeader'
-        @ul outlet: 'internalSummary', class: 'symbolSummary list-unstyled'
       @div outlet: 'bundledArea', =>
         @div outlet: 'bundledHeader', class: 'symbolHeader'
         @ul outlet: 'bundledSummary', class: 'symbolSummary list-unstyled'
@@ -57,6 +53,7 @@ class AtomReporter extends View
     $(document.body).append this
 
   reportRunnerResults: (runner) ->
+    @updateSpecCounts()
     if @failedCount == 0
       @message.text "Success!"
     else
@@ -94,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()
@@ -110,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
@@ -126,22 +126,18 @@ 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
-    internalPackageSpecs = 0
     bundledPackageSpecs = 0
     userPackageSpecs = 0
     for spec in specs
-      symbol = $$ -> @li class: "spec-summary pending spec-summary-#{spec.id}"
+      symbol = $$ -> @li id: "spec-summary-#{spec.id}", class: "spec-summary pending"
       switch spec.specType
         when 'core'
           coreSpecs++
           @coreSummary.append symbol
-        when 'internal'
-          internalPackageSpecs++
-          @internalSummary.append symbol
         when 'bundled'
           bundledPackageSpecs++
           @bundledSummary.append symbol
@@ -153,10 +149,6 @@ class AtomReporter extends View
       @coreHeader.text("Core Specs (#{coreSpecs}):")
     else
       @coreArea.hide()
-    if internalPackageSpecs > 0
-      @internalHeader.text("Internal Package Specs (#{internalPackageSpecs}):")
-    else
-      @internalArea.hide()
     if bundledPackageSpecs > 0
       @bundledHeader.text("Bundled Package Specs (#{bundledPackageSpecs}):")
     else
@@ -170,7 +162,7 @@ class AtomReporter extends View
     @runningSpecCount++
 
   specComplete: (spec) ->
-    specSummaryElement = $(".spec-summary-#{spec.id}")
+    specSummaryElement = $("#spec-summary-#{spec.id}")
     specSummaryElement.removeClass('pending')
     specSummaryElement.data("description", spec.getFullName())
 
@@ -196,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: ->
@@ -205,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()
 
@@ -233,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

@@ -1,9 +1,7 @@
-$ = require 'jquery'
-RootView = require 'root-view'
-{$$} = require 'space-pen'
-fsUtils = require 'fs-utils'
+{$, $$, fs, RootView}  = require 'atom'
 Exec = require('child_process').exec
 path = require 'path'
+ThemeManager = require '../src/theme-manager'
 
 describe "the `atom` global", ->
   beforeEach ->
@@ -14,11 +12,22 @@ describe "the `atom` global", ->
       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')
+          spyOn(pack, 'activateStylesheets').andCallThrough()
           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
+          expect(pack.activateStylesheets).toHaveBeenCalled()
+
+        it "continues if the package has an invalid package.json", ->
+          spyOn(console, 'warn')
+          config.set("core.disabledPackages", [])
+          expect(-> atom.loadPackage("package-with-broken-package-json")).not.toThrow()
+
+        it "continues if the package has an invalid keymap", ->
+          config.set("core.disabledPackages", [])
+          expect(-> atom.loadPackage("package-with-broken-keymap")).not.toThrow()
 
     describe ".unloadPackage(name)", ->
       describe "when the package is active", ->
@@ -48,7 +57,7 @@ describe "the `atom` global", ->
         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')
+              mainModule = require('./fixtures/packages/package-with-main/main-module')
               spyOn(mainModule, 'activate')
               pack = atom.activatePackage('package-with-main')
               expect(mainModule.activate).toHaveBeenCalled()
@@ -56,7 +65,7 @@ describe "the `atom` global", ->
 
           describe "when the metadata does not specify a main module", ->
             it "requires index.coffee", ->
-              indexModule = require('fixtures/packages/package-with-index/index')
+              indexModule = require('./fixtures/packages/package-with-index/index')
               spyOn(indexModule, 'activate')
               pack = atom.activatePackage('package-with-index')
               expect(indexModule.activate).toHaveBeenCalled()
@@ -72,9 +81,9 @@ describe "the `atom` global", ->
             [mainModule, pack] = []
 
             beforeEach ->
-              mainModule = require 'fixtures/packages/package-with-activation-events/index'
+              mainModule = require './fixtures/packages/package-with-activation-events/index'
               spyOn(mainModule, 'activate').andCallThrough()
-              AtomPackage = require 'atom-package'
+              AtomPackage = require '../src/atom-package'
               spyOn(AtomPackage.prototype, 'requireMainModule').andCallThrough()
               pack = atom.activatePackage('package-with-activation-events')
 
@@ -85,7 +94,7 @@ describe "the `atom` global", ->
               expect(mainModule.activate).toHaveBeenCalled()
 
             it "triggers the activation event on all handlers registered during activation", ->
-              rootView.open()
+              rootView.openSync()
               editor = rootView.getActiveView()
               eventHandler = jasmine.createSpy("activation-event")
               editor.command 'activation-event', eventHandler
@@ -151,36 +160,70 @@ describe "the `atom` global", ->
               expect(keymap.bindingsForElement(element1)['ctrl-n']).toBe 'keymap-2'
               expect(keymap.bindingsForElement(element3)['ctrl-y']).toBeUndefined()
 
+        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.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.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 = 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()
+              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()
 
               atom.activatePackage("package-with-stylesheets-manifest")
 
-              expect(stylesheetElementForId(one)).toExist()
-              expect(stylesheetElementForId(two)).toExist()
-              expect(stylesheetElementForId(three)).not.toExist()
+              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 = 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()
+              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")
+              expect(atom.themes.stylesheetElementForId(one)).not.toExist()
+              expect(atom.themes.stylesheetElementForId(two)).not.toExist()
+              expect(atom.themes.stylesheetElementForId(three)).not.toExist()
 
               atom.activatePackage("package-with-stylesheets")
-              expect(stylesheetElementForId(one)).toExist()
-              expect(stylesheetElementForId(two)).toExist()
-              expect(stylesheetElementForId(three)).toExist()
+              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", ->
@@ -197,12 +240,12 @@ describe "the `atom` global", ->
       describe "textmate packages", ->
         it "loads the package's grammars", ->
           expect(syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-          atom.activatePackage('ruby-tmbundle', sync: true)
+          atom.activatePackage('language-ruby', 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)
+          atom.activatePackage('language-ruby', sync: true)
           expect(syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBe '# '
 
         describe "when the package has no grammars but does have preferences", ->
@@ -219,7 +262,7 @@ describe "the `atom` global", ->
 
     describe ".deactivatePackage(id)", ->
       describe "atom packages", ->
-        it "calls `deactivate` on the package's main module", ->
+        it "calls `deactivate` on the package's main module if activate was successful", ->
           pack = atom.activatePackage("package-with-deactivate")
           expect(atom.isPackageActive("package-with-deactivate")).toBeTruthy()
           spyOn(pack.mainModule, 'deactivate').andCallThrough()
@@ -228,13 +271,30 @@ describe "the `atom` global", ->
           expect(pack.mainModule.deactivate).toHaveBeenCalled()
           expect(atom.isPackageActive("package-with-module")).toBeFalsy()
 
+          spyOn(console, 'warn')
+          badPack = atom.activatePackage("package-that-throws-on-activate")
+          expect(atom.isPackageActive("package-that-throws-on-activate")).toBeTruthy()
+          spyOn(badPack.mainModule, 'deactivate').andCallThrough()
+
+          atom.deactivatePackage("package-that-throws-on-activate")
+          expect(badPack.mainModule.deactivate).not.toHaveBeenCalled()
+          expect(atom.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.activatePackage("package-that-throws-on-activate")
+          spyOn(badPack.mainModule, 'serialize').andCallThrough()
+
+          atom.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.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(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", ->
@@ -252,12 +312,12 @@ describe "the `atom` global", ->
         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()
+          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.activatePackage("package-with-scoped-properties")
@@ -265,19 +325,104 @@ describe "the `atom` global", ->
           atom.deactivatePackage("package-with-scoped-properties")
           expect(syntax.getProperty ['.source.omg'], 'editor.increaseIndentPattern').toBeUndefined()
 
-      describe "texmate packages", ->
+      describe "textmate packages", ->
         it "removes the package's grammars", ->
           expect(syntax.selectGrammar("file.rb").name).toBe "Null Grammar"
-          atom.activatePackage('ruby-tmbundle', sync: true)
+          atom.activatePackage('language-ruby', sync: true)
           expect(syntax.selectGrammar("file.rb").name).toBe "Ruby"
-          atom.deactivatePackage('ruby-tmbundle')
+          atom.deactivatePackage('language-ruby')
           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')
+          atom.activatePackage('language-ruby', sync: true)
+          atom.deactivatePackage('language-ruby')
           expect(syntax.getProperty(['.source.ruby'], 'editor.commentStart')).toBeUndefined()
 
-  describe ".getVersion", ->
-    it "returns the current version number", ->
-      expect(typeof atom.getVersion()).toBe 'string'
+    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(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(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(config.get('core.disabledPackages')).not.toContain packageName
+
+          pack = atom.packages.disablePackage(packageName)
+
+          activatedPackages = atom.packages.getActivePackages()
+          expect(activatedPackages).not.toContain(pack)
+          expect(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(config.get('core.themes')).not.toContain packageName
+          expect(config.get('core.disabledPackages')).not.toContain packageName
+
+          # enabling of theme
+          pack = atom.packages.enablePackage(packageName)
+          activatedPackages = atom.packages.getActivePackages()
+          expect(activatedPackages).toContain(pack)
+          expect(config.get('core.themes')).toContain packageName
+          expect(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(config.get('core.themes')).not.toContain packageName
+          expect(config.get('core.themes')).not.toContain packageName
+          expect(config.get('core.disabledPackages')).not.toContain packageName

spec/command-installer-spec.coffee

@@ -0,0 +1,35 @@
+{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.remove(directory) if fs.exists(directory)
+
+  it "symlinks the command and makes it executable", ->
+    fs.writeSync(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

@@ -1,9 +1,11 @@
-fs = require 'fs'
-fsUtils = require 'fs-utils'
+{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(config.set("foo.bar.baz", 42)).toBe 42
@@ -30,7 +32,7 @@ describe "Config", ->
       config.set("foo.bar.baz", 42)
 
       expect(config.save).toHaveBeenCalled()
-      expect(observeHandler).toHaveBeenCalledWith 42
+      expect(observeHandler).toHaveBeenCalledWith 42, {previous: undefined}
 
     describe "when the value equals the default value", ->
       it "does not store the value", ->
@@ -52,7 +54,18 @@ describe "Config", ->
 
       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")
+      expect(observeHandler).toHaveBeenCalledWith 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", ->
+      config.set("foo.bar.baz", ["b"])
+      observeHandler = jasmine.createSpy "observeHandler"
+      config.observe "foo.bar.baz", observeHandler
+      observeHandler.reset()
+
+      expect(config.unshiftAtKeyPath("foo.bar.baz", "a")).toBe 2
+      expect(config.get("foo.bar.baz")).toEqual ["a", "b"]
+      expect(observeHandler).toHaveBeenCalledWith 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", ->
@@ -63,7 +76,7 @@ describe "Config", ->
 
       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")
+      expect(observeHandler).toHaveBeenCalledWith config.get("foo.bar.baz"), {previous: ['a', 'b', 'c']}
 
   describe ".getPositiveInt(keyPath, defaultValue)", ->
     it "returns the proper current or default value", ->
@@ -77,8 +90,10 @@ describe "Config", ->
       expect(config.getPositiveInt('editor.preferredLineLength', 80)).toBe 80
 
   describe ".save()", ->
+    nodeFs = require 'fs'
+
     beforeEach ->
-      spyOn(fs, 'writeFileSync')
+      spyOn(nodeFs, 'writeFileSync')
       jasmine.unspy config, 'save'
 
     describe "when ~/.atom/config.json exists", ->
@@ -89,11 +104,11 @@ describe "Config", ->
         config.set("x.y.z", 3)
         config.setDefaults("a.b", e: 4, f: 5)
 
-        fs.writeFileSync.reset()
+        nodeFs.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(nodeFs.writeFileSync.argsForCall[0][0]).toBe(path.join(config.configDirPath, "config.json"))
+        writtenConfig = JSON.parse(nodeFs.writeFileSync.argsForCall[0][1])
         expect(writtenConfig).toEqual config.settings
 
     describe "when ~/.atom/config.json doesn't exist", ->
@@ -104,12 +119,12 @@ describe "Config", ->
         config.set("x.y.z", 3)
         config.setDefaults("a.b", e: 4, f: 5)
 
-        fs.writeFileSync.reset()
+        nodeFs.writeFileSync.reset()
         config.save()
 
-        expect(fs.writeFileSync.argsForCall[0][0]).toBe(path.join(config.configDirPath, "config.cson"))
+        expect(nodeFs.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)
+        writtenConfig = CoffeeScript.eval(nodeFs.writeFileSync.argsForCall[0][1], bare: true)
         expect(writtenConfig).toEqual config.settings
 
   describe ".setDefaults(keyPath, defaults)", ->
@@ -138,34 +153,34 @@ describe "Config", ->
     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")
+      expect(observeHandler).toHaveBeenCalledWith("value 2", {previous: 'value 1'})
       observeHandler.reset()
 
       config.set('foo.bar.baz', "value 1")
-      expect(observeHandler).toHaveBeenCalledWith("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
       config.set('foo.bar.baz', undefined)
-      expect(observeHandler).toHaveBeenCalledWith(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
       config.set("foo.bar", undefined)
 
-      expect(observeHandler).toHaveBeenCalledWith(undefined)
+      expect(observeHandler).toHaveBeenCalledWith(undefined, {previous: 'value 1'})
       observeHandler.reset()
 
       config.set("foo.bar.baz", "i'm back")
-      expect(observeHandler).toHaveBeenCalledWith("i'm back")
+      expect(observeHandler).toHaveBeenCalledWith("i'm back", {previous: undefined})
 
   describe ".initializeConfigDirectory()", ->
     beforeEach ->
-      config.configDirPath = '/tmp/dot-atom-dir'
-      expect(fsUtils.exists(config.configDirPath)).toBeFalsy()
+      config.configDirPath = dotAtomPath
+      expect(fs.exists(config.configDirPath)).toBeFalsy()
 
     afterEach ->
-      fsUtils.remove('/tmp/dot-atom-dir') if fsUtils.exists('/tmp/dot-atom-dir')
+      fs.remove(dotAtomPath) if fs.exists(dotAtomPath)
 
     describe "when the configDirPath doesn't exist", ->
       it "copies the contents of dot-atom to ~/.atom", ->
@@ -177,24 +192,23 @@ describe "Config", ->
         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()
+          expect(fs.exists(config.configDirPath)).toBeTruthy()
+          expect(fs.exists(path.join(config.configDirPath, 'packages'))).toBeTruthy()
+          expect(fs.exists(path.join(config.configDirPath, 'snippets'))).toBeTruthy()
+          expect(fs.isFileSync(path.join(config.configDirPath, 'config.cson'))).toBeTruthy()
 
   describe ".loadUserConfig()", ->
     beforeEach ->
-      config.configDirPath = '/tmp/dot-atom-dir'
+      config.configDirPath = dotAtomPath
       config.configFilePath = path.join(config.configDirPath, "config.cson")
-      expect(fsUtils.exists(config.configDirPath)).toBeFalsy()
+      expect(fs.exists(config.configDirPath)).toBeFalsy()
 
     afterEach ->
-      fsUtils.remove('/tmp/dot-atom-dir') if fsUtils.exists('/tmp/dot-atom-dir')
+      fs.remove(dotAtomPath) if fs.exists(dotAtomPath)
 
     describe "when the config file contains valid cson", ->
       beforeEach ->
-        fsUtils.writeSync(config.configFilePath, "foo: bar: 'baz'")
+        fs.writeSync(config.configFilePath, "foo: bar: 'baz'")
         config.loadUserConfig()
 
       it "updates the config data based on the file contents", ->
@@ -203,7 +217,7 @@ describe "Config", ->
     describe "when the config file contains invalid cson", ->
       beforeEach ->
         spyOn(console, 'error')
-        fsUtils.writeSync(config.configFilePath, "{{{{{")
+        fs.writeSync(config.configFilePath, "{{{{{")
 
       it "logs an error to the console and does not overwrite the config file on a subsequent save", ->
         config.loadUserConfig()
@@ -213,19 +227,19 @@ describe "Config", ->
 
     describe "when the config file does not exist", ->
       it "creates it with an empty object", ->
-        fsUtils.makeTree(config.configDirPath)
+        fs.makeTree(config.configDirPath)
         config.loadUserConfig()
-        expect(fsUtils.exists(config.configFilePath)).toBe true
+        expect(fs.exists(config.configFilePath)).toBe true
         expect(CSON.readFileSync(config.configFilePath)).toEqual {}
 
   describe ".observeUserConfig()", ->
     updatedHandler = null
 
     beforeEach ->
-      config.configDirPath = '/tmp/dot-atom-dir'
+      config.configDirPath = dotAtomPath
       config.configFilePath = path.join(config.configDirPath, "config.cson")
-      expect(fsUtils.exists(config.configDirPath)).toBeFalsy()
-      fsUtils.writeSync(config.configFilePath, "foo: bar: 'baz'")
+      expect(fs.exists(config.configDirPath)).toBeFalsy()
+      fs.writeSync(config.configFilePath, "foo: bar: 'baz'")
       config.loadUserConfig()
       config.observeUserConfig()
       updatedHandler = jasmine.createSpy("updatedHandler")
@@ -233,11 +247,11 @@ describe "Config", ->
 
     afterEach ->
       config.unobserveUserConfig()
-      fsUtils.remove('/tmp/dot-atom-dir') if fsUtils.exists('/tmp/dot-atom-dir')
+      fs.remove(dotAtomPath) if fs.exists(dotAtomPath)
 
     describe "when the config file changes to contain valid cson", ->
       it "updates the config data", ->
-        fsUtils.writeSync(config.configFilePath, "foo: { bar: 'quux', baz: 'bar'}")
+        fs.writeSync(config.configFilePath, "foo: { bar: 'quux', baz: 'bar'}")
         waitsFor 'update event', -> updatedHandler.callCount > 0
         runs ->
           expect(config.get('foo.bar')).toBe 'quux'
@@ -246,7 +260,7 @@ describe "Config", ->
     describe "when the config file changes to contain invalid cson", ->
       beforeEach ->
         spyOn(console, 'error')
-        fsUtils.writeSync(config.configFilePath, "}}}")
+        fs.writeSync(config.configFilePath, "}}}")
         waitsFor "error to be logged", -> console.error.callCount > 0
 
       it "logs a warning and does not update config data", ->
@@ -257,7 +271,7 @@ describe "Config", ->
 
       describe "when the config file subsequently changes again to contain valid cson", ->
         beforeEach ->
-          fsUtils.writeSync(config.configFilePath, "foo: bar: 'baz'")
+          fs.writeSync(config.configFilePath, "foo: bar: 'baz'")
           waitsFor 'update event', -> updatedHandler.callCount > 0
 
         it "updates the config data and resumes saving", ->

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

spec/directory-spec.coffee

@@ -1,12 +1,12 @@
-Directory = require 'directory'
-fsUtils = require 'fs-utils'
+Directory = require '../src/directory'
+{fs} = require 'atom'
 path = require 'path'
 
 describe "Directory", ->
   directory = null
 
   beforeEach ->
-    directory = new Directory(fsUtils.resolveOnLoadPath('fixtures'))
+    directory = new Directory(path.join(__dirname, 'fixtures'))
 
   afterEach ->
     directory.off()
@@ -15,11 +15,11 @@ describe "Directory", ->
     temporaryFilePath = null
 
     beforeEach ->
-      temporaryFilePath = path.join(fsUtils.resolveOnLoadPath('fixtures'), 'temporary')
-      fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
+      temporaryFilePath = path.join(__dirname, 'fixtures', 'temporary')
+      fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
 
     afterEach ->
-      fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
+      fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
 
     it "triggers 'contents-changed' event handlers", ->
       changeHandler = null
@@ -27,13 +27,13 @@ describe "Directory", ->
       runs ->
         changeHandler = jasmine.createSpy('changeHandler')
         directory.on 'contents-changed', changeHandler
-        fsUtils.writeSync(temporaryFilePath, '')
+        fs.writeSync(temporaryFilePath, '')
 
       waitsFor "first change", -> changeHandler.callCount > 0
 
       runs ->
         changeHandler.reset()
-        fsUtils.remove(temporaryFilePath)
+        fs.remove(temporaryFilePath)
 
       waitsFor "second change", -> changeHandler.callCount > 0
 
@@ -42,10 +42,10 @@ describe "Directory", ->
 
     beforeEach ->
       temporaryFilePath = path.join(directory.path, 'temporary')
-      fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
+      fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
 
     afterEach ->
-      fsUtils.remove(temporaryFilePath) if fsUtils.exists(temporaryFilePath)
+      fs.remove(temporaryFilePath) if fs.exists(temporaryFilePath)
 
     it "no longer triggers events", ->
       changeHandler = null
@@ -53,7 +53,7 @@ describe "Directory", ->
       runs ->
         changeHandler = jasmine.createSpy('changeHandler')
         directory.on 'contents-changed', changeHandler
-        fsUtils.writeSync(temporaryFilePath, '')
+        fs.writeSync(temporaryFilePath, '')
 
       waitsFor "change event", -> changeHandler.callCount > 0
 
@@ -62,7 +62,7 @@ describe "Directory", ->
         directory.off()
       waits 20
 
-      runs -> fsUtils.remove(temporaryFilePath)
+      runs -> fs.remove(temporaryFilePath)
       waits 20
       runs -> expect(changeHandler.callCount).toBe 0
 
@@ -84,9 +84,9 @@ describe "Directory", ->
       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')
+      symlinkPath = path.join(__dirname, 'fixtures', 'symlink-to-dir')
       symlinkDirectory = new Directory(symlinkPath)
-      realFilePath = fsUtils.resolveOnLoadPath('fixtures/dir/a')
+      realFilePath = require.resolve('./fixtures/dir/a')
       expect(symlinkDirectory.relativize(symlinkPath)).toBe ''
       expect(symlinkDirectory.relativize(realFilePath)).toBe 'a'
 
@@ -97,13 +97,13 @@ describe "Directory", ->
     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, "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')
+      symlinkPath = path.join(__dirname, 'fixtures', 'symlink-to-dir')
       symlinkDirectory = new Directory(symlinkPath)
-      realFilePath = fsUtils.resolveOnLoadPath('fixtures/dir/a')
+      realFilePath = require.resolve('./fixtures/dir/a')
       expect(symlinkDirectory.contains(realFilePath)).toBe true
 
     it "returns false if the directory's path is not a prefix of the path", ->

spec/display-buffer-spec.coffee

@@ -1,20 +1,55 @@
-DisplayBuffer = require 'display-buffer'
-Buffer = require 'text-buffer'
-_ = require 'underscore'
+DisplayBuffer = require '../src/display-buffer'
+{_} = require 'atom'
 
 describe "DisplayBuffer", ->
   [displayBuffer, buffer, changeHandler, tabLength] = []
   beforeEach ->
     tabLength = 2
-    atom.activatePackage('javascript-tmbundle', sync: true)
-    buffer = project.bufferForPath('sample.js')
-    displayBuffer = new DisplayBuffer(buffer, { tabLength })
-    displayBuffer.on 'changed', changeHandler = jasmine.createSpy 'changeHandler'
+    atom.activatePackage('language-javascript', sync: true)
+    buffer = project.bufferForPathSync('sample.js')
+    displayBuffer = new DisplayBuffer({buffer, tabLength})
+    changeHandler = jasmine.createSpy 'changeHandler'
+    displayBuffer.on 'changed', changeHandler
 
   afterEach ->
     displayBuffer.destroy()
     buffer.release()
 
+  describe "@deserialize(state)", ->
+    it "constructs a display buffer with the same buffer, folds, editorWidthInChars, and tabLength", ->
+      displayBuffer.setTabLength(4)
+      displayBuffer.setEditorWidthInChars(64)
+      displayBuffer.createFold(2, 4)
+      displayBuffer2 = deserialize(displayBuffer.serialize())
+      expect(displayBuffer2.id).toBe displayBuffer.id
+      expect(displayBuffer2.buffer).toBe displayBuffer.buffer
+      expect(displayBuffer2.tokenizedBuffer.buffer).toBe displayBuffer.tokenizedBuffer.buffer
+      expect(displayBuffer2.isFoldedAtBufferRow(2)).toBeTruthy()
+      expect(displayBuffer2.getSoftWrapColumn()).toBe displayBuffer.getSoftWrapColumn()
+      expect(displayBuffer2.getTabLength()).toBe displayBuffer.getTabLength()
+
+  describe ".copy()", ->
+    it "creates a new DisplayBuffer with the same initial state", ->
+      marker1 = displayBuffer.markBufferRange([[1, 2], [3, 4]], id: 1)
+      marker2 = displayBuffer.markBufferRange([[2, 3], [4, 5]], isReversed: true, id: 2)
+      marker3 = displayBuffer.markBufferPosition([5, 6], id: 3)
+      displayBuffer.createFold(3, 5)
+
+      displayBuffer2 = displayBuffer.copy()
+      expect(displayBuffer2.id).not.toBe displayBuffer.id
+      expect(displayBuffer2.buffer).toBe displayBuffer.buffer
+      expect(displayBuffer2.getTabLength()).toBe displayBuffer.getTabLength()
+
+      expect(displayBuffer2.getMarkerCount()).toEqual displayBuffer.getMarkerCount()
+      expect(displayBuffer2.findMarker(id: 1)).toEqual marker1
+      expect(displayBuffer2.findMarker(id: 2)).toEqual marker2
+      expect(displayBuffer2.findMarker(id: 3)).toEqual marker3
+      expect(displayBuffer2.isFoldedAtBufferRow(3)).toBeTruthy()
+
+      # can diverge from origin
+      displayBuffer2.destroyFoldsContainingBufferRow(3)
+      expect(displayBuffer2.isFoldedAtBufferRow(3)).not.toBe displayBuffer.isFoldedAtBufferRow(3)
+
   describe "when the buffer changes", ->
     it "renders line numbers correctly", ->
       originalLineCount = displayBuffer.getLineCount()
@@ -24,10 +59,23 @@ describe "DisplayBuffer", ->
 
   describe "soft wrapping", ->
     beforeEach ->
-      displayBuffer.setSoftWrapColumn(50)
+      displayBuffer.setSoftWrap(true)
+      displayBuffer.setEditorWidthInChars(50)
       changeHandler.reset()
 
     describe "rendering of soft-wrapped lines", ->
+      describe "when editor.softWrapAtPreferredLineLength is set", ->
+        it "uses the preferred line length as the soft wrap column when it is less than the configured soft wrap column", ->
+          config.set('editor.preferredLineLength', 100)
+          config.set('editor.softWrapAtPreferredLineLength', true)
+          expect(displayBuffer.lineForRow(10).text).toBe '    return '
+
+          config.set('editor.preferredLineLength', 5)
+          expect(displayBuffer.lineForRow(10).text).toBe 'funct'
+
+          config.set('editor.softWrapAtPreferredLineLength', false)
+          expect(displayBuffer.lineForRow(10).text).toBe '    return '
+
       describe "when the line is shorter than the max line length", ->
         it "renders the line unchanged", ->
           expect(displayBuffer.lineForRow(0).text).toBe buffer.lineForRow(0)
@@ -45,7 +93,7 @@ describe "DisplayBuffer", ->
         describe "when there is no whitespace before the boundary", ->
           it "wraps the line exactly at the boundary since there's no more graceful place to wrap it", ->
             buffer.change([[0, 0], [1, 0]], 'abcdefghijklmnopqrstuvwxyz\n')
-            displayBuffer.setSoftWrapColumn(10)
+            displayBuffer.setEditorWidthInChars(10)
             expect(displayBuffer.lineForRow(0).text).toBe 'abcdefghij'
             expect(displayBuffer.lineForRow(1).text).toBe 'klmnopqrst'
             expect(displayBuffer.lineForRow(2).text).toBe 'uvwxyz'
@@ -104,6 +152,20 @@ describe "DisplayBuffer", ->
 
           expect(changeHandler).toHaveBeenCalledWith(start: 3, end: 9, screenDelta: -6, bufferDelta: -4)
 
+      describe "when a newline is inserted, deleted, and re-inserted at the end of a wrapped line (regression)", ->
+        it "correctly renders the original wrapped line", ->
+          buffer = project.buildBufferSync(null, '')
+          displayBuffer = new DisplayBuffer({buffer, tabLength, editorWidthInChars: 30, softWrap: true})
+
+          buffer.insert([0, 0], "the quick brown fox jumps over the lazy dog.")
+          buffer.insert([0, Infinity], '\n')
+          buffer.delete([[0, Infinity], [1, 0]])
+          buffer.insert([0, Infinity], '\n')
+
+          expect(displayBuffer.lineForRow(0).text).toBe "the quick brown fox jumps over "
+          expect(displayBuffer.lineForRow(1).text).toBe "the lazy dog."
+          expect(displayBuffer.lineForRow(2).text).toBe ""
+
     describe "position translation", ->
       it "translates positions accounting for wrapped lines", ->
         # before any wrapped lines
@@ -132,9 +194,9 @@ describe "DisplayBuffer", ->
         expect(displayBuffer.bufferPositionForScreenPosition([3, -5])).toEqual([3, 0])
         expect(displayBuffer.bufferPositionForScreenPosition([3, Infinity])).toEqual([3, 50])
 
-    describe ".setSoftWrapColumn(length)", ->
+    describe ".setEditorWidthInChars(length)", ->
       it "changes the length at which lines are wrapped and emits a change event for all screen lines", ->
-        displayBuffer.setSoftWrapColumn(40)
+        displayBuffer.setEditorWidthInChars(40)
         expect(tokensText displayBuffer.lineForRow(4).tokens).toBe 'left = [], right = [];'
         expect(tokensText displayBuffer.lineForRow(5).tokens).toBe '    while(items.length > 0) {'
         expect(tokensText displayBuffer.lineForRow(12).tokens).toBe 'sort(left).concat(pivot).concat(sort(rig'
@@ -144,14 +206,15 @@ describe "DisplayBuffer", ->
     beforeEach ->
       displayBuffer.destroy()
       buffer.release()
-      buffer = project.bufferForPath('two-hundred.txt')
-      displayBuffer = new DisplayBuffer(buffer, { tabLength })
+      buffer = project.bufferForPathSync('two-hundred.txt')
+      displayBuffer = new DisplayBuffer({buffer, tabLength})
       displayBuffer.on 'changed', changeHandler
 
     describe "when folds are created and destroyed", ->
       describe "when a fold spans multiple lines", ->
         it "replaces the lines spanned by the fold with a placeholder that references the fold object", ->
           fold = displayBuffer.createFold(4, 7)
+          expect(fold).toBeDefined()
 
           [line4, line5] = displayBuffer.linesForRows(4, 5)
           expect(line4.fold).toBe fold
@@ -250,7 +313,7 @@ describe "DisplayBuffer", ->
 
       describe "when there is another display buffer pointing to the same buffer", ->
         it "does not create folds in the other display buffer", ->
-          otherDisplayBuffer = new DisplayBuffer(buffer, { tabLength })
+          otherDisplayBuffer = new DisplayBuffer({buffer, tabLength})
           displayBuffer.createFold(2, 4)
           expect(otherDisplayBuffer.foldsStartingAtBufferRow(2).length).toBe 0
 
@@ -274,7 +337,7 @@ describe "DisplayBuffer", ->
           expect(changeHandler).toHaveBeenCalledWith(start: 1, end: 3, screenDelta: -2, bufferDelta: -4)
 
         describe "when the changes is subsequently undone", ->
-          it "restores destroyed folds", ->
+          xit "restores destroyed folds", ->
             buffer.undo()
             expect(displayBuffer.lineForRow(2).text).toBe '2'
             expect(displayBuffer.lineForRow(2).fold).toBe fold1
@@ -454,7 +517,8 @@ describe "DisplayBuffer", ->
 
   describe ".clipScreenPosition(screenPosition, wrapBeyondNewlines: false, wrapAtSoftNewlines: false, skipAtomicTokens: false)", ->
     beforeEach ->
-      displayBuffer.setSoftWrapColumn(50)
+      displayBuffer.setSoftWrap(true)
+      displayBuffer.setEditorWidthInChars(50)
 
     it "allows valid positions", ->
       expect(displayBuffer.clipScreenPosition([4, 5])).toEqual [4, 5]
@@ -601,8 +665,8 @@ describe "DisplayBuffer", ->
           oldTailBufferPosition: [8, 4]
           newTailScreenPosition: [5, 4]
           newTailBufferPosition: [8, 4]
-          bufferChanged: false
-          valid: true
+          textChanged: false
+          isValid: true
         }
         markerChangedHandler.reset()
 
@@ -617,8 +681,8 @@ describe "DisplayBuffer", ->
           oldTailBufferPosition: [8, 4]
           newTailScreenPosition: [5, 4]
           newTailBufferPosition: [8, 4]
-          bufferChanged: true
-          valid: true
+          textChanged: true
+          isValid: true
         }
         markerChangedHandler.reset()
 
@@ -633,8 +697,8 @@ describe "DisplayBuffer", ->
           oldTailBufferPosition: [8, 4]
           newTailScreenPosition: [8, 4]
           newTailBufferPosition: [8, 4]
-          bufferChanged: false
-          valid: true
+          textChanged: false
+          isValid: true
         }
         markerChangedHandler.reset()
 
@@ -649,8 +713,8 @@ describe "DisplayBuffer", ->
           oldTailBufferPosition: [8, 4]
           newTailScreenPosition: [5, 4]
           newTailBufferPosition: [8, 4]
-          bufferChanged: false
-          valid: true
+          textChanged: false
+          isValid: true
         }
 
       it "triggers the 'changed' event whenever the marker tail's position changes in the buffer or on screen", ->
@@ -665,8 +729,8 @@ describe "DisplayBuffer", ->
           oldTailBufferPosition: [8, 4]
           newTailScreenPosition: [8, 20]
           newTailBufferPosition: [11, 20]
-          bufferChanged: false
-          valid: true
+          textChanged: false
+          isValid: true
         }
         markerChangedHandler.reset()
 
@@ -681,24 +745,24 @@ describe "DisplayBuffer", ->
           oldTailBufferPosition: [11, 20]
           newTailScreenPosition: [8, 23]
           newTailBufferPosition: [11, 23]
-          bufferChanged: true
-          valid: true
+          textChanged: true
+          isValid: true
         }
 
-      it "triggers the 'changed' event whenever the marker is invalidated or revalidated", ->
+      xit "triggers the 'changed' event whenever the marker is invalidated or revalidated", ->
         buffer.deleteRow(8)
         expect(markerChangedHandler).toHaveBeenCalled()
         expect(markerChangedHandler.argsForCall[0][0]).toEqual {
           oldHeadScreenPosition: [5, 10]
           oldHeadBufferPosition: [8, 10]
           newHeadScreenPosition: [5, 10]
-          newHeadBufferPosition: [8, 10]
+          newHeadBufferPosition: [8, 0]
           oldTailScreenPosition: [5, 4]
           oldTailBufferPosition: [8, 4]
           newTailScreenPosition: [5, 4]
-          newTailBufferPosition: [8, 4]
-          bufferChanged: true
-          valid: false
+          newTailBufferPosition: [8, 0]
+          textChanged: true
+          isValid: false
         }
 
         markerChangedHandler.reset()
@@ -714,15 +778,15 @@ describe "DisplayBuffer", ->
           oldTailBufferPosition: [8, 4]
           newTailScreenPosition: [5, 4]
           newTailBufferPosition: [8, 4]
-          bufferChanged: true
-          valid: true
+          textChanged: true
+          isValid: true
         }
 
       it "does not call the callback for screen changes that don't change the position of the marker", ->
         displayBuffer.createFold(10, 11)
         expect(markerChangedHandler).not.toHaveBeenCalled()
 
-      it "updates markers before emitting buffer change events, but does not notify their observers until the change event", ->
+      xit "updates markers before emitting buffer change events, but does not notify their observers until the change event", ->
         marker2 = displayBuffer.markBufferRange([[8, 1], [8, 1]])
         marker2.on 'changed', marker2ChangedHandler = jasmine.createSpy("marker2ChangedHandler")
         displayBuffer.on 'changed', changeHandler = jasmine.createSpy("changeHandler").andCallFake -> onDisplayBufferChange()
@@ -839,3 +903,15 @@ describe "DisplayBuffer", ->
         marker2.on 'destroyed', destroyedHandler
         buffer.getMarker(marker2.id).destroy()
         expect(destroyedHandler).toHaveBeenCalled()
+
+    describe "DisplayBufferMarker.copy(attributes)", ->
+      it "creates a copy of the marker with the given attributes merged in", ->
+        initialMarkerCount = displayBuffer.getMarkerCount()
+        marker1 = displayBuffer.markScreenRange([[5, 4], [5, 10]], a: 1, b: 2)
+        expect(displayBuffer.getMarkerCount()).toBe initialMarkerCount + 1
+
+        marker2 = marker1.copy(b: 3)
+        expect(marker2.getBufferRange()).toEqual marker1.getBufferRange()
+        expect(displayBuffer.getMarkerCount()).toBe initialMarkerCount + 2
+        expect(marker1.getAttributes()).toEqual a: 1, b: 2
+        expect(marker2.getAttributes()).toEqual a: 1, b: 3

spec/edit-session-replication-spec.coffee

@@ -0,0 +1,62 @@
+{Site} = require 'telepath'
+Environment = require './environment'
+
+describe "EditSession replication", ->
+  [env1, env2, editSession1, editSession2] = []
+  beforeEach ->
+    env1 = new Environment(siteId: 1)
+    env2 = env1.clone(siteId: 2)
+    envConnection = env1.connect(env2)
+    doc2 = null
+
+    env1.run ->
+      editSession1 = project.openSync('sample.js')
+      editSession1.setScrollTop(5)
+      editSession1.setScrollLeft(5)
+      editSession1.setCursorScreenPosition([0, 5])
+      editSession1.addSelectionForBufferRange([[1, 2], [3, 4]])
+      doc1 = editSession1.getState()
+      doc2 = doc1.clone(env2.site)
+      envConnection.connect(doc1, doc2)
+
+    env2.run ->
+      editSession2 = deserialize(doc2)
+
+  afterEach ->
+    env1.destroy()
+    env2.destroy()
+
+  it "replicates the selections of existing replicas", ->
+    expect(editSession2.getRemoteSelectedBufferRanges()).toEqual editSession1.getSelectedBufferRanges()
+
+    editSession1.getLastSelection().setBufferRange([[2, 3], [4, 5]])
+    expect(editSession2.getRemoteSelectedBufferRanges()).toEqual editSession1.getSelectedBufferRanges()
+
+    editSession1.addCursorAtBufferPosition([5, 6])
+    expect(editSession2.getRemoteSelectedBufferRanges()).toEqual editSession1.getSelectedBufferRanges()
+
+    editSession1.consolidateSelections()
+    expect(editSession2.getRemoteSelectedBufferRanges()).toEqual editSession1.getSelectedBufferRanges()
+
+  it "introduces a local cursor for a new replica at the position of the last remote cursor", ->
+    expect(editSession2.getCursors().length).toBe 1
+    expect(editSession2.getSelections().length).toBe 1
+    expect(editSession2.getCursorBufferPosition()).toEqual [3, 4]
+    expect(editSession2.getSelectedBufferRanges()).toEqual [[[3, 4], [3, 4]]]
+
+    expect(editSession1.getRemoteCursors().length).toBe 1
+    expect(editSession1.getRemoteSelections().length).toBe 1
+    [cursor] = editSession1.getRemoteCursors()
+    [selection] = editSession1.getRemoteSelections()
+    expect(cursor.getBufferPosition()).toEqual [3, 4]
+    expect(selection.getBufferRange()).toEqual [[3, 4], [3, 4]]
+
+  it "replicates the scroll position", ->
+    expect(editSession2.getScrollTop()).toBe editSession1.getScrollTop()
+    expect(editSession2.getScrollLeft()).toBe editSession1.getScrollLeft()
+
+    editSession1.setScrollTop(10)
+    expect(editSession2.getScrollTop()).toBe 10
+
+    editSession2.setScrollLeft(20)
+    expect(editSession1.getScrollLeft()).toBe 20

spec/editor-replication-spec.coffee

@@ -0,0 +1,37 @@
+{Site} = require 'telepath'
+Editor = require '../src/editor'
+Environment = require './environment'
+
+describe "Editor replication", ->
+  [env1, env2, editSession1, editSession2, editor1, editor2] = []
+
+  beforeEach ->
+    env1 = new Environment(siteId: 1)
+    env2 = env1.clone(siteId: 2)
+    envConnection = env1.connect(env2)
+    doc2 = null
+
+    env1.run ->
+      editSession1 = project.openSync('sample.js')
+      editSession1.setSelectedBufferRange([[1, 2], [3, 4]])
+      doc1 = editSession1.getState()
+      doc2 = doc1.clone(env2.site)
+      envConnection.connect(doc1, doc2)
+      editor1 = new Editor(editSession1)
+      editor1.attachToDom()
+
+    env2.run ->
+      editSession2 = deserialize(doc2)
+      editor2 = new Editor(editSession2)
+      editor2.attachToDom()
+
+  afterEach ->
+    env1.destroy()
+    env2.destroy()
+
+  it "displays the cursors and selections from all replicas", ->
+    expect(editor1.getSelectionViews().length).toBe 2
+    expect(editor2.getSelectionViews().length).toBe 2
+
+    expect(editor1.getCursorViews().length).toBe 2
+    expect(editor2.getCursorViews().length).toBe 2

spec/editor-spec.coffee

@@ -1,27 +1,21 @@
-RootView = require 'root-view'
-EditSession = require 'edit-session'
-Buffer = require 'text-buffer'
-Editor = require 'editor'
-Range = require 'range'
-Project = require 'project'
-$ = require 'jquery'
-{$$} = require 'space-pen'
-_ = require 'underscore'
-fsUtils = require 'fs-utils'
+{_, $, $$, fs, Editor, Range, RootView} = require 'atom'
 path = require 'path'
+temp = require 'temp'
 
 describe "Editor", ->
   [buffer, editor, editSession, cachedLineHeight, cachedCharWidth] = []
 
   beforeEach ->
-    atom.activatePackage('text-tmbundle', sync: true)
-    atom.activatePackage('javascript-tmbundle', sync: true)
-    editSession = project.open('sample.js')
+    atom.activatePackage('language-text', sync: true)
+    atom.activatePackage('language-javascript', sync: true)
+    editSession = project.openSync('sample.js')
     buffer = editSession.buffer
     editor = new Editor(editSession)
     editor.lineOverdraw = 2
     editor.isFocused = true
     editor.enableKeymap()
+    editor.calculateHeightInLines = ->
+      Math.ceil(@height() / @lineHeight)
     editor.attachToDom = ({ heightInLines, widthInChars } = {}) ->
       heightInLines ?= @getBuffer().getLineCount()
       @height(getLineHeight() * heightInLines)
@@ -39,7 +33,7 @@ describe "Editor", ->
     cachedCharWidth
 
   calcDimensions = ->
-    editorForMeasurement = new Editor(editSession: project.open('sample.js'))
+    editorForMeasurement = new Editor(editSession: project.openSync('sample.js'))
     editorForMeasurement.attachToDom()
     cachedLineHeight = editorForMeasurement.lineHeight
     cachedCharWidth = editorForMeasurement.charWidth
@@ -72,6 +66,15 @@ describe "Editor", ->
       expect(editor).not.toMatchSelector ':focus'
       expect(editor.hiddenInput).toMatchSelector ':focus'
 
+    it "does not scroll the editor (regression)", ->
+      editor.attachToDom(heightInLines: 2)
+      editor.selectAll()
+      editor.hiddenInput.blur()
+      editor.focus()
+
+      expect(editor.hiddenInput).toMatchSelector ':focus'
+      expect($(editor[0]).scrollTop()).toBe 0
+
   describe "when the hidden input is focused / unfocused", ->
     it "assigns the isFocused flag on the editor and also adds/removes the .focused css class", ->
       editor.attachToDom()
@@ -84,9 +87,9 @@ describe "Editor", ->
 
   describe "when the activeEditSession's file is modified on disk", ->
     it "triggers an alert", ->
-      filePath = "/tmp/atom-changed-file.txt"
-      fsUtils.writeSync(filePath, "")
-      editSession = project.open(filePath)
+      filePath = path.join(temp.dir, 'atom-changed-file.txt')
+      fs.writeSync(filePath, "")
+      editSession = project.openSync(filePath)
       editor.edit(editSession)
       editor.insertText("now the buffer is modified")
 
@@ -95,7 +98,7 @@ describe "Editor", ->
 
       spyOn(atom, "confirm")
 
-      fsUtils.writeSync(filePath, "a file change")
+      fs.writeSync(filePath, "a file change")
 
       waitsFor "file to trigger contents-changed event", ->
         fileChangeHandler.callCount > 0
@@ -112,26 +115,26 @@ describe "Editor", ->
     [newEditSession, newBuffer] = []
 
     beforeEach ->
-      newEditSession = project.open('two-hundred.txt')
+      newEditSession = project.openSync('two-hundred.txt')
       newBuffer = newEditSession.buffer
 
     it "updates the rendered lines, cursors, selections, scroll position, and event subscriptions to match the given edit session", ->
       editor.attachToDom(heightInLines: 5, widthInChars: 30)
-      editor.setCursorBufferPosition([3, 5])
+      editor.setCursorBufferPosition([6, 13])
       editor.scrollToBottom()
       editor.scrollLeft(150)
       previousScrollHeight = editor.verticalScrollbar.prop('scrollHeight')
       previousScrollTop = editor.scrollTop()
       previousScrollLeft = editor.scrollLeft()
 
-      newEditSession.setScrollTop(120)
+      newEditSession.setScrollTop(900)
       newEditSession.setSelectedBufferRange([[40, 0], [43, 1]])
 
       editor.edit(newEditSession)
       { firstRenderedScreenRow, lastRenderedScreenRow } = editor
       expect(editor.lineElementForScreenRow(firstRenderedScreenRow).text()).toBe newBuffer.lineForRow(firstRenderedScreenRow)
       expect(editor.lineElementForScreenRow(lastRenderedScreenRow).text()).toBe newBuffer.lineForRow(editor.lastRenderedScreenRow)
-      expect(editor.scrollTop()).toBe 120
+      expect(editor.scrollTop()).toBe 900
       expect(editor.scrollLeft()).toBe 0
       expect(editor.getSelectionView().regions[0].position().top).toBe 40 * editor.lineHeight
       editor.insertText("hello")
@@ -144,14 +147,14 @@ describe "Editor", ->
       expect(editor.verticalScrollbar.prop('scrollHeight')).toBe previousScrollHeight
       expect(editor.scrollTop()).toBe previousScrollTop
       expect(editor.scrollLeft()).toBe previousScrollLeft
-      expect(editor.getCursorView().position()).toEqual { top: 3 * editor.lineHeight, left: 5 * editor.charWidth }
+      expect(editor.getCursorView().position()).toEqual { top: 6 * editor.lineHeight, left: 13 * editor.charWidth }
       editor.insertText("goodbye")
-      expect(editor.lineElementForScreenRow(3).text()).toMatch /^    vgoodbyear/
+      expect(editor.lineElementForScreenRow(6).text()).toMatch /^      currentgoodbye/
 
     it "triggers alert if edit session's buffer goes into conflict with changes on disk", ->
-      filePath = "/tmp/atom-changed-file.txt"
-      fsUtils.writeSync(filePath, "")
-      tempEditSession = project.open(filePath)
+      filePath = path.join(temp.dir, 'atom-changed-file.txt')
+      fs.writeSync(filePath, "")
+      tempEditSession = project.openSync(filePath)
       editor.edit(tempEditSession)
       tempEditSession.insertText("a buffer change")
 
@@ -159,7 +162,7 @@ describe "Editor", ->
 
       contentsConflictedHandler = jasmine.createSpy("contentsConflictedHandler")
       tempEditSession.on 'contents-conflicted', contentsConflictedHandler
-      fsUtils.writeSync(filePath, "a file change")
+      fs.writeSync(filePath, "a file change")
       waitsFor ->
         contentsConflictedHandler.callCount > 0
 
@@ -245,11 +248,11 @@ describe "Editor", ->
     filePath = null
 
     beforeEach ->
-      filePath = "/tmp/something.txt"
-      fsUtils.writeSync(filePath, filePath)
+      filePath = path.join(temp.dir, 'something.txt')
+      fs.writeSync(filePath, filePath)
 
     afterEach ->
-      fsUtils.remove(filePath) if fsUtils.exists(filePath)
+      fs.remove(filePath) if fs.exists(filePath)
 
     it "emits event when buffer's path is changed", ->
       eventHandler = jasmine.createSpy('eventHandler')
@@ -260,7 +263,7 @@ describe "Editor", ->
     it "emits event when editor receives a new buffer", ->
       eventHandler = jasmine.createSpy('eventHandler')
       editor.on 'editor:path-changed', eventHandler
-      editor.edit(project.open(filePath))
+      editor.edit(project.openSync(filePath))
       expect(eventHandler).toHaveBeenCalled()
 
     it "stops listening to events on previously set buffers", ->
@@ -268,15 +271,15 @@ describe "Editor", ->
       oldBuffer = editor.getBuffer()
       editor.on 'editor:path-changed', eventHandler
 
-      editor.edit(project.open(filePath))
+      editor.edit(project.openSync(filePath))
       expect(eventHandler).toHaveBeenCalled()
 
       eventHandler.reset()
-      oldBuffer.saveAs("/tmp/atom-bad.txt")
+      oldBuffer.saveAs(path.join(temp.dir, 'atom-bad.txt'))
       expect(eventHandler).not.toHaveBeenCalled()
 
       eventHandler.reset()
-      editor.getBuffer().saveAs("/tmp/atom-new.txt")
+      editor.getBuffer().saveAs(path.join(temp.dir, 'atom-new.txt'))
       expect(eventHandler).toHaveBeenCalled()
 
     it "loads the grammar for the new path", ->
@@ -286,15 +289,13 @@ describe "Editor", ->
 
   describe "font family", ->
     beforeEach ->
-      expect(editor.css('font-family')).not.toBe 'Courier'
+      expect(editor.css('font-family')).toBe 'Courier'
 
     it "when there is no config in fontFamily don't set it", ->
-      expect($("head style.font-family")).not.toExist()
+      atom.config.set('editor.fontFamily', null)
+      expect(editor.css('font-family')).toBe ''
 
     describe "when the font family changes", ->
-      afterEach ->
-        editor.clearFontFamily()
-
       it "updates the font family of editors and recalculates dimensions critical to cursor positioning", ->
         editor.attachToDom(12)
         lineHeightBefore = editor.lineHeight
@@ -303,7 +304,6 @@ describe "Editor", ->
 
         config.set("editor.fontFamily", "PCMyungjo")
         expect(editor.css('font-family')).toBe 'PCMyungjo'
-        expect($("head style.editor-font-family").text()).toMatch "{font-family: PCMyungjo}"
         expect(editor.charWidth).not.toBe charWidthBefore
         expect(editor.getCursorView().position()).toEqual { top: 5 * editor.lineHeight, left: 6 * editor.charWidth }
 
@@ -317,8 +317,7 @@ describe "Editor", ->
       expect(editor.css('font-size')).not.toBe "10px"
 
     it "sets the initial font size based on the value from config", ->
-      expect($("head style.font-size")).toExist()
-      expect($("head style.font-size").text()).toMatch "{font-size: #{config.get('editor.fontSize')}px}"
+      expect(editor.css('font-size')).toBe "#{config.get('editor.fontSize')}px"
 
     describe "when the font size changes", ->
       it "updates the font sizes of editors and recalculates dimensions critical to cursor positioning", ->
@@ -404,11 +403,8 @@ describe "Editor", ->
         beforeEach ->
           editor.setFontFamily('sans-serif')
 
-        afterEach ->
-          editor.clearFontFamily()
-
         it "positions the cursor to the clicked row and column", ->
-          {top, left} = editor.pixelOffsUtilsetForScreenPosition([3, 30])
+          {top, left} = editor.pixelOffsetForScreenPosition([3, 30])
           editor.renderedLines.trigger mousedownEvent(pageX: left, pageY: top)
           expect(editor.getCursorScreenPosition()).toEqual [3, 30]
 
@@ -440,6 +436,29 @@ describe "Editor", ->
         editor.renderedLines.trigger mousedownEvent(editor: editor, point: [3, 12], originalEvent: {detail: 1}, shiftKey: true)
         expect(editor.getSelectedBufferRange()).toEqual [[3, 10], [3, 12]]
 
+      describe "when clicking between a word and a non-word", ->
+        it "selects the word", ->
+          expect(editor.getCursorScreenPosition()).toEqual(row: 0, column: 0)
+          editor.renderedLines.trigger mousedownEvent(editor: editor, point: [1, 21], originalEvent: {detail: 1})
+          editor.renderedLines.trigger 'mouseup'
+          editor.renderedLines.trigger mousedownEvent(editor: editor, point: [1, 21], originalEvent: {detail: 2})
+          editor.renderedLines.trigger 'mouseup'
+          expect(editor.getSelectedText()).toBe "function"
+
+          editor.setCursorBufferPosition([0, 0])
+          editor.renderedLines.trigger mousedownEvent(editor: editor, point: [1, 22], originalEvent: {detail: 1})
+          editor.renderedLines.trigger 'mouseup'
+          editor.renderedLines.trigger mousedownEvent(editor: editor, point: [1, 22], originalEvent: {detail: 2})
+          editor.renderedLines.trigger 'mouseup'
+          expect(editor.getSelectedText()).toBe "items"
+
+          editor.setCursorBufferPosition([0, 0])
+          editor.renderedLines.trigger mousedownEvent(editor: editor, point: [0, 28], originalEvent: {detail: 1})
+          editor.renderedLines.trigger 'mouseup'
+          editor.renderedLines.trigger mousedownEvent(editor: editor, point: [0, 28], originalEvent: {detail: 2})
+          editor.renderedLines.trigger 'mouseup'
+          expect(editor.getSelectedText()).toBe "{"
+
     describe "triple/quardruple/etc-click", ->
       it "selects the line under the cursor", ->
         expect(editor.getCursorScreenPosition()).toEqual(row: 0, column: 0)
@@ -884,13 +903,14 @@ describe "Editor", ->
         expect(editor.getSelection().isEmpty()).toBeTruthy()
         expect(cursorView).toBeVisible()
 
+      it "moves the hiddenInput to the same position with cursor's view", ->
+        editor.setCursorScreenPosition(row: 2, column: 2)
+        expect(editor.getCursorView().offset()).toEqual(editor.hiddenInput.offset())
+
       describe "when the editor is using a variable-width font", ->
         beforeEach ->
           editor.setFontFamily('sans-serif')
 
-        afterEach ->
-          editor.clearFontFamily()
-
         it "correctly positions the cursor", ->
           editor.setCursorBufferPosition([3, 30])
           expect(editor.getCursorView().position()).toEqual {top: 3 * editor.lineHeight, left: 178}
@@ -1013,7 +1033,7 @@ describe "Editor", ->
 
           describe "when soft-wrap is enabled", ->
             beforeEach ->
-              editor.setSoftWrap(true)
+              editSession.setSoftWrap(true)
 
             it "does not scroll the buffer horizontally", ->
               editor.width(charWidth * 30)
@@ -1042,10 +1062,12 @@ describe "Editor", ->
     describe "when the text exceeds the editor width and the scroll-view is horizontally scrolled", ->
       it "wraps the text and renders properly", ->
         editor.attachToDom(heightInLines: 30, widthInChars: 30)
+        editor.setWidthInChars(100)
         editor.setText("Fashion axe umami jean shorts retro hashtag carles mumblecore. Photo booth skateboard Austin gentrify occupy ethical. Food truck gastropub keffiyeh, squid deep v pinterest literally sustainable salvia scenester messenger bag. Neutra messenger bag flexitarian four loko, shoreditch VHS pop-up tumblr seitan synth master cleanse. Marfa selvage ugh, raw denim authentic try-hard mcsweeney's trust fund fashion axe actually polaroid viral sriracha. Banh mi marfa plaid single-origin coffee. Pickled mumblecore lomo ugh bespoke.")
         editor.scrollLeft(editor.charWidth * 30)
         editor.trigger "editor:toggle-soft-wrap"
         expect(editor.scrollLeft()).toBe 0
+        expect(editor.activeEditSession.getSoftWrapColumn()).not.toBe 100
 
   describe "text rendering", ->
     describe "when all lines in the buffer are visible on screen", ->
@@ -1086,8 +1108,8 @@ describe "Editor", ->
         expect(span0.children('span:eq(2)')).toMatchSelector '.meta.brace.curly.js'
         expect(span0.children('span:eq(2)').text()).toBe "{"
 
-        line12 = editor.renderedLines.find('.line:eq(11)')
-        expect(line12.find('span:eq(2)')).toMatchSelector '.keyword'
+        line12 = editor.renderedLines.find('.line:eq(11)').children('span:eq(0)')
+        expect(line12.children('span:eq(1)')).toMatchSelector '.keyword'
 
       it "wraps hard tabs in a span", ->
         editor.setText('\t<- hard tab')
@@ -1102,12 +1124,13 @@ describe "Editor", ->
         expect(span0_0).toMatchSelector '.leading-whitespace'
         expect(span0_0.text()).toBe '  '
 
-      it "wraps trailing whitespace in a span", ->
-        editor.setText('trailing whitespace ->   ')
-        line0 = editor.renderedLines.find('.line:first')
-        span0_last = line0.children('span:eq(0)').children('span:last')
-        expect(span0_last).toMatchSelector '.trailing-whitespace'
-        expect(span0_last.text()).toBe '   '
+      describe "when the line has trailing whitespace", ->
+        it "wraps trailing whitespace in a span", ->
+          editor.setText('trailing whitespace ->   ')
+          line0 = editor.renderedLines.find('.line:first')
+          span0_last = line0.children('span:eq(0)').children('span:last')
+          expect(span0_last).toMatchSelector '.trailing-whitespace'
+          expect(span0_last.text()).toBe '   '
 
       describe "when lines are updated in the buffer", ->
         it "syntax highlights the updated lines", ->
@@ -1416,7 +1439,7 @@ describe "Editor", ->
 
     describe "when autoscrolling at the end of the document", ->
       it "renders lines properly", ->
-        editor.edit(project.open('two-hundred.txt'))
+        editor.edit(project.openSync('two-hundred.txt'))
         editor.attachToDom(heightInLines: 5.5)
 
         expect(editor.renderedLines.find('.line').length).toBe 8
@@ -1479,10 +1502,13 @@ describe "Editor", ->
         expect(editor.renderedLines.find('.line:first').text()).toBe "a line that ends with a carriage return#{cr}#{eol}"
 
       describe "when wrapping is on", ->
+        beforeEach ->
+          editSession.setSoftWrap(true)
+
         it "doesn't show the end of line invisible at the end of lines broken due to wrapping", ->
-          editor.setSoftWrapColumn(6)
           editor.setText "a line that wraps"
           editor.attachToDom()
+          editor.setWidthInChars(6)
           config.set "editor.showInvisibles", true
           space = editor.invisibles?.space
           expect(space).toBeTruthy()
@@ -1492,9 +1518,9 @@ describe "Editor", ->
           expect(editor.renderedLines.find('.line:last').text()).toBe "wraps#{eol}"
 
         it "displays trailing carriage return using a visible non-empty value", ->
-          editor.setSoftWrapColumn(6)
           editor.setText "a line that\r\n"
           editor.attachToDom()
+          editor.setWidthInChars(6)
           config.set "editor.showInvisibles", true
           space = editor.invisibles?.space
           expect(space).toBeTruthy()
@@ -1619,20 +1645,22 @@ describe "Editor", ->
 
           expect(editor.renderedLines.find('.line:eq(10) .indent-guide').length).toBe 1
           expect(editor.renderedLines.find('.line:eq(10) .indent-guide').text()).toBe "#{eol} "
+          expect(editor.renderedLines.find('.line:eq(10) .invisible-character').text()).toBe eol
 
           editor.setCursorBufferPosition([9])
           editor.indent()
 
           expect(editor.renderedLines.find('.line:eq(10) .indent-guide').length).toBe 2
           expect(editor.renderedLines.find('.line:eq(10) .indent-guide').text()).toBe "#{eol}   "
+          expect(editor.renderedLines.find('.line:eq(10) .invisible-character').text()).toBe eol
 
   describe "when soft-wrap is enabled", ->
     beforeEach ->
+      editSession.setSoftWrap(true)
       editor.attachToDom()
       setEditorHeightInLines(editor, 20)
       setEditorWidthInChars(editor, 50)
-      editor.setSoftWrap(true)
-      expect(editor.activeEditSession.softWrapColumn).toBe 50
+      expect(editor.activeEditSession.getSoftWrapColumn()).toBe 50
 
     it "wraps lines that are too long to fit within the editor's width, adjusting cursor positioning accordingly", ->
       expect(editor.renderedLines.find('.line').length).toBe 16
@@ -1665,19 +1693,15 @@ describe "Editor", ->
       expect(editor.bufferPositionForScreenPosition(editor.getCursorScreenPosition())).toEqual [3, 60]
 
     it "does not wrap the lines of any newly assigned buffers", ->
-      otherEditSession = project.open()
+      otherEditSession = project.openSync()
       otherEditSession.buffer.setText([1..100].join(''))
       editor.edit(otherEditSession)
       expect(editor.renderedLines.find('.line').length).toBe(1)
 
-    it "unwraps lines and cancels window resize listener when softwrap is disabled", ->
+    it "unwraps lines when softwrap is disabled", ->
       editor.toggleSoftWrap()
       expect(editor.renderedLines.find('.line:eq(3)').text()).toBe '    var pivot = items.shift(), current, left = [], right = [];'
 
-      spyOn(editor, 'setSoftWrapColumn')
-      $(window).trigger 'resize'
-      expect(editor.setSoftWrapColumn).not.toHaveBeenCalled()
-
     it "allows the cursor to move down to the last line", ->
       _.times editor.getLastScreenRow(), -> editor.moveCursorDown()
       expect(editor.getCursorScreenPosition()).toEqual [editor.getLastScreenRow(), 0]
@@ -1700,15 +1724,15 @@ describe "Editor", ->
       editor.moveCursorRight()
       expect(editor.getCursorScreenPosition()).toEqual [11, 0]
 
-    it "calls .setSoftWrapColumn() when the editor is attached because now its dimensions are available to calculate it", ->
-      otherEditor = new Editor(editSession: project.open('sample.js'))
-      spyOn(otherEditor, 'setSoftWrapColumn')
+    it "calls .setWidthInChars() when the editor is attached because now its dimensions are available to calculate it", ->
+      otherEditor = new Editor(editSession: project.openSync('sample.js'))
+      spyOn(otherEditor, 'setWidthInChars')
 
-      otherEditor.setSoftWrap(true)
-      expect(otherEditor.setSoftWrapColumn).not.toHaveBeenCalled()
+      otherEditor.activeEditSession.setSoftWrap(true)
+      expect(otherEditor.setWidthInChars).not.toHaveBeenCalled()
 
       otherEditor.simulateDomAttachment()
-      expect(otherEditor.setSoftWrapColumn).toHaveBeenCalled()
+      expect(otherEditor.setWidthInChars).toHaveBeenCalled()
       otherEditor.remove()
 
   describe "gutter rendering", ->
@@ -1744,7 +1768,8 @@ describe "Editor", ->
 
     describe "when wrapping is on", ->
       it "renders a • instead of line number for wrapped portions of lines", ->
-        editor.setSoftWrapColumn(50)
+        editSession.setSoftWrap(true)
+        editor.setWidthInChars(50)
         expect(editor.gutter.find('.line-number').length).toEqual(8)
         expect(editor.gutter.find('.line-number:eq(3)').intValue()).toBe 4
         expect(editor.gutter.find('.line-number:eq(4)').html()).toBe '&nbsp;•'
@@ -1805,7 +1830,7 @@ describe "Editor", ->
 
     describe "when the switching from an edit session for a long buffer to an edit session for a short buffer", ->
       it "updates the line numbers to reflect the shorter buffer", ->
-        emptyEditSession = project.open(null)
+        emptyEditSession = project.openSync(null)
         editor.edit(emptyEditSession)
         expect(editor.gutter.lineNumbers.find('.line-number').length).toBe 1
 
@@ -1857,13 +1882,55 @@ describe "Editor", ->
         # doesn't allow regular editors to set grammars
         expect(-> editor.setGrammar()).toThrow()
 
-
     describe "when config.editor.showLineNumbers is false", ->
       it "doesn't render any line numbers", ->
         expect(editor.gutter.lineNumbers).toBeVisible()
         config.set("editor.showLineNumbers", false)
         expect(editor.gutter.lineNumbers).not.toBeVisible()
 
+    describe "using gutter's api", ->
+      it "can get all the line number elements", ->
+        elements = editor.gutter.getLineNumberElements()
+        len = editor.gutter.lastScreenRow - editor.gutter.firstScreenRow + 1
+        expect(elements).toHaveLength(len)
+
+      it "can get a single line number element", ->
+        element = editor.gutter.getLineNumberElement(3)
+        expect(element).toBeTruthy()
+
+      it "returns falsy when there is no line element", ->
+        expect(editor.gutter.getLineNumberElement(42)).toHaveLength 0
+
+      it "can add and remove classes to all the line numbers", ->
+        wasAdded = editor.gutter.addClassToAllLines('heyok')
+        expect(wasAdded).toBe true
+
+        elements = editor.gutter.getLineNumberElementsForClass('heyok')
+        expect($(elements)).toHaveClass('heyok')
+
+        editor.gutter.removeClassFromAllLines('heyok')
+        expect($(editor.gutter.getLineNumberElements())).not.toHaveClass('heyok')
+
+      it "can add and remove classes from a single line number", ->
+        wasAdded = editor.gutter.addClassToLine(3, 'heyok')
+        expect(wasAdded).toBe true
+
+        element = editor.gutter.getLineNumberElement(2)
+        expect($(element)).not.toHaveClass('heyok')
+
+      it "can fetch line numbers by their class", ->
+        editor.gutter.addClassToLine(1, 'heyok')
+        editor.gutter.addClassToLine(3, 'heyok')
+
+        elements = editor.gutter.getLineNumberElementsForClass('heyok')
+        expect(elements.length).toBe 2
+
+        expect($(elements[0])).toHaveClass 'line-number-1'
+        expect($(elements[0])).toHaveClass 'heyok'
+
+        expect($(elements[1])).toHaveClass 'line-number-3'
+        expect($(elements[1])).toHaveClass 'heyok'
+
   describe "gutter line highlighting", ->
     beforeEach ->
       editor.attachToDom(heightInLines: 5.5)
@@ -1883,7 +1950,7 @@ describe "Editor", ->
     describe "when there is wrapping", ->
       beforeEach ->
         editor.attachToDom(30)
-        editor.setSoftWrap(true)
+        editSession.setSoftWrap(true)
         setEditorWidthInChars(editor, 20)
 
       it "highlights the line where the initial cursor position is", ->
@@ -1946,7 +2013,7 @@ describe "Editor", ->
 
     describe "when there is wrapping", ->
       beforeEach ->
-        editor.setSoftWrap(true)
+        editSession.setSoftWrap(true)
         setEditorWidthInChars(editor, 20)
 
       it "highlights the line where the initial cursor position is", ->
@@ -1967,7 +2034,7 @@ describe "Editor", ->
 
   describe "folding", ->
     beforeEach ->
-      editSession = project.open('two-hundred.txt')
+      editSession = project.openSync('two-hundred.txt')
       buffer = editSession.buffer
       editor.edit(editSession)
       editor.attachToDom()
@@ -2024,7 +2091,7 @@ describe "Editor", ->
       it "adds/removes the 'selected' class to the fold's line element and hides the cursor if it is on the fold line", ->
         editor.createFold(2, 4)
 
-        editor.setSelectedBufferRange([[1, 0], [2, 0]], preserveFolds: true, reverse: true)
+        editor.setSelectedBufferRange([[1, 0], [2, 0]], preserveFolds: true, isReversed: true)
         expect(editor.lineElementForScreenRow(2)).toMatchSelector('.fold.selected')
 
         editor.setSelectedBufferRange([[1, 0], [1, 1]], preserveFolds: true)
@@ -2104,11 +2171,11 @@ describe "Editor", ->
 
     beforeEach ->
       filePath = project.resolve('git/working-dir/file.txt')
-      originalPathText = fsUtils.read(filePath)
-      editor.edit(project.open(filePath))
+      originalPathText = fs.read(filePath)
+      editor.edit(project.openSync(filePath))
 
     afterEach ->
-      fsUtils.writeSync(filePath, originalPathText)
+      fs.writeSync(filePath, originalPathText)
 
     it "restores the contents of the editor to the HEAD revision", ->
       editor.setText('')
@@ -2139,10 +2206,21 @@ describe "Editor", ->
         expect(editor.pixelPositionForBufferPosition([2,7])).toEqual top: 0, left: 0
 
     describe "when the editor is attached and visible", ->
-      it "returns the top and left pixel positions", ->
+      beforeEach ->
         editor.attachToDom()
+
+      it "returns the top and left pixel positions", ->
         expect(editor.pixelPositionForBufferPosition([2,7])).toEqual top: 40, left: 70
 
+      it "caches the left position", ->
+        editor.renderedLines.css('font-size', '16px')
+        expect(editor.pixelPositionForBufferPosition([2,8])).toEqual top: 40, left: 80
+
+        # make characters smaller
+        editor.renderedLines.css('font-size', '15px')
+
+        expect(editor.pixelPositionForBufferPosition([2,8])).toEqual top: 40, left: 80
+
   describe "when clicking in the gutter", ->
     beforeEach ->
       editor.attachToDom()
@@ -2219,14 +2297,15 @@ describe "Editor", ->
     [filePath] = []
 
     beforeEach ->
-      filePath = path.join(fsUtils.absolute("/tmp"), "grammar-change.txt")
-      fsUtils.writeSync(filePath, "var i;")
+      tmpdir = fs.absolute(temp.dir)
+      filePath = path.join(tmpdir, "grammar-change.txt")
+      fs.writeSync(filePath, "var i;")
 
     afterEach ->
-      fsUtils.remove(filePath) if fsUtils.exists(filePath)
+      fs.remove(filePath) if fs.exists(filePath)
 
     it "updates all the rendered lines when the grammar changes", ->
-      editor.edit(project.open(filePath))
+      editor.edit(project.openSync(filePath))
       expect(editor.getGrammar().name).toBe 'Plain Text'
       syntax.setGrammarOverrideForPath(filePath, 'source.js')
       editor.reloadGrammar()
@@ -2246,7 +2325,7 @@ describe "Editor", ->
       expect(editor.getGrammar().name).toBe 'JavaScript'
 
     it "emits an editor:grammar-changed event when updated", ->
-      editor.edit(project.open(filePath))
+      editor.edit(project.openSync(filePath))
 
       eventHandler = jasmine.createSpy('eventHandler')
       editor.on('editor:grammar-changed', eventHandler)
@@ -2567,15 +2646,16 @@ describe "Editor", ->
     it "saves the state of the rendered lines, the display buffer, and the buffer to a file of the user's choosing", ->
       saveDialogCallback = null
       spyOn(atom, 'showSaveDialog').andCallFake (callback) -> saveDialogCallback = callback
-      spyOn(fsUtils, 'writeSync')
+      spyOn(fs, 'writeSync')
 
       editor.trigger 'editor:save-debug-snapshot'
 
+      statePath = path.join(temp.dir, 'state')
       expect(atom.showSaveDialog).toHaveBeenCalled()
-      saveDialogCallback('/tmp/state')
-      expect(fsUtils.writeSync).toHaveBeenCalled()
-      expect(fsUtils.writeSync.argsForCall[0][0]).toBe '/tmp/state'
-      expect(typeof fsUtils.writeSync.argsForCall[0][1]).toBe 'string'
+      saveDialogCallback(statePath)
+      expect(fs.writeSync).toHaveBeenCalled()
+      expect(fs.writeSync.argsForCall[0][0]).toBe statePath
+      expect(typeof fs.writeSync.argsForCall[0][1]).toBe 'string'
 
   describe "when the escape key is pressed on the editor", ->
     it "clears multiple selections if there are any, and otherwise allows other bindings to be handled", ->
@@ -2597,7 +2677,7 @@ describe "Editor", ->
     describe "when the editor's text is changed", ->
       it "redraws the editor when it is next shown", ->
         window.rootView = new RootView
-        rootView.open('sample.js')
+        rootView.openSync('sample.js')
         rootView.attachToDom()
         editor = rootView.getActiveView()
 
@@ -2651,7 +2731,7 @@ describe "Editor", ->
   describe "when the editor is removed", ->
     it "fires a editor:will-be-removed event", ->
       window.rootView = new RootView
-      rootView.open('sample.js')
+      rootView.openSync('sample.js')
       rootView.attachToDom()
       editor = rootView.getActiveView()
 
@@ -2670,3 +2750,12 @@ describe "Editor", ->
 
       for rowNumber in [1..5]
         expect(editor.lineElementForScreenRow(rowNumber).text()).toBe buffer.lineForRow(rowNumber)
+
+  describe "when the window is resized", ->
+    it "updates the active edit session with the current soft wrap column", ->
+      editor.attachToDom()
+      setEditorWidthInChars(editor, 50)
+      expect(editor.activeEditSession.getSoftWrapColumn()).toBe 50
+      setEditorWidthInChars(editor, 100)
+      $(window).trigger 'resize'
+      expect(editor.activeEditSession.getSoftWrapColumn()).toBe 100

spec/environment.coffee

@@ -0,0 +1,59 @@
+path = require 'path'
+{Site} = require 'telepath'
+{fs} = require 'atom'
+Project = require '../src/project'
+
+module.exports =
+class Environment
+  constructor: ({@site, @state, siteId, projectPath}={}) ->
+    @site ?= new Site(siteId ? 1)
+    if @state?
+      @run => @project = deserialize(@state.get('project'))
+    else
+      @state = @site.createDocument({})
+      @project = new Project(projectPath ? path.join(__dirname, 'fixtures'))
+      @state.set(project: @project.getState())
+
+  clone: (params) ->
+    site = new Site(params.siteId)
+    new Environment(site: site, state: @state.clone(site))
+
+  destroy: ->
+    @project.destroy()
+
+  getState: -> @state
+
+  run: (fn) ->
+    uninstall = @install()
+    fn()
+    uninstall()
+
+  install: ->
+    oldSite = window.site
+    oldProject = window.project
+    window.site = @site
+    window.project = @project
+    ->
+      window.site = oldSite
+      window.project = oldProject
+
+  connect: (otherEnv) ->
+    new EnvironmentConnection(this, otherEnv)
+
+
+  connectDocuments: (docA, docB, envB) ->
+
+class EnvironmentConnection
+  constructor: (@envA, @envB) ->
+    @envA.getState().connect(@envB.getState())
+
+  connect: (docA, docB) ->
+    unless docA.site is @envA.site
+      throw new Error("Document and environment sites do not match (doc: site #{docA.site.id}, env: site #{@envA.site.id})")
+    unless docB.site is @envB.site
+      throw new Error("Document and environment sites do not match (doc: site #{docB.site.id}, env: site #{@envB.site.id})")
+
+    connection = docA.connect(docB)
+    connection.abFilter = (fn) => @envB.run(fn)
+    connection.baFilter = (fn) => @envA.run(fn)
+    connection

spec/file-spec.coffee

@@ -0,0 +1,132 @@
+{File, fs} = require 'atom'
+path = require 'path'
+
+describe 'File', ->
+  [filePath, file] = []
+
+  beforeEach ->
+    filePath = path.join(__dirname, 'fixtures', 'atom-file-test.txt') # Don't put in /tmp because /tmp symlinks to /private/tmp and screws up the rename test
+    fs.remove(filePath) if fs.exists(filePath)
+    fs.writeSync(filePath, "this is old!")
+    file = new File(filePath)
+
+  afterEach ->
+    file.off()
+    fs.remove(filePath) if fs.exists(filePath)
+
+  describe "when the file has not been read", ->
+    describe "when the contents of the file change", ->
+      it "triggers 'contents-changed' event handlers", ->
+        file.on 'contents-changed', changeHandler = jasmine.createSpy('changeHandler')
+        fs.writeSync(file.getPath(), "this is new!")
+
+        waitsFor "change event", ->
+          changeHandler.callCount > 0
+
+  describe "when the file has already been read", ->
+    beforeEach ->
+      file.readSync()
+
+    describe "when the contents of the file change", ->
+      it "triggers 'contents-changed' event handlers", ->
+        changeHandler = null
+        changeHandler = jasmine.createSpy('changeHandler')
+        file.on 'contents-changed', changeHandler
+        fs.writeSync(file.getPath(), "this is new!")
+
+        waitsFor "change event", ->
+          changeHandler.callCount > 0
+
+        runs ->
+          changeHandler.reset()
+          fs.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
+        fs.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 fs.exists(newPath)
+          fs.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
+
+        fs.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
+
+        fs.move(filePath, newPath)
+
+        waitsFor "move event", ->
+          moveHandler.callCount > 0
+
+        runs ->
+          expect(changeHandler).not.toHaveBeenCalled()
+          fs.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()
+
+        fs.remove(filePath)
+
+        expect(changeHandler).not.toHaveBeenCalled()
+        waits 20
+        runs ->
+          fs.writeSync(filePath, "HE HAS RISEN!")
+          expect(changeHandler).not.toHaveBeenCalled()
+
+        waitsFor "resurrection change event", ->
+          changeHandler.callCount == 1
+
+        runs ->
+          expect(removeHandler).not.toHaveBeenCalled()
+          fs.writeSync(filePath, "Hallelujah!")
+          changeHandler.reset()
+
+        waitsFor "post-resurrection change event", ->
+          changeHandler.callCount > 0

spec/fixtures/evil-files/a_file_with_utf8.txt

@@ -1 +0,0 @@
-I am evil because there's a UTF-8 character right here: ă

spec/fixtures/evil-files/file with spaces.txt

@@ -1 +0,0 @@
-I am evil because there are spaces in my name

spec/fixtures/evil-files/goddam newlines

@@ -1 +0,0 @@
-I am evil because there's a newline in my name

spec/fixtures/evil-files/quote".txt

@@ -1 +0,0 @@
-I am evil because there's a " in my filename. Why you do that!?

spec/fixtures/evil-files/utfă.md

@@ -1 +0,0 @@
-I am evil because there's a UTF-8 character in my name

spec/fixtures/gfm.md

@@ -1 +0,0 @@
-  * First list item

spec/fixtures/git/working-dir/.gitignore

@@ -1 +1,2 @@
-ignored.txt
+poop
+ignored.txt

spec/fixtures/git/working-dir/git.git/HEAD

@@ -0,0 +1 @@
+ref: refs/heads/master

spec/fixtures/git/working-dir/git.git/config

@@ -0,0 +1,6 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+	ignorecase = true