devclean 0.1.2

A tool to clean up your development environment
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
73
74
75
76
77
78
79
80
81
82
83
84

use human_bytes::human_bytes;
use prettytable::format;
use prettytable::{color, Attr, Cell, Row, Table};
use serde::{Deserialize, Serialize};
use std::path::PathBuf;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct AnalyzeTarget {
    pub path: PathBuf,
    pub depth: u16,
    pub size: Option<u64>,
}

impl PartialOrd for AnalyzeTarget {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for AnalyzeTarget {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.size.cmp(&other.size)
    }
}

impl std::fmt::Display for AnalyzeTarget {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{} ({})",
            self.path.to_string_lossy(),
            human_bytes(self.size.unwrap_or(0) as f64)
        )
    }
}

impl AnalyzeTarget {
    pub fn new(path: PathBuf, depth: u16, size: Option<u64>) -> Self {
        AnalyzeTarget { path, depth, size }
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct AnalyzeTargets(pub Vec<AnalyzeTarget>);

impl From<&AnalyzeTarget> for Row {
    fn from(target: &AnalyzeTarget) -> Self {
        Row::new(vec![
            Cell::new(&target.path.to_string_lossy())
                .with_style(Attr::ForegroundColor(color::GREEN)),
            Cell::new(&target.depth.to_string()),
            Cell::new(human_bytes(target.size.unwrap_or(0) as f64).as_str()),
        ])
    }
}

impl From<&AnalyzeTargets> for Table {
    fn from(targets: &AnalyzeTargets) -> Self {
        let mut table = Table::new();
        table.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
        table.set_titles(Row::new(vec![
            Cell::new("Path").with_style(Attr::Bold),
            Cell::new("Depth").with_style(Attr::Bold),
            Cell::new("Size").with_style(Attr::Bold),
        ]));
        for target in &targets.0 {
            table.add_row(Row::from(target));
        }
        table
    }
}

impl AnalyzeTargets {
    pub fn to_table(&self) -> Table {
        Table::from(self)
    }
}

impl std::fmt::Display for AnalyzeTargets {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let table = Table::from(self);
        write!(f, "{}", table)
    }
}