Table des matières
Dans la première partie de notre tutoriel, nous avons réussi à faire en sorte que notre programme prenne un fichier texte et génère des blocs avec les paragraphes qu'il contenait, nous avons également réussi à lui donner la possibilité d'exporter ce que nous avons construit dans un fichier externe.Deuxième itération
Comme nous l'avons dit au début, nous devons faire le programme le plus modulaire et pour y parvenir, nous devons mener nos code orienté objet.
Pour cela, nous devons faire les abstractions nécessaires afin que nous puissions construire des classes qui contiennent les méthodes qui atteignent nos objectifs.
Exigences
Faisons une liste des composants que nous devons construire, avec cela nous saurons ce que nous devons avoir pour que notre programme soit plus complet :
- UNE analyseur, cet objet va nous permettre de lire le texte et de manipuler les autres classes.
- Règles, Nous allons faire une règle pour chaque type de bloc, cela nous permettra de détecter quel type de bloc nous avons et quel format nous devons lui appliquer.
- Filtres, avec eux, nous allons incorporer des expressions régulières pour pouvoir gérer certains éléments internes.
- Manipulateurs, ces gestionnaires seront utilisés par le analyseur pour générer la sortie traitée. Tous gestionnaire il sera capable de gérer un autre type d'étiquettes.
Cette classe va nous permettre de gérer certains types d'étiquettes pour les sorties, voyons le code qu'elle peut contenir :
gestionnaire de classe : def callback (self, prefix, name, * args) : method = getattr (self, prefix + name, None) if callable (method) : return method (* args) def start (self, name) : self. callback ('start_', nom) def end (self, name): self.callback ('end_', name) def sub (self, name): def substitution (match): result = self.callback ('sub_', name, match) default = match.group (0) renvoie le résultat ou renvoie la substitution par défaut Si nous faisons maintenant un petit exercice, nous pouvons voir nos progrès jusqu'à présent :
>>> depuis les gestionnaires import HTMLRenderer >>> handler = HTMLRenderer () >>> import re >>> re.sub (r '\ * (. +?) \ *', handler.sub ('emphasis'),' Ceci * est * un test ')' Ceci c'est une test' Comme nous l'avons vu dans l'appel précédent, nous importons d'abord notre classe Moteur de rendu HTML quel est le nôtre gestionnaire, puis nous importons ré avec laquelle nous allons gérer les expressions régulières, puis nous allons à re.sub l'expression et la méthode avec laquelle elle doit être appliquée, puis le texte et enfin nous voyons que la sortie a généré le code HTML nécessaire.
Règles
Une fois qu'on a les handlers, il est temps de faire les règles, elles vont nous aider à donner une destination aux différents blocs, cependant, il faut qu'elle soit orientée objet pour qu'on ne se retrouve pas avec un grand nombre de blocs imbriqué si pour valider tous les cas.
Nous devons aussi avoir une super classe qui gère nos règles, voyons le code suivant qui contient la super classe.
class Rule: def action (self, block, handler): handler.start (self.type) handler.feed (block) handler.end (self.type) return True
Comme on voit la méthode action () reçoit le bloc et le type de gestionnaire qu'il doit utiliser, avec cela il pourra distinguer quel bloc il doit appliquer à ce qu'il reçoit par paramètres et ainsi finaliser le code qui doit être imprimé.
Avec cela, nous terminons le didacticiel et laissons à chacun le soin de continuer jusqu'à ce que le projet soit prêt selon les directives données au début dans la première partie de ce didacticiel.Avez-vous aimé et aidé ce tutoriel ?Vous pouvez récompenser l'auteur en appuyant sur ce bouton pour lui donner un point positif
