tslint-ban-snippets/dist/tslint-ban-snippets.es5.js

import { Rules, RuleWalker } from 'tslint';

/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */

var extendStatics = function(d, b) {
    extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return extendStatics(d, b);
};

function __extends(d, b) {
    extendStatics(d, b);
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}

var BAN_SNIPPETS_RULE_ID = "tsl-ban-snippets";

var SNIPPETS_PROP = "snippets";
var REGEX_SNIPPETS_PROP = "regexSnippets";
var ConfigFactory;
(function (ConfigFactory) {
    function createForBanSnippetsRule(options) {
        var config = createFromArguments(options, BAN_SNIPPETS_RULE_ID);
        validate(config, "banned", BAN_SNIPPETS_RULE_ID);
        config.banned.forEach(function (b) { return validateSnippetsList(b, BAN_SNIPPETS_RULE_ID); });
        return config;
    }
    ConfigFactory.createForBanSnippetsRule = createForBanSnippetsRule;
    function validate(config, prop, ruleId) {
        if (!hasProp(config, prop)) {
            throw new Error("invalid config for rule " + ruleId + " - " + prop + " is missing");
        }
    }
    function hasProp(config, prop) {
        return config[prop] !== undefined;
    }
    function validateSnippetsList(config, ruleId) {
        // either snippets OR regexSnippets is required
        var hasSnippets = hasProp(config, SNIPPETS_PROP);
        var hasRegexSnippets = hasProp(config, REGEX_SNIPPETS_PROP);
        var isValid = hasSnippets || hasRegexSnippets;
        var hasBoth = hasSnippets && hasRegexSnippets;
        if (!isValid || hasBoth) {
            throw new Error("invalid config for rule " + ruleId + " - either " + SNIPPETS_PROP + " or " + REGEX_SNIPPETS_PROP + " must be set");
        }
    }
    function createFromArguments(options, ruleId) {
        var args = options.ruleArguments;
        if (args.length !== 1) {
            throw new Error("tslint rule is misconfigured (" + ruleId + ") - options.ruleArguments length is " + args.length);
        }
        var config = args[0];
        return config;
    }
})(ConfigFactory || (ConfigFactory = {}));

var GeneralRuleUtils;
(function (GeneralRuleUtils) {
    function buildFailureString(message, ruleId) {
        // include the rule ID, to make it easier to disable
        return message + " (" + ruleId + ")";
    }
    GeneralRuleUtils.buildFailureString = buildFailureString;
    function isFileInPaths(filePath, paths) {
        return paths.some(function (path) { return filePath.indexOf(path) >= 0; });
    }
    GeneralRuleUtils.isFileInPaths = isFileInPaths;
})(GeneralRuleUtils || (GeneralRuleUtils = {}));

var Rule = /** @class */ (function (_super) {
    __extends(Rule, _super);
    function Rule() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Rule.prototype.apply = function (sourceFile) {
        var config = ConfigFactory.createForBanSnippetsRule(this.getOptions());
        var walker = new StatementsWalker(sourceFile, this.getOptions(), config);
        this.applyWithWalker(walker);
        return walker.getFailures();
    };
    return Rule;
}(Rules.AbstractRule));
var StatementsWalker = /** @class */ (function (_super) {
    __extends(StatementsWalker, _super);
    function StatementsWalker(sourceFile, options, config) {
        var _this = _super.call(this, sourceFile, options) || this;
        _this.config = config;
        return _this;
    }
    StatementsWalker.prototype.visitReturnStatement = function (node) {
        this.visitSomeNode(node);
    };
    StatementsWalker.prototype.visitBinaryExpression = function (node) {
        this.visitSomeNode(node);
        _super.prototype.visitBinaryExpression.call(this, node);
    };
    StatementsWalker.prototype.visitCallExpression = function (node) {
        this.visitSomeNode(node);
        _super.prototype.visitCallExpression.call(this, node);
    };
    StatementsWalker.prototype.visitDebuggerStatement = function (node) {
        this.visitSomeNode(node);
        _super.prototype.visitDebuggerStatement.call(this, node);
    };
    StatementsWalker.prototype.visitSomeNode = function (node) {
        var _this = this;
        var text = node.getText();
        var relevantBanned = this.getRelevantBanned();
        relevantBanned.forEach(function (banned) {
            if (banned.snippets) {
                _this.checkBannedSnippet(banned.snippets, text, node, banned.message);
            }
            else if (banned.regexSnippets) {
                _this.checkRegexBannedSnippet(banned.regexSnippets, text, node, banned.message);
            }
            else {
                throw new Error("Invalid config? No snippets and no regex-snippets");
            }
        });
    };
    StatementsWalker.prototype.checkBannedSnippet = function (snippets, text, node, message) {
        var bannedCodeFound = snippets.filter(function (bannedSnippet) { return text.indexOf(bannedSnippet) >= 0; });
        if (bannedCodeFound.length > 0) {
            this.failRule(node, bannedCodeFound, message);
        }
    };
    StatementsWalker.prototype.checkRegexBannedSnippet = function (regexSnippets, text, node, message) {
        var bannedCodeFound = regexSnippets.filter(function (regexSnippet) {
            var regex = new RegExp(regexSnippet);
            return regex.test(text);
        });
        if (bannedCodeFound.length > 0) {
            this.failRule(node, bannedCodeFound, message);
        }
    };
    StatementsWalker.prototype.failRule = function (node, bannedCodeFound, message) {
        var failureNode = node.getFirstToken() || node;
        this.addFailureAtNode(failureNode, GeneralRuleUtils.buildFailureString(message || "Do not use banned code '" + bannedCodeFound.join("' or '") + "'.", BAN_SNIPPETS_RULE_ID));
    };
    StatementsWalker.prototype.getRelevantBanned = function () {
        var sourceFilePath = this.getSourceFile().fileName;
        return this.config.banned.filter(function (b) {
            return (!b.includePaths ||
                GeneralRuleUtils.isFileInPaths(sourceFilePath, b.includePaths)) &&
                (!b.excludePaths || !GeneralRuleUtils.isFileInPaths(sourceFilePath, b.excludePaths));
        });
    };
    return StatementsWalker;
}(RuleWalker));

export { Rule };
//# sourceMappingURL=tslint-ban-snippets.es5.js.map