google-spreadsheet-translation-sync 1.3.5 → 1.3.6

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "google-spreadsheet-translation-sync",
-  "version": "1.3.5",
+  "version": "1.3.6",
   "description": "A plugin to read and write i18n translationsfrom and to google spreadsheets ",
   "main": "index.js",
   "scripts": {
-    "test": "mocha --reporter spec"
+    "test": "mocha --reporter spec",
+    "build": "grunt build"
   },
   "repository": {
     "type": "git",

package/src/handler.js

@@ -1,6 +1,5 @@
 'use strict'
 
-
 /**
  *
  * @param translationFormat
@@ -13,6 +12,8 @@ module.exports.getHandler = function (translationFormat) {
   switch (translationFormat) {
     default:
       throw new Error('No handler available for the translation format ' + translationFormat);
+    case TRANSLATION_FORMATS.JSON_STRUCTURE:
+      return require('./handlers/json_structure');
     case TRANSLATION_FORMATS.LOCALE_JSON:
       return require('./handlers/locale_json');
     case TRANSLATION_FORMATS.GETTEXT:

package/src/handlers/json_structure.js

@@ -0,0 +1,116 @@
+'use strict'
+
+const fs = require('fs');
+const withoutError = require('../helpers').withoutError
+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) {
+                callback(err ? {} : JSON.parse(data));
+            })
+        }
+    });
+}
+
+/**
+ * A wrapper to return a flat key: value object structure, used for uploading
+ * @param {string} filePath
+ * @param {function} callback
+ */
+module.exports.getTranslationKeys = function (filePath, callback) {
+    const result = {};
+
+    const keyFlattener = function(structure, prefix) {
+        prefix = prefix || '';
+
+        Object.keys(structure).forEach((key) => {
+
+            const subStructure = structure[key];
+
+            if (typeof subStructure === 'object' && subStructure !== null && subStructure !== undefined) {
+                keyFlattener(subStructure, prefix + key + '.');
+            } else {
+                result[prefix + key] = subStructure;
+            }
+        })
+
+    }
+
+    this.loadTranslationFile(filePath, (parsedObject) => {
+        keyFlattener(parsedObject);
+        callback(result);
+    });
+}
+
+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.JSON_STRUCTURE, namespace, locale, options);
+                const file = path.resolve(translationRootFolder + '/' + localeFileName);
+
+                mod.loadTranslationFile(file, function (translations) {
+                    const potentiallyUpdatedTranslations = translationData[locale][namespace];
+
+                    Object.keys(potentiallyUpdatedTranslations).forEach((key) => {
+                        const parts = key.split('.');
+                        let tree = translations;
+
+                        while (parts.length > 0) {
+                            const part = parts.shift();
+
+                            if (parts.length === 0) {
+                                tree[part] = potentiallyUpdatedTranslations[key];
+                            } else {
+                                if (!tree[part]) {
+                                    tree[part] = {}
+                                }
+
+                                tree = tree[part];
+                            }
+                        }
+                    });
+
+                    // now we write
+                    fs.writeFile(file, JSON.stringify(translations, null, 4), function (err) {
+                        if (withoutError(err)) {
+                            // console.info('Updated translations of %o', localeFileName);
+                        }
+                        done2();
+                    })
+                })
+            }, function () {
+                done();
+            })
+
+        } else {
+            done();
+        }
+    }, function (err) {
+        if (withoutError(err, callback)) {
+            callback(null);
+        }
+    });
+
+
+}

package/src/util/constraints.js

@@ -1,5 +1,6 @@
 const formats = {
-  LOCALE_JSON: 'locale_json',
+  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',
   PROPERTIES: 'properties',
   YAML: 'yml'

package/src/util/file-utils.js

@@ -19,6 +19,7 @@ module.exports.buildTranslationFileName = function (format, namespace, locale, o
       throw new Error('Unknown extension for translation format ' + format);
       break;
     case constraints.TRANSLATION_FORMATS.LOCALE_JSON:
+    case constraints.TRANSLATION_FORMATS.JSON_STRUCTURE:
       extension = 'json';
       break;
     case constraints.TRANSLATION_FORMATS.GETTEXT:

package/test/test.js

@@ -21,6 +21,10 @@ const timeout = 20000;
 var tmpFile = tmp.fileSync({postfix: '.csv'});
 
 const csv = require('fast-csv');
+const fileUtils = require("../src/util/file-utils");
+const yamlHandler = require("../src/handlers/yaml");
+const rimraf = require("rimraf");
+const yaml = require("js-yaml");
 const testFile = tmpFile.name;
 const csvData = [
   ['key', 'default', 'de', 'it', 'fr', 'pl', 'hu'],
@@ -53,8 +57,8 @@ function ensureFolder (folder) {
 }
 
 
-// const testFor = 'all' // 'connect', 'upload', 'import', 'properties', 'locale_json', 'gettext', 'yml'
-// const testFor = 'yml';
+// const testFor = 'all' // 'connect', 'upload', 'import', 'properties', 'locale_json', 'gettext', 'yml', 'json_structure'
+// const testFor = 'json_structure';
 const testFor = 'all';
 
 const tests = [
@@ -514,6 +518,118 @@ const tests = [
       });
     }
   },
+
+  {
+    name: 'should upload changes in the json_structure test project',
+    run: ['upload', 'json_structure'],
+    fnc: function (done) {
+      this.timeout(timeout);
+
+      const baseName = 'messages';
+
+      const options = {
+        translationFormat: 'json_structure',
+        fileBaseName: baseName,
+        keyId: csvData[0][0],
+        gid: 0,
+        namespaceSeparator: '.',
+        spreadsheetId: testSheetId,
+        credentials: accessData
+      }
+
+      const files = [];
+
+      const tempFolder = tmp.dirSync({prefix: 'trans-dyn-to-update'});
+      const handler = require('../src/handlers/json_structure');
+      const fileUtils = require('../src/util/file-utils');
+
+      const data = {};
+
+      csvData[0].forEach( function (key, index) {
+
+        if (index > 0) {
+          data[key] = {default: {}}
+          csvData.forEach(function (lines, i) {
+            if (i > 0 && lines[index]) {
+              data[key].default[lines[0]] = lines[index];
+            }
+          });
+          files.push(tempFolder.name + '/' + fileUtils.buildTranslationFileName(options.translationFormat, null, key, options));
+        }
+      });
+
+      handler.updateTranslations(data, tempFolder.name, options, () => {
+
+        app.exportToSpreadsheet(files, options, function (err) {
+          const rimraf = require("rimraf");
+          expect(err).to.be.null;
+
+          if (!err) {
+            connector(options.spreadsheetId, options.gid, accessData, function (err, sheet) {
+              expect(err).to.be.null;
+              expect(sheet).to.be.an('object');
+
+              sheet.getRows({
+                offset: 0,
+                limit: csvData.length - 1
+              }).then(function (rows) {
+                expect(rows).to.have.lengthOf(csvData.length - 1);
+                expect(rows[0][options.keyId]).to.equal(csvData[1][0]);
+                expect(rows[0].pl).to.equal(csvData[1][5]);
+                expect(rows[0].default).to.equal(csvData[1][1]);
+                expect(rows[0].hu).to.equal('Elfogadom'); // this was not part of the upload and should not be overwrittem
+                expect(rows[1].default).to.equal(csvData[2][1]);
+                expect(rows[1].de).to.equal(csvData[2][2]);
+                expect(rows[1].key).to.equal(csvData[2][0]);
+                rimraf.sync(tempFolder.name);
+                done()
+              })
+            })
+          } else {
+            rimraf.sync(tempFolder.name);
+            done()
+          }
+        })
+      });
+    }
+  },
+
+  {
+    name: 'should import updated json_structure keys from the test project',
+    run: ['import', 'json_structure'],
+    fnc: function (done) {
+      this.timeout(timeout);
+
+      const baseName = 'messages';
+
+      const options = {
+        translationFormat: 'json_structure',
+        fileBaseName: baseName,
+        namespaceSeparator: '.',
+        spreadsheetId: testSheetId_yaml,
+        credentials: accessData
+      };
+
+      const translationRoot = ensureFolder(path.resolve('./test/translations/' + options.translationFormat + '/'));
+      const testFile = path.resolve(translationRoot + '/' + baseName + '.en.json');
+
+      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 translations = require(testFile);
+
+          expect(translations.add_address).to.equal("Add new address");
+          expect(translations.additional.news).to.equal("Additional News");
+        }
+        done();
+      });
+    }
+  },
 ];