@herb-tools/language-server 0.8.10 → 0.9.1

package/src/hover_service.ts

@@ -0,0 +1,90 @@
+import { Hover, MarkupKind, Position } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
+import { Visitor } from "@herb-tools/node-wasm"
+import { IdentityPrinter } from "@herb-tools/printer"
+import { ActionViewTagHelperToHTMLRewriter } from "@herb-tools/rewriter"
+import { isERBOpenTagNode } from "@herb-tools/core"
+import { ParserService } from "./parser_service"
+import { nodeToRange, isPositionInRange, rangeSize } from "./range_utils"
+import { ACTION_VIEW_HELPERS } from "./action_view_helpers"
+
+import type { Node, HTMLElementNode } from "@herb-tools/core"
+import type { Range } from "vscode-languageserver/node"
+
+class ActionViewElementCollector extends Visitor {
+  public elements: { node: HTMLElementNode; range: Range }[] = []
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    if (node.element_source && node.element_source !== "HTML" && isERBOpenTagNode(node.open_tag)) {
+      this.elements.push({
+        node,
+        range: nodeToRange(node),
+      })
+    }
+
+    this.visitChildNodes(node)
+  }
+}
+
+export class HoverService {
+  private parserService: ParserService
+
+  constructor(parserService: ParserService) {
+    this.parserService = parserService
+  }
+
+  getHover(textDocument: TextDocument, position: Position): Hover | null {
+    const parseResult = this.parserService.parseContent(textDocument.getText(), {
+      action_view_helpers: true,
+      track_whitespace: true,
+    })
+
+    const collector = new ActionViewElementCollector()
+    collector.visit(parseResult.value)
+
+    let bestElement: { node: HTMLElementNode; range: Range } | null = null
+    let bestSize = Infinity
+
+    for (const element of collector.elements) {
+      if (isPositionInRange(position, element.range)) {
+        const size = rangeSize(element.range)
+
+        if (size < bestSize) {
+          bestSize = size
+          bestElement = element
+        }
+      }
+    }
+
+    if (!bestElement) {
+      return null
+    }
+
+    const elementSource = bestElement.node.element_source
+    const rewriter = new ActionViewTagHelperToHTMLRewriter()
+    const rewrittenNode = rewriter.rewrite(bestElement.node as Node, { baseDir: process.cwd() })
+    const htmlOutput = IdentityPrinter.print(rewrittenNode)
+    const helper = ACTION_VIEW_HELPERS[elementSource]
+    const parts: string[] = []
+
+    if (helper) {
+      parts.push(`\`\`\`ruby\n${helper.signature}\n\`\`\``)
+    }
+
+    parts.push(`**HTML equivalent**\n\`\`\`erb\n${htmlOutput.trim()}\n\`\`\``)
+
+    if (helper) {
+      parts.push(`[${elementSource}](${helper.documentationURL})`)
+    }
+
+    return {
+      contents: {
+        kind: MarkupKind.Markdown,
+        value: parts.join("\n\n"),
+      },
+      range: bestElement.range,
+    }
+  }
+
+}

package/src/index.ts

@@ -3,7 +3,11 @@ export * from "./service"
 export * from "./diagnostics"
 export * from "./document_service"
 export * from "./formatting_service"
+export * from "./folding_range_service"
 export * from "./project"
 export * from "./settings"
 export * from "./utils"
+export * from "./range_utils"
 export * from "./cli"
+export * from "./document_highlight_service"
+export * from "./comment_service"

package/src/line_context_collector.ts

@@ -0,0 +1,97 @@
+import { Visitor, HTMLCommentNode, } from "@herb-tools/core"
+
+import { lspLine } from "./range_utils"
+import { isERBCommentNode } from "@herb-tools/core"
+
+import type { Node, ERBNode, ERBContentNode, HTMLTextNode, HTMLElementNode } from "@herb-tools/core"
+
+export type LineContext = "erb-comment" | "html-comment" | "erb-tag" | "html-content" | "empty"
+
+export interface LineInfo {
+  line: number
+  context: LineContext
+  node: Node | null
+}
+
+export class LineContextCollector extends Visitor {
+  public lineMap: Map<number, LineInfo> = new Map()
+  public erbNodesPerLine: Map<number, ERBContentNode[]> = new Map()
+  public htmlCommentNodesPerLine: Map<number, HTMLCommentNode> = new Map()
+
+  visitERBNode(node: ERBNode): void {
+    if (!node.tag_opening || !node.tag_closing) return
+
+    const startLine = lspLine(node.tag_opening.location.start)
+
+    const nodes = this.erbNodesPerLine.get(startLine) || []
+    nodes.push(node as ERBContentNode)
+    this.erbNodesPerLine.set(startLine, nodes)
+
+    if (isERBCommentNode(node)) {
+      this.setLine(startLine, "erb-comment", node)
+    } else {
+      this.setLine(startLine, "erb-tag", node)
+    }
+  }
+
+  visitERBContentNode(node: ERBContentNode): void {
+    this.visitERBNode(node)
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLCommentNode(node: HTMLCommentNode): void {
+    const startLine = lspLine(node.location.start)
+    const endLine = lspLine(node.location.end)
+
+    for (let line = startLine; line <= endLine; line++) {
+      this.htmlCommentNodesPerLine.set(line, node)
+      this.setLine(line, "html-comment", node)
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const startLine = lspLine(node.location.start)
+    const endLine = lspLine(node.location.end)
+
+    for (let line = startLine; line <= endLine; line++) {
+      if (!this.lineMap.has(line)) {
+        this.setLine(line, "html-content", node)
+      }
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLTextNode(node: HTMLTextNode): void {
+    const startLine = lspLine(node.location.start)
+    const endLine = lspLine(node.location.end)
+
+    for (let line = startLine; line <= endLine; line++) {
+      if (!this.lineMap.has(line)) {
+        this.setLine(line, "html-content", node)
+      }
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  private setLine(line: number, context: LineContext, node: Node): void {
+    const existing = this.lineMap.get(line)
+
+    if (existing) {
+      if (existing.context === "erb-comment" || existing.context === "erb-tag") return
+
+      if (context === "erb-comment" || context === "erb-tag") {
+        this.lineMap.set(line, { line, context, node })
+
+        return
+      }
+
+      if (existing.context === "html-comment") return
+    }
+
+    this.lineMap.set(line, { line, context, node })
+  }
+}

package/src/linter_service.ts

@@ -1,14 +1,15 @@
-import { Diagnostic, Range, Position, CodeDescription, Connection } from "vscode-languageserver/node"
+import { Diagnostic, CodeDescription, Connection } from "vscode-languageserver/node"
 import { TextDocument } from "vscode-languageserver-textdocument"
 
-import { Linter, rules, type RuleClass } from "@herb-tools/linter"
+import { Linter, rules, ruleDocumentationUrl, type RuleClass } from "@herb-tools/linter"
 import { loadCustomRules as loadCustomRulesFromFs } from "@herb-tools/linter/loader"
 import { Herb } from "@herb-tools/node-wasm"
 import { Config } from "@herb-tools/config"
 
 import { Settings } from "./settings"
 import { Project } from "./project"
-import { lintToDignosticSeverity } from "./utils"
+import { lintToDignosticSeverity, lintToDignosticTags } from "./utils"
+import { lspRangeFromLocation } from "./range_utils"
 
 const OPEN_CONFIG_ACTION = 'Open .herb.yml'
 
@@ -113,7 +114,27 @@ export class LinterService {
     }
   }
 
+  private shouldLintFile(uri: string): boolean {
+    const filePath = uri.replace(/^file:\/\//, '')
+
+    if (filePath.endsWith('.herb.yml')) return false
+
+    const config = this.settings.projectConfig
+    if (!config) return true
+
+    const hasConfigFile = Config.exists(config.projectPath)
+    if (!hasConfigFile) return true
+
+    const relativePath = filePath.replace(this.project.projectPath + '/', '')
+
+    return config.isLinterEnabledForPath(relativePath)
+  }
+
   async lintDocument(textDocument: TextDocument): Promise<LintServiceResult> {
+    if (!this.shouldLintFile(textDocument.uri)) {
+      return { diagnostics: [] }
+    }
+
     const settings = await this.settings.getDocumentSettings(textDocument.uri)
     const linterEnabled = settings?.linter?.enabled ?? true
 
@@ -149,19 +170,16 @@ export class LinterService {
     const lintResult = this.linter.lint(content, { fileName: textDocument.uri })
 
     const diagnostics: Diagnostic[] = lintResult.offenses.map(offense => {
-      const range = Range.create(
-        Position.create(offense.location.start.line - 1, offense.location.start.column),
-        Position.create(offense.location.end.line - 1, offense.location.end.column),
-      )
+      const range = lspRangeFromLocation(offense.location)
 
       const customRulePath = this.customRulePaths.get(offense.rule)
       const codeDescription: CodeDescription = {
         href: customRulePath
           ? `file://${customRulePath}`
-          : `https://herb-tools.dev/linter/rules/${offense.rule}`
+          : ruleDocumentationUrl(offense.rule)
       }
 
-      return {
+      const diagnostic: Diagnostic = {
         source: this.source,
         severity: lintToDignosticSeverity(offense.severity),
         range,
@@ -170,6 +188,14 @@ export class LinterService {
         data: { rule: offense.rule },
         codeDescription
       }
+
+      const tags = lintToDignosticTags(offense.tags)
+
+      if (tags.length > 0) {
+        diagnostic.tags = tags
+      }
+
+      return diagnostic
     })
 
     return { diagnostics }

package/src/parser_service.ts

@@ -1,8 +1,10 @@
-import { Diagnostic, DiagnosticSeverity, Range, Position } from "vscode-languageserver/node"
+import { Diagnostic, DiagnosticSeverity } from "vscode-languageserver/node"
 import { TextDocument } from "vscode-languageserver-textdocument"
 import { Herb, Visitor } from "@herb-tools/node-wasm"
 
-import type { Node, HerbError, DocumentNode } from "@herb-tools/node-wasm"
+import type { Node, HerbError, DocumentNode, ParseResult, ParseOptions } from "@herb-tools/node-wasm"
+
+import { lspRangeFromLocation } from "./range_utils"
 
 class ErrorVisitor extends Visitor {
   private readonly source = "Herb Parser "
@@ -18,7 +20,7 @@ class ErrorVisitor extends Visitor {
     const diagnostic: Diagnostic = {
       source: this.source,
       severity: DiagnosticSeverity.Error,
-      range: this.rangeFromHerbError(error),
+      range: lspRangeFromLocation(error.location),
       message: error.message,
       code: error.type,
       data: {
@@ -29,13 +31,6 @@ class ErrorVisitor extends Visitor {
 
     this.diagnostics.push(diagnostic)
   }
-
-  private rangeFromHerbError(error: HerbError): Range {
-    return Range.create(
-      Position.create(error.location.start.line - 1, error.location.start.column),
-      Position.create(error.location.end.line - 1, error.location.end.column),
-    )
-  }
 }
 
 export interface ParseServiceResult {
@@ -56,4 +51,8 @@ export class ParserService {
       diagnostics: errorVisitor.diagnostics
     }
   }
+
+  parseContent(content: string, options?: ParseOptions): ParseResult {
+    return Herb.parse(content, options)
+  }
 }

package/src/range_utils.ts

@@ -0,0 +1,90 @@
+import { Position, Range } from "vscode-languageserver/node"
+import type { TextDocument } from "vscode-languageserver-textdocument"
+import type { SerializedPosition, SerializedLocation, Node, Token, ERBNode, HTMLOpenTagNode } from "@herb-tools/core"
+
+export function lspPosition(herbPosition: SerializedPosition): Position {
+  return Position.create(herbPosition.line - 1, herbPosition.column)
+}
+
+export function lspLine(herbPosition: SerializedPosition): number {
+  return herbPosition.line - 1
+}
+
+export function lspRangeFromLocation(herbLocation: SerializedLocation): Range {
+  return Range.create(lspPosition(herbLocation.start), lspPosition(herbLocation.end))
+}
+
+export function erbTagToRange(node: ERBNode): Range | null {
+  if (!node.tag_opening || !node.tag_closing) return null
+
+  return Range.create(
+    lspPosition(node.tag_opening.location.start),
+    lspPosition(node.tag_closing.location.end),
+  )
+}
+
+export function tokenToRange(token: Token | null): Range | null {
+  if (!token) return null
+
+  return lspRangeFromLocation(token.location)
+}
+
+export function nodeToRange(node: Node): Range {
+  return lspRangeFromLocation(node.location)
+}
+
+export function openTagRanges(tag: HTMLOpenTagNode): (Range | null)[] {
+  const ranges: (Range | null)[] = []
+
+  if (tag.tag_opening && tag.tag_name) {
+    ranges.push(Range.create(
+      lspPosition(tag.tag_opening.location.start),
+      lspPosition(tag.tag_name.location.end),
+    ))
+  }
+
+  ranges.push(tokenToRange(tag.tag_closing))
+
+  return ranges
+}
+
+export function isPositionInRange(position: Position, range: Range): boolean {
+  if (position.line < range.start.line || position.line > range.end.line) {
+    return false
+  }
+
+  if (position.line === range.start.line && position.character < range.start.character) {
+    return false
+  }
+
+  if (position.line === range.end.line && position.character > range.end.character) {
+    return false
+  }
+
+  return true
+}
+
+export function rangeSize(range: Range): number {
+  if (range.start.line === range.end.line) {
+    return range.end.character - range.start.character
+  }
+
+  return (range.end.line - range.start.line) * 10000 + range.end.character
+}
+
+/**
+ * Returns a Range that spans the entire document
+ */
+export function getFullDocumentRange(document: TextDocument): Range {
+  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)
+  }
+}

package/src/rewrite_code_action_service.ts

@@ -0,0 +1,165 @@
+import { CodeAction, CodeActionKind, TextEdit, WorkspaceEdit, Range } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
+import { Visitor, Herb } from "@herb-tools/node-wasm"
+import { IdentityPrinter } from "@herb-tools/printer"
+import { ActionViewTagHelperToHTMLRewriter, HTMLToActionViewTagHelperRewriter } from "@herb-tools/rewriter"
+import { isERBOpenTagNode, isHTMLOpenTagNode } from "@herb-tools/core"
+import { ParserService } from "./parser_service"
+import { nodeToRange } from "./range_utils"
+
+import type { Node, HTMLElementNode } from "@herb-tools/core"
+
+interface CollectedElement {
+  node: HTMLElementNode
+  range: Range
+}
+
+class ElementCollector extends Visitor {
+  public actionViewElements: CollectedElement[] = []
+  public htmlElements: CollectedElement[] = []
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    if (node.element_source && node.element_source !== "HTML" && isERBOpenTagNode(node.open_tag)) {
+      this.actionViewElements.push({
+        node,
+        range: nodeToRange(node),
+      })
+    } else if (isHTMLOpenTagNode(node.open_tag) && node.open_tag.tag_name) {
+      this.htmlElements.push({
+        node,
+        range: nodeToRange(node),
+      })
+    }
+
+    this.visitChildNodes(node)
+  }
+}
+
+export class RewriteCodeActionService {
+  private parserService: ParserService
+
+  constructor(parserService: ParserService) {
+    this.parserService = parserService
+  }
+
+  getCodeActions(document: TextDocument, requestedRange: Range): CodeAction[] {
+    const parseResult = this.parserService.parseContent(document.getText(), {
+      action_view_helpers: true,
+      track_whitespace: true,
+    })
+
+    const collector = new ElementCollector()
+    collector.visit(parseResult.value)
+
+    const actions: CodeAction[] = []
+
+    for (const element of collector.actionViewElements) {
+      if (!this.rangesOverlap(element.range, requestedRange)) continue
+
+      const action = this.createActionViewToHTMLAction(document, element)
+
+      if (action) {
+        actions.push(action)
+      }
+    }
+
+    for (const element of collector.htmlElements) {
+      if (!this.rangesOverlap(element.range, requestedRange)) continue
+
+      const action = this.createHTMLToActionViewAction(document, element)
+
+      if (action) {
+        actions.push(action)
+      }
+    }
+
+    return actions
+  }
+
+  private createActionViewToHTMLAction(document: TextDocument, element: CollectedElement): CodeAction | null {
+    const originalText = document.getText(element.range)
+
+    const parseResult = this.parserService.parseContent(originalText, {
+      action_view_helpers: true,
+      track_whitespace: true,
+    })
+
+    if (parseResult.failed) return null
+
+    const rewriter = new ActionViewTagHelperToHTMLRewriter()
+    rewriter.rewrite(parseResult.value as Node, { baseDir: process.cwd() })
+
+    const rewrittenText = IdentityPrinter.print(parseResult.value)
+
+    if (rewrittenText === originalText) return null
+
+    const edit: WorkspaceEdit = {
+      changes: {
+        [document.uri]: [TextEdit.replace(element.range, rewrittenText)]
+      }
+    }
+
+    const tagName = element.node.tag_name?.value
+    const title = tagName
+      ? `Herb: Convert to \`<${tagName}>\``
+      : "Herb: Convert to HTML"
+
+    return {
+      title,
+      kind: CodeActionKind.RefactorRewrite,
+      edit,
+    }
+  }
+
+  private createHTMLToActionViewAction(document: TextDocument, element: CollectedElement): CodeAction | null {
+    const originalText = document.getText(element.range)
+
+    const parseResult = this.parserService.parseContent(originalText, {
+      track_whitespace: true,
+    })
+
+    if (parseResult.failed) return null
+
+    const rewriter = new HTMLToActionViewTagHelperRewriter()
+    rewriter.rewrite(parseResult.value as Node, { baseDir: process.cwd() })
+
+    const rewrittenText = IdentityPrinter.print(parseResult.value)
+
+    if (rewrittenText === originalText) return null
+
+    const edit: WorkspaceEdit = {
+      changes: {
+        [document.uri]: [TextEdit.replace(element.range, rewrittenText)]
+      }
+    }
+
+    const tagName = element.node.tag_name?.value
+    const isAnchor = tagName === "a"
+    const isTurboFrame = tagName === "turbo-frame"
+    const methodName = tagName?.replace(/-/g, "_")
+    const title = isAnchor
+      ? "Herb: Convert to `link_to`"
+      : isTurboFrame
+        ? "Herb: Convert to `turbo_frame_tag`"
+        : methodName
+          ? `Herb: Convert to \`tag.${methodName}\``
+          : "Herb: Convert to tag helper"
+
+    return {
+      title,
+      kind: CodeActionKind.RefactorRewrite,
+      edit,
+    }
+  }
+
+  private rangesOverlap(r1: Range, r2: Range): boolean {
+    if (r1.end.line < r2.start.line) return false
+    if (r1.start.line > r2.end.line) return false
+
+    if (r1.end.line === r2.start.line && r1.end.character < r2.start.character) return false
+    if (r1.start.line === r2.end.line && r1.start.character > r2.end.character) return false
+
+    return true
+  }
+}

package/src/server.ts

@@ -12,6 +12,11 @@ import {
   DocumentRangeFormattingParams,
   CodeActionParams,
   CodeActionKind,
+  FoldingRangeParams,
+  DocumentHighlightParams,
+  HoverParams,
+  TextDocumentIdentifier,
+  Range,
 } from "vscode-languageserver/node"
 
 import { Service } from "./service"
@@ -51,8 +56,11 @@ export class Server {
           documentFormattingProvider: true,
           documentRangeFormattingProvider: true,
           codeActionProvider: {
-            codeActionKinds: [CodeActionKind.QuickFix, CodeActionKind.SourceFixAll]
+            codeActionKinds: [CodeActionKind.QuickFix, CodeActionKind.SourceFixAll, CodeActionKind.RefactorRewrite]
           },
+          foldingRangeProvider: true,
+          documentHighlightProvider: true,
+          hoverProvider: true,
         },
       }
 
@@ -157,11 +165,30 @@ export class Server {
       return this.service.formattingService.formatRange(params)
     })
 
+    this.connection.onDocumentHighlight((params: DocumentHighlightParams) => {
+      const document = this.service.documentService.get(params.textDocument.uri)
+
+      if (!document) return []
+
+      return this.service.documentHighlightService.getDocumentHighlights(document, params.position)
+    })
+
+    this.connection.onHover((params: HoverParams) => {
+      const document = this.service.documentService.get(params.textDocument.uri)
+
+      if (!document) return null
+
+      return this.service.hoverService.getHover(document, params.position)
+    })
+
     this.connection.onCodeAction((params: CodeActionParams) => {
       const document = this.service.documentService.get(params.textDocument.uri)
 
       if (!document) return []
 
+      const parseResult = this.service.parserService.parseDocument(document)
+      if (parseResult.diagnostics.length > 0) return []
+
       const diagnostics = params.context.diagnostics
       const documentText = document.getText()
 
@@ -172,8 +199,33 @@ export class Server {
       )
 
       const autofixCodeActions = this.service.codeActionService.autofixCodeActions(params, document)
+      const rewriteCodeActions = this.service.rewriteCodeActionService.getCodeActions(document, params.range)
+
+      return autofixCodeActions.concat(linterDisableCodeActions).concat(rewriteCodeActions)
+    })
+
+    this.connection.onFoldingRanges((params: FoldingRangeParams) => {
+      const document = this.service.documentService.get(params.textDocument.uri)
+
+      if (!document) return []
+
+      return this.service.foldingRangeService.getFoldingRanges(document)
+    })
+
+    this.connection.onRequest('herb/toggleLineComment', (params: { textDocument: TextDocumentIdentifier, range: Range }) => {
+      const document = this.service.documentService.get(params.textDocument.uri)
+
+      if (!document) return []
+
+      return this.service.commentService.toggleLineComment(document, params.range)
+    })
+
+    this.connection.onRequest('herb/toggleBlockComment', (params: { textDocument: TextDocumentIdentifier, range: Range }) => {
+      const document = this.service.documentService.get(params.textDocument.uri)
+
+      if (!document) return []
 
-      return autofixCodeActions.concat(linterDisableCodeActions)
+      return this.service.commentService.toggleBlockComment(document, params.range)
     })
   }