feat(eslint-plugin): [member-accessibility] add more options

packages/eslint-plugin/src/rules/explicit-member-accessibility.ts

@@ -1,7 +1,51 @@
 import { TSESTree } from '@typescript-eslint/typescript-estree';
 import * as util from '../util';
 
-export default util.createRule({
+enum Check {
+  Yes,
+  No,
+  NoPublic,
+}
+
+interface NoPublic {
+  noPublic?: boolean;
+}
+
+type Override = boolean | NoPublic;
+
+/**
+ * Type guard to ease checking on which kind of override is being supplied
+ *
+ * @param {Override} [option]
+ * @returns {option is NoPublic}
+ */
+function isNoPublic(option?: Override): option is NoPublic {
+  return typeof option !== 'boolean';
+}
+
+interface Config {
+  noPublic?: boolean;
+  overrides?: {
+    accessors?: Override;
+    constructors?: Override;
+    methods?: Override;
+    properties?: Override;
+  };
+}
+type Options = [Config];
+
+type MessageIds = 'unwantedPublicAccessibility' | 'missingAccessibility';
+
+const override = {
+  type: ['object', 'boolean'],
+  properties: {
+    noPublic: {
+      type: 'boolean',
+    },
+  },
+};
+
+export default util.createRule<Options, MessageIds>({
   name: 'explicit-member-accessibility',
   meta: {
     type: 'problem',
@@ -15,30 +59,144 @@ export default util.createRule({
     messages: {
       missingAccessibility:
         'Missing accessibility modifier on {{type}} {{name}}.',
+      unwantedPublicAccessibility:
+        'Public accessibility modifier on {{type}} {{name}}.',
     },
-    schema: [],
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          noPublic: {
+            type: 'boolean',
+          },
+          overrides: {
+            type: 'object',
+            properties: {
+              accessors: override,
+              constructors: override,
+              methods: override,
+              parameterProperties: override,
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
   },
-  defaultOptions: [],
+  defaultOptions: [
+    // technically there is a default, but the overrides mean
+    // that if we apply them here, it will break the no override case.
+    {},
+  ],
   create(context) {
+    const option: Config = util.applyDefault([{}], context.options)[0];
+
+    /**
+     * @param defaultCheck
+     * @param overrideToCheck
+     */
+
+    /**
+     * Reads the value set on the Override and returns a Check value
+     * Check value is used to control what, if any accessiblity modifiers are required or banned
+     * @param {Check} defaultCheck
+     * @param {Override} [overrideToCheck]
+     * @returns {Check}
+     */
+    function parseOverride(
+      defaultCheck: Check,
+      overrideToCheck?: Override,
+    ): Check {
+      let result: Check = defaultCheck;
+      if (typeof overrideToCheck !== 'undefined') {
+        if (isNoPublic(overrideToCheck) && overrideToCheck.noPublic) {
+          result = Check.NoPublic;
+        } else if (!overrideToCheck) {
+          result = Check.No;
+        }
+      }
+      return result;
+    }
+
+    let baseCheck = Check.Yes;
+    if (option.noPublic) {
+      baseCheck = Check.NoPublic;
+    }
+    let ctorCheck: Check = baseCheck;
+    let accessorCheck: Check = baseCheck;
+    let methodCheck: Check = baseCheck;
+    let propCheck: Check = baseCheck;
+    if (option.overrides) {
+      ctorCheck = parseOverride(baseCheck, option.overrides.constructors);
+      accessorCheck = parseOverride(baseCheck, option.overrides.accessors);
+      methodCheck = parseOverride(baseCheck, option.overrides.methods);
+      propCheck = parseOverride(baseCheck, option.overrides.properties);
+    }
+
+    /**
+     *Generates the report for rule violations
+     *
+     * @param {MessageIds} messageId
+     * @param {string} nodeType
+     * @param {(TSESTree.MethodDefinition | TSESTree.ClassProperty)} node
+     */
+    function reportIssue(
+      messageId: MessageIds,
+      nodeType: string,
+      node: TSESTree.MethodDefinition | TSESTree.ClassProperty,
+    ) {
+      context.report({
+        node: node,
+        messageId: messageId,
+        data: {
+          type: nodeType,
+          name: util.getNameFromPropertyName(node.key),
+        },
+      });
+    }
+
     /**
      * Checks if a method declaration has an accessibility modifier.
      * @param methodDefinition The node representing a MethodDefinition.
      */
     function checkMethodAccessibilityModifier(
       methodDefinition: TSESTree.MethodDefinition,
     ): void {
-      if (
-        !methodDefinition.accessibility &&
-        util.isTypeScriptFile(context.getFilename())
-      ) {
-        context.report({
-          node: methodDefinition,
-          messageId: 'missingAccessibility',
-          data: {
-            type: 'method definition',
-            name: util.getNameFromPropertyName(methodDefinition.key),
-          },
-        });
+      let nodeType = 'method definition';
+      let check: Check = baseCheck;
+      switch (methodDefinition.kind) {
+        case 'method':
+          check = methodCheck;
+          break;
+        case 'constructor':
+          check = ctorCheck;
+          break;
+        case 'get':
+        case 'set':
+          check = accessorCheck;
+          nodeType = `${methodDefinition.kind} property accessor`;
+          break;
+        default:
+          check = baseCheck;
+          break;
+      }
+      if (check == Check.No) {
+        return;
+      }
+
+      if (util.isTypeScriptFile(context.getFilename())) {
+        if (
+          check === Check.NoPublic &&
+          methodDefinition.accessibility === 'public'
+        ) {
+          reportIssue(
+            'unwantedPublicAccessibility',
+            nodeType,
+            methodDefinition,
+          );
+        } else if (check === Check.Yes && !methodDefinition.accessibility) {
+          reportIssue('missingAccessibility', nodeType, methodDefinition);
+        }
       }
     }
 
@@ -49,18 +207,17 @@ export default util.createRule({
     function checkPropertyAccessibilityModifier(
       classProperty: TSESTree.ClassProperty,
     ): void {
-      if (
-        !classProperty.accessibility &&
-        util.isTypeScriptFile(context.getFilename())
-      ) {
-        context.report({
-          node: classProperty,
-          messageId: 'missingAccessibility',
-          data: {
-            type: 'class property',
-            name: util.getNameFromPropertyName(classProperty.key),
-          },
-        });
+      const nodeType = 'class property';
+
+      if (util.isTypeScriptFile(context.getFilename())) {
+        if (
+          propCheck === Check.NoPublic &&
+          classProperty.accessibility === 'public'
+        ) {
+          reportIssue('unwantedPublicAccessibility', nodeType, classProperty);
+        } else if (propCheck === Check.Yes && !classProperty.accessibility) {
+          reportIssue('missingAccessibility', nodeType, classProperty);
+        }
       }
     }