feat: Retrieve local copybooks if exists eclipse-che4zGH-327

sergiuilie · temanbrcom · commit 7d3a06880c50 · 2020-06-02T14:50:08.000+02:00
diff --git a/clients/cobol-lsp-vscode-extension/package.json b/clients/cobol-lsp-vscode-extension/package.json
@@ -55,6 +55,14 @@
             {
                 "command": "broadcom-cobol-lsp.cpy-manager.resolve-local-copybooks",
                 "title": "Resolve Local Copybooks"
+            },
+            {
+                "command": "broadcom-cobol-lsp.cpy-manager.resolve-git-copybooks",
+                "title": "Resolve Local 2"
+            },
+            {
+                "command": "broadcom-cobol-lsp.cpy-manager.resolve-git-copybooks-2",
+                "title": "Get local copybooks"
             }
         ],
         "languages": [
diff --git a/clients/cobol-lsp-vscode-extension/src/__tests__/LocalCopybookResolverTest.ts b/clients/cobol-lsp-vscode-extension/src/__tests__/LocalCopybookResolverTest.ts
@@ -17,6 +17,7 @@ import * as path from "path";
 import {PATHS_LOCAL_KEY, SETTINGS_SECTION } from "../constants";
 import {LocalCopybookResolver} from "../services/settings/LocalCopybookResolver";
 import {SettingsUtils} from "../services/settings/util/SettingsUtils";
+import { URL } from "url";
 
 const settingsParser: LocalCopybookResolver = new LocalCopybookResolver();
 const STAR_LOCATION = "*";
diff --git a/clients/cobol-lsp-vscode-extension/src/__tests__/PrioritizerTest.ts b/clients/cobol-lsp-vscode-extension/src/__tests__/PrioritizerTest.ts
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2020 Broadcom.
+ * The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Broadcom, Inc. - initial API and implementation
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { Prioritizer } from "../services/Prioritizer";
+import { SettingsUtils } from "../services/settings/util/SettingsUtils";
+
+const prioritizer: Prioritizer = new Prioritizer();
+const FILENAME1: string = "test.cpy";
+const FILENAME2: string = "mama.cpy";
+const FILENAME3: string = "tata";
+let FILENAME_URI1: string = "";
+let FILENAME_URI2: string = "";
+let FILENAME_URI3: string = "";
+
+beforeAll(() => {
+    FILENAME_URI1 = createFile(FILENAME1);
+    FILENAME_URI2 = createFile(FILENAME2);
+    FILENAME_URI3 = createFile(FILENAME3);
+    SettingsUtils.getWorkspacesURI = jest.fn().mockReturnValue(["file://"]);
+});
+
+afterAll(() => {
+    return deleteTempFile([FILENAME_URI1, FILENAME_URI2, FILENAME_URI3]);
+});
+
+describe("ConfigurationSwitcher tests", () => {
+    test("check if copybooks are present local", () => {
+        prioritizer.checkCopybooksPresentLocal([FILENAME1, FILENAME2], [FILENAME_URI1, FILENAME_URI2, "./src"]);
+        expect(prioritizer.getLocalCpyURI().length).toBe(2);
+    });
+
+    test("copybook is found even without extension", () => {
+        prioritizer.checkCopybooksPresentLocal([FILENAME3], [FILENAME_URI3]);
+        expect(prioritizer.getLocalCpyURI().length).toBe(1);
+    });
+});
+
+describe("Negative scenario test", () => {
+    test("Path is not provided and method should return empty list", () => {
+        prioritizer.checkCopybooksPresentLocal([FILENAME1], []);
+        expect(prioritizer.getLocalCpyURI().length).toBe(0);
+    });
+});
+
+function createFile(filename: string): string {
+    fs.writeFile(path.join(__dirname, filename), "Some dummy content", err => {
+        if (err) {
+            return null;
+        }
+    });
+    return path.resolve(__dirname, filename);
+}
+
+function deleteTempFile(filenames: string[]) {
+    filenames.forEach(filename => {
+        const filePath: string = path.resolve(filename);
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    });
+}
diff --git a/clients/cobol-lsp-vscode-extension/src/extension.ts b/clients/cobol-lsp-vscode-extension/src/extension.ts
@@ -17,7 +17,7 @@ import { changeDefaultZoweProfile } from "./commands/ChangeDefaultZoweProfile";
 import { editDatasetPaths } from "./commands/EditDatasetPaths";
 import { fetchCopybookCommand } from "./commands/FetchCopybookCommand";
 import { DEPENDENCIES_FOLDER, REASON_MSG } from "./constants";
-import { LANGUAGE_ID, SETTINGS_SECTION } from "./constants";
+import { LANGUAGE_ID, SETTINGS_SECTION, PATHS_LOCAL_KEY } from "./constants";
 import { CopybookFix } from "./services/CopybookFix";
 import { CopybooksCodeActionProvider } from "./services/CopybooksCodeActionProvider";
 import { CopybooksDownloader } from "./services/CopybooksDownloader";
@@ -31,16 +31,18 @@ import { ProfileService } from "./services/ProfileService";
 import {CopybookResolver} from "./services/settings/CopybookResolver";
 import {LocalCopybookResolver} from "./services/settings/LocalCopybookResolver";
 import { ZoweApi } from "./services/ZoweApi";
+import { Prioritizer } from "./services/Prioritizer";
 
 export async function activate(context: vscode.ExtensionContext) {
     initializeSettings();
 
     const zoweApi: ZoweApi = new ZoweApi();
     const profileService: ProfileService = new ProfileService(zoweApi);
     const copybookFix: CopybookFix = new CopybookFix();
+    const prioritizer: Prioritizer = new Prioritizer();
     const copybooksPathGenerator: CopybooksPathGenerator = new CopybooksPathGenerator(profileService);
-    const copyBooksDownloader: CopybooksDownloader = new CopybooksDownloader(copybookFix, zoweApi, profileService, copybooksPathGenerator);
-    const languageClientService: LanguageClientService = new LanguageClientService(copybooksPathGenerator);
+    const copyBooksDownloader: CopybooksDownloader = new CopybooksDownloader(copybookFix, zoweApi, profileService, copybooksPathGenerator, prioritizer);
+    const languageClientService: LanguageClientService = new LanguageClientService(copybooksPathGenerator, prioritizer);
     const pathsService: PathsService = new PathsService();
     const copybookResolver: CopybookResolver = new LocalCopybookResolver();
 
@@ -81,6 +83,17 @@ export async function activate(context: vscode.ExtensionContext) {
         resolveLocalCopybooks(copybookResolver);
     }));
 
+    //to be deleted after implementation
+    context.subscriptions.push
+    (vscode.commands.registerCommand("broadcom-cobol-lsp.cpy-manager.resolve-git-copybooks", () => {
+        prioritizer.checkCopybooksPresentLocal(["DEMO1", "DEMO2"],
+             vscode.workspace.getConfiguration(SETTINGS_SECTION).get(PATHS_LOCAL_KEY));
+    }));
+
+    context.subscriptions.push
+    (vscode.commands.registerCommand("broadcom-cobol-lsp.cpy-manager.resolve-git-copybooks-2", () => {
+        vscode.window.showInformationMessage("My message: " + prioritizer.getLocalCpyURI());
+    }));
 
     context.subscriptions.push(languageClientService.start());
     context.subscriptions.push(initWorkspaceTracker(copyBooksDownloader));
diff --git a/clients/cobol-lsp-vscode-extension/src/services/CopybooksDownloader.ts b/clients/cobol-lsp-vscode-extension/src/services/CopybooksDownloader.ts
@@ -14,11 +14,12 @@
 
 import * as fs from "fs";
 import * as vscode from "vscode";
-import { loadDepFile, DependenciesDesc } from "./DependencyService";
-import { DEPENDENCIES_FOLDER, PROCESS_DOWNLOAD_ERROR_MSG } from "../constants";
-import { CopybookFix } from "./CopybookFix";
+import { DEPENDENCIES_FOLDER, PROCESS_DOWNLOAD_ERROR_MSG, SETTINGS_SECTION, PATHS_LOCAL_KEY } from "../constants";
 import { CopybooksPathGenerator, createDatasetPath, createCopybookPath, checkWorkspace } from "./CopybooksPathGenerator";
+import { Prioritizer } from "./Prioritizer";
+import { CopybookFix } from "./CopybookFix";
 import { CopybookProfile, DownloadQueue } from "./DownloadQueue";
+import { loadDepFile, DependenciesDesc } from "./DependencyService";
 import { ProfileService } from "./ProfileService";
 import { ZoweApi } from "./ZoweApi";
 
@@ -29,7 +30,8 @@ export class CopybooksDownloader implements vscode.Disposable {
         private resolver: CopybookFix,
         private zoweApi: ZoweApi,
         private profileService: ProfileService,
-        private pathGenerator: CopybooksPathGenerator) { }
+        private pathGenerator: CopybooksPathGenerator,
+        private prioritizer: Prioritizer) { }
 
     public async redownloadDependencies(message: string = "Redownload dependencies requested.") {
         (await vscode.workspace.findFiles(DEPENDENCIES_FOLDER + "/**/*.dep")).forEach(dep => {
@@ -39,9 +41,9 @@ export class CopybooksDownloader implements vscode.Disposable {
 
     /**
      * @param copybooks array of copybooks names to download
+     * @param programName analyzed COBOL file
      */
     async downloadCopybooks(copybooks: string[], programName: string): Promise<void> {
-        // TODO do it right
         const profile: string = await this.profileService.getProfile(programName);
         if (!profile) {
             return;
@@ -54,22 +56,25 @@ export class CopybooksDownloader implements vscode.Disposable {
             return;
         }
         const depDesc: DependenciesDesc = loadDepFile(depFileUri);
+
+        // TODO: REMOVE PROFILE OR ADD IT AFTER LOCAL CHECK
         const profile: string = await this.profileService.getProfile(depDesc.programName);
         if (!profile) {
             return;
         }
 
-        const missingCopybooks: string[] = await this.listMissingCopybooks(depDesc.copybooks, profile);
+        this.prioritizer.checkCopybooksPresentLocal(depDesc.copybooks,
+        vscode.workspace.getConfiguration(SETTINGS_SECTION).get(PATHS_LOCAL_KEY));
+        const notLocalCpy: string[] = this.prioritizer.getNotLocalCpy();
+        const localCpyExists: boolean = this.prioritizer.getLocalCpyURI().length > 0;
 
-        if (!message.length) {
-            missingCopybooks.forEach(copybook => this.queue.push(copybook, profile));
-        } else if (missingCopybooks.length > 0) {
-            this.resolver.fixMissingDownloads(message, missingCopybooks, profile, {
-                hasPaths: (await this.pathGenerator.listDatasets()).length > 0,
-                hasProfiles: Object.keys(await this.profileService.listProfiles()).length > 1,
-            });
+        // message to be displayed should be adjusted according to the requirments
+        if (localCpyExists) {
+        // we can use the logic from continueDownloadFromMF in order to ask user if would like to use Zowe or no - TBD
+                this.notifyUserIfCopyNotLocal("Some copybooks are not present locally", notLocalCpy.length > 0);
+            } else {
+                this.continueDownloadFromMF(notLocalCpy, depDesc.programName, message);
         }
-
     }
 
     public async start() {
@@ -121,6 +126,50 @@ export class CopybooksDownloader implements vscode.Disposable {
         this.queue.stop();
     }
 
+    /**
+     * This method pushes missingCopybooks into the queue to be downloaded from MF
+     * @param message message to be displayed
+     * @param missingCopybooks copybooks which are not presented locally
+     * @param profile Zowe connection profile
+     */
+    private async resolveMissingCopybooksFromMF(message: string, missingCopybooks: string[], profile: string) {
+        if (!message.length) {
+            missingCopybooks.forEach(copybook => this.queue.push(copybook, profile));
+        } else if (missingCopybooks.length > 0) {
+            this.resolver.fixMissingDownloads(message, missingCopybooks, profile, {
+                hasPaths: (await this.pathGenerator.listDatasets()).length > 0,
+                hasProfiles: Object.keys(await this.profileService.listProfiles()).length > 1,
+            });
+        }
+    }
+
+    /**
+     * @param title message to be displayed
+     * @param cpyNotLocal check if there are any copybooks unresolved locally
+     */
+    private notifyUserIfCopyNotLocal(title: string, cpyNotLocal: boolean) {
+        if (cpyNotLocal) { vscode.window.showErrorMessage(title); }
+    }
+
+    /**
+     * This method is implemented in order to create a smooth transition from local analyze to MF download
+     * @param notLocalCpy copybooks not present in local workspace
+     * @param programName analyzed COBOL file
+     * @param message message to be displayed
+     */
+    private async continueDownloadFromMF(notLocalCpy: string[], programName: string, message: string) {
+        const action = await vscode.window.showErrorMessage("Do you wanna use Zowe?",
+                "Yes", "Never");
+        if (action === "Yes") {
+            const profile: string = await this.profileService.getProfile(programName);
+            if (!profile) {
+                return;
+            }
+            const missingCopybooks: string[] = await this.listMissingCopybooks(notLocalCpy, profile);
+            this.resolveMissingCopybooksFromMF(message, missingCopybooks, profile);
+        }
+    }
+
     private async fetchCopybook(dataset: string, copybookProfile: CopybookProfile): Promise<boolean> {
         let members: string[] = [];
         try {
diff --git a/clients/cobol-lsp-vscode-extension/src/services/LanguageClientService.ts b/clients/cobol-lsp-vscode-extension/src/services/LanguageClientService.ts
@@ -15,16 +15,17 @@
 import * as fs from "fs";
 import * as net from "net";
 import * as vscode from "vscode";
-import { LANGUAGE_ID } from "../constants";
-import {CancellationToken, ConfigurationParams, ConfigurationRequest, LanguageClient, LanguageClientOptions, StreamInfo} from "vscode-languageclient";
+import { LANGUAGE_ID, PATHS_ZOWE, SETTINGS_SECTION } from "../constants";
+import { CancellationToken, ConfigurationParams, ConfigurationRequest, LanguageClient, LanguageClientOptions, StreamInfo} from "vscode-languageclient";
 import { ConfigurationWorkspaceMiddleware } from "vscode-languageclient/lib/configuration";
 import { CopybooksPathGenerator } from "./CopybooksPathGenerator";
 import { JavaCheck } from "./JavaCheck";
+import { Prioritizer } from "./Prioritizer";
 
 export class LanguageClientService {
     private jarPath: string;
 
-    constructor(private copybooksPathGenerator: CopybooksPathGenerator) {
+    constructor(private copybooksPathGenerator: CopybooksPathGenerator, private prioritizer: Prioritizer) {
         const ext = vscode.extensions.getExtension("BroadcomMFD.cobol-language-support");
         this.jarPath = `${ext.extensionPath}/server/lsp-service-cobol-${ext.packageJSON.version}.jar`;
     }
@@ -53,6 +54,24 @@ export class LanguageClientService {
             next: ConfigurationRequest.HandlerSignature) => {
 
             // TODO if request params are right
+
+            // TODO after server modification this method return the local copybooks URI
+            /*
+             there should be logic here to check if user complete the zowe settings, than add
+             calculated path to response object
+             use checkMFSettings and this.copybooksPathGenerator.listUris()
+            */
+
+            /**
+             * TODO
+             * at initialize moment, check if there is a dependency file created for the open COBOL
+             * file, if not send empty array, if yes call prioritizer.checkCopybooksPresentLocal
+             * If the dependency file is not present at the initialize moment, the server after analyzing
+             * the open file has to ask for settings in order to resolve the local copybooks
+             */
+
+            console.log(this.prioritizer.getLocalCpyURI());
+
             return (await this.copybooksPathGenerator.listUris()).map(uri => uri.toString());
             // TODO else return next(params, token);
         };
@@ -65,6 +84,11 @@ export class LanguageClientService {
             middleware: { workspace: configurationMiddleware }
         };
     }
+
+    private checkMFSettings(): boolean {
+      return vscode.workspace.getConfiguration(SETTINGS_SECTION).has(PATHS_ZOWE);
+    }
+
     private createServerOptions(jarPath: string) {
         const port = this.getLspPort();
         if (port) {
diff --git a/clients/cobol-lsp-vscode-extension/src/services/Prioritizer.ts b/clients/cobol-lsp-vscode-extension/src/services/Prioritizer.ts
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020 Broadcom.
+ * The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Broadcom, Inc. - initial API and implementation
+ */
+
+import * as fs from "fs";
+import {URL} from "url";
+import {LocalCopybookResolver} from "./settings/LocalCopybookResolver";
+
+export class Prioritizer {
+    private settingsParser: LocalCopybookResolver = new LocalCopybookResolver();
+    private localCpyURI: string[];
+    private notLocalCpy: string[];
+
+    public setLocalCpyURI(localCpy: string[]) {
+        this.localCpyURI = localCpy;
+    }
+
+    public getLocalCpyURI(): string[] {
+        return this.localCpyURI;
+    }
+
+    public setNotLocalCpy(notLocalCpy: string[]) {
+        this.notLocalCpy = notLocalCpy;
+    }
+
+    public getNotLocalCpy(): string[] {
+        return this.notLocalCpy;
+    }
+
+    public checkCopybooksPresentLocal(copybooks: string[], listUri: string[]) {
+        const resolvedUri: string[] = this.settingsParser.resolve(listUri);
+        const copybooksPath: string[] = [];
+        const notLocal: string[] = [];
+        copybooks.forEach(copybook => {
+            const copybookPath: string = this.copybookInLocal(copybook, resolvedUri);
+            if (copybookPath) {
+                copybooksPath.push(copybookPath);
+            } else {
+                notLocal.push(copybook);
+            }
+        });
+        this.setNotLocalCpy(notLocal);
+        this.setLocalCpyURI(copybooksPath);
+    }
+
+    private copybookInLocal(copybook: string, resolvedUri: string[]): string {
+        let finalUri: URL;
+        resolvedUri.forEach(uri => {
+            let url = new URL(uri);
+            if (uri.includes(copybook) && fs.existsSync(url)) {
+                finalUri = url;
+            }
+        });
+        return finalUri ? finalUri.href : null;
+    }
+
+}
