Add simple document management for Html documents

Author: davidwengier

src/lsptoolshost/razor/htmlDocument.ts

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { getUriPath } from '../../razor/src/uriPaths';
+
+export class HtmlDocument {
+    public readonly path: string;
+    private content = '';
+
+    public constructor(public readonly uri: vscode.Uri) {
+        this.path = getUriPath(uri);
+    }
+
+    public getContent() {
+        return this.content;
+    }
+
+    public setContent(content: string) {
+        this.content = content;
+    }
+}

src/lsptoolshost/razor/htmlDocumentContentProvider.ts

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { HtmlDocumentManager } from './htmlDocumentManager';
+import { RazorLogger } from '../../razor/src/razorLogger';
+import { getUriPath } from '../../razor/src/uriPaths';
+
+export class HtmlDocumentContentProvider implements vscode.TextDocumentContentProvider {
+    public static readonly scheme = 'razor-html';
+
+    private readonly onDidChangeEmitter: vscode.EventEmitter<vscode.Uri> = new vscode.EventEmitter<vscode.Uri>();
+
+    constructor(private readonly documentManager: HtmlDocumentManager, private readonly logger: RazorLogger) {}
+
+    public get onDidChange() {
+        return this.onDidChangeEmitter.event;
+    }
+
+    public fireDidChange(uri: vscode.Uri) {
+        this.onDidChangeEmitter.fire(uri);
+    }
+
+    public provideTextDocumentContent(uri: vscode.Uri) {
+        const document = this.findDocument(uri);
+        if (!document) {
+            // Document was removed from the document manager, meaning there's no more content for this
+            // file. Report an empty document.
+            this.logger.logVerbose(
+                `Could not find document '${getUriPath(
+                    uri
+                )}' when updating the HTML buffer. This typically happens when a document is removed.`
+            );
+            return '';
+        }
+
+        return document.getContent();
+    }
+
+    private findDocument(uri: vscode.Uri) {
+        const projectedPath = getUriPath(uri);
+
+        return this.documentManager.documents.find(
+            (document) => document.path.localeCompare(projectedPath, undefined, { sensitivity: 'base' }) === 0
+        );
+    }
+}

src/lsptoolshost/razor/htmlDocumentManager.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 * as vscode from 'vscode';
+import { RazorLogger } from '../../razor/src/razorLogger';
+import { PlatformInformation } from '../../shared/platform';
+import { getUriPath } from '../../razor/src/uriPaths';
+import { virtualHtmlSuffix } from '../../razor/src/razorConventions';
+import { HtmlDocumentContentProvider } from './htmlDocumentContentProvider';
+import { HtmlDocument } from './htmlDocument';
+
+export class HtmlDocumentManager {
+    private readonly htmlDocuments: { [hostDocumentPath: string]: HtmlDocument } = {};
+    private readonly contentProvider: HtmlDocumentContentProvider;
+
+    constructor(private readonly platformInfo: PlatformInformation, private readonly logger: RazorLogger) {
+        this.contentProvider = new HtmlDocumentContentProvider(this, this.logger);
+    }
+
+    public get documents() {
+        return Object.values(this.htmlDocuments);
+    }
+
+    public register() {
+        const didCloseRegistration = vscode.workspace.onDidCloseTextDocument(async (document) => {
+            if (document.languageId !== 'html') {
+                return;
+            }
+
+            await this.closeDocument(document.uri);
+        });
+
+        const providerRegistration = vscode.workspace.registerTextDocumentContentProvider(
+            HtmlDocumentContentProvider.scheme,
+            this.contentProvider
+        );
+
+        return vscode.Disposable.from(didCloseRegistration, providerRegistration);
+    }
+
+    public async updateDocumentText(uri: vscode.Uri, text: string) {
+        const document = await this.getDocument(uri);
+
+        this.logger.logVerbose(`New content for '${uri}', updating '${document.path}'.`);
+
+        document.setContent(text);
+
+        this.contentProvider.fireDidChange(document.uri);
+    }
+
+    private async closeDocument(uri: vscode.Uri) {
+        const document = await this.getDocument(uri);
+
+        if (document) {
+            this.logger.logVerbose(`Document '${document.uri}' was closed. Removing from the document manager.`);
+
+            delete this.htmlDocuments[document.path];
+        }
+    }
+
+    public async getDocument(uri: vscode.Uri): Promise<HtmlDocument> {
+        let document = this.findDocument(uri);
+
+        // This might happen in the case that a file is opened outside the workspace
+        if (!document) {
+            this.logger.logMessage(
+                `File '${uri}' didn't exist in the Razor document list. This is likely because it's from outside the workspace.`
+            );
+            document = this.addDocument(uri);
+        }
+
+        await vscode.workspace.openTextDocument(document.uri);
+
+        return document!;
+    }
+
+    private addDocument(uri: vscode.Uri): HtmlDocument {
+        let document = this.findDocument(uri);
+        if (document) {
+            this.logger.logMessage(`Skipping document creation for '${document.path}' because it already exists.`);
+            return document;
+        }
+
+        document = this.createDocument(uri);
+        this.htmlDocuments[document.path] = document;
+
+        return document;
+    }
+
+    private findDocument(uri: vscode.Uri): HtmlDocument | undefined {
+        let path = getUriPath(uri);
+
+        // We might be passed a Razor document Uri, but we store and manage Html projected documents.
+        if (uri.scheme !== HtmlDocumentContentProvider.scheme) {
+            path = `${path}${virtualHtmlSuffix}`;
+        }
+
+        if (this.platformInfo.isLinux()) {
+            return this.htmlDocuments[path];
+        }
+
+        return Object.values(this.htmlDocuments).find(
+            (document) => document.path.localeCompare(path, undefined, { sensitivity: 'base' }) === 0
+        );
+    }
+
+    private createDocument(uri: vscode.Uri) {
+        uri = uri.with({
+            scheme: HtmlDocumentContentProvider.scheme,
+            path: `${uri.path}${virtualHtmlSuffix}`,
+        });
+        const projectedDocument = new HtmlDocument(uri);
+
+        return projectedDocument;
+    }
+}