aboutsummaryrefslogtreecommitdiff
path: root/base/zsh
diff options
context:
space:
mode:
authorAdam Hovorka <[email protected]>2017-09-04 13:42:23 -0600
committerAdam Hovorka <[email protected]>2017-09-04 13:42:23 -0600
commit8ae9c465242c5e379877a15832043113021d714e (patch)
treee7d1eabb895ee5dc954dc88ca3d6896b0c8ffadc /base/zsh
parent8916659e0e1cb67b860373f2d094445bb1f657aa (diff)
Switch from stowsh to dotbot
Diffstat (limited to 'base/zsh')
-rw-r--r--base/zsh/aliases.zsh31
-rw-r--r--base/zsh/async493
-rw-r--r--base/zsh/colors.zsh3
-rw-r--r--base/zsh/completion.zsh81
-rw-r--r--base/zsh/correction.zsh7
-rw-r--r--base/zsh/fancy-man.zsh32
-rw-r--r--base/zsh/fasd.zsh3
-rw-r--r--base/zsh/fast-syntax-highlighting/fast-highlight715
-rw-r--r--base/zsh/fast-syntax-highlighting/fast-syntax-highlighting.plugin.zsh272
-rw-r--r--base/zsh/functions.zsh18
-rw-r--r--base/zsh/history.zsh15
-rw-r--r--base/zsh/k.zsh540
-rw-r--r--base/zsh/prompt.zsh6
-rw-r--r--base/zsh/prompt_pure_setup385
-rw-r--r--base/zsh/stack.zsh3
-rw-r--r--base/zsh/tipz.zsh84
16 files changed, 2688 insertions, 0 deletions
diff --git a/base/zsh/aliases.zsh b/base/zsh/aliases.zsh
new file mode 100644
index 0000000..21544af
--- /dev/null
+++ b/base/zsh/aliases.zsh
@@ -0,0 +1,31 @@
+# UTILITY
+
+alias ls="ls --color=auto"
+alias less='less -R'
+alias grep='grep --color=auto'
+alias ..='cd ../'
+
+alias sudoe="sudo -E"
+alias svim="sudo -E vim"
+alias svimdiff="sudo -E vimdiff"
+
+# SAFETY
+
+alias cp="cp -i"
+alias mv="mv -i"
+
+# GIT
+
+alias gd='git diff'
+alias gco='git checkout'
+alias gs='git status --short'
+alias gl='git pull'
+alias gp='git push'
+alias gpp='git pull; git push'
+alias gwc='git whatchanged -p --abbrev-commit --pretty=medium'
+
+# POWER
+
+alias reboot="systemctl reboot"
+alias shutdown="systemctl poweroff"
+alias poweroff="systemctl poweroff"
diff --git a/base/zsh/async b/base/zsh/async
new file mode 100644
index 0000000..d11a99a
--- /dev/null
+++ b/base/zsh/async
@@ -0,0 +1,493 @@
+#!/usr/bin/env zsh
+
+#
+# zsh-async
+#
+# version: 1.5.0
+# author: Mathias Fredriksson
+# url: https://github.com/mafredri/zsh-async
+#
+
+# Produce debug output from zsh-async when set to 1.
+ASYNC_DEBUG=${ASYNC_DEBUG:-0}
+
+# Wrapper for jobs executed by the async worker, gives output in parseable format with execution time
+_async_job() {
+ # Disable xtrace as it would mangle the output.
+ setopt localoptions noxtrace
+
+ # Store start time as double precision (+E disables scientific notation)
+ float -F duration=$EPOCHREALTIME
+
+ # Run the command and capture both stdout (`eval`) and stderr (`cat`) in
+ # separate subshells. When the command is complete, we grab write lock
+ # (mutex token) and output everything except stderr inside the command
+ # block, after the command block has completed, the stdin for `cat` is
+ # closed, causing stderr to be appended with a $'\0' at the end to mark the
+ # end of output from this job.
+ local stdout stderr ret tok
+ {
+ stdout=$(eval "$@")
+ ret=$?
+ duration=$(( EPOCHREALTIME - duration )) # Calculate duration.
+
+ # Grab mutex lock, stalls until token is available.
+ read -r -k 1 -p tok || exit 1
+
+ # Return output (<job_name> <return_code> <stdout> <duration> <stderr>).
+ print -r -n - ${(q)1} $ret ${(q)stdout} $duration
+ } 2> >(stderr=$(cat) && print -r -n - " "${(q)stderr}$'\0')
+
+ # Unlock mutex by inserting a token.
+ print -n -p $tok
+}
+
+# The background worker manages all tasks and runs them without interfering with other processes
+_async_worker() {
+ # Reset all options to defaults inside async worker.
+ emulate -R zsh
+
+ # Make sure monitor is unset to avoid printing the
+ # pids of child processes.
+ unsetopt monitor
+
+ # Redirect stderr to `/dev/null` in case unforseen errors produced by the
+ # worker. For example: `fork failed: resource temporarily unavailable`.
+ # Some older versions of zsh might also print malloc errors (know to happen
+ # on at least zsh 5.0.2 and 5.0.8) likely due to kill signals.
+ exec 2>/dev/null
+
+ # When a zpty is deleted (using -d) all the zpty instances created before
+ # the one being deleted receive a SIGHUP, unless we catch it, the async
+ # worker would simply exit (stop working) even though visible in the list
+ # of zpty's (zpty -L).
+ TRAPHUP() {
+ return 0 # Return 0, indicating signal was handled.
+ }
+
+ local -A storage
+ local unique=0
+ local notify_parent=0
+ local parent_pid=0
+ local coproc_pid=0
+ local processing=0
+
+ local -a zsh_hooks zsh_hook_functions
+ zsh_hooks=(chpwd periodic precmd preexec zshexit zshaddhistory)
+ zsh_hook_functions=(${^zsh_hooks}_functions)
+ unfunction $zsh_hooks &>/dev/null # Deactivate all zsh hooks inside the worker.
+ unset $zsh_hook_functions # And hooks with registered functions.
+ unset zsh_hooks zsh_hook_functions # Cleanup.
+
+ child_exit() {
+ local -a pids
+ pids=(${${(v)jobstates##*:*:}%\=*})
+
+ # If coproc (cat) is the only child running, we close it to avoid
+ # leaving it running indefinitely and cluttering the process tree.
+ if (( ! processing )) && [[ $#pids = 1 ]] && [[ $coproc_pid = $pids[1] ]]; then
+ coproc :
+ coproc_pid=0
+ fi
+
+ # On older version of zsh (pre 5.2) we notify the parent through a
+ # SIGWINCH signal because `zpty` did not return a file descriptor (fd)
+ # prior to that.
+ if (( notify_parent )); then
+ # We use SIGWINCH for compatibility with older versions of zsh
+ # (pre 5.1.1) where other signals (INFO, ALRM, USR1, etc.) could
+ # cause a deadlock in the shell under certain circumstances.
+ kill -WINCH $parent_pid
+ fi
+ }
+
+ # Register a SIGCHLD trap to handle the completion of child processes.
+ trap child_exit CHLD
+
+ # Process option parameters passed to worker
+ while getopts "np:u" opt; do
+ case $opt in
+ n) notify_parent=1;;
+ p) parent_pid=$OPTARG;;
+ u) unique=1;;
+ esac
+ done
+
+ killjobs() {
+ local tok
+ local -a pids
+ pids=(${${(v)jobstates##*:*:}%\=*})
+
+ # No need to send SIGHUP if no jobs are running.
+ (( $#pids == 0 )) && continue
+ (( $#pids == 1 )) && [[ $coproc_pid = $pids[1] ]] && continue
+
+ # Grab lock to prevent half-written output in case a child
+ # process is in the middle of writing to stdin during kill.
+ (( coproc_pid )) && read -r -k 1 -p tok
+
+ kill -HUP -$$ # Send to entire process group.
+ coproc : # Quit coproc.
+ coproc_pid=0 # Reset pid.
+ }
+
+ local request
+ local -a cmd
+ while :; do
+ # Wait for jobs sent by async_job.
+ read -r -d $'\0' request || {
+ # Since we handle SIGHUP above (and thus do not know when `zpty -d`)
+ # occurs, a failure to read probably indicates that stdin has
+ # closed. This is why we propagate the signal to all children and
+ # exit manually.
+ kill -HUP -$$ # Send SIGHUP to all jobs.
+ exit 0
+ }
+
+ # Check for non-job commands sent to worker
+ case $request in
+ _unset_trap) notify_parent=0; continue;;
+ _killjobs) killjobs; continue;;
+ esac
+
+ # Parse the request using shell parsing (z) to allow commands
+ # to be parsed from single strings and multi-args alike.
+ cmd=("${(z)request}")
+
+ # Name of the job (first argument).
+ local job=$cmd[1]
+
+ # If worker should perform unique jobs
+ if (( unique )); then
+ # Check if a previous job is still running, if yes, let it finnish
+ for pid in ${${(v)jobstates##*:*:}%\=*}; do
+ if [[ ${storage[$job]} == $pid ]]; then
+ continue 2
+ fi
+ done
+ fi
+
+ # Guard against closing coproc from trap before command has started.
+ processing=1
+
+ # Because we close the coproc after the last job has completed, we must
+ # recreate it when there are no other jobs running.
+ if (( ! coproc_pid )); then
+ # Use coproc as a mutex for synchronized output between children.
+ coproc cat
+ coproc_pid="$!"
+ # Insert token into coproc
+ print -n -p "t"
+ fi
+
+ # Run job in background, completed jobs are printed to stdout.
+ _async_job $cmd &
+ # Store pid because zsh job manager is extremely unflexible (show jobname as non-unique '$job')...
+ storage[$job]="$!"
+
+ processing=0 # Disable guard.
+ done
+}
+
+#
+# Get results from finnished jobs and pass it to the to callback function. This is the only way to reliably return the
+# job name, return code, output and execution time and with minimal effort.
+#
+# usage:
+# async_process_results <worker_name> <callback_function>
+#
+# callback_function is called with the following parameters:
+# $1 = job name, e.g. the function passed to async_job
+# $2 = return code
+# $3 = resulting stdout from execution
+# $4 = execution time, floating point e.g. 2.05 seconds
+# $5 = resulting stderr from execution
+#
+async_process_results() {
+ setopt localoptions noshwordsplit
+
+ local worker=$1
+ local callback=$2
+ local caller=$3
+ local -a items
+ local null=$'\0' data
+ integer -l len pos num_processed
+
+ typeset -gA ASYNC_PROCESS_BUFFER
+
+ # Read output from zpty and parse it if available.
+ while zpty -r -t $worker data 2>/dev/null; do
+ ASYNC_PROCESS_BUFFER[$worker]+=$data
+ len=${#ASYNC_PROCESS_BUFFER[$worker]}
+ pos=${ASYNC_PROCESS_BUFFER[$worker][(i)$null]} # Get index of NULL-character (delimiter).
+
+ # Keep going until we find a NULL-character.
+ if (( ! len )) || (( pos > len )); then
+ continue
+ fi
+
+ while (( pos <= len )); do
+ # Take the content from the beginning, until the NULL-character and
+ # perform shell parsing (z) and unquoting (Q) as an array (@).
+ items=("${(@Q)${(z)ASYNC_PROCESS_BUFFER[$worker][1,$pos-1]}}")
+
+ # Remove the extracted items from the buffer.
+ ASYNC_PROCESS_BUFFER[$worker]=${ASYNC_PROCESS_BUFFER[$worker][$pos+1,$len]}
+
+ if (( $#items == 5 )); then
+ $callback "${(@)items}" # Send all parsed items to the callback.
+ else
+ # In case of corrupt data, invoke callback with *async* as job
+ # name, non-zero exit status and an error message on stderr.
+ $callback "async" 1 "" 0 "$0:$LINENO: error: bad format, got ${#items} items (${(@q)items})"
+ fi
+
+ (( num_processed++ ))
+
+ len=${#ASYNC_PROCESS_BUFFER[$worker]}
+ if (( len > 1 )); then
+ pos=${ASYNC_PROCESS_BUFFER[$worker][(i)$null]} # Get index of NULL-character (delimiter).
+ fi
+ done
+ done
+
+ (( num_processed )) && return 0
+
+ # Avoid printing exit value when `setopt printexitvalue` is active.`
+ [[ $caller = trap || $caller = watcher ]] && return 0
+
+ # No results were processed
+ return 1
+}
+
+# Watch worker for output
+_async_zle_watcher() {
+ setopt localoptions noshwordsplit
+ typeset -gA ASYNC_PTYS ASYNC_CALLBACKS
+ local worker=$ASYNC_PTYS[$1]
+ local callback=$ASYNC_CALLBACKS[$worker]
+
+ if [[ -n $callback ]]; then
+ async_process_results $worker $callback watcher
+ fi
+}
+
+#
+# Start a new asynchronous job on specified worker, assumes the worker is running.
+#
+# usage:
+# async_job <worker_name> <my_function> [<function_params>]
+#
+async_job() {
+ setopt localoptions noshwordsplit
+
+ local worker=$1; shift
+
+ local -a cmd
+ cmd=("$@")
+ if (( $#cmd > 1 )); then
+ cmd=(${(q)cmd}) # Quote special characters in multi argument commands.
+ fi
+
+ zpty -w $worker $cmd$'\0'
+}
+
+# This function traps notification signals and calls all registered callbacks
+_async_notify_trap() {
+ setopt localoptions noshwordsplit
+
+ for k in ${(k)ASYNC_CALLBACKS}; do
+ async_process_results $k ${ASYNC_CALLBACKS[$k]} trap
+ done
+}
+
+#
+# Register a callback for completed jobs. As soon as a job is finnished, async_process_results will be called with the
+# specified callback function. This requires that a worker is initialized with the -n (notify) option.
+#
+# usage:
+# async_register_callback <worker_name> <callback_function>
+#
+async_register_callback() {
+ setopt localoptions noshwordsplit nolocaltraps
+
+ typeset -gA ASYNC_CALLBACKS
+ local worker=$1; shift
+
+ ASYNC_CALLBACKS[$worker]="$*"
+
+ # Enable trap when the ZLE watcher is unavailable, allows
+ # workers to notify (via -n) when a job is done.
+ if [[ ! -o interactive ]] || [[ ! -o zle ]]; then
+ trap '_async_notify_trap' WINCH
+ fi
+}
+
+#
+# Unregister the callback for a specific worker.
+#
+# usage:
+# async_unregister_callback <worker_name>
+#
+async_unregister_callback() {
+ typeset -gA ASYNC_CALLBACKS
+
+ unset "ASYNC_CALLBACKS[$1]"
+}
+
+#
+# Flush all current jobs running on a worker. This will terminate any and all running processes under the worker, use
+# with caution.
+#
+# usage:
+# async_flush_jobs <worker_name>
+#
+async_flush_jobs() {
+ setopt localoptions noshwordsplit
+
+ local worker=$1; shift
+
+ # Check if the worker exists
+ zpty -t $worker &>/dev/null || return 1
+
+ # Send kill command to worker
+ async_job $worker "_killjobs"
+
+ # Clear the zpty buffer.
+ local junk
+ if zpty -r -t $worker junk '*'; then
+ (( ASYNC_DEBUG )) && print -n "async_flush_jobs $worker: ${(V)junk}"
+ while zpty -r -t $worker junk '*'; do
+ (( ASYNC_DEBUG )) && print -n "${(V)junk}"
+ done
+ (( ASYNC_DEBUG )) && print
+ fi
+
+ # Finally, clear the process buffer in case of partially parsed responses.
+ typeset -gA ASYNC_PROCESS_BUFFER
+ unset "ASYNC_PROCESS_BUFFER[$worker]"
+}
+
+#
+# Start a new async worker with optional parameters, a worker can be told to only run unique tasks and to notify a
+# process when tasks are complete.
+#
+# usage:
+# async_start_worker <worker_name> [-u] [-n] [-p <pid>]
+#
+# opts:
+# -u unique (only unique job names can run)
+# -n notify through SIGWINCH signal
+# -p pid to notify (defaults to current pid)
+#
+async_start_worker() {
+ setopt localoptions noshwordsplit
+
+ local worker=$1; shift
+ zpty -t $worker &>/dev/null && return
+
+ typeset -gA ASYNC_PTYS
+ typeset -h REPLY
+ typeset has_xtrace=0
+
+ # Make sure async worker is started without xtrace
+ # (the trace output interferes with the worker).
+ [[ -o xtrace ]] && {
+ has_xtrace=1
+ unsetopt xtrace
+ }
+
+ if (( ! ASYNC_ZPTY_RETURNS_FD )) && [[ -o interactive ]] && [[ -o zle ]]; then
+ # When zpty doesn't return a file descriptor (on older versions of zsh)
+ # we try to guess it anyway.
+ integer -l zptyfd
+ exec {zptyfd}>&1 # Open a new file descriptor (above 10).
+ exec {zptyfd}>&- # Close it so it's free to be used by zpty.
+ fi
+
+ zpty -b $worker _async_worker -p $$ $@ || {
+ async_stop_worker $worker
+ return 1
+ }
+
+ # Re-enable it if it was enabled, for debugging.
+ (( has_xtrace )) && setopt xtrace
+
+ if [[ $ZSH_VERSION < 5.0.8 ]]; then
+ # For ZSH versions older than 5.0.8 we delay a bit to give
+ # time for the worker to start before issuing commands,
+ # otherwise it will not be ready to receive them.
+ sleep 0.001
+ fi
+
+ if [[ -o interactive ]] && [[ -o zle ]]; then
+ if (( ! ASYNC_ZPTY_RETURNS_FD )); then
+ REPLY=$zptyfd # Use the guessed value for the file desciptor.
+ fi
+
+ ASYNC_PTYS[$REPLY]=$worker # Map the file desciptor to the worker.
+ zle -F $REPLY _async_zle_watcher # Register the ZLE handler.
+
+ # Disable trap in favor of ZLE handler when notify is enabled (-n).
+ async_job $worker _unset_trap
+ fi
+}
+
+#
+# Stop one or multiple workers that are running, all unfetched and incomplete work will be lost.
+#
+# usage:
+# async_stop_worker <worker_name_1> [<worker_name_2>]
+#
+async_stop_worker() {
+ setopt localoptions noshwordsplit
+
+ local ret=0
+ for worker in $@; do
+ # Find and unregister the zle handler for the worker
+ for k v in ${(@kv)ASYNC_PTYS}; do
+ if [[ $v == $worker ]]; then
+ zle -F $k
+ unset "ASYNC_PTYS[$k]"
+ fi
+ done
+ async_unregister_callback $worker
+ zpty -d $worker 2>/dev/null || ret=$?
+
+ # Clear any partial buffers.
+ typeset -gA ASYNC_PROCESS_BUFFER
+ unset "ASYNC_PROCESS_BUFFER[$worker]"
+ done
+
+ return $ret
+}
+
+#
+# Initialize the required modules for zsh-async. To be called before using the zsh-async library.
+#
+# usage:
+# async_init
+#
+async_init() {
+ (( ASYNC_INIT_DONE )) && return
+ ASYNC_INIT_DONE=1
+
+ zmodload zsh/zpty
+ zmodload zsh/datetime
+
+ # Check if zsh/zpty returns a file descriptor or not,
+ # shell must also be interactive with zle enabled.
+ ASYNC_ZPTY_RETURNS_FD=0
+ [[ -o interactive ]] && [[ -o zle ]] && {
+ typeset -h REPLY
+ zpty _async_test :
+ (( REPLY )) && ASYNC_ZPTY_RETURNS_FD=1
+ zpty -d _async_test
+ }
+}
+
+async() {
+ async_init
+}
+
+async "$@"
diff --git a/base/zsh/colors.zsh b/base/zsh/colors.zsh
new file mode 100644
index 0000000..9c8e32b
--- /dev/null
+++ b/base/zsh/colors.zsh
@@ -0,0 +1,3 @@
+export CLICOLOR=1
+
+source `dirname $0`/fast-syntax-highlighting/fast-syntax-highlighting.plugin.zsh
diff --git a/base/zsh/completion.zsh b/base/zsh/completion.zsh
new file mode 100644
index 0000000..f9e452d
--- /dev/null
+++ b/base/zsh/completion.zsh
@@ -0,0 +1,81 @@
+autoload -U compinit
+compinit
+
+setopt extendedglob
+setopt NO_NOMATCH
+
+unsetopt menu_complete # do not autoselect the first completion entry
+unsetopt flowcontrol
+setopt auto_menu # show completion menu on succesive tab press
+setopt complete_in_word
+setopt always_to_end
+
+WORDCHARS=''
+
+zmodload -i zsh/complist
+
+## case-insensitive (all),partial-word and then substring completion
+if [ "x$CASE_SENSITIVE" = "xtrue" ]; then
+ zstyle ':completion:*' matcher-list 'r:|[._-]=* r:|=*' 'l:|=* r:|=*'
+ unset CASE_SENSITIVE
+else
+ zstyle ':completion:*' matcher-list 'm:{a-zA-Z}={A-Za-z}' 'r:|[._-]=* r:|=*' 'l:|=* r:|=*'
+fi
+
+zstyle ':completion:*' list-colors ''
+
+# should this be in keybindings?
+bindkey -M menuselect '^o' accept-and-infer-next-history
+
+zstyle ':completion:*:*:*:*:*' menu select
+zstyle ':completion:*:*:kill:*:processes' list-colors '=(#b) #([0-9]#) ([0-9a-z-]#)*=01;34=0=01'
+zstyle ':completion:*:*:*:*:processes' command "ps -u `whoami` -o pid,user,comm -w -w"
+
+# disable named-directories autocompletion
+zstyle ':completion:*:cd:*' tag-order local-directories directory-stack path-directories
+cdpath=(.)
+
+# use /etc/hosts and known_hosts for hostname completion
+[ -r /etc/ssh/ssh_known_hosts ] && _global_ssh_hosts=(${${${${(f)"$(</etc/ssh/ssh_known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _global_ssh_hosts=()
+[ -r ~/.ssh/known_hosts ] && _ssh_hosts=(${${${${(f)"$(<$HOME/.ssh/known_hosts)"}:#[\|]*}%%\ *}%%,*}) || _ssh_hosts=()
+[ -r ~/.ssh/config ] && _ssh_config=($(cat ~/.ssh/config | sed -ne 's/Host[=\t ]//p')) || _ssh_config=()
+[ -r /etc/hosts ] && : ${(A)_etc_hosts:=${(s: :)${(ps:\t:)${${(f)~~"$(</etc/hosts)"}%%\#*}##[:blank:]#[^[:blank:]]#}}} || _etc_hosts=()
+hosts=(
+ "$_ssh_config[@]"
+ "$_global_ssh_hosts[@]"
+ "$_ssh_hosts[@]"
+ "$_etc_hosts[@]"
+ "$HOST"
+ localhost
+)
+zstyle ':completion:*:hosts' hosts $hosts
+zstyle ':completion:*' users off
+
+# Use caching so that commands like apt and dpkg complete are useable
+zstyle ':completion::complete:*' use-cache 1
+zstyle ':completion::complete:*' cache-path $ZSH/cache/
+# Don't complete uninteresting users
+zstyle ':completion:*:*:*:users' ignored-patterns \
+ adm amanda apache avahi beaglidx bin cacti canna clamav daemon \
+ dbus distcache dovecot fax ftp games gdm gkrellmd gopher \
+ hacluster haldaemon halt hsqldb ident junkbust ldap lp mail \
+ mailman mailnull mldonkey mysql nagios \
+ named netdump news nfsnobody nobody nscd ntp nut nx openvpn \
+ operator pcap postfix postgres privoxy pulse pvm quagga radvd \
+ rpc rpcuser rpm shutdown squid sshd sync uucp vcsa xfs
+
+# ... unless we really want to.
+zstyle '*' single-ignored show
+
+if [ "x$COMPLETION_WAITING_DOTS" = "xtrue" ]; then
+ expand-or-complete-with-dots() {
+ echo -n "\e[31m......\e[0m"
+ zle expand-or-complete
+ zle redisplay
+ }
+ zle -N expand-or-complete-with-dots
+ bindkey "^I" expand-or-complete-with-dots
+fi
+
+zstyle -e ':completion:*:(ssh|scp|sftp|rsh|rsync):hosts' hosts 'reply=(${=${${(f)"$(cat {/etc/ssh_,~/.ssh/known_}hosts(|2)(N) /dev/null)"}%%[# ]*}//,/ })'
+
diff --git a/base/zsh/correction.zsh b/base/zsh/correction.zsh
new file mode 100644
index 0000000..ce25627
--- /dev/null
+++ b/base/zsh/correction.zsh
@@ -0,0 +1,7 @@
+setopt correct_all
+alias man='nocorrect man'
+alias mv='nocorrect mv'
+alias mkdir='nocorrect mkdir'
+alias gist='nocorrect gist'
+alias sudo='nocorrect sudo'
+alias npm='nocorrect npm'
diff --git a/base/zsh/fancy-man.zsh b/base/zsh/fancy-man.zsh
new file mode 100644
index 0000000..05843dc
--- /dev/null
+++ b/base/zsh/fancy-man.zsh
@@ -0,0 +1,32 @@
+if [[ "$OSTYPE" = solaris* ]]
+then
+ if [[ ! -x "$HOME/.bin/nroff" ]]
+ then
+ mkdir -p "$HOME/.bin"
+ cat > "$HOME/.bin/nroff" <<EOF
+#!/bin/sh
+if [ -n "\$_NROFF_U" -a "\$1,\$2,\$3" = "-u0,-Tlp,-man" ]; then
+ shift
+ exec /usr/bin/nroff -u\$_NROFF_U "\$@"
+fi
+#-- Some other invocation of nroff
+exec /usr/bin/nroff "\$@"
+EOF
+chmod +x "$HOME/.bin/nroff"
+ fi
+fi
+
+function man {
+ env \
+ LESS_TERMCAP_mb=$(printf "\e[1;31m") \
+ LESS_TERMCAP_md=$(printf "\e[1;34m") \
+ LESS_TERMCAP_me=$(printf "\e[0m") \
+ LESS_TERMCAP_se=$(printf "\e[0m") \
+ LESS_TERMCAP_so=$(printf "\e[1;34m") \
+ LESS_TERMCAP_ue=$(printf "\e[0m") \
+ LESS_TERMCAP_us=$(printf "\e[4;37m") \
+ PAGER="${commands[less]:-$PAGER}" \
+ _NROFF_U=1 \
+ PATH="$HOME/.bin:$PATH" \
+ man "$@"
+}
diff --git a/base/zsh/fasd.zsh b/base/zsh/fasd.zsh
new file mode 100644
index 0000000..eb96ab0
--- /dev/null
+++ b/base/zsh/fasd.zsh
@@ -0,0 +1,3 @@
+if command -v fasd >/dev/null 2>&1; then
+ eval "$(fasd --init zsh-hook zsh-ccomp zsh-ccomp-install zsh-wcomp zsh-wcomp-install posix-alias)"
+fi
diff --git a/base/zsh/fast-syntax-highlighting/fast-highlight b/base/zsh/fast-syntax-highlighting/fast-highlight
new file mode 100644
index 0000000..70c8867
--- /dev/null
+++ b/base/zsh/fast-syntax-highlighting/fast-highlight
@@ -0,0 +1,715 @@
+# -------------------------------------------------------------------------------------------------
+# Copyright (c) 2010-2016 zsh-syntax-highlighting contributors
+# Copyright (c) 2016-2017 Sebastian Gniazdowski (modifications)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted
+# provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this list of conditions
+# and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice, this list of
+# conditions and the following disclaimer in the documentation and/or other materials provided
+# with the distribution.
+# * Neither the name of the zsh-syntax-highlighting contributors nor the names of its contributors
+# may be used to endorse or promote products derived from this software without specific prior
+# written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# -------------------------------------------------------------------------------------------------
+
+typeset -gA __fast_highlight_main__command_type_cache
+
+# Define default styles. You can set this after loading the plugin in
+# Zshrc and use 256 via numbers, like: fg=150
+typeset -gA FAST_HIGHLIGHT_STYLES
+: ${FAST_HIGHLIGHT_STYLES[default]:=none}
+: ${FAST_HIGHLIGHT_STYLES[unknown-token]:=fg=red,bold}
+: ${FAST_HIGHLIGHT_STYLES[reserved-word]:=fg=yellow}
+: ${FAST_HIGHLIGHT_STYLES[alias]:=fg=green}
+: ${FAST_HIGHLIGHT_STYLES[suffix-alias]:=fg=green}
+: ${FAST_HIGHLIGHT_STYLES[builtin]:=fg=green}
+: ${FAST_HIGHLIGHT_STYLES[function]:=fg=green}
+: ${FAST_HIGHLIGHT_STYLES[command]:=fg=green}
+: ${FAST_HIGHLIGHT_STYLES[precommand]:=fg=green}
+: ${FAST_HIGHLIGHT_STYLES[commandseparator]:=none}
+: ${FAST_HIGHLIGHT_STYLES[hashed-command]:=fg=green}
+: ${FAST_HIGHLIGHT_STYLES[path]:=fg=magenta}
+: ${FAST_HIGHLIGHT_STYLES[path_pathseparator]:=}
+: ${FAST_HIGHLIGHT_STYLES[globbing]:=fg=blue,bold}
+: ${FAST_HIGHLIGHT_STYLES[history-expansion]:=fg=blue,bold}
+: ${FAST_HIGHLIGHT_STYLES[single-hyphen-option]:=fg=cyan}
+: ${FAST_HIGHLIGHT_STYLES[double-hyphen-option]:=fg=cyan}
+: ${FAST_HIGHLIGHT_STYLES[back-quoted-argument]:=none}
+: ${FAST_HIGHLIGHT_STYLES[single-quoted-argument]:=fg=yellow}
+: ${FAST_HIGHLIGHT_STYLES[double-quoted-argument]:=fg=yellow}
+: ${FAST_HIGHLIGHT_STYLES[dollar-quoted-argument]:=fg=yellow}
+: ${FAST_HIGHLIGHT_STYLES[back-or-dollar-double-quoted-argument]:=fg=cyan}
+: ${FAST_HIGHLIGHT_STYLES[back-dollar-quoted-argument]:=fg=cyan}
+: ${FAST_HIGHLIGHT_STYLES[assign]:=none}
+: ${FAST_HIGHLIGHT_STYLES[redirection]:=none}
+: ${FAST_HIGHLIGHT_STYLES[comment]:=fg=black,bold}
+: ${FAST_HIGHLIGHT_STYLES[variable]:=none}
+
+
+typeset -gA __FAST_HIGHLIGHT_TOKEN_TYPES
+
+__FAST_HIGHLIGHT_TOKEN_TYPES=(
+
+ # Precommand
+
+ 'builtin' 1
+ 'command' 1
+ 'exec' 1
+ 'nocorrect' 1
+ 'noglob' 1
+ 'pkexec' 1 # immune to #121 because it's usually not passed --option flags
+
+ # Control flow
+ # Tokens that, at (naively-determined) "command position", are followed by
+ # a de jure command position. All of these are reserved words.
+
+ $'\x7b' 2 # block
+ $'\x28' 2 # subshell
+ '()' 2 # anonymous function
+ 'while' 2
+ 'until' 2
+ 'if' 2
+ 'then' 2
+ 'elif' 2
+ 'else' 2
+ 'do' 2
+ 'time' 2
+ 'coproc' 2
+ '!' 2 # reserved word; unrelated to $histchars[1]
+
+ # Command separators
+
+ '|' 3
+ '||' 3
+ ';' 3
+ '&' 3
+ '&&' 3
+ '|&' 3
+ '&!' 3
+ '&|' 3
+ # ### 'case' syntax, but followed by a pattern, not by a command
+ # ';;' ';&' ';|'
+)
+
+# A hash instead of multiple globals
+typeset -gA FAST_HIGHLIGHT
+
+# Get the type of a command.
+#
+# Uses the zsh/parameter module if available to avoid forks, and a
+# wrapper around 'type -w' as fallback.
+#
+# Takes a single argument.
+#
+# The result will be stored in REPLY.
+-fast-highlight-main-type() {
+ REPLY=$__fast_highlight_main__command_type_cache[(e)$1]
+ [[ -z "$REPLY" ]] && {
+
+ if zmodload -e zsh/parameter; then
+ if (( $+aliases[(e)$1] )); then
+ REPLY=alias
+ elif (( $+functions[(e)$1] )); then
+ REPLY=function
+ elif (( $+builtins[(e)$1] )); then
+ REPLY=builtin
+ elif (( $+commands[(e)$1] )); then
+ REPLY=command
+ elif (( $+saliases[(e)${1##*.}] )); then
+ REPLY='suffix alias'
+ elif (( $reswords[(Ie)$1] )); then
+ REPLY=reserved
+ # zsh 5.2 and older have a bug whereby running 'type -w ./sudo' implicitly
+ # runs 'hash ./sudo=/usr/local/bin/./sudo' (assuming /usr/local/bin/sudo
+ # exists and is in $PATH). Avoid triggering the bug, at the expense of
+ # falling through to the $() below, incurring a fork. (Issue #354.)
+ #
+ # The second disjunct mimics the isrelative() C call from the zsh bug.
+ elif [[ $1 != */* || "${+ZSH_ARGZERO}" = "1" ]] && ! builtin type -w -- $1 >/dev/null 2>&1; then
+ REPLY=none
+ fi
+ fi
+
+ [[ -z "$REPLY" ]] && REPLY="${$(LC_ALL=C builtin type -w -- $1 2>/dev/null)##*: }"
+
+ [[ "$REPLY" = "none" ]] && {
+ [[ -d "$1" ]] && REPLY="dirpath" || {
+ for cdpath_dir in $cdpath; do
+ [[ -d "$cdpath_dir/$1" ]] && { REPLY="dirpath"; break; }
+ done
+ }
+ }
+
+ __fast_highlight_main__command_type_cache[(e)$1]=$REPLY
+
+ }
+}
+
+# Below are variables that must be defined in outer
+# scope so that they are reachable in *-process()
+-fast-highlight-fill-option-variables() {
+ if [[ -o ignore_braces ]] || eval '[[ -o ignore_close_braces ]] 2>/dev/null'; then
+ FAST_HIGHLIGHT[right_brace_is_recognised_everywhere]=0
+ else
+ FAST_HIGHLIGHT[right_brace_is_recognised_everywhere]=1
+ fi
+
+ if [[ -o path_dirs ]]; then
+ FAST_HIGHLIGHT[path_dirs_was_set]=1
+ else
+ FAST_HIGHLIGHT[path_dirs_was_set]=0
+ fi
+
+ if [[ -o multi_func_def ]]; then
+ FAST_HIGHLIGHT[multi_func_def]=1
+ else
+ FAST_HIGHLIGHT[multi_func_def]=0
+ fi
+
+ if [[ -o interactive_comments ]]; then
+ FAST_HIGHLIGHT[ointeractive_comments]=1
+ else
+ FAST_HIGHLIGHT[ointeractive_comments]=0
+ fi
+}
+
+# Main syntax highlighting function.
+-fast-highlight-process()
+{
+ emulate -L zsh
+ setopt extendedglob bareglobqual nonomatch noksharrays
+
+ [[ $CONTEXT == "select" ]] && return 1
+ [[ ${#BUFFER} -gt 10000 ]] && return 1 # Limit based on n-history length
+
+ (( FAST_HIGHLIGHT[path_dirs_was_set] )) && setopt PATH_DIRS
+ (( FAST_HIGHLIGHT[ointeractive_comments] )) && local interactive_comments= # _set_ to empty
+
+ # Variable declarations and initializations
+ # in_array_assignment true between 'a=(' and the matching ')'
+ # braces_stack: "R" for round, "Q" for square, "Y" for curly
+ # mybuf, cdpath_dir are used in sub-functions
+ local start_pos=0 end_pos start end highlight_glob=1 arg style in_array_assignment=0 MATCH expanded_path braces_stack buf="$PREBUFFER$BUFFER" mybuf cdpath_dir cur_cmd alias_target
+ # arg_type can be 0, 1, 2 or 3, i.e. precommand, control flow, command separator
+ # idx and end_idx are used in sub-functions
+ # for this_word and next_word look below at commented integers and at state machine description
+ integer arg_type=0 MBEGIN MEND in_redirection len=${#buf} already_added offset idx end_idx this_word=1 next_word=0 insane_alias pos
+ local -a match mbegin mend
+
+ # integer BIT_start=1 BIT_regular=2 BIT_sudo_opt=4 BIT_sudo_arg=8 BIT_always=16
+
+ # State machine
+ #
+ # The states are:
+ # - :start: Command word
+ # - :sudo_opt: A leading-dash option to sudo (such as "-u" or "-i")
+ # - :sudo_arg: The argument to a sudo leading-dash option that takes one,
+ # when given as a separate word; i.e., "foo" in "-u foo" (two
+ # words) but not in "-ufoo" (one word).
+ # - :regular: "Not a command word", and command delimiters are permitted.
+ # Mainly used to detect premature termination of commands.
+ # - :always: The word 'always' in the «{ foo } always { bar }» syntax.
+ #
+ # When the kind of a word is not yet known, $this_word / $next_word may contain
+ # multiple states. For example, after "sudo -i", the next word may be either
+ # another --flag or a command name, hence the state would include both :start:
+ # and :sudo_opt:.
+ #
+ # The tokens are always added with both leading and trailing colons to serve as
+ # word delimiters (an improvised array); [[ $x == *:foo:* ]] and x=${x//:foo:/}
+ # will DTRT regardless of how many elements or repetitions $x has..
+ #
+ # Handling of redirections: upon seeing a redirection token, we must stall
+ # the current state --- that is, the value of $this_word --- for two iterations
+ # (one for the redirection operator, one for the word following it representing
+ # the redirection target). Therefore, we set $in_redirection to 2 upon seeing a
+ # redirection operator, decrement it each iteration, and stall the current state
+ # when it is non-zero. Thus, upon reaching the next word (the one that follows
+ # the redirection operator and target), $this_word will still contain values
+ # appropriate for the word immediately following the word that preceded the
+ # redirection operator.
+ #
+ # The "the previous word was a redirection operator" state is not communicated
+ # to the next iteration via $next_word/$this_word as usual, but via
+ # $in_redirection. The value of $next_word from the iteration that processed
+ # the operator is discarded.
+ #
+
+ # Processing buffer
+ local proc_buf="$buf" needle
+ for arg in ${interactive_comments-${(z)buf}} \
+ ${interactive_comments+${(zZ+c+)buf}}; do
+ # Initialize $next_word to its default value?
+ (( in_redirection )) && (( --in_redirection ))
+ (( in_redirection == 0 )) && next_word=2 # else Stall $next_word.
+
+ # Initialize per-"simple command" [zshmisc(1)] variables:
+ #
+ # $already_added (see next paragraph)
+ # $style how to highlight $arg
+ # $in_array_assignment boolean flag for "between '(' and ')' of array assignment"
+ # $highlight_glob boolean flag for "'noglob' is in effect"
+ #
+ # $already_added is set to 1 to disable adding an entry to region_highlight
+ # for this iteration. Currently, that is done for "" and $'' strings,
+ # which add the entry early so escape sequences within the string override
+ # the string's color.
+ already_added=0
+ style=unknown-token
+ if (( this_word & 1 )); then
+ in_array_assignment=0
+ [[ $arg == 'noglob' ]] && highlight_glob=0
+ fi
+
+ # Compute the new $start_pos and $end_pos, skipping over whitespace in $buf.
+ if [[ $arg == ';' ]] ; then
+ # We're looking for either a semicolon or a newline, whichever comes
+ # first. Both of these are rendered as a ";" (SEPER) by the ${(z)..}
+ # flag.
+ #
+ # We can't use the (Z+n+) flag because that elides the end-of-command
+ # token altogether, so 'echo foo\necho bar' (two commands) becomes
+ # indistinguishable from 'echo foo echo bar' (one command with three
+ # words for arguments).
+ needle=$'[;\n]'
+ offset=$(( ${proc_buf[(i)$needle]} - 1 ))
+ (( start_pos += offset ))
+ (( end_pos = start_pos + $#arg ))
+
+ # Do not run default code for case when there is a new line
+ # It shouldn't be treated as ';', i.e. shouldn't be highlighted
+ # as unknown-token when appears after command-starting arg like "{"
+ if [[ "${proc_buf[offset+1]}" = $'\n' ]]; then
+ (( in_array_assignment )) && (( this_word = 2 )) || { (( this_word = 1 )); highlight_glob=1; }
+ in_redirection=0
+ proc_buf="${proc_buf[offset + $#arg + 1,len]}"
+ start_pos=$end_pos
+ continue
+ else
+ # One more short path – for ';' command separator
+ (( in_array_assignment )) && (( this_word = 2 )) || { (( this_word = 1 )); highlight_glob=1; }
+ in_redirection=0
+ [[ "${FAST_HIGHLIGHT_STYLES[commandseparator]}" != "none" ]] && (( start=start_pos-${#PREBUFFER}, end=end_pos-${#PREBUFFER}, start >= 0 )) && reply+=("$start $end ${FAST_HIGHLIGHT_STYLES[commandseparator]}")
+ proc_buf="${proc_buf[offset + $#arg + 1,len]}"
+ start_pos=$end_pos
+ continue
+ fi
+
+ arg_type=3
+ else
+ offset=0
+ if [[ "$proc_buf" = (#b)(#s)(([[:space:]]|\\[[:space:]])##)* ]]; then
+ # The first, outer parenthesis
+ offset="${mend[1]}"
+ fi
+ ((start_pos+=offset))
+ ((end_pos=start_pos+${#arg}))
+
+ # No-hit will result in value 0
+ arg_type=${__FAST_HIGHLIGHT_TOKEN_TYPES[$arg]}
+ fi
+
+ proc_buf="${proc_buf[offset + $#arg + 1,len]}"
+
+ # Handle the INTERACTIVE_COMMENTS option.
+ #
+ # We use the (Z+c+) flag so the entire comment is presented as one token in $arg.
+ if [[ -n ${interactive_comments+'set'} && $arg[1] == $histchars[3] ]]; then
+ if (( this_word & 3 )); then
+ style=comment
+ else
+ style=unknown-token # prematurely terminated
+ fi
+ # ADD
+ (( start=start_pos-${#PREBUFFER}, end=end_pos-${#PREBUFFER}, start >= 0 )) && reply+=("$start $end ${FAST_HIGHLIGHT_STYLES[$style]}")
+ start_pos=$end_pos
+ continue
+ fi
+
+ # Analyse the current word.
+ if [[ $arg == (<0-9>|)(\<|\>)* ]] && [[ $arg != (\<|\>)$'\x28'* ]]; then
+ # A '<' or '>', possibly followed by a digit
+ in_redirection=2
+ fi
+
+ # Special-case the first word after 'sudo'.
+ if (( ! in_redirection )); then
+ if (( this_word & 4 )) && [[ $arg != -* ]]; then
+ (( this_word = this_word ^ 4 ))
+ fi
+
+ # Parse the sudo command line
+ if (( this_word & 4 )); then
+ case "$arg" in
+ # Flag that requires an argument
+ '-'[Cgprtu])
+ (( this_word & 1 )) && (( this_word = this_word ^ 1 ))
+ (( next_word = 8 ))
+ ;;
+ # This prevents misbehavior with sudo -u -otherargument
+ '-'*)
+ (( this_word & 1 )) && (( this_word = this_word ^ 1 ))
+ (( next_word = next_word | 1 ))
+ (( next_word = next_word | 4 ))
+ ;;
+ *) ;;
+ esac
+ elif (( this_word & 8 )); then
+ (( next_word = next_word | 4 ))
+ (( next_word = next_word | 1 ))
+ fi
+ fi
+
+ expanded_path=""
+
+ # The Great Fork: is this a command word? Is this a non-command word?
+ if (( this_word & 16 )) && [[ $arg == 'always' ]]; then
+ # try-always construct
+ style=reserved-word # de facto a reserved word, although not de jure
+ (( next_word = 1 ))
+ elif (( this_word & 1 )) && (( in_redirection == 0 )); then # $arg is the command word
+ cur_cmd="$arg"
+ if (( arg_type == 1 )); then
+ style=precommand
+ elif [[ "$arg" = "sudo" ]]; then
+ style=precommand
+ (( next_word & 2 )) && (( next_word = next_word ^ 2 ))
+ (( next_word = next_word | 4 ))
+ (( next_word = next_word | 1 ))
+ else
+ # Special-case: command word is '$foo', like that, without braces or anything.
+ #
+ # That's not entirely correct --- if the parameter's value happens to be a reserved
+ # word, the parameter expansion will be highlighted as a reserved word --- but that
+ # incorrectness is outweighed by the usability improvement of permitting the use of
+ # parameters that refer to commands, functions, and builtins.
+ if [[ ${arg[1]} == \$ ]] && (( ${+parameters} )) && [[ ${arg:1} = (#m)([a-zA-Z_][a-zA-Z0-9_]#|[0-9]##) ]] && (( ${+parameters[${MATCH}]} )); then
+ -fast-highlight-main-type ${(P)MATCH}
+ else
+ : ${expanded_path::=${(Q)~arg}}
+ -fast-highlight-main-type $expanded_path
+ fi
+
+ case $REPLY in
+ reserved) # reserved word
+ style=reserved-word
+ if [[ $arg == $'\x7b' ]]; then
+ braces_stack='Y'"$braces_stack"
+ elif [[ $arg == $'\x7d' && $braces_stack[1] == "Y" ]]; then
+ # We're at command word, so no need to check right_brace_is_recognised_everywhere
+ braces_stack[1]=""
+ style=reserved-word
+ (( next_word = next_word | 16 ))
+ elif [[ $arg == "[[" ]]; then
+ braces_stack='A'"$braces_stack"
+ fi
+ ;;
+ 'suffix alias') style=suffix-alias;;
+ alias)
+ insane_alias=0
+ case $arg in
+ # Issue #263: aliases with '=' on their LHS.
+ #
+ # There are three cases:
+ #
+ # - Unsupported, breaks 'alias -L' output, but invokable:
+ ('='*) :;;
+ # - Unsupported, not invokable:
+ (*'='*) insane_alias=1;;
+ # - The common case:
+ (*) :;;
+ esac
+ if (( insane_alias )); then
+ style=unknown-token
+ else
+ style=alias
+ zmodload -e zsh/parameter && alias_target=${aliases[$arg]} || alias_target="${"$(alias -- $arg)"#*=}"
+ [[ ${__FAST_HIGHLIGHT_TOKEN_TYPES[$alias_target]} = "1" && "$arg_type" != "1" ]] && __FAST_HIGHLIGHT_TOKEN_TYPES[$arg]="1"
+ fi
+ ;;
+ builtin) style=builtin;;
+ function) style=function;;
+ command) style=command;;
+ hashed) style=hashed-command;;
+ dirpath) style=path;;
+ none) # Assign?
+ if [[ $arg == [[:alpha:]_][[:alnum:]_]#(|\[[^\]]#\])(|[+])=* ]] || [[ $arg == [0-9]##(|[+])=* ]]; then
+ style=assign
+ # Assignment to a scalar parameter or to array
+ # (For array assignments, the command doesn't start until the ")" token.)
+ [[ $arg[-1] == '(' ]] && in_array_assignment=1 || (( next_word = next_word | 1 ))
+ elif [[ $arg[1] = $histchars[1] && -n "${arg[2]}" ]]; then
+ style=history-expansion
+ elif [[ $arg[1] == $histchars[2] ]]; then
+ style=history-expansion
+ elif (( arg_type == 3 )); then
+ # This highlights empty commands (semicolon follows nothing) as an error.
+ # Zsh accepts them, though.
+ (( this_word & 2 )) && style=commandseparator
+ elif [[ $arg[1,2] == '((' ]]; then
+ # Arithmetic evaluation.
+ #
+ # Note: prior to zsh-5.1.1-52-g4bed2cf (workers/36669), the ${(z)...}
+ # splitter would only output the '((' token if the matching '))' had
+ # been typed. Therefore, under those versions of zsh, BUFFER="(( 42"
+ # would be highlighted as an error until the matching "))" are typed.
+ #
+ # We highlight just the opening parentheses, as a reserved word; this
+ # is how [[ ... ]] is highlighted, too.
+
+ # ADD
+ (( start=start_pos-${#PREBUFFER}, end=end_pos-${#PREBUFFER}, start >= 0 )) && reply+=("$start $(( start + 2 )) ${FAST_HIGHLIGHT_STYLES[reserved-word]}")
+ already_added=1
+ # ADD
+ [[ $arg[-2,-1] == '))' ]] && (( start=start_pos-${#PREBUFFER}, end=end_pos-${#PREBUFFER}, start >= 0 )) && reply+=("$(( end - 2 )) $end ${FAST_HIGHLIGHT_STYLES[reserved-word]}")
+ elif [[ $arg == '()' ]]; then
+ # anonymous function
+ style=reserved-word
+ elif [[ $arg == $'\x28' ]]; then
+ # subshell
+ style=reserved-word
+ braces_stack='R'"$braces_stack"
+ elif [[ $arg == $'\x29' ]]; then
+ [[ $braces_stack[1] == "R" ]] && { braces_stack[1]=""; style=reserved-word; }
+ elif (( this_word & 14 )); then
+ style=default
+ fi
+ ;;
+ *)
+ # ADD
+ # (( start=start_pos-${#PREBUFFER}, end=end_pos-${#PREBUFFER}, start >= 0 )) && reply+=("$start $end commandtypefromthefuture-$REPLY")
+ already_added=1
+ ;;
+ esac
+ fi
+ # in_redirection || BIT_regular || BIT_sudo_opt || BIT_sudo_arg
+ elif (( in_redirection + this_word & 14 ))
+ then # $arg is a non-command word
+ case $arg in
+ ']]')
+ style=reserved-word
+ [[ $braces_stack[1] == "A" ]] && braces_stack[1]=""
+ ;;
+ ']')
+ style=builtin
+ ;;
+ $'\x28')
+ # '(' inside [[
+ style=reserved-word
+ braces_stack='R'"$braces_stack"
+ ;;
+ $'\x29') # subshell or end of array assignment
+ if (( in_array_assignment )); then
+ style=assign
+ in_array_assignment=0
+ (( next_word = next_word | 1 ))
+ elif [[ $braces_stack[1] == "R" ]]; then
+ braces_stack[1]=""
+ style=reserved-word
+ fi;;
+ $'\x28\x29') # possibly a function definition
+ # || false # TODO: or if the previous word was a command word
+ (( FAST_HIGHLIGHT[multi_func_def] )) && (( next_word = next_word | 1 ))
+ style=reserved-word
+ # Remove possible annoying unknown-token style, or misleading function style
+ reply[-1]=()
+ ;;
+ '--'*) style=double-hyphen-option;;
+ '-'*) style=single-hyphen-option;;
+ "'"*) style=single-quoted-argument;;
+ '"'*)
+ # ADD
+ (( start=start_pos-${#PREBUFFER}, end=end_pos-${#PREBUFFER}, start >= 0 )) && reply+=("$start $end ${FAST_HIGHLIGHT_STYLES[double-quoted-argument]}")
+ -fast-highlight-string
+ already_added=1
+ ;;
+ \$\'*)
+ # ADD
+ (( start=start_pos-${#PREBUFFER}, end=end_pos-${#PREBUFFER}, start >= 0 )) && reply+=("$start $end ${FAST_HIGHLIGHT_STYLES[dollar-quoted-argument]}")
+ -fast-highlight-dollar-string
+ already_added=1
+ ;;
+ \$[^\(]*)
+ style=variable
+ ;;
+ '`'*) style=back-quoted-argument;;
+ [*?]*|*[^\\][*?]*)
+ (( highlight_glob )) && style=globbing || style=default;;
+ *) if [[ $arg = $'\x7d' && $braces_stack[1] == "Y" && "$FAST_HIGHLIGHT[right_brace_is_recognised_everywhere]" = "1" ]]; then
+ # right brace
+ # Parsing rule: # {
+ #
+ # Additionally, `tt(})' is recognized in any position if neither the
+ # tt(IGNORE_BRACES) option nor the tt(IGNORE_CLOSE_BRACES) option is set."""
+ braces_stack[1]=""
+ style=reserved-word
+ (( next_word = next_word | 16 ))
+ elif [[ $arg[1] = $histchars[1] && -n "${arg[2]}" ]]; then
+ style=history-expansion
+ elif (( arg_type == 3 )); then
+ style=commandseparator
+ elif (( in_redirection == 2 )); then
+ style=redirection
+ else
+ if [[ -z "${FAST_HIGHLIGHT[no_check_paths]}" ]] && -fast-highlight-check-path; then
+ # ADD
+ (( start=start_pos-${#PREBUFFER}, end=end_pos-${#PREBUFFER}, start >= 0 )) && reply+=("$start $end ${FAST_HIGHLIGHT_STYLES[path]}")
+ already_added=1
+
+ [[ -n "$FAST_HIGHLIGHT_STYLES[path_pathseparator]" && "$FAST_HIGHLIGHT_STYLES[path]" != "$FAST_HIGHLIGHT_STYLES[path_pathseparator]" ]] && {
+ for (( pos = start_pos; pos <= end_pos; pos++ )) ; do
+ # ADD
+ [[ ${buf[pos]} == "/" ]] && (( start=pos-${#PREBUFFER}, start >= 0 )) && reply+=("$(( start - 1 )) $start ${FAST_HIGHLIGHT_STYLES[path_pathseparator]}")
+ done
+ }
+ else
+ style=default
+ fi
+ fi
+ ;;
+ esac
+ fi
+
+ # ADD
+ (( already_added == 0 )) && [[ "${FAST_HIGHLIGHT_STYLES[$style]}" != "none" ]] && (( start=start_pos-${#PREBUFFER}, end=end_pos-${#PREBUFFER}, start >= 0 )) && reply+=("$start $end ${FAST_HIGHLIGHT_STYLES[$style]}")
+
+ if (( arg_type == 3 )); then
+ if [[ $arg == ';' ]] && (( in_array_assignment )); then
+ # literal newline inside an array assignment
+ (( next_word = 2 ))
+ elif [[ -n "${braces_stack[(r)A]}" ]]; then
+ (( next_word = 2 ))
+ else
+ (( next_word = 1 ))
+ highlight_glob=1
+ fi
+ elif (( arg_type == 1 || arg_type == 2 )) && (( this_word & 1 )); then
+ (( next_word = 1 ))
+ elif [[ $arg == "repeat" ]] && (( this_word & 1 )); then
+ # skip the repeat-count word
+ in_redirection=2
+ # The redirection mechanism assumes $this_word describes the word
+ # following the redirection. Make it so.
+ #
+ # That word can be a command word with shortloops (`repeat 2 ls`)
+ # or a command separator (`repeat 2; ls` or `repeat 2; do ls; done`).
+ #
+ # The repeat-count word will be handled like a redirection target.
+ (( this_word = 3 ))
+ fi
+ start_pos=$end_pos
+ # This is the default/common codepath.
+ (( in_redirection == 0 )) && (( this_word = next_word )) #else # Stall $this_word.
+ done
+
+ return 0
+}
+
+# Check if $arg is a path.
+# If yes, return 0 and in $REPLY the style to use.
+# Else, return non-zero (and the contents of $REPLY is undefined).
+-fast-highlight-check-path()
+{
+ : ${expanded_path:=${(Q)~arg}}
+
+ [[ -z $expanded_path ]] && return 1
+ [[ -e $expanded_path ]] && return 0
+
+ # Search the path in CDPATH, only for CD command
+ [[ "$cur_cmd" = "cd" ]] && for cdpath_dir in $cdpath ; do
+ [[ -e "$cdpath_dir/$expanded_path" ]] && return 0
+ done
+
+ # It's not a path.
+ return 1
+}
+
+# Highlight special chars inside double-quoted strings
+-fast-highlight-string()
+{
+ mybuf="$arg"
+ idx=start_pos
+
+ while [[ "$mybuf" = (#b)[^\$\\]#((\$(#B)([a-zA-Z_:][a-zA-Z0-9_:]#|[0-9]##)(#b)(\[[^\]]#\])(#c0,1))|(\$[{](\([a-zA-Z0@%#]##\))(#c0,1)[a-zA-Z0-9_:#]##(\[[^\]]#\])(#c0,1)[}])|[\\][\'\"\$]|[\\](*))(*) ]]; do
+ [[ -n "${match[7]}" ]] && {
+ # Skip following char – it is quoted. Choice is
+ # made to not highlight such quoting
+ idx+=${mbegin[1]}+1
+ mybuf="${match[7]:1}"
+ } || {
+ idx+=${mbegin[1]}-1
+ end_idx=idx+${mend[1]}-${mbegin[1]}+1
+ mybuf="${match[8]}"
+
+ # ADD
+ (( start=idx-${#PREBUFFER}, end=end_idx-${#PREBUFFER}, start >= 0 )) && reply+=("$start $end ${FAST_HIGHLIGHT_STYLES[back-or-dollar-double-quoted-argument]}")
+
+ idx=end_idx
+ }
+ done
+}
+
+# Highlight special chars inside dollar-quoted strings
+-fast-highlight-dollar-string()
+{
+ local i j k style
+ local AA
+ integer c
+ # Starting dollar-quote is at 1:2, so start parsing at offset 3 in the string.
+ for (( i = 3 ; i < end_pos - start_pos ; i += 1 )) ; do
+ (( j = i + start_pos - 1 ))
+ (( k = j + 1 ))
+ case "$arg[$i]" in
+ "\\") style=back-dollar-quoted-argument
+ for (( c = i + 1 ; c <= end_pos - start_pos ; c += 1 )); do
+ [[ "$arg[$c]" != ([0-9xXuUa-fA-F]) ]] && break
+ done
+ AA=$arg[$i+1,$c-1]
+ # Matching for HEX and OCT values like \0xA6, \xA6 or \012
+ if [[ "$AA" =~ "^(x|X)[0-9a-fA-F]{1,2}"
+ || "$AA" =~ "^[0-7]{1,3}"
+ || "$AA" =~ "^u[0-9a-fA-F]{1,4}"
+ || "$AA" =~ "^U[0-9a-fA-F]{1,8}"
+ ]]; then
+ (( k += $#MATCH ))
+ (( i += $#MATCH ))
+ else
+ if (( $#arg > $i+1 )) && [[ $arg[$i+1] == [xXuU] ]]; then
+ # \x not followed by hex digits is probably an error
+ style=unknown-token
+ fi
+ (( k += 1 )) # Color following char too.
+ (( i += 1 )) # Skip parsing the escaped char.
+ fi
+ ;;
+ *) continue ;;
+
+ esac
+ # ADD
+ (( start=j-${#PREBUFFER}, end=k-${#PREBUFFER}, start >= 0 )) && reply+=("$start $end ${FAST_HIGHLIGHT_STYLES[$style]}")
+ done
+}
+
+# -------------------------------------------------------------------------------------------------
+# Main highlighter initialization
+# -------------------------------------------------------------------------------------------------
+
+-fast-highlight-init() {
+ __fast_highlight_main__command_type_cache=()
+}
+
+# vim:ft=zsh:sw=2:sts=2
+# -*- mode: zsh; sh-indentation: 2; indent-tabs-mode: nil; sh-basic-offset: 2; -*-
diff --git a/base/zsh/fast-syntax-highlighting/fast-syntax-highlighting.plugin.zsh b/base/zsh/fast-syntax-highlighting/fast-syntax-highlighting.plugin.zsh
new file mode 100644
index 0000000..235d425
--- /dev/null
+++ b/base/zsh/fast-syntax-highlighting/fast-syntax-highlighting.plugin.zsh
@@ -0,0 +1,272 @@
+# -------------------------------------------------------------------------------------------------
+# Copyright (c) 2010-2016 zsh-syntax-highlighting contributors
+# Copyright (c) 2017 Sebastian Gniazdowski (modifications)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted
+# provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this list of conditions
+# and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice, this list of
+# conditions and the following disclaimer in the documentation and/or other materials provided
+# with the distribution.
+# * Neither the name of the zsh-syntax-highlighting contributors nor the names of its contributors
+# may be used to endorse or promote products derived from this software without specific prior
+# written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+# FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# -------------------------------------------------------------------------------------------------
+# -*- mode: zsh; sh-indentation: 2; indent-tabs-mode: nil; sh-basic-offset: 2; -*-
+# vim: ft=zsh sw=2 ts=2 et
+# -------------------------------------------------------------------------------------------------
+
+
+# Set $ZERO to the expected value, regardless of functionargzero.
+typeset -g ZERO=${(%):-%N}
+
+# Invokes each highlighter that needs updating.
+# This function is supposed to be called whenever the ZLE state changes.
+_zsh_highlight()
+{
+ # Store the previous command return code to restore it whatever happens.
+ local ret=$?
+
+ # Remove all highlighting in isearch, so that only the underlining done by zsh itself remains.
+ # For details see FAQ entry 'Why does syntax highlighting not work while searching history?'.
+ if [[ $WIDGET == zle-isearch-update ]] && ! (( $+ISEARCHMATCH_ACTIVE )); then
+ region_highlight=()
+ return $ret
+ fi
+
+ setopt localoptions warncreateglobal noksharrays
+ local REPLY # don't leak $REPLY into global scope
+ local -a reply
+
+ # Do not highlight if there are more than 300 chars in the buffer. It's most
+ # likely a pasted command or a huge list of files in that case..
+ [[ -n ${ZSH_HIGHLIGHT_MAXLENGTH:-} ]] && [[ $#BUFFER -gt $ZSH_HIGHLIGHT_MAXLENGTH ]] && return $ret
+
+ # Do not highlight if there are pending inputs (copy/paste).
+ [[ $PENDING -gt 0 ]] && return $ret
+
+ # Reset region highlight to build it from scratch
+ # may need to remove path_prefix highlighting when the line ends
+ if [[ $WIDGET == zle-line-finish ]] || _zsh_highlight_buffer_modified; then
+ -fast-highlight-init
+ -fast-highlight-process && region_highlight=( $reply ) || region_highlight=()
+ fi
+
+ {
+ local cache_place
+ local -a region_highlight_copy
+
+ # Re-apply zle_highlight settings
+
+ # region
+ if (( REGION_ACTIVE == 1 )); then
+ _zsh_highlight_apply_zle_highlight region standout "$MARK" "$CURSOR"
+ elif (( REGION_ACTIVE == 2 )); then
+ () {
+ local needle=$'\n'
+ integer min max
+ if (( MARK > CURSOR )) ; then
+ min=$CURSOR max=$MARK
+ else
+ min=$MARK max=$CURSOR
+ fi
+ (( min = ${${BUFFER[1,$min]}[(I)$needle]} ))
+ (( max += ${${BUFFER:($max-1)}[(i)$needle]} - 1 ))
+ _zsh_highlight_apply_zle_highlight region standout "$min" "$max"
+ }
+ fi
+
+ # yank / paste (zsh-5.1.1 and newer)
+ (( $+YANK_ACTIVE )) && (( YANK_ACTIVE )) && _zsh_highlight_apply_zle_highlight paste standout "$YANK_START" "$YANK_END"
+
+ # isearch
+ (( $+ISEARCHMATCH_ACTIVE )) && (( ISEARCHMATCH_ACTIVE )) && _zsh_highlight_apply_zle_highlight isearch underline "$ISEARCHMATCH_START" "$ISEARCHMATCH_END"
+
+ # suffix
+ (( $+SUFFIX_ACTIVE )) && (( SUFFIX_ACTIVE )) && _zsh_highlight_apply_zle_highlight suffix bold "$SUFFIX_START" "$SUFFIX_END"
+
+ return $ret
+
+ } always {
+ typeset -g _ZSH_HIGHLIGHT_PRIOR_BUFFER="$BUFFER"
+ typeset -gi _ZSH_HIGHLIGHT_PRIOR_CURSOR=$CURSOR
+ }
+}
+
+# Apply highlighting based on entries in the zle_highlight array.
+# This function takes four arguments:
+# 1. The exact entry (no patterns) in the zle_highlight array:
+# region, paste, isearch, or suffix
+# 2. The default highlighting that should be applied if the entry is unset
+# 3. and 4. Two integer values describing the beginning and end of the
+# range. The order does not matter.
+_zsh_highlight_apply_zle_highlight() {
+ local entry="$1" default="$2"
+ integer first="$3" second="$4"
+
+ # read the relevant entry from zle_highlight
+ local region="${zle_highlight[(r)${entry}:*]}"
+
+ if [[ -z "$region" ]]; then
+ # entry not specified at all, use default value
+ region=$default
+ else
+ # strip prefix
+ region="${region#${entry}:}"
+
+ # no highlighting when set to the empty string or to 'none'
+ if [[ -z "$region" ]] || [[ "$region" == none ]]; then
+ return
+ fi
+ fi
+
+ integer start end
+ if (( first < second )); then
+ start=$first end=$second
+ else
+ start=$second end=$first
+ fi
+ region_highlight+=("$start $end $region")
+}
+
+
+# -------------------------------------------------------------------------------------------------
+# API/utility functions for highlighters
+# -------------------------------------------------------------------------------------------------
+
+# Whether the command line buffer has been modified or not.
+#
+# Returns 0 if the buffer has changed since _zsh_highlight was last called.
+_zsh_highlight_buffer_modified()
+{
+ [[ "${_ZSH_HIGHLIGHT_PRIOR_BUFFER:-}" != "$BUFFER" ]]
+}
+
+# Whether the cursor has moved or not.
+#
+# Returns 0 if the cursor has moved since _zsh_highlight was last called.
+_zsh_highlight_cursor_moved()
+{
+ [[ -n $CURSOR ]] && [[ -n ${_ZSH_HIGHLIGHT_PRIOR_CURSOR-} ]] && (($_ZSH_HIGHLIGHT_PRIOR_CURSOR != $CURSOR))
+}
+
+# -------------------------------------------------------------------------------------------------
+# Setup functions
+# -------------------------------------------------------------------------------------------------
+
+# Helper for _zsh_highlight_bind_widgets
+# $1 is name of widget to call
+_zsh_highlight_call_widget()
+{
+ builtin zle "$@" && _zsh_highlight
+}
+
+# Rebind all ZLE widgets to make them invoke _zsh_highlights.
+_zsh_highlight_bind_widgets()
+{
+ setopt localoptions noksharrays
+ typeset -F SECONDS
+ local prefix=orig-s$SECONDS-r$RANDOM # unique each time, in case we're sourced more than once
+
+ # Load ZSH module zsh/zleparameter, needed to override user defined widgets.
+ zmodload zsh/zleparameter 2>/dev/null || {
+ print -r -- >&2 'zsh-syntax-highlighting: failed loading zsh/zleparameter.'
+ return 1
+ }
+
+ # Override ZLE widgets to make them invoke _zsh_highlight.
+ local -U widgets_to_bind
+ widgets_to_bind=(${${(k)widgets}:#(.*|run-help|which-command|beep|set-local-history|yank)})
+
+ # Always wrap special zle-line-finish widget. This is needed to decide if the
+ # current line ends and special highlighting logic needs to be applied.
+ # E.g. remove cursor imprint, don't highlight partial paths, ...
+ widgets_to_bind+=(zle-line-finish)
+
+ # Always wrap special zle-isearch-update widget to be notified of updates in isearch.
+ # This is needed because we need to disable highlighting in that case.
+ widgets_to_bind+=(zle-isearch-update)
+
+ local cur_widget
+ for cur_widget in $widgets_to_bind; do
+ case $widgets[$cur_widget] in
+
+ # Already rebound event: do nothing.
+ user:_zsh_highlight_widget_*);;
+
+ # The "eval"'s are required to make $cur_widget a closure: the value of the parameter at function
+ # definition time is used.
+ #
+ # We can't use ${0/_zsh_highlight_widget_} because these widgets are always invoked with
+ # NO_function_argzero, regardless of the option's setting here.
+
+ # User defined widget: override and rebind old one with prefix "orig-".
+ user:*) zle -N $prefix-$cur_widget ${widgets[$cur_widget]#*:}
+ eval "_zsh_highlight_widget_${(q)prefix}-${(q)cur_widget}() { _zsh_highlight_call_widget ${(q)prefix}-${(q)cur_widget} -- \"\$@\" }"
+ zle -N $cur_widget _zsh_highlight_widget_$prefix-$cur_widget;;
+
+ # Completion widget: override and rebind old one with prefix "orig-".
+ completion:*) zle -C $prefix-$cur_widget ${${(s.:.)widgets[$cur_widget]}[2,3]}
+ eval "_zsh_highlight_widget_${(q)prefix}-${(q)cur_widget}() { _zsh_highlight_call_widget ${(q)prefix}-${(q)cur_widget} -- \"\$@\" }"
+ zle -N $cur_widget _zsh_highlight_widget_$prefix-$cur_widget;;
+
+ # Builtin widget: override and make it call the builtin ".widget".
+ builtin) eval "_zsh_highlight_widget_${(q)prefix}-${(q)cur_widget}() { _zsh_highlight_call_widget .${(q)cur_widget} -- \"\$@\" }"
+ zle -N $cur_widget _zsh_highlight_widget_$prefix-$cur_widget;;
+
+ # Incomplete or nonexistent widget: Bind to z-sy-h directly.
+ *)
+ if [[ $cur_widget == zle-* ]] && [[ -z $widgets[$cur_widget] ]]; then
+ _zsh_highlight_widget_${cur_widget}() { :; _zsh_highlight }
+ zle -N $cur_widget _zsh_highlight_widget_$cur_widget
+ else
+ # Default: unhandled case.
+ print -r -- >&2 "zsh-syntax-highlighting: unhandled ZLE widget ${(qq)cur_widget}"
+ fi
+ esac
+ done
+}
+
+# -------------------------------------------------------------------------------------------------
+# Setup
+# -------------------------------------------------------------------------------------------------
+
+# Try binding widgets.
+_zsh_highlight_bind_widgets || {
+ print -r -- >&2 'zsh-syntax-highlighting: failed binding ZLE widgets, exiting.'
+ return 1
+}
+
+# Reset scratch variables when commandline is done.
+_zsh_highlight_preexec_hook()
+{
+ typeset -g _ZSH_HIGHLIGHT_PRIOR_BUFFER=
+ typeset -gi _ZSH_HIGHLIGHT_PRIOR_CURSOR=0
+}
+
+autoload -U add-zsh-hook
+add-zsh-hook preexec _zsh_highlight_preexec_hook 2>/dev/null || {
+ print -r -- >&2 'zsh-syntax-highlighting: failed loading add-zsh-hook.'
+}
+
+# Load zsh/parameter module if available
+zmodload zsh/parameter 2>/dev/null
+
+autoload -U is-at-least
+source "${ZERO:h}/fast-highlight"
+
+[[ "${+termcap[Co]}" = 1 && "${termcap[Co]}" = "256" ]] && FAST_HIGHLIGHT_STYLES[variable]="fg=112"
+
+-fast-highlight-fill-option-variables
diff --git a/base/zsh/functions.zsh b/base/zsh/functions.zsh
new file mode 100644
index 0000000..d2905ad
--- /dev/null
+++ b/base/zsh/functions.zsh
@@ -0,0 +1,18 @@
+function todo {
+ a=""
+ for i; do a="$a,$i"; done
+ a="{$(echo "$a" | cut -d',' -f2-)}"
+ echo "grep -R --exclude-dir=$a TODO | sed -e 's/.*TODO //;s/ \*\/$//;s/ -->//' | LC_ALL=C sort -u" | zsh
+}
+
+function which {
+ (alias; declare -f) | /usr/bin/which --tty-only --read-alias --read-functions --show-tilde --show-dot $@
+} #export -f which
+
+function trash {
+ mkdir -p "$HOME/.trash"
+ for file in "$@"; do
+ mv "$file" "$HOME/.trash/$(basename $file).$(date +%Y%m%d-%H%M%S)"
+ done
+} # Add this to your crontab:
+# 43 0 * * 3 find ~/.trash -mindepth 1 -mtime +90 -delete
diff --git a/base/zsh/history.zsh b/base/zsh/history.zsh
new file mode 100644
index 0000000..f21023d
--- /dev/null
+++ b/base/zsh/history.zsh
@@ -0,0 +1,15 @@
+if [ -z $HISTFILE ]; then
+ HISTFILE=$HOME/.zsh_history
+fi
+HISTSIZE=100000
+SAVEHIST=100000
+HISTCONTROL=ignoredups
+
+setopt append_history
+setopt extended_history
+setopt hist_expire_dups_first
+setopt hist_ignore_dups # ignore duplication command history list
+setopt hist_ignore_space
+setopt hist_verify
+setopt inc_append_history
+
diff --git a/base/zsh/k.zsh b/base/zsh/k.zsh
new file mode 100644
index 0000000..e7dc9fb
--- /dev/null
+++ b/base/zsh/k.zsh
@@ -0,0 +1,540 @@
+zmodload zsh/datetime
+zmodload -F zsh/stat b:zstat
+
+k () {
+ # ----------------------------------------------------------------------------
+ # Setup
+ # ----------------------------------------------------------------------------
+
+ # Stop stat failing when a directory contains either no files or no hidden files
+ # Track if we _accidentally_ create a new global variable
+ setopt local_options null_glob typeset_silent no_auto_pushd
+
+ # Process options and get files/directories
+ typeset -a o_all o_almost_all o_human o_si o_directory o_no_directory o_no_vcs o_help
+ zparseopts -E -D \
+ a=o_all -all=o_all \
+ A=o_almost_all -almost-all=o_almost_all \
+ d=o_directory -directory=o_directory \
+ h=o_human -human=o_human \
+ -si=o_si \
+ n=o_no_directory -no-directory=o_no_directory \
+ -no-vcs=o_no_vcs \
+ -help=o_help
+
+ # Print Help if bad usage, or they asked for it
+ if [[ $? != 0 || "$o_help" != "" ]]
+ then
+ print -u2 "Usage: k [options] DIR"
+ print -u2 "Options:"
+ print -u2 "\t-a --all list entries starting with ."
+ print -u2 "\t-A --almost-all list all except . and .."
+ print -u2 "\t-d --directory list only directories"
+ print -u2 "\t-n --no-directory do not list directories"
+ print -u2 "\t-h --human show filesizes in human-readable format"
+ print -u2 "\t --si with -h, use powers of 1000 not 1024"
+ print -u2 "\t --no-vcs do not get VCS status (much faster)"
+ print -u2 "\t --help show this help"
+ return 1
+ fi
+
+ # Check for conflicts
+ if [[ "$o_directory" != "" && "$o_no_directory" != "" ]]; then
+ print -u2 "$o_directory and $o_no_directory cannot be used together"
+ return 1
+ fi
+
+ # Check which numfmt available (if any), warn user if not available
+ typeset -i numfmt_available=0
+ typeset -i gnumfmt_available=0
+ if [[ "$o_human" != "" ]]; then
+ if [[ $+commands[numfmt] == 1 ]]; then
+ numfmt_available=1
+ elif [[ $+commands[gnumfmt] == 1 ]]; then
+ gnumfmt_available=1
+ else
+ print -u2 "'numfmt' or 'gnumfmt' command not found, human readable output will not work."
+ print -u2 "\tFalling back to normal file size output"
+ # Set o_human to off
+ o_human=""
+ fi
+ fi
+
+ # Create numfmt local function
+ numfmt_local () {
+ if [[ "$o_si" != "" ]]; then
+ if (( $numfmt_available )); then
+ numfmt --to=si $1
+ elif (( $gnumfmt_available )); then
+ gnumfmt --to=si $1
+ fi
+ else
+ if (( $numfmt_available )); then
+ numfmt --to=iec $1
+ elif (( $gnumfmt_available )); then
+ gnumfmt --to=iec $1
+ fi
+ fi
+ }
+
+ # Set if we're in a repo or not
+ typeset -i INSIDE_WORK_TREE=0
+ if [[ $(command git rev-parse --is-inside-work-tree 2>/dev/null) == true ]]; then
+ INSIDE_WORK_TREE=1
+ fi
+
+ # Setup array of directories to print
+ typeset -a base_dirs
+ typeset base_dir
+
+ if [[ "$@" == "" ]]; then
+ base_dirs=.
+ else
+ base_dirs=($@)
+ fi
+
+
+ # Colors
+ # ----------------------------------------------------------------------------
+ # default colors
+ K_COLOR_DI="0;34" # di:directory
+ K_COLOR_LN="0;35" # ln:symlink
+ K_COLOR_SO="0;32" # so:socket
+ K_COLOR_PI="0;33" # pi:pipe
+ K_COLOR_EX="0;31" # ex:executable
+ K_COLOR_BD="34;46" # bd:block special
+ K_COLOR_CD="34;43" # cd:character special
+ K_COLOR_SU="30;41" # su:executable with setuid bit set
+ K_COLOR_SG="30;46" # sg:executable with setgid bit set
+ K_COLOR_TW="30;42" # tw:directory writable to others, with sticky bit
+ K_COLOR_OW="30;43" # ow:directory writable to others, without sticky bit
+
+ # read colors if osx and $LSCOLORS is defined
+ if [[ $(uname) == 'Darwin' && -n $LSCOLORS ]]; then
+ # Translate OSX/BSD's LSCOLORS so we can use the same here
+ K_COLOR_DI=$(_k_bsd_to_ansi $LSCOLORS[1] $LSCOLORS[2])
+ K_COLOR_LN=$(_k_bsd_to_ansi $LSCOLORS[3] $LSCOLORS[4])
+ K_COLOR_SO=$(_k_bsd_to_ansi $LSCOLORS[5] $LSCOLORS[6])
+ K_COLOR_PI=$(_k_bsd_to_ansi $LSCOLORS[7] $LSCOLORS[8])
+ K_COLOR_EX=$(_k_bsd_to_ansi $LSCOLORS[9] $LSCOLORS[10])
+ K_COLOR_BD=$(_k_bsd_to_ansi $LSCOLORS[11] $LSCOLORS[12])
+ K_COLOR_CD=$(_k_bsd_to_ansi $LSCOLORS[13] $LSCOLORS[14])
+ K_COLOR_SU=$(_k_bsd_to_ansi $LSCOLORS[15] $LSCOLORS[16])
+ K_COLOR_SG=$(_k_bsd_to_ansi $LSCOLORS[17] $LSCOLORS[18])
+ K_COLOR_TW=$(_k_bsd_to_ansi $LSCOLORS[19] $LSCOLORS[20])
+ K_COLOR_OW=$(_k_bsd_to_ansi $LSCOLORS[21] $LSCOLORS[22])
+ fi
+
+ # read colors if linux and $LS_COLORS is defined
+ # if [[ $(uname) == 'Linux' && -n $LS_COLORS ]]; then
+
+ # fi
+
+ # ----------------------------------------------------------------------------
+ # Loop over passed directories and files to display
+ # ----------------------------------------------------------------------------
+ for base_dir in $base_dirs
+ do
+ # ----------------------------------------------------------------------------
+ # Display name if multiple paths were passed
+ # ----------------------------------------------------------------------------
+ if [[ "$#base_dirs" > 1 ]]; then
+ # Only add a newline if its not the first iteration
+ if [[ "$base_dir" != "${base_dirs[1]}" ]]; then
+ print
+ fi
+ print -r "${base_dir}:"
+ fi
+ # ----------------------------------------------------------------------------
+ # Vars
+ # ----------------------------------------------------------------------------
+
+ typeset -a MAX_LEN A RESULTS STAT_RESULTS
+ typeset TOTAL_BLOCKS
+
+ # Get now
+ typeset K_EPOCH="${EPOCHSECONDS:?}"
+
+ typeset -i TOTAL_BLOCKS=0
+
+ MAX_LEN=(0 0 0 0 0 0)
+
+ # Array to hold results from `stat` call
+ RESULTS=()
+
+ # only set once per directory so must be out of the main loop
+ typeset -i IS_GIT_REPO=0
+ typeset GIT_TOPLEVEL
+
+ typeset -i LARGE_FILE_COLOR=196
+ typeset -a SIZELIMITS_TO_COLOR
+ SIZELIMITS_TO_COLOR=(
+ 1024 46 # <= 1kb
+ 2048 82 # <= 2kb
+ 3072 118 # <= 3kb
+ 5120 154 # <= 5kb
+ 10240 190 # <= 10kb
+ 20480 226 # <= 20kb
+ 40960 220 # <= 40kb
+ 102400 214 # <= 100kb
+ 262144 208 # <= 0.25mb || 256kb
+ 524288 202 # <= 0.5mb || 512kb
+ )
+ typeset -i ANCIENT_TIME_COLOR=236 # > more than 2 years old
+ typeset -a FILEAGES_TO_COLOR
+ FILEAGES_TO_COLOR=(
+ 0 196 # < in the future, #spooky
+ 60 255 # < less than a min old
+ 3600 252 # < less than an hour old
+ 86400 250 # < less than 1 day old
+ 604800 244 # < less than 1 week old
+ 2419200 244 # < less than 28 days (4 weeks) old
+ 15724800 242 # < less than 26 weeks (6 months) old
+ 31449600 240 # < less than 1 year old
+ 62899200 238 # < less than 2 years old
+ )
+
+ # ----------------------------------------------------------------------------
+ # Build up list of files/directories to show
+ # ----------------------------------------------------------------------------
+
+ typeset -a show_list
+ show_list=()
+
+ # Check if it even exists
+ if [[ ! -e $base_dir ]]; then
+ print -u2 "k: cannot access $base_dir: No such file or directory"
+
+ # If its just a file, skip the directory handling
+ elif [[ -f $base_dir ]]; then
+ show_list=($base_dir)
+
+ #Directory, add its contents
+ else
+ # Break total blocks of the front of the stat call, then push the rest to results
+ if [[ "$o_all" != "" && "$o_almost_all" == "" && "$o_no_directory" == "" ]]; then
+ show_list+=($base_dir/.)
+ show_list+=($base_dir/..)
+ fi
+
+ if [[ "$o_all" != "" || "$o_almost_all" != "" ]]; then
+ if [[ "$o_directory" != "" ]]; then
+ show_list+=($base_dir/*(D/))
+ elif [[ "$o_no_directory" != "" ]]; then
+ #Use (^/) instead of (.) so sockets and symlinks get displayed
+ show_list+=($base_dir/*(D^/))
+ else
+ show_list+=($base_dir/*(D))
+ fi
+ else
+ if [[ "$o_directory" != "" ]]; then
+ show_list+=($base_dir/*(/))
+ elif [[ "$o_no_directory" != "" ]]; then
+ #Use (^/) instead of (.) so sockets and symlinks get displayed
+ show_list+=($base_dir/*(^/))
+ else
+ show_list+=($base_dir/*)
+ fi
+ fi
+ fi
+
+ # ----------------------------------------------------------------------------
+ # Stat call to get directory listing
+ # ----------------------------------------------------------------------------
+ typeset -i i=1 j=1 k=1
+ typeset -a STATS_PARAMS_LIST
+ typeset fn statvar h
+ typeset -A sv
+
+ STATS_PARAMS_LIST=()
+ for fn in $show_list
+ do
+ statvar="stats_$i"
+ typeset -A $statvar
+ zstat -H $statvar -Lsn -F "%s^%d^%b^%H:%M^%Y" -- "$fn" # use lstat, render mode/uid/gid to strings
+ STATS_PARAMS_LIST+=($statvar)
+ i+=1
+ done
+
+
+ # On each result calculate padding by getting max length on each array member
+ for statvar in "${STATS_PARAMS_LIST[@]}"
+ do
+ sv=("${(@Pkv)statvar}")
+ if [[ ${#sv[mode]} -gt $MAX_LEN[1] ]]; then MAX_LEN[1]=${#sv[mode]} ; fi
+ if [[ ${#sv[nlink]} -gt $MAX_LEN[2] ]]; then MAX_LEN[2]=${#sv[nlink]} ; fi
+ if [[ ${#sv[uid]} -gt $MAX_LEN[3] ]]; then MAX_LEN[3]=${#sv[uid]} ; fi
+ if [[ ${#sv[gid]} -gt $MAX_LEN[4] ]]; then MAX_LEN[4]=${#sv[gid]} ; fi
+
+ if [[ "$o_human" != "" ]]; then
+ h=$(numfmt_local ${sv[size]})
+ if (( ${#h} > $MAX_LEN[5] )); then MAX_LEN[5]=${#h}; fi
+ else
+ if [[ ${#sv[size]} -gt $MAX_LEN[5] ]]; then MAX_LEN[5]=${#sv[size]}; fi
+ fi
+
+ TOTAL_BLOCKS+=$sv[blocks]
+ done
+
+ # Print total block before listing
+ echo "total $TOTAL_BLOCKS"
+
+ # ----------------------------------------------------------------------------
+ # Loop through each line of stat, pad where appropriate and do git dirty checking
+ # ----------------------------------------------------------------------------
+
+ typeset REPOMARKER
+ typeset PERMISSIONS HARDLINKCOUNT OWNER GROUP FILESIZE FILESIZE_OUT DATE NAME SYMLINK_TARGET
+ typeset FILETYPE PER1 PER2 PER3 PERMISSIONS_OUTPUT STATUS
+ typeset TIME_DIFF TIME_COLOR DATE_OUTPUT
+ typeset -i IS_DIRECTORY IS_SYMLINK IS_SOCKET IS_PIPE IS_EXECUTABLE IS_BLOCK_SPECIAL IS_CHARACTER_SPECIAL HAS_UID_BIT HAS_GID_BIT HAS_STICKY_BIT IS_WRITABLE_BY_OTHERS
+ typeset -i COLOR
+
+ k=1
+ for statvar in "${STATS_PARAMS_LIST[@]}"
+ do
+ sv=("${(@Pkv)statvar}")
+
+ # We check if the result is a git repo later, so set a blank marker indication the result is not a git repo
+ REPOMARKER=" "
+ IS_DIRECTORY=0
+ IS_SYMLINK=0
+ IS_SOCKET=0
+ IS_PIPE=0
+ IS_EXECUTABLE=0
+ IS_BLOCK_SPECIAL=0
+ IS_CHARACTER_SPECIAL=0
+ HAS_UID_BIT=0
+ HAS_GID_BIT=0
+ HAS_STICKY_BIT=0
+ IS_WRITABLE_BY_OTHERS=0
+
+ PERMISSIONS="${sv[mode]}"
+ HARDLINKCOUNT="${sv[nlink]}"
+ OWNER="${sv[uid]}"
+ GROUP="${sv[gid]}"
+ FILESIZE="${sv[size]}"
+ DATE=(${(s:^:)sv[mtime]}) # Split date on ^
+ NAME="${sv[name]}"
+ SYMLINK_TARGET="${sv[link]}"
+
+ # Check for file types
+ if [[ -d "$NAME" ]]; then IS_DIRECTORY=1; fi
+ if [[ -L "$NAME" ]]; then IS_SYMLINK=1; fi
+ if [[ -S "$NAME" ]]; then IS_SOCKET=1; fi
+ if [[ -p "$NAME" ]]; then IS_PIPE=1; fi
+ if [[ -x "$NAME" ]]; then IS_EXECUTABLE=1; fi
+ if [[ -b "$NAME" ]]; then IS_BLOCK_SPECIAL=1; fi
+ if [[ -c "$NAME" ]]; then IS_CHARACTER_SPECIAL=1; fi
+ if [[ -u "$NAME" ]]; then HAS_UID_BIT=1; fi
+ if [[ -g "$NAME" ]]; then HAS_GID_BIT=1; fi
+ if [[ -k "$NAME" ]]; then HAS_STICKY_BIT=1; fi
+ if [[ $PERMISSIONS[9] == 'w' ]]; then IS_WRITABLE_BY_OTHERS=1; fi
+
+ # IS_GIT_REPO is a 1 if $NAME is a file/directory in a git repo, OR if $NAME is a git-repo itself
+ # GIT_TOPLEVEL is set to the directory containing the .git folder of a git-repo
+
+ # is this a git repo
+ if [[ "$o_no_vcs" != "" ]]; then
+ IS_GIT_REPO=0
+ GIT_TOPLEVEL=''
+ else
+ if (( IS_DIRECTORY ));
+ then builtin cd -q $NAME 2>/dev/null || builtin cd -q - >/dev/null && IS_GIT_REPO=0 #Say no if we don't have permissions there
+ else builtin cd -q $NAME:a:h 2>/dev/null || builtin cd -q - >/dev/null && IS_GIT_REPO=0
+ fi
+ if [[ $(command git rev-parse --is-inside-work-tree 2>/dev/null) == true ]]; then
+ IS_GIT_REPO=1
+ GIT_TOPLEVEL=$(command git rev-parse --show-toplevel)
+ else
+ IS_GIT_REPO=0
+ fi
+ builtin cd -q - >/dev/null
+ fi
+
+ # Get human readable output if necessary
+ if [[ "$o_human" != "" ]]; then
+ # I hate making this call twice, but its either that, or do a bunch
+ # of calculations much earlier.
+ FILESIZE_OUT=$(numfmt_local $FILESIZE)
+ else
+ FILESIZE_OUT=$FILESIZE
+ fi
+
+ # Pad so all the lines align - firstline gets padded the other way
+ PERMISSIONS="${(r:MAX_LEN[1]:)PERMISSIONS}"
+ HARDLINKCOUNT="${(l:MAX_LEN[2]:)HARDLINKCOUNT}"
+ OWNER="${(l:MAX_LEN[3]:)OWNER}"
+ GROUP="${(l:MAX_LEN[4]:)GROUP}"
+ FILESIZE_OUT="${(l:MAX_LEN[5]:)FILESIZE_OUT}"
+
+ # --------------------------------------------------------------------------
+ # Colour the permissions - TODO
+ # --------------------------------------------------------------------------
+ # Colour the first character based on filetype
+ FILETYPE="${PERMISSIONS[1]}"
+
+ # Permissions Owner
+ PER1="${PERMISSIONS[2,4]}"
+
+ # Permissions Group
+ PER2="${PERMISSIONS[5,7]}"
+
+ # Permissions User
+ PER3="${PERMISSIONS[8,10]}"
+
+ PERMISSIONS_OUTPUT="$FILETYPE$PER1$PER2$PER3"
+
+ # --------------------------------------------------------------------------
+ # Colour the symlinks
+ # --------------------------------------------------------------------------
+
+ # --------------------------------------------------------------------------
+ # Colour Owner and Group
+ # --------------------------------------------------------------------------
+ OWNER=$'\e[38;5;241m'"$OWNER"$'\e[0m'
+ GROUP=$'\e[38;5;241m'"$GROUP"$'\e[0m'
+
+ # --------------------------------------------------------------------------
+ # Colour file weights
+ # --------------------------------------------------------------------------
+ COLOR=LARGE_FILE_COLOR
+ for i j in ${SIZELIMITS_TO_COLOR[@]}
+ do
+ (( FILESIZE <= i )) || continue
+ COLOR=$j
+ break
+ done
+
+ FILESIZE_OUT=$'\e[38;5;'"${COLOR}m$FILESIZE_OUT"$'\e[0m'
+
+ # --------------------------------------------------------------------------
+ # Colour the date and time based on age, then format for output
+ # --------------------------------------------------------------------------
+ # Setup colours based on time difference
+ TIME_DIFF=$(( K_EPOCH - DATE[1] ))
+ TIME_COLOR=$ANCIENT_TIME_COLOR
+ for i j in ${FILEAGES_TO_COLOR[@]}
+ do
+ (( TIME_DIFF < i )) || continue
+ TIME_COLOR=$j
+ break
+ done
+
+ # Format date to show year if more than 6 months since last modified
+ if (( TIME_DIFF < 15724800 )); then
+ DATE_OUTPUT="${DATE[2]} ${(r:5:: :)${DATE[3][0,5]}} ${DATE[4]}"
+ else
+ DATE_OUTPUT="${DATE[2]} ${(r:6:: :)${DATE[3][0,5]}} ${DATE[5]}" # extra space; 4 digit year instead of 5 digit HH:MM
+ fi;
+ DATE_OUTPUT[1]="${DATE_OUTPUT[1]//0/ }" # If day of month begins with zero, replace zero with space
+
+ # Apply colour to formated date
+ DATE_OUTPUT=$'\e[38;5;'"${TIME_COLOR}m${DATE_OUTPUT}"$'\e[0m'
+
+ # --------------------------------------------------------------------------
+ # Colour the repomarker
+ # --------------------------------------------------------------------------
+ if [[ "$o_no_vcs" != "" ]]; then
+ REPOMARKER=""
+ elif (( IS_GIT_REPO != 0)); then
+ # If we're not in a repo, still check each directory if it's a repo, and
+ # then mark appropriately
+ if (( INSIDE_WORK_TREE == 0 )); then
+ if (( IS_DIRECTORY )); then
+ if command git --git-dir="$GIT_TOPLEVEL/.git" --work-tree="${NAME}" diff --stat --quiet --ignore-submodules HEAD &>/dev/null # if dirty
+ then REPOMARKER=$'\e[38;5;46m|\e[0m' # Show a green vertical bar for clean
+ else REPOMARKER=$'\e[0;31m+\e[0m' # Show a red vertical bar if dirty
+ fi
+ fi
+ else
+ if (( IS_DIRECTORY )); then
+ # If the directory isn't ignored or clean, we'll just say it's dirty
+ if command git check-ignore --quiet ${NAME} 2>/dev/null; then STATUS='!!'
+ elif command git diff --stat --quiet --ignore-submodules ${NAME} 2> /dev/null; then STATUS='';
+ else STATUS=' M'
+ fi
+ else
+ # File
+ STATUS=$(command git status --porcelain --ignored --untracked-files=normal $GIT_TOPLEVEL/${${${NAME:a}##$GIT_TOPLEVEL}#*/})
+ fi
+ STATUS=${STATUS[1,2]}
+ if [[ $STATUS == ' M' ]]; then REPOMARKER=$'\e[0;31m+\e[0m'; # Tracked & Dirty
+ elif [[ $STATUS == 'M ' ]]; then REPOMARKER=$'\e[38;5;082m+\e[0m'; # Tracked & Dirty & Added
+ elif [[ $STATUS == '??' ]]; then REPOMARKER=$'\e[38;5;214m+\e[0m'; # Untracked
+ elif [[ $STATUS == '!!' ]]; then REPOMARKER=$'\e[38;5;238m|\e[0m'; # Ignored
+ elif [[ $STATUS == 'A ' ]]; then REPOMARKER=$'\e[38;5;082m+\e[0m'; # Added
+ else REPOMARKER=$'\e[38;5;082m|\e[0m'; # Good
+ fi
+ fi
+ fi
+
+ # --------------------------------------------------------------------------
+ # Colour the filename
+ # --------------------------------------------------------------------------
+ # Unfortunately, the choices for quoting which escape ANSI color sequences are q & qqqq; none of q- qq qqq work.
+ # But we don't want to quote '.'; so instead we escape the escape manually and use q-
+ NAME="${${NAME##*/}//$'\e'/\\e}" # also propagate changes to SYMLINK_TARGET below
+
+ if [[ $IS_DIRECTORY == 1 ]]; then
+ if [[ $IS_WRITABLE_BY_OTHERS == 1 ]]; then
+ if [[ $HAS_STICKY_BIT == 1 ]]; then
+ NAME=$'\e['"$K_COLOR_TW"'m'"$NAME"$'\e[0m';
+ fi
+ NAME=$'\e['"$K_COLOR_OW"'m'"$NAME"$'\e[0m';
+ fi
+ NAME=$'\e['"$K_COLOR_DI"'m'"$NAME"$'\e[0m';
+ elif [[ $IS_SYMLINK == 1 ]]; then NAME=$'\e['"$K_COLOR_LN"'m'"$NAME"$'\e[0m';
+ elif [[ $IS_SOCKET == 1 ]]; then NAME=$'\e['"$K_COLOR_SO"'m'"$NAME"$'\e[0m';
+ elif [[ $IS_PIPE == 1 ]]; then NAME=$'\e['"$K_COLOR_PI"'m'"$NAME"$'\e[0m';
+ elif [[ $HAS_UID_BIT == 1 ]]; then NAME=$'\e['"$K_COLOR_SU"'m'"$NAME"$'\e[0m';
+ elif [[ $HAS_GID_BIT == 1 ]]; then NAME=$'\e['"$K_COLOR_SG"'m'"$NAME"$'\e[0m';
+ elif [[ $IS_EXECUTABLE == 1 ]]; then NAME=$'\e['"$K_COLOR_EX"'m'"$NAME"$'\e[0m';
+ elif [[ $IS_BLOCK_SPECIAL == 1 ]]; then NAME=$'\e['"$K_COLOR_BD"'m'"$NAME"$'\e[0m';
+ elif [[ $IS_CHARACTER_SPECIAL == 1 ]]; then NAME=$'\e['"$K_COLOR_CD"'m'"$NAME"$'\e[0m';
+ fi
+
+ # --------------------------------------------------------------------------
+ # Format symlink target
+ # --------------------------------------------------------------------------
+ if [[ $SYMLINK_TARGET != "" ]]; then SYMLINK_TARGET="-> ${SYMLINK_TARGET//$'\e'/\\e}"; fi
+
+ # --------------------------------------------------------------------------
+ # Display final result
+ # --------------------------------------------------------------------------
+ print -r -- "$PERMISSIONS_OUTPUT $HARDLINKCOUNT $OWNER $GROUP $FILESIZE_OUT $DATE_OUTPUT $REPOMARKER $NAME $SYMLINK_TARGET"
+
+ k=$((k+1)) # Bump loop index
+ done
+ done
+}
+
+_k_bsd_to_ansi() {
+ local foreground=$1 background=$2 foreground_ansi background_ansi
+ case $foreground in
+ a) foreground_ansi=30;;
+ b) foreground_ansi=31;;
+ c) foreground_ansi=32;;
+ d) foreground_ansi=33;;
+ e) foreground_ansi=34;;
+ f) foreground_ansi=35;;
+ g) foreground_ansi=36;;
+ h) foreground_ansi=37;;
+ x) foreground_ansi=0;;
+ esac
+ case $background in
+ a) background_ansi=40;;
+ b) background_ansi=41;;
+ c) background_ansi=42;;
+ d) background_ansi=43;;
+ e) background_ansi=44;;
+ f) background_ansi=45;;
+ g) background_ansi=46;;
+ h) background_ansi=47;;
+ x) background_ansi=0;;
+ esac
+ printf "%s;%s" $background_ansi $foreground_ansi
+}
+
+# http://upload.wikimedia.org/wikipedia/en/1/15/Xterm_256color_chart.svg
+# vim: set ts=2 sw=2 ft=zsh et :
diff --git a/base/zsh/prompt.zsh b/base/zsh/prompt.zsh
new file mode 100644
index 0000000..2e4dca9
--- /dev/null
+++ b/base/zsh/prompt.zsh
@@ -0,0 +1,6 @@
+if [[ `tty | sed -ne "\_^/dev/tty[0-9]*_p"` ]]; then
+ PROMPT='%F{0}%B[ %F{6}%b%M %B%1~ %F{0}]%(!.#.$)%f%b '
+else
+ autoload -U promptinit && promptinit
+ prompt pure
+fi
diff --git a/base/zsh/prompt_pure_setup b/base/zsh/prompt_pure_setup
new file mode 100644
index 0000000..d9b7f2d
--- /dev/null
+++ b/base/zsh/prompt_pure_setup
@@ -0,0 +1,385 @@
+# Quickref
+# git:
+# %b => current branch
+# %a => current action (rebase/merge)
+# prompt:
+# %F => color dict
+# %f => reset color
+# %~ => current path
+# %* => time
+# %n => username
+# %m => shortname host
+# %(?..) => prompt conditional - %(condition.true.false)
+# terminal codes:
+# \e7 => save cursor position
+# \e[2A => move cursor 2 lines up
+# \e[1G => go to position 1 in terminal
+# \e8 => restore cursor position
+# \e[K => clears everything after the cursor on the current line
+# \e[2K => clear everything on the current line
+
+PURER_PROMPT_COMMAND_COUNT=0
+STATUS_COLOR=6
+
+# turns seconds into human readable time
+# 165392 => 1d 21h 56m 32s
+# https://github.com/sindresorhus/pretty-time-zsh
+prompt_pure_human_time_to_var() {
+ local human=" [" total_seconds=$1 var=$2
+ local days=$(( total_seconds / 60 / 60 / 24 ))
+ local hours=$(( total_seconds / 60 / 60 % 24 ))
+ local minutes=$(( total_seconds / 60 % 60 ))
+ local seconds=$(( total_seconds % 60 ))
+ (( days > 0 )) && human+="${days}d "
+ (( hours > 0 )) && human+="${hours}h "
+ (( minutes > 0 )) && human+="${minutes}m "
+ human+="${seconds}s]"
+
+ # store human readable time in variable as specified by caller
+ typeset -g "${var}"="${human}"
+}
+
+# stores (into prompt_pure_cmd_exec_time) the exec time of the last command if set threshold was exceeded
+prompt_pure_check_cmd_exec_time() {
+ integer elapsed
+ (( elapsed = EPOCHSECONDS - ${prompt_pure_cmd_timestamp:-$EPOCHSECONDS} ))
+ prompt_pure_cmd_exec_time=
+ (( elapsed > ${PURE_CMD_MAX_EXEC_TIME:=15} )) && {
+ prompt_pure_human_time_to_var $elapsed "prompt_pure_cmd_exec_time"
+ }
+}
+
+prompt_pure_clear_screen() {
+ # enable output to terminal
+ zle -I
+ # clear screen and move cursor to (0, 0)
+ print -n '\e[2J\e[0;0H'
+ # reset command count to zero so we don't start with a blank line
+ PURER_PROMPT_COMMAND_COUNT=0
+ # print preprompt
+ prompt_pure_preprompt_render precmd
+}
+
+# set STATUS_COLOR: cyan for "insert", green for "normal" mode.
+prompt_purer_vim_mode() {
+ STATUS_COLOR="${${KEYMAP/vicmd/16}/(main|viins)/6}"
+ prompt_pure_preprompt_render
+}
+
+prompt_pure_set_title() {
+ # emacs terminal does not support settings the title
+ (( ${+EMACS} )) && return
+
+ # tell the terminal we are setting the title
+ print -n '\e]0;'
+ # show hostname if connected through ssh
+ [[ -n $SSH_CONNECTION ]] && print -Pn '(%m) '
+ case $1 in
+ expand-prompt)
+ print -Pn $2;;
+ ignore-escape)
+ print -rn $2;;
+ esac
+ # end set title
+ print -n '\a'
+}
+
+prompt_pure_preexec() {
+ # attempt to detect and prevent prompt_pure_async_git_fetch from interfering with user initiated git or hub fetch
+ [[ $2 =~ (git|hub)\ .*(pull|fetch) ]] && async_flush_jobs 'prompt_pure'
+
+ prompt_pure_cmd_timestamp=$EPOCHSECONDS
+
+ # shows the current dir and executed command in the title while a process is active
+ prompt_pure_set_title 'ignore-escape' "$PWD:t: $2"
+}
+
+# string length ignoring ansi escapes
+prompt_pure_string_length_to_var() {
+ local str=$1 var=$2 length
+ # perform expansion on str and check length
+ length=$(( ${#${(S%%)str//(\%([KF1]|)\{*\}|\%[Bbkf])}} ))
+
+ # store string length in variable as specified by caller
+ typeset -g "${var}"="${length}"
+}
+
+prompt_pure_preprompt_render() {
+ # store the current prompt_subst setting so that it can be restored later
+ local prompt_subst_status=$options[prompt_subst]
+
+ # make sure prompt_subst is unset to prevent parameter expansion in preprompt
+ setopt local_options no_prompt_subst
+
+ # check that no command is currently running, the preprompt will otherwise be rendered in the wrong place
+ [[ -n ${prompt_pure_cmd_timestamp+x} && "$1" != "precmd" ]] && return
+
+ # set color for git branch/dirty status, change color if dirty checking has been delayed
+ local git_color=20
+ [[ -n ${prompt_pure_git_last_dirty_check_timestamp+x} ]] && git_color=1
+
+ # construct preprompt
+ local preprompt=""
+
+ # add a newline between commands
+ FIRST_COMMAND_THRESHOLD=1
+ if [[ "$PURER_PROMPT_COMMAND_COUNT" -gt "$FIRST_COMMAND_THRESHOLD" ]]; then
+ preprompt+=$'\n'
+ fi
+
+ # host ID
+ if [[ "$PROMPT_HOST_COLOR" ]]; then
+ preprompt+="%b%F{black}%K{$PROMPT_HOST_COLOR} "
+ [[ "$PROMPT_SHORT_HOSTNAME" ]] && preprompt+="$PROMPT_SHORT_HOSTNAME "
+ preprompt+="%F{$PROMPT_HOST_COLOR}%K{18}%f"
+ fi
+ preprompt+="%K{18} "
+ # directory, colored by vim status
+ preprompt+="%B%F{$STATUS_COLOR}%c%f%b"
+ # git info
+ preprompt+="%F{$git_color}${vcs_info_msg_0_}${prompt_pure_git_dirty}%f"
+ # git pull/push arrows
+ preprompt+="%F{cyan}${prompt_pure_git_arrows}%f"
+ # username and machine if applicable
+ #preprompt+=$prompt_pure_username
+ # execution time
+ preprompt+="%F{20}${prompt_pure_cmd_exec_time}%f"
+ # end with symbol, colored by previous command exit code
+ # local symbol_color="%(?.${PURE_PROMPT_SYMBOL_COLOR:-magenta}.red)"
+ # preprompt+=" %F{$symbol_color}${PURE_PROMPT_SYMBOL:-❯}%f"
+ preprompt+=" %F{18}%(?.%k.%K{1}%F{1}%k)%f"
+ # 
+
+ preprompt+=" "
+
+ # make sure prompt_pure_last_preprompt is a global array
+ typeset -g -a prompt_pure_last_preprompt
+
+ PROMPT="$preprompt"
+
+ # if executing through precmd, do not perform fancy terminal editing
+ if [[ "$1" != "precmd" ]]; then
+ # only redraw if the expanded preprompt has changed
+ # [[ "${prompt_pure_last_preprompt[2]}" != "${(S%%)preprompt}" ]] || return
+
+ # redraw prompt (also resets cursor position)
+ zle && zle .reset-prompt
+
+ setopt no_prompt_subst
+ fi
+
+ # store both unexpanded and expanded preprompt for comparison
+ prompt_pure_last_preprompt=("$preprompt" "${(S%%)preprompt}")
+}
+
+prompt_pure_precmd() {
+ # check exec time and store it in a variable
+ prompt_pure_check_cmd_exec_time
+
+ # by making sure that prompt_pure_cmd_timestamp is defined here the async functions are prevented from interfering
+ # with the initial preprompt rendering
+ prompt_pure_cmd_timestamp=
+
+ # shows the full path in the title
+ prompt_pure_set_title 'expand-prompt' '%~'
+
+ # get vcs info
+ vcs_info
+
+ # preform async git dirty check and fetch
+ prompt_pure_async_tasks
+
+ # Increment command counter
+ PURER_PROMPT_COMMAND_COUNT=$((PURER_PROMPT_COMMAND_COUNT+1))
+
+ # print the preprompt
+ prompt_pure_preprompt_render "precmd"
+
+ # remove the prompt_pure_cmd_timestamp, indicating that precmd has completed
+ unset prompt_pure_cmd_timestamp
+}
+
+# fastest possible way to check if repo is dirty
+prompt_pure_async_git_dirty() {
+ setopt localoptions noshwordsplit
+ local untracked_dirty=$1 dir=$2
+
+ # use cd -q to avoid side effects of changing directory, e.g. chpwd hooks
+ builtin cd -q $dir
+
+ if [[ $untracked_dirty = 0 ]]; then
+ command git diff --no-ext-diff --quiet --exit-code
+ else
+ test -z "$(command git status --porcelain --ignore-submodules -unormal)"
+ fi
+
+ return $?
+}
+
+prompt_pure_async_git_fetch() {
+ setopt localoptions noshwordsplit
+ # use cd -q to avoid side effects of changing directory, e.g. chpwd hooks
+ builtin cd -q $1
+
+ # set GIT_TERMINAL_PROMPT=0 to disable auth prompting for git fetch (git 2.3+)
+ export GIT_TERMINAL_PROMPT=0
+ # set ssh BachMode to disable all interactive ssh password prompting
+ export GIT_SSH_COMMAND=${GIT_SSH_COMMAND:-"ssh -o BatchMode=yes"}
+
+ command git -c gc.auto=0 fetch &>/dev/null || return 1
+
+ # check arrow status after a successful git fetch
+ prompt_pure_async_git_arrows $1
+}
+
+prompt_pure_async_git_arrows() {
+ setopt localoptions noshwordsplit
+ builtin cd -q $1
+ command git rev-list --left-right --count HEAD...@'{u}'
+}
+
+prompt_pure_async_tasks() {
+ setopt localoptions noshwordsplit
+
+ # initialize async worker
+ ((!${prompt_pure_async_init:-0})) && {
+ async_start_worker "prompt_pure" -u -n
+ async_register_callback "prompt_pure" prompt_pure_async_callback
+ prompt_pure_async_init=1
+ }
+
+ # store working_tree without the "x" prefix
+ local working_tree="${vcs_info_msg_1_#x}"
+
+ # check if the working tree changed (prompt_pure_current_working_tree is prefixed by "x")
+ if [[ ${prompt_pure_current_working_tree#x} != $working_tree ]]; then
+ # stop any running async jobs
+ async_flush_jobs "prompt_pure"
+
+ # reset git preprompt variables, switching working tree
+ unset prompt_pure_git_dirty
+ unset prompt_pure_git_last_dirty_check_timestamp
+ prompt_pure_git_arrows=
+
+ # set the new working tree and prefix with "x" to prevent the creation of a named path by AUTO_NAME_DIRS
+ prompt_pure_current_working_tree="x${working_tree}"
+ fi
+
+ # only perform tasks inside git working tree
+ [[ -n $working_tree ]] || return
+
+ async_job "prompt_pure" prompt_pure_async_git_arrows $working_tree
+
+ # do not preform git fetch if it is disabled or working_tree == HOME
+ if (( ${PURE_GIT_PULL:-1} )) && [[ $working_tree != $HOME ]]; then
+ # tell worker to do a git fetch
+ async_job "prompt_pure" prompt_pure_async_git_fetch $working_tree
+ fi
+
+ # if dirty checking is sufficiently fast, tell worker to check it again, or wait for timeout
+ integer time_since_last_dirty_check=$(( EPOCHSECONDS - ${prompt_pure_git_last_dirty_check_timestamp:-0} ))
+ if (( time_since_last_dirty_check > ${PURE_GIT_DELAY_DIRTY_CHECK:-1800} )); then
+ unset prompt_pure_git_last_dirty_check_timestamp
+ # check check if there is anything to pull
+ async_job "prompt_pure" prompt_pure_async_git_dirty ${PURE_GIT_UNTRACKED_DIRTY:-1} $working_tree
+ fi
+}
+
+prompt_pure_check_git_arrows() {
+ setopt localoptions noshwordsplit
+ local arrows left=${1:-0} right=${2:-0}
+
+ (( right > 0 )) && arrows+=${PURE_GIT_DOWN_ARROW:-⇣}
+ (( left > 0 )) && arrows+=${PURE_GIT_UP_ARROW:-⇡}
+
+ [[ -n $arrows ]] || return
+ typeset -g REPLY=" $arrows"
+}
+
+prompt_pure_async_callback() {
+ setopt localoptions noshwordsplit
+ local job=$1 code=$2 output=$3 exec_time=$4
+
+ case $job in
+ prompt_pure_async_git_dirty)
+ local prev_dirty=$prompt_pure_git_dirty
+ if (( code == 0 )); then
+ prompt_pure_git_dirty=
+ else
+ prompt_pure_git_dirty="*"
+ fi
+
+ [[ $prev_dirty != $prompt_pure_git_dirty ]] && prompt_pure_preprompt_render
+
+ # When prompt_pure_git_last_dirty_check_timestamp is set, the git info is displayed in a different color.
+ # To distinguish between a "fresh" and a "cached" result, the preprompt is rendered before setting this
+ # variable. Thus, only upon next rendering of the preprompt will the result appear in a different color.
+ (( $exec_time > 2 )) && prompt_pure_git_last_dirty_check_timestamp=$EPOCHSECONDS
+ ;;
+ prompt_pure_async_git_fetch|prompt_pure_async_git_arrows)
+ # prompt_pure_async_git_fetch executes prompt_pure_async_git_arrows
+ # after a successful fetch.
+ if (( code == 0 )); then
+ local REPLY
+ prompt_pure_check_git_arrows ${(ps:\t:)output}
+ if [[ $prompt_pure_git_arrows != $REPLY ]]; then
+ prompt_pure_git_arrows=$REPLY
+ prompt_pure_preprompt_render
+ fi
+ fi
+ ;;
+ esac
+}
+
+prompt_pure_setup() {
+ # prevent percentage showing up
+ # if output doesn't end with a newline
+ export PROMPT_EOL_MARK=''
+
+ # prompt_opts=(subst percent)
+
+ # borrowed from promptinit, sets the prompt options in case pure was not
+ # initialized via promptinit.
+ # setopt noprompt{bang,cr,percent,subst} "prompt${^prompt_opts[@]}"
+
+ zmodload zsh/datetime
+ zmodload zsh/zle
+ zmodload zsh/parameter
+
+ autoload -Uz add-zsh-hook
+ autoload -Uz vcs_info
+ autoload -Uz async && async
+
+ add-zsh-hook precmd prompt_pure_precmd
+ add-zsh-hook preexec prompt_pure_preexec
+
+ zstyle ':vcs_info:*' enable git
+ zstyle ':vcs_info:*' use-simple true
+ # only export two msg variables from vcs_info
+ zstyle ':vcs_info:*' max-exports 2
+ # vcs_info_msg_0_ = ' %b' (for branch)
+ # vcs_info_msg_1_ = 'x%R' git top level (%R), x-prefix prevents creation of a named path (AUTO_NAME_DIRS)
+ zstyle ':vcs_info:git*' formats ' %b' 'x%R'
+ zstyle ':vcs_info:git*' actionformats ' %b|%a' 'x%R'
+
+ # if the user has not registered a custom zle widget for clear-screen,
+ # override the builtin one so that the preprompt is displayed correctly when
+ # ^L is issued.
+ if [[ $widgets[clear-screen] == 'builtin' ]]; then
+ zle -N clear-screen prompt_pure_clear_screen
+ fi
+
+ # register custom function for vim-mode
+ zle -N zle-keymap-select prompt_purer_vim_mode
+
+ # show username@host if logged in through SSH
+ [[ "$SSH_CONNECTION" != '' ]] && prompt_pure_username=' %F{242}%n@%m%f'
+
+ # show username@host if root, with username in white
+ [[ $UID -eq 0 ]] && prompt_pure_username=' %F{white}%n%f%F{242}@%m%f'
+
+ # create prompt
+ prompt_pure_preprompt_render 'precmd'
+}
+
+prompt_pure_setup "$@"
diff --git a/base/zsh/stack.zsh b/base/zsh/stack.zsh
new file mode 100644
index 0000000..444b88d
--- /dev/null
+++ b/base/zsh/stack.zsh
@@ -0,0 +1,3 @@
+DIRSTACKSIZE=8
+setopt autocd autopushd pushdminus pushdsilent pushdtohome
+alias dh='dirs -v'
diff --git a/base/zsh/tipz.zsh b/base/zsh/tipz.zsh
new file mode 100644
index 0000000..bb1e224
--- /dev/null
+++ b/base/zsh/tipz.zsh
@@ -0,0 +1,84 @@
+###
+# Search the defined aliases for a match
+###
+function _tipz_find_match() {
+ local bits alias command result=""
+ local -a aliases args; args="$@"
+
+ # Load the current aliases into an array
+ local oldIFS=$IFS
+ IFS=$'\n' aliases=($(alias))
+ IFS=$oldIFS
+
+ # Loop through each of the aliases
+ for line in "${aliases[@]}"; do
+ # Split the line on '=' to separate the command
+ # and its alias
+ bits=("${(s/=/)line}")
+ alias=$bits[1]
+ command=$bits[2]
+
+ # Create a regex that finds an exact match for
+ # the current argument string
+ args="${(@)args[@]}"
+ local pattern=$'^[\'\"]?'${args//([\{\}\(\)\[\]\*\?\:\\\.\|])/\\\$1}$'[\'\"]?$'
+
+ # Check if the command matches the regex
+ if [[ "$command" =~ $pattern ]]; then
+ # Ensure that the longest matching command is stored
+ if [[ ${#command} > ${#result} ]]; then
+ result=$alias
+ fi
+ fi
+ done
+
+ # If a result has been found, output it
+ if [[ -n $result ]]; then
+ echo $result
+ return 0
+ fi
+
+ return 1
+}
+
+###
+# Search for alias tips for the currently executing command
+###
+function _tipz_process {
+ local -a cmd; cmd=($@)
+ integer i=$(( ${#cmd} + 1 ))
+
+ # Loop for the length of the argument list, knocking
+ # an argument from the end of the list each time, and
+ # then using the remaining arguments to search for aliases
+ while [[ $i > 0 ]]; do
+ # Check the current string for a match
+ result=$(_tipz_find_match "${(@)cmd:0:$i}")
+
+ # If the search exited successfully,
+ # output the tip to the user
+ if [[ $? -eq 0 ]]; then
+ print -P "%B%F{8}Alias tip: %b$result ${(@)cmd:$i}%f"
+ return 0
+ fi
+
+ # Decrement the counter
+ i=$(( i - 1 ))
+ done
+
+ return 1
+}
+
+###
+# A small function to filter out strange arguments
+# sent from the add-zsh-hook preexec hook
+###
+function _tipz_prexec() {
+ _tipz_process $(echo $1)
+}
+
+###
+# Register the preexec hook
+###
+autoload -Uz add-zsh-hook
+add-zsh-hook preexec _tipz_prexec