modifs.mineures sans commentaires

bash/src/pman.sh

@@ -28,6 +28,152 @@ 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_BASE=       ; UPSTREAM_MERGE_FROM=       ; UPSTREAM_MERGE_TO=DEVELOP ; UPSTREAM_PREL=  ; UPSTREAM_DELETE=
+DEVELOP_BASE=MAIN    ; DEVELOP_MERGE_FROM=FEATURE ; DEVELOP_MERGE_TO=MAIN     ; DEVELOP_PREL=to ; DEVELOP_DELETE=from
+MAIN_BASE=           ; MAIN_MERGE_FROM=DEVELOP    ; MAIN_MERGE_TO=DIST        ; MAIN_PREL=from  ; 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=to
+
+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" 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" ]
+}
+
+: "
+# description des variables #
+
+* PMAN_TOOL -- nom de l'outil, e.g pdev, pmain, pdist
+
+* PMAN_REF_BRANCH -- code de la branche de référence basé sur le nom de l'outil
+* PmanRefBranch -- 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
+
+* PMAN_UNIQUE -- si la branche de référence est unique. est vide pour les
+  codes de branches multiples, telle que FEATURE
+
+* PMAN_BASE_BRANCH -- branche de base à partir de laquelle créer la branche
+  de référence
+* PmanBaseBranch -- 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
+
+* PMAN_MERGE_FROM -- code de la branche source à partir de laquelle la fusion
+  est faite dans PMAN_REF_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_REF_BRANCH. vide si la branche n'a pas de destination
+* PMAN_DIR -- direction de la fusion:
+  'from' si on fait PMAN_MERGE_FROM --> PMAN_REF_BRANCH
+  'to' si on fait PMAN_REF_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
+* PmanMergeSrc -- 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
+
+* PMAN_MERGE_DEST -- code de la branche destination pour la fusion, ou vide si
+  la fusion n'est pas possible
+* PmanMergeDest -- 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
+
+* PMAN_CAN_MERGE -- indique si la fusion est théoriquement possible, c'est à
+  dire que $PMAN_MERGE_SRC et $PMAN_MERGE_DEST sont tous les deux non vides
+* IfCanMerge -- indique si la fusion est effectivement possible, c'est à dire
+  que $IfMergeSrc et $IfMergeDest sont tous les deux non vides"
+
+[ -n "$PMAN_TOOL" ] || PMAN_TOOL="$MYNAME"
+PMAN_REF_BRANCH="PMAN_TOOL_${PMAN_TOOL^^}"; PMAN_REF_BRANCH="${!PMAN_REF_BRANCH}"
+function set_pman_vars() {
+    PmanRefBranch="${!PMAN_REF_BRANCH}"
+    case "$PMAN_REF_BRANCH" in
+    FEATURE|RELEASE|HOTFIX) PMAN_UNIQUE=;;
+    *) PMAN_UNIQUE=1;;
+    esac
+
+    PMAN_BASE_BRANCH=$(get_base_branch "$PMAN_REF_BRANCH")
+    [ -n "$PMAN_BASE_BRANCH" ] && PmanBaseBranch="${!PMAN_BASE_BRANCH}" || PmanBaseBranch=
+
+    PMAN_MERGE_FROM=$(get_merge_from_branch "$PMAN_REF_BRANCH")
+    PMAN_MERGE_TO=$(get_merge_to_branch "$PMAN_REF_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_REF_BRANCH" "$PMAN_DIR" && echo 1)
+    PMAN_DELETE_MERGED=$(should_delete_merged "$PMAN_REF_BRANCH" "$PMAN_DIR" && echo 1)
+    case "$PMAN_DIR" in
+    to)
+        PMAN_MERGE_SRC="$PMAN_REF_BRANCH"
+        PMAN_MERGE_DEST="$PMAN_MERGE_TO"
+        ;;
+    from)
+        PMAN_MERGE_SRC="$PMAN_MERGE_FROM"
+        PMAN_MERGE_DEST="$PMAN_REF_BRANCH"
+        ;;
+    esac
+
+    [ -n "$PMAN_MERGE_SRC" -a -n "$PMAN_MERGE_DEST" ] && PMAN_CAN_MERGE=1 || PMAN_CAN_MERGE=
+    [ -n "$PMAN_MERGE_SRC" ] && PmanMergeSrc="${!PMAN_MERGE_SRC}" || PmanMergeSrc=
+    [ -n "$PMAN_MERGE_DEST" ] && PmanMergeDest="${!PMAN_MERGE_DEST}" || PmanMergeDest=
+}
+
+################################################################################
+
 function _init_changelog() {
     setx date=date +%d/%m/%Y-%H:%M
     ac_set_tmpfile changelog
@@ -156,14 +302,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() {
@@ -208,23 +354,32 @@ function load_branches() {
         HotfixBranch=
         MainBranch=
         DistBranch=
+        IfRefBranch=
+        IfBaseBranch=
+        IfMergeSrc=
+        IfMergeDest=
         for branch in "${LocalBranches[@]}"; do
             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
+            [ -n "$PmanRefBranch" -a "$branch" == "$PmanRefBranch" ] && IfRefBranch="$branch"
+            [ -n "$PmanBaseBranch" -a "$branch" == "$PmanBaseBranch" ] && IfBaseBranch="$branch"
+            [ -n "$PmanMergeSrc" -a "$branch" == "$PmanMergeSrc" ] && IfMergeSrc="$branch"
+            [ -n "$PmanMergeDest" -a "$branch" == "$PmanMergeDest" ] && IfMergeDest="$branch"
         done
+        [ -n "$IfMergeSrc" -a "$IfMergeDest" ] && IfCanMerge=1 || IfCanMerge=
         ;;
     esac
 }
@@ -249,12 +404,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=

bash/src/pman.tool.sh

@@ -0,0 +1,299 @@
+# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
+
+git_cleancheckout_DIRTY="\
+Vous avez des modifications locales.
+Enregistrez ces modifications avant de fusionner la branche"
+
+function resolve_unique_branch() {
+    if [ "$PMAN_REF_BRANCH" == FEATURE ]; then
+        if [ $# -gt 0 ]; then
+            UniqueBranch="$FEATURE${1#$FEATURE}"
+        elif [[ "$CurrentBranch" == "$FEATURE"* ]]; then
+            UniqueBranch="$CurrentBranch"
+        elif [ ${#FeatureBranches[*]} -eq 0 ]; then
+            die "Vous devez spécifier la branche de feature"
+        elif [ ${#FeatureBranches[*]} -eq 1 ]; then
+            UniqueBranch="${FeatureBranches[0]}"
+        else
+            simple_menu \
+                UniqueBranch FeatureBranches \
+                -t "Branches de feature" \
+                -m "Veuillez choisir la branche de feature" \
+                -d "${FeatureBranches[0]}"
+        fi
+        PMAN_REF_BRANCH=UniqueBranch
+        PMAN_MERGE_SRC=UniqueBranch
+    else
+        die "resolve_unique_branch: $PMAN_REF_BRANCH: non implémenté"
+    fi
+}
+
+function dump_action() {
+    enote "Valeurs des variables:
+PMAN_TOOL=$PMAN_TOOL
+PMAN_REF_BRANCH=$PMAN_REF_BRANCH${PmanRefBranch:+ PmanRefBranch=$PmanRefBranch IfRefBranch=$IfRefBranch}
+PMAN_BASE_BRANCH=$PMAN_BASE_BRANCH${PmanBaseBranch:+ PmanBaseBranch=$PmanBaseBranch IfCreateBase=$IfCreateBase}
+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${PmanMergeSrc:+ PmanMergeSrc=$PmanMergeSrc IfMergeSrc=$IfMergeSrc}
+PMAN_MERGE_DEST=$PMAN_MERGE_DEST${PmanMergeDest:+ PmanMergeDest=$PmanMergeDest IfMergeDest=$IfMergeDest}
+PMAN_CAN_MERGE=$PMAN_CAN_MERGE IfCanMerge=$IfCanMerge
+
+CurrentBranch=$CurrentBranch
+LocalBranches=${LocalBranches[*]}
+RemoteBranches=${RemoteBranches[*]}
+AllBranches=${AllBranches[*]}
+
+UpstreamBranch=$UpstreamBranch
+FeatureBranches=${FeatureBranches[*]}
+DevelopBranch=$DevelopBranch
+ReleaseBranch=$ReleaseBranch
+HotfixBranch=$HotfixBranch
+MainBranch=$MainBranch
+DistBranch=$DistBranch
+"
+}
+
+function _ensure_branch() {
+    [ -n "$PmanRefBranch" ] || die "\
+La branche $PMAN_REF_BRANCH n'a pas été définie.
+Veuillez éditer le fichier .pman.conf"
+    [ "$1" == init -o -n "$IfRefBranch" ] || die "$PmanRefBranch: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
+}
+
+function _ensure_base_branch() {
+    [ -n "${!PMAN_BASE_BRANCH}" ] || die "\
+La branche $PMAN_BASE_BRANCH n'a pas été définie.
+Veuillez éditer le fichier .pman.conf"
+    [ "$1" == init -o -n "$IfCreateBase" ] || die "${!PMAN_BASE_BRANCH}: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
+}
+
+function _ensure_merge_src() {
+    [ -n "$PmanMergeSrc" ] || die "\
+La branche $PMAN_MERGE_SRC n'a pas été définie.
+Veuillez éditer le fichier .pman.conf"
+    [ "$1" == init -o -n "$IfMergeSrc" ] || die "$PmanMergeSrc: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
+}
+
+function _ensure_merge_dest() {
+    [ -n "$PmanMergeDest" ] || die "\
+La branche $PMAN_MERGE_DEST n'a pas été définie.
+Veuillez éditer le fichier .pman.conf"
+    [ "$1" == init -o -n "$IfMergeDest" ] || die "$PmanMergeDest: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
+}
+
+function checkout_action() {
+    local -a push_branches
+
+    [ -n "$PMAN_UNIQUE" ] || resolve_unique_branch "$@" || die
+    _ensure_branch init
+
+    if [ -n "$IfRefBranch" ]; then
+        git checkout "$IfRefBranch"
+    elif array_contains LocalBranches "$PmanRefBranch"; then
+        git checkout "$PmanRefBranch"
+    elif array_contains AllBranches "$PmanRefBranch"; then
+        enote "$PmanRefBranch: une branche du même nom existe dans l'origine"
+        ask_yesno "Voulez-vous basculer sur cette branche?" O || die
+        git checkout "$PmanRefBranch"
+    elif [ -n "$PMAN_BASE_BRANCH" ]; then
+        _ensure_base_branch
+
+        resolve_should_push
+
+        local SrcBranch="${!PMAN_BASE_BRANCH}" DestBranch="$PmanRefBranch"
+        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
+}
+
+#XXXX
+#[ -n "$PmanMergeSrc" ] ||
+#    die "Aucune branche définie pour $PMAN_MERGE_SRC. Veuillez éditer le fichier .pman.conf"
+function ensure_merge_branches() {
+    [ -n "$PMAN_CAN_MERGE" ] ||
+        die "$PmanRefBranch: Aucune configuration de fusion trouvée pour cette branche"
+
+    local branches
+    [ "$1" == -a ] && branches=AllBranches || branches=LocalBranches
+
+    SrcBranch="$PmanMergeSrc"
+    array_contains "$branches" "$SrcBranch" || die "$SrcBranch: branche source introuvable"
+    DestBranch="$PmanMergeDest"
+    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_merge_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() {
+    [ -n "$PMAN_UNIQUE" ] || resolve_unique_branch "$@" || die
+    ensure_merge_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
+    set -x #XXX
+    _merge_action "$@"
+}
+
+function rebase_action() {
+    die "non implémenté"
+}
+

wip/_pman.tool

@@ -1,298 +1,117 @@
 #!/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.tool pman.conf
-
-git_cleancheckout_DIRTY="\
-Vous avez des modifications locales.
-Enregistrez ces modifications avant de fusionner la branche"
-
-function dump_action() {
-    echo -n "\
-SRC_TYPE=$SRC_TYPE
-SRC_BRANCH=$SRC_BRANCH
-DEST_TYPE=$DEST_TYPE
-DEST_BRANCH=$DEST_BRANCH
-
-CurrentBranch=$CurrentBranch
-LocalBranches=${LocalBranches[*]}
-RemoteBranches=${RemoteBranches[*]}
-AllBranches=${AllBranches[*]}
-
-SrcType=$SrcType
-SrcBranch=$SrcBranch
-DestType=$DestType
-DestBranch=$DestBranch
-
-UpstreamBranch=$UpstreamBranch
-FeatureBranches=${FeatureBranches[*]}
-DevelopBranch=$DevelopBranch
-ReleaseBranch=$ReleaseBranch
-HotfixBranch=$HotfixBranch
-MainBranch=$MainBranch
-DistBranch=$DistBranch
-"
-}
-
-function _ensure_src_branch() {
-    [ -n "$SrcBranch" ] || die "La branche $SRC_TYPE n'a pas été définie"
-    [ "$1" == init -o -n "${!SRC_BRANCH}" ] || die "$SrcBranch: cette branche n'existe pas (le dépôt a-t-il été initialisé?)"
-}
-
-function _ensure_dest_branch() {
-    [ -n "$DestBranch" ] || die "La branche $DEST_TYPE n'a pas été définie"
-    [ "$1" == init -o -n "${!DEST_BRANCH}" ] || die "$DestBranch: 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
-        array_contains AllBranches "$SrcBranch" && exit_with enote "\
-$SrcBranch: une branche du même nom existe dans l'origine
-    git checkout $SrcBranch"
-        _ensure_dest_branch
-        _ensure_src_branch init
-
-        resolve_should_push
-
-        enote "Vous allez créer la branche ${COULEUR_BLEUE}$SrcBranch${COULEUR_NORMALE} <-- ${COULEUR_ROUGE}$DestBranch${COULEUR_NORMALE}"
-        ask_yesno "Voulez-vous continuer?" O || die
-
-        einfo "Création de la branche $SrcBranch"
-        git checkout -b "$SrcBranch" "$DestBranch" || die
-        push_branches+=("$SrcBranch")
-
-        _push_branches
-    fi
-    git checkout "$SrcBranch"
-}
-
-function ensure_branches() {
-    [ -n "${!SRC_BRANCH}" -a -n "${!DEST_BRANCH}" ] ||
-        die "${!SRC_BRANCH}: Aucune configuration de fusion trouvée pour cette branche"
-
-   array_contains LocalBranches "${!SRC_BRANCH}" || die "${!SRC_BRANCH}: branche source introuvable"
-   array_contains LocalBranches "${!DEST_BRANCH}" || die "${!DEST_BRANCH}: branche destination introuvable"
-}
-
-function _show_action() {
-    local commits
-    setx commits=_list_commits
-    if [ -n "$commits" ]; then
-        if [ $ShowLevel -ge 2 ]; then
-            {
-                echo "\
-# Commits à fusionner ${!SRC_BRANCH} --> ${!DEST_BRANCH}
-
-$commits
-"
-                _sd_COLOR=always _show_diff
-            } | less -eRF
-        else
-            einfo "Commits à fusionner ${!SRC_BRANCH} --> ${!DEST_BRANCH}"
-            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}${!SRC_BRANCH}${COULEUR_NORMALE} dans ${COULEUR_ROUGE}${!DEST_BRANCH}${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_$SRC_TYPE"; [ -n "${!hook}" ] && _scripta <<EOF
-(
-${!hook}
-)$or_die
-EOF
-    _mscript_merge_branch
-    hook="AFTER_MERGE_$SRC_TYPE"; [ -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_$SRC_TYPE"; [ -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_$DEST_TYPE"; [ -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_$DEST_TYPE"; [ -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() {
-    if [ -n "$MERGE_PREL" ]; 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=
-    [ -z "$_Fake" ] && git_ensure_cleancheckout
-    if array_contains LocalBranches "$SrcBranch"; then
-        ensure_branches
-        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
-}
-
-function rebase_action() {
-    die "non implémenté"
-}
-
-
-################################################################################
-# Programme principal
-################################################################################
 
 loaded_config=
 if check_gitdir; then
     load_branches all
-    load_config "$PMAN_TOOL"
+    load_config
-    if [ -n "${!SRC_TYPE}" ]; then
+    set_pman_vars
-        load_branches current "${!SRC_TYPE}"
+    if [ -n "$PmanMergeSrc" ]; then
+        load_branches current "$PmanMergeSrc"
+        loaded_config=1
+    elif [ -n "$PmanRefBranch" ]; then
+        load_branches current "$PmanRefBranch"
         loaded_config=1
     fi
+else
+    set_pman_vars
 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_REF_BRANCH" ]; then
-    purpose="${purpose} et sa fusion dans $DestDesc"
+    BranchDesc="${COULEUR_BLANCHE}<$PMAN_REF_BRANCH>"
+    [ -n "$PmanRefBranch" -a -n "$PMAN_UNIQUE" ] && BranchDesc="$BranchDesc ($PmanRefBranch)"
+    BranchDesc="$BranchDesc${COULEUR_NORMALE}"
 fi
+if [ -n "$PMAN_MERGE_SRC" ]; then
+    MergeSrcDesc="${COULEUR_BLEUE}<$PMAN_MERGE_SRC>"
+    [ -n "$PmanMergeSrc" -a -n "$PMAN_UNIQUE" ] && MergeSrcDesc="$MergeSrcDesc ($PmanMergeSrc)"
+    MergeSrcDesc="$MergeSrcDesc${COULEUR_NORMALE}"
+fi
+if [ -n "$PMAN_MERGE_DEST" ]; then
+    MergeDestDesc="${COULEUR_ROUGE}<$PMAN_MERGE_DEST>"
+    [ -n "$PmanMergeDest" -a -n "$PMAN_UNIQUE" ] && MergeDestDesc="$MergeDestDesc ($PmanMergeDest)"
+    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 "$PmanRefBranch" -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_REF_BRANCH
+--show|--merge"
+    fi
+    if [ "$PMAN_REF_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 +124,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 +148,6 @@ c'est l'option par défaut"
     )
 fi
 
-    
 chdir=
 Origin=
 ConfigBranch=
@@ -339,8 +158,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 +178,14 @@ 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
+    set_pman_vars
-        load_branches current "${!SRC_TYPE}"
+    if [ -n "$PmanMergeSrc" ]; then
+        load_branches current "$PmanMergeSrc"
+    elif [ -n "$PmanRefBranch" ]; then
+        load_branches current "$PmanRefBranch"
     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/pinit

@@ -0,0 +1,191 @@
+#!/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
+
+################################################################################
+# Informations
+################################################################################
+
+SHOW_VARS=(
+    --Configuration
+    "${CONFIG_VARS[@]}"
+    --Paramètres
+    CurrentBranch
+    CurrentType=SrcType
+)
+
+function show_action() {
+    local var src
+    echo_setv ConfigBranch="$ConfigBranch"
+    echo_setv ConfigFile="$(ppath "$ConfigFile")"
+    for var in "${SHOW_VARS[@]}"; do
+        if [ "${var#--}" != "$var" ]; then
+            estep "${var#--}"
+        else
+            splitfsep "$var" = var src
+            [ -n "$src" ] || src="$var"
+            echo_setv "$var=${!src}"
+        fi
+    done
+}
+
+################################################################################
+# Initialisation
+################################################################################
+
+function _init_config() {
+    if [ ! -f .pman.conf -o -n "$ForceCreate" ]; then
+        ac_set_tmpfile config
+        cp "$ConfigFile" "$config"
+        "${EDITOR:-nano}" "$config"
+        [ -s "$config" ] || return 1
+
+        cp "$config" .pman.conf
+        if testdiff .pman.conf "$ConfigFile"; then
+            ConfigFile="$(pwd)/.pman.conf"
+            load_config
+            load_branches current "$SrcBranch"
+        fi
+        git add .pman.conf
+    fi
+    if [ ! -f ".gitignore" ]; then
+        echo >.gitignore "\
+.~lock*#
+.*.swp"
+        git add .gitignore
+    fi
+    return 0
+}
+
+function init_repo_action() {
+    local -a push_branches; local config
+
+    [ ${#LocalBranches[*]} -eq 0 ] || die "Ce dépôt a déjà été initialisé"
+
+    _init_config || exit_with ewarn "Initialisation du dépôt annulée"
+
+    einfo "Création de la branche $MAIN"
+    git symbolic-ref HEAD "refs/heads/$MAIN"
+    git commit -m "commit initial"
+    push_branches+=("$MAIN")
+
+    einfo "Création de la branche $DEVELOP"
+    git checkout -b "$DEVELOP"
+    push_branches+=("$DEVELOP")
+
+    _push_branches
+}
+
+function init_config_action() {
+    local -a push_branches; local config
+
+    [ -f .pman.conf -a -z "$ForceCreate" ] && die "La configuration pman a déjà été initialisée"
+
+    resolve_should_push
+
+    _init_config || exit_with ewarn "Initialisation de la configuration annulée"
+    git commit -m "configuration pman"
+    push_branches+=("$CurrentBranch")
+
+    _push_branches
+}
+
+function _init_composer() {
+    if [ ! -f .composer.pman.yml -o -n "$ForceCreate" ]; then
+        ac_set_tmpfile config
+        cat >"$config" <<EOF
+# -*- coding: utf-8 mode: yaml -*- vim:sw=2:sts=2:et:ai:si:sta:fenc=utf-8
+
+composer:
+  match_prefix:
+  match_prefix-dev:
+  profiles: [ dev, dist ]
+  dev:
+    link: true
+    require:
+    reqire-dev:
+  dist:
+    link: false
+    require:
+    reqire-dev:
+EOF
+        "${EDITOR:-nano}" "$config"
+        [ -s "$config" ] || return 1
+
+        cp "$config" .composer.pman.yml
+        git add .composer.pman.yml
+    fi
+    return 0
+}
+
+function init_composer_action() {
+    local -a push_branches; local config
+
+    [ -f .composer.pman.yml -a -z "$ForceCreate" ] && die "La configuration pman composer a déjà été initialisée"
+
+    resolve_should_push
+
+    _init_composer || exit_with ewarn "Initialisation de la configuration annulée"
+    git commit -m "configuration pman composer"
+    push_branches+=("$CurrentBranch")
+
+    _push_branches
+}
+
+function init_action() {
+    local what="${1:-repo}"; shift
+    case "$what" in
+    repo|r) init_repo_action "$@";;
+    config|c) init_config_action "$@";;
+    composer|o) init_composer_action "$@";;
+    *) die "$what: destination non implémentée"
+    esac
+}
+
+################################################################################
+# Programme principal
+################################################################################
+
+chdir=
+ConfigFile=
+action=init
+Origin=
+Push=1
+ForceCreate=
+args=(
+    "initialiser un dépôt git"
+    "repo|config|composer|all"
+    -d:,--chdir:BASEDIR chdir= "répertoire dans lequel se placer avant de lancer les opérations"
+    -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"
+    -w,--show-config action=show "++\
+afficher la configuration chargée"
+    -O:,--origin Origin= "++\
+origine vers laquelle pousser les branches"
+    -n,--no-push Push= "\
+ne pas pousser les branches vers leur origine après leur création"
+    --push Push=1 "++\
+pousser les branches vers leur origine après leur création.
+c'est l'option par défaut"
+    -f,--force-create ForceCreate=1 "\
+Avec config, forcer la (re)création du fichier .pman.conf"
+)
+parse_args "$@"; set -- "${args[@]}"
+
+# charger la configuration
+ensure_gitdir "$chdir"
+load_branches all
+load_config
+load_branches current
+
+# puis faire l'action que l'on nous demande
+case "$action" in
+show) show_action "$@";;
+init)
+    git_ensure_cleancheckout
+    init_action "$@"
+    ;;
+*) die "$action: action non implémentée";;
+esac

wip/pups

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

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