Camelcase - support for optional chaining (#163)

Author: villesau

README.md

@@ -29,6 +29,7 @@ original ones as well!).
 {
   "rules": {
     "babel/new-cap": 1,
+    "babel/camelcase": 1,
     "babel/no-invalid-this": 1,
     "babel/object-curly-spacing": 1,
     "babel/quotes": 1,
@@ -45,6 +46,7 @@ Each rule corresponds to a core `eslint` rule, and has the same options.
 🛠: means it's autofixable with `--fix`.
 
 - `babel/new-cap`: Ignores capitalized decorators (`@Decorator`)
+- `babel/camelcase: doesn't complain about optional chaining (`var foo = bar?.a_b;`)
 - `babel/no-invalid-this`: doesn't fail when inside class properties (`class A { a = this.b; }`)
 - `babel/object-curly-spacing`: doesn't complain about `export x from "mod";` or `export * as x from "mod";` (🛠)
 - `babel/quotes`: doesn't complain about JSX fragment shorthand syntax (`<>foo</>;`)

index.js

@@ -8,6 +8,7 @@ module.exports = {
     'func-params-comma-dangle': require('./rules/func-params-comma-dangle'),
     'generator-star-spacing': require('./rules/generator-star-spacing'),
     'new-cap': require('./rules/new-cap'),
+    'camelcase': require('./rules/camelcase'),
     'no-await-in-loop': require('./rules/no-await-in-loop'),
     'no-invalid-this': require('./rules/no-invalid-this'),
     'no-unused-expressions': require('./rules/no-unused-expressions'),
@@ -20,6 +21,7 @@ module.exports = {
   rulesConfig: {
     'array-bracket-spacing': 0,
     'arrow-parens': 0,
+    'camelcase': 0,
     'flow-object-type': 0,
     'func-params-comma-dangle': 0,
     'generator-star-spacing': 0,
@@ -28,7 +30,7 @@ module.exports = {
     'no-invalid-this': 0,
     'no-unused-expressions': 0,
     'object-curly-spacing': 0,
-    'object-shorthand': 0,  
+    'object-shorthand': 0,
     'quotes': 0,
     'semi': 0,
     'valid-typeof': 0,

rules/camelcase.js

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview Rule to flag non-camelcased identifiers
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    docs: {
+      description: "enforce camelcase naming convention",
+      category: "Stylistic Issues",
+      recommended: false,
+      url: "https://eslint.org/docs/rules/camelcase"
+    },
+
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignoreDestructuring: {
+            type: "boolean"
+          },
+          properties: {
+            enum: ["always", "never"]
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+
+    messages: {
+      notCamelCase: "Identifier '{{name}}' is not in camel case."
+    }
+  },
+
+  create(context) {
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    // contains reported nodes to avoid reporting twice on destructuring with shorthand notation
+    const reported = [];
+    const ALLOWED_PARENT_TYPES = new Set(["CallExpression", "NewExpression"]);
+    const MEMBER_EXPRESSIONS = ["MemberExpression", "OptionalMemberExpression"];
+
+    /**
+     * Checks if expression is supported member expression.
+     *
+     * @param {string} expression - An expression to check.
+     * @returns {boolean} `true` if the expression type is supported
+     */
+    function isMemberExpression(expression) {
+      return MEMBER_EXPRESSIONS.indexOf(expression) >= 0;
+    }
+
+    /**
+     * Checks if a string contains an underscore and isn't all upper-case
+     * @param {string} name The string to check.
+     * @returns {boolean} if the string is underscored
+     * @private
+     */
+    function isUnderscored(name) {
+
+      // if there's an underscore, it might be A_CONSTANT, which is okay
+      return name.indexOf("_") > -1 && name !== name.toUpperCase();
+    }
+
+    /**
+     * Checks if a parent of a node is an ObjectPattern.
+     * @param {ASTNode} node The node to check.
+     * @returns {boolean} if the node is inside an ObjectPattern
+     * @private
+     */
+    function isInsideObjectPattern(node) {
+      let { parent } = node;
+
+      while (parent) {
+        if (parent.type === "ObjectPattern") {
+          return true;
+        }
+
+        parent = parent.parent;
+      }
+
+      return false;
+    }
+
+    /**
+     * Reports an AST node as a rule violation.
+     * @param {ASTNode} node The node to report.
+     * @returns {void}
+     * @private
+     */
+    function report(node) {
+      if (reported.indexOf(node.parent) < 0) {
+        reported.push(node.parent);
+        context.report({ node, messageId: "notCamelCase", data: { name: node.name } });
+      }
+    }
+
+    const options = context.options[0] || {};
+    let properties = options.properties || "";
+    const ignoreDestructuring = options.ignoreDestructuring || false;
+
+    if (properties !== "always" && properties !== "never") {
+      properties = "always";
+    }
+
+    return {
+
+      Identifier(node) {
+
+        /*
+         * Leading and trailing underscores are commonly used to flag
+         * private/protected identifiers, strip them
+         */
+        const name = node.name.replace(/^_+|_+$/g, ""),
+          effectiveParent = isMemberExpression(node.parent.type) ? node.parent.parent : node.parent;
+
+        // MemberExpressions get special rules
+        if (isMemberExpression(node.parent.type)) {
+
+          // "never" check properties
+          if (properties === "never") {
+            return;
+          }
+
+          // Always report underscored object names
+          if (node.parent.object.type === "Identifier" && node.parent.object.name === node.name && isUnderscored(name)) {
+            report(node);
+
+            // Report AssignmentExpressions only if they are the left side of the assignment
+          } else if (effectiveParent.type === "AssignmentExpression" && isUnderscored(name) && (!isMemberExpression(effectiveParent.right.type) || isMemberExpression(effectiveParent.left.type) && effectiveParent.left.property.name === node.name)) {
+            report(node);
+          }
+
+          /*
+           * Properties have their own rules, and
+           * AssignmentPattern nodes can be treated like Properties:
+           * e.g.: const { no_camelcased = false } = bar;
+           */
+        } else if (node.parent.type === "Property" || node.parent.type === "AssignmentPattern") {
+
+          if (node.parent.parent && node.parent.parent.type === "ObjectPattern") {
+
+            const assignmentKeyEqualsValue = node.parent.key.name === node.parent.value.name;
+
+            // prevent checking righthand side of destructured object
+            if (node.parent.key === node && node.parent.value !== node) {
+              return;
+            }
+
+            const valueIsUnderscored = node.parent.value.name && isUnderscored(name);
+
+            // ignore destructuring if the option is set, unless a new identifier is created
+            if (valueIsUnderscored && !(assignmentKeyEqualsValue && ignoreDestructuring)) {
+              report(node);
+            }
+          }
+
+          // "never" check properties or always ignore destructuring
+          if (properties === "never" || (ignoreDestructuring && isInsideObjectPattern(node))) {
+            return;
+          }
+
+          // don't check right hand side of AssignmentExpression to prevent duplicate warnings
+          if (isUnderscored(name) && !ALLOWED_PARENT_TYPES.has(effectiveParent.type) && !(node.parent.right === node)) {
+            report(node);
+          }
+
+          // Check if it's an import specifier
+        } else if (["ImportSpecifier", "ImportNamespaceSpecifier", "ImportDefaultSpecifier"].indexOf(node.parent.type) >= 0) {
+
+          // Report only if the local imported identifier is underscored
+          if (node.parent.local && node.parent.local.name === node.name && isUnderscored(name)) {
+            report(node);
+          }
+
+          // Report anything that is underscored that isn't a CallExpression
+        } else if (isUnderscored(name) && !ALLOWED_PARENT_TYPES.has(effectiveParent.type)) {
+          report(node);
+        }
+      }
+
+    };
+
+  }
+};