Struct TaskIndex 

pub struct TaskIndex { /* private fields */ }

Lazy, thread-safe index of every markdown file that contains tasks.

Files with neither a task nor a marker are deliberately absent rather than stored empty, which keeps both memory and every query’s iteration proportional to the notes that actually have something to show. How large a share of a repository that is depends on the configuration: with markers enabled a note needs only the word TODO in a sentence to qualify, so the index is no longer the small minority of files it is with checkboxes alone.

Files matching tasks_ignore_globs are absent too. Excluding them here, at the one place the index is filled, is what makes the exclusion complete: the panel, the folder facets, total_matches and every count all derive from TaskIndex::snapshot.

Implementations

impl TaskIndex

pub fn new(ignore_globs: &[String]) -> Self

Creates an empty, unbuilt index that excludes files matching ignore_globs (the tasks_ignore_globs config option).

The patterns are compiled here, once, mirroring Repo::init’s compiled_ignore_globs: the build walks every markdown file in the repository, so re-parsing the patterns per file would cost far more than the matching itself.

A pattern that does not compile is dropped with a warning rather than refused. Config::validate already rejects one at startup, so the only way to reach here with a bad pattern is to bypass config loading entirely.

pub fn with_markers(ignore_globs: &[String], markers: &[String]) -> Self

TaskIndex::new, additionally indexing the incomplete markers in markers (the incomplete_markers config option).

An empty slice disables marker scanning, the same equivalence incomplete_markers = [] already has for the renderer — which is also how a caller says “highlighting is off”, since a marker with no highlight has no #mbr-marker-N anchor for the panel to link to.

The rule is compiled here, once, for the reason the ignore globs are: the build reads every markdown file in the repository, so re-compiling a regex per file would dwarf the matching. MarkerRule is Send + Sync (it wraps a Regex), which is what lets the whole index be shared as an Arc into spawn_blocking.

pub fn is_built(&self) -> bool

Whether the one-time build has completed.

pub fn len(&self) -> usize

Number of indexed files (only files that contain tasks).

pub fn is_empty(&self) -> bool

Whether the index currently holds no files.

pub fn get(&self, abs_path: &Path) -> Option<Arc<FileTasks>>

The tasks recorded for one absolute path, if any.

pub fn snapshot(&self) -> Vec<Arc<FileTasks>>

A cheap snapshot of every indexed file, for querying.

Clones Arcs, not data. Taking a snapshot rather than querying through a pin guard keeps the guard off the (potentially slow) grouping pass and gives the query a stable view even if the watcher fires mid-query.

pub async fn ensure_built( self: &Arc<Self>, repo: &Arc<Repo>, ) -> Result<(), TaskIndexError>

Builds the index if it has not been built yet.

Idempotent and single-flight: concurrent callers await one build. The work runs on spawn_blocking because it is a sequential pass of synchronous file reads.

Individual unreadable files (permissions, invalid UTF-8, oversized) are skipped with a debug log; only a panic in the build task is an error.

pub fn invalidate_file( &self, abs_path: &Path, event: &ChangeEventType, repo: &Repo, )

Re-scans (Created/Modified) or drops (Deleted) one file.

No-op when the index has never been built. A change arriving before anybody asked for tasks must not trigger the very build the laziness exists to avoid.

NOTE (known window): a file changed while the initial build is running is skipped here, because the build has not published itself yet, and the build may already have read that file’s previous contents. The entry then stays stale until the file changes again or the process restarts. Closing it would mean either serializing the watcher against the build (blocking edits behind a full-repo read pass) or queueing deferred invalidations forever for the common case where tasks are never opened. Neither is worth it for a window that is bounded by one build.

Call this after Repo::invalidate_file for the same event: the url/title of a created or modified file are read back out of the repo.

pub fn rebuild_if_built(&self, repo: &Repo)

Re-scans the whole repository, but only if the index was already built.

The watcher calls this on its full-rescan path (a change batch too large to patch file by file), where per-file invalidation would cost more than one read pass. Like Self::invalidate_file it does nothing when the index has never been built, so an unused task index stays free.

Entries are replaced and stale ones pruned in a single pass at the end, so a concurrent query never observes a half-empty index — only the old contents or the new ones.

Trait Implementations

impl Default for TaskIndex

fn default() -> Self

Returns the “default value” for a type.