Rename to zip

Author: akshita31

src/observers/WarningMessageObserver.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { MessageItem, vscode } from '../vscodeAdapter';
-import { BaseEvent, OmnisharpServerOnError, OmnisharpServerMsBuildProjectDiagnostics, ArchiveError } from "../omnisharp/loggingEvents";
+import { BaseEvent, OmnisharpServerOnError, OmnisharpServerMsBuildProjectDiagnostics, ZipError } from "../omnisharp/loggingEvents";
 import { Scheduler } from 'rxjs/Scheduler';
 import { Subject } from 'rxjs/Subject';
 import 'rxjs/add/operator/debounceTime';
@@ -32,8 +32,8 @@ export class WarningMessageObserver {
             case OmnisharpServerMsBuildProjectDiagnostics.name:
                 this.handleOmnisharpServerMsBuildProjectDiagnostics(<OmnisharpServerMsBuildProjectDiagnostics>event);
                 break;
-            case ArchiveError.name:
-                this.handleArchiveError(<ArchiveError>event);
+            case ZipError.name:
+                this.handleArchiveError(<ZipError>event);
                 break;
         }
     }
@@ -44,7 +44,7 @@ export class WarningMessageObserver {
         }
     }
 
-    private async handleArchiveError(event: ArchiveError) {
+    private async handleArchiveError(event: ZipError) {
         await showWarningMessage(this.vscode, event.message);
     }
 }

src/omnisharp/loggingEvents.ts

@@ -118,7 +118,7 @@ export class DownloadSizeObtained implements BaseEvent {
     constructor(public packageSize: number) { }
 }
 
-export class ArchiveError implements BaseEvent {
+export class ZipError implements BaseEvent {
     constructor(public message: string) { }
 }
 

src/packageManager/PackageManager.ts

@@ -8,7 +8,7 @@ import { Package } from './Package';
 import { PackageError } from './PackageError';
 import { NestedError } from "../NestedError";
 import { DownloadFile } from './FileDownloader';
-import { InstallArchive } from './ArchiveInstaller';
+import { InstallZip } from './ZipInstaller';
 import { EventStream } from '../EventStream';
 import { NetworkSettingsProvider } from "../NetworkSettings";
 import { filterPackages } from "./PackageFilterer";
@@ -21,7 +21,7 @@ export async function DownloadAndInstallPackages(packages: Package[], provider:
         for (let pkg of filteredPackages) {
             try {
                 let buffer = await DownloadFile(pkg.description, eventStream, provider, pkg.url, pkg.fallbackUrl);
-                await InstallArchive(buffer, pkg.description, pkg.installPath, pkg.binaries, eventStream);
+                await InstallZip(buffer, pkg.description, pkg.installPath, pkg.binaries, eventStream);
             }
             catch (error) {
                 if (error instanceof NestedError) {

src/packageManager/ArchiveInstaller.ts renamed to src/packageManager/ZipInstaller.ts

@@ -8,17 +8,17 @@ import * as mkdirp from 'mkdirp';
 import * as path from 'path';
 import * as yauzl from 'yauzl';
 import { EventStream } from "../EventStream";
-import { InstallationStart, ArchiveError } from "../omnisharp/loggingEvents";
+import { InstallationStart, ZipError } from "../omnisharp/loggingEvents";
 import { NestedError } from '../NestedError';
 
-export async function InstallArchive(buffer: Buffer, description: string, destinationInstallPath: string, binaries: string[], eventStream: EventStream): Promise<void> {
+export async function InstallZip(buffer: Buffer, description: string, destinationInstallPath: string, binaries: string[], eventStream: EventStream): Promise<void> {
     eventStream.post(new InstallationStart(description));
 
     return new Promise<void>((resolve, reject) => {
         yauzl.fromBuffer(buffer, { lazyEntries: true }, (err, zipFile) => {
             if (err) {
-                eventStream.post(new ArchiveError("C# Extension was unable to download its dependencies. Please check your internet connection. If you use a proxy server, please visit https://aka.ms/VsCodeCsharpNetworking"));
-                return reject(new NestedError('Corrupted archive error'));
+                eventStream.post(new ZipError("C# Extension was unable to download its dependencies. Please check your internet connection. If you use a proxy server, please visit https://aka.ms/VsCodeCsharpNetworking"));
+                return reject(new NestedError('Corrupted zip error'));
             }
 
             zipFile.readEntry();

test/unitTests/Packages/ArchiveInstaller.test.ts renamed to test/unitTests/Packages/ZipInstaller.test.ts

@@ -8,10 +8,10 @@ import * as path from 'path';
 import * as chai from 'chai';
 import * as util from '../../../src/common';
 import { CreateTmpDir, TmpAsset } from '../../../src/CreateTmpAsset';
-import { InstallArchive } from '../../../src/packageManager/ArchiveInstaller';
+import { InstallZip } from '../../../src/packageManager/ZipInstaller';
 import { EventStream } from '../../../src/EventStream';
 import { PlatformInformation } from '../../../src/platform';
-import { BaseEvent, InstallationStart, ArchiveError } from '../../../src/omnisharp/loggingEvents';
+import { BaseEvent, InstallationStart, ZipError } from '../../../src/omnisharp/loggingEvents';
 import { Files, Binaries, createTestZipAsync } from '../testAssets/CreateTestZip';
 
 chai.use(require("chai-as-promised"));
@@ -38,15 +38,15 @@ suite('ArchiveInstaller', () => {
     });
 
     test('The folder is unzipped and all the files are present at the expected paths', async () => {
-        await InstallArchive(testBuffer, fileDescription, installationPath, [], eventStream);
+        await InstallZip(testBuffer, fileDescription, installationPath, [], eventStream);
         for (let elem of allFiles) {
             let filePath = path.join(installationPath, elem.path);
             expect(await util.fileExists(filePath)).to.be.true;
         }
     });
 
     test('The folder is unzipped and all the expected events are created', async () => {
-        await InstallArchive(testBuffer, fileDescription, installationPath, [], eventStream);
+        await InstallZip(testBuffer, fileDescription, installationPath, [], eventStream);
         let eventSequence: BaseEvent[] = [
             new InstallationStart(fileDescription)
         ];
@@ -56,7 +56,7 @@ suite('ArchiveInstaller', () => {
     test('The folder is unzipped and the binaries have the expected permissions(except on Windows)', async () => {
         if (!((await PlatformInformation.GetCurrent()).isWindows())) {
             let resolvedBinaryPaths = Binaries.map(binary => path.join(installationPath, binary.path));
-            await InstallArchive(testBuffer, fileDescription, installationPath, resolvedBinaryPaths, eventStream);
+            await InstallZip(testBuffer, fileDescription, installationPath, resolvedBinaryPaths, eventStream);
             for (let binaryPath of resolvedBinaryPaths) {
                 expect(await util.fileExists(binaryPath)).to.be.true;
                 let mode = (await fs.stat(binaryPath)).mode;
@@ -65,18 +65,18 @@ suite('ArchiveInstaller', () => {
         }
     });
 
-    test('Error is thrown when the buffer contains an invalid archive', async () => {
-        expect(InstallArchive(new Buffer("My file", "utf8"), "Text File", installationPath, [], eventStream)).to.be.rejected;
+    test('Error is thrown when the buffer contains an invalid zip', async () => {
+        expect(InstallZip(new Buffer("My file", "utf8"), "Text File", installationPath, [], eventStream)).to.be.rejected;
     });
 
-    test('Error event is created when the buffer contains an invalid archive', async () => {
+    test('Error event is created when the buffer contains an invalid zip', async () => {
         try {
-            await InstallArchive(new Buffer("some content", "utf8"), "Text File", installationPath, [], eventStream);
+            await InstallZip(new Buffer("some content", "utf8"), "Text File", installationPath, [], eventStream);
         }
         catch{
             let eventSequence: BaseEvent[] = [
                 new InstallationStart("Text File"),
-                new ArchiveError("C# Extension was unable to download its dependencies. Please check your internet connection. If you use a proxy server, please visit https://aka.ms/VsCodeCsharpNetworking")
+                new ZipError("C# Extension was unable to download its dependencies. Please check your internet connection. If you use a proxy server, please visit https://aka.ms/VsCodeCsharpNetworking")
             ];
             expect(eventBus).to.be.deep.equal(eventSequence);
         }

test/unitTests/logging/WarningMessageObserver.test.ts

@@ -6,7 +6,7 @@
 import { WarningMessageObserver } from '../../../src/observers/WarningMessageObserver';
 import { assert, use as chaiUse, expect, should } from 'chai';
 import { getFakeVsCode, getMSBuildDiagnosticsMessage, getOmnisharpMSBuildProjectDiagnosticsEvent, getOmnisharpServerOnErrorEvent } from '../testAssets/Fakes';
-import { BaseEvent, ArchiveError } from '../../../src/omnisharp/loggingEvents';
+import { BaseEvent, ZipError } from '../../../src/omnisharp/loggingEvents';
 import { vscode } from '../../../src/vscodeAdapter';
 import { TestScheduler } from 'rxjs/testing/TestScheduler';
 import { Observable } from 'rxjs/Observable';
@@ -173,9 +173,9 @@ suite('WarningMessageObserver', () => {
         });
     });
 
-    suite('ArchiveError', () => {
+    suite('ZipError', () => {
         test('When the event is fired then a warning message is displayed', () => {
-            let event = new ArchiveError("This is an error");
+            let event = new ZipError("This is an error");
             observer.post(event);
             expect(warningMessages.length).to.be.equal(1);
             expect(warningMessages[0]).to.be.equal("This is an error");