Draft off one of compound scope type

Author: AndreasArvidsson

src/processTargets/modifiers/scopeHandlers/LineScopeHandler.ts

@@ -1,6 +1,6 @@
 import { range } from "lodash";
 import { Position, Range, TextEditor } from "vscode";
-import { Direction } from "../../../typings/targetDescriptor.types";
+import { Direction, ScopeType } from "../../../typings/targetDescriptor.types";
 import { getDocumentRange } from "../../../util/range";
 import { LineTarget } from "../../targets";
 import { OutOfRangeError } from "../targetSequenceUtils";
@@ -12,7 +12,7 @@ export default class LineScopeHandler implements ScopeHandler {
   public readonly iterationScopeType = { type: "document" } as const;
 
   constructor(
-    public readonly scopeType: { type: "line" },
+    public readonly scopeType: ScopeType,
     protected languageId: string
   ) {}
 

src/processTargets/modifiers/scopeHandlers/OneOfScopeHandler.ts

@@ -0,0 +1,91 @@
+import { Position, Range, TextEditor } from "vscode";
+import { getScopeHandler } from ".";
+import {
+  Direction,
+  OneOfScopeType,
+} from "../../../typings/targetDescriptor.types";
+import type { IterationScope, Scope, TargetScope } from "./scope.types";
+import { ScopeHandler } from "./scopeHandler.types";
+
+export default class OneOfScopeHandler implements ScopeHandler {
+  iterationScopeType = undefined;
+
+  constructor(
+    public readonly scopeType: OneOfScopeType,
+    private languageId: string
+  ) {}
+
+  /** Return smallest target scope touching position */
+  getScopesTouchingPosition(
+    editor: TextEditor,
+    position: Position,
+    ancestorIndex?: number
+  ): TargetScope[] {
+    const targetScopes = this.getsScopeHandlers().flatMap((scopeHandler) =>
+      scopeHandler.getScopesTouchingPosition(editor, position, ancestorIndex)
+    );
+    targetScopes.sort(scopeComparator);
+    return [targetScopes[0]];
+  }
+
+  /** Return all scopes overlapping range not contained by another scope */
+  getScopesOverlappingRange(editor: TextEditor, range: Range): TargetScope[] {
+    const targetScopes = this.getsScopeHandlers().flatMap((scopeHandler) =>
+      scopeHandler.getScopesOverlappingRange(editor, range)
+    );
+    return targetScopes.filter(
+      (targetScope) =>
+        !targetScopes.find((s) => s.domain.contains(targetScope.domain))
+    );
+  }
+
+  /** Returns smallest iteration scope touching position */
+  getIterationScopesTouchingPosition(
+    editor: TextEditor,
+    position: Position
+  ): IterationScope[] {
+    const iterationScopes = this.getsScopeHandlers().flatMap((scopeHandler) =>
+      scopeHandler.getIterationScopesTouchingPosition(editor, position)
+    );
+    iterationScopes.sort(scopeComparator);
+    return [iterationScopes[0]];
+  }
+
+  getScopeRelativeToPosition(
+    editor: TextEditor,
+    position: Position,
+    offset: number,
+    direction: Direction
+  ): TargetScope {
+    throw new Error("not implemented");
+    // const scopeType=this.scopeType.scopeTypes[offset]
+    // const targetScopes = this.getsScopeHandlers().map((scopeHandler) =>
+    //   scopeHandler.getScopeRelativeToPosition(
+    //     editor,
+    //     position,
+    //     offset,
+    //     direction
+    //   )
+    // )
+  }
+
+  private getsScopeHandlers(): ScopeHandler[] {
+    return this.scopeType.scopeTypes.map((scopeType) => {
+      const handler = getScopeHandler(scopeType, this.languageId);
+      if (handler == null) {
+        throw new Error(`No available scope handler for '${scopeType.type}'`);
+      }
+      return handler;
+    });
+  }
+}
+
+function scopeComparator(a: Scope, b: Scope): number {
+  if (a.domain.contains(b.domain)) {
+    return 1;
+  }
+  if (b.domain.contains(a.domain)) {
+    return -1;
+  }
+  return 0;
+}

src/processTargets/modifiers/scopeHandlers/getScopeHandler.ts

@@ -4,6 +4,7 @@ import {
   LineScopeHandler,
   TokenScopeHandler,
   WordScopeHandler,
+  OneOfScopeHandler,
 } from ".";
 import type { ScopeType } from "../../../typings/targetDescriptor.types";
 import type { ScopeHandler } from "./scopeHandler.types";
@@ -39,7 +40,9 @@ export default function getScopeHandler(
     case "identifier":
       return new IdentifierScopeHandler(scopeType, languageId);
     case "line":
-      return new LineScopeHandler(scopeType as { type: "line" }, languageId);
+      return new LineScopeHandler(scopeType, languageId);
+    case "oneOf":
+      return new OneOfScopeHandler(scopeType, languageId);
     default:
       return undefined;
   }

src/processTargets/modifiers/scopeHandlers/index.ts

@@ -10,5 +10,7 @@ export * from "./WordScopeHandler";
 export { default as WordScopeHandler } from "./WordScopeHandler";
 export * from "./TokenScopeHandler";
 export { default as TokenScopeHandler } from "./TokenScopeHandler";
+export * from "./OneOfScopeHandler";
+export { default as OneOfScopeHandler } from "./OneOfScopeHandler";
 export * from "./getScopeHandler";
 export { default as getScopeHandler } from "./getScopeHandler";

src/typings/targetDescriptor.types.ts

@@ -156,10 +156,16 @@ export interface SurroundingPairScopeType {
   requireStrongContainment?: boolean;
 }
 
+export interface OneOfScopeType {
+  type: "oneOf";
+  scopeTypes: ScopeType[];
+}
+
 export type ScopeType =
   | SimpleScopeType
   | SurroundingPairScopeType
-  | CustomRegexScopeType;
+  | CustomRegexScopeType
+  | OneOfScopeType;
 
 export interface ContainingSurroundingPairModifier
   extends ContainingScopeModifier {