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 # Contributing:
  15 # If you want to help to improve grml's zsh setup, clone the grml-etc-core
  16 # repository from git.grml.org:
  17 #   git clone git://git.grml.org/grml-etc-core.git
  18 #
  19 # Make your changes, commit them; use 'git format-patch' to create a series
  20 # of patches and send those to the following address via 'git send-email':
  21 #   grml-etc-core@grml.org
  22 #
  23 # Doing so makes sure the right people get your patches for review and
  24 # possibly inclusion.
  25
  26 # zsh-refcard-tag documentation: {{{
  27 #   You may notice strange looking comments in this file.
  28 #   These are there for a purpose. grml's zsh-refcard can now be
  29 #   automatically generated from the contents of the actual configuration
  30 #   file. However, we need a little extra information on which comments
  31 #   and what lines of code to take into account (and for what purpose).
  32 #
  33 # Here is what they mean:
  34 #
  35 # List of tags (comment types) used:
  36 #   #a#     Next line contains an important alias, that should
  37 #           be included in the grml-zsh-refcard.
  38 #           (placement tag: @@INSERT-aliases@@)
  39 #   #f#     Next line contains the beginning of an important function.
  40 #           (placement tag: @@INSERT-functions@@)
  41 #   #v#     Next line contains an important variable.
  42 #           (placement tag: @@INSERT-variables@@)
  43 #   #k#     Next line contains an important keybinding.
  44 #           (placement tag: @@INSERT-keybindings@@)
  45 #   #d#     Hashed directories list generation:
  46 #               start   denotes the start of a list of 'hash -d'
  47 #                       definitions.
  48 #               end     denotes its end.
  49 #           (placement tag: @@INSERT-hasheddirs@@)
  50 #   #A#     Abbreviation expansion list generation:
  51 #               start   denotes the beginning of abbreviations.
  52 #               end     denotes their end.
  53 #           Lines within this section that end in '#d .*' provide
  54 #           extra documentation to be included in the refcard.
  55 #           (placement tag: @@INSERT-abbrev@@)
  56 #   #m#     This tag allows you to manually generate refcard entries
  57 #           for code lines that are hard/impossible to parse.
  58 #               Example:
  59 #                   #m# k ESC-h Call the run-help function
  60 #               That would add a refcard entry in the keybindings table
  61 #               for 'ESC-h' with the given comment.
  62 #           So the syntax is: #m# <section> <argument> <comment>
  63 #   #o#     This tag lets you insert entries to the 'other' hash.
  64 #           Generally, this should not be used. It is there for
  65 #           things that cannot be done easily in another way.
  66 #           (placement tag: @@INSERT-other-foobar@@)
  67 #
  68 #   All of these tags (except for m and o) take two arguments, the first
  69 #   within the tag, the other after the tag:
  70 #
  71 #   #<tag><section># <comment>
  72 #
  73 #   Where <section> is really just a number, which are defined by the
  74 #   @secmap array on top of 'genrefcard.pl'. The reason for numbers
  75 #   instead of names is, that for the reader, the tag should not differ
  76 #   much from a regular comment. For zsh, it is a regular comment indeed.
  77 #   The numbers have got the following meanings:
  78 #         0 -> "default"
  79 #         1 -> "system"
  80 #         2 -> "user"
  81 #         3 -> "debian"
  82 #         4 -> "search"
  83 #         5 -> "shortcuts"
  84 #         6 -> "services"
  85 #
  86 #   So, the following will add an entry to the 'functions' table in the
  87 #   'system' section, with a (hopefully) descriptive comment:
  88 #       #f1# Edit an alias via zle
  89 #       edalias() {
  90 #
  91 #   It will then show up in the @@INSERT-aliases-system@@ replacement tag
  92 #   that can be found in 'grml-zsh-refcard.tex.in'.
  93 #   If the section number is omitted, the 'default' section is assumed.
  94 #   Furthermore, in 'grml-zsh-refcard.tex.in' @@INSERT-aliases@@ is
  95 #   exactly the same as @@INSERT-aliases-default@@. If you want a list of
  96 #   *all* aliases, for example, use @@INSERT-aliases-all@@.
  97 #}}}
  98
  99 # zsh profiling {{{
 100 # just execute 'ZSH_PROFILE_RC=1 zsh' and run 'zprof' to get the details
 101 if [[ $ZSH_PROFILE_RC -gt 0 ]] ; then
 102     zmodload zsh/zprof
 103 fi
 104 # }}}
 105
 106 # load .zshrc.pre to give the user the chance to overwrite the defaults
 107 [[ -r ${HOME}/.zshrc.pre ]] && source ${HOME}/.zshrc.pre
 108
 109 # {{{ check for version/system
 110 # check for versions (compatibility reasons)
 111 is4(){
 112     [[ $ZSH_VERSION == <4->* ]] && return 0
 113     return 1
 114 }
 115
 116 is41(){
 117     [[ $ZSH_VERSION == 4.<1->* || $ZSH_VERSION == <5->* ]] && return 0
 118     return 1
 119 }
 120
 121 is42(){
 122     [[ $ZSH_VERSION == 4.<2->* || $ZSH_VERSION == <5->* ]] && return 0
 123     return 1
 124 }
 125
 126 is425(){
 127     [[ $ZSH_VERSION == 4.2.<5->* || $ZSH_VERSION == 4.<3->* || $ZSH_VERSION == <5->* ]] && return 0
 128     return 1
 129 }
 130
 131 is43(){
 132     [[ $ZSH_VERSION == 4.<3->* || $ZSH_VERSION == <5->* ]] && return 0
 133     return 1
 134 }
 135
 136 is433(){
 137     [[ $ZSH_VERSION == 4.3.<3->* || $ZSH_VERSION == <5->* ]] && return 0
 138     return 1
 139 }
 140
 141 #f1# Checks whether or not you're running grml
 142 isgrml(){
 143     [[ -f /etc/grml_version ]] && return 0
 144     return 1
 145 }
 146
 147 #f1# Checks whether or not you're running a grml cd
 148 isgrmlcd(){
 149     [[ -f /etc/grml_cd ]] && return 0
 150     return 1
 151 }
 152
 153 if isgrml ; then
 154 #f1# Checks whether or not you're running grml-small
 155     isgrmlsmall() {
 156         [[ ${${${(f)"$(</etc/grml_version)"}%% *}##*-} == 'small' ]] && return 0 ; return 1
 157     }
 158 else
 159     isgrmlsmall() { return 1 }
 160 fi
 161
 162 isdarwin(){
 163     [[ $OSTYPE == darwin* ]] && return 0
 164     return 1
 165 }
 166
 167 #f1# are we running within an utf environment?
 168 isutfenv() {
 169     case "$LANG $CHARSET $LANGUAGE" in
 170         *utf*) return 0 ;;
 171         *UTF*) return 0 ;;
 172         *)     return 1 ;;
 173     esac
 174 }
 175
 176 # check for user, if not running as root set $SUDO to sudo
 177 (( EUID != 0 )) && SUDO='sudo' || SUDO=''
 178
 179 # change directory to home on first invocation of zsh
 180 # important for rungetty -> autologin
 181 # Thanks go to Bart Schaefer!
 182 isgrml && checkhome() {
 183     if [[ -z "$ALREADY_DID_CD_HOME" ]] ; then
 184         export ALREADY_DID_CD_HOME=$HOME
 185         cd
 186     fi
 187 }
 188
 189 # check for zsh v3.1.7+
 190
 191 if ! [[ ${ZSH_VERSION} == 3.1.<7->*      \
 192      || ${ZSH_VERSION} == 3.<2->.<->*    \
 193      || ${ZSH_VERSION} == <4->.<->*   ]] ; then
 194
 195     printf '-!-\n'
 196     printf '-!- In this configuration we try to make use of features, that only\n'
 197     printf '-!- require version 3.1.7 of the shell; That way this setup can be\n'
 198     printf '-!- used with a wide range of zsh versions, while using fairly\n'
 199     printf '-!- advanced features in all supported versions.\n'
 200     printf '-!-\n'
 201     printf '-!- However, you are running zsh version %s.\n' "$ZSH_VERSION"
 202     printf '-!-\n'
 203     printf '-!- While this *may* work, it might as well fail.\n'
 204     printf '-!- Please consider updating to at least version 3.1.7 of zsh.\n'
 205     printf '-!-\n'
 206     printf '-!- DO NOT EXPECT THIS TO WORK FLAWLESSLY!\n'
 207     printf '-!- If it does today, you'\''ve been lucky.\n'
 208     printf '-!-\n'
 209     printf '-!- Ye been warned!\n'
 210     printf '-!-\n'
 211
 212     function zstyle() { : }
 213 fi
 214
 215 # autoload wrapper - use this one instead of autoload directly
 216 # We need to define this function as early as this, because autoloading
 217 # 'is-at-least()' needs it.
 218 function zrcautoload() {
 219     emulate -L zsh
 220     setopt extended_glob
 221     local fdir ffile
 222     local -i ffound
 223
 224     ffile=$1
 225     (( found = 0 ))
 226     for fdir in ${fpath} ; do
 227         [[ -e ${fdir}/${ffile} ]] && (( ffound = 1 ))
 228     done
 229
 230     (( ffound == 0 )) && return 1
 231     if [[ $ZSH_VERSION == 3.1.<6-> || $ZSH_VERSION == <4->* ]] ; then
 232         autoload -U ${ffile} || return 1
 233     else
 234         autoload ${ffile} || return 1
 235     fi
 236     return 0
 237 }
 238
 239 # Load is-at-least() for more precise version checks
 240 # Note that this test will *always* fail, if the is-at-least
 241 # function could not be marked for autoloading.
 242 zrcautoload is-at-least || is-at-least() { return 1 }
 243
 244 # }}}
 245
 246 # {{{ set some important options (as early as possible)
 247 # Please update these tags, if you change the umask settings below.
 248 #o# r_umask     002
 249 #o# r_umaskstr  rwxrwxr-x
 250 #o# umask       022
 251 #o# umaskstr    rwxr-xr-x
 252 (( EUID != 0 )) && umask 002 || umask 022
 253
 254 setopt append_history       # append history list to the history file (important for multiple parallel zsh sessions!)
 255 is4 && setopt SHARE_HISTORY # import new commands from the history file also in other zsh-session
 256 setopt extended_history     # save each command's beginning timestamp and the duration to the history file
 257 is4 && setopt histignorealldups # If  a  new  command  line being added to the history
 258                             # list duplicates an older one, the older command is removed from the list
 259 setopt histignorespace      # remove command lines from the history list when
 260                             # the first character on the line is a space
 261 setopt auto_cd              # if a command is issued that can't be executed as a normal command,
 262                             # and the command is the name of a directory, perform the cd command to that directory
 263 setopt extended_glob        # in order to use #, ~ and ^ for filename generation
 264                             # grep word *~(*.gz|*.bz|*.bz2|*.zip|*.Z) ->
 265                             # -> searches for word not in compressed files
 266                             # don't forget to quote '^', '~' and '#'!
 267 setopt longlistjobs         # display PID when suspending processes as well
 268 setopt notify               # report the status of backgrounds jobs immediately
 269 setopt hash_list_all        # Whenever a command completion is attempted, make sure \
 270                             # the entire command path is hashed first.
 271 setopt completeinword       # not just at the end
 272 setopt nohup                # and don't kill them, either
 273 setopt auto_pushd           # make cd push the old directory onto the directory stack.
 274 setopt nonomatch            # try to avoid the 'zsh: no matches found...'
 275 setopt nobeep               # avoid "beep"ing
 276 setopt pushd_ignore_dups    # don't push the same dir twice.
 277 setopt noglobdots           # * shouldn't match dotfiles. ever.
 278 setopt noshwordsplit        # use zsh style word splitting
 279
 280 # }}}
 281
 282 # setting some default values {{{
 283
 284 NOCOR=${NOCOR:-0}
 285 NOMENU=${NOMENU:-0}
 286 NOPRECMD=${NOPRECMD:-0}
 287 COMMAND_NOT_FOUND=${COMMAND_NOT_FOUND:-0}
 288 GRML_ZSH_CNF_HANDLER=${GRML_ZSH_CNF_HANDLER:-/usr/share/command-not-found/command-not-found}
 289 BATTERY=${BATTERY:-0}
 290 GRMLSMALL_SPECIFIC=${GRMLSMALL_SPECIFIC:-1}
 291 GRML_ALWAYS_LOAD_ALL=${GRML_ALWAYS_LOAD_ALL:-0}
 292 ZSH_NO_DEFAULT_LOCALE=${ZSH_NO_DEFAULT_LOCALE:-0}
 293
 294 if isgrmlcd ; then
 295     GRML_WARN_SKEL=${GRML_WARN_SKEL:-0}
 296 else
 297     GRML_WARN_SKEL=${GRML_WARN_SKEL:-1}
 298 fi
 299
 300 if (( GRML_WARN_SKEL != 0 )) ; then
 301
 302 function grml_warn_skel_main() {
 303     printf '
 304 Dear user,
 305
 306 You updated grml'\''s zshrc which brings a major change.
 307 The configuration is kept only in one file, being the global zshrc.
 308 In the past, the configuration was split in two files, with the
 309 second file being the .zshrc file from /etc/skel.
 310
 311 If you have a .zshrc file in your home directory that originally
 312 came from the skel directory, please remove it. This is also the case
 313 if you followed earlier instructions from the grml-zsh-refcard or
 314 from <http://grml.org/console/> on non-grml systems.
 315
 316 Please see the current grml-zsh-refcard (available at
 317 <http://grml.org/zsh/>) for updated installation information. In short,
 318 you don'\''t want a .zshrc.global file. Install the global zshrc to
 319 ~/.zshrc and be done.
 320
 321 If you need changes to the configuration, use ~/.zshrc.pre and
 322 ~/.zshrc.local.
 323
 324 '
 325 }
 326
 327 function grml_warn_skel_remove() {
 328     printf 'To remove this warning execute '\''grml_do_not_warn_skel'\''.\n\n'
 329 }
 330
 331 function grml_do_not_warn_skel() {
 332     printf '# Do not warn about old skel dot-files anymore\n' >>! ~/.zshrc.pre
 333     printf 'GRML_WARN_SKEL=0\n' >>! ~/.zshrc.pre
 334 }
 335
 336 # let's try to guess how the user uses us.
 337 if is-at-least 4.3.7 ; then
 338     # funcsourcetrace requires at least version 4.3.7 of zsh.
 339     GRML_SRC_FILE="${${funcsourcetrace[1]}%:*}"
 340
 341     grml_warn_skel_main
 342     case ${GRML_SRC_FILE} in
 343         (${HOME}/.zshrc.global)
 344             grml_warn_skel_remove
 345             printf '\nIt looks like you copied the grml zshrc to '\''~/.zshrc.global'\''.\n'
 346             printf 'Nowadays you just copy the global zshrc to '\''~/.zshrc'\'' to use\n'
 347             printf 'it on a non-grml-system.\n'
 348             ;;
 349         (${HOME}/.zshrc)
 350             printf '\nIt looks like you copied the grml zshrc to '\''~/.zshrc'\''.\n'
 351             printf 'We'\''ll disable this warning automatically for later sessions.\n'
 352             grml_do_not_warn_skel
 353             ;;
 354         (*)
 355             grml_do_not_warn_skel
 356             ;;
 357     esac
 358 else
 359     grml_warn_skel_main
 360     grml_warn_skel_remove
 361 fi
 362
 363 unfunction grml_warn_skel_remove grml_warn_skel_main
 364
 365 fi # GRML_WARN_SKEL
 366
 367 # }}}
 368
 369 # utility functions {{{
 370 # this function checks if a command exists and returns either true
 371 # or false. This avoids using 'which' and 'whence', which will
 372 # avoid problems with aliases for which on certain weird systems. :-)
 373 # Usage: check_com [-c|-g] word
 374 #   -c  only checks for external commands
 375 #   -g  does the usual tests and also checks for global aliases
 376 check_com() {
 377     emulate -L zsh
 378     local -i comonly gatoo
 379
 380     if [[ $1 == '-c' ]] ; then
 381         (( comonly = 1 ))
 382         shift
 383     elif [[ $1 == '-g' ]] ; then
 384         (( gatoo = 1 ))
 385     else
 386         (( comonly = 0 ))
 387         (( gatoo = 0 ))
 388     fi
 389
 390     if (( ${#argv} != 1 )) ; then
 391         printf 'usage: check_com [-c] <command>\n' >&2
 392         return 1
 393     fi
 394
 395     if (( comonly > 0 )) ; then
 396         [[ -n ${commands[$1]}  ]] && return 0
 397         return 1
 398     fi
 399
 400     if   [[ -n ${commands[$1]}    ]] \
 401       || [[ -n ${functions[$1]}   ]] \
 402       || [[ -n ${aliases[$1]}     ]] \
 403       || [[ -n ${reswords[(r)$1]} ]] ; then
 404
 405         return 0
 406     fi
 407
 408     if (( gatoo > 0 )) && [[ -n ${galiases[$1]} ]] ; then
 409         return 0
 410     fi
 411
 412     return 1
 413 }
 414
 415 # creates an alias and precedes the command with
 416 # sudo if $EUID is not zero.
 417 salias() {
 418     emulate -L zsh
 419     local only=0 ; local multi=0
 420     while [[ $1 == -* ]] ; do
 421         case $1 in
 422             (-o) only=1 ;;
 423             (-a) multi=1 ;;
 424             (--) shift ; break ;;
 425             (-h)
 426                 printf 'usage: salias [-h|-o|-a] <alias-expression>\n'
 427                 printf '  -h      shows this help text.\n'
 428                 printf '  -a      replace '\'' ; '\'' sequences with '\'' ; sudo '\''.\n'
 429                 printf '          be careful using this option.\n'
 430                 printf '  -o      only sets an alias if a preceding sudo would be needed.\n'
 431                 return 0
 432                 ;;
 433             (*) printf "unkown option: '%s'\n" "$1" ; return 1 ;;
 434         esac
 435         shift
 436     done
 437
 438     if (( ${#argv} > 1 )) ; then
 439         printf 'Too many arguments %s\n' "${#argv}"
 440         return 1
 441     fi
 442
 443     key="${1%%\=*}" ;  val="${1#*\=}"
 444     if (( EUID == 0 )) && (( only == 0 )); then
 445         alias -- "${key}=${val}"
 446     elif (( EUID > 0 )) ; then
 447         (( multi > 0 )) && val="${val// ; / ; sudo }"
 448         alias -- "${key}=sudo ${val}"
 449     fi
 450
 451     return 0
 452 }
 453
 454 # a "print -l ${(u)foo}"-workaround for pre-4.2.0 shells
 455 # usage: uprint foo
 456 #   Where foo is the *name* of the parameter you want printed.
 457 #   Note that foo is no typo; $foo would be wrong here!
 458 if ! is42 ; then
 459     uprint () {
 460         emulate -L zsh
 461         local -a u
 462         local w
 463         local parameter=$1
 464
 465         if [[ -z ${parameter} ]] ; then
 466             printf 'usage: uprint <parameter>\n'
 467             return 1
 468         fi
 469
 470         for w in ${(P)parameter} ; do
 471             [[ -z ${(M)u:#$w} ]] && u=( $u $w )
 472         done
 473
 474         builtin print -l $u
 475     }
 476 fi
 477
 478 # Check if we can read given files and source those we can.
 479 xsource() {
 480     emulate -L zsh
 481     if (( ${#argv} < 1 )) ; then
 482         printf 'usage: xsource FILE(s)...\n' >&2
 483         return 1
 484     fi
 485
 486     while (( ${#argv} > 0 )) ; do
 487         [[ -r $1 ]] && source $1
 488         shift
 489     done
 490     return 0
 491 }
 492
 493 # Check if we can read a given file and 'cat(1)' it.
 494 xcat() {
 495     emulate -L zsh
 496     if (( ${#argv} != 1 )) ; then
 497         printf 'usage: xcat FILE\n' >&2
 498         return 1
 499     fi
 500
 501     [[ -r $1 ]] && cat $1
 502     return 0
 503 }
 504
 505 # Remove these functions again, they are of use only in these
 506 # setup files. This should be called at the end of .zshrc.
 507 xunfunction() {
 508     emulate -L zsh
 509     local -a funcs
 510     funcs=(salias xcat xsource xunfunction zrcautoload)
 511
 512     for func in $funcs ; do
 513         [[ -n ${functions[$func]} ]] \
 514             && unfunction $func
 515     done
 516     return 0
 517 }
 518
 519 # this allows us to stay in sync with grml's zshrc and put own
 520 # modifications in ~/.zshrc.local
 521 zrclocal() {
 522     xsource "/etc/zsh/zshrc.local"
 523     xsource "${HOME}/.zshrc.local"
 524     return 0
 525 }
 526
 527 #}}}
 528
 529 # locale setup {{{
 530 if (( ZSH_NO_DEFAULT_LOCALE == 0 )); then
 531     xsource "/etc/default/locale"
 532 fi
 533
 534 for var in LANG LC_ALL LC_MESSAGES ; do
 535     [[ -n ${(P)var} ]] && export $var
 536 done
 537
 538 xsource "/etc/sysconfig/keyboard"
 539
 540 TZ=$(xcat /etc/timezone)
 541 # }}}
 542
 543 # check for potentially old files in 'completion.d' {{{
 544 setopt extendedglob
 545 xof=(/etc/zsh/completion.d/*~/etc/zsh/completion.d/_*(N))
 546 if (( ${#xof} > 0 )) ; then
 547     printf '\n -!- INFORMATION\n\n'
 548     printf ' -!- %s file(s) not starting with an underscore (_) found in\n' ${#xof}
 549     printf ' -!- /etc/zsh/completion.d/.\n\n'
 550     printf ' -!- While this has been the case in old versions of grml-etc-core,\n'
 551     printf ' -!- recent versions of the grml-zsh-setup have all these files rewritten\n'
 552     printf ' -!- and renamed. Furthermore, the grml-zsh-setup will *only* add files\n'
 553     printf ' -!- named _* to that directory.\n\n'
 554     printf ' -!- If you added functions to completion.d yourself, please consider\n'
 555     printf ' -!- moving them to /etc/zsh/functions.d/. Files in that directory, not\n'
 556     printf ' -!- starting with an underscore are marked for automatic loading\n'
 557     printf ' -!- by default (so that is quite convenient).\n\n'
 558     printf ' -!- If there are files *not* starting with an underscore from an older\n'
 559     printf ' -!- grml-etc-core in completion.d, you may safely remove them.\n\n'
 560     printf ' -!- Delete the files for example via running:\n\n'
 561     printf "      rm ${xof}\n\n"
 562     printf ' -!- Note, that this message will *not* go away, unless you yourself\n'
 563     printf ' -!- resolve the situation manually.\n\n'
 564     BROKEN_COMPLETION_DIR=1
 565 fi
 566 unset xof
 567 # }}}
 568
 569 # {{{ set some variables
 570 if check_com -c vim ; then
 571 #v#
 572     export EDITOR=${EDITOR:-vim}
 573 else
 574     export EDITOR=${EDITOR:-vi}
 575 fi
 576
 577 #v#
 578 export PAGER=${PAGER:-less}
 579
 580 #v#
 581 export MAIL=${MAIL:-/var/mail/$USER}
 582
 583 # if we don't set $SHELL then aterm, rxvt,.. will use /bin/sh or /bin/bash :-/
 584 export SHELL='/bin/zsh'
 585
 586 # color setup for ls:
 587 check_com -c dircolors && eval $(dircolors -b)
 588 # color setup for ls on OS X:
 589 isdarwin && export CLICOLOR=1
 590
 591 # do MacPorts setup on darwin
 592 if isdarwin && [[ -d /opt/local ]]; then
 593     # Note: PATH gets set in /etc/zprofile on Darwin, so this can't go into
 594     # zshenv.
 595     PATH="/opt/local/bin:/opt/local/sbin:$PATH"
 596     MANPATH="/opt/local/share/man:$MANPATH"
 597 fi
 598 # do Fink setup on darwin
 599 isdarwin && xsource /sw/bin/init.sh
 600
 601 # completion functions go to /etc/zsh/completion.d
 602 # function files may be put into /etc/zsh/functions.d, from where they
 603 # will be automatically autoloaded.
 604 if [[ -n "$BROKEN_COMPLETION_DIR" ]] ; then
 605     print 'Warning: not setting completion directories because broken files have been found.' >&2
 606 else
 607     [[ -d /etc/zsh/completion.d ]] && fpath=( $fpath /etc/zsh/completion.d )
 608     if [[ -d /etc/zsh/functions.d ]] ; then
 609         fdir='/etc/zsh/functions.d'
 610         fpath=( ${fdir} ${fdir}/**/*(/N) ${fpath} )
 611         for func in ${fdir}/**/[^_]*[^~](N.) ; do
 612             zrcautoload ${func:t}
 613         done
 614         unset fdir
 615     fi
 616 fi
 617
 618 # support colors in less
 619 export LESS_TERMCAP_mb=$'\E[01;31m'
 620 export LESS_TERMCAP_md=$'\E[01;31m'
 621 export LESS_TERMCAP_me=$'\E[0m'
 622 export LESS_TERMCAP_se=$'\E[0m'
 623 export LESS_TERMCAP_so=$'\E[01;44;33m'
 624 export LESS_TERMCAP_ue=$'\E[0m'
 625 export LESS_TERMCAP_us=$'\E[01;32m'
 626
 627 MAILCHECK=30       # mailchecks
 628 REPORTTIME=5       # report about cpu-/system-/user-time of command if running longer than 5 seconds
 629 watch=(notme root) # watch for everyone but me and root
 630
 631 # automatically remove duplicates from these arrays
 632 typeset -U path cdpath fpath manpath
 633 # }}}
 634
 635 # {{{ keybindings
 636 if [[ "$TERM" != emacs ]] ; then
 637     [[ -z "$terminfo[kdch1]" ]] || bindkey -M emacs "$terminfo[kdch1]" delete-char
 638     [[ -z "$terminfo[khome]" ]] || bindkey -M emacs "$terminfo[khome]" beginning-of-line
 639     [[ -z "$terminfo[kend]"  ]] || bindkey -M emacs "$terminfo[kend]"  end-of-line
 640     [[ -z "$terminfo[kdch1]" ]] || bindkey -M vicmd "$terminfo[kdch1]" vi-delete-char
 641     [[ -z "$terminfo[khome]" ]] || bindkey -M vicmd "$terminfo[khome]" vi-beginning-of-line
 642     [[ -z "$terminfo[kend]"  ]] || bindkey -M vicmd "$terminfo[kend]"  vi-end-of-line
 643     [[ -z "$terminfo[cuu1]"  ]] || bindkey -M viins "$terminfo[cuu1]"  vi-up-line-or-history
 644     [[ -z "$terminfo[cuf1]"  ]] || bindkey -M viins "$terminfo[cuf1]"  vi-forward-char
 645     [[ -z "$terminfo[kcuu1]" ]] || bindkey -M viins "$terminfo[kcuu1]" vi-up-line-or-history
 646     [[ -z "$terminfo[kcud1]" ]] || bindkey -M viins "$terminfo[kcud1]" vi-down-line-or-history
 647     [[ -z "$terminfo[kcuf1]" ]] || bindkey -M viins "$terminfo[kcuf1]" vi-forward-char
 648     [[ -z "$terminfo[kcub1]" ]] || bindkey -M viins "$terminfo[kcub1]" vi-backward-char
 649     # ncurses stuff:
 650     [[ "$terminfo[kcuu1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcuu1]/O/[}" vi-up-line-or-history
 651     [[ "$terminfo[kcud1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcud1]/O/[}" vi-down-line-or-history
 652     [[ "$terminfo[kcuf1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcuf1]/O/[}" vi-forward-char
 653     [[ "$terminfo[kcub1]" == $'\eO'* ]] && bindkey -M viins "${terminfo[kcub1]/O/[}" vi-backward-char
 654     [[ "$terminfo[khome]" == $'\eO'* ]] && bindkey -M viins "${terminfo[khome]/O/[}" beginning-of-line
 655     [[ "$terminfo[kend]"  == $'\eO'* ]] && bindkey -M viins "${terminfo[kend]/O/[}"  end-of-line
 656     [[ "$terminfo[khome]" == $'\eO'* ]] && bindkey -M emacs "${terminfo[khome]/O/[}" beginning-of-line
 657     [[ "$terminfo[kend]"  == $'\eO'* ]] && bindkey -M emacs "${terminfo[kend]/O/[}"  end-of-line
 658 fi
 659
 660 ## keybindings (run 'bindkeys' for details, more details via man zshzle)
 661 # use emacs style per default:
 662 bindkey -e
 663 # use vi style:
 664 # bindkey -v
 665
 666 #if [[ "$TERM" == screen ]] ; then
 667 bindkey '\e[1~' beginning-of-line       # home
 668 bindkey '\e[4~' end-of-line             # end
 669 bindkey '\e[A'  up-line-or-search       # cursor up
 670 bindkey '\e[B'  down-line-or-search     # <ESC>-
 671
 672 bindkey '^xp'   history-beginning-search-backward
 673 bindkey '^xP'   history-beginning-search-forward
 674 # bindkey -s '^L' "|less\n"             # ctrl-L pipes to less
 675 # bindkey -s '^B' " &\n"                # ctrl-B runs it in the background
 676 # if terminal type is set to 'rxvt':
 677 bindkey '\e[7~' beginning-of-line       # home
 678 bindkey '\e[8~' end-of-line             # end
 679 #fi
 680
 681 # insert unicode character
 682 # usage example: 'ctrl-x i' 00A7 'ctrl-x i' will give you an §
 683 # See for example http://unicode.org/charts/ for unicode characters code
 684 zrcautoload insert-unicode-char
 685 zle -N insert-unicode-char
 686 #k# Insert Unicode character
 687 bindkey '^Xi' insert-unicode-char
 688
 689 # just type 'cd ...' to get 'cd ../..'
 690 #  rationalise-dot() {
 691 #  if [[ $LBUFFER == *.. ]] ; then
 692 #    LBUFFER+=/..
 693 #  else
 694 #    LBUFFER+=.
 695 #  fi
 696 #  }
 697 #  zle -N rationalise-dot
 698 #  bindkey . rationalise-dot
 699
 700 #  bindkey '\eq' push-line-or-edit
 701
 702 ## toggle the ,. abbreviation feature on/off
 703 # NOABBREVIATION: default abbreviation-state
 704 #                 0 - enabled (default)
 705 #                 1 - disabled
 706 NOABBREVIATION=${NOABBREVIATION:-0}
 707
 708 grml_toggle_abbrev() {
 709     if (( ${NOABBREVIATION} > 0 )) ; then
 710         NOABBREVIATION=0
 711     else
 712         NOABBREVIATION=1
 713     fi
 714 }
 715
 716 zle -N grml_toggle_abbrev
 717 bindkey '^xA' grml_toggle_abbrev
 718
 719 # add a command line to the shells history without executing it
 720 commit-to-history() {
 721     print -s ${(z)BUFFER}
 722     zle send-break
 723 }
 724 zle -N commit-to-history
 725 bindkey "^x^h" commit-to-history
 726
 727 # only slash should be considered as a word separator:
 728 slash-backward-kill-word() {
 729     local WORDCHARS="${WORDCHARS:s@/@}"
 730     # zle backward-word
 731     zle backward-kill-word
 732 }
 733 zle -N slash-backward-kill-word
 734
 735 #k# Kill everything in a word up to its last \kbd{/}
 736 bindkey '\ev' slash-backward-kill-word
 737
 738 # }}}
 739
 740 # a generic accept-line wrapper {{{
 741
 742 # This widget can prevent unwanted autocorrections from command-name
 743 # to _command-name, rehash automatically on enter and call any number
 744 # of builtin and user-defined widgets in different contexts.
 745 #
 746 # For a broader description, see:
 747 # <http://bewatermyfriend.org/posts/2007/12-26.11-50-38-tooltime.html>
 748 #
 749 # The code is imported from the file 'zsh/functions/accept-line' from
 750 # <http://ft.bewatermyfriend.org/comp/zsh/zsh-dotfiles.tar.bz2>, which
 751 # distributed under the same terms as zsh itself.
 752
 753 # A newly added command will may not be found or will cause false
 754 # correction attempts, if you got auto-correction set. By setting the
 755 # following style, we force accept-line() to rehash, if it cannot
 756 # find the first word on the command line in the $command[] hash.
 757 zstyle ':acceptline:*' rehash true
 758
 759 function Accept-Line() {
 760     setopt localoptions noksharrays
 761     local -a subs
 762     local -xi aldone
 763     local sub
 764
 765     zstyle -a ":acceptline:${alcontext}" actions subs
 766
 767     (( ${#subs} < 1 )) && return 0
 768
 769     (( aldone = 0 ))
 770     for sub in ${subs} ; do
 771         [[ ${sub} == 'accept-line' ]] && sub='.accept-line'
 772         zle ${sub}
 773
 774         (( aldone > 0 )) && break
 775     done
 776 }
 777
 778 function Accept-Line-getdefault() {
 779     local default_action
 780
 781     zstyle -s ":acceptline:${alcontext}" default_action default_action
 782     case ${default_action} in
 783         ((accept-line|))
 784             printf ".accept-line"
 785             ;;
 786         (*)
 787             printf ${default_action}
 788             ;;
 789     esac
 790 }
 791
 792 function accept-line() {
 793     setopt localoptions noksharrays
 794     local -a cmdline
 795     local -x alcontext
 796     local buf com fname format msg default_action
 797
 798     alcontext='default'
 799     buf="${BUFFER}"
 800     cmdline=(${(z)BUFFER})
 801     com="${cmdline[1]}"
 802     fname="_${com}"
 803
 804     zstyle -t ":acceptline:${alcontext}" rehash \
 805         && [[ -z ${commands[$com]} ]]           \
 806         && rehash
 807
 808     if    [[ -n ${reswords[(r)$com]} ]] \
 809        || [[ -n ${aliases[$com]}     ]] \
 810        || [[ -n ${functions[$com]}   ]] \
 811        || [[ -n ${builtins[$com]}    ]] \
 812        || [[ -n ${commands[$com]}    ]] ; then
 813
 814         # there is something sensible to execute, just do it.
 815         alcontext='normal'
 816         zle Accept-Line
 817
 818         default_action=$(Accept-Line-getdefault)
 819         zstyle -T ":acceptline:${alcontext}" call_default \
 820             && zle ${default_action}
 821         return
 822     fi
 823
 824     if    [[ -o correct              ]] \
 825        || [[ -o correctall           ]] \
 826        && [[ -n ${functions[$fname]} ]] ; then
 827
 828         # nothing there to execute but there is a function called
 829         # _command_name; a completion widget. Makes no sense to
 830         # call it on the commandline, but the correct{,all} options
 831         # will ask for it nevertheless, so warn the user.
 832         if [[ ${LASTWIDGET} == 'accept-line' ]] ; then
 833             # Okay, we warned the user before, he called us again,
 834             # so have it his way.
 835             alcontext='force'
 836             zle Accept-Line
 837
 838             default_action=$(Accept-Line-getdefault)
 839             zstyle -T ":acceptline:${alcontext}" call_default \
 840                 && zle ${default_action}
 841             return
 842         fi
 843
 844         # prepare warning message for the user, configurable via zstyle.
 845         zstyle -s ":acceptline:${alcontext}" compwarnfmt msg
 846
 847         if [[ -z ${msg} ]] ; then
 848             msg="%c will not execute and completion %f exists."
 849         fi
 850
 851         zformat -f msg "${msg}" "c:${com}" "f:${fname}"
 852
 853         zle -M -- "${msg}"
 854         return
 855     elif [[ -n ${buf//[$' \t\n']##/} ]] ; then
 856         # If we are here, the commandline contains something that is not
 857         # executable, which is neither subject to _command_name correction
 858         # and is not empty. might be a variable assignment
 859         alcontext='misc'
 860         zle Accept-Line
 861
 862         default_action=$(Accept-Line-getdefault)
 863         zstyle -T ":acceptline:${alcontext}" call_default \
 864             && zle ${default_action}
 865         return
 866     fi
 867
 868     # If we got this far, the commandline only contains whitespace, or is empty.
 869     alcontext='empty'
 870     zle Accept-Line
 871
 872     default_action=$(Accept-Line-getdefault)
 873     zstyle -T ":acceptline:${alcontext}" call_default \
 874         && zle ${default_action}
 875 }
 876
 877 zle -N accept-line
 878 zle -N Accept-Line
 879
 880 # }}}
 881
 882 # power completion - abbreviation expansion {{{
 883 # power completion / abbreviation expansion / buffer expansion
 884 # see http://zshwiki.org/home/examples/zleiab for details
 885 # less risky than the global aliases but powerful as well
 886 # just type the abbreviation key and afterwards ',.' to expand it
 887 declare -A abk
 888 setopt extendedglob
 889 setopt interactivecomments
 890 abk=(
 891 #   key   # value                  (#d additional doc string)
 892 #A# start
 893     '...'  '../..'
 894     '....' '../../..'
 895     'BG'   '& exit'
 896     'C'    '| wc -l'
 897     'G'    '|& grep --color=auto '
 898     'H'    '| head'
 899     'Hl'   ' --help |& less -r'    #d (Display help in pager)
 900     'L'    '| less'
 901     'LL'   '|& less -r'
 902     'M'    '| most'
 903     'N'    '&>/dev/null'           #d (No Output)
 904     'R'    '| tr A-z N-za-m'       #d (ROT13)
 905     'SL'   '| sort | less'
 906     'S'    '| sort -u'
 907     'T'    '| tail'
 908     'V'    '|& vim -'
 909 #A# end
 910     'co'   './configure && make && sudo make install'
 911 )
 912
 913 globalias() {
 914     emulate -L zsh
 915     setopt extendedglob
 916     local MATCH
 917
 918     if (( NOABBREVIATION > 0 )) ; then
 919         LBUFFER="${LBUFFER},."
 920         return 0
 921     fi
 922
 923     matched_chars='[.-|_a-zA-Z0-9]#'
 924     LBUFFER=${LBUFFER%%(#m)[.-|_a-zA-Z0-9]#}
 925     LBUFFER+=${abk[$MATCH]:-$MATCH}
 926 }
 927
 928 zle -N globalias
 929 bindkey ",." globalias
 930 # }}}
 931
 932 # {{{ autoloading
 933 zrcautoload zmv    # who needs mmv or rename?
 934 zrcautoload history-search-end
 935
 936 # we don't want to quote/espace URLs on our own...
 937 # if autoload -U url-quote-magic ; then
 938 #    zle -N self-insert url-quote-magic
 939 #    zstyle ':url-quote-magic:*' url-metas '*?[]^()~#{}='
 940 # else
 941 #    print 'Notice: no url-quote-magic available :('
 942 # fi
 943 alias url-quote='autoload -U url-quote-magic ; zle -N self-insert url-quote-magic'
 944
 945 #m# k ESC-h Call \kbd{run-help} for the 1st word on the command line
 946 alias run-help >&/dev/null && unalias run-help
 947 zrcautoload run-help # use via 'esc-h'
 948
 949 # completion system
 950 if zrcautoload compinit ; then
 951     compinit || print 'Notice: no compinit available :('
 952 else
 953     print 'Notice: no compinit available :('
 954     function zstyle { }
 955     function compdef { }
 956 fi
 957
 958 is4 && zrcautoload zed # use ZLE editor to edit a file or function
 959
 960 is4 && \
 961 for mod in complist deltochar mathfunc ; do
 962     zmodload -i zsh/${mod} 2>/dev/null || print "Notice: no ${mod} available :("
 963 done
 964
 965 # autoload zsh modules when they are referenced
 966 if is4 ; then
 967     tmpargs=(
 968         a   stat
 969         a   zpty
 970         ap  mapfile
 971     )
 972
 973     while (( ${#tmpargs} > 0 )) ; do
 974         zmodload -${tmpargs[1]} zsh/${tmpargs[2]} ${tmpargs[2]}
 975         shift 2 tmpargs
 976     done
 977     unset tmpargs
 978 fi
 979
 980 if is4 && zrcautoload insert-files && zle -N insert-files ; then
 981     #k# Insert files
 982     bindkey "^Xf" insert-files # C-x-f
 983 fi
 984
 985 bindkey ' '   magic-space    # also do history expansion on space
 986 #k# Trigger menu-complete
 987 bindkey '\ei' menu-complete  # menu completion via esc-i
 988
 989 # press esc-e for editing command line in $EDITOR or $VISUAL
 990 if is4 && zrcautoload edit-command-line && zle -N edit-command-line ; then
 991     #k# Edit the current line in \kbd{\$EDITOR}
 992     bindkey '\ee' edit-command-line
 993 fi
 994
 995 if is4 && [[ -n ${(k)modules[zsh/complist]} ]] ; then
 996     #k# menu selection: pick item but stay in the menu
 997     bindkey -M menuselect '\e^M' accept-and-menu-complete
 998
 999     # accept a completion and try to complete again by using menu
1000     # completion; very useful with completing directories
1001     # by using 'undo' one's got a simple file browser
1002     bindkey -M menuselect '^o' accept-and-infer-next-history
1003 fi
1004
1005 # press "ctrl-e d" to insert the actual date in the form yyyy-mm-dd
1006 _bkdate() { BUFFER="$BUFFER$(date '+%F')"; CURSOR=$#BUFFER; }
1007 zle -N _bkdate
1008
1009 #k# Insert a timestamp on the command line (yyyy-mm-dd)
1010 bindkey '^Ed' _bkdate
1011
1012 # press esc-m for inserting last typed word again (thanks to caphuso!)
1013 insert-last-typed-word() { zle insert-last-word -- 0 -1 };
1014 zle -N insert-last-typed-word;
1015
1016 #k# Insert last typed word
1017 bindkey "\em" insert-last-typed-word
1018
1019 #k# Shortcut for \kbd{fg<enter>}
1020 bindkey -s '^z' "fg\n"
1021
1022 # run command line as user root via sudo:
1023 sudo-command-line() {
1024     [[ -z $BUFFER ]] && zle up-history
1025     [[ $BUFFER != sudo\ * ]] && BUFFER="sudo $BUFFER"
1026 }
1027 zle -N sudo-command-line
1028
1029 #k# Put the current command line into a \kbd{sudo} call
1030 bindkey "^Os" sudo-command-line
1031
1032 ### jump behind the first word on the cmdline.
1033 ### useful to add options.
1034 function jump_after_first_word() {
1035     local words
1036     words=(${(z)BUFFER})
1037
1038     if (( ${#words} <= 1 )) ; then
1039         CURSOR=${#BUFFER}
1040     else
1041         CURSOR=${#${words[1]}}
1042     fi
1043 }
1044 zle -N jump_after_first_word
1045
1046 bindkey '^x1' jump_after_first_word
1047
1048 # }}}
1049
1050 # {{{ history
1051
1052 ZSHDIR=$HOME/.zsh
1053
1054 #v#
1055 HISTFILE=$HOME/.zsh_history
1056 isgrmlcd && HISTSIZE=500  || HISTSIZE=5000
1057 isgrmlcd && SAVEHIST=1000 || SAVEHIST=10000 # useful for setopt append_history
1058
1059 # }}}
1060
1061 # dirstack handling {{{
1062
1063 DIRSTACKSIZE=${DIRSTACKSIZE:-20}
1064 DIRSTACKFILE=${DIRSTACKFILE:-${HOME}/.zdirs}
1065
1066 if [[ -f ${DIRSTACKFILE} ]] && [[ ${#dirstack[*]} -eq 0 ]] ; then
1067     dirstack=( ${(f)"$(< $DIRSTACKFILE)"} )
1068     # "cd -" won't work after login by just setting $OLDPWD, so
1069     [[ -d $dirstack[0] ]] && cd $dirstack[0] && cd $OLDPWD
1070 fi
1071
1072 chpwd() {
1073     if is42 ; then
1074         builtin print -l ${(u)dirstack} >! ${DIRSTACKFILE}
1075     else
1076         uprint dirstack >! ${DIRSTACKFILE}
1077     fi
1078 }
1079
1080 # }}}
1081
1082 # directory based profiles {{{
1083
1084 if is433 ; then
1085
1086 CHPWD_PROFILE='default'
1087 function chpwd_profiles() {
1088     # Say you want certain settings to be active in certain directories.
1089     # This is what you want.
1090     #
1091     # zstyle ':chpwd:profiles:/usr/src/grml(|/|/*)'   profile grml
1092     # zstyle ':chpwd:profiles:/usr/src/debian(|/|/*)' profile debian
1093     #
1094     # When that's done and you enter a directory that matches the pattern
1095     # in the third part of the context, a function called chpwd_profile_grml,
1096     # for example, is called (if it exists).
1097     #
1098     # If no pattern matches (read: no profile is detected) the profile is
1099     # set to 'default', which means chpwd_profile_default is attempted to
1100     # be called.
1101     #
1102     # A word about the context (the ':chpwd:profiles:*' stuff in the zstyle
1103     # command) which is used: The third part in the context is matched against
1104     # ${PWD}. That's why using a pattern such as /foo/bar(|/|/*) makes sense.
1105     # Because that way the profile is detected for all these values of ${PWD}:
1106     #   /foo/bar
1107     #   /foo/bar/
1108     #   /foo/bar/baz
1109     # So, if you want to make double damn sure a profile works in /foo/bar
1110     # and everywhere deeper in that tree, just use (|/|/*) and be happy.
1111     #
1112     # The name of the detected profile will be available in a variable called
1113     # 'profile' in your functions. You don't need to do anything, it'll just
1114     # be there.
1115     #
1116     # Then there is the parameter $CHPWD_PROFILE is set to the profile, that
1117     # was is currently active. That way you can avoid running code for a
1118     # profile that is already active, by running code such as the following
1119     # at the start of your function:
1120     #
1121     # function chpwd_profile_grml() {
1122     #     [[ ${profile} == ${CHPWD_PROFILE} ]] && return 1
1123     #   ...
1124     # }
1125     #
1126     # The initial value for $CHPWD_PROFILE is 'default'.
1127     #
1128     # Version requirement:
1129     #   This feature requires zsh 4.3.3 or newer.
1130     #   If you use this feature and need to know whether it is active in your
1131     #   current shell, there are several ways to do that. Here are two simple
1132     #   ways:
1133     #
1134     #   a) If knowing if the profiles feature is active when zsh starts is
1135     #      good enough for you, you can put the following snippet into your
1136     #      .zshrc.local:
1137     #
1138     #   (( ${+functions[chpwd_profiles]} )) && print "directory profiles active"
1139     #
1140     #   b) If that is not good enough, and you would prefer to be notified
1141     #      whenever a profile changes, you can solve that by making sure you
1142     #      start *every* profile function you create like this:
1143     #
1144     #   function chpwd_profile_myprofilename() {
1145     #       [[ ${profile} == ${CHPWD_PROFILE} ]] && return 1
1146     #       print "chpwd(): Switching to profile: $profile"
1147     #     ...
1148     #   }
1149     #
1150     #      That makes sure you only get notified if a profile is *changed*,
1151     #      not everytime you change directory, which would probably piss
1152     #      you off fairly quickly. :-)
1153     #
1154     # There you go. Now have fun with that.
1155     local -x profile
1156
1157     zstyle -s ":chpwd:profiles:${PWD}" profile profile || profile='default'
1158     if (( ${+functions[chpwd_profile_$profile]} )) ; then
1159         chpwd_profile_${profile}
1160     fi
1161
1162     CHPWD_PROFILE="${profile}"
1163     return 0
1164 }
1165 chpwd_functions=( ${chpwd_functions} chpwd_profiles )
1166
1167 fi # is433
1168
1169 # }}}
1170
1171 # {{{ display battery status on right side of prompt via running 'BATTERY=1 zsh'
1172 if [[ $BATTERY -gt 0 ]] ; then
1173     if ! check_com -c acpi ; then
1174         BATTERY=0
1175     fi
1176 fi
1177
1178 battery() {
1179 if [[ $BATTERY -gt 0 ]] ; then
1180     PERCENT="${${"$(acpi 2>/dev/null)"}/(#b)[[:space:]]#Battery <->: [^0-9]##, (<->)%*/${match[1]}}"
1181     if [[ -z "$PERCENT" ]] ; then
1182         PERCENT='acpi not present'
1183     else
1184         if [[ "$PERCENT" -lt 20 ]] ; then
1185             PERCENT="warning: ${PERCENT}%%"
1186         else
1187             PERCENT="${PERCENT}%%"
1188         fi
1189     fi
1190 fi
1191 }
1192 # }}}
1193
1194 # set colors for use in prompts {{{
1195 if zrcautoload colors && colors 2>/dev/null ; then
1196     BLUE="%{${fg[blue]}%}"
1197     RED="%{${fg_bold[red]}%}"
1198     GREEN="%{${fg[green]}%}"
1199     CYAN="%{${fg[cyan]}%}"
1200     MAGENTA="%{${fg[magenta]}%}"
1201     YELLOW="%{${fg[yellow]}%}"
1202     WHITE="%{${fg[white]}%}"
1203     NO_COLOUR="%{${reset_color}%}"
1204 else
1205     BLUE=$'%{\e[1;34m%}'
1206     RED=$'%{\e[1;31m%}'
1207     GREEN=$'%{\e[1;32m%}'
1208     CYAN=$'%{\e[1;36m%}'
1209     WHITE=$'%{\e[1;37m%}'
1210     MAGENTA=$'%{\e[1;35m%}'
1211     YELLOW=$'%{\e[1;33m%}'
1212     NO_COLOUR=$'%{\e[0m%}'
1213 fi
1214
1215 # }}}
1216
1217 # gather version control information for inclusion in a prompt {{{
1218
1219 if ! is41 ; then
1220     # Be quiet about version problems in grml's zshrc as the user cannot disable
1221     # loading vcs_info() as it is *in* the zshrc - as you can see. :-)
1222     # Just unset most probable variables and disable vcs_info altogether.
1223     local -i i
1224     for i in {0..9} ; do
1225         unset VCS_INFO_message_${i}_
1226     done
1227     zstyle ':vcs_info:*' enable false
1228 fi
1229
1230 # The following code is imported from the file 'zsh/functions/vcs_info'
1231 # from <http://ft.bewatermyfriend.org/comp/zsh/zsh-dotfiles.tar.bz2>,
1232 # which distributed under the same terms as zsh itself.
1233
1234 # we will be using two variables, so let the code know now.
1235 zstyle ':vcs_info:*' max-exports 2
1236
1237 # vcs_info() documentation:
1238 #{{{
1239 # REQUIREMENTS:
1240 #{{{
1241 #     This functionality requires zsh version >= 4.1.*.
1242 #}}}
1243 #
1244 # LOADING:
1245 #{{{
1246 # To load vcs_info(), copy this file to your $fpath[] and do:
1247 #   % autoload -Uz vcs_info && vcs_info
1248 #
1249 # To work, vcs_info() needs 'setopt prompt_subst' in your setup.
1250 #}}}
1251 #
1252 # QUICKSTART:
1253 #{{{
1254 # To get vcs_info() working quickly (including colors), you can do the
1255 # following (assuming, you loaded vcs_info() properly - see above):
1256 #
1257 # % RED=$'%{\e[31m%}'
1258 # % GR=$'%{\e[32m%}'
1259 # % MA=$'%{\e[35m%}'
1260 # % YE=$'%{\e[33m%}'
1261 # % NC=$'%{\e[0m%}'
1262 #
1263 # % zstyle ':vcs_info:*' actionformats \
1264 #       "${MA}(${NC}%s${MA})${YE}-${MA}[${GR}%b${YE}|${RED}%a${MA}]${NC} "
1265 #
1266 # % zstyle ':vcs_info:*' formats       \
1267 #       "${MA}(${NC}%s${MA})${Y}-${MA}[${GR}%b${MA}]${NC}%} "
1268 #
1269 # % zstyle ':vcs_info:(sv[nk]|bzr):*' branchformat "%b${RED}:${YE}%r"
1270 #
1271 # % precmd () { vcs_info }
1272 # % PS1='${MA}[${GR}%n${MA}] ${MA}(${RED}%!${MA}) ${YE}%3~ ${VCS_INFO_message_0_}${NC}%# '
1273 #
1274 # Obviously, the las two lines are there for demonstration: You need to
1275 # call vcs_info() from your precmd() function (see 'SPECIAL FUNCTIONS' in
1276 # 'man zshmisc'). Once that is done you need a *single* quoted
1277 # '${VCS_INFO_message_0_}' in your prompt.
1278 #
1279 # Now call the 'vcs_info_printsys' utility from the command line:
1280 #
1281 # % vcs_info_printsys
1282 # # list of supported version control backends:
1283 # # disabled systems are prefixed by a hash sign (#)
1284 # git
1285 # hg
1286 # bzr
1287 # darcs
1288 # svk
1289 # mtn
1290 # svn
1291 # cvs
1292 # cdv
1293 # tla
1294 # # flavours (cannot be used in the disable style; they
1295 # # are disabled with their master [git-svn -> git]):
1296 # git-p4
1297 # git-svn
1298 #
1299 # Ten version control backends as you can see. You may not want all
1300 # of these. Because there is no point in running the code to detect
1301 # systems you do not use. ever. So, there is a way to disable some
1302 # backends altogether:
1303 #
1304 # % zstyle ':vcs_info:*' disable bzr cdv darcs mtn svk tla
1305 #
1306 # If you rerun 'vcs_info_printsys' now, you will see the backends listed
1307 # in the 'disable' style marked as diabled by a hash sign. That means the
1308 # detection of these systems is skipped *completely*. No wasted time there.
1309 #
1310 # For more control, read the reference below.
1311 #}}}
1312 #
1313 # CONFIGURATION:
1314 #{{{
1315 # The vcs_info() feature can be configured via zstyle.
1316 #
1317 # First, the context in which we are working:
1318 #       :vcs_info:<vcs-string>:<user-context>
1319 #
1320 # ...where <vcs-string> is one of:
1321 #   - git, git-svn, git-p4, hg, darcs, bzr, cdv, mtn, svn, cvs, svk or tla.
1322 #
1323 # ...and <user-context> is a freely configurable string, assignable by the
1324 # user as the first argument to vcs_info() (see its description below).
1325 #
1326 # There is are three special values for <vcs-string>: The first is named
1327 # 'init', that is in effect as long as there was no decision what vcs
1328 # backend to use. The second is 'preinit; it is used *before* vcs_info()
1329 # is run, when initializing the data exporting variables. The third
1330 # special value is 'formats' and is used by the 'vcs_info_lastmsg' for
1331 # looking up its styles.
1332 #
1333 # There are two pre-defined values for <user-context>:
1334 #   default  - the one used if none is specified
1335 #   command  - used by vcs_info_lastmsg to lookup its styles.
1336 #
1337 # You may *not* use 'print_systems_' as a user-context string, because it
1338 # is used internally.
1339 #
1340 # You can of course use ':vcs_info:*' to match all VCSs in all
1341 # user-contexts at once.
1342 #
1343 # Another special context is 'formats', which is used by the
1344 # vcs_info_lastmsg() utility function (see below).
1345 #
1346 #
1347 # This is a description of all styles, that are looked up:
1348 #   formats             - A list of formats, used when actionformats is not
1349 #                         used (which is most of the time).
1350 #   actionformats       - A list of formats, used if a there is a special
1351 #                         action going on in your current repository;
1352 #                         (like an interactive rebase or a merge conflict)
1353 #   branchformat        - Some backends replace %b in the formats and
1354 #                         actionformats styles above, not only by a branch
1355 #                         name but also by a revision number. This style
1356 #                         let's you modify how that string should look like.
1357 #   nvcsformats         - These "formats" are exported, when we didn't detect
1358 #                         a version control system for the current directory.
1359 #                         This is useful, if you want vcs_info() to completely
1360 #                         take over the generation of your prompt.
1361 #                         You would do something like
1362 #                           PS1='${VCS_INFO_message_0_}'
1363 #                         to accomplish that.
1364 #   max-exports         - Defines the maximum number if VCS_INFO_message_*_
1365 #                         variables vcs_info() will export.
1366 #   enable              - Checked in the 'init' context. If set to false,
1367 #                         vcs_info() will do nothing.
1368 #   disable             - Provide a list of systems, you don't want
1369 #                         the vcs_info() to check for repositories
1370 #                         (checked in the 'init' context, too).
1371 #   disable-patterns    - A list of patterns that are checked against $PWD.
1372 #                         If the pattern matches, vcs_info will be disabled.
1373 #                         Say, ~/.zsh is a directory under version control,
1374 #                         in which you do not want vcs_info to be active, do:
1375 #                         zstyle ':vcs_info:*' disable-patterns "$HOME/.zsh+(|/*)"
1376 #   use-simple          - If there are two different ways of gathering
1377 #                         information, you can select the simpler one
1378 #                         by setting this style to true; the default
1379 #                         is to use the not-that-simple code, which is
1380 #                         potentially a lot slower but might be more
1381 #                         accurate in all possible cases.
1382 #   use-prompt-escapes  - determines if we assume that the assembled
1383 #                         string from vcs_info() includes prompt escapes.
1384 #                         (Used by vcs_info_lastmsg().
1385 #
1386 # The use-simple style is only available for the bzr backend.
1387 #
1388 # The default values for these in all contexts are:
1389 #   formats             " (%s)-[%b|%a]-"
1390 #   actionformats       " (%s)-[%b]-"
1391 #   branchformat        "%b:%r" (for bzr, svn and svk)
1392 #   nvcsformats         ""
1393 #   max-exports         2
1394 #   enable              true
1395 #   disable             (empty list)
1396 #   disable-patterns    (empty list)
1397 #   use-simple          false
1398 #   use-prompt-escapes  true
1399 #
1400 #
1401 # In normal formats and actionformats, the following replacements
1402 # are done:
1403 #   %s  - The vcs in use (git, hg, svn etc.)
1404 #   %b  - Information about the current branch.
1405 #   %a  - An identifier, that describes the action.
1406 #         Only makes sense in actionformats.
1407 #   %R  - base directory of the repository.
1408 #   %r  - repository name
1409 #         If %R is '/foo/bar/repoXY', %r is 'repoXY'.
1410 #   %S  - subdirectory within a repository. if $PWD is
1411 #         '/foo/bar/reposXY/beer/tasty', %S is 'beer/tasty'.
1412 #
1413 #
1414 # In branchformat these replacements are done:
1415 #   %b  - the branch name
1416 #   %r  - the current revision number
1417 #
1418 # Not all vcs backends have to support all replacements.
1419 # nvcsformat does not perform *any* replacements. It is just a string.
1420 #}}}
1421 #
1422 # ODDITIES:
1423 #{{{
1424 # If you want to use the %b (bold off) prompt expansion in 'formats', which
1425 # expands %b itself, use %%b. That will cause the vcs_info() expansion to
1426 # replace %%b with %b. So zsh's prompt expansion mechanism can handle it.
1427 # Similarly, to hand down %b from branchformat, use %%%%b. Sorry for this
1428 # inconvenience, but it cannot be easily avoided. Luckily we do not clash
1429 # with a lot of prompt expansions and this only needs to be done for those.
1430 # See 'man zshmisc' for details about EXPANSION OF PROMPT SEQUENCES.
1431 #}}}
1432 #
1433 # FUNCTION DESCRIPTIONS (public API):
1434 #{{{
1435 #   vcs_info()
1436 #       The main function, that runs all backends and assembles
1437 #       all data into ${VCS_INFO_message_*_}. This is the function
1438 #       you want to call from precmd() if you want to include
1439 #       up-to-date information in your prompt (see VARIABLE
1440 #       DESCRIPTION below).
1441 #
1442 #   vcs_info_printsys()
1443 #       Prints a list of all supported version control systems.
1444 #       Useful to find out possible contexts (and which of them are enabled)
1445 #       or values for the 'disable' style.
1446 #
1447 #   vcs_info_lastmsg()
1448 #       Outputs the last ${VCS_INFO_message_*_} value. Takes into account
1449 #       the value of the use-prompt-escapes style in ':vcs_info:formats'.
1450 #       It also only prints max-exports values.
1451 #
1452 # All functions named VCS_INFO_* are for internal use only.
1453 #}}}
1454 #
1455 # VARIABLE DESCRIPTION:
1456 #{{{
1457 #   ${VCS_INFO_message_N_}    (Note the trailing underscore)
1458 #       Where 'N' is an integer, eg: VCS_INFO_message_0_
1459 #       These variables are the storage for the informational message the
1460 #       last vcs_info() call has assembled. These are strongly connected
1461 #       to the formats, actionformats and nvcsformats styles described
1462 #       above. Those styles are lists. the first member of that list gets
1463 #       expanded into ${VCS_INFO_message_0_}, the second into
1464 #       ${VCS_INFO_message_1_} and the Nth into ${VCS_INFO_message_N-1_}.
1465 #       These parameters are exported into the environment.
1466 #       (See the max-exports style above.)
1467 #}}}
1468 #
1469 # EXAMPLES:
1470 #{{{
1471 #   Don't use vcs_info at all (even though it's in your prompt):
1472 #   % zstyle ':vcs_info:*' enable false
1473 #
1474 #   Disable the backends for bzr and svk:
1475 #   % zstyle ':vcs_info:*' disable bzr svk
1476 #
1477 #   Provide a special formats for git:
1478 #   % zstyle ':vcs_info:git:*' formats       ' GIT, BABY! [%b]'
1479 #   % zstyle ':vcs_info:git:*' actionformats ' GIT ACTION! [%b|%a]'
1480 #
1481 #   Use the quicker bzr backend (if you do, please report if it does
1482 #   the-right-thing[tm] - thanks):
1483 #   % zstyle ':vcs_info:bzr:*' use-simple true
1484 #
1485 #   Display the revision number in yellow for bzr and svn:
1486 #   % zstyle ':vcs_info:(svn|bzr):*' branchformat '%b%{'${fg[yellow]}'%}:%r'
1487 #
1488 # If you want colors, make sure you enclose the color codes in %{...%},
1489 # if you want to use the string provided by vcs_info() in prompts.
1490 #
1491 # Here is how to print the vcs infomation as a command:
1492 #   % alias vcsi='vcs_info command; vcs_info_lastmsg'
1493 #
1494 #   This way, you can even define different formats for output via
1495 #   vcs_info_lastmsg() in the ':vcs_info:command:*' namespace.
1496 #}}}
1497 #}}}
1498 # utilities
1499 VCS_INFO_adjust () { #{{{
1500     [[ -n ${vcs_comm[overwrite_name]} ]] && vcs=${vcs_comm[overwrite_name]}
1501     return 0
1502 }
1503 # }}}
1504 VCS_INFO_check_com () { #{{{
1505     (( ${+commands[$1]} )) && [[ -x ${commands[$1]} ]] && return 0
1506     return 1
1507 }
1508 # }}}
1509 VCS_INFO_formats () { # {{{
1510     setopt localoptions noksharrays
1511     local action=$1 branch=$2 base=$3
1512     local msg
1513     local -i i
1514
1515     if [[ -n ${action} ]] ; then
1516         zstyle -a ":vcs_info:${vcs}:${usercontext}" actionformats msgs
1517         (( ${#msgs} < 1 )) && msgs[1]=' (%s)-[%b|%a]-'
1518     else
1519         zstyle -a ":vcs_info:${vcs}:${usercontext}" formats msgs
1520         (( ${#msgs} < 1 )) && msgs[1]=' (%s)-[%b]-'
1521     fi
1522
1523     (( ${#msgs} > maxexports )) && msgs[$(( maxexports + 1 )),-1]=()
1524     for i in {1..${#msgs}} ; do
1525         zformat -f msg ${msgs[$i]}                      \
1526                         a:${action}                     \
1527                         b:${branch}                     \
1528                         r:${base:t}                     \
1529                         s:${vcs}                        \
1530                         R:${base}                       \
1531                         S:"$(VCS_INFO_reposub ${base})"
1532         msgs[$i]=${msg}
1533     done
1534     return 0
1535 }
1536 # }}}
1537 VCS_INFO_maxexports () { #{{{
1538     zstyle -s ":vcs_info:${vcs}:${usercontext}" "max-exports" maxexports || maxexports=2
1539     if [[ ${maxexports} != <-> ]] || (( maxexports < 1 )); then
1540         printf 'vcs_info(): expecting numeric arg >= 1 for max-exports (got %s).\n' ${maxexports}
1541         printf 'Defaulting to 2.\n'
1542         maxexports=2
1543     fi
1544 }
1545 # }}}
1546 VCS_INFO_nvcsformats () { #{{{
1547     setopt localoptions noksharrays
1548     local c v
1549
1550     if [[ $1 == 'preinit' ]] ; then
1551         c=default
1552         v=preinit
1553     fi
1554     zstyle -a ":vcs_info:${v:-$vcs}:${c:-$usercontext}" nvcsformats msgs
1555     (( ${#msgs} > maxexports )) && msgs[${maxexports},-1]=()
1556 }
1557 # }}}
1558 VCS_INFO_realpath () { #{{{
1559     # a portable 'readlink -f'
1560     # forcing a subshell, to ensure chpwd() is not removed
1561     # from the calling shell (if VCS_INFO_realpath() is called
1562     # manually).
1563     (
1564         (( ${+functions[chpwd]} )) && unfunction chpwd
1565         setopt chaselinks
1566         cd $1 2>/dev/null && pwd
1567     )
1568 }
1569 # }}}
1570 VCS_INFO_reposub () { #{{{
1571     setopt localoptions extendedglob
1572     local base=${1%%/##}
1573
1574     [[ ${PWD} == ${base}/* ]] || {
1575         printf '.'
1576         return 1
1577     }
1578     printf '%s' ${PWD#$base/}
1579     return 0
1580 }
1581 # }}}
1582 VCS_INFO_set () { #{{{
1583     setopt localoptions noksharrays
1584     local -i i j
1585
1586     if [[ $1 == '--clear' ]] ; then
1587         for i in {0..9} ; do
1588             unset VCS_INFO_message_${i}_
1589         done
1590     fi
1591     if [[ $1 == '--nvcs' ]] ; then
1592         [[ $2 == 'preinit' ]] && (( maxexports == 0 )) && (( maxexports = 1 ))
1593         for i in {0..$((maxexports - 1))} ; do
1594             typeset -gx VCS_INFO_message_${i}_=
1595         done
1596         VCS_INFO_nvcsformats $2
1597     fi
1598
1599     (( ${#msgs} - 1 < 0 )) && return 0
1600     for i in {0..$(( ${#msgs} - 1 ))} ; do
1601         (( j = i + 1 ))
1602         typeset -gx VCS_INFO_message_${i}_=${msgs[$j]}
1603     done
1604     return 0
1605 }
1606 # }}}
1607 # information gathering
1608 VCS_INFO_bzr_get_data () { # {{{
1609     setopt localoptions noksharrays
1610     local bzrbase bzrbr
1611     local -a bzrinfo
1612
1613     if zstyle -t ":vcs_info:${vcs}:${usercontext}" "use-simple" ; then
1614         bzrbase=${vcs_comm[basedir]}
1615         bzrinfo[2]=${bzrbase:t}
1616         if [[ -f ${bzrbase}/.bzr/branch/last-revision ]] ; then
1617             bzrinfo[1]=$(< ${bzrbase}/.bzr/branch/last-revision)
1618             bzrinfo[1]=${${bzrinfo[1]}%% *}
1619         fi
1620     else
1621         bzrbase=${${(M)${(f)"$( bzr info )"}:# ##branch\ root:*}/*: ##/}
1622         bzrinfo=( ${${${(M)${(f)"$( bzr version-info )"}:#(#s)(revno|branch-nick)*}/*: /}/*\//} )
1623         bzrbase="$(VCS_INFO_realpath ${bzrbase})"
1624     fi
1625
1626     zstyle -s ":vcs_info:${vcs}:${usercontext}" branchformat bzrbr || bzrbr="%b:%r"
1627     zformat -f bzrbr "${bzrbr}" "b:${bzrinfo[2]}" "r:${bzrinfo[1]}"
1628     VCS_INFO_formats '' "${bzrbr}" "${bzrbase}"
1629     return 0
1630 }
1631 # }}}
1632 VCS_INFO_cdv_get_data () { # {{{
1633     local cdvbase
1634
1635     cdvbase=${vcs_comm[basedir]}
1636     VCS_INFO_formats '' "${cdvbase:t}" "${cdvbase}"
1637     return 0
1638 }
1639 # }}}
1640 VCS_INFO_cvs_get_data () { # {{{
1641     local cvsbranch cvsbase basename
1642
1643     cvsbase="."
1644     while [[ -d "${cvsbase}/../CVS" ]]; do
1645         cvsbase="${cvsbase}/.."
1646     done
1647     cvsbase="$(VCS_INFO_realpath ${cvsbase})"
1648     cvsbranch=$(< ./CVS/Repository)
1649     basename=${cvsbase:t}
1650     cvsbranch=${cvsbranch##${basename}/}
1651     [[ -z ${cvsbranch} ]] && cvsbranch=${basename}
1652     VCS_INFO_formats '' "${cvsbranch}" "${cvsbase}"
1653     return 0
1654 }
1655 # }}}
1656 VCS_INFO_darcs_get_data () { # {{{
1657     local darcsbase
1658
1659     darcsbase=${vcs_comm[basedir]}
1660     VCS_INFO_formats '' "${darcsbase:t}" "${darcsbase}"
1661     return 0
1662 }
1663 # }}}
1664 VCS_INFO_git_getaction () { #{{{
1665     local gitaction='' gitdir=$1
1666     local tmp
1667
1668     for tmp in "${gitdir}/rebase-apply" \
1669                "${gitdir}/rebase"       \
1670                "${gitdir}/../.dotest" ; do
1671         if [[ -d ${tmp} ]] ; then
1672             if   [[ -f "${tmp}/rebasing" ]] ; then
1673                 gitaction="rebase"
1674             elif [[ -f "${tmp}/applying" ]] ; then
1675                 gitaction="am"
1676             else
1677                 gitaction="am/rebase"
1678             fi
1679             printf '%s' ${gitaction}
1680             return 0
1681         fi
1682     done
1683
1684     for tmp in "${gitdir}/rebase-merge/interactive" \
1685                "${gitdir}/.dotest-merge/interactive" ; do
1686         if [[ -f "${tmp}" ]] ; then
1687             printf '%s' "rebase-i"
1688             return 0
1689         fi
1690     done
1691
1692     for tmp in "${gitdir}/rebase-merge" \
1693                "${gitdir}/.dotest-merge" ; do
1694         if [[ -d "${tmp}" ]] ; then
1695             printf '%s' "rebase-m"
1696             return 0
1697         fi
1698     done
1699
1700     if [[ -f "${gitdir}/MERGE_HEAD" ]] ; then
1701         printf '%s' "merge"
1702         return 0
1703     fi
1704
1705     if [[ -f "${gitdir}/BISECT_LOG" ]] ; then
1706         printf '%s' "bisect"
1707         return 0
1708     fi
1709     return 1
1710 }
1711 # }}}
1712 VCS_INFO_git_getbranch () { #{{{
1713     local gitbranch gitdir=$1
1714     local gitsymref='git symbolic-ref HEAD'
1715
1716     if    [[ -d "${gitdir}/rebase-apply" ]] \
1717        || [[ -d "${gitdir}/rebase" ]]       \
1718        || [[ -d "${gitdir}/../.dotest" ]]   \
1719        || [[ -f "${gitdir}/MERGE_HEAD" ]] ; then
1720         gitbranch="$(${(z)gitsymref} 2> /dev/null)"
1721         [[ -z ${gitbranch} ]] && [[ -r ${gitdir}/rebase-apply/head-name ]] \
1722             && gitbranch="$(< ${gitdir}/rebase-apply/head-name)"
1723
1724     elif   [[ -f "${gitdir}/rebase-merge/interactive" ]] \
1725         || [[ -d "${gitdir}/rebase-merge" ]] ; then
1726         gitbranch="$(< ${gitdir}/rebase-merge/head-name)"
1727
1728     elif   [[ -f "${gitdir}/.dotest-merge/interactive" ]] \
1729         || [[ -d "${gitdir}/.dotest-merge" ]] ; then
1730         gitbranch="$(< ${gitdir}/.dotest-merge/head-name)"
1731
1732     else
1733         gitbranch="$(${(z)gitsymref} 2> /dev/null)"
1734
1735         if [[ $? -ne 0 ]] ; then
1736             gitbranch="$(git describe --exact-match HEAD 2>/dev/null)"
1737
1738             if [[ $? -ne 0 ]] ; then
1739                 gitbranch="${${"$(< $gitdir/HEAD)"}[1,7]}..."
1740             fi
1741         fi
1742     fi
1743
1744     printf '%s' "${gitbranch##refs/heads/}"
1745     return 0
1746 }
1747 # }}}
1748 VCS_INFO_git_get_data () { # {{{
1749     setopt localoptions extendedglob
1750     local gitdir gitbase gitbranch gitaction
1751
1752     gitdir=${vcs_comm[gitdir]}
1753     gitbranch="$(VCS_INFO_git_getbranch ${gitdir})"
1754
1755     if [[ -z ${gitdir} ]] || [[ -z ${gitbranch} ]] ; then
1756         return 1
1757     fi
1758
1759     VCS_INFO_adjust
1760     gitaction="$(VCS_INFO_git_getaction ${gitdir})"
1761     gitbase=${PWD%/${$( git rev-parse --show-prefix )%/##}}
1762     VCS_INFO_formats "${gitaction}" "${gitbranch}" "${gitbase}"
1763     return 0
1764 }
1765 # }}}
1766 VCS_INFO_hg_get_data () { # {{{
1767     local hgbranch hgbase file
1768
1769     hgbase=${vcs_comm[basedir]}
1770
1771     file="${hgbase}/.hg/branch"
1772     if [[ -r ${file} ]] ; then
1773         hgbranch=$(< ${file})
1774     else
1775         hgbranch='default'
1776     fi
1777
1778     VCS_INFO_formats '' "${hgbranch}" "${hgbase}"
1779     return 0
1780 }
1781 # }}}
1782 VCS_INFO_mtn_get_data () { # {{{
1783     local mtnbranch mtnbase
1784
1785     mtnbase=${vcs_comm[basedir]}
1786     mtnbranch=${${(M)${(f)"$( mtn status )"}:#(#s)Current branch:*}/*: /}
1787     VCS_INFO_formats '' "${mtnbranch}" "${mtnbase}"
1788     return 0
1789 }
1790 # }}}
1791 VCS_INFO_svk_get_data () { # {{{
1792     local svkbranch svkbase
1793
1794     svkbase=${vcs_comm[basedir]}
1795     zstyle -s ":vcs_info:${vcs}:${usercontext}" branchformat svkbranch || svkbranch="%b:%r"
1796     zformat -f svkbranch "${svkbranch}" "b:${vcs_comm[branch]}" "r:${vcs_comm[revision]}"
1797     VCS_INFO_formats '' "${svkbranch}" "${svkbase}"
1798     return 0
1799 }
1800 # }}}
1801 VCS_INFO_svn_get_data () { # {{{
1802     setopt localoptions noksharrays
1803     local svnbase svnbranch
1804     local -a svninfo
1805
1806     svnbase="."
1807     while [[ -d "${svnbase}/../.svn" ]]; do
1808         svnbase="${svnbase}/.."
1809     done
1810     svnbase="$(VCS_INFO_realpath ${svnbase})"
1811     svninfo=( ${${${(M)${(f)"$( svn info )"}:#(#s)(URL|Revision)*}/*: /}/*\//} )
1812
1813     zstyle -s ":vcs_info:${vcs}:${usercontext}" branchformat svnbranch || svnbranch="%b:%r"
1814     zformat -f svnbranch "${svnbranch}" "b:${svninfo[1]}" "r:${svninfo[2]}"
1815     VCS_INFO_formats '' "${svnbranch}" "${svnbase}"
1816     return 0
1817 }
1818 # }}}
1819 VCS_INFO_tla_get_data () { # {{{
1820     local tlabase tlabranch
1821
1822     tlabase="$(VCS_INFO_realpath ${vcs_comm[basedir]})"
1823     # tree-id gives us something like 'foo@example.com/demo--1.0--patch-4', so:
1824     tlabranch=${${"$( tla tree-id )"}/*\//}
1825     VCS_INFO_formats '' "${tlabranch}" "${tlabase}"
1826     return 0
1827 }
1828 # }}}
1829 # detection
1830 VCS_INFO_detect_by_dir() { #{{{
1831     local dirname=$1
1832     local basedir="." realbasedir
1833
1834     realbasedir="$(VCS_INFO_realpath ${basedir})"
1835     while [[ ${realbasedir} != '/' ]]; do
1836         if [[ -n ${vcs_comm[detect_need_file]} ]] ; then
1837             [[ -d ${basedir}/${dirname} ]] && \
1838             [[ -e ${basedir}/${dirname}/${vcs_comm[detect_need_file]} ]] && \
1839                 break
1840         else
1841             [[ -d ${basedir}/${dirname} ]] && break
1842         fi
1843
1844         basedir=${basedir}/..
1845         realbasedir="$(VCS_INFO_realpath ${basedir})"
1846     done
1847
1848     [[ ${realbasedir} == "/" ]] && return 1
1849     vcs_comm[basedir]=${realbasedir}
1850     return 0
1851 }
1852 # }}}
1853 VCS_INFO_bzr_detect() { #{{{
1854     VCS_INFO_check_com bzr || return 1
1855     vcs_comm[detect_need_file]=branch/format
1856     VCS_INFO_detect_by_dir '.bzr'
1857     return $?
1858 }
1859 # }}}
1860 VCS_INFO_cdv_detect() { #{{{
1861     VCS_INFO_check_com cdv || return 1
1862     vcs_comm[detect_need_file]=format
1863     VCS_INFO_detect_by_dir '.cdv'
1864     return $?
1865 }
1866 # }}}
1867 VCS_INFO_cvs_detect() { #{{{
1868     VCS_INFO_check_com svn || return 1
1869     [[ -d "./CVS" ]] && [[ -r "./CVS/Repository" ]] && return 0
1870     return 1
1871 }
1872 # }}}
1873 VCS_INFO_darcs_detect() { #{{{
1874     VCS_INFO_check_com darcs || return 1
1875     vcs_comm[detect_need_file]=format
1876     VCS_INFO_detect_by_dir '_darcs'
1877     return $?
1878 }
1879 # }}}
1880 VCS_INFO_git_detect() { #{{{
1881     if VCS_INFO_check_com git && git rev-parse --is-inside-work-tree &> /dev/null ; then
1882         vcs_comm[gitdir]="$(git rev-parse --git-dir 2> /dev/null)" || return 1
1883         if   [[ -d ${vcs_comm[gitdir]}/svn ]]             ; then vcs_comm[overwrite_name]='git-svn'
1884         elif [[ -d ${vcs_comm[gitdir]}/refs/remotes/p4 ]] ; then vcs_comm[overwrite_name]='git-p4' ; fi
1885         return 0
1886     fi
1887     return 1
1888 }
1889 # }}}
1890 VCS_INFO_hg_detect() { #{{{
1891     VCS_INFO_check_com hg || return 1
1892     vcs_comm[detect_need_file]=store
1893     VCS_INFO_detect_by_dir '.hg'
1894     return $?
1895 }
1896 # }}}
1897 VCS_INFO_mtn_detect() { #{{{
1898     VCS_INFO_check_com mtn || return 1
1899     vcs_comm[detect_need_file]=revision
1900     VCS_INFO_detect_by_dir '_MTN'
1901     return $?
1902 }
1903 # }}}
1904 VCS_INFO_svk_detect() { #{{{
1905     setopt localoptions noksharrays extendedglob
1906     local -a info
1907     local -i fhash
1908     fhash=0
1909
1910     VCS_INFO_check_com svk || return 1
1911     [[ -f ~/.svk/config ]] || return 1
1912
1913     # This detection function is a bit different from the others.
1914     # We need to read svk's config file to detect a svk repository
1915     # in the first place. Therefore, we'll just proceed and read
1916     # the other information, too. This is more then any of the
1917     # other detections do but this takes only one file open for
1918     # svk at most. VCS_INFO_svk_get_data() get simpler, too. :-)
1919     while IFS= read -r line ; do
1920         if [[ -n ${vcs_comm[basedir]} ]] ; then
1921             line=${line## ##}
1922             [[ ${line} == depotpath:* ]] && vcs_comm[branch]=${line##*/}
1923             [[ ${line} == revision:* ]] && vcs_comm[revision]=${line##*[[:space:]]##}
1924             [[ -n ${vcs_comm[branch]} ]] && [[ -n ${vcs_comm[revision]} ]] && break
1925             continue
1926         fi
1927         (( fhash > 0 )) && [[ ${line} == '  '[^[:space:]]*:* ]] && break
1928         [[ ${line} == '  hash:'* ]] && fhash=1 && continue
1929         (( fhash == 0 )) && continue
1930         [[ ${PWD}/ == ${${line## ##}%:*}/* ]] && vcs_comm[basedir]=${${line## ##}%:*}
1931     done < ~/.svk/config
1932
1933     [[ -n ${vcs_comm[basedir]} ]]  && \
1934     [[ -n ${vcs_comm[branch]} ]]   && \
1935     [[ -n ${vcs_comm[revision]} ]] && return 0
1936     return 1
1937 }
1938 # }}}
1939 VCS_INFO_svn_detect() { #{{{
1940     VCS_INFO_check_com svn || return 1
1941     [[ -d ".svn" ]] && return 0
1942     return 1
1943 }
1944 # }}}
1945 VCS_INFO_tla_detect() { #{{{
1946     VCS_INFO_check_com tla || return 1
1947     vcs_comm[basedir]="$(tla tree-root 2> /dev/null)" && return 0
1948     return 1
1949 }
1950 # }}}
1951 # public API
1952 vcs_info_printsys () { # {{{
1953     vcs_info print_systems_
1954 }
1955 # }}}
1956 vcs_info_lastmsg () { # {{{
1957     local -i i
1958
1959     VCS_INFO_maxexports
1960     for i in {0..$((maxexports - 1))} ; do
1961         printf '$VCS_INFO_message_%d_: "' $i
1962         if zstyle -T ':vcs_info:formats:command' use-prompt-escapes ; then
1963             print -nP ${(P)${:-VCS_INFO_message_${i}_}}
1964         else
1965             print -n ${(P)${:-VCS_INFO_message_${i}_}}
1966         fi
1967         printf '"\n'
1968     done
1969 }
1970 # }}}
1971 vcs_info () { # {{{
1972     local pat
1973     local -i found
1974     local -a VCSs disabled dps
1975     local -x vcs usercontext
1976     local -ix maxexports
1977     local -ax msgs
1978     local -Ax vcs_comm
1979
1980     vcs="init"
1981     VCSs=(git hg bzr darcs svk mtn svn cvs cdv tla)
1982     case $1 in
1983         (print_systems_)
1984             zstyle -a ":vcs_info:${vcs}:${usercontext}" "disable" disabled
1985             print -l '# list of supported version control backends:' \
1986                      '# disabled systems are prefixed by a hash sign (#)'
1987             for vcs in ${VCSs} ; do
1988                 [[ -n ${(M)disabled:#${vcs}} ]] && printf '#'
1989                 printf '%s\n' ${vcs}
1990             done
1991             print -l '# flavours (cannot be used in the disable style; they' \
1992                      '# are disabled with their master [git-svn -> git]):'   \
1993                      git-{p4,svn}
1994             return 0
1995             ;;
1996         ('')
1997             [[ -z ${usercontext} ]] && usercontext=default
1998             ;;
1999         (*) [[ -z ${usercontext} ]] && usercontext=$1
2000             ;;
2001     esac
2002
2003     zstyle -T ":vcs_info:${vcs}:${usercontext}" "enable" || {
2004         [[ -n ${VCS_INFO_message_0_} ]] && VCS_INFO_set --clear
2005         return 0
2006     }
2007     zstyle -a ":vcs_info:${vcs}:${usercontext}" "disable" disabled
2008
2009     zstyle -a ":vcs_info:${vcs}:${usercontext}" "disable-patterns" dps
2010     for pat in ${dps} ; do
2011         if [[ ${PWD} == ${~pat} ]] ; then
2012             [[ -n ${vcs_info_msg_0_} ]] && VCS_INFO_set --clear
2013             return 0
2014         fi
2015     done
2016
2017     VCS_INFO_maxexports
2018
2019     (( found = 0 ))
2020     for vcs in ${VCSs} ; do
2021         [[ -n ${(M)disabled:#${vcs}} ]] && continue
2022         vcs_comm=()
2023         VCS_INFO_${vcs}_detect && (( found = 1 )) && break
2024     done
2025
2026     (( found == 0 )) && {
2027         VCS_INFO_set --nvcs
2028         return 0
2029     }
2030
2031     VCS_INFO_${vcs}_get_data || {
2032         VCS_INFO_set --nvcs
2033         return 1
2034     }
2035
2036     VCS_INFO_set
2037     return 0
2038 }
2039
2040 VCS_INFO_set --nvcs preinit
2041 # }}}
2042
2043 # Change vcs_info formats for the grml prompt. The 2nd format sets up
2044 # $vcs_info_msg_1_ to contain "zsh: repo-name" used to set our screen title.
2045 # TODO: The included vcs_info() version still uses $VCS_INFO_message_N_.
2046 #       That needs to be the use of $VCS_INFO_message_N_ needs to be changed
2047 #       to $vcs_info_msg_N_ as soon as we use the included version.
2048 if [[ "$TERM" == dumb ]] ; then
2049     zstyle ':vcs_info:*' actionformats "(%s%)-[%b|%a] " "zsh: %r"
2050     zstyle ':vcs_info:*' formats       "(%s%)-[%b] "    "zsh: %r"
2051 else
2052     # these are the same, just with a lot of colours:
2053     zstyle ':vcs_info:*' actionformats "${MAGENTA}(${NO_COLOUR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${YELLOW}|${RED}%a${MAGENTA}]${NO_COLOUR} " \
2054                                        "zsh: %r"
2055     zstyle ':vcs_info:*' formats       "${MAGENTA}(${NO_COLOUR}%s${MAGENTA})${YELLOW}-${MAGENTA}[${GREEN}%b${MAGENTA}]${NO_COLOUR}%} " \
2056                                        "zsh: %r"
2057     zstyle ':vcs_info:(sv[nk]|bzr):*' branchformat "%b${RED}:${YELLOW}%r"
2058 fi
2059
2060 # }}}
2061
2062 # command not found handling {{{
2063
2064 (( ${COMMAND_NOT_FOUND} == 1 )) &&
2065 function command_not_found_handler() {
2066     emulate -L zsh
2067     if [[ -x ${GRML_ZSH_CNF_HANDLER} ]] ; then
2068         ${GRML_ZSH_CNF_HANDLER} $1
2069     fi
2070     return 1
2071 }
2072
2073 # }}}
2074
2075 # {{{ set prompt
2076 if zrcautoload promptinit && promptinit 2>/dev/null ; then
2077     promptinit # people should be able to use their favourite prompt
2078 else
2079     print 'Notice: no promptinit available :('
2080 fi
2081
2082 setopt prompt_subst
2083
2084 # make sure to use right prompt only when not running a command
2085 is41 && setopt transient_rprompt
2086
2087 # TODO: revise all these NO* variables and especially their documentation
2088 #       in zsh-help() below.
2089 is4 && [[ $NOPRECMD -eq 0 ]] && precmd () {
2090     [[ $NOPRECMD -gt 0 ]] && return 0
2091     # update VCS information
2092     vcs_info
2093
2094     if [[ $TERM == screen* ]] ; then
2095         if [[ -n ${VCS_INFO_message_1_} ]] ; then
2096             print -nP "\ek${VCS_INFO_message_1_}\e\\"
2097         else
2098             print -nP "\ekzsh\e\\"
2099         fi
2100     fi
2101     # just use DONTSETRPROMPT=1 to be able to overwrite RPROMPT
2102     if [[ $DONTSETRPROMPT -eq 0 ]] ; then
2103         if [[ $BATTERY -gt 0 ]] ; then
2104             # update battery (dropped into $PERCENT) information
2105             battery
2106             RPROMPT="%(?..:() ${PERCENT}"
2107         else
2108             RPROMPT="%(?..:() "
2109         fi
2110     fi
2111     # adjust title of xterm
2112     # see http://www.faqs.org/docs/Linux-mini/Xterm-Title.html
2113     [[ ${NOTITLE} -gt 0 ]] && return 0
2114     case $TERM in
2115         (xterm*|rxvt*)
2116             print -Pn "\e]0;%n@%m: %~\a"
2117             ;;
2118     esac
2119 }
2120
2121 # preexec() => a function running before every command
2122 is4 && [[ $NOPRECMD -eq 0 ]] && \
2123 preexec () {
2124     [[ $NOPRECMD -gt 0 ]] && return 0
2125 # set hostname if not running on host with name 'grml'
2126     if [[ -n "$HOSTNAME" ]] && [[ "$HOSTNAME" != $(hostname) ]] ; then
2127        NAME="@$HOSTNAME"
2128     fi
2129 # get the name of the program currently running and hostname of local machine
2130 # set screen window title if running in a screen
2131     if [[ "$TERM" == screen* ]] ; then
2132         # local CMD=${1[(wr)^(*=*|sudo|ssh|-*)]}       # don't use hostname
2133         local CMD="${1[(wr)^(*=*|sudo|ssh|-*)]}$NAME" # use hostname
2134         echo -ne "\ek$CMD\e\\"
2135     fi
2136 # adjust title of xterm
2137     [[ ${NOTITLE} -gt 0 ]] && return 0
2138     case $TERM in
2139         (xterm*|rxvt*)
2140             print -Pn "\e]0;%n@%m: $1\a"
2141             ;;
2142     esac
2143 }
2144
2145 EXITCODE="%(?..%?%1v )"
2146 PS2='\`%_> '      # secondary prompt, printed when the shell needs more information to complete a command.
2147 PS3='?# '         # selection prompt used within a select loop.
2148 PS4='+%N:%i:%_> ' # the execution trace prompt (setopt xtrace). default: '+%N:%i>'
2149
2150 # set variable debian_chroot if running in a chroot with /etc/debian_chroot
2151 if [[ -z "$debian_chroot" ]] && [[ -r /etc/debian_chroot ]] ; then
2152     debian_chroot=$(cat /etc/debian_chroot)
2153 fi
2154
2155 # don't use colors on dumb terminals (like emacs):
2156 if [[ "$TERM" == dumb ]] ; then
2157     PROMPT="${EXITCODE}${debian_chroot:+($debian_chroot)}%n@%m %40<...<%B%~%b%<< "'${VCS_INFO_message_0_}'"%# "
2158 else
2159     # only if $GRMLPROMPT is set (e.g. via 'GRMLPROMPT=1 zsh') use the extended prompt
2160     # set variable identifying the chroot you work in (used in the prompt below)
2161     if [[ $GRMLPROMPT -gt 0 ]] ; then
2162         PROMPT="${RED}${EXITCODE}${CYAN}[%j running job(s)] ${GREEN}{history#%!} ${RED}%(3L.+.) ${BLUE}%* %D
2163 ${BLUE}%n${NO_COLOUR}@%m %40<...<%B%~%b%<< %# "
2164     else
2165         # This assembles the primary prompt string
2166         if (( EUID != 0 )); then
2167             PROMPT="${RED}${EXITCODE}${WHITE}${debian_chroot:+($debian_chroot)}${BLUE}%n${NO_COLOUR}@%m %40<...<%B%~%b%<< "'${VCS_INFO_message_0_}'"%# "
2168         else
2169             PROMPT="${BLUE}${EXITCODE}${WHITE}${debian_chroot:+($debian_chroot)}${RED}%n${NO_COLOUR}@%m %40<...<%B%~%b%<< "'${VCS_INFO_message_0_}'"%# "
2170         fi
2171     fi
2172 fi
2173
2174 # if we are inside a grml-chroot set a specific prompt theme
2175 if [[ -n "$GRML_CHROOT" ]] ; then
2176     PROMPT="%{$fg[red]%}(CHROOT) %{$fg_bold[red]%}%n%{$fg_no_bold[white]%}@%m %40<...<%B%~%b%<< %\# "
2177 fi
2178 # }}}
2179
2180 # {{{ 'hash' some often used directories
2181 #d# start
2182 hash -d deb=/var/cache/apt/archives
2183 hash -d doc=/usr/share/doc
2184 hash -d linux=/lib/modules/$(command uname -r)/build/
2185 hash -d log=/var/log
2186 hash -d slog=/var/log/syslog
2187 hash -d src=/usr/src
2188 hash -d templ=/usr/share/doc/grml-templates
2189 hash -d tt=/usr/share/doc/texttools-doc
2190 hash -d www=/var/www
2191 #d# end
2192 # }}}
2193
2194 # {{{ some aliases
2195 if check_com -c screen ; then
2196     if [[ $UID -eq 0 ]] ; then
2197         [[ -r /etc/grml/screenrc ]] && alias screen="${commands[screen]} -c /etc/grml/screenrc"
2198     elif [[ -r $HOME/.screenrc ]] ; then
2199         alias screen="${commands[screen]} -c $HOME/.screenrc"
2200     else
2201         [[ -r /etc/grml/screenrc_grml ]] && alias screen="${commands[screen]} -c /etc/grml/screenrc_grml"
2202     fi
2203 fi
2204
2205 # do we have GNU ls with color-support?
2206 if ls --help 2>/dev/null | grep -- --color= >/dev/null && [[ "$TERM" != dumb ]] ; then
2207     #a1# execute \kbd{@a@}:\quad ls with colors
2208     alias ls='ls -b -CF --color=auto'
2209     #a1# execute \kbd{@a@}:\quad list all files, with colors
2210     alias la='ls -la --color=auto'
2211     #a1# long colored list, without dotfiles (@a@)
2212     alias ll='ls -l --color=auto'
2213     #a1# long colored list, human readable sizes (@a@)
2214     alias lh='ls -hAl --color=auto'
2215     #a1# List files, append qualifier to filenames \\&\quad(\kbd{/} for directories, \kbd{@} for symlinks ...)
2216     alias l='ls -lF --color=auto'
2217 else
2218     alias ls='ls -b -CF'
2219     alias la='ls -la'
2220     alias ll='ls -l'
2221     alias lh='ls -hAl'
2222     alias l='ls -lF'
2223 fi
2224
2225 alias mdstat='cat /proc/mdstat'
2226 alias ...='cd ../../'
2227
2228 # generate alias named "$KERNELVERSION-reboot" so you can use boot with kexec:
2229 if [[ -x /sbin/kexec ]] && [[ -r /proc/cmdline ]] ; then
2230     alias "$(uname -r)-reboot"="kexec -l --initrd=/boot/initrd.img-"$(uname -r)" --command-line=\"$(cat /proc/cmdline)\" /boot/vmlinuz-"$(uname -r)""
2231 fi
2232
2233 alias cp='nocorrect cp'         # no spelling correction on cp
2234 alias mkdir='nocorrect mkdir'   # no spelling correction on mkdir
2235 alias mv='nocorrect mv'         # no spelling correction on mv
2236 alias rm='nocorrect rm'         # no spelling correction on rm
2237
2238 #a1# Execute \kbd{rmdir}
2239 alias rd='rmdir'
2240 #a1# Execute \kbd{rmdir}
2241 alias md='mkdir'
2242
2243 # see http://www.cl.cam.ac.uk/~mgk25/unicode.html#term for details
2244 alias term2iso="echo 'Setting terminal to iso mode' ; print -n '\e%@'"
2245 alias term2utf="echo 'Setting terminal to utf-8 mode'; print -n '\e%G'"
2246
2247 # make sure it is not assigned yet
2248 [[ -n ${aliases[utf2iso]} ]] && unalias utf2iso
2249 utf2iso() {
2250     if isutfenv ; then
2251         for ENV in $(env | command grep -i '.utf') ; do
2252             eval export "$(echo $ENV | sed 's/UTF-8/iso885915/ ; s/utf8/iso885915/')"
2253         done
2254     fi
2255 }
2256
2257 # make sure it is not assigned yet
2258 [[ -n ${aliases[iso2utf]} ]] && unalias iso2utf
2259 iso2utf() {
2260     if ! isutfenv ; then
2261         for ENV in $(env | command grep -i '\.iso') ; do
2262             eval export "$(echo $ENV | sed 's/iso.*/UTF-8/ ; s/ISO.*/UTF-8/')"
2263         done
2264     fi
2265 }
2266
2267 # set up software synthesizer via speakup
2268 swspeak() {
2269     if [ -x /usr/sbin/swspeak-setup ] ; then
2270        setopt singlelinezle
2271        unsetopt prompt_cr
2272        export PS1="%m%# "
2273        /usr/sbin/swspeak-setup $@
2274      else # old version:
2275         aumix -w 90 -v 90 -p 90 -m 90
2276         if ! [[ -r /dev/softsynth ]] ; then
2277             flite -o play -t "Sorry, software synthesizer not available. Did you boot with swspeak bootoption?"
2278             return 1
2279         else
2280            setopt singlelinezle
2281            unsetopt prompt_cr
2282            export PS1="%m%# "
2283             nice -n -20 speechd-up
2284             sleep 2
2285             flite -o play -t "Finished setting up software synthesizer"
2286         fi
2287      fi
2288 }
2289
2290 # I like clean prompt, so provide simple way to get that
2291 check_com 0 || alias 0='return 0'
2292
2293 # for really lazy people like mika:
2294 check_com S &>/dev/null || alias S='screen'
2295 check_com s &>/dev/null || alias s='ssh'
2296
2297 # get top 10 shell commands:
2298 alias top10='print -l ? ${(o)history%% *} | uniq -c | sort -nr | head -n 10'
2299
2300 # truecrypt; use e.g. via 'truec /dev/ice /mnt/ice' or 'truec -i'
2301 if check_com -c truecrypt ; then
2302     if isutfenv ; then
2303         alias truec='truecrypt --mount-options "rw,sync,dirsync,users,uid=1000,gid=users,umask=077,utf8" '
2304     else
2305         alias truec='truecrypt --mount-options "rw,sync,dirsync,users,uid=1000,gid=users,umask=077" '
2306     fi
2307 fi
2308
2309 #f1# Hints for the use of zsh on grml
2310 zsh-help() {
2311     print "$bg[white]$fg[black]
2312 zsh-help - hints for use of zsh on grml
2313 =======================================$reset_color"
2314
2315     print '
2316 Main configuration of zsh happens in /etc/zsh/zshrc.
2317 That file is part of the package grml-etc-core, if you want to
2318 use them on a non-grml-system just get the tar.gz from
2319 http://deb.grml.org/ or (preferably) get it from the git repository:
2320
2321   http://git.grml.org/f/grml-etc-core/etc/zsh/zshrc
2322
2323 This version of grml'\''s zsh setup does not use skel/.zshrc anymore.
2324 The file is still there, but it is empty for backwards compatibility.
2325
2326 For your own changes use these two files:
2327     $HOME/.zshrc.pre
2328     $HOME/.zshrc.local
2329
2330 The former is sourced very early in our zshrc, the latter is sourced
2331 very lately.
2332
2333 System wide configuration without touching configuration files of grml
2334 can take place in /etc/zsh/zshrc.local.
2335
2336 Normally, the root user (EUID == 0) does not get the whole grml setup.
2337 If you want to force the whole setup for that user, too, set
2338 GRML_ALWAYS_LOAD_ALL=1 in .zshrc.pre in root'\''s home directory.
2339
2340 For information regarding zsh start at http://grml.org/zsh/
2341
2342 Take a look at grml'\''s zsh refcard:
2343 % xpdf =(zcat /usr/share/doc/grml-docs/zsh/grml-zsh-refcard.pdf.gz)
2344
2345 Check out the main zsh refcard:
2346 % '$BROWSER' http://www.bash2zsh.com/zsh_refcard/refcard.pdf
2347
2348 And of course visit the zsh-lovers:
2349 % man zsh-lovers
2350
2351 You can adjust some options through environment variables when
2352 invoking zsh without having to edit configuration files.
2353 Basically meant for bash users who are not used to the power of
2354 the zsh yet. :)
2355
2356   "NOCOR=1    zsh" => deactivate automatic correction
2357   "NOMENU=1   zsh" => do not use auto menu completion (note: use ctrl-d for completion instead!)
2358   "NOPRECMD=1 zsh" => disable the precmd + preexec commands (set GNU screen title)
2359   "NOTITLE=1  zsh" => disable setting the title of xterms without disabling
2360                       preexec() and precmd() completely
2361   "BATTERY=1  zsh" => activate battery status (via acpi) on right side of prompt
2362   "COMMAND_NOT_FOUND=1 zsh"
2363                    => Enable a handler if an external command was not found
2364                       The command called in the handler can be altered by setting
2365                       the GRML_ZSH_CNF_HANDLER variable, the default is:
2366                       "/usr/share/command-not-found/command-not-found"
2367
2368 A value greater than 0 is enables a feature; a value equal to zero
2369 disables it. If you like one or the other of these settings, you can
2370 add them to ~/.zshrc.pre to ensure they are set when sourcing grml'\''s
2371 zshrc.'
2372
2373     print "
2374 $bg[white]$fg[black]
2375 Please report wishes + bugs to the grml-team: http://grml.org/bugs/
2376 Enjoy your grml system with the zsh!$reset_color"
2377 }
2378
2379 # debian stuff
2380 if [[ -r /etc/debian_version ]] ; then
2381     #a3# Execute \kbd{apt-cache search}
2382     alias acs='apt-cache search'
2383     #a3# Execute \kbd{apt-cache show}
2384     alias acsh='apt-cache show'
2385     #a3# Execute \kbd{apt-cache policy}
2386     alias acp='apt-cache policy'
2387     #a3# Execute \kbd{apt-get dist-upgrade}
2388     salias adg="apt-get dist-upgrade"
2389     #a3# Execute \kbd{apt-get install}
2390     salias agi="apt-get install"
2391     #a3# Execute \kbd{aptitude install}
2392     salias ati="aptitude install"
2393     #a3# Execute \kbd{apt-get upgrade}
2394     salias ag="apt-get upgrade"
2395     #a3# Execute \kbd{apt-get update}
2396     salias au="apt-get update"
2397     #a3# Execute \kbd{aptitude update ; aptitude safe-upgrade}
2398     salias -a up="aptitude update ; aptitude safe-upgrade"
2399     #a3# Execute \kbd{dpkg-buildpackage}
2400     alias dbp='dpkg-buildpackage'
2401     #a3# Execute \kbd{grep-excuses}
2402     alias ge='grep-excuses'
2403
2404     # debian upgrade
2405     #f3# Execute \kbd{apt-get update \&\& }\\&\quad \kbd{apt-get dist-upgrade}
2406     upgrade() {
2407         emulate -L zsh
2408         if [[ -z $1 ]] ; then
2409             $SUDO apt-get update
2410             $SUDO apt-get -u upgrade
2411         else
2412             ssh $1 $SUDO apt-get update
2413             # ask before the upgrade
2414             local dummy
2415             ssh $1 $SUDO apt-get --no-act upgrade
2416             echo -n 'Process the upgrade?'
2417             read -q dummy
2418             if [[ $dummy == "y" ]] ; then
2419                 ssh $1 $SUDO apt-get -u upgrade --yes
2420             fi
2421         fi
2422     }
2423
2424     # get a root shell as normal user in live-cd mode:
2425     if isgrmlcd && [[ $UID -ne 0 ]] ; then
2426        alias su="sudo su"
2427      fi
2428
2429     #a1# Take a look at the syslog: \kbd{\$PAGER /var/log/syslog}
2430     salias llog="$PAGER /var/log/syslog"     # take a look at the syslog
2431     #a1# Take a look at the syslog: \kbd{tail -f /var/log/syslog}
2432     salias tlog="tail -f /var/log/syslog"    # follow the syslog
2433 fi
2434
2435 # sort installed Debian-packages by size
2436 if check_com -c grep-status ; then
2437     #a3# List installed Debian-packages sorted by size
2438     alias debs-by-size='grep-status -FStatus -sInstalled-Size,Package -n "install ok installed" | paste -sd "  \n" | sort -rn'
2439 fi
2440
2441 # if cdrecord is a symlink (to wodim) or isn't present at all warn:
2442 if [[ -L /usr/bin/cdrecord ]] || ! check_com -c cdrecord ; then
2443     if check_com -c wodim ; then
2444         alias cdrecord="echo 'cdrecord is not provided under its original name by Debian anymore.
2445 See #377109 in the BTS of Debian for more details.
2446
2447 Please use the wodim binary instead' ; return 1"
2448     fi
2449 fi
2450
2451 # get_tw_cli has been renamed into get_3ware
2452 if check_com -c get_3ware ; then
2453     get_tw_cli() {
2454         echo 'Warning: get_tw_cli has been renamed into get_3ware. Invoking get_3ware for you.'>&2
2455         get_3ware
2456     }
2457 fi
2458
2459 # I hate lacking backward compatibility, so provide an alternative therefore
2460 if ! check_com -c apache2-ssl-certificate ; then
2461
2462     apache2-ssl-certificate() {
2463
2464     print 'Debian does not ship apache2-ssl-certificate anymore (see #398520). :('
2465     print 'You might want to take a look at Debian the package ssl-cert as well.'
2466     print 'To generate a certificate for use with apache2 follow the instructions:'
2467
2468     echo '
2469
2470 export RANDFILE=/dev/random
2471 mkdir /etc/apache2/ssl/
2472 openssl req $@ -new -x509 -days 365 -nodes -out /etc/apache2/ssl/apache.pem -keyout /etc/apache2/ssl/apache.pem
2473 chmod 600 /etc/apache2/ssl/apache.pem
2474
2475 Run "grml-tips ssl-certificate" if you need further instructions.
2476 '
2477     }
2478 fi
2479 # }}}
2480
2481 # {{{ Use hard limits, except for a smaller stack and no core dumps
2482 unlimit
2483 is425 && limit stack 8192
2484 isgrmlcd && limit core 0 # important for a live-cd-system
2485 limit -s
2486 # }}}
2487
2488 # {{{ completion system
2489
2490 # called later (via is4 && grmlcomp)
2491 # note: use 'zstyle' for getting current settings
2492 #         press ^Xh (control-x h) for getting tags in context; ^X? (control-x ?) to run complete_debug with trace output
2493 grmlcomp() {
2494     # TODO: This could use some additional information
2495
2496     # allow one error for every three characters typed in approximate completer
2497     zstyle ':completion:*:approximate:'    max-errors 'reply=( $((($#PREFIX+$#SUFFIX)/3 )) numeric )'
2498
2499     # don't complete backup files as executables
2500     zstyle ':completion:*:complete:-command-::commands' ignored-patterns '(aptitude-*|*\~)'
2501
2502     # start menu completion only if it could find no unambiguous initial string
2503     zstyle ':completion:*:correct:*'       insert-unambiguous true
2504     zstyle ':completion:*:corrections'     format $'%{\e[0;31m%}%d (errors: %e)%{\e[0m%}'
2505     zstyle ':completion:*:correct:*'       original true
2506
2507     # activate color-completion
2508     zstyle ':completion:*:default'         list-colors ${(s.:.)LS_COLORS}
2509
2510     # format on completion
2511     zstyle ':completion:*:descriptions'    format $'%{\e[0;31m%}completing %B%d%b%{\e[0m%}'
2512
2513     # complete 'cd -<tab>' with menu
2514     zstyle ':completion:*:*:cd:*:directory-stack' menu yes select
2515
2516     # insert all expansions for expand completer
2517     zstyle ':completion:*:expand:*'        tag-order all-expansions
2518     zstyle ':completion:*:history-words'   list false
2519
2520     # activate menu
2521     zstyle ':completion:*:history-words'   menu yes
2522
2523     # ignore duplicate entries
2524     zstyle ':completion:*:history-words'   remove-all-dups yes
2525     zstyle ':completion:*:history-words'   stop yes
2526
2527     # match uppercase from lowercase
2528     zstyle ':completion:*'                 matcher-list 'm:{a-z}={A-Z}'
2529
2530     # separate matches into groups
2531     zstyle ':completion:*:matches'         group 'yes'
2532     zstyle ':completion:*'                 group-name ''
2533
2534     if [[ "$NOMENU" -eq 0 ]] ; then
2535         # if there are more than 5 options allow selecting from a menu
2536         zstyle ':completion:*'               menu select=5
2537     else
2538         # don't use any menus at all
2539         setopt no_auto_menu
2540     fi
2541
2542     zstyle ':completion:*:messages'        format '%d'
2543     zstyle ':completion:*:options'         auto-description '%d'
2544
2545     # describe options in full
2546     zstyle ':completion:*:options'         description 'yes'
2547
2548     # on processes completion complete all user processes
2549     zstyle ':completion:*:processes'       command 'ps -au$USER'
2550
2551     # offer indexes before parameters in subscripts
2552     zstyle ':completion:*:*:-subscript-:*' tag-order indexes parameters
2553
2554     # provide verbose completion information
2555     zstyle ':completion:*'                 verbose true
2556
2557     # recent (as of Dec 2007) zsh versions are able to provide descriptions
2558     # for commands (read: 1st word in the line) that it will list for the user
2559     # to choose from. The following disables that, because it's not exactly fast.
2560     zstyle ':completion:*:-command-:*:'    verbose false
2561
2562     # set format for warnings
2563     zstyle ':completion:*:warnings'        format $'%{\e[0;31m%}No matches for:%{\e[0m%} %d'
2564
2565     # define files to ignore for zcompile
2566     zstyle ':completion:*:*:zcompile:*'    ignored-patterns '(*~|*.zwc)'
2567     zstyle ':completion:correct:'          prompt 'correct to: %e'
2568
2569     # Ignore completion functions for commands you don't have:
2570     zstyle ':completion::(^approximate*):*:functions' ignored-patterns '_*'
2571
2572     # Provide more processes in completion of programs like killall:
2573     zstyle ':completion:*:processes-names' command 'ps c -u ${USER} -o command | uniq'
2574
2575     # complete manual by their section
2576     zstyle ':completion:*:manuals'    separate-sections true
2577     zstyle ':completion:*:manuals.*'  insert-sections   true
2578     zstyle ':completion:*:man:*'      menu yes select
2579
2580     # provide .. as a completion
2581     zstyle ':completion:*' special-dirs ..
2582
2583     # run rehash on completion so new installed program are found automatically:
2584     _force_rehash() {
2585         (( CURRENT == 1 )) && rehash
2586         return 1
2587     }
2588
2589     ## correction
2590     # some people don't like the automatic correction - so run 'NOCOR=1 zsh' to deactivate it
2591     if [[ "$NOCOR" -gt 0 ]] ; then
2592         zstyle ':completion:*' completer _oldlist _expand _force_rehash _complete _files _ignored
2593         setopt nocorrect
2594     else
2595         # try to be smart about when to use what completer...
2596         setopt correct
2597         zstyle -e ':completion:*' completer '
2598             if [[ $_last_try != "$HISTNO$BUFFER$CURSOR" ]] ; then
2599                 _last_try="$HISTNO$BUFFER$CURSOR"
2600                 reply=(_complete _match _ignored _prefix _files)
2601             else
2602                 if [[ $words[1] == (rm|mv) ]] ; then
2603                     reply=(_complete _files)
2604                 else
2605                     reply=(_oldlist _expand _force_rehash _complete _ignored _correct _approximate _files)
2606                 fi
2607             fi'
2608     fi
2609
2610     # command for process lists, the local web server details and host completion
2611     zstyle ':completion:*:urls' local 'www' '/var/www/' 'public_html'
2612
2613     # caching
2614     [[ -d $ZSHDIR/cache ]] && zstyle ':completion:*' use-cache yes && \
2615                             zstyle ':completion::complete:*' cache-path $ZSHDIR/cache/
2616
2617     # host completion /* add brackets as vim can't parse zsh's complex cmdlines 8-) {{{ */
2618     if is42 ; then
2619         [[ -r ~/.ssh/known_hosts ]] && _ssh_hosts=(${${${${(f)"$(<$HOME/.ssh/known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _ssh_hosts=()
2620         [[ -r /etc/hosts ]] && : ${(A)_etc_hosts:=${(s: :)${(ps:\t:)${${(f)~~"$(</etc/hosts)"}%%\#*}##[:blank:]#[^[:blank:]]#}}} || _etc_hosts=()
2621     else
2622         _ssh_hosts=()
2623         _etc_hosts=()
2624     fi
2625     hosts=(
2626         $(hostname)
2627         "$_ssh_hosts[@]"
2628         "$_etc_hosts[@]"
2629         grml.org
2630         localhost
2631     )
2632     zstyle ':completion:*:hosts' hosts $hosts
2633     # TODO: so, why is this here?
2634     #  zstyle '*' hosts $hosts
2635
2636     # use generic completion system for programs not yet defined; (_gnu_generic works
2637     # with commands that provide a --help option with "standard" gnu-like output.)
2638     for compcom in cp deborphan df feh fetchipac head hnb ipacsum mv \
2639                    pal stow tail uname ; do
2640         [[ -z ${_comps[$compcom]} ]] && compdef _gnu_generic ${compcom}
2641     done; unset compcom
2642
2643     # see upgrade function in this file
2644     compdef _hosts upgrade
2645 }
2646 # }}}
2647
2648 # {{{ grmlstuff
2649 grmlstuff() {
2650 # people should use 'grml-x'!
2651     startx() {
2652         if [[ -e /etc/X11/xorg.conf ]] ; then
2653             [[ -x /usr/bin/startx ]] && /usr/bin/startx "$@" || /usr/X11R6/bin/startx "$@"
2654         else
2655             echo "Please use the script \"grml-x\" for starting the X Window System
2656 because there does not exist /etc/X11/xorg.conf yet.
2657 If you want to use startx anyway please call \"/usr/bin/startx\"."
2658             return -1
2659         fi
2660     }
2661
2662     xinit() {
2663         if [[ -e /etc/X11/xorg.conf ]] ; then
2664             [[ -x /usr/bin/xinit ]] && /usr/bin/xinit || /usr/X11R6/bin/xinit
2665         else
2666             echo "Please use the script \"grml-x\" for starting the X Window System.
2667 because there does not exist /etc/X11/xorg.conf yet.
2668 If you want to use xinit anyway please call \"/usr/bin/xinit\"."
2669             return -1
2670         fi
2671     }
2672
2673     if check_com -c 915resolution ; then
2674         alias 855resolution='echo -e "Please use 915resolution as resolution modify tool for Intel graphic chipset."; return -1'
2675     fi
2676
2677     #a1# Output version of running grml
2678     alias grml-version='cat /etc/grml_version'
2679
2680     if check_com -c rebuildfstab ; then
2681         #a1# Rebuild /etc/fstab
2682         alias grml-rebuildfstab='rebuildfstab -v -r -config'
2683     fi
2684
2685     if check_com -c grml-debootstrap ; then
2686         alias debian2hd='print "Installing debian to harddisk is possible via using grml-debootstrap." ; return 1'
2687     fi
2688 }
2689 # }}}
2690
2691 # {{{ now run the functions
2692 isgrml && checkhome
2693 is4    && isgrml    && grmlstuff
2694 is4    && grmlcomp
2695 # }}}
2696
2697 # {{{ keephack
2698 is4 && xsource "/etc/zsh/keephack"
2699 # }}}
2700
2701 # {{{ wonderful idea of using "e" glob qualifier by Peter Stephenson
2702 # You use it as follows:
2703 # $ NTREF=/reference/file
2704 # $ ls -l *(e:nt:)
2705 # This lists all the files in the current directory newer than the reference file.
2706 # You can also specify the reference file inline; note quotes:
2707 # $ ls -l *(e:'nt ~/.zshenv':)
2708 is4 && nt() {
2709     if [[ -n $1 ]] ; then
2710         local NTREF=${~1}
2711     fi
2712     [[ $REPLY -nt $NTREF ]]
2713 }
2714 # }}}
2715
2716 # shell functions {{{
2717
2718 #f1# Provide csh compatibility
2719 setenv()  { typeset -x "${1}${1:+=}${(@)argv[2,$#]}" }  # csh compatibility
2720
2721 #f1# Reload an autoloadable function
2722 freload() { while (( $# )); do; unfunction $1; autoload -U $1; shift; done }
2723
2724 # TODO: Who really uses reload()? The proper way to reload a zsh setup is to
2725 # actually restart the shell via 'exec zsh'. And reload with arguments is the
2726 # same as freload() above. -ft
2727 #f1# Reload zsh setup
2728 reload() {
2729     if [[ "$#*" -eq 0 ]] ; then
2730         [[ -r ~/.zshrc ]] && . ~/.zshrc
2731     else
2732         local fn
2733         for fn in "$@"; do
2734             unfunction $fn
2735             autoload -U $fn
2736         done
2737     fi
2738 }
2739 compdef _functions reload freload
2740
2741 #f1# List symlinks in detail (more detailed version of 'readlink -f' and 'whence -s')
2742 sll() {
2743     [[ -z "$1" ]] && printf 'Usage: %s <file(s)>\n' "$0" && return 1
2744     for file in "$@" ; do
2745         while [[ -h "$file" ]] ; do
2746             ls -l $file
2747             file=$(readlink "$file")
2748         done
2749     done
2750 }
2751
2752 # fast manual access
2753 if check_com qma ; then
2754     #f1# View the zsh manual
2755     manzsh()  { qma zshall "$1" }
2756     compdef _man qma
2757 else
2758     manzsh()  { /usr/bin/man zshall |  vim -c "se ft=man| se hlsearch" +/"$1" - ; }
2759 fi
2760
2761 # TODO: Is it supported to use pager settings like this?
2762 #   PAGER='less -Mr' - If so, the use of $PAGER here needs fixing
2763 # with respect to wordsplitting. (ie. ${=PAGER})
2764 if check_com -c $PAGER ; then
2765     #f1# View Debian's changelog of a given package
2766     dchange() {
2767         emulate -L zsh
2768         if [[ -r /usr/share/doc/$1/changelog.Debian.gz ]] ; then
2769             $PAGER /usr/share/doc/$1/changelog.Debian.gz
2770         elif [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2771             $PAGER /usr/share/doc/$1/changelog.gz
2772         else
2773             if check_com -c aptitude ; then
2774                 echo "No changelog for package $1 found, using aptitude to retrieve it."
2775                 if isgrml ; then
2776                     aptitude -t unstable changelog $1
2777                 else
2778                     aptitude changelog $1
2779                 fi
2780             else
2781                 echo "No changelog for package $1 found, sorry."
2782                 return 1
2783             fi
2784         fi
2785     }
2786     _dchange() { _files -W /usr/share/doc -/ }
2787     compdef _dchange dchange
2788
2789     #f1# View Debian's NEWS of a given package
2790     dnews() {
2791         emulate -L zsh
2792         if [[ -r /usr/share/doc/$1/NEWS.Debian.gz ]] ; then
2793             $PAGER /usr/share/doc/$1/NEWS.Debian.gz
2794         else
2795             if [[ -r /usr/share/doc/$1/NEWS.gz ]] ; then
2796                 $PAGER /usr/share/doc/$1/NEWS.gz
2797             else
2798                 echo "No NEWS file for package $1 found, sorry."
2799                 return 1
2800             fi
2801         fi
2802     }
2803     _dnews() { _files -W /usr/share/doc -/ }
2804     compdef _dnews dnews
2805
2806     #f1# View upstream's changelog of a given package
2807     uchange() {
2808         emulate -L zsh
2809         if [[ -r /usr/share/doc/$1/changelog.gz ]] ; then
2810             $PAGER /usr/share/doc/$1/changelog.gz
2811         else
2812             echo "No changelog for package $1 found, sorry."
2813             return 1
2814         fi
2815     }
2816     _uchange() { _files -W /usr/share/doc -/ }
2817     compdef _uchange uchange
2818 fi
2819
2820 # zsh profiling
2821 profile() {
2822     ZSH_PROFILE_RC=1 $SHELL "$@"
2823 }
2824
2825 #f1# Edit an alias via zle
2826 edalias() {
2827     [[ -z "$1" ]] && { echo "Usage: edalias <alias_to_edit>" ; return 1 } || vared aliases'[$1]' ;
2828 }
2829 compdef _aliases edalias
2830
2831 #f1# Edit a function via zle
2832 edfunc() {
2833     [[ -z "$1" ]] && { echo "Usage: edfun <function_to_edit>" ; return 1 } || zed -f "$1" ;
2834 }
2835 compdef _functions edfunc
2836
2837 # use it e.g. via 'Restart apache2'
2838 #m# f6 Start() \kbd{/etc/init.d/\em{process}}\quad\kbd{start}
2839 #m# f6 Restart() \kbd{/etc/init.d/\em{process}}\quad\kbd{restart}
2840 #m# f6 Stop() \kbd{/etc/init.d/\em{process}}\quad\kbd{stop}
2841 #m# f6 Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{reload}
2842 #m# f6 Force-Reload() \kbd{/etc/init.d/\em{process}}\quad\kbd{force-reload}
2843 if [[ -d /etc/init.d || -d /etc/service ]] ; then
2844     __start_stop() {
2845         local action_="${1:l}"  # e.g Start/Stop/Restart
2846         local service_="$2"
2847         local param_="$3"
2848
2849         local service_target_="$(readlink /etc/init.d/$service_)"
2850         if [[ $service_target_ == "/usr/bin/sv" ]]; then
2851             # runit
2852             case "${action_}" in
2853                 start) if [[ ! -e /etc/service/$service_ ]]; then
2854                            $SUDO ln -s "/etc/sv/$service_" "/etc/service/"
2855                        else
2856                            $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2857                        fi ;;
2858                 # there is no reload in runits sysv emulation
2859                 reload) $SUDO "/etc/init.d/$service_" "force-reload" "$param_" ;;
2860                 *) $SUDO "/etc/init.d/$service_" "${action_}" "$param_" ;;
2861             esac
2862         else
2863             # sysvinit
2864             $SUDO "/etc/init.d/$service_" "${action_}" "$param_"
2865         fi
2866     }
2867
2868     for i in Start Restart Stop Force-Reload Reload ; do
2869         eval "$i() { __start_stop $i \"\$1\" \"\$2\" ; }"
2870     done
2871 fi
2872
2873 #f1# Provides useful information on globbing
2874 H-Glob() {
2875     echo -e "
2876     /      directories
2877     .      plain files
2878     @      symbolic links
2879     =      sockets
2880     p      named pipes (FIFOs)
2881     *      executable plain files (0100)
2882     %      device files (character or block special)
2883     %b     block special files
2884     %c     character special files
2885     r      owner-readable files (0400)
2886     w      owner-writable files (0200)
2887     x      owner-executable files (0100)
2888     A      group-readable files (0040)
2889     I      group-writable files (0020)
2890     E      group-executable files (0010)
2891     R      world-readable files (0004)
2892     W      world-writable files (0002)
2893     X      world-executable files (0001)
2894     s      setuid files (04000)
2895     S      setgid files (02000)
2896     t      files with the sticky bit (01000)
2897
2898   print *(m-1)          # Files modified up to a day ago
2899   print *(a1)           # Files accessed a day ago
2900   print *(@)            # Just symlinks
2901   print *(Lk+50)        # Files bigger than 50 kilobytes
2902   print *(Lk-50)        # Files smaller than 50 kilobytes
2903   print **/*.c          # All *.c files recursively starting in \$PWD
2904   print **/*.c~file.c   # Same as above, but excluding 'file.c'
2905   print (foo|bar).*     # Files starting with 'foo' or 'bar'
2906   print *~*.*           # All Files that do not contain a dot
2907   chmod 644 *(.^x)      # make all plain non-executable files publically readable
2908   print -l *(.c|.h)     # Lists *.c and *.h
2909   print **/*(g:users:)  # Recursively match all files that are owned by group 'users'
2910   echo /proc/*/cwd(:h:t:s/self//) # Analogous to >ps ax | awk '{print $1}'<"
2911 }
2912 alias help-zshglob=H-Glob
2913
2914 check_com -c qma && alias ?='qma zshall'
2915
2916 # grep for running process, like: 'any vim'
2917 any() {
2918     emulate -L zsh
2919     if [[ -z "$1" ]] ; then
2920         echo "any - grep for process(es) by keyword" >&2
2921         echo "Usage: any <keyword>" >&2 ; return 1
2922     else
2923         local STRING=$1
2924         local LENGTH=$(expr length $STRING)
2925         local FIRSCHAR=$(echo $(expr substr $STRING 1 1))
2926         local REST=$(echo $(expr substr $STRING 2 $LENGTH))
2927         ps xauwww| grep "[$FIRSCHAR]$REST"
2928     fi
2929 }
2930
2931 # After resuming from suspend, system is paging heavily, leading to very bad interactivity.
2932 # taken from $LINUX-KERNELSOURCE/Documentation/power/swsusp.txt
2933 [[ -r /proc/1/maps ]] && \
2934 deswap() {
2935     print 'Reading /proc/[0-9]*/maps and sending output to /dev/null, this might take a while.'
2936     cat $(sed -ne 's:.* /:/:p' /proc/[0-9]*/maps | sort -u | grep -v '^/dev/')  > /dev/null
2937     print 'Finished, running "swapoff -a; swapon -a" may also be useful.'
2938 }
2939
2940 # print hex value of a number
2941 hex() {
2942     emulate -L zsh
2943     [[ -n "$1" ]] && printf "%x\n" $1 || { print 'Usage: hex <number-to-convert>' ; return 1 }
2944 }
2945
2946 # calculate (or eval at all ;-)) with perl => p[erl-]eval
2947 # hint: also take a look at zcalc -> 'autoload zcalc' -> 'man zshmodules | less -p MATHFUNC'
2948 peval() {
2949     [[ -n "$1" ]] && CALC="$*" || print "Usage: calc [expression]"
2950     perl -e "print eval($CALC),\"\n\";"
2951 }
2952 functions peval &>/dev/null && alias calc=peval
2953
2954 # brltty seems to have problems with utf8 environment and/or font Uni3-Terminus16 under
2955 # certain circumstances, so work around it, no matter which environment we have
2956 brltty() {
2957     if [[ -z "$DISPLAY" ]] ; then
2958         consolechars -f /usr/share/consolefonts/default8x16.psf.gz
2959         command brltty "$@"
2960     else
2961         command brltty "$@"
2962     fi
2963 }
2964
2965 # just press 'asdf' keys to toggle between dvorak and us keyboard layout
2966 aoeu() {
2967     echo -n 'Switching to us keyboard layout: '
2968     [[ -z "$DISPLAY" ]] && $SUDO loadkeys us &>/dev/null || setxkbmap us &>/dev/null
2969     echo 'Done'
2970 }
2971 asdf() {
2972     echo -n 'Switching to dvorak keyboard layout: '
2973     [[ -z "$DISPLAY" ]] && $SUDO loadkeys dvorak &>/dev/null || setxkbmap dvorak &>/dev/null
2974     echo 'Done'
2975 }
2976 # just press 'asdf' key to toggle from neon layout to us keyboard layout
2977 uiae() {
2978     echo -n 'Switching to us keyboard layout: '
2979     setxkbmap us && echo 'Done' || echo 'Failed'
2980 }
2981
2982 # set up an ipv6 tunnel
2983 ipv6-tunnel() {
2984     emulate -L zsh
2985     case $1 in
2986         start)
2987             if ifconfig sit1 2>/dev/null | grep -q 'inet6 addr: 2002:.*:1::1' ; then
2988                 print 'ipv6 tunnel already set up, nothing to be done.'
2989                 print 'execute: "ifconfig sit1 down ; ifconfig sit0 down" to remove ipv6-tunnel.' ; return 1
2990             else
2991                 [[ -n "$PUBLIC_IP" ]] || \
2992                     local PUBLIC_IP=$(ifconfig $(route -n | awk '/^0\.0\.0\.0/{print $8; exit}') | \
2993                                       awk '/inet addr:/ {print $2}' | tr -d 'addr:')
2994
2995                 [[ -n "$PUBLIC_IP" ]] || { print 'No $PUBLIC_IP set and could not determine default one.' ; return 1 }
2996                 local IPV6ADDR=$(printf "2002:%02x%02x:%02x%02x:1::1" $(print ${PUBLIC_IP//./ }))
2997                 print -n "Setting up ipv6 tunnel $IPV6ADDR via ${PUBLIC_IP}: "
2998                 ifconfig sit0 tunnel ::192.88.99.1 up
2999                 ifconfig sit1 add "$IPV6ADDR" && print done || print failed
3000             fi
3001             ;;
3002         status)
3003             if ifconfig sit1 2>/dev/null | grep -q 'inet6 addr: 2002:.*:1::1' ; then
3004                 print 'ipv6 tunnel available' ; return 0
3005             else
3006                 print 'ipv6 tunnel not available' ; return 1
3007             fi
3008             ;;
3009         stop)
3010             if ifconfig sit1 2>/dev/null | grep -q 'inet6 addr: 2002:.*:1::1' ; then
3011                 print -n 'Stopping ipv6 tunnel (sit0 + sit1): '
3012                 ifconfig sit1 down ; ifconfig sit0 down && print done || print failed
3013             else
3014                 print 'No ipv6 tunnel found, nothing to be done.' ; return 1
3015             fi
3016             ;;
3017         *)
3018             print "Usage: ipv6-tunnel [start|stop|status]">&2 ; return 1
3019             ;;
3020     esac
3021 }
3022
3023 # run dhclient for wireless device
3024 iwclient() {
3025     salias dhclient "$(wavemon -d | awk '/device/{print $2}')"
3026 }
3027
3028 # spawn a minimally set up ksh - useful if you want to umount /usr/.
3029 minimal-shell() {
3030     exec env -i ENV="/etc/minimal-shellrc" HOME="$HOME" TERM="$TERM" ksh
3031 }
3032
3033 # a wrapper for vim, that deals with title setting
3034 #   VIM_OPTIONS
3035 #       set this array to a set of options to vim you always want
3036 #       to have set when calling vim (in .zshrc.local), like:
3037 #           VIM_OPTIONS=( -p )
3038 #       This will cause vim to send every file given on the
3039 #       commandline to be send to it's own tab (needs vim7).
3040 vim() {
3041     VIM_PLEASE_SET_TITLE='yes' command vim ${VIM_OPTIONS} "$@"
3042 }
3043
3044 # make a backup of a file
3045 bk() {
3046     cp -a "$1" "${1}_$(date --iso-8601=seconds)"
3047 }
3048
3049 #f1# grep for patterns in grml's zsh setup
3050 zg() {
3051 #{{{
3052     LANG=C perl -e '
3053
3054 sub usage {
3055     print "usage: zg -[anr] <pattern>\n";
3056     print " Search for patterns in grml'\''s zshrc.\n";
3057     print " zg takes no or exactly one option plus a non empty pattern.\n\n";
3058     print "   options:\n";
3059     print "     --  no options (use if your pattern starts in with a dash.\n";
3060     print "     -a  search for the pattern in all code regions\n";
3061     print "     -n  search for the pattern in non-root code only\n";
3062     print "     -r  search in code for everyone (also root) only\n\n";
3063     print "   The default is -a for non-root users and -r for root.\n\n";
3064     print " If you installed the zshrc to a non-default locations (ie *NOT*\n";
3065     print " in /etc/zsh/zshrc) do: export GRML_ZSHRC=\$HOME/.zshrc\n";
3066     print " ...in case you copied the file to that location.\n\n";
3067     exit 1;
3068 }
3069
3070 if ($ENV{GRML_ZSHRC} ne "") {
3071     $RC = $ENV{GRML_ZSHRC};
3072 } else {
3073     $RC = "/etc/zsh/zshrc";
3074 }
3075
3076 usage if ($#ARGV < 0 || $#ARGV > 1);
3077 if ($> == 0) { $mode = "allonly"; }
3078 else { $mode = "all"; }
3079
3080 $opt = $ARGV[0];
3081 if ($opt eq "--")     { shift; }
3082 elsif ($opt eq "-a")  { $mode = "all"; shift; }
3083 elsif ($opt eq "-n")  { $mode = "nonroot"; shift; }
3084 elsif ($opt eq "-r" ) { $mode = "allonly"; shift; }
3085 elsif ($opt =~ m/^-/ || $#ARGV > 0) { usage(); }
3086
3087 $pattern = $ARGV[0];
3088 usage() if ($pattern eq "");
3089
3090 open FH, "<$RC" or die "zg: Could not open $RC: $!\n";
3091 while ($line = <FH>) {
3092     chomp $line;
3093     if ($line =~ m/^#:grep:marker:for:mika:/) { $markerfound = 1; next; }
3094     next if ($mode eq "nonroot" && markerfound == 0);
3095     break if ($mode eq "allonly" && markerfound == 1);
3096     print $line, "\n" if ($line =~ /$pattern/);
3097 }
3098 close FH;
3099 exit 0;
3100
3101     ' -- "$@"
3102 #}}}
3103     return $?
3104 }
3105
3106 # }}}
3107
3108 # {{{ make sure our environment is clean regarding colors
3109 for color in BLUE RED GREEN CYAN YELLOW MAGENTA WHITE ; unset $color
3110 # }}}
3111
3112 # "persistent history" {{{
3113 # just write important commands you always need to ~/.important_commands
3114 if [[ -r ~/.important_commands ]] ; then
3115     fc -R ~/.important_commands
3116 fi
3117 # }}}
3118
3119 #:grep:marker:for:mika: :-)
3120 ### non-root (EUID != 0) code below
3121 ###
3122
3123 if (( GRML_ALWAYS_LOAD_ALL == 0 )) && (( $EUID == 0 )) ; then
3124     zrclocal
3125     return 0
3126 fi
3127
3128
3129 # variables {{{
3130
3131 # set terminal property (used e.g. by msgid-chooser)
3132 export COLORTERM="yes"
3133
3134 # set default browser
3135 if [[ -z "$BROWSER" ]] ; then
3136     if [[ -n "$DISPLAY" ]] ; then
3137         #v# If X11 is running
3138         check_com -c firefox && export BROWSER=firefox
3139     else
3140         #v# If no X11 is running
3141         check_com -c w3m && export BROWSER=w3m
3142     fi
3143 fi
3144
3145 #m# v QTDIR \kbd{/usr/share/qt[34]}\quad [for non-root only]
3146 [[ -d /usr/share/qt3 ]] && export QTDIR=/usr/share/qt3
3147 [[ -d /usr/share/qt4 ]] && export QTDIR=/usr/share/qt4
3148
3149 # support running 'jikes *.java && jamvm HelloWorld' OOTB:
3150 #v# [for non-root only]
3151 [[ -f /usr/share/classpath/glibj.zip ]] && export JIKESPATH=/usr/share/classpath/glibj.zip
3152 # }}}
3153
3154 # aliases {{{
3155
3156 # Xterm resizing-fu.
3157 # Based on http://svn.kitenet.net/trunk/home-full/.zshrc?rev=11710&view=log (by Joey Hess)
3158 alias hide='echo -en "\033]50;nil2\007"'
3159 alias tiny='echo -en "\033]50;-misc-fixed-medium-r-normal-*-*-80-*-*-c-*-iso8859-15\007"'
3160 alias small='echo -en "\033]50;6x10\007"'
3161 alias medium='echo -en "\033]50;-misc-fixed-medium-r-normal--13-120-75-75-c-80-iso8859-15\007"'
3162 alias default='echo -e "\033]50;-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-15\007"'
3163 alias large='echo -en "\033]50;-misc-fixed-medium-r-normal-*-*-150-*-*-c-*-iso8859-15\007"'
3164 alias huge='echo -en "\033]50;-misc-fixed-medium-r-normal-*-*-210-*-*-c-*-iso8859-15\007"'
3165 alias smartfont='echo -en "\033]50;-artwiz-smoothansi-*-*-*-*-*-*-*-*-*-*-*-*\007"'
3166 alias semifont='echo -en "\033]50;-misc-fixed-medium-r-semicondensed-*-*-120-*-*-*-*-iso8859-15\007"'
3167
3168 # general
3169 #a2# Execute \kbd{du -sch}
3170 alias da='du -sch'
3171 #a2# Execute \kbd{jobs -l}
3172 alias j='jobs -l'
3173
3174 # compile stuff
3175 #a2# Execute \kbd{./configure}
3176 alias CO="./configure"
3177 #a2# Execute \kbd{./configure --help}
3178 alias CH="./configure --help"
3179
3180 # arch/tla stuff
3181 if check_com -c tla ; then
3182     #a2# Execute \kbd{tla what-changed --diffs | less}
3183     alias tdi='tla what-changed --diffs | less'
3184     #a2# Execute \kbd{tla-buildpackage}
3185     alias tbp='tla-buildpackage'
3186     #a2# Execute \kbd{tla archive-mirror}
3187     alias tmi='tla archive-mirror'
3188     #a2# Execute \kbd{tla commit}
3189     alias tco='tla commit'
3190     #a2# Execute \kbd{tla star-merge}
3191     alias tme='tla star-merge'
3192 fi
3193
3194 # listing stuff
3195 #a2# Execute \kbd{ls -lSrah}
3196 alias dir="ls -lSrah"
3197 #a2# Only show dot-directories
3198 alias lad='ls -d .*(/)'                # only show dot-directories
3199 #a2# Only show dot-files
3200 alias lsa='ls -a .*(.)'                # only show dot-files
3201 #a2# Only files with setgid/setuid/sticky flag
3202 alias lss='ls -l *(s,S,t)'             # only files with setgid/setuid/sticky flag
3203 #a2# Only show 1st ten symlinks
3204 alias lsl='ls -l *(@[1,10])'           # only symlinks
3205 #a2# Display only executables
3206 alias lsx='ls -l *(*[1,10])'           # only executables
3207 #a2# Display world-{readable,writable,executable} files
3208 alias lsw='ls -ld *(R,W,X.^ND/)'       # world-{readable,writable,executable} files
3209 #a2# Display the ten biggest files
3210 alias lsbig="ls -flh *(.OL[1,10])"     # display the biggest files
3211 #a2# Only show directories
3212 alias lsd='ls -d *(/)'                 # only show directories
3213 #a2# Only show empty directories
3214 alias lse='ls -d *(/^F)'               # only show empty directories
3215 #a2# Display the ten newest files
3216 alias lsnew="ls -rl *(D.om[1,10])"     # display the newest files
3217 #a2# Display the ten oldest files
3218 alias lsold="ls -rtlh *(D.om[1,10])"   # display the oldest files
3219 #a2# Display the ten smallest files
3220 alias lssmall="ls -Srl *(.oL[1,10])"   # display the smallest files
3221
3222 # chmod
3223 #a2# Execute \kbd{chmod 600}
3224 alias rw-='chmod 600'
3225 #a2# Execute \kbd{chmod 700}
3226 alias rwx='chmod 700'
3227 #m# a2 r-{}- Execute \kbd{chmod 644}
3228 alias r--='chmod 644'
3229 #a2# Execute \kbd{chmod 755}
3230 alias r-x='chmod 755'
3231
3232 # some useful aliases
3233 #a2# Execute \kbd{mkdir -o}
3234 alias md='mkdir -p'
3235
3236 check_com -c ipython && alias ips='ipython -p sh'
3237
3238 # console stuff
3239 #a2# Execute \kbd{mplayer -vo fbdev}
3240 alias cmplayer='mplayer -vo fbdev'
3241 #a2# Execute \kbd{mplayer -vo fbdev -fs -zoom}
3242 alias fbmplayer='mplayer -vo fbdev -fs -zoom'
3243 #a2# Execute \kbd{links2 -driver fb}
3244 alias fblinks='links2 -driver fb'
3245
3246 #a2# ssh with StrictHostKeyChecking=no \\&\quad and UserKnownHostsFile unset
3247 alias insecssh='ssh -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3248 alias insecscp='scp -o "StrictHostKeyChecking=no" -o "UserKnownHostsFile=/dev/null"'
3249
3250 # simple webserver
3251 check_com -c python && alias http="python -m SimpleHTTPServer"
3252
3253 # Use 'g' instead of 'git':
3254 check_com g || alias g='git'
3255
3256 # check whether Debian's package management (dpkg) is running
3257 if check_com salias ; then
3258     #a2# Check whether a dpkg instance is currently running
3259     salias check_dpkg_running="dpkg_running"
3260 fi
3261
3262 # work around non utf8 capable software in utf environment via $LANG and luit
3263 if check_com isutfenv && check_com luit ; then
3264     if check_com -c mrxvt ; then
3265         isutfenv && [[ -n "$LANG" ]] && \
3266             alias mrxvt="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit mrxvt"
3267     fi
3268
3269     if check_com -c aterm ; then
3270         isutfenv && [[ -n "$LANG" ]] && \
3271             alias aterm="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit aterm"
3272     fi
3273
3274     if check_com -c centericq ; then
3275         isutfenv && [[ -n "$LANG" ]] && \
3276             alias centericq="LANG=${LANG/(#b)(*)[.@]*/$match[1].iso885915} luit centericq"
3277     fi
3278 fi
3279 # }}}
3280
3281 # useful functions {{{
3282
3283 # searching
3284 #f4# Search for newspostings from authors
3285 agoogle() { ${=BROWSER} "http://groups.google.com/groups?as_uauthors=$*" ; }
3286 #f4# Search Debian Bug Tracking System
3287 debbug()  {
3288     emulate -L zsh
3289     setopt extendedglob
3290     if [[ $# -eq 1 ]]; then
3291         case "$1" in
3292             ([0-9]##)
3293             ${=BROWSER} "http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=$1"
3294             ;;
3295             (*@*)
3296             ${=BROWSER} "http://bugs.debian.org/cgi-bin/pkgreport.cgi?submitter=$1"
3297             ;;
3298             (*)
3299             ${=BROWSER} "http://bugs.debian.org/$*"
3300             ;;
3301         esac
3302     else
3303         print "$0 needs one argument"
3304         return 1
3305     fi
3306 }
3307 #f4# Search Debian Bug Tracking System in mbox format
3308 debbugm() {
3309     emulate -L zsh
3310     bts show --mbox $1
3311 }
3312 #f4# Search DMOZ
3313 dmoz()    {
3314     emulate -L zsh
3315     ${=BROWSER} http://search.dmoz.org/cgi-bin/search\?search=${1// /_}
3316 }
3317 #f4# Search German   Wiktionary
3318 dwicti()  {
3319     emulate -L zsh
3320     ${=BROWSER} http://de.wiktionary.org/wiki/${(C)1// /_}
3321 }
3322 #f4# Search English  Wiktionary
3323 ewicti()  {
3324     emulate -L zsh
3325     ${=BROWSER} http://en.wiktionary.org/wiki/${(C)1// /_}
3326 }
3327 #f4# Search Google Groups
3328 ggogle()  {
3329     emulate -L zsh
3330     ${=BROWSER} "http://groups.google.com/groups?q=$*"
3331 }
3332 #f4# Search Google
3333 google()  {
3334     emulate -L zsh
3335     ${=BROWSER} "http://www.google.com/search?&num=100&q=$*"
3336 }
3337 #f4# Search Google Groups for MsgID
3338 mggogle() {
3339     emulate -L zsh
3340     ${=BROWSER} "http://groups.google.com/groups?selm=$*"
3341 }
3342 #f4# Search Netcraft
3343 netcraft(){
3344     emulate -L zsh
3345     ${=BROWSER} "http://toolbar.netcraft.com/site_report?url=$1"
3346 }
3347 #f4# Use German Wikipedia's full text search
3348 swiki()   {
3349     emulate -L zsh
3350     ${=BROWSER} http://de.wikipedia.org/wiki/Spezial:Search/${(C)1}
3351 }
3352 #f4# search \kbd{dict.leo.org}
3353 oleo()    {
3354     emulate -L zsh
3355     ${=BROWSER} "http://dict.leo.org/?search=$*"
3356 }
3357 #f4# Search German   Wikipedia
3358 wikide()  {
3359     emulate -L zsh
3360     ${=BROWSER} http://de.wikipedia.org/wiki/"${(C)*}"
3361 }
3362 #f4# Search English  Wikipedia
3363 wikien()  {
3364     emulate -L zsh
3365     ${=BROWSER} http://en.wikipedia.org/wiki/"${(C)*}"
3366 }
3367 #f4# Search official debs
3368 wodeb()   {
3369     emulate -L zsh
3370     ${=BROWSER} "http://packages.debian.org/search?keywords=$1&searchon=contents&suite=${2:=unstable}&section=all"
3371 }
3372
3373 #m# f4 gex() Exact search via Google
3374 check_com google && gex () {
3375     google "\"[ $1]\" $*"
3376 }
3377
3378 # misc
3379 #f5# Backup \kbd{file {\rm to} file\_timestamp}
3380 bk() {
3381     emulate -L zsh
3382     cp -b $1 $1_`date --iso-8601=m`
3383 }
3384 #f5# Copied diff
3385 cdiff() {
3386     emulate -L zsh
3387     diff -crd "$*" | egrep -v "^Only in |^Binary files "
3388 }
3389 #f5# cd to directoy and list files
3390 cl() {
3391     emulate -L zsh
3392     cd $1 && ls -a
3393 }
3394 #f5# Cvs add
3395 cvsa() {
3396     emulate -L zsh
3397     cvs add $* && cvs com -m 'initial checkin' $*
3398 }
3399 #f5# Cvs diff
3400 cvsd() {
3401     emulate -L zsh
3402     cvs diff -N $* |& $PAGER
3403 }
3404 #f5# Cvs log
3405 cvsl() {
3406     emulate -L zsh
3407     cvs log $* |& $PAGER
3408 }
3409 #f5# Cvs update
3410 cvsq() {
3411     emulate -L zsh
3412     cvs -nq update
3413 }
3414 #f5# Rcs2log
3415 cvsr() {
3416     emulate -L zsh
3417     rcs2log $* | $PAGER
3418 }
3419 #f5# Cvs status
3420 cvss() {
3421     emulate -L zsh
3422     cvs status -v $*
3423 }
3424 #f5# Disassemble source files using gcc and as
3425 disassemble(){
3426     emulate -L zsh
3427     gcc -pipe -S -o - -O -g $* | as -aldh -o /dev/null
3428 }
3429 #f5# Firefox remote control - open given URL
3430 fir() {
3431     firefox -a firefox -remote "openURL($1)"
3432 }
3433 #f5# Create Directoy and \kbd{cd} to it
3434 mcd() {
3435     mkdir -p "$@" && cd "$@"
3436 }
3437 #f5# Unified diff to timestamped outputfile
3438 mdiff() {
3439     diff -udrP "$1" "$2" > diff.`date "+%Y-%m-%d"`."$1"
3440 }
3441 #f5# Memory overview
3442 memusage() {
3443     ps aux | awk '{if (NR > 1) print $5; if (NR > 2) print "+"} END { print "p" }' | dc
3444 }
3445 #f5# Show contents of tar file
3446 shtar() {
3447     emulate -L zsh
3448     gunzip -c $1 | tar -tf - -- | $PAGER
3449 }
3450 #f5# Show contents of tgz file
3451 shtgz() {
3452     emulate -L zsh
3453     tar -ztf $1 | $PAGER
3454 }
3455 #f5# Show contents of zip file
3456 shzip() {
3457     emulate -L zsh
3458     unzip -l $1 | $PAGER
3459 }
3460 #f5# Greps signature from file
3461 sig() {
3462     emulate -L zsh
3463     agrep -d '^-- $' "$*" ~/.Signature
3464 }
3465 #f5# Unified diff
3466 udiff() {
3467     emulate -L zsh
3468     diff -urd $* | egrep -v "^Only in |^Binary files "
3469 }
3470 #f5# (Mis)use \kbd{vim} as \kbd{less}
3471 viless() {
3472     emulate -L zsh
3473     vim --cmd 'let no_plugin_maps = 1' -c "so \$VIMRUNTIME/macros/less.vim" "${@:--}"
3474 }
3475
3476 # download video from youtube
3477 ytdl() {
3478     emulate -L zsh
3479     if ! [[ -n "$2" ]] ; then
3480         print "Usage: ydtl http://youtube.com/watch?v=.... outputfile.flv">&2
3481         return 1
3482     else
3483         wget -O${2} "http://youtube.com/get_video?"${${${"$(wget -o/dev/null -O- "${1}" | grep -e watch_fullscreen)"}##*watch_fullscreen\?}%%\&fs=*}
3484     fi
3485 }
3486
3487 # Function Usage: uopen $URL/$file
3488 #f5# Download a file and display it locally
3489 uopen() {
3490     emulate -L zsh
3491     if ! [[ -n "$1" ]] ; then
3492         print "Usage: uopen \$URL/\$file">&2
3493         return 1
3494     else
3495         FILE=$1
3496         MIME=$(curl --head $FILE | grep Content-Type | cut -d ' ' -f 2 | cut -d\; -f 1)
3497         MIME=${MIME%$'\r'}
3498         curl $FILE | see ${MIME}:-
3499     fi
3500 }
3501
3502 # Function Usage: doc packagename
3503 #f5# \kbd{cd} to /usr/share/doc/\textit{package}
3504 doc() {
3505     emulate -L zsh
3506     cd /usr/share/doc/$1 && ls
3507 }
3508 _doc() { _files -W /usr/share/doc -/ }
3509 check_com compdef && compdef _doc doc
3510
3511 #f5# Make screenshot
3512 sshot() {
3513     [[ ! -d ~/shots  ]] && mkdir ~/shots
3514     #cd ~/shots ; sleep 5 ; import -window root -depth 8 -quality 80 `date "+%Y-%m-%d--%H:%M:%S"`.png
3515     cd ~/shots ; sleep 5; import -window root shot_`date --iso-8601=m`.jpg
3516 }
3517
3518 # list images only
3519 limg() {
3520     local -a images
3521     images=( *.{jpg,gif,png}(.N) )
3522
3523     if [[ $#images -eq 0 ]] ; then
3524         print "No image files found"
3525     else
3526         ls "$@" "$images[@]"
3527     fi
3528 }
3529
3530 #f5# Create PDF file from source code
3531 makereadable() {
3532     emulate -L zsh
3533     output=$1
3534     shift
3535     a2ps --medium A4dj -E -o $output $*
3536     ps2pdf $output
3537 }
3538
3539 # zsh with perl-regex - use it e.g. via:
3540 # regcheck '\s\d\.\d{3}\.\d{3} Euro' ' 1.000.000 Euro'
3541 #f5# Checks whether a regex matches or not.\\&\quad Example: \kbd{regcheck '.\{3\} EUR' '500 EUR'}
3542 regcheck() {
3543     emulate -L zsh
3544     zmodload -i zsh/pcre
3545     pcre_compile $1 && \
3546     pcre_match $2 && echo "regex matches" || echo "regex does not match"
3547 }
3548
3549 #f5# List files which have been modified within the last {\it n} days
3550 new() {
3551     emulate -L zsh
3552     print -l *(m-$1)
3553 }
3554
3555 #f5# Grep in history
3556 greph() {
3557     emulate -L zsh
3558     history 0 | grep $1
3559 }
3560 # use colors when GNU grep with color-support
3561 #a2# Execute \kbd{grep -{}-color=auto}
3562 (grep --help 2>/dev/null |grep -- --color) >/dev/null && alias grep='grep --color=auto'
3563 #a2# Execute \kbd{grep -i -{}-color=auto}
3564 alias GREP='grep -i --color=auto'
3565
3566 #f5# Watch manpages in a stretched style
3567 man2() { PAGER='dash -c "sed G | /usr/bin/less"' command man "$@" ; }
3568
3569 # d():Copyright 2005 Nikolai Weibull <nikolai@bitwi.se>
3570 # note: option AUTO_PUSHD has to be set
3571 #f5# Jump between directories
3572 d() {
3573     emulate -L zsh
3574     autoload -U colors
3575     local color=$fg_bold[blue]
3576     integer i=0
3577     dirs -p | while read dir; do
3578         local num="${$(printf "%-4d " $i)/ /.}"
3579         printf " %s  $color%s$reset_color\n" $num $dir
3580         (( i++ ))
3581     done
3582     integer dir=-1
3583     read -r 'dir?Jump to directory: ' || return
3584     (( dir == -1 )) && return
3585     if (( dir < 0 || dir >= i )); then
3586         echo d: no such directory stack entry: $dir
3587         return 1
3588     fi
3589     cd ~$dir
3590 }
3591
3592 # usage example: 'lcheck strcpy'
3593 #f5# Find out which libs define a symbol
3594 lcheck() {
3595     if [[ -n "$1" ]] ; then
3596         nm -go /usr/lib/lib*.a 2>/dev/null | grep ":[[:xdigit:]]\{8\} . .*$1"
3597     else
3598         echo "Usage: lcheck <function>" >&2
3599     fi
3600 }
3601
3602 #f5# Clean up directory - remove well known tempfiles
3603 purge() {
3604     FILES=(*~(N) .*~(N) \#*\#(N) *.o(N) a.out(N) *.core(N) *.cmo(N) *.cmi(N) .*.swp(N))
3605     NBFILES=${#FILES}
3606     if [[ $NBFILES > 0 ]] ; then
3607         print $FILES
3608         local ans
3609         echo -n "Remove these files? [y/n] "
3610         read -q ans
3611         if [[ $ans == "y" ]] ; then
3612             rm ${FILES}
3613             echo ">> $PWD purged, $NBFILES files removed"
3614         else
3615             echo "Ok. .. than not.."
3616         fi
3617     fi
3618 }
3619
3620 # Translate DE<=>EN
3621 # 'translate' looks up fot a word in a file with language-to-language
3622 # translations (field separator should be " : "). A typical wordlist looks
3623 # like at follows:
3624 #  | english-word : german-transmission
3625 # It's also only possible to translate english to german but not reciprocal.
3626 # Use the following oneliner to turn back the sort order:
3627 #  $ awk -F ':' '{ print $2" : "$1" "$3 }' \
3628 #    /usr/local/lib/words/en-de.ISO-8859-1.vok > ~/.translate/de-en.ISO-8859-1.vok
3629 #f5# Translates a word
3630 trans() {
3631     emulate -L zsh
3632     case "$1" in
3633         -[dD]*)
3634             translate -l de-en $2
3635             ;;
3636         -[eE]*)
3637             translate -l en-de $2
3638             ;;
3639         *)
3640             echo "Usage: $0 { -D | -E }"
3641             echo "         -D == German to English"
3642             echo "         -E == English to German"
3643     esac
3644 }
3645
3646 #f5# List all occurrences of programm in current PATH
3647 plap() {
3648     emulate -L zsh
3649     if [[ $# = 0 ]] ; then
3650         echo "Usage:    $0 program"
3651         echo "Example:  $0 zsh"
3652         echo "Lists all occurrences of program in the current PATH."
3653     else
3654         ls -l ${^path}/*$1*(*N)
3655     fi
3656 }
3657
3658 # Found in the mailinglistarchive from Zsh (IIRC ~1996)
3659 #f5# Select items for specific command(s) from history
3660 selhist() {
3661     emulate -L zsh
3662     local TAB=$'\t';
3663     (( $# < 1 )) && {
3664         echo "Usage: $0 command"
3665         return 1
3666     };
3667     cmd=(${(f)"$(grep -w $1 $HISTFILE | sort | uniq | pr -tn)"})
3668     print -l $cmd | less -F
3669     echo -n "enter number of desired command [1 - $(( ${#cmd[@]} - 1 ))]: "
3670     local answer
3671     read answer
3672     print -z "${cmd[$answer]#*$TAB}"
3673 }
3674
3675 # Use vim to convert plaintext to HTML
3676 #f5# Transform files to html with highlighting
3677 2html() {
3678     emulate -L zsh
3679     vim -u NONE -n -c ':syntax on' -c ':so $VIMRUNTIME/syntax/2html.vim' -c ':wqa' $1 &>/dev/null
3680 }
3681
3682 # Usage: simple-extract <file>
3683 #f5# Smart archive extractor
3684 simple-extract () {
3685     emulate -L zsh
3686     if [[ -f $1 ]] ; then
3687         case $1 in
3688             *.tar.bz2)  bzip2 -v -d $1      ;;
3689             *.tar.gz)   tar -xvzf $1        ;;
3690             *.rar)      unrar $1            ;;
3691             *.deb)      ar -x $1            ;;
3692             *.bz2)      bzip2 -d $1         ;;
3693             *.lzh)      lha x $1            ;;
3694             *.gz)       gunzip -d $1        ;;
3695             *.tar)      tar -xvf $1         ;;
3696             *.tgz)      gunzip -d $1        ;;
3697             *.tbz2)     tar -jxvf $1        ;;
3698             *.zip)      unzip $1            ;;
3699             *.Z)        uncompress $1       ;;
3700             *)          echo "'$1' Error. Please go away" ;;
3701         esac
3702     else
3703         echo "'$1' is not a valid file"
3704     fi
3705 }
3706
3707 # Usage: smartcompress <file> (<type>)
3708 #f5# Smart archive creator
3709 smartcompress() {
3710     emulate -L zsh
3711     if [[ -n $2 ]] ; then
3712         case $2 in
3713             tgz | tar.gz)   tar -zcvf$1.$2 $1 ;;
3714             tbz2 | tar.bz2) tar -jcvf$1.$2 $1 ;;
3715             tar.Z)          tar -Zcvf$1.$2 $1 ;;
3716             tar)            tar -cvf$1.$2  $1 ;;
3717             gz | gzip)      gzip           $1 ;;
3718             bz2 | bzip2)    bzip2          $1 ;;
3719             *)
3720                 echo "Error: $2 is not a valid compression type"
3721                 ;;
3722         esac
3723     else
3724         smartcompress $1 tar.gz
3725     fi
3726 }
3727
3728 # Usage: show-archive <archive>
3729 #f5# List an archive's content
3730 show-archive() {
3731     emulate -L zsh
3732     if [[ -f $1 ]] ; then
3733         case $1 in
3734             *.tar.gz)      gunzip -c $1 | tar -tf - -- ;;
3735             *.tar)         tar -tf $1 ;;
3736             *.tgz)         tar -ztf $1 ;;
3737             *.zip)         unzip -l $1 ;;
3738             *.bz2)         bzless $1 ;;
3739             *.deb)         dpkg-deb --fsys-tarfile $1 | tar -tf - -- ;;
3740             *)             echo "'$1' Error. Please go away" ;;
3741         esac
3742     else
3743         echo "'$1' is not a valid archive"
3744     fi
3745 }
3746
3747 # It's shameless stolen from <http://www.vim.org/tips/tip.php?tip_id=167>
3748 #f5# Use \kbd{vim} as your manpage reader
3749 vman() {
3750     emulate -L zsh
3751     man $* | col -b | view -c 'set ft=man nomod nolist' -
3752 }
3753
3754 # function readme() { $PAGER -- (#ia3)readme* }
3755 #f5# View all README-like files in current directory in pager
3756 readme() {
3757     emulate -L zsh
3758     local files
3759     files=(./(#i)*(read*me|lue*m(in|)ut)*(ND))
3760     if (($#files)) ; then
3761         $PAGER $files
3762     else
3763         print 'No README files.'
3764     fi
3765 }
3766
3767 # function ansi-colors()
3768 #f5# Display ANSI colors
3769 ansi-colors() {
3770     typeset esc="\033[" line1 line2
3771     echo " _ _ _40 _ _ _41_ _ _ _42 _ _ 43_ _ _ 44_ _ _45 _ _ _ 46_ _ _ 47_ _ _ 49_ _"
3772     for fore in 30 31 32 33 34 35 36 37; do
3773         line1="$fore "
3774         line2="   "
3775         for back in 40 41 42 43 44 45 46 47 49; do
3776             line1="${line1}${esc}${back};${fore}m Normal ${esc}0m"
3777             line2="${line2}${esc}${back};${fore};1m Bold   ${esc}0m"
3778         done
3779         echo -e "$line1\n$line2"
3780     done
3781 }
3782
3783 # suidfind() { ls -latg $path | grep '^...s' }
3784 #f5# Find all files in \$PATH with setuid bit set
3785 suidfind() { ls -latg $path/*(sN) }
3786
3787 # See above but this is /better/ ... anywise ..
3788 findsuid() {
3789     print 'Output will be written to ~/suid_* ...'
3790     $SUDO find / -type f \( -perm -4000 -o -perm -2000 \) -ls > ~/suid_suidfiles.`date "+%Y-%m-%d"`.out 2>&1
3791     $SUDO find / -type d \( -perm -4000 -o -perm -2000 \) -ls > ~/suid_suiddirs.`date "+%Y-%m-%d"`.out 2>&1
3792     $SUDO find / -type f \( -perm -2 -o -perm -20 \) -ls > ~/suid_writefiles.`date "+%Y-%m-%d"`.out 2>&1
3793     $SUDO find / -type d \( -perm -2 -o -perm -20 \) -ls > ~/suid_writedirs.`date "+%Y-%m-%d"`.out 2>&1
3794     print 'Finished'
3795 }
3796
3797 # TODO: So, this is the third incarnation of this function!?
3798 #f5# Reload given functions
3799 refunc() {
3800     for func in $argv ; do
3801         unfunction $func
3802         autoload $func
3803     done
3804 }
3805
3806 # a small check to see which DIR is located on which server/partition.
3807 # stolen and modified from Sven's zshrc.forall
3808 #f5# Report diskusage of a directory
3809 dirspace() {
3810     emulate -L zsh
3811     if [[ -n "$1" ]] ; then
3812         for dir in "$@" ; do
3813             if [[ -d "$dir" ]] ; then
3814                 ( cd $dir; echo "-<$dir>"; du -shx .; echo);
3815             else
3816                 echo "warning: $dir does not exist" >&2
3817             fi
3818         done
3819     else
3820         for dir in $path; do
3821             if [[ -d "$dir" ]] ; then
3822                 ( cd $dir; echo "-<$dir>"; du -shx .; echo);
3823             else
3824                 echo "warning: $dir does not exist" >&2
3825             fi
3826         done
3827     fi
3828 }
3829
3830 # % slow_print `cat /etc/passwd`
3831 #f5# Slowly print out parameters
3832 slow_print() {
3833     for argument in "$@" ; do
3834         for ((i = 1; i <= ${#1} ;i++)) ; do
3835             print -n "${argument[i]}"
3836             sleep 0.08
3837         done
3838         print -n " "
3839     done
3840     print ""
3841 }
3842
3843 #f5# Show some status info
3844 status() {
3845     print
3846     print "Date..: "$(date "+%Y-%m-%d %H:%M:%S")
3847     print "Shell.: Zsh $ZSH_VERSION (PID = $$, $SHLVL nests)"
3848     print "Term..: $TTY ($TERM), ${BAUD:+$BAUD bauds, }$COLUMNS x $LINES chars"
3849     print "Login.: $LOGNAME (UID = $EUID) on $HOST"
3850     print "System: $(cat /etc/[A-Za-z]*[_-][rv]e[lr]*)"
3851     print "Uptime:$(uptime)"
3852     print
3853 }
3854
3855 # Rip an audio CD
3856 #f5# Rip an audio CD
3857 audiorip() {
3858     mkdir -p ~/ripps
3859     cd ~/ripps
3860     cdrdao read-cd --device $DEVICE --driver generic-mmc audiocd.toc
3861     cdrdao read-cddb --device $DEVICE --driver generic-mmc audiocd.toc
3862     echo " * Would you like to burn the cd now? (yes/no)"
3863     read input
3864     if [[ "$input" = "yes" ]] ; then
3865         echo " ! Burning Audio CD"
3866         audioburn
3867         echo " * done."
3868     else
3869         echo " ! Invalid response."
3870     fi
3871 }
3872
3873 # and burn it
3874 #f5# Burn an audio CD (in combination with audiorip)
3875 audioburn() {
3876     cd ~/ripps
3877     cdrdao write --device $DEVICE --driver generic-mmc audiocd.toc
3878     echo " * Should I remove the temporary files? (yes/no)"
3879     read input
3880     if [[ "$input" = "yes" ]] ; then
3881         echo " ! Removing Temporary Files."
3882         cd ~
3883         rm -rf ~/ripps
3884         echo " * done."
3885     else
3886         echo " ! Invalid response."
3887     fi
3888 }
3889
3890 #f5# Make an audio CD from all mp3 files
3891 mkaudiocd() {
3892     # TODO: do the renaming more zshish, possibly with zmv()
3893     emulate -L zsh
3894     cd ~/ripps
3895     for i in *.[Mm][Pp]3; do mv "$i" `echo $i | tr '[A-Z]' '[a-z]'`; done
3896     for i in *.mp3; do mv "$i" `echo $i | tr ' ' '_'`; done
3897     for i in *.mp3; do mpg123 -w `basename $i .mp3`.wav $i; done
3898     normalize -m *.wav
3899     for i in *.wav; do sox $i.wav -r 44100 $i.wav resample; done
3900 }
3901
3902 #f5# Create an ISO image. You are prompted for\\&\quad volume name, filename and directory
3903 mkiso() {
3904     emulate -L zsh
3905     echo " * Volume name "
3906     read volume
3907     echo " * ISO Name (ie. tmp.iso)"
3908     read iso
3909     echo " * Directory or File"
3910     read files
3911     mkisofs -o ~/$iso -A $volume -allow-multidot -J -R -iso-level 3 -V $volume -R $files
3912 }
3913
3914 #f5# Simple thumbnails generator
3915 genthumbs() {
3916     rm -rf thumb-* index.html
3917     echo "
3918 <html>
3919   <head>
3920     <title>Images</title>
3921   </head>
3922   <body>" > index.html
3923     for f in *.(gif|jpeg|jpg|png) ; do
3924         convert -size 100x200 "$f" -resize 100x200 thumb-"$f"
3925         echo "    <a href=\"$f\"><img src=\"thumb-$f\"></a>" >> index.html
3926     done
3927     echo "
3928   </body>
3929 </html>" >> index.html
3930 }
3931
3932 #f5# Set all ulimit parameters to \kbd{unlimited}
3933 allulimit() {
3934     ulimit -c unlimited
3935     ulimit -d unlimited
3936     ulimit -f unlimited
3937     ulimit -l unlimited
3938     ulimit -n unlimited
3939     ulimit -s unlimited
3940     ulimit -t unlimited
3941 }
3942
3943 # ogg2mp3 with bitrate of 192
3944 ogg2mp3_192() {
3945     emulate -L zsh
3946     oggdec -o - $1 | lame -b 192 - ${1:r}.mp3
3947 }
3948
3949 #f5# RFC 2396 URL encoding in Z-Shell
3950 urlencode() {
3951     emulate -L zsh
3952     setopt extendedglob
3953     input=( ${(s::)1} )
3954     print ${(j::)input/(#b)([^A-Za-z0-9_.!~*\'\(\)-])/%${(l:2::0:)$(([##16]#match))}}
3955 }
3956
3957 #f5# Install x-lite (VoIP software)
3958 getxlite() {
3959     emulate -L zsh
3960     setopt errreturn
3961     [[ -d ~/tmp ]] || mkdir ~/tmp
3962     cd ~/tmp
3963
3964     echo "Downloading http://www.counterpath.com/download/X-Lite_Install.tar.gz and storing it in ~/tmp:"
3965     if wget http://www.counterpath.com/download/X-Lite_Install.tar.gz ; then
3966         unp X-Lite_Install.tar.gz && echo done || echo failed
3967     else
3968         echo "Error while downloading." ; return 1
3969     fi
3970
3971     if [[ -x xten-xlite/xtensoftphone ]] ; then
3972         echo "Execute xten-xlite/xtensoftphone to start xlite."
3973     fi
3974 }
3975
3976 #f5# Install skype
3977 getskype() {
3978     emulate -L zsh
3979     setopt errreturn
3980     echo "Downloading debian package of skype."
3981     echo "Notice: If you want to use a more recent skype version run 'getskypebeta'."
3982     wget http://www.skype.com/go/getskype-linux-deb
3983     $SUDO dpkg -i skype*.deb && echo "skype installed."
3984 }
3985
3986 #f5# Install beta-version of skype
3987 getskypebeta() {
3988     emulate -L zsh
3989     setopt errreturn
3990     echo "Downloading debian package of skype (beta version)."
3991     wget http://www.skype.com/go/getskype-linux-beta-deb
3992     $SUDO dpkg -i skype-beta*.deb && echo "skype installed."
3993 }
3994
3995 #f5# Install gizmo (VoIP software)
3996 getgizmo() {
3997     emulate -L zsh
3998     setopt errreturn
3999     echo "libgtk2.0-0, gconf2, libstdc++6, libasound2 and zlib1g have to be available. Installing."
4000     $SUDO apt-get update
4001     $SUDO apt-get install libgtk2.0-0 gconf2 libstdc++6 libasound2 zlib1g
4002     wget "$(lynx --dump http://gizmo5.com/pc/download/linux/ | awk '/libstdc\+\+6.*\.deb/ {print $2}')"
4003     $SUDO dpkg -i gizmo-project*.deb && echo "gizmo installed."
4004 }
4005
4006 #f5# Get and run AIR (Automated Image and Restore)
4007 getair() {
4008     emulate -L zsh
4009     setopt errreturn
4010     [[ -w . ]] || { echo 'Error: you do not have write permissions in this directory. Exiting.' ; return 1 }
4011     local VER='1.2.8'
4012     wget http://puzzle.dl.sourceforge.net/sourceforge/air-imager/air-$VER.tar.gz
4013     tar zxf air-$VER.tar.gz
4014     cd air-$VER
4015     INTERACTIVE=no $SUDO ./install-air-1.2.8
4016     [[ -x /usr/local/bin/air ]] && [[ -n "$DISPLAY" ]] && $SUDO air
4017 }
4018
4019 #f5# Get specific git commitdiff
4020 git-get-diff() {
4021     emulate -L zsh
4022     if [[ -z $GITTREE ]] ; then
4023         GITTREE='linux/kernel/git/torvalds/linux-2.6.git'
4024     fi
4025     if ! [[ -z $1 ]] ; then
4026         ${=BROWSER} "http://kernel.org/git/?p=$GITTREE;a=commitdiff;h=$1"
4027     else
4028         echo "Usage: git-get-diff <commit>"
4029     fi
4030 }
4031
4032 #f5# Get specific git commit
4033 git-get-commit() {
4034     emulate -L zsh
4035     if [[ -z $GITTREE ]] ; then
4036         GITTREE='linux/kernel/git/torvalds/linux-2.6.git'
4037     fi
4038     if ! [[ -z $1 ]] ; then
4039         ${=BROWSER} "http://kernel.org/git/?p=$GITTREE;a=commit;h=$1"
4040     else
4041         echo "Usage: git-get-commit <commit>"
4042     fi
4043 }
4044
4045 #f5# Get specific git diff
4046 git-get-plaindiff () {
4047     emulate -L zsh
4048     if [[ -z $GITTREE ]] ; then
4049        GITTREE='linux/kernel/git/torvalds/linux-2.6.git'
4050     fi
4051     if [[ -z $1 ]] ; then
4052        echo 'Usage: git-get-plaindiff '
4053     else
4054        echo -n "Downloading $1.diff ... "
4055        # avoid "generating ..." stuff from kernel.org server:
4056        wget --quiet "http://kernel.org/git/?p=$GITTREE;a=commitdiff_plain;h=$1" -O /dev/null
4057        wget --quiet "http://kernel.org/git/?p=$GITTREE;a=commitdiff_plain;h=$1" -O $1.diff \
4058             && echo done || echo failed
4059     fi
4060 }
4061
4062
4063 # http://strcat.de/blog/index.php?/archives/335-Software-sauber-deinstallieren...html
4064 #f5# Log 'make install' output
4065 mmake() {
4066     emulate -L zsh
4067     [[ ! -d ~/.errorlogs ]] && mkdir ~/.errorlogs
4068     make -n install > ~/.errorlogs/${PWD##*/}-makelog
4069 }
4070
4071 #f5# Indent source code
4072 smart-indent() {
4073     indent -npro -kr -i8 -ts8 -sob -l80 -ss -ncs "$@"
4074 }
4075
4076 # highlight important stuff in diff output, usage example: hg diff | hidiff
4077 #m# a2 hidiff \kbd{histring} oneliner for diffs
4078 check_com -c histring && \
4079     alias hidiff="histring -fE '^Comparing files .*|^diff .*' | histring -c yellow -fE '^\-.*' | histring -c green -fE '^\+.*'"
4080
4081 # rename pictures based on information found in exif headers
4082 #f5# Rename pictures based on information found in exif headers
4083 exirename() {
4084     emulate -L zsh
4085     if [[ $# -lt 1 ]] ; then
4086         echo 'Usage: jpgrename $FILES' >& 2
4087         return 1
4088     else
4089         echo -n 'Checking for jhead with version newer than 1.9: '
4090         jhead_version=`jhead -h | grep 'used by most Digital Cameras.  v.*' | awk '{print $6}' | tr -d v`
4091         if [[ $jhead_version > '1.9' ]]; then
4092             echo 'success - now running jhead.'
4093             jhead -n%Y-%m-%d_%Hh%M_%f $*
4094         else
4095             echo 'failed - exiting.'
4096         fi
4097     fi
4098 }
4099
4100 # open file in vim and jump to line
4101 # http://www.downgra.de/archives/2007/05/08/T19_21_11/
4102 j2v() {
4103     emulate -L zsh
4104     local -a params
4105     params=(${*//(#m):[0-9]*:/\\n+${MATCH//:/}}) # replace ':23:' to '\n+23'
4106     params=(${(s|\n|)${(j|\n|)params}}) # join array using '\n', then split on all '\n'
4107     vim ${params}
4108 }
4109
4110 # get_ic() - queries imap servers for capabilities; real simple. no imaps
4111 ic_get() {
4112     emulate -L zsh
4113     local port
4114     if [[ ! -z $1 ]] ; then
4115         port=${2:-143}
4116         print "querying imap server on $1:${port}...\n";
4117         print "a1 capability\na2 logout\n" | nc $1 ${port}
4118     else
4119         print "usage:\n  $0 <imap-server> [port]"
4120     fi
4121 }
4122
4123 # creates a Maildir/ with its {new,cur,tmp} subdirs
4124 mkmaildir() {
4125     emulate -L zsh
4126     local root subdir
4127     root=${MAILDIR_ROOT:-${HOME}/Mail}
4128     if [[ -z ${1} ]] ; then print "Usage:\n $0 <dirname>" ; return 1 ; fi
4129     subdir=${1}
4130     mkdir -p ${root}/${subdir}/{cur,new,tmp}
4131 }
4132
4133 #f5# Change the xterm title from within GNU-screen
4134 xtrename() {
4135     emulate -L zsh
4136     if [[ $1 != "-f" ]] ; then
4137         if [[ -z ${DISPLAY} ]] ; then
4138             printf 'xtrename only makes sense in X11.\n'
4139             return 1
4140         fi
4141     else
4142         shift
4143     fi
4144     if [[ -z $1 ]] ; then
4145         printf 'usage: xtrename [-f] "title for xterm"\n'
4146         printf '  renames the title of xterm from _within_ screen.\n'
4147         printf '  also works without screen.\n'
4148         printf '  will not work if DISPLAY is unset, use -f to override.\n'
4149         return 0
4150     fi
4151     print -n "\eP\e]0;${1}\C-G\e\\"
4152     return 0
4153 }
4154
4155 # hl() highlighted less
4156 # http://ft.bewatermyfriend.org/comp/data/zsh/zfunct.html
4157 if check_com -c highlight ; then
4158     function hl() {
4159     emulate -L zsh
4160         local theme lang
4161         theme=${HL_THEME:-""}
4162         case ${1} in
4163             (-l|--list)
4164                 ( printf 'available languages (syntax parameter):\n\n' ;
4165                     highlight --list-langs ; ) | less -SMr
4166                 ;;
4167             (-t|--themes)
4168                 ( printf 'available themes (style parameter):\n\n' ;
4169                     highlight --list-themes ; ) | less -SMr
4170                 ;;
4171             (-h|--help)
4172                 printf 'usage: hl <syntax[:theme]> <file>\n'
4173                 printf '    available options: --list (-l), --themes (-t), --help (-h)\n\n'
4174                 printf '  Example: hl c main.c\n'
4175                 ;;
4176             (*)
4177                 if [[ -z ${2} ]] || (( ${#argv} > 2 )) ; then
4178                     printf 'usage: hl <syntax[:theme]> <file>\n'
4179                     printf '    available options: --list (-l), --themes (-t), --help (-h)\n'
4180                     (( ${#argv} > 2 )) && printf '  Too many arguments.\n'
4181                     return 1
4182                 fi
4183                 lang=${1%:*}
4184                 [[ ${1} == *:* ]] && [[ -n ${1#*:} ]] && theme=${1#*:}
4185                 if [[ -n ${theme} ]] ; then
4186                     highlight --xterm256 --syntax ${lang} --style ${theme} ${2} | less -SMr
4187                 else
4188                     highlight --ansi --syntax ${lang} ${2} | less -SMr
4189                 fi
4190                 ;;
4191         esac
4192         return 0
4193     }
4194     # ... and a proper completion for hl()
4195     # needs 'highlight' as well, so it fits fine in here.
4196     function _hl_genarg()  {
4197         local expl
4198         if [[ -prefix 1 *: ]] ; then
4199             local themes
4200             themes=(${${${(f)"$(LC_ALL=C highlight --list-themes)"}/ #/}:#*(Installed|Use name)*})
4201             compset -P 1 '*:'
4202             _wanted -C list themes expl theme compadd ${themes}
4203         else
4204             local langs
4205             langs=(${${${(f)"$(LC_ALL=C highlight --list-langs)"}/ #/}:#*(Installed|Use name)*})
4206             _wanted -C list languages expl languages compadd -S ':' -q ${langs}
4207         fi
4208     }
4209     function _hl_complete() {
4210         _arguments -s '1: :_hl_genarg' '2:files:_path_files'
4211     }
4212     compdef _hl_complete hl
4213 fi
4214
4215 # Create small urls via http://tinyurl.com using wget(1).
4216 function zurl() {
4217     emulate -L zsh
4218     [[ -z $1 ]] && { print "USAGE: zurl <URL>" ; return 1 }
4219
4220     local PN url tiny grabber search result preview
4221     PN=$0
4222     url=$1
4223 #   Check existence of given URL with the help of ping(1).
4224 #   N.B. ping(1) only works without an eventual given protocol.
4225     ping -c 1 ${${url#(ftp|http)://}%%/*} >& /dev/null || \
4226         read -q "?Given host ${${url#http://*/}%/*} is not reachable by pinging. Proceed anyway? [y|n] "
4227
4228     if (( $? == 0 )) ; then
4229 #           Prepend 'http://' to given URL where necessary for later output.
4230             [[ ${url} != http(s|)://* ]] && url='http://'${url}
4231             tiny='http://tinyurl.com/create.php?url='
4232             if check_com -c wget ; then
4233                 grabber='wget -O- -o/dev/null'
4234             else
4235                 print "wget is not available, but mandatory for ${PN}. Aborting."
4236             fi
4237 #           Looking for i.e.`copy('http://tinyurl.com/7efkze')' in TinyURL's HTML code.
4238             search='copy\(?http://tinyurl.com/[[:alnum:]]##*'
4239             result=${(M)${${${(f)"$(${=grabber} ${tiny}${url})"}[(fr)${search}*]}//[()\';]/}%%http:*}
4240 #           TinyURL provides the rather new feature preview for more confidence. <http://tinyurl.com/preview.php>
4241             preview='http://preview.'${result#http://}
4242
4243             printf '%s\n\n' "${PN} - Shrinking long URLs via webservice TinyURL <http://tinyurl.com>."
4244             printf '%s\t%s\n\n' 'Given URL:' ${url}
4245             printf '%s\t%s\n\t\t%s\n' 'TinyURL:' ${result} ${preview}
4246     else
4247         return 1
4248     fi
4249 }
4250
4251 #f2# Print a specific line of file(s).
4252 linenr () {
4253 # {{{
4254     emulate -L zsh
4255     if [ $# -lt 2 ] ; then
4256        print "Usage: linenr <number>[,<number>] <file>" ; return 1
4257     elif [ $# -eq 2 ] ; then
4258          local number=$1
4259          local file=$2
4260          command ed -s $file <<< "${number}n"
4261     else
4262          local number=$1
4263          shift
4264          for file in "$@" ; do
4265              if [ ! -d $file ] ; then
4266                 echo "${file}:"
4267                 command ed -s $file <<< "${number}n" 2> /dev/null
4268              else
4269                 continue
4270              fi
4271          done | less
4272     fi
4273 # }}}
4274 }
4275
4276 #f2# Find history events by search pattern and list them by date.
4277 whatwhen()  {
4278 # {{{
4279     emulate -L zsh
4280     local usage help ident format_l format_s first_char remain first last
4281     usage='USAGE: whatwhen [options] <searchstring> <search range>'
4282     help='Use' \`'whatwhen -h'\'' for further explanations.'
4283     ident=${(l,${#${:-Usage: }},, ,)}
4284     format_l="${ident}%s\t\t\t%s\n"
4285     format_s="${format_l//(\\t)##/\\t}"
4286     # Make the first char of the word to search for case
4287     # insensitive; e.g. [aA]
4288     first_char=[${(L)1[1]}${(U)1[1]}]
4289     remain=${1[2,-1]}
4290     # Default search range is `-100'.
4291     first=${2:-\-100}
4292     # Optional, just used for `<first> <last>' given.
4293     last=$3
4294     case $1 in
4295         ("")
4296             printf '%s\n\n' 'ERROR: No search string specified. Aborting.'
4297             printf '%s\n%s\n\n' ${usage} ${help} && return 1
4298         ;;
4299         (-h)
4300             printf '%s\n\n' ${usage}
4301             print 'OPTIONS:'
4302             printf $format_l '-h' 'show help text'
4303             print '\f'
4304             print 'SEARCH RANGE:'
4305             printf $format_l "'0'" 'the whole history,'
4306             printf $format_l '-<n>' 'offset to the current history number; (default: -100)'
4307             printf $format_s '<[-]first> [<last>]' 'just searching within a give range'
4308             printf '\n%s\n' 'EXAMPLES:'
4309             printf ${format_l/(\\t)/} 'whatwhen grml' '# Range is set to -100 by default.'
4310             printf $format_l 'whatwhen zsh -250'
4311             printf $format_l 'whatwhen foo 1 99'
4312         ;;
4313         (\?)
4314             printf '%s\n%s\n\n' ${usage} ${help} && return 1
4315         ;;
4316         (*)
4317             # -l list results on stout rather than invoking $EDITOR.
4318             # -i Print dates as in YYYY-MM-DD.
4319             # -m Search for a - quoted - pattern within the history.
4320             fc -li -m "*${first_char}${remain}*" $first $last
4321         ;;
4322     esac
4323 # }}}
4324 }
4325
4326 # change fluxbox keys from 'Alt-#' to 'Alt-F#' and vice versa
4327 fluxkey-change() {
4328     emulate -L zsh
4329     [[ -n "$FLUXKEYS" ]] || local FLUXKEYS="$HOME/.fluxbox/keys"
4330     if ! [[ -r "$FLUXKEYS" ]] ; then
4331         echo "Sorry, \$FLUXKEYS file $FLUXKEYS could not be read - nothing to be done."
4332         return 1
4333     else
4334         if grep -q 'Mod1 F[0-9] :Workspace [0-9]' $FLUXKEYS ; then
4335             echo -n 'Switching to Alt-# mode in ~/.fluxbox/keys: '
4336             sed -i -e 's|^\(Mod[0-9]\+[: space :]\+\)F\([0-9]\+[: space :]\+:Workspace.*\)|\1\2|' $FLUXKEYS && echo done || echo failed
4337         elif grep -q 'Mod1 [0-9] :Workspace [0-9]' $FLUXKEYS ; then
4338             echo -n 'Switching to Alt-F# mode in ~/.fluxbox/keys: '
4339             sed -i -e 's|^\(Mod[0-9]\+[: space :]\+\)\([0-9]\+[: space :]\+:Workspace.*\)|\1F\2|' $FLUXKEYS && echo done || echo failed
4340         else
4341             echo 'Sorry, do not know what to do.'
4342             return 1
4343         fi
4344     fi
4345 }
4346
4347 # retrieve weather information on the console
4348 # Usage example: 'weather LOWG'
4349 weather() {
4350     emulate -L zsh
4351     [[ -n "$1" ]] || {
4352         print 'Usage: weather <station_id>' >&2
4353         print 'List of stations: http://en.wikipedia.org/wiki/List_of_airports_by_ICAO_code'>&2
4354         return 1
4355     }
4356
4357     local PLACE="${1:u}"
4358     local FILE="$HOME/.weather/$PLACE"
4359     local LOG="$HOME/.weather/log"
4360
4361     [[ -d $HOME/.weather ]] || {
4362         print -n "Creating $HOME/.weather: "
4363         mkdir $HOME/.weather
4364         print 'done'
4365     }
4366
4367     print "Retrieving information for ${PLACE}:"
4368     print
4369     wget -T 10 --no-verbose --output-file=$LOG --output-document=$FILE --timestamping http://weather.noaa.gov/pub/data/observations/metar/decoded/$PLACE.TXT
4370
4371     if [[ $? -eq 0 ]] ; then
4372         if [[ -n "$VERBOSE" ]] ; then
4373             cat $FILE
4374         else
4375             DATE=$(grep 'UTC' $FILE | sed 's#.* /##')
4376             TEMPERATURE=$(awk '/Temperature/ { print $4" degree Celcius / " $2" degree Fahrenheit" }' $FILE| tr -d '(')
4377             echo "date: $DATE"
4378             echo "temp:  $TEMPERATURE"
4379         fi
4380     else
4381         print "There was an error retrieving the weather information for $PLACE" >&2
4382         cat $LOG
4383         return 1
4384     fi
4385 }
4386 # }}}
4387
4388 # mercurial related stuff {{{
4389 if check_com -c hg ; then
4390     # gnu like diff for mercurial
4391     # http://www.selenic.com/mercurial/wiki/index.cgi/TipsAndTricks
4392     #f5# GNU like diff for mercurial
4393     hgdi() {
4394         emulate -L zsh
4395         for i in $(hg status -marn "$@") ; diff -ubwd <(hg cat "$i") "$i"
4396     }
4397
4398     # build debian package
4399     #a2# Alias for \kbd{hg-buildpackage}
4400     alias hbp='hg-buildpackage'
4401
4402     # execute commands on the versioned patch-queue from the current repos
4403     alias mq='hg -R $(readlink -f $(hg root)/.hg/patches)'
4404
4405     # diffstat for specific version of a mercurial repository
4406     #   hgstat      => display diffstat between last revision and tip
4407     #   hgstat 1234 => display diffstat between revision 1234 and tip
4408     #f5# Diffstat for specific version of a mercurial repos
4409     hgstat() {
4410         emulate -L zsh
4411         [[ -n "$1" ]] && hg diff -r $1 -r tip | diffstat || hg export tip | diffstat
4412     }
4413
4414     #f5# Get current mercurial tip via hg itself
4415     gethgclone() {
4416         emulate -L zsh
4417         setopt errreturn
4418         if [[ -f mercurial-tree/.hg ]] ; then
4419             cd mercurial-tree
4420             echo "Running hg pull for retreiving latest version..."
4421             hg pull
4422             echo "Finished update. Building mercurial"
4423             make local
4424             echo "Setting \$PATH to $PWD:\$PATH..."
4425             export PATH="$PWD:$PATH"
4426         else
4427             echo "Downloading mercurial via hg"
4428             hg clone http://selenic.com/repo/hg mercurial-tree
4429             cd mercurial-tree
4430             echo "Building mercurial"
4431             make local
4432             echo "Setting \$PATH to $PWD:\$PATH..."
4433             export PATH="$PWD:$PATH"
4434             echo "make sure you set it permanent via ~/.zshrc if you plan to use it permanently."
4435             # echo "Setting \$PYTHONPATH to PYTHONPATH=\${HOME}/lib/python,"
4436             # export PYTHONPATH=${HOME}/lib/python
4437         fi
4438     }
4439
4440 fi # end of check whether we have the 'hg'-executable
4441
4442 # get current mercurial snapshot
4443 #f5# Get current mercurial snapshot
4444 gethgsnap() {
4445     emulate -L zsh
4446     setopt errreturn
4447     if [[ -f mercurial-snapshot.tar.gz ]] ; then
4448          echo "mercurial-snapshot.tar.gz exists already, skipping download."
4449     else
4450         echo "Downloading mercurial snapshot"
4451         wget http://www.selenic.com/mercurial/mercurial-snapshot.tar.gz
4452     fi
4453     echo "Unpacking mercurial-snapshot.tar.gz"
4454     tar zxf mercurial-snapshot.tar.gz
4455     cd mercurial-snapshot/
4456     echo "Installing required build-dependencies"
4457     $SUDO apt-get update
4458     $SUDO apt-get install python2.4-dev
4459     echo "Building mercurial"
4460     make local
4461     echo "Setting \$PATH to $PWD:\$PATH..."
4462     export PATH="$PWD:$PATH"
4463     echo "make sure you set it permanent via ~/.zshrc if you plan to use it permanently."
4464 }
4465 # }}}
4466
4467 # some useful commands often hard to remember - let's grep for them {{{
4468 # actually use our zg() function now. :)
4469
4470 # Work around ion/xterm resize bug.
4471 #if [[ "$SHLVL" -eq 1 ]]; then
4472 #       if check_com -c resize ; then
4473 #               eval `resize </dev/null`
4474 #       fi
4475 #fi
4476
4477 # enable jackd:
4478 #  /usr/bin/jackd -dalsa -dhw:0 -r48000 -p1024 -n2
4479 # now play audio file:
4480 #  alsaplayer -o jack foobar.mp3
4481
4482 # send files via netcat
4483 # on sending side:
4484 #  send() {j=$*; tar cpz ${j/%${!#}/}|nc -w 1 ${!#} 51330;}
4485 #  send dir* $HOST
4486 #  alias receive='nc -vlp 51330 | tar xzvp'
4487
4488 # debian stuff:
4489 # dh_make -e foo@localhost -f $1
4490 # dpkg-buildpackage -rfakeroot
4491 # lintian *.deb
4492 # dpkg-scanpackages ./ /dev/null | gzip > Packages.gz
4493 # dpkg-scansources . | gzip > Sources.gz
4494 # grep-dctrl --field Maintainer $* /var/lib/apt/lists/*
4495
4496 # other stuff:
4497 # convert -geometry 200x200 -interlace LINE -verbose
4498 # ldapsearch -x -b "OU=Bedienstete,O=tug" -h ldap.tugraz.at sn=$1
4499 # ps -ao user,pcpu,start,command
4500 # gpg --keyserver blackhole.pca.dfn.de --recv-keys
4501 # xterm -bg black -fg yellow -fn -misc-fixed-medium-r-normal--14-140-75-75-c-90-iso8859-15 -ah
4502 # nc -vz $1 1-1024   # portscan via netcat
4503 # wget --mirror --no-parent --convert-links
4504 # pal -d `date +%d`
4505 # autoload -U tetris; zle -N tetris; bindkey '...' ; echo "press ... for playing tennis"
4506 #
4507 # modify console cursor
4508 # see http://www.tldp.org/HOWTO/Framebuffer-HOWTO-5.html
4509 # print $'\e[?96;0;64c'
4510 # }}}
4511
4512 # grml-small cleanups {{{
4513
4514 # The following is used to remove zsh-config-items that do not work
4515 # in grml-small by default.
4516 # If you do not want these adjustments (for whatever reason), set
4517 # $GRMLSMALL_SPECIFIC to 0 in your .zshrc.pre file (which this configuration
4518 # sources if it is there).
4519
4520 if (( GRMLSMALL_SPECIFIC > 0 )) && isgrmlsmall ; then
4521
4522     unset abk[V]
4523     unalias    'V'      &> /dev/null
4524     unfunction vman     &> /dev/null
4525     unfunction vimpm    &> /dev/null
4526     unfunction vimhelp  &> /dev/null
4527     unfunction viless   &> /dev/null
4528     unfunction 2html    &> /dev/null
4529
4530     # manpages are not in grmlsmall
4531     unfunction manzsh   &> /dev/null
4532     unalias    man2     &> /dev/null
4533     unalias    man      &> /dev/null
4534     unfunction man2     &> /dev/null
4535
4536 fi
4537
4538 #}}}
4539
4540 zrclocal
4541
4542 ## genrefcard.pl settings {{{
4543
4544 ### doc strings for external functions from files
4545 #m# f5 grml-wallpaper() Sets a wallpaper (try completion for possible values)
4546
4547 ### example: split functions-search 8,16,24,32
4548 #@# split functions-search 8
4549
4550 ## }}}
4551
4552 ## END OF FILE #################################################################
4553 # vim:filetype=zsh foldmethod=marker autoindent expandtab shiftwidth=4