Implement file system watchers for project moves and deletions

Copilot · eleanorjboyd · Copilot · commit 2960abf42b57 · 2025-06-25T16:46:37.000Z
Co-authored-by: eleanorjboyd &lt;26030610+eleanorjboyd@users.noreply.github.com&gt;
diff --git a/src/common/workspace.apis.ts b/src/common/workspace.apis.ts
@@ -5,6 +5,7 @@ import {
     ConfigurationScope,
     Disposable,
     FileDeleteEvent,
+    FileRenameEvent,
     FileSystemWatcher,
     GlobPattern,
     Uri,
@@ -63,3 +64,11 @@ export function onDidDeleteFiles(
 ): Disposable {
     return workspace.onDidDeleteFiles(listener, thisArgs, disposables);
 }
+
+export function onDidRenameFiles(
+    listener: (e: FileRenameEvent) => any,
+    thisArgs?: any,
+    disposables?: Disposable[],
+): Disposable {
+    return workspace.onDidRenameFiles(listener, thisArgs, disposables);
+}
diff --git a/src/features/projectManager.ts b/src/features/projectManager.ts
@@ -170,6 +170,35 @@ export class PythonProjectManagerImpl implements PythonProjectManager {
         this._onDidChangeProjects.fire(Array.from(this._projects.values()));
     }
 
+    updateProjectUri(oldUri: Uri, newUri: Uri): void {
+        const oldKey = oldUri.toString();
+        const project = this._projects.get(oldKey);
+        
+        if (!project) {
+            return;
+        }
+
+        // Remove the project with the old URI
+        this._projects.delete(oldKey);
+        
+        // Create a new project instance with the updated URI
+        const updatedProject = this.create(
+            path.basename(newUri.fsPath),
+            newUri,
+            {
+                description: project.description,
+                tooltip: project.tooltip,
+                iconPath: (project as PythonProjectsImpl).iconPath, // Cast to implementation to access iconPath
+            }
+        );
+        
+        // Add the updated project
+        this._projects.set(newUri.toString(), updatedProject);
+        
+        // Fire the change event to update the view
+        this._onDidChangeProjects.fire(Array.from(this._projects.values()));
+    }
+
     getProjects(uris?: Uri[]): ReadonlyArray<PythonProject> {
         if (uris === undefined) {
             return Array.from(this._projects.values());
diff --git a/src/features/views/projectView.ts b/src/features/views/projectView.ts
@@ -12,7 +12,7 @@ import {
 import { PythonEnvironment } from '../../api';
 import { ProjectViews } from '../../common/localize';
 import { createSimpleDebounce } from '../../common/utils/debounce';
-import { onDidChangeConfiguration } from '../../common/workspace.apis';
+import { onDidChangeConfiguration, onDidDeleteFiles, onDidRenameFiles } from '../../common/workspace.apis';
 import { EnvironmentManagers, PythonProjectManager } from '../../internal.api';
 import {
     GlobalProjectItem,
@@ -68,6 +68,12 @@ export class ProjectView implements TreeDataProvider<ProjectTreeItem> {
                     this.debouncedUpdateProject.trigger();
                 }
             }),
+            onDidRenameFiles((e) => {
+                this.handleFileRenames(e);
+            }),
+            onDidDeleteFiles((e) => {
+                this.handleFileDeletions(e);
+            }),
         );
     }
 
@@ -224,6 +230,60 @@ export class ProjectView implements TreeDataProvider<ProjectTreeItem> {
         return element.parent;
     }
 
+    private handleFileRenames(e: { readonly files: ReadonlyArray<{ readonly oldUri: Uri; readonly newUri: Uri }> }): void {
+        const projects = this.projectManager.getProjects();
+        
+        for (const { oldUri, newUri } of e.files) {
+            // Check if any project matches the old URI exactly or is contained within it
+            const affectedProjects = projects.filter(project => {
+                const projectPath = project.uri.fsPath;
+                const oldPath = oldUri.fsPath;
+                
+                // Check if the project path is the same as or is a child of the renamed path
+                return projectPath === oldPath || projectPath.startsWith(oldPath + '/') || projectPath.startsWith(oldPath + '\\');
+            });
+            
+            for (const project of affectedProjects) {
+                const projectPath = project.uri.fsPath;
+                const oldPath = oldUri.fsPath;
+                const newPath = newUri.fsPath;
+                
+                // Calculate the new project path
+                let newProjectPath: string;
+                if (projectPath === oldPath) {
+                    // Project path is exactly the renamed path
+                    newProjectPath = newPath;
+                } else {
+                    // Project path is a child of the renamed path
+                    const relativePath = projectPath.substring(oldPath.length);
+                    newProjectPath = newPath + relativePath;
+                }
+                
+                const newProjectUri = Uri.file(newProjectPath);
+                this.projectManager.updateProjectUri(project.uri, newProjectUri);
+            }
+        }
+    }
+
+    private handleFileDeletions(e: { readonly files: ReadonlyArray<Uri> }): void {
+        const projects = this.projectManager.getProjects();
+        
+        for (const deletedUri of e.files) {
+            // Check if any project matches the deleted URI exactly or is contained within it
+            const affectedProjects = projects.filter(project => {
+                const projectPath = project.uri.fsPath;
+                const deletedPath = deletedUri.fsPath;
+                
+                // Check if the project path is the same as or is a child of the deleted path
+                return projectPath === deletedPath || projectPath.startsWith(deletedPath + '/') || projectPath.startsWith(deletedPath + '\\');
+            });
+            
+            if (affectedProjects.length > 0) {
+                this.projectManager.remove(affectedProjects);
+            }
+        }
+    }
+
     dispose() {
         this.disposables.forEach((d) => d.dispose());
     }
diff --git a/src/internal.api.ts b/src/internal.api.ts
@@ -287,6 +287,7 @@ export interface PythonProjectManager extends Disposable {
     ): PythonProject;
     add(pyWorkspace: PythonProject | PythonProject[]): Promise<void>;
     remove(pyWorkspace: PythonProject | PythonProject[]): void;
+    updateProjectUri(oldUri: Uri, newUri: Uri): void;
     getProjects(uris?: Uri[]): ReadonlyArray<PythonProject>;
     get(uri: Uri): PythonProject | undefined;
     onDidChangeProjects: Event<PythonProject[] | undefined>;
diff --git a/src/test/features/projectManager.updateUri.unit.test.ts b/src/test/features/projectManager.updateUri.unit.test.ts
@@ -0,0 +1,88 @@
+import assert from 'assert';
+import { Uri } from 'vscode';
+import { PythonProjectManagerImpl } from '../../features/projectManager';
+
+suite('Project Manager Update URI tests', () => {
+    let projectManager: PythonProjectManagerImpl;
+
+    setup(() => {
+        projectManager = new PythonProjectManagerImpl();
+    });
+
+    teardown(() => {
+        projectManager.dispose();
+    });
+
+    test('updateProjectUri should update existing project URI', () => {
+        const oldUri = Uri.file('/path/to/old/project');
+        const newUri = Uri.file('/path/to/new/project');
+
+        // Create a project and manually add it to the internal map to bypass the complex add method
+        const project = projectManager.create('TestProject', oldUri, {
+            description: 'Test project',
+            tooltip: 'Test tooltip'
+        });
+        
+        // Access private _projects map to manually add the project for testing
+        (projectManager as any)._projects.set(oldUri.toString(), project);
+
+        // Verify project exists with old URI
+        const oldProject = projectManager.get(oldUri);
+        assert.ok(oldProject, 'Project should exist with old URI');
+        assert.equal(oldProject.uri.fsPath, oldUri.fsPath, 'Old URI should match');
+
+        // Update the project URI
+        projectManager.updateProjectUri(oldUri, newUri);
+
+        // Verify project no longer exists with old URI
+        const oldProjectAfterUpdate = projectManager.get(oldUri);
+        assert.equal(oldProjectAfterUpdate, undefined, 'Project should not exist with old URI after update');
+
+        // Verify project exists with new URI
+        const newProject = projectManager.get(newUri);
+        assert.ok(newProject, 'Project should exist with new URI');
+        assert.equal(newProject.uri.fsPath, newUri.fsPath, 'New URI should match');
+        assert.equal(newProject.name, 'project', 'Project name should be based on new path');
+        assert.equal(newProject.description, 'Test project', 'Description should be preserved');
+        assert.equal(newProject.tooltip, 'Test tooltip', 'Tooltip should be preserved');
+    });
+
+    test('updateProjectUri should handle non-existent project gracefully', () => {
+        const oldUri = Uri.file('/path/to/nonexistent/project');
+        const newUri = Uri.file('/path/to/new/project');
+
+        // Try to update a project that doesn't exist
+        // This should not throw an error
+        assert.doesNotThrow(() => {
+            projectManager.updateProjectUri(oldUri, newUri);
+        }, 'Should handle non-existent project gracefully');
+
+        // Verify no project was created
+        const newProject = projectManager.get(newUri);
+        assert.equal(newProject, undefined, 'No project should be created for non-existent old project');
+    });
+
+    test('remove should remove multiple projects', () => {
+        const project1Uri = Uri.file('/path/to/project1');
+        const project2Uri = Uri.file('/path/to/project2');
+
+        // Create projects and manually add them to the internal map
+        const project1 = projectManager.create('Project1', project1Uri);
+        const project2 = projectManager.create('Project2', project2Uri);
+        
+        // Access private _projects map to manually add projects for testing
+        (projectManager as any)._projects.set(project1Uri.toString(), project1);
+        (projectManager as any)._projects.set(project2Uri.toString(), project2);
+
+        // Verify both projects exist
+        assert.ok(projectManager.get(project1Uri), 'Project1 should exist');
+        assert.ok(projectManager.get(project2Uri), 'Project2 should exist');
+
+        // Remove both projects
+        projectManager.remove([project1, project2]);
+
+        // Verify both projects are removed
+        assert.equal(projectManager.get(project1Uri), undefined, 'Project1 should be removed');
+        assert.equal(projectManager.get(project2Uri), undefined, 'Project2 should be removed');
+    });
+});
