Put all git call functions into a GitClient impl, minor refactoring

HallerPatrick · HallerPatrick · commit d673169cafdc · 2020-12-10T23:05:42.000+01:00
diff --git a/src/onefetch/git_utils.rs b/src/onefetch/git_utils.rs
@@ -1,195 +1,132 @@
-use crate::onefetch::{error::*, utils::bytes_to_human_readable};
-use chrono;
-use chrono::TimeZone;
-use chrono_humanize;
-use git2::{Commit, Repository, Time};
-use std::process::Command;
-use std::str;
-
-pub fn get_git_history2(repo: &Repository, no_merges: bool) -> Result<Vec<Commit>> {
-    let mut revwalk = repo.revwalk()?;
-    revwalk.push_head()?;
-    revwalk.set_sorting(git2::Sort::TIME)?;
-    let commits: Vec<Commit> = revwalk
-        .filter_map(|r| match r {
-            Err(_) => return None,
-            Ok(r) => {
-                let commit = repo.find_commit(r).expect("Could not find commit");
-                if no_merges {
-                    let parents = commit.parents().len();
-                    if parents > 1 {
-                        return None;
-                    }
-                }
-                Some(commit)
-            }
-        })
-        .collect();
+use crate::onefetch::{error::*, utils};
+use git2::{Commit, Repository};
 
-    Ok(commits)
+pub struct GitClient<'a> {
+    repo: &'a Repository,
+    commit_history: Vec<Commit<'a>>,
 }
 
-pub fn get_git_history(dir: &str, no_merges: bool) -> Result<Vec<String>> {
-    let mut args = vec!["-C", dir, "log"];
-    if no_merges {
-        args.push("--no-merges");
+impl<'a> GitClient<'a> {
+    pub fn new(repo: &Repository, no_merges: bool) -> Result<GitClient> {
+        let commit_history = GitClient::get_git_history(repo, no_merges)?;
+        Ok(GitClient { repo: repo, commit_history: commit_history })
     }
 
-    args.push("--pretty=%cr\t%ae\t%an");
+    pub fn get_creation_date(&self) -> Result<String> {
+        let first_commit = self.commit_history.last();
 
-    let output = Command::new("git").args(args).output()?;
-
-    let output = String::from_utf8_lossy(&output.stdout);
-    Ok(output.lines().map(|x| x.to_string()).collect::<Vec<_>>())
-}
+        let output = match first_commit {
+            Some(commit) => {
+                let time = commit.time();
+                utils::git_time_to_human_time(&time)
+            }
+            None => "".into(),
+        };
 
-pub fn get_authors2(git_history: &Vec<Commit>, n: usize) -> Vec<(String, usize, usize)> {
-    let mut authors = std::collections::HashMap::new();
-    let mut author_name_by_email = std::collections::HashMap::new();
-    let mut total_commits = 0;
-    for commit in git_history {
-        let author = commit.author();
-        let author_name = author.name().unwrap().to_string();
-        let author_email = author.email().unwrap();
-
-        let commit_count = authors.entry(author_email.to_string()).or_insert(0);
-        author_name_by_email.entry(author_email.to_string()).or_insert(author_name);
-        *commit_count += 1;
-        total_commits += 1;
+        Ok(output)
     }
 
-    let mut authors: Vec<(String, usize)> = authors.into_iter().collect();
-    authors.sort_by(|(_, a_count), (_, b_count)| b_count.cmp(a_count));
+    pub fn get_number_of_commits(&self) -> String {
+        let number_of_commits = self.commit_history.len();
+        number_of_commits.to_string()
+    }
 
-    authors.truncate(n);
+    pub fn get_authors(&self, n: usize) -> Vec<(String, usize, usize)> {
+        let mut authors = std::collections::HashMap::new();
+        let mut author_name_by_email = std::collections::HashMap::new();
+        let mut total_commits = 0;
+        for commit in &self.commit_history {
+            let author = commit.author();
+            let author_name = author.name().unwrap().to_string();
+            let author_email = author.email().unwrap();
+
+            let commit_count = authors.entry(author_email.to_string()).or_insert(0);
+            author_name_by_email.entry(author_email.to_string()).or_insert(author_name);
+            *commit_count += 1;
+            total_commits += 1;
+        }
 
-    let authors: Vec<(String, usize, usize)> = authors
-        .into_iter()
-        .map(|(author, count)| {
-            (
-                author_name_by_email.get(&author).unwrap().trim_matches('\'').to_string(),
-                count,
-                count * 100 / total_commits,
-            )
-        })
-        .collect();
+        let mut authors: Vec<(String, usize)> = authors.into_iter().collect();
+        authors.sort_by(|(_, a_count), (_, b_count)| b_count.cmp(a_count));
 
-    authors
-}
+        authors.truncate(n);
 
-pub fn get_date_of_last_commit2(git_history: &Vec<Commit>) -> Result<String> {
-    let last_commit = git_history.first();
+        let authors: Vec<(String, usize, usize)> = authors
+            .into_iter()
+            .map(|(author, count)| {
+                (
+                    author_name_by_email.get(&author).unwrap().trim_matches('\'').to_string(),
+                    count,
+                    count * 100 / total_commits,
+                )
+            })
+            .collect();
 
-    let output = match last_commit {
-        Some(commit) => git_time_to_human_time(&commit.time()),
-        None => "".into(),
-    };
-    Ok(output)
-}
+        authors
+    }
 
-fn git_time_to_human_time(time: &Time) -> String {
-    let (offset, _) = match time.offset_minutes() {
-        n if n < 0 => (-n, '-'),
-        n => (n, '+'),
-    };
+    pub fn get_date_of_last_commit(&self) -> String {
+        let last_commit = self.commit_history.first();
 
-    let offset = chrono::FixedOffset::west(offset);
-    let dt_with_tz = offset.timestamp(time.seconds(), 0);
-    let ht = chrono_humanize::HumanTime::from(dt_with_tz);
-    format!("{}", ht.to_text_en(chrono_humanize::Accuracy::Rough, chrono_humanize::Tense::Past))
-}
+        let output = match last_commit {
+            Some(commit) => utils::git_time_to_human_time(&commit.time()),
+            None => "".into(),
+        };
+        output
+    }
 
-pub fn get_creation_date2(git_history: &Vec<Commit>) -> Result<String> {
-    let first_commit = git_history.last();
+    // This collects the repo size excluding .git
+    pub fn get_repo_size(&self) -> (String, u64) {
+        let (repo_size, file_count) = match self.repo.index() {
+            Ok(index) => {
+                let mut repo_size: u128 = 0;
+                let mut file_count: u64 = 0;
+                for index_entry in index.iter() {
+                    file_count += 1;
+                    repo_size += index_entry.file_size as u128;
+                }
+                (repo_size, file_count)
+            }
+            Err(_) => (0, 0),
+        };
 
-    let output = match first_commit {
-        Some(commit) => {
-            let time = commit.time();
-            git_time_to_human_time(&time)
-        }
-        None => "".into(),
-    };
+        (utils::bytes_to_human_readable(repo_size), file_count)
+    }
 
-    Ok(output)
-}
+    fn get_git_history(repo: &'a Repository, no_merges: bool) -> Result<Vec<Commit<'a>>> {
+        let mut revwalk = repo.revwalk()?;
+        revwalk.push_head()?;
+        revwalk.set_sorting(git2::Sort::TIME)?;
+        let commits: Vec<Commit<'a>> = revwalk
+            .filter_map(|r| match r {
+                Err(_) => return None,
+                Ok(r) => {
+                    let commit = repo.find_commit(r).expect("Could not find commit");
+                    if no_merges {
+                        let parents = commit.parents().len();
+                        if parents > 1 {
+                            return None;
+                        }
+                    }
+                    Some(commit.to_owned())
+                }
+            })
+            .collect();
 
-pub fn get_number_of_commits2(git_history: &Vec<Commit>) -> String {
-    let number_of_commits = git_history.len();
-    number_of_commits.to_string()
+        Ok(commits)
+    }
 }
 
-pub fn get_packed_size(repo_size: String, files_count: Option<u64>) -> Result<String> {
+// Should be moved to fmt::Display of Info
+pub fn get_packed_size(repo_size: String, files_count: u64) -> Result<String> {
     match files_count {
-        Some(files_count) => {
-            let res = format!("{} ({} files)", repo_size, files_count.to_string());
-            Ok(res)
-        }
-        None => {
+        0 => {
             let res = repo_size;
             Ok(res.into())
         }
-    }
-}
-
-// This collects the repo size excluding .git
-pub fn get_repo_size2(repo: &Repository) -> String {
-    let repo_size = match repo.index() {
-        Ok(index) => {
-            let mut repo_size: u128 = 0;
-            for index_entry in index.iter() {
-                println!("{}", str::from_utf8(&index_entry.path).unwrap());
-                repo_size += index_entry.file_size as u128;
-            }
-            repo_size
-        }
-        Err(_) => 0,
-    };
-
-    bytes_to_human_readable(repo_size)
-}
-
-pub fn get_repo_size(dir: &str) -> String {
-    let output = Command::new("git")
-        .arg("-C")
-        .arg(dir)
-        .arg("count-objects")
-        .arg("-vH")
-        .output()
-        .expect("Failed to execute git.");
-
-    let output = String::from_utf8_lossy(&output.stdout);
-    let lines = output.to_string();
-    let size_line = lines.split('\n').find(|line| line.starts_with("size-pack:"));
-
-    let repo_size = match size_line {
-        None => String::new(),
-        Some(size_str) => String::from(&(size_str[11..])),
-    };
-    repo_size
-}
-
-pub fn get_files_count(dir: &str) -> Option<u64> {
-    let output = Command::new("git")
-        .arg("-C")
-        .arg(dir)
-        .arg("ls-files")
-        .output()
-        .expect("Failed to execute git.");
-    // To check if command executed successfully or not
-    let error = &output.stderr;
-
-    if error.is_empty() {
-        let output = String::from_utf8_lossy(&output.stdout);
-
-        let lines = output.to_string();
-        let files_list = lines.split('\n');
-        let mut files_count: u64 = 0;
-        for _file in files_list {
-            files_count += 1;
+        _ => {
+            let res = format!("{} ({} files)", repo_size, files_count.to_string());
+            Ok(res)
         }
-        files_count -= 1; // As splitting giving one line extra(blank).
-        Some(files_count)
-    } else {
-        None
     }
 }
diff --git a/src/onefetch/info.rs b/src/onefetch/info.rs
@@ -27,7 +27,7 @@ pub struct Info {
     number_of_commits: String,
     lines_of_code: usize,
     packed_repo_size: String,
-    files_count: Option<u64>,
+    files_count: u64,
     repo_size: String,
     license: String,
     pub dominant_language: Language,
@@ -223,21 +223,13 @@ impl Info {
         let number_of_branches = repo.get_number_of_branches()?;
 
         let repo = Repository::open(&workdir)?;
-        let git_history2 = git_utils::get_git_history2(&repo, config.no_merges)?;
-        let creation_date = git_utils::get_creation_date2(&git_history2)?;
-        let number_of_commits = git_utils::get_number_of_commits2(&git_history2);
-        let authors = git_utils::get_authors2(&git_history2, config.number_of_authors);
-        let last_change = git_utils::get_date_of_last_commit2(&git_history2)?;
-        // let repo_size = git_utils::get_repo_size2(&repo);
-
-        // Git Calls
-        // let git_history = git_utils::get_git_history(&workdir, config.no_merges)?;
-        // let creation_date = git_utils::get_creation_date(&git_history)?;
-        // let number_of_commits = git_utils::get_number_of_commits(&git_history);
-        // let authors = git_utils::get_authors(&git_history, config.number_of_authors);
-        // let last_change = git_utils::get_date_of_last_commit(&git_history)?;
-        let repo_size = git_utils::get_repo_size(&workdir);
-        let files_count = git_utils::get_files_count(&workdir);
+
+        let git_client = git_utils::GitClient::new(&repo, config.no_merges)?;
+        let creation_date = git_client.get_creation_date()?;
+        let number_of_commits = git_client.get_number_of_commits();
+        let authors = git_client.get_authors(config.number_of_authors);
+        let last_change = git_client.get_date_of_last_commit();
+        let (repo_size, files_count) = git_client.get_repo_size();
         let packed_repo_size = git_utils::get_packed_size(repo_size.clone(), files_count)?;
 
         let git_version = cli_utils::get_git_version()?;
@@ -425,12 +417,7 @@ impl Serialize for Info {
         state.serialize_field("linesOfCode", &self.lines_of_code)?;
         state.serialize_field("packedRepoSize", &self.packed_repo_size)?;
         state.serialize_field("repoSize", &self.repo_size)?;
-
-        match &self.files_count {
-            Some(files_count) => state.serialize_field("filesCount", files_count)?,
-            None => {}
-        }
-
+        state.serialize_field("filesCount", &self.files_count)?;
         state.serialize_field("license", &self.license)?;
         state.serialize_field("dominantLanguage", &self.dominant_language)?;
         state.serialize_field("textColors", &self.text_colors)?;
diff --git a/src/onefetch/utils.rs b/src/onefetch/utils.rs
@@ -1,5 +1,8 @@
 use byte_unit::Byte;
+use chrono::{FixedOffset, TimeZone};
+use chrono_humanize::{Accuracy, HumanTime, Tense};
 use colored::Color;
+use git2::Time;
 
 pub fn num_to_color(num: &str) -> Option<Color> {
     let color = match num {
@@ -28,3 +31,15 @@ pub fn bytes_to_human_readable(bytes: u128) -> String {
     let byte = Byte::from_bytes(bytes);
     byte.get_appropriate_unit(true).to_string()
 }
+
+pub fn git_time_to_human_time(time: &Time) -> String {
+    let (offset, _) = match time.offset_minutes() {
+        n if n < 0 => (-n, '-'),
+        n => (n, '+'),
+    };
+
+    let offset = FixedOffset::west(offset);
+    let dt_with_tz = offset.timestamp(time.seconds(), 0);
+    let ht = HumanTime::from(dt_with_tz);
+    format!("{}", ht.to_text_en(Accuracy::Rough, Tense::Past))
+}
