Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

One file per change for new UI strings and attribution rows (#6448)

bherbruck1ceab2ed4c03
diff --git a/.github/workflows/generated.yml b/.github/workflows/generated.yml
index 4f7b62e618..b70b1338a8 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 24c1c11e59..5d6c4a9b31 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/<slug>.json` and new ATTRIBUTION.md rows in a new
+`attribution/pending/<slug>.md`, never into the catalogs or the table (see the README in each folder).
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 125fc8706f..ec779682be 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/<slug>.json`
+ and `attribution/pending/<slug>.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 0000000000..de4c925490
--- /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/<locale>.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 0000000000..e9c671ab26
--- /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 79c9c0b0f9..a4544a3d88 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/<id>.json`: each catalog in `assets/locales` plus the messages of
+/// `assets/locales/pending/*.json` (`{"<locale>": {"<id>": "<text>"}}`, 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<String, Map<String, Value>> = 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<String, std::collections::BTreeMap<String, String>> =
+ serde_json::from_str(&text).map_err(|e| format!("{}: expected {{\"<locale>\": {{\"<id>\": \"<text>\"}}}}: {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 783452373a..df530f322d 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<String, serde_json::Value> { 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 af53e6dbe1..00153db440 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<String> = 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 49f409c1a9..9aecac2dfd 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<String, Messages> = 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 bd7ade1019..35e77f369e 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<String> {
- 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<String, serde_json::Value> = 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 3e97db2623..8d4ee6f9fd 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<String, Vec<String>> {
- 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<String, String> = serde_json::from_str(EN).unwrap();
let mut ids: BTreeMap<String, Vec<String>> = 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 d59de3bffe..6b7b952229 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 1ffc892f10..8e3c82faeb 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<String, String> = serde_json::from_str(include_str!("../../../assets/locales/en.json")).unwrap();
+ let english: std::collections::BTreeMap<String, String> =
+ 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 2d229690b0..a4f38e8420 100644
--- a/xtask/src/assets.rs
+++ b/xtask/src/assets.rs
@@ -58,6 +58,9 @@ fn walk(dir: &Path, root: &Path, out: &mut Vec<String>) -> 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 96f86c3809..06c27f2649 100644
--- a/xtask/src/i18n.rs
+++ b/xtask/src/i18n.rs
@@ -122,8 +122,15 @@ fn locales(root: &Path) -> Result<Vec<String>, String> {
fn read(root: &Path, locale: &str) -> Result<Map<String, Value>, 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 ce3abf360a..7f40540137 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 2a079dd254..f56eb17913 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 0000000000..878a7171da
--- /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/<slug>.json`: `{"<locale>": {"<id>": "<text>"}}`, folded into the
+//! catalogs (`assets/locales/<locale>.json`, sorted as `cargo xtask lists` expects).
+//! - `attribution/pending/<slug>.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<String, BTreeMap<String, String>>);
+
+fn files_with(dir: &Path, ext: &str) -> Result<Vec<PathBuf>, String> {
+ let Ok(entries) = std::fs::read_dir(dir) else { return Ok(Vec::new()) };
+ let mut files: Vec<PathBuf> = 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<Vec<LocalePending>, 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<String, BTreeMap<String, String>> =
+ serde_json::from_str(&text).map_err(|e| format!("{name}: expected {{\"<locale>\": {{\"<id>\": \"<text>\"}}}}: {e}"))?;
+ out.push((path, map));
+ }
+ Ok(out)
+}
+
+fn read_catalog(root: &Path, locale: &str) -> Result<Map<String, Value>, 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<BTreeMap<String, String>, 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<String, Map<String, Value>>, Vec<PathBuf>);
+
+/// Locale → catalog with the pending messages folded in, plus the pending files that fed them.
+fn plan_locales(root: &Path) -> Result<Plan, String> {
+ let pending = read_locale_pending(root)?;
+ let mut catalogs: BTreeMap<String, Map<String, Value>> = 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<usize, String> {
+ 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<Vec<(String, String)>, 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<Option<String>, 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<String, String> =
+ 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<usize, String> {
+ 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());
+ }
+}