implement 'short paint' scope type (#737)

* implement 'small paint' scope type

* additional test with white space on each side

* updates to get small paint working besides removal range

* stage refactors recommended during pair programming

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* revert some refactors after merging

* Updates small paint to stop on any surrounding pairs' delimiter

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* some additional small paint tests

* rename small paint stage

* remove unnecessary changed

* update default phrase from small paint to short paint

* update short paint every behavior

* update short paint to call process surrounding pair directly

* fix short paint stage capitalization

* fix short paint modifier capitalization

* update small paint  every tests and scope type in tests

* refactor  short paint

* Switch to strong containment implementation

* fix bug with paint selection type

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fix a reference to short paint stage name

* remove outdated tests

* boundedNonWhitespaceStage -> BoundedNonWhitespaceStage

* Cleanup

* paint and short paint tests

* better change every paint pair tests

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Andreas Arvidsson <[email protected]>
Co-authored-by: Pokey Rule <[email protected]>

Author: 4 people

cursorless-talon/src/modifiers/containing_scope.py

@@ -53,6 +53,7 @@
     "file": "document",
     "line": "line",
     "paint": "nonWhitespaceSequence",
+    "short paint": "boundedNonWhitespaceSequence",
     "link": "url",
     "token": "token",
 }

src/processTargets/getModifierStage.ts

@@ -31,6 +31,9 @@ import {
   UrlStage,
 } from "./modifiers/scopeTypeStages/RegexStage";
 import TokenStage from "./modifiers/scopeTypeStages/TokenStage";
+import BoundedNonWhitespaceSequenceStage, {
+  BoundedNonWhitespaceSequenceModifier,
+} from "./modifiers/BoundedNonWhitespaceStage";
 import SurroundingPairStage from "./modifiers/SurroundingPairStage";
 import { ModifierStage } from "./PipelineStages.types";
 
@@ -89,6 +92,10 @@ const getContainingScopeStage = (
       return new NonWhitespaceSequenceStage(
         modifier as NonWhitespaceSequenceModifier
       );
+    case "boundedNonWhitespaceSequence":
+      return new BoundedNonWhitespaceSequenceStage(
+        modifier as BoundedNonWhitespaceSequenceModifier
+      );
     case "url":
       return new UrlStage(modifier as UrlModifier);
     case "surroundingPair":

src/processTargets/modifiers/BoundedNonWhitespaceStage.ts

@@ -0,0 +1,77 @@
+import { Target } from "../../typings/target.types";
+import {
+  ContainingScopeModifier,
+  EveryScopeModifier,
+} from "../../typings/targetDescriptor.types";
+import { ProcessedTargetsContext } from "../../typings/Types";
+import { ModifierStage } from "../PipelineStages.types";
+import { TokenTarget } from "../targets";
+import getModifierStage from "../getModifierStage";
+import { processSurroundingPair } from "./surroundingPair";
+import { NoContainingScopeError } from "../../errors";
+
+export type BoundedNonWhitespaceSequenceModifier = (
+  | ContainingScopeModifier
+  | EveryScopeModifier
+) & {
+  scopeType: { type: "boundedNonWhitespaceSequence" };
+};
+
+/**
+ * Intersection of NonWhitespaceSequenceStage and a surrounding pair
+ * Expand the target until reaching a white space or surrounding pair.
+ * If there is no surrounding pair defaults to the non white space sequence
+ */
+export default class BoundedNonWhitespaceSequenceStage
+  implements ModifierStage
+{
+  constructor(private modifier: BoundedNonWhitespaceSequenceModifier) {}
+
+  run(context: ProcessedTargetsContext, target: Target): Target[] {
+    const paintStage = getModifierStage({
+      type: this.modifier.type,
+      scopeType: { type: "nonWhitespaceSequence" },
+    });
+
+    const paintTargets = paintStage.run(context, target);
+
+    const pairInfo = processSurroundingPair(
+      context,
+      target.editor,
+      target.contentRange,
+      {
+        type: "surroundingPair",
+        delimiter: "any",
+        requireStrongContainment: true,
+      }
+    );
+
+    if (pairInfo == null) {
+      return paintTargets;
+    }
+
+    const targets = paintTargets.flatMap((paintTarget) => {
+      const contentRange = paintTarget.contentRange.intersection(
+        pairInfo.interiorRange
+      );
+
+      if (contentRange == null || contentRange.isEmpty) {
+        return [];
+      }
+
+      return [
+        new TokenTarget({
+          editor: target.editor,
+          isReversed: target.isReversed,
+          contentRange,
+        }),
+      ];
+    });
+
+    if (targets.length === 0) {
+      throw new NoContainingScopeError(this.modifier.scopeType.type);
+    }
+
+    return targets;
+  }
+}

src/processTargets/modifiers/scopeTypeStages/RegexStage.ts

@@ -38,7 +38,10 @@ class RegexStage implements ModifierStage {
     for (let i = start.line; i <= end.line; ++i) {
       this.getMatchesForLine(editor, i).forEach((range) => {
         // Regex match and selection intersects
-        if (range.end.isAfterOrEqual(start) && range.end.isBeforeOrEqual(end)) {
+        if (
+          range.end.isAfterOrEqual(start) &&
+          range.start.isBeforeOrEqual(end)
+        ) {
           targets.push(this.getTargetFromRange(target, range));
         }
       });

src/processTargets/modifiers/surroundingPair/findDelimiterPairAdjacentToSelection.ts

@@ -1,11 +1,13 @@
+import { SurroundingPairScopeType } from "../../../typings/targetDescriptor.types";
+import { findOppositeDelimiter } from "./findOppositeDelimiter";
 import { getSurroundingPairOffsets } from "./getSurroundingPairOffsets";
 import {
-  SurroundingPairOffsets,
+  DelimiterOccurrence,
   Offsets,
   PossibleDelimiterOccurrence,
-  DelimiterOccurrence,
+  SurroundingPairOffsets,
 } from "./types";
-import { findOppositeDelimiter } from "./findOppositeDelimiter";
+import { weaklyContains } from "./weaklyContains";
 
 /**
  * Looks for a surrounding pair where one of its delimiters contains the entire selection.
@@ -28,7 +30,7 @@ export function findDelimiterPairAdjacentToSelection(
   initialIndex: number,
   delimiterOccurrences: PossibleDelimiterOccurrence[],
   selectionOffsets: Offsets,
-  forceDirection: "left" | "right" | undefined,
+  scopeType: SurroundingPairScopeType,
   bailOnUnmatchedAdjacent: boolean = false
 ): SurroundingPairOffsets | null {
   const indicesToTry = [initialIndex + 1, initialIndex];
@@ -38,8 +40,7 @@ export function findDelimiterPairAdjacentToSelection(
 
     if (
       delimiterOccurrence != null &&
-      delimiterOccurrence.offsets.start <= selectionOffsets.start &&
-      delimiterOccurrence.offsets.end >= selectionOffsets.end
+      weaklyContains(delimiterOccurrence.offsets, selectionOffsets)
     ) {
       const { delimiterInfo } = delimiterOccurrence;
 
@@ -48,14 +49,23 @@ export function findDelimiterPairAdjacentToSelection(
           delimiterOccurrences,
           index,
           delimiterInfo,
-          forceDirection
+          scopeType.forceDirection
         );
 
         if (possibleMatch != null) {
-          return getSurroundingPairOffsets(
+          const surroundingPairOffsets = getSurroundingPairOffsets(
             delimiterOccurrence as DelimiterOccurrence,
             possibleMatch
           );
+
+          if (
+            !scopeType.requireStrongContainment ||
+            (surroundingPairOffsets.leftDelimiter.start <
+              selectionOffsets.start &&
+              surroundingPairOffsets.rightDelimiter.end > selectionOffsets.end)
+          ) {
+            return surroundingPairOffsets;
+          }
         } else if (bailOnUnmatchedAdjacent) {
           return null;
         }

src/processTargets/modifiers/surroundingPair/findSurroundingPairCore.ts

@@ -1,5 +1,8 @@
 import { sortedIndexBy } from "lodash";
-import { SimpleSurroundingPairName } from "../../../typings/targetDescriptor.types";
+import {
+  SimpleSurroundingPairName,
+  SurroundingPairScopeType,
+} from "../../../typings/targetDescriptor.types";
 import { findDelimiterPairAdjacentToSelection } from "./findDelimiterPairAdjacentToSelection";
 import { findDelimiterPairContainingSelection } from "./findDelimiterPairContainingSelection";
 import {
@@ -30,7 +33,7 @@ import {
  * @returns
  */
 export function findSurroundingPairCore(
-  forceDirection: "left" | "right" | undefined,
+  scopeType: SurroundingPairScopeType,
   delimiterOccurrences: PossibleDelimiterOccurrence[],
   acceptableDelimiters: SimpleSurroundingPairName[],
   selectionOffsets: Offsets,
@@ -57,7 +60,7 @@ export function findSurroundingPairCore(
       initialIndex,
       delimiterOccurrences,
       selectionOffsets,
-      forceDirection,
+      scopeType,
       bailOnUnmatchedAdjacent
     );
 

src/processTargets/modifiers/surroundingPair/findSurroundingPairParseTreeBased.ts

@@ -2,7 +2,7 @@ import { Range, TextDocument, TextEditor } from "vscode";
 import { SyntaxNode } from "web-tree-sitter";
 import {
   SimpleSurroundingPairName,
-  SurroundingPairDirection,
+  SurroundingPairScopeType,
 } from "../../../typings/targetDescriptor.types";
 import { getNodeRange } from "../../../util/nodeSelectors";
 import { isContainedInErrorNode } from "../../../util/treeSitterUtils";
@@ -62,7 +62,7 @@ export function findSurroundingPairParseTreeBased(
   selection: Range,
   node: SyntaxNode,
   delimiters: SimpleSurroundingPairName[],
-  forceDirection: "left" | "right" | undefined
+  scopeType: SurroundingPairScopeType
 ) {
   const document: TextDocument = editor.document;
 
@@ -88,7 +88,7 @@ export function findSurroundingPairParseTreeBased(
     individualDelimiters,
     delimiters,
     selectionOffsets,
-    forceDirection,
+    scopeType,
   };
 
   // Walk up the parse tree from parent to parent until we find a node whose
@@ -149,7 +149,7 @@ interface Context {
    */
   selectionOffsets: Offsets;
 
-  forceDirection: SurroundingPairDirection | undefined;
+  scopeType: SurroundingPairScopeType;
 }
 
 /**
@@ -170,7 +170,7 @@ function findSurroundingPairContainedInNode(
     individualDelimiters,
     delimiters,
     selectionOffsets,
-    forceDirection,
+    scopeType,
   } = context;
 
   /**
@@ -213,7 +213,7 @@ function findSurroundingPairContainedInNode(
           // approach might not always work, but seems to work in the
           // languages we've tried.
           let side =
-            delimiterInfo.side === "unknown" && forceDirection == null
+            delimiterInfo.side === "unknown" && scopeType.forceDirection == null
               ? inferDelimiterSide(delimiterNode)
               : delimiterInfo.side;
 
@@ -227,7 +227,7 @@ function findSurroundingPairContainedInNode(
 
   // Just run core algorithm once we have our list of delimiters.
   return findSurroundingPairCore(
-    forceDirection,
+    scopeType,
     delimiterOccurrences,
     delimiters,
     selectionOffsets,

src/processTargets/modifiers/surroundingPair/findSurroundingPairTextBased.ts

@@ -2,8 +2,8 @@ import { escapeRegExp, findLast, uniq } from "lodash";
 import { Range, TextDocument, TextEditor } from "vscode";
 import {
   SimpleSurroundingPairName,
-  SurroundingPairDirection,
   SurroundingPairName,
+  SurroundingPairScopeType,
 } from "../../../typings/targetDescriptor.types";
 import { getDocumentRange } from "../../../util/range";
 import { matchAll } from "../../../util/regex";
@@ -70,7 +70,7 @@ export function findSurroundingPairTextBased(
   range: Range,
   allowableRange: Range | null,
   delimiters: SimpleSurroundingPairName[],
-  forceDirection: "left" | "right" | undefined
+  scopeType: SurroundingPairScopeType
 ) {
   const document: TextDocument = editor.document;
   const fullRange = allowableRange ?? getDocumentRange(document);
@@ -106,7 +106,7 @@ export function findSurroundingPairTextBased(
    * Context to pass to nested call
    */
   const context: Context = {
-    forceDirection,
+    scopeType,
     delimiterRegex,
     delimiters,
     delimiterTextToDelimiterInfoMap,
@@ -196,7 +196,7 @@ function getDelimiterRegex(individualDelimiters: IndividualDelimiter[]) {
  * Context to pass to nested call
  */
 interface Context {
-  forceDirection: SurroundingPairDirection | undefined;
+  scopeType: SurroundingPairScopeType;
   delimiterTextToDelimiterInfoMap: {
     [k: string]: IndividualDelimiter;
   };
@@ -229,11 +229,12 @@ function getDelimiterPairOffsets(
   isAtEndOfFullRange: boolean
 ): SurroundingPairOffsets | null {
   const {
-    forceDirection,
+    scopeType,
     delimiterTextToDelimiterInfoMap,
     delimiterRegex,
     delimiters,
   } = context;
+  const { forceDirection } = scopeType;
 
   // XXX: The below is a bit wasteful when there are multiple targets, because
   // this whole function gets run once per target, so we're re-running this
@@ -290,7 +291,7 @@ function getDelimiterPairOffsets(
 
   // Then just run core algorithm
   const surroundingPair = findSurroundingPairCore(
-    forceDirection,
+    scopeType,
     delimiterOccurrences,
     delimiters,
     selectionOffsets,

src/processTargets/modifiers/surroundingPair/index.ts

@@ -21,21 +21,22 @@ import { findSurroundingPairTextBased } from "./findSurroundingPairTextBased";
  * smallest pair of delimiters which contains the selection.
  *
  * @param context Context to be leveraged by modifier
- * @param selection The selection to process
- * @param modifier The surrounding pair modifier information
+ * @param editor The editor containing the range
+ * @param range The range to process
+ * @param scopeType The surrounding pair modifier information
  * @returns The new selection expanded to the containing surrounding pair or
  * `null` if none was found
  */
 export function processSurroundingPair(
   context: ProcessedTargetsContext,
   editor: TextEditor,
   range: Range,
-  modifier: SurroundingPairScopeType
+  scopeType: SurroundingPairScopeType
 ): SurroundingPairInfo | null {
   const document = editor.document;
   const delimiters = complexDelimiterMap[
-    modifier.delimiter as ComplexSurroundingPairName
-  ] ?? [modifier.delimiter];
+    scopeType.delimiter as ComplexSurroundingPairName
+  ] ?? [scopeType.delimiter];
 
   let node: SyntaxNode | null;
   let textFragmentExtractor: TextFragmentExtractor;
@@ -53,7 +54,7 @@ export function processSurroundingPair(
         range,
         null,
         delimiters,
-        modifier.forceDirection
+        scopeType
       );
     } else {
       throw err;
@@ -73,7 +74,7 @@ export function processSurroundingPair(
       range,
       textFragmentRange,
       delimiters,
-      modifier.forceDirection
+      scopeType
     );
 
     if (surroundingRange != null) {
@@ -89,6 +90,6 @@ export function processSurroundingPair(
     range,
     node,
     delimiters,
-    modifier.forceDirection
+    scopeType
   );
 }

src/processTargets/modifiers/surroundingPair/weaklyContains.ts

@@ -0,0 +1,13 @@
+import { Offsets } from "./types";
+
+/**
+ * Determines whether {@link offsets1} weakly contains {@link offsets2}, which
+ * defined as the boundaries of {@link offsets1} being inside or equal to the
+ * boundaries of {@link offsets2}.
+ * @param offsets1 The first set of offsets
+ * @param offsets2 The second set of offsets
+ * @returns `true` if {@link offsets1} weakly contains {@link offsets2}
+ */
+export function weaklyContains(offsets1: Offsets, offsets2: Offsets) {
+  return offsets1.start <= offsets2.start && offsets1.end >= offsets2.end;
+}