pub mod style;
use super::{
AnalysisResult, collect_hotspot_rows, filter_complexity, filter_interface, filter_volume,
format_rel_path, get_sorted_hotspots, star_string,
};
use crate::analysis::FunctionMetric;
use crate::scoring::Score;
use std::collections::HashMap;
use std::fmt::Write;
use std::fs;
use std::io;
use std::path::{Path, PathBuf};
use style::{CSS, JS_SCRIPT};
pub fn generate_html_report(res: &AnalysisResult, root_dir: &Path) -> io::Result<PathBuf> {
let out_dir = root_dir.join("tools").join("cargo-sig");
if !out_dir.exists() {
fs::create_dir_all(&out_dir)?;
}
let report_path = out_dir.join("SIG_REPORT.html");
fs::write(&report_path, render_html(res, root_dir))?;
Ok(report_path)
}
#[must_use]
pub fn render_html(res: &AnalysisResult, root_dir: &Path) -> String {
let mut out = String::with_capacity(32768);
let mut ctx = HtmlCtx {
out: &mut out,
res,
root_dir,
};
ctx.render_document();
out
}
struct HtmlCtx<'a> {
out: &'a mut String,
res: &'a AnalysisResult<'a>,
root_dir: &'a Path,
}
impl HtmlCtx<'_> {
fn render_document(&mut self) {
self.render_doc_start();
self.render_header();
self.render_scorecard();
self.render_tabs();
self.render_all_panes();
self.render_script();
self.render_doc_end();
}
fn render_all_panes(&mut self) {
self.render_tab_overview();
self.render_tab_violations();
self.render_tab_hotspots();
self.render_tab_duplication();
self.render_tab_architecture();
}
fn render_doc_start(&mut self) {
self.out
.push_str("<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"UTF-8\">\n");
self.out.push_str(
"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n",
);
self.out
.push_str("<title>SIG Maintainability Audit Dashboard</title>\n");
let _ = writeln!(
self.out,
"<style>{CSS}</style>\n</head>\n<body>\n<div class=\"container\">\n"
);
}
fn render_doc_end(&mut self) {
self.out.push_str("<footer>Generated by <strong class=\"brand\">cargo-sig</strong> — Software Improvement Group Static Analyzer for Rust • <a href=\"https://github.com/Vicente-Alejandro/Cargo-Software-Improvement-Group-Analyzer\" target=\"_blank\" rel=\"noopener noreferrer\">GitHub</a> • <a href=\"https://crates.io/crates/cargo-sig\" target=\"_blank\" rel=\"noopener noreferrer\">Crates.io</a></footer>\n</div>\n</body>\n</html>\n");
}
fn render_header(&mut self) {
let s = self.res.score;
let color = get_gauge_color(s.stars);
let offset = compute_gauge_offset(s.stars);
self.out.push_str("<header>\n<div class=\"brand-group\">\n<div class=\"badge-row\">\n<span class=\"badge\">SIG Quality Model</span>\n<span class=\"badge badge-sig\"><span class=\"screen-only\">ISO 25010</span><span class=\"print-only\">ISO/IEC 25010</span></span>\n</div>\n");
self.out.push_str("<h1 class=\"screen-only\">Maintainability Dashboard</h1>\n<p class=\"subtitle screen-only\">Static code health, cyclomatic complexity, git churn, and coverage intelligence.</p>\n<h1 class=\"print-only\">Software Maintainability Audit Report</h1>\n<p class=\"subtitle print-only\">Comprehensive evaluation of static code health, cyclomatic complexity, git churn hotspots, and test coverage.</p>\n</div>\n");
self.out.push_str("<div class=\"header-right\">\n<button class=\"btn-action\" onclick=\"window.print()\" title=\"Export PDF or Print Report\"><svg width=\"15\" height=\"15\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M6 9V2h12v7\"></path><path d=\"M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2\"></path><rect x=\"6\" y=\"14\" width=\"12\" height=\"8\"></rect></svg><span>Export PDF / Print</span></button>\n");
let _ = writeln!(
self.out,
"<div class=\"gauge-box\"><svg class=\"gauge-svg\" viewBox=\"0 0 100 100\"><circle class=\"gauge-bg\" cx=\"50\" cy=\"50\" r=\"42\"></circle><circle class=\"gauge-fill\" cx=\"50\" cy=\"50\" r=\"42\" stroke=\"{color}\" stroke-dasharray=\"263.89\" stroke-dashoffset=\"{offset:.1}\"></circle></svg><div class=\"gauge-text-group\"><span class=\"gauge-val\">{}/7</span><span class=\"gauge-label\">Overall Rating</span></div></div></div></header>\n",
s.stars
);
}
fn render_scorecard(&mut self) {
self.out.push_str("<div class=\"grid-cards\">\n");
self.render_card_final();
self.render_card_health();
self.render_card_coverage();
self.render_card_volume();
self.out.push_str("</div>\n");
}
#[rustfmt::skip]
fn render_card_final(&mut self) {
let s = self.res.score;
let d_html = self.res.delta.map_or(String::new(), |d| { let (t, c) = get_delta_badge_stars(d.delta_stars); format!("<span class=\"badge-delta {c}\">{t}</span>") });
let c = CardData { title: "Final Rating", val: format!("{}/7 Stars", s.stars), stars: s.stars, sub: "Aggregate Maintainability".into(), delta: d_html };
render_metric_card(self.out, &c);
}
#[rustfmt::skip]
fn render_card_health(&mut self) {
let s = self.res.score;
let d_html = self.res.delta.map_or(String::new(), |d| { let (t, c) = get_delta_badge_stars(d.delta_code_stars); format!("<span class=\"badge-delta {c}\">{t}</span>") });
let c = CardData { title: "Code Health", val: format!("{}/7 Stars", s.code_stars), stars: s.code_stars, sub: "Volume & Complexity".into(), delta: d_html };
render_metric_card(self.out, &c);
}
#[rustfmt::skip]
fn render_card_coverage(&mut self) {
let s = self.res.score;
if let (Some(pct), Some(st)) = (s.cov_pct, s.cov_stars) {
let pill = get_star_pill(st);
let delta_html = self.res.delta.and_then(|d| d.delta_cov).map_or(String::new(), |c| {
let (txt, cls) = get_delta_badge_cov(c);
format!("<span class=\"badge-delta {cls}\">{txt}</span>")
});
let _ = writeln!(self.out, "<div class=\"card\"><div class=\"card-header\"><span class=\"card-title\">Test Coverage</span><div class=\"card-badges\">{delta_html}<span class=\"card-pill {}\">{}</span></div></div><div class=\"card-val\">{pct:.1}%</div><div class=\"stars\">{}</div><div class=\"card-sub\">{st}/7 Stars Weighted</div></div>", pill.cls, pill.label, star_string(st));
} else {
let (label, hint) = if crate::coverage::has_llvm_cov() { ("UNAVAILABLE", "Run 'cargo sig -a'") } else { ("NOT INSTALLED", "Run 'cargo install cargo-llvm-cov'") };
let _ = writeln!(self.out, "<div class=\"card\"><div class=\"card-header\"><span class=\"card-title\">Test Coverage</span><span class=\"card-pill pill-amber\">{label}</span></div><div class=\"card-val\">N/A</div><div class=\"stars\">☆☆☆☆☆☆☆</div><div class=\"card-sub\">{hint}</div></div>");
}
}
#[rustfmt::skip]
fn render_card_volume(&mut self) {
let s = self.res.score;
let d_html = self.res.delta.map_or(String::new(), |d| { let (t, c) = get_delta_badge_loc(d.delta_loc); format!("<span class=\"badge-delta {c}\">{t}</span>") });
let c = CardData { title: "System Volume", val: format!("{} LOC", s.total_loc), stars: s.volume_stars, sub: format!("{}/7 Stars Scale", s.volume_stars), delta: d_html };
render_metric_card(self.out, &c);
}
fn render_tabs(&mut self) {
let (v, i, c) = super::count_violations(self.res.metrics);
let total_v = v + i + c;
let (hs, _) = get_sorted_hotspots(self.res);
let _ = writeln!(
self.out,
"<div class=\"tabs\"><button class=\"tab-btn active\" onclick=\"showTab('tab-overview')\">Overview</button><button class=\"tab-btn\" onclick=\"showTab('tab-violations')\">Violations <span class=\"tab-badge\">{total_v}</span></button><button class=\"tab-btn\" onclick=\"showTab('tab-hotspots')\">Hotspots <span class=\"tab-badge\">{}</span></button><button class=\"tab-btn\" onclick=\"showTab('tab-duplication')\">Duplication <span class=\"tab-badge\">{:.1}%</span></button><button class=\"tab-btn\" onclick=\"showTab('tab-architecture')\">Architecture</button></div>",
hs.len(),
self.res.dup_res.percentage
);
}
fn render_tab_overview(&mut self) {
self.out
.push_str("<div id=\"tab-overview\" class=\"tab-pane active\">\n");
self.render_risk_section();
self.render_history_section();
self.out.push_str("</div>\n");
}
fn render_history_section(&mut self) {
if self.res.history.is_empty() { return; }
self.out.push_str("<div class=\"section\"><div class=\"section-header\"><h2 class=\"section-title\">Historical Maintainability Trajectory</h2><span class=\"badge\">tools/cargo-sig/.sig_history.md</span></div>\n");
self.out.push_str("<div class=\"table-wrap\"><table><thead><tr><th>Date</th><th>Commit</th><th>Score</th><th>Code Health</th><th>Coverage</th><th>System Volume</th><th>Violations</th><th>Duplication</th></tr></thead><tbody>\n");
for rec in self.res.history.iter().rev().take(10) {
let cov = rec.cov_pct.map_or_else(|| "N/A".to_string(), |p| format!("{p:.1}%"));
let pill = get_star_pill(rec.stars);
let _ = writeln!(
self.out,
"<tr><td>{}</td><td><code>{}</code></td><td><span class=\"card-pill {}\">{}/7 Stars</span></td><td>{}/7</td><td>{}</td><td>{} LOC</td><td>{}</td><td>{:.1}%</td></tr>",
rec.date, rec.commit, pill.cls, rec.stars, rec.code_stars, cov, rec.total_loc, rec.total_violations, rec.dup_pct
);
}
self.out.push_str("</tbody></table></div></div>\n");
}
fn render_risk_section(&mut self) {
let s = self.res.score;
let low_pct = (100.0 - s.pct_moderate - s.pct_high - s.pct_very_high).max(0.0);
self.out.push_str("<div class=\"section\"><div class=\"section-header\"><h2 class=\"section-title\">Risk Profile Distribution</h2></div>\n");
let _ = writeln!(
self.out,
"<div class=\"risk-bar\"><div class=\"risk-seg risk-low\" style=\"width:{low_pct}%\"></div><div class=\"risk-seg risk-mod\" style=\"width:{}%\"></div><div class=\"risk-seg risk-high\" style=\"width:{}%\"></div><div class=\"risk-seg risk-vhigh\" style=\"width:{}%\"></div></div>",
s.pct_moderate, s.pct_high, s.pct_very_high
);
self.render_risk_legends(low_pct, s);
self.out.push_str("</div>\n");
}
fn render_risk_legends(&mut self, low: f64, s: &Score) {
self.out.push_str("<div class=\"legend-grid\">");
let _ = writeln!(
self.out,
"<div class=\"legend-card\"><span class=\"dot risk-low\"></span><div class=\"legend-info\"><span class=\"legend-name\">Low Risk</span><span class=\"legend-pct\">{low:.1}%</span></div></div><div class=\"legend-card\"><span class=\"dot risk-mod\"></span><div class=\"legend-info\"><span class=\"legend-name\">Moderate</span><span class=\"legend-pct\">{:.1}%</span></div></div><div class=\"legend-card\"><span class=\"dot risk-high\"></span><div class=\"legend-info\"><span class=\"legend-name\">High Risk</span><span class=\"legend-pct\">{:.1}%</span></div></div><div class=\"legend-card\"><span class=\"dot risk-vhigh\"></span><div class=\"legend-info\"><span class=\"legend-name\">Very High</span><span class=\"legend-pct\">{:.1}%</span></div></div></div>",
s.pct_moderate, s.pct_high, s.pct_very_high
);
}
fn render_tab_violations(&mut self) {
self.out
.push_str("<div id=\"tab-violations\" class=\"tab-pane\">\n");
self.render_volume_table();
self.render_complexity_table();
self.render_interface_table();
self.out.push_str("</div>\n");
}
fn render_volume_table(&mut self) {
let meta = TableMeta {
prefix: "vol",
title: "1. Unit Size Violations (> 15 LOC)",
empty_msg: "No unit size violations detected.",
val_header: "Lines of Code",
tag_label: "CRITICAL",
tag_cls: "tag-crit",
};
self.render_table(meta, &filter_volume(self.res.metrics));
}
fn render_complexity_table(&mut self) {
let meta = TableMeta {
prefix: "comp",
title: "2. Unit Complexity Violations (> 5 Branches)",
empty_msg: "No unit complexity violations detected.",
val_header: "Complexity",
tag_label: "WARNING",
tag_cls: "tag-warn",
};
self.render_table(meta, &filter_complexity(self.res.metrics));
}
fn render_interface_table(&mut self) {
let meta = TableMeta {
prefix: "int",
title: "3. Unit Interface Violations (> 4 Parameters)",
empty_msg: "No interface parameter violations detected.",
val_header: "Parameters",
tag_label: "INFO",
tag_cls: "tag-ok",
};
self.render_table(meta, &filter_interface(self.res.metrics));
}
fn render_table_header(&mut self, meta: &TableMeta) {
let _ = writeln!(
self.out,
"<div class=\"table-wrap\"><table><colgroup><col style=\"width:25%\"><col style=\"width:23%\"><col style=\"width:9%\"><col style=\"width:15%\"><col style=\"width:14%\"><col class=\"col-action\" style=\"width:14%\"></colgroup><thead><tr><th>File</th><th>Function</th><th class=\"th-center\">Line</th><th class=\"th-center\">{}</th><th class=\"th-center\">Severity</th><th class=\"th-center col-action\">Action</th></tr></thead><tbody>",
meta.val_header
);
}
#[rustfmt::skip]
fn render_table(&mut self, meta: TableMeta, rows: &[(&FunctionMetric, usize)]) {
let _ = writeln!(self.out, "<div class=\"section print-page-break\"><div class=\"section-header\"><h2 class=\"section-title\">{}</h2></div>", meta.title);
if rows.is_empty() {
let _ = writeln!(self.out, "<p class=\"empty-msg\">{}</p></div>", meta.empty_msg);
return;
}
self.render_table_header(&meta);
for (i, &(m, val)) in rows.iter().enumerate() {
render_table_row(self.out, &RowCtx { meta: &meta, m, val, idx: i + 1, root: self.root_dir });
}
self.out.push_str("</tbody></table></div></div>\n");
}
fn render_tab_hotspots(&mut self) {
let (hs, fr) = get_sorted_hotspots(self.res);
self.out.push_str("<div id=\"tab-hotspots\" class=\"tab-pane print-page-break\">\n<div class=\"section\"><div class=\"section-header\"><h2 class=\"section-title\">Hotspots (Risk × Churn Matrix)</h2></div>\n");
if hs.is_empty() {
self.out.push_str("<p class=\"empty-msg\">No high-risk / high-churn hotspots detected.</p></div></div>\n");
return;
}
self.out.push_str("<div class=\"table-wrap\"><table><colgroup><col style=\"width:8%\"><col style=\"width:32%\"><col style=\"width:14%\"><col style=\"width:14%\"><col style=\"width:12%\"><col style=\"width:20%\"></colgroup><thead><tr><th class=\"th-center\">Rank</th><th>File</th><th class=\"th-center\">Risk Points</th><th class=\"th-center\">Git Churn</th><th class=\"th-center\">Coverage</th><th>Recommendation</th></tr></thead><tbody>\n");
self.render_hotspot_rows(&hs, &fr);
self.out.push_str("</tbody></table></div></div></div>\n");
}
fn render_hotspot_rows(&mut self, hs: &[PathBuf], fr: &HashMap<PathBuf, usize>) {
for row in collect_hotspot_rows(hs, fr, self.res, self.root_dir) {
let _ = writeln!(
self.out,
"<tr><td class=\"cell-center cell-num\">#{}</td><td><code>{}</code></td><td class=\"cell-center cell-num\">{}</td><td class=\"cell-center\">{} commits</td><td class=\"cell-center cell-num\">{}</td><td><span class=\"tag-warn\">{}</span></td></tr>",
row.idx, row.rel_path, row.risk, row.churn, row.cov, row.rec
);
}
}
#[rustfmt::skip]
fn render_tab_duplication(&mut self) {
let dup = self.res.dup_res;
let _ = writeln!(self.out, "<div id=\"tab-duplication\" class=\"tab-pane print-page-break\">\n<div class=\"section\"><div class=\"section-header\"><h2 class=\"section-title\">Code Duplication Spans ({:.1}% Total)</h2></div>", dup.percentage);
if dup.blocks.is_empty() { self.out.push_str("<p class=\"empty-msg\">No duplicated code blocks detected.</p></div></div>\n"); return; }
self.out.push_str("<div class=\"table-wrap\"><table><colgroup><col style=\"width:45%\"><col style=\"width:18%\"><col style=\"width:20%\"><col style=\"width:17%\"></colgroup><thead><tr><th>File</th><th class=\"th-center\">Line Span</th><th class=\"th-center\">Duplicated Lines</th><th class=\"th-center\">Status</th></tr></thead><tbody>\n");
for b in &dup.blocks {
let rel = format_rel_path(&b.file_path, self.root_dir);
let _ = writeln!(self.out, "<tr><td><code>{rel}</code></td><td class=\"cell-center\">L{}-L{}</td><td class=\"cell-center cell-num\">{} lines</td><td class=\"cell-center\"><span class=\"tag-warn\">DUPLICATE</span></td></tr>", b.start_line, b.end_line, (b.end_line - b.start_line) + 1);
}
self.out.push_str("</tbody></table></div></div></div>\n");
}
fn render_tab_architecture(&mut self) {
self.out.push_str("<div id=\"tab-architecture\" class=\"tab-pane print-page-break\">\n<div class=\"section\"><div class=\"section-header\"><h2 class=\"section-title\">Architecture & Component Balance</h2></div><div class=\"arch-card\">\n");
if super::is_balanced(self.res.metrics) {
self.out.push_str("<div class=\"arch-item\"><span>Component Balance</span><span class=\"tag-ok\">BALANCED (< 50% Share Each)</span></div>\n");
} else {
self.out.push_str("<div class=\"arch-item\"><span>Component Balance</span><span class=\"tag-warn\">UNBALANCED (> 50% Single Component)</span></div>\n");
}
self.render_cycles();
self.out.push_str("</div></div></div>\n");
}
#[rustfmt::skip]
fn render_cycles(&mut self) {
let cycles = self.res.graph.detect_cycles();
if cycles.is_empty() { self.out.push_str("<div class=\"arch-item\"><span>Circular Dependencies</span><span class=\"tag-ok\">NONE DETECTED</span></div>\n"); return; }
let _ = writeln!(self.out, "<div class=\"arch-item\"><span>Circular Dependencies</span><span class=\"tag-crit\">{} DETECTED</span></div><ul class=\"cycle-list\">", cycles.len());
for (i, c) in cycles.iter().take(5).enumerate() {
let chain: Vec<String> = c.iter().map(|p| format!("<code>{}</code>", format_rel_path(p, self.root_dir))).collect();
let _ = writeln!(self.out, "<li class=\"cycle-item\">Cycle #{}: {} → {}</li>", i + 1, chain.join(" → "), chain[0]);
}
self.out.push_str("</ul>\n");
}
fn render_script(&mut self) {
self.out.push_str(JS_SCRIPT);
}
}
struct RowCtx<'a> {
meta: &'a TableMeta<'a>,
m: &'a FunctionMetric,
val: usize,
idx: usize,
root: &'a Path,
}
fn render_table_row(out: &mut String, ctx: &RowCtx) {
let rel = format_rel_path(&ctx.m.file_path, ctx.root);
let row_id = format!("{}-code-{}", ctx.meta.prefix, ctx.idx);
let source = read_function_source(&ctx.m.file_path, ctx.m.start_line, ctx.m.lines_of_code);
let _ = writeln!(
out,
"<tr><td><code>{rel}</code></td><td><code>{}</code></td><td class=\"cell-center\">L{}</td><td class=\"cell-center cell-num\">{}</td><td class=\"cell-center\"><span class=\"{}\">{}</span></td><td class=\"cell-center col-action\"><button class=\"expand-btn\" onclick=\"toggleCode(this, '{row_id}')\">View Code</button></td></tr>",
ctx.m.function_name, ctx.m.start_line, ctx.val, ctx.meta.tag_cls, ctx.meta.tag_label
);
let _ = writeln!(
out,
"<tr id=\"{row_id}\" class=\"code-expand-row\"><td colspan=\"6\" class=\"code-expand-cell\"><pre class=\"code-box\"><code>{source}</code></pre></td></tr>"
);
}
fn read_function_source(file_path: &Path, start_line: usize, loc: usize) -> String {
if start_line == 0 || loc == 0 {
return String::from("<em>Source line data unavailable</em>");
}
let Ok(content) = fs::read_to_string(file_path) else {
return String::from("<em>Source file unavailable</em>");
};
format_source_lines(&content, start_line, loc)
}
#[rustfmt::skip]
fn format_source_lines(content: &str, start_line: usize, loc: usize) -> String {
let lines: Vec<&str> = content.lines().collect();
let start_idx = start_line.saturating_sub(1);
let end_idx = (start_idx + loc).min(lines.len());
if start_idx >= lines.len() { return String::from("<em>Source range out of bounds</em>"); }
let mut code = String::with_capacity(loc * 40);
for (i, line) in lines[start_idx..end_idx].iter().enumerate() {
let _ = writeln!(code, "<span class=\"ln\">{:>4} |</span> {}", start_line + i, escape_html_str(line));
}
code
}
fn escape_html_str(s: &str) -> String {
s.replace('&', "&")
.replace('<', "<")
.replace('>', ">")
.replace('"', """)
.replace('\'', "'")
}
fn compute_gauge_offset(stars: u8) -> f64 {
let circumference = 263.89;
let frac = f64::from(stars.min(7)) / 7.0;
circumference * (1.0 - frac)
}
fn get_gauge_color(stars: u8) -> &'static str {
match stars {
6..=7 => "#10b981",
4..=5 => "#f59e0b",
_ => "#f43f5e",
}
}
struct StarPill {
cls: &'static str,
label: &'static str,
}
fn get_star_pill(stars: u8) -> StarPill {
let (cls, label) = match stars {
6..=7 => ("pill-green", "EXCELLENT"),
4..=5 => ("pill-amber", "MODERATE"),
_ => ("pill-red", "CRITICAL"),
};
StarPill { cls, label }
}
fn get_delta_badge_stars(delta: i8) -> (String, &'static str) {
match delta {
0 => ("=".to_string(), "delta-same"),
d if d > 0 => (format!("+{d}"), "delta-pos"),
d => (format!("{d}"), "delta-neg"),
}
}
fn get_delta_badge_loc(delta: isize) -> (String, &'static str) {
match delta {
0 => ("=".to_string(), "delta-same"),
d if d > 0 => (format!("+{d}"), "delta-same"),
d => (format!("{d}"), "delta-pos"),
}
}
fn get_delta_badge_cov(delta: f32) -> (String, &'static str) {
if delta.abs() < 0.05 {
("=".to_string(), "delta-same")
} else if delta > 0.0 {
(format!("+{delta:.1}%"), "delta-pos")
} else {
(format!("{delta:.1}%"), "delta-neg")
}
}
struct CardData<'a> {
title: &'a str,
val: String,
stars: u8,
sub: String,
delta: String,
}
fn render_metric_card(out: &mut String, c: &CardData) {
let pill = get_star_pill(c.stars);
let _ = writeln!(
out,
"<div class=\"card\"><div class=\"card-header\"><span class=\"card-title\">{}</span><div class=\"card-badges\">{}<span class=\"card-pill {}\">{}</span></div></div><div class=\"card-val\">{}</div><div class=\"stars\">{}</div><div class=\"card-sub\">{}</div></div>",
c.title, c.delta, pill.cls, pill.label, c.val, star_string(c.stars), c.sub
);
}
struct TableMeta<'a> {
prefix: &'a str,
title: &'a str,
empty_msg: &'a str,
val_header: &'a str,
tag_label: &'a str,
tag_cls: &'a str,
}
#[cfg(test)]
mod tests {
use super::*;
use crate::coverage::Coverage;
use tempfile::tempdir;
#[test]
fn test_render_html_empty() {
let dir = tempdir().unwrap();
let graph = crate::coupling::CouplingGraph::default();
let churns = HashMap::new();
let dup_res = crate::duplication::DuplicationResult::default();
let score = Score {
stars: 7,
code_stars: 7,
cov_stars: Some(7),
cov_pct: Some(100.0),
volume_stars: 7,
total_loc: 0,
pct_moderate: 0.0,
pct_high: 0.0,
pct_very_high: 0.0,
};
let res = AnalysisResult {
metrics: &[],
churns: &churns,
cov: &None,
score: &score,
dup_res: &dup_res,
graph: &graph,
delta: None,
history: &[],
};
let html = render_html(&res, dir.path());
assert!(html.contains("<!DOCTYPE html>"));
assert!(html.contains("Maintainability Dashboard"));
assert!(html.contains("Software Maintainability Audit Report"));
assert!(html.contains("7/7"));
assert!(html.contains("showTab"));
assert!(html.contains("toggleCode"));
assert!(html.contains("Export PDF / Print"));
}
#[test]
fn test_render_html_with_data() {
let dir = tempdir().unwrap();
let main_file = dir.path().join("src/main.rs");
fs::create_dir_all(main_file.parent().unwrap()).unwrap();
fs::write(&main_file, "fn test_fn() {\n println!(\"hello\");\n}\n").unwrap();
let m1 = FunctionMetric {
file_path: main_file,
function_name: "test_fn".to_string(),
start_line: 1,
lines_of_code: 3,
parameter_count: 5,
cyclomatic_complexity: 6,
};
let metrics = vec![m1];
let mut churns = HashMap::new();
churns.insert(dir.path().join("src/main.rs"), 4);
let mut cov_map = HashMap::new();
cov_map.insert(
dir.path().join("src/main.rs"),
Coverage { hit: 8, total: 10 },
);
let cov = Some(cov_map);
let dup_res = crate::duplication::DuplicationResult {
percentage: 3.5,
blocks: vec![crate::duplication::DuplicationBlock {
file_path: dir.path().join("src/main.rs"),
start_line: 1,
end_line: 3,
}],
};
let mut edges = HashMap::new();
let mut neighbors = std::collections::HashSet::new();
neighbors.insert(dir.path().join("src/lib.rs"));
edges.insert(dir.path().join("src/main.rs"), neighbors);
let graph = crate::coupling::CouplingGraph {
edges,
ignored_externals: 0,
};
let score = Score {
stars: 4,
code_stars: 4,
cov_stars: Some(5),
cov_pct: Some(80.0),
volume_stars: 6,
total_loc: 120,
pct_moderate: 15.0,
pct_high: 5.0,
pct_very_high: 0.0,
};
let res = AnalysisResult {
metrics: &metrics,
churns: &churns,
cov: &cov,
score: &score,
dup_res: &dup_res,
graph: &graph,
delta: None,
history: &[],
};
let html = render_html(&res, dir.path());
assert!(html.contains("src/main.rs"));
assert!(html.contains("test_fn"));
assert!(html.contains("WARNING"));
assert!(html.contains("View Code"));
assert!(html.contains("hello"));
let report_path = generate_html_report(&res, dir.path()).unwrap();
assert!(report_path.exists());
}
#[test]
fn test_compute_gauge_offset_and_color() {
assert!(compute_gauge_offset(7) < 1.0);
assert_eq!(get_gauge_color(7), "#10b981");
assert_eq!(get_gauge_color(4), "#f59e0b");
assert_eq!(get_gauge_color(2), "#f43f5e");
}
#[test]
fn test_read_function_source() {
let dir = tempdir().unwrap();
let f = dir.path().join("foo.rs");
fs::write(&f, "fn foo() {\n let x = 1 < 2;\n}\n").unwrap();
let src = read_function_source(&f, 1, 3);
assert!(src.contains("1 < 2"));
assert!(src.contains("1 |"));
let empty = read_function_source(&f, 0, 0);
assert!(empty.contains("unavailable"));
}
}