📝 markdown

Markdown Parser & HTML Renderer - CommonMark Compatible

~400 satır ~35 fonksiyon CommonMark

📖 Genel Bakış

Markdown modülü, CommonMark standardına uyumlu Markdown parser ve HTML renderer sağlar. AST manipulation, syntax highlighting ve table of contents generation destekler.

🔑 Temel Özellikler

🚀 Hızlı Başlangıç

içe_aktar markdown

// Basit rendering
değişken html = markdown.render("# Hello\nWorld!")
io.println(html)
// Output: <h1>Hello</h1>\n<p>World!</p>

// Dosyadan okuma
değişken md_text = fs.read_to_string("README.md")?
değişken html = markdown.render(md_text)
fs.write("README.html", html)?

💡 Örnek 1: Blog Generator

içe_aktar markdown, fs, time, regex

yapı BlogPost yap
    title: yazı,
    date: time.Date,
    author: yazı,
    content_html: yazı,
    excerpt: yazı,
    reading_time: sayı
son

fonksiyon parse_blog_post(md_file: yazı) -> Sonuç[BlogPost, Hata] yap
    // Markdown dosyasını oku
    değişken content = fs.read_to_string(md_file)?
    
    // Front matter parse et (YAML)
    değişken (frontmatter, body) = split_frontmatter(content)?
    
    değişken title = frontmatter.get("title")?
    değişken date = time.parse(frontmatter.get("date")?, "%Y-%m-%d")?
    değişken author = frontmatter.get("author")?
    
    // Markdown to HTML
    değişken doc = markdown.parse(body)
    
    // Table of contents ekle
    değişken toc = markdown.generate_toc(doc)
    
    // Syntax highlighting
    markdown.highlight_code_blocks(doc, yap
        theme: "github",
        line_numbers: doğru
    son)
    
    değişken html = markdown.to_html(doc)
    
    // Excerpt (first paragraph)
    değişken excerpt = markdown.extract_text(doc, max_length: 150)
    
    // Reading time (ortalama 200 kelime/dakika)
    değişken word_count = markdown.word_count(doc)
    değişken reading_time = (word_count / 200).max(1)
    
    dön Tamam(BlogPost yap
        title: title,
        date: date,
        author: author,
        content_html: html,
        excerpt: excerpt,
        reading_time: reading_time
    son)
son

fonksiyon generate_blog_html(post: BlogPost) -> yazı yap
    dön "
        <article>
            <header>
                <h1>{}</h1>
                <div class='meta'>
                    <span>By {}</span>
                    <span>{}</span>
                    <span>{} min read</span>
                </div>
            </header>
            <div class='excerpt'>{}</div>
            <div class='content'>
                {}
            </div>
        </article>
    ".formatla(
        post.title,
        post.author,
        post.date.format("%B %d, %Y"),
        post.reading_time,
        post.excerpt,
        post.content_html
    )
son

fonksiyon ana() yap
    değişken posts = []
    
    // Tüm blog postlarını parse et
    her file içinde fs.read_dir("posts")? için yap
        eğer file.ends_with(".md") ise yap
            eşle parse_blog_post("posts/" + file) yap
                Tamam(post) => posts.ekle(post),
                Hata(e) => io.eprintln("Error parsing {}: {}", file, e)
            son
        son
    son
    
    // Tarihe göre sırala
    posts.sort_by(|a, b| b.date.cmp(&a.date))
    
    // HTML oluştur
    her post içinde posts için yap
        değişken html = generate_blog_html(post)
        değişken slug = post.title.to_lowercase().replace(" ", "-")
        fs.write("output/{}.html".formatla(slug), html)?
    son
    
    io.println("Generated {} blog posts", posts.uzunluk())
son

💡 Örnek 2: Documentation Generator

içe_aktar markdown, fs

fonksiyon generate_docs(input_dir: yazı, output_dir: yazı) -> Sonuç[Hiçbir, Hata] yap
    // Template
    değişken template = fs.read_to_string("template.html")?
    
    // Sidebar navigation
    değişken nav_items = []
    
    // Process all markdown files
    her file içinde fs.glob("{}/**/*.md".formatla(input_dir))? için yap
        değişken md_text = fs.read_to_string(file)?
        değişken doc = markdown.parse(md_text)
        
        // Extract title (first h1)
        değişken title = markdown.find_first_heading(doc, level: 1)
            .unwrap_or("Untitled")
        
        // Generate TOC
        değişken toc_html = markdown.generate_toc_html(doc, yap
            min_level: 2,
            max_level: 4,
            id_prefix: "toc-"
        son)
        
        // Add IDs to headings
        markdown.add_heading_ids(doc)
        
        // Convert to HTML
        değişken content_html = markdown.to_html(doc)
        
        // Apply template
        değişken html = template
            .replace("{{title}}", title)
            .replace("{{toc}}", toc_html)
            .replace("{{content}}", content_html)
        
        // Output path
        değişken rel_path = file.strip_prefix(input_dir)?
        değişken out_file = "{}/{}.html".formatla(output_dir, 
            rel_path.strip_suffix(".md")?)
        
        fs.create_dir_all(fs.parent(out_file)?)?
        fs.write(out_file, html)?
        
        // Add to navigation
        nav_items.ekle(yap
            title: title,
            path: rel_path.replace(".md", ".html")
        son)
        
        io.println("✓ Generated {}", out_file)
    son
    
    // Generate index with navigation
    generate_index(output_dir, nav_items)?
    
    dön Tamam(Hiçbir)
son

📦 AST Manipulation

// Parse to AST
değişken doc = markdown.parse("# Title\nContent")

// Traverse nodes
değişken root = doc.root()
her node içinde root.children() için yap
    eşle node.type() yap
        NodeType.Heading(level) => yap
            io.println("H{}: {}", level, node.text())
        son,
        NodeType.Paragraph => yap
            io.println("Paragraph: {}", node.text())
        son,
        _ => yap son
    son
son

// Modify AST
değişken heading = markdown.Node.new_heading(2)
heading.append_text("New Section")
root.append_child(heading)

// Convert back to HTML
değişken html = markdown.to_html(doc)

🔗 İlgili Modüller

← Tüm Modüller