Run shell blocks with :cmdline, :stdin and :shebang !136

merged merged by cmc on 2026-10-07 07:59 UTC · krz/orgstar:shell-cmdline into main

3 files changed, +69 −9

Layout: unified · split

Sources/OrgApp/BabelRunner.swift +7 −1

         process.environment = environment
         let stdin = Pipe()
         switch job.runner {
-        case .process(let executable, let arguments):
+        case .process(let executable, var arguments):
+            if let script = job.script {
+                let file = folder.appendingPathComponent("script")
+                try script.write(to: file, atomically: true, encoding: .utf8)
+                try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: file.path)
+                arguments = arguments.map { $0.replacingOccurrences(of: Babel.scriptFileToken, with: file.path) }
+            }
             process.arguments = [executable] + arguments
         case .emacs:
             guard let emacs = EmacsRunner.executable() else { throw Failure(description: "Emacs isn't installed, so Emacs Lisp blocks can't run.") }

Sources/OrgCore/Compute/Babel.swift +46 −6

     var resolved: [String: Babel.VarValue] = [:]
     var caret = 0
     var options = Babel.Options()
+    /// A script for the runner to write to an executable file, for `Babel.scriptFileToken`.
+    public internal(set) var script: String?
     /// An Emacs Lisp block's form, for `Babel.evaluateNatively`.
     public internal(set) var lispForm: String?
 public enum Babel {
     public static let resultFileToken = "__ORGSTAR_RESULT_FILE__"
+    /// Stands, in a job's arguments, for the executable file the runner writes `job.script` to.
+    public static let scriptFileToken = "__ORGSTAR_SCRIPT_FILE__"
     static let shells: Set<String> = ["sh", "bash", "zsh", "shell", "fish", "ksh", "dash", "ash", "csh", "mksh", "posh"]
     static let generic: [String: (String, [String])] = [
         "ruby": ("ruby", []), "js": ("node", []), "javascript": ("node", []), "R": ("Rscript", ["-"]),
         if eval == "never" || eval == "no" || eval == "never-export" || eval == "no-export" {
             return .failure(.message("Evaluation of this \(language) code block\(block.name.map { " (\($0)) " } ?? " ")is disabled."))
         }
-        if params.single[":cmdline"] != nil, !["dot", "plantuml", "mermaid"].contains(language) {
+        if params.single[":cmdline"] != nil, !["dot", "plantuml", "mermaid"].contains(language), !shells.contains(language) {
-            return .failure(.message(":cmdline isn't supported yet; nothing was run."))
+            return .failure(.message(":cmdline isn't supported for \(language) yet; nothing was run."))
         }
-        for key in [":prologue", ":epilogue", ":post", ":stdin", ":shebang"] where params.single[key] != nil {
+        for key in [":prologue", ":epilogue", ":post", ":stdin", ":shebang"] where params.single[key] != nil
+            && !(shells.contains(language) && [":stdin", ":shebang"].contains(key)) {
             return .failure(.message("\(key) isn't supported yet; nothing was run."))
         }
         let session = params.single[":session"].flatMap { $0 == "none" ? nil : ($0.isEmpty ? "*\(language)*" : $0) }
                             file: toFile ? file : nil, fileDescription: params.single[":file-desc"])
         }
         let vars: [(String, VarValue)]
+        var stdin: VarValue?
         do {
             vars = try params.vars.map { ($0.name, try resolve($0.value, model: model, text: ns, refs: refs)) }
+            stdin = try params.single[":stdin"].map { try resolve($0, model: model, text: ns, refs: refs) }
         } catch let needed as Needed {
             // Asked about once, with every block the references reach.
             let texts = [ns.substring(with: NSRange(location))] + referencedBlocks(params, model: model, text: ns, seen: []).map { ns.substring(with: NSRange($0.range)) }
                 }
                 lines.append("\(name)='" + s.replacingOccurrences(of: "'", with: "'\"'\"'") + "'")
             }
-            let full = (lines + [body]).joined(separator: "\n") + (valueIsExitStatus ? "\necho $?" : "")
             let executable = language == "shell" ? options.shell : language
+            let cmdline = params.single[":cmdline"]
+            let shebang = params.single[":shebang"].flatMap { $0.contains(where: { !$0.isWhitespace }) ? $0 : nil }
+            if session == nil, stdin != nil || cmdline != nil || shebang != nil {
+                // `org-babel-sh-evaluate`: an executable script, run by the shell with the
+                // command line after it and `:stdin` as its input; the value is its last line.
+                var script = (shebang ?? "#!/usr/bin/env \(executable)") + "\n"
+                if params.single[":padline"] != "no" { script += "\n" }
+                script += (lines + [body]).joined(separator: "\n")
+                let command = Babel.scriptFileToken + (stdin != nil || cmdline != nil ? " " + (cmdline ?? "") : "")
+                var job = BabelJob(
+                    language: language, runner: .process(executable: executable, arguments: ["-c", command]),
+                    input: stdin.map(shellString) ?? "", directory: dir, block: location, blockText: blockText, alwaysAsk: alwaysAsk,
+                    finish: finishBase(.shell(valueIsExitStatus: valueIsExitStatus))
+                )
+                job.script = script
+                return .success(job)
+            }
+            let full = (lines + [body]).joined(separator: "\n") + (valueIsExitStatus ? "\necho $?" : "")
             return .success(BabelJob(
                 language: language, runner: session.map { .session(name: $0, executable: executable, python: false) } ?? .process(executable: executable, arguments: []),
                 input: full.trimmingCharacters(in: .whitespacesAndNewlines) + "\n", directory: dir,
     static func referencedBlocks(_ params: Params, model: DocumentModel, text: NSString, seen: Set<String>) -> [SrcBlockInfo] {
         var found: [SrcBlockInfo] = []
         var seen = seen
-        for variable in params.vars {
+        for value in params.vars.map(\.value) + [params.single[":stdin"]].compactMap({ $0 }) {
-            guard let (block, arguments) = referencedBlock(variable.value, model: model), let name = block.name, seen.insert(name).inserted else { continue }
+            guard let (block, arguments) = referencedBlock(value, model: model), let name = block.name, seen.insert(name).inserted else { continue }
             found.append(block)
             let extra = arguments.map { [splitArguments($0).map { (":var", $0) }] } ?? []
             if let inner = try? Params(block: block, model: model, text: text, extra: extra) {
         throw Failure.message("\(value) isn't a table or list.")
     }
+    /// `org-babel-sh-var-to-string`: a table's rows as tab-separated lines, a list's items as
+    /// lines.
+    static func shellString(_ value: VarValue) -> String {
+        func cell(_ c: Cell) -> String {
+            switch c {
+            case .number(let n): n
+            case .text(let s): s
+            }
+        }
+        switch value {
+        case .scalar(let s), .number(let s): return s
+        case .list(let items): return items.map(cell).joined(separator: "\n")
+        case .table(let rows): return rows.map { $0.map(cell).joined(separator: "\t") }.joined(separator: "\n")
+        }
+    }
     /// `org-babel-python-var-to-python`.
     static func pythonLiteral(_ value: VarValue) -> String {
         func cell(_ c: Cell) -> String {

Tests/OrgCoreTests/BabelTests.swift +16 −2

         let process = Process()
         process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
         switch job.runner {
-        case .process(let executable, let arguments):
+        case .process(let executable, var arguments):
+            if let script = job.script {
+                let file = folder.appendingPathComponent("script")
+                try script.write(to: file, atomically: true, encoding: .utf8)
+                try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: file.path)
+                arguments = arguments.map { $0.replacingOccurrences(of: Babel.scriptFileToken, with: file.path) }
+            }
             process.arguments = [executable] + arguments
         case .emacs:
             let script = folder.appendingPathComponent("babel.el")
         "#+PROPERTY: header-args :results output\n#+begin_src sh\nprintf 'a b\\nc d\\n'\n#+end_src\n",
         "* Heading\n:PROPERTIES:\n:header-args:sh: :results verbatim\n:END:\n#+begin_src sh\necho 1 2\n#+end_src\n",
         "#+HEADER: :results output\n#+begin_src sh\nprintf 'x y\\nz w\\n'\n#+end_src\n",
+        // `:cmdline`, `:stdin` and `:shebang`.
+        "#+begin_src sh :cmdline one \"two words\" :results output\nfor a in \"$@\"; do echo \"[$a]\"; done\n#+end_src\n",
+        "#+begin_src sh :cmdline 3\necho $(( $1 * 2 ))\n#+end_src\n",
+        "#+NAME: rows\n| a | 1 |\n| b | 2 |\n\n#+begin_src sh :stdin rows :results output\nwhile IFS=$(printf '\\t') read -r k v; do echo \"$k=$v\"; done\n#+end_src\n",
+        "#+NAME: items\n- x\n- y\n\n#+begin_src sh :stdin items\nwc -l | tr -d ' '\n#+end_src\n",
+        "#+begin_src bash :shebang #!/bin/bash :results output\necho ${BASH_VERSION:+bash}\n#+end_src\n",
+        "#+begin_src sh :cmdline a b :padline no :var x=5 :results output\necho $x $#\n#+end_src\n",
+        "#+begin_src sh :stdin src :results output\ntr a-z A-Z\n#+end_src\n\n#+NAME: src\n#+begin_src sh\necho hello\n#+end_src\n",
         // `:var` from other blocks' results.
         "#+begin_src sh :var x=five\necho $((x+1))\n#+end_src\n\n#+NAME: five\n#+begin_src sh\necho 5\n#+end_src\n",
         "#+begin_src python :var t=tbl\nreturn [len(t), t[1][0]]\n#+end_src\n\n#+NAME: tbl\n#+begin_src python\nreturn [[1, 2], [3, 4]]\n#+end_src\n",
             ("#+begin_src sh :eval never\necho\n#+end_src\n", "Evaluation of this sh code block is disabled."),
             ("#+begin_src ruby :session s\nputs 1\n#+end_src\n", ":session isn't supported for ruby yet; nothing was run."),
             ("#+begin_src sh :noweb yes\n<<x()>>\n#+end_src\n", "Noweb references that run a block (x()) aren't supported yet; nothing was run."),
-            ("#+begin_src sh :cmdline -x\necho\n#+end_src\n", ":cmdline isn't supported yet; nothing was run."),
+            ("#+begin_src python :cmdline -x\nreturn 1\n#+end_src\n", ":cmdline isn't supported for python yet; nothing was run."),
             ("#+begin_src cobol\nDISPLAY\n#+end_src\n", "No way to run cobol blocks yet."),
             ("#+begin_src sh :var x=loop\necho\n#+end_src\n#+NAME: loop\n#+begin_src sh :var y=loop\necho\n#+end_src\n", "loop refers to itself through :var"),
         ] {