Struct IgnoreSpec 

pub struct IgnoreSpec {
    pub gitignore: bool,
    pub dot_ignore: bool,
    pub exclude_git: bool,
    pub patterns: Vec<String>,
}

What a sync excludes. Part of the shared root’s identity (crate::RootKey): two syncs indexing different trees cannot share a reconciler, exactly as for recursive — so this derives Hash/Eq over the normalized pattern list rather than over a compiled matcher.

Fields

gitignore: bool

Honor .gitignore in and above the root, plus the governing repository’s $GIT_DIR/info/exclude and the user’s core.excludesFile.

dot_ignore: bool

Honor .ignore in and above the root — ripgrep’s convention, which a project can use to hide things from tooling without telling git to stop tracking them.

exclude_git: bool

Omit every entry whose final component is exactly .git.

patterns: Vec<String>

Extra gitignore-syntax patterns, root-anchored, highest precedence.

Implementations

impl IgnoreSpec

pub fn is_empty(&self) -> bool

Nothing to exclude: the reconciler skips building a matcher at all, so an unfiltered sync pays exactly what it paid before.

pub fn reads_ignore_files(&self) -> bool

Whether any per-directory ignore file is consulted.

pub fn file_names(&self) -> Vec<&'static str>

Per-directory ignore file names this spec reads, ascending precedence within one directory.

pub fn parse_patterns(text: &str) -> Vec<String>

Normalize the wire form — one gitignore line per \n — into the pattern list. Blank lines and # comments are dropped here rather than at compile time so that two specs differing only in whitespace share one shared root.

Order carries meaning only when a negation is present, since gitignore’s rule is last-match-wins and a list of pure exclusions commutes. Such a list is therefore sorted and deduplicated, so two clients that asked for the same thing in a different order share one root instead of building two identical indexes. A list with a ! in it is left exactly as written — reordering it would change what it means.

Trait Implementations

impl Clone for IgnoreSpec

fn clone(&self) -> IgnoreSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IgnoreSpec

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

Formats the value using the given formatter.

impl Default for IgnoreSpec

fn default() -> IgnoreSpec

Returns the “default value” for a type.

impl Eq for IgnoreSpec

impl Hash for IgnoreSpec

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for IgnoreSpec

fn eq(&self, other: &IgnoreSpec) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for IgnoreSpec