Enum TraversalPath 

pub enum TraversalPath {
    Direct,
    Symlink {
        target: PathBuf,
        target_exists: bool,
    },
    Mount {
        filesystem: FilesystemType,
        mount_point: PathBuf,
    },
    Recursive {
        depth: usize,
        original: PathBuf,
    },
    Dependency {
        manager: DependencyManager,
        dep_root: PathBuf,
    },
}

How we reached this location during traversal. This context helps understand if a path is “real” or indirect.

Variants

Direct

Directly under the scan root via normal directory traversal

Symlink

Reached via symbolic link

Fields

target: PathBuf

The actual target of the symlink

target_exists: bool

Whether the target exists

Mount

Crossed a mount point boundary

Fields

filesystem: FilesystemType

The filesystem type we’re now on

mount_point: PathBuf

Mount point path

Recursive

Reached via recursive traversal into a nested structure

Fields

depth: usize

How deep we are from the original interesting location

original: PathBuf

The original path that led us here

Dependency

Inside a dependency/vendor directory (node_modules, vendor, etc.)

Fields

manager: DependencyManager

Type of dependency manager

dep_root: PathBuf

Root of the dependency tree

Trait Implementations

impl Clone for TraversalPath

fn clone(&self) -> TraversalPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TraversalPath

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TraversalPath

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TraversalPath

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TraversalPath

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TraversalPath