suite pwip

bash/src/pman.sh

@@ -28,6 +28,62 @@ CONFIG_VARS=(
     UPSTREAM DEVELOP FEATURE RELEASE MAIN TAG_PREFIX TAG_SUFFIX HOTFIX DIST NOAUTO
 )
 
+PMAN_TOOL_PUPS=UPSTREAM
+PMAN_TOOL_PDEV=DEVELOP
+PMAN_TOOL_PWIP=FEATURE
+PMAN_TOOL_PMAIN=MAIN
+PMAN_TOOL_PDIST=DIST
+UPSTREAM_CREATE_BASE=       ; UPSTREAM_MERGE_FROM=       ; UPSTREAM_MERGE_TO=DEVELOP ; UPSTREAM_PREL=  ; UPSTREAM_DELETE=
+DEVELOP_CREATE_BASE=MAIN    ; DEVELOP_MERGE_FROM=FEATURE ; DEVELOP_MERGE_TO=MAIN     ; DEVELOP_PREL=to ; DEVELOP_DELETE=from
+MAIN_CREATE_BASE=           ; MAIN_MERGE_FROM=DEVELOP    ; MAIN_MERGE_TO=DIST        ; MAIN_PREL=from  ; MAIN_DELETE=
+DIST_CREATE_BASE=MAIN       ; DIST_MERGE_FROM=MAIN       ; DIST_MERGE_TO=            ; DIST_PREL=      ; DIST_DELETE=
+FEATURE_CREATE_BASE=DEVELOP ; FEATURE_MERGE_FROM=        ; FEATURE_MERGE_TO=DEVELOP ; FEATURE_PREL=    ; FEATURE_DELETE=to
+
+function get_create_base() {
+    # 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^^}_CREATE_BASE"; branch="${!infos}"
+    [ -n "$branch" ] && echo "$branch" || return 1
+}
+
+function get_merge_from() {
+    # 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() {
+    # 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" dir="${2:-to}" infos
+    [ -n "$branch" ] || return 1
+    infos="${branch^^}_PREL"
+    [ "${!infos}" == "$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" dir="${2:-to}" infos
+    [ -n "$branch" ] || return 1
+    infos="${branch^^}_DELETE"
+    [ "${!infos}" == "$dir" ]
+}
+
 function _init_changelog() {
     setx date=date +%d/%m/%Y-%H:%M
     ac_set_tmpfile changelog
@@ -156,14 +212,14 @@ function check_gitdir() {
 
     # se mettre à la racine du dépôt git
     local gitdir
-    git_ensure_gitvcs
+    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
+    check_gitdir "$@" || die || return 1
 }
 
 function load_branches() {
@@ -201,6 +257,10 @@ function load_branches() {
         esac
 
         local branch
+        PmanBranch=
+        PmanCreateBase=
+        PmanMergeSrc=
+        PmanMergeDest=
         UpstreamBranch=
         FeatureBranches=()
         DevelopBranch=
@@ -209,19 +269,27 @@ function load_branches() {
         MainBranch=
         DistBranch=
         for branch in "${LocalBranches[@]}"; do
+            [ -n "$PMAN_BRANCH" ] && [ "$branch" == "${!PMAN_BRANCH}" ] &&
+                PmanBranch="$branch"
+            [ -n "$PMAN_CREATE_BASE" ] && [ "$branch" == "${!PMAN_CREATE_BASE}" ] &&
+                PmanCreateBase="$branch"
+            [ -n "$PMAN_MERGE_SRC" ] && [ "$branch" == "${!PMAN_MERGE_SRC}" ] &&
+                PmanMergeSrc="$branch"
+            [ -n "$PMAN_MERGE_DEST" ] && [ "$branch" == "${!PMAN_MERGE_DEST}" ] &&
+                PmanMergeDest="$branch"
             if [ "$branch" == "$UPSTREAM" ]; then
                 UpstreamBranch="$branch"
-            elif [[ "$branch" == "$FEATURE"* ]]; then
+            elif [ -n "$FEATURE" ] && [[ "$branch" == "$FEATURE"* ]]; then
                 FeatureBranches+=("$branch")
-            elif [ "$branch" == "$DEVELOP" ]; then
+            elif [ -n "$DEVELOP" -a "$branch" == "$DEVELOP" ]; then
                 DevelopBranch="$branch"
-            elif [[ "$branch" == "$RELEASE"* ]]; then
+            elif [ -n "$RELEASE" ] && [[ "$branch" == "$RELEASE"* ]]; then
                 ReleaseBranch="$branch"
-            elif [[ "$branch" == "$HOTFIX"* ]]; then
+            elif [ -n "$HOTFIX" ] && [[ "$branch" == "$HOTFIX"* ]]; then
                 HotfixBranch="$branch"
-            elif [ "$branch" == "$MAIN" ]; then
+            elif [ -n "$MAIN" -a "$branch" == "$MAIN" ]; then
                 MainBranch="$branch"
-            elif [ "$branch" == "$DIST" ]; then
+            elif [ -n "$DIST" -a "$branch" == "$DIST" ]; then
                 DistBranch="$branch"
             fi
         done
@@ -249,12 +317,6 @@ function load_config() {
     elif [ -f .pman.conf ]; then
         ConfigFile="$(pwd)/.pman.conf"
         source "$ConfigFile"
-    elif [ -n "$1" -a -n "${MYNAME#$1}" ]; then
-        # $1 est le nom de base de l'outil e.g "pdev", et le suffixe est la
-        # configuration à charger par défaut. i.e pdev74 chargera par défaut la
-        # configuration pman74.conf
-        ConfigFile="$NULIBDIR/bash/src/pman${MYNAME#$1}.conf.sh"
-        source "$ConfigFile"
     else
         ConfigFile="$NULIBDIR/bash/src/pman.conf.sh"
     fi

bash/src/pman.tool.pdev.sh

@@ -1,10 +0,0 @@
-# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
-
-PMAN_TOOLS=pdev
-SRC_TYPE=DEVELOP
-SRC_BRANCH="${SRC_TYPE,,}"; SRC_BRANCH="${SRC_BRANCH^}Branch"
-DEST_TYPE=MAIN
-DEST_BRANCH="${DEST_TYPE,,}"; DEST_BRANCH="${DEST_BRANCH^}Branch"
-ALLOW_MERGE=1
-MERGE_PREL=1
-ALLOW_DELETE=

bash/src/pman.tool.pdist.sh

@@ -1,10 +0,0 @@
-# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
-
-PMAN_TOOL=pdist
-SRC_TYPE=DIST
-SRC_BRANCH="${SRC_TYPE,,}"; SRC_BRANCH="${SRC_BRANCH^}Branch"
-DEST_TYPE=
-DEST_BRANCH=
-ALLOW_MERGE=
-MERGE_PREL=
-ALLOW_DELETE=

bash/src/pman.tool.pmain.sh

@@ -1,10 +0,0 @@
-# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
-
-PMAN_TOOL=pmain
-SRC_TYPE=MAIN
-SRC_BRANCH="${SRC_TYPE,,}"; SRC_BRANCH="${SRC_BRANCH^}Branch"
-DEST_TYPE=DIST
-DEST_BRANCH="${DEST_TYPE,,}"; DEST_BRANCH="${DEST_BRANCH^}Branch"
-ALLOW_MERGE=1
-MERGE_PREL=
-ALLOW_DELETE=

wip/_pman.tool

@@ -1,29 +1,92 @@
 #!/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 "pman.tool.$MYNAME"
+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() {
-    echo -n "\
+    enote "Valeurs des variables:
-SRC_TYPE=$SRC_TYPE
+PMAN_TOOL=$PMAN_TOOL
-SRC_BRANCH=$SRC_BRANCH
+PMAN_BRANCH=$PMAN_BRANCH${PMAN_BRANCH:+ !PMAN_BRANCH=${!PMAN_BRANCH} PmanBranch=$PmanBranch}
-DEST_TYPE=$DEST_TYPE
+PMAN_CREATE_BASE=$PMAN_CREATE_BASE${PMAN_CREATE_BASE:+ !PMAN_CREATE_BASE=${!PMAN_CREATE_BASE} PmanCreateBase=$PmanCreateBase}
-DEST_BRANCH=$DEST_BRANCH
+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[*]}
 
-SrcType=$SrcType
-SrcBranch=$SrcBranch
-DestType=$DestType
-DestBranch=$DestBranch
-
 UpstreamBranch=$UpstreamBranch
 FeatureBranches=${FeatureBranches[*]}
 DevelopBranch=$DevelopBranch
@@ -34,46 +97,76 @@ DistBranch=$DistBranch
 "
 }
 
-function _ensure_src_branch() {
+#XXXX
-    [ -n "$SrcBranch" ] || die "La branche $SRC_TYPE n'a pas été définie"
+#[ -n "${!PMAN_MERGE_SRC}" ] ||
-    [ "$1" == init -o -n "${!SRC_BRANCH}" ] || die "$SrcBranch: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
+#    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_dest_branch() {
+function _ensure_create_base() {
-    [ -n "$DestBranch" ] || die "La branche $DEST_TYPE n'a pas été définie"
+    [ -n "${!PMAN_CREATE_BASE}" ] || die "\
-    [ "$1" == init -o -n "${!DEST_BRANCH}" ] || die "$DestBranch: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
+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
 
-    if [ -z "${!SRC_BRANCH}" ]; then
+    _ensure_branch init
-        array_contains AllBranches "$SrcBranch" && exit_with enote "\
+    if [ -n "$PmanBranch" ]; then
-$SrcBranch: une branche du même nom existe dans l'origine
+        git checkout "$PmanBranch"
-    git checkout $SrcBranch"
+    elif array_contains AllBranches "${!PMAN_BRANCH}"; then
-        _ensure_dest_branch
+        enote "${!PMAN_BRANCH}: une branche du même nom existe dans l'origine"
-        _ensure_src_branch init
+        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
 
-        enote "Vous allez créer la branche ${COULEUR_BLEUE}$SrcBranch${COULEUR_NORMALE} <-- ${COULEUR_ROUGE}$DestBranch${COULEUR_NORMALE}"
+        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 $SrcBranch"
+        einfo "Création de la branche $DestBranch"
-        git checkout -b "$SrcBranch" "$DestBranch" || die
+        git checkout -b "$DestBranch" "$SrcBranch" || die
-        push_branches+=("$SrcBranch")
+        push_branches+=("$DestBranch")
 
         _push_branches
     fi
-    git checkout "$SrcBranch"
 }
 
 function ensure_branches() {
-    [ -n "${!SRC_BRANCH}" -a -n "${!DEST_BRANCH}" ] ||
+    [ -n "$PMAN_CAN_MERGE" ] ||
-        die "${!SRC_BRANCH}: Aucune configuration de fusion trouvée pour cette branche"
+        die "${!PMAN_BRANCH}: Aucune configuration de fusion trouvée pour cette branche"
 
-   array_contains LocalBranches "${!SRC_BRANCH}" || die "${!SRC_BRANCH}: branche source introuvable"
+    local branches
-   array_contains LocalBranches "${!DEST_BRANCH}" || die "${!DEST_BRANCH}: branche destination introuvable"
+    [ "$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() {
@@ -83,14 +176,14 @@ function _show_action() {
         if [ $ShowLevel -ge 2 ]; then
             {
                 echo "\
-# Commits à fusionner ${!SRC_BRANCH} --> ${!DEST_BRANCH}
+# Commits à fusionner $SrcBranch --> $DestBranch
 
 $commits
 "
                 _sd_COLOR=always _show_diff
             } | less -eRF
         else
-            einfo "Commits à fusionner ${!SRC_BRANCH} --> ${!DEST_BRANCH}"
+            einfo "Commits à fusionner $SrcBranch --> $DestBranch"
             eecho "$commits"
         fi
     fi
@@ -104,7 +197,7 @@ function show_action() {
 function _merge_action() {
     enote "\
 Ce script va
-- fusionner la branche ${COULEUR_BLEUE}${!SRC_BRANCH}${COULEUR_NORMALE} dans ${COULEUR_ROUGE}${!DEST_BRANCH}${COULEUR_NORMALE}${Push:+
+- 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
 
@@ -121,13 +214,13 @@ Ce script va
 if [ -n "\$merge" ]; then
 esection "Fusionner la branche"
 EOF
-    hook="BEFORE_MERGE_$SRC_TYPE"; [ -n "${!hook}" ] && _scripta <<EOF
+    hook="BEFORE_MERGE_$PMAN_MERGE_SRC"; [ -n "${!hook}" ] && _scripta <<EOF
 (
 ${!hook}
 )$or_die
 EOF
     _mscript_merge_branch
-    hook="AFTER_MERGE_$SRC_TYPE"; [ -n "${!hook}" ] && _scripta <<EOF
+    hook="AFTER_MERGE_$PMAN_MERGE_SRC"; [ -n "${!hook}" ] && _scripta <<EOF
 (
 ${!hook}
 )$or_die
@@ -144,7 +237,7 @@ if [ -n "\$delete" ]; then
 esection "Supprimer la branche"
 EOF
         _mscript_delete_branch
-        hook="AFTER_DELETE_$SRC_TYPE"; [ -n "${!hook}" ] && _scripta <<EOF
+        hook="AFTER_DELETE_$PMAN_MERGE_SRC"; [ -n "${!hook}" ] && _scripta <<EOF
 (
 ${!hook}
 )$or_die
@@ -160,7 +253,7 @@ EOF
 if [ -n "\$push" ]; then
 esection "Pousser les branches"
 EOF
-    hook="BEFORE_PUSH_$DEST_TYPE"; [ -n "${!hook}" ] && _scripta <<EOF
+    hook="BEFORE_PUSH_$PMAN_MERGE_DEST"; [ -n "${!hook}" ] && _scripta <<EOF
 (
 ${!hook}
 )$or_die
@@ -172,7 +265,7 @@ EOF
         _script_push_branches
         _scripta <<<fi
     fi
-    hook="AFTER_PUSH_$DEST_TYPE"; [ -n "${!hook}" ] && _scripta <<EOF
+    hook="AFTER_PUSH_$PMAN_MERGE_DEST"; [ -n "${!hook}" ] && _scripta <<EOF
 (
 ${!hook}
 )$or_die
@@ -210,89 +303,145 @@ Il y a aussi les commandes supplémentaires suivantes:
         einfo "$msg"
     fi
 }
+
 function merge_action() {
-    if [ -n "$MERGE_PREL" ]; then
+    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 "$ALLOW_DELETE" ] || Delete=
+    [ -n "$PMAN_DELETE_MERGED" ] || Delete=
     [ -z "$_Fake" ] && git_ensure_cleancheckout
-    if array_contains LocalBranches "$SrcBranch"; then
+
-        ensure_branches
+    if ! array_contains LocalBranches "$SrcBranch" && array_contains AllBranches "$SrcBranch"; then
-        resolve_should_push
-        _merge_action "$@"
-    elif array_contains AllBranches "$SrcBranch"; then
         enote "$SrcBranch: une branche du même nom existe dans l'origine"
-        die "$SrcBranch: branche locale introuvable"
-    else
-        die "$SrcBranch: branche introuvable"
     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 "$PMAN_TOOL"
+    load_config
-    if [ -n "${!SRC_TYPE}" ]; then
+    if [ -n "${!PMAN_MERGE_SRC}" ]; then
-        load_branches current "${!SRC_TYPE}"
+        load_branches current "${!PMAN_MERGE_SRC}"
+        loaded_config=1
+    elif [ -n "${!PMAN_BRANCH}" ]; then
+        load_branches current "${!PMAN_BRANCH}"
         loaded_config=1
     fi
 fi
-[ -n "${!SRC_TYPE}" ] && SrcDesc="${!SRC_TYPE}" || SrcDesc="<$SRC_TYPE>"
-SrcDesc="${COULEUR_BLEUE}$SrcDesc${COULEUR_NORMALE}"
-DestDesc=
 
-purpose="gérer la branche $SrcDesc"
+BranchDesc=
-if [ -n "$DEST_TYPE" ]; then
+MergeSrcDesc=
-    [ -n "${!DEST_TYPE}" ] && DestDesc="${!DEST_TYPE}" || DestDesc="<$DEST_TYPE>"
+MergeDestDesc=
-    DestDesc="${COULEUR_ROUGE}$DestDesc${COULEUR_NORMALE}"
+if [ -n "$PMAN_BRANCH" ]; then
-    purpose="${purpose} et sa fusion dans $DestDesc"
+    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"
+    -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. cette option est prioritaire sur --config-branch
+fichier de configuration des branches. le fichier .pman.conf dans le répertoire
-par défaut, utiliser le fichier .pman.conf dans le répertoire du dépôt s'il existe"
+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"
-    --checkout action=checkout "++\
-basculer sur la branche $SrcDesc. c'est l'action par défaut"
 )
-if [ -n "$ALLOW_MERGE" ]; then
+if [ -n "$PmanBranch" -a -n "$PMAN_UNIQUE" ]; then
-    usage="${usage}|--show|--merge"
+    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_${SRC_TYPE}
+    BEFORE_MERGE_${PMAN_MERGE_SRC}
-    AFTER_MERGE_${SRC_TYPE}"
+    AFTER_MERGE_${PMAN_MERGE_SRC}"
     args+=(
         -w,--show '$action=show; inc@ ShowLevel' "\
-lister les modifications qui seraient fusionnées dans la branche $DestDesc"
+lister ce qui serait fusionné dans la branche $MergeDestDesc"
-        -b,--rebase action=rebase "\
+#        -b,--rebase action=rebase "\
-lancer git rebase -i sur la branche $SrcDesc. cela permet de réordonner les
+#lancer git rebase -i sur la branche $MergeSrcDesc. cela permet de réordonner
-commits pour nettoyer l'historique avant la fusion"
+#les commits pour nettoyer l'historique avant la fusion"
-        -m,--merge action=merge "++\
+        -m,--merge action=merge "\
-fusionner la branche $SrcDesc dans la branche $DestDesc"
+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 "$MERGE_PREL" ]; then
+    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"
@@ -305,22 +454,23 @@ ne pas pousser les branches vers leur origine après la fusion"
 pousser les branches vers leur origine après la fusion.
 c'est l'option par défaut"
     )
-    if [ -n "$ALLOW_DELETE" ]; then
+    if [ -n "$PMAN_DELETE_MERGED" ]; then
         variables="${variables}
-    AFTER_DELETE_${SRC_TYPE}}"
+    AFTER_DELETE_${PMAN_MERGE_SRC}"
         args+=(
             -k,--no-delete Delete= "\
-ne pas supprimer la branche $SrcDesc après la fusion dans la branche $DestDesc
+ne pas supprimer la branche $MergeSrcDesc après la fusion dans la branche
-cette option ne devrait pas être utilisée avec --squash"
+$MergeDestDesc. cette option ne devrait pas être utilisée avec --squash"
             --delete Delete=1 "++\
-supprimer la branche $SrcDesc après la fusion dans la branche $DestDesc
+supprimer la branche $MergeSrcDesc après la fusion dans la branche
+$MergeDestDesc.
 c'est l'option par défaut"
         )
     fi
-    if [ -n "$DEST_TYPE" ]; then
+    if [ -n "$PMAN_MERGE_DEST" ]; then
         variables="${variables}
-    BEFORE_PUSH_${DEST_TYPE}
+    BEFORE_PUSH_${PMAN_MERGE_DEST}
-    AFTER_PUSH_${DEST_TYPE}"
+    AFTER_PUSH_${PMAN_MERGE_DEST}"
     fi
     args+=(
         -a:,--after-merge AfterMerge= "\
@@ -328,7 +478,6 @@ c'est l'option par défaut"
     )
 fi
 
-    
 chdir=
 Origin=
 ConfigBranch=
@@ -339,8 +488,8 @@ action=checkout
 ShowLevel=0
 TechMerge=
 SquashMsg=
-[ -z "$PMAN_NO_PUSH" ] && Push=1 || Push=
+Push=1
-[ -z "$PMAN_NO_DELETE" ] && Delete=1 || Delete=
+Delete=1
 AfterMerge=
 args=(
     "$purpose"
@@ -359,14 +508,13 @@ if [ -z "$loaded_config" -o -n "$chdir" -o -n "$ConfigFile" -o -n "$ConfigBranch
     # charger la configuration
     ensure_gitdir "$chdir"
     load_branches all
-    load_config "$PMAN_TOOL"
+    load_config
-    if [ -n "${!SRC_TYPE}" ]; then
+    if [ -n "${!PMAN_MERGE_SRC}" ]; then
-        load_branches current "${!SRC_TYPE}"
+        load_branches current "${!PMAN_MERGE_SRC}"
+    elif [ -n "${!PMAN_BRANCH}" ]; then
+        load_branches current "${!PMAN_BRANCH}"
     fi
 fi
 resolve_should_push quiet
 
-[ -n "${!SRC_TYPE}" ] ||
-    die "Aucune branche définie pour $SRC_TYPE. Veuillez éditer le fichier .pman.conf"
-
 "${action}_action" "$@"

wip/pwip

@@ -1,60 +0,0 @@
-#!/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
-
-git_cleancheckout_DIRTY="\
-Vous avez des modifications locales.
-Enregistrez ces modifications avant de créer une nouvelle branche"
-
-chdir=
-Origin=
-ConfigBranch=
-ConfigFile=
-[ -z "$PMAN_NO_PUSH" ] && Push=1 || Push=
-args=(
-    "créer une branche de feature"
-    "<feature>"
-    -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. cette option est prioritaire sur --config-branch
-par défaut, utiliser le fichier .pman.conf dans le répertoire du dépôt s'il existe"
-    -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"
-)
-parse_args "$@"; set -- "${args[@]}"
-
-# charger la configuration
-ensure_gitdir "$chdir"
-load_branches all
-load_config "$MYNAME"
-load_branches current
-
-branch="$1"
-if [ -z "$branch" -a ${#FeatureBranches[*]} -eq 1 ]; then
-    branch="${FeatureBranches[0]}"
-fi
-[ -n "$branch" ] || die "Vous devez spécifier la branche à créer"
-branch="$FEATURE${branch#$FEATURE}"
-
-resolve_should_push
-git_ensure_cleancheckout
-
-if array_contains AllBranches "$branch"; then
-    git checkout -q "$branch"
-else
-    # si la branche source n'existe pas, la créer
-    args=(--origin "$Origin")
-    if [ -n "$ConfigFile" ]; then args+=(--config-file "$ConfigFile")
-    elif [ -n "$ConfigBranch" ]; then args+=(--config-branch "$ConfigBranch")
-    fi
-    [ -z "$Push" ] && args+=(--no-push)
-    exec "$MYDIR/pman" "${args[@]}" "$branch"
-fi

wip/pwip

@@ -0,0 +1 @@
+_pman.tool