hyperzlib
/
nodebb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: #7743, meta/languages and languages

Browse Source
v1.18.x
Barış Soner Uşaklı 6 years ago
parent 66aa443b7a
commit c02686bfc8
2 changed files with 171 additions and 230 deletions
Show Stats Download Patch File Download Diff File

112
src/languages.js
Unescape Escape View File

@ -1,99 +1,73 @@
'use strict'; 'use strict';
var fs = require('fs'); const fs = require('fs');
var path = require('path'); const path = require('path');
var async = require('async');
var Languages = module.exports; const util = require('util');
var languagesPath = path.join(__dirname, '../build/public/language'); const readFileAsync = util.promisify(fs.readFile);
const Languages = module.exports;
const languagesPath = path.join(__dirname, '../build/public/language');
const files = fs.readdirSync(path.join(__dirname, '../public/vendor/jquery/timeago/locales')); const files = fs.readdirSync(path.join(__dirname, '../public/vendor/jquery/timeago/locales'));
Languages.timeagoCodes = files.filter(f => f.startsWith('jquery.timeago')).map(f => f.split('.')[2]); Languages.timeagoCodes = files.filter(f => f.startsWith('jquery.timeago')).map(f => f.split('.')[2]);
Languages.get = function (language, namespace, callback) { Languages.get = async function (language, namespace) {
fs.readFile(path.join(languagesPath, language, namespace + '.json'), { encoding: 'utf-8' }, function (err, data) { let data = await readFileAsync(path.join(languagesPath, language, namespace + '.json'), 'utf8');
if (err) {
return callback(err);
}
try { try {
data = JSON.parse(data) || {}; data = JSON.parse(data) || {};
} catch (e) { } catch (err) {
return callback(e); throw err;
} }
return data;
callback(null, data);
});
}; };
var codeCache = null; let codeCache = null;
Languages.listCodes = function (callback) { Languages.listCodes = async function () {
if (codeCache && codeCache.length) { if (codeCache && codeCache.length) {
return callback(null, codeCache); return codeCache;
} }
fs.readFile(path.join(languagesPath, 'metadata.json'), 'utf8', function (err, file) {
if (err && err.code === 'ENOENT') {
return callback(null, []);
}
if (err) {
return callback(err);
}
var parsed;
try { try {
parsed = JSON.parse(file); const file = await readFileAsync(path.join(languagesPath, 'metadata.json'), 'utf8');
} catch (e) { const parsed = JSON.parse(file);
return callback(e);
codeCache = parsed.languages;
return parsed.languages;
} catch (err) {
if (err.code === 'ENOENT') {
return [];
}
throw err;
} }
var langs = parsed.languages;
codeCache = langs;
callback(null, langs);
});
}; };
var listCache = null; let listCache = null;
Languages.list = function (callback) { Languages.list = async function () {
if (listCache && listCache.length) { if (listCache && listCache.length) {
return callback(null, listCache); return listCache;
}
Languages.listCodes(function (err, codes) {
if (err) {
return callback(err);
} }
async.map(codes, function (folder, next) { const codes = await Languages.listCodes();
var configPath = path.join(languagesPath, folder, 'language.json');
fs.readFile(configPath, 'utf8', function (err, file) { let languages = await Promise.all(codes.map(async function (folder) {
if (err && err.code === 'ENOENT') {
return next();
}
if (err) {
return next(err);
}
var lang;
try { try {
lang = JSON.parse(file); const configPath = path.join(languagesPath, folder, 'language.json');
} catch (e) { const file = await readFileAsync(configPath, 'utf8');
return next(e); const lang = JSON.parse(file);
return lang;
} catch (err) {
if (err.code === 'ENOENT') {
return;
} }
next(null, lang); throw err;
});
}, function (err, languages) {
if (err) {
return callback(err);
} }
}));
// filter out invalid ones // filter out invalid ones
languages = languages.filter(function (lang) { languages = languages.filter(lang => lang && lang.code && lang.name && lang.dir);
return lang && lang.code && lang.name && lang.dir;
});
listCache = languages; listCache = languages;
callback(null, languages); return languages;
});
});
}; };
require('./promisify')(Languages);

193
src/meta/languages.js
Unescape Escape View File

@ -1,27 +1,27 @@
'use strict'; 'use strict';
var path = require('path'); const path = require('path');
var async = require('async'); const fs = require('fs');
var fs = require('fs'); const mkdirp = require('mkdirp');
var mkdirp = require('mkdirp'); const rimraf = require('rimraf');
var rimraf = require('rimraf'); const _ = require('lodash');
var _ = require('lodash');
const util = require('util');
var file = require('../file'); const mkdirpAsync = util.promisify(mkdirp);
var Plugins = require('../plugins'); const rimrafAsync = util.promisify(rimraf);
const writeFileAsync = util.promisify(fs.writeFile);
var buildLanguagesPath = path.join(__dirname, '../../build/public/language'); const readFileAsync = util.promisify(fs.readFile);
var coreLanguagesPath = path.join(__dirname, '../../public/language');
const file = require('../file');
function getTranslationMetadata(callback) { const Plugins = require('../plugins');
async.waterfall([
// generate list of languages and namespaces const buildLanguagesPath = path.join(__dirname, '../../build/public/language');
function (next) { const coreLanguagesPath = path.join(__dirname, '../../public/language');
file.walk(coreLanguagesPath, next);
}, async function getTranslationMetadata() {
function (paths, next) { const paths = await file.walk(coreLanguagesPath);
var languages = []; let languages = [];
var namespaces = []; let namespaces = [];
paths.forEach(function (p) { paths.forEach(function (p) {
if (!p.endsWith('.json')) { if (!p.endsWith('.json')) {
@ -40,130 +40,97 @@ function getTranslationMetadata(callback) {
namespaces.push(namespace); namespaces.push(namespace);
}); });
next(null, {
languages: _.union(languages, Plugins.languageData.languages).sort().filter(Boolean), languages = _.union(languages, Plugins.languageData.languages).sort().filter(Boolean);
namespaces: _.union(namespaces, Plugins.languageData.namespaces).sort().filter(Boolean), namespaces = _.union(namespaces, Plugins.languageData.namespaces).sort().filter(Boolean);
});
},
// save a list of languages to `${buildLanguagesPath}/metadata.json` // save a list of languages to `${buildLanguagesPath}/metadata.json`
// avoids readdirs later on // avoids readdirs later on
function (ref, next) { await mkdirpAsync(buildLanguagesPath);
async.series([ const result = {
function (next) { languages: languages,
mkdirp(buildLanguagesPath, next); namespaces: namespaces,
}, };
function (next) { await writeFileAsync(path.join(buildLanguagesPath, 'metadata.json'), JSON.stringify(result));
fs.writeFile(path.join(buildLanguagesPath, 'metadata.json'), JSON.stringify({ return result;
languages: ref.languages,
namespaces: ref.namespaces,
}), next);
},
], function (err) {
next(err, ref);
});
},
], callback);
} }
function writeLanguageFile(language, namespace, translations, callback) { async function writeLanguageFile(language, namespace, translations) {
var dev = global.env === 'development'; const dev = global.env === 'development';
var filePath = path.join(buildLanguagesPath, language, namespace + '.json'); const filePath = path.join(buildLanguagesPath, language, namespace + '.json');
async.series([ await mkdirpAsync(path.dirname(filePath));
async.apply(mkdirp, path.dirname(filePath)), await writeFileAsync(filePath, JSON.stringify(translations, null, dev ? 2 : 0));
async.apply(fs.writeFile, filePath, JSON.stringify(translations, null, dev ? 2 : 0)),
], callback);
} }
// for each language and namespace combination, // for each language and namespace combination,
// run through core and all plugins to generate // run through core and all plugins to generate
// a full translation hash // a full translation hash
function buildTranslations(ref, next) { async function buildTranslations(ref) {
var namespaces = ref.namespaces; const namespaces = ref.namespaces;
var languages = ref.languages; const languages = ref.languages;
var plugins = _.values(Plugins.pluginsData).filter(function (plugin) { const plugins = _.values(Plugins.pluginsData).filter(function (plugin) {
return typeof plugin.languages === 'string'; return typeof plugin.languages === 'string';
}); });
async.each(namespaces, function (namespace, next) { const promises = [];
async.each(languages, function (lang, next) {
var translations = {}; namespaces.forEach(function (namespace) {
languages.forEach(function (language) {
promises.push(buildNamespaceLanguage(language, namespace, plugins));
});
});
await Promise.all(promises);
}
async.series([ async function buildNamespaceLanguage(lang, namespace, plugins) {
const translations = {};
// core first // core first
function (cb) { await assignFileToTranslations(translations, path.join(coreLanguagesPath, lang, namespace + '.json'));
fs.readFile(path.join(coreLanguagesPath, lang, namespace + '.json'), 'utf8', function (err, file) {
if (err) {
if (err.code === 'ENOENT') {
return cb();
}
return cb(err);
}
try { await Promise.all(plugins.map(pluginData => addPlugin(translations, pluginData, lang, namespace)));
Object.assign(translations, JSON.parse(file));
cb(); if (Object.keys(translations).length) {
} catch (err) { await writeLanguageFile(lang, namespace, translations);
cb(err);
} }
}); }
},
function (cb) { async function addPlugin(translations, pluginData, lang, namespace) {
const pluginLanguages = path.join(__dirname, '../../node_modules/', pluginData.id, pluginData.languages);
const defaultLang = pluginData.defaultLang || 'en-GB';
// for each plugin, fallback in this order: // for each plugin, fallback in this order:
// 1. correct language string (en-GB) // 1. correct language string (en-GB)
// 2. old language string (en_GB) // 2. old language string (en_GB)
// 3. corrected plugin defaultLang (en-US) // 3. corrected plugin defaultLang (en-US)
// 4. old plugin defaultLang (en_US) // 4. old plugin defaultLang (en_US)
async.each(plugins, function (pluginData, done) { const langs = [
var pluginLanguages = path.join(__dirname, '../../node_modules/', pluginData.id, pluginData.languages);
var defaultLang = pluginData.defaultLang || 'en-GB';
async.eachSeries([
defaultLang.replace('-', '_').replace('-x-', '@'), defaultLang.replace('-', '_').replace('-x-', '@'),
defaultLang.replace('_', '-').replace('@', '-x-'), defaultLang.replace('_', '-').replace('@', '-x-'),
lang.replace('-', '_').replace('-x-', '@'), lang.replace('-', '_').replace('-x-', '@'),
lang, lang,
], function (language, next) { ];
fs.readFile(path.join(pluginLanguages, language, namespace + '.json'), 'utf8', function (err, file) {
if (err) { for (const language of langs) {
if (err.code === 'ENOENT') { /* eslint-disable no-await-in-loop */
return next(null, false); await assignFileToTranslations(translations, path.join(pluginLanguages, language, namespace + '.json'));
}
return next(err);
} }
}
async function assignFileToTranslations(translations, path) {
try { try {
Object.assign(translations, JSON.parse(file)); const fileData = await readFileAsync(path, 'utf8');
next(null, true); Object.assign(translations, JSON.parse(fileData));
} catch (err) { } catch (err) {
next(err); if (err.code !== 'ENOENT') {
} throw err;
});
}, done);
}, function (err) {
if (err) {
return cb(err);
} }
if (Object.keys(translations).length) {
writeLanguageFile(lang, namespace, translations, cb);
return;
} }
cb();
});
},
], next);
}, next);
}, next);
} }
exports.build = function buildLanguages(callback) { exports.build = async function buildLanguages() {
async.waterfall([ await rimrafAsync(buildLanguagesPath);
function (next) { const data = await getTranslationMetadata();
rimraf(buildLanguagesPath, next); await buildTranslations(data);
},
getTranslationMetadata,
buildTranslations,
], callback);
}; };

Write Preview
Loading…
Cancel
Save