html-translation-lib 0.1.0

高性能HTML翻译库，专为网页本地化设计，提供智能缓存、并发批处理和内存优化功能
Documentation 
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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//! 同步翻译示例
//! 
//! 演示如何在非异步环境中使用同步翻译接口

use html_translation_lib::translate_html_content_sync;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("HTML翻译库 - 同步使用示例");
    println!("{}", "=".repeat(50));
    
    // 示例HTML内容
    let html_content = r#"
    <html>
    <head>
        <title>Synchronous Translation Example</title>
    </head>
    <body>
        <h1>Welcome to Sync Translation</h1>
        <p>This example demonstrates synchronous HTML translation.</p>
        <p>The content will be translated without using async/await syntax.</p>
        
        <section>
            <h2>Benefits of Synchronous API</h2>
            <ul>
                <li>Easy integration with legacy code</li>
                <li>No async runtime required</li>
                <li>Simpler error handling</li>
                <li>Compatible with blocking operations</li>
            </ul>
        </section>
        
        <footer>
            <p>Translation completed in synchronous mode.</p>
        </footer>
    </body>
    </html>
    "#;
    
    println!("\n📄 原始HTML内容:");
    println!("{}", "=".repeat(40));
    println!("{}", html_content);
    println!("{}", "=".repeat(40));
    
    println!("\n🔄 开始同步翻译...");
    let start_time = std::time::Instant::now();
    
    // 使用同步API进行翻译
    let translated_html = translate_html_content_sync(
        html_content,
        "zh",  // 目标语言：中文
        Some("http://localhost:1188/translate")  // API地址
    )?;
    
    let duration = start_time.elapsed();
    println!("✅ 翻译完成！耗时: {:?}", duration);
    
    println!("\n📄 翻译后的HTML内容:");
    println!("{}", "=".repeat(40));
    println!("{}", translated_html);
    println!("{}", "=".repeat(40));
    
    // 保存结果
    std::fs::write("sync_translated.html", &translated_html)?;
    println!("\n💾 翻译结果已保存到: sync_translated.html");
    
    println!("\n📊 处理摘要:");
    println!("   原文长度: {} 字符", html_content.len());
    println!("   译文长度: {} 字符", translated_html.len());
    println!("   处理时间: {:?}", duration);
    
    // 演示错误处理
    println!("\n🧪 演示错误处理...");
    match translate_html_content_sync("", "zh", Some("http://invalid-url")) {
        Ok(_) => println!("意外成功"),
        Err(e) => println!("✅ 正确捕获错误: {}", e),
    }
    
    println!("\n🎉 同步翻译示例完成！");
    
    Ok(())
}

/// 演示在传统函数中使用同步API
fn process_html_file(file_path: &str) -> Result<String, Box<dyn std::error::Error>> {
    println!("📁 处理文件: {}", file_path);
    
    // 读取文件
    let content = std::fs::read_to_string(file_path)?;
    
    // 翻译内容
    let translated = translate_html_content_sync(
        &content,
        "zh",
        Some("http://localhost:1188/translate")
    )?;
    
    // 返回翻译结果
    Ok(translated)
}

/// 演示批量文件处理
fn batch_process_files(file_paths: &[&str]) -> Result<Vec<String>, Box<dyn std::error::Error>> {
    let mut results = Vec::new();
    
    for &path in file_paths {
        match process_html_file(path) {
            Ok(translated) => {
                results.push(translated);
                println!("✅ 成功处理: {}", path);
            }
            Err(e) => {
                println!("❌ 处理失败 {}: {}", path, e);
                // 继续处理其他文件
            }
        }
    }
    
    Ok(results)
}