Struct Pattern 

pub struct Pattern { /* private fields */ }

A pattern that can be matched against filesystem paths

Syntax

The syntax for patterns is similar to Linux’ glob, with a few differences.

• Normal characters behave as expected
• ? matches any character
• * matches any suite of characters, or no character at all
• [abc] matches any of a, b or c
• [!abc] matches any character except a, b and c
• [\[] matches [. The list of escapable characters is [, ], {, }, *, ?, \, /, | and ‘:’
  • [abc\[] matches any of a, b, c or [
• [[:alpha:]] will match any alphabetic character. The list of character classes are:
  • :alpha: for any alphabetic character
  • :digit: for any digit
  • :alphanumeric: for any alphabetic character or digit
  • :uppercase: for any uppercase character
  • :lowercase: for any lowercase character
  • :whitespace: for any whitespace character
• [![:alpha:]] will match any non-alphabetic character
• {a|bc} will match any of a or bc
  • This can be combined with other matchers, e.g. {[[:alpha:]][![:digit]]|[[:digit:]]*} will match any alphabetic character followed by a non-digit character, OR a digit followed by anything

Matches are performed against path components, e.g. in /path/to/item components are path, to and item. Matchers cannot match path separators.

In addition, note that ** will match any possible combination of directories. For instance, /**/*.txt will match any of /file.txt, /dir/file.txt, /dir/dir2/file.txt, and so on.

Platform-specific support

• / and \ are treated as path separators independently of the platform
• Absolute patterns can only be matched against absolute paths. e.g. /dir will not match dir. Note that using a crate::Walker will not cause this problem as a base directory is used.
• Absolute patterns can be matched against named drives in Windows, e.g. \dir will match against C:\dir (but not the opposite)
• Supported syntaxes for Windows drives are C:\ and \\?\C:\
• Other verbatim paths such as \\?\server\share or \\.\device are unsupported
• Paths starting with \\?\C:\ are normalized like any other path

Implementations

impl Pattern

pub fn new(input: &str) -> Result<Self, ParsingError>

Parse a pattern with the default options

pub fn new_with_opts( input: &str, opts: PatternOpts, ) -> Result<Self, ParsingError>

Parse a pattern

Examples found in repository

examples/walker.rs (lines 6-11)

fn main() {
    let pattern = Pattern::new_with_opts(
        "**/*.*",
        PatternOpts {
            case_insensitive: false,
        },
    )
    .unwrap();

    let walker = Walker::new(pattern, Path::new("/"));

    for path in walker {
        match path {
            Ok(path) => println!("OK: {}", path.display()),
            Err(err) => println!("ERR: {err}"),
        }
    }
}

pub fn is_absolute(&self) -> bool

Check if the pattern is absolute (only matches absolute paths)

pub fn prefix(&self) -> Option<PathPrefix>

Get the path prefix

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

Match the pattern against a path

Note that the path should be normalized. For instance, ‘..’ components in the pattern will be matched against literal ‘..’ in the path.

pub fn match_against(&self, path: &Path) -> PatternMatchResult

pub fn common_root_dir(&self) -> &Path

Get the common root directory for all possible matches of this pattern

pub fn has_wildcard(&self) -> bool

Check if the component contains a wildcard

Can be useful for e.g. determining if a matching directory should be traversed or not, as the presence or absence of a wildcard indicates whether descendants may match

Example:

• /a/b matches /a/b but cannot match any descendant
• /a/**/b matches /a/b and may match some descendants
• /a/b/** matches /a/b and may match some descendants

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pattern

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

Formats the value using the given formatter.