Struct GitWatcher 

pub struct GitWatcher { /* private fields */ }

A git watcher for detecting git repository state changes.

Uses the notify crate internally to watch the .git directory for changes. Provides a non-blocking interface suitable for use in TUI event loops.

This is useful for caching git statistics and only recomputing them when the git state actually changes, rather than polling at a fixed interval.

Implementations

impl GitWatcher

pub fn new() -> Result<Self, Error>

Create a new git watcher with default configuration.

Uses 100ms debounce by default.

Errors

Returns a notify::Error if the watcher cannot be created.

Example

use ratatui_toolkit::services::git_watcher::GitWatcher;

let watcher = GitWatcher::new().unwrap();

impl GitWatcher

pub fn with_config(config: GitWatchConfig) -> Result<Self, Error>

Create a new git watcher with custom configuration.

Arguments

• config - Configuration for the watcher.

Errors

Returns a notify::Error if the watcher cannot be created.

Example

use ratatui_toolkit::services::git_watcher::{GitWatcher, GitWatchConfig};

let config = GitWatchConfig::new()
    .debounce_ms(200);

let watcher = GitWatcher::with_config(config).unwrap();

impl GitWatcher

pub fn check_for_changes(&mut self) -> bool

Check if there are any pending git state changes.

This is a non-blocking operation that returns true if any relevant git changes have been detected since the last check.

Returns

true if git changes were detected, false otherwise.

Example

use ratatui_toolkit::services::git_watcher::GitWatcher;
use std::path::Path;

let mut watcher = GitWatcher::new().unwrap();
watcher.watch(Path::new("/path/to/repo")).unwrap();

// In your event loop:
if watcher.check_for_changes() {
    println!("Git state changed, recompute stats!");
}

pub fn has_pending_changes(&self) -> bool

Check if there are pending changes without consuming them.

This is useful when you want to know if there are changes but don’t want to reset the flag yet.

Returns

true if git changes are pending, false otherwise.

impl GitWatcher

pub fn drain_events(&mut self)

Drain all pending events without processing them.

This clears the event queue and resets the pending changes flag, useful when you want to ignore accumulated changes (e.g., after a batch operation).

Example

use ratatui_toolkit::services::git_watcher::GitWatcher;
use std::path::Path;

let mut watcher = GitWatcher::new().unwrap();
watcher.watch(Path::new("/path/to/repo")).unwrap();

// After some operation that causes many changes:
watcher.drain_events();

impl GitWatcher

pub fn unwatch(&mut self, repo_path: &Path) -> Result<(), Error>

Stop watching a git repository.

Arguments

• repo_path - Path to the repository root (where .git is located).

Errors

Returns a notify::Error if the path cannot be unwatched.

Example

use ratatui_toolkit::services::git_watcher::GitWatcher;
use std::path::Path;

let mut watcher = GitWatcher::new().unwrap();
let path = Path::new("/path/to/repo");
watcher.watch(path).unwrap();
// Later...
watcher.unwatch(path).unwrap();

impl GitWatcher

pub fn watch(&mut self, repo_path: &Path) -> Result<(), Error>

Start watching a git repository for changes.

Watches the .git directory recursively to detect any changes to the repository state (commits, staging, branches, etc.).

Arguments

• repo_path - Path to the repository root (where .git is located).

Errors

Returns a notify::Error if the path cannot be watched or if the .git directory doesn’t exist.

Example

use ratatui_toolkit::services::git_watcher::GitWatcher;
use std::path::Path;

let mut watcher = GitWatcher::new().unwrap();
watcher.watch(Path::new("/path/to/repo")).unwrap();

Trait Implementations

impl Debug for GitWatcher

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

Formats the value using the given formatter.