269 lines
7.3 KiB
JavaScript
269 lines
7.3 KiB
JavaScript
/**
|
||
* Script to find missing translations in locale files for Jan
|
||
*
|
||
* Usage:
|
||
* node scripts/find-missing-translations.js [options]
|
||
*
|
||
* Options:
|
||
* --locale=<locale> Only check a specific locale (e.g. --locale=id)
|
||
* --file=<file> Only check a specific file (e.g. --file=common.json)
|
||
* --help Show this help message
|
||
*/
|
||
|
||
const fs = require('fs')
|
||
const path = require('path')
|
||
|
||
// Process command line arguments
|
||
const args = process.argv.slice(2).reduce((acc, arg) => {
|
||
if (arg === '--help') {
|
||
acc.help = true
|
||
} else if (arg.startsWith('--locale=')) {
|
||
acc.locale = arg.split('=')[1]
|
||
} else if (arg.startsWith('--file=')) {
|
||
acc.file = arg.split('=')[1]
|
||
}
|
||
return acc
|
||
}, {})
|
||
|
||
// Show help if requested
|
||
if (args.help) {
|
||
console.log(`
|
||
Find Missing Translations for Jan
|
||
|
||
A utility script to identify missing translations across locale files.
|
||
Compares non-English locale files to the English ones to find any missing keys.
|
||
|
||
Usage:
|
||
node scripts/find-missing-translations.js [options]
|
||
|
||
Options:
|
||
--locale=<locale> Only check a specific locale (e.g. --locale=id)
|
||
--file=<file> Only check a specific file (e.g. --file=common.json)
|
||
--help Show this help message
|
||
|
||
Output:
|
||
- Generates a report of missing translations for the web-app
|
||
`)
|
||
process.exit(0)
|
||
}
|
||
|
||
// Path to the locales directory
|
||
const LOCALES_DIR = path.join(__dirname, '../web-app/src/locales')
|
||
|
||
// Recursively find all keys in an object
|
||
function findKeys(obj, parentKey = '') {
|
||
let keys = []
|
||
|
||
for (const [key, value] of Object.entries(obj)) {
|
||
const currentKey = parentKey ? `${parentKey}.${key}` : key
|
||
|
||
if (typeof value === 'object' && value !== null) {
|
||
// If value is an object, recurse
|
||
keys = [...keys, ...findKeys(value, currentKey)]
|
||
} else {
|
||
// If value is a primitive, add the key
|
||
keys.push(currentKey)
|
||
}
|
||
}
|
||
|
||
return keys
|
||
}
|
||
|
||
// Get value at a dotted path in an object
|
||
function getValueAtPath(obj, path) {
|
||
const parts = path.split('.')
|
||
let current = obj
|
||
|
||
for (const part of parts) {
|
||
if (current === undefined || current === null) {
|
||
return undefined
|
||
}
|
||
current = current[part]
|
||
}
|
||
|
||
return current
|
||
}
|
||
|
||
// Function to check translations
|
||
function checkTranslations() {
|
||
// Get all locale directories (or filter to the specified locale)
|
||
const allLocales = fs.readdirSync(LOCALES_DIR).filter((item) => {
|
||
const stats = fs.statSync(path.join(LOCALES_DIR, item))
|
||
return stats.isDirectory() && item !== 'en' // Exclude English as it's our source
|
||
})
|
||
|
||
// Filter to the specified locale if provided
|
||
const locales = args.locale
|
||
? allLocales.filter((locale) => locale === args.locale)
|
||
: allLocales
|
||
|
||
if (args.locale && locales.length === 0) {
|
||
console.error(`Error: Locale '${args.locale}' not found in ${LOCALES_DIR}`)
|
||
process.exit(1)
|
||
}
|
||
|
||
console.log(
|
||
`Checking ${locales.length} non-English locale(s): ${locales.join(', ')}`
|
||
)
|
||
|
||
// Get all English JSON files
|
||
const englishDir = path.join(LOCALES_DIR, 'en')
|
||
let englishFiles = fs
|
||
.readdirSync(englishDir)
|
||
.filter((file) => file.endsWith('.json') && !file.startsWith('.'))
|
||
|
||
// Filter to the specified file if provided
|
||
if (args.file) {
|
||
if (!englishFiles.includes(args.file)) {
|
||
console.error(`Error: File '${args.file}' not found in ${englishDir}`)
|
||
process.exit(1)
|
||
}
|
||
englishFiles = englishFiles.filter((file) => file === args.file)
|
||
}
|
||
|
||
// Load file contents
|
||
let englishFileContents
|
||
|
||
try {
|
||
englishFileContents = englishFiles.map((file) => ({
|
||
name: file,
|
||
content: JSON.parse(fs.readFileSync(path.join(englishDir, file), 'utf8')),
|
||
}))
|
||
} catch (e) {
|
||
console.error(`Error: File '${englishDir}' is not a valid JSON file`)
|
||
process.exit(1)
|
||
}
|
||
|
||
console.log(
|
||
`Checking ${
|
||
englishFileContents.length
|
||
} translation file(s): ${englishFileContents.map((f) => f.name).join(', ')}`
|
||
)
|
||
|
||
// Results object to store missing translations
|
||
const missingTranslations = {}
|
||
|
||
// For each locale, check for missing translations
|
||
for (const locale of locales) {
|
||
missingTranslations[locale] = {}
|
||
|
||
for (const { name, content: englishContent } of englishFileContents) {
|
||
const localeFilePath = path.join(LOCALES_DIR, locale, name)
|
||
|
||
// Check if the file exists in the locale
|
||
if (!fs.existsSync(localeFilePath)) {
|
||
missingTranslations[locale][name] = { file: 'File is missing entirely' }
|
||
continue
|
||
}
|
||
|
||
// Load the locale file
|
||
let localeContent
|
||
|
||
try {
|
||
localeContent = JSON.parse(fs.readFileSync(localeFilePath, 'utf8'))
|
||
} catch (e) {
|
||
console.error(
|
||
`Error: File '${localeFilePath}' is not a valid JSON file`
|
||
)
|
||
process.exit(1)
|
||
}
|
||
|
||
// Find all keys in the English file
|
||
const englishKeys = findKeys(englishContent)
|
||
|
||
// Check for missing keys in the locale file
|
||
const missingKeys = []
|
||
|
||
for (const key of englishKeys) {
|
||
const englishValue = getValueAtPath(englishContent, key)
|
||
const localeValue = getValueAtPath(localeContent, key)
|
||
|
||
if (localeValue === undefined) {
|
||
missingKeys.push({
|
||
key,
|
||
englishValue,
|
||
})
|
||
}
|
||
}
|
||
|
||
if (missingKeys.length > 0) {
|
||
missingTranslations[locale][name] = missingKeys
|
||
}
|
||
}
|
||
}
|
||
|
||
return outputResults(missingTranslations)
|
||
}
|
||
|
||
// Function to output results
|
||
function outputResults(missingTranslations) {
|
||
let hasMissingTranslations = false
|
||
|
||
console.log(`\nMissing Translations Report:\n`)
|
||
|
||
for (const [locale, files] of Object.entries(missingTranslations)) {
|
||
if (Object.keys(files).length === 0) {
|
||
console.log(`✅ ${locale}: No missing translations`)
|
||
continue
|
||
}
|
||
|
||
hasMissingTranslations = true
|
||
console.log(`📝 ${locale}:`)
|
||
|
||
for (const [fileName, missingItems] of Object.entries(files)) {
|
||
if (missingItems.file) {
|
||
console.log(` - ${fileName}: ${missingItems.file}`)
|
||
continue
|
||
}
|
||
|
||
console.log(
|
||
` - ${fileName}: ${missingItems.length} missing translations`
|
||
)
|
||
|
||
for (const { key, englishValue } of missingItems) {
|
||
console.log(` ${key}: "${englishValue}"`)
|
||
}
|
||
}
|
||
|
||
console.log('')
|
||
}
|
||
|
||
return hasMissingTranslations
|
||
}
|
||
|
||
// Main function to find missing translations
|
||
function findMissingTranslations() {
|
||
try {
|
||
console.log('Starting translation check for Jan web-app...')
|
||
|
||
const hasMissingTranslations = checkTranslations()
|
||
|
||
// Summary
|
||
if (!hasMissingTranslations) {
|
||
console.log('\n✅ All translations are complete!')
|
||
} else {
|
||
console.log('\n✏️ To add missing translations:')
|
||
console.log('1. Add the missing keys to the corresponding locale files')
|
||
console.log('2. Translate the English values to the appropriate language')
|
||
console.log(
|
||
'3. You can use yq commands to update JSON files efficiently:'
|
||
)
|
||
console.log(
|
||
' yq -i \'.namespace.key = "Translation"\' web-app/src/locales/<locale>/<file>.json'
|
||
)
|
||
console.log(
|
||
'4. Run this script again to verify all translations are complete'
|
||
)
|
||
// Exit with error code to fail CI checks
|
||
process.exit(1)
|
||
}
|
||
} catch (error) {
|
||
console.error('Error:', error.message)
|
||
console.error(error.stack)
|
||
process.exit(1)
|
||
}
|
||
}
|
||
|
||
// Run the main function
|
||
findMissingTranslations()
|