@herb-tools/language-server 0.3.0 → 0.3.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@herb-tools/language-server",
-  "description": "Powerful and seamless HTML-aware ERB parsing and tooling.",
-  "version": "0.3.0",
+  "description": "Herb HTML+ERB Language Tools and Language Server Protocol integration.",
+  "version": "0.3.1",
   "author": "Marco Roth",
   "license": "MIT",
   "engines": {
@@ -13,24 +13,39 @@
     "url": "https://github.com/marcoroth/herb.git",
     "directory": "javascript/packages/language-server"
   },
+  "main": "./dist/herb-language-server.cjs",
+  "module": "./dist/server.js",
+  "types": "./dist/types/server.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/types/server.d.ts",
+      "import": "./dist/server.js",
+      "require": "./dist/herb-language-server.cjs",
+      "default": "./dist/server.js"
+    }
+  },
   "homepage": "https://herb-tools.dev",
   "bin": {
-    "herb-language-server": "./dist/herb-language-server"
+    "herb-language-server": "./bin/herb-language-server"
   },
   "scripts": {
     "clean": "rimraf dist",
     "prebuild": "yarn run clean",
     "build": "tsc -b && rollup -c rollup.config.mjs",
-    "postbuild": "node scripts/executable.mjs",
     "watch": "tsc -b -w",
-    "test": "echo 'TODO'",
+    "test": "echo 'TODO: add tests'",
     "prepublishOnly": "yarn clean && yarn build && yarn test"
   },
   "files": [
-    "dist"
+    "package.json",
+    "README.md",
+    "src/",
+    "bin/",
+    "dist/"
   ],
   "dependencies": {
-    "@herb-tools/node-wasm": "0.3.0",
+    "@herb-tools/node-wasm": "0.3.1",
     "dedent": "^1.6.0",
     "typescript": "^5.8.3",
     "vscode-languageserver": "^9.0.1",

package/src/config.ts

@@ -0,0 +1,101 @@
+export type HerbConfigOptions = {}
+
+export type HerbLSPConfig = {
+  version: string
+  createdAt: string
+  updatedAt: string
+  options: HerbConfigOptions
+}
+
+import path from "path"
+import { version } from "../package.json"
+import { promises as fs } from "fs"
+
+export class Config {
+  static configPath = ".herb-lsp/config.json"
+
+  public readonly path: string
+  public config: HerbLSPConfig
+
+  constructor(projectPath: string, config: HerbLSPConfig) {
+    this.path = Config.configPathFromProjectPath(projectPath)
+    this.config = config
+  }
+
+  get version(): string {
+    return this.config.version
+  }
+
+  get createdAt(): Date {
+    return new Date(this.config.createdAt)
+  }
+
+  get updatedAt(): Date {
+    return new Date(this.config.updatedAt)
+  }
+
+  get options(): HerbConfigOptions {
+    return this.config.options
+  }
+
+  public toJSON() {
+    return JSON.stringify(this.config, null, "  ")
+  }
+
+  private updateTimestamp() {
+    this.config.updatedAt = new Date().toISOString()
+  }
+
+  private updateVersion() {
+    this.config.version = version
+  }
+
+  async write() {
+    this.updateVersion()
+    this.updateTimestamp()
+
+    const folder = path.dirname(this.path)
+
+    fs.stat(folder)
+      .then(() => {})
+      .catch(async () => await fs.mkdir(folder))
+      .finally(async () => await fs.writeFile(this.path, this.toJSON()))
+  }
+
+  async read() {
+    return await fs.readFile(this.path, "utf8")
+  }
+
+  static configPathFromProjectPath(projectPath: string) {
+    return path.join(projectPath, this.configPath)
+  }
+
+  static async fromPathOrNew(projectPath: string) {
+    try {
+      return await this.fromPath(projectPath)
+    } catch (error: any) {
+      return Config.newConfig(projectPath)
+    }
+  }
+
+  static async fromPath(projectPath: string) {
+    const configPath = Config.configPathFromProjectPath(projectPath)
+
+    try {
+      const config = JSON.parse(await fs.readFile(configPath, "utf8"))
+
+      return new Config(projectPath, config)
+    } catch (error: any) {
+      throw new Error(`Error reading config file at: ${configPath}. Error: ${error.message}`)
+    }
+  }
+
+  static newConfig(projectPath: string): Config {
+    return new Config(projectPath, {
+      version,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      options: {}
+    })
+  }
+}

package/src/diagnostics.ts

@@ -0,0 +1,116 @@
+import { Connection, Diagnostic, DiagnosticSeverity, Range, Position } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+import { Herb, Visitor } from "@herb-tools/node-wasm"
+
+import { DocumentService } from "./document_service"
+
+import type { Node, HerbError } from "@herb-tools/node-wasm"
+
+class ErrorVisitor extends Visitor {
+  private diagnostics: Diagnostics
+  private textDocument: TextDocument
+
+  constructor(diagnostics: Diagnostics, textDocument: TextDocument) {
+    super()
+    this.diagnostics = diagnostics
+    this.textDocument = textDocument
+  }
+
+  visitChildNodes(node: Node) {
+    super.visitChildNodes(node)
+
+    node.errors.forEach(error => this.publishDiagnosticForError(error, node))
+  }
+
+  private publishDiagnosticForError(error: HerbError, node: Node): void {
+    this.diagnostics.pushDiagnostic(
+      error.message,
+      error.type,
+      this.rangeFromHerbError(error),
+      this.textDocument,
+      {
+        error: error.toJSON(),
+        node: node.toJSON()
+      },
+      DiagnosticSeverity.Error
+    )
+  }
+
+  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 class Diagnostics {
+  private readonly connection: Connection
+  private readonly documentService: DocumentService
+  private readonly diagnosticsSource = "Herb LSP "
+  private diagnostics: Map<TextDocument, Diagnostic[]> = new Map()
+
+  constructor(
+    connection: Connection,
+    documentService: DocumentService,
+  ) {
+    this.connection = connection
+    this.documentService = documentService
+  }
+
+  validate(textDocument: TextDocument) {
+    const content = textDocument.getText()
+    const result = Herb.parse(content)
+    const visitor = new ErrorVisitor(this, textDocument)
+
+    result.visit(visitor)
+
+    this.sendDiagnosticsFor(textDocument)
+  }
+
+  refreshDocument(document: TextDocument) {
+    this.validate(document)
+  }
+
+  refreshAllDocuments() {
+    this.documentService.getAll().forEach((document) => {
+      this.refreshDocument(document)
+    })
+  }
+
+  pushDiagnostic(
+    message: string,
+    code: string,
+    range: Range,
+    textDocument: TextDocument,
+    data = {},
+    severity: DiagnosticSeverity = DiagnosticSeverity.Error,
+  ) {
+    const diagnostic: Diagnostic = {
+      source: this.diagnosticsSource,
+      severity,
+      range,
+      message,
+      code,
+      data,
+    }
+
+    const diagnostics = this.diagnostics.get(textDocument) || []
+    diagnostics.push(diagnostic)
+
+    this.diagnostics.set(textDocument, diagnostics)
+
+    return diagnostic
+  }
+
+  private sendDiagnosticsFor(textDocument: TextDocument) {
+    const diagnostics = this.diagnostics.get(textDocument) || []
+
+    this.connection.sendDiagnostics({
+      uri: textDocument.uri,
+      diagnostics,
+    })
+
+    this.diagnostics.delete(textDocument)
+  }
+}

package/src/document_service.ts

@@ -0,0 +1,35 @@
+import { Connection, TextDocuments } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
+export class DocumentService {
+  public documents: TextDocuments<TextDocument>
+  document?: TextDocument
+
+  constructor(connection: Connection) {
+    this.documents = new TextDocuments(TextDocument)
+
+    // Make the text document manager listen on the connection
+    // for open, change and close text document events
+    this.documents.listen(connection)
+  }
+
+  get(uri: string) {
+    return this.documents.get(uri)
+  }
+
+  getAll() {
+    return this.documents.all()
+  }
+
+  get onDidChangeContent() {
+    return this.documents.onDidChangeContent
+  }
+
+  get onDidOpen() {
+    return this.documents.onDidOpen
+  }
+
+  get onDidClose() {
+    return this.documents.onDidClose
+  }
+}

package/src/project.ts

@@ -0,0 +1,20 @@
+import { Herb } from "@herb-tools/node-wasm"
+import { Connection } from "vscode-languageserver/node"
+
+export class Project {
+  connection: Connection
+  projectPath: string
+
+  constructor(connection: Connection, projectPath: string) {
+    this.projectPath = projectPath
+    this.connection = connection
+  }
+
+  async initialize() {
+    await Herb.load()
+  }
+
+  async refresh() {
+    // TODO
+  }
+}

package/src/server.ts

@@ -0,0 +1,93 @@
+import {
+  createConnection,
+  ProposedFeatures,
+  InitializeParams,
+  DidChangeConfigurationNotification,
+  DidChangeWatchedFilesNotification,
+  TextDocumentSyncKind,
+  InitializeResult,
+} from "vscode-languageserver/node"
+
+import { Service } from "./service"
+import { HerbSettings } from "./settings"
+
+let service: Service
+const connection = createConnection(ProposedFeatures.all)
+
+connection.onInitialize(async (params: InitializeParams) => {
+  service = new Service(connection, params)
+  await service.init()
+
+  const result: InitializeResult = {
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Incremental,
+    },
+  }
+
+  if (service.settings.hasWorkspaceFolderCapability) {
+    result.capabilities.workspace = {
+      workspaceFolders: {
+        supported: true,
+      },
+    }
+  }
+
+  return result
+})
+
+connection.onInitialized(() => {
+  if (service.settings.hasConfigurationCapability) {
+    // Register for all configuration changes.
+    connection.client.register(DidChangeConfigurationNotification.type, undefined)
+  }
+
+  if (service.settings.hasWorkspaceFolderCapability) {
+    connection.workspace.onDidChangeWorkspaceFolders((_event) => {
+      connection.console.log("Workspace folder change event received.")
+    })
+  }
+
+  connection.client.register(DidChangeWatchedFilesNotification.type, {
+    watchers: [
+      { globPattern: `**/**/*.html.erb` },
+      { globPattern: `**/**/.herb-lsp/config.json` },
+    ],
+  })
+})
+
+connection.onDidChangeConfiguration((change) => {
+  if (service.settings.hasConfigurationCapability) {
+    // Reset all cached document settings
+    service.settings.documentSettings.clear()
+  } else {
+    service.settings.globalSettings = (
+      (change.settings.languageServerHerb || service.settings.defaultSettings)
+    ) as HerbSettings
+  }
+
+  service.refresh()
+})
+
+connection.onDidOpenTextDocument((params) => {
+  console.error(params)
+  const document = service.documentService.get(params.textDocument.uri)
+
+  if (document) {
+    service.diagnostics.refreshDocument(document)
+  }
+})
+
+connection.onDidChangeWatchedFiles((params) => {
+  params.changes.forEach(async (event) => {
+    if (event.uri.endsWith("/.herb-lsp/config.json")) {
+      await service.refreshConfig()
+
+      service.documentService.getAll().forEach((document) => {
+        service.diagnostics.refreshDocument(document)
+      })
+    }
+  })
+})
+
+// Listen on the connection
+connection.listen()

package/src/service.ts

@@ -0,0 +1,51 @@
+import { Connection, InitializeParams } from "vscode-languageserver/node"
+
+import { Settings } from "./settings"
+import { DocumentService } from "./document_service"
+import { Diagnostics } from "./diagnostics"
+import { Config } from "./config"
+import { Project } from "./project"
+
+export class Service {
+  connection: Connection
+  settings: Settings
+  diagnostics: Diagnostics
+  documentService: DocumentService
+  project: Project
+  config?: Config
+
+  constructor(connection: Connection, params: InitializeParams) {
+    this.connection = connection
+    this.settings = new Settings(params, this.connection)
+    this.documentService = new DocumentService(this.connection)
+    this.project = new Project(connection, this.settings.projectPath.replace("file://", ""))
+    this.diagnostics = new Diagnostics(this.connection, this.documentService)
+  }
+
+  async init() {
+    await this.project.initialize()
+
+    this.config = await Config.fromPathOrNew(this.project.projectPath)
+
+    // Only keep settings for open documents
+    this.documentService.onDidClose((change) => {
+      this.settings.documentSettings.delete(change.document.uri)
+    })
+
+    // The content of a text document has changed. This event is emitted
+    // when the text document first opened or when its content has changed.
+    this.documentService.onDidChangeContent((change) => {
+      this.diagnostics.refreshDocument(change.document)
+    })
+  }
+
+  async refresh() {
+    await this.project.refresh()
+
+    this.diagnostics.refreshAllDocuments()
+  }
+
+  async refreshConfig() {
+    this.config = await Config.fromPathOrNew(this.project.projectPath)
+  }
+}

package/src/settings.ts

@@ -0,0 +1,63 @@
+import { ClientCapabilities, Connection, InitializeParams } from "vscode-languageserver/node"
+
+export interface HerbSettings {}
+
+export class Settings {
+  // The global settings, used when the `workspace/configuration` request is not supported by the client.
+  // Please note that this is not the case when using this server with the client provided in this example
+  // but could happen with other clients.
+  defaultSettings: HerbSettings = {}
+  globalSettings: HerbSettings = this.defaultSettings
+  documentSettings: Map<string, Thenable<HerbSettings>> = new Map()
+
+  hasConfigurationCapability = false
+  hasWorkspaceFolderCapability = false
+  hasDiagnosticRelatedInformationCapability = false
+
+  params: InitializeParams
+  capabilities: ClientCapabilities
+  connection: Connection
+
+  constructor(params: InitializeParams, connection: Connection) {
+    this.params = params
+    this.capabilities = params.capabilities
+    this.connection = connection
+
+    // Does the client support the `workspace/configuration` request?
+    // If not, we fall back using global settings.
+    this.hasConfigurationCapability = !!(this.capabilities.workspace && !!this.capabilities.workspace.configuration)
+
+    this.hasWorkspaceFolderCapability = !!(
+      this.capabilities.workspace && !!this.capabilities.workspace.workspaceFolders
+    )
+
+    this.hasDiagnosticRelatedInformationCapability = !!(
+      this.capabilities.textDocument &&
+      this.capabilities.textDocument.publishDiagnostics &&
+      this.capabilities.textDocument.publishDiagnostics.relatedInformation
+    )
+  }
+
+  get projectPath(): string {
+    return this.params.workspaceFolders?.at(0)?.uri || ""
+  }
+
+  getDocumentSettings(resource: string): Thenable<HerbSettings> {
+    if (!this.hasConfigurationCapability) {
+      return Promise.resolve(this.globalSettings)
+    }
+
+    let result = this.documentSettings.get(resource)
+
+    if (!result) {
+      result = this.connection.workspace.getConfiguration({
+        scopeUri: resource,
+        section: "languageServerHerb",
+      })
+
+      this.documentSettings.set(resource, result)
+    }
+
+    return result
+  }
+}

package/src/utils.ts

@@ -0,0 +1,11 @@
+export function camelize(value: string) {
+  return value.replace(/(?:[_-])([a-z0-9])/g, (_, char) => char.toUpperCase())
+}
+
+export function dasherize(value: string) {
+  return value.replace(/([A-Z])/g, (_, char) => `-${char.toLowerCase()}`)
+}
+
+export function capitalize(value: string) {
+  return value.charAt(0).toUpperCase() + value.slice(1)
+}