@herb-tools/language-server 0.8.10 → 0.9.1

package/src/document_highlight_service.ts

@@ -0,0 +1,267 @@
+import { DocumentHighlight, DocumentHighlightKind, Range, Position } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
+import { Visitor } from "@herb-tools/core"
+import { ParserService } from "./parser_service"
+
+import { isERBIfNode, isERBElseNode, isHTMLOpenTagNode } from "@herb-tools/core"
+import { erbTagToRange, tokenToRange, nodeToRange, openTagRanges, isPositionInRange, rangeSize } from "./range_utils"
+
+import type {
+  Node,
+  ERBNode,
+  ERBContentNode,
+  HTMLElementNode,
+  HTMLConditionalElementNode,
+  HTMLAttributeNode,
+  HTMLCommentNode,
+  ERBIfNode,
+  ERBUnlessNode,
+  ERBCaseNode,
+  ERBCaseMatchNode,
+  ERBBeginNode,
+  ERBRescueNode,
+} from "@herb-tools/core"
+
+export class DocumentHighlightCollector extends Visitor {
+  public groups: Range[][] = []
+  private processedIfNodes: Set<ERBIfNode> = new Set()
+
+  visitERBNode(node: ERBNode): void {
+    if ('end_node' in node && node.end_node) {
+      this.addGroup([erbTagToRange(node), erbTagToRange(node.end_node)])
+    }
+  }
+
+  visitERBContentNode(node: ERBContentNode): void {
+    this.addGroup([tokenToRange(node.tag_opening), tokenToRange(node.tag_closing)])
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLCommentNode(node: HTMLCommentNode): void {
+    this.addGroup([tokenToRange(node.comment_start), tokenToRange(node.comment_end)])
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const ranges: (Range | null)[] = []
+
+    if (node.open_tag && isHTMLOpenTagNode(node.open_tag)) {
+      ranges.push(...openTagRanges(node.open_tag))
+    } else if (node.open_tag) {
+      ranges.push(nodeToRange(node.open_tag))
+    }
+
+    if (node.close_tag) {
+      ranges.push(nodeToRange(node.close_tag))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLAttributeNode(node: HTMLAttributeNode): void {
+    const ranges: (Range | null)[] = []
+
+    if (node.name) {
+      ranges.push(nodeToRange(node.name))
+    }
+
+    if (node.equals) {
+      ranges.push(tokenToRange(node.equals))
+    }
+
+    if (node.value) {
+      ranges.push(nodeToRange(node.value))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLConditionalElementNode(node: HTMLConditionalElementNode): void {
+    const ranges: (Range | null)[] = []
+
+    if (node.open_conditional) {
+      ranges.push(erbTagToRange(node.open_conditional))
+    }
+
+    if (node.open_tag) {
+      ranges.push(...openTagRanges(node.open_tag))
+    }
+
+    if (node.close_tag) {
+      ranges.push(nodeToRange(node.close_tag))
+    }
+
+    if (node.close_conditional) {
+      ranges.push(erbTagToRange(node.close_conditional))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitERBIfNode(node: ERBIfNode): void {
+    if (this.processedIfNodes.has(node)) {
+      this.visitChildNodes(node)
+      return
+    }
+
+    this.markIfChainAsProcessed(node)
+
+    const ranges: (Range | null)[] = []
+    ranges.push(erbTagToRange(node))
+
+    let current: Node | null = node.subsequent
+
+    while (current) {
+      if (isERBIfNode(current)) {
+        ranges.push(erbTagToRange(current))
+        current = current.subsequent
+      } else if (isERBElseNode(current)) {
+        ranges.push(erbTagToRange(current))
+        break
+      } else {
+        break
+      }
+    }
+
+    if (node.end_node) {
+      ranges.push(erbTagToRange(node.end_node))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitERBUnlessNode(node: ERBUnlessNode): void {
+    const ranges: (Range | null)[] = []
+    ranges.push(erbTagToRange(node))
+
+    if (node.else_clause) {
+      ranges.push(erbTagToRange(node.else_clause))
+    }
+
+    if (node.end_node) {
+      ranges.push(erbTagToRange(node.end_node))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitERBCaseNode(node: ERBCaseNode): void {
+    this.visitERBAnyCaseNode(node)
+  }
+
+  visitERBCaseMatchNode(node: ERBCaseMatchNode): void {
+    this.visitERBAnyCaseNode(node)
+  }
+
+  visitERBAnyCaseNode(node: ERBCaseNode | ERBCaseMatchNode): void {
+    const ranges: (Range | null)[] = []
+    ranges.push(erbTagToRange(node))
+
+    for (const condition of node.conditions) {
+      ranges.push(erbTagToRange(condition as ERBNode))
+    }
+
+    if (node.else_clause) {
+      ranges.push(erbTagToRange(node.else_clause))
+    }
+
+    if (node.end_node) {
+      ranges.push(erbTagToRange(node.end_node))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitERBBeginNode(node: ERBBeginNode): void {
+    const ranges: (Range | null)[] = []
+    ranges.push(erbTagToRange(node))
+
+    let rescue: ERBRescueNode | null = node.rescue_clause
+
+    while (rescue) {
+      ranges.push(erbTagToRange(rescue))
+      rescue = rescue.subsequent
+    }
+
+    if (node.else_clause) {
+      ranges.push(erbTagToRange(node.else_clause))
+    }
+
+    if (node.ensure_clause) {
+      ranges.push(erbTagToRange(node.ensure_clause))
+    }
+
+    if (node.end_node) {
+      ranges.push(erbTagToRange(node.end_node))
+    }
+
+    this.addGroup(ranges)
+    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 addGroup(ranges: (Range | null)[]): void {
+    const filtered = ranges.filter((r): r is Range => r !== null)
+    if (filtered.length >= 2) {
+      this.groups.push(filtered)
+    }
+  }
+}
+
+export class DocumentHighlightService {
+  private parserService: ParserService
+
+  constructor(parserService: ParserService) {
+    this.parserService = parserService
+  }
+
+  getDocumentHighlights(textDocument: TextDocument, position: Position): DocumentHighlight[] {
+    const parseResult = this.parserService.parseDocument(textDocument)
+    const collector = new DocumentHighlightCollector()
+    collector.visit(parseResult.document)
+
+    let bestGroup: Range[] | null = null
+    let bestSize = Infinity
+
+    for (const group of collector.groups) {
+      const matchingRange = group.find(range => isPositionInRange(position, range))
+
+      if (matchingRange) {
+        const size = rangeSize(matchingRange)
+
+        if (size < bestSize) {
+          bestSize = size
+          bestGroup = group
+        }
+      }
+    }
+
+    if (bestGroup) {
+      return bestGroup.map(range => DocumentHighlight.create(range, DocumentHighlightKind.Text))
+    }
+
+    return []
+  }
+
+}

package/src/document_save_service.ts

@@ -11,6 +11,15 @@ export class DocumentSaveService {
   private autofixService: AutofixService
   private formattingService: FormattingService
 
+  /**
+   * Tracks documents that were recently autofixed via applyFixesAndFormatting
+   * (triggered by onDocumentFormatting). When editor.formatOnSave is enabled,
+   * onDocumentFormatting fires BEFORE willSaveWaitUntil. If applyFixesAndFormatting
+   * already applied autofix, applyFixes must skip to avoid conflicting edits
+   * (since this.documents hasn't been updated between the two events).
+   */
+  private recentlyAutofixedViaFormatting = new Set<string>()
+
   constructor(connection: Connection, settings: Settings, autofixService: AutofixService, formattingService: FormattingService) {
     this.connection = connection
     this.settings = settings
@@ -30,6 +39,11 @@ export class DocumentSaveService {
 
     if (!fixOnSave) return []
 
+    if (this.recentlyAutofixedViaFormatting.delete(document.uri)) {
+      this.connection.console.log(`[DocumentSave] applyFixes skipping: already autofixed via formatting`)
+      return []
+    }
+
     return this.autofixService.autofix(document)
   }
 
@@ -48,6 +62,10 @@ export class DocumentSaveService {
 
     if (fixOnSave) {
       autofixEdits = await this.autofixService.autofix(document)
+
+      if (autofixEdits.length > 0) {
+        this.recentlyAutofixedViaFormatting.add(document.uri)
+      }
     }
 
     if (!formatterEnabled) return autofixEdits
@@ -56,12 +74,6 @@ export class DocumentSaveService {
       return this.formattingService.formatOnSave(document, reason)
     }
 
-    const autofixedDocument: TextDocument = {
-      ...document,
-      uri: document.uri,
-      getText: () => autofixEdits[0].newText,
-    }
-
-    return this.formattingService.formatOnSave(autofixedDocument, reason)
+    return this.formattingService.formatOnSave(document, reason, autofixEdits[0].newText)
   }
 }

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`)