cargo-reclaim 0.2.1

Safe Cargo cleanup for target directories, stale artifacts, and Cargo home caches
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use std::error::Error;
use std::fmt;
use std::path::PathBuf;

pub type ReclaimResult<T> = Result<T, ReclaimError>;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ReclaimError {
    EmptyPath,
    EmptyEvidence,
    EmptyPolicyReason,
    AbsoluteInventoryChildPath { path: PathBuf },
    InventoryPathEscape { path: PathBuf },
    InventorySymlinkNotFollowed { path: PathBuf },
    MissingInventoryPath { path: PathBuf },
    InventoryRead { path: PathBuf, message: String },
    DiskRead { path: PathBuf, message: String },
}

impl fmt::Display for ReclaimError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::EmptyPath => formatter.write_str("path must not be empty"),
            Self::EmptyEvidence => formatter.write_str("target evidence must not be empty"),
            Self::EmptyPolicyReason => formatter.write_str("policy reason must not be empty"),
            Self::AbsoluteInventoryChildPath { path } => {
                write!(
                    formatter,
                    "inventory child path must be relative: {}",
                    path.display()
                )
            }
            Self::InventoryPathEscape { path } => {
                write!(
                    formatter,
                    "inventory child path must not escape target root: {}",
                    path.display()
                )
            }
            Self::InventorySymlinkNotFollowed { path } => {
                write!(
                    formatter,
                    "inventory path is a symlink and symlink following is disabled: {}",
                    path.display()
                )
            }
            Self::MissingInventoryPath { path } => {
                write!(
                    formatter,
                    "inventory path does not exist: {}",
                    path.display()
                )
            }
            Self::InventoryRead { path, message } => {
                write!(
                    formatter,
                    "failed to read inventory path {}: {message}",
                    path.display()
                )
            }
            Self::DiskRead { path, message } => {
                write!(
                    formatter,
                    "failed to read disk metrics for {}: {message}",
                    path.display()
                )
            }
        }
    }
}

impl Error for ReclaimError {}