@herb-tools/language-server 0.3.0 → 0.4.0

package/src/server.ts

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

package/src/service.ts

@@ -0,0 +1,66 @@
+import { Connection, InitializeParams } from "vscode-languageserver/node"
+
+import { Settings, HerbSettings } from "./settings"
+import { DocumentService } from "./document_service"
+import { Diagnostics } from "./diagnostics"
+import { ParserService } from "./parser_service"
+import { LinterService } from "./linter_service"
+import { Config } from "./config"
+import { Project } from "./project"
+import { FormattingService } from "./formatting_service"
+
+export class Service {
+  connection: Connection
+  settings: Settings
+  diagnostics: Diagnostics
+  documentService: DocumentService
+  parserService: ParserService
+  linterService: LinterService
+  project: Project
+  config?: Config
+  formatting: FormattingService
+
+  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.parserService = new ParserService()
+    this.linterService = new LinterService(this.settings)
+    this.formatting = new FormattingService(this.connection, this.documentService.documents, this.project, this.settings)
+    this.diagnostics = new Diagnostics(this.connection, this.documentService, this.parserService, this.linterService)
+
+    // Initialize global settings from initialization options
+    if (params.initializationOptions) {
+      this.settings.globalSettings = params.initializationOptions as HerbSettings
+    }
+  }
+
+  async init() {
+    await this.project.initialize()
+    await this.formatting.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(async (change) => {
+      await this.diagnostics.refreshDocument(change.document)
+    })
+  }
+
+  async refresh() {
+    await this.project.refresh()
+    await this.diagnostics.refreshAllDocuments()
+  }
+
+  async refreshConfig() {
+    this.config = await Config.fromPathOrNew(this.project.projectPath)
+    await this.formatting.refreshConfig()
+  }
+}

package/src/settings.ts

@@ -0,0 +1,82 @@
+import { ClientCapabilities, Connection, InitializeParams } from "vscode-languageserver/node"
+import { defaultFormatOptions } from "@herb-tools/formatter"
+
+export interface HerbSettings {
+  trace?: {
+    server?: string
+  }
+  linter?: {
+    enabled?: boolean
+  }
+  formatter?: {
+    enabled?: boolean
+    indentWidth?: number
+    maxLineLength?: number
+  }
+}
+
+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 = {
+    formatter: {
+      enabled: false,
+      indentWidth: defaultFormatOptions.indentWidth,
+      maxLineLength: defaultFormatOptions.maxLineLength
+    }
+  }
+  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)
+}