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
    -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 &&
source "$(dirname "$0")/../../ulib/ulib" &&
urequire DEFAULTS ||
exit 1

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 generate_shell() {
    local file="$1"
    local dir="$(dirname "$file")"
    local mode=sh

    check_overwrite "$1" || return

    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;;
    esac

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

        if [ -z "$type" ]; then
            if [ -d "$dir/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 ]; 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
Une vieille version de nutools est installée. Il faut charger /etc/ulib et
définir manuellement les paramètres à utiliser.
Voulez-vous générer un script avec cette configuration?" X &&
                type=manual
            fi
        fi
        if [ -z "$type" ] && 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 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 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
        fi
        if [ -z "$type" ]; then
            if [ -d "$dir/ulib" ]; then
                enote "Le type de script 'system-or-local' a été sélectionné automatiquement"
                type=system-or-local
            elif [ -f /etc/ulibauto ]; 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

        if [ "$type" == system-or-local ]; then
            echo >"$file" '#!/bin/bash
'"$modeline"'
source "$(dirname "$0")/ulib/auto" || exit 1
eval "$(genparse)"
'
        elif [ "$type" == default ]; then
            echo >"$file" '#!/bin/bash
'"$modeline"'
source /etc/ulibauto || exit 1
eval "$(genparse)"
'
        elif [ "$type" == manual ]; then
            echo >"$file" '#!/bin/bash
'"$modeline"'

function display_help() {
    uecho "$scriptname: 

USAGE
    $scriptname [options]

OPTIONS"
}

source /etc/ulib &&
urequire DEFAULTS ||
exit 1

parse_opts "${PRETTYOPTS[@]}" \
    --help '\''$exit_with display_help'\'' \
    @ args -- "$@" && set -- "${args[@]}" || die "$args"
'
        elif [ "$type" == vanilla ]; then
            echo >"$file" "#!/bin/bash
$modeline"
        fi
        chmod +x "$file"
        eend
    else
        estep "$(ppath "$file")"
        echo >"$file" "$modeline"
    fi
    [ -n "$2" ] && array_add "$2" "$file"
    return 0
}

template=
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

    if [ "$t" == shell ]; then
        generate_shell "$file" files2edit || r=$?
    else
        die "shell: template invalide: $t"
    fi
done

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

exit $r