feat: add support for workspace folders

.gitignore

@@ -3,3 +3,4 @@ npm-debug.log
 build/
 yarn.lock
 package-lock.json
+.pnpm-debug.log

lib/auto-languageclient.ts

@@ -29,6 +29,7 @@ import { ConsoleLogger, FilteredLogger, Logger } from "./logger"
 import { LanguageServerProcess, ServerManager, ActiveServer } from "./server-manager.js"
 import { Disposable, CompositeDisposable, Point, Range, TextEditor } from "atom"
 import * as ac from "atom/autocomplete-plus"
+import { basename } from "path"
 
 export { ActiveServer, LanguageClientConnection, LanguageServerProcess }
 export type ConnectionType = "stdio" | "socket" | "ipc"
@@ -106,12 +107,13 @@ export default class AutoLanguageClient {
 
   /** (Optional) Return the parameters used to initialize a client - you may want to extend capabilities */
   protected getInitializeParams(projectPath: string, lsProcess: LanguageServerProcess): ls.InitializeParams {
+    const rootUri = Convert.pathToUri(projectPath)
     return {
       processId: lsProcess.pid,
       rootPath: projectPath,
-      rootUri: Convert.pathToUri(projectPath),
+      rootUri,
       locale: atom.config.get("atom-i18n.locale") || "en",
-      workspaceFolders: null,
+      workspaceFolders: [{ uri: rootUri, name: basename(projectPath) }],
       // The capabilities supported.
       // TODO the capabilities set to false/undefined are TODO. See {ls.ServerCapabilities} for a full list.
       capabilities: {
@@ -124,7 +126,7 @@ export default class AutoLanguageClient {
             changeAnnotationSupport: undefined,
             resourceOperations: ["create", "rename", "delete"],
           },
-          workspaceFolders: false,
+          workspaceFolders: true,
           didChangeConfiguration: {
             dynamicRegistration: false,
           },
@@ -568,6 +570,8 @@ export default class AutoLanguageClient {
     })
 
     ShowDocumentAdapter.attach(server.connection)
+
+    server.connection.onWorkspaceFolders(() => this._serverManager.getWorkspaceFolders())
   }
 
   public shouldSyncForEditor(editor: TextEditor, projectPath: string): boolean {

lib/languageclient.ts

@@ -281,6 +281,27 @@ export class LanguageClientConnection extends EventEmitter {
     this._sendNotification(lsp.DidChangeWatchedFilesNotification.type, params)
   }
 
+  /**
+   * Public: Register a callback for the `workspace.workspaceFolders` request. This request is sent from the server to
+   * Atom to fetch the current open list of workspace folders
+   *
+   * @param A Callback which returns a {Promise} containing an {Array} of {lsp.WorkspaceFolder[]} or {null} if only a
+   *   single file is open in the tool.
+   */
+  public onWorkspaceFolders(callback: () => Promise<lsp.WorkspaceFolder[] | null>): void {
+    return this._onRequest(lsp.WorkspaceFoldersRequest.type, callback)
+  }
+
+  /**
+   * Public: Send a `workspace/didChangeWorkspaceFolders` notification.
+   *
+   * @param {DidChangeWorkspaceFoldersParams} params An object that contains the actual workspace folder change event
+   *   ({WorkspaceFoldersChangeEvent}) in its {event} property
+   */
+  public didChangeWorkspaceFolders(params: lsp.DidChangeWorkspaceFoldersParams): void {
+    this._sendNotification(lsp.DidChangeWorkspaceFoldersNotification.type, params)
+  }
+
   /**
    * Public: Register a callback for the `textDocument/publishDiagnostics` message.
    *

lib/server-manager.ts

@@ -6,7 +6,7 @@ import { Logger } from "./logger"
 import { CompositeDisposable, FilesystemChangeEvent, TextEditor } from "atom"
 import { ReportBusyWhile } from "./utils"
 
-type MinimalLanguageServerProcess = Pick<ChildProcess, "stdin" | "stdout" | "stderr" | "pid" | "kill" | "on">
+export type MinimalLanguageServerProcess = Pick<ChildProcess, "stdin" | "stdout" | "stderr" | "pid" | "kill" | "on">
 
 /**
  * Public: Defines a language server process which is either a ChildProcess, or it is a minimal object that resembles a
@@ -38,6 +38,7 @@ export class ServerManager {
   private _disposable: CompositeDisposable = new CompositeDisposable()
   private _editorToServer: Map<TextEditor, ActiveServer> = new Map()
   private _normalizedProjectPaths: string[] = []
+  private _previousNormalizedProjectPaths: string[] | undefined = undefined // TODO we should not hold a separate cache
   private _isStarted = false
 
   constructor(
@@ -60,6 +61,7 @@ export class ServerManager {
         this._disposable.add(atom.project.onDidChangeFiles(this.projectFilesChanged.bind(this)))
       }
     }
+    this._isStarted = true
   }
 
   public stopListening(): void {
@@ -111,8 +113,8 @@ export class ServerManager {
     }
   }
 
-  public getActiveServers(): ActiveServer[] {
-    return this._activeServers.slice()
+  public getActiveServers(): Readonly<ActiveServer[]> {
+    return this._activeServers
   }
 
   public async getServer(
@@ -252,17 +254,55 @@ export class ServerManager {
   }
 
   public updateNormalizedProjectPaths(): void {
-    this._normalizedProjectPaths = atom.project.getDirectories().map((d) => this.normalizePath(d.getPath()))
+    this._normalizedProjectPaths = atom.project.getPaths().map(normalizePath)
   }
 
-  public normalizePath(projectPath: string): string {
-    return !projectPath.endsWith(path.sep) ? path.join(projectPath, path.sep) : projectPath
+  public getNormalizedProjectPaths(): Readonly<string[]> {
+    return this._normalizedProjectPaths
+  }
+
+  /**
+   * Public: fetch the current open list of workspace folders
+   *
+   * @returns A {Promise} containing an {Array} of {lsp.WorkspaceFolder[]} or {null} if only a single file is open in the tool.
+   */
+  public getWorkspaceFolders(): Promise<ls.WorkspaceFolder[] | null> {
+    // NOTE the method must return a Promise based on the specification
+    const projectPaths = this.getNormalizedProjectPaths()
+    if (projectPaths.length === 0) {
+      // only a single file is open
+      return Promise.resolve(null)
+    } else {
+      return Promise.resolve(projectPaths.map(normalizedProjectPathToWorkspaceFolder))
+    }
   }
 
   public async projectPathsChanged(projectPaths: string[]): Promise<void> {
-    const pathsSet = new Set(projectPaths.map(this.normalizePath))
-    const serversToStop = this._activeServers.filter((s) => !pathsSet.has(s.projectPath))
+    const pathsAll = projectPaths.map(normalizePath)
+
+    const previousPaths = this._previousNormalizedProjectPaths ?? this.getNormalizedProjectPaths()
+    const pathsRemoved = previousPaths.filter((projectPath) => !pathsAll.includes(projectPath))
+    const pathsAdded = pathsAll.filter((projectPath) => !previousPaths.includes(projectPath))
+
+    // update cache
+    this._previousNormalizedProjectPaths = pathsAll
+
+    // send didChangeWorkspaceFolders
+    const didChangeWorkspaceFoldersParams = {
+      event: {
+        added: pathsAdded.map(normalizedProjectPathToWorkspaceFolder),
+        removed: pathsRemoved.map(normalizedProjectPathToWorkspaceFolder),
+      },
+    }
+    for (const activeServer of this._activeServers) {
+      activeServer.connection.didChangeWorkspaceFolders(didChangeWorkspaceFoldersParams)
+    }
+
+    // stop the servers that don't have projectPath
+    const serversToStop = this._activeServers.filter((server) => pathsRemoved.includes(server.projectPath))
     await Promise.all(serversToStop.map((s) => this.stopServer(s)))
+
+    // update this._normalizedProjectPaths
     this.updateNormalizedProjectPaths()
   }
 
@@ -290,4 +330,23 @@ export class ServerManager {
       }
     }
   }
+
+  /** @deprecated Use the exported `normalizePath` function */
+  public normalizePath = normalizePath
+}
+
+export function projectPathToWorkspaceFolder(projectPath: string): ls.WorkspaceFolder {
+  const normalizedProjectPath = normalizePath(projectPath)
+  return normalizedProjectPathToWorkspaceFolder(normalizedProjectPath)
+}
+
+export function normalizedProjectPathToWorkspaceFolder(normalizedProjectPath: string): ls.WorkspaceFolder {
+  return {
+    uri: Convert.pathToUri(normalizedProjectPath),
+    name: path.basename(normalizedProjectPath),
+  }
+}
+
+export function normalizePath(projectPath: string): string {
+  return !projectPath.endsWith(path.sep) ? path.join(projectPath, path.sep) : projectPath
 }

package.json

@@ -37,11 +37,13 @@
   },
   "devDependencies": {
     "@types/atom": "^1.40.10",
+    "@types/jasmine": "^3.7.1",
     "@types/node": "15.0.2",
     "atom-jasmine3-test-runner": "^5.2.4",
     "eslint-config-atomic": "^1.14.3",
     "prettier-config-atomic": "^2.0.4",
     "shx": "^0.3.3",
+    "spawk": "^1.4.0",
     "typescript": "~4.2.4"
   }
 }