pip install markdown pygments python-frontmatter

import markdown
import logging
from typing import Dict, Any, Optional

class BasicMarkdownConverter:
    """
    基礎(chǔ)Markdown轉(zhuǎn)換器類
    提供Markdown到HTML的基本轉(zhuǎn)換功能
    """
    
    def __init__(self, extensions: list = None, extension_configs: Dict = None):
        """
        初始化轉(zhuǎn)換器
        
        Args:
            extensions: Markdown擴(kuò)展列表
            extension_configs: 擴(kuò)展配置字典
        """
        self.logger = logging.getLogger(__name__)
        
        # 默認(rèn)擴(kuò)展
        self.default_extensions = [
            'extra',          # 額外語法支持
            'codehilite',     # 代碼高亮
            'toc',            # 目錄生成
            'tables',         # 表格支持
        ]
        
        self.extensions = extensions or self.default_extensions
        self.extension_configs = extension_configs or {}
        
        self.logger.info("Markdown轉(zhuǎn)換器初始化完成")
    
    def convert(self, markdown_text: str, **kwargs) -> str:
        """
        將Markdown文本轉(zhuǎn)換為HTML
        
        Args:
            markdown_text: Markdown格式文本
            **kwargs: 額外參數(shù)
            
        Returns:
            str: 轉(zhuǎn)換后的HTML
        """
        try:
            if not markdown_text:
                return ""
            
            # 使用markdown庫進(jìn)行轉(zhuǎn)換
            html_content = markdown.markdown(
                markdown_text,
                extensions=self.extensions,
                extension_configs=self.extension_configs,
                **kwargs
            )
            
            self.logger.debug(f"成功轉(zhuǎn)換Markdown文本，長度: {len(markdown_text)}")
            return html_content
            
        except Exception as e:
            self.logger.error(f"Markdown轉(zhuǎn)換失敗: {str(e)}")
            return f"<p>轉(zhuǎn)換錯(cuò)誤: {str(e)}</p>"
    
    def convert_file(self, file_path: str, encoding: str = 'utf-8') -> str:
        """
        轉(zhuǎn)換Markdown文件為HTML
        
        Args:
            file_path: 文件路徑
            encoding: 文件編碼
            
        Returns:
            str: 轉(zhuǎn)換后的HTML
        """
        try:
            with open(file_path, 'r', encoding=encoding) as f:
                markdown_content = f.read()
            
            return self.convert(markdown_content)
            
        except FileNotFoundError:
            self.logger.error(f"文件未找到: {file_path}")
            return f"<p>文件未找到: {file_path}</p>"
        except Exception as e:
            self.logger.error(f"文件轉(zhuǎn)換失敗: {str(e)}")
            return f"<p>文件轉(zhuǎn)換錯(cuò)誤: {str(e)}</p>"

def demo_basic_conversion():
    """演示基礎(chǔ)轉(zhuǎn)換功能"""
    
    # 創(chuàng)建轉(zhuǎn)換器實(shí)例
    converter = BasicMarkdownConverter()
    
    # 示例Markdown文本
    sample_markdown = """
# 這是一個(gè)標(biāo)題

這是一個(gè)段落，包含**粗體**和*斜體*文本。

## 列表示例

- 項(xiàng)目1
- 項(xiàng)目2
- 項(xiàng)目3

### 代碼示例

```python
def hello_world():
    print("Hello, World!")

# 執(zhí)行轉(zhuǎn)換
html_result = converter.convert(sample_markdown)

print("原始Markdown:")
print(sample_markdown)
print("\n轉(zhuǎn)換后的HTML:")
print(html_result)

return html_result

## 4. 高級(jí)Markdown功能集成

### 4.1 數(shù)學(xué)公式支持

數(shù)學(xué)公式是技術(shù)文檔中的重要組成部分，我們通過MathJax集成數(shù)學(xué)公式支持。

```python
import re

class AdvancedMarkdownConverter(BasicMarkdownConverter):
    """
    高級(jí)Markdown轉(zhuǎn)換器
    支持?jǐn)?shù)學(xué)公式、流程圖等高級(jí)功能
    """
    
    def __init__(self, enable_math: bool = True, enable_diagrams: bool = True):
        """
        初始化高級(jí)轉(zhuǎn)換器
        
        Args:
            enable_math: 是否啟用數(shù)學(xué)公式支持
            enable_diagrams: 是否啟用圖表支持
        """
        extensions = [
            'extra',
            'codehilite',
            'toc',
            'tables',
            'mdx_math',  # 數(shù)學(xué)公式支持
        ]
        
        extension_configs = {
            'codehilite': {
                'css_class': 'highlight',
                'linenums': True,
            },
            'toc': {
                'title': '目錄',
                'permalink': True,
            },
            'mdx_math': {
                'enable_dollar_delimiter': True,
            }
        }
        
        super().__init__(extensions, extension_configs)
        
        self.enable_math = enable_math
        self.enable_diagrams = enable_diagrams
        
    def _inject_mathjax_support(self, html_content: str) -> str:
        """
        注入MathJax支持代碼
        
        Args:
            html_content: HTML內(nèi)容
            
        Returns:
            str: 注入MathJax后的HTML
        """
        if not self.enable_math:
            return html_content
            
        mathjax_script = """
        <script>
        MathJax = {
            tex: {
                inlineMath: [['$', '$'], ['\\(', '\\)']],
                displayMath: [['$$', '$$'], ['\\[', '\\]']]
            },
            svg: {
                fontCache: 'global'
            }
        };
        </script>
        <script type="text/javascript" id="MathJax-script" async
            src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-svg.js">
        </script>
        """
        
        # 將MathJax腳本注入到head標(biāo)簽前
        if '</head>' in html_content:
            return html_content.replace('</head>', mathjax_script + '</head>')
        else:
            return mathjax_script + html_content
    
    def _process_mermaid_diagrams(self, html_content: str) -> str:
        """
        處理Mermaid流程圖
        
        Args:
            html_content: HTML內(nèi)容
            
        Returns:
            str: 處理后的HTML
        """
        if not self.enable_diagrams:
            return html_content
            
        # 查找Mermaid代碼塊
        pattern = r'<pre><code class="language-mermaid">(.*?)</code></pre>'
        
        def replace_mermaid(match):
            mermaid_code = match.group(1)
            # 對(duì)HTML實(shí)體進(jìn)行解碼
            import html
            mermaid_code = html.unescape(mermaid_code)
            return f'<div class="mermaid">{mermaid_code}</div>'
        
        processed_html = re.sub(pattern, replace_mermaid, html_content, flags=re.DOTALL)
        
        # 注入Mermaid支持
        mermaid_script = """
        <script src="https://cdn.jsdelivr.net/npm/mermaid@9/dist/mermaid.min.js"></script>
        <script>mermaid.initialize({startOnLoad:true});</script>
        """
        
        if '</body>' in processed_html:
            return processed_html.replace('</body>', mermaid_script + '</body>')
        else:
            return processed_html + mermaid_script
    
    def convert(self, markdown_text: str, **kwargs) -> str:
        """
        高級(jí)Markdown轉(zhuǎn)換
        
        Args:
            markdown_text: Markdown文本
            **kwargs: 額外參數(shù)
            
        Returns:
            str: 轉(zhuǎn)換后的HTML
        """
        basic_html = super().convert(markdown_text, **kwargs)
        
        # 應(yīng)用高級(jí)處理
        html_with_math = self._inject_mathjax_support(basic_html)
        final_html = self._process_mermaid_diagrams(html_with_math)
        
        return final_html

def create_mermaid_diagram(diagram_type: str, content: str) -> str:
    """
    創(chuàng)建Mermaid圖表
    
    Args:
        diagram_type: 圖表類型（flowchart, sequence, gantt等）
        content: 圖表內(nèi)容
        
    Returns:
        str: Mermaid代碼塊
    """
    mermaid_template = f"""
```mermaid
{diagram_type}
{content}

## 5. Web框架集成

### 5.1 Flask集成示例

Flask是一個(gè)輕量級(jí)的Python Web框架，適合快速開發(fā)Web應(yīng)用。

```python
from flask import Flask, render_template, request, jsonify
import os
from datetime import datetime

app = Flask(__name__)

# 初始化Markdown轉(zhuǎn)換器
markdown_converter = AdvancedMarkdownConverter()

class MarkdownManager:
    """Markdown內(nèi)容管理器"""
    
    def __init__(self, storage_dir: str = "content"):
        self.storage_dir = storage_dir
        os.makedirs(storage_dir, exist_ok=True)
    
    def save_markdown(self, filename: str, content: str) -> str:
        """保存Markdown內(nèi)容到文件"""
        filepath = os.path.join(self.storage_dir, f"{filename}.md")
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(content)
        return filepath
    
    def load_markdown(self, filename: str) -> Optional[str]:
        """從文件加載Markdown內(nèi)容"""
        filepath = os.path.join(self.storage_dir, f"{filename}.md")
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                return f.read()
        except FileNotFoundError:
            return None

# 初始化管理器
md_manager = MarkdownManager()

@app.route('/')
def index():
    """首頁"""
    return render_template('index.html')

@app.route('/preview', methods=['POST'])
def preview_markdown():
    """Markdown實(shí)時(shí)預(yù)覽接口"""
    markdown_text = request.json.get('content', '')
    
    if not markdown_text:
        return jsonify({'html': '', 'error': '內(nèi)容為空'})
    
    try:
        html_content = markdown_converter.convert(markdown_text)
        return jsonify({'html': html_content, 'error': ''})
    except Exception as e:
        return jsonify({'html': '', 'error': str(e)})

@app.route('/save', methods=['POST'])
def save_document():
    """保存Markdown文檔"""
    filename = request.json.get('filename', '')
    content = request.json.get('content', '')
    
    if not filename or not content:
        return jsonify({'success': False, 'error': '文件名和內(nèi)容不能為空'})
    
    try:
        filepath = md_manager.save_markdown(filename, content)
        return jsonify({
            'success': True, 
            'message': f'文檔已保存: {filepath}'
        })
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)})

@app.route('/document/<filename>')
def view_document(filename):
    """查看Markdown文檔"""
    content = md_manager.load_markdown(filename)
    
    if content is None:
        return render_template('error.html', message='文檔不存在')
    
    html_content = markdown_converter.convert(content)
    return render_template('viewer.html', 
                         title=filename,
                         content=html_content)

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

# views.py
from django.shortcuts import render
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
import json

from .markdown_utils import AdvancedMarkdownConverter

converter = AdvancedMarkdownConverter()

@csrf_exempt
def markdown_preview(request):
    """Markdown預(yù)覽視圖"""
    if request.method == 'POST':
        try:
            data = json.loads(request.body)
            markdown_text = data.get('content', '')
            
            html_content = converter.convert(markdown_text)
            
            return JsonResponse({
                'success': True,
                'html': html_content
            })
        except Exception as e:
            return JsonResponse({
                'success': False,
                'error': str(e)
            })
    
    return JsonResponse({'error': '僅支持POST請(qǐng)求'})

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('preview/', views.markdown_preview, name='markdown_preview'),
]

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Markdown編輯器</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background-color: #f5f5f5;
            color: #333;
        }
        
        .container {
            max-width: 1200px;
            margin: 0 auto;
            padding: 20px;
        }
        
        .editor-container {
            display: flex;
            gap: 20px;
            height: 80vh;
        }
        
        @media (max-width: 768px) {
            .editor-container {
                flex-direction: column;
                height: auto;
            }
        }
        
        .editor-panel, .preview-panel {
            flex: 1;
            background: white;
            border-radius: 8px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
            overflow: hidden;
        }
        
        .panel-header {
            background: #2c3e50;
            color: white;
            padding: 15px 20px;
            font-weight: bold;
        }
        
        .editor-textarea {
            width: 100%;
            height: calc(100% - 60px);
            border: none;
            padding: 20px;
            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
            font-size: 14px;
            line-height: 1.5;
            resize: none;
            outline: none;
        }
        
        .preview-content {
            padding: 20px;
            height: calc(100% - 60px);
            overflow-y: auto;
        }
        
        .toolbar {
            background: #34495e;
            padding: 10px 20px;
            display: flex;
            gap: 10px;
        }
        
        .btn {
            background: #3498db;
            color: white;
            border: none;
            padding: 8px 16px;
            border-radius: 4px;
            cursor: pointer;
            transition: background 0.3s;
        }
        
        .btn:hover {
            background: #2980b9;
        }
        
        .btn-save {
            background: #27ae60;
        }
        
        .btn-save:hover {
            background: #219a52;
        }
        
        /* Markdown預(yù)覽樣式 */
        .preview-content h1, .preview-content h2, .preview-content h3 {
            margin-top: 1.5em;
            margin-bottom: 0.5em;
            color: #2c3e50;
        }
        
        .preview-content code {
            background: #f8f9fa;
            padding: 2px 6px;
            border-radius: 3px;
            font-family: monospace;
        }
        
        .preview-content pre {
            background: #f8f9fa;
            padding: 15px;
            border-radius: 5px;
            overflow-x: auto;
        }
        
        .preview-content blockquote {
            border-left: 4px solid #3498db;
            padding-left: 15px;
            margin-left: 0;
            color: #7f8c8d;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>Markdown編輯器</h1>
        
        <div class="toolbar">
            <button class="btn" onclick="insertText('# 標(biāo)題\\n')">標(biāo)題</button>
            <button class="btn" onclick="insertText('**粗體**')">粗體</button>
            <button class="btn" onclick="insertText('*斜體*')">斜體</button>
            <button class="btn" onclick="insertText('- 列表項(xiàng)')">列表</button>
            <button class="btn" onclick="insertText('`代碼`')">代碼</button>
            <button class="btn" onclick="insertText('[鏈接](http://)')">鏈接</button>
            <button class="btn btn-save" onclick="saveDocument()">保存</button>
        </div>
        
        <div class="editor-container">
            <div class="editor-panel">
                <div class="panel-header">編輯器</div>
                <textarea id="markdownEditor" class="editor-textarea" 
                          placeholder="在此輸入Markdown內(nèi)容..."># 歡迎使用Markdown編輯器

這是一個(gè)**示例文檔**，支持以下功能：

## 功能特性
- 實(shí)時(shí)預(yù)覽
- 代碼高亮
- 數(shù)學(xué)公式
- 流程圖

### 數(shù)學(xué)公式示例
行內(nèi)公式：$E = mc^2$

塊級(jí)公式：
$$
\\nabla \\cdot \\mathbf{E} = \\frac{\\rho}{\\epsilon_0}
$$

### 代碼示例
```python
def hello_world():
    print("Hello, Markdown!")

        <div class="preview-panel">
            <div class="panel-header">預(yù)覽</div>
            <div id="preview" class="preview-content"></div>
        </div>
    </div>
</div>

<script>
    const editor = document.getElementById('markdownEditor');
    const preview = document.getElementById('preview');
    
    // 實(shí)時(shí)預(yù)覽
    editor.addEventListener('input', updatePreview);
    
    // 初始預(yù)覽
    updatePreview();
    
    function updatePreview() {
        const content = editor.value;
        
        fetch('/preview', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({ content: content })
        })
        .then(response => response.json())
        .then(data => {
            if (data.error) {
                preview.innerHTML = `<div class="error">錯(cuò)誤: ${data.error}</div>`;
            } else {
                preview.innerHTML = data.html;
                // 重新初始化Mermaid
                if (typeof mermaid !== 'undefined') {
                    mermaid.init();
                }
            }
        })
        .catch(error => {
            preview.innerHTML = `<div class="error">請(qǐng)求失敗: ${error}</div>`;
        });
    }
    
    function insertText(text) {
        const start = editor.selectionStart;
        const end = editor.selectionEnd;
        const selectedText = editor.value.substring(start, end);
        
        editor.setRangeText(text);
        editor.focus();
        editor.setSelectionRange(start + text.length, start + text.length);
        updatePreview();
    }
    
    function saveDocument() {
        const filename = prompt('請(qǐng)輸入文件名:');
        if (!filename) return;
        
        const content = editor.value;
        
        fetch('/save', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({
                filename: filename,
                content: content
            })
        })
        .then(response => response.json())
        .then(data => {
            if (data.success) {
                alert('保存成功!');
            } else {
                alert('保存失敗: ' + data.error);
            }
        })
        .catch(error => {
            alert('保存失敗: ' + error);
        });
    }
    
    // 快捷鍵支持
    editor.addEventListener('keydown', function(e) {
        if (e.ctrlKey || e.metaKey) {
            switch(e.key) {
                case 's':
                    e.preventDefault();
                    saveDocument();
                    break;
                case 'b':
                    e.preventDefault();
                    insertText('**');
                    break;
                case 'i':
                    e.preventDefault();
                    insertText('*');
                    break;
            }
        }
    });
</script>

#!/usr/bin/env python3
"""
Markdown編輯器Web應(yīng)用
"""

import os
import logging
from datetime import datetime
from typing import Dict, Any, Optional, List
from flask import Flask, render_template, request, jsonify, send_from_directory

# Markdown處理相關(guān)庫
import markdown
from markdown.extensions import Extension
from markdown.preprocessors import Preprocessor
import pygments
from pygments import highlight
from pygments.lexers import get_lexer_by_name, TextLexer
from pygments.formatters import HtmlFormatter

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

class EnhancedMarkdownConverter:
    """
    增強(qiáng)型Markdown轉(zhuǎn)換器
    支持代碼高亮、數(shù)學(xué)公式、流程圖等高級(jí)功能
    """
    
    def __init__(self):
        """初始化轉(zhuǎn)換器"""
        self.logger = logging.getLogger(__name__)
        
        # 配置擴(kuò)展
        self.extensions = [
            'markdown.extensions.extra',
            'markdown.extensions.toc',
            'markdown.extensions.tables',
            'markdown.extensions.codehilite',
            'markdown.extensions.fenced_code',
        ]
        
        self.extension_configs = {
            'markdown.extensions.codehilite': {
                'css_class': 'highlight',
                'linenums': True,
                'use_pygments': True,
            },
            'markdown.extensions.toc': {
                'title': '目錄',
                'permalink': True,
            }
        }
        
        self.logger.info("增強(qiáng)型Markdown轉(zhuǎn)換器初始化完成")
    
    def convert(self, markdown_text: str) -> str:
        """
        轉(zhuǎn)換Markdown文本為HTML
        
        Args:
            markdown_text: Markdown格式文本
            
        Returns:
            str: 轉(zhuǎn)換后的HTML
        """
        try:
            if not markdown_text:
                return ""
            
            # 轉(zhuǎn)換Markdown
            html_content = markdown.markdown(
                markdown_text,
                extensions=self.extensions,
                extension_configs=self.extension_configs,
                output_format='html5'
            )
            
            # 添加樣式支持
            html_content = self._wrap_with_styles(html_content)
            
            self.logger.debug(f"成功轉(zhuǎn)換Markdown文本")
            return html_content
            
        except Exception as e:
            self.logger.error(f"Markdown轉(zhuǎn)換失敗: {str(e)}")
            return f'<div class="error">轉(zhuǎn)換錯(cuò)誤: {str(e)}</div>'
    
    def _wrap_with_styles(self, html_content: str) -> str:
        """
        為HTML內(nèi)容添加CSS樣式包裝
        
        Args:
            html_content: HTML內(nèi)容
            
        Returns:
            str: 帶樣式的HTML
        """
        styles = """
        <style>
        .markdown-content {
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
            line-height: 1.6;
            color: #333;
            max-width: 100%;
        }
        
        .markdown-content h1, .markdown-content h2, .markdown-content h3 {
            border-bottom: 1px solid #eaecef;
            padding-bottom: 0.3em;
            margin-top: 1.5em;
        }
        
        .markdown-content code {
            background-color: #f6f8fa;
            padding: 0.2em 0.4em;
            border-radius: 3px;
            font-size: 0.9em;
        }
        
        .markdown-content pre {
            background-color: #f6f8fa;
            padding: 1em;
            border-radius: 5px;
            overflow-x: auto;
        }
        
        .markdown-content blockquote {
            border-left: 4px solid #dfe2e5;
            padding-left: 1em;
            margin-left: 0;
            color: #6a737d;
        }
        
        .markdown-content table {
            border-collapse: collapse;
            width: 100%;
        }
        
        .markdown-content table th, .markdown-content table td {
            border: 1px solid #dfe2e5;
            padding: 0.5em;
        }
        
        .markdown-content table th {
            background-color: #f6f8fa;
        }
        
        .error {
            color: #d73a49;
            background-color: #ffebef;
            padding: 1em;
            border-radius: 5px;
        }
        </style>
        """
        
        return f'<div class="markdown-content">{html_content}</div>'

class MarkdownFileManager:
    """Markdown文件管理器"""
    
    def __init__(self, base_dir: str = "markdown_docs"):
        """
        初始化文件管理器
        
        Args:
            base_dir: 文檔存儲(chǔ)基礎(chǔ)目錄
        """
        self.base_dir = base_dir
        os.makedirs(base_dir, exist_ok=True)
        self.logger = logging.getLogger(__name__)
    
    def list_documents(self) -> List[Dict[str, Any]]:
        """列出所有文檔"""
        documents = []
        
        try:
            for filename in os.listdir(self.base_dir):
                if filename.endswith('.md'):
                    filepath = os.path.join(self.base_dir, filename)
                    stat = os.stat(filepath)
                    
                    documents.append({
                        'name': filename[:-3],  # 移除.md擴(kuò)展名
                        'path': filepath,
                        'size': stat.st_size,
                        'modified': datetime.fromtimestamp(stat.st_mtime)
                    })
        except Exception as e:
            self.logger.error(f"列出文檔失敗: {str(e)}")
        
        return sorted(documents, key=lambda x: x['modified'], reverse=True)
    
    def save_document(self, name: str, content: str) -> bool:
        """
        保存文檔
        
        Args:
            name: 文檔名稱
            content: 文檔內(nèi)容
            
        Returns:
            bool: 是否保存成功
        """
        try:
            # 確保名稱安全
            safe_name = "".join(c for c in name if c.isalnum() or c in ('-', '_'))
            if not safe_name:
                safe_name = "untitled"
            
            filepath = os.path.join(self.base_dir, f"{safe_name}.md")
            
            with open(filepath, 'w', encoding='utf-8') as f:
                f.write(content)
            
            self.logger.info(f"文檔保存成功: {filepath}")
            return True
            
        except Exception as e:
            self.logger.error(f"保存文檔失敗: {str(e)}")
            return False
    
    def load_document(self, name: str) -> Optional[str]:
        """
        加載文檔
        
        Args:
            name: 文檔名稱
            
        Returns:
            Optional[str]: 文檔內(nèi)容，如果不存在返回None
        """
        try:
            filepath = os.path.join(self.base_dir, f"{name}.md")
            
            with open(filepath, 'r', encoding='utf-8') as f:
                return f.read()
                
        except FileNotFoundError:
            self.logger.warning(f"文檔不存在: {name}")
            return None
        except Exception as e:
            self.logger.error(f"加載文檔失敗: {str(e)}")
            return None

# 創(chuàng)建Flask應(yīng)用
app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key-here'

# 初始化組件
markdown_converter = EnhancedMarkdownConverter()
file_manager = MarkdownFileManager()

@app.route('/')
def index():
    """首頁"""
    documents = file_manager.list_documents()
    return render_template('index.html', documents=documents)

@app.route('/editor')
def editor():
    """編輯器頁面"""
    doc_name = request.args.get('doc', '')
    content = ""
    
    if doc_name:
        content = file_manager.load_document(doc_name) or ""
    
    return render_template('editor.html', doc_name=doc_name, initial_content=content)

@app.route('/api/preview', methods=['POST'])
def api_preview():
    """Markdown預(yù)覽API"""
    data = request.get_json()
    
    if not data or 'content' not in data:
        return jsonify({'error': '缺少內(nèi)容參數(shù)'}), 400
    
    content = data['content']
    html_content = markdown_converter.convert(content)
    
    return jsonify({'html': html_content})

@app.route('/api/save', methods=['POST'])
def api_save():
    """保存文檔API"""
    data = request.get_json()
    
    if not data or 'name' not in data or 'content' not in data:
        return jsonify({'success': False, 'error': '缺少參數(shù)'}), 400
    
    name = data['name']
    content = data['content']
    
    if not name.strip():
        return jsonify({'success': False, 'error': '文檔名稱不能為空'})
    
    success = file_manager.save_document(name, content)
    
    if success:
        return jsonify({'success': True, 'message': '文檔保存成功'})
    else:
        return jsonify({'success': False, 'error': '保存失敗'})

@app.route('/api/documents')
def api_documents():
    """獲取文檔列表API"""
    documents = file_manager.list_documents()
    return jsonify({'documents': documents})

@app.route('/view/<doc_name>')
def view_document(doc_name):
    """查看文檔頁面"""
    content = file_manager.load_document(doc_name)
    
    if content is None:
        return render_template('error.html', message='文檔不存在')
    
    html_content = markdown_converter.convert(content)
    return render_template('viewer.html', title=doc_name, content=html_content)

@app.route('/static/<path:filename>')
def static_files(filename):
    """靜態(tài)文件服務(wù)"""
    return send_from_directory('static', filename)

# 錯(cuò)誤處理
@app.errorhandler(404)
def not_found(error):
    return render_template('error.html', message='頁面未找到'), 404

@app.errorhandler(500)
def internal_error(error):
    return render_template('error.html', message='服務(wù)器內(nèi)部錯(cuò)誤'), 500

if __name__ == '__main__':
    # 創(chuàng)建模板目錄（如果不存在）
    os.makedirs('templates', exist_ok=True)
    os.makedirs('static', exist_ok=True)
    
    # 運(yùn)行應(yīng)用
    app.run(
        host='0.0.0.0',
        port=5000,
        debug=True
    )

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}Markdown編輯器{% endblock %}</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}" rel="external nofollow" >
</head>
<body>
    <nav class="navbar">
        <div class="nav-container">
            <h1 class="nav-brand">Markdown編輯器</h1>
            <div class="nav-links">
                <a href="{{ url_for('index') }}" rel="external nofollow" >首頁</a>
                <a href="{{ url_for('editor') }}" rel="external nofollow"  rel="external nofollow" >新建文檔</a>
            </div>
        </div>
    </nav>
    
    <main class="main-content">
        {% block content %}{% endblock %}
    </main>
    
    <footer class="footer">
        <p>&copy; 2024 Markdown編輯器. 基于Python和Flask構(gòu)建.</p>
    </footer>
    
    {% block scripts %}{% endblock %}
</body>
</html>

{% extends "base.html" %}

{% block content %}
<div class="container">
    <div class="header">
        <h2>我的文檔</h2>
        <a href="{{ url_for('editor') }}" rel="external nofollow"  rel="external nofollow"  class="btn btn-primary">新建文檔</a>
    </div>
    
    <div class="document-list">
        {% if documents %}
            {% for doc in documents %}
            <div class="document-card">
                <h3>{{ doc.name }}</h3>
                <p>修改時(shí)間: {{ doc.modified.strftime('%Y-%m-%d %H:%M') }}</p>
                <p>大小: {{ (doc.size / 1024)|round(2) }} KB</p>
                <div class="document-actions">
                    <a href="{{ url_for('editor', doc=doc.name) }}" rel="external nofollow"  class="btn">編輯</a>
                    <a href="{{ url_for('view_document', doc_name=doc.name) }}" rel="external nofollow"  class="btn">查看</a>
                </div>
            </div>
            {% endfor %}
        {% else %}
            <div class="empty-state">
                <p>還沒有文檔，點(diǎn)擊"新建文檔"開始創(chuàng)作吧！</p>
            </div>
        {% endif %}
    </div>
</div>
{% endblock %}

import unittest
import tempfile
import os
from your_app import EnhancedMarkdownConverter, MarkdownFileManager

class TestMarkdownConverter(unittest.TestCase):
    """Markdown轉(zhuǎn)換器測試"""
    
    def setUp(self):
        self.converter = EnhancedMarkdownConverter()
    
    def test_basic_conversion(self):
        """測試基礎(chǔ)轉(zhuǎn)換"""
        markdown = "# 標(biāo)題\n\n這是一個(gè)段落"
        result = self.converter.convert(markdown)
        self.assertIn("<h1>標(biāo)題</h1>", result)
        self.assertIn("<p>這是一個(gè)段落</p>", result)
    
    def test_code_highlighting(self):
        """測試代碼高亮"""
        markdown = "```python\nprint('Hello')\n```"
        result = self.converter.convert(markdown)
        self.assertIn("highlight", result)

class TestFileManager(unittest.TestCase):
    """文件管理器測試"""
    
    def setUp(self):
        self.temp_dir = tempfile.mkdtemp()
        self.manager = MarkdownFileManager(self.temp_dir)
    
    def test_save_and_load(self):
        """測試保存和加載"""
        test_content = "# 測試文檔\n\n內(nèi)容"
        self.manager.save_document("test", test_content)
        
        loaded = self.manager.load_document("test")
        self.assertEqual(loaded, test_content)
    
    def tearDown(self):
        import shutil
        shutil.rmtree(self.temp_dir)

if __name__ == '__main__':
    unittest.main()

import time
import random
import string

def generate_random_markdown(length=1000):
    """生成隨機(jī)Markdown內(nèi)容"""
    sections = []
    
    for _ in range(length // 100):
        # 標(biāo)題
        title_level = random.randint(1, 3)
        title = ''.join(random.choices(string.ascii_letters, k=10))
        sections.append('#' * title_level + ' ' + title)
        
        # 段落
        paragraph = ' '.join(''.join(random.choices(string.ascii_letters, k=5)) 
                           for _ in range(20))
        sections.append(paragraph)
        
        # 代碼塊
        if random.random() > 0.7:
            code = '\n'.join(''.join(random.choices(string.printable, k=30)) 
                           for _ in range(5))
            sections.append(f"```python\n[code]\n```")
    
    return '\n\n'.join(sections)

def performance_test():
    """性能測試"""
    converter = EnhancedMarkdownConverter()
    
    # 生成測試數(shù)據(jù)
    test_data = generate_random_markdown(5000)
    
    # 測試轉(zhuǎn)換性能
    start_time = time.time()
    result = converter.convert(test_data)
    end_time = time.time()
    
    print(f"轉(zhuǎn)換性能: {len(test_data)} 字符 -> {len(result)} 字符")
    print(f"耗時(shí): {end_time - start_time:.4f} 秒")
    print(f"速度: {len(test_data) / (end_time - start_time) / 1000:.2f} K字符/秒")

if __name__ == "__main__":
    performance_test()

# wsgi.py
from your_app import app

if __name__ == "__main__":
    app.run()

pip install gunicorn
gunicorn -w 4 -b 0.0.0.0:5000 wsgi:app

from flask import Flask
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

app = Flask(__name__)
limiter = Limiter(
    app,
    key_func=get_remote_address,
    default_limits=["200 per day", "50 per hour"]
)

@app.route('/api/preview', methods=['POST'])
@limiter.limit("10 per minute")  # 限制預(yù)覽頻率
def api_preview():
    # ... 原有代碼