use crate::lint::{Group, Lint};
use crate::scan::{Hit, Position, located};
pub(crate) const DOUBLE_ENCODED: Lint =
Lint::new("double-encoded", Group::Hazard);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Run {
pub at: Position,
pub len: usize,
pub decoded: char,
}
impl Run {
pub(crate) const fn hit(&self) -> Hit {
Hit {
position: self.at,
character: self.decoded,
}
}
pub(crate) const fn covers(&self, byte: usize) -> bool {
match byte.checked_sub(self.at.byte) {
Some(into) => into < self.len,
None => false,
}
}
}
pub(crate) fn inside(runs: &[Run], byte: usize) -> bool {
let after = runs.partition_point(|run| run.at.byte <= byte);
after
.checked_sub(1)
.and_then(|last| runs.get(last))
.is_some_and(|run| run.covers(byte))
}
const fn promised(lead: char) -> Option<usize> {
match lead {
'\u{C2}'..='\u{DF}' => Some(1),
'\u{E0}'..='\u{EF}' => Some(2),
'\u{F0}'..='\u{F4}' => Some(3),
_ => None,
}
}
const fn continuation(c: char) -> bool {
matches!(c, '\u{80}'..='\u{BF}')
}
const fn control(c: char) -> bool {
matches!(c, '\u{80}'..='\u{9F}')
}
struct Open {
lead: Hit,
promised: usize,
tail: Vec<char>,
}
impl Open {
fn of(hit: Hit) -> Option<Self> {
let promised = promised(hit.character)?;
Some(Self {
lead: hit,
promised,
tail: Vec::new(),
})
}
fn closed(&self) -> Option<Run> {
let complete = self.tail.len() == self.promised;
let signed = self.tail.iter().any(|c| control(*c));
let decoded = if complete && signed {
self.decode()
} else {
None
};
Some(Run {
at: self.lead.position,
len: self.tail.len().saturating_add(1).saturating_mul(2),
decoded: decoded?,
})
}
fn decode(&self) -> Option<char> {
let latin1 = std::iter::once(self.lead.character)
.chain(self.tail.iter().copied());
let bytes: Vec<u8> = latin1
.filter_map(|c| u8::try_from(u32::from(c)).ok())
.collect();
let mut chars = std::str::from_utf8(&bytes).ok()?.chars();
let first = chars.next()?;
chars.next().is_none().then_some(first)
}
}
pub(crate) fn runs(text: &str) -> Vec<Run> {
if text.is_ascii() || !text.chars().any(control) {
return Vec::new();
}
let mut found = Vec::new();
let mut open = None;
for hit in located(text) {
open = step(open, hit, &mut found);
}
found
}
fn step(open: Option<Open>, hit: Hit, found: &mut Vec<Run>) -> Option<Open> {
match open {
Some(mut run) if continuation(hit.character) => {
run.tail.push(hit.character);
if run.tail.len() < run.promised {
return Some(run);
}
found.extend(run.closed());
None
}
_ => Open::of(hit),
}
}
#[cfg(test)]
mod tests {
use super::{DOUBLE_ENCODED, inside, runs};
use crate::lint::Lint;
type Seen = (usize, usize, usize, usize, char);
fn seen(text: &str) -> Vec<Seen> {
runs(text)
.iter()
.map(|r| (r.at.line, r.at.column, r.at.byte, r.len, r.decoded))
.collect()
}
#[test]
fn the_lint_is_registered_as_a_hazard() {
assert_eq!(Lint::named("double-encoded"), Some(DOUBLE_ENCODED));
}
#[test]
fn the_issues_example_is_two_runs() {
let text = "two runs must \u{e2}\u{8a}\u{a5} share a dir \
\u{e2}\u{80}\u{94} ok\n";
let expected =
vec![(1, 15, 14, 6, '\u{22A5}'), (1, 31, 33, 6, '\u{2014}')];
assert_eq!(seen(text), expected);
}
#[test]
fn a_two_byte_and_a_four_byte_character_are_runs() {
assert_eq!(seen("\u{c2}\u{80}"), vec![(1, 1, 0, 4, '\u{80}')]);
let pile = "x\u{f0}\u{9f}\u{91}\u{8d}";
assert_eq!(seen(pile), vec![(1, 2, 1, 8, '\u{1F44D}')]);
}
#[test]
fn an_accented_letter_is_no_run() {
assert_eq!(seen("caf\u{e9}"), vec![]);
assert_eq!(seen("\u{c3}\u{a9}"), vec![]);
assert_eq!(seen("\u{c3}\u{a9} and \u{85}"), vec![]);
}
#[test]
fn a_short_or_invalid_run_is_none() {
assert_eq!(seen("\u{e2}\u{80}"), vec![]);
assert_eq!(seen("\u{e2}\u{80}x"), vec![]);
assert_eq!(seen("\u{e0}\u{80}\u{80}"), vec![]);
}
#[test]
fn a_stray_lead_does_not_hide_the_run_after_it() {
assert_eq!(
seen("\u{e2}\u{e2}\u{80}\u{94}"),
vec![(1, 2, 2, 6, '\u{2014}')]
);
}
#[test]
fn inside_asks_the_damaged_bytes_only() {
let found = runs("a\u{e2}\u{80}\u{94}b");
assert!(!inside(&found, 0));
assert!(inside(&found, 1) && inside(&found, 6));
assert!(!inside(&found, 7));
}
}