@atlaskit/eslint-plugin-platform 0.0.4 → 0.0.6

package/src/rules/ensure-test-runner-nested-count/index.tsx

@@ -0,0 +1,83 @@
+import type { Rule } from 'eslint';
+import type { SimpleCallExpression } from 'estree';
+
+const NESTED_LIMIT: number = 4;
+const TEST_RUNNER_IDENTIFIER = 'ffTest' as const;
+
+const getDepthOfNestedRunner = (
+  node: SimpleCallExpression & Rule.NodeParentExtension,
+): number => {
+  // Calculate the depth of a binary tree, using a queue to track path
+  let queue: typeof node[] = [];
+  queue.push(node);
+  let depth = 0;
+  while (queue.length > 0) {
+    let nodeCount = queue.length;
+    while (nodeCount > 0) {
+      let currentNode = queue.shift() as typeof node;
+      if (
+        currentNode.arguments[1].type === 'ArrowFunctionExpression' &&
+        currentNode.arguments[1].body.type === 'CallExpression' &&
+        currentNode.arguments[1].body.callee.type === 'Identifier' &&
+        currentNode.arguments[1].body.callee.name === TEST_RUNNER_IDENTIFIER
+      ) {
+        queue.push({
+          ...currentNode.arguments[1].body,
+          parent: currentNode.parent,
+        });
+      }
+      if (
+        currentNode.arguments[2]?.type === 'ArrowFunctionExpression' &&
+        currentNode.arguments[2].body.type === 'CallExpression' &&
+        currentNode.arguments[2].body.callee.type === 'Identifier' &&
+        currentNode.arguments[2].body.callee.name === TEST_RUNNER_IDENTIFIER
+      ) {
+        queue.push({
+          ...currentNode.arguments[2].body,
+          parent: currentNode.parent,
+        });
+      }
+      nodeCount--;
+    }
+    depth++;
+  }
+  return depth;
+};
+
+const rule: Rule.RuleModule = {
+  meta: {
+    docs: {
+      recommended: false,
+    },
+    type: 'problem',
+    messages: {
+      tooManyNestedTestRunner:
+        '{{nestedTestRunner}} test runners are nested. Feature flags may need a clean-up',
+    },
+  },
+  create(context) {
+    return {
+      // Find the most outside test runner, could be inside a describe or not
+      [`Program > * > CallExpression[callee.name=/${TEST_RUNNER_IDENTIFIER}/], CallExpression[callee.name=/describe/] > * > * > * > CallExpression[callee.name=/${TEST_RUNNER_IDENTIFIER}/]`]:
+        (node: Rule.Node) => {
+          if (node.type === 'CallExpression') {
+            // Calculate the depth of nested test runners, counting from the most outside
+            const depth = getDepthOfNestedRunner(node);
+
+            if (depth > NESTED_LIMIT) {
+              return context.report({
+                node,
+                messageId: 'tooManyNestedTestRunner',
+                data: {
+                  nestedTestRunner: depth.toString(),
+                },
+              });
+            }
+          }
+          return {};
+        },
+    };
+  },
+};
+
+export default rule;

package/src/rules/no-invalid-feature-flag-usage/__tests__/unit/rule.test.tsx

@@ -0,0 +1,49 @@
+import { tester } from '../../../../__tests__/utils/_tester';
+import rule from '../../index';
+
+describe('enforce-feature-flag-usage-structure tests', () => {
+  tester.run('ensure-feature-flag-registration', rule, {
+    valid: [
+      {
+        // IfStatement
+        code: `if(getBooleanFF('test-flag')) { }`,
+      },
+      {
+        // ConditionalExpression
+        code: `const val = getBooleanFF('test-flag') ? 'yay' : 'no';`,
+      },
+      {
+        // LogicalExpression
+        code: `const val = 100 + (getBooleanFF('test-flag') && 50 || 10);`,
+      },
+    ],
+    invalid: [
+      {
+        code: `getBooleanFF('test-flag')`,
+        errors: [{ messageId: 'onlyInlineIf' }],
+      },
+      {
+        code: `const val = getBooleanFF('test-flag')`,
+        errors: [{ messageId: 'onlyInlineIf' }],
+      },
+      {
+        code: `const ff = "test-flag"; if(getBooleanFF(ff)) { }`,
+        errors: [{ messageId: 'onlyStringLiteral' }],
+      },
+      {
+        code: `if(getBooleanFF('test-flag') && getBooleanFF('test-flag')) { }`,
+        errors: [
+          { messageId: 'multipleFlagCheckInExpression' },
+          { messageId: 'multipleFlagCheckInExpression' },
+        ],
+      },
+      {
+        code: `if((getBooleanFF('test-flag') || 1 == true) && getBooleanFF('test-flag')) { }`,
+        errors: [
+          { messageId: 'multipleFlagCheckInExpression' },
+          { messageId: 'multipleFlagCheckInExpression' },
+        ],
+      },
+    ],
+  });
+});

package/src/rules/no-invalid-feature-flag-usage/index.tsx

@@ -0,0 +1,108 @@
+import type { Rule } from 'eslint';
+
+const FF_GETTER_BOOLEAN_IDENTIFIER = 'getBooleanFF' as const;
+
+const __isOnlyOneFlagCheckInExpression = (
+  root: Rule.Node,
+  ignoredNode: Rule.Node,
+): boolean => {
+  switch (root.type) {
+    case 'IfStatement':
+      return __isOnlyOneFlagCheckInExpression(
+        root.test as Rule.Node,
+        ignoredNode,
+      );
+
+    case 'CallExpression':
+      if (root === ignoredNode) {
+        return true;
+      }
+      return !(
+        root.callee.type === 'Identifier' &&
+        root.callee.name === FF_GETTER_BOOLEAN_IDENTIFIER
+      );
+
+    // shouldn't ever get here but just in case
+    case 'Identifier':
+      return root.name !== FF_GETTER_BOOLEAN_IDENTIFIER;
+
+    case 'BinaryExpression':
+    case 'LogicalExpression':
+      return (
+        __isOnlyOneFlagCheckInExpression(root.left as Rule.Node, ignoredNode) &&
+        __isOnlyOneFlagCheckInExpression(root.right as Rule.Node, ignoredNode)
+      );
+
+    default:
+      return true;
+  }
+};
+
+const isOnlyOneFlagCheckInExpression = (node: Rule.Node): boolean => {
+  let root = node.parent;
+  // find the root node of the expression
+  while (root.type === 'LogicalExpression') {
+    root = root.parent;
+  }
+
+  return __isOnlyOneFlagCheckInExpression(root, node);
+};
+
+const rule: Rule.RuleModule = {
+  meta: {
+    hasSuggestions: false,
+    docs: {
+      recommended: false,
+    },
+    type: 'problem',
+    messages: {
+      onlyInlineIf:
+        "Only call feature flags as part of an expression, don't assign to a variable! See http://go/pff-eslint for more details",
+      onlyStringLiteral:
+        "Only get feature flags by string literal, don't use variables! See http://go/pff-eslint for more details",
+      multipleFlagCheckInExpression: `Only check one flag per expression! See http://go/pff-eslint for more details`,
+    },
+  },
+  create(context) {
+    return {
+      [`CallExpression[callee.name=/${FF_GETTER_BOOLEAN_IDENTIFIER}/]`]: (
+        node: Rule.Node,
+      ) => {
+        // to make typescript happy
+        if (node.type === 'CallExpression') {
+          const args = node.arguments;
+
+          if (args.length === 1 && args[0].type !== 'Literal') {
+            return context.report({
+              node,
+              messageId: 'onlyStringLiteral',
+            });
+          }
+
+          switch (node.parent?.type) {
+            case 'IfStatement':
+            case 'ConditionalExpression':
+              break;
+            case 'LogicalExpression':
+              if (!isOnlyOneFlagCheckInExpression(node)) {
+                context.report({
+                  node,
+                  messageId: 'multipleFlagCheckInExpression',
+                });
+              }
+              break;
+            default:
+              return context.report({
+                node,
+                messageId: 'onlyInlineIf',
+              });
+          }
+        }
+
+        return {};
+      },
+    };
+  },
+};
+
+export default rule;

package/tmp/api-report-tmp.d.ts

@@ -12,6 +12,9 @@ export const configs: {
         plugins: string[];
         rules: {
             '@atlaskit/platform/ensure-feature-flag-registration': string;
+            '@atlaskit/platform/ensure-test-runner-arguments': string;
+            '@atlaskit/platform/ensure-test-runner-nested-count': string;
+            '@atlaskit/platform/no-invalid-feature-flag-usage': string;
         };
     };
 };
@@ -19,6 +22,9 @@ export const configs: {
 // @public (undocumented)
 export const rules: {
     'ensure-feature-flag-registration': Rule.RuleModule;
+    'ensure-test-runner-arguments': Rule.RuleModule;
+    'ensure-test-runner-nested-count': Rule.RuleModule;
+    'no-invalid-feature-flag-usage': Rule.RuleModule;
 };
 
 // (No @packageDocumentation comment for this package)