@textlint/kernel/lib/src/fixer/fixer-processor.js

textlint kernel is core logic by pure JavaScript.

// LICENSE : MIT
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const fixer_task_1 = __importDefault(require("../task/fixer-task"));
const task_runner_1 = __importDefault(require("../task/task-runner"));
const TextlintSourceCodeImpl_1 = require("../context/TextlintSourceCodeImpl");
const debug_1 = __importDefault(require("debug"));
const source_code_fixer_1 = require("@textlint/source-code-fixer");
const invariant_1 = require("../util/invariant");
const parse_by_plugin_1 = require("../util/parse-by-plugin");
const debug = (0, debug_1.default)("textlint:fixer-processor");
class FixerProcessor {
    /**
     * @param {Processor} processor
     * @param {MessageProcessManager} messageProcessManager
     */
    constructor(processor, messageProcessManager) {
        this.processor = processor;
        this.messageProcessManager = messageProcessManager;
    }
    /**
     * Run fixer process
     * @param {Config} config
     * @param {string} [configBaseDir]
     * @param {TextlintKernelRule[]} [rules]
     * @param {TextlintKernelFilterRule[]} [filterRules]
     * @param {SourceCode} sourceCode
     * @returns {Promise.<TextlintFixResult>}
     */
    async process({ config, configBaseDir, ruleDescriptors, filterRules, sourceCode }) {
        (0, invariant_1.invariant)(sourceCode);
        const { preProcess, postProcess } = this.processor.processor(sourceCode.ext);
        // messages
        let resultFilePath = sourceCode.filePath;
        // applied fixing messages
        // Revert = Sequentially apply message to applied output
        // SourceCodeFixer.sequentiallyApplyFixes(fixedOutput, result.applyingMessages);
        const applyingMessages = [];
        // not applied fixing messages
        const remainingMessages = [];
        // original means original for applyingMessages and remainingMessages
        // pre-applyingMessages + remainingMessages
        const originalMessages = [];
        // apply fixes to sourceText sequentially
        let sourceText = sourceCode.text;
        for (const ruleDescriptor of ruleDescriptors.fixableDescriptors) {
            const parseResult = await (0, parse_by_plugin_1.parseByPlugin)({
                preProcess,
                sourceText,
                filePath: sourceCode.filePath
            });
            if (parseResult instanceof Error) {
                // --fix can not report error as lint error
                // Because fix's result has output content, It makes confuse user.
                throw parseResult;
            }
            const newSourceCode = new TextlintSourceCodeImpl_1.TextlintSourceCodeImpl({
                text: parseResult.text,
                ast: parseResult.ast,
                filePath: resultFilePath,
                ext: sourceCode.ext
            });
            // create new Task
            const task = new fixer_task_1.default({
                config,
                fixableRuleDescriptor: ruleDescriptor,
                filterRuleDescriptors: filterRules,
                sourceCode: newSourceCode,
                configBaseDir
            });
            const messages = await task_runner_1.default.process(task);
            const result = await postProcess(messages, sourceCode.filePath);
            const filteredResult = {
                messages: this.messageProcessManager.process(result.messages),
                filePath: result.filePath ? result.filePath : `<Unknown{sourceCode.ext}>`
            };
            // TODO: should be removed resultFilePath
            resultFilePath = filteredResult.filePath;
            const applied = (0, source_code_fixer_1.applyFixesToSourceCode)(newSourceCode, filteredResult.messages);
            // add messages
            Array.prototype.push.apply(applyingMessages, applied.applyingMessages);
            Array.prototype.push.apply(remainingMessages, applied.remainingMessages);
            Array.prototype.push.apply(originalMessages, applied.messages);
            // if not fixed, still use current sourceText
            if (!applied.fixed) {
                continue;
            }
            // if fixed, use fixed text at next
            sourceText = applied.output;
        }
        debug(`Finish Processing: ${resultFilePath}`);
        debug(`applyingMessages: ${applyingMessages.length}`);
        debug(`remainingMessages: ${remainingMessages.length}`);
        return {
            filePath: resultFilePath ? resultFilePath : `<Unknown{sourceCode.ext}>`,
            output: sourceText,
            messages: originalMessages,
            applyingMessages,
            remainingMessages
        };
    }
}
exports.default = FixerProcessor;
//# sourceMappingURL=fixer-processor.js.map