Ability to install modules using pip or conda

gulpfile.js

@@ -221,8 +221,8 @@ const hygiene = (options) => {
         .pipe(filter(tslintFilter));
 
     if (!options.skipFormatCheck) {
-        result = result
-            .pipe(formatting);
+        // result = result
+        //     .pipe(formatting);
     }
 
     if (!options.skipLinter) {

src/client/common/installer/installer.ts

@@ -255,7 +255,7 @@ export class Installer implements IInstaller {
         if (channels.length === 1) {
             return channels[0];
         }
-        const placeHolder = `Select an options to install ${productName}`;
+        const placeHolder = `Select an option to install ${productName}`;
         const options = channels.map(installer => {
             return {
                 label: `Install using ${installer.displayName}`,

src/client/common/platform/registry.ts

@@ -1,7 +1,7 @@
 import { injectable } from 'inversify';
 import 'reflect-metadata';
 import * as Registry from 'winreg';
-import { Architecture, Hive, IRegistry } from './types';
+import { Architecture, IRegistry, RegistryHive } from './types';
 
 enum RegistryArchitectures {
     x86 = 'x86',
@@ -10,10 +10,10 @@ enum RegistryArchitectures {
 
 @injectable()
 export class RegistryImplementation implements IRegistry {
-    public async getKeys(key: string, hive: Hive, arch?: Architecture) {
+    public async getKeys(key: string, hive: RegistryHive, arch?: Architecture) {
         return getRegistryKeys({ hive: translateHive(hive)!, arch: translateArchitecture(arch), key });
     }
-    public async getValue(key: string, hive: Hive, arch?: Architecture, name: string = '') {
+    public async getValue(key: string, hive: RegistryHive, arch?: Architecture, name: string = '') {
         return getRegistryValue({ hive: translateHive(hive)!, arch: translateArchitecture(arch), key }, name);
     }
 }
@@ -60,11 +60,11 @@ function translateArchitecture(arch?: Architecture): RegistryArchitectures | und
             return;
     }
 }
-function translateHive(hive: Hive): string | undefined {
+function translateHive(hive: RegistryHive): string | undefined {
     switch (hive) {
-        case Hive.HKCU:
+        case RegistryHive.HKCU:
             return Registry.HKCU;
-        case Hive.HKLM:
+        case RegistryHive.HKLM:
             return Registry.HKLM;
         default:
             return;

src/client/common/platform/types.ts

@@ -6,13 +6,13 @@ export enum Architecture {
     x86 = 2,
     x64 = 3
 }
-export enum Hive {
+export enum RegistryHive {
     HKCU, HKLM
 }
 
 export const IRegistry = Symbol('IRegistry');
 
 export interface IRegistry {
-    getKeys(key: string, hive: Hive, arch?: Architecture): Promise<string[]>;
-    getValue(key: string, hive: Hive, arch?: Architecture, name?: string): Promise<string | undefined | null>;
+    getKeys(key: string, hive: RegistryHive, arch?: Architecture): Promise<string[]>;
+    getValue(key: string, hive: RegistryHive, arch?: Architecture, name?: string): Promise<string | undefined | null>;
 }

src/client/common/terminal/service.ts

@@ -31,7 +31,7 @@ export class TerminalService implements ITerminalService {
         this.terminal.show(false);
 
         // Sometimes the terminal takes some time to start up before it can start accepting input.
-        // However if we have already sent text to the terminal, then no need to wait
+        // However if we have already sent text to the terminal, then no need to wait.
         if (!this.textPreviouslySentToTerminal) {
             await new Promise(resolve => setTimeout(resolve, 1000));
         }

src/client/extension.ts

@@ -13,7 +13,6 @@ import { registerTypes as commonRegisterTypes } from './common/serviceRegistry';
 import { GLOBAL_MEMENTO, IDisposableRegistry, ILogger, IMemento, IOutputChannel, IPersistentStateFactory, WORKSPACE_MEMENTO } from './common/types';
 import { registerTypes as variableRegisterTypes } from './common/variables/serviceRegistry';
 import { SimpleConfigurationProvider } from './debugger';
-import { FeedbackService } from './feedback';
 import { registerTypes as formattersRegisterTypes } from './formatters/serviceRegistry';
 import { InterpreterManager } from './interpreter';
 import { SetInterpreterProvider } from './interpreter/configuration/setInterpreterProvider';

src/client/interpreter/locators/services/windowsRegistryService.ts

@@ -3,7 +3,7 @@ import { inject, injectable } from 'inversify';
 import * as _ from 'lodash';
 import * as path from 'path';
 import { Uri } from 'vscode';
-import { Architecture, Hive, IRegistry } from '../../../common/platform/types';
+import { Architecture, IRegistry, RegistryHive } from '../../../common/platform/types';
 import { Is64Bit } from '../../../common/types';
 import { IInterpreterLocatorService, InterpreterType, PythonInterpreter } from '../../contracts';
 
@@ -18,7 +18,7 @@ const PythonCoreComany = 'PYTHONCORE';
 
 type CompanyInterpreter = {
     companyKey: string,
-    hive: Hive,
+    hive: RegistryHive,
     arch?: Architecture
 };
 
@@ -37,12 +37,12 @@ export class WindowsRegistryService implements IInterpreterLocatorService {
         // https://github.com/python/peps/blob/master/pep-0514.txt#L357
         const hkcuArch = this.is64Bit ? undefined : Architecture.x86;
         const promises: Promise<CompanyInterpreter[]>[] = [
-            this.getCompanies(Hive.HKCU, hkcuArch),
-            this.getCompanies(Hive.HKLM, Architecture.x86)
+            this.getCompanies(RegistryHive.HKCU, hkcuArch),
+            this.getCompanies(RegistryHive.HKLM, Architecture.x86)
         ];
         // https://github.com/Microsoft/PTVS/blob/ebfc4ca8bab234d453f15ee426af3b208f3c143c/Python/Product/Cookiecutter/Shared/Interpreters/PythonRegistrySearch.cs#L44
         if (this.is64Bit) {
-            promises.push(this.getCompanies(Hive.HKLM, Architecture.x64));
+            promises.push(this.getCompanies(RegistryHive.HKLM, Architecture.x64));
         }
 
         const companies = await Promise.all<CompanyInterpreter[]>(promises);
@@ -65,19 +65,19 @@ export class WindowsRegistryService implements IInterpreterLocatorService {
                 return prev;
             }, []);
     }
-    private async getCompanies(hive: Hive, arch?: Architecture): Promise<CompanyInterpreter[]> {
+    private async getCompanies(hive: RegistryHive, arch?: Architecture): Promise<CompanyInterpreter[]> {
         return this.registry.getKeys('\\Software\\Python', hive, arch)
             .then(companyKeys => companyKeys
                 .filter(companyKey => CompaniesToIgnore.indexOf(path.basename(companyKey).toUpperCase()) === -1)
                 .map(companyKey => {
                     return { companyKey, hive, arch };
                 }));
     }
-    private async getInterpretersForCompany(companyKey: string, hive: Hive, arch?: Architecture) {
+    private async getInterpretersForCompany(companyKey: string, hive: RegistryHive, arch?: Architecture) {
         const tagKeys = await this.registry.getKeys(companyKey, hive, arch);
         return Promise.all(tagKeys.map(tagKey => this.getInreterpreterDetailsForCompany(tagKey, companyKey, hive, arch)));
     }
-    private getInreterpreterDetailsForCompany(tagKey: string, companyKey: string, hive: Hive, arch?: Architecture): Promise<PythonInterpreter | undefined | null> {
+    private getInreterpreterDetailsForCompany(tagKey: string, companyKey: string, hive: RegistryHive, arch?: Architecture): Promise<PythonInterpreter | undefined | null> {
         const key = `${tagKey}\\InstallPath`;
         type InterpreterInformation = null | undefined | {
             installPath: string,
@@ -133,13 +133,13 @@ export class WindowsRegistryService implements IInterpreterLocatorService {
                 return null;
             });
     }
-    private async getInterpreterDisplayName(tagKey: string, companyKey: string, hive: Hive, arch?: Architecture) {
+    private async getInterpreterDisplayName(tagKey: string, companyKey: string, hive: RegistryHive, arch?: Architecture) {
         const displayName = await this.registry.getValue(tagKey, hive, arch, 'DisplayName');
         if (displayName && displayName.length > 0) {
             return displayName;
         }
     }
-    private async  getCompanyDisplayName(companyKey: string, hive: Hive, arch?: Architecture) {
+    private async  getCompanyDisplayName(companyKey: string, hive: RegistryHive, arch?: Architecture) {
         const displayName = await this.registry.getValue(companyKey, hive, arch, 'DisplayName');
         if (displayName && displayName.length > 0) {
             return displayName;

src/client/linters/errorHandlers/main.ts

@@ -7,17 +7,17 @@ import { ModuleNotInstalledErrorHandler } from './notInstalled';
 import { StandardErrorHandler } from './standard';
 
 export class ErrorHandler implements IErrorHandler {
-    private handlder: BaseErrorHandler;
+    private handler: BaseErrorHandler;
     constructor(product: Product, installer: IInstaller,
         helper: ILinterHelper, logger: ILogger,
         outputChannel: OutputChannel, serviceContainer: IServiceContainer) {
         // Create chain of handlers.
         const standardErrorHandler = new StandardErrorHandler(product, installer, helper, logger, outputChannel, serviceContainer);
-        this.handlder = new ModuleNotInstalledErrorHandler(product, installer, helper, logger, outputChannel, serviceContainer);
-        this.handlder.setNextHandler(standardErrorHandler);
+        this.handler = new ModuleNotInstalledErrorHandler(product, installer, helper, logger, outputChannel, serviceContainer);
+        this.handler.setNextHandler(standardErrorHandler);
     }
 
     public handleError(error: Error, resource: Uri, execInfo: ExecutionInfo): Promise<boolean> {
-        return this.handlder.handleError(error, resource, execInfo);
+        return this.handler.handleError(error, resource, execInfo);
     }
 }

src/test/common/common.test.ts

@@ -29,35 +29,41 @@ suite('ChildProc', () => {
     test('Stream Stdout', done => {
         const output: string[] = [];
         function handleOutput(data: string) {
-            output.push(data);
+            if (data.trim().length > 0) {
+                output.push(data.trim());
+            }
         }
         execPythonFile(undefined, 'python', ['-c', 'print(1)'], __dirname, false, handleOutput).then(() => {
             assert.equal(output.length, 1, 'Ouput length incorrect');
-            assert.equal(output[0], `1${EOL}`, 'Ouput value incorrect');
+            assert.equal(output[0], '1', 'Ouput value incorrect');
         }).then(done).catch(done);
     });
 
     test('Stream Stdout (Unicode)', async () => {
         const output: string[] = [];
         function handleOutput(data: string) {
-            output.push(data);
+            if (data.trim().length > 0) {
+                output.push(data.trim());
+            }
         }
         await execPythonFile(undefined, 'python', ['-c', 'print(\'öä\')'], __dirname, false, handleOutput);
         assert.equal(output.length, 1, 'Ouput length incorrect');
-        assert.equal(output[0], `öä${EOL}`, 'Ouput value incorrect');
+        assert.equal(output[0], 'öä', 'Ouput value incorrect');
     });
 
     test('Stream Stdout with Threads', function (done) {
         // tslint:disable-next-line:no-invalid-this
         this.timeout(6000);
         const output: string[] = [];
         function handleOutput(data: string) {
-            output.push(data);
+            if (data.trim().length > 0) {
+                output.push(data.trim());
+            }
         }
         execPythonFile(undefined, 'python', ['-c', 'import sys\nprint(1)\nsys.__stdout__.flush()\nimport time\ntime.sleep(5)\nprint(2)'], __dirname, false, handleOutput).then(() => {
             assert.equal(output.length, 2, 'Ouput length incorrect');
-            assert.equal(output[0], `1${EOL}`, 'First Ouput value incorrect');
-            assert.equal(output[1], `2${EOL}`, 'Second Ouput value incorrect');
+            assert.equal(output[0], '1', 'First Ouput value incorrect');
+            assert.equal(output[1], '2', 'Second Ouput value incorrect');
         }).then(done).catch(done);
     });
 
@@ -66,7 +72,9 @@ suite('ChildProc', () => {
         const def = createDeferred<any>();
         const output: string[] = [];
         function handleOutput(data: string) {
-            output.push(data);
+            if (data.trim().length > 0) {
+                output.push(data.trim());
+            }
         }
         const cancellation = new vscode.CancellationTokenSource();
         execPythonFile(undefined, 'python', ['-c', 'import sys\nprint(1)\nsys.__stdout__.flush()\nimport time\ntime.sleep(5)\nprint(2)'], __dirname, false, handleOutput, cancellation.token).then(() => {

src/test/interpreters/mocks.ts

@@ -1,4 +1,4 @@
-import { Architecture, Hive, IRegistry } from '../../client/common/platform/types';
+import { Architecture, IRegistry, RegistryHive } from '../../client/common/platform/types';
 import { IProcessService } from '../../client/common/process/types';
 import { IInterpreterLocatorService, IInterpreterVersionService, InterpreterType, PythonInterpreter } from '../../client/interpreter/contracts';
 import { CondaLocatorService } from '../../client/interpreter/locators/services/condaLocator';
@@ -15,10 +15,10 @@ export class MockProvider implements IInterpreterLocatorService {
 }
 
 export class MockRegistry implements IRegistry {
-    constructor(private keys: { key: string, hive: Hive, arch?: Architecture, values: string[] }[],
-        private values: { key: string, hive: Hive, arch?: Architecture, value: string, name?: string }[]) {
+    constructor(private keys: { key: string, hive: RegistryHive, arch?: Architecture, values: string[] }[],
+        private values: { key: string, hive: RegistryHive, arch?: Architecture, value: string, name?: string }[]) {
     }
-    public async getKeys(key: string, hive: Hive, arch?: Architecture): Promise<string[]> {
+    public async getKeys(key: string, hive: RegistryHive, arch?: Architecture): Promise<string[]> {
         const items = this.keys.find(item => {
             if (typeof item.arch === 'number') {
                 return item.key === key && item.hive === hive && item.arch === arch;
@@ -28,7 +28,7 @@ export class MockRegistry implements IRegistry {
 
         return items ? Promise.resolve(items.values) : Promise.resolve([]);
     }
-    public async getValue(key: string, hive: Hive, arch?: Architecture, name?: string): Promise<string | undefined | null> {
+    public async getValue(key: string, hive: RegistryHive, arch?: Architecture, name?: string): Promise<string | undefined | null> {
         const items = this.values.find(item => {
             if (item.key !== key || item.hive !== hive) {
                 return false;