Discard lines in file diff

lib/controllers/file-patch-controller.js

@@ -40,18 +40,26 @@ export default class FilePatchController {
       );
     } else {
       // NOTE: Outer div is required for etch to render elements correctly
+      const filePath = this.props.filePatch.getPath();
+      const hasUndoHistory = this.props.repository ? this.hasUndoHistory() : false;
       return (
         <div className="github-PaneView pane-item">
           <FilePatchView
             ref="filePatchView"
             commandRegistry={this.props.commandRegistry}
             attemptLineStageOperation={this.attemptLineStageOperation}
             didSurfaceFile={this.didSurfaceFile}
+            didDiveIntoCorrespondingFilePatch={this.diveIntoCorrespondingFilePatch}
             attemptHunkStageOperation={this.attemptHunkStageOperation}
             hunks={hunks}
+            filePath={filePath}
             stagingStatus={this.props.stagingStatus}
+            isPartiallyStaged={this.props.isPartiallyStaged}
             registerHunkView={this.props.registerHunkView}
             openCurrentFile={this.openCurrentFile}
+            discardLines={this.props.discardLines}
+            undoLastDiscard={this.undoLastDiscard}
+            hasUndoHistory={hasUndoHistory}
           />
         </div>
       );
@@ -164,6 +172,14 @@ export default class FilePatchController {
     }
   }
 
+  @autobind
+  diveIntoCorrespondingFilePatch() {
+    const filePath = this.props.filePatch.getPath();
+    const stagingStatus = this.props.stagingStatus === 'staged' ? 'unstaged' : 'staged';
+    this.props.quietlySelectItem(filePath, stagingStatus);
+    return this.props.didDiveIntoFilePath(filePath, stagingStatus, {amending: this.props.isAmending});
+  }
+
   didUpdateFilePatch() {
     // FilePatch was mutated so all we need to do is re-render
     return etch.update(this);
@@ -187,4 +203,14 @@ export default class FilePatchController {
     textEditor.setCursorBufferPosition(position);
     return textEditor;
   }
+
+  @autobind
+  undoLastDiscard() {
+    return this.props.undoLastDiscard(this.props.filePatch.getPath());
+  }
+
+  @autobind
+  hasUndoHistory() {
+    return this.props.repository.hasUndoHistory(this.props.filePatch.getPath());
+  }
 }

lib/controllers/git-controller.js

@@ -1,6 +1,6 @@
 import path from 'path';
 
-import {CompositeDisposable, Disposable, File} from 'atom';
+import {CompositeDisposable, Disposable, File, TextBuffer} from 'atom';
 
 import React from 'react';
 import {autobind} from 'core-decorators';
@@ -18,11 +18,14 @@ import GitPanelController from './git-panel-controller';
 import StatusBarTileController from './status-bar-tile-controller';
 import ModelObserver from '../models/model-observer';
 import ModelStateRegistry from '../models/model-state-registry';
+import discardChangesInBuffer from '../discard-changes-in-buffer';
+import {CannotRestoreError} from '../models/file-discard-history';
 
 const nullFilePatchState = {
   filePath: null,
   filePatch: null,
   stagingStatus: null,
+  partiallyStaged: null,
 };
 
 export default class GitController extends React.Component {
@@ -182,9 +185,15 @@ export default class GitController extends React.Component {
               commandRegistry={this.props.commandRegistry}
               filePatch={this.state.filePatch}
               stagingStatus={this.state.stagingStatus}
+              isAmending={this.state.amending}
+              isPartiallyStaged={this.state.partiallyStaged}
               onRepoRefresh={this.onRepoRefresh}
               didSurfaceFile={this.surfaceFromFileAtPath}
+              didDiveIntoFilePath={this.diveIntoFilePatchForPath}
+              quietlySelectItem={this.quietlySelectItem}
               openFiles={this.openFiles}
+              discardLines={this.discardLines}
+              undoLastDiscard={this.undoLastDiscard}
             />
           </EtchWrapper>
         </PaneItem>
@@ -211,9 +220,10 @@ export default class GitController extends React.Component {
 
     const staged = stagingStatus === 'staged';
     const filePatch = await repository.getFilePatchForPath(filePath, {staged, amending: staged && amending});
+    const partiallyStaged = await repository.isPartiallyStaged(filePath);
     return new Promise(resolve => {
       if (filePatch) {
-        this.setState({filePath, filePatch, stagingStatus}, () => {
+        this.setState({filePath, filePatch, stagingStatus, partiallyStaged}, () => {
           // TODO: can be better done w/ a prop?
           if (activate && this.filePatchControllerPane) {
             this.filePatchControllerPane.activate();
@@ -336,4 +346,98 @@ export default class GitController extends React.Component {
   handleChangeTab(activeTab) {
     this.setState({activeTab});
   }
+
+  @autobind
+  async discardLines(lines) {
+    const relFilePath = this.state.filePatch.getPath();
+    const absfilePath = path.join(this.props.repository.getWorkingDirectoryPath(), relFilePath);
+    let buffer, disposable;
+    const isSafe = async () => {
+      const editor = this.props.workspace.getTextEditors().find(e => e.getPath() === absfilePath);
+      if (editor) {
+        buffer = editor.getBuffer();
+        if (buffer.isModified()) {
+          this.props.notificationManager.addError('Cannot discard lines.', {description: 'You have unsaved changes.'});
+          return false;
+        }
+      } else {
+        buffer = new TextBuffer({filePath: absfilePath, load: true});
+        await new Promise(resolve => {
+          disposable = buffer.onDidReload(() => {
+            disposable.dispose();
+            resolve();
+          });
+        });
+      }
+      return true;
+    };
+    const snapshots = await this.props.repository.storeBeforeAndAfterBlobs(relFilePath, isSafe, () => {
+      this.discardChangesInBuffer(buffer, this.state.filePatch, lines);
+    });
+    if (disposable) { disposable.dispose(); }
+    return snapshots;
+  }
+
+  discardChangesInBuffer(buffer, filePatch, lines) {
+    discardChangesInBuffer(buffer, filePatch, lines);
+  }
+
+  @autobind
+  async undoLastDiscard(filePath) {
+    const relFilePath = this.state.filePatch.getPath();
+    const absfilePath = path.join(this.props.repository.getWorkingDirectoryPath(), relFilePath);
+    const isSafe = () => {
+      const editor = this.props.workspace.getTextEditors().find(e => e.getPath() === absfilePath);
+      if (editor && editor.getBuffer().isModified()) {
+        this.notifyInabilityToUndo(relFilePath, 'You have unsaved changes.');
+        return false;
+      }
+      return true;
+    };
+    try {
+      await this.props.repository.attemptToRestoreBlob(filePath, isSafe);
+    } catch (e) {
+      if (e instanceof CannotRestoreError) {
+        this.notifyInabilityToUndo(relFilePath, 'Contents have been modified since last discard.');
+      } else if (e.stdErr.match(/fatal: Not a valid object name/)) {
+        this.notifyInabilityToUndo(relFilePath, 'Discard history has expired.');
+        this.props.repository.clearDiscardHistoryForPath(filePath);
+      } else {
+        // eslint-disable-next-line no-console
+        console.error(e);
+      }
+    }
+  }
+
+  notifyInabilityToUndo(filePath, description) {
+    const openPreDiscardVersion = () => this.openFileBeforeLastDiscard(filePath);
+    this.props.notificationManager.addError(
+      'Cannot undo last discard.',
+      {
+        description: `${description} Would you like to open pre-discard version of "${filePath}" in new buffer?`,
+        buttons: [{
+          text: 'Open in new buffer',
+          onDidClick: openPreDiscardVersion,
+          dismissable: true,
+        }],
+      },
+    );
+  }
+
+  async openFileBeforeLastDiscard(filePath) {
+    const {beforeSha} = await this.props.repository.getLastHistorySnapshotsForPath(filePath);
+    const contents = await this.props.repository.getBlobContents(beforeSha);
+    const editor = await this.props.workspace.open();
+    editor.setText(contents);
+    return editor;
+  }
+
+  @autobind
+  quietlySelectItem(filePath, stagingStatus) {
+    if (this.gitPanelController) {
+      return this.gitPanelController.getWrappedComponent().quietlySelectItem(filePath, stagingStatus);
+    } else {
+      return null;
+    }
+  }
 }

lib/controllers/git-panel-controller.js

@@ -231,4 +231,9 @@ export default class GitPanelController {
   isFocused() {
     return this.refs.gitPanel.isFocused();
   }
+
+  @autobind
+  quietlySelectItem(filePath, stagingStatus) {
+    return this.refs.gitPanel.quitelySelectItem(filePath, stagingStatus);
+  }
 }

lib/discard-changes-in-buffer.js

@@ -0,0 +1,35 @@
+export default function discardChangesInBuffer(buffer, filePatch, discardedLines) {
+  buffer.transact(() => {
+    let addedCount = 0;
+    let removedCount = 0;
+    let deletedCount = 0;
+    filePatch.getHunks().forEach(hunk => {
+      hunk.getLines().forEach(line => {
+        if (discardedLines.has(line)) {
+          if (line.status === 'deleted') {
+            const row = (line.oldLineNumber - deletedCount) + addedCount - removedCount - 1;
+            buffer.insert([row, 0], line.text + '\n');
+            addedCount++;
+          } else if (line.status === 'added') {
+            const row = line.newLineNumber + addedCount - removedCount - 1;
+            if (buffer.lineForRow(row) === line.text) {
+              buffer.deleteRow(row);
+              removedCount++;
+            } else {
+              throw new Error(buffer.lineForRow(row) + ' does not match ' + line.text);
+            }
+          } else if (line.status === 'nonewline') {
+            // TODO: handle no new line case
+          } else {
+            throw new Error(`unrecognized status: ${line.status}. Must be 'added' or 'deleted'`);
+          }
+        }
+        if (line.getStatus() === 'deleted') {
+          deletedCount++;
+        }
+      });
+    });
+  });
+
+  buffer.save();
+}

lib/git-shell-out-strategy.js

@@ -7,7 +7,7 @@ import {parse as parseDiff} from 'what-the-diff';
 
 import GitPromptServer from './git-prompt-server';
 import AsyncQueue from './async-queue';
-import {readFile, fsStat, deleteFileOrFolder} from './helpers';
+import {readFile, writeFile, fsStat, deleteFileOrFolder} from './helpers';
 
 const LINE_ENDING_REGEX = /\r?\n/;
 
@@ -36,7 +36,7 @@ export default class GitShellOutStrategy {
   }
 
   // Execute a command and read the output using the embedded Git environment
-  exec(args, stdin = null, useGitPromptServer = false) {
+  exec(args, stdin = null, useGitPromptServer = false, redirectFilePath = null) {
     /* eslint-disable no-console */
     const subscriptions = new CompositeDisposable();
     return this.commandQueue.push(async () => {
@@ -99,6 +99,9 @@ export default class GitShellOutStrategy {
             err.command = formattedArgs;
             return Promise.reject(err);
           }
+          if (redirectFilePath) {
+            return writeFile(redirectFilePath, stdout);
+          }
           return stdout;
         });
     });
@@ -268,6 +271,19 @@ export default class GitShellOutStrategy {
     return rawDiffs[0];
   }
 
+  async isPartiallyStaged(filePath) {
+    const args = ['status', '--short', '--', filePath];
+    const output = await this.exec(args);
+    const results = output.trim().split(LINE_ENDING_REGEX);
+    if (results.length === 2) {
+      return true;
+    } else if (results.length === 1) {
+      return ['MM', 'AM', 'MD'].includes(results[0].slice(0, 2));
+    } else {
+      throw new Error(`Unexpected output for ${args.join(' ')}: ${output}`);
+    }
+  }
+
   /**
    * Miscellaneous getters
    */
@@ -445,6 +461,26 @@ export default class GitShellOutStrategy {
       return [];
     }
   }
+
+  async createBlob({filePath, stdin} = {}) {
+    let output;
+    if (filePath) {
+      output = await this.exec(['hash-object', '-w', filePath]);
+    } else if (stdin) {
+      output = await this.exec(['hash-object', '-w', '--stdin'], stdin);
+    } else {
+      throw new Error('Must supply file path or stdin');
+    }
+    return output.trim();
+  }
+
+  async restoreBlob(filePath, sha) {
+    await this.exec(['cat-file', '-p', sha], null, null, path.join(this.workingDir, filePath));
+  }
+
+  async getBlobContents(sha) {
+    return await this.exec(['cat-file', '-p', sha]);
+  }
 }
 
 function buildAddedFilePatch(filePath, contents, stats) {

lib/helpers.js

@@ -9,6 +9,14 @@ export function readFile(absoluteFilePath, encoding = 'utf8') {
   });
 }
 
+export function writeFile(absoluteFilePath, contents) {
+  return new Promise((resolve, reject) => {
+    fs.writeFile(absoluteFilePath, contents, err => {
+      if (err) { return reject(err); } else { return resolve(); }
+    });
+  });
+}
+
 export function deleteFileOrFolder(path) {
   return new Promise((resolve, reject) => {
     fs.remove(path, err => {