Enum Severity 

pub enum Severity {
    Blocking,
    NonBlocking,
    Nit,
}

Only Blocking gates a merge. This is the whole defence against the nitpick spiral: a competent reviewer can always find something, so “no objections remaining” is not a stopping condition but “no blocking objections” is.

Variants

Blocking

NonBlocking

Nit

Implementations

impl Severity

pub fn as_str(self) -> &'static str

pub fn parse_lenient(text: &str) -> Option<Self>

Accept the canonical spelling, any listed alias, and any difference in case, spacing, hyphens, or underscores.

Examples found in repository

examples/preview.rs (line 26)

fn finding(severity: &str, title: &str, detail: &str, file: &str, in_scope: bool) -> Finding {
    Finding {
        severity: Severity::parse_lenient(severity).expect("severity"),
        title: title.into(),
        detail: detail.into(),
        file: file.into(),
        in_scope,
        ..Default::default()
    }
}

fn rule(label: &str) {
    println!("\n\x1b[1m{label}\x1b[0m\n{}", "-".repeat(72));
}

fn main() {
    let loose = std::env::args().any(|a| a == "--loose");
    let style = if loose {
        Style {
            terse: false,
            ..Style::default()
        }
    } else {
        Style::default()
    };
    if loose {
        println!("(concision gate OFF: this is what a model would post unedited)");
    }

    rule("A clean review");
    println!(
        "{}",
        review_comment(
            "codex",
            1,
            &Review {
                verdict: Verdict::Approve,
                next_action: NextAction::Merge,
                summary: "I reviewed the changes on this branch carefully and I am happy to \
                          report that the retry path is correct, the backoff calculation is \
                          sound, and the new test covers the 429 case that the issue described. \
                          I have no objections to this change landing as it stands."
                    .into(),
                findings: vec![],
            },
            &style
        )
    );

    rule("A review with real work in it");
    println!(
        "{}",
        review_comment(
            "codex",
            2,
            &Review {
                verdict: Verdict::ChangesRequested,
                next_action: NextAction::HandBack,
                summary: "There is one genuine defect here that should block, along with a \
                          couple of improvements that I do not think need to gate this \
                          particular pull request, and one pre-existing problem I noticed \
                          while reading the surrounding code."
                    .into(),
                findings: vec![
                    finding(
                        "blocking",
                        "Retry loop never terminates when max_attempts is unset",
                        "I confirmed this by running the 429 test with max_attempts left at its \
                         default of None: the loop spins forever because the guard on line 91 \
                         compares against Some(0) rather than checking for None first. This is \
                         not a theoretical concern, the test hangs and I had to kill it.",
                        "src/net.rs:88",
                        true,
                    ),
                    finding(
                        "non-blocking",
                        "The request timeout is hard coded to thirty seconds",
                        "It would be better if this were configurable, since a slow upstream \
                         will now fail rather than wait, but the previous code had the same \
                         limitation so this is not a regression introduced by the change.",
                        "src/net.rs:44",
                        true,
                    ),
                    finding(
                        "nit",
                        "Log line says \"retrying\" without saying how many attempts remain",
                        "Purely a readability point for whoever is reading the logs at 3am.",
                        "src/net.rs:102",
                        true,
                    ),
                    finding(
                        "blocking",
                        "Config loader swallows a parse error",
                        "Unrelated to this PR, but load_config discards the error from serde and \
                         returns Default::default(), so a typo in the config file is silently \
                         ignored.",
                        "src/config.rs:210",
                        false,
                    ),
                ],
            },
            &style
        )
    );

    rule("Answering that review");
    println!(
        "{}",
        disposition_comment(
            "claude",
            &ResponseDoc {
                summary: "One of the two blocking points was right and I have fixed it. I do not \
                          agree with the other and have explained why below rather than changing \
                          working code to make the review go away."
                    .into(),
                dispositions: vec![],
            },
            &["Retry loop never terminates when max_attempts is unset".to_string()],
            &[
                "Config loader swallows a parse error. The caller already validates the file \
               against the schema before load_config is reached, so the discarded error is \
               unreachable in practice."
                    .to_string()
            ],
            &["https://github.com/you/thing/issues/512".to_string()],
            &style
        )
        .unwrap_or_default()
    );

    rule("The pull request body");
    println!(
        "{}",
        pr_body(
            478,
            &Implementation {
                summary: "Retry a 429 with exponential backoff instead of failing the request."
                    .into(),
                problem: "A rate limited response was treated as fatal, so a single throttled \
                          call ended a run that had hours of work left in it. The retry path \
                          existed but only covered connection errors, and nothing in the logs \
                          said which of the two had happened."
                    .into(),
                changes: vec![
                    "`send` now retries a 429, honouring `Retry-After` when the server sets it \
                     and backing off exponentially when it does not"
                        .into(),
                    "the retry budget is bounded at five attempts, so a permanent 429 still \
                     ends the call rather than spinning"
                        .into(),
                    "a retry logs the status it is retrying, which is what made the original \
                     failure impossible to tell apart from a dropped connection"
                        .into(),
                ],
                testing: vec![
                    "`cargo test retries_a_rate_limited_request`, which fakes a 429 with a \
                     `Retry-After` of 2 and asserts the wait"
                        .into(),
                    "point it at a throttled endpoint and watch a run finish rather than stop \
                     on the first 429"
                        .into(),
                ],
                notes: Some(
                    "Streaming calls do not go through `send` and are unchanged, which is worth \
                     a follow-up but not this one."
                        .into()
                ),
                ..Implementation::default()
            },
            Some("cargo test"),
            &style
        )
    );

    rule("What a whole run leaves on the PR (the default, one comment)");
    let mut ended = IssueRun::new(482, "t");
    ended.disputes = vec![Dispute {
        title: "Config loader swallows a parse error".into(),
        file: "src/config.rs".into(),
        reasoning: "the caller validates against the schema before load_config is reached".into(),
    }];
    ended.filed = vec![
        "https://github.com/you/thing/issues/485".into(),
        "https://github.com/you/thing/issues/486".into(),
    ];
    println!(
        "{}",
        outcome_comment(
            &ended,
            &spar::model::Ledger::new(),
            &Ending::OutOfRounds,
            &style
        )
        .unwrap_or_default()
    );
    println!("\n  (and a clean run that filed nothing posts no comment at all)");

    rule("What a run leaves when the closing pass did not sign it off");
    let mut left = IssueRun::new(482, "t");
    left.noted = vec![finding(
        "non-blocking",
        "Timeout is not configurable",
        "The retry budget is fixed at three.",
        "src/net.rs",
        true,
    )];
    let unresolved = vec![finding(
        "blocking",
        "The retry fix never reaches the 429 path",
        "The guard added in round 2 sits after the early return on line 88, so a rate limited \
         response still takes the old path. Reproduced with the 429 test.",
        "src/net.rs:88",
        true,
    )];
    println!(
        "{}",
        outcome_comment(
            &left,
            &spar::model::Ledger::new(),
            &Ending::Unresolved(&unresolved),
            &style
        )
        .unwrap_or_default()
    );

    rule("A review of somebody else's pull request (spar review)");
    let judged = |standing, severity, title: &str, detail: &str, file: &str, by: &str| Judged {
        finding: finding(severity, title, detail, file, true),
        raised_by: by.to_string(),
        standing,
        counterpoint: None,
        defence: None,
        rated: None,
    };
    let mut disputed = judged(
        FindingStanding::Disputed,
        "blocking",
        "Config loader swallows a parse error",
        "load_config discards the error from serde and returns a default.",
        "src/config.rs:210",
        "claude",
    );
    disputed.counterpoint =
        Some("the caller validates against the schema before load_config is reached".into());
    println!(
        "{}",
        verdict_comment(
            &[
                judged(
                    FindingStanding::Corroborated,
                    "blocking",
                    "Retry loop never terminates when max_attempts is unset",
                    "Both reviewers reproduced this: the guard on line 91 compares against \
                     Some(0) rather than checking for None, so the 429 test hangs.",
                    "src/net.rs:88",
                    "claude and codex",
                ),
                judged(
                    FindingStanding::Confirmed,
                    "non-blocking",
                    "The request timeout is hard coded",
                    "Not a regression, the previous code had the same limitation.",
                    "src/net.rs:44",
                    "codex",
                ),
                judged(
                    FindingStanding::Unverified,
                    "nit",
                    "Log line does not say how many attempts remain",
                    "Readability for whoever reads the logs at 3am.",
                    "src/net.rs:102",
                    "claude",
                ),
                disputed,
                judged(
                    FindingStanding::Withdrawn,
                    "blocking",
                    "Off by one in the backoff",
                    "Withdrawn after the other reviewer pointed at the test that covers it.",
                    "src/net.rs:70",
                    "codex",
                ),
            ],
            &style
        )
    );

    rule("A second look at that pull request, after the author pushed (spar review --recheck)");
    let recorded = |severity: &str, title: &str, detail: &str, file: &str, standing| {
        spar::model::RecordedFinding {
            title: title.into(),
            file: file.into(),
            severity: Severity::parse_lenient(severity).expect("severity"),
            detail: detail.into(),
            in_scope: true,
            raised_by: "claude and codex".into(),
            standing,
            counterpoint: None,
            defence: None,
        }
    };
    println!(
        "{}",
        recheck_comment(
            &Delta {
                from: "0123abcdef".into(),
                commits: vec![
                    "a1b2c3d check for None before comparing attempts".into(),
                    "e4f5a6b make the request timeout configurable".into(),
                ],
                rewritten: false,
            },
            &[
                Rechecked {
                    recorded: recorded(
                        "blocking",
                        "Retry loop never terminates when max_attempts is unset",
                        "The guard on line 91 compares against Some(0) rather than checking for None.",
                        "src/net.rs:88",
                        FindingStanding::Corroborated,
                    ),
                    resolution: Resolution::Fixed(
                        "src/net.rs:91 now matches on None first, and the 429 test that used to \
                         hang passes in 0.3s when run with cargo test retry"
                            .into(),
                    ),
                },
                Rechecked {
                    recorded: recorded(
                        "non-blocking",
                        "The request timeout is hard coded",
                        "Not a regression, the previous code had the same limitation.",
                        "src/net.rs:44",
                        FindingStanding::Confirmed,
                    ),
                    resolution: Resolution::Rebutted(
                        "the author's reply is right that the timeout comes from the caller's \
                         Client builder since e4f5a6b, so there is nothing left to make configurable \
                         here"
                            .into(),
                    ),
                },
                Rechecked {
                    recorded: recorded(
                        "blocking",
                        "Config loader swallows a parse error",
                        "load_config discards the error from serde and returns a default.",
                        "src/config.rs:210",
                        FindingStanding::Confirmed,
                    ),
                    resolution: Resolution::Open(
                        "codex still sees it: load_config still returns Default on a parse error, \
                         and nothing upstream validates the file first"
                            .into(),
                    ),
                },
            ],
            &[judged(
                FindingStanding::Corroborated,
                "non-blocking",
                "The new None branch logs at error level on every retry",
                "Each retry now writes an error line, so a flaky upstream fills the log with \
                 errors for a request that succeeds on the third try.",
                "src/net.rs:93",
                "claude and codex",
            )],
            &style,
            2
        )
    );

    rule("An issue both reviewers declined");
    println!(
        "{}",
        skip_comment(
            &SkippedItem {
                issue: 91,
                title: "Add a dark mode".into(),
                tracker: false,
                reasons: [
                    (
                        "claude".to_string(),
                        "This was already implemented in 1.4 and shipped behind the theme \
                         setting, so there is nothing left to do here."
                            .to_string()
                    ),
                    (
                        "codex".to_string(),
                        "Duplicate of #62, which is still open and has the full discussion."
                            .to_string()
                    ),
                ]
                .into_iter()
                .collect(),
            },
            &style
        )
    );
    rule("Answering a comment in its own thread");
    for item in [
        settled(
            Ask::Implement,
            "alice",
            "src/retry.rs:91",
            "Added the guard on the retry path and a test that reproduces the original failure.",
            "",
            true,
        ),
        settled(
            Ask::Decline,
            "bob",
            "src/pool.rs:14",
            "",
            "Every caller of this function already holds the pool lock, so the check on line 14 \
             cannot be reached with a null connection. I ran the suite with an assertion in its \
             place and nothing tripped it.",
            false,
        ),
        settled(
            Ask::Defer,
            "carol",
            "src/electrum.rs:203",
            "",
            "This is real and it predates the branch: the reconnect monitor puts a stopped wallet \
             back into the header router. It is not caused by anything here, so fixing it in this \
             pull request would put an unrelated change in front of whoever reviews it.",
            false,
        ),
    ] {
        println!("{}\n", thread_reply(&item, &style));
    }

    rule("What a check-in leaves on the pull request");
    let mut fixed = settled(
        Ask::Implement,
        "alice",
        "the pull request",
        "Retried the 429 with the backoff the issue asked for.",
        "",
        true,
    );
    fixed.pending.file = None;
    let mut parked = settled(
        Ask::Decline,
        "dave",
        "the pull request",
        "",
        "The two reviewers read the same code and did not agree about whether the guard is \
         reachable.",
        false,
    );
    parked.pending.file = None;
    parked.parked = true;
    println!(
        "{}",
        checkin_comment(&[fixed, parked], &style)
            .unwrap_or_else(|| "(nothing to say, so no comment is posted)".into())
    );
    println!("\n  (and a check-in with nothing outstanding posts no comment at all)");

    rule("An idea filed from a brainstorm");
    let idea = Candidate {
        id: 1,
        idea: Idea {
            title: "Batch settlement with hash timelocks".into(),
            combines: vec![
                "hash time locked contracts".into(),
                "batch auctions".into(),
                "the OP_CHECKSEQUENCEVERIFY delay".into(),
            ],
            how_it_works: "Each trade posts a hash timelock, and one batch auction clears every \
                           one of them at the deadline together, so the batch is the settlement."
                .into(),
            why_new: "The nearest thing is a plain escrow, which settles one trade at a time \
                      and cannot net them against each other."
                .into(),
            enables: "Settling many trades in one transaction.".into(),
            risks: "A fee spike at the deadline makes the batch uneconomic.".into(),
            first_experiment: "Simulate ten trades on regtest and count the bytes.".into(),
        },
        proposers: vec!["claude".into()],
        parent: None,
        objection: Some((
            "codex".into(),
            "Coinjoin coordinators already batch settlement.".into(),
        )),
        defence: Some(
            "A coordinator batches inputs, not conditional trades; nothing there clears a hash \
             lock."
                .into(),
        ),
        standing: Standing::Defended,
        rank_sum: 3,
    };
    println!("{}", issue_body(&idea, &style));
    println!("\n  (who proposed and who objected stays in the session file, never in the issue)");

    println!();
}

pub fn valid_values() -> String

impl Severity

pub fn rank(self) -> u8

How badly it matters, independent of the order the variants happen to be declared in. Relying on derived Ord here would silently invert the moment somebody reorders the enum.

pub fn graver(self, other: Self) -> Self

The graver of two judgements.

Two reviewers disagreeing about severity is resolved upward on purpose: advice that under-reports a real defect is worse than advice that over-reports a small one.

Trait Implementations

impl Clone for Severity

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Severity

impl Debug for Severity

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Severity

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Severity

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Severity

impl Hash for Severity

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Severity

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Severity

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for Severity

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Severity

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Severity