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
use config::Options;
use display;
use ignore::{DirEntry, Error, Walk};
use stats_collector::{FileType, StatsCollector};
use walker::build_shallow;
/// Streamer represents the object traversing the filesystem, printing the structure and collecting stats.
pub struct Streamer {
prev_depth: usize,
curr_depth: usize,
parent_depths: Vec<usize>,
curr_line_count: Option<usize>,
collector: StatsCollector,
dir_only: bool,
count_lines: bool,
colours: bool,
options: Options,
}
impl Streamer {
pub fn new(opt: Options, collector: StatsCollector) -> Streamer {
Streamer {
prev_depth: 0,
curr_depth: 0,
parent_depths: vec![],
curr_line_count: None,
collector: collector,
dir_only: opt.dir_only,
count_lines: opt.line_count,
colours: !opt.no_colours,
options: opt,
}
}
/// kicks off a recursive streaming of a directory file structure
pub fn stream_tree(&mut self, walker: &mut Walk) -> Result<(), Error> {
let mut prev = walker
.next()
.expect("could not get first element from walker")
.expect("could not get first element from walker");
self.prev_depth = prev.depth();
// walker traverses depth first, ignoring files/folders it can't parse or does not have permission to
for dir in walker.into_iter().filter_map(|e| e.ok()) {
self.curr_depth = dir.depth();
self.stream_node(&prev, false)?;
prev = dir;
self.prev_depth = self.curr_depth;
}
self.stream_node(&prev, true)?;
println!("{}", self.collector);
Ok(())
}
/// parse and stream an individual node, correctly printing its representation and updating statistics.
fn stream_node(&mut self, node: &DirEntry, is_last: bool) -> Result<(), Error> {
let mut is_last = is_last;
let file_name = node.file_name().to_owned().into_string().unwrap();
//parses current file type and tally stats
let file_type = self.collector.parse_and_collect(node)?;
// match on file type to do additional logic, such as skip directory or do line counting
match file_type {
FileType::File if self.dir_only => return Ok(()),
FileType::File if self.count_lines => {
// if failed to count lines (.e.g. no permission to read file) just pretend its 0
self.curr_line_count = Some(self.collector.count_lines(node).unwrap_or(0));
}
_ => self.curr_line_count = None,
}
let mut should_pop = false;
// This logic allows us to keep record parents (store in vec) of the current file.
// We are always traversing one file ahead of what we print, so we can tell whether the thing to print
// is the last of its parent directory (when the depth changes)
// additional we build a shallow walker that tries to figure out if the paren dir is the last dir,
// if so we pop it from the vec stack because we don't need to print that branch afterwards.
if self.prev_depth != self.curr_depth {
if self.prev_depth < self.curr_depth {
if let Some(parent_path) = node.path().parent() {
let mut shallow_walker = build_shallow(parent_path, &self.options)?
.into_iter()
.filter_map(|e| e.ok())
.skip_while(|n| n.path() != node.path())
.skip(1);
if let Some(_) = shallow_walker.next() {
self.parent_depths.push(self.prev_depth);
} else {
is_last = true;
}
}
} else {
should_pop = true;
is_last = true;
}
}
display::print(
file_name,
file_type,
self.prev_depth,
is_last,
&self.parent_depths,
self.curr_line_count,
self.colours,
);
if should_pop {
self.parent_depths.pop();
}
Ok(())
}
}