Add missing translations at build time

Author: lfabreges

demo/app/i18n/fr.json

@@ -0,0 +1,5 @@
+{
+  "hello": {
+    "world": "Bonjour le monde !"
+  }
+}

hooks/converter.android.ts

@@ -1,23 +1,14 @@
 import * as fs from "fs";
 import * as path from "path";
 
-import { ConverterCommon, I18nEntry, SupportedLanguages } from "./converter.common";
+import { ConverterCommon, I18nEntries, SupportedLanguages } from "./converter.common";
 import { encodeKey, encodeValue } from "../src/resource.android";
 
 export class ConverterAndroid extends ConverterCommon {
   protected cleanObsoleteResourcesFiles(resourcesDirectory: string, supportedLanguages: SupportedLanguages): this {
     fs.readdirSync(resourcesDirectory).filter(fileName => {
-      const match = /^values(?:-(.+))?$/.exec(fileName);
-      if (!match) {
-        return false;
-      } else if (match[1]) {
-        return !supportedLanguages.has(match[1]);
-      } else {
-        for (const [language, isDefaultLanguage] of supportedLanguages) {
-          if (isDefaultLanguage) { return false; }
-        }
-        return true;
-      }
+      const match = /^values-(.+)$/.exec(fileName);
+      return match && !supportedLanguages.has(match[1]);
     }).map(fileName => {
       return path.join(resourcesDirectory, fileName);
     }).filter(filePath => {
@@ -35,23 +26,23 @@ export class ConverterAndroid extends ConverterCommon {
   protected createLanguageResourcesFiles(
     language: string,
     isDefaultLanguage: boolean,
-    i18nContentIterator: Iterable<I18nEntry>
+    i18nEntries: I18nEntries
   ): this {
     const languageResourcesDir = path.join(
       this.appResourcesDirectoryPath,
       `values${isDefaultLanguage ? "" : `-${language}`}`
     );
     this.createDirectoryIfNeeded(languageResourcesDir);
     let strings = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<resources>\n";
-    for (const { key, value } of i18nContentIterator) {
+    i18nEntries.forEach((value, key) => {
       const encodedKey = encodeKey(key);
       const encodedValue = encodeValue(value);
       strings += `  <string name="${encodedKey}">${encodedValue}</string>\n`;
       if (key === "app.name") {
         strings += `  <string name="app_name">${encodedValue}</string>\n`;
         strings += `  <string name="title_activity_kimera">${encodedValue}</string>\n`;
       }
-    }
+    });
     strings += "</resources>\n";
     const resourceFilePath = path.join(languageResourcesDir, "strings.xml");
     if (this.writeFileSyncIfNeeded(resourceFilePath, strings)) {

hooks/converter.common.ts

@@ -36,36 +36,79 @@ export abstract class ConverterCommon extends EventEmitter {
   protected abstract createLanguageResourcesFiles(
     language: string,
     isDefaultLanguage: boolean,
-    i18nContentIterator: Iterable<I18nEntry>
+    i18nEntries: I18nEntries
   ): this;
 
   public abstract livesyncExclusionPatterns(): string[];
 
+  public loadLangage(filePath: string): I18nEntries {
+    delete (<any>require).cache[(<any>require).resolve(filePath)];
+
+    const fileContent = require(filePath);
+    const i18nEntries: I18nEntries = new Map();
+    const stack = [{ prefix: "", element: fileContent }];
+
+    while (stack.length > 0) {
+      const { prefix, element } = stack.pop();
+      if (Array.isArray(element)) {
+        i18nEntries.set(prefix, element.join(""));
+      } else if (typeof element === "object") {
+        for (const key of Object.keys(element)) {
+          stack.push({ prefix: prefix === "" ? key : `${prefix}.${key}`, element: element[key] });
+        }
+      } else {
+        i18nEntries.set(prefix, new String(element).valueOf());
+      }
+    }
+
+    return i18nEntries;
+  }
+
   public run(): this {
     if (!fs.existsSync(this.i18nDirectoryPath)) {
-      this.logger.info(`'${this.i18nDirectoryPath}' doesn't exists: nothing to localize`);
+      this.logger.warn(`'${this.i18nDirectoryPath}' doesn't exists: nothing to localize`);
       return this;
     }
 
+    let defaultLanguage = undefined;
     const supportedLanguages: SupportedLanguages = new Map();
 
     fs.readdirSync(this.i18nDirectoryPath).map(fileName => {
       return path.join(this.i18nDirectoryPath, fileName);
     }).filter(filePath => {
       return fs.statSync(filePath).isFile();
-    }).map(filePath => {
-      delete (<any>require).cache[(<any>require).resolve(filePath)];
-      return filePath;
-    }).map(filePath => {
+    }).forEach(filePath => {
       let language = path.basename(filePath, path.extname(filePath));
-      const isDefaultLanguage = path.extname(language) === ".default";
-      if (isDefaultLanguage) { language = path.basename(language, ".default"); }
-      supportedLanguages.set(language, isDefaultLanguage);
-      this.createLanguageResourcesFiles(
-        language,
-        isDefaultLanguage,
-        this.i18nContentGenerator(require(filePath))
-      );
+      if (path.extname(language) === ".default") {
+        language = path.basename(language, ".default");
+        defaultLanguage = language;
+      }
+      supportedLanguages.set(language, filePath);
+    });
+
+    if (supportedLanguages.size === 0) {
+      this.logger.warn(`'${this.i18nDirectoryPath}' is empty: nothing to localize`);
+      return this;
+    }
+
+    if (!defaultLanguage) {
+      defaultLanguage = supportedLanguages.keys().next().value;
+      this.logger.warn(`No file found with the .default extension: default langage set to '${defaultLanguage}'`);
+    }
+
+    const defaultLanguageI18nEntries = this.loadLangage(supportedLanguages.get(defaultLanguage));
+    this.createLanguageResourcesFiles(defaultLanguage, true, defaultLanguageI18nEntries);
+
+    supportedLanguages.forEach((filePath, language) => {
+      if (language !== defaultLanguage) {
+        const languageI18nEntries = this.loadLangage(filePath);
+        defaultLanguageI18nEntries.forEach((value, key) => {
+          if (!languageI18nEntries.has(key)) {
+            languageI18nEntries.set(key, value);
+          }
+        });
+        this.createLanguageResourcesFiles(language, false, languageI18nEntries);
+      }
     });
 
     [this.appResourcesDirectoryPath, this.appResourcesDestinationDirectoryPath].forEach(resourcesDirectoryPath => {
@@ -77,22 +120,6 @@ export abstract class ConverterCommon extends EventEmitter {
     return this;
   }
 
-  public * i18nContentGenerator(i18nContent: any): Iterable<I18nEntry> {
-    const stack = [{ prefix: "", element: i18nContent }];
-    while (stack.length > 0) {
-      const { prefix, element } = stack.pop();
-      if (Array.isArray(element)) {
-        yield { key: prefix, value: element.join("") };
-      } else if (typeof element === "object") {
-        for (const key of Object.keys(element)) {
-          stack.push({ prefix: prefix === "" ? key : `${prefix}.${key}`, element: element[key] });
-        }
-      } else {
-        yield { key: <string>prefix, value: new String(element).valueOf() };
-      }
-    }
-  }
-
   protected createDirectoryIfNeeded(directoryPath: string): this {
     if (!fs.existsSync(directoryPath) || !fs.statSync(directoryPath).isDirectory()) { mkdirp.sync(directoryPath); }
     return this;
@@ -118,5 +145,5 @@ export abstract class ConverterCommon extends EventEmitter {
   }
 }
 
-export type I18nEntry = { key: string; value: string; };
-export type SupportedLanguages = Map<string, boolean>;
+export type I18nEntries = Map<string, string>;
+export type SupportedLanguages = Map<string, string>;

hooks/converter.ios.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as plist from "simple-plist";
 
-import { ConverterCommon, I18nEntry, SupportedLanguages } from "./converter.common";
+import { ConverterCommon, I18nEntries, SupportedLanguages } from "./converter.common";
 import { encodeKey, encodeValue } from "../src/resource.ios";
 
 export class ConverterIOS extends ConverterCommon {
@@ -30,27 +30,25 @@ export class ConverterIOS extends ConverterCommon {
   protected createLanguageResourcesFiles(
     language: string,
     isDefaultLanguage: boolean,
-    i18nContentIterator: Iterable<I18nEntry>
+    i18nEntries: I18nEntries
   ): this {
-    const localizableStrings: I18nEntry[] = [];
-    const infoPlistStrings: I18nEntry[] = [];
-    for (const { key, value } of i18nContentIterator) {
-      localizableStrings.push({ key, value });
+    const infoPlistStrings: I18nEntries = new Map();
+    i18nEntries.forEach((value, key) => {
       if (key === "app.name") {
-        infoPlistStrings.push({ key: "CFBundleDisplayName", value });
-        infoPlistStrings.push({ key: "CFBundleName", value });
+        infoPlistStrings.set("CFBundleDisplayName", value);
+        infoPlistStrings.set("CFBundleName", value);
       } else if (key.startsWith("ios.info.plist.")) {
-        infoPlistStrings.push({ key: key.substr(15), value });
+        infoPlistStrings.set(key.substr(15), value);
       }
-    }
+    });
     const languageResourcesDir = path.join(this.appResourcesDirectoryPath, `${language}.lproj`);
     this
       .createDirectoryIfNeeded(languageResourcesDir)
-      .writeStrings(languageResourcesDir, "Localizable.strings", localizableStrings, true)
+      .writeStrings(languageResourcesDir, "Localizable.strings", i18nEntries, true)
       .writeStrings(languageResourcesDir, "InfoPlist.strings", infoPlistStrings, false)
     ;
     if (isDefaultLanguage) {
-      infoPlistStrings.push({ key: "CFBundleDevelopmentRegion", value: language });
+      infoPlistStrings.set("CFBundleDevelopmentRegion", language);
       this.writeInfoPlist(infoPlistStrings);
     }
     return this;
@@ -66,34 +64,34 @@ export class ConverterIOS extends ConverterCommon {
   private writeStrings(
     languageResourcesDir: string,
     resourceFileName: string,
-    strings: I18nEntry[],
+    strings: I18nEntries,
     encodeKeys: boolean
   ): this {
     let content = "";
-    for (const { key, value } of strings) {
+    strings.forEach((value, key) => {
       content += `"${encodeKeys ? encodeKey(key) : key}" = "${encodeValue(value)}";\n`;
-    }
+    });
     const resourceFilePath = path.join(languageResourcesDir, resourceFileName);
     if (this.writeFileSyncIfNeeded(resourceFilePath, content)) {
       this.emit(ConverterCommon.RESOURCE_CHANGED_EVENT);
     }
     return this;
   }
 
-  private writeInfoPlist(infoPlistValues: I18nEntry[]) {
+  private writeInfoPlist(infoPlistValues: I18nEntries) {
     const resourceFilePath = path.join(this.appResourcesDirectoryPath, "Info.plist");
     if (!fs.existsSync(resourceFilePath)) {
       this.logger.warn(`'${resourceFilePath}' doesn't exists: unable to set default language`);
       return this;
     }
     const data = plist.readFileSync(resourceFilePath);
     let resourceChanged = false;
-    for (const { key, value } of infoPlistValues) {
+    infoPlistValues.forEach((value, key) => {
       if (!data.hasOwnProperty(key) || data[key] !== value) {
         data[key] = value;
         resourceChanged = true;
       }
-    }
+    });
     if (resourceChanged) {
       plist.writeFileSync(resourceFilePath, data);
       this.emit(ConverterCommon.CONFIGURATION_CHANGED_EVENT);