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);
+ });
+ });
+}