Merge pull request #315 from o2sh/replace-git-sys-calls

Replace git sys calls with git2-rs (libgit2)

Author: o2sh

Diff for: src/main.rs

@@ -2,26 +2,23 @@
 #![recursion_limit = "1024"]
 #![cfg_attr(feature = "fail-on-deprecated", deny(deprecated))]
 
-use onefetch::{cli::Cli, cli_utils, error::*, git_utils, info};
+use onefetch::{cli::Cli, cli_utils, error::*, info, printer, repo};
 
-use {
-    process::{Command, Stdio},
-    std::{io, process},
-};
+use std::{io, process};
 
 mod onefetch;
 
 fn run() -> Result<()> {
     #[cfg(windows)]
     let _ = ansi_term::enable_ansi_support();
 
-    if !is_git_installed() {
+    if !cli_utils::is_git_installed() {
         return Err("git failed to execute!".into());
     }
 
     let config = Cli::new()?;
 
-    if !git_utils::is_valid_repo(&config.repo_path)? {
+    if !repo::is_valid(&config.repo_path)? {
         return Err("please run onefetch inside of a non-bare git repository".into());
     }
 
@@ -35,7 +32,7 @@ fn run() -> Result<()> {
 
     let info = info::Info::new(config)?;
 
-    let mut printer = cli_utils::Printer::new(io::BufWriter::new(io::stdout()), info);
+    let mut printer = printer::Printer::new(io::BufWriter::new(io::stdout()), info);
 
     printer.print()?;
 
@@ -55,7 +52,3 @@ fn main() {
         }
     }
 }
-
-fn is_git_installed() -> bool {
-    Command::new("git").arg("--version").stdout(Stdio::null()).status().is_ok()
-}

Diff for: src/onefetch/cli_utils.rs

@@ -1,90 +1,8 @@
-use crate::onefetch::{
-    ascii_art::AsciiArt, deps::package_manager::PackageManager, error::*, info::Info,
-    language::Language,
-};
-use colored::Color;
+use crate::onefetch::{deps::package_manager::PackageManager, error::*, language::Language};
 use std::env;
-use std::io::Write;
+use std::process::{Command, Stdio};
 use strum::IntoEnumIterator;
 
-pub struct Printer<W> {
-    writer: W,
-    info: Info,
-}
-
-impl<W: Write> Printer<W> {
-    pub fn new(writer: W, info: Info) -> Self {
-        Self { writer, info }
-    }
-
-    pub fn print(&mut self) -> Result<()> {
-        let center_pad = "   ";
-        let info_str = format!("{}", &self.info);
-        let mut info_lines = info_str.lines();
-        let colors: Vec<Color> = Vec::new();
-        let mut buf = String::new();
-
-        if self.info.config.art_off {
-            buf.push_str(&info_str);
-        } else if let Some(custom_image) = &self.info.config.image {
-            buf.push_str(
-                &self
-                    .info
-                    .config
-                    .image_backend
-                    .as_ref()
-                    .unwrap()
-                    .add_image(
-                        info_lines.map(|s| format!("{}{}", center_pad, s)).collect(),
-                        custom_image,
-                        self.info.config.image_color_resolution,
-                    )
-                    .chain_err(|| "Error while drawing image")?,
-            );
-        } else {
-            let mut logo_lines = if let Some(custom_ascii) = &self.info.config.ascii_input {
-                AsciiArt::new(custom_ascii, &colors, !self.info.config.no_bold)
-            } else {
-                AsciiArt::new(self.get_ascii(), &self.info.ascii_colors, !self.info.config.no_bold)
-            };
-
-            loop {
-                match (logo_lines.next(), info_lines.next()) {
-                    (Some(logo_line), Some(info_line)) => {
-                        buf.push_str(&format!("{}{}{:^}\n", logo_line, center_pad, info_line))
-                    }
-                    (Some(logo_line), None) => buf.push_str(&format!("{}\n", logo_line)),
-                    (None, Some(info_line)) => buf.push_str(&format!(
-                        "{:<width$}{}{:^}\n",
-                        "",
-                        center_pad,
-                        info_line,
-                        width = logo_lines.width()
-                    )),
-                    (None, None) => {
-                        buf.push('\n');
-                        break;
-                    }
-                }
-            }
-        }
-
-        write!(self.writer, "{}", buf)?;
-
-        Ok(())
-    }
-
-    fn get_ascii(&self) -> &str {
-        let language = if let Some(ascii_language) = &self.info.config.ascii_language {
-            ascii_language
-        } else {
-            &self.info.dominant_language
-        };
-
-        language.get_ascii_art()
-    }
-}
-
 pub fn print_supported_languages() -> Result<()> {
     for l in Language::iter() {
         println!("{}", l);
@@ -106,3 +24,12 @@ pub fn is_truecolor_terminal() -> bool {
         .map(|colorterm| colorterm == "truecolor" || colorterm == "24bit")
         .unwrap_or(false)
 }
+
+pub fn get_git_version() -> Result<String> {
+    let version = Command::new("git").arg("--version").output()?;
+    Ok(String::from_utf8_lossy(&version.stdout).replace('\n', ""))
+}
+
+pub fn is_git_installed() -> bool {
+    Command::new("git").arg("--version").stdout(Stdio::null()).status().is_ok()
+}

Diff for: src/onefetch/git_utils.rs

@@ -1,80 +1,120 @@
-use crate::onefetch::{commit_info::CommitInfo, error::*};
-use git2::{Repository, RepositoryOpenFlags};
-use regex::Regex;
-use std::path::Path;
-
-pub fn get_repo_work_dir(repo: &Repository) -> Result<String> {
-    if let Some(workdir) = work_dir(&repo)?.to_str() {
-        Ok(workdir.to_string())
-    } else {
-        Err("invalid workdir".into())
+use crate::onefetch::error::*;
+use std::process::Command;
+
+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");
     }
-}
 
-fn work_dir(repo: &Repository) -> Result<&Path> {
-    repo.workdir().ok_or_else(|| "unable to query workdir".into())
+    args.push("--pretty=%cr\t%ae\t%an");
+
+    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<_>>())
 }
 
-pub fn get_repo_name_and_url(repo: &Repository) -> Result<(String, String)> {
-    let config = repo.config()?;
-    let mut remote_origin_url: Option<String> = None;
-    let mut remote_url_fallback = String::new();
-    let mut repository_name = String::new();
-    let remote_regex = Regex::new(r"remote\.[a-zA-Z0-9]+\.url").unwrap();
-
-    for entry in &config.entries(None).unwrap() {
-        let entry = entry?;
-        let entry_name = entry.name().unwrap();
-        if entry_name == "remote.origin.url" {
-            remote_origin_url = Some(entry.value().unwrap().to_string());
-        } else if remote_regex.is_match(entry_name) {
-            remote_url_fallback = entry.value().unwrap().to_string()
-        }
+pub fn get_authors(git_history: &[String], 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 line in git_history {
+        let author_email = line.split('\t').collect::<Vec<_>>()[1].to_string();
+        let author_name = line.split('\t').collect::<Vec<_>>()[2].to_string();
+        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 remote_url = if let Some(url) = remote_origin_url { url } else { remote_url_fallback };
+    let mut authors: Vec<(String, usize)> = authors.into_iter().collect();
+    authors.sort_by(|(_, a_count), (_, b_count)| b_count.cmp(a_count));
 
-    let name_parts: Vec<&str> = remote_url.split('/').collect();
+    authors.truncate(n);
 
-    if !name_parts.is_empty() {
-        let mut i = 1;
-        while repository_name.is_empty() && i <= name_parts.len() {
-            repository_name = name_parts[name_parts.len() - i].to_string();
-            i += 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();
 
-    if repository_name.contains(".git") {
-        let repo_name = repository_name.clone();
-        let parts: Vec<&str> = repo_name.split(".git").collect();
-        repository_name = parts[0].to_string();
-    }
+    authors
+}
+
+pub fn get_date_of_last_commit(git_history: &[String]) -> Result<String> {
+    let last_commit = git_history.first();
+
+    let output = match last_commit {
+        Some(date) => date.split('\t').collect::<Vec<_>>()[0].to_string(),
+        None => "??".into(),
+    };
 
-    Ok((repository_name, remote_url))
+    Ok(output)
 }
 
-pub fn get_current_commit_info(repo: &Repository) -> Result<CommitInfo> {
-    let head = repo.head()?;
-    let head_oid = head.target().ok_or("")?;
-    let refs = repo.references()?;
-    let refs_info = refs
-        .filter_map(|reference| match reference {
-            Ok(reference) => match (reference.target(), reference.shorthand()) {
-                (Some(oid), Some(shorthand)) if oid == head_oid => Some(if reference.is_tag() {
-                    String::from("tags/") + shorthand
-                } else {
-                    String::from(shorthand)
-                }),
-                _ => None,
-            },
-            Err(_) => None,
-        })
-        .collect::<Vec<String>>();
-    Ok(CommitInfo::new(head_oid, refs_info))
+pub fn get_creation_date(git_history: &[String]) -> Result<String> {
+    let first_commit = git_history.last();
+
+    let output = match first_commit {
+        Some(creation_time) => creation_time.split('\t').collect::<Vec<_>>()[0].to_string(),
+        None => "??".into(),
+    };
+
+    Ok(output)
 }
 
-pub fn is_valid_repo(repo_path: &str) -> Result<bool> {
-    let repo = Repository::open_ext(repo_path, RepositoryOpenFlags::empty(), Vec::<&Path>::new());
+pub fn get_number_of_commits(git_history: &[String]) -> String {
+    let number_of_commits = git_history.len();
+    number_of_commits.to_string()
+}
+
+pub fn get_packed_size(dir: &str) -> Result<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:"));
 
-    Ok(repo.is_ok() && !repo?.is_bare())
+    let repo_size = match size_line {
+        None => "??",
+        Some(size_str) => &(size_str[11..]),
+    };
+
+    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: u128 = 0;
+        for _file in files_list {
+            files_count += 1;
+        }
+        files_count -= 1; // As splitting giving one line extra(blank).
+        let res = repo_size.to_owned() + (" (") + &(files_count.to_string()) + (" files)");
+        Ok(res)
+    } else {
+        let res = repo_size;
+        Ok(res.into())
+    }
 }