@herb-tools/language-server 0.8.9 → 0.9.0

package/dist/types/rewrite_code_action_service.d.ts

@@ -0,0 +1,11 @@
+import { CodeAction, Range } from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { ParserService } from "./parser_service";
+export declare class RewriteCodeActionService {
+    private parserService;
+    constructor(parserService: ParserService);
+    getCodeActions(document: TextDocument, requestedRange: Range): CodeAction[];
+    private createActionViewToHTMLAction;
+    private createHTMLToActionViewAction;
+    private rangesOverlap;
+}

package/dist/types/service.d.ts

@@ -11,6 +11,11 @@ import { ConfigService } from "./config_service";
 import { AutofixService } from "./autofix_service";
 import { CodeActionService } from "./code_action_service";
 import { DocumentSaveService } from "./document_save_service";
+import { FoldingRangeService } from "./folding_range_service";
+import { DocumentHighlightService } from "./document_highlight_service";
+import { HoverService } from "./hover_service";
+import { RewriteCodeActionService } from "./rewrite_code_action_service";
+import { CommentService } from "./comment_service";
 export declare class Service {
     connection: Connection;
     settings: Settings;
@@ -25,6 +30,11 @@ export declare class Service {
     configService: ConfigService;
     codeActionService: CodeActionService;
     documentSaveService: DocumentSaveService;
+    foldingRangeService: FoldingRangeService;
+    documentHighlightService: DocumentHighlightService;
+    hoverService: HoverService;
+    rewriteCodeActionService: RewriteCodeActionService;
+    commentService: CommentService;
     constructor(connection: Connection, params: InitializeParams);
     init(): Promise<void>;
     refresh(): Promise<void>;

package/dist/types/utils.d.ts

@@ -1,12 +1,6 @@
 import { DiagnosticSeverity } from "vscode-languageserver/node";
 import type { LintSeverity } from "@herb-tools/linter";
-import type { Range } from "vscode-languageserver/node";
-import type { TextDocument } from "vscode-languageserver-textdocument";
 export declare function camelize(value: string): string;
 export declare function dasherize(value: string): string;
 export declare function capitalize(value: string): string;
 export declare function lintToDignosticSeverity(severity: LintSeverity): DiagnosticSeverity;
-/**
- * Returns a Range that spans the entire document
- */
-export declare function getFullDocumentRange(document: TextDocument): Range;

package/dist/utils.js

@@ -1,5 +1,4 @@
 import { DiagnosticSeverity } from "vscode-languageserver/node";
-import { Position } from "vscode-languageserver/node";
 export function camelize(value) {
     return value.replace(/(?:[_-])([a-z0-9])/g, (_, char) => char.toUpperCase());
 }
@@ -17,19 +16,4 @@ export function lintToDignosticSeverity(severity) {
         case "hint": return DiagnosticSeverity.Hint;
     }
 }
-/**
- * Returns a Range that spans the entire document
- */
-export function getFullDocumentRange(document) {
-    const lastLine = document.lineCount - 1;
-    const lastLineText = document.getText({
-        start: Position.create(lastLine, 0),
-        end: Position.create(lastLine + 1, 0)
-    });
-    const lastLineLength = lastLineText.length;
-    return {
-        start: Position.create(0, 0),
-        end: Position.create(lastLine, lastLineLength)
-    };
-}
 //# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAG/D,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAKrD,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,OAAO,KAAK,CAAC,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAA;AAC9E,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,OAAO,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,CAAA;AACzE,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AACvD,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,QAAsB;IAC5D,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,OAAO,CAAC,CAAC,OAAO,kBAAkB,CAAC,KAAK,CAAA;QAC7C,KAAK,SAAS,CAAC,CAAC,OAAO,kBAAkB,CAAC,OAAO,CAAA;QACjD,KAAK,MAAM,CAAC,CAAC,OAAO,kBAAkB,CAAC,WAAW,CAAA;QAClD,KAAK,MAAM,CAAC,CAAC,OAAO,kBAAkB,CAAC,IAAI,CAAA;IAC7C,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAsB;IACzD,MAAM,QAAQ,GAAG,QAAQ,CAAC,SAAS,GAAG,CAAC,CAAA;IACvC,MAAM,YAAY,GAAG,QAAQ,CAAC,OAAO,CAAC;QACpC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;QACnC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC,CAAC;KACtC,CAAC,CAAA;IACF,MAAM,cAAc,GAAG,YAAY,CAAC,MAAM,CAAA;IAE1C,OAAO;QACL,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;QAC5B,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,cAAc,CAAC;KAC/C,CAAA;AACH,CAAC"}
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAG/D,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,OAAO,KAAK,CAAC,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAA;AAC9E,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,OAAO,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,CAAA;AACzE,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AACvD,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,QAAsB;IAC5D,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,OAAO,CAAC,CAAC,OAAO,kBAAkB,CAAC,KAAK,CAAA;QAC7C,KAAK,SAAS,CAAC,CAAC,OAAO,kBAAkB,CAAC,OAAO,CAAA;QACjD,KAAK,MAAM,CAAC,CAAC,OAAO,kBAAkB,CAAC,WAAW,CAAA;QAClD,KAAK,MAAM,CAAC,CAAC,OAAO,kBAAkB,CAAC,IAAI,CAAA;IAC7C,CAAC;AACH,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@herb-tools/language-server",
   "description": "Herb HTML+ERB Language Tools and Language Server Protocol integration.",
-  "version": "0.8.9",
+  "version": "0.9.0",
   "author": "Marco Roth",
   "license": "MIT",
   "engines": {
@@ -45,12 +45,17 @@
     "dist/"
   ],
   "dependencies": {
-    "@herb-tools/config": "0.8.9",
-    "@herb-tools/formatter": "0.8.9",
-    "@herb-tools/linter": "0.8.9",
-    "@herb-tools/node-wasm": "0.8.9",
+    "@herb-tools/config": "0.9.0",
+    "@herb-tools/formatter": "0.9.0",
+    "@herb-tools/linter": "0.9.0",
+    "@herb-tools/node-wasm": "0.9.0",
+    "@herb-tools/printer": "0.9.0",
+    "@herb-tools/rewriter": "0.9.0",
     "dedent": "^1.7.0",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3"
   }
 }

package/src/action_view_helpers.ts

@@ -0,0 +1,23 @@
+export interface ActionViewHelperInfo {
+  signature: string
+  documentationURL: string
+}
+
+export const ACTION_VIEW_HELPERS: Record<string, ActionViewHelperInfo> = {
+  "ActionView::Helpers::TagHelper#tag": {
+    signature: "tag.<tag name>(optional content, options)",
+    documentationURL: "https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-tag",
+  },
+  "ActionView::Helpers::TagHelper#content_tag": {
+    signature: "content_tag(name, content_or_options_with_block = nil, options = nil, escape = true, &block)",
+    documentationURL: "https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-content_tag",
+  },
+  "ActionView::Helpers::UrlHelper#link_to": {
+    signature: "link_to(name = nil, options = nil, html_options = nil, &block)",
+    documentationURL: "https://api.rubyonrails.org/classes/ActionView/Helpers/UrlHelper.html#method-i-link_to",
+  },
+  "Turbo::FramesHelper#turbo_frame_tag": {
+    signature: "turbo_frame_tag(*ids, src: nil, target: nil, **attributes, &block)",
+    documentationURL: "https://www.rubydoc.info/github/hotwired/turbo-rails/Turbo/FramesHelper:turbo_frame_tag",
+  },
+}

package/src/autofix_service.ts

@@ -5,7 +5,7 @@ import { Herb } from "@herb-tools/node-wasm"
 import { Linter } from "@herb-tools/linter"
 import { Config } from "@herb-tools/config"
 
-import { getFullDocumentRange } from "./utils"
+import { getFullDocumentRange } from "./range_utils"
 
 export class AutofixService {
   private connection: Connection

package/src/code_action_service.ts

@@ -1,4 +1,4 @@
-import { CodeAction, CodeActionKind, CodeActionParams, Diagnostic, Range, Position, TextEdit, WorkspaceEdit, CreateFile, TextDocumentEdit, OptionalVersionedTextDocumentIdentifier } from "vscode-languageserver/node"
+import { CodeAction, CodeActionKind, CodeActionParams, Diagnostic, Range, TextEdit, WorkspaceEdit, CreateFile, TextDocumentEdit, OptionalVersionedTextDocumentIdentifier } from "vscode-languageserver/node"
 import { TextDocument } from "vscode-languageserver-textdocument"
 
 import { Config } from "@herb-tools/config"
@@ -6,7 +6,7 @@ import { Project } from "./project"
 import { Herb } from "@herb-tools/node-wasm"
 import { Linter } from "@herb-tools/linter"
 
-import { getFullDocumentRange } from "./utils"
+import { getFullDocumentRange, lspRangeFromLocation } from "./range_utils"
 
 import type { LintOffense } from "@herb-tools/linter"
 
@@ -362,10 +362,7 @@ export class CodeActionService {
   }
 
   private offenseToRange(offense: LintOffense): Range {
-    return {
-      start: Position.create(offense.location.start.line - 1, offense.location.start.column),
-      end: Position.create(offense.location.end.line - 1, offense.location.end.column)
-    }
+    return lspRangeFromLocation(offense.location)
   }
 
   private rangesEqual(r1: Range, r2: Range): boolean {

package/src/comment_ast_utils.ts

@@ -0,0 +1,282 @@
+import { ParserService } from "./parser_service"
+import { LineContextCollector } from "./line_context_collector"
+
+import { HTMLCommentNode, Location, createSyntheticToken } from "@herb-tools/core"
+import { IdentityPrinter } from "@herb-tools/printer"
+
+import { isERBCommentNode, isLiteralNode, createLiteral } from "@herb-tools/core"
+import { asMutable } from "@herb-tools/rewriter"
+
+import type { Node, ERBContentNode } from "@herb-tools/core"
+
+/**
+ * Commenting strategy for a line:
+ * - "single-erb": sole ERB tag on the line → insert # at column offset
+ * - "all-erb": multiple ERB tags with no significant HTML → # into each
+ * - "per-segment": control-flow ERB wrapping HTML → # each ERB, <!-- --> each HTML segment
+ * - "whole-line": output ERB mixed with HTML → wrap entire line in <!-- --> with ERB #
+ * - "html-only": pure HTML content → wrap in <!-- -->
+ */
+export type CommentStrategy = "single-erb" | "all-erb" | "per-segment" | "whole-line" | "html-only"
+
+interface LineSegment {
+  text: string
+  isERB: boolean
+  node?: ERBContentNode
+}
+
+export function commentERBNode(node: ERBContentNode): void {
+  const mutable = asMutable(node)
+
+  if (mutable.tag_opening) {
+    const currentValue = mutable.tag_opening.value
+
+    mutable.tag_opening = createSyntheticToken(
+      currentValue.substring(0, 2) + "#" + currentValue.substring(2),
+      mutable.tag_opening.type
+    )
+  }
+}
+
+export function uncommentERBNode(node: ERBContentNode): void {
+  const mutable = asMutable(node)
+
+  if (mutable.tag_opening && mutable.tag_opening.value === "<%#") {
+    const contentValue = mutable.content?.value || ""
+
+    if (
+      contentValue.startsWith(" graphql ") ||
+      contentValue.startsWith(" %= ") ||
+      contentValue.startsWith(" == ") ||
+      contentValue.startsWith(" % ") ||
+      contentValue.startsWith(" = ") ||
+      contentValue.startsWith(" - ")
+    ) {
+      mutable.tag_opening = createSyntheticToken("<%", mutable.tag_opening.type)
+      mutable.content = createSyntheticToken(contentValue.substring(1), mutable.content!.type)
+    } else {
+      mutable.tag_opening = createSyntheticToken("<%", mutable.tag_opening.type)
+    }
+  }
+}
+
+export function determineStrategy(erbNodes: ERBContentNode[], lineText: string): CommentStrategy {
+  if (erbNodes.length === 0) {
+    return "html-only"
+  }
+
+  if (erbNodes.length === 1) {
+    const node = erbNodes[0]
+    if (!node.tag_opening || !node.tag_closing) return "html-only"
+
+    const nodeStart = node.tag_opening.location.start.column
+    const nodeEnd = node.tag_closing.location.end.column
+    const isSoleContent = lineText.substring(0, nodeStart).trim() === "" && lineText.substring(nodeEnd).trim() === ""
+
+    if (isSoleContent) {
+      return "single-erb"
+    }
+
+    return "whole-line"
+  }
+
+  const segments = getLineSegments(lineText, erbNodes)
+  const hasHTML = segments.some(segment => !segment.isERB && segment.text.trim() !== "")
+
+  if (!hasHTML) {
+    return "all-erb"
+  }
+
+  const allControlTags = erbNodes.every(node => node.tag_opening?.value === "<%")
+
+  if (allControlTags) {
+    return "per-segment"
+  }
+
+  return "whole-line"
+}
+
+function getLineSegments(lineText: string, erbNodes: ERBContentNode[]): LineSegment[] {
+  const segments: LineSegment[] = []
+  const sorted = [...erbNodes].sort((a, b) => a.tag_opening!.location.start.column - b.tag_opening!.location.start.column)
+
+  let position = 0
+
+  for (const node of sorted) {
+    const nodeStart = node.tag_opening!.location.start.column
+    const nodeEnd = node.tag_closing!.location.end.column
+
+    if (nodeStart > position) {
+      segments.push({ text: lineText.substring(position, nodeStart), isERB: false })
+    }
+
+    segments.push({ text: lineText.substring(nodeStart, nodeEnd), isERB: true, node })
+    position = nodeEnd
+  }
+
+  if (position < lineText.length) {
+    segments.push({ text: lineText.substring(position), isERB: false })
+  }
+
+  return segments
+}
+
+/**
+ * Comment a line using AST mutation for strategies where the parser produces flat children,
+ * and text-segment manipulation for per-segment (where the parser nests nodes).
+ */
+export function commentLineContent(content: string, erbNodes: ERBContentNode[], strategy: CommentStrategy, parserService: ParserService): string {
+  if (strategy === "per-segment") {
+    return commentPerSegment(content, erbNodes)
+  }
+
+  const parseResult = parserService.parseContent(content, { track_whitespace: true })
+  const lineCollector = new LineContextCollector()
+  parseResult.visit(lineCollector)
+
+  const lineERBNodes = lineCollector.erbNodesPerLine.get(0) || []
+  const document = parseResult.value
+  const children = asMutable(document).children
+
+  switch (strategy) {
+    case "all-erb":
+      for (const node of lineERBNodes) {
+        commentERBNode(node)
+      }
+      break
+
+    case "whole-line": {
+      for (const node of lineERBNodes) {
+        commentERBNode(node)
+      }
+
+      const commentNode = new HTMLCommentNode({
+        type: "AST_HTML_COMMENT_NODE",
+        location: Location.zero,
+        errors: [],
+        comment_start: createSyntheticToken("<!--", "TOKEN_HTML_COMMENT_START"),
+        children: [createLiteral(" "), ...(children.slice() as Node[]), createLiteral(" ")],
+        comment_end: createSyntheticToken("-->", "TOKEN_HTML_COMMENT_END"),
+      })
+
+      children.length = 0
+      children.push(commentNode)
+      break
+    }
+
+    case "html-only": {
+      const commentNode = new HTMLCommentNode({
+        type: "AST_HTML_COMMENT_NODE",
+        location: Location.zero,
+        errors: [],
+        comment_start: createSyntheticToken("<!--", "TOKEN_HTML_COMMENT_START"),
+        children: [createLiteral(" "), ...(children.slice() as Node[]), createLiteral(" ")],
+        comment_end: createSyntheticToken("-->", "TOKEN_HTML_COMMENT_END"),
+      })
+
+      children.length = 0
+      children.push(commentNode)
+      break
+    }
+  }
+
+  return IdentityPrinter.print(document, { ignoreErrors: true })
+}
+
+/**
+ * Per-segment commenting uses text segments because the parser creates nested
+ * structures (e.g., ERBIfNode) that don't allow flat child iteration.
+ */
+function commentPerSegment(content: string, erbNodes: ERBContentNode[]): string {
+  const segments = getLineSegments(content, erbNodes)
+
+  return segments.map(segment => {
+    if (segment.isERB) {
+      return segment.text.substring(0, 2) + "#" + segment.text.substring(2)
+    } else if (segment.text.trim() !== "") {
+      return `<!-- ${segment.text} -->`
+    }
+
+    return segment.text
+  }).join("")
+}
+
+export function uncommentLineContent(content: string, parserService: ParserService): string {
+  const parseResult = parserService.parseContent(content, { track_whitespace: true })
+  const lineCollector = new LineContextCollector()
+
+  parseResult.visit(lineCollector)
+
+  const lineERBNodes = lineCollector.erbNodesPerLine.get(0) || []
+  const document = parseResult.value
+  const children = asMutable(document).children
+
+  for (const node of lineERBNodes) {
+    if (isERBCommentNode(node)) {
+      uncommentERBNode(node)
+    }
+  }
+
+  let index = 0
+
+  while (index < children.length) {
+    const child = children[index]
+
+    if (child.type === "AST_HTML_COMMENT_NODE") {
+      const commentNode = child as HTMLCommentNode
+      const innerChildren = [...commentNode.children]
+
+      if (innerChildren.length > 0) {
+        const first = innerChildren[0]
+
+        if (isLiteralNode(first) && first.content.startsWith(" ")) {
+          const trimmed = first.content.substring(1)
+
+          if (trimmed === "") {
+            innerChildren.shift()
+          } else {
+            innerChildren[0] = createLiteral(trimmed)
+          }
+        }
+      }
+
+      if (innerChildren.length > 0) {
+        const last = innerChildren[innerChildren.length - 1]
+
+        if (isLiteralNode(last) && last.content.endsWith(" ")) {
+          const trimmed = last.content.substring(0, last.content.length - 1)
+
+          if (trimmed === "") {
+            innerChildren.pop()
+          } else {
+            innerChildren[innerChildren.length - 1] = createLiteral(trimmed)
+          }
+        }
+      }
+
+      const innerERBNodes: ERBContentNode[] = []
+      const innerCollector = new LineContextCollector()
+
+      for (const innerChild of innerChildren) {
+        innerCollector.visit(innerChild)
+      }
+
+      innerERBNodes.push(...(innerCollector.erbNodesPerLine.get(0) || []))
+
+      for (const erbNode of innerERBNodes) {
+        if (isERBCommentNode(erbNode)) {
+          uncommentERBNode(erbNode)
+        }
+      }
+
+      children.splice(index, 1, ...innerChildren)
+      index += innerChildren.length
+
+      continue
+    }
+
+    index++
+  }
+
+  return IdentityPrinter.print(document, { ignoreErrors: true })
+}

package/src/comment_service.ts

@@ -0,0 +1,228 @@
+import { TextEdit, Range, Position } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
+import { ParserService } from "./parser_service"
+import { LineContextCollector } from "./line_context_collector"
+
+import { lspLine } from "./range_utils"
+import { determineStrategy, commentLineContent, uncommentLineContent } from "./comment_ast_utils"
+
+import type { LineInfo } from "./line_context_collector"
+import type { ERBContentNode, HTMLCommentNode } from "@herb-tools/core"
+
+export class CommentService {
+  private parserService: ParserService
+
+  constructor(parserService: ParserService) {
+    this.parserService = parserService
+  }
+
+  toggleLineComment(document: TextDocument, range: Range): TextEdit[] {
+    const parseResult = this.parserService.parseDocument(document)
+    const collector = new LineContextCollector()
+
+    collector.visit(parseResult.document)
+
+    const startLine = range.start.line
+    const endLine = range.end.line
+    const lineInfos: LineInfo[] = []
+
+    for (let line = startLine; line <= endLine; line++) {
+      const lineText = document.getText(Range.create(line, 0, line + 1, 0)).replace(/\n$/, "")
+
+      if (lineText.trim() === "") {
+        continue
+      }
+
+      if (this.lineIsIfFalseWrapped(lineText) !== null) {
+        lineInfos.push({ line, context: "erb-comment", node: null })
+        continue
+      }
+
+      const htmlCommentNode = collector.htmlCommentNodesPerLine.get(line)
+      const info = collector.lineMap.get(line)
+
+      if (htmlCommentNode && this.htmlCommentSpansLine(htmlCommentNode, lineText)) {
+        lineInfos.push({ line, context: "html-comment", node: htmlCommentNode })
+      } else if (info) {
+        if (info.context === "html-comment") {
+          lineInfos.push({ line, context: "html-content", node: null })
+        } else {
+          lineInfos.push(info)
+        }
+      } else {
+        lineInfos.push({ line, context: "html-content", node: null })
+      }
+    }
+
+    if (lineInfos.length === 0) return []
+
+    const allCommented = lineInfos.every(
+      info => info.context === "erb-comment" || info.context === "html-comment"
+    )
+
+    const edits: TextEdit[] = []
+
+    if (allCommented) {
+      for (const info of lineInfos) {
+        const lineText = document.getText(Range.create(info.line, 0, info.line + 1, 0)).replace(/\n$/, "")
+        const edit = this.uncommentLine(info, lineText, collector)
+
+        if (edit) edits.push(edit)
+      }
+    } else {
+      for (const info of lineInfos) {
+        if (info.context === "erb-comment" || info.context === "html-comment") continue
+
+        const lineText = document.getText(Range.create(info.line, 0, info.line + 1, 0)).replace(/\n$/, "")
+        const erbNodes = collector.erbNodesPerLine.get(info.line) || []
+        const edit = this.commentLine(info, lineText, erbNodes, collector)
+
+        if (edit) edits.push(edit)
+      }
+    }
+
+    return edits
+  }
+
+  toggleBlockComment(document: TextDocument, range: Range): TextEdit[] {
+    const startLine = range.start.line
+    const endLine = range.end.line
+
+    const firstLineText = document.getText(Range.create(startLine, 0, startLine + 1, 0)).replace(/\n$/, "")
+    const lastLineText = document.getText(Range.create(endLine, 0, endLine + 1, 0)).replace(/\n$/, "")
+    const isWrapped = firstLineText.trim() === "<% if false %>" && lastLineText.trim() === "<% end %>"
+
+    if (isWrapped) {
+      return [
+        TextEdit.del(Range.create(endLine, 0, endLine + 1, 0)),
+        TextEdit.del(Range.create(startLine, 0, startLine + 1, 0)),
+      ]
+    } else {
+      const firstLineIndent = this.getIndentation(firstLineText)
+
+      return [
+        TextEdit.insert(Position.create(endLine + 1, 0), `${firstLineIndent}<% end %>\n`),
+        TextEdit.insert(Position.create(startLine, 0), `${firstLineIndent}<% if false %>\n`),
+      ]
+    }
+  }
+
+  private commentLine(info: LineInfo, lineText: string, erbNodes: ERBContentNode[], collector: LineContextCollector): TextEdit | null {
+    const lineRange = Range.create(info.line, 0, info.line, lineText.length)
+    const indent = this.getIndentation(lineText)
+    const content = lineText.trimStart()
+    const htmlCommentNode = collector.htmlCommentNodesPerLine.get(info.line)
+
+    if (htmlCommentNode) {
+      return TextEdit.replace(lineRange, `${indent}<% if false %>${content}<% end %>`)
+    }
+
+    const strategy = determineStrategy(erbNodes, lineText)
+
+    if (strategy === "single-erb") {
+      const node = erbNodes[0]
+      const insertColumn = node.tag_opening!.location.start.column + 2
+
+      return TextEdit.insert(Position.create(info.line, insertColumn), "#")
+    }
+
+    const result = commentLineContent(content, erbNodes, strategy, this.parserService)
+
+    return TextEdit.replace(lineRange, indent + result)
+  }
+
+  private lineIsIfFalseWrapped(lineText: string): string | null {
+    const trimmed = lineText.trimStart()
+    const indent = this.getIndentation(lineText)
+
+    if (trimmed.startsWith("<% if false %>") && trimmed.endsWith("<% end %>")) {
+      const inner = trimmed.slice("<% if false %>".length, -"<% end %>".length)
+
+      return indent + inner
+    }
+
+    return null
+  }
+
+  private uncommentLine(info: LineInfo, lineText: string, collector: LineContextCollector): TextEdit | null {
+    const lineRange = Range.create(info.line, 0, info.line, lineText.length)
+    const indent = this.getIndentation(lineText)
+    const ifFalseContent = this.lineIsIfFalseWrapped(lineText)
+
+    if (ifFalseContent !== null) {
+      return TextEdit.replace(lineRange, ifFalseContent)
+    }
+
+    if (info.context === "erb-comment") {
+      const node = info.node as ERBContentNode
+      if (!node?.tag_opening || !node?.tag_closing) return null
+
+      const contentValue = (node as any).content?.value as string | null
+      const trimmedContent = contentValue?.trim() || ""
+
+      if (trimmedContent.startsWith("<") && !trimmedContent.startsWith("<%")) {
+        return TextEdit.replace(lineRange, `${indent}${trimmedContent}`)
+      }
+
+      if (lspLine(node.tag_opening.location.start) !== info.line) return null
+
+      const erbNodes = collector.erbNodesPerLine.get(info.line) || []
+
+      if (erbNodes.length > 1) {
+        const content = lineText.trimStart()
+        const result = uncommentLineContent(content, this.parserService)
+
+        return TextEdit.replace(lineRange, indent + result)
+      }
+
+      const hashColumn = node.tag_opening.location.start.column + 2
+
+      if (
+        contentValue?.startsWith(" graphql ") ||
+        contentValue?.startsWith(" %= ") ||
+        contentValue?.startsWith(" == ") ||
+        contentValue?.startsWith(" % ") ||
+        contentValue?.startsWith(" = ") ||
+        contentValue?.startsWith(" - ")
+      ) {
+        return TextEdit.del(Range.create(info.line, hashColumn, info.line, hashColumn + 2))
+      }
+
+      return TextEdit.del(Range.create(info.line, hashColumn, info.line, hashColumn + 1))
+    }
+
+    if (info.context === "html-comment") {
+      const commentNode = info.node as HTMLCommentNode | null
+
+      if (commentNode?.comment_start && commentNode?.comment_end) {
+        const contentStart = commentNode.comment_start.location.end.column
+        const contentEnd = commentNode.comment_end.location.start.column
+        const innerContent = lineText.substring(contentStart, contentEnd).trim()
+
+        const result = uncommentLineContent(innerContent, this.parserService)
+
+        return TextEdit.replace(lineRange, `${indent}${result}`)
+      }
+    }
+
+    return null
+  }
+
+  private htmlCommentSpansLine(node: HTMLCommentNode, lineText: string): boolean {
+    if (!node.comment_start || !node.comment_end) return false
+
+    const commentStart = node.comment_start.location.start.column
+    const commentEnd = node.comment_end.location.end.column
+    const contentBefore = lineText.substring(0, commentStart).trim()
+    const contentAfter = lineText.substring(commentEnd).trim()
+
+    return contentBefore === "" && contentAfter === ""
+  }
+
+  private getIndentation(lineText: string): string {
+    const match = lineText.match(/^(\s*)/)
+
+    return match ? match[1] : ""
+  }
+}