use custom editor API, closes llvm#9

Author: dvirtz

.cspell.json

@@ -0,0 +1,23 @@
+{
+    "version": "0.1",
+    "language": "en",
+    "words": [
+        "dvirtz",
+        "Yitzchaki"
+    ],
+    "ignorePaths": [
+        "node_modules/**"
+    ],
+    "flagWords": [],
+    "languageSettings": [
+        {
+            "languageId": "markdown",
+            "ignoreRegExpList": [
+                "/`.*?`/", // inline code
+                "/(```+)\\s?[\\s\\S]+?\\1/g", // code block
+                "/'s\\b/", // trailing 's
+                "<!--.*?-->" // comments
+            ]
+        }
+    ]
+}

.github/workflows/main.yml

@@ -25,3 +25,5 @@ jobs:
         uses: GabrielBB/[email protected]
         with:
           run: npm test
+      - name: Spellcheck
+        run: npm run spellcheck

.vscode/tasks.json

@@ -11,10 +11,20 @@
             "presentation": {
                 "reveal": "never"
             },
+            "group": "build",
+            "label": "npm: watch",
+            "detail": "tsc -watch -p ./"
+        },
+        {
+            "type": "npm",
+            "script": "test",
             "group": {
                 "kind": "build",
                 "isDefault": true
-            }
+            },
+            "problemMatcher": [],
+            "label": "npm: test",
+            "detail": "node ./out/test/runTest.js"
         }
     ]
-}
+}

package-lock.json

@@ -32,25 +32,10 @@
     "viewer"
   ],
   "activationEvents": [
-    "onLanguage:parquet"
+    "onCustomEditor:parquetViewer.parquetViewer"
   ],
   "main": "./out/extension",
   "contributes": {
-    "languages": [
-      {
-        "id": "parquet",
-        "extensions": [
-          ".parquet"
-        ]
-      }
-    ],
-    "commands": [
-      {
-        "command": "extension.viewParquetAsJson",
-        "category": "Parquet",
-        "title": "View as JSON"
-      }
-    ],
     "configuration": [
       {
         "title": "parquet-viewer",
@@ -62,6 +47,17 @@
           }
         }
       }
+    ],
+    "customEditors": [
+      {
+        "viewType": "parquetViewer.parquetViewer",
+        "displayName": "Parquet Viewer",
+        "selector": [
+          {
+            "filenamePattern": "*.parquet"
+          }
+        ]
+      }
     ]
   },
   "scripts": {
@@ -70,21 +66,26 @@
     "watch": "tsc -watch -p ./",
     "pretest": "npm run compile",
     "test": "node ./out/test/runTest.js",
-    "deploy": "vsce publish --yarn"
+    "deploy": "vsce publish --yarn",
+    "spellcheck": "cspell '**/*.ts' '**/*.md'"
   },
   "devDependencies": {
-    "@types/chai": "^4.2.11",
-    "@types/chai-as-promised": "^7.1.2",
-    "@types/glob": "^7.1.1",
-    "@types/mocha": "^2.2.42",
-    "@types/node": "^8.10.25",
-    "@types/vscode": "^1.30.0",
+    "@types/chai": "^4.2.14",
+    "@types/chai-as-promised": "^7.1.3",
+    "@types/glob": "^7.1.3",
+    "@types/mocha": "^8.0.3",
+    "@types/node": "^14.14.6",
+    "@types/vscode": "^1.50.0",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
-    "mocha": "^6.1.4",
-    "tslint": "^5.8.0",
-    "typescript": "^3.1.4",
-    "vsce": "^1.75.0",
-    "vscode-test": "^1.3.0"
+    "cspell": "^5.1.3",
+    "mocha": "^8.2.0",
+    "tslint": "^6.1.3",
+    "typescript": "^4.0.5",
+    "vsce": "^1.81.1",
+    "vscode-test": "^1.4.1"
+  },
+  "dependencies": {
+    "@async-generators/to-array": "^0.1.0"
   }
 }

package.json

@@ -0,0 +1,37 @@
+import * as vscode from 'vscode';
+
+export function disposeAll(disposables: vscode.Disposable[]): void {
+	while (disposables.length) {
+		const item = disposables.pop();
+		if (item) {
+			item.dispose();
+		}
+	}
+}
+
+export abstract class Disposable {
+	private _isDisposed = false;
+
+	protected _disposables: vscode.Disposable[] = [];
+
+	public dispose(): any {
+		if (this._isDisposed) {
+			return;
+		}
+		this._isDisposed = true;
+		disposeAll(this._disposables);
+	}
+
+	protected _register<T extends vscode.Disposable>(value: T): T {
+		if (this._isDisposed) {
+			value.dispose();
+		} else {
+			this._disposables.push(value);
+		}
+		return value;
+	}
+
+	protected get isDisposed(): boolean {
+		return this._isDisposed;
+	}
+}

src/dispose.ts

@@ -2,48 +2,17 @@
 // The module 'vscode' contains the VS Code extensibility API
 // Import the module and reference it with the alias vscode in your code below
 import * as vscode from 'vscode';
-import { ParquetContentProvider } from './parquet_content_provider';
+import { ParquetEditorProvider } from './parquet-editor-provider';
+import { ParquetToolsRunner } from './parquet-tools-runner';
 
 // this method is called when your extension is activated
 // your extension is activated the very first time the command is executed
 export function activate(context: vscode.ExtensionContext) {
   console.log('parquet-viewer activated');
 
-  // ParquetContentProvider.spawnParquetTools(['-h']).then(process => process.on('error', (err: string) => {
-  //   vscode.window.showErrorMessage('parquet-tools not in PATH (' + err + ')');
-  // }));
-
-  const scheme = 'parquet';
-  const provider = new ParquetContentProvider();
-
-  context.subscriptions.push(vscode.workspace.registerTextDocumentContentProvider(scheme, provider));
-
-  let onFile = function (document: vscode.TextDocument) {
-    if (document.fileName.endsWith('parquet') && document.uri.scheme !== scheme) {
-      let uri = vscode.Uri.parse(scheme + '://' + document.uri.path + ".as.json");
-      vscode.window.showTextDocument(uri);
-    }
-  };
-
-  context.subscriptions.push(vscode.commands.registerTextEditorCommand('extension.viewParquetAsJson', (textEditor: { document: any; }) => {
-    let document = textEditor.document;
-    if (!document.fileName.endsWith('parquet')) {
-      vscode.window.showErrorMessage("Please open a parquet file");
-      return; // no editor
-    }
-    onFile(document);
+  ParquetToolsRunner.spawnParquetTools(['-h']).then(process => process.on('error', (err: string) => {
+    vscode.window.showErrorMessage('parquet-tools not in PATH (' + err + ')');
   }));
 
-  context.subscriptions.push(vscode.workspace.onDidOpenTextDocument(onFile));
-  context.subscriptions.push(vscode.workspace.onDidChangeTextDocument((e: { document: any; }) => {
-    onFile(e.document);
-  }));
-
-  if (vscode.window.activeTextEditor) {
-    onFile(vscode.window.activeTextEditor.document);
-  }
+  context.subscriptions.push(ParquetEditorProvider.register(context));
 }
-
-// this method is called when your extension is deactivated
-export function deactivate() {
-}

src/extension.ts

@@ -0,0 +1,23 @@
+import * as vscode from "vscode";
+import * as assert from 'assert';
+
+export class ParquetTextDocumentContentProvider implements vscode.TextDocumentContentProvider {
+  private static jsonMap: Map<string, string> = new Map();
+
+  public static has(path: string): boolean {
+    return ParquetTextDocumentContentProvider.jsonMap.has(path);
+  }
+
+  public static add(path:string, content: string) {
+    ParquetTextDocumentContentProvider.jsonMap.set(path, content);
+  }
+
+  onDidChangeEmitter = new vscode.EventEmitter<vscode.Uri>();
+  onDidChange = this.onDidChangeEmitter.event;
+
+  async provideTextDocumentContent(uri: vscode.Uri): Promise<string | undefined> {
+    const parquetPath = uri.fsPath.replace(/\.as\.json$/, '');
+    assert(ParquetTextDocumentContentProvider.has(parquetPath));
+    return ParquetTextDocumentContentProvider.jsonMap.get(parquetPath);
+  }
+}

src/parquet-document-provider.ts

@@ -0,0 +1,118 @@
+import * as vscode from "vscode";
+import * as path from 'path';
+import { getNonce } from './util';
+import { Disposable } from "./dispose";
+import { ParquetTextDocumentContentProvider } from "./parquet-document-provider";
+import { ParquetToolsRunner } from "./parquet-tools-runner";
+import toArray from '@async-generators/to-array';
+
+
+class DummyDocument extends Disposable implements vscode.CustomDocument {
+  uri: vscode.Uri;
+  path: string;
+
+  constructor(uri: vscode.Uri) {
+    super();
+    this.uri = uri;
+    this.path = uri.fsPath;
+  }
+
+  private open() {
+    vscode.window.showTextDocument(
+      this.uri.with({ scheme: 'parquet', path: this.path + '.as.json' })
+    );
+  }
+
+  public async show() {
+    if (ParquetTextDocumentContentProvider.has(this.path)) {
+      this.open();
+      return;
+    }
+
+    return await vscode.window.withProgress({
+      location: vscode.ProgressLocation.Notification,
+      title: `opening ${path.basename(this.path)}`,
+      cancellable: true
+    },
+      async (progress, token) => {
+        try {
+          const json = await toArray(ParquetToolsRunner.toJson(this.path, token));
+          ParquetTextDocumentContentProvider.add(this.path, json.join(''));
+          this.open();
+        } catch (err) {
+          if (!token.isCancellationRequested) {
+            vscode.window.showErrorMessage(err);
+          }
+        }
+      });
+  }
+
+  dispose(): void {
+    super.dispose();
+  }
+}
+
+export class ParquetEditorProvider implements vscode.CustomReadonlyEditorProvider<DummyDocument> {
+
+  private static readonly viewType = 'parquetViewer.parquetViewer';
+
+  public static register(context: vscode.ExtensionContext): vscode.Disposable {
+    const provider = new ParquetEditorProvider;
+    const providerRegistration = vscode.window.registerCustomEditorProvider(ParquetEditorProvider.viewType, provider);
+
+    context.subscriptions.push(
+      vscode.workspace.registerTextDocumentContentProvider('parquet', new ParquetTextDocumentContentProvider)
+    );
+
+    return providerRegistration;
+  }
+
+  async openCustomDocument(uri: vscode.Uri): Promise<DummyDocument> {
+    return new DummyDocument(uri);
+  }
+
+  async resolveCustomEditor(
+    document: DummyDocument,
+    webviewPanel: vscode.WebviewPanel,
+    _token: vscode.CancellationToken
+  ): Promise<void> {
+    // Setup initial content for the webview
+    webviewPanel.webview.options = {
+      enableScripts: true,
+    };
+
+    webviewPanel.webview.html = this.getHtmlForWebview(webviewPanel.webview, document);
+
+    webviewPanel.webview.onDidReceiveMessage(_ => document.show());
+
+    document.show();
+  }
+
+  private getHtmlForWebview(webview: vscode.Webview, document: DummyDocument): string {
+    // Use a nonce to whitelist which scripts can be run
+    const nonce = getNonce();
+
+    const res = /* html */`
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>browser-amd-editor</title>
+    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+    <!-- <meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src ${webview.cspSource} 'nonce-${nonce}'; img-src ${webview.cspSource}; style-src 'unsafe-inline' ${webview.cspSource};"> -->
+    </head>
+  <body>
+    <p>Click <a href="${path.basename(document.uri.fsPath)}.as.json" id="here">here</a> to open JSON</p>
+    <script nonce="${nonce}">
+      //# sourceURL=to-json.js
+      const vscode = acquireVsCodeApi();
+      document.getElementById('here').addEventListener('click', _ => {
+        vscode.postMessage();
+      });
+    </script>
+  </body>
+</html>`;
+    return res;
+  }
+
+
+}