Struct ProjectScope 

pub struct ProjectScope { /* private fields */ }

A repo-relative file set. The repo_root is canonicalized at construction time; every PathBuf in paths is relative to it and already stripped of leading ./ segments.

The struct intentionally stores paths only, not content — see Self::read for the disk-reading step. Construction never touches file contents, so a ProjectScope is cheap to build, clone, and further narrow via Self::filter.

Implementations

impl ProjectScope

pub fn build( repo_root: PathBuf, include: &GlobSet, exclude: &GlobSet, ) -> Result<Self>

Walk repo_root and capture every regular file whose repo-relative path matches include and does not match exclude. Both globsets are pre-compiled; use Self::build_from_patterns if you only have raw pattern strings.

Semantics of an empty globset:

• empty include → nothing is captured (a strict “include set” with no rules matches nothing). Pass a globset containing **/* (or use Self::build_from_patterns with ["**/*"]) to mean “include everything”.
• empty exclude → nothing is excluded.

The walker descends into all subdirectories unconditionally; path-level exclusion is the only mechanism for skipping vendored directories like node_modules. Callers wanting the classic blocklist should pass it explicitly via the exclude set.

pub fn build_from_patterns( repo_root: PathBuf, include: &[&str], exclude: &[&str], ) -> Result<Self>

Convenience wrapper around Self::build for callers that have glob strings rather than compiled GlobSets. The include and exclude slices are compiled into globsets here; an empty include list is rewritten to ["**/*"] so callers don’t have to remember the “include everything” idiom.

pub fn filter(&self, include: &GlobSet, exclude: &GlobSet) -> Self

Derive a stricter scope by AND-ing additional include/exclude rules onto the existing path set. The returned scope shares the same repo_root; its paths are a (possibly equal) subset of self.paths. No I/O happens — purely set arithmetic over the already-walked paths.

pub fn filter_by_patterns( &self, include: &[&str], exclude: &[&str], ) -> Result<Self>

Glob-string variant of Self::filter. Same empty-include convention as Self::build_from_patterns.

pub async fn read(&self) -> Result<ProjectScopeContent>

Read every in-scope file from disk into memory, producing a ProjectScopeContent. Reads run sequentially via tokio::fs; for very large projects we can swap in a JoinSet later, but sequential reads keep the failure ordering deterministic which matters for the resume-after-error story.

pub fn repo_root(&self) -> &Path

pub fn paths(&self) -> &BTreeSet<PathBuf>

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

Trait Implementations

impl Clone for ProjectScope

fn clone(&self) -> ProjectScope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProjectScope

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

Formats the value using the given formatter.