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
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

use crate::modules::core::unknown_handler::TransliterationMetadata;
use thiserror::Error;

pub mod tokens;
pub mod trait_based_converter;
pub use tokens::{AbugidaToken, AlphabetToken, HubToken, HubTokenSequence};

#[derive(Error, Debug, Clone)]
pub enum HubError {
    #[error("Invalid input: {0}")]
    InvalidInput(String),
    #[error("Mapping not found: {0}")]
    MappingNotFound(String),
    #[error("Conversion failed: {0}")]
    ConversionFailed(String),
}

/// Hub format representation - token-based only
#[derive(Debug, Clone, PartialEq)]
pub enum HubFormat {
    // Token-based formats only
    AbugidaTokens(HubTokenSequence),
    AlphabetTokens(HubTokenSequence),
}

impl HubFormat {
    /// Convert tokens to string representation
    pub fn to_debug_string(&self) -> String {
        match self {
            HubFormat::AbugidaTokens(tokens) => {
                // Simple debug representation showing token names
                tokens
                    .iter()
                    .map(|t| format!("{:?}", t))
                    .collect::<Vec<_>>()
                    .join(" ")
            }
            HubFormat::AlphabetTokens(tokens) => {
                // Simple debug representation showing token names
                tokens
                    .iter()
                    .map(|t| format!("{:?}", t))
                    .collect::<Vec<_>>()
                    .join(" ")
            }
        }
    }

    /// Check if this is abugida format
    pub fn is_abugida(&self) -> bool {
        matches!(self, HubFormat::AbugidaTokens(_))
    }

    /// Check if this is alphabet format
    pub fn is_alphabet(&self) -> bool {
        matches!(self, HubFormat::AlphabetTokens(_))
    }
}

// Type aliases for backward compatibility
pub type HubInput = HubFormat;
pub type HubOutput = HubFormat;

#[derive(Debug, Clone)]
pub struct HubResult {
    pub output: HubOutput,
    pub metadata: Option<TransliterationMetadata>,
}

/// Core hub trait for token-based bidirectional conversion
pub trait HubTrait {
    /// Three conversion methods - simplified for clarity
    fn abugida_to_alphabet_tokens(
        &self,
        tokens: &HubTokenSequence,
    ) -> Result<HubTokenSequence, HubError>;
    fn alphabet_to_abugida_tokens(
        &self,
        tokens: &HubTokenSequence,
    ) -> Result<HubTokenSequence, HubError>;
    fn identity_transform(&self, tokens: &HubTokenSequence) -> Result<HubTokenSequence, HubError> {
        // Default implementation - just clone
        Ok(tokens.clone())
    }

    /// Generic conversion between hub formats - routes to appropriate method
    fn convert(&self, input: &HubInput, target_is_alphabet: bool) -> Result<HubOutput, HubError> {
        match (input, target_is_alphabet) {
            (HubFormat::AbugidaTokens(tokens), true) => {
                let alphabet_tokens = self.abugida_to_alphabet_tokens(tokens)?;
                Ok(HubFormat::AlphabetTokens(alphabet_tokens))
            }
            (HubFormat::AbugidaTokens(tokens), false) => {
                let abugida_tokens = self.identity_transform(tokens)?;
                Ok(HubFormat::AbugidaTokens(abugida_tokens))
            }
            (HubFormat::AlphabetTokens(tokens), false) => {
                let abugida_tokens = self.alphabet_to_abugida_tokens(tokens)?;
                Ok(HubFormat::AbugidaTokens(abugida_tokens))
            }
            (HubFormat::AlphabetTokens(tokens), true) => {
                let alphabet_tokens = self.identity_transform(tokens)?;
                Ok(HubFormat::AlphabetTokens(alphabet_tokens))
            }
        }
    }

    /// Generic conversion with metadata
    fn convert_with_metadata(&self, input: &HubInput) -> Result<HubResult, HubError> {
        match input {
            HubFormat::AbugidaTokens(tokens) => {
                let alphabet_tokens = self.abugida_to_alphabet_tokens(tokens)?;
                Ok(HubResult {
                    output: HubFormat::AlphabetTokens(alphabet_tokens),
                    metadata: None,
                })
            }
            HubFormat::AlphabetTokens(tokens) => {
                let abugida_tokens = self.alphabet_to_abugida_tokens(tokens)?;
                Ok(HubResult {
                    output: HubFormat::AbugidaTokens(abugida_tokens),
                    metadata: None,
                })
            }
        }
    }
}

/// Central hub implementing token-based conversions
pub struct Hub {}

impl Hub {
    pub fn new() -> Self {
        Self {}
    }
}

impl HubTrait for Hub {
    fn abugida_to_alphabet_tokens(
        &self,
        tokens: &HubTokenSequence,
    ) -> Result<HubTokenSequence, HubError> {
        // Use trait-based implementation with generated mappings
        trait_based_converter::TraitBasedConverter::abugida_to_alphabet(tokens)
    }

    fn alphabet_to_abugida_tokens(
        &self,
        tokens: &HubTokenSequence,
    ) -> Result<HubTokenSequence, HubError> {
        // Use trait-based implementation with generated mappings
        trait_based_converter::TraitBasedConverter::alphabet_to_abugida(tokens)
    }
}

impl Default for Hub {
    fn default() -> Self {
        Self::new()
    }
}

// Token-based hub tests
#[cfg(test)]
mod token_tests;