git-slop 0.16.0

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

use globset::Glob;
use serde_json::{Value, json};

use super::CompiledPathOverride;

fn marker(text: &str) -> Option<(String, Option<String>)> {
    text.lines().take(3).find_map(|line| {
        let normalized = line.trim().trim_start_matches(['#', '/', '*', ' ']).trim();
        let lower = normalized.to_ascii_lowercase();
        let marker = lower.find("@generated from ")?;
        let descriptor = normalized[marker + "@generated from ".len()..].trim();
        let (source, command) = descriptor
            .split_once(" by ")
            .map_or((descriptor, None), |(source, command)| {
                (source, Some(command))
            });
        Some((
            source.trim().to_owned(),
            command.map(|value| value.trim().to_owned()),
        ))
    })
}

pub(super) fn generated_provenance(text: &str, tracked_paths: &[String]) -> (Vec<String>, Value) {
    let Some((source, generator_command)) = marker(text) else {
        return (
            Vec::new(),
            json!({
                "source_paths": [],
                "source_globs": [],
                "generator_command": null,
                "verification_command": null
            }),
        );
    };
    let generated_from = source.clone();
    let is_glob = source.contains(['*', '?', '[']);
    let source_globs = if is_glob {
        vec![source.clone()]
    } else {
        Vec::new()
    };
    let mut source_paths = if is_glob {
        Glob::new(&source)
            .ok()
            .map(|glob| {
                let matcher = glob.compile_matcher();
                tracked_paths
                    .iter()
                    .filter(|path| matcher.is_match(path))
                    .cloned()
                    .collect::<Vec<_>>()
            })
            .unwrap_or_default()
    } else if tracked_paths.iter().any(|path| path == &source) {
        vec![source]
    } else {
        Vec::new()
    };
    source_paths.sort();
    source_paths.dedup();
    let verification_command = generator_command.as_deref().and_then(|command| {
        command
            .contains("generate-release-workflow")
            .then(|| format!("{command} --check"))
    });
    let provenance = json!({
        "source_paths": source_paths,
        "source_globs": source_globs,
        "generator_command": generator_command,
        "verification_command": verification_command
    });
    let generated_from = if source_paths.is_empty() {
        vec![generated_from]
    } else {
        source_paths
    };
    (generated_from, provenance)
}

pub(super) fn configured_generated_provenance(
    path: &str,
    overrides: &[CompiledPathOverride],
    tracked_paths: &[String],
) -> Option<(Vec<String>, Value)> {
    let mapping = overrides.iter().rev().find(|mapping| {
        mapping.matcher.is_match(path)
            && (!mapping.generated_source_globs.is_empty()
                || mapping.generator_command.is_some()
                || mapping.verification_command.is_some())
    })?;
    let mut source_paths = mapping
        .generated_source_globs
        .iter()
        .filter_map(|pattern| Glob::new(pattern).ok())
        .map(|pattern| pattern.compile_matcher())
        .flat_map(|matcher| {
            tracked_paths
                .iter()
                .filter(move |candidate| matcher.is_match(candidate))
                .cloned()
        })
        .collect::<Vec<_>>();
    source_paths.sort();
    source_paths.dedup();
    let generated_from = if source_paths.is_empty() {
        mapping.generated_source_globs.clone()
    } else {
        source_paths.clone()
    };
    Some((
        generated_from,
        json!({
            "source_paths": source_paths,
            "source_globs": mapping.generated_source_globs,
            "generator_command": mapping.generator_command,
            "verification_command": mapping.verification_command
        }),
    ))
}