use super::*;
use serde_json::Value;
use xuanji::pretty_json;
pub fn report_json_with_stale_policy(
outcome: &Outcome,
stale: &[BaselineEntry],
coverage: Option<&Coverage>,
disallow_stale: bool,
) -> String {
let policy = stale_policy(outcome, stale, disallow_stale);
let has_disallowed_stale = policy.stale_disallowed;
let (label, violations, error, subject) = match outcome {
Outcome::Clean(subject) => (
if has_disallowed_stale {
"violations"
} else {
"clean"
},
Vec::new(),
Value::Null,
Some(*subject),
),
Outcome::Violations(report) => (
"violations",
report.violations.iter().map(Violation::to_json).collect(),
Value::Null,
None,
),
Outcome::ConstitutionError(message) => (
"constitution_error",
Vec::new(),
Value::String(message.clone()),
None,
),
_ => ("unknown", Vec::new(), Value::Null, None),
};
let stale_baseline: Vec<Value> = stale
.iter()
.map(|entry| {
let mut object = entry.id.to_json();
object["rule"] = serde_json::json!(entry.rule);
object["finding"] = serde_json::json!(entry.finding);
object["owner"] = serde_json::json!(entry.owner);
object["tracker"] = serde_json::json!(entry.tracker);
object
})
.collect();
let mut document = serde_json::json!({
"format": "tianheng.reaction/structured-facts",
"outcome": label,
"exit_code": policy.exit_code,
"violations": violations,
"stale_baseline": stale_baseline,
"stale_disallowed": has_disallowed_stale,
"error": error,
});
if let Some(subject) = subject {
document["subject"] = serde_json::json!({
"declared": subject.declared(),
"reached": subject.reached(),
});
}
if let Some(coverage) = coverage {
document["coverage"] = serde_json::json!({
"workspace_crates": coverage.total,
"uncovered": coverage.uncovered,
});
}
pretty_json(&document)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StalePolicy {
pub stale_disallowed: bool,
pub exit_code: u8,
}
pub fn stale_policy(
outcome: &Outcome,
stale: &[BaselineEntry],
disallow_stale: bool,
) -> StalePolicy {
let stale_disallowed = disallow_stale && !stale.is_empty();
let exit_code = if stale_disallowed && outcome.exit_code() == 0 {
1
} else {
outcome.exit_code()
};
StalePolicy {
stale_disallowed,
exit_code,
}
}
pub fn report_json(
outcome: &Outcome,
stale: &[BaselineEntry],
coverage: Option<&Coverage>,
) -> String {
report_json_with_stale_policy(outcome, stale, coverage, false)
}
pub fn constitution_text(constitution: &Constitution) -> String {
let boundaries = constitution.boundaries();
let noun = if boundaries.len() == 1 {
"boundary"
} else {
"boundaries"
};
let mut out = format!(
"Constitution: {} ({} {noun})\n",
constitution.name(),
boundaries.len()
);
for boundary in boundaries {
let (severity, target, rule, reason) = match boundary {
Boundary::Crate(b) => {
let rule = match dependency_kind_label(b.dependency_kind()) {
Some(kind) => format!("{} ({kind} dependencies)", b.rule().text()),
None => b.rule().text(),
};
(
b.severity(),
format!("crate {}", b.target().package),
rule,
b.reason(),
)
}
Boundary::Module(b) => (
b.severity(),
format!("module {} in {}", b.module(), b.crate_package()),
b.rule().text(),
b.reason(),
),
};
out.push_str(&format!(
"\n[{}] {target}\n rule: {rule}\n reason: {reason}\n",
severity.as_str()
));
}
out
}
pub fn constitution_json(constitution: &Constitution) -> String {
let boundaries: Vec<Value> = constitution
.boundaries()
.iter()
.map(boundary_json)
.collect();
let document = serde_json::json!({
"format": "tianheng.constitution/declared-boundaries",
"constitution": constitution.name(),
"boundaries": boundaries,
});
pretty_json(&document)
}
fn boundary_json(boundary: &Boundary) -> Value {
match boundary {
Boundary::Crate(b) => {
let mut object = serde_json::json!({
"kind": "crate",
"target": b.target().package,
"rule": b.rule().label(),
"severity": b.severity().as_str(),
"reason": b.reason(),
});
for (key, value) in b.rule().json_params() {
object[key] = value;
}
if let Some(kind) = dependency_kind_label(b.dependency_kind()) {
object["dependency_kind"] = serde_json::json!(kind);
}
if let Some(anchor) = b.anchor() {
object["anchor"] = serde_json::json!(anchor);
}
object
}
Boundary::Module(b) => {
let mut object = serde_json::json!({
"kind": "module",
"target": b.module(),
"crate": b.crate_package(),
"rule": b.rule().label(),
"severity": b.severity().as_str(),
"reason": b.reason(),
});
for (key, value) in b.rule().json_params() {
object[key] = value;
}
if let Some(anchor) = b.anchor() {
object["anchor"] = serde_json::json!(anchor);
}
if b.scan_depth().is_shallow() {
object["scan_depth"] = serde_json::json!(b.scan_depth().as_str());
}
object
}
}
}
fn dependency_kind_label(kind: DependencyKind) -> Option<&'static str> {
match kind {
DependencyKind::Normal => None,
DependencyKind::Dev => Some("dev"),
DependencyKind::Build => Some("build"),
}
}