initial commit of actions

github/codeql-action-v2/node_modules/eslint-plugin-filenames/lib/common/getExportedName.js

@@ -0,0 +1,38 @@
+function getNodeName(node, options) {
+    var op = options || [];
+
+    if (node.type === "Identifier") {
+        return node.name;
+    }
+
+    if (node.id && node.id.type === "Identifier") {
+        return node.id.name;
+    }
+
+    if (op[2] && node.type === "CallExpression" && node.callee.type === "Identifier") {
+      return node.callee.name;
+    }
+}
+
+module.exports = function getExportedName(programNode, options) {
+    for (var i = 0; i < programNode.body.length; i += 1) {
+        var node = programNode.body[i];
+
+        // export default ...
+        if (node.type === "ExportDefaultDeclaration") {
+            return getNodeName(node.declaration, options);
+        }
+
+        // module.exports = ...
+        if (node.type === "ExpressionStatement" &&
+            node.expression.type === "AssignmentExpression" &&
+            node.expression.left.type === "MemberExpression" &&
+            node.expression.left.object.type === "Identifier" &&
+            node.expression.left.object.name === "module" &&
+            node.expression.left.property.type === "Identifier" &&
+            node.expression.left.property.name === "exports"
+        ) {
+            return getNodeName(node.expression.right, options);
+        }
+    }
+};

github/codeql-action-v2/node_modules/eslint-plugin-filenames/lib/common/isIgnoredFilename.js

@@ -0,0 +1,5 @@
+var ignoredFilenames = [ "<text>", "<input>" ];
+
+module.exports = function isIgnoredFilename(filename) {
+    return ignoredFilenames.indexOf(filename) !== -1;
+};

github/codeql-action-v2/node_modules/eslint-plugin-filenames/lib/common/isIndexFile.js

@@ -0,0 +1,3 @@
+module.exports = function isIndexFile(parsed) {
+    return parsed.name === 'index';
+};

github/codeql-action-v2/node_modules/eslint-plugin-filenames/lib/common/parseFilename.js

@@ -0,0 +1,12 @@
+var path = require('path');
+
+module.exports = function parseFilename(filename) {
+    var ext = path.extname(filename);
+
+    return {
+        dir: path.dirname(filename),
+        base: path.basename(filename),
+        ext: ext,
+        name: path.basename(filename, ext)
+    }
+};

github/codeql-action-v2/node_modules/eslint-plugin-filenames/lib/rules/match-exported.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview Rule to ensure that filenames match the exports of the file
+ * @author Stefan Lau
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+var path = require('path'),
+    camelCase = require('lodash.camelcase'),
+    upperFirst = require('lodash.upperfirst'),
+    parseFilename = require('../common/parseFilename'),
+    isIgnoredFilename = require('../common/isIgnoredFilename'),
+    getExportedName = require('../common/getExportedName'),
+    isIndexFile = require('../common/isIndexFile'),
+    transforms = {
+        kebab: require('lodash.kebabcase'),
+        snake: require('lodash.snakecase'),
+        camel: camelCase,
+        pascal: function (name) {
+            return upperFirst(camelCase(name));
+        }
+    },
+    transformNames = Object.keys(transforms),
+    transformSchema = { "enum": transformNames.concat([ null ]) };
+
+function getStringToCheckAgainstExport(parsed, replacePattern) {
+    var dirArray = parsed.dir.split(path.sep);
+    var lastDirectory = dirArray[dirArray.length - 1];
+
+    if (isIndexFile(parsed)) {
+        return lastDirectory;
+    } else {
+        return replacePattern ? parsed.name.replace(replacePattern, '') : parsed.name;
+    }
+}
+
+function getTransformsFromOptions(option) {
+    var usedTransforms = (option && option.push) ? option : [ option ];
+
+    return usedTransforms.map(function (name) {
+        return transforms[name];
+    });
+}
+
+function transform(exportedName, transforms) {
+    return transforms.map(function (t) {
+        return t ? t(exportedName) : exportedName;
+    });
+}
+
+function anyMatch(expectedExport, transformedNames) {
+    return transformedNames.some(function (name) {
+        return name === expectedExport;
+    });
+}
+
+function getWhatToMatchMessage(transforms) {
+    if (transforms.length === 1 && !transforms[0]) {
+        return "the exported name";
+    }
+    if (transforms.length > 1) {
+        return "any of the exported and transformed names"
+    }
+    return "the exported and transformed name";
+}
+
+module.exports = function(context) {
+    return {
+        "Program": function (node) {
+            var transforms = getTransformsFromOptions(context.options[0]),
+                replacePattern = context.options[1] ? new RegExp(context.options[1]) : null,
+                filename = context.getFilename(),
+                absoluteFilename = path.resolve(filename),
+                parsed = parseFilename(absoluteFilename),
+                shouldIgnore = isIgnoredFilename(filename),
+                exportedName = getExportedName(node, context.options),
+                isExporting = Boolean(exportedName),
+                expectedExport = getStringToCheckAgainstExport(parsed, replacePattern),
+                transformedNames = transform(exportedName, transforms),
+                everythingIsIndex = exportedName === 'index' && parsed.name === 'index',
+                matchesExported = anyMatch(expectedExport, transformedNames) || everythingIsIndex,
+                reportIf = function (condition, messageForNormalFile, messageForIndexFile) {
+                    var message = (!messageForIndexFile || !isIndexFile(parsed)) ? messageForNormalFile : messageForIndexFile;
+
+                    if (condition) {
+                        context.report(node, message, {
+                            name: parsed.base,
+                            expectedExport: expectedExport,
+                            exportName: transformedNames.join("', '"),
+                            extension: parsed.ext,
+                            whatToMatch: getWhatToMatchMessage(transforms)
+                        });
+                    }
+                };
+
+            if (shouldIgnore) return;
+
+            reportIf(
+                isExporting && !matchesExported,
+                "Filename '{{expectedExport}}' must match {{whatToMatch}} '{{exportName}}'.",
+                "The directory '{{expectedExport}}' must be named '{{exportName}}', after the exported value of its index file."
+            );
+        }
+    }
+};
+
+module.exports.schema = [
+    {
+
+        oneOf: [
+            transformSchema,
+            { type: "array", items: transformSchema, minItems: 1 }
+        ]
+    },
+    {
+        type: [ "string", "null" ]
+    },
+    {
+        type: [ "boolean", "null" ]
+    }
+];

github/codeql-action-v2/node_modules/eslint-plugin-filenames/lib/rules/match-regex.js

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Rule to ensure that filenames match a convention (default: camelCase)
+ * @author Stefan Lau
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+"use strict";
+
+var path = require("path"),
+    parseFilename = require('../common/parseFilename'),
+    getExportedName = require('../common/getExportedName'),
+    isIgnoredFilename = require('../common/isIgnoredFilename');
+
+module.exports = function(context) {
+    var defaultRegexp = /^([a-z0-9]+)([A-Z][a-z0-9]+)*$/g,
+        conventionRegexp = context.options[0] ? new RegExp(context.options[0]) : defaultRegexp,
+        ignoreExporting = context.options[1] ? context.options[1] : false;
+
+    return {
+        "Program": function(node) {
+            var filename = context.getFilename(),
+                absoluteFilename = path.resolve(filename),
+                parsed = parseFilename(absoluteFilename),
+                shouldIgnore = isIgnoredFilename(filename),
+                isExporting = Boolean(getExportedName(node)),
+                matchesRegex = conventionRegexp.test(parsed.name);
+
+            if (shouldIgnore) return;
+            if (ignoreExporting && isExporting) return;
+            if (!matchesRegex) {
+                context.report(node, "Filename '{{name}}' does not match the naming convention.", {
+                    name: parsed.base
+                });
+            }
+        }
+    };
+};

github/codeql-action-v2/node_modules/eslint-plugin-filenames/lib/rules/no-index.js

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Rule to ensure that there exist no index files
+ * @author Stefan Lau
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+var path = require('path'),
+    parseFilename = require('../common/parseFilename'),
+    isIgnoredFilename = require('../common/isIgnoredFilename'),
+    isIndexFile = require('../common/isIndexFile');
+
+module.exports = function(context) {
+    return {
+        "Program": function(node) {
+            var filename = context.getFilename(),
+                absoluteFilename = path.resolve(filename),
+                parsed = parseFilename(absoluteFilename),
+                shouldIgnore = isIgnoredFilename(filename),
+                isIndex = isIndexFile(parsed);
+
+
+            if (shouldIgnore) return;
+            if (isIndex) {
+                context.report(node, "'index.js' files are not allowed.");
+            }
+        }
+    };
+
+};