/usr/share/zsh/5.5.1/functions
Edit: /usr/share/zsh/5.5.1/functions/zsh-newuser-install (30047B)
# Function to install startup files for a new user.
# Currently it only creates or edits .zshrc.
#
# It can be run again by giving it the option "-f".
# Sanitize environment.
emulate -L zsh
setopt extendedglob nonomatch warncreateglobal
# How the function will be referred to.
local myname=zsh-newuser-install
# Quick test not requiring any setting up.
# Don't run if we're root. (These variables are provided by the shell.)
if (( EUID == 0 || UID == 0 )); then
if [[ $1 = -f ]]; then
print -r "$myname: won't run as root. Read the manual." >&2
fi
return 1
fi
# clear is missing in some Cygwin configurations (lacking ncurses)
if ! ( clear >/dev/null 2>/dev/null ); then
if zmodload zsh/termcap 2>/dev/null; then
clear() { echotc cl; }
else
clear() { print -n "\e[H\e[J"; }
fi
fi
# The directory in which to look for and save .zshrc.
local zd=${ZDOTDIR:-$HOME}
# The same directory in a user friendly form, i.e. with ~ replacement.
# (We don't want to use glob_subst since that has other side effects.)
local zdmsg
# The message used if an other blank .zshrc is created.
local msg="# Created by newuser for $ZSH_VERSION"
# The lines marking the start and end of the section edited.
local startline="# Lines configured by $myname"
local endline="# End of lines configured by $myname"
# Prompts used for reading a key. The initial "?" is required.
local shortprompt="?--- Type a key --- "
local longprompt="?--- Type one of the keys in parentheses --- "
# Prefix for all temporary files. Any files starting with this
# will be removed at the end of the script.
local tmpfile=${TMPPREFIX:-/tmp/zsh}-zni-$$
# Report of the state of settings for the top-level menu.
local -A install_state
# Values of all parameters etc. to be saved (including
# those read in from the existing file.)
local -A parsed_parameters parsed_options parsed_bindings parsed_keymaps
# Corresponding state in a user-readable form.
local -A state_parameters state_options state_bindings state_keymaps
# Indicate whether an option defaults on or off.
local -A default_options
# Lines read in from between $startline and $endline which were
# not understood. These are retained but moved out of that section
# with a message.
local -a unparsed
# Lines used in submenus: the setting to output in a form
# that can be exeucuted (an assignment, setopt or unsetopt), a brief message
# about the setting, and the state copied from and to state_parameters or
# state_options. Elements of all three arrays must correspond.
local -a output_lines display_lines state_lines
# Variable indicating some of the lines in the above variables
# have been read in, i.e. the user has already configured the
# particular set of settings.
integer lines_read
# Lines to set up completion. This is special as it is only
# edited by compinstall, not this function.
local -a completion_lines
# Utility variables
local -a reply match mbegin mend
# Key read from user, used all over the place.
local key
# For default replies from read
local REPLY
integer save lines_found
install_state[history]=Recommended
install_state[completion]=Recommended
install_state[bindkey]=Recommended
# Don't save anything if interrupted.
trap 'save=0' HUP INT QUIT
# Substitute an initial ~ for human consumption.
if [[ $zd = $HOME(#b)(|/*) ]]; then
zdmsg="~$match[1]"
else
zdmsg=$zd
fi
# Don't run if we can't write to $zd.
# Assume this is a temporary condition and exit silently---
# if this really is a new user this probably isn't the right
# time for screeds of explanation.
if [[ ! -w $zd ]]; then
if [[ $1 = -f ]]; then
print -r "$myname: can't write to $zdmsg." >&2
fi
return 1
fi
# Don't run unless we can talk to the user.
if [[ ! -t 0 || ! -t 1 ]]; then
if [[ $1 = -f ]]; then
print -r "$myname: can only be used interactively." >&2
fi
return 1
fi
# Don't run unless terminal is sane.
if (( ${LINES:-0} < 15 || ${COLUMNS:-0} < 72 )); then
return 1
fi
if [[ $1 != -f ]]; then
# The zsh/newuser module already tests for the following, so this test only
# triggers if zsh-newuser-install is run by hand.
if [[ -e $zd/.zshenv || -e $zd/.zprofile || \
-e $zd/.zshrc || -e $zd/.zlogin ]]; then
print -r "$myname: startup files exist, aborting.
Use the argument -f if you want to force the function to be run again." >&2
return 1
fi
fi
# start of try block for tidy-up in always block
{
########################################################################
# Utility functions
########################################################################
# All internal functions start with __zni_. These will be removed
# when the main function exits.
# Read existing lines from .zshrc, if any.
__zni_retrieve_lines() {
local line
reply=()
lines_found=0
[[ -f $zd/.zshrc ]] || return 1
grep "$startline" $zd/.zshrc 1>/dev/null 2>&1 || return 1
lines_found=1
sed -n "/^[ ]*$startline/,/^[ ]*$endline/p" $zd/.zshrc |
while read -r line; do
reply+=($line)
done
return 0
}
# First argument is a state; other arguments are lines
# to parse. They should either contain single assignments or
# setopt or unsetopt statements. The state for each parameter
# or option so parsed is set to the value given by the first argument.
__zni_parse_lines() {
local line opt warned first
local -a args
local state=$1
shift
for line in "$@"; do
case $line in
((#b)[[:blank:]]#([[:IDENT:]]##)=(*))
parsed_parameters[$match[1]]=$match[2]
state_parameters[$match[1]]=$state
;;
((#b)[[:blank:]]#(un|)setopt[[:blank:]]##(*))
# TBD: handle setopt noX / unsetopt X
for opt in ${=match[2]}; do
opt=${${opt//(#m)[[:upper:]]/${(L)MATCH}}//_}
if [[ $match[1] = un ]]; then
parsed_options[$opt]=off
else
parsed_options[$opt]=on
fi
state_options[$opt]=$state
done
;;
((#b)[[:blank:]]#bindkey[[:blank:]]##(*))
args=(${(z)match[1]})
# store keys unquoted: will need quoting for output.
first=${(Q)args[1]}
shift args
if [[ $first = -[ev] && ${#args} -eq 0 ]]; then
case $first in
(-e)
parsed_keymaps[main]=emacs
;;
(-v)
parsed_keymaps[main]=vi
;;
esac
state_keymaps[main]=$state
else
# TODO: handling keymap options
parsed_bindings[first]=${args[2,-1]}
state_bindings[first]=$state
fi
;;
([[:blank:]]#($startline|$endline|))
;;
(*)
unparsed+=($line)
print -r "WARNING: failed to understand line:
$line
which will be retained but not edited."
warned=1
;;
esac
done
if [[ -n $warned ]]; then
read -k key$shortprompt
fi
}
# Apply defaults. Arguments in the form
# -p parameter_name default_value description
# ...
# -o option_name default=on|off description
# ...
# Options on by default should begin !, e.g. !nomatch. They
# will still appear under the base option but with an indication that
# the default is on. The default applies to the base option. Hack, sorry.
# -b bindkey_string default_value description
# ...
# -B default_keymap=emacs|vi|none description
#
# They're not really defaults (they're not the same as the
# builtin defaults), so the description output is "not yet saved".
#
# All variables to be edited in this section must be mentioned,
# though defaults can be blank in which case nothing will be
# saved unless the variable is set by the user. The description
# is then "no value set".
#
# -B is a bit strange: it's simply designed to allow the user to
# select "bindkey -e" for Emacs or "bindkey -v" for vi. It only
# takes a single argument. Real key bindings use -b.
#
# This operation transfers some subset of settings from the parsed_*
# and state_* variables to the *_lines variables for editing.
__zni_apply_defaults() {
local un suf
# Reset the lines to be edited.
state_lines=()
display_lines=()
output_lines=()
lines_read=0
case $1 in
(-p)
shift
while [[ $# -gt 0 && $1 != -* ]]; do
# skip default if it was read in
if [[ -z $state_parameters[$1] ]]; then
parsed_parameters[$1]=$2
if [[ -n $2 ]]; then
state_parameters[$1]="not yet saved"
else
state_parameters[$1]="no value set"
fi
elif [[ $state_parameters[$1] = saved ]]; then
(( lines_read++ ))
fi
state_lines+=($state_parameters[$1])
display_lines+=("$3")
output_lines+=("$1=$parsed_parameters[$1]")
shift 3
done
;;
(-o)
shift
while [[ $# -gt 0 && $1 != -* ]]; do
# skip default if there was a setting
if [[ $1 != ${1##!} ]]; then
argv[1]=${1##!}
default_options[$1]=on
else
default_options[$1]=off
fi
if [[ -z $state_options[$1] ]]; then
parsed_options[$1]=$2
if [[ -n $2 ]]; then
state_options[$1]="not yet saved"
else
state_options[$1]="no value set"
fi
elif [[ $state_options[$1] = saved ]]; then
(( lines_read++ ))
fi
if [[ $parsed_options[$1] = on ]]; then
un=
suf=
elif [[ -z $parsed_options[$1] && $default_options[$1] = on ]]
then
un=
suf=", default on"
else
# display as unsetopt even if no value to save yet
un=un
suf=
fi
state_lines+=("$state_options[$1]$suf")
display_lines+=("$3")
output_lines+=("${un}setopt $1")
shift 3
done
;;
(-b)
shift
# this will barf on bindings beginning -; there's no good
# reason to rebind that, even in vi command mode, so perhaps
# we just add it to the sanity checks when we get around to them.
while [[ $# -gt 0 && $1 != -* ]]; do
if [[ -z $state_bindings[$1] ]]; then
parsed_bindings[$1]=$2
if [[ -n $2 ]]; then
state_bindings[$1]="not yet saved"
else
state_bindings[$1]="no value set"
fi
elif [[ $state_bindings[$1] = saved ]]; then
(( lines_read++ ))
fi
state_lines+=($state_bindings[$1])
display_lines+=("$3")
output_lines+=("bindkey ${(qq)1}${2:+ $2}")
shift 3
done
;;
(-B)
shift
if [[ -z $state_keymaps[main] ]]; then
parsed_keymaps[main]=$1
if [[ $1 = none ]]; then
state_keymaps[main]="no value set"
else
state_keymaps[main]="not yet saved"
fi
elif [[ $state_keymaps[main] = saved ]]; then
(( lines_read++ ))
fi
state_lines+=($state_keymaps[main])
display_lines+=("$2")
# display as -e even if no value to save yet
if [[ $parsed_keymaps[main] = vi ]]; then
output_lines+=("bindkey -v")
else
output_lines+=("bindkey -e")
fi
shift 2
;;
esac
}
# Display and edit the settings given by the set of *_lines arrays.
# If requested by the user, apply the settings, updating the
# parsed_* and state_* variables.
__zni_display_and_edit() {
integer i changes
local default edval ldisp rdisp
local -a states displays outputs tstval
states=("${state_lines[@]}")
displays=("${display_lines[@]}")
outputs=("${output_lines[@]}")
if [[ -n ${states[(r)not yet saved]} ]]; then
# default should be installed, unless user says otherwise
(( changes++ ))
fi
while true; do
clear
print -r $1
# snicker...
print -r ${(l.${#1}..=.):-}
print
if (( $# > 1 )); then
print -rl $argv[2,-1]
print
fi
# Output each setting with a description and state.
for (( i = 1; i <= ${#output_lines}; i++ )); do
default=${states[$i]%%,*}
if [[ $default = ("no value set"|"not to be saved"*) ]]; then
ldisp="# $outputs[$i]"
else
ldisp=$outputs[$i]
fi
rdisp=${default:+($default)}
print -r "# ($i) $displays[$i]
$ldisp${(l.$COLUMNS-${#ldisp}-${#rdisp}-1.):-}$rdisp"
done
if (( changes )); then
print -r "
# (0) Remember edits and return to main menu (does not save file yet)
# (q) Abandon edits and return to main menu
"
else
print -r "
# (0) or (q) Return to main menu (no changes made yet)
"
fi
read -k key$longprompt
print
if [[ $key = <-> && $key -ge 1 && $key -le ${#outputs} ]]; then
(( i = key ))
case $outputs[$i] in
((#b)(|un)setopt' '(*))
# Try to locate the appropriate section in the manual.
# I personally have no wish whatsoever to make this
# use sed or awk. Suggestions welcome.
if [[ -s $tmpfile-man-options ]]; then
perl -ne 's/^(\s*)([A-Z]+)_?([A-Z]*)_?([A-Z]*)(\s*\(.+\)|\s*\<.+\>)*\s*$/\L$1$2$3$4\n/ and "'$match[2]'" =~ /^(|no)\L$2$3$4$/ and $print = 1 and next; next unless $print; exit if /^\s*$/; print; ' <$tmpfile-man-options >$tmpfile-man 2>/dev/null
else
rm -f $tmpfile-man
fi
while true; do
clear
if [[ -s $tmpfile-man ]]; then
read <$tmpfile-man
print "Option $match[2]:"
cat $tmpfile-man
print
else
print "Option $match[2]: $displays[$i]"
fi
print "The option $match[2] is currently ${match[1]:+un}set.
Type:
(s) to set it (turn it on)
(u) to unset it (turn it off)
(n) neither to set or unset it (use shell default: \
$default_options[$match[2]])
(k) or (q) to keep the current setting:"
read -k key$shortprompt
print
case $key in
(s)
(( changes++ ))
outputs[$i]="setopt $match[2]"
states[$i]="set but not saved"
;;
(u)
(( changes++ ))
outputs[$i]="unsetopt $match[2]"
states[$i]="set but not saved"
;;
(n)
(( changes++ ))
outputs[$i]="unsetopt $match[2]"
states[$i]="no value set"
;;
([kq])
;;
(*)
continue
;;
esac
break;
done
;;
((#b)([^=]##)=(*))
if [[ -s $tmpfile-man-param ]]; then
perl -ne 's/^(\s*)([A-Z]+)(\s*\<.+\>)*\s*$/$1$2\n/ and "$2" eq "'$match[1]'" and $print = 1; next unless $print; exit if /^\s*$/; print;' <$tmpfile-man-param >$tmpfile-man 2>/dev/null
else
rm -f $tmpfile-man
fi
if [[ -s $tmpfile-man ]]; then
print -n Variable
cat $tmpfile-man
print
else
print -r "Variable ${match[1]}: $displays[$i]"
fi
print -r "Edit a value. If it is left blank, nothing will be saved:"
edval=$match[2]
if vared -M emacs -p "$match[1]> " -h edval; then
# check this assignment doesn't produce multiple words
# e.g. "HISTFILE=never rm -f ~" does produce multiple words...
# this isn't perfect, e.g. "(this would get split on assignment)",
# but that's fairly benign.
tstval=(${=edval})
if (( ${#tstval} > 1 )); then
print "Error: value isn't a single word.
Use quotes or backslashes if your value contains spaces.
Note that you shouldn't quote an initial ~ in file names." >&2
read -k key$shortprompt
# now check the assignment works...
# don't suppress any errors, they may be useful.
# this means we need to suppress warncreateglobal.
elif ! ( typeset -g $match[1]; eval "$match[1]=$edval" ); then
print "Error: bad shell syntax in value.
The value will be assigned to the variable exactly as you enter it.
Make sure all quotes are paired." >&2
read -k key$shortprompt
else
outputs[$i]="$match[1]=$edval"
if [[ -n $edval ]]; then
states[$i]="set but not saved"
else
states[$i]="no value set"
fi
(( changes++ ))
fi
else
read -k key'?--- Edit abandoned, type a key --- '
fi
;;
(bindkey' '-[ev])
while true; do
print -nr "Pick a keymap (set of keys) to use when editing.
Type:
(e) for Emacs keymap (recommended unless you are vi user)
(v) for Vi keymap
(n) not to set a keymap (allow shell to choose)
(k) to keep the current setting, "
if [[ ${state_lines[$i]%%,*} = ("no value set"|"not to be saved") ]]
then
print -r "(n):"
elif [[ $output_lines[$i] = *-v ]]; then
print -r "(v):"
else
print -r "(e):"
fi
read -k key$longprompt
case $key in
(e)
(( changes++ ))
outputs[$i]="bindkey -e"
states[$i]="set but not saved"
;;
(v)
(( changes++ ))
outputs[$i]="bindkey -v"
states[$i]="set but not saved"
;;
(n)
(( changes++ ))
outputs[$i]="bindkey -e"
states[$i]="not to be saved"
;;
(k)
;;
(*)
continue
;;
esac
break
done
;;
(bindkey' '*)
# TODO: this needs writing. We need to be able to read
# keys and translate them, sanity check them, and ideally
# handle keymaps, at least vi command and insert.
;;
(*)
print "*** Internal error: bad setting '$outputs[$i]' ***" >&2
read -k key'?--- Type a key in forlorn hope --- '
;;
esac
elif [[ $key = 0 ]]; then
# Update the *_lines variables
state_lines=("${states[@]}")
display_lines=("${displays[@]}")
output_lines=("${outputs[@]}")
# Also save any lines suitably marked to parsed_* and state_*
# by rerunning __zni_parse_lines on each such line.
for (( i = 1; i <= ${#output_lines}; i++ )); do
if [[ ${state_lines[$i]%%,*} = \
("set but not saved"|"not to be saved"|"not yet saved") ]]
then
__zni_parse_lines ${state_lines[$i]%%,*} $output_lines[$i]
fi
done
return $(( changes == 0 ))
elif [[ $key = [qQ] ]]; then
return 1
fi
done
}
# Print and despatch a submenu.
# The first argument is the title. The remaining arguments
# are pairs of descriptions and functions to execute.
# There shouldn't be more than 9 entries.
# The usual entries 0 and q are added automatically.
__zni_submenu() {
local title=$1
local desc func
local -a descs funcs
integer i
shift
clear
print -r $title
print -r ${(l.${#title}..=.):-}
for desc func; do
if [[ -z $func ]]; then
print "*** Internal error: bad argument set for __zni_submenu ***" >&2
read -k key'?--- Type a key in forlorn hope --- '
return 1
fi
descs+=($desc)
funcs+=($func)
done
while true; do
for (( i = 1; i <= ${#descs}; i++ )); do
print -r "
($i) $descs[$i]"
done
print -r "
(0) or (q) Return to previous menu"
read -k key$longprompt
if [[ $key = [0qQ] ]]; then
return 1
elif (( key >= 1 && key <= ${#funcs} )); then
$funcs[$key]
fi
done
}
# Save all values that have been edited to .zshrc.
__zni_save() {
local key optline newline
local -a on_opts off_opts lines lines2
integer i
# Record lines containing parameter settings, sorted.
for key in ${(ok)parsed_parameters}; do
if [[ $state_parameters[$key] != ("no value set"|"not to be saved") ]]
then
lines+=("$key=$parsed_parameters[$key]")
fi
done
# Search through sorted options, make list of those to
# be turned on and off. Those marked "no value set" aren't
# to be output.
for key in ${(ok)parsed_options}; do
if [[ $state_options[$key] != ("no value set"|"not to be saved") ]]; then
if [[ $parsed_options[$key] = on ]]; then
on_opts+=($key)
else
off_opts+=($key)
fi
fi
done
# Construct lines of options to turn on, keeping them short.
optline="setopt"
for (( i = 1; i <= ${#on_opts}; i++ )); do
newline="$optline $on_opts[$i]"
if [[ ${#newline} -ge 72 ]]; then
lines+=($optline)
optline="setopt $on_opts[$i]"
else
optline=$newline
fi
if (( i == ${#on_opts} )); then
lines+=($optline)
fi
done
# Construct lines of options to turn off, keeping them short.
optline="unsetopt"
for (( i = 1; i <= ${#off_opts}; i++ )); do
newline="$optline $off_opts[$i]"
if [[ ${#newline} -ge 72 ]]; then
lines+=($optline)
optline="unsetopt $off_opts[$i]"
else
optline=$newline
fi
if (( i == ${#off_opts} )); then
lines+=($optline)
fi
done
# Construct lines of bindkey commands. First the keymap.
if [[ $state_keymaps[main] != (|"no value set"|"not to be saved") ]]; then
case $parsed_keymaps[main] in
(emacs)
lines+=("bindkey -e")
;;
(vi)
lines+=("bindkey -v")
;;
(none)
;;
(*)
print -r "\
*** Internal error: bad type $parsed_keymaps[main] for keymap ***" >&2
read -k key'?--- Type a key in forlorn hope --- '
;;
esac
fi
# Now bindings.
for key in ${(ok)parsed_bindings}; do
if [[ $state_bindings[$key] != ("no value set"|"not to be saved") ]]; then
lines+=("bindkey ${(qq)key} ${parsed_bindings[$key]}")
fi
done
# Save the lines with a start and end marker to a temporary file.
print -rl $startline $lines $endline >$tmpfile
if (( ${#unparsed} )); then
print "# The following lines were read by $myname.
# They were moved here as they could not be understood.
# $(date)
${(F)unparsed}
# End of lines moved by $myname." >>$tmpfile
fi
if grep "$startline" $zd/.zshrc 1>/dev/null 2>&1; then
# Found the start line; replace the section.
# We could this by reading the lines in zsh, but in case
# the .zshrc is huge it's perhaps better to use sed.
sed -e "/^[ ]*$endline/r $tmpfile
/^[ ]*$startline/,/^[ ]*$endline/d" $zd/.zshrc >${tmpfile}.repl &&
cp ${tmpfile}.repl $zd/.zshrc
else
# No current start marker; just append.
cat $tmpfile >>$zd/.zshrc
fi
}
########################################################################
# Specific configurations
########################################################################
__zni_history_config() {
__zni_apply_defaults -p \
HISTSIZE 1000 "Number of lines of history kept within the shell." \
HISTFILE $zdmsg/.histfile "File where history is saved." \
SAVEHIST 1000 "Number of lines of history to save to \$HISTFILE."
if __zni_display_and_edit "History configuration"; then
install_state[history]="Unsaved changes"
save=1
fi
}
__zni_completion_config() {
autoload -Uz compinstall
if compinstall -d; then
print "The completion system has already been activated.
You can run the configuration tool (compinstall) at any time by typing
autoload -Uz compinstall
compinstall
Do you wish to run it now [y/n]?"
read -k key$shortprompt
if [[ $key = [yY] ]]; then
compinstall
fi
print
else
while true; do
clear
print "The new completion system (compsys) allows you to complete
commands, arguments and special shell syntax such as variables. It provides
completions for a wide range of commonly used commands in most cases simply
by typing the TAB key. Documentation is in the zshcompsys manual page.
If it is not turned on, only a few simple completions such as filenames
are available but the time to start the shell is slightly shorter.
You can:
(1) Turn on completion with the default options.
(2) Run the configuration tool (compinstall). You can also run
this from the command line with the following commands:
autoload -Uz compinstall
compinstall
if you don't want to configure completion now.
(0) Don't turn on completion.
"
read -k key$longprompt
case $key in
(1)
completion_lines=${(f)"$(compinstall -o)"}
install_state[completion]="Unsaved changes"
save=1
;;
(2)
if compinstall; then
install_state[completion]="Configured"
# compinstall has done it's thing, so we don't need
# to write anything.
completion_lines=()
fi
;;
(0)
completion_lines=()
install_state[completion]="Recommended"
;;
(*)
continue
;;
esac
break
done
fi
}
__zni_bindkey_config() {
__zni_apply_defaults -B emacs "Change default editing configuration"
if __zni_display_and_edit "Default editing configuration" \
"The keys in the shell's line editor can be made to behave either" \
"like Emacs or like Vi, two common Unix editors. If you have no" \
"experience of either, Emacs is recommended. If you don't pick one," \
"the shell will try to guess based on the EDITOR environment variable." \
"Usually it's better to pick one explicitly."; then
install_state[bindkey]="Unsaved changes"
save=1
fi
}
__zni_completion_save() {
if (( ${#completion_lines} )); then
# We don't try to replace existing lines of completion configuration ---
# that's up to compinstall. We should already have tested that
# there was no existing completion set up.
print -rl $completion_lines >>$zd/.zshrc
fi
}
__zni_options_config() {
# when we have enough, should use:
# __zni_submenu "Common shell options"
# This is deliberately just a tiny selection.
# Feel free to extend it, but if you do, consider using __zni_submenu.
# The "no" prefix is used to indicate options on by default.
__zni_apply_defaults -o autocd '' "Change directory given just path." \
extendedglob '' "Use additional pattern matching features." \
appendhistory '' "Append new history lines instead of overwriting." \
'!nomatch' '' "Unmatched patterns cause an error." \
'!beep' '' "Beep on errors." \
notify '' "Immediately report changes in background job status."
if __zni_display_and_edit "Common shell options" \
"The following are some of the shell options that are most often used." \
"The descriptions are very brief; if you would like more information," \
"read the zshoptions manual page (type \"man zshoptions\")."; then
install_state[options]="Unsaved changes"
save=1
fi
}
########################################################################
# Main function
########################################################################
# Read and parse any existing lines, in case the function
# was called again.
__zni_retrieve_lines &&
__zni_parse_lines saved "$reply[@]"
if [[ $state_parameters[HISTORY] = saved ]]; then
install_state[history]="Saved"
fi
autoload -Uz compinstall
zstyle :compinstall filename $zd/.zshrc
if compinstall -d; then
install_state[completion]="Saved"
fi
# skip initial screen if the function was deliberately run by the user.
if [[ $1 != -f ]]; then
clear
print -r "This is the Z Shell configuration function for new users,
$myname.
You are seeing this message because you have no zsh startup files
(the files .zshenv, .zprofile, .zshrc, .zlogin in the directory
$zdmsg). This function can help you with a few settings that should
make your use of the shell easier.
You can:
(q) Quit and do nothing. The function will be run again next time."
if [[ ! -f $zd/.zshrc ]]; then
print -r "
(0) Exit, creating the file $zdmsg/.zshrc containing just a comment.
That will prevent this function being run again."
fi
print -r "
(1) Continue to the main menu.
"
if [[ -f /etc/zsh/newuser.zshrc.recommended ]]; then
print -r "(2) Populate your $zdmsg/.zshrc with the configuration recommended
by the system administrator and exit (you will need to edit
the file by hand, if so desired).
"
fi
read -k key$longprompt
print
case $key in
([qQ])
return 0
;;
(0)
print -r $msg >$zd/.zshrc
return 0
;;
(1)
;;
(2)
cp /etc/zsh/newuser.zshrc.recommended $zd/.zshrc
source $zd/.zshrc
return 0
;;
(*)
print -r "Aborting."
if [[ $1 != -f ]]; then
print "\
The function will be run again next time. To prevent this, execute:
touch $zdmsg/.zshrc"
fi
return 1
;;
esac
fi
print -r "Attempting to extract information from manual pages..."
(man zshoptions | col -b > $tmpfile-man-options;
man zshparam | col -b > $tmpfile-man-param) 2>/dev/null
while true; do
clear
print -nr "Please pick one of the following options:
(1) Configure settings for history, i.e. command lines remembered
and saved by the shell.\
${install_state[history]:+ ($install_state[history].)}
(2) "
if [[ $install_state[completion] = Recommended ]]; then
print -nr "Configure"
else
print -nr "Use"
fi
print -r " the new completion system.\
${install_state[completion]:+ ($install_state[completion].)}
(3) Configure how keys behave when editing command lines.\
${install_state[bindkey]:+ ($install_state[bindkey].)}
(4) Pick some of the more common shell options. These are simple \"on\"
or \"off\" switches controlling the shell's features. \
${install_state[options]:+ ($install_state[options].)}
"
print -nr "(0) Exit, "
if (( save )); then
print -r "saving the new settings. They will take effect immediately."
elif [[ -f $zd/.zshrc ]]; then
print -r "leaving the existing $zdmsg/.zshrc alone."
else
print -r "creating a blank $zdmsg/.zshrc file."
fi
print -r "
(a) Abort all settings and start from scratch. Note this will overwrite
any settings from $myname already in the startup file.
It will not alter any of your other settings, however."
if [[ $1 = -f ]]; then
print -r "
(q) Quit and do nothing else."
else
print -r "
(q) Quit and do nothing else. The function will be run again next time."
fi
read -k key$longprompt
print
case $key in
([qQ])
break
;;
([aA])
parsed_parameters=()
state_parameters=()
parsed_options=()
state_options=()
parsed_keymaps=()
state_keymaps=()
parsed_bindings=()
state_bindings=()
unparsed=()
;;
(0)
clear
if (( save )); then
if [[ -f $zd/.zshrc ]]; then
cp $zd/.zshrc $zd/.zshrc.zni &&
print -r "Copied old '$zdmsg/.zshrc' to '$zdmsg/.zshrc.zni'.
"
fi
__zni_save
__zni_completion_save
elif [[ ! -f $zd/.zshrc ]]; then
print -r $msg >$zd/.zshrc
fi
if [[ $1 != -f ]]; then
print -r "The function will not be run in future, but you can run
it yourself as follows:
autoload -Uz $myname
$myname -f
The code added to $zdmsg/.zshrc is marked by the lines
$startline
$endline
You should not edit anything between these lines if you intend to
run $myname again. You may, however, edit any other part
of the file."
fi
break
;;
(1)
__zni_history_config
;;
(2)
__zni_completion_config
;;
(3)
__zni_bindkey_config
;;
(4)
__zni_options_config
;;
esac
done
} always {
# Tidy up: always executed unless the shell is stopped dead
# in its tracks.
unfunction -m $myname __zni_\*
rm -f $tmpfile*
}