Added support for previous and next containing scope type

cursorless-talon/src/cheatsheet/sections/scopes.py

@@ -4,7 +4,7 @@
 def get_scopes():
     return {
         **get_lists(
-            ["scope_type", "subtoken_scope_type"],
+            ["scope_type"],
             {"argumentOrParameter": "Argument"},
         ),
         "<P>": "Paired delimiter",

cursorless-talon/src/cheatsheet_html/sections/scopes.py

@@ -3,7 +3,7 @@
 
 def get_scopes():
     return get_lists(
-        ["scope_type", "subtoken_scope_type"],
+        ["scope_type"],
         "scopeType",
         {"argumentOrParameter": "Argument"},
     )

cursorless-talon/src/command.py

@@ -135,7 +135,7 @@ def construct_cursorless_command_argument(
         use_pre_phrase_snapshot = False
 
     return {
-        "version": 2,
+        "version": 3,
         "spokenForm": get_spoken_form(),
         "action": {
             "name": action,

cursorless-talon/src/marks/lines_number.py

@@ -37,13 +37,8 @@ class CustomizableTerm:
 @mod.capture(rule="{user.cursorless_line_direction} <number_small>")
 def cursorless_line_number(m) -> dict[str, Any]:
     direction = directions_map[m.cursorless_line_direction]
-    line_number = m.number_small
-    line = {
-        "lineNumber": direction.formatter(line_number),
-        "type": direction.type,
-    }
     return {
         "type": "lineNumber",
-        "anchor": line,
-        "active": line,
+        "lineNumberType": direction.type,
+        "lineNumber": direction.formatter(m.number_small),
     }

cursorless-talon/src/modifiers/containing_scope.py

@@ -52,6 +52,8 @@
     "start tag": "xmlStartTag",
     "end tag": "xmlEndTag",
     # Text-based scope types
+    "char": "character",
+    "word": "word",
     "block": "paragraph",
     "cell": "notebookCell",
     "file": "document",
@@ -71,40 +73,26 @@
 }
 
 
-@mod.capture(rule="{user.cursorless_scope_type}")
+@mod.capture(
+    rule="{user.cursorless_scope_type} | {user.cursorless_custom_regex_scope_type}"
+)
 def cursorless_scope_type(m) -> dict[str, str]:
     """Simple cursorless scope type that only need to specify their type"""
-    return {"type": m.cursorless_scope_type}
-
-
-@mod.capture(rule="{user.cursorless_custom_regex_scope_type}")
-def cursorless_custom_regex_scope_type(m) -> dict[str, str]:
-    """Cursorless custom regular expression scope type"""
-    return {"type": "customRegex", "regex": m.cursorless_custom_regex_scope_type}
+    try:
+        return {"type": m.cursorless_scope_type}
+    except AttributeError:
+        return {"type": "customRegex", "regex": m.cursorless_custom_regex_scope_type}
 
 
-@mod.capture(
-    rule="[every] (<user.cursorless_scope_type> | <user.cursorless_custom_regex_scope_type>)"
-)
+@mod.capture(rule="[every] <user.cursorless_scope_type>")
 def cursorless_containing_scope(m) -> dict[str, Any]:
     """Expand to containing scope"""
-    try:
-        scope_type = m.cursorless_scope_type
-    except AttributeError:
-        scope_type = m.cursorless_custom_regex_scope_type
     return {
         "type": "everyScope" if m[0] == "every" else "containingScope",
-        "scopeType": scope_type,
+        "scopeType": m.cursorless_scope_type,
     }
 
 
-# NOTE: Please do not change these dicts.  Use the CSVs for customization.
-# See https://www.cursorless.org/docs/user/customization/
-subtoken_scope_types = {
-    "word": "word",
-    "char": "character",
-}
-
 # NOTE: Please do not change these dicts.  Use the CSVs for customization.
 # See https://www.cursorless.org/docs/user/customization/
 # NB: This is a hack until we support having inside and outside on arbitrary
@@ -119,7 +107,6 @@ def on_ready():
         "modifier_scope_types",
         {
             "scope_type": scope_types,
-            "subtoken_scope_type": subtoken_scope_types,
             "surrounding_pair_scope_type": surrounding_pair_scope_types,
         },
     )

cursorless-talon/src/modifiers/modifiers.py

@@ -39,7 +39,8 @@ def cursorless_simple_modifier(m) -> dict[str, str]:
 head_tail_swallowed_modifiers = [
     "<user.cursorless_simple_modifier>",  # bounds, just, leading, trailing
     "<user.cursorless_containing_scope>",  # funk, state, class
-    "<user.cursorless_subtoken_scope>",  # first past second word
+    "<user.cursorless_ordinal_scope>",  # first past second word
+    "<user.cursorless_relative_scope>",  # next funk
     "<user.cursorless_surrounding_pair>",  # matching/pair [curly, round]
 ]
 

cursorless-talon/src/modifiers/ordinal_scope.py

@@ -0,0 +1,68 @@
+from typing import Any
+
+from talon import Module
+
+from ..compound_targets import is_active_included, is_anchor_included
+
+mod = Module()
+
+
+@mod.capture(rule="<user.ordinals_small> | last")
+def ordinal_or_last(m) -> int:
+    """An ordinal or the word 'last'"""
+    if m[0] == "last":
+        return -1
+    return m.ordinals_small - 1
+
+
+@mod.capture(
+    rule="<user.ordinal_or_last> [{user.cursorless_range_connective} <user.ordinal_or_last>] <user.cursorless_scope_type>"
+)
+def cursorless_ordinal_range(m) -> dict[str, Any]:
+    """Ordinal range"""
+    if len(m.ordinal_or_last_list) > 1:
+        range_connective = m.cursorless_range_connective
+        include_anchor = is_anchor_included(range_connective)
+        include_active = is_active_included(range_connective)
+        anchor = create_ordinal_scope_modifier(
+            m.cursorless_scope_type, m.ordinal_or_last_list[0]
+        )
+        active = create_ordinal_scope_modifier(
+            m.cursorless_scope_type, m.ordinal_or_last_list[1]
+        )
+        return {
+            "type": "range",
+            "anchor": anchor,
+            "active": active,
+            "excludeAnchor": not include_anchor,
+            "excludeActive": not include_active,
+        }
+    else:
+        return create_ordinal_scope_modifier(
+            m.cursorless_scope_type, m.ordinal_or_last_list[0]
+        )
+
+
+@mod.capture(rule="(first | last) <number_small> <user.cursorless_scope_type>")
+def cursorless_first_last(m) -> dict[str, Any]:
+    """First/last `n` scopes; eg "first three funk"""
+    if m[0] == "first":
+        return create_ordinal_scope_modifier(m.cursorless_scope_type, 0, m.number_small)
+    return create_ordinal_scope_modifier(
+        m.cursorless_scope_type, -m.number_small, m.number_small
+    )
+
+
+@mod.capture(rule="<user.cursorless_ordinal_range> | <user.cursorless_first_last>")
+def cursorless_ordinal_scope(m) -> dict[str, Any]:
+    """Ordinal ranges such as subwords or characters"""
+    return m[0]
+
+
+def create_ordinal_scope_modifier(scope_type: Any, start: int, length: int = 1):
+    return {
+        "type": "ordinalScope",
+        "scopeType": scope_type,
+        "start": start,
+        "length": length,
+    }

cursorless-talon/src/modifiers/relative_scope.py

@@ -0,0 +1,17 @@
+from typing import Any
+
+from talon import Module
+
+mod = Module()
+
+
+@mod.capture(rule="(previous | next) <user.cursorless_scope_type>")
+def cursorless_relative_scope(m) -> dict[str, Any]:
+    """Previous/next scope"""
+    return {
+        "type": "relativeScope",
+        "scopeType": m.cursorless_scope_type,
+        "offset": 1,
+        "length": 1,
+        "direction": "backward" if m[0] == "previous" else "forward",
+    }

src/core/TokenGraphemeSplitter.ts

@@ -68,7 +68,7 @@ export const UNKNOWN = "[unk]";
 /**
  * Regex used to split a token into graphemes.
  */
-export const GRAPHEME_SPLIT_REGEX = /\p{L}\p{M}*|\P{L}/gu;
+export const GRAPHEME_SPLIT_REGEX = /\p{L}\p{M}*|[\p{N}\p{P}\p{S}]/gu;
 
 export class TokenGraphemeSplitter {
   private disposables: Disposable[] = [];

src/core/commandRunner/command.types.ts

@@ -4,17 +4,18 @@ import {
   CommandV0,
   CommandV1,
 } from "../commandVersionUpgrades/upgradeV1ToV2/commandV1.types";
+import { CommandV2 } from "../commandVersionUpgrades/upgradeV2ToV3/commandV2.types";
 
 export type CommandComplete = Required<Omit<CommandLatest, "spokenForm">> &
   Pick<CommandLatest, "spokenForm"> & { action: Required<ActionCommand> };
 
-export const LATEST_VERSION = 2 as const;
+export const LATEST_VERSION = 3 as const;
 
 export type CommandLatest = Command & {
   version: typeof LATEST_VERSION;
 };
 
-export type Command = CommandV0 | CommandV1 | CommandV2;
+export type Command = CommandV0 | CommandV1 | CommandV2 | CommandV3;
 
 interface ActionCommand {
   /**
@@ -28,11 +29,11 @@ interface ActionCommand {
   args?: unknown[];
 }
 
-export interface CommandV2 {
+export interface CommandV3 {
   /**
    * The version number of the command API
    */
-  version: 2;
+  version: 3;
 
   /**
    * The spoken form of the command if issued from a voice command system

src/core/commandVersionUpgrades/canonicalizeAndValidateCommand.ts

@@ -16,6 +16,7 @@ import canonicalizeActionName from "./canonicalizeActionName";
 import canonicalizeTargets from "./canonicalizeTargets";
 import { upgradeV0ToV1 } from "./upgradeV0ToV1";
 import { upgradeV1ToV2 } from "./upgradeV1ToV2";
+import { upgradeV2ToV3 } from "./upgradeV2ToV3";
 
 /**
  * Given a command argument which comes from the client, normalize it so that it
@@ -66,6 +67,9 @@ function upgradeCommand(command: Command): CommandLatest {
       case 1:
         command = upgradeV1ToV2(command);
         break;
+      case 2:
+        command = upgradeV2ToV3(command);
+        break;
       default:
         throw new Error(
           `Can't upgrade from unknown version ${command.version}`

src/core/commandVersionUpgrades/upgradeV1ToV2/upgradeStrictHere.ts

@@ -1,5 +1,5 @@
 import { isDeepStrictEqual } from "util";
-import { PartialPrimitiveTargetDescriptor } from "../../../typings/targetDescriptor.types";
+import { PartialPrimitiveTargetDescriptorV2 } from "../upgradeV2ToV3/targetDescriptorV2.types";
 
 const STRICT_HERE = {
   type: "primitive",
@@ -9,11 +9,11 @@ const STRICT_HERE = {
   modifier: { type: "identity" },
   insideOutsideType: "inside",
 };
-const IMPLICIT_TARGET: PartialPrimitiveTargetDescriptor = {
+const IMPLICIT_TARGET: PartialPrimitiveTargetDescriptorV2 = {
   type: "primitive",
   isImplicit: true,
 };
 export const upgradeStrictHere = (
-  target: PartialPrimitiveTargetDescriptor
-): PartialPrimitiveTargetDescriptor =>
+  target: PartialPrimitiveTargetDescriptorV2
+): PartialPrimitiveTargetDescriptorV2 =>
   isDeepStrictEqual(target, STRICT_HERE) ? IMPLICIT_TARGET : target;