648 lines
24 KiB
Bash
Executable file
648 lines
24 KiB
Bash
Executable file
#!/bin/bash
|
||
|
||
# Commands one might want to use in this script :
|
||
# pull fetch checkout commit push reset merge rebase stash branch status tag revert
|
||
|
||
# Commands which can be used recursively :
|
||
# pull fetch commit push branch status (checkout <branch>) reset prune
|
||
|
||
# Commands which can not be used recursively (and need for example a commit hash) :
|
||
# revert <commit> -> rollback <commit>
|
||
# checkout <commit> -> checkout <commit>
|
||
|
||
# Commands which need a bit more glue around them (with for example several steps) :
|
||
# branch <branch> + checkout <branch> -> newfeature <branch>
|
||
# checkout master + branch -d <branch> -> delfeature
|
||
|
||
if [ $# -ge 1 ]; then
|
||
SUBCOMMAND="$1"
|
||
printf '%s\n' "$@"
|
||
else
|
||
printf "%s\n" "USAGE: $0 subcommand [git_options]"
|
||
printf "%s\n" "Available git subcommands: add branch checkout commit diff fetch log pull push reset shortlog stash status tag whatchanged"
|
||
printf "%s\n" "Available custom subcommands: newfeature delfeature fusion rollback"
|
||
exit 1;
|
||
fi;
|
||
|
||
CONFIGS_REPO="${CONFIGS_DIR:-${HOME}/git/configs}"
|
||
# the default branch name: we expect it to be the same in all repos
|
||
DEFAULT_BRANCH=master
|
||
|
||
command_noneedcommit () {
|
||
SUBCOMMAND="$1"
|
||
shift 1
|
||
SUBMODULE_LIST=$(git submodule --quiet foreach 'echo $displaypath' | tr '\n' ' ')
|
||
# printf '%s\n' "SUBMODULE_LIST: $SUBMODULE_LIST" >&2
|
||
MODULE_THREAD=$(printf '%s' "$MODULE_THREAD $MODULE" | sed s/'^\ '//)
|
||
# printf '%s\n' "MODULE_THREAD=$MODULE_THREAD" >&2
|
||
if [ "x$SUBMODULE_LIST" != "x" ]; then
|
||
for SUBMODULE in $SUBMODULE_LIST; do
|
||
printf '%s\n' "* cd $SUBMODULE" >&2
|
||
cd $SUBMODULE
|
||
pwd
|
||
# Quand on descend dans le submodule
|
||
# supermodule devient le module précédent
|
||
# module devient le submodule précédent
|
||
# printf '%s\n' "SUPERMODULE=$MODULE ; MODULE=$SUBMODULE" >&2
|
||
SUPERMODULE=$MODULE ; MODULE=$SUBMODULE
|
||
command_noneedcommit $SUBCOMMAND "$@";
|
||
printf '%s\n' "* cd .." >&2
|
||
cd ../
|
||
pwd
|
||
# Quand on remonte dans le supermodule
|
||
# submodule devient le module précédent
|
||
# module devient le supermodule précédent
|
||
# supermodule devient l'avant-dernier item du module thread
|
||
# printf '%s\n' "SUBMODULE=$MODULE ; MODULE=$SUPERMODULE" >&2
|
||
SUBMODULE=$MODULE ; MODULE=$SUPERMODULE
|
||
MODULE_THREAD=$(printf '%s\n' $MODULE_THREAD | sed -E s/'\ ?[[:graph:]]*$'//)
|
||
SUPERMODULE=$(printf '%s\n' $MODULE_THREAD | sed -E s/'\ ?[[:graph:]]*$'// | awk '{ print $(NF) }')
|
||
# printf '%s\n' "MODULE_THREAD=$MODULE_THREAD ; SUPERMODULE=$SUPERMODULE" >&2
|
||
done
|
||
fi
|
||
printf '%s\n' "* git $SUBCOMMAND $@" >&2
|
||
git $SUBCOMMAND "$@"
|
||
noneedcommit_ret=$(($noneedcommit_ret + $?))
|
||
return $noneedcommit_ret
|
||
}
|
||
|
||
command_needcommit () {
|
||
SUBCOMMAND="$1"
|
||
shift 1
|
||
if [ $# -ge 1 ]; then
|
||
eval LASTARG=\${$#}
|
||
n=$(($# - 1))
|
||
eval ARGSNOLAST=\${@:1:$n}
|
||
else
|
||
LASTARG=$(git rev-parse HEAD)
|
||
ARGSNOLAST=${@}
|
||
fi
|
||
COMMIT=$LASTARG
|
||
SUBMODULE_LIST=$(git submodule --quiet foreach 'echo $displaypath' | tr '\n' ' ')
|
||
# printf '%s\n' "SUBMODULE_LIST: $SUBMODULE_LIST" >&2
|
||
MODULE_THREAD=$(printf '%s' "$MODULE_THREAD $MODULE" | sed s/'^\ '//)
|
||
# printf '%s\n' "MODULE_THREAD=$MODULE_THREAD" >&2
|
||
COMMIT_THREAD=$(printf '%s' "$COMMIT_THREAD $COMMIT" | sed s/'^\ '//)
|
||
# printf '%s\n' "COMMIT_THREAD=$COMMIT_THREAD" >&2
|
||
if [ "x$SUBMODULE_LIST" != "x" ]; then
|
||
for SUBMODULE in $SUBMODULE_LIST; do
|
||
printf '%s\n' "* git ls-tree $COMMIT $SUBMODULE" >&2
|
||
git ls-tree $COMMIT $SUBMODULE
|
||
# SUBCOMMIT=$(git ls-tree $COMMIT $SUBMODULE | awk '{ print $3 }')
|
||
SUBCOMMIT=$(git ls-tree --object-only $COMMIT $SUBMODULE)
|
||
printf '%s\n' "* cd $SUBMODULE" >&2
|
||
cd $SUBMODULE
|
||
pwd
|
||
# Quand on descend dans le submodule
|
||
# supermodule devient le module précédent
|
||
# module devient le submodule précédent
|
||
# printf '%s\n' "SUPERMODULE=$MODULE ; MODULE=$SUBMODULE" >&2
|
||
SUPERMODULE=$MODULE ; MODULE=$SUBMODULE
|
||
# Quand on descend dans le submodule
|
||
# supercommit devient le commit précédent
|
||
# commit devient le subcommit précédent
|
||
# printf '%s\n' "SUPERCOMMIT=$COMMIT ; COMMIT=$SUBCOMMIT" >&2
|
||
SUPERCOMMIT=$COMMIT ; COMMIT=$SUBCOMMIT ;
|
||
command_needcommit $SUBCOMMAND $ARGSNOLAST $COMMIT;
|
||
printf '%s\n' "* cd .." >&2
|
||
cd ../
|
||
pwd
|
||
# Quand on remonte dans le supermodule
|
||
# submodule devient le module précédent
|
||
# module devient le supermodule précédent
|
||
# supermodule devient l'avant-dernier item du module thread
|
||
# printf '%s\n' "SUBMODULE=$MODULE ; MODULE=$SUPERMODULE" >&2
|
||
SUBMODULE=$MODULE ; MODULE=$SUPERMODULE ;
|
||
MODULE_THREAD=$(printf '%s\n' $MODULE_THREAD | sed -E s/'\ ?[[:graph:]]*$'//) ;
|
||
SUPERMODULE=$(printf '%s\n' $MODULE_THREAD | sed -E s/'\ ?[[:graph:]]*$'// | awk '{ print $(NF) }')
|
||
# printf '%s\n' "MODULE_THREAD=$MODULE_THREAD ; SUPERMODULE=$SUPERMODULE" >&2
|
||
# Quand on remonte dans le supermodule
|
||
# subcommit devient le commit précédent
|
||
# commit devient le supercommit précédent
|
||
# supercommit devient l'avant-dernier item du commit thread
|
||
# printf '%s\n' "SUBCOMMIT=$COMMIT ; COMMIT=$SUPERCOMMIT" >&2
|
||
SUBCOMMIT=$COMMIT ; COMMIT=$SUPERCOMMIT ;
|
||
COMMIT_THREAD=$(printf '%s\n' $COMMIT_THREAD | sed -E s/'\ ?[[:graph:]]*$'//) ;
|
||
SUPERCOMMIT=$(printf '%s\n' $COMMIT_THREAD | sed -E s/'\ ?[[:graph:]]*$'// | awk '{ print $(NF) }')
|
||
# printf '%s\n' "COMMIT_THREAD=$COMMIT_THREAD ; SUPERCOMMIT=$SUPERCOMMIT" >&2
|
||
done
|
||
fi
|
||
# printf '%s\n' "COMMIT THREAD for MODULE THREAD $MODULE_THREAD : $COMMIT_THREAD" >&2
|
||
printf '%s\n' "* git ${SUBCOMMAND} $ARGSNOLAST $COMMIT" >&2
|
||
git ${SUBCOMMAND} $ARGSNOLAST $COMMIT
|
||
needcommit_ret=$(($needcommit_ret + $?))
|
||
return $needcommit_ret
|
||
}
|
||
|
||
command_needtwocommits () {
|
||
SUBCOMMAND="$1"
|
||
shift 1
|
||
if [ $# -ge 1 ]; then
|
||
eval LASTARG=\${$#}
|
||
n=$(($# - 1))
|
||
eval ARGSNOLAST=\${@:1:$n}
|
||
else
|
||
printf '%s\n' "No argument given, aborting." >&2
|
||
return 1
|
||
fi
|
||
COMMITRANGE=$LASTARG
|
||
COMMIT_A=$(printf '%s\n' "$COMMITRANGE" | sed -E 's/\.{2,}.*//')
|
||
COMMIT_B=$(printf '%s\n' "$COMMITRANGE" | sed -E 's/.*\.{2,}//')
|
||
SEPARATOR=$(printf '%s\n' "$COMMITRANGE" | sed -E 's/.*[^.](\.{2,})[^.].*/\1/')
|
||
SUBMODULE_LIST=$(git submodule --quiet foreach 'echo $displaypath' | tr '\n' ' ')
|
||
# printf '%s\n' "SUBMODULE_LIST: $SUBMODULE_LIST" >&2
|
||
MODULE_THREAD=$(printf '%s' "$MODULE_THREAD $MODULE" | sed s/'^\ '//)
|
||
# printf '%s\n' "MODULE_THREAD=$MODULE_THREAD" >&2
|
||
COMMIT_A_THREAD=$(printf '%s' "$COMMIT_A_THREAD $COMMIT_A" | sed s/'^\ '//)
|
||
# printf '%s\n' "COMMIT_A_THREAD=$COMMIT_A_THREAD" >&2
|
||
COMMIT_B_THREAD=$(printf '%s' "$COMMIT_B_THREAD $COMMIT_B" | sed s/'^\ '//)
|
||
# printf '%s\n' "COMMIT_B_THREAD=$COMMIT_B_THREAD" >&2
|
||
if [ "x$SUBMODULE_LIST" != "x" ]; then
|
||
for SUBMODULE in $SUBMODULE_LIST; do
|
||
printf '%s\n' "* git ls-tree $COMMIT_A $SUBMODULE" >&2
|
||
git ls-tree $COMMIT_A $SUBMODULE
|
||
SUBCOMMIT_A=$(git ls-tree --object-only $COMMIT_A $SUBMODULE)
|
||
printf '%s\n' "* git ls-tree $COMMIT_B $SUBMODULE" >&2
|
||
git ls-tree $COMMIT_B $SUBMODULE
|
||
SUBCOMMIT_B=$(git ls-tree --object-only $COMMIT_B $SUBMODULE)
|
||
printf '%s\n' "* cd $SUBMODULE" >&2
|
||
cd $SUBMODULE
|
||
pwd
|
||
# Quand on descend dans le submodule
|
||
# supermodule devient le module précédent
|
||
# module devient le submodule précédent
|
||
# printf '%s\n' "SUPERMODULE=$MODULE ; MODULE=$SUBMODULE" >&2
|
||
SUPERMODULE=$MODULE ; MODULE=$SUBMODULE
|
||
# Quand on descend dans le submodule
|
||
# supercommit devient le commit précédent
|
||
# commit devient le subcommit précédent
|
||
# printf '%s\n' "SUPERCOMMIT_A=$COMMIT_A ; COMMIT_A=$SUBCOMMIT_A" >&2
|
||
SUPERCOMMIT_A=$COMMIT_A ; COMMIT_A=$SUBCOMMIT_A ;
|
||
# printf '%s\n' "SUPERCOMMIT_B=$COMMIT_B ; COMMIT_B=$SUBCOMMIT_B" >&2
|
||
SUPERCOMMIT_B=$COMMIT_B ; COMMIT_B=$SUBCOMMIT_B ;
|
||
command_needtwocommits $SUBCOMMAND $ARGSNOLAST ${COMMIT_A}${SEPARATOR}${COMMIT_B};
|
||
printf '%s\n' "* cd .." >&2
|
||
cd ../
|
||
pwd
|
||
# Quand on remonte dans le supermodule
|
||
# submodule devient le module précédent
|
||
# module devient le supermodule précédent
|
||
# supermodule devient l'avant-dernier item du module thread
|
||
# printf '%s\n' "SUBMODULE=$MODULE ; MODULE=$SUPERMODULE" >&2
|
||
SUBMODULE=$MODULE ; MODULE=$SUPERMODULE ;
|
||
MODULE_THREAD=$(printf '%s\n' $MODULE_THREAD | sed -E s/'\ ?[[:graph:]]*$'//) ;
|
||
SUPERMODULE=$(printf '%s\n' $MODULE_THREAD | sed -E s/'\ ?[[:graph:]]*$'// | awk '{ print $(NF) }')
|
||
# printf '%s\n' "MODULE_THREAD=$MODULE_THREAD ; SUPERMODULE=$SUPERMODULE" >&2
|
||
# Quand on remonte dans le supermodule
|
||
# subcommit devient le commit précédent
|
||
# commit devient le supercommit précédent
|
||
# supercommit devient l'avant-dernier item du commit thread
|
||
# printf '%s\n' "SUBCOMMIT_A=$COMMIT_A ; COMMIT_A=$SUPERCOMMIT_A" >&2
|
||
SUBCOMMIT_A=$COMMIT_A ; COMMIT_A=$SUPERCOMMIT_A ;
|
||
COMMIT_A_THREAD=$(printf '%s\n' $COMMIT_A_THREAD | sed -E s/'\ ?[[:graph:]]*$'//) ;
|
||
SUPERCOMMIT_A=$(printf '%s\n' $COMMIT_A_THREAD | sed -E s/'\ ?[[:graph:]]*$'// | awk '{ print $(NF) }')
|
||
# printf '%s\n' "SUBCOMMIT_B=$COMMIT_B ; COMMIT_B=$SUPERCOMMIT_B" >&2
|
||
SUBCOMMIT_B=$COMMIT_B ; COMMIT_B=$SUPERCOMMIT_B ;
|
||
COMMIT_B_THREAD=$(printf '%s\n' $COMMIT_B_THREAD | sed -E s/'\ ?[[:graph:]]*$'//) ;
|
||
SUPERCOMMIT_B=$(printf '%s\n' $COMMIT_B_THREAD | sed -E s/'\ ?[[:graph:]]*$'// | awk '{ print $(NF) }')
|
||
# printf '%s\n' "COMMIT_A_THREAD=$COMMIT_A_THREAD ; SUPERCOMMIT_A=$SUPERCOMMIT_A" >&2
|
||
# printf '%s\n' "COMMIT_B_THREAD=$COMMIT_B_THREAD ; SUPERCOMMIT_B=$SUPERCOMMIT_B" >&2
|
||
done
|
||
fi
|
||
# printf '%s\n' "COMMIT_A THREAD for MODULE THREAD $MODULE_THREAD : $COMMIT_A_THREAD" >&2
|
||
# printf '%s\n' "COMMIT_B THREAD for MODULE THREAD $MODULE_THREAD : $COMMIT_B_THREAD" >&2
|
||
printf '%s\n' "* git ${SUBCOMMAND} $ARGSNOLAST ${COMMIT_A}${SEPARATOR}${COMMIT_B}" >&2
|
||
git ${SUBCOMMAND} $ARGSNOLAST ${COMMIT_A}${SEPARATOR}${COMMIT_B}
|
||
needtwocommits_ret=$(($needtwocommits_ret + $?))
|
||
return $needtwocommits_ret
|
||
}
|
||
|
||
command_generic () {
|
||
if [ $# -ge 1 ]; then
|
||
eval LASTARG=\${$#}
|
||
n=$(($# - 1))
|
||
eval ARGSNOLAST=\${@:1:$n}
|
||
# check if argument has '..' in it
|
||
printf '%s\n' "$LASTARG" | grep '\.\.'
|
||
ret=$?
|
||
if [ "$ret" -eq 0 ]; then
|
||
command_needtwocommits "$@"
|
||
return $?
|
||
else
|
||
# check if argument is a branch
|
||
isbranch=$(git branch -a | grep -v 'remotes/origin/HEAD' | sed s#remotes/origin/## | grep -c -- "$LASTARG")
|
||
# check if argument is a revision (commit or tag)
|
||
argtype=$(git cat-file -t -- $LASTARG 2>/dev/null)
|
||
if [ $isbranch -eq 0 ] && ( [ "x$argtype" = "xcommit" ] || [ "x$argtype" = "xtag" ] ); then
|
||
command_needcommit "$@"
|
||
return $?
|
||
fi
|
||
fi
|
||
# else
|
||
# # LASTARG=$DEFAULT_BRANCH
|
||
# # LASTARG=$(git rev-parse HEAD)
|
||
# ARGSNOLAST=${@}
|
||
# command_noneedcommit "$@"
|
||
# return $?
|
||
fi
|
||
noneedcommit_ret=0
|
||
command_noneedcommit "$@"
|
||
generic_ret=$?
|
||
return $generic_ret
|
||
}
|
||
|
||
command_revert_add () {
|
||
SUBCOMMAND="$1"
|
||
shift 1
|
||
if [ $# -ge 1 ]; then
|
||
eval LASTARG=\${$#}
|
||
n=$(($# - 1))
|
||
eval ARGSNOLAST=\${@:1:$n}
|
||
else
|
||
LASTARG=$(git rev-parse HEAD)
|
||
ARGSNOLAST=${@}
|
||
fi
|
||
COMMIT=$LASTARG
|
||
SUBMODULE_LIST=$(git submodule --quiet foreach 'echo $displaypath' | tr '\n' ' ')
|
||
# printf '%s\n' "SUBMODULE_LIST: $SUBMODULE_LIST" >&2
|
||
MODULE_THREAD=$(printf '%s' "$MODULE_THREAD $MODULE" | sed s/'^\ '//)
|
||
# printf '%s\n' "MODULE_THREAD=$MODULE_THREAD" >&2
|
||
COMMIT_THREAD=$(printf '%s' "$COMMIT_THREAD $COMMIT" | sed s/'^\ '//)
|
||
# printf '%s\n' "COMMIT_THREAD=$COMMIT_THREAD" >&2
|
||
if [ "x$SUBMODULE_LIST" != "x" ]; then
|
||
for SUBMODULE in $SUBMODULE_LIST; do
|
||
printf '%s\n' "* git ls-tree $COMMIT $SUBMODULE" >&2
|
||
git ls-tree $COMMIT $SUBMODULE
|
||
# SUBCOMMIT=$(git ls-tree $COMMIT $SUBMODULE | awk '{ print $3 }')
|
||
SUBCOMMIT=$(git ls-tree --object-only $COMMIT $SUBMODULE)
|
||
printf '%s\n' "* cd $SUBMODULE" >&2
|
||
cd $SUBMODULE
|
||
pwd
|
||
# Quand on descend dans le submodule
|
||
# supermodule devient le module précédent
|
||
# module devient le submodule précédent
|
||
# printf '%s\n' "SUPERMODULE=$MODULE ; MODULE=$SUBMODULE" >&2
|
||
SUPERMODULE=$MODULE ; MODULE=$SUBMODULE
|
||
# Quand on descend dans le submodule
|
||
# supercommit devient le commit précédent
|
||
# commit devient le subcommit précédent
|
||
# printf '%s\n' "SUPERCOMMIT=$COMMIT ; COMMIT=$SUBCOMMIT" >&2
|
||
SUPERCOMMIT=$COMMIT ; COMMIT=$SUBCOMMIT ;
|
||
command_revert_add $SUBCOMMAND $ARGSNOLAST $COMMIT;
|
||
printf '%s\n' "* cd .." >&2
|
||
cd ../
|
||
pwd
|
||
# Quand on remonte dans le supermodule
|
||
# submodule devient le module précédent
|
||
# module devient le supermodule précédent
|
||
# supermodule devient l'avant-dernier item du module thread
|
||
# printf '%s\n' "SUBMODULE=$MODULE ; MODULE=$SUPERMODULE" >&2
|
||
SUBMODULE=$MODULE ; MODULE=$SUPERMODULE ;
|
||
MODULE_THREAD=$(printf '%s\n' $MODULE_THREAD | sed -E s/'\ ?[[:graph:]]*$'//) ;
|
||
SUPERMODULE=$(printf '%s\n' $MODULE_THREAD | sed -E s/'\ ?[[:graph:]]*$'// | awk '{ print $(NF) }')
|
||
# printf '%s\n' "MODULE_THREAD=$MODULE_THREAD ; SUPERMODULE=$SUPERMODULE" >&2
|
||
printf '%s\n' "* git add $SUBMODULE" >&2
|
||
git add $SUBMODULE
|
||
# Quand on remonte dans le supermodule
|
||
# subcommit devient le commit précédent
|
||
# commit devient le supercommit précédent
|
||
# supercommit devient l'avant-dernier item du commit thread
|
||
# printf '%s\n' "SUBCOMMIT=$COMMIT ; COMMIT=$SUPERCOMMIT" >&2
|
||
SUBCOMMIT=$COMMIT ; COMMIT=$SUPERCOMMIT ;
|
||
COMMIT_THREAD=$(printf '%s\n' $COMMIT_THREAD | sed -E s/'\ ?[[:graph:]]*$'//) ;
|
||
SUPERCOMMIT=$(printf '%s\n' $COMMIT_THREAD | sed -E s/'\ ?[[:graph:]]*$'// | awk '{ print $(NF) }')
|
||
# printf '%s\n' "COMMIT_THREAD=$COMMIT_THREAD ; SUPERCOMMIT=$SUPERCOMMIT" >&2
|
||
done
|
||
fi
|
||
# printf '%s\n' "COMMIT THREAD for MODULE THREAD $MODULE_THREAD : $COMMIT_THREAD" >&2
|
||
printf '%s\n' "* git revert --no-edit --no-commit $ARGSNOLAST $COMMIT" >&2
|
||
git revert --no-edit --no-commit $ARGSNOLAST $COMMIT
|
||
revert_add_ret=$(($revert_add_ret + $?))
|
||
return $revert_add_ret
|
||
}
|
||
|
||
command_add_commit () {
|
||
SUBCOMMAND="$1"
|
||
shift 1
|
||
if [ $# -ge 1 ]; then
|
||
eval LASTARG=\${$#}
|
||
n=$(($# - 1))
|
||
eval ARGSNOLAST=\${@:1:$n}
|
||
else
|
||
LASTARG=$(git rev-parse HEAD)
|
||
ARGSNOLAST=${@}
|
||
fi
|
||
if [ "x$commit_type" = "xrevert" ]; then
|
||
COMMIT=$LASTARG
|
||
elif [ "x$commit_type" = "xmerge" ]; then
|
||
BRANCH=$LASTARG
|
||
fi
|
||
SUBMODULE_LIST=$(git submodule --quiet foreach 'echo $displaypath' | tr '\n' ' ')
|
||
# printf '%s\n' "SUBMODULE_LIST: $SUBMODULE_LIST" >&2
|
||
MODULE_THREAD=$(printf '%s' "$MODULE_THREAD $MODULE" | sed s/'^\ '//)
|
||
# printf '%s\n' "MODULE_THREAD=$MODULE_THREAD" >&2
|
||
COMMIT_THREAD=$(printf '%s' "$COMMIT_THREAD $COMMIT" | sed s/'^\ '//)
|
||
# printf '%s\n' "COMMIT_THREAD=$COMMIT_THREAD" >&2
|
||
if [ "x$SUBMODULE_LIST" != "x" ]; then
|
||
for SUBMODULE in $SUBMODULE_LIST; do
|
||
if [ "x$commit_type" = "xrevert" ]; then
|
||
printf '%s\n' "* git ls-tree $COMMIT $SUBMODULE" >&2
|
||
git ls-tree $COMMIT $SUBMODULE
|
||
# SUBCOMMIT=$(git ls-tree $COMMIT $SUBMODULE | awk '{ print $3 }')
|
||
SUBCOMMIT=$(git ls-tree --object-only $COMMIT $SUBMODULE)
|
||
fi
|
||
printf '%s\n' "* cd $SUBMODULE" >&2
|
||
cd $SUBMODULE
|
||
pwd
|
||
# Quand on descend dans le submodule
|
||
# supermodule devient le module précédent
|
||
# module devient le submodule précédent
|
||
# printf '%s\n' "SUPERMODULE=$MODULE ; MODULE=$SUBMODULE" >&2
|
||
SUPERMODULE=$MODULE ; MODULE=$SUBMODULE
|
||
if [ "x$commit_type" = "xrevert" ]; then
|
||
# Quand on descend dans le submodule
|
||
# supercommit devient le commit précédent
|
||
# commit devient le subcommit précédent
|
||
# printf '%s\n' "SUPERCOMMIT=$COMMIT ; COMMIT=$SUBCOMMIT" >&2
|
||
SUPERCOMMIT=$COMMIT ; COMMIT=$SUBCOMMIT ;
|
||
command_add_commit $SUBCOMMAND $ARGSNOLAST $COMMIT;
|
||
else
|
||
command_add_commit $SUBCOMMAND "$@";
|
||
fi
|
||
printf '%s\n' "* cd .." >&2
|
||
cd ../
|
||
pwd
|
||
# Quand on remonte dans le supermodule
|
||
# submodule devient le module précédent
|
||
# module devient le supermodule précédent
|
||
# supermodule devient l'avant-dernier item du module thread
|
||
# printf '%s\n' "SUBMODULE=$MODULE ; MODULE=$SUPERMODULE" >&2
|
||
SUBMODULE=$MODULE ; MODULE=$SUPERMODULE ;
|
||
MODULE_THREAD=$(printf '%s\n' $MODULE_THREAD | sed -E s/'\ ?[[:graph:]]*$'//) ;
|
||
SUPERMODULE=$(printf '%s\n' $MODULE_THREAD | sed -E s/'\ ?[[:graph:]]*$'// | awk '{ print $(NF) }')
|
||
# printf '%s\n' "MODULE_THREAD=$MODULE_THREAD ; SUPERMODULE=$SUPERMODULE" >&2
|
||
printf '%s\n' "* git add $SUBMODULE" >&2
|
||
git add $SUBMODULE
|
||
if [ "x$commit_type" = "xrevert" ]; then
|
||
# Quand on remonte dans le supermodule
|
||
# subcommit devient le commit précédent
|
||
# commit devient le supercommit précédent
|
||
# supercommit devient l'avant-dernier item du commit thread
|
||
# printf '%s\n' "SUBCOMMIT=$COMMIT ; COMMIT=$SUPERCOMMIT" >&2
|
||
SUBCOMMIT=$COMMIT ; COMMIT=$SUPERCOMMIT ;
|
||
COMMIT_THREAD=$(printf '%s\n' $COMMIT_THREAD | sed -E s/'\ ?[[:graph:]]*$'//) ;
|
||
SUPERCOMMIT=$(printf '%s\n' $COMMIT_THREAD | sed -E s/'\ ?[[:graph:]]*$'// | awk '{ print $(NF) }')
|
||
# printf '%s\n' "COMMIT_THREAD=$COMMIT_THREAD ; SUPERCOMMIT=$SUPERCOMMIT" >&2
|
||
fi
|
||
done
|
||
fi
|
||
if [ "x$commit_type" = "xrevert" ]; then
|
||
# printf '%s\n' "COMMIT THREAD for MODULE THREAD $MODULE_THREAD : $COMMIT_THREAD" >&2
|
||
printf '%s\n' "* git commit -m \"Revert commit ${COMMIT}\"" >&2
|
||
git commit -m "Revert commit ${COMMIT}"
|
||
add_commit_ret=$(($add_commit_ret + $?))
|
||
return $add_commit_ret
|
||
elif [ "x$commit_type" = "xmerge" ]; then
|
||
BRANCH_CUR=$(git rev-parse --abbrev-ref HEAD)
|
||
printf '%s\n' "* git commit -m \"Merge branch '${BRANCH}'\"" >&2
|
||
git commit -m "Merge branch '${BRANCH}'"
|
||
add_commit_ret=$(($add_commit_ret + $?))
|
||
return $add_commit_ret
|
||
else
|
||
printf '%s\n' "* git commit $@" >&2
|
||
git commit "$@"
|
||
add_commit_ret=$(($add_commit_ret + $?))
|
||
return $add_commit_ret
|
||
fi
|
||
}
|
||
|
||
command_revert_add_commit () {
|
||
if [ $# -ge 1 ]; then
|
||
eval LASTARG=\${$#}
|
||
n=$(($# - 1))
|
||
eval ARGSNOLAST=${@:1:$n}
|
||
# check if argument is a commit
|
||
printf '%s\n' "commit:$LASTARG" >&2
|
||
COMMIT=$(printf '%s\n' $LASTARG | sed 's/^ *//')
|
||
COMMIT_THREAD="$COMMIT"
|
||
else
|
||
printf "%s\n" "USAGE: $0 rollback <commit_hash>"
|
||
exit 1;
|
||
fi;
|
||
|
||
command_revert_add "$@" || return $?
|
||
commit_type='revert'
|
||
command_add_commit "$@" || return $?
|
||
}
|
||
|
||
command_merge_add_commit () {
|
||
SUBCOMMAND="$1"
|
||
shift 1
|
||
if [ $# -ge 1 ]; then
|
||
eval LASTARG=\${$#}
|
||
n=$(($# - 1))
|
||
eval ARGSNOLAST=${@:1:$n}
|
||
# check if argument is a branch
|
||
isbranch=$(git branch -a | grep -v 'remotes/origin/HEAD' | sed s#remotes/origin/## | grep -c -- "$LASTARG")
|
||
if [ $isbranch -eq 1 ]; then
|
||
printf '%s\n' "branch_to_merge:$LASTARG" >&2
|
||
BRANCH=$(printf '%s\n' $LASTARG | sed 's/^ *//')
|
||
fi
|
||
# check if we are in a branch
|
||
BRANCH_CUR=$(git rev-parse --abbrev-ref HEAD)
|
||
BRANCH_LIST=$(git branch | sed 's/^[*]\?\ *//g')
|
||
for i in $BRANCH_LIST; do
|
||
if [ "${i}" = "${BRANCH_CUR}" ]; then
|
||
isinbranch=1
|
||
break
|
||
fi
|
||
done
|
||
fi
|
||
if [ $# -lt 1 ] || [ $isbranch -eq 0 ] || [ $isinbranch -eq 0 ]; then
|
||
printf "%s\n" "USAGE: $0 checkout <target_branch> && $0 fusion <branch_to_merge>"
|
||
exit 1;
|
||
fi;
|
||
|
||
command_generic merge --no-commit --squash "$@" || return $?
|
||
commit_type='merge'
|
||
command_add_commit $SUBCOMMAND "$@" || return $?
|
||
}
|
||
|
||
#TODO: lister les N submodules dans le dépôt
|
||
#SUBMODULES=$(git submodule --quiet foreach --recursive 'echo $sm_path')
|
||
SUBMODULES=$(git submodule --quiet foreach --recursive 'echo $displaypath')
|
||
|
||
cd $CONFIGS_REPO
|
||
MODULE='.'
|
||
#MODULE_THREAD="$MODULE"
|
||
committype=''
|
||
|
||
case ${SUBCOMMAND} in
|
||
add)
|
||
command_noneedcommit "$@"
|
||
;;
|
||
fetch)
|
||
command_noneedcommit "$@"
|
||
;;
|
||
log)
|
||
# command_noneedcommit "$@"
|
||
command_generic "$@"
|
||
;;
|
||
pull)
|
||
command_noneedcommit "$@"
|
||
;;
|
||
push)
|
||
command_noneedcommit "$@"
|
||
;;
|
||
reset)
|
||
# command_noneedcommit "$@"
|
||
command_generic "$@"
|
||
;;
|
||
shortlog)
|
||
# pas pertinent ?
|
||
# command_noneedcommit "$@"
|
||
command_generic "$@"
|
||
;;
|
||
stash)
|
||
# pas pertinent ? peut faciliter la vie... voir en fonction de la complexité
|
||
command_noneedcommit "$@"
|
||
;;
|
||
status)
|
||
command_noneedcommit "$@"
|
||
;;
|
||
whatchanged)
|
||
command_noneedcommit "$@"
|
||
;;
|
||
list-branches)
|
||
SUBCOMMAND="branch"
|
||
shift 1
|
||
command_generic $SUBCOMMAND "$@"
|
||
;;
|
||
list-commits)
|
||
SUBCOMMAND="log --pretty=oneline -n1"
|
||
shift 1
|
||
command_generic $SUBCOMMAND "$@"
|
||
;;
|
||
checkout)
|
||
isinbranch=0
|
||
BRANCH_CUR=$(git rev-parse --abbrev-ref HEAD)
|
||
if [ "$BRANCH_CUR" = "HEAD" ]; then
|
||
COMMIT_CUR=$(git rev-parse HEAD)
|
||
fi
|
||
BRANCH_LIST=$(git branch | sed 's/^[*]\?\ *//g')
|
||
for i in $BRANCH_LIST; do
|
||
if [ "${i}" = "${BRANCH_CUR}" ]; then
|
||
isinbranch=1
|
||
break
|
||
fi
|
||
done
|
||
if [ $isinbranch -eq 0 ]; then
|
||
BRANCH_CUR=$DEFAULT_BRANCH
|
||
fi
|
||
command_generic "$@"
|
||
ret=$?
|
||
# if it failed, we go back to the previous branch (or the default)
|
||
if [ $ret -ne 0 ]; then
|
||
printf '%s\n' "*** *** /!\ CHECKOUT FAILED! Moving back to ${BRANCH_CUR} /!\ *** ***" >&2
|
||
command_generic checkout "$BRANCH_CUR"
|
||
fi
|
||
;;
|
||
diff)
|
||
# command_noneedcommit "$@"
|
||
command_generic "$@"
|
||
;;
|
||
commit)
|
||
BRANCH_CUR=$(git rev-parse --abbrev-ref HEAD)
|
||
if [ "$BRANCH_CUR" = "$DEFAULT_BRANCH" ] ; then
|
||
printf '%s\n' "Committing in $BRANCH_CUR not supported !" >&2
|
||
printf '%s\n' "Create a new branch with $0 newfeature <branch name> instead." >&2
|
||
exit 1
|
||
else
|
||
command_add_commit "$@"
|
||
fi
|
||
;;
|
||
# reset)
|
||
# ;;
|
||
tag)
|
||
command_generic "$@"
|
||
;;
|
||
# switch)
|
||
# ;;
|
||
branch) # some features replaced with newfeature/delfeature
|
||
command_noneedcommit "$@"
|
||
;;
|
||
# merge) # replaced with fusion
|
||
# command_noneedcommit "$@"
|
||
# ;;
|
||
# rebase)
|
||
#
|
||
# rebase is complicated. It error-prone and requires a lot of user
|
||
# interaction. It's better to do it by hand. You should not use it
|
||
# very often anyway.
|
||
#
|
||
# ;;
|
||
# revert) # replaced with rollback
|
||
# ;;
|
||
fusion)
|
||
command_merge_add_commit "$@"
|
||
;;
|
||
rollback)
|
||
command_revert_add_commit "$@"
|
||
ret=$?
|
||
# if it failed, then
|
||
# 1. stash the uncommitted changes
|
||
# 2. reset --hard HEAD^
|
||
# 3. apply the stashed changes
|
||
if [ $ret -ne 0 ]; then
|
||
printf '%s\n' "ERROR: rollback failed." >&2
|
||
# command_checkout "$BRANCH_CUR"
|
||
fi
|
||
;;
|
||
newfeature)
|
||
if [ $# -ge 2 ]; then
|
||
eval LASTARG=\${$#}
|
||
n=$(($# - 1))
|
||
eval ARGSNOLAST=${@:1:$n}
|
||
BRANCH="$LASTARG"
|
||
else
|
||
printf "%s\n" "USAGE: $0 newfeature branch_name"
|
||
exit 1;
|
||
fi;
|
||
printf '%s\n' "* $0 branch $BRANCH" >&2
|
||
$0 branch "$BRANCH"
|
||
|
||
printf '%s\n' "* $0 checkout $BRANCH" >&2
|
||
$0 checkout "$BRANCH"
|
||
;;
|
||
delfeature)
|
||
if [ $# -ge 2 ]; then
|
||
eval LASTARG=\${$#}
|
||
n=$(($# - 1))
|
||
eval ARGSNOLAST=${@:1:$n}
|
||
BRANCH="$LASTARG"
|
||
else
|
||
printf "%s\n" "USAGE: $0 delfeature branch_name"
|
||
exit 1;
|
||
fi;
|
||
printf '%s\n' "* $0 checkout $DEFAULT_BRANCH" >&2
|
||
$0 checkout $DEFAULT_BRANCH
|
||
|
||
printf '%s\n' "* $0 branch -d $BRANCH" >&2
|
||
$0 branch -d "$BRANCH"
|
||
|
||
# printf '%s\n' "* $0 branch -D $BRANCH"
|
||
# $0 branch -D "$BRANCH"
|
||
|
||
# printf '%s\n' "* $0 push origin :$BRANCH"
|
||
# $0 push origin :$BRANCH
|
||
|
||
# printf '%s\n' "* $0 fetch --prune"
|
||
# $0 fetch --prune
|
||
|
||
#TODO: code qui supprime la branche dans /tmp sur auto-ansible.in
|
||
;;
|
||
*)
|
||
printf '%s\n' "Subcommand ${SUBCOMMAND} not supported, use git directly" >&2
|
||
exit 1;
|
||
;;
|
||
esac
|