Struct Report 

pub struct Report {
    pub case_name: String,
    pub severity: Severity,
    pub primary: Option<Diagnosis>,
    pub also_considered: Vec<Diagnosis>,
    pub reproduction: String,
}

Top-level result of crate::rules::diagnose.

primary is None when no rule fired with confidence ≥ 0.6 (the classification threshold). also_considered is sorted by descending confidence and capped above by the primary’s confidence.

Fields

case_name: String

Stable name of the case being diagnosed (matches Case::name).

severity: Severity

Severity tag from the case (mirrored verbatim).

primary: Option<Diagnosis>

Top-confidence diagnosis, if any rule fired above threshold.

also_considered: Vec<Diagnosis>

Other rules that fired, sorted by descending confidence and bounded above by primary.confidence. Empty when only one rule fired (or none did).

reproduction: String

Pre-rendered curl reproduction string. Header order is alphabetical; the body is inlined with --data-raw so the string is the same on every machine (no absolute paths).

Implementations

impl Report

pub fn exit_code(&self) -> i32

Process exit code the CLI should return for this report.

0 if a primary diagnosis fired with confidence ≥ 0.60, 1 if the case is unclassified or low-confidence. The threshold matches the human formatter’s “No rule matched” message. Higher-level “bad input” errors are mapped to exit code 2 by the CLI itself, not here.

Examples

use api_debug_lab::{diagnose, Case};
use std::path::Path;

let case = Case::load("auth_missing", Path::new("fixtures"))?;
assert_eq!(diagnose(&case).exit_code(), 0);

pub fn render(&self, format: Format) -> String

Render the report in the requested Format.

Both formats are byte-stable: the same input always produces the same output bytes. The JSON format uses pretty-printing so diffs in PRs are legible.

Examples

use api_debug_lab::{diagnose, Case, Format};
use std::path::Path;

let case = Case::load("auth_missing", Path::new("fixtures"))?;
let report = diagnose(&case);
let human = report.render(Format::Human);
assert!(human.starts_with("CASE:"));

Trait Implementations

impl Clone for Report

fn clone(&self) -> Report

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Report

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Report

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Report

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Report

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Report