229 lines
6.3 KiB
Plaintext
229 lines
6.3 KiB
Plaintext
# Tools
|
|
alias g="git"
|
|
alias bfg="java -jar $HOME/daten/applications/bfg-1.13.0.jar"
|
|
alias magit='nvim -c MagitOnly'
|
|
|
|
alias y='yadm'
|
|
yc() {
|
|
echo "config/$1:" >/tmp/yc-msg
|
|
yadm commit -v --template /tmp/yc-msg ${@:2} -- "$XDG_CONFIG_HOME/$1"
|
|
}
|
|
|
|
gcn() {
|
|
if test $# -eq 0 || test -e $1
|
|
then
|
|
fulldir="$(realpath ${1:-$PWD})"
|
|
dir="${fulldir#$DATA/*/}"
|
|
else
|
|
dir="notes/$1"
|
|
fulldir="$DATA/2-standards/$dir"
|
|
fi
|
|
echo "$dir:" >/tmp/gcn-msg
|
|
git commit -v --template /tmp/gcn-msg ${@:2} -- $fulldir
|
|
}
|
|
|
|
# if in home or under XDG_CONFIG_HOME and not within a git directory, replace git by yadm
|
|
git() {
|
|
case "$1" in
|
|
reset) test "$2" = "--hard" && return 1;;
|
|
config) ;;
|
|
clone) ;;
|
|
*) case "$PWD" in
|
|
$HOME|$XDG_CONFIG_HOME|$LAST_YADM)
|
|
yadm "$@"
|
|
return
|
|
;;
|
|
$XDG_CONFIG_HOME*|$HOME/.local*)
|
|
if ! command git rev-parse --show-toplevel &>/dev/null; then
|
|
export LAST_YADM="$PWD"
|
|
yadm "$@"
|
|
return
|
|
fi;;
|
|
esac;;
|
|
esac
|
|
command git "$@";
|
|
}
|
|
|
|
# BRANCHES
|
|
# Remove list of tags local & remote
|
|
gitrmtag() {
|
|
declare -a refs
|
|
local index=1
|
|
for tag in $@; do refs[index++]=":refs/tags/$tag"; done
|
|
git push origin "${refs[@]}" && git tag -d "$@"
|
|
}
|
|
# Rename a tag
|
|
gitretag() {
|
|
git push origin refs/tags/${1}:refs/tags/${2} :refs/tags/$1 && git tag -d $1
|
|
}
|
|
|
|
# Repo management {{{
|
|
gitinit() {
|
|
git init -b main
|
|
git add .
|
|
git commit -m "First strike"
|
|
gitorigin "$@"
|
|
git push
|
|
}
|
|
|
|
gitbackup() {
|
|
p=$(basename $PWD)
|
|
builtin cd ..
|
|
git clone --mirror $p
|
|
cd $p
|
|
}
|
|
|
|
project() {
|
|
cd $projects_dir
|
|
if [ -d $2 ]
|
|
then cd "$2" && gitorigin "$@"
|
|
else gitclone "$@"
|
|
fi
|
|
}
|
|
|
|
gitremote() {
|
|
case "$1" in
|
|
http*) echo "git@$(echo "$1" | cut -d'/' -f3):$(echo "$1" | cut -d'/' -f4)/$(echo "$1" | cut -d'/' -f5)" ;;
|
|
git:*) echo "$1" ;;
|
|
*) test "$3" = "cau" && 3="CAU-Kiel-Tech-Inf"
|
|
test "$3" = "btl" && 3="betweenthelinesev"
|
|
echo "git@${1:-github.com}:${3:-$(git config user.name)}/${2:-$(basename $PWD)}.git" ;;
|
|
esac
|
|
}
|
|
|
|
gitclone() {
|
|
remote=$(gitremote "$@")
|
|
echo $remote
|
|
git clone $remote ${@:4} || return $?
|
|
cd "$(test $4 && echo $4 || basename ${remote%.git})"
|
|
}
|
|
|
|
gitfork() {
|
|
builtin cd "$projects_dir/_forks"
|
|
gitclone github.com "$1" "" "$3" --recurse-submodules || return $?
|
|
test "$2" && git remote add upstream "$(gitremote github.com "$1" "$2")"
|
|
git remote -v
|
|
}
|
|
|
|
# set repo as origin and set all branches upstream to their respective remote branch, if available
|
|
gitorigin() {
|
|
git remote remove origin 2>/dev/null
|
|
git remote add origin $(gitremote "$@")
|
|
git remote -v && git fetch || ( last=$? && echo "git fetch failed, aborting\!" && return $last )
|
|
|
|
git branch | sed 's/ //g' | sed 's/*//' | while read branch
|
|
do test $(git branch -a | grep origin/$branch | wc -l) -gt 0 && git branch -u origin/$branch $branch
|
|
done
|
|
}
|
|
|
|
# set repo as upstream or add a new remote
|
|
gitupstream() {
|
|
if test "$3"
|
|
then
|
|
local name="$3"
|
|
git remote remove "$3" 2>/dev/null
|
|
else
|
|
git remote get-url upstream 2>/dev/null && local name="$1" || local name="upstream"
|
|
fi
|
|
local origin="$(git remote get-url origin)"
|
|
git remote add -f $name "$(echo $origin | cut -d':' -f1):$1/${2:-$(echo $origin | cut -d'/' -f2)}"
|
|
git remote -v
|
|
}
|
|
# }}}
|
|
|
|
# Rewriting history {{{
|
|
|
|
# gets the AuthorDate of a given committish
|
|
git-authordate() {
|
|
local date=$(git log --pretty=fuller --date=raw -1 $1 | grep AuthorDate)
|
|
echo ${date##*: }
|
|
}
|
|
# executes a git command (usually commit) with the date of a given committish
|
|
git-withdate() {
|
|
date=$(git-authordate $1)
|
|
GIT_AUTHOR_DATE="$date" GIT_COMMITTER_DATE="$date" git "${@:2}"
|
|
}
|
|
|
|
# takes all changes in the current working tree and amends them to the given commit
|
|
gitedit() {
|
|
git stash
|
|
gitcommits -q $1
|
|
git reset --keep $1
|
|
git stash pop
|
|
git-withdate $1 commit --all --amend "${@:2}"
|
|
gitcommits
|
|
}
|
|
|
|
# takes two committishs and squashes them with all commits between them into a single commit
|
|
# this will rewrite the full history from then on, but should not create any conflicts
|
|
gitsquash() {
|
|
local -a options
|
|
while [ $# -gt 0 ]; do
|
|
case $1 in
|
|
-i) ignore=true; shift 1;;
|
|
-f|--force) force=true; shift 1;;
|
|
-*) options+=($1); exit 1;;
|
|
*) break;;
|
|
esac
|
|
done
|
|
|
|
((#!=2)) && echo "Usage: [options] <startcommit> <endcommit>" && return 1
|
|
[[ -n $(git status -s) ]] && [ ! $force ] && echo -e "Tree is dirty, commit or stash your changes first!\nIf you want to execute the command regardless, run again with --force" && return 1
|
|
|
|
1=$(git rev-parse $1)
|
|
2=$(git rev-parse $2)
|
|
[ $(git rev-list $1 --count) -lt $(git rev-list $2 --count) ] && t=$1 && 1=$2 && 2=$t
|
|
|
|
gitcommits -q $1
|
|
git reset --hard $1
|
|
if [ $(git rev-list $2 --count) = 1 ]; then
|
|
git update-ref -d HEAD
|
|
git add .
|
|
git-withdate $1 commit -c $1
|
|
else
|
|
git reset -q $2
|
|
git add .
|
|
git commit --amend
|
|
fi
|
|
gitcommits
|
|
}
|
|
|
|
# given a committish, this command saves a list of commits between the HEAD and the given committish into the .git directory
|
|
# when ran without parameters it applies the saved list of commits onto the current HEAD
|
|
gitcommits() {
|
|
verbosity=1
|
|
while [[ $# -gt 0 ]]; do
|
|
case $1 in
|
|
-v) verbosity=2; shift 1;;
|
|
-q|--quiet) verbosity=0; shift 1;;
|
|
--theirs) params=(-X theirs); shift 1;;
|
|
*) break;;
|
|
esac
|
|
done
|
|
|
|
stashed="$(git rev-parse --show-toplevel)/.git/stashed-commits"
|
|
if [ $1 ]; then
|
|
if [ $verbosity -eq 0 ]
|
|
then git rev-list --reverse HEAD...$1 >$stashed
|
|
else git rev-list --reverse HEAD...$1 | tee $stashed
|
|
fi
|
|
else
|
|
local aborted
|
|
for commit in $(cat $stashed); do
|
|
[ $aborted ] && rest+=($commit) && continue
|
|
[ $verbosity -gt 0 ] && git --no-pager log --oneline -1 $commit
|
|
git-withdate $commit cherry-pick $commit ${params:0} >/dev/null
|
|
last=$?
|
|
[ $last -gt 0 ] && aborted=true && typeset -a rest && continue
|
|
[ $verbosity -gt 0 ] && echo -e "\e[1A$(git log --color=always --pretty=format:"%C(yellow)$(git rev-parse --short HEAD^^)%C(bold) -> %Creset%C(yellow)%h%Creset %s" -1)"
|
|
[ $verbosity -gt 1 ] && git status -s
|
|
done
|
|
echo $rest >$stashed
|
|
[ $aborted ] && echo "A problem was encountered. Fix it and run 'gitcommits' again to apply the remaining ${#rest} commits."
|
|
fi
|
|
}
|
|
# }}}
|
|
|
|
# Testing
|
|
gittestcommit() { touch file$((++i)) && git add 'file*' && git commit -m "Create file$i"; }
|