@herb-tools/language-server 0.8.10 → 0.9.0

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,6 +165,22 @@ 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)
 
@@ -172,8 +196,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)
     })
   }
 

package/src/service.ts

@@ -12,6 +12,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"
 
 import { version } from "../package.json"
 
@@ -30,6 +35,11 @@ export class Service {
   configService: ConfigService
   codeActionService: CodeActionService
   documentSaveService: DocumentSaveService
+  foldingRangeService: FoldingRangeService
+  documentHighlightService: DocumentHighlightService
+  hoverService: HoverService
+  rewriteCodeActionService: RewriteCodeActionService
+  commentService: CommentService
 
   constructor(connection: Connection, params: InitializeParams) {
     this.connection = connection
@@ -44,6 +54,11 @@ export class Service {
     this.codeActionService = new CodeActionService(this.project, this.config)
     this.diagnostics = new Diagnostics(this.connection, this.documentService, this.parserService, this.linterService, this.configService)
     this.documentSaveService = new DocumentSaveService(this.connection, this.settings, this.autofixService, this.formattingService)
+    this.foldingRangeService = new FoldingRangeService(this.parserService)
+    this.documentHighlightService = new DocumentHighlightService(this.parserService)
+    this.hoverService = new HoverService(this.parserService)
+    this.rewriteCodeActionService = new RewriteCodeActionService(this.parserService)
+    this.commentService = new CommentService(this.parserService)
 
     if (params.initializationOptions) {
       this.settings.globalSettings = params.initializationOptions as PersonalHerbSettings

package/src/utils.ts

@@ -1,11 +1,6 @@
 import { DiagnosticSeverity } from "vscode-languageserver/node"
 import type { LintSeverity } from "@herb-tools/linter"
 
-import { Position } from "vscode-languageserver/node"
-
-import type { Range } from "vscode-languageserver/node"
-import type { TextDocument } from "vscode-languageserver-textdocument"
-
 export function camelize(value: string) {
   return value.replace(/(?:[_-])([a-z0-9])/g, (_, char) => char.toUpperCase())
 }
@@ -26,20 +21,3 @@ export function lintToDignosticSeverity(severity: LintSeverity): DiagnosticSever
     case "hint": return DiagnosticSeverity.Hint
   }
 }
-
-/**
- * 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)
-  }
-}