Handle multiple targets per scope

Author: AndreasArvidsson

packages/cursorless-org-docs/scripts/prepare-assets.ts

@@ -6,13 +6,6 @@ import {
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-interface Scope {
-  content?: string;
-  removal?: string;
-  domain?: string;
-  insertionDelimiter?: string;
-}
-
 interface Fixture {
   name: string;
   facet: string;
@@ -21,6 +14,17 @@ interface Fixture {
   scopes: Scope[];
 }
 
+interface Scope {
+  domain?: string;
+  targets: Target[];
+}
+
+interface Target {
+  content?: string;
+  removal?: string;
+  insertionDelimiter?: string;
+}
+
 const fixtures: Fixture[] = [];
 
 for (const test of getScopeTestPaths()) {
@@ -48,23 +52,25 @@ function parseTest(test: ScopeTestPath) {
   const lines = fixture.substring(delimiterIndex + 4).split(/\n/);
   const scopes: Scope[] = [];
   const unprocessedTypes: string[] = [];
-  let currentScopeIndex = "";
-  let currentScope: Scope = {};
+  let currentScopeIndex = "1";
+  let currentTargetIndex = "1";
+  let currentTarget: Target = {};
+  let currentScope: Scope = { targets: [currentTarget] };
 
   function processLine(type: string, value: string) {
     switch (type) {
+      case "Domain":
+        currentScope.domain = value;
+        break;
       case "Content":
       case "Range":
-        currentScope.content = value;
+        currentTarget.content = value;
         break;
       case "Removal":
-        currentScope.removal = value;
-        break;
-      case "Domain":
-        currentScope.domain = value;
+        currentTarget.removal = value;
         break;
       case "Insertion delimiter":
-        currentScope.insertionDelimiter = value.substring(1, value.length - 1);
+        currentTarget.insertionDelimiter = value.substring(1, value.length - 1);
         break;
       case "Leading delimiter":
       case "Leading delimiter: Content":
@@ -97,17 +103,16 @@ function parseTest(test: ScopeTestPath) {
 
     const { scopeIndex, targetIndex, type, value } = parsedLine;
 
-    if (targetIndex != null) {
-      // TODO: handle target index fixtures
-      return;
-    }
-
-    if (scopeIndex != null && scopeIndex !== currentScopeIndex) {
-      if (currentScopeIndex !== "") {
-        scopes.push(currentScope);
-      }
+    if (scopeIndex !== currentScopeIndex) {
+      scopes.push(currentScope);
       currentScopeIndex = scopeIndex;
-      currentScope = {};
+      currentTargetIndex = "1";
+      currentTarget = {};
+      currentScope = { targets: [currentTarget] };
+    } else if (targetIndex != null && targetIndex !== currentTargetIndex) {
+      currentTargetIndex = targetIndex;
+      currentTarget = {};
+      currentScope.targets.push(currentTarget);
     }
 
     if (value == null) {
@@ -125,9 +130,7 @@ function parseTest(test: ScopeTestPath) {
     processLine(type, value);
   }
 
-  if (currentScope != null) {
-    scopes.push(currentScope);
-  }
+  scopes.push(currentScope);
 
   const result: Fixture = {
     name: test.name,
@@ -158,7 +161,7 @@ function parseLine(line: string) {
       };
     }
     return {
-      scopeIndex: undefined,
+      scopeIndex: "1",
       targetIndex: undefined,
       type: header,
     };

packages/cursorless-org-docs/src/docs/user/languages/components/ScopeVisualizer.tsx

@@ -5,13 +5,6 @@ import { Code, type Highlight } from "./Code";
 
 type RangeType = "content" | "removal";
 
-interface Scope {
-  content: string;
-  removal?: string;
-  domain?: string;
-  insertionDelimiter?: string;
-}
-
 interface Fixture {
   name: string;
   facet: string;
@@ -20,6 +13,17 @@ interface Fixture {
   scopes: Scope[];
 }
 
+interface Scope {
+  domain?: string;
+  targets: Target[];
+}
+
+interface Target {
+  content: string;
+  removal?: string;
+  insertionDelimiter?: string;
+}
+
 const scopeTests = scopeTestsExport as Fixture[];
 
 interface Props {
@@ -63,42 +67,45 @@ function renderFixture(
   renderWhitespace: boolean,
 ) {
   const highlights: Highlight[] = [];
-
   let previousRange: Range | undefined;
 
   for (const scope of fixture.scopes) {
-    const conciseRange =
+    const conciseRanges =
       rangeType === "content"
-        ? scope.content
-        : (scope.removal ?? scope.content);
-    let range = Range.fromConcise(conciseRange);
+        ? scope.targets.map((t) => t.content)
+        : scope.targets.map((t) => t.removal ?? t.content);
+    const ranges = conciseRanges.map((r) => Range.fromConcise(r));
 
-    if (scope.domain != null && scope.domain !== conciseRange) {
+    if (scope.domain != null && conciseRanges.some((r) => r !== scope.domain)) {
       highlights.push({
         type: "domain",
         range: Range.fromConcise(scope.domain),
       });
     }
 
-    if (previousRange != null) {
-      const intersection = previousRange.intersection(range);
+    for (const r of ranges) {
+      let range = r;
 
-      if (intersection != null && !intersection.isEmpty) {
-        highlights.push({
-          type: rangeType,
-          range: intersection,
-        });
+      if (previousRange != null) {
+        const intersection = previousRange.intersection(range);
 
-        range = new Range(intersection.end, range.end);
+        if (intersection != null && !intersection.isEmpty) {
+          highlights.push({
+            type: rangeType,
+            range: intersection,
+          });
+
+          range = new Range(intersection.end, range.end);
+        }
       }
-    }
 
-    highlights.push({
-      type: rangeType,
-      range,
-    });
+      highlights.push({
+        type: rangeType,
+        range,
+      });
 
-    previousRange = range;
+      previousRange = range;
+    }
   }
 
   return (