internal virtual void DidChangeConfiguration(LSP.Implementation.LanguageClient client) { var param = new DidChangeConfigurationParams(); param.settings = new object(); client.Send.WorkspaceDidChangeConfiguration(param); }
protected async Task HandleDidChangeConfigurationNotification( DidChangeConfigurationParams <SettingsWrapper> configChangeParams, EventContext eventContext) { bool oldScriptAnalysisEnabled = this.currentSettings.ScriptAnalysis.Enable.HasValue; this.currentSettings.Update( configChangeParams.Settings.Powershell); if (oldScriptAnalysisEnabled != this.currentSettings.ScriptAnalysis.Enable) { // If the user just turned off script analysis, send a diagnostics // event to clear the analysis markers that they already have if (!this.currentSettings.ScriptAnalysis.Enable.Value) { ScriptFileMarker[] emptyAnalysisDiagnostics = new ScriptFileMarker[0]; foreach (var scriptFile in editorSession.Workspace.GetOpenedFiles()) { await PublishScriptDiagnostics( scriptFile, emptyAnalysisDiagnostics, eventContext); } } } }
public async Task ChangeConfigurationTest() { using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile()) using (TestHelper testHelper = new TestHelper()) { bool connected = await testHelper.Connect(queryTempFile.FilePath, ConnectionTestUtils.LocalhostConnection); Assert.True(connected, "Connection was not successful"); Thread.Sleep(500); var settings = new SqlToolsSettings(); settings.SqlTools.IntelliSense.EnableIntellisense = false; DidChangeConfigurationParams <SqlToolsSettings> configParams = new DidChangeConfigurationParams <SqlToolsSettings>() { Settings = settings }; await testHelper.RequestChangeConfigurationNotification(configParams); Thread.Sleep(2000); await testHelper.Disconnect(queryTempFile.FilePath); } }
public override async Task DidChangeConfiguration(DidChangeConfigurationParams @params, CancellationToken cancellationToken) { _disposableBag.ThrowIfDisposed(); if (Analyzer == null) { LogMessage(MessageType.Error, "Change configuration notification sent to uninitialized server"); return; } var reanalyze = true; if (@params.settings != null) { if (@params.settings is ServerSettings settings) { reanalyze = HandleConfigurationChanges(settings); } else { LogMessage(MessageType.Error, "change configuration notification sent unsupported settings"); return; } } if (reanalyze) { await ReloadModulesAsync(cancellationToken); } }
public async Task <Unit> Handle(DidChangeConfigurationParams request, CancellationToken cancellationToken) { _logger.LogTrace("Settings changed. Updating the server."); await _optionsMonitor.UpdateAsync(); return(new Unit()); }
protected override void DidChangeConfiguration(DidChangeConfigurationParams @params) { _maxNumberOfProblems = @params?.settings?.languageServerExample?.maxNumberOfProblems ?? 100; foreach (var document in _documents.All) { ValidateTextDocument(document); } }
protected override void DidChangeConfiguration(DidChangeConfigurationParams @params) { _maxNumberOfProblems = @params?.settings?.languageServerExample?.maxNumberOfProblems ?? _maxNumberOfProblems; Logger.Instance.Log($"maxNumberOfProblems is set to {_maxNumberOfProblems}."); foreach (var document in _documents.All) { ValidateTextDocument(document); } }
protected override void DidChangeConfiguration(DidChangeConfigurationParams @params) { _validator.UpdateConfig(@params.settings); foreach (var document in _documents.All) { ValidateTextDocument(document); } }
/// <summary> /// Handles the configuration change event /// </summary> internal async Task HandleDidChangeConfigurationNotification( DidChangeConfigurationParams <TConfig> configChangeParams, EventContext eventContext) { Logger.Write(LogLevel.Verbose, "HandleDidChangeConfigurationNotification"); // Propagate the changes to the event handlers var configUpdateTasks = ConfigChangeCallbacks.Select( t => t(configChangeParams.Settings, CurrentSettings, eventContext)); await Task.WhenAll(configUpdateTasks); }
public Task <Unit> Handle(DidChangeConfigurationParams configChangeParams, CancellationToken token) { var json = configChangeParams.Settings?.SelectToken("ostw") as JObject; if (json != null) { var config = json.ToObject <RawConfiguration>(); I18n.I18n.LoadLanguage(config.GetOutputLanguage()); } return(Unit.Task); }
public Task <Unit> Handle(DidChangeConfigurationParams configChangeParams, CancellationToken token) { var json = configChangeParams.Settings?.SelectToken("ostw") as JObject; if (json != null) { dynamic config = json; ReferencesCodeLens = config.codelens.references; ImplementsCodeLens = config.codelens.implements; ElementCountCodeLens = config.codelens.elementCount; OutputLanguage = GetOutputLanguage(config.outputLanguage); LanguageInfo.LoadLanguage(OutputLanguage); OptimizeOutput = config.optimizeOutput; } return(Unit.Task); OutputLanguage GetOutputLanguage(string languageString) { switch (languageString) { case "English": return(OutputLanguage.enUS); case "German": return(OutputLanguage.deDE); case "Spanish (Castilian)": return(OutputLanguage.esES); case "Spanish (Mexico)": return(OutputLanguage.esMX); case "French": return(OutputLanguage.frFR); case "Italian": return(OutputLanguage.itIT); case "Japanese": return(OutputLanguage.jaJP); case "Korean": return(OutputLanguage.koKR); case "Polish": return(OutputLanguage.plPL); case "Portuguese": return(OutputLanguage.ptBR); case "Russian": return(OutputLanguage.ruRU); case "Chinese (S)": return(OutputLanguage.zhCN); case "Chinese (T)": return(OutputLanguage.zhTW); default: return(OutputLanguage.enUS); } } }
public override void OnDidChangeConfiguration(DidChangeConfigurationParams parameters) { if (parameters.settings is Newtonsoft.Json.Linq.JArray) { Newtonsoft.Json.Linq.JArray array = parameters.settings as Newtonsoft.Json.Linq.JArray; IEnumerable <string> arguments = array.Select(t => t.ToString()); typeCobolWorkspace.DidChangeConfigurationParams(arguments); } else { typeCobolWorkspace.DidChangeConfigurationParams(parameters.settings.ToString()); } }
public void SendSettings(DidChangeConfigurationParams parameter) { this.CurrentSettings = parameter.Settings.ToString(); this.NotifyPropertyChanged(nameof(CurrentSettings)); JToken parsedSettings = JToken.Parse(this.CurrentSettings); int newMaxProblems = parsedSettings.Children().First().Values <int>("maxNumberOfProblems").First(); if (this.maxProblems != newMaxProblems) { this.maxProblems = newMaxProblems; } }
public async Task Handle_UpdatesOptions() { // Arrange var optionsMonitor = new TestRazorLSPOptionsMonitor(ConfigurationService, Cache); var endpoint = new RazorConfigurationEndpoint(optionsMonitor, LoggerFactory); var request = new DidChangeConfigurationParams(); // Act await endpoint.Handle(request, CancellationToken.None); // Assert Assert.True(optionsMonitor.Called, "UpdateAsync was not called."); }
public async Task <Unit> Handle(DidChangeConfigurationParams request, CancellationToken cancellationToken) { // null means we need to re-read the configuration // https://github.com/Microsoft/vscode-languageserver-node/issues/380 if (request.Settings == null || request.Settings.Type == JTokenType.Null) { await GetWorkspaceConfiguration(); return(Unit.Value); } ParseClientConfiguration(request.Settings); OnReload(); return(Unit.Value); }
public void DidChangeConfiguration(DidChangeConfigurationParams @params, CancellationToken cancellationToken) { _disposableBag.ThrowIfDisposed(); switch (@params.settings) { case ServerSettings settings: Settings = settings; _symbolHierarchyMaxSymbols = Settings.analysis.symbolsHierarchyMaxSymbols; _completionSource.Options = Settings.completion; break; default: _log?.Log(TraceEventType.Error, "change configuration notification sent unsupported settings"); break; } }
public void DidChangeConfiguration(DidChangeConfigurationParams @params, CancellationToken cancellationToken) { _disposableBag.ThrowIfDisposed(); switch (@params.settings) { case ServerSettings settings: { if (HandleConfigurationChanges(settings)) { RestartAnalysis(); } break; } default: _log?.Log(TraceEventType.Error, "change configuration notification sent unsupported settings"); break; } }
public void SimpleTest(string expected) { var model = new DidChangeConfigurationParams() { Settings = new Dictionary <string, BooleanNumberString>() { { "abc", 1 }, { "def", "a" }, { "ghi", true }, } }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = JsonConvert.DeserializeObject <DidChangeConfigurationParams>(expected); deresult.ShouldBeEquivalentTo(model); }
public Task <Unit> Handle(DidChangeConfigurationParams request, CancellationToken cancellationToken) { if (_capability == null) { return(Unit.Task); } // null means we need to re-read the configuration // https://github.com/Microsoft/vscode-languageserver-node/issues/380 if (request.Settings == null || request.Settings.Type == JTokenType.Null) { _triggerChange.OnNext(System.Reactive.Unit.Default); return(Unit.Task); } Data.Clear(); _configurationConverter.ParseClientConfiguration(Data, request.Settings); OnReload(); return(Unit.Task); }
public void SimpleTest(string expected) { var model = new DidChangeConfigurationParams() { Settings = JObject.FromObject(new Dictionary <string, object>() { { "abc", 1 }, { "def", "a" }, { "ghi", true }, }) }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject <DidChangeConfigurationParams>(expected); deresult.Should().BeEquivalentTo(model); }
public void SendSettings(DidChangeConfigurationParams parameter) { this.CurrentSettings = parameter.Settings.ToString(); this.NotifyPropertyChanged(nameof(CurrentSettings)); try { JToken parsedSettings = JToken.Parse(this.CurrentSettings); int newMaxProblems = parsedSettings.Children().First().Values <int>("maxNumberOfProblems").First(); if (this.maxProblems != newMaxProblems) { this.maxProblems = newMaxProblems; this.SendDiagnostics(); } } catch (Exception ex) { LoggingService.Log("Error reading settings: " + ex.Message); } }
async Task SendConfigurationSettings() { var settings = LanguageClientConfigurationSettingsProvider.GetSettings( client.ConfigurationSections, client.GetType()); if (settings == null) { return; } Log("Sending '{0}' message.", Methods.WorkspaceDidChangeConfigurationName); var message = new DidChangeConfigurationParams { Settings = settings }; await jsonRpc.NotifyWithParameterObjectAsync(Methods.WorkspaceDidChangeConfigurationName, message); Log("Configuration sent.", Id); }
public Task DidChangeConfiguration(JToken token) { var settings = new LanguageServerSettings(); var rootSection = token["settings"]; var pythonSection = rootSection?["python"]; var autoComplete = pythonSection?["autoComplete"]; if (autoComplete != null) { var showAdvancedMembers = autoComplete["showAdvancedMembers"] as JValue; settings.SuppressAdvancedMembers = showAdvancedMembers == null || (showAdvancedMembers.Type == JTokenType.Boolean && !showAdvancedMembers.ToObject <bool>()); } var p = new DidChangeConfigurationParams() { settings = settings }; return(_server.DidChangeConfiguration(p)); }
/// <summary> /// Handles the configuration change event /// </summary> internal async Task HandleDidChangeConfigurationNotification( DidChangeConfigurationParams <TConfig> configChangeParams, EventContext eventContext) { try { Logger.Instance.Write(LogLevel.Verbose, "HandleDidChangeConfigurationNotification"); // Propagate the changes to the event handlers var configUpdateTasks = ConfigChangeCallbacks.Select( t => t(configChangeParams.Settings, CurrentSettings, eventContext)); await Task.WhenAll(configUpdateTasks); } catch (Exception ex) { Logger.Instance.Write(LogLevel.Error, "Unknown error " + ex.ToString()); // Swallow exceptions here to prevent us from crashing // TODO: this probably means the ScriptFile model is in a bad state or out of sync with the actual file; we should recover here return; } }
public abstract Task <Unit> Handle(DidChangeConfigurationParams request, CancellationToken cancellationToken);
public override async Task <Unit> Handle(DidChangeConfigurationParams request, CancellationToken cancellationToken) { LanguageServerSettingsWrapper incomingSettings = request.Settings.ToObject <LanguageServerSettingsWrapper>(); _logger.LogTrace("Handling DidChangeConfiguration"); if (incomingSettings is null || incomingSettings.Powershell is null) { _logger.LogTrace("Incoming settings were null"); return(await Unit.Task.ConfigureAwait(false)); } SendFeatureChangesTelemetry(incomingSettings); bool profileLoadingPreviouslyEnabled = _configurationService.CurrentSettings.EnableProfileLoading; bool oldScriptAnalysisEnabled = _configurationService.CurrentSettings.ScriptAnalysis.Enable ?? false; string oldScriptAnalysisSettingsPath = _configurationService.CurrentSettings.ScriptAnalysis?.SettingsPath; _configurationService.CurrentSettings.Update( incomingSettings.Powershell, _workspaceService.WorkspacePath, _logger); // We need to load the profiles if: // - Profile loading is configured, AND // - Profiles haven't been loaded before, OR // - The profile loading configuration just changed bool loadProfiles = _configurationService.CurrentSettings.EnableProfileLoading && (!_profilesLoaded || !profileLoadingPreviouslyEnabled); if (!_psesHost.IsRunning) { _logger.LogTrace("Starting command loop"); if (loadProfiles) { _logger.LogTrace("Loading profiles..."); } await _psesHost.TryStartAsync(new HostStartOptions { LoadProfiles = loadProfiles }, CancellationToken.None).ConfigureAwait(false); if (loadProfiles) { _profilesLoaded = true; _logger.LogTrace("Loaded!"); } } // TODO: Load profiles when the host is already running if (!_cwdSet) { if (!string.IsNullOrEmpty(_configurationService.CurrentSettings.Cwd) && Directory.Exists(_configurationService.CurrentSettings.Cwd)) { _logger.LogTrace($"Setting CWD (from config) to {_configurationService.CurrentSettings.Cwd}"); await _psesHost.SetInitialWorkingDirectoryAsync( _configurationService.CurrentSettings.Cwd, CancellationToken.None).ConfigureAwait(false); } else if (_workspaceService.WorkspacePath is not null && Directory.Exists(_workspaceService.WorkspacePath)) { _logger.LogTrace($"Setting CWD (from workspace) to {_workspaceService.WorkspacePath}"); await _psesHost.SetInitialWorkingDirectoryAsync( _workspaceService.WorkspacePath, CancellationToken.None).ConfigureAwait(false); } else { _logger.LogTrace("Tried to set CWD but in bad state"); } _cwdSet = true; }
} // Does nothing public abstract Task DidChangeConfiguration(DidChangeConfigurationParams @params, CancellationToken cancellationToken);
public override Task <Unit> Handle(DidChangeConfigurationParams request, CancellationToken cancellationToken) => _handler.Invoke(request, cancellationToken);
protected async Task HandleDidChangeConfigurationNotification( DidChangeConfigurationParams<SettingsWrapper> configChangeParams, EventContext eventContext) { bool oldScriptAnalysisEnabled = this.currentSettings.ScriptAnalysis.Enable.HasValue; this.currentSettings.Update( configChangeParams.Settings.Powershell); if (oldScriptAnalysisEnabled != this.currentSettings.ScriptAnalysis.Enable) { // If the user just turned off script analysis, send a diagnostics // event to clear the analysis markers that they already have if (!this.currentSettings.ScriptAnalysis.Enable.Value) { ScriptFileMarker[] emptyAnalysisDiagnostics = new ScriptFileMarker[0]; foreach (var scriptFile in editorSession.Workspace.GetOpenedFiles()) { await PublishScriptDiagnostics( scriptFile, emptyAnalysisDiagnostics, eventContext); } } } }
public static void DidChangeConfiguration(this ILanguageClientWorkspace router, DidChangeConfigurationParams @params) { router.SendNotification(WorkspaceNames.DidChangeConfiguration, @params); }
/// <summary> /// Request a configuration change notification /// </summary> public async Task RequestChangeConfigurationNotification(DidChangeConfigurationParams <SqlToolsSettings> configParams) { await Driver.SendEvent(DidChangeConfigurationNotification <SqlToolsSettings> .Type, configParams); }