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 ${HOME}/.zshrc.pre ]] && source ${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 is439(){
 148     [[ $ZSH_VERSION == 4.3.<9->* || $ZSH_VERSION == 4.<4->* \
 149                                  || $ZSH_VERSION == <5->* ]] && return 0
 150     return 1
 151 }
 152
 153 #f1# Checks whether or not you're running grml
 154 isgrml(){
 155     [[ -f /etc/grml_version ]] && return 0
 156     return 1
 157 }
 158
 159 #f1# Checks whether or not you're running a grml cd
 160 isgrmlcd(){
 161     [[ -f /etc/grml_cd ]] && return 0
 162     return 1
 163 }
 164
 165 if isgrml ; then
 166 #f1# Checks whether or not you're running grml-small
 167     isgrmlsmall() {
 168         if [[ ${${${(f)"$(</etc/grml_version)"}%% *}##*-} == 'small' ]]; then
 169             return 0
 170         fi
 171         return 1
 172     }
 173 else
 174     isgrmlsmall() { return 1 }
 175 fi
 176
 177 isdarwin(){
 178     [[ $OSTYPE == darwin* ]] && return 0
 179     return 1
 180 }
 181
 182 #f1# are we running within an utf environment?
 183 isutfenv() {
 184     case "$LANG $CHARSET $LANGUAGE" in
 185         *utf*) return 0 ;;
 186         *UTF*) return 0 ;;
 187         *)     return 1 ;;
 188     esac
 189 }
 190
 191 # check for user, if not running as root set $SUDO to sudo
 192 (( EUID != 0 )) && SUDO='sudo' || SUDO=''
 193
 194 # change directory to home on first invocation of zsh
 195 # important for rungetty -> autologin
 196 # Thanks go to Bart Schaefer!
 197 isgrml && checkhome() {
 198     if [[ -z "$ALREADY_DID_CD_HOME" ]] ; then
 199         export ALREADY_DID_CD_HOME=$HOME
 200         cd
 201     fi
 202 }
 203
 204 # check for zsh v3.1.7+
 205
 206 if ! [[ ${ZSH_VERSION} == 3.1.<7->*      \
 207      || ${ZSH_VERSION} == 3.<2->.<->*    \
 208      || ${ZSH_VERSION} == <4->.<->*   ]] ; then
 209
 210     printf '-!-\n'
 211     printf '-!- In this configuration we try to make use of features, that only\n'
 212     printf '-!- require version 3.1.7 of the shell; That way this setup can be\n'
 213     printf '-!- used with a wide range of zsh versions, while using fairly\n'
 214     printf '-!- advanced features in all supported versions.\n'
 215     printf '-!-\n'
 216     printf '-!- However, you are running zsh version %s.\n' "$ZSH_VERSION"
 217     printf '-!-\n'
 218     printf '-!- While this *may* work, it might as well fail.\n'
 219     printf '-!- Please consider updating to at least version 3.1.7 of zsh.\n'
 220     printf '-!-\n'
 221     printf '-!- DO NOT EXPECT THIS TO WORK FLAWLESSLY!\n'
 222     printf '-!- If it does today, you'\''ve been lucky.\n'
 223     printf '-!-\n'
 224     printf '-!- Ye been warned!\n'
 225     printf '-!-\n'
 226
 227     function zstyle() { : }
 228 fi
 229
 230 # autoload wrapper - use this one instead of autoload directly
 231 # We need to define this function as early as this, because autoloading
 232 # 'is-at-least()' needs it.
 233 function zrcautoload() {
 234     emulate -L zsh
 235     setopt extended_glob
 236     local fdir ffile
 237     local -i ffound
 238
 239     ffile=$1
 240     (( found = 0 ))
 241     for fdir in ${fpath} ; do
 242         [[ -e ${fdir}/${ffile} ]] && (( ffound = 1 ))
 243     done
 244
 245     (( ffound == 0 )) && return 1
 246     if [[ $ZSH_VERSION == 3.1.<6-> || $ZSH_VERSION == <4->* ]] ; then
 247         autoload -U ${ffile} || return 1
 248     else
 249         autoload ${ffile} || return 1
 250     fi
 251     return 0
 252 }
 253
 254 # Load is-at-least() for more precise version checks Note that this test will
 255 # *always* fail, if the is-at-least function could not be marked for
 256 # autoloading.
 257 zrcautoload is-at-least || is-at-least() { return 1 }
 258
 259 # set some important options (as early as possible)
 260
 261 # append history list to the history file; this is the default but we make sure
 262 # because it's required for share_history.
 263 setopt append_history
 264
 265 # import new commands from the history file also in other zsh-session
 266 is4 && setopt share_history
 267
 268 # save each command's beginning timestamp and the duration to the history file
 269 setopt extended_history
 270
 271 # If a new command line being added to the history list duplicates an older
 272 # one, the older command is removed from the list
 273 is4 && setopt histignorealldups
 274
 275 # remove command lines from the history list when the first character on the
 276 # line is a space
 277 setopt histignorespace
 278
 279 # if a command is issued that can't be executed as a normal command, and the
 280 # command is the name of a directory, perform the cd command to that directory.
 281 setopt auto_cd
 282
 283 # in order to use #, ~ and ^ for filename generation grep word
 284 # *~(*.gz|*.bz|*.bz2|*.zip|*.Z) -> searches for word not in compressed files
 285 # don't forget to quote '^', '~' and '#'!
 286 setopt extended_glob
 287
 288 # display PID when suspending processes as well
 289 setopt longlistjobs
 290
 291 # try to avoid the 'zsh: no matches found...'
 292 setopt nonomatch
 293
 294 # report the status of backgrounds jobs immediately
 295 setopt notify
 296
 297 # whenever a command completion is attempted, make sure the entire command path
 298 # is hashed first.
 299 setopt hash_list_all
 300
 301 # not just at the end
 302 setopt completeinword
 303
 304 # Don't send SIGHUP to background processes when the shell exits.
 305 setopt nohup
 306
 307 # make cd push the old directory onto the directory stack.
 308 setopt auto_pushd
 309
 310 # avoid "beep"ing
 311 setopt nobeep
 312
 313 # don't push the same dir twice.
 314 setopt pushd_ignore_dups
 315
 316 # * shouldn't match dotfiles. ever.
 317 setopt noglobdots
 318
 319 # use zsh style word splitting
 320 setopt noshwordsplit
 321
 322 # don't error out when unset parameters are used
 323 setopt unset
 324
 325 # setting some default values
 326 NOCOR=${NOCOR:-0}
 327 NOMENU=${NOMENU:-0}
 328 NOPRECMD=${NOPRECMD:-0}
 329 COMMAND_NOT_FOUND=${COMMAND_NOT_FOUND:-0}
 330 GRML_ZSH_CNF_HANDLER=${GRML_ZSH_CNF_HANDLER:-/usr/share/command-not-found/command-not-found}
 331 BATTERY=${BATTERY:-0}
 332 GRMLSMALL_SPECIFIC=${GRMLSMALL_SPECIFIC:-1}
 333 ZSH_NO_DEFAULT_LOCALE=${ZSH_NO_DEFAULT_LOCALE:-0}
 334
 335 # utility functions
 336 # this function checks if a command exists and returns either true
 337 # or false. This avoids using 'which' and 'whence', which will
 338 # avoid problems with aliases for which on certain weird systems. :-)
 339 # Usage: check_com [-c|-g] word
 340 #   -c  only checks for external commands
 341 #   -g  does the usual tests and also checks for global aliases
 342 check_com() {
 343     emulate -L zsh
 344     local -i comonly gatoo
 345
 346     if [[ $1 == '-c' ]] ; then
 347         (( comonly = 1 ))
 348         shift
 349     elif [[ $1 == '-g' ]] ; then
 350         (( gatoo = 1 ))
 351     else
 352         (( comonly = 0 ))
 353         (( gatoo = 0 ))
 354     fi
 355
 356     if (( ${#argv} != 1 )) ; then
 357         printf 'usage: check_com [-c] <command>\n' >&2
 358         return 1
 359     fi
 360
 361     if (( comonly > 0 )) ; then
 362         [[ -n ${commands[$1]}  ]] && return 0
 363         return 1
 364     fi
 365
 366     if   [[ -n ${commands[$1]}    ]] \
 367       || [[ -n ${functions[$1]}   ]] \
 368       || [[ -n ${aliases[$1]}     ]] \
 369       || [[ -n ${reswords[(r)$1]} ]] ; then
 370
 371         return 0
 372     fi
 373
 374     if (( gatoo > 0 )) && [[ -n ${galiases[$1]} ]] ; then
 375         return 0
 376     fi
 377
 378     return 1
 379 }
 380
 381 # creates an alias and precedes the command with
 382 # sudo if $EUID is not zero.
 383 salias() {
 384     emulate -L zsh
 385     local only=0 ; local multi=0
 386     while [[ $1 == -* ]] ; do
 387         case $1 in
 388             (-o) only=1 ;;
 389             (-a) multi=1 ;;
 390             (--) shift ; break ;;
 391             (-h)
 392                 printf 'usage: salias [-h|-o|-a] <alias-expression>\n'
 393                 printf '  -h      shows this help text.\n'
 394                 printf '  -a      replace '\'' ; '\'' sequences with '\'' ; sudo '\''.\n'
 395                 printf '          be careful using this option.\n'
 396                 printf '  -o      only sets an alias if a preceding sudo would be needed.\n'
 397                 return 0
 398                 ;;
 399             (*) printf "unkown option: '%s'\n" "$1" ; return 1 ;;
 400         esac
 401         shift
 402     done
 403
 404     if (( ${#argv} > 1 )) ; then
 405         printf 'Too many arguments %s\n' "${#argv}"
 406         return 1
 407     fi
 408
 409     key="${1%%\=*}" ;  val="${1#*\=}"
 410     if (( EUID == 0 )) && (( only == 0 )); then
 411         alias -- "${key}=${val}"
 412     elif (( EUID > 0 )) ; then
 413         (( multi > 0 )) && val="${val// ; / ; sudo }"
 414         alias -- "${key}=sudo ${val}"
 415     fi
 416
 417     return 0
 418 }
 419
 420 # a "print -l ${(u)foo}"-workaround for pre-4.2.0 shells
 421 # usage: uprint foo
 422 #   Where foo is the *name* of the parameter you want printed.
 423 #   Note that foo is no typo; $foo would be wrong here!
 424 if ! is42 ; then
 425     uprint () {
 426         emulate -L zsh
 427         local -a u
 428         local w
 429         local parameter=$1
 430
 431         if [[ -z ${parameter} ]] ; then
 432             printf 'usage: uprint <parameter>\n'
 433             return 1
 434         fi
 435
 436         for w in ${(P)parameter} ; do
 437             [[ -z ${(M)u:#$w} ]] && u=( $u $w )
 438         done
 439
 440         builtin print -l $u
 441     }
 442 fi
 443
 444 # Check if we can read given files and source those we can.
 445 xsource() {
 446     if (( ${#argv} < 1 )) ; then
 447         printf 'usage: xsource FILE(s)...\n' >&2
 448         return 1
 449     fi
 450
 451     while (( ${#argv} > 0 )) ; do
 452         [[ -r "$1" ]] && source "$1"
 453         shift
 454     done
 455     return 0
 456 }
 457
 458 # Check if we can read a given file and 'cat(1)' it.
 459 xcat() {
 460     emulate -L zsh
 461     if (( ${#argv} != 1 )) ; then
 462         printf 'usage: xcat FILE\n' >&2
 463         return 1
 464     fi
 465
 466     [[ -r $1 ]] && cat $1
 467     return 0
 468 }
 469
 470 # Remove these functions again, they are of use only in these
 471 # setup files. This should be called at the end of .zshrc.
 472 xunfunction() {
 473     emulate -L zsh
 474     local -a funcs
 475     funcs=(salias xcat xsource xunfunction zrcautoload)
 476
 477     for func in $funcs ; do
 478         [[ -n ${functions[$func]} ]] \
 479             && unfunction $func
 480     done
 481     return 0
 482 }
 483
 484 # this allows us to stay in sync with grml's zshrc and put own
 485 # modifications in ~/.zshrc.local
 486 zrclocal() {
 487     xsource "/etc/zsh/zshrc.local"
 488     xsource "${HOME}/.zshrc.local"
 489     return 0
 490 }
 491
 492 # locale setup
 493 if (( ZSH_NO_DEFAULT_LOCALE == 0 )); then
 494     xsource "/etc/default/locale"
 495 fi
 496
 497 for var in LANG LC_ALL LC_MESSAGES ; do
 498     [[ -n ${(P)var} ]] && export $var
 499 done
 500
 501 xsource "/etc/sysconfig/keyboard"
 502
 503 TZ=$(xcat /etc/timezone)
 504
 505 # set some variables
 506 if check_com -c vim ; then
 507 #v#
 508     export EDITOR=${EDITOR:-vim}
 509 else
 510     export EDITOR=${EDITOR:-vi}
 511 fi
 512
 513 #v#
 514 export PAGER=${PAGER:-less}
 515
 516 #v#
 517 export MAIL=${MAIL:-/var/mail/$USER}
 518
 519 # if we don't set $SHELL then aterm, rxvt,.. will use /bin/sh or /bin/bash :-/
 520 export SHELL='/bin/zsh'
 521
 522 # color setup for ls:
 523 check_com -c dircolors && eval $(dircolors -b)
 524 # color setup for ls on OS X:
 525 isdarwin && export CLICOLOR=1
 526
 527 # do MacPorts setup on darwin
 528 if isdarwin && [[ -d /opt/local ]]; then
 529     # Note: PATH gets set in /etc/zprofile on Darwin, so this can't go into
 530     # zshenv.
 531     PATH="/opt/local/bin:/opt/local/sbin:$PATH"
 532     MANPATH="/opt/local/share/man:$MANPATH"
 533 fi
 534 # do Fink setup on darwin
 535 isdarwin && xsource /sw/bin/init.sh
 536
 537 # load our function and completion directories
 538 for fdir in /usr/share/grml/zsh/completion /usr/share/grml/zsh/functions; do
 539     fpath=( ${fdir} ${fdir}/**/*(/N) ${fpath} )
 540     if [[ ${fpath} == '/usr/share/grml/zsh/functions' ]] ; then
 541         for func in ${fdir}/**/[^_]*[^~](N.) ; do
 542             zrcautoload ${func:t}
 543         done
 544     fi
 545 done
 546 unset fdir func
 547
 548 # support colors in less
 549 export LESS_TERMCAP_mb=$'\E[01;31m'
 550 export LESS_TERMCAP_md=$'\E[01;31m'
 551 export LESS_TERMCAP_me=$'\E[0m'
 552 export LESS_TERMCAP_se=$'\E[0m'
 553 export LESS_TERMCAP_so=$'\E[01;44;33m'
 554 export LESS_TERMCAP_ue=$'\E[0m'
 555 export LESS_TERMCAP_us=$'\E[01;32m'
 556
 557 # mailchecks
 558 MAILCHECK=30
 559
 560 # report about cpu-/system-/user-time of command if running longer than
 561 # 5 seconds
 562 REPORTTIME=5
 563
 564 # watch for everyone but me and root
 565 watch=(notme root)
 566
 567 # automatically remove duplicates from these arrays
 568 typeset -U path cdpath fpath manpath
 569
 570 # keybindings
 571 if [[ "$TERM" != emacs ]] ; then
 572     [[ -z "$terminfo[kdch1]" ]] || bindkey -M emacs "$terminfo[kdch1]" delete-char
 573     [[ -z "$terminfo[khome]" ]] || bindkey -M emacs "$terminfo[khome]" beginning-of-line
 574     [[ -z "$terminfo[kend]"  ]] || bindkey -M emacs "$terminfo[kend]"  end-of-line
 575     [[ -z "$terminfo[kdch1]" ]] || bindkey -M vicmd "$terminfo[kdch1]" vi-delete-char
 576     [[ -z "$terminfo[khome]" ]] || bindkey -M vicmd "$terminfo[khome]" vi-beginning-of-line
 577     [[ -z "$terminfo[kend]"  ]] || bindkey -M vicmd "$terminfo[kend]"  vi-end-of-line
 578     [[ -z "$terminfo[cuu1]"  ]] || bindkey -M viins "$terminfo[cuu1]"  vi-up-line-or-history
 579     [[ -z "$terminfo[cuf1]"  ]] || bindkey -M viins "$terminfo[cuf1]"  vi-forward-char
 580     [[ -z "$terminfo[kcuu1]" ]] || bindkey -M viins "$terminfo[kcuu1]" vi-up-line-or-history
 581     [[ -z "$terminfo[kcud1]" ]] || bindkey -M viins "$terminfo[kcud1]" vi-down-line-or-history
 582     [[ -z "$terminfo[kcuf1]" ]] || bindkey -M viins "$terminfo[kcuf1]" vi-forward-char
 583     [[ -z "$terminfo[kcub1]" ]] || bindkey -M viins "$terminfo[kcub1]" vi-backward-char
 584     # ncurses stuff:
 585     [[ "$terminfo[kcuu1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcuu1]/O/[}" vi-up-line-or-history
 586     [[ "$terminfo[kcud1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcud1]/O/[}" vi-down-line-or-history
 587     [[ "$terminfo[kcuf1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcuf1]/O/[}" vi-forward-char
 588     [[ "$terminfo[kcub1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcub1]/O/[}" vi-backward-char
 589     [[ "$terminfo[khome]" == $'\eO'* ]] && bindkey -M viins "${terminfo[khome]/O/[}" beginning-of-line
 590     [[ "$terminfo[kend]"  == $'\eO'* ]] && bindkey -M viins "${terminfo[kend]/O/[}"  end-of-line
 591     [[ "$terminfo[khome]" == $'\eO'* ]] && bindkey -M emacs "${terminfo[khome]/O/[}" beginning-of-line
 592     [[ "$terminfo[kend]"  == $'\eO'* ]] && bindkey -M emacs "${terminfo[kend]/O/[}"  end-of-line
 593 fi
 594
 595 ## keybindings (run 'bindkeys' for details, more details via man zshzle)
 596 # use emacs style per default:
 597 bindkey -e
 598 # use vi style:
 599 # bindkey -v
 600
 601 ## beginning-of-line OR beginning-of-buffer OR beginning of history
 602 ## by: Bart Schaefer <schaefer@brasslantern.com>, Bernhard Tittelbach
 603 beginning-or-end-of-somewhere() {
 604     local hno=$HISTNO
 605     if [[ ( "${LBUFFER[-1]}" == $'\n' && "${WIDGET}" == beginning-of* ) || \
 606       ( "${RBUFFER[1]}" == $'\n' && "${WIDGET}" == end-of* ) ]]; then
 607         zle .${WIDGET:s/somewhere/buffer-or-history/} "$@"
 608     else
 609         zle .${WIDGET:s/somewhere/line-hist/} "$@"
 610         if (( HISTNO != hno )); then
 611             zle .${WIDGET:s/somewhere/buffer-or-history/} "$@"
 612         fi
 613     fi
 614 }
 615 zle -N beginning-of-somewhere beginning-or-end-of-somewhere
 616 zle -N end-of-somewhere beginning-or-end-of-somewhere
 617
 618
 619 #if [[ "$TERM" == screen ]] ; then
 620
 621 ## with HOME/END, move to beginning/end of line (on multiline) on first keypress
 622 ## to beginning/end of buffer on second keypress
 623 ## and to beginning/end of history on (at most) the third keypress
 624 # terminator & non-debian xterm
 625 bindkey '\eOH' beginning-of-somewhere  # home
 626 bindkey '\eOF' end-of-somewhere        # end
 627 # freebsd console
 628 bindkey '\e[H' beginning-of-somewhere   # home
 629 bindkey '\e[F' end-of-somewhere         # end
 630 # xterm,gnome-terminal,quake,etc
 631 bindkey '^[[1~' beginning-of-somewhere  # home
 632 bindkey '^[[4~' end-of-somewhere        # end
 633 # if terminal type is set to 'rxvt':
 634 bindkey '\e[7~' beginning-of-somewhere  # home
 635 bindkey '\e[8~' end-of-somewhere        # end
 636 #fi
 637
 638 bindkey '\e[A'  up-line-or-search       # cursor up
 639 bindkey '\e[B'  down-line-or-search     # <ESC>-
 640
 641 ## alt-backspace is already the default for backwards-delete-word
 642 ## let's also set alt-delete for deleting current word (right of cursor)
 643 #k# Kill right-side word
 644 bindkey '^[[3~'   delete-word # Modeswitch
 645 bindkey '^[[3;3~' delete-word # Alt_L
 646
 647 ## use Ctrl-left-arrow and Ctrl-right-arrow for jumping to word-beginnings on the CL
 648 bindkey "\e[5C" forward-word
 649 bindkey "\e[5D" backward-word
 650 bindkey "\e[1;5C" forward-word
 651 bindkey "\e[1;5D" backward-word
 652 ## the same for alt-left-arrow and alt-right-arrow
 653 bindkey '^[[1;3C' forward-word
 654 bindkey '^[[1;3D' backward-word
 655
 656 # Search backward in the history for a line beginning with the current
 657 # line up to the cursor and move the cursor to the end of the line then
 658 zle -N history-beginning-search-backward-end history-search-end
 659 zle -N history-beginning-search-forward-end  history-search-end
 660 #k# search history backward for entry beginning with typed text
 661 bindkey '^xp'   history-beginning-search-backward-end
 662 #k# search history forward for entry beginning with typed text
 663 bindkey '^xP'   history-beginning-search-forward-end
 664 #k# search history backward for entry beginning with typed text
 665 bindkey "\e[5~" history-beginning-search-backward-end # PageUp
 666 #k# search history forward for entry beginning with typed text
 667 bindkey "\e[6~" history-beginning-search-forward-end  # PageDown
 668
 669 # bindkey -s '^L' "|less\n"             # ctrl-L pipes to less
 670 # bindkey -s '^B' " &\n"                # ctrl-B runs it in the background
 671
 672 # insert unicode character
 673 # usage example: 'ctrl-x i' 00A7 'ctrl-x i' will give you an §
 674 # See for example http://unicode.org/charts/ for unicode characters code
 675 zrcautoload insert-unicode-char
 676 zle -N insert-unicode-char
 677 #k# Insert Unicode character
 678 bindkey '^Xi' insert-unicode-char
 679
 680 #m# k Shift-tab Perform backwards menu completion
 681 if [[ -n "$terminfo[kcbt]" ]]; then
 682     bindkey "$terminfo[kcbt]" reverse-menu-complete
 683 elif [[ -n "$terminfo[cbt]" ]]; then # required for GNU screen
 684     bindkey "$terminfo[cbt]"  reverse-menu-complete
 685 fi
 686
 687 ## toggle the ,. abbreviation feature on/off
 688 # NOABBREVIATION: default abbreviation-state
 689 #                 0 - enabled (default)
 690 #                 1 - disabled
 691 NOABBREVIATION=${NOABBREVIATION:-0}
 692
 693 grml_toggle_abbrev() {
 694     if (( ${NOABBREVIATION} > 0 )) ; then
 695         NOABBREVIATION=0
 696     else
 697         NOABBREVIATION=1
 698     fi
 699 }
 700
 701 zle -N grml_toggle_abbrev
 702 bindkey '^xA' grml_toggle_abbrev
 703
 704 # add a command line to the shells history without executing it
 705 commit-to-history() {
 706     print -s ${(z)BUFFER}
 707     zle send-break
 708 }
 709 zle -N commit-to-history
 710 bindkey "^x^h" commit-to-history
 711
 712 # only slash should be considered as a word separator:
 713 slash-backward-kill-word() {
 714     local WORDCHARS="${WORDCHARS:s@/@}"
 715     # zle backward-word
 716     zle backward-kill-word
 717 }
 718 zle -N slash-backward-kill-word
 719
 720 #k# Kill left-side word or everything up to next slash
 721 bindkey '\ev' slash-backward-kill-word
 722 #k# Kill left-side word or everything up to next slash
 723 bindkey '\e^h' slash-backward-kill-word
 724 #k# Kill left-side word or everything up to next slash
 725 bindkey '\e^?' slash-backward-kill-word
 726
 727 # use the new *-pattern-* widgets for incremental history search
 728 if is439 ; then
 729     bindkey '^r' history-incremental-pattern-search-backward
 730     bindkey '^s' history-incremental-pattern-search-forward
 731 fi
 732
 733 # a generic accept-line wrapper
 734
 735 # This widget can prevent unwanted autocorrections from command-name
 736 # to _command-name, rehash automatically on enter and call any number
 737 # of builtin and user-defined widgets in different contexts.
 738 #
 739 # For a broader description, see:
 740 # <http://bewatermyfriend.org/posts/2007/12-26.11-50-38-tooltime.html>
 741 #
 742 # The code is imported from the file 'zsh/functions/accept-line' from
 743 # <http://ft.bewatermyfriend.org/comp/zsh/zsh-dotfiles.tar.bz2>, which
 744 # distributed under the same terms as zsh itself.
 745
 746 # A newly added command will may not be found or will cause false
 747 # correction attempts, if you got auto-correction set. By setting the
 748 # following style, we force accept-line() to rehash, if it cannot
 749 # find the first word on the command line in the $command[] hash.
 750 zstyle ':acceptline:*' rehash true
 751
 752 function Accept-Line() {
 753     setopt localoptions noksharrays
 754     local -a subs
 755     local -xi aldone
 756     local sub
 757     local alcontext=${1:-$alcontext}
 758
 759     zstyle -a ":acceptline:${alcontext}" actions subs
 760
 761     (( ${#subs} < 1 )) && return 0
 762
 763     (( aldone = 0 ))
 764     for sub in ${subs} ; do
 765         [[ ${sub} == 'accept-line' ]] && sub='.accept-line'
 766         zle ${sub}
 767
 768         (( aldone > 0 )) && break
 769     done
 770 }
 771
 772 function Accept-Line-getdefault() {
 773     emulate -L zsh
 774     local default_action
 775
 776     zstyle -s ":acceptline:${alcontext}" default_action default_action
 777     case ${default_action} in
 778         ((accept-line|))
 779             printf ".accept-line"
 780             ;;
 781         (*)
 782             printf ${default_action}
 783             ;;
 784     esac
 785 }
 786
 787 function Accept-Line-HandleContext() {
 788     zle Accept-Line
 789
 790     default_action=$(Accept-Line-getdefault)
 791     zstyle -T ":acceptline:${alcontext}" call_default \
 792         && zle ${default_action}
 793 }
 794
 795 function accept-line() {
 796     setopt localoptions noksharrays
 797     local -ax cmdline
 798     local -x alcontext
 799     local buf com fname format msg default_action
 800
 801     alcontext='default'
 802     buf="${BUFFER}"
 803     cmdline=(${(z)BUFFER})
 804     com="${cmdline[1]}"
 805     fname="_${com}"
 806
 807     Accept-Line 'preprocess'
 808
 809     zstyle -t ":acceptline:${alcontext}" rehash \
 810         && [[ -z ${commands[$com]} ]]           \
 811         && rehash
 812
 813     if    [[ -n ${com}               ]] \
 814        && [[ -n ${reswords[(r)$com]} ]] \
 815        || [[ -n ${aliases[$com]}     ]] \
 816        || [[ -n ${functions[$com]}   ]] \
 817        || [[ -n ${builtins[$com]}    ]] \
 818        || [[ -n ${commands[$com]}    ]] ; then
 819
 820         # there is something sensible to execute, just do it.
 821         alcontext='normal'
 822         Accept-Line-HandleContext
 823
 824         return
 825     fi
 826
 827     if    [[ -o correct              ]] \
 828        || [[ -o correctall           ]] \
 829        && [[ -n ${functions[$fname]} ]] ; then
 830
 831         # nothing there to execute but there is a function called
 832         # _command_name; a completion widget. Makes no sense to
 833         # call it on the commandline, but the correct{,all} options
 834         # will ask for it nevertheless, so warn the user.
 835         if [[ ${LASTWIDGET} == 'accept-line' ]] ; then
 836             # Okay, we warned the user before, he called us again,
 837             # so have it his way.
 838             alcontext='force'
 839             Accept-Line-HandleContext
 840
 841             return
 842         fi
 843
 844         if zstyle -t ":acceptline:${alcontext}" nocompwarn ; then
 845             alcontext='normal'
 846             Accept-Line-HandleContext
 847         else
 848             # prepare warning message for the user, configurable via zstyle.
 849             zstyle -s ":acceptline:${alcontext}" compwarnfmt msg
 850
 851             if [[ -z ${msg} ]] ; then
 852                 msg="%c will not execute and completion %f exists."
 853             fi
 854
 855             zformat -f msg "${msg}" "c:${com}" "f:${fname}"
 856
 857             zle -M -- "${msg}"
 858         fi
 859         return
 860     elif [[ -n ${buf//[$' \t\n']##/} ]] ; then
 861         # If we are here, the commandline contains something that is not
 862         # executable, which is neither subject to _command_name correction
 863         # and is not empty. might be a variable assignment
 864         alcontext='misc'
 865         Accept-Line-HandleContext
 866
 867         return
 868     fi
 869
 870     # If we got this far, the commandline only contains whitespace, or is empty.
 871     alcontext='empty'
 872     Accept-Line-HandleContext
 873 }
 874
 875 zle -N accept-line
 876 zle -N Accept-Line
 877 zle -N Accept-Line-HandleContext
 878
 879 # power completion - abbreviation expansion
 880 # power completion / abbreviation expansion / buffer expansion
 881 # see http://zshwiki.org/home/examples/zleiab for details
 882 # less risky than the global aliases but powerful as well
 883 # just type the abbreviation key and afterwards ',.' to expand it
 884 declare -A abk
 885 setopt extendedglob
 886 setopt interactivecomments
 887 abk=(
 888 #   key   # value                  (#d additional doc string)
 889 #A# start
 890     '...'  '../..'
 891     '....' '../../..'
 892     'BG'   '& exit'
 893     'C'    '| wc -l'
 894     'G'    '|& grep --color=auto '
 895     'H'    '| head'
 896     'Hl'   ' --help |& less -r'    #d (Display help in pager)
 897     'L'    '| less'
 898     'LL'   '|& less -r'
 899     'M'    '| most'
 900     'N'    '&>/dev/null'           #d (No Output)
 901     'R'    '| tr A-z N-za-m'       #d (ROT13)
 902     'SL'   '| sort | less'
 903     'S'    '| sort -u'
 904     'T'    '| tail'
 905     'V'    '|& vim -'
 906 #A# end
 907     'co'   './configure && make && sudo make install'
 908 )
 909
 910 zleiab() {
 911     emulate -L zsh
 912     setopt extendedglob
 913     local MATCH
 914
 915     if (( NOABBREVIATION > 0 )) ; then
 916         LBUFFER="${LBUFFER},."
 917         return 0
 918     fi
 919
 920     matched_chars='[.-|_a-zA-Z0-9]#'
 921     LBUFFER=${LBUFFER%%(#m)[.-|_a-zA-Z0-9]#}
 922     LBUFFER+=${abk[$MATCH]:-$MATCH}
 923 }
 924
 925 zle -N zleiab
 926 bindkey ",." zleiab
 927
 928 # autoloading
 929 zrcautoload zmv    # who needs mmv or rename?
 930 zrcautoload history-search-end
 931
 932 # we don't want to quote/espace URLs on our own...
 933 # if autoload -U url-quote-magic ; then
 934 #    zle -N self-insert url-quote-magic
 935 #    zstyle ':url-quote-magic:*' url-metas '*?[]^()~#{}='
 936 # else
 937 #    print 'Notice: no url-quote-magic available :('
 938 # fi
 939 alias url-quote='autoload -U url-quote-magic ; zle -N self-insert url-quote-magic'
 940
 941 #m# k ESC-h Call \kbd{run-help} for the 1st word on the command line
 942 alias run-help >&/dev/null && unalias run-help
 943 for rh in run-help{,-git,-svk,-svn}; do
 944     zrcautoload $rh
 945 done; unset rh
 946
 947 # completion system
 948 if zrcautoload compinit ; then
 949     compinit || print 'Notice: no compinit available :('
 950 else
 951     print 'Notice: no compinit available :('
 952     function zstyle { }
 953     function compdef { }
 954 fi
 955
 956 is4 && zrcautoload zed # use ZLE editor to edit a file or function
 957
 958 is4 && \
 959 for mod in complist deltochar mathfunc ; do
 960     zmodload -i zsh/${mod} 2>/dev/null || print "Notice: no ${mod} available :("
 961 done
 962
 963 # autoload zsh modules when they are referenced
 964 if is4 ; then
 965     zmodload -a  zsh/stat    zstat
 966     zmodload -a  zsh/zpty    zpty
 967     zmodload -ap zsh/mapfile mapfile
 968 fi
 969
 970 if is4 && zrcautoload insert-files && zle -N insert-files ; then
 971     #k# Insert files and test globbing
 972     bindkey "^Xf" insert-files # C-x-f
 973 fi
 974
 975 bindkey ' '   magic-space    # also do history expansion on space
 976 #k# Trigger menu-complete
 977 bindkey '\ei' menu-complete  # menu completion via esc-i
 978
 979 # press esc-e for editing command line in $EDITOR or $VISUAL
 980 if is4 && zrcautoload edit-command-line && zle -N edit-command-line ; then
 981     #k# Edit the current line in \kbd{\$EDITOR}
 982     bindkey '\ee' edit-command-line
 983 fi
 984
 985 if is4 && [[ -n ${(k)modules[zsh/complist]} ]] ; then
 986     #k# menu selection: pick item but stay in the menu
 987     bindkey -M menuselect '\e^M' accept-and-menu-complete
 988     # also use + and INSERT since it's easier to press repeatedly
 989     bindkey -M menuselect "+" accept-and-menu-complete
 990     bindkey -M menuselect "^[[2~" accept-and-menu-complete
 991
 992     # accept a completion and try to complete again by using menu
 993     # completion; very useful with completing directories
 994     # by using 'undo' one's got a simple file browser
 995     bindkey -M menuselect '^o' accept-and-infer-next-history
 996 fi
 997
 998 # press "ctrl-e d" to insert the actual date in the form yyyy-mm-dd
 999 insert-datestamp() { LBUFFER+=${(%):-'%D{%Y-%m-%d}'}; }
1000 zle -N insert-datestamp
1001
1002 #k# Insert a timestamp on the command line (yyyy-mm-dd)
1003 bindkey '^Ed' insert-datestamp
1004
1005 # press esc-m for inserting last typed word again (thanks to caphuso!)
1006 insert-last-typed-word() { zle insert-last-word -- 0 -1 };
1007 zle -N insert-last-typed-word;
1008
1009 #k# Insert last typed word
1010 bindkey "\em" insert-last-typed-word
1011
1012 function grml-zsh-fg() {
1013   if (( ${#jobstates} )); then
1014     zle .push-input
1015     [[ -o hist_ignore_space ]] && BUFFER=' ' || BUFFER=''
1016     BUFFER="${BUFFER}fg"
1017     zle .accept-line
1018   else
1019     zle -M 'No background jobs. Doing nothing.'
1020   fi
1021 }
1022 zle -N grml-zsh-fg
1023 #k# A smart shortcut for \kbd{fg<enter>}
1024 bindkey '^z' grml-zsh-fg
1025
1026 # run command line as user root via sudo:
1027 sudo-command-line() {
1028     [[ -z $BUFFER ]] && zle up-history
1029     if [[ $BUFFER != sudo\ * ]]; then
1030         BUFFER="sudo $BUFFER"
1031         CURSOR=$(( CURSOR+5 ))
1032     fi
1033 }
1034 zle -N sudo-command-line
1035
1036 #k# prepend the current command with "sudo"
1037 bindkey "^Os" sudo-command-line
1038
1039 ### jump behind the first word on the cmdline.
1040 ### useful to add options.
1041 function jump_after_first_word() {
1042     local words
1043     words=(${(z)BUFFER})
1044
1045     if (( ${#words} <= 1 )) ; then
1046         CURSOR=${#BUFFER}
1047     else
1048         CURSOR=${#${words[1]}}
1049     fi
1050 }
1051 zle -N jump_after_first_word
1052 #k# jump to after first word (for adding options)
1053 bindkey '^x1' jump_after_first_word
1054
1055 # complete word from history with menu (from Book: ZSH, OpenSource-Press)
1056 zle -C hist-complete complete-word _generic
1057 zstyle ':completion:hist-complete:*' completer _history
1058 #k# complete word from history with menu
1059 bindkey "^X^X" hist-complete
1060
1061 ## complete word from currently visible Screen or Tmux buffer.
1062 if check_com -c screen || check_com -c tmux; then
1063     _complete_screen_display() {
1064         [[ "$TERM" != "screen" ]] && return 1
1065
1066         local TMPFILE=$(mktemp)
1067         local -U -a _screen_display_wordlist
1068         trap "rm -f $TMPFILE" EXIT
1069
1070         # fill array with contents from screen hardcopy
1071         if ((${+TMUX})); then
1072             #works, but crashes tmux below version 1.4
1073             #luckily tmux -V option to ask for version, was also added in 1.4
1074             tmux -V &>/dev/null || return
1075             tmux -q capture-pane \; save-buffer -b 0 $TMPFILE \; delete-buffer -b 0
1076         else
1077             screen -X hardcopy $TMPFILE
1078             # screen sucks, it dumps in latin1, apparently always. so recode it
1079             # to system charset
1080             check_com recode && recode latin1 $TMPFILE
1081         fi
1082         _screen_display_wordlist=( ${(QQ)$(<$TMPFILE)} )
1083         # remove PREFIX to be completed from that array
1084         _screen_display_wordlist[${_screen_display_wordlist[(i)$PREFIX]}]=""
1085         compadd -a _screen_display_wordlist
1086     }
1087     #k# complete word from currently visible GNU screen buffer
1088     bindkey -r "^XS"
1089     compdef -k _complete_screen_display complete-word '^XS'
1090 fi
1091
1092 # history
1093
1094 ZSHDIR=$HOME/.zsh
1095
1096 #v#
1097 HISTFILE=$HOME/.zsh_history
1098 isgrmlcd && HISTSIZE=500  || HISTSIZE=5000
1099 isgrmlcd && SAVEHIST=1000 || SAVEHIST=10000 # useful for setopt append_history
1100
1101 # dirstack handling
1102
1103 DIRSTACKSIZE=${DIRSTACKSIZE:-20}
1104 DIRSTACKFILE=${DIRSTACKFILE:-${HOME}/.zdirs}
1105
1106 if [[ -f ${DIRSTACKFILE} ]] && [[ ${#dirstack[*]} -eq 0 ]] ; then
1107     dirstack=( ${(f)"$(< $DIRSTACKFILE)"} )
1108     # "cd -" won't work after login by just setting $OLDPWD, so
1109     [[ -d $dirstack[1] ]] && cd $dirstack[1] && cd $OLDPWD
1110 fi
1111
1112 chpwd() {
1113     local -ax my_stack
1114     my_stack=( ${PWD} ${dirstack} )
1115     if is42 ; then
1116         builtin print -l ${(u)my_stack} >! ${DIRSTACKFILE}
1117     else
1118         uprint my_stack >! ${DIRSTACKFILE}
1119     fi
1120 }
1121
1122 # directory based profiles
1123
1124 if is433 ; then
1125
1126 CHPWD_PROFILE='default'
1127 function chpwd_profiles() {
1128     # Say you want certain settings to be active in certain directories.
1129     # This is what you want.
1130     #
1131     # zstyle ':chpwd:profiles:/usr/src/grml(|/|/*)'   profile grml
1132     # zstyle ':chpwd:profiles:/usr/src/debian(|/|/*)' profile debian
1133     #
1134     # When that's done and you enter a directory that matches the pattern
1135     # in the third part of the context, a function called chpwd_profile_grml,
1136     # for example, is called (if it exists).
1137     #
1138     # If no pattern matches (read: no profile is detected) the profile is
1139     # set to 'default', which means chpwd_profile_default is attempted to
1140     # be called.
1141     #
1142     # A word about the context (the ':chpwd:profiles:*' stuff in the zstyle
1143     # command) which is used: The third part in the context is matched against
1144     # ${PWD}. That's why using a pattern such as /foo/bar(|/|/*) makes sense.
1145     # Because that way the profile is detected for all these values of ${PWD}:
1146     #   /foo/bar
1147     #   /foo/bar/
1148     #   /foo/bar/baz
1149     # So, if you want to make double damn sure a profile works in /foo/bar
1150     # and everywhere deeper in that tree, just use (|/|/*) and be happy.
1151     #
1152     # The name of the detected profile will be available in a variable called
1153     # 'profile' in your functions. You don't need to do anything, it'll just
1154     # be there.
1155     #
1156     # Then there is the parameter $CHPWD_PROFILE is set to the profile, that
1157     # was is currently active. That way you can avoid running code for a
1158     # profile that is already active, by running code such as the following
1159     # at the start of your function:
1160     #
1161     # function chpwd_profile_grml() {
1162     #     [[ ${profile} == ${CHPWD_PROFILE} ]] && return 1
1163     #   ...
1164     # }
1165     #
1166     # The initial value for $CHPWD_PROFILE is 'default'.
1167     #
1168     # Version requirement:
1169     #   This feature requires zsh 4.3.3 or newer.
1170     #   If you use this feature and need to know whether it is active in your
1171     #   current shell, there are several ways to do that. Here are two simple
1172     #   ways:
1173     #
1174     #   a) If knowing if the profiles feature is active when zsh starts is
1175     #      good enough for you, you can put the following snippet into your
1176     #      .zshrc.local:
1177     #
1178     #   (( ${+functions[chpwd_profiles]} )) && print "directory profiles active"
1179     #
1180     #   b) If that is not good enough, and you would prefer to be notified
1181     #      whenever a profile changes, you can solve that by making sure you
1182     #      start *every* profile function you create like this:
1183     #
1184     #   function chpwd_profile_myprofilename() {
1185     #       [[ ${profile} == ${CHPWD_PROFILE} ]] && return 1
1186     #       print "chpwd(): Switching to profile: $profile"
1187     #     ...
1188     #   }
1189     #
1190     #      That makes sure you only get notified if a profile is *changed*,
1191     #      not everytime you change directory, which would probably piss
1192     #      you off fairly quickly. :-)
1193     #
1194     # There you go. Now have fun with that.
1195     local -x profile
1196
1197     zstyle -s ":chpwd:profiles:${PWD}" profile profile || profile='default'
1198     if (( ${+functions[chpwd_profile_$profile]} )) ; then
1199         chpwd_profile_${profile}
1200     fi
1201
1202     CHPWD_PROFILE="${profile}"
1203     return 0
1204 }
1205 chpwd_functions=( ${chpwd_functions} chpwd_profiles )
1206
1207 fi # is433
1208
1209 # display battery status on right side of prompt via running 'BATTERY=1 zsh'
1210 if [[ $BATTERY -gt 0 ]] ; then
1211     if ! check_com -c acpi ; then
1212         BATTERY=0
1213     fi
1214 fi
1215
1216 battery() {
1217 if [[ $BATTERY -gt 0 ]] ; then
1218     PERCENT="${${"$(acpi 2>/dev/null)"}/(#b)[[:space:]]#Battery <->: [^0-9]##, (<->)%*/${match[1]}}"
1219     if [[ -z "$PERCENT" ]] ; then
1220         PERCENT='acpi not present'
1221     else
1222         if [[ "$PERCENT" -lt 20 ]] ; then
1223             PERCENT="warning: ${PERCENT}%%"
1224         else
1225             PERCENT="${PERCENT}%%"
1226         fi
1227     fi
1228 fi
1229 }
1230 # set colors for use in prompts
1231 if zrcautoload colors && colors 2>/dev/null ; then
1232     BLUE="%{${fg[blue]}%}"
1233     RED="%{${fg_bold[red]}%}"
1234     GREEN="%{${fg[green]}%}"
1235     CYAN="%{${fg[cyan]}%}"
1236     MAGENTA="%{${fg[magenta]}%}"
1237     YELLOW="%{${fg[yellow]}%}"
1238     WHITE="%{${fg[white]}%}"
1239     NO_COLOUR="%{${reset_color}%}"
1240 else
1241     BLUE=$'%{\e[1;34m%}'
1242     RED=$'%{\e[1;31m%}'
1243     GREEN=$'%{\e[1;32m%}'
1244     CYAN=$'%{\e[1;36m%}'
1245     WHITE=$'%{\e[1;37m%}'
1246     MAGENTA=$'%{\e[1;35m%}'
1247     YELLOW=$'%{\e[1;33m%}'
1248     NO_COLOUR=$'%{\e[0m%}'
1249 fi
1250
1251 # gather version control information for inclusion in a prompt
1252
1253 if zrcautoload vcs_info; then
1254     # `vcs_info' in zsh versions 4.3.10 and below have a broken `_realpath'
1255     # function, which can cause a lot of trouble with our directory-based
1256     # profiles. So:
1257     if [[ ${ZSH_VERSION} == 4.3.<-10> ]] ; then
1258         function VCS_INFO_realpath () {
1259             setopt localoptions NO_shwordsplit chaselinks
1260             ( builtin cd -q $1 2> /dev/null && pwd; )
1261         }
1262     fi
1263
1264     zstyle ':vcs_info:*' max-exports 2
1265
1266     if [[ -o restricted ]]; then
1267         zstyle ':vcs_info:*' enable NONE
1268     fi
1269 fi
1270
1271 # Change vcs_info formats for the grml prompt. The 2nd format sets up
1272 # $vcs_info_msg_1_ to contain "zsh: repo-name" used to set our screen title.
1273 # TODO: The included vcs_info() version still uses $VCS_INFO_message_N_.
1274 #       That needs to be the use of $VCS_INFO_message_N_ needs to be changed
1275 #       to $vcs_info_msg_N_ as soon as we use the included version.
1276 if [[ "$TERM" == dumb ]] ; then
1277     zstyle ':vcs_info:*' actionformats "(%s%)-[%b|%a] " "zsh: %r"
1278     zstyle ':vcs_info:*' formats       "(%s%)-[%b] "    "zsh: %r"
1279 else
1280     # these are the same, just with a lot of colours:
1281     zstyle ':vcs_info:*' actionformats "${MAGENTA}(${NO_COLOUR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${YELLOW}|${RED}%a${MAGENTA}]${NO_COLOUR} " \
1282                                        "zsh: %r"
1283     zstyle ':vcs_info:*' formats       "${MAGENTA}(${NO_COLOUR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${MAGENTA}]${NO_COLOUR}%} " \
1284                                        "zsh: %r"
1285     zstyle ':vcs_info:(sv[nk]|bzr):*' branchformat "%b${RED}:${YELLOW}%r"
1286 fi
1287
1288 # command not found handling
1289
1290 (( ${COMMAND_NOT_FOUND} == 1 )) &&
1291 function command_not_found_handler() {
1292     emulate -L zsh
1293     if [[ -x ${GRML_ZSH_CNF_HANDLER} ]] ; then
1294         ${GRML_ZSH_CNF_HANDLER} $1
1295     fi
1296     return 1
1297 }
1298
1299 # set prompt
1300 if zrcautoload promptinit && promptinit 2>/dev/null ; then
1301     promptinit # people should be able to use their favourite prompt
1302 else
1303     print 'Notice: no promptinit available :('
1304 fi
1305
1306 setopt prompt_subst
1307
1308 # make sure to use right prompt only when not running a command
1309 is41 && setopt transient_rprompt
1310
1311
1312 function ESC_print () {
1313     info_print $'\ek' $'\e\\' "$@"
1314 }
1315 function set_title () {
1316     info_print  $'\e]0;' $'\a' "$@"
1317 }
1318
1319 function info_print () {
1320     local esc_begin esc_end
1321     esc_begin="$1"
1322     esc_end="$2"
1323     shift 2
1324     printf '%s' ${esc_begin}
1325     printf '%s' "$*"
1326     printf '%s' "${esc_end}"
1327 }
1328
1329 # TODO: revise all these NO* variables and especially their documentation
1330 #       in zsh-help() below.
1331 is4 && [[ $NOPRECMD -eq 0 ]] && precmd () {
1332     [[ $NOPRECMD -gt 0 ]] && return 0
1333     # update VCS information
1334     (( ${+functions[vcs_info]} )) && vcs_info
1335
1336     if [[ $TERM == screen* ]] ; then
1337         if [[ -n ${vcs_info_msg_1_} ]] ; then
1338             ESC_print ${vcs_info_msg_1_}
1339         else
1340             ESC_print "zsh"
1341         fi
1342     fi
1343     # just use DONTSETRPROMPT=1 to be able to overwrite RPROMPT
1344     if [[ ${DONTSETRPROMPT:-} -eq 0 ]] ; then
1345         if [[ $BATTERY -gt 0 ]] ; then
1346             # update battery (dropped into $PERCENT) information
1347             battery
1348             RPROMPT="%(?..:() ${PERCENT}"
1349         else
1350             RPROMPT="%(?..:() "
1351         fi
1352     fi
1353     # adjust title of xterm
1354     # see http://www.faqs.org/docs/Linux-mini/Xterm-Title.html
1355     [[ ${NOTITLE:-} -gt 0 ]] && return 0
1356     case $TERM in
1357         (xterm*|rxvt*)
1358             set_title ${(%):-"%n@%m: %~"}
1359             ;;
1360     esac
1361 }
1362
1363 # preexec() => a function running before every command
1364 is4 && [[ $NOPRECMD -eq 0 ]] && \
1365 preexec () {
1366     [[ $NOPRECMD -gt 0 ]] && return 0
1367 # set hostname if not running on host with name 'grml'
1368     if [[ -n "$HOSTNAME" ]] && [[ "$HOSTNAME" != $(hostname) ]] ; then
1369        NAME="@$HOSTNAME"
1370     fi
1371 # get the name of the program currently running and hostname of local machine
1372 # set screen window title if running in a screen
1373     if [[ "$TERM" == screen* ]] ; then
1374         # local CMD=${1[(wr)^(*=*|sudo|ssh|-*)]}       # don't use hostname
1375         local CMD="${1[(wr)^(*=*|sudo|ssh|-*)]}$NAME" # use hostname
1376         ESC_print ${CMD}
1377     fi
1378 # adjust title of xterm
1379     [[ ${NOTITLE} -gt 0 ]] && return 0
1380     case $TERM in
1381         (xterm*|rxvt*)
1382             set_title "${(%):-"%n@%m:"}" "$1"
1383             ;;
1384     esac
1385 }
1386
1387 EXITCODE="%(?..%?%1v )"
1388 # secondary prompt, printed when the shell needs more information to complete a
1389 # command.
1390 PS2='\`%_> '
1391 # selection prompt used within a select loop.
1392 PS3='?# '
1393 # the execution trace prompt (setopt xtrace). default: '+%N:%i>'
1394 PS4='+%N:%i:%_> '
1395
1396 # set variable debian_chroot if running in a chroot with /etc/debian_chroot
1397 if [[ -z "$debian_chroot" ]] && [[ -r /etc/debian_chroot ]] ; then
1398     debian_chroot=$(cat /etc/debian_chroot)
1399 fi
1400
1401 # don't use colors on dumb terminals (like emacs):
1402 if [[ "$TERM" == dumb ]] ; then
1403     PROMPT="${EXITCODE}${debian_chroot:+($debian_chroot)}%n@%m %40<...<%B%~%b%<< "
1404 else
1405     # only if $GRMLPROMPT is set (e.g. via 'GRMLPROMPT=1 zsh') use the extended
1406     # prompt set variable identifying the chroot you work in (used in the
1407     # prompt below)
1408     if [[ $GRMLPROMPT -gt 0 ]] ; then
1409         PROMPT="${RED}${EXITCODE}${CYAN}[%j running job(s)] ${GREEN}{history#%!} ${RED}%(3L.+.) ${BLUE}%* %D
1410 ${BLUE}%n${NO_COLOUR}@%m %40<...<%B%~%b%<< "
1411     else
1412         # This assembles the primary prompt string
1413         if (( EUID != 0 )); then
1414             PROMPT="${RED}${EXITCODE}${WHITE}${debian_chroot:+($debian_chroot)}${BLUE}%n${NO_COLOUR}@%m %40<...<%B%~%b%<< "
1415         else
1416             PROMPT="${BLUE}${EXITCODE}${WHITE}${debian_chroot:+($debian_chroot)}${RED}%n${NO_COLOUR}@%m %40<...<%B%~%b%<< "
1417         fi
1418     fi
1419 fi
1420
1421 PROMPT="${PROMPT}"'${vcs_info_msg_0_}'"%# "
1422
1423 # if we are inside a grml-chroot set a specific prompt theme
1424 if [[ -n "$GRML_CHROOT" ]] ; then
1425     PROMPT="%{$fg[red]%}(CHROOT) %{$fg_bold[red]%}%n%{$fg_no_bold[white]%}@%m %40<...<%B%~%b%<< %\# "
1426 fi
1427
1428 # 'hash' some often used directories
1429 #d# start
1430 hash -d deb=/var/cache/apt/archives
1431 hash -d doc=/usr/share/doc
1432 hash -d linux=/lib/modules/$(command uname -r)/build/
1433 hash -d log=/var/log
1434 hash -d slog=/var/log/syslog
1435 hash -d src=/usr/src
1436 hash -d templ=/usr/share/doc/grml-templates
1437 hash -d tt=/usr/share/doc/texttools-doc
1438 hash -d www=/var/www
1439 #d# end
1440
1441 # some aliases
1442 if check_com -c screen ; then
1443     if [[ $UID -eq 0 ]] ; then
1444         if [[ -r /etc/grml/screenrc ]]; then
1445             alias screen="${commands[screen]} -c /etc/grml/screenrc"
1446         fi
1447     elif [[ -r $HOME/.screenrc ]] ; then
1448         alias screen="${commands[screen]} -c $HOME/.screenrc"
1449     else
1450         if [[ -r /etc/grml/screenrc_grml ]]; then
1451             alias screen="${commands[screen]} -c /etc/grml/screenrc_grml"
1452         else
1453             if [[ -r /etc/grml/screenrc ]]; then
1454                 alias screen="${commands[screen]} -c /etc/grml/screenrc"
1455             fi
1456         fi
1457     fi
1458 fi
1459
1460 # do we have GNU ls with color-support?
1461 if ls --help 2>/dev/null | grep -- --color= >/dev/null \
1462    && [[ "$TERM" != dumb ]]
1463 then
1464     #a1# execute \kbd{@a@}:\quad ls with colors
1465     alias ls='ls -b -CF --color=auto'
1466     #a1# execute \kbd{@a@}:\quad list all files, with colors
1467     alias la='ls -la --color=auto'
1468     #a1# long colored list, without dotfiles (@a@)
1469     alias ll='ls -l --color=auto'
1470     #a1# long colored list, human readable sizes (@a@)
1471     alias lh='ls -hAl --color=auto'
1472     #a1# List files, append qualifier to filenames \\&\quad(\kbd{/} for directories, \kbd{@} for symlinks ...)
1473     alias l='ls -lF --color=auto'
1474 else
1475     alias ls='ls -b -CF'
1476     alias la='ls -la'
1477     alias ll='ls -l'
1478     alias lh='ls -hAl'
1479     alias l='ls -lF'
1480 fi
1481
1482 alias mdstat='cat /proc/mdstat'
1483 alias ...='cd ../../'
1484
1485 # generate alias named "$KERNELVERSION-reboot" so you can use boot with kexec:
1486 if [[ -x /sbin/kexec ]] && [[ -r /proc/cmdline ]] ; then
1487     alias "$(uname -r)-reboot"="kexec -l --initrd=/boot/initrd.img-"$(uname -r)" --command-line=\"$(cat /proc/cmdline)\" /boot/vmlinuz-"$(uname -r)""
1488 fi
1489
1490 # see http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for details
1491 alias term2iso="echo 'Setting terminal to iso mode' ; print -n '\e%@'"
1492 alias term2utf="echo 'Setting terminal to utf-8 mode'; print -n '\e%G'"
1493
1494 # make sure it is not assigned yet
1495 [[ -n ${aliases[utf2iso]} ]] && unalias utf2iso
1496 utf2iso() {
1497     if isutfenv ; then
1498         for ENV in $(env | command grep -i '.utf') ; do
1499             eval export "$(echo $ENV | sed 's/UTF-8/iso885915/ ; s/utf8/iso885915/')"
1500         done
1501     fi
1502 }
1503
1504 # make sure it is not assigned yet
1505 [[ -n ${aliases[iso2utf]} ]] && unalias iso2utf
1506 iso2utf() {
1507     if ! isutfenv ; then
1508         for ENV in $(env | command grep -i '\.iso') ; do
1509             eval export "$(echo $ENV | sed 's/iso.*/UTF-8/ ; s/ISO.*/UTF-8/')"
1510         done
1511     fi
1512 }
1513
1514 # especially for roadwarriors using GNU screen and ssh:
1515 if ! check_com asc &>/dev/null ; then
1516   asc() { autossh -t "$@" 'screen -RdU' }
1517   compdef asc=ssh
1518 fi
1519
1520 #f1# Hints for the use of zsh on grml
1521 zsh-help() {
1522     print "$bg[white]$fg[black]
1523 zsh-help - hints for use of zsh on grml
1524 =======================================$reset_color"
1525
1526     print '
1527 Main configuration of zsh happens in /etc/zsh/zshrc.
1528 That file is part of the package grml-etc-core, if you want to
1529 use them on a non-grml-system just get the tar.gz from
1530 http://deb.grml.org/ or (preferably) get it from the git repository:
1531
1532   http://git.grml.org/f/grml-etc-core/etc/zsh/zshrc
1533
1534 This version of grml'\''s zsh setup does not use skel/.zshrc anymore.
1535 The file is still there, but it is empty for backwards compatibility.
1536
1537 For your own changes use these two files:
1538     $HOME/.zshrc.pre
1539     $HOME/.zshrc.local
1540
1541 The former is sourced very early in our zshrc, the latter is sourced
1542 very lately.
1543
1544 System wide configuration without touching configuration files of grml
1545 can take place in /etc/zsh/zshrc.local.
1546
1547 For information regarding zsh start at http://grml.org/zsh/
1548
1549 Take a look at grml'\''s zsh refcard:
1550 % xpdf =(zcat /usr/share/doc/grml-docs/zsh/grml-zsh-refcard.pdf.gz)
1551
1552 Check out the main zsh refcard:
1553 % '$BROWSER' http://www.bash2zsh.com/zsh_refcard/refcard.pdf
1554
1555 And of course visit the zsh-lovers:
1556 % man zsh-lovers
1557
1558 You can adjust some options through environment variables when
1559 invoking zsh without having to edit configuration files.
1560 Basically meant for bash users who are not used to the power of
1561 the zsh yet. :)
1562
1563   "NOCOR=1    zsh" => deactivate automatic correction
1564   "NOMENU=1   zsh" => do not use auto menu completion
1565                       (note: use ctrl-d for completion instead!)
1566   "NOPRECMD=1 zsh" => disable the precmd + preexec commands (set GNU screen title)
1567   "NOTITLE=1  zsh" => disable setting the title of xterms without disabling
1568                       preexec() and precmd() completely
1569   "BATTERY=1  zsh" => activate battery status (via acpi) on right side of prompt
1570   "COMMAND_NOT_FOUND=1 zsh"
1571                    => Enable a handler if an external command was not found
1572                       The command called in the handler can be altered by setting
1573                       the GRML_ZSH_CNF_HANDLER variable, the default is:
1574                       "/usr/share/command-not-found/command-not-found"
1575
1576 A value greater than 0 is enables a feature; a value equal to zero
1577 disables it. If you like one or the other of these settings, you can
1578 add them to ~/.zshrc.pre to ensure they are set when sourcing grml'\''s
1579 zshrc.'
1580
1581     print "
1582 $bg[white]$fg[black]
1583 Please report wishes + bugs to the grml-team: http://grml.org/bugs/
1584 Enjoy your grml system with the zsh!$reset_color"
1585 }
1586
1587 # debian stuff
1588 if [[ -r /etc/debian_version ]] ; then
1589     #a3# Execute \kbd{apt-cache search}
1590     alias acs='apt-cache search'
1591     #a3# Execute \kbd{apt-cache show}
1592     alias acsh='apt-cache show'
1593     #a3# Execute \kbd{apt-cache policy}
1594     alias acp='apt-cache policy'
1595     #a3# Execute \kbd{apt-get dist-upgrade}
1596     salias adg="apt-get dist-upgrade"
1597     #a3# Execute \kbd{apt-get install}
1598     salias agi="apt-get install"
1599     #a3# Execute \kbd{aptitude install}
1600     salias ati="aptitude install"
1601     #a3# Execute \kbd{apt-get upgrade}
1602     salias ag="apt-get upgrade"
1603     #a3# Execute \kbd{apt-get update}
1604     salias au="apt-get update"
1605     #a3# Execute \kbd{aptitude update ; aptitude safe-upgrade}
1606     salias -a up="aptitude update ; aptitude safe-upgrade"
1607     #a3# Execute \kbd{dpkg-buildpackage}
1608     alias dbp='dpkg-buildpackage'
1609     #a3# Execute \kbd{grep-excuses}
1610     alias ge='grep-excuses'
1611
1612     # get a root shell as normal user in live-cd mode:
1613     if isgrmlcd && [[ $UID -ne 0 ]] ; then
1614        alias su="sudo su"
1615      fi
1616
1617     #a1# Take a look at the syslog: \kbd{\$PAGER /var/log/syslog}
1618     salias llog="$PAGER /var/log/syslog"     # take a look at the syslog
1619     #a1# Take a look at the syslog: \kbd{tail -f /var/log/syslog}
1620     salias tlog="tail -f /var/log/syslog"    # follow the syslog
1621 fi
1622
1623 # sort installed Debian-packages by size
1624 if check_com -c dpkg-query ; then
1625     #a3# List installed Debian-packages sorted by size
1626     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"
1627 fi
1628
1629 # if cdrecord is a symlink (to wodim) or isn't present at all warn:
1630 if [[ -L /usr/bin/cdrecord ]] || ! check_com -c cdrecord; then
1631     if check_com -c wodim; then
1632         cdrecord() {
1633             cat <<EOMESS
1634 cdrecord is not provided under its original name by Debian anymore.
1635 See #377109 in the BTS of Debian for more details.
1636
1637 Please use the wodim binary instead
1638 EOMESS
1639             return 1
1640         }
1641     fi
1642 fi
1643
1644 # Use hard limits, except for a smaller stack and no core dumps
1645 unlimit
1646 is425 && limit stack 8192
1647 isgrmlcd && limit core 0 # important for a live-cd-system
1648 limit -s
1649
1650 # completion system
1651
1652 # called later (via is4 && grmlcomp)
1653 # note: use 'zstyle' for getting current settings
1654 #         press ^Xh (control-x h) for getting tags in context; ^X? (control-x ?) to run complete_debug with trace output
1655 grmlcomp() {
1656     # TODO: This could use some additional information
1657
1658     # allow one error for every three characters typed in approximate completer
1659     zstyle ':completion:*:approximate:'    max-errors 'reply=( $((($#PREFIX+$#SUFFIX)/3 )) numeric )'
1660
1661     # don't complete backup files as executables
1662     zstyle ':completion:*:complete:-command-::commands' ignored-patterns '(aptitude-*|*\~)'
1663
1664     # start menu completion only if it could find no unambiguous initial string
1665     zstyle ':completion:*:correct:*'       insert-unambiguous true
1666     zstyle ':completion:*:corrections'     format $'%{\e[0;31m%}%d (errors: %e)%{\e[0m%}'
1667     zstyle ':completion:*:correct:*'       original true
1668
1669     # activate color-completion
1670     zstyle ':completion:*:default'         list-colors ${(s.:.)LS_COLORS}
1671
1672     # format on completion
1673     zstyle ':completion:*:descriptions'    format $'%{\e[0;31m%}completing %B%d%b%{\e[0m%}'
1674
1675     # automatically complete 'cd -<tab>' and 'cd -<ctrl-d>' with menu
1676     # zstyle ':completion:*:*:cd:*:directory-stack' menu yes select
1677
1678     # insert all expansions for expand completer
1679     zstyle ':completion:*:expand:*'        tag-order all-expansions
1680     zstyle ':completion:*:history-words'   list false
1681
1682     # activate menu
1683     zstyle ':completion:*:history-words'   menu yes
1684
1685     # ignore duplicate entries
1686     zstyle ':completion:*:history-words'   remove-all-dups yes
1687     zstyle ':completion:*:history-words'   stop yes
1688
1689     # match uppercase from lowercase
1690     zstyle ':completion:*'                 matcher-list 'm:{a-z}={A-Z}'
1691
1692     # separate matches into groups
1693     zstyle ':completion:*:matches'         group 'yes'
1694     zstyle ':completion:*'                 group-name ''
1695
1696     if [[ "$NOMENU" -eq 0 ]] ; then
1697         # if there are more than 5 options allow selecting from a menu
1698         zstyle ':completion:*'               menu select=5
1699     else
1700         # don't use any menus at all
1701         setopt no_auto_menu
1702     fi
1703
1704     zstyle ':completion:*:messages'        format '%d'
1705     zstyle ':completion:*:options'         auto-description '%d'
1706
1707     # describe options in full
1708     zstyle ':completion:*:options'         description 'yes'
1709
1710     # on processes completion complete all user processes
1711     zstyle ':completion:*:processes'       command 'ps -au$USER'
1712
1713     # offer indexes before parameters in subscripts
1714     zstyle ':completion:*:*:-subscript-:*' tag-order indexes parameters
1715
1716     # provide verbose completion information
1717     zstyle ':completion:*'                 verbose true
1718
1719     # recent (as of Dec 2007) zsh versions are able to provide descriptions
1720     # for commands (read: 1st word in the line) that it will list for the user
1721     # to choose from. The following disables that, because it's not exactly fast.
1722     zstyle ':completion:*:-command-:*:'    verbose false
1723
1724     # set format for warnings
1725     zstyle ':completion:*:warnings'        format $'%{\e[0;31m%}No matches for:%{\e[0m%} %d'
1726
1727     # define files to ignore for zcompile
1728     zstyle ':completion:*:*:zcompile:*'    ignored-patterns '(*~|*.zwc)'
1729     zstyle ':completion:correct:'          prompt 'correct to: %e'
1730
1731     # Ignore completion functions for commands you don't have:
1732     zstyle ':completion::(^approximate*):*:functions' ignored-patterns '_*'
1733
1734     # Provide more processes in completion of programs like killall:
1735     zstyle ':completion:*:processes-names' command 'ps c -u ${USER} -o command | uniq'
1736
1737     # complete manual by their section
1738     zstyle ':completion:*:manuals'    separate-sections true
1739     zstyle ':completion:*:manuals.*'  insert-sections   true
1740     zstyle ':completion:*:man:*'      menu yes select
1741
1742     # provide .. as a completion
1743     zstyle ':completion:*' special-dirs ..
1744
1745     # run rehash on completion so new installed program are found automatically:
1746     _force_rehash() {
1747         (( CURRENT == 1 )) && rehash
1748         return 1
1749     }
1750
1751     ## correction
1752     # some people don't like the automatic correction - so run 'NOCOR=1 zsh' to deactivate it
1753     if [[ "$NOCOR" -gt 0 ]] ; then
1754         zstyle ':completion:*' completer _oldlist _expand _force_rehash _complete _files _ignored
1755         setopt nocorrect
1756     else
1757         # try to be smart about when to use what completer...
1758         setopt correct
1759         zstyle -e ':completion:*' completer '
1760             if [[ $_last_try != "$HISTNO$BUFFER$CURSOR" ]] ; then
1761                 _last_try="$HISTNO$BUFFER$CURSOR"
1762                 reply=(_complete _match _ignored _prefix _files)
1763             else
1764                 if [[ $words[1] == (rm|mv) ]] ; then
1765                     reply=(_complete _files)
1766                 else
1767                     reply=(_oldlist _expand _force_rehash _complete _ignored _correct _approximate _files)
1768                 fi
1769             fi'
1770     fi
1771
1772     # command for process lists, the local web server details and host completion
1773     zstyle ':completion:*:urls' local 'www' '/var/www/' 'public_html'
1774
1775     # caching
1776     [[ -d $ZSHDIR/cache ]] && zstyle ':completion:*' use-cache yes && \
1777                             zstyle ':completion::complete:*' cache-path $ZSHDIR/cache/
1778
1779     # host completion
1780     if is42 ; then
1781         [[ -r ~/.ssh/known_hosts ]] && _ssh_hosts=(${${${${(f)"$(<$HOME/.ssh/known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _ssh_hosts=()
1782         [[ -r /etc/hosts ]] && : ${(A)_etc_hosts:=${(s: :)${(ps:\t:)${${(f)~~"$(</etc/hosts)"}%%\#*}##[:blank:]#[^[:blank:]]#}}} || _etc_hosts=()
1783     else
1784         _ssh_hosts=()
1785         _etc_hosts=()
1786     fi
1787     hosts=(
1788         $(hostname)
1789         "$_ssh_hosts[@]"
1790         "$_etc_hosts[@]"
1791         grml.org
1792         localhost
1793     )
1794     zstyle ':completion:*:hosts' hosts $hosts
1795     # TODO: so, why is this here?
1796     #  zstyle '*' hosts $hosts
1797
1798     # use generic completion system for programs not yet defined; (_gnu_generic works
1799     # with commands that provide a --help option with "standard" gnu-like output.)
1800     for compcom in cp deborphan df feh fetchipac head hnb ipacsum mv \
1801                    pal stow tail uname ; do
1802         [[ -z ${_comps[$compcom]} ]] && compdef _gnu_generic ${compcom}
1803     done; unset compcom
1804
1805     # see upgrade function in this file
1806     compdef _hosts upgrade
1807 }
1808
1809 # grmlstuff
1810 grmlstuff() {
1811 # people should use 'grml-x'!
1812     if check_com -c 915resolution; then
1813         855resolution() {
1814             echo "Please use 915resolution as resolution modifying tool for Intel \
1815 graphic chipset."
1816             return -1
1817         }
1818     fi
1819
1820     #a1# Output version of running grml
1821     alias grml-version='cat /etc/grml_version'
1822
1823     if check_com -c rebuildfstab ; then
1824         #a1# Rebuild /etc/fstab
1825         alias grml-rebuildfstab='rebuildfstab -v -r -config'
1826     fi
1827
1828     if check_com -c grml-debootstrap ; then
1829         debian2hd() {
1830             echo "Installing debian to harddisk is possible by using grml-debootstrap."
1831             return 1
1832         }
1833     fi
1834 }
1835
1836 # now run the functions
1837 isgrml && checkhome
1838 is4    && isgrml    && grmlstuff
1839 is4    && grmlcomp
1840
1841 # keephack
1842 is4 && xsource "/etc/zsh/keephack"
1843
1844 # wonderful idea of using "e" glob qualifier by Peter Stephenson
1845 # You use it as follows:
1846 # $ NTREF=/reference/file
1847 # $ ls -l *(e:nt:)
1848 # This lists all the files in the current directory newer than the reference file.
1849 # You can also specify the reference file inline; note quotes:
1850 # $ ls -l *(e:'nt ~/.zshenv':)
1851 is4 && nt() {
1852     if [[ -n $1 ]] ; then
1853         local NTREF=${~1}
1854     fi
1855     [[ $REPLY -nt $NTREF ]]
1856 }
1857
1858 # shell functions
1859
1860 #f1# Reload an autoloadable function
1861 freload() { while (( $# )); do; unfunction $1; autoload -U $1; shift; done }
1862 compdef _functions freload
1863
1864 #f1# List symlinks in detail (more detailed version of 'readlink -f' and 'whence -s')
1865 sll() {
1866     [[ -z "$1" ]] && printf 'Usage: %s <file(s)>\n' "$0" && return 1
1867     for file in "$@" ; do
1868         while [[ -h "$file" ]] ; do
1869             ls -l $file
1870             file=$(readlink "$file")
1871         done
1872     done
1873 }
1874
1875 # TODO: Is it supported to use pager settings like this?
1876 #   PAGER='less -Mr' - If so, the use of $PAGER here needs fixing
1877 # with respect to wordsplitting. (ie. ${=PAGER})
1878 if check_com -c $PAGER ; then
1879     #f1# View Debian's changelog of a given package
1880     dchange() {
1881         emulate -L zsh
1882         if [[ -r /usr/share/doc/$1/changelog.Debian.gz ]] ; then
1883             $PAGER /usr/share/doc/$1/changelog.Debian.gz
1884         elif [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
1885             $PAGER /usr/share/doc/$1/changelog.gz
1886         else
1887             if check_com -c aptitude ; then
1888                 echo "No changelog for package $1 found, using aptitude to retrieve it."
1889                 if isgrml ; then
1890                     aptitude -t unstable changelog $1
1891                 else
1892                     aptitude changelog $1
1893                 fi
1894             else
1895                 echo "No changelog for package $1 found, sorry."
1896                 return 1
1897             fi
1898         fi
1899     }
1900     _dchange() { _files -W /usr/share/doc -/ }
1901     compdef _dchange dchange
1902
1903     #f1# View Debian's NEWS of a given package
1904     dnews() {
1905         emulate -L zsh
1906         if [[ -r /usr/share/doc/$1/NEWS.Debian.gz ]] ; then
1907             $PAGER /usr/share/doc/$1/NEWS.Debian.gz
1908         else
1909             if [[ -r /usr/share/doc/$1/NEWS.gz ]] ; then
1910                 $PAGER /usr/share/doc/$1/NEWS.gz
1911             else
1912                 echo "No NEWS file for package $1 found, sorry."
1913                 return 1
1914             fi
1915         fi
1916     }
1917     _dnews() { _files -W /usr/share/doc -/ }
1918     compdef _dnews dnews
1919
1920     #f1# View upstream's changelog of a given package
1921     uchange() {
1922         emulate -L zsh
1923         if [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
1924             $PAGER /usr/share/doc/$1/changelog.gz
1925         else
1926             echo "No changelog for package $1 found, sorry."
1927             return 1
1928         fi
1929     }
1930     _uchange() { _files -W /usr/share/doc -/ }
1931     compdef _uchange uchange
1932 fi
1933
1934 # zsh profiling
1935 profile() {
1936     ZSH_PROFILE_RC=1 $SHELL "$@"
1937 }
1938
1939 #f1# Edit an alias via zle
1940 edalias() {
1941     [[ -z "$1" ]] && { echo "Usage: edalias <alias_to_edit>" ; return 1 } || vared aliases'[$1]' ;
1942 }
1943 compdef _aliases edalias
1944
1945 #f1# Edit a function via zle
1946 edfunc() {
1947     [[ -z "$1" ]] && { echo "Usage: edfunc <function_to_edit>" ; return 1 } || zed -f "$1" ;
1948 }
1949 compdef _functions edfunc
1950
1951 # use it e.g. via 'Restart apache2'
1952 #m# f6 Start() \kbd{/etc/init.d/\em{process}}\quad\kbd{start}
1953 #m# f6 Restart() \kbd{/etc/init.d/\em{process}}\quad\kbd{restart}
1954 #m# f6 Stop() \kbd{/etc/init.d/\em{process}}\quad\kbd{stop}
1955 #m# f6 Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{reload}
1956 #m# f6 Force-Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{force-reload}
1957 if [[ -d /etc/init.d || -d /etc/service ]] ; then
1958     __start_stop() {
1959         local action_="${1:l}"  # e.g Start/Stop/Restart
1960         local service_="$2"
1961         local param_="$3"
1962
1963         local service_target_="$(readlink /etc/init.d/$service_)"
1964         if [[ $service_target_ == "/usr/bin/sv" ]]; then
1965             # runit
1966             case "${action_}" in
1967                 start) if [[ ! -e /etc/service/$service_ ]]; then
1968                            $SUDO ln -s "/etc/sv/$service_" "/etc/service/"
1969                        else
1970                            $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
1971                        fi ;;
1972                 # there is no reload in runits sysv emulation
1973                 reload) $SUDO "/etc/init.d/$service_" "force-reload" "$param_" ;;
1974                 *) $SUDO "/etc/init.d/$service_" "${action_}" "$param_" ;;
1975             esac
1976         else
1977             # sysvinit
1978             $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
1979         fi
1980     }
1981
1982     _grmlinitd() {
1983         local -a scripts
1984         scripts=( /etc/init.d/*(x:t) )
1985         _describe "service startup script" scripts
1986     }
1987
1988     for i in Start Restart Stop Force-Reload Reload ; do
1989         eval "$i() { __start_stop $i \"\$1\" \"\$2\" ; }"
1990         compdef _grmlinitd $i
1991     done
1992 fi
1993
1994 #f1# Provides useful information on globbing
1995 H-Glob() {
1996     echo -e "
1997     /      directories
1998     .      plain files
1999     @      symbolic links
2000     =      sockets
2001     p      named pipes (FIFOs)
2002     *      executable plain files (0100)
2003     %      device files (character or block special)
2004     %b     block special files
2005     %c     character special files
2006     r      owner-readable files (0400)
2007     w      owner-writable files (0200)
2008     x      owner-executable files (0100)
2009     A      group-readable files (0040)
2010     I      group-writable files (0020)
2011     E      group-executable files (0010)
2012     R      world-readable files (0004)
2013     W      world-writable files (0002)
2014     X      world-executable files (0001)
2015     s      setuid files (04000)
2016     S      setgid files (02000)
2017     t      files with the sticky bit (01000)
2018
2019   print *(m-1)          # Files modified up to a day ago
2020   print *(a1)           # Files accessed a day ago
2021   print *(@)            # Just symlinks
2022   print *(Lk+50)        # Files bigger than 50 kilobytes
2023   print *(Lk-50)        # Files smaller than 50 kilobytes
2024   print **/*.c          # All *.c files recursively starting in \$PWD
2025   print **/*.c~file.c   # Same as above, but excluding 'file.c'
2026   print (foo|bar).*     # Files starting with 'foo' or 'bar'
2027   print *~*.*           # All Files that do not contain a dot
2028   chmod 644 *(.^x)      # make all plain non-executable files publically readable
2029   print -l *(.c|.h)     # Lists *.c and *.h
2030   print **/*(g:users:)  # Recursively match all files that are owned by group 'users'
2031   echo /proc/*/cwd(:h:t:s/self//) # Analogous to >ps ax | awk '{print $1}'<"
2032 }
2033 alias help-zshglob=H-Glob
2034
2035 #v1# set number of lines to display per page
2036 HELP_LINES_PER_PAGE=20
2037 #v1# set location of help-zle cache file
2038 HELP_ZLE_CACHE_FILE=~/.cache/zsh_help_zle_lines.zsh
2039 #f1# helper function for help-zle, actually generates the help text
2040 help_zle_parse_keybindings()
2041 {
2042     emulate -L zsh
2043     setopt extendedglob
2044     unsetopt ksharrays  #indexing starts at 1
2045
2046     #v1# choose files that help-zle will parse for keybindings
2047     ((${+HELPZLE_KEYBINDING_FILES})) || HELPZLE_KEYBINDING_FILES=( /etc/zsh/zshrc ~/.zshrc.pre ~/.zshrc ~/.zshrc.local )
2048
2049     if [[ -r $HELP_ZLE_CACHE_FILE ]]; then
2050         local load_cache=0
2051         for f ($KEYBINDING_FILES) [[ $f -nt $HELP_ZLE_CACHE_FILE ]] && load_cache=1
2052         [[ $load_cache -eq 0 ]] && . $HELP_ZLE_CACHE_FILE && return
2053     fi
2054
2055     #fill with default keybindings, possibly to be overwriten in a file later
2056     #Note that due to zsh inconsistency on escaping assoc array keys, we encase the key in '' which we will remove later
2057     local -A help_zle_keybindings
2058     help_zle_keybindings['<Ctrl>@']="set MARK"
2059     help_zle_keybindings['<Ctrl>X<Ctrl>J']="vi-join lines"
2060     help_zle_keybindings['<Ctrl>X<Ctrl>B']="jump to matching brace"
2061     help_zle_keybindings['<Ctrl>X<Ctrl>U']="undo"
2062     help_zle_keybindings['<Ctrl>_']="undo"
2063     help_zle_keybindings['<Ctrl>X<Ctrl>F<c>']="find <c> in cmdline"
2064     help_zle_keybindings['<Ctrl>A']="goto beginning of line"
2065     help_zle_keybindings['<Ctrl>E']="goto end of line"
2066     help_zle_keybindings['<Ctrl>t']="transpose charaters"
2067     help_zle_keybindings['<Alt>T']="transpose words"
2068     help_zle_keybindings['<Alt>s']="spellcheck word"
2069     help_zle_keybindings['<Ctrl>K']="backward kill buffer"
2070     help_zle_keybindings['<Ctrl>U']="forward kill buffer"
2071     help_zle_keybindings['<Ctrl>y']="insert previously killed word/string"
2072     help_zle_keybindings["<Alt>'"]="quote line"
2073     help_zle_keybindings['<Alt>"']="quote from mark to cursor"
2074     help_zle_keybindings['<Alt><arg>']="repeat next cmd/char <arg> times (<Alt>-<Alt>1<Alt>0a -> -10 times 'a')"
2075     help_zle_keybindings['<Alt>U']="make next word Uppercase"
2076     help_zle_keybindings['<Alt>l']="make next word lowercase"
2077     help_zle_keybindings['<Ctrl>Xd']="preview expansion under cursor"
2078     help_zle_keybindings['<Alt>q']="push current CL into background, freeing it. Restore on next CL"
2079     help_zle_keybindings['<Alt>.']="insert (and interate through) last word from prev CLs"
2080     help_zle_keybindings['<Alt>,']="complete word from newer history (consecutive hits)"
2081     help_zle_keybindings['<Alt>m']="repeat last typed word on current CL"
2082     help_zle_keybindings['<Ctrl>V']="insert next keypress symbol literally (e.g. for bindkey)"
2083     help_zle_keybindings['!!:n*<Tab>']="insert last n arguments of last command"
2084     help_zle_keybindings['!!:n-<Tab>']="insert arguments n..N-2 of last command (e.g. mv s s d)"
2085     help_zle_keybindings['<Alt>H']="run help on current command"
2086
2087     #init global variables
2088     unset help_zle_lines help_zle_sln
2089     typeset -g -a help_zle_lines
2090     typeset -g help_zle_sln=1
2091
2092     local k v
2093     local lastkeybind_desc contents     #last description starting with #k# that we found
2094     local num_lines_elapsed=0            #number of lines between last description and keybinding
2095     #search config files in the order they a called (and thus the order in which they overwrite keybindings)
2096     for f in $HELPZLE_KEYBINDING_FILES; do
2097         [[ -r "$f" ]] || continue   #not readable ? skip it
2098         contents="$(<$f)"
2099         for cline in "${(f)contents}"; do
2100             #zsh pattern: matches lines like: #k# ..............
2101             if [[ "$cline" == (#s)[[:space:]]#\#k\#[[:space:]]##(#b)(*)[[:space:]]#(#e) ]]; then
2102                 lastkeybind_desc="$match[*]"
2103                 num_lines_elapsed=0
2104             #zsh pattern: matches lines that set a keybinding using bindkey or compdef -k
2105             #             ignores lines that are commentend out
2106             #             grabs first in '' or "" enclosed string with length between 1 and 6 characters
2107             elif [[ "$cline" == [^#]#(bindkey|compdef -k)[[:space:]](*)(#b)(\"((?)(#c1,6))\"|\'((?)(#c1,6))\')(#B)(*)  ]]; then
2108                 #description prevously found ? description not more than 2 lines away ? keybinding not empty ?
2109                 if [[ -n $lastkeybind_desc && $num_lines_elapsed -lt 2 && -n $match[1] ]]; then
2110                     #substitute keybinding string with something readable
2111                     k=${${${${${${${match[1]/\\e\^h/<Alt><BS>}/\\e\^\?/<Alt><BS>}/\\e\[5~/<PageUp>}/\\e\[6~/<PageDown>}//(\\e|\^\[)/<Alt>}//\^/<Ctrl>}/3~/<Alt><Del>}
2112                     #put keybinding in assoc array, possibly overwriting defaults or stuff found in earlier files
2113                     #Note that we are extracting the keybinding-string including the quotes (see Note at beginning)
2114                     help_zle_keybindings[${k}]=$lastkeybind_desc
2115                 fi
2116                 lastkeybind_desc=""
2117             else
2118               ((num_lines_elapsed++))
2119             fi
2120         done
2121     done
2122     unset contents
2123     #calculate length of keybinding column
2124     local kstrlen=0
2125     for k (${(k)help_zle_keybindings[@]}) ((kstrlen < ${#k})) && kstrlen=${#k}
2126     #convert the assoc array into preformated lines, which we are able to sort
2127     for k v in ${(kv)help_zle_keybindings[@]}; do
2128         #pad keybinding-string to kstrlen chars and remove outermost characters (i.e. the quotes)
2129         help_zle_lines+=("${(r:kstrlen:)k[2,-2]}${v}")
2130     done
2131     #sort lines alphabetically
2132     help_zle_lines=("${(i)help_zle_lines[@]}")
2133     [[ -d ${HELP_ZLE_CACHE_FILE:h} ]] || mkdir -p "${HELP_ZLE_CACHE_FILE:h}"
2134     echo "help_zle_lines=(${(q)help_zle_lines[@]})" >| $HELP_ZLE_CACHE_FILE
2135     zcompile $HELP_ZLE_CACHE_FILE
2136 }
2137 typeset -g help_zle_sln
2138 typeset -g -a help_zle_lines
2139
2140 #f1# Provides (partially autogenerated) help on keybindings and the zsh line editor
2141 help-zle()
2142 {
2143     emulate -L zsh
2144     unsetopt ksharrays  #indexing starts at 1
2145     #help lines already generated ? no ? then do it
2146     [[ ${+functions[help_zle_parse_keybindings]} -eq 1 ]] && {help_zle_parse_keybindings && unfunction help_zle_parse_keybindings}
2147     #already displayed all lines ? go back to the start
2148     [[ $help_zle_sln -gt ${#help_zle_lines} ]] && help_zle_sln=1
2149     local sln=$help_zle_sln
2150     #note that help_zle_sln is a global var, meaning we remember the last page we viewed
2151     help_zle_sln=$((help_zle_sln + HELP_LINES_PER_PAGE))
2152     zle -M "${(F)help_zle_lines[sln,help_zle_sln-1]}"
2153 }
2154 #k# display help for keybindings and ZLE (cycle pages with consecutive use)
2155 zle -N help-zle && bindkey '^Xz' help-zle
2156
2157 # grep for running process, like: 'any vim'
2158 any() {
2159     emulate -L zsh
2160     unsetopt KSH_ARRAYS
2161     if [[ -z "$1" ]] ; then
2162         echo "any - grep for process(es) by keyword" >&2
2163         echo "Usage: any <keyword>" >&2 ; return 1
2164     else
2165         ps xauwww | grep -i --color=auto "[${1[1]}]${1[2,-1]}"
2166     fi
2167 }
2168
2169
2170 # After resuming from suspend, system is paging heavily, leading to very bad interactivity.
2171 # taken from $LINUX-KERNELSOURCE/Documentation/power/swsusp.txt
2172 [[ -r /proc/1/maps ]] && \
2173 deswap() {
2174     print 'Reading /proc/[0-9]*/maps and sending output to /dev/null, this might take a while.'
2175     cat $(sed -ne 's:.* /:/:p' /proc/[0-9]*/maps | sort -u | grep -v '^/dev/')  > /dev/null
2176     print 'Finished, running "swapoff -a; swapon -a" may also be useful.'
2177 }
2178
2179 # a wrapper for vim, that deals with title setting
2180 #   VIM_OPTIONS
2181 #       set this array to a set of options to vim you always want
2182 #       to have set when calling vim (in .zshrc.local), like:
2183 #           VIM_OPTIONS=( -p )
2184 #       This will cause vim to send every file given on the
2185 #       commandline to be send to it's own tab (needs vim7).
2186 vim() {
2187     VIM_PLEASE_SET_TITLE='yes' command vim ${VIM_OPTIONS} "$@"
2188 }
2189
2190 # make a backup of a file
2191 bk() {
2192     cp -a "$1" "${1}_$(date --iso-8601=seconds)"
2193 }
2194
2195 ssl_hashes=( sha512 sha256 sha1 md5 )
2196
2197 for sh in ${ssl_hashes}; do
2198     eval 'ssl-cert-'${sh}'() {
2199         emulate -L zsh
2200         if [[ -z $1 ]] ; then
2201             printf '\''usage: %s <file>\n'\'' "ssh-cert-'${sh}'"
2202             return 1
2203         fi
2204         openssl x509 -noout -fingerprint -'${sh}' -in $1
2205     }'
2206 done; unset sh
2207
2208 ssl-cert-fingerprints() {
2209     emulate -L zsh
2210     local i
2211     if [[ -z $1 ]] ; then
2212         printf 'usage: ssl-cert-fingerprints <file>\n'
2213         return 1
2214     fi
2215     for i in ${ssl_hashes}
2216         do ssl-cert-$i $1;
2217     done
2218 }
2219
2220 ssl-cert-info() {
2221     emulate -L zsh
2222     if [[ -z $1 ]] ; then
2223         printf 'usage: ssl-cert-info <file>\n'
2224         return 1
2225     fi
2226     openssl x509 -noout -text -in $1
2227     ssl-cert-fingerprints $1
2228 }
2229
2230 # make sure our environment is clean regarding colors
2231 for color in BLUE RED GREEN CYAN YELLOW MAGENTA WHITE ; unset $color
2232
2233 # "persistent history"
2234 # just write important commands you always need to ~/.important_commands
2235 if [[ -r ~/.important_commands ]] ; then
2236     fc -R ~/.important_commands
2237 fi
2238
2239 # load the lookup subsystem if it's available on the system
2240 zrcautoload lookupinit && lookupinit
2241
2242 # variables
2243
2244 # set terminal property (used e.g. by msgid-chooser)
2245 export COLORTERM="yes"
2246
2247 # aliases
2248
2249 # general
2250 #a2# Execute \kbd{du -sch}
2251 alias da='du -sch'
2252 #a2# Execute \kbd{jobs -l}
2253 alias j='jobs -l'
2254
2255 # listing stuff
2256 #a2# Execute \kbd{ls -lSrah}
2257 alias dir="ls -lSrah"
2258 #a2# Only show dot-directories
2259 alias lad='ls -d .*(/)'                # only show dot-directories
2260 #a2# Only show dot-files
2261 alias lsa='ls -a .*(.)'                # only show dot-files
2262 #a2# Only files with setgid/setuid/sticky flag
2263 alias lss='ls -l *(s,S,t)'             # only files with setgid/setuid/sticky flag
2264 #a2# Only show 1st ten symlinks
2265 alias lsl='ls -l *(@)'                 # only symlinks
2266 #a2# Display only executables
2267 alias lsx='ls -l *(*)'                 # only executables
2268 #a2# Display world-{readable,writable,executable} files
2269 alias lsw='ls -ld *(R,W,X.^ND/)'       # world-{readable,writable,executable} files
2270 #a2# Display the ten biggest files
2271 alias lsbig="ls -flh *(.OL[1,10])"     # display the biggest files
2272 #a2# Only show directories
2273 alias lsd='ls -d *(/)'                 # only show directories
2274 #a2# Only show empty directories
2275 alias lse='ls -d *(/^F)'               # only show empty directories
2276 #a2# Display the ten newest files
2277 alias lsnew="ls -rtlh *(D.om[1,10])"   # display the newest files
2278 #a2# Display the ten oldest files
2279 alias lsold="ls -rtlh *(D.Om[1,10])"   # display the oldest files
2280 #a2# Display the ten smallest files
2281 alias lssmall="ls -Srl *(.oL[1,10])"   # display the smallest files
2282
2283 # some useful aliases
2284 #a2# Remove current empty directory. Execute \kbd{cd ..; rmdir $OLDCWD}
2285 alias rmcdir='cd ..; rmdir $OLDPWD || cd $OLDPWD'
2286
2287 #a2# ssh with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
2288 alias insecssh='ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
2289 alias insecscp='scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
2290
2291 # simple webserver
2292 check_com -c python && alias http="python -m SimpleHTTPServer"
2293
2294 # work around non utf8 capable software in utf environment via $LANG and luit
2295 if check_com isutfenv && check_com luit ; then
2296     if check_com -c mrxvt ; then
2297         isutfenv && [[ -n "$LANG" ]] && \
2298             alias mrxvt="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit mrxvt"
2299     fi
2300
2301     if check_com -c aterm ; then
2302         isutfenv && [[ -n "$LANG" ]] && \
2303             alias aterm="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit aterm"
2304     fi
2305
2306     if check_com -c centericq ; then
2307         isutfenv && [[ -n "$LANG" ]] && \
2308             alias centericq="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit centericq"
2309     fi
2310 fi
2311
2312 # useful functions
2313
2314 #f5# Backup \kbd{file {\rm to} file\_timestamp}
2315 bk() {
2316     emulate -L zsh
2317     cp -b $1 $1_`date --iso-8601=m`
2318 }
2319
2320 #f5# cd to directoy and list files
2321 cl() {
2322     emulate -L zsh
2323     cd $1 && ls -a
2324 }
2325
2326 # smart cd function, allows switching to /etc when running 'cd /etc/fstab'
2327 cd() {
2328     if (( ${#argv} == 1 )) && [[ -f ${1} ]]; then
2329         [[ ! -e ${1:h} ]] && return 1
2330         print "Correcting ${1} to ${1:h}"
2331         builtin cd ${1:h}
2332     else
2333         builtin cd "$@"
2334     fi
2335 }
2336
2337 #f5# Create Directoy and \kbd{cd} to it
2338 mkcd() {
2339     mkdir -p "$@" && cd "$@"
2340 }
2341
2342 #f5# Create temporary directory and \kbd{cd} to it
2343 cdt() {
2344     local t
2345     t=$(mktemp -d)
2346     echo "$t"
2347     builtin cd "$t"
2348 }
2349
2350 #f5# Create directory under cursor or the selected area
2351 # Press ctrl-xM to create the directory under the cursor or the selected area.
2352 # To select an area press ctrl-@ or ctrl-space and use the cursor.
2353 # Use case: you type "mv abc ~/testa/testb/testc/" and remember that the
2354 # directory does not exist yet -> press ctrl-XM and problem solved
2355 inplaceMkDirs() {
2356     local PATHTOMKDIR
2357     if ((REGION_ACTIVE==1)); then
2358         local F=$MARK T=$CURSOR
2359         if [[ $F -gt $T ]]; then
2360             F=${CURSOR}
2361             T=${MARK}
2362         fi
2363         # get marked area from buffer and eliminate whitespace
2364         PATHTOMKDIR=${BUFFER[F+1,T]%%[[:space:]]##}
2365         PATHTOMKDIR=${PATHTOMKDIR##[[:space:]]##}
2366     else
2367         local bufwords iword
2368         bufwords=(${(z)LBUFFER})
2369         iword=${#bufwords}
2370         bufwords=(${(z)BUFFER})
2371         PATHTOMKDIR="${(Q)bufwords[iword]}"
2372     fi
2373     [[ -z "${PATHTOMKDIR}" ]] && return 1
2374     if [[ -e "${PATHTOMKDIR}" ]]; then
2375         zle -M " path already exists, doing nothing"
2376     else
2377         zle -M "$(mkdir -p -v "${PATHTOMKDIR}")"
2378         zle end-of-line
2379     fi
2380 }
2381 #k# mkdir -p <dir> from string under cursor or marked area
2382 zle -N inplaceMkDirs && bindkey '^XM' inplaceMkDirs
2383
2384 #f5# List files which have been accessed within the last {\it n} days, {\it n} defaults to 1
2385 accessed() {
2386     emulate -L zsh
2387     print -l -- *(a-${1:-1})
2388 }
2389
2390 #f5# List files which have been changed within the last {\it n} days, {\it n} defaults to 1
2391 changed() {
2392     emulate -L zsh
2393     print -l -- *(c-${1:-1})
2394 }
2395
2396 #f5# List files which have been modified within the last {\it n} days, {\it n} defaults to 1
2397 modified() {
2398     emulate -L zsh
2399     print -l -- *(m-${1:-1})
2400 }
2401 # modified() was named new() in earlier versions, add an alias for backwards compatibility
2402 check_com new || alias new=modified
2403
2404 # use colors when GNU grep with color-support
2405 #a2# Execute \kbd{grep -{}-color=auto}
2406 (grep --help 2>/dev/null |grep -- --color) >/dev/null && alias grep='grep --color=auto'
2407
2408 # Translate DE<=>EN
2409 # 'translate' looks up fot a word in a file with language-to-language
2410 # translations (field separator should be " : "). A typical wordlist looks
2411 # like at follows:
2412 #  | english-word : german-transmission
2413 # It's also only possible to translate english to german but not reciprocal.
2414 # Use the following oneliner to turn back the sort order:
2415 #  $ awk -F ':' '{ print $2" : "$1" "$3 }' \
2416 #    /usr/local/lib/words/en-de.ISO-8859-1.vok > ~/.translate/de-en.ISO-8859-1.vok
2417 #f5# Translates a word
2418 trans() {
2419     emulate -L zsh
2420     case "$1" in
2421         -[dD]*)
2422             translate -l de-en $2
2423             ;;
2424         -[eE]*)
2425             translate -l en-de $2
2426             ;;
2427         *)
2428             echo "Usage: $0 { -D | -E }"
2429             echo "         -D == German to English"
2430             echo "         -E == English to German"
2431     esac
2432 }
2433
2434 # Usage: simple-extract <file>
2435 # Using option -d deletes the original archive file.
2436 #f5# Smart archive extractor
2437 simple-extract() {
2438     emulate -L zsh
2439     setopt extended_glob noclobber
2440     local DELETE_ORIGINAL DECOMP_CMD USES_STDIN USES_STDOUT GZTARGET WGET_CMD
2441     local RC=0
2442     zparseopts -D -E "d=DELETE_ORIGINAL"
2443     for ARCHIVE in "${@}"; do
2444         case $ARCHIVE in
2445             *.(tar.bz2|tbz2|tbz))
2446                 DECOMP_CMD="tar -xvjf -"
2447                 USES_STDIN=true
2448                 USES_STDOUT=false
2449                 ;;
2450             *.(tar.gz|tgz))
2451                 DECOMP_CMD="tar -xvzf -"
2452                 USES_STDIN=true
2453                 USES_STDOUT=false
2454                 ;;
2455             *.(tar.xz|txz|tar.lzma))
2456                 DECOMP_CMD="tar -xvJf -"
2457                 USES_STDIN=true
2458                 USES_STDOUT=false
2459                 ;;
2460             *.tar)
2461                 DECOMP_CMD="tar -xvf -"
2462                 USES_STDIN=true
2463                 USES_STDOUT=false
2464                 ;;
2465             *.rar)
2466                 DECOMP_CMD="unrar x"
2467                 USES_STDIN=false
2468                 USES_STDOUT=false
2469                 ;;
2470             *.lzh)
2471                 DECOMP_CMD="lha x"
2472                 USES_STDIN=false
2473                 USES_STDOUT=false
2474                 ;;
2475             *.7z)
2476                 DECOMP_CMD="7z x"
2477                 USES_STDIN=false
2478                 USES_STDOUT=false
2479                 ;;
2480             *.(zip|jar))
2481                 DECOMP_CMD="unzip"
2482                 USES_STDIN=false
2483                 USES_STDOUT=false
2484                 ;;
2485             *.deb)
2486                 DECOMP_CMD="ar -x"
2487                 USES_STDIN=false
2488                 USES_STDOUT=false
2489                 ;;
2490             *.bz2)
2491                 DECOMP_CMD="bzip2 -d -c -"
2492                 USES_STDIN=true
2493                 USES_STDOUT=true
2494                 ;;
2495             *.(gz|Z))
2496                 DECOMP_CMD="gzip -d -c -"
2497                 USES_STDIN=true
2498                 USES_STDOUT=true
2499                 ;;
2500             *.(xz|lzma))
2501                 DECOMP_CMD="xz -d -c -"
2502                 USES_STDIN=true
2503                 USES_STDOUT=true
2504                 ;;
2505             *)
2506                 print "ERROR: '$ARCHIVE' has unrecognized archive type." >&2
2507                 RC=$((RC+1))
2508                 continue
2509                 ;;
2510         esac
2511
2512         if ! check_com ${DECOMP_CMD[(w)1]}; then
2513             echo "ERROR: ${DECOMP_CMD[(w)1]} not installed." >&2
2514             RC=$((RC+2))
2515             continue
2516         fi
2517
2518         GZTARGET="${ARCHIVE:t:r}"
2519         if [[ -f $ARCHIVE ]] ; then
2520
2521             print "Extracting '$ARCHIVE' ..."
2522             if $USES_STDIN; then
2523                 if $USES_STDOUT; then
2524                     ${=DECOMP_CMD} < "$ARCHIVE" > $GZTARGET
2525                 else
2526                     ${=DECOMP_CMD} < "$ARCHIVE"
2527                 fi
2528             else
2529                 if $USES_STDOUT; then
2530                     ${=DECOMP_CMD} "$ARCHIVE" > $GZTARGET
2531                 else
2532                     ${=DECOMP_CMD} "$ARCHIVE"
2533                 fi
2534             fi
2535             [[ $? -eq 0 && -n "$DELETE_ORIGINAL" ]] && rm -f "$ARCHIVE"
2536
2537         elif [[ "$ARCHIVE" == (#s)(https|http|ftp)://* ]] ; then
2538             if check_com curl; then
2539                 WGET_CMD="curl -L -k -s -o -"
2540             elif check_com wget; then
2541                 WGET_CMD="wget -q -O - --no-check-certificate"
2542             else
2543                 print "ERROR: neither wget nor curl is installed" >&2
2544                 RC=$((RC+4))
2545                 continue
2546             fi
2547             print "Downloading and Extracting '$ARCHIVE' ..."
2548             if $USES_STDIN; then
2549                 if $USES_STDOUT; then
2550                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD} > $GZTARGET
2551                     RC=$((RC+$?))
2552                 else
2553                     ${=WGET_CMD} "$ARCHIVE" | ${=DECOMP_CMD}
2554                     RC=$((RC+$?))
2555                 fi
2556             else
2557                 if $USES_STDOUT; then
2558                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE") > $GZTARGET
2559                 else
2560                     ${=DECOMP_CMD} =(${=WGET_CMD} "$ARCHIVE")
2561                 fi
2562             fi
2563
2564         else
2565             print "ERROR: '$ARCHIVE' is neither a valid file nor a supported URI." >&2
2566             RC=$((RC+8))
2567         fi
2568     done
2569     return $RC
2570 }
2571
2572 __archive_or_uri()
2573 {
2574     _alternative \
2575         '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)"' \
2576         '_urls:Remote Archives:_urls'
2577 }
2578
2579 _simple_extract()
2580 {
2581     _arguments \
2582         '-d[delete original archivefile after extraction]' \
2583         '*:Archive Or Uri:__archive_or_uri'
2584 }
2585 compdef _simple_extract simple-extract
2586 alias se=simple-extract
2587
2588 #f5# Set all ulimit parameters to \kbd{unlimited}
2589 allulimit() {
2590     ulimit -c unlimited
2591     ulimit -d unlimited
2592     ulimit -f unlimited
2593     ulimit -l unlimited
2594     ulimit -n unlimited
2595     ulimit -s unlimited
2596     ulimit -t unlimited
2597 }
2598
2599 #f5# Change the xterm title from within GNU-screen
2600 xtrename() {
2601     emulate -L zsh
2602     if [[ $1 != "-f" ]] ; then
2603         if [[ -z ${DISPLAY} ]] ; then
2604             printf 'xtrename only makes sense in X11.\n'
2605             return 1
2606         fi
2607     else
2608         shift
2609     fi
2610     if [[ -z $1 ]] ; then
2611         printf 'usage: xtrename [-f] "title for xterm"\n'
2612         printf '  renames the title of xterm from _within_ screen.\n'
2613         printf '  also works without screen.\n'
2614         printf '  will not work if DISPLAY is unset, use -f to override.\n'
2615         return 0
2616     fi
2617     print -n "\eP\e]0;${1}\C-G\e\\"
2618     return 0
2619 }
2620
2621 # TODO:
2622 # Rewrite this by either using tinyurl.com's API
2623 # or using another shortening service to comply with
2624 # tinyurl.com's policy.
2625 #
2626 # Create small urls via http://tinyurl.com using wget(1).
2627 #function zurl() {
2628 #    emulate -L zsh
2629 #    [[ -z $1 ]] && { print "USAGE: zurl <URL>" ; return 1 }
2630 #
2631 #    local PN url tiny grabber search result preview
2632 #    PN=$0
2633 #    url=$1
2634 ##   Check existence of given URL with the help of ping(1).
2635 ##   N.B. ping(1) only works without an eventual given protocol.
2636 #    ping -c 1 ${${url#(ftp|http)://}%%/*} >& /dev/null || \
2637 #        read -q "?Given host ${${url#http://*/}%/*} is not reachable by pinging. Proceed anyway? [y|n] "
2638 #
2639 #    if (( $? == 0 )) ; then
2640 ##           Prepend 'http://' to given URL where necessary for later output.
2641 #            [[ ${url} != http(s|)://* ]] && url='http://'${url}
2642 #            tiny='http://tinyurl.com/create.php?url='
2643 #            if check_com -c wget ; then
2644 #                grabber='wget -O- -o/dev/null'
2645 #            else
2646 #                print "wget is not available, but mandatory for ${PN}. Aborting."
2647 #            fi
2648 ##           Looking for i.e.`copy('http://tinyurl.com/7efkze')' in TinyURL's HTML code.
2649 #            search='copy\(?http://tinyurl.com/[[:alnum:]]##*'
2650 #            result=${(M)${${${(f)"$(${=grabber} ${tiny}${url})"}[(fr)${search}*]}//[()\';]/}%%http:*}
2651 ##           TinyURL provides the rather new feature preview for more confidence. <http://tinyurl.com/preview.php>
2652 #            preview='http://preview.'${result#http://}
2653 #
2654 #            printf '%s\n\n' "${PN} - Shrinking long URLs via webservice TinyURL <http://tinyurl.com>."
2655 #            printf '%s\t%s\n\n' 'Given URL:' ${url}
2656 #            printf '%s\t%s\n\t\t%s\n' 'TinyURL:' ${result} ${preview}
2657 #    else
2658 #        return 1
2659 #    fi
2660 #}
2661
2662 #f2# Find history events by search pattern and list them by date.
2663 whatwhen()  {
2664     emulate -L zsh
2665     local usage help ident format_l format_s first_char remain first last
2666     usage='USAGE: whatwhen [options] <searchstring> <search range>'
2667     help='Use `whatwhen -h'\'' for further explanations.'
2668     ident=${(l,${#${:-Usage: }},, ,)}
2669     format_l="${ident}%s\t\t\t%s\n"
2670     format_s="${format_l//(\\t)##/\\t}"
2671     # Make the first char of the word to search for case
2672     # insensitive; e.g. [aA]
2673     first_char=[${(L)1[1]}${(U)1[1]}]
2674     remain=${1[2,-1]}
2675     # Default search range is `-100'.
2676     first=${2:-\-100}
2677     # Optional, just used for `<first> <last>' given.
2678     last=$3
2679     case $1 in
2680         ("")
2681             printf '%s\n\n' 'ERROR: No search string specified. Aborting.'
2682             printf '%s\n%s\n\n' ${usage} ${help} && return 1
2683         ;;
2684         (-h)
2685             printf '%s\n\n' ${usage}
2686             print 'OPTIONS:'
2687             printf $format_l '-h' 'show help text'
2688             print '\f'
2689             print 'SEARCH RANGE:'
2690             printf $format_l "'0'" 'the whole history,'
2691             printf $format_l '-<n>' 'offset to the current history number; (default: -100)'
2692             printf $format_s '<[-]first> [<last>]' 'just searching within a give range'
2693             printf '\n%s\n' 'EXAMPLES:'
2694             printf ${format_l/(\\t)/} 'whatwhen grml' '# Range is set to -100 by default.'
2695             printf $format_l 'whatwhen zsh -250'
2696             printf $format_l 'whatwhen foo 1 99'
2697         ;;
2698         (\?)
2699             printf '%s\n%s\n\n' ${usage} ${help} && return 1
2700         ;;
2701         (*)
2702             # -l list results on stout rather than invoking $EDITOR.
2703             # -i Print dates as in YYYY-MM-DD.
2704             # -m Search for a - quoted - pattern within the history.
2705             fc -li -m "*${first_char}${remain}*" $first $last
2706         ;;
2707     esac
2708 }
2709
2710 # mercurial related stuff
2711 if check_com -c hg ; then
2712     # gnu like diff for mercurial
2713     # http://www.selenic.com/mercurial/wiki/index.cgi/TipsAndTricks
2714     #f5# GNU like diff for mercurial
2715     hgdi() {
2716         emulate -L zsh
2717         for i in $(hg status -marn "$@") ; diff -ubwd <(hg cat "$i") "$i"
2718     }
2719
2720     # build debian package
2721     #a2# Alias for \kbd{hg-buildpackage}
2722     alias hbp='hg-buildpackage'
2723
2724     # execute commands on the versioned patch-queue from the current repos
2725     alias mq='hg -R $(readlink -f $(hg root)/.hg/patches)'
2726
2727     # diffstat for specific version of a mercurial repository
2728     #   hgstat      => display diffstat between last revision and tip
2729     #   hgstat 1234 => display diffstat between revision 1234 and tip
2730     #f5# Diffstat for specific version of a mercurial repos
2731     hgstat() {
2732         emulate -L zsh
2733         [[ -n "$1" ]] && hg diff -r $1 -r tip | diffstat || hg export tip | diffstat
2734     }
2735
2736 fi # end of check whether we have the 'hg'-executable
2737
2738 # grml-small cleanups
2739
2740 # The following is used to remove zsh-config-items that do not work
2741 # in grml-small by default.
2742 # If you do not want these adjustments (for whatever reason), set
2743 # $GRMLSMALL_SPECIFIC to 0 in your .zshrc.pre file (which this configuration
2744 # sources if it is there).
2745
2746 if (( GRMLSMALL_SPECIFIC > 0 )) && isgrmlsmall ; then
2747
2748     unset abk[V]
2749     unalias    'V'      &> /dev/null
2750     unfunction vman     &> /dev/null
2751     unfunction viless   &> /dev/null
2752     unfunction 2html    &> /dev/null
2753
2754     # manpages are not in grmlsmall
2755     unfunction manzsh   &> /dev/null
2756     unfunction man2     &> /dev/null
2757
2758 fi
2759
2760 zrclocal
2761
2762 ## genrefcard.pl settings
2763
2764 ### doc strings for external functions from files
2765 #m# f5 grml-wallpaper() Sets a wallpaper (try completion for possible values)
2766
2767 ### example: split functions-search 8,16,24,32
2768 #@# split functions-search 8
2769
2770 ## END OF FILE #################################################################
2771 # vim:filetype=zsh foldmethod=marker autoindent expandtab shiftwidth=4
2772 # Local variables:
2773 # mode: sh
2774 # End: