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