Function: apheleia--call-process

apheleia--call-process is a natively compiled function defined in apheleia-formatters.el.

Signature

(apheleia--call-process &key NAME STDIN STDOUT STDERR COMMAND REMOTE NOQUERY CONNECTION-TYPE CALLBACK)

Documentation

Helper to synchronously run a formatter process.

This function essentially runs COMMAND synchronously passing STDIN as standard input and saving output to the STDOUT and STDERR buffers. Once the process is finished CALLBACK will be invoked with the exit code (see process-exit-status) of the process.

This function accepts all the same arguments as apheleia--make-process for simplicity, however some may not be used. This includes: NAME, NO-QUERY, and CONNECTION-TYPE.

Source Code

;; Defined in /nix/store/lwcwryzabcmvjcwwzzs65jrwf7p7d7cs-emacs-packages-deps/share/emacs/site-lisp/elpa/apheleia-20260915.1628/apheleia-formatters.el
(cl-defun apheleia--call-process
    (&key name stdin stdout stderr command
          remote noquery connection-type callback)
  "Helper to synchronously run a formatter process.
This function essentially runs COMMAND synchronously passing STDIN
as standard input and saving output to the STDOUT and STDERR buffers.
Once the process is finished CALLBACK will be invoked with the exit
code (see `process-exit-status') of the process.

This function accepts all the same arguments as `apheleia--make-process'
for simplicity, however some may not be used. This includes: NAME,
NO-QUERY, and CONNECTION-TYPE."
  (ignore name noquery connection-type)
  (let* ((run-on-remote (and (eq apheleia-remote-algorithm 'remote)
                             remote))
	 ;; Resolve the formatter executable's path to ensure it's
	 ;; found
	 (command (cons (executable-find (car command) run-on-remote) (cdr command)))
         (stderr-file (apheleia--make-temp-file run-on-remote "apheleia"))
         (args
          (append
           (list
            ;; argv[0]
            (car command)
            ;; If stdin we don't delete the STDIN buffer text with
            ;; `call-process-region'. Otherwise we send no INFILE
            ;; argument to `call-process'.
            (not stdin)
            ;; stdout buffer and stderr file. `call-process' cannot
            ;; capture stderr into a separate buffer, the best we can
            ;; do is save and read from a file.
            `(,stdout ,stderr-file)
            ;; Do not re/display stdout as output is received.
            nil)
           ;; argv[1:]
           (cdr command))))
    (apheleia--log
     'process "Sending stderr for process %s to tempfile %s"
     name stderr-file)
    (unwind-protect
        (let ((exit-status
               (cl-letf* ((message (symbol-function #'message))
                          ((symbol-function #'message)
                           (lambda (format-string &rest args)
                             (unless (string-prefix-p "Renaming" (car args))
                               (apply message format-string args)))))
                 (cond
                  ((and run-on-remote stdin)
                   ;; There's no call-process variant for this, we'll have to
                   ;; copy STDIN to a remote temporary file, create a subshell
                   ;; on the remote that runs the formatter and passes the temp
                   ;; file as stdin and then deletes it.
                   (let* ((remote-stdin
                           (apheleia--make-temp-file
                            run-on-remote "apheleia-stdin"))
                          ;; WARN: This assumes a POSIX compatible shell.
                          (shell
                           (or (bound-and-true-p tramp-default-remote-shell)
                               "sh"))
                          (shell-command
                           (concat
                            (mapconcat #'shell-quote-argument command " ")
                            " < "
                            (shell-quote-argument
                             (apheleia-formatters-local-buffer-file-name
                              remote-stdin)))))
                     (unwind-protect
                         (progn
                           (with-current-buffer stdin
                             (apheleia--write-region-silently
                              nil nil remote-stdin))
                           (apheleia--log
                            'process
                            "Using process-file to create process %s with %S"
                            name (list shell "-c" shell-command))
                           (process-file
                            shell nil (nth 2 args) nil "-c" shell-command))
                       (delete-file remote-stdin))))
                  (stdin
                   (apheleia--log
                    'process
                    "Using call-process-region to create process %s with %S"
                    name command)
                   (with-current-buffer stdin
                     (apply #'call-process-region
                            (point-min) (point-max) args)))
                  (run-on-remote
                   (apheleia--log
                    'process
                    "Using process-file to create process %s with %S"
                    name command)
                   (apply #'process-file args))
                  (t
                   (apheleia--log
                    'process
                    "Using process-file to create process %s with %S"
                    name command)
                   (apply #'call-process args))))))
          ;; Save stderr from STDERR-FILE back into the STDERR buffer.
          (with-current-buffer stderr
            (insert-file-contents stderr-file))
          ;; I don't think it's possible to get here if the process
          ;; was interrupted, since we were running it synchronously,
          ;; so it should be ok to assume we pass nil to the callback.
          (funcall callback exit-status nil)
          ;; We return nil because there's no live process that can be
          ;; returned.
          nil)
      (delete-file stderr-file))))