Current Dev State

static/js/ketcher2/node_modules/eslint/lib/internal-rules/internal-consistent-docs-description.js

@@ -0,0 +1,130 @@
+/**
+ * @fileoverview Internal rule to enforce meta.docs.description conventions.
+ * @author Vitor Balocco
+ */
+
+"use strict";
+
+const ALLOWED_FIRST_WORDS = [
+    "enforce",
+    "require",
+    "disallow"
+];
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Gets the property of the Object node passed in that has the name specified.
+ *
+ * @param {string} property Name of the property to return.
+ * @param {ASTNode} node The ObjectExpression node.
+ * @returns {ASTNode} The Property node or null if not found.
+ */
+function getPropertyFromObject(property, node) {
+    const properties = node.properties;
+
+    for (let i = 0; i < properties.length; i++) {
+        if (properties[i].key.name === property) {
+            return properties[i];
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Verifies that the meta.docs.description property follows our internal conventions.
+ *
+ * @param {RuleContext} context The ESLint rule context.
+ * @param {ASTNode} exportsNode ObjectExpression node that the rule exports.
+ * @returns {void}
+ */
+function checkMetaDocsDescription(context, exportsNode) {
+    if (exportsNode.type !== "ObjectExpression") {
+
+        // if the exported node is not the correct format, "internal-no-invalid-meta" will already report this.
+        return;
+    }
+
+    const metaProperty = getPropertyFromObject("meta", exportsNode);
+    const metaDocs = metaProperty && getPropertyFromObject("docs", metaProperty.value);
+    const metaDocsDescription = metaDocs && getPropertyFromObject("description", metaDocs.value);
+
+    if (!metaDocsDescription) {
+
+        // if there is no `meta.docs.description` property, "internal-no-invalid-meta" will already report this.
+        return;
+    }
+
+    const description = metaDocsDescription.value.value;
+
+    if (typeof description !== "string") {
+        context.report({
+            node: metaDocsDescription.value,
+            message: "`meta.docs.description` should be a string."
+        });
+        return;
+    }
+
+    if (description === "") {
+        context.report({
+            node: metaDocsDescription.value,
+            message: "`meta.docs.description` should not be empty."
+        });
+        return;
+    }
+
+    if (description.indexOf(" ") === 0) {
+        context.report({
+            node: metaDocsDescription.value,
+            message: "`meta.docs.description` should not start with whitespace."
+        });
+        return;
+    }
+
+    const firstWord = description.split(" ")[0];
+
+    if (ALLOWED_FIRST_WORDS.indexOf(firstWord) === -1) {
+        context.report({
+            node: metaDocsDescription.value,
+            message: "`meta.docs.description` should start with one of the following words: {{ allowedWords }}. Started with \"{{ firstWord }}\" instead.",
+            data: {
+                allowedWords: ALLOWED_FIRST_WORDS.join(", "),
+                firstWord
+            }
+        });
+    }
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "enforce correct conventions of `meta.docs.description` property in core rules",
+            category: "Internal",
+            recommended: false
+        },
+
+        schema: []
+    },
+
+    create(context) {
+        return {
+            AssignmentExpression(node) {
+                if (node.left &&
+                    node.right &&
+                    node.left.type === "MemberExpression" &&
+                    node.left.object.name === "module" &&
+                    node.left.property.name === "exports") {
+
+                    checkMetaDocsDescription(context, node.right);
+                }
+            }
+        };
+    }
+};

static/js/ketcher2/node_modules/eslint/lib/internal-rules/internal-no-invalid-meta.js

@@ -0,0 +1,188 @@
+/**
+ * @fileoverview Internal rule to prevent missing or invalid meta property in core rules.
+ * @author Vitor Balocco
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Gets the property of the Object node passed in that has the name specified.
+ *
+ * @param {string} property Name of the property to return.
+ * @param {ASTNode} node The ObjectExpression node.
+ * @returns {ASTNode} The Property node or null if not found.
+ */
+function getPropertyFromObject(property, node) {
+    const properties = node.properties;
+
+    for (let i = 0; i < properties.length; i++) {
+        if (properties[i].key.name === property) {
+            return properties[i];
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Extracts the `meta` property from the ObjectExpression that all rules export.
+ *
+ * @param {ASTNode} exportsNode ObjectExpression node that the rule exports.
+ * @returns {ASTNode} The `meta` Property node or null if not found.
+ */
+function getMetaPropertyFromExportsNode(exportsNode) {
+    return getPropertyFromObject("meta", exportsNode);
+}
+
+/**
+ * Whether this `meta` ObjectExpression has a `docs` property defined or not.
+ *
+ * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
+ * @returns {boolean} `true` if a `docs` property exists.
+ */
+function hasMetaDocs(metaPropertyNode) {
+    return Boolean(getPropertyFromObject("docs", metaPropertyNode.value));
+}
+
+/**
+ * Whether this `meta` ObjectExpression has a `docs.description` property defined or not.
+ *
+ * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
+ * @returns {boolean} `true` if a `docs.description` property exists.
+ */
+function hasMetaDocsDescription(metaPropertyNode) {
+    const metaDocs = getPropertyFromObject("docs", metaPropertyNode.value);
+
+    return metaDocs && getPropertyFromObject("description", metaDocs.value);
+}
+
+/**
+ * Whether this `meta` ObjectExpression has a `docs.category` property defined or not.
+ *
+ * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
+ * @returns {boolean} `true` if a `docs.category` property exists.
+ */
+function hasMetaDocsCategory(metaPropertyNode) {
+    const metaDocs = getPropertyFromObject("docs", metaPropertyNode.value);
+
+    return metaDocs && getPropertyFromObject("category", metaDocs.value);
+}
+
+/**
+ * Whether this `meta` ObjectExpression has a `docs.recommended` property defined or not.
+ *
+ * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
+ * @returns {boolean} `true` if a `docs.recommended` property exists.
+ */
+function hasMetaDocsRecommended(metaPropertyNode) {
+    const metaDocs = getPropertyFromObject("docs", metaPropertyNode.value);
+
+    return metaDocs && getPropertyFromObject("recommended", metaDocs.value);
+}
+
+/**
+ * Whether this `meta` ObjectExpression has a `schema` property defined or not.
+ *
+ * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
+ * @returns {boolean} `true` if a `schema` property exists.
+ */
+function hasMetaSchema(metaPropertyNode) {
+    return getPropertyFromObject("schema", metaPropertyNode.value);
+}
+
+/**
+ * Checks the validity of the meta definition of this rule and reports any errors found.
+ *
+ * @param {RuleContext} context The ESLint rule context.
+ * @param {ASTNode} exportsNode ObjectExpression node that the rule exports.
+ * @param {boolean} ruleIsFixable whether the rule is fixable or not.
+ * @returns {void}
+ */
+function checkMetaValidity(context, exportsNode) {
+    const metaProperty = getMetaPropertyFromExportsNode(exportsNode);
+
+    if (!metaProperty) {
+        context.report(exportsNode, "Rule is missing a meta property.");
+        return;
+    }
+
+    if (!hasMetaDocs(metaProperty)) {
+        context.report(metaProperty, "Rule is missing a meta.docs property.");
+        return;
+    }
+
+    if (!hasMetaDocsDescription(metaProperty)) {
+        context.report(metaProperty, "Rule is missing a meta.docs.description property.");
+        return;
+    }
+
+    if (!hasMetaDocsCategory(metaProperty)) {
+        context.report(metaProperty, "Rule is missing a meta.docs.category property.");
+        return;
+    }
+
+    if (!hasMetaDocsRecommended(metaProperty)) {
+        context.report(metaProperty, "Rule is missing a meta.docs.recommended property.");
+        return;
+    }
+
+    if (!hasMetaSchema(metaProperty)) {
+        context.report(metaProperty, "Rule is missing a meta.schema property.");
+    }
+}
+
+/**
+ * Whether this node is the correct format for a rule definition or not.
+ *
+ * @param {ASTNode} node node that the rule exports.
+ * @returns {boolean} `true` if the exported node is the correct format for a rule definition
+ */
+function isCorrectExportsFormat(node) {
+    return node.type === "ObjectExpression";
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "enforce correct use of `meta` property in core rules",
+            category: "Internal",
+            recommended: false
+        },
+
+        schema: []
+    },
+
+    create(context) {
+        let exportsNode;
+
+        return {
+            AssignmentExpression(node) {
+                if (node.left &&
+                    node.right &&
+                    node.left.type === "MemberExpression" &&
+                    node.left.object.name === "module" &&
+                    node.left.property.name === "exports") {
+
+                    exportsNode = node.right;
+                }
+            },
+
+            "Program:exit"() {
+                if (!isCorrectExportsFormat(exportsNode)) {
+                    context.report({ node: exportsNode, message: "Rule does not export an Object. Make sure the rule follows the new rule format." });
+                    return;
+                }
+
+                checkMetaValidity(context, exportsNode);
+            }
+        };
+    }
+};