fallback properly with pluralized strings (#7495)

Signed-off-by: Kerry Archibald <kerrya@element.io>

src/languageHandler.tsx

@@ -41,6 +41,7 @@ counterpart.setSeparator('|');
 
 // see `translateWithFallback` for an explanation of fallback handling
 const FALLBACK_LOCALE = 'en';
+counterpart.setFallbackLocale(FALLBACK_LOCALE);
 
 interface ITranslatableError extends Error {
     translatedMessage: string;
@@ -79,12 +80,12 @@ export function _td(s: string): string { // eslint-disable-line @typescript-esli
  * should be wrapped with an appropriate `lang='en'` attribute
  * counterpart's `translate` doesn't expose a way to determine if the resulting translation
  * is in the target locale or a fallback locale
- * for this reason, we do not set a fallback via `counterpart.setFallbackLocale`
+ * for this reason, force fallbackLocale === locale in the first call to translate
  * and fallback 'manually' so we can mark fallback strings appropriately
  * */
 const translateWithFallback = (text: string, options?: object): { translated?: string, isFallback?: boolean } => {
-    const translated = counterpart.translate(text, options);
+    const translated = counterpart.translate(text, { ...options, fallbackLocale: counterpart.getLocale() });
-    if (/^missing translation:/.test(translated)) {
+    if (!translated || /^missing translation:/.test(translated)) {
         const fallbackTranslated = counterpart.translate(text, { ...options, locale: FALLBACK_LOCALE });
         return { translated: fallbackTranslated, isFallback: true };
     }

test/i18n-test/languageHandler-test.tsx

@@ -118,7 +118,7 @@ describe('languageHandler', function() {
         });
     });
 
-    describe('when a translation string does not exist in active language', () => {
+    describe('for a non-en language', () => {
         beforeEach(async () => {
             stubClient();
             await setLanguage('lv');
@@ -130,33 +130,75 @@ describe('languageHandler', function() {
             setMissingEntryGenerator(counterpartDefaultMissingEntryGen);
         });
 
+        // mocked lv has only `"Uploading %(filename)s and %(count)s others|one"`
         const lvExistingPlural = 'Uploading %(filename)s and %(count)s others';
+        const lvNonExistingPlural = '%(spaceName)s and %(count)s others';
 
-        // lv does not have a pluralizer function
+        describe('pluralization', () => {
-        const noPluralizerCase = [
+            const pluralCases = [
-            'handles plural strings when no pluralizer exists for language',
+                [
-            lvExistingPlural,
+                    'falls back when plural string exists but not for for count',
-            { count: 1, filename: 'test.txt' },
+                    lvExistingPlural,
-            undefined,
+                    { count: 2, filename: 'test.txt' },
-            'Uploading test.txt and 1 other',
+                    undefined,
-        ] as TestCase;
+                    'Uploading test.txt and 2 others',
+                ],
+                [
+                    'falls back when plural string does not exists at all',
+                    lvNonExistingPlural,
+                    { count: 2, spaceName: 'test' },
+                    undefined,
+                    'test and 2 others',
+                ],
+            ] as TestCase[];
 
-        describe('_t', () => {
+            describe('_t', () => {
-            it.each([...testCasesEn, noPluralizerCase])(
+                it('translated correctly when plural string exists for count', () => {
-                "%s and translates with fallback locale",
+                    expect(_t(
-                async (_d, translationString, variables, tags, result) => {
+                        lvExistingPlural,
-                    expect(_t(translationString, variables, tags)).toEqual(result);
+                        { count: 1, filename: 'test.txt' }, undefined)).toEqual('Качване на test.txt и 1 друг');
-                },
+                });
-            );
+                it.each(pluralCases)(
+                    "%s",
+                    async (_d, translationString, variables, tags, result) => {
+                        expect(_t(translationString, variables, tags)).toEqual(result);
+                    },
+                );
+            });
+
+            describe('_tDom()', () => {
+                it('translated correctly when plural string exists for count', () => {
+                    expect(_tDom(
+                        lvExistingPlural,
+                        { count: 1, filename: 'test.txt' }, undefined)).toEqual('Качване на test.txt и 1 друг');
+                });
+                it.each(pluralCases)(
+                    "%s and translates with fallback locale, attributes fallback locale",
+                    async (_d, translationString, variables, tags, result) => {
+                        expect(_tDom(translationString, variables, tags)).toEqual(<span lang="en">{ result }</span>);
+                    },
+                );
+            });
         });
 
-        describe('_tDom()', () => {
+        describe('when a translation string does not exist in active language', () => {
-            it.each([...testCasesEn, noPluralizerCase])(
+            describe('_t', () => {
-                "%s and translates with fallback locale, attributes fallback locale",
+                it.each(testCasesEn)(
-                async (_d, translationString, variables, tags, result) => {
+                    "%s and translates with fallback locale",
-                    expect(_tDom(translationString, variables, tags)).toEqual(<span lang="en">{ result }</span>);
+                    async (_d, translationString, variables, tags, result) => {
-                },
+                        expect(_t(translationString, variables, tags)).toEqual(result);
-            );
+                    },
+                );
+            });
+
+            describe('_tDom()', () => {
+                it.each(testCasesEn)(
+                    "%s and translates with fallback locale, attributes fallback locale",
+                    async (_d, translationString, variables, tags, result) => {
+                        expect(_tDom(translationString, variables, tags)).toEqual(<span lang="en">{ result }</span>);
+                    },
+                );
+            });
         });
     });
 });