Count file stats by dir

src/worker/run/internal.rs

@@ -18,9 +18,15 @@ use super::{Finished, RunInProgress};
 
 #[derive(Default)]
 struct Counts {
+    files: usize,
+    lines: usize,
+    todos: usize,
     files_by_ext: HashMap<String, usize>,
     lines_by_ext: HashMap<String, usize>,
     todos_by_ext: HashMap<String, usize>,
+    files_by_dir: HashMap<String, usize>,
+    lines_by_dir: HashMap<String, usize>,
+    todos_by_dir: HashMap<String, usize>,
 }
 
 fn count(run: &RunInProgress, path: &Path) -> somehow::Result<Counts> {
@@ -36,10 +42,29 @@ fn count(run: &RunInProgress, path: &Path) -> somehow::Result<Counts> {
             continue;
         }
 
-        let extension = entry
+        let relative_path = entry
+            .path()
+            .components()
+            .collect::<Vec<_>>()
+            .into_iter()
+            .rev()
+            .take(entry.depth())
+            .rev()
+            .collect::<PathBuf>();
+
+        let ext = entry
             .path()
             .extension()
-            .unwrap_or_default()
+            .unwrap_or("none".as_ref())
+            .to_string_lossy()
+            .to_string();
+
+        let dir = relative_path
+            .components()
+            .next()
+            .filter(|_| relative_path.components().count() > 1)
+            .map(|c| c.as_os_str())
+            .unwrap_or("none".as_ref())
             .to_string_lossy()
             .to_string();
 
@@ -53,19 +78,16 @@ fn count(run: &RunInProgress, path: &Path) -> somehow::Result<Counts> {
             }
         }
 
-        *counts.files_by_ext.entry(extension.clone()).or_default() += 1;
+        counts.files += 1;
-        *counts.lines_by_ext.entry(extension.clone()).or_default() += lines;
+        counts.lines += lines;
-        *counts.todos_by_ext.entry(extension.clone()).or_default() += todos;
+        counts.todos += todos;
+        *counts.files_by_ext.entry(ext.clone()).or_default() += 1;
+        *counts.lines_by_ext.entry(ext.clone()).or_default() += lines;
+        *counts.todos_by_ext.entry(ext.clone()).or_default() += todos;
+        *counts.files_by_dir.entry(dir.clone()).or_default() += 1;
+        *counts.lines_by_dir.entry(dir.clone()).or_default() += lines;
+        *counts.todos_by_dir.entry(dir.clone()).or_default() += todos;
 
-        let relative_path = entry
-            .path()
-            .components()
-            .collect::<Vec<_>>()
-            .into_iter()
-            .rev()
-            .take(entry.depth())
-            .rev()
-            .collect::<PathBuf>();
         run.log_stdout(format!(
             "{} has {lines} line{}, {todos} todo{}",
             relative_path.display(),
@@ -77,72 +99,69 @@ fn count(run: &RunInProgress, path: &Path) -> somehow::Result<Counts> {
     Ok(counts)
 }
 
+fn measurement(value: f64, direction: Direction) -> Measurement {
+    Measurement {
+        value,
+        stddev: None,
+        unit: None,
+        direction: Some(direction),
+    }
+}
+
 fn measurements(counts: Counts) -> HashMap<String, Measurement> {
     let mut measurements = HashMap::new();
 
     // Files
     measurements.insert(
         "files".to_string(),
-        Measurement {
+        measurement(counts.files as f64, Direction::Neutral),
-            value: counts.files_by_ext.values().sum::<usize>() as f64,
-            stddev: None,
-            unit: None,
-            direction: Some(Direction::Neutral),
-        },
     );
-    for (extension, count) in counts.files_by_ext {
+    for (ext, count) in counts.files_by_ext {
         measurements.insert(
-            format!("files.{extension}"),
+            format!("files.by ext.{ext}"),
-            Measurement {
+            measurement(count as f64, Direction::Neutral),
-                value: count as f64,
+        );
-                stddev: None,
+    }
-                unit: None,
+    for (dir, count) in counts.files_by_dir {
-                direction: Some(Direction::Neutral),
+        measurements.insert(
-            },
+            format!("files.by dir.{dir}"),
+            measurement(count as f64, Direction::Neutral),
         );
     }
 
     // Lines
     measurements.insert(
         "lines".to_string(),
-        Measurement {
+        measurement(counts.lines as f64, Direction::Neutral),
-            value: counts.lines_by_ext.values().sum::<usize>() as f64,
-            stddev: None,
-            unit: None,
-            direction: Some(Direction::Neutral),
-        },
     );
-    for (extension, count) in counts.lines_by_ext {
+    for (ext, count) in counts.lines_by_ext {
         measurements.insert(
-            format!("lines.{extension}"),
+            format!("lines.by ext.{ext}"),
-            Measurement {
+            measurement(count as f64, Direction::Neutral),
-                value: count as f64,
+        );
-                stddev: None,
+    }
-                unit: None,
+    for (dir, count) in counts.lines_by_dir {
-                direction: Some(Direction::Neutral),
+        measurements.insert(
-            },
+            format!("lines.by dir.{dir}"),
+            measurement(count as f64, Direction::Neutral),
         );
     }
 
     // Todos
     measurements.insert(
         "todos".to_string(),
-        Measurement {
+        measurement(counts.todos as f64, Direction::LessIsBetter),
-            value: counts.todos_by_ext.values().sum::<usize>() as f64,
-            stddev: None,
-            unit: None,
-            direction: Some(Direction::LessIsBetter),
-        },
     );
-    for (extension, count) in counts.todos_by_ext {
+    for (ext, count) in counts.todos_by_ext {
         measurements.insert(
-            format!("todos.{extension}"),
+            format!("todos.by ext.{ext}"),
-            Measurement {
+            measurement(count as f64, Direction::LessIsBetter),
-                value: count as f64,
+        );
-                stddev: None,
+    }
-                unit: None,
+    for (dir, count) in counts.todos_by_dir {
-                direction: Some(Direction::LessIsBetter),
+        measurements.insert(
-            },
+            format!("todos.by dir.{dir}"),
+            measurement(count as f64, Direction::LessIsBetter),
         );
     }