.functions

# Make a directory and `cd` into it
mkd() {
	mkdir -p "$@" && cd "$_"
}

# `cd` into a directory and `ls`
cdl() {
	cd "$1" && ls
}

# Jump up `n` directories
up() {
	local ups=""
	for i in $(seq 1 ${1:-1}); do
		ups=$ups"../"
	done
	cd $ups
}

# `man` that supports shell builtins
# Source: https://unix.stackexchange.com/a/18088
man() {
	case "$(type -t "$1"):$1" in
		# built-in
		builtin:*) help "$1" | "${PAGER:-less}";;
		# pattern
		*[[?*]*) help "$1" | "${PAGER:-less}";;
		# something else, presumed to be an external command or options for the man
		# command or a section number
		*) command -p man "$@";;
	esac
}

# Get the weather
weather() {
	# If no $1, use the zip code from our IP
	# If no $2, use "q0n" as URL params
	curl -s -H "Accept-Language: ${LANG%_*}" http://wttr.in/${1:-$(curl -s http://ipinfo.io/postal)}?${2:-q0n}
}

# `tre` is a shorthand for `tree` with hidden files and color enabled, ignoring
# the `.git` directory, listing directories first. The output gets piped into
# `less` with options to preserve color and line numbers, unless the output is
# small enough for one screen.
# Source: https://github.com/mathiasbynens/dotfiles
tre() {
	tree -aC -I '.git|node_modules|bower_components' --dirsfirst "$@" | less -FRNX;
}

# Select a range of a file by line numbers
# Usage: selrg 5 10 file.txt
selrg() {
	sed -n "${1},${2}p" "${3}"
}

# Kill all processes on a specified port
# Source: https://stackoverflow.com/a/5043907
killport() {
	if [ -z "${1}" ]; then
		echo "Usage: \`killport <port>\`"
		return 1
	fi

	lsof -i tcp:${1} | awk 'NR!=1 {print $2}' | xargs kill
}

# Determine size of a file or total size of a directory
# Source: https://github.com/mathiasbynens/dotfiles
fs() {
	if du -b /dev/null > /dev/null 2>&1; then
		local arg=-sbh;
	else
		local arg=-sh;
	fi
	if [[ -n "$@" ]]; then
		du $arg -- "$@";
	else
		du $arg .[^.]* ./*;
	fi;
}

# Compare original and gzipped file size
# Source: https://github.com/necolas/dotfiles
gz() {
    local origsize=$(wc -c < "$1")
    local gzipsize=$(gzip -c "$1" | wc -c)
    local ratio=$(echo "$gzipsize * 100 / $origsize" | bc -l)

    printf "orig: %d bytes\n" "$origsize"
    printf "gzip: %d bytes (%2.2f%%)\n" "$gzipsize" "$ratio"
}

# General "extract" function
# Source: https://github.com/xvoland/Extract
extract() {
	if [ -z "$1" ]; then
		# display usage if no parameters given
		echo "Usage: extract <path/file_name>.<zip|rar|bz2|gz|tar|tbz2|tgz|Z|7z|xz|ex|tar.bz2|tar.gz|tar.xz>"
		echo "       extract <path/file_name_1.ext> [path/file_name_2.ext] [path/file_name_3.ext]"
		return 1
	else
		for n in $@
		do
			if [ -f "$n" ] ; then
				case "${n%,}" in
					*.tar.bz2|*.tar.gz|*.tar.xz|*.tbz2|*.tgz|*.txz|*.tar)
					             tar xvf "$n"       ;;
					*.lzma)      unlzma ./"$n"      ;;
					*.bz2)       bunzip2 ./"$n"     ;;
					*.rar)       unrar x -ad ./"$n" ;;
					*.gz)        gunzip ./"$n"      ;;
					*.zip)       unzip ./"$n"       ;;
					*.z)         uncompress ./"$n"  ;;
					*.7z|*.arj|*.cab|*.chm|*.deb|*.dmg|*.iso|*.lzh|*.msi|*.rpm|*.udf|*.wim|*.xar)
					             7z x ./"$n"        ;;
					*.xz)        unxz ./"$n"        ;;
					*.exe)       cabextract ./"$n"  ;;
					*)
					             echo "extract: '$n' - unknown archive method"
					             return 1
					             ;;
				esac
			else
				echo "'$n' - file does not exist"
				return 1
			fi
		done
	fi
}

# Create a .tar.gz archive, using `zopfli`, `pigz` or `gzip` for compression
# Source: https://github.com/mathiasbynens/dotfiles
targz() {
	local tmpFile="${@%/}.tar";
	tar -cvf "${tmpFile}" --exclude=".DS_Store" "${@}" || return 1;

	size=$(
		stat -f"%z" "${tmpFile}" 2> /dev/null; # macOS `stat`
		stat -c"%s" "${tmpFile}" 2> /dev/null;  # GNU `stat`
	);

	local cmd="";
	if (( size < 52428800 )) && hash zopfli 2> /dev/null; then
		# the .tar file is smaller than 50 MB and Zopfli is available; use it
		cmd="zopfli";
	else
		if hash pigz 2> /dev/null; then
			cmd="pigz";
		else
			cmd="gzip";
		fi;
	fi;

	echo "Compressing .tar ($((size / 1000)) kB) using \`${cmd}\`…";
	"${cmd}" -v "${tmpFile}" || return 1;
	[ -f "${tmpFile}" ] && rm "${tmpFile}";

	zippedSize=$(
		stat -f"%z" "${tmpFile}.gz" 2> /dev/null; # macOS `stat`
		stat -c"%s" "${tmpFile}.gz" 2> /dev/null; # GNU `stat`
	);

	echo "${tmpFile}.gz ($((zippedSize / 1000)) kB) created successfully.";
}

# Upload a file to the hastebin service
# Source: https://github.com/diethnis/standalones
haste() {
	local output returnfile contents
	if (( $# == 0 )) && [[ $(printf "%s" "$0" | wc -c) > 0 ]]
		then
		contents=$0
	elif (( $# != 1 )) || [[ $1 =~ ^(-h|--help)$ ]]
		then
		echo "Usage: $0 FILE"
		echo "Upload contents of plaintext document to hastebin."
		echo "\nInvocation with no arguments takes input from stdin or pipe."
		echo "Terminate stdin by EOF (Ctrl-D)."
		return 1
	elif [[ -e $1 && ! -f $1 ]]
		then
		echo "Error: Not a regular file."
		return 1
	elif [[ ! -e $1 ]]
		then
		echo "Error: No such file."
		return 1
	elif (( $(stat -c %s $1) > (512*1024**1) ))
		then
		echo "Error: File must be smaller than 512 KiB."
		return 1
	fi
	if [[ -n "$contents" ]] || [[ $(printf "%s" "$contents" | wc -c) < 1 ]]
		then
		contents=$(cat $1)
	fi
	output=$(curl -# -f -XPOST "https://hastebin.com/documents" -d"$contents")
	if (( $? == 0 )) && [[ $output =~ \"key\" ]]
		then
		returnfile=$(sed 's/^.*"key":"/https:\/\/hastebin.com\//;s/".*$//' <<< "$output")
		if [[ -n $returnfile ]]
			then
			echo "$returnfile"
			return 0
		fi
	fi
	echo "Upload failed."
	return 1
}

# Cache $DISPLAY if we're not in tmux, otherwise update from the cache
# Based on: http://alexteichman.com/octo/blog/2014/01/01/x11-forwarding-and-terminal-multiplexers/
update-x11-forwarding() {
	if [ ! -f ~/.display ]; then
		touch ~/.display
	fi

	if [ -z "$TMUX" ]; then
		echo $DISPLAY > ~/.display
	else
		export DISPLAY=`cat ~/.display`
	fi
}