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