Merge pull request #23 from OmniSharp/handler-collection

Update handler collection to support many handlers of a type

Author: david-driscoll

sample/SampleServer/Program.cs

@@ -39,7 +39,8 @@ class TextDocumentHandler : ITextDocumentSyncHandler
         private readonly ILanguageServer _router;
 
         private readonly DocumentSelector _documentSelector = new DocumentSelector(
-            new DocumentFilter() {
+            new DocumentFilter()
+            {
                 Pattern = "**/*.csproj",
                 Language = "xml"
             }
@@ -52,19 +53,24 @@ public TextDocumentHandler(ILanguageServer router)
             _router = router;
         }
 
-        public TextDocumentSyncOptions Options { get; } = new TextDocumentSyncOptions() {
+        public TextDocumentSyncOptions Options { get; } = new TextDocumentSyncOptions()
+        {
             WillSaveWaitUntil = false,
             WillSave = true,
             Change = TextDocumentSyncKind.Full,
-            Save = new SaveOptions() {
+            Save = new SaveOptions()
+            {
                 IncludeText = true
             },
             OpenClose = true
         };
 
+        public string Key => (string)_documentSelector;
+
         public Task Handle(DidChangeTextDocumentParams notification)
         {
-            _router.LogMessage(new LogMessageParams() {
+            _router.LogMessage(new LogMessageParams()
+            {
                 Type = MessageType.Log,
                 Message = "Hello World!!!!"
             });
@@ -73,7 +79,8 @@ public Task Handle(DidChangeTextDocumentParams notification)
 
         TextDocumentChangeRegistrationOptions IRegistration<TextDocumentChangeRegistrationOptions>.GetRegistrationOptions()
         {
-            return new TextDocumentChangeRegistrationOptions() {
+            return new TextDocumentChangeRegistrationOptions()
+            {
                 DocumentSelector = _documentSelector,
                 SyncKind = Options.Change
             };
@@ -86,15 +93,17 @@ public void SetCapability(SynchronizationCapability capability)
 
         public async Task Handle(DidOpenTextDocumentParams notification)
         {
-            _router.LogMessage(new LogMessageParams() {
+            _router.LogMessage(new LogMessageParams()
+            {
                 Type = MessageType.Log,
                 Message = "Hello World!!!!"
             });
         }
 
         TextDocumentRegistrationOptions IRegistration<TextDocumentRegistrationOptions>.GetRegistrationOptions()
         {
-            return new TextDocumentRegistrationOptions() {
+            return new TextDocumentRegistrationOptions()
+            {
                 DocumentSelector = _documentSelector,
             };
         }
@@ -111,7 +120,8 @@ public Task Handle(DidSaveTextDocumentParams notification)
 
         TextDocumentSaveRegistrationOptions IRegistration<TextDocumentSaveRegistrationOptions>.GetRegistrationOptions()
         {
-            return new TextDocumentSaveRegistrationOptions() {
+            return new TextDocumentSaveRegistrationOptions()
+            {
                 DocumentSelector = _documentSelector,
                 IncludeText = Options.Save.IncludeText
             };

src/JsonRpc/IJsonRpcHandler.cs

@@ -3,5 +3,8 @@
     /// <summary>
     /// A simple marker interface to use for storing handlings (which will be cast out later)
     /// </summary>
-    public interface IJsonRpcHandler { }
-}
+    public interface IJsonRpcHandler
+    {
+        string Key { get; }
+    }
+}

src/Lsp/Abstractions/IHandlerCollection.cs

@@ -6,9 +6,7 @@ namespace OmniSharp.Extensions.LanguageServer.Abstractions
 {
     interface IHandlerCollection : IEnumerable<ILspHandlerDescriptor>
     {
-        IDisposable Add(IJsonRpcHandler handler);
-
-        IEnumerable<ILspHandlerDescriptor> Get(string method);
-        IEnumerable<ILspHandlerDescriptor> Get(IJsonRpcHandler handler);
+        IDisposable Add(params IJsonRpcHandler[] handlers);
+        IDisposable Add(IEnumerable<IJsonRpcHandler> handlers);
     }
-}
+}

src/Lsp/HandlerCollection.cs

@@ -22,51 +22,45 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
-        public IDisposable Add(IJsonRpcHandler handler)
+        public IDisposable Add(params IJsonRpcHandler[] handlers)
         {
-            //var type = handler.GetType();
+            return Add(handlers.AsEnumerable());
+        }
 
-            var handlers = new List<HandlerDescriptor>();
-            foreach (var implementedInterface in handler.GetType().GetTypeInfo()
-                .ImplementedInterfaces
-                .Where(x => !string.IsNullOrWhiteSpace(LspHelper.GetMethodName(x))))
+        public IDisposable Add(IEnumerable<IJsonRpcHandler> handlers)
+        {
+            var descriptors = new List<HandlerDescriptor>();
+            foreach (var handler in handlers)
             {
-                var @interface = GetHandlerInterface(implementedInterface);
-                var registration = UnwrapGenericType(typeof(IRegistration<>), implementedInterface);
-                var capability = UnwrapGenericType(typeof(ICapability<>), implementedInterface);
-
-                Type @params = null;
-                if (@interface.GetTypeInfo().IsGenericType)
+                foreach (var implementedInterface in handler.GetType().GetTypeInfo()
+                    .ImplementedInterfaces
+                    .Where(x => !string.IsNullOrWhiteSpace(LspHelper.GetMethodName(x))))
                 {
-                    @params = @interface.GetTypeInfo().GetGenericArguments()[0];
+                    var @interface = GetHandlerInterface(implementedInterface);
+                    var registration = UnwrapGenericType(typeof(IRegistration<>), implementedInterface);
+                    var capability = UnwrapGenericType(typeof(ICapability<>), implementedInterface);
+
+                    Type @params = null;
+                    if (@interface.GetTypeInfo().IsGenericType)
+                    {
+                        @params = @interface.GetTypeInfo().GetGenericArguments()[0];
+                    }
+
+                    var h = new HandlerDescriptor(
+                        LspHelper.GetMethodName(implementedInterface),
+                        handler,
+                        @interface,
+                        @params,
+                        registration,
+                        capability,
+                        () => _handlers.RemoveWhere(instance => instance.Handler == handler));
+
+                    descriptors.Add(h);
+                    _handlers.Add(h);
                 }
-
-                var h = new HandlerDescriptor(
-                    LspHelper.GetMethodName(implementedInterface),
-                    handler,
-                    @interface,
-                    @params,
-                    registration,
-                    capability,
-                    () => _handlers.RemoveWhere(instance => instance.Handler == handler));
-
-                handlers.Add(h);
             }
 
-            foreach (var a in handlers)
-                _handlers.Add(a);
-
-            return new ImutableDisposable(handlers);
-        }
-
-        public IEnumerable<ILspHandlerDescriptor> Get(IJsonRpcHandler handler)
-        {
-            return _handlers.Where(instance => instance.Handler == handler);
-        }
-
-        public IEnumerable<ILspHandlerDescriptor> Get(string method)
-        {
-            return _handlers.Where(instance => instance.Method == method);
+            return new ImutableDisposable(descriptors);
         }
 
         private static readonly Type[] HandlerTypes = { typeof(INotificationHandler), typeof(INotificationHandler<>), typeof(IRequestHandler<>), typeof(IRequestHandler<,>), };
@@ -96,4 +90,4 @@ private Type UnwrapGenericType(Type genericType, Type type)
                 ?.GetGenericArguments()[0];
         }
     }
-}
+}

src/Lsp/HandlerDescriptor.cs

@@ -94,14 +94,15 @@ public override bool Equals(object obj)
         {
             if (obj is HandlerDescriptor handler)
             {
-                return handler.HandlerType == HandlerType;
+                return handler.HandlerType == HandlerType && handler.Handler.Key == Handler.Key;
             }
             return false;
         }
 
         public override int GetHashCode()
         {
-            return HandlerType.GetHashCode();
+            if (string.IsNullOrWhiteSpace(Handler.Key)) return HandlerType.GetHashCode();
+            return Tuple.Create(HandlerType, Handler.Key).GetHashCode();
         }
     }
-}
+}

src/Lsp/Handlers/CancelRequestHandler.cs

@@ -13,6 +13,8 @@ internal CancelRequestHandler(LspRequestRouter requestRouter)
             _requestRouter = requestRouter;
         }
 
+        public string Key => nameof(ICancelRequestHandler);
+
         public Task Handle(CancelParams notification)
         {
             _requestRouter.CancelRequest(notification.Id);

src/Lsp/Handlers/ExitHandler.cs

@@ -12,6 +12,8 @@ public ExitHandler(ShutdownHandler shutdownHandler)
             _shutdownHandler = shutdownHandler;
         }
 
+        public string Key => nameof(IExitHandler);
+
         public Task Handle()
         {
             Exit?.Invoke(_shutdownHandler.ShutdownRequested ? 0 : 1);

src/Lsp/Handlers/ShutdownHandler.cs

@@ -6,6 +6,8 @@ namespace OmniSharp.Extensions.LanguageServer.Handlers
 {
     public class ShutdownHandler : IShutdownHandler, IAwaitableTermination
     {
+        public string Key => nameof(IShutdownHandler);
+
         public Task Handle()
         {
             ShutdownRequested = true;

src/Lsp/LanguageServer.cs

@@ -63,21 +63,35 @@ IRequestProcessIdentifier requestProcessIdentifier
         public InitializeParams Client { get; private set; }
         public InitializeResult Server { get; private set; }
 
+        public string Key => nameof(ILanguageServer);
+
         public IDisposable AddHandler(IJsonRpcHandler handler)
         {
-            var handlerDisposable = _collection.Add(handler);
+            return AddHandler(handler);
+        }
+
+        public IDisposable AddHandlers(params IJsonRpcHandler[] handlers)
+        {
+            return AddHandlers(handlers.AsEnumerable());
+        }
+
+        public IDisposable AddHandlers(IEnumerable<IJsonRpcHandler> handlers)
+        {
+            var handlerDisposable = _collection.Add(handlers);
 
             return new ImutableDisposable(
                 handlerDisposable,
-                new Disposable(() => {
-                    var handlers = _collection
-                        .Where(x => x.Handler == handler)
+                new Disposable(() =>
+                {
+                    var foundItems = handlers
+                    .SelectMany(handler => _collection
+                        .Where(x => handler == x.Handler)
                         .Where(x => x.AllowsDynamicRegistration)
                         .Select(x => x.Registration)
-                        .Where(x => x != null)
-                        .ToArray();
+                        .Where(x => x != null))
+                    .ToArray();
 
-                    Task.Run(() => this.UnregisterCapability(new UnregistrationParams() { Unregisterations = handlers }));
+                    Task.Run(() => this.UnregisterCapability(new UnregistrationParams() { Unregisterations = foundItems }));
                 }));
         }
 
@@ -115,7 +129,8 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
                 }
             }
 
-            var serverCapabilities = new ServerCapabilities() {
+            var serverCapabilities = new ServerCapabilities()
+            {
                 CodeActionProvider = HasHandler<ICodeActionHandler>(),
                 CodeLensProvider = GetOptions<ICodeLensOptions, CodeLensOptions>(CodeLensOptions.Of),
                 CompletionProvider = GetOptions<ICompletionOptions, CompletionOptions>(CompletionOptions.Of),
@@ -145,7 +160,8 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
             }
             else
             {
-                serverCapabilities.TextDocumentSync = textSyncHandler?.Options ?? new TextDocumentSyncOptions() {
+                serverCapabilities.TextDocumentSync = textSyncHandler?.Options ?? new TextDocumentSyncOptions()
+                {
                     Change = TextDocumentSyncKind.None,
                     OpenClose = false,
                     Save = new SaveOptions() { IncludeText = false },

src/Lsp/Models/DocumentFilter.cs

@@ -1,4 +1,6 @@
-using Minimatch;
+using System.Collections.Generic;
+using System.Text;
+using Minimatch;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 using OmniSharp.Extensions.LanguageServer.Protocol.Document;
@@ -39,7 +41,8 @@ public class DocumentFilter
         public string Pattern
         {
             get => _pattern;
-            set {
+            set
+            {
                 _pattern = value;
                 _minimatcher = new Minimatcher(value, new Options() { MatchBase = true });
             }
@@ -54,6 +57,24 @@ public string Pattern
         private string _pattern;
         private Minimatcher _minimatcher;
 
+        public static explicit operator string(DocumentFilter documentFilter)
+        {
+            var items = new List<string>();
+            if (documentFilter.HasLanguage)
+            {
+                items.Add(documentFilter.Language);
+            }
+            if (documentFilter.HasScheme)
+            {
+                items.Add(documentFilter.Scheme);
+            }
+            if (documentFilter.HasPattern)
+            {
+                items.Add(documentFilter.Pattern);
+            }
+            return $"[{string.Join(", ", items)}]";
+        }
+
         public bool IsMatch(TextDocumentAttributes attributes)
         {
             if (HasLanguage && HasPattern && HasScheme)
@@ -88,4 +109,4 @@ public bool IsMatch(TextDocumentAttributes attributes)
             return false;
         }
     }
-}
+}

src/Lsp/Models/DocumentSelector.cs

@@ -38,9 +38,14 @@ public static implicit operator DocumentSelector(List<DocumentFilter> items)
             return new DocumentSelector(items);
         }
 
+        public static explicit operator string(DocumentSelector documentSelector)
+        {
+            return string.Join(", ", documentSelector.Select(x => (string)x));
+        }
+
         public bool IsMatch(TextDocumentAttributes attributes)
         {
             return this.Any(z => z.IsMatch(attributes));
         }
     }
-}
+}