0b9419ea7c · krz/orgstar

Sources/OrgCore/Keymap/Keymap.swift +6 −4

     }
     /// What can follow `prefix`: each next key with the command it runs, or nil when it
-    /// leads to a longer sequence. Sorted by key.
+    /// leads to a longer sequence. Sorted by key. The command is the first candidate that
-    public func continuations(of prefix: [KeyChord], mode: String? = nil) -> [(key: KeyChord, command: String?)] {
+    /// `runs` accepts, as dispatch picks it, or the first candidate when none does.
+    public func continuations(of prefix: [KeyChord], mode: String? = nil, runs: (KeyBinding) -> Bool = { _ in true }) -> [(key: KeyChord, command: String?)] {
         var seen: [KeyChord: String?] = [:]
         for binding in bindings where binding.mode == mode && binding.keys.count > prefix.count && Array(binding.keys.prefix(prefix.count)) == prefix {
             let next = binding.keys[prefix.count]
             guard seen[next] == nil else { continue }
             if isPrefix(sequence, mode: mode) {
                 seen[next] = .some(nil)
-            } else if let command = candidates(for: sequence, mode: mode).first?.command {
+            } else {
-                seen[next] = .some(command)
+                let found = candidates(for: sequence, mode: mode)
+                if let command = (found.first(where: runs) ?? found.first)?.command { seen[next] = .some(command) }
             }
         }
         return seen.map { (key: $0.key, command: $0.value) }.sorted { $0.key.description < $1.key.description }

Sources/OrgEditorAppKit/Modal.swift +7 −4

         }
         switch dispatcher.feed(chord) {
         case .pending(let keys):
-            let next = keymap.continuations(of: keys, mode: dispatcher.mode).map { item in
+            let context = editContext()
+            let next = keymap.continuations(of: keys, mode: dispatcher.mode) { modalRuns($0, in: context) }.map { item in
                 (key: item.key.description, title: item.command.map { EditorCommands.command($0)?.title ?? $0 } ?? "+prefix")
             }
             onKeysPending?(KeySequence.format(keys), next)
         case .complete(let keys, let candidates):
             if keys.count > 1 { onKeysPending?(nil, []) }
             let context = editContext()
-            if let binding = candidates.first(where: { binding in
+            if let binding = candidates.first(where: { modalRuns($0, in: context) }) {
-                (binding.when.map { KeyContext.holds($0, in: context) } ?? true) && commandApplies(binding.command, in: context)
-            }) {
                 run(binding.command)
                 updateCursor()
                 return true
         return EditContext(revision: document.revision, text: document.text, tree: document.tree, selection: [selected.location..<NSMaxRange(selected)], options: options)
     }
+    private func modalRuns(_ binding: KeyBinding, in context: EditContext) -> Bool {
+        (binding.when.map { KeyContext.holds($0, in: context) } ?? true) && commandApplies(binding.command, in: context)
+    }
     private func commandApplies(_ id: String, in context: EditContext) -> Bool {
         if !isOrg, id.hasPrefix("org.") { return false }
         return switch EditorCommands.command(id)?.action {

Sources/OrgEditorAppKit/OrgEditor.swift +8 −4

         if modal { return handleModal(chord) }
         switch dispatcher.feed(chord) {
         case .pending(let keys):
-            let next = keymap.continuations(of: keys).map { item in
+            let context = context()
+            let next = keymap.continuations(of: keys) { runs($0, in: context) }.map { item in
                 (key: item.key.description, title: item.command.map { EditorCommands.command($0)?.title ?? $0 } ?? "+prefix")
             }
             onKeysPending?(KeySequence.format(keys), next)
         case .complete(let keys, let candidates):
             if keys.count > 1 { onKeysPending?(nil, []) }
             let context = context()
-            let runnable = candidates.first { binding in
+            let runnable = candidates.first { runs($0, in: context) }
-                (binding.when.map { KeyContext.holds($0, in: context) } ?? true) && applies(binding.command, in: context)
-            }
             if let binding = runnable ?? (keys.count > 1 ? candidates.first : nil) {
                 run(binding.command)
                 return true
         return true
     }
+    /// Whether a key's `binding` runs in `context`: its context holds and its command applies.
+    private func runs(_ binding: KeyBinding, in context: EditContext) -> Bool {
+        (binding.when.map { KeyContext.holds($0, in: context) } ?? true) && applies(binding.command, in: context)
+    }
     private func applies(_ id: String, in context: EditContext) -> Bool {
         if !isOrg, id.hasPrefix("org.") { return false }
         return switch EditorCommands.command(id)?.action {

Tests/OrgCoreTests/KeymapTests.swift +13

	@@ -194,6 +194,19 @@ struct KeymapTests {
194	#expect(keymap.continuations(of: []).contains { $0.key == KeyChord("c", .control) && $0.command == nil })	194	#expect(keymap.continuations(of: []).contains { $0.key == KeyChord("c", .control) && $0.command == nil })
195	}	195	}
196		196
		197	@Test func continuationsFollowContext() {
		198	let keymap = KeymapPreset.emacs.keymap
		199	let text = "* a\n#+begin_src sh\necho\n#+end_src\n"
		200	func hint(at caret: Int) -> String?? {
		201	let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [caret..<caret])
		202	return keymap.continuations(of: [KeyChord("c", .control)]) { binding in
		203	binding.when.map { KeyContext.holds($0, in: context) } ?? true
		204	}.first { $0.key == KeyChord("c", .control) }?.command
		205	}
		206	#expect(hint(at: 1) == "org.ctrl-c-ctrl-c")
		207	#expect(hint(at: 20) == "org.babel.execute")
		208	}
		209
197	@Test func contexts() {	210	@Test func contexts() {
198	let text = "* a\n\| x \|\n- item\n"	211	let text = "* a\n\| x \|\n- item\n"
199	let tree = OrgParser.parse(text)	212	let tree = OrgParser.parse(text)

Tests/OrgEditorAppKitTests/ModalTests.swift +15

	@@ -72,6 +72,21 @@ struct ModalTests {
72	#expect(h.editor.vim.mode == .normal)	72	#expect(h.editor.vim.mode == .normal)
73	}	73	}
74		74
		75	@Test func keyHintsFollowContext() {
		76	let h = doom("* a\n#+begin_src sh\necho\n#+end_src\n")
		77	var hints: [(key: String, title: String)] = []
		78	h.editor.onKeysPending = { _, next in if !next.isEmpty { hints = next } }
		79	func hint() -> String? { hints.first { $0.key == "C-c" }?.title }
		80	h.caret(at: 1)
		81	type(h, "C-c")
		82	#expect(hint() != nil && hint() != "Run Source Block")
		83	type(h, "C-g")
		84	h.caret(at: 20)
		85	type(h, "C-c")
		86	#expect(hint() == "Run Source Block")
		87	type(h, "C-g")
		88	}
		89
75	@Test func visualSelection() {	90	@Test func visualSelection() {
76	let h = doom("one two three\n")	91	let h = doom("one two three\n")
77	h.caret(at: 0)	92	h.caret(at: 0)

Commit 0b9419ea7c

Commit `0b9419ea7c`