Function check_embedded_directives

atomic-canonical/src/directive.rs:215–269

Reject a REGISTERED directive name embedded mid-prose with an attrs brace (e.g. `… ::file-ref{path=x} …` inside a sentence). The block parser only reads directives at line start, so an embedded one would silently stay prose and its edge would be lost. Unregistered names stay prose (the inline rule); `std::fs` and `foo::ref{...}` never match — the colon run must not follow an identifier character.

(text: &str)

/// prose (the inline rule); `std::fs` and `foo::ref{...}` never match — the
/// colon run must not follow an identifier character.
pub fn check_embedded_directives(text: &str) -> Result<()> {
    let mut in_fence = false;
    for raw_line in text.lines() {
        let line = strip_html_comments(raw_line);
        let t = line.trim_start();
        if t.starts_with("```") {
            in_fence = !in_fence;
            continue;
        }
        // Lines the block parser handles itself (directive opens/closes).
        if in_fence || t.starts_with(':') {
            continue;
        }
        let bytes = line.as_bytes();
        let mut i = 0;
        while i < bytes.len() {
            if bytes[i] != b':' {
                i += 1;
                continue;
            }
            let start = i;
            while i < bytes.len() && bytes[i] == b':' {
                i += 1;
            }
            let run = i - start;
            if !(2..=3).contains(&run) {
                continue;
            }
            if start > 0 {
                let prev = bytes[start - 1];
                if prev.is_ascii_alphanumeric() || prev == b'_' {
                    continue;
                }
            }
            let name_start = i;
            while i < bytes.len()
                && (bytes[i].is_ascii_lowercase() || bytes[i].is_ascii_digit() || bytes[i] == b'-')
            {
                i += 1;
            }
            if i == name_start || i >= bytes.len() || bytes[i] != b'{' {
                continue;
            }
            let name = &line[name_start..i];
            if vocab::is_known_directive(name) {
                return Err(CanonicalError::Directive(format!(
                    "directive '{}{name}' is embedded in prose — block \
                     directives must start their own line",
                    ":".repeat(run)
                )));
            }
        }
    }
    Ok(())
}

/// Drop `<!-- … -->` spans so template guidance comments never trip the
/// embedded-directive check.