forkctl 0.0.1

Verify and rebase reusable StGit downstream patch stacks
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

use super::App;
use crate::process::{capture, run};
use anyhow::{Context, Result, ensure};
use std::fs;

impl App {
    pub fn verify(&self) -> Result<()> {
        self.require_clean()?;
        let upstream = &self.manifest.upstream;
        let actual_url = capture(&self.repo, "git", ["remote", "get-url", &upstream.remote])?;
        ensure!(
            actual_url == upstream.url,
            "remote {} is {}, expected {}",
            upstream.remote,
            actual_url,
            upstream.url
        );
        let push_url = capture(
            &self.repo,
            "git",
            ["remote", "get-url", "--push", &upstream.remote],
        )?;
        ensure!(
            push_url == "DISABLED",
            "remote {} push URL is {}, expected DISABLED",
            upstream.remote,
            push_url
        );

        for (label, revision) in [
            ("canonical base", self.manifest.bases.canonical.as_str()),
            ("stack base", self.manifest.bases.stack.as_str()),
        ] {
            run(
                &self.repo,
                "git",
                ["cat-file", "-e", &format!("{revision}^{{commit}}")],
            )
            .with_context(|| format!("{label} commit is unavailable: {revision}"))?;
        }

        let actual_base = capture(&self.repo, "stg", ["id", "{base}"])?;
        ensure!(
            actual_base == self.manifest.bases.stack,
            "StGit base is {}, expected {}",
            actual_base,
            self.manifest.bases.stack
        );
        let merge_base = capture(
            &self.repo,
            "git",
            ["merge-base", &self.manifest.bases.stack, &upstream.git_ref],
        )?;
        ensure!(
            merge_base == self.manifest.bases.canonical,
            "canonical merge base is {}, expected {}",
            merge_base,
            self.manifest.bases.canonical
        );

        let actual_stack = self.stg_series()?;
        let expected_stack = self.manifest.patch_names();
        ensure!(
            actual_stack == expected_stack,
            "StGit patch order differs: got {}, expected {}",
            actual_stack.join(", "),
            expected_stack.join(", ")
        );
        ensure!(
            capture(&self.repo, "stg", ["series", "--unapplied", "--count"])? == "0",
            "all fork patches must be applied"
        );

        self.verify_allowed_diff(
            &self.manifest.bases.canonical,
            &self.manifest.bases.stack,
            &self.manifest.allow.base,
            "pre-stack drift",
        )?;
        let source_top_name = self.manifest.source_top()?.name.as_str();
        let source_top = capture(&self.repo, "stg", ["id", source_top_name])?;
        self.verify_allowed_diff(
            &source_top,
            "HEAD",
            &self.manifest.allow.tooling,
            "tooling patch path",
        )?;

        self.verify_required_text()?;

        let expected_tree = capture(
            &self.repo,
            "git",
            ["rev-parse", &format!("{source_top}^{{tree}}")],
        )?;
        let reconstructed_tree = self.reconstruct_tree()?;
        ensure!(
            reconstructed_tree == expected_tree,
            "exported patches reconstruct {reconstructed_tree}, expected {expected_tree}"
        );

        println!(
            "forkctl: canonical={} stack-base={} patches={} source-tree={}",
            self.manifest.bases.canonical,
            self.manifest.bases.stack,
            expected_stack.len(),
            expected_tree
        );
        Ok(())
    }

    fn verify_required_text(&self) -> Result<()> {
        for required in &self.manifest.required {
            let path = self.repo.join(&required.path);
            let contents =
                fs::read_to_string(&path).with_context(|| format!("read {}", path.display()))?;
            ensure!(
                contents.contains(&required.contains),
                "required contract missing from {}: {}",
                required.path,
                required.contains
            );
        }
        Ok(())
    }
}