Added live preview from dynajoe/vscode-pegjs-live

AUTHORS

@@ -9,3 +9,5 @@ Sven Slootweg <admin@cryto.net> (https://github.com/joepie91/)
 yy0931 (https://github.com/yy0931)
 Rene Saarsoo <nene@triin.net> (https://github.com/nene/)
 Lionel Rowe (https://github.com/lionel-rowe/)
+Joe Andaverde (https://github.com/dynajoe)
+Michael Klaus <mkit.de@gmail.com> (https://github.com/qades78)

CHANGELOG.md

@@ -0,0 +1,4 @@
+# Changes
+
+## 2.4.2
+- Live Preview

README.md

@@ -55,6 +55,14 @@ of all of the rules in the Outline view.
 
 ![Outline](/images/outline.png)
 
+## Live Preview
+
+Live edit and test your Grammars, optionally starting at the rule under cursor.
+
+### Tips
+
+Name your grammar like this for optimal experience: grammar_name.language_extension.peggy. Where language_extension is the extension of the language you're parsing. This will provide syntax highlighting if you have a matching language server installed.
+
 ## Contributing
 
 Feel free to contribute to this extension [here](https://github.com/peggyjs/code-peggy-language).

client/index.ts

@@ -0,0 +1,10 @@
+import { activate as activateClient, deactivate } from "./client";
+import { ExtensionContext } from "vscode";
+import { activate as activateLivePreview } from "./preview";
+
+export function activate(context: ExtensionContext): void {
+  activateLivePreview(context);
+  activateClient(context);
+}
+
+export { deactivate };

client/memFs.ts

@@ -0,0 +1,259 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable @typescript-eslint/member-ordering */
+/* eslint-disable init-declarations */
+/* eslint-disable @typescript-eslint/init-declarations */
+/* eslint-disable new-cap */
+/* eslint-disable no-use-before-define */
+/* eslint-disable @typescript-eslint/explicit-member-accessibility */
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *-------------------------------------------------------------------------------------------- */
+
+import * as path from "path";
+import * as vscode from "vscode";
+
+export class File implements vscode.FileStat {
+  type: vscode.FileType;
+
+  ctime: number;
+
+  mtime: number;
+
+  size: number;
+
+  name: string;
+
+  data?: Uint8Array;
+
+  constructor(name: string) {
+    this.type = vscode.FileType.File;
+    this.ctime = Date.now();
+    this.mtime = Date.now();
+    this.size = 0;
+    this.name = name;
+  }
+}
+
+export class Directory implements vscode.FileStat {
+  type: vscode.FileType;
+
+  ctime: number;
+
+  mtime: number;
+
+  size: number;
+
+  name: string;
+
+  entries: Map<string, Directory | File>;
+
+  constructor(name: string) {
+    this.type = vscode.FileType.Directory;
+    this.ctime = Date.now();
+    this.mtime = Date.now();
+    this.size = 0;
+    this.name = name;
+    this.entries = new Map();
+  }
+}
+
+export type Entry = Directory | File;
+
+export class MemFS implements vscode.FileSystemProvider {
+  root = new Directory("");
+
+  // --- manage file metadata
+  exists(uri: vscode.Uri): boolean {
+    return this._lookup(uri, true) !== null;
+  }
+
+  stat(uri: vscode.Uri): vscode.FileStat {
+    return this._lookup(uri, false);
+  }
+
+  readDirectory(uri: vscode.Uri): [string, vscode.FileType][] {
+    const entry = this._lookupAsDirectory(uri, false);
+    const result: [string, vscode.FileType][] = [];
+    for (const [name, child] of entry.entries) {
+      result.push([name, child.type]);
+    }
+    return result;
+  }
+
+  // --- manage file contents
+
+  readFile(uri: vscode.Uri): Uint8Array {
+    const data = this._lookupAsFile(uri, false).data;
+    if (data) {
+      return data;
+    }
+    throw vscode.FileSystemError.FileNotFound();
+  }
+
+  writeFile(
+    uri: vscode.Uri,
+    content: Uint8Array,
+    options: { create: boolean; overwrite: boolean }
+  ): void {
+    const basename = path.posix.basename(uri.path);
+    const parent = this._lookupParentDirectory(uri);
+    let entry = parent.entries.get(basename);
+    if (entry instanceof Directory) {
+      throw vscode.FileSystemError.FileIsADirectory(uri);
+    }
+    if (!entry && !options.create) {
+      throw vscode.FileSystemError.FileNotFound(uri);
+    }
+    if (entry && options.create && !options.overwrite) {
+      throw vscode.FileSystemError.FileExists(uri);
+    }
+    if (!entry) {
+      entry = new File(basename);
+      parent.entries.set(basename, entry);
+      this._fireSoon({ type: vscode.FileChangeType.Created, uri });
+    }
+    entry.mtime = Date.now();
+    entry.size = content.byteLength;
+    entry.data = content;
+
+    this._fireSoon({ type: vscode.FileChangeType.Changed, uri });
+  }
+
+  // --- manage files/folders
+
+  rename(
+    oldUri: vscode.Uri,
+    newUri: vscode.Uri,
+    options: { overwrite: boolean }
+  ): void {
+    if (!options.overwrite && this._lookup(newUri, true)) {
+      throw vscode.FileSystemError.FileExists(newUri);
+    }
+
+    const entry = this._lookup(oldUri, false);
+    const oldParent = this._lookupParentDirectory(oldUri);
+
+    const newParent = this._lookupParentDirectory(newUri);
+    const newName = path.posix.basename(newUri.path);
+
+    oldParent.entries.delete(entry.name);
+    entry.name = newName;
+    newParent.entries.set(newName, entry);
+
+    this._fireSoon(
+      { type: vscode.FileChangeType.Deleted, uri: oldUri },
+      { type: vscode.FileChangeType.Created, uri: newUri }
+    );
+  }
+
+  delete(uri: vscode.Uri): void {
+    const dirname = uri.with({ path: path.posix.dirname(uri.path) });
+    const basename = path.posix.basename(uri.path);
+    const parent = this._lookupAsDirectory(dirname, false);
+    if (!parent.entries.has(basename)) {
+      throw vscode.FileSystemError.FileNotFound(uri);
+    }
+    parent.entries.delete(basename);
+    parent.mtime = Date.now();
+    parent.size -= 1;
+    this._fireSoon(
+      { type: vscode.FileChangeType.Changed, uri: dirname },
+      { uri, type: vscode.FileChangeType.Deleted }
+    );
+  }
+
+  createDirectory(uri: vscode.Uri): void {
+    const basename = path.posix.basename(uri.path);
+    const dirname = uri.with({ path: path.posix.dirname(uri.path) });
+    const parent = this._lookupAsDirectory(dirname, false);
+
+    const entry = new Directory(basename);
+    parent.entries.set(entry.name, entry);
+    parent.mtime = Date.now();
+    parent.size += 1;
+    this._fireSoon(
+      { type: vscode.FileChangeType.Changed, uri: dirname },
+      { type: vscode.FileChangeType.Created, uri }
+    );
+  }
+
+  // --- lookup
+
+  private _lookup(uri: vscode.Uri, silent: false): Entry;
+  private _lookup(uri: vscode.Uri, silent: boolean): Entry | undefined;
+  private _lookup(uri: vscode.Uri, silent: boolean): Entry | undefined {
+    const parts = uri.path.split("/");
+    let entry: Entry = this.root;
+    for (const part of parts) {
+      if (!part) {
+        continue;
+      }
+      let child: Entry | undefined;
+      if (entry instanceof Directory) {
+        child = entry.entries.get(part);
+      }
+      if (!child) {
+        if (!silent) {
+          throw vscode.FileSystemError.FileNotFound(uri);
+        } else {
+          return undefined;
+        }
+      }
+      entry = child;
+    }
+    return entry;
+  }
+
+  private _lookupAsDirectory(uri: vscode.Uri, silent: boolean): Directory {
+    const entry = this._lookup(uri, silent);
+    if (entry instanceof Directory) {
+      return entry;
+    }
+    throw vscode.FileSystemError.FileNotADirectory(uri);
+  }
+
+  private _lookupAsFile(uri: vscode.Uri, silent: boolean): File {
+    const entry = this._lookup(uri, silent);
+    if (entry instanceof File) {
+      return entry;
+    }
+    throw vscode.FileSystemError.FileIsADirectory(uri);
+  }
+
+  private _lookupParentDirectory(uri: vscode.Uri): Directory {
+    const dirname = uri.with({ path: path.posix.dirname(uri.path) });
+    return this._lookupAsDirectory(dirname, false);
+  }
+
+  // --- manage file events
+
+  private _emitter = new vscode.EventEmitter<vscode.FileChangeEvent[]>();
+
+  private _bufferedEvents: vscode.FileChangeEvent[] = [];
+
+  private _fireSoonHandle?: NodeJS.Timer;
+
+  readonly onDidChangeFile: vscode.Event<vscode.FileChangeEvent[]>
+    = this._emitter.event;
+
+  watch(_resource: vscode.Uri): vscode.Disposable {
+    // Ignore, fires for all changes...
+    return new vscode.Disposable(() => {});
+  }
+
+  private _fireSoon(...events: vscode.FileChangeEvent[]): void {
+    this._bufferedEvents.push(...events);
+
+    if (this._fireSoonHandle) {
+      clearTimeout(this._fireSoonHandle);
+    }
+
+    this._fireSoonHandle = setTimeout(() => {
+      this._emitter.fire(this._bufferedEvents);
+      this._bufferedEvents.length = 0;
+    }, 5);
+  }
+}