@fimbul/wotan/src/runner.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Runner = void 0;
const tslib_1 = require("tslib");
const linter_1 = require("./linter");
const ymir_1 = require("@fimbul/ymir");
const path = require("path");
const ts = require("typescript");
const glob = require("glob");
const utils_1 = require("./utils");
const minimatch_1 = require("minimatch");
const processor_loader_1 = require("./services/processor-loader");
const inversify_1 = require("inversify");
const cached_file_system_1 = require("./services/cached-file-system");
const configuration_manager_1 = require("./services/configuration-manager");
const project_host_1 = require("./project-host");
const debug = require("debug");
const normalize_glob_1 = require("normalize-glob");
const program_state_1 = require("./services/program-state");
const config_hash_1 = require("./config-hash");
const log = debug('wotan:runner');
let Runner = class Runner {
    constructor(fs, configManager, linter, processorLoader, directories, logger, filterFactory, programStateFactory) {
        this.fs = fs;
        this.configManager = configManager;
        this.linter = linter;
        this.processorLoader = processorLoader;
        this.directories = directories;
        this.logger = logger;
        this.filterFactory = filterFactory;
        this.programStateFactory = programStateFactory;
    }
    lintCollection(options) {
        const config = options.config !== undefined ? this.configManager.loadLocalOrResolved(options.config) : undefined;
        const cwd = this.directories.getCurrentDirectory();
        const files = options.files.map((pattern) => ({ hasMagic: glob.hasMagic(pattern), normalized: Array.from(normalize_glob_1.normalizeGlob(pattern, cwd)) }));
        const exclude = utils_1.flatMap(options.exclude, (pattern) => normalize_glob_1.normalizeGlob(pattern, cwd));
        const linterOptions = {
            reportUselessDirectives: options.reportUselessDirectives
                ? options.reportUselessDirectives === true
                    ? 'error'
                    : options.reportUselessDirectives
                : undefined,
        };
        if (options.project.length === 0 && options.files.length !== 0)
            return this.lintFiles({ ...options, files, exclude }, config, linterOptions);
        return this.lintProject({ ...options, files, exclude }, config, linterOptions);
    }
    *lintProject(options, config, linterOptions) {
        const processorHost = new project_host_1.ProjectHost(this.directories.getCurrentDirectory(), config, this.fs, this.configManager, this.processorLoader);
        for (let { files, program, configFilePath: tsconfigPath } of this.getFilesAndProgram(options.project, options.files, options.exclude, processorHost, options.references)) {
            const programState = options.cache ? this.programStateFactory.create(program, processorHost, tsconfigPath) : undefined;
            let invalidatedProgram = false;
            const factory = {
                getCompilerOptions() {
                    return program.getCompilerOptions();
                },
                getProgram() {
                    if (invalidatedProgram) {
                        log('updating invalidated program');
                        program = processorHost.updateProgram(program);
                        invalidatedProgram = false;
                    }
                    return program;
                },
            };
            for (const file of files) {
                if (options.config === undefined)
                    config = this.configManager.find(file);
                const mapped = processorHost.getProcessedFileInfo(file);
                const originalName = mapped === undefined ? file : mapped.originalName;
                const effectiveConfig = config && this.configManager.reduce(config, originalName);
                if (effectiveConfig === undefined)
                    continue;
                let sourceFile = program.getSourceFile(file);
                const originalContent = mapped === undefined ? sourceFile.text : mapped.originalContent;
                let summary;
                const fix = shouldFix(sourceFile, options, originalName);
                const configHash = programState === undefined ? undefined : config_hash_1.createConfigHash(effectiveConfig, linterOptions);
                const resultFromCache = programState === null || programState === void 0 ? void 0 : programState.getUpToDateResult(sourceFile.fileName, configHash);
                if (fix) {
                    let updatedFile = false;
                    summary = this.linter.lintAndFix(sourceFile, originalContent, effectiveConfig, (content, range) => {
                        invalidatedProgram = true;
                        const oldContent = sourceFile.text;
                        sourceFile = ts.updateSourceFile(sourceFile, content, range);
                        const hasErrors = utils_1.hasParseErrors(sourceFile);
                        if (hasErrors) {
                            log("Autofixing caused syntax errors in '%s', rolling back", sourceFile.fileName);
                            sourceFile = ts.updateSourceFile(sourceFile, oldContent, utils_1.invertChangeRange(range));
                        }
                        else {
                            updatedFile = true;
                        }
                        // either way we need to store the new SourceFile as the old one is now corrupted
                        processorHost.updateSourceFile(sourceFile);
                        return hasErrors ? undefined : sourceFile;
                    }, fix === true ? undefined : fix, factory, mapped === null || mapped === void 0 ? void 0 : mapped.processor, linterOptions, 
                    // pass cached results so we can apply fixes from cache
                    resultFromCache);
                    if (updatedFile)
                        programState === null || programState === void 0 ? void 0 : programState.update(factory.getProgram(), sourceFile.fileName);
                }
                else {
                    summary = {
                        findings: resultFromCache !== null && resultFromCache !== void 0 ? resultFromCache : this.linter.getFindings(sourceFile, effectiveConfig, factory, mapped === null || mapped === void 0 ? void 0 : mapped.processor, linterOptions),
                        fixes: 0,
                        content: originalContent,
                    };
                }
                if (programState !== undefined && resultFromCache !== summary.findings)
                    programState.setFileResult(file, configHash, summary.findings);
                yield [originalName, summary];
            }
            programState === null || programState === void 0 ? void 0 : programState.save();
        }
    }
    *lintFiles(options, config, linterOptions) {
        let processor;
        for (const file of getFiles(options.files, options.exclude, this.directories.getCurrentDirectory())) {
            if (options.config === undefined)
                config = this.configManager.find(file);
            const effectiveConfig = config && this.configManager.reduce(config, file);
            if (effectiveConfig === undefined)
                continue;
            let originalContent;
            let name;
            let content;
            if (effectiveConfig.processor) {
                const ctor = this.processorLoader.loadProcessor(effectiveConfig.processor);
                if (utils_1.hasSupportedExtension(file, options.extensions)) {
                    name = file;
                }
                else {
                    name = file + ctor.getSuffixForFile({
                        fileName: file,
                        getSettings: () => effectiveConfig.settings,
                        readFile: () => originalContent = this.fs.readFile(file),
                    });
                    if (!utils_1.hasSupportedExtension(name, options.extensions))
                        continue;
                }
                if (originalContent === undefined) // might be initialized by the processor requesting the file content
                    originalContent = this.fs.readFile(file);
                processor = new ctor({
                    source: originalContent,
                    sourceFileName: file,
                    targetFileName: name,
                    settings: effectiveConfig.settings,
                });
                content = processor.preprocess();
            }
            else if (utils_1.hasSupportedExtension(file, options.extensions)) {
                processor = undefined;
                name = file;
                content = originalContent = this.fs.readFile(file);
            }
            else {
                continue;
            }
            let sourceFile = ts.createSourceFile(name, content, ts.ScriptTarget.ESNext, true);
            const fix = shouldFix(sourceFile, options, file);
            let summary;
            if (fix) {
                summary = this.linter.lintAndFix(sourceFile, originalContent, effectiveConfig, (newContent, range) => {
                    sourceFile = ts.updateSourceFile(sourceFile, newContent, range);
                    if (utils_1.hasParseErrors(sourceFile)) {
                        log("Autofixing caused syntax errors in '%s', rolling back", sourceFile.fileName);
                        // Note: 'sourceFile' shouldn't be used after this as it contains invalid code
                        return;
                    }
                    return sourceFile;
                }, fix === true ? undefined : fix, undefined, processor, linterOptions);
            }
            else {
                summary = {
                    findings: this.linter.getFindings(sourceFile, effectiveConfig, undefined, processor, linterOptions),
                    fixes: 0,
                    content: originalContent,
                };
            }
            yield [file, summary];
        }
    }
    *getFilesAndProgram(projects, patterns, exclude, host, references) {
        const cwd = utils_1.unixifyPath(this.directories.getCurrentDirectory());
        if (projects.length !== 0) {
            projects = projects.map((configFile) => this.checkConfigDirectory(utils_1.unixifyPath(path.resolve(cwd, configFile))));
        }
        else if (references) {
            projects = [this.checkConfigDirectory(cwd)];
        }
        else {
            const project = ts.findConfigFile(cwd, (f) => this.fs.isFile(f));
            if (project === undefined)
                throw new ymir_1.ConfigurationError(`Cannot find tsconfig.json for directory '${cwd}'.`);
            projects = [project];
        }
        const allMatchedFiles = [];
        const include = [];
        const nonMagicGlobs = [];
        for (const pattern of patterns) {
            if (!pattern.hasMagic) {
                const mm = new minimatch_1.Minimatch(pattern.normalized[0]);
                nonMagicGlobs.push({ raw: pattern.normalized[0], match: mm });
                include.push(mm);
            }
            else {
                include.push(...pattern.normalized.map((p) => new minimatch_1.Minimatch(p)));
            }
        }
        const ex = exclude.map((p) => new minimatch_1.Minimatch(p, { dot: true }));
        const projectsSeen = [];
        let filesOfPreviousProject;
        for (const { program, configFilePath } of this.createPrograms(projects, host, projectsSeen, references, isFileIncluded)) {
            const ownFiles = [];
            const files = [];
            const fileFilter = this.filterFactory.create({ program, host });
            for (const sourceFile of program.getSourceFiles()) {
                if (!fileFilter.filter(sourceFile))
                    continue;
                const { fileName } = sourceFile;
                ownFiles.push(fileName);
                const originalName = host.getFileSystemFile(fileName);
                if (!isFileIncluded(originalName))
                    continue;
                files.push(fileName);
                allMatchedFiles.push(originalName);
            }
            // uncache all files of the previous project if they are no longer needed
            if (filesOfPreviousProject !== undefined)
                for (const oldFile of filesOfPreviousProject)
                    if (!ownFiles.includes(oldFile))
                        host.uncacheFile(oldFile);
            filesOfPreviousProject = ownFiles;
            if (files.length !== 0)
                yield { files, program, configFilePath };
        }
        ensurePatternsMatch(nonMagicGlobs, ex, allMatchedFiles, projectsSeen);
        function isFileIncluded(fileName) {
            return (include.length === 0 || include.some((p) => p.match(fileName))) && !ex.some((p) => p.match(fileName));
        }
    }
    checkConfigDirectory(fileOrDirName) {
        switch (this.fs.getKind(fileOrDirName)) {
            case 0 /* NonExistent */:
                throw new ymir_1.ConfigurationError(`The specified path does not exist: '${fileOrDirName}'`);
            case 2 /* Directory */: {
                const file = utils_1.unixifyPath(path.join(fileOrDirName, 'tsconfig.json'));
                if (!this.fs.isFile(file))
                    throw new ymir_1.ConfigurationError(`Cannot find a tsconfig.json file at the specified directory: '${fileOrDirName}'`);
                return file;
            }
            default:
                return fileOrDirName;
        }
    }
    *createPrograms(projects, host, seen, references, isFileIncluded) {
        for (const configFile of projects) {
            if (configFile === undefined)
                continue;
            const configFilePath = typeof configFile === 'string' ? configFile : configFile.sourceFile.fileName;
            if (!utils_1.addUnique(seen, configFilePath))
                continue;
            let commandLine;
            if (typeof configFile !== 'string') {
                ({ commandLine } = configFile);
            }
            else {
                commandLine = host.getParsedCommandLine(configFile);
                if (commandLine === undefined)
                    continue;
            }
            if (commandLine.errors.length !== 0)
                this.logger.warn(ts.formatDiagnostics(commandLine.errors, host));
            if (commandLine.fileNames.length !== 0) {
                if (!commandLine.options.composite || commandLine.fileNames.some((file) => isFileIncluded(host.getFileSystemFile(file)))) {
                    log("Using project '%s'", configFilePath);
                    let resolvedReferences;
                    {
                        // this is in a nested block to allow garbage collection while recursing
                        const program = host.createProgram(commandLine.fileNames, commandLine.options, undefined, commandLine.projectReferences);
                        yield { program, configFilePath };
                        if (references)
                            resolvedReferences = program.getResolvedProjectReferences();
                    }
                    if (resolvedReferences !== undefined)
                        yield* this.createPrograms(resolvedReferences, host, seen, true, isFileIncluded);
                    continue;
                }
                log("Project '%s' contains no file to lint", configFilePath);
            }
            if (references) {
                if (typeof configFile !== 'string') {
                    if (configFile.references !== undefined)
                        yield* this.createPrograms(configFile.references, host, seen, true, isFileIncluded);
                }
                else if (commandLine.projectReferences !== undefined) {
                    yield* this.createPrograms(commandLine.projectReferences.map((ref) => this.checkConfigDirectory(ref.path)), host, seen, true, isFileIncluded);
                }
            }
        }
    }
};
Runner = tslib_1.__decorate([
    inversify_1.injectable(),
    tslib_1.__metadata("design:paramtypes", [cached_file_system_1.CachedFileSystem,
        configuration_manager_1.ConfigurationManager,
        linter_1.Linter,
        processor_loader_1.ProcessorLoader,
        ymir_1.DirectoryService,
        ymir_1.MessageHandler,
        ymir_1.FileFilterFactory,
        program_state_1.ProgramStateFactory])
], Runner);
exports.Runner = Runner;
function getFiles(patterns, exclude, cwd) {
    const result = [];
    const globOptions = {
        cwd,
        nobrace: true,
        cache: {},
        ignore: exclude,
        nodir: true,
        realpathCache: {},
        statCache: {},
        symlinks: {},
    };
    for (const pattern of patterns) {
        let matched = pattern.hasMagic;
        for (const normalized of pattern.normalized) {
            const match = glob.sync(normalized, globOptions);
            if (match.length !== 0) {
                matched = true;
                result.push(...match);
            }
        }
        if (!matched && !isExcluded(pattern.normalized[0], exclude.map((p) => new minimatch_1.Minimatch(p, { dot: true }))))
            throw new ymir_1.ConfigurationError(`'${pattern.normalized[0]}' does not exist.`);
    }
    return new Set(result.map(utils_1.unixifyPath)); // deduplicate files
}
function ensurePatternsMatch(include, exclude, files, projects) {
    for (const pattern of include)
        if (!isExcluded(pattern.raw, exclude) && !files.some((f) => pattern.match.match(f)))
            throw new ymir_1.ConfigurationError(`'${pattern.raw}' is not included in any of the projects: '${projects.join("', '")}'.`);
}
function isExcluded(file, exclude) {
    for (const e of exclude)
        if (e.match(file))
            return true;
    return false;
}
function shouldFix(sourceFile, options, originalName) {
    if (options.fix && utils_1.hasParseErrors(sourceFile)) {
        log("Not fixing '%s' because of parse errors.", originalName);
        return false;
    }
    return options.fix;
}
//# sourceMappingURL=runner.js.map