Add hierarchical package view, for issue #57

Flanker32 · Flanker32 · commit 95bf714147d9 · 2018-11-30T16:49:38.000+08:00
diff --git a/package.json b/package.json
@@ -62,6 +62,11 @@
           "type": "boolean",
           "description": "Synchronize dependency viewer selection with folder explorer",
           "default": true
+        },
+        "java.dependency.isHierarchicalView": {
+          "type": "boolean",
+          "description": "Switch whether package shows in hierarchical view",
+          "default": false
         }
       }
     },
diff --git a/src/settings.ts b/src/settings.ts
@@ -28,5 +28,9 @@ export class Settings {
         return this._depdendencyConfig.get("syncWithFolderExplorer");
     }
 
+    public static isHierarchicalView(): boolean {
+        return this._depdendencyConfig.get("isHierarchicalView");
+    }
+
     private static _depdendencyConfig: WorkspaceConfiguration = workspace.getConfiguration("java.dependency");
 }
diff --git a/src/views/dependencyExplorer.ts b/src/views/dependencyExplorer.ts
@@ -9,6 +9,7 @@ import { Utility } from "../utility";
 import { DataNode } from "./dataNode";
 import { DependencyDataProvider } from "./dependencyDataProvider";
 import { ExplorerNode } from "./explorerNode";
+import { PackageRootNode } from "./packageRootNode";
 
 export class DependencyExplorer {
 
@@ -49,7 +50,6 @@ export class DependencyExplorer {
         if (!current) {
             return;
         }
-
         const res = current.getChildren();
         if (Utility.isThenable(res)) {
             res.then((children: DataNode[]) => {
@@ -71,8 +71,23 @@ export class DependencyExplorer {
                             this._selectionWhenHidden = c;
                         }
                     } else {
-                        paths.shift();
-                        this.revealPath(c, paths);
+                        // Resove Hierarchical packages
+                        const node = paths.shift();
+                        if (Settings.isHierarchicalView() && c instanceof PackageRootNode) {
+                            const packageNode = paths.shift();
+                            const res = c.getChildren();
+                            if (Utility.isThenable(res)) {
+                                res.then(() => {
+                                    const correspondPackageNode = c.getPackageNodeFromNodeData(packageNode);
+                                    this.revealPath(correspondPackageNode, paths);
+                                });
+                            } else {
+                                const correspondPackageNode = c.getPackageNodeFromNodeData(packageNode);
+                                this.revealPath(correspondPackageNode, paths);
+                            }
+                        } else {
+                            this.revealPath(c, paths);
+                        }
                     }
                     break;
                 }
diff --git a/src/views/packageRootNode.ts b/src/views/packageRootNode.ts
@@ -4,6 +4,8 @@
 import { Jdtls } from "../java/jdtls";
 import { INodeData, NodeKind } from "../java/nodeData";
 import { IPackageRootNodeData, PackageRootKind } from "../java/packageRootNodeData";
+import { Settings } from "../settings";
+import { Utility } from "../utility";
 import { DataNode } from "./dataNode";
 import { ExplorerNode } from "./explorerNode";
 import { FileNode } from "./fileNode";
@@ -14,15 +16,45 @@ import { TypeRootNode } from "./typeRootNode";
 
 export class PackageRootNode extends DataNode {
 
-    constructor(nodeData: INodeData, parent: DataNode, private _project: ProjectNode) {
+    private packageTree: PackageTreeNode;
+
+    constructor(nodeData: INodeData, parent: DataNode, private _project: ProjectNode, packageTree: PackageTreeNode = null) {
         super(nodeData, parent);
+        this.packageTree = packageTree;
+    }
+
+    // Get correspond packageRootNode when revealPath
+    public getPackageNodeFromNodeData(classPackage: INodeData): PackageRootNode {
+        // tslint:disable-next-line:no-this-assignment
+        let packageRootNode: PackageRootNode = this;
+        while (packageRootNode.packageTree === null || packageRootNode.packageTree.fullName !== classPackage.name) {
+            let noMatchPackage: boolean = true;
+            packageRootNode.createChildNodeList().forEach((child) => {
+                if (child instanceof PackageRootNode && classPackage.name.startsWith(child.packageTree.fullName)) {
+                    packageRootNode = child;
+                    noMatchPackage = false;
+                }
+            });
+            if (noMatchPackage) {
+                return null;
+            }
+        }
+        return packageRootNode;
     }
 
     protected loadData(): Thenable<INodeData[]> {
-        return Jdtls.getPackageData({ kind: NodeKind.PackageRoot, projectUri: this._project.nodeData.uri, rootPath: this.nodeData.path });
+        if (this.packageTree && this.packageTree.isPackage) {
+            // load package data
+            return Jdtls.getPackageData({
+                kind: NodeKind.Package, projectUri: this._project.nodeData.uri, path: this.packageTree.fullName, rootPath: this.nodeData.path,
+            });
+        } else {
+            return Jdtls.getPackageData({ kind: NodeKind.PackageRoot, projectUri: this._project.nodeData.uri, rootPath: this.nodeData.path });
+        }
+
     }
 
-    protected createChildNodeList(): ExplorerNode[] {
+    protected createFlatChildNodeList(): ExplorerNode[] {
         const result = [];
         if (this.nodeData.children && this.nodeData.children.length) {
             this.sort();
@@ -41,7 +73,67 @@ export class PackageRootNode extends DataNode {
         return result;
     }
 
+    protected createHierarchicalChildNodeList(): ExplorerNode[] {
+        const result = [];
+        if (this.nodeData.children && this.nodeData.children.length) {
+            this.nodeData.children.forEach((data) => {
+                if (data.kind === NodeKind.File) {
+                    result.push(new FileNode(data, this));
+                } else if (data.kind === NodeKind.Folder) {
+                    result.push(new FolderNode(data, this, this._project, this));
+                } else if (data.kind === NodeKind.TypeRoot) {
+                    result.push(new TypeRootNode(data, this));
+                }
+            });
+        }
+        this.getHierarchicalPackageNodes().forEach((node) => result.push(node));
+        result.sort();
+        return result;
+    }
+
+    protected createChildNodeList(): ExplorerNode[] {
+        if (Settings.isHierarchicalView()) {
+            return this.createHierarchicalChildNodeList();
+        } else {
+            return this.createFlatChildNodeList();
+        }
+    }
+
+    protected getHierarchicalPackageNodes(): ExplorerNode[] {
+        const result = [];
+        const packageTree = this.packageTree ? this.packageTree : this.getPackageTree();
+        packageTree.childs.forEach((childNode) => {
+            const childNodeData: INodeData = {
+                name: childNode.name,
+                moduleName: this.nodeData.moduleName,
+                path: this.nodeData.path,
+                uri: null,
+                kind: NodeKind.PackageRoot,
+                children: null,
+            };
+            result.push(new PackageRootNode(childNodeData, this, this._project, childNode));
+        });
+        return result;
+    }
+
+    // Generage tree for packages, use for Hierarchical view
+    protected getPackageTree(): PackageTreeNode {
+        const result: PackageTreeNode = new PackageTreeNode("", "");
+        if (this.nodeData.children && this.nodeData.children.length) {
+            this.nodeData.children.forEach((child) => {
+                if (child.kind === NodeKind.Package) {
+                    result.addPackage(child.name);
+                }
+            });
+        }
+        result.compressTree();
+        return result;
+    }
+
     protected get iconPath(): { light: string; dark: string } {
+        if (this.packageTree !== null) {
+            return ExplorerNode.resolveIconPath("package");
+        }
         const data = <IPackageRootNodeData>this.nodeData;
         if (data.entryKind === PackageRootKind.K_BINARY) {
             return ExplorerNode.resolveIconPath("jar");
@@ -50,3 +142,54 @@ export class PackageRootNode extends DataNode {
         }
     }
 }
+
+class PackageTreeNode {
+    public name: string;
+    public fullName: string;
+    public childs: PackageTreeNode[] = [];
+    public isPackage: boolean = false;
+
+    constructor(packageName: string, parentName: string) {
+        const splitPackageName = packageName.split(".");
+        this.name = splitPackageName[0];
+        this.fullName = parentName === "" ? this.name : parentName + "." + this.name;
+        if (splitPackageName.length > 1) {
+            this.childs.push(new PackageTreeNode(packageName.substring(this.name.length + 1), this.fullName));
+        } else {
+            this.isPackage = true;
+        }
+    }
+
+    public addPackage(packageName: string): void {
+        const splitPackageName = packageName.split(".");
+        const firstSubName = splitPackageName[0];
+        const restname = packageName.substring(firstSubName.length + 1);
+
+        let contains: boolean = false;
+        this.childs.forEach((child) => {
+            if (child.name === firstSubName) {
+                if (restname === "") {
+                    child.isPackage = true;
+                } else {
+                    child.addPackage(restname);
+                }
+                contains = true;
+            }
+        });
+        if (!contains) {
+            this.childs.push(new PackageTreeNode(packageName, this.fullName));
+        }
+    }
+
+    public compressTree(): void {
+        // Don't compress the root node
+        while (this.name !== "" && this.childs.length === 1 && !this.isPackage) {
+            const child = this.childs[0];
+            this.fullName = this.fullName + "." + child.name;
+            this.name = this.name + "." + child.name;
+            this.childs = child.childs;
+            this.isPackage = child.isPackage;
+        }
+        this.childs.forEach((child) => child.compressTree());
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,11 @@`
`62`	`62`	`"type": "boolean",`
`63`	`63`	`"description": "Synchronize dependency viewer selection with folder explorer",`
`64`	`64`	`"default": true`
	`65`	`+ },`
	`66`	`+ "java.dependency.isHierarchicalView": {`
	`67`	`+ "type": "boolean",`
	`68`	`+ "description": "Switch whether package shows in hierarchical view",`
	`69`	`+ "default": false`
`65`	`70`	`}`
`66`	`71`	`}`
`67`	`72`	`},`
Original file line number	Diff line number	Diff line change
`@@ -28,5 +28,9 @@ export class Settings {`
`28`	`28`	`return this._depdendencyConfig.get("syncWithFolderExplorer");`
`29`	`29`	`}`
`30`	`30`
	`31`	`+ public static isHierarchicalView(): boolean {`
	`32`	`+ return this._depdendencyConfig.get("isHierarchicalView");`
	`33`	`+ }`
	`34`	`+`
`31`	`35`	`private static _depdendencyConfig: WorkspaceConfiguration = workspace.getConfiguration("java.dependency");`
`32`	`36`	`}`