lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

release_qualification.rs (7113B)


      1 use std::{ffi::OsString, fs, path::Path, process::Command};
      2 
      3 use serde::Deserialize;
      4 
      5 #[derive(Debug, Deserialize)]
      6 struct Catalog {
      7     package: Vec<Package>,
      8 }
      9 
     10 #[derive(Debug, Deserialize)]
     11 struct Package {
     12     name: String,
     13     state: String,
     14     groups: Vec<String>,
     15 }
     16 
     17 #[derive(Debug, PartialEq, Eq)]
     18 struct CargoInvocation {
     19     args: Vec<String>,
     20 }
     21 
     22 pub fn run_feature_matrix(workspace_root: &Path) -> Result<(), String> {
     23     for invocation in feature_matrix(workspace_root)? {
     24         eprintln!("cargo {}", invocation.args.join(" "));
     25         let mut command = Command::new("cargo");
     26         command
     27             .args(&invocation.args)
     28             .current_dir(workspace_root)
     29             .env("RUSTFLAGS", rustflags_with_warnings_denied());
     30         let status = command
     31             .status()
     32             .map_err(|error| format!("failed to start cargo: {error}"))?;
     33         if !status.success() {
     34             return Err(format!(
     35                 "public feature qualification failed: cargo {}",
     36                 invocation.args.join(" ")
     37             ));
     38         }
     39     }
     40     Ok(())
     41 }
     42 
     43 fn rustflags_with_warnings_denied() -> OsString {
     44     let mut rustflags = std::env::var_os("RUSTFLAGS").unwrap_or_default();
     45     if !rustflags.is_empty() {
     46         rustflags.push(" ");
     47     }
     48     rustflags.push("-Dwarnings");
     49     rustflags
     50 }
     51 
     52 fn feature_matrix(workspace_root: &Path) -> Result<Vec<CargoInvocation>, String> {
     53     let path = workspace_root.join("contracts/crates/catalog.v2.toml");
     54     let raw = fs::read_to_string(&path)
     55         .map_err(|error| format!("failed to read {}: {error}", path.display()))?;
     56     let catalog = toml::from_str::<Catalog>(&raw)
     57         .map_err(|error| format!("failed to parse {}: {error}", path.display()))?;
     58     let mut packages = catalog
     59         .package
     60         .into_iter()
     61         .filter(|package| {
     62             package.state == "active" && package.groups.iter().any(|group| group == "public_native")
     63         })
     64         .collect::<Vec<_>>();
     65     packages.sort_by(|left, right| left.name.cmp(&right.name));
     66     let expected = crate::catalog::public_packages(workspace_root)?;
     67     if packages
     68         .iter()
     69         .map(|p| p.name.as_str())
     70         .collect::<std::collections::BTreeSet<_>>()
     71         != expected.iter().map(String::as_str).collect()
     72     {
     73         return Err(format!(
     74             "library feature qualification must match current public allocation, found {} packages",
     75             packages.len()
     76         ));
     77     }
     78 
     79     let mut invocations = Vec::new();
     80     let feature_map = package_feature_map(workspace_root)?;
     81     for package in packages {
     82         let features = feature_map
     83             .get(&package.name)
     84             .ok_or_else(|| format!("cargo metadata omitted features for {}", package.name))?;
     85         invocations.push(check_invocation(&package.name, None, true));
     86         invocations.push(check_invocation(&package.name, None, false));
     87         for feature in features {
     88             invocations.push(check_invocation(&package.name, Some(feature), true));
     89         }
     90         invocations.push(CargoInvocation {
     91             args: vec![
     92                 "check".to_owned(),
     93                 "-p".to_owned(),
     94                 package.name,
     95                 "--all-targets".to_owned(),
     96                 "--all-features".to_owned(),
     97                 "--locked".to_owned(),
     98             ],
     99         });
    100     }
    101     Ok(invocations)
    102 }
    103 
    104 fn package_feature_map(
    105     workspace_root: &Path,
    106 ) -> Result<std::collections::BTreeMap<String, Vec<String>>, String> {
    107     let output = Command::new("cargo")
    108         .args(["metadata", "--format-version", "1", "--locked", "--no-deps"])
    109         .current_dir(workspace_root)
    110         .output()
    111         .map_err(|error| format!("failed to start cargo metadata: {error}"))?;
    112     if !output.status.success() {
    113         return Err("locked cargo metadata failed".to_owned());
    114     }
    115     let metadata: serde_json::Value = serde_json::from_slice(&output.stdout)
    116         .map_err(|error| format!("failed to parse cargo metadata: {error}"))?;
    117     let packages = metadata
    118         .get("packages")
    119         .and_then(serde_json::Value::as_array)
    120         .ok_or_else(|| "cargo metadata omitted packages".to_owned())?;
    121     packages
    122         .iter()
    123         .map(|package| {
    124             let name = package
    125                 .get("name")
    126                 .and_then(serde_json::Value::as_str)
    127                 .ok_or_else(|| "cargo metadata package omitted name".to_owned())?;
    128             let mut features = package
    129                 .get("features")
    130                 .and_then(serde_json::Value::as_object)
    131                 .ok_or_else(|| format!("cargo metadata omitted features for {name}"))?
    132                 .keys()
    133                 .filter(|feature| feature.as_str() != "default")
    134                 .cloned()
    135                 .collect::<Vec<_>>();
    136             features.sort_unstable();
    137             Ok((name.to_owned(), features))
    138         })
    139         .collect()
    140 }
    141 
    142 fn check_invocation(
    143     package: &str,
    144     feature: Option<&str>,
    145     no_default_features: bool,
    146 ) -> CargoInvocation {
    147     let mut args = vec!["check".to_owned(), "-p".to_owned(), package.to_owned()];
    148     if no_default_features {
    149         args.push("--lib".to_owned());
    150         args.push("--no-default-features".to_owned());
    151     } else {
    152         args.push("--all-targets".to_owned());
    153     }
    154     if let Some(feature) = feature {
    155         args.push("--features".to_owned());
    156         args.push(feature.to_owned());
    157     }
    158     args.push("--locked".to_owned());
    159     CargoInvocation { args }
    160 }
    161 
    162 #[cfg(test)]
    163 mod tests {
    164     use super::{check_invocation, feature_matrix};
    165 
    166     #[test]
    167     fn current_catalog_generates_the_complete_library_feature_matrix() {
    168         let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
    169             .parent()
    170             .and_then(std::path::Path::parent)
    171             .expect("workspace root");
    172         let matrix = feature_matrix(root).expect("feature matrix");
    173         assert!(matrix.len() > 68);
    174         assert!(matrix.iter().any(|entry| {
    175             entry
    176                 .args
    177                 .windows(2)
    178                 .any(|pair| pair == ["--features", "blossom"])
    179                 && entry
    180                     .args
    181                     .windows(2)
    182                     .any(|pair| pair == ["-p", "radroots_nostr"])
    183         }));
    184         assert!(matrix.iter().any(|entry| {
    185             entry
    186                 .args
    187                 .windows(2)
    188                 .any(|pair| pair == ["-p", "radroots_geonames"])
    189                 && entry.args.iter().any(|arg| arg == "--all-features")
    190         }));
    191     }
    192 
    193     #[test]
    194     fn individual_features_never_enable_defaults_implicitly() {
    195         let invocation = check_invocation("radroots_event", Some("knowledge"), true);
    196         assert!(
    197             invocation
    198                 .args
    199                 .iter()
    200                 .any(|arg| arg == "--no-default-features")
    201         );
    202         assert_eq!(
    203             invocation
    204                 .args
    205                 .windows(2)
    206                 .find(|pair| pair[0] == "--features"),
    207             Some(&["--features".to_owned(), "knowledge".to_owned()][..])
    208         );
    209     }
    210 }