Sync with template-lint

Author: NullVoxPopuli

docs/rules/template-no-unbalanced-curlies.md

@@ -2,67 +2,58 @@
 
 <!-- end auto-generated rule header -->
 
-Disallow unbalanced mustache curlies in templates.
+Normally, the compiler will find stray curlies and throw a syntax error. However, it won't be able to catch every case.
 
-## Rule Details
-
-This rule detects unbalanced opening `{{` and closing `}}` mustache braces in templates, which typically indicates a syntax error or typo.
-
-## Examples
-
-Examples of **incorrect** code for this rule:
+For example, these are all syntax errors:
 
 ```gjs
 <template>
-  {{value}
+  {{ x }
+  {{ x }}}
+  {{{ x }
+  {{{ x }}
 </template>
 ```
 
-```gjs
-<template>
-  {{{value}}
-</template>
-```
+Whereas these are not:
 
 ```gjs
 <template>
-  {{#if condition}}
-    {{value}
-  {{/if}}
+  { x }}
+  { x }
+  }
+  }}
+  }}}
+  }}}}... (any number of closing curlies past one)
 </template>
 ```
 
-Examples of **correct** code for this rule:
+This rule focuses on closing double `}}` and triple `}}}` curlies with no matching opening curlies.
 
-```gjs
-<template>
-  {{value}}
-</template>
-```
+## Examples
 
-```gjs
-<template>
-  {{#if condition}}
-    {{value}}
-  {{/if}}
-</template>
-```
+This rule **forbids** the following:
 
 ```gjs
 <template>
-  {{helper param1 param2}}
+  foo}}
+  {foo}}
+  foo}}}
+  {foo}}}
 </template>
 ```
 
 ## Migration
 
 If you have curlies in your code that you wish to show verbatim, but are flagged by this rule, you can formulate them as a handlebars expression:
 
-```hbs
-<p>This is a closing double curly: {{'}}'}}</p>
-<p>This is a closing triple curly: {{'}}}'}}</p>
+```gjs
+<template>
+  <p>This is a closing double curly: {{ '}}' }}</p>
+  <p>This is a closing triple curly: {{ '}}}' }}</p>
+</template>
 ```
 
 ## References
 
-- [eslint-plugin-ember template-no-unbalanced-curlies](https://github.com/ember-cli/eslint-plugin-ember/blob/master/docs/rules/template-no-unbalanced-curlies.md)
+- [Handlebars docs/expressions](https://handlebarsjs.com/guide/expressions.html)

lib/rules/template-no-unbalanced-curlies.js

@@ -1,3 +1,8 @@
+const hbsParser = require('ember-eslint-parser/hbs');
+
+const SUSPECT_CHARS = '}}';
+const reLines = /(.*?(?:\r\n?|\n|$))/gm;
+
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
@@ -10,8 +15,7 @@ module.exports = {
     },
     schema: [],
     messages: {
-      noUnbalancedCurlies:
-        'Unbalanced mustache curlies detected. This may indicate a syntax error.',
+      noUnbalancedCurlies: 'Unbalanced curlies detected',
     },
     originallyFrom: {
       name: 'ember-template-lint',
@@ -22,24 +26,54 @@ module.exports = {
   },
 
   create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
     return {
-      GlimmerTemplate(node) {
-        const sourceCode = context.sourceCode || context.getSourceCode();
-        const text = sourceCode.getText(node);
-
-        // Count opening and closing curlies
-        // Note: The parser typically catches unbalanced curlies before rules run
-        // This serves as a safety check for edge cases
-        // eslint-disable-next-line unicorn/better-regex -- need to escape braces
-        const openingCount = (text.match(/\{\{/g) || []).length;
-        // eslint-disable-next-line unicorn/better-regex -- need to escape braces
-        const closingCount = (text.match(/\}\}/g) || []).length;
-
-        if (openingCount !== closingCount) {
-          context.report({
-            node,
-            messageId: 'noUnbalancedCurlies',
-          });
+      GlimmerTextNode(node) {
+        const chars = node.chars;
+
+        if (!chars.includes(SUSPECT_CHARS)) {
+          return;
+        }
+
+        let isMustache = false;
+
+        try {
+          const ast = hbsParser.parseForESLint(chars).ast;
+          const body = ast.body?.[0]?.body ?? ast.body ?? [];
+          isMustache = body.length > 0 && body[0].type === 'GlimmerMustacheStatement';
+        } catch {
+          // Not a valid standalone mustache; continue checking for stray closing curlies.
+        }
+
+        if (isMustache) {
+          return;
+        }
+
+        let lineNum = node.loc.start.line;
+        let colNum = node.loc.start.column;
+        const source = sourceCode.getText(node);
+        const lines = chars.match(reLines) || [];
+
+        for (const line of lines) {
+          const suspectIndex = line.indexOf(SUSPECT_CHARS);
+
+          if (suspectIndex !== -1) {
+            const length = line.slice(suspectIndex).startsWith('}}}') ? 3 : 2;
+
+            context.report({
+              node,
+              messageId: 'noUnbalancedCurlies',
+              loc: {
+                start: { line: lineNum, column: colNum + suspectIndex },
+                end: { line: lineNum, column: colNum + suspectIndex + length },
+              },
+              source,
+            });
+          }
+
+          lineNum++;
+          colNum = 1;
         }
       },
     };