use std::sync::LazyLock;
use regex::Regex;
#[expect(
clippy::expect_used,
reason = "static LazyLock built from a literal regex: compile-time verifiable, \
so a runtime parse failure would mean the binary was linked against \
a broken `regex` crate and panicking at first-use is the only \
meaningful recovery"
)]
static FULL_MARKER: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\[\[ ## (\w+) ## \]\]").expect("static regex is always valid"));
#[derive(Debug, PartialEq, Eq)]
pub(super) enum MarkerScan {
NoMarker { content_before: String },
MarkerFound {
content_before: String,
name: String,
remainder: String,
},
}
#[derive(Debug, Default)]
pub(super) struct MarkerDetector {
tail_buffer: String,
}
impl MarkerDetector {
pub(super) fn new() -> Self {
Self::default()
}
pub(super) fn push(&mut self, chunk: &str) -> MarkerScan {
if self.tail_buffer.is_empty() {
return Self::scan(chunk, &mut self.tail_buffer);
}
let mut working = std::mem::take(&mut self.tail_buffer);
working.push_str(chunk);
Self::scan(&working, &mut self.tail_buffer)
}
fn scan(working: &str, tail_buffer_out: &mut String) -> MarkerScan {
if let Some(cap) = FULL_MARKER.captures(working) {
let full_match = cap.get(0).unwrap_or_else(|| {
unreachable!("regex group 0 always present on a match");
});
let name = cap.get(1).unwrap_or_else(|| {
unreachable!("regex group 1 always present on this pattern");
});
return MarkerScan::MarkerFound {
content_before: working[..full_match.start()].to_owned(),
name: name.as_str().to_owned(),
remainder: working[full_match.end()..].to_owned(),
};
}
let split_point = longest_partial_marker_suffix_start(working);
let content_before = working[..split_point].to_owned();
working[split_point..].clone_into(tail_buffer_out);
MarkerScan::NoMarker { content_before }
}
pub(super) fn drain_tail(&mut self) -> String {
std::mem::take(&mut self.tail_buffer)
}
#[cfg(test)]
pub(super) fn tail(&self) -> &str {
&self.tail_buffer
}
}
fn longest_partial_marker_suffix_start(s: &str) -> usize {
let bytes = s.as_bytes();
let scan_start = bytes.len().saturating_sub(MAX_MARKER_PREFIX);
for i in scan_start..bytes.len() {
if bytes[i] == b'[' && is_potential_marker_prefix(&s[i..]) {
return i;
}
}
bytes.len()
}
const MAX_MARKER_PREFIX: usize = 128;
fn is_potential_marker_prefix(s: &str) -> bool {
if s.is_empty() {
return false;
}
let mut st = State::Start;
for ch in s.chars() {
st = match (st, ch) {
(State::Start, '[') => State::Bracket1,
(State::Bracket1, '[') => State::Bracket2,
(State::Bracket2, ' ') => State::Space1,
(State::Space1, '#') => State::Hash1a,
(State::Hash1a, '#') => State::Hash1b,
(State::Hash1b, ' ') => State::Space2,
(State::Space2, c) if is_name_char(c) => State::InsideName,
(State::InsideName, c) if is_name_char(c) => State::InsideName,
(State::InsideName, ' ') => State::Space3,
(State::Space3, '#') => State::Hash2a,
(State::Hash2a, '#') => State::Hash2b,
(State::Hash2b, ' ') => State::Space4,
(State::Space4, ']') => State::CloseBracket1,
_ => return false,
}
}
true
}
const fn is_name_char(c: char) -> bool {
c.is_ascii_alphanumeric() || c == '_'
}
#[derive(Debug, Clone, Copy)]
enum State {
Start,
Bracket1,
Bracket2,
Space1,
Hash1a,
Hash1b,
Space2,
InsideName,
Space3,
Hash2a,
Hash2b,
Space4,
CloseBracket1,
}
#[cfg(test)]
mod tests {
use super::*;
fn detect_one(chunk: &str) -> MarkerScan {
let mut d = MarkerDetector::new();
d.push(chunk)
}
#[test]
fn complete_marker_in_one_chunk() {
match detect_one("hello [[ ## answer ## ]] world") {
MarkerScan::MarkerFound {
content_before,
name,
remainder,
} => {
assert_eq!(content_before, "hello ");
assert_eq!(name, "answer");
assert_eq!(remainder, " world");
}
scan @ MarkerScan::NoMarker { .. } => {
panic!("expected MarkerFound, got {scan:?}")
}
}
}
#[test]
fn multiple_markers_in_one_chunk() {
let mut d = MarkerDetector::new();
let scan_a = d.push("[[ ## a ## ]]content1[[ ## b ## ]]content2");
let remainder_after_a = match scan_a {
MarkerScan::MarkerFound {
content_before,
name,
remainder,
} => {
assert_eq!(content_before, "");
assert_eq!(name, "a");
remainder
}
scan @ MarkerScan::NoMarker { .. } => {
panic!("expected MarkerFound(a), got {scan:?}")
}
};
match d.push(&remainder_after_a) {
MarkerScan::MarkerFound {
content_before,
name,
remainder,
} => {
assert_eq!(content_before, "content1");
assert_eq!(name, "b");
assert_eq!(remainder, "content2");
}
scan @ MarkerScan::NoMarker { .. } => {
panic!("expected MarkerFound(b), got {scan:?}")
}
}
assert_eq!(d.tail(), "");
}
#[test]
fn empty_chunk_handled_safely() {
let mut d = MarkerDetector::new();
match d.push("") {
MarkerScan::NoMarker { content_before } => assert_eq!(content_before, ""),
scan @ MarkerScan::MarkerFound { .. } => {
panic!("expected NoMarker for empty input, got {scan:?}")
}
}
assert_eq!(d.tail(), "");
match d.push("") {
MarkerScan::NoMarker { content_before } => assert_eq!(content_before, ""),
scan @ MarkerScan::MarkerFound { .. } => panic!("got {scan:?}"),
}
assert_eq!(d.tail(), "");
}
#[test]
fn no_marker_clean_content() {
let mut d = MarkerDetector::new();
match d.push("just text here") {
MarkerScan::NoMarker { content_before } => {
assert_eq!(content_before, "just text here");
}
scan @ MarkerScan::MarkerFound { .. } => {
panic!("expected NoMarker, got {scan:?}")
}
}
assert_eq!(d.tail(), "");
}
#[test]
fn marker_split_across_chunks_at_every_boundary() {
let full = "before [[ ## fname ## ]] after";
for split in 1..full.len() {
let mut d = MarkerDetector::new();
let first = d.push(&full[..split]);
let second = d.push(&full[split..]);
let mut content_before = String::new();
let mut name: Option<String> = None;
let mut remainder = String::new();
let mut marker_found = false;
for scan in [first, second] {
match scan {
MarkerScan::NoMarker { content_before: c } => {
if marker_found {
remainder.push_str(&c);
} else {
content_before.push_str(&c);
}
}
MarkerScan::MarkerFound {
content_before: c,
name: n,
remainder: r,
} => {
content_before.push_str(&c);
name = Some(n);
remainder.push_str(&r);
marker_found = true;
}
}
}
assert_eq!(name.as_deref(), Some("fname"), "split={split}");
assert_eq!(content_before, "before ", "split={split}");
assert_eq!(remainder, " after", "split={split}");
assert_eq!(
d.tail(),
"",
"tail should be empty after marker found; split={split}"
);
}
}
#[test]
fn tail_buffer_holds_partial_marker_prefixes() {
let prefixes = [
"[",
"[[",
"[[ ",
"[[ #",
"[[ ##",
"[[ ## ",
"[[ ## fname",
"[[ ## fname ",
"[[ ## fname #",
"[[ ## fname ##",
"[[ ## fname ## ",
"[[ ## fname ## ]",
];
for prefix in prefixes {
let mut d = MarkerDetector::new();
let chunk = format!("safe content {prefix}");
match d.push(&chunk) {
MarkerScan::NoMarker { content_before } => {
assert_eq!(content_before, "safe content ", "prefix={prefix:?}");
assert_eq!(d.tail(), prefix, "prefix={prefix:?}");
}
scan @ MarkerScan::MarkerFound { .. } => {
panic!("expected NoMarker for prefix {prefix:?}, got {scan:?}")
}
}
}
}
#[test]
fn literal_double_bracket_not_marker_flushes_after_disambiguation() {
let mut d = MarkerDetector::new();
match d.push("literal [[") {
MarkerScan::NoMarker { content_before } => assert_eq!(content_before, "literal "),
scan @ MarkerScan::MarkerFound { .. } => panic!("got {scan:?}"),
}
assert_eq!(d.tail(), "[[");
match d.push("!not marker") {
MarkerScan::NoMarker { content_before } => {
assert_eq!(content_before, "[[!not marker");
}
scan @ MarkerScan::MarkerFound { .. } => panic!("got {scan:?}"),
}
assert_eq!(d.tail(), "");
}
#[test]
fn completed_marker_split_across_chunks() {
let mut d = MarkerDetector::new();
let s1 = d.push("[[ ## comple");
match s1 {
MarkerScan::NoMarker { content_before } => assert_eq!(content_before, ""),
scan @ MarkerScan::MarkerFound { .. } => {
panic!("expected NoMarker, got {scan:?}")
}
}
match d.push("ted ## ]]") {
MarkerScan::MarkerFound {
content_before,
name,
remainder,
} => {
assert_eq!(content_before, "");
assert_eq!(name, "completed");
assert_eq!(remainder, "");
}
scan @ MarkerScan::NoMarker { .. } => {
panic!("expected MarkerFound, got {scan:?}")
}
}
}
#[test]
fn drain_tail_returns_held_bytes() {
let mut d = MarkerDetector::new();
d.push("content [[ ##");
assert_eq!(d.tail(), "[[ ##");
assert_eq!(d.drain_tail(), "[[ ##");
assert_eq!(d.tail(), "");
}
#[test]
fn potential_prefix_rejects_complete_marker() {
assert!(!is_potential_marker_prefix("[[ ## x ## ]]"));
}
#[test]
fn potential_prefix_rejects_garbage() {
for s in ["foo", "[x", "[[ #x", "[[ ## name## ]]", "[[ ## name ## ] ]"] {
assert!(!is_potential_marker_prefix(s), "should reject {s:?}");
}
}
}