shlesha 0.5.7

High-performance extensible transliteration library with hub-and-spoke architecture
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

use shlesha::Shlesha;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Testing custom schema functionality...");

    // Create a new Shlesha instance
    let mut transliterator = Shlesha::new();

    // Test without custom schema first
    println!("\n1. Testing supported scripts before loading custom schema:");
    let scripts = transliterator.list_supported_scripts();
    println!("Built-in scripts: {:?}", scripts);

    // Try to use custom encoding before loading (should fail)
    println!("\n2. Testing custom encoding before loading schema:");
    match transliterator.transliterate("kam", "my_custom_encoding", "devanagari") {
        Ok(result) => println!("Unexpected success: {}", result),
        Err(e) => println!("Expected error: {}", e),
    }

    // Load the custom schema
    println!("\n3. Loading custom schema...");
    transliterator.load_schema_from_file("examples/custom_encoding.yaml")?;
    println!("Custom schema loaded successfully!");

    // Test if the custom script is now supported
    println!("\n4. Testing if custom script is now supported:");
    let supports_custom = transliterator.supports_script("my_custom_encoding");
    println!("Supports 'my_custom_encoding': {}", supports_custom);

    // Test conversion with custom encoding
    println!("\n5. Testing conversion with custom encoding:");
    let test_cases = vec![("k", "क"), ("kam", "कम"), ("gam", "गम"), ("pani", "पनि")];

    for (input, expected) in test_cases {
        match transliterator.transliterate(input, "my_custom_encoding", "devanagari") {
            Ok(result) => {
                println!("  '{}' -> '{}' (expected: '{}')", input, result, expected);
                if result == expected {
                    println!("    ✓ Correct!");
                } else {
                    println!("    ✗ Mismatch!");
                }
            }
            Err(e) => println!("  '{}' -> Error: {}", input, e),
        }
    }

    // Test reverse conversion (custom -> devanagari -> custom)
    println!("\n6. Testing round-trip conversion:");
    match transliterator.transliterate("kam", "my_custom_encoding", "devanagari") {
        Ok(devanagari_result) => {
            println!(
                "  my_custom_encoding -> devanagari: 'kam' -> '{}'",
                devanagari_result
            );

            // Try to convert back (this might not work perfectly yet)
            match transliterator.transliterate(
                &devanagari_result,
                "devanagari",
                "my_custom_encoding",
            ) {
                Ok(custom_result) => {
                    println!(
                        "  devanagari -> my_custom_encoding: '{}' -> '{}'",
                        devanagari_result, custom_result
                    );
                }
                Err(e) => println!("  devanagari -> my_custom_encoding: Error: {}", e),
            }
        }
        Err(e) => println!("  Error in first conversion: {}", e),
    }

    println!("\n7. Testing conversion to other scripts:");
    match transliterator.transliterate("kam", "my_custom_encoding", "iast") {
        Ok(result) => println!("  my_custom_encoding -> iast: 'kam' -> '{}'", result),
        Err(e) => println!("  my_custom_encoding -> iast: Error: {}", e),
    }

    println!("\nCustom schema test completed!");
    Ok(())
}