Infra
/
rougail
9
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rst to md

This commit is contained in:
Emmanuel Garette 2021-02-06 16:01:35 +01:00
parent 66356d8ff0
commit 845d25c2ff
9 changed files with 373 additions and 399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
doc/family.rst → doc/family.md
View File

@ -1,34 +1,30 @@
Famille # Famille
=======
Une famille ## Une famille
-----------
Une famille est un conteneur de variables. Une famille est un conteneur de variables.
Pour décrire une famille il faut mettre au minimum un nom : Pour décrire une famille il faut mettre au minimum un nom :
<family name="my_family"/> ```<family name="my_family"/>```
Cette famille doit être placé dans une balise "variables" : Cette famille doit être placé dans une balise "variables" :
<variables> ```<variables>
<family name="my_family"/> <family name="my_family"/>
</variables> </variables>```
Description et aide sur la famille ## Description et aide sur la famille
----------------------------------
En plus d'un nom, il est possible de mettre une "description" à la famille. C'est une information "utilisateur" qui nous permettra d'avoir des informations complémentaires sur le contenu de cette famille : En plus d'un nom, il est possible de mettre une "description" à la famille. C'est une information "utilisateur" qui nous permettra d'avoir des informations complémentaires sur le contenu de cette famille :
<family name="my_family" description="This is a great family"/> ```<family name="my_family" description="This is a great family"/>```
En plus de la description, il est possible de préciser une aide complémentaire : En plus de la description, il est possible de préciser une aide complémentaire :
<family name="my_family" help="This is a great family"/> ```<family name="my_family" help="This is a great family"/>```
Mode de la famille ## Mode de la famille
------------------
Le mode par défaut d'une famille correspond au mode le plus petite des variables dans cette famille. Le mode par défaut d'une famille correspond au mode le plus petite des variables dans cette famille.
@ -36,10 +32,9 @@ Changer le mode d'une famille permet de définir le mode par défaut des variabl
Pour définir le mode : Pour définir le mode :
<family name="my_family" mode="expert"/> ```<family name="my_family" mode="expert"/>```
Cacher une famille # Cacher une famille
------------------
Il est possible de cacher une famille, ainsi toutes les variables inclusent dans cette famille. Il est possible de cacher une famille, ainsi toutes les variables inclusent dans cette famille.
@ -48,17 +43,16 @@ Par contre ces variables sont accessibles lorsqu'on va utiliser ces variables.
Pour cacher une famille : Pour cacher une famille :
<family name="my_family" hidden="True"/> ```<family name="my_family" hidden="True"/>```
Les familles crées dynamiquement ## Les familles crées dynamiquement
--------------------------------
Pour créer une famille crées dynamiquement, il faut créer une family fictive lié à une variable. Pour créer une famille crées dynamiquement, il faut créer une family fictive lié à une variable.
Le nom et la description de la famille et des variables qu'elle contient sera en réalité le prefix du nouveau nom/description. Le suffix viendra de la variable liée. Le nom et la description de la famille et des variables qu'elle contient sera en réalité le prefix du nouveau nom/description. Le suffix viendra de la variable liée.
Par exemple : Par exemple :
<family name='my_family'> ```<family name='my_family'>
<variable name='varname' multi="True"> <variable name='varname' multi="True">
<value>val1</value> <value>val1</value>
<value>val2</value> <value>val2</value>
@ -66,7 +60,7 @@ Par exemple :
</family> </family>
<family name='my_dyn_family\_' dynamic="varname description="Describe ""> <family name='my_dyn_family\_' dynamic="varname description="Describe "">
<variable name='my_dyn_var\_'/> <variable name='my_dyn_var\_'/>
</family> </family>```
Créera trois familles : Créera trois familles :

293
doc/fill.md Normal file
View File

@ -0,0 +1,293 @@
# Les variables calculées
Une variable calculée est une variable donc sa valeur est le résultat d'une fonction python.
## Variable avec une valeur par défaut calculée
Créons une variable dont la valeur est retournée par la fonction "return_no" :
```<variables>
<family name="family">
<variable name="my_calculated_variable"/>
</family>
</variables>
<constraints>
<fill name="return_no" target="my_calculated_variable"/>
</constraints>```
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.
Si l'utilisateur à définit une valeur par défaut à "my_calculated_variable" :
```<variable name="my_calculated_variable">
<value>yes</value>
</variable>```
Cette valeur par défaut sera complètement ignorée.
## 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 :
```<variable name="my_calculated_variable" hidden="True"/>```
Si une condition "hidden_if_in" est spécifié à la variable, la valeur sera modifiable par l'utilisateur si elle n'est pas cachée mais elle sera systèmatiquement calculée (même si elle a déjà était modifiée) si la variable est cachée.
## Variable avec valeur calculée obligatoire
Par défaut les variables calculées ne sont pas des varibles obligatoires.
Dans ce cas un calcul peut retourner None, mais surtout un utilisateur peut spécifier une valeur nulle à cette variable. Dans ce cas le calcul ne sera pas réalisé.
## Fonction avec une valeur fixe comme paramètre positionnel
Déclarons un calcul avec paramètre :
```<constraints>
<fill name="return_value" target="my_calculated_variable">
<param>no</param>
</fill>
</constraints>```
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 :
```<constraints>
<fill name="return_value" target="my_calculated_variable">
<param name="valeur">no</param>
</fill>
</constraints>```
Dans ce cas la fonction return_value sera exécuté avec le paramètre nommé "valeur" dont sa valeur sera "no".
## Paramètre avec un nombre
Déclarons un calcul avec paramètre avec un nombre :
```<constraints>
<fill name="return_value_with_number" target="my_calculated_variable">
<param type="number">1</param>
</fill>
</constraints>```
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 dont la valeur est issue d'une autre 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 :
```<variables>
<family name="family">
<variable name="my_calculated_variable"/>
<variable name="my_variable" type="number" description="My variable">
<value>1</value>
</variable>
</family>
</variables>
<constraints>
<fill name="return_value_with_number" target="my_calculated_variable">
<param type="variable">my_variable</param>
</fill>
</constraints>```
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 dont la valeur est issue d'une information de la configuration
Créons une variable et la contrainte :
```<variables>
<family name="family">
<variable name="my_calculated_variable" type="string" description="My calculated variable"/>
</family>
</variables>
<constraints>
<fill name="return_value" target="my_calculated_variable">
<param type="information">server_name</param>
</fill>
</constraints>```
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".
## 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" :
<variables>
<family name="family">
<variable name="my_calculated_variable"/>
</family>
</variables>
<constraints>
<fill name="return_value" target="my_calculated_variable">
<param type="variable" optional="True">unknow_variable</param>
</fill>
</constraints>
Dans ce cas la fonction "return_value" est exécuté sans paramètre.
## Paramètre avec variable potentiellement désactivée
FIXME :
<!ATTLIST param notraisepropertyerror (True|False) "False">
Il n'y a pas spécialement de test !
## Les variables suiveuses
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
## Les variables dynamiques
### Paramètre avec variable dynamique
Il est possible de faire un calcul avec comme paramètre une variable dynamique mais pour une suffix particulier :
```<variables>
<family name='family'>
<variable name='suffixes' type='string' description="Suffixes of dynamic family" multi="True">
<value>val1</value>
<value>val2</value>
</variable>
<variable name="my_calculated_variable" type="string" description="My calculated variable"/>
</family>
<family name='dyn' dynamic="suffixes">
<variable name='vardyn' type='string' description="Dynamic variable">
<value>val</value>
</variable>
</family>
</variables>
<constraints>
<fill name="return_value" target="my_calculated_variable">
<param type="variable">vardynval1</param>
</fill>
</constraints>```
Dans ce cas, valeur du paramètre de la fonction "return_value" sera la valeur de la variable "vardyn" avec le suffix "val1".
### Calcule d'une variable dynamique
Il est également possible de calculer une variable dynamique à partir d'une variable standard :
```<variables>
<family name='family'>
<variable name='suffixes' type='string' description="Suffixes of dynamic family" multi="True">
<value>val1</value>
<value>val2</value>
</variable>
<variable name="my_variable" type="string" description="My variable">
<value>val</value>
</variable>
</family>
<family name='dyn' dynamic="suffixes">
<variable name="my_calculated_variable_dyn_" type="string" description="My calculated variable"/>
<value>val</value>
</variable>
</family>
</variables>
<constraints>
<fill name="return_value" target="my_calculated_variable_dyn_">
<param type="variable">my_variable</param>
</fill>
</constraints>```
Dans ce cas, les variables dynamiques "my_calculated_variable_dyn_" seront calculés à partir de la valeur de la variable "my_variable".
Que cela soit pour la variable "my_calculated_variable_dyn_val1" et "my_calculated_variable_dyn_val2".
Par contre, il n'est pas possible de faire un calcul pour une seule des deux variables issues de la variable dynamique.
Si c'est ce que vous cherchez à faire, il faudra prévoir un traitement particulier dans votre fonction.
Dans ce cas, il faut explicitement demander la valeur du suffix dans la fonction :
```<constraints>
<fill name="return_value_suffix" target="my_calculated_variable_dyn_">
<param type="variable">my_variable</param>
<param type="suffix"/>
</fill>
</constraints>```
Et ainsi faire un traitement spécifique pour ce suffix :
```def return_value_suffix(value, suffix):
if suffix == 'val1':
return value```
## Redéfinition des calcules
Dans un premier dictionnaire déclarons notre variable et notre calcule :
```<variables>
<family name="family">
<variable name="my_calculated_variable"/>
</family>
</variables>
<constraints>
<fill name="return_no" target="my_calculated_variable"/>
</constraints>```
Dans un second dictionnaire il est possible de redéfinir le calcul :
```<variables>
<family name="family">
<variable name="my_calculated_variable" redefine="True"/>
</family>
</variables>
<constraints>
<fill name="return_yes" target="my_calculated_variable"/>
</constraints>```
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 :
```<variables>
<family name="family">
<variable name="my_calculated_variable"/>
</family>
</variables>
<constraints>
<fill name="return_no" target="my_calculated_variable"/>
</constraints>```
Dans un second dictionnaire supprimer ce calcul :
```<variables>
<family name="family">
<variable name="my_calculated_variable" redefine="True" remove_fill="True"/>
</family>
</variables>```

310
doc/fill.rst
View File

@ -1,310 +0,0 @@
Les variables calculées
=======================
Une variable calculée est une variable donc sa valeur est le résultat d'une fonction python.
Variable avec une valeur par défaut calculée
--------------------------------------------
Créons une variable dont la valeur est retournée par la fonction "return_no" :
<variables>
<family name="family">
<variable name="my_calculated_variable"/>
</family>
</variables>
<constraints>
<fill name="return_no" target="my_calculated_variable"/>
</constraints>
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.
Si l'utilisateur à définit une valeur par défaut à "my_calculated_variable" :
<variable name="my_calculated_variable">
<value>yes</value>
</variable>
Cette valeur par défaut sera complètement ignorée.
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 :
<variable name="my_calculated_variable" hidden="True"/>
Si une condition "hidden_if_in" est spécifié à la variable, la valeur sera modifiable par l'utilisateur si elle n'est pas cachée mais elle sera systèmatiquement calculée (même si elle a déjà était modifiée) si la variable est cachée.
Variable avec valeur calculée obligatoire
-----------------------------------------
Par défaut les variables calculées ne sont pas des varibles obligatoires.
Dans ce cas un calcul peut retourner None, mais surtout un utilisateur peut spécifier une valeur nulle à cette variable. Dans ce cas le calcul ne sera pas réalisé.
Fonction avec une valeur fixe comme paramètre positionnel
---------------------------------------------------------
Déclarons un calcul avec paramètre :
<constraints>
<fill name="return_value" target="my_calculated_variable">
<param>no</param>
</fill>
</constraints>
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 :
<constraints>
<fill name="return_value" target="my_calculated_variable">
<param name="valeur">no</param>
</fill>
</constraints>
Dans ce cas la fonction return_value sera exécuté avec le paramètre nommé "valeur" dont sa valeur sera "no".
Paramètre avec un nombre
------------------------
Déclarons un calcul avec paramètre avec un nombre :
<constraints>
<fill name="return_value_with_number" target="my_calculated_variable">
<param type="number">1</param>
</fill>
</constraints>
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 dont la valeur est issue d'une autre 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 :
<variables>
<family name="family">
<variable name="my_calculated_variable"/>
<variable name="my_variable" type="number" description="My variable">
<value>1</value>
</variable>
</family>
</variables>
<constraints>
<fill name="return_value_with_number" target="my_calculated_variable">
<param type="variable">my_variable</param>
</fill>
</constraints>
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 dont la valeur est issue d'une information de la configuration
------------------------------------------------------------------------
Créons une variable et la contrainte :
<variables>
<family name="family">
<variable name="my_calculated_variable" type="string" description="My calculated variable"/>
</family>
</variables>
<constraints>
<fill name="return_value" target="my_calculated_variable">
<param type="information">server_name</param>
</fill>
</constraints>
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".
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" :
<variables>
<family name="family">
<variable name="my_calculated_variable"/>
</family>
</variables>
<constraints>
<fill name="return_value" target="my_calculated_variable">
<param type="variable" optional="True">unknow_variable</param>
</fill>
</constraints>
Dans ce cas la fonction "return_value" est exécuté sans paramètre.
Paramètre avec variable potentiellement désactivée
--------------------------------------------------
FIXME :
<!ATTLIST param notraisepropertyerror (True|False) "False">
Il n'y a pas spécialement de test !
Les variables suiveuses
-----------------------
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
Les variables dynamiques
------------------------
Paramètre avec variable dynamique
'''''''''''''''''''''''''''''''''
Il est possible de faire un calcul avec comme paramètre une variable dynamique mais pour une suffix particulier :
<variables>
<family name='family'>
<variable name='suffixes' type='string' description="Suffixes of dynamic family" multi="True">
<value>val1</value>
<value>val2</value>
</variable>
<variable name="my_calculated_variable" type="string" description="My calculated variable"/>
</family>
<family name='dyn' dynamic="suffixes">
<variable name='vardyn' type='string' description="Dynamic variable">
<value>val</value>
</variable>
</family>
</variables>
<constraints>
<fill name="return_value" target="my_calculated_variable">
<param type="variable">vardynval1</param>
</fill>
</constraints>
Dans ce cas, valeur du paramètre de la fonction "return_value" sera la valeur de la variable "vardyn" avec le suffix "val1".
Calcule d'une variable dynamique
''''''''''''''''''''''''''''''''
Il est également possible de calculer une variable dynamique à partir d'une variable standard :
<variables>
<family name='family'>
<variable name='suffixes' type='string' description="Suffixes of dynamic family" multi="True">
<value>val1</value>
<value>val2</value>
</variable>
<variable name="my_variable" type="string" description="My variable">
<value>val</value>
</variable>
</family>
<family name='dyn' dynamic="suffixes">
<variable name="my_calculated_variable_dyn_" type="string" description="My calculated variable"/>
<value>val</value>
</variable>
</family>
</variables>
<constraints>
<fill name="return_value" target="my_calculated_variable_dyn_">
<param type="variable">my_variable</param>
</fill>
</constraints>
Dans ce cas, les variables dynamiques "my_calculated_variable_dyn_" seront calculés à partir de la valeur de la variable "my_variable".
Que cela soit pour la variable "my_calculated_variable_dyn_val1" et "my_calculated_variable_dyn_val2".
Par contre, il n'est pas possible de faire un calcul pour une seule des deux variables issues de la variable dynamique.
Si c'est ce que vous cherchez à faire, il faudra prévoir un traitement particulier dans votre fonction.
Dans ce cas, il faut explicitement demander la valeur du suffix dans la fonction :
<constraints>
<fill name="return_value_suffix" target="my_calculated_variable_dyn_">
<param type="variable">my_variable</param>
<param type="suffix"/>
</fill>
</constraints>
Et ainsi faire un traitement spécifique pour ce suffix :
def return_value_suffix(value, suffix):
if suffix == 'val1':
return value
Redéfinition des calcules
-------------------------
Dans un premier dictionnaire déclarons notre variable et notre calcule :
<variables>
<family name="family">
<variable name="my_calculated_variable"/>
</family>
</variables>
<constraints>
<fill name="return_no" target="my_calculated_variable"/>
</constraints>
Dans un second dictionnaire il est possible de redéfinir le calcul :
<variables>
<family name="family">
<variable name="my_calculated_variable" redefine="True"/>
</family>
</variables>
<constraints>
<fill name="return_yes" target="my_calculated_variable"/>
</constraints>
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 :
<variables>
<family name="family">
<variable name="my_calculated_variable"/>
</family>
</variables>
<constraints>
<fill name="return_no" target="my_calculated_variable"/>
</constraints>
Dans un second dictionnaire supprimer ce calcul :
<variables>
<family name="family">
<variable name="my_calculated_variable" redefine="True" remove_fill="True"/>
</family>
</variables>

12
doc/index.md Normal file
View File

@ -0,0 +1,12 @@
# Rougail
## Les variables
- [Le conteneur des variables](variables.md)
- [Les familles](family.md)
- [Les variables](variable.md)
- [Les modes](mode.md)
## Les contraintes
- [Les calcules automatiques](fill.md)

0
doc/index.rst
View File

0
doc/mode.rst → doc/mode.md
View File

79
doc/variable.rst → doc/variable.md
View File

@ -1,17 +1,14 @@
Variable # Variable
========
Un variable ## Un variable
-----------
Une variable est forcement dans une famille. Il faut donc déjà avoir créer une famille. Une variable est forcement dans une famille. Il faut donc déjà avoir créer une famille.
Une variable est déjà un nom. C'est à dire qu'on pourra utiliser plus tard la variable via ce nom. Une variable est déjà un nom. C'est à dire qu'on pourra utiliser plus tard la variable via ce nom.
<variable name="my_variable"/> ```<variable name="my_variable"/>```
Description et aide sur la variable ## Description et aide sur la variable
----------------------------------
En plus d'un nom, il est possible de mettre une "description" à la variable. C'est une information "utilisateur" qui nous permettra d'avoir des informations complémentaires sur le contenu de cette variable : En plus d'un nom, il est possible de mettre une "description" à la variable. C'est une information "utilisateur" qui nous permettra d'avoir des informations complémentaires sur le contenu de cette variable :
@ -21,8 +18,7 @@ En plus de la description, il est possible de préciser une aide complémentaire
<variable name="my_variable" help="This is a greate variable"/> <variable name="my_variable" help="This is a greate variable"/>
Le type de la variable ## Le type de la variable
----------------------
Une variable a un type. Ce type permet de définir les valeurs acceptées par cette variable : Une variable a un type. Ce type permet de définir les valeurs acceptées par cette variable :
@ -53,28 +49,25 @@ Une variable a un type. Ce type permet de définir les valeurs acceptées par ce
Pour définir le type d'une variable : Pour définir le type d'une variable :
<variable name="my_variable" type="number"/> ```<variable name="my_variable" type="number"/>```
Variable à valeur multiple ## Variable à valeur multiple
--------------------------
Par défaut une variable ne peut acceuillir qu'une seule valeur. Il peut être utile de pouvoir spécifier plusieurs valeurs à une même variable. Par défaut une variable ne peut acceuillir qu'une seule valeur. Il peut être utile de pouvoir spécifier plusieurs valeurs à une même variable.
Pour définir une variable à valeur multiple : Pour définir une variable à valeur multiple :
<variable name="my_variable" multi="True"/> ```<variable name="my_variable" multi="True"/>```
Mode de la variable ## Mode de la variable
-------------------
Le mode par défaut d'une variable correspond au mode de la famille. Le mode par défaut d'une variable correspond au mode de la famille.
Pour définir le mode : Pour définir le mode :
<variable name="my_variable" mode="expert"/> ```<variable name="my_variable" mode="expert"/>```
Cacher une variable ## Cacher une variable
-------------------
Il est possible de cacher une variable. Il est possible de cacher une variable.
@ -83,10 +76,9 @@ Par contre cette variable sont accessibles lorsqu'on va l'utiliser.
Pour cacher une variable : Pour cacher une variable :
<variable name="my_variable" hidden="True"/> ```<variable name="my_variable" hidden="True"/>```
Désactiver une variable ## Désactiver une variable
-----------------------
Il est possible de désactiver une variable. Il est possible de désactiver une variable.
@ -94,35 +86,32 @@ Désactiver une variable signifie qu'elle ne sera pas visible lorsqu'on modifie
Pour désactiver une variable : Pour désactiver une variable :
<variable name="my_variable" disabled="True"/> ```<variable name="my_variable" disabled="True"/>```
Variable obligatoire ## Variable obligatoire
--------------------
Variable dont une valeur est requise : Variable dont une valeur est requise :
<variable name="my_variable" mandatory="True"/> ```<variable name="my_variable" mandatory="True"/>```
Valeur par défaut d'une variable ## Valeur par défaut d'une variable
--------------------------------
Il est possible de fixer les valeurs par défaut d'une variable : Il est possible de fixer les valeurs par défaut d'une variable :
<variable name="my_variable"> ```<variable name="my_variable">
<value>value</value> <value>value</value>
</variable> </variable>```
Pour une variable multiple, il est possible de préciser plusieurs valeurs : Pour une variable multiple, il est possible de préciser plusieurs valeurs :
<variable name="my_variable" multi="True"> ```<variable name="my_variable" multi="True">
<value>value 1</value> <value>value 1</value>
<value>value 2</value> <value>value 2</value>
</variable> </variable>```
Une valeur par défaut peut également être `une valeur calculer <fill.rst>`. Une valeur par défaut peut également être `une valeur calculer <fill.rst>`.
Redéfinir une variable ## Redéfinir une variable
----------------------
Il est possible de définir une variable dans un dictionnaire et de changer son comportement dans une second dictionnaire. Il est possible de définir une variable dans un dictionnaire et de changer son comportement dans une second dictionnaire.
@ -138,48 +127,44 @@ Créons notre variable :
Et redéfinisons là : Et redéfinisons là :
<variable name="my_variable" redefine="True" description="New description"/> ```<variable name="my_variable" redefine="True" description="New description"/>```
Créer une variable inexistante ## Créer une variable inexistante
------------------------------
Il est parfois utile de créer une variable si elle n'existe pas dans un autre dictionnaire : Il est parfois utile de créer une variable si elle n'existe pas dans un autre dictionnaire :
<variable name="my_variable" exists="False"/> ```<variable name="my_variable" exists="False"/>```
Si cette variable existe dans un autre dictionnaire, elle ne sera pas modifier ni recréé Si cette variable existe dans un autre dictionnaire, elle ne sera pas modifier ni recréé
Redéfinir une variable si elle existe ## Redéfinir une variable si elle existe
-------------------------------------
Parfois on veut pouvoir redéfinir une variable mais seulement dans le cas où elle existe déjà : Parfois on veut pouvoir redéfinir une variable mais seulement dans le cas où elle existe déjà :
<variable name="my_variable" redefine="True" exists="True" hidden="True"/> ```<variable name="my_variable" redefine="True" exists="True" hidden="True"/>```
Variable à valeur automatiquement modifiée ## Variable à valeur automatiquement modifiée
------------------------------------------
Une variable avec valeur automatiquement modifiée est une variable dont la valeur sera considéré comme modifié quand le serveur sera déployé. Une variable avec valeur automatiquement modifiée est une variable dont la valeur sera considéré comme modifié quand le serveur sera déployé.
Voici une variable a valeur automatiquement modifiée : Voici une variable a valeur automatiquement modifiée :
<variable name="my_variable" auto_save="True"> ```<variable name="my_variable" auto_save="True">
<value>my_value</value> <value>my_value</value>
</variable> </variable>```
Dans ce cas la valeur est fixée à la valeur actuelle. Dans ce cas la valeur est fixée à la valeur actuelle.
Par exemple, si la valeur de cette variable est issue d'un calcul, la valeur ne sera plus recalculée. Par exemple, si la valeur de cette variable est issue d'un calcul, la valeur ne sera plus recalculée.
Ces variables sont généralement des variables obligatoires. En effet ces variable ne sont automatiquement modifiées que si elles sont une valeurs. Ces variables sont généralement des variables obligatoires. En effet ces variable ne sont automatiquement modifiées que si elles sont une valeurs.
Variable à valeur en lecture seule automatique ## Variable à valeur en lecture seule automatique
----------------------------------------------
Une variable avec valeur en lecture seule automatique est une variable dont la valeur ne sera plus modifiable par l'utilisateur quand le serveur sera déployé. Une variable avec valeur en lecture seule automatique est une variable dont la valeur ne sera plus modifiable par l'utilisateur quand le serveur sera déployé.
Voici un variable à valeur en lecture seule automatique : Voici un variable à valeur en lecture seule automatique :
<variable name="my_variable" auto_freeze="True"/> ```<variable name="my_variable" auto_freeze="True"/>```
Dans ce cas la valeur est fixée à la valeur actuelle et elle ne sera plus modifiable par l'utilisateur. Dans ce cas la valeur est fixée à la valeur actuelle et elle ne sera plus modifiable par l'utilisateur.
Par exemple, si la valeur de cette variable est issue d'un calcul, la valeur ne sera plus recalculée. Par exemple, si la valeur de cette variable est issue d'un calcul, la valeur ne sera plus recalculée.

9
doc/variables.md Normal file
View File

@ -0,0 +1,9 @@
# Le conteneur des variables Variables
La balise variable est le conteneur de l'ensemble des familles dans laquelle on pourra placer des variables :
```<?xml version='1.0' encoding='UTF-8'?>
<rougail>
<variables/>
</rougail>
```

9
doc/variables.rst
View File

@ -1,9 +0,0 @@
Variables
=========
La balise variable est le conteneur de l'ensemble des familles dans laquelle on pourra placer des variables :
<?xml version='1.0' encoding='UTF-8'?>
<rougail>
<variables/>
</rougail>