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

@@ -81,6 +81,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,169 @@
+import {
+  ContiguousScopeType,
+  Direction,
+  Position,
+  Range,
+  ScopeType,
+  TextEditor,
+  next,
+} from "@cursorless/common";
+import { ScopeHandlerFactory } from ".";
+import { Target } from "../../../typings/target.types";
+import { constructScopeRangeTarget } from "../constructScopeRangeTarget";
+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> {
+    let targetRangeOpposite = next(
+      generateTargetRangesInDirection(
+        this.scopeHandler,
+        editor,
+        position,
+        direction === "forward" ? "backward" : "forward",
+      ),
+    );
+
+    const targetRangesIter = generateTargetRangesInDirection(
+      this.scopeHandler,
+      editor,
+      position,
+      direction,
+    );
+
+    for (const targetRange of targetRangesIter) {
+      if (
+        targetRangeOpposite != null &&
+        isAdjacent(targetRangeOpposite.proximal, targetRange.proximal)
+      ) {
+        yield combineScopes(targetRangeOpposite.distal, targetRange.distal);
+        targetRangeOpposite = undefined;
+      } else {
+        yield combineScopes(targetRange.proximal, targetRange.distal);
+      }
+    }
+  }
+}
+
+function combineScopes(scope1: TargetScope, scope2: TargetScope): TargetScope {
+  if (scope1.domain.isRangeEqual(scope2.domain)) {
+    return scope1;
+  }
+
+  return {
+    editor: scope1.editor,
+    domain: scope1.domain.union(scope2.domain),
+    getTargets: (isReversed) => {
+      return constructScopeRangeTarget(isReversed, scope1, scope2);
+    },
+  };
+}
+
+function* generateTargetRangesInDirection(
+  scopeHandler: ScopeHandler,
+  editor: TextEditor,
+  position: Position,
+  direction: Direction,
+): Iterable<{ proximal: TargetScope; distal: TargetScope }> {
+  let proximal, distal: TargetScope | undefined;
+
+  const generator = scopeHandler.generateScopes(editor, position, direction, {
+    allowAdjacentScopes: true,
+    skipAncestorScopes: true,
+  });
+
+  for (const scope of generator) {
+    if (proximal == null) {
+      proximal = scope;
+    }
+
+    if (distal != null) {
+      if (!isAdjacent(distal, scope)) {
+        yield { proximal, distal };
+        proximal = scope;
+      }
+    }
+
+    distal = scope;
+  }
+
+  if (proximal != null && distal != null) {
+    yield { proximal, distal };
+  }
+}
+
+function isAdjacent(scope1: TargetScope, scope2: TargetScope): boolean {
+  if (scope1.domain.isRangeEqual(scope2.domain)) {
+    return true;
+  }
+
+  const [startTarget, endTarget] = getTargetsInDocumentOrder(
+    scope1.getTargets(false)[0],
+    scope2.getTargets(false)[0],
+  );
+
+  const leadingRange =
+    startTarget.getTrailingDelimiterTarget()?.contentRange ??
+    startTarget.contentRange;
+  const trailingRange =
+    endTarget.getLeadingDelimiterTarget()?.contentRange ??
+    endTarget.contentRange;
+
+  if (leadingRange.intersection(trailingRange) != null) {
+    return true;
+  }
+
+  // Non line targets are excluded if they are separated by more than one line
+  if (
+    !startTarget.isLine &&
+    trailingRange.start.line - leadingRange.end.line > 1
+  ) {
+    return false;
+  }
+
+  // Finally targets are excluded if there is non whitespace text between them
+  const rangeBetween = new Range(leadingRange.end, trailingRange.start);
+  const text = startTarget.editor.document.getText(rangeBetween);
+  return /^\s*$/.test(text);
+}
+
+function getTargetsInDocumentOrder(
+  target1: Target,
+  target2: Target,
+): [Target, Target] {
+  return target1.contentRange.start.isBefore(target2.contentRange.start)
+    ? [target1, target2]
+    : [target2, target1];
+}

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: {},

packages/cursorless-vscode-e2e/src/suite/fixtures/recorded/contiguousScopes/changeFatBlock.yml

@@ -0,0 +1,29 @@
+languageId: plaintext
+command:
+  version: 6
+  spokenForm: change fat block
+  action:
+    name: clearAndSetSelection
+    target:
+      type: primitive
+      modifiers:
+        - type: containingScope
+          scopeType:
+            type: contiguous
+            scopeType: {type: paragraph}
+  usePrePhraseSnapshot: true
+initialState:
+  documentContents: |-
+    aaa
+    aaa
+
+    bbb
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  marks: {}
+finalState:
+  documentContents: ""
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}