macroforge_ts 0.1.80

TypeScript macro expansion engine - write compile-time macros in Rust
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

use macroforge_ts::host::{MacroExpander, expand::MacroExpansion};

fn format_snapshot(input: &str, result: &MacroExpansion) -> String {
    let mut out = String::new();

    out.push_str("## Input\n\n");
    out.push_str(input.trim());

    out.push_str("\n\n## Output\n\n");
    out.push_str(result.code.trim());

    out.push_str("\n\n## DTS\n\n");
    match &result.type_output {
        Some(dts) if !dts.trim().is_empty() => out.push_str(dts.trim()),
        _ => out.push_str("(none)"),
    }

    out.push_str("\n\n## Diagnostics\n\n");
    if result.diagnostics.is_empty() {
        out.push_str("(none)");
    } else {
        for d in &result.diagnostics {
            out.push_str(&format!("{:?}: {}\n", d.level, d.message));
            for note in &d.notes {
                out.push_str(&format!("  note: {note}\n"));
            }
            if let Some(help) = &d.help {
                out.push_str(&format!("  help: {help}\n"));
            }
        }
        // trim trailing newline
        while out.ends_with('\n') {
            out.pop();
        }
    }

    out.push('\n');
    out
}

fn format_error_snapshot(input: &str, error: &dyn std::fmt::Display) -> String {
    let mut out = String::new();

    out.push_str("## Input\n\n");
    out.push_str(input.trim());
    out.push_str("\n\n## Error\n\n");
    out.push_str(&error.to_string());
    out.push('\n');
    out
}

#[test]
fn spec_ok() {
    let expander = MacroExpander::new().unwrap();

    insta::glob!("fixtures/ok/**/*.ts", |path| {
        let input = std::fs::read_to_string(path).unwrap();
        let file_name = path.file_name().unwrap().to_str().unwrap();

        let result = expander
            .expand_source(&input, file_name)
            .unwrap_or_else(|e| {
                panic!("Fixture {path:?} should expand successfully, got error: {e}")
            });

        assert!(
            result.changed,
            "Fixture {path:?} should contain macros (changed == true)",
        );

        let snapshot = format_snapshot(&input, &result);

        let fixture_dir = path.parent().unwrap();
        insta::with_settings!({
            snapshot_path => fixture_dir.join("snapshots"),
            prepend_module_to_snapshot => false,
        }, {
            insta::assert_snapshot!(snapshot);
        });
    });
}

#[test]
fn spec_error() {
    let expander = MacroExpander::new().unwrap();

    insta::glob!("fixtures/error/**/*.ts", |path| {
        let input = std::fs::read_to_string(path).unwrap();
        let file_name = path.file_name().unwrap().to_str().unwrap();

        let snapshot = match expander.expand_source(&input, file_name) {
            Ok(result) => format_snapshot(&input, &result),
            Err(e) => format_error_snapshot(&input, &e),
        };

        let fixture_dir = path.parent().unwrap();
        insta::with_settings!({
            snapshot_path => fixture_dir.join("snapshots"),
            prepend_module_to_snapshot => false,
        }, {
            insta::assert_snapshot!(snapshot);
        });
    });
}