Commit `2c9d41fe76`

2c9d41fe76b77b2a438183ed86c564ba5fe0c5c5

parent: 441daa361a

Verified · cmc

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

Share Vim registers, macros and uppercase marks across buffers

Named registers, the clipboard's linewise record and keyboard macros
are kept once for every editor. Uppercase marks are file marks: a jump
to one set in another buffer shows that buffer at the mark. Lowercase
marks and the jump list stay per buffer.

Layout: unified · split

Sources/OrgCore/Keymap/Vim.swift +3 −2

     public internal(set) var mode: Mode = .normal
     /// Keys of the command being typed.
     public private(set) var pending: [KeyChord] = []
-    var registers: [Character: (text: String, linewise: Bool)] = [:]
+    /// Named registers. Evil's are global: an editor with several engines shares them.
+    public var registers: [Character: (text: String, linewise: Bool)] = [:]
     /// What the clipboard held when this engine last wrote it, and whether that was whole lines.
-    var clipboardRecord: (text: String, linewise: Bool)?
+    public var clipboardRecord: (text: String, linewise: Bool)?
     var anchor = 0
     var goalColumn: Int?
     var lastFind: (kind: Character, char: String)?

Sources/OrgEditorAppKit/Modal.swift +39 −6

 import OrgCore
 import OrgDocument
+/// An editor a file mark is in, gone when its buffer closes.
+struct WeakEditor {
+    weak var editor: OrgEditor?
+}
 /// Modal editing: keys go to the keymap for the current evil state first (leader keys,
 /// evil-org's org keys), then to `Vim`.
 extension OrgEditor {
             let wasInsert = vim.mode == .insert
             let visual = vim.mode == .visual || vim.mode == .visualLine
             let caret = visual ? (visualCaret ?? textView.selectedRange().location) : textView.selectedRange().location
+            if jumpToFileMark(key) { continue }
             let clipboard = NSPasteboard.general.string(forType: .string)
             var marks = vimMarks
+            for (name, mark) in Self.fileMarks where mark.owner.editor === self { marks[name] = mark.offset }
             if jumpIndex > 0, jumpIndex <= jumpList.count { marks["'"] = jumpList[jumpIndex - 1] }
+            vim.registers = Self.vimRegisters
+            vim.clipboardRecord = Self.vimClipboardRecord
             let actions = vim.feed(key, Vim.Context(text: document.text, caret: caret, clipboard: clipboard, halfPage: halfPage, marks: marks, visible: visibleText))
+            Self.vimRegisters = vim.registers
+            Self.vimClipboardRecord = vim.clipboardRecord
             apply(actions)
             if !wasInsert, vim.mode == .insert {
                 insertSnapshot = (document.text, textView.selectedRange().location)
         return true
     }
+    /// `'A` or `` `A `` for a file mark in another editor: that editor's buffer shows at the
+    /// mark. True when the key went there.
+    private func jumpToFileMark(_ key: KeyChord) -> Bool {
+        guard vim.mode == .normal, vim.pending.count == 1, let quote = vim.pending.first, quote == KeyChord("'") || quote == KeyChord("`"),
+              key.modifiers.isEmpty, key.key.count == 1, let name = key.key.first, name.isUppercase,
+              let mark = Self.fileMarks[name], let owner = mark.owner.editor, owner !== self else { return false }
+        vim.reset()
+        let ns = owner.document.text as NSString
+        var target = min(mark.offset, ns.length)
+        if quote == KeyChord("'") {
+            // The line's first non-blank.
+            target = ns.lineRange(for: NSRange(location: target, length: 0)).location
+            while target < ns.length, ns.character(at: target) == 32 || ns.character(at: target) == 9 { target += 1 }
+        }
+        onJumpToEditor?(owner, target)
+        return true
+    }
     /// Moves marks and jump positions through an edit.
     func mapVimPositions(through edit: TextEdit) {
-        guard !vimMarks.isEmpty || !jumpList.isEmpty else { return }
+        let owned = Self.fileMarks.filter { $0.value.owner.editor === self }
+        guard !vimMarks.isEmpty || !jumpList.isEmpty || !owned.isEmpty else { return }
         let names = Array(vimMarks.keys)
-        let mapped = ViewState(selection: names.map { vimMarks[$0]!..<vimMarks[$0]! } + jumpList.map { $0..<$0 }).mapped(through: [edit]).selection
+        let fileNames = Array(owned.keys)
+        let positions = names.map { vimMarks[$0]! } + fileNames.map { owned[$0]!.offset } + jumpList
+        let mapped = ViewState(selection: positions.map { $0..<$0 }).mapped(through: [edit]).selection
         for (i, name) in names.enumerated() { vimMarks[name] = mapped[i].lowerBound }
-        jumpList = mapped.dropFirst(names.count).map { $0.lowerBound }
+        for (i, name) in fileNames.enumerated() { Self.fileMarks[name]?.offset = mapped[names.count + i].lowerBound }
+        jumpList = mapped.dropFirst(names.count + fileNames.count).map { $0.lowerBound }
     }
     func insertTyped(_ key: KeyChord) {
             case .message(let text):
                 onMessage?(text)
             case .setMark(let name, let offset):
-                vimMarks[name] = offset
+                if name.isUppercase { Self.fileMarks[name] = (WeakEditor(editor: self), offset) } else { vimMarks[name] = offset }
             case .jumped(let from):
                 // A new jump drops the ones C-o went back past.
                 jumpList = Array(jumpList.prefix(jumpIndex))
                     onMessage?("Defining keyboard macro…")
                 } else if let register = recordingRegister {
                     // Without the `q` that ended it.
-                    macros[register] = Array(recordedKeys.dropLast())
+                    Self.macros[register] = Array(recordedKeys.dropLast())
                     recordingRegister = nil
                     onMessage?("Keyboard macro defined")
                 }
             case .playMacro(let name, let count):
-                guard let keys = macros[name], !keys.isEmpty else {
+                guard let keys = Self.macros[name], !keys.isEmpty else {
                     onMessage?("No macro in register \(name)")
                     continue
                 }

Sources/OrgEditorAppKit/OrgEditor.swift +10 −2

     var insertSnapshot: (text: String, caret: Int)?
     /// The evil cursor in visual states, where the selection's start isn't it.
     var visualCaret: Int?
-    /// Vim marks, mapped through edits.
+    /// Vim's lowercase marks, mapped through edits.
     var vimMarks: [Character: Int] = [:]
+    /// Uppercase marks, with the editor each is in: global, as evil's file marks are.
+    static var fileMarks: [Character: (owner: WeakEditor, offset: Int)] = [:]
+    /// Registers and keyboard macros, shared by every editor as evil's are global.
+    static var vimRegisters: [Character: (text: String, linewise: Bool)] = [:]
+    static var vimClipboardRecord: (text: String, linewise: Bool)?
+    static var macros: [Character: [KeyChord]] = [:]
+    /// Shows `editor`'s buffer with the caret at the offset, for a jump to a file mark set
+    /// there.
+    public var onJumpToEditor: ((OrgEditor, Int) -> Void)?
     /// Jump positions, oldest first, mapped through edits; `jumpIndex` is where C-o and C-i are.
     var jumpList: [Int] = []
     var jumpIndex = 0
     /// The register keys go into while `q` records, and its keys so far.
     var recordingRegister: Character?
     var recordedKeys: [KeyChord] = []
-    var macros: [Character: [KeyChord]] = [:]
     var replayingMacro = 0
     /// A region is active: movement extends the selection, as after C-SPC in Emacs.
     private(set) var markActive = false

Sources/Orgstar/EditorView.swift +7 −2

             coordinator.path = session.path
             container.subviews.forEach { $0.removeFromSuperview() }
             coordinator.editor = nil
-            if let path = session.path, let shown = coordinator.editors[path] ?? makeEditor(container) {
+            if let path = session.path, let shown = coordinator.editors[path] ?? makeEditor(container, coordinator) {
                 coordinator.editors[path] = shown
                 shown.scroll.frame = container.bounds
                 container.addSubview(shown.scroll)
     }
     /// An editor for the current buffer, which becomes the buffer's live state.
-    private func makeEditor(_ container: NSView) -> (editor: OrgEditor, scroll: NSScrollView)? {
+    private func makeEditor(_ container: NSView, _ coordinator: Coordinator) -> (editor: OrgEditor, scroll: NSScrollView)? {
         guard let document = session.document else { return nil }
         let mode: OrgEditor.Mode = session.isOrg ? .org : .plain(language: session.path.flatMap(FileTypes.language))
         let editor = OrgEditor(document: document, frame: container.bounds, editable: document.isEditable, highlighter: Self.highlighter, mode: mode, options: options)
             }
             session?.open(target)
         }
+        editor.onJumpToEditor = { [weak session, weak coordinator] other, offset in
+            guard let session, let path = coordinator?.editors.first(where: { $0.value.editor === other })?.key else { return }
+            session.open(path)
+            session.reveal(offset)
+        }
         editor.onExternal = onExternal
         editor.knownTags = knownTags
         editor.onPrompt = { [weak commands] prompt, reply in commands?.ask(prompt, reply: reply) }

Tests/OrgEditorAppKitTests/ModalTests.swift +35

	@@ -72,6 +72,41 @@ struct ModalTests {
72	#expect(h.editor.vim.mode == .normal)	72	#expect(h.editor.vim.mode == .normal)
73	}	73	}
74		74
		75	@Test func registersAndMacrosAreShared() {
		76	let a = doom("alpha beta\n")
		77	let b = doom("one\ntwo\n")
		78	a.caret(at: 0)
		79	type(a, "\" r y w")
		80	b.caret(at: 0)
		81	type(b, "\" r P")
		82	#expect(b.editor.document.text == "alpha one\ntwo\n")
		83	type(a, "q m A ! ESC q")
		84	type(b, "j @ m")
		85	#expect(b.editor.document.text == "alpha one\ntwo!\n")
		86	}
		87
		88	@Test func uppercaseMarksAreGlobal() {
		89	let a = doom("first\n second\n")
		90	let b = doom("other\ntext\n")
		91	var jumps: [(OrgEditor, Int)] = []
		92	b.editor.onJumpToEditor = { jumps.append(($0, $1)) }
		93	a.caret(at: 10)
		94	type(a, "m Q m q")
		95	b.caret(at: 0)
		96	type(b, "' Q")
		97	#expect(jumps.count == 1 && jumps.first?.0 === a.editor && jumps.first?.1 == 8)
		98	type(b, "` Q")
		99	#expect(jumps.last?.1 == 10)
		100	// Lowercase marks stay in their buffer.
		101	type(b, "j ' q")
		102	#expect(b.textView.selectedRange().location == 6)
		103	// In its own buffer the mark is an ordinary jump, and follows edits.
		104	type(a, "g g O")
		105	a.textView.insertText("new", replacementRange: a.textView.selectedRange())
		106	type(a, "ESC ` Q")
		107	#expect(a.textView.selectedRange().location == 14)
		108	}
		109
75	@Test func zzSavesAndClosesAsWq() {	110	@Test func zzSavesAndClosesAsWq() {
76	let h = doom("text\n")	111	let h = doom("text\n")
77	var app: [String] = []	112	var app: [String] = []

Commit 2c9d41fe76

Commit `2c9d41fe76`