etc/zsh/zshrc

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