Add fraction parsing module with LaTeX/Unicode support

diyung0 · diyung0 · commit c058df6d6bb1 · 2025-10-27T00:25:23.000+09:00
diff --git a/libs/braillify/src/char_struct.rs b/libs/braillify/src/char_struct.rs
@@ -1,4 +1,4 @@
-use crate::{math_symbol_shortcut::is_math_symbol_char, symbol_shortcut::is_symbol_char};
+use crate::{math_symbol_shortcut::is_math_symbol_char, symbol_shortcut::is_symbol_char, fraction::is_unicode_fraction};
 
 /// Character in Korean
 #[derive(Debug)]
@@ -58,6 +58,7 @@ pub enum CharType {
     Number(char),
     Symbol(char),
     MathSymbol(char),
+    Fraction(char), 
     Space(char),
 }
 
@@ -75,6 +76,9 @@ impl CharType {
         if is_math_symbol_char(c) {
             return Ok(Self::MathSymbol(c));
         }
+        if is_unicode_fraction(c) { 
+            return Ok(Self::Fraction(c));
+        }
         let code = c as u32;
         if (0x3131..=0x3163).contains(&code) {
             return Ok(Self::KoreanPart(c));
@@ -144,6 +148,9 @@ mod test {
                 CharType::Space(ch) => {
                     assert!(ch.is_whitespace());
                 }
+                CharType::Fraction(ch) => {
+                    assert!(is_unicode_fraction(ch));
+                }
             }
         }
     }
diff --git a/libs/braillify/src/fraction.rs b/libs/braillify/src/fraction.rs
@@ -0,0 +1,166 @@
+use unicode_normalization::UnicodeNormalization;
+
+const FRACTION_SLASH: char = '\u{2044}';
+
+fn consume_whitespace(iter: &mut std::iter::Peekable<std::str::Chars>) {
+    while let Some(c) = iter.peek() {
+        if c.is_whitespace() {
+            iter.next();
+        } else {
+            break;
+        }
+    }
+}
+
+fn encode_number_string(s: &str, part_name: &str) -> Result<Vec<u8>, String> {
+    let mut result = Vec::new();
+    for c in s.chars() {
+        if !c.is_ascii_digit() {
+            return Err(format!("Invalid {} part (non-ascii digit): {}", part_name, c));
+        }
+        result.extend(crate::number::encode_number(c));
+    }
+    Ok(result)
+}
+
+pub fn encode_fraction(numerator: &str, denominator: &str) -> Result<Vec<u8>, String> {
+    let mut result = vec![60];
+    result.extend(encode_number_string(denominator, "fraction denominator")?);
+    result.push(12);
+    result.push(60);
+    result.extend(encode_number_string(numerator, "fraction numerator")?);
+    Ok(result)
+}
+
+pub fn encode_fraction_in_context(numerator: &str, denominator: &str) -> Result<Vec<u8>, String> {
+    let mut result = vec![60];
+    result.extend(encode_number_string(numerator, "fraction numerator")?);
+    result.push(56);
+    result.push(12);
+    result.push(60);
+    result.extend(encode_number_string(denominator, "fraction denominator")?);
+    Ok(result)
+}
+
+pub fn encode_mixed_fraction(whole: &str, numerator: &str, denominator: &str) -> Result<Vec<u8>, String> {
+    let mut result = vec![60];
+    result.extend(encode_number_string(whole, "whole number")?);
+    result.extend(encode_fraction(numerator, denominator)?);
+    Ok(result)
+}
+
+fn normalize_digit(c: char) -> Option<char> {
+    match c {
+        '0' | '⁰' | '₀' => Some('0'),
+        '1' | '¹' | '₁' => Some('1'),
+        '2' | '²' | '₂' => Some('2'),
+        '3' | '³' | '₃' => Some('3'),
+        '4' | '⁴' | '₄' => Some('4'),
+        '5' | '⁵' | '₅' => Some('5'),
+        '6' | '⁶' | '₆' => Some('6'),
+        '7' | '⁷' | '₇' => Some('7'),
+        '8' | '⁸' | '₈' => Some('8'),
+        '9' | '⁹' | '₉' => Some('9'),
+        _ => None,
+    }
+}
+
+fn read_braced_content(
+    iter: &mut std::iter::Peekable<std::str::Chars>
+) -> Option<String> {
+    consume_whitespace(iter);
+    
+    if iter.next()? != '{' { return None; }
+
+    let mut content = String::new();
+    while let Some(c) = iter.peek() {
+        match c {
+            '}' => {
+                iter.next();
+                return if content.is_empty() { None } else { Some(content) };
+            }
+            _ if c.is_whitespace() => {
+                iter.next();
+            }
+            _ => {
+                if let Some(digit) = normalize_digit(*c) {
+                    content.push(digit);
+                    iter.next();
+                } else {
+                    return None;
+                }
+            }
+        }
+    }
+    None
+}
+
+pub fn parse_latex_fraction(s: &str) -> Option<(Option<String>, String, String)> {
+    let mut iter = s.trim().chars().peekable();
+
+    if iter.next()? != '$' { return None; }
+
+    consume_whitespace(&mut iter);
+
+    let mut whole_part_str = String::new();
+    while let Some(digit) = iter.peek().and_then(|c| normalize_digit(*c)) {
+        whole_part_str.push(digit);
+        iter.next();
+    }
+    let whole_part = if whole_part_str.is_empty() { None } else { Some(whole_part_str) };
+
+    consume_whitespace(&mut iter);
+    
+    if iter.next() != Some('\\') ||
+       iter.next() != Some('f') ||
+       iter.next() != Some('r') ||
+       iter.next() != Some('a') ||
+       iter.next() != Some('c') {
+        return None;
+    }
+
+    let numerator = read_braced_content(&mut iter)?;
+    let denominator = read_braced_content(&mut iter)?;
+
+    consume_whitespace(&mut iter);
+    
+    if iter.next()? != '$' { return None; }
+
+    consume_whitespace(&mut iter);
+    
+    if iter.next().is_some() {
+        return None;
+    }
+
+    Some((whole_part, numerator, denominator))
+}
+
+pub fn parse_unicode_fraction(c: char) -> Option<(String, String)> {
+    let decomposed = c.nfkd().collect::<String>();
+    if !decomposed.contains(FRACTION_SLASH) {
+        return None;
+    }
+
+    let parts: Vec<&str> = decomposed.split(FRACTION_SLASH).collect();
+
+    if parts.len() == 2 {
+        let num_str = parts[0].trim();
+        let den_str = parts[1].trim();
+        if num_str.is_empty() || den_str.is_empty() {
+            return None;
+        }
+        if !num_str.chars().all(|c| c.is_ascii_digit()) {
+            return None; 
+        }
+        if !den_str.chars().all(|c| c.is_ascii_digit()) {
+            return None; 
+        }
+        Some((num_str.to_string(), den_str.to_string()))
+    } else {
+        None
+    }
+}
+
+pub fn is_unicode_fraction(c: char) -> bool {
+  parse_unicode_fraction(c).is_some()
+}
diff --git a/libs/braillify/src/lib.rs b/libs/braillify/src/lib.rs
@@ -1,6 +1,8 @@
 use jauem::choseong::encode_choseong;
 use moeum::jungsong::encode_jungsong;
 use utils::has_choseong_o;
+use once_cell::sync::Lazy;
+use regex::Regex;
 
 use crate::{
     char_struct::CharType,
@@ -11,6 +13,11 @@ use crate::{
     split::split_korean_jauem,
 };
 
+static FRACTION_REGEX: Lazy<Regex> = Lazy::new(|| {
+    Regex::new(r#"^(\d+)\/(\d+)"#)
+        .expect("Failed to compile FRACTION_REGEX")
+});
+
 mod char_shortcut;
 mod char_struct;
 #[cfg(feature = "cli")]
@@ -29,6 +36,7 @@ mod symbol_shortcut;
 mod unicode;
 mod utils;
 mod word_shortcut;
+mod fraction;
 
 pub struct Encoder {
     is_english: bool,
@@ -74,6 +82,16 @@ impl Encoder {
         skip_count: &mut usize,
         result: &mut Vec<u8>,
     ) -> Result<(), String> {
+        if word.starts_with('$') && word.ends_with('$') {
+            if let Some((whole, num, den)) = fraction::parse_latex_fraction(word) {
+                if let Some(w) = whole {
+                    result.extend(fraction::encode_mixed_fraction(&w, &num, &den)?);
+                } else {
+                    result.extend(fraction::encode_fraction(&num, &den)?);
+                }
+                return Ok(());
+            }
+        }
         if let Some((_, code, rest)) = word_shortcut::split_word_shortcut(word) {
             result.extend(code);
             if !rest.is_empty() {
@@ -281,15 +299,44 @@ impl Encoder {
                     }
                     CharType::Number(c) => {
                         if !is_number {
-                            // 제43항 숫자 사이에 마침표, 쉼표, 연결표가 붙어 나올 때에는 뒤의 숫자에 수표를 적지 않는다.
+                            let remaining_word: String = word_chars[i..].iter().collect();
+
+                            if let Some(captures) = FRACTION_REGEX.captures(&remaining_word) {
+                                let numerator = &captures[1];
+                                let denominator = &captures[2];
+                                let match_len = captures[0].len();
+                                let k = i + match_len;
+
+                                let is_date_or_range = 
+                                    (numerator.len() > 1 || denominator.len() > 1) ||
+                                    (k < word_len && word_chars[k] == '/') ||
+                                    (k < word_len && word_chars[k] == '~');
+                                
+                                if !is_date_or_range {
+                                    result.extend(fraction::encode_fraction_in_context(numerator, denominator)?);
+                                    *skip_count = match_len - 1; 
+                                    is_number = true;
+                                    continue;
+                                }
+                            }
+                             // 제43항 숫자 사이에 마침표, 쉼표, 연결표가 붙어 나올 때에는 뒤의 숫자에 수표를 적지 않는다.
                             if !(i > 0 && ['.', ','].contains(&word_chars[i - 1])) {
                                 // 제40항 숫자는 수표 ⠼을 앞세워 다음과 같이 적는다.
                                 result.push(60);
                             }
                             is_number = true;
-                        }
+                        }      
                         result.extend(number::encode_number(c));
-                    }
+                    },
+                    CharType::Fraction(c) => {
+                        if let Some((num_str, den_str)) = fraction::parse_unicode_fraction(c) {
+                            result.extend(fraction::encode_fraction(
+                                &num_str,
+                                &den_str
+                            )?);
+                            is_number = true; 
+                        }
+                    },
                     CharType::Symbol(c) => {
                         if c == ','
                             && is_number

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use crate::{math_symbol_shortcut::is_math_symbol_char, symbol_shortcut::is_symbol_char};`
	`1`	`+use crate::{math_symbol_shortcut::is_math_symbol_char, symbol_shortcut::is_symbol_char, fraction::is_unicode_fraction};`
`2`	`2`
`3`	`3`	`/// Character in Korean`
`4`	`4`	`#[derive(Debug)]`
`@@ -58,6 +58,7 @@ pub enum CharType {`
`58`	`58`	`Number(char),`
`59`	`59`	`Symbol(char),`
`60`	`60`	`MathSymbol(char),`
	`61`	`+ Fraction(char),`
`61`	`62`	`Space(char),`
`62`	`63`	`}`
`63`	`64`
`@@ -75,6 +76,9 @@ impl CharType {`
`75`	`76`	`if is_math_symbol_char(c) {`
`76`	`77`	`return Ok(Self::MathSymbol(c));`
`77`	`78`	`}`
	`79`	`+ if is_unicode_fraction(c) {`
	`80`	`+ return Ok(Self::Fraction(c));`
	`81`	`+ }`
`78`	`82`	`let code = c as u32;`
`79`	`83`	`if (0x3131..=0x3163).contains(&code) {`
`80`	`84`	`return Ok(Self::KoreanPart(c));`
`@@ -144,6 +148,9 @@ mod test {`
`144`	`148`	`CharType::Space(ch) => {`
`145`	`149`	`assert!(ch.is_whitespace());`
`146`	`150`	`}`
	`151`	`+ CharType::Fraction(ch) => {`
	`152`	`+ assert!(is_unicode_fraction(ch));`
	`153`	`+ }`
`147`	`154`	`}`
`148`	`155`	`}`
`149`	`156`	`}`