use std::fmt::Write as _;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
use anyhow::Result;
use serde_json::json;
use crate::model::{OutputFormat, RenderOptions, ScanReport};
use crate::scanner::totals_by_category;
/// Renders a scan report without path redaction.
///
/// # Errors
///
/// Returns an error when JSON serialization fails.
pub fn render(report: &ScanReport, format: OutputFormat) -> Result<String> {
render_with_options(report, format, RenderOptions::default())
}
/// Renders a scan report with presentation controls.
///
/// # Errors
///
/// Returns an error when JSON serialization fails.
pub fn render_with_options(
report: &ScanReport,
format: OutputFormat,
options: RenderOptions,
) -> Result<String> {
let display_report = if options.redact_paths {
redact_report(report)
} else {
report.clone()
};
match format {
OutputFormat::Table => Ok(render_table(&display_report)),
OutputFormat::Json => Ok(serde_json::to_string_pretty(&display_report)?),
OutputFormat::Jsonl => render_jsonl(&display_report),
OutputFormat::Html => Ok(render_html(&display_report)),
}
}
/// Formats bytes with binary units.
#[must_use]
pub fn human_bytes(bytes: u64) -> String {
const UNITS: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"];
let mut unit = 0;
let mut divisor = 1_u64;
while bytes / divisor >= 1024 && unit < UNITS.len() - 1 {
divisor = divisor.saturating_mul(1024);
unit += 1;
}
if unit == 0 {
format!("{bytes} {}", UNITS[unit])
} else {
let whole = bytes / divisor;
let hundredths = bytes % divisor * 100 / divisor;
format!("{whole}.{hundredths:02} {}", UNITS[unit])
}
}
fn render_table(report: &ScanReport) -> String {
let mut output = String::new();
let _ = writeln!(
output,
"{:<23} {:>12} {:>10} PATH",
"CATEGORY", "SIZE", "AGE"
);
let _ = writeln!(output, "{}", "-".repeat(92));
for candidate in &report.candidates {
let _ = writeln!(
output,
"{:<23} {:>12} {:>10} {}",
candidate.category,
human_bytes(candidate.bytes),
human_age(candidate.modified_at_unix),
candidate.path.display()
);
}
for candidate in &report.review_candidates {
let _ = writeln!(
output,
"{:<23} {:>12} {:>10} {}",
"review-only",
human_bytes(candidate.bytes),
human_age(candidate.modified_at_unix),
candidate.path.display()
);
}
let _ = writeln!(output, "{}", "-".repeat(92));
let _ = writeln!(
output,
"{} candidates, {} reclaimable",
report.candidates.len(),
human_bytes(report.total_bytes)
);
if !report.review_candidates.is_empty() {
let _ = writeln!(
output,
"{} review-only observations, {} watched",
report.review_candidates.len(),
human_bytes(report.review_total_bytes)
);
}
for warning in &report.warnings {
let _ = writeln!(output, "warning: {warning}");
}
output
}
fn render_jsonl(report: &ScanReport) -> Result<String> {
let mut output = String::new();
for candidate in &report.candidates {
writeln!(
output,
"{}",
serde_json::to_string(&json!({"type": "candidate", "candidate": candidate}))?
)?;
}
for candidate in &report.review_candidates {
writeln!(
output,
"{}",
serde_json::to_string(&json!({"type": "review_candidate", "candidate": candidate}))?
)?;
}
writeln!(
output,
"{}",
serde_json::to_string(&json!({
"type": "summary",
"candidate_count": report.candidates.len(),
"total_bytes": report.total_bytes,
"review_candidate_count": report.review_candidates.len(),
"review_total_bytes": report.review_total_bytes,
"warnings": report.warnings,
}))?
)?;
Ok(output)
}
fn render_html(report: &ScanReport) -> String {
let totals = totals_by_category(report);
let mut cards = String::new();
for (category, bytes) in totals {
let _ = write!(
cards,
"<article><span>{}</span><strong>{}</strong></article>",
escape_html(&category.to_string()),
human_bytes(bytes)
);
}
let mut rows = String::new();
for candidate in &report.candidates {
let _ = write!(
rows,
"<tr><td>{}</td><td><code>{}</code></td><td>{}</td><td>{}</td><td>{}</td></tr>",
escape_html(&candidate.category.to_string()),
escape_html(&candidate.path.to_string_lossy()),
human_bytes(candidate.bytes),
human_age(candidate.modified_at_unix),
escape_html(&candidate.reason)
);
}
for candidate in &report.review_candidates {
let _ = write!(
rows,
"<tr><td>review-only</td><td><code>{}</code></td><td>{}</td><td>{}</td><td>{}</td></tr>",
escape_html(&candidate.path.to_string_lossy()),
human_bytes(candidate.bytes),
human_age(candidate.modified_at_unix),
escape_html(&candidate.reason)
);
}
let mut warnings = String::new();
for warning in &report.warnings {
let _ = write!(warnings, "<li>{}</li>", escape_html(warning));
}
format!(
r#"<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>devclean scan report</title><style>
:root{{color-scheme:dark;font-family:Inter,ui-sans-serif,system-ui;background:#08111f;color:#ecf3ff}}body{{margin:0}}main{{max-width:1180px;margin:auto;padding:48px 24px}}h1{{font-size:42px;margin-bottom:8px}}.lead{{color:#aebdd2}}.summary{{display:grid;grid-template-columns:repeat(auto-fit,minmax(170px,1fr));gap:12px;margin:28px 0}}article{{background:#111d31;border:1px solid #263854;border-radius:14px;padding:16px}}article span{{display:block;color:#94a7c2;font-size:12px}}article strong{{font-size:22px}}.total{{color:#5fe0a5}}.review{{color:#ffcf72}}.table{{overflow:auto;border:1px solid #263854;border-radius:14px}}table{{width:100%;border-collapse:collapse;min-width:900px}}th,td{{padding:12px;text-align:left;border-bottom:1px solid #263854}}th{{background:#15233a;color:#cbd9ed}}td{{color:#b7c5da}}code{{color:#dbe9ff}}.warnings{{color:#ffcf72}}</style></head><body><main><h1>devclean scan</h1><p class="lead">Read-only inventory of rebuildable development artifacts.</p><p class="total"><strong>{}</strong> across {} safe candidates</p><p class="review"><strong>{}</strong> across {} review-only observations</p><section class="summary">{}</section><div class="table"><table><thead><tr><th>Category</th><th>Path</th><th>Size</th><th>Age</th><th>Evidence</th></tr></thead><tbody>{}</tbody></table></div><section class="warnings"><h2>Warnings</h2><ul>{}</ul></section></main></body></html>"#,
human_bytes(report.total_bytes),
report.candidates.len(),
human_bytes(report.review_total_bytes),
report.review_candidates.len(),
cards,
rows,
warnings
)
}
fn redact_report(report: &ScanReport) -> ScanReport {
let mut redacted = report.clone();
for candidate in &mut redacted.candidates {
candidate.path = redact_path(&candidate.path, &report.roots);
}
for candidate in &mut redacted.review_candidates {
candidate.path = redact_path(&candidate.path, &report.roots);
}
for observation in &mut redacted.learning_observations {
observation.path = redact_path(&observation.path, &report.roots);
}
redacted.roots = report
.roots
.iter()
.enumerate()
.map(|(index, _)| PathBuf::from(format!("<root:{}>", index + 1)))
.collect();
redacted.warnings = report
.warnings
.iter()
.map(|warning| redact_text(warning, &report.roots))
.collect();
redacted
}
fn redact_text(value: &str, roots: &[PathBuf]) -> String {
let mut redacted = value.to_owned();
for (index, root) in roots.iter().enumerate() {
let root_text = root.to_string_lossy();
redacted = redacted.replace(root_text.as_ref(), &format!("<root:{}>", index + 1));
}
if let Some(base) = directories::BaseDirs::new() {
let home = base.home_dir().to_string_lossy();
redacted = redacted.replace(home.as_ref(), "<home>");
}
redacted
}
fn redact_path(path: &Path, roots: &[PathBuf]) -> PathBuf {
for (index, root) in roots.iter().enumerate() {
if let Ok(relative) = path.strip_prefix(root) {
return PathBuf::from(format!("<root:{}>", index + 1)).join(relative);
}
}
if let Some(base) = directories::BaseDirs::new() {
if let Ok(relative) = path.strip_prefix(base.home_dir()) {
return PathBuf::from("<home>").join(relative);
}
}
PathBuf::from("<external>").join(path.file_name().unwrap_or_default())
}
fn human_age(modified_at_unix: Option<u64>) -> String {
let Some(modified) = modified_at_unix else {
return "unknown".to_owned();
};
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_or(modified, |duration| duration.as_secs());
let seconds = now.saturating_sub(modified);
if seconds >= 86_400 {
format!("{}d", seconds / 86_400)
} else if seconds >= 3_600 {
format!("{}h", seconds / 3_600)
} else if seconds >= 60 {
format!("{}m", seconds / 60)
} else {
format!("{seconds}s")
}
}
fn escape_html(value: &str) -> String {
value
.replace('&', "&")
.replace('<', "<")
.replace('>', ">")
.replace('"', """)
.replace('\'', "'")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::{Candidate, Category, Confidence, ScanReport};
fn report(path: &str) -> ScanReport {
ScanReport {
roots: vec![PathBuf::from("/private/project")],
candidates: vec![Candidate {
category: Category::NodeModules,
path: PathBuf::from(path),
bytes: 1024,
reason: "test".to_owned(),
modified_at_unix: None,
confidence: Confidence::Safe,
}],
review_candidates: Vec::new(),
learning_observations: Vec::new(),
warnings: Vec::new(),
total_bytes: 1024,
review_total_bytes: 0,
observed_total_bytes: 0,
protect_git_tracked: true,
}
}
#[test]
fn human_bytes_should_use_binary_units() {
assert_eq!(human_bytes(1024), "1.00 KiB");
}
#[test]
fn render_html_should_escape_candidate_paths() -> Result<()> {
let output = render(&report("/tmp/<script>"), OutputFormat::Html)?;
assert!(!output.contains("<script>"));
Ok(())
}
#[test]
fn render_should_redact_paths_in_json() -> Result<()> {
let output = render_with_options(
&report("/private/project/node_modules"),
OutputFormat::Json,
RenderOptions { redact_paths: true },
)?;
assert!(!output.contains("/private/project"));
Ok(())
}
#[test]
fn render_should_redact_paths_inside_warnings() -> Result<()> {
let mut input = report("/private/project/node_modules");
input
.warnings
.push("protected /private/project/node_modules".to_owned());
let output = render_with_options(
&input,
OutputFormat::Json,
RenderOptions { redact_paths: true },
)?;
assert!(!output.contains("/private/project"));
Ok(())
}
}