more tests and more models using the converter

Author: TylerLeonhardt

src/Protocol/Models/ConfigurationItem.cs

@@ -1,11 +1,14 @@
 using System;
+using Newtonsoft.Json;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
+using OmniSharp.Extensions.LanguageServer.Protocol.Serialization.Converters;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
     public class ConfigurationItem
     {
         [Optional]
+        [JsonConverter(typeof(AbsoluteUriConverter))]
         public Uri ScopeUri { get; set; }
         [Optional]
         public string Section { get; set; }

src/Protocol/Models/DocumentLink.cs

@@ -2,8 +2,8 @@
 using MediatR;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
-using Newtonsoft.Json.Serialization;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
+using OmniSharp.Extensions.LanguageServer.Protocol.Serialization.Converters;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
@@ -23,6 +23,7 @@ public class DocumentLink : ICanBeResolved, IRequest<DocumentLink>
         /// The uri this link points to. If missing a resolve request is sent later.
         /// </summary>
         [Optional]
+        [JsonConverter(typeof(AbsoluteUriConverter))]
         public Uri Target { get; set; }
 
         /// </summary>

src/Protocol/Models/InitializeParams.cs

@@ -4,6 +4,7 @@
 using Newtonsoft.Json.Serialization;
 using OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
+using OmniSharp.Extensions.LanguageServer.Protocol.Serialization.Converters;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
@@ -34,6 +35,7 @@ public string RootPath
         /// folder is open. If both `rootPath` and `rootUri` are set
         /// `rootUri` wins.
         /// </summary>
+        [JsonConverter(typeof(AbsoluteUriConverter))]
         public Uri RootUri { get; set; }
 
         /// <summary>

src/Protocol/Models/LocationLink.cs

@@ -1,5 +1,7 @@
 using System;
+using Newtonsoft.Json;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
+using OmniSharp.Extensions.LanguageServer.Protocol.Serialization.Converters;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
@@ -17,6 +19,7 @@ public class LocationLink
         /// <summary>
         /// The target resource identifier of this link.
         /// </summary>
+        [JsonConverter(typeof(AbsoluteUriConverter))]
         public Uri TargetUri { get; set; }
 
         /// <summary>
@@ -32,4 +35,4 @@ public class LocationLink
         /// </summary>
         public Range TargetSelectionRange { get; set; }
     }
-}
+}

src/Protocol/Models/WorkspaceEdit.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
+using OmniSharp.Extensions.LanguageServer.Protocol.Serialization.Converters;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
 {
@@ -11,6 +13,7 @@ public class WorkspaceEdit
         /// Holds changes to existing resources.
         /// </summary>
         [Optional]
+        [JsonConverter(typeof(DictionaryUriConverter<Uri, IEnumerable<TextEdit>>))]
         public IDictionary<Uri, IEnumerable<TextEdit>> Changes { get; set; }
         /// <summary>
         /// An array of `TextDocumentEdit`s to express changes to n different text documents

src/Protocol/Serialization/Converters/AbsoluteUriConverter.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. 	// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 // #see https://github.com/NuGet/NuGet.Server
 using System;
+using System.Text;
 using Newtonsoft.Json;
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Serialization.Converters
@@ -46,26 +47,41 @@ public override void WriteJson(JsonWriter writer, Uri value, JsonSerializer seri
                 throw new JsonSerializationException("The value must be a URI.");
             }
 
-            if (!uriValue.IsAbsoluteUri)
+            writer.WriteValue(Convert(uriValue));
+        }
+
+        public static string Convert(Uri uri)
+        {
+            if (!uri.IsAbsoluteUri)
             {
                 throw new JsonSerializationException("The URI value must be an absolute Uri. Relative URI instances are not allowed.");
             }
 
-            if (uriValue.IsFile)
+            if (uri.IsFile)
             {
-                // Regular file paths
-                if (uriValue.HostNameType == UriHostNameType.Basic)
+                // First add the file scheme and ://
+                var builder = new StringBuilder(uri.Scheme)
+                    .Append("://");
+
+                // UNC file paths use the Host
+                if (uri.HostNameType != UriHostNameType.Basic)
                 {
-                    writer.WriteValue($"{uriValue.Scheme}://{uriValue.PathAndQuery}");
-                    return;
+                    builder.Append(uri.Host);
                 }
 
-                // UNC file paths
-                writer.WriteValue($"{uriValue.Scheme}://{uriValue.Host}{uriValue.PathAndQuery}");
-                return;
+                // Paths that start with a drive letter don't have a slash in the PathAndQuery
+                // but they need it in the final result.
+                if (uri.PathAndQuery[0] != '/')
+                {
+                    builder.Append('/');
+                }
+
+                // Lastly add the remaining parts of the URL
+                builder.Append(uri.PathAndQuery);
+                return builder.ToString();
             }
 
-            writer.WriteValue(uriValue.AbsoluteUri);
+            return uri.AbsoluteUri;
         }
     }
 }

src/Protocol/Serialization/Converters/DictionaryUriConverter.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace OmniSharp.Extensions.LanguageServer.Protocol.Serialization.Converters
+{
+    /// <summary>
+    /// This is necessary because Newtonsoft.Json creates <see cref="Uri"/> instances with
+    /// <see cref="UriKind.RelativeOrAbsolute"/> which treats UNC paths as relative. NuGet.Core uses
+    /// <see cref="UriKind.Absolute"/> which treats UNC paths as absolute. For more details, see:
+    /// https://github.com/JamesNK/Newtonsoft.Json/issues/2128
+    /// </summary><
+    class DictionaryUriConverter<TKey, TValue> :
+        JsonConverter<Dictionary<TKey, TValue>> where TKey : Uri
+    {
+        private readonly AbsoluteUriConverter _uriConverter = new AbsoluteUriConverter();
+
+        public override Dictionary<TKey, TValue> ReadJson(
+            JsonReader reader,
+            Type objectType,
+            Dictionary<TKey, TValue> existingValue,
+            bool hasExistingValue,
+            JsonSerializer serializer)
+        {
+            if (reader.TokenType != JsonToken.StartObject)
+            {
+                throw new JsonException();
+            }
+
+            Dictionary<TKey, TValue> value = new Dictionary<TKey, TValue>();
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonToken.EndObject)
+                {
+                    return value;
+                }
+
+                // Get the key.
+                if (reader.TokenType != JsonToken.PropertyName)
+                {
+                    throw new JsonException();
+                }
+
+                // Get the stringified Uri.
+                string propertyName = (string) reader.Value;
+                reader.Read();
+
+                Uri key = new Uri(propertyName, UriKind.Absolute);
+
+                // Get the value.
+                TValue v = serializer.Deserialize<TValue>(reader);
+
+                // Add to dictionary.
+                value.Add((TKey) key, v);
+            }
+
+            throw new JsonException();
+        }
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Dictionary<TKey, TValue> value,
+            JsonSerializer serializer)
+        {
+            writer.WriteStartObject();
+
+            foreach (KeyValuePair<TKey, TValue> kvp in value)
+            {
+                writer.WritePropertyName(AbsoluteUriConverter.Convert(kvp.Key));
+                serializer.Serialize(writer, kvp.Value);
+            }
+
+            writer.WriteEndObject();
+        }
+    }
+}

test/Lsp.Tests/Models/ApplyWorkspaceEditParamsTests.cs

@@ -52,7 +52,8 @@ public void NonStandardCharactersTest(string expected)
                 {
                     Changes = new Dictionary<Uri, IEnumerable<TextEdit>>() {
                         {
-                            new Uri("/abc/123/Mörkö.cs"), new [] {
+                            // Mörkö
+                            new Uri("file:///abc/123/M%C3%B6rk%C3%B6.cs"), new [] {
                                 new TextEdit() {
                                     NewText = "new text",
                                     Range = new Range(new Position(1, 1), new Position(2,2))

test/Lsp.Tests/Models/CodeActionParamsTests.cs

@@ -54,7 +54,8 @@ public void NonStandardCharactersTest(string expected)
                 },
                 Range = new Range(new Position(1, 1), new Position(2, 2)),
                 TextDocument = new TextDocumentIdentifier() {
-                    Uri = new Uri("/test/123/树.cs")
+                    // 树 - Chinese for tree
+                    Uri = new Uri("file:///test/123/%E6%A0%91.cs")
                 }
             };
             var result = Fixture.SerializeObject(model);

test/Lsp.Tests/Models/CodeLensParamsTests.cs

@@ -24,5 +24,20 @@ public void SimpleTest(string expected)
             var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<CodeLensParams>(expected);
             deresult.Should().BeEquivalentTo(model);
         }
+
+        [Theory, JsonFixture]
+        public void NonStandardCharactersTest(string expected)
+        {
+            var model = new CodeLensParams() {
+                // UNC path with Chinese character for tree.
+                TextDocument = new TextDocumentIdentifier(new Uri("\\\\abc\\123\\树.cs")),
+            };
+            var result = Fixture.SerializeObject(model);
+
+            result.Should().Be(expected);
+
+            var deresult = new Serializer(ClientVersion.Lsp3).DeserializeObject<CodeLensParams>(expected);
+            deresult.Should().BeEquivalentTo(model);
+        }
     }
 }