Merge branch 'master' into dh-async-repo

src/atom-environment.coffee

@@ -1,5 +1,6 @@
 crypto = require 'crypto'
 path = require 'path'
+ipc = require 'ipc'
 
 _ = require 'underscore-plus'
 {deprecate} = require 'grim'
@@ -116,7 +117,7 @@ class AtomEnvironment extends Model
 
   # Call .loadOrCreate instead
   constructor: (params={}) ->
-    {@applicationDelegate, @window, @document, configDirPath, @enablePersistence} = params
+    {@blobStore, @applicationDelegate, @window, @document, configDirPath, @enablePersistence} = params
 
     @state = {version: @constructor.version}
 
@@ -203,6 +204,15 @@ class AtomEnvironment extends Model
 
     @observeAutoHideMenuBar()
 
+    checkPortableHomeWritable = ->
+      responseChannel = "check-portable-home-writable-response"
+      ipc.on responseChannel, (response) ->
+        ipc.removeAllListeners(responseChannel)
+        atom.notifications.addWarning("#{response.message.replace(/([\\\.+\\-_#!])/g, '\\$1')}") if not response.writable
+      ipc.send('check-portable-home-writable', responseChannel)
+
+    checkPortableHomeWritable()
+
   setConfigSchema: ->
     @config.setSchema null, {type: 'object', properties: _.clone(require('./config-schema'))}
 
@@ -306,6 +316,7 @@ class AtomEnvironment extends Model
     @project = null
     @commands.clear()
     @stylesElement.remove()
+    @config.unobserveUserConfig()
 
     @uninstallWindowEventHandler()
 
@@ -636,6 +647,7 @@ class AtomEnvironment extends Model
     @state.packageStates = @packages.packageStates
     @state.fullScreen = @isFullScreen()
     @saveStateSync()
+    @saveBlobStoreSync()
 
   openInitialEmptyEditorIfNecessary: ->
     return unless @config.get('core.openEmptyEditorOnStart')
@@ -759,6 +771,11 @@ class AtomEnvironment extends Model
   showSaveDialogSync: (options={}) ->
     @applicationDelegate.showSaveDialog(options)
 
+  saveBlobStoreSync: ->
+    return unless @enablePersistence
+
+    @blobStore.save()
+
   saveStateSync: ->
     return unless @enablePersistence
 

src/browser/atom-portable.coffee

@@ -0,0 +1,35 @@
+fs = require 'fs-plus'
+path = require 'path'
+ipc = require 'ipc'
+
+module.exports =
+class AtomPortable
+  @getPortableAtomHomePath: ->
+    execDirectoryPath = path.dirname(process.execPath)
+    path.join(execDirectoryPath, '..', '.atom')
+
+  @setPortable: (existingAtomHome) ->
+    fs.copySync(existingAtomHome, @getPortableAtomHomePath())
+
+  @isPortableInstall: (platform, environmentAtomHome, defaultHome) ->
+    return false unless platform in ['linux', 'win32']
+    return false if environmentAtomHome
+    return false if not fs.existsSync(@getPortableAtomHomePath())
+    # currently checking only that the directory exists  and is writable,
+    # probably want to do some integrity checks on contents in future
+    @isPortableAtomHomePathWritable(defaultHome)
+
+  @isPortableAtomHomePathWritable: (defaultHome) ->
+    writable = false
+    message = ""
+    try
+      writePermissionTestFile = path.join(@getPortableAtomHomePath(), "write.test")
+      fs.writeFileSync(writePermissionTestFile, "test") if not fs.existsSync(writePermissionTestFile)
+      fs.removeSync(writePermissionTestFile)
+      writable = true
+    catch error
+      message = "Failed to use portable Atom home directory (#{@getPortableAtomHomePath()}).  Using the default instead (#{defaultHome}).  #{error.message}"
+
+    ipc.on 'check-portable-home-writable', (event) ->
+      event.sender.send 'check-portable-home-writable-response', {writable, message}
+    writable

src/browser/atom-window.coffee

@@ -49,6 +49,7 @@ class AtomWindow
     loadSettings.resourcePath = @resourcePath
     loadSettings.devMode ?= false
     loadSettings.safeMode ?= false
+    loadSettings.atomHome = process.env.ATOM_HOME
 
     # Only send to the first non-spec window created
     if @constructor.includeShellLoadTime and not @isSpec

src/browser/main.coffee

@@ -12,15 +12,14 @@ yargs = require 'yargs'
 console.log = require 'nslog'
 
 start = ->
-  setupAtomHome()
+  args = parseCommandLine()
+  setupAtomHome(args)
   setupCompileCache()
   return if handleStartupEventWithSquirrel()
 
   # NB: This prevents Win10 from showing dupe items in the taskbar
   app.setAppUserModelId('com.squirrel.atom.atom')
 
-  args = parseCommandLine()
-
   addPathToOpen = (event, pathToOpen) ->
     event.preventDefault()
     args.pathsToOpen.push(pathToOpen)
@@ -57,11 +56,25 @@ handleStartupEventWithSquirrel = ->
 setupCrashReporter = ->
   crashReporter.start(productName: 'Atom', companyName: 'GitHub')
 
-setupAtomHome = ->
+setupAtomHome = ({setPortable}) ->
   return if process.env.ATOM_HOME
+
   atomHome = path.join(app.getHomeDir(), '.atom')
+  AtomPortable = require './atom-portable'
+
+  if setPortable and not AtomPortable.isPortableInstall(process.platform, process.env.ATOM_HOME, atomHome)
+    try
+      AtomPortable.setPortable(atomHome)
+    catch error
+      console.log("Failed copying portable directory '#{atomHome}' to '#{AtomPortable.getPortableAtomHomePath()}'")
+      console.log("#{error.message} #{error.stack}")
+
+  if AtomPortable.isPortableInstall(process.platform, process.env.ATOM_HOME, atomHome)
+    atomHome = AtomPortable.getPortableAtomHomePath()
+
   try
     atomHome = fs.realpathSync(atomHome)
+
   process.env.ATOM_HOME = atomHome
 
 setupCompileCache = ->
@@ -100,6 +113,7 @@ parseCommandLine = ->
   options.boolean('profile-startup').describe('profile-startup', 'Create a profile of the startup execution time.')
   options.alias('r', 'resource-path').string('r').describe('r', 'Set the path to the Atom source directory and enable dev-mode.')
   options.boolean('safe').describe('safe', 'Do not load packages from ~/.atom/packages or ~/.atom/dev/packages.')
+  options.boolean('portable').describe('portable', 'Set portable mode. Copies the ~/.atom folder to be a sibling of the installed Atom location if a .atom folder is not already there.')
   options.alias('t', 'test').boolean('t').describe('t', 'Run the specified specs and exit with error code on failures.')
   options.string('timeout').describe('timeout', 'When in test mode, waits until the specified time (in minutes) and kills the process (exit code: 130).')
   options.alias('v', 'version').boolean('v').describe('v', 'Print the version.')
@@ -129,6 +143,7 @@ parseCommandLine = ->
   profileStartup = args['profile-startup']
   urlsToOpen = []
   devResourcePath = process.env.ATOM_DEV_RESOURCE_PATH ? path.join(app.getHomeDir(), 'github', 'atom')
+  setPortable = args.portable
 
   if args['resource-path']
     devMode = true
@@ -149,6 +164,6 @@ parseCommandLine = ->
 
   {resourcePath, devResourcePath, pathsToOpen, urlsToOpen, executedFrom, test,
    version, pidToKillWhenClosed, devMode, safeMode, newWindow,
-   logFile, socketPath, profileStartup, timeout}
+   logFile, socketPath, profileStartup, timeout, setPortable}
 
 start()

src/file-system-blob-store.js

@@ -0,0 +1,111 @@
+'use strict'
+
+const fs = require('fs-plus')
+const path = require('path')
+
+module.exports =
+class FileSystemBlobStore {
+  static load (directory) {
+    let instance = new FileSystemBlobStore(directory)
+    instance.load()
+    return instance
+  }
+
+  constructor (directory) {
+    this.inMemoryBlobs = new Map()
+    this.blobFilename = path.join(directory, 'BLOB')
+    this.blobMapFilename = path.join(directory, 'MAP')
+    this.lockFilename = path.join(directory, 'LOCK')
+    this.storedBlob = new Buffer(0)
+    this.storedBlobMap = {}
+  }
+
+  load () {
+    if (!fs.existsSync(this.blobMapFilename)) {
+      return
+    }
+    if (!fs.existsSync(this.blobFilename)) {
+      return
+    }
+    this.storedBlob = fs.readFileSync(this.blobFilename)
+    this.storedBlobMap = JSON.parse(fs.readFileSync(this.blobMapFilename))
+  }
+
+  save () {
+    let dump = this.getDump()
+    let blobToStore = Buffer.concat(dump[0])
+    let mapToStore = JSON.stringify(dump[1])
+
+    let acquiredLock = false
+    try {
+      fs.writeFileSync(this.lockFilename, 'LOCK', {flag: 'wx'})
+      acquiredLock = true
+
+      fs.writeFileSync(this.blobFilename, blobToStore)
+      fs.writeFileSync(this.blobMapFilename, mapToStore)
+    } catch (error) {
+      // Swallow the exception silently only if we fail to acquire the lock.
+      if (error.code !== 'EEXIST') {
+        throw error
+      }
+    } finally {
+      if (acquiredLock) {
+        fs.unlinkSync(this.lockFilename)
+      }
+    }
+  }
+
+  has (key) {
+    return this.inMemoryBlobs.hasOwnProperty(key) || this.storedBlobMap.hasOwnProperty(key)
+  }
+
+  get (key) {
+    return this.getFromMemory(key) || this.getFromStorage(key)
+  }
+
+  set (key, buffer) {
+    return this.inMemoryBlobs.set(key, buffer)
+  }
+
+  delete (key) {
+    this.inMemoryBlobs.delete(key)
+    delete this.storedBlobMap[key]
+  }
+
+  getFromMemory (key) {
+    return this.inMemoryBlobs.get(key)
+  }
+
+  getFromStorage (key) {
+    if (!this.storedBlobMap[key]) {
+      return
+    }
+
+    return this.storedBlob.slice.apply(this.storedBlob, this.storedBlobMap[key])
+  }
+
+  getDump () {
+    let buffers = []
+    let blobMap = {}
+    let currentBufferStart = 0
+
+    function dump (key, getBufferByKey) {
+      let buffer = getBufferByKey(key)
+      buffers.push(buffer)
+      blobMap[key] = [currentBufferStart, currentBufferStart + buffer.length]
+      currentBufferStart += buffer.length
+    }
+
+    for (let key of this.inMemoryBlobs.keys()) {
+      dump(key, this.getFromMemory.bind(this))
+    }
+
+    for (let key of Object.keys(this.storedBlobMap)) {
+      if (!blobMap[key]) {
+        dump(key, this.getFromStorage.bind(this))
+      }
+    }
+
+    return [buffers, blobMap]
+  }
+}

src/initialize-application-window.coffee

@@ -1,34 +1,34 @@
 # Like sands through the hourglass, so are the days of our lives.
+module.exports = ({blobStore}) ->
+  path = require 'path'
+  require './window'
+  {getWindowLoadSettings} = require './window-load-settings-helpers'
 
-path = require 'path'
-require './window'
-{getWindowLoadSettings} = require './window-load-settings-helpers'
+  {resourcePath, isSpec, devMode} = getWindowLoadSettings()
 
-{resourcePath, isSpec, devMode} = getWindowLoadSettings()
+  # Add application-specific exports to module search path.
+  exportsPath = path.join(resourcePath, 'exports')
+  require('module').globalPaths.push(exportsPath)
+  process.env.NODE_PATH = exportsPath
 
-# Add application-specific exports to module search path.
-exportsPath = path.join(resourcePath, 'exports')
-require('module').globalPaths.push(exportsPath)
-process.env.NODE_PATH = exportsPath
+  # Make React faster
+  process.env.NODE_ENV ?= 'production' unless devMode
 
-# Make React faster
-process.env.NODE_ENV ?= 'production' unless devMode
+  AtomEnvironment = require './atom-environment'
+  ApplicationDelegate = require './application-delegate'
+  window.atom = new AtomEnvironment({
+    window, document, blobStore,
+    applicationDelegate: new ApplicationDelegate,
+    configDirPath: process.env.ATOM_HOME
+    enablePersistence: true
+  })
 
-AtomEnvironment = require './atom-environment'
-ApplicationDelegate = require './application-delegate'
-window.atom = new AtomEnvironment({
-  window, document,
-  applicationDelegate: new ApplicationDelegate,
-  configDirPath: process.env.ATOM_HOME
-  enablePersistence: true
-})
+  atom.displayWindow()
+  atom.loadStateSync()
+  atom.startEditorWindow()
 
-atom.displayWindow()
-atom.loadStateSync()
-atom.startEditorWindow()
-
-# Workaround for focus getting cleared upon window creation
-windowFocused = ->
-  window.removeEventListener('focus', windowFocused)
-  setTimeout (-> document.querySelector('atom-workspace').focus()), 0
-window.addEventListener('focus', windowFocused)
+  # Workaround for focus getting cleared upon window creation
+  windowFocused = ->
+    window.removeEventListener('focus', windowFocused)
+    setTimeout (-> document.querySelector('atom-workspace').focus()), 0
+  window.addEventListener('focus', windowFocused)

src/initialize-test-window.coffee

@@ -1,69 +1,78 @@
-# Start the crash reporter before anything else.
-require('crash-reporter').start(productName: 'Atom', companyName: 'GitHub')
-remote = require 'remote'
+cloneObject = (object) ->
+  clone = {}
+  clone[key] = value for key, value of object
+  clone
 
-exitWithStatusCode = (status) ->
-  remote.require('app').emit('will-quit')
-  remote.process.exit(status)
+module.exports = ({blobStore}) ->
+  # Start the crash reporter before anything else.
+  require('crash-reporter').start(productName: 'Atom', companyName: 'GitHub')
+  remote = require 'remote'
 
-try
-  path = require 'path'
-  ipc = require 'ipc'
-  {getWindowLoadSettings} = require './window-load-settings-helpers'
-  AtomEnvironment = require '../src/atom-environment'
-  ApplicationDelegate = require '../src/application-delegate'
+  exitWithStatusCode = (status) ->
+    remote.require('app').emit('will-quit')
+    remote.process.exit(status)
 
-  {testRunnerPath, legacyTestRunnerPath, headless, logFile, testPaths} = getWindowLoadSettings()
+  try
+    path = require 'path'
+    ipc = require 'ipc'
+    {getWindowLoadSettings} = require './window-load-settings-helpers'
+    AtomEnvironment = require '../src/atom-environment'
+    ApplicationDelegate = require '../src/application-delegate'
 
-  if headless
-    # Override logging in headless mode so it goes to the console, regardless
-    # of the --enable-logging flag to Electron.
-    console.log = (args...) ->
-      ipc.send 'write-to-stdout', args.join(' ') + '\n'
-    console.warn = (args...) ->
-      ipc.send 'write-to-stderr', args.join(' ') + '\n'
-    console.error = (args...) ->
-      ipc.send 'write-to-stderr', args.join(' ') + '\n'
-  else
-    # Show window synchronously so a focusout doesn't fire on input elements
-    # that are focused in the very first spec run.
-    remote.getCurrentWindow().show()
+    {testRunnerPath, legacyTestRunnerPath, headless, logFile, testPaths} = getWindowLoadSettings()
 
-  handleKeydown = (event) ->
-    # Reload: cmd-r / ctrl-r
-    if (event.metaKey or event.ctrlKey) and event.keyCode is 82
-      ipc.send('call-window-method', 'restart')
+    if headless
+      # Override logging in headless mode so it goes to the console, regardless
+      # of the --enable-logging flag to Electron.
+      console.log = (args...) ->
+        ipc.send 'write-to-stdout', args.join(' ') + '\n'
+      console.warn = (args...) ->
+        ipc.send 'write-to-stderr', args.join(' ') + '\n'
+      console.error = (args...) ->
+        ipc.send 'write-to-stderr', args.join(' ') + '\n'
+    else
+      # Show window synchronously so a focusout doesn't fire on input elements
+      # that are focused in the very first spec run.
+      remote.getCurrentWindow().show()
 
-    # Toggle Dev Tools: cmd-alt-i / ctrl-alt-i
-    if (event.metaKey or event.ctrlKey) and event.altKey and event.keyCode is 73
-      ipc.send('call-window-method', 'toggleDevTools')
+    handleKeydown = (event) ->
+      # Reload: cmd-r / ctrl-r
+      if (event.metaKey or event.ctrlKey) and event.keyCode is 82
+        ipc.send('call-window-method', 'restart')
 
-    # Reload: cmd-w / ctrl-w
-    if (event.metaKey or event.ctrlKey) and event.keyCode is 87
-      ipc.send('call-window-method', 'close')
+      # Toggle Dev Tools: cmd-alt-i / ctrl-alt-i
+      if (event.metaKey or event.ctrlKey) and event.altKey and event.keyCode is 73
+        ipc.send('call-window-method', 'toggleDevTools')
 
-  window.addEventListener('keydown', handleKeydown, true)
+      # Reload: cmd-w / ctrl-w
+      if (event.metaKey or event.ctrlKey) and event.keyCode is 87
+        ipc.send('call-window-method', 'close')
 
-  # Add 'exports' to module search path.
-  exportsPath = path.join(getWindowLoadSettings().resourcePath, 'exports')
-  require('module').globalPaths.push(exportsPath)
-  process.env.NODE_PATH = exportsPath # Set NODE_PATH env variable since tasks may need it.
+    window.addEventListener('keydown', handleKeydown, true)
 
-  document.title = "Spec Suite"
+    # Add 'exports' to module search path.
+    exportsPath = path.join(getWindowLoadSettings().resourcePath, 'exports')
+    require('module').globalPaths.push(exportsPath)
+    process.env.NODE_PATH = exportsPath # Set NODE_PATH env variable since tasks may need it.
 
-  testRunner = require(testRunnerPath)
-  legacyTestRunner = require(legacyTestRunnerPath)
-  buildAtomEnvironment = (params) -> new AtomEnvironment(params)
-  buildDefaultApplicationDelegate = (params) -> new ApplicationDelegate()
+    document.title = "Spec Suite"
 
-  promise = testRunner({
-    logFile, headless, testPaths, buildAtomEnvironment, buildDefaultApplicationDelegate, legacyTestRunner
-  })
+    testRunner = require(testRunnerPath)
+    legacyTestRunner = require(legacyTestRunnerPath)
+    buildDefaultApplicationDelegate = -> new ApplicationDelegate()
+    buildAtomEnvironment = (params) ->
+      params = cloneObject(params)
+      params.blobStore = blobStore unless params.hasOwnProperty("blobStore")
+      new AtomEnvironment(params)
 
-  promise.then(exitWithStatusCode) if getWindowLoadSettings().headless
-catch error
-  if getWindowLoadSettings().headless
-    console.error(error.stack ? error)
-    exitWithStatusCode(1)
-  else
-    throw error
+    promise = testRunner({
+      logFile, headless, testPaths, buildAtomEnvironment, buildDefaultApplicationDelegate, legacyTestRunner
+    })
+
+    promise.then(exitWithStatusCode) if getWindowLoadSettings().headless
+  catch error
+    if getWindowLoadSettings().headless
+      console.error(error.stack ? error)
+      exitWithStatusCode(1)
+    else
+      throw error

src/lines-yardstick.coffee

@@ -159,9 +159,12 @@ class LinesYardstick
       0
 
   leftPixelPositionForCharInTextNode: (lineNode, textNode, charIndex) ->
-    @rangeForMeasurement.setStart(textNode, 0)
-    @rangeForMeasurement.setEnd(textNode, charIndex)
-    width = @rangeForMeasurement.getBoundingClientRect().width
+    if charIndex is 0
+      width = 0
+    else
+      @rangeForMeasurement.setStart(textNode, 0)
+      @rangeForMeasurement.setEnd(textNode, charIndex)
+      width = @rangeForMeasurement.getBoundingClientRect().width
 
     @rangeForMeasurement.setStart(textNode, 0)
     @rangeForMeasurement.setEnd(textNode, textNode.textContent.length)

src/native-compile-cache.js

@@ -0,0 +1,101 @@
+'use strict'
+
+const Module = require('module')
+const path = require('path')
+const cachedVm = require('cached-run-in-this-context')
+
+class NativeCompileCache {
+  constructor () {
+    this.cacheStore = null
+    this.previousModuleCompile = null
+  }
+
+  setCacheStore (store) {
+    this.cacheStore = store
+  }
+
+  install () {
+    this.savePreviousModuleCompile()
+    this.overrideModuleCompile()
+  }
+
+  uninstall () {
+    this.restorePreviousModuleCompile()
+  }
+
+  savePreviousModuleCompile () {
+    this.previousModuleCompile = Module.prototype._compile
+  }
+
+  overrideModuleCompile () {
+    let cacheStore = this.cacheStore
+    let resolvedArgv = null
+    // Here we override Node's module.js
+    // (https://github.com/atom/node/blob/atom/lib/module.js#L378), changing
+    // only the bits that affect compilation in order to use the cached one.
+    Module.prototype._compile = function (content, filename) {
+      let self = this
+      // remove shebang
+      content = content.replace(/^\#\!.*/, '')
+      function require (path) {
+        return self.require(path)
+      }
+      require.resolve = function (request) {
+        return Module._resolveFilename(request, self)
+      }
+      require.main = process.mainModule
+
+      // Enable support to add extra extension types
+      require.extensions = Module._extensions
+      require.cache = Module._cache
+
+      let dirname = path.dirname(filename)
+
+      // create wrapper function
+      let wrapper = Module.wrap(content)
+
+      let compiledWrapper = null
+      if (cacheStore.has(filename)) {
+        let buffer = cacheStore.get(filename)
+        let compilationResult = cachedVm.runInThisContextCached(wrapper, filename, buffer)
+        compiledWrapper = compilationResult.result
+        if (compilationResult.wasRejected) {
+          cacheStore.delete(filename)
+        }
+      } else {
+        let compilationResult = cachedVm.runInThisContext(wrapper, filename)
+        if (compilationResult.cacheBuffer) {
+          cacheStore.set(filename, compilationResult.cacheBuffer)
+        }
+        compiledWrapper = compilationResult.result
+      }
+      if (global.v8debug) {
+        if (!resolvedArgv) {
+          // we enter the repl if we're not given a filename argument.
+          if (process.argv[1]) {
+            resolvedArgv = Module._resolveFilename(process.argv[1], null)
+          } else {
+            resolvedArgv = 'repl'
+          }
+        }
+
+        // Set breakpoint on module start
+        if (filename === resolvedArgv) {
+          // Installing this dummy debug event listener tells V8 to start
+          // the debugger.  Without it, the setBreakPoint() fails with an
+          // 'illegal access' error.
+          global.v8debug.Debug.setListener(function () {})
+          global.v8debug.Debug.setBreakPoint(compiledWrapper, 0, 0)
+        }
+      }
+      let args = [self.exports, require, self, filename, dirname, process, global]
+      return compiledWrapper.apply(self.exports, args)
+    }
+  }
+
+  restorePreviousModuleCompile () {
+    Module.prototype._compile = this.previousModuleCompile
+  }
+}
+
+module.exports = new NativeCompileCache()

src/package-manager.coffee

@@ -467,7 +467,7 @@ class PackageManager
     detail = "#{error.message} in #{metadataPath}"
     stack = "#{error.stack}\n  at #{metadataPath}:1:1"
     message = "Failed to load the #{path.basename(packagePath)} package"
-    @notificationManager.addError(message, {stack, detail, dismissable: true})
+    @notificationManager.addError(message, {stack, detail, packageName: path.basename(packagePath), dismissable: true})
 
   uninstallDirectory: (directory) ->
     symlinkPromise = new Promise (resolve) ->

src/package.coffee

@@ -293,7 +293,7 @@ class Package
         if error?
           detail = "#{error.message} in #{grammarPath}"
           stack = "#{error.stack}\n  at #{grammarPath}:1:1"
-          @notificationManager.addFatalError("Failed to load a #{@name} package grammar", {stack, detail, dismissable: true})
+          @notificationManager.addFatalError("Failed to load a #{@name} package grammar", {stack, detail, packageName: @name, dismissable: true})
         else
           grammar.packageName = @name
           grammar.bundledPackage = @bundledPackage
@@ -317,7 +317,7 @@ class Package
         if error?
           detail = "#{error.message} in #{settingsPath}"
           stack = "#{error.stack}\n  at #{settingsPath}:1:1"
-          @notificationManager.addFatalError("Failed to load the #{@name} package settings", {stack, detail, dismissable: true})
+          @notificationManager.addFatalError("Failed to load the #{@name} package settings", {stack, detail, packageName: @name, dismissable: true})
         else
           @settings.push(settings)
           settings.activate() if @settingsActivated
@@ -634,4 +634,4 @@ class Package
       detail = error.message
       stack = error.stack ? error
 
-    @notificationManager.addFatalError(message, {stack, detail, dismissable: true})
+    @notificationManager.addFatalError(message, {stack, detail, packageName: @name, dismissable: true})

src/text-editor.coffee

@@ -573,6 +573,45 @@ class TextEditor extends Model
     else
       'untitled'
 
+  # Essential: Get unique title for display in other parts of the UI
+  # such as the window title.
+  #
+  # If the editor's buffer is unsaved, its title is "untitled"
+  # If the editor's buffer is saved, its unique title is formatted as one
+  # of the following,
+  # * "<filename>" when it is the only editing buffer with this file name.
+  # * "<unique-dir-prefix>/.../<filename>", where the "..." may be omitted
+  # if the the direct parent directory is already different.
+  #
+  # Returns a {String}
+  getUniqueTitle: ->
+    if sessionPath = @getPath()
+      title = @getTitle()
+
+      # find text editors with identical file name.
+      paths = []
+      for textEditor in atom.workspace.getTextEditors() when textEditor isnt this
+        if textEditor.getTitle() is title
+          paths.push(textEditor.getPath())
+      if paths.length is 0
+        return title
+      fileName = path.basename(sessionPath)
+
+      # find the first directory in all these paths that is unique
+      nLevel = 0
+      while (_.some(paths, (apath) -> path.basename(apath) is path.basename(sessionPath)))
+        sessionPath = path.dirname(sessionPath)
+        paths = _.map(paths, (apath) -> path.dirname(apath))
+        nLevel += 1
+
+      directory = path.basename sessionPath
+      if nLevel > 1
+        path.join(directory, "...", fileName)
+      else
+        path.join(directory, fileName)
+    else
+      'untitled'
+
   # Essential: Get the editor's long title for display in other parts of the UI
   # such as the window title.
   #
@@ -879,6 +918,7 @@ class TextEditor extends Model
         @foldBufferRow(foldedRow)
 
       @setSelectedBufferRange(selection.translate([-insertDelta]), preserveFolds: true, autoscroll: true)
+      @autoIndentSelectedRows() if @shouldAutoIndent()
 
   # Move lines intersecting the most recent selection down by one row in screen
   # coordinates.
@@ -935,6 +975,7 @@ class TextEditor extends Model
         @foldBufferRow(foldedRow)
 
       @setSelectedBufferRange(selection.translate([insertDelta]), preserveFolds: true, autoscroll: true)
+      @autoIndentSelectedRows() if @shouldAutoIndent()
 
   # Duplicate the most recent cursor's current line.
   duplicateLines: ->