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