diff --git a/.github/workflows/generated.yml b/.github/workflows/generated.yml index 4f7b62e61..b70b1338a 100644 --- a/.github/workflows/generated.yml +++ b/.github/workflows/generated.yml @@ -1,6 +1,8 @@ # Files generated from the code are rewritten here, on main, after each merge, so pull requests # never edit them (two pull requests that each regenerated one would always conflict): # THIRD-PARTY-LICENSES.txt (`cargo xtask licences`) and docs/features.md (`cargo xtask features`). +# Pending files (assets/locales/pending, attribution/pending) are folded into the catalogs and +# ATTRIBUTION.md by `cargo xtask fold-pending`. name: Generated files on: @@ -17,6 +19,8 @@ on: - "crates/engine/**" - "apps/solidcraft-cli/**" - "xtask/**" + - "assets/locales/pending/*.json" + - "attribution/pending/*.md" - ".github/workflows/generated.yml" workflow_dispatch: @@ -48,13 +52,15 @@ jobs: run: cargo xtask licences - name: docs/features.md run: cargo xtask features + - name: Pending locale strings and attribution rows + run: cargo xtask fold-pending - name: Commit if changed run: | - if git diff --quiet -- THIRD-PARTY-LICENSES.txt docs/features.md; then echo "unchanged"; exit 0; fi + if [ -z "$(git status --porcelain)" ]; then echo "unchanged"; exit 0; fi git config user.name "github-actions[bot]" git config user.email "41898282+github-actions[bot]@users.noreply.github.com" - git add THIRD-PARTY-LICENSES.txt docs/features.md - git commit -m "Regenerate THIRD-PARTY-LICENSES.txt and docs/features.md [skip ci]" + git add -A THIRD-PARTY-LICENSES.txt docs/features.md assets/locales ATTRIBUTION.md attribution + git commit -m "Regenerate generated files and fold pending files [skip ci]" for _ in 1 2 3; do git pull --rebase origin main && git push origin HEAD:main && exit 0 sleep 10 diff --git a/AGENTS.md b/AGENTS.md index 24c1c11e5..5d6c4a9b3 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -218,3 +218,5 @@ workflow; never regenerate them in a PR. Keep them conflict-free (CONTRIBUTING.md, "Lists many changes add to"): message catalogs sorted (`cargo xtask lists --fix`), `mod` lines in their sorted group, the language list English first then by id, generated files left to `main`, and a design-format change as one new file. +New UI strings go in a new `assets/locales/pending/.json` and new ATTRIBUTION.md rows in a new +`attribution/pending/.md`, never into the catalogs or the table (see the README in each folder). diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 125fc8706..ec779682b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -280,6 +280,9 @@ and a fresh CI run: after each merge by the Generated files workflow (`cargo xtask licences`, `cargo xtask features`). Don't regenerate or edit them in a pull request. - **Design format**: one file per change, never an edit to a shared number (above). +- **New UI strings and attribution rows**: one new file per change, `assets/locales/pending/.json` + and `attribution/pending/.md`, instead of editing the catalogs or the ATTRIBUTION.md table; + `cargo xtask fold-pending` folds them on `main` (see the README in each folder). ## Sending a change diff --git a/assets/locales/pending/README.md b/assets/locales/pending/README.md new file mode 100644 index 000000000..de4c92549 --- /dev/null +++ b/assets/locales/pending/README.md @@ -0,0 +1,24 @@ +# Pending UI strings + +A pull request that adds UI strings adds **one new file here** instead of editing +`assets/locales/.json`. Two pull requests then never touch the same file, so they never +conflict. + +- Name it after the change, lowercase with dashes: `sketch-trim-hints.json`. +- Contents: a map from locale code to `{"message id": "text"}`. Give English; add other locales + you can translate (a locale you leave out falls back to English, as before): + + ```json + { + "en": { "sketch.trim.hint": "Click a segment to trim it" }, + "de": { "sketch.trim.hint": "Segment zum Kürzen anklicken" } + } + ``` + +- The id must not already be in that locale's catalog, nor in another pending file; the build and + `cargo xtask lists` fail otherwise. To change an existing message, edit the catalog itself. +- Don't sort or fold anything. The app, `cargo xtask i18n` and the tests read these files as part of + the catalogs, so your strings work in your own pull request. +- After a merge, the Generated files workflow runs `cargo xtask fold-pending` on `main`: it adds the + messages to the catalogs (sorted, one per line) and deletes the files. Never run it in a pull + request. diff --git a/attribution/pending/README.md b/attribution/pending/README.md new file mode 100644 index 000000000..e9c671ab2 --- /dev/null +++ b/attribution/pending/README.md @@ -0,0 +1,12 @@ +# Pending attribution rows + +A pull request that adds an asset adds **one new file here** instead of a row in `ATTRIBUTION.md`, +so two pull requests never edit the same table. + +- Name it after the change, lowercase with dashes: `render-studio-example.md`. +- Contents: the rows only, in the format of the files table in `ATTRIBUTION.md` + (`| File | Author | Source | Licence |`); a header line is allowed and ignored. +- A file that already has a row in `ATTRIBUTION.md` or another pending file fails + `cargo xtask lists`. `cargo xtask assets` counts pending rows as attributed. +- After a merge, the Generated files workflow runs `cargo xtask fold-pending` on `main`: it appends + the rows to `ATTRIBUTION.md` and deletes the files. Never run it in a pull request. diff --git a/crates/ui-egui/build.rs b/crates/ui-egui/build.rs index 79c9c0b0f..a4544a3d8 100644 --- a/crates/ui-egui/build.rs +++ b/crates/ui-egui/build.rs @@ -36,12 +36,67 @@ fn main() { } println!("cargo:rerun-if-changed=build.rs"); scenario_tests(); + if let Err(e) = merged_locales() { + eprintln!("locales: {e}"); + std::process::exit(1); + } if let Err(e) = icon_data() { eprintln!("icon data: {e}"); std::process::exit(1); } } +/// `$OUT_DIR/locales/.json`: each catalog in `assets/locales` plus the messages of +/// `assets/locales/pending/*.json` (`{"": {"": ""}}`, one file per change, folded +/// into the catalogs on main), so a pull request's new strings work before they are folded. An id +/// a catalog already has, or a locale without a catalog, fails the build, as `cargo xtask lists` +/// does. +fn merged_locales() -> Result<(), String> { + use serde_json::{Map, Value}; + let dir = std::path::Path::new("../../assets/locales"); + println!("cargo:rerun-if-changed={}", dir.display()); + let mut catalogs: std::collections::BTreeMap> = std::collections::BTreeMap::new(); + for entry in std::fs::read_dir(dir).map_err(|e| format!("{}: {e}", dir.display()))?.filter_map(Result::ok) { + let path = entry.path(); + if path.extension().is_none_or(|x| x != "json") { + continue; + } + let Some(id) = path.file_stem().and_then(|s| s.to_str()) else { continue }; + let text = std::fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?; + match serde_json::from_str(&text).map_err(|e| format!("{}: {e}", path.display()))? { + Value::Object(map) => catalogs.insert(id.to_string(), map), + _ => return Err(format!("{}: a catalog must be a JSON object", path.display())), + }; + } + let pending = dir.join("pending"); + println!("cargo:rerun-if-changed={}", pending.display()); + let mut files: Vec<_> = std::fs::read_dir(&pending) + .map(|rd| rd.filter_map(|e| e.ok().map(|e| e.path())).filter(|p| p.extension().is_some_and(|x| x == "json")).collect()) + .unwrap_or_default(); + files.sort(); + for file in files { + let text = std::fs::read_to_string(&file).map_err(|e| format!("{}: {e}", file.display()))?; + let map: std::collections::BTreeMap> = + serde_json::from_str(&text).map_err(|e| format!("{}: expected {{\"\": {{\"\": \"\"}}}}: {e}", file.display()))?; + for (locale, messages) in map { + let catalog = + catalogs.get_mut(&locale).ok_or_else(|| format!("{}: `{locale}` has no catalog assets/locales/{locale}.json", file.display()))?; + for (id, text) in messages { + if catalog.insert(id.clone(), Value::String(text)).is_some() { + return Err(format!("{}: `{id}` is already in {locale}.json (or another pending file)", file.display())); + } + } + } + } + let out = std::path::Path::new(&std::env::var("OUT_DIR").map_err(|e| e.to_string())?).join("locales"); + std::fs::create_dir_all(&out).map_err(|e| e.to_string())?; + for (id, catalog) in catalogs { + let text = serde_json::to_string(&catalog).map_err(|e| e.to_string())?; + std::fs::write(out.join(format!("{id}.json")), text).map_err(|e| e.to_string())?; + } + Ok(()) +} + /// `$OUT_DIR/scenario_tests.rs`: a `#[test]` per scenario file, named after it; a scenario with /// a `{"pending": "why"}` step is `#[ignore]`d with that reason (it waits for a fix). fn scenario_tests() { diff --git a/crates/ui-egui/src/colour_vision_tests.rs b/crates/ui-egui/src/colour_vision_tests.rs index 783452373..df530f322 100644 --- a/crates/ui-egui/src/colour_vision_tests.rs +++ b/crates/ui-egui/src/colour_vision_tests.rs @@ -879,7 +879,7 @@ fn the_shader_gets_the_modes_colours_and_its_stripes() { #[test] fn the_sections_messages_are_in_every_catalog() { let load = |text: &str| -> serde_json::Map { serde_json::from_str(text).unwrap() }; - let english = load(include_str!("../../../assets/locales/en.json")); + let english = load(include_str!(concat!(env!("OUT_DIR"), "/locales/en.json"))); let ids: Vec<&str> = ColorVision::ALL .into_iter() .flat_map(|m| [m.label_id(), m.help_id()]) @@ -887,14 +887,14 @@ fn the_sections_messages_are_in_every_catalog() { .chain(["ui.colour_vision", "ui.colour_vision_mode", "ui.colour_vision_sample", "ui.colour_vision_note"]) .collect(); for (lang, text) in [ - ("cs", include_str!("../../../assets/locales/cs.json")), - ("da", include_str!("../../../assets/locales/da.json")), - ("de", include_str!("../../../assets/locales/de.json")), - ("ja", include_str!("../../../assets/locales/ja.json")), - ("ko", include_str!("../../../assets/locales/ko.json")), - ("pl", include_str!("../../../assets/locales/pl.json")), - ("ru", include_str!("../../../assets/locales/ru.json")), - ("zh", include_str!("../../../assets/locales/zh.json")), + ("cs", include_str!(concat!(env!("OUT_DIR"), "/locales/cs.json"))), + ("da", include_str!(concat!(env!("OUT_DIR"), "/locales/da.json"))), + ("de", include_str!(concat!(env!("OUT_DIR"), "/locales/de.json"))), + ("ja", include_str!(concat!(env!("OUT_DIR"), "/locales/ja.json"))), + ("ko", include_str!(concat!(env!("OUT_DIR"), "/locales/ko.json"))), + ("pl", include_str!(concat!(env!("OUT_DIR"), "/locales/pl.json"))), + ("ru", include_str!(concat!(env!("OUT_DIR"), "/locales/ru.json"))), + ("zh", include_str!(concat!(env!("OUT_DIR"), "/locales/zh.json"))), ] { let catalog = load(text); for id in &ids { diff --git a/crates/ui-egui/src/command_help.rs b/crates/ui-egui/src/command_help.rs index af53e6dbe..00153db44 100644 --- a/crates/ui-egui/src/command_help.rs +++ b/crates/ui-egui/src/command_help.rs @@ -81,7 +81,7 @@ mod tests { #[test] fn every_help_message_is_for_a_documented_command() { - let english = help_keys(include_str!("../../../assets/locales/en.json")); + let english = help_keys(include_str!(concat!(env!("OUT_DIR"), "/locales/en.json"))); let wanted: BTreeSet = DOCUMENTED.iter().map(|id| format!("help.{id}")).collect(); assert_eq!(english, wanted); for key in &english { @@ -92,8 +92,8 @@ mod tests { #[test] fn the_help_texts_are_written_in_every_complete_language() { - let english = catalog(include_str!("../../../assets/locales/en.json")); - for source in [include_str!("../../../assets/locales/ja.json"), include_str!("../../../assets/locales/zh.json")] { + let english = catalog(include_str!(concat!(env!("OUT_DIR"), "/locales/en.json"))); + for source in [include_str!(concat!(env!("OUT_DIR"), "/locales/ja.json")), include_str!(concat!(env!("OUT_DIR"), "/locales/zh.json"))] { let other = catalog(source); for (key, text) in english.iter().filter(|(k, _)| k.starts_with("help.")) { let translated = other.get(key).unwrap_or_else(|| panic!("{key} missing")); diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs index 49f409c1a..9aecac2df 100644 --- a/crates/ui-egui/src/i18n.rs +++ b/crates/ui-egui/src/i18n.rs @@ -31,36 +31,32 @@ impl Catalog { } } -static ENGLISH: Catalog = Catalog::new("en", "English", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/en.json"))); -static CZECH: Catalog = Catalog::new("cs", "Čeština", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/cs.json"))); -static DANISH: Catalog = Catalog::new("da", "Dansk", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/da.json"))); -static GERMAN: Catalog = Catalog::new("de", "Deutsch", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/de.json"))); +static ENGLISH: Catalog = Catalog::new("en", "English", include_str!(concat!(env!("OUT_DIR"), "/locales/en.json"))); +static CZECH: Catalog = Catalog::new("cs", "Čeština", include_str!(concat!(env!("OUT_DIR"), "/locales/cs.json"))); +static DANISH: Catalog = Catalog::new("da", "Dansk", include_str!(concat!(env!("OUT_DIR"), "/locales/da.json"))); +static GERMAN: Catalog = Catalog::new("de", "Deutsch", include_str!(concat!(env!("OUT_DIR"), "/locales/de.json"))); /// English in UK spelling: only the messages whose spelling differs; the rest are English's. -static ENGLISH_UK: Catalog = - Catalog::new("en-GB", "English (UK)", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/en-GB.json"))); -static SPANISH: Catalog = Catalog::new("es", "Español (España)", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/es.json"))); -static FRENCH: Catalog = Catalog::new("fr", "Français", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/fr.json"))); -static GALICIAN: Catalog = Catalog::new("gl", "Galego", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/gl.json"))); -static HUNGARIAN: Catalog = Catalog::new("hu", "Magyar", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/hu.json"))); -static INDONESIAN: Catalog = - Catalog::new("id", "Bahasa Indonesia", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/id.json"))); -static ITALIAN: Catalog = Catalog::new("it", "Italiano", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/it.json"))); -static JAPANESE: Catalog = Catalog::new("ja", "日本語", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/ja.json"))); -static KOREAN: Catalog = Catalog::new("ko", "한국어", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/ko.json"))); -static MALAY: Catalog = Catalog::new("ms", "Bahasa Melayu", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/ms.json"))); -static DUTCH: Catalog = Catalog::new("nl", "Nederlands", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/nl.json"))); -static POLISH: Catalog = Catalog::new("pl", "Polski", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/pl.json"))); -static PORTUGUESE_BR: Catalog = - Catalog::new("pt-BR", "Português (Brasil)", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/pt-BR.json"))); -static ROMANIAN: Catalog = Catalog::new("ro", "Română", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/ro.json"))); -static RUSSIAN: Catalog = Catalog::new("ru", "Русский", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/ru.json"))); -static SWEDISH: Catalog = Catalog::new("sv", "Svenska", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/sv.json"))); -static TURKISH: Catalog = Catalog::new("tr", "Türkçe", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/tr.json"))); -static UKRAINIAN: Catalog = Catalog::new("uk", "Українська", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/uk.json"))); -static VIETNAMESE: Catalog = Catalog::new("vi", "Tiếng Việt", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/vi.json"))); -static CHINESE: Catalog = Catalog::new("zh", "中文", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/zh.json"))); -static CHINESE_TRADITIONAL: Catalog = - Catalog::new("zh-TW", "繁體中文", include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/zh-TW.json"))); +static ENGLISH_UK: Catalog = Catalog::new("en-GB", "English (UK)", include_str!(concat!(env!("OUT_DIR"), "/locales/en-GB.json"))); +static SPANISH: Catalog = Catalog::new("es", "Español (España)", include_str!(concat!(env!("OUT_DIR"), "/locales/es.json"))); +static FRENCH: Catalog = Catalog::new("fr", "Français", include_str!(concat!(env!("OUT_DIR"), "/locales/fr.json"))); +static GALICIAN: Catalog = Catalog::new("gl", "Galego", include_str!(concat!(env!("OUT_DIR"), "/locales/gl.json"))); +static HUNGARIAN: Catalog = Catalog::new("hu", "Magyar", include_str!(concat!(env!("OUT_DIR"), "/locales/hu.json"))); +static INDONESIAN: Catalog = Catalog::new("id", "Bahasa Indonesia", include_str!(concat!(env!("OUT_DIR"), "/locales/id.json"))); +static ITALIAN: Catalog = Catalog::new("it", "Italiano", include_str!(concat!(env!("OUT_DIR"), "/locales/it.json"))); +static JAPANESE: Catalog = Catalog::new("ja", "日本語", include_str!(concat!(env!("OUT_DIR"), "/locales/ja.json"))); +static KOREAN: Catalog = Catalog::new("ko", "한국어", include_str!(concat!(env!("OUT_DIR"), "/locales/ko.json"))); +static MALAY: Catalog = Catalog::new("ms", "Bahasa Melayu", include_str!(concat!(env!("OUT_DIR"), "/locales/ms.json"))); +static DUTCH: Catalog = Catalog::new("nl", "Nederlands", include_str!(concat!(env!("OUT_DIR"), "/locales/nl.json"))); +static POLISH: Catalog = Catalog::new("pl", "Polski", include_str!(concat!(env!("OUT_DIR"), "/locales/pl.json"))); +static PORTUGUESE_BR: Catalog = Catalog::new("pt-BR", "Português (Brasil)", include_str!(concat!(env!("OUT_DIR"), "/locales/pt-BR.json"))); +static ROMANIAN: Catalog = Catalog::new("ro", "Română", include_str!(concat!(env!("OUT_DIR"), "/locales/ro.json"))); +static RUSSIAN: Catalog = Catalog::new("ru", "Русский", include_str!(concat!(env!("OUT_DIR"), "/locales/ru.json"))); +static SWEDISH: Catalog = Catalog::new("sv", "Svenska", include_str!(concat!(env!("OUT_DIR"), "/locales/sv.json"))); +static TURKISH: Catalog = Catalog::new("tr", "Türkçe", include_str!(concat!(env!("OUT_DIR"), "/locales/tr.json"))); +static UKRAINIAN: Catalog = Catalog::new("uk", "Українська", include_str!(concat!(env!("OUT_DIR"), "/locales/uk.json"))); +static VIETNAMESE: Catalog = Catalog::new("vi", "Tiếng Việt", include_str!(concat!(env!("OUT_DIR"), "/locales/vi.json"))); +static CHINESE: Catalog = Catalog::new("zh", "中文", include_str!(concat!(env!("OUT_DIR"), "/locales/zh.json"))); +static CHINESE_TRADITIONAL: Catalog = Catalog::new("zh-TW", "繁體中文", include_str!(concat!(env!("OUT_DIR"), "/locales/zh-TW.json"))); /// English first (the fallback), then by language id, one per line so that adding a language /// doesn't edit a line another addition edits. #[rustfmt::skip] @@ -267,8 +263,22 @@ pub fn tr_name(text: &str) -> String { mod tests { use super::*; + /// Strings a pull request adds under `assets/locales/pending/` work before they are folded + /// into the catalogs (the build merges them in). #[test] + fn pending_messages_are_in_the_catalogs() { + let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/locales/pending"); + for entry in std::fs::read_dir(dir).unwrap().filter_map(Result::ok).filter(|e| e.path().extension().is_some_and(|x| x == "json")) { + let pending: BTreeMap = serde_json::from_str(&std::fs::read_to_string(entry.path()).unwrap()).unwrap(); + for (locale, messages) in pending { + for (id, text) in messages { + assert_eq!(Locale::for_language(&locale).text(&id), text, "{locale}: {id}"); + } + } + } + } + #[test] fn alias_resolution_regression() { static LEGACY: Catalog = Catalog::new("test-legacy", "Test", r#"{"Pitch":"legacy pitch"}"#); static ALIAS: Catalog = Catalog::new("test-alias", "Test", r#"{"coupling.pitch":"mechanical pitch"}"#); diff --git a/crates/ui-egui/src/i18n_menu_tests.rs b/crates/ui-egui/src/i18n_menu_tests.rs index bd7ade101..35e77f369 100644 --- a/crates/ui-egui/src/i18n_menu_tests.rs +++ b/crates/ui-egui/src/i18n_menu_tests.rs @@ -16,7 +16,7 @@ use solidcraft_engine::Session; /// Every English text `label()` can be asked to translate. fn english_texts() -> BTreeSet { - const EN: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/en.json")); + const EN: &str = include_str!(concat!(env!("OUT_DIR"), "/locales/en.json")); let messages: serde_json::Map = serde_json::from_str(EN).expect("en.json is valid JSON"); messages.values().filter_map(|v| v.as_str().map(str::to_string)).collect() } diff --git a/crates/ui-egui/src/i18n_painted_tests.rs b/crates/ui-egui/src/i18n_painted_tests.rs index 3e97db262..8d4ee6f9f 100644 --- a/crates/ui-egui/src/i18n_painted_tests.rs +++ b/crates/ui-egui/src/i18n_painted_tests.rs @@ -13,7 +13,7 @@ use crate::{Services, SolveApp}; /// English text → the catalog ids that carry it. fn english_ids() -> BTreeMap> { - const EN: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/locales/en.json")); + const EN: &str = include_str!(concat!(env!("OUT_DIR"), "/locales/en.json")); let messages: BTreeMap = serde_json::from_str(EN).unwrap(); let mut ids: BTreeMap> = BTreeMap::new(); for (id, text) in messages { diff --git a/crates/ui-egui/src/material_card_review.rs b/crates/ui-egui/src/material_card_review.rs index d59de3bff..6b7b95222 100644 --- a/crates/ui-egui/src/material_card_review.rs +++ b/crates/ui-egui/src/material_card_review.rs @@ -372,7 +372,7 @@ mod tests { "moisture_unit", ]; for catalog in crate::i18n::LOCALES.iter().filter(|c| c.id != "en-GB") { - let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/locales").join(format!("{}.json", catalog.id)); + let path = std::path::Path::new(env!("OUT_DIR")).join("locales").join(format!("{}.json", catalog.id)); let messages: Value = serde_json::from_str(&std::fs::read_to_string(path).unwrap()).unwrap(); for key in keys.into_iter().chain(KINDS) { let key = format!("ui.material_review.{key}"); diff --git a/crates/ui-egui/src/workspace.rs b/crates/ui-egui/src/workspace.rs index 1ffc892f1..8e3c82fae 100644 --- a/crates/ui-egui/src/workspace.rs +++ b/crates/ui-egui/src/workspace.rs @@ -667,7 +667,8 @@ mod tests { #[test] fn promoted_long_labels_have_compact_ribbon_names() { let specs = solidcraft_engine::command_specs(); - let english: std::collections::BTreeMap = serde_json::from_str(include_str!("../../../assets/locales/en.json")).unwrap(); + let english: std::collections::BTreeMap = + serde_json::from_str(include_str!(concat!(env!("OUT_DIR"), "/locales/en.json"))).unwrap(); for section in SECTIONS { let (commands, count) = layout(section.tab, section.panel, &specs).unwrap(); for command in commands.iter().take(count) { diff --git a/xtask/src/assets.rs b/xtask/src/assets.rs index 2d229690b..a4f38e842 100644 --- a/xtask/src/assets.rs +++ b/xtask/src/assets.rs @@ -58,6 +58,9 @@ fn walk(dir: &Path, root: &Path, out: &mut Vec) -> Result<(), String> { fn needs_attribution(path: &str) -> bool { // Include code masters, native work, catalogs, metadata and licence texts in the collection. + if path.starts_with("assets/locales/pending/") { + return false; + } if path.starts_with("assets/") { return !path.ends_with(".md"); } @@ -71,7 +74,12 @@ fn missing<'a>(files: &'a [String], attribution: &str) -> Vec<&'a str> { } pub fn run(root: &Path) -> Result<(), String> { - let attribution = std::fs::read_to_string(root.join("ATTRIBUTION.md")).map_err(|e| format!("ATTRIBUTION.md: {e}"))?; + let mut attribution = std::fs::read_to_string(root.join("ATTRIBUTION.md")).map_err(|e| format!("ATTRIBUTION.md: {e}"))?; + // Rows still pending (attribution/pending/*.md) count: they are folded on main. + for (_, row) in crate::pending::attribution_rows(root)? { + attribution.push('\n'); + attribution.push_str(&row); + } let mut files = Vec::new(); walk(root, root, &mut files)?; files.sort(); diff --git a/xtask/src/i18n.rs b/xtask/src/i18n.rs index 96f86c380..06c27f264 100644 --- a/xtask/src/i18n.rs +++ b/xtask/src/i18n.rs @@ -122,8 +122,15 @@ fn locales(root: &Path) -> Result, String> { fn read(root: &Path, locale: &str) -> Result, String> { let path = root.join(DIR).join(format!("{locale}.json")); let text = std::fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?; + // Messages still in assets/locales/pending/ count: they are folded on main. + let pending = crate::pending::locale_messages(root, locale)?; match serde_json::from_str(&text) { - Ok(Value::Object(map)) => Ok(map), + Ok(Value::Object(mut map)) => { + for (id, text) in pending { + map.entry(id).or_insert(Value::String(text)); + } + Ok(map) + } Ok(_) => Err(format!("{}: a catalog must be a JSON object", path.display())), Err(e) => Err(format!("{}: {e}", path.display())), } diff --git a/xtask/src/lists.rs b/xtask/src/lists.rs index ce3abf360..7f4054013 100644 --- a/xtask/src/lists.rs +++ b/xtask/src/lists.rs @@ -37,7 +37,9 @@ pub fn run(root: &Path, fix: bool) -> Result<(), String> { stale.join(", ") )); } - println!("lists: message catalogs are sorted"); + crate::pending::check_locales(root)?; + crate::pending::check_attribution(root)?; + println!("lists: message catalogs are sorted; pending locale and attribution files fold cleanly"); Ok(()) } diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 2a079dd25..f56eb1791 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -12,6 +12,7 @@ mod icons; mod layers; mod licences; mod lists; +mod pending; mod render_assets; mod test; mod test_nextest; @@ -55,6 +56,9 @@ commands: write THIRD-PARTY-LICENSES.txt (the licences of every shipped crate, embedded in the programs); --check only reports when it is out of date: pull requests leave it to the Generated files workflow on main + fold-pending fold assets/locales/pending/*.json into the catalogs and attribution/pending/*.md + into ATTRIBUTION.md, and delete them (the Generated files workflow runs this on + main; pull requests add the pending files instead of editing the shared ones) lists [--fix] check that files many changes add to are sorted one item per line (the message catalogs in assets/locales); --fix sorts them test [CARGO ARGS] [-- TEST ARGS] @@ -92,6 +96,7 @@ fn main() -> ExitCode { } Some("book") => book::run(&root(), !rest.contains(&"--no-build")), Some("licences") => licences::run(&root(), rest.contains(&"--check")), + Some("fold-pending") => pending::run(&root()), Some("lists") => lists::run(&root(), rest.contains(&"--fix")), Some("test") => { let (cargo_args, test_args) = rest.iter().position(|a| *a == "--").map_or((&rest[..], &[][..]), |i| (&rest[..i], &rest[i + 1..])); diff --git a/xtask/src/pending.rs b/xtask/src/pending.rs new file mode 100644 index 000000000..878a7171d --- /dev/null +++ b/xtask/src/pending.rs @@ -0,0 +1,292 @@ +//! Pending files: one file per change for what many pull requests add to, folded on `main`. +//! +//! - `assets/locales/pending/.json`: `{"": {"": ""}}`, folded into the +//! catalogs (`assets/locales/.json`, sorted as `cargo xtask lists` expects). +//! - `attribution/pending/.md`: rows of the ATTRIBUTION.md files table, appended to it. +//! +//! `cargo xtask fold-pending` folds and deletes them (the Generated files workflow runs it on +//! `main`); `check_*` is what `cargo xtask lists`, `i18n` and `assets` run on every pull request. +//! Both read `README.md` in each folder as documentation, never as a pending file. + +use std::collections::BTreeMap; +use std::path::{Path, PathBuf}; + +use serde_json::{Map, Value}; + +const LOCALES: &str = "assets/locales"; +const LOCALES_PENDING: &str = "assets/locales/pending"; +const ATTRIBUTION_PENDING: &str = "attribution/pending"; + +/// One pending locale file: its path and, per locale, the messages it adds. +type LocalePending = (PathBuf, BTreeMap>); + +fn files_with(dir: &Path, ext: &str) -> Result, String> { + let Ok(entries) = std::fs::read_dir(dir) else { return Ok(Vec::new()) }; + let mut files: Vec = entries + .filter_map(Result::ok) + .map(|e| e.path()) + .filter(|p| p.extension().is_some_and(|x| x == ext) && p.file_name().is_some_and(|n| n != "README.md")) + .collect(); + files.sort(); + Ok(files) +} + +fn show(root: &Path, path: &Path) -> String { + path.strip_prefix(root).unwrap_or(path).display().to_string() +} + +fn read_locale_pending(root: &Path) -> Result, String> { + let mut out = Vec::new(); + for path in files_with(&root.join(LOCALES_PENDING), "json")? { + let name = show(root, &path); + let text = std::fs::read_to_string(&path).map_err(|e| format!("{name}: {e}"))?; + let map: BTreeMap> = + serde_json::from_str(&text).map_err(|e| format!("{name}: expected {{\"\": {{\"\": \"\"}}}}: {e}"))?; + out.push((path, map)); + } + Ok(out) +} + +fn read_catalog(root: &Path, locale: &str) -> Result, String> { + let path = root.join(LOCALES).join(format!("{locale}.json")); + let text = std::fs::read_to_string(&path).map_err(|e| format!("{}: {e}", show(root, &path)))?; + match serde_json::from_str(&text) { + Ok(Value::Object(map)) => Ok(map), + Ok(_) => Err(format!("{}: a catalog must be a JSON object", show(root, &path))), + Err(e) => Err(format!("{}: {e}", show(root, &path))), + } +} + +/// The messages the pending files add to one locale, for the tools that read the catalogs. +pub fn locale_messages(root: &Path, locale: &str) -> Result, String> { + let mut out = BTreeMap::new(); + for (_, map) in read_locale_pending(root)? { + if let Some(messages) = map.get(locale) { + out.extend(messages.clone()); + } + } + Ok(out) +} + +/// Fails on a pending file the fold could not apply: a locale without a catalog, an id the catalog +/// already has, or an id two pending files both add. Returns nothing else. +pub fn check_locales(root: &Path) -> Result<(), String> { + plan_locales(root).map(|_| ()) +} + +type Plan = (BTreeMap>, Vec); + +/// Locale → catalog with the pending messages folded in, plus the pending files that fed them. +fn plan_locales(root: &Path) -> Result { + let pending = read_locale_pending(root)?; + let mut catalogs: BTreeMap> = BTreeMap::new(); + let mut added_by: BTreeMap<(String, String), String> = BTreeMap::new(); + let mut problems = Vec::new(); + for (path, map) in &pending { + let name = show(root, path); + for (locale, messages) in map { + if !root.join(LOCALES).join(format!("{locale}.json")).is_file() { + problems.push(format!("{name}: `{locale}` has no catalog assets/locales/{locale}.json")); + continue; + } + if !catalogs.contains_key(locale) { + catalogs.insert(locale.clone(), read_catalog(root, locale)?); + } + for (id, text) in messages { + if let Some(other) = added_by.get(&(locale.clone(), id.clone())) { + problems.push(format!("{name}: `{id}` ({locale}) is also added by {other}")); + } else if catalogs[locale].contains_key(id) { + problems.push(format!("{name}: `{id}` is already in {locale}.json (rename the new id, or edit the catalog)")); + } else { + added_by.insert((locale.clone(), id.clone()), name.clone()); + if let Some(catalog) = catalogs.get_mut(locale) { + catalog.insert(id.clone(), Value::String(text.clone())); + } + } + } + } + } + if problems.is_empty() { Ok((catalogs, pending.into_iter().map(|(p, _)| p).collect())) } else { Err(problems.join("\n")) } +} + +/// Fold every pending locale file into the catalogs and delete it. Returns how many messages. +pub fn fold_locales(root: &Path) -> Result { + let (catalogs, files) = plan_locales(root)?; + if files.is_empty() { + return Ok(0); + } + let mut count = 0; + for (locale, catalog) in &catalogs { + let before = read_catalog(root, locale)?.len(); + count += catalog.len() - before; + let text = crate::lists::canonical(&serde_json::to_string(catalog).map_err(|e| e.to_string())?)?; + let path = root.join(LOCALES).join(format!("{locale}.json")); + std::fs::write(&path, text).map_err(|e| format!("{}: {e}", show(root, &path)))?; + } + for file in files { + std::fs::remove_file(&file).map_err(|e| format!("{}: {e}", show(root, &file)))?; + } + Ok(count) +} + +/// The first cell of a table row (the file path), when the line is a data row of the files table. +fn row_file(line: &str) -> Option<&str> { + let line = line.trim(); + if !line.starts_with('|') { + return None; + } + let cell = line.split('|').nth(1)?.trim(); + (!cell.is_empty() && cell != "File" && !cell.starts_with("---") && !cell.starts_with(":-")).then_some(cell) +} + +/// The rows of every pending attribution file: (file name, row line). Anything else in a pending +/// file besides the table header and blank lines is an error, so a stray note is not lost. +pub fn attribution_rows(root: &Path) -> Result, String> { + let mut rows = Vec::new(); + for path in files_with(&root.join(ATTRIBUTION_PENDING), "md")? { + let name = show(root, &path); + let text = std::fs::read_to_string(&path).map_err(|e| format!("{name}: {e}"))?; + for line in text.lines().map(str::trim_end).filter(|l| !l.trim().is_empty()) { + if row_file(line).is_some() { + rows.push((name.clone(), line.to_string())); + } else if !line.trim_start().starts_with('|') { + return Err(format!("{name}: only ATTRIBUTION.md table rows (`| File | Author | Source | Licence |`) belong here, not `{line}`")); + } + } + } + Ok(rows) +} + +/// ATTRIBUTION.md with the pending rows appended to its files table; an error when a row's file +/// already has one (in the table or in another pending file). +fn merged_attribution(root: &Path) -> Result, String> { + let rows = attribution_rows(root)?; + if rows.is_empty() { + return Ok(None); + } + let path = root.join("ATTRIBUTION.md"); + let text = std::fs::read_to_string(&path).map_err(|e| format!("ATTRIBUTION.md: {e}"))?; + let mut lines: Vec<&str> = text.lines().collect(); + let start = lines.iter().position(|l| l.trim() == "## Files").ok_or("ATTRIBUTION.md has no `## Files` section")?; + let end = lines[start..].iter().position(|l| l.starts_with("## ") && l.trim() != "## Files").map_or(lines.len(), |i| start + i); + let last_row = (start..end).rev().find(|&i| lines[i].trim_start().starts_with('|')).ok_or("ATTRIBUTION.md: no files table under `## Files`")?; + let mut seen: BTreeMap = + lines[start..end].iter().filter_map(|l| row_file(l)).map(|f| (f.to_string(), "ATTRIBUTION.md".into())).collect(); + let mut problems = Vec::new(); + for (name, row) in &rows { + let Some(file) = row_file(row) else { continue }; + if let Some(other) = seen.get(file) { + problems.push(format!("{name}: `{file}` already has a row in {other}")); + } else { + seen.insert(file.to_string(), name.clone()); + } + } + if !problems.is_empty() { + return Err(problems.join("\n")); + } + let new: Vec<&str> = rows.iter().map(|(_, r)| r.as_str()).collect(); + lines.splice(last_row + 1..last_row + 1, new); + Ok(Some(lines.join("\n") + "\n")) +} + +pub fn check_attribution(root: &Path) -> Result<(), String> { + merged_attribution(root).map(|_| ()) +} + +/// Append the pending rows to ATTRIBUTION.md and delete the pending files. Returns the row count. +pub fn fold_attribution(root: &Path) -> Result { + let Some(text) = merged_attribution(root)? else { return Ok(0) }; + let count = attribution_rows(root)?.len(); + std::fs::write(root.join("ATTRIBUTION.md"), text).map_err(|e| format!("ATTRIBUTION.md: {e}"))?; + for file in files_with(&root.join(ATTRIBUTION_PENDING), "md")? { + std::fs::remove_file(&file).map_err(|e| format!("{}: {e}", show(root, &file)))?; + } + Ok(count) +} + +/// `cargo xtask fold-pending`. +pub fn run(root: &Path) -> Result<(), String> { + let messages = fold_locales(root)?; + let rows = fold_attribution(root)?; + println!("fold-pending: {messages} message(s) into assets/locales, {rows} row(s) into ATTRIBUTION.md"); + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn tree(catalogs: &[(&str, &str)]) -> PathBuf { + use std::sync::atomic::{AtomicUsize, Ordering}; + static N: AtomicUsize = AtomicUsize::new(0); + let root = std::env::temp_dir().join(format!("xtask-pending-{}-{}", std::process::id(), N.fetch_add(1, Ordering::Relaxed))); + let _ = std::fs::remove_dir_all(&root); + std::fs::create_dir_all(root.join(LOCALES_PENDING)).unwrap(); + std::fs::create_dir_all(root.join(ATTRIBUTION_PENDING)).unwrap(); + for (locale, text) in catalogs { + std::fs::write(root.join(LOCALES).join(format!("{locale}.json")), text).unwrap(); + } + std::fs::write( + root.join("ATTRIBUTION.md"), + "# Attribution\n\n## Files\n\n| File | Author | Source | Licence |\n|---|---|---|---|\n| a.png | me | own | MIT |\n\n## Other\n\ntext\n", + ) + .unwrap(); + root + } + + fn put(root: &Path, rel: &str, text: &str) { + std::fs::write(root.join(rel), text).unwrap(); + } + + #[test] + fn locale_files_fold_sorted_and_are_removed() { + let root = tree(&[("en", "{\n \"b\": \"B\"\n}\n"), ("ja", "{\n \"b\": \"ビ\"\n}\n")]); + put(&root, "assets/locales/pending/one.json", r#"{"en": {"z": "Z", "a": "A"}, "ja": {"a": "ア"}}"#); + put(&root, "assets/locales/pending/two.json", r#"{"en": {"m": "M"}}"#); + put(&root, "assets/locales/pending/README.md", "docs, never folded"); + assert_eq!(locale_messages(&root, "en").unwrap().len(), 3); + assert_eq!(fold_locales(&root).unwrap(), 4); + let en = std::fs::read_to_string(root.join("assets/locales/en.json")).unwrap(); + assert_eq!(en, "{\n \"a\": \"A\",\n \"b\": \"B\",\n \"m\": \"M\",\n \"z\": \"Z\"\n}\n"); + assert_eq!(en, crate::lists::canonical(&en).unwrap()); + assert!(std::fs::read_to_string(root.join("assets/locales/ja.json")).unwrap().contains("\"a\": \"ア\"")); + assert!(!root.join("assets/locales/pending/one.json").exists() && !root.join("assets/locales/pending/two.json").exists()); + assert!(root.join("assets/locales/pending/README.md").exists()); + assert!(locale_messages(&root, "en").unwrap().is_empty()); + } + + #[test] + fn a_key_the_catalog_has_or_two_files_add_fails_and_nothing_is_changed() { + let root = tree(&[("en", "{\n \"b\": \"B\"\n}\n")]); + put(&root, "assets/locales/pending/one.json", r#"{"en": {"b": "again"}}"#); + let err = fold_locales(&root).unwrap_err(); + assert!(err.contains("`b` is already in en.json"), "{err}"); + assert!(root.join("assets/locales/pending/one.json").exists()); + assert_eq!(std::fs::read_to_string(root.join("assets/locales/en.json")).unwrap(), "{\n \"b\": \"B\"\n}\n"); + + put(&root, "assets/locales/pending/one.json", r#"{"en": {"c": "C"}}"#); + put(&root, "assets/locales/pending/two.json", r#"{"en": {"c": "C2"}}"#); + assert!(check_locales(&root).unwrap_err().contains("is also added by")); + put(&root, "assets/locales/pending/two.json", r#"{"xx": {"d": "D"}}"#); + assert!(check_locales(&root).unwrap_err().contains("no catalog")); + put(&root, "assets/locales/pending/two.json", "[]"); + assert!(check_locales(&root).is_err()); + } + + #[test] + fn attribution_rows_fold_into_the_files_table_and_a_repeat_fails() { + let root = tree(&[]); + put(&root, "attribution/pending/x.md", "| File | Author | Source | Licence |\n|---|---|---|---|\n| b.png | me | own | MIT |\n"); + put(&root, "attribution/pending/y.md", "| c.png | me | own | MIT |\n"); + assert_eq!(attribution_rows(&root).unwrap().len(), 2); + assert_eq!(fold_attribution(&root).unwrap(), 2); + let text = std::fs::read_to_string(root.join("ATTRIBUTION.md")).unwrap(); + assert!(text.contains("| a.png | me | own | MIT |\n| b.png | me | own | MIT |\n| c.png | me | own | MIT |\n\n## Other"), "{text}"); + assert!(!root.join("attribution/pending/x.md").exists()); + + put(&root, "attribution/pending/z.md", "| a.png | you | own | MIT |\n"); + assert!(check_attribution(&root).unwrap_err().contains("already has a row")); + put(&root, "attribution/pending/z.md", "a stray note\n"); + assert!(check_attribution(&root).is_err()); + } +}