Index update event for structure view in VSCode

Author: BoykoAlex

headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/commands/JsonNodeHandler.java

@@ -218,7 +218,8 @@ private void addChild(Consumer<Node> consumer) {
 	}
 
 	private static void assignNodeId(Node n, Node p) {
-		String textId = n.attributes.containsKey(TEXT) ? (String) n.attributes.get(TEXT) : "";
+		String textId = n.attributes.containsKey(PROJECT_ID) ? (String) n.attributes.get(PROJECT_ID)
+				: n.attributes.containsKey(TEXT) ? (String) n.attributes.get(TEXT) : "";
 
 		Location location = (Location) n.attributes.get(LOCATION);
 		String locationId = location == null ? "" : "%s:%d:%d".formatted(location.getUri(), location.getRange().getStart().getLine(), location.getRange().getStart().getCharacter());

vscode-extensions/vscode-spring-boot/lib/api.d.ts

@@ -1,6 +1,6 @@
 import { Event, Uri } from "vscode";
 import { LanguageClient } from "vscode-languageclient/node";
-import { LiveProcess } from "./notification";
+import { IndexUpdateDetails, LiveProcess } from "./notification";
 import {Location} from "vscode-languageclient";
 
 export interface ExtensionAPI {
@@ -109,9 +109,9 @@ interface InjectionPoint {
 
 interface SpringIndex {
    readonly beans: (params: BeansParams) =>  Promise<Bean[]>;
-   readonly onSpringIndexUpdated: Event<void>;
+   readonly onSpringIndexUpdated: Event<IndexUpdateDetails>;
 }
 
 interface BeansParams {
     projectName: string;
-}
+}

vscode-extensions/vscode-spring-boot/lib/apiManager.ts

@@ -1,6 +1,6 @@
 import { commands } from "vscode";
 import { Emitter, LanguageClient } from "vscode-languageclient/node";
-import {Bean, BeansParams, ExtensionAPI} from "./api";
+import { Bean, BeansParams, ExtensionAPI } from "./api";
 import {
     LiveProcess,
     LiveProcessConnectedNotification,
@@ -9,6 +9,7 @@ import {
     LiveProcessGcPausesMetricsUpdatedNotification,
     LiveProcessMemoryMetricsUpdatedNotification,
     SpringIndexUpdatedNotification,
+    IndexUpdateDetails,
 } from "./notification";
 import {RequestType} from "vscode-languageclient";
 
@@ -19,7 +20,7 @@ export class ApiManager {
     private onDidLiveProcessUpdateEmitter: Emitter<LiveProcess> = new Emitter<LiveProcess>();
     private onDidLiveProcessGcPausesMetricsUpdateEmitter: Emitter<LiveProcess> = new Emitter<LiveProcess>();
     private onDidLiveProcessMemoryMetricsUpdateEmitter: Emitter<LiveProcess> = new Emitter<LiveProcess>();
-    private onSpringIndexUpdateEmitter: Emitter<void> = new Emitter<void>();
+    private onSpringIndexUpdateEmitter: Emitter<IndexUpdateDetails> = new Emitter<IndexUpdateDetails>();
 
     public constructor(client: LanguageClient) {
         const onDidLiveProcessConnect = this.onDidLiveProcessConnectEmitter.event;
@@ -61,7 +62,7 @@ export class ApiManager {
         client.onNotification(LiveProcessGcPausesMetricsUpdatedNotification.type, (process: LiveProcess) => this.onDidLiveProcessGcPausesMetricsUpdateEmitter.fire(process));
         client.onNotification(LiveProcessMemoryMetricsUpdatedNotification.type, (process: LiveProcess) => this.onDidLiveProcessMemoryMetricsUpdateEmitter.fire(process));
 
-        client.onNotification(SpringIndexUpdatedNotification.type, () => this.onSpringIndexUpdateEmitter.fire());
+        client.onNotification(SpringIndexUpdatedNotification.type, (details: IndexUpdateDetails) => this.onSpringIndexUpdateEmitter.fire(details));
 
         const beansRequestType = new RequestType<BeansParams, Bean[], void>('spring/index/beans');
         const beans = (params: BeansParams) => {

vscode-extensions/vscode-spring-boot/lib/explorer/explorer-tree-provider.ts

@@ -1,72 +1,36 @@
-import { Event, EventEmitter, ExtensionContext, ProviderResult, TreeDataProvider, TreeItem, TreeItemCollapsibleState, window } from "vscode";
+import { Event, EventEmitter, ExtensionContext, ProviderResult, TreeDataProvider, TreeItem, window } from "vscode";
 import { StructureManager } from "./structure-tree-manager";
-import { SpringNode } from "./nodes";
+import { StereotypedNode } from "./nodes";
 
-export class ExplorerTreeProvider implements TreeDataProvider<SpringNode> {
+export class ExplorerTreeProvider implements TreeDataProvider<StereotypedNode> {
 
-    private emitter: EventEmitter<undefined | SpringNode | SpringNode[]>;
-    public readonly onDidChangeTreeData: Event<undefined | SpringNode | SpringNode[]>;
-    private expansionStates: Map<string, TreeItemCollapsibleState> = new Map();
+    private emitter: EventEmitter<undefined | StereotypedNode | StereotypedNode[]>;
+    public readonly onDidChangeTreeData: Event<undefined | StereotypedNode | StereotypedNode[]>;
 
     constructor(private manager: StructureManager) {
-        this.emitter = new EventEmitter<undefined | SpringNode | SpringNode[]>();
+        this.emitter = new EventEmitter<undefined | StereotypedNode | StereotypedNode[]>();
         this.onDidChangeTreeData = this.emitter.event;
-        this.manager.onDidChange(e => {
-            // Expansion states are tracked via onDidExpandElement/onDidCollapseElement events
-            this.emitter.fire(e);
-        });
+        this.manager.onDidChange(e => this.emitter.fire(e));
     }
 
     createTreeView(context: ExtensionContext, viewId: string) {
-        const treeView = window.createTreeView(viewId, { treeDataProvider: this, showCollapseAll: true });
-            
-        // Track expansion/collapse events to preserve state across refreshes
-        context.subscriptions.push(treeView.onDidExpandElement(e => {
-            const nodeId = e.element.getNodeId();
-            this.setExpansionState(nodeId, TreeItemCollapsibleState.Expanded);
-        }));
-            
-        context.subscriptions.push(treeView.onDidCollapseElement(e => {
-            const nodeId = e.element.getNodeId();
-            this.setExpansionState(nodeId, TreeItemCollapsibleState.Collapsed);
-        }));
-        
+        const treeView = window.createTreeView(viewId, { treeDataProvider: this, showCollapseAll: true });            
         context.subscriptions.push(treeView);
         return treeView
     }
 
-    getTreeItem(element: SpringNode): TreeItem | Thenable<TreeItem> {
-        const nodeId = element.getNodeId();
-        const savedState = this.expansionStates.get(nodeId);
-        return element.getTreeItem(savedState);
+    getTreeItem(element: StereotypedNode): TreeItem | Thenable<TreeItem> {
+        return element.getTreeItem();
     }
 
-    getChildren(element?: SpringNode): ProviderResult<SpringNode[]> {
+    getChildren(element?: StereotypedNode): ProviderResult<StereotypedNode[]> {
         if (element) {
             return element.children;
         }
         return this.getRootElements();
     }
 
-    getRootElements(): ProviderResult<SpringNode[]> {
+    getRootElements(): ProviderResult<StereotypedNode[]> {
         return this.manager.rootElements;
     }
-
-
-    private getExpansionState(nodeId: string): TreeItemCollapsibleState | undefined {
-        return this.expansionStates.get(nodeId);
-    }
-
-    private setExpansionState(nodeId: string, state: TreeItemCollapsibleState): void {
-        this.expansionStates.set(nodeId, state);
-    }
-
-    // getParent?(element: SpringNode): ProviderResult<SpringNode> {
-    //     throw new Error("Method not implemented.");
-    // }
-
-    // resolveTreeItem?(item: TreeItem, element: SpringNode, token: CancellationToken): ProviderResult<TreeItem> {
-    //     throw new Error("Method not implemented.");
-    // }
-
 }

vscode-extensions/vscode-spring-boot/lib/explorer/nodes.ts

@@ -1,60 +1,26 @@
 import { TextDocumentShowOptions, ThemeIcon, TreeItem, TreeItemCollapsibleState, Uri } from "vscode";
 import { Location } from "vscode-languageclient";
 import { LsStereoTypedNode } from "./structure-tree-manager";
+import * as ls from 'vscode-languageserver-protocol';
 
-export class SpringNode {
-    constructor(public children: SpringNode[], protected parent?: SpringNode) {}
-    
-    getTreeItem(savedState?: TreeItemCollapsibleState): TreeItem {
-        const defaultState = savedState !== undefined ? savedState : TreeItemCollapsibleState.Collapsed;
-        return new TreeItem("<node>", this.computeState(defaultState));
-    }
-    
-    computeState(defaultState: TreeItemCollapsibleState): TreeItemCollapsibleState {
-        return Array.isArray(this.children) && this.children.length ? defaultState : TreeItemCollapsibleState.None;
-    }
-    
-    getNodeId(): string {
-        return "<base-node>";
-    }
-    
-    protected getParentPath(): string {
-        if (!this.parent) {
-            return "";
-        }
-        
-        const parentText = this.parent.getNodeText();
-        // Recursively get the full path of all ancestors up to the root
-        const ancestorPath = this.parent.getParentPath();
-        
-        return ancestorPath ? `${ancestorPath}/${parentText}` : parentText;
-    }
-    
-    protected getNodeText(): string {
-        return "<node>";
-    }
-}
-
-export class StereotypedNode extends SpringNode {
-    constructor(private n: LsStereoTypedNode, children: SpringNode[], parent?: SpringNode) {
-        super(children, parent);
-    }
+export class StereotypedNode {
+    constructor(private n: LsStereoTypedNode, public children: StereotypedNode[], protected parent?: StereotypedNode) {}
 
     getTreeItem(savedState?: TreeItemCollapsibleState): TreeItem {
-        const item = super.getTreeItem(savedState);
-        item.label = this.n.attributes.text;
-        item.iconPath = this.computeIcon();
+        const defaultState = savedState !== undefined ? savedState : TreeItemCollapsibleState.Collapsed;
+        const item = new TreeItem(this.label, Array.isArray(this.children) && this.children.length ? defaultState : TreeItemCollapsibleState.None);
+        item.iconPath = new ThemeIcon(this.n.attributes.icon);
+        item.id = this.nodeId;
 
         // Add context value if reference attribute exists
         if (this.n.attributes.reference) {
             item.contextValue = "stereotypedNodeWithReference";
         }
 
-        if (this.n.attributes.icon === 'project') {
+        if (this.projectId) {
             item.contextValue = "project";
         }
 
-        
         if (this.n.attributes.location) {
             const location = this.n.attributes.location as Location;
             item.command = {
@@ -68,24 +34,20 @@ export class StereotypedNode extends SpringNode {
         return item;
     }
 
-    getProjectId(): string {
-        return this.n.attributes.projectId || this.n.attributes.text;
+    get projectId(): string {
+        return this.n.attributes.projectId;
     }
 
-    getNodeId(): string {
+    get nodeId(): string {
         return this.n.attributes.nodeId || this.n.attributes.text;
     }
 
-    protected getNodeText(): string {
+    get label(): string {
         return this.n.attributes.text || '';
     }
 
-    getReferenceValue(): any {
-        return this.n.attributes.reference;
-    }
-
-    computeIcon() {
-        return new ThemeIcon(this.n.attributes.icon);
+    get referenceValue(): ls.Location | undefined {
+        return this.n.attributes.reference as ls.Location;
     }
 
 }

vscode-extensions/vscode-spring-boot/lib/explorer/structure-tree-manager.ts

@@ -1,30 +1,35 @@
-import { commands, EventEmitter, Event, ExtensionContext, window, Memento, Uri, QuickPickItem } from "vscode";
-import { SpringNode, StereotypedNode } from "./nodes";
+import { commands, EventEmitter, Event, ExtensionContext, window, Memento, QuickPickItem } from "vscode";
+import { StereotypedNode } from "./nodes";
 import { ExtensionAPI } from "../api";
-import * as ls from 'vscode-languageserver-protocol';
-
 
 const SPRING_STRUCTURE_CMD = "sts/spring-boot/structure";
 
+interface StructureCommandParams {
+    updateMetadata: boolean;
+    groups?: Record<string, string[]>;
+    affectedProjects?: string[];
+}
+
 export class StructureManager {
 
-    private _rootElements: Thenable<SpringNode[]>
-    private _onDidChange: EventEmitter<SpringNode | undefined> = new EventEmitter<SpringNode | undefined>();
+    private _rootElementsRequest: Thenable<StereotypedNode[]>
+    private _rootElements: StereotypedNode[] = [];
+    private _onDidChange = new EventEmitter<undefined | StereotypedNode | StereotypedNode[]>();
     private workspaceState: Memento;
 
     constructor(context: ExtensionContext, api: ExtensionAPI) {
         this.workspaceState = context.workspaceState;
         context.subscriptions.push(commands.registerCommand("vscode-spring-boot.structure.refresh", () => this.refresh(true)));
-        context.subscriptions.push(commands.registerCommand("vscode-spring-boot.structure.openReference", (node) => {
-            const reference = node?.getReferenceValue() as ls.Location;;
+        context.subscriptions.push(commands.registerCommand("vscode-spring-boot.structure.openReference", (node: StereotypedNode) => {
+            const reference = node?.referenceValue;
             if (reference) {
                 const location = api.client.protocol2CodeConverter.asLocation(reference)
                 window.showTextDocument(location.uri, { selection: location.range });
             }
         }));
 
         context.subscriptions.push(commands.registerCommand("vscode-spring-boot.structure.grouping", async (node: StereotypedNode) => {
-            const projectName = node.getProjectId();
+            const projectName = node.projectId;
             const groups = await commands.executeCommand<Groups>("sts/spring-boot/structure/groups", projectName);
             const initialGroups: string[] | undefined = this.getVisibleGroups(projectName);
             const items = (groups?.groups || []).map(g => ({
@@ -45,38 +50,81 @@ export class StructureManager {
             }
         }));
 
-        context.subscriptions.push(api.getSpringIndex().onSpringIndexUpdated(e => this.refresh(false)));
+        context.subscriptions.push(api.getSpringIndex().onSpringIndexUpdated(indexUpdateDetails => this.refresh(false, indexUpdateDetails.affectedProjects)));
 
     }
 
-    get rootElements(): Thenable<SpringNode[]> {
-        return this._rootElements;
+    get rootElements(): Thenable<StereotypedNode[]> {
+        return this._rootElementsRequest;
     }
 
-    refresh(updateMetadata: boolean): void {
-        this._rootElements = commands.executeCommand(SPRING_STRUCTURE_CMD,
-                {
-                    "updateMetadata" : updateMetadata,
-                    "groups" : this.getGroupings()
-                }).then(json => {
+    // Serves 2 purposes: non UI trigerred refresh as a result of the index update and a UI trigerred refresh
+    // The UI trigerred refresh needs to preceed with an event fired such that tree view would kick off a new promise getting all new root elements and would show progress while promise is being resolved.
+    // The index update typically would have a list of projects for which index has changed then the refresh can be silent with letting the tree know about new data once it is computed
+    // If the index update event doesn't have a list of project then this is an edge case for which we'd show the preogress and treat it like UI trigerred refresh
+    refresh(updateMetadata: boolean, affectedProjects?: string[]): void {
+        const isPartialLoad = !!(affectedProjects && affectedProjects.length);
+        // Notify the tree to get the children to trigger "loading" bar in the view???
+        const params = {
+            updateMetadata,
+            affectedProjects,
+            groups: this.getGroupings(),
+        } as StructureCommandParams;
+        this._rootElementsRequest = commands.executeCommand(SPRING_STRUCTURE_CMD, params).then(json => {
             const nodes = this.parseArray(json);
-            this._onDidChange.fire(undefined);
-            return nodes;
+            if (isPartialLoad) {
+                const newNodes = [] as StereotypedNode[];
+                const nodesMap = {} as Record<string, StereotypedNode>;
+                affectedProjects.forEach(projectName => nodesMap[projectName] = nodes.find(n => n.projectId === projectName));
+                // merge old and newly fetched stereotype root nodes
+                let onlyMutations = true;
+                this._rootElements.forEach(n => {
+                    if (nodesMap.hasOwnProperty(n.projectId)) {
+                        const newN = nodesMap[n.projectId];
+                        delete nodesMap[n.projectId];
+                        if (newN) {
+                            newNodes.push(newN);
+                        } else {
+                            // element removed
+                            onlyMutations = false;
+                        }
+                    } else {
+                        newNodes.push(n);
+                    }
+                });
+                if (Object.values(nodesMap).length) {
+                    // elements added
+                    onlyMutations = false;
+                    Object.values(nodesMap).filter(n => !!n).forEach(n => newNodes.push(n));                       
+                }
+                this._rootElements = newNodes;
+                // TODO: Partial tree refresh didn't wowrk for restbucks it remains either without children or without the full text label
+                // (test with `spring-restbucks` project in a workspace with other boot projects, i.e. demo, spring-petclinic)
+                this._onDidChange.fire(/*onlyMutations ? nodes : */undefined);
+            } else {
+                this._rootElements = nodes;
+                // No need to fire another event to update the UI since there is an event fired before referesh is trigerred to reference the new promise
+            }
+            return this._rootElements;
         });
+        if (!isPartialLoad) {
+            // Fire an event for full reload to have a progress bar while the promise above is resolved
+            this._onDidChange.fire(undefined);
+        } 
     }
 
-    private parseNode(json: any, parent?: SpringNode): SpringNode | undefined {
+    private parseNode(json: any, parent?: StereotypedNode): StereotypedNode | undefined {
         const node = new StereotypedNode(json as LsStereoTypedNode, [], parent);
         // Parse children after creating the node so we can pass it as parent
         node.children.push(...this.parseArray(json.children, node));
         return node;
     }
 
-    private parseArray(json: any, parent?: SpringNode): SpringNode[] {
+    private parseArray(json: any, parent?: StereotypedNode): StereotypedNode[] {
         return Array.isArray(json) ? (json as []).map(j => this.parseNode(j, parent)).filter(e => !!e) : [];
     }
 
-    public get onDidChange(): Event<SpringNode | undefined> {
+    public get onDidChange(): Event<undefined | StereotypedNode | StereotypedNode[]> {
         return this._onDidChange.event;
     }