etc/zsh/zshrc

   1 # Filename:      /etc/zsh/zshrc
   2 # Purpose:       config file for zsh (z shell)
   3 # Authors:       grml-team (grml.org), (c) Michael Prokop <mika@grml.org>
   4 # Bug-Reports:   see http://grml.org/bugs/
   5 # License:       This file is licensed under the GPL v2.
   6 ################################################################################
   7 # This file is sourced only for interactive shells. It
   8 # should contain commands to set up aliases, functions,
   9 # options, key bindings, etc.
  10 #
  11 # Global Order: zshenv, zprofile, zshrc, zlogin
  12 ################################################################################
  13
  14 # USAGE
  15 # If you are using this file as your ~/.zshrc file, please use ~/.zshrc.pre
  16 # and ~/.zshrc.local for your own customisations. The former file is read
  17 # before ~/.zshrc, the latter is read after it. Also, consider reading the
  18 # refcard and the reference manual for this setup, both available from:
  19 #     <http://grml.org/zsh/>
  20
  21 # Contributing:
  22 # If you want to help to improve grml's zsh setup, clone the grml-etc-core
  23 # repository from git.grml.org:
  24 #   git clone git://git.grml.org/grml-etc-core.git
  25 #
  26 # Make your changes, commit them; use 'git format-patch' to create a series
  27 # of patches and send those to the following address via 'git send-email':
  28 #   grml-etc-core@grml.org
  29 #
  30 # Doing so makes sure the right people get your patches for review and
  31 # possibly inclusion.
  32
  33 # zsh-refcard-tag documentation:
  34 #   You may notice strange looking comments in this file.
  35 #   These are there for a purpose. grml's zsh-refcard can now be
  36 #   automatically generated from the contents of the actual configuration
  37 #   file. However, we need a little extra information on which comments
  38 #   and what lines of code to take into account (and for what purpose).
  39 #
  40 # Here is what they mean:
  41 #
  42 # List of tags (comment types) used:
  43 #   #a#     Next line contains an important alias, that should
  44 #           be included in the grml-zsh-refcard.
  45 #           (placement tag: @@INSERT-aliases@@)
  46 #   #f#     Next line contains the beginning of an important function.
  47 #           (placement tag: @@INSERT-functions@@)
  48 #   #v#     Next line contains an important variable.
  49 #           (placement tag: @@INSERT-variables@@)
  50 #   #k#     Next line contains an important keybinding.
  51 #           (placement tag: @@INSERT-keybindings@@)
  52 #   #d#     Hashed directories list generation:
  53 #               start   denotes the start of a list of 'hash -d'
  54 #                       definitions.
  55 #               end     denotes its end.
  56 #           (placement tag: @@INSERT-hasheddirs@@)
  57 #   #A#     Abbreviation expansion list generation:
  58 #               start   denotes the beginning of abbreviations.
  59 #               end     denotes their end.
  60 #           Lines within this section that end in '#d .*' provide
  61 #           extra documentation to be included in the refcard.
  62 #           (placement tag: @@INSERT-abbrev@@)
  63 #   #m#     This tag allows you to manually generate refcard entries
  64 #           for code lines that are hard/impossible to parse.
  65 #               Example:
  66 #                   #m# k ESC-h Call the run-help function
  67 #               That would add a refcard entry in the keybindings table
  68 #               for 'ESC-h' with the given comment.
  69 #           So the syntax is: #m# <section> <argument> <comment>
  70 #   #o#     This tag lets you insert entries to the 'other' hash.
  71 #           Generally, this should not be used. It is there for
  72 #           things that cannot be done easily in another way.
  73 #           (placement tag: @@INSERT-other-foobar@@)
  74 #
  75 #   All of these tags (except for m and o) take two arguments, the first
  76 #   within the tag, the other after the tag:
  77 #
  78 #   #<tag><section># <comment>
  79 #
  80 #   Where <section> is really just a number, which are defined by the
  81 #   @secmap array on top of 'genrefcard.pl'. The reason for numbers
  82 #   instead of names is, that for the reader, the tag should not differ
  83 #   much from a regular comment. For zsh, it is a regular comment indeed.
  84 #   The numbers have got the following meanings:
  85 #         0 -> "default"
  86 #         1 -> "system"
  87 #         2 -> "user"
  88 #         3 -> "debian"
  89 #         4 -> "search"
  90 #         5 -> "shortcuts"
  91 #         6 -> "services"
  92 #
  93 #   So, the following will add an entry to the 'functions' table in the
  94 #   'system' section, with a (hopefully) descriptive comment:
  95 #       #f1# Edit an alias via zle
  96 #       edalias() {
  97 #
  98 #   It will then show up in the @@INSERT-aliases-system@@ replacement tag
  99 #   that can be found in 'grml-zsh-refcard.tex.in'.
 100 #   If the section number is omitted, the 'default' section is assumed.
 101 #   Furthermore, in 'grml-zsh-refcard.tex.in' @@INSERT-aliases@@ is
 102 #   exactly the same as @@INSERT-aliases-default@@. If you want a list of
 103 #   *all* aliases, for example, use @@INSERT-aliases-all@@.
 104
 105 # zsh profiling
 106 # just execute 'ZSH_PROFILE_RC=1 zsh' and run 'zprof' to get the details
 107 if [[ $ZSH_PROFILE_RC -gt 0 ]] ; then
 108     zmodload zsh/zprof
 109 fi
 110
 111 # load .zshrc.pre to give the user the chance to overwrite the defaults
 112 [[ -r ${ZDOTDIR:-${HOME}}/.zshrc.pre ]] && source ${ZDOTDIR:-${HOME}}/.zshrc.pre
 113
 114 # check for version/system
 115 # check for versions (compatibility reasons)
 116 function is4 () {
 117     [[ $ZSH_VERSION == <4->* ]] && return 0
 118     return 1
 119 }
 120
 121 function is41 () {
 122     [[ $ZSH_VERSION == 4.<1->* || $ZSH_VERSION == <5->* ]] && return 0
 123     return 1
 124 }
 125
 126 function is42 () {
 127     [[ $ZSH_VERSION == 4.<2->* || $ZSH_VERSION == <5->* ]] && return 0
 128     return 1
 129 }
 130
 131 function is425 () {
 132     [[ $ZSH_VERSION == 4.2.<5->* || $ZSH_VERSION == 4.<3->* || $ZSH_VERSION == <5->* ]] && return 0
 133     return 1
 134 }
 135
 136 function is43 () {
 137     [[ $ZSH_VERSION == 4.<3->* || $ZSH_VERSION == <5->* ]] && return 0
 138     return 1
 139 }
 140
 141 function is433 () {
 142     [[ $ZSH_VERSION == 4.3.<3->* || $ZSH_VERSION == 4.<4->* \
 143                                  || $ZSH_VERSION == <5->* ]] && return 0
 144     return 1
 145 }
 146
 147 function is437 () {
 148     [[ $ZSH_VERSION == 4.3.<7->* || $ZSH_VERSION == 4.<4->* \
 149                                  || $ZSH_VERSION == <5->* ]] && return 0
 150     return 1
 151 }
 152
 153 function is439 () {
 154     [[ $ZSH_VERSION == 4.3.<9->* || $ZSH_VERSION == 4.<4->* \
 155                                  || $ZSH_VERSION == <5->* ]] && return 0
 156     return 1
 157 }
 158
 159 #f1# Checks whether or not you're running grml
 160 function isgrml () {
 161     [[ -f /etc/grml_version ]] && return 0
 162     return 1
 163 }
 164
 165 #f1# Checks whether or not you're running a grml cd
 166 function isgrmlcd () {
 167     [[ -f /etc/grml_cd ]] && return 0
 168     return 1
 169 }
 170
 171 if isgrml ; then
 172 #f1# Checks whether or not you're running grml-small
 173     function isgrmlsmall () {
 174         if [[ ${${${(f)"$(</etc/grml_version)"}%% *}##*-} == 'small' ]]; then
 175             return 0
 176         fi
 177         return 1
 178     }
 179 else
 180     function isgrmlsmall () { return 1 }
 181 fi
 182
 183 GRML_OSTYPE=$(uname -s)
 184
 185 function islinux () {
 186     [[ $GRML_OSTYPE == "Linux" ]]
 187 }
 188
 189 function isdarwin () {
 190     [[ $GRML_OSTYPE == "Darwin" ]]
 191 }
 192
 193 function isfreebsd () {
 194     [[ $GRML_OSTYPE == "FreeBSD" ]]
 195 }
 196
 197 function isopenbsd () {
 198     [[ $GRML_OSTYPE == "OpenBSD" ]]
 199 }
 200
 201 function issolaris () {
 202     [[ $GRML_OSTYPE == "SunOS" ]]
 203 }
 204
 205 #f1# are we running within an utf environment?
 206 function isutfenv () {
 207     case "$LANG $CHARSET $LANGUAGE" in
 208         *utf*) return 0 ;;
 209         *UTF*) return 0 ;;
 210         *)     return 1 ;;
 211     esac
 212 }
 213
 214 # check for user, if not running as root set $SUDO to sudo
 215 (( EUID != 0 )) && SUDO='sudo' || SUDO=''
 216
 217 # change directory to home on first invocation of zsh
 218 # important for rungetty -> autologin
 219 # Thanks go to Bart Schaefer!
 220 isgrml && function checkhome () {
 221     if [[ -z "$ALREADY_DID_CD_HOME" ]] ; then
 222         export ALREADY_DID_CD_HOME=$HOME
 223         cd
 224     fi
 225 }
 226
 227 # check for zsh v3.1.7+
 228
 229 if ! [[ ${ZSH_VERSION} == 3.1.<7->*      \
 230      || ${ZSH_VERSION} == 3.<2->.<->*    \
 231      || ${ZSH_VERSION} == <4->.<->*   ]] ; then
 232
 233     printf '-!-\n'
 234     printf '-!- In this configuration we try to make use of features, that only\n'
 235     printf '-!- require version 3.1.7 of the shell; That way this setup can be\n'
 236     printf '-!- used with a wide range of zsh versions, while using fairly\n'
 237     printf '-!- advanced features in all supported versions.\n'
 238     printf '-!-\n'
 239     printf '-!- However, you are running zsh version %s.\n' "$ZSH_VERSION"
 240     printf '-!-\n'
 241     printf '-!- While this *may* work, it might as well fail.\n'
 242     printf '-!- Please consider updating to at least version 3.1.7 of zsh.\n'
 243     printf '-!-\n'
 244     printf '-!- DO NOT EXPECT THIS TO WORK FLAWLESSLY!\n'
 245     printf '-!- If it does today, you'\''ve been lucky.\n'
 246     printf '-!-\n'
 247     printf '-!- Ye been warned!\n'
 248     printf '-!-\n'
 249
 250     function zstyle () { : }
 251 fi
 252
 253 # autoload wrapper - use this one instead of autoload directly
 254 # We need to define this function as early as this, because autoloading
 255 # 'is-at-least()' needs it.
 256 function zrcautoload () {
 257     emulate -L zsh
 258     setopt extended_glob
 259     local fdir ffile
 260     local -i ffound
 261
 262     ffile=$1
 263     (( ffound = 0 ))
 264     for fdir in ${fpath} ; do
 265         [[ -e ${fdir}/${ffile} ]] && (( ffound = 1 ))
 266     done
 267
 268     (( ffound == 0 )) && return 1
 269     if [[ $ZSH_VERSION == 3.1.<6-> || $ZSH_VERSION == <4->* ]] ; then
 270         autoload -U ${ffile} || return 1
 271     else
 272         autoload ${ffile} || return 1
 273     fi
 274     return 0
 275 }
 276
 277 # The following is the ‘add-zsh-hook’ function from zsh upstream. It is
 278 # included here to make the setup work with older versions of zsh (prior to
 279 # 4.3.7) in which this function had a bug that triggers annoying errors during
 280 # shell startup. This is exactly upstreams code from f0068edb4888a4d8fe94def,
 281 # with just a few adjustments in coding style to make the function look more
 282 # compact. This definition can be removed as soon as we raise the minimum
 283 # version requirement to 4.3.7 or newer.
 284 function add-zsh-hook () {
 285     # Add to HOOK the given FUNCTION.
 286     # HOOK is one of chpwd, precmd, preexec, periodic, zshaddhistory,
 287     # zshexit, zsh_directory_name (the _functions subscript is not required).
 288     #
 289     # With -d, remove the function from the hook instead; delete the hook
 290     # variable if it is empty.
 291     #
 292     # -D behaves like -d, but pattern characters are active in the function
 293     # name, so any matching function will be deleted from the hook.
 294     #
 295     # Without -d, the FUNCTION is marked for autoload; -U is passed down to
 296     # autoload if that is given, as are -z and -k. (This is harmless if the
 297     # function is actually defined inline.)
 298     emulate -L zsh
 299     local -a hooktypes
 300     hooktypes=(
 301         chpwd precmd preexec periodic zshaddhistory zshexit
 302         zsh_directory_name
 303     )
 304     local usage="Usage: $0 hook function\nValid hooks are:\n  $hooktypes"
 305     local opt
 306     local -a autoopts
 307     integer del list help
 308     while getopts "dDhLUzk" opt; do
 309         case $opt in
 310         (d) del=1 ;;
 311         (D) del=2 ;;
 312         (h) help=1 ;;
 313         (L) list=1 ;;
 314         ([Uzk]) autoopts+=(-$opt) ;;
 315         (*) return 1 ;;
 316         esac
 317     done
 318     shift $(( OPTIND - 1 ))
 319     if (( list )); then
 320         typeset -mp "(${1:-${(@j:|:)hooktypes}})_functions"
 321         return $?
 322     elif (( help || $# != 2 || ${hooktypes[(I)$1]} == 0 )); then
 323         print -u$(( 2 - help )) $usage
 324         return $(( 1 - help ))
 325     fi
 326     local hook="${1}_functions"
 327     local fn="$2"
 328     if (( del )); then
 329         # delete, if hook is set
 330         if (( ${(P)+hook} )); then
 331             if (( del == 2 )); then
 332                 set -A $hook ${(P)hook:#${~fn}}
 333             else
 334                 set -A $hook ${(P)hook:#$fn}
 335             fi
 336             # unset if no remaining entries --- this can give better
 337             # performance in some cases
 338             if (( ! ${(P)#hook} )); then
 339                 unset $hook
 340             fi
 341         fi
 342     else
 343         if (( ${(P)+hook} )); then
 344             if (( ${${(P)hook}[(I)$fn]} == 0 )); then
 345                 set -A $hook ${(P)hook} $fn
 346             fi
 347         else
 348             set -A $hook $fn
 349         fi
 350         autoload $autoopts -- $fn
 351     fi
 352 }
 353
 354 # Load is-at-least() for more precise version checks Note that this test will
 355 # *always* fail, if the is-at-least function could not be marked for
 356 # autoloading.
 357 zrcautoload is-at-least || function is-at-least () { return 1 }
 358
 359 # set some important options (as early as possible)
 360
 361 # append history list to the history file; this is the default but we make sure
 362 # because it's required for share_history.
 363 setopt append_history
 364
 365 # import new commands from the history file also in other zsh-session
 366 is4 && setopt share_history
 367
 368 # save each command's beginning timestamp and the duration to the history file
 369 setopt extended_history
 370
 371 # If a new command line being added to the history list duplicates an older
 372 # one, the older command is removed from the list
 373 is4 && setopt histignorealldups
 374
 375 # remove command lines from the history list when the first character on the
 376 # line is a space
 377 setopt histignorespace
 378
 379 # if a command is issued that can't be executed as a normal command, and the
 380 # command is the name of a directory, perform the cd command to that directory.
 381 setopt auto_cd
 382
 383 # in order to use #, ~ and ^ for filename generation grep word
 384 # *~(*.gz|*.bz|*.bz2|*.zip|*.Z) -> searches for word not in compressed files
 385 # don't forget to quote '^', '~' and '#'!
 386 setopt extended_glob
 387
 388 # display PID when suspending processes as well
 389 setopt longlistjobs
 390
 391 # report the status of backgrounds jobs immediately
 392 setopt notify
 393
 394 # whenever a command completion is attempted, make sure the entire command path
 395 # is hashed first.
 396 setopt hash_list_all
 397
 398 # not just at the end
 399 setopt completeinword
 400
 401 # Don't send SIGHUP to background processes when the shell exits.
 402 setopt nohup
 403
 404 # make cd push the old directory onto the directory stack.
 405 setopt auto_pushd
 406
 407 # avoid "beep"ing
 408 setopt nobeep
 409
 410 # don't push the same dir twice.
 411 setopt pushd_ignore_dups
 412
 413 # * shouldn't match dotfiles. ever.
 414 setopt noglobdots
 415
 416 # use zsh style word splitting
 417 setopt noshwordsplit
 418
 419 # don't error out when unset parameters are used
 420 setopt unset
 421
 422 # setting some default values
 423 NOCOR=${NOCOR:-0}
 424 NOMENU=${NOMENU:-0}
 425 NOPRECMD=${NOPRECMD:-0}
 426 COMMAND_NOT_FOUND=${COMMAND_NOT_FOUND:-0}
 427 GRML_ZSH_CNF_HANDLER=${GRML_ZSH_CNF_HANDLER:-/usr/share/command-not-found/command-not-found}
 428 GRML_DISPLAY_BATTERY=${GRML_DISPLAY_BATTERY:-${BATTERY:-0}}
 429 GRMLSMALL_SPECIFIC=${GRMLSMALL_SPECIFIC:-1}
 430 ZSH_NO_DEFAULT_LOCALE=${ZSH_NO_DEFAULT_LOCALE:-0}
 431
 432 typeset -ga ls_options
 433 typeset -ga grep_options
 434 if ls --color=auto / >/dev/null 2>&1; then
 435     ls_options+=( --color=auto )
 436 elif ls -G / >/dev/null 2>&1; then
 437     ls_options+=( -G )
 438 fi
 439 if grep --color=auto -q "a" <<< "a" >/dev/null 2>&1; then
 440     grep_options+=( --color=auto )
 441 fi
 442
 443 # utility functions
 444 # this function checks if a command exists and returns either true
 445 # or false. This avoids using 'which' and 'whence', which will
 446 # avoid problems with aliases for which on certain weird systems. :-)
 447 # Usage: check_com [-c|-g] word
 448 #   -c  only checks for external commands
 449 #   -g  does the usual tests and also checks for global aliases
 450 function check_com () {
 451     emulate -L zsh
 452     local -i comonly gatoo
 453     comonly=0
 454     gatoo=0
 455
 456     if [[ $1 == '-c' ]] ; then
 457         comonly=1
 458         shift 1
 459     elif [[ $1 == '-g' ]] ; then
 460         gatoo=1
 461         shift 1
 462     fi
 463
 464     if (( ${#argv} != 1 )) ; then
 465         printf 'usage: check_com [-c|-g] <command>\n' >&2
 466         return 1
 467     fi
 468
 469     if (( comonly > 0 )) ; then
 470         (( ${+commands[$1]}  )) && return 0
 471         return 1
 472     fi
 473
 474     if     (( ${+commands[$1]}    )) \
 475         || (( ${+functions[$1]}   )) \
 476         || (( ${+aliases[$1]}     )) \
 477         || (( ${+reswords[(r)$1]} )) ; then
 478         return 0
 479     fi
 480
 481     if (( gatoo > 0 )) && (( ${+galiases[$1]} )) ; then
 482         return 0
 483     fi
 484
 485     return 1
 486 }
 487
 488 # creates an alias and precedes the command with
 489 # sudo if $EUID is not zero.
 490 function salias () {
 491     emulate -L zsh
 492     local only=0 ; local multi=0
 493     local key val
 494     while getopts ":hao" opt; do
 495         case $opt in
 496             o) only=1 ;;
 497             a) multi=1 ;;
 498             h)
 499                 printf 'usage: salias [-hoa] <alias-expression>\n'
 500                 printf '  -h      shows this help text.\n'
 501                 printf '  -a      replace '\'' ; '\'' sequences with '\'' ; sudo '\''.\n'
 502                 printf '          be careful using this option.\n'
 503                 printf '  -o      only sets an alias if a preceding sudo would be needed.\n'
 504                 return 0
 505                 ;;
 506             *) salias -h >&2; return 1 ;;
 507         esac
 508     done
 509     shift "$((OPTIND-1))"
 510
 511     if (( ${#argv} > 1 )) ; then
 512         printf 'Too many arguments %s\n' "${#argv}"
 513         return 1
 514     fi
 515
 516     key="${1%%\=*}" ;  val="${1#*\=}"
 517     if (( EUID == 0 )) && (( only == 0 )); then
 518         alias -- "${key}=${val}"
 519     elif (( EUID > 0 )) ; then
 520         (( multi > 0 )) && val="${val// ; / ; sudo }"
 521         alias -- "${key}=sudo ${val}"
 522     fi
 523
 524     return 0
 525 }
 526
 527 # Check if we can read given files and source those we can.
 528 function xsource () {
 529     if (( ${#argv} < 1 )) ; then
 530         printf 'usage: xsource FILE(s)...\n' >&2
 531         return 1
 532     fi
 533
 534     while (( ${#argv} > 0 )) ; do
 535         [[ -r "$1" ]] && source "$1"
 536         shift
 537     done
 538     return 0
 539 }
 540
 541 # Check if we can read a given file and 'cat(1)' it.
 542 function xcat () {
 543     emulate -L zsh
 544     if (( ${#argv} != 1 )) ; then
 545         printf 'usage: xcat FILE\n' >&2
 546         return 1
 547     fi
 548
 549     [[ -r $1 ]] && cat $1
 550     return 0
 551 }
 552
 553 # Remove these functions again, they are of use only in these
 554 # setup files. This should be called at the end of .zshrc.
 555 function xunfunction () {
 556     emulate -L zsh
 557     local -a funcs
 558     local func
 559     funcs=(salias xcat xsource xunfunction zrcautoload zrcautozle)
 560     for func in $funcs ; do
 561         [[ -n ${functions[$func]} ]] \
 562             && unfunction $func
 563     done
 564     return 0
 565 }
 566
 567 # this allows us to stay in sync with grml's zshrc and put own
 568 # modifications in ~/.zshrc.local
 569 function zrclocal () {
 570     xsource "/etc/zsh/zshrc.local"
 571     xsource "${ZDOTDIR:-${HOME}}/.zshrc.local"
 572     return 0
 573 }
 574
 575 # locale setup
 576 if (( ZSH_NO_DEFAULT_LOCALE == 0 )); then
 577     xsource "/etc/default/locale"
 578 fi
 579
 580 for var in LANG LC_ALL LC_MESSAGES ; do
 581     [[ -n ${(P)var} ]] && export $var
 582 done
 583 builtin unset -v var
 584
 585 # set some variables
 586 if check_com -c vim ; then
 587 #v#
 588     export EDITOR=${EDITOR:-vim}
 589 else
 590     export EDITOR=${EDITOR:-vi}
 591 fi
 592
 593 #v#
 594 export PAGER=${PAGER:-less}
 595
 596 #v#
 597 export MAIL=${MAIL:-/var/mail/$USER}
 598
 599 # color setup for ls:
 600 check_com -c dircolors && eval $(dircolors -b)
 601 # color setup for ls on OS X / FreeBSD:
 602 isdarwin && export CLICOLOR=1
 603 isfreebsd && export CLICOLOR=1
 604
 605 # do MacPorts setup on darwin
 606 if isdarwin && [[ -d /opt/local ]]; then
 607     # Note: PATH gets set in /etc/zprofile on Darwin, so this can't go into
 608     # zshenv.
 609     PATH="/opt/local/bin:/opt/local/sbin:$PATH"
 610     MANPATH="/opt/local/share/man:$MANPATH"
 611 fi
 612 # do Fink setup on darwin
 613 isdarwin && xsource /sw/bin/init.sh
 614
 615 # load our function and completion directories
 616 for fdir in /usr/share/grml/zsh/completion /usr/share/grml/zsh/functions; do
 617     fpath=( ${fdir} ${fdir}/**/*(/N) ${fpath} )
 618 done
 619 typeset -aU ffiles
 620 ffiles=(/usr/share/grml/zsh/functions/**/[^_]*[^~](N.:t))
 621 (( ${#ffiles} > 0 )) && autoload -U "${ffiles[@]}"
 622 unset -v fdir ffiles
 623
 624 # support colors in less
 625 export LESS_TERMCAP_mb=$'\E[01;31m'
 626 export LESS_TERMCAP_md=$'\E[01;31m'
 627 export LESS_TERMCAP_me=$'\E[0m'
 628 export LESS_TERMCAP_se=$'\E[0m'
 629 export LESS_TERMCAP_so=$'\E[01;44;33m'
 630 export LESS_TERMCAP_ue=$'\E[0m'
 631 export LESS_TERMCAP_us=$'\E[01;32m'
 632
 633 # mailchecks
 634 MAILCHECK=30
 635
 636 # report about cpu-/system-/user-time of command if running longer than
 637 # 5 seconds
 638 REPORTTIME=5
 639
 640 # watch for everyone but me and root
 641 watch=(notme root)
 642
 643 # automatically remove duplicates from these arrays
 644 typeset -U path PATH cdpath CDPATH fpath FPATH manpath MANPATH
 645
 646 # Load a few modules
 647 is4 && \
 648 for mod in parameter complist deltochar mathfunc ; do
 649     zmodload -i zsh/${mod} 2>/dev/null || print "Notice: no ${mod} available :("
 650 done && builtin unset -v mod
 651
 652 # autoload zsh modules when they are referenced
 653 if is4 ; then
 654     zmodload -a  zsh/stat    zstat
 655     zmodload -a  zsh/zpty    zpty
 656     zmodload -ap zsh/mapfile mapfile
 657 fi
 658
 659 # completion system
 660 COMPDUMPFILE=${COMPDUMPFILE:-${ZDOTDIR:-${HOME}}/.zcompdump}
 661 if zrcautoload compinit ; then
 662     compinit -d ${COMPDUMPFILE} || print 'Notice: no compinit available :('
 663 else
 664     print 'Notice: no compinit available :('
 665     function compdef { }
 666 fi
 667
 668 # completion system
 669
 670 # called later (via is4 && grmlcomp)
 671 # note: use 'zstyle' for getting current settings
 672 #         press ^xh (control-x h) for getting tags in context; ^x? (control-x ?) to run complete_debug with trace output
 673 function grmlcomp () {
 674     # TODO: This could use some additional information
 675
 676     # Make sure the completion system is initialised
 677     (( ${+_comps} )) || return 1
 678
 679     # allow one error for every three characters typed in approximate completer
 680     zstyle ':completion:*:approximate:'    max-errors 'reply=( $((($#PREFIX+$#SUFFIX)/3 )) numeric )'
 681
 682     # don't complete backup files as executables
 683     zstyle ':completion:*:complete:-command-::commands' ignored-patterns '(aptitude-*|*\~)'
 684
 685     # start menu completion only if it could find no unambiguous initial string
 686     zstyle ':completion:*:correct:*'       insert-unambiguous true
 687     zstyle ':completion:*:corrections'     format $'%{\e[0;31m%}%d (errors: %e)%{\e[0m%}'
 688     zstyle ':completion:*:correct:*'       original true
 689
 690     # activate color-completion
 691     zstyle ':completion:*:default'         list-colors ${(s.:.)LS_COLORS}
 692
 693     # format on completion
 694     zstyle ':completion:*:descriptions'    format $'%{\e[0;31m%}completing %B%d%b%{\e[0m%}'
 695
 696     # automatically complete 'cd -<tab>' and 'cd -<ctrl-d>' with menu
 697     # zstyle ':completion:*:*:cd:*:directory-stack' menu yes select
 698
 699     # insert all expansions for expand completer
 700     zstyle ':completion:*:expand:*'        tag-order all-expansions
 701     zstyle ':completion:*:history-words'   list false
 702
 703     # activate menu
 704     zstyle ':completion:*:history-words'   menu yes
 705
 706     # ignore duplicate entries
 707     zstyle ':completion:*:history-words'   remove-all-dups yes
 708     zstyle ':completion:*:history-words'   stop yes
 709
 710     # match uppercase from lowercase
 711     zstyle ':completion:*'                 matcher-list 'm:{a-z}={A-Z}'
 712
 713     # separate matches into groups
 714     zstyle ':completion:*:matches'         group 'yes'
 715     zstyle ':completion:*'                 group-name ''
 716
 717     if [[ "$NOMENU" -eq 0 ]] ; then
 718         # if there are more than 5 options allow selecting from a menu
 719         zstyle ':completion:*'               menu select=5
 720     else
 721         # don't use any menus at all
 722         setopt no_auto_menu
 723     fi
 724
 725     zstyle ':completion:*:messages'        format '%d'
 726     zstyle ':completion:*:options'         auto-description '%d'
 727
 728     # describe options in full
 729     zstyle ':completion:*:options'         description 'yes'
 730
 731     # on processes completion complete all user processes
 732     zstyle ':completion:*:processes'       command 'ps -au$USER'
 733
 734     # offer indexes before parameters in subscripts
 735     zstyle ':completion:*:*:-subscript-:*' tag-order indexes parameters
 736
 737     # provide verbose completion information
 738     zstyle ':completion:*'                 verbose true
 739
 740     # recent (as of Dec 2007) zsh versions are able to provide descriptions
 741     # for commands (read: 1st word in the line) that it will list for the user
 742     # to choose from. The following disables that, because it's not exactly fast.
 743     zstyle ':completion:*:-command-:*:'    verbose false
 744
 745     # set format for warnings
 746     zstyle ':completion:*:warnings'        format $'%{\e[0;31m%}No matches for:%{\e[0m%} %d'
 747
 748     # define files to ignore for zcompile
 749     zstyle ':completion:*:*:zcompile:*'    ignored-patterns '(*~|*.zwc)'
 750     zstyle ':completion:correct:'          prompt 'correct to: %e'
 751
 752     # Ignore completion functions for commands you don't have:
 753     zstyle ':completion::(^approximate*):*:functions' ignored-patterns '_*'
 754
 755     # Provide more processes in completion of programs like killall:
 756     zstyle ':completion:*:processes-names' command 'ps c -u ${USER} -o command | uniq'
 757
 758     # complete manual by their section
 759     zstyle ':completion:*:manuals'    separate-sections true
 760     zstyle ':completion:*:manuals.*'  insert-sections   true
 761     zstyle ':completion:*:man:*'      menu yes select
 762
 763     # Search path for sudo completion
 764     zstyle ':completion:*:sudo:*' command-path /usr/local/sbin \
 765                                                /usr/local/bin  \
 766                                                /usr/sbin       \
 767                                                /usr/bin        \
 768                                                /sbin           \
 769                                                /bin            \
 770                                                /usr/X11R6/bin
 771
 772     # provide .. as a completion
 773     zstyle ':completion:*' special-dirs ..
 774
 775     # run rehash on completion so new installed program are found automatically:
 776     function _force_rehash () {
 777         (( CURRENT == 1 )) && rehash
 778         return 1
 779     }
 780
 781     ## correction
 782     # some people don't like the automatic correction - so run 'NOCOR=1 zsh' to deactivate it
 783     if [[ "$NOCOR" -gt 0 ]] ; then
 784         zstyle ':completion:*' completer _oldlist _expand _force_rehash _complete _files _ignored
 785         setopt nocorrect
 786     else
 787         # try to be smart about when to use what completer...
 788         setopt correct
 789         zstyle -e ':completion:*' completer '
 790             if [[ $_last_try != "$HISTNO$BUFFER$CURSOR" ]] ; then
 791                 _last_try="$HISTNO$BUFFER$CURSOR"
 792                 reply=(_complete _match _ignored _prefix _files)
 793             else
 794                 if [[ $words[1] == (rm|mv) ]] ; then
 795                     reply=(_complete _files)
 796                 else
 797                     reply=(_oldlist _expand _force_rehash _complete _ignored _correct _approximate _files)
 798                 fi
 799             fi'
 800     fi
 801
 802     # command for process lists, the local web server details and host completion
 803     zstyle ':completion:*:urls' local 'www' '/var/www/' 'public_html'
 804
 805     # Some functions, like _apt and _dpkg, are very slow. We can use a cache in
 806     # order to speed things up
 807     if [[ ${GRML_COMP_CACHING:-yes} == yes ]]; then
 808         GRML_COMP_CACHE_DIR=${GRML_COMP_CACHE_DIR:-${ZDOTDIR:-$HOME}/.cache}
 809         if [[ ! -d ${GRML_COMP_CACHE_DIR} ]]; then
 810             command mkdir -p "${GRML_COMP_CACHE_DIR}"
 811         fi
 812         zstyle ':completion:*' use-cache  yes
 813         zstyle ':completion:*:complete:*' cache-path "${GRML_COMP_CACHE_DIR}"
 814     fi
 815
 816     # host completion
 817     if is42 ; then
 818         [[ -r ~/.ssh/config ]] && _ssh_config_hosts=(${${(s: :)${(ps:\t:)${${(@M)${(f)"$(<$HOME/.ssh/config)"}:#Host *}#Host }}}:#*[*?]*}) || _ssh_config_hosts=()
 819         [[ -r ~/.ssh/known_hosts ]] && _ssh_hosts=(${${${${(f)"$(<$HOME/.ssh/known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _ssh_hosts=()
 820         [[ -r /etc/hosts ]] && : ${(A)_etc_hosts:=${(s: :)${(ps:\t:)${${(f)~~"$(</etc/hosts)"}%%\#*}##[:blank:]#[^[:blank:]]#}}} || _etc_hosts=()
 821     else
 822         _ssh_config_hosts=()
 823         _ssh_hosts=()
 824         _etc_hosts=()
 825     fi
 826     hosts=(
 827         $(hostname)
 828         "$_ssh_config_hosts[@]"
 829         "$_ssh_hosts[@]"
 830         "$_etc_hosts[@]"
 831         localhost
 832     )
 833     zstyle ':completion:*:hosts' hosts $hosts
 834     # TODO: so, why is this here?
 835     #  zstyle '*' hosts $hosts
 836
 837     # use generic completion system for programs not yet defined; (_gnu_generic works
 838     # with commands that provide a --help option with "standard" gnu-like output.)
 839     for compcom in cp deborphan df feh fetchipac gpasswd head hnb ipacsum mv \
 840                    pal stow uname ; do
 841         [[ -z ${_comps[$compcom]} ]] && compdef _gnu_generic ${compcom}
 842     done; unset compcom
 843
 844     # see upgrade function in this file
 845     compdef _hosts upgrade
 846 }
 847
 848 # Keyboard setup: The following is based on the same code, we wrote for
 849 # debian's setup. It ensures the terminal is in the right mode, when zle is
 850 # active, so the values from $terminfo are valid. Therefore, this setup should
 851 # work on all systems, that have support for `terminfo'. It also requires the
 852 # zsh in use to have the `zsh/terminfo' module built.
 853 #
 854 # If you are customising your `zle-line-init()' or `zle-line-finish()'
 855 # functions, make sure you call the following utility functions in there:
 856 #
 857 #     - zle-line-init():      zle-smkx
 858 #     - zle-line-finish():    zle-rmkx
 859
 860 # Use emacs-like key bindings by default:
 861 bindkey -e
 862
 863 # Custom widgets:
 864
 865 ## beginning-of-line OR beginning-of-buffer OR beginning of history
 866 ## by: Bart Schaefer <schaefer@brasslantern.com>, Bernhard Tittelbach
 867 function beginning-or-end-of-somewhere () {
 868     local hno=$HISTNO
 869     if [[ ( "${LBUFFER[-1]}" == $'\n' && "${WIDGET}" == beginning-of* ) || \
 870       ( "${RBUFFER[1]}" == $'\n' && "${WIDGET}" == end-of* ) ]]; then
 871         zle .${WIDGET:s/somewhere/buffer-or-history/} "$@"
 872     else
 873         zle .${WIDGET:s/somewhere/line-hist/} "$@"
 874         if (( HISTNO != hno )); then
 875             zle .${WIDGET:s/somewhere/buffer-or-history/} "$@"
 876         fi
 877     fi
 878 }
 879 zle -N beginning-of-somewhere beginning-or-end-of-somewhere
 880 zle -N end-of-somewhere beginning-or-end-of-somewhere
 881
 882 # add a command line to the shells history without executing it
 883 function commit-to-history () {
 884     print -s ${(z)BUFFER}
 885     zle send-break
 886 }
 887 zle -N commit-to-history
 888
 889 # only slash should be considered as a word separator:
 890 function slash-backward-kill-word () {
 891     local WORDCHARS="${WORDCHARS:s@/@}"
 892     # zle backward-word
 893     zle backward-kill-word
 894 }
 895 zle -N slash-backward-kill-word
 896
 897 # a generic accept-line wrapper
 898
 899 # This widget can prevent unwanted autocorrections from command-name
 900 # to _command-name, rehash automatically on enter and call any number
 901 # of builtin and user-defined widgets in different contexts.
 902 #
 903 # For a broader description, see:
 904 # <http://bewatermyfriend.org/posts/2007/12-26.11-50-38-tooltime.html>
 905 #
 906 # The code is imported from the file 'zsh/functions/accept-line' from
 907 # <http://ft.bewatermyfriend.org/comp/zsh/zsh-dotfiles.tar.bz2>, which
 908 # distributed under the same terms as zsh itself.
 909
 910 # A newly added command will may not be found or will cause false
 911 # correction attempts, if you got auto-correction set. By setting the
 912 # following style, we force accept-line() to rehash, if it cannot
 913 # find the first word on the command line in the $command[] hash.
 914 zstyle ':acceptline:*' rehash true
 915
 916 function Accept-Line () {
 917     setopt localoptions noksharrays
 918     local -a subs
 919     local -xi aldone
 920     local sub
 921     local alcontext=${1:-$alcontext}
 922
 923     zstyle -a ":acceptline:${alcontext}" actions subs
 924
 925     (( ${#subs} < 1 )) && return 0
 926
 927     (( aldone = 0 ))
 928     for sub in ${subs} ; do
 929         [[ ${sub} == 'accept-line' ]] && sub='.accept-line'
 930         zle ${sub}
 931
 932         (( aldone > 0 )) && break
 933     done
 934 }
 935
 936 function Accept-Line-getdefault () {
 937     emulate -L zsh
 938     local default_action
 939
 940     zstyle -s ":acceptline:${alcontext}" default_action default_action
 941     case ${default_action} in
 942         ((accept-line|))
 943             printf ".accept-line"
 944             ;;
 945         (*)
 946             printf ${default_action}
 947             ;;
 948     esac
 949 }
 950
 951 function Accept-Line-HandleContext () {
 952     zle Accept-Line
 953
 954     default_action=$(Accept-Line-getdefault)
 955     zstyle -T ":acceptline:${alcontext}" call_default \
 956         && zle ${default_action}
 957 }
 958
 959 function accept-line () {
 960     setopt localoptions noksharrays
 961     local -a cmdline
 962     local -x alcontext
 963     local buf com fname format msg default_action
 964
 965     alcontext='default'
 966     buf="${BUFFER}"
 967     cmdline=(${(z)BUFFER})
 968     com="${cmdline[1]}"
 969     fname="_${com}"
 970
 971     Accept-Line 'preprocess'
 972
 973     zstyle -t ":acceptline:${alcontext}" rehash \
 974         && [[ -z ${commands[$com]} ]]           \
 975         && rehash
 976
 977     if    [[ -n ${com}               ]] \
 978        && [[ -n ${reswords[(r)$com]} ]] \
 979        || [[ -n ${aliases[$com]}     ]] \
 980        || [[ -n ${functions[$com]}   ]] \
 981        || [[ -n ${builtins[$com]}    ]] \
 982        || [[ -n ${commands[$com]}    ]] ; then
 983
 984         # there is something sensible to execute, just do it.
 985         alcontext='normal'
 986         Accept-Line-HandleContext
 987
 988         return
 989     fi
 990
 991     if    [[ -o correct              ]] \
 992        || [[ -o correctall           ]] \
 993        && [[ -n ${functions[$fname]} ]] ; then
 994
 995         # nothing there to execute but there is a function called
 996         # _command_name; a completion widget. Makes no sense to
 997         # call it on the commandline, but the correct{,all} options
 998         # will ask for it nevertheless, so warn the user.
 999         if [[ ${LASTWIDGET} == 'accept-line' ]] ; then
1000             # Okay, we warned the user before, he called us again,
1001             # so have it his way.
1002             alcontext='force'
1003             Accept-Line-HandleContext
1004
1005             return
1006         fi
1007
1008         if zstyle -t ":acceptline:${alcontext}" nocompwarn ; then
1009             alcontext='normal'
1010             Accept-Line-HandleContext
1011         else
1012             # prepare warning message for the user, configurable via zstyle.
1013             zstyle -s ":acceptline:${alcontext}" compwarnfmt msg
1014
1015             if [[ -z ${msg} ]] ; then
1016                 msg="%c will not execute and completion %f exists."
1017             fi
1018
1019             zformat -f msg "${msg}" "c:${com}" "f:${fname}"
1020
1021             zle -M -- "${msg}"
1022         fi
1023         return
1024     elif [[ -n ${buf//[$' \t\n']##/} ]] ; then
1025         # If we are here, the commandline contains something that is not
1026         # executable, which is neither subject to _command_name correction
1027         # and is not empty. might be a variable assignment
1028         alcontext='misc'
1029         Accept-Line-HandleContext
1030
1031         return
1032     fi
1033
1034     # If we got this far, the commandline only contains whitespace, or is empty.
1035     alcontext='empty'
1036     Accept-Line-HandleContext
1037 }
1038
1039 zle -N accept-line
1040 zle -N Accept-Line
1041 zle -N Accept-Line-HandleContext
1042
1043 # power completion / abbreviation expansion / buffer expansion
1044 # see http://zshwiki.org/home/examples/zleiab for details
1045 # less risky than the global aliases but powerful as well
1046 # just type the abbreviation key and afterwards 'ctrl-x .' to expand it
1047 declare -A abk
1048 setopt extendedglob
1049 setopt interactivecomments
1050 abk=(
1051 #   key   # value                  (#d additional doc string)
1052 #A# start
1053     '...'  '../..'
1054     '....' '../../..'
1055     'BG'   '& exit'
1056     'C'    '| wc -l'
1057     'G'    '|& grep '${grep_options:+"${grep_options[*]}"}
1058     'H'    '| head'
1059     'Hl'   ' --help |& less -r'    #d (Display help in pager)
1060     'L'    '| less'
1061     'LL'   '|& less -r'
1062     'M'    '| most'
1063     'N'    '&>/dev/null'           #d (No Output)
1064     'R'    '| tr A-z N-za-m'       #d (ROT13)
1065     'SL'   '| sort | less'
1066     'S'    '| sort -u'
1067     'T'    '| tail'
1068     'V'    '|& vim -'
1069 #A# end
1070     'co'   './configure && make && sudo make install'
1071 )
1072
1073 function zleiab () {
1074     emulate -L zsh
1075     setopt extendedglob
1076     local MATCH
1077
1078     LBUFFER=${LBUFFER%%(#m)[.\-+:|_a-zA-Z0-9]#}
1079     LBUFFER+=${abk[$MATCH]:-$MATCH}
1080 }
1081
1082 zle -N zleiab
1083
1084 function help-show-abk () {
1085   zle -M "$(print "Available abbreviations for expansion:"; print -a -C 2 ${(kv)abk})"
1086 }
1087
1088 zle -N help-show-abk
1089
1090 # press "ctrl-e d" to insert the actual date in the form yyyy-mm-dd
1091 function insert-datestamp () { LBUFFER+=${(%):-'%D{%Y-%m-%d}'}; }
1092 zle -N insert-datestamp
1093
1094 # press esc-m for inserting last typed word again (thanks to caphuso!)
1095 function insert-last-typed-word () { zle insert-last-word -- 0 -1 };
1096 zle -N insert-last-typed-word;
1097
1098 function grml-zsh-fg () {
1099   if (( ${#jobstates} )); then
1100     zle .push-input
1101     [[ -o hist_ignore_space ]] && BUFFER=' ' || BUFFER=''
1102     BUFFER="${BUFFER}fg"
1103     zle .accept-line
1104   else
1105     zle -M 'No background jobs. Doing nothing.'
1106   fi
1107 }
1108 zle -N grml-zsh-fg
1109
1110 # run command line as user root via sudo:
1111 function sudo-command-line () {
1112     [[ -z $BUFFER ]] && zle up-history
1113     if [[ $BUFFER != sudo\ * ]]; then
1114         BUFFER="sudo $BUFFER"
1115         CURSOR=$(( CURSOR+5 ))
1116     fi
1117 }
1118 zle -N sudo-command-line
1119
1120 ### jump behind the first word on the cmdline.
1121 ### useful to add options.
1122 function jump_after_first_word () {
1123     local words
1124     words=(${(z)BUFFER})
1125
1126     if (( ${#words} <= 1 )) ; then
1127         CURSOR=${#BUFFER}
1128     else
1129         CURSOR=${#${words[1]}}
1130     fi
1131 }
1132 zle -N jump_after_first_word
1133
1134 #f5# Create directory under cursor or the selected area
1135 function inplaceMkDirs () {
1136     # Press ctrl-xM to create the directory under the cursor or the selected area.
1137     # To select an area press ctrl-@ or ctrl-space and use the cursor.
1138     # Use case: you type "mv abc ~/testa/testb/testc/" and remember that the
1139     # directory does not exist yet -> press ctrl-XM and problem solved
1140     local PATHTOMKDIR
1141     if ((REGION_ACTIVE==1)); then
1142         local F=$MARK T=$CURSOR
1143         if [[ $F -gt $T ]]; then
1144             F=${CURSOR}
1145             T=${MARK}
1146         fi
1147         # get marked area from buffer and eliminate whitespace
1148         PATHTOMKDIR=${BUFFER[F+1,T]%%[[:space:]]##}
1149         PATHTOMKDIR=${PATHTOMKDIR##[[:space:]]##}
1150     else
1151         local bufwords iword
1152         bufwords=(${(z)LBUFFER})
1153         iword=${#bufwords}
1154         bufwords=(${(z)BUFFER})
1155         PATHTOMKDIR="${(Q)bufwords[iword]}"
1156     fi
1157     [[ -z "${PATHTOMKDIR}" ]] && return 1
1158     PATHTOMKDIR=${~PATHTOMKDIR}
1159     if [[ -e "${PATHTOMKDIR}" ]]; then
1160         zle -M " path already exists, doing nothing"
1161     else
1162         zle -M "$(mkdir -p -v "${PATHTOMKDIR}")"
1163         zle end-of-line
1164     fi
1165 }
1166
1167 zle -N inplaceMkDirs
1168
1169 #v1# set number of lines to display per page
1170 HELP_LINES_PER_PAGE=20
1171 #v1# set location of help-zle cache file
1172 HELP_ZLE_CACHE_FILE=~/.cache/zsh_help_zle_lines.zsh
1173 # helper function for help-zle, actually generates the help text
1174 function help_zle_parse_keybindings () {
1175     emulate -L zsh
1176     setopt extendedglob
1177     unsetopt ksharrays  #indexing starts at 1
1178
1179     #v1# choose files that help-zle will parse for keybindings
1180     ((${+HELPZLE_KEYBINDING_FILES})) || HELPZLE_KEYBINDING_FILES=( /etc/zsh/zshrc ~/.zshrc.pre ~/.zshrc ~/.zshrc.local )
1181
1182     if [[ -r $HELP_ZLE_CACHE_FILE ]]; then
1183         local load_cache=0
1184         local f
1185         for f ($HELPZLE_KEYBINDING_FILES) [[ $f -nt $HELP_ZLE_CACHE_FILE ]] && load_cache=1
1186         [[ $load_cache -eq 0 ]] && . $HELP_ZLE_CACHE_FILE && return
1187     fi
1188
1189     #fill with default keybindings, possibly to be overwriten in a file later
1190     #Note that due to zsh inconsistency on escaping assoc array keys, we encase the key in '' which we will remove later
1191     local -A help_zle_keybindings
1192     help_zle_keybindings['<Ctrl>@']="set MARK"
1193     help_zle_keybindings['<Ctrl>x<Ctrl>j']="vi-join lines"
1194     help_zle_keybindings['<Ctrl>x<Ctrl>b']="jump to matching brace"
1195     help_zle_keybindings['<Ctrl>x<Ctrl>u']="undo"
1196     help_zle_keybindings['<Ctrl>_']="undo"
1197     help_zle_keybindings['<Ctrl>x<Ctrl>f<c>']="find <c> in cmdline"
1198     help_zle_keybindings['<Ctrl>a']="goto beginning of line"
1199     help_zle_keybindings['<Ctrl>e']="goto end of line"
1200     help_zle_keybindings['<Ctrl>t']="transpose charaters"
1201     help_zle_keybindings['<Alt>t']="transpose words"
1202     help_zle_keybindings['<Alt>s']="spellcheck word"
1203     help_zle_keybindings['<Ctrl>k']="backward kill buffer"
1204     help_zle_keybindings['<Ctrl>u']="forward kill buffer"
1205     help_zle_keybindings['<Ctrl>y']="insert previously killed word/string"
1206     help_zle_keybindings["<Alt>'"]="quote line"
1207     help_zle_keybindings['<Alt>"']="quote from mark to cursor"
1208     help_zle_keybindings['<Alt><arg>']="repeat next cmd/char <arg> times (<Alt>-<Alt>1<Alt>0a -> -10 times 'a')"
1209     help_zle_keybindings['<Alt>u']="make next word Uppercase"
1210     help_zle_keybindings['<Alt>l']="make next word lowercase"
1211     help_zle_keybindings['<Ctrl>xd']="preview expansion under cursor"
1212     help_zle_keybindings['<Alt>q']="push current CL into background, freeing it. Restore on next CL"
1213     help_zle_keybindings['<Alt>.']="insert (and interate through) last word from prev CLs"
1214     help_zle_keybindings['<Alt>,']="complete word from newer history (consecutive hits)"
1215     help_zle_keybindings['<Alt>m']="repeat last typed word on current CL"
1216     help_zle_keybindings['<Ctrl>v']="insert next keypress symbol literally (e.g. for bindkey)"
1217     help_zle_keybindings['!!:n*<Tab>']="insert last n arguments of last command"
1218     help_zle_keybindings['!!:n-<Tab>']="insert arguments n..N-2 of last command (e.g. mv s s d)"
1219     help_zle_keybindings['<Alt>h']="show help/manpage for current command"
1220
1221     #init global variables
1222     unset help_zle_lines help_zle_sln
1223     typeset -g -a help_zle_lines
1224     typeset -g help_zle_sln=1
1225
1226     local k v f cline
1227     local lastkeybind_desc contents     #last description starting with #k# that we found
1228     local num_lines_elapsed=0            #number of lines between last description and keybinding
1229     #search config files in the order they a called (and thus the order in which they overwrite keybindings)
1230     for f in $HELPZLE_KEYBINDING_FILES; do
1231         [[ -r "$f" ]] || continue   #not readable ? skip it
1232         contents="$(<$f)"
1233         for cline in "${(f)contents}"; do
1234             #zsh pattern: matches lines like: #k# ..............
1235             if [[ "$cline" == (#s)[[:space:]]#\#k\#[[:space:]]##(#b)(*)[[:space:]]#(#e) ]]; then
1236                 lastkeybind_desc="$match[*]"
1237                 num_lines_elapsed=0
1238             #zsh pattern: matches lines that set a keybinding using bind2map, bindkey or compdef -k
1239             #             ignores lines that are commentend out
1240             #             grabs first in '' or "" enclosed string with length between 1 and 6 characters
1241             elif [[ "$cline" == [^#]#(bind2maps[[:space:]](*)-s|bindkey|compdef -k)[[:space:]](*)(#b)(\"((?)(#c1,6))\"|\'((?)(#c1,6))\')(#B)(*)  ]]; then
1242                 #description prevously found ? description not more than 2 lines away ? keybinding not empty ?
1243                 if [[ -n $lastkeybind_desc && $num_lines_elapsed -lt 2 && -n $match[1] ]]; then
1244                     #substitute keybinding string with something readable
1245                     k=${${${${${${${match[1]/\\e\^h/<Alt><BS>}/\\e\^\?/<Alt><BS>}/\\e\[5~/<PageUp>}/\\e\[6~/<PageDown>}//(\\e|\^\[)/<Alt>}//\^/<Ctrl>}/3~/<Alt><Del>}
1246                     #put keybinding in assoc array, possibly overwriting defaults or stuff found in earlier files
1247                     #Note that we are extracting the keybinding-string including the quotes (see Note at beginning)
1248                     help_zle_keybindings[${k}]=$lastkeybind_desc
1249                 fi
1250                 lastkeybind_desc=""
1251             else
1252               ((num_lines_elapsed++))
1253             fi
1254         done
1255     done
1256     unset contents
1257     #calculate length of keybinding column
1258     local kstrlen=0
1259     for k (${(k)help_zle_keybindings[@]}) ((kstrlen < ${#k})) && kstrlen=${#k}
1260     #convert the assoc array into preformated lines, which we are able to sort
1261     for k v in ${(kv)help_zle_keybindings[@]}; do
1262         #pad keybinding-string to kstrlen chars and remove outermost characters (i.e. the quotes)
1263         help_zle_lines+=("${(r:kstrlen:)k[2,-2]}${v}")
1264     done
1265     #sort lines alphabetically
1266     help_zle_lines=("${(i)help_zle_lines[@]}")
1267     [[ -d ${HELP_ZLE_CACHE_FILE:h} ]] || mkdir -p "${HELP_ZLE_CACHE_FILE:h}"
1268     echo "help_zle_lines=(${(q)help_zle_lines[@]})" >| $HELP_ZLE_CACHE_FILE
1269     zcompile $HELP_ZLE_CACHE_FILE
1270 }
1271 typeset -g help_zle_sln
1272 typeset -g -a help_zle_lines
1273
1274 # Provides (partially autogenerated) help on keybindings and the zsh line editor
1275 function help-zle () {
1276     emulate -L zsh
1277     unsetopt ksharrays  #indexing starts at 1
1278     #help lines already generated ? no ? then do it
1279     [[ ${+functions[help_zle_parse_keybindings]} -eq 1 ]] && {help_zle_parse_keybindings && unfunction help_zle_parse_keybindings}
1280     #already displayed all lines ? go back to the start
1281     [[ $help_zle_sln -gt ${#help_zle_lines} ]] && help_zle_sln=1
1282     local sln=$help_zle_sln
1283     #note that help_zle_sln is a global var, meaning we remember the last page we viewed
1284     help_zle_sln=$((help_zle_sln + HELP_LINES_PER_PAGE))
1285     zle -M "${(F)help_zle_lines[sln,help_zle_sln-1]}"
1286 }
1287 zle -N help-zle
1288
1289 ## complete word from currently visible Screen or Tmux buffer.
1290 if check_com -c screen || check_com -c tmux; then
1291     function _complete_screen_display () {
1292         [[ "$TERM" != "screen" ]] && return 1
1293
1294         local TMPFILE=$(mktemp)
1295         local -U -a _screen_display_wordlist
1296         trap "rm -f $TMPFILE" EXIT
1297
1298         # fill array with contents from screen hardcopy
1299         if ((${+TMUX})); then
1300             #works, but crashes tmux below version 1.4
1301             #luckily tmux -V option to ask for version, was also added in 1.4
1302             tmux -V &>/dev/null || return
1303             tmux -q capture-pane \; save-buffer -b 0 $TMPFILE \; delete-buffer -b 0
1304         else
1305             screen -X hardcopy $TMPFILE
1306             # screen sucks, it dumps in latin1, apparently always. so recode it
1307             # to system charset
1308             check_com recode && recode latin1 $TMPFILE
1309         fi
1310         _screen_display_wordlist=( ${(QQ)$(<$TMPFILE)} )
1311         # remove PREFIX to be completed from that array
1312         _screen_display_wordlist[${_screen_display_wordlist[(i)$PREFIX]}]=""
1313         compadd -a _screen_display_wordlist
1314     }
1315     #m# k CTRL-x\,\,\,S Complete word from GNU screen buffer
1316     bindkey -r "^xS"
1317     compdef -k _complete_screen_display complete-word '^xS'
1318 fi
1319
1320 # Load a few more functions and tie them to widgets, so they can be bound:
1321
1322 function zrcautozle () {
1323     emulate -L zsh
1324     local fnc=$1
1325     zrcautoload $fnc && zle -N $fnc
1326 }
1327
1328 function zrcgotwidget () {
1329     (( ${+widgets[$1]} ))
1330 }
1331
1332 function zrcgotkeymap () {
1333     [[ -n ${(M)keymaps:#$1} ]]
1334 }
1335
1336 zrcautozle insert-files
1337 zrcautozle edit-command-line
1338 zrcautozle insert-unicode-char
1339 if zrcautoload history-search-end; then
1340     zle -N history-beginning-search-backward-end history-search-end
1341     zle -N history-beginning-search-forward-end  history-search-end
1342 fi
1343 zle -C hist-complete complete-word _generic
1344 zstyle ':completion:hist-complete:*' completer _history
1345
1346 # The actual terminal setup hooks and bindkey-calls:
1347
1348 # An array to note missing features to ease diagnosis in case of problems.
1349 typeset -ga grml_missing_features
1350
1351 function zrcbindkey () {
1352     if (( ARGC )) && zrcgotwidget ${argv[-1]}; then
1353         bindkey "$@"
1354     fi
1355 }
1356
1357 function bind2maps () {
1358     local i sequence widget
1359     local -a maps
1360
1361     while [[ "$1" != "--" ]]; do
1362         maps+=( "$1" )
1363         shift
1364     done
1365     shift
1366
1367     if [[ "$1" == "-s" ]]; then
1368         shift
1369         sequence="$1"
1370     else
1371         sequence="${key[$1]}"
1372     fi
1373     widget="$2"
1374
1375     [[ -z "$sequence" ]] && return 1
1376
1377     for i in "${maps[@]}"; do
1378         zrcbindkey -M "$i" "$sequence" "$widget"
1379     done
1380 }
1381
1382 if (( ${+terminfo[smkx]} )) && (( ${+terminfo[rmkx]} )); then
1383     function zle-smkx () {
1384         emulate -L zsh
1385         printf '%s' ${terminfo[smkx]}
1386     }
1387     function zle-rmkx () {
1388         emulate -L zsh
1389         printf '%s' ${terminfo[rmkx]}
1390     }
1391     function zle-line-init () {
1392         zle-smkx
1393     }
1394     function zle-line-finish () {
1395         zle-rmkx
1396     }
1397     zle -N zle-line-init
1398     zle -N zle-line-finish
1399 else
1400     for i in {s,r}mkx; do
1401         (( ${+terminfo[$i]} )) || grml_missing_features+=($i)
1402     done
1403     unset i
1404 fi
1405
1406 typeset -A key
1407 key=(
1408     Home     "${terminfo[khome]}"
1409     End      "${terminfo[kend]}"
1410     Insert   "${terminfo[kich1]}"
1411     Delete   "${terminfo[kdch1]}"
1412     Up       "${terminfo[kcuu1]}"
1413     Down     "${terminfo[kcud1]}"
1414     Left     "${terminfo[kcub1]}"
1415     Right    "${terminfo[kcuf1]}"
1416     PageUp   "${terminfo[kpp]}"
1417     PageDown "${terminfo[knp]}"
1418     BackTab  "${terminfo[kcbt]}"
1419 )
1420
1421 # Guidelines for adding key bindings:
1422 #
1423 #   - Do not add hardcoded escape sequences, to enable non standard key
1424 #     combinations such as Ctrl-Meta-Left-Cursor. They are not easily portable.
1425 #
1426 #   - Adding Ctrl characters, such as '^b' is okay; note that '^b' and '^B' are
1427 #     the same key.
1428 #
1429 #   - All keys from the $key[] mapping are obviously okay.
1430 #
1431 #   - Most terminals send "ESC x" when Meta-x is pressed. Thus, sequences like
1432 #     '\ex' are allowed in here as well.
1433
1434 bind2maps emacs             -- Home   beginning-of-somewhere
1435 bind2maps       viins vicmd -- Home   vi-beginning-of-line
1436 bind2maps emacs             -- End    end-of-somewhere
1437 bind2maps       viins vicmd -- End    vi-end-of-line
1438 bind2maps emacs viins       -- Insert overwrite-mode
1439 bind2maps             vicmd -- Insert vi-insert
1440 bind2maps emacs             -- Delete delete-char
1441 bind2maps       viins vicmd -- Delete vi-delete-char
1442 bind2maps emacs viins vicmd -- Up     up-line-or-search
1443 bind2maps emacs viins vicmd -- Down   down-line-or-search
1444 bind2maps emacs             -- Left   backward-char
1445 bind2maps       viins vicmd -- Left   vi-backward-char
1446 bind2maps emacs             -- Right  forward-char
1447 bind2maps       viins vicmd -- Right  vi-forward-char
1448 #k# Perform abbreviation expansion
1449 bind2maps emacs viins       -- -s '^x.' zleiab
1450 #k# Display list of abbreviations that would expand
1451 bind2maps emacs viins       -- -s '^xb' help-show-abk
1452 #k# mkdir -p <dir> from string under cursor or marked area
1453 bind2maps emacs viins       -- -s '^xM' inplaceMkDirs
1454 #k# display help for keybindings and ZLE
1455 bind2maps emacs viins       -- -s '^xz' help-zle
1456 #k# Insert files and test globbing
1457 bind2maps emacs viins       -- -s "^xf" insert-files
1458 #k# Edit the current line in \kbd{\$EDITOR}
1459 bind2maps emacs viins       -- -s '\ee' edit-command-line
1460 #k# search history backward for entry beginning with typed text
1461 bind2maps emacs viins       -- -s '^xp' history-beginning-search-backward-end
1462 #k# search history forward for entry beginning with typed text
1463 bind2maps emacs viins       -- -s '^xP' history-beginning-search-forward-end
1464 #k# search history backward for entry beginning with typed text
1465 bind2maps emacs viins       -- PageUp history-beginning-search-backward-end
1466 #k# search history forward for entry beginning with typed text
1467 bind2maps emacs viins       -- PageDown history-beginning-search-forward-end
1468 bind2maps emacs viins       -- -s "^x^h" commit-to-history
1469 #k# Kill left-side word or everything up to next slash
1470 bind2maps emacs viins       -- -s '\ev' slash-backward-kill-word
1471 #k# Kill left-side word or everything up to next slash
1472 bind2maps emacs viins       -- -s '\e^h' slash-backward-kill-word
1473 #k# Kill left-side word or everything up to next slash
1474 bind2maps emacs viins       -- -s '\e^?' slash-backward-kill-word
1475 # Do history expansion on space:
1476 bind2maps emacs viins       -- -s ' ' magic-space
1477 #k# Trigger menu-complete
1478 bind2maps emacs viins       -- -s '\ei' menu-complete  # menu completion via esc-i
1479 #k# Insert a timestamp on the command line (yyyy-mm-dd)
1480 bind2maps emacs viins       -- -s '^ed' insert-datestamp
1481 #k# Insert last typed word
1482 bind2maps emacs viins       -- -s "\em" insert-last-typed-word
1483 #k# A smart shortcut for \kbd{fg<enter>}
1484 bind2maps emacs viins       -- -s '^z' grml-zsh-fg
1485 #k# prepend the current command with "sudo"
1486 bind2maps emacs viins       -- -s "^os" sudo-command-line
1487 #k# jump to after first word (for adding options)
1488 bind2maps emacs viins       -- -s '^x1' jump_after_first_word
1489 #k# complete word from history with menu
1490 bind2maps emacs viins       -- -s "^x^x" hist-complete
1491
1492 # insert unicode character
1493 # usage example: 'ctrl-x i' 00A7 'ctrl-x i' will give you an §
1494 # See for example http://unicode.org/charts/ for unicode characters code
1495 #k# Insert Unicode character
1496 bind2maps emacs viins       -- -s '^xi' insert-unicode-char
1497
1498 # use the new *-pattern-* widgets for incremental history search
1499 if zrcgotwidget history-incremental-pattern-search-backward; then
1500     for seq wid in '^r' history-incremental-pattern-search-backward \
1501                    '^s' history-incremental-pattern-search-forward
1502     do
1503         bind2maps emacs viins vicmd -- -s $seq $wid
1504     done
1505     builtin unset -v seq wid
1506 fi
1507
1508 if zrcgotkeymap menuselect; then
1509     #m# k Shift-tab Perform backwards menu completion
1510     bind2maps menuselect -- BackTab reverse-menu-complete
1511
1512     #k# menu selection: pick item but stay in the menu
1513     bind2maps menuselect -- -s '\e^M' accept-and-menu-complete
1514     # also use + and INSERT since it's easier to press repeatedly
1515     bind2maps menuselect -- -s '+' accept-and-menu-complete
1516     bind2maps menuselect -- Insert accept-and-menu-complete
1517
1518     # accept a completion and try to complete again by using menu
1519     # completion; very useful with completing directories
1520     # by using 'undo' one's got a simple file browser
1521     bind2maps menuselect -- -s '^o' accept-and-infer-next-history
1522 fi
1523
1524 # Finally, here are still a few hardcoded escape sequences; Special sequences
1525 # like Ctrl-<Cursor-key> etc do suck a fair bit, because they are not
1526 # standardised and most of the time are not available in a terminals terminfo
1527 # entry.
1528 #
1529 # While we do not encourage adding bindings like these, we will keep these for
1530 # backward compatibility.
1531
1532 ## use Ctrl-left-arrow and Ctrl-right-arrow for jumping to word-beginnings on
1533 ## the command line.
1534 # URxvt sequences:
1535 bind2maps emacs viins vicmd -- -s '\eOc' forward-word
1536 bind2maps emacs viins vicmd -- -s '\eOd' backward-word
1537 # These are for xterm:
1538 bind2maps emacs viins vicmd -- -s '\e[1;5C' forward-word
1539 bind2maps emacs viins vicmd -- -s '\e[1;5D' backward-word
1540 ## the same for alt-left-arrow and alt-right-arrow
1541 # URxvt again:
1542 bind2maps emacs viins vicmd -- -s '\e\e[C' forward-word
1543 bind2maps emacs viins vicmd -- -s '\e\e[D' backward-word
1544 # Xterm again:
1545 bind2maps emacs viins vicmd -- -s '^[[1;3C' forward-word
1546 bind2maps emacs viins vicmd -- -s '^[[1;3D' backward-word
1547 # Also try ESC Left/Right:
1548 bind2maps emacs viins vicmd -- -s '\e'${key[Right]} forward-word
1549 bind2maps emacs viins vicmd -- -s '\e'${key[Left]}  backward-word
1550
1551 # autoloading
1552
1553 zrcautoload zmv
1554 zrcautoload zed
1555
1556 # we don't want to quote/espace URLs on our own...
1557 # if autoload -U url-quote-magic ; then
1558 #    zle -N self-insert url-quote-magic
1559 #    zstyle ':url-quote-magic:*' url-metas '*?[]^()~#{}='
1560 # else
1561 #    print 'Notice: no url-quote-magic available :('
1562 # fi
1563 alias url-quote='autoload -U url-quote-magic ; zle -N self-insert url-quote-magic'
1564
1565 #m# k ESC-h Call \kbd{run-help} for the 1st word on the command line
1566 alias run-help >&/dev/null && unalias run-help
1567 for rh in run-help{,-git,-ip,-openssl,-p4,-sudo,-svk,-svn}; do
1568     zrcautoload $rh
1569 done; unset rh
1570
1571 # command not found handling
1572
1573 (( ${COMMAND_NOT_FOUND} == 1 )) &&
1574 function command_not_found_handler () {
1575     emulate -L zsh
1576     if [[ -x ${GRML_ZSH_CNF_HANDLER} ]] ; then
1577         ${GRML_ZSH_CNF_HANDLER} $1
1578     fi
1579     return 1
1580 }
1581
1582 # history
1583
1584 #v#
1585 HISTFILE=${ZDOTDIR:-${HOME}}/.zsh_history
1586 isgrmlcd && HISTSIZE=500  || HISTSIZE=5000
1587 isgrmlcd && SAVEHIST=1000 || SAVEHIST=10000 # useful for setopt append_history
1588
1589 # dirstack handling
1590
1591 DIRSTACKSIZE=${DIRSTACKSIZE:-20}
1592 DIRSTACKFILE=${DIRSTACKFILE:-${ZDOTDIR:-${HOME}}/.zdirs}
1593
1594 if zstyle -T ':grml:chpwd:dirstack' enable; then
1595     typeset -gaU GRML_PERSISTENT_DIRSTACK
1596     function grml_dirstack_filter () {
1597         local -a exclude
1598         local filter entry
1599         if zstyle -s ':grml:chpwd:dirstack' filter filter; then
1600             $filter $1 && return 0
1601         fi
1602         if zstyle -a ':grml:chpwd:dirstack' exclude exclude; then
1603             for entry in "${exclude[@]}"; do
1604                 [[ $1 == ${~entry} ]] && return 0
1605             done
1606         fi
1607         return 1
1608     }
1609
1610     function chpwd () {
1611         (( ZSH_SUBSHELL )) && return
1612         (( $DIRSTACKSIZE <= 0 )) && return
1613         [[ -z $DIRSTACKFILE ]] && return
1614         grml_dirstack_filter $PWD && return
1615         GRML_PERSISTENT_DIRSTACK=(
1616             $PWD "${(@)GRML_PERSISTENT_DIRSTACK[1,$DIRSTACKSIZE]}"
1617         )
1618         builtin print -l ${GRML_PERSISTENT_DIRSTACK} >! ${DIRSTACKFILE}
1619     }
1620
1621     if [[ -f ${DIRSTACKFILE} ]]; then
1622         # Enabling NULL_GLOB via (N) weeds out any non-existing
1623         # directories from the saved dir-stack file.
1624         dirstack=( ${(f)"$(< $DIRSTACKFILE)"}(N) )
1625         # "cd -" won't work after login by just setting $OLDPWD, so
1626         [[ -d $dirstack[1] ]] && cd -q $dirstack[1] && cd -q $OLDPWD
1627     fi
1628
1629     if zstyle -t ':grml:chpwd:dirstack' filter-on-load; then
1630         for i in "${dirstack[@]}"; do
1631             if ! grml_dirstack_filter "$i"; then
1632                 GRML_PERSISTENT_DIRSTACK=(
1633                     "${GRML_PERSISTENT_DIRSTACK[@]}"
1634                     $i
1635                 )
1636             fi
1637         done
1638     else
1639         GRML_PERSISTENT_DIRSTACK=( "${dirstack[@]}" )
1640     fi
1641 fi
1642
1643 # directory based profiles
1644
1645 if is433 ; then
1646
1647 # chpwd_profiles(): Directory Profiles, Quickstart:
1648 #
1649 # In .zshrc.local:
1650 #
1651 #   zstyle ':chpwd:profiles:/usr/src/grml(|/|/*)'   profile grml
1652 #   zstyle ':chpwd:profiles:/usr/src/debian(|/|/*)' profile debian
1653 #   chpwd_profiles
1654 #
1655 # For details see the `grmlzshrc.5' manual page.
1656 function chpwd_profiles () {
1657     local profile context
1658     local -i reexecute
1659
1660     context=":chpwd:profiles:$PWD"
1661     zstyle -s "$context" profile profile || profile='default'
1662     zstyle -T "$context" re-execute && reexecute=1 || reexecute=0
1663
1664     if (( ${+parameters[CHPWD_PROFILE]} == 0 )); then
1665         typeset -g CHPWD_PROFILE
1666         local CHPWD_PROFILES_INIT=1
1667         (( ${+functions[chpwd_profiles_init]} )) && chpwd_profiles_init
1668     elif [[ $profile != $CHPWD_PROFILE ]]; then
1669         (( ${+functions[chpwd_leave_profile_$CHPWD_PROFILE]} )) \
1670             && chpwd_leave_profile_${CHPWD_PROFILE}
1671     fi
1672     if (( reexecute )) || [[ $profile != $CHPWD_PROFILE ]]; then
1673         (( ${+functions[chpwd_profile_$profile]} )) && chpwd_profile_${profile}
1674     fi
1675
1676     CHPWD_PROFILE="${profile}"
1677     return 0
1678 }
1679
1680 chpwd_functions=( ${chpwd_functions} chpwd_profiles )
1681
1682 fi # is433
1683
1684 # Prompt setup for grml:
1685
1686 # set colors for use in prompts (modern zshs allow for the use of %F{red}foo%f
1687 # in prompts to get a red "foo" embedded, but it's good to keep these for
1688 # backwards compatibility).
1689 if is437; then
1690     BLUE="%F{blue}"
1691     RED="%F{red}"
1692     GREEN="%F{green}"
1693     CYAN="%F{cyan}"
1694     MAGENTA="%F{magenta}"
1695     YELLOW="%F{yellow}"
1696     WHITE="%F{white}"
1697     NO_COLOR="%f"
1698 elif zrcautoload colors && colors 2>/dev/null ; then
1699     BLUE="%{${fg[blue]}%}"
1700     RED="%{${fg_bold[red]}%}"
1701     GREEN="%{${fg[green]}%}"
1702     CYAN="%{${fg[cyan]}%}"
1703     MAGENTA="%{${fg[magenta]}%}"
1704     YELLOW="%{${fg[yellow]}%}"
1705     WHITE="%{${fg[white]}%}"
1706     NO_COLOR="%{${reset_color}%}"
1707 else
1708     BLUE=$'%{\e[1;34m%}'
1709     RED=$'%{\e[1;31m%}'
1710     GREEN=$'%{\e[1;32m%}'
1711     CYAN=$'%{\e[1;36m%}'
1712     WHITE=$'%{\e[1;37m%}'
1713     MAGENTA=$'%{\e[1;35m%}'
1714     YELLOW=$'%{\e[1;33m%}'
1715     NO_COLOR=$'%{\e[0m%}'
1716 fi
1717
1718 # First, the easy ones: PS2..4:
1719
1720 # secondary prompt, printed when the shell needs more information to complete a
1721 # command.
1722 PS2='\`%_> '
1723 # selection prompt used within a select loop.
1724 PS3='?# '
1725 # the execution trace prompt (setopt xtrace). default: '+%N:%i>'
1726 PS4='+%N:%i:%_> '
1727
1728 # Some additional features to use with our prompt:
1729 #
1730 #    - battery status
1731 #    - debian_chroot
1732 #    - vcs_info setup and version specific fixes
1733
1734 # display battery status on right side of prompt using 'GRML_DISPLAY_BATTERY=1' in .zshrc.pre
1735
1736 function battery () {
1737 if [[ $GRML_DISPLAY_BATTERY -gt 0 ]] ; then
1738     if islinux ; then
1739         batterylinux
1740     elif isopenbsd ; then
1741         batteryopenbsd
1742     elif isfreebsd ; then
1743         batteryfreebsd
1744     elif isdarwin ; then
1745         batterydarwin
1746     else
1747         #not yet supported
1748         GRML_DISPLAY_BATTERY=0
1749     fi
1750 fi
1751 }
1752
1753 function batterylinux () {
1754 GRML_BATTERY_LEVEL=''
1755 local batteries bat capacity
1756 batteries=( /sys/class/power_supply/BAT*(N) )
1757 if (( $#batteries > 0 )) ; then
1758     for bat in $batteries ; do
1759         if [[ -e $bat/capacity ]]; then
1760             capacity=$(< $bat/capacity)
1761         else
1762             typeset -F energy_full=$(< $bat/energy_full)
1763             typeset -F energy_now=$(< $bat/energy_now)
1764             typeset -i capacity=$(( 100 * $energy_now / $energy_full))
1765         fi
1766         case $(< $bat/status) in
1767         Charging)
1768             GRML_BATTERY_LEVEL+=" ^"
1769             ;;
1770         Discharging)
1771             if (( capacity < 20 )) ; then
1772                 GRML_BATTERY_LEVEL+=" !v"
1773             else
1774                 GRML_BATTERY_LEVEL+=" v"
1775             fi
1776             ;;
1777         *) # Full, Unknown
1778             GRML_BATTERY_LEVEL+=" ="
1779             ;;
1780         esac
1781         GRML_BATTERY_LEVEL+="${capacity}%%"
1782     done
1783 fi
1784 }
1785
1786 function batteryopenbsd () {
1787 GRML_BATTERY_LEVEL=''
1788 local bat batfull batwarn batnow num
1789 for num in 0 1 ; do
1790     bat=$(sysctl -n hw.sensors.acpibat${num} 2>/dev/null)
1791     if [[ -n $bat ]]; then
1792         batfull=${"$(sysctl -n hw.sensors.acpibat${num}.amphour0)"%% *}
1793         batwarn=${"$(sysctl -n hw.sensors.acpibat${num}.amphour1)"%% *}
1794         batnow=${"$(sysctl -n hw.sensors.acpibat${num}.amphour3)"%% *}
1795         case "$(sysctl -n hw.sensors.acpibat${num}.raw0)" in
1796             *" discharging"*)
1797                 if (( batnow < batwarn )) ; then
1798                     GRML_BATTERY_LEVEL+=" !v"
1799                 else
1800                     GRML_BATTERY_LEVEL+=" v"
1801                 fi
1802                 ;;
1803             *" charging"*)
1804                 GRML_BATTERY_LEVEL+=" ^"
1805                 ;;
1806             *)
1807                 GRML_BATTERY_LEVEL+=" ="
1808                 ;;
1809         esac
1810         GRML_BATTERY_LEVEL+="${$(( 100 * batnow / batfull ))%%.*}%%"
1811     fi
1812 done
1813 }
1814
1815 function batteryfreebsd () {
1816 GRML_BATTERY_LEVEL=''
1817 local num
1818 local -A table
1819 for num in 0 1 ; do
1820     table=( ${=${${${${${(M)${(f)"$(acpiconf -i $num 2>&1)"}:#(State|Remaining capacity):*}%%( ##|%)}//:[ $'\t']##/@}// /-}//@/ }} )
1821     if [[ -n $table ]] && [[ $table[State] != "not-present" ]] ; then
1822         case $table[State] in
1823             *discharging*)
1824                 if (( $table[Remaining-capacity] < 20 )) ; then
1825                     GRML_BATTERY_LEVEL+=" !v"
1826                 else
1827                     GRML_BATTERY_LEVEL+=" v"
1828                 fi
1829                 ;;
1830             *charging*)
1831                 GRML_BATTERY_LEVEL+=" ^"
1832                 ;;
1833             *)
1834                 GRML_BATTERY_LEVEL+=" ="
1835                 ;;
1836         esac
1837         GRML_BATTERY_LEVEL+="$table[Remaining-capacity]%%"
1838     fi
1839 done
1840 }
1841
1842 function batterydarwin () {
1843 GRML_BATTERY_LEVEL=''
1844 local -a table
1845 table=( ${$(pmset -g ps)[(w)7,8]%%(\%|);} )
1846 if [[ -n $table[2] ]] ; then
1847     case $table[2] in
1848         charging)
1849             GRML_BATTERY_LEVEL+=" ^"
1850             ;;
1851         discharging)
1852             if (( $table[1] < 20 )) ; then
1853                 GRML_BATTERY_LEVEL+=" !v"
1854             else
1855                 GRML_BATTERY_LEVEL+=" v"
1856             fi
1857             ;;
1858         *)
1859             GRML_BATTERY_LEVEL+=" ="
1860             ;;
1861     esac
1862     GRML_BATTERY_LEVEL+="$table[1]%%"
1863 fi
1864 }
1865
1866 # set variable debian_chroot if running in a chroot with /etc/debian_chroot
1867 if [[ -z "$debian_chroot" ]] && [[ -r /etc/debian_chroot ]] ; then
1868     debian_chroot=$(</etc/debian_chroot)
1869 fi
1870
1871 # gather version control information for inclusion in a prompt
1872
1873 if zrcautoload vcs_info; then
1874     # `vcs_info' in zsh versions 4.3.10 and below have a broken `_realpath'
1875     # function, which can cause a lot of trouble with our directory-based
1876     # profiles. So:
1877     if [[ ${ZSH_VERSION} == 4.3.<-10> ]] ; then
1878         function VCS_INFO_realpath () {
1879             setopt localoptions NO_shwordsplit chaselinks
1880             ( builtin cd -q $1 2> /dev/null && pwd; )
1881         }
1882     fi
1883
1884     zstyle ':vcs_info:*' max-exports 2
1885
1886     if [[ -o restricted ]]; then
1887         zstyle ':vcs_info:*' enable NONE
1888     fi
1889 fi
1890
1891 typeset -A grml_vcs_coloured_formats
1892 typeset -A grml_vcs_plain_formats
1893
1894 grml_vcs_plain_formats=(
1895     format "(%s%)-[%b] "    "zsh: %r"
1896     actionformat "(%s%)-[%b|%a] " "zsh: %r"
1897     rev-branchformat "%b:%r"
1898 )
1899
1900 grml_vcs_coloured_formats=(
1901     format "${MAGENTA}(${NO_COLOR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${MAGENTA}]${NO_COLOR} "
1902     actionformat "${MAGENTA}(${NO_COLOR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${YELLOW}|${RED}%a${MAGENTA}]${NO_COLOR} "
1903     rev-branchformat "%b${RED}:${YELLOW}%r"
1904 )
1905
1906 typeset GRML_VCS_COLOUR_MODE=xxx
1907
1908 function grml_vcs_info_toggle_colour () {
1909     emulate -L zsh
1910     if [[ $GRML_VCS_COLOUR_MODE == plain ]]; then
1911         grml_vcs_info_set_formats coloured
1912     else
1913         grml_vcs_info_set_formats plain
1914     fi
1915     return 0
1916 }
1917
1918 function grml_vcs_info_set_formats () {
1919     emulate -L zsh
1920     #setopt localoptions xtrace
1921     local mode=$1 AF F BF
1922     if [[ $mode == coloured ]]; then
1923         AF=${grml_vcs_coloured_formats[actionformat]}
1924         F=${grml_vcs_coloured_formats[format]}
1925         BF=${grml_vcs_coloured_formats[rev-branchformat]}
1926         GRML_VCS_COLOUR_MODE=coloured
1927     else
1928         AF=${grml_vcs_plain_formats[actionformat]}
1929         F=${grml_vcs_plain_formats[format]}
1930         BF=${grml_vcs_plain_formats[rev-branchformat]}
1931         GRML_VCS_COLOUR_MODE=plain
1932     fi
1933
1934     zstyle ':vcs_info:*'              actionformats "$AF" "zsh: %r"
1935     zstyle ':vcs_info:*'              formats       "$F"  "zsh: %r"
1936     zstyle ':vcs_info:(sv[nk]|bzr):*' branchformat  "$BF"
1937     return 0
1938 }
1939
1940 # Change vcs_info formats for the grml prompt. The 2nd format sets up
1941 # $vcs_info_msg_1_ to contain "zsh: repo-name" used to set our screen title.
1942 if [[ "$TERM" == dumb ]] ; then
1943     grml_vcs_info_set_formats plain
1944 else
1945     grml_vcs_info_set_formats coloured
1946 fi
1947
1948 # Now for the fun part: The grml prompt themes in `promptsys' mode of operation
1949
1950 # This actually defines three prompts:
1951 #
1952 #    - grml
1953 #    - grml-large
1954 #    - grml-chroot
1955 #
1956 # They all share the same code and only differ with respect to which items they
1957 # contain. The main source of documentation is the `prompt_grml_help' function
1958 # below, which gets called when the user does this: prompt -h grml
1959
1960 function prompt_grml_help () {
1961     <<__EOF0__
1962   prompt grml
1963
1964     This is the prompt as used by the grml-live system <http://grml.org>. It is
1965     a rather simple one-line prompt, that by default looks something like this:
1966
1967         <user>@<host> <current-working-directory>[ <vcs_info-data>]%
1968
1969     The prompt itself integrates with zsh's prompt themes system (as you are
1970     witnessing right now) and is configurable to a certain degree. In
1971     particular, these aspects are customisable:
1972
1973         - The items used in the prompt (e.g. you can remove \`user' from
1974           the list of activated items, which will cause the user name to
1975           be omitted from the prompt string).
1976
1977         - The attributes used with the items are customisable via strings
1978           used before and after the actual item.
1979
1980     The available items are: at, battery, change-root, date, grml-chroot,
1981     history, host, jobs, newline, path, percent, rc, rc-always, sad-smiley,
1982     shell-level, time, user, vcs
1983
1984     The actual configuration is done via zsh's \`zstyle' mechanism. The
1985     context, that is used while looking up styles is:
1986
1987         ':prompt:grml:<left-or-right>:<subcontext>'
1988
1989     Here <left-or-right> is either \`left' or \`right', signifying whether the
1990     style should affect the left or the right prompt. <subcontext> is either
1991     \`setup' or 'items:<item>', where \`<item>' is one of the available items.
1992
1993     The styles:
1994
1995         - use-rprompt (boolean): If \`true' (the default), print a sad smiley
1996           in $RPROMPT if the last command a returned non-successful error code.
1997           (This in only valid if <left-or-right> is "right"; ignored otherwise)
1998
1999         - items (list): The list of items used in the prompt. If \`vcs' is
2000           present in the list, the theme's code invokes \`vcs_info'
2001           accordingly. Default (left): rc change-root user at host path vcs
2002           percent; Default (right): sad-smiley
2003
2004     Available styles in 'items:<item>' are: pre, post. These are strings that
2005     are inserted before (pre) and after (post) the item in question. Thus, the
2006     following would cause the user name to be printed in red instead of the
2007     default blue:
2008
2009         zstyle ':prompt:grml:*:items:user' pre '%F{red}'
2010
2011     Note, that the \`post' style may remain at its default value, because its
2012     default value is '%f', which turns the foreground text attribute off (which
2013     is exactly, what is still required with the new \`pre' value).
2014 __EOF0__
2015 }
2016
2017 function prompt_grml-chroot_help () {
2018     <<__EOF0__
2019   prompt grml-chroot
2020
2021     This is a variation of the grml prompt, see: prompt -h grml
2022
2023     The main difference is the default value of the \`items' style. The rest
2024     behaves exactly the same. Here are the defaults for \`grml-chroot':
2025
2026         - left: grml-chroot user at host path percent
2027         - right: (empty list)
2028 __EOF0__
2029 }
2030
2031 function prompt_grml-large_help () {
2032     <<__EOF0__
2033   prompt grml-large
2034
2035     This is a variation of the grml prompt, see: prompt -h grml
2036
2037     The main difference is the default value of the \`items' style. In
2038     particular, this theme uses _two_ lines instead of one with the plain
2039     \`grml' theme. The rest behaves exactly the same. Here are the defaults
2040     for \`grml-large':
2041
2042         - left: rc jobs history shell-level change-root time date newline user
2043                 at host path vcs percent
2044         - right: sad-smiley
2045 __EOF0__
2046 }
2047
2048 function grml_prompt_setup () {
2049     emulate -L zsh
2050     autoload -Uz vcs_info
2051     # The following autoload is disabled for now, since this setup includes a
2052     # static version of the ‘add-zsh-hook’ function above. It needs to be
2053     # reenabled as soon as that static definition is removed again.
2054     #autoload -Uz add-zsh-hook
2055     add-zsh-hook precmd prompt_$1_precmd
2056 }
2057
2058 function prompt_grml_setup () {
2059     grml_prompt_setup grml
2060 }
2061
2062 function prompt_grml-chroot_setup () {
2063     grml_prompt_setup grml-chroot
2064 }
2065
2066 function prompt_grml-large_setup () {
2067     grml_prompt_setup grml-large
2068 }
2069
2070 # These maps define default tokens and pre-/post-decoration for items to be
2071 # used within the themes. All defaults may be customised in a context sensitive
2072 # matter by using zsh's `zstyle' mechanism.
2073 typeset -gA grml_prompt_pre_default \
2074             grml_prompt_post_default \
2075             grml_prompt_token_default \
2076             grml_prompt_token_function
2077
2078 grml_prompt_pre_default=(
2079     at                ''
2080     battery           ' '
2081     change-root       ''
2082     date              '%F{blue}'
2083     grml-chroot       '%F{red}'
2084     history           '%F{green}'
2085     host              ''
2086     jobs              '%F{cyan}'
2087     newline           ''
2088     path              '%B'
2089     percent           ''
2090     rc                '%B%F{red}'
2091     rc-always         ''
2092     sad-smiley        ''
2093     shell-level       '%F{red}'
2094     time              '%F{blue}'
2095     user              '%B%F{blue}'
2096     vcs               ''
2097 )
2098
2099 grml_prompt_post_default=(
2100     at                ''
2101     battery           ''
2102     change-root       ''
2103     date              '%f'
2104     grml-chroot       '%f '
2105     history           '%f'
2106     host              ''
2107     jobs              '%f'
2108     newline           ''
2109     path              '%b'
2110     percent           ''
2111     rc                '%f%b'
2112     rc-always         ''
2113     sad-smiley        ''
2114     shell-level       '%f'
2115     time              '%f'
2116     user              '%f%b'
2117     vcs               ''
2118 )
2119
2120 grml_prompt_token_default=(
2121     at                '@'
2122     battery           'GRML_BATTERY_LEVEL'
2123     change-root       'debian_chroot'
2124     date              '%D{%Y-%m-%d}'
2125     grml-chroot       'GRML_CHROOT'
2126     history           '{history#%!} '
2127     host              '%m '
2128     jobs              '[%j running job(s)] '
2129     newline           $'\n'
2130     path              '%40<..<%~%<< '
2131     percent           '%# '
2132     rc                '%(?..%? )'
2133     rc-always         '%?'
2134     sad-smiley        '%(?..:()'
2135     shell-level       '%(3L.+ .)'
2136     time              '%D{%H:%M:%S} '
2137     user              '%n'
2138     vcs               '0'
2139 )
2140
2141 function grml_theme_has_token () {
2142     if (( ARGC != 1 )); then
2143         printf 'usage: grml_theme_has_token <name>\n'
2144         return 1
2145     fi
2146     (( ${+grml_prompt_token_default[$1]} ))
2147 }
2148
2149 function GRML_theme_add_token_usage () {
2150     <<__EOF0__
2151   Usage: grml_theme_add_token <name> [-f|-i] <token/function> [<pre> <post>]
2152
2153     <name> is the name for the newly added token. If the \`-f' or \`-i' options
2154     are used, <token/function> is the name of the function (see below for
2155     details). Otherwise it is the literal token string to be used. <pre> and
2156     <post> are optional.
2157
2158   Options:
2159
2160     -f <function>   Use a function named \`<function>' each time the token
2161                     is to be expanded.
2162
2163     -i <function>   Use a function named \`<function>' to initialise the
2164                     value of the token _once_ at runtime.
2165
2166     The functions are called with one argument: the token's new name. The
2167     return value is expected in the \$REPLY parameter. The use of these
2168     options is mutually exclusive.
2169
2170     There is a utility function \`grml_theme_has_token', which you can use
2171     to test if a token exists before trying to add it. This can be a guard
2172     for situations in which a \`grml_theme_add_token' call may happen more
2173     than once.
2174
2175   Example:
2176
2177     To add a new token \`day' that expands to the current weekday in the
2178     current locale in green foreground colour, use this:
2179
2180       grml_theme_add_token day '%D{%A}' '%F{green}' '%f'
2181
2182     Another example would be support for \$VIRTUAL_ENV:
2183
2184       function virtual_env_prompt () {
2185         REPLY=\${VIRTUAL_ENV+\${VIRTUAL_ENV:t} }
2186       }
2187       grml_theme_add_token virtual-env -f virtual_env_prompt
2188
2189     After that, you will be able to use a changed \`items' style to
2190     assemble your prompt.
2191 __EOF0__
2192 }
2193
2194 function grml_theme_add_token () {
2195     emulate -L zsh
2196     local name token pre post
2197     local -i init funcall
2198
2199     if (( ARGC == 0 )); then
2200         GRML_theme_add_token_usage
2201         return 0
2202     fi
2203
2204     init=0
2205     funcall=0
2206     pre=''
2207     post=''
2208     name=$1
2209     shift
2210     if [[ $1 == '-f' ]]; then
2211         funcall=1
2212         shift
2213     elif [[ $1 == '-i' ]]; then
2214         init=1
2215         shift
2216     fi
2217
2218     if (( ARGC == 0 )); then
2219         printf '
2220 grml_theme_add_token: No token-string/function-name provided!\n\n'
2221         GRML_theme_add_token_usage
2222         return 1
2223     fi
2224     token=$1
2225     shift
2226     if (( ARGC != 0 && ARGC != 2 )); then
2227         printf '
2228 grml_theme_add_token: <pre> and <post> need to by specified _both_!\n\n'
2229         GRML_theme_add_token_usage
2230         return 1
2231     fi
2232     if (( ARGC )); then
2233         pre=$1
2234         post=$2
2235         shift 2
2236     fi
2237
2238     if grml_theme_has_token $name; then
2239         printf '
2240 grml_theme_add_token: Token `%s'\'' exists! Giving up!\n\n' $name
2241         GRML_theme_add_token_usage
2242         return 2
2243     fi
2244     if (( init )); then
2245         $token $name
2246         token=$REPLY
2247     fi
2248     grml_prompt_pre_default[$name]=$pre
2249     grml_prompt_post_default[$name]=$post
2250     if (( funcall )); then
2251         grml_prompt_token_function[$name]=$token
2252         grml_prompt_token_default[$name]=23
2253     else
2254         grml_prompt_token_default[$name]=$token
2255     fi
2256 }
2257
2258 function grml_wrap_reply () {
2259     emulate -L zsh
2260     local target="$1"
2261     local new="$2"
2262     local left="$3"
2263     local right="$4"
2264
2265     if (( ${+parameters[$new]} )); then
2266         REPLY="${left}${(P)new}${right}"
2267     else
2268         REPLY=''
2269     fi
2270 }
2271
2272 function grml_prompt_addto () {
2273     emulate -L zsh
2274     local target="$1"
2275     local lr it apre apost new v REPLY
2276     local -a items
2277     shift
2278
2279     [[ $target == PS1 ]] && lr=left || lr=right
2280     zstyle -a ":prompt:${grmltheme}:${lr}:setup" items items || items=( "$@" )
2281     typeset -g "${target}="
2282     for it in "${items[@]}"; do
2283         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" pre apre \
2284             || apre=${grml_prompt_pre_default[$it]}
2285         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" post apost \
2286             || apost=${grml_prompt_post_default[$it]}
2287         zstyle -s ":prompt:${grmltheme}:${lr}:items:$it" token new \
2288             || new=${grml_prompt_token_default[$it]}
2289         if (( ${+grml_prompt_token_function[$it]} )); then
2290             ${grml_prompt_token_function[$it]} $it
2291         else
2292             case $it in
2293             battery)
2294                 grml_wrap_reply $target $new '' ''
2295                 ;;
2296             change-root)
2297                 grml_wrap_reply $target $new '(' ')'
2298                 ;;
2299             grml-chroot)
2300                 if [[ -n ${(P)new} ]]; then
2301                     REPLY="$CHROOT"
2302                 else
2303                     REPLY=''
2304                 fi
2305                 ;;
2306             vcs)
2307                 v="vcs_info_msg_${new}_"
2308                 if (( ! vcscalled )); then
2309                     vcs_info
2310                     vcscalled=1
2311                 fi
2312                 if (( ${+parameters[$v]} )) && [[ -n "${(P)v}" ]]; then
2313                     REPLY="${(P)v}"
2314                 else
2315                     REPLY=''
2316                 fi
2317                 ;;
2318             *) REPLY="$new" ;;
2319             esac
2320         fi
2321         # Strip volatile characters per item. This is off by default. See the
2322         # global stripping code a few lines below for details.
2323         if [[ -o prompt_subst ]] && zstyle -t ":prompt:${grmltheme}:${lr}:items:$it" \
2324                                            strip-sensitive-characters
2325         then
2326             REPLY="${REPLY//[$\`]/}"
2327         fi
2328         typeset -g "${target}=${(P)target}${apre}${REPLY}${apost}"
2329     done
2330
2331     # Per default, strip volatile characters (in the prompt_subst case)
2332     # globally. If the option is off, the style has no effect. For more
2333     # control, this can be turned off and stripping can be configured on a
2334     # per-item basis (see above).
2335     if [[ -o prompt_subst ]] && zstyle -T ":prompt:${grmltheme}:${lr}:setup" \
2336                                        strip-sensitive-characters
2337     then
2338         typeset -g "${target}=${${(P)target}//[$\`]/}"
2339     fi
2340 }
2341
2342 function prompt_grml_precmd () {
2343     emulate -L zsh
2344     local grmltheme=grml
2345     local -a left_items right_items
2346     left_items=(rc change-root user at host path vcs percent)
2347     right_items=(sad-smiley)
2348
2349     prompt_grml_precmd_worker
2350 }
2351
2352 function prompt_grml-chroot_precmd () {
2353     emulate -L zsh
2354     local grmltheme=grml-chroot
2355     local -a left_items right_items
2356     left_items=(grml-chroot user at host path percent)
2357     right_items=()
2358
2359     prompt_grml_precmd_worker
2360 }
2361
2362 function prompt_grml-large_precmd () {
2363     emulate -L zsh
2364     local grmltheme=grml-large
2365     local -a left_items right_items
2366     left_items=(rc jobs history shell-level change-root time date newline
2367                 user at host path vcs percent)
2368     right_items=(sad-smiley)
2369
2370     prompt_grml_precmd_worker
2371 }
2372
2373 function prompt_grml_precmd_worker () {
2374     emulate -L zsh
2375     local -i vcscalled=0
2376
2377     grml_prompt_addto PS1 "${left_items[@]}"
2378     if zstyle -T ":prompt:${grmltheme}:right:setup" use-rprompt; then
2379         grml_prompt_addto RPS1 "${right_items[@]}"
2380     fi
2381 }
2382
2383 function grml_prompt_fallback () {
2384     setopt prompt_subst
2385     local p0 p1
2386
2387     p0="${RED}%(?..%? )${WHITE}${debian_chroot:+($debian_chroot)}"
2388     p1="${BLUE}%n${NO_COLOR}@%m %40<...<%B%~%b%<< "'${vcs_info_msg_0_}'"%# "
2389     if (( EUID == 0 )); then
2390         PROMPT="${BLUE}${p0}${RED}${p1}"
2391     else
2392         PROMPT="${RED}${p0}${BLUE}${p1}"
2393     fi
2394 }
2395
2396 if zrcautoload promptinit && promptinit 2>/dev/null ; then
2397     # Since we define the required functions in here and not in files in
2398     # $fpath, we need to stick the theme's name into `$prompt_themes'
2399     # ourselves, since promptinit does not pick them up otherwise.
2400     prompt_themes+=( grml grml-chroot grml-large )
2401     # Also, keep the array sorted...
2402     prompt_themes=( "${(@on)prompt_themes}" )
2403 else
2404     print 'Notice: no promptinit available :('
2405     grml_prompt_fallback
2406     function precmd () { (( ${+functions[vcs_info]} )) && vcs_info; }
2407 fi
2408
2409 if is437; then
2410     # The prompt themes use modern features of zsh, that require at least
2411     # version 4.3.7 of the shell. Use the fallback otherwise.
2412     if [[ $GRML_DISPLAY_BATTERY -gt 0 ]]; then
2413         zstyle ':prompt:grml:right:setup' items sad-smiley battery
2414         add-zsh-hook precmd battery
2415     fi
2416     if [[ "$TERM" == dumb ]] ; then
2417         zstyle ":prompt:grml(|-large|-chroot):*:items:grml-chroot" pre ''
2418         zstyle ":prompt:grml(|-large|-chroot):*:items:grml-chroot" post ' '
2419         for i in rc user path jobs history date time shell-level; do
2420             zstyle ":prompt:grml(|-large|-chroot):*:items:$i" pre ''
2421             zstyle ":prompt:grml(|-large|-chroot):*:items:$i" post ''
2422         done
2423         unset i
2424         zstyle ':prompt:grml(|-large|-chroot):right:setup' use-rprompt false
2425     elif (( EUID == 0 )); then
2426         zstyle ':prompt:grml(|-large|-chroot):*:items:user' pre '%B%F{red}'
2427     fi
2428
2429     # Finally enable one of the prompts.
2430     if [[ -n $GRML_CHROOT ]]; then
2431         prompt grml-chroot
2432     elif [[ $GRMLPROMPT -gt 0 ]]; then
2433         prompt grml-large
2434     else
2435         prompt grml
2436     fi
2437 else
2438     grml_prompt_fallback
2439     function precmd () { (( ${+functions[vcs_info]} )) && vcs_info; }
2440 fi
2441
2442 # Terminal-title wizardry
2443
2444 function ESC_print () {
2445     info_print $'\ek' $'\e\\' "$@"
2446 }
2447 function set_title () {
2448     info_print  $'\e]0;' $'\a' "$@"
2449 }
2450
2451 function info_print () {
2452     local esc_begin esc_end
2453     esc_begin="$1"
2454     esc_end="$2"
2455     shift 2
2456     printf '%s' ${esc_begin}
2457     printf '%s' "$*"
2458     printf '%s' "${esc_end}"
2459 }
2460
2461 function grml_reset_screen_title () {
2462     # adjust title of xterm
2463     # see http://www.faqs.org/docs/Linux-mini/Xterm-Title.html
2464     [[ ${NOTITLE:-} -gt 0 ]] && return 0
2465     case $TERM in
2466         (xterm*|rxvt*)
2467             set_title ${(%):-"%n@%m: %~"}
2468             ;;
2469     esac
2470 }
2471
2472 function grml_vcs_to_screen_title () {
2473     if [[ $TERM == screen* ]] ; then
2474         if [[ -n ${vcs_info_msg_1_} ]] ; then
2475             ESC_print ${vcs_info_msg_1_}
2476         else
2477             ESC_print "zsh"
2478         fi
2479     fi
2480 }
2481
2482 function grml_maintain_name () {
2483     # set hostname if not running on host with name 'grml'
2484     if [[ -n "$HOSTNAME" ]] && [[ "$HOSTNAME" != $(hostname) ]] ; then
2485        NAME="@$HOSTNAME"
2486     fi
2487 }
2488
2489 function grml_cmd_to_screen_title () {
2490     # get the name of the program currently running and hostname of local
2491     # machine set screen window title if running in a screen
2492     if [[ "$TERM" == screen* ]] ; then
2493         local CMD="${1[(wr)^(*=*|sudo|ssh|-*)]}$NAME"
2494         ESC_print ${CMD}
2495     fi
2496 }
2497
2498 function grml_control_xterm_title () {
2499     case $TERM in
2500         (xterm*|rxvt*)
2501             set_title "${(%):-"%n@%m:"}" "$1"
2502             ;;
2503     esac
2504 }
2505
2506 # The following autoload is disabled for now, since this setup includes a
2507 # static version of the ‘add-zsh-hook’ function above. It needs to be
2508 # reenabled as soon as that static definition is removed again.
2509 #zrcautoload add-zsh-hook || add-zsh-hook () { :; }
2510 if [[ $NOPRECMD -eq 0 ]]; then
2511     add-zsh-hook precmd grml_reset_screen_title
2512     add-zsh-hook precmd grml_vcs_to_screen_title
2513     add-zsh-hook preexec grml_maintain_name
2514     add-zsh-hook preexec grml_cmd_to_screen_title
2515     if [[ $NOTITLE -eq 0 ]]; then
2516         add-zsh-hook preexec grml_control_xterm_title
2517     fi
2518 fi
2519
2520 # 'hash' some often used directories
2521 #d# start
2522 hash -d deb=/var/cache/apt/archives
2523 hash -d doc=/usr/share/doc
2524 hash -d linux=/lib/modules/$(command uname -r)/build/
2525 hash -d log=/var/log
2526 hash -d slog=/var/log/syslog
2527 hash -d src=/usr/src
2528 hash -d www=/var/www
2529 #d# end
2530
2531 # some aliases
2532 if check_com -c screen ; then
2533     if [[ $UID -eq 0 ]] ; then
2534         if [[ -r /etc/grml/screenrc ]]; then
2535             alias screen='screen -c /etc/grml/screenrc'
2536         fi
2537     elif [[ ! -r $HOME/.screenrc ]] ; then
2538         if [[ -r /etc/grml/screenrc_grml ]]; then
2539             alias screen='screen -c /etc/grml/screenrc_grml'
2540         else
2541             if [[ -r /etc/grml/screenrc ]]; then
2542                 alias screen='screen -c /etc/grml/screenrc'
2543             fi
2544         fi
2545     fi
2546 fi
2547
2548 # do we have GNU ls with color-support?
2549 if [[ "$TERM" != dumb ]]; then
2550     #a1# List files with colors (\kbd{ls \ldots})
2551     alias ls="command ls ${ls_options:+${ls_options[*]}}"
2552     #a1# List all files, with colors (\kbd{ls -la \ldots})
2553     alias la="command ls -la ${ls_options:+${ls_options[*]}}"
2554     #a1# List files with long colored list, without dotfiles (\kbd{ls -l \ldots})
2555     alias ll="command ls -l ${ls_options:+${ls_options[*]}}"
2556     #a1# List files with long colored list, human readable sizes (\kbd{ls -hAl \ldots})
2557     alias lh="command ls -hAl ${ls_options:+${ls_options[*]}}"
2558     #a1# List files with long colored list, append qualifier to filenames (\kbd{ls -l \ldots})\\&\quad(\kbd{/} for directories, \kbd{@} for symlinks ...)
2559     alias l="command ls -l ${ls_options:+${ls_options[*]}}"
2560 else
2561     alias la='command ls -la'
2562     alias ll='command ls -l'
2563     alias lh='command ls -hAl'
2564     alias l='command ls -l'
2565 fi
2566
2567 if [[ -r /proc/mdstat ]]; then
2568     alias mdstat='cat /proc/mdstat'
2569 fi
2570
2571 alias ...='cd ../../'
2572
2573 # generate alias named "$KERNELVERSION-reboot" so you can use boot with kexec:
2574 if [[ -x /sbin/kexec ]] && [[ -r /proc/cmdline ]] ; then
2575     alias "$(uname -r)-reboot"="kexec -l --initrd=/boot/initrd.img-"$(uname -r)" --command-line=\"$(cat /proc/cmdline)\" /boot/vmlinuz-"$(uname -r)""
2576 fi
2577
2578 # see http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for details
2579 alias term2iso="echo 'Setting terminal to iso mode' ; print -n '\e%@'"
2580 alias term2utf="echo 'Setting terminal to utf-8 mode'; print -n '\e%G'"
2581
2582 # make sure it is not assigned yet
2583 [[ -n ${aliases[utf2iso]} ]] && unalias utf2iso
2584 function utf2iso () {
2585     if isutfenv ; then
2586         local ENV
2587         for ENV in $(env | command grep -i '.utf') ; do
2588             eval export "$(echo $ENV | sed 's/UTF-8/iso885915/ ; s/utf8/iso885915/')"
2589         done
2590     fi
2591 }
2592
2593 # make sure it is not assigned yet
2594 [[ -n ${aliases[iso2utf]} ]] && unalias iso2utf
2595 function iso2utf () {
2596     if ! isutfenv ; then
2597         local ENV
2598         for ENV in $(env | command grep -i '\.iso') ; do
2599             eval export "$(echo $ENV | sed 's/iso.*/UTF-8/ ; s/ISO.*/UTF-8/')"
2600         done
2601     fi
2602 }
2603
2604 # especially for roadwarriors using GNU screen and ssh:
2605 if ! check_com asc &>/dev/null ; then
2606   function asc () { autossh -t "$@" 'screen -RdU' }
2607   compdef asc=ssh
2608 fi
2609
2610 #f1# Hints for the use of zsh on grml
2611 function zsh-help () {
2612     print "$bg[white]$fg[black]
2613 zsh-help - hints for use of zsh on grml
2614 =======================================$reset_color"
2615
2616     print '
2617 Main configuration of zsh happens in /etc/zsh/zshrc.
2618 That file is part of the package grml-etc-core, if you want to
2619 use them on a non-grml-system just get the tar.gz from
2620 http://deb.grml.org/ or (preferably) get it from the git repository:
2621
2622   http://git.grml.org/f/grml-etc-core/etc/zsh/zshrc
2623
2624 This version of grml'\''s zsh setup does not use skel/.zshrc anymore.
2625 The file is still there, but it is empty for backwards compatibility.
2626
2627 For your own changes use these two files:
2628     $HOME/.zshrc.pre
2629     $HOME/.zshrc.local
2630
2631 The former is sourced very early in our zshrc, the latter is sourced
2632 very lately.
2633
2634 System wide configuration without touching configuration files of grml
2635 can take place in /etc/zsh/zshrc.local.
2636
2637 For information regarding zsh start at http://grml.org/zsh/
2638
2639 Take a look at grml'\''s zsh refcard:
2640 % xpdf =(zcat /usr/share/doc/grml-docs/zsh/grml-zsh-refcard.pdf.gz)
2641
2642 Check out the main zsh refcard:
2643 % '$BROWSER' http://www.bash2zsh.com/zsh_refcard/refcard.pdf
2644
2645 And of course visit the zsh-lovers:
2646 % man zsh-lovers
2647
2648 You can adjust some options through environment variables when
2649 invoking zsh without having to edit configuration files.
2650 Basically meant for bash users who are not used to the power of
2651 the zsh yet. :)
2652
2653   "NOCOR=1    zsh" => deactivate automatic correction
2654   "NOMENU=1   zsh" => do not use auto menu completion
2655                       (note: use ctrl-d for completion instead!)
2656   "NOPRECMD=1 zsh" => disable the precmd + preexec commands (set GNU screen title)
2657   "NOTITLE=1  zsh" => disable setting the title of xterms without disabling
2658                       preexec() and precmd() completely
2659   "GRML_DISPLAY_BATTERY=1  zsh"
2660                    => activate battery status on right side of prompt (WIP)
2661   "COMMAND_NOT_FOUND=1 zsh"
2662                    => Enable a handler if an external command was not found
2663                       The command called in the handler can be altered by setting
2664                       the GRML_ZSH_CNF_HANDLER variable, the default is:
2665                       "/usr/share/command-not-found/command-not-found"
2666
2667 A value greater than 0 is enables a feature; a value equal to zero
2668 disables it. If you like one or the other of these settings, you can
2669 add them to ~/.zshrc.pre to ensure they are set when sourcing grml'\''s
2670 zshrc.'
2671
2672     print "
2673 $bg[white]$fg[black]
2674 Please report wishes + bugs to the grml-team: http://grml.org/bugs/
2675 Enjoy your grml system with the zsh!$reset_color"
2676 }
2677
2678 # debian stuff
2679 if [[ -r /etc/debian_version ]] ; then
2680     if [[ -z "$GRML_NO_APT_ALIASES" ]]; then
2681         #a3# Execute \kbd{apt-cache search}
2682         alias acs='apt-cache search'
2683         #a3# Execute \kbd{apt-cache show}
2684         alias acsh='apt-cache show'
2685         #a3# Execute \kbd{apt-cache policy}
2686         alias acp='apt-cache policy'
2687         if check_com -c apt ; then
2688           #a3# Execute \kbd{apt dist-upgrade}
2689           salias adg="apt dist-upgrade"
2690           #a3# Execute \kbd{apt upgrade}
2691           salias ag="apt upgrade"
2692           #a3# Execute \kbd{apt install}
2693           salias agi="apt install"
2694           #a3# Execute \kbd{apt-get update}
2695           salias au="apt update"
2696         else
2697           salias adg="apt-get dist-upgrade"
2698           salias ag="apt-get upgrade"
2699           salias agi="apt-get install"
2700           salias au="apt-get update"
2701         fi
2702         #a3# Execute \kbd{aptitude install}
2703         salias ati="aptitude install"
2704         #a3# Execute \kbd{aptitude update ; aptitude safe-upgrade}
2705         salias -a up="aptitude update ; aptitude safe-upgrade"
2706         #a3# Execute \kbd{dpkg-buildpackage}
2707         alias dbp='dpkg-buildpackage'
2708         #a3# Execute \kbd{grep-excuses}
2709         alias ge='grep-excuses'
2710     fi
2711
2712     # get a root shell as normal user in live-cd mode:
2713     if isgrmlcd && [[ $UID -ne 0 ]] ; then
2714        alias su="sudo su"
2715     fi
2716
2717 fi
2718
2719 # use /var/log/syslog iff present, fallback to journalctl otherwise
2720 if [ -e /var/log/syslog ] ; then
2721   #a1# Take a look at the syslog: \kbd{\$PAGER /var/log/syslog || journalctl}
2722   salias llog="$PAGER /var/log/syslog"     # take a look at the syslog
2723   #a1# Take a look at the syslog: \kbd{tail -f /var/log/syslog || journalctl}
2724   salias tlog="tail -f /var/log/syslog"    # follow the syslog
2725 elif check_com -c journalctl ; then
2726   salias llog="journalctl"
2727   salias tlog="journalctl -f"
2728 fi
2729
2730 # sort installed Debian-packages by size
2731 if check_com -c dpkg-query ; then
2732     #a3# List installed Debian-packages sorted by size
2733     alias debs-by-size="dpkg-query -Wf 'x \${Installed-Size} \${Package} \${Status}\n' | sed -ne '/^x  /d' -e '/^x \(.*\) install ok installed$/s//\1/p' | sort -nr"
2734 fi
2735
2736 # if cdrecord is a symlink (to wodim) or isn't present at all warn:
2737 if [[ -L /usr/bin/cdrecord ]] || ! check_com -c cdrecord; then
2738     if check_com -c wodim; then
2739         function cdrecord () {
2740             <<__EOF0__
2741 cdrecord is not provided under its original name by Debian anymore.
2742 See #377109 in the BTS of Debian for more details.
2743
2744 Please use the wodim binary instead
2745 __EOF0__
2746             return 1
2747         }
2748     fi
2749 fi
2750
2751 if isgrmlcd; then
2752     # No core dumps: important for a live-cd-system
2753     limit -s core 0
2754 fi
2755
2756 # grmlstuff
2757 function grmlstuff () {
2758 # people should use 'grml-x'!
2759     if check_com -c 915resolution; then
2760         function 855resolution () {
2761             echo "Please use 915resolution as resolution modifying tool for Intel \
2762 graphic chipset."
2763             return -1
2764         }
2765     fi
2766
2767     #a1# Output version of running grml
2768     alias grml-version='cat /etc/grml_version'
2769
2770     if check_com -c grml-debootstrap ; then
2771         function debian2hd () {
2772             echo "Installing debian to harddisk is possible by using grml-debootstrap."
2773             return 1
2774         }
2775     fi
2776 }
2777
2778 # now run the functions
2779 isgrml && checkhome
2780 is4    && isgrml    && grmlstuff
2781 is4    && grmlcomp
2782
2783 # keephack
2784 is4 && xsource "/etc/zsh/keephack"
2785
2786 # wonderful idea of using "e" glob qualifier by Peter Stephenson
2787 # You use it as follows:
2788 # $ NTREF=/reference/file
2789 # $ ls -l *(e:nt:)
2790 # This lists all the files in the current directory newer than the reference file.
2791 # You can also specify the reference file inline; note quotes:
2792 # $ ls -l *(e:'nt ~/.zshenv':)
2793 is4 && function nt () {
2794     if [[ -n $1 ]] ; then
2795         local NTREF=${~1}
2796     fi
2797     [[ $REPLY -nt $NTREF ]]
2798 }
2799
2800 # shell functions
2801
2802 #f1# Reload an autoloadable function
2803 function freload () { while (( $# )); do; unfunction $1; autoload -U $1; shift; done }
2804 compdef _functions freload
2805
2806 #
2807 # Usage:
2808 #
2809 #      e.g.:   a -> b -> c -> d  ....
2810 #
2811 #      sll a
2812 #
2813 #
2814 #      if parameter is given with leading '=', lookup $PATH for parameter and resolve that
2815 #
2816 #      sll =java
2817 #
2818 #      Note: limit for recursive symlinks on linux:
2819 #            http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/fs/namei.c?id=refs/heads/master#l808
2820 #            This limits recursive symlink follows to 8,
2821 #            while limiting consecutive symlinks to 40.
2822 #
2823 #      When resolving and displaying information about symlinks, no check is made
2824 #      that the displayed information does make any sense on your OS.
2825 #      We leave that decission to the user.
2826 #
2827 #      The zstat module is used to detect symlink loops. zstat is available since zsh4.
2828 #      With an older zsh you will need to abort with <C-c> in that case.
2829 #      When a symlink loop is detected, a warning ist printed and further processing is stopped.
2830 #
2831 #      Module zstat is loaded by default in grml zshrc, no extra action needed for that.
2832 #
2833 #      Known bugs:
2834 #      If you happen to come accross a symlink that points to a destination on an other partition
2835 #      with the same inode number, that will be marked as symlink loop though it is not.
2836 #      Two hints for this situation:
2837 #      I)  Play lottery the same day, as you seem to be rather lucky right now.
2838 #      II) Send patches.
2839 #
2840 #      return status:
2841 #      0 upon success
2842 #      1 file/dir not accesible
2843 #      2 symlink loop detected
2844 #
2845 #f1# List symlinks in detail (more detailed version of 'readlink -f', 'whence -s' and 'namei -l')
2846 function sll () {
2847     if [[ -z ${1} ]] ; then
2848         printf 'Usage: %s <symlink(s)>\n' "${0}"
2849         return 1
2850     fi
2851
2852     local file jumpd curdir
2853     local -i 10 RTN LINODE i
2854     local -a    SEENINODES
2855     curdir="${PWD}"
2856     RTN=0
2857
2858     for file in "${@}" ; do
2859         SEENINODES=()
2860         ls -l "${file:a}"   || RTN=1
2861
2862         while [[ -h "$file" ]] ; do
2863             if is4 ; then
2864                 LINODE=$(zstat -L +inode "${file}")
2865                 for i in ${SEENINODES} ; do
2866                     if (( ${i} == ${LINODE} )) ; then
2867                         builtin cd -q "${curdir}"
2868                         print 'link loop detected, aborting!'
2869                         return 2
2870                     fi
2871                 done
2872                 SEENINODES+=${LINODE}
2873             fi
2874             jumpd="${file:h}"
2875             file="${file:t}"
2876
2877             if [[ -d ${jumpd} ]] ; then
2878                 builtin cd -q "${jumpd}"  || RTN=1
2879             fi
2880             file=$(readlink "$file")
2881
2882             jumpd="${file:h}"
2883             file="${file:t}"
2884
2885             if [[ -d ${jumpd} ]] ; then
2886                 builtin cd -q "${jumpd}"  || RTN=1
2887             fi
2888
2889             ls -l "${PWD}/${file}"     || RTN=1
2890         done
2891         shift 1
2892         if (( ${#} >= 1 )) ; then
2893             print ""
2894         fi
2895         builtin cd -q "${curdir}"
2896     done
2897     return ${RTN}
2898 }
2899
2900 # TODO: Is it supported to use pager settings like this?
2901 #   PAGER='less -Mr' - If so, the use of $PAGER here needs fixing
2902 # with respect to wordsplitting. (ie. ${=PAGER})
2903 if check_com -c $PAGER ; then
2904     #f3# View Debian's changelog of given package(s)
2905     function dchange () {
2906         emulate -L zsh
2907         [[ -z "$1" ]] && printf 'Usage: %s <package_name(s)>\n' "$0" && return 1
2908
2909         local package
2910         for package in "$@" ; do
2911             if [[ -r /usr/share/doc/${package}/changelog.Debian.gz ]] ; then
2912                 $PAGER /usr/share/doc/${package}/changelog.Debian.gz
2913             elif [[ -r /usr/share/doc/${package}/changelog.gz ]] ; then
2914                 $PAGER /usr/share/doc/${package}/changelog.gz
2915             elif [[ -r /usr/share/doc/${package}/changelog ]] ; then
2916                 $PAGER /usr/share/doc/${package}/changelog
2917             else
2918                 if check_com -c aptitude ; then
2919                     echo "No changelog for package $package found, using aptitude to retrieve it."
2920                     aptitude changelog "$package"
2921                 elif check_com -c apt-get ; then
2922                     echo "No changelog for package $package found, using apt-get to retrieve it."
2923                     apt-get changelog "$package"
2924                 else
2925                     echo "No changelog for package $package found, sorry."
2926                 fi
2927             fi
2928         done
2929     }
2930     function _dchange () { _files -W /usr/share/doc -/ }
2931     compdef _dchange dchange
2932
2933     #f3# View Debian's NEWS of a given package
2934     function dnews () {
2935         emulate -L zsh
2936         if [[ -r /usr/share/doc/$1/NEWS.Debian.gz ]] ; then
2937             $PAGER /usr/share/doc/$1/NEWS.Debian.gz
2938         else
2939             if [[ -r /usr/share/doc/$1/NEWS.gz ]] ; then
2940                 $PAGER /usr/share/doc/$1/NEWS.gz
2941             else
2942                 echo "No NEWS file for package $1 found, sorry."
2943                 return 1
2944             fi
2945         fi
2946     }
2947     function _dnews () { _files -W /usr/share/doc -/ }
2948     compdef _dnews dnews
2949
2950     #f3# View Debian's copyright of a given package
2951     function dcopyright () {
2952         emulate -L zsh
2953         if [[ -r /usr/share/doc/$1/copyright ]] ; then
2954             $PAGER /usr/share/doc/$1/copyright
2955         else
2956             echo "No copyright file for package $1 found, sorry."
2957             return 1
2958         fi
2959     }
2960     function _dcopyright () { _files -W /usr/share/doc -/ }
2961     compdef _dcopyright dcopyright
2962
2963     #f3# View upstream's changelog of a given package
2964     function uchange () {
2965         emulate -L zsh
2966         if [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2967             $PAGER /usr/share/doc/$1/changelog.gz
2968         else
2969             echo "No changelog for package $1 found, sorry."
2970             return 1
2971         fi
2972     }
2973     function _uchange () { _files -W /usr/share/doc -/ }
2974     compdef _uchange uchange
2975 fi
2976
2977 # zsh profiling
2978 function profile () {
2979     ZSH_PROFILE_RC=1 zsh "$@"
2980 }
2981
2982 #f1# Edit an alias via zle
2983 function edalias () {
2984     [[ -z "$1" ]] && { echo "Usage: edalias <alias_to_edit>" ; return 1 } || vared aliases'[$1]' ;
2985 }
2986 compdef _aliases edalias
2987
2988 #f1# Edit a function via zle
2989 function edfunc () {
2990     [[ -z "$1" ]] && { echo "Usage: edfunc <function_to_edit>" ; return 1 } || zed -f "$1" ;
2991 }
2992 compdef _functions edfunc
2993
2994 # use it e.g. via 'Restart apache2'
2995 #m# f6 Start() \kbd{service \em{process}}\quad\kbd{start}
2996 #m# f6 Restart() \kbd{service \em{process}}\quad\kbd{restart}
2997 #m# f6 Stop() \kbd{service \em{process}}\quad\kbd{stop}
2998 #m# f6 Reload() \kbd{service \em{process}}\quad\kbd{reload}
2999 #m# f6 Force-Reload() \kbd{service \em{process}}\quad\kbd{force-reload}
3000 #m# f6 Status() \kbd{service \em{process}}\quad\kbd{status}
3001 if [[ -d /etc/init.d || -d /etc/service ]] ; then
3002     function __start_stop () {
3003         local action_="${1:l}"  # e.g Start/Stop/Restart
3004         local service_="$2"
3005         local param_="$3"
3006
3007         local service_target_="$(readlink /etc/init.d/$service_)"
3008         if [[ $service_target_ == "/usr/bin/sv" ]]; then
3009             # runit
3010             case "${action_}" in
3011                 start) if [[ ! -e /etc/service/$service_ ]]; then
3012                            $SUDO ln -s "/etc/sv/$service_" "/etc/service/"
3013                        else
3014                            $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
3015                        fi ;;
3016                 # there is no reload in runits sysv emulation
3017                 reload) $SUDO "/etc/init.d/$service_" "force-reload" "$param_" ;;
3018                 *) $SUDO "/etc/init.d/$service_" "${action_}" "$param_" ;;
3019             esac
3020         else
3021             # sysv/sysvinit-utils, upstart
3022             if check_com -c service ; then
3023               $SUDO service "$service_" "${action_}" "$param_"
3024             else
3025               $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
3026             fi
3027         fi
3028     }
3029
3030     function _grmlinitd () {
3031         local -a scripts
3032         scripts=( /etc/init.d/*(x:t) )
3033         _describe "service startup script" scripts
3034     }
3035
3036     for i in Start Restart Stop Force-Reload Reload Status ; do
3037         eval "function $i () { __start_stop $i \"\$1\" \"\$2\" ; }"
3038         compdef _grmlinitd $i
3039     done
3040     builtin unset -v i
3041 fi
3042
3043 #f1# Provides useful information on globbing
3044 function H-Glob () {
3045     echo -e "
3046     /      directories
3047     .      plain files
3048     @      symbolic links
3049     =      sockets
3050     p      named pipes (FIFOs)
3051     *      executable plain files (0100)
3052     %      device files (character or block special)
3053     %b     block special files
3054     %c     character special files
3055     r      owner-readable files (0400)
3056     w      owner-writable files (0200)
3057     x      owner-executable files (0100)
3058     A      group-readable files (0040)
3059     I      group-writable files (0020)
3060     E      group-executable files (0010)
3061     R      world-readable files (0004)
3062     W      world-writable files (0002)
3063     X      world-executable files (0001)
3064     s      setuid files (04000)
3065     S      setgid files (02000)
3066     t      files with the sticky bit (01000)
3067
3068   print *(m-1)          # Files modified up to a day ago
3069   print *(a1)           # Files accessed a day ago
3070   print *(@)            # Just symlinks
3071   print *(Lk+50)        # Files bigger than 50 kilobytes
3072   print *(Lk-50)        # Files smaller than 50 kilobytes
3073   print **/*.c          # All *.c files recursively starting in \$PWD
3074   print **/*.c~file.c   # Same as above, but excluding 'file.c'
3075   print (foo|bar).*     # Files starting with 'foo' or 'bar'
3076   print *~*.*           # All Files that do not contain a dot
3077   chmod 644 *(.^x)      # make all plain non-executable files publically readable
3078   print -l *(.c|.h)     # Lists *.c and *.h
3079   print **/*(g:users:)  # Recursively match all files that are owned by group 'users'
3080   echo /proc/*/cwd(:h:t:s/self//) # Analogous to >ps ax | awk '{print $1}'<"
3081 }
3082 alias help-zshglob=H-Glob
3083
3084 # grep for running process, like: 'any vim'
3085 function any () {
3086     emulate -L zsh
3087     unsetopt KSH_ARRAYS
3088     if [[ -z "$1" ]] ; then
3089         echo "any - grep for process(es) by keyword" >&2
3090         echo "Usage: any <keyword>" >&2 ; return 1
3091     else
3092         ps xauwww | grep -i "${grep_options[@]}" "[${1[1]}]${1[2,-1]}"
3093     fi
3094 }
3095
3096
3097 # After resuming from suspend, system is paging heavily, leading to very bad interactivity.
3098 # taken from $LINUX-KERNELSOURCE/Documentation/power/swsusp.txt
3099 [[ -r /proc/1/maps ]] && \
3100 function deswap () {
3101     print 'Reading /proc/[0-9]*/maps and sending output to /dev/null, this might take a while.'
3102     cat $(sed -ne 's:.* /:/:p' /proc/[0-9]*/maps | sort -u | grep -v '^/dev/')  > /dev/null
3103     print 'Finished, running "swapoff -a; swapon -a" may also be useful.'
3104 }
3105
3106 # a wrapper for vim, that deals with title setting
3107 #   VIM_OPTIONS
3108 #       set this array to a set of options to vim you always want
3109 #       to have set when calling vim (in .zshrc.local), like:
3110 #           VIM_OPTIONS=( -p )
3111 #       This will cause vim to send every file given on the
3112 #       commandline to be send to it's own tab (needs vim7).
3113 if check_com vim; then
3114     function vim () {
3115         VIM_PLEASE_SET_TITLE='yes' command vim ${VIM_OPTIONS} "$@"
3116     }
3117 fi
3118
3119 ssl_hashes=( sha512 sha256 sha1 md5 )
3120
3121 for sh in ${ssl_hashes}; do
3122     eval 'ssl-cert-'${sh}'() {
3123         emulate -L zsh
3124         if [[ -z $1 ]] ; then
3125             printf '\''usage: %s <file>\n'\'' "ssh-cert-'${sh}'"
3126             return 1
3127         fi
3128         openssl x509 -noout -fingerprint -'${sh}' -in $1
3129     }'
3130 done; unset sh
3131
3132 function ssl-cert-fingerprints () {
3133     emulate -L zsh
3134     local i
3135     if [[ -z $1 ]] ; then
3136         printf 'usage: ssl-cert-fingerprints <file>\n'
3137         return 1
3138     fi
3139     for i in ${ssl_hashes}
3140         do ssl-cert-$i $1;
3141     done
3142 }
3143
3144 function ssl-cert-info () {
3145     emulate -L zsh
3146     if [[ -z $1 ]] ; then
3147         printf 'usage: ssl-cert-info <file>\n'
3148         return 1
3149     fi
3150     openssl x509 -noout -text -in $1
3151     ssl-cert-fingerprints $1
3152 }
3153
3154 # make sure our environment is clean regarding colors
3155 builtin unset -v BLUE RED GREEN CYAN YELLOW MAGENTA WHITE NO_COLOR
3156
3157 # "persistent history"
3158 # just write important commands you always need to $GRML_IMPORTANT_COMMANDS
3159 # defaults for backward compatibility to ~/.important_commands
3160 if [[ -r ~/.important_commands ]] ; then
3161     GRML_IMPORTANT_COMMANDS=~/.important_commands
3162 else
3163     GRML_IMPORTANT_COMMANDS=${GRML_IMPORTANT_COMMANDS:-${ZDOTDIR:-${HOME}}/.important_commands}
3164 fi
3165 [[ -r ${GRML_IMPORTANT_COMMANDS} ]] && builtin fc -R ${GRML_IMPORTANT_COMMANDS}
3166
3167 # load the lookup subsystem if it's available on the system
3168 zrcautoload lookupinit && lookupinit
3169
3170 # variables
3171
3172 # set terminal property (used e.g. by msgid-chooser)
3173 export COLORTERM="yes"
3174
3175 # aliases
3176
3177 # general
3178 #a2# Execute \kbd{du -sch}
3179 [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias da='du -sch'
3180
3181 # listing stuff
3182 #a2# Execute \kbd{ls -lSrah}
3183 alias dir="command ls -lSrah"
3184 #a2# Only show dot-directories
3185 alias lad='command ls -d .*(/)'
3186 #a2# Only show dot-files
3187 alias lsa='command ls -a .*(.)'
3188 #a2# Only files with setgid/setuid/sticky flag
3189 alias lss='command ls -l *(s,S,t)'
3190 #a2# Only show symlinks
3191 alias lsl='command ls -l *(@)'
3192 #a2# Display only executables
3193 alias lsx='command ls -l *(*)'
3194 #a2# Display world-{readable,writable,executable} files
3195 alias lsw='command ls -ld *(R,W,X.^ND/)'
3196 #a2# Display the ten biggest files
3197 alias lsbig="command ls -flh *(.OL[1,10])"
3198 #a2# Only show directories
3199 alias lsd='command ls -d *(/)'
3200 #a2# Only show empty directories
3201 alias lse='command ls -d *(/^F)'
3202 #a2# Display the ten newest files
3203 alias lsnew="command ls -rtlh *(D.om[1,10])"
3204 #a2# Display the ten oldest files
3205 alias lsold="command ls -rtlh *(D.Om[1,10])"
3206 #a2# Display the ten smallest files
3207 alias lssmall="command ls -Srl *(.oL[1,10])"
3208 #a2# Display the ten newest directories and ten newest .directories
3209 alias lsnewdir="command ls -rthdl *(/om[1,10]) .*(D/om[1,10])"
3210 #a2# Display the ten oldest directories and ten oldest .directories
3211 alias lsolddir="command ls -rthdl *(/Om[1,10]) .*(D/Om[1,10])"
3212
3213 # some useful aliases
3214 #a2# Remove current empty directory. Execute \kbd{cd ..; rmdir \$OLDCWD}
3215 alias rmcdir='cd ..; rmdir $OLDPWD || cd $OLDPWD'
3216
3217 #a2# ssh with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
3218 alias insecssh='ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3219 #a2# scp with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
3220 alias insecscp='scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3221
3222 # work around non utf8 capable software in utf environment via $LANG and luit
3223 if check_com isutfenv && check_com luit ; then
3224     if check_com -c mrxvt ; then
3225         isutfenv && [[ -n "$LANG" ]] && \
3226             alias mrxvt="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit mrxvt"
3227     fi
3228
3229     if check_com -c aterm ; then
3230         isutfenv && [[ -n "$LANG" ]] && \
3231             alias aterm="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit aterm"
3232     fi
3233
3234     if check_com -c centericq ; then
3235         isutfenv && [[ -n "$LANG" ]] && \
3236             alias centericq="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit centericq"
3237     fi
3238 fi
3239
3240 # useful functions
3241
3242 #f5# Backup \kbd{file_or_folder {\rm to} file_or_folder\_timestamp}
3243 function bk () {
3244     emulate -L zsh
3245     local current_date=$(date -u "+%Y-%m-%dT%H:%M:%SZ")
3246     local clean keep move verbose result all to_bk
3247     setopt extended_glob
3248     keep=1
3249     while getopts ":hacmrv" opt; do
3250         case $opt in
3251             a) (( all++ ));;
3252             c) unset move clean && (( ++keep ));;
3253             m) unset keep clean && (( ++move ));;
3254             r) unset move keep && (( ++clean ));;
3255             v) verbose="-v";;
3256             h) <<__EOF0__
3257 bk [-hcmv] FILE [FILE ...]
3258 bk -r [-av] [FILE [FILE ...]]
3259 Backup a file or folder in place and append the timestamp
3260 Remove backups of a file or folder, or all backups in the current directory
3261
3262 Usage:
3263 -h    Display this help text
3264 -c    Keep the file/folder as is, create a copy backup using cp(1) (default)
3265 -m    Move the file/folder, using mv(1)
3266 -r    Remove backups of the specified file or directory, using rm(1). If none
3267       is provided, remove all backups in the current directory.
3268 -a    Remove all (even hidden) backups.
3269 -v    Verbose
3270
3271 The -c, -r and -m options are mutually exclusive. If specified at the same time,
3272 the last one is used.
3273
3274 The return code is the sum of all cp/mv/rm return codes.
3275 __EOF0__
3276 return 0;;
3277             \?) bk -h >&2; return 1;;
3278         esac
3279     done
3280     shift "$((OPTIND-1))"
3281     if (( keep > 0 )); then
3282         if islinux || isfreebsd; then
3283             for to_bk in "$@"; do
3284                 cp $verbose -a "${to_bk%/}" "${to_bk%/}_$current_date"
3285                 (( result += $? ))
3286             done
3287         else
3288             for to_bk in "$@"; do
3289                 cp $verbose -pR "${to_bk%/}" "${to_bk%/}_$current_date"
3290                 (( result += $? ))
3291             done
3292         fi
3293     elif (( move > 0 )); then
3294         while (( $# > 0 )); do
3295             mv $verbose "${1%/}" "${1%/}_$current_date"
3296             (( result += $? ))
3297             shift
3298         done
3299     elif (( clean > 0 )); then
3300         if (( $# > 0 )); then
3301             for to_bk in "$@"; do
3302                 rm $verbose -rf "${to_bk%/}"_[0-9](#c4,)-(0[0-9]|1[0-2])-([0-2][0-9]|3[0-1])T([0-1][0-9]|2[0-3])(:[0-5][0-9])(#c2)Z
3303                 (( result += $? ))
3304             done
3305         else
3306             if (( all > 0 )); then
3307                 rm $verbose -rf *_[0-9](#c4,)-(0[0-9]|1[0-2])-([0-2][0-9]|3[0-1])T([0-1][0-9]|2[0-3])(:[0-5][0-9])(#c2)Z(D)
3308             else
3309                 rm $verbose -rf *_[0-9](#c4,)-(0[0-9]|1[0-2])-([0-2][0-9]|3[0-1])T([0-1][0-9]|2[0-3])(:[0-5][0-9])(#c2)Z
3310             fi
3311             (( result += $? ))
3312         fi
3313     fi
3314     return $result
3315 }
3316
3317 #f5# cd to directoy and list files
3318 function cl () {
3319     emulate -L zsh
3320     cd $1 && ls -a
3321 }
3322
3323 # smart cd function, allows switching to /etc when running 'cd /etc/fstab'
3324 function cd () {
3325     if (( ${#argv} == 1 )) && [[ -f ${1} ]]; then
3326         [[ ! -e ${1:h} ]] && return 1
3327         print "Correcting ${1} to ${1:h}"
3328         builtin cd ${1:h}
3329     else
3330         builtin cd "$@"
3331     fi
3332 }
3333
3334 #f5# Create Directoy and \kbd{cd} to it
3335 function mkcd () {
3336     if (( ARGC != 1 )); then
3337         printf 'usage: mkcd <new-directory>\n'
3338         return 1;
3339     fi
3340     if [[ ! -d "$1" ]]; then
3341         command mkdir -p "$1"
3342     else
3343         printf '`%s'\'' already exists: cd-ing.\n' "$1"
3344     fi
3345     builtin cd "$1"
3346 }
3347
3348 #f5# Create temporary directory and \kbd{cd} to it
3349 function cdt () {
3350     builtin cd "$(mktemp -d)"
3351     builtin pwd
3352 }
3353
3354 #f5# List files which have been accessed within the last {\it n} days, {\it n} defaults to 1
3355 function accessed () {
3356     emulate -L zsh
3357     print -l -- *(a-${1:-1})
3358 }
3359
3360 #f5# List files which have been changed within the last {\it n} days, {\it n} defaults to 1
3361 function changed () {
3362     emulate -L zsh
3363     print -l -- *(c-${1:-1})
3364 }
3365
3366 #f5# List files which have been modified within the last {\it n} days, {\it n} defaults to 1
3367 function modified () {
3368     emulate -L zsh
3369     print -l -- *(m-${1:-1})
3370 }
3371 # modified() was named new() in earlier versions, add an alias for backwards compatibility
3372 check_com new || alias new=modified
3373
3374 # use colors when GNU grep with color-support
3375 if (( $#grep_options > 0 )); then
3376     o=${grep_options:+"${grep_options[*]}"}
3377     #a2# Execute \kbd{grep -{}-color=auto}
3378     alias grep='grep '$o
3379     alias egrep='egrep '$o
3380     unset o
3381 fi
3382
3383 # Translate DE<=>EN
3384 # 'translate' looks up a word in a file with language-to-language
3385 # translations (field separator should be " : "). A typical wordlist looks
3386 # like the following:
3387 #  | english-word : german-translation
3388 # It's also only possible to translate english to german but not reciprocal.
3389 # Use the following oneliner to reverse the sort order:
3390 #  $ awk -F ':' '{ print $2" : "$1" "$3 }' \
3391 #    /usr/local/lib/words/en-de.ISO-8859-1.vok > ~/.translate/de-en.ISO-8859-1.vok
3392 #f5# Translates a word
3393 function trans () {
3394     emulate -L zsh
3395     case "$1" in
3396         -[dD]*)
3397             translate -l de-en $2
3398             ;;
3399         -[eE]*)
3400             translate -l en-de $2
3401             ;;
3402         *)
3403             echo "Usage: $0 { -D | -E }"
3404             echo "         -D == German to English"
3405             echo "         -E == English to German"
3406     esac
3407 }
3408
3409 # Usage: simple-extract <file>
3410 # Using option -d deletes the original archive file.
3411 #f5# Smart archive extractor
3412 function simple-extract () {
3413     emulate -L zsh
3414     setopt extended_glob noclobber
3415     local ARCHIVE DELETE_ORIGINAL DECOMP_CMD USES_STDIN USES_STDOUT GZTARGET WGET_CMD
3416     local RC=0
3417     zparseopts -D -E "d=DELETE_ORIGINAL"
3418     for ARCHIVE in "${@}"; do
3419         case $ARCHIVE in
3420             *(tar.bz2|tbz2|tbz))
3421                 DECOMP_CMD="tar -xvjf -"
3422                 USES_STDIN=true
3423                 USES_STDOUT=false
3424                 ;;
3425             *(tar.gz|tgz))
3426                 DECOMP_CMD="tar -xvzf -"
3427                 USES_STDIN=true
3428                 USES_STDOUT=false
3429                 ;;
3430             *(tar.xz|txz|tar.lzma))
3431                 DECOMP_CMD="tar -xvJf -"
3432                 USES_STDIN=true
3433                 USES_STDOUT=false
3434                 ;;
3435             *tar)
3436                 DECOMP_CMD="tar -xvf -"
3437                 USES_STDIN=true
3438                 USES_STDOUT=false
3439                 ;;
3440             *rar)
3441                 DECOMP_CMD="unrar x"
3442                 USES_STDIN=false
3443                 USES_STDOUT=false
3444                 ;;
3445             *lzh)
3446                 DECOMP_CMD="lha x"
3447                 USES_STDIN=false
3448                 USES_STDOUT=false
3449                 ;;
3450             *7z)
3451                 DECOMP_CMD="7z x"
3452                 USES_STDIN=false
3453                 USES_STDOUT=false
3454                 ;;
3455             *(zip|jar))
3456                 DECOMP_CMD="unzip"
3457                 USES_STDIN=false
3458                 USES_STDOUT=false
3459                 ;;
3460             *deb)
3461                 DECOMP_CMD="ar -x"
3462                 USES_STDIN=false
3463                 USES_STDOUT=false
3464                 ;;
3465             *bz2)
3466                 DECOMP_CMD="bzip2 -d -c -"
3467                 USES_STDIN=true
3468                 USES_STDOUT=true
3469                 ;;
3470             *(gz|Z))
3471                 DECOMP_CMD="gzip -d -c -"
3472                 USES_STDIN=true
3473                 USES_STDOUT=true
3474                 ;;
3475             *(xz|lzma))
3476                 DECOMP_CMD="xz -d -c -"
3477                 USES_STDIN=true
3478                 USES_STDOUT=true
3479                 ;;
3480             *)
3481                 print "ERROR: '$ARCHIVE' has unrecognized archive type." >&2
3482                 RC=$((RC+1))
3483                 continue
3484                 ;;
3485         esac
3486
3487         if ! check_com ${DECOMP_CMD[(w)1]}; then
3488             echo "ERROR: ${DECOMP_CMD[(w)1]} not installed." >&2
3489             RC=$((RC+2))
3490             continue
3491         fi
3492
3493         GZTARGET="${ARCHIVE:t:r}"
3494         if [[ -f $ARCHIVE ]] ; then
3495
3496             print "Extracting '$ARCHIVE' ..."
3497             if $USES_STDIN; then
3498                 if $USES_STDOUT; then
3499                     ${=DECOMP_CMD} < "$ARCHIVE" > $GZTARGET
3500                 else
3501                     ${=DECOMP_CMD} < "$ARCHIVE"
3502                 fi
3503             else
3504                 if $USES_STDOUT; then
3505                     ${=DECOMP_CMD} "$ARCHIVE" > $GZTARGET
3506                 else
3507                     ${=DECOMP_CMD} "$ARCHIVE"
3508                 fi
3509             fi
3510             [[ $? -eq 0 && -n "$DELETE_ORIGINAL" ]] && rm -f "$ARCHIVE"
3511
3512         elif [[ "$ARCHIVE" == (#s)(https|http|ftp)://* ]] ; then
3513             if check_com curl; then
3514                 WGET_CMD="curl -L -s -o -"
3515             elif check_com wget; then
3516                 WGET_CMD="wget -q -O -"
3517             elif check_com fetch; then
3518                 WGET_CMD="fetch -q -o -"
3519             else
3520                 print "ERROR: neither wget, curl nor fetch is installed" >&2
3521                 RC=$((RC+4))
3522                 continue
3523             fi
3524             print "Downloading and Extracting '$ARCHIVE' ..."
3525             if $USES_STDIN; then
3526                 if $USES_STDOUT; then
3527                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD} > $GZTARGET
3528                     RC=$((RC+$?))
3529                 else
3530                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD}
3531                     RC=$((RC+$?))
3532                 fi
3533             else
3534                 if $USES_STDOUT; then
3535                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE") > $GZTARGET
3536                 else
3537                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE")
3538                 fi
3539             fi
3540
3541         else
3542             print "ERROR: '$ARCHIVE' is neither a valid file nor a supported URI." >&2
3543             RC=$((RC+8))
3544         fi
3545     done
3546     return $RC
3547 }
3548
3549 function __archive_or_uri () {
3550     _alternative \
3551         'files:Archives:_files -g "*.(#l)(tar.bz2|tbz2|tbz|tar.gz|tgz|tar.xz|txz|tar.lzma|tar|rar|lzh|7z|zip|jar|deb|bz2|gz|Z|xz|lzma)"' \
3552         '_urls:Remote Archives:_urls'
3553 }
3554
3555 function _simple_extract () {
3556     _arguments \
3557         '-d[delete original archivefile after extraction]' \
3558         '*:Archive Or Uri:__archive_or_uri'
3559 }
3560 compdef _simple_extract simple-extract
3561 [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias se=simple-extract
3562
3563 #f5# Change the xterm title from within GNU-screen
3564 function xtrename () {
3565     emulate -L zsh
3566     if [[ $1 != "-f" ]] ; then
3567         if [[ -z ${DISPLAY} ]] ; then
3568             printf 'xtrename only makes sense in X11.\n'
3569             return 1
3570         fi
3571     else
3572         shift
3573     fi
3574     if [[ -z $1 ]] ; then
3575         printf 'usage: xtrename [-f] "title for xterm"\n'
3576         printf '  renames the title of xterm from _within_ screen.\n'
3577         printf '  also works without screen.\n'
3578         printf '  will not work if DISPLAY is unset, use -f to override.\n'
3579         return 0
3580     fi
3581     print -n "\eP\e]0;${1}\C-G\e\\"
3582     return 0
3583 }
3584
3585 # Create small urls via http://goo.gl using curl(1).
3586 # API reference: https://code.google.com/apis/urlshortener/
3587 function zurl () {
3588     emulate -L zsh
3589     setopt extended_glob
3590
3591     if [[ -z $1 ]]; then
3592         print "USAGE: zurl <URL>"
3593         return 1
3594     fi
3595
3596     local PN url prog api json contenttype item
3597     local -a data
3598     PN=$0
3599     url=$1
3600
3601     # Prepend 'http://' to given URL where necessary for later output.
3602     if [[ ${url} != http(s|)://* ]]; then
3603         url='http://'${url}
3604     fi
3605
3606     if check_com -c curl; then
3607         prog=curl
3608     else
3609         print "curl is not available, but mandatory for ${PN}. Aborting."
3610         return 1
3611     fi
3612     api='https://www.googleapis.com/urlshortener/v1/url'
3613     contenttype="Content-Type: application/json"
3614     json="{\"longUrl\": \"${url}\"}"
3615     data=(${(f)"$($prog --silent -H ${contenttype} -d ${json} $api)"})
3616     # Parse the response
3617     for item in "${data[@]}"; do
3618         case "$item" in
3619             ' '#'"id":'*)
3620                 item=${item#*: \"}
3621                 item=${item%\",*}
3622                 printf '%s\n' "$item"
3623                 return 0
3624                 ;;
3625         esac
3626     done
3627     return 1
3628 }
3629
3630 #f2# Find history events by search pattern and list them by date.
3631 function whatwhen () {
3632     emulate -L zsh
3633     local usage help ident format_l format_s first_char remain first last
3634     usage='USAGE: whatwhen [options] <searchstring> <search range>'
3635     help='Use `whatwhen -h'\'' for further explanations.'
3636     ident=${(l,${#${:-Usage: }},, ,)}
3637     format_l="${ident}%s\t\t\t%s\n"
3638     format_s="${format_l//(\\t)##/\\t}"
3639     # Make the first char of the word to search for case
3640     # insensitive; e.g. [aA]
3641     first_char=[${(L)1[1]}${(U)1[1]}]
3642     remain=${1[2,-1]}
3643     # Default search range is `-100'.
3644     first=${2:-\-100}
3645     # Optional, just used for `<first> <last>' given.
3646     last=$3
3647     case $1 in
3648         ("")
3649             printf '%s\n\n' 'ERROR: No search string specified. Aborting.'
3650             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3651         ;;
3652         (-h)
3653             printf '%s\n\n' ${usage}
3654             print 'OPTIONS:'
3655             printf $format_l '-h' 'show help text'
3656             print '\f'
3657             print 'SEARCH RANGE:'
3658             printf $format_l "'0'" 'the whole history,'
3659             printf $format_l '-<n>' 'offset to the current history number; (default: -100)'
3660             printf $format_s '<[-]first> [<last>]' 'just searching within a give range'
3661             printf '\n%s\n' 'EXAMPLES:'
3662             printf ${format_l/(\\t)/} 'whatwhen grml' '# Range is set to -100 by default.'
3663             printf $format_l 'whatwhen zsh -250'
3664             printf $format_l 'whatwhen foo 1 99'
3665         ;;
3666         (\?)
3667             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3668         ;;
3669         (*)
3670             # -l list results on stout rather than invoking $EDITOR.
3671             # -i Print dates as in YYYY-MM-DD.
3672             # -m Search for a - quoted - pattern within the history.
3673             fc -li -m "*${first_char}${remain}*" $first $last
3674         ;;
3675     esac
3676 }
3677
3678 # mercurial related stuff
3679 if check_com -c hg ; then
3680     # gnu like diff for mercurial
3681     # http://www.selenic.com/mercurial/wiki/index.cgi/TipsAndTricks
3682     #f5# GNU like diff for mercurial
3683     function hgdi () {
3684         emulate -L zsh
3685         local i
3686         for i in $(hg status -marn "$@") ; diff -ubwd <(hg cat "$i") "$i"
3687     }
3688
3689     # build debian package
3690     #a2# Alias for \kbd{hg-buildpackage}
3691     alias hbp='hg-buildpackage'
3692
3693     # execute commands on the versioned patch-queue from the current repos
3694     [[ -n "$GRML_NO_SMALL_ALIASES" ]] || alias mq='hg -R $(readlink -f $(hg root)/.hg/patches)'
3695
3696     # diffstat for specific version of a mercurial repository
3697     #   hgstat      => display diffstat between last revision and tip
3698     #   hgstat 1234 => display diffstat between revision 1234 and tip
3699     #f5# Diffstat for specific version of a mercurial repos
3700     function hgstat () {
3701         emulate -L zsh
3702         [[ -n "$1" ]] && hg diff -r $1 -r tip | diffstat || hg export tip | diffstat
3703     }
3704
3705 fi # end of check whether we have the 'hg'-executable
3706
3707 # grml-small cleanups
3708
3709 # The following is used to remove zsh-config-items that do not work
3710 # in grml-small by default.
3711 # If you do not want these adjustments (for whatever reason), set
3712 # $GRMLSMALL_SPECIFIC to 0 in your .zshrc.pre file (which this configuration
3713 # sources if it is there).
3714
3715 if (( GRMLSMALL_SPECIFIC > 0 )) && isgrmlsmall ; then
3716
3717     unset abk[V]
3718     unalias    'V'      &> /dev/null
3719     unfunction vman     &> /dev/null
3720     unfunction viless   &> /dev/null
3721     unfunction 2html    &> /dev/null
3722
3723     # manpages are not in grmlsmall
3724     unfunction manzsh   &> /dev/null
3725     unfunction man2     &> /dev/null
3726
3727 fi
3728
3729 zrclocal
3730
3731 ## genrefcard.pl settings
3732
3733 ### doc strings for external functions from files
3734 #m# f5 grml-wallpaper() Sets a wallpaper (try completion for possible values)
3735
3736 ### example: split functions-search 8,16,24,32
3737 #@# split functions-search 8
3738
3739 ## END OF FILE #################################################################
3740 # vim:filetype=zsh foldmethod=marker autoindent expandtab shiftwidth=4
3741 # Local variables:
3742 # mode: sh
3743 # End: