From 0c0d1416d6f9228c3333409257c81e96fded11a2 Mon Sep 17 00:00:00 2001 From: Emmanuel Garette Date: Sat, 6 Feb 2021 17:36:43 +0100 Subject: [PATCH] reorganise --- doc/family/simple.md | 4 +- doc/fill/README.md | 7 ++ doc/fill/param.md | 186 +++++++++++++++++++++++++++++++++++++ doc/fill/redefine.md | 61 ++++++++++++ doc/fill/value.md | 104 +++++++++++++++++++++ doc/variable/README.md | 6 ++ doc/variable/simple.md | 204 +++++++++++++++++++++++++++++++++++++++++ doc/variables.md | 2 +- 8 files changed, 571 insertions(+), 3 deletions(-) create mode 100644 doc/fill/README.md create mode 100644 doc/fill/param.md create mode 100644 doc/fill/redefine.md create mode 100644 doc/fill/value.md create mode 100644 doc/variable/README.md create mode 100644 doc/variable/simple.md diff --git a/doc/family/simple.md b/doc/family/simple.md index 76acb0d3..cbc17fbc 100644 --- a/doc/family/simple.md +++ b/doc/family/simple.md @@ -1,6 +1,6 @@ # Une famille -Une famille est un conteneur de variables. +Une famille est un [conteneur de variables](variables.md). Pour décrire une famille il faut mettre au minimum un nom : @@ -8,7 +8,7 @@ Pour décrire une famille il faut mettre au minimum un nom : ``` -Cette famille doit être placé dans une balise "variables" : +Cette famille doit être placé dans une balise [variables](variables.md) : ``` diff --git a/doc/fill/README.md b/doc/fill/README.md new file mode 100644 index 00000000..62163905 --- /dev/null +++ b/doc/fill/README.md @@ -0,0 +1,7 @@ +# Les variables calculées + +Une variable calculée est une variable donc sa valeur est le résultat d'une fonction python. + + - [Valeur calculée de la variable](value.md) + - [Paramètre de la fonction](param.md) + - [Réfinition](redefine.md) diff --git a/doc/fill/param.md b/doc/fill/param.md new file mode 100644 index 00000000..79e9947e --- /dev/null +++ b/doc/fill/param.md @@ -0,0 +1,186 @@ +# Paramètre de la fonction + +## Paramètre positionnel + +Déclarons un calcul avec paramètre : + +``` + + + no + + +``` + +Créons la fonction correspondante : + +``` +def return_value(value): + return value +``` + +La variable aura donc "no" comme valeur puisque le paramètre aura la valeur fixe "no". + +## Paramètre nommée + +Déclarons une contrainte avec un paramètre nommée : + +``` + + + no + + +``` + +Dans ce cas la fonction return_value sera exécuté avec le paramètre nommé "valeur" dont sa valeur sera "no". + +## Paramètre de type texte + +Dans l'exemple précédent : + +``` + + + no + + +``` + +Le paramètre est de type texte (ou "string"). + +## Paramètre de type nombre + +Déclarons un calcul avec paramètre avec un nombre : + +``` + + + 1 + + +``` + +Créons la fonction correspondante : + +``` +def return_value_with_number(value): + if value == 1: + return 'no' + return 'yes' +``` + +La variable aura donc "no" comme valeur puisque le paramètre aura la valeur fixe "1". + +## Paramètre de type variable + +Créons deux variables avec une contrainte de type variable qui contient le nom de la variable dont sa valeur sera utilisé comme paramètre : + +``` + + + + + 1 + + + + + + my_variable + + +``` + +Si l'utilisateur laisse la valeur 1 à "my_variable", la valeur par défault de la variable "my_calculated_variable" sera "no". +Si la valeur de "my_variable" est différent de 1, la valeur par défaut de la variable "my_calculated_variable" sera "yes". + +### Paramètre avec variable potentiellement non existante + +Suivant le contexte une variable peut exister ou ne pas exister. + +Un paramètre de type "variable" peut être "optional" : + +``` + + + + + + + + unknow_variable + + +``` + +Dans ce cas la fonction "return_value" est exécuté sans paramètre. + +Si maintenant on créé un nouveau dictionnaire en créant cette variable, la fonction sera exécuté avec le paramètre. + +### Paramètre avec variable potentiellement désactivée + +FIXME : + +Il n'y a pas spécialement de test ! + +### Paramètre avec variable suiveuse + +[variable suiveuse](variable/leadership.md) + +FIXME : + +- tests/flattener_dicos/10leadership_append/00-base.xml +- tests/flattener_dicos/10leadership_auto/00-base.xml +- tests/flattener_dicos/10leadership_autoleader/00-base.xml +- tests/flattener_dicos/10leadership_autoleader_expert/00-base.xml + +### Paramètre avec variable dynamique + +Il est possible de faire un calcul avec comme paramètre [une variable d'une famille dynamique](family/auto.md) mais pour une suffix particulier : + +``` + + + + val1 + val2 + + + + + + val + + + + + + vardynval1 + + +``` + +Dans ce cas, valeur du paramètre de la fonction "return_value" sera la valeur de la variable "vardyn" avec le suffix "val1". + +## Paramètre de type information + +Le paramètre peut être la valeur est issue d'une information de la configuration. + +Créons une variable et la contrainte : + +``` + + + + + + + + server_name + + +``` + +Dans ce cas, l'information de la configuration "server_name" sera utilisé comme valeur de la variable "my_calculated_variable". +Si l'information n'existe pas, la paramètre aura la valeur "None". diff --git a/doc/fill/redefine.md b/doc/fill/redefine.md new file mode 100644 index 00000000..f29fd0e8 --- /dev/null +++ b/doc/fill/redefine.md @@ -0,0 +1,61 @@ +# Rédéfinition + +## Redéfinition des calcules + +Dans un premier dictionnaire déclarons notre variable et notre calcule : + +``` + + + + + + + + +``` + +Dans un second dictionnaire il est possible de redéfinir le calcul : + +``` + + + + + + + + +``` + +Dans ce cas, à aucun moment la fonction "return_no" ne sera exécuté. Seul la fonction "return_yes" le sera. + +## Redéfinition avec suppression d'un calcul + +Il se peut que dans un dictionnaire on décide de définir une valeur par défaut à une variable via un calcul. + +Dans un second dictionnaire il est possible de supprimer ce calcul. + +Dans un premier dictionnaire déclarons notre variable et notre calcule : + +``` + + + + + + + + +``` + +Dans un second dictionnaire supprimer ce calcul : + +``` + + + + + +``` + diff --git a/doc/fill/value.md b/doc/fill/value.md new file mode 100644 index 00000000..8d33a681 --- /dev/null +++ b/doc/fill/value.md @@ -0,0 +1,104 @@ +# Valeur calculée de la variable + +## Variable avec une valeur par défaut calculée + +Créons une variable dont la valeur est retournée par la fonction "return_no" : + +``` + + + + + + + + +``` + +Puis créons la fonction "return_no" : + +``` +def return_no(): + return 'no' +``` + +Dans ce cas, la valeur par défaut est la valeur retournée par la fonction (ici "no"), elle sera calculée tant que l'utilisateur n'a pas de spécifié une valeur à cette variable. + +Attention, si une valeur par défaut est définit dans la variable "my_calculated_variable" : + +``` + + yes + +``` + +Cette valeur par défaut sera complètement ignorée. C'est le calcul qui en définira la valeur. + +## Variable avec une valeur calculée + +En ajoutant le paramètre "hidden" à "True" dans la variable précédente, l'utilisateur n'aura plus la possibilité de modifié la valeur. La valeur de la variable sera donc systématiquement calculée : + +``` +