Struct GlobPath 

pub struct GlobPath { /* private fields */ }

A path-aware glob pattern with globstar support.

Examples

use kaish_glob::GlobPath;
use std::path::Path;

let pattern = GlobPath::new("**/*.rs").unwrap();
assert!(pattern.matches(Path::new("main.rs")));
assert!(pattern.matches(Path::new("src/main.rs")));
assert!(pattern.matches(Path::new("src/lib/utils.rs")));
assert!(!pattern.matches(Path::new("README.md")));

Implementations

impl GlobPath

pub fn new(pattern: &str) -> Result<GlobPath, PatternError>

Parse a glob pattern into a GlobPath.

Patterns starting with / are anchored to the root. ** matches zero or more directory components.

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

Check if a path matches this pattern.

pub fn static_prefix(&self) -> Option<PathBuf>

Get the static prefix of the pattern (directories before any wildcard).

This is useful for optimization: we can start the walk from this prefix instead of the root.

Examples

use kaish_glob::GlobPath;
use std::path::PathBuf;

let pattern = GlobPath::new("src/lib/**/*.rs").unwrap();
assert_eq!(pattern.static_prefix(), Some(PathBuf::from("src/lib")));

let pattern = GlobPath::new("**/*.rs").unwrap();
assert_eq!(pattern.static_prefix(), None);

pub fn split_static_dir(&self) -> (PathBuf, GlobPath)

Split the pattern into its deepest static directory prefix and the remaining pattern to match beneath it.

Used to start a walk from the literal leading directories instead of the filesystem root: walking from / is O(filesystem) and skips hidden intermediate directories, so /tmp/.tmpXXXX/*.txt would match nothing. At least one segment is always kept in the remaining pattern, so an all-literal pattern (/a/b/c.txt) walks /a/b and matches c.txt rather than trying to descend into the file itself. The returned pattern is unanchored (the anchor is consumed by the caller’s walk root).

Examples

use kaish_glob::GlobPath;
use std::path::{Path, PathBuf};

let (dir, rest) = GlobPath::new("/a/b/*.txt").unwrap().split_static_dir();
assert_eq!(dir, PathBuf::from("a/b"));
assert!(rest.matches(Path::new("c.txt")));

// All-literal: the final component stays in the match pattern.
let (dir, rest) = GlobPath::new("/a/b/c.txt").unwrap().split_static_dir();
assert_eq!(dir, PathBuf::from("a/b"));
assert!(rest.matches(Path::new("c.txt")));

// No static prefix (leading wildcard / globstar): empty dir, full pattern.
let (dir, _rest) = GlobPath::new("**/*.rs").unwrap().split_static_dir();
assert_eq!(dir, PathBuf::new());

pub fn is_dir_only(&self) -> bool

Check if the pattern only matches directories.

pub fn is_anchored(&self) -> bool

Check if the pattern is anchored (starts with /).

pub fn has_globstar(&self) -> bool

Check if the pattern contains a globstar (**).

Patterns with globstar require recursive directory traversal. Patterns without globstar only match at a fixed depth.

pub fn fixed_depth(&self) -> Option<usize>

Get the depth of the pattern (number of path components).

Returns None if the pattern contains globstar (variable depth).

Trait Implementations

impl Clone for GlobPath

fn clone(&self) -> GlobPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GlobPath

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

Formats the value using the given formatter.