Sketch out formatter for R extension

extensions/positron-r/src/commands.ts

@@ -4,8 +4,9 @@
 
 import * as vscode from 'vscode';
 import * as positron from 'positron';
-import { delay } from './util';
+import { timeout } from './util';
 import { RRuntime } from './runtime';
+import { getRunningRRuntime } from './provider';
 import { getRPackageName } from './contexts';
 import { getRPackageTasks } from './tasks';
 import { randomUUID } from 'crypto';
@@ -56,57 +57,40 @@ export async function registerCommands(context: vscode.ExtensionContext, runtime
 			const packageName = await getRPackageName();
 			const tasks = await getRPackageTasks();
 			const task = tasks.filter(task => task.definition.task === 'r.task.packageInstall')[0];
-			const runningRuntimes = await positron.runtime.getRunningRuntimes('r');
-			if (!runningRuntimes || !runningRuntimes.length) {
-				vscode.window.showWarningMessage('Cannot install package as there is no R interpreter running.');
-				return;
-			}
-			// For now, there will be only one running R runtime:
-			const runtime = runtimes.get(runningRuntimes[0].runtimeId);
-
-			if (runtime) {
-				const execution = await vscode.tasks.executeTask(task);
-				const disp1 = vscode.tasks.onDidEndTaskProcess(async e => {
-					if (e.execution === execution) {
-						if (e.exitCode === 0) {
-							vscode.commands.executeCommand('workbench.panel.positronConsole.focus');
-							try {
-								await positron.runtime.restartLanguageRuntime(runtime.metadata.runtimeId);
-							} catch {
-								// If restarting promise rejects, dispose of listener:
-								disp1.dispose();
-							}
-
-							// A promise that resolves when the runtime is ready:
-							const promise = new Promise<void>(resolve => {
-								const disp2 = runtime.onDidChangeRuntimeState(runtimeState => {
-									if (runtimeState === positron.RuntimeState.Ready) {
-										resolve();
-										disp2.dispose();
-									}
-								});
-							});
+			const runtime = await getRunningRRuntime(runtimes);
+
+			const execution = await vscode.tasks.executeTask(task);
+			const disp1 = vscode.tasks.onDidEndTaskProcess(async e => {
+				if (e.execution === execution) {
+					if (e.exitCode === 0) {
+						vscode.commands.executeCommand('workbench.panel.positronConsole.focus');
+						try {
+							await positron.runtime.restartLanguageRuntime(runtime.metadata.runtimeId);
+						} catch {
+							// If restarting promise rejects, dispose of listener:
+							disp1.dispose();
+						}
 
-							// A promise that rejects after a timeout;
-							const timeout = new Promise<void>((_, reject) => {
-								setTimeout(() => {
-									reject(new Error('Timed out after 10 seconds waiting for R to be ready.'));
-								}, 1e4);
+						// A promise that resolves when the runtime is ready:
+						const promise = new Promise<void>(resolve => {
+							const disp2 = runtime.onDidChangeRuntimeState(runtimeState => {
+								if (runtimeState === positron.RuntimeState.Ready) {
+									resolve();
+									disp2.dispose();
+								}
 							});
-
-							// Wait for the the runtime to be ready, or for the timeout:
-							await Promise.race([promise, timeout]);
-							runtime.execute(`library(${packageName})`,
-								randomUUID(),
-								positron.RuntimeCodeExecutionMode.Interactive,
-								positron.RuntimeErrorBehavior.Continue);
-						}
-						disp1.dispose();
+						});
+
+						// Wait for the the runtime to be ready, or for a timeout:
+						await Promise.race([promise, timeout(1e4, 'waiting for R to be ready')]);
+						runtime.execute(`library(${packageName})`,
+							randomUUID(),
+							positron.RuntimeCodeExecutionMode.Interactive,
+							positron.RuntimeErrorBehavior.Continue);
 					}
-				});
-			} else {
-				throw new Error(`R runtime '${runningRuntimes[0].runtimeId}' is not registered in the extension host`);
-			}
+					disp1.dispose();
+				}
+			});
 		}),
 
 		vscode.commands.registerCommand('r.packageTest', () => {

extensions/positron-r/src/extension.ts

@@ -6,6 +6,7 @@ import * as vscode from 'vscode';
 import * as positron from 'positron';
 
 import { registerCommands } from './commands';
+import { registerFormatter } from './formatting';
 import { providePackageTasks } from './tasks';
 import { setContexts } from './contexts';
 import { discoverTests } from './testing';
@@ -29,6 +30,9 @@ export function activate(context: vscode.ExtensionContext) {
 	// Register commands.
 	registerCommands(context, runtimes);
 
+	// Register formatter.
+	registerFormatter(context, runtimes);
+
 	// Provide tasks.
 	providePackageTasks(context);
 

extensions/positron-r/src/formatting.ts

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (C) 2023 Posit Software, PBC. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import * as positron from 'positron';
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs';
+import { RRuntime, lastRuntimePath } from './runtime';
+import { getRunningRRuntime } from './provider';
+import { timeout } from './util';
+import { randomUUID } from 'crypto';
+
+export async function registerFormatter(context: vscode.ExtensionContext, runtimes: Map<string, RRuntime>) {
+
+	const rDocumentSelector = { scheme: 'file', language: 'r' } as vscode.DocumentSelector;
+
+	context.subscriptions.push(
+		vscode.languages.registerDocumentFormattingEditProvider(
+			rDocumentSelector,
+			new FormatterProvider(runtimes)
+		)
+	);
+}
+
+class FormatterProvider implements vscode.DocumentFormattingEditProvider {
+	constructor(public runtimes: Map<string, RRuntime>) { }
+
+	public provideDocumentFormattingEdits(document: vscode.TextDocument):
+		vscode.ProviderResult<vscode.TextEdit[]> {
+		return this.formatDocument(document, this.runtimes);
+	}
+
+	private async formatDocument(
+		document: vscode.TextDocument,
+		runtimes: Map<string, RRuntime>
+	): Promise<vscode.TextEdit[]> {
+		if (!lastRuntimePath) {
+			throw new Error(`No running R runtime to provide R package tasks.`);
+		}
+
+		const runtime = await getRunningRRuntime(runtimes);
+		const id = randomUUID();
+
+		// We can only use styler on files right now, so write the document to a temp file
+		const originalSource = document.getText();
+		const tempdir = os.tmpdir();
+		const fileToStyle = path.basename(document.fileName);
+		const stylerFile = path.join(tempdir, `styler-${fileToStyle}`);
+		fs.writeFileSync(stylerFile, originalSource);
+
+		// A promise that resolves when the runtime is idle:
+		const promise = new Promise<void>(resolve => {
+			const disp = runtime.onDidReceiveRuntimeMessage(runtimeMessage => {
+				if (runtimeMessage.parent_id === id &&
+					runtimeMessage.type === positron.LanguageRuntimeMessageType.State) {
+					const runtimeMessageState = runtimeMessage as positron.LanguageRuntimeState;
+					if (runtimeMessageState.state === positron.RuntimeOnlineState.Idle) {
+						resolve();
+						disp.dispose();
+					}
+				}
+			});
+		});
+
+		// Actual formatting is done by styler
+		runtime.execute(
+			`styler::style_file('${stylerFile}')`,
+			id,
+			positron.RuntimeCodeExecutionMode.Silent,
+			positron.RuntimeErrorBehavior.Continue);
+
+		// Wait for the the runtime to be idle, or for the timeout:
+		await Promise.race([promise, timeout(2e4, 'waiting for formatting')]);
+
+		// Read the now formatted file and then delete it
+		const formattedSource = fs.readFileSync(stylerFile).toString();
+		fs.promises.unlink(stylerFile);
+
+		// Return the formatted source
+		const fileStart = new vscode.Position(0, 0);
+		const fileEnd = document.lineAt(document.lineCount - 1).range.end;
+		return [new vscode.TextEdit(new vscode.Range(fileStart, fileEnd), formattedSource)];
+	}
+}

extensions/positron-r/src/lsp.ts

@@ -4,7 +4,7 @@
 
 import * as vscode from 'vscode';
 import * as positron from 'positron';
-import { PromiseHandles } from './util';
+import { PromiseHandles, timeout } from './util';
 import { RStatementRangeProvider } from './statement-range';
 
 import {
@@ -187,15 +187,8 @@ export class ArkLsp implements vscode.Disposable {
 				this._client!.stop();
 			});
 
-		// Don't wait more than a couple of seconds for the client to stop.
-		const timeout = new Promise<void>((_, reject) => {
-			setTimeout(() => {
-				reject(`Timed out after 2 seconds waiting for client to stop.`);
-			}, 2000);
-		});
-
-		// Wait for the client to enter the stopped state, or for the timeout
-		await Promise.race([promise, timeout]);
+		// Don't wait more than a couple of seconds for the client to stop
+		await Promise.race([promise, timeout(2000, 'waiting for client to stop')]);
 	}
 
 	/**

extensions/positron-r/src/provider.ts

@@ -277,6 +277,20 @@ export async function* rRuntimeProvider(
 	}
 }
 
+
+export async function getRunningRRuntime(runtimes: Map<string, RRuntime>): Promise<RRuntime> {
+	const runningRuntimes = await positron.runtime.getRunningRuntimes('r');
+	if (!runningRuntimes || !runningRuntimes.length) {
+		throw new Error('Cannot get running runtime as there is no R interpreter running.');
+	}
+	// For now, there will be only one running R runtime:
+	const runtime = runtimes.get(runningRuntimes[0].runtimeId);
+	if (!runtime) {
+		throw new Error(`R runtime '${runningRuntimes[0].runtimeId}' is not registered in the extension host`);
+	}
+	return runtime;
+}
+
 // directory where this OS is known to keep its R installations
 function rHeadquarters(): string {
 	switch (process.platform) {

extensions/positron-r/src/util.ts

@@ -21,6 +21,11 @@ export function delay(ms: number) {
 	return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+export function timeout(ms: number, reason: string) {
+	return new Promise((_, reject) => {
+		setTimeout(() => reject(`Timeout while ${reason}`), ms);
+	});
+}
 
 export function readLines(pth: string): Array<string> {
 	const bigString = fs.readFileSync(pth, 'utf8');