harmos-runtime 0.1.7

Harmos runtime: managed state, undo, recovery, background work and typed streams.
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
140
141
142
143
144

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

// Locate The Fixtures The One Build Stamped And The Package Binaries Nextest Exposes
#![allow(dead_code)]

/* === Modules === */

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

/* === Imports === */

// Standard Library Imports
use std::ffi::OsStr;
use std::path::PathBuf;
use std::process::Command;
use std::sync::OnceLock;

// Third Party Imports
use serde_json::Value;

// Local Imports

/* === Constants === */

/* === Macros === */

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

/* === Structs === */

/* === Enums === */

/* === Traits === */

/* === Implementations === */

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

pub fn command(program: impl AsRef<OsStr>) -> Command {
    let command = Command::new(program);
    #[cfg(windows)]
    let command = {
        use std::os::windows::process::CommandExt;
        let mut command = command;
        command.creation_flags(0x08000000);
        command
    };
    command
}

pub fn manifest() -> PathBuf {
    std::env::var_os("CARGO_MANIFEST_DIR").map(PathBuf::from).expect("nextest sets the manifest directory")
}

pub fn workspace() -> PathBuf {
    manifest().ancestors().nth(2).expect("crates live two levels below the workspace").to_owned()
}

pub fn artifact(name: &str) -> PathBuf {
    let path = stamp()["metadata"]["artifacts"][name].as_str().unwrap_or_else(|| panic!("the fixture stamp has no {name}"));
    directory().join(path)
}

pub fn component(name: &str) -> Vec<u8> {
    std::fs::read(artifact(name)).unwrap_or_else(|error| panic!("stamped component {name} is unreadable: {error}"))
}

// Tests Own These Inert Copies; Inspecting Them Never Loads Or Executes A Plugin.
pub fn inspection(name: &str) -> Vec<u8> {
    let path = stamp()["metadata"]["inspections"][name].as_str().unwrap_or_else(|| panic!("the fixture stamp has no {name} inspection"));
    let path = directory().join(path);
    std::fs::read(path).unwrap_or_else(|error| panic!("inspection fixture {name} is unreadable: {error}"))
}

pub fn input(name: &str) -> PathBuf {
    directory().join(stamp()["metadata"][name].as_str().unwrap_or_else(|| panic!("fixture stamp has no {name} input")))
}

pub fn library(name: &str) -> PathBuf {
    directory().join(stamp()["metadata"]["libraries"][name].as_str().unwrap_or_else(|| panic!("the fixture stamp has no {name} library")))
}

pub fn dependencies() -> PathBuf {
    directory().join(stamp()["metadata"]["dependencies"].as_str().expect("the fixture stamp names the dependency directory"))
}

// Nextest Names The Extracted Executable At Run Time; Plain `cargo test` Only Has The Compile-Time Path.
pub fn binary(name: &str, compiled: Option<&str>) -> PathBuf {
    let variable = format!("NEXTEST_BIN_EXE_{}", name.replace('-', "_"));
    std::env::var_os(&variable)
        .map(PathBuf::from)
        .or_else(|| compiled.map(PathBuf::from))
        .unwrap_or_else(|| panic!("{variable} is unset and the package does not own {name}"))
}

// The Vendored Protobuf Compiler Travels With The Stamped Offline Inputs, Not The Build Runner's Registry
pub fn protoc() -> PathBuf {
    let platform = match (std::env::consts::OS, std::env::consts::ARCH) {
        ("linux", "x86_64") => "linux-x86_64",
        ("linux", "aarch64") => "linux-aarch_64",
        ("macos", "x86_64") => "macos-x86_64",
        ("macos", "aarch64") => "macos-aarch_64",
        ("windows", _) => "win32",
        other => panic!("no vendored protoc for {other:?}"),
    };
    let prefix = format!("protoc-bin-vendored-{platform}-");
    let vendor = input("vendor");
    let package = std::fs::read_dir(&vendor)
        .unwrap()
        .map(|entry| entry.unwrap().path())
        .find(|path| path.file_name().and_then(|name| name.to_str()).is_some_and(|name| name.starts_with(&prefix)))
        .unwrap_or_else(|| panic!("the stamped vendor directory has no {prefix}* package"));
    package.join("bin").join(if cfg!(windows) { "protoc.exe" } else { "protoc" })
}

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

fn directory() -> PathBuf {
    let profile = match std::env::var("STKR_TEST_PROFILE") {
        Ok(profile) if matches!(profile.as_str(), "dev" | "release") => profile,
        Err(std::env::VarError::NotPresent) => "dev".to_owned(),
        _ => panic!("STKR_TEST_PROFILE must be dev or release"),
    };
    let target = format!("{}-{}", std::env::consts::OS, std::env::consts::ARCH);
    workspace().join("target/build").join(profile).join(target).join("fixtures")
}

fn stamp() -> &'static Value {
    static STAMP: OnceLock<Value> = OnceLock::new();
    STAMP.get_or_init(|| {
        let path = directory().join("stamp.json");
        let bytes = std::fs::read(&path).unwrap_or_else(|error| panic!("fixture stamp {} is unreadable: {error}", path.display()));
        serde_json::from_slice(&bytes).expect("the fixture stamp is JSON")
    })
}

/* === Tests === */