locize-cli 10.3.2 → 11.0.0

package/filterNamespaces.js

@@ -1,11 +1,11 @@
 const filterNamespaces = (opt, nss) => {
   if (opt.namespace) {
-    nss = nss.filter((ns) => ns.namespace === opt.namespace);
+    nss = nss.filter((ns) => ns.namespace === opt.namespace)
   }
   if (opt.namespaces && opt.namespaces.length > 0) {
-    nss = nss.filter((ns) => opt.namespaces.indexOf(ns.namespace) > -1);
+    nss = nss.filter((ns) => opt.namespaces.indexOf(ns.namespace) > -1)
   }
-  return nss;
-};
+  return nss
+}
 
-module.exports = filterNamespaces;
+module.exports = filterNamespaces

package/format.js

@@ -1,206 +1,206 @@
-const colors = require('colors');
-const fs = require('fs');
-const async = require('async');
-const path = require('path');
-const diff = require('diff');
-const convertToFlatFormat = require('./convertToFlatFormat');
-const convertToDesiredFormat = require('./convertToDesiredFormat');
-const sortFlatResources = require('./sortFlatResources');
-const formats = require('./formats');
-const fileExtensionsMap = formats.fileExtensionsMap;
-const acceptedFileExtensions = formats.acceptedFileExtensions;
-const reversedFileExtensionsMap = formats.reversedFileExtensionsMap;
+const colors = require('colors')
+const fs = require('fs')
+const async = require('async')
+const path = require('path')
+const diff = require('diff')
+const convertToFlatFormat = require('./convertToFlatFormat')
+const convertToDesiredFormat = require('./convertToDesiredFormat')
+const sortFlatResources = require('./sortFlatResources')
+const formats = require('./formats')
+const fileExtensionsMap = formats.fileExtensionsMap
+const acceptedFileExtensions = formats.acceptedFileExtensions
+const reversedFileExtensionsMap = formats.reversedFileExtensionsMap
 
 const handleError = (err, cb) => {
   if (!cb && err) {
-    console.error(colors.red(err.message));
-    process.exit(1);
+    console.error(colors.red(err.message))
+    process.exit(1)
   }
-  if (cb) cb(err);
-};
+  if (cb) cb(err)
+}
 
 const getFiles = (srcpath) => {
-  var files = [];
+  let files = []
   fs.readdirSync(srcpath).forEach((file) => {
     if (fs.statSync(path.join(srcpath, file)).isDirectory()) {
-      files = files.concat(getFiles(path.join(srcpath, file)));
+      files = files.concat(getFiles(path.join(srcpath, file)))
     } else if (acceptedFileExtensions.indexOf(path.extname(file)) > -1) {
-      files.push(path.join(srcpath, file));
+      files.push(path.join(srcpath, file))
     }
-  });
-  return files;
-};
+  })
+  return files
+}
 
-function readLocalFile(opt, fPath, clb) {
-  const fExt = path.extname(fPath);
-  const namespace = path.basename(fPath, fExt);
-  const splitted = fPath.split(path.sep);
-  const lng = splitted[splitted.length - 2];
+function readLocalFile (opt, fPath, clb) {
+  const fExt = path.extname(fPath)
+  const namespace = path.basename(fPath, fExt)
+  const splitted = fPath.split(path.sep)
+  const lng = splitted[splitted.length - 2]
 
   fs.readFile(fPath, (err, data) => {
-    if (err) return clb(err);
+    if (err) return clb(err)
 
     fs.stat(fPath, (err, stat) => {
-      if (err) return clb(err);
+      if (err) return clb(err)
 
       clb(null, {
-        namespace: namespace,
+        namespace,
         path: fPath,
         extension: fExt,
         original: data.toString(),
         language: lng,
         mtime: stat.mtime
-      });
-    });
-  });
+      })
+    })
+  })
 }
 
-function readLocalFiles(opt, filePaths, clb) {
+function readLocalFiles (opt, filePaths, clb) {
   async.map(filePaths, (filePath, cb) => {
-    readLocalFile(opt, filePath, cb);
-  }, clb);
+    readLocalFile(opt, filePath, cb)
+  }, clb)
 }
 
-function convertAllFilesToFlatFormat(opt, files, clb) {
+function convertAllFilesToFlatFormat (opt, files, clb) {
   async.map(files, (file, cb) => {
     if (fileExtensionsMap[file.extension].indexOf(opt.format) < 0) {
-      return cb(new Error(`Format mismatch! Found ${fileExtensionsMap[file.extension][0]} but requested ${opt.format}!`));
+      return cb(new Error(`Format mismatch! Found ${fileExtensionsMap[file.extension][0]} but requested ${opt.format}!`))
     }
 
     convertToFlatFormat(opt, file.original, (err, content) => {
       if (err) {
-        err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '');
-        err.message += '\n' + file.path;
-        return cb(err);
+        err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '')
+        err.message += '\n' + file.path
+        return cb(err)
       }
 
-      file.content = sortFlatResources(content);
-      cb(null, file);
-    });
-  }, clb);
+      file.content = sortFlatResources(content)
+      cb(null, file)
+    })
+  }, clb)
 }
 
-function convertAllFilesToDesiredFormat(opt, files, clb) {
+function convertAllFilesToDesiredFormat (opt, files, clb) {
   async.map(files, (file, cb) => {
     convertToDesiredFormat(opt, file.namespace, file.language, file.content, file.mtime, (err, res) => {
       if (err) {
-        err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '');
-        return cb(err);
+        err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '')
+        return cb(err)
       }
-      res = (opt.format !== 'xlsx' && !res.endsWith('\n')) ? (res + '\n') : res;
-      file.converted = res;
-      cb(null, file);
-    });
-  }, clb);
+      res = (opt.format !== 'xlsx' && !res.endsWith('\n')) ? (res + '\n') : res
+      file.converted = res
+      cb(null, file)
+    })
+  }, clb)
 }
 
-function writeLocalFile(opt, file, clb) {
+function writeLocalFile (opt, file, clb) {
   if (file.converted === file.original) {
-    if (opt.noCallback) console.log(colors.grey(`${file.path} unchanged`));
-    return clb(null);
+    if (opt.noCallback) console.log(colors.grey(`${file.path} unchanged`))
+    return clb(null)
   }
 
-  const d = diff.diffLines(file.original, file.converted);
+  const d = diff.diffLines(file.original, file.converted)
   d.forEach((part) => {
     // green for additions, red for deletions
     // grey for common parts
-    const color = part.added ? 'green' : part.removed ? 'red' : 'grey';
-    if (opt.noCallback) console.log(part.value[color]);
-  });
+    const color = part.added ? 'green' : part.removed ? 'red' : 'grey'
+    if (opt.noCallback) console.log(part.value[color])
+  })
 
-  if (opt.noCallback) console.log(colors.yellow(`reformatting ${file.path}...`));
+  if (opt.noCallback) console.log(colors.yellow(`reformatting ${file.path}...`))
   if (opt.dry) {
-    if (opt.noCallback) console.log(colors.yellow(`would have reformatted ${file.path}...`));
-    return clb(null, true);
+    if (opt.noCallback) console.log(colors.yellow(`would have reformatted ${file.path}...`))
+    return clb(null, true)
   }
 
-  const fileContent = (opt.format !== 'xlsx' && !file.converted.endsWith('\n')) ? (file.converted + '\n') : file.converted;
+  const fileContent = (opt.format !== 'xlsx' && !file.converted.endsWith('\n')) ? (file.converted + '\n') : file.converted
 
-  fs.writeFile(file.path, fileContent, (err) => clb(err, true));
+  fs.writeFile(file.path, fileContent, (err) => clb(err, true))
 }
 
-function writeLocalFiles(opt, files, clb) {
+function writeLocalFiles (opt, files, clb) {
   async.map(files, (file, cb) => {
-    writeLocalFile(opt, file, cb);
-  }, clb);
+    writeLocalFile(opt, file, cb)
+  }, clb)
 }
 
-function processFiles(opt, filePaths, clb) {
+function processFiles (opt, filePaths, clb) {
   readLocalFiles(opt, filePaths, (err, orgFiles) => {
-    if (err) return clb(err);
+    if (err) return clb(err)
 
     if (!opt.format) {
       if (orgFiles.length === 0) {
-        return clb(new Error('Please provide a format!'));
+        return clb(new Error('Please provide a format!'))
       }
       // guess format
-      opt.format = fileExtensionsMap[orgFiles[0].extension][0];
-      if (opt.noCallback) console.log(colors.bgYellow(`No format argument was passed, so guessing "${opt.format}" format.`));
+      opt.format = fileExtensionsMap[orgFiles[0].extension][0]
+      if (opt.noCallback) console.log(colors.bgYellow(`No format argument was passed, so guessing "${opt.format}" format.`))
     }
 
     convertAllFilesToFlatFormat(opt, orgFiles, (err, files) => {
-      if (err) return clb(err);
+      if (err) return clb(err)
 
       opt.getNamespace = (o, lng, ns, cb) => {
-        const foundOrgFile = orgFiles.find((f) => f.namespace === ns && f.language === lng);
+        const foundOrgFile = orgFiles.find((f) => f.namespace === ns && f.language === lng)
         if (!foundOrgFile) {
-          return cb(new Error(`No file found for language "${lng}" and namespace "${ns}" locally!`));
+          return cb(new Error(`No file found for language "${lng}" and namespace "${ns}" locally!`))
         }
-        cb(null, foundOrgFile.content, foundOrgFile.mtime);
-      };
+        cb(null, foundOrgFile.content, foundOrgFile.mtime)
+      }
 
       // just the value
       files.forEach((f) => {
         if (f.content) {
           Object.keys(f.content).forEach((k) => {
             if (f.content[k] && typeof f.content[k] === 'object' && f.content[k].value !== undefined) {
-              f.content[k] = f.content[k].value;
+              f.content[k] = f.content[k].value
             }
-          });
+          })
         }
-      });
+      })
 
       convertAllFilesToDesiredFormat(opt, files, (err, convertedFiles) => {
-        if (err) return clb(err);
+        if (err) return clb(err)
 
-        writeLocalFiles(opt, convertedFiles, clb);
-      });
-    });
-  });
+        writeLocalFiles(opt, convertedFiles, clb)
+      })
+    })
+  })
 }
 
 const format = (opt, cb) => {
   if (opt.format && !reversedFileExtensionsMap[opt.format]) {
-    return handleError(new Error(`${opt.format} is not a valid format!`), cb);
+    return handleError(new Error(`${opt.format} is not a valid format!`), cb)
   }
 
-  opt.noCallback = !cb;
+  opt.noCallback = !cb
 
   fs.lstat(opt.fileOrDirectory, (err, stat) => {
-    if (err) return handleError(err, cb);
+    if (err) return handleError(err, cb)
 
-    const isDirectory = stat.isDirectory();
+    const isDirectory = stat.isDirectory()
 
-    var filePaths = [];
+    let filePaths = []
     if (isDirectory) {
       try {
-        filePaths = getFiles(opt.fileOrDirectory);
+        filePaths = getFiles(opt.fileOrDirectory)
       } catch (err) {}
     } else {
-      filePaths = [opt.fileOrDirectory];
+      filePaths = [opt.fileOrDirectory]
     }
 
     processFiles(opt, filePaths, (err, writeResults) => {
-      if (err) return handleError(err, cb);
+      if (err) return handleError(err, cb)
       if (!cb) {
-        console.log(colors.green('FINISHED'));
+        console.log(colors.green('FINISHED'))
         if (opt.dry && writeResults.find((wr) => !!wr)) {
-          process.exit(1);
+          process.exit(1)
         }
       }
-      if (cb) cb(null);
-    });
-  });
-};
+      if (cb) cb(null)
+    })
+  })
+}
 
-module.exports = format;
+module.exports = format

package/formats.js

@@ -15,19 +15,19 @@ const fileExtensionsMap = {
   '.php': ['laravel'],
   '.properties': ['properties'],
   '.xcstrings': ['xcstrings']
-};
+}
 
-const acceptedFileExtensions = Object.keys(fileExtensionsMap);
+const acceptedFileExtensions = Object.keys(fileExtensionsMap)
 
-const reversedFileExtensionsMap = {};
+const reversedFileExtensionsMap = {}
 acceptedFileExtensions.forEach((ext) => {
   fileExtensionsMap[ext].forEach((format) => {
-    reversedFileExtensionsMap[format] = ext;
-  });
-});
+    reversedFileExtensionsMap[format] = ext
+  })
+})
 
 module.exports = {
-  fileExtensionsMap: fileExtensionsMap,
-  acceptedFileExtensions: acceptedFileExtensions,
-  reversedFileExtensionsMap: reversedFileExtensionsMap
-};
+  fileExtensionsMap,
+  acceptedFileExtensions,
+  reversedFileExtensionsMap
+}

package/get.js

@@ -1,78 +1,81 @@
-const colors = require('colors');
-const request = require('./request');
-const flatten = require('flat');
+const colors = require('colors')
+const request = require('./request')
+const flatten = require('flat')
 
 const get = (opt, cb) => {
-  const url = opt.getPath
+  const url = `${opt.apiEndpoint}/{{projectId}}/{{version}}/{{lng}}/{{ns}}`
     .replace('{{projectId}}', opt.projectId)
     .replace('{{ver}}', opt.version)
     .replace('{{version}}', opt.version)
     .replace('{{language}}', opt.language)
     .replace('{{lng}}', opt.language)
     .replace('{{ns}}', opt.namespace)
-    .replace('{{namespace}}', opt.namespace);
+    .replace('{{namespace}}', opt.namespace)
 
   // if (!cb) console.log(colors.yellow(`getting ${opt.key} from ${opt.version}/${opt.language}/${opt.namespace}...`));
 
   if (opt.key && opt.key.indexOf(',') > 0 && opt.key.indexOf(' ') < 0) {
-    opt.keys = opt.key.split(',');
-    delete opt.key;
+    opt.keys = opt.key.split(',')
+    delete opt.key
   }
 
-  request(url, {
+  request(`${url}${opt.cdnType === 'standard' ? '?cache=no' : ''}`, {
     method: 'get'
   }, (err, res, obj) => {
     if (err) {
-      if (!cb) console.log(colors.red(`get failed for ${opt.key || opt.keys.join(', ')} from ${opt.version}/${opt.language}/${opt.namespace}...`));
+      if (!cb) console.log(colors.red(`get failed for ${opt.key || opt.keys.join(', ')} from ${opt.version}/${opt.language}/${opt.namespace}...`))
       if (err) {
-        if (!cb) { console.error(colors.red(err.message)); process.exit(1); }
-        if (cb) cb(err);
-        return;
+        if (!cb) { console.error(colors.red(err.message)); process.exit(1) }
+        if (cb) cb(err)
+        return
       }
     }
-    if (res.status >= 300) {
-      if (!cb) { console.error(colors.red(res.statusText + ' (' + res.status + ')')); process.exit(1); }
-      if (cb) cb(new Error(res.statusText + ' (' + res.status + ')'));
-      return;
+    const ignore404 = res.status === 404 && opt.cdnType === 'standard'
+    if (res.status >= 300 && !ignore404) {
+      if (!cb) { console.error(colors.red(res.statusText + ' (' + res.status + ')')); process.exit(1) }
+      if (cb) cb(new Error(res.statusText + ' (' + res.status + ')'))
+      return
     }
     // if (!cb) console.log(colors.green(`got ${opt.opt.key || opt.keys.join(', ')} from ${opt.version}/${opt.language}/${opt.namespace}...`));
 
-    const flat = flatten(obj);
+    if (ignore404) obj = {}
+
+    const flat = flatten(obj)
     if (opt.key) {
       if (!flat[opt.key]) {
-        if (!cb) { console.error(colors.red(`${opt.key} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`)); process.exit(1); }
-        if (cb) cb(new Error(`${opt.key} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`));
-        return;
+        if (!cb) { console.error(colors.red(`${opt.key} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`)); process.exit(1) }
+        if (cb) cb(new Error(`${opt.key} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`))
+        return
       }
-      if (!cb) console.log(flat[opt.key]);
+      if (!cb) console.log(flat[opt.key])
     }
     if (opt.keys) {
-      const ret = {};
-      const retWitAllKeys = {};
+      const ret = {}
+      const retWitAllKeys = {}
       opt.keys.forEach((k) => {
         if (flat[k] !== undefined) {
-          ret[k] = flat[k];
+          ret[k] = flat[k]
         }
-        retWitAllKeys[k] = flat[k];
-      });
-      const retKeys = Object.keys(ret);
+        retWitAllKeys[k] = flat[k]
+      })
+      const retKeys = Object.keys(ret)
       if (retKeys.length === 0) {
-        if (!cb) { console.error(colors.red(`${opt.keys.join(', ')} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`)); process.exit(1); }
-        if (cb) cb(new Error(`${opt.keys.join(', ')} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`));
-        return;
+        if (!cb) { console.error(colors.red(`${opt.keys.join(', ')} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`)); process.exit(1) }
+        if (cb) cb(new Error(`${opt.keys.join(', ')} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`))
+        return
       }
       if (!cb) {
         if (console.table) {
-          console.table(retWitAllKeys);
+          console.table(retWitAllKeys)
         } else {
           opt.keys.forEach((k) => {
-            console.log(`${k}\t=>\t${ret[k] || ''}`);
-          });
+            console.log(`${k}\t=>\t${ret[k] || ''}`)
+          })
         }
       }
     }
-    if (cb) cb(null);
-  });
-};
+    if (cb) cb(null)
+  })
+}
 
-module.exports = get;
+module.exports = get

package/getBranches.js

@@ -1,40 +1,40 @@
-const colors = require('colors');
-const request = require('./request');
+const colors = require('colors')
+const request = require('./request')
 
 const getBranches = (opt, cb) => {
-  request(opt.apiPath + '/branches/' + opt.projectId, {
+  request(opt.apiEndpoint + '/branches/' + opt.projectId, {
     method: 'get',
     headers: {
-      'Authorization': opt.apiKey
+      Authorization: opt.apiKey
     }
   }, (err, res, obj) => {
     if (err || (obj && (obj.errorMessage || obj.message))) {
-      if (!cb) console.log(colors.red('getting branches failed...'));
+      if (!cb) console.log(colors.red('getting branches failed...'))
 
       if (err) {
-        if (!cb) { console.error(colors.red(err.message)); process.exit(1); }
-        if (cb) cb(err);
-        return;
+        if (!cb) { console.error(colors.red(err.message)); process.exit(1) }
+        if (cb) cb(err)
+        return
       }
       if (obj && (obj.errorMessage || obj.message)) {
-        if (!cb) { console.error(colors.red((obj.errorMessage || obj.message))); process.exit(1); }
-        if (cb) cb(new Error((obj.errorMessage || obj.message)));
-        return;
+        if (!cb) { console.error(colors.red((obj.errorMessage || obj.message))); process.exit(1) }
+        if (cb) cb(new Error((obj.errorMessage || obj.message)))
+        return
       }
     }
     if (res.status === 404) {
-      if (!cb) { console.error(colors.yellow(res.statusText + ' (' + res.status + ')')); process.exit(1); }
-      if (cb) cb(null, null);
-      return;
+      if (!cb) { console.error(colors.yellow(res.statusText + ' (' + res.status + ')')); process.exit(1) }
+      if (cb) cb(null, null)
+      return
     }
     if (res.status >= 300) {
-      if (!cb) { console.error(colors.red(res.statusText + ' (' + res.status + ')')); process.exit(1); }
-      if (cb) cb(new Error(res.statusText + ' (' + res.status + ')'));
-      return;
+      if (!cb) { console.error(colors.red(res.statusText + ' (' + res.status + ')')); process.exit(1) }
+      if (cb) cb(new Error(res.statusText + ' (' + res.status + ')'))
+      return
     }
-    if (!cb) console.log(colors.green('getting branches successful'));
-    if (cb) cb(null, obj);
-  });
-};
+    if (!cb) console.log(colors.green('getting branches successful'))
+    if (cb) cb(null, obj)
+  })
+}
 
-module.exports = getBranches;
+module.exports = getBranches

package/getJob.js

@@ -1,40 +1,40 @@
-const colors = require('colors');
-const request = require('./request');
+const colors = require('colors')
+const request = require('./request')
 
 const getJob = (opt, jobId, cb) => {
-  request(opt.apiPath + '/jobs/' + opt.projectId + '/' + jobId, {
+  request(opt.apiEndpoint + '/jobs/' + opt.projectId + '/' + jobId, {
     method: 'get',
     headers: {
-      'Authorization': opt.apiKey
+      Authorization: opt.apiKey
     }
   }, (err, res, obj) => {
     if (err || (obj && (obj.errorMessage || obj.message))) {
-      if (!cb) console.log(colors.red('getting job failed...'));
+      if (!cb) console.log(colors.red('getting job failed...'))
 
       if (err) {
-        if (!cb) { console.error(colors.red(err.message)); process.exit(1); }
-        if (cb) cb(err);
-        return;
+        if (!cb) { console.error(colors.red(err.message)); process.exit(1) }
+        if (cb) cb(err)
+        return
       }
       if (obj && (obj.errorMessage || obj.message)) {
-        if (!cb) { console.error(colors.red((obj.errorMessage || obj.message))); process.exit(1); }
-        if (cb) cb(new Error((obj.errorMessage || obj.message)));
-        return;
+        if (!cb) { console.error(colors.red((obj.errorMessage || obj.message))); process.exit(1) }
+        if (cb) cb(new Error((obj.errorMessage || obj.message)))
+        return
       }
     }
     if (res.status === 404) {
-      if (!cb) { console.error(colors.yellow(res.statusText + ' (' + res.status + ')')); process.exit(1); }
-      if (cb) cb(null, null);
-      return;
+      if (!cb) { console.error(colors.yellow(res.statusText + ' (' + res.status + ')')); process.exit(1) }
+      if (cb) cb(null, null)
+      return
     }
     if (res.status >= 300) {
-      if (!cb) { console.error(colors.red(res.statusText + ' (' + res.status + ')')); process.exit(1); }
-      if (cb) cb(new Error(res.statusText + ' (' + res.status + ')'));
-      return;
+      if (!cb) { console.error(colors.red(res.statusText + ' (' + res.status + ')')); process.exit(1) }
+      if (cb) cb(new Error(res.statusText + ' (' + res.status + ')'))
+      return
     }
-    if (!cb) console.log(colors.green('getting job successful'));
-    if (cb) cb(null, obj);
-  });
-};
+    if (!cb) console.log(colors.green('getting job successful'))
+    if (cb) cb(null, obj)
+  })
+}
 
-module.exports = getJob;
+module.exports = getJob