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).

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

Match a path under file-walk semantics, honouring the leading-dot rule.

When dotglob is false (the default) a leading . in a path component is matched only by a segment that explicitly begins with a literal .: bare wildcards (*, ?, […]) and globstar (**) skip dot entries, so * hides dotfiles while .*, .github, and **/.env reach them. dotglob == true disables the rule (bash shopt -s dotglob).

This differs from matches, which is dotfile-agnostic and used for include/exclude filtering of already-walked paths.

pub fn could_descend(&self, dir: &Path, dotglob: bool) -> bool

Whether the walker should descend into the directory at relative path dir — i.e. whether some entry beneath it could still match.

Honours the same leading-dot rule as matches_walk: ** does not descend into hidden directories without dotglob, while an explicitly named dot directory (.github, or a .foo segment reached through a zero-width **) is entered.

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.