Bash function squashing output from 'jobs' while job is paused - linux

Question

# allow CTRL-Q and CTRL-S keybindings
vim() {
(
# No ttyctl, so we need to save and then restore terminal settings
# osx users, use stty -g
local STTYOPTS="$(stty --save 2> /dev/null)"
trap "stty $STTYOPTS" EXIT
stty stop '' start '' -ixoff
command vim "$#"
)
}
I'm using the above shell function to temporarily change stty options so that CTRL-Q and CTRL-S can function as keybinds in vim.
This works nicely, but as a side-effect I can no longer see which file corresponds to a background job when I pause vim with CTRL-Z. I frequently work with multiple sessions in the background and it would be really handy to be able to see which job is which again.
Current output from jobs with a background task:
root#rock64:~# jobs
[1]+ Stopped ( local STTYOPTS="$(stty --save 2> /dev/null)"; trap "stty $STTYOPTS" EXIT; stty stop '' start '' -ixoff; command vim "$#" )
root#rock64:~#
Unwrapped output like this would be ideal:
root#rock64:~# jobs
[1]+ Stopped vim .bashrc
root#rock64:~#
Is there a different way to achieve the same effect (temporarily changing STTY options with restore on job completion) without squashing the background jobs listing?
I'm running Bash 4.4.x at the moment but I could easily compile a newer version if needed.

Answer 1

So what I am suggesting in the comment is difficult to convey without better code formatting. I am simply suggesting removing the surrounding ( and ). Additionally, the RETURN trap would need to be removed, so I just made a second function that, when return is called, we jump back to the original function and remove the trap.
runvim() {
local STTYOPTS="$(stty --save 2> /dev/null)"
trap "stty $STTYOPTS" RETURN # This may need to be changed to RETURN
stty stop '' start '' -ixoff
command vim "$#"
}
# allow CTRL-Q and CTRL-S keybindings
vim() {
# No ttyctl, so we need to save and then restore terminal settings
# osx users, use stty -g
runvim "$#"
trap - RETURN
}
Alternative
You could put this in a script called vim in $HOME/bin:
#!/bin/bash
STTYOPTS="$(stty --save 2> /dev/null)"
trap "stty $STTYOPTS" EXIT
stty stop '' start '' -ixoff
#/usr/bin/vim "$#" # or where ever your vim is
$( whereis vim | cut -d\ -f3) "$#" # Here is a more generic version.
Then add that directory to the front of your PATH variable by adding export PATH="$HOME/bin:$PATH" to your favorite dot file.

Answer 2

Edit:
I went ahead and improved the wrapper to look for the next real vim in the path if it's run as a symlink called 'vim' in the user path. This avoids needing to use an alias pointing 'vim' at vimwrapper.sh and transparently forwards 'vim' calls to the actual vim binary. I think this is basically complete now.
#!/usr/bin/env bash
#
# vimwrapper.sh: Wrapper script to enable use of CTRL-Q/S keybinds in Vim
#
# Using a wrapper script avoids clobbering the editor command line with an
# anonymous subshell that's hard to read when vim is suspended with ^Z. We need
# the scope of the subshell to trap our trap (aaayyyyy) and keep the stty magic
# out of our interactive environment's namespace. The wrapper script just
# makes background jobs look sane if you interrupt vim with CTRL-Z.
# set -x
case $(basename "$0") in
"vim")
# Check if we're shadowing real vim by existing earlier in the path as a
# symlink and call it directly if so. This lets us symlink vimwrapper.sh to
# "$HOME/bin/vim", munge "$HOME:/bin" onto the beginning of the path and
# transparently wrap calls to 'vim' without our script going recursive.
for _v in $(which -a "vim"); do
# I refuse to fork myself. You know what, fork you too.
[[ $(realpath "$_v") == $(realpath "$0") ]] && continue
#printf "found real vim in path at '%s'\n" "$(realpath $_v)"
cmd="$_v" && break
done
if [[ -z "$cmd" ]]; then
echo "$(basename $0): Unable to find real vim in path"
exit 1
fi
;;
*)
cmd="vim"
;;
esac
STTYOPTS="$(stty --save 2> /dev/null)"
trap "stty $STTYOPTS" EXIT
stty stop '' start '' -ixoff
command "$cmd" "$#"
Original post:
After playing with this for a while today I think I've got a decent solution. A subshell is necessary to scope/contain the stty parameter changes and the vim process that we want effected by them, but it doesn't have to be an anonymous function in the main shell environment.
#!/usr/bin/env bash
#
# vimwrapper.sh: Wrapper script to enable use of CTRL-Q/S keybinds in Vim
# For best results bind 'alias vim="/path/to/vimwrapper.sh"
#
# Using a wrapper and alias avoids clobbering the editor command line with an
# anonymous subshell that's hard to read when vim is suspended with ^Z. We need
# the scope of the subshell to trap our trap (aaayyyyy) and keep the stty magic
# out of our interactive environment's namespace. The wrapper script just
# makes background jobs look sane if you interrupt vim with CTRL-Z.
# We'll be paranoid and make sure our wrapper script isn't the target of the
# 'command vim' call that comes next.
if [[ $(realpath $(basename "$0")) == $(realpath $(which vim)) ]]; then
echo "$0: I refuse to fork myself. You know what, fork you too."
else
# Save stty state and restore on exit.
STTYOPTS="$(stty --save 2> /dev/null)"
trap "stty $STTYOPTS" EXIT
stty stop '' start '' -ixoff
command vim "$*"
fi
exit 0
Binding a call to the wrapper script as alias vim="~/foo/vimwrapper.sh" takes care of everything nicely:
root#rock64:~/bin# vim vim.sh
[1]+ Stopped ~/bin/vim.sh vim.sh
It's possible to symlink vimwrapper.sh as 'vim' somewhere in the path provided its location has a lower priority than real vim's too. I added a check for that so it doesn't go recursive by accident. I'll probably expand that a little bit so the script can shadow the real vim in the path and figure out which is the right command to call by looking at which -a vim and picking the next entry that isn't itself.
Thanks #Jason for pointing me in the right direction, I really appreciate it.