Show files as conflicted in git panel when discard undo creates merge conflicts, handle various edge cases

lib/controllers/git-controller.js

@@ -21,7 +21,7 @@ import RepositoryConflictController from './repository-conflict-controller';
 import ModelObserver from '../models/model-observer';
 import ModelStateRegistry from '../models/model-state-registry';
 import Conflict from '../models/conflicts/conflict';
-import {copyFile} from '../helpers';
+import {copyFile, deleteFileOrFolder} from '../helpers';
 import {GitError} from '../git-shell-out-strategy';
 
 const nullFilePatchState = {
@@ -413,7 +413,7 @@ export default class GitController extends React.Component {
     };
     return await this.props.repository.storeBeforeAndAfterBlobs(
       filePaths,
-      () => this.ensureNoUnsavedFiles(filePaths, 'Cannot discard lines.'),
+      () => this.ensureNoUnsavedFiles(filePaths, 'Cannot discard changes in selected files.'),
       destructiveAction,
     );
   }
@@ -501,9 +501,17 @@ export default class GitController extends React.Component {
 
   async proceedWithLastDiscardUndo(results, partialDiscardFilePath = null) {
     const promises = results.map(async result => {
-      const {filePath, resultPath} = result;
+      const {filePath, resultPath, deleted, conflict, theirsSha, commonBaseSha} = result;
       const absFilePath = path.join(this.props.repository.getWorkingDirectoryPath(), filePath);
-      await copyFile(resultPath, absFilePath);
+      if (deleted && resultPath === null) {
+        await deleteFileOrFolder(absFilePath);
+      } else {
+        await copyFile(resultPath, absFilePath);
+      }
+      if (conflict) {
+        const currentSha = await this.props.repository.createBlob({filePath});
+        await this.props.repository.updateIndex(filePath, commonBaseSha, currentSha, theirsSha);
+      }
     });
     await Promise.all(promises);
     await this.props.repository.popDiscardHistory(partialDiscardFilePath);

lib/controllers/repository-conflict-controller.js

@@ -86,9 +86,9 @@ export default class RepositoryConflictController extends React.Component {
       return [];
     }
 
-    const basePath = this.props.workingDirectoryPath;
+    const commonBasePath = this.props.workingDirectoryPath;
     const fullMergeConflictPaths = new Set(
-      this.props.mergeConflictPaths.map(relativePath => path.join(basePath, relativePath)),
+      this.props.mergeConflictPaths.map(relativePath => path.join(commonBasePath, relativePath)),
     );
 
     return this.state.openEditors.filter(editor => fullMergeConflictPaths.has(editor.getPath()));

lib/git-shell-out-strategy.js

@@ -5,6 +5,7 @@ import {CompositeDisposable} from 'atom';
 
 import {GitProcess} from 'git-kitchen-sink';
 import {parse as parseDiff} from 'what-the-diff';
+import dedent from 'dedent-js';
 
 import GitPromptServer from './git-prompt-server';
 import AsyncQueue from './async-queue';
@@ -243,7 +244,6 @@ export default class GitShellOutStrategy {
     const args = ['diff', '--name-status', '--no-renames'];
     if (options.staged) { args.push('--staged'); }
     if (options.target) { args.push(options.target); }
-    if (options.diffFilter === 'unmerged') { args.push('--diff-filter=U'); }
     const output = await this.exec(args);
 
     const statusMap = {
@@ -508,7 +508,11 @@ export default class GitShellOutStrategy {
       try {
         output = (await this.exec(['hash-object', '-w', filePath], {writeOperation: true})).trim();
       } catch (e) {
-        output = null;
+        if (e.stdErr.match(/fatal: Cannot open .*: No such file or directory/)) {
+          output = null;
+        } else {
+          throw e;
+        }
       }
     } else if (stdin) {
       output = (await this.exec(['hash-object', '-w', '--stdin'], {stdin, writeOperation: true})).trim();
@@ -528,9 +532,9 @@ export default class GitShellOutStrategy {
     return await this.exec(['cat-file', '-p', sha]);
   }
 
-  async mergeFile(currentPath, basePath, otherPath, resultPath) {
+  async mergeFile(oursPath, commonBasePath, theirsPath, resultPath) {
     const args = [
-      'merge-file', '-p', currentPath, basePath, otherPath,
+      'merge-file', '-p', oursPath, commonBasePath, theirsPath,
       '-L', 'current', '-L', 'after discard', '-L', 'before discard',
     ];
     let output;
@@ -546,7 +550,23 @@ export default class GitShellOutStrategy {
       }
     }
     await writeFile(resultPath, output);
-    return {filePath: currentPath, resultPath, conflict};
+    return {filePath: oursPath, resultPath, conflict};
+  }
+
+  async updateIndex(filePath, commonBaseSha, oursSha, theirsSha) {
+    const fileMode = await this.getFileMode(filePath);
+    let indexInfo = dedent`
+      0 0000000000000000000000000000000000000000\t${filePath}
+      ${fileMode} ${commonBaseSha} 1\t${filePath}\n
+    `;
+    if (oursSha) { indexInfo += `${fileMode} ${oursSha} 2\t${filePath}\n`; }
+    if (theirsSha) { indexInfo += `${fileMode} ${theirsSha} 3\t${filePath}\n`; }
+    return this.exec(['update-index', '--index-info'], {stdin: indexInfo});
+  }
+
+  async getFileMode(filePath) {
+    const output = await this.exec(['ls-files', '--stage', '--', filePath]);
+    return output.slice(0, 6);
   }
 }
 

lib/models/discard-history.js

@@ -3,13 +3,14 @@ import os from 'os';
 
 import {PartialFileDiscardHistory, WholeFileDiscardHistory} from './discard-history-stores';
 
-import {getTempDir} from '../helpers';
+import {getTempDir, copyFile} from '../helpers';
 
 export default class DiscardHistory {
-  constructor(createBlob, expandBlobToFile, mergeFile, {maxHistoryLength} = {}) {
+  constructor(createBlob, expandBlobToFile, mergeFile, workdirPath, {maxHistoryLength} = {}) {
     this.createBlob = createBlob;
     this.expandBlobToFile = expandBlobToFile;
     this.mergeFile = mergeFile;
+    this.workdirPath = workdirPath;
     this.partialFileHistory = new PartialFileDiscardHistory(maxHistoryLength);
     this.wholeFileHistory = new WholeFileDiscardHistory(maxHistoryLength);
   }
@@ -114,25 +115,37 @@ export default class DiscardHistory {
   async expandBlobsToFilesInTempFolder(snapshots) {
     const tempFolderPath = await getTempDir(path.join(os.tmpdir(), 'github-discard-history-'));
     const pathPromises = snapshots.map(async ({filePath, beforeSha, afterSha}) => {
-      const otherPath = !beforeSha ? null :
+      const theirsPath = !beforeSha ? null :
         await this.expandBlobToFile(path.join(tempFolderPath, `${filePath}-before-discard`), beforeSha);
-      const basePath = !afterSha ? null :
+      const commonBasePath = !afterSha ? null :
         await this.expandBlobToFile(path.join(tempFolderPath, `${filePath}-after-discard`), afterSha);
-      const resultPath = path.join(tempFolderPath, `${filePath}-merge-result`);
-      return {filePath, basePath, otherPath, resultPath};
+      const resultPath = path.join(tempFolderPath, `~${filePath}-merge-result`);
+      return {filePath, commonBasePath, theirsPath, resultPath, theirsSha: beforeSha, commonBaseSha: afterSha};
     });
     return await Promise.all(pathPromises);
   }
 
   async mergeFiles(filePaths) {
-    const mergeFilePromises = filePaths.map(({filePath, basePath, otherPath, resultPath}) => {
-      if (otherPath && basePath) {
-        return this.mergeFile(filePath, basePath, otherPath, resultPath);
-      } else if (!otherPath && basePath) { // deleted file
-        // TODO: handle this
-        return null;
+    const mergeFilePromises = filePaths.map(async (filePathInfo, i) => {
+      const {filePath, commonBasePath, theirsPath, resultPath, theirsSha, commonBaseSha} = filePathInfo;
+      let mergeResult;
+      if (theirsPath && commonBasePath) {
+        mergeResult = await this.mergeFile(filePath, commonBasePath, theirsPath, resultPath);
+      } else if (!theirsPath && commonBasePath) { // deleted file
+        const oursSha = await this.createBlob({filePath});
+        if (oursSha === commonBaseSha) { // no changes since discard, mark file to be deleted
+          mergeResult = {filePath, resultPath: null, deleted: true, conflict: false};
+        } else { // changes since discard result in conflict
+          await copyFile(path.join(this.workdirPath, filePath), resultPath);
+          mergeResult = {filePath, resultPath, conflict: true};
+        }
+      } else if (theirsPath && !commonBasePath) { // added file
+        // TODO
+      } else {
+        throw new Error('One of the following must be defined - theirsPath:' +
+          `${theirsPath} or commonBasePath: ${commonBasePath}`);
       }
-      return null;
+      return {...mergeResult, theirsSha, commonBaseSha};
     });
     return await Promise.all(mergeFilePromises);
   }

lib/models/repository.js

@@ -74,6 +74,7 @@ export default class Repository {
       this.createBlob,
       this.expandBlobToFile,
       this.mergeFile,
+      this.workingDirectoryPath,
       {maxHistoryLength: 60},
     );
     if (history) { this.discardHistory.updateHistory(history); }
@@ -428,8 +429,12 @@ export default class Repository {
   }
 
   @autobind
-  mergeFile(currentPath, basePath, otherPath, resultPath) {
-    return this.git.mergeFile(currentPath, basePath, otherPath, resultPath);
+  mergeFile(oursPath, commonBasePath, theirsPath, resultPath) {
+    return this.git.mergeFile(oursPath, commonBasePath, theirsPath, resultPath);
+  }
+
+  updateIndex(filePath, commonBaseSha, oursSha, theirsSha) {
+    return this.git.updateIndex(filePath, commonBaseSha, oursSha, theirsSha);
   }
 
   async createDiscardHistoryBlob() {

lib/views/push-pull-menu-view.js

@@ -11,6 +11,10 @@ export default class PushPullMenuView extends React.Component {
     remoteName: React.PropTypes.string,
     aheadCount: React.PropTypes.number,
     behindCount: React.PropTypes.number,
+    notificationManager: React.PropTypes.object,
+    fetch: React.PropTypes.func,
+    push: React.PropTypes.func,
+    pull: React.PropTypes.func,
   }
 
   static defaultProps = {