Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2025-12-24 12:19:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

[html] clean up request service: add CustomDataRequestService #135459

Browse Source
This commit is contained in:
Martin Aeschlimann
2021-11-29 11:25:04 +01:00
parent 414c15079b
commit 3d8b5674c7
19 changed files with 95 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
extensions/html-language-features/server/src/customData.ts
View File

@@ -4,9 +4,9 @@
*--------------------------------------------------------------------------------------------*/
import { IHTMLDataProvider, newHTMLDataProvider } from 'vscode-html-languageservice';
import { RequestService } from './requests';
import { CustomDataRequestService } from './htmlServer';
export function fetchHTMLDataProviders(dataPaths: string[], requestService: RequestService): Promise<IHTMLDataProvider[]> {
export function fetchHTMLDataProviders(dataPaths: string[], requestService: CustomDataRequestService): Promise<IHTMLDataProvider[]> {
const providers = dataPaths.map(async p => {
try {
const content = await requestService.getContent(p);

34
extensions/html-language-features/server/src/htmlServer.ts
View File

@@ -24,12 +24,16 @@ import { getFoldingRanges } from './modes/htmlFolding';
import { fetchHTMLDataProviders } from './customData';
import { getSelectionRanges } from './modes/selectionRanges';
import { SemanticTokenProvider, newSemanticTokenProvider } from './modes/semanticTokens';
import { RequestService, getRequestService } from './requests';
import { FileSystemProvider, getFileSystemProvider } from './requests';
namespace CustomDataChangedNotification {
export const type: NotificationType<string[]> = new NotificationType('html/customDataChanged');
}
namespace CustomDataContent {
export const type: RequestType<string, string, any> = new RequestType('html/customDataContent');
}
namespace TagCloseRequest {
export const type: RequestType<TextDocumentPositionParams, string | null, any> = new RequestType('html/tag');
}
@@ -47,8 +51,7 @@ namespace SemanticTokenLegendRequest {
}
export interface RuntimeEnvironment {
file?: RequestService;
http?: RequestService
fileFs?: FileSystemProvider;
configureHttpRequests?(proxy: string, strictSSL: boolean): void;
readonly timer: {
setImmediate(callback: (...args: any[]) => void, ...args: any[]): Disposable;
@@ -56,6 +59,12 @@ export interface RuntimeEnvironment {
}
}
export interface CustomDataRequestService {
getContent(uri: string): Promise<string>;
}
export function startServer(connection: Connection, runtime: RuntimeEnvironment) {
// Create a text document manager.
@@ -74,10 +83,11 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
let workspaceFoldersSupport = false;
let foldingRangeLimit = Number.MAX_VALUE;
const notReady = () => Promise.reject('Not Ready');
let requestService: RequestService = { getContent: notReady, stat: notReady, readDirectory: notReady };
const customDataRequestService : CustomDataRequestService = {
getContent(uri: string) {
return connection.sendRequest(CustomDataContent.type, uri);
}
};
let globalSettings: Settings = {};
let documentSettings: { [key: string]: Thenable<Settings> } = {};
@@ -113,17 +123,19 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
}
}
requestService = getRequestService(initializationOptions?.handledSchemas || ['file'], connection, runtime);
const handledSchemas = initializationOptions?.handledSchemas as string[] ?? ['file'];
const fileSystemProvider = getFileSystemProvider(handledSchemas, connection, runtime);
const workspace = {
get settings() { return globalSettings; },
get folders() { return workspaceFolders; }
};
languageModes = getLanguageModes(initializationOptions?.embeddedLanguages || { css: true, javascript: true }, workspace, params.capabilities, requestService);
languageModes = getLanguageModes(initializationOptions?.embeddedLanguages || { css: true, javascript: true }, workspace, params.capabilities, fileSystemProvider);
const dataPaths: string[] = initializationOptions?.dataPaths || [];
fetchHTMLDataProviders(dataPaths, requestService).then(dataProviders => {
fetchHTMLDataProviders(dataPaths, customDataRequestService).then(dataProviders => {
languageModes.updateDataProviders(dataProviders);
});
@@ -567,7 +579,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
});
connection.onNotification(CustomDataChangedNotification.type, dataPaths => {
fetchHTMLDataProviders(dataPaths, requestService).then(dataProviders => {
fetchHTMLDataProviders(dataPaths, customDataRequestService).then(dataProviders => {
languageModes.updateDataProviders(dataProviders);
});
});

4
extensions/html-language-features/server/src/modes/languageModes.ts
View File

@@ -21,7 +21,7 @@ import { getCSSMode } from './cssMode';
import { getDocumentRegions, HTMLDocumentRegions } from './embeddedSupport';
import { getHTMLMode } from './htmlMode';
import { getJavaScriptMode } from './javascriptMode';
import { RequestService } from '../requests';
import { FileSystemProvider } from '../requests';
export {
WorkspaceFolder, CompletionItem, CompletionList, CompletionItemKind, Definition, Diagnostic, DocumentHighlight, DocumentHighlightKind,
@@ -97,7 +97,7 @@ export interface LanguageModeRange extends Range {
attributeValue?: boolean;
}
export function getLanguageModes(supportedLanguages: { [languageId: string]: boolean; }, workspace: Workspace, clientCapabilities: ClientCapabilities, requestService: RequestService): LanguageModes {
export function getLanguageModes(supportedLanguages: { [languageId: string]: boolean; }, workspace: Workspace, clientCapabilities: ClientCapabilities, requestService: FileSystemProvider): LanguageModes {
const htmlLanguageService = getHTMLLanguageService({ clientCapabilities, fileSystemProvider: requestService });
const cssLanguageService = getCSSLanguageService({ clientCapabilities, fileSystemProvider: requestService });

4
extensions/html-language-features/server/src/node/htmlServerMain.ts
View File

@@ -6,7 +6,7 @@
import { createConnection, Connection, Disposable } from 'vscode-languageserver/node';
import { formatError } from '../utils/runner';
import { RuntimeEnvironment, startServer } from '../htmlServer';
import { getNodeFSRequestService } from './nodeFs';
import { getNodeFileFS } from './nodeFs';
// Create a connection for the server.
@@ -30,7 +30,7 @@ const runtime: RuntimeEnvironment = {
return { dispose: () => clearTimeout(handle) };
}
},
file: getNodeFSRequestService()
fileFs: getNodeFileFS()
};
startServer(connection, runtime);

19
extensions/html-language-features/server/src/node/nodeFs.ts
View File

@@ -3,32 +3,19 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { RequestService, getScheme } from '../requests';
import { FileSystemProvider, getScheme } from '../requests';
import { URI as Uri } from 'vscode-uri';
import * as fs from 'fs';
import { FileType } from 'vscode-css-languageservice';
export function getNodeFSRequestService(): RequestService {
export function getNodeFileFS(): FileSystemProvider {
function ensureFileUri(location: string) {
if (getScheme(location) !== 'file') {
throw new Error('fileRequestService can only handle file URLs');
throw new Error('fileSystemProvider 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) => {

35
extensions/html-language-features/server/src/requests.ts
View File

@@ -7,9 +7,6 @@ import { URI } from 'vscode-uri';
import { RequestType, Connection } from 'vscode-languageserver';
import { RuntimeEnvironment } from './htmlServer';
export namespace FsContentRequest {
export const type: RequestType<{ uri: string; encoding?: string; }, string, any> = new RequestType('fs/content');
}
export namespace FsStatRequest {
export const type: RequestType<string, FileStat, any> = new RequestType('fs/stat');
}
@@ -56,45 +53,27 @@ export interface FileStat {
size: number;
}
export interface RequestService {
getContent(uri: string, encoding?: string): Promise<string>;
export interface FileSystemProvider {
stat(uri: string): Promise<FileStat>;
readDirectory(uri: string): Promise<[string, FileType][]>;
}
export function getRequestService(handledSchemas: string[], connection: Connection, runtime: RuntimeEnvironment): RequestService {
const builtInHandlers: { [protocol: string]: RequestService | undefined } = {};
for (let protocol of handledSchemas) {
if (protocol === 'file') {
builtInHandlers[protocol] = runtime.file;
} else if (protocol === 'http' || protocol === 'https') {
builtInHandlers[protocol] = runtime.http;
}
}
export function getFileSystemProvider(handledSchemas: string[], connection: Connection, runtime: RuntimeEnvironment): FileSystemProvider {
const fileFs = runtime.fileFs && handledSchemas.indexOf('file') !== -1 ? runtime.fileFs : undefined;
return {
async stat(uri: string): Promise<FileStat> {
const handler = builtInHandlers[getScheme(uri)];
if (handler) {
return handler.stat(uri);
if (fileFs && uri.startsWith('file:')) {
return fileFs.stat(uri);
}
const res = await connection.sendRequest(FsStatRequest.type, uri.toString());
return res;
},
readDirectory(uri: string): Promise<[string, FileType][]> {
const handler = builtInHandlers[getScheme(uri)];
if (handler) {
return handler.readDirectory(uri);
if (fileFs && uri.startsWith('file:')) {
return fileFs.readDirectory(uri);
}
return connection.sendRequest(FsReadDirRequest.type, uri.toString());
},
getContent(uri: string, encoding?: string): Promise<string> {
const handler = builtInHandlers[getScheme(uri)];
if (handler) {
return handler.getContent(uri, encoding);
}
return connection.sendRequest(FsContentRequest.type, { uri: uri.toString(), encoding });
}
};
}

4
extensions/html-language-features/server/src/test/completions.test.ts
View File

@@ -7,7 +7,7 @@ import * as assert from 'assert';
import * as path from 'path';
import { URI } from 'vscode-uri';
import { getLanguageModes, WorkspaceFolder, TextDocument, CompletionList, CompletionItemKind, ClientCapabilities, TextEdit } from '../modes/languageModes';
import { getNodeFSRequestService } from '../node/nodeFs';
import { getNodeFileFS } from '../node/nodeFs';
import { getDocumentContext } from '../utils/documentContext';
export interface ItemDescription {
label: string;
@@ -59,7 +59,7 @@ export async function testCompletionFor(value: string, expected: { count?: numbe
let position = document.positionAt(offset);
const context = getDocumentContext(uri, workspace.folders);
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFSRequestService());
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFileFS());
const mode = languageModes.getModeAtPosition(document, position)!;
let list = await mode.doComplete!(document, position, context);

4
extensions/html-language-features/server/src/test/folding.test.ts
View File

@@ -8,7 +8,7 @@ import * as assert from 'assert';
import { getFoldingRanges } from '../modes/htmlFolding';
import { TextDocument, getLanguageModes } from '../modes/languageModes';
import { ClientCapabilities } from 'vscode-css-languageservice';
import { getNodeFSRequestService } from '../node/nodeFs';
import { getNodeFileFS } from '../node/nodeFs';
interface ExpectedIndentRange {
startLine: number;
@@ -22,7 +22,7 @@ async function assertRanges(lines: string[], expected: ExpectedIndentRange[], me
settings: {},
folders: [{ name: 'foo', uri: 'test://foo' }]
};
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFSRequestService());
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFileFS());
const actual = await getFoldingRanges(languageModes, document, nRanges, null);
let actualRanges = [];

4
extensions/html-language-features/server/src/test/formatting.test.ts
View File

@@ -10,7 +10,7 @@ import * as assert from 'assert';
import { getLanguageModes, TextDocument, Range, FormattingOptions, ClientCapabilities } from '../modes/languageModes';
import { format } from '../modes/formatting';
import { getNodeFSRequestService } from '../node/nodeFs';
import { getNodeFileFS } from '../node/nodeFs';
suite('HTML Embedded Formatting', () => {
@@ -19,7 +19,7 @@ suite('HTML Embedded Formatting', () => {
settings: options,
folders: [{ name: 'foo', uri: 'test://foo' }]
};
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFSRequestService());
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFileFS());
let rangeStartOffset = value.indexOf('|');
let rangeEndOffset;

6
extensions/html-language-features/server/src/test/rename.test.ts
View File

@@ -5,7 +5,7 @@
import * as assert from 'assert';
import { WorkspaceEdit, TextDocument, getLanguageModes, ClientCapabilities } from '../modes/languageModes';
import { getNodeFSRequestService } from '../node/nodeFs';
import { getNodeFileFS } from '../node/nodeFs';
async function testRename(value: string, newName: string, expectedDocContent: string): Promise<void> {
@@ -17,7 +17,7 @@ async function testRename(value: string, newName: string, expectedDocContent: st
settings: {},
folders: [{ name: 'foo', uri: 'test://foo' }]
};
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFSRequestService());
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFileFS());
const javascriptMode = languageModes.getMode('javascript')
const position = document.positionAt(offset);
@@ -49,7 +49,7 @@ async function testNoRename(value: string, newName: string): Promise<void> {
settings: {},
folders: [{ name: 'foo', uri: 'test://foo' }]
};
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFSRequestService());
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFileFS());
const javascriptMode = languageModes.getMode('javascript')
const position = document.positionAt(offset);

4
extensions/html-language-features/server/src/test/selectionRanges.test.ts
View File

@@ -7,7 +7,7 @@ import 'mocha';
import * as assert from 'assert';
import { getLanguageModes, ClientCapabilities, TextDocument, SelectionRange } from '../modes/languageModes';
import { getSelectionRanges } from '../modes/selectionRanges';
import { getNodeFSRequestService } from '../node/nodeFs';
import { getNodeFileFS } from '../node/nodeFs';
async function assertRanges(content: string, expected: (number | string)[][]): Promise<void> {
let message = `${content} gives selection range:\n`;
@@ -19,7 +19,7 @@ async function assertRanges(content: string, expected: (number | string)[][]): P
settings: {},
folders: [{ name: 'foo', uri: 'test://foo' }]
};
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFSRequestService());
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFileFS());
const document = TextDocument.create('test://foo.html', 'html', 1, content);
const actualRanges = await getSelectionRanges(languageModes, document, [document.positionAt(offset)]);

4
extensions/html-language-features/server/src/test/semanticTokens.test.ts
View File

@@ -7,7 +7,7 @@ import 'mocha';
import * as assert from 'assert';
import { TextDocument, getLanguageModes, ClientCapabilities, Range, Position } from '../modes/languageModes';
import { newSemanticTokenProvider } from '../modes/semanticTokens';
import { getNodeFSRequestService } from '../node/nodeFs';
import { getNodeFileFS } from '../node/nodeFs';
interface ExpectedToken {
startLine: number;
@@ -22,7 +22,7 @@ async function assertTokens(lines: string[], expected: ExpectedToken[], ranges?:
settings: {},
folders: [{ name: 'foo', uri: 'test://foo' }]
};
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFSRequestService());
const languageModes = getLanguageModes({ css: true, javascript: true }, workspace, ClientCapabilities.LATEST, getNodeFileFS());
const semanticTokensProvider = newSemanticTokenProvider(languageModes);
const legend = semanticTokensProvider.legend;