bangla 0.1.1

A Rust crate for Bangla date, calendar, number conversion, currency, and Bangladeshi addresses.
Documentation
/// Converts an ASCII digit character to its Bengali Unicode equivalent.
fn ascii_digit_to_bangla(c: char) -> char {
    match c {
        '0' => '০',
        '1' => '১',
        '2' => '২',
        '3' => '৩',
        '4' => '৪',
        '5' => '৫',
        '6' => '৬',
        '7' => '৭',
        '8' => '৮',
        '9' => '৯',
        other => other,
    }
}

/// Converts a Bengali digit character back to its ASCII equivalent.
fn bangla_digit_to_ascii(c: char) -> Option<char> {
    match c {
        '০' => Some('0'),
        '১' => Some('1'),
        '২' => Some('2'),
        '৩' => Some('3'),
        '৪' => Some('4'),
        '৫' => Some('5'),
        '৬' => Some('6'),
        '৭' => Some('7'),
        '৮' => Some('8'),
        '৯' => Some('9'),
        _ => None,
    }
}

/// Converts a number or numeric string into Bengali digit characters.
///
/// Non-digit characters (e.g. `-`, `.`, `,`) are passed through unchanged.
///
/// # Examples
/// ```
/// use bangla::number::to_bangla_digits;
/// assert_eq!(to_bangla_digits(1234), "১২৩৪");
/// assert_eq!(to_bangla_digits(0),    "০");
/// ```
pub fn to_bangla_digits<N: ToString>(n: N) -> String {
    n.to_string().chars().map(ascii_digit_to_bangla).collect()
}

/// Converts a string of Bengali digits back to an ASCII digit string.
///
/// Any character that is not a Bengali digit is passed through unchanged,
/// so mixed strings (e.g. `"১২৩৪.৫৬"`) are handled gracefully.
///
/// # Examples
/// ```
/// use bangla::number::from_bangla_digits;
/// assert_eq!(from_bangla_digits("১২৩৪"), "1234");
/// assert_eq!(from_bangla_digits("১২৩৪.৫৬"), "1234.56");
/// ```
pub fn from_bangla_digits(s: &str) -> String {
    s.chars()
        .map(|c| bangla_digit_to_ascii(c).unwrap_or(c))
        .collect()
}

/// Parses a Bengali digit string into a `u64`.
///
/// Returns `None` if the string (after digit conversion) is not a valid integer.
///
/// # Examples
/// ```
/// use bangla::number::parse_bangla_digits;
/// assert_eq!(parse_bangla_digits("১২৩৪"), Some(1234u64));
/// assert_eq!(parse_bangla_digits("abc"),  None);
/// ```
pub fn parse_bangla_digits(s: &str) -> Option<u64> {
    from_bangla_digits(s).parse().ok()
}

/// Formats a number using the South Asian lakh/crore grouping system
/// and renders the digits in Bengali.
///
/// Groups: ones (3 digits), then pairs (lakhs, crores, …).
///
/// # Examples
/// ```
/// use bangla::number::to_bangla_currency;
/// assert_eq!(to_bangla_currency(1_23_456), "১,২৩,৪৫৬");
/// assert_eq!(to_bangla_currency(1000),     "১,০০০");
/// assert_eq!(to_bangla_currency(99),       "৯৯");
/// ```
pub fn to_bangla_currency(amount: u64) -> String {
    let ascii = amount.to_string();
    let digits: Vec<char> = ascii.chars().collect();
    let len = digits.len();

    // Build groups: last 3, then pairs from right to left
    let mut groups: Vec<&[char]> = Vec::new();
    if len <= 3 {
        groups.push(&digits[..]);
    } else {
        groups.push(&digits[len - 3..]);
        let mut pos = len - 3;
        while pos > 0 {
            let start = if pos >= 2 { pos - 2 } else { 0 };
            groups.push(&digits[start..pos]);
            pos = start;
        }
        groups.reverse();
    }

    groups
        .iter()
        .map(|g| {
            g.iter()
                .map(|&c| ascii_digit_to_bangla(c))
                .collect::<String>()
        })
        .collect::<Vec<_>>()
        .join(",")
}

/// Formats a monetary amount as a full Bangla currency string (টাকা).
///
/// # Examples
/// ```
/// use bangla::number::format_taka;
/// assert_eq!(format_taka(1_23_456), "১,২৩,৪৫৬ টাকা");
/// ```
pub fn format_taka(amount: u64) -> String {
    format!("{} টাকা", to_bangla_currency(amount))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_to_bangla_digits() {
        assert_eq!(to_bangla_digits(0u32), "০");
        assert_eq!(to_bangla_digits(1234u32), "১২৩৪");
        assert_eq!(to_bangla_digits(1431u32), "১৪৩১");
    }

    #[test]
    fn test_from_bangla_digits() {
        assert_eq!(from_bangla_digits("১২৩৪"), "1234");
        assert_eq!(from_bangla_digits("০"), "0");
        assert_eq!(from_bangla_digits("১২৩৪.৫৬"), "1234.56");
    }

    #[test]
    fn test_parse_bangla_digits() {
        assert_eq!(parse_bangla_digits("১২৩৪"), Some(1234));
        assert_eq!(parse_bangla_digits("abc"), None);
    }

    #[test]
    fn test_currency_grouping() {
        assert_eq!(to_bangla_currency(99), "৯৯");
        assert_eq!(to_bangla_currency(1000), "১,০০০");
        assert_eq!(to_bangla_currency(12345), "১২,৩৪৫");
        assert_eq!(to_bangla_currency(123456), "১,২৩,৪৫৬");
        assert_eq!(to_bangla_currency(1_00_00_000), "১,০০,০০,০০০");
    }

    #[test]
    fn test_format_taka() {
        assert_eq!(format_taka(500), "৫০০ টাকা");
    }
}