Struct PatternMatcher 

pub struct PatternMatcher { /* private fields */ }

Pattern matcher for resource discovery in repositories.

The PatternMatcher provides glob pattern matching capabilities for discovering resources in Git repositories and local directories. It supports standard glob patterns and handles cross-platform path matching.

Thread Safety

PatternMatcher is thread-safe and can be cloned for use in concurrent contexts.

Examples

use agpm_cli::pattern::PatternMatcher;
use std::path::Path;

let matcher = PatternMatcher::new("agents/*.md")?;

// Check if a path matches
assert!(matcher.matches(Path::new("agents/helper.md")));
assert!(!matcher.matches(Path::new("snippets/code.md")));

// Find all matches in a directory
let matches = matcher.find_matches(Path::new("/path/to/repo"))?;
println!("Found {} matching files", matches.len());

Implementations

impl PatternMatcher

pub fn new(pattern_str: &str) -> Result<Self>

Creates a new pattern matcher from a glob pattern string.

The pattern is compiled once during creation for efficient matching. Invalid glob patterns will return an error.

Arguments

• pattern_str - A glob pattern string (e.g., “.md”, “**/.py”)

Returns

A new PatternMatcher instance ready for matching operations.

Errors

Returns an error if:

• The pattern contains invalid glob syntax
• The pattern is malformed or contains unsupported features

Examples

use agpm_cli::pattern::PatternMatcher;

// Simple wildcard
let matcher = PatternMatcher::new("*.md")?;

// Recursive matching
let matcher = PatternMatcher::new("**/docs/*.md")?;

// Character classes
let matcher = PatternMatcher::new("agent[0-9].md")?;

pub fn find_matches(&self, base_path: &Path) -> Result<Vec<PathBuf>>

Finds all files matching the pattern in the specified directory.

This method recursively traverses the directory tree and returns all files that match the compiled pattern. The search is performed relative to the base path, ensuring portable pattern matching across platforms.

Security

This method includes security measures:

• Does not follow symlinks to prevent directory traversal attacks
• Returns relative paths to prevent information disclosure
• Handles permission errors gracefully

Arguments

• base_path - The directory to search in (must exist)

Returns

A vector of relative paths (from base_path) that match the pattern. Paths are returned as PathBuf for easy manipulation.

Errors

Returns an error if:

• The base path does not exist or cannot be accessed
• The base path cannot be canonicalized
• Permission errors occur during directory traversal
• I/O errors prevent directory reading

Examples

use agpm_cli::pattern::PatternMatcher;
use std::path::Path;

let matcher = PatternMatcher::new("**/*.md")?;
let matches = matcher.find_matches(Path::new("/repo"))?;

for path in matches {
    println!("Found: {}", path.display());
}

pub fn matches(&self, path: &Path) -> bool

Checks if a single path matches the compiled pattern.

This is a lightweight operation that checks if the given path matches the pattern without filesystem access. Useful for filtering or validation operations.

Arguments

• path - The path to test against the pattern

Returns

true if the path matches the pattern, false otherwise.

Examples

use agpm_cli::pattern::PatternMatcher;
use std::path::Path;

let matcher = PatternMatcher::new("agents/*.md")?;

assert!(matcher.matches(Path::new("agents/helper.md")));
assert!(matcher.matches(Path::new("agents/reviewer.md")));
assert!(!matcher.matches(Path::new("snippets/code.md")));
assert!(!matcher.matches(Path::new("agents/nested/deep.md")));

pub fn pattern(&self) -> &str

Returns the original pattern string used to create this matcher.

Useful for logging, debugging, or displaying the pattern to users.

Returns

The original pattern string as provided to PatternMatcher::new.

Examples

use agpm_cli::pattern::PatternMatcher;

let pattern_str = "**/*.md";
let matcher = PatternMatcher::new(pattern_str)?;

assert_eq!(matcher.pattern(), pattern_str);

Trait Implementations

impl Clone for PatternMatcher

fn clone(&self) -> PatternMatcher

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PatternMatcher

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

Formats the value using the given formatter.