@herb-tools/language-server 0.3.1 → 0.4.1

package/src/server.ts

@@ -6,88 +6,106 @@ import {
   DidChangeWatchedFilesNotification,
   TextDocumentSyncKind,
   InitializeResult,
+  Connection,
+  DocumentFormattingParams,
 } from "vscode-languageserver/node"
 
 import { Service } from "./service"
 import { HerbSettings } from "./settings"
 
-let service: Service
-const connection = createConnection(ProposedFeatures.all)
+export class Server {
+  private service!: Service
+  private connection: Connection
 
-connection.onInitialize(async (params: InitializeParams) => {
-  service = new Service(connection, params)
-  await service.init()
-
-  const result: InitializeResult = {
-    capabilities: {
-      textDocumentSync: TextDocumentSyncKind.Incremental,
-    },
+  constructor() {
+    this.connection = createConnection(ProposedFeatures.all)
+    this.setupEventHandlers()
   }
 
-  if (service.settings.hasWorkspaceFolderCapability) {
-    result.capabilities.workspace = {
-      workspaceFolders: {
-        supported: true,
-      },
-    }
-  }
+  private setupEventHandlers() {
+    this.connection.onInitialize(async (params: InitializeParams) => {
+      this.service = new Service(this.connection, params)
 
-  return result
-})
+      await this.service.init()
 
-connection.onInitialized(() => {
-  if (service.settings.hasConfigurationCapability) {
-    // Register for all configuration changes.
-    connection.client.register(DidChangeConfigurationNotification.type, undefined)
-  }
+      const result: InitializeResult = {
+        capabilities: {
+          textDocumentSync: TextDocumentSyncKind.Incremental,
+          documentFormattingProvider: true,
+        },
+      }
+
+      if (this.service.settings.hasWorkspaceFolderCapability) {
+        result.capabilities.workspace = {
+          workspaceFolders: {
+            supported: true,
+          },
+        }
+      }
 
-  if (service.settings.hasWorkspaceFolderCapability) {
-    connection.workspace.onDidChangeWorkspaceFolders((_event) => {
-      connection.console.log("Workspace folder change event received.")
+      return result
     })
-  }
 
-  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
-  }
+    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` },
+        ],
+      })
+    })
 
-  service.refresh()
-})
+    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()
+    })
 
-connection.onDidOpenTextDocument((params) => {
-  console.error(params)
-  const document = service.documentService.get(params.textDocument.uri)
+    this.connection.onDidOpenTextDocument(async (params) => {
+      const document = this.service.documentService.get(params.textDocument.uri)
 
-  if (document) {
-    service.diagnostics.refreshDocument(document)
-  }
-})
+      if (document) {
+        await this.service.diagnostics.refreshDocument(document)
+      }
+    })
 
-connection.onDidChangeWatchedFiles((params) => {
-  params.changes.forEach(async (event) => {
-    if (event.uri.endsWith("/.herb-lsp/config.json")) {
-      await service.refreshConfig()
+    this.connection.onDidChangeWatchedFiles((params) => {
+      params.changes.forEach(async (event) => {
+        if (event.uri.endsWith("/.herb-lsp/config.json")) {
+          await this.service.refreshConfig()
 
-      service.documentService.getAll().forEach((document) => {
-        service.diagnostics.refreshDocument(document)
+          const documents = this.service.documentService.getAll()
+          await Promise.all(documents.map(document => 
+            this.service.diagnostics.refreshDocument(document)
+          ))
+        }
       })
-    }
-  })
-})
+    })
 
-// Listen on the connection
-connection.listen()
+    this.connection.onDocumentFormatting((params: DocumentFormattingParams) => {
+      return this.service.formatting.formatDocument(params)
+    })
+  }
+
+  listen() {
+    this.connection.listen()
+  }
+}

package/src/service.ts

@@ -1,29 +1,44 @@
 import { Connection, InitializeParams } from "vscode-languageserver/node"
 
-import { Settings } from "./settings"
+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.diagnostics = new Diagnostics(this.connection, this.documentService)
+    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)
 
@@ -34,18 +49,18 @@ export class Service {
 
     // 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)
+    this.documentService.onDidChangeContent(async (change) => {
+      await this.diagnostics.refreshDocument(change.document)
     })
   }
 
   async refresh() {
     await this.project.refresh()
-
-    this.diagnostics.refreshAllDocuments()
+    await this.diagnostics.refreshAllDocuments()
   }
 
   async refreshConfig() {
     this.config = await Config.fromPathOrNew(this.project.projectPath)
+    await this.formatting.refreshConfig()
   }
 }

package/src/settings.ts

@@ -1,12 +1,34 @@
 import { ClientCapabilities, Connection, InitializeParams } from "vscode-languageserver/node"
+import { defaultFormatOptions } from "@herb-tools/formatter"
 
-export interface HerbSettings {}
+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 = {}
+  defaultSettings: HerbSettings = {
+    linter: {
+      enabled: true
+    },
+    formatter: {
+      enabled: false,
+      indentWidth: defaultFormatOptions.indentWidth,
+      maxLineLength: defaultFormatOptions.maxLineLength
+    }
+  }
   globalSettings: HerbSettings = this.defaultSettings
   documentSettings: Map<string, Thenable<HerbSettings>> = new Map()