du-dust 0.6.1

A more intuitive version of du
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use crate::display_node::DisplayNode;
use crate::node::Node;
use std::collections::BinaryHeap;
use std::collections::HashSet;
use std::path::PathBuf;

pub fn get_by_depth(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode> {
    if top_level_nodes.is_empty() {
        // perhaps change this, bring back Error object?
        return None;
    }
    let root = get_new_root(top_level_nodes);
    Some(build_by_depth(&root, n - 1))
}

pub fn get_biggest(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode> {
    if top_level_nodes.is_empty() {
        // perhaps change this, bring back Error object?
        return None;
    }

    let mut heap = BinaryHeap::new();
    let number_top_level_nodes = top_level_nodes.len();
    let root = get_new_root(top_level_nodes);

    root.children.iter().for_each(|c| heap.push(c));

    let mut allowed_nodes = HashSet::new();
    allowed_nodes.insert(&root.name);

    for _ in number_top_level_nodes..n {
        let line = heap.pop();
        match line {
            Some(line) => {
                line.children.iter().for_each(|c| heap.push(c));
                allowed_nodes.insert(&line.name);
            }
            None => break,
        }
    }
    recursive_rebuilder(&allowed_nodes, &root)
}

fn build_by_depth(node: &Node, depth: usize) -> DisplayNode {
    let new_children = {
        if depth == 0 {
            vec![]
        } else {
            let mut new_children: Vec<_> = node
                .children
                .iter()
                .map(|c| build_by_depth(c, depth - 1))
                .collect();
            new_children.sort();
            new_children.reverse();
            new_children
        }
    };

    DisplayNode {
        name: node.name.clone(),
        size: node.size,
        children: new_children,
    }
}

fn get_new_root(top_level_nodes: Vec<Node>) -> Node {
    if top_level_nodes.len() > 1 {
        let total_size = top_level_nodes.iter().map(|node| node.size).sum();
        Node {
            name: PathBuf::from("(total)"),
            size: total_size,
            children: top_level_nodes,
            inode_device: None,
        }
    } else {
        top_level_nodes.into_iter().next().unwrap()
    }
}

fn recursive_rebuilder<'a>(
    allowed_nodes: &'a HashSet<&PathBuf>,
    current: &Node,
) -> Option<DisplayNode> {
    let mut new_children: Vec<_> = current
        .children
        .iter()
        .filter_map(|c| {
            if allowed_nodes.contains(&c.name) {
                recursive_rebuilder(allowed_nodes, c)
            } else {
                None
            }
        })
        .collect();
    new_children.sort();
    new_children.reverse();
    let newnode = DisplayNode {
        name: current.name.clone(),
        size: current.size,
        children: new_children,
    };
    Some(newnode)
}