Bashing is better than extending

Babashka tasks are one of the great discoveries of our time, allowing us to write build tasks in Clojure, with the development ergonomics of a lisp.

The babashka book has a section on adding shell completions. Boom. This is all you need. Now you can enjoy those babashka tasks completions.

Bound to M-!

This is the interactive doorway into emacs lisp start-process functionality.

Bound to M-& and has the same effect as adding a & in shell-command. To kill the process I can hit C-c C-c.

Very useful, very similar to shell-command-async. Always uses the same buffer called *compilation*. You can set compile-command for instance via .dir-locals.el, then it auto makes a compile command in that project.

dired-do-shell-command and dired-do-async-shell-command are symetrical with shell-command and async-shell-command. Those functions call shell-command.

Bound to ! and & in dired Docstring is worth reading. Important to know is that * expands to dired-file-name-at-point, or the marked files, but is implicit as the last arg.

Sometimes you are currently visiting a script file and you just want to run it.

(defun mm/shell-command-on-file (command)
  "Execute COMMAND asynchronously on the current file."
  (interactive (list (read-shell-command
                      (concat "Async shell command on " (buffer-name) ": "))))
  (let ((filename (if (equal major-mode 'dired-mode)
                      default-directory
                    (buffer-file-name))))
    (async-shell-command (concat command " " filename))))

Thanks to Gavin Freeborn for the initial version of this code.

(advice-add
   #'compilation-revert-buffer
   :filter-args
   (defun mm/always-noconfirm-compilation-revert-buffer (args)
     (pcase args
       (`(,ignore-auto nil) `(,ignore-auto t))
       (_ args))))

I use revert-buffer as a consenting adult - kill and restart the compile command, without asking.

(defun mememacs/create-script* (file bang setup)
  (find-file file)
  (insert bang)
  (save-buffer)
  (evil-insert-state)
  (set-file-modes file #o751)
  (funcall setup))

(defun mememacs/create-script (file)
  (interactive "Fnew script: ")
  (mememacs/create-script*
   file
   "#!/bin/sh\n"
   #'shell-script-mode))

(defun mememacs/create-bb-script (file)
  (interactive "Fnew bb: ")
  (mememacs/create-script*
   file
   "#!/usr/bin/env bb\n"
   #'clojure-mode))

I have bound these in dired-mode. Then, I use mm/shell-command-on-file to dev interactively sort of.

Btw shell-script-mode becomes a power house when you integrate shellcheck. flycheck has something for that. (pretty sure flymake should as well.) Shellcheck makes superb warnings. Firmly in my "adopt" circle.

When you run a second command, by default, it tries to reuse the old buffer and asks you

(yes-or-no-p
 (format
  "A command is running in the default buffer.  %s? "
  action))

I put the command into the buffer name so I usually get a unique buffer name.

(setq async-shell-command-buffer 'new-buffer)

  (defun path-slug (dir)
    "Returns the initials of `dir`s path,
with the last part appended fully

Example:

(path-slug \"/foo/bar/hello\")
=> \"f/b/hello\" "
    (let* ((path (replace-regexp-in-string "\\." "" dir))
           (path (split-string path "/" t))
           (path-s (mapconcat
                    (lambda (it)
                      (cl-subseq it 0 1))
                    (nbutlast (copy-sequence path) 1)
                    "/"))
           (path-s (concat
                    path-s
                    "/"
                    (car (last path)))))
      path-s))

  (defun mm/put-command-in-async-buff-name (f &rest args)
    (let* ((path-s (if default-directory (path-slug default-directory) ""))
           (command (car args))
           (buffname (concat path-s " " command))
           (shell-command-buffer-name-async
            (format
             "*async-shell-command %s*"
             (string-trim
              (substring buffname 0 (min (length buffname) 50))))))
      (apply f args)))

  (advice-add 'shell-command :around #'mm/put-command-in-async-buff-name)

Now I can complete buffers and start typing the commands. And the buffers don't have an anonymous name like *async-shell-command<2>*.

Sort of a power setting when you do async-shell-command a lot. Nowadays I do:

(setf async-shell-command-buffer 'new-buffer)

If I want to kill I can do C-c C-c on the old buffer.

(defun mm/shell-via-async-shell-command ()
    (let ((display-buffer-alist
           '((".*" display-buffer-same-window))))
      (async-shell-command shell-file-name)))

You get a shell buffer running your shell. Does everything I need from a terminal. It pays of having a minimal .rc file. This is also why I have shell-file-name set to "/bin/bash". Even though I have a cool zsh config with vi mode. I get all emacs editing power in that shell buffer.

I use project.el. project-compile runs compile in the project root. Analogously, there is project-async-shell-command. projectile, a big and widely used package, provides similar commands.

Similar to going to the *compilation* buffer and revert-buffer. But a single command.

If you use Koacha together with compile, you will get output sprinkled with ANSI (color) escape codes.

Bit cluttering on the eyes.

I knew from earlier dabblings that there is a package called ansi-color. So I checked around on how to make my buffer colored nicely.

Turns out that comint already has ansi-color-compilation-filter setup by default. Checking the code for compile I see that with prefix arg, the buffer becomes a comint buffer. So I decided I always make my compile buffers comint buffers.

(advice-add
   'compile
   :filter-args
   (defun mm/always-use-comint-for-compile (args)
     `(,(car args) t)))

Koacha output looks like this:

Nice tip in case you did not know: You can define preset configs in ~/.ssh/config and they will show up as bash completions when you type ssh and hit tap.

Host dotomic-system-ec2
     HostName ...
     ...

So now I just type M-& for async-shell-command, then ssh, then I hit tap and I get dotomic-system-ec2 as completion. Yes!

Through embark the power of completions is further amplified. For instance, I can complete git branches via git checkout completions.

Another example. I used to use helm-pass for pass. Guess what, pass has great shell completions. I get a free interface to pass just with async-shell-command.

It matters. For instance, if you use "/bin/bash" and you set up your path in a zshrc that might be a pitfall. Another thing that happened to me was that keychain was prompting for my ssh password inside the bash-completion process, making it hang.

1. can you start `bash` and have completions? (on arch, maybe you want to install bash-completion).