Commit `d97c1b6580`

d97c1b65806245f0532b2e44b4bcec45da6ecd70

parent: 515b208bfa

Verified · cmc

cmc <hello@cleberg.net> · 2026-10-08 03:58 UTC

Repeat snipes with ; and ,

After s or S, ; repeats the snipe and , reverses it, with the snipe's
count, over the visible text (Doom's evil-snipe-repeat-scope). After
f, F, t or T they repeat the find as before.

Layout: unified · split

Sources/OrgCore/Keymap/Vim.swift +19 −5

     var anchor = 0
     var goalColumn: Int?
     var lastFind: (kind: Character, char: String)?
-    var lastSnipe: (forward: Bool, chars: String)?
+    var lastSnipe: (forward: Bool, chars: String, count: Int)?
+    /// `;` and `,` repeat a snipe when one came after the last f, F, t or T.
+    var lastWasSnipe = false
     var lastSearch: (pattern: String, forward: Bool)?
     /// The keys and inserted text of the last change, for `.`.
     var lastChange: (keys: [KeyChord], inserted: String?)?
             let char = keys[1].key == "SPC" ? " " : keys[1].key
             guard char.count == 1 else { return .invalid }
             lastFind = (Character(key.key), char)
+            lastWasSnipe = false
             guard let p = find(Character(key.key), char, buffer, c, count: n) else { return .invalid }
             return .moved(p, key.key == "f" || key.key == "t" ? .inclusive : .exclusive)
+        case (";", []) where lastWasSnipe, (",", []) where lastWasSnipe:
+            // evil-snipe-repeat, with Doom's `evil-snipe-repeat-scope` visible.
+            guard let last = lastSnipe else { return .invalid }
+            let forward = key.key == ";" ? last.forward : !last.forward
+            let scope = contextVisible.map { min($0.lowerBound, buffer.length)..<min($0.upperBound, buffer.length) }
+            guard let p = snipe(forward: forward, last.chars, buffer, c, count: n * last.count, scope: scope) else { return .invalid }
+            return .moved(p, .exclusive)
         case (";", []), (",", []):
             guard let last = lastFind else { return .invalid }
             var kind = last.kind
             // evil-snipe with `evil-snipe-scope` line.
             guard keys.count >= 3 else { return .incomplete }
             let chars = keys[1].key + keys[2].key
-            lastSnipe = (key.key == "s", chars)
+            lastSnipe = (key.key == "s", chars, n)
+            lastWasSnipe = true
             guard let p = snipe(forward: key.key == "s", chars, buffer, c, count: n) else { return .invalid }
             return .moved(p, .exclusive)
         case ("%", []):
         return p
     }
-    func snipe(forward: Bool, _ chars: String, _ buffer: Buffer, _ c: Int, count n: Int) -> Int? {
+    /// Searches the caret's line, or `scope` when given.
-        let line = buffer.substring(buffer.lineStart(c)..<buffer.lineEnd(c)) as NSString
+    func snipe(forward: Bool, _ chars: String, _ buffer: Buffer, _ c: Int, count n: Int, scope: Range<Int>? = nil) -> Int? {
-        let start = buffer.lineStart(c)
+        let range = scope ?? buffer.lineStart(c)..<buffer.lineEnd(c)
+        let line = buffer.substring(range) as NSString
+        let start = range.lowerBound
+        guard range.lowerBound <= c, c <= range.upperBound else { return nil }
         let smart = chars == chars.lowercased()
         var p = c - start
         for _ in 0..<n {

Tests/OrgCoreTests/VimTests.swift +22

	@@ -134,6 +134,11 @@ struct VimTests {
134	("long line here\nab\nlonger line\n", 10, "j j x"),	134	("long line here\nab\nlonger line\n", 10, "j j x"),
135	("one two three\n", 0, "s t h x"),	135	("one two three\n", 0, "s t h x"),
136	("one two three\n", 12, "S t w x"),	136	("one two three\n", 12, "S t w x"),
		137	("ab ab ab ab\n", 0, "s a b ; ; x"),
		138	("ab ab ab ab\n", 0, "s a b ; ; , x"),
		139	("ab ab ab ab\n", 10, "S a b ; x"),
		140	("ab ab ab ab ab ab\n", 0, "2 s a b ; x"),
		141	("one tw tw tw\n", 0, "f w s t w ; x"),
137	("one two three\n", 0, "\" a y w w \" a P"),	142	("one two three\n", 0, "\" a y w w \" a P"),
138	("one two three\n", 0, "\" _ d w"),	143	("one two three\n", 0, "\" _ d w"),
139	(" one\n", 2, "o x ESC"),	144	(" one\n", 2, "o x ESC"),
	@@ -206,6 +211,23 @@ struct VimTests {
206	#expect(vim.feed(KeyChord("Q"), context) == [.ex("q!")])	211	#expect(vim.feed(KeyChord("Q"), context) == [.ex("q!")])
207	}	212	}
208		213
		214	@Test func snipeRepeatsOverTheVisibleText() {
		215	let text = "ab x\ncd ab\nab\n"
		216	func caret(_ keys: String, visible: Range<Int>?) -> Int {
		217	var driver = VimDriver(text, caret: 0)
		218	driver.visible = visible
		219	driver.type(Self.keys(keys))
		220	return driver.caret
		221	}
		222	// The snipe itself keeps to the line; repeats search what the window shows.
		223	#expect(caret("s a b ;", visible: nil) == 0)
		224	#expect(caret("s a b ;", visible: 0..<14) == 8)
		225	#expect(caret("s a b ; ;", visible: 0..<14) == 11)
		226	#expect(caret("s a b ; ; ,", visible: 0..<14) == 8)
		227	// After f, ; repeats the f.
		228	#expect(caret("s a b f x ;", visible: 0..<14) == 3)
		229	}
		230
209	@Test func halfPageScrollsFollowTheWindow() {	231	@Test func halfPageScrollsFollowTheWindow() {
210	#expect(driven(0, "C-d", halfPage: 5) == 35)	232	#expect(driven(0, "C-d", halfPage: 5) == 35)
211	#expect(driven(70, "C-u", halfPage: 5) == 35)	233	#expect(driven(70, "C-u", halfPage: 5) == 35)

Commit d97c1b6580

Commit `d97c1b6580`