4.7 KiB

Raw Blame History

TODO

Améliorer rtoinst

ajouter le support de pffprofile pour deploydb

Refaire/repenser les fonctions evalX

dans chaque exemple, on affiche l'invocation de evalX suivi de l'équivalent en syntaxe standard

evala permet de traiter des tableaux
```
evala with array // add a b c
array=("${array[@]}" a b c)
```
les fonctions à utiliser pour le traitement sont configurées avec des variables spéciales. par exemple, on peut indiquer que la commande add ci-dessus est en réalité gérée par la fonction array_add et que c'est une commande de type modify qui prend en premier argument le nom du tableau:
```
__evala_add_func=array_add
__evala_add_type=m
__evala_add_arg=first
```
en fonction du type de fonction, les arguments supplémentaires supportés sont différents. par défaut, la fonction à utiliser est du même nom que la commande, est du type scalar, et prend comme argument @ Ainsi les deux commandes suivantes sont équivalentes:
```
evala with array // echo
echo "${array[@]}"
```
et assument les définitions suivantes:
```
__evala_echo_func=echo
__evala_echo_type=s
__evala_echo_arg=@
```

evalx permet d'utiliser toutes ces fonctions ensemble

evalx seq 5 //p grep -v 3 //a prepend prefix // append suffix //c echo
array=($(seq 5 | grep -v 3)); array=(prefix "${array[@]}"); array=("${array[@]}" suffix); echo "${array[@]}"

# à partir du mode evala, on peut exécuter directement les arguments du
# tableau comme une commande en terminant par //c
evalx -a with array // prepend echo //c
array=(echo "${array[@]}"); "${array[@]}"

evalx commence par défaut en mode evalc. il est possible avec les options -i, -s, -a, -c, -p, -m de forcer respectivement evali, evals, evala, evalc, evalp, evalm

Il faudra réfléchir à comment sortir du mode evalm pour utilisation avec evalx. ou alors on part du principe que evalm est toujours en fin de chaine.

Faire la fonction cmdx

cmdx permet de lancer une commande avec les arguments qui sont générés par evalx. cmdx commence par défaut en mode evalm. Par exemple, les deux commandes suivantes sont équivalentes:

cmdx etitle //"Copie de " basename "$src" //" vers " ppath "$dest"
etitle "Copie de $(basename "$src") vers $(ppath "$dest")"

Comme pour evalx, les options -i, -s, -a, -c, -p, -m permettent de forcer respectivement les modes evali, evals, evala, evalc, evalp, evalm. Par exemple les deux commandes suivantes sont équivalentes:

cmdx -c echo a // b
echo "$(b "$(a)")"

Faire la fonction checkx

checkx permet de tester le résultat d'une commande evalx. elle s'utilise de cette manière:

checkx cmds... OP VALUE

Les opérateurs sont de la forme:

is -n|notempty
is -z|empty
is ok
is ko
== value
!= value
etc.

checkx remplace testx avec une syntaxe plus naturelle. si aucun script n'utilise les fonctions testx, peut-être peut-on simplement supprimer les fonctions testx et renommer checkx en testx

checkx -p a // b == c
[ "$(evalp a // b)" == c ]

Les commande suivantes sont équivalentes deux à deux:

checkx cmd is -z
[ -z "$(evalx cmd)" ]

checkx cmd is ok
evalx cmd; [ $? -eq 0 ]

checkx cmd is ko
evalx cmd; [ $? -ne 0 ]

checkx cmd == value
[ "$(evalx cmd)" == value ]

Faire la fonction storex

storex permet de mettre le résultat d'une fonction evalx dans une variable ou de l'ajouter à un tableau. l'idée est d'avoir la même syntaxe que checkx. je ne suis pas encore tout à fait sûr que ce soit une bonne chose.

Les commande suivantes sont équivalentes deux à deux:

storex cmd to var
var="$(evalx cmd)"

storex cmd to var
setx var=cmd

storex -a cmd to array
array_add array "$(evalx cmd)"

storex -r cmd from array
array_del array "$(evalx cmd)"

syntaxes alternatives

storex cmd to var
addx cmd to array
removex cmd from array

alternatives

setx var=cmd
evalx cmd // array_add array
evalx cmd // array_del array

note: il ne semble pas nécessaire au vu de l'alternative d'implémenter storex, addx, removex.

par contre, il faut corriger un bug d'evalc: la dernière commande doit être exécutée telle quelle. en effet,

evalc a // b

devrait être équivalent à

b "$(a)"

mais en fait c'est plutôt

echo "$(b "$(a)")"

et ça pose problème, notamment si b initialise des variables, etc.

Fonctions diverses

retcode cmd: affiche le code de retour de cmd. équivalent à cmd; echo $?

-- coding: utf-8 mode: markdown -- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8:noeol:binary

4.7 KiB Raw Blame History