hygiene/

lib.rs

//! Issue hygiene of this repository: the form of a pull request, and of
//! a commit on `main`. The module [`book`] checks the book, [`wrap`]
//! checks the wrap of its pages, [`blank`] finds two blank lines in a
//! row, [`versions`] finds the name of a version of riff, [`ci`] picks
//! the checks that `just ci` runs, and [`terminal`] finds the crates of
//! the terminal in the dependencies of a crate.
//!
//! # Design
//!
//! A change reaches `main` through a pull request, as one squash commit.
//! GitHub makes the commit from the pull request: its title, then the
//! number of the pull request, then its body. So the form of the body is
//! the form of each commit on `main`:
//!
//! ```text
//! Closes #77
//!
//! Pause and resume the riff. A new riff starts paused.
//!
//! Issue: #77
//! Milestone: Wave 3
//! ```
//!
//! - The link line, `Closes #N` or `Refs #N`, links the pull request and
//!   the issue. The last pull request of an issue has `Closes #N`, so its
//!   merge closes the issue. Each other one has `Refs #N`.
//! - The trailers `Issue:` and `Milestone:` end the body. They name the
//!   issue and the wave in the same form in each commit. The trailer
//!   `Milestone:` names a wave by its number: `Wave 3`, with no name
//!   ([`milestone_value`]). The check compares only the number, so a
//!   rename of a wave breaks no pull request ([`names_milestone`],
//!   01M518A04JWYJE5FA1VR309SAA).
//! - The trailers stand in the last block of git trailers of the
//!   message ([`trailers`]). Other trailers may stand in the block,
//!   before or after them: `Signed-off-by:`, `Generated-by:`. At the
//!   squash, GitHub adds a `Co-authored-by:` line for each co-author of
//!   the commits, in a paragraph of its own. So `hygiene pr` checks the
//!   message that the squash will make ([`PullRequest::squash_message`]),
//!   not only the body.
//! - The merge wraps each line of the body over 72 characters
//!   ([`merge_wrap`]). The tail of a trailer line goes to a line with no
//!   `Key:`, and that line ends the block of trailers. So `hygiene pr`
//!   fails a trailer line over the width (`trailer-wrap`) before the
//!   merge.
//!
//! `hygiene pr N` reads pull request N and its issue with `gh`, and runs
//! [`check_pr`]. `hygiene commit [REV]` reads the message of a commit
//! with `git`, and runs [`check_commit`]. Each error names its rule:
//!
//! | Rule | Finds |
//! |---|---|
//! | `link` | A body with no link line, or with more than one. |
//! | `keyword` | Another closing keyword of GitHub before an issue number, for example `Fixes #12`. It closes an issue with no check. |
//! | `title` | A title of a pull request that ends with `(#N)`. GitHub adds the number of the pull request. |
//! | `issue-trailer` | No `Issue: #N` trailer, more than one, or one that names another issue than the link line. |
//! | `milestone-trailer` | No `Milestone:` trailer, more than one, or one that names another wave than the pull request. |
//! | `trailer-wrap` | A line of the last block of trailers over 72 characters. The merge wraps it, and the wrapped part is no trailer line ([`merge_wrap`]). |
//! | `milestone` | A pull request or an issue with no milestone, or two different milestones. |
//! | `issue-open` | An issue that is closed. |
//! | `commit-title` | A commit title that does not end with `(#PR)`, or that names the issue in place of the pull request. |
//!
//! ```
//! use hygiene::{Issue, PullRequest};
//!
//! let pr = PullRequest::new(
//!     "Pause and resume the riff",
//!     "Closes #77\n\nPause the riff.\n\nIssue: #77\nMilestone: Wave 3\n",
//!     Some("Wave 3"),
//! );
//! let issue = Issue::new(77, "OPEN", Some("Wave 3"));
//! assert!(hygiene::check_pr(&pr, Some(&issue)).is_empty());
//!
//! let commit = "Pause and resume the riff (#90)\n\nCloses #77\n\nIssue: #77\nMilestone: Wave 3\n";
//! assert!(hygiene::check_commit(commit).is_empty());
//! ```

use std::fmt;

use serde::Deserialize;

pub mod blank;
pub mod book;
pub mod ci;
pub mod part;
pub mod terminal;
pub mod versions;
pub mod wrap;

/// A milestone, as `gh --json milestone` gives it.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
pub struct Milestone {
    /// The name, for example `Wave 3`.
    pub title: String,
}

/// A pull request, as `gh pr view --json title,body,milestone,author,commits`
/// gives it.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
pub struct PullRequest {
    /// The title. The squash commit gets it, and the number.
    pub title: String,
    /// The body. The squash commit gets it as its message.
    pub body: String,
    /// The milestone, or `None`.
    pub milestone: Option<Milestone>,
    /// The author of the pull request. The squash commit is its work, so
    /// it is not a co-author.
    #[serde(default)]
    pub author: Option<Person>,
    /// The commits of the pull request.
    #[serde(default)]
    pub commits: Vec<PullCommit>,
}

/// A person, as `gh` gives an author. `gh` leaves out the fields that
/// it does not know.
#[derive(Debug, Clone, Default, PartialEq, Eq, Deserialize)]
pub struct Person {
    /// The login on GitHub.
    #[serde(default)]
    pub login: String,
    /// The name.
    #[serde(default)]
    pub name: String,
    /// The email.
    #[serde(default)]
    pub email: String,
}

/// A commit of a pull request: the people that GitHub counts as its
/// authors. They are the author, and each person of a `Co-authored-by:`
/// line.
#[derive(Debug, Clone, Default, PartialEq, Eq, Deserialize)]
pub struct PullCommit {
    /// The authors of the commit.
    #[serde(default)]
    pub authors: Vec<Person>,
}

impl PullRequest {
    /// A pull request with a title, a body and a milestone, and no
    /// co-author.
    pub fn new(title: &str, body: &str, milestone: Option<&str>) -> Self {
        Self {
            title: title.to_owned(),
            body: body.to_owned(),
            milestone: milestone.map(milestone_of),
            author: None,
            commits: Vec::new(),
        }
    }

    /// The same pull request with `author` as its author.
    pub fn by(mut self, author: Person) -> Self {
        self.author = Some(author);
        self
    }

    /// The same pull request with one more commit by `author`.
    pub fn with_commit_by(mut self, author: Person) -> Self {
        self.commits.push(PullCommit {
            authors: vec![author],
        });
        self
    }

    /// The lines `Co-authored-by: Name <email>` that GitHub adds to the
    /// squash commit: one for each author of a commit, except the author
    /// of the pull request, and each one once.
    ///
    /// ```
    /// use hygiene::{Person, PullRequest};
    /// let person = |login: &str, name: &str, email: &str| Person {
    ///     login: login.into(),
    ///     name: name.into(),
    ///     email: email.into(),
    /// };
    /// let pr = PullRequest::new("T", "Text.", None)
    ///     .by(person("ana", "Ana", "ana@example.com"))
    ///     .with_commit_by(person("ana", "Ana", "ana@example.com"))
    ///     .with_commit_by(person("", "GLM-5.3-Flash", "noreply@z.ai"))
    ///     .with_commit_by(person("", "GLM-5.3-Flash", "noreply@z.ai"));
    /// assert_eq!(pr.co_authors(), ["Co-authored-by: GLM-5.3-Flash <noreply@z.ai>"]);
    /// ```
    pub fn co_authors(&self) -> Vec<String> {
        let mut lines: Vec<String> = Vec::new();
        for person in self.commits.iter().flat_map(|c| &c.authors) {
            let own = self.author.as_ref().is_some_and(|a| {
                (!a.login.is_empty() && a.login == person.login)
                    || (!a.email.is_empty() && a.email == person.email)
            });
            let name = if person.name.is_empty() {
                &person.login
            } else {
                &person.name
            };
            if own || name.is_empty() {
                continue;
            }
            let line = format!("Co-authored-by: {name} <{}>", person.email);
            if !lines.contains(&line) {
                lines.push(line);
            }
        }
        lines
    }

    /// The message that the squash will make from the body: the body, with
    /// each line over [`MERGE_WIDTH`] wrapped as the merge wraps it
    /// ([`merge_wrap`]), then the lines of [`PullRequest::co_authors`] in a
    /// paragraph of their own. GitHub adds them after a blank line, also
    /// when the body ends with trailers.
    ///
    /// ```
    /// use hygiene::{Person, PullRequest};
    /// let glm = Person { name: "GLM".into(), email: "noreply@z.ai".into(), ..Person::default() };
    /// let pr = PullRequest::new("T", "Text.\n\nIssue: #7\n", None).with_commit_by(glm);
    /// assert_eq!(
    ///     pr.squash_message(),
    ///     "Text.\n\nIssue: #7\n\nCo-authored-by: GLM <noreply@z.ai>\n"
    /// );
    /// ```
    pub fn squash_message(&self) -> String {
        self.with_co_authors(merge_wrap(&self.body.replace("\r\n", "\n")))
    }

    /// The message of [`PullRequest::squash_message`] as the author wrote
    /// it, before the merge wraps its long lines.
    fn written_message(&self) -> String {
        self.with_co_authors(self.body.replace("\r\n", "\n"))
    }

    /// `body`, then the lines of [`PullRequest::co_authors`].
    fn with_co_authors(&self, mut message: String) -> String {
        let co_authors = self.co_authors();
        if !co_authors.is_empty() {
            message.truncate(message.trim_end().len());
            message.push_str("\n\n");
            message.push_str(&co_authors.join("\n"));
            message.push('\n');
        }
        message
    }
}

/// An issue, as `gh issue view --json number,state,milestone` gives it.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
pub struct Issue {
    /// The number.
    pub number: u64,
    /// `OPEN` or `CLOSED`.
    pub state: String,
    /// The milestone, or `None`.
    pub milestone: Option<Milestone>,
}

impl Issue {
    /// An issue with a number, a state and a milestone.
    pub fn new(number: u64, state: &str, milestone: Option<&str>) -> Self {
        Self {
            number,
            state: state.to_owned(),
            milestone: milestone.map(milestone_of),
        }
    }
}

fn milestone_of(title: &str) -> Milestone {
    Milestone {
        title: title.to_owned(),
    }
}

/// The number N of the wave title `title`: `Wave N`, or `Wave N: NAME`
/// with a name that is not blank. `None` for each other title.
///
/// ```
/// use hygiene::wave_number;
///
/// assert_eq!(wave_number("Wave 6"), Some(6));
/// assert_eq!(wave_number("Wave 27: 3.0 Wave A"), Some(27));
/// assert_eq!(wave_number("Backlog"), None);
/// assert_eq!(wave_number("Wave 2x"), None);
/// assert_eq!(wave_number("Wave 6:"), None);
/// assert_eq!(wave_number("Wave -1"), None);
/// ```
pub fn wave_number(title: &str) -> Option<u64> {
    let rest = title.strip_prefix("Wave ")?;
    let (number, name) = match rest.split_once(':') {
        Some((number, name)) => (number, Some(name)),
        None => (rest, None),
    };
    let digits = !number.is_empty() && number.bytes().all(|b| b.is_ascii_digit());
    let named = name.is_none_or(|n| n.starts_with(' ') && !n.trim().is_empty());
    (digits && named).then(|| number.parse().ok()).flatten()
}

/// The value of the trailer `Milestone:` for the milestone `title`: the
/// wave by its number, `Wave N` with no name, or the whole title of a
/// milestone that is not a wave (01M518A07QF1YACBYT91M0DD1R).
///
/// ```
/// assert_eq!(hygiene::milestone_value("Wave 28: cloud, fixes that slow the work"), "Wave 28");
/// assert_eq!(hygiene::milestone_value("Wave 3"), "Wave 3");
/// assert_eq!(hygiene::milestone_value("Backlog"), "Backlog");
/// ```
pub fn milestone_value(title: &str) -> String {
    wave_number(title).map_or_else(|| title.to_owned(), |n| format!("Wave {n}"))
}

/// True when the trailer `Milestone: value` names the milestone `title`.
/// Two waves match by their number, so the name of a wave can change.
/// Each other milestone matches by its whole title
/// (01M518A04JWYJE5FA1VR309SAA).
///
/// ```
/// use hygiene::names_milestone;
///
/// let renamed = "Wave 28: cloud, fixes that slow the work";
/// assert!(names_milestone("Wave 28", renamed));
/// assert!(names_milestone("Wave 28: after 1.4.0", renamed), "the title before the rename");
/// assert!(!names_milestone("Wave 27: after 1.4.0", renamed), "another wave");
/// assert!(names_milestone("Backlog", "Backlog"));
/// assert!(!names_milestone("Wave 28", "Backlog"));
/// ```
pub fn names_milestone(value: &str, title: &str) -> bool {
    match (wave_number(value), wave_number(title)) {
        (Some(named), Some(own)) => named == own,
        _ => value == title,
    }
}

/// A broken rule of issue hygiene.
///
/// ```
/// let error = hygiene::Error::new("link", "the body has no link line");
/// assert_eq!(error.to_string(), "link: the body has no link line");
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Error {
    /// The rule, for example `link`. See the table of rules.
    pub rule: &'static str,
    /// What is wrong, and what to do.
    pub text: String,
}

impl Error {
    /// An error of `rule`.
    pub fn new(rule: &'static str, text: impl Into<String>) -> Self {
        Self {
            rule,
            text: text.into(),
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}: {}", self.rule, self.text)
    }
}

/// The link line of a pull request.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Link {
    /// `Closes #N`: the last pull request of issue N. Its merge closes
    /// the issue.
    Closes(u64),
    /// `Refs #N`: each other pull request of issue N.
    Refs(u64),
}

impl Link {
    /// The number of the issue.
    pub fn issue(self) -> u64 {
        match self {
            Self::Closes(n) | Self::Refs(n) => n,
        }
    }

    /// The link of one line: `Closes #N` or `Refs #N`, and nothing else.
    ///
    /// ```
    /// use hygiene::Link;
    /// assert_eq!(Link::parse("Closes #12"), Some(Link::Closes(12)));
    /// assert_eq!(Link::parse("  Refs #7 "), Some(Link::Refs(7)));
    /// assert_eq!(Link::parse("closes #12"), None, "a keyword, not a link line");
    /// assert_eq!(Link::parse("Closes #12 and #13"), None);
    /// ```
    pub fn parse(line: &str) -> Option<Self> {
        let mut words = line.split_whitespace();
        let (word, number, None) = (words.next()?, words.next()?, words.next()) else {
            return None;
        };
        let n = issue_ref(number)?;
        match word {
            "Closes" => Some(Self::Closes(n)),
            "Refs" => Some(Self::Refs(n)),
            _ => None,
        }
    }
}

/// The number of `#N`.
///
/// ```
/// assert_eq!(hygiene::issue_ref("#12"), Some(12));
/// assert_eq!(hygiene::issue_ref("12"), None);
/// assert_eq!(hygiene::issue_ref("#"), None);
/// ```
pub fn issue_ref(word: &str) -> Option<u64> {
    let digits = word.strip_prefix('#')?;
    if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
        return None;
    }
    digits.parse().ok()
}

/// The closing keywords of GitHub.
const KEYWORDS: &[&str] = &[
    "close", "closes", "closed", "fix", "fixes", "fixed", "resolve", "resolves", "resolved",
];

/// Each closing keyword of GitHub before an issue number, outside the
/// link lines. GitHub closes such an issue at the merge.
///
/// ```
/// let body = "Closes #12\n\nThis fixes #13, and closes: #14. It closes a gap.";
/// assert_eq!(hygiene::stray_keywords(body), ["fixes #13", "closes: #14"]);
/// ```
pub fn stray_keywords(body: &str) -> Vec<String> {
    let mut found = Vec::new();
    for line in body.lines().filter(|l| Link::parse(l).is_none()) {
        let words: Vec<&str> = line.split_whitespace().collect();
        for pair in words.windows(2) {
            let keyword = pair[0].trim_end_matches(':').to_lowercase();
            if KEYWORDS.contains(&keyword.as_str()) && names_issue(pair[1]) {
                let number = pair[1].trim_end_matches(|c: char| !c.is_ascii_digit());
                found.push(format!("{} {number}", pair[0]));
            }
        }
    }
    found
}

/// True for `#N` or `OWNER/REPO#N`, with punctuation after it.
fn names_issue(word: &str) -> bool {
    let word = word.trim_end_matches(|c: char| !c.is_ascii_digit());
    word.rfind('#')
        .is_some_and(|i| issue_ref(&word[i..]).is_some())
}

/// The trailers of a message: the lines `Key: value` of its last block of
/// trailers. The block is the last paragraphs of the message that hold
/// only such lines. GitHub adds its `Co-authored-by:` lines after a blank
/// line, so the block may have more than one paragraph. A paragraph with a
/// line of another form ends the block, and a last paragraph of that form
/// leaves no trailer at all.
///
/// ```
/// let body = "Closes #7\n\nText.\n\nIssue: #7\nMilestone: Wave 3\n";
/// assert_eq!(hygiene::trailers(body), [
///     ("Issue".to_owned(), "#7".to_owned()),
///     ("Milestone".to_owned(), "Wave 3".to_owned()),
/// ]);
/// assert!(hygiene::trailers("Text.\n\nIssue: #7\nmore text").is_empty());
///
/// // The squash of a pull request with a co-author:
/// let squash = "Text.\n\nIssue: #7\nMilestone: Wave 3\n\nCo-authored-by: A <a@b.c>\n";
/// let keys: Vec<_> = hygiene::trailers(squash).into_iter().map(|(k, _)| k).collect();
/// assert_eq!(keys, ["Issue", "Milestone", "Co-authored-by"]);
///
/// // A paragraph of text after the trailers ends the block.
/// assert!(hygiene::trailers("Issue: #7\n\nText.\n\nCo-authored-by: A <a@b.c>\n")
///     .iter()
///     .all(|(k, _)| k != "Issue"));
/// ```
pub fn trailers(text: &str) -> Vec<(String, String)> {
    trailer_block(text)
        .into_iter()
        .filter_map(trailer_line)
        .collect()
}

/// The lines of the last block of trailers of a message, each one a line
/// `Key: value` ([`trailers`]).
fn trailer_block(text: &str) -> Vec<&str> {
    let mut paragraphs: Vec<Vec<&str>> = Vec::new();
    let mut open = false;
    for line in text.lines().map(str::trim_end) {
        if line.is_empty() {
            open = false;
        } else if open {
            paragraphs.last_mut().unwrap().push(line);
        } else {
            paragraphs.push(vec![line]);
            open = true;
        }
    }
    let mut found = Vec::new();
    for paragraph in paragraphs.iter().rev() {
        if !paragraph.iter().all(|line| trailer_line(line).is_some()) {
            break;
        }
        found.splice(0..0, paragraph.iter().copied());
    }
    found
}

/// The width of a line in the message of a squash commit: the merge
/// wraps a longer line ([`merge_wrap`]).
pub const MERGE_WIDTH: usize = 72;

/// The text as the squash merge of GitHub leaves it: a line of
/// [`MERGE_WIDTH`] characters or fewer stays as it is. A longer line loses
/// its indent and its double spaces, and is filled again with whole words
/// up to [`MERGE_WIDTH`] characters. The wrapped lines have no indent, and
/// the next line does not join them. A word longer than the width stays on
/// a line of its own.
///
/// So a trailer line over the width is no trailer line in the commit: the
/// second line of it has no `Key:`, and it ends the block of trailers
/// (`trailer-wrap`, 01M6FYR8XH4WPAH2AFW6B0NARJ).
///
/// ```
/// let line = "Generated-by: GLM-5.3-Flash (brief, implementation, task review, final review)";
/// assert_eq!(
///     hygiene::merge_wrap(line),
///     "Generated-by: GLM-5.3-Flash (brief, implementation, task review, final\nreview)"
/// );
///
/// // A line of 72 characters stays. The next line stays too.
/// let kept = format!("{}\n  indent\n", "word ".repeat(14) + "wo");
/// assert_eq!(hygiene::merge_wrap(&kept), kept);
///
/// // A long line with an indent loses it.
/// let item = "  ".to_owned() + &"word ".repeat(15);
/// assert!(!hygiene::merge_wrap(&item).starts_with(' '));
/// ```
pub fn merge_wrap(text: &str) -> String {
    let mut wrapped = String::with_capacity(text.len());
    for (i, line) in text.split('\n').enumerate() {
        if i > 0 {
            wrapped.push('\n');
        }
        if line.chars().count() <= MERGE_WIDTH {
            wrapped.push_str(line);
            continue;
        }
        let mut width = 0;
        for word in line.split_whitespace() {
            let length = word.chars().count();
            if width == 0 {
                // The first word of a line.
            } else if width + 1 + length <= MERGE_WIDTH {
                wrapped.push(' ');
                width += 1;
            } else {
                wrapped.push('\n');
                width = 0;
            }
            wrapped.push_str(word);
            width += length;
        }
    }
    wrapped
}

/// Each line of the last block of trailers of `text` that the merge wraps.
fn wrapped_trailer_lines(text: &str) -> Vec<&str> {
    trailer_block(text)
        .into_iter()
        .filter(|line| line.chars().count() > MERGE_WIDTH)
        .collect()
}

/// The key and the value of a line `Key: value`, or `None`.
fn trailer_line(line: &str) -> Option<(String, String)> {
    let (key, value) = line.split_once(": ")?;
    let key_ok = !key.is_empty() && key.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-');
    if !key_ok || value.trim().is_empty() {
        return None;
    }
    Some((key.to_owned(), value.trim().to_owned()))
}

/// The issue of a pull request: the issue of its first link line, or of
/// its `Issue:` trailer. `hygiene pr` reads this issue.
///
/// ```
/// use hygiene::PullRequest;
/// let pr = PullRequest::new("T", "Refs #9\n\nIssue: #9\nMilestone: Wave 3", None);
/// assert_eq!(hygiene::issue_number(&pr), Some(9));
/// assert_eq!(hygiene::issue_number(&PullRequest::new("T", "Text.", None)), None);
/// ```
pub fn issue_number(pr: &PullRequest) -> Option<u64> {
    let body = pr.body.replace("\r\n", "\n");
    body.lines()
        .find_map(Link::parse)
        .map(Link::issue)
        .or_else(|| {
            trailers(&body)
                .iter()
                .find(|(k, _)| k == "Issue")
                .and_then(|(_, v)| issue_ref(v))
        })
}

/// The number `N` at the end of a title `TEXT (#N)`.
fn title_number(title: &str) -> Option<u64> {
    let (_, tail) = title.trim_end().strip_suffix(')')?.rsplit_once("(#")?;
    issue_ref(&format!("#{tail}"))
}

/// The values of the trailer `key`.
fn values<'a>(trailers: &'a [(String, String)], key: &str) -> Vec<&'a str> {
    trailers
        .iter()
        .filter(|(k, _)| k == key)
        .map(|(_, v)| v.as_str())
        .collect()
}

/// The issue of the one `Issue: #N` trailer. Adds an `issue-trailer`
/// error when the trailer is missing, when it is there more than one
/// time, or when its value is not `#N`.
fn issue_trailer(trailers: &[(String, String)], errors: &mut Vec<Error>) -> Option<u64> {
    match values(trailers, "Issue")[..] {
        [] => {
            errors.push(Error::new(
                "issue-trailer",
                "the message does not end with the trailer `Issue: #N`",
            ));
            None
        }
        [value] => {
            let n = issue_ref(value);
            if n.is_none() {
                errors.push(Error::new(
                    "issue-trailer",
                    format!("`Issue: {value}` does not name an issue as `#N`"),
                ));
            }
            n
        }
        ref many => {
            errors.push(Error::new(
                "issue-trailer",
                format!("the message has {} `Issue:` trailers; keep one", many.len()),
            ));
            None
        }
    }
}

/// The value of the one `Milestone:` trailer. Adds a
/// `milestone-trailer` error when the trailer is missing, or when it is
/// there more than one time.
fn milestone_trailer<'a>(
    trailers: &'a [(String, String)],
    errors: &mut Vec<Error>,
) -> Option<&'a str> {
    match values(trailers, "Milestone")[..] {
        [] => {
            errors.push(Error::new(
                "milestone-trailer",
                "the message does not end with the trailer `Milestone: M`",
            ));
            None
        }
        [value] => Some(value),
        ref many => {
            errors.push(Error::new(
                "milestone-trailer",
                format!(
                    "the message has {} `Milestone:` trailers; keep one",
                    many.len()
                ),
            ));
            None
        }
    }
}

/// Checks a pull request and its issue. `issue` is `None` when the pull
/// request names no issue. Returns each broken rule, in the order of the
/// table of rules.
///
/// ```
/// use hygiene::{Issue, PullRequest};
///
/// let pr = PullRequest::new("Fix it (#12)", "Fixes #12\n\nIssue: #12\n", Some("Wave 3"));
/// let issue = Issue::new(12, "CLOSED", Some("Wave 4"));
/// let rules: Vec<_> = hygiene::check_pr(&pr, Some(&issue)).iter().map(|e| e.rule).collect();
/// assert_eq!(rules, ["link", "keyword", "title", "milestone-trailer", "milestone", "issue-open"]);
/// ```
pub fn check_pr(pr: &PullRequest, issue: Option<&Issue>) -> Vec<Error> {
    check_pr_for(Rules::All, pr, issue)
}

/// The rules that a check of a pull request applies.
///
/// riff reads the link line and the trailer `Issue:`. The other rules
/// are the habits of riff itself. So a repository gets them only when
/// its riff config asks for them.
///
/// ```
/// use hygiene::Rules;
///
/// assert!(Rules::All.applies("milestone"));
/// assert!(Rules::Read.applies("link") && Rules::Read.applies("issue-trailer"));
/// assert!(!Rules::Read.applies("title"));
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Rules {
    /// Each rule of the table: the repository of riff, and a repository
    /// whose riff config asks for them.
    All,
    /// Only the rules for what riff reads: `link` and `issue-trailer`.
    Read,
}

impl Rules {
    /// True when the rule named `rule` is one of these rules.
    pub fn applies(self, rule: &str) -> bool {
        match self {
            Self::All => true,
            Self::Read => matches!(rule, "link" | "issue-trailer"),
        }
    }
}

/// Checks a pull request and its issue with the rules `rules`
/// ([`check_pr`] with [`Rules::All`]).
///
/// ```
/// use hygiene::{Issue, PullRequest, Rules};
///
/// // A title with `(#12)`, a keyword and no milestone: only `Rules::All` finds them.
/// let pr = PullRequest::new("Fix it (#12)", "Closes #12\n\nFixes #13\n\nIssue: #12\n", None);
/// let issue = Issue::new(12, "OPEN", None);
/// let rules = |set| -> Vec<_> {
///     hygiene::check_pr_for(set, &pr, Some(&issue)).iter().map(|e| e.rule).collect()
/// };
/// assert_eq!(rules(Rules::All), ["keyword", "title", "milestone-trailer", "milestone", "milestone"]);
/// assert!(rules(Rules::Read).is_empty());
///
/// // What riff reads still holds.
/// let pr = PullRequest::new("Fix it", "Closes #12\n\nIssue: #9\n", None);
/// let found: Vec<_> = hygiene::check_pr_for(Rules::Read, &pr, None).iter().map(|e| e.rule).collect();
/// assert_eq!(found, ["issue-trailer"]);
/// ```
pub fn check_pr_for(rules: Rules, pr: &PullRequest, issue: Option<&Issue>) -> Vec<Error> {
    let mut errors = all_errors(pr, issue);
    errors.retain(|e| rules.applies(e.rule));
    errors
}

/// Each broken rule of a pull request, whatever the rules.
fn all_errors(pr: &PullRequest, issue: Option<&Issue>) -> Vec<Error> {
    let body = pr.body.replace("\r\n", "\n");
    let mut errors = Vec::new();

    let links: Vec<Link> = body.lines().filter_map(Link::parse).collect();
    let link = match links[..] {
        [] => {
            errors.push(Error::new(
                "link",
                "the body has no line `Closes #N` or `Refs #N`",
            ));
            None
        }
        [link] => Some(link),
        ref many => {
            errors.push(Error::new(
                "link",
                format!(
                    "the body has {} link lines; keep one: `Closes #N` in the last pull request of the issue, `Refs #N` in each other one",
                    many.len()
                ),
            ));
            None
        }
    };
    for keyword in stray_keywords(&body) {
        errors.push(Error::new(
            "keyword",
            format!("`{keyword}` closes an issue with no check; use the link line"),
        ));
    }
    if let Some(n) = title_number(&pr.title) {
        errors.push(Error::new(
            "title",
            format!("the title ends with `(#{n})`; GitHub adds the number of the pull request"),
        ));
    }

    // The other rules judge the trailers as the author wrote them. A line
    // that the merge wraps has its own error.
    let trailers = trailers(&pr.written_message());
    let named = issue_trailer(&trailers, &mut errors);
    if let (Some(named), Some(link)) = (named, link)
        && named != link.issue()
    {
        errors.push(Error::new(
            "issue-trailer",
            format!(
                "`Issue: #{named}` names another issue than the link line (#{})",
                link.issue()
            ),
        ));
    }
    let wave = milestone_trailer(&trailers, &mut errors);
    let pr_milestone = pr.milestone.as_ref().map(|m| m.title.as_str());
    if let (Some(wave), Some(own)) = (wave, pr_milestone)
        && !names_milestone(wave, own)
    {
        errors.push(Error::new(
            "milestone-trailer",
            format!("`Milestone: {wave}` is not the milestone of the pull request ({own})"),
        ));
    }

    for line in wrapped_trailer_lines(&body) {
        errors.push(Error::new(
            "trailer-wrap",
            format!(
                "the trailer line `{line}` has {} characters, and the merge wraps a line over {MERGE_WIDTH}: the wrapped part is no trailer line, and the block of trailers ends there; keep the line to {MERGE_WIDTH} characters",
                line.chars().count()
            ),
        ));
    }

    if pr_milestone.is_none() {
        errors.push(Error::new("milestone", "the pull request has no milestone"));
    }
    if let Some(issue) = issue {
        let n = issue.number;
        match (
            pr_milestone,
            issue.milestone.as_ref().map(|m| m.title.as_str()),
        ) {
            (_, None) => errors.push(Error::new(
                "milestone",
                format!("issue #{n} has no milestone"),
            )),
            (Some(own), Some(its)) if own != its => errors.push(Error::new(
                "milestone",
                format!("the pull request has milestone `{own}`, and issue #{n} has `{its}`"),
            )),
            _ => {}
        }
        if issue.state != "OPEN" {
            errors.push(Error::new("issue-open", format!("issue #{n} is closed")));
        }
    }
    errors
}

/// Checks the message of a commit on `main`. Returns each broken rule.
///
/// ```
/// let errors = hygiene::check_commit("Fix the tail (#48)\n\nIssue: #48\n");
/// let rules: Vec<_> = errors.iter().map(|e| e.rule).collect();
/// assert_eq!(rules, ["milestone-trailer", "commit-title"]);
/// ```
pub fn check_commit(message: &str) -> Vec<Error> {
    let message = message.replace("\r\n", "\n");
    let (title, body) = message.split_once('\n').unwrap_or((&message, ""));
    let mut errors = Vec::new();
    let trailers = trailers(body);
    let issue = issue_trailer(&trailers, &mut errors);
    milestone_trailer(&trailers, &mut errors);
    match title_number(title) {
        None => errors.push(Error::new(
            "commit-title",
            "the title does not end with `(#PR)`; GitHub adds it at the squash merge of a pull request",
        )),
        Some(n) if Some(n) == issue => errors.push(Error::new(
            "commit-title",
            format!("the title ends with issue #{n}, not with a pull request"),
        )),
        Some(_) => {}
    }
    errors
}

#[cfg(test)]
mod tests {
    use super::*;

    const GOOD: &str = "Closes #77\n\nPause the riff.\n\nIssue: #77\nMilestone: Wave 3\n";

    fn pr(body: &str, milestone: Option<&str>) -> PullRequest {
        PullRequest::new("Pause and resume the riff", body, milestone)
    }

    fn open(milestone: Option<&str>) -> Issue {
        Issue::new(77, "OPEN", milestone)
    }

    /// The rules of the errors of a pull request with an open issue 77.
    fn rules(pr: &PullRequest, issue: &Issue) -> Vec<&'static str> {
        check_pr(pr, Some(issue)).iter().map(|e| e.rule).collect()
    }

    #[test]
    fn a_good_pull_request_passes() {
        assert_eq!(
            check_pr(&pr(GOOD, Some("Wave 3")), Some(&open(Some("Wave 3")))),
            []
        );
        let refs = GOOD.replace("Closes #77", "Refs #77");
        assert_eq!(
            check_pr(&pr(&refs, Some("Wave 3")), Some(&open(Some("Wave 3")))),
            []
        );
    }

    #[test]
    fn a_body_from_the_web_with_crlf_passes() {
        let body = GOOD.replace('\n', "\r\n");
        assert_eq!(
            check_pr(&pr(&body, Some("Wave 3")), Some(&open(Some("Wave 3")))),
            []
        );
    }

    #[test]
    fn other_trailers_may_follow() {
        let body = format!("{GOOD}Claude-Session: https://claude.ai/code/session_x\n");
        assert!(rules(&pr(&body, Some("Wave 3")), &open(Some("Wave 3"))).is_empty());
    }

    #[test]
    fn no_link_line_fails() {
        let body = GOOD.replace("Closes #77\n\n", "");
        let errors = check_pr(&pr(&body, Some("Wave 3")), Some(&open(Some("Wave 3"))));
        assert_eq!(
            errors,
            [Error::new(
                "link",
                "the body has no line `Closes #N` or `Refs #N`"
            )]
        );
    }

    #[test]
    fn two_link_lines_fail() {
        let body = GOOD.replace("Closes #77\n", "Closes #77\nRefs #77\n");
        let errors = check_pr(&pr(&body, Some("Wave 3")), Some(&open(Some("Wave 3"))));
        assert_eq!(errors.len(), 1);
        assert_eq!(errors[0].rule, "link");
        assert!(
            errors[0].text.starts_with("the body has 2 link lines"),
            "{}",
            errors[0]
        );
    }

    #[test]
    fn another_closing_keyword_fails() {
        let body = GOOD.replace("Pause the riff.", "It also fixes #12.");
        let errors = check_pr(&pr(&body, Some("Wave 3")), Some(&open(Some("Wave 3"))));
        assert_eq!(
            errors,
            [Error::new(
                "keyword",
                "`fixes #12` closes an issue with no check; use the link line"
            )]
        );
    }

    #[test]
    fn a_title_with_a_number_fails() {
        let mut with_number = pr(GOOD, Some("Wave 3"));
        with_number.title = "Pause and resume the riff (#77)".into();
        assert_eq!(rules(&with_number, &open(Some("Wave 3"))), ["title"]);
    }

    #[test]
    fn no_issue_trailer_fails() {
        let body = GOOD.replace("Issue: #77\n", "");
        let errors = check_pr(&pr(&body, Some("Wave 3")), Some(&open(Some("Wave 3"))));
        assert_eq!(
            errors,
            [Error::new(
                "issue-trailer",
                "the message does not end with the trailer `Issue: #N`"
            )]
        );
    }

    #[test]
    fn an_issue_trailer_of_another_issue_fails() {
        let body = GOOD.replace("Issue: #77", "Issue: #78");
        let errors = check_pr(&pr(&body, Some("Wave 3")), Some(&open(Some("Wave 3"))));
        assert_eq!(
            errors,
            [Error::new(
                "issue-trailer",
                "`Issue: #78` names another issue than the link line (#77)"
            )]
        );
    }

    #[test]
    fn an_issue_trailer_that_is_not_a_number_fails() {
        let body = GOOD.replace("Issue: #77", "Issue: 77");
        assert_eq!(
            rules(&pr(&body, Some("Wave 3")), &open(Some("Wave 3"))),
            ["issue-trailer"]
        );
    }

    #[test]
    fn two_issue_trailers_fail() {
        let body = GOOD.replace("Issue: #77\n", "Issue: #77\nIssue: #77\n");
        assert_eq!(
            rules(&pr(&body, Some("Wave 3")), &open(Some("Wave 3"))),
            ["issue-trailer"]
        );
    }

    #[test]
    fn trailers_in_the_middle_do_not_count() {
        let body = format!("{GOOD}\nA last paragraph of text.\n");
        assert_eq!(
            rules(&pr(&body, Some("Wave 3")), &open(Some("Wave 3"))),
            ["issue-trailer", "milestone-trailer"]
        );
    }

    #[test]
    fn no_milestone_trailer_fails() {
        let body = GOOD.replace("Milestone: Wave 3\n", "");
        let errors = check_pr(&pr(&body, Some("Wave 3")), Some(&open(Some("Wave 3"))));
        assert_eq!(
            errors,
            [Error::new(
                "milestone-trailer",
                "the message does not end with the trailer `Milestone: M`"
            )]
        );
    }

    #[test]
    fn a_milestone_trailer_of_another_wave_fails() {
        let body = GOOD.replace("Wave 3", "Wave 4");
        let errors = check_pr(&pr(&body, Some("Wave 3")), Some(&open(Some("Wave 3"))));
        assert_eq!(
            errors,
            [Error::new(
                "milestone-trailer",
                "`Milestone: Wave 4` is not the milestone of the pull request (Wave 3)"
            )]
        );
    }

    /// 01M518A04JWYJE5FA1VR309SAA: the lead renamed `Wave 28: after
    /// 1.4.0` while a pull request had its old title in the trailer.
    #[test]
    fn a_trailer_of_the_old_title_passes_after_a_rename_of_the_wave() {
        let renamed = Some("Wave 28: cloud, fixes that slow the work");
        let body = GOOD.replace("Wave 3", "Wave 28: after 1.4.0");
        assert_eq!(check_pr(&pr(&body, renamed), Some(&open(renamed))), []);
        let number = GOOD.replace("Wave 3", "Wave 28");
        assert_eq!(check_pr(&pr(&number, renamed), Some(&open(renamed))), []);

        let other = GOOD.replace("Wave 3", "Wave 27: after 1.4.0");
        assert_eq!(
            check_pr(&pr(&other, renamed), Some(&open(renamed))),
            [Error::new(
                "milestone-trailer",
                "`Milestone: Wave 27: after 1.4.0` is not the milestone of the pull request \
                 (Wave 28: cloud, fixes that slow the work)"
            )]
        );
    }

    #[test]
    fn a_milestone_that_is_not_a_wave_needs_its_whole_title() {
        let body = GOOD.replace("Wave 3", "Backlog");
        assert!(check_pr(&pr(&body, Some("Backlog")), Some(&open(Some("Backlog")))).is_empty());
        let body = GOOD.replace("Wave 3", "Backlog 2");
        assert_eq!(
            rules(&pr(&body, Some("Backlog")), &open(Some("Backlog"))),
            ["milestone-trailer"]
        );
    }

    #[test]
    fn a_wave_title_has_a_number_and_an_optional_name() {
        for (title, number) in [
            ("Wave 1", Some(1)),
            ("Wave 27: 3.0 Wave A, local sessions", Some(27)),
            ("Wave 007", Some(7)),
            ("Wave", None),
            ("Wave ", None),
            ("wave 3", None),
            ("Wave 3 ", None),
            ("Wave 3:x", None),
            ("Wave 3:  ", None),
            ("Wave 99999999999999999999999", None),
            ("Backlog", None),
        ] {
            assert_eq!(wave_number(title), number, "{title}");
        }
    }

    #[test]
    fn a_milestone_of_the_pull_request_that_differs_from_the_issue_fails() {
        let errors = check_pr(&pr(GOOD, Some("Wave 3")), Some(&open(Some("Wave 4"))));
        assert_eq!(
            errors,
            [Error::new(
                "milestone",
                "the pull request has milestone `Wave 3`, and issue #77 has `Wave 4`"
            )]
        );
    }

    #[test]
    fn no_milestone_fails() {
        assert_eq!(rules(&pr(GOOD, None), &open(Some("Wave 3"))), ["milestone"]);
        assert_eq!(rules(&pr(GOOD, Some("Wave 3")), &open(None)), ["milestone"]);
    }

    #[test]
    fn a_closed_issue_fails() {
        let closed = Issue::new(77, "CLOSED", Some("Wave 3"));
        let errors = check_pr(&pr(GOOD, Some("Wave 3")), Some(&closed));
        assert_eq!(errors, [Error::new("issue-open", "issue #77 is closed")]);
    }

    #[test]
    fn with_no_issue_only_the_form_is_checked() {
        let errors = check_pr(&pr("Text only.", None), None);
        let rules: Vec<_> = errors.iter().map(|e| e.rule).collect();
        assert_eq!(
            rules,
            ["link", "issue-trailer", "milestone-trailer", "milestone"]
        );
    }

    #[test]
    fn a_good_commit_passes() {
        let message = format!("Pause and resume the riff (#90)\n\n{GOOD}");
        assert_eq!(check_commit(&message), []);
    }

    #[test]
    fn a_commit_with_no_number_or_trailers_fails() {
        let errors = check_commit("Pause and resume the riff\n\nText.\n");
        let rules: Vec<_> = errors.iter().map(|e| e.rule).collect();
        assert_eq!(
            rules,
            ["issue-trailer", "milestone-trailer", "commit-title"]
        );
    }

    #[test]
    fn a_commit_of_the_old_flow_fails() {
        let errors =
            check_commit("Pause and resume the riff (#77)\n\nIssue: #77\nMilestone: Wave 3\n");
        assert_eq!(
            errors,
            [Error::new(
                "commit-title",
                "the title ends with issue #77, not with a pull request"
            )]
        );
    }

    #[test]
    fn a_commit_with_only_a_title_has_no_trailers() {
        let rules: Vec<_> = check_commit("docs: fix a word (#90)")
            .iter()
            .map(|e| e.rule)
            .collect();
        assert_eq!(rules, ["issue-trailer", "milestone-trailer"]);
    }

    /// A squash message of a pull request with a co-author: the trailers
    /// with a line `Generated-by:`, then the paragraph `Co-authored-by:`
    /// that GitHub adds.
    const SQUASH: &str = "Make the link test count (#1348)\n\nCloses #692\n\nText.\n\n\
        Issue: #692\nMilestone: Wave 41\nGenerated-by: GLM-5.3-Flash\n\n\
        Co-authored-by: GLM-5.3-Flash <noreply@z.ai>\n";

    #[test]
    fn a_commit_with_a_co_author_after_the_trailers_passes() {
        for message in [
            // The lines of one block.
            "T (#9)\n\nIssue: #7\nMilestone: Wave 3\nCo-authored-by: A <a@b.c>\n",
            // GitHub adds a blank line before its lines.
            "T (#9)\n\nIssue: #7\nMilestone: Wave 3\n\nCo-authored-by: A <a@b.c>\n",
            // Other trailers stand before and after.
            "T (#9)\n\nSigned-off-by: A <a@b.c>\nIssue: #7\nMilestone: Wave 3\nGenerated-by: X\n",
            SQUASH,
        ] {
            assert_eq!(check_commit(message), [], "{message}");
        }
    }

    #[test]
    fn a_commit_with_the_trailers_before_the_last_block_fails() {
        for message in [
            // A paragraph of text after the trailers.
            "T (#9)\n\nIssue: #7\nMilestone: Wave 3\n\nText.\n",
            // A paragraph of text between the trailers and the co-author.
            "T (#9)\n\nIssue: #7\nMilestone: Wave 3\n\nText.\n\nCo-authored-by: A <a@b.c>\n",
            // A line of text in the paragraph of the trailers.
            "T (#9)\n\nIssue: #7\nMilestone: Wave 3\nmore text\n\nCo-authored-by: A <a@b.c>\n",
        ] {
            let rules: Vec<_> = check_commit(message).iter().map(|e| e.rule).collect();
            assert_eq!(rules, ["issue-trailer", "milestone-trailer"], "{message}");
        }
    }

    /// The body of the outside pull request #1348 in short, as its author wrote it:
    /// the trailer `Generated-by:` is on one line of 78 characters.
    const BODY_1348: &str = "Closes #692\n\n\
        The count check accepts `tries` or `tries + 1` accepts. The call still ends after its budget, with the text `no_reply`, after at least 2 tries, each on a new connection. Nothing else changed.\n\n\
        Issue: #692\nMilestone: Wave 41\n\
        Generated-by: GLM-5.3-Flash (brief, implementation, task review, final review)\n";

    /// The commit that the merge made from the whole body (c60887ef).
    const COMMIT_1348: &str = "The link test counts an accepted connection with no read (#1348)\n\n\
        Closes #692\n\n\
        The count check accepts `tries` or `tries + 1` accepts. The call still\n\
        ends after its budget, with the text `no_reply`, after at least 2 tries,\n\
        each on a new connection. Nothing else changed.\n\n\
        Issue: #692\nMilestone: Wave 41\n\
        Generated-by: GLM-5.3-Flash (brief, implementation, task review, final\nreview)\n\n\
        Co-authored-by: GLM-5.3-Flash <noreply@z.ai>\n";

    #[test]
    fn the_merge_wraps_a_long_line_as_it_did_for_the_commit_1348() {
        let pr = PullRequest::new(
            "The link test counts an accepted connection with no read",
            BODY_1348,
            Some("Wave 41"),
        )
        .with_commit_by(person("GLM-5.3-Flash", "noreply@z.ai"));
        let title_and_body = format!("{} (#1348)\n\n{}", pr.title, pr.squash_message());
        assert_eq!(title_and_body, COMMIT_1348);
    }

    #[test]
    fn the_commit_1348_fails_the_commit_rule() {
        let rules: Vec<_> = check_commit(COMMIT_1348).iter().map(|e| e.rule).collect();
        assert_eq!(rules, ["issue-trailer", "milestone-trailer"]);
    }

    #[test]
    fn the_pull_request_1348_fails_with_the_reason_before_the_merge() {
        let pr = PullRequest::new(
            "The link test counts an accepted connection with no read",
            BODY_1348,
            Some("Wave 41"),
        )
        .with_commit_by(person("GLM-5.3-Flash", "noreply@z.ai"));
        let issue = Issue::new(692, "OPEN", Some("Wave 41"));
        let errors = check_pr(&pr, Some(&issue));
        let rules: Vec<_> = errors.iter().map(|e| e.rule).collect();
        assert_eq!(rules, ["trailer-wrap"], "{errors:?}");
        let text = errors[0].to_string();
        assert!(
            text.contains("Generated-by: GLM-5.3-Flash (brief"),
            "{text}"
        );
        assert!(text.contains("78 characters"), "{text}");
        assert!(text.contains("keep the line to 72 characters"), "{text}");
    }

    #[test]
    fn a_trailer_line_of_the_width_passes_and_one_character_more_fails() {
        let value = |n: usize| "x".repeat(n - "Generated-by: ".len());
        for (length, rules_found) in [
            (MERGE_WIDTH, vec![]),
            (MERGE_WIDTH + 1, vec!["trailer-wrap"]),
        ] {
            let body = format!("{GOOD}Generated-by: {}\n", value(length));
            assert_eq!(
                rules(&pr(&body, Some("Wave 3")), &open(Some("Wave 3"))),
                rules_found,
                "{length}"
            );
        }
    }

    #[test]
    fn each_long_trailer_line_has_an_error() {
        let long = "word ".repeat(15);
        let body = format!("{GOOD}Generated-by: {long}\nSigned-off-by: {long}\n");
        assert_eq!(
            rules(&pr(&body, Some("Wave 3")), &open(Some("Wave 3"))),
            ["trailer-wrap", "trailer-wrap"]
        );
    }

    #[test]
    fn a_long_line_of_text_is_no_error() {
        let text = format!(
            "Closes #77\n\n{}\n\nIssue: #77\nMilestone: Wave 3\n",
            "word ".repeat(30)
        );
        assert_eq!(
            check_pr(&pr(&text, Some("Wave 3")), Some(&open(Some("Wave 3")))),
            []
        );
    }

    #[test]
    fn the_merge_leaves_a_line_of_the_width_and_the_lines_after_it() {
        assert_eq!(merge_wrap(GOOD), GOOD);
        let kept = format!("{}\n  indent  two\n", "word ".repeat(14) + "wo");
        assert_eq!(merge_wrap(&kept), kept);
    }

    #[test]
    fn the_merge_fills_a_long_line_again_with_whole_words() {
        let line = format!("  {}", "word ".repeat(30));
        let wrapped = merge_wrap(&line);
        assert!(wrapped.lines().count() > 1);
        for wrapped_line in wrapped.lines() {
            assert!(
                wrapped_line.chars().count() <= MERGE_WIDTH,
                "{wrapped_line}"
            );
            assert!(wrapped_line.starts_with("word") && wrapped_line.ends_with("word"));
        }
        assert_eq!(wrapped.split_whitespace().count(), 30);
        // A word over the width stays whole on its line.
        let url = "u".repeat(80);
        assert_eq!(
            merge_wrap(&format!("see {url} here")),
            format!("see\n{url}\nhere")
        );
    }

    #[test]
    fn the_trailers_of_a_block_of_two_paragraphs_keep_their_order() {
        let found =
            trailers("Text.\n\nIssue: #7\nMilestone: Wave 3\n\nCo-authored-by: A <a@b.c>\n");
        let keys: Vec<_> = found.iter().map(|(k, _)| k.as_str()).collect();
        assert_eq!(keys, ["Issue", "Milestone", "Co-authored-by"]);
    }

    #[test]
    fn a_message_of_one_paragraph_of_text_has_no_trailer() {
        assert!(trailers("").is_empty());
        assert!(trailers("Text.\n").is_empty());
        assert!(trailers("Text.\n\nMore.\n").is_empty());
    }

    fn person(name: &str, email: &str) -> Person {
        Person {
            name: name.to_owned(),
            email: email.to_owned(),
            ..Person::default()
        }
    }

    fn glm() -> Person {
        person("GLM-5.3-Flash", "noreply@z.ai")
    }

    #[test]
    fn a_pull_request_with_a_co_author_passes() {
        let pr = pr(GOOD, Some("Wave 3")).with_commit_by(glm());
        assert_eq!(
            pr.co_authors(),
            ["Co-authored-by: GLM-5.3-Flash <noreply@z.ai>"]
        );
        assert_eq!(check_pr(&pr, Some(&open(Some("Wave 3")))), []);
    }

    #[test]
    fn a_pull_request_with_a_body_that_ends_with_text_fails_also_with_a_co_author() {
        let body = format!("{GOOD}\nA last paragraph of text.\n");
        let pr = pr(&body, Some("Wave 3")).with_commit_by(glm());
        assert_eq!(
            rules(&pr, &open(Some("Wave 3"))),
            ["issue-trailer", "milestone-trailer"]
        );
    }

    #[test]
    fn the_author_of_the_pull_request_is_no_co_author() {
        let ana = Person {
            login: "ana".to_owned(),
            ..person("Ana", "ana@example.com")
        };
        let pr = pr(GOOD, Some("Wave 3"))
            .by(ana.clone())
            .with_commit_by(ana)
            .with_commit_by(glm())
            .with_commit_by(glm());
        assert_eq!(pr.co_authors().len(), 1);
        assert_eq!(
            pr.squash_message(),
            format!("{GOOD}\nCo-authored-by: GLM-5.3-Flash <noreply@z.ai>\n")
        );
    }

    #[test]
    fn a_pull_request_with_no_co_author_has_its_body_as_message() {
        assert_eq!(pr(GOOD, None).squash_message(), GOOD);
        let web = GOOD.replace('\n', "\r\n");
        assert_eq!(pr(&web, None).squash_message(), GOOD);
    }

    #[test]
    fn gh_json_of_a_pull_request_with_commits_has_its_co_author() {
        let json = r#"{
            "title": "T", "body": "Closes #1\n\nIssue: #1\nMilestone: Wave 3",
            "milestone": {"title": "Wave 3"},
            "author": {"id": "x", "is_bot": false, "login": "ana", "name": "Ana"},
            "commits": [
                {"oid": "a", "authors": [{"email": "ana@example.com", "id": "x", "login": "ana", "name": "Ana"}]},
                {"oid": "b", "authors": [
                    {"email": "ana@example.com", "id": "x", "login": "ana", "name": "Ana"},
                    {"email": "noreply@z.ai", "id": "", "login": "", "name": "GLM-5.3-Flash"}
                ]}
            ]
        }"#;
        let pr: PullRequest = serde_json::from_str(json).unwrap();
        assert_eq!(
            pr.co_authors(),
            ["Co-authored-by: GLM-5.3-Flash <noreply@z.ai>"]
        );
        assert_eq!(check_pr(&pr, Some(&open(Some("Wave 3")))), []);
    }

    #[test]
    fn the_rules_that_riff_reads_pass_a_pull_request_of_another_habit() {
        let plain = PullRequest::new(
            "Fix it (#77)",
            "Closes #77\n\nFixes #78.\n\nIssue: #77\n",
            None,
        );
        let issue = Issue::new(77, "CLOSED", None);
        assert_eq!(check_pr_for(Rules::Read, &plain, Some(&issue)), []);
        assert!(!check_pr_for(Rules::All, &plain, Some(&issue)).is_empty());
    }

    #[test]
    fn the_rules_that_riff_reads_find_a_missing_link_and_a_wrong_issue_line() {
        let rules = |body: &str| -> Vec<&'static str> {
            check_pr_for(Rules::Read, &pr(body, None), None)
                .iter()
                .map(|e| e.rule)
                .collect()
        };
        assert_eq!(rules("Text.\n\nIssue: #77\n"), ["link"]);
        assert_eq!(rules("Closes #77\n\nText.\n"), ["issue-trailer"]);
        assert_eq!(rules("Closes #77\n\nIssue: #9\n"), ["issue-trailer"]);
        assert!(rules("Refs #77\n\nIssue: #77\n").is_empty());
    }
}