@gitlab/eslint-plugin 9.2.0 → 10.0.1

package/jest.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  moduleFileExtensions: ['js'],
+  transform: {
+    '^.+\\.js$': ['babel-jest', { sourceType: 'script' }],
+  },
+};

package/lib/configs/default.js

@@ -105,7 +105,6 @@ module.exports = {
       'error',
       {
         groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
-        alphabetize: { order: 'asc' },
       },
     ],
     // BEGIN rules to aid migration from Vue 2.x to 3.x.

package/lib/configs/i18n.js

@@ -4,6 +4,7 @@ module.exports = {
     '@gitlab/require-i18n-strings': 'error',
     '@gitlab/vue-require-i18n-attribute-strings': 'error',
     '@gitlab/vue-require-i18n-strings': 'error',
-    '@gitlab/require-string-literal-i18n-helpers': 'error',
+    '@gitlab/require-valid-i18n-helpers': 'error',
+    '@gitlab/vue-require-valid-i18n-helpers': 'error',
   },
 };

package/lib/index.js

@@ -3,16 +3,17 @@
  */
 module.exports = {
   rules: {
-    'require-string-literal-i18n-helpers': require('./rules/require-string-literal-i18n-helpers.js'),
     'no-global-event-off': require('./rules/no-global-event-off.js'),
     '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'),
     'vue-emit-events-with-two-args': require('./rules/vue-emit-events-with-two-args.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-require-i18n-attribute-strings': require('./rules/vue-require-i18n-attribute-strings.js'),
     'vue-require-i18n-strings': require('./rules/vue-require-i18n-strings.js'),
     'vue-require-required-key': require('./rules/vue-require-required-key.js'),
+    'vue-require-valid-i18n-helpers': require('./rules/vue-require-valid-i18n-helpers.js'),
     'vue-slot-name-casing': require('./rules/vue-slot-name-casing.js'),
   },
   configs: {

package/lib/rules/require-i18n-strings.js

@@ -4,6 +4,11 @@
  */
 'use strict';
 
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+const { isTemplateLiteral, getTemplateLiteralString } = require('../utils/rule-utils');
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -269,21 +274,10 @@ module.exports = {
       return node.type === 'Literal';
     }
 
-    function isTemplateLiteral(node) {
-      return node.type === 'TemplateLiteral';
-    }
-
     function stripVariables(value) {
       return value ? value.replace(/(\%{[\w-]+})/g, '') : '';
     }
 
-    function getTemplateLiteralString(node) {
-      return node.quasis
-        .filter((quasi) => quasi.type === 'TemplateElement')
-        .map((quasi) => quasi.value.raw)
-        .join('');
-    }
-
     function getCallExpressionString(node, callee) {
       if (callee.name === 'sprintf') {
         return stripVariables(node.value);

package/lib/rules/require-valid-i18n-helpers.js

@@ -0,0 +1,29 @@
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+const { DOCS_BASE_URL } = require('../constants');
+const { validateI18nHelperCallFactory } = require('../utils/i18n-utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    type: 'error',
+    docs: {
+      description: 'Enforces valid usage of translation helpers in JavaScript.',
+      category: 'i18n',
+      url: DOCS_BASE_URL + '/require-valid-i18n-helpers.md',
+    },
+  },
+  create(context) {
+    const validateI18nHelperCall = validateI18nHelperCallFactory(context);
+
+    return {
+      CallExpression(node) {
+        validateI18nHelperCall(node);
+      },
+    };
+  },
+};

package/lib/rules/vue-require-valid-i18n-helpers.js

@@ -0,0 +1,30 @@
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+const { DOCS_BASE_URL } = require('../constants');
+const { defineTemplateBodyVisitor } = require('../utils/index');
+const { validateI18nHelperCallFactory } = require('../utils/i18n-utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    type: 'error',
+    docs: {
+      description: 'Enforces valid usage of translation helpers in Vue templates.',
+      category: 'i18n',
+      url: DOCS_BASE_URL + '/vue-require-valid-i18n-helpers.md',
+    },
+  },
+  create(context) {
+    const validateI18nHelperCall = validateI18nHelperCallFactory(context);
+
+    return defineTemplateBodyVisitor(context, {
+      CallExpression(node) {
+        validateI18nHelperCall(node);
+      },
+    });
+  },
+};

package/lib/utils/i18n-utils.js

@@ -0,0 +1,68 @@
+const {
+  getFunctionName,
+  isString,
+  isTemplateLiteral,
+  getTemplateLiteralString,
+} = require('../utils/rule-utils');
+
+const GETTEXT = '__';
+const P_GETTEXT = 's__';
+const N_GETTEXT = 'n__';
+
+const ERROR_MESSAGE_STRING_LITERAL = 'Translation helpers must be called with a string literal.';
+const ERROR_MESSAGE_MISSING_NAMESPACE = 's__ requires a translation namespace to be provided.';
+
+const mustBeCalledWithStringLiteralArguments = (context, node) => {
+  const report = (node) => {
+    context.report({
+      node,
+      message: ERROR_MESSAGE_STRING_LITERAL,
+    });
+  };
+
+  if (!node.arguments.length) {
+    report(node);
+  }
+  const [arg1, arg2] = node.arguments;
+  if ([arg1, arg2].some((arg) => arg && !isString(arg))) {
+    report(node);
+  }
+};
+
+const mustHaveNamespace = (context, node) => {
+  if (node.arguments.length === 2) {
+    return;
+  }
+
+  const [arg] = node.arguments;
+  const value = isTemplateLiteral(arg) ? getTemplateLiteralString(arg).trim() : arg.value;
+  if (!/^\w.+\|/.test(value)) {
+    context.report({
+      node,
+      message: ERROR_MESSAGE_MISSING_NAMESPACE,
+    });
+  }
+};
+
+const VALIDATORS = {
+  [GETTEXT]: [mustBeCalledWithStringLiteralArguments],
+  [P_GETTEXT]: [mustBeCalledWithStringLiteralArguments, mustHaveNamespace],
+  [N_GETTEXT]: [mustBeCalledWithStringLiteralArguments],
+};
+
+const validateI18nHelperCallFactory = (context) => (node) => {
+  const functionName = getFunctionName(node);
+  if (!Object.keys(VALIDATORS).includes(functionName)) {
+    return;
+  }
+
+  VALIDATORS[functionName].forEach((validator) => {
+    validator(context, node);
+  });
+};
+
+module.exports = {
+  validateI18nHelperCallFactory,
+  ERROR_MESSAGE_STRING_LITERAL,
+  ERROR_MESSAGE_MISSING_NAMESPACE,
+};

package/lib/utils/rule-utils.js

@@ -7,6 +7,7 @@ const V_TEXT = 'VText';
 const V_ELEMENT = 'VElement';
 const TEMPLATE_LITERAL = 'TemplateLiteral';
 const LITERAL = 'Literal';
+const IDENTIFIER = 'Identifier';
 
 const NODE_TYPES = {
   CALL_EXPRESSION,
@@ -18,6 +19,7 @@ const NODE_TYPES = {
   V_ELEMENT,
   TEMPLATE_LITERAL,
   LITERAL,
+  IDENTIFIER,
 };
 
 function closest(node, predicate) {
@@ -39,6 +41,29 @@ function isString(node) {
   return [LITERAL, TEMPLATE_LITERAL].includes(node.type);
 }
 
+/**
+ * Checks whether a node is a template literal.
+ *
+ * @param {ASTNode} node The node to type check
+ * @returns {boolean} `true` if node is a template literal.
+ */
+function isTemplateLiteral(node) {
+  return node.type === TEMPLATE_LITERAL;
+}
+
+/**
+ * Extracts the string out of a template literal node.
+ *
+ * @param {ASTNode} node The template literal node
+ * @returns {string} The extracted string.
+ */
+function getTemplateLiteralString(node) {
+  return node.quasis
+    .filter((quasi) => quasi.type === 'TemplateElement')
+    .map((quasi) => quasi.value.raw)
+    .join('');
+}
+
 /**
  * Check that a node is a `VLiteral type`
  * @param {ASTNode} node The node to type check
@@ -54,10 +79,6 @@ function isVLiteral(node) {
  * @returns {array} In form [prefix, postfix] with the content to prepend and append to the string
  */
 function selectFixFunction({ type, value }) {
-  // TODO: needs tests
-  // TODO: these are gitlab specific fixes...
-  // TODO: Need a config for the default externalization function to use
-  // TODO: probably need withExpressionWithQuotes....
   const noQuotes = ['__(', ')'];
   const withQuotes = ['__("', '")'];
   const withExpression = ['{{ __(', ') }}'];
@@ -65,7 +86,6 @@ function selectFixFunction({ type, value }) {
 
   const hasQuotes = isWrappedWithQuotes(value);
 
-  // TODO: double check this is still needed
   if (type === NODE_TYPES.V_TEXT) {
     return hasQuotes ? withExpression : withQuotesExpression;
   } else {
@@ -170,6 +190,8 @@ module.exports = {
   clearSplitLines,
   closest,
   isString,
+  isTemplateLiteral,
+  getTemplateLiteralString,
   isVLiteral,
   removeNewLines,
   selectFixFunction,

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@gitlab/eslint-plugin",
-  "version": "9.2.0",
+  "version": "10.0.1",
   "description": "GitLab package for our custom eslint rules",
   "main": "lib/index.js",
   "scripts": {
     "createRule": "./scripts/createRule.js && yarn update",
     "update": "./scripts/updateFiles.js && prettier --write lib/index.js",
     "commit": "npx git-cz",
-    "test": "mocha tests --recursive"
+    "test": "jest tests"
   },
   "repository": "https://gitlab.com/gitlab-org/frontend/eslint-plugin.git",
   "keywords": [
@@ -48,7 +48,7 @@
   "devDependencies": {
     "eslint": "^7.27.0",
     "glob": "^7.1.3",
-    "mocha": "^6.2.3",
+    "jest": "^26.6.3",
     "prettier": "^2.2.1",
     "pretty-quick": "^3.1.0"
   },

package/docs/rules/require-string-literal-i18n-helpers.md

@@ -1,26 +0,0 @@
-# @gitlab/require-string-literal-i18n-helpers
-
-Prevents translation helpers from being called with non-string-literal arguments.
-
-## Rule Details
-
-### Examples of **incorrect** code for this rule
-
-```js
-const label = __(LABEL);
-const description = __(getDescription());
-```
-
-### Examples of **correct** code for this rule
-
-```js
-const label = __('Some label');
-```
-
-## Options
-
-Nothing
-
-## Related rules
-
-- TBA

package/lib/rules/require-string-literal-i18n-helpers.js

@@ -1,61 +0,0 @@
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-const { DOCS_BASE_URL } = require('../constants');
-const { getFunctionName, isString } = require('../utils/rule-utils');
-
-// ------------------------------------------------------------------------------
-//   Helpers
-// ------------------------------------------------------------------------------
-
-const I18N_HELPERS = new Set(['__', 's__', 'n__']);
-const ERROR_MESSAGE = 'Translation helpers must be called with a string literal.';
-
-const isI18nCall = (node) => {
-  const functionName = getFunctionName(node);
-  return functionName && I18N_HELPERS.has(functionName);
-};
-
-const checkFunctionArgumentFactory = (context) => (node) => {
-  if (!isI18nCall(node)) {
-    return;
-  }
-  const report = (node) => {
-    context.report({
-      node,
-      message: ERROR_MESSAGE,
-    });
-  };
-
-  if (!node.arguments.length) {
-    report(node);
-  }
-  const [arg1, arg2] = node.arguments;
-  if ([arg1, arg2].some((arg) => arg && !isString(arg))) {
-    report(node);
-  }
-};
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  meta: {
-    type: 'error',
-    docs: {
-      description: 'Prevents translation helpers from being called with non-string-literal arguments.',
-      category: 'i18n',
-      url: DOCS_BASE_URL + '/require-string-literal-i18n-helpers.md',
-    },
-  },
-  create(context) {
-    const checkFunctionArgument = checkFunctionArgumentFactory(context);
-
-    return {
-      CallExpression(node) {
-        checkFunctionArgument(node);
-      },
-    };
-  },
-};