Struct Find 

pub struct Find<'a> { /* private fields */ }

File finder with pattern matching support.

Create via Find::new() and chain methods to configure the search.

Examples

Basic Pattern Matching

use heroforge_core::Repository;
use heroforge_core::fs::Find;

let repo = Repository::open("project.forge")?;

// Find all Rust source files
let rust_files = Find::new(&repo)
    .pattern("**/*.rs")
    .paths()?;

// Find multiple patterns
let source_files = Find::new(&repo)
    .patterns(&["**/*.rs", "**/*.toml", "**/*.md"])
    .paths()?;

Ignore Patterns

// Exclude build artifacts
let files = Find::new(&repo)
    .pattern("**/*.rs")
    .ignore("target/**")
    .ignore("**/generated/**")
    .paths()?;

// Use common gitignore patterns
let clean = Find::new(&repo)
    .pattern("**/*")
    .use_gitignore()
    .ignore_hidden()
    .paths()?;

Directory and Depth Limits

// Search only in src directory
let src_files = Find::new(&repo)
    .in_dir("src")
    .pattern("**/*.rs")
    .paths()?;

// Limit depth to 2 levels
let shallow = Find::new(&repo)
    .pattern("**/*")
    .max_depth(2)
    .paths()?;

Implementations

impl<'a> Find<'a>

pub fn new(repo: &'a Repository) -> Self

Create a new Find instance for the given repository.

pub fn at_commit(self, hash: &str) -> Self

Search at a specific commit hash.

pub fn on_trunk(self) -> Self

Search on trunk (default).

pub fn on_branch(self, branch: &str) -> Result<Self>

Search on a specific branch.

pub fn pattern(self, pattern: &str) -> Self

Add a glob pattern to match files.

Supports standard glob syntax:

• * matches any sequence of characters in a path segment
• ** matches any sequence of path segments
• ? matches any single character
• [abc] matches any character in the brackets

pub fn patterns(self, patterns: &[&str]) -> Self

Add multiple glob patterns at once.

pub fn ignore(self, pattern: &str) -> Self

Exclude files matching this pattern.

pub fn ignore_patterns(self, patterns: &[&str]) -> Self

Add multiple ignore patterns at once.

pub fn ignore_hidden(self) -> Self

Exclude hidden files (files starting with .).

pub fn use_gitignore(self) -> Self

Apply common gitignore-style patterns.

pub fn ignore_case(self) -> Self

Enable case-insensitive pattern matching.

pub fn max_depth(self, depth: usize) -> Self

Limit search to a maximum directory depth.

pub fn files_only(self) -> Self

Only match regular files (exclude executables and symlinks).

pub fn executables_only(self) -> Self

Only match executable files.

pub fn symlinks_only(self) -> Self

Only match symbolic links.

pub fn min_size(self, bytes: usize) -> Self

Filter to files at least this size (in bytes).

pub fn max_size(self, bytes: usize) -> Self

Filter to files at most this size (in bytes).

pub fn in_dir(self, dir: &str) -> Self

Restrict search to a specific directory.

pub fn execute(&self) -> Result<FindResult>

Execute the search and return full results with metadata.

pub fn paths(&self) -> Result<Vec<String>>

Execute and return just the file paths.

pub fn count(&self) -> Result<usize>

Execute and return only the count of matching files.