use crate::fix::emoji::{Layer, SETTLE, Trail, itself};
use crate::fix::map::Map;
use crate::fix::walk::{Ground, Pass, Span, run};
use crate::fix::{Error, Law, Marks, Rewrite};
use crate::scan::Hit;
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct Report {
pub rewrites: Vec<Rewrite>,
pub unmapped: Vec<Hit>,
}
impl Report {
#[must_use]
pub fn drifted(&self) -> bool {
!self.rewrites.is_empty()
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Fixed {
pub output: String,
pub report: Report,
trail: Trail,
}
impl Fixed {
#[must_use]
pub fn origins(&self, original: &str, hits: &[Hit]) -> Vec<Hit> {
self.trail.origins(original, hits)
}
pub(crate) fn place<T>(
&self,
original: &str,
items: &mut [T],
hit: fn(&mut T) -> &mut Hit,
) {
self.trail.place(original, items, hit);
}
}
pub fn fix(
text: &str,
map: &Map,
allowed: impl Fn(char) -> bool,
) -> Result<Fixed, Error> {
let law = Law {
allowed: &allowed,
hazards: &|_| Vec::new(),
kept: &|_| Vec::new(),
restores: &|_| Vec::new(),
};
fix_under(text, map, law)
}
pub(crate) fn fix_under(
text: &str,
map: &Map,
law: Law<'_>,
) -> Result<Fixed, Error> {
let mut seen = History::new(text);
let mut pass = guarded(text, map, law)?;
for _ in 0..SETTLE {
let again = guarded(&pass.output, map, law)?;
if again.output == pass.output {
return Ok(seen.settled(pass));
}
seen.record(pass.spans);
pass = again;
}
Err(Error::NotIdempotent)
}
#[derive(Debug)]
struct History<'t> {
original: &'t str,
report: Report,
trail: Trail,
}
impl<'t> History<'t> {
const fn new(original: &'t str) -> Self {
Self {
original,
report: Report {
rewrites: Vec::new(),
unmapped: Vec::new(),
},
trail: Trail::new(),
}
}
fn record(&mut self, spans: Vec<Span>) {
if spans.is_empty() {
return;
}
let layer = Layer::of(spans.iter().map(Span::extent));
let mut rows: Vec<Rewrite> =
spans.into_iter().map(Span::into_rewrite).collect();
self.trail.place(self.original, &mut rows, rewrite_hit);
if self.report.rewrites.is_empty() {
self.report.rewrites = rows;
} else {
self.report.rewrites.append(&mut rows);
}
self.trail.push(layer);
}
fn settled(mut self, pass: Pass) -> Fixed {
let Pass {
output,
spans,
mut unmapped,
} = pass;
self.trail.place(self.original, &mut unmapped, itself);
self.report.unmapped = unmapped;
self.record(spans);
self.report.rewrites.sort_by_key(|r| r.hit.position.byte);
Fixed {
output,
report: self.report,
trail: self.trail,
}
}
}
fn guarded(text: &str, map: &Map, law: Law<'_>) -> Result<Pass, Error> {
let ground = Ground {
map,
allowed: law.allowed,
budget: map.budget(),
};
let pass = run(text, ground, Marks::of(text, law))?;
if untouched_bytes_match(text, &pass) {
Ok(pass)
} else {
Err(Error::TouchedAllowedBytes)
}
}
#[cfg(test)]
pub(super) fn check(
text: &str,
map: &Map,
allowed: &dyn Fn(char) -> bool,
) -> Result<Report, Error> {
Ok(fix(text, map, allowed)?.report)
}
fn rewrite_hit(rewrite: &mut Rewrite) -> &mut Hit {
&mut rewrite.hit
}
fn untouched_bytes_match(text: &str, pass: &Pass) -> bool {
let mut cut = Cut::default();
for span in &pass.spans {
if !cut.gap_matches(text, &pass.output, span.hit.position.byte) {
return false;
}
cut.skip(span);
}
cut.tail_matches(text, &pass.output)
}
#[derive(Debug, Default)]
struct Cut {
input: usize,
output: usize,
}
impl Cut {
fn gap_matches(&self, text: &str, out: &str, next: usize) -> bool {
let before = text.get(self.input..next);
let end = self.output.checked_add(next.saturating_sub(self.input));
let after = end.and_then(|stop| out.get(self.output..stop));
before.is_some() && before == after
}
#[cfg(test)]
fn start_of(&self, span: &Span) -> usize {
let gap = span.hit.position.byte.saturating_sub(self.input);
self.output.saturating_add(gap)
}
fn skip(&mut self, span: &Span) {
let gap = span.hit.position.byte.saturating_sub(self.input);
self.output = self
.output
.saturating_add(gap)
.saturating_add(span.to.len());
self.input = span.hit.position.byte.saturating_add(span.len);
}
fn tail_matches(&self, text: &str, out: &str) -> bool {
text.get(self.input..) == out.get(self.output..)
}
}
#[cfg(test)]
#[path = "apply_test.rs"]
mod tests;