refactor: Use factory pattern to create explorer nodes

jdtls.ext/com.microsoft.jdtls.ext.core/src/com/microsoft/jdtls/ext/core/PackageCommand.java

@@ -367,17 +367,20 @@ private static IPackageFragmentRoot getPackageFragmentRootFromQuery(PackageParam
             return packageRoot;
         }
 
-        // jar in Referenced Libraries must be constructed from path
-        IJavaProject javaProject = getJavaProject(query.getProjectUri());
-        if (javaProject != null) {
-            try {
-                packageRoot = javaProject.findPackageFragmentRoot(Path.fromPortableString(query.getRootPath()));
-            } catch (JavaModelException e) {
-                return null;
+        if (query.getProjectUri() != null && query.getRootPath() != null) {
+            // jar in Referenced Libraries must be constructed from path
+            IJavaProject javaProject = getJavaProject(query.getProjectUri());
+            if (javaProject != null) {
+                try {
+                    return javaProject.findPackageFragmentRoot(Path.fromPortableString(query.getRootPath()));
+                } catch (JavaModelException e) {
+                    JdtlsExtActivator.log(e);
+                    return null;
+                }
             }
         }
 
-        return packageRoot;
+        return null;
     }
 
     private static List<PackageNode> getRootTypes(PackageParams query, IProgressMonitor pm) {
@@ -421,41 +424,47 @@ public static List<Object> getChildrenForPackage(IPackageFragment packageFragmen
     }
 
     private static List<PackageNode> getFolderChildren(PackageParams query, IProgressMonitor pm) {
+        List<Object> children = new LinkedList<>();
+        IJavaProject javaProject = null;
         try {
             IPackageFragmentRoot packageRoot = getPackageFragmentRootFromQuery(query);
-            if (packageRoot == null) {
-                throw new CoreException(
-                        new Status(IStatus.ERROR, JdtlsExtActivator.PLUGIN_ID, String.format("No package root found for %s", query.getPath())));
-            }
-            List<Object> children = new LinkedList<>();
-            if (packageRoot.getKind() == IPackageFragmentRoot.K_BINARY) {
-                Object[] resources = packageRoot.getNonJavaResources();
-                for (Object resource : resources) {
-                    if (pm.isCanceled()) {
-                        throw new OperationCanceledException();
-                    }
-                    if (resource instanceof JarEntryDirectory) {
-                        JarEntryDirectory directory = (JarEntryDirectory) resource;
-                        Object[] directoryChildren = findJarDirectoryChildren(directory, query.getPath());
-                        if (children != null) {
-                            children.addAll(Arrays.asList(directoryChildren));
+            if (packageRoot != null) {
+                if (packageRoot.getKind() == IPackageFragmentRoot.K_BINARY) {
+                    Object[] resources = packageRoot.getNonJavaResources();
+                    for (Object resource : resources) {
+                        if (pm.isCanceled()) {
+                            throw new OperationCanceledException();
+                        }
+                        if (resource instanceof JarEntryDirectory) {
+                            JarEntryDirectory directory = (JarEntryDirectory) resource;
+                            Object[] directoryChildren = findJarDirectoryChildren(directory, query.getPath());
+                            if (children != null) {
+                                children.addAll(Arrays.asList(directoryChildren));
+                            }
                         }
                     }
+                } else {
+                    javaProject = packageRoot.getJavaProject();
+                    IFolder folder = ResourcesPlugin.getWorkspace().getRoot().getFolder(Path.fromPortableString(query.getPath()));
+                    if (folder.exists()) {
+                        boolean isJavaElement = JavaCore.create(folder) != null;
+                        children.addAll(Arrays.stream(folder.members())
+                            .filter(f -> isJavaElement ? f instanceof IFile : true)
+                            .collect(Collectors.toList())
+                        );
+                    }
                 }
             } else {
-                IJavaProject javaProject = packageRoot.getJavaProject();
-                IFolder folder = javaProject.getProject().getFolder(new Path(query.getPath()).makeRelativeTo(javaProject.getProject().getFullPath()));
-                if (folder != null && folder.exists()) {
-                    boolean isJavaElement = JavaCore.create(folder) != null;
-                    children.addAll(Arrays.stream(folder.members())
-                        .filter(f -> isJavaElement ? f instanceof IFile : true)
-                        .collect(Collectors.toList())
-                    );
+                // general resource folder.
+                IFolder folder = ResourcesPlugin.getWorkspace().getRoot().getFolder(Path.fromPortableString(query.getPath()));
+                if (folder.exists()) {
+                    children.addAll(Arrays.asList(folder.members()));
+                    javaProject = JavaCore.create(folder.getProject());
                 }
             }
 
             ResourceSet resourceSet = new ResourceSet(children);
-            ResourceVisitor visitor = new JavaResourceVisitor(packageRoot.getJavaProject());
+            ResourceVisitor visitor = new JavaResourceVisitor(javaProject);
             resourceSet.accept(visitor);
             return visitor.getNodes();
 

jdtls.ext/com.microsoft.jdtls.ext.core/src/com/microsoft/jdtls/ext/core/model/NodeKind.java

@@ -16,13 +16,13 @@ public enum NodeKind {
 
     PROJECT(2),
 
-    CONTAINER(3),
+    PACKAGEROOT(3),
 
-    PACKAGEROOT(4),
+    PACKAGE(4),
 
-    PACKAGE(5),
+    PRIMARYTYPE(5),
 
-    PRIMARYTYPE(6),
+    CONTAINER(6),
 
     FOLDER(7),
 

package.json

@@ -792,7 +792,7 @@
     ]
   },
   "scripts": {
-    "compile": "tsc -p . && webpack --config webpack.config.js",
+    "compile": "tsc -p . && webpack --config webpack.config.js --mode development",
     "watch": "webpack --mode development --watch",
     "test": "tsc -p . && node ./dist/test/index.js",
     "test-ui": "tsc -p . && node ./dist/test/ui/index.js",

src/java/nodeData.ts

@@ -4,10 +4,10 @@
 export enum NodeKind {
     Workspace = 1,
     Project = 2,
-    Container = 3,
-    PackageRoot = 4,
-    Package = 5,
-    PrimaryType = 6,
+    PackageRoot = 3,
+    Package = 4,
+    PrimaryType = 5,
+    Container = 6,
     Folder = 7,
     File = 8,
 }

src/views/containerNode.ts

@@ -8,7 +8,6 @@ import { INodeData, NodeKind } from "../java/nodeData";
 import { DataNode } from "./dataNode";
 import { ExplorerNode } from "./explorerNode";
 import { NodeFactory } from "./nodeFactory";
-import { PackageRootNode } from "./packageRootNode";
 import { ProjectNode } from "./projectNode";
 
 export class ContainerNode extends DataNode {
@@ -37,15 +36,15 @@ export class ContainerNode extends DataNode {
     protected async loadData(): Promise<INodeData[]> {
         return Jdtls.getPackageData({ kind: NodeKind.Container, projectUri: this._project.uri, path: this.path });
     }
+
     protected createChildNodeList(): ExplorerNode[] {
-        const result: PackageRootNode[] = [];
+        const result: (ExplorerNode | undefined)[] = [];
         if (this.nodeData.children && this.nodeData.children.length) {
-            this.sort();
-            this.nodeData.children.forEach((classpathNode) => {
-                result.push(NodeFactory.createPackageRootNode(classpathNode, this, this._project));
+            this.nodeData.children.forEach((nodeData) => {
+                result.push(NodeFactory.createNode(nodeData, this, this._project));
             });
         }
-        return result;
+        return result.filter(<T>(n?: T): n is T => Boolean(n));
     }
 
     protected get contextValue(): string {

src/views/dataNode.ts

@@ -77,6 +77,7 @@ export abstract class DataNode extends ExplorerNode {
                 const data = await this.loadData();
                 this._nodeData.children = data;
                 this._childrenNodes = this.createChildNodeList() || [];
+                this.sort();
                 return this._childrenNodes;
             }
             return this._childrenNodes;
@@ -97,12 +98,15 @@ export abstract class DataNode extends ExplorerNode {
     }
 
     protected sort() {
-        this.nodeData.children?.sort((a: INodeData, b: INodeData) => {
-            if (a.kind === b.kind) {
-                return a.name < b.name ? -1 : 1;
-            } else {
-                return a.kind - b.kind;
+        this._childrenNodes.sort((a: ExplorerNode, b: ExplorerNode) => {
+            if (a instanceof DataNode && b instanceof DataNode) {
+                if (a.nodeData.kind === b.nodeData.kind) {
+                    return a.nodeData.name < b.nodeData.name ? -1 : 1;
+                } else {
+                    return a.nodeData.kind - b.nodeData.kind;
+                }
             }
+            return 0;
         });
     }
 

src/views/folderNode.ts

@@ -7,11 +7,11 @@ import { Jdtls } from "../java/jdtls";
 import { INodeData, NodeKind } from "../java/nodeData";
 import { DataNode } from "./dataNode";
 import { ExplorerNode } from "./explorerNode";
-import { FileNode } from "./fileNode";
 import { ProjectNode } from "./projectNode";
+import { NodeFactory } from "./nodeFactory";
 
 export class FolderNode extends DataNode {
-    constructor(nodeData: INodeData, parent: DataNode, private _project: ProjectNode, private _rootNode: DataNode) {
+    constructor(nodeData: INodeData, parent: DataNode, private _project: ProjectNode, private _rootNode?: DataNode) {
         super(nodeData, parent);
     }
 
@@ -20,24 +20,19 @@ export class FolderNode extends DataNode {
             kind: NodeKind.Folder,
             projectUri: this._project.uri,
             path: this.path,
-            rootPath: this._rootNode.path,
-            handlerIdentifier: this._rootNode.handlerIdentifier,
+            rootPath: this._rootNode?.path,
+            handlerIdentifier: this._rootNode?.handlerIdentifier,
         });
     }
 
     protected createChildNodeList(): ExplorerNode[] {
-        const result: ExplorerNode[] = [];
+        const result: (ExplorerNode | undefined)[] = [];
         if (this.nodeData.children && this.nodeData.children.length) {
-            this.sort();
             this.nodeData.children.forEach((nodeData) => {
-                if (nodeData.kind === NodeKind.File) {
-                    result.push(new FileNode(nodeData, this));
-                } else if (nodeData.kind === NodeKind.Folder) {
-                    result.push(new FolderNode(nodeData, this, this._project, this._rootNode));
-                }
+                result.push(NodeFactory.createNode(nodeData, this, this._project, this._rootNode));
             });
         }
-        return result;
+        return result.filter(<T>(n?: T): n is T => Boolean(n));
     }
 
     protected get iconPath(): ThemeIcon {

src/views/hierarchicalPackageNode.ts

@@ -4,15 +4,13 @@
 import * as _ from "lodash";
 import { TreeItem, TreeItemCollapsibleState } from "vscode";
 import { HierarchicalPackageNodeData } from "../java/hierarchicalPackageNodeData";
-import { INodeData, NodeKind } from "../java/nodeData";
+import { INodeData } from "../java/nodeData";
 import { explorerLock } from "../utils/Lock";
 import { DataNode } from "./dataNode";
 import { ExplorerNode } from "./explorerNode";
-import { FileNode } from "./fileNode";
-import { FolderNode } from "./folderNode";
 import { PackageNode } from "./packageNode";
-import { PrimaryTypeNode } from "./PrimaryTypeNode";
 import { ProjectNode } from "./projectNode";
+import { NodeFactory } from "./nodeFactory";
 
 export class HierarchicalPackageNode extends PackageNode {
 
@@ -38,7 +36,9 @@ export class HierarchicalPackageNode extends PackageNode {
                     this.nodeData.children = data;
                 }
             }
-            return this.createChildNodeList();
+            this._childrenNodes = this.createChildNodeList() || [];
+            this.sort();
+            return this._childrenNodes;
         } finally {
             explorerLock.release();
         }
@@ -64,24 +64,13 @@ export class HierarchicalPackageNode extends PackageNode {
     }
 
     protected createChildNodeList(): ExplorerNode[] {
-        const result: ExplorerNode[] = [];
+        const result: (ExplorerNode | undefined)[] = [];
         if (this.nodeData.children && this.nodeData.children.length) {
-            this.sort();
             this.nodeData.children.forEach((nodeData) => {
-                if (nodeData.kind === NodeKind.File) {
-                    result.push(new FileNode(nodeData, this));
-                } else if (nodeData instanceof HierarchicalPackageNodeData) {
-                    result.push(new HierarchicalPackageNode(nodeData, this, this._project, this._rootNode));
-                } else if (nodeData.kind === NodeKind.PrimaryType) {
-                    if (nodeData.metaData && nodeData.metaData[PrimaryTypeNode.K_TYPE_KIND]) {
-                        result.push(new PrimaryTypeNode(nodeData, this, this._rootNode));
-                    }
-                } else if (nodeData.kind === NodeKind.Folder) {
-                    result.push(new FolderNode(nodeData, this, this._project, this._rootNode));
-                }
+                result.push(NodeFactory.createNode(nodeData, this, this._project, this._rootNode));
             });
         }
-        return result;
+        return result.filter(<T>(n?: T): n is T => Boolean(n));
     }
 
     private getHierarchicalNodeData(): HierarchicalPackageNodeData {

src/views/hierarchicalPackageRootNode.ts

@@ -5,11 +5,9 @@ import { HierarchicalPackageNodeData } from "../java/hierarchicalPackageNodeData
 import { INodeData, NodeKind } from "../java/nodeData";
 import { DataNode } from "./dataNode";
 import { ExplorerNode } from "./explorerNode";
-import { FileNode } from "./fileNode";
-import { FolderNode } from "./folderNode";
 import { HierarchicalPackageNode } from "./hierarchicalPackageNode";
+import { NodeFactory } from "./nodeFactory";
 import { PackageRootNode } from "./packageRootNode";
-import { PrimaryTypeNode } from "./PrimaryTypeNode";
 import { ProjectNode } from "./projectNode";
 
 export class HierarchicalPackageRootNode extends PackageRootNode {
@@ -31,36 +29,27 @@ export class HierarchicalPackageRootNode extends PackageRootNode {
     }
 
     protected createChildNodeList(): ExplorerNode[] {
-        const result: ExplorerNode[] = [];
+        const result: (ExplorerNode | undefined)[] = [];
+        const packageData: any[] = [];
         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.PrimaryType) {
-                    if (data.metaData && data.metaData[PrimaryTypeNode.K_TYPE_KIND]) {
-                        result.push(new PrimaryTypeNode(data, this, this));
-                    }
+            this.nodeData.children.forEach((nodeData) => {
+                if (nodeData.kind === NodeKind.Package) {
+                    // Invisible project may have an empty named package root (the linked folder),
+                    // in that case, we will skip it.
+                    packageData.push(nodeData);
+                } else {
+                    result.push(NodeFactory.createNode(nodeData, this, this._project, this));
                 }
             });
         }
-        return result.concat(this.getHierarchicalPackageNodes());
-    }
-
-    protected getHierarchicalPackageNodes(): ExplorerNode[] {
-        const hierarchicalPackageNodeData = this.getHierarchicalPackageNodeData();
-        return hierarchicalPackageNodeData?.children.map((hierarchicalChildrenNode) =>
-            new HierarchicalPackageNode(hierarchicalChildrenNode, this, this._project, this)) || [];
-    }
 
-    private getHierarchicalPackageNodeData(): HierarchicalPackageNodeData  | undefined {
-        if (this.nodeData.children && this.nodeData.children.length) {
-            const nodeDataList = this.nodeData.children
-                .filter((child) => child.kind === NodeKind.Package);
-            return HierarchicalPackageNodeData.createHierarchicalNodeDataByPackageList(nodeDataList);
+        if (packageData.length > 0) {
+            const data: HierarchicalPackageNodeData = HierarchicalPackageNodeData.createHierarchicalNodeDataByPackageList(packageData);
+            if (data) {
+                result.push(...data.children.map(d => NodeFactory.createNode(d, this, this._project, this)));
+            }
         }
-        return undefined;
+
+        return result.filter(<T>(n?: T): n is T => Boolean(n));
     }
 }