Make binaries optional for AbsolutePathPackage

src/packageManager/AbsolutePath.ts

@@ -3,16 +3,16 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { isAbsolute, resolve } from "path";
+import * as path from "path";
 
 export class AbsolutePath {
     constructor(public value: string) {
-        if (!isAbsolute(value)) {
+        if (!path.isAbsolute(value)) {
             throw new Error("The path must be absolute");
         }
     }
 
     public static getAbsolutePath(...pathSegments: string[]): AbsolutePath {
-        return new AbsolutePath(resolve(...pathSegments));
+        return new AbsolutePath(path.resolve(...pathSegments));
     }
-}
+}

src/packageManager/AbsolutePathPackage.ts

@@ -13,8 +13,8 @@ export class AbsolutePathPackage implements IPackage {
         public url: string,
         public platforms: string[],
         public architectures: string[],
-        public binaries: AbsolutePath[],
         public installPath: AbsolutePath,
+        public binaries?: AbsolutePath[],
         public installTestPath?: AbsolutePath,
         public fallbackUrl?: string,
         public platformId?: string,
@@ -29,8 +29,8 @@ export class AbsolutePathPackage implements IPackage {
             pkg.url,
             pkg.platforms,
             pkg.architectures,
-            getAbsoluteBinaries(pkg, extensionPath),
             getAbsoluteInstallPath(pkg, extensionPath),
+            getAbsoluteBinaries(pkg, extensionPath),
             getAbsoluteInstallTestPath(pkg, extensionPath),
             pkg.fallbackUrl,
             pkg.platformId,
@@ -40,21 +40,17 @@ export class AbsolutePathPackage implements IPackage {
     }
 }
 
-function getAbsoluteInstallTestPath(pkg: Package, extensionPath: string): AbsolutePath {
-    if (pkg.installTestPath) {
+function getAbsoluteInstallTestPath(pkg: Package, extensionPath: string): AbsolutePath | undefined {
+    if (pkg.installTestPath !== undefined) {
         return AbsolutePath.getAbsolutePath(extensionPath, pkg.installTestPath);
     }
 
-    return null;
+    return undefined;
 }
 
-function getAbsoluteBinaries(pkg: Package, extensionPath: string): AbsolutePath[] {
-    let basePath = getAbsoluteInstallPath(pkg, extensionPath).value;
-    if (pkg.binaries) {
-        return pkg.binaries.map(value => AbsolutePath.getAbsolutePath(basePath, value));
-    }
-
-    return null;
+function getAbsoluteBinaries(pkg: Package, extensionPath: string): AbsolutePath[] | undefined {
+    const basePath = getAbsoluteInstallPath(pkg, extensionPath).value;
+    return pkg.binaries?.map(value => AbsolutePath.getAbsolutePath(basePath, value));
 }
 
 function getAbsoluteInstallPath(pkg: Package, extensionPath: string): AbsolutePath {

src/packageManager/ZipInstaller.ts

@@ -12,7 +12,7 @@ import { InstallationStart, ZipError } from "../omnisharp/loggingEvents";
 import { NestedError } from '../NestedError';
 import { AbsolutePath } from './AbsolutePath';
 
-export async function InstallZip(buffer: Buffer, description: string, destinationInstallPath: AbsolutePath, binaries: AbsolutePath[], eventStream: EventStream): Promise<void> {
+export async function InstallZip(buffer: Buffer, description: string, destinationInstallPath: AbsolutePath, binaries: AbsolutePath[] | undefined, eventStream: EventStream): Promise<void> {
     eventStream.post(new InstallationStart(description));
 
     return new Promise<void>((resolve, reject) => {
@@ -49,12 +49,9 @@ export async function InstallZip(buffer: Buffer, description: string, destinatio
                         try {
                             await mkdirp(path.dirname(absoluteEntryPath), 0o775);
 
-                            let binaryPaths = binaries && binaries.map(binary => binary.value);
-
                             // Make sure executable files have correct permissions when extracted
-                            let fileMode = binaryPaths && binaryPaths.indexOf(absoluteEntryPath) !== -1
-                                ? 0o755
-                                : 0o664;
+                            const binaryPaths = binaries?.map(binary => binary.value);
+                            const fileMode = binaryPaths?.includes(absoluteEntryPath) ? 0o755 : 0o664;
 
                             readStream.pipe(fs.createWriteStream(absoluteEntryPath, { mode: fileMode }));
                             readStream.on('end', () => zipFile.readEntry());