Show dock items on first run

lib/async-queue.js

@@ -39,14 +39,17 @@ export default class AsyncQueue {
   }
 
   push(fn, {parallel} = {parallel: true}) {
+    if (this.disposed) {
+      throw new Error('AsyncQueue is disposed');
+    }
     const task = new Task(fn, parallel);
     this.queue.push(task);
     this.processQueue();
     return task.getPromise();
   }
 
   processQueue() {
-    if (!this.queue.length || this.nonParallelizableOperation) { return; }
+    if (!this.queue.length || this.nonParallelizableOperation || this.disposed) { return; }
 
     const task = this.queue[0];
     const canRunParallelOp = task.runsInParallel() && this.tasksInProgress < this.parallelism;
@@ -59,14 +62,24 @@ export default class AsyncQueue {
   }
 
   async processTask(task, runsInParallel) {
+    if (this.disposed) { return; }
+
     this.tasksInProgress++;
     if (!runsInParallel) {
       this.nonParallelizableOperation = true;
     }
 
-    await task.execute();
-    this.tasksInProgress--;
-    this.nonParallelizableOperation = false;
-    this.processQueue();
+    try {
+      await task.execute();
+    } finally {
+      this.tasksInProgress--;
+      this.nonParallelizableOperation = false;
+      this.processQueue();
+    }
+  }
+
+  dispose() {
+    this.queue = [];
+    this.disposed = true;
   }
 }

lib/controllers/root-controller.js

@@ -55,12 +55,14 @@ export default class RootController extends React.Component {
     switchboard: PropTypes.instanceOf(Switchboard),
     savedState: PropTypes.object,
     useLegacyPanels: PropTypes.bool,
+    firstRun: React.PropTypes.bool,
   }
 
   static defaultProps = {
     switchboard: new Switchboard(),
     savedState: {},
     useLegacyPanels: false,
+    firstRun: true,
   }
 
   serialize() {
@@ -77,8 +79,8 @@ export default class RootController extends React.Component {
     this.state = {
       ...nullFilePatchState,
       amending: false,
-      gitTabActive: !!props.savedState.gitTabActive,
-      githubPanelActive: !!props.savedState.githubPanelActive,
+      gitTabActive: props.firstRun || props.savedState.gitTabActive,
+      githubPanelActive: props.firstRun || props.savedState.githubPanelActive,
       panelSize: props.savedState.panelSize || 400,
       activeTab: props.savedState.activeTab || 0,
       cloneDialogActive: false,
@@ -163,7 +165,8 @@ export default class RootController extends React.Component {
           workspace={this.props.workspace}
           getItem={({subtree}) => subtree.getWrappedComponent()}
           onDidCloseItem={() => this.setState({gitTabActive: false})}
-          stubItemSelector="git-tab-controller">
+          stubItemSelector="git-tab-controller"
+          activate={this.props.firstRun}>
           <EtchWrapper
             ref={c => { this.gitTabController = c; }}
             className="github-PanelEtchWrapper"

lib/git-shell-out-strategy.js

@@ -132,9 +132,8 @@ export default class GitShellOutStrategy {
         env,
         processCallback: child => {
           child.on('error', err => {
-            console.error('Error executing: ' + formattedArgs);
-
-            console.error(err.stack);
+            console.warn('Error executing: ' + formattedArgs + ':');
+            console.warn(err.stack);
           });
           child.stdin.on('error', err => {
             console.error('Error writing to process: ' + formattedArgs);
@@ -653,6 +652,10 @@ export default class GitShellOutStrategy {
       return executable ? '100755' : '100644';
     }
   }
+
+  destroy() {
+    this.commandQueue.dispose();
+  }
 }
 
 function buildAddedFilePatch(filePath, contents, executable) {

lib/github-package.js

@@ -21,6 +21,7 @@ import GitTimingsView from './views/git-timings-view';
 import AsyncQueue from './async-queue';
 
 const defaultState = {
+  firstRun: true,
   resolutionProgressByPath: {},
 };
 
@@ -170,11 +171,16 @@ export default class GithubPackage {
     return {
       activeRepositoryPath,
       gitController: this.controller.serialize(),
+      firstRun: false,
     };
   }
 
   @autobind
   rerender(callback) {
+    if (this.workspace.isDestroyed()) {
+      return;
+    }
+
     if (!this.element) {
       this.element = document.createElement('div');
       this.subscriptions.add(new Disposable(() => {
@@ -201,6 +207,7 @@ export default class GithubPackage {
         cloneRepositoryForProjectPath={this.cloneRepositoryForProjectPath}
         switchboard={this.switchboard}
         useLegacyPanels={this.useLegacyPanels}
+        firstRun={this.savedState.firstRun}
       />, this.element, callback,
     );
   }
@@ -370,6 +377,10 @@ export default class GithubPackage {
   }
 
   async updateActiveContext(savedState = {}) {
+    if (this.workspace.isDestroyed()) {
+      return;
+    }
+
     this.switchboard.didBeginActiveContextUpdate();
 
     const nextActiveContext = await this.getNextContext(savedState);

lib/models/repository-states/cloning.js

@@ -13,14 +13,18 @@ export default class Cloning extends State {
 
   async start() {
     await mkdirs(this.workdir());
-    await this.git().clone(this.remoteUrl, {recursive: true});
+    await this.doClone(this.remoteUrl, {recursive: true});
 
     await this.transitionTo('Loading');
   }
 
   showGitTabLoading() {
     return true;
   }
+
+  directClone(remoteUrl, options) {
+    return this.git().clone(remoteUrl, options);
+  }
 }
 
 State.register(Cloning);

lib/models/repository-states/destroyed.js

@@ -6,6 +6,7 @@ import State from './state';
 export default class Destroyed extends State {
   start() {
     this.didDestroy();
+    this.repository.git.destroy && this.repository.git.destroy();
     this.repository.emitter.dispose();
   }
 

lib/models/repository-states/initializing.js

@@ -5,14 +5,18 @@ import State from './state';
  */
 export default class Initializing extends State {
   async start() {
-    await this.git().init(this.workdir());
+    await this.doInit(this.workdir());
 
     await this.transitionTo('Loading');
   }
 
   showGitTabLoading() {
     return true;
   }
+
+  directInit(workdir) {
+    return this.git().init(workdir);
+  }
 }
 
 State.register(Initializing);

lib/models/repository-states/loading.js

@@ -6,7 +6,7 @@ import State from './state';
  */
 export default class Loading extends State {
   async start() {
-    if (await this.git().isGitRepository()) {
+    if (await this.isGitRepository()) {
       const history = await this.loadHistoryPayload();
       return this.transitionTo('Present', history);
     } else {
@@ -31,6 +31,18 @@ export default class Loading extends State {
   showGitTabLoading() {
     return true;
   }
+
+  directIsGitRepository() {
+    return this.git().isGitRepository();
+  }
+
+  directGetConfig(key, options) {
+    return this.git().getConfig(key, options);
+  }
+
+  directGetBlobContents(sha) {
+    return this.git().getBlobContents(sha);
+  }
 }
 
 State.register(Loading);

lib/models/repository-states/state.js

@@ -407,6 +407,12 @@ export default class State {
     return this.repository.getWorkingDirectoryPath();
   }
 
+  // Call methods on the active Repository state, even if the state has transitioned beneath you.
+  // Use this to perform operations within `start()` methods to guard against interrupted state transitions.
+  current() {
+    return this.repository.state;
+  }
+
   // Return a Promise that will resolve once the state transitions from Loading.
   getLoadPromise() {
     return this.repository.getLoadPromise();
@@ -439,16 +445,55 @@ export default class State {
     return this.repository.emitter.emit('did-update');
   }
 
+  // Direct git access
+  // Non-delegated git operations for internal use within states.
+
+  directIsGitRepository() {
+    return Promise.resolve(false);
+  }
+
+  directGetConfig(key, options = {}) {
+    return Promise.resolve(null);
+  }
+
+  directGetBlobContents() {
+    return Promise.reject(new Error('Not a valid object name'));
+  }
+
+  directInit() {
+    return Promise.resolve();
+  }
+
+  directClone(remoteUrl, options) {
+    return Promise.resolve();
+  }
+
+  // Deferred operations
+  // Direct raw git operations to the current state, even if the state has been changed. Use these methods within
+  // start() methods.
+
+  isGitRepository() {
+    return this.current().directIsGitRepository();
+  }
+
+  doInit(workdir) {
+    return this.current().directInit();
+  }
+
+  doClone(remoteUrl, options) {
+    return this.current().directClone(remoteUrl, options);
+  }
+
   // Parse a DiscardHistory payload from the SHA recorded in config.
   async loadHistoryPayload() {
-    const historySha = await this.git().getConfig('atomGithub.historySha');
+    const historySha = await this.current().directGetConfig('atomGithub.historySha');
     if (!historySha) {
       return {};
     }
 
     let blob;
     try {
-      blob = await this.git().getBlobContents(historySha);
+      blob = await this.current().directGetBlobContents(historySha);
     } catch (e) {
       if (/Not a valid object name/.test(e.stdErr)) {
         return {};

lib/models/repository.js

@@ -67,11 +67,18 @@ export default class Repository {
   // State management //////////////////////////////////////////////////////////////////////////////////////////////////
 
   transition(currentState, StateConstructor, ...payload) {
+    if (currentState !== this.state) {
+      // Attempted transition from a non-active state, most likely from an asynchronous start() method.
+      return Promise.resolve();
+    }
+
     const nextState = new StateConstructor(this, ...payload);
     this.state = nextState;
 
     this.emitter.emit('did-change-state', {from: currentState, to: this.state});
-    this.emitter.emit('did-update');
+    if (!this.isDestroyed()) {
+      this.emitter.emit('did-update');
+    }
 
     return this.state.start();
   }

lib/views/dock-item.js

@@ -26,6 +26,7 @@ export default class DockItem extends React.Component {
     getItem: PropTypes.func,
     onDidCloseItem: PropTypes.func,
     stubItemSelector: PropTypes.string,
+    activate: PropTypes.bool,
   }
 
   static defaultProps = {
@@ -65,8 +66,15 @@ export default class DockItem extends React.Component {
     if (stub) {
       stub.setRealItem(itemToAdd);
       this.dockItem = stub;
+      if (this.props.activate) {
+        this.activate();
+      }
     } else {
-      Promise.resolve(this.props.workspace.open(itemToAdd)).then(item => { this.dockItem = item; });
+      Promise.resolve(this.props.workspace.open(itemToAdd, {activatePane: false}))
+        .then(item => {
+          this.dockItem = item;
+          if (this.props.activate) { this.activate(); }
+        });
     }
 
     this.subscriptions = this.props.workspace.onDidDestroyPaneItem(({item}) => {
@@ -94,7 +102,9 @@ export default class DockItem extends React.Component {
 
   activate() {
     setTimeout(() => {
-      if (!this.dockItem) { return; }
+      if (!this.dockItem || this.didCloseItem || this.props.workspace.isDestroyed()) {
+        return;
+      }
 
       const pane = this.props.workspace.paneForItem(this.dockItem);
       if (pane) {