Support more TS cases

Author: weirdpattern

lib/rules/camelcase.js

@@ -19,6 +19,12 @@ module.exports = {
 
     create(context) {
         const rules = baseRule.create(context);
+        const TS_PROPERTY_TYPES = [
+            "TSPropertySignature",
+            "ClassProperty",
+            "TSParameterProperty",
+            "TSAbstractClassProperty"
+        ];
 
         const options = context.options[0] || {};
         let properties = options.properties || "";
@@ -53,6 +59,26 @@ module.exports = {
             );
         }
 
+        /**
+         * Checks if the the node is a valid TypeScript property type.
+         * @param {Node} node the node to be validated.
+         * @returns {boolean} true if the node is a TypeScript property type.
+         * @private
+         */
+        function isTSPropertyType(node) {
+            if (!node.parent) return false;
+            if (TS_PROPERTY_TYPES.includes(node.parent.type)) return true;
+
+            if (node.parent.type === "AssignmentPattern") {
+                return (
+                    node.parent.parent &&
+                    TS_PROPERTY_TYPES.includes(node.parent.parent.type)
+                );
+            }
+
+            return false;
+        }
+
         return {
             Identifier(node) {
                 /*
@@ -67,7 +93,7 @@ module.exports = {
                 }
 
                 // Check TypeScript specific nodes
-                if (node.parent && node.parent.type === "TSPropertySignature") {
+                if (isTSPropertyType(node)) {
                     if (properties === "always" && isUnderscored(name)) {
                         context.report({
                             node,

tests/lib/rules/camelcase.js

@@ -24,18 +24,82 @@ const ruleTester = new RuleTester({
 ruleTester.run("camelcase", ruleCamelcase, {
     valid: [
         {
-            code: "interface Foo { b_ar: null }",
+            code: "interface Foo { b_ar: number }",
             options: [{ properties: "never" }]
         },
         {
-            code: "interface Foo { bar: null }",
+            code: "interface Foo { bar: number }",
+            options: [{ properties: "always" }]
+        },
+        {
+            code: "class Foo { b_ar: number; }",
+            options: [{ properties: "never" }]
+        },
+        {
+            code: "class Foo { bar: number; }",
+            options: [{ properties: "always" }]
+        },
+        {
+            code: "class Foo { b_ar: number = 0; }",
+            options: [{ properties: "never" }]
+        },
+        {
+            code: "class Foo { bar: number = 0; }",
+            options: [{ properties: "always" }]
+        },
+        {
+            code: "class Foo { constructor(private b_ar: number) {} }",
+            options: [{ properties: "never" }]
+        },
+        {
+            code: "class Foo { constructor(private bar: number) {} }",
+            options: [{ properties: "always" }]
+        },
+        {
+            code: "class Foo { constructor(private b_ar: number = 0) {} }",
+            options: [{ properties: "never" }]
+        },
+        {
+            code: "class Foo { constructor(private bar: number = 0) {} }",
+            options: [{ properties: "always" }]
+        },
+        {
+            code: "abstract class Foo { b_ar: number; }",
+            options: [{ properties: "never" }]
+        },
+        {
+            code: "abstract class Foo { bar: number; }",
+            options: [{ properties: "always" }]
+        },
+        {
+            code: "abstract class Foo { b_ar: number = 0; }",
+            options: [{ properties: "never" }]
+        },
+        {
+            code: "abstract class Foo { bar: number = 0; }",
+            options: [{ properties: "always" }]
+        },
+        {
+            code: "abstract class Foo { abstract b_ar: number; }",
+            options: [{ properties: "never" }]
+        },
+        {
+            code: "abstract class Foo { abstract bar: number; }",
+            options: [{ properties: "always" }]
+        },
+        {
+            code: "abstract class Foo { abstract b_ar: number = 0; }",
+            options: [{ properties: "never" }]
+        },
+        {
+            code: "abstract class Foo { abstract bar: number = 0; }",
             options: [{ properties: "always" }]
         }
     ],
 
     invalid: [
         {
-            code: "interface Foo { b_ar: null }",
+            code: "interface Foo { b_ar: number }",
             options: [{ properties: "always" }],
             errors: [
                 {
@@ -44,6 +108,83 @@ ruleTester.run("camelcase", ruleCamelcase, {
                     column: 17
                 }
             ]
+        },
+        {
+            code: "class Foo { b_ar: number; }",
+            options: [{ properties: "always" }],
+            errors: [
+                {
+                    message: "Identifier 'b_ar' is not in camel case.",
+                    line: 1,
+                    column: 13
+                }
+            ]
+        },
+        {
+            code: "class Foo { constructor(private b_ar: number) {} }",
+            options: [{ properties: "always" }],
+            errors: [
+                {
+                    message: "Identifier 'b_ar' is not in camel case.",
+                    line: 1,
+                    column: 33
+                }
+            ]
+        },
+        {
+            code: "class Foo { constructor(private b_ar: number = 0) {} }",
+            options: [{ properties: "always" }],
+            errors: [
+                {
+                    message: "Identifier 'b_ar' is not in camel case.",
+                    line: 1,
+                    column: 33
+                }
+            ]
+        },
+        {
+            code: "abstract class Foo { b_ar: number; }",
+            options: [{ properties: "always" }],
+            errors: [
+                {
+                    message: "Identifier 'b_ar' is not in camel case.",
+                    line: 1,
+                    column: 22
+                }
+            ]
+        },
+        {
+            code: "abstract class Foo { b_ar: number = 0; }",
+            options: [{ properties: "always" }],
+            errors: [
+                {
+                    message: "Identifier 'b_ar' is not in camel case.",
+                    line: 1,
+                    column: 22
+                }
+            ]
+        },
+        {
+            code: "abstract class Foo { abstract b_ar: number; }",
+            options: [{ properties: "always" }],
+            errors: [
+                {
+                    message: "Identifier 'b_ar' is not in camel case.",
+                    line: 1,
+                    column: 31
+                }
+            ]
+        },
+        {
+            code: "abstract class Foo { abstract b_ar: number = 0; }",
+            options: [{ properties: "always" }],
+            errors: [
+                {
+                    message: "Identifier 'b_ar' is not in camel case.",
+                    line: 1,
+                    column: 31
+                }
+            ]
         }
     ]
 });