Scope tests

.pre-commit-config.yaml

@@ -40,7 +40,7 @@ repos:
         # tests use strings with trailing white space to represent the final
         # document contents. For example
         # packages/cursorless-vscode-e2e/src/suite/fixtures/recorded/languages/ruby/changeCondition.yml
-        exclude: ^packages/cursorless-vscode-e2e/src/suite/fixtures/recorded/.*/[^/]*\.yml$
+        exclude: ^packages/cursorless-vscode-e2e/src/suite/fixtures/.*/[^/]*\.(yml|scope)$
   - repo: local
     hooks:
       - id: eslint

packages/common/src/index.ts

@@ -93,3 +93,5 @@ export * from "./types/TestCaseFixture";
 export * from "./util/getEnvironmentVariableStrict";
 export * from "./util/CompositeKeyDefaultMap";
 export * from "./util/toPlainObject";
+export * from "./scopeSupportFacets/scopeSupportFacets";
+export * from "./scopeSupportFacets/getLanguageScopeSupport";

packages/common/src/scopeSupportFacets/getLanguageScopeSupport.ts

@@ -0,0 +1,21 @@
+import { htmlSupport } from "./html";
+import { javascriptSupport } from "./javascript";
+import { plaintextSupport } from "./plaintext";
+import {
+  LanguageScopeSupportFacetMap,
+  TextualLanguageScopeSupportFacetMap,
+} from "./scopeSupportFacets";
+
+export function getLanguageScopeSupport(
+  languageId: string,
+): TextualLanguageScopeSupportFacetMap | LanguageScopeSupportFacetMap {
+  switch (languageId) {
+    case "plaintext":
+      return plaintextSupport;
+    case "javascript":
+      return javascriptSupport;
+    case "html":
+      return htmlSupport;
+  }
+  throw Error(`Unsupported language: '${languageId}'`);
+}

packages/common/src/scopeSupportFacets/html.ts

@@ -0,0 +1,19 @@
+import {
+  LanguageScopeSupportFacetMap,
+  ScopeSupportFacetLevel,
+} from "@cursorless/common";
+
+const { supported, notApplicable } = ScopeSupportFacetLevel;
+
+export const htmlSupport: LanguageScopeSupportFacetMap = {
+  ["key.attribute"]: supported,
+  ["tags.element"]: supported,
+
+  namedFunction: notApplicable,
+  ["name.assignment"]: notApplicable,
+  ["key.mapPair"]: notApplicable,
+  ["key.mapPair.iteration"]: notApplicable,
+  ["value.mapPair"]: notApplicable,
+  ["value.mapPair.iteration"]: notApplicable,
+  ["value.assignment"]: notApplicable,
+};

packages/common/src/scopeSupportFacets/javascript.ts

@@ -0,0 +1,19 @@
+import {
+  LanguageScopeSupportFacetMap,
+  ScopeSupportFacetLevel,
+} from "@cursorless/common";
+
+const { supported, notApplicable } = ScopeSupportFacetLevel;
+
+export const javascriptSupport: LanguageScopeSupportFacetMap = {
+  namedFunction: supported,
+  ["name.assignment"]: supported,
+  ["key.mapPair"]: supported,
+  ["key.mapPair.iteration"]: supported,
+  ["value.mapPair"]: supported,
+  ["value.mapPair.iteration"]: supported,
+  ["value.assignment"]: supported,
+
+  ["key.attribute"]: notApplicable,
+  ["tags.element"]: notApplicable,
+};

packages/common/src/scopeSupportFacets/plaintext.ts

@@ -0,0 +1,15 @@
+import {
+  ScopeSupportFacetLevel,
+  TextualLanguageScopeSupportFacetMap,
+} from "@cursorless/common";
+
+const { supported } = ScopeSupportFacetLevel;
+
+export const plaintextSupport: TextualLanguageScopeSupportFacetMap = {
+  character: supported,
+  word: supported,
+  token: supported,
+  line: supported,
+  paragraph: supported,
+  document: supported,
+};

packages/common/src/scopeSupportFacets/scopeSupportFacets.ts

@@ -0,0 +1,211 @@
+import { SimpleScopeTypeType } from "..";
+
+const scopeSupportFacets = [
+  //   "list",
+  //   "list.interior",
+  //   "map",
+  //   "map.interior",
+  //   "collectionKey",
+  "namedFunction",
+  //   "namedFunction.interior",
+  //   "functionName",
+  //   "anonymousFunction",
+  //   "anonymousFunction.interior",
+  "name.assignment",
+  "key.attribute",
+  "key.mapPair",
+  "key.mapPair.iteration",
+  "value.assignment",
+  "value.mapPair",
+  "value.mapPair.iteration",
+  //   "value.assignment.removal",
+  //   "value.return",
+  //   "value.return.removal",
+  //   "value.collectionItem",
+  //   "value.collectionItem.removal",
+  //   "statement",
+  //   "ifStatement",
+  //   "condition.if",
+  //   "condition.while",
+  //   "condition.doWhile",
+  //   "condition.for",
+  //   "condition.ternary",
+  //   "branch",
+  //   "comment.line",
+  //   "comment.block",
+  //   "string.singleLine",
+  //   "string.multiLine",
+  //   "textFragment",
+  //   "functionCall",
+  //   "functionCallee",
+  //   "argumentOrParameter.argument",
+  //   "argumentOrParameter.argument.removal",
+  //   "argumentOrParameter.parameter",
+  //   "argumentOrParameter.parameter.removal",
+  //   "class",
+  //   "class.interior",
+  //   "className",
+  //   "type",
+  "tags.element",
+] as const;
+
+const textualScopeSupportFacets = [
+  "character",
+  "word",
+  "token",
+  "line",
+  "paragraph",
+  "document",
+] as const;
+
+export type ScopeSupportFacet = (typeof scopeSupportFacets)[number];
+export type TextualScopeSupportFacet =
+  (typeof textualScopeSupportFacets)[number];
+
+export interface ScopeSupportFacetInfo {
+  label: string;
+  description: string;
+  scopeType: SimpleScopeTypeType;
+  isIteration?: boolean;
+  examples: string[];
+}
+
+export const scopeSupportFacetInfos: Record<
+  ScopeSupportFacet,
+  ScopeSupportFacetInfo
+> = {
+  namedFunction: {
+    label: "Named function",
+    description: "A named function",
+    scopeType: "namedFunction",
+    examples: ["function foo() {}", "const foo = () => {}"],
+  },
+  ["name.assignment"]: {
+    label: "Assignment name",
+    description: "Name(LHS) of an assignment",
+    scopeType: "name",
+    examples: ["const foo = 1"],
+  },
+  ["key.attribute"]: {
+    label: "Attributes key",
+    description: "Key(LHS) of an attribute",
+    scopeType: "collectionKey",
+    examples: ['id="root"'],
+  },
+  ["key.mapPair"]: {
+    label: "Map key",
+    description: "Key(LHS) of a map pair",
+    scopeType: "collectionKey",
+    examples: ["value: 0"],
+  },
+  ["key.mapPair.iteration"]: {
+    label: "Map pair key iteration",
+    description: "Iteration of map pair keys",
+    scopeType: "collectionKey",
+    isIteration: true,
+    examples: ["{ value: 0 }"],
+  },
+  ["value.assignment"]: {
+    label: "Assignment value",
+    description: "Value(RHS) of an assignment",
+    scopeType: "value",
+    examples: ["const foo = 1"],
+  },
+  ["value.mapPair"]: {
+    label: "Map pair value",
+    description: "Key(RHS) of a map pair",
+    scopeType: "value",
+    examples: ["value: 0"],
+  },
+  ["value.mapPair.iteration"]: {
+    label: "Map pair value iteration",
+    description: "Iteration of map pair values",
+    scopeType: "value",
+    isIteration: true,
+    examples: ["{ value: 0 }"],
+  },
+  ["tags.element"]: {
+    label: "Tags",
+    description: "Both tags in an xml element",
+    scopeType: "xmlBothTags",
+    examples: ["<div></div>"],
+  },
+  // list: {
+  //   label: "List",
+  //   description: "A list of items",
+  //   scopeType: "list",
+  // },
+  // "list.interior": {
+  //   label: "List interior",
+  //   description: "Excludes the opening and closing delimiters of the list",
+  //   scopeType: "list",
+  // },
+  // map: {
+  //   label: "Map",
+  //   description: "A map of key-value pairs",
+  //   scopeType: "map",
+  // },
+  // "map.interior": {
+  //   label: "Map interior",
+  //   description: "Excludes the opening and closing delimiters of the map",
+  //   scopeType: "map",
+  // },
+};
+
+export const textualScopeSupportFacetInfos: Record<
+  TextualScopeSupportFacet,
+  ScopeSupportFacetInfo
+> = {
+  character: {
+    label: "Character",
+    description: "A single character in the document",
+    scopeType: "character",
+    examples: ["a", "."],
+  },
+  word: {
+    label: "Word",
+    description: "A single word in a token",
+    scopeType: "word",
+    examples: ["foo_bar", "fooBar"],
+  },
+  token: {
+    label: "Token",
+    description: "A single token in the document",
+    scopeType: "token",
+    examples: ["foo", "("],
+  },
+  line: {
+    label: "Line",
+    description: "A single line in the document",
+    scopeType: "line",
+    examples: ["foo"],
+  },
+  paragraph: {
+    label: "Paragraph",
+    description:
+      "A single paragraph(contiguous block of lines) in the document",
+    scopeType: "paragraph",
+    examples: ["foo\nbar"],
+  },
+  document: {
+    label: "Documents",
+    description: "The entire document",
+    scopeType: "document",
+    examples: ["foo\n\nbar"],
+  },
+};
+
+export enum ScopeSupportFacetLevel {
+  supported,
+  unsupported,
+  notApplicable,
+}
+
+export type LanguageScopeSupportFacetMap = Partial<
+  Record<ScopeSupportFacet, ScopeSupportFacetLevel>
+>;
+
+export type TextualLanguageScopeSupportFacetMap = Record<
+  TextualScopeSupportFacet,
+  ScopeSupportFacetLevel
+>;

packages/common/src/testUtil/getFixturePaths.ts

@@ -21,6 +21,10 @@ export function getRecordedTestsDirPath() {
   return path.join(getFixturesPath(), "recorded");
 }
 
+export function getScopeTestsDirPath() {
+  return path.join(getFixturesPath(), "scopes");
+}
+
 export function getRecordedTestPaths() {
   const directory = getRecordedTestsDirPath();
   const relativeDir = path.dirname(directory);
@@ -32,3 +36,17 @@ export function getRecordedTestPaths() {
       path: p,
     }));
 }
+
+export function getScopeTestPaths() {
+  const directory = getScopeTestsDirPath();
+  const relativeDir = path.dirname(directory);
+
+  return walkFilesSync(directory)
+    .filter((p) => p.endsWith(".scope"))
+    .map((p) => ({
+      path: p,
+      name: path.relative(relativeDir, p.substring(0, p.lastIndexOf("."))),
+      languageId: path.dirname(path.relative(directory, p)).split(path.sep)[0],
+      facet: path.basename(p).match(/([a-zA-Z.]+)\d*\.scope/)![1],
+    }));
+}

packages/common/src/types/ScopeProvider.ts

@@ -178,7 +178,13 @@ export interface ScopeRanges {
  */
 export interface TargetRanges {
   contentRange: Range;
+  removalRange: Range;
   removalHighlightRange: GeneralizedRange;
+  leadingDelimiter: TargetRanges | undefined;
+  trailingDelimiter: TargetRanges | undefined;
+  interior: TargetRanges[] | undefined;
+  boundary: TargetRanges[] | undefined;
+  insertionDelimiter: string;
 }
 
 /**

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

@@ -6,10 +6,36 @@ import {
 import { Target } from "../typings/target.types";
 
 export function getTargetRanges(target: Target): TargetRanges {
+  const interior = (() => {
+    try {
+      target.getInteriorStrict().map(getTargetRanges);
+    } catch (error) {
+      return undefined;
+    }
+  })();
+
+  const boundary = (() => {
+    try {
+      target.getBoundaryStrict().map(getTargetRanges);
+    } catch (error) {
+      return undefined;
+    }
+  })();
+
   return {
     contentRange: target.contentRange,
+    removalRange: target.getRemovalRange(),
     removalHighlightRange: target.isLine
       ? toLineRange(target.getRemovalHighlightRange())
       : toCharacterRange(target.getRemovalHighlightRange()),
+    leadingDelimiter: getOptionalTarget(target.getLeadingDelimiterTarget()),
+    trailingDelimiter: getOptionalTarget(target.getTrailingDelimiterTarget()),
+    interior,
+    boundary,
+    insertionDelimiter: target.insertionDelimiter,
   };
 }
+
+function getOptionalTarget(target: Target | undefined) {
+  return target != null ? getTargetRanges(target) : undefined;
+}