Add surrounding pair modifier (#3) (#168)

* Add surrounding pair modifier (#3)

* delimeter => delimiter

* Clean up

* Tweak

* More tweak

Co-authored-by: Pokey Rule <[email protected]>

Author: maciejklimek

.gitignore

@@ -3,3 +3,4 @@ dist
 node_modules
 .vscode-test/
 *.vsix
+package-lock.json

package.json

@@ -221,4 +221,4 @@
 		"immutability-helper": "^3.1.1",
 		"lodash": "^4.17.21"
 	}
-}
+}

src/Types.ts

@@ -68,6 +68,7 @@ export type Delimiter =
   | "parentheses"
   | "singleQuotes"
   | "doubleQuotes";
+
 export type ScopeType =
   | "argumentOrParameter"
   | "arrowFunction"
@@ -97,7 +98,8 @@ export type PieceType = "word" | "character";
 
 export interface SurroundingPairModifier {
   type: "surroundingPair";
-  delimiter: Delimiter;
+  delimiter: Delimiter | null;
+  delimitersOnly: boolean;
 }
 export interface ContainingScopeModifier {
   type: "containingScope";

src/languages/index.ts

@@ -1,17 +1,17 @@
+import { SyntaxNode } from "web-tree-sitter";
+import { notSupported } from "../nodeMatchers";
+import { selectionWithEditorFromRange } from "../selectionUtils";
 import {
   NodeMatcher,
   NodeMatcherValue,
   ScopeType,
   SelectionWithEditor,
 } from "../Types";
+import csharp from "./csharp";
+import java from "./java";
 import json from "./json";
 import python from "./python";
 import typescript from "./typescript";
-import csharp from "./csharp";
-import java from "./java";
-import { notSupported } from "../nodeMatchers";
-import { SyntaxNode } from "web-tree-sitter";
-import { selectionWithEditorFromRange } from "../selectionUtils";
 
 const languageMatchers: Record<string, Record<ScopeType, NodeMatcher>> = {
   csharp: csharp,

src/languages/surroundingPair.ts

@@ -0,0 +1,122 @@
+import { maxBy, zip } from "lodash";
+import { Position, Selection } from "vscode";
+import { Point, SyntaxNode } from "web-tree-sitter";
+import {
+  Delimiter,
+  NodeMatcher,
+  NodeMatcherValue,
+  SelectionWithEditor,
+} from "../Types";
+
+function positionFromPoint(point: Point): Position {
+  return new Position(point.row, point.column);
+}
+
+const delimiterToText: Record<Delimiter, string[]> = {
+  squareBrackets: ["[", "]"],
+  curlyBrackets: ["{", "}"],
+  angleBrackets: ["<", ">"],
+  parentheses: ["(", ")"],
+  singleQuotes: ["'", "'"],
+  doubleQuotes: ['"', '"'],
+};
+
+const leftToRightMap: Record<string, string> = Object.fromEntries(
+  Object.values(delimiterToText)
+);
+
+export function createSurroundingPairMatcher(
+  delimiter: Delimiter | null,
+  delimitersOnly: boolean
+): NodeMatcher {
+  return function nodeMatcher(
+    selection: SelectionWithEditor,
+    node: SyntaxNode
+  ) {
+    const delimitersToCheck =
+      delimiter == null ? Object.keys(delimiterToText) : [delimiter];
+
+    const leftDelimiterTypes = delimitersToCheck.map(
+      (delimiter) => delimiterToText[delimiter][0]
+    );
+
+    const leftDelimiterNodes = node.children.filter(
+      (child) =>
+        leftDelimiterTypes.includes(child.type) &&
+        positionFromPoint(child.startPosition).isBeforeOrEqual(
+          selection.selection.start
+        )
+    );
+
+    if (leftDelimiterNodes.length === 0) {
+      return null;
+    }
+
+    const leftDelimiterNode = leftDelimiterNodes[leftDelimiterNodes.length - 1];
+    const rightDelimiterType = leftToRightMap[leftDelimiterNode.type];
+
+    const rightDelimiterNode = node.children.find(
+      (child) =>
+        child.type === rightDelimiterType && child !== leftDelimiterNode
+    );
+
+    if (rightDelimiterNode == null) {
+      return null;
+    }
+
+    return extractSelection(
+      leftDelimiterNode,
+      rightDelimiterNode,
+      delimitersOnly
+    );
+  };
+}
+
+function extractSelection(
+  leftDelimiterNode: SyntaxNode,
+  rightDelimiterNode: SyntaxNode,
+  delimitersOnly: boolean
+): NodeMatcherValue[] {
+  if (delimitersOnly === false) {
+    return [
+      {
+        node: leftDelimiterNode,
+        selection: {
+          selection: new Selection(
+            positionFromPoint(leftDelimiterNode.endPosition),
+            positionFromPoint(rightDelimiterNode.startPosition)
+          ),
+          context: {
+            outerSelection: new Selection(
+              positionFromPoint(leftDelimiterNode.startPosition),
+              positionFromPoint(rightDelimiterNode.endPosition)
+            ),
+          },
+        },
+      },
+    ];
+  } else {
+    return [
+      {
+        node: leftDelimiterNode,
+        selection: {
+          selection: new Selection(
+            positionFromPoint(leftDelimiterNode.startPosition),
+            positionFromPoint(leftDelimiterNode.endPosition)
+          ),
+          context: {},
+        },
+      },
+      {
+        node: rightDelimiterNode,
+        selection: {
+          selection: new Selection(
+            positionFromPoint(rightDelimiterNode.startPosition),
+            positionFromPoint(rightDelimiterNode.endPosition)
+          ),
+          context: {},
+        },
+      },
+    ];
+  }
+}

src/processTargets.ts

@@ -1,27 +1,30 @@
-import { concat, range, zip } from "lodash";
 import update from "immutability-helper";
+import { concat, range, zip } from "lodash";
+import * as vscode from "vscode";
+import { Location, Position, Range, Selection, TextDocument } from "vscode";
 import { SyntaxNode } from "web-tree-sitter";
+import { SUBWORD_MATCHER } from "./constants";
 import { getNodeMatcher } from "./languages";
-import { Selection, Range, Position, Location, TextDocument } from "vscode";
+import { createSurroundingPairMatcher } from "./languages/surroundingPair";
+import { performInsideOutsideAdjustment } from "./performInsideOutsideAdjustment";
+import {
+  selectionFromPositions,
+  selectionWithEditorFromPositions,
+  selectionWithEditorFromRange,
+} from "./selectionUtils";
 import {
+  LineNumberPosition,
   Mark,
+  Modifier,
+  NodeMatcher,
   PrimitiveTarget,
   ProcessedTargetsContext,
   RangeTarget,
   SelectionContext,
   SelectionWithEditor,
   Target,
   TypedSelection,
-  Modifier,
-  LineNumberPosition,
 } from "./Types";
-import { performInsideOutsideAdjustment } from "./performInsideOutsideAdjustment";
-import { SUBWORD_MATCHER } from "./constants";
-import {
-  selectionFromPositions,
-  selectionWithEditorFromPositions,
-  selectionWithEditorFromRange,
-} from "./selectionUtils";
 
 export default function processTargets(
   context: ProcessedTargetsContext,
@@ -173,6 +176,7 @@ function processSinglePrimitiveTarget(
       transformSelection(context, target, markSelection)
     )
   );
+
   const typedSelections = transformedSelections.map(
     ({ selection, context: selectionContext }) =>
       createTypedSelection(context, target, selection, selectionContext)
@@ -251,6 +255,31 @@ function getSelectionsFromMark(
   }
 }
 
+function findNearestContainingAncestorNode(
+  startNode: SyntaxNode,
+  nodeMatcher: NodeMatcher,
+  selection: SelectionWithEditor
+) {
+  let node: SyntaxNode | null = startNode;
+  while (node != null) {
+    const matches = nodeMatcher(selection, node);
+    if (matches != null) {
+      return matches
+        .map((match) => match.selection)
+        .map((matchedSelection) => ({
+          selection: selectionWithEditorFromRange(
+            selection,
+            matchedSelection.selection
+          ),
+          context: matchedSelection.context,
+        }));
+    }
+    node = node.parent;
+  }
+
+  return null;
+}
+
 function transformSelection(
   context: ProcessedTargetsContext,
   target: PrimitiveTarget,
@@ -268,25 +297,18 @@ function transformSelection(
         modifier.scopeType,
         modifier.includeSiblings ?? false
       );
-
       let node: SyntaxNode | null = context.getNodeAtLocation(
         new Location(selection.editor.document.uri, selection.selection)
       );
 
-      while (node != null) {
-        const matches = nodeMatcher(selection, node);
-        if (matches != null) {
-          return matches
-            .map((match) => match.selection)
-            .map((matchedSelection) => ({
-              selection: selectionWithEditorFromRange(
-                selection,
-                matchedSelection.selection
-              ),
-              context: matchedSelection.context,
-            }));
-        }
-        node = node.parent;
+      let result = findNearestContainingAncestorNode(
+        node,
+        nodeMatcher,
+        selection
+      );
+
+      if (result != null) {
+        return result;
       }
 
       throw new Error(`Couldn't find containing ${modifier.scopeType}`);
@@ -392,8 +414,32 @@ function transformSelection(
     }
 
     case "matchingPairSymbol":
-    case "surroundingPair":
       throw new Error("Not implemented");
+
+    case "surroundingPair":
+      {
+        let node: SyntaxNode | null = context.getNodeAtLocation(
+          new vscode.Location(
+            selection.editor.document.uri,
+            selection.selection
+          )
+        );
+
+        const nodeMatcher = createSurroundingPairMatcher(
+          modifier.delimiter,
+          modifier.delimitersOnly
+        );
+        let result = findNearestContainingAncestorNode(
+          node,
+          nodeMatcher,
+          selection
+        );
+        if (result != null) {
+          return result;
+        }
+      }
+
+      throw new Error(`Couldn't find containing `);
   }
 }
 
@@ -603,6 +649,7 @@ function getTokenSelectionContext(
     containingListDelimiter: " ",
     leadingDelimiterRange: isInDelimitedList ? leadingDelimiterRange : null,
     trailingDelimiterRange: isInDelimitedList ? trailingDelimiterRange : null,
+    outerSelection: selectionContext.outerSelection,
   };
 }
 

src/test/suite/fixtures/recorded/surroundingPair/chuckMatching.yml

@@ -0,0 +1,35 @@
+spokenForm: chuck matching
+languageId: python
+command:
+  actionName: delete
+  partialTargets:
+    - type: primitive
+      modifier:
+        { type: surroundingPair, delimiter: null, delimitersOnly: false }
+  extraArgs: []
+marks: {}
+initialState:
+  documentContents: f"j{fdfhjkd}lkjlkj"
+  selections:
+    - anchor: { line: 0, character: 15 }
+      active: { line: 0, character: 15 }
+finalState:
+  documentContents: ""
+  selections:
+    - anchor: { line: 0, character: 0 }
+      active: { line: 0, character: 0 }
+  thatMark:
+    - anchor: { line: 0, character: 0 }
+      active: { line: 0, character: 0 }
+fullTargets:
+  [
+    {
+      type: primitive,
+      mark: { type: cursor },
+      selectionType: token,
+      position: contents,
+      modifier:
+        { type: surroundingPair, delimiter: null, delimitersOnly: false },
+      insideOutsideType: outside,
+    },
+  ]