Add qps-ploc pseudolocalization support by andrew-polk · Pull Request #158 · sillsdev/l10nsharp

andrew-polk · 2026-08-22T04:50:49Z

Problem

Applications built on L10NSharp have no good way for testers to verify internationalization. Hard-coded (non-localizable) strings, clipped layouts, broken format placeholders, and runtime string concatenation are invisible in an English UI and only surface after real translations arrive.

Fix

This PR adds the industry-standard qps-ploc pseudo-locale. Any lookup for language qps-ploc returns the live English text pseudolocalized — every vowel doubled with an accent on the first of the pair for ~30-40% in-word expansion, all wrapped in brackets (e.g. Title Missing → [Tîitlée Mîissîing]) — with format placeholders ({0}, {0:n0}, named {app_title}-style, and %0-style) and HTML/XML tags passed through untouched. Plain English on screen then means a hard-coded string; a missing ] means truncation; brackets mid-sentence mean concatenation.

Lookups work by simply setting the language code (SetUILanguage("qps-ploc") or a per-call language list); all the lookup funnels (static, preferred-languages, dynamic, and the WinForms paths — both runtime lookups and designer-created controls, whose localizers read the string cache directly) are hooked, and the transform is applied exactly once. The code-supplied English wins over the cache, mirroring the existing en rule.
The pseudo-locale is derived from English at lookup time: no translation files exist, are loaded, or are written for it, it never maps to/from a real language, and it reports itself exactly as complete as English (availability and counts).
LocalizationManager.OfferPseudoLocalization (default false) gates only whether it is advertised in GetAvailableLocalizedLanguages()/GetUILanguages(), so end users never see the test locale unless the app opts in (e.g. alpha channels). Display name is hard-coded as "Pseudo-English (qps-ploc)".
The transform lives in an isolated, internal src/L10NSharp/Pseudo/ silo and adds no package dependency. The vowel-doubling style follows Mozilla’s pseudolocalization approach, chosen for readability after trying several styles live in Bloom; the MIT-licensed PseudoLocalizer project was the starting point, and its adapted placeholder/markup-skipping logic remains (attribution in the silo’s README). LocalizationManager.PseudoLocalize(string) exposes the transform for strings that bypass L10NSharp.

Additive only — no behavior change for consumers that never request qps-ploc. 31 new tests pin the transform behaviors and the lookup/gating semantics.

Devin review

This change is

github-actions · 2026-08-22T04:54:12Z

Test Results

    7 files ±    0 144 suites +20 37s ⏱️ +2s
223 tests +  36 218 ✔️ +  36   5 💤 ±0 0 ❌ ±0
858 runs +144 843 ✔️ +144 15 💤 ±0 0 ❌ ±0

Results for commit 75db5a4. ± Comparison against base commit 18dd76e.

♻️ This comment has been updated with latest results.

andrew-polk · 2026-08-22T05:13:54Z

[Claude Fable 5] Consulted Devin on 2026-08-21 up to commit 139d6fe. Across three review rounds it raised two bugs — an English-over-pseudo preference edge (fixed in c436838 before it reached GitHub) and a null preferred-language-id crash (fixed in 139d6fe, thread, resolved) — plus 6 informational notes assessed as not actionable. Final re-review is clean: 0 bugs, 0 investigate flags. CI green on all checks.

andrew-polk · 2026-08-24T21:26:15Z

[Claude Fable 5] Consulted Devin on 2026-08-24 up to commit dd7f3a0 (the switch to the doubled-vowel transform). Re-review clean: 0 bugs, 0 investigate flags, 7 informational notes assessed as not actionable. CI green on all checks.

andrew-polk · 2026-08-24T21:55:11Z

[Claude Fable 5] Consulted Devin on 2026-08-24 up to commit b5b346d. Re-review clean: 0 bugs, 0 investigate flags, 9 informational notes assessed as not actionable. CI green on all checks.

andrew-polk · 2026-08-25T21:16:49Z

[Claude Fable 5] Consulted Devin on 2026-08-24 up to commit 303b495 (the WinForms designer-path fix and the master merge). Re-review clean: 0 bugs, 0 investigate flags, 9 informational notes assessed as not actionable. CI green on all checks.

imnasnainaec

Looks good. Lots of ⛏️ nitpicks, some inspired from Devin informational flags, other from me looking for over-wordy prose. All optional: worth a moment of consideration, but take-or-leave as you like.

@imnasnainaec reviewed 5 files and all commit messages, and made 13 comments.
Reviewable status: 5 of 12 files reviewed, 13 unresolved discussions (waiting on andrew-polk).

CHANGELOG.md line 24 at r2 (raw file):

- [L10NSharp] Added `net8.0` as a target framework, enabling use on non-Windows platforms, and added cross-platform CI/CD coverage for `net8.0`.
- [L10NSharp] Added UiLanguageChanged event to ILocalizationManager. This provides a way for clients to deal with changes now that (in Windows) LocalizeItemDlg<XLiffDocument>.StringsLocalized no longer exists.
- [L10NSharp] Added pseudolocalization support: any lookup for the standard `qps-ploc` pseudo-locale (`LocalizationManager.PseudoLocalizationLanguageId`) returns the English text pseudolocalized at runtime — every vowel doubled with an accent on the first of the pair, wrapped in brackets (e.g. `[Tîitlée Mîissîing]`) — so testers can spot non-internationalized strings and layout problems. No translation files exist or are created for it. Set `LocalizationManager.OfferPseudoLocalization = true` to include it in `GetAvailableLocalizedLanguages()`/`GetUILanguages()`; `LocalizationManager.PseudoLocalize(string)` exposes the transform directly. The transform is self-contained (its placeholder/markup-skipping logic was adapted from the MIT-licensed PseudoLocalizer project — see `src/L10NSharp/Pseudo/README.md`), so no new package dependency is added.

⛏️ This CHANGELOG entry perhaps gives more details than necessary.

src/L10NSharp/L10NCultureInfo.cs line 115 at r2 (raw file):

				EnglishName = "Pseudo-English (qps-ploc)";
				DisplayName = EnglishName;
				NativeName = EnglishName;

⛏️ This sets the four name fields but leaves TwoLetterISOLanguageName, ThreeLetterISOLanguageName, IetfLanguageTag, NumberFormat platform-dependent. Consider also pinning them here so the pseudo culture is identical everywhere.

src/L10NSharp/LocalizationManagerInternal.cs line 391 at r2 (raw file):

		{
			if (LocalizationManager.IsPseudoLanguageId(lang))
				lang = LocalizationManager.kDefaultLang; // pseudo is exactly as complete as English

⛏️ This

if (LocalizationManager.IsPseudoLanguageId(lang))
    lang = LocalizationManager.kDefaultLang; // pseudo is exactly as complete as English

could also be added to FractionApproved and FractionTranslated for consistency and future-proofing (though not strictly necessary now, by coincidence).

src/L10NSharp/LocalizationManagerInternal.cs line 497 at r2 (raw file):

		{
			if (string.IsNullOrWhiteSpace(id))
				return string.IsNullOrEmpty(englishText) ? string.Empty : englishText;

⛏️ When no managers are loaded, this early-exit only special-cases en, so a qps-ploc request falls through and the caller gets the raw string id instead of pseudolocalized text (even when englishText was supplied).

This doesn't match how GetString(...) was modified in this pr. Claude-suggest extension of the guard:

if (!string.IsNullOrEmpty(englishText))
{
    if (langId == LocalizationManager.kDefaultLang)
        return englishText;
    if (LocalizationManager.IsPseudoLanguageId(langId))
        return PseudoLocalization.Transform(englishText);
}
return id;

src/L10NSharp/LocalizationManagerInternal.cs line 526 at r2 (raw file):

					}

					return string.IsNullOrEmpty(englishText) ? id : englishText;

⛏️ The two instances of

					return string.IsNullOrEmpty(englishText) ? id : englishText;

could use PseudoLocalization.Transform when
IsPseudoLanguageId(langId), so pseudo mode stays visually obvious.

src/L10NSharp/LocalizationManagerInternal.cs line 536 at r2 (raw file):

			// caller-supplied englishText wins over the cache. Note that this never engages the
			// dynamic-string collection machinery below: no files exist or are written for the
			// pseudo-locale.

⛏️ Since not engaging dynamic-string collection is intended, it's probably worth adding a note to Pseudo/README.md, so devs won't rely on exercising the app to collect dynamic strings and be surprised when a pseudo run quietly produce nothing.

src/L10NSharp/Pseudo/EscapeHelpers.cs line 20 at r2 (raw file):

				int j = i;

				while (j < array.Length - 1 && IsPlaceholderNameChar(array[++j]))

⛏️ The name scan accepts only letters/digits/underscore plus an optional:format, so a placeholder with an alignment segment (e.g., {name,10}) or a space in the name (e.g., {first name}) fails the closing } check and gets pseudolocalized character by character.

Consuming an optional ,alignment segment (and anything up to } after the name) would close the gap in a couple of lines and keep the parser's fail-open behavior for genuinely malformed braces.

src/L10NSharp/Pseudo/PseudoLocalization.cs line 9 at r2 (raw file):

	/// untouched. E.g. "Title Missing" becomes "[Tîitlée Mîissîing]". The transform is
	/// deterministic, and self-contained in this folder (see its README.md), so L10NSharp
	/// carries no extra dependency for this feature.

⛏️ The last sentence in this summary feels unnecessary here.

src/L10NSharp/Pseudo/README.md line 28 at r2 (raw file):

and others. Earlier iterations of this feature (see git history) used the full accent map
and per-word padding of the PseudoLocalizer project, which we used as a starting point but
replaced for readability.

⛏️ Some of the latter half of the "Design notes:" paragraph feels unnecessary.

src/L10NSharp/Pseudo/README.md line 34 at r2 (raw file):

`EscapeHelpers` (the placeholder/markup-skipping logic) is adapted from the MIT-licensed
[PseudoLocalizer](https://github.com/martincostello/Pseudolocalizer) project, Copyright (C)
2012, Anders Kaplan, and extended here to also recognize `%0`-style and named

⛏️ The license/copyright detail in this Provenance sentence is unnecessary, given the full license copied below (though the author's name is probably nice to have in this prose.

src/L10NSharp/XLiffUtils/XliffLocalizationManager.cs line 513 at r2 (raw file):

			// the English entry. Doing it here rather than only in GetLocalizedString matters
			// because the WinForms component localizers (which set the Text of designer-created
			// controls, tool strip items and column headers) call straight into the string cache;

⛏️ This parenthetical may be unnecessary.

src/L10NSharp.Tests/PseudoLocalizationTests.cs line 302 at r2 (raw file):

		/// <summary>
		/// The WinForms component localizers -- what sets the Text of controls, tool strip items
		/// and column headers created in the designer -- read the string cache directly rather

⛏️ This -- aside may be unnecessary.

andrew-polk

@andrew-polk+AI made 12 comments and resolved 12 discussions.
Reviewable status: 4 of 13 files reviewed, 1 unresolved discussion (waiting on andrew-polk and imnasnainaec).

CHANGELOG.md line 24 at r2 (raw file):