Struct SourceTreeWatcher 

pub struct SourceTreeWatcher { /* private fields */ }

Recursive source-tree watcher with .gitignore filtering and git state detection.

Unlike super::FileWatcher (which watches a single directory for index file invalidation), SourceTreeWatcher monitors the full project tree and is designed for the sqryd daemon’s rebuild loop.

Implementations

impl SourceTreeWatcher

pub fn new(root: &Path) -> Result<Self>

Creates a new source-tree watcher rooted at root.

The watcher recursively monitors all files under root, filtering out .gitignore-excluded paths, .git/ internals (delegated to the internal GitStateWatcher), and common editor temporaries.

Errors

Returns an error if:

• The notify watcher cannot be created or attached.
• The git-state watcher cannot be created (missing .git).
• The .gitignore file exists but is malformed (logged as warning, not fatal — an empty matcher is used as fallback).

pub fn root(&self) -> &Path

Returns the repository root this watcher is monitoring.

pub fn git_state(&self) -> &GitStateWatcher

Returns a reference to the internal GitStateWatcher.

pub fn wait_for_changes( &self, debounce: Duration, last_git_state: Option<&LastIndexedGitState>, ) -> Result<ChangeSet>

Blocking wait for changes with sliding-window debounce.

Blocks until at least one relevant event arrives, then continues collecting events until debounce elapses with no new events. Returns a ChangeSet with all changes observed during the window.

If last_git_state is provided, the git-state classifier runs against it and the result is stored in ChangeSet::git_change_class.

Errors

Returns an error if the underlying watcher channel disconnects.

pub fn wait_for_changes_cancellable( &self, debounce: Duration, last_git_state: Option<&LastIndexedGitState>, cancelled: &AtomicBool, cancel_poll_period: Duration, ) -> Result<Option<ChangeSet>>

Debounced wait for changes with cooperative cancellation.

Behaves like Self::wait_for_changes but polls cancelled on a cancel_poll_period cadence so callers can terminate a blocking watcher thread without waiting for a real filesystem event. If cancelled.load(Ordering::Acquire) == true is observed at any checkpoint — including before the first event arrives, or during the sliding debounce window — this returns Ok(None) promptly, discarding any raw changes accumulated so far (the workspace is assumed to be terminating).

On a non-empty debounce window completing without cancellation, returns Ok(Some(cs)).

Parameters

• debounce: sliding quiet-period length (same semantics as Self::wait_for_changes).
• last_git_state: optional baseline for git-state classification; None produces git_change_class = None.
• cancelled: shared cancellation flag. Read with Ordering::Acquire so writes on the evicting thread (typically under the workspace-manager write lock) synchronise with this reader.
• cancel_poll_period: how often to check cancelled while waiting for the first event and during the sliding window. Production callers use ~100 ms; tests can use ~10 ms for fast termination.

Errors

Returns Err if the underlying notify channel disconnects (the watcher is unrecoverable).

pub fn poll_changes( &self, last_git_state: Option<&LastIndexedGitState>, ) -> Result<Option<ChangeSet>>

Non-blocking poll for changes.

Drains all pending events from the channel, applies debounce coalescing, and returns a ChangeSet. Returns Ok(None) if no events are pending.

If last_git_state is provided, the git-state classifier runs against it when git events were observed.

Errors

Returns an error if the watcher channel is in an unrecoverable state.