use std::ops::Range;
use hashbrown::HashSet;
use crate::dict::{canonical, strip_possessive};
const PREFIX: &str = "redink:";
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Kind {
UnclosedOff { reason: Option<String> },
Malformed,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Warning {
pub byte_offset: usize,
pub kind: Kind,
pub message: String,
}
#[derive(Debug, Default, Clone)]
pub struct Allow {
ci: HashSet<String>,
cs: HashSet<String>,
}
impl Allow {
fn insert(&mut self, entry: &str) {
match entry.strip_prefix('=') {
Some(exact) => {
self.cs.insert(canonical(exact));
}
None => {
self.ci.insert(canonical(entry).to_lowercase());
}
}
}
pub fn is_empty(&self) -> bool {
self.ci.is_empty() && self.cs.is_empty()
}
pub fn contains(&self, word: &str) -> bool {
if self.is_empty() {
return false;
}
let has = |w: &str| {
self.cs.contains(w) || (!self.ci.is_empty() && self.ci.contains(&w.to_lowercase()))
};
has(word) || strip_possessive(word).is_some_and(has)
}
}
#[derive(Debug, Default)]
pub struct Directives {
pub skips: Vec<Range<usize>>,
pub allow: Allow,
pub warnings: Vec<Warning>,
}
struct Comment<'a> {
span: Range<usize>,
body: &'a str,
}
fn comments_in(src: &str, range: Range<usize>) -> impl Iterator<Item = Comment<'_>> {
let mut at = range.start;
let end = range.end;
std::iter::from_fn(move || {
let open = at + src[at..end].find("<!--")?;
let body_start = open + 4;
let close = body_start + src[body_start..end].find("-->")?;
at = close + 3;
Some(Comment {
span: open..at,
body: &src[body_start..close],
})
})
}
pub fn collect(src: &str, html: &[Range<usize>]) -> Directives {
let mut out = Directives::default();
let mut off_since: Option<(usize, &str)> = None;
for comment in html.iter().flat_map(|r| comments_in(src, r.clone())) {
let body = comment.body.trim();
let Some(rest) = strip_prefix_ignore_case(body, PREFIX) else {
continue;
};
let at = comment.span.start;
let mut words = rest.split_whitespace();
let command = words.next().unwrap_or("");
let reason = rest[command.len()..].trim();
let mut warn = |message: String| {
out.warnings.push(Warning {
byte_offset: at,
kind: Kind::Malformed,
message,
})
};
match command {
"off" => match off_since {
Some(_) => warn(format!(
"redink:off{} while checking is already off; ignored",
describe(reason)
)),
None => off_since = Some((at, reason)),
},
"on" => match off_since.take() {
Some((start, _)) => out.skips.push(start..comment.span.end),
None => warn(format!(
"redink:on{} without a preceding redink:off; ignored",
describe(reason)
)),
},
"allow" => {
let mut any = false;
for w in words.filter(|w| *w != "=") {
out.allow.insert(w);
any = true;
}
if !any {
warn("redink:allow lists no words".into());
}
}
_ => warn(format!(
"unknown directive `{body}` (expected redink:off, redink:on, or redink:allow)"
)),
}
}
if let Some((start, reason)) = off_since {
out.skips.push(start..src.len());
out.warnings.push(Warning {
byte_offset: start,
kind: Kind::UnclosedOff {
reason: (!reason.is_empty()).then(|| reason.to_string()),
},
message: format!(
"redink:off{} is never switched back on; the rest of the file is unchecked",
describe(reason)
),
});
}
out
}
fn describe(reason: &str) -> String {
if reason.is_empty() {
String::new()
} else {
format!(" (\u{201c}{reason}\u{201d})")
}
}
fn strip_prefix_ignore_case<'a>(s: &'a str, prefix: &str) -> Option<&'a str> {
let head = s.get(..prefix.len())?;
head.eq_ignore_ascii_case(prefix)
.then(|| s[prefix.len()..].trim_start())
}
#[cfg(test)]
mod tests {
use super::*;
fn collect_all(src: &str) -> Directives {
collect(src, std::slice::from_ref(&(0..src.len())))
}
#[test]
fn off_on_pair_skips_between() {
let src = "a <!-- redink:off --> b <!-- redink:on --> c";
let d = collect_all(src);
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
assert_eq!(d.skips, vec![2..src.find(" c").unwrap()]);
}
#[test]
fn unclosed_off_skips_to_eof_and_warns() {
let src = "a <!-- redink:off --> b c";
let d = collect_all(src);
assert_eq!(d.skips, vec![2..src.len()]);
assert_eq!(d.warnings.len(), 1);
assert_eq!(d.warnings[0].byte_offset, 2);
assert_eq!(d.warnings[0].kind, Kind::UnclosedOff { reason: None });
assert!(d.warnings[0].message.contains("never switched back on"));
}
#[test]
fn reasons_are_accepted_and_echoed() {
let src = "<!-- redink:off Kesh's dialect --> a <!-- redink:on end of dialect --> b";
let d = collect_all(src);
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
assert_eq!(d.skips.len(), 1);
let d = collect_all("x <!-- redink:off Kesh's dialect --> y");
assert_eq!(
d.warnings[0].kind,
Kind::UnclosedOff {
reason: Some("Kesh's dialect".into())
}
);
assert!(
d.warnings[0]
.message
.contains("\u{201c}Kesh's dialect\u{201d}"),
"{}",
d.warnings[0].message
);
}
#[test]
fn stray_on_and_double_off_warn() {
let src = "<!-- redink:on --> <!-- redink:off --> <!-- redink:off --> x <!-- redink:on -->";
let d = collect_all(src);
assert_eq!(d.warnings.len(), 2, "{:?}", d.warnings);
assert!(d.warnings[0].message.contains("without a preceding"));
assert!(d.warnings[1].message.contains("already off"));
assert!(d.warnings.iter().all(|w| w.kind == Kind::Malformed));
assert_eq!(
d.skips,
vec![src.find("<!-- redink:off").unwrap()..src.len()]
);
}
#[test]
fn malformed_directives_warn() {
for bad in [
"<!-- redink:of -->",
"<!-- Redink:Off -->",
"<!-- redink:off: dialect -->",
"<!-- redink:allow -->",
"<!-- redink: -->",
] {
let d = collect_all(bad);
assert_eq!(d.warnings.len(), 1, "{bad}: {:?}", d.warnings);
assert!(d.skips.is_empty(), "{bad}");
}
}
#[test]
fn ordinary_comments_are_not_directives() {
let d = collect_all("<!-- TODO: redink:off later --> <!-- just a note -->");
assert!(d.warnings.is_empty());
assert!(d.skips.is_empty());
}
#[test]
fn allow_honours_case_and_possessives() {
let d = collect_all("<!--\n redink:allow vorld =Kesh\n Zeb\n-->");
assert!(d.warnings.is_empty(), "{:?}", d.warnings);
let a = &d.allow;
assert!(a.contains("vorld") && a.contains("Vorld") && a.contains("VORLD"));
assert!(a.contains("Kesh") && a.contains("Kesh's"));
assert!(!a.contains("kesh"), "exact-case entry matched other casing");
assert!(a.contains("zeb"), "entries may span lines");
assert!(!a.contains("world"));
}
#[test]
fn allow_canonicalizes_possessive_entries() {
let d = collect_all("<!-- redink:allow Atrax's -->");
assert!(d.allow.contains("Atrax") && d.allow.contains("atrax's"));
}
}