Add TextSearchProvider (#27)

hasparus · web-flow · commit 86e7d98daa4b · 2021-12-22T10:52:23.000+01:00
* Change null to undefined

* Stop looping on self-referencing contracts

* Make textSearchProvider work

* Fix .vscodeignore
diff --git a/packages/ethereum-viewer/.vscodeignore b/packages/ethereum-viewer/.vscodeignore
@@ -4,6 +4,7 @@
 **/*.map
 **/*.ts
 dist/test/**
+dist/**/*.test.ts
 node_modules/**
 out/**
 src/**
diff --git a/packages/ethereum-viewer/package.json b/packages/ethereum-viewer/package.json
@@ -10,8 +10,7 @@
     "watch": "webpack --watch",
     "pretest": "yarn run build",
     "lint": "eslint src --ext ts",
-    "serve": "serve --cors -l 5000 --ssl-cert ../../certs/localhost.pem --ssl-key ../../certs/localhost-key.pem",
-    "run-in-browser": "vscode-test-web --browserType=chromium --extensionDevelopmentPath=. ."
+    "serve": "serve --cors -l 5000 --ssl-cert ../../certs/localhost.pem --ssl-key ../../certs/localhost-key.pem"
   },
   "dependencies": {
     "fast-json-stable-stringify": "^2.1.0",
diff --git a/packages/ethereum-viewer/src/contributedCommands.ts b/packages/ethereum-viewer/src/contributedCommands.ts
@@ -1,7 +1,7 @@
-import { commands, ExtensionContext, QuickPickItem,window } from "vscode";
+import { commands, ExtensionContext, QuickPickItem, window } from "vscode";
 
-import { ApiName,explorerApiUrls, networkNames } from "./explorer";
-import { FileSystem } from "./filesystem";
+import { ApiName, explorerApiUrls, networkNames } from "./explorer";
+import { FileSystem } from "./fs";
 import { openContractSource } from "./openContractSource";
 import { unsafeEntries } from "./util/unsafeEntries";
 
diff --git a/packages/ethereum-viewer/src/extension.ts b/packages/ethereum-viewer/src/extension.ts
@@ -5,7 +5,7 @@ import { registerContributedCommands } from "./contributedCommands";
 import { executeHostCommand } from "./executeHostCommand";
 import * as explorer from "./explorer";
 import { explorerApiUrls, networkNames } from "./explorer";
-import { FileSystem } from "./filesystem";
+import { FileSystem } from "./fs";
 import { openContractSource } from "./openContractSource";
 
 let initialized = false;
diff --git a/packages/ethereum-viewer/src/fs/fileSearchProvider.ts b/packages/ethereum-viewer/src/fs/fileSearchProvider.ts
@@ -12,7 +12,6 @@ import {
 export class StaticFileSearchProvider
   implements FileSearchProvider, Disposable
 {
-  static scheme = "github1s";
   private readonly disposable?: Disposable;
 
   // HACK: We don't support searching for added files.
diff --git a/packages/ethereum-viewer/src/fs/fileSystem.test.ts b/packages/ethereum-viewer/src/fs/fileSystem.test.ts
@@ -1,6 +1,6 @@
 import { strictEqual } from "assert";
 
-import { FileSystem } from "../filesystem";
+import { FileSystem } from "./fileSystem";
 
 describe(FileSystem.name, () => {
   it("creates file", () => {
diff --git a/packages/ethereum-viewer/src/fs/fileSystem.ts b/packages/ethereum-viewer/src/fs/fileSystem.ts
diff --git a/packages/ethereum-viewer/src/fs/fileSystemProvider.test.ts b/packages/ethereum-viewer/src/fs/fileSystemProvider.test.ts
diff --git a/packages/ethereum-viewer/src/fs/fileSystemProvider.ts b/packages/ethereum-viewer/src/fs/fileSystemProvider.ts
diff --git a/packages/ethereum-viewer/src/fs/index.ts b/packages/ethereum-viewer/src/fs/index.ts
@@ -0,0 +1,3 @@
+export { StaticFileSearchProvider } from "./fileSearchProvider";
+export { FileSystem } from "./fileSystem";
+export { MemFSTextSearchProvider } from "./textSearchProvider";
diff --git a/packages/ethereum-viewer/src/fs/textSearchProvider.test.ts b/packages/ethereum-viewer/src/fs/textSearchProvider.test.ts
@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from "assert";
+
+import {
+  fixNewline,
+  MemFSTextSearchProvider,
+  // fixRegexNewline,
+} from "./textSearchProvider";
+
+describe(MemFSTextSearchProvider.name, () => {
+  // @todo tests for fixRegexNewline
+  // @todo tests for TextSearchProvider
+
+  it("fixNewline - matching", () => {
+    function testFixNewline([inputReg, testStr, shouldMatch = true]: readonly [
+      string,
+      string,
+      boolean?
+    ]): void {
+      const fixed = fixNewline(inputReg);
+      const reg = new RegExp(fixed);
+      assert.strictEqual(
+        reg.test(testStr),
+        shouldMatch,
+        `${inputReg} => ${reg}, ${testStr}, ${shouldMatch}`
+      );
+    }
+
+    (
+      [
+        ["foo", "foo"],
+
+        ["foo\n", "foo\r\n"],
+        ["foo\n", "foo\n"],
+        ["foo\nabc", "foo\r\nabc"],
+        ["foo\nabc", "foo\nabc"],
+        ["foo\r\n", "foo\r\n"],
+
+        ["foo\nbarc", "foobar", false],
+        ["foobar", "foo\nbar", false],
+      ] as const
+    ).forEach(testFixNewline);
+  });
+});
diff --git a/packages/ethereum-viewer/src/fs/textSearchProvider.ts b/packages/ethereum-viewer/src/fs/textSearchProvider.ts
@@ -0,0 +1,225 @@
+import {
+  CancellationToken,
+  Disposable,
+  Progress,
+  Range,
+  TextSearchComplete,
+  TextSearchMatch,
+  TextSearchOptions,
+  TextSearchProvider,
+  TextSearchQuery,
+  TextSearchResult,
+  Uri,
+} from "vscode";
+
+export class MemFSTextSearchProvider implements TextSearchProvider, Disposable {
+  private readonly disposable?: Disposable;
+
+  constructor(
+    private readonly files: readonly [string /* key */, string /* contents */][]
+  ) {}
+
+  dispose() {
+    this.disposable?.dispose();
+  }
+
+  provideTextSearchResults(
+    query: TextSearchQuery,
+    options: TextSearchOptions,
+    progress: Progress<TextSearchResult>,
+    _token: CancellationToken
+  ): TextSearchComplete {
+    const limit = new Limit(options.maxResults || Infinity);
+
+    // @todo handle options.includes, options.folder and options.excludes
+    // @todo handle all options on query
+    for (const [path, content] of this.files) {
+      const uri = Uri.from({ scheme: "memfs", path: "/" + path });
+      searchInFile(query, options, progress, uri, content, limit);
+    }
+
+    return { limitHit: limit.isHit() };
+  }
+}
+
+function searchInFile(
+  query: TextSearchQuery,
+  _options: TextSearchOptions,
+  progress: Progress<TextSearchResult>,
+  uri: Uri,
+  content: string,
+  limit: Limit
+): void {
+  let { pattern } = query;
+
+  const originalLines = content.split("\n");
+
+  if (!query.isCaseSensitive) {
+    content = content.toLowerCase();
+    pattern = pattern.toLowerCase();
+  }
+
+  const lines = content.split("\n");
+
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex];
+    const matches: TextSearchMatch[] = [];
+
+    if (query.isRegExp) {
+      const regex = new RegExp(fixNewline(pattern), "g");
+      const hits = Array.from(line.matchAll(regex)).filter(hasIndex);
+      if (!hits.length) continue;
+      limit.increase(hits.length);
+
+      matches.push({
+        uri,
+        ranges: hits.map(
+          (hit) =>
+            new Range(
+              lineIndex,
+              hit.index,
+              lineIndex,
+              hit.index + hit[0].length
+            )
+        ),
+        preview: {
+          text: originalLines[lineIndex],
+          matches: hits.map(
+            (hit) => new Range(0, hit.index, 0, hit.index + hit[0].length)
+          ),
+        },
+      });
+    } else {
+      const index = line.indexOf(pattern);
+
+      if (index !== -1) {
+        matches.push({
+          uri,
+          // @todo group all matches in the document under one progress.report
+          ranges: new Range(
+            lineIndex,
+            index,
+            lineIndex,
+            index + pattern.length
+          ),
+          preview: {
+            text: originalLines[lineIndex],
+            matches: new Range(0, index, 0, index + pattern.length),
+          },
+        });
+      }
+    }
+
+    matches.forEach((m) => {
+      progress.report(m);
+    });
+
+    if (limit.isHit()) break;
+  }
+}
+
+class Limit {
+  private current: number;
+  constructor(private readonly max: number) {
+    this.current = 0;
+  }
+
+  isHit() {
+    return this.current >= this.max;
+  }
+  increase(value: number) {
+    this.current += value;
+  }
+}
+
+function hasIndex(
+  hit: RegExpMatchArray
+): hit is RegExpMatchArray & { index: number } {
+  return hit.index !== undefined;
+}
+
+/**
+ * Replaces _actual newline_ in the pattern with escaped newline.
+ */
+export function fixNewline(pattern: string): string {
+  return pattern.replace(/\n/g, "\\r?\\n");
+}
+
+// @todo VSCode RipgrepTextSearchProvider fixes regex with the following code
+// export function fixRegexNewline(pattern: string): string {
+// 	// we parse the pattern anew each tiem
+// 	let re: ReAST.Pattern;
+// 	try {
+// 		re = new RegExpParser().parsePattern(pattern);
+// 	} catch {
+// 		return pattern;
+// 	}
+
+// 	let output = '';
+// 	let lastEmittedIndex = 0;
+// 	const replace = (start: number, end: number, text: string) => {
+// 		output += pattern.slice(lastEmittedIndex, start) + text;
+// 		lastEmittedIndex = end;
+// 	};
+
+// 	const context: ReAST.Node[] = [];
+// 	const visitor = new RegExpVisitor({
+// 		onCharacterEnter(char) {
+// 			if (char.raw !== '\\n') {
+// 				return;
+// 			}
+
+// 			const parent = context[0];
+// 			if (!parent) {
+// 				// simple char, \n -> \r?\n
+// 				replace(char.start, char.end, '\\r?\\n');
+// 			} else if (context.some(isLookBehind)) {
+// 				// no-op in a lookbehind, see #100569
+// 			} else if (parent.type === 'CharacterClass') {
+// 				if (parent.negate) {
+// 					// negative bracket expr, [^a-z\n] -> (?![a-z]|\r?\n)
+// 					const otherContent = pattern.slice(parent.start + 2, char.start) + pattern.slice(char.end, parent.end - 1);
+// 					replace(parent.start, parent.end, '(?!\\r?\\n' + (otherContent ? `|[${otherContent}]` : '') + ')');
+// 				} else {
+// 					// positive bracket expr, [a-z\n] -> (?:[a-z]|\r?\n)
+// 					const otherContent = pattern.slice(parent.start + 1, char.start) + pattern.slice(char.end, parent.end - 1);
+// 					replace(parent.start, parent.end, otherContent === '' ? '\\r?\\n' : `(?:[${otherContent}]|\\r?\\n)`);
+// 				}
+// 			} else if (parent.type === 'Quantifier') {
+// 				replace(char.start, char.end, '(?:\\r?\\n)');
+// 			}
+// 		},
+// 		onQuantifierEnter(node) {
+// 			context.unshift(node);
+// 		},
+// 		onQuantifierLeave() {
+// 			context.shift();
+// 		},
+// 		onCharacterClassRangeEnter(node) {
+// 			context.unshift(node);
+// 		},
+// 		onCharacterClassRangeLeave() {
+// 			context.shift();
+// 		},
+// 		onCharacterClassEnter(node) {
+// 			context.unshift(node);
+// 		},
+// 		onCharacterClassLeave() {
+// 			context.shift();
+// 		},
+// 		onAssertionEnter(node) {
+// 			if (isLookBehind(node)) {
+// 				context.push(node);
+// 			}
+// 		},
+// 		onAssertionLeave(node) {
+// 			if (context[0] === node) {
+// 				context.shift();
+// 			}
+// 		},
+// 	});
+
+// 	visitor.visit(re);
+// 	output += pattern.slice(lastEmittedIndex);
+// 	return output;
+// }
diff --git a/packages/ethereum-viewer/src/openContractSource.ts b/packages/ethereum-viewer/src/openContractSource.ts
@@ -8,13 +8,17 @@ import {
 } from "vscode";
 
 import * as explorer from "./explorer";
-import { StaticFileSearchProvider } from "./fileSearchProvider";
-import { FileSystem } from "./filesystem";
+import {
+  FileSystem,
+  MemFSTextSearchProvider,
+  StaticFileSearchProvider,
+} from "./fs";
 import { fixtures } from "./test/fixtures";
 
 const IS_ONLINE = true; // Treat this as a toggle for development.
 
-let searchProviderDisposable: Disposable | undefined;
+let fileSearchProviderDisposable: Disposable | undefined;
+let textSearchProviderDisposable: Disposable | undefined;
 
 export interface OpenContractSourceArgs {
   fs: FileSystem;
@@ -30,12 +34,19 @@ export async function openContractSource(
 
   const mainFile = getMainContractFile(entries, info);
 
-  searchProviderDisposable?.dispose();
-  searchProviderDisposable = workspace.registerFileSearchProvider(
+  fileSearchProviderDisposable?.dispose();
+  fileSearchProviderDisposable = workspace.registerFileSearchProvider(
     "memfs",
     new StaticFileSearchProvider(entries.map(([path]) => path))
   );
-  context.subscriptions.push(searchProviderDisposable);
+  context.subscriptions.push(fileSearchProviderDisposable);
+
+  textSearchProviderDisposable?.dispose();
+  textSearchProviderDisposable = workspace.registerTextSearchProvider(
+    "memfs",
+    new MemFSTextSearchProvider(entries)
+  );
+  context.subscriptions.push(textSearchProviderDisposable);
 
   // We're trying to open the file even if it doesn't exist yet.
   await showTextDocument(mainFile);
diff --git a/packages/ethereum-viewer/src/todo.textSearchProvider.ts b/packages/ethereum-viewer/src/todo.textSearchProvider.ts
diff --git a/packages/ethereum-viewer/src/util/outputChannel.ts b/packages/ethereum-viewer/src/util/outputChannel.ts

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,6 @@ import {`
`12`	`12`	`export class StaticFileSearchProvider`
`13`	`13`	`implements FileSearchProvider, Disposable`
`14`	`14`	`{`
`15`		`- static scheme = "github1s";`
`16`	`15`	`private readonly disposable?: Disposable;`
`17`	`16`
`18`	`17`	`// HACK: We don't support searching for added files.`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+export { StaticFileSearchProvider } from "./fileSearchProvider";`
	`2`	`+export { FileSystem } from "./fileSystem";`
	`3`	`+export { MemFSTextSearchProvider } from "./textSearchProvider";`