public override async Task <object> HandleRequestAsync( ExecuteCommandParams request, RequestContext context, CancellationToken cancellationToken ) { Contract.ThrowIfNull(request.Arguments); var document = context.Document; if (document == null) { return(false); } var commandService = document.Project.LanguageServices.GetService <IXamlCommandService>(); if (commandService == null) { return(false); } // request.Arguments has two argument for CreateEventHandlerCommand // Arguments[0]: TextDocumentIdentifier // Arguments[1]: XamlEventDescription var arguments = new object[] { ((JToken)request.Arguments[1]).ToObject <XamlEventDescription>() }; return(await commandService .ExecuteCommandAsync(document, request.Command, arguments, cancellationToken) .ConfigureAwait(false)); }
public async Task RequestsCancellation() { var executeCommandHandler = Substitute.For <IExecuteCommandHandler>(); executeCommandHandler .Handle(Arg.Any <ExecuteCommandParams>(), Arg.Any <CancellationToken>()) .Returns(async(c) => { await Task.Delay(1000, c.Arg <CancellationToken>()); throw new XunitException("Task was not cancelled in time!"); return(Unit.Value); }); var collection = new HandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue) { executeCommandHandler }; AutoSubstitute.Provide <IHandlerCollection>(collection); var mediator = AutoSubstitute.Resolve <LspRequestRouter>(); var id = Guid.NewGuid().ToString(); var @params = new ExecuteCommandParams() { Command = "123" }; var request = new Request(id, "workspace/executeCommand", JObject.Parse(JsonConvert.SerializeObject(@params, new Serializer(ClientVersion.Lsp3).Settings))); var response = ((IRequestRouter)mediator).RouteRequest(request); mediator.CancelRequest(id); var result = await response; result.IsError.Should().BeTrue(); result.Error.Should().BeEquivalentTo(new RequestCancelled()); }
public async Task RequestsCancellation() { var executeCommandHandler = Substitute.For <IExecuteCommandHandler>(); executeCommandHandler .Handle(Arg.Any <ExecuteCommandParams>(), Arg.Any <CancellationToken>()) .Returns(async(c) => { await Task.Delay(1000, c.Arg <CancellationToken>()); throw new XunitException("Task was not cancelled in time!"); return(Unit.Value); }); var collection = new SharedHandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers()) { executeCommandHandler }; AutoSubstitute.Provide <IHandlerCollection>(collection); AutoSubstitute.Provide <IEnumerable <ILspHandlerDescriptor> >(collection); var mediator = AutoSubstitute.Resolve <LspRequestRouter>(); var id = Guid.NewGuid().ToString(); var @params = new ExecuteCommandParams() { Command = "123" }; var request = new Request(id, "workspace/executeCommand", JObject.Parse(JsonConvert.SerializeObject(@params, new Serializer(ClientVersion.Lsp3).Settings))); var cts = new CancellationTokenSource(); cts.Cancel(); var response = ((IRequestRouter <ILspHandlerDescriptor>)mediator).RouteRequest(mediator.GetDescriptor(request), request, cts.Token); Func <Task> action = () => ((IRequestRouter <ILspHandlerDescriptor>)mediator).RouteRequest(mediator.GetDescriptor(request), request, cts.Token); await action.Should().ThrowAsync <OperationCanceledException>(); }
public async Task RequestsCancellation() { var executeCommandHandler = Substitute.For <IExecuteCommandHandler>(); executeCommandHandler .Handle(Arg.Any <ExecuteCommandParams>(), Arg.Any <CancellationToken>()) .Returns(async(c) => { await Task.Delay(1000, c.Arg <CancellationToken>()); throw new XunitException("Task was not cancelled in time!"); }); var collection = new HandlerCollection { executeCommandHandler }; var mediator = new LspRequestRouter(collection, _testLoggerFactory, _handlerMatcherCollection); var id = Guid.NewGuid().ToString(); var @params = new ExecuteCommandParams() { Command = "123" }; var request = new Request(id, "workspace/executeCommand", JObject.Parse(JsonConvert.SerializeObject(@params))); var response = ((IRequestRouter)mediator).RouteRequest(request); mediator.CancelRequest(id); var result = await response; result.IsError.Should().BeTrue(); result.Error.ShouldBeEquivalentTo(new RequestCancelled()); }
public Task ExecuteCommand(ExecuteCommandParams executeCommandParams) { if (provider != null) { return(provider.ExecuteCommand(executeCommandParams, param => ExecuteCommandInternal(param))); } return(ExecuteCommandInternal(executeCommandParams)); }
public override Task <object> ExecuteCommand(ExecuteCommandParams @params, CancellationToken token) { _disposableBag.ThrowIfDisposed(); Command(new CommandEventArgs { command = @params.command, arguments = @params.arguments }); return(Task.FromResult((object)null)); }
private IExecuteWorkspaceCommandHandler FindCommandHandler(ExecuteCommandParams request) { var commandName = request.Command; if (string.IsNullOrEmpty(commandName) || !_executeCommandHandlers.TryGetValue(commandName, out var executeCommandHandler)) { throw new ArgumentException(string.Format("Command name ({0}) is invalid", commandName)); } return(executeCommandHandler.Value); }
public override void Apply(Workspace workspace, CancellationToken cancellationToken) { Task.Run(async() => { var executeCommandParams = new ExecuteCommandParams { Command = _command.CommandIdentifier, Arguments = _command.Arguments }; await _lspClient.RequestAsync(Methods.WorkspaceExecuteCommand, executeCommandParams, cancellationToken).ConfigureAwait(false); }); }
public void SimpleTest(string expected) { var model = new ExecuteCommandParams { Arguments = new JArray(1, "2"), Command = "command" }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = new LspSerializer(ClientVersion.Lsp3).DeserializeObject <ExecuteCommandParams>(expected); deresult.Should().BeEquivalentTo(model, x => x.UsingStructuralRecordEquality()); }
public void SimpleTest(string expected) { var model = new ExecuteCommandParams() { Arguments = new ObjectContainer(1, "2"), Command = "command" }; var result = Fixture.SerializeObject(model); result.Should().Be(expected); var deresult = JsonConvert.DeserializeObject <ExecuteCommandParams>(expected); deresult.ShouldBeEquivalentTo(model); }
public Task ExecuteCommand(Command command) { if (!IsStarted) { return(Task.CompletedTask); } Log("Sending '{0}'.", Methods.WorkspaceExecuteCommandName); var message = new ExecuteCommandParams { Command = command.CommandIdentifier, Arguments = command.Arguments }; return(executeCommandProvider.ExecuteCommand(message)); }
/// <summary> /// Called from workspace/ExecuteCommand to attempt to locate and execute a command understood by this provider. /// </summary> public Result <dynamic, ResponseError> ExecuteCommand(ExecuteCommandParams commandParams, CancellationToken token) { // TODO: support cancellation foreach (var command in s_executeCommandInformation) { if (command.Command.Equals(commandParams.Command, StringComparison.Ordinal)) { return(command.ExecuteCommand(ProviderContext, commandParams.Arguments)); } } throw new InvalidOperationException($"Unknown command '{commandParams.Command}'. Supported commands are {GetSupportedCommands()}."); string GetSupportedCommands() { return(string.Join(", ", s_executeCommandInformation.Select(c => $"'{c.Command}'"))); } }
protected override Result <dynamic, ResponseError> ExecuteCommand(ExecuteCommandParams @params) { switch (@params.command) { case "reload_language_server": Proxy.Window.ShowMessage(new LanguageServer.Parameters.Window.ShowMessageParams { type = LanguageServer.Parameters.Window.MessageType.Info, message = "CheezLanguageServer was reset" }); return(ResetLanguageServer()); } return(Result <dynamic, ResponseError> .Error(new ResponseError { code = ErrorCodes.InvalidRequest, message = $"Unknown command {@params.command}" })); }
public async Task ExecutesHandler() { var executeCommandHandler = Substitute.For <IExecuteCommandHandler>(); var collection = new HandlerCollection { executeCommandHandler }; IRequestRouter mediator = new RequestRouter(collection, new Serializer()); var id = Guid.NewGuid().ToString(); var @params = new ExecuteCommandParams() { Command = "123" }; var request = new Request(id, "workspace/executeCommand", JObject.Parse(JsonConvert.SerializeObject(@params))); var response = await mediator.RouteRequest(request); await executeCommandHandler.Received(1).Handle(Arg.Any <ExecuteCommandParams>(), Arg.Any <CancellationToken>()); }
public async Task <Unit> Handle(ExecuteCommandParams request, CancellationToken cancellationToken) { Debug.Assert(request.Command == "omnisharp/executeCodeAction"); var data = request.Arguments[0].ToObject <CommandData>(_serializer.JsonSerializer); var omnisharpCaRequest = new RunCodeActionRequest { Identifier = data.Identifier, FileName = data.Uri.GetFileSystemPath(), Column = data.Range.Start.Character, Line = data.Range.Start.Line, Selection = Helpers.FromRange(data.Range), ApplyTextChanges = false, WantsTextChanges = true, WantsAllCodeActionOperations = true }; var omnisharpCaResponse = await _runActionHandler.Handle(omnisharpCaRequest); if (omnisharpCaResponse.Changes != null) { var edit = Helpers.ToWorkspaceEdit( omnisharpCaResponse.Changes, _server.ClientSettings.Capabilities.Workspace.WorkspaceEdit.Value, _documentVersions ); ; await _server.Workspace.ApplyWorkspaceEdit(new ApplyWorkspaceEditParams() { Label = data.Name, Edit = edit }, cancellationToken); // Do something with response? //if (response.Applied) } return(Unit.Value); }
public async Task ExecutesHandler() { var executeCommandHandler = Substitute.For <IExecuteCommandHandler>(); var mediator = Substitute.For <IMediator>(); var collection = new HandlerCollection { executeCommandHandler }; AutoSubstitute.Provide(collection); var router = AutoSubstitute.Resolve <RequestRouter>(); var id = Guid.NewGuid().ToString(); var @params = new ExecuteCommandParams() { Command = "123" }; var request = new Request(id, "workspace/executeCommand", JObject.Parse(JsonConvert.SerializeObject(@params))); var response = await router.RouteRequest(router.GetDescriptor(request), request, CancellationToken.None); await executeCommandHandler.Received(1).Handle(Arg.Any <ExecuteCommandParams>(), Arg.Any <CancellationToken>()); }
public Task <object> ExecuteWorkspaceCommandAsync(ExecuteCommandParams executeCommandParams, CancellationToken cancellationToken) => _requestHandlerProvider.ExecuteRequestAsync <ExecuteCommandParams, object>(Methods.WorkspaceExecuteCommandName, executeCommandParams, _clientCapabilities, _clientName, cancellationToken);
public object?OnExecuteCommand(JToken arg) { ExecuteCommandParams param = Utils.TryJTokenAs <ExecuteCommandParams>(arg); object?CastAndExecute <T>(Func <T, object?> command) where T : class =>
public virtual Task <object> ExecuteCommand(ExecuteCommandParams @params, CancellationToken cancellationToken) => Task.FromResult((object)null);
Handle(ExecuteCommandParams request, CancellationToken cancellationToken) { return(Task.FromResult(Unit.Value)); }
Task <object> ExecuteCommandInternal(ExecuteCommandParams executeCommandParams) { return(jsonRpc.InvokeWithParameterObjectAsync(Methods.WorkspaceExecuteCommand, executeCommandParams)); }
public Task <object> ExecuteWorkspaceCommandAsync(ExecuteCommandParams executeCommandParams, CancellationToken cancellationToken) { Contract.ThrowIfNull(_clientCapabilities, $"{nameof(InitializeAsync)} has not been called."); return(RequestDispatcher.ExecuteRequestAsync <ExecuteCommandParams, object>(Queue, Methods.WorkspaceExecuteCommandName, executeCommandParams, _clientCapabilities, ClientName, cancellationToken)); }
public override Task <Unit> Handle(ExecuteCommandParams request, CancellationToken cancellationToken) => _handler.Invoke(request, cancellationToken);
public abstract Task <Unit> Handle(ExecuteCommandParams request, CancellationToken cancellationToken);
public abstract RpcResult ExecuteCommand(ExecuteCommandParams args);
public static Task ExecuteCommand(this ILanguageClientWorkspace router, ExecuteCommandParams @params, CancellationToken cancellationToken = default) { return(router.SendRequest(WorkspaceNames.ExecuteCommand, @params, cancellationToken)); }
public override TextDocumentIdentifier?GetTextDocumentIdentifier( ExecuteCommandParams request ) => ((JToken)request.Arguments.First()).ToObject <TextDocumentIdentifier>();
/// <nodoc /> public Result <object, ResponseError> ExecuteCommand(ExecuteCommandParams executeParams, CancellationToken token) { return(m_executeCommandProvider.ExecuteCommand(executeParams, token)); }
public static Task ExecuteCommand(this ILanguageClientWorkspace router, ExecuteCommandParams @params) { return(router.SendRequest(WorkspaceNames.ExecuteCommand, @params)); }
public virtual TextDocumentIdentifier?GetTextDocumentIdentifier(ExecuteCommandParams request) => null;