full2half 0.1.1

//! # Full2Half
//!
//! A simple library for converting full-width characters to half-width characters and vice versa.
//!
//! ## References
//!
//! [Wikipedia](https://en.wikipedia.org/wiki/Halfwidth_and_Fullwidth_Forms_(Unicode_block))
//! [Unicode](https://www.unicode.org/charts/PDF/UFF00.pdf)
//!
//! ## Basic Example
//!
//! This is the most basic use case, where no customization is needed.
//!
//! ```
//! use full2half::CharacterWidth;
//!
//! let full_width_string = "Ｈｅｌｌｏ　Ｗｏｒｌｄ！";
//! let half_width_string = "Hello World!";
//!
//! assert_eq!(full_width_string.to_half_width(), half_width_string);
//! assert_eq!(half_width_string.to_full_width(), full_width_string);
//! ```
//!
//! ## Extended Example
//!
//! Furthermore this library allows to customize which charactersets and specific characters to ignore.
//!
//! ```
//! use full2half::CharacterWidth;
//!
//! let full_width_string = "Ｈｅｌｌｏ　Ｗｏｒｌｄ！";
//! let expected_string = "Hｅllo World！";
//! let ignore = vec!["！", "ｅ"];
//!
//! assert_eq!(full_width_string.to_half_width_ext(ignore, true, true, true, false).unwrap(), expected_string);
//! ```

use std::collections::HashMap;

/// Trait for converting full-width characters to half-width characters and vice versa.
pub trait CharacterWidth {
    /// Converts full-width characters to half-width characters.
    ///
    /// # Returns
    ///
    /// A String with full-width characters converted to half-width characters.
    fn to_half_width(&self) -> String;

    /// Converts half-width characters to full-width characters.
    ///
    /// # Returns
    ///
    /// A String with half-width characters converted to full-width characters.
    fn to_full_width(&self) -> String;

    /// Converts full-width characters to half-width characters, allowing to customize which characters to ignore.
    ///
    /// # Arguments
    ///
    /// * `ignore` - A vector of characters that will be ignored when converting.
    /// * `alpha` - A boolean that determines whether or not to convert alphanumeric characters.
    /// * `symbols` - A boolean that determines whether or not to convert symbols.
    /// * `kana` - A boolean that determines whether or not to convert kana characters.
    /// * `hangul` - A boolean that determines whether or not to convert hangul characters.
    ///
    /// # Errors
    ///
    /// Returns an error if any of the characters in `ignore` are not valid characters to ignore.
    ///
    /// # Returns
    ///
    /// A String with full-width characters converted to half-width characters, with the desired characters ignored.
    fn to_half_width_ext(&self, ignore: Vec<&str>, alpha: bool, symbols: bool, kana: bool, hangul: bool) -> Result<String, String>;

    /// Converts half-width characters to full-width characters, allowing to customize which characters to ignore.
    ///
    /// # Arguments
    ///
    /// * `ignore` - A vector of characters that will be ignored when converting.
    /// * `alpha` - A boolean that determines whether or not to convert alphanumeric characters.
    /// * `symbols` - A boolean that determines whether or not to convert symbols.
    /// * `kana` - A boolean that determines whether or not to convert kana characters.
    /// * `hangul` - A boolean that determines whether or not to convert hangul characters.
    ///
    /// # Errors
    ///
    /// Returns an error if any of the characters in `ignore` are not valid characters to ignore.
    ///
    /// # Returns
    ///
    /// A String with half-width characters converted to full-width characters, with the desired characters ignored.
    fn to_full_width_ext(&self, ignore: Vec<&str>, alpha: bool, symbols: bool, kana: bool, hangul: bool) -> Result<String, String>;
}

impl<T: AsRef<str>> CharacterWidth for T {
    fn to_half_width(&self) -> String {
        let map = create_map(false);
        self.replace_characters(&map)
    }

    fn to_full_width(&self) -> String {
        let map = create_map(true);
        self.replace_characters(&map)
    }

    fn to_half_width_ext(&self, ignore: Vec<&str>, alpha: bool, symbols: bool, kana: bool, hangul: bool) -> Result<String, String> {
        let map = create_map_ext(ignore, alpha, symbols, kana, hangul, false)?;
        Ok(self.replace_characters(&map))
    }

    fn to_full_width_ext(&self, ignore: Vec<&str>, alpha: bool, symbols: bool, kana: bool, hangul: bool) -> Result<String, String> {
        let map = create_map_ext(ignore, alpha, symbols, kana, hangul, true)?;
        Ok(self.replace_characters(&map))
    }
}

/// Trait for replacing characters in a string.
trait ReplaceCharacters {
    /// Replaces characters in a string by iterating over a HashMap and replacing matched keys with it's value.
    ///
    /// # Arguments
    ///
    /// * `map` - A HashMap that maps characters to be replaced with the character to replace it with.
    fn replace_characters(&self, map: &HashMap<String, String>) -> String;
}

impl<T: AsRef<str>> ReplaceCharacters for T {
    fn replace_characters(&self, map: &HashMap<String, String>) -> String {
        let mut sorted_map: Vec<_> = map.iter().collect();
        sorted_map.sort_by(|a, b| b.0.len().cmp(&a.0.len()));
    
        sorted_map.iter().fold(self.as_ref().to_string(), |acc, (k, v)| {
            acc.replace(k.as_str(), v.as_str())
        })
    }
}

/// Creates a HashMap that maps full-width characters to half-width characters or vice versa.
///
/// # Arguments
///
/// * `reverse` - A boolean that determines whether or not to reverse the mapping for
/// converting half-width characters to full-width characters.
fn create_map(reverse: bool) -> HashMap<String, String> {
    let mut map = HashMap::new();

    map.extend(create_alpha_numeric_map(reverse));
    map.extend(create_symbols_map(reverse));
    map.extend(create_kana_map(reverse));
    map.extend(create_hangul_map(reverse));

    map
}

/// Creates a HashMap that maps full-width characters to half-width characters or vice versa,
/// allowing to customize which characters to ignore.
///
/// # Arguments
///
/// * `ignore` - A vector of strings that will be ignored when converting.
/// * `alpha` - A boolean that determines whether or not to convert alphanumeric characters.
/// * `symbols` - A boolean that determines whether or not to convert symbols.
/// * `kana` - A boolean that determines whether or not to convert kana characters.
/// * `hangul` - A boolean that determines whether or not to convert hangul characters.
/// * `reverse` - A boolean that determines whether or not to reverse the mapping for
/// converting half-width characters to full-width characters.
///
/// # Errors
///
/// Returns an error if any of the characters in `ignore` are not valid characters to ignore.
/// Meaning they are not alphanumeric, symbols, kana, hangul characters or are not half-width
/// when converting to full-width and vice versa.
fn create_map_ext(
    ignore: Vec<&str>,
    alpha: bool,
    symbols: bool,
    kana: bool,
    hangul: bool,
    reverse: bool,
) -> Result<HashMap<String, String>, String> {
    let mut map = HashMap::new();

    if alpha { map.extend(create_alpha_numeric_map(reverse)); }
    if symbols { map.extend(create_symbols_map(reverse)); }
    if kana { map.extend(create_kana_map(reverse)); }
    if hangul { map.extend(create_hangul_map(reverse)); }

    for i in ignore.iter() {
        match map.remove(*i) {
            Some(_) => (),
            None => return Err(format!("'{}' is not a valid character to ignore.", i)),
        }
    }

    Ok(map)
}

/// Creates a HashMap that maps full-width characters to half-width characters for
/// alphanumeric characters.
///
/// # Arguments
///
/// * `reverse` - A boolean that determines whether or not to reverse the mapping for
/// converting half-width characters to full-width characters.
fn create_alpha_numeric_map(reverse: bool) -> HashMap<String, String> {
    let mut map = HashMap::new();

    let full_width = vec![
        "０", "１", "２", "３", "４", "５", "６", "７", "８", "９", "Ａ", "Ｂ", "Ｃ", "Ｄ", "Ｅ", "Ｆ", "Ｇ",
        "Ｈ", "Ｉ", "Ｊ", "Ｋ", "Ｌ", "Ｍ", "Ｎ", "Ｏ", "Ｐ", "Ｑ", "Ｒ", "Ｓ", "Ｔ", "Ｕ", "Ｖ", "Ｗ", "Ｘ",
        "Ｙ", "Ｚ", "ａ", "ｂ", "ｃ", "ｄ", "ｅ", "ｆ", "ｇ", "ｈ", "ｉ", "ｊ", "ｋ", "ｌ", "ｍ", "ｎ", "ｏ",
        "ｐ", "ｑ", "ｒ", "ｓ", "ｔ", "ｕ", "ｖ", "ｗ", "ｘ", "ｙ", "ｚ",
    ];

    let half_width = vec![
        "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I",
        "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b",
        "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u",
        "v", "w", "x", "y", "z",
    ];

    for (i, j) in full_width.iter().zip(half_width.iter()) {
        match reverse {
            true => map.insert(j.to_string(), i.to_string()),
            false => map.insert(i.to_string(), j.to_string()),
        };
    }

    map
}

/// Creates a HashMap that maps full-width characters to half-width characters for symbols.
///
/// # Arguments
///
/// * `reverse` - A boolean that determines whether or not to reverse the mapping for
/// converting half-width characters to full-width characters.
fn create_symbols_map(reverse: bool) -> HashMap<String, String> {
    let mut map = HashMap::new();

    let full_width = vec![
        "！", "＂", "＃", "＄", "％", "＆", "＇", "（", "）", "＊", "＋", "，", "－", "．", "／",
        "：", "；", "＜", "＝", "＞", "？", "＠", "［", "＼", "］", "＾", "＿", "｀", "｛", "｜",
        "｝", "～", "。", "、", "￠", "￡", "￢", "￣", "￤", "￥", "￦", "　",
    ];

    let half_width = vec![
        "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/",
        ":", ";", "<", "=", ">", "?", "@", "[", "\\", "]", "^", "_", "`", "{", "|",
        "}", "~", "｡", "､", "¢", "£", "¬", "¯", "¦", "¥", "₩", " ",
    ];

    for (i, j) in full_width.iter().zip(half_width.iter()) {
        match reverse {
            true => map.insert(j.to_string(), i.to_string()),
            false => map.insert(i.to_string(), j.to_string()),
        };
    }

    map
}

/// Creates a HashMap that maps full-width characters to half-width characters for
/// kana characters.
///
/// # Arguments
///
/// * `reverse` - A boolean that determines whether or not to reverse the mapping for
/// converting half-width characters to full-width characters.
fn create_kana_map(reverse: bool) -> HashMap<String, String> {
    let mut map = HashMap::new();

    let mut full_width = vec![
        "ァ", "ア", "ィ", "イ", "ゥ", "ウ", "ェ", "エ", "ォ", "オ", "カ", "ガ", "キ", "ギ", "ク",
        "グ", "ケ", "ゲ", "コ", "ゴ", "サ", "ザ", "シ", "ジ", "ス", "ズ", "セ", "ゼ", "ソ", "ゾ", "タ",
        "ダ", "チ", "ヂ", "ッ", "ツ", "ヅ", "テ", "デ", "ト", "ド", "ナ", "ニ", "ヌ", "ネ", "ノ", "ハ",
        "バ", "パ", "ヒ", "ビ", "ピ", "フ", "ブ", "プ", "ヘ", "ベ", "ペ", "ホ", "ボ", "ポ", "マ", "ミ",
        "ム", "メ", "モ", "ャ", "ヤ", "ュ", "ユ", "ョ", "ヨ", "ラ", "リ", "ル", "レ", "ロ", "ヮ", "ワ",
        "ヲ", "ン", "ヴ", "ヷ", "ヺ", "・", "ー", "「", "」",
    ];

    let mut half_width = vec![
        "ｧ", "ｱ", "ｨ", "ｲ", "ｩ", "ｳ", "ｪ", "ｴ", "ｫ", "ｵ", "ｶ", "ｶﾞ", "ｷ", "ｷﾞ", "ｸ",
        "ｸﾞ", "ｹ", "ｹﾞ", "ｺ", "ｺﾞ", "ｻ", "ｻﾞ", "ｼ", "ｼﾞ", "ｽ", "ｽﾞ", "ｾ", "ｾﾞ", "ｿ", "ｿﾞ", "ﾀ",
        "ﾀﾞ", "ﾁ", "ﾁﾞ", "ｯ", "ﾂ", "ﾂﾞ", "ﾃ", "ﾃﾞ", "ﾄ", "ﾄﾞ", "ﾅ", "ﾆ", "ﾇ", "ﾈ", "ﾉ", "ﾊ",
        "ﾊﾞ", "ﾊﾟ", "ﾋ", "ﾋﾞ", "ﾋﾟ", "ﾌ", "ﾌﾞ", "ﾌﾟ", "ﾍ", "ﾍﾞ", "ﾍﾟ", "ﾎ", "ﾎﾞ", "ﾎﾟ", "ﾏ", "ﾐ",
        "ﾑ", "ﾒ", "ﾓ", "ｬ", "ﾔ", "ｭ", "ﾕ", "ｮ", "ﾖ", "ﾗ", "ﾘ", "ﾙ", "ﾚ", "ﾛ", "ﾜ", "ﾜ",
        "ｦ", "ﾝ", "ｳﾞ", "ﾜﾞ", "ｦﾞ", "･", "ｰ", "｢", "｣",
    ];

    if !reverse {
        full_width.push("ヵ");
        half_width.push("ｶ");

        full_width.push("ヶ");
        half_width.push("ｹ");
    }

    for (i, j) in full_width.iter().zip(half_width.iter()) {
        match reverse {
            true => map.insert(j.to_string(), i.to_string()),
            false => map.insert(i.to_string(), j.to_string()),
        };
    }

    map
}

/// Creates a HashMap that maps full-width characters to half-width characters for
/// hangul characters.
///
/// # Arguments
///
/// * `reverse` - A boolean that determines whether or not to reverse the mapping for
/// converting half-width characters to full-width characters.
fn create_hangul_map(reverse: bool) -> HashMap<String, String> {
    let mut map = HashMap::new();

    let full_width = vec![
        "ㄱ", "ㄲ", "ㄳ", "ㄴ", "ㄵ", "ㄶ", "ㄷ", "ㄸ", "ㄹ", "ㄺ", "ㄻ", "ㄼ", "ㄽ", "ㄾ", "ㄿ", // U+313x
        "ㅀ", "ㅁ", "ㅂ", "ㅃ", "ㅄ", "ㅅ", "ㅆ", "ㅇ", "ㅈ", "ㅉ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ", // U+314x
        "ㅏ", "ㅐ", "ㅑ", "ㅒ", "ㅓ", "ㅔ", "ㅕ", "ㅖ", "ㅗ", "ㅘ", "ㅙ", "ㅚ", // U+314F, U+315x
        "ㅛ", "ㅜ", "ㅝ", "ㅞ", "ㅟ", "ㅠ", "ㅡ", "ㅢ", "ㅣ", // U+315B-F, U+316x
    ];

    let half_width = vec![
        "ﾡ", "ﾢ", "ﾣ", "ﾤ", "ﾥ", "ﾦ", "ﾧ", "ﾨ", "ﾩ", "ﾪ", "ﾫ", "ﾬ", "ﾭ", "ﾮ", "ﾯ", // U+FFAx
        "ﾰ", "ﾱ", "ﾲ", "ﾳ", "ﾴ", "ﾵ", "ﾶ", "ﾷ", "ﾸ", "ﾹ", "ﾺ", "ﾻ", "ﾼ", "ﾽ", "ﾾ", // U+FFBx
        "ￂ", "ￃ", "ￄ", "ￅ", "ￆ", "ￇ", "ￊ", "ￋ", "ￌ", "ￍ", "ￎ", "ￏ", // U+FFCx
        "ￒ", "ￓ", "ￔ", "ￕ", "ￖ", "ￗ", "ￚ", "ￛ", "ￜ", // U+FFDx
    ];

    for (i, j) in full_width.iter().zip(half_width.iter()) {
        match reverse {
            true => map.insert(j.to_string(), i.to_string()),
            false => map.insert(i.to_string(), j.to_string()),
        };
    }

    map
}

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

    #[test]
    fn test_alpha_numeric_map() {
        let full_width = "０１２３４５６７８９ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ";
        let half_width = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

        for (full, half) in full_width.chars().zip(half_width.chars()) {
            assert_eq!(full.to_string().to_half_width(), half.to_string());
            assert_eq!(half.to_string().to_full_width(), full.to_string());
        }
    }

    #[test]
    fn test_symbols_map() {
        let full_width = "！＂＃＄％＆＇（）＊＋，－．／：；＜＝＞？＠［＼］＾＿｀｛｜｝～。、￠￡￢￣￤￥￦　";
        let half_width = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~｡､¢£¬¯¦¥₩ ";

        for (full, half) in full_width.chars().zip(half_width.chars()) {
            assert_eq!(full.to_string().to_half_width(), half.to_string());
            assert_eq!(half.to_string().to_full_width(), full.to_string());
        }
    }

    #[test]
    fn test_kana_map() {
        let full_width = "ァアィイゥウェエォオカキクケコサシスセソタチッツテトナニヌネノハヒフヘホマミムメモャヤュユョヨラリルレロヮワヲン・ー「」ヵヶ";
        let half_width = "ｧｱｨｲｩｳｪｴｫｵｶｷｸｹｺｻｼｽｾｿﾀﾁｯﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓｬﾔｭﾕｮﾖﾗﾘﾙﾚﾛﾜﾜｦﾝ･ｰ｢｣ｶｹ";

        for (full, half) in full_width.chars().zip(half_width.chars()) {
            // EDGE CASE: ヮワ -> ﾜﾜ
            if full == 'ヮ' || half == 'ﾜ' {
                assert_eq!(full.to_string().to_half_width(), "ﾜ".to_string());
                assert_eq!(half.to_string().to_full_width(), "ワ".to_string());
                continue;
            }

            // EDGE CASE: ヵヶ -> ｶｹ -> カケ
            // These characters are not in the map in reverse mode.
            if full == 'ヵ' || half == 'ｶ' {
                assert_eq!(full.to_string().to_half_width(), "ｶ".to_string());
                assert_eq!(half.to_string().to_full_width(), "カ".to_string());
                continue;
            }

            if full == 'ヶ' || half == 'ｹ' {
                assert_eq!(full.to_string().to_half_width(), "ｹ".to_string());
                assert_eq!(half.to_string().to_full_width(), "ケ".to_string());
                continue;
            }

            assert_eq!(full.to_string().to_half_width(), half.to_string());
            assert_eq!(half.to_string().to_full_width(), full.to_string());
        }

        let special_full_width = "ガギグゲゴザジズゼゾダヂヅデドバパビピブプベペボポヴヷヺ";
        let special_half_width = vec![
            "ｶﾞ", "ｷﾞ", "ｸﾞ", "ｹﾞ", "ｺﾞ", "ｻﾞ", "ｼﾞ", "ｽﾞ", "ｾﾞ", "ｿﾞ", "ﾀﾞ", "ﾁﾞ", "ﾂﾞ", "ﾃﾞ", "ﾄﾞ",
            "ﾊﾞ", "ﾊﾟ", "ﾋﾞ", "ﾋﾟ", "ﾌﾞ", "ﾌﾟ", "ﾍﾞ", "ﾍﾟ", "ﾎﾞ", "ﾎﾟ", "ｳﾞ", "ﾜﾞ", "ｦﾞ"
        ];

        for (full, half) in special_full_width.chars().zip(special_half_width.iter()) {
            assert_eq!(full.to_string().to_half_width(), half.to_string());
            assert_eq!(half.to_string().to_full_width(), full.to_string());
        }
    }

    #[test]
    fn test_hangul_map() {
        let full_width = "ㄱㄲㄳㄴㄵㄶㄷㄸㄹㄺㄻㄼㄽㄾㄿㅀㅁㅂㅃㅄㅅㅆㅇㅈㅉㅊㅋㅌㅍㅎㅏㅐㅑㅒㅓㅔㅕㅖㅗㅘㅙㅚㅛㅜㅝㅞㅟㅠㅡㅢㅣ"; 
        let half_width = "ﾡﾢﾣﾤﾥﾦﾧﾨﾩﾪﾫﾬﾭﾮﾯﾰﾱﾲﾳﾴﾵﾶﾷﾸﾹﾺﾻﾼﾽﾾￂￃￄￅￆￇￊￋￌￍￎￏￒￓￔￕￖￗￚￛￜ";

        for (full, half) in full_width.chars().zip(half_width.chars()) {
            assert_eq!(full.to_string().to_half_width(), half.to_string());
            assert_eq!(half.to_string().to_full_width(), full.to_string());
        }
    }

    #[test]
    fn test_character_width_trait() {
        let full_width_string = "Ｈｅｌｌｏ　Ｗｏｒｌｄ！";
        let half_width_string = "Hello World!";
        assert_eq!(full_width_string.to_half_width(), half_width_string);

        // Alpha Numerics Ignored
        assert_eq!(
            full_width_string.to_half_width_ext(vec![], false, true, true, true).unwrap(),
            "Ｈｅｌｌｏ Ｗｏｒｌｄ!"
        );

        // Symbols Ignored
        assert_eq!(
            full_width_string.to_half_width_ext(vec![], true, false, true, true).unwrap(),
            "Hello　World！"
        );

        let full_width_string = "カタカナ";
        let half_width_string = "ｶﾀｶﾅ";
        assert_eq!(full_width_string.to_half_width(), half_width_string);

        // Kana Ignored
        assert_eq!(
            full_width_string.to_half_width_ext(vec![], true, true, false, true).unwrap(),
            full_width_string
        );

        let full_width_string = "ㅈㅉ";
        let half_width_string = "ﾸﾹ";
        assert_eq!(full_width_string.to_half_width(), half_width_string);

        // Hangul Ignored
        assert_eq!(
            full_width_string.to_half_width_ext(vec![], true, true, true, false).unwrap(),
            full_width_string
        );

        let full_width_string = "Ｈｅｌｌｏ　Ｗｏｒｌｄ！カタカナㅈㅉ";
        let half_width_string = "Hello World!ｶﾀｶﾅﾸﾹ";
        assert_eq!(full_width_string.to_half_width(), half_width_string);

        // All Ignored
        assert_eq!(
            full_width_string.to_half_width_ext(vec![], false, false, false, false).unwrap(),
            full_width_string
        );

        // Test specific characters ignored
        let full_width_string = "Ｈｅｌｌｏ　Ｗｏｒｌｄ！カタカナㅈㅉ";
        let half_width_string = "Hｅllo World！カﾀカﾅㅈﾹ";
        assert_eq!(
            full_width_string.to_half_width_ext(vec!["！", "ｅ", "カ", "ㅈ"], true, true, true, true).unwrap(),
            half_width_string
        );

        // Test invalid characters ignored
        assert!(full_width_string.to_half_width_ext(vec!["!"], true, true, true, true).is_err());
        assert!(half_width_string.to_full_width_ext(vec!["！"], true, true, true, true).is_err());
    }

    #[test]
    fn test_replace_characters_trait() {
        let mut map = HashMap::new();
        map.insert("a".to_string(), "b".to_string());

        let string = "abcdefg";
        assert_eq!(string.replace_characters(&map), "bbcdefg");
    }
}