spacehog 0.1.5

A simple utility for finding large files on your system.
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::fmt::Display;
use std::fs::ReadDir;
use std::io;
use std::path::PathBuf;

use crate::bytes;

pub fn from_path(path: &str) -> io::Result<FileIter> {
    let dir = std::fs::read_dir(path)?;
    Ok(FileIter { stack: vec![dir] })
}

#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
pub struct File {
    size: Size,
    path: PathBuf,
}

impl File {
    pub fn new(path: impl Into<PathBuf>, size: u64) -> Self {
        File {
            size: Size(size),
            path: path.into(),
        }
    }
}

impl Display for File {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{} {}", self.size, self.path.display())
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub struct Size(u64);

impl Display for Size {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", bytes::humanize(self.0))
    }
}

pub struct FileIter {
    stack: Vec<ReadDir>,
}

impl Iterator for FileIter {
    type Item = File;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            if let Some(dir) = self.stack.last_mut() {
                // Explore the current directory.
                if let Some(entry) = dir.next() {
                    let entry = entry.ok()?;
                    let path = entry.path();
                    if path.is_dir() {
                        self.stack.push(std::fs::read_dir(path).ok()?);
                    } else {
                        return Some(File::new(path, entry.metadata().ok()?.len()));
                    }
                } else {
                    // No more entries in the current directory.
                    self.stack.pop();
                }
            } else {
                // No more directories to explore.
                return None;
            }
        }
    }
}

#[cfg(test)]
mod test {
    use super::{from_path, File};

    #[test]
    fn file_can_be_formatted_as_a_string() {
        struct Case {
            file: File,
            want: &'static str,
        }
        let cases = vec![
            Case {
                file: File::new("/path/to/file.txt", 1000),
                want: "1 KB /path/to/file.txt",
            },
            Case {
                file: File::new("/path/to/file.txt", 34250),
                want: "34 KB /path/to/file.txt",
            },
        ];
        for case in cases {
            let got = case.file.to_string();
            assert_eq!(case.want, got);
        }
    }

    #[test]
    fn files_can_be_sorted_in_descending_order() {
        let mut files = vec![
            File::new("/path/to/a.txt", 20),
            File::new("/path/to/b.txt", 10),
            File::new("/path/to/d.txt", 10),
            File::new("/path/to/c.txt", 30),
        ];

        let want = vec![
            File::new("/path/to/c.txt", 30),
            File::new("/path/to/a.txt", 20),
            File::new("/path/to/d.txt", 10),
            File::new("/path/to/b.txt", 10),
        ];
        files.sort_by(|a, b| b.cmp(a));

        assert_eq!(want, files);
    }

    #[test]
    fn from_path_returns_iterator_over_files_in_the_given_path() {
        let want = vec![
            File::new("./testdata/en/hello.txt", 6),
            File::new("./testdata/en/world.txt", 7),
            File::new("./testdata/es/hola.txt", 5),
            File::new("./testdata/es/mundo.txt", 6),
        ];
        let mut got = from_path("./testdata").unwrap().collect::<Vec<_>>();
        // Sort by path for consistent ordering.
        got.sort_by_key(|f| f.path.clone());
        assert_eq!(want, got);
    }
}