shine-cli 2.0.1

Give personal automation a reviewable lifecycle
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

use super::manifest::hash_content;
use anyhow::{Context, Result, bail};
use serde_json::{Map, Value};

pub(super) fn managed_hash(source_bytes: &[u8], managed_keys: &[String]) -> Result<u64> {
    let managed = managed_payload_from_source(source_bytes, managed_keys)?;
    Ok(hash_content(&serialize_object(&managed)?))
}

pub(super) fn installed_hash(current_bytes: &[u8], managed_keys: &[String]) -> Result<Option<u64>> {
    let current = parse_json_object(
        current_bytes,
        "json-merge: destination must be a JSON object",
    )?;
    let managed = collect_managed_subset(&current, managed_keys);
    if managed.is_empty() {
        return Ok(None);
    }
    Ok(Some(hash_content(&serialize_object(&managed)?)))
}

fn managed_payload_from_source(
    source_bytes: &[u8],
    managed_keys: &[String],
) -> Result<Map<String, Value>> {
    let source = parse_json_object(source_bytes, "json-merge: source must be a JSON object")?;
    let mut managed = Map::new();
    for key in managed_keys {
        let value = source
            .get(key)
            .cloned()
            .ok_or_else(|| anyhow::anyhow!("json-merge: source missing managed key `{key}`"))?;
        managed.insert(key.clone(), value);
    }
    Ok(managed)
}

fn collect_managed_subset(
    source: &Map<String, Value>,
    managed_keys: &[String],
) -> Map<String, Value> {
    let mut managed = Map::new();
    for key in managed_keys {
        if let Some(value) = source.get(key).cloned() {
            managed.insert(key.clone(), value);
        }
    }
    managed
}

fn parse_json_object(bytes: &[u8], context: &'static str) -> Result<Map<String, Value>> {
    let value: Value = serde_json::from_slice(bytes).context(context)?;
    let Value::Object(object) = value else {
        bail!("{context}");
    };
    Ok(object)
}

fn serialize_object(object: &Map<String, Value>) -> Result<Vec<u8>> {
    let mut out = serde_json::to_vec_pretty(object).context("json-merge: serialization failed")?;
    if out.last() != Some(&b'\n') {
        out.push(b'\n');
    }
    Ok(out)
}

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

    #[test]
    fn installed_hash_ignores_unmanaged_keys() {
        let hash = installed_hash(
            br#"{
  "proxy": { "mode": "manual" },
  "containersProxy": { "mode": "system" },
  "theme": "dark"
}"#,
            &["proxy".to_string(), "containersProxy".to_string()],
        )
        .unwrap();

        assert!(hash.is_some());
    }

    #[test]
    fn installed_hash_returns_none_when_managed_keys_missing() {
        let hash = installed_hash(
            br#"{ "theme": "dark" }"#,
            &["proxy".to_string(), "containersProxy".to_string()],
        )
        .unwrap();

        assert!(hash.is_none());
    }
}