Added support for more generic uris (#239)

* Added support for more generic uris

* Reacted to feedback

Author: david-driscoll

src/Protocol/DocumentUri.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
+using System.Text.RegularExpressions;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 using static System.IO.Path;
 
@@ -14,17 +15,23 @@ namespace OmniSharp.Extensions.LanguageServer.Protocol
     /// <remarks>This exists because of some non-standard serialization in vscode around uris and .NET's behavior when deserializing those uris</remarks>
     public class DocumentUri : IEquatable<DocumentUri>
     {
+        private static readonly Regex WindowsPath =
+            new Regex(@"^\w(?:\:|%3a)[\\|\/]", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        private readonly string _delimiter = SchemeDelimiter;
+
         /// <summary>
         /// Create a new document uri
         /// </summary>
         /// <param name="url"></param>
         public DocumentUri(string url)
         {
+            var uncMatch = false;
             var delimiterIndex = url.IndexOf(SchemeDelimiter, StringComparison.Ordinal);
-            if (delimiterIndex == -1)
+            if ((uncMatch = url.StartsWith(@"\\")) || (url.StartsWith("/")) || (WindowsPath.IsMatch(url)))
             {
                 // Unc path
-                if (url.StartsWith("\\\\"))
+                if (uncMatch)
                 {
                     var authorityEndIndex = url.IndexOf('\\', 2);
                     Authority = url.Substring(2, authorityEndIndex - 2);
@@ -42,25 +49,36 @@ public DocumentUri(string url)
                 Query = string.Empty;
                 Fragment = string.Empty;
                 Path = Uri.UnescapeDataString(url.StartsWith("/") ? url : "/" + url);
-
                 return;
             }
 
-            Scheme = url.Substring(0, delimiterIndex);
-
-            var authorityIndex = url.IndexOf('/', delimiterIndex + SchemeDelimiter.Length);
-            Authority = url.Substring(delimiterIndex + SchemeDelimiter.Length,
-                authorityIndex - (delimiterIndex + SchemeDelimiter.Length));
-
-            // this is a possible windows path without the proper tripple slash
-            // file://c:/some/path.file.cs
-            // We need deal with this case.
-            if (Authority.IndexOf(':') > -1 || Authority.IndexOf("%3a", StringComparison.OrdinalIgnoreCase) > -1)
+            int authorityIndex;
+            if (delimiterIndex == -1)
             {
+                delimiterIndex = url.IndexOf(':');
+                authorityIndex = delimiterIndex + 1;
                 Authority = string.Empty;
-                authorityIndex = delimiterIndex + SchemeDelimiter.Length;
+                _delimiter = ":";
+            }
+            else
+            {
+                var delimiterSize = SchemeDelimiter.Length;
+                authorityIndex = url.IndexOf('/', delimiterIndex + delimiterSize);
+                Authority = url.Substring(delimiterIndex + delimiterSize,
+                    authorityIndex - (delimiterIndex + delimiterSize));
+
+                // this is a possible windows path without the proper tripple slash
+                // file://c:/some/path.file.cs
+                // We need deal with this case.
+                if (Authority.IndexOf(':') > -1 || Authority.IndexOf("%3a", StringComparison.OrdinalIgnoreCase) > -1)
+                {
+                    Authority = string.Empty;
+                    authorityIndex = delimiterIndex + delimiterSize;
+                }
             }
 
+            Scheme = url.Substring(0, delimiterIndex);
+
             var fragmentIndex = url.IndexOf('#');
             if (fragmentIndex > -1)
             {
@@ -152,8 +170,16 @@ public Uri ToUri()
         /// </summary>
         /// <returns></returns>
         /// <remarks>This will not a uri encode asian and cyrillic characters</remarks>
-        public override string ToString() =>
-            $"{Scheme}{SchemeDelimiter}{Authority}{Path}{(string.IsNullOrWhiteSpace(Query) ? "" : "?" + Query)}{(string.IsNullOrWhiteSpace(Fragment) ? "" : "#" + Fragment)}";
+        public override string ToString()
+        {
+            if (string.IsNullOrWhiteSpace(_stringValue))
+            {
+                _stringValue =
+                    $"{Scheme}{_delimiter}{Authority}{Path}{(string.IsNullOrWhiteSpace(Query) ? "" : "?" + Query)}{(string.IsNullOrWhiteSpace(Fragment) ? "" : "#" + Fragment)}";
+            }
+
+            return _stringValue;
+        }
 
         /// <summary>
         /// Gets the file system path prefixed with / for unix platforms
@@ -166,7 +192,7 @@ public string GetFileSystemPath()
             if (Path.IndexOf(':') == -1 && !(Scheme == UriSchemeFile && !string.IsNullOrWhiteSpace(Authority)))
                 return Path;
             if (!string.IsNullOrWhiteSpace(Authority))
-                return $"\\\\{Authority}{Path}".Replace('/', '\\');
+                return $@"\\{Authority}{Path}".Replace('/', '\\');
             return Path.TrimStart('/').Replace('/', '\\');
         }
 
@@ -299,6 +325,8 @@ public static DocumentUri From(Uri uri)
         /// </summary>
         public static readonly string SchemeDelimiter = Uri.SchemeDelimiter;
 
+        private string _stringValue;
+
         /// <summary>
         ///     Get the local file-system path for the specified document URI.
         /// </summary>

test/Lsp.Tests/DocumentUriTests.cs

@@ -219,6 +219,52 @@ public override IEnumerator<object[]> GetEnumerator()
             }
         }
 
+        [Theory]
+        [ClassData(typeof(ResourceStringUris))]
+        public void Should_Handle_Resource_String_Uris(string uri, string expected)
+        {
+            _testOutputHelper.WriteLine($"Given: {uri}");
+            _testOutputHelper.WriteLine($"Expected: {expected}");
+            new DocumentUri(uri).ToString().Should().Be(expected);
+        }
+
+        public class ResourceStringUris : IEnumerable<object[]>
+        {
+            private const string ResourcePath = "untitled:Untitled-1";
+            private const string ResourcePathWithPath = "untitled:Untitled-1/some/path";
+
+            protected IEnumerable<(string, string)> AddPaths(params string[] paths)
+            {
+                foreach (var path in paths)
+                {
+                    yield return (path.Replace("c:", "c%3A"), path);
+                    yield return (path.Replace("c:", "c%3a"), path);
+                    yield return (path, path);
+                }
+            }
+
+            public IEnumerator<object[]> GetEnumerator()
+            {
+                foreach (var (source, destination) in AddPaths(
+                    ResourcePath,
+                    ResourcePath.Replace("Untitled", "Пространствоимен"),
+                    ResourcePath.Replace("Untitled", "汉字漢字"),
+                    ResourcePath.Replace("Untitled", "のはでした"),
+                    ResourcePath.Replace("Untitled", "コンサート"),
+                    ResourcePathWithPath,
+                    ResourcePathWithPath.Replace("Untitled", "Пространствоимен"),
+                    ResourcePathWithPath.Replace("Untitled", "汉字漢字"),
+                    ResourcePathWithPath.Replace("Untitled", "のはでした"),
+                    ResourcePathWithPath.Replace("Untitled", "コンサート")
+                ))
+                {
+                    yield return new object[] {source, destination};
+                }
+            }
+
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+
         [Theory]
         [ClassData(typeof(WindowsPathUris))]
         public void Should_Handle_Windows_Uris(Uri uri, DocumentUri expected)
@@ -535,11 +581,13 @@ public abstract class BaseSingle : IEnumerable<object[]>
         {
             protected IEnumerable<(string, DocumentUri)> AddPaths(params string[] paths)
             {
-                foreach (var path in paths)
+                foreach (var expectedPath in paths)
                 {
-                    yield return (path.Replace("c:", "c%3A"), path);
-                    yield return (path.Replace("c:", "c%3a"), path);
-                    yield return (path, path);
+                    if (expectedPath.Replace("c:", "c%3A") != expectedPath)
+                        yield return (expectedPath.Replace("c:", "c%3A"), expectedPath);
+                    if (expectedPath.Replace("c:", "c%3a") != expectedPath)
+                        yield return (expectedPath.Replace("c:", "c%3a"), expectedPath);
+                    yield return (expectedPath, expectedPath);
                 }
             }