Improve assertScopes, add some regex tests (#25)

- assertScopes now supports asserting scopes over a whole range, and
correctly tracks multiplicity of scopes
- Added a few regex tests based on grammar-test.swift
- Upgraded node-test-github-reporter for
nearform/node-test-github-reporter#287

Author: jtbandes

.vscode/tasks.json

@@ -0,0 +1,25 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "test",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "problemMatcher": [
+        {
+          "pattern": {
+            "regexp": "^test at ([^:]+):(\\d+):(\\d+)$",
+            "file": 1,
+            "line": 2,
+            "column": 3
+          }
+        }
+      ],
+      "label": "npm: test",
+      "detail": "yarn node --test test/*.test.*"
+    }
+  ]
+}

.yarn/patches/node-test-github-reporter.patch

@@ -17,6 +17,8 @@ export default tseslint.config(
   foxglove.configs.typescript,
   {
     rules: {
+      "no-warning-comments": "off",
+
       // prettier plugin currently produces some pnp-related import error
       "prettier/prettier": "off",
     },

eslint.config.ts

@@ -26,7 +26,7 @@
     "@types/plist": "3.0.4",
     "commander": "11.1.0",
     "eslint": "9.27.0",
-    "node-test-github-reporter": "patch:node-test-github-reporter@npm%3A1.3.0#~/.yarn/patches/node-test-github-reporter.patch",
+    "node-test-github-reporter": "1.3.1",
     "plist": "3.1.0",
     "prettier": "3.5.3",
     "shiki": "3.4.2",

package.json

@@ -10,6 +10,12 @@ const assertScopes = await createAssertScopes({
   patterns: [
     { match: "foo", name: "example.foo" },
     { match: "bar", name: "example.bar" },
+    {
+      begin: "begin",
+      end: "end",
+      name: "example.range",
+      patterns: [{ include: "$self" }],
+    },
   ],
 });
 
@@ -21,24 +27,77 @@ await test("assertions", () => {
     { message: "Expected a source line before assertion" },
   );
 
+  assertScopes(
+    //
+    $`foo bar`,
+    _`~~~     example.foo`,
+    _`    ~~~ example.bar`,
+    $`foo bar`,
+    _`~~~     example.foo`,
+    _`    ~~~ example.bar`,
+  );
+
   assert.throws(
     () => {
       assertScopes(
         //
         $`foo bar`,
+        _`    ~~~ example.bar`,
         _`~~~     example.foo`,
       );
     },
-    { message: "Not enough assertions" },
+    { message: "Assertions should be sorted by start index" },
   );
 
-  assert.throws(() => {
-    assertScopes(
-      //
-      $`foo bar`,
-      _`    ~~~ example.bar`,
-    );
-  }, /Skipped token should have no scopes/);
+  assert.throws(
+    () => {
+      assertScopes(
+        //
+        $`foo`,
+        _`~~  example.foo`,
+      );
+    },
+    {
+      message:
+        "Partial assertions are not allowed (asserting 0-2 of 0-3: source.test, example.foo)",
+    },
+  );
+
+  assert.throws(
+    () => {
+      assertScopes(
+        //
+        $`foo`,
+        _` ~~ example.foo`,
+      );
+    },
+    {
+      message:
+        "Partial assertions are not allowed (asserting 1-3 of 0-3: source.test, example.foo)",
+    },
+  );
+
+  assert.throws(
+    () => {
+      assertScopes(
+        //
+        $`foo bar`,
+        _`~~~     example.foo`,
+      );
+    },
+    { message: /Missing assertions for 4-7: source\.test, example\.bar/ },
+  );
+
+  assert.throws(
+    () => {
+      assertScopes(
+        //
+        $`foo bar`,
+        _`    ~~~ example.bar`,
+      );
+    },
+    { message: /Missing assertions for 0-3: source\.test, example\.foo/ },
+  );
 
   assert.throws(
     () => {
@@ -48,6 +107,27 @@ await test("assertions", () => {
         _`~~~~~~ wrong.scope`,
       );
     },
-    { message: "No token found matching assertion (0-6: wrong.scope)" },
+    { message: "Token does not match wrong.scope (0-5: source.test)" },
   );
+
+  assertScopes(
+    //
+    $`begin foo end`,
+    _`~~~~~~~~~~~~~~ example.range`,
+    _`      ~~~      example.foo`,
+  );
+
+  assertScopes(
+    $`begin begin end end`,
+    _`~~~~~~~~~~~~~~~~~~~ example.range`,
+    _`      ~~~~~~~~~     example.range`,
+  );
+
+  assert.throws(() => {
+    assertScopes(
+      //
+      $`begin begin end end`,
+      _`~~~~~~~~~~~~~~~~~~~ example.range`,
+    );
+  }, "Incorrect assertions for 6-11: source.test, example.range, example.range");
 });

test/assert-scopes.test.ts

@@ -3,54 +3,97 @@ import assert from "node:assert/strict";
 import { createHighlighter } from "shiki";
 import type { Grammar, LanguageRegistration } from "shiki";
 
+function formatToken(token: IToken) {
+  return `${token.startIndex}-${token.endIndex}: ${token.scopes.join(", ")}`;
+}
+
 function assertScopes(
   grammar: Grammar,
   rootScopeName: string,
   ...items: (string | ScopeAssertion)[]
 ) {
-  function stripRootScope(scopes: string[]): string[] {
-    if (scopes[0] === rootScopeName) {
-      return scopes.slice(1);
-    }
-    return scopes;
-  }
-
+  let currentLine: string | undefined;
+  let currentState: ReturnType<Grammar["tokenizeLine"]> | undefined;
+  let assertedScopesByTokenIdx: string[][] = [];
   let currentAssertion: ScopeAssertion | undefined;
+  const checkMissingAssertions = () => {
+    if (!currentState || currentLine == undefined) {
+      return;
+    }
+    const noAssertions = assertedScopesByTokenIdx.every((scopes) => scopes.length === 0);
+    if (noAssertions) {
+      assert.fail(
+        "No assertions provided. Suggested assertions:\n" +
+          currentState.tokens
+            .flatMap((token) => {
+              const scopes = token.scopes.filter((scope) => scope !== rootScopeName);
+              if (scopes.length === 0) {
+                return [];
+              }
+              return [
+                "  _`" +
+                  " ".repeat(token.startIndex) +
+                  "~".repeat(token.endIndex - token.startIndex) +
+                  " ".repeat(currentLine!.length - token.endIndex + 1) +
+                  scopes.join(", ") +
+                  "`,",
+              ];
+            })
+            .join("\n"),
+      );
+    }
+    currentState.tokens.forEach((token, i) => {
+      const asserted = assertedScopesByTokenIdx[i]!;
+      assert.deepEqual(
+        asserted.toSorted(),
+        token.scopes.filter((scope) => scope !== rootScopeName).toSorted(),
+        `${asserted.length === 0 ? "Missing" : "Incorrect"} assertions for ${formatToken(token)}`,
+      );
+    });
+  };
   try {
-    let state: ReturnType<Grammar["tokenizeLine"]> | undefined;
-    let tokenIndex = 0;
     for (const item of items) {
       if (typeof item === "string") {
-        if (state && tokenIndex < state.tokens.length) {
-          assert.fail("Not enough assertions");
-        }
-        state = grammar.tokenizeLine(item, state?.ruleStack ?? null);
-        tokenIndex = 0;
+        checkMissingAssertions();
+        currentLine = item;
+        currentState = grammar.tokenizeLine(currentLine, currentState?.ruleStack ?? null);
+        assertedScopesByTokenIdx = Array.from(currentState.tokens, () => []);
+        currentAssertion = undefined;
         continue;
       }
+
+      const prevAssertion = currentAssertion;
       currentAssertion = item;
-      if (!state) {
-        assert.fail("Expected a source line before assertion");
+      if (prevAssertion) {
+        assert(
+          item.startIndex >= prevAssertion.startIndex,
+          "Assertions should be sorted by start index",
+        );
       }
-      while (
-        tokenIndex < state.tokens.length &&
-        (state.tokens[tokenIndex]!.startIndex !== item.startIndex ||
-          state.tokens[tokenIndex]!.endIndex !== item.endIndex)
-      ) {
-        const token: IToken = state.tokens[tokenIndex]!;
-        assert.deepEqual(stripRootScope(token.scopes), [], "Skipped token should have no scopes");
-        ++tokenIndex;
+      if (!currentState || currentLine == undefined) {
+        assert.fail("Expected a source line before assertion");
       }
-      assert(
-        tokenIndex < state.tokens.length,
-        `No token found matching assertion (${item.startIndex}-${item.endIndex}: ${item.scopes.join(", ")})`,
-      );
-      const token = state.tokens[tokenIndex++]!;
-      assert.deepEqual(stripRootScope(token.scopes), item.scopes);
-    }
-    if (state && tokenIndex < state.tokens.length) {
-      assert.fail("Not enough assertions");
+
+      currentState.tokens.forEach((token, i) => {
+        if (token.endIndex <= item.startIndex || token.startIndex >= item.endIndex) {
+          return;
+        }
+        if (token.startIndex < item.startIndex || token.endIndex > item.endIndex) {
+          assert.fail(
+            `Partial assertions are not allowed (asserting ${item.startIndex}-${item.endIndex} of ${formatToken(token)})`,
+          );
+        }
+        const asserted = assertedScopesByTokenIdx[i]!;
+        for (const scope of item.scopes) {
+          assert(
+            token.scopes.includes(scope),
+            `Token does not match ${scope} (${formatToken(token)})`,
+          );
+          asserted.push(scope);
+        }
+      });
     }
+    checkMissingAssertions();
   } catch (err) {
     if (err instanceof assert.AssertionError) {
       const newStack = currentAssertion?.stack;
@@ -87,7 +130,7 @@ class ScopeAssertion {
 }
 
 export function $(strings: TemplateStringsArray): string {
-  return strings[0]!;
+  return strings.raw[0]!;
 }
 
 export function _(strings: TemplateStringsArray): ScopeAssertion {

test/assert-scopes.ts

@@ -13,3 +13,26 @@ await test("basic", () => {
     _`       ~~~~~~ support.type.swift`,
   );
 });
+
+await test("import", () => {
+  assertScopes(
+    $`import Foo   // whitespace ok`,
+    _`~~~~~~~~~~~~~                 meta.import.swift`,
+    _`~~~~~~                        keyword.control.import.swift`,
+    _`       ~~~                    entity.name.type.swift`,
+    _`             ~~~~~~~~~~~~~~~~ comment.line.double-slash.swift`,
+    _`             ~~               punctuation.definition.comment.swift`,
+  );
+
+  assertScopes(
+    $`import func Control.Monad.>>=`,
+    _`~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ meta.import.swift`,
+    _`~~~~~~                        keyword.control.import.swift`,
+    _`       ~~~~                   storage.modifier.swift`,
+    _`            ~~~~~~~           entity.name.type.swift`,
+    _`                   ~          punctuation.separator.import.swift`,
+    _`                    ~~~~~     entity.name.type.swift`,
+    _`                         ~    punctuation.separator.import.swift`,
+    _`                          ~~~ entity.name.type.swift`,
+  );
+});