@gitlab/eslint-plugin 18.0.0 → 18.2.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [18.2.0](https://gitlab.com/gitlab-org/frontend/eslint-plugin/compare/v18.1.0...v18.2.0) (2023-03-03)
+
+
+### Features
+
+* Implement no explicit wrapper destroy rule ([afae3a8](https://gitlab.com/gitlab-org/frontend/eslint-plugin/commit/afae3a8f5fe3e68e5680774bbbf4fdb52f21dc4f))
+
+# [18.1.0](https://gitlab.com/gitlab-org/frontend/eslint-plugin/compare/v18.0.0...v18.1.0) (2022-09-26)
+
+
+### Features
+
+* **jest:** restrict usage of toBeTruthy or toBeFalsy ([43fa628](https://gitlab.com/gitlab-org/frontend/eslint-plugin/commit/43fa6283a94b1ba2f04408f60dc3b7bcc800a3a5))
+
 # [18.0.0](https://gitlab.com/gitlab-org/frontend/eslint-plugin/compare/v17.0.0...v18.0.0) (2022-09-21)
 
 

package/docs/development.md

@@ -19,6 +19,11 @@ Run `yarn createRule`, it will create:
 - `lib/rules/<name>.js` (rule definition)
 - `tests/rules/<name>.js` (rule unit tests)
 
+## Exploring AST
+
+Eslint works with [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) and exposes AST nodes for the rules to use.
+To better understrand how the syntax tree looks like for your code example, you can use (AST Explorer tool)[https://astexplorer.net/]
+
 ## Testing
 
 Run `yarn test` to execute the test suite, the suite includes rule tests and util tests.

package/docs/rules/vtu-no-explicit-wrapper-destroy.md

@@ -0,0 +1,65 @@
+# @gitlab/vtu-no-explicit-wrapper-destroy
+
+Throw an error when detecting a `wrapper.destroy()` and/or a `wrapper = null` in Jest hooks: `afterEach`, `afterAll`, `beforeEach`, `beforeAll`.
+
+## Rule Details
+
+This rules checks if there are unnecessary calls and assignments in Jest hooks.
+
+With [enabling auto-destroy](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/100389)
+we no longer need to call `wrapper.destroy()` explicitly in our test code.
+It is also [not necessary to explicitly nullify a wrapper](https://gitlab.com/gitlab-org/frontend/rfcs/-/issues/71).
+
+This rule checks the contents of Jest hooks and checks if something that looks like a wrapper for a vm gets explicitly destroyed.
+
+### Examples of **incorrect** code for this rule
+
+A variable containing `wrapper` or `vm` has a `.destroy()` call.
+
+```javascript
+afterEach(() => {
+    drawerWrapper.destroy();
+});
+```
+
+```javascript
+afterEach(() => {
+    vm.destroy();
+});
+```
+
+A variable containing `wrapper` or `vm` has a `= null` assignment.
+
+```javascript
+afterEach(() => {
+  wrapper = null;
+  wrapper.destroy();
+  jest.resetAllMocks();
+});
+```
+
+### Examples of **correct** code for this rule
+
+A variable that doesn't have a `wrapper` of `vm` is not treated as a target for this rule.
+
+```javascript
+afterEach(() => {
+    instance.destroy();
+    instance = null;
+    resetHTMLFixture();
+});
+```
+
+## Options
+
+Nothing
+
+## Related rules
+
+None
+
+## When Not To Use It
+
+Feel free to disable the rule for any lines that you know are either
+wrongly caught by the rule, or are the exceptional cases where the destroy
+call or null assignment are required

package/docs/rules/vue-require-i18n-strings.md

@@ -18,7 +18,7 @@ Detect non externalized strings in vue `<template>`
 Correctly externalized attributes or attributes that contain no letters
 
 ```html
-<div>{{ _("test") }}</div>
+<div>{{ __("test") }}</div>
 <div>{{ test }}</div>
 <p>→</p>
 ```

package/docs/rules.md

@@ -8,6 +8,7 @@ Available rules:
 - [no-runtime-template-compiler](./rules/no-runtime-template-compiler.md): Disallow components which rely on a runtime template compiler.
 - [require-i18n-strings](./rules/require-i18n-strings.md): Detect a string which has been hard coded and requires externalization.
 - [require-valid-i18n-helpers](./rules/require-valid-i18n-helpers.md): Enforces valid usage of translation helpers in JavaScript.
+- [vtu-no-explicit-wrapper-destroy](./rules/vtu-no-explicit-wrapper-destroy.md): Prevents redundant destroy calls and null asignment
 - [vue-no-data-toggle](./rules/vue-no-data-toggle.md): Restrict the use of `data-toggle` bootstrap behaviors within Vue templates
 - [vue-no-new-non-primitive-in-template](./rules/vue-no-new-non-primitive-in-template.md): Prevents non-primitive values from being declared in templates
 - [vue-prefer-dollar-scopedslots](./rules/vue-prefer-dollar-scopedslots.md): Prefer $scopedSlots over $slots for Vue 2.x.

package/lib/configs/jest.js

@@ -9,5 +9,9 @@ module.exports = {
         ignoreTypeOfDescribeName: true,
       },
     ],
+    'jest/no-restricted-matchers': ['error', {
+      toBeFalsy: 'Prefer a stronger matcher like `toBe(false)`',
+      toBeTruthy: 'Prefer a stronger matcher like `toBe(true)`'
+    }]
   },
 };

package/lib/index.js

@@ -7,6 +7,7 @@ module.exports = {
     'no-runtime-template-compiler': require('./rules/no-runtime-template-compiler.js'),
     'require-i18n-strings': require('./rules/require-i18n-strings.js'),
     'require-valid-i18n-helpers': require('./rules/require-valid-i18n-helpers.js'),
+    'vtu-no-explicit-wrapper-destroy': require('./rules/vtu-no-explicit-wrapper-destroy.js'),
     'vue-no-data-toggle': require('./rules/vue-no-data-toggle.js'),
     'vue-no-new-non-primitive-in-template': require('./rules/vue-no-new-non-primitive-in-template.js'),
     'vue-prefer-dollar-scopedslots': require('./rules/vue-prefer-dollar-scopedslots.js'),

package/lib/rules/vtu-no-explicit-wrapper-destroy.js

@@ -0,0 +1,145 @@
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+const { DOCS_BASE_URL } = require('../constants');
+const { NODE_TYPES } = require('../utils/rule-utils');
+
+// ------------------------------------------------------------------------------
+//   Helpers
+// ------------------------------------------------------------------------------
+
+class Rule {
+  #vmWrapperNameParts;
+  #context;
+
+  constructor(context, options) {
+    this.#vmWrapperNameParts = options.wrapperNames || commonVmWrapperNameParts;
+    this.#context = context;
+  }
+
+  verifyExpression = (expression) => {
+    if (
+      expression.type === NODE_TYPES.CALL_EXPRESSION &&
+      this.#isRedundantDestroyCall(expression)
+    ) {
+      this.#context.report({
+        node: expression,
+        messageId: 'redundantDestroy',
+      });
+    }
+
+    if (
+      expression.type === NODE_TYPES.ASSIGNMENT_EXPRESSION &&
+      this.#isRedundantNullAssignment(expression)
+    ) {
+      this.#context.report({
+        node: expression,
+        messageId: 'redundantNullAssignment',
+      });
+    }
+  };
+
+  #isPotentialVmWrapper = (variableName) =>
+    this.#vmWrapperNameParts.some((namePart) =>
+      variableName.toLowerCase().includes(namePart.toLowerCase()),
+    );
+
+  #isRedundantDestroyCall = (expression) => {
+    const calleeName = expression.callee.object?.name;
+    const functionCallName = expression.callee.property?.name;
+    if (!calleeName || !functionCallName) {
+      return false;
+    }
+
+    return this.#isPotentialVmWrapper(calleeName) && functionCallName === 'destroy';
+  };
+
+  #isRedundantNullAssignment = (expression) => {
+    if (
+      expression.left.type !== NODE_TYPES.IDENTIFIER ||
+      expression.right.type !== NODE_TYPES.LITERAL
+    ) {
+      return false;
+    }
+
+    const identifierName = expression.left.name;
+    const assignmentLiteralValue = expression.right.value;
+
+    return this.#isPotentialVmWrapper(identifierName) && assignmentLiteralValue === null;
+  };
+}
+
+const functionNameRuleTrigger = 'afterEach';
+const defaultOptions = {
+  ruleTriggerer: functionNameRuleTrigger,
+  wrapperNames: ['vm', 'wrapper'],
+};
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    type: 'error',
+    docs: {
+      description: 'Prevents redundant destroy calls and null asignment',
+      category: 'maintainability',
+      url: DOCS_BASE_URL + '/vtu-no-explicit-wrapper-destroy.md',
+    },
+    messages: {
+      redundantDestroy: `Redundant 'destroy()' call in 'after...' block.`,
+      redundantNullAssignment: `Redundant null assignment in 'after...' block.`,
+    },
+    //Optional:
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          ruleTriggerer: {
+            type: 'string',
+          },
+          wrapperNames: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+            uniqueItems: true,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const options = { ...defaultOptions, ...(context.options[0] || {}) };
+
+        const name = node.callee.name;
+        if (name !== options.ruleTriggerer) {
+          return;
+        }
+
+        const rule = new Rule(context, options);
+
+        const afterEachFunction = node.arguments[0].body;
+
+        if (afterEachFunction.type === NODE_TYPES.BLOCK_STATEMENT) {
+          const statements = afterEachFunction.body;
+          for (const statement of statements) {
+            if (statement.type !== NODE_TYPES.EXPRESSION_STATEMENT) {
+              continue;
+            }
+
+            const expression = statement.expression;
+
+            rule.verifyExpression(expression);
+          }
+        } else {
+          rule.verifyExpression(afterEachFunction);
+        }
+      },
+    };
+  },
+};

package/lib/utils/rule-utils.js

@@ -1,4 +1,7 @@
 const CALL_EXPRESSION = 'CallExpression';
+const ASSIGNMENT_EXPRESSION = 'AssignmentExpression';
+const BLOCK_STATEMENT = 'BlockStatement';
+const EXPRESSION_STATEMENT = 'ExpressionStatement';
 const V_ATTRIBUTE = 'VAttribute';
 const V_DIRECTIVE_KEY = 'VDirectiveKey';
 const V_EXPRESSION_CONTAINER = 'VExpressionContainer';
@@ -11,6 +14,9 @@ const IDENTIFIER = 'Identifier';
 
 const NODE_TYPES = {
   CALL_EXPRESSION,
+  BLOCK_STATEMENT,
+  ASSIGNMENT_EXPRESSION,
+  EXPRESSION_STATEMENT,
   V_ATTRIBUTE,
   V_DIRECTIVE_KEY,
   V_EXPRESSION_CONTAINER,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitlab/eslint-plugin",
-  "version": "18.0.0",
+  "version": "18.2.0",
   "description": "GitLab package for our custom eslint rules",
   "main": "lib/index.js",
   "scripts": {