Commit `e4003d118e`

e4003d118e0bebe476c67fcaf17455fd815bd5cd

parent: aeb1840b38

Verified · cmc

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

C-c C-c in a table runs org-ctrl-c-ctrl-c

The Emacs preset (and Doom, built from it) bound C-c C-c in tables to org.table.align. org-ctrl-c-ctrl-c now evaluates a typed formula, then recalculates a row marked # or aligns, falling back to Emacs when the row needs it.

Layout: unified · split

Sources/OrgCore/Commands/CtrlCCtrlC.swift +13 −3

 // C-c C-c (`org-ctrl-c-ctrl-c`, Org 9.8.7) for the contexts no more specific binding takes:
 // headings set tags, clock lines get their duration again, timestamps their weekday, cookies
 // update, items toggle their checkbox, or without one have their list repaired, setup keywords
-// refresh, and elsewhere there's nothing to do.
+// refresh, tables evaluate a typed formula, then align or recalculate a row marked `#`, and
+// elsewhere there's nothing to do.
 /// `org-ctrl-c-ctrl-c`.
 public struct CtrlCCtrlC: OrgCommand {
         if KeyContext.holds("table", in: context) || TableRecalculate.tblfmLine(in: context) != nil {
             // At the table's very start the context is the table itself, which org recalculates.
             let atStart = buffer.saveExcursion { buffer.tableBegin() } == context.caret
-            return TableRecalculate.tblfmLine(in: context) != nil || atStart ? TableRecalculate(all: true).run(in: context) : commitBuffer(context) { buffer in
+            if TableRecalculate.tblfmLine(in: context) != nil || atStart { return TableRecalculate(all: true).run(in: context) }
+            // `org-table-maybe-eval-formula`, then `org-table-maybe-recalculate-line` on a row
+            // marked `#`, which aligns, or else `org-table-align`.
+            let step = commitBuffer(context) { buffer in
                 try buffer.tableMaybeEvalFormula()
-                buffer.tableAlign()
+                guard buffer.lookingAtLine("^[ \\t]*\\| *# *(\\||$)") else { return buffer.tableAlign() }
+                do {
+                    try buffer.tableRecalculate(all: false)
+                } catch let error as Calc.Unsupported {
+                    throw EmacsBuffer.UserError(message: TableRecalculate.emacsMessage + error.reason)
+                }
             }
+            return TableRecalculate.inEmacs(step, form: "(org-ctrl-c-ctrl-c)", in: context)
         }
         if buffer.footnoteReferenceAtPoint() != nil
             || buffer.footnoteDefinitions().contains(where: { $0.begin <= context.caret && context.caret < ($0.contentsBegin ?? $0.end) }) {

Sources/OrgCore/Compute/TableFormulas.swift +11 −6

                 throw EmacsBuffer.UserError(message: Self.emacsMessage + error.reason)
             }
         }
-        guard case .failed(let message) = step, message.hasPrefix(Self.emacsMessage) else { return step }
+        let form = Self.tblfmLine(in: context) != nil ? "(org-table-calc-current-TBLFM)" : all ? "(org-table-recalculate t)" : "(org-table-recalculate nil)"
-        // Emacs recalculates the table; its text replaces the table here.
+        return Self.inEmacs(step, form: form, in: context)
+    }
+    /// A step that failed with `emacsMessage` as a request to run `form` on the table in
+    /// Emacs, whose text then replaces the table here; other steps unchanged.
+    static func inEmacs(_ step: CommandStep, form: String, in context: EditContext) -> CommandStep {
+        guard case .failed(let message) = step, message.hasPrefix(emacsMessage) else { return step }
         let buffer = EmacsBuffer(context.text, point: context.caret, settings: context.tree.settings, options: context.options)
-        let onTblfm = Self.tblfmLine(in: context) != nil
+        let onTblfm = tblfmLine(in: context) != nil
         if onTblfm {
             while buffer.forwardLine(-1) == 0, !buffer.lookingAtLine("^[ \\t]*\\|") {}
         }
         let table = buffer.tableBegin()..<buffer.tableEnd()
-        let tblfm = onTblfm ? Self.tblfmLine(in: context) ?? "" : buffer.firstTblfm(after: table.upperBound) ?? ""
+        let tblfm = onTblfm ? tblfmLine(in: context) ?? "" : buffer.firstTblfm(after: table.upperBound) ?? ""
-        let form = onTblfm ? "(org-table-calc-current-TBLFM)" : all ? "(org-table-recalculate t)" : "(org-table-recalculate nil)"
         return .external(.emacsTable(
             table: table, point: context.caret, form: form,
-            reason: String(message.dropFirst(Self.emacsMessage.count)), lisp: tblfm.contains("'(")
+            reason: String(message.dropFirst(emacsMessage.count)), lisp: tblfm.contains("'(")
         ))
     }
 }

Sources/OrgCore/Keymap/Presets.swift +1 −1

	@@ -998,7 +998,7 @@ public enum KeymapPreset: String, Sendable, CaseIterable {
998	command = "org.fill-paragraph"	998	command = "org.fill-paragraph"
999	[[bind]]	999	[[bind]]
1000	keys = "C-c C-c"	1000	keys = "C-c C-c"
1001	command = "org.table.align"	1001	command = "org.ctrl-c-ctrl-c"
1002	when = "table"	1002	when = "table"
1003	[[bind]]	1003	[[bind]]
1004	keys = "C-c C-c"	1004	keys = "C-c C-c"

Tests/OrgCoreTests/KeymapTests.swift +1 −1

	@@ -212,6 +212,6 @@ struct CtrlCCtrlCKeyTests {
212	}	212	}
213	#expect(command(at: 1) == "org.ctrl-c-ctrl-c")	213	#expect(command(at: 1) == "org.ctrl-c-ctrl-c")
214	#expect(command(at: 5) == "org.ctrl-c-ctrl-c")	214	#expect(command(at: 5) == "org.ctrl-c-ctrl-c")
215	#expect(command(at: 13) == "org.table.align")	215	#expect(command(at: 13) == "org.ctrl-c-ctrl-c")
216	}	216	}
217	}	217	}

Tests/OrgCoreTests/TableFormulaEntryTests.swift +5

         let replaced = "| a | b |\n| 1 | =$1*5 |\n#+TBLFM: $2=$1*2::@1$2=x\n"
         let reuse = "| a | b |\n| 2 | = |\n#+TBLFM: $2=$1*2\n\nText\n"
         let last = "| 1 | =$1+1 |\n"
+        let marked = "|   | x | y |\n|---+---+---|\n| # | 2 |   |\n|   | 3 |   |\n#+TBLFM: $3=$2*10\n"
+        let markedTyped = "| # | 2 | =$2+1 | |\n| # | 5 | | |\n#+TBLFM: $4=$2*2\n"
         let prompt = { (arg: String) in "(cl-letf (((symbol-function 'read-string) (lambda (&rest _) \"\"))) (org-table-eval-formula \(arg)))" }
         let cases: [(String, String, any OrgCommand, [String: String], String)] = [
             (plain, "*2", TableCommand(.nextField), [:], "(org-table-next-field)"),
             (stored, "| 3", TableEvalFormula(named: false), ["formula": "$1*3"], "(org-table-eval-formula nil \"$1*3\")"),
             (stored, "| 3", TableEvalFormula(named: true), ["formula": "99"], "(org-table-eval-formula '(4) \"99\")"),
             (stored, "| 1 | 2", CtrlCCtrlC(), [:], "(org-ctrl-c-ctrl-c)"),
+            (marked, "| 2", CtrlCCtrlC(), [:], "(org-ctrl-c-ctrl-c)"),
+            (marked, "| 3", CtrlCCtrlC(), [:], "(org-ctrl-c-ctrl-c)"),
+            (markedTyped, "+1", CtrlCCtrlC(), [:], "(org-ctrl-c-ctrl-c)"),
             (stored, "| 3 | 4", TableEvalFormula(named: false), ["formula": ""], prompt("nil")),
             (stored, "| 1", TableEvalFormula(named: true), ["formula": ""], prompt("'(4)")),
         ]

Commit e4003d118e

Commit `e4003d118e`