fix: trailing comma inside delimiters no longer over-indents (#27)

* fix: trailing comma inside delimiters no longer over-indents

Two bugs fixed:

1. Trailing commas inside delimited constructs ({}, [], ()) added an
   extra indent level because the CONTINUATION regex matched them and
   added cx.unit on top of what delimitedIndent already provided. Added
   isInsideDelimiter() to skip continuation indent when inside an
   unclosed bracket.

2. The CONTINUATION regex's trailing-comment capture (#.*)?$ matched
   #{interpolation} inside strings as a "comment", so lines like
   "Hello, #{@name}!" were treated as ending with a trailing comma.
   Changed to (#(?:[^{].*)?)?$ to exclude #{.

13 new test cases (section 33), 1 previously-skipped test unskipped.

* chore: rebuild demo bundle with latest indent fix

* chore: release 0.4.3

Author: jeanpaulsio

CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to this project will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [0.4.3] - 2026-03-27
+
+### Fixed
+
+- **Trailing comma inside delimiters** — Pressing Enter after a line ending with a trailing comma inside `{}`, `[]`, or `()` no longer adds an extra indent level. Added delimiter-depth detection so the continuation-indent logic defers to `delimitedIndent` inside brackets.
+- **String interpolation false positive** — The continuation regex's trailing-comment capture `(#.*)?$` was matching `#{interpolation}` inside strings as a comment, causing lines like `"Hello, #{@name}!"` to be treated as trailing-comma continuations. Fixed by excluding `#{` from the comment pattern.
+
+### Added
+
+- 14 new indent test cases (section 33 + unskipped 28b) covering hashes, arrays, method args, nested constructs, bare call continuations, and interpolated strings
+
+## [0.4.2] - 2026-03-27
+
+### Fixed
+
+- **Heredocs with trailing code** — `foo(<<~SQL)`, `<<~HEREDOC.strip`, and similar patterns where code follows the heredoc opener now parse correctly.
+
 ## [0.4.1] - 2026-03-26
 
 ### Fixed

demo/demo.js

@@ -27348,10 +27348,15 @@
   // ============================================================
   // Less-than / Heredoc external tokenizer (#10)
   //
-  // `<` is ambiguous: comparison, `<=`, `<<` left shift, or heredoc start.
+  // `<` is ambiguous: comparison, `<=`, `<<` left shift, or heredoc.
   // When `<<` is followed by [-~]?IDENTIFIER (or quoted string), and the
-  // parser allows Heredoc, we scan to the matching closing delimiter
-  // and emit the entire heredoc as one token.
+  // parser allows Heredoc, we emit a Heredoc token.
+  //
+  // Two modes depending on trailing code after the opener:
+  // 1. No trailing code: token spans opener + body + closing delimiter
+  // 2. Trailing code (e.g. foo(<<~SQL) or <<~HEREDOC.strip): token spans
+  //    only the opener, allowing the parser to handle trailing syntax
+  //
   // Otherwise emit lessThanOp or lessThanEqOp for comparison.
   // ============================================================
   const lessThanTokenizer = new ExternalTokenizer((input, stack) => {
@@ -27361,9 +27366,9 @@
       // Try heredoc: <<
       if (second === 60 /* '<' */) {
           if (stack.canShift(Heredoc)) {
-              const heredocLen = tryMatchHeredoc(input);
-              if (heredocLen > 0) {
-                  input.acceptToken(Heredoc, heredocLen);
+              const result = tryMatchHeredoc(input);
+              if (result) {
+                  input.acceptToken(Heredoc, result);
                   return;
               }
           }
@@ -27388,13 +27393,20 @@
           input.acceptToken(lessThanOp, 1);
       }
   });
-  // Try to match a complete heredoc starting at the current position.
-  // Returns the total length including the closing delimiter, or 0 if no match.
+  // Try to match a heredoc at the current position.
+  // Returns the total token length, or null if no match.
+  //
+  // Two modes:
+  // 1. No trailing code after opener: token spans opener + body + closing delimiter
+  //    e.g. <<~SQL\n  SELECT 1\nSQL → entire thing is one token
+  // 2. Trailing code after opener: token spans only the opener
+  //    e.g. <<~SQL in foo(<<~SQL) → just <<~SQL is the token
   function tryMatchHeredoc(input) {
       let pos = 2; // past <<
       // Optional - or ~
       const modifier = input.peek(pos);
-      if (modifier === 45 /* - */ || modifier === 126 /* ~ */)
+      const indented = modifier === 45 /* - */ || modifier === 126; /* ~ */
+      if (indented)
           pos++;
       // Read the delimiter
       let delimiter = "";
@@ -27405,7 +27417,7 @@
           while (true) {
               const ch = input.peek(pos);
               if (ch === -1 || ch === 10)
-                  return 0; // unterminated quote
+                  return null; // unterminated quote
               if (ch === quoteChar) {
                   pos++;
                   break;
@@ -27417,90 +27429,87 @@
       else {
           // Bare identifier delimiter: <<~DELIM
           if (!isIdentStart(input.peek(pos)))
-              return 0;
+              return null;
           while (isIdentChar(input.peek(pos))) {
               delimiter += String.fromCharCode(input.peek(pos));
               pos++;
           }
       }
       if (!delimiter)
-          return 0;
-      // After the delimiter, only whitespace/comments allowed on the rest of the line.
-      // If there's code (like .method or (args)), this is << left-shift, not a heredoc.
+          return null;
+      const openerLength = pos; // This is the length of just <<~DELIM
+      // Check what follows the delimiter on the same line.
+      // For bare identifiers without a modifier, non-whitespace trailing code
+      // means this is << operator, not heredoc. E.g. <<File.expand_path(...)
+      // With a modifier (<<~ or <<-) or quoted delimiter, trailing code is OK.
+      let scanPos = pos;
+      let hasTrailingCode = false;
       while (true) {
-          const ch = input.peek(pos);
+          const ch = input.peek(scanPos);
           if (ch === -1)
-              return 0;
+              return null; // EOF on opener line, no body possible
           if (ch === 10) {
-              pos++;
+              scanPos++;
               break;
           }
           if (ch === 13) {
-              pos++;
-              if (input.peek(pos) === 10)
-                  pos++;
+              scanPos++;
+              if (input.peek(scanPos) === 10)
+                  scanPos++;
               break;
           }
           if (ch === 32 || ch === 9) {
-              pos++;
+              scanPos++;
               continue;
-          } // whitespace OK
+          }
           if (ch === 35 /* # */) { // comment — skip rest of line
               while (true) {
-                  const c = input.peek(pos);
+                  const c = input.peek(scanPos);
                   if (c === -1 || c === 10 || c === 13)
                       break;
-                  pos++;
+                  scanPos++;
               }
               continue;
           }
-          // For bare identifiers (not quoted), any non-whitespace after delimiter
-          // means this is << operator, not heredoc. E.g. <<File.expand_path(...)
-          if (quoteChar !== 39 && quoteChar !== 34 && quoteChar !== 96)
-              return 0;
-          pos++; // quoted delimiters can have trailing content (e.g. <<~"SQL", other_arg)
+          // Bare identifier without modifier + trailing code = not a heredoc
+          if (quoteChar !== 39 && quoteChar !== 34 && quoteChar !== 96 &&
+              !indented)
+              return null;
+          hasTrailingCode = true;
+          scanPos++; // modifier/quoted → skip trailing code
       }
-      // Scan lines looking for the closing delimiter
-      const isIndented = modifier === 45 || modifier === 126; // <<- or <<~
       while (true) {
           let lineContent = "";
-          // For indented heredocs (<<- or <<~), skip leading whitespace
-          if (isIndented) {
-              while (input.peek(pos) === 32 || input.peek(pos) === 9)
-                  pos++;
+          if (indented) {
+              while (input.peek(scanPos) === 32 || input.peek(scanPos) === 9)
+                  scanPos++;
           }
-          // Read the rest of the line
           while (true) {
-              const ch = input.peek(pos);
+              const ch = input.peek(scanPos);
               if (ch === -1 || ch === 10 || ch === 13)
                   break;
               lineContent += String.fromCharCode(ch);
-              pos++;
+              scanPos++;
           }
-          // Check if this line matches the delimiter (trimmed)
           if (lineContent === delimiter) {
-              // Include the delimiter line in the token
-              // Advance past newline if present
-              const ch = input.peek(pos);
-              if (ch === 10)
-                  pos++;
-              else if (ch === 13) {
-                  pos++;
-                  if (input.peek(pos) === 10)
-                      pos++;
+              // Found closing delimiter
+              if (hasTrailingCode) {
+                  // Trailing code present — emit only the opener so the parser
+                  // can handle ), .method, etc. on the same line
+                  return openerLength;
               }
-              return pos;
+              // No trailing code — emit the full heredoc (opener + body + delimiter)
+              return scanPos;
           }
-          // Advance past newline
-          const ch = input.peek(pos);
+          const ch = input.peek(scanPos);
           if (ch === -1)
-              return pos; // unterminated heredoc — emit what we have
+              return null; // EOF without closing delimiter
           if (ch === 10)
-              pos++;
+              scanPos++;
           else if (ch === 13) {
-              pos++;
-              if (input.peek(pos) === 10)
-                  pos++;
+              scanPos++;
+              if (input.peek(scanPos) === 10)
+                  scanPos++;
           }
       }
   }
@@ -27859,7 +27868,8 @@
   // Intermediate keywords whose body should indent
   const INTERMEDIATE = /^\s*(else|elsif|when|in|rescue|ensure)\b/;
   // Line ends with a continuation indicator (trailing operator, comma, backslash)
-  const CONTINUATION = /(\+|-|\*|&&|\|\||\\|,|\.)\s*(#.*)?$/;
+  // The optional trailing comment uses (#(?:[^{].*)?)? to avoid matching #{interpolation} inside strings
+  const CONTINUATION = /(\+|-|\*|&&|\|\||\\|,|\.)\s*(#(?:[^{].*)?)?$/;
   // Line starts with a dot (method chaining continuation)
   const LEADING_DOT = /^\s*\./;
   function opensBlock(text) {
@@ -27878,6 +27888,29 @@
       const prevLine = cx.lineAt(lineFrom - 1);
       return prevLine.from;
   }
+  // Check if a line is inside an unclosed delimiter ({, [, ()
+  // by scanning backwards from lineFrom to count unmatched openers
+  function isInsideDelimiter(cx, lineFrom) {
+      let depth = 0;
+      let scanFrom = lineFrom;
+      while (true) {
+          scanFrom = prevLineFrom(cx, scanFrom);
+          if (scanFrom < 0)
+              break;
+          const text = lineText(cx, scanFrom);
+          for (let i = text.length - 1; i >= 0; i--) {
+              const ch = text[i];
+              if (ch === "}" || ch === "]" || ch === ")")
+                  depth++;
+              else if (ch === "{" || ch === "[" || ch === "(") {
+                  if (depth === 0)
+                      return true;
+                  depth--;
+              }
+          }
+      }
+      return false;
+  }
   function rubyIndentService(cx, pos) {
       const line = cx.lineAt(pos);
       const text = line.text;
@@ -28006,6 +28039,11 @@
           }
           // Previous line ends with continuation (trailing operator, comma, backslash)
           if (CONTINUATION.test(prevText)) {
+              // Inside delimited constructs ({}, [], ()), don't add extra indent —
+              // delimitedIndent already handles the correct level
+              if (isInsideDelimiter(cx, prevFrom)) {
+                  return prevIndent;
+              }
               // Check if the line before that was also a continuation — if so, stay at same level
               if (prevFrom > 0) {
                   let prev2From = prevLineFrom(cx, prevFrom);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemirror-lang-ruby",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Ruby language support for CodeMirror 6, built on a Lezer grammar",
   "type": "module",
   "main": "dist/index.cjs",

src/index.ts

@@ -64,7 +64,8 @@ const DEINDENT_CLOSE = /^\s*[\}\]\)]/
 const INTERMEDIATE = /^\s*(else|elsif|when|in|rescue|ensure)\b/
 
 // Line ends with a continuation indicator (trailing operator, comma, backslash)
-const CONTINUATION = /(\+|-|\*|&&|\|\||\\|,|\.)\s*(#.*)?$/
+// The optional trailing comment uses (#(?:[^{].*)?)? to avoid matching #{interpolation} inside strings
+const CONTINUATION = /(\+|-|\*|&&|\|\||\\|,|\.)\s*(#(?:[^{].*)?)?$/
 
 // Line starts with a dot (method chaining continuation)
 const LEADING_DOT = /^\s*\./
@@ -87,6 +88,27 @@ function prevLineFrom(cx: IndentContext, lineFrom: number): number {
   return prevLine.from
 }
 
+// Check if a line is inside an unclosed delimiter ({, [, ()
+// by scanning backwards from lineFrom to count unmatched openers
+function isInsideDelimiter(cx: IndentContext, lineFrom: number): boolean {
+  let depth = 0
+  let scanFrom = lineFrom
+  while (true) {
+    scanFrom = prevLineFrom(cx, scanFrom)
+    if (scanFrom < 0) break
+    const text = lineText(cx, scanFrom)
+    for (let i = text.length - 1; i >= 0; i--) {
+      const ch = text[i]
+      if (ch === "}" || ch === "]" || ch === ")") depth++
+      else if (ch === "{" || ch === "[" || ch === "(") {
+        if (depth === 0) return true
+        depth--
+      }
+    }
+  }
+  return false
+}
+
 function rubyIndentService(cx: IndentContext, pos: number): number | undefined {
   const line = cx.lineAt(pos)
   const text = line.text
@@ -211,6 +233,11 @@ function rubyIndentService(cx: IndentContext, pos: number): number | undefined {
 
     // Previous line ends with continuation (trailing operator, comma, backslash)
     if (CONTINUATION.test(prevText)) {
+      // Inside delimited constructs ({}, [], ()), don't add extra indent —
+      // delimitedIndent already handles the correct level
+      if (isInsideDelimiter(cx, prevFrom)) {
+        return prevIndent
+      }
       // Check if the line before that was also a continuation — if so, stay at same level
       if (prevFrom > 0) {
         let prev2From = prevLineFrom(cx, prevFrom)