Verify selector before registering keybinding

Remove some default packages

.gitattributes

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

.github

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

.gitignore

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

.gitmodules

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

.nakignore

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

CHANGELOG.md

@@ -1,94 +0,0 @@
-* Fixed: Package generator package not opening window to generated package
-
-* Fixed: Precompile bootstrap.less for faster startup
-
-* Fixed: Save sometimes failing from an editor that was split
-* Fixed: Search results not appearing when set to exclude ignores
-
-* Fixed: Status bar and gutter displaying incorrect Git status information
-* Fixed: Packages not installing from the Settings view
-* Fixed: Spec runner now works from a released build
-* Fixed: Literate CoffeeScript not syntax highlighting correctly
-
-* Added: Soft wrap and tab length can now be set in the settings view
-* Fixed: Python import statements not syntax highlighting correctly
-
-* 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

@@ -1,63 +1,92 @@
-# :rotating_light: Contributing to Atom :rotating_light:
+# :tada: Contributing to Atom :tada:
 
+These are just guidelines, not rules, use your best judgement and feel free
+to propose changes to this document in a pull request.
 
 ## Issues
   * Include screenshots and animated GIFs whenever possible, they are immensely
-    helpful
+    helpful.
   * Include the behavior you expected to happen and other places you've seen
     that behavior such as Emacs, vi, Xcode, etc.
-  * Check the Console app for stack traces to include if reporting a crash
-  * Check the Dev tools (`alt-cmd-i`) for errors and stack traces to include
+  * Check the Console app for stack traces to include if reporting a crash.
+  * Check the Dev tools (`alt-cmd-i`) for errors and stack traces to include.
+  
+### Package Repositories
 
-## Code
-  * Follow the [JavaScript](https://github.com/styleguide/javascript),
-    [CSS](https://github.com/styleguide/css),
-    and [Objective-C](https://github.com/github/objective-c-conventions)
-    styleguides
-  * Include thoughtfully worded [Jasmine](http://pivotal.github.com/jasmine/)
+This is the repository for the core Atom editor only. Atom comes bundled with
+many packages and themes that are stored in other repos under the
+[atom org](https://github.com/atom) such as [tabs](https://github.com/atom/tabs),
+[find-and-replace](https://github.com/atom/find-and-replace),
+[language-javascript](https://github.com/atom/language-javascript),
+and [atom-light-ui](http://github.com/atom/atom-light-ui).
+
+If you think you know which package is causing the issue you are reporting, feel
+free to open up the issue in that specific repository instead. When in doubt
+just open the issue here but be aware that it may get closed here and reopened
+in the proper package's repository.
+
+## Pull Requests
+  * Include screenshots and animated GIFs whenever possible.
+  * Follow the [CoffeeScript](#coffeescript-styleguide),
+    [JavaScript](https://github.com/styleguide/javascript),
+    and [CSS](https://github.com/styleguide/css) styleguides
+  * Include thoughtfully worded [Jasmine](http://pivotal.github.com/jasmine)
     specs
-  * Style new elements in both the light and dark default themes when
-    appropriate
-  * 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:
-  * Files end with a newline
+  * Avoid placing files in `vendor`. 3rd-party packages should be added as a
+    `package.json` dependency.
+  * Files end with a newline.
+  * Requires should be in the following order:
+    * Built in Node Modules (such as `path`)
+    * Built in Atom and Atom Shell Modules (such as `atom`, `shell`)
+    * Local Modules (using relative paths)
   * Class variables and methods should be in the following order:
-    * Class variables (variables starting with a `@`)
     * Class methods (methods starting with a `@`)
-    * Instance variables
     * Instance methods
+  * Beware of platform differences
+    * Use `require('atom').fs.getHomeDirectory()` to get the home directory.
+    * Use `path.join()` to concatenate filenames.
+    * Temporary directory is not `/tmp` on Windows, use `os.tmpdir()` when
+      possible
 
-## Philosophy
+## Git Commit Messages
+  * Use the present tense
+  * Reference issues and pull requests liberally
+  * Consider starting the commit message with an applicable emoji:
+    * :lipstick: when improving the format/structure of the code
+    * :racehorse: when improving performance
+    * :non-potable_water: when plugging memory leaks
+    * :memo: when writing docs
 
-### Write Beautiful Code
-Once you get something working, take the time to consider whether you can achieve it in a more elegant way. We're planning on open-sourcing Atom, so let's put our best foot forward.
+## CoffeeScript Styleguide
 
-### When in doubt, pair-up
-Pairing can be an effective and fun way to pass on culture, knowledge, and taste. If you can find the time, we encourage you to work synchronously with other community members of all experience levels to help the knowledge-mulching process. It doesn't have to be all the time; a little pairing goes a long way.
+* Set parameter defaults without spaces around the equal sign
+  * `clear = (count=1) ->` instead of `clear = (count = 1) ->`
 
-### Write tests, and write them first
-The test suite keeps protects our codebase from the ravages of entropy, but it only works when we have thorough coverage. Before you write implementation code, write a  failing test proving that it's needed.
+## Documentation Styleguide
 
-### Leave the test suite better than you found it
-Consider how the specs you are adding fit into the spec-file as a whole. Is this the right place for your spec? Does the spec need to be reorganized now that you're adding this extra dimension? Specs are only as useful as the next person's ability to understand them.
+* Use [TomDoc](http://tomdoc.org).
+* Use [Markdown](https://daringfireball.net/projects/markdown).
+* Reference classes with `{ClassName}` style notation.
+* Reference methods with `{ClassName.methodName}` style notation.
+* Delegate to comments elsewhere with `{Delegates to: ClassName.methodName}`
+  style notation.
 
-### Solve today's problem
-Avoid adding flexibility that isn't needed *today*. Nothing is ever set in stone, and we can always go back and add flexibility later. Adding it early just means we have to pay for complexity that we might not end up using.
+### Example
 
-### Favor clarity over brevity or cleverness.
-Three lines that someone else can read are better than one line that's tricky.
-
-### Don't be defensive
-Only catch exceptions that are truly exceptional. Assume that components we control will honor their contracts. If they don't, the solution is to find and fix the problem in code rather than cluttering the code with attempts to foresee all potential issues at runtime.
-
-### Don't be afraid to add classes and methods
-Code rarely suffers from too many methods and classes, and  often suffers from too few. Err on the side of numerous short, well-named methods. Pull out classes with well-defined roles.
-
-### Rip shit out
-Don't be afraid to delete code. Don't be afraid to rewrite something that needs to be refreshed. If it's in version control, we can always resurrect it.
-
-### Maintain a consistent level of abstraction
-Every line in a method should read at the same basic level of abstraction. If there's a section of a method that goes into a lot more detail than the rest of the method, consider extracting a new method and giving it a clear name.
+```coffee
+# Public: Disable the package with the given name.
+#
+# This method emits multiple events:
+#
+# * `package-will-be-disabled` - before the package is disabled.
+# * `package-disabled`         - after the package is disabled.
+#
+# name     - The {String} name of the package to disable.
+# options  - The {Object} with disable options (default: {}):
+#   :trackTime - `true` to track the amount of time disabling took.
+#   :ignoreErrors - `true` to catch and ignore errors thrown.
+# callback - The {Function} to call after the package has been disabled.
+#
+# Returns `undefined`.
+disablePackage: (name, options, callback) ->
+```

LICENSE.md

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

README.md

@@ -1,26 +1,17 @@
-# Atom — Futuristic Text Editing
+# Atom — The hackable editor
 
-![atom](https://s3.amazonaws.com/speakeasy/apps/icons/27/medium/7db16e44-ba57-11e2-8c6f-981faf658e00.png)
+![Atom](http://i.imgur.com/OrTvUAD.png)
 
-Check out our [guides](https://atom-docs.githubapp.com/v20.0/index.html) and [API documentation](https://atom-docs.githubapp.com/v20.0/api/index.html).
+Check out our [guides and API documentation](https://www.atom.io/docs/latest/).
 
 ## Installing
 
-Download the latest Atom release from [speakeasy](https://speakeasy.githubapp.com/apps/27).
+Download the latest [Atom release](https://github.com/atom/atom/releases/latest).
 
-It will automatically update when a new release is available.
+Atom will automatically update when a new release is available.
 
 ## Building
 
-### Requirements
+Follow the instructions in the [build docs][building].
 
-  * Mountain Lion
-  * Boxen (Obviously Atom won't release with this requirement)
-
-### Installation
-
-  1. `gh-setup atom`
-
-  2. `cd ~/github/atom`
-
-  3. `script/build`
+[building]: https://github.com/atom/atom/blob/master/docs/building-atom.md

atom.gyp

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

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,7 +9,7 @@ if [ ! -d $ATOM_PATH ]; then
   exit 1
 fi
 
-while getopts ":whvft-:" opt; do
+while getopts ":wtfvhs-:" opt; do
   case "$opt" in
     -)
       case "${OPTARG}" in
@@ -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,11 +1,9 @@
 require '../spec/spec-helper'
 
-$ = require 'jquery'
-_ = require 'underscore'
-{Point} = require 'telepath'
-Project = require 'project'
-fsUtils = require 'fs-utils'
-TokenizedBuffer = require 'tokenized-buffer'
+path = require 'path'
+{$, _, Point, fs} = require 'atom'
+Project = require '../src/project'
+TokenizedBuffer = require '../src/tokenized-buffer'
 
 defaultCount = 100
 window.pbenchmark = (args...) -> window.benchmark(args..., profile: true)
@@ -13,7 +11,7 @@ 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(fsUtils.resolveOnLoadPath('benchmark/fixtures'))
+window.benchmarkFixturesProject = new Project(path.join(__dirname, 'fixtures'))
 
 beforeEach ->
   window.project = window.benchmarkFixturesProject
@@ -75,8 +73,8 @@ window.clickEvent = (properties={}) ->
 
 window.mouseEvent = (type, properties) ->
   if properties.point
-    {point, editor} = properties
-    {top, left} = @pagePixelPositionForPoint(editor, point)
+    {point, editorView} = properties
+    {top, left} = @pagePixelPositionForPoint(editorView, point)
     properties.pageX = left + 1
     properties.pageY = top + 1
   properties.originalEvent ?= {detail: 1}
@@ -88,14 +86,14 @@ window.mousedownEvent = (properties={}) ->
 window.mousemoveEvent = (properties={}) ->
   window.mouseEvent('mousemove', properties)
 
-window.pagePixelPositionForPoint = (editor, point) ->
+window.pagePixelPositionForPoint = (editorView, point) ->
   point = Point.fromObject point
-  top = editor.lines.offset().top + point.row * editor.lineHeight
-  left = editor.lines.offset().left + point.column * editor.charWidth - editor.lines.scrollLeft()
+  top = editorView.lines.offset().top + point.row * editorView.lineHeight
+  left = editorView.lines.offset().left + point.column * editorView.charWidth - editorView.lines.scrollLeft()
   { top, left }
 
-window.setEditorWidthInChars = (editor, widthInChars, charWidth=editor.charWidth) ->
-  editor.width(charWidth * widthInChars + editor.lines.position().left)
+window.seteditorViewWidthInChars = (editorView, widthInChars, charWidth=editorView.charWidth) ->
+  editorView.width(charWidth * widthInChars + editorView.lines.position().left)
 
 $.fn.resultOfTrigger = (type) ->
   event = $.Event(type)

benchmark/benchmark-suite.coffee

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

build/Gruntfile.coffee

@@ -1,19 +1,65 @@
 fs = require 'fs'
 path = require 'path'
+os = require 'os'
+
+# Add support for obselete APIs of vm module so we can make some third-party
+# modules work under node v0.11.x.
+require 'vm-compatibility-layer'
 
 fm = require 'json-front-matter'
-_ = require 'underscore'
+_ = require 'underscore-plus'
 
-packageJson = require './package.json'
+packageJson = require '../package.json'
+
+# OAuth token for atom-bot
+# TODO Remove once all repositories are public
+process.env.ATOM_ACCESS_TOKEN ?= '362295be4c5258d3f7b967bbabae662a455ca2a7'
+
+# Shim harmony collections in case grunt was invoked without harmony
+# collections enabled
+_.extend(global, require('harmony-collections')) unless global.WeakMap?
 
 module.exports = (grunt) ->
-  appName = 'Atom.app'
+  grunt.loadNpmTasks('grunt-coffeelint')
+  grunt.loadNpmTasks('grunt-lesslint')
+  grunt.loadNpmTasks('grunt-cson')
+  grunt.loadNpmTasks('grunt-contrib-csslint')
+  grunt.loadNpmTasks('grunt-contrib-coffee')
+  grunt.loadNpmTasks('grunt-contrib-less')
+  grunt.loadNpmTasks('grunt-markdown')
+  grunt.loadNpmTasks('grunt-shell')
+  grunt.loadNpmTasks('grunt-download-atom-shell')
+  grunt.loadNpmTasks('grunt-peg')
+  grunt.loadTasks('tasks')
+
+  # This allows all subsequent paths to the relative to the root of the repo
+  grunt.file.setBase(path.resolve('..'))
+
+  if not grunt.option('verbose')
+    grunt.log.writeln = (args...) -> grunt.log
+    grunt.log.write = (args...) -> grunt.log
+
   [major, minor, patch] = packageJson.version.split('.')
-  buildDir = grunt.option('build-dir') ? '/tmp/atom-build'
-  shellAppDir = path.join(buildDir, appName)
-  contentsDir = path.join(shellAppDir, 'Contents')
-  appDir = path.join(contentsDir, 'Resources', 'app')
-  installDir = path.join('/Applications', appName)
+  if 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)
+    contentsDir = shellAppDir
+    appDir = path.join(shellAppDir, 'resources', 'app')
+    atomShellDownloadDir = path.join(os.tmpdir(), 'atom-cached-atom-shells')
+  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')
+    atomShellDownloadDir = '/tmp/atom-cached-atom-shells'
+
+  installDir = path.join(installRoot, appName)
 
   coffeeConfig =
     options:
@@ -22,6 +68,7 @@ module.exports = (grunt) ->
       expand: true
       src: [
         'src/**/*.coffee'
+        'exports/**/*.coffee'
         'static/**/*.coffee'
       ]
       dest: appDir
@@ -32,39 +79,50 @@ module.exports = (grunt) ->
       paths: [
         'static/variables'
         'static'
-        'vendor'
       ]
     glob_to_multiple:
       expand: true
       src: [
-        'src/**/*.less'
         'static/**/*.less'
-        'themes/**/*.less'
-        'vendor/bootstrap/less/bootstrap.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'
-        'themes/**/*.cson'
       ]
       dest: appDir
       ext: '.json'
 
+  pegConfig =
+    glob_to_multiple:
+      expand: true
+      src: ['src/**/*.pegjs']
+      dest: appDir
+      ext: '.js'
+
   for child in fs.readdirSync('node_modules') when child isnt '.bin'
     directory = path.join('node_modules', child)
-    {engines} = grunt.file.readJSON(path.join(directory, 'package.json'))
+    {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")
+      pegConfig.glob_to_multiple.src.push("#{directory}/**/*.pegjs")
 
   grunt.initConfig
     pkg: grunt.file.readJSON('package.json')
@@ -75,19 +133,28 @@ module.exports = (grunt) ->
 
     less: lessConfig
 
+    'prebuild-less': prebuildLessConfig
+
     cson: csonConfig
 
+    peg: pegConfig
+
     coffeelint:
       options:
         no_empty_param_list:
           level: 'error'
         max_line_length:
           level: 'ignore'
+        indentation:
+          level: 'ignore'
       src: [
         'dot-atom/**/*.coffee'
+        'exports/**/*.coffee'
         'src/**/*.coffee'
-        'tasks/**/*.coffee'
-        'Gruntfile.coffee'
+      ]
+      build: [
+        'build/tasks/**/*.coffee'
+        'build/Gruntfile.coffee'
       ]
       test: [
         'spec/*.coffee'
@@ -96,6 +163,7 @@ module.exports = (grunt) ->
     csslint:
       options:
         'adjoining-classes': false
+        'duplicate-background-images': false
         'box-model': false
         'box-sizing': false
         'bulletproof-font-face': false
@@ -115,13 +183,11 @@ module.exports = (grunt) ->
         'vendor-prefix': false
       src: [
         'static/**/*.css'
-        'themes/**/*.css'
       ]
 
     lesslint:
       src: [
         'static/**/*.less'
-        'themes/**/*.less'
       ]
 
     markdown:
@@ -144,37 +210,23 @@ module.exports = (grunt) ->
             _.extend(context, parsed.attributes)
             parsed.body
 
+    'download-atom-shell':
+      version: packageJson.atomShellVersion
+      outputDir: 'atom-shell'
+      downloadDir: atomShellDownloadDir
+      rebuild: true  # rebuild native modules after atom-shell is updated
+
     shell:
       'kill-atom':
-        command: 'pkill Atom'
+        command: 'pkill -9 Atom'
         options:
           stdout: false
           stderr: false
           failOnError: false
 
-      test:
-        command: "#{path.join(contentsDir, 'MacOS', 'Atom')} --test --resource-path=#{__dirname}"
-        options:
-          stdout: true
-          stderr: true
-          callback: (error, stdout, stderr, callback) ->
-            grunt.warn('Specs failed') if error?
-            callback()
-
-  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', 'peg'])
   grunt.registerTask('lint', ['coffeelint', 'csslint', 'lesslint'])
-  grunt.registerTask('test', ['shell:kill-atom', 'shell:test'])
-  grunt.registerTask('ci', ['lint', 'update-atom-shell', 'build', 'set-development-version', 'test'])
-  grunt.registerTask('deploy', ['partial-clean', 'update-atom-shell', 'build', 'codesign'])
+  grunt.registerTask('test', ['shell:kill-atom', 'run-specs'])
+  grunt.registerTask('ci', ['output-disk-space', 'download-atom-shell', 'build', 'set-version', 'lint', 'test', 'codesign', 'publish-build'])
   grunt.registerTask('docs', ['markdown:guides', 'build-docs'])
-  grunt.registerTask('default', ['update-atom-shell', 'build', 'set-development-version', 'install'])
+  grunt.registerTask('default', ['download-atom-shell', 'build', 'set-version', 'install'])

build/README.md

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

build/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "atom-build",
+  "description": "Atom build",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/atom/atom.git"
+  },
+  "dependencies": {
+    "async": "~0.2.9",
+    "biscotto": "0.6.0",
+    "formidable": "~1.0.14",
+    "fs-plus": "2.x",
+    "github-releases": "~0.2.0",
+    "grunt": "~0.4.1",
+    "grunt-cli": "~0.1.9",
+    "grunt-coffeelint": "git://github.com/atom/grunt-coffeelint.git",
+    "grunt-contrib-csslint": "~0.1.2",
+    "grunt-contrib-coffee": "~0.9.0",
+    "grunt-contrib-less": "~0.8.0",
+    "grunt-cson": "0.6.0",
+    "grunt-download-atom-shell": "git+https://atom-bot:362295be4c5258d3f7b967bbabae662a455ca2a7@github.com/atom/grunt-download-atom-shell#v0.6.0",
+    "grunt-lesslint": "0.13.0",
+    "grunt-markdown": "~0.4.0",
+    "grunt-peg": "~1.1.0",
+    "grunt-shell": "~0.3.1",
+    "harmony-collections": "~0.3.8",
+    "json-front-matter": "~0.1.3",
+    "rcedit": "~0.1.2",
+    "request": "~2.27.0",
+    "rimraf": "~2.2.2",
+    "runas": "0.5.x",
+    "underscore-plus": "1.x",
+    "unzip": "~0.1.9",
+    "vm-compatibility-layer": "~0.1.0"
+  }
+}

build/tasks/build-task.coffee

@@ -0,0 +1,80 @@
+fs = require 'fs'
+path = require 'path'
+
+module.exports = (grunt) ->
+  {cp, isAtomPackage, mkdir, rm} = require('./task-helpers')(grunt)
+
+  grunt.registerTask 'build', 'Build the application', ->
+    shellAppDir = grunt.config.get('atom.shellAppDir')
+    buildDir = grunt.config.get('atom.buildDir')
+    appDir = grunt.config.get('atom.appDir')
+
+    rm shellAppDir
+    mkdir path.dirname(buildDir)
+
+    if process.platform is 'darwin'
+      cp 'atom-shell/Atom.app', shellAppDir
+    else if process.platform is 'win32'
+      cp 'atom-shell', shellAppDir
+
+    mkdir appDir
+
+    cp 'atom.sh', path.join(appDir, 'atom.sh')
+    cp 'package.json', path.join(appDir, 'package.json')
+
+    packageDirectories = []
+    nonPackageDirectories = [
+      'benchmark'
+      'dot-atom'
+      'vendor'
+      'resources'
+    ]
+
+    {devDependencies} = grunt.file.readJSON('package.json')
+    for child in fs.readdirSync('node_modules')
+      directory = path.join('node_modules', child)
+      if isAtomPackage(directory)
+        packageDirectories.push(directory)
+      else
+        nonPackageDirectories.push(directory)
+
+    # Put any paths here that shouldn't end up in the built Atom.app
+    # so that it doesn't becomes larger than it needs to be.
+    ignoredPaths = [
+      path.join('git-utils', 'deps')
+      path.join('oniguruma', 'deps')
+      path.join('less', 'dist')
+      path.join('less', 'test')
+      path.join('bootstrap', 'docs')
+      path.join('bootstrap', 'examples')
+      path.join('spellchecker', 'vendor')
+      path.join('xmldom', 'test')
+      path.join('jasmine-reporters', 'ext')
+      path.join('build', 'Release', 'obj.target')
+      path.join('build', 'Release', '.deps')
+      path.join('vendor', 'apm')
+      path.join('resources', 'mac')
+      path.join('resources', 'win')
+    ]
+    ignoredPaths = ignoredPaths.map (ignoredPath) -> "(#{ignoredPath})"
+    nodeModulesFilter = new RegExp(ignoredPaths.join('|'))
+    packageFilter = new RegExp("(#{ignoredPaths.join('|')})|(.+\\.(cson|coffee)$)")
+    for directory in nonPackageDirectories
+      cp directory, path.join(appDir, directory), filter: nodeModulesFilter
+    for directory in packageDirectories
+      cp directory, path.join(appDir, directory), filter: packageFilter
+
+    cp 'spec', path.join(appDir, 'spec')
+    cp 'src', path.join(appDir, 'src'), filter: /.+\.(cson|coffee)$/
+    cp 'static', path.join(appDir, 'static')
+    cp 'apm', path.join(appDir, 'apm'), filter: nodeModulesFilter
+
+    if process.platform is 'darwin'
+      grunt.file.recurse path.join('resources', 'mac'), (sourcePath, rootDirectory, subDirectory='', filename) ->
+        unless /.+\.plist/.test(sourcePath)
+          grunt.file.copy(sourcePath, path.resolve(appDir, '..', subDirectory, filename))
+
+    dependencies = ['compile']
+    dependencies.push('copy-info-plist') if process.platform is 'darwin'
+    dependencies.push('set-exe-icon') if process.platform is 'win32'
+    grunt.task.run(dependencies...)

build/tasks/clean-task.coffee

@@ -1,16 +1,21 @@
 path = require 'path'
+os = require 'os'
 
 module.exports = (grunt) ->
   {rm} = require('./task-helpers')(grunt)
 
-
   grunt.registerTask 'partial-clean', 'Delete some of the build files', ->
+    tmpdir = if process.platform is 'win32' then os.tmpdir() else '/tmp'
+
     rm grunt.config.get('atom.buildDir')
     rm require('../src/coffee-cache').cacheDir
-    rm '/tmp/atom-cached-atom-shells'
+    rm require('../src/less-compile-cache').cacheDir
+    rm path.join(tmpdir, 'atom-cached-atom-shells')
     rm 'atom-shell'
 
   grunt.registerTask 'clean', 'Delete all the build files', ->
+    homeDir = process.env[if process.platform is 'win32' then 'USERPROFILE' else 'HOME']
+
     rm 'node_modules'
-    rm path.join(process.env.HOME, '.atom', '.node-gyp')
+    rm path.join(homeDir, '.atom', '.node-gyp')
     grunt.task.run('partial-clean')

build/tasks/codesign-task.coffee

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

build/tasks/docs-task.coffee

@@ -0,0 +1,157 @@
+path = require 'path'
+
+async = require 'async'
+fs = require 'fs-plus'
+request = require 'request'
+
+module.exports = (grunt) ->
+  {rm} = require('./task-helpers')(grunt)
+
+  cmd = path.join('node_modules', '.bin', 'coffee')
+  commonArgs = [path.join('build', 'node_modules', '.bin', 'biscotto'), '--']
+  opts =
+    stdio: 'inherit'
+
+  grunt.registerTask 'build-docs', 'Builds the API docs in src', ->
+    done = @async()
+
+    downloadIncludes (error, includePaths) ->
+      if error?
+        done(error)
+      else
+        rm('docs/output/api')
+        args = [
+          commonArgs...
+          '--title', 'Atom API Documentation'
+          '-o', 'docs/output/api'
+          '-r', 'docs/README.md'
+          'src/'
+          includePaths...
+        ]
+        grunt.util.spawn({cmd, args, opts}, done)
+
+  grunt.registerTask 'lint-docs', 'Generate stats about the doc coverage', ->
+    done = @async()
+    downloadIncludes (error, includePaths) ->
+      if error?
+        done(error)
+      else
+        args = [
+          commonArgs...
+          '--noOutput'
+          'src/'
+          includePaths...
+        ]
+        grunt.util.spawn({cmd, args, opts}, done)
+
+  grunt.registerTask 'missing-docs', 'Generate stats about the doc coverage', ->
+    done = @async()
+    downloadIncludes (error, includePaths) ->
+      if error?
+        done(error)
+      else
+        args = [
+          commonArgs...
+          '--noOutput'
+          '--missing'
+          'src/'
+          includePaths...
+        ]
+        grunt.util.spawn({cmd, args, opts}, done)
+
+  grunt.registerTask 'copy-docs', 'Copies over latest API docs to atom-docs', ->
+    done = @async()
+
+    fetchTag = (args..., callback) ->
+      cmd = 'git'
+      args = ['describe', '--abbrev=0', '--tags']
+      grunt.util.spawn {cmd, args}, (error, result) ->
+        if error?
+          callback(error)
+        else
+          callback(null, String(result).trim())
+
+    copyDocs = (tag, callback) ->
+      cmd = 'cp'
+      args = ['-r', 'docs/output/', "../atom.io/public/docs/api/#{tag}/"]
+
+      fs.exists "../atom.io/public/docs/api/", (exists) ->
+        if exists
+          grunt.util.spawn {cmd, args}, (error, result) ->
+            if error?
+              callback(error)
+            else
+              callback(null, tag)
+        else
+          grunt.log.error "../atom.io/public/docs/api/ doesn't exist"
+          return false
+
+    grunt.util.async.waterfall [fetchTag, copyDocs], done
+
+  grunt.registerTask 'deploy-docs', 'Publishes latest API docs to atom-docs.githubapp.com', ->
+    done = @async()
+    docsRepoArgs = ['--work-tree=../atom-docs/', '--git-dir=../atom-docs/.git/']
+
+    fetchTag = (args..., callback) ->
+      cmd = 'git'
+      args = ['describe', '--abbrev=0', '--tags']
+      grunt.util.spawn {cmd, args}, (error, result) ->
+        if error?
+          callback(error)
+        else
+          callback(null, String(result).trim().split('.')[0..1].join('.'))
+
+    stageDocs = (tag, callback) ->
+      cmd = 'git'
+      args = [docsRepoArgs..., 'add', "public/#{tag}"]
+      grunt.util.spawn({cmd, args, opts}, callback)
+
+    fetchSha = (args..., callback) ->
+      cmd = 'git'
+      args = ['rev-parse', 'HEAD']
+      grunt.util.spawn {cmd, args}, (error, result) ->
+        if error?
+          callback(error)
+        else
+          callback(null, String(result).trim())
+
+    commitChanges = (sha, callback) ->
+      cmd = 'git'
+      args = [docsRepoArgs..., 'commit', "-m Update API docs to #{sha}"]
+      grunt.util.spawn({cmd, args, opts}, callback)
+
+    pushOrigin = (args..., callback) ->
+      cmd = 'git'
+      args = [docsRepoArgs..., 'push', 'origin', 'master']
+      grunt.util.spawn({cmd, args, opts}, callback)
+
+    pushHeroku = (args..., callback) ->
+      cmd = 'git'
+      args = [docsRepoArgs..., 'push', 'heroku', 'master']
+      grunt.util.spawn({cmd, args, opts}, callback)
+
+    grunt.util.async.waterfall [fetchTag, stageDocs, fetchSha, commitChanges, pushOrigin, pushHeroku], done
+
+downloadFileFromRepo = ({repo, file}, callback) ->
+  uri = "https://raw.github.com/atom/#{repo}/master/#{file}"
+  request uri, (error, response, contents) ->
+    return callback(error) if error?
+    downloadPath = path.join('docs', 'includes', repo, file)
+    fs.writeFile downloadPath, contents, (error) ->
+      callback(error, downloadPath)
+
+downloadIncludes = (callback) ->
+  includes = [
+    {repo: 'first-mate',  file: 'src/grammar.coffee'}
+    {repo: 'first-mate',  file: 'src/grammar-registry.coffee'}
+    {repo: 'node-pathwatcher', file: 'src/directory.coffee'}
+    {repo: 'node-pathwatcher', file: 'src/file.coffee'}
+    {repo: 'space-pen',   file: 'src/space-pen.coffee'}
+    {repo: 'text-buffer', file: 'src/marker.coffee'}
+    {repo: 'text-buffer', file: 'src/point.coffee'}
+    {repo: 'text-buffer', file: 'src/range.coffee'}
+    {repo: 'text-buffer', file: 'src/text-buffer.coffee'}
+    {repo: 'theorist',    file: 'src/model.coffee'}
+  ]
+
+  async.map(includes, downloadFileFromRepo, callback)

build/tasks/install-task.coffee

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

build/tasks/output-disk-space.coffee

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

build/tasks/prebuild-less-task.coffee

@@ -0,0 +1,45 @@
+path = require 'path'
+
+LessCache = require 'less-cache'
+
+module.exports = (grunt) ->
+  grunt.registerMultiTask 'prebuild-less', 'Prebuild cached of compiled LESS files', ->
+    prebuiltConfigurations = [
+      ['atom-dark-ui', 'atom-dark-syntax']
+      ['atom-dark-ui', 'atom-light-syntax']
+      ['atom-dark-ui', 'solarized-dark-syntax']
+      ['atom-dark-ui', 'base16-tomorrow-dark-theme']
+      ['atom-light-ui', 'atom-light-syntax']
+      ['atom-light-ui', 'atom-dark-syntax']
+      ['atom-light-ui', 'solarized-dark-syntax']
+      ['atom-light-ui', 'base16-tomorrow-dark-theme']
+    ]
+
+    directory = path.join(grunt.config.get('atom.appDir'), 'less-compile-cache')
+
+    for configuration in prebuiltConfigurations
+      importPaths = grunt.config.get('less.options.paths')
+      themeMains = []
+      for theme in configuration
+        # TODO Use AtomPackage class once it runs outside of an Atom context
+        themePath = path.resolve('node_modules', theme)
+        stylesheetsDir = path.join(themePath, 'stylesheets')
+        {main} = grunt.file.readJSON(path.join(themePath, 'package.json'))
+        main ?= 'index.less'
+        mainPath = path.join(themePath, main)
+        themeMains.push(mainPath) if grunt.file.isFile(mainPath)
+        importPaths.unshift(stylesheetsDir) if grunt.file.isDir(stylesheetsDir)
+
+      grunt.verbose.writeln("Building LESS cache for #{configuration.join(', ').yellow}")
+      lessCache = new LessCache
+        cacheDir: directory
+        resourcePath: path.resolve('.')
+        importPaths: importPaths
+
+      for file in @filesSrc
+        grunt.verbose.writeln("File #{file.cyan} created in cache.")
+        lessCache.readFileSync(file)
+
+      for file in themeMains
+        grunt.verbose.writeln("File #{file.cyan} created in cache.")
+        lessCache.readFileSync(file)

build/tasks/publish-build-task.coffee

@@ -0,0 +1,172 @@
+child_process = require 'child_process'
+path = require 'path'
+
+_ = require 'underscore-plus'
+fs = require 'fs-plus'
+GitHub = require 'github-releases'
+request = require 'request'
+
+grunt = null
+maxReleases = 10
+assetName = 'atom-mac.zip'
+assetPath = "/tmp/atom-build/#{assetName}"
+commitSha = process.env.JANKY_SHA1
+token = process.env.ATOM_ACCESS_TOKEN
+defaultHeaders =
+  Authorization: "token #{token}"
+  'User-Agent': 'Atom'
+
+module.exports = (gruntObject) ->
+  grunt = gruntObject
+  grunt.registerTask 'publish-build', 'Publish the built app', ->
+    return unless process.platform is 'darwin'
+    return if process.env.JANKY_SHA1 and process.env.JANKY_BRANCH isnt 'master'
+
+    done = @async()
+
+    createBuildRelease (error, release) ->
+      return done(error) if error?
+      zipApp (error) ->
+        return done(error) if error?
+        uploadAsset release, (error) ->
+          return done(error) if error?
+          publishRelease release, (error) ->
+            return done(error) if error?
+            getAtomDraftRelease (error, release) ->
+              return done(error) if error?
+              deleteExistingAsset release, (error) ->
+                return done(error) if error?
+                uploadAsset(release, done)
+
+logError = (message, error, details) ->
+  grunt.log.error(message)
+  grunt.log.error(error.message ? error) if error?
+  grunt.log.error(details) if details
+
+zipApp = (callback) ->
+  fs.removeSync(assetPath)
+
+  options = {cwd: path.dirname(assetPath), maxBuffer: Infinity}
+  child_process.exec "zip -r --symlinks #{assetName} Atom.app", options, (error, stdout, stderr) ->
+    if error?
+      logError('Zipping Atom.app failed', error, stderr)
+    callback(error)
+
+getRelease = (callback) ->
+  options =
+    uri: 'https://api.github.com/repos/atom/atom-master-builds/releases'
+    method: 'GET'
+    headers: defaultHeaders
+    json: true
+  request options, (error, response, releases=[]) ->
+    if error? or response.statusCode isnt 200
+      logError('Fetching releases failed', error, releases)
+      callback(error ? new Error(response.statusCode))
+    else
+      if releases.length > maxReleases
+        deleteRelease(release) for release in releases[maxReleases..]
+
+      for release in releases when release.name is commitSha
+        callback(null, release)
+        return
+      callback()
+
+getAtomDraftRelease = (callback) ->
+  atomRepo = new GitHub({repo: 'atom/atom', token})
+  atomRepo.getReleases (error, releases=[]) ->
+    if error?
+      logError('Fetching atom/atom releases failed', error, releases)
+      callback(error)
+    else
+      for release in releases when release.draft
+        callback(null, release)
+        return
+      callback(new Error('No draft release in atom/atom repo'))
+
+deleteRelease = (release) ->
+  options =
+    uri: release.url
+    method: 'DELETE'
+    headers: defaultHeaders
+    json: true
+  request options, (error, response, body='') ->
+    if error? or response.statusCode isnt 204
+      logError('Deleting release failed', error, body)
+
+deleteExistingAsset = (release, callback) ->
+  for asset in release.assets when asset.name is assetName
+    options =
+      uri: asset.url
+      method: 'DELETE'
+      headers: defaultHeaders
+    request options, (error, response, body='') ->
+      if error? or response.statusCode isnt 204
+        logError('Deleting existing release asset failed', error, body)
+        callback(error ? new Error(response.statusCode))
+      else
+        callback()
+
+    return
+
+  callback()
+
+createBuildRelease = (callback) ->
+  getRelease (error, release) ->
+    if error?
+      callback(error)
+      return
+
+    if release?
+      deleteExistingAsset release, (error) ->
+        callback(error, release)
+      return
+
+    options =
+      uri: 'https://api.github.com/repos/atom/atom-master-builds/releases'
+      method: 'POST'
+      headers: defaultHeaders
+      json:
+        tag_name: "v#{commitSha}"
+        target_commitish: 'master'
+        name: commitSha
+        body: "Build of [atom@#{commitSha.substring(0, 7)}](https://github.com/atom/atom/commits/#{commitSha})"
+        draft: true
+        prerelease: true
+    request options, (error, response, release={}) ->
+      if error? or response.statusCode isnt 201
+        logError('Creating release failed', error, release)
+        callback(error ? new Error(response.statusCode))
+      else
+        callback(null, release)
+
+uploadAsset = (release, callback) ->
+  options =
+    uri: release.upload_url.replace(/\{.*$/, "?name=#{assetName}")
+    method: 'POST'
+    headers: _.extend({
+      'Content-Type': 'application/zip'
+      'Content-Length': fs.getSizeSync(assetPath)
+      }, defaultHeaders)
+
+  assetRequest = request options, (error, response, body='') ->
+    if error? or response.statusCode >= 400
+      logError('Upload release asset failed', error, body)
+      callback(error ? new Error(response.statusCode))
+    else
+      callback(null, release)
+
+  fs.createReadStream(assetPath).pipe(assetRequest)
+
+publishRelease = (release, callback) ->
+  options =
+    uri: release.url
+    method: 'POST'
+    headers: defaultHeaders
+    json:
+      draft: false
+  request options, (error, response, body={}) ->
+    if error? or response.statusCode isnt 200
+      logError('Creating release failed', error, body)
+      callback(error ? new Error(response.statusCode))
+    else
+      callback()

build/tasks/publish-packages.coffee

@@ -0,0 +1,108 @@
+async = require 'async'
+request = require 'request'
+
+# Configure and publish all packages in package.json to atom.io
+#
+# This task should be run whenever you want to be sure that atom.io contains
+# all the packages and versions referenced in Atom's package.json file.
+module.exports = (grunt) ->
+  {spawn} = require('./task-helpers')(grunt)
+
+  baseUrl = "https://www.atom.io/api/packages"
+
+  packageExists = (packageName, token, callback) ->
+    requestSettings =
+      url: "#{baseUrl}/#{packageName}"
+      json: true
+      headers:
+        authorization: token
+    request.get requestSettings, (error, response, body={}) ->
+      if error?
+        callback(error)
+      else
+        callback(null, response.statusCode is 404)
+
+  createPackage = (packageName, token, callback) ->
+    requestSettings =
+      url: baseUrl
+      json: true
+      headers:
+        authorization: token
+      method: 'POST'
+      body:
+        repository: "atom/#{packageName}"
+
+    request.get requestSettings, (error, response, body={}) ->
+      if error?
+        callback(error)
+      else if response.statusCode isnt 201
+        message = body.message ? body.error ? body
+        callback(new Error("Creating package failed: #{message}"))
+      else
+        callback()
+
+  createPackageVersion = (packageName, tag, token, callback) ->
+    requestSettings =
+      url: "#{baseUrl}/#{packageName}/versions"
+      json: true
+      method: 'POST'
+      headers:
+        authorization: token
+      body:
+        tag: tag
+
+    request.get requestSettings, (error, response, body={}) ->
+      if error?
+        callback(error)
+      else if response.statusCode isnt 201
+        message = body.message ? body.error ? body
+        if message is 'Version exists'
+          callback()
+        else
+          callback(new Error("Creating new version failed: #{message}"))
+      else
+        callback()
+
+  getToken = (callback) ->
+    if token = process.env.ATOM_ACCESS_TOKEN
+      callback(null, token)
+    else
+      spawn {cmd: 'security', args: ['-q', 'find-generic-password', '-ws', 'GitHub API Token']}, (error, result, code) ->
+        token = result.toString() unless error?
+        callback(error, token)
+
+  grunt.registerTask 'publish-packages', 'Publish all bundled packages', ->
+    done = @async()
+
+    getToken (error, token) ->
+      unless token
+        grunt.log.error('Token not found in keychain or ATOM_ACCESS_TOKEN environment variable')
+        done(false)
+
+      {packageDependencies} = grunt.file.readJSON('package.json') ? {}
+      tasks = []
+      for name, version of packageDependencies
+        do (name, version) ->
+          tasks.push (callback) ->
+            grunt.verbose.writeln("Publishing #{name}@#{version}")
+            tag = "v#{version}"
+            packageExists name, token, (error, exists) ->
+              if error?
+                callback(error)
+                return
+
+              if exists
+                createPackage name, token, (error) ->
+                  if error?
+                    callback(error)
+                  else
+                    createPackageVersion(name, tag, token, callback)
+              else
+                createPackageVersion(name, tag, token, callback)
+
+      async.waterfall tasks, (error) ->
+        if error?
+          grunt.log.error(error.message)
+          done(false)
+        else
+          done()

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

@@ -0,0 +1,12 @@
+path = require 'path'
+
+module.exports = (grunt) ->
+  grunt.registerTask 'set-exe-icon', 'Set icon of the exe', ->
+    done = @async()
+
+    shellAppDir = grunt.config.get('atom.shellAppDir')
+    shellExePath = path.join(shellAppDir, 'atom.exe')
+    iconPath = path.resolve('resources', 'win', 'atom.ico')
+
+    rcedit = require('rcedit')
+    rcedit(shellExePath, {'icon': iconPath}, done)

build/tasks/set-version-task.coffee

@@ -0,0 +1,50 @@
+fs = require 'fs'
+path = require 'path'
+
+module.exports = (grunt) ->
+  {spawn} = require('./task-helpers')(grunt)
+
+  getVersion = (callback) ->
+    if process.env.JANKY_SHA1 and process.env.JANKY_BRANCH is 'master'
+      {version} = require(path.join(grunt.config.get('atom.appDir'), 'package.json'))
+      callback(null, version)
+    else
+      cmd = 'git'
+      args = ['rev-parse', '--short', 'HEAD']
+      spawn {cmd, args}, (error, {stdout}={}, code) ->
+        callback(error, stdout?.trim?())
+
+  grunt.registerTask 'set-version', 'Set the version in the plist and package.json', ->
+    done = @async()
+
+    getVersion (error, version) ->
+      if error?
+        done(error)
+        return
+
+      appDir = grunt.config.get('atom.appDir')
+
+      # Replace version field of package.json.
+      packageJsonPath = path.join(appDir, 'package.json')
+      packageJson = require(packageJsonPath)
+      packageJson.version = version
+      packageJsonString = JSON.stringify(packageJson, null, 2)
+      fs.writeFileSync(packageJsonPath, packageJsonString)
+
+      if process.platform is 'darwin'
+        cmd = 'script/set-version'
+        args = [grunt.config.get('atom.buildDir'), version]
+        spawn {cmd, args}, (error, result, code) -> done(error)
+      else if process.platform is 'win32'
+        shellAppDir = grunt.config.get('atom.shellAppDir')
+        shellExePath = path.join(shellAppDir, 'atom.exe')
+
+        strings =
+          CompanyName: 'GitHub, Inc.'
+          FileDescription: 'The hackable editor'
+          LegalCopyright: 'Copyright (C) 2013 GitHub, Inc. All rights reserved'
+          ProductName: 'Atom'
+          ProductVersion: version
+
+        rcedit = require('rcedit')
+        rcedit(shellExePath, {'version-string': strings}, done)

build/tasks/spec-task.coffee

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

build/tasks/task-helpers.coffee

@@ -0,0 +1,67 @@
+fs = require 'fs-plus'
+path = require 'path'
+
+module.exports = (grunt) ->
+  cp: (source, destination, {filter}={}) ->
+    unless grunt.file.exists(source)
+      grunt.fatal("Cannot copy non-existent #{source.cyan} to #{destination.cyan}")
+
+    copyFile = (sourcePath, destinationPath) ->
+      return if filter?.test(sourcePath)
+
+      stats = fs.lstatSync(sourcePath)
+      if stats.isSymbolicLink()
+        grunt.file.mkdir(path.dirname(destinationPath))
+        fs.symlinkSync(fs.readlinkSync(sourcePath), destinationPath)
+      else if stats.isFile()
+        grunt.file.copy(sourcePath, destinationPath)
+
+      if grunt.file.exists(destinationPath)
+        fs.chmodSync(destinationPath, fs.statSync(sourcePath).mode)
+
+    if grunt.file.isFile(source)
+      copyFile(source, destination)
+    else
+      try
+        onFile = (sourcePath) ->
+          destinationPath = path.join(destination, path.relative(source, sourcePath))
+          copyFile(sourcePath, destinationPath)
+        onDirectory = (sourcePath) ->
+          if fs.isSymbolicLinkSync(sourcePath)
+            destinationPath = path.join(destination, path.relative(source, sourcePath))
+            copyFile(sourcePath, destinationPath)
+            false
+          else
+            true
+        fs.traverseTreeSync source, onFile, onDirectory
+      catch error
+        grunt.fatal(error)
+
+    grunt.verbose.writeln("Copied #{source.cyan} to #{destination.cyan}.")
+
+  mkdir: (args...) ->
+    grunt.file.mkdir(args...)
+
+  rm: (args...) ->
+    grunt.file.delete(args..., force: true) if grunt.file.exists(args...)
+
+  spawn: (options, callback) ->
+    childProcess = require 'child_process'
+    stdout = []
+    stderr = []
+    error = null
+    proc = childProcess.spawn(options.cmd, options.args, options.opts)
+    proc.stdout.on 'data', (data) -> stdout.push(data.toString())
+    proc.stderr.on 'data', (data) -> stderr.push(data.toString())
+    proc.on 'close', (exitCode, signal) ->
+      error = new Error(signal) if exitCode != 0
+      results = {stderr: stderr.join(''), stdout: stdout.join(''), code: exitCode}
+      grunt.log.error results.stderr if exitCode != 0
+      callback(error, results, exitCode)
+
+  isAtomPackage: (packagePath) ->
+    try
+      {engines} = grunt.file.readJSON(path.join(packagePath, 'package.json'))
+      engines?.atom?
+    catch error
+      false

build/tasks/update-octicons-task.coffee

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

docs/README.md

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

docs/advanced/configuration.md

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

docs/advanced/globals.md

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

docs/advanced/keymaps.md

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

docs/advanced/serialization.md

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

docs/advanced/view-system.md

@@ -0,0 +1,58 @@
+## Atom's View System
+
+### SpacePen Basics
+
+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
+have methods that are view-specific. For example, you could call both general
+and view-specific on the global `atom.workspaceView` instance:
+
+```coffeescript
+atom.workspaceView.find('.editor.active') # standard jQuery method
+atom.workspaceView.getActiveEditor()      # view-specific method
+```
+
+If you retrieve a jQuery wrapper for an element associated with a view, use the
+`.view()` method to retrieve the element's view object:
+
+```coffeescript
+# this is a plain jQuery object; you can't call view-specific methods
+editorElement = atom.workspaceView.find('.editor.active')
+
+# get the view object by calling `.view()` to call view-specific methods
+editorView = editorElement.view()
+editorView.setCursorBufferPosition([1, 2])
+```
+
+Refer to the [SpacePen] documentation for more details.
+
+### WorkspaceView
+
+The root of Atom's view hierarchy is a global called `atom.workspaceView`, which is a
+singleton instance of the `WorkspaceView` view class. The root view fills the entire
+window, and contains every other view. If you open Atom's inspector with
+`alt-cmd-i`, you can see the internal structure of `WorkspaceView`:
+
+![WorkspaceView in the inspector][workspaceview-inspector]
+
+#### Panes
+
+The `WorkspaceView` contains `prependToBottom/Top/Left/Right` and
+`appendToBottom/Top/Left/Right` methods, which are used to add Tool Panels. Tool
+panels are elements that take up screen real estate not devoted to text editing.
+In the example above, the `TreeView` is appended to the left, and the
+`CommandPanel` is appended to the top.
+
+```coffeescript
+# place a view to the left of the panes
+atom.workspaceView.appendToLeft(new MyView)
+
+# place a view below the panes
+atom.workspaceView.appendToBottom(new MyOtherView)
+```
+
+[spacepen]: http://github.com/nathansobo/space-pen
+[workspaceView-inspector]: https://f.cloud.github.com/assets/1424/1091631/1932c2d6-166b-11e3-8adf-9690fe82d3b8.png

docs/building-atom.md

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

docs/contributing.md

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

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

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

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

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

docs/creating-a-package.md

@@ -1,53 +1,56 @@
-{{{
-"title": "Creating a Package"
-}}}
+# Creating Packages
 
-# 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.
+Packages are at the core of Atom. Nearly everything outside of the main editor
+is handled by a package. That includes "core" pieces like the [file tree][file-tree],
+[status bar][status-bar], [syntax highlighting][cs-syntax], and more.
 
 A package can contain a variety of different resource types to change Atom's
-behavior. The basic package layout is as follows (though not every package will
-have all of these directories):
+behavior. The basic package layout is as follows:
 
 ```text
 my-package/
-  lib/
-  stylesheets/
-  keymaps/
-  snippets/
   grammars/
+  keymaps/
+  lib/
+  menus/
   spec/
-  package.json
+  snippets/
+  stylesheets/
   index.coffee
+  package.json
 ```
 
+Not every package will have (or need) all of these directories.
+
+We have [a tutorial on creating your first package][first-package].
+
 ## package.json
 
-Similar to [npm packages][npm], Atom packages
-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.
+Similar to [npm packages][npm], Atom packages contain a _package.json_ file
+in their top-level directory. This file contains metadata about the package,
+such as the path to its "main" module, library dependencies, and manifests
+specifying the order in which its resources should be loaded.
 
-In addition to the regular [npm package.json keys](https://npmjs.org/doc/json.html)
-available, Atom package.json files have their own additions.
+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.
+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.
+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 _menus_ directory are added alphabetically.
 - `snippets` (**Optional**): an Array of Strings identifying the order of the
-snippets your package needs to load. If not specified, snippets in the _snippets_
-directory are added alphabetically.
+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.
+trigger your package's activation. You can delay the loading of your package
+until one of these events is triggered.
 
 ## Source Code
 
@@ -64,11 +67,11 @@ 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).
+- `activate(state)`: This **required** method is called when your
+package is activated. It is passed the state data from the last time the window
+was serialized if 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
@@ -83,62 +86,146 @@ you don't need to worry because that's getting torn down anyway.
 
 ### Simple Package Code
 
+Your directory would look like this:
+
 ```text
 my-package/
-  package.json # optional
+  package.json
   index.coffee
   lib/
     my-package.coffee
 ```
 
-`index.coffee`:
+`index.coffee` might be:
 ```coffeescript
 module.exports = require "./lib/my-package"
 ```
 
-`my-package/my-package.coffee`:
+`my-package/my-package.coffee` might start:
 ```coffeescript
 module.exports =
-  activate: (rootView, state) -> # ...
+  activate: (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/atom/atom/)
-for examples of Atom's API in action.
+Beyond this simple contract, your package has access to Atom's API. Be aware
+that since we are early in development, APIs are subject to change and we have
+not yet established clear boundaries between what is public and what is private.
+Also, please collaborate with us if you need an API that doesn't exist. Our goal
+is to build out Atom's API organically based on the needs of package authors
+like you.
 
 ## Stylesheets
 
 Stylesheets for your package should be placed in the _stylesheets_ directory.
 Any stylesheets in this directory will be loaded and attached to the DOM when
-your package is activated. Stylesheets can be written as CSS or LESS.
+your package is activated. Stylesheets can be written as CSS or [LESS] (but LESS
+is recommended).
 
-An optional `stylesheets` array in your _package.json_ can list the stylesheets by
-name to specify a loading order; otherwise, stylesheets are loaded alphabetically.
+Ideally, you won't need much in the way of styling. We've provided a standard
+set of components which define both the colors and UI elements for any package
+that fits into Atom seamlessly. You can view all of Atom's UI components by opening
+the styleguide: open the command palette (`cmd-shift-P`) and search for _styleguide_,
+or just type `cmd-ctrl-G`.
+
+If you _do_ need special styling, try to keep only structural styles in the package
+stylesheets. If you _must_ specify colors and sizing, these should be taken from
+the active theme's [ui-variables.less][ui-variables]. For more information, see the
+[theme variables docs][theme-variables]. If you follow this guideline, your package
+will look good out of the box with any theme!
+
+An optional `stylesheets` array in your _package.json_ can list the stylesheets
+by name to specify a loading order; otherwise, stylesheets are loaded
+alphabetically.
 
 ## Keymaps
 
-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.
+It's recommended that you provide key bindings for commonly used actions 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.
+```coffeescript
+'.tree-view-scroller':
+  'ctrl-V': 'changer:magic'
+```
 
-See the [main keymaps documentation](../internals/keymaps.md) for more information on
+Keymaps are placed in the _keymaps_ subdirectory. By default, all keymaps are
+loaded in alphabetical order. An optional `keymaps` array in your _package.json_
+can specify which keymaps to load and in what order.
+
+
+Keybindings are executed by determining which element the keypress occurred on. In
+the example above, `changer:magic` command is executed when pressing `ctrl-V` on
+the `.tree-view-scroller` element.
+
+See the [main keymaps documentation][keymaps] for more detailed information on
 how keymaps work.
 
+## Menus
+
+Menus are placed in the _menus_ subdirectory. By default, all menus are loaded
+in alphabetical order. An optional `menus` array in your _package.json_ can
+specify which menus to load and in what order.
+
+### Application Menu
+
+It's recommended that you create an application menu item for common actions
+with your package that aren't tied to a specific element:
+
+```coffeescript
+'menu': [
+  {
+    'label': 'Packages'
+    'submenu': [
+      {
+        'label': 'My Package'
+        'submenu': [
+          {
+            'label': 'Toggle'
+            'command': 'my-package:toggle'
+          }
+        ]
+      }
+    ]
+  }
+]
+```
+
+To add your own item to the application menu, simply create a top level `menu`
+key in any menu configuration file in _menus_. This can be a JSON or [CSON] file.
+
+The menu templates you specify are merged with all other templates provided
+by other packages in the order which they were loaded.
+
+### Context Menu
+
+It's recommended to specify a context menu item for commands that are linked to
+specific parts of the interface, like adding a file in the tree-view:
+
+```coffeescript
+'context-menu':
+  '.tree-view':
+    'Add file': 'tree-view:add-file'
+  '.workspace':
+    'Inspect Element': 'core:inspect'
+```
+
+To add your own item to the application menu simply create a top level
+`context-menu` key in any menu configuration file in _menus_. This can be a
+JSON or [CSON] file.
+
+Context menus are created by determining which element was selected and
+then adding all of the menu items whose selectors match that element (in
+the order which they were loaded). The process is then repeated for the
+elements until reaching the top of the DOM tree.
+
+In the example above, the `Add file` item will only appear when the focused item
+or one of its parents has the `tree-view` class applied to it.
+
 ## Snippets
 
-An extension can supply language snippets in the _snippets_ directory. These can
-be `.cson` or `.json` files. Here's an example:
+An extension can supply language snippets in the _snippets_ directory which
+allows the user to enter repetitive text quickly:
 
 ```coffeescript
 ".source.coffee .specs":
@@ -153,24 +240,26 @@ be `.cson` or `.json` files. Here's an example:
     """
 ```
 
-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`.
+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.
+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.
+`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:
 
@@ -195,14 +284,14 @@ To capture a single group, simply use the `name` key instead:
 }
 ```
 
-This indicates that Markdown header lines (`#`, `##`, `###`) should be applied with
-the `markup.heading.gfm` token.
+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).
+[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:
+Your grammar should also include a `filetypes` array, which is a list of file
+extensions your grammar supports:
 
 ```coffeescript
 'fileTypes': [
@@ -214,280 +303,93 @@ your grammar supports:
 ]
 ```
 
+## 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 equivalent 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.
+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
-execute the tests, so you can assume that any DSL available there is available
-to your package as well.
+Under the hood, [Jasmine] executes your tests, so you can assume that any DSL
+available there is available to your package as well.
 
-# Full Example
+**FIXME: Explain the following**
 
-Let's take a look at creating our first package.
+* jasmine
+* jasmine-focused
+* `spec/fixtures` and global.project
+* setTimeout
+* whatever else is different in spec-helper
 
-Atom has a command you can enter that'll create a package for you:
-`package-generator:generate`. Otherwise, you can hit `cmd-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_.
+## Running Tests
 
-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!
+TODO: Probably use the menu option now.
 
-In order to demonstrate the capabilities of Atom and its API, our Changer plugin
-is going to do two things:
+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.
 
-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
+## Publishing
 
-Let's get started!
+Atom bundles a command line utility called [apm] which can be used to publish
+Atom packages to the public registry.
 
-## Changing Keybindings and Commands
+Once your package is written and ready for distribution you can run the
+following to publish your package:
 
-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:
-
-```coffeescript
-'.tree-view-scroller':
-  'ctrl-V': 'changer:magic'
+```sh
+cd my-package
+apm publish minor
 ```
 
-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.
+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.
 
-`.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.
+Run `apm help publish` to see all the available options and `apm help` to see
+all the other available commands.
 
-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:
+## Included Libraries
 
-```coffeescript
-rootView.command "changer:magic", => @magic()
-```
+FIXME: Describe `require 'atom'
 
-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.
+In addition to core node.js modules, all packages can `require` the following
+popular libraries into their packages:
 
-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 '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-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 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)
-```
-
-# 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.
+* [SpacePen] (as `require 'space-pen'`)
+* [jQuery] (as `require 'jquery'`)
+* [Underscore] (as `require 'underscore'`)
 
+Additional libraries can be found by browsing Atom's *node_modules* folder.
 
+[file-tree]: https://github.com/atom/tree-view
+[status-bar]: https://github.com/atom/status-bar
+[cs-syntax]: https://github.com/atom/language-coffee-script
 [npm]: http://en.wikipedia.org/wiki/Npm_(software)
+[npm-keys]: https://npmjs.org/doc/json.html
+[apm]: https://github.com/atom/apm
+[git-tag]: http://git-scm.com/book/en/Git-Basics-Tagging
+[wrap-guide]: https://github.com/atom/wrap-guide/
+[keymaps]: advanced/keymaps.md
+[theme-variables]: theme-variables.md
+[tm-tokens]: http://manual.macromates.com/en/language_grammars.html
+[spacepen]: https://github.com/nathansobo/space-pen
+[path]: http://nodejs.org/docs/latest/api/path.html
+[jquery]: http://jquery.com/
+[underscore]: http://underscorejs.org/
+[jasmine]: https://github.com/pivotal/jasmine
+[cson]: https://github.com/atom/season
+[less]: http://lesscss.org
+[ui-variables]: https://github.com/atom/atom-dark-ui/blob/master/stylesheets/ui-variables.less
+[first-package]: your-first-package.html

docs/creating-a-theme.md

@@ -1,76 +1,135 @@
-{{{
-"title": "Creating a Theme"
-}}}
-
 # Creating a Theme
 
-## Overview
+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.
 
-* Explain the difference between ui themes and syntax themes
+Since CSS is the basis of the theming system, we can load multiple themes within
+Atom, and the themes behave just as they would on a website. Themes loaded first
+are overridden by themes which are loaded later. The order of theme loading is
+controlled within the Settings/Themes pane.
+
+This flexibility is helpful for users that prefer a light interface with a dark
+syntax theme. Atom currently has only interface and syntax themes, but it is
+possible to create a theme to style something specific — say, changing
+the colors in the tree view or creating a language specific syntax theme.
 
 ## Getting Started
 
-* What do I need to install?
-  * Atom - to edit text
-  * Git - to track and distribute your themes
-* What do I need to know?
-  * CSS/LESS - as that's what themes are written in
-  * Devtools - so you can find the selector you're looking for.
-* Is there an example I can start from?
-  * Yes, you can clone https://github.com/atom/solarized-dark-syntax
+Themes are pretty straight forward but it's still helpful to be familiar with
+a few things before starting:
 
-# Create a minimal syntax theme
+* LESS is a superset of CSS, but it has some really handy features like
+  variables. If you aren't familiar with its syntax take a few minutes
+  to [familiarize yourself][less-tutorial].
+* You may also want to review the concept of a _[package.json]_, too. This file
+is used to help distribute your theme to Atom users.
 
-```bash
-cd ~/.atom/packages
-mkdir my-theme
-cd my-theme
-git init
-mkdir stylesheets
-apm init --theme
-cat > index.less <<END
-@import "./stylesheets/base.less";
-@import "./stylesheets/overrides.less";
-END
-cat > stylesheets/base.less <<END
-@import "ui-variables";
+There are two types of themes you can create: syntax themes and interface themes.
+The differences between them are simply a matter of what they target and what
+they provide. Syntax themes focus on the entire editor pane, while interface themes
+target elements which are outside of the editor.
 
-.editor {
-  color: fade(@text-color, 20%);
-}
-END
-cat > stylesheets/overrides.less <<END
-@import "ui-variables";
+## Creating a Syntax Theme
 
-.editor {
-  color: fade(@text-color, 80%);
-}
-END
-```
+Let's create your first theme.
 
-### Important points
+To get started, hit `cmd-shift-P`, and start typing "Generate Theme" to generate
+a package. Select "Generate Theme," and you'll be asked for a theme name. Let's
+call ours _motif_.
 
-* Notice the theme attribute in the package.json file (generated by apm). This
-  is specific to Atom and required for all theme packages. Otherwise they won't
-  be displayed in the theme chooser.
-* Notice the ui-variables require. If you'd like to make your theme adapt to the
-  users choosen ui theme, these variables allow you to create your own colors
-  based on them.
+Atom will pop open a new window, showing the _motif_ theme, with a default set of
+folders and files created for us. If you hit `cmd-,` and navigate to the Themes
+menu option, you'll see the `motif` theme already available. Drag it over from
+"Enabled Themes" to "Available Themes."
 
-## How to create a UI theme
+Open up _stylesheets/colors.less_ to change the various colors variables which
+have been already been defined. For example, turn `@red` into `#f4c2c1`.
 
-* Needs to have a file called ui-variables and it must contain the following
-  variables:
-    * A list of variables from @benogle's theme refactor.
+Then, open _stylesheets/base.less_, and modify the various syntax CSS selectors
+that have been already been defined. Each of these selectors represents a different
+part of the Atom window. Themes that don't need to modify a particular region
+can simply remove the selectors they don't need.
 
-## How to just override UI colors
+As an example, let's make the `.gutter` `background-color` into `@red`.
 
-* Not interested in making an entire theme? Not to worry, you can override just
-  the colors.
-* Create a theme as above but just include a single file in your `stylesheets`
-  directory called `ui-variables.less`
-* IMPORTANT: This theme must come before
+Reload Atom by hitting `cmd-r` to see the changes you made reflected in your Atom
+window. Pretty neat!
 
-## How to create a syntax theme
+## Creating an Interface Theme
 
-* Explain the idea behind grammars/tokens and classes you'd want to override.
+Interface themes  **must** provide a `ui-variables.less` file which contains all
+of the variables provided by the [core themes][ui-variables].
+
+To create an interface UI theme, do the following:
+
+1. Fork one of the following repos
+  1. [atom-dark-ui]
+  1. [atom-light-ui]
+1. Open a terminal in the forked theme's directory
+1. Open your new theme in a Dev Mode Atom window (run `atom -d .` in the terminal or use the __View > Developer > Open in Dev Mode__ menu)
+1. Change the name of the theme in the theme's `package.json` file
+1. Run `apm link` to tell Atom about your new theme
+1. Reload Atom (`cmd-r`)
+1. Enable the theme via the themes panel in settings
+1. Make changes! Since you opened the theme in a Dev Mode window, changes will
+   be instantly reflected in the editor without having to reload.
+
+## Development workflow
+
+There are a few of tools to help make theme development faster.
+
+### Live Reload
+
+Reloading by hitting `cmd-r` after you make changes to your theme is less than ideal.
+Atom supports [live updating][livereload] of styles on Dev Mode Atom windows.
+
+To enable a Dev Mode window:
+
+1. Open your theme directory in a dev window by either going to the
+__View > Developer > Open in Dev Mode__ menu or by hitting the `cmd-shift-o`
+shortcut
+1. Make a change to your theme file and save it. Your change should be
+immediately applied!
+
+If you'd like to reload all the styles at any time, you can use the shortcut
+`cmd-ctrl-R`.
+
+### Developer Tools
+
+Atom is based on the Chrome browser, and supports Chrome's Developer Tools. You
+can open them by selecting the __View > Toggle Developer Tools__ menu, or by using
+the `cmd-option-i` shortcut.
+
+The dev tools allow you to inspect elements and take a look at their CSS
+properties.
+
+![devtools-img]
+
+Check out Google's [extensive tutorial][devtools-tutorial] for a short introduction.
+
+### Atom Styleguide
+
+If you are creating an interface theme, you'll want a way to see how your theme
+changes affect all the components in the system. The [styleguide] is a page with
+every component Atom supports rendered.
+
+To open the styleguide, open the command palette (`cmd-shift-P`) and search for
+_styleguide_, or use the shortcut `cmd-ctrl-shift-g`.
+
+![styleguide-img]
+
+[less]: http://lesscss.org/
+[git]: http://git-scm.com/
+[atom]: https://atom.io/
+[package.json]: ./creating-a-package.html#package-json
+[less-tutorial]: https://speakerdeck.com/danmatthews/less-css
+[devtools-tutorial]: https://developers.google.com/chrome-developer-tools/docs/elements
+[ui-variables]: ./theme-variables.html
+[livereload]: https://github.com/atom/dev-live-reload
+[styleguide]: https://github.com/atom/styleguide
+[atom-dark-ui]: https://github.com/atom/atom-dark-ui
+[atom-light-ui]: https://github.com/atom/atom-light-ui
+[styleguide-img]: https://f.cloud.github.com/assets/69169/1347390/2d431d98-36af-11e3-8f8e-3f4ce1e67adb.png
+[devtools-img]: https://f.cloud.github.com/assets/69169/1347391/2d51f91c-36af-11e3-806f-f7b334af43e9.png
+[themesettings-img]: https://f.cloud.github.com/assets/69169/1347569/3150bd0c-36b2-11e3-9d69-423503acfe3f.png

docs/customizing-atom.md

@@ -1,58 +1,33 @@
-{{{
-"title": "Customizing Atom"
-}}}
+# Customizing Atom
 
-# Configuration Settings
+To change a setting, configure a theme, or install a package just open the
+Settings pane in the current window by pressing `cmd+,`.
 
-## Your .atom Directory
+## Changing The Theme
 
-When you install Atom, an _.atom_ directory is created in your home directory.
-If you press `cmd-,`, 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.
+Because Atom themes are based on CSS, it's possible (and encouraged) to have
+multiple themes active at the same time. Atom comes with both light and dark
+interface themes as well as several syntax themes (you can also [create your
+own][create-theme]).
 
-Atom loads configuration settings from the `config.cson` file in your _~/.atom_
-directory, which contains CoffeeScript-style JSON:
+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.
 
-```coffeescript
-core:
-  hideGitIgnoredFiles: true
-editor:
-  fontSize: 18
-```
+## Installing Packages
 
-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.
+You can install non-bundled packages by going to the `Available Packages`
+section on the `Packages` tab within the Settings panel (`cmd-,`).
 
-## Glossary of Config Keys
+You can also install packages from the command line using the
+[apm](https://github.com/atom/apm) command:
 
-- `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.
+`apm install <package_name>` to install the latest version.
+
+`apm install <package_name>@<package_version>` to install a specific version.
+
+For example `apm install emmet@0.1.5` installs the `0.1.5` release of the
+[Emmet](https://github.com/atom/emmet) package into `~/.atom/packages`.
 
 ## Customizing Key Bindings
 
@@ -65,8 +40,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
@@ -75,51 +51,95 @@ the editor to insert a newline. But if the same keystroke occurs inside of a
 select list's mini-editor, it instead emits the `core:confirm` event based on
 the binding in the more-specific selector.
 
-By default, any keymap files in your `~/.atom/keymaps` directory are loaded
-in alphabetical order when Atom is started. They will always be loaded last,
-giving you the chance to override bindings that are defined by Atom's core
-keymaps or third-party packages.
+By default, `~/.atom/keymap.cson` is loaded when Atom is started. It will always
+be loaded last, giving you the chance to override bindings that are defined by
+Atom's core keymaps or third-party packages.
 
-## Changing The Theme
+You'll want to know all the commands available to you. Open the Settings panel
+(`cmd-,`) and select the _Keybindings_ tab. It will show you all the keybindings
+currently in use.
 
-Atom comes bundled with two themes `atom-dark-*` and `atom-light-*`.
+## Advanced Configuration
 
-Because Atom themes are based on CSS, it's possible to have multiple themes
-active at the same time.
+Atom loads configuration settings from the `config.cson` file in your _~/.atom_
+directory, which contains CoffeeScript-style JSON:
 
-For example, you'll usually select a theme for the UI and another theme for
-syntax highlighting.  You can change themes from the preferences pane.
+```coffeescript
+core:
+  excludeVcsIgnoredPaths: true
+editor:
+  fontSize: 18
+```
 
-You install new themes by placing them in the _~/.atom/themes_ directory. A
-theme can be a single LESS file or a directory containing multiple LESS files.
+The configuration itself is grouped by the package name or one of the two core
+namespaces: `core` and `editor`.
 
-## Installing Packages
+### Configuration Key Reference
 
-FIXME: Rewrite for the new dialog.
+- `core`
+  - `disabledPackages`: An array of package names to disable
+  - `excludeVcsIgnoredPaths`: Don't search within files specified by _.gitignore_
+  - `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`)
+- `wrap-guide`
+  - `columns`: Array of hashes with a `pattern` and `column` key to match the
+             the path of the current editor to a column position.
 
-## Quick Personal Hacks
+### Quick Personal Hacks
 
-### user.coffee
+### init.coffee
 
-When Atom finishes loading, it will evaluate _user.coffee_ in your _~/.atom_
+When Atom finishes loading, it will evaluate _init.coffee_ in your _~/.atom_
 directory, giving you a chance to run arbitrary personal CoffeeScript code to
 make customizations. You have full access to Atom's API from code in this file.
-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.less
+This file can also be named _init.js_ and contain JavaScript code.
+
+### styles.css
 
 If you want to apply quick-and-dirty personal styling changes without creating
 an entire theme that you intend to distribute, you can add styles to
-_user.less_ in your _~/.atom_ directory.
+_styles.css_ in your _~/.atom_ directory.
 
-For example, to change the color of the highlighted line number for the line that
-contains the cursor, you could add the following style to _user.less_:
+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 _styles.css_:
 
-```less
-@highlight-color: pink;
-
-.editor .line-number.cursor-line {
-  color: @highlight-color;
+```css
+.editor .cursor {
+  border-color: pink;
 }
 ```
+
+You can also name the file _styles.less_ if you want to style Atom using
+[LESS][LESS].
+
+[create-a-package]: creating-packages.md
+[create-theme]: creating-a-theme.md
+[LESS]: http://www.lesscss.org

docs/getting-started.md

@@ -1,108 +1,104 @@
-{{{
-"title": "Getting Started"
-}}}
-
 # Getting Started
 
 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][configuring], [theming][theming], and [extending][extending] Atom.
+[configuring], [theming], and [extending] Atom.
 
 ## The Command Palette
 
-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 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 below.
+If there's one key-command you remember in Atom, it should be `cmd-shift-P`. You
+can always press `cmd-shift-P` to bring up a list of commands (and key bindings)
+that are relevant to the currently focused interface element. This is a great
+way to explore the system and learn key bindings interactively. For information
+about adding or changing a key binding refer to the [customizing key
+bindings][key-bindings] section.
 
-![Command Palette](https://f.cloud.github.com/assets/1424/1091618/ee7c3554-166a-11e3-9955-aaa61bb5509c.png)
+![Command Palette]
 
 ## 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.
+Atom windows are scoped to a single directory on disk. If you launch Atom from
+the command line via the `atom` command and don't specify a path, Atom opens a
+window for the current working directory. The current window's directory will be
+visible as the root of the tree view at the left, and also serve as the context
+for all file-related operations.
 
 #### Finding Files
 
-The fastest way to find a file in your project is to use the fuzzy finder. Just
-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.
+The fastest way to find a file is to use the fuzzy finder. Press `cmd-t` and
+begin typing the name of the file you're looking for. If you are looking for a
+file that is already open press `cmd-b` to bring up a searchable list of open
+files.
 
-You can also use the tree view to navigate to a file. To open or move focus to
-the tree view, hit `cmd-\`. You can then navigate to a file and select it with
-`return`.
+You can also use the tree view to navigate to a file. To open and focus the
+the tree view, press `ctrl-0`. The tree view can be toggled open and closed with
+`cmd-\`.
 
 #### Adding, Moving, Deleting Files
 
-Currently, all file modification is performed via the tree view. To add a file,
-select a directory in the tree view and press `a`. Then type the name of the
-file. Any intermediate directories you type will be created automatically if
-needed.
-
-To move or rename a file or directory, select it in the tree view and hit `m`.
-To delete a file, select it in the tree view and hit `delete`.
+Currently, all file modification is performed via the tree view. Add, move, or
+delete a file by right-clicking in the tree view and selecting the desired
+operation from the context menu. You can also perform these operations from the
+keyboard by selecting a file or directory and using `a` to add, `m` to move, and
+`delete` to delete.
 
 ### Searching
 
 #### Find and Replace
 
-FIXME: Describe https://github.com/atom/find-and-replace
+To search within a buffer use `cmd-f`. To search the entire project use
+`cmd-shift-f`.
 
 #### Navigating By Symbols
 
-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.
+To jump to a symbol such as a method definition, press `cmd-r`. This opens a
+list of all symbols in the current file, which you can fuzzy filter similarly to
+`cmd-t`.
 
-To search for symbols across your project use `cmd-shift-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](https://github.com/kevinsawicki/dotfiles/blob/master/.ctags).
+To search for symbols across your project, use `cmd-shift-r`. First you'll need
+to make sure you have ctags installed and a tags file generated for your
+project. Also, if you're editing CoffeeScript, it's a good idea to update your
+`~/.ctags` file to understand the language. Here is [a good example][ctags].
 
 ### Split Panes
 
-You can split any editor pane horizontally or vertically by using `ctrl-\` 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.
+You can split any editor pane horizontally or vertically by using `cmd-k right`
+or `cmd-k down`. Once you have a split pane, you can move focus between them
+with `cmd-k cmd-right` or `cmd-k cmd-down`. To close a pane, close all its
+editors with `meta-w`, then press `meta-w` one more time to close the pane. You
+can configure panes to auto-close with empty in the preferences.
 
 ### Folding
 
-You can fold everything with `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.
+You can fold blocks of code by clicking the arrows that appear when you hover
+your mouse cursor over the gutter. You can also fold and unfold from the
+keyboard with `alt-cmd-[` and `alt-cmd-]`. To fold everything, use
+`alt-cmd-shift-{` and to unfold everything use `alt-cmd-shift-}`. You can also
+fold at a specific indentation level with `cmd-k cmd-N` where N is the
+indentation depth.
 
 ### Soft-Wrap
 
 If you want to toggle soft wrap, trigger the command from the command palette.
-Hit `cmd-p` to open the palette, then type "wrap" to find the correct
-command.
+Press `cmd-shift-P` to open the palette, then type "wrap" to find the correct
+command. By default, lines will wrap based on the size of the editor. If you
+prefer to wrap at a specific line length, toggle "Wrap at preferred line length"
+in preferences.
 
 ## Configuration
 
-If you press `cmd-,`, a configuration panel will appear in the currently focused
-pane. This will serve as the primary interface for adjusting configuration
-settings, adding and changing key bindings, tweaking styles, etc.
+Press `cmd-,` to display the preferences pane. This serves as the primary
+interface for adjusting config settings, installing packages and changing
+themes.
 
 For more advanced configuration see the [customization guide][customization].
 
-## Installing Packages
-
-To install a package, open the configuration panel and select the packages tab.
-
-FIXME: Needs more details.
-
-[configuring]: customizing-atom.html
-[theming]: creating-a-theme.html
-[extending]: creating-a-package.html
-[customization]: customizing-atom.html
+[configuring]: customizing-atom.md
+[theming]: creating-a-theme.md
+[extending]: creating-a-package.md
+[customization]: customizing-atom.md
+[key-bindings]: customizing-atom.md#customizing-key-bindings
+[command palette]: https://f.cloud.github.com/assets/1424/1091618/ee7c3554-166a-11e3-9955-aaa61bb5509c.png
+[ctags]: https://github.com/kevinsawicki/dotfiles/blob/master/.ctags

docs/index.md

@@ -1,16 +1,13 @@
-{{{
-"title": "Guides"
-}}}
-
 ## Guides
 
-* [Getting Started](getting-started.html)
-* [Customizing Atom](customizing-atom.html)
-* [Creating a Package](creating-a-package.html)
-* [Creating a Theme](creating-a-theme.html)
+* [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.html)
-* [Keymaps](internals/keymaps.html)
-* [Serialization](internals/serialization.html)
-* [View System](internals/view-system.html)
+
+* [Configuration](advanced/configuration.md)
+* [Keymaps](advanced/keymaps.md)
+* [Serialization](advanced/serialization.md)
+* [View System](advanced/view-system.md)

docs/internals/configuration.md

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

docs/internals/keymaps.md

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

docs/internals/view-system.md

@@ -1,64 +0,0 @@
-## Atom's View System
-
-### 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
-
-View objects are actually jQuery wrappers around DOM fragments, supporting all
-the typical jQuery traversal and manipulation methods. In addition, view objects
-have methods that are view-specific. For example, you could call both general
-and view-specific on the global `rootView` instance:
-
-```coffeescript
-rootView.find('.editor.active') # standard jQuery method
-rootView.getActiveEditor()      # view-specific method
-```
-
-If you retrieve a jQuery wrapper for an element associated with a view, use the
-`.view()` method to retrieve the element's view object:
-
-```coffeescript
-# this is a plain jQuery object; you can't call view-specific methods
-editorElement = rootView.find('.editor.active')
-
-# get the view object by calling `.view()` to call view-specific methods
-editorView = editorElement.view()
-editorView.setCursorBufferPosition([1, 2])
-```
-
-Refer to the [SpacePen](http://github.com/nathansobo/space-pen) documentation
-for more details.
-
-### RootView
-
-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-cmd-i`, you can see the internal structure of `RootView`:
-
-![RootView in the inspector](https://f.cloud.github.com/assets/1424/1091631/1932c2d6-166b-11e3-8adf-9690fe82d3b8.png)
-
-#### Panes
-
-The `RootView` contains a `#horizontal` and a `#vertical` axis surrounding
-`#panes`. Elements in the horizontal axis will tile across the window
-horizontally, appearing to have a vertical orientation. Items in the vertical
-axis will tile across the window vertically, appearing to have a horizontal
-orientation. You would typically attach tool panels to the root view's primary
-axes. Tool panels are elements which take up some screen real estate that isn't
-devoted to direct editing. In the example above, the `TreeView` is present in
-the `#horizontal` axis to the left of the `#panes`, and the `CommandPanel` is
-present in the `#vertical` axis below the `#panes`.
-
-You can attach a tool panel to an axis using the `horizontal` or `vertical`
-outlets as follows:
-
-```coffeescript
-# place a view to the left of the panes (or use .append() to place it to the right)
-rootView.horizontal.prepend(new MyView)
-
-# place a view below the panes (or use .prepend() to place it above)
-rootView.vertical.append(new MyOtherView)
-```

docs/proposals/private-beta-tasks.md

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

docs/proposals/private-beta-timeline.md

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

docs/publishing-a-package.md

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

docs/setting-up-travis.md

@@ -0,0 +1,39 @@
+# Setting up Travis CI
+
+Packages under the [atom org][atom-org] should use [Travis CI][travis-ci] for
+builds.
+
+Currently we have a [Travis Pro][travis-pro] account since the repositories
+are private.  This process will be simpler and have fewer steps once the
+package repos are made public.
+
+Each package builds using the [build-package][build-package] script, any
+changes to the build should be made in that script and will affect all
+package builds immediately.
+
+Each package builds against the latest successful build of atom@master. The
+master builds are stored in the [atom-master-builds][atom-master-builds] repo
+as releases named by the SHA-1 built.
+
+## Configuring a package
+
+* Run `cd ~/github/my-package` to navigate to the package repo locally
+* Run `apm test` to verify that the package currently builds via [apm][apm]
+* Add the package repo to the [Travis CI team][travis-ci-team]
+* Run `gem install travis` to install the [travis gem][travis-gem]
+* Run `travis login --pro` and log in using the [atom-build][atom-build] user
+  and the password from the *Shared-Developers* folder in LastPass
+* Run `apm ci` to add a `.travis.yml` file to the repo and to configure Travis
+* Log into [Travis][travis-ci] as the `atom-build` user and you should now see
+  the package listed and building
+  
+
+[apm]: https://github.com/atom/apm
+[build-package]: https://github.com/atom/apm/blob/master/script/build-package
+[atom-build]: https://github.com/atom-build
+[atom-master-builds]: https://github.com/atom/atom-master-builds/releases
+[atom-org]: https://github.com/atom
+[travis-ci]: https://magnum.travis-ci.com
+[travis-ci-team]: https://github.com/organizations/atom/teams/596636
+[travis-gem]: https://rubygems.org/gems/travis
+[travis-pro]: http://about.travis-ci.org/docs/user/travis-pro

docs/template.jst

@@ -137,8 +137,7 @@
         </div>
         <div class="collapse navbar-collapse">
           <ul class="nav navbar-nav">
-            <li><a href="/<%= tag %>/index.html">Guides</a></li>
-            <li><a href="/<%= tag %>/api/index.html">API</a></li>
+            <li><a href="/docs/api/<%= tag %>/api/index.html">API</a></li>
           </ul>
         </div><!--/.nav-collapse -->
       </div>

docs/theme-variables.md

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

docs/your-first-package.md

@@ -0,0 +1,155 @@
+# Create Your First Package
+
+This tutorial will guide you though creating a simple command that replaces the
+selected text with [ascii art](http://en.wikipedia.org/wiki/ASCII_art). When you
+run our new command with the word "cool" selected, it will be replaced with:
+
+```
+                     ___
+                    /\_ \
+  ___    ___     ___\//\ \
+ /'___\ / __`\  / __`\\ \ \
+/\ \__//\ \L\ \/\ \L\ \\_\ \_
+\ \____\ \____/\ \____//\____\
+ \/____/\/___/  \/___/ \/____/
+```
+
+The final package can be viewed at
+[https://github.com/atom/ascii-art](https://github.com/atom/ascii-art).
+
+To begin, press `cmd-shift-P` to bring up the [Command
+Palette](https://github.com/atom/command-palette). Type "generate package" and
+select the "Package Generator: Generate Package" command. Now we need to name
+the package. Let's call it _ascii-art_.
+
+Atom will open a new window with the contents of our new _ascii-art_ package
+displayed in the Tree View. Because this window is opened **after** the package
+is created, the ASCII Art package will be loaded and available in our new
+window. To verify this, toggle the Command Palette (`cmd-shift-P`) and type
+"ASCII Art". You'll see a new `ASCII Art: Toggle` command. When triggered, this
+command displays a default message.
+
+Now let's edit the package files to make our ASCII Art package do something
+interesting. Since this package doesn't need any UI, we can remove all
+view-related code. Start by opening up _lib/ascii-art.coffee_. Remove all view
+code, so the `module.exports` section looks like this:
+
+```coffeescript
+module.exports =
+  activate: ->
+```
+
+## Create a Command
+
+Now let's add a command. We recommend that you namespace your commands with the
+package name followed by a `:`, so we'll call our command `ascii-art:convert`.
+Register the command in _lib/ascii-art.coffee_:
+
+```coffeescript
+module.exports =
+  activate: ->
+    atom.workspaceView.command "ascii-art:convert", => @convert()
+
+  convert: ->
+    # This assumes the active pane item is an editor
+    editor = atom.workspace.activePaneItem
+    editor.insertText('Hello, World!')
+```
+
+The `atom.workspaceView.command` method takes a command name and a callback. The
+callback executes when the command is triggered. In this case, when the command
+is triggered the callback will call the `convert` method and insert 'Hello,
+World!'.
+
+## Reload the Package
+
+Before we can trigger `ascii-art:convert`, we need to load the latest code for
+our package by reloading the window. Run the command `window:reload` from the
+command palette or by pressing `ctrl-alt-cmd-l`.
+
+## Trigger the Command
+
+Now open the command panel and search for the `ascii-art:convert` command. But
+it's not there! To fix this, open _package.json_ and find the property called
+`activationEvents`. Activation Events speed up load time by allowing Atom to
+delay a package's activation until it's needed. So remove the existing command
+and add `ascii-art:convert` to the `activationEvents` array:
+
+```json
+"activationEvents": ["ascii-art:convert"],
+```
+
+First, reload the window by running the command `window:reload`. Now when you
+run the `ascii-art:convert` command it will output 'Hello, World!'
+
+## Add a Key Binding
+
+Now let's add a key binding to trigger the `ascii-art:convert` command. Open
+_keymaps/ascii-art.cson_ and add a key binding linking `ctrl-alt-a` to the
+`ascii-art:convert` command. You can delete the pre-existing key binding since
+you don't need it anymore. When finished, the file will look like this:
+
+```coffeescript
+'.editor':
+  'cmd-alt-a': 'ascii-art:convert'
+```
+
+Notice `.editor` on the first line. Just like CSS, keymap selectors *scope* key
+bindings so they only apply to specific elements. In this case, our binding is
+only active for elements matching the `.editor` selector. If the Tree View has
+focus, pressing `cmd-alt-a` won't trigger the `ascii-art:convert` command. But
+if the editor has focus, the `ascii-art:convert` method *will* be triggered.
+More information on key bindings can be found in the
+[keymaps](advanced/keymaps.html) documentation.
+
+Now reload the window and verify that the key binding works! You can also verify
+that it **doesn't** work when the Tree View is focused.
+
+## Add the ASCII Art
+
+Now we need to convert the selected text to ASCII art. To do this we will use
+the [figlet](https://npmjs.org/package/figlet) [node](http://nodejs.org/) module
+from [npm](https://npmjs.org/). Open _package.json_ and add the latest version of
+figlet to the dependencies:
+
+```json
+"dependencies": {
+   "figlet": "1.0.8"
+}
+```
+
+After saving the file, run the command 'update-package-dependencies:update' from
+the Command Palette. This will install the package's node module dependencies,
+only figlet in this case. You will need to run
+'update-package-dependencies:update' whenever you update the dependencies field
+in your _package.json_ file.
+
+Now require the figlet node module in _lib/ascii-art.coffee_ and instead of
+inserting 'Hello, World!' convert the selected text to ASCII art.
+
+```coffeescript
+convert: ->
+  # This assumes the active pane item is an editor
+  editor = atom.workspace.activePaneItem
+  selection = editor.getSelection()
+
+  figlet = require 'figlet'
+  figlet selection.getText(), {font: "Larry 3D 2"}, (error, asciiArt) ->
+    if error
+      console.error(error)
+    else
+      selection.insertText("\n#{asciiArt}\n")
+```
+
+Select some text in an editor window and hit `cmd-alt-a`. :tada: You're now an
+ASCII art professional!
+
+## Further reading
+
+* [Getting your project on GitHub guide](http://guides.github.com/overviews/desktop)
+
+* [Creating a package guide](creating-a-package.html) for more information
+  on the mechanics of packages
+
+* [Publishing a package guide](publish-a-package.html) for more information
+  on publishing your package to [atom.io](https://atom.io)

dot-atom/init.coffee

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

dot-atom/keymap.cson

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

dot-atom/snippets.cson

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

dot-atom/snippets/coffee.cson

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

dot-atom/styles.css

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

dot-atom/themes/README.md

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

dot-atom/user.coffee

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

dot-atom/user.css

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

exports/atom.coffee

@@ -0,0 +1,25 @@
+{Point, Range} = require 'text-buffer'
+
+module.exports =
+  _: require 'underscore-plus'
+  BufferedNodeProcess: require '../src/buffered-node-process'
+  BufferedProcess: require '../src/buffered-process'
+  fs: require 'fs-plus'
+  Git: require '../src/git'
+  Point: Point
+  Range: Range
+
+# The following classes can't be used from a Task handler and should therefore
+# only be exported when not running as a child node process
+unless process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
+  {$, $$, $$$, View} = require '../src/space-pen-extensions'
+
+  module.exports.$ = $
+  module.exports.$$ = $$
+  module.exports.$$$ = $$$
+  module.exports.EditorView = require '../src/editor-view'
+  module.exports.ScrollView = require '../src/scroll-view'
+  module.exports.SelectListView = require '../src/select-list-view'
+  module.exports.Task = require '../src/task'
+  module.exports.View = View
+  module.exports.WorkspaceView = require '../src/workspace-view'

keymaps/apple.cson

@@ -1,21 +0,0 @@
-'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-right': 'editor:move-to-end-of-line'
-  'meta-left': 'editor:move-to-beginning-of-line'
-  'alt-left': 'editor:move-to-beginning-of-word'
-  'alt-right': 'editor:move-to-end-of-word'
-  'meta-shift-left': 'editor:select-to-beginning-of-line'
-  'meta-shift-right': 'editor:select-to-end-of-line'
-  'alt-shift-left': 'editor:select-to-beginning-of-word'
-  'alt-shift-right': 'editor:select-to-end-of-word'
-  '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,96 +0,0 @@
-'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'
-  'escape': 'core:cancel'
-  'meta-w': 'core:close'
-  'up': 'core:move-up'
-  'down': 'core:move-down'
-  'left': 'core:move-left'
-  'right': 'core:move-right'
-  'shift-up': 'core:select-up'
-  'shift-down': 'core:select-down'
-  'shift-left': 'core:select-left'
-  'shift-right': 'core:select-right'
-  'meta-a': 'core:select-all'
-  'backspace': 'core:backspace'
-  'shift-backspace': 'core:backspace'
-  'delete': 'core:delete'
-  'meta-z': 'core:undo'
-  'meta-Z': 'core:redo'
-  'meta-x': 'core:cut'
-  'meta-c': 'core:copy'
-  'meta-v': 'core:paste'
-  'pageup': 'core:page-up'
-  'pagedown': 'core:page-down'
-
-  'meta-alt-s': 'window:save-all'
-  'meta-W': 'window:close'
-  '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'
-  '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'
-  'ctrl--': 'pane:split-down'
-  'ctrl-w s': 'pane:split-down'
-
-  'meta-{': 'pane:show-previous-item'
-  'meta-}': 'pane:show-next-item'
-  'alt-meta-left': 'pane:show-previous-item'
-  'alt-meta-right': 'pane:show-next-item'
-  'meta-1': 'pane:show-item-1'
-  'meta-2': 'pane:show-item-2'
-  'meta-3': 'pane:show-item-3'
-  'meta-4': 'pane:show-item-4'
-  'meta-5': 'pane:show-item-5'
-  'meta-6': 'pane:show-item-6'
-  'meta-7': 'pane:show-item-7'
-  'meta-8': 'pane:show-item-8'
-  'meta-9': 'pane:show-item-9'
-  'meta-T': 'pane:reopen-closed-item'
-  'alt-meta-w': 'pane:close-other-items'
-  'meta-P': 'pane:close'
-
-'.tool-panel':
-  'meta-escape': 'tool-panel:unfocus'
-  'escape': 'core:close'
-  'meta-w': 'noop'
-
-# allow standard input fields to work correctly
-'input:not(.hidden-input)':
-  'tab': 'core:focus-next'
-  'shift-tab': 'core:focus-previous'
-  'left': 'native!'
-  'right': 'native!'
-  'shift-left': 'native!'
-  'shift-right': 'native!'
-  'backspace': 'native!'
-  'shift-backspace': 'native!'
-  'delete': 'native!'
-  'meta-z': 'native!'
-  'meta-Z': 'native!'
-  'meta-x': 'native!'
-  'meta-c': 'native!'
-  'meta-v': 'native!'
-
-'button':
-  'tab': 'core:focus-next'
-  'shift-tab': 'core:focus-previous'

keymaps/base.cson

@@ -0,0 +1,78 @@
+'.editor':
+  # Platform Bindings
+  'alt-left': 'editor:move-to-beginning-of-word'
+  'alt-right': 'editor:move-to-end-of-word'
+  'alt-shift-left': 'editor:select-to-beginning-of-word'
+  'alt-shift-right': 'editor:select-to-end-of-word'
+  'home': 'editor:move-to-first-character-of-line'
+  'end': 'editor:move-to-end-of-screen-line'
+  'shift-home': 'editor:select-to-first-character-of-line'
+  'shift-end': 'editor:select-to-end-of-line'
+
+  # Sublime Parity
+  'ctrl-t': 'editor:transpose'
+
+'.editor:not(.mini)':
+  # Atom Specific
+  'ctrl-C': 'editor:copy-path'
+
+  # Sublime Parity
+  'tab': 'editor:indent'
+  'enter': 'editor:newline'
+  'shift-tab': 'editor:outdent-selected-rows'
+  'ctrl-K': 'editor:delete-line'
+  'ctrl-shift-up': 'editor:add-selection-above'
+  'ctrl-shift-down': 'editor:add-selection-below'
+
+'.tool-panel.panel-left, .tool-panel.panel-right':
+  'escape': 'tool-panel:unfocus'
+
+'.editor !important, .editor.mini !important':
+  'escape': 'editor:consolidate-selections'
+
+# allow standard input fields to work correctly
+'body .native-key-bindings':
+  'tab': 'core:focus-next'
+  'shift-tab': 'core:focus-previous'
+  'enter': 'native!'
+  'backspace': 'native!'
+  'shift-backspace': 'native!'
+  'delete': 'native!'
+  'up': 'native!'
+  'down': 'native!'
+  'shift-up': 'native!'
+  'shift-down': 'native!'
+  'alt-up': 'native!'
+  'alt-down': 'native!'
+  'alt-shift-up': 'native!'
+  'alt-shift-down': 'native!'
+  'cmd-up': 'native!'
+  'cmd-down': 'native!'
+  'cmd-shift-up': 'native!'
+  'cmd-shift-down': 'native!'
+  'ctrl-up': 'native!'
+  'ctrl-down': 'native!'
+  'ctrl-shift-up': 'native!'
+  'ctrl-shift-down': 'native!'
+  'left': 'native!'
+  'right': 'native!'
+  'shift-left': 'native!'
+  'shift-right': 'native!'
+  'alt-left': 'native!'
+  'alt-right': 'native!'
+  'alt-shift-left': 'native!'
+  'alt-shift-right': 'native!'
+  'cmd-left': 'native!'
+  'cmd-right': 'native!'
+  'cmd-shift-left': 'native!'
+  'cmd-shift-right': 'native!'
+  'ctrl-left': 'native!'
+  'ctrl-right': 'native!'
+  'ctrl-shift-left': 'native!'
+  'ctrl-shift-right': 'native!'
+  'ctrl-b': 'native!'
+  'ctrl-f': 'native!'
+  'ctrl-F': 'native!'
+  'ctrl-B': 'native!'
+  'ctrl-h': 'native!'
+  'ctrl-d': 'native!'

keymaps/darwin.cson

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

keymaps/editor.cson

@@ -1,47 +0,0 @@
-'.editor':
-  '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'
-  'ctrl-{': 'editor:fold-all'
-  'ctrl-}': 'editor:unfold-all'
-  'ctrl-meta-1': 'editor:fold-at-indent-level-1'
-  'ctrl-meta-2': 'editor:fold-at-indent-level-2'
-  'ctrl-meta-3': 'editor:fold-at-indent-level-3'
-  'ctrl-meta-4': 'editor:fold-at-indent-level-4'
-  'ctrl-meta-5': 'editor:fold-at-indent-level-5'
-  'ctrl-meta-6': 'editor:fold-at-indent-level-6'
-  'ctrl-meta-7': 'editor:fold-at-indent-level-7'
-  'ctrl-meta-8': 'editor:fold-at-indent-level-8'
-  'ctrl-meta-9': 'editor:fold-at-indent-level-9'
-
-  'alt-shift-down': 'editor:add-selection-below'
-  'alt-shift-up': 'editor:add-selection-above'
-  'alt-meta-ctrl-f': 'editor:fold-selection'
-  '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-<': 'editor:scroll-to-cursor'
-
-'.editor.mini':
-  'enter': 'core:confirm',
-  'escape': 'core:cancel'
-  'meta-w': 'core:cancel'
-
-'.editor !important, .editor.mini !important':
-  'escape': 'editor:consolidate-selections'

keymaps/emacs.cson

@@ -1,33 +1,7 @@
-'body':
-  'ctrl-p': 'core:move-up'
-  'ctrl-n': 'core:move-down'
-  'ctrl-b': 'core:move-left'
-  'ctrl-f': 'core:move-right'
-  'ctrl-P': 'core:select-up'
-  'ctrl-N': 'core:select-down'
-  'ctrl-F': 'core:select-right'
-  'ctrl-B': 'core:select-left'
-  'alt-ctrl-n': 'editor:add-selection-below'
-  'alt-ctrl-p': 'editor:add-selection-above'
-  'ctrl-h': 'core:backspace'
-  'ctrl-d': 'core:delete'
-
 '.editor':
   'alt-f': 'editor:move-to-end-of-word'
   'alt-F': 'editor:select-to-end-of-word'
   'alt-b': 'editor:move-to-beginning-of-word'
   'alt-B': 'editor:select-to-beginning-of-word'
-  'ctrl-a': 'editor:move-to-first-character-of-line'
-  'ctrl-e': 'editor:move-to-end-of-line'
   'alt-h': 'editor:backspace-to-beginning-of-word'
   'alt-d': 'editor:delete-to-end-of-word'
-  'ctrl-k': 'editor:cut-to-end-of-line'
-
-# allow standard input fields to work correctly
-'input:not(.hidden-input)':
-  'ctrl-b': 'native!'
-  'ctrl-f': 'native!'
-  'ctrl-F': 'native!'
-  'ctrl-B': 'native!'
-  'ctrl-h': 'native!'
-  'ctrl-d': 'native!'

keymaps/git.cson

@@ -1,2 +0,0 @@
-'.editor':
-  'alt-meta-z': 'editor:checkout-head-revision'

keymaps/select-list.cson

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

keymaps/win32.cson

@@ -0,0 +1,107 @@
+'body':
+  # Atom Specific
+  'enter': 'core:confirm'
+  'escape': 'core:cancel'
+  'up': 'core:move-up'
+  'down': 'core:move-down'
+  'left': 'core:move-left'
+  'right': 'core:move-right'
+  'ctrl-alt-r': 'window:reload'
+  'ctrl-alt-i': 'window:toggle-dev-tools'
+  'ctrl-alt-p': 'window:run-package-specs'
+  'ctrl-alt-s': 'application:run-all-specs'
+
+  # Sublime Parity
+  'ctrl-N': 'application:new-window'
+  'ctrl-W': 'window:close'
+  'ctrl-o': 'application:open'
+  'ctrl-T': 'pane:reopen-closed-item'
+  'ctrl-n': 'application:new-file'
+  'ctrl-s': 'core:save'
+  'ctrl-S': 'core:save-as'
+  'ctrl-w': 'core:close'
+  'ctrl-z': 'core:undo'
+  'ctrl-y': 'core:redo'
+  'ctrl-x': 'core:cut'
+  'ctrl-c': 'core:copy'
+  'ctrl-v': 'core:paste'
+  'shift-up': 'core:select-up'
+  'shift-down': 'core:select-down'
+  'shift-left': 'core:select-left'
+  'shift-right': 'core:select-right'
+  'delete': 'core:delete'
+  'pageup': 'core:page-up'
+  'pagedown': 'core:page-down'
+  'backspace': 'core:backspace'
+  'ctrl-tab': 'pane:show-next-item'
+  'ctrl-shift-tab': 'pane:show-previous-item'
+  'ctrl-shift-up': 'core:move-up'
+  'ctrl-shift-down': 'core:move-down'
+  'ctrl-=': 'window:increase-font-size'
+  'ctrl-+': 'window:increase-font-size'
+  'ctrl--': 'window:decrease-font-size'
+  'ctrl-_': 'window:decrease-font-size'
+  'ctrl-0': 'window:reset-font-size'
+
+  'ctrl-k up': 'pane:split-up' # Atom Specific
+  'ctrl-k down': 'pane:split-down' # Atom Specific
+  'ctrl-k left': 'pane:split-left' # Atom Specific
+  'ctrl-k right': 'pane:split-right' # Atom Specific
+  'ctrl-k ctrl-w': 'pane:close' # Atom Specific
+  'ctrl-k alt-ctrl-w': 'pane:close-other-items' # Atom Specific
+  'ctrl-k ctrl-p': 'window:focus-previous-pane'
+  'ctrl-k ctrl-n': 'window:focus-next-pane'
+  'ctrl-k ctrl-up':    'window:focus-pane-above'
+  'ctrl-k ctrl-down':  'window:focus-pane-below'
+  'ctrl-k ctrl-left':  'window:focus-pane-on-left'
+  'ctrl-k ctrl-right': 'window:focus-pane-on-right'
+
+'.workspace .editor':
+  # Windows specific
+  'ctrl-delete': 'editor:backspace-to-beginning-of-word'
+
+  # Sublime Parity
+  'ctrl-a': 'core:select-all'
+  'ctrl-alt-p': 'editor:log-cursor-scope'
+  'ctrl-k ctrl-u': 'editor:upper-case'
+  'ctrl-k ctrl-l': 'editor:lower-case'
+
+'.workspace .editor:not(.mini)':
+  # Atom specific
+  'alt-ctrl-z': 'editor:checkout-head-revision'
+  'ctrl-<': 'editor:scroll-to-cursor'
+  'alt-ctrl-f': 'editor:fold-selection'
+
+  # Sublime Parity
+  'ctrl-enter': 'editor:newline-below'
+  'ctrl-shift-enter': 'editor:newline-above'
+  'ctrl-]': 'editor:indent-selected-rows'
+  'ctrl-[': 'editor:outdent-selected-rows'
+  'ctrl-up': 'editor:move-line-up'
+  'ctrl-down': 'editor:move-line-down'
+  'ctrl-/': 'editor:toggle-line-comments'
+  'ctrl-j': 'editor:join-line'
+  'ctrl-D': 'editor:duplicate-line'
+
+  'ctrl-alt-[': 'editor:fold-current-row'
+  'ctrl-alt-]': 'editor:unfold-current-row'
+  'ctrl-alt-{': 'editor:fold-all' # Atom Specific
+  'ctrl-alt-}': 'editor:unfold-all' # Atom Specific
+  'ctrl-k ctrl-0': 'editor:unfold-all'
+  'ctrl-k ctrl-1': 'editor:fold-at-indent-level-1'
+  'ctrl-k ctrl-2': 'editor:fold-at-indent-level-2'
+  'ctrl-k ctrl-3': 'editor:fold-at-indent-level-3'
+  'ctrl-k ctrl-4': 'editor:fold-at-indent-level-4'
+  'ctrl-k ctrl-5': 'editor:fold-at-indent-level-5'
+  'ctrl-k ctrl-6': 'editor:fold-at-indent-level-6'
+  'ctrl-k ctrl-7': 'editor:fold-at-indent-level-7'
+  'ctrl-k ctrl-8': 'editor:fold-at-indent-level-8'
+  'ctrl-k ctrl-9': 'editor:fold-at-indent-level-9'
+
+# allow standard input fields to work correctly
+'body .native-key-bindings':
+  'ctrl-z': 'native!'
+  'ctrl-Z': 'native!'
+  'ctrl-x': 'native!'
+  'ctrl-c': 'native!'
+  'ctrl-v': 'native!'

menus/darwin.cson

@@ -0,0 +1,172 @@
+'menu': [
+  {
+    label: 'Atom'
+    submenu: [
+      { label: 'About Atom', command: 'application:about' }
+      { label: "VERSION", enabled: false }
+      { label: "Restart and Install Update", command: 'application:install-update', visible: false}
+      { label: "Check for Update", command: 'application:check-for-update', visible: false}
+      { type: 'separator' }
+      { label: 'Preferences...', command: 'application:show-settings' }
+      { label: 'Open Your Config', command: 'application:open-your-config' }
+      { label: 'Open Your Init Script', command: 'application:open-your-init-script' }
+      { label: 'Open Your Keymap', command: 'application:open-your-keymap' }
+      { label: 'Open Your Snippets', command: 'application:open-your-snippets' }
+      { label: 'Open Your Stylesheet', command: 'application:open-your-stylesheet' }
+      { type: 'separator' }
+      { label: 'Install Shell Commands', command: 'window:install-shell-commands' }
+      { type: 'separator' }
+      { label: 'Hide Atom', command: 'application:hide' }
+      { label: 'Hide Others', command: 'application:hide-other-applications' }
+      { 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' }
+      { label: 'Split into Lines', command: 'editor:split-selections-into-lines'}
+      { type: 'separator' }
+      { label: 'Select to Top', command: 'core:select-to-top' }
+      { label: 'Select to Bottom', command: 'core:select-to-bottom' }
+      { 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: 'Find'
+    submenu: []
+  }
+
+  {
+    label: 'View'
+    submenu: [
+      { label: 'Reload', command: 'window:reload' }
+      { label: 'Toggle Full Screen', command: 'window:toggle-full-screen' }
+      {
+        label: 'Developer'
+        submenu: [
+          { label: 'Open In Dev Mode...', command: 'application:open-dev' }
+          { label: 'Run Atom Specs', command: 'application:run-all-specs' }
+          { label: 'Run Package Specs', command: 'window:run-package-specs' }
+          { label: 'Toggle Developer Tools', command: 'window:toggle-dev-tools' }
+        ]
+      }
+      { type: 'separator' }
+      { label: 'Toggle Soft Wrap', command: 'editor:toggle-soft-wrap' }
+    ]
+  }
+
+  {
+    label: 'Packages'
+    submenu: []
+  }
+
+  {
+    label: 'Window'
+    submenu: [
+      { label: 'Minimize', command: 'application:minimize' }
+      { label: 'Zoom', command: 'application:zoom' }
+      { type: 'separator' }
+      { label: 'Bring All to Front', command: 'application:bring-all-windows-to-front' }
+    ]
+  }
+
+  {
+    label: 'Help'
+    submenu: [
+      { label: 'Documentation', command: 'application:open-documentation' }
+      { label: 'Report an Issue', command: 'application:report-issue' }
+      { type: 'separator' }
+    ]
+  }
+]

menus/win32.cson

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

package.json

@@ -1,7 +1,8 @@
 {
   "name": "atom",
-  "version": "26.0.0",
-  "main": "./src/main.js",
+  "productName": "Atom",
+  "version": "0.51.0",
+  "main": "./src/browser/main.js",
   "repository": {
     "type": "git",
     "url": "https://github.com/atom/atom.git"
@@ -9,120 +10,136 @@
   "bugs": {
     "url": "https://github.com/atom/atom/issues"
   },
-  "atomShellVersion": "0.4.5",
+  "licenses": [
+    {
+      "type": "Apache",
+      "url": "http://github.com/atom/atom/raw/master/LICENSE.md"
+    }
+  ],
+  "atomShellVersion": "0.9.2",
   "dependencies": {
     "async": "0.2.6",
-    "coffee-script": "1.6.2",
-    "coffeestack": "0.4.0",
-    "first-mate": "0.1.0",
-    "git-utils": "0.24.0",
+    "bootstrap": "git://github.com/atom/bootstrap.git#6af81906189f1747fd6c93479e3d998ebe041372",
+    "clear-cut": "0.2.0",
+    "coffee-script": "1.7.0",
+    "coffeestack": "0.7.0",
+    "delegato": "1.x",
+    "emissary": "1.x",
+    "first-mate": ">=1.1.5 <2.0",
+    "fs-plus": "2.x",
+    "fstream": "0.1.24",
+    "fuzzaldrin": "1.x",
+    "git-utils": "1.x",
     "guid": "0.0.10",
-    "jasmine-focused": "~0.12.0",
+    "jasmine-tagged": "1.x",
     "mkdirp": "0.3.5",
-    "less": "git://github.com/nathansobo/less.js.git",
-    "nak": "0.2.18",
-    "nslog": "0.1.0",
-    "oniguruma": "0.20.0",
+    "keytar": "0.15.1",
+    "less-cache": "0.12.0",
+    "mixto": "1.x",
+    "nslog": "0.5.0",
+    "oniguruma": "1.x",
     "optimist": "0.4.0",
-    "pathwatcher": "0.5.0",
-    "patrick": "0.4.0",
-    "pegjs": "0.7.0",
-    "plist": "git://github.com/nathansobo/node-plist.git",
-    "rimraf": "2.1.4",
-    "season": "0.12.0",
+    "pathwatcher": "0.16.0",
+    "pegjs": "0.8.0",
+    "property-accessors": "1.x",
+    "q": "1.0.x",
+    "random-words": "0.0.1",
+    "runas": "0.5.x",
+    "scandal": "0.14.0",
+    "season": "1.x",
     "semver": "1.1.4",
-    "space-pen": "1.2.0",
-    "tantamount": "0.3.0",
-    "telepath": "0.1.2",
+    "serializable": "1.x",
+    "space-pen": "3.1.1",
     "temp": "0.5.0",
-    "underscore": "1.4.4",
-    "archive-view": "0.3.0",
-    "autocomplete": "0.4.0",
-    "autoflow": "0.1.0",
-    "bookmarks": "0.2.0",
-    "bracket-matcher": "0.3.0",
-    "collaboration": "0.9.0",
-    "command-logger": "0.2.0",
-    "command-panel": "0.2.0",
-    "command-palette": "0.1.0",
-    "fuzzy-finder": "0.3.0",
-    "editor-stats": "0.1.0",
-    "gfm": "0.3.0",
-    "git-diff": "0.2.0",
-    "gists": "0.1.0",
-    "github-sign-in": "0.1.0",
-    "go-to-line": "0.2.0",
-    "grammar-selector": "0.2.0",
-    "image-view": "0.3.0",
-    "link": "0.1.0",
-    "markdown-preview": "0.2.0",
-    "package-generator": "0.4.0",
-    "settings-view": "0.11.0",
-    "snippets": "0.2.0",
-    "spell-check": "0.3.0",
-    "status-bar": "0.3.0",
-    "symbols-view": "0.4.0",
-    "tabs": "0.2.0",
-    "terminal": "0.7.0",
-    "to-the-hubs": "0.1.0",
-    "toml": "0.1.0",
-    "tree-view": "0.2.1",
-    "whitespace": "0.3.0",
-    "wrap-guide": "0.1.0",
-    "c-tmbundle": "1.0.0",
-    "coffee-script-tmbundle": "6.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"
+    "text-buffer": ">=1.1.2 <2.0",
+    "theorist": "1.x",
+    "underscore-plus": "1.x",
+    "vm-compatibility-layer": "0.1.0"
   },
-  "devDependencies": {
-    "biscotto": "0.0.16",
-    "grunt": "~0.4.1",
-    "grunt-cli": "~0.1.9",
-    "grunt-coffeelint": "0.0.6",
-    "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",
-    "walkdir": "0.0.7",
-    "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-dark-syntax": "0.13.0",
+    "atom-dark-ui": "0.22.0",
+    "atom-light-syntax": "0.13.0",
+    "atom-light-ui": "0.21.0",
+    "base16-tomorrow-dark-theme": "0.11.0",
+    "solarized-dark-syntax": "0.9.0",
+    "solarized-light-syntax": "0.5.0",
+    "archive-view": "0.23.0",
+    "autocomplete": "0.23.0",
+    "autoflow": "0.14.0",
+    "autosave": "0.11.0",
+    "background-tips": "0.7.0",
+    "bookmarks": "0.20.0",
+    "bracket-matcher": "0.20.0",
+    "command-palette": "0.17.0",
+    "dev-live-reload": "0.26.0",
+    "exception-reporting": "0.13.0",
+    "feedback": "0.24.0",
+    "find-and-replace": "0.83.0",
+    "fuzzy-finder": "0.35.0",
+    "gists": "0.17.0",
+    "git-diff": "0.24.0",
+    "github-sign-in": "0.19.0",
+    "go-to-line": "0.16.0",
+    "grammar-selector": "0.20.0",
+    "image-view": "0.24.0",
+    "keybinding-resolver": "0.10.0",
+    "link": "0.17.0",
+    "markdown-preview": "0.32.0",
+    "metrics": "0.26.0",
+    "open-on-github": "0.20.0",
+    "package-generator": "0.26.0",
+    "release-notes": "0.20.0",
+    "settings-view": "0.76.0",
+    "snippets": "0.30.0",
+    "spell-check": "0.25.0",
+    "status-bar": "0.32.0",
+    "styleguide": "0.24.0",
+    "symbols-view": "0.36.0",
+    "tabs": "0.19.0",
+    "timecop": "0.13.0",
+    "tree-view": "0.69.0",
+    "update-package-dependencies": "0.3.0",
+    "welcome": "0.4.0",
+    "whitespace": "0.14.0",
+    "wrap-guide": "0.14.0",
+    "language-c": "0.8.0",
+    "language-clojure": "0.2.0",
+    "language-coffee-script": "0.9.0",
+    "language-css": "0.7.0",
+    "language-gfm": "0.17.0",
+    "language-git": "0.6.0",
+    "language-go": "0.4.0",
+    "language-html": "0.5.0",
+    "language-hyperlink": "0.5.0",
+    "language-java": "0.5.0",
+    "language-javascript": "0.8.0",
+    "language-json": "0.5.0",
+    "language-less": "0.4.0",
+    "language-make": "0.4.0",
+    "language-mustache": "0.3.0",
+    "language-objective-c": "0.5.0",
+    "language-pegjs": "0.3.0",
+    "language-perl": "0.5.0",
+    "language-php": "0.6.0",
+    "language-property-list": "0.5.0",
+    "language-puppet": "0.5.0",
+    "language-python": "0.5.0",
+    "language-ruby": "0.11.0",
+    "language-ruby-on-rails": "0.6.0",
+    "language-sass": "0.6.0",
+    "language-shellscript": "0.5.0",
+    "language-source": "0.5.0",
+    "language-sql": "0.5.0",
+    "language-text": "0.4.0",
+    "language-todo": "0.4.0",
+    "language-toml": "0.9.0",
+    "language-xml": "0.5.0",
+    "language-yaml": "0.4.0"
   },
   "private": true,
   "scripts": {
-    "preinstall": "true",
-    "test": "grunt test"
+    "preinstall": "node -e 'process.exit(0)'",
+    "test": "node script/test"
   }
 }

script/bootstrap

@@ -1,22 +1,51 @@
-#!/bin/sh
+#!/usr/bin/env node --harmony_collections
+var safeExec = require('./utils/child-process-wrapper.js').safeExec;
+var fs = require('fs');
+var path = require('path');
 
-# exit on subprocess errors
-set -o errexit
+// OAuth token for atom-bot
+// TODO Remove once all repositories are public
+if (!process.env.ATOM_ACCESS_TOKEN)
+  process.env.ATOM_ACCESS_TOKEN = '362295be4c5258d3f7b967bbabae662a455ca2a7';
 
-exit_unless_npm_exists() {
-  if ! hash npm 2> /dev/null; then
-    echo "ERROR: Atom requires npm"
-    exit 1
-  fi
+// Executes an array of commands one by one.
+function executeCommands(commands, done, index) {
+  index = (index == undefined ? 0 : index);
+  if (index < commands.length) {
+    var command = commands[index];
+    var options = null;
+    if (typeof command !== 'string') {
+      options = command.options;
+      command = command.command;
+    }
+    safeExec(command, options, executeCommands.bind(this, commands, done, index + 1));
+  } else
+    done(null);
 }
 
-exit_unless_npm_exists
+var apmVendorPath = path.resolve(__dirname, '..', 'vendor', 'apm');
+var apmInstallPath = path.resolve(__dirname, '..', 'apm');
+if (!fs.existsSync(apmInstallPath))
+  fs.mkdirSync(apmInstallPath);
+if (!fs.existsSync(path.join(apmInstallPath, 'node_modules')))
+  fs.mkdirSync(path.join(apmInstallPath, 'node_modules'));
 
-git submodule --quiet sync
-git submodule --quiet update --recursive --init
+var apmFlags = process.env.JANKY_SHA1 || process.argv.indexOf('--no-color') !== -1 ? '--no-color' : '';
+var packagesToDedupe = ['fs-plus', 'humanize-plus', 'oniguruma', 'roaster', 'season'];
+var echoNewLine = process.platform == 'win32' ? 'echo.' : 'echo';
+var commands = [
+  'git submodule --quiet sync',
+  'git submodule --quiet update --recursive --init',
+  {command: 'npm install --quiet', options: {cwd: path.resolve(__dirname, '..', 'build'), ignoreStdout: true}},
+  {command: 'npm install --quiet', options: {cwd: apmVendorPath, ignoreStdout: true}},
+  {command: 'npm install --quiet ' + apmVendorPath, options: {cwd: apmInstallPath, ignoreStdout: true}},
+  {command: 'npm install --quiet ' + apmVendorPath, options: {ignoreStdout: true}},
+  {command: 'node ../../apm/node_modules/atom-package-manager/bin/apm rebuild', options: {cwd: path.resolve('node_modules', 'atom-package-manager'), ignoreStdout: true}},
+  echoNewLine,
+  'node apm/node_modules/atom-package-manager/bin/apm clean ' + apmFlags,
+  'node apm/node_modules/atom-package-manager/bin/apm install --quiet ' + apmFlags,
+  'node apm/node_modules/atom-package-manager/bin/apm dedupe --quiet ' + apmFlags + ' ' + packagesToDedupe.join(' '),
+];
 
-(cd vendor/apm && npm install --silent .)
-
-npm install --silent vendor/apm
-echo ""
-./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,13 @@
-#!/bin/sh
+#!/usr/bin/env node --harmony_collections
+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() {
+  // build/node_modules/.bin/grunt "$@"
+  var gruntPath = path.join('build', 'node_modules', '.bin', 'grunt') + (process.platform === 'win32' ? '.cmd' : '');
+  var args = ['--gruntfile', path.resolve('build', 'Gruntfile.coffee')];
+  args = args.concat(process.argv.slice(2));
+  cp.safeSpawn(gruntPath, args, process.exit);
+});

script/build.cmd

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

script/cibuild

@@ -1,12 +1,44 @@
-#!/bin/sh
+#!/usr/bin/env node --harmony_collections
+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 == 'linux')
+  throw new Error('cibuild can not run on linux yet!');
 
-rm -rf ~/.atom
-git clean -dff
+var homeDir = process.platform == 'win32' ? process.env.USERPROFILE : process.env.HOME;
 
-./script/bootstrap
-./node_modules/.bin/apm clean
-./node_modules/.bin/grunt ci --stack --no-color
+function loadEnvironmentVariables(filePath) {
+  try {
+    var lines = fs.readFileSync(filePath, 'utf8').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) { }
+}
+
+function readEnvironmentVariables() {
+  loadEnvironmentVariables('/var/lib/jenkins/config/atomcredentials')
+  loadEnvironmentVariables('/var/lib/jenkins/config/xcodekeychain')
+}
+
+readEnvironmentVariables();
+cp.safeExec.bind(global, 'node script/bootstrap', function(error) {
+  if (error)
+    process.exit(1);
+  require('fs-plus').removeSync.bind(global, path.join(homeDir, '.atom'))
+  var async = require('async');
+  var gruntPath = path.join('build', 'node_modules', '.bin', 'grunt') + (process.platform === 'win32' ? '.cmd' : '');
+  var tasks = [
+    cp.safeExec.bind(global, 'git clean -dff'),
+    cp.safeExec.bind(global, gruntPath + ' ci --gruntfile build/Gruntfile.coffee --stack --no-color'),
+  ]
+  async.series(tasks, function(error) {
+    process.exit(error ? 1 : 0);
+  });
+})();

script/clean

@@ -0,0 +1,37 @@
+#!/usr/bin/env node --harmony_collections
+var cp = require('./utils/child-process-wrapper.js');
+var path = require('path');
+var os = require('os');
+
+var removeCommand = process.platform === 'win32' ? 'del /F /Q /S ' : 'rm -rf ';
+var productName = require('../package.json').productName;
+
+process.chdir(path.dirname(__dirname));
+var home = process.env[(process.platform === 'win32') ? 'USERPROFILE' : 'HOME'];
+var tmpdir = process.platform === 'win32' ? os.tmpdir() : '/tmp';
+
+// Windows: Use START as a way to ignore error if Atom.exe isnt running
+var killatom = process.platform === 'win32' ? 'START taskkill /F /IM ' + productName + '.exe' : 'pkill -9 ' + productName + ' || true';
+
+var commands = [
+  killatom,
+  [__dirname, '..', 'node_modules'],
+  [__dirname, '..', 'build', 'node_modules'],
+  [__dirname, '..', 'apm', 'node_modules'],
+  [__dirname, '..', 'vendor', 'apm', 'node_modules'],
+  [__dirname, '..', 'atom-shell'],
+  [home, '.atom', '.node-gyp'],
+  [home, '.atom', 'storage'],
+  [tmpdir, 'atom-build'],
+  [tmpdir, 'atom-cached-atom-shells'],
+  [tmpdir, 'atom-compile-cache'],
+];
+var run = function() {
+  var next = commands.shift();
+  if (!next)
+    process.exit(0);
+  if (Array.isArray(next))
+    next = removeCommand + path.resolve.apply(path.resolve, next);
+  cp.safeExec(next, run);
+};
+run();

script/clean.cmd

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

script/constructicon/build

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

script/constructicon/prebuild

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

script/copy-folder.cmd

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

script/create-shortcut.cmd

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

script/grunt

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

script/install-cli

@@ -0,0 +1,10 @@
+#!/usr/bin/env coffee
+
+path = require 'path'
+CommandInstaller = require '../src/command-installer'
+
+callback = (error) ->
+  console.warn error.message if error?
+
+CommandInstaller.installAtomCommand(path.resolve(__dirname, '..'), callback)
+CommandInstaller.installApmCommand(path.resolve(__dirname, '..'), callback)

script/set-version

@@ -3,11 +3,11 @@
 set -e
 
 BUILT_PRODUCTS_DIR=$1
+VERSION=$2
 PLIST_PATH="$BUILT_PRODUCTS_DIR/Atom.app/Contents/Info.plist"
 HELPER_PLIST_PATH="$BUILT_PRODUCTS_DIR/Atom.app/Contents/Frameworks/Atom Helper.app/Contents/Info.plist"
 
 # Update version
-VERSION=$(git rev-parse --short HEAD | tr -d "\n")
 /usr/libexec/PlistBuddy -c "Set CFBundleShortVersionString $VERSION" "$PLIST_PATH"
 /usr/libexec/PlistBuddy -c "Set CFBundleVersion $VERSION" "$PLIST_PATH"
 /usr/libexec/PlistBuddy -c "Set CFBundleShortVersionString $VERSION" "$HELPER_PLIST_PATH"

script/test

@@ -1,8 +1,10 @@
-#!/bin/sh
+#!/usr/bin/env node --harmony_collections
+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() {
+  var gruntPath = path.join('node_modules', '.bin', 'grunt') + (process.platform === 'win32' ? '.cmd' : '');
+  safeExec(gruntPath + ' ci --stack --no-color', process.exit);
+});

script/utils/child-process-wrapper.js

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

script/utils/update-octicons

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