update customTask, fixed watcher

Author: aelam

package-lock.json

@@ -416,6 +416,7 @@
     "dev-package": "vsce package -o swift-lang-development.vsix"
   },
   "devDependencies": {
+    "@types/checksum": "^0.1.33",
     "@types/glob": "^7.1.4",
     "@types/mocha": "^9.0.0",
     "@types/node": "14.x",
@@ -434,6 +435,7 @@
   },
   "dependencies": {
     "@types/plist": "^3.0.2",
+    "checksum": "^1.0.0",
     "plist": "^3.0.5",
     "vscode-languageclient": "^8.0.0"
   }

package.json

@@ -123,6 +123,10 @@ export class FolderContext implements vscode.Disposable {
         await this.swiftPackage.reloadPackageResolved();
     }
 
+    get resolvedContent(): string | undefined {
+        return this.resolvedContent;
+    }
+
     /**
      * Fire an event to all folder observers
      * @param event event type

src/FolderContext.ts

@@ -14,7 +14,6 @@
 
 import * as vscode from "vscode";
 import { FolderContext } from "./FolderContext";
-import { buildDirectoryFromWorkspacePath } from "./utilities/utilities";
 import { FolderEvent, WorkspaceContext } from "./WorkspaceContext";
 
 /**
@@ -26,7 +25,6 @@ import { FolderEvent, WorkspaceContext } from "./WorkspaceContext";
 export class PackageWatcher {
     private packageFileWatcher?: vscode.FileSystemWatcher;
     private resolvedFileWatcher?: vscode.FileSystemWatcher;
-    private workspaceStateFileWatcher?: vscode.FileSystemWatcher;
 
     constructor(private folderContext: FolderContext, private workspaceContext: WorkspaceContext) {}
 
@@ -37,7 +35,6 @@ export class PackageWatcher {
     install() {
         this.packageFileWatcher = this.createPackageFileWatcher();
         this.resolvedFileWatcher = this.createResolvedFileWatcher();
-        this.workspaceStateFileWatcher = this.createWorkspaceStateFileWatcher();
     }
 
     /**
@@ -47,7 +44,6 @@ export class PackageWatcher {
     dispose() {
         this.packageFileWatcher?.dispose();
         this.resolvedFileWatcher?.dispose();
-        this.workspaceStateFileWatcher?.dispose();
     }
 
     private createPackageFileWatcher(): vscode.FileSystemWatcher {
@@ -64,23 +60,9 @@ export class PackageWatcher {
         const watcher = vscode.workspace.createFileSystemWatcher(
             new vscode.RelativePattern(this.folderContext.folder, "Package.resolved")
         );
-        watcher.onDidCreate(async () => await this.handlePackageResolvedChange());
-        watcher.onDidChange(async () => await this.handlePackageResolvedChange());
-        watcher.onDidDelete(async () => await this.handlePackageResolvedChange());
-        return watcher;
-    }
-
-    private createWorkspaceStateFileWatcher(): vscode.FileSystemWatcher {
-        const uri = vscode.Uri.file(
-            buildDirectoryFromWorkspacePath(this.folderContext.folder.fsPath, true)
-        );
-
-        const watcher = vscode.workspace.createFileSystemWatcher(
-            new vscode.RelativePattern(uri, "workspace-state.json")
-        );
-        watcher.onDidCreate(async () => await this.handleWorkspaceStateChange());
-        watcher.onDidChange(async () => await this.handleWorkspaceStateChange());
-        watcher.onDidDelete(async () => await this.handleWorkspaceStateChange());
+        // watcher.onDidCreate(async () => await this.handlePackageResolvedChange());
+        watcher.onDidChange(async () => await this.handlePackageResolvedChange("change"));
+        watcher.onDidDelete(async () => await this.handlePackageResolvedChange("delete"));
         return watcher;
     }
 
@@ -102,17 +84,17 @@ export class PackageWatcher {
      *
      * This will resolve any changes in the Package.resolved.
      */
-    private async handlePackageResolvedChange() {
-        await this.folderContext.reloadPackageResolved();
-        this.workspaceContext.fireEvent(this.folderContext, FolderEvent.resolvedUpdated);
-    }
+    private async handlePackageResolvedChange(action: "change" | "delete") {
+        // if Package.resolved is modified, we need to resolve the dependencies
+        // after resolving is done, it will MODIFY the Package.resolved again
+        // BUT, the file content is not actually changed
+        // we don't want to resolve the dependencies again
+        const hasChanges = await this.folderContext.swiftPackage.packageResovledHasChanged(action);
+        if (!hasChanges) {
+            return;
+        }
 
-    /**
-     * Handles a create or change event for **workspace-state.json**.
-     *
-     * This will resolve any changes in the workspace-state.json
-     */
-    private async handleWorkspaceStateChange() {
-        this.workspaceContext.fireEvent(this.folderContext, FolderEvent.workspaceStateUpdated);
+        await this.folderContext.swiftPackage.reloadPackageResolved();
+        this.workspaceContext.fireEvent(this.folderContext, FolderEvent.resolvedUpdated);
     }
 }

src/PackageWatcher.ts

@@ -19,6 +19,7 @@ import {
     execSwift,
     getErrorDescription,
 } from "./utilities/utilities";
+import checksum = require("checksum");
 
 /** Swift Package Manager contents */
 export interface PackageContents {
@@ -165,7 +166,9 @@ export class SwiftPackage implements PackageContents {
         readonly folder: vscode.Uri,
         private contents: SwiftPackageState,
         public resolved: PackageResolved | undefined,
-        public plugins: PackagePlugin[]
+        public plugins: PackagePlugin[],
+        public resolvedContent: string | undefined,
+        public dependencySet: Set<string>
     ) {}
 
     /**
@@ -177,7 +180,8 @@ export class SwiftPackage implements PackageContents {
         const contents = await SwiftPackage.loadPackage(folder);
         const resolved = await SwiftPackage.loadPackageResolved(folder);
         const plugins = await SwiftPackage.loadPlugins(folder);
-        return new SwiftPackage(folder, contents, resolved, plugins);
+        const resolvedContent = await SwiftPackage.loadPackageResolvedFile(folder);
+        return new SwiftPackage(folder, contents, resolved, plugins, resolvedContent, new Set());
     }
 
     /**
@@ -213,10 +217,22 @@ export class SwiftPackage implements PackageContents {
         }
     }
 
-    static async loadPackageResolved(folder: vscode.Uri): Promise<PackageResolved | undefined> {
+    static async loadPackageResolvedFile(folder: vscode.Uri): Promise<string | undefined> {
         try {
             const uri = vscode.Uri.joinPath(folder, "Package.resolved");
             const contents = await fs.readFile(uri.fsPath, "utf8");
+            return contents;
+        } catch {
+            return undefined;
+        }
+    }
+
+    static async loadPackageResolved(folder: vscode.Uri): Promise<PackageResolved | undefined> {
+        try {
+            const contents = await SwiftPackage.loadPackageResolvedFile(folder);
+            if (contents === undefined) {
+                return undefined;
+            }
             const json = JSON.parse(contents);
             const version = <{ version: number }>json;
             if (version.version === 1) {
@@ -257,6 +273,34 @@ export class SwiftPackage implements PackageContents {
         }
     }
 
+    async packageResovledHasChanged(action: any): Promise<boolean> {
+        console.log(action);
+        const resolvedContent = await SwiftPackage.loadPackageResolvedFile(this.folder);
+
+        console.log(resolvedContent);
+        console.log(this.resolvedContent);
+
+        if (resolvedContent === undefined) {
+            return false;
+        }
+        // deletion --> creation --> modification
+        // r  undefined   exists        exists
+        // pr exists      undefined     exists
+
+        if (this.resolvedContent === undefined) {
+            return true;
+        }
+
+        const oldChecksum = checksum(resolvedContent);
+        const newChecksum = checksum(this.resolvedContent);
+
+        if (oldChecksum !== newChecksum) {
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * Load workspace-state.json file for swift package
      * @returns Workspace state
@@ -275,13 +319,35 @@ export class SwiftPackage implements PackageContents {
         }
     }
 
+    /**
+     * Run `swift package describe` and return results
+     * @param folder folder package is in
+     * @returns results of `swift package describe`
+     */
+    async resolveDependencyGraph(): Promise<Set<string>> {
+        return this.dependencySet;
+    }
+
+    updateDependencySetWithStdout(stdout: string): void {
+        const lines = stdout
+            .split("\n")
+            .filter(item => item !== "")
+            .map(item => item.trim());
+        this.updateDependencySet(new Set(lines ?? []));
+    }
+
+    updateDependencySet(dependencySet: Set<string>): void {
+        this.dependencySet = dependencySet;
+    }
+
     /** Reload swift package */
     public async reload() {
         this.contents = await SwiftPackage.loadPackage(this.folder);
     }
 
     /** Reload Package.resolved file */
     public async reloadPackageResolved() {
+        this.resolvedContent = await SwiftPackage.loadPackageResolvedFile(this.folder);
         this.resolved = await SwiftPackage.loadPackageResolved(this.folder);
     }