521 lines
17 KiB
Bash
Executable File
521 lines
17 KiB
Bash
Executable File
#!/bin/bash
|
|
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
source "$(dirname -- "$0")/../load.sh" || exit 1
|
|
require: git pman pman.conf
|
|
|
|
### description des variables ###
|
|
# * PMAN_TOOL -- nom de l'outil, e.g pdev, pmain, pdist
|
|
# * PMAN_BRANCH -- code de la branche de référence basé sur le nom de l'outil
|
|
# * PMAN_UNIQUE -- si cette branche est unique
|
|
# * PMAN_CREATE_BASE -- branche de base à partir de laquelle créer la branche
|
|
# * PMAN_MERGE_FROM -- code de la branche source à partir de laquelle la fusion
|
|
# est faite dans PMAN_BRANCH. vide si la branche n'a pas de source
|
|
# * PMAN_MERGE_TO -- code de la branche destination dans laquelle la fusion est
|
|
# faite depuis PMAN_BRANCH. vide si la branche n'a pas de destination
|
|
# * PMAN_DIR -- direction de la fusion:
|
|
# "from" si on fait PMAN_MERGE_FROM --> PMAN_BRANCH
|
|
# "to" si on fait PMAN_BRANCH --> PMAN_MERGE_TO
|
|
# * PMAN_PREL_MERGE -- si la fusion devrait se faire avec prel
|
|
# * PMAN_DELETE_MERGED -- s'il faut supprimer la branche source après la fusion
|
|
# * PMAN_MERGE_SRC -- code de la branche source pour la fusion, ou vide si la
|
|
# fusion n'est pas possible
|
|
# * PMAN_MERGE_DEST -- code de la branche destination pour la fusion, ou vide si
|
|
# la fusion n'est pas possible
|
|
# * PMAN_CAN_MERGE -- indique si la fusion est possible
|
|
# * ${!PMAN_BRANCH} -- nom effectif de la branche si elle est définie dans
|
|
# .pman.conf
|
|
# * $PmanBranch -- nom effectif de la branche *si elle existe*, vide sinon
|
|
# * ${!PMAN_MERGE_SRC} -- nom effectif de la branche source si elle est définie
|
|
# dans .pman.conf
|
|
# * $PmanMergeSrc -- nom effectif de la branche source *si elle existe*, vide
|
|
# sinon
|
|
# * ${!PMAN_MERGE_DEST} -- nom effectif de la branche destination si elle est
|
|
# définie dans .pman.conf
|
|
# * $PmanMergeDest -- nom effectif de la branche source *si elle existe*, vide
|
|
# sinon
|
|
|
|
[ -n "$PMAN_TOOL" ] || PMAN_TOOL="$MYNAME"
|
|
PMAN_BRANCH="PMAN_TOOL_${PMAN_TOOL^^}"; PMAN_BRANCH="${!PMAN_BRANCH}"
|
|
function set_pman_vars() {
|
|
case "$PMAN_BRANCH" in
|
|
FEATURE|RELEASE|HOTFIX) PMAN_UNIQUE=;;
|
|
*) PMAN_UNIQUE=1;;
|
|
esac
|
|
PMAN_CREATE_BASE=$(get_create_base "$PMAN_BRANCH")
|
|
PMAN_MERGE_FROM=$(get_merge_from "$PMAN_BRANCH")
|
|
PMAN_MERGE_TO=$(get_merge_to "$PMAN_BRANCH")
|
|
if [ -n "$1" ]; then PMAN_DIR="$1"
|
|
else PMAN_DIR=to
|
|
#elif [ -n "$PMAN_MERGE_TO" ]; then PMAN_DIR=to
|
|
#else PMAN_DIR=from
|
|
fi
|
|
PMAN_PREL_MERGE=$(should_prel_merge "$PMAN_BRANCH" "$PMAN_DIR" && echo 1)
|
|
PMAN_DELETE_MERGED=$(should_delete_merged "$PMAN_BRANCH" "$PMAN_DIR" && echo 1)
|
|
case "$PMAN_DIR" in
|
|
to)
|
|
PMAN_MERGE_SRC="$PMAN_BRANCH"
|
|
PMAN_MERGE_DEST="$PMAN_MERGE_TO"
|
|
;;
|
|
from)
|
|
PMAN_MERGE_SRC="$PMAN_MERGE_FROM"
|
|
PMAN_MERGE_DEST="$PMAN_BRANCH"
|
|
;;
|
|
esac
|
|
[ -n "$PMAN_MERGE_SRC" -a -n "$PMAN_MERGE_DEST" ] && PMAN_CAN_MERGE=1 || PMAN_CAN_MERGE=
|
|
}
|
|
|
|
git_cleancheckout_DIRTY="\
|
|
Vous avez des modifications locales.
|
|
Enregistrez ces modifications avant de fusionner la branche"
|
|
|
|
function dump_action() {
|
|
enote "Valeurs des variables:
|
|
PMAN_TOOL=$PMAN_TOOL
|
|
PMAN_BRANCH=$PMAN_BRANCH${PMAN_BRANCH:+ !PMAN_BRANCH=${!PMAN_BRANCH} PmanBranch=$PmanBranch}
|
|
PMAN_CREATE_BASE=$PMAN_CREATE_BASE${PMAN_CREATE_BASE:+ !PMAN_CREATE_BASE=${!PMAN_CREATE_BASE} PmanCreateBase=$PmanCreateBase}
|
|
PMAN_MERGE_FROM=$PMAN_MERGE_FROM
|
|
PMAN_MERGE_TO=$PMAN_MERGE_TO
|
|
PMAN_DIR=$PMAN_DIR
|
|
PMAN_PREL_MERGE=$PMAN_PREL_MERGE
|
|
PMAN_DELETE_MERGED=$PMAN_DELETE_MERGED
|
|
PMAN_MERGE_SRC=$PMAN_MERGE_SRC${PMAN_MERGE_SRC:+ !PMAN_MERGE_SRC=${!PMAN_MERGE_SRC} PmanMergeSrc=$PmanMergeSrc}
|
|
PMAN_MERGE_DEST=$PMAN_MERGE_DEST${PMAN_MERGE_DEST:+ !PMAN_MERGE_DEST=${!PMAN_MERGE_DEST} PmanMergeDest=$PmanMergeDest}
|
|
PMAN_CAN_MERGE=$PMAN_CAN_MERGE
|
|
|
|
CurrentBranch=$CurrentBranch
|
|
LocalBranches=${LocalBranches[*]}
|
|
RemoteBranches=${RemoteBranches[*]}
|
|
AllBranches=${AllBranches[*]}
|
|
|
|
UpstreamBranch=$UpstreamBranch
|
|
FeatureBranches=${FeatureBranches[*]}
|
|
DevelopBranch=$DevelopBranch
|
|
ReleaseBranch=$ReleaseBranch
|
|
HotfixBranch=$HotfixBranch
|
|
MainBranch=$MainBranch
|
|
DistBranch=$DistBranch
|
|
"
|
|
}
|
|
|
|
#XXXX
|
|
#[ -n "${!PMAN_MERGE_SRC}" ] ||
|
|
# die "Aucune branche définie pour $PMAN_MERGE_SRC. Veuillez éditer le fichier .pman.conf"
|
|
|
|
function _ensure_branch() {
|
|
[ -n "${!PMAN_BRANCH}" ] || die "\
|
|
La branche $PMAN_BRANCH n'a pas été définie.
|
|
Veuillez éditer le fichier .pman.conf"
|
|
[ "$1" == init -o -n "$PmanBranch" ] || die "${!PMAN_BRANCH}: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
|
|
}
|
|
|
|
function _ensure_create_base() {
|
|
[ -n "${!PMAN_CREATE_BASE}" ] || die "\
|
|
La branche $PMAN_CREATE_BASE n'a pas été définie.
|
|
Veuillez éditer le fichier .pman.conf"
|
|
[ "$1" == init -o -n "$PmanCreateBase" ] || die "${!PMAN_CREATE_BASE}: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
|
|
}
|
|
|
|
function _ensure_merge_src() {
|
|
[ -n "${!PMAN_MERGE_SRC}" ] || die "\
|
|
La branche $PMAN_MERGE_SRC n'a pas été définie.
|
|
Veuillez éditer le fichier .pman.conf"
|
|
[ "$1" == init -o -n "$PmanMergeSrc" ] || die "${!PMAN_MERGE_SRC}: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
|
|
}
|
|
|
|
function _ensure_merge_dest() {
|
|
[ -n "${!PMAN_MERGE_DEST}" ] || die "\
|
|
La branche $PMAN_MERGE_DEST n'a pas été définie.
|
|
Veuillez éditer le fichier .pman.conf"
|
|
[ "$1" == init -o -n "$PmanMergeDest" ] || die "${!PMAN_MERGE_DEST}: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
|
|
}
|
|
|
|
function checkout_action() {
|
|
local -a push_branches
|
|
|
|
_ensure_branch init
|
|
if [ -n "$PmanBranch" ]; then
|
|
git checkout "$PmanBranch"
|
|
elif array_contains AllBranches "${!PMAN_BRANCH}"; then
|
|
enote "${!PMAN_BRANCH}: une branche du même nom existe dans l'origine"
|
|
ask_yesno "Voulez-vous basculer sur cette branche?" O || die
|
|
git checkout "${!PMAN_BRANCH}"
|
|
elif [ -n "$PMAN_CREATE_BASE" ]; then
|
|
_ensure_create_base
|
|
|
|
resolve_should_push
|
|
|
|
local SrcBranch="${!PMAN_CREATE_BASE}" DestBranch="${!PMAN_BRANCH}"
|
|
enote "Vous allez créer la branche ${COULEUR_BLEUE}$DestBranch${COULEUR_NORMALE} <-- ${COULEUR_ROUGE}$SrcBranch${COULEUR_NORMALE}"
|
|
ask_yesno "Voulez-vous continuer?" O || die
|
|
|
|
einfo "Création de la branche $DestBranch"
|
|
git checkout -b "$DestBranch" "$SrcBranch" || die
|
|
push_branches+=("$DestBranch")
|
|
|
|
_push_branches
|
|
fi
|
|
}
|
|
|
|
function ensure_branches() {
|
|
[ -n "$PMAN_CAN_MERGE" ] ||
|
|
die "${!PMAN_BRANCH}: Aucune configuration de fusion trouvée pour cette branche"
|
|
|
|
local branches
|
|
[ "$1" == -a ] && branches=AllBranches || branches=LocalBranches
|
|
|
|
SrcBranch="${!PMAN_MERGE_SRC}"
|
|
array_contains "$branches" "$SrcBranch" || die "$SrcBranch: branche source introuvable"
|
|
DestBranch="${!PMAN_MERGE_DEST}"
|
|
array_contains "$branches" "$DestBranch" || die "$DestBranch: branche destination introuvable"
|
|
}
|
|
|
|
function _show_action() {
|
|
local commits
|
|
setx commits=_list_commits
|
|
if [ -n "$commits" ]; then
|
|
if [ $ShowLevel -ge 2 ]; then
|
|
{
|
|
echo "\
|
|
# Commits à fusionner $SrcBranch --> $DestBranch
|
|
|
|
$commits
|
|
"
|
|
_sd_COLOR=always _show_diff
|
|
} | less -eRF
|
|
else
|
|
einfo "Commits à fusionner $SrcBranch --> $DestBranch"
|
|
eecho "$commits"
|
|
fi
|
|
fi
|
|
}
|
|
function show_action() {
|
|
git_check_cleancheckout || ewarn "$git_cleancheckout_DIRTY"
|
|
ensure_branches
|
|
_show_action "$@"
|
|
}
|
|
|
|
function _merge_action() {
|
|
enote "\
|
|
Ce script va
|
|
- fusionner la branche ${COULEUR_BLEUE}$SrcBranch${COULEUR_NORMALE} dans ${COULEUR_ROUGE}$DestBranch${COULEUR_NORMALE}${Push:+
|
|
- pousser les branches modifiées}"
|
|
ask_yesno "Voulez-vous continuer?" O || die
|
|
|
|
local script=".git/pman-merge.sh"
|
|
local -a push_branches delete_branches
|
|
local hook
|
|
local comment=
|
|
local or_die=" || exit 1"
|
|
|
|
_mscript_start
|
|
_scripta <<EOF
|
|
################################################################################
|
|
# merge
|
|
if [ -n "\$merge" ]; then
|
|
esection "Fusionner la branche"
|
|
EOF
|
|
hook="BEFORE_MERGE_$PMAN_MERGE_SRC"; [ -n "${!hook}" ] && _scripta <<EOF
|
|
(
|
|
${!hook}
|
|
)$or_die
|
|
EOF
|
|
_mscript_merge_branch
|
|
hook="AFTER_MERGE_$PMAN_MERGE_SRC"; [ -n "${!hook}" ] && _scripta <<EOF
|
|
(
|
|
${!hook}
|
|
)$or_die
|
|
EOF
|
|
_scripta <<EOF
|
|
fi
|
|
EOF
|
|
|
|
if [ -n "$ShouldDelete" ]; then
|
|
_scripta <<EOF
|
|
################################################################################
|
|
# delete
|
|
if [ -n "\$delete" ]; then
|
|
esection "Supprimer la branche"
|
|
EOF
|
|
_mscript_delete_branch
|
|
hook="AFTER_DELETE_$PMAN_MERGE_SRC"; [ -n "${!hook}" ] && _scripta <<EOF
|
|
(
|
|
${!hook}
|
|
)$or_die
|
|
EOF
|
|
_scripta <<EOF
|
|
fi
|
|
EOF
|
|
fi
|
|
|
|
_scripta <<EOF
|
|
################################################################################
|
|
# push
|
|
if [ -n "\$push" ]; then
|
|
esection "Pousser les branches"
|
|
EOF
|
|
hook="BEFORE_PUSH_$PMAN_MERGE_DEST"; [ -n "${!hook}" ] && _scripta <<EOF
|
|
(
|
|
${!hook}
|
|
)$or_die
|
|
EOF
|
|
_script_push_branches
|
|
if [ ${#delete_branches[*]} -gt 0 ]; then
|
|
_scripta <<<"if [ -n \"\$delete\" ]; then"
|
|
push_branches=("${delete_branches[@]}")
|
|
_script_push_branches
|
|
_scripta <<<fi
|
|
fi
|
|
hook="AFTER_PUSH_$PMAN_MERGE_DEST"; [ -n "${!hook}" ] && _scripta <<EOF
|
|
(
|
|
${!hook}
|
|
)$or_die
|
|
EOF
|
|
_scripta <<EOF
|
|
fi
|
|
EOF
|
|
|
|
[ -n "$Delete" -o -z "$ShouldDelete" ] && Deleted=1 || Deleted=
|
|
[ -n "$ShouldDelete" -a -n "$Delete" ] && ShouldDelete=
|
|
[ -n "$ShouldPush" -a -n "$Push" ] && ShouldPush=
|
|
if [ -n "$_Fake" ]; then
|
|
cat "$script"
|
|
elif ! "$script" merge ${Delete:+delete} ${Push:+push}; then
|
|
eimportant "\
|
|
Le script $script a été lancé avec les arguments 'merge${Delete:+ delete}${Push:+ push}'
|
|
En cas d'erreur de merge, veuillez corriger les erreurs puis continuer avec
|
|
git merge --continue
|
|
Sinon, veuillez consulter le script et/ou le relancer
|
|
./$script${Delete:+ delete}${Push:+ push}"
|
|
die
|
|
elif [ -n "$Deleted" -a -n "$Push" ]; then
|
|
[ -n "$_KeepScript" ] || rm "$script"
|
|
[ -n "$AfterMerge" ] && eval "$AfterMerge"
|
|
else
|
|
local msg="\
|
|
Le script $script a été lancé avec les arguments 'merge${Delete:+ delete}${Push:+ push}'
|
|
Vous pouvez consulter le script et/ou le relancer
|
|
./$script${ShouldDelete:+ delete}${ShouldPush:+ push}"
|
|
[ -n "$AfterMerge" ] && msg="$msg
|
|
Il y a aussi les commandes supplémentaires suivantes:
|
|
${AfterMerge//
|
|
/
|
|
}"
|
|
einfo "$msg"
|
|
fi
|
|
}
|
|
|
|
function merge_action() {
|
|
ensure_branches -a
|
|
|
|
if [ -n "$PMAN_PREL_MERGE" ]; then
|
|
[ -n "$ForceMerge" ] || die "$SrcBranch: cette branche doit être fusionnée dans $DestBranch avec prel"
|
|
fi
|
|
[ -n "$AfterMerge" ] || setx AfterMerge=qvals git checkout -q "$SrcBranch"
|
|
[ -n "$PMAN_DELETE_MERGED" ] || Delete=
|
|
[ -z "$_Fake" ] && git_ensure_cleancheckout
|
|
|
|
if ! array_contains LocalBranches "$SrcBranch" && array_contains AllBranches "$SrcBranch"; then
|
|
enote "$SrcBranch: une branche du même nom existe dans l'origine"
|
|
fi
|
|
if ! array_contains LocalBranches "$DestBranch" && array_contains AllBranches "$DestBranch"; then
|
|
enote "$DestBranch: une branche du même nom existe dans l'origine"
|
|
fi
|
|
array_contains LocalBranches "$SrcBranch" || die "$SrcBranch: branche locale introuvable"
|
|
array_contains LocalBranches "$DestBranch" || die "$DestBranch: branche locale introuvable"
|
|
|
|
resolve_should_push
|
|
_merge_action "$@"
|
|
}
|
|
|
|
function rebase_action() {
|
|
die "non implémenté"
|
|
}
|
|
|
|
################################################################################
|
|
# Programme principal
|
|
################################################################################
|
|
|
|
set_pman_vars
|
|
loaded_config=
|
|
if check_gitdir; then
|
|
load_branches all
|
|
load_config
|
|
if [ -n "${!PMAN_MERGE_SRC}" ]; then
|
|
load_branches current "${!PMAN_MERGE_SRC}"
|
|
loaded_config=1
|
|
elif [ -n "${!PMAN_BRANCH}" ]; then
|
|
load_branches current "${!PMAN_BRANCH}"
|
|
loaded_config=1
|
|
fi
|
|
fi
|
|
|
|
BranchDesc=
|
|
MergeSrcDesc=
|
|
MergeDestDesc=
|
|
if [ -n "$PMAN_BRANCH" ]; then
|
|
BranchDesc="${COULEUR_BLANCHE}<$PMAN_BRANCH>"
|
|
[ -n "${!PMAN_BRANCH}" -a -n "$PMAN_UNIQUE" ] && BranchDesc="$BranchDesc (${!PMAN_BRANCH})"
|
|
BranchDesc="$BranchDesc${COULEUR_NORMALE}"
|
|
fi
|
|
if [ -n "$PMAN_MERGE_SRC" ]; then
|
|
MergeSrcDesc="${COULEUR_BLEUE}<$PMAN_MERGE_SRC>"
|
|
[ -n "${!PMAN_MERGE_SRC}" -a -n "$PMAN_UNIQUE" ] && MergeSrcDesc="$MergeSrcDesc (${!PMAN_MERGE_SRC})"
|
|
MergeSrcDesc="$MergeSrcDesc${COULEUR_NORMALE}"
|
|
fi
|
|
if [ -n "$PMAN_MERGE_DEST" ]; then
|
|
MergeDestDesc="${COULEUR_ROUGE}<$PMAN_MERGE_DEST>"
|
|
[ -n "${!PMAN_MERGE_DEST}" -a -n "$PMAN_UNIQUE" ] && MergeDestDesc="$MergeDestDesc (${!PMAN_MERGE_DEST})"
|
|
MergeDestDesc="$MergeDestDesc${COULEUR_NORMALE}"
|
|
fi
|
|
|
|
[ -n "$PMAN_UNIQUE" ] &&
|
|
purpose="gérer la branche $BranchDesc" ||
|
|
purpose="gérer les branches $BranchDesc"
|
|
usage="--checkout"
|
|
variables=
|
|
args=(
|
|
-d:,--chdir:BASEDIR chdir= "\
|
|
répertoire dans lequel se placer avant de lancer les opérations"
|
|
-O:,--origin Origin= "++\
|
|
origine à partir de laquelle les branches distantes sont considérées"
|
|
-B:,--config-branch ConfigBranch= "++\
|
|
branche à partir de laquelle charger la configuration"
|
|
-c:,--config-file:CONFIG ConfigFile= "++\
|
|
fichier de configuration des branches. le fichier .pman.conf dans le répertoire
|
|
du dépôt est utilisé par défaut s'il existe. cette option est prioritaire sur
|
|
--config-branch"
|
|
--fake _Fake=1 "++option non documentée"
|
|
--keep-script _KeepScript=1 "++option non documentée"
|
|
--dump action=dump "++afficher les noms des branches"
|
|
)
|
|
if [ -n "$PmanBranch" -a -n "$PMAN_UNIQUE" ]; then
|
|
args+=(
|
|
--checkout action=checkout "++\
|
|
créer le cas échéant la branche $BranchDesc et basculer vers elle.
|
|
c'est l'option par défaut"
|
|
)
|
|
elif [ -z "$PMAN_UNIQUE" ]; then
|
|
args+=(
|
|
--checkout action=checkout "\
|
|
créer le cas échéant la branche $BranchDesc et basculer vers elle.
|
|
c'est l'option par défaut"
|
|
)
|
|
else
|
|
args+=(
|
|
--checkout action=checkout "\
|
|
créer la branche $MergeDestDesc et basculer vers elle.
|
|
c'est l'option par défaut"
|
|
)
|
|
fi
|
|
|
|
if [ -n "$PMAN_CAN_MERGE" ]; then
|
|
if [ -n "$PMAN_UNIQUE" ]; then
|
|
usage="${usage}|--show|--merge"
|
|
else
|
|
usage="${usage} $PMAN_BRANCH
|
|
--show|--merge"
|
|
fi
|
|
if [ "$PMAN_BRANCH" != "$PMAN_MERGE_SRC" ]; then
|
|
usage="$usage
|
|
|
|
NB: du fait de la configuration des branches, la fusion se fait dans le sens
|
|
inverse $MergeSrcDesc --> $MergeDestDesc"
|
|
else
|
|
usage="$usage
|
|
|
|
NB: La fusion se fait dans le sens $MergeSrcDesc --> $MergeDestDesc"
|
|
fi
|
|
variables="\
|
|
Les variables supplémentaires suivantes peuvent être définies:
|
|
BEFORE_MERGE_${PMAN_MERGE_SRC}
|
|
AFTER_MERGE_${PMAN_MERGE_SRC}"
|
|
args+=(
|
|
-w,--show '$action=show; inc@ ShowLevel' "\
|
|
lister ce qui serait fusionné dans la branche $MergeDestDesc"
|
|
# -b,--rebase action=rebase "\
|
|
#lancer git rebase -i sur la branche $MergeSrcDesc. cela permet de réordonner
|
|
#les commits pour nettoyer l'historique avant la fusion"
|
|
-m,--merge action=merge "\
|
|
fusionner la branche $MergeSrcDesc dans la branche $MergeDestDesc"
|
|
--tech-merge TechMerge=1 "++option non documentée"
|
|
-s:,--squash:COMMIT_MSG SquashMsg= "\
|
|
fusionner les modifications de la branche comme un seul commit"
|
|
)
|
|
if [ -n "$PMAN_PREL_MERGE" ]; then
|
|
args+=(
|
|
-f,--force-merge ForceMerge=1 "++\
|
|
forcer la fusion pour une branche qui devrait être traitée par prel"
|
|
)
|
|
fi
|
|
args+=(
|
|
-n,--no-push Push= "\
|
|
ne pas pousser les branches vers leur origine après la fusion"
|
|
--push Push=1 "++\
|
|
pousser les branches vers leur origine après la fusion.
|
|
c'est l'option par défaut"
|
|
)
|
|
if [ -n "$PMAN_DELETE_MERGED" ]; then
|
|
variables="${variables}
|
|
AFTER_DELETE_${PMAN_MERGE_SRC}"
|
|
args+=(
|
|
-k,--no-delete Delete= "\
|
|
ne pas supprimer la branche $MergeSrcDesc après la fusion dans la branche
|
|
$MergeDestDesc. cette option ne devrait pas être utilisée avec --squash"
|
|
--delete Delete=1 "++\
|
|
supprimer la branche $MergeSrcDesc après la fusion dans la branche
|
|
$MergeDestDesc.
|
|
c'est l'option par défaut"
|
|
)
|
|
fi
|
|
if [ -n "$PMAN_MERGE_DEST" ]; then
|
|
variables="${variables}
|
|
BEFORE_PUSH_${PMAN_MERGE_DEST}
|
|
AFTER_PUSH_${PMAN_MERGE_DEST}"
|
|
fi
|
|
args+=(
|
|
-a:,--after-merge AfterMerge= "\
|
|
évaluer le script spécifié après une fusion *réussie*"
|
|
)
|
|
fi
|
|
|
|
chdir=
|
|
Origin=
|
|
ConfigBranch=
|
|
ConfigFile=
|
|
_Fake=
|
|
_KeepScript=
|
|
action=checkout
|
|
ShowLevel=0
|
|
TechMerge=
|
|
SquashMsg=
|
|
Push=1
|
|
Delete=1
|
|
AfterMerge=
|
|
args=(
|
|
"$purpose"
|
|
"\
|
|
$usage
|
|
|
|
CONFIGURATION
|
|
|
|
Le fichier .pman.conf contient la configuration des branches.
|
|
$variables"
|
|
"${args[@]}"
|
|
)
|
|
parse_args "$@"; set -- "${args[@]}"
|
|
|
|
if [ -z "$loaded_config" -o -n "$chdir" -o -n "$ConfigFile" -o -n "$ConfigBranch" ]; then
|
|
# charger la configuration
|
|
ensure_gitdir "$chdir"
|
|
load_branches all
|
|
load_config
|
|
if [ -n "${!PMAN_MERGE_SRC}" ]; then
|
|
load_branches current "${!PMAN_MERGE_SRC}"
|
|
elif [ -n "${!PMAN_BRANCH}" ]; then
|
|
load_branches current "${!PMAN_BRANCH}"
|
|
fi
|
|
fi
|
|
resolve_should_push quiet
|
|
|
|
"${action}_action" "$@"
|