refactor jupyter changes #757

Author: DonJayamanne

src/client/jupyter/common/constants.ts

@@ -0,0 +1,31 @@
+
+export const PythonLanguage = { language: 'python', scheme: 'file' };
+
+export namespace Commands {
+    export namespace Jupyter {
+        export const Get_All_KernelSpecs_For_Language = 'jupyter.getAllKernelSpecsForLanguage';
+        export const Get_All_KernelSpecs = 'jupyter.getAllKernelSpecs';
+        export const Kernel_Options = 'jupyter.kernelOptions';
+        export const StartKernelForKernelSpeck = 'jupyter.sartKernelForKernelSpecs';
+        export const ExecuteRangeInKernel = 'jupyter.execRangeInKernel';
+        export const ExecuteSelectionOrLineInKernel = 'jupyter.runSelectionLine';
+        export namespace Cell {
+            export const ExecuteCurrentCell = 'jupyter.execCurrentCell';
+            export const ExecuteCurrentCellAndAdvance = 'jupyter.execCurrentCellAndAdvance';
+            export const AdcanceToCell = 'jupyter.advanceToNextCell';
+            export const DisplayCellMenu = 'jupyter.displayCellMenu';
+            export const GoToPreviousCell = 'jupyter.gotToPreviousCell';
+            export const GoToNextCell = 'jupyter.gotToNextCell';
+        }
+        export namespace Kernel {
+            export const Select = 'jupyter.selectKernel';
+            export const Interrupt = 'jupyter.kernelInterrupt';
+            export const Restart = 'jupyter.kernelRestart';
+            export const Shutdown = 'jupyter.kernelShutDown';
+            export const Details = 'jupyter.kernelDetails';
+        }
+        export namespace Notebook {
+            export const ShutDown = 'jupyter.shutdown';
+        }
+    }
+}

src/client/jupyter/common/contracts.ts

@@ -0,0 +1,12 @@
+
+export interface JupyterSettings {
+    appendResults: boolean;
+    pythonPath: string;
+    languages: JupyterLanguageSetting[];
+}
+
+export interface JupyterLanguageSetting {
+    languageId: string;
+    defaultKernel?: string;
+    startupCode?: string[];
+}

src/client/jupyter/common/languageProvider.ts

@@ -0,0 +1,89 @@
+import { Range, Position, TextDocument, workspace } from 'vscode';
+import { JupyterLanguageSetting } from './contracts';
+import { EOL } from 'os';
+
+/**
+ * Language providers 
+ * 
+ * @export
+ * @interface LanguageProvider
+ */
+export interface LanguageProvider {
+    /**
+     * Returns a Regular Expression used to determine whether a line is a Cell delimiter or not
+     * 
+     * @type {RegExp}
+     * @memberOf LanguageProvider
+     */
+    cellIdentifier: RegExp;
+
+    /**
+     * Returns the selected code
+     * If not implemented, then the currently active line or selected code is taken.
+     * Can be implemented to ensure valid blocks of code are selected.
+     * E.g if user selects only the If statement, code can be impelemented to ensure all code within the if statement (block) is returned
+     * @param {string} selectedCode The selected code as identified by this extension.
+     * @param {Range} [currentCell] Range of the currently active cell
+     * @returns {Promise<string>} The code selected. If nothing is to be done, return the parameter value.
+     * 
+     * @memberOf LanguageProvider
+     */
+    getSelectedCode(selectedCode: string, currentCell?: Range): Promise<string>;
+
+    /**
+     * Gets the first line (position) of executable code within a range 
+     * 
+     * @param {TextDocument} document
+     * @param {number} startLine
+     * @param {number} endLine
+     * @returns {Promise<Position>}
+     * 
+     * @memberOf LanguageProvider
+     */
+    getFirstLineOfExecutableCode(document: TextDocument, range: Range): Promise<Position>;
+}
+
+export class LanguageProviders {
+    private static providers: Map<string, LanguageProvider> = new Map<string, LanguageProvider>();
+    public static registerLanguageProvider(language: string, provider: LanguageProvider) {
+        if (typeof language !== 'string' || language.length === 0) {
+            throw new Error(`Argument 'language' is invalid`);
+        }
+        if (typeof provider !== 'object' || language === null) {
+            throw new Error(`Argument 'provider' is invalid`);
+        }
+        LanguageProviders.providers.set(language, provider);
+    }
+    public static cellIdentifier(language: string): RegExp {
+        return LanguageProviders.providers.has(language) ?
+            LanguageProviders.providers.get(language).cellIdentifier : null;
+    }
+    public static getSelectedCode(language: string, selectedCode: string, currentCell?: Range): Promise<string> {
+        return LanguageProviders.providers.has(language) ?
+            LanguageProviders.providers.get(language).getSelectedCode(selectedCode, currentCell) :
+            Promise.resolve(selectedCode);
+    }
+    public static getFirstLineOfExecutableCode(language: string, defaultRange: Range, document: TextDocument, range: Range): Promise<Position> | Promise<Range> {
+        return LanguageProviders.providers.has(language) ?
+            LanguageProviders.providers.get(language).getFirstLineOfExecutableCode(document, range) :
+            Promise.resolve(defaultRange);
+    }
+    private static getLanguageSetting(language: string): JupyterLanguageSetting {
+        let jupyterConfig = workspace.getConfiguration('jupyter');
+        let langSettings = jupyterConfig.get('languages') as JupyterLanguageSetting[];
+        let lowerLang = language.toLowerCase();
+        return langSettings.find(setting => setting.languageId.toLowerCase() === lowerLang);
+    }
+
+    public static getDefaultKernel(language: string): string {
+        let langSetting = LanguageProviders.getLanguageSetting(language);
+        return langSetting ? langSetting.defaultKernel : null;
+    }
+    public static getStartupCode(language: string): string {
+        let langSetting = LanguageProviders.getLanguageSetting(language);
+        if (!langSetting || langSetting.startupCode.length === 0) {
+            return null;
+        }
+        return langSetting.startupCode.join(EOL);
+    }
+} 

src/client/jupyter/common/utils.ts

@@ -0,0 +1,80 @@
+
+'use strict';
+// TODO: Cleanup this place
+// Add options for execPythonFile
+import * as path from 'path';
+import * as fs from 'fs';
+
+export const IS_WINDOWS = /^win/.test(process.platform);
+export const PATH_VARIABLE_NAME = IS_WINDOWS ? 'Path' : 'PATH';
+
+const PathValidity: Map<string, boolean> = new Map<string, boolean>();
+export function validatePath(filePath: string): Promise<string> {
+    if (filePath.length === 0) {
+        return Promise.resolve('');
+    }
+    if (PathValidity.has(filePath)) {
+        return Promise.resolve(PathValidity.get(filePath) ? filePath : '');
+    }
+    return new Promise<string>(resolve => {
+        fs.exists(filePath, exists => {
+            PathValidity.set(filePath, exists);
+            return resolve(exists ? filePath : '');
+        });
+    });
+}
+export function fsExistsAsync(filePath: string): Promise<boolean> {
+    return new Promise<boolean>(resolve => {
+        fs.exists(filePath, exists => {
+            PathValidity.set(filePath, exists);
+            return resolve(exists);
+        });
+    });
+}
+
+export function formatErrorForLogging(error: Error | string): string {
+    let message: string = '';
+    if (typeof error === 'string') {
+        message = error;
+    }
+    else {
+        if (error.message) {
+            message = `Error Message: ${error.message}`;
+        }
+        if (error.name && error.message.indexOf(error.name) === -1) {
+            message += `, (${error.name})`;
+        }
+        const innerException = (error as any).innerException;
+        if (innerException && (innerException.message || innerException.name)) {
+            if (innerException.message) {
+                message += `, Inner Error Message: ${innerException.message}`;
+            }
+            if (innerException.name && innerException.message.indexOf(innerException.name) === -1) {
+                message += `, (${innerException.name})`;
+            }
+        }
+    }
+    return message;
+}
+
+export function getSubDirectories(rootDir: string): Promise<string[]> {
+    return new Promise<string[]>(resolve => {
+        fs.readdir(rootDir, (error, files) => {
+            if (error) {
+                return resolve([]);
+            }
+            const subDirs = [];
+            files.forEach(name => {
+                const fullPath = path.join(rootDir, name);
+                try {
+                    if (fs.statSync(fullPath).isDirectory()) {
+                        subDirs.push(fullPath);
+                    }
+                }
+                catch (ex) {
+                }
+            });
+            resolve(subDirs);
+        });
+    });
+}