##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
## Charger ulib. Nécessite bash.
##@cooked nocomments

# Ce fichier doit être *sourcé*. Si ce fichier n'est pas sourcé, alors le
# répertoire ulib doit être disponible dans le répertoire du script qui inclue
# ce fichier. Ceci peut-être fait avec ulibsync.

# Ensuite, des librairies individuelles de ulib peuvent être chargées avec la
# fonction urequire(), e.g.
#     source /etc/ulib || exit 1
#     urequire DEFAULTS conf
# 'DEFAULTS' permet de charger base, pretty, sysinfos et compat.

function eerror() { echo "error: $*" 1>&2; }
function die() { [ -n "$*" ] && eerror "$*"; exit 1; }

## Calculer l'emplacement de ulib

# il est possible de forcer la valeur de ULIBDIR avec FORCED_ULIBDIR. ceci est
# utile avec bash 2.x qui ne supporte pas la variable BASH_SOURCE
ULIBDIR="${FORCED_ULIBDIR:-@@dest@@/lib/ulib}"

if [ "$ULIBDIR" = "@@""dest""@@/lib/ulib" ]; then
    # La valeur "@@"dest"@@" n'est remplacée que dans la copie de ce script
    # faite dans /etc. Sinon, il faut toujours faire le calcul. Cela permet de
    # déplacer la librairie n'importe ou sur le disque, ce qui est
    # particulièrement intéressant quand on fait du déploiement.
    ULIBDIR="${BASH_SOURCE[0]}"
    if [ -n "$ULIBDIR" -a -f "$ULIBDIR" ]; then
        # Fichier sourcé
        ULIBDIR="$(dirname "$ULIBDIR")"
    else
        # Fichier non sourcé. Tout exprimer par rapport au script courant
        ULIBDIR="$(dirname "$0")"
        if [ -d "$ULIBDIR/ulib" ]; then
            ULIBDIR="$ULIBDIR/ulib"
        elif [ -d "$ULIBDIR/lib/ulib" ]; then
            ULIBDIR="$ULIBDIR/lib/ulib"
        fi
    fi
fi
ULIBDIR="$(cd "$ULIBDIR" 2>/dev/null; pwd)"
ULIBDIRS=("$ULIBDIR")

# marqueur pour tester si ulib a été réellement chargé. Il faut avoir $ULIBINIT==$ULIBDIR
ULIBINIT="$ULIBDIR"

# liste des fichiers sourcés par urequire
[ -n "$ULIBPROVIDED" ] || ULIBPROVIDED=(ulib)

function uprovided() {
    # Tester si le module $1 a déjà été chargé par urequire
    local module
    for module in "${ULIBPROVIDED[@]}"; do
        [ "$module" == "$1" ] && return 0
    done
    return 1
}

function uprovide() {
    # Spécifier que le module $1 a été sourcée, ou prétendre que c'est le cas.
    # Retourner 1 si le module était déjà pourvu, 0 si c'est la première fois
    # qu'on le pourvoit
    uprovided "$1" && return 1
    ULIBPROVIDED=("${ULIBPROVIDED[@]}" "$1")
}

# Si cette variable est non vide, urequire recharge toujours le module, même
# s'il a déjà été chargé. Cette valeur n'est pas transitive: il faut toujours
# recharger explicitement tous les modules désirés
__ULIB_FORCE_RELOAD=

function urequire() {
    # Sourcer un module recherché dans ULIBDIRS
    # Le module DEFAULTS est traité de façon particulière: si le fichier associé
    # n'est pas trouvé, charger base, pretty, sysinfos et compat à la place
    # Si un module n'est pas trouvé, quitter le script avec die()
    local __u_module __u_ulibdir __u_found
    [ -n "$*" ] || set DEFAULTS

    # garder une copie de la valeur originale et casser la transitivité
    local __ulib_force_reload="$__ULIB_FORCE_RELOAD"
    local __ULIB_FORCE_RELOAD

    for __u_module in "$@"; do
        __u_found=
        for __u_ulibdir in "${ULIBDIRS[@]}"; do
            if [ -f "$__u_ulibdir/$__u_module" ]; then
                __u_found=1
                if [ -n "$__ulib_force_reload" ] || ! uprovided "$__u_module"; then
                    uprovide "$__u_module"
                    source "$__u_ulibdir/$__u_module" || die
                fi
                break
            fi
        done
        if [ -z "$__u_found" -a "$__u_module" == DEFAULTS ]; then
            __u_found=1
            for __u_module in base pretty sysinfos compat; do
                if [ -n "$__ulib_force_reload" ] || ! uprovided "$__u_module"; then
                    uprovide "$__u_module"
                    source "$__u_ulibdir/$__u_module" || die
                fi
            done
        fi
        [ -n "$__u_found" ] || die "Unable to find $__u_module in ${ULIBDIR[*]}"
    done
    return 0
}

function ulibadd() {
    # Ajouter $1 au chemin de recherche de urequire
    [ -d "$1" ] && ULIBDIRS=("${ULIBDIRS[@]}" "$(cd "$1"; pwd)")
}

function ulibsync() {
    # Synchroniser les modules de ulib dans le répertoire $1
    local destdir="$(abspath "${1:-.}")"
    local -a __CPNOVCS_RSYNC_ARGS
    __CPNOVCS_RSYNC_ARGS=(-q --delete)
    [ "$destdir/ulib" != "$ULIBDIR" ] && cpdirnovcs "$ULIBDIR" "$destdir/ulib"
}

function __ulibver_parse_version() {
# copie verbatim de la fonction parseversion() du script ulib dans nutools
    if [ -n "$2" ]; then
        local version="${1:-${version:-000000000}}"
        local major minor patch pversion
    else
        version="${1:-${version:-000000000}}"
    fi
    while [ ${#version} -lt 9 ]; do version="0$version"; done
    major="${version:0:3}"; while [ ${#major} -gt 1 -a "${major#0}" != "$major" ]; do major="${major#0}"; done
    minor="${version:3:3}"; while [ ${#minor} -gt 1 -a "${minor#0}" != "$minor" ]; do minor="${minor#0}"; done
    patch="${version:6:3}"; while [ ${#patch} -gt 1 -a "${patch#0}" != "$patch" ]; do patch="${patch#0}"; done
    pversion="$major.$minor.$patch"
    [ -n "$2" ] && eval "${2}version=\$version; ${2}major=\$major; ${2}minor=\$minor; ${2}patch=\$patch; ${2}pversion=\$pversion"
}
function __ulibver_format_version() {
# copie verbatim de la fonction formatversion() du script ulib dans nutools
    local major="${1:-${major:-0}}" minor="${2:-${minor:-0}}" patch="${3:-${patch:-0}}"
    while [ ${#major} -lt 3 ]; do major="0$major"; done
    while [ ${#minor} -lt 3 ]; do minor="0$minor"; done
    while [ ${#patch} -lt 3 ]; do patch="0$patch"; done
    echo "$major$minor$patch"
}
function __ulibver_parse_pversion() {
# copie verbatim de la fonction parsepversion() du script ulib dans nutools
    local v M m p
    if [[ "$1" == *.* ]]; then
        local v="$1"; shift
        local M=0 m=0 p=0
        if [[ "$v" == *.* ]]; then
            p="${v##*.}"; v="${v%.*}"
            if [[ "$v" == *.* ]]; then
                m="${v##*.}"; v="${v%.*}"
                if [[ "$v" == *.* ]]; then M="${v##*.}"; v="${v%.*}"
                else M="$v"
                fi
            else m="$v"
            fi
        else p="$v"
        fi
        __ulibver_parse_version "$(__ulibver_format_version "$M" "$m" "$p")" "$@"
    else
        __ulibver_parse_version "$@"
    fi
}
function ulibver() {
    # Vérifier que la version actuelle de ulib est au moins à la version $1
    # (inclue) et éventuellement au plus à la version $2 (exclue)
    [ -f "$ULIBDIR/.ulibver" ] || return 1
    local version=000000000 major minor patch pversion
    __ulibver_parse_version "$(<"$ULIBDIR/.ulibver")"
    if [ -n "$1" ]; then
        local minversion=000000000 minmajor minminor minpatch minpversion
        __ulibver_parse_pversion "$1" min
        if [ "$major" -lt "$minmajor" ]; then
            return 1
        elif [ "$major" -eq "$minmajor" ]; then
            if [ "$minor" -lt "$minminor" ]; then
                return 1
            elif [ "$minor" -eq "$minminor" ]; then
                [ "$patch" -lt "$minpatch" ] && return 1
            fi
        fi
    fi
    if [ -n "$2" ]; then
        local maxversion=000000000 maxmajor maxmaxor maxpatch maxpversion
        __ulibver_parse_pversion "$2" max
        if [ "$major" -gt "$maxmajor" ]; then
            return 1
        elif [ "$major" -eq "$maxmajor" ]; then
            if [ "$minor" -gt "$maxminor" ]; then
                return 1
            elif [ "$minor" -eq "$maxminor" ]; then
                [ "$patch" -ge "$maxpatch" ] && return 1
            fi
        fi
    fi
    return 0
}

function ulibver_require() {
    ulibver "$@" && return 0
    eerror "Ce script nécessite ulib version${1:+" >= $1"}${2:+" < $2"}"
    return 1
}
