@fimbul/wotan/src/services/configuration-manager.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConfigurationManager = void 0;
const tslib_1 = require("tslib");
const inversify_1 = require("inversify");
const ymir_1 = require("@fimbul/ymir");
const path = require("path");
const utils_1 = require("../utils");
const minimatch_1 = require("minimatch");
const isNegated = require("is-negated-glob");
const cached_file_system_1 = require("./cached-file-system");
let ConfigurationManager = class ConfigurationManager {
    constructor(directories, configProvider, fs, cache) {
        this.directories = directories;
        this.configProvider = configProvider;
        this.fs = fs;
        this.configCache = cache.create();
    }
    /** Look up the location of the configuration file for the specified file name. */
    findPath(file) {
        file = path.resolve(this.directories.getCurrentDirectory(), file);
        try {
            return this.configProvider.find(file);
        }
        catch (e) {
            throw new ymir_1.ConfigurationError(`Error finding configuration for '${file}': ${e && e.message}`);
        }
    }
    /** Load the configuration for the specified file. */
    find(file) {
        const config = this.findPath(file);
        return config === undefined ? undefined : this.load(config);
    }
    /** Load the given config from a local file if it exists or from the resolved path otherwise */
    loadLocalOrResolved(pathOrName, basedir = this.directories.getCurrentDirectory()) {
        const absolute = path.resolve(basedir, pathOrName);
        return this.load(this.fs.isFile(absolute) ? absolute : this.resolve(pathOrName, basedir));
    }
    /**
     * Resolve a configuration name to it's absolute path.
     *
     * @param name
     *   - name of a builtin config
     *   - package name in `node_modules` or a submodule thereof
     *   - absolute path
     *   - relative path starting with `./` or `../`
     */
    resolve(name, basedir) {
        try {
            return this.configProvider.resolve(name, path.resolve(this.directories.getCurrentDirectory(), basedir));
        }
        catch (e) {
            throw new ymir_1.ConfigurationError(`${e && e.message}`);
        }
    }
    /**
     * Collects all matching configuration options for the given file. Flattens all base configs and matches overrides.
     * Returns `undefined` if the file is excluded in one of the configuraton files.
     */
    reduce(config, file) {
        return reduceConfig(config, path.resolve(this.directories.getCurrentDirectory(), file), { rules: new Map(), settings: new Map(), processor: undefined });
    }
    /** Get the processor configuration for a given file. */
    getProcessor(config, fileName) {
        return findProcessorInConfig(config, path.resolve(this.directories.getCurrentDirectory(), fileName)) || undefined;
    }
    /** Get the settings for a given file. */
    getSettings(config, fileName) {
        return reduceSettings(config, path.resolve(this.directories.getCurrentDirectory(), fileName), new Map());
    }
    /** Load a configuration from a resolved path using the ConfigurationProvider, recursively resolving and loading base configs. */
    load(fileName) {
        const stack = [];
        const loadResolved = (file) => {
            const circular = stack.includes(file);
            stack.push(file);
            if (circular)
                throw new Error(`Circular configuration dependency.`);
            const config = this.configProvider.load(file, {
                stack,
                load: (name) => utils_1.resolveCachedResult(this.configCache, this.configProvider.resolve(name, path.dirname(file)), loadResolved),
            });
            stack.pop();
            return config;
        };
        try {
            return utils_1.resolveCachedResult(this.configCache, path.resolve(this.directories.getCurrentDirectory(), fileName), loadResolved);
        }
        catch (e) {
            throw new ymir_1.ConfigurationError(`Error loading ${stack.join(' => ')}: ${e && e.message}`);
        }
    }
};
ConfigurationManager = tslib_1.__decorate([
    inversify_1.injectable(),
    tslib_1.__metadata("design:paramtypes", [ymir_1.DirectoryService,
        ymir_1.ConfigurationProvider,
        cached_file_system_1.CachedFileSystem,
        ymir_1.CacheFactory])
], ConfigurationManager);
exports.ConfigurationManager = ConfigurationManager;
function reduceConfig(config, filename, receiver) {
    const relativeFilename = path.relative(path.dirname(config.filename), filename);
    if (config.exclude !== undefined && matchesGlobs(relativeFilename, config.exclude))
        return;
    for (const base of config.extends)
        if (reduceConfig(base, filename, receiver) === undefined)
            return;
    extendConfig(receiver, config);
    if (config.overrides !== undefined)
        for (const override of config.overrides)
            if (matchesGlobs(relativeFilename, override.files))
                extendConfig(receiver, override);
    return receiver;
}
function extendConfig(receiver, config) {
    if (config.processor !== undefined)
        receiver.processor = config.processor || undefined;
    if (config.settings !== undefined)
        extendSettings(receiver.settings, config.settings);
    if (config.rules !== undefined)
        extendRules(receiver.rules, config.rules);
}
function matchesGlobs(file, patterns) {
    for (let i = patterns.length - 1; i >= 0; --i) {
        const glob = isNegated(patterns[i]);
        const local = glob.pattern.startsWith('./');
        if (local)
            glob.pattern = glob.pattern.substr(2);
        if (new minimatch_1.Minimatch(glob.pattern, { matchBase: !local, dot: true }).match(file))
            return !glob.negated;
    }
    return false;
}
function extendRules(receiver, rules) {
    for (const [ruleName, config] of rules) {
        const prev = receiver.get(ruleName);
        receiver.set(ruleName, {
            severity: 'error',
            options: undefined,
            ...prev,
            ...config,
        });
    }
}
function extendSettings(receiver, settings) {
    for (const [key, value] of settings)
        receiver.set(key, value);
}
function findProcessorInConfig(config, fileName) {
    if (config.overrides !== undefined) {
        const relative = path.relative(path.dirname(config.filename), fileName);
        for (let i = config.overrides.length - 1; i >= 0; --i) {
            const override = config.overrides[i];
            if (override.processor !== undefined && matchesGlobs(relative, override.files))
                return override.processor;
        }
    }
    if (config.processor !== undefined)
        return config.processor;
    for (let i = config.extends.length - 1; i >= 0; --i) {
        const processor = findProcessorInConfig(config.extends[i], fileName);
        if (processor !== undefined)
            return processor;
    }
    return;
}
function reduceSettings(config, fileName, receiver) {
    for (const base of config.extends)
        reduceSettings(base, fileName, receiver);
    if (config.settings !== undefined)
        extendSettings(receiver, config.settings);
    if (config.overrides !== undefined) {
        const relative = path.relative(path.dirname(config.filename), fileName);
        for (const override of config.overrides)
            if (override.settings && matchesGlobs(relative, override.files))
                extendSettings(receiver, override.settings);
    }
    return receiver;
}
//# sourceMappingURL=configuration-manager.js.map