Client side Controller support:

* Adding file/folder to referenced libraries
* Removing a jar file from referenced libraries
* Manually trigger refreshing of referenced libraries in classpath

Author: Vigilans

src/commands.ts

@@ -32,8 +32,16 @@ export namespace Commands {
 
     export const JAVA_PROJECT_CREATE = "java.project.create";
 
+    export const JAVA_PROJECT_ADD_LIBRARIES = "java.project.addLibraries";
+
+    export const JAVA_PROJECT_REMOVE_LIBRARY = "java.project.removeLibrary";
+
+    export const JAVA_PROJECT_REFRESH_LIBRARIES = "java.project.refreshLibraries";
+
     export const JAVA_PROJECT_LIST = "java.project.list";
 
+    export const JAVA_PROJECT_REFRESH_LIB_SERVER = "java.project.refreshLib";
+
     export const JAVA_GETPACKAGEDATA = "java.getPackageData";
 
     export const JAVA_RESOLVEPATH = "java.resolvePath";

src/controllers/libraryController.ts

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import * as chokidar from "chokidar";
+import * as fse from "fs-extra";
+import * as _ from "lodash";
+import { commands, Disposable, ExtensionContext, Uri, window, workspace, WorkspaceFolder } from "vscode";
+import { instrumentOperation } from "vscode-extension-telemetry-wrapper";
+import { Commands } from "../commands";
+import { Jdtls } from "../java/jdtls";
+import { Settings } from "../settings";
+import { Utility } from "../utility";
+import { DataNode } from "../views/dataNode";
+
+export class LibraryController implements Disposable {
+
+    private libraryWatcher: chokidar.FSWatcher | undefined = undefined;
+
+    public constructor(public readonly context: ExtensionContext) {
+        context.subscriptions.push(commands.registerCommand(Commands.JAVA_PROJECT_ADD_LIBRARIES,
+            instrumentOperation(Commands.JAVA_PROJECT_ADD_LIBRARIES, (operationId: string, node: DataNode) => this.addLibraries())));
+        context.subscriptions.push(commands.registerCommand(Commands.JAVA_PROJECT_REMOVE_LIBRARY,
+            instrumentOperation(Commands.JAVA_PROJECT_REMOVE_LIBRARY, (operationId: string, node: DataNode) => this.removeLibrary(node.path))));
+        context.subscriptions.push(commands.registerCommand(Commands.JAVA_PROJECT_REFRESH_LIBRARIES,
+            instrumentOperation(Commands.JAVA_PROJECT_REFRESH_LIBRARIES, (operationId: string, node: DataNode) => this.refreshLibraries())));
+    }
+
+    public dispose() {
+        if (this.libraryWatcher) {
+            this.libraryWatcher.close();
+            this.libraryWatcher = undefined;
+        }
+    }
+
+    public async addLibraries(libraryGlobs?: string[]) {
+        if (!libraryGlobs) {
+            libraryGlobs = [];
+            const workspaceFolder: WorkspaceFolder | undefined = Utility.getDefaultWorkspaceFolder();
+            const results: Uri[] | undefined = await window.showOpenDialog({
+                defaultUri: workspaceFolder && workspaceFolder.uri,
+                canSelectFiles: true,
+                canSelectFolders: true,
+                canSelectMany: true,
+                openLabel: "Select",
+            });
+            if (!results) {
+                return;
+            }
+            libraryGlobs = await Promise.all(results.map(async (uri: Uri) => {
+                const uriPath = workspace.asRelativePath(uri, false);
+                return (await fse.stat(uri.fsPath)).isDirectory() ? `${uriPath}/**/*.jar` : uriPath;
+            }));
+        }
+        const setting = Settings.referencedLibraries();
+        if (Settings.isDefaultReferencedLibraries()) {
+            setting.include = [];
+        }
+        setting.include.push(...libraryGlobs);
+        Settings.updateReferencedLibraries(setting);
+    }
+
+    public async removeLibrary(library: string) {
+        const setting = Settings.referencedLibraries();
+        setting.exclude.push(workspace.asRelativePath(library));
+        Settings.updateReferencedLibraries(setting);
+    }
+
+    public async refreshLibraries(): Promise<void> {
+        const workspaceFolder = Utility.getDefaultWorkspaceFolder();
+        if (workspaceFolder) {
+            await Jdtls.refreshLibraries(workspaceFolder.uri.toString());
+        }
+    }
+}

src/controllers/projectController.ts

@@ -4,14 +4,20 @@
 import * as fse from "fs-extra";
 import * as _ from "lodash";
 import * as path from "path";
-import { commands, ExtensionContext, Uri, window, workspace } from "vscode";
+import { commands, Disposable, ExtensionContext, Uri, window, workspace } from "vscode";
+import { instrumentOperation } from "vscode-extension-telemetry-wrapper";
 import * as xml2js from "xml2js";
+import { Commands } from "../commands";
 import { Utility } from "../utility";
 
-export class ProjectController {
-    constructor(public readonly context: ExtensionContext) {
+export class ProjectController implements Disposable {
+    public constructor(public readonly context: ExtensionContext) {
+        context.subscriptions.push(commands.registerCommand(Commands.JAVA_PROJECT_CREATE,
+            instrumentOperation(Commands.JAVA_PROJECT_CREATE, () => this.createJavaProject())));
     }
 
+    public dispose() {}
+
     public async createJavaProject() {
         const javaVersion: number = await this.getJavaVersion();
         if (!javaVersion) {

src/extension.ts

@@ -4,6 +4,7 @@
 import { commands, ExtensionContext } from "vscode";
 import { dispose as disposeTelemetryWrapper, initializeFromJsonFile, instrumentOperation } from "vscode-extension-telemetry-wrapper";
 import { Commands } from "./commands";
+import { LibraryController } from "./controllers/libraryController";
 import { ProjectController } from "./controllers/projectController";
 import { Services } from "./services";
 import { Settings } from "./settings";
@@ -20,10 +21,8 @@ function activateExtension(operationId: string, context: ExtensionContext) {
     Services.initialize(context);
     Settings.initialize(context);
 
-    const projectController: ProjectController = new ProjectController(context);
-    const instrumented = instrumentOperation(Commands.JAVA_PROJECT_CREATE, () => projectController.createJavaProject());
-    context.subscriptions.push(commands.registerCommand(Commands.JAVA_PROJECT_CREATE, instrumented));
-
+    context.subscriptions.push(new ProjectController(context));
+    context.subscriptions.push(new LibraryController(context));
     context.subscriptions.push(new DependencyExplorer(context));
 }
 

src/java/jdtls.ts

@@ -10,6 +10,10 @@ export namespace Jdtls {
         return commands.executeCommand(Commands.EXECUTE_WORKSPACE_COMMAND, Commands.JAVA_PROJECT_LIST, params);
     }
 
+    export function refreshLibraries(params): Thenable<boolean> {
+        return commands.executeCommand(Commands.EXECUTE_WORKSPACE_COMMAND, Commands.JAVA_PROJECT_REFRESH_LIB_SERVER, params);
+    }
+
     export function getPackageData(params): Thenable<INodeData[]> {
         return commands.executeCommand(Commands.EXECUTE_WORKSPACE_COMMAND, Commands.JAVA_GETPACKAGEDATA, params);
     }

src/settings.ts

@@ -2,8 +2,8 @@
 // Licensed under the MIT license.
 
 import {
-    commands, ConfigurationChangeEvent, Disposable, DocumentHighlight, ExtensionContext,
-    window, workspace, WorkspaceConfiguration,
+    commands, ConfigurationChangeEvent, ExtensionContext,
+    workspace, WorkspaceConfiguration,
 } from "vscode";
 import { instrumentOperation } from "vscode-extension-telemetry-wrapper";
 import { Commands } from "./commands";
@@ -73,6 +73,33 @@ export class Settings {
         workspace.getConfiguration().update("java.dependency.packagePresentation", PackagePresentation.Hierarchical, false);
     }
 
+    public static updateReferencedLibraries(setting: IReferencedLibraries): void {
+        let updateSetting: string[] | Partial<IReferencedLibraries> = {
+            include: setting.include,
+            exclude: setting.exclude.length > 0 ? setting.exclude : undefined,
+            sources: Object.keys(setting.sources).length > 0 ? setting.sources : undefined,
+        };
+        if (!updateSetting.exclude && !updateSetting.sources) {
+            updateSetting = setting.include;
+        }
+        workspace.getConfiguration().update("java.project.referencedLibraries", updateSetting);
+    }
+
+    public static referencedLibraries(): IReferencedLibraries {
+        const setting = workspace.getConfiguration("java.project").get<string[] | Partial<IReferencedLibraries>>("referencedLibraries");
+        const defaultSetting: IReferencedLibraries = { include: [], exclude: [], sources: {} };
+        if (Array.isArray(setting)) {
+            return { ...defaultSetting, include: setting };
+        } else {
+            return { ...defaultSetting, ...setting };
+        }
+    }
+
+    public static isDefaultReferencedLibraries(): boolean {
+        const setting = workspace.getConfiguration("java.project").inspect<string[] | Partial<IReferencedLibraries>>("referencedLibraries");
+        return setting.defaultValue && !setting.globalValue && !setting.workspaceValue && !setting.workspaceFolderValue;
+    }
+
     public static showOutline(): boolean {
         return this._dependencyConfig.get("showOutline");
     }
@@ -104,3 +131,9 @@ enum PackagePresentation {
 }
 
 type Listener = (updatedConfig: WorkspaceConfiguration, oldConfig: WorkspaceConfiguration) => void;
+
+export interface IReferencedLibraries {
+    include: string[];
+    exclude: string[];
+    sources: { [binary: string]: string };
+}