304 lines
9.1 KiB
Bash
Executable File
304 lines
9.1 KiB
Bash
Executable File
#!/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_args()
|
|
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;;
|
|
legacy|l) stype=legacy;;
|
|
""|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_args() 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"
|
|
}
|
|
|
|
args=(--help '\''$exit_with display_help'\'')
|
|
parse_args "$@"; set -- "${args[@]}"
|
|
'
|
|
;;
|
|
legacy)
|
|
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
|