1#![allow(clippy::disallowed_methods, reason = "This is only used in xtasks")]
2use std::{
3 fmt::{self, Debug},
4 ops::Not,
5 process::Command,
6 str::FromStr,
7 sync::LazyLock,
8};
9
10use anyhow::{Context, Result, anyhow};
11use derive_more::{Deref, DerefMut, FromStr};
12
13use itertools::Itertools;
14use regex::Regex;
15use semver::Version;
16use serde::Deserialize;
17
18pub trait Subcommand {
19 type ParsedOutput: FromStr<Err = anyhow::Error>;
20
21 fn args(&self) -> impl IntoIterator<Item = String>;
22}
23
24#[derive(Deref, DerefMut)]
25pub struct GitCommand<G: Subcommand> {
26 #[deref]
27 #[deref_mut]
28 subcommand: G,
29}
30
31impl<G: Subcommand> GitCommand<G> {
32 #[must_use]
33 pub fn run(subcommand: G) -> Result<G::ParsedOutput> {
34 Self { subcommand }.run_impl()
35 }
36
37 fn run_impl(self) -> Result<G::ParsedOutput> {
38 let command_output = Command::new("git")
39 .args(self.subcommand.args())
40 .output()
41 .context("Failed to spawn command")?;
42
43 if command_output.status.success() {
44 String::from_utf8(command_output.stdout)
45 .map_err(|_| anyhow!("Invalid UTF8"))
46 .and_then(|s| {
47 G::ParsedOutput::from_str(s.trim())
48 .map_err(|e| anyhow!("Failed to parse from string: {e:?}"))
49 })
50 } else {
51 anyhow::bail!(
52 "Command failed with exit code {}, stderr: {}",
53 command_output.status.code().unwrap_or_default(),
54 String::from_utf8(command_output.stderr).unwrap_or_default()
55 )
56 }
57 }
58}
59
60#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
61pub enum ReleaseChannel {
62 Stable,
63 Preview,
64}
65
66impl ReleaseChannel {
67 pub(crate) fn tag_suffix(&self) -> &'static str {
68 match self {
69 ReleaseChannel::Stable => "",
70 ReleaseChannel::Preview => "-pre",
71 }
72 }
73}
74
75#[derive(Debug, Clone)]
76pub struct VersionTag(Version, ReleaseChannel);
77
78impl VersionTag {
79 pub fn parse(input: &str) -> Result<Self, anyhow::Error> {
80 // Being a bit more lenient for human inputs
81 let version = input.strip_prefix('v').unwrap_or(input);
82
83 let (version_str, channel) = version
84 .strip_suffix("-pre")
85 .map_or((version, ReleaseChannel::Stable), |version_str| {
86 (version_str, ReleaseChannel::Preview)
87 });
88
89 Version::parse(version_str)
90 .map(|version| Self(version, channel))
91 .map_err(|_| anyhow::anyhow!("Failed to parse version from tag!"))
92 }
93
94 pub fn version(&self) -> &Version {
95 &self.0
96 }
97}
98
99impl ToString for VersionTag {
100 fn to_string(&self) -> String {
101 format!(
102 "v{version}{channel_suffix}",
103 version = self.0,
104 channel_suffix = self.1.tag_suffix()
105 )
106 }
107}
108
109#[derive(Debug, Deref, FromStr, PartialEq, Eq, Hash, Deserialize)]
110pub struct CommitSha(pub(crate) String);
111
112impl CommitSha {
113 pub fn new(sha: String) -> Self {
114 Self(sha)
115 }
116
117 pub fn short(&self) -> &str {
118 self.0.as_str().split_at(8).0
119 }
120}
121
122#[derive(Debug)]
123pub struct CommitDetails {
124 sha: CommitSha,
125 author: Committer,
126 title: String,
127 body: String,
128}
129
130impl CommitDetails {
131 pub fn new(sha: CommitSha, author: Committer, title: String, body: String) -> Self {
132 Self {
133 sha,
134 author,
135 title,
136 body,
137 }
138 }
139}
140
141#[derive(Debug, Clone, PartialEq, Eq)]
142pub struct Committer {
143 name: String,
144 email: String,
145}
146
147impl Committer {
148 pub fn new(name: &str, email: &str) -> Self {
149 Self {
150 name: name.to_owned(),
151 email: email.to_owned(),
152 }
153 }
154}
155
156impl fmt::Display for Committer {
157 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
158 write!(formatter, "{} ({})", self.name, self.email)
159 }
160}
161
162impl CommitDetails {
163 const BODY_DELIMITER: &str = "|body-delimiter|";
164 const COMMIT_DELIMITER: &str = "|commit-delimiter|";
165 const FIELD_DELIMITER: &str = "|field-delimiter|";
166 const FORMAT_STRING: &str = "%H|field-delimiter|%an|field-delimiter|%ae|field-delimiter|%s|body-delimiter|%b|commit-delimiter|";
167
168 fn parse(line: &str, body: &str) -> Result<Self, anyhow::Error> {
169 let Some([sha, author_name, author_email, title]) =
170 line.splitn(4, Self::FIELD_DELIMITER).collect_array()
171 else {
172 return Err(anyhow!("Failed to parse commit fields from input {line}"));
173 };
174
175 Ok(CommitDetails {
176 sha: CommitSha(sha.to_owned()),
177 author: Committer::new(author_name, author_email),
178 title: title.to_owned(),
179 body: body.to_owned(),
180 })
181 }
182
183 pub fn pr_number(&self) -> Option<u64> {
184 // Since we use squash merge, all commit titles end with the '(#12345)' pattern.
185 // While we could strictly speaking index into this directly, go for a slightly
186 // less prone approach to errors
187 const PATTERN: &str = " (#";
188 self.title
189 .rfind(PATTERN)
190 .and_then(|location| {
191 self.title[location..]
192 .find(')')
193 .map(|relative_end| location + PATTERN.len()..location + relative_end)
194 })
195 .and_then(|range| self.title[range].parse().ok())
196 }
197
198 pub(crate) fn co_authors(&self) -> Option<Vec<Committer>> {
199 static CO_AUTHOR_REGEX: LazyLock<Regex> =
200 LazyLock::new(|| Regex::new(r"Co-authored-by: (.+) <(.+)>").unwrap());
201
202 let mut co_authors = Vec::new();
203
204 for cap in CO_AUTHOR_REGEX.captures_iter(&self.body.as_ref()) {
205 let Some((name, email)) = cap
206 .get(1)
207 .map(|m| m.as_str())
208 .zip(cap.get(2).map(|m| m.as_str()))
209 else {
210 continue;
211 };
212 co_authors.push(Committer::new(name, email));
213 }
214
215 co_authors.is_empty().not().then_some(co_authors)
216 }
217
218 pub(crate) fn author(&self) -> &Committer {
219 &self.author
220 }
221
222 pub(crate) fn title(&self) -> &str {
223 &self.title
224 }
225
226 pub(crate) fn sha(&self) -> &CommitSha {
227 &self.sha
228 }
229}
230
231#[derive(Debug, Deref, Default, DerefMut)]
232pub struct CommitList(Vec<CommitDetails>);
233
234impl CommitList {
235 pub fn range(&self) -> Option<String> {
236 self.0
237 .first()
238 .zip(self.0.last())
239 .map(|(first, last)| format!("{}..{}", last.sha().0, first.sha().0))
240 }
241}
242
243impl IntoIterator for CommitList {
244 type IntoIter = std::vec::IntoIter<CommitDetails>;
245 type Item = CommitDetails;
246
247 fn into_iter(self) -> std::vec::IntoIter<Self::Item> {
248 self.0.into_iter()
249 }
250}
251
252impl FromStr for CommitList {
253 type Err = anyhow::Error;
254
255 fn from_str(input: &str) -> Result<Self, Self::Err> {
256 Ok(CommitList(
257 input
258 .split(CommitDetails::COMMIT_DELIMITER)
259 .filter(|commit_details| !commit_details.is_empty())
260 .map(|commit_details| {
261 let (line, body) = commit_details
262 .trim()
263 .split_once(CommitDetails::BODY_DELIMITER)
264 .expect("Missing body delimiter");
265 CommitDetails::parse(line, body)
266 .expect("Parsing from the output should succeed")
267 })
268 .collect(),
269 ))
270 }
271}
272
273pub struct GetVersionTags;
274
275impl Subcommand for GetVersionTags {
276 type ParsedOutput = VersionTagList;
277
278 fn args(&self) -> impl IntoIterator<Item = String> {
279 ["tag", "-l", "v*"].map(ToOwned::to_owned)
280 }
281}
282
283pub struct VersionTagList(Vec<VersionTag>);
284
285impl VersionTagList {
286 pub fn sorted(mut self) -> Self {
287 self.0.sort_by(|a, b| a.version().cmp(b.version()));
288 self
289 }
290
291 pub fn find_previous_minor_version(&self, version_tag: &VersionTag) -> Option<&VersionTag> {
292 self.0
293 .iter()
294 .take_while(|tag| tag.version() < version_tag.version())
295 .collect_vec()
296 .into_iter()
297 .rev()
298 .find(|tag| {
299 (tag.version().major < version_tag.version().major
300 || (tag.version().major == version_tag.version().major
301 && tag.version().minor < version_tag.version().minor))
302 && tag.version().patch == 0
303 })
304 }
305}
306
307impl FromStr for VersionTagList {
308 type Err = anyhow::Error;
309
310 fn from_str(s: &str) -> Result<Self, Self::Err> {
311 let version_tags = s.lines().flat_map(VersionTag::parse).collect_vec();
312
313 version_tags
314 .is_empty()
315 .not()
316 .then_some(Self(version_tags))
317 .ok_or_else(|| anyhow::anyhow!("No version tags found"))
318 }
319}
320
321pub struct CommitsFromVersionToVersion {
322 version_tag: VersionTag,
323 branch: String,
324}
325
326impl CommitsFromVersionToVersion {
327 pub fn new(version_tag: VersionTag, branch: String) -> Self {
328 Self {
329 version_tag,
330 branch,
331 }
332 }
333}
334
335impl Subcommand for CommitsFromVersionToVersion {
336 type ParsedOutput = CommitList;
337
338 fn args(&self) -> impl IntoIterator<Item = String> {
339 [
340 "log".to_string(),
341 format!("--pretty=format:{}", CommitDetails::FORMAT_STRING),
342 format!(
343 "{version}..{branch}",
344 version = self.version_tag.to_string(),
345 branch = self.branch
346 ),
347 ]
348 }
349}
350
351pub struct NoOutput;
352
353impl FromStr for NoOutput {
354 type Err = anyhow::Error;
355
356 fn from_str(_: &str) -> Result<Self, Self::Err> {
357 Ok(NoOutput)
358 }
359}
360
361#[cfg(test)]
362mod tests {
363 use super::*;
364 use indoc::indoc;
365
366 #[test]
367 fn parse_stable_version_tag() {
368 let tag = VersionTag::parse("v0.172.8").unwrap();
369 assert_eq!(tag.version().major, 0);
370 assert_eq!(tag.version().minor, 172);
371 assert_eq!(tag.version().patch, 8);
372 assert_eq!(tag.1, ReleaseChannel::Stable);
373 }
374
375 #[test]
376 fn parse_preview_version_tag() {
377 let tag = VersionTag::parse("v0.172.1-pre").unwrap();
378 assert_eq!(tag.version().major, 0);
379 assert_eq!(tag.version().minor, 172);
380 assert_eq!(tag.version().patch, 1);
381 assert_eq!(tag.1, ReleaseChannel::Preview);
382 }
383
384 #[test]
385 fn parse_version_tag_without_v_prefix() {
386 let tag = VersionTag::parse("0.172.8").unwrap();
387 assert_eq!(tag.version().major, 0);
388 assert_eq!(tag.version().minor, 172);
389 assert_eq!(tag.version().patch, 8);
390 }
391
392 #[test]
393 fn parse_invalid_version_tag() {
394 let result = VersionTag::parse("vConradTest");
395 assert!(result.is_err());
396 }
397
398 #[test]
399 fn version_tag_stable_roundtrip() {
400 let tag = VersionTag::parse("v0.172.8").unwrap();
401 assert_eq!(tag.to_string(), "v0.172.8");
402 }
403
404 #[test]
405 fn version_tag_preview_roundtrip() {
406 let tag = VersionTag::parse("v0.172.1-pre").unwrap();
407 assert_eq!(tag.to_string(), "v0.172.1-pre");
408 }
409
410 #[test]
411 fn sorted_orders_by_semver() {
412 let input = indoc! {"
413 v0.172.8
414 v0.170.1
415 v0.171.4
416 v0.170.2
417 v0.172.11
418 v0.171.3
419 v0.172.9
420 "};
421 let list = VersionTagList::from_str(input).unwrap().sorted();
422 for window in list.0.windows(2) {
423 assert!(
424 window[0].version() <= window[1].version(),
425 "{} should come before {}",
426 window[0].to_string(),
427 window[1].to_string()
428 );
429 }
430 assert_eq!(list.0[0].to_string(), "v0.170.1");
431 assert_eq!(list.0[list.0.len() - 1].to_string(), "v0.172.11");
432 }
433
434 #[test]
435 fn find_previous_minor_for_173_returns_172() {
436 let input = indoc! {"
437 v0.170.1
438 v0.170.2
439 v0.171.3
440 v0.171.4
441 v0.172.0
442 v0.172.8
443 v0.172.9
444 v0.172.11
445 "};
446 let list = VersionTagList::from_str(input).unwrap().sorted();
447 let target = VersionTag::parse("v0.173.0").unwrap();
448 let previous = list.find_previous_minor_version(&target).unwrap();
449 assert_eq!(previous.version().major, 0);
450 assert_eq!(previous.version().minor, 172);
451 assert_eq!(previous.version().patch, 0);
452 }
453
454 #[test]
455 fn find_previous_minor_skips_same_minor() {
456 let input = indoc! {"
457 v0.172.8
458 v0.172.9
459 v0.172.11
460 "};
461 let list = VersionTagList::from_str(input).unwrap().sorted();
462 let target = VersionTag::parse("v0.172.8").unwrap();
463 assert!(list.find_previous_minor_version(&target).is_none());
464 }
465
466 #[test]
467 fn find_previous_minor_with_major_version_gap() {
468 let input = indoc! {"
469 v0.172.0
470 v0.172.9
471 v0.172.11
472 "};
473 let list = VersionTagList::from_str(input).unwrap().sorted();
474 let target = VersionTag::parse("v1.0.0").unwrap();
475 let previous = list.find_previous_minor_version(&target).unwrap();
476 assert_eq!(previous.to_string(), "v0.172.0");
477 }
478
479 #[test]
480 fn find_previous_minor_requires_zero_patch_version() {
481 let input = indoc! {"
482 v0.172.1
483 v0.172.9
484 v0.172.11
485 "};
486 let list = VersionTagList::from_str(input).unwrap().sorted();
487 let target = VersionTag::parse("v1.0.0").unwrap();
488 assert!(list.find_previous_minor_version(&target).is_none());
489 }
490
491 #[test]
492 fn parse_tag_list_from_real_tags() {
493 let input = indoc! {"
494 v0.9999-temporary
495 vConradTest
496 v0.172.8
497 "};
498 let list = VersionTagList::from_str(input).unwrap();
499 assert_eq!(list.0.len(), 1);
500 assert_eq!(list.0[0].to_string(), "v0.172.8");
501 }
502
503 #[test]
504 fn parse_empty_tag_list_fails() {
505 let result = VersionTagList::from_str("");
506 assert!(result.is_err());
507 }
508
509 #[test]
510 fn pr_number_from_squash_merge_title() {
511 let line = format!(
512 "abc123{d}Author Name{d}author@email.com{d}Add cool feature (#12345)",
513 d = CommitDetails::FIELD_DELIMITER
514 );
515 let commit = CommitDetails::parse(&line, "").unwrap();
516 assert_eq!(commit.pr_number(), Some(12345));
517 }
518
519 #[test]
520 fn pr_number_missing() {
521 let line = format!(
522 "abc123{d}Author Name{d}author@email.com{d}Some commit without PR ref",
523 d = CommitDetails::FIELD_DELIMITER
524 );
525 let commit = CommitDetails::parse(&line, "").unwrap();
526 assert_eq!(commit.pr_number(), None);
527 }
528
529 #[test]
530 fn pr_number_takes_last_match() {
531 let line = format!(
532 "abc123{d}Author Name{d}author@email.com{d}Fix (#123) and refactor (#456)",
533 d = CommitDetails::FIELD_DELIMITER
534 );
535 let commit = CommitDetails::parse(&line, "").unwrap();
536 assert_eq!(commit.pr_number(), Some(456));
537 }
538
539 #[test]
540 fn co_authors_parsed_from_body() {
541 let line = format!(
542 "abc123{d}Author Name{d}author@email.com{d}Some title",
543 d = CommitDetails::FIELD_DELIMITER
544 );
545 let body = indoc! {"
546 Co-authored-by: Alice Smith <alice@example.com>
547 Co-authored-by: Bob Jones <bob@example.com>
548 "};
549 let commit = CommitDetails::parse(&line, body).unwrap();
550 let co_authors = commit.co_authors().unwrap();
551 assert_eq!(co_authors.len(), 2);
552 assert_eq!(
553 co_authors[0],
554 Committer::new("Alice Smith", "alice@example.com")
555 );
556 assert_eq!(
557 co_authors[1],
558 Committer::new("Bob Jones", "bob@example.com")
559 );
560 }
561
562 #[test]
563 fn no_co_authors_returns_none() {
564 let line = format!(
565 "abc123{d}Author Name{d}author@email.com{d}Some title",
566 d = CommitDetails::FIELD_DELIMITER
567 );
568 let commit = CommitDetails::parse(&line, "").unwrap();
569 assert!(commit.co_authors().is_none());
570 }
571
572 #[test]
573 fn commit_sha_short_returns_first_8_chars() {
574 let sha = CommitSha("abcdef1234567890abcdef1234567890abcdef12".into());
575 assert_eq!(sha.short(), "abcdef12");
576 }
577
578 #[test]
579 fn parse_commit_list_from_git_log_format() {
580 let fd = CommitDetails::FIELD_DELIMITER;
581 let bd = CommitDetails::BODY_DELIMITER;
582 let cd = CommitDetails::COMMIT_DELIMITER;
583
584 let input = format!(
585 "sha111{fd}Alice{fd}alice@test.com{fd}First commit (#100){bd}First body{cd}sha222{fd}Bob{fd}bob@test.com{fd}Second commit (#200){bd}Second body{cd}"
586 );
587
588 let list = CommitList::from_str(&input).unwrap();
589 assert_eq!(list.0.len(), 2);
590
591 assert_eq!(list.0[0].sha().0, "sha111");
592 assert_eq!(
593 list.0[0].author(),
594 &Committer::new("Alice", "alice@test.com")
595 );
596 assert_eq!(list.0[0].title(), "First commit (#100)");
597 assert_eq!(list.0[0].pr_number(), Some(100));
598 assert_eq!(list.0[0].body, "First body");
599
600 assert_eq!(list.0[1].sha().0, "sha222");
601 assert_eq!(list.0[1].author(), &Committer::new("Bob", "bob@test.com"));
602 assert_eq!(list.0[1].title(), "Second commit (#200)");
603 assert_eq!(list.0[1].pr_number(), Some(200));
604 assert_eq!(list.0[1].body, "Second body");
605 }
606}