use core::fmt;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BloatJson {
#[serde(rename = "file-size")]
pub file_size: u64,
#[serde(rename = "text-section-size")]
pub text_section_size: u64,
pub functions: Vec<Function>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Function {
#[serde(rename = "crate", skip_serializing_if = "Option::is_none")]
pub krate: Option<String>,
pub name: String,
pub size: u64,
}
#[derive(Debug)]
pub enum ParseError {
Syntax(serde_json::Error),
Schema(serde_json::Error),
CratesMode,
NotAnObject,
}
impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ParseError::Syntax(err) => {
write!(f, "input is not valid JSON: {err}")
}
ParseError::Schema(err) => write!(
f,
"input is not `cargo bloat` JSON output: {err}\n\
help: generate it with `cargo bloat --message-format=json -n 0`"
),
ParseError::CratesMode => write!(
f,
"this is `cargo bloat --crates` output (has `crates`, expected `functions`)\n\
help: drop `--crates` - bloat-show builds its own per-crate view from function data"
),
ParseError::NotAnObject => write!(
f,
"expected a JSON object at the top level\n\
help: generate it with `cargo bloat --message-format=json -n 0`"
),
}
}
}
impl core::error::Error for ParseError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
ParseError::Syntax(err) | ParseError::Schema(err) => Some(err),
ParseError::CratesMode | ParseError::NotAnObject => None,
}
}
}
impl BloatJson {
pub fn from_json_str(json: &str) -> Result<Self, ParseError> {
match serde_json::from_str(json) {
Ok(data) => Ok(data),
Err(err) => Err(classify(json, err)),
}
}
pub fn from_rendered_html(html: &str) -> Option<&str> {
const OPEN: &str = "<script id=\"bloat-data\" type=\"application/json\">";
const CLOSE: &str = "</script>";
let start = html.find(OPEN)? + OPEN.len();
let len = html[start..].find(CLOSE)?;
Some(html[start..start + len].trim())
}
pub fn crate_count(&self) -> usize {
let mut names: Vec<&str> = self.functions.iter().map(Function::crate_name).collect();
names.sort_unstable();
names.dedup();
names.len()
}
}
fn classify(json: &str, err: serde_json::Error) -> ParseError {
let Ok(value) = serde_json::from_str::<serde_json::Value>(json) else {
return ParseError::Syntax(err);
};
let serde_json::Value::Object(obj) = value else {
return ParseError::NotAnObject;
};
match !obj.contains_key("functions") && obj.contains_key("crates") {
true => ParseError::CratesMode,
false => ParseError::Schema(err),
}
}
impl Function {
pub fn crate_name(&self) -> &str {
match self.krate.as_deref() {
None => "[unknown]",
Some(name) => name.strip_suffix('?').unwrap_or(name),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_minimal_document() {
let json = r#"{
"file-size": 100,
"text-section-size": 60,
"functions": [{ "crate": "wasmi", "name": "wasmi::run", "size": 40 }]
}"#;
let data = BloatJson::from_json_str(json).unwrap();
assert_eq!(data.file_size, 100);
assert_eq!(data.text_section_size, 60);
assert_eq!(data.functions.len(), 1);
assert_eq!(data.functions[0].size, 40);
}
#[test]
fn crates_mode_gets_a_dedicated_error() {
let json = r#"{
"file-size": 100,
"text-section-size": 60,
"crates": [{ "name": "wasmi", "size": 40 }]
}"#;
let err = BloatJson::from_json_str(json).unwrap_err();
assert!(matches!(err, ParseError::CratesMode), "got {err:?}");
assert!(err.to_string().contains("drop `--crates`"));
}
#[test]
fn missing_crate_field_is_tolerated() {
let json = r#"{
"file-size": 1,
"text-section-size": 1,
"functions": [{ "name": "anon", "size": 1 }]
}"#;
let data = BloatJson::from_json_str(json).unwrap();
assert_eq!(data.functions[0].crate_name(), "[unknown]");
}
#[test]
fn crate_count_ignores_the_guessed_marker() {
let json = r#"{
"file-size": 1,
"text-section-size": 1,
"functions": [
{ "crate": "wasmi", "name": "a", "size": 1 },
{ "crate": "wasmi?", "name": "b", "size": 1 },
{ "crate": "std", "name": "c", "size": 1 }
]
}"#;
let data = BloatJson::from_json_str(json).unwrap();
assert_eq!(data.crate_count(), 2);
}
#[test]
fn non_object_input_is_rejected() {
let err = BloatJson::from_json_str("[]").unwrap_err();
assert!(matches!(err, ParseError::NotAnObject), "got {err:?}");
}
#[test]
fn invalid_json_is_reported_as_syntax_error() {
let err = BloatJson::from_json_str("{").unwrap_err();
assert!(matches!(err, ParseError::Syntax(_)), "got {err:?}");
}
}