Implement W and B vi motions

Author: lkollar

Lib/_pyrepl/reader.py

@@ -157,7 +157,9 @@ def make_default_commands() -> dict[CommandName, type[Command]]:
         (r"0", "beginning-of-line"),
         (r"$", "end-of-line"),
         (r"w", "vi-forward-word"),
+        (r"W", "vi-forward-word-ws"),
         (r"b", "vi-backward-word"),
+        (r"B", "vi-backward-word-ws"),
         (r"e", "end-of-word"),
         (r"^", "first-non-whitespace-character"),
 
@@ -599,6 +601,29 @@ def vi_forward_word(self, p: int | None = None) -> int:
         # 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).
@@ -633,6 +658,33 @@ def vi_bow(self, p: int | None = None) -> int:
 
         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 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

@@ -27,6 +27,11 @@ def do(self) -> None:
         for _ in range(r.get_arg()):
             r.pos = r.vi_forward_word()
 
+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()
 
 class vi_backward_word(MotionCommand):
     def do(self) -> None:
@@ -35,6 +40,14 @@ def do(self) -> None:
             r.pos = r.vi_bow()
 
 
+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()
+
+
+
 # ============================================================================
 # Mode Switching Commands
 # ============================================================================

Lib/test/test_pyrepl/test_reader.py

@@ -1021,6 +1021,27 @@ def test_vi_word_boundaries(self):
             ("get_value(x)", "$b", 10, "b from end lands on x"),
             ("get_value(x)", "$bb", 9, "second b lands on ("),
             ("get_value(x)", "$bbb", 0, "third b lands on get_value"),
+
+            # W (WORD motion by whitespace-delimited words)
+            ("foo.bar baz", "0W", 8, "W skips punctuation to baz"),
+            ("one,two three", "0W", 8, "W skips comma to three"),
+            ("hello   world", "0W", 8, "W handles multiple spaces"),
+            ("get_value(x)", "0W", 11, "W clamps to end (no whitespace)"),
+
+            # Backward W (B)
+            ("foo.bar baz", "$B", 8, "B from end lands on baz"),
+            ("foo.bar baz", "$BB", 0, "second B lands on foo.bar"),
+            ("one,two three", "$B", 8, "B from end lands on three"),
+            ("one,two three", "$BB", 0, "second B lands on one,two"),
+            ("hello   world", "$B", 8, "B from end lands on world"),
+            ("hello   world", "$BB", 0, "second B lands on hello"),
+
+            # Edge cases
+            ("   spaces", "0w", 3, "w from BOL skips leading spaces"),
+            ("trailing   ", "0w", 10, "w clamps at end after trailing spaces"),
+            ("a", "0w", 0, "w on single char stays in bounds"),
+            ("", "0w", 0, "w on empty buffer stays at 0"),
+            ("a b c", "0www", 4, "multiple w's work correctly"),
         ]
 
         for text, keys, expected_pos, desc in test_cases: