Calculate authors on the fly as much as possible; don't store commits

Author: Byron

src/info/author.rs

@@ -25,6 +25,10 @@ impl Author {
             contribution,
         }
     }
+
+    pub fn clear_email(&mut self) {
+        self.email = None;
+    }
 }
 
 impl std::fmt::Display for Author {

src/info/mod.rs

@@ -159,7 +159,7 @@ impl Info {
     pub fn new(config: Config) -> Result<Self> {
         let git_version = cli::get_git_version();
         let repo = Repository::discover(&config.repo_path)?;
-        let internal_repo = Repo::new(&repo, config.no_merges, &config.bot_regex_pattern)?;
+        let mut internal_repo = Repo::new(&repo, config.no_merges, &config.bot_regex_pattern)?;
         let (repo_name, repo_url) = internal_repo.get_name_and_url()?;
         let head_refs = internal_repo.get_head_refs()?;
         let pending_changes = internal_repo.get_pending_changes()?;
@@ -170,7 +170,7 @@ impl Info {
         let creation_date = internal_repo.get_creation_date(config.iso_time);
         let number_of_commits = internal_repo.get_number_of_commits();
         let (authors, contributors) =
-            internal_repo.get_authors(config.number_of_authors, config.show_email)?;
+            internal_repo.take_authors(config.number_of_authors, config.show_email);
         let last_change = internal_repo.get_date_of_last_commit(config.iso_time);
         let (repo_size, file_count) = internal_repo.get_repo_size();
         let workdir = internal_repo.get_work_dir()?;

src/info/repo.rs

@@ -15,8 +15,8 @@ use time_humanize::HumanTime;
 
 pub struct Repo<'a> {
     git2_repo: &'a Repository,
-    repo: git::Repository,
-    commits: Vec<git::DetachedObject>,
+    authors: Vec<Author>,
+    total_num_authors: usize,
     num_commits: usize,
     time_of_most_recent_commit: git::actor::Time,
     time_of_first_commit: git::actor::Time,
@@ -41,12 +41,17 @@ impl<'a> Repo<'a> {
         bot_regex_pattern: &Option<Regex>,
     ) -> Result<Self> {
         let mut repo = git::open(git2_repo.path())?;
-        let (logs, num_commits, time_of_first_commit, time_of_most_recent_commit) =
-            Self::extract_commit_infos(&mut repo, no_merges, bot_regex_pattern)?;
+        let (
+            authors,
+            total_num_authors,
+            num_commits,
+            time_of_first_commit,
+            time_of_most_recent_commit,
+        ) = Self::extract_commit_infos(&mut repo, no_merges, bot_regex_pattern)?;
         Ok(Self {
             git2_repo,
-            repo,
-            commits: logs,
+            authors,
+            total_num_authors,
             num_commits,
             time_of_first_commit,
             time_of_most_recent_commit,
@@ -60,76 +65,53 @@ impl<'a> Repo<'a> {
         no_merges: bool,
         bot_regex_pattern: &Option<Regex>,
     ) -> Result<(
-        Vec<git::DetachedObject>,
+        Vec<Author>,
+        usize,
         usize,
         git::actor::Time,
         git::actor::Time,
     )> {
         // assure that objects we just traversed are coming from cache
         // when we read the commit right after.
         repo.object_cache_size(128 * 1024);
-        let mut commits = Vec::new();
 
         let mut most_recent_commit_time = None;
         let mut first_commit_time = None;
         let mut ancestors = repo.head()?.peel_to_commit_in_place()?.ancestors();
         let mut commit_iter = ancestors.all().peekable();
 
+        let mailmap = repo.load_mailmap();
+        let mut author_to_number_of_commits: HashMap<Sig, usize> = HashMap::new();
+        let mut total_nbr_of_commits = 0;
+
+        let mut num_commits = 0;
         while let Some(commit_id) = commit_iter.next() {
             let commit: git::Commit = commit_id?
                 .object()
                 .expect("commit is still present/comes from cache")
                 .into_commit();
-            if no_merges && commit.parent_ids().take(2).count() > 1 {
-                continue;
-            }
-            if is_bot(commit.iter().author(), bot_regex_pattern) {
-                continue;
-            }
-
-            most_recent_commit_time.get_or_insert_with(|| commit.time());
-            if commit_iter.peek().is_none() {
-                first_commit_time = commit.time()?.into();
-            }
-            commits.push(commit.detach().into());
-        }
-
-        let num_commits = commits.len();
-        Ok((
-            commits,
-            num_commits,
-            first_commit_time.expect("at least one commit"),
-            most_recent_commit_time.expect("at least one commit")?,
-        ))
-    }
+            num_commits += 1;
+            {
+                let commit = commit.decode()?;
+                if no_merges && commit.parents().take(2).count() > 1 {
+                    continue;
+                }
 
-    pub fn get_creation_date(&self, iso_time: bool) -> String {
-        gitoxide_time_to_formatted_time(self.time_of_first_commit, iso_time)
-    }
+                if is_bot(commit.author, bot_regex_pattern) {
+                    continue;
+                }
 
-    pub fn get_number_of_commits(&self) -> String {
-        self.num_commits.to_string()
-    }
+                let author_nbr_of_commits = author_to_number_of_commits
+                    .entry(Sig::from(mailmap.resolve(commit.author)))
+                    .or_insert(0);
+                *author_nbr_of_commits += 1;
+                total_nbr_of_commits += 1;
 
-    pub fn get_authors(
-        &self,
-        number_of_authors_to_display: usize,
-        show_email: bool,
-    ) -> Result<(Vec<Author>, usize)> {
-        let mut author_to_number_of_commits: HashMap<Sig, usize> = HashMap::new();
-        let mut total_nbr_of_commits = 0;
-        let mailmap = self.repo.load_mailmap();
-        for commit in &self.commits {
-            let mut commit = git::objs::CommitRefIter::from_bytes(&commit.data);
-            let author = match commit.author() {
-                Some(author) => mailmap.resolve(&author),
-                None => continue,
-            };
-            let author_nbr_of_commits = author_to_number_of_commits
-                .entry(Sig::from(author))
-                .or_insert(0);
-            *author_nbr_of_commits += 1;
-            total_nbr_of_commits += 1;
+                most_recent_commit_time.get_or_insert_with(|| commit.committer.time);
+                if commit_iter.peek().is_none() {
+                    first_commit_time = commit.committer.time.into();
+                }
+            }
         }
 
         let mut authors_by_number_of_commits: Vec<(Sig, usize)> =
@@ -139,24 +121,51 @@ impl<'a> Repo<'a> {
 
         authors_by_number_of_commits.sort_by(|(_, a_count), (_, b_count)| b_count.cmp(a_count));
 
-        if number_of_authors > number_of_authors_to_display {
-            authors_by_number_of_commits.truncate(number_of_authors_to_display);
-        }
-
         let authors: Vec<Author> = authors_by_number_of_commits
             .into_iter()
             .map(|(author, author_nbr_of_commits)| {
                 let email = author.email;
                 Author::new(
                     author.name,
-                    show_email.then(|| email),
+                    email.into(),
                     author_nbr_of_commits,
                     total_nbr_of_commits,
                 )
             })
             .collect();
 
-        Ok((authors, number_of_authors))
+        Ok((
+            authors,
+            number_of_authors,
+            num_commits,
+            first_commit_time.expect("at least one commit"),
+            most_recent_commit_time.expect("at least one commit"),
+        ))
+    }
+
+    pub fn get_creation_date(&self, iso_time: bool) -> String {
+        gitoxide_time_to_formatted_time(self.time_of_first_commit, iso_time)
+    }
+
+    pub fn get_number_of_commits(&self) -> String {
+        self.num_commits.to_string()
+    }
+
+    pub fn take_authors(
+        &mut self,
+        number_of_authors_to_display: usize,
+        show_email: bool,
+    ) -> (Vec<Author>, usize) {
+        if self.total_num_authors > number_of_authors_to_display {
+            self.authors.truncate(number_of_authors_to_display);
+        }
+
+        if !show_email {
+            for author in &mut self.authors {
+                author.clear_email();
+            }
+        }
+        (std::mem::take(&mut self.authors), self.total_num_authors)
     }
 
     pub fn get_date_of_last_commit(&self, iso_time: bool) -> String {
@@ -351,13 +360,10 @@ impl<'a> Repo<'a> {
     }
 }
 
-fn is_bot(author: Option<git::actor::SignatureRef<'_>>, bot_regex_pattern: &Option<Regex>) -> bool {
-    author
-        .and_then(|author| {
-            bot_regex_pattern
-                .as_ref()
-                .map(|regex| regex.is_match(author.name.to_str_lossy().as_ref()))
-        })
+fn is_bot(author: git::actor::SignatureRef<'_>, bot_regex_pattern: &Option<Regex>) -> bool {
+    bot_regex_pattern
+        .as_ref()
+        .map(|regex| regex.is_match(author.name.to_str_lossy().as_ref()))
         .unwrap_or(false)
 }