Commit `3e80720dbf`

3e80720dbff31d31d0bb2f4b66335e8b8b81f78e

parent: 3ed8024d96

Verified · cmc

cmc <hello@cleberg.net> · 2026-10-08 02:05 UTC

Babel file Lisp, PWD, and buffers by truename

Lisp header values that need the file (buffer-file-name, expand-file-name)
are evaluated by planning again with the path before the run, so :cache
hashes them as Emacs does. Blocks run with PWD set, as call-process does.
Opening a file by another path shows its open buffer, and buffers of the
same name are named as uniquify does.

Layout: unified · split

Sources/OrgApp/BabelRunner.swift +2

         let directory = job.directory.map { URL(fileURLWithPath: $0, relativeTo: fileDirectory).standardizedFileURL } ?? fileDirectory
         guard FileManager.default.fileExists(atPath: directory.path) else { throw Failure(description: "No folder \(directory.path) for :dir.") }
         process.currentDirectoryURL = directory
+        // As Emacs's `call-process` does, so `pwd` prints the folder as written, not resolved.
+        process.environment?["PWD"] = directory.path
         let stdout = folder.appendingPathComponent("stdout")
         FileManager.default.createFile(atPath: stdout.path, contents: nil)
         let out = try FileHandle(forWritingTo: stdout)

Sources/OrgApp/DocumentSession.swift +27 −1

	@@ -147,7 +147,26 @@ public final class DocumentSession {
147	public var caret: Int { buffer?.selection.first?.lowerBound ?? 0 }	147	public var caret: Int { buffer?.selection.first?.lowerBound ?? 0 }
148	private var name: String { path.map { ($0 as NSString).lastPathComponent } ?? "" }	148	private var name: String { path.map { ($0 as NSString).lastPathComponent } ?? "" }
149		149
150	private func entry(_ path: String) -> Entry? { entries.first { $0.path == path } }	150	/// The open buffer of `path`, or of the same file by another path (`find-buffer-visiting`
		151	/// by truename).
		152	private func entry(_ path: String) -> Entry? {
		153	if let exact = entries.first(where: { $0.path == path }) { return exact }
		154	let truename = URL(fileURLWithPath: path).resolvingSymlinksInPath().path
		155	return entries.first { URL(fileURLWithPath: $0.path).resolvingSymlinksInPath().path == truename }
		156	}
		157
		158	/// The buffer's name as uniquify writes it (`post-forward-angle-brackets`): the file name,
		159	/// with as many of its folders as tell it apart from other open files of the same name.
		160	public func bufferName(_ path: String) -> String {
		161	let name = (path as NSString).lastPathComponent
		162	let others = openPaths.filter { $0 != path && ($0 as NSString).lastPathComponent == name }
		163	guard !others.isEmpty else { return name }
		164	func folders(_ p: String) -> [String] { (p as NSString).deletingLastPathComponent.split(separator: "/").map(String.init).reversed() }
		165	let mine = folders(path)
		166	var count = 1
		167	while count < mine.count, others.contains(where: { folders($0).prefix(count) == mine.prefix(count) }) { count += 1 }
		168	return name + "<" + mine.prefix(count).reversed().joined(separator: "/") + ">"
		169	}
151		170
152	public func isOpen(_ path: String) -> Bool { entry(path) != nil }	171	public func isOpen(_ path: String) -> Bool { entry(path) != nil }
153		172
	@@ -727,6 +746,13 @@ public final class DocumentSession {
727	var job = job	746	var job = job
728	let approved = job.approved	747	let approved = job.approved
729	func agreed(_ block: BabelJob) -> Bool { approved.isEmpty \|\| approved.contains(block.blockText) }	748	func agreed(_ block: BabelJob) -> Bool { approved.isEmpty \|\| approved.contains(block.blockText) }
		749	if job.needsFile {
		750	let document = entry.buffer.document
		751	switch Babel.replan(job, file: entry.path, text: document.text, tree: document.tree) {
		752	case .failure(.message(let message)): return message
		753	case .success(let next): job = next
		754	}
		755	}
730	while let need = job.needs.first {	756	while let need = job.needs.first {
731	guard agreed(need.job) else { return "The blocks changed while running; nothing more was run." }	757	guard agreed(need.job) else { return "The blocks changed while running; nothing more was run." }
732	let output = try await run(need.job)	758	let output = try await run(need.job)

Sources/OrgCore/Compute/Babel.swift +33 −5

     public internal(set) var script: String?
     /// An Emacs Lisp block's form, for `Babel.evaluateNatively`.
     public internal(set) var lispForm: String?
+    /// A Lisp header value couldn't be evaluated without the file's path: plan again with
+    /// `Babel.replan` before running.
+    public internal(set) var needsFile = false
     public struct Need: Sendable, Equatable {
         /// The `:var` value, `name` or `name(args)`.
         /// `shell-file-name`, from `SHELL` as Emacs sets it: runs blocks in the `shell` language
         /// and chooses how variables are written in the `:cache` hash.
         public var shell = ProcessInfo.processInfo.environment["SHELL"] ?? "/bin/sh"
+        /// The file the block is in, for Lisp header values that use it.
+        public var file: String?
         public init() {}
     }
         return plan(context, options: job.options, resolved: resolved)
     }
+    /// Plans `job`'s block again knowing the file it is in.
+    public static func replan(_ job: BabelJob, file: String, text: String, tree: OrgTree) -> Result<BabelJob, Failure> {
+        var options = job.options
+        options.file = file
+        let context = EditContext(revision: 0, text: text, tree: tree, selection: [job.caret..<job.caret])
+        return plan(context, options: options, resolved: job.resolved)
+    }
     static func plan(_ context: EditContext, options: Options, resolved: [String: VarValue]) -> Result<BabelJob, Failure> {
         let text = context.text
         let ns = text as NSString
     static func plan(_ block: SrcBlockInfo, params: Params, model: DocumentModel, text ns: NSString, options: Options,
                      location: Range<Int>, name: String?, inline: Bool = false, refs: References? = nil, useCache: Bool = true) -> Result<BabelJob, Failure> {
+        var evaluated = params
+        evaluated.evaluateLisp(file: options.file)
+        let needsFile = options.file == nil && evaluated.lisp.contains { evaluated.evaluated[$0] == nil }
+        return planBlock(block, params: params, model: model, text: ns, options: options, location: location, name: name, inline: inline,
+                         refs: refs, useCache: useCache).map { job in
+            var job = job
+            job.needsFile = needsFile
+            return job
+        }
+    }
+    static func planBlock(_ block: SrcBlockInfo, params: Params, model: DocumentModel, text ns: NSString, options: Options,
+                          location: Range<Int>, name: String?, inline: Bool, refs: References?, useCache: Bool) -> Result<BabelJob, Failure> {
         let refs = refs ?? References(resolved: [:], options: options)
         var params = params
-        params.evaluateLisp()
+        params.evaluateLisp(file: options.file)
+        let needsFile = options.file == nil && params.lisp.contains { params.evaluated[$0] == nil }
         guard let language = block.language else { return .failure(.message("This block has no language")) }
         let eval = params.single[":eval"]?.lowercased()
         if eval == "never" || eval == "no" || eval == "never-export" || eval == "no-export" {
         } catch {
             return .failure(.message("\(error)"))
         }
-        if useCache, !inline, params.single[":cache"] == "yes" {
+        if useCache, !inline, !needsFile, params.single[":cache"] == "yes" {
             do {
                 let state = try cacheState(language: language, params: params, tables: tables, body: body, location: location, name: name,
                                            call: location != block.range, text: ns, options: options)
         /// `org-babel-read` on the Lisp values the interpreter can evaluate: a string or number
         /// takes the form's place; other values are kept in `evaluated`.
-        mutating func evaluateLisp() {
+        mutating func evaluateLisp(file: String?) {
             for key in lisp {
-                guard let form = try? LispReader.readFirst(single[key] ?? "").sexp, let value = try? Elisp().eval(form) else { continue }
+                guard let form = try? LispReader.readFirst(single[key] ?? "").sexp,
+                      let value = try? (file.map { Tangle.fileLisp(path: $0) } ?? Elisp()).eval(form) else { continue }
                 let printed = Elisp.printed(value)
                 if let s = value.string {
                     single[key] = s
             var inner = refs
             inner.visiting.insert(name)
             var params = try Params(block: block, model: model, text: text, extra: extra)
-            params.evaluateLisp()
+            params.evaluateLisp(file: refs.options.file)
             // A cached block gives its result without running, as `org-babel-execute-src-block` does.
             var useCache = true
             if params.single[":cache"] == "yes", let language = block.language {

Sources/OrgCore/Compute/Tangle.swift +10 −4

         return params
     }
-    /// `org-babel-read` of a header value written as Lisp, with what a file's buffer knows:
+    /// An interpreter with what a file's buffer knows: `buffer-file-name`, `default-directory`,
-    /// `buffer-file-name`, `default-directory` and `system-type`.
+    /// `system-type` and the file name functions.
-    static func evaluate(_ value: String, key: String, path: String) throws -> String {
+    static func fileLisp(path: String) -> Elisp {
-        let refusal = Babel.Failure.message("\(key) \(value) is Lisp tangling can't evaluate yet; nothing was tangled.")
         let lisp = Elisp()
         let directory = (path as NSString).deletingLastPathComponent + "/"
         lisp.set("buffer-file-name", .string(path))
             let name = try string(args, 0)
             return .string(name.hasSuffix("/") ? name : name + "/")
         }
+        return lisp
+    }
+    /// `org-babel-read` of a header value written as Lisp, in `fileLisp`.
+    static func evaluate(_ value: String, key: String, path: String) throws -> String {
+        let refusal = Babel.Failure.message("\(key) \(value) is Lisp tangling can't evaluate yet; nothing was tangled.")
+        let lisp = fileLisp(path: path)
         guard let form = try? LispReader.readFirst(value).sexp, let result = try? lisp.eval(form), !Elisp.isNil(result) else { throw refusal }
         switch result {
         case .string(let s): return s

Sources/Orgstar/ContentView.swift +4 −9

                     }
             }
         }
-        .navigationTitle((previewPath ?? session.path).map { ($0 as NSString).lastPathComponent } ?? "Orgstar")
+        .navigationTitle(previewPath.map { ($0 as NSString).lastPathComponent } ?? session.path.map(session.bufferName) ?? "Orgstar")
         .navigationSubtitle(session.isReadOnly ? "Read-only: not UTF-8" : "")
         .searchable(text: $query, placement: .toolbar, prompt: "Search notes")
         .searchFocused($searchFocused)
     /// `SPC b b`: open buffers, most recent first, by name (with the folder when names repeat).
     private func switchBuffer() {
         let paths = session.recentPaths.dropFirst() + session.recentPaths.prefix(1)
-        let names = paths.map { ($0 as NSString).lastPathComponent }
+        let labels = paths.map(session.bufferName)
-        let labels = paths.map { path in
-            let name = (path as NSString).lastPathComponent
-            guard names.filter({ $0 == name }).count > 1 else { return name }
-            return name + " — " + ((path as NSString).deletingLastPathComponent as NSString).lastPathComponent
-        }
         guard !labels.isEmpty else { return commands.show("No buffers are open") }
         commands.ask(Prompt(key: "buffer", message: "Switch to buffer:", choices: labels)) { answer in
             guard let answer, let index = labels.firstIndex(of: answer) else { return }
     private func tab(_ path: String) -> some View {
         let current = path == session.path
         return HStack(spacing: 6) {
-            Text((path as NSString).lastPathComponent)
+            Text(session.bufferName(path))
                 .lineLimit(1)
                 .foregroundStyle(current ? .primary : .secondary)
                 .accessibilityAddTraits(current ? [.isButton, .isSelected] : .isButton)
             }
             .buttonStyle(.borderless)
             .help("Close")
-            .accessibilityLabel("Close \((path as NSString).lastPathComponent)" + (session.dirtyPaths.contains(path) ? ", unsaved" : ""))
+            .accessibilityLabel("Close \(session.bufferName(path))" + (session.dirtyPaths.contains(path) ? ", unsaved" : ""))
         }
         .font(.callout)
         .padding(.horizontal, 12)

Sources/OrgstarMobile/EditorScreen.swift +1 −1

	@@ -55,7 +55,7 @@ struct EditorScreen: View {
55	ProgressView()	55	ProgressView()
56	}	56	}
57	}	57	}
58	.navigationTitle((path as NSString).lastPathComponent + (session.dirtyPaths.contains(path) ? " •" : ""))	58	.navigationTitle(session.bufferName(path) + (session.dirtyPaths.contains(path) ? " •" : ""))
59	.navigationBarTitleDisplayMode(.inline)	59	.navigationBarTitleDisplayMode(.inline)
60	.toolbar(.hidden, for: .tabBar)	60	.toolbar(.hidden, for: .tabBar)
61	.toolbar {	61	.toolbar {

Tests/OrgAppTests/AppTests.swift +27

	@@ -190,6 +190,33 @@ struct DocumentSessionTests {
190	#expect(session.revealRequest?.offset == 12)	190	#expect(session.revealRequest?.offset == 12)
191	}	191	}
192		192
		193	@Test func sameFileByAnotherPathSharesItsBuffer() throws {
		194	let notes = try Folder()
		195	let file = try notes.write("a.org", "* One\n")
		196	let link = notes.url.appendingPathComponent("link")
		197	try FileManager.default.createSymbolicLink(at: link, withDestinationURL: notes.url)
		198	let session = DocumentSession(recovery: FileRecoveryStore(directory: notes.url.appendingPathComponent(".r")))
		199	session.open(file.path)
		200	session.open(link.appendingPathComponent("a.org").path)
		201	#expect(session.openPaths == [file.path])
		202	#expect(session.path == file.path)
		203	}
		204
		205	@Test func buffersOfTheSameNameShowTheirFolders() throws {
		206	let notes = try Folder()
		207	let a = try notes.write("x/blog/index.org", "a\n")
		208	let b = try notes.write("y/blog/index.org", "b\n")
		209	let c = try notes.write("y/other.org", "c\n")
		210	let session = DocumentSession(recovery: FileRecoveryStore(directory: notes.url.appendingPathComponent(".r")))
		211	session.open(a.path)
		212	#expect(session.bufferName(a.path) == "index.org")
		213	session.open(b.path)
		214	session.open(c.path)
		215	#expect(session.bufferName(a.path) == "index.org<x/blog>")
		216	#expect(session.bufferName(b.path) == "index.org<y/blog>")
		217	#expect(session.bufferName(c.path) == "other.org")
		218	}
		219
193	@Test func openReadsSetupFiles() throws {	220	@Test func openReadsSetupFiles() throws {
194	let notes = try Folder()	221	let notes = try Folder()
195	try notes.write("setup.org", "#+TODO: NEXT \| DONE\n")	222	try notes.write("setup.org", "#+TODO: NEXT \| DONE\n")

Tests/OrgCoreTests/BabelCacheTests.swift +30 −3

	@@ -96,13 +96,40 @@ struct BabelCacheTests {
96	#expect(second.failure == "Cached: \"hi\"")	96	#expect(second.failure == "Cached: \"hi\"")
97	}	97	}
98		98
		99	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
		100	func fileLispMatchesEmacs() throws {
		101	let text = "#+begin_src sh :cache yes :dir (file-name-directory buffer-file-name) :foo (file-name-nondirectory buffer-file-name)\npwd\n#+end_src\n"
		102	let emacs = try EmacsOracle.evaluate(text, """
		103	(progn (require 'ob-shell) (goto-char (point-min))
		104	(let ((info (org-babel-get-src-block-info)))
		105	(setf (nth 2 info) (org-babel-process-params (nth 2 info)))
		106	(list buffer-file-name (org-babel-sha1-hash info :eval))))
		107	""")
		108	let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [2..<2])
		109	guard case .success(let first) = Babel.plan(context) else {
		110	Issue.record("not planned")
		111	return
		112	}
		113	#expect(first.needsFile)
		114	#expect(first.finish.hash == nil)
		115	guard case .success(let job) = Babel.replan(first, file: emacs[0], text: text, tree: context.tree) else {
		116	Issue.record("not replanned")
		117	return
		118	}
		119	#expect(!job.needsFile)
		120	#expect(job.finish.hash == emacs[1])
		121	#expect(job.directory == (emacs[0] as NSString).deletingLastPathComponent + "/")
		122	}
		123
99	@Test func lispHeadersAreRefused() {	124	@Test func lispHeadersAreRefused() {
100	let text = "#+begin_src sh :cache yes :dir (expand-file-name \"x\")\necho hi\n#+end_src\n"	125	let text = "#+begin_src sh :cache yes :dir (user-full-name)\necho hi\n#+end_src\n"
101	let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [2..<2])	126	let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [2..<2])
102	guard case .failure(.message(let message)) = Babel.plan(context) else {	127	var options = Babel.Options()
		128	options.file = "/tmp/a.org"
		129	guard case .failure(.message(let message)) = Babel.plan(context, options: options) else {
103	Issue.record("planned")	130	Issue.record("planned")
104	return	131	return
105	}	132	}
106	#expect(message.hasPrefix(":cache with :dir (expand-file-name"))	133	#expect(message.hasPrefix(":cache with :dir (user-full-name)"))
107	}	134	}
108	}	135	}

Tests/OrgCoreTests/BabelTests.swift +3 −1

         case .session:
             return BabelOutput(stdout: "")
         }
-        process.currentDirectoryURL = job.directory.map { URL(fileURLWithPath: $0, relativeTo: directory) } ?? directory
+        process.currentDirectoryURL = job.directory.map { URL(fileURLWithPath: $0, relativeTo: directory).standardizedFileURL } ?? directory
+        process.environment = ProcessInfo.processInfo.environment.merging(["PWD": process.currentDirectoryURL!.path]) { $1 }
         let stdin = Pipe()
         let stdout = Pipe()
         process.standardInput = stdin
         "TBL#+begin_src python :var t=tbl :colnames '(\"x\" \"y\")\nreturn t\n#+end_src\n",
         "TBL#+begin_src python :var t=tbl :rownames '(\"r1\" \"r2\")\nreturn t\n#+end_src\n",
         "#+begin_src sh :dir (concat \"/\" \"usr\") :results output\npwd\n#+end_src\n",
+        "#+begin_src sh :dir /tmp :results output\npwd\n#+end_src\n",
         "#+NAME: items\n- one\n- two\n\n#+begin_src shell :var l=items :results output\necho \"$l\"\n#+end_src\n",
         // Lisp values.
         "#+begin_src python :var l='(1 2) m='((1 2) (3 4)) n=(+ 1 2) s='(\"a\" \"b\")\nreturn [l, m, n, s]\n#+end_src\n",

Commit 3e80720dbf

Commit `3e80720dbf`