migrated to microdown

Author: Ducasse

Chapters/Chap00-TinyBlog-Introduction-FR.md

@@ -0,0 +1 @@
+## A propos de ce livreTout au long de ce projet, nous allons vous guider pour développer et enrichir une application Web, nommée TinyBlog, pour gérer un ou plusieurs blogs. La figure *@TinyBlogOnPharoCloudHere@* montre l'état final de l'application. L'idée est qu'un visiteur du site Web puisse voir les posts et que l'auteur du blog puisse se connecter sur le site pour administrer le blog c'est-à-dire ajouter, supprimer ou modifier des posts.TinyBlog est une petite application pédagogique qui va vous montrer comment développer et déployer une application web en utilisant Pharo / Seaside / Mongo et d'autres frameworks tels que NeoJSON.Notre idée est que par la suite vous pourrez réutiliser cette infrastructure pour créer vos propres applications Web.### StructureDans la première partie appelée "Tutoriel de base", vous allez développer et déployer, TinyBlog, une  application et son administration en utilisant Pharo et le framework Seaside ainsi que d'autres bibliothèques comme Voyage ou Magritte. Le déploiement en utilisant la base de données Mongo est optionnel mais cela vous permet de voir que Voyage est une façade élégante et simple pour faire persister des données notamment dans Mongo.Dans une seconde partie optionnelle, nous abordons des aspects optionnels tel que l'export de données, l'utilisation de templates comme Mustache ou comment exposer votre application via une API REST.Les solutions proposées dans ce tutoriel sont parfois non optimales afin de vous faire réagir et que vous puissiez proposer d'autres solutions et des améliorations. Notre objectif n'est pas d'être exhaustif. Nous montrons une façon de faire cependant nous invitons le lecteur à lire les références sur les autres chapitres, livres et tutoriaux Pharo afin d'approfondir son expertise et enrichir son application.Finalement, afin de vous permettre de ne pas abandonner si vous ne trouvez pas une erreur, le dernier chapitre vous permet de chargerle code décrit dans chacun des chapitres.![L'application TinyBlog.](figures/TinyBlogOnPharoCloud.png width=100&label=TinyBlogOnPharoCloudHere)### Installation de PharoDans ce tutoriel, nous supposons que vous utilisez l'image Pharo du MOOC \(actuellement une image Pharo 8.0\) dans laquelle ont été chargés des bibliothèques et des frameworks spécifiques pour le développement d'applications Web: Seaside \(le serveur d'application web à base de composants\), Magritte \(un framework de description pour la génération automatique de rapport\), Bootstrap \(la bibliothèque de rendu web\), Voyage \(un framework pour sauver vos objets\) et quelques autres.Vous pouvez récupérer l'image Pharo MOOC en utilisant le Pharo Launcher \([http://pharo.org/download](http://pharo.org/download)\).### Règles de nommageDans la suite, nous préfixons tous les noms de classe par `TB` \(pour TinyBlog\).Vous pouvez:- soit choisir un autre préfixe \(par exemple `TBM`\) afin de pouvoir ensuite charger la correction dans la même image Pharo et la comparer à votre propre implémentation,- soit choisir le même préfixe afin de pouvoir fusionner les solutions proposées avec votre code. L'outil de gestion de versions vous montrera les différences et vous permettra d'apprendre des changements. Cette solution est toutefois plus contraignante si vous implémentez des fonctionnalités supplémentaires par rapport aux corrections ou même différemment ce qui est fort probable.### RessourcesPharo possède de bonnes ressources pédagogiques ainsi qu'une communauté d'utilisateurs accueillante. Voici quelques informations qui peuvent vous être utiles.- [http://books.pharo.org](http://books.pharo.org) contient des ouvrages autour de Pharo. Pharo by Example peut vous aider dans les aspects de découverte du langage et des bibliothèques de base. Entreprise Pharo: a Web Perspective presente d'autres aspects utiles pour le développement web.- [http://book.seaside.st](http://book.seaside.st) est un des ouvrages sur Seaside. Il est en cours de migration en livre open-source sur [https://github.com/SquareBracketAssociates/DynamicWebDevelopmentWithSeaside](https://github.com/SquareBracketAssociates/DynamicWebDevelopmentWithSeaside).- [http://mooc.pharo.org](http://mooc.pharo.org) propose un excellent Mooc \(cours en ligne\) comprenant plus de 90 videos expliquant des points de syntaxes mais aussi de conception objet.- Sur la page Web [http://pharo.org/community](http://pharo.org/community) vous trouverez le lien vers le channel discord où nombre de Pharoers échangent et s'entraident.### RemerciementsLes auteurs remercient chaleureusement René Paul Mages pour sa relecture attentive de ce livre.

Chapters/Chap00-TinyBlog-Introduction-FR.pillar

@@ -0,0 +1,59 @@
+## Modèle de l'application TinyBlog@cha:modelDans ce chapitre, nous développons une partie du modèle de l'application Tinyblog.Le modèle est particulièrement simple : il définit un bulletin. Dans le chapitre suivantnous définissons un blog qui contient une liste de bulletins.### La classe TBPost![TBPost une classe très simple gérant principalement des données.](figures/postUML.pdf width=20&label=postUml)Nous commençons ici par la représentation d'un bulletin \(post\) avec la classe `TBPost`. Elle est très simple \(comme le montre la figure *@postUml@*\) et elle définie ainsi:```Object subclass: #TBPost
+   instanceVariableNames: 'title text date category visible'
+   classVariableNames: ''
+   package: 'TinyBlog'```Nous utilisons cinq variables d'instance pour décrire un bulletin sur le blog.| Variable | Signification |  || --- | --- | --- || title | Titre du bulletin |  || text | Texte du bulletin |  || date | Date de redaction |  || category | Rubrique contenant le bulletin |  || visible | Post visible ou pas ? |  |Cette classe est également dotée de méthodes d'accès \(aussi appelées accesseurs\) à ces variables d'instances dans le protocole 'accessing'. Vous pouvez utiliser un refactoring pour créer automatiquement toutes les méthodes suivantes:```TBPost >> title
+   ^ title``````TBPost >> title: aString
+   title := aString``````TBPost >> text
+   ^ text``````TBPost >> text: aString
+   text := aString``````TBPost >> date
+   ^ date``````TBPost >> date: aDate
+   date := aDate``````TBPost >> visible
+   ^ visible``````TBPost >> visible: aBoolean
+   visible := aBoolean``````TBPost >> category
+   ^ category``````TBPost >> category: anObject
+   category := anObject```### Gérer la visibilité d'un postAjoutons dans le protocole 'action' des méthodes pour indiquer qu'un post est visible ou pas.```TBPost >> beVisible
+   self visible: true``````TBPost >> notVisible
+   self visible: false```### InitialisationLa méthode `initialize` \(protocole 'initialization'\) fixe la date à celle du jour et la visibilité à faux. L'utilisateur devra par la suite activer la visibilité.Cela permet de rédiger des brouillons et de ne publier un bulletin que lorsque celui-ci est terminé.Un bulletin est également rangé par défaut dans la catégorie 'Unclassified' que l'on définit au niveau classe.La méthode `unclassifiedTag` renvoie une valeur indiquant que le post n'est pas rangé dans une catégorie.```TBPost class >> unclassifiedTag
+   ^ 'Unclassified'```Attention la méthode `unclassifiedTag` est définie au niveau de la classe \(cliquer le bouton 'Class' pour la définir\). Les autres méthodes sont des méthodes d'instances c'est-à-dire qu'elles seront exécutées sur des instances de la classe `TBPost`.```TBPost >> initialize
+	super initialize.
+	self category: TBPost unclassifiedTag.
+	self date: Date today.
+	self notVisible```Dans la solution proposée ci-dessus pour la méthode `initialize`, il serait préférable de ne pas faire une référence en dur à la classe `TBPost`. Proposer une solution. La séquence 3 de la semaine 6 du MOOC peut vous aider à mieux comprendre pourquoi \([http://rmod-pharo-mooc.lille.inria.fr/MOOC/WebPortal/co/content\_67.html](http://rmod-pharo-mooc.lille.inria.fr/MOOC/WebPortal/co/content_67.html)\) il faut éviter de référencer des classes directement et comment faire.### Méthodes de créationCoté classe, on définit des méthodes de classe \(i.e., exécuter sur des classes\) pour faciliter la création de post appartenant ou pas à une catégorie - de telles méthodes sont souvent groupées dans le protocole 'instance creation'.Nous définissons deux méthodes.```TBPost class >> title: aTitle text: aText
+   ^ self new
+        title: aTitle;
+        text: aText;
+        yourself``````TBPost class >> title: aTitle text: aText category: aCategory
+   ^ (self title: aTitle text: aText)
+            category: aCategory;
+            yourself```### Création de postsCréons des posts pour s'assurer que tout fonctionne. Ouvrez l'outil Playground et executez l'expression suivante :```TBPost
+	title: 'Welcome in TinyBlog'
+	text: 'TinyBlog is a small blog engine made with Pharo.'
+	category: 'TinyBlog'```Si vous inspectez le code ci-dessus \(clic droit sur l'expression et "Inspect it"\), vous allez obtenir un inspecteur sur l'objet post nouvellement créé comme représenté sur la figure *@inspectorOnTBPost@*.![Inspecteur sur une instance de TBPost.](figures/inspectorOnTBPost.png width=100&label=inspectorOnTBPost)### Ajout de quelques tests unitairesInspecter manuellemment des objets n'est pas une manière systématique de vérifier que ces objets ont les propriétes attendues.Bien que le modèle soit simple nous pouvons définir quelques tests.En mode Test Driven Developpement nous écrivons les tests en premier.Ici nous avons préféré vous laissez définir une petite classe pour vous familiariser avec l'IDE.Mais maintenant nous réparons ce manque.Nous définissons la classe `TBPostTest` \(comme sous-classe de `TestCase`\).```TestCase subclass: #TBPostTest
+	instanceVariableNames: ''
+	classVariableNames: ''
+	package: 'TinyBlog-Tests'```Nous définissons deux tests.```TBPostTest >> testWithoutCategoryIsUnclassified
+
+	| post |
+	post := TBPost
+		title: 'Welcome to TinyBlog'
+		text: 'TinyBlog is a small blog engine made with Pharo.'.
+	self assert: post title equals: 'Welcome to TinyBlog' .
+	self assert: post category = TBPost unclassifiedTag.``````TBPostTest >> testPostIsCreatedCorrectly
+
+		| post |
+		post := TBPost
+			title: 'Welcome to TinyBlog'
+			text: 'TinyBlog is a small blog engine made with Pharo.'
+			category: 'TinyBlog'.
+		self assert: post title equals: 'Welcome to TinyBlog' .
+		self assert: post text equals: 'TinyBlog is a small blog engine made with Pharo.' .```Vos tests doivent passer.### Interrogation d'un postDans le protocole 'testing', définissez les deux méthodes suivantes qui permettent respectivement, de demander à un post s'il est visible, et s'il est classé dans une catégorie.```TBPost >> isVisible
+   ^ self visible``````TBPost >> isUnclassified
+   ^ self category = TBPost unclassifiedTag```De même il serait préférable de ne pas faire une référence en dur à la classe `TBPost` dans le corps d'une méthode.Proposer une solution!De plus, prenons le temps de mettre à jour notre test pour couvrir ce nouvel aspect.Nous simplifions de cette manière la logique de notre test.```TBPostTest >> testWithoutCategoryIsUnclassified
+
+	| post |
+	post := TBPost
+		title: 'Welcome to TinyBlog'
+		text: 'TinyBlog is a small blog engine made with Pharo.'.
+	self assert: post title equals: 'Welcome to TinyBlog' .
+	self assert: post isUnclassified.
+	self deny: post isVisible```### ConclusionNous avons développé une première partie du modèle \(la classe `TBPost`\) et défini quelques tests. Nous vous suggérons fortementd'écrire d'autres tests unitaires pour vérifier que ce modèle fonctionne correctement même s'il est simple.