@reteps/tree-sitter-htmlmustache 0.1.0 → 0.2.1

package/cli/out/main.js

@@ -1838,11 +1838,20 @@ function mergeAdjacentForks(items) {
   }
   return result;
 }
+function hasTagEvents(items) {
+  for (const item of items) {
+    if (item.type !== "fork") return true;
+    if (hasTagEvents(item.truthy) || hasTagEvents(item.falsy)) return true;
+  }
+  return false;
+}
 function collectSectionNames(items) {
   const names = /* @__PURE__ */ new Set();
   for (const item of items) {
     if (item.type === "fork") {
-      names.add(item.sectionName);
+      if (hasTagEvents(item.truthy) || hasTagEvents(item.falsy)) {
+        names.add(item.sectionName);
+      }
       for (const name of collectSectionNames(item.truthy)) names.add(name);
       for (const name of collectSectionNames(item.falsy)) names.add(name);
     }
@@ -2004,6 +2013,196 @@ function checkHtmlBalance(rootNode) {
   return allErrors;
 }
 
+// lsp/server/src/mustacheChecks.ts
+function checkNestedSameNameSections(rootNode) {
+  const errors = [];
+  function visit(node, ancestors) {
+    if (node.type === "mustache_section" || node.type === "mustache_inverted_section") {
+      const name = getSectionName(node);
+      if (name) {
+        if (ancestors.has(name)) {
+          const beginNode = node.children.find(
+            (c) => c.type === "mustache_section_begin" || c.type === "mustache_inverted_section_begin"
+          );
+          errors.push({
+            node: beginNode ?? node,
+            message: `Nested duplicate section: {{#${name}}} is already open in an ancestor`
+          });
+        }
+        const next = new Set(ancestors);
+        next.add(name);
+        for (const child of node.children) {
+          visit(child, next);
+        }
+        return;
+      }
+    }
+    for (const child of node.children) {
+      visit(child, ancestors);
+    }
+  }
+  visit(rootNode, /* @__PURE__ */ new Set());
+  return errors;
+}
+function checkUnquotedMustacheAttributes(rootNode) {
+  const errors = [];
+  function visit(node) {
+    if (node.type === "html_attribute") {
+      const mustacheNode = node.children.find((c) => c.type === "mustache_interpolation");
+      if (mustacheNode) {
+        errors.push({
+          node: mustacheNode,
+          message: `Unquoted mustache attribute value: ${mustacheNode.text}`,
+          fix: [{
+            startIndex: mustacheNode.startIndex,
+            endIndex: mustacheNode.endIndex,
+            newText: `"${mustacheNode.text}"`
+          }],
+          fixDescription: "Wrap mustache value in quotes"
+        });
+      }
+      return;
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+function checkConsecutiveSameNameSections(rootNode, sourceText) {
+  const errors = [];
+  function visit(node) {
+    const children = node.children;
+    for (let i = 0; i < children.length - 1; i++) {
+      const current = children[i];
+      const next = children[i + 1];
+      if (current.type !== "mustache_section" && current.type !== "mustache_inverted_section" || current.type !== next.type) {
+        continue;
+      }
+      const currentName = getSectionName(current);
+      const nextName = getSectionName(next);
+      if (!currentName || !nextName || currentName !== nextName) continue;
+      const gap = sourceText.slice(current.endIndex, next.startIndex);
+      if (gap.length > 0 && !/^\s*$/.test(gap)) continue;
+      const endTagType = current.type === "mustache_section" ? "mustache_section_end" : "mustache_inverted_section_end";
+      const beginTagType = next.type === "mustache_section" ? "mustache_section_begin" : "mustache_inverted_section_begin";
+      const currentEndTag = current.children.find((c) => c.type === endTagType);
+      const nextBeginTag = next.children.find((c) => c.type === beginTagType);
+      if (!currentEndTag || !nextBeginTag) continue;
+      const sectionTypeStr = current.type === "mustache_section" ? "#" : "^";
+      const nextBeginNode = next.children.find(
+        (c) => c.type === "mustache_section_begin" || c.type === "mustache_inverted_section_begin"
+      );
+      errors.push({
+        node: nextBeginNode ?? next,
+        message: `Consecutive duplicate section: {{${sectionTypeStr}${nextName}}} can be merged with previous {{${sectionTypeStr}${nextName}}}`,
+        severity: "warning",
+        fix: [{
+          startIndex: currentEndTag.startIndex,
+          endIndex: nextBeginTag.endIndex,
+          newText: ""
+        }],
+        fixDescription: "Merge consecutive sections"
+      });
+    }
+    for (const child of children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+function areMutuallyExclusive(a, b) {
+  for (const ac of a) {
+    for (const bc of b) {
+      if (ac.name === bc.name && ac.inverted !== bc.inverted) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function formatConditionClause(a, b) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const c of [...a, ...b]) {
+    if (!seen.has(c.name)) {
+      seen.set(c.name, c.inverted);
+    }
+  }
+  if (seen.size === 0) return "";
+  const parts = [];
+  for (const [name, inverted] of seen) {
+    parts.push(`${name} is ${inverted ? "falsy" : "truthy"}`);
+  }
+  return ` (when ${parts.join(", ")})`;
+}
+function collectAttributes(node, conditions, out) {
+  for (const child of node.children) {
+    if (child.type === "html_attribute") {
+      const nameNode = child.children.find((c) => c.type === "html_attribute_name");
+      if (nameNode) {
+        out.push({ nameNode, conditions: [...conditions] });
+      }
+    } else if (child.type === "mustache_attribute") {
+      const section = child.children.find(
+        (c) => c.type === "mustache_section" || c.type === "mustache_inverted_section"
+      );
+      if (section) {
+        const name = getSectionName(section);
+        if (name) {
+          const inverted = section.type === "mustache_inverted_section";
+          collectAttributes(section, [...conditions, { name, inverted }], out);
+        }
+      }
+    }
+  }
+}
+function checkDuplicateAttributes(rootNode) {
+  const errors = [];
+  function visit(node) {
+    if (node.type === "html_start_tag" || node.type === "html_self_closing_tag") {
+      const occurrences = [];
+      collectAttributes(node, [], occurrences);
+      const groups = /* @__PURE__ */ new Map();
+      for (const occ of occurrences) {
+        const key = occ.nameNode.text.toLowerCase();
+        let group2 = groups.get(key);
+        if (!group2) {
+          group2 = [];
+          groups.set(key, group2);
+        }
+        group2.push(occ);
+      }
+      for (const [, group2] of groups) {
+        if (group2.length < 2) continue;
+        for (let i = 1; i < group2.length; i++) {
+          let conflictIdx = -1;
+          for (let j = 0; j < i; j++) {
+            if (!areMutuallyExclusive(group2[i].conditions, group2[j].conditions)) {
+              conflictIdx = j;
+              break;
+            }
+          }
+          if (conflictIdx >= 0) {
+            const clause = formatConditionClause(group2[conflictIdx].conditions, group2[i].conditions);
+            errors.push({
+              node: group2[i].nameNode,
+              message: `Duplicate attribute "${group2[i].nameNode.text}"${clause}`
+            });
+          }
+        }
+      }
+      return;
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+
 // cli/src/check.ts
 function errorMessageForNode(nodeType, node) {
   if (nodeType === "mustache_erroneous_section_end" || nodeType === "mustache_erroneous_inverted_section_end") {
@@ -2071,12 +2270,36 @@ function collectErrors(tree, file) {
       nodeText: error.node.text
     });
   }
+  const sourceText = rootNode.text;
+  const mustacheChecks = [
+    ...checkNestedSameNameSections(rootNode),
+    ...checkUnquotedMustacheAttributes(rootNode),
+    ...checkConsecutiveSameNameSections(rootNode, sourceText),
+    ...checkDuplicateAttributes(rootNode)
+  ];
+  for (const error of mustacheChecks) {
+    errors.push({
+      file,
+      line: error.node.startPosition.row + 1,
+      column: error.node.startPosition.column + 1,
+      endLine: error.node.endPosition.row + 1,
+      endColumn: error.node.endPosition.column + 1,
+      message: error.message,
+      nodeText: error.node.text,
+      severity: error.severity,
+      fix: error.fix,
+      fixDescription: error.fixDescription
+    });
+  }
   return errors;
 }
 function formatError(error, source) {
   const lines = source.split("\n");
   const errorLine = error.line - 1;
-  const header = import_chalk.default.bold(`${error.file}:${error.line}:${error.column}`) + " " + import_chalk.default.red("error") + ": " + error.message;
+  const isWarning = error.severity === "warning";
+  const severityLabel = isWarning ? import_chalk.default.yellow("warning") : import_chalk.default.red("error");
+  const colorFn = isWarning ? import_chalk.default.yellow : import_chalk.default.red;
+  const header = import_chalk.default.bold(`${error.file}:${error.line}:${error.column}`) + " " + severityLabel + ": " + error.message;
   const contextStart = Math.max(0, errorLine - 2);
   const contextEnd = Math.min(lines.length - 1, error.endLine - 1);
   const gutterWidth = String(contextEnd + 1).length;
@@ -2100,17 +2323,25 @@ function formatError(error, source) {
   }
   const underlineLength = Math.max(1, underlineEnd - underlineStart);
   const underline = " ".repeat(underlineStart) + "^".repeat(underlineLength) + " " + error.message;
-  outputLines.push(import_chalk.default.dim(" ".repeat(gutterWidth) + " |") + " " + import_chalk.default.red(underline));
+  outputLines.push(import_chalk.default.dim(" ".repeat(gutterWidth) + " |") + " " + colorFn(underline));
   return outputLines.join("\n");
 }
-function formatSummary(totalErrors, filesWithErrors, totalFiles) {
-  if (totalErrors === 0) {
+function formatSummary(totalErrors, filesWithErrors, totalFiles, totalWarnings = 0) {
+  if (totalErrors === 0 && totalWarnings === 0) {
     return import_chalk.default.green(`No errors found (${totalFiles} ${totalFiles === 1 ? "file" : "files"} checked)`);
   }
-  const errStr = totalErrors === 1 ? "error" : "errors";
-  const errFileStr = filesWithErrors === 1 ? "file" : "files";
   const totalStr = totalFiles === 1 ? "file" : "files";
-  return import_chalk.default.red(`${totalErrors} ${errStr} in ${filesWithErrors} ${errFileStr}`) + ` (${totalFiles} ${totalStr} checked)`;
+  const parts = [];
+  if (totalErrors > 0) {
+    const errStr = totalErrors === 1 ? "error" : "errors";
+    parts.push(import_chalk.default.red(`${totalErrors} ${errStr}`));
+  }
+  if (totalWarnings > 0) {
+    const warnStr = totalWarnings === 1 ? "warning" : "warnings";
+    parts.push(import_chalk.default.yellow(`${totalWarnings} ${warnStr}`));
+  }
+  const errFileStr = filesWithErrors === 1 ? "file" : "files";
+  return `${parts.join(", ")} in ${filesWithErrors} ${errFileStr} (${totalFiles} ${totalStr} checked)`;
 }
 function expandGlobs(patterns) {
   const files = /* @__PURE__ */ new Set();
@@ -2168,7 +2399,25 @@ function resolveFiles(cliPatterns) {
   }
   return { files, config };
 }
-var USAGE = `Usage: htmlmustache check [patterns...]
+function applyFixes(source, errors) {
+  const replacements = [];
+  for (const error of errors) {
+    if (error.fix) {
+      replacements.push(...error.fix);
+    }
+  }
+  if (replacements.length === 0) return source;
+  replacements.sort((a, b) => b.startIndex - a.startIndex);
+  let result = source;
+  let minIndex = Infinity;
+  for (const r of replacements) {
+    if (r.endIndex > minIndex) continue;
+    result = result.slice(0, r.startIndex) + r.newText + result.slice(r.endIndex);
+    minIndex = r.startIndex;
+  }
+  return result;
+}
+var USAGE = `Usage: htmlmustache check [options] [patterns...]
 
 Check HTML Mustache templates for errors.
 
@@ -2176,10 +2425,12 @@ Arguments:
   patterns  One or more glob patterns (optional if "include" is set in config)
 
 Options:
+  --fix     Automatically fix fixable errors in-place
   --help    Show this help message
 
 Examples:
   htmlmustache check '**/*.mustache'
+  htmlmustache check --fix '**/*.mustache'
   htmlmustache check 'templates/**/*.hbs' 'partials/**/*.mustache'
   htmlmustache check                       (uses "include" from .htmlmustache.jsonc)`;
 async function run(args) {
@@ -2190,37 +2441,52 @@ async function run(args) {
     console.log(USAGE);
     return 0;
   }
-  const { files, config } = resolveFiles(args);
+  const fixMode = args.includes("--fix");
+  const patterns = args.filter((a) => a !== "--fix");
+  const { files, config } = resolveFiles(patterns);
   if (files.length === 0) {
-    if (args.length === 0 && (!config?.include || config.include.length === 0)) {
+    if (patterns.length === 0 && (!config?.include || config.include.length === 0)) {
       console.log(USAGE);
       return 1;
     }
-    const patterns = args.length > 0 ? args : config?.include ?? [];
+    const displayPatterns = patterns.length > 0 ? patterns : config?.include ?? [];
     console.error(import_chalk.default.yellow("No files matched the given patterns:"));
-    for (const p of patterns) {
+    for (const p of displayPatterns) {
       console.error(import_chalk.default.yellow(`  ${p}`));
     }
     return 1;
   }
   await initializeParser();
   let totalErrors = 0;
+  let totalWarnings = 0;
   let filesWithErrors = 0;
   const cwd = process.cwd();
   const errorOutput = [];
   for (const file of files) {
     const displayPath = import_node_path.default.relative(cwd, file) || file;
-    const source = import_node_fs.default.readFileSync(file, "utf-8");
+    let source = import_node_fs.default.readFileSync(file, "utf-8");
+    if (fixMode) {
+      const tree2 = parseDocument(source);
+      const errors2 = collectErrors(tree2, displayPath);
+      const fixed = applyFixes(source, errors2);
+      if (fixed !== source) {
+        import_node_fs.default.writeFileSync(file, fixed, "utf-8");
+        source = fixed;
+      }
+    }
     const tree = parseDocument(source);
     const errors = collectErrors(tree, displayPath);
+    const fileErrors = errors.filter((e) => e.severity !== "warning");
+    const fileWarnings = errors.filter((e) => e.severity === "warning");
     if (errors.length > 0) {
       filesWithErrors++;
-      totalErrors += errors.length;
+      totalErrors += fileErrors.length;
+      totalWarnings += fileWarnings.length;
       for (const error of errors) {
         errorOutput.push(formatError(error, source));
       }
     }
-    console.log(errors.length > 0 ? import_chalk.default.red(displayPath) : import_chalk.default.dim(displayPath));
+    console.log(errors.length > 0 ? fileErrors.length > 0 ? import_chalk.default.red(displayPath) : import_chalk.default.yellow(displayPath) : import_chalk.default.dim(displayPath));
   }
   if (errorOutput.length > 0) {
     console.log();
@@ -2229,7 +2495,7 @@ async function run(args) {
       console.log();
     }
   }
-  console.log(formatSummary(totalErrors, filesWithErrors, files.length));
+  console.log(formatSummary(totalErrors, filesWithErrors, files.length, totalWarnings));
   return totalErrors > 0 ? 1 : 0;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reteps/tree-sitter-htmlmustache",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "HTML with Mustache/Handlebars template syntax grammar for tree-sitter",
   "repository": {
     "type": "git",