Merge pull request #1549 from FreshRSS/dev1.7.0

Version 1.7.0

35 files changed, 1323 insertions, 0 deletions

diff --git a/docs/fr/contributing.md b/docs/fr/contributing.md
new file mode 100644
index 000000000..c7ccb4d8a
--- /dev/null
+++ b/docs/fr/contributing.md
@@ -0,0 +1,20 @@
+## Contribuer au code
+
+Pour cela, vous vous trouvez au bon endroit pour commencer : la documentation est là pour vous mettre le pied à l'étrier afin de découvrir le code. Voici une sélection de pages qui vous aideront à démarrer :
+
+- [Les premiers pas](developers/01_First_steps.md)
+- [Comment l'on fonctionne sur GitHub](developers/02_Github.md)
+
+S'il vous manque des informations, n'hésitez pas à fouiller un peu la documentation ou venir nous poser directement vos questions sur [la mailing list des développeurs](https://freshrss.org/mailman/listinfo/dev).
+
+## Contribuer à la documentation
+
+Il ne vous aura pas échappé que la documentation est encore un peu vide… il y a énormément de choses à faire ! Si vous souhaitez aider à écrire quelques pages, prenez le temps de lire [les informations données sur Github](https://github.com/FreshRSS/documentation/blob/master/README.fr.md).
+
+Vous pouvez notamment regarder [les tickets ouverts avec le tag "Documentation"](https://github.com/FreshRSS/FreshRSS/issues?labels=Documentation&state=open). Il s'agit de la liste des choses assez spécifiques à ajouter à la documentation.
+
+## Contribuer au blog
+
+Vous souhaitez écrire un article à propos des technologies RSS/Atom/PubSubHubbub ou tout simplement nous donner un coup de main à la rédaction d'un billet ? Vous pouvez nous aider !
+
+Pour cela, il suffit de vous rendre sur le dépôt GitHub [FreshRSS/freshrss.org](https://github.com/FreshRSS/freshrss.org) et de nous proposer une « Pull Request ». Les articles de blog doivent se trouver dans le répertoire `./blog` et être écrits en Markdown.
diff --git a/docs/fr/developers/01_First_steps.md b/docs/fr/developers/01_First_steps.md
new file mode 100644
index 000000000..400523e23
--- /dev/null
+++ b/docs/fr/developers/01_First_steps.md
@@ -0,0 +1,202 @@
+# Configurer son environnement
+
+**TODO**
+
+## Docker
+
+L'image Docker contenant l'environnement de développement de FreshRSS est accessible via :
+
+`$ docker pull marienfressinaud/freshrss`
+
+Vous pouvez lire [le fichier README du dépôt dédié](https://github.com/FreshRSS/docker-freshrss).
+
+# Architecture du projet
+
+**TODO**
+
+# Style de codage
+
+Si vous désirez contribuer au code, il est important de respecter le style de codage suivant. Le code actuel ne le respecte pas entièrement mais il est de notre devoir à tous de le changer dès que l'occasion se présente.
+
+Aucune nouvelle contribution ne respectant pas ces règles ne sera acceptée tant que les corrections nécessaires ne sont pas appliquées.
+
+## Espaces, tabulations et autres caractères blancs
+
+### Indentation
+L'indentation du code doit être faite impérativement avec des tabulations.
+
+### Alignement
+
+Une fois l'indentation faite, il peut être nécessaire de faire un alignement pour simplifier la lecture. Dans ce cas, il faut utiliser les espaces.
+
+```php
+$resultat = une_fonction_avec_un_nom_long($param1, $param2,
+                                          $param3, $param4);
+```
+
+### Fin de ligne
+
+Le caractère de fin de ligne doit être un saut de ligne (LF) qui est le caractère de fin de ligne des systèmes *NIX. Ce caractère ne doit pas être précédé par des caractères blanc.
+
+Il est possible de vérifier la présence de caractères blancs en fin de ligne grâce à Git avec la commande suivante :
+
+```bash
+# commande à lancer avant l'ajout des fichiers dans l'index
+git diff --check
+# commande à lancer après l'ajout des fichiers dans l'index mais avant le commit
+git diff --check --cached
+```
+
+### Fin de fichier
+
+Chaque fichier doit se terminer par une ligne vide.
+
+### Le cas de la virgule, du point et du point-virgule
+
+Il n'y a pas d'espace avant ces caractères, il y en a un après.
+
+### Le cas des opérateurs
+
+Chaque opérateur est entouré d'espaces.
+
+```php
+if ($a == 10) {
+    // faire quelque chose
+}
+
+echo $a ? 1 : 0;
+```
+
+### Le cas des parenthèses
+
+Il n'y a pas d'espaces entre des parenthèses. Il n'y a pas d'espaces avant une parenthèse ouvrante sauf si elle est précédée d'un mot-clé. Il n'y a pas d'espaces après une parenthèse fermante sauf si elle est suivie d'une accolade ouvrante.
+
+```php
+if ($a == 10) {
+    // faire quelque chose
+}
+
+if ((int)$a == 10) {
+    // faire quelque chose
+}
+```
+
+### Le cas des fonctions chainées
+
+Ce cas se présente le plus souvent en Javascript. Quand on a des fonctions chainées, des fonctions anonymes ainsi que des fonctions de rappels, il est très facile de se perdre. Dans ce cas là, on ajoute une indentation supplémentaire pour toute l'instruction et on revient au même niveau pour une instruction de même niveau.
+
+```javascript
+// Première instruction
+shortcut.add(shortcuts.mark_read, function () {
+        //...
+    }, {
+        'disable_in_input': true
+    });
+// Deuxième instruction
+shortcut.add("shift+" + shortcuts.mark_read, function () {
+        //...
+    }, {
+        'disable_in_input': true
+    });
+```
+
+## Longueur des lignes
+
+Les lignes ne doivent pas dépasser 80 caractères. Il est cependant autorisé exceptionnellement de dépasser cette limite s'il n'est pas possible de la respecter mais en aucun cas, les lignes ne doivent dépasser les 100 caractères.
+
+Dans le cas des fonctions, les paramètres peuvent être déclarés sur plusieurs lignes.
+
+```php
+function ma_fonction($param_1, $param_2,
+                     $param_3, $param_4) {
+    // faire quelque chose
+}
+```
+
+## Nommage
+
+L'ensemble des éléments du code (fonctions, classes, méthodes et variables) doivent être nommés de manière à décrire leur usage de façon concise.
+
+### Fonctions et variables
+
+Les fonctions et les variables doivent suivre la convention "snake case".
+
+```php
+// une fontion
+function nom_de_la_fontion() {
+    // faire quelque chose
+}
+// une variable
+$nom_de_la_variable;
+```
+
+### Méthodes
+
+Les méthodes doivent suivre la convention "lower camel case".
+
+```php
+private function nomDeLaMethode() {
+    // faire quelque chose
+}
+```
+
+### Classes
+
+Les classes doivent suivre la convention "upper camel case".
+
+```php
+abstract class NomDeLaClasse {}
+```
+
+## Encodage
+
+Les fichiers doivent être encodés en UTF-8.
+
+## Compatibilité avec PHP 5.3
+
+Il ne faut pas demander l'indice d'un tableau qui est retourné par une fonction ou une méthode. Il faut passer par une variable intermédiaire.
+
+```php
+// code compatible avec PHP 5.3
+$ma_variable = fonction_qui_retourne_un_tableau();
+echo $ma_variable[0];
+// code incompatible avec PHP 5.3
+echo fonction_qui_retourne_un_tableau()[0];
+```
+
+Il ne faut pas utiliser la déclaration raccourcie des tableaux.
+
+```php
+// code compatible avec PHP 5.3
+$variable = array();
+// code incompatible avec PHP 5.3
+$variable = [];
+```
+
+## Divers
+
+### Opérateurs
+Les opérateurs doivent être en fin de ligne dans le cas de conditions sur plusieurs lignes.
+
+```php
+if ($a == 10 ||
+    $a == 20) {
+    // faire quelque chose
+}
+```
+
+### Fin des fichiers
+
+Si le fichier ne contient que du PHP, il ne doit pas comporter de balise fermante
+
+### Tableaux
+
+Lors de l'écriture de tableaux sur plusieurs lignes, tous les éléments doivent être suivis d'une virgule (même le dernier).
+
+```php
+$variable = array(
+    "valeur 1",
+    "valeur 2",
+    "valeur 3",
+);
+```
diff --git a/docs/fr/developers/02_Github.md b/docs/fr/developers/02_Github.md
new file mode 100644
index 000000000..3d4bf9639
--- /dev/null
+++ b/docs/fr/developers/02_Github.md
@@ -0,0 +1,77 @@
+# Remonter un problème ou une suggestion
+
+Malgré le soin apporté à FreshRSS, il se peut que des bugs apparaissent encore. Le projet est jeune et le développement dynamique, aussi celui-ci pourra être corrigé rapidement. Il se peut aussi que vous ayez en tête une fonctionnalité qui n'existe pas encore. Que celle-ci vous paraisse idiote, farfelue, inutile ou trop spécifique, il ne faut surtout pas hésiter à nous la proposer ! Très souvent des "idées en l'air" ont trouvé une oreille attentive. Ce sont les regards externes qui font le plus évoluer le projet.
+
+Si vous êtes convaincus qu'il faut vous faire entendre, voici la marche à suivre.
+
+## Sur GitHub
+
+GitHub est la plate-forme à privilégier pour vos demandes. En effet, cela nous permet de pouvoir discuter à plusieurs sur un problème ou une suggestion et de faire émerger, souvent, des idées nouvelles. Ne négligeons pas cet aspect "social" !
+
+ 1. [Rendez-vous sur le gestionnaire de tickets de bugs](https://github.com/FreshRSS/FreshRSS/issues)
+ 2. Commencez par rechercher si une demande similaire n'a pas déjà été faite. Si oui, n'hésitez pas à ajouter votre voix à la demande.
+ 3. Si votre demande est nouvelle, [ouvrez un nouveau ticket de bug](https://github.com/FreshRSS/FreshRSS/issues/new)
+ 4. Rédigez enfin votre demande. Si vous maitrisez l'anglais, c'est la langue à privilégier car cela permet d'ouvrir la discussion à un plus grand nombre de personnes. Sinon, ce n'est pas grave, continuez en français :)
+ 5. Merci de bien vouloir suivre les quelques conseils donnés plus bas pour faciliter la prise en compte de votre ticket.
+
+## De façon informelle
+
+Tout le monde n'aime pas ou n'utilise pas GitHub pour des raisons aussi diverses que légitimes. C'est pourquoi vous pouvez aussi nous contacter de façon plus informelle.
+
+* Sur [les listes de diffusion](http://freshrss.org/announce-of-the-mailing-lists.html)
+* À des évènements / rencontres autour du Logiciel Libre
+* Autour d'une bière dans un bar
+* Etc.
+
+## Conseils
+
+Voici quelques conseils pour bien présenter votre remontée de bug ou votre suggestion :
+
+
+* **Faites attention à l'orthographe.** même si ce n'est pas toujours facile, faites votre maximum ;)
+* **Donnez un titre explicite à votre demande**, quitte à ce qu'il soit un peu long. Cela nous aide non seulement à comprendre votre demande, mais aussi à retrouver votre ticket plus tard.
+* **Une demande = un ticket.** Vous pouvez avoir des tas d'idées mais vous avez peur de spammer le gestionnaire de bugs : ça ne fait rien. Il vaut mieux avoir un peu trop de tickets que trop de demandes dans un seul. On s'occupera de fermer et regrouper les demandes qui le peuvent.
+* Si vous remontez un bug, pensez à nous **fournir les logs de FreshRSS** (accessibles dans les dossier ''data/log/'' de FreshRSS) **et PHP** (l'emplacement peut varier selon les distributions, mais pensez à chercher dans ''/var/log/httpd'' ou ''/var/log/apache'').
+* Si vous ne trouvez pas les fichiers de logs, précisez-le dans votre ticket afin que nous sachions que vous avez déjà cherché.
+* Tous les bugs ne nécessitent pas les logs, mais si vous doutez, mieux vaut nous les fournir. Les logs sont importants et très utiles pour débugguer !
+* Il se peut que les logs puissent révéler des informations plus ou moins confidentielles, **faites attention à ne rien divulguer de sensible.**
+
+De plus, face à un bug, je ne peux que vous encourager à suivre le format de message suivant (tiré du [site de Max & Sam](http://sametmax.com/template-de-demande-daide-en-informatique/)) :
+
+----
+
+**Quel est mon objectif ?**
+
+Donnez le contexte général de ce que vous essayiez de faire.
+
+**Qu’est-ce que j’ai essayé de faire ?**
+
+Expliquez pas à pas ce que vous avez fait afin que nous puissions reproduire le bug.
+
+**Quels résultats ai-je obtenus ?**
+
+Le bug : ce que vous voyez qui n'aurez pas dû se passer. Ici vous pouvez fournir les logs.
+
+**Quel était le résultat attendu ?**
+
+Afin que nous comprenions bien où est le problème... au moins selon vous :p
+
+**Quelle est ma situation ?**
+
+Pensez à donner les informations suivantes si vous les connaissez :
+
+ 1. Quel navigateur ? Quelle version ?
+ 2. Quel serveur : Apache, Nginx ? Quelle version ?
+ 3. Quelle version de PHP ?
+ 4. MySQL ou SQLite ? Quelle version ?
+ 5. Quelle distribution sur le serveur ? Et… quelle version ?
+
+----
+
+# Système de branches
+
+**TODO**
+
+# Proposer un patch
+
+**TODO**
\ No newline at end of file
diff --git a/docs/fr/developers/03_Backend/01_Database_schema.md b/docs/fr/developers/03_Backend/01_Database_schema.md
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/docs/fr/developers/03_Backend/01_Database_schema.md
diff --git a/docs/fr/developers/03_Backend/02_Minz.md b/docs/fr/developers/03_Backend/02_Minz.md
new file mode 100644
index 000000000..7699f9390
--- /dev/null
+++ b/docs/fr/developers/03_Backend/02_Minz.md
@@ -0,0 +1,27 @@
+# Modèles
+
+**TODO**
+
+# Contrôleurs et actions
+
+**TODO**
+
+# Vues
+
+**TODO**
+
+# Routage
+
+**TODO**
+
+# Écriture des URL
+
+**TODO**
+
+# Internationalisation
+
+**TODO**
+
+# Comprendres les mécanismes internes
+
+**TODO**
diff --git a/docs/fr/developers/03_Backend/03_External_libraries.md b/docs/fr/developers/03_Backend/03_External_libraries.md
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/docs/fr/developers/03_Backend/03_External_libraries.md
diff --git a/docs/fr/developers/03_Backend/04_Changing_source_code.md b/docs/fr/developers/03_Backend/04_Changing_source_code.md
new file mode 100644
index 000000000..0282dd9d2
--- /dev/null
+++ b/docs/fr/developers/03_Backend/04_Changing_source_code.md
@@ -0,0 +1,15 @@
+# Accès à la base de données
+
+**TODO**
+
+# Écrire une action et sa vue associée
+
+**TODO**
+
+# Gestion de l'authentification
+
+**TODO**
+
+# Gestion des logs
+
+**TODO**
diff --git a/docs/fr/developers/03_Backend/05_Extensions.md b/docs/fr/developers/03_Backend/05_Extensions.md
new file mode 100644
index 000000000..0478d77b8
--- /dev/null
+++ b/docs/fr/developers/03_Backend/05_Extensions.md
@@ -0,0 +1,335 @@
+# Fiche technique 0001 — Écriture d'extensions pour FreshRSS
+
+## Présentation de FreshRSS
+
+FreshRSS est un agrégateur de flux RSS / Atom écrit en PHP depuis octobre 2012. Le site officiel est situé à l'adresse [freshrss.org](http://freshrss.org) et son dépot Git est hébergé par Github : [github.com/FreshRSS/FreshRSS](https://github.com/FreshRSS/FreshRSS).
+
+## Problème à résoudre
+
+FreshRSS est limité dans ses possibilités techniques par différents facteurs :
+
+- La disponibilité des développeurs principaux ;
+- La volonté d'intégrer certains changements ;
+- Le niveau de « hack » nécessaire pour intégrer des fonctionnalités à la marge.
+
+Si la première limitation peut, en théorie, être levée par la participation de nouveaux contributeurs au projet, elle est en réalité conditionnée par la volonté des contributeurs à s'intéresser au code source du projet en entier. Afin de lever les deux autres limitations quant à elles, il faudra la plupart du temps passer par un « à-coté » souvent synonyme de « fork ».
+
+Une autre solution consiste à passer par un système d'extensions. En permettant à des utilisateurs d'écrire leur propre extension sans avoir à s'intéresser au cœur même du logiciel de base, on permet :
+
+1. De réduire la quantité de code source à assimiler pour un nouveau contributeur ;
+2. De permettre d'intégrer des nouveautés de façon non-officielles ;
+3. De se passer des développeurs principaux pour d'éventuelles améliorations sans passer par la case « fork ».
+
+Note : il est tout à fait imaginable que les fonctionnalités d'une extension puissent par la suite être intégrées dans le code initial de FreshRSS de façon officielle. Cela permet de proposer un « proof of concept » assez facilement.
+
+
+## Comprendre les mécaniques de base (Minz et MVC)
+
+**TODO** : bouger dans 02_Minz.md
+
+Cette fiche technique devrait renvoyer vers la documentation officielle de FreshRSS et de Minz (le framework PHP sur lequel repose FreshRSS). Malheureusement cette documentation n'existe pas encore. Voici donc en quelques mots les principaux éléments à connaître. Il n'est pas nécessaire de lire l'ensemble des chapitres de cette section si vous n'avez pas à utiliser une fonctionnalité dans votre extension (si vous n'avez pas besoin de traduire votre extension, pas besoin d'en savoir plus sur le module `Minz_Translate` par exemple).
+
+### Architecture MVC
+
+Minz repose et impose une architecture MVC pour les projets l'utilisant. On distingue dans cette architecture trois composants principaux :
+
+- Le Modèle : c'est l'objet de base que l'on va manipuler. Dans FreshRSS, les catégories, les flux et les articles sont des modèles. La partie du code qui permet de les manipuler en base de données fait aussi partie du modèle mais est séparée du modèle de base : on parle de DAO (pour « Data Access Object »). Les modèles sont stockés dans un répertoire `Models`.
+- La Vue : c'est ce qui représente ce que verra l'utilisateur. La vue est donc simplement du code HTML que l'on mixe avec du PHP pour afficher les informations dynamiques. Les vues sont stockées dans un répertoire `views`.
+- Le Contrôleur : c'est ce qui permet de lier modèles et vues entre eux. Typiquement, un contrôleur va charger des modèles à partir de la base de données (une liste d'articles par exemple) pour les « passer » à une vue afin qu'elle les affiche. Les contrôleurs sont stockés dans un répertoire `Controllers`.
+
+### Le routage
+
+Afin de lier une URL à un contrôleur, on doit passer par une phase dite de « routage ». Dans FreshRSS, cela est particulièrement simple car il suffit d'indiquer le nom du contrôleur à charger dans l'URL à l'aide d'un paramètre `c`. Par exemple, l'adresse http://exemple.com?c=hello va exécuter le code contenu dans le contrôleur `hello`.
+
+Une notion qui n'a pas encore été évoquée est le système d'« actions ». Une action est exécutée *sur* un contrôleur. Concrètement, un contrôleur va être représenté par une classe et ses actions par des méthodes. Pour exécuter une action, il est nécessaire d'indiquer un paramètre `a` dans l'URL.
+
+Exemple de code :
+
+```php
+<?php
+
+class FreshRSS_hello_Controller extends Minz_ActionController {
+    public function indexAction() {
+        $this->view->a_variable = 'FooBar';
+    }
+
+    public function worldAction() {
+        $this->view->a_variable = 'Hello World!';
+    }
+}
+
+?>
+```
+
+Si l'on charge l'adresse http://exemple.com?c=hello&a=world, l'action `world` va donc être exécutée sur le contrôleur `hello`.
+
+Note : si `c` ou `a` n'est pas précisée, la valeur par défaut de chacune de ces variables est `index`. Ainsi l'adresse http://exemple.com?c=hello va exécuter l'action `index` du contrôleur `hello`.
+
+Plus loin, sera utilisée la convention `hello/world` pour évoquer un couple contrôleur/action.
+
+### Gestion des vues
+
+Chaque vue est associée à un contrôleur et à une action. La vue associée à `hello/world` va être stockée dans un fichier bien spécifique : `views/hello/world.phtml`. Cette convention est imposée par Minz.
+
+Comme expliqué plus haut, les vues sont du code HTML mixé à du PHP. Exemple de code :
+
+```html
+<p>
+    Phrase passée en paramètre : <?php echo $this->a_variable; ?>
+</p>
+```
+
+La variable `$this->a_variable` a été passée précédemment par le contrôleur (voir exemple précédent). La différence est que dans le contrôleur il est nécessaire de passer par `$this->view` et que dans la vue `$this` suffit.
+
+### Accéder aux paramètres GET / POST
+
+Il est souvent nécessaire de profiter des paramètres passés par GET ou par POST. Dans Minz, ces paramètres sont accessibles de façon indistincts à l'aide de la classe `Minz_Request`. Exemple de code :
+
+```php
+<?php
+
+$default_value = 'foo';
+$param = Minz_Request::param('bar', $default_value);
+
+// Affichera la valeur du paramètre `bar` (passé via GET ou POST)
+// ou "foo" si le paramètre n'existe pas.
+echo $param;
+
+// Force la valeur du paramètre `bar`
+Minz_Request::_param('bar', 'baz');
+
+// Affichera forcément "baz" puisque nous venons de forcer sa valeur.
+// Notez que le second paramètre (valeur par défaut) est facultatif.
+echo Minz_Request::param('bar');
+
+?>
+```
+
+La méthode `Minz_Request::isPost()` peut être utile pour n'exécuter un morceau de code que s'il s'agit d'une requête POST.
+
+Note : il est préférable de n'utiliser `Minz_Request` que dans les contrôleurs. Il est probable que vous rencontriez cette méthode dans les vues de FreshRSS, voire dans les modèles, mais sachez qu'il ne s'agit **pas** d'une bonne pratique.
+
+### Accéder aux paramètres de session
+
+L'accès aux paramètres de session est étrangement similaire aux paramètres GET / POST mais passe par la classe `Minz_Session` cette fois-ci ! Il n'y a pas d'exemple ici car vous pouvez reprendre le précédent en changeant tous les `Minz_Request` par des `Minz_Session`.
+
+### Gestion des URL
+
+Pour profiter pleinement du système de routage de Minz, il est fortement déconseillé d'écrire les URL en dur dans votre code. Par exemple, la vue suivante doit être évitée :
+
+```html
+<p>
+    Accéder à la page <a href="http://exemple.com?c=hello&amp;a=world">Hello world</a>!
+</p>
+```
+
+Si un jour il est décidé d'utiliser un système d'« url rewriting » pour avoir des adresses au format http://exemple.com/controller/action, toutes les adresses précédentes deviendraient ineffectives !
+
+Préférez donc l'utilisation de la classe `Minz_Url` et de sa méthode `display()`. `Minz_Url::display()` prend en paramètre un tableau de la forme suivante :
+
+```php
+<?php
+
+$url_array = array(
+    'c' => 'hello',
+    'a' => 'world',
+    'params' => array(
+        'foo' => 'bar',
+    )
+);
+
+// Affichera quelque chose comme .?c=hello&amp;a=world&amp;foo=bar
+echo Minz_Url::display($url_array);
+
+?>
+```
+
+Comme cela peut devenir un peu pénible à utiliser à la longue, surtout dans les vues, il est préférable d'utiliser le raccourci `_url()` :
+
+```php
+<?php
+
+// Affichera la même chose que précédemment
+echo _url('hello', 'world', 'foo', 'bar');
+
+?>
+```
+
+Note : en règle générale, la forme raccourcie (`_url()`) doit être utilisée dans les vues tandis que la forme longue (`Minz_Url::display()`) doit être utilisée dans les contrôleurs.
+
+### Redirections
+
+Il est souvent nécessaire de rediriger un utilisateur vers une autre page. Pour cela, la classe `Minz_Request` dispose d'une autre méthode utile : `forward()`. Cette méthode prend en argument le même format d'URL que celui vu juste avant.
+
+Exemple de code :
+
+```php
+<?php
+
+$url_array = array(
+    'c' => 'hello',
+    'a' => 'world'
+);
+
+// Indique à Minz de rediriger l'utilisateur vers la page hello/world.
+// Notez qu'il s'agit d'une redirection au sens Minz du terme, pas d'une redirection que le navigateur va avoir à gérer (code HTTP 301 ou 302)
+// Le code qui suit forward() va ainsi être exécuté !
+Minz_Request::forward($url_array);
+
+// Pour effectuer une redirection type 302, ajoutez "true".
+// Le code qui suivra ne sera alors jamais exécuté.
+Minz_Request::forward($url_array, true);
+
+?>
+```
+
+Il est très fréquent de vouloir effectuer une redirection tout en affichant un message à l'utilisateur pour lui indiquer comment s'est déroulée l'action effectuée juste avant (validation d'un formulaire par exemple). Un tel message est passé par une variable de session `notification` (note : nous parlerons plutôt de « feedback » désormais pour éviter la confusion avec une notification qui peut survenir à tout moment). Pour faciliter ce genre d'action très fréquente, il existe deux raccourcis qui effectuent tout deux une redirection type 302 en affectant un message de feedback :
+
+```php
+<?php
+
+$url_array = array(
+    'c' => 'hello',
+    'a' => 'world'
+);
+$feedback_good = 'Tout s\'est bien passé !';
+$feedback_bad = 'Oups, quelque chose n\'a pas marché.';
+
+Minz_Request::good($feedback_good, $url_array);
+
+// ou
+
+Minz_Request::bad($feedback_bad, $url_array);
+
+?>
+```
+
+### Gestion de la traduction
+
+Il est fréquent (et c'est un euphémisme) de vouloir afficher des phrases à l'utilisateur. Dans l'exemple précédent par exemple, nous affichions un feedback à l'utilisateur en fonction du résultat d'une validation de formulaire. Le problème est que FreshRSS possède des utilisateurs de différentes nationalités. Il est donc nécessaire de pouvoir gérer différentes langues pour ne pas rester cantonné à l'Anglais ou au Français.
+
+La solution consiste à utiliser la classe `Minz_Translate` qui permet de traduire dynamiquement FreshRSS (ou toute application basée sur Minz). Avant d'utiliser ce module, il est nécessaire de savoir où trouver les chaînes de caractères à traduire. Chaque langue possède son propre sous-répertoire dans un répertoire parent nommé `i18n`. Par exemple, les fichiers de langue en Français sont situés dans `i18n/fr/`. Il existe sept fichiers différents :
+
+- `admin.php` pour tout ce qui est relatif à l'administration de FreshRSS ;
+- `conf.php` pour l'aspect configuration ;
+- `feedback.php` contient les traductions des messages de feedback ;
+- `gen.php` stocke ce qui est global à FreshRSS (gen pour « general ») ;
+- `index.php` pour la page principale qui liste les flux et la page « À propos » ;
+- `install.php` contient les phrases relatives à l'installation de FreshRSS ;
+- `sub.php` pour l'aspect gestion des abonnements (sub pour « subscription »).
+
+Cette organisation permet de ne pas avoir un unique énorme fichier de traduction.
+
+Les fichiers de traduction sont assez simples : il s'agit seulement de retourner un tableau PHP contenant les traductions. Extrait du fichier `app/i18n/fr/gen.php` :
+
+```php
+<?php
+
+return array(
+    'action' => array(
+        'actualize' => 'Actualiser',
+        'back_to_rss_feeds' => '← Retour à vos flux RSS',
+        'cancel' => 'Annuler',
+        'create' => 'Créer',
+        'disable' => 'Désactiver',
+    ),
+    'freshrss' => array(
+        '_' => 'FreshRSS',
+        'about' => 'À propos de FreshRSS',
+    ),
+);
+
+?>
+```
+
+Pour accéder à ces traductions, `Minz_Translate` va nous aider à l'aide de sa méthode `Minz_Translate::t()`. Comme cela peut être un peu long à taper, il a été introduit un raccourci qui **doit** être utilisé en toutes circonstances : `_t()`. Exemple de code :
+
+```html
+<p>
+    <a href="<?php echo _url('index', 'index'); ?>">
+        <?php echo _t('gen.action.back_to_rss_feeds'); ?>
+    </a>
+</p>
+```
+
+La chaîne à passer à la fonction `_t()` consiste en une série d'identifiants séparés par des points. Le premier identifiant indique de quel fichier on veut extraire la traduction (dans notre cas présent, de `gen.php`), tandis que les suivantes indiquent des entrées de tableaux. Ainsi `action` est une entrée du tableau principal et `back_to_rss_feeds` est une entrée du tableau `action`. Cela permet d'organiser encore un peu plus nos fichiers de traduction.
+
+Il existe un petit cas particulier qui permet parfois de se simplifier la vie : le cas de l'identifiant `_`. Celui-ci doit nécessairement être présent en bout de chaîne et permet de donner une valeur à l'identifiant de niveau supérieur. C'est assez dur à expliquer mais très simple à comprendre. Dans l'exemple donné plus haut, un `_` est associé à la valeur `FreshRSS` : cela signifie qu'il n'y a pas besoin d'écrire `_t('gen.freshrss._')` mais `_t('gen.freshrss')` suffit.
+
+### Gestion de la configuration
+
+## Écrire une extension pour FreshRSS
+
+Nous y voilà ! Nous avons abordé les fonctionnalités les plus utiles de Minz et qui permettent de faire tourner FreshRSS correctement et il est plus que temps d'aborder les extensions en elles-même.
+
+Une extension permet donc d'ajouter des fonctionnalités facilement à FreshRSS sans avoir à toucher au cœur du projet directement.
+
+### Les fichiers et répertoires de base
+
+La première chose à noter est que **toutes** les extensions **doivent** se situer dans le répertoire `extensions`, à la base de l'arborescence de FreshRSS. Une extension est un répertoire contenant un ensemble de fichiers et sous-répertoires obligatoires ou facultatifs. La convention veut que l'on précède le nom du répertoire principal par un « x » pour indiquer qu'il ne s'agit pas d'une extension incluse par défaut dans FreshRSS.
+
+Le répertoire principal d'une extension doit comporter au moins deux fichiers **obligatoire** :
+
+- Un fichier `metadata.json` qui contient une description de l'extension. Ce fichier est écrit en JSON ;
+- Un fichier `extension.php` contenant le point d'entrée de l'extension.
+
+Il est possible aussi que vous ayez besoin de fichiers ou sous-répertoires additionnels selon vos besoins :
+
+- `configure.phtml` est le fichier contenant le formulaire permettant de paramétrer votre extension ;
+- Un répertoire `static/` contenant fichiers CSS et JavaScript dont vous aurez besoin pour votre extension. Notez que si vous devez écrire beaucoup de CSS il est peut-être plus intéressant d'écrire un thème complet (mais ce n'est pas le sujet de cette fiche technique) ;
+- Un répertoire `controllers` contenant des contrôleurs additionnels ;
+- Un répertoire `i18n` contenant des traductions supplémentaires ;
+- Des répertoires `layout` et `views` permettant de définir de nouvelles vues ou d'écraser les vues actuelles.
+
+De plus, il est de bon ton d'avoir un fichier `LICENSE` indiquant la licence sous laquelle est distribuée votre extension et un fichier `README` donnant une description détaillée de celle-ci.
+
+### Écrire le fichier metadata.json
+
+Le fichier `metadata.json` définit votre extension à travers un certain nombre d'éléments importants. Il doit contenir un tableau JSON valide contenant les entrées suivantes :
+
+- `name` : le nom de votre extension ;
+- `author` : votre nom, éventuellement votre adresse mail mais il n'y a pas de format spécifique à adopter ;
+- `description` : une description de votre extension ;
+- `version` : le numéro de version actuel de l'extension ;
+- `entrypoint` : indique le point d'entrée de votre extension. Il doit correspondre au nom de la classe contenue dans le fichier `extension.php` sans le suffixe `Extension` (donc si le point d'entrée est `HelloWorld`, votre classe s'appellera `HelloWorldExtension`) ;
+- `type` : définit le type de votre extension. Il existe deux types : `system` et `user`. Nous étudierons cette différence juste après.
+
+Seuls les champs `name` et `entrypoint` sont requis.
+
+### Choisir entre extension « system » ou « user »
+
+### Écrire le fichier extension.php
+
+Ce fichier est le point d'entrée de votre extension. Il doit contenir une classe bien spécifique pour fonctionner. Comme évoqué plus haut, le nom de la classe doit être votre `entrypoint` suffixé par `Extension` (`HelloWorldExtension` par exemple). De plus, cette classe doit héritée de la classe `Minz_Extension` pour bénéficier des méthodes propres aux extensions.
+
+Votre classe va bénéficier de quatre méthodes à redéfinir :
+
+- `install()` est appelée lorsqu'un utilisateur va cliquer sur le bouton pour activer votre extension. Elle permet par exemple de mettre à jour la base de données d'un utilisateur afin de la rendre compatible avec l'extension. Elle retourne `true` si tout s'est bien passé ou, dans le cas contraire, une chaîne de caractères expliquant le problème ;
+- `uninstall()` est appelée lorsqu'un utilisateur va cliquer sur le bouton pour désactiver votre extension. Ainsi, vous pourrez annuler les changements en base de données que vous avez potentiellement faits dans `install()`. Elle retourne `true` si tout s'est bien passé ou, dans le cas contraire, une chaîne de caractères expliquant le problème ;
+- `init()` est appelée à chaque chargement de page *si l'extension est activée*. Elle va donc initialiser le comportement de l'extension. C'est la méthode la plus importante ;
+- `handleConfigureAction()` est appelée lorsqu'un utilisateur charge le panneau de gestion de l'extension. Plus précisément, elle est appelée lorsque l'URL `?c=extension&a=configure&e=le-nom-de-votre-extension` est chargée. Vous devriez aussi écrire ici le comportement voulu lors de la validation du formulaire contenu dans votre fichier `configure.phtml`.
+
+De plus, vous disposerez d'un certain nombre de méthodes directement héritées de `Minz_Extension` que vous ne devriez pas redéfinir :
+
+- Les « getters » tout d'abord. La plupart sont suffisamment explicites pour ne pas les détailler : `getName()`, `getEntrypoint()`, `getPath()` (permet de récupérer le chemin vers votre extension), `getAuthor()`, `getDescription()`, `getVersion()`, `getType()` ;
+- `getFileUrl($filename, $type)` va vous retourner l'URL vers un fichier du répertoire `static`. Le premier paramètre est le nom du fichier (sans `static/`), le deuxième est le type de fichier à servir (`css` ou `js`) ;
+- `registerController($base_name)` va indiquer à Minz de prendre en compte le contrôleur donné dans le système de routage. Le contrôleur doit se situer dans votre répertoire `Controllers`, le nom du fichier doit être `<base_name>Controller.php` et le nom de la classe `FreshExtension_<base_name>_Controller`.
+
+TODO :
+
+- `registerViews()`
+- `registerTranslates()`
+- `registerHook($hook_name, $hook_function)`
+
+### Système de « hooks »
+
+TODO :
+
+- `entry_before_display` (`function($entry) -> Entry | null`)
+- `entry_before_insert` (`function($entry) -> Entry | null`)
+- `feed_before_insert` (`function($feed) -> Feed | null`)
+- `post_update` (`function(none) -> none`)
+
+### Écrire le fichier configure.phtml
+
+TODO
diff --git a/docs/fr/developers/04_Frontend/01_View_files.md b/docs/fr/developers/04_Frontend/01_View_files.md
new file mode 100644
index 000000000..45174bf58
--- /dev/null
+++ b/docs/fr/developers/04_Frontend/01_View_files.md
@@ -0,0 +1,15 @@
+# Les fichiers .phtml
+
+**TODO**
+
+# Écrire une URL
+
+**TODO**
+
+# Afficher une icône
+
+**TODO**
+
+# Internationalisation
+
+**TODO**
diff --git a/docs/fr/developers/04_Frontend/02_Design.md b/docs/fr/developers/04_Frontend/02_Design.md
new file mode 100644
index 000000000..d05a4c44c
--- /dev/null
+++ b/docs/fr/developers/04_Frontend/02_Design.md
@@ -0,0 +1,11 @@
+# Fichier modèle
+
+**TODO**
+
+# Écrire un nouveau thème
+
+**TODO**
+
+# Surcharger les icônes
+
+**TODO**
diff --git a/docs/fr/developers/05_Release_new_version.md b/docs/fr/developers/05_Release_new_version.md
new file mode 100644
index 000000000..731dc0c76
--- /dev/null
+++ b/docs/fr/developers/05_Release_new_version.md
@@ -0,0 +1,112 @@
+# Préparer la sortie
+
+Afin d'avoir le plus de retour possible avant une sortie, il est préférable de l'annoncer sur GitHub en créant un ticket dédié ([voir les exemples](https://github.com/FreshRSS/FreshRSS/search?utf8=%E2%9C%93&q=Call+for+testing&type=Issues)). Ceci est à faire **au moins une semaine à l'avance**.
+
+Il est aussi recommandé de faire l'annonce sur mailing@freshrss.org.
+
+# S'assurer de l'état de dev
+
+Avant de sortir une nouvelle version de FreshRSS, il faut vous assurer que le code est stable et ne présente pas de bugs majeurs. Idéalement, il faudrait que nos tests soient automatisés et exécutés avant toute publication.
+
+Il faut aussi **vous assurer que le fichier CHANGELOG est à jour** dans la branche de dev avec les mises à jour de la ou les version(s) à sortir.
+
+# Processus Git
+
+```bash
+$ git checkout master
+$ git pull
+$ git merge --ff dev
+$ vim constants.php
+# Mettre à jour le numéro de version x.y.z de FRESHRSS_VERSION
+$ git commit -a
+Version x.y.z
+$ git tag -a x.y.z
+Version x.y.z
+$ git push && git push --tags
+```
+
+# Mise à jour de update.freshrss.org
+
+Il est important de mettre à jour update.freshrss.org puisqu'il s'agit du service par défaut gérant les mises à jour automatiques de FreshRSS.
+
+Le dépot gérant le code se trouve sur GitHub : [FreshRSS/update.freshrss.org](https://github.com/FreshRSS/update.freshrss.org/).
+
+## Écriture du script de mise à jour
+
+Les scripts se trouvent dans le répertoire `./scripts/` et doivent être de la forme `update_to_x.y.z.php`. On trouve aussi dans ce répertoire `update_to_dev.php` destiné aux mises à jour de la branche de dev (ce script ne doit pas inclure de code spécifique à une version particulière !) et `update_util.php` contenant une liste de fonctions utiles à tous les scripts.
+
+Afin d'écrire un nouveau script, il est préférable de copier / coller celui de la dernière version ou de partir de `update_to_dev.php`. La première chose à faire est de définir l'URL à partir de laquelle sera téléchargée le package FreshRSS (`PACKAGE_URL`). L'URL est de la forme `https://codeload.github.com/FreshRSS/FreshRSS/zip/x.y.z`.
+
+Il existe ensuite 5 fonctions à remplir :
+
+- `apply_update()` qui se charge de sauvegarder le répertoire contenant les données, de vérifier sa structure, de télécharger le package FreshRSS, de le déployer et de tout nettoyer. Cette fonction est pré-remplie mais des ajustements peuvent être faits si besoin est (ex. réorganisation de la structure de `./data`). Elle retourne `true` si aucun problème n'est survenu ou une chaîne de caractères indiquant un soucis ;
+- `need_info_update()` retourne `true` si l'utilisateur doit intervenir durant la mise à jour ou `false` sinon ;
+- `ask_info_update()` affiche un formulaire à l'utilisateur si `need_info_update()` a retourné `true` ;
+- `save_info_update()` est chargée de sauvegarder les informations renseignées par l'utilisateur (issues du formulaire de `ask_info_update()`) ;
+- `do_post_update()` est exécutée à la fin de la mise à jour et prend en compte le code de la nouvelle version (ex. si la nouvelle version modifie l'objet `Minz_Configuration`, vous bénéficierez de ces améliorations).
+
+## Mise à jour du fichier de versions
+
+Lorsque le script a été écrit et versionné, il est nécessaire de mettre à jour le fichier `./versions.php` qui contient une table de correspondances indiquant quelles versions sont mises à jour vers quelles autres versions.
+
+Voici un exemple de fichier `versions.php` :
+
+```php
+<?php
+
+return array(
+	// STABLE
+	'0.8.0' => '1.0.0',
+	'0.8.1' => '1.0.0',
+	'1.0.0' => '1.0.1',  // doesn't exist (yet)
+	// DEV
+	'1.1.2-dev' => 'dev',
+	'1.1.3-dev' => 'dev',
+	'1.1.4-dev' => 'dev',
+);
+```
+
+Et voici comment fonctionne cette table :
+
+- à gauche se trouve la version N, à droite la version N+1 ;
+- les versions `x.y.z-dev` sont **toutes** mises à jour vers `dev` ;
+- les versions stables sont mises à jour vers des versions stables ;
+- il est possible de sauter plusieurs versions d'un coup à condition que les scripts de mise à jour le prennent en charge ;
+- il est conseillé d'indiquer la correspondance de la version courante vers sa potentielle future version en précisant que cette version n'existe pas encore. Tant que le script correspondant n'existera pas, rien ne se passera.
+
+Il est **très fortement** indiqué de garder ce fichier rangé selon les numéros de versions en séparant les versions stables et de dev.
+
+## Déploiement
+
+Avant de mettre à jour update.freshrss.org, il est préférable de tester avec dev.update.freshrss.org qui correspond à la pré-production. Mettez donc à jour dev.update.freshrss.org et changez l'URL `FRESHRSS_UPDATE_WEBSITE` de votre instance FreshRSS. Lancez la mise à jour et vérifiez que celle-ci se déroule correctement.
+
+Lorsque vous serez satisfait, mettez à jour update.freshrss.org avec le nouveau script et en testant de nouveau puis passez à la suite.
+
+# Mise à jour des services FreshRSS
+
+Deux services sont à mettre à jour immédiatement après la mise à jour de update.freshrss.org :
+
+- rss.freshrss.org ;
+- demo.freshrss.org (identifiants publics : `demo` / `demodemo`).
+
+# Annoncer publiquement la sortie
+
+Lorsque tout fonctionne, il est temps d'annoncer la sortie au monde entier !
+
+- sur GitHub en créant [une nouvelle release](https://github.com/FreshRSS/FreshRSS/releases/new) ;
+- sur le blog de freshrss.org au minimum pour les versions stables (écrire l'article sur [FreshRSS/freshrss.org](https://github.com/FreshRSS/freshrss.org)).
+- sur Twitter (compte [@FreshRSS](https://twitter.com/FreshRSS)) ;
+- et sur mailing@freshrss.org ;
+
+# Lancer la prochaine version de développement
+
+```bash
+$ git checkout dev
+$ vim constants.php
+# Mettre à jour le numéro de version de FRESHRSS_VERSION
+$ vim CHANGELOG.md
+# Préparer la section pour la prochaine version
+$ git add CHANGELOG.md && git commit && git push
+```
+
+Pensez aussi à mettre à jour update.freshrss.org pour qu'il prenne en compte la version de développement actuelle.
diff --git a/docs/fr/img/doc.edit.png b/docs/fr/img/doc.edit.png
new file mode 100644
index 000000000..bc850e514
--- /dev/null
+++ b/docs/fr/img/doc.edit.png
diff --git a/docs/fr/img/logo_freshrss.png b/docs/fr/img/logo_freshrss.png
new file mode 100644
index 000000000..763b19cb1
--- /dev/null
+++ b/docs/fr/img/logo_freshrss.png
diff --git a/docs/fr/img/users/anonymous_access.1.png b/docs/fr/img/users/anonymous_access.1.png
new file mode 100644
index 000000000..65f985705
--- /dev/null
+++ b/docs/fr/img/users/anonymous_access.1.png
diff --git a/docs/fr/img/users/feed.add.1.png b/docs/fr/img/users/feed.add.1.png
new file mode 100644
index 000000000..b6146857f
--- /dev/null
+++ b/docs/fr/img/users/feed.add.1.png
diff --git a/docs/fr/img/users/feed.filter.1.png b/docs/fr/img/users/feed.filter.1.png
new file mode 100644
index 000000000..519ae41bf
--- /dev/null
+++ b/docs/fr/img/users/feed.filter.1.png
diff --git a/docs/fr/img/users/feed.filter.2.png b/docs/fr/img/users/feed.filter.2.png
new file mode 100644
index 000000000..5e8dd2899
--- /dev/null
+++ b/docs/fr/img/users/feed.filter.2.png
diff --git a/docs/fr/img/users/refresh.1.png b/docs/fr/img/users/refresh.1.png
new file mode 100644
index 000000000..44b7cb156
--- /dev/null
+++ b/docs/fr/img/users/refresh.1.png
diff --git a/docs/fr/img/users/refresh.2.png b/docs/fr/img/users/refresh.2.png
new file mode 100644
index 000000000..78e577704
--- /dev/null
+++ b/docs/fr/img/users/refresh.2.png
diff --git a/docs/fr/img/users/refresh.3.png b/docs/fr/img/users/refresh.3.png
new file mode 100644
index 000000000..e80bfc29f
--- /dev/null
+++ b/docs/fr/img/users/refresh.3.png
diff --git a/docs/fr/img/users/refresh.4.png b/docs/fr/img/users/refresh.4.png
new file mode 100644
index 000000000..abbeb5cd4
--- /dev/null
+++ b/docs/fr/img/users/refresh.4.png
diff --git a/docs/fr/img/users/refresh.5.png b/docs/fr/img/users/refresh.5.png
new file mode 100644
index 000000000..13c885cb1
--- /dev/null
+++ b/docs/fr/img/users/refresh.5.png
diff --git a/docs/fr/img/users/refresh.6.png b/docs/fr/img/users/refresh.6.png
new file mode 100644
index 000000000..0d78e3976
--- /dev/null
+++ b/docs/fr/img/users/refresh.6.png
diff --git a/docs/fr/img/users/status.filter.0.7.png b/docs/fr/img/users/status.filter.0.7.png
new file mode 100644
index 000000000..4516b937f
--- /dev/null
+++ b/docs/fr/img/users/status.filter.0.7.png
diff --git a/docs/fr/img/users/status.filter.0.8.png b/docs/fr/img/users/status.filter.0.8.png
new file mode 100644
index 000000000..5a0b9a3a1
--- /dev/null
+++ b/docs/fr/img/users/status.filter.0.8.png
diff --git a/docs/fr/img/users/token.1.png b/docs/fr/img/users/token.1.png
new file mode 100644
index 000000000..9685e5b43
--- /dev/null
+++ b/docs/fr/img/users/token.1.png
diff --git a/docs/fr/index.md b/docs/fr/index.md
new file mode 100644
index 000000000..d43eaec4e
--- /dev/null
+++ b/docs/fr/index.md
@@ -0,0 +1,22 @@
+![Logo de FreshRSS](img/logo_freshrss.png)
+
+FreshRSS est un agrégateur et lecteur de flux RSS. Il permet de regrouper l'actualité de plusieurs sites différents dans un endroit unique pour que vous puissiez la lire sans devoir aller de site en site.
+
+FreshRSS a été conçu comme un agrégateur puissant et propose des tas de fonctionnalités :
+
+- Agrégation des flux RSS et Atom.
+- Utilisez les favoris pour marquer les articles qui vous ont plu ou que vous souhaitez lire plus tard.
+- Le système de filtrage et de recherche permettent de cibler exactement les articles que vous souhaitez lire.
+- Les statistiques permettent de savoir en un coup d'œil quels sont les sites qui publient le plus, ou à l'inverse, le moins.
+- Importation / exportation des flux au format OPML.
+- Multi-thèmes pour changer l'habillage de FreshRSS.
+- « *Responsive design* » : l'application s'adapte aux petits écrans pour emporter FreshRSS dans votre poche.
+- Multi-utilisateurs pour héberger plusieurs personnes sur une même installation.
+- API Google Reader pour pouvoir y brancher des applications Android.
+- Auto-hébergeable : le code source est libre (AGPL3) et vous pouvez donc l'héberger sur votre propre serveur.
+- Et bien d'autres !
+
+Cette documentation est partagée en deux parties :
+
+- La [documentation utilisateurs](users/02_First_steps.md) pour découvrir plus en profondeur les fonctionnalités de FreshRSS.
+- La [documentation développeurs](developers/01_First_steps.md) pour savoir comment contribuer et mieux comprendre le code source de FreshRSS.
diff --git a/docs/fr/users/01_Installation.md b/docs/fr/users/01_Installation.md
new file mode 100644
index 000000000..86daa636a
--- /dev/null
+++ b/docs/fr/users/01_Installation.md
@@ -0,0 +1,94 @@
+# Les pré-requis sur le serveur
+
+FreshRSS est un logiciel développé en PHP reposant sur le modèle client - serveur. C'est-à-dire qu'il vous faudra un serveur web pour en profiter. Ensuite, FreshRSS ne demande pas une configuration très fournie et peut donc, en théorie, tourner sur la plupart des serveurs mutualisés.
+
+Il est toutefois de votre responsabilité de vérifier que votre hébergement permettra de faire tourner FreshRSS avant de nous taper dessus. Dans le cas où les informations listées ci-dessous ne seraient pas à jour, vous pourrez.
+
+ | Logiciel         | Recommandé                                                                                                     | Fonctionne aussi avec          |
+ | --------         | -----------                                                                                                    | ---------------------          |
+ | Serveur web      | **Apache 2**                                                                                                   | Nginx                          |
+ | PHP              | **PHP 5.3.7+**                                                                                                 | PHP 5.2+                       |
+ | Modules PHP      | Requis : libxml, cURL, PDO_MySQL, PCRE et ctype \\ Requis (32 bits seulement) : GMP \\ Recommandé : JSON, Zlib, mbstring et iconv, ZipArchive |                                |
+ | Base de données  | **MySQL 5.0.3+**                                                                                               | SQLite 3.7.4+                  |
+ | Navigateur       | **Firefox**                                                                                                    | Chrome, Opera, Safari or IE 9+ |
+
+## Note importante
+
+FreshRSS **PEUT** fonctionner sur la version de PHP 5.3.3. En effet, nous utilisons des fonctions spécifiques pour la connexion par formulaire et notamment la bibliothèque ''password_compat''. Celle-ci est compatible avec PHP >= 5.3.7 ou certaines versions plus anciennes incluant un patch spécifique. Cela dépend de la distribution :
+
+*  CentOS et la Red Hat Enterprise Linux 6.5 sont supportés.
+*  En revanche, **Debian avec PHP 5.3.3 n'est pas supporté !** ([Plus d'informations](https://github.com/ircmaxell/password_compat#requirements))
+
+# Choisir la bonne version de FreshRSS
+
+FreshRSS possède trois versions différentes (nous parlons de branches) qui sortent à des fréquences plus ou moins rapides. Aussi prenez le temps de comprendre à quoi correspond chacune de ces versions.
+
+## La version stable
+
+[Téléchargement](https://github.com/FreshRSS/FreshRSS/archive/master.zip)
+
+Cette version sort lorsqu'on considère qu'on a répondu à nos objectifs en terme de nouvelles fonctionnalités. Deux versions peuvent ainsi sortir de façon très rapprochée si les développeurs travaillent bien. En pratique, comme nous nous fixons de nombreux objectifs et que nous travaillons sur notre temps libre, les versions sont souvent assez espacées (plusieurs mois). Son avantage est que le code est particulièrement stable et vous ne devriez pas faire face à de méchants bugs.
+
+## La version de développement
+
+[Téléchargement](https://github.com/FreshRSS/FreshRSS/archive/dev.zip)
+
+Comme son nom l'indique, il s'agit de la version sur laquelle les développeurs travaillent. **Elle est donc totalement instable !** Si vous souhaitez recevoir les améliorations au jour le jour, vous pouvez l'utiliser, mais attention à bien suivre les évolutions sur Github (via [le flux RSS de la branche](https://github.com/FreshRSS/FreshRSS/commits/dev.atom) par exemple). On raconte que les développeurs principaux l'utilisent quotidiennement sans avoir de soucis. Sans doute savent-ils ce qu'ils font…
+
+# Installation sur Apache
+
+**TODO**
+
+Cette partie n'a pas encore été écrite. Néanmoins, comme il s'agit d'une bête application PHP, cela ne pose généralement pas de soucis à installer :)
+
+# Installation sur Nginx
+
+Voici un fichier de configuration pour nginx. Il couvre la configuration pour http, https et php.
+
+_Vous pourrez trouver d'autres fichiers de configuration plus simples mais ces derniers ne seront peut-être pas compatibles avec l'API FreshRSS._
+
+```
+server {
+  listen 80; # http sur le port 80
+  listen 443 ssl; # https sur le port 443
+
+  # configuration https 
+  ssl on;
+  ssl_certificate      /etc/nginx/server.crt;
+  ssl_certificate_key  /etc/nginx/server.key;
+
+  # l'url ou les urls de votre serveur
+  server_name example.com rss.example.com;
+
+  # le répertoire où se trouve le dossier p de FreshRSS
+  root /srv/FreshRSS/p/;
+
+  index index.php index.html index.htm;
+
+  # les fichiers de log nginx
+  access_log /var/log/nginx/rss.access.log;
+  error_log /var/log/nginx/rss.error.log;
+
+  # gestion des fichiers php
+  # il est nécessaire d'utiliser cette expression régulière pour le bon fonctionnement de l'API 
+  location ~ ^.+?\.php(/.*)?$ {
+    fastcgi_pass unix:/var/run/php5-fpm.sock;
+    fastcgi_split_path_info ^(.+\.php)(/.*)$;
+    # Par défaut la variable PATH_INFO n'est pas définie sous PHP-FPM
+    # or l'API FreshRSS greader.php en a besoin. Si vous avez un "Bad Request", vérifiez bien cette dernière !
+    fastcgi_param PATH_INFO $fastcgi_path_info;
+    include fastcgi_params;
+    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+  }
+  
+  location / {
+    try_files $uri $uri/ index.php;
+  }
+}
+```
+
+Pour un tutoriel pas à pas, vous pouvez suivre [cet article dédié](http://www.pihomeserver.fr/2013/05/08/raspberry-pi-home-server-installer-un-agregateur-de-flux-rss-pour-remplacer-google-reader/).
+
+# Conseils de sécurité
+
+**TODO**
diff --git a/docs/fr/users/02_First_steps.md b/docs/fr/users/02_First_steps.md
new file mode 100644
index 000000000..589453f28
--- /dev/null
+++ b/docs/fr/users/02_First_steps.md
@@ -0,0 +1,25 @@
+Découvrir un nouveau logiciel n'est pas toujours facile. Si nous avons voulu FreshRSS le plus intuitif possible, vous aurez peut-être besoin d'un coup de main pour le maîtriser.
+
+Cette section se propose de vous aider dans la prise en main de l'outil. Il ne s'agit que de liens menant vers les autres pages de la documentation mais ordonnées dans un ordre spécifique aux nouveaux arrivants.
+
+[Après l'installation](01_Installation.md), la première chose à faire est d'ajouter un ou plusieurs sites à suivre. Pour cela plusieurs choix s'offrent à vous :
+
+ 1.  [Ajouter un flux manuellement](04_Subscriptions.md#ajouter-un-flux)
+ 2.  [Importer un fichier OPML ou JSON](04_Subscriptions.md#import-et-export)
+ 3.  [Utiliser le bookmark dédié](04_Subscriptions.md#utiliser-le-bookmark)
+
+Une fois que vous avez ajouté vos flux à FreshRSS, il est temps de les lire. Pour cela, trois modes de lecture s'offrent à vous :
+
+ 1.  [La vue normale](03_Main_view.md#la-vue-normale) qui permet de voir et de lire rapidement les nouveaux articles
+ 2.  [La vue globale](03_Main_view.md#la-vue-globale) est destinée à vous offrir un panorama de l'état de vos flux
+ 3.  [La vue lecture](03_Main_view.md#la-vue-lecture) est pensée pour vous offrir un meilleur confort de lecture
+
+Bien, vous maitrisez maintenant la vue que vous préférez ? Il est temps de vous offrir un peu plus de confort de lecture. FreshRSS est grandement configurable et c'est à vous de trouver la configuration qui vous conviendra le plus. Voici tout de même quelques pistes pour améliorer votre quotidien sur FreshRSS :
+
+* [Rangez vos flux dans des catégories](04_Subscriptions.md#organisation_des_flux)
+* [Configurez votre page d'accueil](05_Configuration.md#personnaliser-la-vue)
+* [Configurez vos options de lecture](05_Configuration.md#options-de-lecture)
+* [Mettez à jour vos flux](03_Main_view.md#rafraichir-les-flux)
+* [Filtrez les articles](03_Main_view.md#filtrer-les-articles) pour accéder rapidement à ceux que vous voulez lire en priorité
+* [Retrouvez un article](03_Main_view.md#rechercher-des-articles) qui a été publié il y a quelques jours ou mois
+* [Accédez à vos flux même sur mobile](06_Mobile_access.md)
diff --git a/docs/fr/users/03_Main_view.md b/docs/fr/users/03_Main_view.md
new file mode 100644
index 000000000..744141b7d
--- /dev/null
+++ b/docs/fr/users/03_Main_view.md
@@ -0,0 +1,183 @@
+# La vue normale
+
+**TODO**
+
+# La vue globale
+
+**TODO**
+
+# La vue lecture
+
+**TODO**
+
+# Rafraîchir les flux
+
+Pour profiter pleinement de FreshRSS, il faut qu’il récupère les nouveaux articles disponibles des flux auxquels vous avez souscrit. Pour cela, il existe plusieurs méthodes.
+
+## Mise à jour automatique
+
+C’est la méthode recommandée car il n’y a pas besoin d’y penser, elle se fait toute seule, à la fréquence que vous avez choisi.
+
+### Par le script actualize_script.php
+
+Cette méthode n’est possible que si vous avez accès aux tâches planifiées de la machine sur laquelle est installée votre instance de FreshRSS.
+
+Le script qui permet de mettre à jour les articles s’appelle *actualize_script.php* et se trouve dans le répertoire *app* de votre instance de FreshRSS. La syntaxe des tâches planifiées ne sera pas expliqué ici, cependant voici [une introduction rapide à crontab](http://www.adminschoice.com/crontab-quick-reference/) qui peut vous aider.
+
+Ci-dessous vous trouverez un exemple permettant la mise à jour des articles toutes les heures.
+
+```cron
+0 * * * * php /chemin/vers/FreshRSS/app/actualize_script.php > /tmp/FreshRSS.log 2>&1
+```
+
+
+### Cron en-ligne
+
+Il se peut que vous n’ayez pas accès aux tâches planifiées du serveur hébergeant votre instance de FreshRSS. Il reste une possibilité pour mettre les flux à jour automatiquement.
+
+Pour cela vous devez paramétrer une tâche cron qui devra charger régulièrement une url spécifique : https://votre.serveur.net/FreshRSS/p/i/?c=feed&a=actualize (à adapter selon votre installation). Différents cas de figure peuvent se présenter à vous désormais.
+
+##### Aucune authentification
+
+C’est le cas le plus simple, puisque votre instance est publique, vous n’avez rien de particulier à préciser :
+
+```cron
+0 * * * * curl 'https://votre.serveur.net/FreshRSS/p/i/?c=feed&a=actualize'
+```
+
+##### Authentification par formulaire ou Persona
+
+Dans ces cas-là, si vous avez autorisé la lecture anonyme des articles, vous pouvez aussi permettre à n’importe qui de rafraîchir vos flux (« Autoriser le rafraîchissement anonyme des flux »).
+
+![Configuration de l’accès anonymes](../img/users/anonymous_access.1.png)
+
+L’url précédente devient donc accessible à n’importe qui et vous pouvez utiliser la tâche cron de la partie précédente.
+
+Vous pouvez aussi configurer un jeton d’authentification pour accorder un droit spécial sur votre serveur.
+
+![Configuration du token](../img/users/token.1.png)
+
+La tâche cron à utiliser sera de la forme suivante :
+
+```cron
+0 * * * * curl 'https://votre.serveur.net/FreshRSS/p/i/?c=feed&a=actualize&token=mon-token'
+```
+
+
+##### Authentification HTTP
+
+Dans ce cas-là, le token et les permissions “anonymes” sont inutilisables et il vous sera nécessaire d’indiquer vos identifiants dans la tâche cron. **Notez que cette solution est grandement déconseillée puisqu’elle implique que vos identifiants seront visibles en clair !**
+
+```cron
+0 * * * * curl -u alice:password123 'https://votre.serveur.net/FreshRSS/p/i/?c=feed&a=actualize'
+```
+
+## Mise à jour manuelle
+
+Si vous ne pouvez pas ou ne voulez pas utiliser la méthode automatique, vous pouvez le faire de façon manuelle. Il existe deux méthodes qui permettent de mettre à jour tout ou partie des flux.
+
+### Mise à jour complète
+
+Cette mise à jour se fait pour l’ensemble des flux de l’instance. Pour initier cette mise à jour, il suffit de cliquer sur le lien de mise à jour disponible dans le menu de navigation.
+
+![Menu de navigation](../img/users/refresh.1.png)
+
+Lorsque la mise à jour démarre, une barre de progression apparait et s’actualise au fur et à mesure de la récupération des articles.
+
+![Barre de progression](../img/users/refresh.5.png)
+
+### Mise à jour partielle
+
+Cette mise à jour se fait pour le flux sélectionné uniquement. Pour initier cette mise à jour, il suffit de cliquer sur le lien de mise à jour disponible dans le menu du flux.
+
+![Menu du flux](../img/users/refresh.2.png)
+
+# Filtrer les articles
+
+Avec le nombre croissant d’articles stockés par FreshRSS, il devient important d’avoir des filtres efficaces pour n’afficher qu’une partie des articles. Il existe plusieurs méthodes qui filtrent selon des critères différents. Ces méthodes peuvent être combinées dans la plus part des cas.
+
+##Par catégorie
+
+C’est la méthode la plus simple. Il suffit de cliquer sur le titre d’une catégorie dans le panneau latéral. Il existe deux catégories spéciales qui sont placées en haut dudit panneau :
+
+  * *Flux principal* qui affiche uniquement les articles des flux marqués comme visible dans cette catégorie
+  * *Favoris* qui affiche uniquement les articles, tous flux confondus, marqués comme favoris
+
+##Par flux
+
+Il existe plusieurs méthodes pour filtrer les articles par flux :
+
+  * en cliquant sur le titre du flux dans le panneau latéral
+  * en cliquant sur le titre du flux dans le détail de l’article
+  * en filtrant dans les options du flux dans le panneau latéral
+  * en filtrant dans la configuration du flux
+
+![Filtrer par flux](../img/users/feed.filter.1.png)
+
+##Par statut
+
+Chaque article possède deux attributs qui peuvent être combinés. Le premier attribut indique si l’article a été lu ou non. Le second attribut indique si l’article a été noté comme favori ou non.
+
+Dans la version 0.7.x, les filtres sur les attributs sont accessibles depuis la liste déroulante qui gère l’affichage des articles. Dans cette version, il n’est pas possible de combiner les filtres. Par exemple, on ne peut pas afficher les articles lus qui ont été notés comme favori.
+
+![Filtrer par attribut en version 0.7](../img/users/status.filter.0.7.png)
+
+À partir de la version 0.8, les filtres sur les attributs sont directement accessibles. Il est maintenant possible de les combiner. Comme il est possible de faire toutes les combinaisons, il y en a certaines qui retournent le même résultat. Par exemple, si les quatre filtres sont activés ou désactivés, le résultat sera le même.
+
+![Filtrer par attribut en version 0.8](../img/users/status.filter.0.8.png)
+
+Par défaut, le filtre n’affiche que les articles qui n’ont pas été lus.
+
+##Par contenu
+
+Il est possible de filtrer les articles par leur contenu en entrant une chaine de caractères dans le champ de recherche prévu à cet effet.
+
+##Grâce au champ de recherche
+
+Il est possible d’utiliser le champ de recherche pour raffiner les résultats :
+
+* par auteur : `author:nom` or `author:'nom composé'`
+* par titre : `intitle:mot` or `intitle:'mot composé'`
+* par URL: `inurl:mot` or `inurl:'mot composé'`
+* par tag: `#tag`
+* par texte libre : `mot` or `'mot composé'`
+* par date de découverte, en utilisant le [format d’intervalle de dates ISO 8601](https://fr.wikipedia.org/wiki/ISO_8601#Les_dur.C3.A9es_et_intervalles) : `date:<intervalle>`
+	* D’un jour, mois, ou année :
+		* `date:2014-03-30`
+		* `date:2014-03` or `date:201403`
+		* `date:2014`
+	* D’une heure précise d’un jour donné :
+		* `date:2014-05-30T13`
+		* `date:2014-05-30T13:30`
+	* Entre deux dates :
+		* `date:2014-02/2014-04`
+		* `date:2014-02--2014-04`
+		* `date:2014-02/04`
+		* `date:2014-02-03/05`
+		* `date:2014-02-03T22:00/22:15`
+		* `date:2014-02-03T22:00/15`
+	* Après une date donnée :
+		* `date:2014-03/`
+	* Avant une date donnée :
+		* `date:/2014-03`
+	* Pour une certaine durée après une date donnée :
+		* `date:2014-03/P1W`
+	* Pour une certaine durée avant une date donnée :
+		* `date:P1W/2014-05-25T23:59:59`
+	* Pour une certaine durée avant l’instant présent (la barre oblique est optionnelle) :
+		* `date:P1Y/` ou `date:P1Y` (depuis un an)
+		* `date:P2M/` (depuis deux mois)
+		* `date:P3W/` (depuis trois semaines)
+		* `date:P4D/` (depuis quatre jours)
+		* `date:PT5H/` (depuis cinq heures)
+		* `date:PT30M/` (depuis trente minutes)
+		* `date:PT90S/` (depuis 90 seconds)
+		* `date:P1DT1H/` (depuis un jour et une heure)
+* par date de publication, en utilisant le même format : `pubdate:<intervalle>`
+
+Attention à ne pas introduire d’espace entre l’opérateur et la valeur recherchée.
+
+Certains opérateurs peuvent être utilisé négativement, pour exclure des articles, avec la même syntaxe que ci-dessus, mais préfixé par `!` ou `-` :
+`-author:nom`, `-intitle:mot`, `-inurl:mot`, `-#tag`, `!mot`.
+
+Il est également possible de combiner les mots-clefs pour faire un filtrage encore plus précis, and et il est autorisé d’avoir plusieurs instances de : `author:`, `intitle:`, `inurl:`, `#`, et texte libre.
diff --git a/docs/fr/users/04_Subscriptions.md b/docs/fr/users/04_Subscriptions.md
new file mode 100644
index 000000000..ae4541c29
--- /dev/null
+++ b/docs/fr/users/04_Subscriptions.md
@@ -0,0 +1,15 @@
+# Ajouter un flux
+
+**TODO**
+
+# Import et export
+
+**TODO**
+
+# Utiliser le « bookmark »
+
+**TODO**
+
+# Organisation des flux
+
+**TODO**
diff --git a/docs/fr/users/05_Configuration.md b/docs/fr/users/05_Configuration.md
new file mode 100644
index 000000000..75deff462
--- /dev/null
+++ b/docs/fr/users/05_Configuration.md
@@ -0,0 +1,119 @@
+# Personnaliser la vue
+
+##Langue
+À l'heure actuelle, FreshRSS est disponible en français et en anglais. Après validation de ce choix, la totalité de l'interface sera affichée dans la langue choisie.
+
+Il y a des parties de FreshRSS qui ne sont pas traduites et qui n'ont pas vocation à l'être. Pour le moment, les logs visibles dans l'application ainsi que celle générées par le script de mise à jour automatique en font partie.
+
+##Thème
+Les goûts et les couleurs, ça ne se discute pas. C'est pourquoi FreshRSS propose six thèmes officiels :
+
+ * *Blue Lagoon* par **Mister aiR**
+ * *Dark* par **AD**
+ * *Flat design* par **Marien Fressinaud**
+ * *Origine* par **Marien Fressinaud**
+ * *Pafat* par **Plopoyop**
+ * *Screwdriver* par **Mister aiR**
+
+Si aucun de ceux proposés ne convient, il est toujours possible de créer son propre thème.
+
+Pour sélectionner un thème, il suffit de faire défiler les thèmes jusqu'à l'apparition du thème choisi. Après validation, le thème sera appliqué à l'interface.
+
+##Largeur du contenu
+Il y en a qui préfère des lignes de texte courtes, d'autres qui préfèrent maximiser l'espace disponible sur l'écran. Pour satisfaire le maximum de personne, il est possible de choisir la largeur du contenu affiché. Il y a quatre réglages disponibles :
+
+ * **Fine** qui affiche le contenu jusqu'à 550 pixels
+ * **Moyenne** qui affiche le contenu jusqu'à 800 pixels
+ * **Large** qui affiche le contenu jusqu'à 1000 pixels
+ * **Pas de limite** qui affiche le contenu sur 100% de la place disponible
+
+##Icônes d'article
+
+**TODO**
+
+##Temps d'affichage de la notification HTML5
+Après la mise à jour automatique des flux, FreshRSS utilise l'API de notification de HTML5 pour avertir de l'arrivée de nouveaux articles.
+
+Il est possible de régler la durée d'affichage de cette notification. Par défaut, la valeur est 0.
+
+# Options de lecture
+
+**TODO**
+
+# Archivage
+
+**TODO**
+
+# Partage
+
+**TODO**
+
+# Raccourcis
+
+**TODO**
+
+# Filtres
+
+**TODO**
+
+# Utilisateurs
+
+**TODO**
+
+## Méthodes d'authentification
+
+**Brouillon**
+
+### Authentification HTTP
+
+ 1.  Ne laisse rien de visible
+ 2.  Pour Apache, basé sur un fichier .htaccess
+    - Exemple de .htaccess pour un utilisateur "marie" à placer dans le répertoire de FreshRSS ou dans un répertoire parent :
+
+```
+AuthUserFile /home/marie/repertoire/.htpasswd
+AuthGroupFile /dev/null
+AuthName "Chez Marie"
+AuthType Basic
+Require user marie
+```
+
+Plus d'informations dans [la documentation d'Apache.](http://httpd.apache.org/docs/trunk/howto/auth.html#gettingitworking)
+
+
+# Gestion des flux
+
+## Informations
+
+**TODO**
+
+## Archivage
+
+**TODO**
+
+## Identification
+
+**TODO**
+
+## Avancé
+
+### Récupérer un flux tronqué
+
+La question revient régulièrement, je vais essayer de clarifier ici comment on peut récupérer un flux RSS tronqué avec FreshRSS. Sachez avant tout que la manière de s'y prendre n'est absolument pas "user friendly", mais elle fonctionne :)
+
+Sachez aussi que par cette manière vous générez beaucoup plus de trafic vers les sites d'origines et qu'ils peuvent vous bloquer par conséquent. Les performances de FreshRSS sont aussi moins bonnes car vous devez alors aller chercher le contenu des articles un par un. C'est donc une fonctionnalité à utiliser avec parcimonie !
+
+Ce que j'entends par "Chemin CSS des articles sur le site d’origine" correspond en fait au "chemin" constitué par les IDs et les classes (en html, correspond aux attributs id et class) pour récupérer uniquement la partie intéressante qui correspond à l'article. L'idéal est que ce chemin commence par un id (qui est unique pour la page)
+
+#### Exemple 1 : Rue89
+
+Pour trouver ce chemin, il faut se rendre à l'adresse d'un des articles tronqués (par exemple http://www.rue89.com/2013/10/15/prof-maths-jai-atteint-lextase-dihn-pedagogie-inversee-246635). Il faut alors chercher le "bloc" HTML correspondant au contenu de l'article (dans le code source !)
+
+On trouve ici que le bloc qui englobe uniquement le contenu de l'article est ```<div class="content clearfix">```. On ne va garder que la classe .content ici. Néanmoins, comme je le disais plus haut, il est préférable de commencer le chemin avec un id. Si on remonte au bloc parent, il s'agit du bloc ```<div id="article">``` et c'est parfait ! Le chemin sera donc ```#article .content```
+
+#### Liste de correspondances site -> chemin css
+
+*  Rue89 : ```#article .content```
+*  PCINpact : ```#actu_content```
+*  Lesnumériques : ```article#body div.text.clearfix```
+
diff --git a/docs/fr/users/06_Mobile_access.md b/docs/fr/users/06_Mobile_access.md
new file mode 100644
index 000000000..e1a23c8ba
--- /dev/null
+++ b/docs/fr/users/06_Mobile_access.md
@@ -0,0 +1 @@
+**TODO**
diff --git a/docs/fr/users/07_Frequently_Asked_Questions.md b/docs/fr/users/07_Frequently_Asked_Questions.md
new file mode 100644
index 000000000..9dc80b2e4
--- /dev/null
+++ b/docs/fr/users/07_Frequently_Asked_Questions.md
@@ -0,0 +1,35 @@
+Il est possible que nous n'ayons pas répondu à toutes vos questions dans les parties précédentes. La FAQ regroupe certaines interrogations qui n'ont pas trouvé leur réponse ailleurs.
+
+## C'est quoi ce /i à la fin de l'URL ?
+
+Bien entendu, le ```/i``` n'est pas là pour faire joli ! Il s'agit d'une question de performances et de praticité :
+
+* Cela permet de servir les icônes, images, styles, scripts sans cookie. Sans cela, ces fichiers seraient souvent re-téléchargés, en particulier lorsque Persona ou le formulaire de connexion sont utilisés. De plus, les requêtes vers ces ressources seraient plus lourdes.
+* La racine publique ```./p/``` peut être servie sans restriction d'accès HTTP (qui peut avantageusement être mise en place dans ```./p/i/```).
+* Cela permet d'éviter des problèmes pour des fichiers qui doivent être publics pour bien fonctionner, comme ```favicon.ico```, ```robots.txt```, etc.
+* Cela permet aussi d'avoir un logo FreshRSS plutôt qu'une page blanche pour accueillir l'utilisateur par exemple dans le cas de la restriction d'accès HTTP ou lors de l'attente du chargement plus lourd du reste de l'interface.
+
+## Pourquoi le ```robots.txt``` se trouve dans un sous-répertoire ?
+
+Afin d'améliorer la sécurité, FreshRSS est découpé en deux parties : une partie publique (le répertoire ```./p```) et une partie privée (tout le reste !). Le ```robots.txt``` se trouve donc dans le sous-répertoire ```./p```.
+
+Comme expliqué dans les [conseils de sécurité](01_Installation.md#conseils-de-securite), il est recommandé de faire pointer un nom de domaine vers ce sous-répertoire afin que seule la partie publique ne soit accessible par un navigateur web. De cette manière http://demo.freshrss.org/ pointe vers le répertoire ```./p``` et le ```robots.txt``` se trouve bien à la racine du site : http://demo.freshrss.org/robots.txt.
+
+L'explication est la même pour les fichiers ```favicon.ico``` et ```.htaccess```.
+
+## Pourquoi j'ai des erreurs quand j'essaye d'enregistrer un flux ?
+
+Il peut y avoir différentes origines à ce problème.  
+Le flux peut avoir une syntaxe invalide, il peut ne pas être reconnu par la bibliothèque SimplePie, l'hébergement peut avoir des problèmes, FreshRSS peut être boggué.
+Il faut dans un premier temps déterminer la cause du problème.  
+Voici la liste des étapes à suivre pour la déterminer :
+
+1. __Vérifier la validité du flux__ grâce à l'[outil en ligne du W3C](http://validator.w3.org/feed/ "Validateur en ligne de flux RSS et Atom"). Si ça ne fonctionne pas, nous ne pouvons rien faire.
+1. __Vérifier la reconnaissance par SimplePie__ grâce à l'[outil en ligne de SimplePie](http://simplepie.org/demo/ "Démo officielle de SimplePie"). Si ça ne fonctionne pas, nous ne pouvons rien faire.
+1. __Vérifier l'intégration dans FreshRSS__ grâce à la [démo](http://demo.freshrss.org "Démo officielle de FreshRSS"). Si ça ne fonctionne pas, il faut [créer un ticket sur Github](https://github.com/FreshRSS/FreshRSS/issues/new "Créer un ticket pour FreshRSS") pour que l'on puisse regarder ce qui se passe. Si ça fonctionne, il y a probablement un problème avec l'hébergement.
+
+Voici une liste des flux qui ne fonctionnent pas :
+
+* http://foulab.org/fr/rss/Foulab_News : ne passe pas la validation W3C (novembre 2014)
+* http://eu.battle.net/hearthstone/fr/feed/news : ne passe pas la validation W3C (novembre 2014)
+* http://webseriesmag.blogs.liberation.fr/we/atom.xml : ne fonctionne pas chez l'utilisateur mais passe l'ensemble des validations ci-dessus (novembre 2014)
diff --git a/docs/fr/users/08_PubSubHubbub.md b/docs/fr/users/08_PubSubHubbub.md
new file mode 100644
index 000000000..0f2f14794
--- /dev/null
+++ b/docs/fr/users/08_PubSubHubbub.md
@@ -0,0 +1,15 @@
+# Qu'est-ce que PubSubHubbub ?
+
+Derrière ce nom barbare se cache un protocole qui vient compléter Atom et RSS. En effet, le fonctionnement de base de ces deux derniers implique de vérifier à intervalles réguliers s'il existe de nouveaux articles sur les sites suivis. Cela même si le site concerné n'a rien publié depuis la dernière synchronisation. Le protocole PubSubHubbub permet d'éviter des synchronisations inutiles en notifiant en temps réel l'agrégateur de la présence de nouveaux articles.
+
+# Fonctionnement de PubSubHubbub
+
+On va retrouver trois notions dans PubSubHubbub : les éditeurs (les sites qui publient du contenu), les abonnés (les agrégateurs de flux RSS) et les hubs.
+
+Lorsqu'un agrégateur s'abonne à un site et récupère son flux RSS, il peut y trouver l'adresse d'un hub. Si c'est le cas — car un site peut ne pas en préciser —, l'agrégateur va s'abonner au hub et non pas à l'éditeur directement. Ainsi, lorsqu'un éditeur va publier du contenu, il va notifier le hub qui va lui-même notifier et envoyer le contenu à tous ses abonnés.
+
+Pour pouvoir être notifié, les abonnés doivent fournir une adresse accessible publiquement sur Internet.
+
+# PubSubHubbub et FreshRSS
+
+Depuis la version 1.1.2-beta, FreshRSS supporte officiellement PubSubHubbub. Vous pouvez donc recevoir en temps réel les articles des sites qui affichent dans leur flux RSS un « hub ».