.gitignore

@@ -1,3 +1,2 @@
 /target
-profile.json
+profile.json
-perf.data*

Cargo.toml

@@ -2,7 +2,7 @@ cargo-features = ["codegen-backend"]
 
 [package]
 name = "git-heatmap"
-version = "1.3.0"
+version = "1.2.0"
 edition = "2021"
 authors = ["Wynd <wyndftw@proton.me>"]
 description = "A simple and customizable heatmap for git repos"
@@ -12,41 +12,15 @@ license = "GPL-3.0-or-later"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[lib]
-name = "libgitheatmap"
-path = "src/lib.rs"
-bench = false
-
 [lints.rust]
 unsafe_code = { level = "forbid" }
 
 [dependencies]
-gix = { version = "0.70.0", default-features = false, features = [
+gix = { version = "0.66.0", default-features = false, features = ["mailmap"] }
-	"mailmap",
+clap = { version = "4.5.20", features = ["derive"] }
-	"parallel",
+chrono = { version = "0.4.38" }
-] }
+itertools = { version = "0.13.0" }
-clap = { version = "4.5.26", features = ["derive"] }
+anyhow = { version = "1.0.89" }
-chrono = { version = "0.4.39" }
-itertools = { version = "0.14.0" }
-anyhow = { version = "1.0.95" }
-rayon = { version = "1.10.0" }
-
-[dev-dependencies]
-divan = { version = "0.1.17" }
-mockd = { version = "0.4.35", features = [
-	"datetime",
-	"words",
-	"name",
-	"contact",
-] }
-
-[[bench]]
-name = "commits"
-harness = false
-
-[[bench]]
-name = "heatmap"
-harness = false
 
 [profile.dev]
 codegen-backend = "cranelift"

benches/commits.rs

@@ -1,63 +0,0 @@
-use anyhow::Context;
-use chrono::NaiveDate;
-use libgitheatmap::{self, cli::CliArgs};
-
-fn main() {
-	divan::main();
-}
-
-#[divan::bench]
-fn current_repo_commits() {
-	let home_dir = std::env::current_dir().unwrap();
-
-	let args = CliArgs {
-		root_dir: Some(vec![home_dir]),
-		authors: None,
-		char: '▩',
-		repos: None,
-		ignored_repos: None,
-		branches: None,
-		since: "2024-01-01".to_string(),
-		until: None,
-		split_months: false,
-		months_per_row: 13,
-		no_merges: false,
-		..Default::default()
-	};
-
-	let since = NaiveDate::parse_from_str(&args.since, "%Y-%m-%d").unwrap();
-
-	let until = NaiveDate::parse_from_str("2025-01-01", "%Y-%m-%d").unwrap();
-
-	libgitheatmap::get_commits(args, since, until)
-		.with_context(|| "Could not fetch commit list")
-		.unwrap();
-}
-
-#[divan::bench(sample_count = 20)]
-fn all_repos_commits() {
-	let home_dir = std::path::PathBuf::from("/home");
-
-	let args = CliArgs {
-		root_dir: Some(vec![home_dir]),
-		authors: None,
-		char: '▩',
-		repos: None,
-		ignored_repos: None,
-		branches: None,
-		since: "2024-01-01".to_string(),
-		until: None,
-		split_months: false,
-		months_per_row: 13,
-		no_merges: false,
-		..Default::default()
-	};
-
-	let since = NaiveDate::parse_from_str(&args.since, "%Y-%m-%d").unwrap();
-
-	let until = NaiveDate::parse_from_str("2025-01-01", "%Y-%m-%d").unwrap();
-
-	libgitheatmap::get_commits(args, since, until)
-		.with_context(|| "Could not fetch commit list")
-		.unwrap();
-}

benches/heatmap.rs

@@ -1,55 +0,0 @@
-use std::sync::OnceLock;
-
-use chrono::{Local, NaiveDate};
-use gix::ObjectId;
-use libgitheatmap::{
-	heatmap::{self, Heatmap},
-	Commit,
-};
-
-static COMMITS: OnceLock<Vec<Commit>> = OnceLock::new();
-
-fn main() {
-	let mut commits: Vec<Commit> = vec![];
-	for _n in 0..1000 {
-		let id = ObjectId::Sha1([0u8; 20]);
-		let title = mockd::words::sentence(10);
-		let author = mockd::name::full();
-		let email = mockd::contact::email();
-		let time = mockd::datetime::date_range(
-			"2024-01-01T00:00:00Z".to_string(),
-			"2025-01-01T00:00:00Z".to_string(),
-		)
-		.with_timezone(&Local);
-		commits.push(Commit::new(id, title, author, email, time));
-	}
-
-	COMMITS.set(commits).expect("unable to generate commits");
-
-	divan::main();
-}
-
-#[divan::bench]
-fn heatmap_generation() {
-	let since = NaiveDate::parse_from_str("2024-01-01", "%Y-%m-%d").unwrap();
-
-	let until = NaiveDate::parse_from_str("2025-01-01", "%Y-%m-%d").unwrap();
-
-	let commits_vec = COMMITS
-		.get()
-		.expect("unable to access commits list")
-		.to_vec();
-	let commits = commits_vec.len();
-	let repos = 1;
-
-	let _heatmap = Heatmap::new(
-		since,
-		until,
-		commits,
-		repos,
-		commits_vec,
-		false,
-		13,
-		heatmap::Format::Chars,
-	);
-}

src/cli.rs

@@ -5,7 +5,7 @@ use clap::{arg, Parser, ValueHint};
 
 use crate::heatmap::{ColorLogic, Format, HeatmapColors};
 
-#[derive(Clone, Default, Debug, Parser, PartialEq, Eq)]
+#[derive(Clone, Debug, Parser, PartialEq, Eq)]
 #[command(version, about, author, long_about = None, args_override_self = true)]
 pub struct CliArgs {
 	#[arg(long("root-dir"), value_hint = ValueHint::DirPath)]

src/heatmap.rs

@@ -234,23 +234,20 @@ impl Chunk {
 	}
 }
 
-#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, ValueEnum)]
+#[derive(Clone, Debug, PartialEq, Eq, ValueEnum)]
 pub enum HeatmapColors {
-	#[default]
 	Green,
 	Red,
 }
 
-#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, ValueEnum)]
+#[derive(Clone, Debug, PartialEq, Eq, ValueEnum)]
 pub enum ColorLogic {
-	#[default]
 	ByAmount,
 	ByWeight,
 }
 
-#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, ValueEnum)]
+#[derive(Clone, Debug, PartialEq, Eq, ValueEnum)]
 pub enum Format {
-	#[default]
 	Chars,
 	Numbers,
 }

src/lib.rs

@@ -1,379 +0,0 @@
-#![feature(let_chains)]
-
-use std::{
-	cmp::Reverse,
-	path::{self, PathBuf},
-	sync::OnceLock,
-};
-
-use anyhow::anyhow;
-use chrono::{DateTime, Duration, Local, NaiveDate, NaiveTime, TimeZone};
-use clap::Parser;
-use cli::CliArgs;
-use gix::{
-	bstr::ByteSlice, revision::walk::Sorting, traverse::commit::simple::CommitTimeOrder, ObjectId,
-	ThreadSafeRepository,
-};
-use heatmap::{ColorLogic, HeatmapColors};
-use itertools::Itertools;
-use mailmap::Mailmap;
-use rayon::prelude::*;
-use rgb::Rgb;
-
-pub mod cli;
-pub mod heatmap;
-pub mod mailmap;
-pub mod rgb;
-
-pub const ESCAPE: &str = "\x1B";
-pub const RESET: &str = "\x1B[0m";
-pub const DAYS: [&str; 7] = ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"];
-pub static CHAR: OnceLock<char> = OnceLock::new();
-pub static COLOR_LOGIC: OnceLock<ColorLogic> = OnceLock::new();
-pub static COLOR_MAP: OnceLock<Vec<String>> = OnceLock::new();
-
-pub const GREEN_COLOR_MAP: [Rgb; 5] = [
-	Rgb(0, 0, 0),
-	Rgb(14, 68, 41),
-	Rgb(0, 109, 50),
-	Rgb(38, 166, 65),
-	Rgb(25, 255, 64),
-];
-
-pub const RED_COLOR_MAP: [Rgb; 5] = [
-	Rgb(0, 0, 0),
-	Rgb(208, 169, 35),
-	Rgb(208, 128, 35),
-	Rgb(208, 78, 35),
-	Rgb(255, 0, 0),
-];
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct Commit {
-	id: ObjectId,
-	title: String,
-	author: Author,
-	time: DateTime<Local>,
-}
-
-impl Commit {
-	pub fn new(
-		id: ObjectId,
-		title: String,
-		author: String,
-		email: String,
-		time: DateTime<Local>,
-	) -> Self {
-		Self {
-			id,
-			title,
-			author: Author {
-				name: author,
-				email,
-			},
-			time,
-		}
-	}
-}
-
-#[derive(Debug, PartialEq, Eq, Hash, Clone)]
-pub struct Author {
-	name: String,
-	email: String,
-}
-
-pub fn args() -> CliArgs {
-	let args = CliArgs::parse();
-
-	CHAR.set(args.char).unwrap();
-	COLOR_LOGIC.set(args.counting).unwrap();
-	let color_map = match args.color_scheme {
-		HeatmapColors::Green => GREEN_COLOR_MAP,
-		HeatmapColors::Red => RED_COLOR_MAP,
-	};
-	let color_map = color_map
-		.into_iter()
-		.map(|c| c.to_ansi())
-		.collect::<Vec<_>>();
-	COLOR_MAP.set(color_map).unwrap();
-
-	args
-}
-
-pub fn get_commits(
-	args: CliArgs,
-	start_date: NaiveDate,
-	end_date: NaiveDate,
-) -> anyhow::Result<(usize, usize, Vec<Commit>)> {
-	let mut commits: Vec<Commit> = vec![];
-
-	let ignored_repos = args.ignored_repos.as_ref().unwrap_or(&vec![]).to_owned();
-
-	let (repos, branches) = match &args.root_dir {
-		Some(roots) => {
-			let mut repos: Vec<PathBuf> = vec![];
-			for root in roots {
-				find_git_repos(root, &mut repos, &ignored_repos);
-			}
-			let branches = vec!["".to_string(); repos.len()];
-			(repos, branches)
-		}
-		None => {
-			let repos = match args.repos {
-				Some(r) => r,
-				None => vec![PathBuf::from(".")],
-			};
-
-			let branches = args.branches.unwrap_or_else(|| vec!["".to_string()]);
-
-			if repos.len() > 1 && repos.len() != branches.len() {
-				return Err(anyhow!(
-					"Number of repos ({}) needs to match the number of branch lists ({})!",
-					repos.len(),
-					branches.len()
-				));
-			}
-			(repos, branches)
-		}
-	};
-
-	let midnight = NaiveTime::from_hms_opt(0, 0, 0).unwrap();
-	let start_date = start_date.and_time(midnight);
-	let start_date = Local.from_local_datetime(&start_date).unwrap();
-
-	let current_time = Local::now().time();
-	let end_date = end_date.and_time(current_time);
-	let end_date = Local.from_local_datetime(&end_date).unwrap();
-
-	let authors = args.authors.unwrap_or_default();
-
-	let mut repos_count: usize = 0;
-	let mut branches_count: usize = 0;
-
-	for (i, repo_path) in repos.iter().enumerate() {
-		let repo = ThreadSafeRepository::open(repo_path).unwrap();
-
-		let branch_names = &*branches[i];
-		let branches = get_repo_branches(&repo, branch_names).unwrap();
-
-		let mailmap = Mailmap::new(repo_path);
-
-		let branch_commits: Vec<_> = branches
-			.par_iter()
-			.filter_map(|branch| get_commit_ids(&repo, branch, start_date))
-			.reduce(Vec::new, |mut c, n| {
-				c.extend(n);
-				c
-			});
-
-		let repo = repo.to_thread_local();
-
-		let branch_commits = branch_commits
-			.into_iter()
-			.unique()
-			.filter_map(|c| repo.find_commit(c).ok())
-			.filter_map(|c| {
-				let title = c
-					.message()
-					.ok()?
-					.title
-					.trim_ascii()
-					.to_str()
-					.ok()?
-					.to_string();
-
-				if args.no_merges {
-					let is_merge = c.parent_ids().count() > 1;
-					if is_merge {
-						return None;
-					}
-				}
-
-				let author = c.author().ok()?;
-
-				let email = author.email.to_string();
-				let name = author.name.to_string();
-
-				let author = Author { name, email };
-				let author = mailmap.resolve(author);
-
-				if !authors.is_empty() && !authors.contains(&author.name) {
-					return None;
-				}
-
-				let time = c.time().ok()?;
-				let time =
-					DateTime::from_timestamp_millis(time.seconds * 1000)?.with_timezone(&Local);
-				if time < start_date || time > end_date {
-					return None;
-				}
-
-				Some(Commit {
-					id: c.id,
-					title,
-					author,
-					time,
-				})
-			})
-			.collect_vec();
-
-		if !branch_commits.is_empty() {
-			repos_count += 1;
-			branches_count += branches.len();
-		}
-
-		commits.extend(branch_commits);
-	}
-
-	commits.par_sort_by_cached_key(|a| Reverse(a.time));
-
-	Ok((repos_count, branches_count, commits))
-}
-
-fn get_repo_branches(repo: &ThreadSafeRepository, branch_names: &str) -> Option<Vec<String>> {
-	if branch_names.is_empty() {
-		let repo = repo.to_thread_local();
-		let Ok(refs) = repo.references()
-		else {
-			return None;
-		};
-
-		let Ok(prefix) = refs.prefixed("refs/heads")
-		else {
-			return None;
-		};
-
-		let branches = prefix
-			.filter_map(Result::ok)
-			.filter_map(|b| {
-				b.inner
-					.name
-					.to_string()
-					.strip_prefix("refs/heads/")
-					.map(|s| s.to_string())
-			})
-			.collect();
-
-		Some(branches)
-	}
-	else {
-		Some(branch_names.split(' ').map(|s| s.to_string()).collect())
-	}
-}
-
-fn get_commit_ids(
-	repo: &ThreadSafeRepository,
-	branch: &str,
-	start_date: DateTime<Local>,
-) -> Option<Vec<ObjectId>> {
-	let repo = repo.to_thread_local();
-
-	// When passing the default @ (HEAD) branch this might actually not exist at all
-	// locally so we're skipping it
-	let rev = repo.rev_parse(branch).ok()?;
-
-	let branch_commits = rev
-		.single()
-		.unwrap()
-		.ancestors()
-		.sorting(Sorting::ByCommitTimeCutoff {
-			order: CommitTimeOrder::NewestFirst,
-			seconds: start_date.timestamp(),
-		})
-		.all()
-		.ok()?;
-
-	let commits = branch_commits
-		.filter_map(|c| c.ok())
-		.map(|c| c.id)
-		.collect();
-
-	Some(commits)
-}
-
-fn find_git_repos(scan_path: &path::Path, repos: &mut Vec<PathBuf>, ignored_repos: &Vec<String>) {
-	if let Some(path) = walk_dir(scan_path, ignored_repos) {
-		repos.extend(path)
-	}
-}
-
-pub fn walk_dir(scan_path: &path::Path, ignored_repos: &Vec<String>) -> Option<Vec<PathBuf>> {
-	let Ok(dirs) = scan_path.read_dir()
-	else {
-		return None;
-	};
-
-	let dirs: Vec<PathBuf> = dirs
-		.par_bridge()
-		.filter_map(|d| d.ok())
-		.filter(|d| {
-			let dir_name = d.file_name().to_string_lossy().to_string();
-			!ignored_repos.contains(&dir_name)
-		})
-		.filter(|d| d.file_type().is_ok_and(|t| t.is_dir()))
-		.filter_map(|d| {
-			let dir = d.path();
-			let filename = dir.file_name().unwrap_or_default().to_string_lossy();
-
-			match filename.as_ref() {
-				".git" => Some(vec![dir]),
-				_ => walk_dir(&dir, ignored_repos),
-			}
-		})
-		.reduce(Vec::new, |mut c, n| {
-			c.extend(n);
-			c
-		});
-
-	Some(dirs)
-}
-
-pub fn get_default_until(since: NaiveDate) -> String {
-	let mut until = Local::now().date_naive();
-	if since + Duration::days(365) < until {
-		until = since + Duration::days(365);
-	}
-	until.format("%Y-%m-%d").to_string()
-}
-
-fn get_color(val: i32, high: i32) -> usize {
-	match COLOR_LOGIC.get() {
-		Some(logic) => match logic {
-			ColorLogic::ByAmount => match val {
-				0 => 0,
-				x if x < 2 => 1,
-				x if x < 4 => 2,
-				x if x < 6 => 3,
-				x if x >= 6 => 4,
-				_ => 0,
-			},
-			ColorLogic::ByWeight => {
-				let color = val as f32 / high as f32;
-				match color {
-					0.0 => 0,
-					x if x <= 0.2 => 1,
-					x if x <= 0.4 => 2,
-					x if x <= 0.8 => 3,
-					x if x > 0.8 => 4,
-					_ => 0,
-				}
-			}
-		},
-		None => 0,
-	}
-}
-
-fn get_char() -> char {
-	*CHAR.get_or_init(|| '▩')
-}
-
-fn get_color_map() -> Vec<String> {
-	COLOR_MAP
-		.get_or_init(|| {
-			GREEN_COLOR_MAP
-				.into_iter()
-				.map(|c| c.to_ansi())
-				.collect::<Vec<_>>()
-		})
-		.to_vec()
-}

src/main.rs

@@ -1,24 +1,93 @@
-use anyhow::{Context, Result};
+#![feature(let_chains)]
-use chrono::NaiveDate;
+
-use libgitheatmap::heatmap::Heatmap;
+use std::{
+	cmp::Reverse,
+	collections::HashSet,
+	path::{self, PathBuf},
+	sync::OnceLock,
+};
+
+use anyhow::{anyhow, Context, Result};
+use chrono::{DateTime, Duration, Local, NaiveDate, NaiveTime, TimeZone};
+use clap::Parser;
+use gix::{bstr::ByteSlice, traverse::commit::simple::Sorting, ObjectId};
+use heatmap::{ColorLogic, HeatmapColors};
+use itertools::Itertools;
+use mailmap::Mailmap;
+use rgb::Rgb;
+
+use crate::{cli::CliArgs, heatmap::Heatmap};
+
+mod cli;
+mod heatmap;
+mod mailmap;
+mod rgb;
+
+pub const ESCAPE: &str = "\x1B";
+pub const RESET: &str = "\x1B[0m";
+pub const DAYS: [&str; 7] = ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"];
+pub static CHAR: OnceLock<char> = OnceLock::new();
+static COLOR_LOGIC: OnceLock<ColorLogic> = OnceLock::new();
+pub static COLOR_MAP: OnceLock<Vec<String>> = OnceLock::new();
+
+const GREEN_COLOR_MAP: [Rgb; 5] = [
+	Rgb(0, 0, 0),
+	Rgb(14, 68, 41),
+	Rgb(0, 109, 50),
+	Rgb(38, 166, 65),
+	Rgb(25, 255, 64),
+];
+
+const RED_COLOR_MAP: [Rgb; 5] = [
+	Rgb(0, 0, 0),
+	Rgb(208, 169, 35),
+	Rgb(208, 128, 35),
+	Rgb(208, 78, 35),
+	Rgb(255, 0, 0),
+];
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+struct Commit {
+	id: ObjectId,
+	title: String,
+	author: Author,
+	time: DateTime<Local>,
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+struct Author {
+	name: String,
+	email: String,
+}
 
 fn main() -> Result<()> {
-	let args = libgitheatmap::args();
+	let args = CliArgs::parse();
+
+	CHAR.set(args.char).unwrap();
+	COLOR_LOGIC.set(args.counting.clone()).unwrap();
+	let color_map = match args.color_scheme {
+		HeatmapColors::Green => GREEN_COLOR_MAP,
+		HeatmapColors::Red => RED_COLOR_MAP,
+	};
+	let color_map = color_map
+		.into_iter()
+		.map(|c| c.to_ansi())
+		.collect::<Vec<_>>();
+	COLOR_MAP.set(color_map).unwrap();
 
 	let since = NaiveDate::parse_from_str(&args.since, "%Y-%m-%d").unwrap();
 
 	let until = args
 		.until
 		.clone()
-		.unwrap_or_else(|| libgitheatmap::get_default_until(since));
+		.unwrap_or_else(|| get_default_until(since));
 	let until = NaiveDate::parse_from_str(&until, "%Y-%m-%d").unwrap();
 
 	let split_months = args.split_months;
 	let months_per_row = args.months_per_row;
-	let format = args.format;
+	let format = args.format.clone();
 
-	let commits = libgitheatmap::get_commits(args, since, until)
+	let commits = get_commits(args, since, until).with_context(|| "Could not fetch commit list")?;
-		.with_context(|| "Could not fetch commit list")?;
 
 	let heatmap = Heatmap::new(
 		since,
@@ -35,3 +104,244 @@ fn main() -> Result<()> {
 
 	Ok(())
 }
+
+fn get_default_until(since: NaiveDate) -> String {
+	let mut until = Local::now().date_naive();
+	if since + Duration::days(365) < until {
+		until = since + Duration::days(365);
+	}
+	until.format("%Y-%m-%d").to_string()
+}
+
+fn get_color(val: i32, high: i32) -> usize {
+	match COLOR_LOGIC.get() {
+		Some(logic) => match logic {
+			ColorLogic::ByAmount => match val {
+				0 => 0,
+				x if x < 2 => 1,
+				x if x < 4 => 2,
+				x if x < 6 => 3,
+				x if x >= 6 => 4,
+				_ => 0,
+			},
+			ColorLogic::ByWeight => {
+				let color = val as f32 / high as f32;
+				match color {
+					0.0 => 0,
+					x if x <= 0.2 => 1,
+					x if x <= 0.4 => 2,
+					x if x <= 0.8 => 3,
+					x if x > 0.8 => 4,
+					_ => 0,
+				}
+			}
+		},
+		None => 0,
+	}
+}
+
+fn get_char() -> char {
+	*CHAR.get_or_init(|| '▩')
+}
+
+fn get_color_map() -> Vec<String> {
+	COLOR_MAP
+		.get_or_init(|| {
+			GREEN_COLOR_MAP
+				.into_iter()
+				.map(|c| c.to_ansi())
+				.collect::<Vec<_>>()
+		})
+		.to_vec()
+}
+
+fn find_git_repos(
+	scan_path: &path::Path,
+	repos: &mut Vec<PathBuf>,
+	ignored_repos: &Vec<String>,
+	_args: &CliArgs,
+) {
+	let Ok(dirs) = scan_path.read_dir()
+	else {
+		return;
+	};
+
+	let dirs: Vec<_> = dirs
+		.filter_map(|d| d.ok())
+		.filter(|d| {
+			let dir_name = d.file_name().to_string_lossy().to_string();
+			!ignored_repos.contains(&dir_name)
+		})
+		.filter(|d| d.file_type().is_ok_and(|t| t.is_dir()))
+		.collect_vec();
+
+	let dirs = dirs.iter().map(|d| d.path());
+
+	for dir in dirs {
+		let filename = dir.file_name().unwrap_or_default().to_string_lossy();
+		match filename.as_ref() {
+			".git" => repos.push(dir),
+			_ => find_git_repos(&dir, repos, ignored_repos, _args),
+		}
+	}
+}
+
+fn get_commits(
+	args: CliArgs,
+	start_date: NaiveDate,
+	end_date: NaiveDate,
+) -> Result<(usize, usize, Vec<Commit>)> {
+	let mut commits: HashSet<Commit> = HashSet::new();
+
+	let ignored_repos = args.ignored_repos.as_ref().unwrap_or(&vec![]).to_owned();
+
+	let (repos, branches) = match &args.root_dir {
+		Some(roots) => {
+			let mut repos: Vec<PathBuf> = vec![];
+			for root in roots {
+				find_git_repos(root, &mut repos, &ignored_repos, &args);
+			}
+			let branches = vec!["".to_string(); repos.len()];
+			(repos, branches)
+		}
+		None => {
+			let repos = match args.repos {
+				Some(r) => r,
+				None => vec![PathBuf::from(".")],
+			};
+
+			let branches = args.branches.unwrap_or_else(|| vec!["".to_string()]);
+
+			if repos.len() > 1 && repos.len() != branches.len() {
+				return Err(anyhow!(
+					"Number of repos ({}) needs to match the number of branch lists ({})!",
+					repos.len(),
+					branches.len()
+				));
+			}
+			(repos, branches)
+		}
+	};
+
+	let midnight = NaiveTime::from_hms_opt(0, 0, 0).unwrap();
+	let start_date = start_date.and_time(midnight);
+	let start_date = Local.from_local_datetime(&start_date).unwrap();
+
+	let current_time = Local::now().time();
+	let end_date = end_date.and_time(current_time);
+	let end_date = Local.from_local_datetime(&end_date).unwrap();
+
+	let authors = args.authors.unwrap_or_default();
+	let mut repos_count = 0;
+	let mut branches_count = 0;
+
+	for (i, repo_path) in repos.iter().enumerate() {
+		let repo = gix::open(repo_path).unwrap();
+
+		let branch_names = &*branches[i];
+		let mut branches = vec![];
+		if branch_names.is_empty() {
+			branches = repo
+				.references()?
+				.prefixed("refs/heads")?
+				.filter_map(Result::ok)
+				.filter_map(|b| {
+					b.inner
+						.name
+						.to_string()
+						.strip_prefix("refs/heads/")
+						.map(|s| s.to_string())
+				})
+				.collect_vec();
+		}
+		else {
+			let branch_names = branch_names.split(' ').map(|s| s.to_string());
+			branches.extend(branch_names);
+		}
+
+		let mailmap = Mailmap::new(repo_path);
+		let mut has_commits = false;
+
+		for branch in &branches {
+			// When passing the default @ (HEAD) branch this might actually not exist at all
+			// locally so we're skipping it
+			let Ok(rev) = repo.rev_parse(&**branch)
+			else {
+				continue;
+			};
+
+			let branch_commits = rev
+				.single()
+				.unwrap()
+				.ancestors()
+				.sorting(Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
+					seconds: start_date.timestamp(),
+				})
+				.all()?;
+
+			branch_commits
+				.filter_map(|c| c.ok())
+				.filter_map(|c| c.object().ok())
+				.filter_map(|c| {
+					let title = c
+						.message()
+						.ok()?
+						.title
+						.trim_ascii()
+						.to_str()
+						.ok()?
+						.to_string();
+
+					if args.no_merges {
+						let is_merge = c.parent_ids().count() > 1;
+						if is_merge {
+							return None;
+						}
+					}
+
+					let author = c.author().ok()?;
+
+					let email = author.email.to_string();
+					let name = author.name.to_string();
+
+					let author = Author { name, email };
+					let author = mailmap.resolve(author);
+
+					if !authors.is_empty() && !authors.contains(&author.name) {
+						return None;
+					}
+
+					let time = c.time().ok()?;
+					let time =
+						DateTime::from_timestamp_millis(time.seconds * 1000)?.with_timezone(&Local);
+					if time < start_date || time > end_date {
+						return None;
+					}
+
+					has_commits = true;
+
+					Some(Commit {
+						id: c.id,
+						title,
+						author,
+						time,
+					})
+				})
+				.for_each(|c| {
+					commits.insert(c);
+				});
+		}
+
+		if has_commits {
+			repos_count += 1;
+			branches_count += branches.len();
+		}
+	}
+
+	let commits = commits
+		.into_iter()
+		.sorted_by_cached_key(|a| Reverse(a.time))
+		.collect_vec();
+
+	Ok((repos_count, branches_count, commits))
+}