# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
##@cooked nocomments
module: base.split "Fonctions de base: analyse et découpage de valeurs"
require: base.arr

function: splitfsep "\
Découper \$1 de la forme first[SEPsecond] entre first, qui est placé dans la
variable \$3(=first) et second, qui est placée dans la variable \$4(=second). \$2
est la valeur SEP. Le découpage est faite sur la *première* occurence de SEP."
function splitfsep() {
    if [[ "$1" == *"$2"* ]]; then
        setv "${3:-first}" "${1%%$2*}"
        setv "${4:-second}" "${1#*$2}"
    else
        setv "${3:-first}" "$1"
        setv "${4:-second}"
    fi
}

function: splitfsep2 "\
Découper \$1 de la forme [firstSEP]second entre first, qui est placé dans la
variable \$3(=first) et second, qui est placée dans la variable \$4(=second). \$2
est la valeur SEP. Le découpage est faite sur la *première* occurence de SEP."
function splitfsep2() {
    if [[ "$1" == *"$2"* ]]; then
        setv "${3:-first}" "${1%%$2*}"
        setv "${4:-second}" "${1#*$2}"
    else
        setv "${3:-first}"
        setv "${4:-second}" "$1"
    fi
}

function: splitlsep "\
Découper \$1 de la forme first[SEPsecond] entre first, qui est placé dans la
variable \$3(=first) et second, qui est placée dans la variable \$4(=second). \$2
est la valeur SEP. Le découpage est faite sur la *dernière* occurence de SEP."
function splitlsep() {
    if [[ "$1" == *"$2"* ]]; then
        setv "${3:-first}" "${1%$2*}"
        setv "${4:-second}" "${1##*$2}"
    else
        setv "${3:-first}" "$1"
        setv "${4:-second}"
    fi
}

function: splitlsep2 "\
Découper \$1 de la forme [firstSEP]second entre first, qui est placé dans la
variable \$3(=first) et second, qui est placée dans la variable \$4(=second). \$2
est la valeur SEP. Le découpage est faite sur la *dernière* occurence de SEP."
function splitlsep2() {
    if [[ "$1" == *"$2"* ]]; then
        setv "${3:-first}" "${1%$2*}"
        setv "${4:-second}" "${1##*$2}"
    else
        setv "${3:-first}"
        setv "${4:-second}" "$1"
    fi
}

function: splitvar "\
Découper \$1 de la forme name[=value] entre le nom, qui est placé dans la
variable \$2(=name) et la valeur, qui est placée dans la variable \$3(=value)"
function splitvar() {
    splitfsep "$1" = "${2:-name}" "${3:-value}"
}

function: splitpath "\
Découper \$1 de la forme [dir/]name entre le répertoire, qui est placé dans la
variable \$2(=dir), et le nom du fichier, qui est placé dans la variable
\$3(=name)"
function splitpath() {
    splitlsep2 "$1" / "${2:-dir}" "${3:-name}"
}

function: splitname "\
Découper \$1 de la forme basename[.ext] entre le nom de base du fichier, qui
est placé dans la variable \$2(=basename) et l'extension, qui est placée dans
la variable \$3(=ext)

Attention, si \$1 est un chemin, le résultat risque d'être faussé. Par exemple,
'splitname a.b/c' ne donne pas le résultat escompté."
function splitname() {
    splitlsep "$1" . "${2:-basename}" "${3:-ext}"
}

function: splithost "\
Découper \$1 de la forme hostname[.domain] entre le nom d'hôte, qui est placé
dans la variable \$2(=hostname) et le domaine, qui est placée dans la variable
\$3(=domain)"
function splithost() {
    splitfsep "$1" . "${2:-hostname}" "${3:-domain}"
}

function: splituserhost "\
Découper \$1 de la forme [user@]host entre le nom de l'utilisateur, qui est placé
dans la variable \$2(=user) et le nom d'hôte, qui est placée dans la variable
\$3(=host)"
function splituserhost() {
    splitfsep2 "$1" @ "${2:-user}" "${3:-host}"
}

function: splitpair "\
Découper \$1 de la forme first[:second] entre la première valeur, qui est placé
dans la variable \$2(=src) et la deuxième valeur, qui est placée dans la variable
\$3(=dest)"
function splitpair() {
    splitfsep "$1" : "${2:-src}" "${3:-dest}"
}

function: splitproxy "\
Découper \$1 de la forme http://[user:password@]host[:port]/ entre les valeurs
\$2(=host), \$3(=port), \$4(=user), \$5(=password)

S'il n'est pas spécifié, port vaut 3128 par défaut"
function splitproxy() {
    local sy__tmp sy__host sy__port sy__creds sy__user sy__password

    sy__tmp="${1#http://}"
    if [[ "$sy__tmp" == *@* ]]; then
        sy__creds="${sy__tmp%%@*}"
        sy__tmp="${sy__tmp#${sy__creds}@}"
        splitpair "$sy__creds" sy__user sy__password
    fi
    sy__tmp="${sy__tmp%%/*}"
    splitpair "$sy__tmp" sy__host sy__port
    [ -n "$sy__port" ] || sy__port=3128

    setv "${2:-host}" "$sy__host"
    setv "${3:-port}" "$sy__port"
    setv "${4:-user}" "$sy__user"
    setv "${5:-password}" "$sy__password"
}

function: spliturl "\
Découper \$1 de la forme scheme://[user:password@]host[:port]/path entre les
valeurs \$2(=scheme), \$3(=user), \$4(=password), \$5(=host), \$6(=port), \$7(=path)

S'il n'est pas spécifié, port vaut 80 pour http, 443 pour https, 21 pour ftp"
function spliturl() {
    local sl__tmp sl__scheme sl__creds sl__user sl__password sl__host sl__port sl__path

    sl__scheme="${1%%:*}"
    sl__tmp="${1#${sl__scheme}://}"
    if [[ "$sl__tmp" == */* ]]; then
        sl__path="${sl__tmp#*/}"
        sl__tmp="${sl__tmp%%/*}"
    fi
    if [[ "$sl__tmp" == *@* ]]; then
        sl__creds="${sl__tmp%%@*}"
        sl__tmp="${sl__tmp#${sl__creds}@}"
        splitpair "$sl__creds" sl__user sl__password
    fi
    splitpair "$sl__tmp" sl__host sl__port
    if [ -z "$sl__port" ]; then
        [ "$sl__scheme" == "http" ] && sl__port=80
        [ "$sl__scheme" == "https" ] && sl__port=443
        [ "$sl__scheme" == "ftp" ] && sl__port=21
    fi

    setv "${2:-scheme}" "$sl__scheme"
    setv "${3:-user}" "$sl__user"
    setv "${4:-password}" "$sl__password"
    setv "${5:-host}" "$sl__host"
    setv "${6:-port}" "$sl__port"
    setv "${7:-path}" "$sl__path"
}

function: splitwcs "\
Découper un nom de chemin \$1 entre la partie sans wildcards, qui est placée dans
la variables \$2(=basedir), et la partie avec wildcards, qui est placée dans la
variable \$3(=filespec)"
function splitwcs() {
    local ss__p="$1"
    local ss__dd="${2:-basedir}" ss__df="${3:-filespec}" ss__part ss__d ss__f
    local -a ss__parts
    array_split ss__parts "$ss__p" "/"
    for ss__part in "${ss__parts[@]}"; do
        if [[ "$ss__part" == *\** ]] || [[ "$ss__part" == *\?* ]] || [ -n "$ss__f" ]; then
            ss__f="${ss__f:+$ss__f/}$ss__part"
        else
            ss__d="${ss__d:+$ss__d/}$ss__part"
        fi
    done
    [ "${ss__p#/}" != "$ss__p" ] && ss__d="/$ss__d"
    _setv "$ss__dd" "$ss__d"
    _setv "$ss__df" "$ss__f"
}