cli.collect.js

const inquirer = require('inquirer');
const joi = require('joi');
const fs = require('fs');
const path = require('path');
const chalk = require('chalk');
const {
    plantumlVersions
} = require('./utils')

const validate = (schema) => answers => {
    return !(joi.validate(answers, schema).error);
};

module.exports = async (currentConfiguration, conf, program) => {
    if (!currentConfiguration.PROJECT_NAME || program.config) {
        responses = await inquirer.prompt({
            type: 'input',
            name: 'projectName',
            message: 'Project Name',
            default: currentConfiguration.PROJECT_NAME || path.parse(process.cwd()).name,
            validate: validate(joi.string().trim().optional())
        });
        conf.set('projectName', responses.projectName);
    }

    if (!currentConfiguration.HOMEPAGE_NAME || program.config) {
        responses = await inquirer.prompt({
            type: 'input',
            name: 'homepageName',
            message: 'HomePage Name',
            default: currentConfiguration.HOMEPAGE_NAME || 'Overview',
            validate: validate(joi.string().trim().optional())
        });
        conf.set('homepageName', responses.homepageName);
    }

    if (!currentConfiguration.ROOT_FOLDER || program.config) {
        responses = await inquirer.prompt({
            type: 'input',
            name: 'rootFolder',
            message: 'Root documentation folder',
            default: currentConfiguration.ROOT_FOLDER || 'src',
            validate: answers => {
                let isValid = validate(joi.string().trim().optional())(answers);
                if (isValid) {
                    if (answers.indexOf('/') !== -1 || answers.indexOf('\\') !== -1)
                        return false;

                    //check it's an actual folder
                    let isDirectory = fs.statSync(path.join(process.cwd(), answers)).isDirectory();
                    if (isDirectory)
                        return true;
                }
                return false;
            }
        });
        conf.set('rootFolder', responses.rootFolder);
    }

    if (!currentConfiguration.DIST_FOLDER || program.config) {
        responses = await inquirer.prompt({
            type: 'input',
            name: 'distFolder',
            message: 'Destination folder',
            default: currentConfiguration.DIST_FOLDER || 'docs',
            validate: answers => {
                let isValid = validate(joi.string().trim().optional());
                if (isValid) {
                    if (answers.indexOf('/') !== -1 || answers.indexOf('\\') !== -1)
                        return false;
                    return true;
                }
                return false;
            }
        });
        conf.set('distFolder', responses.distFolder);
    }

    if (currentConfiguration.GENERATE_MD === undefined || currentConfiguration.GENERATE_COMPLETE_MD_FILE === undefined ||
        currentConfiguration.GENERATE_PDF === undefined || currentConfiguration.GENERATE_COMPLETE_PDF_FILE === undefined ||
        currentConfiguration.GENERATE_WEBSITE === undefined || program.config) {

        let defaults = [
            currentConfiguration.GENERATE_MD === undefined ? null : currentConfiguration.GENERATE_MD ? 'generateMD' : null,
            currentConfiguration.GENERATE_PDF === undefined ? 'generatePDF' : currentConfiguration.GENERATE_PDF ? 'generatePDF' : null,
            currentConfiguration.GENERATE_COMPLETE_MD_FILE === undefined ? null : currentConfiguration.GENERATE_COMPLETE_MD_FILE ? 'generateCompleteMD' : null,
            currentConfiguration.GENERATE_COMPLETE_PDF_FILE === undefined ? 'generateCompletePDF' : currentConfiguration.GENERATE_COMPLETE_PDF_FILE ? 'generateCompletePDF' : null,
            currentConfiguration.GENERATE_WEBSITE === undefined ? 'generateWEB' : currentConfiguration.GENERATE_WEBSITE ? 'generateWEB' : null
        ];

        responses = await inquirer.prompt({
            type: 'checkbox',
            name: 'generate',
            message: 'Compilation format:',
            default: defaults,
            choices: [{
                name: 'Multiple markdown files',
                value: 'generateMD'
            }, {
                name: 'Generate a single complete markdown file',
                value: 'generateCompleteMD'
            }, {
                name: 'Generate multiple pdf files',
                value: 'generatePDF'
            }, {
                name: 'Generate a single complete pdf file',
                value: 'generateCompletePDF'
            }, {
                name: 'Generate website',
                value: 'generateWEB'
            }]
        });

        conf.set('generateMD', !!responses.generate.find(x => x === 'generateMD'));
        conf.set('generatePDF', !!responses.generate.find(x => x === 'generatePDF'));
        conf.set('generateCompleteMD', !!responses.generate.find(x => x === 'generateCompleteMD'));
        conf.set('generateCompletePDF', !!responses.generate.find(x => x === 'generateCompletePDF'));
        conf.set('generateWEB', !!responses.generate.find(x => x === 'generateWEB'));

        if (!!responses.generate.find(x => x === 'generateMD')) {
            let mdOptions = await inquirer.prompt({
                type: 'confirm',
                name: 'includeNavigation',
                message: 'Include basic navigation?',
                default: currentConfiguration.INCLUDE_NAVIGATION === undefined ? false : currentConfiguration.INCLUDE_NAVIGATION
            });
            conf.set('includeNavigation', mdOptions.includeNavigation);

            mdOptions = await inquirer.prompt({
                type: 'confirm',
                name: 'includeTableOfContents',
                message: 'Include navigable table of contents?',
                default: currentConfiguration.INCLUDE_TABLE_OF_CONTENTS === undefined ? true : currentConfiguration.INCLUDE_TABLE_OF_CONTENTS
            });
            conf.set('includeTableOfContents', mdOptions.includeTableOfContents);
        }

        if (!!responses.generate.find(x => x === 'generateWEB')) {
            let webOptions = await inquirer.prompt({
                type: 'input',
                name: 'webTheme',
                message: 'Change the default docsify theme?',
                default: currentConfiguration.WEB_THEME || '//unpkg.com/docsify/lib/themes/vue.css'
            });
            conf.set('webTheme', webOptions.webTheme);

            webOptions = await inquirer.prompt({
                type: 'input',
                name: 'repoUrl',
                message: 'Include a repository url?',
                default: currentConfiguration.REPO_NAME
            });
            conf.set('repoUrl', webOptions.repoUrl);

            webOptions = await inquirer.prompt({
                type: 'input',
                name: 'webPort',
                message: 'Change the default serve port?',
                default: currentConfiguration.WEB_PORT || '3000'
            });
            conf.set('webPort', webOptions.webPort);
        }

        if (!!responses.generate.find(x => x === 'generatePDF' || x === 'generateCompletePDF')) {
            let pdfOptions = await inquirer.prompt({
                type: 'input',
                name: 'pdfCss',
                message: 'Add a custom css for the pdf (filename)?',
                default: currentConfiguration.PDF_CSS
            });
            conf.set('pdfCss', pdfOptions.pdfCss);
        }
    }

    let plantumlVersion, ver;
    if (currentConfiguration.PLANTUML_VERSION === undefined || program.config) {
        let defaultPlantumlVersion = currentConfiguration.PLANTUML_VERSION === undefined ? 'latest' : currentConfiguration.PLANTUML_VERSION;
        responses = await inquirer.prompt({
            type: 'list',
            name: 'plantumlVersion',
            message: 'PlantUML version:',
            default: defaultPlantumlVersion,
            choices: plantumlVersions.map(v => {
                return {
                    name: v.version,
                    value: v.version
                };
            }).concat({
                name: 'latest (compatible with plantuml online server)',
                value: 'latest'
            })
        });
        plantumlVersion = responses.plantumlVersion;
        conf.set('plantumlVersion', plantumlVersion);
        if (currentConfiguration.PLANTUML_VERSION && plantumlVersion !== currentConfiguration.PLANTUML_VERSION) {
            console.log(chalk.bold(chalk.yellow('WARNING:')));
            console.log(chalk.bold(chalk.yellow(`You need to update the plantuml file to include https://raw.githubusercontent.com/adrianvlupu/C4-PlantUML/${plantumlVersion}.`)));
        }
    } else {
        plantumlVersion = currentConfiguration.PLANTUML_VERSION;
    }
    ver = plantumlVersions.find(v => v.version === plantumlVersion);
    if (plantumlVersion === 'latest')
        ver = plantumlVersions.find(v => v.isLatest);
    if (!ver)
        throw new Error(`PlantUML version ${options.PLANTUML_VERSION} not supported`);
    if (!ver.isLatest){
        console.log(chalk.bold(chalk.yellow(`Generating diagram images using the online plantuml server will break on version ${ver.version}.`)));
        console.log(chalk.bold(chalk.yellow(`The build will generate diagram images using the included ${ver.jar}.`)));
    }

    if (currentConfiguration.GENERATE_LOCAL_IMAGES === undefined ||
        currentConfiguration.INCLUDE_BREADCRUMBS === undefined || currentConfiguration.INCLUDE_LINK_TO_DIAGRAM === undefined || program.config) {
        let defaults = [
            currentConfiguration.INCLUDE_BREADCRUMBS === undefined ? 'includeBreadcrumbs' : currentConfiguration.INCLUDE_BREADCRUMBS ? 'includeBreadcrumbs' : null,
            currentConfiguration.GENERATE_LOCAL_IMAGES === undefined ? null : currentConfiguration.GENERATE_LOCAL_IMAGES ? 'generateLocalImages' : null,
            currentConfiguration.INCLUDE_LINK_TO_DIAGRAM === undefined ? null : currentConfiguration.INCLUDE_LINK_TO_DIAGRAM ? 'includeLinkToDiagram' : null,
            currentConfiguration.DIAGRAMS_ON_TOP === undefined ? 'diagramsOnTop' : currentConfiguration.DIAGRAMS_ON_TOP ? 'diagramsOnTop' : null
        ];
        let choices = [{
            name: 'Include breadcrumbs',
            value: 'includeBreadcrumbs'
        }, {
            name: 'Replace diagrams with a link',
            value: 'includeLinkToDiagram'
        }, {
            name: 'Place diagrams before text',
            value: 'diagramsOnTop'
        }];
        if (ver.isLatest)
            choices.push({
                name: 'Generate diagram images locally',
                value: 'generateLocalImages'
            });

        responses = await inquirer.prompt({
            type: 'checkbox',
            name: 'generate',
            message: 'Compilation format:',
            default: defaults,
            choices: choices
        });
        conf.set('includeBreadcrumbs', !!responses.generate.find(x => x === 'includeBreadcrumbs'));
        conf.set('includeLinkToDiagram', !!responses.generate.find(x => x === 'includeLinkToDiagram'));
        conf.set('diagramsOnTop', !!responses.generate.find(x => x === 'diagramsOnTop'));
        if (ver.isLatest) {
            conf.set('generateLocalImages', !!responses.generate.find(x => x === 'generateLocalImages'));
        } else {
            conf.set('generateLocalImages', true);
        }
    }

    if (!currentConfiguration.CHARSET || program.config) {
        responses = await inquirer.prompt({
            type: 'input',
            name: 'charset',
            message: 'Change the default charset',
            default: currentConfiguration.CHARSET || 'UTF-8'
        });
        conf.set('charset', responses.charset);
    }
};