amont-runtime 1.1.0

The amont hook logic: registry, dispatchers, checks and the trust model
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! A minimal JSON emitter for `amont list --json`.
//!
//! Twenty lines for a flat, known schema — not a general serialiser. See
//! `manifest.rs`'s module doc for why this project prefers that trade on the
//! commit path: this crate must stay dependency-free, and a hand-rolled
//! escaper for the one shape `CheckListing` needs costs less than a `serde`
//! tree that runs on every commit in 96 repositories.

/// Escape `s` per the JSON spec: `"`, `\`, and control characters.
pub fn escape(s: &str) -> String {
    let mut out = String::with_capacity(s.len() + 2);
    for c in s.chars() {
        match c {
            '"' => out.push_str("\\\""),
            '\\' => out.push_str("\\\\"),
            '\n' => out.push_str("\\n"),
            '\r' => out.push_str("\\r"),
            '\t' => out.push_str("\\t"),
            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
            c => out.push(c),
        }
    }
    out
}

pub fn string_field(key: &str, value: &str) -> String {
    format!("\"{}\":\"{}\"", escape(key), escape(value))
}

pub fn bool_field(key: &str, value: bool) -> String {
    format!("\"{}\":{value}", escape(key))
}

/// A number, unquoted — a limit a reader will compare against is worth
/// emitting as one rather than as a string they have to parse back.
pub fn int_field(key: &str, value: i64) -> String {
    format!("\"{}\":{value}", escape(key))
}

/// `null` when `value` is `None` — used for `stage_filter` and `command`.
pub fn opt_string_field(key: &str, value: Option<&str>) -> String {
    match value {
        Some(v) => string_field(key, v),
        None => format!("\"{}\":null", escape(key)),
    }
}

pub fn string_array_field(key: &str, values: &[String]) -> String {
    let items: Vec<String> = values
        .iter()
        .map(|v| format!("\"{}\"", escape(v)))
        .collect();
    format!("\"{}\":[{}]", escape(key), items.join(","))
}

/// Comma-join already-built `"key":value` fragments into `{...}`.
pub fn object(fields: &[String]) -> String {
    format!("{{{}}}", fields.join(","))
}

/// Comma-join already-built objects into `[...]`.
pub fn array(items: &[String]) -> String {
    format!("[{}]", items.join(","))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn escapes_quote_backslash_and_control_chars() {
        assert_eq!(escape("a\"b"), "a\\\"b");
        assert_eq!(escape("a\\b"), "a\\\\b");
        assert_eq!(escape("a\nb"), "a\\nb");
        assert_eq!(escape("a\rb"), "a\\rb");
        assert_eq!(escape("a\tb"), "a\\tb");
        assert_eq!(escape("a\u{1}b"), "a\\u0001b");
    }

    #[test]
    fn plain_text_is_untouched() {
        assert_eq!(escape("pre-commit-clippy"), "pre-commit-clippy");
        assert_eq!(escape(""), "");
    }

    #[test]
    fn fields_quote_both_key_and_string_value() {
        assert_eq!(
            string_field("id", "pre-commit-clippy"),
            "\"id\":\"pre-commit-clippy\""
        );
        assert_eq!(bool_field("pushed", true), "\"pushed\":true");
        assert_eq!(bool_field("pushed", false), "\"pushed\":false");
        assert_eq!(opt_string_field("command", None), "\"command\":null");
        assert_eq!(
            opt_string_field("command", Some("ruff check")),
            "\"command\":\"ruff check\""
        );
    }

    #[test]
    fn string_array_field_joins_and_escapes_each_element() {
        assert_eq!(string_array_field("scope_files", &[]), "\"scope_files\":[]");
        assert_eq!(
            string_array_field("scope_files", &[".rs".to_string(), "a\"b".to_string()]),
            "\"scope_files\":[\".rs\",\"a\\\"b\"]"
        );
    }

    #[test]
    fn object_and_array_join_with_commas() {
        assert_eq!(
            object(&["\"a\":1".into(), "\"b\":2".into()]),
            "{\"a\":1,\"b\":2}"
        );
        assert_eq!(array(&["1".into(), "2".into()]), "[1,2]");
        assert_eq!(object(&[]), "{}");
        assert_eq!(array(&[]), "[]");
    }
}