alef 0.75.0

Opinionated polyglot binding generator for Rust libraries
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

use super::*;
use crate::cli::cache::{CACHE_DIR, LEGACY_SCAFFOLD_OWNED_PATHS_MANIFEST, OWNERSHIP_MANIFEST};

/// THE DEFECT: a path whose ownership predates #80 and has never been rewritten since
/// lives only under the gitignored `.alef/` cache -- see
/// [`LEGACY_SCAFFOLD_OWNED_PATHS_MANIFEST`]'s doc. A consumer that clears `.alef` (a
/// clean, an upgrade, a fresh CI runner) used to lose that record outright: alef had
/// no durable proof left that it ever wrote the file, and refused to overwrite it. One
/// consumer hit this for 48 of its own outputs, including every README.
///
/// The fix: any query against the legacy record -- exactly what `alef verify`'s
/// frozen-file scan and every ownership-gated write already perform, unconditionally,
/// for every unmarkable managed path -- promotes it into the committed
/// [`OWNERSHIP_MANIFEST`] immediately, not only on the next authorised write. Once
/// promoted, the entry lives at the repo root, outside `.alef/`, so clearing the cache
/// afterward is harmless.
///
/// Red without the fix: the first query is a plain read with no side effect, so after
/// `.alef` is removed the second query finds nothing in either record and answers
/// `false`. ~keep
#[test]
fn legacy_only_ownership_survives_the_cache_being_cleared_once_queried() {
    let dir = tempfile::tempdir().expect("tempdir");
    let base = dir.path();
    let relative = Path::new("packages/java/pom.xml");

    std::fs::create_dir_all(base.join(CACHE_DIR)).expect("create legacy cache dir");
    std::fs::write(
        base.join(CACHE_DIR).join(LEGACY_SCAFFOLD_OWNED_PATHS_MANIFEST),
        "packages/java/pom.xml\n",
    )
    .expect("seed legacy record");
    assert!(
        !base.join(OWNERSHIP_MANIFEST).exists(),
        "ownership starts recorded only in the legacy cache"
    );

    assert!(
        is_scaffold_owned_path(base, &base.join(relative)),
        "sanity: the legacy record alone must already answer true"
    );

    std::fs::remove_dir_all(base.join(CACHE_DIR)).expect("clear the cache, as `alef clean` / a fresh CI runner would");
    assert!(!base.join(CACHE_DIR).exists(), "sanity: the cache is now wholly absent");

    assert!(
        is_scaffold_owned_path(base, &base.join(relative)),
        "ownership queried once while the legacy cache still existed must survive the cache being cleared"
    );
}

/// The companion guard for the fix above: a path that was never recorded anywhere --
/// not the legacy cache, not the committed record -- must stay refused even though the
/// cache is also wholly absent. Without this, "the cache is absent, so forgive it"
/// would be indistinguishable from disabling the ownership check outright: a file alef
/// genuinely did not author must still be refused. ~keep
#[test]
fn path_never_recorded_stays_refused_even_with_no_cache_at_all() {
    let dir = tempfile::tempdir().expect("tempdir");
    let base = dir.path();
    let relative = Path::new("packages/java/pom.xml");

    assert!(!base.join(CACHE_DIR).exists(), "sanity: no cache at all");
    assert!(
        !base.join(OWNERSHIP_MANIFEST).exists(),
        "sanity: no committed record either"
    );

    assert!(
        !is_scaffold_owned_path(base, &base.join(relative)),
        "a path alef never recorded must stay refused, cache absent or not"
    );
}

/// A record written by a pre-#80 alef, which exists only under the
/// gitignored cache, must keep working -- otherwise upgrading turns every
/// unmarkable file in every existing consumer repo into a refusal at once.
#[test]
fn legacy_gitignored_record_is_still_honoured_for_reads() {
    let dir = tempfile::tempdir().expect("tempdir");
    let base = dir.path();
    let relative = Path::new("packages/java/pom.xml");

    std::fs::create_dir_all(base.join(CACHE_DIR)).expect("create legacy cache dir");
    std::fs::write(
        base.join(CACHE_DIR).join(LEGACY_SCAFFOLD_OWNED_PATHS_MANIFEST),
        "packages/java/pom.xml\n",
    )
    .expect("seed legacy record");

    assert!(!base.join(OWNERSHIP_MANIFEST).exists(), "no committed record yet");
    assert!(is_scaffold_owned_path(base, &base.join(relative)));
}