Struct FilterSettings 

pub struct FilterSettings {
    pub includes: Vec<FilterPattern>,
    pub excludes: Vec<FilterPattern>,
}

Settings for filtering files based on include/exclude patterns

Fields

includes: Vec<FilterPattern>

patterns for files to include (if non-empty, only matching files are included)

excludes: Vec<FilterPattern>

patterns for files to exclude

Implementations

impl FilterSettings

pub fn new() -> Self

Create new empty filter settings

pub fn add_include(&mut self, pattern: &str) -> Result<(), Error>

Add an include pattern

pub fn add_exclude(&mut self, pattern: &str) -> Result<(), Error>

Add an exclude pattern

pub fn is_empty(&self) -> bool

Check if this filter has any patterns

pub fn has_includes(&self) -> bool

Check if this filter has any include patterns

pub fn should_include_root_item( &self, name: &Path, is_dir: bool, ) -> FilterResult

Determine if a root item (the source itself) should be included based on filter patterns.

This is a specialized version of should_include for root items (the source directory or file being copied). Anchored patterns (starting with /) are skipped because they are meant to match paths INSIDE the source root, not the source root itself.

For root files, only non-anchored simple patterns (no /) can directly match the name. For root directories, they’re always traversed if include patterns exist (to find matching content inside).

For example, pattern /bar on source foo/ should match foo/bar, not filter out foo.

pub fn should_include(&self, relative_path: &Path, is_dir: bool) -> FilterResult

Determine if a path should be included based on filter patterns

Precedence

• If only excludes: include everything except matches
• If only includes: include only matches (exclude everything else by default)
• If both: excludes take priority (excludes checked first, then includes)

Directory handling

Directories are traversed when include patterns exist if they could potentially contain matching files. For non-anchored patterns (like *.txt), all directories are traversed. For anchored patterns (like /bar), only directories matching the pattern prefix are traversed.

pub fn directly_matches_include( &self, relative_path: &Path, is_dir: bool, ) -> bool

Check if a path directly matches any include pattern (not just could_contain_matches). Used to determine if an empty directory should be kept.

Returns true if:

• No include patterns exist (everything is directly included)
• At least one include pattern directly matches the path

Returns false if:

• Include patterns exist but none match the path (directory was only traversed)

pub fn could_contain_matches( &self, dir_path: &Path, pattern: &FilterPattern, ) -> bool

Check if a directory could potentially contain files matching the pattern

pub fn from_file(path: &Path) -> Result<Self, Error>

Parse filter settings from a file

File Format

# comments supported
--include *.rs
--include Cargo.toml
--exclude target/
--exclude *.log

pub fn parse_content(content: &str) -> Result<Self, Error>

Parse filter settings from a string (filter file format)

Trait Implementations

impl Clone for FilterSettings

fn clone(&self) -> FilterSettings

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FilterSettings

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

Formats the value using the given formatter.

impl Default for FilterSettings

fn default() -> FilterSettings

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FilterSettings

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Serialize for FilterSettings

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.