Add hierarchical package view, for issue #57

package.json

@@ -62,6 +62,12 @@
           "type": "boolean",
           "description": "Synchronize dependency viewer selection with folder explorer",
           "default": true
+        },
+        "java.dependency.packagePresentation": {
+          "type": "string",
+          "enum":["flat","hierarchical"],
+          "description": "Set the presentation model of packages",
+          "default": "flat"
         }
       }
     },

src/java/packageTreeNode.ts

@@ -0,0 +1,66 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import { INodeData, NodeKind } from "./nodeData";
+
+export 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());
+    }
+
+    public getNodeDataFromPackageTreeNode(nodeData: INodeData): INodeData {
+        return {
+            name: this.name,
+            moduleName: nodeData.moduleName,
+            path: nodeData.path,
+            uri: null,
+            kind: NodeKind.PackageRoot,
+            children: null,
+        };
+    }
+}

src/settings.ts

@@ -28,5 +28,9 @@ export class Settings {
         return this._depdendencyConfig.get("syncWithFolderExplorer");
     }
 
+    public static isHierarchicalView(): boolean {
+        return this._depdendencyConfig.get("packagePresentation") === "hierarchical";
+    }
+
     private static _depdendencyConfig: WorkspaceConfiguration = workspace.getConfiguration("java.dependency");
 }

src/views/containerNode.ts

@@ -5,7 +5,7 @@ import { Jdtls } from "../java/jdtls";
 import { INodeData, NodeKind } from "../java/nodeData";
 import { DataNode } from "./dataNode";
 import { ExplorerNode } from "./explorerNode";
-import { PackageRootNode } from "./packageRootNode";
+import { NodeFactory } from "./nodeFactory";
 import { ProjectNode } from "./projectNode";
 
 export class ContainerNode extends DataNode {
@@ -21,7 +21,7 @@ export class ContainerNode extends DataNode {
         if (this.nodeData.children && this.nodeData.children.length) {
             this.sort();
             this.nodeData.children.forEach((classpathNode) => {
-                result.push(new PackageRootNode(classpathNode, this, this._project));
+                result.push(NodeFactory.createPackageRootNode(classpathNode, this, this._project));
             });
         }
         return result;

src/views/dependencyExplorer.ts

@@ -2,13 +2,13 @@
 // Licensed under the MIT license.
 
 import { ExtensionContext, ProviderResult, TextEditor, TreeView, TreeViewVisibilityChangeEvent, Uri, window } from "vscode";
-import { Jdtls } from "../java/jdtls";
 import { INodeData } from "../java/nodeData";
 import { Settings } from "../settings";
 import { Utility } from "../utility";
 import { DataNode } from "./dataNode";
 import { DependencyDataProvider } from "./dependencyDataProvider";
 import { ExplorerNode } from "./explorerNode";
+import { PathProcesser } from "./pathProcesser";
 
 export class DependencyExplorer {
 
@@ -40,16 +40,13 @@ export class DependencyExplorer {
     }
 
     public reveal(uri: Uri): void {
-        Jdtls.resolvePath(uri.toString()).then((paths: INodeData[]) => {
-            this.revealPath(this._dataProvider, paths);
-        });
+        PathProcesser.resolvePath(uri).then((paths: INodeData[]) => this.revealPath(this._dataProvider, paths));
     }
 
     private revealPath(current: { getChildren: (element?: ExplorerNode) => ProviderResult<ExplorerNode[]> }, paths: INodeData[]) {
         if (!current) {
             return;
         }
-
         const res = current.getChildren();
         if (Utility.isThenable(res)) {
             res.then((children: DataNode[]) => {

src/views/hierachicalPackageRootNode.ts

@@ -0,0 +1,97 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import { INodeData, NodeKind } from "../java/nodeData";
+import { PackageTreeNode } from "../java/packageTreeNode";
+import { Settings } from "../settings";
+import { DataNode } from "./dataNode";
+import { ExplorerNode } from "./explorerNode";
+import { FileNode } from "./fileNode";
+import { FolderNode } from "./folderNode";
+import { HierachicalPackageRootSubNode } from "./hierachicalPackageRootSubNode";
+import { PackageRootNode } from "./packageRootNode";
+import { ProjectNode } from "./projectNode";
+import { TypeRootNode } from "./typeRootNode";
+
+export class HierachicalPackageRootNode extends PackageRootNode {
+
+    public static async convertPaths(paths: INodeData[]): Promise<INodeData[]> {
+        const index = paths.findIndex((nodeData) => nodeData.kind === NodeKind.PackageRoot);
+        const projectNodeData = paths.find((nodeData) => nodeData.kind === NodeKind.Project);
+        const packageRootNodeData = paths[index];
+        const packageNodeData = paths[index + 1];
+        const packageRootNode = new HierachicalPackageRootNode(packageRootNodeData, null, new ProjectNode(projectNodeData, null));
+
+        const correspondDataNodes: INodeData[] = [];
+        let correspondNode = await packageRootNode.revealPath(packageNodeData);
+        while (correspondNode instanceof HierachicalPackageRootSubNode) {
+            correspondDataNodes.push({
+                name: correspondNode.nodeData.name,
+                moduleName: null,
+                path: correspondNode.nodeData.path,
+                uri: null,
+                kind: NodeKind.PackageRoot,
+                children: null,
+            });
+            correspondNode = correspondNode.getParent();
+        }
+        const result = paths.slice(null, index + 1).concat(correspondDataNodes.reverse(), paths.slice(index + 2));
+        return result;
+    }
+
+    constructor(nodeData: INodeData, parent: DataNode, _project: ProjectNode) {
+        super(nodeData, parent, _project);
+    }
+
+    public async revealPath(packageNodeData: INodeData): Promise<ExplorerNode> {
+        await this.getChildren();
+        let packageTreeNode: PackageTreeNode = this.getPackageTree();
+        let result: DataNode = null;
+        while (packageTreeNode && packageTreeNode.fullName !== packageNodeData.name) {
+            packageTreeNode = packageTreeNode.childs.find((child) => packageNodeData.name.startsWith(child.fullName));
+            result = packageTreeNode ? new HierachicalPackageRootSubNode(packageTreeNode.getNodeDataFromPackageTreeNode(this.nodeData),
+                result, this._project, packageTreeNode) : null;
+        }
+        return result;
+    }
+
+    protected createChildNodeList(): ExplorerNode[] {
+        const result = [];
+        if (this.nodeData.children && this.nodeData.children.length) {
+            this.sort();
+            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));
+                }
+            });
+        }
+        const packageNodeList = this.getHierarchicalPackageNodes();
+        return packageNodeList.concat(result);
+    }
+
+    protected getHierarchicalPackageNodes(): ExplorerNode[] {
+        const result = [];
+        const packageTree = this.getPackageTree();
+        packageTree.childs.forEach((childNode) => {
+            result.push(new HierachicalPackageRootSubNode(childNode.getNodeDataFromPackageTreeNode(this.nodeData), this, this._project, childNode));
+        });
+        return result;
+    }
+
+    private 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;
+    }
+}

src/views/hierachicalPackageRootSubNode.ts

@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import { Jdtls } from "../java/jdtls";
+import { INodeData, NodeKind } from "../java/nodeData";
+import { PackageTreeNode } from "../java/packageTreeNode";
+import { DataNode } from "./dataNode";
+import { ExplorerNode } from "./explorerNode";
+import { FileNode } from "./fileNode";
+import { FolderNode } from "./folderNode";
+import { ProjectNode } from "./projectNode";
+import { TypeRootNode } from "./typeRootNode";
+
+export class HierachicalPackageRootSubNode extends DataNode {
+
+    public packageTree: PackageTreeNode;
+
+    constructor(nodeData: INodeData, parent: DataNode, private _project: ProjectNode, packageTree: PackageTreeNode = null) {
+        super(nodeData, parent);
+        this.packageTree = packageTree;
+    }
+
+    protected loadData(): Thenable<any[]> {
+        return Jdtls.getPackageData({
+            kind: NodeKind.Package, projectUri: this._project.nodeData.uri, path: this.packageTree.fullName, rootPath: this.nodeData.path,
+        });
+    }
+
+    protected get iconPath(): { light: string; dark: string } {
+        return ExplorerNode.resolveIconPath("package");
+    }
+
+    protected createChildNodeList(): ExplorerNode[] {
+        const result = [];
+        if (this.nodeData.children && this.nodeData.children.length) {
+            this.sort();
+            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));
+                }
+            });
+        }
+        const packageNodeList = this.getHierarchicalPackageNodes();
+        return packageNodeList.concat(result);
+    }
+
+    protected getHierarchicalPackageNodes(): ExplorerNode[] {
+        const result = [];
+        this.packageTree.childs.forEach((childNode) => {
+            result.push(new HierachicalPackageRootSubNode(childNode.getNodeDataFromPackageTreeNode(this.nodeData), this, this._project, childNode));
+        });
+        return result;
+    }
+}