alef 0.83.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
94
95
96
97
98

use super::*;
use crate::core::config::{Language, ReadmeConfig, ResolvedCrateConfig};
use std::collections::HashMap;
use std::path::PathBuf;

fn readme_config(root: &std::path::Path, template_dir: PathBuf) -> ResolvedCrateConfig {
    let mut languages = HashMap::new();
    languages.insert(
        "rust".to_string(),
        serde_json::json!({
            "template": "rust.md",
            "output_path": "README.md"
        }),
    );
    ResolvedCrateConfig {
        name: "sample_core".to_string(),
        version_from: root.join("Cargo.toml").to_string_lossy().into_owned(),
        sources: vec![root.join("src/lib.rs")],
        workspace_root: Some(root.to_path_buf()),
        languages: vec![Language::Rust],
        readme: Some(ReadmeConfig {
            template_dir: Some(template_dir),
            snippets_dir: None,
            config: None,
            output_pattern: None,
            discord_url: None,
            banner_url: None,
            languages,
            targets: HashMap::new(),
        }),
        ..ResolvedCrateConfig::default()
    }
}

#[test]
fn sync_versions_without_regen_preserves_readme_content() {
    let _guard = CWD_LOCK.lock().unwrap_or_else(|error| error.into_inner());
    let original_cwd = std::env::current_dir().expect("current directory");
    let temporary = tempfile::tempdir().expect("temporary directory");
    let root = temporary.path();
    let templates = root.join("templates");
    std::fs::create_dir_all(root.join("src")).expect("source directory");
    std::fs::create_dir_all(&templates).expect("template directory");
    std::fs::write(root.join("src/lib.rs"), "pub fn transform() {}\n").expect("Rust source");
    std::fs::write(
        root.join("Cargo.toml"),
        "[package]\nname = \"sample_core\"\nversion = \"1.2.3\"\nedition = \"2024\"\n",
    )
    .expect("Cargo.toml");
    std::fs::write(root.join("package.json"), r#"{"name":"sample","version":"1.0.0"}"#).expect("package.json");
    std::fs::write(templates.join("rust.md"), "# Regenerated README\n").expect("README template");
    // Seeded as alef-owned (carries the same self-embedded HTML-comment marker
    // `readme::template`'s real output does -- see its `~keep` note) with a
    // deliberately *different* body than what "rust.md" renders, so the two
    // assertions below can actually distinguish "no_regen skipped the write"
    // from "no_regen let it through": a genuinely hand-written, never-alef-owned
    // README is exactly what the write-time ownership guard exists to protect,
    // and regenerating over it is covered by that guard's own tests, not this one.
    let original_readme = "<!-- This file is auto-generated by alef — DO NOT EDIT. -->\n\
<!-- To regenerate: alef readme -->\n\
<!-- To verify freshness: alef verify -->\n\n\
# Stale Regenerated README\n";
    std::fs::write(root.join("README.md"), original_readme).expect("README");
    let config_path = root.join("alef.toml");
    std::fs::write(&config_path, "").expect("alef.toml");
    let config = readme_config(root, templates);

    std::env::set_current_dir(root).expect("enter temporary directory");
    let result = sync_versions(&config, &config_path, None, true, true, None);
    std::env::set_current_dir(&original_cwd).expect("restore current directory");
    result.expect("sync versions");

    assert_eq!(
        std::fs::read_to_string(root.join("README.md")).expect("read README"),
        original_readme
    );
    assert!(
        std::fs::read_to_string(root.join("package.json"))
            .expect("read package.json")
            .contains("1.2.3"),
        "version-coordinate edits remain active without regeneration"
    );

    std::fs::write(root.join("package.json"), r#"{"name":"sample","version":"1.0.0"}"#).expect("reset package.json");
    std::env::set_current_dir(root).expect("re-enter temporary directory");
    let result = sync_versions(&config, &config_path, None, false, true, None);
    std::env::set_current_dir(&original_cwd).expect("restore current directory");
    result.expect("sync versions with regeneration");
    let regenerated = std::fs::read_to_string(root.join("README.md")).expect("read regenerated README");
    assert!(
        regenerated.ends_with("# Regenerated README\n"),
        "regeneration must replace the stale alef-owned body, got:\n{regenerated}"
    );
    assert!(
        !regenerated.contains("Stale"),
        "the stale body must not survive regeneration, got:\n{regenerated}"
    );
}