use crate::charset::builtin::{ASCII, ascii_definition};
use crate::charset::{
ParseError, SetCatalog, SetDefinition, SetMember, parse_line,
};
use std::collections::{BTreeSet, HashMap};
use std::sync::LazyLock;
pub(crate) const LOCALES: &str = include_str!("locales.ctrm-sets");
const PUNCTUATION: &str = "typography-";
static INDEX: LazyLock<HashMap<&'static str, &'static str>> =
LazyLock::new(|| {
let mut index = HashMap::new();
for line in LOCALES.lines() {
if let Some((head, _)) = line.split_once(' ') {
index.entry(head).or_insert(line);
}
}
index
});
fn line_of(name: &str) -> Option<&'static str> {
INDEX.get(name).copied()
}
fn compiled(name: &str) -> Result<Option<SetDefinition>, ParseError> {
match line_of(name).map(parse_line).transpose()?.flatten() {
Some(definition) => inlined(definition).map(Some),
None => Ok(None),
}
}
fn inlined(definition: SetDefinition) -> Result<SetDefinition, ParseError> {
let mut members = Vec::new();
for member in definition.members {
members.extend(parent_of(member)?);
}
Ok(SetDefinition {
name: definition.name,
members,
})
}
fn parent_of(member: SetMember) -> Result<Vec<SetMember>, ParseError> {
Ok(match member {
SetMember::Named(name) if name == ASCII => ascii_definition().members,
SetMember::Named(name) => match compiled(&name)? {
Some(found) => found.members,
None => vec![SetMember::Named(name)],
},
other => vec![other],
})
}
fn named(member: &SetMember) -> Option<&String> {
match member {
SetMember::Named(name) => Some(name),
SetMember::Labelled { member, .. } => named(member),
SetMember::Literal(_) | SetMember::Range(_) => None,
}
}
pub(crate) fn adopt<I>(
catalog: &mut SetCatalog,
wanted: I,
) -> Result<(), ParseError>
where
I: IntoIterator<Item = String>,
{
let mut queue: Vec<String> = wanted.into_iter().collect();
let mut seen = BTreeSet::new();
while let Some(name) = queue.pop() {
if catalog.get(&name).is_none()
&& let Some(definition) = compiled(&name)?
{
catalog.insert(definition);
}
let members = catalog.get(&name).map(|d| d.members.iter());
let reached = members.into_iter().flatten().filter_map(named);
queue.extend(reached.filter(|n| !seen.contains(*n)).cloned());
seen.insert(name);
}
Ok(())
}
pub(crate) fn names() -> impl Iterator<Item = &'static str> {
let declaring = LOCALES.lines().filter(|line| !line.starts_with('#'));
declaring.filter_map(|line| line.split_whitespace().next())
}
pub(crate) fn is_punctuation(name: &str) -> bool {
name.starts_with(PUNCTUATION)
}
pub(crate) fn adopt_all(catalog: &mut SetCatalog) -> Result<(), ParseError> {
for line in LOCALES.lines() {
if let Some(definition) = parse_line(line)?
&& catalog.get(&definition.name).is_none()
{
catalog.insert(inlined(definition)?);
}
}
Ok(())
}
#[cfg(test)]
#[path = "lookup_test.rs"]
mod tests;