Struct MarkerRule 

pub struct MarkerRule { /* private fields */ }

The compiled incomplete_markers rule: one shared answer to “is this an incomplete marker?”, used by the renderer that highlights them and by the scanner that indexes them.

It is a newtype rather than a bare Regex so that regex stays out of this crate’s public API, and so the two consumers cannot drift apart into two notions of what a marker is.

Word boundaries

Boundaries are decided per alternative, not once around the group. A single \b on the whole alternation demands a word character on the far side of every marker, whatever the marker ends with — so a marker configured as TODO: would never match TODO: foo, because the byte after the colon is a space. Symmetrically, a leading \b would stop @todo from matching at the start of a line, and would demand a word character before the @. So a \b is prefixed only when the marker’s first character is word-ish and suffixed only when its last one is, where word-ish means char::is_alphanumeric() || c == '_' — the definition the regex crate’s own Unicode \b uses.

Longest match

The regex crate’s alternation is leftmost-first, not leftmost-longest: in TODO|TODOMAYBE the shorter branch would win. Alternatives are therefore sorted longest-first at construction, which makes the result independent of the order the markers appear in the configuration file.

No prefilter

There is deliberately no hand-rolled pre-check of the kind [might_be_task] performs. The two situations are not the same. [might_be_task] exists to keep [TASK_LINE] off the regex crate’s capture-tracking engine, which is the slow one — roughly 710ns against 70ns, as documented on [TASK_LINE]. A MarkerRule search captures nothing, so it runs on the meta engine, which already extracts the literal alternation and drives a SIMD prefilter over it. A second prefilter in front of that would duplicate work the regex crate does better, and would have to be kept in agreement with the boundary rules above.

Implementations

impl MarkerRule

pub fn new(markers: &[String]) -> Option<Self>

Compiles a rule from the configured markers, or returns None when there is nothing to match.

Empty entries are dropped, so incomplete_markers = [""] is the same off switch as incomplete_markers = [] — and None is the signal to skip the pass entirely rather than to run a pattern that matches everywhere.

Markers are regex::escaped, so a marker containing metacharacters (FIXME() is matched literally instead of breaking compilation.

pub fn cached(markers: &[String]) -> Option<Arc<Self>>

MarkerRule::new, memoised on the marker list that produced it.

Use this on any path that runs per file or per request. Compiling the pattern costs ~80µs — three to four times what rendering a small page costs in total — because the regex crate builds an NFA, a lazy DFA and a literal prefilter. The render pipeline needs a rule for every page it renders, and mark_incomplete is on by default in server and GUI mode, so compiling per render put that 80µs on the default path for every request. (Callers that build a rule once and keep it — TaskIndex does — should keep calling MarkerRule::new and own the result.)

Keyed by the marker list rather than held in a plain OnceLock because a single process legitimately renders with more than one configuration: the test suite does it constantly, and nothing stops a GUI from opening two repositories whose .mbr/config.toml disagree. A None result is cached too, so a marker list that cannot compile is not retried per page.

Entries are never evicted. The key space is the set of distinct incomplete_markers values a process ever sees — one in production, a handful under test — so there is nothing to bound.

pub fn block_initial_match(&self, text: &str) -> Option<usize>

Byte length of the marker text begins with, or None when it begins with something else.

This is the renderer’s block-initial test, and the direct replacement for the old ^(?:M1|M2)\b pattern.

pub fn find_iter<'t>( &'t self, text: &'t str, ) -> impl Iterator<Item = Range<usize>> + 't

Every marker in text, as byte ranges, ascending and non-overlapping.

pub fn find_in_line(&self, line: &str) -> Option<usize>

Byte offset of the first marker in a raw source line that a reader would actually see, or None when the line has none.

Unlike MarkerRule::find_iter this understands markdown: a marker inside a code span, a wikilink target, a link destination or title, an autolink or a reference definition does not count. See [MarkupCursor].

Trait Implementations

impl Clone for MarkerRule

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MarkerRule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.