syncable-cli 0.37.1

A Rust-based CLI that analyzes code repositories and generates Infrastructure as Code configurations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

//! JSON formatter.

use crate::analyzer::kubelint::lint::LintResult;
use serde::Serialize;

/// Format a lint result as JSON.
pub fn format(result: &LintResult) -> String {
    let output = JsonOutput::from(result);
    serde_json::to_string_pretty(&output).unwrap_or_else(|_| "{}".to_string())
}

#[derive(Serialize)]
struct JsonOutput {
    failures: Vec<JsonFailure>,
    summary: JsonSummary,
}

#[derive(Serialize)]
struct JsonFailure {
    check: String,
    severity: String,
    message: String,
    file_path: String,
    object_name: String,
    object_kind: String,
    object_namespace: Option<String>,
    line: Option<u32>,
    remediation: Option<String>,
}

#[derive(Serialize)]
struct JsonSummary {
    objects_analyzed: usize,
    checks_run: usize,
    total_failures: usize,
    passed: bool,
}

impl From<&LintResult> for JsonOutput {
    fn from(result: &LintResult) -> Self {
        Self {
            failures: result.failures.iter().map(JsonFailure::from).collect(),
            summary: JsonSummary {
                objects_analyzed: result.summary.objects_analyzed,
                checks_run: result.summary.checks_run,
                total_failures: result.failures.len(),
                passed: result.summary.passed,
            },
        }
    }
}

impl From<&crate::analyzer::kubelint::types::CheckFailure> for JsonFailure {
    fn from(f: &crate::analyzer::kubelint::types::CheckFailure) -> Self {
        Self {
            check: f.code.to_string(),
            severity: f.severity.to_string(),
            message: f.message.clone(),
            file_path: f.file_path.display().to_string(),
            object_name: f.object_name.clone(),
            object_kind: f.object_kind.clone(),
            object_namespace: f.object_namespace.clone(),
            line: f.line,
            remediation: f.remediation.clone(),
        }
    }
}