git-slop 0.16.4

A deterministic repository token-defragmenter for humans and AI agents.
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
121
122
123
124
125
126
127
128
129
130

use anyhow::{Context, Result, bail};
use globset::Glob;
use serde_json::{Map, Value, json};

use crate::model::Classification;

pub(super) fn validate_path_command(
    mapping: &Map<String, Value>,
    path: &str,
    index: usize,
) -> Result<()> {
    if mapping
        .get("command")
        .and_then(Value::as_str)
        .is_none_or(|command| command.trim().is_empty())
    {
        bail!("{path}[{index}].command must be a non-empty string");
    }
    Ok(())
}

pub(super) fn validate_generated_override(
    mapping: &Map<String, Value>,
    path: &str,
    index: usize,
) -> Result<()> {
    if let Some(globs) = mapping.get("generated_source_globs") {
        let Some(globs) = globs.as_array() else {
            bail!("{path}[{index}].generated_source_globs must be an array");
        };
        for (glob_index, glob) in globs.iter().enumerate() {
            let Some(glob) = glob.as_str() else {
                bail!("{path}[{index}].generated_source_globs[{glob_index}] must be a string");
            };
            Glob::new(glob).with_context(|| {
                format!("{path}[{index}].generated_source_globs[{glob_index}] is not a valid glob")
            })?;
        }
    }
    for key in ["generator_command", "verification_command"] {
        if mapping
            .get(key)
            .is_some_and(|value| value.as_str().is_none_or(|value| value.trim().is_empty()))
        {
            bail!("{path}[{index}].{key} must be a non-empty string");
        }
    }
    Ok(())
}

pub(super) fn path_command_schema() -> Value {
    json!({
        "type": "object",
        "additionalProperties": false,
        "required": ["path_glob", "command"],
        "properties": {
            "path_glob": {"type": "string", "minLength": 1, "description": "Repository path glob."},
            "command": {"type": "string", "minLength": 1, "description": "Focused verification command."}
        }
    })
}

pub(super) fn path_override_schema() -> Value {
    json!({
        "type": "object",
        "additionalProperties": false,
        "required": ["glob"],
        "properties": {
            "glob": {"type": "string", "minLength": 1},
            "classification": {"type": "string", "enum": Classification::values()},
            "profile": {"type": "string", "enum": ["agent_context", "data_context"]},
            "language": {"type": "string", "minLength": 1},
            "verification_applicability": {"type": "string", "enum": ["auto", "applicable", "not_applicable"]},
            "generated_source_globs": {"type": "array", "items": {"type": "string", "minLength": 1}},
            "generator_command": {"type": "string", "minLength": 1},
            "verification_command": {"type": "string", "minLength": 1}
        },
        "anyOf": [
            {"required": ["classification"]},
            {"required": ["profile"]},
            {"required": ["language"]},
            {"required": ["verification_applicability"]},
            {"required": ["generated_source_globs"]},
            {"required": ["generator_command"]},
            {"required": ["verification_command"]}
        ]
    })
}

#[cfg(test)]
mod tests {
    use std::fs;

    use serde_json::json;
    use tempfile::tempdir;

    use super::super::{config_path, load};

    #[test]
    fn verification_commands_accept_non_empty_entries_and_reject_blank_entries() {
        let repository = tempdir().expect("temporary repository");
        let path = config_path(repository.path());
        fs::create_dir_all(path.parent().expect("config parent")).expect("config directory");
        fs::write(
            &path,
            serde_yaml::to_string(&json!({
                "schema_version": 2,
                "verification": {"commands": ["cargo test --locked"]}
            }))
            .expect("serialize config"),
        )
        .expect("config");
        let normalized = load(repository.path()).expect("valid command");
        assert_eq!(
            normalized["verification"]["commands"],
            json!(["cargo test --locked"])
        );

        fs::write(
            &path,
            "schema_version: 2\nverification:\n  commands:\n    - '   '\n",
        )
        .expect("config");
        let error = load(repository.path()).expect_err("blank command must fail closed");
        assert!(
            error.to_string().contains("must be a non-empty string"),
            "{error:#}"
        );
    }
}