# add to index
ga() { git_add "${@}"; }
git_add() {
	git \
		add \
		"${@}"
}

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

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

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

# create a branch
gb() { git_branch "${@}"; }
git_branch() {
	git \
		branch \
		"${@}"
}

# delete a branch
gbd() { git_branch_delete "${@}"; }
git_branch_delete() {
	git \
		branch \
		--delete \
		"${@}"
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# fetch from the remote repository
gf() { git_fetch "${@}"; }
git_fetch() {
	git \
		fetch \
		--tags \
		--verbose \
		"${@}"
}

# fetch from remote repository and prune local orphan branches
gfp() { git_fetch_prune "${@}"; }
git_fetch_prune() {
	git_fetch \
		--prune \
		"${@}"
}

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

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

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

# log history
gl() { git_log "${@}"; }
git_log() {
	local format="\
%C(auto)%h%d
S %C(red)%GS
A %C(green)%ai
  %C(green)%an %ae
C %C(blue)%ci
  %C(blue)%cn %ce
%B"
	git \
		log \
		--abbrev=8 \
		--abbrev-commit \
		--format="${format}" \
		--graph \
		"${@}"
}

# log all history
gla() { git_log_all "${@}"; }
git_log_all() {
	git_log \
		--all \
		"${@}"
}

# log all history with patches
glap() { git_log_all_patch "${@}"; }
git_log_all_patch() {
	git_log \
		--all \
		--patch \
		"${@}"
}

# log history with patches
glp() { git_log_patch "${@}"; }
git_log_patch() {
	git_log \
		--patch \
		"${@}"
}

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

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

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

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

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

# push to the remote repository
gp() { git_push "${@}"; }
git_push() {
	git \
		push \
		--tags \
		--verbose \
		"${@}"
}

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

# force the push to the remote repository
gpf() { git_push_force "${@}"; }
git_push_force() {
	git_push \
		--force \
		"${@}"
}

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

# abort current rebase
grba() { git_re_base_abort "${@}"; }
git_re_base_abort() {
	git \
		rebase \
		--abort \
		"${@}"
}

# continue current rebase
grbc() { git_re_base_continue "${@}"; }
git_re_base_continue() {
	git \
		rebase \
		--continue \
		"${@}"
}

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

# rebase interactively
grbi() { git_re_base_interactive "${@}"; }
git_re_base_interactive() {
	git \
		rebase \
		--interactive \
		"${@}"
}

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

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

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

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

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

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

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

# show a commit
gsc() { git_show_commit "${@}"; }
git_show_commit() {
	git \
		show \
		"${@}"
}

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

# tag a commit
gt() { git_tag "${@}"; }
git_tag() {
	git \
		tag \
		"${@}"
}

# delete a tag
gtd() { git_tag_delete "${@}"; }
git_tag_delete() {
	git \
		tag \
		--delete \
		"${@}"
}