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(¬ice).ok(); 73 crate::generate::data_notices::install(source_root, ¬ice, mode)?; 74 changed |= previous_notice.as_deref() 75 != Some( 76 fs::read(¬ice) 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 }