lib

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

package_metadata.rs (7787B)


      1 use std::{fs, path::Path};
      2 
      3 use crate::{
      4     build_control::Mode,
      5     sdk_generation::{
      6         fs::{write_bytes_if_changed, write_or_check},
      7         package_matrix::{package_specs, wasm_package_specs},
      8     },
      9 };
     10 
     11 pub(crate) const PACKAGE_README_FILE: &str = "README.md";
     12 pub(crate) const PACKAGE_LICENSE_FILES: [&str; 2] = ["LICENSE-MIT", "LICENSE-APACHE"];
     13 pub(crate) fn generate_package_metadata(
     14     source_root: &Path,
     15     consumer_root: &Path,
     16     mode: Mode,
     17 ) -> Result<(), String> {
     18     for spec in package_specs() {
     19         write_package_metadata(source_root, &consumer_root.join(spec.package_dir), mode)?;
     20         println!("generated package metadata {}", spec.package_name);
     21     }
     22     for spec in wasm_package_specs() {
     23         write_package_metadata(source_root, &consumer_root.join(spec.package_dir), mode)?;
     24         println!("generated package metadata {}", spec.package_name);
     25     }
     26     Ok(())
     27 }
     28 
     29 pub(crate) fn package_description<'a>(
     30     json: &'a serde_json::Value,
     31     package_json_path: &Path,
     32 ) -> Result<&'a str, String> {
     33     let description = json
     34         .get("description")
     35         .and_then(serde_json::Value::as_str)
     36         .ok_or_else(|| {
     37             format!(
     38                 "package.json missing description: {}",
     39                 package_json_path.display()
     40             )
     41         })?;
     42     if description.trim().is_empty() || description.trim() != description {
     43         return Err(format!(
     44             "package.json description must be non-empty and trimmed: {}",
     45             package_json_path.display()
     46         ));
     47     }
     48     Ok(description)
     49 }
     50 
     51 pub(crate) fn package_readme(package_name: &str, description: &str) -> String {
     52     format!(
     53         "# {package_name}\n\n{description}\n\nThis package publishes generated ESM JavaScript, TypeScript declarations, and any runtime artifacts from the Radroots SDK build pipeline. Runtime files are distributed from `dist/`; source and provenance metadata are kept outside the npm package payload.\n\n## License\n\nRadroots source is licensed under either MIT or Apache-2.0, at your option. See `LICENSE-MIT` and `LICENSE-APACHE`. Retain `NOTICE` for the separately attributed pinned currency and timezone data material.\n"
     54     )
     55 }
     56 
     57 fn write_package_metadata(
     58     source_root: &Path,
     59     package_dir: &Path,
     60     mode: Mode,
     61 ) -> Result<bool, String> {
     62     let package_json_path = package_dir.join("package.json");
     63     let json = read_package_json(&package_json_path)?;
     64     let package_name = package_name(&json, &package_json_path)?;
     65     let description = package_description(&json, &package_json_path)?;
     66     let readme_path = package_dir.join(PACKAGE_README_FILE);
     67     let readme = package_readme(package_name, description);
     68     let previous_readme = fs::read_to_string(&readme_path).ok();
     69     write_or_check(&readme_path, &readme, mode)?;
     70     let mut changed = previous_readme.as_deref() != Some(readme.as_str());
     71     let notice = package_dir.join("NOTICE");
     72     let previous_notice = fs::read(&notice).ok();
     73     crate::generate::data_notices::install(source_root, &notice, mode)?;
     74     changed |= previous_notice.as_deref()
     75         != Some(
     76             fs::read(&notice)
     77                 .map_err(|_| "generated package NOTICE is missing".to_owned())?
     78                 .as_slice(),
     79         );
     80     for file_name in PACKAGE_LICENSE_FILES {
     81         let source_path = source_root.join(file_name);
     82         let contents = fs::read(&source_path)
     83             .map_err(|error| format!("failed to read {}: {error}", source_path.display()))?;
     84         let destination = package_dir.join(file_name);
     85         match mode {
     86             Mode::Write => changed |= write_bytes_if_changed(&destination, &contents)?,
     87             Mode::Check => {
     88                 let current = fs::read(&destination).map_err(|error| {
     89                     format!("failed to read {}: {error}", destination.display())
     90                 })?;
     91                 if current != contents {
     92                     return Err(format!(
     93                         "stale package license metadata: {}",
     94                         destination.display()
     95                     ));
     96                 }
     97             }
     98         }
     99     }
    100     Ok(changed)
    101 }
    102 
    103 fn read_package_json(path: &Path) -> Result<serde_json::Value, String> {
    104     let raw = fs::read_to_string(path)
    105         .map_err(|error| format!("failed to read {}: {error}", path.display()))?;
    106     serde_json::from_str::<serde_json::Value>(&raw)
    107         .map_err(|error| format!("failed to parse {}: {error}", path.display()))
    108 }
    109 
    110 fn package_name<'a>(
    111     json: &'a serde_json::Value,
    112     package_json_path: &Path,
    113 ) -> Result<&'a str, String> {
    114     json.get("name")
    115         .and_then(serde_json::Value::as_str)
    116         .ok_or_else(|| format!("package.json missing name: {}", package_json_path.display()))
    117 }
    118 
    119 #[cfg(test)]
    120 pub(crate) mod tests {
    121     use std::{
    122         fs,
    123         path::PathBuf,
    124         time::{SystemTime, UNIX_EPOCH},
    125     };
    126 
    127     use crate::build_control::Mode;
    128 
    129     use super::{package_readme, write_package_metadata};
    130 
    131     #[test]
    132     fn package_metadata_generation_is_deterministic() {
    133         let root = test_root("metadata_generation");
    134         let package_dir = root.join("packages/example");
    135         fs::create_dir_all(&package_dir).expect("create package");
    136         fs::write(root.join("LICENSE-MIT"), "MIT license\n").expect("write MIT license");
    137         fs::write(root.join("LICENSE-APACHE"), "Apache license\n").expect("write Apache license");
    138         prepare_materials(&root);
    139         fs::write(
    140             package_dir.join("package.json"),
    141             r#"{
    142   "name": "@radroots/example",
    143   "description": "Example package"
    144 }"#,
    145         )
    146         .expect("write package json");
    147 
    148         assert!(
    149             write_package_metadata(&root, &package_dir, Mode::Write).expect("first generation")
    150         );
    151         assert_eq!(
    152             fs::read_to_string(package_dir.join("README.md")).expect("read README"),
    153             package_readme("@radroots/example", "Example package")
    154         );
    155         assert_eq!(
    156             fs::read_to_string(package_dir.join("LICENSE-MIT")).expect("read MIT"),
    157             "MIT license\n"
    158         );
    159         assert!(
    160             !write_package_metadata(&root, &package_dir, Mode::Write).expect("second generation")
    161         );
    162         write_package_metadata(&root, &package_dir, Mode::Check).expect("fresh metadata");
    163 
    164         fs::write(package_dir.join("NOTICE"), "missing attribution\n").unwrap();
    165         assert!(write_package_metadata(&root, &package_dir, Mode::Check).is_err());
    166 
    167         let _ = fs::remove_dir_all(root);
    168     }
    169 
    170     fn test_root(name: &str) -> PathBuf {
    171         let stamp = SystemTime::now()
    172             .duration_since(UNIX_EPOCH)
    173             .expect("system time after epoch")
    174             .as_nanos();
    175         let root = std::env::temp_dir().join(format!(
    176             "radroots_sdk_xtask_package_metadata_{name}_{}_{}",
    177             std::process::id(),
    178             stamp
    179         ));
    180         let _ = fs::remove_dir_all(&root);
    181         root
    182     }
    183 
    184     pub(crate) fn prepare_materials(root: &std::path::Path) {
    185         let source = crate::workspace_root();
    186         let contract = crate::generate::data_notices::CONTRACT;
    187         let raw = fs::read(source.join(contract)).unwrap();
    188         let value: serde_json::Value = serde_json::from_slice(&raw).unwrap();
    189         for name in std::iter::once(contract).chain(
    190             value["materials"]
    191                 .as_array()
    192                 .unwrap()
    193                 .iter()
    194                 .map(|v| v["path"].as_str().unwrap()),
    195         ) {
    196             let destination = root.join(name);
    197             fs::create_dir_all(destination.parent().unwrap()).unwrap();
    198             fs::copy(source.join(name), destination).unwrap();
    199         }
    200         crate::generate::data_notices::run("--write", root).unwrap();
    201     }
    202 }