Added File Churn Metric (#1071)

* add churn metric

* add diff_count

* revert

* rename

* add churn cli flags

* fix integration test

* add unit tests

* try fix codeowners

* fix codeowners

* Optimize diff implementation

* delay conversion to String for filepaths to the last moment. That way, only the paths that
  are displayed will be converted in an operation that isn't free.
* change diff implementation to decode parents only once, instead of three times in the commmon case.
* setup an object cache in the `Repository` for faster traversals and much faster diffs.

* Don't fail on missing parent as we want to work in shallow repos, too

* Increase performance by decoding the commit only once

Previously, each time we would query commit information, the commit would
lazily be decoded until the point of interest under the hood.

Now we decode everything once, which is faster than what happened before.

Note that diffs are still causing the parents to be decoded even we *could*
pass them in, but it's not worth the complexity for just 100 commits
(the default value for churn).

* track changes on executable files

* remove for_each method

* use horizontal ellipsis

* review

* use MAIN_SEPERATOR when building path

* revert

* run expensive diffs in parallel and abort them once we run out of time.

That way, we could even use higher amounts of diffs if we wanted to, or could
warn if there was not enough time to reach the desired amount of diffs.

* Always calculate at least one diff for 'churn'

That way, there is always some data to work with.
This is important in case the repo is very small and the thread needs some time
to start-up and finish.

* improved readability + churn_pool_size CLI flag

The churn_pool_size allow the user to force onefetch to be deterministic
in the number of commits used to create the churn summary

* fix test

* halt if the churn pool size is bigger than the total number of commits

* improve readability

* add unit test

* refactor

* simplify `should_break()`

* update to latest `gix` version

* Avoid exhaustive memory consumption by sending the commit-id instead of its buffer.

The delta-processing happens by referring to a commit, and previously we could
send the whole commit buffer (which is expensive) as the overall amount of buffers
in flight would be bounded.

Now that the bound was removed, it's necessary to limit the costs of the commit,
and we do this by referring to it by id instead.

That way, on the linux kernel, we get these values for memory consumption:

* bounded: 960MB
* unbounded buffer: 2156
* unbounded id: 1033

---------

Co-authored-by: Sebastian Thiel <[email protected]>

Author: o2sh

Cargo.lock

@@ -26,7 +26,7 @@ clap_complete = "4.3.0"
 gix-features-for-configuration-only = { package = "gix-features", version = "0.29.0", features = [
     "zlib-ng",
 ] }
-gix = { version = "0.44.1", default-features = false, features = [
+gix = { version = "0.45.1", default-features = false, features = [
     "max-performance-safe",
 ] }
 git2 = { version = "0.17.1", default-features = false }
@@ -55,6 +55,7 @@ criterion = "0.4.0"
 gix-testtools = "0.12.0"
 insta = { version = "1.29.0", features = ["json", "redactions"] }
 pretty_assertions = "1.3.0"
+rstest = "0.17.0"
 
 [[bench]]
 name = "repo"

Cargo.toml

@@ -63,6 +63,15 @@ pub struct InfoCliOptions {
     /// Maximum NUM of languages to be shown
     #[arg(long, default_value_t = 6usize, value_name = "NUM")]
     pub number_of_languages: usize,
+    /// Maximum NUM of file churns to be shown
+    #[arg(long, default_value_t = 3usize, value_name = "NUM")]
+    pub number_of_file_churns: usize,
+    /// Maximum NUM of commits from HEAD used to compute the churn summary
+    ///
+    /// By default, the actual value is non-deterministic due to time-based computation
+    /// and will be displayed under the info title "Churn (NUM)"
+    #[arg(long, value_name = "NUM")]
+    pub churn_pool_size: Option<usize>,
     /// Ignore all files & directories matching EXCLUDE
     #[arg(long, short, num_args = 1.., value_hint = ValueHint::AnyPath)]
     pub exclude: Vec<PathBuf>,
@@ -228,6 +237,8 @@ impl Default for InfoCliOptions {
         InfoCliOptions {
             number_of_authors: 3,
             number_of_languages: 6,
+            number_of_file_churns: 3,
+            churn_pool_size: Option::default(),
             exclude: Vec::default(),
             no_bots: Option::default(),
             no_merges: Default::default(),

src/cli.rs

@@ -1,6 +1,6 @@
 use crate::{
     cli::NumberSeparator,
-    info::{format_number, utils::git::Commits, utils::info_field::InfoField},
+    info::{format_number, utils::git::CommitMetrics, utils::info_field::InfoField},
 };
 use owo_colors::{DynColors, OwoColorize};
 use serde::Serialize;
@@ -10,46 +10,42 @@ use std::fmt::Write;
 #[serde(rename_all = "camelCase")]
 pub struct Author {
     pub name: String,
-    email: String,
+    email: Option<String>,
     nbr_of_commits: usize,
     contribution: usize,
     #[serde(skip_serializing)]
-    show_email: bool,
-    #[serde(skip_serializing)]
     number_separator: NumberSeparator,
 }
 
 impl Author {
     pub fn new(
-        name: gix::bstr::BString,
-        email: gix::bstr::BString,
+        name: String,
+        email: Option<String>,
         nbr_of_commits: usize,
         total_nbr_of_commits: usize,
-        show_email: bool,
         number_separator: NumberSeparator,
     ) -> Self {
         let contribution =
             (nbr_of_commits as f32 * 100. / total_nbr_of_commits as f32).round() as usize;
         Self {
-            name: name.to_string(),
-            email: email.to_string(),
+            name,
+            email,
             nbr_of_commits,
             contribution,
-            show_email,
             number_separator,
         }
     }
 }
 
 impl std::fmt::Display for Author {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        if self.show_email {
+        if let Some(email) = &self.email {
             write!(
                 f,
                 "{}% {} <{}> {}",
                 self.contribution,
                 self.name,
-                self.email,
+                email,
                 format_number(&self.nbr_of_commits, self.number_separator)
             )
         } else {
@@ -72,8 +68,8 @@ pub struct AuthorsInfo {
 }
 
 impl AuthorsInfo {
-    pub fn new(info_color: DynColors, commits: &Commits) -> Self {
-        let authors = commits.authors_to_display.clone();
+    pub fn new(info_color: DynColors, commit_metrics: &CommitMetrics) -> Self {
+        let authors = commit_metrics.authors_to_display.clone();
         Self {
             authors,
             info_color,
@@ -91,9 +87,9 @@ impl std::fmt::Display for AuthorsInfo {
             let author_str = author.color(self.info_color);
 
             if i == 0 {
-                let _ = write!(authors_info, "{author_str}");
+                write!(authors_info, "{author_str}")?;
             } else {
-                let _ = write!(authors_info, "\n{:<width$}{}", "", author_str, width = pad);
+                write!(authors_info, "\n{:<width$}{}", "", author_str, width = pad)?;
             }
         }
 
@@ -128,10 +124,9 @@ mod test {
     fn test_display_author() {
         let author = Author::new(
             "John Doe".into(),
-            "[email protected]".into(),
+            Some("[email protected]".into()),
             1500,
             2000,
-            true,
             NumberSeparator::Plain,
         );
 
@@ -140,14 +135,7 @@ mod test {
 
     #[test]
     fn test_display_author_with_no_email() {
-        let author = Author::new(
-            "John Doe".into(),
-            "[email protected]".into(),
-            1500,
-            2000,
-            false,
-            NumberSeparator::Plain,
-        );
+        let author = Author::new("John Doe".into(), None, 1500, 2000, NumberSeparator::Plain);
 
         assert_eq!(author.to_string(), "75% John Doe 1500");
     }
@@ -156,10 +144,9 @@ mod test {
     fn test_authors_info_title_with_one_author() {
         let author = Author::new(
             "John Doe".into(),
-            "[email protected]".into(),
+            Some("[email protected]".into()),
             1500,
             2000,
-            true,
             NumberSeparator::Plain,
         );
 
@@ -175,19 +162,17 @@ mod test {
     fn test_authors_info_title_with_two_authors() {
         let author = Author::new(
             "John Doe".into(),
-            "[email protected]".into(),
+            Some("[email protected]".into()),
             1500,
             2000,
-            true,
             NumberSeparator::Plain,
         );
 
         let author_2 = Author::new(
             "Roberto Berto".into(),
-            "[email protected]".into(),
+            None,
             240,
             300,
-            false,
             NumberSeparator::Plain,
         );
 
@@ -203,10 +188,9 @@ mod test {
     fn test_author_info_value_with_one_author() {
         let author = Author::new(
             "John Doe".into(),
-            "[email protected]".into(),
+            Some("[email protected]".into()),
             1500,
             2000,
-            true,
             NumberSeparator::Plain,
         );
 
@@ -227,19 +211,17 @@ mod test {
     fn test_author_info_value_with_two_authors() {
         let author = Author::new(
             "John Doe".into(),
-            "[email protected]".into(),
+            Some("[email protected]".into()),
             1500,
             2000,
-            true,
             NumberSeparator::Plain,
         );
 
         let author_2 = Author::new(
             "Roberto Berto".into(),
-            "[email protected]".into(),
+            None,
             240,
             300,
-            false,
             NumberSeparator::Plain,
         );
 

src/info/author.rs

@@ -0,0 +1,157 @@
+use super::utils::{git::CommitMetrics, info_field::InfoField};
+use crate::{cli::NumberSeparator, info::format_number};
+use owo_colors::{DynColors, OwoColorize};
+use serde::Serialize;
+use std::fmt::Write;
+
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct FileChurn {
+    pub file_path: String,
+    pub nbr_of_commits: usize,
+    #[serde(skip_serializing)]
+    number_separator: NumberSeparator,
+}
+
+impl FileChurn {
+    pub fn new(
+        file_path: String,
+        nbr_of_commits: usize,
+        number_separator: NumberSeparator,
+    ) -> Self {
+        Self {
+            file_path,
+            nbr_of_commits,
+            number_separator,
+        }
+    }
+}
+
+impl std::fmt::Display for FileChurn {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "{} {}",
+            shorten_file_path(&self.file_path, 2),
+            format_number(&self.nbr_of_commits, self.number_separator)
+        )
+    }
+}
+
+#[derive(Serialize)]
+pub struct ChurnInfo {
+    pub file_churns: Vec<FileChurn>,
+    pub churn_pool_size: usize,
+    #[serde(skip_serializing)]
+    pub info_color: DynColors,
+}
+impl ChurnInfo {
+    pub fn new(info_color: DynColors, commit_metrics: &CommitMetrics) -> Self {
+        let file_churns = commit_metrics.file_churns_to_display.clone();
+        Self {
+            file_churns,
+            churn_pool_size: commit_metrics.churn_pool_size,
+            info_color,
+        }
+    }
+}
+impl std::fmt::Display for ChurnInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let mut churn_info = String::new();
+
+        let pad = self.title().len() + 2;
+
+        for (i, churn) in self.file_churns.iter().enumerate() {
+            let churn_str = churn.color(self.info_color);
+
+            if i == 0 {
+                write!(churn_info, "{churn_str}")?;
+            } else {
+                write!(churn_info, "\n{:<width$}{}", "", churn_str, width = pad)?;
+            }
+        }
+
+        write!(f, "{churn_info}")
+    }
+}
+
+#[typetag::serialize]
+impl InfoField for ChurnInfo {
+    fn value(&self) -> String {
+        self.to_string()
+    }
+
+    fn title(&self) -> String {
+        format!("Churn ({})", self.churn_pool_size)
+    }
+
+    fn should_color(&self) -> bool {
+        false
+    }
+}
+
+fn shorten_file_path(file_path: &str, depth: usize) -> String {
+    let components: Vec<&str> = file_path.split('/').collect();
+
+    if depth == 0 || components.len() <= depth {
+        return file_path.to_string();
+    }
+
+    let truncated_components: Vec<&str> = components
+        .iter()
+        .skip(components.len() - depth)
+        .copied()
+        .collect();
+
+    format!("\u{2026}/{}", truncated_components.join("/"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_display_file_churn() {
+        let file_churn = FileChurn::new("path/to/file.txt".into(), 50, NumberSeparator::Plain);
+
+        assert_eq!(file_churn.to_string(), "\u{2026}/to/file.txt 50");
+    }
+
+    #[test]
+    fn test_churn_info_value_with_two_file_churns() {
+        let file_churn_1 = FileChurn::new("path/to/file.txt".into(), 50, NumberSeparator::Plain);
+        let file_churn_2 = FileChurn::new("file_2.txt".into(), 30, NumberSeparator::Plain);
+
+        let churn_info = ChurnInfo {
+            file_churns: vec![file_churn_1, file_churn_2],
+            churn_pool_size: 5,
+            info_color: DynColors::Rgb(255, 0, 0),
+        };
+
+        assert!(churn_info.value().contains(
+            &"\u{2026}/to/file.txt 50"
+                .color(DynColors::Rgb(255, 0, 0))
+                .to_string()
+        ));
+
+        assert!(churn_info
+            .value()
+            .contains(&"file_2.txt 30".color(DynColors::Rgb(255, 0, 0)).to_string()));
+    }
+
+    #[test]
+    fn test_truncate_file_path() {
+        assert_eq!(shorten_file_path("path/to/file.txt", 3), "path/to/file.txt");
+        assert_eq!(shorten_file_path("another/file.txt", 2), "another/file.txt");
+        assert_eq!(shorten_file_path("file.txt", 1), "file.txt");
+        assert_eq!(
+            shorten_file_path("path/to/file.txt", 2),
+            "\u{2026}/to/file.txt"
+        );
+        assert_eq!(
+            shorten_file_path("another/file.txt", 1),
+            "\u{2026}/file.txt"
+        );
+        assert_eq!(shorten_file_path("file.txt", 0), "file.txt");
+    }
+}