Aiutami a capire: il processo post-cottura

spirobel · 29 Maggio 2020, 9:51am

Ciao,
Sarei molto lieto se qualcuno potesse aiutarmi a capire come funziona il processo di post-cottura. In particolare, sono interessato a questa parte:

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

perché l’elaborazione avviene dopo che il post è già stato “cotto”?
Forse potremmo esaminare il processo necessario per aggiungere una funzionalità come le onebox o le “citazioni di utenti specifici”, se non esistessero già. Così sono arrivato a Prettytext discourse/app/assets/javascripts/pretty-text at f9608c0af5f7b1109117a5aba979acb00c28cf9a · discourse/discourse · GitHub
che gestisce la conversione da e verso Markdown e il rendering della casella di anteprima. Ho anche trovato la funzione rebake nel modello del post nel 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?

che chiama il metodo cook di 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|

questa funzione esegue la conversione Markdown in JavaScript nel 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 }

il mio pensiero era che fosse fatto in questo modo per ridurre la duplicazione del codice, ma poi ho scoperto il

CookedPostProcessor

che ho collegato all’inizio. Sembra che alcune elaborazioni avvengano solo in JavaScript, mentre altre avvengono sia in JavaScript che in Ruby all’interno di CookedPostProcessor. Quindi, per riassumere: 1. È necessario disporre di regole di conversione da e verso Markdown (sembra che siano solo in JavaScript) 2. È necessario avere del codice per creare l’HTML (parte in JavaScript e parte anche in Ruby). Sono interessato a sapere perché il punto (2.) viene eseguito parzialmente in JavaScript e parzialmente in Ruby. Potresti farmi un esempio? Sarei anche molto felice se potessi correggere eventuali false ipotesi che ho fatto in questo post.
Grazie mille!
Spirobel

fzngagan · 2 Luglio 2020, 4:26pm

Per iniziare, controlla la scheda Network della console JS per vedere cosa viene catturato nel frontend e inviato al server quando viene creato un post. Ciò significa che tutti i dati inviati all’API di Rails vengono ulteriormente elaborati da Rails. Successivamente, nella tabella posts, vedrai le colonne raw e cooked, che indicano rispettivamente la forma non elaborata e elaborata del post.

spirobel · 3 Luglio 2020, 3:18pm

Ok, grazie per la tua risposta. Penso che mi limiterò a esplorare questo pezzo per pezzo. Credo che forse l’approccio di “ragionarci sopra partendo dai principi fondamentali” che ho adottato non funzioni, perché è nato per motivi storici.

Argomento		Risposte	Visualizzazioni
Post Cooking Process with Landing Pages Development	0	369	Novembre 5, 2021
Importing posts with Markdown Migration	11	975	Ottobre 19, 2023
Edit of rebaked post doesn't show in HTML; only in raw Bug	8	1855	Settembre 29, 2015
How to decorate a post before it's cooked? Development	4	979	Marzo 5, 2021
Working with different needs in raw/cooked content Development	7	5263	Maggio 15, 2025

Aiutami a capire: il processo post-cottura

Argomenti correlati