Struct fs_tree::FsTree

pub struct FsTree {
    pub path: PathBuf,
    pub file_type: TreeNode,
}

A filesystem tree recursive type.

Methods for iteration: .iter(), .nodes() or .paths().

Fields

path: PathBuf

The filename of this file.

file_type: TreeNode

The TreeNode of this file.

Implementations

impl FsTree

pub fn new_regular(path: impl Into<PathBuf>) -> Self

Creates a FsTree::Regular from arguments.

pub fn new_directory(path: impl Into<PathBuf>, children: Vec<Self>) -> Self

Creates a FsTree::Directory from arguments.

pub fn new_symlink( path: impl Into<PathBuf>, target_path: impl Into<PathBuf> ) -> Self

Creates a FsTree::Symlink from arguments.

pub fn collect_from_directory(path: impl AsRef<Path>) -> Result<Vec<Self>>

Collects a Vec of FsTree from path that is a directory.

pub fn collect_from_directory_symlink( path: impl AsRef<Path> ) -> Result<Vec<Self>>

Collects a Vec of FsTree from path that is a directory, entries can be symlinks.

pub fn from_path(path: impl AsRef<Path>) -> Result<Self>

Builds a FsTree from path, follows symlinks.

Similar to from_path_symlink.

If file at path is a regular file, will return a FsTree::Regular. If file at path is a directory file, FsTree::Directory (with .children).

Errors:

• If Io::Error from fs::metadata(path)
• If it is a directory, and Io::Error from fs::read_dir(path) iterator usage
• If unexpected file type at path

This function traverses symlinks until final destination, and then reads it, so it can never return Ok(FsTree::Symlink { .. ]}), if you wish otherwise, use FsTree::from_path_symlink instead.

pub fn from_path_symlink(path: impl AsRef<Path>) -> Result<Self>

Builds a FsTree from path, follows symlinks.

Similar to from_path_symlink.

If file at path is a regular file, will return a FsTree::Regular. If file at path is a directory file, FsTree::Directory (with children field). If file at path is a symlink file, FsTree::Symlink (with target_path field).

Errors:

• If Io::Error from fs::metadata(path)
• If it is a directory, and Io::Error from fs::read_dir(path) iterator usage
• If it is a symlink, and Io::Error from fs::read_link(path)
• If unexpected file type at path

If you wish to traverse symlinks until final destination, instead, use FsTree::from_path.

pub fn from_path_text(path: impl AsRef<Path>) -> Option<Self>

Splits Path pieces into a FsTree.

Returns None if the string is empty.

Can only build Regular and Directory, not symlink.

Example:

use fs_tree::{FsTree, tree};

let result = FsTree::from_path_text("dir/inner/file");

let expected = tree! {
    dir: {
        inner: {
            file
        }
    }
};

assert_eq!(result, Some(expected));

pub fn from_path_pieces<I, P>(path_iter: I) -> Option<Self>where I: IntoIterator<Item = P>, P: AsRef<Path>,

Generic version of FsTree::from_path_text.

Returns None if path is empty.

pub fn iter(&self) -> Iter<'_>

An iterator over (&FsTree, PathBuf).

pub fn files(&self) -> FilesIter<'_>

Iterator of all FsTrees in the structure

pub fn paths(&self) -> PathsIter<'_>

Shorthand for self.files().paths(), see link to .paths() method

pub fn make_paths_relative(&mut self)

Fix relative paths from each node piece.

If you manually build a structure like:

"a": [
    "b": [
        "c",
    ]
]

Using the create methods, then you need to run this function to make them relative paths.

"a": [
    "a/b": [
        "a/b/c",
    ]
]

Then, you can access any of the files only by looking at their path.

pub fn make_paths_absolute(&mut self) -> Result<()>

Makes all paths in the tree absolute.

Errors:

In case std::fs::canonicalize fails at any path, this function will stop and return an IoError, leave the tree in a mixed state in terms of canonical paths.

pub fn merge(self, other: Self) -> Option<Self>

Merge this tree with other FsTree.

This function is currently experimental and likely to change in future versions.

Errors:

This errs if:

• The trees have different roots and thus cannot be merged.
• There are file conflicts.

pub fn children(&self) -> Option<&[Self]>

Reference to children vec if self.is_directory().

pub fn children_mut(&mut self) -> Option<&mut Vec<Self>>

Reference to children vec if self.is_directory(), mutable.

pub fn target(&self) -> Option<&PathBuf>

Reference to target_path if self.is_symlink().

pub fn target_mut(&mut self) -> Option<&mut PathBuf>

Reference to target_path if self.is_symlink(), mutable.

pub fn apply_to_children0(&mut self, f: impl FnMut(&mut Self))

Apply a closure for each direct child of this FsTree.

Only 1 level deep.

pub fn apply_to_all_children1(&mut self, f: impl FnMut(&mut Self) + Copy)

Apply a closure to all direct and indirect descendants inside of this structure.

Calls recursively for all levels.

pub fn apply_to_all(&mut self, f: impl FnMut(&mut Self) + Copy)

Apply a closure to all direct and indirect descendants inside, also includes root.

Calls recursively for all levels.

pub fn is_regular(&self) -> bool

Shorthand for file.file_type.is_regular()

pub fn is_dir(&self) -> bool

Shorthand for file.file_type.is_dir()

pub fn is_symlink(&self) -> bool

Shorthand for file.file_type.is_symlink()

pub fn to_regular(self) -> Self

Turn this node of the tree into a regular file.

Beware the possible recursive drop of nested nodes if this node was a directory.

pub fn to_directory(self, children: Vec<Self>) -> Self

Turn this node of the tree into a directory.

Beware the possible recursive drop of nested nodes if this node was a directory.

pub fn to_symlink(self, target_path: impl Into<PathBuf>) -> Self

Turn this node of the tree into a symlink.

Beware the possible recursive drop of nested nodes if this node was a directory.

pub fn has_same_type_as(&self, other: &FsTree) -> bool

Checks if the FsTree file type is the same as other FsTree.

pub fn create_at(&self, folder: impl AsRef<Path>) -> Result<()>

Create the tree folder structure in the path

pub fn create(&self) -> Result<()>

Create FsTree in the current directory.

Alias to self.create_at(".").

pub fn get(&self, path: impl AsRef<Path>) -> Option<&FsTree>

Returns a reference to the node at the path.

Examples:

use fs_tree::FsTree;

let root = FsTree::from_path_text("root/b/c/d").unwrap();

// Indexing is relative from `root`, so `root` cannot be indexed.
assert!(root.get("root").is_none());

assert_eq!(root["b"], FsTree::from_path_text("b/c/d").unwrap());
assert_eq!(root["b/c"], FsTree::from_path_text("c/d").unwrap());
assert_eq!(root["b"]["c"], FsTree::from_path_text("c/d").unwrap());
assert_eq!(root["b/c/d"], FsTree::from_path_text("d").unwrap());
assert_eq!(root["b/c"]["d"], FsTree::from_path_text("d").unwrap());
assert_eq!(root["b"]["c/d"], FsTree::from_path_text("d").unwrap());
assert_eq!(root["b"]["c"]["d"], FsTree::from_path_text("d").unwrap());

Trait Implementations

impl Clone for FsTree

fn clone(&self) -> FsTree

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FsTree

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

Formats the value using the given formatter.

impl Hash for FsTree

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<P> Index<P> for FsTreewhere P: AsRef<Path>,

type Output = FsTree

The returned type after indexing.

fn index(&self, path: P) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Ord for FsTree

fn cmp(&self, other: &FsTree) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<FsTree> for FsTree

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<FsTree> for FsTree

fn partial_cmp(&self, other: &FsTree) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for FsTree

impl StructuralEq for FsTree

impl StructuralPartialEq for FsTree