Move most of the vi-specific logic out of Reader

Author: lkollar

Lib/_pyrepl/reader.py

@@ -58,10 +58,6 @@ def make_default_syntax_table() -> dict[str, int]:
     return st
 
 
-def _is_vi_word_char(c: str) -> bool:
-    return c.isalnum() or c == '_'
-
-
 def make_default_commands() -> dict[CommandName, type[Command]]:
     result: dict[CommandName, type[Command]] = {}
     all_commands = itertools.chain(vars(commands).values(), vars(vi_commands).values())
@@ -543,190 +539,6 @@ def eow(self, p: int | None = None) -> int:
             p += 1
         return p
 
-    def vi_eow(self, p: int | None = None) -> int:
-        """Return the 0-based index of the last character of the word
-        following p most immediately (vi 'e' semantics).
-
-        Vi has three character classes: word chars (alnum + _), punctuation
-        (non-word, non-whitespace), and whitespace. 'e' moves to the end
-        of the current or next word/punctuation sequence."""
-        if p is None:
-            p = self.pos
-        b = self.buffer
-
-        if not b:
-            return 0
-
-        # Helper to check if at end of current sequence
-        def at_sequence_end(pos: int) -> bool:
-            if pos >= len(b) - 1:
-                return True
-            curr_is_word = _is_vi_word_char(b[pos])
-            next_is_word = _is_vi_word_char(b[pos + 1])
-            curr_is_space = b[pos].isspace()
-            next_is_space = b[pos + 1].isspace()
-            if curr_is_word:
-                return not next_is_word
-            elif not curr_is_space:
-                # Punctuation - at end if next is word or whitespace
-                return next_is_word or next_is_space
-            return True
-
-        # If already at end of a word/punctuation, move forward
-        if p < len(b) and at_sequence_end(p):
-            p += 1
-
-        # Skip whitespace
-        while p < len(b) and b[p].isspace():
-            p += 1
-
-        if p >= len(b):
-            return len(b) - 1
-
-        # Move to end of current word or punctuation sequence
-        if _is_vi_word_char(b[p]):
-            while p + 1 < len(b) and _is_vi_word_char(b[p + 1]):
-                p += 1
-        else:
-            # Punctuation sequence
-            while p + 1 < len(b) and not _is_vi_word_char(b[p + 1]) and not b[p + 1].isspace():
-                p += 1
-
-        return min(p, len(b) - 1)
-
-    def vi_forward_word(self, p: int | None = None) -> int:
-        """Return the 0-based index of the first character of the next word
-        (vi 'w' semantics).
-
-        Vi has three character classes: word chars (alnum + _), punctuation
-        (non-word, non-whitespace), and whitespace. 'w' moves to the start
-        of the next word or punctuation sequence."""
-        if p is None:
-            p = self.pos
-        b = self.buffer
-
-        if not b or p >= len(b):
-            return max(0, len(b) - 1) if b else 0
-
-        # Skip current word or punctuation sequence
-        if _is_vi_word_char(b[p]):
-            # On a word char - skip word chars
-            while p < len(b) and _is_vi_word_char(b[p]):
-                p += 1
-        elif not b[p].isspace():
-            # On punctuation - skip punctuation
-            while p < len(b) and not _is_vi_word_char(b[p]) and not b[p].isspace():
-                p += 1
-
-        # Skip whitespace to find next word or punctuation
-        while p < len(b) and b[p].isspace():
-            p += 1
-
-        # Clamp to valid buffer range
-        return min(p, len(b) - 1) if b else 0
-
-    def vi_forward_word_ws(self, p: int | None = None) -> int:
-        """Return the 0-based index of the first character of the next WORD
-        (vi 'W' semantics).
-
-        Treats white space as the only separator."""
-        if p is None:
-            p = self.pos
-        b = self.buffer
-
-        if not b or p >= len(b):
-            return max(0, len(b) - 1) if b else 0
-
-        # Skip all non-whitespace (the current WORD)
-        while p < len(b) and not b[p].isspace():
-            p += 1
-
-        # Skip whitespace to find next WORD
-        while p < len(b) and b[p].isspace():
-            p += 1
-
-        # Clamp to valid buffer range
-        return min(p, len(b) - 1) if b else 0
-
-    def vi_bow(self, p: int | None = None) -> int:
-        """Return the 0-based index of the beginning of the word preceding p
-        (vi 'b' semantics).
-
-        Vi has three character classes: word chars (alnum + _), punctuation
-        (non-word, non-whitespace), and whitespace. 'b' moves to the start
-        of the current or previous word/punctuation sequence."""
-        if p is None:
-            p = self.pos
-        b = self.buffer
-
-        if not b or p <= 0:
-            return 0
-
-        p -= 1
-
-        # Skip whitespace going backward
-        while p >= 0 and b[p].isspace():
-            p -= 1
-
-        if p < 0:
-            return 0
-
-        # Now skip the word or punctuation sequence we landed in
-        if _is_vi_word_char(b[p]):
-            while p > 0 and _is_vi_word_char(b[p - 1]):
-                p -= 1
-        else:
-            # Punctuation sequence
-            while p > 0 and not _is_vi_word_char(b[p - 1]) and not b[p - 1].isspace():
-                p -= 1
-
-        return p
-
-    def vi_bow_ws(self, p: int | None = None) -> int:
-        """Return the 0-based index of the beginning of the WORD preceding p
-        (vi 'B' semantics).
-
-        Treats white space as the only separator."""
-        if p is None:
-            p = self.pos
-        b = self.buffer
-
-        if not b or p <= 0:
-            return 0
-
-        p -= 1
-
-        # Skip whitespace going backward
-        while p >= 0 and b[p].isspace():
-            p -= 1
-
-        if p < 0:
-            return 0
-
-        # Now skip the WORD we landed in
-        while p > 0 and not b[p - 1].isspace():
-            p -= 1
-
-        return p
-
-    def find_char_forward(self, char: str, p: int | None = None) -> int | None:
-        """Find next occurrence of char after p. Returns index or None."""
-        if p is None:
-            p = self.pos
-        for i in range(p + 1, len(self.buffer)):
-            if self.buffer[i] == char:
-                return i
-        return None
-
-    def find_char_backward(self, char: str, p: int | None = None) -> int | None:
-        """Find previous occurrence of char before p. Returns index or None."""
-        if p is None:
-            p = self.pos
-        for i in range(p - 1, -1, -1):
-            if self.buffer[i] == char:
-                return i
-        return None
-
     def bol(self, p: int | None = None) -> int:
         """Return the 0-based index of the line break preceding p most
         immediately.

Lib/_pyrepl/vi_commands.py

@@ -6,6 +6,15 @@
 from . import input as _input
 from .types import ViFindDirection
 from .trace import trace
+from .vi_motions import (
+    vi_eow,
+    vi_forward_word as _vi_forward_word,
+    vi_forward_word_ws as _vi_forward_word_ws,
+    vi_bow,
+    vi_bow_ws,
+    find_char_forward,
+    find_char_backward,
+)
 
 
 class ViKillCommand(KillCommand):
@@ -26,33 +35,33 @@ class end_of_word(MotionCommand):
     def do(self) -> None:
         r = self.reader
         for _ in range(r.get_arg()):
-            r.pos = r.vi_eow()
+            r.pos = vi_eow(r.buffer, r.pos)
 
 
 class vi_forward_word(MotionCommand):
     def do(self) -> None:
         r = self.reader
         for _ in range(r.get_arg()):
-            r.pos = r.vi_forward_word()
+            r.pos = _vi_forward_word(r.buffer, r.pos)
 
 class vi_forward_word_ws(MotionCommand):
     def do(self) -> None:
         r = self.reader
         for _ in range(r.get_arg()):
-            r.pos = r.vi_forward_word_ws()
+            r.pos = _vi_forward_word_ws(r.buffer, r.pos)
 
 class vi_backward_word(MotionCommand):
     def do(self) -> None:
         r = self.reader
         for _ in range(r.get_arg()):
-            r.pos = r.vi_bow()
+            r.pos = vi_bow(r.buffer, r.pos)
 
 
 class vi_backward_word_ws(MotionCommand):
     def do(self) -> None:
         r = self.reader
         for _ in range(r.get_arg()):
-            r.pos = r.vi_bow_ws()
+            r.pos = vi_bow_ws(r.buffer, r.pos)
 
 
 
@@ -127,7 +136,7 @@ class vi_delete_word(ViKillCommand):
     def do(self) -> None:
         r = self.reader
         for _ in range(r.get_arg()):
-            end = r.vi_forward_word()
+            end = _vi_forward_word(r.buffer, r.pos)
             if end > r.pos:
                 self.kill_range(r.pos, end)
 
@@ -264,14 +273,14 @@ def _execute_find(self, char: str, direction: ViFindDirection | None, inclusive:
         r = self.reader
         for _ in range(r.get_arg()):
             if direction == ViFindDirection.FORWARD:
-                new_pos = r.find_char_forward(char)
+                new_pos = find_char_forward(r.buffer, r.pos, char)
                 if new_pos is not None:
                     if not inclusive:
                         new_pos -= 1
                     if new_pos > r.pos:
                         r.pos = new_pos
             else:
-                new_pos = r.find_char_backward(char)
+                new_pos = find_char_backward(r.buffer, r.pos, char)
                 if new_pos is not None:
                     if not inclusive:
                         new_pos += 1
@@ -304,14 +313,14 @@ def do(self) -> None:
 
         for _ in range(r.get_arg()):
             if direction == ViFindDirection.FORWARD:
-                new_pos = r.find_char_forward(char)
+                new_pos = find_char_forward(r.buffer, r.pos, char)
                 if new_pos is not None:
                     if not inclusive:
                         new_pos -= 1
                     if new_pos > r.pos:
                         r.pos = new_pos
             else:
-                new_pos = r.find_char_backward(char)
+                new_pos = find_char_backward(r.buffer, r.pos, char)
                 if new_pos is not None:
                     if not inclusive:
                         new_pos += 1
@@ -334,14 +343,14 @@ def do(self) -> None:
 
         for _ in range(r.get_arg()):
             if direction == ViFindDirection.FORWARD:
-                new_pos = r.find_char_forward(char)
+                new_pos = find_char_forward(r.buffer, r.pos, char)
                 if new_pos is not None:
                     if not inclusive:
                         new_pos -= 1
                     if new_pos > r.pos:
                         r.pos = new_pos
             else:
-                new_pos = r.find_char_backward(char)
+                new_pos = find_char_backward(r.buffer, r.pos, char)
                 if new_pos is not None:
                     if not inclusive:
                         new_pos += 1
@@ -358,7 +367,7 @@ class vi_change_word(ViKillCommand):
     def do(self) -> None:
         r = self.reader
         for _ in range(r.get_arg()):
-            end = r.vi_eow() + 1  # +1 to include last char
+            end = vi_eow(r.buffer, r.pos) + 1  # +1 to include last char
             if end > r.pos:
                 self.kill_range(r.pos, end)
         r.enter_insert_mode()