scratch-l10n/scripts/validate-extension-inputs.mjs

#!/usr/bin/env node
/**
 * @file
 * Script to validate extension block input placeholders
 */
import assert from 'assert'
import async from 'async'
import fs from 'fs'
import path from 'path'
import locales from '../src/supported-locales.mjs'

// Globals
const JSON_DIR = path.join(process.cwd(), '/editor/extensions')
const source = JSON.parse(fs.readFileSync(`${JSON_DIR}/en.json`))

// Matches everything inside brackets, and the brackets themselves.
// e.g. matches '[MOTOR_ID]', '[POWER]' from 'altera a potência de [MOTOR_ID] para [POWER]'
const blockInputRegex = /\[.+?\]/g

let numTotalErrors = 0

const validateExtensionInputs = (translationData, locale) => {
  let numLocaleErrors = 0
  for (const block of Object.keys(translationData)) {
    const englishBlockInputs = source[block].match(blockInputRegex)

    if (!englishBlockInputs) continue

    // If null (meaning no matches), that means that English block inputs exist but translated ones don't.
    // Coerce it to an empty array so that the assertion below fails, instead of getting the less-helpful error
    // that we can't call Array.includes on null.
    const translatedBlockInputs = translationData[block].match(blockInputRegex) || []

    for (const input of englishBlockInputs) {
      // Currently there are enough errors here that it would be tedious to fix an error, rerun this tool
      // to find the next error, and repeat. So, catch the assertion error and add to the number of total errors.
      // This allows all errors to be displayed when the command is run, rather than just the first encountered.
      try {
        assert(
          translatedBlockInputs.includes(input),

          `Block '${block}' in locale '${locale}' does not include input ${input}:\n` + translationData[block],
        )
      } catch (err) {
        numLocaleErrors++
        console.error(err.message + '\n')
      }
    }
  }

  if (numLocaleErrors > 0) {
    numTotalErrors += numLocaleErrors
    throw new Error(`${numLocaleErrors} total error(s) for locale '${locale}'`)
  }
}

const validate = (locale, callback) => {
  fs.readFile(`${JSON_DIR}/${locale}.json`, (err, data) => {
    if (err) callback(err)
    // let this throw an error if invalid json
    data = JSON.parse(data)

    try {
      validateExtensionInputs(data, locale)
    } catch (error) {
      console.error(error.message + '\n')
    }

    callback()
  })
}

async.each(Object.keys(locales), validate, err => {
  if (err) {
    console.error(err)
    process.exit(1)
  }

  if (numTotalErrors > 0) {
    console.error(`${numTotalErrors} total extension input error(s)`)
    process.exit(1)
  }
})