umsc 0.1.0

Uyghur multi-script converter for Arabic, Latin, Yengi, Cyrillic, XJUS, and Uzbek Latin scripts
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

# umsc

`umsc` is a Rust library for converting Uyghur text between multiple writing systems.

It is a port of the original Python `UgMultiScriptConverter` and supports conversions between:

- `UAS` - Uyghur Arabic Script
- `ULS` - Uyghur Latin Script
- `UYS` - Uyghur Yengi Script
- `CTS` - Common Turkic Script
- `UCS` - Uyghur Cyrillic Script
- `XJUS` - Xinjiang University English Case Sensitive
- `UZLS` - Uzbek Latin Script
- `IPA` - IPA output from `CTS`

## Installation

Add the crate to your project:

```bash
cargo add umsc
```

Or add it manually to `Cargo.toml`:

```toml
[dependencies]
umsc = "0.1.0"
```

## Usage

### Convert with the top-level function

```rust
use umsc::{convert, Script};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arabic = "ئاپ";
    let latin = convert(arabic, Script::Uas, Script::Uls)?;

    assert_eq!(latin, "ap");
    Ok(())
}
```

### Reuse a converter instance

```rust
use umsc::{Script, UgMultiScriptConverter};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let converter = UgMultiScriptConverter::new(Script::Cts, Script::Uas);
    let text = converter.convert("ap")?;

    assert_eq!(text, "ئاپ");
    Ok(())
}
```

### Parse scripts from strings

```rust
use std::str::FromStr;
use umsc::{convert, Script};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let source = Script::from_str("uas")?;
    let target = Script::from_str("ucs")?;
    let text = convert("ئاپ", source, target)?;

    assert_eq!(text, "ап");
    Ok(())
}
```

## Supported conversions

The library only exposes the conversion pairs implemented by the original Python logic. For example:

- `UAS -> CTS`, `ULS`, `UCS`, `UYS`, `UZLS`
- `ULS -> CTS`, `UAS`, `UCS`, `UYS`
- `UYS -> CTS`, `UAS`, `ULS`, `UCS`
- `UCS -> CTS`, `UAS`, `ULS`, `UYS`
- `XJUS -> CTS`, `UAS`
- `UZLS -> CTS`
- `CTS -> UAS`, `ULS`, `UYS`, `UCS`, `UZLS`, `XJUS`, `IPA`

Unsupported pairs return an error.

## Notes

- Conversion behavior follows the original Python script as closely as practical.
- Some transliteration paths are table-driven and order-sensitive by design.
- This crate is a library only; it does not currently provide a CLI binary.