769 lines
24 KiB
Bash
769 lines
24 KiB
Bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
|
|
# configuration par défaut
|
|
# doit être identique au contenu de pman.conf
|
|
# les branches sont mergées dans cet ordre:
|
|
# upstream --> develop --> [release -->] main --> dist
|
|
# feature _/ hotfix _/
|
|
|
|
# branche upstream
|
|
UPSTREAM=
|
|
# branches de développement
|
|
DEVELOP=develop
|
|
FEATURE=wip/
|
|
# branche de préparation de release
|
|
RELEASE=release-
|
|
# branche de release
|
|
MAIN=master
|
|
TAG_PREFIX=
|
|
TAG_SUFFIX=
|
|
# branche de hotfix
|
|
HOTFIX=hotfix-
|
|
# branche de distribution
|
|
DIST=
|
|
# désactiver les releases automatiques?
|
|
NOAUTO=
|
|
|
|
CONFIG_VARS=(
|
|
UPSTREAM DEVELOP FEATURE RELEASE MAIN HOTFIX DIST
|
|
TAG_PREFIX TAG_SUFFIX NOAUTO
|
|
)
|
|
|
|
################################################################################
|
|
|
|
PMAN_BRANCHES=(UPSTREAM DEVELOP FEATURE MAIN DIST)
|
|
PMAN_TOOL_PDEV=DEVELOP
|
|
PMAN_TOOL_PWIP=FEATURE
|
|
PMAN_TOOL_PMAIN=MAIN
|
|
PMAN_TOOL_PDIST=DIST
|
|
UPSTREAM_BASE=DEVELOP ; UPSTREAM_MERGE_FROM= ; UPSTREAM_MERGE_TO=DEVELOP ; UPSTREAM_PREL= ; UPSTREAM_DELETE=
|
|
DEVELOP_BASE=MAIN ; DEVELOP_MERGE_FROM=FEATURE ; DEVELOP_MERGE_TO=MAIN ; DEVELOP_PREL=from ; DEVELOP_DELETE=to
|
|
MAIN_BASE=DEVELOP ; MAIN_MERGE_FROM=DEVELOP ; MAIN_MERGE_TO=DIST ; MAIN_PREL=to ; MAIN_DELETE=
|
|
DIST_BASE=MAIN ; DIST_MERGE_FROM=MAIN ; DIST_MERGE_TO= ; DIST_PREL= ; DIST_DELETE=
|
|
FEATURE_BASE=DEVELOP ; FEATURE_MERGE_FROM= ; FEATURE_MERGE_TO=DEVELOP ; FEATURE_PREL= ; FEATURE_DELETE=from
|
|
|
|
UPSTREAM_CREATE_FUNCTION=_create_upstream_action
|
|
|
|
function get_base_branch() {
|
|
# afficher la branche depuis laquelle créer la branche $1
|
|
# retourner 1 en cas d'erreur (pas de branche source)
|
|
local branch="$1" infos
|
|
[ -n "$branch" ] || return 1
|
|
infos="${branch^^}_BASE"; branch="${!infos}"
|
|
[ -n "$branch" ] && echo "$branch" || return 1
|
|
}
|
|
|
|
function get_merge_from_branch() {
|
|
# afficher la branche depuis laquelle la branche $1 doit merger
|
|
# retourner 1 en cas d'erreur (pas de branche source)
|
|
local branch="$1" infos
|
|
[ -n "$branch" ] || return 1
|
|
infos="${branch^^}_MERGE_FROM"; branch="${!infos}"
|
|
[ -n "$branch" ] && echo "$branch" || return 1
|
|
}
|
|
|
|
function get_merge_to_branch() {
|
|
# afficher la branche dans laquelle la branche $1 doit merger
|
|
# retourner 1 en cas d'erreur (pas de branche destination)
|
|
local branch="$1" infos
|
|
[ -n "$branch" ] || return 1
|
|
infos="${branch^^}_MERGE_TO"; branch="${!infos}"
|
|
[ -n "$branch" ] && echo "$branch" || return 1
|
|
}
|
|
|
|
function should_prel_merge() {
|
|
# tester si la branche $1 doit être mergée avec prel dans la direction
|
|
# $2(=to)
|
|
local branch="$1" merge_dir="${2:-to}" infos
|
|
[ -n "$branch" ] || return 1
|
|
infos="${branch^^}_PREL"
|
|
[ "${!infos}" == "$merge_dir" ]
|
|
}
|
|
|
|
function should_delete_merged() {
|
|
# tester si la branche $1 doit être supprimée après avoir été mergée dans la
|
|
# direction $2(=to)
|
|
local branch="$1" merge_dir="${2:-to}" infos
|
|
[ -n "$branch" ] || return 1
|
|
infos="${branch^^}_DELETE"
|
|
[ "${!infos}" == "$merge_dir" ]
|
|
}
|
|
|
|
: "
|
|
# description des variables #
|
|
|
|
* REF_BRANCH -- code de la branche de référence basé sur le nom de l'outil
|
|
* RefBranch -- nom effectif de la branche si elle est définie dans
|
|
.pman.conf, vide sinon
|
|
* IfRefBranch -- nom effectif de la branche *si elle existe*, vide sinon
|
|
|
|
* REF_UNIQUE -- si la branche de référence est unique. est vide pour les
|
|
codes de branches multiples, telle que FEATURE
|
|
|
|
* BASE_BRANCH -- branche de base à partir de laquelle créer la branche
|
|
de référence
|
|
* BaseBranch -- nom effectif de la branche de base si elle est définie
|
|
dans .pman.conf, vide sinon
|
|
* IfBaseBranch -- nom effectif de la branche de base *si elle existe*, vide
|
|
sinon
|
|
|
|
* MERGE_FROM -- code de la branche source à partir de laquelle la fusion
|
|
est faite dans REF_BRANCH. vide si la branche n'a pas de source
|
|
* MERGE_TO -- code de la branche destination dans laquelle la fusion est
|
|
faite depuis REF_BRANCH. vide si la branche n'a pas de destination
|
|
* MERGE_DIR -- direction de la fusion:
|
|
'from' si on fait REF_BRANCH --> MERGE_TO
|
|
'to' si on fait MERGE_FROM --> REF_BRANCH
|
|
* PREL_MERGE -- si la fusion devrait se faire avec prel
|
|
* DELETE_MERGED -- s'il faut supprimer la branche source après la fusion
|
|
|
|
* MERGE_SRC -- code de la branche source pour la fusion, ou vide si la
|
|
fusion n'est pas possible
|
|
* MergeSrc -- nom effectif de la branche source si elle est définie
|
|
dans .pman.conf
|
|
* IfMergeSrc -- nom effectif de la branche source *si elle existe*, vide
|
|
sinon
|
|
|
|
* MERGE_DEST -- code de la branche destination pour la fusion, ou vide si
|
|
la fusion n'est pas possible
|
|
* MergeDest -- nom effectif de la branche destination si elle est
|
|
définie dans .pman.conf
|
|
* IfMergeDest -- nom effectif de la branche source *si elle existe*, vide
|
|
sinon"
|
|
|
|
function set_pman_vars() {
|
|
RefBranch="${!REF_BRANCH}"
|
|
case "$REF_BRANCH" in
|
|
FEATURE|RELEASE|HOTFIX) REF_UNIQUE=;;
|
|
*) REF_UNIQUE=1;;
|
|
esac
|
|
|
|
BASE_BRANCH=$(get_base_branch "$REF_BRANCH")
|
|
[ -n "$BASE_BRANCH" ] && BaseBranch="${!BASE_BRANCH}" || BaseBranch=
|
|
|
|
MERGE_FROM=$(get_merge_from_branch "$REF_BRANCH")
|
|
MERGE_TO=$(get_merge_to_branch "$REF_BRANCH")
|
|
if [ -n "$1" ]; then MERGE_DIR="$1"
|
|
else MERGE_DIR=from
|
|
fi
|
|
PREL_MERGE=$(should_prel_merge "$REF_BRANCH" "$MERGE_DIR" && echo 1)
|
|
DELETE_MERGED=$(should_delete_merged "$REF_BRANCH" "$MERGE_DIR" && echo 1)
|
|
case "$MERGE_DIR" in
|
|
from)
|
|
MERGE_SRC="$REF_BRANCH"
|
|
MERGE_DEST="$MERGE_TO"
|
|
;;
|
|
to)
|
|
MERGE_SRC="$MERGE_FROM"
|
|
MERGE_DEST="$REF_BRANCH"
|
|
;;
|
|
esac
|
|
|
|
[ -n "$MERGE_SRC" ] && MergeSrc="${!MERGE_SRC}" || MergeSrc=
|
|
[ -n "$MERGE_DEST" ] && MergeDest="${!MERGE_DEST}" || MergeDest=
|
|
}
|
|
|
|
################################################################################
|
|
|
|
function _init_changelog() {
|
|
setx date=date +%d/%m/%Y-%H:%M
|
|
ac_set_tmpfile changelog
|
|
echo >"$changelog" "\
|
|
Vérifiez et complétez la liste des changements le cas échéant.
|
|
Un fichier vide annule l'opération
|
|
Ces lignes ne seront pas incluses dans le fichier destination
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
"
|
|
}
|
|
|
|
function _filter_rel() {
|
|
# enlever les commits "techniques" générés par ce script
|
|
awk '
|
|
BEGIN { tech = 0 }
|
|
tech == 0 && $0 ~ /^\+.*<pman>/ { tech = 1; next }
|
|
tech == 1 && $0 ~ /^\|/ { next }
|
|
tech == 1 && $0 ~ /^\+/ { tech = 0 }
|
|
$0 !~ /<pman>/ { print }
|
|
'
|
|
}
|
|
|
|
function _filter_changes() {
|
|
# enlever les commits "inutiles" pour générer le fichier CHANGES.md
|
|
grep -vE '^([+|] )?[0-9a-f]+ modifs\.mineures sans commentaires$' |
|
|
grep -vE '^([+|] )?[0-9a-f]+ (cosmetic|typo|bug|fix|maj projet|maj deps)$'
|
|
}
|
|
|
|
function _format_md() {
|
|
awk '
|
|
$0 == "" || $0 ~ /^#/ { print; next }
|
|
$1 == "+" {
|
|
$1 = "*"
|
|
$2 = "`" $2 "`"
|
|
print; next
|
|
}
|
|
$1 == "|" {
|
|
$1 = " *"
|
|
$2 = "`" $2 "`"
|
|
print; next
|
|
}
|
|
{
|
|
$1 = "* `" $1 "`"
|
|
print; next
|
|
}
|
|
'
|
|
}
|
|
|
|
function _list_commits() {
|
|
local source="${1:-$MergeSrc}" dest="${2:-$MergeDest}" mergebase
|
|
setx mergebase=git merge-base "$dest" "$source"
|
|
git log --oneline --graph --no-decorate "$mergebase..$source" |
|
|
grep -vF '|\' | grep -vF '|/' | sed -r 's/^(\| )+\* +/| /; s/^\* +/+ /' |
|
|
_filter_rel
|
|
}
|
|
|
|
function _show_diff() {
|
|
local source="${1:-$MergeSrc}" dest="${2:-$MergeDest}" mergebase
|
|
setx mergebase=git merge-base "$dest" "$source"
|
|
git diff ${_sd_COLOR:+--color=$_sd_COLOR} "$mergebase..$source"
|
|
}
|
|
|
|
function _scripte() {
|
|
echo >>"$script"
|
|
echo "$comment$(qvals "$@")" >>"$script"
|
|
}
|
|
|
|
function _scripta() {
|
|
[ $# -gt 0 ] && _scripte einfo "$*"
|
|
cat >>"$script"
|
|
}
|
|
|
|
function _script_push_branches() {
|
|
[ ${#push_branches[*]} -gt 0 ] || return
|
|
[ -n "$Origin" ] || Origin=origin
|
|
git_have_remote "$Origin" || return
|
|
|
|
local branch cmd remote rbranch
|
|
for branch in "${push_branches[@]}"; do
|
|
if [[ "$branch" == *:* ]]; then
|
|
cmd="$(qvals git push "$Origin" "$branch")"
|
|
else
|
|
setx remote=git_get_branch_remote "$branch"
|
|
if [ "$remote" == "$Origin" ]; then
|
|
setx rbranch=git_get_branch_merge "$branch"
|
|
if [ -n "$rbranch" ]; then
|
|
# pousser vers la branche distante existante
|
|
cmd="$(qvals git push "$Origin" "$branch:${rbranch#refs/heads/}")"
|
|
else
|
|
# pas de branche distante: pousser et traquer
|
|
cmd="$(qvals git push -u "$Origin" "$branch:$branch")"
|
|
fi
|
|
elif [ -n "$remote" ]; then
|
|
# pousser vers un remote différent
|
|
cmd="$(qvals git push "$Origin" "$branch:$branch")"
|
|
else
|
|
# pas de remote: pousser et traquer
|
|
cmd="$(qvals git push -u "$Origin" "$branch:$branch")"
|
|
fi
|
|
fi
|
|
_scripta <<<"$comment$cmd$or_die"
|
|
done
|
|
}
|
|
|
|
function _script_push_tags() {
|
|
local origin tag
|
|
_scripte einfo "push tags"
|
|
for tag in "${push_tags[@]}"; do
|
|
origin="$Origin"
|
|
[ -n "$origin" ] || origin=origin
|
|
_scripta <<EOF
|
|
$comment$(qvals git push --force "$origin" tag "$tag")$or_die
|
|
EOF
|
|
done
|
|
}
|
|
|
|
################################################################################
|
|
# Config
|
|
|
|
function check_gitdir() {
|
|
# commencer dans le répertoire indiqué
|
|
local chdir="$1"
|
|
if [ -n "$chdir" ]; then
|
|
cd "$chdir" || return 1
|
|
fi
|
|
|
|
# se mettre à la racine du dépôt git
|
|
local gitdir
|
|
git_check_gitvcs || return 1
|
|
setx gitdir=git_get_toplevel
|
|
cd "$gitdir" || return 1
|
|
}
|
|
|
|
function ensure_gitdir() {
|
|
# commencer dans le répertoire indiqué
|
|
check_gitdir "$@" || die || return 1
|
|
}
|
|
|
|
function load_branches() {
|
|
local branch what="${1:-all}"; shift
|
|
case "$what" in
|
|
all)
|
|
[ -n "$Origin" ] || Origin=origin
|
|
setx CurrentBranch=git_get_branch
|
|
setx -a LocalBranches=git_list_branches
|
|
setx -a RemoteBranches=git_list_rbranches "$Origin"
|
|
setx -a AllBranches=git_list_pbranches "$Origin"
|
|
;;
|
|
current)
|
|
UpstreamBranch=
|
|
FeatureBranches=()
|
|
DevelopBranch=
|
|
ReleaseBranch=
|
|
HotfixBranch=
|
|
MainBranch=
|
|
DistBranch=
|
|
IfRefBranch=
|
|
IfBaseBranch=
|
|
IfMergeSrc=
|
|
IfMergeDest=
|
|
for branch in "${LocalBranches[@]}"; do
|
|
if [ "$branch" == "$UPSTREAM" ]; then
|
|
UpstreamBranch="$branch"
|
|
elif [ -n "$FEATURE" ] && [[ "$branch" == "$FEATURE"* ]]; then
|
|
FeatureBranches+=("$branch")
|
|
elif [ -n "$DEVELOP" -a "$branch" == "$DEVELOP" ]; then
|
|
DevelopBranch="$branch"
|
|
elif [ -n "$RELEASE" ] && [[ "$branch" == "$RELEASE"* ]]; then
|
|
ReleaseBranch="$branch"
|
|
elif [ -n "$HOTFIX" ] && [[ "$branch" == "$HOTFIX"* ]]; then
|
|
HotfixBranch="$branch"
|
|
elif [ -n "$MAIN" -a "$branch" == "$MAIN" ]; then
|
|
MainBranch="$branch"
|
|
elif [ -n "$DIST" -a "$branch" == "$DIST" ]; then
|
|
DistBranch="$branch"
|
|
fi
|
|
[ -n "$RefBranch" -a "$branch" == "$RefBranch" ] && IfRefBranch="$branch"
|
|
[ -n "$BaseBranch" -a "$branch" == "$BaseBranch" ] && IfBaseBranch="$branch"
|
|
[ -n "$MergeSrc" -a "$branch" == "$MergeSrc" ] && IfMergeSrc="$branch"
|
|
[ -n "$MergeDest" -a "$branch" == "$MergeDest" ] && IfMergeDest="$branch"
|
|
done
|
|
[ -n "$IfMergeSrc" -a "$IfMergeDest" ] && IfCanMerge=1 || IfCanMerge=
|
|
;;
|
|
esac
|
|
}
|
|
|
|
function load_config() {
|
|
if [ "${ConfigFile#::}" != "$ConfigFile" ]; then
|
|
ConfigFile="$NULIBDIR/bash/src/pman${ConfigFile#::}.conf.sh"
|
|
fi
|
|
if [ -n "$ConfigFile" ]; then
|
|
source "$ConfigFile" || die || return
|
|
elif [ -n "$ConfigBranch" ]; then
|
|
# c'est le seul cas où ConfigFile reste vide
|
|
if ! array_contains LocalBranches "$ConfigBranch"; then
|
|
die "$ConfigBranch: branche de configuration introuvable" || return
|
|
else
|
|
local config
|
|
ac_set_tmpfile config
|
|
git show "$ConfigBranch:.pman.conf" >"$config" 2>/dev/null
|
|
[ -s "$config" ] || die "$ConfigBranch: aucune configuration trouvée sur cette branche" || return
|
|
ConfigFile="$config"
|
|
source "$ConfigFile"
|
|
fi
|
|
elif [ -f .pman.conf ]; then
|
|
ConfigFile="$(pwd)/.pman.conf"
|
|
source "$ConfigFile"
|
|
else
|
|
ConfigFile="$NULIBDIR/bash/src/pman.conf.sh"
|
|
fi
|
|
|
|
# S'assurer que nulib est dans le PATH pour que les scripts utilisateurs
|
|
# puissent utiliser les outils fournis
|
|
export PATH="$NULIBDIR/bin:$PATH"
|
|
}
|
|
|
|
################################################################################
|
|
# Divers
|
|
|
|
function resolve_should_push() {
|
|
local quiet="$1"
|
|
ShouldPush=1
|
|
if ! git_have_remote "$Origin" && [ -n "$Push" ]; then
|
|
[ -n "$quiet" ] || enote "L'option --no-push a été forcée puisque ce dépôt n'a pas d'origine"
|
|
ShouldPush=
|
|
fi
|
|
[ -z "$ShouldPush" ] && Push=
|
|
}
|
|
|
|
function _push_branches() {
|
|
[ ${#push_branches[*]} -gt 0 ] || return
|
|
[ -n "$Origin" ] || Origin=origin
|
|
git_have_remote "$Origin" || return
|
|
|
|
local -a cmds; local branch cmd remote rbranch
|
|
for branch in "${push_branches[@]}"; do
|
|
if [[ "$branch" == *:* ]]; then
|
|
cmds+=("$(qvals git push "$Origin" "$branch")")
|
|
else
|
|
setx remote=git_get_branch_remote "$branch"
|
|
if [ "$remote" == "$Origin" ]; then
|
|
setx rbranch=git_get_branch_merge "$branch"
|
|
if [ -n "$rbranch" ]; then
|
|
# pousser vers la branche distante existante
|
|
cmds+=("$(qvals git push "$Origin" "$branch:${rbranch#refs/heads/}")")
|
|
else
|
|
# pas de branche distante: pousser et traquer
|
|
cmds+=("$(qvals git push -u "$Origin" "$branch:$branch")")
|
|
fi
|
|
elif [ -n "$remote" ]; then
|
|
# pousser vers un remote différent
|
|
cmds+=("$(qvals git push "$Origin" "$branch:$branch")")
|
|
else
|
|
# pas de remote: pousser et traquer
|
|
cmds+=("$(qvals git push -u "$Origin" "$branch:$branch")")
|
|
fi
|
|
fi
|
|
done
|
|
[ -n "$Push" ] || enote "L'option --no-push étant utilisée, les opérations à effectuer sont simplement affichées"
|
|
for cmd in "${cmds[@]}"; do
|
|
einfo "$cmd"
|
|
if [ -n "$Push" ]; then
|
|
if ! eval "$cmd"; then
|
|
ewarn "Une erreur s'est produite, les opérations seront simplement affichées"
|
|
Push=
|
|
fi
|
|
fi
|
|
done
|
|
}
|
|
|
|
################################################################################
|
|
# Merge
|
|
|
|
function _mscript_start() {
|
|
>"$script"
|
|
_scripta <<EOF
|
|
#!/bin/bash
|
|
$(qvals source "$NULIBDIR/load.sh") || exit 1
|
|
|
|
$(echo_setv MergeSrc="$MergeSrc")
|
|
$(echo_setv MergeDest="$MergeDest")
|
|
|
|
merge=
|
|
delete=
|
|
push=
|
|
for arg in "\$@"; do
|
|
case "\$arg" in
|
|
merge) merge=1;;
|
|
delete) delete=1;;
|
|
push) push=1;;
|
|
esac
|
|
done
|
|
EOF
|
|
chmod +x "$script"
|
|
}
|
|
|
|
function _mscript_merge_branch() {
|
|
local msg
|
|
|
|
# basculer sur la branche
|
|
_scripta "switch to branch $MergeDest" <<EOF
|
|
$comment$(qvals git checkout "$MergeDest")$or_die
|
|
EOF
|
|
|
|
if [ -n "$SquashMsg" ]; then
|
|
msg="$SquashMsg"
|
|
[ -n "$TechMerge" ] && msg="<pman>$msg"
|
|
_scripta "squash merge $MergeSrc" <<EOF
|
|
$comment$(qvals git merge "$MergeSrc" --squash)$or_die
|
|
$comment$(qvals git commit -m "$msg")$or_die
|
|
EOF
|
|
else
|
|
msg="Intégration de la branche $MergeSrc"
|
|
[ -n "$TechMerge" ] && msg="<pman>$msg"
|
|
_scripta "merge $MergeSrc" <<EOF
|
|
$comment$(qvals git merge "$MergeSrc" --no-ff -m "$msg")$or_die
|
|
EOF
|
|
fi
|
|
array_addu push_branches "$MergeDest"
|
|
}
|
|
|
|
function _mscript_delete_branch() {
|
|
_scripta "delete branch $MergeSrc" <<EOF
|
|
$comment$(qvals git branch -D "$MergeSrc")$or_die
|
|
EOF
|
|
array_addu delete_branches ":$MergeSrc"
|
|
}
|
|
|
|
################################################################################
|
|
# Release
|
|
|
|
function _rscript_start() {
|
|
>"$script"
|
|
_scripta <<EOF
|
|
#!/bin/bash
|
|
$(qvals source "$NULIBDIR/load.sh") || exit 1
|
|
|
|
$(echo_setv MergeSrc="$MergeSrc")
|
|
$(echo_setv Version="$Version")
|
|
$(echo_setv Tag="$Tag")
|
|
$(echo_setv ReleaseBranch="$ReleaseBranch")
|
|
$(echo_setv MergeDest="$MergeDest")
|
|
|
|
create=
|
|
merge=
|
|
push=
|
|
for arg in "\$@"; do
|
|
case "\$arg" in
|
|
create) create=1;;
|
|
merge) merge=1;;
|
|
push) push=1;;
|
|
esac
|
|
done
|
|
EOF
|
|
chmod +x "$script"
|
|
}
|
|
|
|
function _rscript_create_release_branch() {
|
|
local date changelog
|
|
|
|
_init_changelog
|
|
echo >>"$changelog" "\
|
|
## Release $Tag du $date
|
|
"
|
|
_list_commits | _filter_changes | _format_md >>"$changelog"
|
|
"${EDITOR:-nano}" +7 "$changelog"
|
|
[ -s "$changelog" ] || exit_with ewarn "Création de la release annulée"
|
|
|
|
# créer la branche de release et basculer dessus
|
|
_scripta "create branch $ReleaseBranch" <<EOF
|
|
$(qvals git checkout -b "$ReleaseBranch" "$MergeSrc")$or_die
|
|
EOF
|
|
|
|
# créer le changelog
|
|
_scripta "update CHANGES.md" <<EOF
|
|
tmpchanges=/tmp/pman_CHANGES.$$.md
|
|
$(qvals echo "$(awk <"$changelog" '
|
|
BEGIN { p = 0 }
|
|
p == 0 && $0 == "" { p = 1; next }
|
|
p == 1 { print }
|
|
')") >"\$tmpchanges"
|
|
if [ -s CHANGES.md ]; then
|
|
echo >>"\$tmpchanges"
|
|
cat CHANGES.md >>"\$tmpchanges"
|
|
fi
|
|
cat "\$tmpchanges" >CHANGES.md
|
|
rm -f "\$tmpchanges"
|
|
git add CHANGES.md
|
|
EOF
|
|
|
|
# mettre à jour la version
|
|
_scripta "update VERSION.txt" <<EOF
|
|
$(qvals echo "$Version") >VERSION.txt
|
|
git add VERSION.txt
|
|
EOF
|
|
|
|
# Enregistrer les changements
|
|
_scripta "commit" <<EOF
|
|
$(qvals git commit -m "<pman>Init changelog & version $Tag")
|
|
EOF
|
|
}
|
|
|
|
function _rscript_merge_release_branch() {
|
|
local dest="$1" tag="$2"
|
|
|
|
# basculer sur la branche
|
|
_scripta "switch to branch $dest" <<EOF
|
|
$comment$(qvals git checkout "$dest")$or_die
|
|
EOF
|
|
|
|
# fusionner la branche de release
|
|
_scripta "merge branch $ReleaseBranch" <<EOF
|
|
$comment$(qvals git merge "$ReleaseBranch" -m "<pman>Intégration de la branche $ReleaseBranch" --no-ff)$or_die
|
|
EOF
|
|
array_addu push_branches "$dest"
|
|
|
|
# tagger la release
|
|
if [ -n "$tag" ]; then
|
|
_scripta "create tag $tag" <<EOF
|
|
$comment$(qvals git tag --force "$tag")$or_die
|
|
EOF
|
|
array_addu push_tags "$tag"
|
|
fi
|
|
}
|
|
|
|
function _rscript_delete_release_branch() {
|
|
_scripta "delete branch $ReleaseBranch" <<EOF
|
|
$comment$(qvals git branch -D "$ReleaseBranch")$or_die
|
|
EOF
|
|
}
|
|
|
|
################################################################################
|
|
# Outils
|
|
|
|
function dump_action() {
|
|
enote "Valeurs des variables:
|
|
REF_BRANCH=$REF_BRANCH${RefBranch:+ RefBranch=$RefBranch IfRefBranch=$IfRefBranch}
|
|
BASE_BRANCH=$BASE_BRANCH${BaseBranch:+ BaseBranch=$BaseBranch IfBaseBranch=$IfBaseBranch}
|
|
MERGE_FROM=$MERGE_FROM
|
|
MERGE_TO=$MERGE_TO
|
|
MERGE_DIR=$MERGE_DIR
|
|
PREL_MERGE=$PREL_MERGE
|
|
DELETE_MERGED=$DELETE_MERGED
|
|
MERGE_SRC=$MERGE_SRC${MergeSrc:+ MergeSrc=$MergeSrc IfMergeSrc=$IfMergeSrc}
|
|
MERGE_DEST=$MERGE_DEST${MergeDest:+ MergeDest=$MergeDest IfMergeDest=$IfMergeDest}
|
|
|
|
CurrentBranch=$CurrentBranch
|
|
LocalBranches=${LocalBranches[*]}
|
|
RemoteBranches=${RemoteBranches[*]}
|
|
AllBranches=${AllBranches[*]}
|
|
|
|
UpstreamBranch=$UpstreamBranch
|
|
FeatureBranches=${FeatureBranches[*]}
|
|
DevelopBranch=$DevelopBranch
|
|
ReleaseBranch=$ReleaseBranch
|
|
HotfixBranch=$HotfixBranch
|
|
MainBranch=$MainBranch
|
|
DistBranch=$DistBranch
|
|
"
|
|
}
|
|
|
|
function resolve_unique_branch() {
|
|
if [ "$REF_BRANCH" == FEATURE ]; then
|
|
if [ $# -gt 0 ]; then
|
|
RefBranch="$FEATURE${1#$FEATURE}"
|
|
elif [[ "$CurrentBranch" == "$FEATURE"* ]]; then
|
|
RefBranch="$CurrentBranch"
|
|
elif [ ${#FeatureBranches[*]} -eq 0 ]; then
|
|
die "Vous devez spécifier la branche de feature"
|
|
elif [ ${#FeatureBranches[*]} -eq 1 ]; then
|
|
RefBranch="${FeatureBranches[0]}"
|
|
else
|
|
simple_menu \
|
|
RefBranch FeatureBranches \
|
|
-t "Branches de feature" \
|
|
-m "Veuillez choisir la branche de feature" \
|
|
-d "${FeatureBranches[0]}"
|
|
fi
|
|
else
|
|
die "resolve_unique_branch: $REF_BRANCH: non implémenté"
|
|
fi
|
|
if [ "$MERGE_DIR" == from ]; then
|
|
MergeSrc="$RefBranch"
|
|
elif [ "$MERGE_DIR" == to ]; then
|
|
MergeDest="$RefBranch"
|
|
fi
|
|
}
|
|
|
|
function _ensure_ref_branch() {
|
|
[ -n "$RefBranch" ] || die "\
|
|
La branche $REF_BRANCH n'a pas été définie.
|
|
Veuillez éditer le fichier .pman.conf"
|
|
[ "$1" == init -o -n "$IfRefBranch" ] || die "$RefBranch: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
|
|
}
|
|
|
|
function _ensure_base_branch() {
|
|
[ -n "$BaseBranch" ] || die "\
|
|
La branche $BASE_BRANCH n'a pas été définie.
|
|
Veuillez éditer le fichier .pman.conf"
|
|
[ "$1" == init -o -n "$IfBaseBranch" ] || die "$BaseBranch: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
|
|
}
|
|
|
|
function _create_default_action() {
|
|
enote "Vous allez créer la branche ${COULEUR_BLEUE}$RefBranch${COULEUR_NORMALE} <-- ${COULEUR_ROUGE}$BaseBranch${COULEUR_NORMALE}"
|
|
ask_yesno "Voulez-vous continuer?" O || die
|
|
|
|
einfo "Création de la branche $RefBranch"
|
|
git checkout -b "$RefBranch" "$BaseBranch" || die
|
|
push_branches+=("$RefBranch")
|
|
}
|
|
|
|
function _create_upstream_action() {
|
|
enote "Vous allez créer la branche ${COULEUR_BLEUE}$RefBranch${COULEUR_NORMALE}"
|
|
ask_yesno "Voulez-vous continuer?" O || die
|
|
|
|
# faire une copie de la configuration actuelle
|
|
local config; ac_set_tmpfile config
|
|
cp "$ConfigFile" "$config"
|
|
|
|
einfo "Création de la branche $RefBranch"
|
|
git checkout --orphan "$RefBranch" || die
|
|
git rm -rf .
|
|
cp "$config" .pman.conf
|
|
git add .pman.conf
|
|
git commit -m "commit initial"
|
|
push_branches+=("$RefBranch")
|
|
|
|
einfo "Fusion dans $DevelopBranch"
|
|
git checkout "$DevelopBranch"
|
|
git merge \
|
|
--no-ff -m "<pman>Intégration initiale de la branche $RefBranch" \
|
|
-srecursive -Xours --allow-unrelated-histories \
|
|
"$RefBranch"
|
|
push_branches+=("$DevelopBranch")
|
|
}
|
|
|
|
function checkout_action() {
|
|
local -a push_branches
|
|
|
|
[ -n "$REF_UNIQUE" ] || resolve_unique_branch "$@"
|
|
_ensure_ref_branch init
|
|
|
|
if array_contains LocalBranches "$RefBranch"; then
|
|
git checkout "$RefBranch"
|
|
elif array_contains AllBranches "$RefBranch"; then
|
|
enote "$RefBranch: une branche du même nom existe dans l'origine"
|
|
ask_yesno "Voulez-vous basculer sur cette branche?" O || die
|
|
git checkout "$RefBranch"
|
|
else
|
|
_ensure_base_branch
|
|
resolve_should_push
|
|
|
|
local create_function
|
|
create_function="${REF_BRANCH}_CREATE_FUNCTION"; create_function="${!create_function}"
|
|
[ -n "$create_function" ] || create_function=_create_default_action
|
|
"$create_function"
|
|
|
|
_push_branches
|
|
fi
|
|
}
|
|
|
|
function ensure_merge_branches() {
|
|
[ -n "$MergeSrc" ] || die "\
|
|
$RefBranch: configuration de fusion non trouvée: la branche $MERGE_SRC n'a pas été définie.
|
|
Veuillez éditer le fichier .pman.conf"
|
|
[ -n "$MergeDest" ] || die "\
|
|
$RefBranch: configuration de fusion non trouvée: la branche $MERGE_DEST n'a pas été définie.
|
|
Veuillez éditer le fichier .pman.conf"
|
|
|
|
local branches
|
|
[ "$1" == -a ] && branches=AllBranches || branches=LocalBranches
|
|
array_contains "$branches" "$MergeSrc" || die "$MergeSrc: branche source introuvable"
|
|
array_contains "$branches" "$MergeDest" || die "$MergeDest: branche destination introuvable"
|
|
}
|
|
|
|
function _show_action() {
|
|
local commits
|
|
setx commits=_list_commits "$MergeSrc" "$MergeDest"
|
|
if [ -n "$commits" ]; then
|
|
if [ $ShowLevel -ge 2 ]; then
|
|
{
|
|
echo "\
|
|
# Commits à fusionner $MergeSrc --> $MergeDest
|
|
|
|
$commits
|
|
"
|
|
_sd_COLOR=always _show_diff
|
|
} | less -eRF
|
|
else
|
|
einfo "Commits à fusionner $MergeSrc --> $MergeDest"
|
|
eecho "$commits"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function show_action() {
|
|
git_check_cleancheckout || ewarn "$git_cleancheckout_DIRTY"
|
|
[ -n "$REF_UNIQUE" ] || resolve_unique_branch "$@"
|
|
ensure_merge_branches
|
|
_show_action "$@"
|
|
}
|