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 zrcautoload add-zsh-hook || add-zsh-hook () { :; }
1675 if [[ $NOPRECMD -gt 0 ]]; then
1676     add-zsh-hook precmd grml_reset_screen_title
1677     add-zsh-hook precmd grml_vcs_to_screen_title
1678 fi
1679
1680 # preexec() => a function running before every command
1681 is4 && [[ $NOPRECMD -eq 0 ]] && \
1682 preexec () {
1683     [[ $NOPRECMD -gt 0 ]] && return 0
1684 # set hostname if not running on host with name 'grml'
1685     if [[ -n "$HOSTNAME" ]] && [[ "$HOSTNAME" != $(hostname) ]] ; then
1686        NAME="@$HOSTNAME"
1687     fi
1688 # get the name of the program currently running and hostname of local machine
1689 # set screen window title if running in a screen
1690     if [[ "$TERM" == screen* ]] ; then
1691         # local CMD=${1[(wr)^(*=*|sudo|ssh|-*)]}       # don't use hostname
1692         local CMD="${1[(wr)^(*=*|sudo|ssh|-*)]}$NAME" # use hostname
1693         ESC_print ${CMD}
1694     fi
1695 # adjust title of xterm
1696     [[ ${NOTITLE} -gt 0 ]] && return 0
1697     case $TERM in
1698         (xterm*|rxvt*)
1699             set_title "${(%):-"%n@%m:"}" "$1"
1700             ;;
1701     esac
1702 }
1703
1704 # 'hash' some often used directories
1705 #d# start
1706 hash -d deb=/var/cache/apt/archives
1707 hash -d doc=/usr/share/doc
1708 hash -d linux=/lib/modules/$(command uname -r)/build/
1709 hash -d log=/var/log
1710 hash -d slog=/var/log/syslog
1711 hash -d src=/usr/src
1712 hash -d templ=/usr/share/doc/grml-templates
1713 hash -d tt=/usr/share/doc/texttools-doc
1714 hash -d www=/var/www
1715 #d# end
1716
1717 # some aliases
1718 if check_com -c screen ; then
1719     if [[ $UID -eq 0 ]] ; then
1720         if [[ -r /etc/grml/screenrc ]]; then
1721             alias screen="${commands[screen]} -c /etc/grml/screenrc"
1722         fi
1723     elif [[ -r $HOME/.screenrc ]] ; then
1724         alias screen="${commands[screen]} -c $HOME/.screenrc"
1725     else
1726         if [[ -r /etc/grml/screenrc_grml ]]; then
1727             alias screen="${commands[screen]} -c /etc/grml/screenrc_grml"
1728         else
1729             if [[ -r /etc/grml/screenrc ]]; then
1730                 alias screen="${commands[screen]} -c /etc/grml/screenrc"
1731             fi
1732         fi
1733     fi
1734 fi
1735
1736 # do we have GNU ls with color-support?
1737 if [[ "$TERM" != dumb ]]; then
1738     #a1# execute \kbd{@a@}:\quad ls with colors
1739     alias ls='ls -b -CF '${ls_options:+"${ls_options[*]}"}
1740     #a1# execute \kbd{@a@}:\quad list all files, with colors
1741     alias la='ls -la '${ls_options:+"${ls_options[*]}"}
1742     #a1# long colored list, without dotfiles (@a@)
1743     alias ll='ls -l '${ls_options:+"${ls_options[*]}"}
1744     #a1# long colored list, human readable sizes (@a@)
1745     alias lh='ls -hAl '${ls_options:+"${ls_options[*]}"}
1746     #a1# List files, append qualifier to filenames \\&\quad(\kbd{/} for directories, \kbd{@} for symlinks ...)
1747     alias l='ls -lF '${ls_options:+"${ls_options[*]}"}
1748 else
1749     alias ls='ls -b -CF'
1750     alias la='ls -la'
1751     alias ll='ls -l'
1752     alias lh='ls -hAl'
1753     alias l='ls -lF'
1754 fi
1755
1756 alias mdstat='cat /proc/mdstat'
1757 alias ...='cd ../../'
1758
1759 # generate alias named "$KERNELVERSION-reboot" so you can use boot with kexec:
1760 if [[ -x /sbin/kexec ]] && [[ -r /proc/cmdline ]] ; then
1761     alias "$(uname -r)-reboot"="kexec -l --initrd=/boot/initrd.img-"$(uname -r)" --command-line=\"$(cat /proc/cmdline)\" /boot/vmlinuz-"$(uname -r)""
1762 fi
1763
1764 # see http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for details
1765 alias term2iso="echo 'Setting terminal to iso mode' ; print -n '\e%@'"
1766 alias term2utf="echo 'Setting terminal to utf-8 mode'; print -n '\e%G'"
1767
1768 # make sure it is not assigned yet
1769 [[ -n ${aliases[utf2iso]} ]] && unalias utf2iso
1770 utf2iso() {
1771     if isutfenv ; then
1772         for ENV in $(env | command grep -i '.utf') ; do
1773             eval export "$(echo $ENV | sed 's/UTF-8/iso885915/ ; s/utf8/iso885915/')"
1774         done
1775     fi
1776 }
1777
1778 # make sure it is not assigned yet
1779 [[ -n ${aliases[iso2utf]} ]] && unalias iso2utf
1780 iso2utf() {
1781     if ! isutfenv ; then
1782         for ENV in $(env | command grep -i '\.iso') ; do
1783             eval export "$(echo $ENV | sed 's/iso.*/UTF-8/ ; s/ISO.*/UTF-8/')"
1784         done
1785     fi
1786 }
1787
1788 # especially for roadwarriors using GNU screen and ssh:
1789 if ! check_com asc &>/dev/null ; then
1790   asc() { autossh -t "$@" 'screen -RdU' }
1791   compdef asc=ssh
1792 fi
1793
1794 #f1# Hints for the use of zsh on grml
1795 zsh-help() {
1796     print "$bg[white]$fg[black]
1797 zsh-help - hints for use of zsh on grml
1798 =======================================$reset_color"
1799
1800     print '
1801 Main configuration of zsh happens in /etc/zsh/zshrc.
1802 That file is part of the package grml-etc-core, if you want to
1803 use them on a non-grml-system just get the tar.gz from
1804 http://deb.grml.org/ or (preferably) get it from the git repository:
1805
1806   http://git.grml.org/f/grml-etc-core/etc/zsh/zshrc
1807
1808 This version of grml'\''s zsh setup does not use skel/.zshrc anymore.
1809 The file is still there, but it is empty for backwards compatibility.
1810
1811 For your own changes use these two files:
1812     $HOME/.zshrc.pre
1813     $HOME/.zshrc.local
1814
1815 The former is sourced very early in our zshrc, the latter is sourced
1816 very lately.
1817
1818 System wide configuration without touching configuration files of grml
1819 can take place in /etc/zsh/zshrc.local.
1820
1821 For information regarding zsh start at http://grml.org/zsh/
1822
1823 Take a look at grml'\''s zsh refcard:
1824 % xpdf =(zcat /usr/share/doc/grml-docs/zsh/grml-zsh-refcard.pdf.gz)
1825
1826 Check out the main zsh refcard:
1827 % '$BROWSER' http://www.bash2zsh.com/zsh_refcard/refcard.pdf
1828
1829 And of course visit the zsh-lovers:
1830 % man zsh-lovers
1831
1832 You can adjust some options through environment variables when
1833 invoking zsh without having to edit configuration files.
1834 Basically meant for bash users who are not used to the power of
1835 the zsh yet. :)
1836
1837   "NOCOR=1    zsh" => deactivate automatic correction
1838   "NOMENU=1   zsh" => do not use auto menu completion
1839                       (note: use ctrl-d for completion instead!)
1840   "NOPRECMD=1 zsh" => disable the precmd + preexec commands (set GNU screen title)
1841   "NOTITLE=1  zsh" => disable setting the title of xterms without disabling
1842                       preexec() and precmd() completely
1843   "BATTERY=1  zsh" => activate battery status (via acpi) on right side of prompt
1844   "COMMAND_NOT_FOUND=1 zsh"
1845                    => Enable a handler if an external command was not found
1846                       The command called in the handler can be altered by setting
1847                       the GRML_ZSH_CNF_HANDLER variable, the default is:
1848                       "/usr/share/command-not-found/command-not-found"
1849
1850 A value greater than 0 is enables a feature; a value equal to zero
1851 disables it. If you like one or the other of these settings, you can
1852 add them to ~/.zshrc.pre to ensure they are set when sourcing grml'\''s
1853 zshrc.'
1854
1855     print "
1856 $bg[white]$fg[black]
1857 Please report wishes + bugs to the grml-team: http://grml.org/bugs/
1858 Enjoy your grml system with the zsh!$reset_color"
1859 }
1860
1861 # debian stuff
1862 if [[ -r /etc/debian_version ]] ; then
1863     #a3# Execute \kbd{apt-cache search}
1864     alias acs='apt-cache search'
1865     #a3# Execute \kbd{apt-cache show}
1866     alias acsh='apt-cache show'
1867     #a3# Execute \kbd{apt-cache policy}
1868     alias acp='apt-cache policy'
1869     #a3# Execute \kbd{apt-get dist-upgrade}
1870     salias adg="apt-get dist-upgrade"
1871     #a3# Execute \kbd{apt-get install}
1872     salias agi="apt-get install"
1873     #a3# Execute \kbd{aptitude install}
1874     salias ati="aptitude install"
1875     #a3# Execute \kbd{apt-get upgrade}
1876     salias ag="apt-get upgrade"
1877     #a3# Execute \kbd{apt-get update}
1878     salias au="apt-get update"
1879     #a3# Execute \kbd{aptitude update ; aptitude safe-upgrade}
1880     salias -a up="aptitude update ; aptitude safe-upgrade"
1881     #a3# Execute \kbd{dpkg-buildpackage}
1882     alias dbp='dpkg-buildpackage'
1883     #a3# Execute \kbd{grep-excuses}
1884     alias ge='grep-excuses'
1885
1886     # get a root shell as normal user in live-cd mode:
1887     if isgrmlcd && [[ $UID -ne 0 ]] ; then
1888        alias su="sudo su"
1889      fi
1890
1891     #a1# Take a look at the syslog: \kbd{\$PAGER /var/log/syslog}
1892     salias llog="$PAGER /var/log/syslog"     # take a look at the syslog
1893     #a1# Take a look at the syslog: \kbd{tail -f /var/log/syslog}
1894     salias tlog="tail -f /var/log/syslog"    # follow the syslog
1895 fi
1896
1897 # sort installed Debian-packages by size
1898 if check_com -c dpkg-query ; then
1899     #a3# List installed Debian-packages sorted by size
1900     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"
1901 fi
1902
1903 # if cdrecord is a symlink (to wodim) or isn't present at all warn:
1904 if [[ -L /usr/bin/cdrecord ]] || ! check_com -c cdrecord; then
1905     if check_com -c wodim; then
1906         cdrecord() {
1907             cat <<EOMESS
1908 cdrecord is not provided under its original name by Debian anymore.
1909 See #377109 in the BTS of Debian for more details.
1910
1911 Please use the wodim binary instead
1912 EOMESS
1913             return 1
1914         }
1915     fi
1916 fi
1917
1918 # Use hard limits, except for a smaller stack and no core dumps
1919 unlimit
1920 is425 && limit stack 8192
1921 isgrmlcd && limit core 0 # important for a live-cd-system
1922 limit -s
1923
1924 # completion system
1925
1926 # called later (via is4 && grmlcomp)
1927 # note: use 'zstyle' for getting current settings
1928 #         press ^xh (control-x h) for getting tags in context; ^x? (control-x ?) to run complete_debug with trace output
1929 grmlcomp() {
1930     # TODO: This could use some additional information
1931
1932     # allow one error for every three characters typed in approximate completer
1933     zstyle ':completion:*:approximate:'    max-errors 'reply=( $((($#PREFIX+$#SUFFIX)/3 )) numeric )'
1934
1935     # don't complete backup files as executables
1936     zstyle ':completion:*:complete:-command-::commands' ignored-patterns '(aptitude-*|*\~)'
1937
1938     # start menu completion only if it could find no unambiguous initial string
1939     zstyle ':completion:*:correct:*'       insert-unambiguous true
1940     zstyle ':completion:*:corrections'     format $'%{\e[0;31m%}%d (errors: %e)%{\e[0m%}'
1941     zstyle ':completion:*:correct:*'       original true
1942
1943     # activate color-completion
1944     zstyle ':completion:*:default'         list-colors ${(s.:.)LS_COLORS}
1945
1946     # format on completion
1947     zstyle ':completion:*:descriptions'    format $'%{\e[0;31m%}completing %B%d%b%{\e[0m%}'
1948
1949     # automatically complete 'cd -<tab>' and 'cd -<ctrl-d>' with menu
1950     # zstyle ':completion:*:*:cd:*:directory-stack' menu yes select
1951
1952     # insert all expansions for expand completer
1953     zstyle ':completion:*:expand:*'        tag-order all-expansions
1954     zstyle ':completion:*:history-words'   list false
1955
1956     # activate menu
1957     zstyle ':completion:*:history-words'   menu yes
1958
1959     # ignore duplicate entries
1960     zstyle ':completion:*:history-words'   remove-all-dups yes
1961     zstyle ':completion:*:history-words'   stop yes
1962
1963     # match uppercase from lowercase
1964     zstyle ':completion:*'                 matcher-list 'm:{a-z}={A-Z}'
1965
1966     # separate matches into groups
1967     zstyle ':completion:*:matches'         group 'yes'
1968     zstyle ':completion:*'                 group-name ''
1969
1970     if [[ "$NOMENU" -eq 0 ]] ; then
1971         # if there are more than 5 options allow selecting from a menu
1972         zstyle ':completion:*'               menu select=5
1973     else
1974         # don't use any menus at all
1975         setopt no_auto_menu
1976     fi
1977
1978     zstyle ':completion:*:messages'        format '%d'
1979     zstyle ':completion:*:options'         auto-description '%d'
1980
1981     # describe options in full
1982     zstyle ':completion:*:options'         description 'yes'
1983
1984     # on processes completion complete all user processes
1985     zstyle ':completion:*:processes'       command 'ps -au$USER'
1986
1987     # offer indexes before parameters in subscripts
1988     zstyle ':completion:*:*:-subscript-:*' tag-order indexes parameters
1989
1990     # provide verbose completion information
1991     zstyle ':completion:*'                 verbose true
1992
1993     # recent (as of Dec 2007) zsh versions are able to provide descriptions
1994     # for commands (read: 1st word in the line) that it will list for the user
1995     # to choose from. The following disables that, because it's not exactly fast.
1996     zstyle ':completion:*:-command-:*:'    verbose false
1997
1998     # set format for warnings
1999     zstyle ':completion:*:warnings'        format $'%{\e[0;31m%}No matches for:%{\e[0m%} %d'
2000
2001     # define files to ignore for zcompile
2002     zstyle ':completion:*:*:zcompile:*'    ignored-patterns '(*~|*.zwc)'
2003     zstyle ':completion:correct:'          prompt 'correct to: %e'
2004
2005     # Ignore completion functions for commands you don't have:
2006     zstyle ':completion::(^approximate*):*:functions' ignored-patterns '_*'
2007
2008     # Provide more processes in completion of programs like killall:
2009     zstyle ':completion:*:processes-names' command 'ps c -u ${USER} -o command | uniq'
2010
2011     # complete manual by their section
2012     zstyle ':completion:*:manuals'    separate-sections true
2013     zstyle ':completion:*:manuals.*'  insert-sections   true
2014     zstyle ':completion:*:man:*'      menu yes select
2015
2016     # Search path for sudo completion
2017     zstyle ':completion:*:sudo:*' command-path /usr/local/sbin \
2018                                                /usr/local/bin  \
2019                                                /usr/sbin       \
2020                                                /usr/bin        \
2021                                                /sbin           \
2022                                                /bin            \
2023                                                /usr/X11R6/bin
2024
2025     # provide .. as a completion
2026     zstyle ':completion:*' special-dirs ..
2027
2028     # run rehash on completion so new installed program are found automatically:
2029     _force_rehash() {
2030         (( CURRENT == 1 )) && rehash
2031         return 1
2032     }
2033
2034     ## correction
2035     # some people don't like the automatic correction - so run 'NOCOR=1 zsh' to deactivate it
2036     if [[ "$NOCOR" -gt 0 ]] ; then
2037         zstyle ':completion:*' completer _oldlist _expand _force_rehash _complete _files _ignored
2038         setopt nocorrect
2039     else
2040         # try to be smart about when to use what completer...
2041         setopt correct
2042         zstyle -e ':completion:*' completer '
2043             if [[ $_last_try != "$HISTNO$BUFFER$CURSOR" ]] ; then
2044                 _last_try="$HISTNO$BUFFER$CURSOR"
2045                 reply=(_complete _match _ignored _prefix _files)
2046             else
2047                 if [[ $words[1] == (rm|mv) ]] ; then
2048                     reply=(_complete _files)
2049                 else
2050                     reply=(_oldlist _expand _force_rehash _complete _ignored _correct _approximate _files)
2051                 fi
2052             fi'
2053     fi
2054
2055     # command for process lists, the local web server details and host completion
2056     zstyle ':completion:*:urls' local 'www' '/var/www/' 'public_html'
2057
2058     # caching
2059     [[ -d $ZSHDIR/cache ]] && zstyle ':completion:*' use-cache yes && \
2060                             zstyle ':completion::complete:*' cache-path $ZSHDIR/cache/
2061
2062     # host completion
2063     if is42 ; then
2064         [[ -r ~/.ssh/known_hosts ]] && _ssh_hosts=(${${${${(f)"$(<$HOME/.ssh/known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _ssh_hosts=()
2065         [[ -r /etc/hosts ]] && : ${(A)_etc_hosts:=${(s: :)${(ps:\t:)${${(f)~~"$(</etc/hosts)"}%%\#*}##[:blank:]#[^[:blank:]]#}}} || _etc_hosts=()
2066     else
2067         _ssh_hosts=()
2068         _etc_hosts=()
2069     fi
2070     hosts=(
2071         $(hostname)
2072         "$_ssh_hosts[@]"
2073         "$_etc_hosts[@]"
2074         localhost
2075     )
2076     zstyle ':completion:*:hosts' hosts $hosts
2077     # TODO: so, why is this here?
2078     #  zstyle '*' hosts $hosts
2079
2080     # use generic completion system for programs not yet defined; (_gnu_generic works
2081     # with commands that provide a --help option with "standard" gnu-like output.)
2082     for compcom in cp deborphan df feh fetchipac head hnb ipacsum mv \
2083                    pal stow tail uname ; do
2084         [[ -z ${_comps[$compcom]} ]] && compdef _gnu_generic ${compcom}
2085     done; unset compcom
2086
2087     # see upgrade function in this file
2088     compdef _hosts upgrade
2089 }
2090
2091 # grmlstuff
2092 grmlstuff() {
2093 # people should use 'grml-x'!
2094     if check_com -c 915resolution; then
2095         855resolution() {
2096             echo "Please use 915resolution as resolution modifying tool for Intel \
2097 graphic chipset."
2098             return -1
2099         }
2100     fi
2101
2102     #a1# Output version of running grml
2103     alias grml-version='cat /etc/grml_version'
2104
2105     if check_com -c rebuildfstab ; then
2106         #a1# Rebuild /etc/fstab
2107         alias grml-rebuildfstab='rebuildfstab -v -r -config'
2108     fi
2109
2110     if check_com -c grml-debootstrap ; then
2111         debian2hd() {
2112             echo "Installing debian to harddisk is possible by using grml-debootstrap."
2113             return 1
2114         }
2115     fi
2116 }
2117
2118 # now run the functions
2119 isgrml && checkhome
2120 is4    && isgrml    && grmlstuff
2121 is4    && grmlcomp
2122
2123 # keephack
2124 is4 && xsource "/etc/zsh/keephack"
2125
2126 # wonderful idea of using "e" glob qualifier by Peter Stephenson
2127 # You use it as follows:
2128 # $ NTREF=/reference/file
2129 # $ ls -l *(e:nt:)
2130 # This lists all the files in the current directory newer than the reference file.
2131 # You can also specify the reference file inline; note quotes:
2132 # $ ls -l *(e:'nt ~/.zshenv':)
2133 is4 && nt() {
2134     if [[ -n $1 ]] ; then
2135         local NTREF=${~1}
2136     fi
2137     [[ $REPLY -nt $NTREF ]]
2138 }
2139
2140 # shell functions
2141
2142 #f1# Reload an autoloadable function
2143 freload() { while (( $# )); do; unfunction $1; autoload -U $1; shift; done }
2144 compdef _functions freload
2145
2146 #f1# List symlinks in detail (more detailed version of 'readlink -f' and 'whence -s')
2147 sll() {
2148     [[ -z "$1" ]] && printf 'Usage: %s <file(s)>\n' "$0" && return 1
2149     for file in "$@" ; do
2150         while [[ -h "$file" ]] ; do
2151             ls -l $file
2152             file=$(readlink "$file")
2153         done
2154     done
2155 }
2156
2157 # TODO: Is it supported to use pager settings like this?
2158 #   PAGER='less -Mr' - If so, the use of $PAGER here needs fixing
2159 # with respect to wordsplitting. (ie. ${=PAGER})
2160 if check_com -c $PAGER ; then
2161     #f1# View Debian's changelog of a given package
2162     dchange() {
2163         emulate -L zsh
2164         if [[ -r /usr/share/doc/$1/changelog.Debian.gz ]] ; then
2165             $PAGER /usr/share/doc/$1/changelog.Debian.gz
2166         elif [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2167             $PAGER /usr/share/doc/$1/changelog.gz
2168         else
2169             if check_com -c aptitude ; then
2170                 echo "No changelog for package $1 found, using aptitude to retrieve it."
2171                 if isgrml ; then
2172                     aptitude -t unstable changelog $1
2173                 else
2174                     aptitude changelog $1
2175                 fi
2176             else
2177                 echo "No changelog for package $1 found, sorry."
2178                 return 1
2179             fi
2180         fi
2181     }
2182     _dchange() { _files -W /usr/share/doc -/ }
2183     compdef _dchange dchange
2184
2185     #f1# View Debian's NEWS of a given package
2186     dnews() {
2187         emulate -L zsh
2188         if [[ -r /usr/share/doc/$1/NEWS.Debian.gz ]] ; then
2189             $PAGER /usr/share/doc/$1/NEWS.Debian.gz
2190         else
2191             if [[ -r /usr/share/doc/$1/NEWS.gz ]] ; then
2192                 $PAGER /usr/share/doc/$1/NEWS.gz
2193             else
2194                 echo "No NEWS file for package $1 found, sorry."
2195                 return 1
2196             fi
2197         fi
2198     }
2199     _dnews() { _files -W /usr/share/doc -/ }
2200     compdef _dnews dnews
2201
2202     #f1# View Debian's copyright of a given package
2203     dcopyright() {
2204         emulate -L zsh
2205         if [[ -r /usr/share/doc/$1/copyright ]] ; then
2206             $PAGER /usr/share/doc/$1/copyright
2207         else
2208             echo "No copyright file for package $1 found, sorry."
2209             return 1
2210         fi
2211     }
2212     _dcopyright() { _files -W /usr/share/doc -/ }
2213     compdef _dcopyright dcopyright
2214
2215     #f1# View upstream's changelog of a given package
2216     uchange() {
2217         emulate -L zsh
2218         if [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2219             $PAGER /usr/share/doc/$1/changelog.gz
2220         else
2221             echo "No changelog for package $1 found, sorry."
2222             return 1
2223         fi
2224     }
2225     _uchange() { _files -W /usr/share/doc -/ }
2226     compdef _uchange uchange
2227 fi
2228
2229 # zsh profiling
2230 profile() {
2231     ZSH_PROFILE_RC=1 $SHELL "$@"
2232 }
2233
2234 #f1# Edit an alias via zle
2235 edalias() {
2236     [[ -z "$1" ]] && { echo "Usage: edalias <alias_to_edit>" ; return 1 } || vared aliases'[$1]' ;
2237 }
2238 compdef _aliases edalias
2239
2240 #f1# Edit a function via zle
2241 edfunc() {
2242     [[ -z "$1" ]] && { echo "Usage: edfunc <function_to_edit>" ; return 1 } || zed -f "$1" ;
2243 }
2244 compdef _functions edfunc
2245
2246 # use it e.g. via 'Restart apache2'
2247 #m# f6 Start() \kbd{/etc/init.d/\em{process}}\quad\kbd{start}
2248 #m# f6 Restart() \kbd{/etc/init.d/\em{process}}\quad\kbd{restart}
2249 #m# f6 Stop() \kbd{/etc/init.d/\em{process}}\quad\kbd{stop}
2250 #m# f6 Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{reload}
2251 #m# f6 Force-Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{force-reload}
2252 #m# f6 Status() \kbd{/etc/init.d/\em{process}}\quad\kbd{status}
2253 if [[ -d /etc/init.d || -d /etc/service ]] ; then
2254     __start_stop() {
2255         local action_="${1:l}"  # e.g Start/Stop/Restart
2256         local service_="$2"
2257         local param_="$3"
2258
2259         local service_target_="$(readlink /etc/init.d/$service_)"
2260         if [[ $service_target_ == "/usr/bin/sv" ]]; then
2261             # runit
2262             case "${action_}" in
2263                 start) if [[ ! -e /etc/service/$service_ ]]; then
2264                            $SUDO ln -s "/etc/sv/$service_" "/etc/service/"
2265                        else
2266                            $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2267                        fi ;;
2268                 # there is no reload in runits sysv emulation
2269                 reload) $SUDO "/etc/init.d/$service_" "force-reload" "$param_" ;;
2270                 *) $SUDO "/etc/init.d/$service_" "${action_}" "$param_" ;;
2271             esac
2272         else
2273             # sysvinit
2274             $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2275         fi
2276     }
2277
2278     _grmlinitd() {
2279         local -a scripts
2280         scripts=( /etc/init.d/*(x:t) )
2281         _describe "service startup script" scripts
2282     }
2283
2284     for i in Start Restart Stop Force-Reload Reload Status ; do
2285         eval "$i() { __start_stop $i \"\$1\" \"\$2\" ; }"
2286         compdef _grmlinitd $i
2287     done
2288 fi
2289
2290 #f1# Provides useful information on globbing
2291 H-Glob() {
2292     echo -e "
2293     /      directories
2294     .      plain files
2295     @      symbolic links
2296     =      sockets
2297     p      named pipes (FIFOs)
2298     *      executable plain files (0100)
2299     %      device files (character or block special)
2300     %b     block special files
2301     %c     character special files
2302     r      owner-readable files (0400)
2303     w      owner-writable files (0200)
2304     x      owner-executable files (0100)
2305     A      group-readable files (0040)
2306     I      group-writable files (0020)
2307     E      group-executable files (0010)
2308     R      world-readable files (0004)
2309     W      world-writable files (0002)
2310     X      world-executable files (0001)
2311     s      setuid files (04000)
2312     S      setgid files (02000)
2313     t      files with the sticky bit (01000)
2314
2315   print *(m-1)          # Files modified up to a day ago
2316   print *(a1)           # Files accessed a day ago
2317   print *(@)            # Just symlinks
2318   print *(Lk+50)        # Files bigger than 50 kilobytes
2319   print *(Lk-50)        # Files smaller than 50 kilobytes
2320   print **/*.c          # All *.c files recursively starting in \$PWD
2321   print **/*.c~file.c   # Same as above, but excluding 'file.c'
2322   print (foo|bar).*     # Files starting with 'foo' or 'bar'
2323   print *~*.*           # All Files that do not contain a dot
2324   chmod 644 *(.^x)      # make all plain non-executable files publically readable
2325   print -l *(.c|.h)     # Lists *.c and *.h
2326   print **/*(g:users:)  # Recursively match all files that are owned by group 'users'
2327   echo /proc/*/cwd(:h:t:s/self//) # Analogous to >ps ax | awk '{print $1}'<"
2328 }
2329 alias help-zshglob=H-Glob
2330
2331 #v1# set number of lines to display per page
2332 HELP_LINES_PER_PAGE=20
2333 #v1# set location of help-zle cache file
2334 HELP_ZLE_CACHE_FILE=~/.cache/zsh_help_zle_lines.zsh
2335 #f1# helper function for help-zle, actually generates the help text
2336 help_zle_parse_keybindings()
2337 {
2338     emulate -L zsh
2339     setopt extendedglob
2340     unsetopt ksharrays  #indexing starts at 1
2341
2342     #v1# choose files that help-zle will parse for keybindings
2343     ((${+HELPZLE_KEYBINDING_FILES})) || HELPZLE_KEYBINDING_FILES=( /etc/zsh/zshrc ~/.zshrc.pre ~/.zshrc ~/.zshrc.local )
2344
2345     if [[ -r $HELP_ZLE_CACHE_FILE ]]; then
2346         local load_cache=0
2347         for f ($HELPZLE_KEYBINDING_FILES) [[ $f -nt $HELP_ZLE_CACHE_FILE ]] && load_cache=1
2348         [[ $load_cache -eq 0 ]] && . $HELP_ZLE_CACHE_FILE && return
2349     fi
2350
2351     #fill with default keybindings, possibly to be overwriten in a file later
2352     #Note that due to zsh inconsistency on escaping assoc array keys, we encase the key in '' which we will remove later
2353     local -A help_zle_keybindings
2354     help_zle_keybindings['<Ctrl>@']="set MARK"
2355     help_zle_keybindings['<Ctrl>x<Ctrl>j']="vi-join lines"
2356     help_zle_keybindings['<Ctrl>x<Ctrl>b']="jump to matching brace"
2357     help_zle_keybindings['<Ctrl>x<Ctrl>u']="undo"
2358     help_zle_keybindings['<Ctrl>_']="undo"
2359     help_zle_keybindings['<Ctrl>x<Ctrl>f<c>']="find <c> in cmdline"
2360     help_zle_keybindings['<Ctrl>a']="goto beginning of line"
2361     help_zle_keybindings['<Ctrl>e']="goto end of line"
2362     help_zle_keybindings['<Ctrl>t']="transpose charaters"
2363     help_zle_keybindings['<Alt>t']="transpose words"
2364     help_zle_keybindings['<Alt>s']="spellcheck word"
2365     help_zle_keybindings['<Ctrl>k']="backward kill buffer"
2366     help_zle_keybindings['<Ctrl>u']="forward kill buffer"
2367     help_zle_keybindings['<Ctrl>y']="insert previously killed word/string"
2368     help_zle_keybindings["<Alt>'"]="quote line"
2369     help_zle_keybindings['<Alt>"']="quote from mark to cursor"
2370     help_zle_keybindings['<Alt><arg>']="repeat next cmd/char <arg> times (<Alt>-<Alt>1<Alt>0a -> -10 times 'a')"
2371     help_zle_keybindings['<Alt>u']="make next word Uppercase"
2372     help_zle_keybindings['<Alt>l']="make next word lowercase"
2373     help_zle_keybindings['<Ctrl>xd']="preview expansion under cursor"
2374     help_zle_keybindings['<Alt>q']="push current CL into background, freeing it. Restore on next CL"
2375     help_zle_keybindings['<Alt>.']="insert (and interate through) last word from prev CLs"
2376     help_zle_keybindings['<Alt>,']="complete word from newer history (consecutive hits)"
2377     help_zle_keybindings['<Alt>m']="repeat last typed word on current CL"
2378     help_zle_keybindings['<Ctrl>v']="insert next keypress symbol literally (e.g. for bindkey)"
2379     help_zle_keybindings['!!:n*<Tab>']="insert last n arguments of last command"
2380     help_zle_keybindings['!!:n-<Tab>']="insert arguments n..N-2 of last command (e.g. mv s s d)"
2381     help_zle_keybindings['<Alt>h']="show help/manpage for current command"
2382
2383     #init global variables
2384     unset help_zle_lines help_zle_sln
2385     typeset -g -a help_zle_lines
2386     typeset -g help_zle_sln=1
2387
2388     local k v
2389     local lastkeybind_desc contents     #last description starting with #k# that we found
2390     local num_lines_elapsed=0            #number of lines between last description and keybinding
2391     #search config files in the order they a called (and thus the order in which they overwrite keybindings)
2392     for f in $HELPZLE_KEYBINDING_FILES; do
2393         [[ -r "$f" ]] || continue   #not readable ? skip it
2394         contents="$(<$f)"
2395         for cline in "${(f)contents}"; do
2396             #zsh pattern: matches lines like: #k# ..............
2397             if [[ "$cline" == (#s)[[:space:]]#\#k\#[[:space:]]##(#b)(*)[[:space:]]#(#e) ]]; then
2398                 lastkeybind_desc="$match[*]"
2399                 num_lines_elapsed=0
2400             #zsh pattern: matches lines that set a keybinding using bindkey or compdef -k
2401             #             ignores lines that are commentend out
2402             #             grabs first in '' or "" enclosed string with length between 1 and 6 characters
2403             elif [[ "$cline" == [^#]#(bindkey|compdef -k)[[:space:]](*)(#b)(\"((?)(#c1,6))\"|\'((?)(#c1,6))\')(#B)(*)  ]]; then
2404                 #description prevously found ? description not more than 2 lines away ? keybinding not empty ?
2405                 if [[ -n $lastkeybind_desc && $num_lines_elapsed -lt 2 && -n $match[1] ]]; then
2406                     #substitute keybinding string with something readable
2407                     k=${${${${${${${match[1]/\\e\^h/<Alt><BS>}/\\e\^\?/<Alt><BS>}/\\e\[5~/<PageUp>}/\\e\[6~/<PageDown>}//(\\e|\^\[)/<Alt>}//\^/<Ctrl>}/3~/<Alt><Del>}
2408                     #put keybinding in assoc array, possibly overwriting defaults or stuff found in earlier files
2409                     #Note that we are extracting the keybinding-string including the quotes (see Note at beginning)
2410                     help_zle_keybindings[${k}]=$lastkeybind_desc
2411                 fi
2412                 lastkeybind_desc=""
2413             else
2414               ((num_lines_elapsed++))
2415             fi
2416         done
2417     done
2418     unset contents
2419     #calculate length of keybinding column
2420     local kstrlen=0
2421     for k (${(k)help_zle_keybindings[@]}) ((kstrlen < ${#k})) && kstrlen=${#k}
2422     #convert the assoc array into preformated lines, which we are able to sort
2423     for k v in ${(kv)help_zle_keybindings[@]}; do
2424         #pad keybinding-string to kstrlen chars and remove outermost characters (i.e. the quotes)
2425         help_zle_lines+=("${(r:kstrlen:)k[2,-2]}${v}")
2426     done
2427     #sort lines alphabetically
2428     help_zle_lines=("${(i)help_zle_lines[@]}")
2429     [[ -d ${HELP_ZLE_CACHE_FILE:h} ]] || mkdir -p "${HELP_ZLE_CACHE_FILE:h}"
2430     echo "help_zle_lines=(${(q)help_zle_lines[@]})" >| $HELP_ZLE_CACHE_FILE
2431     zcompile $HELP_ZLE_CACHE_FILE
2432 }
2433 typeset -g help_zle_sln
2434 typeset -g -a help_zle_lines
2435
2436 #f1# Provides (partially autogenerated) help on keybindings and the zsh line editor
2437 help-zle()
2438 {
2439     emulate -L zsh
2440     unsetopt ksharrays  #indexing starts at 1
2441     #help lines already generated ? no ? then do it
2442     [[ ${+functions[help_zle_parse_keybindings]} -eq 1 ]] && {help_zle_parse_keybindings && unfunction help_zle_parse_keybindings}
2443     #already displayed all lines ? go back to the start
2444     [[ $help_zle_sln -gt ${#help_zle_lines} ]] && help_zle_sln=1
2445     local sln=$help_zle_sln
2446     #note that help_zle_sln is a global var, meaning we remember the last page we viewed
2447     help_zle_sln=$((help_zle_sln + HELP_LINES_PER_PAGE))
2448     zle -M "${(F)help_zle_lines[sln,help_zle_sln-1]}"
2449 }
2450 #k# display help for keybindings and ZLE (cycle pages with consecutive use)
2451 zle -N help-zle && bindkey '^xz' help-zle
2452
2453 # grep for running process, like: 'any vim'
2454 any() {
2455     emulate -L zsh
2456     unsetopt KSH_ARRAYS
2457     if [[ -z "$1" ]] ; then
2458         echo "any - grep for process(es) by keyword" >&2
2459         echo "Usage: any <keyword>" >&2 ; return 1
2460     else
2461         ps xauwww | grep -i "${grep_options[@]}" "[${1[1]}]${1[2,-1]}"
2462     fi
2463 }
2464
2465
2466 # After resuming from suspend, system is paging heavily, leading to very bad interactivity.
2467 # taken from $LINUX-KERNELSOURCE/Documentation/power/swsusp.txt
2468 [[ -r /proc/1/maps ]] && \
2469 deswap() {
2470     print 'Reading /proc/[0-9]*/maps and sending output to /dev/null, this might take a while.'
2471     cat $(sed -ne 's:.* /:/:p' /proc/[0-9]*/maps | sort -u | grep -v '^/dev/')  > /dev/null
2472     print 'Finished, running "swapoff -a; swapon -a" may also be useful.'
2473 }
2474
2475 # a wrapper for vim, that deals with title setting
2476 #   VIM_OPTIONS
2477 #       set this array to a set of options to vim you always want
2478 #       to have set when calling vim (in .zshrc.local), like:
2479 #           VIM_OPTIONS=( -p )
2480 #       This will cause vim to send every file given on the
2481 #       commandline to be send to it's own tab (needs vim7).
2482 if check_com vim; then
2483     vim() {
2484         VIM_PLEASE_SET_TITLE='yes' command vim ${VIM_OPTIONS} "$@"
2485     }
2486 fi
2487
2488 # make a backup of a file
2489 bk() {
2490     cp -a "$1" "${1}_$(date --iso-8601=seconds)"
2491 }
2492
2493 ssl_hashes=( sha512 sha256 sha1 md5 )
2494
2495 for sh in ${ssl_hashes}; do
2496     eval 'ssl-cert-'${sh}'() {
2497         emulate -L zsh
2498         if [[ -z $1 ]] ; then
2499             printf '\''usage: %s <file>\n'\'' "ssh-cert-'${sh}'"
2500             return 1
2501         fi
2502         openssl x509 -noout -fingerprint -'${sh}' -in $1
2503     }'
2504 done; unset sh
2505
2506 ssl-cert-fingerprints() {
2507     emulate -L zsh
2508     local i
2509     if [[ -z $1 ]] ; then
2510         printf 'usage: ssl-cert-fingerprints <file>\n'
2511         return 1
2512     fi
2513     for i in ${ssl_hashes}
2514         do ssl-cert-$i $1;
2515     done
2516 }
2517
2518 ssl-cert-info() {
2519     emulate -L zsh
2520     if [[ -z $1 ]] ; then
2521         printf 'usage: ssl-cert-info <file>\n'
2522         return 1
2523     fi
2524     openssl x509 -noout -text -in $1
2525     ssl-cert-fingerprints $1
2526 }
2527
2528 # make sure our environment is clean regarding colors
2529 for color in BLUE RED GREEN CYAN YELLOW MAGENTA WHITE ; unset $color
2530
2531 # "persistent history"
2532 # just write important commands you always need to ~/.important_commands
2533 if [[ -r ~/.important_commands ]] ; then
2534     fc -R ~/.important_commands
2535 fi
2536
2537 # load the lookup subsystem if it's available on the system
2538 zrcautoload lookupinit && lookupinit
2539
2540 # variables
2541
2542 # set terminal property (used e.g. by msgid-chooser)
2543 export COLORTERM="yes"
2544
2545 # aliases
2546
2547 # general
2548 #a2# Execute \kbd{du -sch}
2549 alias da='du -sch'
2550 #a2# Execute \kbd{jobs -l}
2551 alias j='jobs -l'
2552
2553 # listing stuff
2554 #a2# Execute \kbd{ls -lSrah}
2555 alias dir="ls -lSrah"
2556 #a2# Only show dot-directories
2557 alias lad='ls -d .*(/)'
2558 #a2# Only show dot-files
2559 alias lsa='ls -a .*(.)'
2560 #a2# Only files with setgid/setuid/sticky flag
2561 alias lss='ls -l *(s,S,t)'
2562 #a2# Only show symlinks
2563 alias lsl='ls -l *(@)'
2564 #a2# Display only executables
2565 alias lsx='ls -l *(*)'
2566 #a2# Display world-{readable,writable,executable} files
2567 alias lsw='ls -ld *(R,W,X.^ND/)'
2568 #a2# Display the ten biggest files
2569 alias lsbig="ls -flh *(.OL[1,10])"
2570 #a2# Only show directories
2571 alias lsd='ls -d *(/)'
2572 #a2# Only show empty directories
2573 alias lse='ls -d *(/^F)'
2574 #a2# Display the ten newest files
2575 alias lsnew="ls -rtlh *(D.om[1,10])"
2576 #a2# Display the ten oldest files
2577 alias lsold="ls -rtlh *(D.Om[1,10])"
2578 #a2# Display the ten smallest files
2579 alias lssmall="ls -Srl *(.oL[1,10])"
2580 #a2# Display the ten newest directories and ten newest .directories
2581 alias lsnewdir="ls -rthdl *(/om[1,10]) .*(D/om[1,10])"
2582 #a2# Display the ten oldest directories and ten oldest .directories
2583 alias lsolddir="ls -rthdl *(/Om[1,10]) .*(D/Om[1,10])"
2584
2585 # some useful aliases
2586 #a2# Remove current empty directory. Execute \kbd{cd ..; rmdir $OLDCWD}
2587 alias rmcdir='cd ..; rmdir $OLDPWD || cd $OLDPWD'
2588
2589 #a2# ssh with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
2590 alias insecssh='ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
2591 alias insecscp='scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
2592
2593 # work around non utf8 capable software in utf environment via $LANG and luit
2594 if check_com isutfenv && check_com luit ; then
2595     if check_com -c mrxvt ; then
2596         isutfenv && [[ -n "$LANG" ]] && \
2597             alias mrxvt="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit mrxvt"
2598     fi
2599
2600     if check_com -c aterm ; then
2601         isutfenv && [[ -n "$LANG" ]] && \
2602             alias aterm="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit aterm"
2603     fi
2604
2605     if check_com -c centericq ; then
2606         isutfenv && [[ -n "$LANG" ]] && \
2607             alias centericq="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit centericq"
2608     fi
2609 fi
2610
2611 # useful functions
2612
2613 #f5# Backup \kbd{file {\rm to} file\_timestamp}
2614 bk() {
2615     emulate -L zsh
2616     cp -b $1 $1_`date --iso-8601=m`
2617 }
2618
2619 #f5# cd to directoy and list files
2620 cl() {
2621     emulate -L zsh
2622     cd $1 && ls -a
2623 }
2624
2625 # smart cd function, allows switching to /etc when running 'cd /etc/fstab'
2626 cd() {
2627     if (( ${#argv} == 1 )) && [[ -f ${1} ]]; then
2628         [[ ! -e ${1:h} ]] && return 1
2629         print "Correcting ${1} to ${1:h}"
2630         builtin cd ${1:h}
2631     else
2632         builtin cd "$@"
2633     fi
2634 }
2635
2636 #f5# Create Directoy and \kbd{cd} to it
2637 mkcd() {
2638     if (( ARGC != 1 )); then
2639         printf 'usage: mkcd <new-directory>\n'
2640         return 1;
2641     fi
2642     if [[ ! -d "$1" ]]; then
2643         command mkdir -p "$1"
2644     else
2645         printf '`%s'\'' already exists: cd-ing.\n' "$1"
2646     fi
2647     builtin cd "$1"
2648 }
2649
2650 #f5# Create temporary directory and \kbd{cd} to it
2651 cdt() {
2652     local t
2653     t=$(mktemp -d)
2654     echo "$t"
2655     builtin cd "$t"
2656 }
2657
2658 #f5# Create directory under cursor or the selected area
2659 # Press ctrl-xM to create the directory under the cursor or the selected area.
2660 # To select an area press ctrl-@ or ctrl-space and use the cursor.
2661 # Use case: you type "mv abc ~/testa/testb/testc/" and remember that the
2662 # directory does not exist yet -> press ctrl-XM and problem solved
2663 inplaceMkDirs() {
2664     local PATHTOMKDIR
2665     if ((REGION_ACTIVE==1)); then
2666         local F=$MARK T=$CURSOR
2667         if [[ $F -gt $T ]]; then
2668             F=${CURSOR}
2669             T=${MARK}
2670         fi
2671         # get marked area from buffer and eliminate whitespace
2672         PATHTOMKDIR=${BUFFER[F+1,T]%%[[:space:]]##}
2673         PATHTOMKDIR=${PATHTOMKDIR##[[:space:]]##}
2674     else
2675         local bufwords iword
2676         bufwords=(${(z)LBUFFER})
2677         iword=${#bufwords}
2678         bufwords=(${(z)BUFFER})
2679         PATHTOMKDIR="${(Q)bufwords[iword]}"
2680     fi
2681     [[ -z "${PATHTOMKDIR}" ]] && return 1
2682     PATHTOMKDIR=${~PATHTOMKDIR}
2683     if [[ -e "${PATHTOMKDIR}" ]]; then
2684         zle -M " path already exists, doing nothing"
2685     else
2686         zle -M "$(mkdir -p -v "${PATHTOMKDIR}")"
2687         zle end-of-line
2688     fi
2689 }
2690 #k# mkdir -p <dir> from string under cursor or marked area
2691 zle -N inplaceMkDirs && bindkey '^xM' inplaceMkDirs
2692
2693 #f5# List files which have been accessed within the last {\it n} days, {\it n} defaults to 1
2694 accessed() {
2695     emulate -L zsh
2696     print -l -- *(a-${1:-1})
2697 }
2698
2699 #f5# List files which have been changed within the last {\it n} days, {\it n} defaults to 1
2700 changed() {
2701     emulate -L zsh
2702     print -l -- *(c-${1:-1})
2703 }
2704
2705 #f5# List files which have been modified within the last {\it n} days, {\it n} defaults to 1
2706 modified() {
2707     emulate -L zsh
2708     print -l -- *(m-${1:-1})
2709 }
2710 # modified() was named new() in earlier versions, add an alias for backwards compatibility
2711 check_com new || alias new=modified
2712
2713 # use colors when GNU grep with color-support
2714 #a2# Execute \kbd{grep -{}-color=auto}
2715 (( $#grep_options > 0 )) && alias grep='grep '${grep_options:+"${grep_options[*]}"}
2716
2717 # Translate DE<=>EN
2718 # 'translate' looks up fot a word in a file with language-to-language
2719 # translations (field separator should be " : "). A typical wordlist looks
2720 # like at follows:
2721 #  | english-word : german-transmission
2722 # It's also only possible to translate english to german but not reciprocal.
2723 # Use the following oneliner to turn back the sort order:
2724 #  $ awk -F ':' '{ print $2" : "$1" "$3 }' \
2725 #    /usr/local/lib/words/en-de.ISO-8859-1.vok > ~/.translate/de-en.ISO-8859-1.vok
2726 #f5# Translates a word
2727 trans() {
2728     emulate -L zsh
2729     case "$1" in
2730         -[dD]*)
2731             translate -l de-en $2
2732             ;;
2733         -[eE]*)
2734             translate -l en-de $2
2735             ;;
2736         *)
2737             echo "Usage: $0 { -D | -E }"
2738             echo "         -D == German to English"
2739             echo "         -E == English to German"
2740     esac
2741 }
2742
2743 # Usage: simple-extract <file>
2744 # Using option -d deletes the original archive file.
2745 #f5# Smart archive extractor
2746 simple-extract() {
2747     emulate -L zsh
2748     setopt extended_glob noclobber
2749     local DELETE_ORIGINAL DECOMP_CMD USES_STDIN USES_STDOUT GZTARGET WGET_CMD
2750     local RC=0
2751     zparseopts -D -E "d=DELETE_ORIGINAL"
2752     for ARCHIVE in "${@}"; do
2753         case $ARCHIVE in
2754             *(tar.bz2|tbz2|tbz))
2755                 DECOMP_CMD="tar -xvjf -"
2756                 USES_STDIN=true
2757                 USES_STDOUT=false
2758                 ;;
2759             *(tar.gz|tgz))
2760                 DECOMP_CMD="tar -xvzf -"
2761                 USES_STDIN=true
2762                 USES_STDOUT=false
2763                 ;;
2764             *(tar.xz|txz|tar.lzma))
2765                 DECOMP_CMD="tar -xvJf -"
2766                 USES_STDIN=true
2767                 USES_STDOUT=false
2768                 ;;
2769             *tar)
2770                 DECOMP_CMD="tar -xvf -"
2771                 USES_STDIN=true
2772                 USES_STDOUT=false
2773                 ;;
2774             *rar)
2775                 DECOMP_CMD="unrar x"
2776                 USES_STDIN=false
2777                 USES_STDOUT=false
2778                 ;;
2779             *lzh)
2780                 DECOMP_CMD="lha x"
2781                 USES_STDIN=false
2782                 USES_STDOUT=false
2783                 ;;
2784             *7z)
2785                 DECOMP_CMD="7z x"
2786                 USES_STDIN=false
2787                 USES_STDOUT=false
2788                 ;;
2789             *(zip|jar))
2790                 DECOMP_CMD="unzip"
2791                 USES_STDIN=false
2792                 USES_STDOUT=false
2793                 ;;
2794             *deb)
2795                 DECOMP_CMD="ar -x"
2796                 USES_STDIN=false
2797                 USES_STDOUT=false
2798                 ;;
2799             *bz2)
2800                 DECOMP_CMD="bzip2 -d -c -"
2801                 USES_STDIN=true
2802                 USES_STDOUT=true
2803                 ;;
2804             *(gz|Z))
2805                 DECOMP_CMD="gzip -d -c -"
2806                 USES_STDIN=true
2807                 USES_STDOUT=true
2808                 ;;
2809             *(xz|lzma))
2810                 DECOMP_CMD="xz -d -c -"
2811                 USES_STDIN=true
2812                 USES_STDOUT=true
2813                 ;;
2814             *)
2815                 print "ERROR: '$ARCHIVE' has unrecognized archive type." >&2
2816                 RC=$((RC+1))
2817                 continue
2818                 ;;
2819         esac
2820
2821         if ! check_com ${DECOMP_CMD[(w)1]}; then
2822             echo "ERROR: ${DECOMP_CMD[(w)1]} not installed." >&2
2823             RC=$((RC+2))
2824             continue
2825         fi
2826
2827         GZTARGET="${ARCHIVE:t:r}"
2828         if [[ -f $ARCHIVE ]] ; then
2829
2830             print "Extracting '$ARCHIVE' ..."
2831             if $USES_STDIN; then
2832                 if $USES_STDOUT; then
2833                     ${=DECOMP_CMD} < "$ARCHIVE" > $GZTARGET
2834                 else
2835                     ${=DECOMP_CMD} < "$ARCHIVE"
2836                 fi
2837             else
2838                 if $USES_STDOUT; then
2839                     ${=DECOMP_CMD} "$ARCHIVE" > $GZTARGET
2840                 else
2841                     ${=DECOMP_CMD} "$ARCHIVE"
2842                 fi
2843             fi
2844             [[ $? -eq 0 && -n "$DELETE_ORIGINAL" ]] && rm -f "$ARCHIVE"
2845
2846         elif [[ "$ARCHIVE" == (#s)(https|http|ftp)://* ]] ; then
2847             if check_com curl; then
2848                 WGET_CMD="curl -L -k -s -o -"
2849             elif check_com wget; then
2850                 WGET_CMD="wget -q -O - --no-check-certificate"
2851             else
2852                 print "ERROR: neither wget nor curl is installed" >&2
2853                 RC=$((RC+4))
2854                 continue
2855             fi
2856             print "Downloading and Extracting '$ARCHIVE' ..."
2857             if $USES_STDIN; then
2858                 if $USES_STDOUT; then
2859                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD} > $GZTARGET
2860                     RC=$((RC+$?))
2861                 else
2862                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD}
2863                     RC=$((RC+$?))
2864                 fi
2865             else
2866                 if $USES_STDOUT; then
2867                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE") > $GZTARGET
2868                 else
2869                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE")
2870                 fi
2871             fi
2872
2873         else
2874             print "ERROR: '$ARCHIVE' is neither a valid file nor a supported URI." >&2
2875             RC=$((RC+8))
2876         fi
2877     done
2878     return $RC
2879 }
2880
2881 __archive_or_uri()
2882 {
2883     _alternative \
2884         '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)"' \
2885         '_urls:Remote Archives:_urls'
2886 }
2887
2888 _simple_extract()
2889 {
2890     _arguments \
2891         '-d[delete original archivefile after extraction]' \
2892         '*:Archive Or Uri:__archive_or_uri'
2893 }
2894 compdef _simple_extract simple-extract
2895 alias se=simple-extract
2896
2897 #f5# Set all ulimit parameters to \kbd{unlimited}
2898 allulimit() {
2899     ulimit -c unlimited
2900     ulimit -d unlimited
2901     ulimit -f unlimited
2902     ulimit -l unlimited
2903     ulimit -n unlimited
2904     ulimit -s unlimited
2905     ulimit -t unlimited
2906 }
2907
2908 #f5# Change the xterm title from within GNU-screen
2909 xtrename() {
2910     emulate -L zsh
2911     if [[ $1 != "-f" ]] ; then
2912         if [[ -z ${DISPLAY} ]] ; then
2913             printf 'xtrename only makes sense in X11.\n'
2914             return 1
2915         fi
2916     else
2917         shift
2918     fi
2919     if [[ -z $1 ]] ; then
2920         printf 'usage: xtrename [-f] "title for xterm"\n'
2921         printf '  renames the title of xterm from _within_ screen.\n'
2922         printf '  also works without screen.\n'
2923         printf '  will not work if DISPLAY is unset, use -f to override.\n'
2924         return 0
2925     fi
2926     print -n "\eP\e]0;${1}\C-G\e\\"
2927     return 0
2928 }
2929
2930 # Create small urls via http://goo.gl using curl(1).
2931 # API reference: https://code.google.com/apis/urlshortener/
2932 function zurl() {
2933     emulate -L zsh
2934     setopt extended_glob
2935
2936     if [[ -z $1 ]]; then
2937         print "USAGE: zurl <URL>"
2938         return 1
2939     fi
2940
2941     local PN url prog api json contenttype item
2942     local -a data
2943     PN=$0
2944     url=$1
2945
2946     # Prepend 'http://' to given URL where necessary for later output.
2947     if [[ ${url} != http(s|)://* ]]; then
2948         url='http://'${url}
2949     fi
2950
2951     if check_com -c curl; then
2952         prog=curl
2953     else
2954         print "curl is not available, but mandatory for ${PN}. Aborting."
2955         return 1
2956     fi
2957     api='https://www.googleapis.com/urlshortener/v1/url'
2958     contenttype="Content-Type: application/json"
2959     json="{\"longUrl\": \"${url}\"}"
2960     data=(${(f)"$($prog --silent -H ${contenttype} -d ${json} $api)"})
2961     # Parse the response
2962     for item in "${data[@]}"; do
2963         case "$item" in
2964             ' '#'"id":'*)
2965                 item=${item#*: \"}
2966                 item=${item%\",*}
2967                 printf '%s\n' "$item"
2968                 return 0
2969                 ;;
2970         esac
2971     done
2972     return 1
2973 }
2974
2975 #f2# Find history events by search pattern and list them by date.
2976 whatwhen()  {
2977     emulate -L zsh
2978     local usage help ident format_l format_s first_char remain first last
2979     usage='USAGE: whatwhen [options] <searchstring> <search range>'
2980     help='Use `whatwhen -h'\'' for further explanations.'
2981     ident=${(l,${#${:-Usage: }},, ,)}
2982     format_l="${ident}%s\t\t\t%s\n"
2983     format_s="${format_l//(\\t)##/\\t}"
2984     # Make the first char of the word to search for case
2985     # insensitive; e.g. [aA]
2986     first_char=[${(L)1[1]}${(U)1[1]}]
2987     remain=${1[2,-1]}
2988     # Default search range is `-100'.
2989     first=${2:-\-100}
2990     # Optional, just used for `<first> <last>' given.
2991     last=$3
2992     case $1 in
2993         ("")
2994             printf '%s\n\n' 'ERROR: No search string specified. Aborting.'
2995             printf '%s\n%s\n\n' ${usage} ${help} && return 1
2996         ;;
2997         (-h)
2998             printf '%s\n\n' ${usage}
2999             print 'OPTIONS:'
3000             printf $format_l '-h' 'show help text'
3001             print '\f'
3002             print 'SEARCH RANGE:'
3003             printf $format_l "'0'" 'the whole history,'
3004             printf $format_l '-<n>' 'offset to the current history number; (default: -100)'
3005             printf $format_s '<[-]first> [<last>]' 'just searching within a give range'
3006             printf '\n%s\n' 'EXAMPLES:'
3007             printf ${format_l/(\\t)/} 'whatwhen grml' '# Range is set to -100 by default.'
3008             printf $format_l 'whatwhen zsh -250'
3009             printf $format_l 'whatwhen foo 1 99'
3010         ;;
3011         (\?)
3012             printf '%s\n%s\n\n' ${usage} ${help} && return 1
3013         ;;
3014         (*)
3015             # -l list results on stout rather than invoking $EDITOR.
3016             # -i Print dates as in YYYY-MM-DD.
3017             # -m Search for a - quoted - pattern within the history.
3018             fc -li -m "*${first_char}${remain}*" $first $last
3019         ;;
3020     esac
3021 }
3022
3023 # mercurial related stuff
3024 if check_com -c hg ; then
3025     # gnu like diff for mercurial
3026     # http://www.selenic.com/mercurial/wiki/index.cgi/TipsAndTricks
3027     #f5# GNU like diff for mercurial
3028     hgdi() {
3029         emulate -L zsh
3030         for i in $(hg status -marn "$@") ; diff -ubwd <(hg cat "$i") "$i"
3031     }
3032
3033     # build debian package
3034     #a2# Alias for \kbd{hg-buildpackage}
3035     alias hbp='hg-buildpackage'
3036
3037     # execute commands on the versioned patch-queue from the current repos
3038     alias mq='hg -R $(readlink -f $(hg root)/.hg/patches)'
3039
3040     # diffstat for specific version of a mercurial repository
3041     #   hgstat      => display diffstat between last revision and tip
3042     #   hgstat 1234 => display diffstat between revision 1234 and tip
3043     #f5# Diffstat for specific version of a mercurial repos
3044     hgstat() {
3045         emulate -L zsh
3046         [[ -n "$1" ]] && hg diff -r $1 -r tip | diffstat || hg export tip | diffstat
3047     }
3048
3049 fi # end of check whether we have the 'hg'-executable
3050
3051 # grml-small cleanups
3052
3053 # The following is used to remove zsh-config-items that do not work
3054 # in grml-small by default.
3055 # If you do not want these adjustments (for whatever reason), set
3056 # $GRMLSMALL_SPECIFIC to 0 in your .zshrc.pre file (which this configuration
3057 # sources if it is there).
3058
3059 if (( GRMLSMALL_SPECIFIC > 0 )) && isgrmlsmall ; then
3060
3061     unset abk[V]
3062     unalias    'V'      &> /dev/null
3063     unfunction vman     &> /dev/null
3064     unfunction viless   &> /dev/null
3065     unfunction 2html    &> /dev/null
3066
3067     # manpages are not in grmlsmall
3068     unfunction manzsh   &> /dev/null
3069     unfunction man2     &> /dev/null
3070
3071 fi
3072
3073 zrclocal
3074
3075 ## genrefcard.pl settings
3076
3077 ### doc strings for external functions from files
3078 #m# f5 grml-wallpaper() Sets a wallpaper (try completion for possible values)
3079
3080 ### example: split functions-search 8,16,24,32
3081 #@# split functions-search 8
3082
3083 ## END OF FILE #################################################################
3084 # vim:filetype=zsh foldmethod=marker autoindent expandtab shiftwidth=4
3085 # Local variables:
3086 # mode: sh
3087 # End: