Rendre le markdown dans la template ou à l'enregistrement

Bonjour,

Je voulais savoir quelle était la meilleure méthode pour rendre le markdown. Faut-il le faire au dans la template avec un tag tel que {{ content|markdown }} comme ont l'air de faire de nombreuses applications django ou alors le rendre à la réception du formulaire et l'enregistrer dans la base de donnée avec les balises html ?

J'ai essayé de regarder comment faisait Zeste De Savoir mais j'ai pas trouvé où ça se faisait… La seconde méthode me parait beaucoup plus performante non ? Seulement il faut que je garde deux copies du texte, une du markdown et une du texte converti en html…

J'attends vos conseils. Merci à vous.

J'ignore comment fait ZdS, mais sa dépens du nombre de lectures… plus un élément est lu plus il devra être converti si tu le rend à chaque visionnage… alors que si tu le stock converti tu ne l'aura finalement converti qu'une seule fois. En temps processeur tu y gagne beaucoup.

Personnellement je préférè la première méthode qui évite de garder et gérer deux copies du texte.

Tu peux aussi faire le rendu du markdown coté client si tu veux soulager ton serveur, ça sera transparent pour le client normalement!

Tu as vraiment un souçis de performance actuellement ? La 1ere solution reste la plus pratique, simple et flexible. Je serais toi je regarderais une autre solution que si vraiment j'avais un réel problème pratique de performance !

Zeste de savoir fait le traitement à l'écriture et l'enregistre en bdd. C'est un principe de dénormalisation qui permet d'améliorer significativement les performances d'autant que ça permet –dans une certaine mesure– d'avoir la donnée précalculée en mémoire (memcached).

Pour information, zeste de savoir organise les postes ainsi :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

class Comment(models.Model):

    """Comment in forum, articles, tutorial, chapter, etc."""
    class Meta:
        verbose_name = 'Commentaire'
        verbose_name_plural = 'Commentaires'

    objects = InheritanceManager()

    author = models.ForeignKey(User, verbose_name='Auteur',
                               related_name='comments', db_index=True)
    editor = models.ForeignKey(User, verbose_name='Editeur',
                               related_name='comments-editor+',
                               null=True, blank=True)
    ip_address = models.CharField('Adresse IP de l\'auteur ', max_length=39)

    position = models.IntegerField('Position', db_index=True)

    text = models.TextField('Texte')
    text_html = models.TextField('Texte en Html')

    like = models.IntegerField('Likes', default=0)
    dislike = models.IntegerField('Dislikes', default=0)

    pubdate = models.DateTimeField('Date de publication', auto_now_add=True, db_index=True)
    update = models.DateTimeField('Date d\'édition', null=True, blank=True)
    update_index_date = models.DateTimeField(
        'Date de dernière modification pour la réindexation partielle',
        auto_now=True,
        db_index=True)

    is_visible = models.BooleanField('Est visible', default=True)
    text_hidden = models.CharField(
        'Texte de masquage ',
        max_length=80,
        default='')

    def update_content(self, text):
        self.text = text
        self.text_html = emarkdown(self.text)

Nous appelons update_content lorsqu'on crée ou qu'on met à jour un poste.

Du coup, côté template, on a :

1
2
3
4
5
6
7
8
9

 {% if message.is_visible != False %}
                <div itemprop="text">
                    {{ message.text_html|safe }}
                </div>
            {% elif perms_change %}
                <div class="message-hidden-content">
                    {{ message.text_html|safe }}
                </div>
            {% endif %}

Comme la précisé La Source, si tes informations sont censées être accessibles le plus souvent en lecture pour l'utilisateur, il vaut mieux créer un champ qui stocke la valeur après le parsing. Le parsing du markdown est une tache qui est très couteuse en général, donc si on peut eviter de le faire à chaque raffraichissement de la page, c'est une bonne idée.

ZdS stocke lui aussi le contenu html pour le rendre a vitesse de l'eclair quand il faut. L'avantage est que le cpu souffrira moins.