plox 0.3.7

Turn messy logs into clean graphs. Plot fields or regex matches over time, mark events, count occurrences — all from your terminal.
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

use std::path::PathBuf;

pub fn common_path_ancestor(paths: &[PathBuf]) -> Option<PathBuf> {
	let canonicalized: Result<Vec<_>, _> = paths.iter().map(|p| p.canonicalize()).collect();
	common_path_ancestor_inner(&canonicalized.ok()?)
}

fn common_path_ancestor_inner(paths: &[PathBuf]) -> Option<PathBuf> {
	if paths.is_empty() {
		return None;
	}

	let mut iter = paths.iter();
	let first = iter.next()?;

	let mut components: Vec<_> =
		first.parent().expect("shall be full path here").components().collect();

	for path in iter {
		let mut new_components = Vec::new();
		for (a, b) in components
			.iter()
			.zip(path.parent().expect("shall be full path here").components())
		{
			if a == &b {
				new_components.push(*a);
			} else {
				break;
			}
		}
		if new_components.is_empty() {
			return None;
		}
		components = new_components;
	}

	let ancestor = components.iter().fold(PathBuf::new(), |mut acc, comp| {
		acc.push(comp.as_os_str());
		acc
	});

	Some(ancestor)
}

#[cfg(test)]
mod tests {
	use crate::{logging::init_tracing_test, utils::common_path_ancestor_inner};
	use std::path::PathBuf;

	#[test]
	fn test_common_path_ancestor() {
		init_tracing_test();
		let p1 = PathBuf::from("/a/b/c/log1");
		let p2 = PathBuf::from("/a/b/d/log2");
		let r = common_path_ancestor_inner(&[p1, p2]).unwrap();
		assert_eq!(r, PathBuf::from("/a/b"));
		let p1 = PathBuf::from("/a/b/d/log1");
		let p2 = PathBuf::from("/a/b/d/log2");
		let r = common_path_ancestor_inner(&[p1, p2]).unwrap();
		assert_eq!(r, PathBuf::from("/a/b/d"));
		let p1 = PathBuf::from("/a/b/d/log1");
		let p2 = PathBuf::from("/a/b/d/log2");
		let r = common_path_ancestor_inner(&[p1, p2]).unwrap();
		assert_eq!(r, PathBuf::from("/a/b/d"));
		let p1 = PathBuf::from("/a/c/d/log1");
		let p2 = PathBuf::from("/a/b/d/log2");
		let r = common_path_ancestor_inner(&[p1, p2]).unwrap();
		assert_eq!(r, PathBuf::from("/a"));
		let p1 = PathBuf::from("/a/c/d/log1");
		let r = common_path_ancestor_inner(&[p1]).unwrap();
		assert_eq!(r, PathBuf::from("/a/c/d/"));
		let p1 = PathBuf::from("/log1");
		let r = common_path_ancestor_inner(&[p1]).unwrap();
		assert_eq!(r, PathBuf::from("/"));
		let p1 = PathBuf::from("/log1");
		let p2 = PathBuf::from("/log2");
		let r = common_path_ancestor_inner(&[p1, p2]).unwrap();
		assert_eq!(r, PathBuf::from("/"));
	}
}