@herb-tools/language-server 0.8.10 → 0.9.1

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] : ""
+  }
+}

package/src/diagnostics.ts

@@ -1,26 +1,5 @@
 import { TextDocument } from "vscode-languageserver-textdocument"
-import { Connection, Diagnostic, DiagnosticSeverity, DiagnosticTag } from "vscode-languageserver/node"
-import { Visitor } from "@herb-tools/core"
-
-import type {
-  Node,
-  ERBCaseNode,
-  ERBCaseMatchNode,
-  ERBIfNode,
-  ERBElseNode,
-  ERBUnlessNode,
-  ERBForNode,
-  ERBWhileNode,
-  ERBUntilNode,
-  ERBWhenNode,
-  ERBBeginNode,
-  ERBRescueNode,
-  ERBEnsureNode,
-  ERBBlockNode,
-  ERBInNode,
-} from "@herb-tools/core"
-
-import { isHTMLTextNode } from "@herb-tools/core"
+import { Connection, Diagnostic } from "vscode-languageserver/node"
 
 import { ParserService } from "./parser_service"
 import { LinterService } from "./linter_service"
@@ -57,12 +36,10 @@ export class Diagnostics {
     } else {
       const parseResult = this.parserService.parseDocument(textDocument)
       const lintResult = await this.linterService.lintDocument(textDocument)
-      const unreachableCodeDiagnostics = this.getUnreachableCodeDiagnostics(parseResult.document)
 
       allDiagnostics = [
         ...parseResult.diagnostics,
         ...lintResult.diagnostics,
-        ...unreachableCodeDiagnostics,
       ]
     }
 
@@ -70,12 +47,6 @@ export class Diagnostics {
     this.sendDiagnosticsFor(textDocument)
   }
 
-  private getUnreachableCodeDiagnostics(document: Node): Diagnostic[] {
-    const collector = new UnreachableCodeCollector()
-    collector.visit(document)
-    return collector.diagnostics
-  }
-
   async refreshDocument(document: TextDocument) {
     await this.validate(document)
   }
@@ -96,278 +67,3 @@ export class Diagnostics {
     this.diagnostics.delete(textDocument)
   }
 }
-
-export class UnreachableCodeCollector extends Visitor {
-  diagnostics: Diagnostic[] = []
-  private processedIfNodes: Set<ERBIfNode> = new Set()
-  private processedElseNodes: Set<ERBElseNode> = new Set()
-
-  visitERBCaseNode(node: ERBCaseNode): void {
-    this.checkUnreachableChildren(node.children)
-    this.checkAndMarkElseClause(node.else_clause)
-    this.visitChildNodes(node)
-  }
-
-  visitERBCaseMatchNode(node: ERBCaseMatchNode): void {
-    this.checkUnreachableChildren(node.children)
-    this.checkAndMarkElseClause(node.else_clause)
-    this.visitChildNodes(node)
-  }
-
-  visitERBIfNode(node: ERBIfNode): void {
-    if (this.processedIfNodes.has(node)) {
-      return
-    }
-
-    this.markIfChainAsProcessed(node)
-
-    this.markElseNodesInIfChain(node)
-
-    const entireChainEmpty = this.isEntireIfChainEmpty(node)
-
-    if (entireChainEmpty) {
-      this.checkEmptyStatements(node, node.statements, "if")
-    } else {
-      this.checkIfChainParts(node)
-    }
-
-    this.visitChildNodes(node)
-  }
-
-  visitERBElseNode(node: ERBElseNode): void {
-    if (this.processedElseNodes.has(node)) {
-      this.visitChildNodes(node)
-      return
-    }
-
-    this.checkEmptyStatements(node, node.statements, "else")
-    this.visitChildNodes(node)
-  }
-
-  visitERBUnlessNode(node: ERBUnlessNode): void {
-    const unlessHasContent = this.statementsHaveContent(node.statements)
-    const elseHasContent = node.else_clause && this.statementsHaveContent(node.else_clause.statements)
-
-    if (node.else_clause) {
-      this.processedElseNodes.add(node.else_clause)
-    }
-
-    const entireBlockEmpty = !unlessHasContent && !elseHasContent
-
-    if (entireBlockEmpty) {
-      this.checkEmptyStatements(node, node.statements, "unless")
-    } else {
-      if (!unlessHasContent) {
-        this.checkEmptyStatementsWithEndLocation(node, node.statements, "unless", node.else_clause)
-      }
-
-      if (node.else_clause && !elseHasContent) {
-        this.checkEmptyStatements(node.else_clause, node.else_clause.statements, "else")
-      }
-    }
-
-    this.visitChildNodes(node)
-  }
-
-  visitERBForNode(node: ERBForNode): void {
-    this.checkEmptyStatements(node, node.statements, "for")
-    this.visitChildNodes(node)
-  }
-
-  visitERBWhileNode(node: ERBWhileNode): void {
-    this.checkEmptyStatements(node, node.statements, "while")
-    this.visitChildNodes(node)
-  }
-
-  visitERBUntilNode(node: ERBUntilNode): void {
-    this.checkEmptyStatements(node, node.statements, "until")
-    this.visitChildNodes(node)
-  }
-
-  visitERBWhenNode(node: ERBWhenNode): void {
-    if (!node.then_keyword) {
-      this.checkEmptyStatements(node, node.statements, "when")
-    }
-
-    this.visitChildNodes(node)
-  }
-
-  visitERBBeginNode(node: ERBBeginNode): void {
-    this.checkEmptyStatements(node, node.statements, "begin")
-    this.visitChildNodes(node)
-  }
-
-  visitERBRescueNode(node: ERBRescueNode): void {
-    this.checkEmptyStatements(node, node.statements, "rescue")
-    this.visitChildNodes(node)
-  }
-
-  visitERBEnsureNode(node: ERBEnsureNode): void {
-    this.checkEmptyStatements(node, node.statements, "ensure")
-    this.visitChildNodes(node)
-  }
-
-  visitERBBlockNode(node: ERBBlockNode): void {
-    this.checkEmptyStatements(node, node.body, "block")
-    this.visitChildNodes(node)
-  }
-
-  visitERBInNode(node: ERBInNode): void {
-    if (!node.then_keyword) {
-      this.checkEmptyStatements(node, node.statements, "in")
-    }
-
-    this.visitChildNodes(node)
-  }
-
-  private checkUnreachableChildren(children: Node[]): void {
-    for (const child of children) {
-      if (isHTMLTextNode(child) && child.content.trim() === "") {
-        continue
-      }
-
-      this.addDiagnostic(
-        child.location,
-        "Unreachable code: content between case and when/in is never executed"
-      )
-    }
-  }
-
-  private checkEmptyStatements(node: Node, statements: Node[], blockType: string): void {
-    this.checkEmptyStatementsWithEndLocation(node, statements, blockType, null)
-  }
-
-  private checkEmptyStatementsWithEndLocation(node: Node, statements: Node[], blockType: string, subsequentNode: Node | null): void {
-    if (this.statementsHaveContent(statements)) {
-      return
-    }
-
-    const startLocation = node.location.start
-    const endLocation = subsequentNode
-      ? subsequentNode.location.start
-      : node.location.end
-
-    this.addDiagnostic(
-      { start: startLocation, end: endLocation },
-      `Empty ${blockType} block: this control flow statement has no content`
-    )
-  }
-
-  private addDiagnostic(location: { start: { line: number; column: number }, end: { line: number; column: number } }, message: string): void {
-    const diagnostic: Diagnostic = {
-      range: {
-        start: {
-          line: this.toZeroBased(location.start.line),
-          character: location.start.column
-        },
-        end: {
-          line: this.toZeroBased(location.end.line),
-          character: location.end.column
-        }
-      },
-      message,
-      severity: DiagnosticSeverity.Hint,
-      tags: [DiagnosticTag.Unnecessary],
-      source: "Herb Language Server"
-    }
-
-    this.diagnostics.push(diagnostic)
-  }
-
-  private statementsHaveContent(statements: Node[]): boolean {
-    return statements.some(statement => {
-      if (isHTMLTextNode(statement)) {
-        return statement.content.trim() !== ""
-      }
-
-      return true
-    })
-  }
-
-  private checkAndMarkElseClause(elseClause: ERBElseNode | null): void {
-    if (!elseClause) {
-      return
-    }
-
-    this.processedElseNodes.add(elseClause)
-    if (!this.statementsHaveContent(elseClause.statements)) {
-      this.checkEmptyStatements(elseClause, elseClause.statements, "else")
-    }
-  }
-
-  private markIfChainAsProcessed(node: ERBIfNode): void {
-    this.processedIfNodes.add(node)
-    this.traverseSubsequentNodes(node.subsequent, (current) => {
-      if (current.type === 'AST_ERB_IF_NODE') {
-        this.processedIfNodes.add(current as ERBIfNode)
-      }
-    })
-  }
-
-  private markElseNodesInIfChain(node: ERBIfNode): void {
-    this.traverseSubsequentNodes(node.subsequent, (current) => {
-      if (current.type === 'AST_ERB_ELSE_NODE') {
-        this.processedElseNodes.add(current as ERBElseNode)
-      }
-    })
-  }
-
-  private traverseSubsequentNodes(startNode: Node | null, callback: (node: Node) => void): void {
-    let current = startNode
-    while (current) {
-      callback(current)
-
-      if ('subsequent' in current) {
-        current = (current as any).subsequent
-      } else {
-        break
-      }
-    }
-  }
-
-  private checkIfChainParts(node: ERBIfNode): void {
-    if (!this.statementsHaveContent(node.statements)) {
-      this.checkEmptyStatementsWithEndLocation(node, node.statements, "if", node.subsequent)
-    }
-
-    this.traverseSubsequentNodes(node.subsequent, (current) => {
-      if (!('statements' in current) || !Array.isArray((current as any).statements)) {
-        return
-      }
-
-      if (this.statementsHaveContent((current as any).statements)) {
-        return
-      }
-
-      const blockType = current.type === 'AST_ERB_IF_NODE' ? 'elsif' : 'else'
-      const nextSubsequent = 'subsequent' in current ? (current as any).subsequent : null
-
-      if (nextSubsequent) {
-        this.checkEmptyStatementsWithEndLocation(current, (current as any).statements, blockType, nextSubsequent)
-      } else {
-        this.checkEmptyStatements(current, (current as any).statements, blockType)
-      }
-    })
-  }
-
-  private isEntireIfChainEmpty(node: ERBIfNode): boolean {
-    if (this.statementsHaveContent(node.statements)) {
-      return false
-    }
-
-    let hasContent = false
-    this.traverseSubsequentNodes(node.subsequent, (current) => {
-      if ('statements' in current && Array.isArray((current as any).statements)) {
-        if (this.statementsHaveContent((current as any).statements)) {
-          hasContent = true
-        }
-      }
-    })
-
-    return !hasContent
-  }
-
-  private toZeroBased(line: number): number {
-    return line - 1
-  }
-}