Synchronize MATLAB path with client workspace folders

dklilley · dklilley · commit 98b1af4e71f5 · 2024-12-19T09:34:21.000-05:00
diff --git a/matlab/+matlabls/+handlers/PathSynchronizerHandler.m b/matlab/+matlabls/+handlers/PathSynchronizerHandler.m
@@ -0,0 +1,75 @@
+classdef (Hidden) PathSynchronizerHandler < matlabls.handlers.FeatureHandler
+    % PATHSYNCHRONIZERHANDLER The feature handler to support synchronizing the MATLAB path
+    % with the client's workspace. This provides access points to add and remove from the path,
+    % as well as get/set MATLAB's current working directory.
+
+    % Copyright 2024 The MathWorks, Inc.
+
+    properties (Access = private)
+        CdRequestChannel = "/matlabls/pathSynchronizer/cd/request"
+
+        PwdRequestChannel = "/matlabls/pathSynchronizer/pwd/request"
+        PwdResponseChannel = "/matlabls/pathSynchronizer/pwd/response"
+
+        AddPathRequestChannel = "/matlabls/pathSynchronizer/addpath/request"
+        RmPathRequestChannel = "/matlabls/pathSynchronizer/rmpath/request"
+    end
+
+    methods
+        function this = PathSynchronizerHandler ()
+            this.RequestSubscriptions(1) = matlabls.internal.CommunicationManager.subscribe(this.CdRequestChannel, @this.handleCdRequest);
+            this.RequestSubscriptions(2) = matlabls.internal.CommunicationManager.subscribe(this.PwdRequestChannel, @this.handlePwdRequest);
+            this.RequestSubscriptions(3) = matlabls.internal.CommunicationManager.subscribe(this.AddPathRequestChannel, @this.handleAddPathRequest);
+            this.RequestSubscriptions(4) = matlabls.internal.CommunicationManager.subscribe(this.RmPathRequestChannel, @this.handleRmPathRequest);
+        end
+    end
+
+    methods (Access = private)
+        function handleCdRequest (~, msg)
+            path = msg.path;
+
+            try
+                cd(path)
+            catch e
+                disp('Error during `cd` operation:')
+                disp(e.message)
+            end
+        end
+
+        function handlePwdRequest (this, msg)
+            try
+                currentPath = pwd();
+
+                responseChannel = strcat(this.PwdResponseChannel, '/', msg.channelId);
+                matlabls.internal.CommunicationManager.publish(responseChannel, currentPath);
+            catch e
+                disp('Error during `pwd` operation:')
+                disp(e.message)
+            end
+        end
+
+        function handleAddPathRequest (~, msg)
+            paths = msg.paths;
+            paths = strjoin(paths, pathsep);
+
+            try
+                addpath(paths)
+            catch e
+                disp('Error during `addpath` operation:')
+                disp(e.message)
+            end
+        end
+
+        function handleRmPathRequest (~, msg)
+            paths = msg.paths;
+            paths = strjoin(paths, pathsep);
+
+            try
+                rmpath(paths)
+            catch e
+                disp('Error during `rmpath` operation:')
+                disp(e.message)
+            end
+        end
+    end
+end
diff --git a/matlab/+matlabls/MatlabLanguageServerHelper.m b/matlab/+matlabls/MatlabLanguageServerHelper.m
@@ -32,6 +32,7 @@ function initializeFeatureHandlers (this)
             this.FeatureHandlers(end + 1) = matlabls.handlers.LintingSupportHandler();
             this.FeatureHandlers(end + 1) = matlabls.handlers.NavigationSupportHandler();
             this.FeatureHandlers(end + 1) = matlabls.handlers.FoldingSupportHandler();
+            this.FeatureHandlers(end + 1) = matlabls.handlers.PathSynchronizerHandler();
         end
     end
 end
diff --git a/src/lifecycle/PathSynchronizer.ts b/src/lifecycle/PathSynchronizer.ts
@@ -0,0 +1,155 @@
+// Copyright 2024 The MathWorks, Inc.
+
+import { WorkspaceFolder, WorkspaceFoldersChangeEvent } from 'vscode-languageserver'
+import ClientConnection, { Connection } from '../ClientConnection'
+import Logger from '../logging/Logger'
+import MatlabLifecycleManager from './MatlabLifecycleManager'
+import { MatlabConnection } from './MatlabCommunicationManager'
+import * as os from 'os'
+import path from 'path'
+
+export default class PathSynchronizer {
+    readonly CD_REQUEST_CHANNEL = '/matlabls/pathSynchronizer/cd/request'
+
+    readonly PWD_REQUEST_CHANNEL = '/matlabls/pathSynchronizer/pwd/request'
+    readonly PWD_RESPONSE_CHANNEL = '/matlabls/pathSynchronizer/pwd/response'
+
+    readonly ADDPATH_REQUEST_CHANNEL = '/matlabls/pathSynchronizer/addpath/request'
+    readonly RMPATH_REQUEST_CHANNEL = '/matlabls/pathSynchronizer/rmpath/request'
+
+    constructor (private readonly matlabLifecycleManager: MatlabLifecycleManager) {}
+
+    /**
+     * Initializes the PathSynchronizer by setting up event listeners.
+     * 
+     * Upon MATLAB connection, all workspace folders are added to the MATLAB search path.
+     * Additionally, MATLAB's CWD is set to the first workspace folder to avoid potential
+     * function shadowing issues.
+     * 
+     * As workspace folders are added or removed, the MATLAB path is updated accordingly.
+     */
+    initialize () {
+        const clientConnection = ClientConnection.getConnection()
+
+        this.matlabLifecycleManager.eventEmitter.on('connected', () => this.handleMatlabConnected(clientConnection))
+        
+        clientConnection.workspace.onDidChangeWorkspaceFolders(event => this.handleWorkspaceFoldersChanged(event))
+    }
+
+    /**
+     * Handles synchronizing the MATLAB path with the current workspace folders when MATLAB
+     * has been connected.
+     *
+     * @param clientConnection The current client connection
+     */
+    private async handleMatlabConnected (clientConnection: Connection): Promise<void> {
+        const matlabConnection = await this.matlabLifecycleManager.getMatlabConnection()
+        if (matlabConnection == null) {
+            // As the connection was just established, this should not happen
+            Logger.warn('MATLAB connection is unavailable after connection established')
+            return
+        }
+
+        const workspaceFolders = await clientConnection.workspace.getWorkspaceFolders()
+        if (workspaceFolders == null || workspaceFolders.length === 0) {
+            // No workspace folders - no action needs to be taken
+            return
+        }
+
+        const folderPaths = this.convertWorkspaceFoldersToFilePaths(workspaceFolders)
+
+        // cd to first workspace folder
+        this.setWorkingDirectory(folderPaths[0], matlabConnection)
+
+        // add all workspace folders to path
+        this.addToPath(folderPaths, matlabConnection)
+    }
+
+    /**
+     * Handles synchronizing the MATLAB path with newly added/removed workspace folders.
+     *
+     * @param event The workspace folders change event
+     */
+    private async handleWorkspaceFoldersChanged (event: WorkspaceFoldersChangeEvent): Promise<void> {
+        const matlabConnection = await this.matlabLifecycleManager.getMatlabConnection()
+        if (matlabConnection == null) {
+            return
+        }
+
+        const cwd = await this.getCurrentWorkingDirectory(matlabConnection)
+
+        // addpath for all added folders
+        const addedFolderPaths = this.convertWorkspaceFoldersToFilePaths(event.added)
+        this.addToPath(addedFolderPaths, matlabConnection)
+
+        // rmpath for all removed folders
+        const removedFolderPaths = this.convertWorkspaceFoldersToFilePaths(event.removed)
+        this.removeFromPath(removedFolderPaths, matlabConnection)
+
+        // log warning if primary workspace folder was removed
+        if (this.isCwdInPaths(removedFolderPaths, cwd)) {
+            Logger.warn('The current working directory was removed from the workspace.')
+        }
+    }
+
+    private setWorkingDirectory (path: string, matlabConnection: MatlabConnection): void {
+        Logger.log(`CWD set to: ${path}`)
+
+        matlabConnection.publish(this.CD_REQUEST_CHANNEL, {
+            path
+        })
+    }
+
+    private getCurrentWorkingDirectory (matlabConnection: MatlabConnection): Promise<string> {
+        const channelId = matlabConnection.getChannelId()
+        const channel = `${this.PWD_RESPONSE_CHANNEL}/${channelId}`
+
+        return new Promise<string>(resolve => {
+            const responseSub = matlabConnection.subscribe(channel, message => {
+                const cwd = message as string
+                matlabConnection.unsubscribe(responseSub)
+                resolve(path.normalize(cwd))
+            })
+
+            matlabConnection.publish(this.PWD_REQUEST_CHANNEL, {
+                channelId
+            })
+        })
+    }
+
+    private addToPath (paths: string[], matlabConnection: MatlabConnection): void {
+        if (paths.length === 0) return
+
+        Logger.log(`Adding workspace folder(s) to the MATLAB Path: \n\t${paths.join('\n\t')}`)
+        matlabConnection.publish(this.ADDPATH_REQUEST_CHANNEL, {
+            paths
+        })
+    }
+
+    private removeFromPath (paths: string[], matlabConnection: MatlabConnection): void {
+        if (paths.length === 0) return
+
+        Logger.log(`Removing workspace folder(s) from the MATLAB Path: \n\t${paths.join('\n\t')}`)
+        matlabConnection.publish(this.RMPATH_REQUEST_CHANNEL, {
+            paths
+        })
+    }
+
+    private convertWorkspaceFoldersToFilePaths (workspaceFolders: WorkspaceFolder[]): string[] {
+        return workspaceFolders.map(folder => {
+            let uri = decodeURIComponent(folder.uri)
+            uri = uri.replace('file:///', '')
+            return path.normalize(uri)
+        });
+    }
+
+    private isCwdInPaths (folderPaths: string[], cwd: string): boolean {
+        if (os.platform() === 'win32') {
+            // On Windows, paths are case-insensitive
+            return folderPaths.some(folderPath => folderPath.toLowerCase() === cwd.toLowerCase());
+        } else {
+            // On Unix-like systems, paths are case-sensitive
+            return folderPaths.includes(cwd);
+        }
+    }
+}
diff --git a/src/server.ts b/src/server.ts
@@ -30,6 +30,7 @@ import MVMServer from './mvm/MVMServer'
 import { stopLicensingServer } from './licensing/server'
 import { setInstallPath } from './licensing/config'
 import { handleInstallPathSettingChanged, handleSignInChanged, setupLicensingNotificationListenersAndUpdateClient } from './utils/LicensingUtils'
+import PathSynchronizer from './lifecycle/PathSynchronizer'
 
 export async function startServer (): Promise<void> {
     cacheAndClearProxyEnvironmentVariables()
@@ -56,6 +57,8 @@ export async function startServer (): Promise<void> {
     const navigationSupportProvider = new NavigationSupportProvider(matlabLifecycleManager, indexer, documentIndexer, pathResolver)
     const renameSymbolProvider = new RenameSymbolProvider(matlabLifecycleManager, documentIndexer)
 
+    let pathSynchronizer: PathSynchronizer | null
+
     // Create basic text document manager
     const documentManager: TextDocuments<TextDocument> = new TextDocuments(TextDocument)
 
@@ -146,6 +149,12 @@ export async function startServer (): Promise<void> {
 
         workspaceIndexer.setupCallbacks(capabilities)
 
+        if (capabilities.workspace?.workspaceFolders != null) {
+            // If workspace folders are supported, try to synchronize the MATLAB path with the user's workspace.
+            pathSynchronizer = new PathSynchronizer(matlabLifecycleManager)
+            pathSynchronizer.initialize()
+        }
+
         mvm = new MVM(matlabLifecycleManager);
         mvmServer = new MVMServer(mvm, NotificationService);
         matlabDebugAdaptor = new MatlabDebugAdaptorServer(mvm, new DebugServices(mvm));
