cspell/dist/app.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CheckFailed = exports.run = void 0;
const path = require("path");
const commander = require("commander");
// eslint-disable-next-line @typescript-eslint/no-var-requires
const npmPackage = require(path.join(__dirname, '..', 'package.json'));
const application_1 = require("./application");
const App = require("./application");
const chalk = require("chalk");
// interface InitOptions extends Options {}
const templateIssue = `${chalk.green('${uri}')}:${chalk.yellow('${row}:${col}')} - Unknown word (${chalk.red('${text}')})`;
const templateIssueLegacy = `${chalk.green('${uri}')}[\${row}, \${col}]: Unknown word: ${chalk.red('${text}')}`;
const templateIssueWordsOnly = '${text}';
function genIssueEmitter(template) {
    return function issueEmitter(issue) {
        console.log(formatIssue(template, issue));
    };
}
function errorEmitter(message, error) {
    console.error(chalk.red(message), error.toString());
}
function infoEmitter(message, msgType) {
    switch (msgType) {
        case 'Debug':
            console.info(chalk.cyan(message));
            break;
        case 'Info':
            console.info(chalk.yellow(message));
            break;
        case 'Progress':
            console.info(chalk.white(message));
            break;
    }
}
function debugEmitter(message) {
    infoEmitter(message, App.MessageTypes.Debug);
}
function nullEmitter(_) {
    /* empty */
}
async function asyncNullEmitter(_) {
    /* empty */
}
function getEmitters(options) {
    const issueTemplate = options.wordsOnly
        ? templateIssueWordsOnly
        : options.legacy
            ? templateIssueLegacy
            : templateIssue;
    const { silent = false, issues } = options;
    return {
        issue: silent || !issues ? nullEmitter : genIssueEmitter(issueTemplate),
        error: silent ? asyncNullEmitter : errorEmitter,
        info: silent || !options.verbose ? nullEmitter : infoEmitter,
        debug: options.debug ? debugEmitter : nullEmitter,
    };
}
async function run(program, argv) {
    const prog = program || commander;
    const args = argv || process.argv;
    prog.passCommandToAction(false);
    return new Promise((resolve, rejects) => {
        let showHelp = true;
        prog.exitOverride();
        prog.version(npmPackage.version)
            .description('Spelling Checker for Code')
            .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
            .option('--no-color', 'Turn off color.')
            .option('--color', 'Force color');
        prog.option('-v, --verbose', 'display more information about the files being checked and the configuration')
            .option('--local <local>', 'Set language locals. i.e. "en,fr" for English and French, or "en-GB" for British English.')
            .option('--language-id <language>', 'Force programming language for unknown extensions. i.e. "php" or "scala"')
            .option('--languageId <language>', 'Force programming language for unknown extensions. i.e. "php" or "scala"')
            .option('--wordsOnly', 'Only output the words not found in the dictionaries.')
            .option('-u, --unique', 'Only output the first instance of a word not found in the dictionaries.')
            .option('--debug', 'Output information useful for debugging cspell.json files.')
            .option('-e, --exclude <glob>', 'Exclude files matching the glob pattern')
            .option('--no-issues', 'Do not show the spelling errors.')
            .option('--no-summary', 'Turn off summary message in console')
            .option('-s, --silent', 'Silent mode, suppress error messages')
            .option('-r, --root <root folder>', 'Root directory, defaults to current directory.')
            .option('--must-find-files', 'Error if no files are found', false)
            .option('--no-must-find-files', 'Do not error is no files are found')
            // The following options are planned features
            // .option('-w, --watch', 'Watch for any changes to the matching files and report any errors')
            // .option('--force', 'Force the exit value to always be 0')
            .option('--legacy', 'Legacy output')
            .arguments('<files...>')
            .action((files, options) => {
            const { mustFindFiles } = options;
            const emitters = getEmitters(options);
            if (!files || !files.length) {
                return;
            }
            showHelp = false;
            return App.lint(files, options, emitters).then((result) => {
                if (options.summary && !options.silent) {
                    console.error('CSpell: Files checked: %d, Issues found: %d in %d files', result.files, result.issues, result.filesWithIssues.size);
                }
                if (result.issues || result.errors || (mustFindFiles && !result.files)) {
                    throw new CheckFailed('check failed', 1);
                }
            });
        });
        prog.command('trace')
            .description('Trace words')
            .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
            .option('--local <local>', 'Set language locals. i.e. "en,fr" for English and French, or "en-GB" for British English.')
            .option('--languageId <language>', 'Force programming language for unknown extensions. i.e. "php" or "scala"')
            .option('--no-color', 'Turn off color.')
            .option('--color', 'Force color')
            .arguments('<words...>')
            .action((words, options) => {
            showHelp = false;
            return App.trace(words, options).then((result) => {
                result.forEach(emitTraceResult);
            });
        });
        prog.command('check <files...>')
            .description('Spell check file(s) and display the result. The full file is displayed in color.')
            .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
            .option('--no-color', 'Turn off color.')
            .option('--color', 'Force color')
            .action(async (files, options) => {
            showHelp = false;
            for (const filename of files) {
                console.log(chalk.yellowBright(`Check file: ${filename}`));
                console.log();
                try {
                    const result = await application_1.checkText(filename, options);
                    for (const item of result.items) {
                        const fn = item.flagIE === App.IncludeExcludeFlag.EXCLUDE
                            ? chalk.gray
                            : item.isError
                                ? chalk.red
                                : chalk.whiteBright;
                        const t = fn(item.text);
                        process.stdout.write(t);
                    }
                    console.log();
                }
                catch (e) {
                    console.error(`Failed to read "${filename}"`);
                }
                console.log();
            }
        });
        /*
        program
            .command('init')
            .description('(Alpha) Initialize a cspell.json file.')
            .option('-o, --output <cspell.json>', 'define where to write file.')
            .option('--extends <cspell.json>', 'extend an existing cspell.json file.')
            .action((options: InitOptions) => {
                showHelp = false;
                CSpellApplication.createInit(options).then(
                    () => process.exit(0),
                    () => process.exit(1)
                );
                console.log('Init');
            });
        */
        const usage = `

Examples:
    cspell "*.js"                   Check all .js files in the current directory
    cspell "**/*.js"                Check all .js files from the current directory
    cspell "src/**/*.js"            Only check .js under src
    cspell "**/*.txt" "**/*.js"     Check both .js and .txt files.
    cat LICENSE | cspell stdin      Read from stdin the contents of LICENSE
`;
        prog.on('--help', function () {
            console.log(usage);
            showHelp = false;
        });
        function reject(e) {
            if (showHelp) {
                prog.help();
            }
            rejects(e);
        }
        try {
            prog.parseAsync(args)
                .then(() => {
                if (showHelp) {
                    prog.help();
                }
                resolve();
            })
                .catch(reject);
        }
        catch (e) {
            reject(e);
        }
    });
}
exports.run = run;
function emitTraceResult(r) {
    const terminalWidth = process.stdout.columns || 120;
    const widthName = 20;
    const w = chalk.green(r.word);
    const f = r.found ? chalk.whiteBright('*') : chalk.dim('-');
    const n = chalk.yellowBright(pad(r.dictName, widthName));
    const used = [r.word.length, 1, widthName].reduce((a, b) => a + b, 3);
    const widthSrc = terminalWidth - used;
    const s = chalk.white(trimMid(r.dictSource, widthSrc));
    const line = [w, f, n, s].join(' ');
    console.log(line);
}
function pad(s, w) {
    return (s + ' '.repeat(w)).substr(0, w);
}
function trimMid(s, w) {
    if (s.length <= w) {
        return s;
    }
    const l = Math.floor((w - 3) / 2);
    const r = Math.ceil((w - 3) / 2);
    return s.substr(0, l) + '...' + s.substr(-r);
}
function formatIssue(template, issue) {
    const { uri = '', row, col, text } = issue;
    return template
        .replace(/\$\{uri\}/, uri)
        .replace(/\$\{row\}/, row.toString())
        .replace(/\$\{col\}/, col.toString())
        .replace(/\$\{text\}/, text);
}
class CheckFailed extends Error {
    constructor(message, errorCode) {
        super(message);
        this.errorCode = errorCode;
    }
}
exports.CheckFailed = CheckFailed;
//# sourceMappingURL=app.js.map