harmos-macros 0.1.8

Procedural macros for Harmos artifacts, catalogs and identities.
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
131
132
133
134
135
136
137
138
139

/* ***
 *
 * Harmos
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * ***
 */

/* === Modules === */

/* === Re-Exports === */

/* === Imports === */

// Standard Library Imports
use std::ffi::OsStr;
use std::fs;
use std::path::Path;
use std::process::Output;
// Third Party Imports

// Local Imports
use crate::fixtures;

/* === Constants === */

/* === Macros === */

/* === Type Aliases === */

/* === Structs === */

/* === Enums === */

/* === Traits === */

/* === Implementations === */

/* === Public Functions === */

/* === Private Functions === */

fn author(rustc: &OsStr, fixtures: &Path, dependencies: &Path, output: &Path, facade: &Path, fixture: &str, features: &[&str]) -> Output {
    let mut command = fixtures::command(rustc);
    command
        .arg("--edition=2024")
        .arg("--crate-type=bin")
        .arg("--emit=metadata")
        .arg(fixtures.join(fixture))
        .arg("--extern")
        .arg(format!("facade={}", facade.display()))
        .arg("-L")
        .arg(format!("dependency={}", dependencies.display()))
        .arg("--out-dir")
        .arg(output);
    for feature in features {
        command.arg("--cfg").arg(format!("feature=\"{feature}\""));
    }
    command.output().unwrap_or_else(|error| panic!("rustc runs {fixture}: {error}"))
}

/* === Tests === */

#[test]
fn crate_builds_against() {
    let harmos = fixtures::library("harmos");
    let serde = fixtures::library("serde");
    let dependencies = fixtures::dependencies();
    let fixtures = fixtures::manifest().join("tests/fixtures");
    let output = std::env::temp_dir().join(format!("harmos-facade-ui-{}", std::process::id()));
    let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
    fs::create_dir_all(&output).expect("the compile-test output directory is available");

    // Built once against Harmos and serde — never harmos-macros directly, since
    // the facade re-exports the attributes through harmos, exactly as
    // `crates/harmos` itself does.
    let compiled = fixtures::command(&rustc)
        .arg("--edition=2024")
        .arg("--crate-type=rlib")
        .arg("--crate-name=facade")
        .arg("--cfg")
        .arg("feature=\"runtime\"")
        .arg(fixtures.join("facade/lib.rs"))
        .arg("--extern")
        .arg(format!("harmos={}", harmos.display()))
        .arg("--extern")
        .arg(format!("serde={}", serde.display()))
        .arg("-L")
        .arg(format!("dependency={}", dependencies.display()))
        .arg("--out-dir")
        .arg(&output)
        .output()
        .expect("rustc builds the facade fixture");
    assert!(compiled.status.success(), "the facade fixture failed to build:\n{}", String::from_utf8_lossy(&compiled.stderr));
    let facade = output.join("libfacade.rlib");
    assert!(facade.is_file(), "the facade build did not produce {}", facade.display());

    for fixture in [
        "facade_message_with_override.rs",
        "facade_operations_with_override.rs",
        "facade_catalog_with_override.rs",
        "facade_lanes_with_override.rs",
    ] {
        let compiled = author(&rustc, &fixtures, &dependencies, &output, &facade, fixture, &[]);
        assert!(
            compiled.status.success(),
            "{fixture} failed to build against the facade alone:\n{}",
            String::from_utf8_lossy(&compiled.stderr)
        );
    }

    let runtime = author(&rustc, &fixtures, &dependencies, &output, &facade, "facade_catalog_with_override.rs", &["runtime"]);
    assert!(runtime.status.success(), "runtime registration failed:\n{}", String::from_utf8_lossy(&runtime.stderr));
    let mismatched =
        author(&rustc, &fixtures, &dependencies, &output, &facade, "facade_catalog_with_override.rs", &["runtime", "mismatched_payload"]);
    let stderr = String::from_utf8_lossy(&mismatched.stderr);
    assert!(!mismatched.status.success(), "mismatched response payload unexpectedly compiled");
    assert!(
        stderr.contains("error[E0271]") && stderr.contains("Result<Response<()>") && stderr.contains("Result<Response<u64>"),
        "unexpected payload diagnostic:\n{stderr}"
    );

    for fixture in [
        "facade_message_without_override.rs",
        "facade_operations_without_override.rs",
        "facade_catalog_without_override.rs",
        "facade_lanes_without_override.rs",
    ] {
        let compiled = author(&rustc, &fixtures, &dependencies, &output, &facade, fixture, &[]);
        let stderr = String::from_utf8_lossy(&compiled.stderr);
        assert!(
            !compiled.status.success(),
            "{fixture} unexpectedly built against the facade alone: the default `::harmos` path \
             must fail to resolve when `harmos` is not linked, or the override is not load-bearing"
        );
        assert!(stderr.contains("harmos"), "{fixture} failed for a reason other than the unresolved default path:\n{stderr}");
    }
}