fix #1280 handle env in shebang (DonJayamanne#1290)

* handle shebangs that resolve paths from env

* oops

* make test more specific

* handle promise

Author: DonJayamanne

src/client/providers/setInterpreterProvider.ts

@@ -63,8 +63,8 @@ export class SetInterpreterProvider implements vscode.Disposable {
         this.presentQuickPick();
     }
 
-    private setShebangInterpreter() {
-        const shebang = ShebangCodeLensProvider.detectShebang(vscode.window.activeTextEditor.document);
+    private async setShebangInterpreter() {
+        const shebang = await ShebangCodeLensProvider.detectShebang(vscode.window.activeTextEditor.document);
         if (shebang) {
             this.interpreterManager.setPythonPath(shebang);
         }

src/client/providers/shebangCodeLensProvider.ts

@@ -1,57 +1,72 @@
 "use strict";
-import * as vscode from 'vscode'
-import { TextDocument, CodeLens, CancellationToken } from 'vscode'
-
+import { IS_WINDOWS } from '../common/utils';
+import * as vscode from 'vscode';
+import * as child_process from 'child_process';
+import * as settings from '../common/configSettings';
+import { TextDocument, CodeLens, CancellationToken } from 'vscode';
+import { getFirstNonEmptyLineFromMultilineString } from '../interpreter/helpers';
 export class ShebangCodeLensProvider implements vscode.CodeLensProvider {
-    private settings;
-    
-    // reload codeLenses on every configuration change.
     onDidChangeCodeLenses: vscode.Event<void> = vscode.workspace.onDidChangeConfiguration;
 
-    public provideCodeLenses(document: TextDocument, token: CancellationToken): Thenable<CodeLens[]> {
-        this.settings = vscode.workspace.getConfiguration('python');
-        const codeLenses = this.createShebangCodeLens(document);
-
+    public async provideCodeLenses(document: TextDocument, token: CancellationToken): Promise<CodeLens[]> {
+        const codeLenses = await this.createShebangCodeLens(document);
         return Promise.resolve(codeLenses);
     }
 
-    private createShebangCodeLens(document: TextDocument) {
-        const shebang = ShebangCodeLensProvider.detectShebang(document)
-        if (!shebang || shebang === this.settings.get('pythonPath')) { 
-            // no shebang detected or interpreter is already set to shebang
-            return; 
+    private async createShebangCodeLens(document: TextDocument) {
+        const shebang = await ShebangCodeLensProvider.detectShebang(document);
+        if (!shebang || shebang === settings.PythonSettings.getInstance().pythonPath) {
+            return [];
         }
 
-        // create CodeLens
         const firstLine = document.lineAt(0);
         const startOfShebang = new vscode.Position(0, 0);
         const endOfShebang = new vscode.Position(0, firstLine.text.length - 1);
         const shebangRange = new vscode.Range(startOfShebang, endOfShebang);
-        
-        const cmd : vscode.Command = { 
-            command: 'python.setShebangInterpreter', 
+
+        const cmd: vscode.Command = {
+            command: 'python.setShebangInterpreter',
             title: 'Set as interpreter'
-        }
+        };
 
         const codeLenses = [(new CodeLens(shebangRange, cmd))];
         return codeLenses;
     }
 
-    public static detectShebang(document: TextDocument) {
-        let error = false;
-    
+    public static async detectShebang(document: TextDocument): Promise<string | undefined> {
         let firstLine = document.lineAt(0);
         if (firstLine.isEmptyOrWhitespace) {
-            error = true;
+            return;
+        }
+
+        if (!firstLine.text.startsWith('#!')) {
+            return;
         }
-    
-        if (!error && "#!" === firstLine.text.substr(0, 2)) {
-            // Shebang detected
-            const shebang = firstLine.text.substr(2).trim();
-            return shebang;
+
+        const shebang = firstLine.text.substr(2).trim();
+        const pythonPath = await ShebangCodeLensProvider.getFullyQualifiedPathToInterpreter(shebang);
+        return typeof pythonPath === 'string' && pythonPath.length > 0 ? pythonPath : undefined;
+    }
+    private static async getFullyQualifiedPathToInterpreter(pythonPath: string) {
+        if (pythonPath.indexOf('bin/env ') >= 0 && !IS_WINDOWS) {
+            // In case we have pythonPath as '/usr/bin/env python'            
+            return new Promise<string>(resolve => {
+                const command = child_process.exec(`${pythonPath} -c 'import sys;print(sys.executable)'`);
+                let result = '';
+                command.stdout.on('data', (data) => {
+                    result += data.toString();
+                });
+                command.on('close', () => {
+                    resolve(getFirstNonEmptyLineFromMultilineString(result));
+                });
+            });
+        }
+        else {
+            return new Promise<string>(resolve => {
+                child_process.execFile(pythonPath, ["-c", "import sys;print(sys.executable)"], (_, stdout) => {
+                    resolve(getFirstNonEmptyLineFromMultilineString(stdout));
+                });
+            });
         }
-    
-        return null;
     }
-
 }

src/test/providers/shebangCodeLenseProvider.test.ts

@@ -1,56 +1,85 @@
 import * as assert from 'assert';
 import * as path from 'path';
 import * as vscode from 'vscode';
-import { ShebangCodeLensProvider } from '../../client/providers/shebangCodeLensProvider'
+import * as child_process from 'child_process';
+import { IS_WINDOWS } from '../../client/common/configSettings';
+import { ShebangCodeLensProvider } from '../../client/providers/shebangCodeLensProvider';
 
 import { initialize, IS_TRAVIS, closeActiveWindows } from '../initialize';
+import { getFirstNonEmptyLineFromMultilineString } from '../../client/interpreter/helpers';
 
 const autoCompPath = path.join(__dirname, '..', '..', '..', 'src', 'test', 'pythonFiles', 'shebang');
 const fileShebang = path.join(autoCompPath, 'shebang.py');
+const fileShebangEnv = path.join(autoCompPath, 'shebangEnv.py');
+const fileShebangInvalid = path.join(autoCompPath, 'shebangInvalid.py');
 const filePlain = path.join(autoCompPath, 'plain.py');
 
-var settings = vscode.workspace.getConfiguration("python");
-const origPythonPath = settings.get("pythonPath");
+var settings = vscode.workspace.getConfiguration('python');
+const origPythonPath = settings.get('pythonPath');
 
-suite("Shebang detection", () => {
-    suiteSetup(async () => {
-        await initialize();
+suite('Shebang detection', () => {
+    suiteSetup(() => initialize());
+    suiteTeardown(() => vscode.workspace.getConfiguration('python').update('pythonPath', origPythonPath));
+    teardown(async () => {
+        await closeActiveWindows();
+        await vscode.workspace.getConfiguration('python').update('pythonPath', origPythonPath);
     });
 
-    suiteTeardown(async () => {
-        await vscode.workspace.getConfiguration("python").update("pythonPath", origPythonPath);
-    });
-
-    teardown(() => closeActiveWindows());
-    setup(() => {
-        settings = vscode.workspace.getConfiguration("python");
-    });
-
-    test("Shebang available, CodeLens showing", async () => {
-        await settings.update("pythonPath", "python");
+    test('Shebang available, CodeLens showing', async () => {
+        await settings.update('pythonPath', 'someUnknownInterpreter');
         const editor = await openFile(fileShebang);
         const codeLenses = await setupCodeLens(editor);
 
-        assert.equal(codeLenses.length, 1, "No CodeLens available");
+        assert.equal(codeLenses.length, 1, 'No CodeLens available');
         let codeLens = codeLenses[0];
         assert(codeLens.range.isSingleLine, 'Invalid CodeLens Range');
         assert.equal(codeLens.command.command, 'python.setShebangInterpreter');
 
     });
 
-    test("Shebang available, CodeLens hiding", async () => {
-        await settings.update("pythonPath", "/usr/bin/test");
+    test('Shebang available, CodeLens hiding', async () => {
+        const pythonPath = await getFullyQualifiedPathToInterpreter('python');
+        await settings.update('pythonPath', pythonPath);
         const editor = await openFile(fileShebang);
         const codeLenses = await setupCodeLens(editor);
-        assert(!codeLenses, "CodeLens available although interpreters are equal");
+        assert.equal(codeLenses.length, 0, 'CodeLens available although interpreters are equal');
 
     });
 
-    test("Shebang missing, CodeLens hiding", async () => {
-        const editor = await openFile(filePlain);
+    test('Shebang not available (invalid shebang)', async () => {
+        const pythonPath = await getFullyQualifiedPathToInterpreter('python');
+        await settings.update('pythonPath', pythonPath);
+        const editor = await openFile(fileShebangInvalid);
         const codeLenses = await setupCodeLens(editor);
-        assert(!codeLenses, "CodeLens available although no shebang");
+        assert.equal(codeLenses.length, 0, 'CodeLens available although shebang is invalid');
+    });
+
+    if (!IS_WINDOWS) {
+        test('Shebang available, CodeLens showing with env', async () => {
+            await settings.update('pythonPath', 'p1');
+            const editor = await openFile(fileShebangEnv);
+            const codeLenses = await setupCodeLens(editor);
 
+            assert.equal(codeLenses.length, 1, 'No CodeLens available');
+            let codeLens = codeLenses[0];
+            assert(codeLens.range.isSingleLine, 'Invalid CodeLens Range');
+            assert.equal(codeLens.command.command, 'python.setShebangInterpreter');
+
+        });
+
+        test('Shebang available, CodeLens hiding with env', async () => {
+            const pythonPath = await getFullyQualifiedPathToInterpreter('python');
+            await settings.update('pythonPath', pythonPath);
+            const editor = await openFile(fileShebangEnv);
+            const codeLenses = await setupCodeLens(editor);
+            assert.equal(codeLenses.length, 0, 'CodeLens available although interpreters are equal');
+        });
+    }
+
+    test('Shebang missing, CodeLens hiding', async () => {
+        const editor = await openFile(filePlain);
+        const codeLenses = await setupCodeLens(editor);
+        assert.equal(codeLenses.length, 0, 'CodeLens available although no shebang');
     });
 
     async function openFile(fileName: string) {
@@ -59,11 +88,18 @@ suite("Shebang detection", () => {
         assert(vscode.window.activeTextEditor, 'No active editor');
         return editor;
     }
+    async function getFullyQualifiedPathToInterpreter(pythonPath: string) {
+        return new Promise<string>(resolve => {
+            child_process.execFile(pythonPath, ['-c', 'import sys;print(sys.executable)'], (_, stdout) => {
+                resolve(getFirstNonEmptyLineFromMultilineString(stdout));
+            });
+        }).catch(() => undefined);
+    }
 
     async function setupCodeLens(editor: vscode.TextEditor) {
         const document = editor.document;
         const codeLensProvider = new ShebangCodeLensProvider();
         const codeLenses = await codeLensProvider.provideCodeLenses(document, null);
         return codeLenses;
     }
-});
+});

src/test/pythonFiles/shebang/shebang.py

@@ -1,3 +1,3 @@
-#!/usr/bin/test
+#!python
 
 print("dummy")

src/test/pythonFiles/shebang/shebangEnv.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+
+print("dummy")

src/test/pythonFiles/shebang/shebangInvalid.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env1234 python
+
+print("dummy")