# Number lines in reverse. Overrides nl(1).
nl () {
local DO_REV=false
if [[ "x$*" == "x-f" ]]; then
# Option -f: force reverse, so it works with pipes, too.
DO_REV=true
shift
elif [[ -t 1 ]]; then
DO_REV=true
fi
if $DO_REV; then
# Note that the escape sequences are constructed
# so that any following tab characters still work.
awk '{printf "\x1b[7m%6d \x1b[0;0m %s\n", ++i, $0}' "$@"
else
command nl "$@"
fi
}
# Remove the current directory and change to its parent.
function rmdir. {
# Remove the current directory and change to its parent.
local DIR ANSWER
if [[ $# -gt 0 ]]; then
echo "Usage: rmdir." >&2
return 1
fi
DIR="$(pwd)"
if [[ -z "$(/bin/ls -A)" ]]; then
cd "${DIR%/*}"
rmdir "$DIR"
else
echo "Directory not empty:" >&2
echo "$DIR" >&2
echo "Are you sure you want to recursively remove the whole directory" >&2
echo -n "with all of its contents? [y/n] " >&2
read ANSWER
if [[ "$ANSWER" == "y" ]]; then
cd "${DIR%/*}"
rm -rf "$DIR"
echo "Ok." >&2
else
echo "Cancelled." >&2
fi
fi
}
# Execute a command in multiple directories.
# See the usage message for details.
#
# This is a shell function instead of a script so that
# any zsh functions and aliases can be used inside the
# <command> argument.
fordir ()
{
local CMD DIR ECODE=0 RESULT QUIET=false
if [[ $# -gt 0 && "$1" == "-q" ]]; then
QUIET=true
shift
fi
if [[ $# -gt 0 ]]; then
if [[ "$1" == "--" ]]; then
shift
elif [[ "$1" != "${1#-}" ]]; then
echo "fordir: Error: Unknown option \"$1\"." >&2
return 1
fi
fi
if [[ $# -lt 2 ]]; then
echo "Usage: fordir [-q] '<command>' <dir> [<dir> ...]" >&2
echo "The <command> must be a single argument, i.e. it should be written in quotes." >&2
echo "It is executed in the current zsh context, so your functions and aliases work" >&2
echo "as expected. The return code is the largest return code of all the commands" >&2
echo "executed." >&2
return 1
fi
CMD="$1"
shift
for DIR in "$@"; do
if ! $QUIET; then
echo "======== $DIR ========"
fi
if [[ ! -d "$DIR" ]]; then
echo "fordir: No such directory: $DIR" >&2
RESULT=1
else
(
cd -- "$DIR"
eval "$CMD" || return $?
)
RESULT=$?
fi
if [[ $RESULT -gt $ECODE ]]; then
ECODE=$RESULT
fi
done
return $ECODE
}
# ``fx'' is a shortcut for ``find | xargs''. The following are equivalent:
#
# find [<opts>] <dir> [...] -type f -print0 | xargs -0 <cmd ...>
# fx [<opts>] [<dir> ...] <cmd ...>
#
# If no <dir> is given, ``.'' is assumed, so you can simply type
# ``fx grep foo'', for example. Aliases can be used (but not
# shell functions), so if you have an alias grip="grep -i", you
# can type ``fx grip foo''. find(1) options such as -d, -s and
# -x can be specified before the directories.
#
# If you need to specify more find(1) primaries, you have to
# terminate them with a double hash, for example:
#
# fx -name \*.c -- grep include
#
# is the same as:
#
# find . -name \*.c -type f -print0 | xargs -0 grep include
#
# ``dx'' is the same as ``fx'', except it uses ``-type d''.
alias fx="_xx f"
alias dx="_xx d"
_xx ()
{
setopt localoptions
unsetopt ksharrays
local -a findargs
local i=1
local need_dot=true
local ftype="$1"
shift
# Collect find(1) options (-d, -s, -x).
while [[ $# -gt 0 && "$1" == -* && "$1" != -*[^EHLPdsx]* ]]; do
findargs[i++]="$1"
shift
done
# Collect directories.
while [[ $# -gt 0 && -d "$1" && "$1" != -* ]]; do
findargs[i++]="$1"
need_dot=false
shift
done
if $need_dot; then
findargs[i++]=.
fi
# Are there more find(1) prinaries? If so, collect until "--".
if [[ $# -gt 0 && "$1" == -* && "$1" != "--" ]]; then
# If the primaries don't begin with "-*" (e.g. "!" or "("),
# they must be preceded by a single "-".
if [[ "$1" == "-" ]]; then
shift
fi
findargs[i++]="("
while [[ $# -gt 0 && "$1" != "--" ]]; do
findargs[i++]="$1"
shift
done
findargs[i++]=")"
fi
if [[ $# -gt 0 && "$1" == "--" ]]; then
shift
fi
if [[ $# -eq 0 ]]; then
echo "Usage: ${ftype}x [<opts>] [<dir> ...] [[-] <primary> ... --] <xargs arguments>" >&2
return 1
fi
local cmd="$1"
shift
if ! whence "$cmd" >/dev/null; then
echo "command not found: $cmd" >&2
return 1
fi
# The following eval+whence construct enables using aliases.
find "${findargs[@]}" -type $ftype -print0 \
| eval xargs -0 `whence "$cmd"` '"$@"'
}
# The "z" function acts as a command prefix that expands
# compressed files (via pipes). If the first argument
# begins with "|", it is appended as an additional filter
# after compression. Examples:
#
# Print MD5 checksums of uncompressed content:
# z md5 *.gz
# Print diff, word by word:
# z '| tr " " "\n"' diff -u oldfile.gz newfile.gz
z () {
setopt localoptions
unsetopt ksharrays
local i
local COMPR
local FILTER=""
if [[ "${1-}" == "|"* ]]; then
FILTER="$1"
shift
fi
for (( i = 1 ; i <= $# ; i++ )) do
case "${argv[i]:e}" in
gz|tgz) COMPR=gzip ;;
bz2|tbz) COMPR=bzip2 ;;
xz|txz|lzma) COMPR=xz ;;
*) COMPR="" ;;
esac
if [[ -n "$COMPR" && -f "$argv[i]" ]]; then
argv[i]="<($COMPR -dc ${(qq)argv[i]} $FILTER )"
elif [[ "$argv[i]" == *[^-A-Za-z0-9_./]* ]]; then
argv[i]="${(qq)argv[i]}"
fi
done
eval "$@"
}
# "magic-slash":
#
# When the user types ``../'', convert every further ``/''
# to another ``../''. In other words:
#
# typed: result:
# ..// --> ../../
# ../// --> ../../../
# ..//// --> ../../../../
magic-slash ()
{
if [[ "$LBUFFER" == *../ ]]; then
LBUFFER+=../
_msg_last_dir "$LBUFFER"
else
LBUFFER+=/
_display_dir_info
fi
}
zle -N magic-slash
bindkey / magic-slash
# Calculate an arithmetic expression (using /usr/bin/bc -l)
# and insert the result at the cursor position.
# Bound to <Esc> <M>.
user-insert-math-expression ()
{
setopt localoptions extendedglob
zle -I
local X=$(
stty sane <&2
read "X?Math expression: " <&2
echo -E "$X" | bc -l 2>/dev/null
)
if [[ $? -ne 0 || -z "$X" ]]; then
zle beep;
zle -M "*** Error in math expression! ***"
else
if [[ "$X" == *.* ]]; then # Decimal point?
X="${X%%0#}" # Remove trailing zeros.
if [[ "$X" == .* ]]; then
X="0$X" # Add zero before.
fi
fi
LBUFFER="${LBUFFER}$X"
fi
}
zle -N user-insert-math-expression
bindkey '^[m' user-insert-math-expression
# Complete the current word by searching the history for matches.
# Bound to <Esc> <Esc>. If there are multiple matches, you
# can go back and forth with <Esc> <Esc> and <Esc> <Del>.
user-magic-history-complete()
{
setopt localoptions
unsetopt ksharrays
local -x PRE="$PREFIX"
local -x NXT=0
if [[ -z "$PRE" ]]; then
if [[ $CURRENT -lt 2 ]]; then
set -- $(fc -ln -1)
if [[ -n "${1-}" ]]; then
compadd -Q -S " " -q -- "$1"
fi
return
fi
PRE="${words[ CURRENT - 1 ]} "
NXT=1
fi
while read LINE; do
if [[ -n "$LINE" ]]; then
compadd -Q -V unsorted -1 -S " " -q -- "$LINE"
fi
done <<-EOT
$(fc -lnr 0 | awk '
BEGIN {
pre = ENVIRON["PRE"] ""
nxt = ENVIRON["NXT"] + 0
lpre = length(pre)
}
{
if ((i = index($0, pre)) && (i == 1 || substr($0, i - 1, 1) ~ /[ ]/)) {
x1 = substr($0, i, lpre)
x2 = substr($0, i + lpre)
if (i = match(x2, /[^ ][ ]/))
x2 = substr(x2, 1, i)
if (nxt)
print x2 " "
else
print x1 x2 " "
}
}
')
EOT
}
zle -C user-magic-history-complete-forw menu-complete user-magic-history-complete
zle -C user-magic-history-complete-back reverse-menu-complete user-magic-history-complete
bindkey '^[^[' user-magic-history-complete-forw
bindkey '^[^H' user-magic-history-complete-back
bindkey '^[^?' user-magic-history-complete-back
# This is a generic function that binds an informative
# command to a key sequence. The output of the command
# is displayed below the current input line of the shell
# (which is not modified).
#
# Syntax: Make_Display_Cmd [-R] <name> <keys> <command>
#
# <name> can be anything descriptive and should consist
# only of letters and digits.
# <keys> Is a keysequence, using the same syntax as the
# "bindkey" built-in command. See zshzle(1).
# <command> is the shell command to be executed. Be
# careful that it doesn't print anything to
# stderr. In case of a problem you can call
# "zle beep" to make a (conditional) beep.
# Note that you should quote the command if
# it contains special characters.
#
# Normally, the output of the command is displayed as-is
# below the current input line. The outout can be
# multiple lines, but should be reasonably short so the
# terminal does not scroll too far.
#
# If the -R option is specified, the command is expected
# to produce a list of words, separated by whitespace,
# which are arranged into columns, similar to the menu
# display of filename completion.
Make_Display_Cmd ()
{
local FL="-M" QU='"'
if [[ "$1" == "-R" ]]; then
FL="$1 \"\""
QU=""
shift
fi
local NM="$1" KY="$2"
shift 2
eval "user-display-$NM() { zle $FL $QU\$($*)$QU; }"
zle -N user-display-$NM
bindkey "$KY" user-display-$NM
}
# Examples:
Make_Display_Cmd date "^[d" date
Make_Display_Cmd cal "^[c" ncal -w
Make_Display_Cmd -R ls "^[l" ls -Fb
Make_Display_Cmd where "^[=" where -- '${${BUFFER%%[ ]*}##*/}' \| expand
