locize-cli 10.3.2 → 10.4.0

package/missing.js

@@ -1,169 +1,169 @@
-const colors = require('colors');
-const async = require('async');
-const path = require('path');
-const request = require('./request');
-const formats = require('./formats');
-const reversedFileExtensionsMap = formats.reversedFileExtensionsMap;
-const getRemoteLanguages = require('./getRemoteLanguages');
-const parseLocalReference = require('./parseLocalReference');
-const parseLocalLanguages = require('./parseLocalLanguages');
-const getRemoteNamespace = require('./getRemoteNamespace');
+const colors = require('colors')
+const async = require('async')
+const path = require('path')
+const request = require('./request')
+const formats = require('./formats')
+const reversedFileExtensionsMap = formats.reversedFileExtensionsMap
+const getRemoteLanguages = require('./getRemoteLanguages')
+const parseLocalReference = require('./parseLocalReference')
+const parseLocalLanguages = require('./parseLocalLanguages')
+const getRemoteNamespace = require('./getRemoteNamespace')
 
 const compareNamespace = (local, remote) => {
   const diff = {
     toAdd: []
-  };
-  local = local || {};
-  remote = remote || {};
+  }
+  local = local || {}
+  remote = remote || {}
   Object.keys(local).forEach((k) => {
-    if (remote[k] === '' && local[k] === '') return;
+    if (remote[k] === '' && local[k] === '') return
     if (!remote[k]) {
-      diff.toAdd.push(k);
+      diff.toAdd.push(k)
     }
-  });
-  return diff;
-};
+  })
+  return diff
+}
 
 const compareNamespaces = (opt, localNamespaces, cb) => {
   async.map(localNamespaces, (ns, clb) => {
     getRemoteNamespace(opt, ns.language, ns.namespace, (err, remoteNamespace) => {
-      if (err) return clb(err);
+      if (err) return clb(err)
 
-      const diff = compareNamespace(ns.content, remoteNamespace);
-      ns.diff = diff;
-      ns.remoteContent = remoteNamespace;
-      clb(null, ns);
-    });
-  }, cb);
-};
+      const diff = compareNamespace(ns.content, remoteNamespace)
+      ns.diff = diff
+      ns.remoteContent = remoteNamespace
+      clb(null, ns)
+    })
+  }, cb)
+}
 
 const saveMissing = (opt, lng, ns, cb) => {
-  var data = {};
-  ns.diff.toAdd.forEach((k) => data[k] = ns.content[k]);
+  const data = {}
+  ns.diff.toAdd.forEach((k) => { data[k] = ns.content[k] })
 
-  if (Object.keys(data).length === 0) return cb(null);
+  if (Object.keys(data).length === 0) return cb(null)
 
-  if (opt.dry) return cb(null);
+  if (opt.dry) return cb(null)
 
-  var payloadKeysLimit = 1000;
+  const payloadKeysLimit = 1000
 
-  function send(d, clb, isRetrying) {
+  function send (d, clb, isRetrying) {
     request(opt.apiPath + '/missing/' + opt.projectId + '/' + opt.version + '/' + lng + '/' + ns.namespace, {
       method: 'post',
       body: d,
       headers: {
-        'Authorization': opt.apiKey
+        Authorization: opt.apiKey
       }
     }, (err, res, obj) => {
-      if (err) return clb(err);
+      if (err) return clb(err)
       if (res.status === 504 && !isRetrying) {
-        return setTimeout(() => send(d, clb, true), 3000);
+        return setTimeout(() => send(d, clb, true), 3000)
       }
       if (res.status >= 300 && res.status !== 412) {
         if (obj && (obj.errorMessage || obj.message)) {
-          return clb(new Error((obj.errorMessage || obj.message)));
+          return clb(new Error((obj.errorMessage || obj.message)))
         }
-        return clb(new Error(res.statusText + ' (' + res.status + ')'));
+        return clb(new Error(res.statusText + ' (' + res.status + ')'))
       }
-      setTimeout(() => clb(null), 1000);
-    });
+      setTimeout(() => clb(null), 1000)
+    })
   }
 
   if (Object.keys(data).length > payloadKeysLimit) {
-    var tasks = [];
-    var keysInObj = Object.keys(data);
+    const tasks = []
+    const keysInObj = Object.keys(data)
 
     while (keysInObj.length > payloadKeysLimit) {
-      (function() {
-        var pagedData = {};
-        keysInObj.splice(0, payloadKeysLimit).forEach((k) => pagedData[k] = data[k]);
-        tasks.push((c) => send(pagedData, c));
-      })();
+      (function () {
+        const pagedData = {}
+        keysInObj.splice(0, payloadKeysLimit).forEach((k) => { pagedData[k] = data[k] })
+        tasks.push((c) => send(pagedData, c))
+      })()
     }
 
-    if (keysInObj.length === 0) return cb(null);
+    if (keysInObj.length === 0) return cb(null)
 
-    var finalPagedData = {};
-    keysInObj.splice(0, keysInObj.length).forEach((k) => finalPagedData[k] = data[k]);
-    tasks.push((c) => send(finalPagedData, c));
+    const finalPagedData = {}
+    keysInObj.splice(0, keysInObj.length).forEach((k) => { finalPagedData[k] = data[k] })
+    tasks.push((c) => send(finalPagedData, c))
 
-    async.series(tasks, cb);
-    return;
+    async.series(tasks, cb)
+    return
   }
 
-  send(data, cb);
-};
+  send(data, cb)
+}
 
 const handleError = (err, cb) => {
   if (!cb && err) {
-    console.error(colors.red(err.stack));
-    process.exit(1);
+    console.error(colors.red(err.stack))
+    process.exit(1)
   }
-  if (cb) cb(err);
-};
+  if (cb) cb(err)
+}
 
 const handleMissing = (opt, localNamespaces, cb) => {
   if (!localNamespaces || localNamespaces.length === 0) {
-    return handleError(new Error('No local namespaces found!'));
+    return handleError(new Error('No local namespaces found!'))
   }
 
   compareNamespaces(opt, localNamespaces, (err, compared) => {
-    if (err) return handleError(err);
+    if (err) return handleError(err)
 
     async.eachLimit(compared, Math.round(require('os').cpus().length / 2), (ns, clb) => {
       if (!cb) {
         if (ns.diff.toAdd.length > 0) {
-          console.log(colors.green(`adding ${ns.diff.toAdd.length} keys in ${ns.language}/${ns.namespace}...`));
-          if (opt.dry) console.log(colors.green(`would add ${ns.diff.toAdd.join(', ')} in ${ns.language}/${ns.namespace}...`));
+          console.log(colors.green(`adding ${ns.diff.toAdd.length} keys in ${ns.language}/${ns.namespace}...`))
+          if (opt.dry) console.log(colors.green(`would add ${ns.diff.toAdd.join(', ')} in ${ns.language}/${ns.namespace}...`))
         }
       }
-      saveMissing(opt, ns.language, ns, clb);
+      saveMissing(opt, ns.language, ns, clb)
     }, (err) => {
-      if (err) return handleError(err);
-      if (!cb) console.log(colors.green('FINISHED'));
-      if (cb) cb(null);
-    });
-  });
-};
+      if (err) return handleError(err)
+      if (!cb) console.log(colors.green('FINISHED'))
+      if (cb) cb(null)
+    })
+  })
+}
 
 const missing = (opt, cb) => {
   if (!reversedFileExtensionsMap[opt.format]) {
-    return handleError(new Error(`${opt.format} is not a valid format!`));
+    return handleError(new Error(`${opt.format} is not a valid format!`))
   }
 
   if (opt.namespace && opt.namespace.indexOf(',') > 0) {
-    opt.namespaces = opt.namespace.split(',');
-    delete opt.namespace;
+    opt.namespaces = opt.namespace.split(',')
+    delete opt.namespace
   }
 
-  opt.pathMaskInterpolationPrefix = opt.pathMaskInterpolationPrefix || '{{';
-  opt.pathMaskInterpolationSuffix = opt.pathMaskInterpolationSuffix || '}}';
-  opt.pathMask = opt.pathMask || `${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}${path.sep}${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`;
-  opt.languageFolderPrefix = opt.languageFolderPrefix || '';
-  opt.pathMask = opt.pathMask.replace(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`, `${opt.languageFolderPrefix}${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`);
+  opt.pathMaskInterpolationPrefix = opt.pathMaskInterpolationPrefix || '{{'
+  opt.pathMaskInterpolationSuffix = opt.pathMaskInterpolationSuffix || '}}'
+  opt.pathMask = opt.pathMask || `${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}${path.sep}${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`
+  opt.languageFolderPrefix = opt.languageFolderPrefix || ''
+  opt.pathMask = opt.pathMask.replace(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`, `${opt.languageFolderPrefix}${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`)
 
   getRemoteLanguages(opt, (err, remoteLanguages) => {
-    if (err) return handleError(err);
+    if (err) return handleError(err)
 
     if (opt.referenceLanguageOnly && opt.language && opt.referenceLanguage !== opt.language) {
-      opt.referenceLanguage = opt.language;
+      opt.referenceLanguage = opt.language
     }
 
     if (opt.referenceLanguageOnly) {
       parseLocalReference(opt, (err, localNamespaces) => {
-        if (err) return handleError(err);
+        if (err) return handleError(err)
 
-        handleMissing(opt, localNamespaces, cb);
-      });
-      return;
+        handleMissing(opt, localNamespaces, cb)
+      })
+      return
     }
 
     parseLocalLanguages(opt, remoteLanguages, (err, localNamespaces) => {
-      if (err) return handleError(err);
+      if (err) return handleError(err)
 
-      handleMissing(opt, localNamespaces, cb);
-    });
-  });
-};
+      handleMissing(opt, localNamespaces, cb)
+    })
+  })
+}
 
-module.exports = missing;
+module.exports = missing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "locize-cli",
-  "version": "10.3.2",
+  "version": "10.4.0",
   "description": "locize cli to import locales",
   "main": "index.js",
   "bin": {
@@ -36,7 +36,9 @@
   },
   "devDependencies": {
     "@yao-pkg/pkg": "6.4.0",
-    "eslint": "8.56.0",
+    "eslint": "9.39.1",
+    "eslint-plugin-import": "2.32.0",
+    "neostandard": "0.12.2",
     "gh-release": "7.0.2"
   },
   "scripts": {

package/parseLocalLanguage.js

@@ -1,203 +1,203 @@
-const fs = require('fs');
-const path = require('path');
-const async = require('async');
-const { mkdirp } = require('mkdirp');
-const convertToFlatFormat = require('./convertToFlatFormat');
-const formats = require('./formats');
-const fileExtensionsMap = formats.fileExtensionsMap;
-const acceptedFileExtensions = formats.acceptedFileExtensions;
-const xcstrings2locize = require('locize-xcstrings/cjs/xcstrings2locize');
+const fs = require('fs')
+const path = require('path')
+const async = require('async')
+const { mkdirp } = require('mkdirp')
+const convertToFlatFormat = require('./convertToFlatFormat')
+const formats = require('./formats')
+const fileExtensionsMap = formats.fileExtensionsMap
+const acceptedFileExtensions = formats.acceptedFileExtensions
+const xcstrings2locize = require('locize-xcstrings/cjs/xcstrings2locize')
 
 const getFiles = (srcpath) => {
   return fs.readdirSync(srcpath).filter((file) => {
-    return !fs.statSync(path.join(srcpath, file)).isDirectory();
-  }).filter((file) => acceptedFileExtensions.indexOf(path.extname(file)) > -1);
-};
+    return !fs.statSync(path.join(srcpath, file)).isDirectory()
+  }).filter((file) => acceptedFileExtensions.indexOf(path.extname(file)) > -1)
+}
 
 const getDirectories = (srcpath) => {
   return fs.readdirSync(srcpath).filter((file) => {
-    return fs.statSync(path.join(srcpath, file)).isDirectory();
-  });
-};
+    return fs.statSync(path.join(srcpath, file)).isDirectory()
+  })
+}
 
 const parseLocalLanguage = (opt, lng, cb) => {
-  const hasNamespaceInPath = opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1;
-  const filledLngMask = opt.pathMask.replace(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`, opt.format === 'xcstrings' ? '' : lng);
-  var firstPartLngMask, lastPartLngMask;
+  const hasNamespaceInPath = opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1
+  const filledLngMask = opt.pathMask.replace(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`, opt.format === 'xcstrings' ? '' : lng)
+  let firstPartLngMask, lastPartLngMask
   if (opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`) > opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`)) {
-    const secondPartMask = opt.pathMask.substring(opt.pathMask.lastIndexOf(path.sep) + 1);
-    firstPartLngMask = secondPartMask.substring(0, secondPartMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`));
-    lastPartLngMask = secondPartMask.substring(secondPartMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`) + `${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`.length);
+    const secondPartMask = opt.pathMask.substring(opt.pathMask.lastIndexOf(path.sep) + 1)
+    firstPartLngMask = secondPartMask.substring(0, secondPartMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`))
+    lastPartLngMask = secondPartMask.substring(secondPartMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`) + `${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`.length)
   }
-  var lngPath;
+  let lngPath
   if (filledLngMask.lastIndexOf(path.sep) > 0) {
-    lngPath = filledLngMask.substring(0, filledLngMask.lastIndexOf(path.sep));
+    lngPath = filledLngMask.substring(0, filledLngMask.lastIndexOf(path.sep))
   }
-  if (!opt.dry && lngPath && lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) < 0) mkdirp.sync(path.join(opt.path, lngPath));
-  var files = [];
+  if (!opt.dry && lngPath && lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) < 0) mkdirp.sync(path.join(opt.path, lngPath))
+  let files = []
   try {
     if (lngPath) {
       if (lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1) {
-        const firstPart = lngPath.substring(0, lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`));
-        const lastPart = lngPath.substring(lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) + `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`.length);
-        var additionalSubDirsLeft = '';
-        var additionalSubDirs = '';
-        var splittedP = lngPath.split(path.sep);
-        const foundSplitted = splittedP.find((s) => s.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1);
-        const foundSplittedIndex = splittedP.indexOf(foundSplitted);
+        const firstPart = lngPath.substring(0, lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`))
+        const lastPart = lngPath.substring(lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) + `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`.length)
+        let additionalSubDirsLeft = ''
+        let additionalSubDirs = ''
+        const splittedP = lngPath.split(path.sep)
+        const foundSplitted = splittedP.find((s) => s.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1)
+        const foundSplittedIndex = splittedP.indexOf(foundSplitted)
         if (splittedP.length > 2) {
-          additionalSubDirsLeft = splittedP.slice(0, foundSplittedIndex).join(path.sep);
-          additionalSubDirs = splittedP.slice(foundSplittedIndex + 1).join(path.sep);
+          additionalSubDirsLeft = splittedP.slice(0, foundSplittedIndex).join(path.sep)
+          additionalSubDirs = splittedP.slice(foundSplittedIndex + 1).join(path.sep)
         }
-        var dirs = getDirectories(path.join(opt.path, additionalSubDirsLeft));
+        let dirs = getDirectories(path.join(opt.path, additionalSubDirsLeft))
         if (additionalSubDirs === '') {
-          dirs = dirs.filter((d) => d.startsWith(firstPart) && d.endsWith(lastPart));
+          dirs = dirs.filter((d) => d.startsWith(firstPart) && d.endsWith(lastPart))
         }
         dirs.forEach((d) => {
           if (additionalSubDirs && fs.statSync(path.join(opt.path, additionalSubDirsLeft, d)).isDirectory()) {
-            var directoryExists = false;
+            let directoryExists = false
             try {
-              directoryExists = fs.statSync(path.join(opt.path, additionalSubDirsLeft, d, additionalSubDirs)).isDirectory();
+              directoryExists = fs.statSync(path.join(opt.path, additionalSubDirsLeft, d, additionalSubDirs)).isDirectory()
             } catch (e) {}
             if (directoryExists) {
-              var subFls = getFiles(path.join(opt.path, additionalSubDirsLeft, d, additionalSubDirs));
-              if (firstPartLngMask || lastPartLngMask) subFls = subFls.filter((f) => path.basename(f, path.extname(f)) === `${firstPartLngMask}${lng}${lastPartLngMask}`);
+              let subFls = getFiles(path.join(opt.path, additionalSubDirsLeft, d, additionalSubDirs))
+              if (firstPartLngMask || lastPartLngMask) subFls = subFls.filter((f) => path.basename(f, path.extname(f)) === `${firstPartLngMask}${lng}${lastPartLngMask}`)
 
               subFls = subFls.filter((f) => {
-                const a = path.join(additionalSubDirsLeft, d, additionalSubDirs, path.basename(f, path.extname(f)));
-                const startIndexOfNs = filledLngMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`);
-                if (startIndexOfNs === -1) return true;
-                const afterNs = filledLngMask.substring(startIndexOfNs + `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`.length);
-                const nsName = a.substring(startIndexOfNs, a.indexOf(afterNs));
-                const b = filledLngMask.replace(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`, nsName);
-                return a === b;
-              });
+                const a = path.join(additionalSubDirsLeft, d, additionalSubDirs, path.basename(f, path.extname(f)))
+                const startIndexOfNs = filledLngMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`)
+                if (startIndexOfNs === -1) return true
+                const afterNs = filledLngMask.substring(startIndexOfNs + `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`.length)
+                const nsName = a.substring(startIndexOfNs, a.indexOf(afterNs))
+                const b = filledLngMask.replace(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`, nsName)
+                return a === b
+              })
 
-              files = files.concat(subFls.map((f) => `${additionalSubDirsLeft ? additionalSubDirsLeft + path.sep : ''}${d}${path.sep}${additionalSubDirs}${path.sep}${f}`));
+              files = files.concat(subFls.map((f) => `${additionalSubDirsLeft ? additionalSubDirsLeft + path.sep : ''}${d}${path.sep}${additionalSubDirs}${path.sep}${f}`))
             }
           } else {
-            const fls = getFiles(path.join(opt.path, additionalSubDirsLeft, d)).filter((f) => path.basename(f, path.extname(f)) === `${firstPartLngMask}${lng}${lastPartLngMask}`);
-            files = files.concat(fls.map((f) => `${additionalSubDirsLeft ? additionalSubDirsLeft + path.sep : ''}${d}${path.sep}${f}`));
+            const fls = getFiles(path.join(opt.path, additionalSubDirsLeft, d)).filter((f) => path.basename(f, path.extname(f)) === `${firstPartLngMask}${lng}${lastPartLngMask}`)
+            files = files.concat(fls.map((f) => `${additionalSubDirsLeft ? additionalSubDirsLeft + path.sep : ''}${d}${path.sep}${f}`))
           }
-        });
+        })
       } else {
-        files = getFiles(path.join(opt.path, lngPath));
+        files = getFiles(path.join(opt.path, lngPath))
       }
     } else {
-      files = getFiles(opt.path);
+      files = getFiles(opt.path)
       // filter lng files...
-      const lngIndex = filledLngMask.indexOf(lng);
-      const lngLeftLength = filledLngMask.length - lngIndex;
+      const lngIndex = filledLngMask.indexOf(lng)
+      const lngLeftLength = filledLngMask.length - lngIndex
       files = files.filter((f) => { // {{language}} can be left or right of {{namespace}}
         if (opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`) < opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`)) {
-          return f.indexOf(lng) === lngIndex;
+          return f.indexOf(lng) === lngIndex
         }
-        return (path.basename(f, path.extname(f)).length - f.indexOf(lng)) === lngLeftLength;
-      });
+        return (path.basename(f, path.extname(f)).length - f.indexOf(lng)) === lngLeftLength
+      })
     }
   } catch (err) {}
   async.map(files, (file, clb) => {
-    var dirPath;
+    let dirPath
     if (file.lastIndexOf(path.sep) > 0) {
-      dirPath = file.substring(0, file.lastIndexOf(path.sep));
-      file = file.substring(file.lastIndexOf(path.sep) + 1);
+      dirPath = file.substring(0, file.lastIndexOf(path.sep))
+      file = file.substring(file.lastIndexOf(path.sep) + 1)
     }
-    const fExt = path.extname(file);
-    var namespace = path.basename(file, fExt);
-    const nsMask = `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`;
-    const filledNsMask = lngPath && lngPath.indexOf(nsMask) > -1 ? filledLngMask : filledLngMask.substring(filledLngMask.lastIndexOf(path.sep) + 1);
-    const startNsIndex = filledNsMask.indexOf(nsMask);
-    var restNsMask = filledNsMask.substring((startNsIndex || 0) + nsMask.length);
-    namespace = namespace.substring(startNsIndex || 0, namespace.lastIndexOf(restNsMask));
+    const fExt = path.extname(file)
+    let namespace = path.basename(file, fExt)
+    const nsMask = `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`
+    const filledNsMask = lngPath && lngPath.indexOf(nsMask) > -1 ? filledLngMask : filledLngMask.substring(filledLngMask.lastIndexOf(path.sep) + 1)
+    const startNsIndex = filledNsMask.indexOf(nsMask)
+    let restNsMask = filledNsMask.substring((startNsIndex || 0) + nsMask.length)
+    namespace = namespace.substring(startNsIndex || 0, namespace.lastIndexOf(restNsMask))
     if (lngPath && lngPath.indexOf(nsMask) > -1) {
-      restNsMask = restNsMask.substring(0, restNsMask.lastIndexOf(path.sep));
+      restNsMask = restNsMask.substring(0, restNsMask.lastIndexOf(path.sep))
       if (dirPath.indexOf(restNsMask) > 0) {
-        namespace = dirPath.substring(filledNsMask.indexOf(nsMask), dirPath.indexOf(restNsMask));
+        namespace = dirPath.substring(filledNsMask.indexOf(nsMask), dirPath.indexOf(restNsMask))
       } else {
-        namespace = dirPath.substring(filledNsMask.indexOf(nsMask));
+        namespace = dirPath.substring(filledNsMask.indexOf(nsMask))
       }
     } else if (!hasNamespaceInPath && startNsIndex < 0) {
-      namespace = opt.namespace;
+      namespace = opt.namespace
     }
-    var fPath = path.join(opt.path, lngPath || '', file);
+    let fPath = path.join(opt.path, lngPath || '', file)
     if (dirPath && lngPath.indexOf(nsMask) > -1) {
-      fPath = path.join(opt.path, dirPath.replace(nsMask, namespace), file);
+      fPath = path.join(opt.path, dirPath.replace(nsMask, namespace), file)
     }
-    if (!namespace) return clb(new Error(`namespace could not be found in ${fPath}`));
-    if (opt.namespaces && opt.namespaces.indexOf(namespace) < 0) return clb(null);
-    if (opt.namespace && opt.namespace !== namespace) return clb(null);
+    if (!namespace) return clb(new Error(`namespace could not be found in ${fPath}`))
+    if (opt.namespaces && opt.namespaces.indexOf(namespace) < 0) return clb(null)
+    if (opt.namespace && opt.namespace !== namespace) return clb(null)
     fs.readFile(fPath, (err, data) => {
-      if (err) return clb(err);
+      if (err) return clb(err)
 
       if (fileExtensionsMap[fExt].indexOf(opt.format) < 0) {
-        return clb(new Error(`Format mismatch! Found ${fileExtensionsMap[fExt][0]} but requested ${opt.format}!`));
+        return clb(new Error(`Format mismatch! Found ${fileExtensionsMap[fExt][0]} but requested ${opt.format}!`))
       }
 
       if (opt.namespace) {
-        let hasNamespaceInPathPask = !opt.pathMask || !opt.pathMaskInterpolationPrefix || !opt.pathMaskInterpolationSuffix;
-        hasNamespaceInPathPask = !hasNamespaceInPathPask && opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1;
+        let hasNamespaceInPathPask = !opt.pathMask || !opt.pathMaskInterpolationPrefix || !opt.pathMaskInterpolationSuffix
+        hasNamespaceInPathPask = !hasNamespaceInPathPask && opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1
         if (!hasNamespaceInPathPask && namespace === lng) {
-          namespace = opt.namespace;
+          namespace = opt.namespace
         }
       }
 
       if (opt.format === 'xcstrings') { // 1 file per namespace including all languages
         try {
-          const content = xcstrings2locize(data);
+          const content = xcstrings2locize(data)
 
           fs.stat(fPath, (err, stat) => {
-            if (err) return clb(err);
+            if (err) return clb(err)
 
             clb(null, Object.keys(content.resources).map((l) => ({
-              namespace: namespace,
+              namespace,
               path: fPath,
               extension: fExt,
               content: content.resources[l],
               language: l,
               mtime: stat.mtime
-            })));
-          });
+            })))
+          })
         } catch (e) {
-          err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '');
-          err.message += '\n' + fPath;
-          return clb(err);
+          err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '')
+          err.message += '\n' + fPath
+          return clb(err)
         }
       } else { // 1 file per namespace/lng
         convertToFlatFormat(opt, data, lng, (err, content) => {
           if (err) {
-            err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '');
-            err.message += '\n' + fPath;
-            return clb(err);
+            err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '')
+            err.message += '\n' + fPath
+            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,
-              content: content,
+              content,
               language: lng,
               mtime: stat.mtime
-            });
-          });
-        });
+            })
+          })
+        })
       }
-    });
+    })
   }, (err, ret) => {
-    if (err) return cb(err);
+    if (err) return cb(err)
     // xcstrings, returns array in array
     const r = ret.filter((r) => r !== undefined).reduce((prev, cur) => {
       if (Array.isArray(cur)) {
-        prev = prev.concat(cur);
+        prev = prev.concat(cur)
       } else {
-        prev.push(cur);
+        prev.push(cur)
       }
-      return prev;
-    }, []);
-    cb(null, r);
-  });
-};
+      return prev
+    }, [])
+    cb(null, r)
+  })
+}
 
-module.exports = parseLocalLanguage;
+module.exports = parseLocalLanguage

package/parseLocalLanguages.js

@@ -1,22 +1,22 @@
-const async = require('async');
-const parseLocalLanguage = require('./parseLocalLanguage');
-const filterNamespaces = require('./filterNamespaces');
+const async = require('async')
+const parseLocalLanguage = require('./parseLocalLanguage')
+const filterNamespaces = require('./filterNamespaces')
 
 const parseLocalLanguages = (opt, lngs, cb) => {
-  var res = [];
+  let res = []
   async.each(lngs, (lng, clb) => {
     if (opt.language && (lng !== opt.language && lng !== opt.referenceLanguage)) {
-      return clb();
+      return clb()
     }
     parseLocalLanguage(opt, lng, (err, nss) => {
-      if (err) return clb(err);
-      res = res.concat(filterNamespaces(opt, nss));
-      clb();
-    });
+      if (err) return clb(err)
+      res = res.concat(filterNamespaces(opt, nss))
+      clb()
+    })
   }, (err) => {
-    if (err) return cb(err);
-    cb(null, res);
-  });
-};
+    if (err) return cb(err)
+    cb(null, res)
+  })
+}
 
-module.exports = parseLocalLanguages;
+module.exports = parseLocalLanguages

package/parseLocalReference.js

@@ -1,10 +1,10 @@
-const parseLocalLanguage = require('./parseLocalLanguage');
-const filterNamespaces = require('./filterNamespaces');
+const parseLocalLanguage = require('./parseLocalLanguage')
+const filterNamespaces = require('./filterNamespaces')
 
 const parseLocalReference = (opt, cb) => parseLocalLanguage(opt, opt.referenceLanguage, (err, nss) => {
-  if (err) return cb(err);
+  if (err) return cb(err)
 
-  cb(err, filterNamespaces(opt, nss).filter((n) => n.language === opt.referenceLanguage));
-});
+  cb(err, filterNamespaces(opt, nss).filter((n) => n.language === opt.referenceLanguage))
+})
 
-module.exports = parseLocalReference;
+module.exports = parseLocalReference