Specific target folder when exporting jar and enhancement of jdtls.ext (#342)

Co-authored-by: Sheng Chen <[email protected]>

Author: CsCherrYY

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

@@ -66,7 +66,7 @@
 
 public final class ProjectCommand {
 
-    public static class MainClassInfo {
+    private static class MainClassInfo {
 
         public String name;
 
@@ -78,10 +78,25 @@ public MainClassInfo(String name, String path) {
         }
     }
 
-    private static final Gson gson = new GsonBuilder()
-            .registerTypeAdapterFactory(new CollectionTypeAdapter.Factory())
-            .registerTypeAdapterFactory(new EnumTypeAdapter.Factory())
-            .create();
+    private static class exportResult {
+        public boolean result;
+        public String message;
+        public String log;
+
+        exportResult(boolean result) {
+            this.result = result;
+            this.log = "";
+        }
+
+        exportResult(boolean result, String message) {
+            this.result = result;
+            this.message = message;
+            this.log = "";
+        }
+    }
+
+    private static final Gson gson = new GsonBuilder().registerTypeAdapterFactory(new CollectionTypeAdapter.Factory())
+            .registerTypeAdapterFactory(new EnumTypeAdapter.Factory()).create();
 
     public static List<PackageNode> listProjects(List<Object> arguments, IProgressMonitor monitor) {
         String workspaceUri = (String) arguments.get(0);
@@ -95,9 +110,11 @@ public static List<PackageNode> listProjects(List<Object> arguments, IProgressMo
             if (!project.isAccessible() || !ProjectUtils.isJavaProject(project)) {
                 continue;
             }
-            // Ignore all the projects that's not contained in the workspace folder, except for the invisible project.
+            // Ignore all the projects that's not contained in the workspace folder, except
+            // for the invisible project.
             // This check is needed in multi-root scenario.
-            if ((!ResourceUtils.isContainedIn(project.getLocation(), paths) && !Objects.equals(project.getName(), invisibleProjectName))) {
+            if ((!ResourceUtils.isContainedIn(project.getLocation(), paths)
+                    && !Objects.equals(project.getName(), invisibleProjectName))) {
                 continue;
             }
             PackageNode projectNode = PackageNode.createNodeForProject(JavaCore.create(project));
@@ -115,7 +132,8 @@ public static boolean refreshLibraries(List<Object> arguments, IProgressMonitor
         String projectName = ProjectUtils.getWorkspaceInvisibleProjectName(workspacePath);
         IProject project = getWorkspaceRoot().getProject(projectName);
         try {
-            ReferencedLibraries libraries = JavaLanguageServerPlugin.getPreferencesManager().getPreferences().getReferencedLibraries();
+            ReferencedLibraries libraries = JavaLanguageServerPlugin.getPreferencesManager().getPreferences()
+                    .getReferencedLibraries();
             UpdateClasspathJob.getInstance().updateClasspath(JavaCore.create(project), libraries);
             return true;
         } catch (Exception e) {
@@ -128,48 +146,47 @@ private static IWorkspaceRoot getWorkspaceRoot() {
         return ResourcesPlugin.getWorkspace().getRoot();
     }
 
-    public static boolean exportJar(List<Object> arguments, IProgressMonitor monitor) {
+    public static exportResult exportJar(List<Object> arguments, IProgressMonitor monitor) {
         if (arguments.size() < 3) {
-            return false;
+            return new exportResult(false, "Invalid export Arguments");
         }
         String mainMethod = gson.fromJson(gson.toJson(arguments.get(0)), String.class);
         String[] classpaths = gson.fromJson(gson.toJson(arguments.get(1)), String[].class);
         String destination = gson.fromJson(gson.toJson(arguments.get(2)), String.class);
         Manifest manifest = new Manifest();
         manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
         if (mainMethod.length() > 0) {
-            manifest.getMainAttributes().put(Attributes.Name.MAIN_CLASS,mainMethod);
+            manifest.getMainAttributes().put(Attributes.Name.MAIN_CLASS, mainMethod);
         }
         try (JarOutputStream target = new JarOutputStream(new FileOutputStream(destination), manifest)) {
-            Set<String> fDirectories = new HashSet<>();
+            Set<String> directories = new HashSet<>();
             for (String classpath : classpaths) {
                 if (classpath != null) {
-                    if(classpath.endsWith(".jar")) {
+                    if (classpath.endsWith(".jar")) {
                         ZipFile zip = new ZipFile(classpath);
-                        writeArchive(zip, true, true, target, fDirectories, monitor);
-                    }
-                    else {
+                        writeArchive(zip, true, true, target, directories, monitor);
+                    } else {
                         File folder = new File(classpath);
-                        writeFileRecursively(folder, target, fDirectories, folder.getAbsolutePath().length() + 1);
+                        writeFileRecursively(folder, target, directories, folder.getAbsolutePath().length() + 1);
                     }
                 }
             }
         } catch (Exception e) {
-            return false;
+            return new exportResult(false, e.getMessage());
         }
-        return true;
+        return new exportResult(true);
     }
 
-    private static void writeFileRecursively(File folder, JarOutputStream fJarOutputStream, Set<String> fDirectories, int len) {
+    private static void writeFileRecursively(File folder, JarOutputStream jarOutputStream, Set<String> directories,
+            int len) {
         File[] files = folder.listFiles();
         for (File file : files) {
             if (file.isDirectory()) {
-                writeFileRecursively(file, fJarOutputStream, fDirectories, len);
+                writeFileRecursively(file, jarOutputStream, directories, len);
             } else if (file.isFile()) {
                 try {
-                    writeFile(file, new Path(file.getAbsolutePath().substring(len)), true, true, fJarOutputStream, fDirectories);
-                }
-                catch (Exception e) {
+                    writeFile(file, new Path(file.getAbsolutePath().substring(len)), true, true, jarOutputStream, directories);
+                } catch (Exception e) {
                     // do nothing
                 }
             }
@@ -219,8 +236,8 @@ public void acceptSearchMatch(SearchMatch match) {
         };
         SearchEngine searchEngine = new SearchEngine();
         try {
-            searchEngine.search(pattern, new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
-                    scope, requestor, new NullProgressMonitor());
+            searchEngine.search(pattern, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, scope,
+                    requestor, new NullProgressMonitor());
         } catch (CoreException e) {
             // ignore
         }

package-lock.json

@@ -178,6 +178,15 @@
           ],
           "description": "%configuration.java.dependency.packagePresentation%",
           "default": "flat"
+        },
+        "java.project.exportJar.targetPath": {
+          "type": "string",
+          "enum": [
+            "${workspaceFolder}/${workspaceFolderBasename}.jar",
+            "askUser"
+          ],
+          "description": "%configuration.java.project.exportJar.targetPath%",
+          "default": "${workspaceFolder}/${workspaceFolderBasename}.jar"
         }
       }
     },

package.json

@@ -22,5 +22,6 @@
   "configuration.java.dependency.syncWithFolderExplorer": "Synchronize Java Projects explorer selection with folder explorer",
   "configuration.java.dependency.autoRefresh": "Synchronize Java Projects explorer with changes",
   "configuration.java.dependency.refreshDelay": "The delay time (ms) the auto refresh is invoked when changes are detected",
-  "configuration.java.dependency.packagePresentation": "Package presentation mode: flat or hierarchical"
+  "configuration.java.dependency.packagePresentation": "Package presentation mode: flat or hierarchical",
+  "configuration.java.project.exportJar.targetPath": "The default output path of export jar"
 }

package.nls.json

@@ -22,5 +22,6 @@
   "configuration.java.dependency.syncWithFolderExplorer": "在 Java 项目管理器中同步关联当前打开的文件",
   "configuration.java.dependency.autoRefresh": "在 Java 项目管理器中自动同步修改",
   "configuration.java.dependency.refreshDelay": "控制 Java 项目管理器刷新的延迟时间 (毫秒)",
-  "configuration.java.dependency.packagePresentation": "Java 包显示方式: 平行显示或者分层显示"
+  "configuration.java.dependency.packagePresentation": "Java 包显示方式: 平行显示或者分层显示",
+  "configuration.java.project.exportJar.targetPath": "导出 Jar 文件的默认路径"
 }

package.nls.zh.json

@@ -1,15 +1,15 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
-import { EOL, platform } from "os";
-import { commands, Uri, window } from "vscode";
-import { sendOperationError } from "vscode-extension-telemetry-wrapper";
+import { tasks } from "vscode";
 import { buildWorkspace } from "./build";
+import { ExportJarTaskProvider } from "./exportJarSteps/ExportJarTaskProvider";
 import { GenerateJarExecutor } from "./exportJarSteps/GenerateJarExecutor";
 import { IExportJarStepExecutor } from "./exportJarSteps/IExportJarStepExecutor";
 import { IStepMetadata } from "./exportJarSteps/IStepMetadata";
 import { ResolveJavaProjectExecutor } from "./exportJarSteps/ResolveJavaProjectExecutor";
 import { ResolveMainMethodExecutor } from "./exportJarSteps/ResolveMainMethodExecutor";
+import { failMessage, successMessage } from "./exportJarSteps/utility";
 import { isStandardServerReady } from "./extension";
 import { INodeData } from "./java/nodeData";
 
@@ -20,74 +20,45 @@ export enum ExportJarStep {
     Finish = "FINISH",
 }
 
-let isExportingJar: boolean = false;
 const stepMap: Map<ExportJarStep, IExportJarStepExecutor> = new Map<ExportJarStep, IExportJarStepExecutor>([
     [ExportJarStep.ResolveJavaProject, new ResolveJavaProjectExecutor()],
     [ExportJarStep.ResolveMainMethod, new ResolveMainMethodExecutor()],
     [ExportJarStep.GenerateJar, new GenerateJarExecutor()],
 ]);
 
-export async function createJarFile(node?: INodeData) {
-    if (!isStandardServerReady() || isExportingJar) {
+let isExportingJar: boolean = false;
+
+export async function executeExportJarTask(node?: INodeData): Promise<void> {
+    if (!isStandardServerReady() || isExportingJar || await buildWorkspace() === false) {
         return;
     }
+    const stepMetadata: IStepMetadata = {
+        entry: node,
+        steps: [],
+    };
+    tasks.executeTask(ExportJarTaskProvider.getTask(stepMetadata));
+    return;
+}
+
+export async function createJarFile(stepMetadata: IStepMetadata) {
     isExportingJar = true;
+    let step: ExportJarStep = ExportJarStep.ResolveJavaProject;
     return new Promise<string>(async (resolve, reject) => {
-        if (await buildWorkspace() === false) {
-            return reject();
-        }
-        let step: ExportJarStep = ExportJarStep.ResolveJavaProject;
-        let stepMetadata: IStepMetadata = {
-            entry: node,
-            elements: [],
-            steps: [],
-        };
         while (step !== ExportJarStep.Finish) {
             try {
-                const executor: IExportJarStepExecutor = stepMap.get(step);
-                if (executor === undefined) {
-                    // Unpredictable error, return to the initialization
-                    step = ExportJarStep.ResolveJavaProject;
-                    stepMetadata = {
-                        entry: node,
-                        elements: [],
-                        steps: [],
-                    };
-                } else {
-                    step = await executor.execute(stepMetadata);
-                }
+                step = await stepMap.get(step).execute(stepMetadata);
             } catch (err) {
-                return err ? reject(`${err}`) : reject();
+                return reject(err);
             }
         }
         return resolve(stepMetadata.outputPath);
     }).then((message) => {
-        successMessage(message);
         isExportingJar = false;
+        successMessage(message);
     }, (err) => {
-        failMessage(err);
         isExportingJar = false;
+        if (err) {
+            failMessage(`${err}`);
+        }
     });
 }
-
-function failMessage(message: string) {
-    sendOperationError("", "Export Jar", new Error(message));
-    window.showErrorMessage(message, "Done");
-}
-
-function successMessage(outputFileName: string) {
-    let openInExplorer: string;
-    if (platform() === "win32") {
-        openInExplorer = "Reveal in File Explorer";
-    } else if (platform() === "darwin") {
-        openInExplorer = "Reveal in Finder";
-    } else {
-        openInExplorer = "Open Containing Folder";
-    }
-    window.showInformationMessage("Successfully exported jar to" + EOL + outputFileName,
-        openInExplorer, "Done").then((messageResult) => {
-            if (messageResult === openInExplorer) {
-                commands.executeCommand("revealFileInOS", Uri.file(outputFileName));
-            }
-        });
-}

src/exportJarFileCommand.ts

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import {
+    CustomExecution, Event, EventEmitter, Pseudoterminal, Task, TaskDefinition,
+    TaskProvider, TaskRevealKind, TaskScope, TerminalDimensions,
+} from "vscode";
+import { createJarFile } from "../exportJarFileCommand";
+import { Settings } from "../settings";
+import { IStepMetadata } from "./IStepMetadata";
+
+export class ExportJarTaskProvider implements TaskProvider {
+
+    public static exportJarType: string = "java";
+
+    public static getTask(stepMetadata: IStepMetadata): Task {
+        const targetPathSetting: string = Settings.getExportJarTargetPath();
+        const defaultDefinition: IExportJarTaskDefinition = {
+            type: ExportJarTaskProvider.exportJarType,
+            targetPath: targetPathSetting,
+            elements: [],
+            mainMethod: undefined,
+        };
+        const task: Task = new Task(defaultDefinition, TaskScope.Workspace, "exportjar:default", ExportJarTaskProvider.exportJarType,
+            new CustomExecution(async (resolvedDefinition: TaskDefinition): Promise<Pseudoterminal> => {
+                return new ExportJarTaskTerminal(resolvedDefinition, stepMetadata);
+            }));
+        task.presentationOptions.reveal = TaskRevealKind.Never;
+        return task;
+    }
+
+    public async resolveTask(_task: Task): Promise<Task> {
+        return _task;
+    }
+
+    public async provideTasks(): Promise<Task[]> {
+        return [];
+    }
+
+}
+
+class ExportJarTaskTerminal implements Pseudoterminal {
+
+    public writeEmitter = new EventEmitter<string>();
+    public closeEmitter = new EventEmitter<void>();
+
+    public onDidWrite: Event<string> = this.writeEmitter.event;
+    public onDidClose?: Event<void> = this.closeEmitter.event;
+
+    private stepMetadata: IStepMetadata;
+
+    constructor(exportJarTaskDefinition: IExportJarTaskDefinition, stepMetadata: IStepMetadata) {
+        this.stepMetadata = stepMetadata;
+        this.stepMetadata.mainMethod = exportJarTaskDefinition.mainMethod;
+        this.stepMetadata.outputPath = exportJarTaskDefinition.targetPath;
+        this.stepMetadata.elements = exportJarTaskDefinition.elements;
+    }
+
+    public async open(initialDimensions: TerminalDimensions | undefined): Promise<void> {
+        await createJarFile(this.stepMetadata);
+        this.closeEmitter.fire();
+    }
+
+    public close(): void {
+
+    }
+}
+
+interface IExportJarTaskDefinition extends TaskDefinition {
+    elements?: string[];
+    mainMethod?: string;
+    targetPath?: string;
+}