robojerk/codeql-action

Initial commit (from f5274cbdce4ae7c9e4b937dcdf95ac70ae436d5f)

Browse source
This commit is contained in:
anaarmas 2020-04-28 16:46:47 +02:00
commit 28ccc3db2d
13974 changed files with 2618436 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

154
node_modules/tslint/lib/enableDisableRules.js generated vendored Normal file
View file

@ -0,0 +1,154 @@
"use strict";
/**
* @license
* Copyright 2014 Palantir Technologies, Inc.
*
* 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
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
Object.defineProperty(exports, "__esModule", { value: true });
// tslint:disable object-literal-sort-keys
var utils = require("tsutils");
var ts = require("typescript");
/**
* regex is: start of string followed by any amount of whitespace
* followed by tslint and colon
* followed by either "enable" or "disable"
* followed optionally by -line or -next-line
* followed by either colon, whitespace or end of string
*/
exports.ENABLE_DISABLE_REGEX = /^\s*tslint:(enable|disable)(?:-(line|next-line))?(:|\s|$)/;
function removeDisabledFailures(sourceFile, failures) {
if (failures.length === 0) {
// Usually there won't be failures anyway, so no need to look for "tslint:disable".
return failures;
}
var failingRules = new Set(failures.map(function (f) { return f.getRuleName(); }));
var map = getDisableMap(sourceFile, failingRules);
return failures.filter(function (failure) {
var disabledIntervals = map.get(failure.getRuleName());
return (disabledIntervals === undefined ||
!disabledIntervals.some(function (_a) {
var pos = _a.pos, end = _a.end;
var failPos = failure.getStartPosition().getPosition();
var failEnd = failure.getEndPosition().getPosition();
return failEnd >= pos && (end === -1 || failPos < end);
}));
});
}
exports.removeDisabledFailures = removeDisabledFailures;
/**
* The map will have an array of TextRange for each disable of a rule in a file.
* (It will have no entry if the rule is never disabled, meaning all arrays are non-empty.)
*/
function getDisableMap(sourceFile, failingRules) {
var map = new Map();
utils.forEachComment(sourceFile, function (fullText, comment) {
var commentText = comment.kind === ts.SyntaxKind.SingleLineCommentTrivia
? fullText.substring(comment.pos + 2, comment.end)
: fullText.substring(comment.pos + 2, comment.end - 2);
var parsed = parseComment(commentText);
if (parsed !== undefined) {
var rulesList = parsed.rulesList, isEnabled = parsed.isEnabled, modifier = parsed.modifier;
var switchRange = getSwitchRange(modifier, comment, sourceFile);
if (switchRange !== undefined) {
var rulesToSwitch = rulesList === "all"
? Array.from(failingRules)
: rulesList.filter(function (r) { return failingRules.has(r); });
for (var _i = 0, rulesToSwitch_1 = rulesToSwitch; _i < rulesToSwitch_1.length; _i++) {
var ruleToSwitch = rulesToSwitch_1[_i];
switchRuleState(ruleToSwitch, isEnabled, switchRange.pos, switchRange.end);
}
}
}
});
return map;
function switchRuleState(ruleName, isEnable, start, end) {
var disableRanges = map.get(ruleName);
if (isEnable) {
if (disableRanges !== undefined) {
var lastDisable = disableRanges[disableRanges.length - 1];
if (lastDisable.end === -1) {
lastDisable.end = start;
if (end !== -1) {
// Disable it again after the enable range is over.
disableRanges.push({ pos: end, end: -1 });
}
}
}
}
else {
// disable
if (disableRanges === undefined) {
map.set(ruleName, [{ pos: start, end: end }]);
}
else if (disableRanges[disableRanges.length - 1].end !== -1) {
disableRanges.push({ pos: start, end: end });
}
}
}
}
/** End will be -1 to indicate no end. */
function getSwitchRange(modifier, range, sourceFile) {
var lineStarts = sourceFile.getLineStarts();
switch (modifier) {
case "line":
return {
// start at the beginning of the line where comment starts
pos: getStartOfLinePosition(range.pos),
// end at the beginning of the line following the comment
end: getStartOfLinePosition(range.end, 1),
};
case "next-line":
// start at the beginning of the line following the comment
var pos = getStartOfLinePosition(range.end, 1);
if (pos === -1) {
// no need to switch anything, there is no next line
return undefined;
}
// end at the beginning of the line following the next line
return { pos: pos, end: getStartOfLinePosition(range.end, 2) };
default:
// switch rule for the rest of the file
// start at the current position, but skip end position
return { pos: range.pos, end: -1 };
}
/** Returns -1 for last line. */
function getStartOfLinePosition(position, lineOffset) {
if (lineOffset === void 0) { lineOffset = 0; }
var line = ts.getLineAndCharacterOfPosition(sourceFile, position).line + lineOffset;
return line >= lineStarts.length ? -1 : lineStarts[line];
}
}
function parseComment(commentText) {
var match = exports.ENABLE_DISABLE_REGEX.exec(commentText);
if (match === null) {
return undefined;
}
// remove everything matched by the previous regex to get only the specified rules
// split at whitespaces
// filter empty items coming from whitespaces at start, at end or empty list
var rulesList = splitOnSpaces(commentText.substr(match[0].length));
if (rulesList.length === 0 && match[3] === ":") {
// nothing to do here: an explicit separator was specified but no rules to switch
return undefined;
}
if (rulesList.length === 0 || rulesList.indexOf("all") !== -1) {
// if list is empty we default to all enabled rules
// if `all` is specified we ignore the other rules and take all enabled rules
rulesList = "all";
}
return { rulesList: rulesList, isEnabled: match[1] === "enable", modifier: match[2] };
}
function splitOnSpaces(str) {
return str.split(/\s+/).filter(function (s) { return s !== ""; });
}