Defining Shell Aliases for Subcommands

Another popular command line tool that works using subcommands is apt. Unlike git, though, it does not provide its own facility for subcommand aliases. For example, if you wanted to add a log subcommand to view recent package installations, removals, and upgrades, you're out of luck. The closest you might get is defining an alias apt-log:

alias apt-log='less /var/log/apt/history.log'

This works fine, but it's not really the same thing. Is there any way to actually add it as a subcommand alias, or "subalias," without editing the source code? One possibility is writing a wrapper function:

apt() {
    if test "$1" = "log"; then
        less /var/log/apt/history.log
    else
        command apt "$@"
    fi
}

Success! This shell function opens the apt log file if its first argument is log; otherwise it passes its arguments to the real apt command. However, this technique quickly gets tedious if you want to define many such subaliases. It would be much nicer to generate wrapper functions like this automatically.

Using some shell magic, we can write a function to do this sort of wrapping for us.

subalias() {
    local cmd body name

    name="${1%%=*}"
    cmd="${name%_*}"
    body="${1#*=}"

    eval "$cmd"'() {
        local cmd='"$cmd"' subcmd="$1"
        if type "${cmd}_${subcmd}" >/dev/null 2>&1; then
            shift
            "${cmd}_${subcmd}" "$@"
        elif type "${cmd}_${subcmd}_subalias" >/dev/null 2>&1; then
            shift
            "${cmd}_${subcmd}_subalias" "$@"
        elif type "${cmd}_subalias" >/dev/null 2>&1; then
            "${cmd}_subalias" "$@"
        else
            command "$cmd" "$@"
        fi
    }'

    if test "$body" != "$1"; then
        eval "${name}_subalias"'() { '"$body"'; }'
    fi
}

Now you can just write subalias apt_log='less /var/log/apt/history.log'. Two functions will be generated for you: apt_log_subalias to open the log file, and the apt wrapper function to dynamically dispatch based on the arguments passed to it.

What else can we do with this? Try implicitly invoking sudo only when it's required:

for action in install reinstall remove purge autoremove update upgrade \
    full-upgrade edit-sources; do
    subalias apt_${action}='sudo apt '"${action}"' "$@"'
done

Now running apt install hello will automatically invoke sudo, but apt show hello will not. There are a couple interesting things to note. One is that, unlike normal aliases, we had to explicitly append arguments to the command by ending it with "$@". Two is that we were able to run subalias multiple times to define multiple subaliases for apt. (The wrapper functions didn't clobber each other and erase the previous subalias.)

OK, what about sub-subaliases? We can do that too!

subalias apt_show='command apt show "$@"'
subalias apt_show_vim='apt show emacs'

Since everybody knows that Emacs is better than vim, now whenever you type apt show vim you will be directed to Emacs instead. Typing any other package name will dispatch to the real apt show like normal.

This kind of code is a lot of fun to play with, but it's also very brittle! You should definitely avoid using these techniques in production, or to prank unsuspecting coworkers ;-). Defining a normal alias is always the simpler solution, but subaliases can still be handy for personal interactive usage. The Bourne shell is a truly malleable language that can be tailored to your preferences, if you can put up with its idiosyncrasies.