use std::{collections::HashMap, sync::OnceLock};
use crate::error::TableError;
const BUILTIN_TSV: &str = include_str!("../data/marspeak.tsv");
static BUILTIN: OnceLock<Table> = OnceLock::new();
#[derive(Debug)]
pub struct Table {
forward: Vec<(char, Box<[char]>)>,
reverse: Vec<(char, char)>,
}
impl Table {
pub fn builtin() -> &'static Table {
BUILTIN.get_or_init(|| Table::parse(BUILTIN_TSV).expect("内置映射表损坏"))
}
pub fn candidates(&self, ch: char) -> Option<&[char]> {
let idx = self.forward.binary_search_by_key(&ch, |k| k.0).ok()?;
Some(self.forward[idx].1.as_ref())
}
pub fn original(&self, ch: char) -> Option<char> {
let idx = self.reverse.binary_search_by_key(&ch, |k| k.0).ok()?;
Some(self.reverse[idx].1)
}
pub fn parse(source: &str) -> Result<Self, TableError> {
let text = source.trim_start_matches('\u{feff}');
let mut forward = Vec::new();
let mut sources: HashMap<char, usize> = HashMap::new();
let mut owners: HashMap<char, char> = HashMap::new();
let mut reverse: Vec<(char, char)> = Vec::new();
for (i, raw) in text.lines().enumerate() {
let line_no = i + 1;
let t = raw.trim_matches(|c: char| c == ' ' || c == '\r');
if t.is_empty() || t.starts_with("#") {
continue;
}
let Some((src, cands)) = t.split_once('\t') else {
return Err(TableError::MissingColumn { line: line_no });
};
let Ok(src) = src.parse::<char>() else {
return Err(TableError::InvalidField {
line: line_no,
field: "source",
value: src.to_string(),
});
};
if sources.insert(src, line_no).is_some() {
return Err(TableError::DuplicateSource {
line: line_no,
ch: src,
});
}
let mut forward_cands_vec = vec![];
for cand in cands.split(',') {
let Ok(cand) = cand.parse::<char>() else {
return Err(TableError::InvalidField {
line: line_no,
field: "candidate",
value: cand.to_string(),
});
};
if src == cand {
return Err(TableError::SelfMapping {
line: line_no,
ch: src,
});
}
if let Some(owner) = owners.insert(cand, src) {
return Err(TableError::DuplicateCandidate {
line: line_no,
candidate: cand,
owner,
});
}
reverse.push((cand, src));
forward_cands_vec.push(cand);
}
forward.push((src, forward_cands_vec.into_boxed_slice()));
}
for (src, line_no) in sources.iter() {
if owners.contains_key(src) {
return Err(TableError::ChainedCandidate {
line: *line_no,
candidate: *src,
});
}
}
forward.sort_unstable_by_key(|e| e.0);
reverse.sort_unstable_by_key(|e| e.0);
Ok(Table { forward, reverse })
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_invalid_field() {
let cases = [
("我\tωǒ", 1), ("ab\t莪", 1), ("我\t莪,,沃", 1), ];
for (input, want_line) in cases {
let err = Table::parse(input).unwrap_err();
assert!(
matches!(err, TableError::InvalidField { line, .. } if line == want_line),
"input {input:?} 应报 InvalidField(line = {want_line}),实际是 {err}"
);
}
}
#[test]
fn test_missing_column() {
let err = Table::parse("我 莪").unwrap_err();
assert!(
matches!(err, TableError::MissingColumn { line: 1 }),
"{err}"
);
}
#[test]
fn test_invalid_field_reports_real_line_number() {
let err = Table::parse("# 这是一条注释\n我\tωǒ").unwrap_err();
assert!(
matches!(err, TableError::InvalidField { line: 2, .. }),
"{err}"
);
}
#[test]
fn test_builtin_table_parses() {
let t = Table::builtin();
assert_eq!(t.candidates('万'), Some(['萭', '萬'].as_slice()));
assert_eq!(t.original('萭'), Some('万'));
assert_eq!(t.original('與'), Some('与'));
}
#[test]
fn test_success_path() {
let t = Table::parse("万\t萭,萬\n与\t玙").unwrap();
assert_eq!(t.candidates('万'), Some(['萭', '萬'].as_slice()));
assert_eq!(t.candidates('与'), Some(['玙'].as_slice()));
assert_eq!(t.candidates('喵'), None);
assert_eq!(t.original('萭'), Some('万'));
assert_eq!(t.original('萬'), Some('万'));
assert_eq!(t.original('玙'), Some('与'));
}
#[test]
fn test_self_mapping() {
let err = Table::parse("我\t我").unwrap_err();
assert!(
matches!(err, TableError::SelfMapping { line: 1, ch: '我' }),
"{err}"
);
}
#[test]
fn test_accepts_any_character_as_candidate() {
for cand in [
'a', 'Z', '7', '!', '@', '😀', '✓', '①', 'ル', 'と', 'ㄖ', 'α', 'ж', '莪', '\t', ] {
let tsv = format!("我\t{cand}");
let t =
Table::parse(&tsv).unwrap_or_else(|e| panic!("候选 {cand:?} 应被接受,实际是 {e}"));
assert_eq!(
t.candidates('我'),
Some([cand].as_slice()),
"候选 {cand:?} 未登记到正向表"
);
assert_eq!(t.original(cand), Some('我'), "候选 {cand:?} 无法还原为原字");
}
}
#[test]
fn test_delimiters_cannot_be_candidates() {
for input in ["我\t,", "我\t "] {
let err = Table::parse(input).unwrap_err();
assert!(
matches!(
err,
TableError::InvalidField {
field: "candidate",
..
}
),
"input {input:?} 应报 InvalidField(candidate),实际是 {err}"
);
}
}
#[test]
fn test_duplicate_candidate() {
let err = Table::parse("我\t莪\n尔\t莪").unwrap_err();
assert!(
matches!(
err,
TableError::DuplicateCandidate {
line: 2,
candidate: '莪',
owner: '我'
}
),
"{err}"
);
}
#[test]
fn test_duplicate_source() {
let err = Table::parse("我\t莪\n我\t沃").unwrap_err();
assert!(
matches!(err, TableError::DuplicateSource { line: 2, ch: '我' }),
"{err}"
);
}
#[test]
fn test_chained_candidate() {
let err = Table::parse("我\t莪\n莪\t沃").unwrap_err();
assert!(
matches!(
err,
TableError::ChainedCandidate {
line: 2,
candidate: '莪'
}
),
"{err}"
);
}
#[test]
fn test_bom_and_crlf_are_tolerated() {
let t = Table::parse("\u{feff}我\t莪\r\n尔\t尓\r\n").unwrap();
assert_eq!(t.candidates('我'), Some(['莪'].as_slice()));
assert_eq!(t.original('尓'), Some('尔'));
}
#[test]
fn test_comments_and_blank_lines_are_skipped() {
let t = Table::parse("# 注释\n\n我\t莪\n\n# 又一条注释\n尔\t尓").unwrap();
assert_eq!(t.candidates('我'), Some(['莪'].as_slice()));
assert_eq!(t.candidates('尔'), Some(['尓'].as_slice()));
}
#[test]
fn test_builtin_table_invariants() {
let t = Table::builtin();
assert!(
t.forward.windows(2).all(|w| w[0].0 <= w[1].0),
"forward 未排序"
);
assert!(
t.reverse.windows(2).all(|w| w[0].0 <= w[1].0),
"reverse 未排序"
);
let mut cand_count = 0;
for (src, cands) in &t.forward {
assert!(!cands.is_empty(), "原字 {src:?} 没有候选");
for cand in cands.iter() {
cand_count += 1;
assert_ne!(cand, src, "原字 {src:?} 映射到自身");
assert_eq!(
t.original(*cand),
Some(*src),
"候选 {cand:?} 无法还原为 {src:?}"
);
assert!(
t.candidates(*cand).is_none(),
"候选 {cand:?} 同时也是原字,形成歧义链"
);
}
}
assert_eq!(t.reverse.len(), cand_count);
}
}