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;
