Added tree

Author: AndreasArvidsson

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/CollectionItemScopeHandler/CollectionItemTextualScopeHandler.ts

@@ -15,9 +15,11 @@ import type {
 } from "../scopeHandler.types";
 import type { ScopeHandlerFactory } from "../ScopeHandlerFactory";
 import { collectionItemIterationScopeHandler } from "./collectionItemIterationScopeHandler";
+import { createRangeTree } from "./createRangeTree";
 import { createTargetScope } from "./createTargetScope";
 import { getInteriorRanges } from "./getInteriorRanges";
 import { getSeparatorOccurrences } from "./getSeparatorOccurrences";
+import { RangeIterator } from "./RangeIterator";
 
 export class CollectionItemTextualScopeHandler extends BaseScopeHandler {
   public scopeType: ScopeType = { type: "collectionItem" };
@@ -48,28 +50,33 @@ export class CollectionItemTextualScopeHandler extends BaseScopeHandler {
       editor,
       "collectionBoundary",
     );
+    const interiorRangeIterator = new RangeIterator(
+      createRangeTree(interiorRanges),
+    );
     const stringRanges = getInteriorRanges(
       this.scopeHandlerFactory,
       this.languageId,
       editor,
       "string",
     );
+    const stringRangeIterator = new RangeIterator(stringRanges);
     const scopes: TargetScope[] = [];
     const usedInteriors = new Set<Range>();
     const iterationStatesStack: IterationState[] = [];
 
     for (const separator of separatorRanges) {
       // Separators in a string are not considered
-      if (stringRanges.contains(separator)) {
+      if (stringRangeIterator.contains(separator)) {
         continue;
       }
 
       const currentIterationState =
         iterationStatesStack[iterationStatesStack.length - 1];
 
       // Get range for smallest containing interior
-      const containingInteriorRange =
-        interiorRanges.getsSmallestContaining(separator);
+      const containingInteriorRange = interiorRangeIterator
+        .getContaining(separator)
+        ?.getSmallLestContaining(separator);
 
       // The contain range is either the interior or the line containing the separator
       const containingIterationRange =
@@ -122,7 +129,7 @@ export class CollectionItemTextualScopeHandler extends BaseScopeHandler {
     }
 
     // Add interior ranges without a delimiter in them. eg: `[foo]`
-    for (const interior of interiorRanges.ranges) {
+    for (const interior of interiorRanges) {
       if (!usedInteriors.has(interior)) {
         const range = shrinkRangeToFitContent(editor, interior);
         if (!range.isEmpty) {

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/CollectionItemScopeHandler/RangeIterator.ts

@@ -1,20 +1,32 @@
 import type { Range } from "@cursorless/common";
 
-export class RangeIterator {
+export class RangeIterator<T extends Range> {
   private index = 0;
 
-  constructor(public ranges: Range[]) {}
+  constructor(public ranges: T[]) {}
 
   contains(separator: Range): boolean {
+    return this.advance(separator);
+  }
+
+  getContaining(separator: Range): T | undefined {
+    if (!this.advance(separator)) {
+      return undefined;
+    }
+
+    return this.ranges[this.index];
+  }
+
+  private advance(separator: Range): boolean {
     while (this.index < this.ranges.length) {
       const range = this.ranges[this.index];
 
       if (range.contains(separator)) {
         return true;
       }
 
-      // Separator is after the range. Since the ranges are sorted, we can stop here.
-      if (separator.start.isAfter(range.end)) {
+      // Separator is before the range. Since the ranges are sorted, we can stop here.
+      if (separator.end.isBefore(range.start)) {
         return false;
       }
 
@@ -23,15 +35,4 @@ export class RangeIterator {
 
     return false;
   }
-
-  getsSmallestContaining(separator: Range): Range | undefined {
-    //   TODO: fixed performance on large files
-    return this.ranges
-      .filter((range) => range.contains(separator))
-      .sort((a, b) => (a.contains(b) ? 1 : b.contains(a) ? -1 : 0))[0];
-  }
 }
-
-// const containingInteriorRange: Range | undefined = interiorRanges
-//         .filter((range) => range.contains(separator))
-//         .sort((a, b) => (a.contains(b) ? 1 : b.contains(a) ? -1 : 0))[0];

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/CollectionItemScopeHandler/RangeNode.ts

@@ -0,0 +1,22 @@
+import { Range } from "@cursorless/common";
+
+export class RangeNode extends Range {
+  children: RangeNode[] = [];
+
+  constructor(private range: Range) {
+    super(range.start, range.end);
+  }
+
+  getSmallLestContaining(separator: Range): Range {
+    let result = this.range;
+
+    for (const child of this.children) {
+      if (child.contains(separator)) {
+        result = child.getSmallLestContaining(separator);
+        break;
+      }
+    }
+
+    return result;
+  }
+}

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/CollectionItemScopeHandler/createRangeTree.ts

@@ -0,0 +1,27 @@
+import type { Range } from "@cursorless/common";
+import { RangeNode } from "./RangeNode";
+
+export function createRangeTree(ranges: Range[]): RangeNode[] {
+  const results: RangeNode[] = [];
+
+  const parents: RangeNode[] = [];
+
+  for (const range of ranges) {
+    const node = new RangeNode(range);
+
+    while (parents.length > 0 && !parents[parents.length - 1].contains(range)) {
+      parents.pop();
+    }
+
+    const parent = parents[parents.length - 1];
+
+    if (parent != null) {
+      parent.children.push(node);
+    } else {
+      parents.push(node);
+      results.push(node);
+    }
+  }
+
+  return results;
+}

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/CollectionItemScopeHandler/getInteriorRanges.ts

@@ -1,17 +1,17 @@
 import {
+  type Range,
   type SurroundingPairName,
   type TextEditor,
   Position,
 } from "@cursorless/common";
 import type { ScopeHandlerFactory } from "../ScopeHandlerFactory";
-import { RangeIterator } from "./RangeIterator";
 
 export function getInteriorRanges(
   scopeHandlerFactory: ScopeHandlerFactory,
   languageId: string,
   editor: TextEditor,
   delimiter: SurroundingPairName,
-): RangeIterator {
+): Range[] {
   const scopeHandler = scopeHandlerFactory.create(
     {
       type: "surroundingPairInterior",
@@ -20,14 +20,12 @@ export function getInteriorRanges(
     languageId,
   );
 
-  const ranges = Array.from(
+  return Array.from(
     scopeHandler.generateScopes(editor, new Position(0, 0), "forward", {
       containment: undefined,
       skipAncestorScopes: false,
       includeDescendantScopes: true,
     }),
     (scope) => scope.domain,
   );
-
-  return new RangeIterator(ranges);
 }