use std::collections::BTreeMap;
use super::ots::FeatureValue;
use super::ott::{LANGUAGES, SCRIPTS};
use crate::shape::FeatureValue as Raw;
#[derive(Clone, Debug, PartialEq)]
pub struct NodeFeatures {
pub features: BTreeMap<String, FeatureValue>,
pub script: String,
pub language: String,
}
const BASE_FEATURES: [&str; 15] = [
"abvm", "blwm", "ccmp", "locl", "mark", "mkmk", "rlig", "calt", "clig", "curs", "dist", "kern",
"liga", "rclt", "itlc",
];
fn preset(script: &str) -> &'static [&'static str] {
match script {
"arab" | "syrc" | "mong" | "nko" => &[
"isol", "fina", "fin2", "fin3", "medi", "med2", "init", "cswh", "mset",
],
"deva" | "beng" | "guru" | "gujr" | "orya" | "taml" | "telu" | "knda" | "mlym" | "sinh" => {
&[
"init", "nukt", "akhn", "rphf", "blwf", "half", "pstf", "vatu", "pres", "blws",
"abvs", "psts", "haln",
]
}
"khmr" | "tibt" => &[
"pref", "blwf", "abvf", "pstf", "pres", "blws", "abvs", "psts",
],
"hang" => &["ccmp", "ljmo", "vjmo", "tjmo"],
_ => &[],
}
}
fn squash(v: &str) -> String {
v.to_lowercase()
.chars()
.filter(|c| c.is_ascii_lowercase() || c.is_ascii_digit())
.collect()
}
fn resolve(value: &str, tags: &[(&str, &str)]) -> String {
let v = squash(value);
if let Some((tag, _)) = tags.iter().rev().find(|(_, name)| squash(name) == v) {
return tag.to_string();
}
if tags.iter().any(|(tag, _)| *tag == v) {
return v;
}
"dflt".to_string()
}
fn is_boolean(s: &str) -> Option<bool> {
match s {
"true" | "yes" | "on" | "t" => Some(true),
"false" | "no" | "off" | "f" => Some(false),
_ => None,
}
}
pub fn node_features(raw: &BTreeMap<String, Raw>) -> NodeFeatures {
let mut spec: BTreeMap<String, Raw> = BTreeMap::new();
for (k, v) in raw {
let v = match v {
Raw::Text(t) if t.to_lowercase() == "true" => Raw::Bool(true),
Raw::Text(t) if t.to_lowercase() == "false" => Raw::Bool(false),
v => v.clone(),
};
spec.insert(k.clone(), v);
}
spec.remove("");
let text = |v: Option<&Raw>| match v {
Some(Raw::Text(t)) => Some(t.clone()),
_ => None,
};
let language =
text(spec.get("language")).map_or("dflt".to_string(), |l| resolve(&l, LANGUAGES));
let script = text(spec.get("script")).map_or("dflt".to_string(), |s| resolve(&s, SCRIPTS));
spec.insert("language".into(), Raw::Text(language.clone()));
spec.insert("script".into(), Raw::Text(script.clone()));
for f in BASE_FEATURES.iter().chain(preset(&script)) {
spec.entry(f.to_string()).or_insert(Raw::Bool(true));
}
spec.entry("mode".into())
.or_insert(Raw::Text("node".into()));
let mut features = BTreeMap::new();
for (k, v) in &spec {
let k = k.to_lowercase();
if k == "language" || k == "script" {
continue;
}
let v = match v {
Raw::Bool(b) => b.then_some(FeatureValue::True),
Raw::Number(n) => Some(FeatureValue::Number(*n)),
Raw::Text(t) => match t.parse::<f64>() {
Ok(n) => Some(FeatureValue::Number(n)),
Err(_) => match is_boolean(t) {
Some(b) => b.then_some(FeatureValue::True),
None => Some(FeatureValue::Text(t.to_lowercase())),
},
},
};
match v {
Some(v) => {
features.insert(k, v);
}
None => {
features.remove(&k);
}
}
}
let defaults = [
("checkmarks", FeatureValue::True),
("spacekern", FeatureValue::True),
("normalize", FeatureValue::Text("nfc".into())),
("szss", FeatureValue::Text("auto".into())),
("amtra", FeatureValue::Text("auto".into())),
("analyze", FeatureValue::True),
("features", FeatureValue::True),
("notdef", FeatureValue::Number(1.0)),
("invisible", FeatureValue::True),
];
for (f, v) in defaults {
let said = spec.keys().any(|k| k.to_lowercase() == f);
if !said {
features.insert(f.to_string(), v);
}
}
NodeFeatures {
features,
script,
language,
}
}
#[cfg(test)]
mod tests {
use super::*;
fn raw(pairs: &[(&str, Raw)]) -> BTreeMap<String, Raw> {
pairs
.iter()
.map(|(k, v)| (k.to_string(), v.clone()))
.collect()
}
#[test]
fn defaults_follow_the_script() {
let latin = node_features(&raw(&[]));
assert_eq!(
(latin.script.as_str(), latin.language.as_str()),
("dflt", "dflt")
);
for f in [
"kern",
"liga",
"mark",
"mkmk",
"itlc",
"spacekern",
"checkmarks",
] {
assert!(latin.features.contains_key(f), "{f}");
}
assert!(!latin.features.contains_key("init"));
let arabic = node_features(&raw(&[("script", Raw::Text("Arabic".into()))]));
assert_eq!(arabic.script, "arab");
assert!(arabic.features.contains_key("init") && arabic.features.contains_key("kern"));
let thai = node_features(&raw(&[("script", Raw::Text("thai".into()))]));
assert_eq!(thai.script, "thai");
assert!(!thai.features.contains_key("init") && thai.features.contains_key("liga"));
}
#[test]
fn request_values_override_and_normalise() {
let f = node_features(&raw(&[
("kern", Raw::Bool(false)),
("liga", Raw::Text("no".into())),
("salt", Raw::Text("2".into())),
("ss01", Raw::Text("Yes".into())),
("language", Raw::Text("DEU".into())),
("spacekern", Raw::Bool(false)),
]));
assert!(!f.features.contains_key("kern"));
assert!(!f.features.contains_key("liga"));
assert!(!f.features.contains_key("spacekern"));
assert_eq!(f.features.get("salt"), Some(&FeatureValue::Number(2.0)));
assert_eq!(
f.features.get("ss01"),
Some(&FeatureValue::Text("yes".into()))
);
assert_eq!(f.language, "deu");
assert_eq!(
node_features(&raw(&[("language", Raw::Text("german".into()))])).language,
"deu"
);
assert_eq!(
node_features(&raw(&[("language", Raw::Text("xx-yy".into()))])).language,
"dflt"
);
}
}