dotfiles/.config/shell/functions

# Shell aliases & functions for Zsh, almost all work for Bash too
# zsh helpers {{{1
if test "$ZSH_NAME" = "zsh"
then
	alias -g ___='"$(eval "$(fc -ln -1)" | tail -n 1)"'
	alias -g G="| grp"
	alias -g X="| xargs -d '\n'"
	alias -g X1="| xargs -d '\n' -n 1"
	alias -g XC="| xclip -selection clipboard"
	alias -g L="--color=always | ${PAGER:-less}"

	# Edit zsh completion
	edcomp() {
		file=$(echo "$1" | sed 's/^\([^_]\)/_\1/')
		$EDITOR "${fpath[-1]}/$file"
		unfunction "$file" && compinit
	}
	compdef "_files -W ${fpath[-1]}/" edcomp
	
	writecompletion() {
		echo "#compdef $1" > "_$1"
		$EDITOR "_$1"
	}
else
	compdef() { true; }
fi

# data directory aliases {{{1
xdh="$XDG_DATA_HOME"
xch="$XDG_CONFIG_HOME"
xsh="$XDG_STATE_HOME"
if test -d "$DATA"; then
	da=$(builtin cd $DATA/_* && pwd)
	d1=$(builtin cd $DATA/1* && pwd)
	d2=$(builtin cd $DATA/2* && pwd)
	d3=$(builtin cd $DATA/3* && pwd)
	d4=$(builtin cd $DATA/4* && pwd)
	dd="$d4/downloads"
fi 2>/dev/null

ulimit -c unlimited # Enable core dumps

which lsb_release >/dev/null && export DIST=$(lsb_release --id | cut -d'	' -f2) || true

unalias rd 2>/dev/null

# System help {{{1

alias h='help'
compdef help=man
alias info='info --vi-keys'

xtrace() {
	set -x
	"$@"
	set +x
}

# Shows source code for command, resolving nested aliases
wh() {
	res=$(which "$@")
	if expr "$res" : "${@:$#}: aliased to" >/dev/null && ! expr "$res" : ".*builtin" >/dev/null
	then echo "$res" | bat --style=plain --language=sh &&
		tool="$(echo "$res" | cut -d' ' -f$(expr 5 '&' "$res" : ".*to \(sudo\|noglob\) " '|' 4) | cut -d'(' -f2)"
		wh $(test $tool = $1 && echo "-p") $tool
		# use command which for other shells
	else test -r "$res" && b "$res" || echo "$res" | bat --style=plain --language=sh
	fi
}
compdef wh=which

pathadd() {
	local IFS=":"
	local result="$@"
	unset IFS
	cat /etc/environment | head -1 | cut -d'"' -f2 | tr ":" "\n" | while read v
			do [[ " $@ " =~ " $v " ]] || result+=":$v"
		done
	echo PATH=\"${result}\"\\n$(cat /etc/environment | tail -n +2) | sudo tee /etc/environment
}

# ZSH completion and stuff {{{1
alias rs="reset && source $HOME/.zshenv && exec $SHELL"
alias hist='print -z $(history | tac | fzf --tiebreak=index --bind='"'"'del:execute(sed "\
;$(echo {4..})$
d" -i.bak $HISTFILE)'"'"' | sed "s|^ \+||" | cut -d" " -f5-)'

# Edit shell config files
# Exit code 1 - no change, 2 - file not found
CONFIG_SHELL_FUNCTIONS="${BASH_SOURCE[0]:-${(%):-%x}}"
edshell() {
	case $1 in
		("") file="$CONFIG_SHELL_FUNCTIONS";;
		(zsh) file="$CONFIG_ZSH/.zshrc";;
		(env) file="$HOME/.zshenv";;
		(-f) grepfile="$(grep --recursive "\(^$2()\|alias $2=\)" $CONFIG_SHELLS -n -m 1)"
			file="$(echo "$grepfile" | cut -d':' -f1)"
			line="$(echo "$grepfile" | cut -d':' -f2)"
			test -f "$file" || return 2;;
		(*) file="$(find $CONFIG_SHELLS -name "$1*" | head -1 | grep . || echo "$CONFIG_SHELLS/$1")";;
	esac
	test -f "$file" && checksum="$(md5sum "$file")"
	$EDITOR "$(test "$line" && echo "+normal! ${line}ggzx" || echo "--")" "${file%:*}"
	test -s "$file" || return 1
	test "$checksum" != "$(md5sum $file)" && rs
}

# Edit a file in the PATH
edbin() {
	f="$(which $1 2>/dev/null)" && test -f "$f" && edit "$f" ||
		edshell -f "$1"; test $? != 2 ||
		edit "$HOME/.local/bin/scripts/$1"
}

# Task management & time tracking {{{1
t() {
	if test "$#" -eq 0 && which tn >/dev/null
	then tn
	else
		if test "$1" = "do"
		then shift && test "$1" -gt 0 2>/dev/null && task mod sched:today "$@" || task add sched:today "$@"
		else task "$@"
		fi
	fi
}
alias tw='timew'
# Create a temporary timewarrior database for testing
alias twtest='( cp -r "$TIMEWARRIORDB" /tmp/tw-bak && TIMEWARRIORDB=/tmp/timewarriordb-test/$(date +%s) && mkdir -p "$TIMEWARRIORDB"/data && :> "$TIMEWARRIORDB"/timewarrior.cfg && $SHELL )'

# Systemd {{{1

alias syslog='less +F /var/log/syslog'

alias sc='sudo systemctl'
alias sce='sudo systemctl enable --now'
alias scd='sudo systemctl disable --now'
scs() {
	systemctl --user status "*$1*" "$1" ||
		sudo systemctl status "*$1*" "$1"
}
alias scu='systemctl --user'
alias scue='systemctl --user enable --now'
alias scud='systemctl --user disable --now'

# Reload or restart matching systemctl service
scr() {
	systemctl --user reload "$1" ||
		sudo systemctl reload "$1" ||
		systemctl --user restart "$1" ||
		sudo systemctl restart "$1"
}

# Restart matching systemctl service with time for adjustments inbetween
scb() {
	systemctl --user stop --show-transaction "$1"
	sudo systemctl stop --show-transaction "$1"
	read
	systemctl --user start --show-transaction "$1"
	sudo systemctl start --show-transaction "$1"
}

alias jcl='sudo SYSTEMD_LESS=FRKi journalctl --boot --no-hostname -e'
alias jc='jcl -u'
alias jcj='jcl -o json-pretty -u'

# Applications {{{1

# Shorthands
alias v='edit'
alias st='synct'
alias expr='noglob expr'
alias get='noglob ='
alias kc='kdeconnect-cli --refresh && kdeconnect-cli --list-devices'

# Shortcuts
alias logoff="loginctl terminate-user $USER"
alias calb='rlwrap -a bc -l'
alias dt='python -c "import time;print(time.asctime(time.localtime()))"'

# Process
alias println='printf "\n"'
alias dedup='awk '"'"'!a[$0]++'"'"
alias lar='last | tac'
alias lst='( last; last -f /var/log/wtmp.1 ) | grep -v "pts/" | tac | less +G'

u() {
	topgrade --only emacs --yes
	which pacman-mirrors >/dev/null &&
		sudo pacman-mirrors --geoip &&
		sudo pacman -Syy
	topgrade
}

# Remote
alias delta="sc restart openvpn-client@deltaPeak.service"
sshl() {
	lemonade server -allow 127.0.0.1 &
	file="/var/tmp/ssh-$1"
	if test ! -e "$file"; then
		ssh-copy-id -i "$(ssh -G "$1" | grep "^identityfile " | head -1 | cut -d " " -f2- | sed "s|^~|$HOME|")" "$1" && touch "$file"
		TERM=xterm-256color kitty +kitten ssh -R 2489:127.0.0.1:2489 "$@"
	else TERM=xterm-256color ssh "$@"
	fi
}

# Listen to loopback of mic
alias listen='pactl load-module module-loopback; echo "Press Enter to stop"; read; pactl unload-module module-loopback'

alias sqli='rlwrap sqlite3 -column -header -cmd .tables'

alias usergroups="cat /etc/passwd | cut -d':' -f1 | xargs -n 1 id"

p() { pass "$@" || pass edit "$@"; }

alias omd="(echo '#+OPTIONS: tags:nil'; xclip -o -selection clipboard) | pandoc -f org-auto_identifiers -t markdown --wrap preserve | xclip -filter"
alias mdo="pandoc -f gfm-ascii_identifiers-gfm_auto_identifiers -t org-auto_identifiers --wrap preserve"
alias mdox="xclip -o -selection clipboard | mdo | xclip -filter"

alias gdiff='git diff --word-diff=color --word-diff-regex=. --no-index'

alias grp='grpc --ignore-case'
alias grpc='grep --color=auto --line-number --binary-files=without-match --directories=skip'
# Grep recursively and paginate
grpr() { grp --color=always --recursive $(echo $DIRS_IGNORE | sed 's/-x/--exclude-dir/g') "$@" | less -F; }
# Grep in shell config files
grsh() { grpr "$@" $HOME/.{ba,z}sh* $HOME/.local/bin $CONFIG_SHELLS $CONFIG_ZSH }

# Recover stray swap files from neovim
alias vrec="ls $XDG_DATA_HOME/nvim/swap | sed 's/\%/\//g' | sed 's|\(.*\)\..*|\1|' | head -1 | xargs --no-run-if-empty nvim"
alias vrecd="ls $XDG_DATA_HOME/nvim/swap | head -1 | xargs -r -i mv {} /tmp"

# I think this was something about recovering backup files
unv() { strings $1 | sed 's/5$//' | dedup; }

alias hx='sudo hexedit --maximize --color'
# Paginated hexyl
hex() { hexyl "$@" | "${PAGER:-less}"; }

alias dic="cat $XDG_DATA_HOME/dictcc/dict.txt | sed '/#/d;/&/d;/^$/d' | fzf --tiebreak=length --bind='alt-bspace:clear-query'"
alias dict="rlwrap rdictcc -d $XDG_DATA_HOME/dictcc"
alias dictu="dict -i $XDG_DATA_HOME/dictcc/dict.txt"

alias startMinecraftServer='curl https://ipinfo.io/ip | xclip -sel clip && cd ~/daten/games/sharedgames/minecraft/server && java -jar forge-1.12.2-14.23.5.2768-universal.jar -mx 8G'

npm-reinstall() {
	rm -rf $TMPDIR/react-*
	rm -rf node_modules/
	npm cache verify
	npm install
}

# Custom tools {{{1

sedcomment() { sed -i "s/$1/#\0/" "${@:2}"; }
seduncomment() { sed -i "s/#\($1\)/\0/" "${@:2}"; }

updateDeps() {
	name="$1"
	pattern="$2"
	depth="4"
	case $name in
		(gradle-wrapper.properties) depth=6;;
	esac
	shift 2
	oldversion="[0-9.]\+"
	while test $# -gt 1; do
		case "$1" in
			(--pattern) oldversion="$2";;
			(--version) version="$2";;
		esac
		shift 2
	done
	echo name $name depth $depth pattern $oldversion version $version
	find -maxdepth $depth -type f -name $name | while read f
	do	highlight $f
		sed -i "s/\($pattern\)$oldversion/\1$version/gw /dev/stdout" $f
	done
}
alias updateKotlin="updateDeps build.gradle.kts 'kotlin(\"jvm\") version ' --version"
alias updateGradle='updateDeps gradle-wrapper.properties "services.gradle.org\/distributions\/gradle-" --version'
alias updateUtils="updateDeps build.gradle.kts '"'"com.github.Xerus2000.util", ".*", "'" --pattern '[^\"]\+' --version"

# Kill all shell background processes
alias killbg='kill ${${(v)jobstates##*:*:}%=*}'

# Kil all Java processes except IDEA
# Pass "-9" to force-kill and "-q" to not output what has been killed
killJava() {
	pgrep -f 'java' | while read id
		do if [[ $(ps --no-headers -o cmd $id) != *"idea"* ]]; then
			[[ "$@" == "-q" ]] || echo "killing $(ps -p $id -o pid,cmd --width 350 --no-headers)"
			if [[ "$@" == "-9" ]]
			then kill -9 $id
			else kill $id
			fi
		fi; done
}

# Files {{{1

alias l="ls -l --almost-all --human-readable --group-directories-first --file-type"

if which fd >/dev/null
then alias f="noglob fdd"
	fdd() { $(which fd >/dev/null && echo fd || echo fdfind) --color=always --hidden --no-ignore-vcs --one-file-system "$@" | less -F; }
	compdef f=fd
else
	alias f='find -not -path "*.sync*" -and -not \( -name daten -prune \)'
	alias f1='find -mindepth 1 -maxdepth 1'
fi

lowercase_transliterate="y/A-Z /a-z-/"
which perl-rename >/dev/null &&
	alias lowercase="perl-rename -iv '$lowercase_transliterate'" ||
	alias lowercase="rename -iv '$lowercase_transliterate'"

# TODO replace cp by rsync, automatically use compression for remote transfers
# rsync directory properly - suffix both dirs with / to act on contents
alias rcn='rsync -v --recursive --human-readable --links --dry-run'
rcd() { rcn --size-only "$@" | tail +2 | tree --fromfile . | less -F; }
alias rc='rcs --links --times'
alias rcu='rc --existing --size-only'
alias rcs='rsync --recursive --info=progress2,remove,symsafe,flist,del --human-readable'
alias dsync='rc --delete --specials'
alias move='rc --remove-source-files'
alias rdiff='rsync --recursive --progress --delete --links --dry-run'

# Swap the names of two files
swap() {
	test $# -eq 2 || exit 1
	mv -n $1 $1.tmp
	mv -n $2 $1
	mv -n $1.tmp $2
}

# mv with automatic sudo if neccessary
smv() {
	test -w "$1" && test -w "$(dirname $2)" && mv "$@" || sudo mv "$@"
}

# Rename the file inside its directory
mvf() {
	smv "$1" "$(dirname $1)/$2"
}

# Move from $1 to $2 and create a relative symlink
mvln() {
	file=$(test -f "$1" && echo 1 || echo 0)
	if test -d $1; then
		mkdir -p "$2"
		mv -vT $1 $2
	else
		mv -v $1 $2
	fi
	[ $file -gt 0 -a -d $2 ] && 2="$2/$(basename $1)"
	ln -vsr "$2" "$1"
}

# Move into an xdg dir (default XDG_DATA_HOME) and create a symlink
mvx() {
	mvln "$1" "${2:-$XDG_DATA_HOME}/${1#.}"
	yadm add "$1" ".config/$1" 2>/dev/null
}

# Create directory and move into it
mkcd() {
	mkdir -p "$1" && cd "$1"
}

# Other stuff {{{1

umoul() {
	if test "$1"
	then arg="$1"
		mountpoint="$(test -d "$arg" && realpath "$arg" || echo "${MNT:-${XDG_RUNTIME_DIR}/mnt}/$arg")"
		mountpoint "$mountpoint" 2>/dev/null || test -b "$mountpoint" ||
			mountpoint="$(mount --show-labels | grep "$arg" | cut -d' ' -f3)"
		test "$mountpoint" || return 1
	else mountpoint="$PWD"
		while test "$mountpoint" != "/"; do
			mountpoint "$mountpoint" >/dev/null && break
			mountpoint="$(dirname "$mountpoint")"
		done
		test "$(dirname "$mountpoint")" = "/" && return 1
	fi
	case "$PWD" in
		("$mountpoint"*) cd "$(dirname $mountpoint)";;
	esac
	moul -u "$mountpoint"
}

resetdocker() {
	#aptremove docker-ce
	kill $(ps -e | grep docker | cut -d' ' -f2)
	sudo rm -rf /var/run/docker /var/lib/docker
	sudo rm /var/run/docker.*
	#aptinstall docker-ce
}

function zipdiff() {
	diff -W200 -y <(unzip -vql $1 | sort -k8) <(unzip -vql $2 | sort -k8) #--suppress-common-lines
}

# SWAP
alias memstat='free -h | awk '"'"'NR==2 {printf "Free memory:\t %s/%s\t(%d%)\n",$7,$2,$7*100/$2} NR==3 {if($2 != "0B") printf "Used swap:\t%s/%s\t(%d%)\n",$3,$2,$2*100/$3}'"'"

stopswap() {
	memstat
	swap_used=$(cat /proc/meminfo | grep SwapFree | awk '{print $2}')
	mem_available=$(cat /proc/meminfo | grep MemAvailable | awk '{print $2}')
	if test $swap_used = 0
	then echo "No swap is in use."
	elif test $swap_used + 100000 < $mem_available
	then echo "Freeing swap..."
		sudo swapoff -a
		sudo swapon -a
		memstat
	else
		echo "Not enough free memory!"
	fi
}