refactor(gumby): use only diff.patch to apply patch #4306

Problem:
The current implementation of the diff viewer relies on the full changed source code being returned by the ExportResultArchive API. This is unnecessary and led to some customer issues when the download size was too large. We should be able to show the diff viewer using only the diff.patch file returned by the API.

Solution:
Get rid of the "parse-diff" library and instead use "diff" (pre-existing dependency) to apply the patch to the user's project.

Author: dhasani23

src/codewhisperer/models/model.ts

@@ -248,12 +248,6 @@ export enum BuildSystem {
     Unknown = 'Unknown',
 }
 
-export enum DropdownStep {
-    STEP_1 = 1,
-    STEP_2 = 2,
-    STEP_3 = 3,
-}
-
 export class ZipManifest {
     sourcesRoot: string = 'sources/'
     dependenciesRoot: string | undefined = 'dependencies/'
@@ -276,6 +270,7 @@ export class TransformByQState {
     private summaryFilePath: string = ''
 
     private resultArchiveFilePath: string = ''
+    private projectCopyFilePath: string = ''
 
     private polledJobStatus: string = ''
 
@@ -349,6 +344,10 @@ export class TransformByQState {
         return this.resultArchiveFilePath
     }
 
+    public getProjectCopyFilePath() {
+        return this.projectCopyFilePath
+    }
+
     public getJobFailureReason() {
         return this.jobFailureReason
     }
@@ -425,6 +424,10 @@ export class TransformByQState {
         this.resultArchiveFilePath = filePath
     }
 
+    public setProjectCopyFilePath(filePath: string) {
+        this.projectCopyFilePath = filePath
+    }
+
     public setJobFailureReason(reason: string) {
         this.jobFailureReason = reason
     }

src/codewhisperer/service/transformationResultsViewProvider.ts

@@ -6,7 +6,7 @@
 import AdmZip from 'adm-zip'
 import os from 'os'
 import fs from 'fs-extra'
-import parseDiff from 'parse-diff'
+import { parsePatch, applyPatches, ParsedDiff } from 'diff'
 import path from 'path'
 import vscode from 'vscode'
 
@@ -102,31 +102,6 @@ export class AddedChangeNode extends ProposedChangeNode {
     }
 }
 
-export class RemovedChangeNode extends ProposedChangeNode {
-    readonly pathToOldContents: string
-    override resourcePath: string
-
-    constructor(pathToOldContents: string) {
-        super()
-        this.pathToOldContents = pathToOldContents
-        this.resourcePath = pathToOldContents
-    }
-
-    override generateCommand(): vscode.Command {
-        return {
-            command: 'vscode.open',
-            arguments: [vscode.Uri.file(this.pathToOldContents)],
-            title: 'Removed Change',
-        }
-    }
-    override generateDescription(): string {
-        return 'R'
-    }
-    override saveFile(): void {
-        fs.removeSync(this.pathToOldContents)
-    }
-}
-
 enum ReviewState {
     ToReview,
     Reviewed_Accepted,
@@ -137,19 +112,74 @@ export class DiffModel {
     changes: ProposedChangeNode[] = []
 
     /**
-     *
+     * This function creates a copy of the changed files of the user's project so that the diff.patch can be applied to them
+     * @param pathToWorkspace Path to the project that was transformed
+     * @param changedFiles List of files that were changed
+     * @returns Path to the folder containing the copied files
+     */
+    public copyProject(pathToWorkspace: string, changedFiles: ParsedDiff[]) {
+        const pathToTmpSrcDir = path.join(os.tmpdir(), `project-copy-${Date.now()}`)
+        fs.mkdirSync(pathToTmpSrcDir)
+        changedFiles.forEach(file => {
+            const pathToTmpFile = path.join(pathToTmpSrcDir, file.oldFileName!.substring(2))
+            // use mkdirsSync to create parent directories in pathToTmpFile too
+            fs.mkdirsSync(path.dirname(pathToTmpFile))
+            const pathToOldFile = path.join(pathToWorkspace, file.oldFileName!.substring(2))
+            // pathToOldFile will not exist for new files such as summary.md
+            if (fs.existsSync(pathToOldFile)) {
+                fs.copyFileSync(pathToOldFile, pathToTmpFile)
+            }
+        })
+        return pathToTmpSrcDir
+    }
+
+    /**
      * @param pathToDiff Path to the diff.patch file expected to be located in the archive returned by ExportResultsArchive
-     * @param pathToTmpSrcDir Path to the directory containing changed source files
-     * @param pathToWorkspace Path to the current open workspace directory
-     * @returns
+     * @param pathToWorkspace Path to the project that was transformed
+     * @returns List of nodes containing the paths of files that were modified, added, or removed
      */
-    public parseDiff(pathToDiff: string, pathToTmpSrcDir: string, pathToWorkspace: string): ProposedChangeNode[] {
+    public parseDiff(pathToDiff: string, pathToWorkspace: string): ProposedChangeNode[] {
         const diffContents = fs.readFileSync(pathToDiff, 'utf8')
-        const changedFiles = parseDiff(diffContents)
-
+        const changedFiles = parsePatch(diffContents)
+        // path to the directory containing copy of the changed files in the transformed project
+        const pathToTmpSrcDir = this.copyProject(pathToWorkspace, changedFiles)
+        transformByQState.setProjectCopyFilePath(pathToTmpSrcDir)
+
+        applyPatches(changedFiles, {
+            loadFile: function (fileObj, callback) {
+                // load original contents of file
+                const filePath = path.join(pathToWorkspace, fileObj.oldFileName!.substring(2))
+                if (!fs.existsSync(filePath)) {
+                    // must be a new file (ex. summary.md), so pass empty string as original contents and do not pass error
+                    callback(undefined, '')
+                } else {
+                    // must be a modified file (most common), so pass original contents
+                    const fileContents = fs.readFileSync(filePath, 'utf-8')
+                    callback(undefined, fileContents)
+                }
+            },
+            // by now, 'content' contains the changes from the patch
+            patched: function (fileObj, content, callback) {
+                const filePath = path.join(pathToTmpSrcDir, fileObj.newFileName!.substring(2))
+                // write changed contents to the copy of the original file (or create a new file)
+                fs.writeFileSync(filePath, content)
+                callback(undefined)
+            },
+            complete: function (err) {
+                if (err) {
+                    getLogger().error(`CodeTransform: ${err} when applying patch`)
+                } else {
+                    getLogger().info('CodeTransform: Patch applied successfully')
+                }
+            },
+        })
         this.changes = changedFiles.flatMap(file => {
-            const originalPath = path.join(pathToWorkspace, file.from !== undefined ? file.from : '')
-            const tmpChangedPath = path.join(pathToTmpSrcDir, file.to !== undefined ? file.to : '')
+            /* ex. file.oldFileName = 'a/src/java/com/project/component/MyFile.java'
+             * ex. file.newFileName = 'b/src/java/com/project/component/MyFile.java'
+             * use substring(2) to ignore the 'a/' and 'b/'
+             */
+            const originalPath = path.join(pathToWorkspace, file.oldFileName!.substring(2))
+            const tmpChangedPath = path.join(pathToTmpSrcDir, file.newFileName!.substring(2))
 
             const originalFileExists = fs.existsSync(originalPath)
             const changedFileExists = fs.existsSync(tmpChangedPath)
@@ -158,8 +188,6 @@ export class DiffModel {
                 return new ModifiedChangeNode(originalPath, tmpChangedPath)
             } else if (!originalFileExists && changedFileExists) {
                 return new AddedChangeNode(originalPath, tmpChangedPath)
-            } else if (originalFileExists && !changedFileExists) {
-                return new RemovedChangeNode(originalPath)
             }
             return []
         })
@@ -322,7 +350,6 @@ export class ProposedTransformationExplorer {
                 zip.extractAllTo(pathContainingArchive)
                 diffModel.parseDiff(
                     path.join(pathContainingArchive, ExportResultArchiveStructure.PathToDiffPatch),
-                    path.join(pathContainingArchive, ExportResultArchiveStructure.PathToSourceDir),
                     transformByQState.getProjectPath()
                 )
                 await vscode.commands.executeCommand(
@@ -373,8 +400,9 @@ export class ProposedTransformationExplorer {
             await vscode.commands.executeCommand('setContext', 'gumby.reviewState', TransformByQReviewStatus.NotStarted)
             transformDataProvider.refresh()
             await vscode.window.showInformationMessage(CodeWhispererConstants.changesAppliedMessage)
-            // delete result archive after changes accepted
+            // delete result archive and copied source code after changes accepted
             fs.rmSync(transformByQState.getResultArchiveFilePath(), { recursive: true, force: true })
+            fs.rmSync(transformByQState.getProjectCopyFilePath(), { recursive: true, force: true })
             telemetry.codeTransform_vcsViewerSubmitted.emit({
                 codeTransformSessionId: codeTransformTelemetryState.getSessionId(),
                 codeTransformJobId: transformByQState.getJobId(),

src/test/codewhisperer/service/resources/modifiedFile.diff

@@ -3,8 +3,6 @@ index 084f378..1705101 100644
 --- a/README.md
 +++ b/README.md
 @@ -1,3 +1,5 @@
-+This line is added
-+
- # Building Java Projects with Gradle
- 
- ##### This guide walks you through using Gradle to build a simple Java project.
+This guide walks you through using Gradle to build a simple Java project.
++This line is added.
+\ No newline at end of file

src/test/codewhisperer/service/resources/removedFile.diff

@@ -5,10 +5,10 @@
 import assert from 'assert'
 import sinon from 'sinon'
 import fs from 'fs-extra'
+import os from 'os'
 import {
     DiffModel,
     AddedChangeNode,
-    RemovedChangeNode,
     ModifiedChangeNode,
 } from '../../../codewhisperer/service/transformationResultsViewProvider'
 import path from 'path'
@@ -26,7 +26,6 @@ describe('DiffModel', function () {
         const testDiffModel = new DiffModel()
 
         const workspacePath = 'workspace'
-        const tmpPath = 'tmp'
 
         sinon.replace(fs, 'existsSync', path => {
             const pathStr = path.toString()
@@ -37,50 +36,33 @@ describe('DiffModel', function () {
             return true
         })
 
-        testDiffModel.parseDiff(getTestFilePath('resources/addedFile.diff'), tmpPath, workspacePath)
+        testDiffModel.parseDiff(getTestFilePath('resources/addedFile.diff'), workspacePath)
 
         assert.strictEqual(testDiffModel.changes.length, 1)
         const change = testDiffModel.changes[0]
 
         assert.strictEqual(change instanceof AddedChangeNode, true)
     })
 
-    it('WHEN parsing a diff patch where a file was removed THEN returns an array representing the removed file', async function () {
-        const testDiffModel = new DiffModel()
-
-        const workspacePath = 'workspace'
-        const tmpPath = 'tmp'
-
-        sinon.replace(fs, 'existsSync', path => {
-            const pathStr = path.toString()
-            if (pathStr.includes(workspacePath)) {
-                return true
-            }
-
-            return false
-        })
-
-        testDiffModel.parseDiff(getTestFilePath('resources/removedFile.diff'), tmpPath, workspacePath)
-
-        assert.strictEqual(testDiffModel.changes.length, 1)
-        const change = testDiffModel.changes[0]
-
-        assert.strictEqual(change instanceof RemovedChangeNode, true)
-    })
-
     it('WHEN parsing a diff patch where a file was modified THEN returns an array representing the modified file', async function () {
         const testDiffModel = new DiffModel()
 
-        const workspacePath = 'workspace'
-        const tmpPath = 'tmp'
+        const workspacePath = os.tmpdir()
 
         sinon.replace(fs, 'existsSync', path => true)
 
-        testDiffModel.parseDiff(getTestFilePath('resources/modifiedFile.diff'), tmpPath, workspacePath)
+        fs.writeFileSync(
+            path.join(workspacePath, 'README.md'),
+            'This guide walks you through using Gradle to build a simple Java project.'
+        )
+
+        testDiffModel.parseDiff(getTestFilePath('resources/modifiedFile.diff'), workspacePath)
 
         assert.strictEqual(testDiffModel.changes.length, 1)
         const change = testDiffModel.changes[0]
 
         assert.strictEqual(change instanceof ModifiedChangeNode, true)
+
+        fs.rmSync(path.join(workspacePath, 'README.md'))
     })
 })