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