alef 0.69.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
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 super::*;
use std::fs;
use std::path::PathBuf;

#[test]
fn readme_language_mapping_can_override_the_shared_snippet_root() {
    let temporary = tempfile::tempdir().expect("temporary README workspace");
    let generated = temporary.path().join("generated/python");
    fs::create_dir_all(&generated).expect("generated snippet root");
    fs::create_dir_all(temporary.path().join("manual")).expect("manual snippet root");
    fs::write(generated.join("hello.py"), "print('generated')").expect("generated snippet");
    fs::write(
        temporary.path().join("template.md"),
        r#"{{ "hello.py" | include_snippet("python") }}"#,
    )
    .expect("README template");

    let mut config = test_config();
    config.readme = Some(ReadmeConfig {
        template_dir: Some(temporary.path().to_path_buf()),
        snippets_dir: Some(PathBuf::from("manual")),
        config: None,
        output_pattern: None,
        discord_url: None,
        banner_url: None,
        languages: std::collections::HashMap::from([(
            "python".to_string(),
            serde_json::json!({
                "template": "template.md",
                "output_path": "packages/python/README.md",
                "snippets_dir": "generated"
            }),
        )]),
        targets: std::collections::HashMap::new(),
    });
    config.workspace_root = Some(temporary.path().to_path_buf());

    let files = generate_readmes(&test_api(), &config, &[Language::Python]).expect("generated README");

    assert!(files[0].content.contains("print('generated')"));
}

#[test]
fn readme_snippet_mapping_can_override_the_root_during_migration() {
    let temporary = tempfile::tempdir().expect("temporary README workspace");
    fs::create_dir_all(temporary.path().join("manual/python")).expect("manual snippet root");
    fs::create_dir_all(temporary.path().join("generated/python")).expect("generated snippet root");
    fs::write(
        temporary.path().join("manual/python/legacy.md"),
        "```python\nprint('legacy')\n```\n",
    )
    .expect("legacy snippet");
    fs::write(
        temporary.path().join("generated/python/current.md"),
        "```python\nprint('current')\n```\n",
    )
    .expect("generated snippet");
    fs::write(
        temporary.path().join("template.md"),
        r#"{{ snippets.legacy | include_snippet("python") }}
{{ snippets.current | include_snippet("python") }}"#,
    )
    .expect("README template");

    let mut config = test_config();
    config.readme = Some(ReadmeConfig {
        template_dir: Some(temporary.path().to_path_buf()),
        snippets_dir: Some(PathBuf::from("manual")),
        config: None,
        output_pattern: None,
        discord_url: None,
        banner_url: None,
        languages: std::collections::HashMap::from([(
            "python".to_string(),
            serde_json::json!({
                "template": "template.md",
                "output_path": "packages/python/README.md",
                "snippets": {
                    "legacy": "legacy.md",
                    "current": {"path": "current.md", "root": "generated"}
                }
            }),
        )]),
        targets: std::collections::HashMap::new(),
    });
    config.workspace_root = Some(temporary.path().to_path_buf());

    let files = generate_readmes(&test_api(), &config, &[Language::Python]).expect("generated README");

    assert!(files[0].content.contains("print('legacy')"));
    assert!(files[0].content.contains("print('current')"));
}

#[test]
fn missing_mapping_root_reports_the_mapping_path_and_resolved_root() {
    let temporary = tempfile::tempdir().expect("temporary README workspace");
    fs::create_dir_all(temporary.path().join("manual")).expect("manual snippet root");
    fs::write(
        temporary.path().join("template.md"),
        r#"{{ snippets.current | include_snippet("python") }}"#,
    )
    .expect("README template");
    let mut config = test_config();
    config.readme = Some(ReadmeConfig {
        template_dir: Some(temporary.path().to_path_buf()),
        snippets_dir: Some(PathBuf::from("manual")),
        config: None,
        output_pattern: None,
        discord_url: None,
        banner_url: None,
        languages: std::collections::HashMap::from([(
            "python".to_string(),
            serde_json::json!({
                "template": "template.md",
                "output_path": "packages/python/README.md",
                "snippets": {"current": {"path": "current.md", "root": "missing"}}
            }),
        )]),
        targets: std::collections::HashMap::new(),
    });
    config.workspace_root = Some(temporary.path().to_path_buf());

    let error = generate_readmes(&test_api(), &config, &[Language::Python]).expect_err("missing mapping root");
    let message = format!("{error:#}");
    assert!(message.contains("current.md"), "{message}");
    // The resolved path is reported with the host's separators, so the expectation has to be
    // built the same way rather than spelled with `/`. ~keep
    let resolved_tail = PathBuf::from("missing").join("python").join("current.md");
    assert!(message.contains(&resolved_tail.display().to_string()), "{message}");
}