diff --git a/doc/family.rst b/doc/family.md
similarity index 68%
rename from doc/family.rst
rename to doc/family.md
index f3c9ef41..4db8073a 100644
--- a/doc/family.rst
+++ b/doc/family.md
@@ -1,34 +1,30 @@
-Famille
-=======
+# Famille
-Une famille
------------
+## Une famille
Une famille est un conteneur de variables.
Pour décrire une famille il faut mettre au minimum un nom :
-
+``````
Cette famille doit être placé dans une balise "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 de la description, il est possible de préciser une aide complémentaire :
-
+``````
-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.
@@ -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 :
-
+``````
-Cacher une famille
-------------------
+# Cacher une famille
Il est possible de cacher une famille, ainsi toutes les variables inclusent dans cette famille.
@@ -48,25 +43,24 @@ Par contre ces variables sont accessibles lorsqu'on va utiliser ces variables.
Pour cacher une famille :
-
+``````
-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.
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 :
-
-
- val1
- val2
-
-
-
-
-
+```
+
+ val1
+ val2
+
+
+
+
+```
Créera trois familles :
diff --git a/doc/fill.md b/doc/fill.md
new file mode 100644
index 00000000..47b1b4ce
--- /dev/null
+++ b/doc/fill.md
@@ -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" :
+
+```
+
+
+
+
+
+
+```
+
+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" :
+
+```
+ yes
+```
+
+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 :
+
+``````
+
+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 :
+
+```
+
+ 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 avec un 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 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 :
+
+```
+
+
+
+ 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 dont 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".
+
+## 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.
+
+## Paramètre avec variable potentiellement désactivée
+
+FIXME :
+
+
+
+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 :
+
+```
+
+
+ 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".
+
+### Calcule d'une variable dynamique
+
+Il est également possible de calculer une variable dynamique à partir d'une variable standard :
+
+```
+
+
+ val1
+ val2
+
+
+ val
+
+
+
+
+ val
+
+
+
+
+
+ my_variable
+
+```
+
+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 :
+
+```
+
+ my_variable
+
+
+```
+
+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 :
+
+```
+
+
+
+
+
+
+```
+
+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.rst b/doc/fill.rst
deleted file mode 100644
index 9e693b60..00000000
--- a/doc/fill.rst
+++ /dev/null
@@ -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" :
-
-
-
-
-
-
-
-
-
-
-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" :
-
-
- yes
-
-
-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 :
-
-
-
-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 :
-
-
-
- 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 avec un 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 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 :
-
-
-
-
-
- 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 dont 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".
-
-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.
-
-Paramètre avec variable potentiellement désactivée
---------------------------------------------------
-
-FIXME :
-
-
-
-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 :
-
-
-
-
- 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".
-
-Calcule d'une variable dynamique
-''''''''''''''''''''''''''''''''
-
-Il est également possible de calculer une variable dynamique à partir d'une variable standard :
-
-
-
-
- val1
- val2
-
-
- val
-
-
-
-
- val
-
-
-
-
-
- my_variable
-
-
-
-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 :
-
-
-
- my_variable
-
-
-
-
-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 :
-
-
-
-
-
-
-
-
-
-
-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/index.md b/doc/index.md
new file mode 100644
index 00000000..ce63dfae
--- /dev/null
+++ b/doc/index.md
@@ -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)
diff --git a/doc/index.rst b/doc/index.rst
deleted file mode 100644
index e69de29b..00000000
diff --git a/doc/mode.rst b/doc/mode.md
similarity index 100%
rename from doc/mode.rst
rename to doc/mode.md
diff --git a/doc/variable.rst b/doc/variable.md
similarity index 73%
rename from doc/variable.rst
rename to doc/variable.md
index 66d86256..2cf1d767 100644
--- a/doc/variable.rst
+++ b/doc/variable.md
@@ -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 déjà un nom. C'est à dire qu'on pourra utiliser plus tard la variable via ce nom.
-
+``````
-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 :
@@ -21,8 +18,7 @@ En plus de la description, il est possible de préciser une aide complémentaire
-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 :
@@ -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 :
-
+``````
-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.
Pour définir une variable à valeur multiple :
-
+``````
-Mode de la variable
--------------------
+## Mode de la variable
Le mode par défaut d'une variable correspond au mode de la famille.
Pour définir le mode :
-
+``````
-Cacher une variable
--------------------
+## 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 :
-
+``````
-Désactiver une variable
------------------------
+## 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 :
-
+``````
-Variable obligatoire
---------------------
+## Variable obligatoire
Variable dont une valeur est requise :
-
+``````
-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 :
-
- value
-
+```
+ value
+```
Pour une variable multiple, il est possible de préciser plusieurs valeurs :
-
- value 1
- value 2
-
+```
+ value 1
+ value 2
+```
Une valeur par défaut peut également être `une valeur calculer `.
-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.
@@ -138,48 +127,44 @@ Créons notre variable :
Et redéfinisons là :
-
+``````
-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 :
-
+``````
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à :
-
+``````
-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é.
Voici une variable a valeur automatiquement modifiée :
-
- my_value
-
+```
+ my_value
+```
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.
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é.
Voici un variable à valeur en lecture seule automatique :
-
+``````
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.
diff --git a/doc/variables.md b/doc/variables.md
new file mode 100644
index 00000000..9f0798f6
--- /dev/null
+++ b/doc/variables.md
@@ -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 :
+
+```
+
+
+
+```
diff --git a/doc/variables.rst b/doc/variables.rst
deleted file mode 100644
index 0b4e9933..00000000
--- a/doc/variables.rst
+++ /dev/null
@@ -1,9 +0,0 @@
-Variables
-=========
-
-La balise variable est le conteneur de l'ensemble des familles dans laquelle on pourra placer des variables :
-
-
-
-
-