updateprojecturi to updateproject and include debounce updates

Author: eleanorjboyd

src/features/projectManager.ts

@@ -170,33 +170,39 @@ 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);
-        
+    /**
+     * Update a project by removing the old one and adding a new one with updated properties.
+     * @param existingUri The URI of the project to update.
+     * @param newName The new name for the project (optional, defaults to old name).
+     * @param newUri The new URI for the project (optional, defaults to old URI).
+     * @param newOptions New options for the project (optional, merged with old options).
+     */
+    async updateProject(
+        existingUri: Uri,
+        newName?: string,
+        newUri?: Uri,
+        newOptions?: { description?: string; tooltip?: string | MarkdownString; iconPath?: IconPath },
+    ): Promise<void> {
+        const project = this.get(existingUri);
         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()));
+        // Remove the old project
+        this.remove(project);
+
+        // Prepare new values
+        const name = newName ?? project.name;
+        const uri = newUri ?? project.uri;
+        const options = {
+            description: newOptions?.description ?? project.description,
+            tooltip: newOptions?.tooltip ?? project.tooltip,
+            iconPath: newOptions?.iconPath ?? (project as PythonProjectsImpl).iconPath,
+        };
+
+        // Create and add the new project
+        const updatedProject = this.create(name, uri, options);
+        await this.add(updatedProject);
     }
 
     getProjects(uris?: Uri[]): ReadonlyArray<PythonProject> {
@@ -212,7 +218,7 @@ export class PythonProjectManagerImpl implements PythonProjectManager {
             }
             return projects;
         }
-    }
+    }0
 
     get(uri: Uri): PythonProject | undefined {
         let pythonProject = this._projects.get(uri.toString());

src/features/views/projectView.ts

@@ -230,24 +230,30 @@ export class ProjectView implements TreeDataProvider<ProjectTreeItem> {
         return element.parent;
     }
 
-    private handleFileRenames(e: { readonly files: ReadonlyArray<{ readonly oldUri: Uri; readonly newUri: Uri }> }): void {
+    private async handleFileRenames(e: {
+        readonly files: ReadonlyArray<{ readonly oldUri: Uri; readonly newUri: Uri }>;
+    }): Promise<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 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 + '\\');
+                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) {
@@ -258,28 +264,39 @@ export class ProjectView implements TreeDataProvider<ProjectTreeItem> {
                     const relativePath = projectPath.substring(oldPath.length);
                     newProjectPath = newPath + relativePath;
                 }
-                
+
                 const newProjectUri = Uri.file(newProjectPath);
-                this.projectManager.updateProjectUri(project.uri, newProjectUri);
+                await this.projectManager.updateProject(project.uri, undefined, newProjectUri);
+            }
+
+            if (affectedProjects.length > 0) {
+                // only trigger update if there are affected projects
+                this.debouncedUpdateProject.trigger();
             }
         }
     }
 
     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 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 + '\\');
+                return (
+                    projectPath === deletedPath ||
+                    projectPath.startsWith(deletedPath + '/') ||
+                    projectPath.startsWith(deletedPath + '\\')
+                );
             });
-            
+
             if (affectedProjects.length > 0) {
                 this.projectManager.remove(affectedProjects);
+                // If there are affected projects, trigger an update
+                this.debouncedUpdateProject.trigger();
             }
         }
     }

src/internal.api.ts

@@ -287,7 +287,12 @@ export interface PythonProjectManager extends Disposable {
     ): PythonProject;
     add(pyWorkspace: PythonProject | PythonProject[]): Promise<void>;
     remove(pyWorkspace: PythonProject | PythonProject[]): void;
-    updateProjectUri(oldUri: Uri, newUri: Uri): void;
+    updateProject(
+        existingUri: Uri,
+        newName?: string,
+        newUri?: Uri,
+        newOptions?: { description?: string; tooltip?: string | MarkdownString; iconPath?: IconPath },
+    ): Promise<void>;
     getProjects(uris?: Uri[]): ReadonlyArray<PythonProject>;
     get(uri: Uri): PythonProject | undefined;
     onDidChangeProjects: Event<PythonProject[] | undefined>;

src/test/features/projectManager.updateUri.unit.test.ts

@@ -21,19 +21,22 @@ suite('Project Manager Update URI tests', () => {
         // 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'
+            tooltip: 'Test tooltip',
         });
-        
+
         // Access private _projects map to manually add the project for testing
-        (projectManager as unknown as { _projects: Map<string, PythonProject> })._projects.set(oldUri.toString(), project);
+        (projectManager as unknown as { _projects: Map<string, PythonProject> })._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);
+        projectManager.updateProject(oldUri, 'project', newUri);
 
         // Verify project no longer exists with old URI
         const oldProjectAfterUpdate = projectManager.get(oldUri);
@@ -55,7 +58,7 @@ suite('Project Manager Update URI tests', () => {
         // Try to update a project that doesn't exist
         // This should not throw an error
         assert.doesNotThrow(() => {
-            projectManager.updateProjectUri(oldUri, newUri);
+            projectManager.updateProject(oldUri, 'project', newUri);
         }, 'Should handle non-existent project gracefully');
 
         // Verify no project was created
@@ -70,7 +73,7 @@ suite('Project Manager Update URI tests', () => {
         // 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
         const pmWithPrivateAccess = projectManager as unknown as { _projects: Map<string, PythonProject> };
         pmWithPrivateAccess._projects.set(project1Uri.toString(), project1);
@@ -87,4 +90,4 @@ suite('Project Manager Update URI tests', () => {
         assert.equal(projectManager.get(project1Uri), undefined, 'Project1 should be removed');
         assert.equal(projectManager.get(project2Uri), undefined, 'Project2 should be removed');
     });
-});
+});