Merge pull request #128 from OmniSharp/feature/delegate-all-the-things

Added delegate handlers for all base interfaces +semver:major

Author: david-driscoll

src/Client/Protocol/LspConnection.cs

@@ -387,7 +387,7 @@ public void SendNotification(string method, object notification)
                 {
                     _outgoing.TryAdd(new ClientMessage
                     {
-                        Method = GeneralNames.CancelRequest,
+                        Method = JsonRpcNames.CancelRequest,
                         Params = new JObject(
                             new JProperty("id", requestId)
                         )
@@ -450,7 +450,7 @@ public void SendNotification(string method, object notification)
                 {
                     _outgoing.TryAdd(new ClientMessage
                     {
-                        Method = GeneralNames.CancelRequest,
+                        Method = JsonRpcNames.CancelRequest,
                         Params = new JObject(
                             new JProperty("id", requestId)
                         )
@@ -817,7 +817,7 @@ async Task DispatchLoop()
                     if (message.Id != null)
                     {
                         // Request.
-                        if (message.Method == GeneralNames.CancelRequest)
+                        if (message.Method == JsonRpcNames.CancelRequest)
                             CancelRequest(message);
                         else
                             DispatchRequest(message);

src/Protocol/Models/CancelParams.cs src/JsonRpc/CancelParams.cssrc/Protocol/Models/CancelParams.cs renamed to src/JsonRpc/CancelParams.cs

@@ -2,7 +2,7 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 
-namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
+namespace OmniSharp.Extensions.JsonRpc
 {
     public class CancelParams : IRequest
     {

src/JsonRpc/CancelRequestExtensions.cs

@@ -0,0 +1,24 @@
+using OmniSharp.Extensions.JsonRpc;
+
+// ReSharper disable CheckNamespace
+
+namespace OmniSharp.Extensions.JsonRpc
+{
+    public static class CancelRequestExtensions
+    {
+        public static void CancelRequest(this IResponseRouter mediator, CancelParams @params)
+        {
+            mediator.SendNotification(JsonRpcNames.CancelRequest, @params);
+        }
+
+        public static void CancelRequest(this IResponseRouter mediator, string id)
+        {
+            mediator.SendNotification(JsonRpcNames.CancelRequest, new CancelParams() { Id = id });
+        }
+
+        public static void CancelRequest(this IResponseRouter mediator, long id)
+        {
+            mediator.SendNotification(JsonRpcNames.CancelRequest, new CancelParams() { Id = id });
+        }
+    }
+}

…/Server/Handlers/CancelRequestHandler.cs src/JsonRpc/CancelRequestHandler.cssrc/Server/Handlers/CancelRequestHandler.cs renamed to src/JsonRpc/CancelRequestHandler.cs src/Server/Handlers/CancelRequestHandler.cs renamed to src/JsonRpc/CancelRequestHandler.cs

@@ -2,16 +2,14 @@
 using System.Threading.Tasks;
 using OmniSharp.Extensions.Embedded.MediatR;
 using OmniSharp.Extensions.JsonRpc;
-using OmniSharp.Extensions.LanguageServer.Protocol;
-using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 
-namespace OmniSharp.Extensions.LanguageServer.Server.Handlers
+namespace OmniSharp.Extensions.JsonRpc
 {
-    public class CancelRequestHandler : ICancelRequestHandler
+    public class CancelRequestHandler<TDescriptor> : ICancelRequestHandler
     {
-        private readonly ILspRequestRouter _requestRouter;
+        private readonly IRequestRouter<TDescriptor> _requestRouter;
 
-        internal CancelRequestHandler(ILspRequestRouter requestRouter)
+        public CancelRequestHandler(IRequestRouter<TDescriptor> requestRouter)
         {
             _requestRouter = requestRouter;
         }

src/JsonRpc/Connection.cs

@@ -7,14 +7,14 @@ namespace OmniSharp.Extensions.JsonRpc
     public class Connection : IDisposable
     {
         private readonly IInputHandler _inputHandler;
-        private readonly IRequestRouter _requestRouter;
+        private readonly IRequestRouter<IHandlerDescriptor> _requestRouter;
 
         public Connection(
             Stream input,
             IOutputHandler outputHandler,
             IReciever reciever,
             IRequestProcessIdentifier requestProcessIdentifier,
-            IRequestRouter requestRouter,
+            IRequestRouter<IHandlerDescriptor> requestRouter,
             IResponseRouter responseRouter,
             ILoggerFactory loggerFactory,
             ISerializer serializer)

src/JsonRpc/DelegatingNotification.cs

@@ -0,0 +1,14 @@
+using OmniSharp.Extensions.Embedded.MediatR;
+
+namespace OmniSharp.Extensions.JsonRpc
+{
+    public class DelegatingNotification<T> : IRequest
+    {
+        public DelegatingNotification(T value)
+        {
+            Value = value;
+        }
+
+        public T Value { get; }
+    }
+}

src/JsonRpc/DelegatingNotificationHandler.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using OmniSharp.Extensions.Embedded.MediatR;
+
+namespace OmniSharp.Extensions.JsonRpc
+{
+    public class DelegatingNotificationHandler<T> : IJsonRpcNotificationHandler<DelegatingNotification<T>>
+    {
+        private readonly Action<T> _handler;
+        private readonly ISerializer _serializer;
+
+        public DelegatingNotificationHandler(ISerializer serializer, Action<T> handler)
+        {
+            _handler = handler;
+            _serializer = serializer;
+        }
+
+        public Task<Unit> Handle(DelegatingNotification<T> request, CancellationToken cancellationToken)
+        {
+            _handler.Invoke(request.Value);
+            return Unit.Task;
+        }
+    }
+
+    public class DelegatingNotificationHandler : IJsonRpcNotificationHandler<DelegatingNotification<object>>
+    {
+        private readonly Action _handler;
+        private readonly ISerializer _serializer;
+
+        public DelegatingNotificationHandler(ISerializer serializer, Action handler)
+        {
+            _handler = handler;
+            _serializer = serializer;
+        }
+
+        public Task<Unit> Handle(DelegatingNotification<object> request, CancellationToken cancellationToken)
+        {
+            _handler.Invoke();
+            return Unit.Task;
+        }
+    }
+}

src/JsonRpc/DelegatingRequest.cs

@@ -0,0 +1,15 @@
+using Newtonsoft.Json.Linq;
+using OmniSharp.Extensions.Embedded.MediatR;
+
+namespace OmniSharp.Extensions.JsonRpc
+{
+    public class DelegatingRequest<T> : IRequest<JToken>, IRequest
+    {
+        public DelegatingRequest(T value)
+        {
+            Value = value;
+        }
+
+        public T Value { get; }
+    }
+}

src/JsonRpc/DelegatingRequestHandler.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+
+namespace OmniSharp.Extensions.JsonRpc
+{
+    public class DelegatingRequestHandler<T, TResponse> : IJsonRpcRequestHandler<DelegatingRequest<T>, JToken>
+    {
+        private readonly Func<T, Task<TResponse>> _handler;
+        private readonly ISerializer _serializer;
+
+        public DelegatingRequestHandler(ISerializer serializer, Func<T, Task<TResponse>> handler)
+        {
+            _handler = handler;
+            _serializer = serializer;
+        }
+
+        public async Task<JToken> Handle(DelegatingRequest<T> request, CancellationToken cancellationToken)
+        {
+            var response = await _handler.Invoke(request.Value);
+            return JToken.FromObject(response, _serializer.JsonSerializer);
+        }
+    }
+
+    public class DelegatingRequestHandler<T> : IJsonRpcRequestHandler<DelegatingRequest<T>, JToken>
+    {
+        private readonly Func<T, Task> _handler;
+        private readonly ISerializer _serializer;
+
+        public DelegatingRequestHandler(ISerializer serializer, Func<T, Task> handler)
+        {
+            _handler = handler;
+            _serializer = serializer;
+        }
+
+        public async Task<JToken> Handle(DelegatingRequest<T> request, CancellationToken cancellationToken)
+        {
+            await _handler.Invoke(request.Value);
+            return JValue.CreateNull();
+        }
+    }
+}

src/JsonRpc/HandlerCollection.cs

@@ -27,6 +27,16 @@ public HandlerInstance(string method, IJsonRpcHandler handler, Type handlerInter
                 HandlerType = handlerInterface;
                 Params = @params;
                 Response = response;
+                HasReturnType = HandlerType.GetInterfaces().Any(@interface =>
+                    @interface.IsGenericType &&
+                    typeof(IRequestHandler<,>).IsAssignableFrom(@interface.GetGenericTypeDefinition())
+                );
+
+                IsDelegatingHandler = @params?.IsGenericType == true &&
+                    (
+                        typeof(DelegatingRequest<>).IsAssignableFrom(@params.GetGenericTypeDefinition()) ||
+                        typeof(DelegatingNotification<>).IsAssignableFrom(@params.GetGenericTypeDefinition())
+                    );
             }
 
             public IJsonRpcHandler Handler { get; }
@@ -35,6 +45,8 @@ public HandlerInstance(string method, IJsonRpcHandler handler, Type handlerInter
             public string Method { get; }
             public Type Params { get; }
             public Type Response { get; }
+            public bool HasReturnType { get; }
+            public bool IsDelegatingHandler { get; }
 
             public void Dispose()
             {
@@ -61,7 +73,8 @@ private void Remove(IJsonRpcHandler handler)
         public IDisposable Add(params IJsonRpcHandler[] handlers)
         {
             var cd = new CompositeDisposable();
-            foreach (var handler in handlers){
+            foreach (var handler in handlers)
+            {
                 cd.Add(Add(GetMethodName(handler.GetType()), handler));
             }
             return cd;
@@ -80,7 +93,9 @@ public IDisposable Add(string method, IJsonRpcHandler handler)
                 var requestInterface = @params.GetInterfaces()
                     .FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IRequest<>));
                 if (requestInterface != null)
+                {
                     response = requestInterface.GetGenericArguments()[0];
+                }
             }
 
             var h = new HandlerInstance(method, handler, @interface, @params, response, () => Remove(handler));