Merge remote-tracking branch 'upstream/master'

* upstream/master:
  Refactor parsing of environment variables (after 439) (#466)
  Refactor extension to remove old way of spawning python processes (#439)

Author: DonJayamanne

gulpfile.js

@@ -309,7 +309,7 @@ function getFilesToProcess(options) {
     // If we need only modified files, then filter the glob.
     if (options && options.mode === 'changes') {
         return gulp.src(all, gulpSrcOptions)
-            .pipe(gitmodified('M', 'A', 'D', 'R', 'C', 'U', '??'));
+            .pipe(gitmodified(['M', 'A', 'D', 'R', 'C', 'U', '??']));
     }
 
     if (options && options.mode === 'staged') {

package-lock.json

@@ -1559,6 +1559,7 @@
 		"@types/mocha": "^2.2.43",
 		"@types/node": "^6.0.40",
 		"@types/semver": "^5.4.0",
+		"@types/shortid": "0.0.29",
 		"@types/sinon": "^2.3.2",
 		"@types/uuid": "^3.3.27",
 		"@types/winreg": "^1.2.30",
@@ -1578,6 +1579,7 @@
 		"mocha": "^2.3.3",
 		"relative": "^3.0.2",
 		"retyped-diff-match-patch-tsd-ambient": "^1.0.0-0",
+		"shortid": "^2.2.8",
 		"sinon": "^2.3.6",
 		"tslint": "^5.7.0",
 		"tslint-eslint-rules": "^4.1.1",

package.json

@@ -5,7 +5,6 @@ import { EventEmitter } from 'events';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import { Uri } from 'vscode';
-import { InterpreterInfoCache } from './interpreterInfoCache';
 import { SystemVariables } from './variables/systemVariables';
 
 // tslint:disable-next-line:no-require-imports no-var-requires
@@ -188,12 +187,10 @@ export class PythonSettings extends EventEmitter implements IPythonSettings {
         // tslint:disable-next-line:no-unsafe-any
         this.disposables.forEach(disposable => disposable.dispose());
         this.disposables = [];
-        InterpreterInfoCache.clear();
     }
 
     // tslint:disable-next-line:cyclomatic-complexity max-func-body-length
     private initializeSettings() {
-        InterpreterInfoCache.clear();
         const workspaceRoot = this.workspaceRoot.fsPath;
         const systemVariables: SystemVariables = new SystemVariables(this.workspaceRoot ? this.workspaceRoot.fsPath : undefined);
         const pythonSettings = vscode.workspace.getConfiguration('python', this.workspaceRoot);

src/client/common/configSettings.ts

@@ -0,0 +1,47 @@
+import * as _ from 'lodash';
+
+type AsyncVoidAction = (...params: {}[]) => Promise<void>;
+type VoidAction = (...params: {}[]) => void;
+
+/**
+ * Debounces a function execution. Function must return either a void or a promise that resolves to a void.
+ * @export
+ * @param {number} [wait] Wait time.
+ * @returns void
+ */
+export function debounce(wait?: number) {
+    // tslint:disable-next-line:no-any no-function-expression
+    return function (_target: any, _propertyName: string, descriptor: TypedPropertyDescriptor<VoidAction> | TypedPropertyDescriptor<AsyncVoidAction>) {
+        const originalMethod = descriptor.value!;
+        // tslint:disable-next-line:no-invalid-this no-any
+        (descriptor as any).value = _.debounce(function () { return originalMethod.apply(this, arguments); }, wait);
+    };
+}
+
+/**
+ * Swallows exceptions thrown by a function. Function must return either a void or a promise that resolves to a void.
+ * @export
+ * @param {string} [scopeName] Scope for the error message to be logged along with the error.
+ * @returns void
+ */
+export function swallowExceptions(scopeName: string) {
+    // tslint:disable-next-line:no-any no-function-expression
+    return function (_target: any, propertyName: string, descriptor: TypedPropertyDescriptor<VoidAction> | TypedPropertyDescriptor<AsyncVoidAction>) {
+        const originalMethod = descriptor.value!;
+        const errorMessage = `Python Extension (Error in ${scopeName}, method:${propertyName}):`;
+        // tslint:disable-next-line:no-any no-function-expression
+        descriptor.value = function (...args: any[]) {
+            try {
+                // tslint:disable-next-line:no-invalid-this no-use-before-declare no-unsafe-any
+                const result = originalMethod.apply(this, args);
+
+                // If method being wrapped returns a promise then wait and swallow errors.
+                if (result && typeof result.then === 'function' && typeof result.catch === 'function') {
+                    return (result as Promise<void>).catch(error => console.error(errorMessage, error));
+                }
+            } catch (error) {
+                console.error(errorMessage, error);
+            }
+        };
+    };
+}

src/client/common/decorators.ts

@@ -0,0 +1,10 @@
+import { injectable } from 'inversify';
+import { ICurrentProcess } from '../types';
+import { EnvironmentVariables } from '../variables/types';
+
+@injectable()
+export class CurrentProcess implements ICurrentProcess {
+    public get env(): EnvironmentVariables {
+        return process.env;
+    }
+}

src/client/common/interpreterInfoCache.ts

@@ -14,7 +14,7 @@ export class PythonExecutionFactory implements IPythonExecutionFactory {
         @inject(IEnvironmentVariablesProvider) private envVarsService: IEnvironmentVariablesProvider) { }
     public async create(resource?: Uri): Promise<IPythonExecutionService> {
         const settings = PythonSettings.getInstance(resource);
-        return this.envVarsService.getEnvironmentVariables(true, resource)
+        return this.envVarsService.getEnvironmentVariables(resource)
             .then(customEnvVars => {
                 return new PythonExecutionService(this.procService, settings.pythonPath, customEnvVars);
             });

src/client/common/process/currentProcess.ts

@@ -12,9 +12,10 @@ import { IS_64_BIT, IS_WINDOWS } from './platform/constants';
 import { PathUtils } from './platform/pathUtils';
 import { RegistryImplementation } from './platform/registry';
 import { IRegistry } from './platform/types';
+import { CurrentProcess } from './process/currentProcess';
 import { TerminalService } from './terminal/service';
 import { ITerminalService } from './terminal/types';
-import { IInstaller, ILogger, IPathUtils, IPersistentStateFactory, Is64Bit, IsWindows } from './types';
+import { ICurrentProcess, IInstaller, ILogger, IPathUtils, IPersistentStateFactory, Is64Bit, IsWindows } from './types';
 
 export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingletonInstance<boolean>(IsWindows, IS_WINDOWS);
@@ -27,6 +28,7 @@ export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingleton<ILogger>(ILogger, Logger);
     serviceManager.addSingleton<ITerminalService>(ITerminalService, TerminalService);
     serviceManager.addSingleton<IPathUtils>(IPathUtils, PathUtils);
+    serviceManager.addSingleton<ICurrentProcess>(ICurrentProcess, CurrentProcess);
 
     if (IS_WINDOWS) {
         serviceManager.addSingleton<IRegistry>(IRegistry, RegistryImplementation);

src/client/common/process/pythonExecutionFactory.ts

@@ -3,6 +3,7 @@
 // Licensed under the MIT License.
 
 import { Uri } from 'vscode';
+import { EnvironmentVariables } from './variables/types';
 export const IOutputChannel = Symbol('IOutputChannel');
 export const IDocumentSymbolProvider = Symbol('IDocumentSymbolProvider');
 export const IsWindows = Symbol('IS_WINDOWS');
@@ -80,3 +81,8 @@ export const IPathUtils = Symbol('IPathUtils');
 export interface IPathUtils {
     getPathVariableName(): 'Path' | 'PATH';
 }
+
+export const ICurrentProcess = Symbol('ICurrentProcess');
+export interface ICurrentProcess {
+    env: EnvironmentVariables;
+}