Add autofix for template-no-negated-condition

Author: johanrd

lib/rules/template-no-negated-condition.js

@@ -42,6 +42,10 @@ function hasNestedFixableHelper(node) {
   );
 }
 
+function escapeRegExp(str) {
+  return str.replaceAll(/[$()*+.?[\\\]^{|}]/g, '\\$&');
+}
+
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
@@ -52,6 +56,7 @@ module.exports = {
       url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/template-no-negated-condition.md',
       templateMode: 'both',
     },
+    fixable: 'code',
     schema: [
       {
         type: 'object',
@@ -80,6 +85,118 @@ module.exports = {
     const simplifyHelpers = options.simplifyHelpers === undefined ? true : options.simplifyHelpers;
     const sourceCode = context.getSourceCode();
 
+    /**
+     * Get the source text for the inner condition of a (not ...) sub-expression,
+     * with the nested helper optionally inverted.
+     */
+    function getUnwrappedConditionText(notExpr, invertHelper) {
+      const inner = notExpr.params[0];
+      if (invertHelper && inner.path?.type === 'GlimmerPathExpression') {
+        const helperName = inner.path.original;
+        const inverted = HELPER_INVERSIONS[helperName];
+        if (inverted !== undefined) {
+          if (inverted === null) {
+            // (not (not x)) -> just x
+            return sourceCode.getText(inner.params[0]);
+          }
+          // (not (eq a b)) -> (not-eq a b)
+          const innerText = sourceCode.getText(inner);
+          return innerText.replace(`(${helperName} `, `(${inverted} `);
+        }
+      }
+      return sourceCode.getText(inner);
+    }
+
+    /**
+     * Build a fix function for block statements.
+     */
+    function buildBlockFix(node, msgId) {
+      return (fixer) => {
+        const fullText = sourceCode.getText(node);
+        const keyword = node.path.original;
+        const notExpr = node.params[0];
+
+        if (msgId === 'negatedHelper') {
+          const conditionText = getUnwrappedConditionText(notExpr, true);
+          const newText = fullText.replace(sourceCode.getText(notExpr), conditionText);
+          return fixer.replaceText(node, newText);
+        }
+
+        if (msgId === 'flipIf') {
+          const conditionText = getUnwrappedConditionText(notExpr, false);
+          const programBody = node.program.body.map((n) => sourceCode.getText(n)).join('');
+          const inverseBody = node.inverse.body.map((n) => sourceCode.getText(n)).join('');
+          return fixer.replaceText(
+            node,
+            `{{#${keyword} ${conditionText}}}${inverseBody}{{else}}${programBody}{{/${keyword}}}`
+          );
+        }
+
+        if (msgId === 'useIf' || msgId === 'useUnless') {
+          const newKeyword = keyword === 'unless' ? 'if' : 'unless';
+          const conditionText = getUnwrappedConditionText(notExpr, false);
+          const notExprText = escapeRegExp(sourceCode.getText(notExpr));
+          const newText = fullText
+            .replace(
+              new RegExp(`^\\{\\{#${keyword} ${notExprText}`),
+              `{{#${newKeyword} ${conditionText}`
+            )
+            .replace(new RegExp(`\\{\\{/${keyword}\\}\\}$`), `{{/${newKeyword}}}`);
+          return fixer.replaceText(node, newText);
+        }
+
+        return null;
+      };
+    }
+
+    /**
+     * Build a fix function for inline (mustache/subexpression) statements.
+     */
+    function buildInlineFix(node, msgId) {
+      return (fixer) => {
+        const fullText = sourceCode.getText(node);
+        const keyword = node.path.original;
+        const notExpr = node.params[0];
+
+        if (msgId === 'negatedHelper') {
+          const conditionText = getUnwrappedConditionText(notExpr, true);
+          const newText = fullText.replace(sourceCode.getText(notExpr), conditionText);
+          return fixer.replaceText(node, newText);
+        }
+
+        if (msgId === 'flipIf') {
+          const conditionText = getUnwrappedConditionText(notExpr, false);
+          const param1Text = sourceCode.getText(node.params[1]);
+          const param2Text = sourceCode.getText(node.params[2]);
+          const isSubExpr = node.type === 'GlimmerSubExpression';
+          const open = isSubExpr ? '(' : '{{';
+          const close = isSubExpr ? ')' : '}}';
+          return fixer.replaceText(
+            node,
+            `${open}${keyword} ${conditionText} ${param2Text} ${param1Text}${close}`
+          );
+        }
+
+        if (msgId === 'useIf' || msgId === 'useUnless') {
+          const newKeyword = keyword === 'unless' ? 'if' : 'unless';
+          const conditionText = getUnwrappedConditionText(notExpr, false);
+          const isSubExpr = node.type === 'GlimmerSubExpression';
+          const open = isSubExpr ? '(' : '{{';
+          const close = isSubExpr ? ')' : '}}';
+          const remainingParams = node.params
+            .slice(1)
+            .map((p) => sourceCode.getText(p))
+            .join(' ');
+          return fixer.replaceText(
+            node,
+            `${open}${newKeyword} ${conditionText} ${remainingParams}${close}`
+          );
+        }
+
+        return null;
+      };
+    }
+
     // eslint-disable-next-line complexity
     function checkNode(node) {
       const nodeIsIf = isIf(node);
@@ -97,7 +214,11 @@ module.exports = {
           if (!simplifyHelpers || !hasNotHelper(node) || !hasNestedFixableHelper(node)) {
             return;
           }
-          context.report({ node: node.params[0], messageId: 'negatedHelper' });
+          context.report({
+            node: node.params[0],
+            messageId: 'negatedHelper',
+            fix: buildBlockFix(node, 'negatedHelper'),
+          });
           return;
         }
 
@@ -129,7 +250,7 @@ module.exports = {
         return;
       }
 
-      // (not a b c) with multiple params — can't simply remove negation
+      // (not a b c) with multiple params - can't simply remove negation
       if (notExpr.params?.length > 1) {
         return;
       }
@@ -150,9 +271,11 @@ module.exports = {
         messageId = 'useUnless';
       }
 
+      const isBlock = node.type === 'GlimmerBlockStatement';
       context.report({
         node: notExpr,
         messageId,
+        fix: isBlock ? buildBlockFix(node, messageId) : buildInlineFix(node, messageId),
       });
     }