Added support for previous and next containing scope type (#960)

* Added support for previous and next containing scope type

* Added tests

* Reverse changes

* Reuse ordinal range for previous/next modifier

* Use correct relative index

* Added word and character as proper scope types

* Select correct target

* Always use token range

* Cleanup

* Clean up

* New implementation of ordinal stage

* Updated tests

* Started working on migration

* Made all tests pass

* Added comment

* Clean up

* Added range modifier

* Added tests for scope type word and character

* Clean up

* Created ordinal capture

* Added ordinal items tests

* cleanup

* Added previous/next capture

* Clean up

* Update cursorless-talon/src/modifiers/ordinals.py

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

* Use if statement instead of attribute error

* Added index file

* Update src/processTargets/processTargets.ts

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

* Update src/typings/targetDescriptor.types.ts

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

* Update src/typings/targetDescriptor.types.ts

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

* Update src/typings/targetDescriptor.types.ts

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

* cleanup

* Added tests

* Clean up types

* Clean up

* Added tests

* Clean up

* Clean up import

* Clean up

* Move ordinal stages into own directory

* Prefer to take scopes to the right

* Added additional word tests

* Made migration for line number mark

* Fixed correct type

* Update grapheme regex

* Added additional tests

* rename

* Use name mark

* Updated modifier names

* Split ordinal and relative scope python files

* `lineType` => `lineNumberType`

* Tweak token grapheme splitter

* Rename variable

* Clarify duplicate range stage names

* Tweaks to relative scope stage

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

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

* Added support for non containing relative scope

* More clean up to relative scope

* Rename

* Reduce nesting

* Tweaks to sub token stage

* Doc strings

* More tweaks to RelativeScopeStage

* Add comment

* Add comments

* Improve error message

* Add a bunch of tests

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

Author: 3 people

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",

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"},
     )

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,

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),
     }

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,
         },
     )

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]
 ]
 

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,
+    }

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",
+    }