# 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

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:
~~~
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