From 845d25c2ffbb42302b18322aee2bee74f754ec31 Mon Sep 17 00:00:00 2001
From: Emmanuel Garette <egarette@cadoles.com>
Date: Sat, 6 Feb 2021 16:01:35 +0100
Subject: [PATCH] rst to md

---
 doc/{family.rst => family.md}     |  52 +++--
 doc/fill.md                       | 293 ++++++++++++++++++++++++++++
 doc/fill.rst                      | 310 ------------------------------
 doc/index.md                      |  12 ++
 doc/index.rst                     |   0
 doc/{mode.rst => mode.md}         |   0
 doc/{variable.rst => variable.md} |  87 ++++-----
 doc/variables.md                  |   9 +
 doc/variables.rst                 |   9 -
 9 files changed, 373 insertions(+), 399 deletions(-)
 rename doc/{family.rst => family.md} (68%)
 create mode 100644 doc/fill.md
 delete mode 100644 doc/fill.rst
 create mode 100644 doc/index.md
 delete mode 100644 doc/index.rst
 rename doc/{mode.rst => mode.md} (100%)
 rename doc/{variable.rst => variable.md} (73%)
 create mode 100644 doc/variables.md
 delete mode 100644 doc/variables.rst

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 :
 
-    <family name="my_family"/>
+```<family name="my_family"/>```
 
 Cette famille doit être placé dans une balise "variables" :
 
-    <variables>
-        <family name="my_family"/>
-    </variables>
+```<variables>
+    <family name="my_family"/>
+</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 :
 
-    <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 :
 
-    <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.
 
@@ -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 :
 
-   <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.
 
@@ -48,25 +43,24 @@ Par contre ces variables sont accessibles lorsqu'on va utiliser ces variables.
 
 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.
 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 :
 
-    <family name='my_family'>
-        <variable name='varname' multi="True">
-            <value>val1</value>
-            <value>val2</value>
-        </variable>
-    </family>
-    <family name='my_dyn_family\_' dynamic="varname description="Describe "">
-        <variable name='my_dyn_var\_'/>
-    </family>
+```<family name='my_family'>
+    <variable name='varname' multi="True">
+        <value>val1</value>
+        <value>val2</value>
+    </variable>
+</family>
+<family name='my_dyn_family\_' dynamic="varname description="Describe "">
+    <variable name='my_dyn_var\_'/>
+</family>```
 
 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" :
+
+```<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>```
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" :
-
-    <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>
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.
 
-    <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 :
 
@@ -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"/>
 
-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 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.
 
 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.
 
 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.
 
@@ -83,10 +76,9 @@ Par contre cette variable sont accessibles lorsqu'on va l'utiliser.
 
 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.
 
@@ -94,35 +86,32 @@ Désactiver une variable signifie qu'elle ne sera pas visible lorsqu'on modifie
 
 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 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 :
 
-    <variable name="my_variable">
-        <value>value</value>
-    </variable>
+```<variable name="my_variable">
+    <value>value</value>
+</variable>```
 
 Pour une variable multiple, il est possible de préciser plusieurs valeurs :
 
-    <variable name="my_variable" multi="True">
-        <value>value 1</value>
-        <value>value 2</value>
-    </variable>
+```<variable name="my_variable" multi="True">
+    <value>value 1</value>
+    <value>value 2</value>
+</variable>```
 
 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.
 
@@ -138,48 +127,44 @@ Créons notre variable :
 
 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 :
 
-    <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éé
 
-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 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é.
 
 Voici une variable a valeur automatiquement modifiée :
 
-    <variable name="my_variable" auto_save="True">
-        <value>my_value</value>
-    </variable>
+```<variable name="my_variable" auto_save="True">
+    <value>my_value</value>
+</variable>```
 
 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 :
 
-    <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.
 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 :
+
+```<?xml version='1.0' encoding='UTF-8'?>
+<rougail>
+    <variables/>
+</rougail>
+```
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 :
-
-    <?xml version='1.0' encoding='UTF-8'?>
-    <rougail>
-        <variables/>
-    </rougail>