@herb-tools/language-server 0.8.9 → 0.9.0

package/src/folding_range_service.ts

@@ -0,0 +1,287 @@
+import { FoldingRange, FoldingRangeKind } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
+import { Visitor } from "@herb-tools/core"
+import { ParserService } from "./parser_service"
+
+import { isERBIfNode } from "@herb-tools/core"
+import { lspLine } from "./range_utils"
+
+import type {
+  Node,
+  ERBNode,
+  ERBContentNode,
+  HTMLElementNode,
+  HTMLOpenTagNode,
+  HTMLAttributeValueNode,
+  HTMLCommentNode,
+  HTMLConditionalElementNode,
+  CDATANode,
+  ERBIfNode,
+  ERBUnlessNode,
+  ERBCaseNode,
+  ERBCaseMatchNode,
+  ERBBeginNode,
+  ERBRescueNode,
+  ERBEnsureNode,
+  ERBElseNode,
+  ERBWhenNode,
+  ERBInNode,
+  SerializedPosition,
+} from "@herb-tools/core"
+
+export class FoldingRangeService {
+  private parserService: ParserService
+
+  constructor(parserService: ParserService) {
+    this.parserService = parserService
+  }
+
+  getFoldingRanges(textDocument: TextDocument): FoldingRange[] {
+    const parseResult = this.parserService.parseDocument(textDocument)
+    const collector = new FoldingRangeCollector()
+
+    collector.visit(parseResult.document)
+
+    return collector.ranges
+  }
+}
+
+export class FoldingRangeCollector extends Visitor {
+  public ranges: FoldingRange[] = []
+  private processedIfNodes: Set<ERBIfNode> = new Set()
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    if (node.body.length > 0 && node.open_tag && node.close_tag) {
+      this.addRange(node.open_tag.location.end, node.close_tag.location.start)
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    if (node.children.length > 0 && node.tag_opening && node.tag_closing) {
+      this.addRange(node.tag_opening.location.end, node.tag_closing.location.start)
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLCommentNode(node: HTMLCommentNode): void {
+    if (node.comment_start && node.comment_end) {
+      this.addRange(node.comment_start.location.end, node.comment_end.location.start, FoldingRangeKind.Comment)
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLAttributeValueNode(node: HTMLAttributeValueNode): void {
+    if (node.children.length > 0) {
+      const first = node.children[0]
+      const last = node.children[node.children.length - 1]
+
+      this.addRange(first.location.start, last.location.end)
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitCDATANode(node: CDATANode): void {
+    this.addRange(node.location.start, node.location.end)
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLConditionalElementNode(node: HTMLConditionalElementNode): void {
+    this.addRange(node.location.start, node.location.end)
+    this.visitChildNodes(node)
+  }
+
+  visitERBNode(node: ERBNode): void {
+    if (node.tag_closing && 'end_node' in node && node.end_node?.tag_opening) {
+      this.addRange(node.tag_closing.location.end, node.end_node.tag_opening.location.start)
+    } else {
+      this.addRange(node.location.start, node.location.end)
+    }
+  }
+
+  visitERBContentNode(node: ERBContentNode): void {
+    if (node.tag_opening && node.tag_closing) {
+      this.addRange(node.tag_opening.location.end, node.tag_closing.location.start)
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitERBIfNode(node: ERBIfNode): void {
+    if (this.processedIfNodes.has(node)) {
+      this.visitChildNodes(node)
+      return
+    }
+
+    this.markIfChainAsProcessed(node)
+
+    const nextAfterIf = node.subsequent ?? node.end_node
+
+    if (node.tag_closing && nextAfterIf?.tag_opening) {
+      this.addRange(node.tag_closing.location.end, nextAfterIf.tag_opening.location.start)
+    }
+
+    let current: ERBIfNode | ERBElseNode | null = node.subsequent
+
+    while (current) {
+      if (isERBIfNode(current)) {
+        const nextAfterElsif = current.subsequent ?? node.end_node
+
+        if (current.tag_closing && nextAfterElsif?.tag_opening) {
+          this.addRange(current.tag_closing.location.end, nextAfterElsif.tag_opening.location.start)
+        }
+
+        current = current.subsequent
+      } else {
+        break
+      }
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitERBUnlessNode(node: ERBUnlessNode): void {
+    const nextAfterUnless = node.else_clause ?? node.end_node
+
+    if (node.tag_closing && nextAfterUnless?.tag_opening) {
+      this.addRange(node.tag_closing.location.end, nextAfterUnless.tag_opening.location.start)
+    }
+
+    if (node.else_clause) {
+      if (node.else_clause.tag_closing && node.end_node?.tag_opening) {
+        this.addRange(node.else_clause.tag_closing.location.end, node.end_node.tag_opening.location.start)
+      }
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitERBCaseNode(node: ERBCaseNode): void {
+    this.addCaseFoldingRanges(node)
+    this.visitChildNodes(node)
+  }
+
+  visitERBCaseMatchNode(node: ERBCaseMatchNode): void {
+    this.addCaseFoldingRanges(node)
+    this.visitChildNodes(node)
+  }
+
+  visitERBWhenNode(node: ERBWhenNode): void {
+    this.visitChildNodes(node)
+  }
+
+  visitERBInNode(node: ERBInNode): void {
+    this.visitChildNodes(node)
+  }
+
+  visitERBBeginNode(node: ERBBeginNode): void {
+    const nextAfterBegin = node.rescue_clause ?? node.else_clause ?? node.ensure_clause ?? node.end_node
+
+    if (node.tag_closing && nextAfterBegin?.tag_opening) {
+      this.addRange(node.tag_closing.location.end, nextAfterBegin.tag_opening.location.start)
+    }
+
+    let rescue: ERBRescueNode | null = node.rescue_clause
+
+    while (rescue) {
+      const nextAfterRescue = rescue.subsequent ?? node.else_clause ?? node.ensure_clause ?? node.end_node
+
+      if (rescue.tag_closing && nextAfterRescue?.tag_opening) {
+        this.addRange(rescue.tag_closing.location.end, nextAfterRescue.tag_opening.location.start)
+      }
+
+      rescue = rescue.subsequent
+    }
+
+    if (node.else_clause) {
+      const nextAfterElse = node.ensure_clause ?? node.end_node
+
+      if (node.else_clause.tag_closing && nextAfterElse?.tag_opening) {
+        this.addRange(node.else_clause.tag_closing.location.end, nextAfterElse.tag_opening.location.start)
+      }
+    }
+
+    if (node.ensure_clause) {
+      if (node.ensure_clause.tag_closing && node.end_node?.tag_opening) {
+        this.addRange(node.ensure_clause.tag_closing.location.end, node.end_node.tag_opening.location.start)
+      }
+    }
+
+    this.visitChildNodes(node)
+  }
+
+  visitERBRescueNode(node: ERBRescueNode): void {
+    this.visitChildNodes(node)
+  }
+
+  visitERBElseNode(node: ERBElseNode): void {
+    this.addRange(node.location.start, node.location.end)
+    this.visitChildNodes(node)
+  }
+
+  visitERBEnsureNode(node: ERBEnsureNode): void {
+    this.visitChildNodes(node)
+  }
+
+  private markIfChainAsProcessed(node: ERBIfNode): void {
+    this.processedIfNodes.add(node)
+
+    let current: Node | null = node.subsequent
+
+    while (current) {
+      if (isERBIfNode(current)) {
+        this.processedIfNodes.add(current)
+        current = current.subsequent
+      } else {
+        break
+      }
+    }
+  }
+
+  private addCaseFoldingRanges(node: ERBCaseNode | ERBCaseMatchNode): void {
+    type ConditionNode = ERBWhenNode | ERBInNode
+    const conditions = node.conditions as ConditionNode[]
+
+    const firstCondition = conditions[0]
+    const nextAfterCase = firstCondition ?? node.else_clause ?? node.end_node
+
+    if (node.tag_closing && nextAfterCase?.tag_opening) {
+      this.addRange(node.tag_closing.location.end, nextAfterCase.tag_opening.location.start)
+    }
+
+    for (let i = 0; i < conditions.length; i++) {
+      const condition = conditions[i]
+      const nextCondition = conditions[i + 1] ?? node.else_clause ?? node.end_node
+
+      if (condition.tag_closing && nextCondition?.tag_opening) {
+        this.addRange(condition.tag_closing.location.end, nextCondition.tag_opening.location.start)
+      }
+    }
+
+    if (node.else_clause) {
+      if (node.else_clause.tag_closing && node.end_node?.tag_opening) {
+        this.addRange(node.else_clause.tag_closing.location.end, node.end_node.tag_opening.location.start)
+      }
+    }
+  }
+
+  private addRange(start: SerializedPosition, end: SerializedPosition, kind?: FoldingRangeKind): void {
+    const startLine = lspLine(start)
+    const endLine = lspLine(end) - 1
+
+    if (endLine > startLine) {
+      this.ranges.push({
+        startLine,
+        startCharacter: start.column,
+        endLine,
+        endCharacter: end.column,
+        kind,
+      })
+    }
+  }
+}

package/src/formatting_service.ts

@@ -186,7 +186,7 @@ export class FormattingService {
     }
   }
 
-  async formatOnSave(document: TextDocument, reason: TextDocumentSaveReason): Promise<TextEdit[]> {
+  async formatOnSave(document: TextDocument, reason: TextDocumentSaveReason, textOverride?: string): Promise<TextEdit[]> {
     this.connection.console.log(`[Formatting] formatOnSave called for ${document.uri}`)
 
     if (reason !== TextDocumentSaveReason.Manual) {
@@ -203,7 +203,7 @@ export class FormattingService {
       return []
     }
 
-    return this.performFormatting({ textDocument: { uri: document.uri }, options: { tabSize: 2, insertSpaces: true } })
+    return this.performFormatting({ textDocument: { uri: document.uri }, options: { tabSize: 2, insertSpaces: true } }, textOverride)
   }
 
   private shouldFormatFile(filePath: string): boolean {
@@ -235,7 +235,7 @@ export class FormattingService {
     } as Config
   }
 
-  private async performFormatting(params: DocumentFormattingParams): Promise<TextEdit[]> {
+  private async performFormatting(params: DocumentFormattingParams, textOverride?: string): Promise<TextEdit[]> {
     const document = this.documents.get(params.textDocument.uri)
 
     if (!document) {
@@ -243,7 +243,7 @@ export class FormattingService {
     }
 
     try {
-      const text = document.getText()
+      const text = textOverride ?? document.getText()
       const config = await this.getConfigWithSettings(params.textDocument.uri)
 
       this.connection.console.log(`[Formatting] Creating formatter with ${this.preRewriters.length} pre-rewriters, ${this.postRewriters.length} post-rewriters`)
@@ -382,10 +382,6 @@ export class FormattingService {
         }).join('\n')
       }
 
-      if (!formattedText.endsWith('\n')) {
-        formattedText += '\n'
-      }
-
       if (formattedText === rangeText) {
         return []
       }

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,7 +1,7 @@
-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"
@@ -9,6 +9,7 @@ import { Config } from "@herb-tools/config"
 import { Settings } from "./settings"
 import { Project } from "./project"
 import { lintToDignosticSeverity } 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,16 +170,13 @@ 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 {

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)
+  }
 }