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