jeanpaulsio
diff --git a/‎README.md‎
Lines changed: 9 additions & 7 deletions b/‎README.md‎
Lines changed: 9 additions & 7 deletions
diff --git a/‎src/highlight.ts‎
Lines changed: 3 additions & 1 deletion b/‎src/highlight.ts‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎src/index.ts‎
Lines changed: 31 additions & 3 deletions b/‎src/index.ts‎
Lines changed: 31 additions & 3 deletions
@@ -50,22 +50,24 @@ Tested against popular open source Ruby projects (large, representative files):
 - **Bare method calls**: `puts "hello"`, `require "json"`, `attr_reader :name`, `include Comparable` (25 common Ruby methods)
 - **Variables**: local, `@instance`, `@@class`, `$global`, `Constants`
 - **Comments**: line `#` and block `=begin`/`=end`
-- **Editor features**: smart indentation (119 test cases), code folding, bracket closing, keyword autocompletion (31 keywords)
+- **Editor features**: smart indentation, code folding, bracket closing, keyword autocompletion (31 keywords)
 
 ## Known limitations
 
-- Blank lines inside class/method bodies can produce spurious error nodes (~38% of parse errors)
-- Multi-arg bare method calls (`raise ArgumentError, "msg"`) not fully supported
-- Compound assignment operators (`+=`, `-=`, `|=`) in some contexts
-- Heredoc and `%`-literal bodies are opaque tokens (no interpolation highlighting inside)
-- `<<` left-shift operator not distinguished from heredoc start
+- **Heredocs as arguments or in chains** — `foo(<<~SQL)` and `<<~HEREDOC.strip` don't parse correctly. Heredocs assigned to variables (`x = <<~SQL`) work fine. The limitation is architectural: the heredoc body starts on the next line but the closing `)` or `.method` needs to be parsed on the current line, which requires a split-token approach not yet implemented.
+- **Leading `::` scope resolution** — `::TopLevel` as a standalone expression doesn't parse. Scoped references with a receiver (`Foo::Bar`, `Foo::Bar::Baz`) work fine.
+- **Advanced pattern matching** — Basic `case/in` with array patterns and pin operators work. Hash patterns (`in {name: String => n}`), guard clauses (`in x if x > 0`), and find patterns (`in [*, 2, *]`) are not yet supported.
+- **Heredoc and `%`-literal bodies** are opaque tokens (no interpolation highlighting inside).
+- **Inline rescue as a standalone expression** — `value = foo rescue nil` works (rescue in assignments), but `foo rescue bar` as a standalone expression outside of assignment context is not supported.
+- **Newline as statement separator** — Ruby uses newlines to separate statements, but the grammar is whitespace-insensitive. An expression followed by `if` on the next line may be parsed as a conditional modifier (e.g., `x = 1\nif cond` parses as `x = (1 if cond)`).
+- **Symbol-key shorthand in method calls** — `foo(name: "value")` with symbol-key syntax is not yet supported. Use rocket syntax `foo(:name => "value")` as a workaround.
 
 ## Development
 
 ```bash
 npm install          # Install dependencies
 npm run build        # Build grammar + bundle to dist/
-npm test             # Run all 89 grammar tests
+npm test             # Run all 105 grammar tests
 npm run lint         # TypeScript type check
 npm run demo:build   # Build the demo page
 ```
 
@@ -1,7 +1,8 @@
 import {styleTags, tags as t} from "@lezer/highlight"
 
 export const rubyHighlighting = styleTags({
-  "def class module end do begin rescue ensure raise return yield": t.keyword,
+  "def class module end do begin rescue ensure return yield super": t.keyword,
+  "BareMethodCall/raise": t.keyword,
   "if elsif else unless case when then while until for in break next": t.keyword,
   "and or not": t.keyword,
   "nil true false self": t.atom,
@@ -39,6 +40,7 @@ export const rubyHighlighting = styleTags({
   ". &.": t.derefOperator,
   ", ;": t.separator,
   'ArithOp "-" "*" "**"': t.arithmeticOperator,
+  '"~" "|" "&" "^" shiftLeftOp shiftRightOp': t.bitwiseOperator,
   CompareOp: t.compareOperator,
   "AssignOp": t.updateOperator,
   LogicOp: t.logicOperator,
 
@@ -43,7 +43,7 @@ const rubyCompletion = completeFromList([
 
 // Block-opening keyword at line start (or after `=` for assignment forms)
 const INDENT_KEYWORD = /\b(def|class|module|if|unless|while|until|for|case|begin)\b/
-const INDENT_AFTER = /^\s*(def|class|module|if|unless|while|until|for|case|begin)\b/
+const INDENT_AFTER = /^\s*(?:(?:private|protected|public|private_class_method|public_class_method)\s+)?(def|class|module|if|unless|while|until|for|case|begin)\b/
 // Also matches `x = if condition`, `x = begin`, `@foo ||= begin`, etc.
 const INDENT_ASSIGN = /[=]\s*(if|unless|case|begin)\b/
 const INDENT_END = /\b(do)\s*(\|[^|]*\|)?\s*(#.*)?$|\{\s*(\|[^|]*\|)?\s*(#.*)?$/
@@ -64,7 +64,7 @@ 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*(#.*)?$/
+const CONTINUATION = /(\+|-|\*|&&|\|\||\\|,|\.)\s*(#.*)?$/
 
 // Line starts with a dot (method chaining continuation)
 const LEADING_DOT = /^\s*\./
@@ -81,14 +81,35 @@ function rubyIndentService(cx: IndentContext, pos: number): number | undefined {
 
   // Current line starts with a deindent keyword → find the right level
   if (DEINDENT_ON.test(text)) {
+    const isEnd = /^\s*end\b/.test(text)
     // Scan backwards to find the matching opening keyword at the right nesting level
     let depth = 0
+    let braceDepth = 0
     for (let i = lineNum - 1; i >= 1; i--) {
       const prev = doc.line(i).text
+      // Track } closers for brace-style blocks
+      if (/^\s*\}/.test(prev)) braceDepth++
       if (/^\s*end\b/.test(prev)) depth++
-      else if (INDENT_AFTER.test(prev) || INDENT_ASSIGN.test(prev) || INDENT_END.test(prev)) {
+      else if (INDENT_AFTER.test(prev) || INDENT_ASSIGN.test(prev)) {
         if (depth === 0) return cx.lineIndent(doc.line(i).from)
         depth--
+      } else if (INDENT_END.test(prev)) {
+        // Distinguish brace-style ({) from do-style openers
+        if (/\{\s*(\|[^|]*\|)?\s*(#.*)?$/.test(prev)) {
+          // Brace-style opener — pair with } closers
+          if (braceDepth > 0) {
+            braceDepth--
+          } else if (!isEnd) {
+            // Non-end keywords (else, rescue, etc.) can match brace openers
+            if (depth === 0) return cx.lineIndent(doc.line(i).from)
+            depth--
+          }
+          // `end` never closes a `{`, so skip this opener
+        } else {
+          // do-style opener
+          if (depth === 0) return cx.lineIndent(doc.line(i).from)
+          depth--
+        }
       }
     }
     return 0
@@ -230,6 +251,13 @@ export const rubyLanguage = LRLanguage.define({
       }),
       foldNodeProp.add({
         "ClassBody ModuleBody MethodBody Block DoBlock BeginBlock": foldInside,
+        "MethodDef ClassDef ModuleDef"(tree, state) {
+          // Fold from end of first line to before `end`
+          const firstLine = state.doc.lineAt(tree.from)
+          const lastLine = state.doc.lineAt(tree.to)
+          if (firstLine.number >= lastLine.number) return null
+          return {from: firstLine.to, to: lastLine.from}
+        },
         "IfStatement UnlessStatement WhileStatement UntilStatement ForStatement CaseStatement"(tree) {
           return {from: tree.from, to: tree.to}
         },