use crate::fix::class;
use crate::fix::codepoint::decode;
use crate::fix::family::{ROOT, Tree};
use crate::fix::words::NAMED;
use crate::fix::{Class, Error, Family, MapEntry};
use crate::rules::Origin;
use std::cmp::Reverse;
use std::collections::{BTreeMap, HashSet};
pub(crate) const BUILTIN: &str = concat!(
include_str!("map.ctrm-map"),
include_str!("emoji/emoji-seq.ctrm-map")
);
pub(crate) struct Match {
pub(crate) len: usize,
pub(crate) to: String,
pub(crate) word: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum Target {
To { to: String, word: bool },
Class(usize),
}
impl Target {
const fn word(&self) -> bool {
matches!(self, Self::To { word: true, .. })
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct Candidate {
source: String,
target: Target,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Map {
entries: Vec<MapEntry>,
classes: Vec<Class>,
tree: Tree,
fidelity: Option<String>,
candidates: Vec<Candidate>,
starts: BTreeMap<char, Vec<usize>>,
}
impl Map {
#[must_use]
pub fn builtin() -> Self {
Self::parse(BUILTIN, &|line| Origin::Builtin { line })
.unwrap_or_default()
}
pub(crate) fn parse(
source: &str,
origin: &dyn Fn(usize) -> Origin,
) -> Result<Self, Error> {
Self::default().layer(source, origin)
}
pub(crate) fn layer(
mut self,
source: &str,
origin: &dyn Fn(usize) -> Origin,
) -> Result<Self, Error> {
for (index, line) in source.lines().enumerate() {
self.read(line, index.saturating_add(1), origin)?;
}
self.dedupe();
self.entries.sort_by_key(|entry| Reverse(entry.from.len()));
self.tree.validate()?;
self.validate_classes()?;
self.index();
Ok(self)
}
#[must_use]
pub(crate) fn tree(&self) -> &Tree {
&self.tree
}
#[must_use]
pub(crate) fn classes(&self) -> &[Class] {
&self.classes
}
#[must_use]
pub(crate) fn fidelity(&self) -> &str {
self.fidelity.as_deref().unwrap_or(ROOT)
}
pub fn with_fidelity(mut self, family: &str) -> Result<Self, Error> {
self.tree.path(family)?;
self.fidelity = Some(family.to_owned());
Ok(self)
}
#[must_use]
pub(crate) fn entries(&self) -> &[MapEntry] {
&self.entries
}
pub(crate) fn resolve_at(
&self,
rest: &str,
allowed: &dyn Fn(char) -> bool,
) -> Result<Option<Match>, Error> {
let first = rest.chars().next().and_then(|c| self.starts.get(&c));
let held = first.into_iter().flatten();
for candidate in held.filter_map(|at| self.candidates.get(*at)) {
let Some(to) = self.try_at(candidate, rest, allowed)? else {
continue;
};
return Ok(Some(Match {
len: candidate.source.len(),
to,
word: candidate.target.word(),
}));
}
Ok(None)
}
pub(crate) fn budget(&self) -> usize {
self.candidates.len().saturating_add(1)
}
fn try_at(
&self,
candidate: &Candidate,
rest: &str,
allowed: &dyn Fn(char) -> bool,
) -> Result<Option<String>, Error> {
if !rest.starts_with(&candidate.source)
|| !violates(&candidate.source, allowed)
{
return Ok(None);
}
self.target_of(&candidate.target, allowed)
}
fn target_of(
&self,
target: &Target,
allowed: &dyn Fn(char) -> bool,
) -> Result<Option<String>, Error> {
match target {
Target::To { to, .. } => Ok(Some(to.clone())),
Target::Class(index) => match self.classes.get(*index) {
Some(class) => {
class::resolve(class, &self.tree, self.fidelity(), allowed)
}
None => Ok(None),
},
}
}
fn read(
&mut self,
line: &str,
number: usize,
origin: &dyn Fn(usize) -> Origin,
) -> Result<(), Error> {
let body = line.trim();
if body.is_empty() || body.starts_with('#') {
return Ok(());
}
match body.split_once(' ') {
Some(("family", rest)) => self.declare(rest, number),
Some(("=", rest)) => self.classify(rest, number),
Some(("use", rest)) => self.pull(rest.trim(), &origin(number)),
Some(("word", rest)) => {
self.add(word(rest, origin(number)), number)
}
_ => self.add(entry(body, origin(number), false), number),
}
}
fn pull(&mut self, name: &str, origin: &Origin) -> Result<(), Error> {
let text = NAMED
.iter()
.find(|(held, _)| *held == name)
.map(|(_, text)| *text)
.ok_or_else(|| Error::UnknownMap {
name: name.to_owned(),
})?;
for (index, line) in text.lines().enumerate() {
self.read(line, index.saturating_add(1), &|_| origin.clone())?;
}
Ok(())
}
fn declare(&mut self, rest: &str, number: usize) -> Result<(), Error> {
let declared = family(rest).ok_or(Error::Syntax { line: number })?;
self.tree.declare(declared)
}
fn classify(&mut self, rest: &str, number: usize) -> Result<(), Error> {
let declared =
class::parse_line(rest).ok_or(Error::Syntax { line: number })?;
self.classes.retain(|held| held.name != declared.name);
self.classes.push(declared);
Ok(())
}
fn add(
&mut self,
entry: Option<MapEntry>,
number: usize,
) -> Result<(), Error> {
let entry = entry.ok_or(Error::Syntax { line: number })?;
if never_withheld(&entry.from) {
return Err(Error::NeverRewritten { line: number });
}
self.entries.push(entry);
Ok(())
}
fn dedupe(&mut self) {
let mut seen = HashSet::new();
let mut kept: Vec<MapEntry> = std::mem::take(&mut self.entries)
.into_iter()
.rev()
.filter(|entry| seen.insert(entry.from.clone()))
.collect();
kept.reverse();
self.entries = kept;
}
fn validate_classes(&self) -> Result<(), Error> {
for class in &self.classes {
for member in &class.members {
self.tree.path(&member.family)?;
}
}
Ok(())
}
fn index(&mut self) {
self.candidates = Vec::new();
for entry in &self.entries {
self.candidates.push(Candidate {
source: entry.from.clone(),
target: Target::To {
to: entry.to.clone(),
word: entry.word,
},
});
}
self.index_classes();
self.candidates
.sort_by_key(|held| Reverse(held.source.len()));
self.index_starts();
}
fn index_starts(&mut self) {
self.starts = BTreeMap::new();
for (at, held) in self.candidates.iter().enumerate() {
if let Some(first) = held.source.chars().next() {
self.starts.entry(first).or_default().push(at);
}
}
}
fn index_classes(&mut self) {
let mut found = Vec::new();
for (index, class) in self.classes.iter().enumerate() {
for member in &class.members {
found.push(Candidate {
source: member.text.clone(),
target: Target::Class(index),
});
}
}
self.candidates.append(&mut found);
}
}
fn family(rest: &str) -> Option<Family> {
let mut words = rest.split_whitespace();
let name = named(words.next()?)?;
let parent = named(words.next()?)?;
if words.next().is_some() {
return None;
}
Some(Family {
name,
parent: Some(parent),
})
}
pub(crate) fn named(word: &str) -> Option<String> {
if word.contains([':', ',']) {
return None;
}
Some(word.to_owned())
}
fn never_withheld(source: &str) -> bool {
let ascii = crate::charset::builtin::ascii();
source.chars().all(|ch| ascii.contains(ch))
}
pub(crate) fn violates(text: &str, allowed: &dyn Fn(char) -> bool) -> bool {
text.chars().any(|ch| !allowed(ch))
}
fn entry(body: &str, origin: Origin, word: bool) -> Option<MapEntry> {
let mut words = body.split_whitespace();
let from = decode(words.next()?)?;
let to = match words.next() {
Some(word) => decode(word)?,
None => String::new(),
};
if from.is_empty() || words.next().is_some() {
return None;
}
Some(MapEntry {
from,
to,
word,
origin,
})
}
fn word(rest: &str, origin: Origin) -> Option<MapEntry> {
entry(rest, origin, true).filter(|held| !held.to.is_empty())
}
#[cfg(test)]
#[path = "map_test.rs"]
mod tests;