nutools/lib/templates/shell

#!/bin/bash
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8

function display_help() {
    uecho "$scriptname: générer un fichier $NAME

USAGE
    $scriptname [options] <file>

OPTIONS
    -t TEMPLATE
        Indiquer le modèle de fichier à utiliser pour la génération. Les valeurs
        valides sont:
            ${TEMPLATES[*]}
    -T TYPE
        Pour un script exécutable, indiquer le type de script à générer:
            system-or-local, sl -- utilise ulib/auto et genparse()
            default, d -- utilise /etc/ulibauto et genparse()
            manual, m -- utilise /etc/ulib et parse_opts()
            vanilla, v -- script simple
            auto -- choisir system-or-local, default ou manual en fonction de
                la présence de [lib/]ulib et/ou de /etc/ulibauto
            autom -- choisir system-or-local ou manual en fonction de
                la présence de [lib/]ulib
    -e, --edit
    -g, --no-edit
        Editer (resp. ne pas éditer) le fichier après l'avoir généré.
        Par défaut, l'éditeur est lancé après la génération.
    -f, --overwrite
        Ecraser le fichier s'il existe déjà
    -E, --encoding ENCODING
        Spécifier l'encoding à utiliser pour la génération du fichier"
}

NAME=shell
TEMPLATES=(shell)
NAMES=()
EXTS=(sh)

if [ $# -eq 2 ]; then
    if [ "$1" == "--matches-template" ]; then
        for template in "${TEMPLATES[@]}"; do
            [ "$template" == "$2" ] && exit 0
        done
        exit 1
    elif [ "$1" == "--matches-name" ]; then
        for name in "${NAMES[@]}"; do
            [ "$name" == "$2" ] && exit 0
        done
        exit 1
    elif [ "$1" == "--matches-ext" ]; then
        for ext in "${EXTS[@]}"; do
            [ "$ext" == "$2" ] && exit 0
        done
        exit 1
    fi
fi

#source /etc/ulib || exit 1
source "$(dirname "$0")/../ulib/ulib" || exit 1
urequire DEFAULTS

set_defaults nutools

function check_overwrite() {
    if [ -e "$1" -a -z "$overwrite" ]; then
        eerror "$1: refus d'écraser un fichier déjà existant (utiliser -f)"
        return 1
    fi
    return 0
}

function __fixtypes() {
    if [[ "$type" == *+* ]]; then
        # ne modifier stype que si une valeur est spécifiée. sinon, garder la
        # valeur précédente
        stype="${type##*+}"
        type="${type%+*}"
    fi

    case "$type" in
    system-or-local|sol|sl|u) type=system-or-local;;
    default|def|d) type=default;;
    manual|man|m) type=manual;;
    vanilla|van|v) type=vanilla;;
    ""|auto|a) type=auto;;
    autom) type=autom;;
    *)
        ewarn "$type: type non reconnu. sélection de la valeur 'default'"
        type=default
        ;;
    esac
    case "$stype" in
    manual|m) stype=manual;;
    ""|auto|a) stype=auto;;
    *)
        ewarn "$stype: sous-type non reconnu. sélection de la valeur 'auto'"
        stype=auto
        ;;
    esac
}

function generate_shell() {
    local file="$1"
    local dir="$(dirname "$file")"
    local mode=sh

    check_overwrite "$1" || return

    local type="$type" stype
    __fixtypes

    local modeline="# -*- coding: $encoding ${mode:+mode: $mode }-*- vim:sw=4:sts=4:et:ai:si:sta:fenc=$encoding"
    if [ -n "$executable" ]; then
        # script exécutable
        etitle "$(ppath "$file")"

        if [[ "$type" == auto* ]]; then
            if [ -d "$dir/ulib" -o -d "$dir/lib/ulib"  ]; then
                ask_yesno "\
Le type de script 'system-or-local' a été sélectionné automatiquement
Une librairie ulib locale est présente. En chargeant ulib/auto, la librairie
système /etc/ulib sera utilisée si elle est disponible. Sinon, la librairie
locale ulib/ulib sera utilisée.
Voulez-vous générer un script avec cette configuration?" X &&
                type=system-or-local
            elif [ -f /etc/ulibauto -a "$type" == auto ]; then
                ask_yesno "\
Le type de script 'default' a été sélectionné automatiquement
En chargeant /etc/ulibauto, la librairie ulib système sera utilisée, et les
paramètres par défaut seront utilisés.
Voulez-vous générer un script avec cette configuration?" X &&
                type=default
            else
                ask_yesno "\
Le type de script 'manual' a été sélectionné automatiquement
En chargeant /etc/ulib, la librairie ulib système sera utilisée, mais il faut
définir manuellement les paramètres à utiliser.
Voulez-vous générer un script avec cette configuration?" X &&
                type=manual
            fi
        fi
        if [[ "$type" == auto* ]] && check_interaction -c; then
            enote "Plusieurs type de scripts peuvent être générés:
- Avec le type 'system-or-local', on assume qu'une librairie ulib locale est
  présente. Le fichier [lib/]ulib/auto est chargé, ce qui a pour conséquence que
  la librairie système /etc/ulib est utilisée si elle est disponible. Sinon, la
  librairie locale [lib/]ulib/ulib est utilisée.
- Avec le type 'default', le fichier /etc/ulibauto est chargé. Les paramètres
  par défaut sont utilisés: urequire DEFAULTS et genparse() pour l'analyse des
  arguments.
- Avec le type 'manual', le fichier /etc/ulib est chargé. Les paramètres par
  défaut sont utilisés manuellement: urequire DEFAULTS et parse_opts() pour
  l'analyse des arguments.
- Avec le type 'vanilla', un script simple est généré."
            local -a types
            types=(system-or-local default manual vanilla)
            simple_menu type types \
                -t "Choix du type de script" \
                -m "Veuillez choisir le type de script à générer" \
                -d manual
            __fixtypes
        fi
        if [[ "$type" == auto* ]]; then
            if [ -d "$dir/ulib" -o -d "$dir/lib/ulib" ]; then
                enote "Le type de script 'system-or-local' a été sélectionné automatiquement"
                type=system-or-local
            elif [ -f /etc/ulibauto -a "$type" == auto ]; then
                enote "Le type de script 'default' a été sélectionné automatiquement"
                type=default
            else
                enote "Le type de script 'manual' a été sélectionné automatiquement"
                type=manual
            fi
        fi

        # d'abord générer l'en-tête par rapport au type
        if [ "$type" == system-or-local ]; then
            local ulibdir
            if [ -d "$dir/ulib" ]; then
                ulibdir=ulib
            elif [ -d "$dir/lib/ulib" ]; then
                ulibdir=lib/ulib
            else
                ulibdir=ulib
            fi
            echo >"$file" '#!/bin/bash
'"$modeline"'
source "$(dirname "$0")/'"$ulibdir"'/auto" || exit 1'
        elif [ "$type" == default ]; then
            echo >"$file" '#!/bin/bash
'"$modeline"'
source /etc/ulibauto || exit 1'
        elif [ "$type" == manual ]; then
            echo >"$file" '#!/bin/bash
'"$modeline"'
source /etc/ulib || exit 1
urequire DEFAULTS'
        elif [ "$type" == vanilla ]; then
            echo >"$file" "#!/bin/bash
$modeline"
        fi

        # ensuite générer le code pour l'analyse des arguments en fonction du
        # sous-type
        if [ "$type" != vanilla ]; then
            case "$stype" in
            manual)
                echo >>"$file" '
function display_help() {
    uecho "$scriptname: 

USAGE
    $scriptname [options]

OPTIONS"
}

parse_opts "${PRETTYOPTS[@]}" \
    --help '\''$exit_with display_help'\'' \
    @ args -- "$@" && set -- "${args[@]}" || die "$args"
'
                ;;
            auto)
                echo >>"$file" '#HELP_DESC="$scriptname: "
#HELP_ARG_DESC=
eval "$(genparse)"
'                ;;
            esac
        fi

        # rendre le fichier exécutable
        chmod +x "$file"
        eend

    else
        # fichier shell non exécutable
        estep "$(ppath "$file")"
        echo >"$file" "$modeline"
    fi

    [ -n "$2" ] && array_add "$2" "$file"
    return 0
}

template=
type="$SHELL_TYPE"
edit=1
overwrite=
encoding=
executable=1
parse_opts "${PRETTYOPTS[@]}" \
    --help '$exit_with display_help' \
    -t:,--template: template= \
    -T:,--type: type= \
    -e,--edit edit=1 \
    -g,--no-edit edit= \
    -f,--overwrite overwrite=1 \
    -E:,--encoding: encoding= \
    -x,--executable executable=1 \
    -n,--no-executable executable= \
    @ args -- "$@" && set -- "${args[@]}" || die "$args"

[ -n "$encoding" ] || encoding=utf-8

files2edit=()
r=0
for file in "$@"; do
    t="$template"
    if [ -z "$t" ]; then
        dir="$(dirname "$file")"
        name="$(basename "$file")"
        # Si template n'est pas spécifié, le déterminer le cas échéant à partir
        # du nom de fichier. Rajouter ici le code approprié
    fi

    case "$t" in
    shell|sh) generate_shell "$file" files2edit || r=$?;;
    *) die "$NAME: template invalide: $t";;
    esac
done

if [ -n "$edit" -a "${#files2edit[*]}" -gt 0 ]; then
    "${EDITOR:-vi}" "${files2edit[@]}"
fi

exit $r