# large set of aliases for git commands

RWX_GIT_LOG_FORMAT="\
%C(auto)%h%d
S %C(red)%GS
A %C(green)%ai %an %ae
C %C(blue)%ci %cn %ce
%B"

RWX_GIT_LOG_FORMAT_DATE="%Y-%m-%d %H:%M:%S"

RWX_GIT_LOG_FORMAT_SHORT="%C(auto)%h %C(green)%ad %C(auto)%s %d"

# add to index
#= ga
rwx_git_add() {
	git \
		add \
		"${@}"
}

# add all to index
#= gaa
rwx_git_add_all() {
	git \
		add \
		--all \
		"${@}"
}

# add parts of all to index
#= gaap
rwx_git_add_all_patch() {
	git \
		add \
		--all \
		--patch \
		"${@}"
}

# add parts to index
#= gap
rwx_git_add_patch() {
	git \
		add \
		--patch \
		"${@}"
}

# create a branch
#= gb
rwx_git_branch() {
	git \
		branch \
		"${@}"
}

# delete a branch
#= gbd
rwx_git_branch_delete() {
	git \
		branch \
		--delete \
		"${@}"
}

# force a branch deletion
#= gbdf
rwx_git_branch_delete_force() {
	git \
		branch \
		--delete \
		--force \
		"${@}"
}

# list branches
#= gbl
rwx_git_branch_list() {
	git \
		branch \
		--all \
		--list \
		--verbose \
		--verbose \
		"${@}"
}

# set the link to a remote branch from a local branch
#= gbsu
rwx_git_branch_set_upstream() {
	git \
		branch \
		--set-upstream-to \
		"${@}"
}

# switch to a branch or checkout file(s) from a commit
#= gc
rwx_git_checkout() {
	git \
		checkout \
		"${@}"
}

# checkout an orphan branch
#= gco
rwx_git_checkout_orphan() {
	git \
		checkout \
		--orphan \
		"${@}"
}

# pick a commit
#= gcp
rwx_git_cherry_pick() {
	git \
		cherry-pick \
		"${@}"
}

# abort the commit pick
#= gcpa
rwx_git_cherry_pick_abort() {
	git \
		cherry-pick \
		--abort \
		"${@}"
}

# continue the commit pick
#= gcpc
rwx_git_cherry_pick_continue() {
	git \
		cherry-pick \
		--continue \
		"${@}"
}

# clean untracked files
#= gcf
rwx_git_clean_force() {
	git \
		clean \
		-d \
		--force \
		"${@}"
}

# redo the last commit with a different message
#= gcam
rwx_git_commit_amend_message() {
	git \
		commit \
		--amend \
		--message \
		"${@}"
}

# make a root commit
#= gcem
rwx_git_commit_empty_message() {
	git \
		commit \
		--allow-empty \
		--allow-empty-message \
		--message \
		"${@}"
}

# commit the index
#= gcm
rwx_git_commit_message() {
	git \
		commit \
		--message \
		"${@}"
}

# configure the user email
#= gcue
rwx_git_config_user_email() {
	git \
		config \
		"user.email" \
		"${@}"
}

# configure the user name
#= gcun
rwx_git_config_user_name() {
	git \
		config \
		"user.name" \
		"${@}"
}

# differences from last or between commits
#= gd
rwx_git_diff() {
	git \
		diff \
		"${@}"
}

# display what is indexed in cache
#= gdc
rwx_git_diff_cached() {
	git \
		diff \
		--cached \
		"${@}"
}

# indexed character-level differences
#= gdcw
rwx_git_diff_cached_word() {
	git \
		diff \
		--cached \
		--word-diff-regex "." \
		"${@}"
}

# differences via external tool
#= gdt
rwx_git_diff_tool() {
	git \
		difftool \
		--dir-diff \
		"${@}"
}

# character-level differences
#= gdw
rwx_git_diff_word() {
	git \
		diff \
		--word-diff-regex "." \
		"${@}"
}

# fetch from the remote repository
#= gf
rwx_git_fetch() {
	rwx_gpg_agent_update &&
		git \
			fetch \
			--tags \
			--verbose \
			"${@}"
}

# fetch from remote repository and prune local orphan branches
#= gfp
rwx_git_fetch_prune() {
	rwx_git_fetch \
		--prune \
		"${@}"
}

# garbage collect all orphan commits
#= ggc
rwx_git_garbage_collect() {
	git \
		reflog \
		expire \
		--all \
		--expire "all" &&
		git \
			gc \
			--aggressive \
			--prune="now"
}

# initialize a new repository
#= gi
rwx_git_init() {
	git \
		init \
		"${@}"
}

# initialize a new bare repository
#= gib
rwx_git_init_bare() {
	git \
		init \
		--bare \
		"${@}"
}

# log history
#= gl
rwx_git_log() {
	git \
		log \
		--abbrev=8 \
		--abbrev-commit \
		--date=format:"${RWX_GIT_LOG_FORMAT_DATE}" \
		--format="${RWX_GIT_LOG_FORMAT}" \
		--graph \
		"${@}"
}

# log all history
#= gla
rwx_git_log_all() {
	rwx_git_log \
		--all \
		"${@}"
}

# log all history as oneline
#= glao
rwx_git_log_all_oneline() {
	rwx_git_log_all \
		--format="${RWX_GIT_LOG_FORMAT_SHORT}" \
		"${@}"
}

# log all history with patches
#= glap
rwx_git_log_all_patch() {
	rwx_git_log \
		--all \
		--patch \
		"${@}"
}

# log history as oneline
#= glo
rwx_git_log_oneline() {
	rwx_git_log \
		--format="${RWX_GIT_LOG_FORMAT_SHORT}" \
		"${@}"
}

# log history with patches
#= glp
rwx_git_log_patch() {
	rwx_git_log \
		--patch \
		"${@}"
}

# fast-forward merge to remote branch
#= gm
rwx_git_merge() {
	git \
		merge \
		--ff-only \
		"${@}"
}

# abort the current merge commit
#= gma
rwx_git_merge_abort() {
	git \
		merge \
		--abort \
		"${@}"
}

# do a merge commit
#= gmc
rwx_git_merge_commit() {
	git \
		merge \
		--no-ff \
		--message \
		"${@}"
}

# squash a branch and index its modifications
#= gms
rwx_git_merge_squash() {
	git \
		merge \
		--squash \
		"${@}"
}

# merge via external tool
#= gmt
rwx_git_merge_tool() {
	git \
		mergetool \
		"${@}"
}

# push to the remote repository
#= gp
rwx_git_push() {
	rwx_gpg_agent_update &&
		git \
			push \
			--tags \
			--verbose \
			"${@}"
}

# delete from the remote repository
#= gpd
rwx_git_push_delete() {
	git \
		push \
		--delete \
		"${@}"
}

# force the push to the remote repository
#= gpf
rwx_git_push_force() {
	rwx_git_push \
		--force \
		"${@}"
}

# rebase current branch onto another
#= grb
rwx_git_re_base() {
	git \
		rebase \
		"${@}"
}

# abort current rebase
#= grba
rwx_git_re_base_abort() {
	git \
		rebase \
		--abort \
		"${@}"
}

# continue current rebase
#= grbc
rwx_git_re_base_continue() {
	git \
		rebase \
		--continue \
		"${@}"
}

# force rebase without fast-forward
#= grbf
rwx_git_re_base_force() {
	git \
		rebase \
		--force-rebase \
		"${@}"
}

# rebase interactively
#= grbi
rwx_git_re_base_interactive() {
	git \
		rebase \
		--interactive \
		"${@}"
}

# add a new remote repository
#= grma
rwx_git_re_mote_add() {
	git \
		remote \
		add \
		"${@}"
}

# list remote repositories
#= grml
rwx_git_re_mote_list() {
	git \
		remote \
		--verbose \
		"${@}"
}

# set the location of a remote repository
#= grmsu
rwx_git_re_mote_set_upstream() {
	git \
		remote \
		set-url \
		"${@}"
}

# show connection to a remote repository
#= grms
rwx_git_re_mote_show() {
	git \
		remote \
		show \
		"${@}"
}

# remove and add removal to index
#= grm
rwx_git_re_move() {
	git \
		rm \
		"${@}"
}

# remove file(s) from index or move current branch pointer
#= grs
rwx_git_re_set() {
	git \
		reset \
		"${@}"
}

# wipe modifications or reset current branch to another commit
#= grsh
rwx_git_re_set_hard() {
	git \
		reset \
		--hard \
		"${@}"
}

# current state of repository
#= gs
rwx_git_status() {
	git \
		status \
		--untracked-files="all" \
		"${@}"
}

# show a commit
#= gsc
rwx_git_show_commit() {
	git \
		show \
		"${@}"
}

# tag a commit
#= gt
rwx_git_tag() {
	git \
		tag \
		"${@}"
}

# delete a tag
#= gtd
rwx_git_tag_delete() {
	git \
		tag \
		--delete \
		"${@}"
}

# update head ref
#= gurh
rwx_git_update_ref_head() {
	if [ -n "${2}" ]; then
		git \
			update-ref \
			"refs/heads/${1}" \
			"${2}"
	fi
}