Aidez-moi à comprendre : le processus post-cuisson

spirobel · Mai 29, 2020, 9:51

Bonjour,

Je serais très reconnaissant si quelqu’un pouvait m’aider à comprendre comment fonctionne le processus de post-cuisson. Je suis particulièrement intéressé par cette partie :

github.com/discourse/discourse

lib/cooked_post_processor.rb

956d15d13

# frozen_string_literal: true

# Post processing that we can do after a post has already been cooked.
# For example, inserting the onebox content, or image sizes/thumbnails.

class CookedPostProcessor
  LIGHTBOX_WRAPPER_CSS_CLASS = "lightbox-wrapper"
  LOADING_SIZE = 10
  LOADING_COLORS = 32

  attr_reader :cooking_options, :doc

  def initialize(post, opts = {})
    @dirty = false
    @opts = opts
    @post = post
    @previous_cooked = (@post.cooked || "").dup
    # NOTE: we re-cook the post here in order to prevent timing issues with edits
    # cf. https://meta.discourse.org/t/edit-of-rebaked-post-doesnt-show-in-html-only-in-raw/33815/6
    @cooking_options = post.cooking_options || opts[:cooking_options] || {}

This file has been truncated. show original

Pourquoi le post-traitement a-t-il lieu après que le message a déjà été « cuit » ?

Peut-être pourrions-nous passer en revue les étapes nécessaires pour ajouter une fonctionnalité comme les oneboxes ou les « citations d’utilisateurs spécifiques », si elle n’existait pas encore. Je suis ainsi tombé sur Prettytext discourse/app/assets/javascripts/pretty-text at f9608c0af5f7b1109117a5aba979acb00c28cf9a · discourse/discourse · GitHub
qui gère la conversion vers et depuis le Markdown ainsi que le rendu de la zone d’aperçu. J’ai également trouvé la fonction rebake dans le modèle de message côté backend :

github.com/discourse/discourse

app/models/post.rb

d9a02d133


      
                else
                  post.custom_fields["rebake_attempts"] = attempts + 1
                  post.save_custom_fields
                end
          
              end
            end
            problems
          end
          
          def rebake!(invalidate_broken_images: false, invalidate_oneboxes: false, priority: nil)
            new_cooked = cook(raw, topic_id: topic_id, invalidate_oneboxes: invalidate_oneboxes)
            old_cooked = cooked
          
            update_columns(
              cooked: new_cooked,
              baked_at: Time.zone.now,
              baked_version: BAKED_VERSION
            )
          
            if is_first_post?

qui appelle la méthode cook de PostAnalyzer :

github.com/discourse/discourse

app/models/post_analyzer.rb

9bff0882c


      
          end
          
          def has_oneboxes?
            return false unless @raw.present?
          
            cooked_stripped
            found_oneboxes?
          end
          
          # What we use to cook posts
          def cook(raw, opts = {})
            cook_method = opts[:cook_method]
            return raw if cook_method == Post.cook_methods[:raw_html]
          
            if cook_method == Post.cook_methods[:email]
              cooked = EmailCook.new(raw).cook(opts)
            else
              cooked = PrettyText.cook(raw, opts)
            end
          
            result = Oneboxer.apply(cooked) do |url|

Cette fonction exécute la conversion Markdown en JavaScript côté backend :

github.com/discourse/discourse

lib/pretty_text.rb

9bff0882c


      
            @ctx
          end
          
          def self.reset_context
            @ctx_init.synchronize do
              @ctx&.dispose
              @ctx = nil
            end
          end
          
          def self.markdown(text, opts = {})
            # we use the exact same markdown converter as the client
            # TODO: use the same extensions on both client and server (in particular the template for mentions)
            baked = nil
            text = text || ""
          
            protect do
              context = v8
          
              custom_emoji = {}
              Emoji.custom.map { |e| custom_emoji[e.name] = e.url }

Mon hypothèse était que cela se fait ainsi pour éviter la duplication de code, mais j’ai ensuite découvert le :

CookedPostProcessor

que j’ai lié plus haut. Il semble que certains traitements soient effectués uniquement en JavaScript, tandis que d’autres le sont à la fois en JavaScript et en Ruby dans CookedPostProcessor. Pour résumer :

Vous devez disposer de règles de conversion vers et depuis le Markdown (semble-t-il uniquement en JavaScript).
Vous devez disposer d’un code pour générer le HTML (une partie en JavaScript, mais une autre aussi en Ruby).

Je suis curieux de savoir pourquoi le point (2) est réalisé partiellement en JavaScript et partiellement en Ruby. Pourriez-vous me donner un exemple ?
Je serais également très heureux si vous pouviez corriger les hypothèses erronées que j’ai formulées dans ce message.

Un grand merci !
Spirobel

fzngagan · Juillet 2, 2020, 4:26

Pour commencer, consultez simplement l’onglet Réseau de la console JavaScript afin de voir ce qui est capturé côté frontend et transmis au serveur lors de la création d’un article. Cela signifie que toutes les données envoyées à l’API Rails sont ensuite traitées par Rails. Ensuite, dans la table posts, vous verrez les colonnes raw et cooked, qui indiquent respectivement les versions non traitée et traitée de l’article.

spirobel · Juillet 3, 2020, 3:18

D’accord, merci pour votre réponse. Je pense que je vais simplement explorer cela pièce par pièce. Je crois que cette approche de « raisonner à partir de principes fondamentaux » que j’ai adoptée ne fonctionne pas, car cela s’est développé pour des raisons historiques.

Sujet		Réponses	Vues
Post Cooking Process with Landing Pages Development	0	369	Novembre 5, 2021
Importing posts with Markdown Migration	11	975	Octobre 19, 2023
Edit of rebaked post doesn't show in HTML; only in raw Bug	8	1855	Septembre 29, 2015
How to decorate a post before it's cooked? Development	4	979	Mars 5, 2021
Working with different needs in raw/cooked content Development	7	5263	Mai 15, 2025

Aidez-moi à comprendre : le processus post-cuisson

Sujets connexes