Contiguous scope

cursorless-talon/src/modifiers/scopes.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from talon import Module
 
 mod = Module()
@@ -12,28 +14,45 @@
     "cursorless_custom_regex_scope_type_plural",
     desc="Supported plural custom regular expression scope types",
 )
+mod.list(
+    "cursorless_contiguous_scope_type",
+    desc="Cursorless contiguous scope type",
+)
 
 
 @mod.capture(
-    rule="{user.cursorless_scope_type} | {user.cursorless_custom_regex_scope_type}"
+    rule="[{user.cursorless_contiguous_scope_type}] ({user.cursorless_scope_type} | {user.cursorless_custom_regex_scope_type})"
 )
-def cursorless_scope_type(m) -> dict[str, str]:
+def cursorless_scope_type(m) -> dict[str, Any]:
     """Cursorless scope type singular"""
     try:
-        return {"type": m.cursorless_scope_type}
+        scope_type = {"type": m.cursorless_scope_type}
     except AttributeError:
-        return {"type": "customRegex", "regex": m.cursorless_custom_regex_scope_type}
+        scope_type = {
+            "type": "customRegex",
+            "regex": m.cursorless_custom_regex_scope_type,
+        }
+
+    try:
+        return {"type": m.cursorless_contiguous_scope_type, "scopeType": scope_type}
+    except AttributeError:
+        return scope_type
 
 
 @mod.capture(
-    rule="{user.cursorless_scope_type_plural} | {user.cursorless_custom_regex_scope_type_plural}"
+    rule="[{user.cursorless_contiguous_scope_type}] ({user.cursorless_scope_type_plural} | {user.cursorless_custom_regex_scope_type_plural})"
 )
-def cursorless_scope_type_plural(m) -> dict[str, str]:
+def cursorless_scope_type_plural(m) -> dict[str, Any]:
     """Cursorless scope type plural"""
     try:
-        return {"type": m.cursorless_scope_type_plural}
+        scope_type = {"type": m.cursorless_scope_type_plural}
     except AttributeError:
-        return {
+        scope_type = {
             "type": "customRegex",
             "regex": m.cursorless_custom_regex_scope_type_plural,
         }
+
+    try:
+        return {"type": m.cursorless_contiguous_scope_type, "scopeType": scope_type}
+    except AttributeError:
+        return scope_type

cursorless-talon/src/spoken_forms.json

@@ -80,6 +80,7 @@
       "visible": "visible"
     },
     "simple_scope_modifier": { "every": "every" },
+    "contiguous_scope_type": { "fat": "contiguous" },
     "interior_modifier": {
       "inside": "interiorOnly"
     },

packages/common/src/types/command/PartialTargetDescriptor.types.ts

@@ -205,11 +205,17 @@ export interface OneOfScopeType {
   scopeTypes: ScopeType[];
 }
 
+export interface ContiguousScopeType {
+  type: "contiguous";
+  scopeType: ScopeType;
+}
+
 export type ScopeType =
   | SimpleScopeType
   | SurroundingPairScopeType
   | CustomRegexScopeType
-  | OneOfScopeType;
+  | OneOfScopeType
+  | ContiguousScopeType;
 
 export interface ContainingSurroundingPairModifier
   extends ContainingScopeModifier {

packages/common/src/util/itertools.ts

@@ -65,3 +65,17 @@ export function isEmptyIterable(iterable: Iterable<unknown>): boolean {
 
   return true;
 }
+
+/**
+ * Returns the first element of the given iterable, or `undefined` if the
+ * iterable is empty
+ * @param iterable The iterable to get the first element of
+ * @returns The first element of the iterable, or `undefined` if the iterable
+ * is empty
+ */
+export function next<T>(generator: Iterable<T>): T | undefined {
+  for (const value of generator) {
+    return value;
+  }
+  return undefined;
+}

packages/cursorless-engine/src/generateSpokenForm/primitiveTargetToSpokenForm.ts

@@ -208,6 +208,12 @@ export class PrimitiveTargetSpokenFormGenerator {
     switch (scopeType.type) {
       case "oneOf":
         throw new NoSpokenFormError(`Scope type '${scopeType.type}'`);
+
+      case "contiguous": {
+        const scope = this.handleScopeType(scopeType.scopeType);
+        return [this.spokenFormMap.modifierExtra.contiguousScope, scope];
+      }
+
       case "surroundingPair": {
         const pair = this.spokenFormMap.pairedDelimiter[scopeType.delimiter];
         if (scopeType.forceDirection != null) {

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/ContiguousScopeHandler.ts

@@ -0,0 +1,209 @@
+import {
+  ContiguousScopeType,
+  Direction,
+  Position,
+  Range,
+  ScopeType,
+  TextEditor,
+  next,
+} from "@cursorless/common";
+import { ScopeHandlerFactory } from ".";
+import type { Target } from "../../../typings/target.types";
+import { BaseScopeHandler } from "./BaseScopeHandler";
+import type { TargetScope } from "./scope.types";
+import type {
+  CustomScopeType,
+  ScopeHandler,
+  ScopeIteratorRequirements,
+} from "./scopeHandler.types";
+
+export class ContiguousScopeHandler extends BaseScopeHandler {
+  protected readonly isHierarchical = false;
+  private readonly scopeHandler: ScopeHandler;
+
+  constructor(
+    private scopeHandlerFactory: ScopeHandlerFactory,
+    public scopeType: ContiguousScopeType,
+    languageId: string,
+  ) {
+    super();
+    const handler = scopeHandlerFactory.create(scopeType.scopeType, languageId);
+    if (handler == null) {
+      throw new Error(
+        `No available scope handler for '${scopeType.scopeType.type}'`,
+      );
+    }
+    this.scopeHandler = handler;
+  }
+
+  get iterationScopeType(): ScopeType | CustomScopeType {
+    return this.scopeHandler.iterationScopeType;
+  }
+
+  generateScopeCandidates(
+    editor: TextEditor,
+    position: Position,
+    direction: Direction,
+    _hints: ScopeIteratorRequirements,
+  ): Iterable<TargetScope> {
+    return direction === "backward"
+      ? this.generateScopeCandidatesBackward(editor, position)
+      : this.generateScopeCandidatesForward(editor, position);
+  }
+
+  private *generateScopeCandidatesBackward(
+    editor: TextEditor,
+    position: Position,
+  ): Iterable<TargetScope> {
+    let targetRangeForward = next(
+      generateTargetRangesInDirection(
+        this.scopeHandler,
+        editor,
+        position,
+        "forward",
+      ),
+    );
+
+    const targetRangesBackwardIter = generateTargetRangesInDirection(
+      this.scopeHandler,
+      editor,
+      position,
+      "backward",
+    );
+
+    for (const targetRange of targetRangesBackwardIter) {
+      if (
+        targetRangeForward != null &&
+        isAdjacent(targetRange[1], targetRangeForward[0])
+      ) {
+        yield targetsToScope(targetRange[0], targetRangeForward[1]);
+        targetRangeForward = undefined;
+      } else {
+        yield targetsToScope(...targetRange);
+      }
+    }
+  }
+
+  private *generateScopeCandidatesForward(
+    editor: TextEditor,
+    position: Position,
+  ): Iterable<TargetScope> {
+    let targetRangeBackward = next(
+      generateTargetRangesInDirection(
+        this.scopeHandler,
+        editor,
+        position,
+        "backward",
+      ),
+    );
+
+    const targetRangesForwardIter = generateTargetRangesInDirection(
+      this.scopeHandler,
+      editor,
+      position,
+      "forward",
+    );
+
+    for (const targetRange of targetRangesForwardIter) {
+      if (
+        targetRangeBackward != null &&
+        isAdjacent(targetRangeBackward[1], targetRange[0])
+      ) {
+        yield targetsToScope(targetRangeBackward[0], targetRange[1]);
+        targetRangeBackward = undefined;
+      } else {
+        yield targetsToScope(...targetRange);
+      }
+    }
+  }
+}
+
+function targetsToScope(
+  leadingTarget: Target,
+  trailingTarget: Target,
+): TargetScope {
+  if (leadingTarget.contentRange.isRangeEqual(trailingTarget.contentRange)) {
+    return {
+      editor: leadingTarget.editor,
+      domain: leadingTarget.contentRange,
+      getTargets: () => [leadingTarget],
+    };
+  }
+
+  const range = leadingTarget.contentRange.union(trailingTarget.contentRange);
+  return {
+    editor: leadingTarget.editor,
+    domain: range,
+    getTargets: () => [leadingTarget.withContentRange(range)],
+  };
+}
+
+function* generateTargetRangesInDirection(
+  scopeHandler: ScopeHandler,
+  editor: TextEditor,
+  position: Position,
+  direction: Direction,
+): Iterable<[Target, Target]> {
+  const isForward = direction === "forward";
+  let first, last: Target | undefined;
+
+  const generator = scopeHandler.generateScopes(editor, position, direction, {
+    allowAdjacentScopes: true,
+    skipAncestorScopes: true,
+  });
+
+  for (const scope of generator) {
+    for (const target of scope.getTargets(false)) {
+      if (first == null) {
+        first = target;
+      }
+
+      if (last != null) {
+        const [leadingTarget, trailingTarget] = isForward
+          ? [last, target]
+          : [target, last];
+
+        if (!isAdjacent(leadingTarget, trailingTarget)) {
+          yield isForward ? [first, last] : [last, first];
+          first = target;
+        }
+      }
+
+      last = target;
+    }
+  }
+
+  if (first != null && last != null) {
+    yield isForward ? [first, last] : [last, first];
+  }
+}
+
+function isAdjacent(leadingTarget: Target, trailingTarget: Target): boolean {
+  if (
+    leadingTarget.contentRange.intersection(trailingTarget.contentRange) != null
+  ) {
+    return true;
+  }
+
+  const leadingRange =
+    leadingTarget.getTrailingDelimiterTarget()?.contentRange ??
+    leadingTarget.contentRange;
+  const trailingRange =
+    trailingTarget.getLeadingDelimiterTarget()?.contentRange ??
+    trailingTarget.contentRange;
+
+  if (leadingRange.intersection(trailingRange) != null) {
+    return true;
+  }
+
+  if (
+    !leadingTarget.isLine &&
+    trailingRange.start.line - leadingRange.end.line > 1
+  ) {
+    return false;
+  }
+
+  const rangeBetween = new Range(leadingRange.end, trailingRange.start);
+  const text = leadingTarget.editor.document.getText(rangeBetween);
+  return /^\s*$/.test(text);
+}

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/ScopeHandlerFactoryImpl.ts

@@ -1,18 +1,21 @@
 import type { ScopeType } from "@cursorless/common";
+import { LanguageDefinitions } from "../../../languages/LanguageDefinitions";
 import { CharacterScopeHandler } from "./CharacterScopeHandler";
-import { CustomRegexScopeHandler } from "./RegexScopeHandler";
+import { ContiguousScopeHandler } from "./ContiguousScopeHandler";
 import { DocumentScopeHandler } from "./DocumentScopeHandler";
 import { IdentifierScopeHandler } from "./IdentifierScopeHandler";
 import { LineScopeHandler } from "./LineScopeHandler";
-import { NonWhitespaceSequenceScopeHandler } from "./RegexScopeHandler";
 import { OneOfScopeHandler } from "./OneOfScopeHandler";
 import { ParagraphScopeHandler } from "./ParagraphScopeHandler";
+import {
+  CustomRegexScopeHandler,
+  NonWhitespaceSequenceScopeHandler,
+  UrlScopeHandler,
+} from "./RegexScopeHandler";
 import { ScopeHandlerFactory } from "./ScopeHandlerFactory";
 import { SentenceScopeHandler } from "./SentenceScopeHandler/SentenceScopeHandler";
 import { TokenScopeHandler } from "./TokenScopeHandler";
-import { UrlScopeHandler } from "./RegexScopeHandler";
 import { WordScopeHandler } from "./WordScopeHandler/WordScopeHandler";
-import { LanguageDefinitions } from "../../../languages/LanguageDefinitions";
 import type { CustomScopeType, ScopeHandler } from "./scopeHandler.types";
 
 /**
@@ -72,6 +75,8 @@ export class ScopeHandlerFactoryImpl implements ScopeHandlerFactory {
         return new CustomRegexScopeHandler(this, scopeType, languageId);
       case "custom":
         return scopeType.scopeHandler;
+      case "contiguous":
+        return new ContiguousScopeHandler(this, scopeType, languageId);
       case "instance":
         // Handle instance pseudoscope with its own special modifier
         throw Error("Unexpected scope type 'instance'");

packages/cursorless-engine/src/scopeProviders/ScopeInfoProvider.ts

@@ -175,6 +175,9 @@ function isLanguageSpecific(scopeType: ScopeType): boolean {
     case "customRegex":
       return false;
 
+    case "contiguous":
+      return isLanguageSpecific(scopeType.scopeType);
+
     case "oneOf":
       throw Error(
         `Can't decide whether scope type ${JSON.stringify(

packages/cursorless-engine/src/spokenForms/SpokenFormType.ts

@@ -59,6 +59,7 @@ type ModifierExtra =
   | "previous"
   | "next"
   | "forward"
-  | "backward";
+  | "backward"
+  | "contiguousScope";
 
 export type SpokenFormType = keyof SpokenFormMapKeyTypes;

packages/cursorless-engine/src/spokenForms/defaultSpokenFormMapCore.ts

@@ -130,6 +130,7 @@ export const defaultSpokenFormMapCore: DefaultSpokenFormMapDefinition = {
     next: "next",
     forward: "forward",
     backward: "backward",
+    contiguousScope: "fat",
   },
 
   customRegex: {},