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