google-spreadsheet-translation-sync 1.3.19 → 1.4.1

package/README.md

@@ -65,6 +65,12 @@ Default value: 'default'
 
 If no locale is provided or could be parsed, the defaultLocaleName is used instead.
 
+#### options.defaultFallback
+Type: `Boolean`   
+Default value: `false`
+
+Fills empty collumns automatically with the value from the defaultLocale - usefull if always complete translations have to be provided per file.
+
 #### options.fileBaseName
 Type: `String`    
 Default value: (empty string)    
@@ -95,6 +101,7 @@ Possible Values:
 * `locale_json` (translations are stored in simple key/value json files)
 * `json_structure` (translations are stored in a json tree, where the keys are split by the . character)
 * `gettext` (utilizes [node gettext-parser](https://github.com/smhg/gettext-parser) for the work with po and mo files)
+* `wordpress` (utilizes [node gettext-parser](https://github.com/smhg/gettext-parser) for the work with po and mo files) and adds additionally the new wordpress 6.5+ `.l10n.php` structure for faster parsing
 * `properties` (utilizes [propertie-reader](https://github.com/steveukx/properties) for java property files)
 * `yml` (utilizes [js-yaml](https://github.com/nodeca/js-yaml) for symfony yaml translation files)
 Default value: `locale_json`

package/index.js

@@ -1,5 +1,10 @@
 'use strict'
 
+/**
+ * The options type
+ * @typedef {{translationFormat: string, mode: string, spreadsheetId: string, gid : string, credentials: {}, keyId: string, fileBaseName: string, namespaces: boolean, defaultLocaleName: string, defaultFallback: boolean}} OptionsObject
+ */
+
 /**
  * Adds commas to a number
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-spreadsheet-translation-sync",
-  "version": "1.3.19",
+  "version": "1.4.1",
   "description": "A plugin to read and write i18n translationsfrom and to google spreadsheets ",
   "main": "index.js",
   "scripts": {

package/src/export-to-spreadsheet.js

@@ -5,7 +5,7 @@
 
 /**
  * @param {[]} translationFiles - an array of files
- * @param {{translationFormat: string, mode: string, spreadsheetId: string, gid : string, credentials: {}, keyId: string, fileBaseName: string, namespaces: boolean, defaultLocaleName: string}} options
+ * @param {OptionsObject} options
  * @param {function} callback
  */
 module.exports = function (translationFiles, options, callback) {

package/src/handler.js

@@ -23,5 +23,7 @@ module.exports.getHandler = function (translationFormat) {
     case 'yaml':
     case TRANSLATION_FORMATS.YAML:
       return require('./handlers/yaml');
+    case TRANSLATION_FORMATS.WORDPRESS:
+      return require('./handlers/wordpress');
   }
 }

package/src/handlers/wordpress.js

@@ -0,0 +1,173 @@
+'use strict'
+
+const fs = require('fs');
+const withoutError = require('../helpers').withoutError
+const gettextParser = require("gettext-parser");
+const constraints = require('../util/constraints');
+
+
+module.exports.loadTranslationFile = function (filePath, callback) {
+
+    fs.access(filePath, function (err) {
+
+        if (err) {
+            callback({}); // we return the empty json
+        } else {
+
+            fs.readFile(filePath, function (err, data) {
+
+                if (err) {
+                    callback({});
+                } else {
+                    callback(gettextParser.po.parse(data));
+                }
+            })
+        }
+    });
+}
+
+/**
+ * A wrapper to return a flat key: value object structure, used for uploading
+ * @param filePath
+ * @param callback
+ */
+module.exports.getTranslationKeys = function (filePath, callback) {
+
+    const translations = {};
+
+    this.loadTranslationFile(filePath, function (parsedObj) {
+        if (parsedObj.translations) {
+            Object.keys(parsedObj.translations['']).forEach(function (key) {
+                translations[key] = parsedObj.translations[''][key].msgstr;
+            });
+        }
+
+        callback(translations);
+    })
+}
+
+
+module.exports.updateTranslations = function (translationData, translationRootFolder, options, callback) {
+    const path = require('path');
+    const async = require('async');
+    const mod = this;
+    const fileUtils = require('../util/file-utils');
+
+    if (! fs.existsSync(translationRootFolder)) {
+        throw new Error('The folder ' + translationRootFolder + ' does not exist');
+    }
+
+    async.each(Object.keys(translationData), function(locale, done) {
+
+        // is it a comment or a real translation?
+        if (locale.substr(0, constraints.commentCollumnName.length) !== constraints.commentCollumnName) {
+
+            async.each(Object.keys(translationData[locale]), function (namespace, done2) {
+
+                const localeFileName = fileUtils.buildTranslationFileName(constraints.TRANSLATION_FORMATS.GETTEXT, namespace, locale, options);
+                const file = path.resolve(translationRootFolder + '/' + localeFileName);
+                const moFile = path.resolve(translationRootFolder + '/' + localeFileName.replace('.po', '.mo'));
+                const phpFile = path.resolve(translationRootFolder + '/' + localeFileName.replace('.po', '.l10n.php'));
+
+                mod.loadTranslationFile(file, function (parsedObj) {
+
+                    // do we have a file?
+                    if (!parsedObj.translations) {
+                        parsedObj = {
+                            "charset": "UTF-8",
+
+                            "headers": {
+                                "content-type": "text/plain; charset=UTF-8",
+                                "plural-forms": "nplurals=2; plural=(n!=1);",
+                                "X-Generator": "node-google-spreadsheet-translation-sync",
+                                "Project-Id-Version": options.fileBaseName,
+                                "Language": locale
+                            },
+
+                            "translations": {
+                                "": {}
+                            }
+                        }
+                    }
+
+                    const potentiallyUpdatedTranslations = translationData[locale][namespace];
+
+                    if (potentiallyUpdatedTranslations) {
+                        // update our object
+                        Object.keys(potentiallyUpdatedTranslations).forEach(function (key, index) {
+                            if (!parsedObj.translations[''][key]) {
+                                parsedObj.translations[''][key] = {
+                                    "msgid": key,
+                                    "msgstr": [],
+                                    "comments": {}
+                                }
+                            }
+
+                            parsedObj.translations[''][key].msgstr[0] = potentiallyUpdatedTranslations[key];
+
+                            // do we have a comment?
+                            if (translationData[constraints.commentCollumnName] && translationData[constraints.commentCollumnName][key]) {
+                                if (!parsedObj.translations[''][key].comments) {
+                                    parsedObj.translations[''][key].comments = {};
+                                }
+
+                                parsedObj.translations[''][key].comments.translator = translationData[constraints.commentCollumnName][key];
+                            }
+                        });
+
+                        // now we write
+
+                        const output = gettextParser.po.compile(parsedObj, {sort: true});
+                        fs.writeFileSync(file, output);
+
+                        const mo = gettextParser.mo.compile(parsedObj);
+                        fs.writeFileSync(moFile, mo);
+
+                        // write the additional .i10n.php file
+
+                        if (fs.existsSync(phpFile)) {
+                            fs.unlinkSync(phpFile);
+                        }
+
+                        let phpContent = '<?php\n';
+                        phpContent += 'return [\n';
+
+                        Object.keys(parsedObj.headers).forEach((header) => {
+                            phpContent += `  "${header.toLocaleLowerCase()}" => ${JSON.stringify(parsedObj.headers[header])},\n`;
+                        })
+
+                        phpContent += `  "messages" => [\n`;
+
+                        Object.keys(parsedObj.translations['']).forEach((key) => {
+                            if (key) {
+                                phpContent += `    "${key}" => ${JSON.stringify(parsedObj.translations[''][key].msgstr[0])},\n`;
+                            }
+                        });
+
+                        phpContent += '  ]\n';
+                        phpContent += '];\n';
+
+                        fs.writeFileSync(phpFile, phpContent);
+
+                        // console.info('Updated translations of %o', localeFileName);
+                    } else {
+                        // console.info('Ignored unchanged %o', localeFileName);
+                    }
+
+                    done2();
+                });
+
+            }, function () {
+                done();
+            })
+        } else {
+            done();
+        }
+    }, function (err) {
+        if (withoutError(err, callback)) {
+            callback(null);
+        }
+    });
+
+
+}

package/src/import-from-spreadsheet.js

@@ -1,5 +1,10 @@
 'use strict'
-
+/**
+ *
+ * @param translationRootFolder
+ * @param {OptionsObject} options
+ * @param callback
+ */
 module.exports = function (translationRootFolder, options, callback) {
 
     const connector = require('./connector');
@@ -74,6 +79,26 @@ module.exports = function (translationRootFolder, options, callback) {
                         }
                     }
 
+                    if (options.defaultFallback) {
+
+                        const defaultLocale = options.defaultLocaleName || 'default';
+
+                        Object.keys(translationData).forEach(locale => {
+                            // use the default locale as reference
+                            Object.keys(translationData[defaultLocale]).forEach(namespace => {
+                                if (!translationData[locale][namespace]) {
+                                    translationData[locale][namespace] = {};
+                                }
+
+                                Object.keys(translationData[defaultLocale][namespace]).forEach(key => {
+                                    if (translationData[locale][namespace][key] === undefined) {
+                                        translationData[locale][namespace][key] = translationData[defaultLocale][namespace][key];
+                                    }
+                                });
+                            });
+                        });
+                    }
+
                     // now we get the handler
                     const h = require('./handler');
                     const TRANSLATION_FORMATS = require('./util/constraints').TRANSLATION_FORMATS;

package/src/util/constraints.js

@@ -2,6 +2,7 @@ const formats = {
   LOCALE_JSON: 'locale_json', // just a plain array - lorem.ipsum keys will be {'lorem.ipsum': 'whatever'}
   JSON_STRUCTURE: 'json_structure', // lorem.ipsum keys will be converted into a json structure: {lorem: {ipsum: 'whatever'}}
   GETTEXT: 'gettext',
+  WORDPRESS: 'wordpress',
   PROPERTIES: 'properties',
   YAML: 'yml'
 };

package/test/test.js

@@ -53,8 +53,8 @@ function ensureFolder (folder) {
 }
 
 
-// const testFor = 'all' // 'connect', 'upload', 'import', 'properties', 'locale_json', 'gettext', 'yml', 'json_structure'
-// const testFor = 'json_structure';
+// const testFor = 'all' // 'connect', 'upload', 'import', 'properties', 'locale_json', 'gettext', 'yml', 'json_structure', 'wordpress'
+// const testFor = 'gettext';
 const testFor = 'all';
 
 const tests = [
@@ -370,6 +370,74 @@ const tests = [
     }
   },
 
+  {
+    name: 'should import updated wordpress keys in the test project',
+    run: ['import', 'wordpress'],
+    fnc: function (done) {
+      this.timeout(timeout);
+
+      const baseName = 'karmapa-chenno';
+
+      const options = {
+        translationFormat: 'wordpress',
+        fileBaseName: baseName,
+        spreadsheetId: testSheetId_gettext,
+        credentials: accessData
+      };
+
+      const translationRoot = ensureFolder(path.resolve('./test/translations/' + options.translationFormat + '/'));
+      const testFile = path.resolve(translationRoot + '/' + baseName + '-en.po');
+      const testFilePhp = path.resolve(translationRoot + '/' + baseName + '-en.l10n.php');
+      const testFilePl = path.resolve(translationRoot + '/' + baseName + '-pl.po');
+
+      app.importFromSpreadsheet(translationRoot, options, function (err) {
+        expect(err).to.be.null
+
+        if (!err) {
+          const fs = require('fs');
+
+          expect(fs.existsSync(testFile)).to.equal(true);
+
+          const po = require('gettext-parser').po.parse(fs.readFileSync(testFile));
+          const poPl = require('gettext-parser').po.parse(fs.readFileSync(testFilePl));
+          const translations = po.translations[''];
+          const translationsPl = poPl.translations[''];
+          expect(translations.add_address.msgstr[0]).to.equal("Add new address");
+          expect(translationsPl['additional.news'].msgstr[0]).to.equal('czecz 2242');
+          expect(translationsPl.add_address).to.be.undefined;
+
+          const phpContent = fs.readFileSync(testFilePhp).toString();
+
+          expect(phpContent).to.equal('<?php\n' +
+              'return [\n' +
+              '  "content-type" => "text/plain; charset=utf-8",\n' +
+              '  "plural-forms" => "nplurals=2; plural=(n!=1);",\n' +
+              '  "x-generator" => "node-google-spreadsheet-translation-sync",\n' +
+              '  "project-id-version" => "karmapa-chenno",\n' +
+              '  "language" => "en",\n' +
+              '  "messages" => [\n' +
+              '    "add_address" => "Add new address",\n' +
+              '    "add_as_favourite" => "Add to Quick Contacts",\n' +
+              '    "add_center" => "Add Center",\n' +
+              '    "add_contact" => "Add contact",\n' +
+              '    "add_phone_number" => "Add new phone",\n' +
+              '    "additional.news" => "Additional News",\n' +
+              '    "administration" => "Administration",\n' +
+              '    "administration_info" => "This page allows you to access functions connected to Members, Centers, Roles and Groups.",\n' +
+              '    "all" => "All",\n' +
+              '    "all_centers" => "All Centers",\n' +
+              '    "all_contacts" => "All contacts",\n' +
+              '    "some.key" => "a Key 370",\n' +
+              '  ]\n' +
+              '];\n');
+
+        }
+
+        done();
+      });
+    }
+  },
+
   {
     name: 'should import updated gettext keys in the test project',
     run: ['import', 'gettext'],
@@ -403,6 +471,49 @@ const tests = [
           const translationsPl = poPl.translations[''];
           expect(translations.add_address.msgstr[0]).to.equal("Add new address");
           expect(translationsPl['additional.news'].msgstr[0]).to.equal('czecz 2242');
+          expect(translationsPl.add_address).to.be.undefined;
+        }
+
+        done();
+      });
+    }
+  },
+
+  {
+    name: 'should fill empty columns with the default',
+    run: ['import', 'gettext'],
+    fnc: function (done) {
+      this.timeout(timeout);
+
+      const baseName = 'om-mani-peme';
+
+      const options = {
+        translationFormat: 'gettext',
+        fileBaseName: baseName,
+        spreadsheetId: testSheetId_gettext,
+        credentials: accessData,
+        defaultLocaleName: 'en',
+        defaultFallback: true
+      };
+
+      const translationRoot = ensureFolder(path.resolve('./test/translations/' + options.translationFormat + '/'));
+      const testFile = path.resolve(translationRoot + '/' + baseName + '-en.po');
+      const testFileDe = path.resolve(translationRoot + '/' + baseName + '-de.po');
+
+      app.importFromSpreadsheet(translationRoot, options, function (err) {
+        expect(err).to.be.null
+
+        if (!err) {
+          const fs = require('fs');
+
+          expect(fs.existsSync(testFile)).to.equal(true);
+
+          const po = require('gettext-parser').po.parse(fs.readFileSync(testFile));
+          const poDe = require('gettext-parser').po.parse(fs.readFileSync(testFileDe));
+          const translations = po.translations[''];
+          const translationsDe = poDe.translations[''];
+          expect(translations['additional.news'].msgstr[0]).to.equal("Additional News");
+          expect(translationsDe['additional.news']?.msgstr[0]).to.equal('Additional News');
         }
 
         done();