Allow to run css language server headless

extensions/css-language-features/client/src/cssClient.ts

@@ -3,20 +3,29 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as fs from 'fs';
-import * as path from 'path';
-import { commands, CompletionItem, CompletionItemKind, ExtensionContext, languages, Position, Range, SnippetString, TextEdit, window, workspace, TextDocument, CompletionContext, CancellationToken, ProviderResult, CompletionList } from 'vscode';
-import { Disposable, LanguageClient, LanguageClientOptions, ServerOptions, TransportKind, ProvideCompletionItemsSignature } from 'vscode-languageclient';
+import { commands, CompletionItem, CompletionItemKind, ExtensionContext, languages, Position, Range, SnippetString, TextEdit, window, TextDocument, CompletionContext, CancellationToken, ProviderResult, CompletionList, extensions } from 'vscode';
+import { Disposable, LanguageClient, LanguageClientOptions, ServerOptions, TransportKind, ProvideCompletionItemsSignature, NotificationType } from 'vscode-languageclient';
 import * as nls from 'vscode-nls';
-import { getCustomDataPathsFromAllExtensions, getCustomDataPathsInAllWorkspaces } from './customData';
+import { getCustomDataSource } from './customData';
+import { RequestService, serveFileSystemRequests } from './requests';
+
+namespace CustomDataChangedNotification {
+	export const type: NotificationType<string[]> = new NotificationType('css/customDataChanged');
+}
 
 const localize = nls.loadMessageBundle();
 
-// this method is called when vs code is activated
-export function activate(context: ExtensionContext) {
+export function startClient(context: ExtensionContext, runtime: { fs?: RequestService }) {
 
-	let serverMain = readJSONFile(context.asAbsolutePath('./server/package.json')).main;
-	let serverModule = context.asAbsolutePath(path.join('server', serverMain));
+	const clientMain = extensions.getExtension('vscode.css-language-features')?.packageJSON?.main;
+	const serverMain = clientMain?.replace('client', 'server').replace('cssClientMain', 'cssServerMain');
+	if (!serverMain) {
+		throw new Error('Unable to compute CSS server module path. Client: ' + clientMain);
+	}
+
+	const serverModule = context.asAbsolutePath(serverMain);
+
+	const customDataSource = getCustomDataSource(context.subscriptions);
 
 	// The debug options for the server
 	let debugOptions = { execArgv: ['--nolazy', '--inspect=6044'] };
@@ -30,11 +39,6 @@ export function activate(context: ExtensionContext) {
 
 	let documentSelector = ['css', 'scss', 'less'];
 
-	let dataPaths = [
-		...getCustomDataPathsInAllWorkspaces(workspace.workspaceFolders),
-		...getCustomDataPathsFromAllExtensions()
-	];
-
 	// Options to control the language client
 	let clientOptions: LanguageClientOptions = {
 		documentSelector,
@@ -42,7 +46,7 @@ export function activate(context: ExtensionContext) {
 			configurationSection: ['css', 'scss', 'less']
 		},
 		initializationOptions: {
-			dataPaths
+			handledSchemas: ['file']
 		},
 		middleware: {
 			provideCompletionItem(document: TextDocument, position: Position, context: CompletionContext, token: CancellationToken, next: ProvideCompletionItemsSignature): ProviderResult<CompletionItem[] | CompletionList> {
@@ -84,6 +88,15 @@ export function activate(context: ExtensionContext) {
 	// Create the language client and start the client.
 	let client = new LanguageClient('css', localize('cssserver.name', 'CSS Language Server'), serverOptions, clientOptions);
 	client.registerProposedFeatures();
+	client.onReady().then(() => {
+
+		client.sendNotification(CustomDataChangedNotification.type, customDataSource.uris);
+		customDataSource.onDidChange(() => {
+			client.sendNotification(CustomDataChangedNotification.type, customDataSource.uris);
+		});
+
+		serveFileSystemRequests(client, runtime);
+	});
 
 	let disposable = client.start();
 	// Push the disposable to the context's subscriptions so that the
@@ -162,13 +175,3 @@ export function activate(context: ExtensionContext) {
 		}
 	}
 }
-
-function readJSONFile(location: string) {
-	try {
-		return JSON.parse(fs.readFileSync(location).toString());
-	} catch (e) {
-		console.log(`Problems reading ${location}: ${e}`);
-		return {};
-	}
-}
-

extensions/css-language-features/client/src/customData.ts

@@ -3,42 +3,78 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as path from 'path';
-import { workspace, WorkspaceFolder, extensions } from 'vscode';
+import { workspace, extensions, Uri, EventEmitter, Disposable } from 'vscode';
+import { resolvePath } from './requests';
 
-interface ExperimentalConfig {
-	customData?: string[];
-	experimental?: {
-		customData?: string[];
+export function getCustomDataSource(toDispose: Disposable[]) {
+	let pathsInWorkspace = getCustomDataPathsInAllWorkspaces();
+	let pathsInExtensions = getCustomDataPathsFromAllExtensions();
+
+	const onChange = new EventEmitter<void>();
+
+	toDispose.push(extensions.onDidChange(_ => {
+		const newPathsInExtensions = getCustomDataPathsFromAllExtensions();
+		if (newPathsInExtensions.length !== pathsInExtensions.length || !newPathsInExtensions.every((val, idx) => val === pathsInExtensions[idx])) {
+			pathsInExtensions = newPathsInExtensions;
+			onChange.fire();
+		}
+	}));
+	toDispose.push(workspace.onDidChangeConfiguration(e => {
+		if (e.affectsConfiguration('css.customData')) {
+			pathsInWorkspace = getCustomDataPathsInAllWorkspaces();
+			onChange.fire();
+		}
+	}));
+
+	return {
+		get uris() {
+			return pathsInWorkspace.concat(pathsInExtensions);
+		},
+		get onDidChange() {
+			return onChange.event;
+		}
 	};
 }
 
-export function getCustomDataPathsInAllWorkspaces(workspaceFolders: readonly WorkspaceFolder[] | undefined): string[] {
+
+function getCustomDataPathsInAllWorkspaces(): string[] {
+	const workspaceFolders = workspace.workspaceFolders;
+
 	const dataPaths: string[] = [];
 
 	if (!workspaceFolders) {
 		return dataPaths;
 	}
 
-	workspaceFolders.forEach(wf => {
-		const allCssConfig = workspace.getConfiguration(undefined, wf.uri);
-		const wfCSSConfig = allCssConfig.inspect<ExperimentalConfig>('css');
-		if (wfCSSConfig && wfCSSConfig.workspaceFolderValue && wfCSSConfig.workspaceFolderValue.customData) {
-			const customData = wfCSSConfig.workspaceFolderValue.customData;
-			if (Array.isArray(customData)) {
-				customData.forEach(t => {
-					if (typeof t === 'string') {
-						dataPaths.push(path.resolve(wf.uri.fsPath, t));
-					}
-				});
+	const collect = (paths: string[] | undefined, rootFolder: Uri) => {
+		if (Array.isArray(paths)) {
+			for (const path of paths) {
+				if (typeof path === 'string') {
+					dataPaths.push(resolvePath(rootFolder, path).toString());
+				}
 			}
 		}
-	});
+	};
 
+	for (let i = 0; i < workspaceFolders.length; i++) {
+		const folderUri = workspaceFolders[i].uri;
+		const allCssConfig = workspace.getConfiguration('css', folderUri);
+		const customDataInspect = allCssConfig.inspect<string[]>('customData');
+		if (customDataInspect) {
+			collect(customDataInspect.workspaceFolderValue, folderUri);
+			if (i === 0) {
+				if (workspace.workspaceFile) {
+					collect(customDataInspect.workspaceValue, workspace.workspaceFile);
+				}
+				collect(customDataInspect.globalValue, folderUri);
+			}
+		}
+
+	}
 	return dataPaths;
 }
 
-export function getCustomDataPathsFromAllExtensions(): string[] {
+function getCustomDataPathsFromAllExtensions(): string[] {
 	const dataPaths: string[] = [];
 
 	for (const extension of extensions.all) {
@@ -47,7 +83,7 @@ export function getCustomDataPathsFromAllExtensions(): string[] {
 		if (contributes && contributes.css && contributes.css.customData && Array.isArray(contributes.css.customData)) {
 			const relativePaths: string[] = contributes.css.customData;
 			relativePaths.forEach(rp => {
-				dataPaths.push(path.resolve(extension.extensionPath, rp));
+				dataPaths.push(Uri.joinPath(extension.extensionUri, rp).toString());
 			});
 		}
 	}

extensions/css-language-features/client/src/node/cssClientMain.ts

@@ -0,0 +1,13 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { getNodeFSRequestService } from './nodeFs';
+import { ExtensionContext } from 'vscode';
+import { startClient } from '../cssClient';
+
+// this method is called when vs code is activated
+export function activate(context: ExtensionContext) {
+	startClient(context, { fs: getNodeFSRequestService() });
+}

extensions/css-language-features/client/src/node/nodeFs.ts

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'fs';
+import { Uri } from 'vscode';
+import { getScheme, RequestService, FileType } from '../requests';
+
+export function getNodeFSRequestService(): RequestService {
+	function ensureFileUri(location: string) {
+		if (getScheme(location) !== 'file') {
+			throw new Error('fileRequestService can only handle file URLs');
+		}
+	}
+	return {
+		getContent(location: string, encoding?: string) {
+			ensureFileUri(location);
+			return new Promise((c, e) => {
+				const uri = Uri.parse(location);
+				fs.readFile(uri.fsPath, encoding, (err, buf) => {
+					if (err) {
+						return e(err);
+					}
+					c(buf.toString());
+
+				});
+			});
+		},
+		stat(location: string) {
+			ensureFileUri(location);
+			return new Promise((c, e) => {
+				const uri = Uri.parse(location);
+				fs.stat(uri.fsPath, (err, stats) => {
+					if (err) {
+						if (err.code === 'ENOENT') {
+							return c({ type: FileType.Unknown, ctime: -1, mtime: -1, size: -1 });
+						} else {
+							return e(err);
+						}
+					}
+
+					let type = FileType.Unknown;
+					if (stats.isFile()) {
+						type = FileType.File;
+					} else if (stats.isDirectory()) {
+						type = FileType.Directory;
+					} else if (stats.isSymbolicLink()) {
+						type = FileType.SymbolicLink;
+					}
+
+					c({
+						type,
+						ctime: stats.ctime.getTime(),
+						mtime: stats.mtime.getTime(),
+						size: stats.size
+					});
+				});
+			});
+		},
+		readDirectory(location: string) {
+			ensureFileUri(location);
+			return new Promise((c, e) => {
+				const path = Uri.parse(location).fsPath;
+
+				fs.readdir(path, { withFileTypes: true }, (err, children) => {
+					if (err) {
+						return e(err);
+					}
+					c(children.map(stat => {
+						if (stat.isSymbolicLink()) {
+							return [stat.name, FileType.SymbolicLink];
+						} else if (stat.isDirectory()) {
+							return [stat.name, FileType.Directory];
+						} else if (stat.isFile()) {
+							return [stat.name, FileType.File];
+						} else {
+							return [stat.name, FileType.Unknown];
+						}
+					}));
+				});
+			});
+		}
+	};
+}

extensions/css-language-features/client/src/requests.ts

@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Uri, workspace } from 'vscode';
+import { RequestType, LanguageClient } from 'vscode-languageclient';
+import { TextDecoder } from 'util';
+
+export namespace FsContentRequest {
+	export const type: RequestType<{ uri: string; encoding?: string; }, string, any, any> = new RequestType('fs/content');
+}
+export namespace FsStatRequest {
+	export const type: RequestType<string, FileStat, any, any> = new RequestType('fs/stat');
+}
+
+export namespace FsReadDirRequest {
+	export const type: RequestType<string, [string, FileType][], any, any> = new RequestType('fs/readDir');
+}
+
+export function serveFileSystemRequests(client: LanguageClient, runtime: { fs?: RequestService; }) {
+	client.onRequest(FsContentRequest.type, (param: { uri: string; encoding?: string; }) => {
+		const uri = Uri.parse(param.uri);
+		if (uri.scheme === 'file' && runtime.fs) {
+			return runtime.fs.getContent(param.uri);
+		}
+		return workspace.fs.readFile(uri).then(buffer => {
+			return new TextDecoder(param.encoding).decode(buffer);
+		});
+	});
+	client.onRequest(FsReadDirRequest.type, (uriString: string) => {
+		const uri = Uri.parse(uriString);
+		if (uri.scheme === 'file' && runtime.fs) {
+			return runtime.fs.readDirectory(uriString);
+		}
+		return workspace.fs.readDirectory(uri);
+	});
+	client.onRequest(FsStatRequest.type, (uriString: string) => {
+		const uri = Uri.parse(uriString);
+		if (uri.scheme === 'file' && runtime.fs) {
+			return runtime.fs.stat(uriString);
+		}
+		return workspace.fs.stat(uri);
+	});
+}
+
+export enum FileType {
+	/**
+	 * The file type is unknown.
+	 */
+	Unknown = 0,
+	/**
+	 * A regular file.
+	 */
+	File = 1,
+	/**
+	 * A directory.
+	 */
+	Directory = 2,
+	/**
+	 * A symbolic link to a file.
+	 */
+	SymbolicLink = 64
+}
+export interface FileStat {
+	/**
+	 * The type of the file, e.g. is a regular file, a directory, or symbolic link
+	 * to a file.
+	 */
+	type: FileType;
+	/**
+	 * The creation timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+	 */
+	ctime: number;
+	/**
+	 * The modification timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+	 */
+	mtime: number;
+	/**
+	 * The size in bytes.
+	 */
+	size: number;
+}
+
+export interface RequestService {
+	getContent(uri: string, encoding?: string): Promise<string>;
+
+	stat(uri: string): Promise<FileStat>;
+	readDirectory(uri: string): Promise<[string, FileType][]>;
+}
+
+export function getScheme(uri: string) {
+	return uri.substr(0, uri.indexOf(':'));
+}
+
+export function dirname(uri: string) {
+	const lastIndexOfSlash = uri.lastIndexOf('/');
+	return lastIndexOfSlash !== -1 ? uri.substr(0, lastIndexOfSlash) : '';
+}
+
+export function basename(uri: string) {
+	const lastIndexOfSlash = uri.lastIndexOf('/');
+	return uri.substr(lastIndexOfSlash + 1);
+}
+
+const Slash = '/'.charCodeAt(0);
+
+export function isAbsolutePath(path: string) {
+	return path.charCodeAt(0) === Slash;
+}
+
+export function resolvePath(uri: Uri, path: string): Uri {
+	if (isAbsolutePath(path)) {
+		return uri.with({ path: path });
+	}
+	return Uri.joinPath(uri, path);
+}
+