feat: add aggregate_statistics to compute commit count, duration, conventional count, unique links, and days since previous release

Signed-off-by: Shingo OKAWA <shingo.okawa.g.h.c@gmail.com>

Author: ognis1205

Cargo.lock

@@ -74,6 +74,7 @@ dyn-clone = "1.0.17"
 urlencoding = "2.1.3"
 cacache = { version = "=13.0.0", features = ["mmap"], default-features = false }
 time = "0.3.37"
+chrono = { version = "0.4.41", features = ["serde"] }
 
 [dependencies.git2]
 version = "0.20.0"

git-cliff-core/Cargo.toml

@@ -38,7 +38,7 @@ use serde_json::value::Value;
 static SHA1_REGEX: Lazy<Regex> = lazy_regex!(r#"^\b([a-f0-9]{40})\b (.*)$"#);
 
 /// Object representing a link
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Deserialize, Serialize)]
 #[serde(rename_all(serialize = "camelCase"))]
 pub struct Link {
 	/// Text of the link.
@@ -123,6 +123,8 @@ impl Range {
 pub struct Commit<'a> {
 	/// Commit ID.
 	pub id:            String,
+	/// Timestamp of the commit in seconds, from epoch.
+	pub timestamp:     i64,
 	/// Commit message including title, description and summary.
 	pub message:       String,
 	/// Conventional commit.
@@ -200,6 +202,7 @@ impl From<&GitCommit<'_>> for Commit<'_> {
 	fn from(commit: &GitCommit<'_>) -> Self {
 		Commit {
 			id: commit.id().to_string(),
+			timestamp: commit.time().seconds(),
 			message: commit.message().unwrap_or_default().trim_end().to_string(),
 			author: commit.author().into(),
 			committer: commit.committer().into(),
@@ -464,6 +467,7 @@ impl Serialize for Commit<'_> {
 
 		let mut commit = serializer.serialize_struct("Commit", 20)?;
 		commit.serialize_field("id", &self.id)?;
+		commit.serialize_field("timestamp", &self.timestamp)?;
 		if let Some(conv) = &self.conv {
 			commit.serialize_field("message", conv.description())?;
 			commit.serialize_field("body", &conv.body())?;

git-cliff-core/src/commit.rs

@@ -1,14 +1,19 @@
-use std::collections::HashMap;
+use std::collections::{
+	HashMap,
+	HashSet,
+};
 
 use crate::commit::commits_to_conventional_commits;
 use crate::error::Result;
 use crate::{
 	commit::{
 		Commit,
+		Link,
 		Range,
 	},
 	config::Bump,
 	config::BumpType,
+	config::LinkParser,
 };
 #[cfg(feature = "remote")]
 use crate::{
@@ -20,6 +25,10 @@ use crate::{
 	},
 };
 
+use chrono::{
+	TimeZone,
+	Utc,
+};
 use next_version::{
 	NextVersion,
 	VersionUpdater,
@@ -31,6 +40,24 @@ use serde::{
 };
 use serde_json::value::Value;
 
+/// Aggregated statistics about commits in the release.
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct Statistics {
+	/// The total number of commits included in the release.
+	pub commit_count:                   usize,
+	/// The time span, in days, from the first to the last commit in the
+	/// release. Only present if there is more than one commit.
+	pub commit_duration_days:           Option<i32>,
+	/// The number of commits that follow the Conventional Commits
+	/// specification.
+	pub conventional_commit_count:      usize,
+	/// The links that were referenced in commit messages.
+	pub unique_links:                   Vec<Link>,
+	/// The number of days since the previous release.
+	/// Only present if this is not the first release.
+	pub days_passed_since_last_release: Option<i32>,
+}
+
 /// Representation of a release.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all(serialize = "camelCase"))]
@@ -96,6 +123,95 @@ impl Release<'_> {
 		self.calculate_next_version_with_config(&Bump::default())
 	}
 
+	/// Aggregates various statistics from the release data.
+	///
+	/// This method computes several metrics based on the current release and
+	/// its commits:
+	///
+	/// - Counts the total number of commits.
+	/// - Determines the number of days between the first and last commit.
+	/// - Counts the number of commits that follow the Conventional Commits
+	///   specification.
+	/// - Extracts and deduplicates all unique links found in commit messages
+	///   using the given link parsers.
+	/// - Calculates the number of days since the previous release, if
+	///   available.
+	pub fn aggregate_statistics(
+		&self,
+		link_parsers: &[LinkParser],
+	) -> Result<Statistics> {
+		let commit_count = self.commits.len();
+		let commit_duration_days = if self.commits.is_empty() {
+			trace!("commit_duration_days: no commits to calculate duration");
+			None
+		} else {
+			self.commits
+				.iter()
+				.min_by_key(|c| c.timestamp)
+				.zip(self.commits.iter().max_by_key(|c| c.timestamp))
+				.and_then(|(first, last)| {
+					Utc.timestamp_opt(first.timestamp, 0)
+						.single()
+						.zip(Utc.timestamp_opt(last.timestamp, 0).single())
+						.map(|(start, end)| {
+							(end.date_naive() - start.date_naive()).num_days() as i32
+						})
+				})
+				.or_else(|| {
+					trace!("commit_duration_days: timestamp conversion failed");
+					None
+				})
+		};
+		let conventional_commit_count =
+			self.commits.iter().filter(|c| c.conv.is_some()).count();
+		let unique_links: Vec<Link> = self
+			.commits
+			.iter()
+			.filter_map(|c| match c.clone().parse_links(link_parsers) {
+				Ok(parsed) => Some(parsed.links),
+				Err(err) => {
+					trace!(
+						"unique_links: parse_links failed for commit {} - {} ({})",
+						c.id.chars().take(7).collect::<String>(),
+						err,
+						c.message.lines().next().unwrap_or_default().trim()
+					);
+					None
+				}
+			})
+			.flatten()
+			.collect::<HashSet<_>>()
+			.into_iter()
+			.collect();
+		let days_passed_since_last_release = match self.previous.as_ref() {
+			Some(prev) => Utc
+				.timestamp_opt(self.timestamp, 0)
+				.single()
+				.zip(Utc.timestamp_opt(prev.timestamp, 0).single())
+				.map(|(curr, prev)| {
+					(curr.date_naive() - prev.date_naive()).num_days() as i32
+				})
+				.or_else(|| {
+					trace!(
+						"days_passed_since_last_release: timestamp conversion \
+						 failed"
+					);
+					None
+				}),
+			None => {
+				trace!("days_passed_since_last_release: previous release not found");
+				None
+			}
+		};
+		Ok(Statistics {
+			commit_count,
+			commit_duration_days,
+			conventional_commit_count,
+			unique_links,
+			days_passed_since_last_release,
+		})
+	}
+
 	/// Calculates the next version based on the commits.
 	///
 	/// It uses the given bump version configuration to calculate the next