##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
## Fonctions pour la gestion des projets
##@cooked nocomments
##@include vcs
##@include semver
##@include xmlsupport
uprovide ptools
urequire vcs semver xmlsupport

function is_any_branch() {
    local branch="$1"; shift
    if [ -z "$branch" ]; then
        branch="$(git_get_branch)" || return 2
    fi
    local annex; git_have_annex && annex=1
    local spec r
    for spec in "$@"; do
        case "$spec" in
        m|master)
            [ -n "$r" ] || r=1
            [ "$branch" == "master" ] && return 0
            ;;
        d|develop)
            [ -n "$r" ] || r=1
            [ "$branch" == "develop" ] && return 0
            ;;
        r|release)
            [ -n "$r" ] || r=1
            [[ "$branch" == release-* ]] && return 0
            ;;
        h|hotfix)
            [ -n "$r" ] || r=1
            [[ "$branch" == hotfix-* ]] && return 0
            ;;
        f|feature|t|topic)
            [ -n "$r" ] || r=1
            [ "$branch" == "master" ] && continue
            [ "$branch" == "develop" ] && continue
            [[ "$branch" == release-* ]] && continue
            [[ "$branch" == hotfix-* ]] && continue
            [ -n "$annex" -a "$branch" == "git-annex" ] && continue
            [[ "$branch" == */* ]] && continue
            return 0
            ;;
        -m|-master)
            [ -n "$r" ] || r=0
            [ "$branch" == "master" ] && return 1;;
        -d|-develop)
            [ -n "$r" ] || r=0
            [ "$branch" == "develop" ] && return 1;;
        -r|-release)
            [ -n "$r" ] || r=0
            [[ "$branch" == release-* ]] && return 1;;
        -h|-hotfix)
            [ -n "$r" ] || r=0
            [[ "$branch" == hotfix-* ]] && return 1;;
        -f|-feature|-t|-topic)
            [ -n "$r" ] || r=0
            [ "$branch" == "master" ] && continue
            [ "$branch" == "develop" ] && continue
            [[ "$branch" == release-* ]] && continue
            [[ "$branch" == hotfix-* ]] && continue
            [ -n "$annex" -a "$branch" == "git-annex" ] && continue
            [[ "$branch" == */* ]] && continue
            return 1
            ;;
        esac
    done
    return ${r:-1}
}
function is_master_branch() { is_any_branch "$1" master; }
function is_develop_branch() { is_any_branch "$1" develop; }
function is_release_branch() { is_any_branch "$1" release; }
function is_hotfix_branch() { is_any_branch "$1" hotfix; }
function is_feature_branch() { is_any_branch "$1" feature; }

function list_release_branches() {
    local origin="$1"
    git_list_${origin:+p}branches "$origin" | grep '^release-'
}
function list_hotfix_branches() {
    local origin="$1"
    git_list_${origin:+p}branches "$origin" | grep '^hotfix-'
}
function list_feature_branches() {
    local origin="$1"
    git_list_${origin:+p}branches "$origin" |
    grep -vF master |
    grep -vF develop |
    grep -v '^release-' |
    grep -v '^hotfix-' |
    grep -v '/' |
    if git_have_annex; then
        grep -vF git-annex
    else
        cat
    fi
}

################################################################################
# Outils de haut niveau

__pver_perror() {
    local r="$1"; shift
    [ $# -gt 0 ] || set "Une erreur s'est produite"
    local m=$r
    [ $m -gt $# ] && m=$#
    [ $m -gt 0 ] && eerror "${!m}"
    return $r
}

__pver_unless() {
    local r m
    if [[ "$1" == -* ]]; then
        [ "${@:1:2}" ] 2>/dev/null; r=$?
        shift; shift
    else
        [ "${@:1:3}" ] 2>/dev/null; r=$?
        shift; shift; shift
    fi
    __pver_perror $r "$@"
}

function __pver_get_prel_version() {
    # retourner la version correspondant à la branche courante si c'est une
    # branche de release. retourner 1 si la branche courante n'est pas une
    # branche de release, 2 si on n'est pas dans un dépôt git
    local branch
    branch="$(git_get_branch)" || return 2
    if [[ "$branch" == release-* ]]; then
        echo "${branch#release-}"
        return 0
    else
        return 1
    fi
}
function __pver_pom_get_vpath() {
    # pour le fichier $1(=pom.xml), retourner le chemin dans lequel se trouve la
    # version du projet
    local pom="${1:-pom.xml}"
    if xpathtool -tf "$pom" /project/version 2>/dev/null; then
        echo /project/version
    elif xpathtool -tf "$pom" /project/parent/version 2>/dev/null; then
        echo /project/parent/version
    else
        echo /project/version
    fi
}

function __pver_pom_get_version() {
    # obtenir la version dans le pom $1(=pom.xml) à partir du chemin $2, qui est
    # déterminé automatiquement s'il n'est pas spécifié.
    local pom="${1:-pom.xml}"
    local vpath="$2"
    local version
    if [ -n "$vpath" ]; then
        xpathtool -f "$pom" -g "$vpath"
        return
    fi
    version="$(xpathtool -f "$pom" -g /project/version 2>/dev/null)"
    if [ -n "$version" ]; then
        echo "$version"
        return
    fi
    version="$(xpathtool -f "$pom" -g /project/parent/version 2>/dev/null)"
    if [ -n "$version" ]; then
        echo "$version"
        return
    fi
}

function __pver_pom_set_version() {
    # modifier la version dans le pom $1(=pom.xml) à la valeur
    # $2(=1.0.0-SNAPSHOT) en utilisant le chemin xpath $3, qui est déterminé
    # automatiquement s'il n'est pas spécifié.
    # retourner 0 si la version a été mise à jour dans le chemin /project/version
    # retourner 1 si la version a été mise à jour dans le chemin /project/parent/version
    # retourner 2 si la version a été mise à jour dans un autre chemin
    # retourner 3 si une erreur s'est produite
    local pom="${1:-pom.xml}"
    local version="${2:-1.0.0-SNAPSHOT}"
    local vpath="$3"
    [ -n "$vpath" ] || vpath="$(__pver_pom_get_vpath "$pom")"
    xpathtool -f "$pom" -s "$vpath" "$version" || return 3
    case "$vpath" in
    /project/version) return 0;;
    /project/parent/version) return 1;;
    *) return 2;;
    esac
}

function pver() {
    local DEFAULT_FILE=VERSION.txt
    local DEFAULT_POM=pom.xml

    local -a args
    local action=auto
    local source=auto
    local file git version operator oversion
    local setversion incversion
    local setpr setprelease setsnapshot setalpha setbeta setrc setrelease
    local setmd resetmetadata setmetadata addmetadata vcsmetadata
    local vpath setmapfile mapfile allow_empty convert=auto maven_update
    parse_opts "${PRETTYOPTS[@]}" \
        --help '$exit_with pver_display_help' \
        -w:,--w:,--fw:,--auto-file: '$set@ file; source=auto-file' \
        --sw:,--auto-string: '$set@ file; source=auto-string' \
        --gw:,--auto-git-string: '$set@ git; source=auto-git-string' \
        -e:,--e:,--pom:,--maven: '$set@ file; source=pom' \
        -E:,--E:,--pom-string:,--maven-string: '$set@ file; source=pom-string' \
        -f:,--f:,--file: '$set@ file; source=file' \
        -F:,--F:,--file-string: '$set@ file; source=file-string' \
        -g:,--g:,--git-file-string:,--git-string: '$set@ git; source=git-file-string' \
        -G:,--G:,--git-pom-string: '$set@ git; source=git-pom-string' \
        --git-prel-string source=git-prel-string \
        -s:,--s:,--string: '$set@ version; source=string' \
        --show action=show \
        --show-source action=show-source \
        --check action=check \
        --eq: '$action=compare; operator=eq; set@ oversion' \
        --ne: '$action=compare; operator=ne; set@ oversion' \
        --lt: '$action=compare; operator=lt; set@ oversion' \
        --le: '$action=compare; operator=le; set@ oversion' \
        --gt: '$action=compare; operator=gt; set@ oversion' \
        --ge: '$action=compare; operator=ge; set@ oversion' \
        -u,--update '$action=update; [ -z "$incversion" ] && incversion=auto' \
        --menu '$action=update; incversion=menu' \
        -v:,--set-version: '$action=update; set@ setversion; incversion=' \
        --prel '$action=update; setversion=prel; incversion=' \
        -x,--major '$action=update; incversion=major' \
        -z,--minor '$action=update; incversion=minor' \
        -p,--patchlevel '$action=update; incversion=patchlevel' \
        -k,--keep '$action=update; incversion=' \
        -l:,--prelease:,--prerelease: '$action=update; setpr=1; setsnapshot=; setalpha=; setbeta=; setrc=; setrelease=; set@ setprelease; [ -z "$setprelease" ] && setrelease=1' \
        -S,--snapshot '$action=update; setpr=1; setsnapshot=1; setalpha=; setbeta=; setrc=; setrelease=' \
        -a,--alpha '$action=update; setpr=1; setsnapshot=; setalpha=1; setbeta=; setrc=; setrelease=' \
        -b,--beta '$action=update; setpr=1; setsnapshot=; setalpha=; setbeta=1; setrc=; setrelease=' \
        -r,--rc '$action=update; setpr=1; setsnapshot=; setalpha=; setbeta=; setrc=1; setrelease=' \
        -R,--release,--final '$action=update; setpr=1; setsnapshot=; setalpha=; setbeta=; setrc=; setrelease=1' \
        -m:,--metadata:,--set-metadata: '$action=update; setmd=1; resetmetadata=1; set@ setmetadata' \
        --add-metadata: '$action=update; setmd=1; set@ addmetadata' \
        -M,--vcs-metadata '$action=update; setmd=1; vcsmetadata=1' \
        --vpath: vpath= \
        --map: '$setmapfile=1; set@ mapfile' \
        --allow-empty allow_empty=1 \
        --convert convert=1 \
        --no-convert convert= \
        -t,--maven-update maven_update=1 \
        @ args -- "$@" && set -- "${args[@]}" || { eerror "$args"; return 1; }

    # Calculer la source
    if [ "$source" == auto-file -o "$source" == auto-string ]; then
        [ -n "$file" ] || file=.
        if [ -d "$file" ]; then
            if [ -f "$file/$DEFAULT_POM" ]; then
                file="$file/$DEFAULT_POM"
            elif [ -f "$file/$DEFAULT_FILE" ]; then
                file="$file/$DEFAULT_FILE"
            elif [ -f "$file/version.txt" ]; then
                file="$file/version.txt"
            else
                file="$file/$DEFAULT_FILE"
            fi
        fi
        if [ "$source" == auto-file ]; then
            if [[ "$file" == *.xml ]]; then source=pom
            else source=file
            fi
        elif [ "$source" == auto-string ]; then
            if [[ "$file" == *.xml ]]; then source=pom-string
            else source=file-string
            fi
        fi
        edebug "Auto-sélection de $(ppath "$file")"

    elif [ "$source" == auto-git-string ]; then
        git_check_gitvcs || return 2
        splitfsep2 "$git" : branch name
        [ -n "$branch" ] || branch=master
        if [ "$(git cat-file -t "$branch:$name" 2>/dev/null)" == tree ]; then
            if git rev-parse --verify --quiet "$branch:${name:+$name/}$DEFAULT_POM" >/dev/null; then
                name="${name:+$name/}$DEFAULT_POM"
            elif git rev-parse --verify --quiet "$branch:${name:+$name/}$DEFAULT_FILE" >/dev/null; then
                name="${name:+$name/}$DEFAULT_FILE"
            elif git rev-parse --verify --quiet "$branch:${name:+$name/}version.txt" >/dev/null; then
                name="${name:+$name/}version.txt"
            fi
        fi
        if git rev-parse --verify --quiet "$branch:$name" >/dev/null; then
            if [[ "$name" == *.xml ]]; then source=git-pom-string
            else source=git-file-string
            fi
            git="$branch:$name"
            edebug "Auto-sélection de $git"
        else
            eerror "$name: fichier introuvable sur la branche $branch"
            return 1
        fi
    fi

    if [ "$source" == auto ]; then
        source=file
        for i in "$DEFAULT_POM" "$DEFAULT_FILE" version.txt; do
            if [ -f "$i" ]; then
                case "$i" in
                "$DEFAULT_POM") source=pom; file="$i"; break;;
                *) source=file; file="$i"; break;;
                esac
            fi
        done
    elif [ "$source" == file -o "$source" == pom ]; then
        [ "$action" == auto ] && action=update
    fi
    [ "$source" == file -a -z "$file" ] && file="$DEFAULT_FILE"
    [ "$source" == pom -a -z "$file" ] && file="$DEFAULT_POM"
    [ "$action" == auto ] && action=show

    if [[ "$source" == auto* ]]; then
        eerror "bug: impossible de déterminer la source"
        return 1
    fi

    if [ "$action" == show-source ]; then
        echo "$source"
        return 0
    fi

    # Lire la version
    local -a maprules
    if [ "$source" == file -o "$source" == pom ]; then
        local mapdir="$(dirname -- "$file")"
        if [ -z "$setmapfile" ]; then
            local tmpfile
            tmpfile="$mapdir/.pver-map"
            [ -f "$tmpfile" ] && mapfile="$tmpfile"
        fi
        if [ -n "$mapfile" ]; then
            __pver_unless -f "$mapfile" "$mapfile: fichier introuvable" || return

            mapdir="$(dirname -- "$mapfile")"
            array_from_lines maprules "$(<"$mapfile" filter_conf)"
            local maprule filespec filevpath filename
            local -a filenames
            for maprule in "${maprules[@]}"; do
                splitpair "$maprule" filespec filevpath
                [ "$filevpath" != - ] || continue
                array_lsfiles filenames "$mapdir" "$filespec"
                [ ${#filenames[*]} -gt 0 ] || continue
                file="${filenames[0]}"
                if [[ "$file" == *.xml ]]; then source=pom
                else source=file
                fi
                edebug "Sélection de $file comme fichier de référence"
                break
            done
        fi
    fi
    [ "$source" == pom ] && maven_update=1

    if [ "$source" == file ]; then
        [ -f "$file" ] && version="$(<"$file")"

    elif [ "$source" == file-string ]; then
        if [ -z "$file" ]; then
            file="$DEFAULT_FILE"
        elif [ -d "$file" ]; then
            file="$file/$DEFAULT_FILE"
        fi
        [ -f "$file" ] && version="$(<"$file")"
        file=

    elif [ "$source" == git-file-string ]; then
        git_check_gitvcs || return 2
        splitfsep2 "$git" : branch name
        [ -n "$branch" ] || branch=master
        [ -n "$name" ] || name="$DEFAULT_FILE"
        if git rev-parse --verify --quiet "$branch:$name" >/dev/null; then
            version="$(git cat-file blob "$branch:$name" 2>/dev/null)"
        fi

    elif [ "$source" == pom ]; then
        __pver_unless -f "$file" "$file: fichier introuvable" || return
        [ -n "$vpath" ] || vpath="$(__pver_pom_get_vpath "$file")"
        version="$(__pver_pom_get_version "$file" "$vpath")"

    elif [ "$source" == pom-string ]; then
        if [ -z "$file" ]; then file="$DEFAULT_POM"
        elif [ -d "$file" ]; then file="$file/$DEFAULT_POM"
        fi
        __pver_unless -f "$file" "$file: fichier introuvable" || return

        [ -n "$vpath" ] || vpath="$(__pver_pom_get_vpath "$file")"
        version="$(__pver_pom_get_version "$file" "$vpath")"
        file=

    elif [ "$source" == git-pom-string ]; then
        git_check_gitvcs || return 2
        splitfsep2 "$git" : branch name
        [ -n "$branch" ] || branch=master
        [ -n "$name" ] || name="$DEFAULT_POM"
        if git rev-parse --verify --quiet "$branch:$name" >/dev/null; then
            local tmpfile; ac_set_tmpfile tmpfile
            git cat-file blob "$branch:$name" >"$tmpfile" 2>/dev/null
            [ -n "$vpath" ] || vpath="$(__pver_pom_get_vpath "$tmpfile")"
            version="$(__pver_pom_get_version "$tmpfile" "$vpath")"
            ac_clean "$tmpfile"
        else
            eerror "$name: fichier introuvable sur la branche $branch"
            return 1
        fi

    elif [ "$source" == git-prel-string ]; then
        version="$(__pver_get_prel_version)" || return
    fi

    [ -n "$version" -o -n "$allow_empty" ] || version=0.0.0

    # Conversion éventuelle du numéro de version
    psemver_parse "$version"
    [ -n "$valid" ] && convert=
    if [ "$convert" == auto ]; then
        [ -z "$valid" ] && convert=1
    fi
    if [ -n "$convert" -a -n "$version" ]; then
        mversion="$(awkrun version="$version" '
function nbdot(s) {
  gsub(/[^.]/, "", s)
  return length(s)
}
BEGIN {
  ### utools, legacy
  if (version ~ /[0-9]+(\.[0-9]+)*(-r[0-9][0-9]\/[0-9][0-9]\/[0-9][0-9][0-9][0-9])?$/) {
    metadata = ""
    # traiter release date
    pos = length(version) - 12
    if (pos > 0) {
      rdate = substr(version, pos + 3)
      metadata = substr(rdate, 7, 4) substr(rdate, 4, 2) substr(rdate, 1, 2)
      version = substr(version, 1, pos)
    }
    # traiter metadata
    match(version, /[0-9]+(\.[0-9]+(\.[0-9]+)?)?/)
    pos = RLENGTH
    if (pos < length(version)) {
      if (metadata != "") metadata = metadata "."
      metadata = metadata substr(version, pos + 2)
    }
    version = substr(version, 1, pos)
    # ajouter les éléments manquants
    while (nbdot(version) < 2) {
      version = version ".0"
    }
    # afficher la version migrée au format semver
    if (metadata != "") print version "+r" metadata
    else print version

  ### maven, pom.xml
  } else if (version ~ /[0-9]+(\.[0-9]+)*(-[sS][nN][aA][pP][sS][hH][oO][tT])?$/) {

    prerelease = ""
    # traiter prerelease
    pos = length(version) - 9
    if (pos > 0) {
      prerelease = substr(version, pos + 2)
      version = substr(version, 1, pos)
    }
    # traiter prerelease
    match(version, /[0-9]+(\.[0-9]+(\.[0-9]+)?)?/)
    pos = RLENGTH
    if (pos < length(version)) {
      if (prerelease != "") prerelease = prerelease "."
      prerelease = prerelease substr(version, pos + 2)
    }
    version = substr(version, 1, pos)
    # ajouter les éléments manquants
    while (nbdot(version) < 2) {
      version = version ".0"
    }
    # afficher la version migrée au format semver
    if (prerelease != "") print version "-" prerelease
    else print version
  }
}')"
        if [ -n "$mversion" ]; then
            version="$mversion"
            psemver_parse "$version"
        fi
    fi

    # Actions
    if [ "$action" == show ]; then
        if [ -n "$version" ]; then
            if isatty; then
                estepi "La version actuelle est $version"
            else
                echo "$version"
            fi
            return 0
        else
            if isatty; then
                estepi "Il n'y a pas de version définie"
            fi
            return 1
        fi
    fi

    if [ "$action" == check ]; then
        __pver_unless -n "$valid" "Numéro de version invalide: $version" || return

    elif [ "$action" == compare ]; then
        psemver_parse "$oversion" o

        case "$operator" in
        eq|same)
            for var in valid major minor patchlevel; do
                ovar="o$var"
                [ "${!var}" == "${!ovar}" ] || return 1
            done
            array_eq prelease oprelease || return 1
            if [ "$operator" == same ]; then
                array_eq metadata ometadata || return 1
            fi
            return 0
            ;;
        ne|diff)
            for var in valid major minor patchlevel; do
                ovar="o$var"
                [ "${!var}" != "${!ovar}" ] && return 0
            done
            ! array_eq prelease oprelease && return 0
            if [ "$operator" == diff ]; then
                ! array_eq metadata ometadata && return 0
            fi
            return 1
            ;;
        lt)
            [ -z "$valid" -a -z "$ovalid" ] && return 1
            [ "$major" -lt "$omajor" ] && return 0
            [ "$major" -gt "$omajor" ] && return 1
            [ "$minor" -lt "$ominor" ] && return 0
            [ "$minor" -gt "$ominor" ] && return 1
            [ "$patchlevel" -lt "$opatchlevel" ] && return 0
            [ "$patchlevel" -gt "$opatchlevel" ] && return 1
            case "$(psemver_compare_prelease "" o)" in
            lt) return 0;;
            esac
            return 1
            ;;
        le)
            [ -z "$valid" -a -z "$ovalid" ] && return 1
            [ "$major" -lt "$omajor" ] && return 0
            [ "$major" -gt "$omajor" ] && return 1
            [ "$minor" -lt "$ominor" ] && return 0
            [ "$minor" -gt "$ominor" ] && return 1
            [ "$patchlevel" -lt "$opatchlevel" ] && return 0
            [ "$patchlevel" -gt "$opatchlevel" ] && return 1
            case "$(psemver_compare_prelease "" o)" in
            lt|eq) return 0;;
            esac
            return 1
            ;;
        gt)
            [ -z "$valid" -a -z "$ovalid" ] && return 1
            [ "$major" -lt "$omajor" ] && return 1
            [ "$major" -gt "$omajor" ] && return 0
            [ "$minor" -lt "$ominor" ] && return 1
            [ "$minor" -gt "$ominor" ] && return 0
            [ "$patchlevel" -lt "$opatchlevel" ] && return 1
            [ "$patchlevel" -gt "$opatchlevel" ] && return 0
            case "$(psemver_compare_prelease "" o)" in
            gt) return 0;;
            esac
            return 1
            ;;
        ge)
            [ -z "$valid" -a -z "$ovalid" ] && return 1
            [ "$major" -lt "$omajor" ] && return 1
            [ "$major" -gt "$omajor" ] && return 0
            [ "$minor" -lt "$ominor" ] && return 1
            [ "$minor" -gt "$ominor" ] && return 0
            [ "$patchlevel" -lt "$opatchlevel" ] && return 1
            [ "$patchlevel" -gt "$opatchlevel" ] && return 0
            case "$(psemver_compare_prelease "" o)" in
            gt|eq) return 0;;
            esac
            return 1
            ;;
        esac

    elif  [ "$action" == update ]; then
        [ -z "$version" -a -n "$allow_empty" ] && return 1
        __pver_unless -n "$valid" "Numéro de version invalide: $version" || return

        if [ -n "$file" ]; then
            if [ -f "$file" ]; then
                isatty && estepi "La version actuelle est $version"
            elif [ "$source" == pom ]; then
                eerror "$file: fichier introuvable"
                return 1
            elif isatty; then
                ask_yesno "Le fichier $(ppath "$file") n'existe pas. Faut-il le créer?" O || return 1
            fi
        fi

        # forcer le numéro de version
        if [ -n "$setversion" ]; then
            if [ "$setversion" == prel ]; then
                setversion="$(__pver_get_prel_version)"
                __pver_perror $? \
                              "$(git_get_branch): n'est pas une release branch" \
                              "Dépôt git introuvable" || return
            fi
            psemver_setversion "$setversion" "" || {
                eerror "Numéro de version invalide: $setversion"
                return 1
            }
        fi

        # Calculer metadata
        if [ -n "$vcsmetadata" ]; then
            resetmetadata=1
            setmetadata="$(git rev-parse --short HEAD)" || return 1
        fi

        # incrémenter les numéros de version
        if [ -n "$maven_update" -a -n "$incversion" ]; then
            # il y a des règles particulières pour maven
            if [ -n "$setrelease" -a -z "$prelease" ]; then
                # on est déjà en release, faire le traitement normal
                maven_update=
            elif [ -n "$setsnapshot" -a "$prelease" == SNAPSHOT ]; then
                # on est déjà en snapshot, faire le traitement normal, mais garder le préfixe SNAPSHOT
                maven_update=
                if [ "$incversion" == auto ]; then
                    [ -n "$setmd" ] && incversion= || incversion=menu
                fi
            elif [ -z "$prelease" ]; then
                # on est en release, passer en snapshot
                setsnapshot=1
                setrelease=
                if [ "$incversion" == auto ]; then
                    [ -n "$setmd" ] && incversion= || incversion=menu
                fi
            elif [ "$prelease" == SNAPSHOT ]; then
                # on est en snapshot, passer en release
                setsnapshot=
                setrelease=1
                if [ "$incversion" == auto ]; then
                    [ -n "$setmd" ] && incversion= || incversion=menu
                fi
            fi
        fi
        if [ "$incversion" == auto ]; then
            [ -n "$setpr" -o -n "$setmd" ] && incversion= || incversion=menu
        fi
        if [ -z "$incversion" -a -n "$maven_update" ]; then
            # on doit incrémenter avec les règles maven, mais aucune des options
            # -[xzp] n'est spécifiée
            if [ -n "$setrelease" ]; then
                incversion=patchlevel
            elif [ -n "$setsnapshot" ]; then
                incversion=patchlevel
            fi
        fi

        if [ -n "$setrelease" ]; then setprelease=
        elif [ -n "$setsnapshot" ]; then setprelease=SNAPSHOT
        fi
        if [ "$incversion" == menu ]; then
            psemver_copy x
            psemver_incsetprmd major x "$setprelease" 1 "$setmetadata" "$addmetadata" "$maven_update"
            psemver_setvar versionx x
            psemver_copy z
            psemver_incsetprmd minor z "$setprelease" 1 "$setmetadata" "$addmetadata" "$maven_update"
            psemver_setvar versionz z
            psemver_copy p
            psemver_incsetprmd patchlevel p "$setprelease" 1 "$setmetadata" "$addmetadata" "$maven_update"
            psemver_setvar versionp p
            psemver_copy k
            psemver_incsetprmd "" k "$setprelease" "$resetmetadata" "$setmetadata" "$addmetadata" "$maven_update"
            psemver_setvar versionk k
            nextvs=(
                "$versionx : maj incompatibles de l'API (-x)"
                "$versionz : maj compatibles de l'API (-z)"
                "$versionp : correction de bugs (-p)"
                "$versionk : ne pas incrémenter la version"
            )
            if [ -z "$maven_update" ]; then
                nextv="${nextvs[1]}"
            else
                nextv="${nextvs[2]}"
            fi
            simple_menu nextv nextvs \
                -t "Incrémenter le numéro de version" \
                -m "Veuillez choisir la prochaine version"
            case "${nextv%)}" in
            *-x) incversion=major;;
            *-z) incversion=minor;;
            *-p) incversion=patchlevel;;
            *) incversion=;;
            esac
        fi

        local r
        if [ -n "$incversion" ]; then
            psemver_incsetprmd "$incversion" "" "$setprelease" 1 "$setmetadata" "$addmetadata" "$maven_update"
            r=$?
        else
            psemver_setprmd "" "$setprelease" "$resetmetadata" "$setmetadata" "$addmetadata"
            r=$?
        fi
        case $r in
        2) eerror "Identifiant de pre-release invalide: $setprelease"; return 1;;
        3) eerror "Identifiant de build invalide: $setmetadata"; return 1;;
        4) eerror "Identifiant de build invalide: $addmetadata"; return 1;;
        esac

        # afficher le résultat final
        local -a depfiles regfiles
        psemver_setvar version
        if [ -n "$file" ]; then
            if [ "$source" == file ]; then
                echo "$version" >"$file"
            elif [ "$source" == pom ]; then
                __pver_pom_set_version "$file" "$version"
                [ $? -eq 3 ] && return 1
            fi
            if [ ${#maprules[*]} -gt 0 ]; then
                # mettre à jour les fichiers mentionnés dans mapfile
                local -a donefiles
                for maprule in "${maprules[@]}"; do
                    splitpair "$maprule" filespec filevpath
                    array_lsfiles filenames "$mapdir" "$filespec"
                    for file in "${filenames[@]}"; do
                        file="$(abspath "$file")"
                        edebug "Examen de $file"
                        # si c'est un wildcard, ne traiter que si le fichier n'a
                        # pas encore été traité
                        case "$filespec" in *\**|*\?*) array_contains donefiles "$file" && break;; esac
                        if [ "$filevpath" != - ]; then
                            if [[ "$file" == *.xml ]]; then
                                edebug "Maj version de $file au chemin XPATH ${filevpath:-par défaut}"
                                __pver_pom_set_version "$file" "$version" "$filevpath"
                                case $? in
                                0|1) array_addu regfiles "$file";;
                                2) array_addu depfiles "$file";;
                                *) return 1;;
                                esac
                            else
                                edebug "Maj version de $file"
                                echo "$version" >"$file"
                            fi
                        else
                            edebug "Fichier $file ignoré"
                        fi
                        array_addu donefiles "$file"
                    done
                done
            fi
        fi
        if isatty; then
            estepn "La nouvelle version est $version"
            if [ ${#depfiles[*]} -gt 0 ]; then
                local msg
                for file in "${depfiles[@]}"; do
                    array_contains regfiles "$file" && continue
                    if [ -z "$msg" ]; then
                        msg="Les fichiers suivants ont été modifiés, et leur version doit être mise à jour:"
                    fi
                    msg="$msg
    $(qvals pver -uzw "$file" -R --menu)"
                done
                [ -n "$msg" ] && eimportant "$msg"
            fi
        else
            echo "$version"
        fi
    fi

    return 0
}