@4dsas/doc_preprocessing/lib/processCommandLine.js

Preprocess 4D doc to be built by docusaurus

const preproc = require("./preprocessor.js")
const settings = require("./settings.js")
const path = require('path')
const fs = require('fs')
const { glob } = require("glob");


async function write(inPath, newContent) {
    await fs.promises.mkdir(path.dirname(inPath), { recursive: true });
    await fs.promises.writeFile(inPath, newContent);
}

function replaceLanguage(inContent, inLanguage) {
    inContent = inContent.replace(/%[A-Z]*%/g, function (v) { return inLanguage.toUpperCase(); })
    inContent = inContent.replace(/%[a-zA-Z]*%/g, function (v) { return inLanguage })
    return inContent;
}

async function Preprocess(inSettings) {
    let preprocessor = new preproc.Preprocessing(inSettings)
    await preprocessor.run()
    const syntaxOutput = inSettings.getString(settings.SETTINGS_KEY.SYNTAX_OUTPUT)
    if (syntaxOutput.length > 0) {
        const c = preprocessor.getSyntaxObject()
        console.log(`Write to ${syntaxOutput}`)
        await write(syntaxOutput, JSON.stringify(c, null, inSettings.getBoolean(settings.SETTINGS_KEY.SYNTAX_PRETTY) ? "\t" : ""))
    }
}


function preprocessMultipleFolders(inTargetPath, info) {

    return new Promise((resolve) => {
        let listPromises = [];
        let listLanguages = [];
        listLanguages = info.getArray(settings.SETTINGS_KEY.LANGUAGES_LIST);
        if (!listLanguages)
            listLanguages = []

        if (listLanguages.length > 0) {
            for (let language of listLanguages) {
                const targetPath = replaceLanguage(inTargetPath, language)
                const folders = glob.sync(targetPath, { mark: true });

                for (const folder of folders) {

                    let i = info.clone()
                    const syntaxOutput = i.getString(settings.SETTINGS_KEY.SYNTAX_OUTPUT)
                    const outputPath = path.join(i.getString(settings.SETTINGS_KEY.OUTPUT), folder)
                    i.set(settings.SETTINGS_KEY.OUTPUT, outputPath)
                    i.set(settings.SETTINGS_KEY.PATH, folder)
                    i.set(settings.SETTINGS_KEY.SYNTAX_OUTPUT, replaceLanguage(syntaxOutput, language))
                    i.set(settings.SETTINGS_KEY.LIST_ARGS, { "language": language })

                    let listExclusions = i.getArray(settings.SETTINGS_KEY.EXCLUDE_LIST)
                    if (listExclusions) {
                        listExclusions.map(x => replaceLanguage(x, language))
                        i.set(settings.SETTINGS_KEY.EXCLUDE_LIST, listExclusions)
                    }

                    listPromises.push(Preprocess(i))
                }
                Promise.all(listPromises).then(() => { resolve() })
            }
        }
        else {
            let listPromises = [];
            const folders = glob.sync(inTargetPath, { mark: true });
            //for each folder launch a preprocess
            for (let folder of folders) {
                let i = info.clone()
                const outputPath = path.join(i.getString(settings.SETTINGS_KEY.OUTPUT), folder)
                i.set(settings.SETTINGS_KEY.OUTPUT, outputPath)
                i.set(settings.SETTINGS_KEY.PATH, folder)
                const syntaxOutput = i.getString(settings.SETTINGS_KEY.SYNTAX_OUTPUT);
                i.set(settings.SETTINGS_KEY.SYNTAX_OUTPUT, syntaxOutput)

                listPromises.push(Preprocess(i))
            }
            Promise.all(listPromises).finally(() => { resolve() })
        }
    })
}



async function processSettingsMultipleFolder(info) {
    let pathToProcess = info.getString(settings.SETTINGS_KEY.PATH);
    if (pathToProcess.length > 0) {

        async function run(info) {
            await preprocessMultipleFolders(pathToProcess, info)
        }

        console.time("Preprocessing")
        await run(info)
        console.timeEnd("Preprocessing")
    }
}



module.exports = {
    processSettingsMultipleFolder
}