aboutsummaryrefslogtreecommitdiff
path: root/base/.zsh
diff options
context:
space:
mode:
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, 0 insertions, 2688 deletions
diff --git a/base/.zsh/aliases.zsh b/base/.zsh/aliases.zsh
deleted file mode 100644
index 21544af..0000000
--- a/base/.zsh/aliases.zsh
+++ /dev/null
@@ -1,31 +0,0 @@
-# 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
deleted file mode 100644
index d11a99a..0000000
--- a/base/.zsh/async
+++ /dev/null
@@ -1,493 +0,0 @@
-#!/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
deleted file mode 100644
index 9c8e32b..0000000
--- a/base/.zsh/colors.zsh
+++ /dev/null
@@ -1,3 +0,0 @@
-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
deleted file mode 100644
index f9e452d..0000000
--- a/base/.zsh/completion.zsh
+++ /dev/null
@@ -1,81 +0,0 @@
-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
deleted file mode 100644
index ce25627..0000000
--- a/base/.zsh/correction.zsh
+++ /dev/null
@@ -1,7 +0,0 @@
-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
deleted file mode 100644
index 05843dc..0000000
--- a/base/.zsh/fancy-man.zsh
+++ /dev/null
@@ -1,32 +0,0 @@
-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
deleted file mode 100644
index eb96ab0..0000000
--- a/base/.zsh/fasd.zsh
+++ /dev/null
@@ -1,3 +0,0 @@
-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
deleted file mode 100644
index 70c8867..0000000
--- a/base/.zsh/fast-syntax-highlighting/fast-highlight
+++ /dev/null
@@ -1,715 +0,0 @@
-# -------------------------------------------------------------------------------------------------
-# 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
deleted file mode 100644
index 235d425..0000000
--- a/base/.zsh/fast-syntax-highlighting/fast-syntax-highlighting.plugin.zsh
+++ /dev/null
@@ -1,272 +0,0 @@
-# -------------------------------------------------------------------------------------------------
-# 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
deleted file mode 100644
index d2905ad..0000000
--- a/base/.zsh/functions.zsh
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index f21023d..0000000
--- a/base/.zsh/history.zsh
+++ /dev/null
@@ -1,15 +0,0 @@
-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
deleted file mode 100644
index e7dc9fb..0000000
--- a/base/.zsh/k.zsh
+++ /dev/null
@@ -1,540 +0,0 @@
-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
deleted file mode 100644
index 2e4dca9..0000000
--- a/base/.zsh/prompt.zsh
+++ /dev/null
@@ -1,6 +0,0 @@
-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
deleted file mode 100644
index d9b7f2d..0000000
--- a/base/.zsh/prompt_pure_setup
+++ /dev/null
@@ -1,385 +0,0 @@
-# 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
deleted file mode 100644
index 444b88d..0000000
--- a/base/.zsh/stack.zsh
+++ /dev/null
@@ -1,3 +0,0 @@
-DIRSTACKSIZE=8
-setopt autocd autopushd pushdminus pushdsilent pushdtohome
-alias dh='dirs -v'
diff --git a/base/.zsh/tipz.zsh b/base/.zsh/tipz.zsh
deleted file mode 100644
index bb1e224..0000000
--- a/base/.zsh/tipz.zsh
+++ /dev/null
@@ -1,84 +0,0 @@
-###
-# 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