google-spreadsheet-translation-sync 1.3.4 → 1.3.8

package/Gruntfile.js

@@ -75,7 +75,7 @@ module.exports = function(grunt) {
     shell: {
       publish_npm: {
         command: [
-            'npmrc public', // well, this is at the moment hardcoded to my personal public registry name
+            // 'npmrc public', // well, this is at the moment hardcoded to my personal public registry name
             'npm publish'
         ].join('&&')
       },

package/README.md

@@ -86,6 +86,7 @@ If `namespaces` or `fileBaseName` is used, this is the separating character. For
 Type: `Enum`   
 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)
 * `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)

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "google-spreadsheet-translation-sync",
-  "version": "1.3.4",
+  "version": "1.3.8",
   "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",
@@ -48,7 +49,7 @@
     "google-spreadsheet": "^3.0.11",
     "js-yaml": "^4.1.0",
     "mkdirp": "^0.5.5",
-    "properties-reader": "github:Andreas-Schoenefeldt/properties#master",
+    "properties-reader": "^2.2.0",
     "shelljs": "^0.7.8",
     "tmp": "^0.1.0"
   }

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,107 @@
+'use strict'
+
+const fs = require('fs');
+const withoutError = require('../helpers').withoutError
+const constraints = require('../util/constraints');
+const {resolveStructureToTree} = require("../util/structure-utils");
+
+
+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) {
+
+                const existingTranslations = err ? {} : JSON.parse(data);
+                const cleanResult = {};
+
+                resolveStructureToTree(cleanResult, existingTranslations);
+
+                callback(cleanResult);
+            })
+        }
+    });
+}
+
+/**
+ * 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];
+
+                    resolveStructureToTree(translations, potentiallyUpdatedTranslations);
+
+                    // 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/handlers/properties.js

@@ -46,7 +46,7 @@ module.exports.updateTranslations = function (translationData, translationRootFo
           fs.writeFileSync(file, '');
         }
 
-        const props = PropertiesReader(file, {write_sections: false});
+        const props = PropertiesReader(file, 'utf-8', { writer: { saveSections: false } });
         const potentiallyUpdatedTranslations = translationData[locale][namespace];
 
         Object.keys(potentiallyUpdatedTranslations).forEach(function (key) {

package/src/handlers/yaml.js

@@ -2,6 +2,7 @@ const fs = require("fs");
 const yaml = require('js-yaml');
 const constraints = require("../util/constraints");
 const {withoutError} = require("../helpers");
+const {resolveStructureToTree} = require("../util/structure-utils");
 
 module.exports.loadTranslationFile = function (filePath, callback) {
     if (fs.existsSync(filePath)) {
@@ -65,24 +66,7 @@ module.exports.updateTranslations = function (translationData, translationRootFo
                 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];
-                            }
-                        }
-                    });
+                    resolveStructureToTree(translations, potentiallyUpdatedTranslations);
 
                     // now we write
                     fs.writeFile(file, yaml.dump(translations, {indent: 4}), function (err) {

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/src/util/structure-utils.js

@@ -0,0 +1,27 @@
+module.exports.resolveStructureToTree = (originalTree, potentialTreeUpdates) => {
+
+    Object.keys(potentialTreeUpdates).forEach((key) => {
+        const parts = key.split('.');
+        let tree = originalTree;
+
+        // remove the full key, if present
+        if (originalTree[key]) {
+            delete originalTree[key];
+        }
+
+        // add it again in a clean fassion
+        while (parts.length > 0) {
+            const part = parts.shift();
+
+            if (parts.length === 0) {
+                tree[part] = potentialTreeUpdates[key];
+            } else {
+                if (!tree[part]) {
+                    tree[part] = {}
+                }
+
+                tree = tree[part];
+            }
+        }
+    })
+}

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 = [
@@ -154,7 +158,7 @@ const tests = [
               file: propertiesFile,
               namespace: namespace,
               locale: key,
-              reader: PropertiesReader(propertiesFile, {write_sections: false})
+              reader: PropertiesReader(propertiesFile, 'utf-8', { writer: { saveSections: false } })
             }
 
             csvData.forEach(function (lines, i) {
@@ -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();
+      });
+    }
+  },
 ];